d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
257 Commits
25 Branches
6 Tags
221 MiB
Tree: 3b475331f2
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3b475331f2'
${ noResults }
source-engine/utils/hlfaceposer/phonemeeditor.cpp

8800 lines
190 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include <Assert.h>
#include <stdio.h>
#include <math.h>
#include "hlfaceposer.h"
#include "PhonemeEditor.h"
#include "PhonemeEditorColors.h"
#include "snd_audio_source.h"
#include "snd_wave_source.h"
#include "ifaceposersound.h"
#include "choreowidgetdrawhelper.h"
#include "mxBitmapButton.h"
#include "phonemeproperties.h"
#include "tier2/riff.h"
#include "StudioModel.h"
#include "expressions.h"
#include "expclass.h"
#include "InputProperties.h"
#include "phonemeextractor/PhonemeExtractor.h"
#include "PhonemeConverter.h"
#include "choreoevent.h"
#include "choreoscene.h"
#include "ChoreoView.h"
#include "filesystem.h"
#include "UtlBuffer.h"
#include "AudioWaveOutput.h"
#include "StudioModel.h"
#include "viewerSettings.h"
#include "ControlPanel.h"
#include "faceposer_models.h"
#include "tier1/strtools.h"
#include "tabwindow.h"
#include "MatSysWin.h"
#include "soundflags.h"
#include "mdlviewer.h"
#include "filesystem_init.h"
#include "WaveBrowser.h"
#include "tier2/p4helpers.h"
#include "vstdlib/random.h"
extern IUniformRandomStream *random;
float SnapTime( float input, float granularity );
#define MODE_TAB_OFFSET 20
// 10x magnification
#define MAX_TIME_ZOOM 1000
// 10% per step
#define TIME_ZOOM_STEP 2
#define SCRUBBER_HEIGHT 15
#define TAG_TOP ( 25 + SCRUBBER_HEIGHT )
#define TAG_BOTTOM ( TAG_TOP + 20 )
#define PLENTY_OF_TIME 99999.9
#define MINIMUM_WORD_GAP 0.02f
#define MINIMUM_PHONEME_GAP 0.01f
#define DEFAULT_WORD_LENGTH 0.25f
#define DEFAULT_PHONEME_LENGTH 0.1f
#define WORD_DATA_EXTENSION ".txt"
// #define ITEM_GAP_EPSILON 0.0025f
struct PhonemeEditorColor
{
int color_number; // For readability
int mode_number; // -1 for all
COLORREF root_color;
COLORREF gray_color; // if mode is wrong...
};
static PhonemeEditorColor g_PEColors[ NUM_COLORS ] =
{
{ COLOR_PHONEME_BACKGROUND, -1, RGB( 240, 240, 220 ) },
{ COLOR_PHONEME_TEXT, -1, RGB( 63, 63, 63 ) },
{ COLOR_PHONEME_LIGHTTEXT, 0, RGB( 180, 180, 120 ) },
{ COLOR_PHONEME_PLAYBACKTICK, 0, RGB( 255, 0, 0 ) },
{ COLOR_PHONEME_WAVDATA, 0, RGB( 128, 31, 63 ) },
{ COLOR_PHONEME_TIMELINE, 0, RGB( 31, 31, 127 ) },
{ COLOR_PHONEME_TIMELINE_MAJORTICK, 0, RGB( 200, 200, 255 ) },
{ COLOR_PHONEME_TIMELINE_MINORTICK, 0, RGB( 210, 210, 240 ) },
{ COLOR_PHONEME_EXTRACTION_RESULT_FAIL, 0, RGB( 180, 180, 0 ) },
{ COLOR_PHONEME_EXTRACTION_RESULT_SUCCESS, 0, RGB( 100, 180, 100 ) },
{ COLOR_PHONEME_EXTRACTION_RESULT_ERROR, 0, RGB( 255, 31, 31 ) },
{ COLOR_PHONEME_EXTRACTION_RESULT_OTHER, 0, RGB( 63, 63, 63 ) },
{ COLOR_PHONEME_TAG_BORDER, 0, RGB( 160, 100, 100 ) },
{ COLOR_PHONEME_TAG_BORDER_SELECTED, 0, RGB( 255, 40, 60 ) },
{ COLOR_PHONEME_TAG_FILLER_NORMAL, 0, RGB( 210, 210, 190 ) },
{ COLOR_PHONEME_TAG_SELECTED, 0, RGB( 200, 130, 130 ) },
{ COLOR_PHONEME_TAG_TEXT, 0, RGB( 63, 63, 63 ) },
{ COLOR_PHONEME_TAG_TEXT_SELECTED, 0, RGB( 250, 250, 250 ) },
{ COLOR_PHONEME_WAV_ENDPOINT, 0, RGB( 0, 0, 200 ) },
{ COLOR_PHONEME_AB, 0, RGB( 63, 190, 210 ) },
{ COLOR_PHONEME_AB_LINE, 0, RGB( 31, 150, 180 ) },
{ COLOR_PHONEME_AB_TEXT, 0, RGB( 100, 120, 120 ) },
{ COLOR_PHONEME_ACTIVE_BORDER, 0, RGB( 150, 240, 180 ) },
{ COLOR_PHONEME_SELECTED_BORDER, 0, RGB( 255, 0, 0 ) },
{ COLOR_PHONEME_TIMING_TAG, -1, RGB( 0, 100, 200 ) },
{ COLOR_PHONEME_EMPHASIS_BG, 1, RGB( 230, 230, 200 ) },
{ COLOR_PHONEME_EMPHASIS_BG_STRONG, 1, RGB( 163, 201, 239 ) },
{ COLOR_PHONEME_EMPHASIS_BG_WEAK, 1, RGB( 237, 239, 163 ) },
{ COLOR_PHONEME_EMPHASIS_BORDER, 1, RGB( 200, 200, 200 ) },
{ COLOR_PHONEME_EMPHASIS_LINECOLOR, 1, RGB( 0, 0, 255 ) },
{ COLOR_PHONEME_EMPHASIS_DOTCOLOR, 1, RGB( 0, 0, 255 ) },
{ COLOR_PHONEME_EMPHASIS_DOTCOLOR_SELECTED, 1, RGB( 240, 80, 20 ) },
{ COLOR_PHONEME_EMPHASIS_TEXT, 1, RGB( 0, 0, 0 ) },
{ COLOR_PHONEME_EMPHASIS_MIDLINE, 1, RGB( 100, 150, 200 ) },
};
struct Extractor
{
PE_APITYPE apitype;
CSysModule *module;
IPhonemeExtractor *extractor;
};
CUtlVector< Extractor > g_Extractors;
bool DoesExtractorExistFor( PE_APITYPE type )
{
for ( int i=0; i < g_Extractors.Count(); i++ )
{
if ( g_Extractors[i].apitype == type )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Implements the RIFF i/o interface on stdio
//-----------------------------------------------------------------------------
class StdIOReadBinary : public IFileReadBinary
{
public:
int open( const char *pFileName )
{
return (int)filesystem->Open( pFileName, "rb" );
}
int read( void *pOutput, int size, int file )
{
if ( !file )
return 0;
return filesystem->Read( pOutput, size, (FileHandle_t)file );
}
void seek( int file, int pos )
{
if ( !file )
return;
filesystem->Seek( (FileHandle_t)file, pos, FILESYSTEM_SEEK_HEAD );
}
unsigned int tell( int file )
{
if ( !file )
return 0;
return filesystem->Tell( (FileHandle_t)file );
}
unsigned int size( int file )
{
if ( !file )
return 0;
return filesystem->Size( (FileHandle_t)file );
}
void close( int file )
{
if ( !file )
return;
filesystem->Close( (FileHandle_t)file );
}
};
class StdIOWriteBinary : public IFileWriteBinary
{
public:
int create( const char *pFileName )
{
MakeFileWriteable( pFileName );
return (int)filesystem->Open( pFileName, "wb" );
}
int write( void *pData, int size, int file )
{
return filesystem->Write( pData, size, (FileHandle_t)file );
}
void close( int file )
{
filesystem->Close( (FileHandle_t)file );
}
void seek( int file, int pos )
{
filesystem->Seek( (FileHandle_t)file, pos, FILESYSTEM_SEEK_HEAD );
}
unsigned int tell( int file )
{
return filesystem->Tell( (FileHandle_t)file );
}
};
// Interface objects
static StdIOWriteBinary io_out;
static StdIOReadBinary io_in;
class CPhonemeModeTab : public CTabWindow
{
public:
typedef CTabWindow BaseClass;
CPhonemeModeTab( mxWindow *parent, int x, int y, int w, int h, int id = 0, int style = 0 ) :
CTabWindow( parent, x, y, w, h, id, style )
{
SetInverted( true );
}
virtual void ShowRightClickMenu( int mx, int my )
{
// Nothing
}
void Init( void )
{
add( "Phonemes" );
add( "Emphasis" );
select( 0 );
}
};
PhonemeEditor * g_pPhonemeEditor = 0;
//-----------------------------------------------------------------------------
// Purpose:
// Input : *parent -
//-----------------------------------------------------------------------------
PhonemeEditor::PhonemeEditor( mxWindow *parent ) :
IFacePoserToolWindow( "PhonemeEditor", "Phoneme Editor" ),
mxWindow( parent, 0, 0, 0, 0 )
{
SetAutoProcess( false );
m_flPlaybackRate = 1.0f;
m_flScrub = 0.0f;
m_flScrubTarget = 0.0f;
m_CurrentMode = MODE_PHONEMES;
Emphasis_Init();
SetupPhonemeEditorColors();
m_bRedoPending = false;
m_nUndoLevel = 0;
m_bWordsActive = false;
m_pWaveFile = NULL;
m_pMixer = NULL;
m_pEvent = NULL;
m_nClickX = 0;
m_WorkFile.m_bDirty = false;
m_WorkFile.m_szWaveFile[ 0 ] = 0;
m_WorkFile.m_szWorkingFile[ 0 ] = 0;
m_WorkFile.m_szBasePath[ 0 ] = 0;
m_nTickHeight = 20;
m_flPixelsPerSecond = 500.0f;
m_nTimeZoom = 100;
m_nTimeZoomStep = TIME_ZOOM_STEP;
m_pHorzScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_PHONEME_SCROLL, mxScrollbar::Horizontal );
m_hPrevCursor = 0;
m_nStartX = 0;
m_nStartY = 0;
m_nLastX = 0;
m_nLastY = 0;
m_nDragType = DRAGTYPE_NONE;
SetClickedPhoneme( -1, -1 );
m_nSelection[ 0 ] = m_nSelection[ 1 ] = 0;
m_bSelectionActive = false;
m_nSelectedPhonemeCount = 0;
m_nSelectedWordCount = 0;
m_btnSave = new mxButton( this, 0, 0, 16, 16, "Save (Ctrl+S)", IDC_SAVE_LINGUISTIC );
m_btnRedoPhonemeExtraction = new mxButton( this, 38, 14, 80, 16, "Re-extract (Ctrl+R)", IDC_REDO_PHONEMEEXTRACTION );
m_btnLoad = new mxButton( this, 0, 0, 0, 0, "Load (Ctrl+O)", IDC_LOADWAVEFILE );
m_btnPlay = new mxButton( this, 0, 0, 16, 16, "Play (Spacebar)", IDC_PLAYBUTTON );
m_pPlaybackRate = new mxSlider( this, 0, 0, 16, 16, IDC_PLAYBACKRATE );
m_pPlaybackRate->setRange( 0.0, 2.0, 40 );
m_pPlaybackRate->setValue( m_flPlaybackRate );
m_pModeTab = new CPhonemeModeTab( this, 0, 0, 500, 20, IDC_MODE_TAB );
m_pModeTab->Init();
m_nLastExtractionResult = SR_RESULT_NORESULT;
ClearDragLimit();
SetSuffix( " - Normal" );
m_flScrubberTimeOffset = 0.0f;
LoadPhonemeConverters();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::OnDelete()
{
if ( m_pWaveFile )
{
char fn[ 512 ];
Q_snprintf( fn, sizeof( fn ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
filesystem->RemoveFile( fn, "GAME" );
}
delete m_pWaveFile;
m_pWaveFile = NULL;
m_Tags.Reset();
m_TagsExt.Reset();
UnloadPhonemeConverters();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::CanClose()
{
if ( !GetDirty() )
return true;
int retval = mxMessageBox( this, va( "Save current changes to %s", m_WorkFile.m_szWaveFile ),
"Phoneme Editor", MX_MB_QUESTION | MX_MB_YESNOCANCEL );
// Cancel
if ( retval == 2 )
{
return false;
}
// Yes
if ( retval == 0 )
{
CommitChanges();
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
PhonemeEditor::~PhonemeEditor( void )
{
}
void PhonemeEditor::SetupPhonemeEditorColors( void )
{
int i;
for ( i = 0; i < NUM_COLORS; i++ )
{
PhonemeEditorColor *p = &g_PEColors[ i ];
Assert( p->color_number == i );
if ( p->mode_number == -1 )
{
p->gray_color = p->root_color;
}
else
{
COLORREF bgColor = g_PEColors[ COLOR_PHONEME_BACKGROUND ].root_color;
int bgr, bgg, bgb;
bgr = GetRValue( bgColor );
bgg = GetGValue( bgColor );
bgb = GetBValue( bgColor );
int r, g, b;
r = GetRValue( p->root_color );
g = GetGValue( p->root_color );
b = GetBValue( p->root_color );
int avg = ( r + g + b ) / 3;
int bgavg = ( bgr + bgg + bgb ) / 3;
// Bias toward bg color
avg += ( bgavg - avg ) / 2.5;
p->gray_color = RGB( avg, avg, avg );
}
}
}
COLORREF PhonemeEditor::PEColor( int colornum )
{
COLORREF clr = RGB( 0, 0, 0 );
if ( colornum < 0 || colornum >= NUM_COLORS )
{
Assert( 0 );
return clr;
}
PhonemeEditorColor *p = &g_PEColors[ colornum ];
if ( p->mode_number == -1 )
{
return p->root_color;
}
int modenum = (int)GetMode();
if ( p->mode_number == modenum )
{
return p->root_color;
}
return p->gray_color;
}
void PhonemeEditor::EditWord( CWordTag *pWord, bool positionDialog /*= false*/ )
{
if ( !pWord )
{
Con_Printf( "PhonemeEditor::EditWord: pWord == NULL\n" );
return;
}
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Edit Word" );
strcpy( params.m_szPrompt, "Current Word:" );
V_strcpy_safe( params.m_szInputText, pWord->GetWord() );
params.m_nLeft = -1;
params.m_nTop = -1;
params.m_bPositionDialog = positionDialog;
if ( params.m_bPositionDialog )
{
RECT rcWord;
GetWordRect( pWord, rcWord );
// Convert to screen coords
POINT pt;
pt.x = rcWord.left;
pt.y = rcWord.top;
ClientToScreen( (HWND)getHandle(), &pt );
params.m_nLeft = pt.x;
params.m_nTop = pt.y;
}
int iret = InputProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
// Validate parameters
if ( CSentence::CountWords( params.m_szInputText ) != 1 )
{
Con_ErrorPrintf( "Edit word: %s has multiple words in it!!!\n", params.m_szInputText );
return;
}
SetFocus( (HWND)getHandle() );
SetDirty( true );
PushUndo();
// Set the word and clear out the phonemes
// ->m_nPhonemeCode = TextToPhoneme( params.m_szName );
pWord->SetWord( params.m_szInputText );
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPhoneme -
// positionDialog -
//-----------------------------------------------------------------------------
void PhonemeEditor::EditPhoneme( CPhonemeTag *pPhoneme, bool positionDialog /*= false*/ )
{
if ( !pPhoneme )
{
Con_Printf( "PhonemeEditor::EditPhoneme: pPhoneme == NULL\n" );
return;
}
CPhonemeParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
V_strcpy_safe( params.m_szName, ConvertPhoneme( pPhoneme->GetPhonemeCode() ) );
params.m_nLeft = -1;
params.m_nTop = -1;
params.m_bPositionDialog = positionDialog;
if ( params.m_bPositionDialog )
{
RECT rcPhoneme;
GetPhonemeRect( pPhoneme, rcPhoneme );
// Convert to screen coords
POINT pt;
pt.x = rcPhoneme.left;
pt.y = rcPhoneme.top;
ClientToScreen( (HWND)getHandle(), &pt );
params.m_nLeft = pt.x;
params.m_nTop = pt.y;
}
int iret = PhonemeProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
SetDirty( true );
PushUndo();
pPhoneme->SetPhonemeCode( TextToPhoneme( params.m_szName ) );
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditPhoneme( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CPhonemeTag *pPhoneme = GetClickedPhoneme();
if ( !pPhoneme )
return;
EditPhoneme( pPhoneme, false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditWord( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CWordTag *pWord = GetClickedWord();
if ( !pWord )
return;
EditWord( pWord, false );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dragtype -
// startx -
// cursor -
//-----------------------------------------------------------------------------
void PhonemeEditor::StartDragging( int dragtype, int startx, int starty, HCURSOR cursor )
{
m_nDragType = dragtype;
m_nStartX = startx;
m_nLastX = startx;
m_nStartY = starty;
m_nLastY = starty;
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = NULL;
}
m_hPrevCursor = SetCursor( cursor );
m_FocusRects.Purge();
RECT rc;
GetWorkspaceRect( rc );
RECT rcStart;
rcStart.left = startx;
rcStart.right = startx;
bool addrect = true;
switch ( dragtype )
{
default:
case DRAGTYPE_SCRUBBER:
{
RECT rcScrub;
GetScrubHandleRect( rcScrub, true );
rcStart = rcScrub;
rcStart.left = ( rcScrub.left + rcScrub.right ) / 2;
rcStart.right = rcStart.left;
rcStart.bottom = h2() - 18 - MODE_TAB_OFFSET;
}
break;
case DRAGTYPE_EMPHASIS_SELECT:
{
RECT rcEmphasis;
Emphasis_GetRect( rc, rcEmphasis );
rcStart.top = starty;
rcStart.bottom = starty;
}
break;
case DRAGTYPE_EMPHASIS_MOVE:
{
SetDirty( true );
PushUndo();
Emphasis_MouseDrag( startx, starty );
m_Tags.Resort();
addrect = false;
}
break;
case DRAGTYPE_SELECTSAMPLES:
case DRAGTYPE_MOVESELECTIONSTART:
case DRAGTYPE_MOVESELECTIONEND:
rcStart.top = rc.top;
rcStart.bottom = rc.bottom;
break;
case DRAGTYPE_MOVESELECTION:
{
rcStart.top = rc.top;
rcStart.bottom = rc.bottom;
// Compute left/right pixels for selection
rcStart.left = GetPixelForSample( m_nSelection[ 0 ] );
rcStart.right = GetPixelForSample( m_nSelection[ 1 ] );
}
break;
case DRAGTYPE_PHONEME:
{
GetPhonemeTrayTopBottom( rcStart );
m_bWordsActive = false;
}
break;
case DRAGTYPE_WORD:
{
GetWordTrayTopBottom( rcStart );
m_bWordsActive = true;
}
break;
case DRAGTYPE_MOVEWORD:
{
TraverseWords( &PhonemeEditor::ITER_AddFocusRectSelectedWords, 0.0f );
addrect = false;
m_bWordsActive = true;
}
break;
case DRAGTYPE_MOVEPHONEME:
{
TraversePhonemes( &PhonemeEditor::ITER_AddFocusRectSelectedPhonemes, 0.0f );
addrect = false;
m_bWordsActive = false;
}
break;
case DRAGTYPE_EVENTTAG_MOVE:
{
rcStart.top = TAG_TOP;
rcStart.bottom = TAG_BOTTOM;
rcStart.left -= 10;
rcStart.right += 10;
}
break;
}
if ( addrect )
{
AddFocusRect( rcStart );
}
DrawFocusRect( "start" );
SetDragLimit( m_nDragType );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// Output : int
//-----------------------------------------------------------------------------
int PhonemeEditor::handleEvent( mxEvent *event )
{
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
int iret = 0;
if ( HandleToolEvent( event ) )
{
return iret;
}
switch ( event->event )
{
case mxEvent::Action:
{
iret = 1;
switch ( event->action )
{
case IDC_EXPORT_SENTENCE:
{
OnExport();
}
break;
case IDC_IMPORT_SENTENCE:
{
OnImport();
}
break;
case IDC_PLAYBACKRATE:
{
m_flPlaybackRate = m_pPlaybackRate->getValue();
redraw();
}
break;
case IDC_MODE_TAB:
{
// The mode changed, so reset stuff here
EditorMode newMode = (EditorMode)m_pModeTab->getSelectedIndex();
bool needpaint = ( m_CurrentMode != newMode );
m_CurrentMode = newMode;
if ( needpaint )
{
switch ( GetMode() )
{
default:
case MODE_PHONEMES:
SetSuffix( " - Normal" );
break;
case MODE_EMPHASIS:
SetSuffix( " - Emphasis Track" );
break;
}
OnModeChanged();
redraw();
}
}
break;
case IDC_EMPHASIS_DELETE:
Emphasis_Delete();
break;
case IDC_EMPHASIS_DESELECT:
Emphasis_DeselectAll();
break;
case IDC_EMPHASIS_SELECTALL:
Emphasis_SelectAll();
break;
case IDC_API_SAPI:
OnSAPI();
break;
case IDC_API_LIPSINC:
OnLipSinc();
break;
case IDC_PLAYBUTTON:
Play();
break;
case IDC_UNDO:
Undo();
break;
case IDC_REDO:
Redo();
break;
case IDC_CLEARUNDO:
ClearUndo();
break;
case IDC_ADDTAG:
AddTag();
break;
case IDC_DELETETAG:
DeleteTag();
break;
case IDC_COMMITEXTRACTED:
CommitExtracted();
SetFocus( (HWND)getHandle() );
break;
case IDC_CLEAREXTRACTED:
ClearExtracted();
break;
case IDC_SEPARATEPHONEMES:
SeparatePhonemes();
break;
case IDC_SNAPPHONEMES:
SnapPhonemes();
break;
case IDC_SEPARATEWORDS:
SeparateWords();
break;
case IDC_SNAPWORDS:
SnapWords();
break;
case IDC_EDITWORDLIST:
EditWordList();
break;
case IDC_EDIT_PHONEME:
EditPhoneme();
break;
case IDC_EDIT_WORD:
EditWord();
break;
case IDC_EDIT_INSERTPHONEMEBEFORE:
EditInsertPhonemeBefore();
break;
case IDC_EDIT_INSERTPHONEMEAFTER:
EditInsertPhonemeAfter();
break;
case IDC_EDIT_INSERTWORDBEFORE:
EditInsertWordBefore();
break;
case IDC_EDIT_INSERTWORDAFTER:
EditInsertWordAfter();
break;
case IDC_EDIT_DELETEPHONEME:
EditDeletePhoneme();
break;
case IDC_EDIT_DELETEWORD:
EditDeleteWord();
break;
case IDC_EDIT_INSERTFIRSTPHONEMEOFWORD:
EditInsertFirstPhonemeOfWord();
break;
case IDC_PHONEME_PLAY_ORIG:
{
StopPlayback();
if ( m_pWaveFile )
{
// Make sure phonemes are loaded
FacePoser_EnsurePhonemesLoaded();
sound->PlaySound( m_pWaveFile, VOL_NORM, &m_pMixer );
}
}
break;
case IDC_PHONEME_SCROLL:
if (event->modifiers == SB_THUMBTRACK)
{
MoveTimeSliderToPos( event->height );
}
else if ( event->modifiers == SB_PAGEUP )
{
int offset = m_pHorzScrollBar->getValue();
offset -= 10;
offset = max( offset, m_pHorzScrollBar->getMinValue() );
MoveTimeSliderToPos( offset );
}
else if ( event->modifiers == SB_PAGEDOWN )
{
int offset = m_pHorzScrollBar->getValue();
offset += 10;
offset = min( offset, m_pHorzScrollBar->getMaxValue() );
MoveTimeSliderToPos( offset );
}
break;
case IDC_REDO_PHONEMEEXTRACTION:
if ( m_Tags.m_Words.Size() <= 0 )
{
// This calls redo LISET if some words are actually entered
EditWordList();
}
else
{
RedoPhonemeExtraction();
}
SetFocus( (HWND)getHandle() );
break;
case IDC_REDO_PHONEMEEXTRACTION_SELECTION:
{
RedoPhonemeExtractionSelected();
}
SetFocus( (HWND)getHandle() );
break;
case IDC_DESELECT:
Deselect();
redraw();
break;
case IDC_PLAY_EDITED:
PlayEditedWave( false );
SetFocus( (HWND)getHandle() );
break;
case IDC_PLAY_EDITED_SELECTION:
PlayEditedWave( true );
SetFocus( (HWND)getHandle() );
break;
case IDC_SAVE_LINGUISTIC:
CommitChanges();
SetFocus( (HWND)getHandle() );
break;
case IDC_LOADWAVEFILE:
LoadWaveFile();
SetFocus( (HWND)getHandle() );
break;
case IDC_CANCELPLAYBACK:
StopPlayback();
SetFocus( (HWND)getHandle() );
break;
case IDC_SELECT_WORDSRIGHT:
SelectWords( true );
break;
case IDC_SELECT_WORDSLEFT:
SelectWords( false );
break;
case IDC_SELECT_PHONEMESRIGHT:
SelectPhonemes( true );
break;
case IDC_SELECT_PHONEMESLEFT:
SelectPhonemes( false );
break;
case IDC_DESELECT_PHONEMESANDWORDS:
DeselectPhonemes();
DeselectWords();
redraw();
break;
case IDC_CLEANUP:
CleanupWordsAndPhonemes( true );
redraw();
break;
case IDC_REALIGNPHONEMES:
RealignPhonemesToWords( true );
redraw();
break;
case IDC_REALIGNWORDS:
RealignWordsToPhonemes( true );
redraw();
break;
case IDC_TOGGLE_VOICEDUCK:
OnToggleVoiceDuck();
break;
}
if ( iret == 1 )
{
SetActiveTool( this );
SetFocus( (HWND)getHandle() );
}
}
break;
case mxEvent::MouseWheeled:
{
// Zoom time in / out
if ( event->height > 0 )
{
m_nTimeZoom = min( m_nTimeZoom + m_nTimeZoomStep, MAX_TIME_ZOOM );
}
else
{
m_nTimeZoom = max( m_nTimeZoom - m_nTimeZoomStep, m_nTimeZoomStep );
}
RepositionHSlider();
iret = 1;
}
break;
case mxEvent::Size:
{
int bw = 100;
int x = 5;
int by = h2() - 18 - MODE_TAB_OFFSET;
m_pModeTab->setBounds( 0, h2() - MODE_TAB_OFFSET, w2(), MODE_TAB_OFFSET );
m_btnRedoPhonemeExtraction->setBounds( x, by, bw, 16 );
x += bw;
m_btnSave->setBounds( x, by, bw, 16 );
x += bw;
m_btnLoad->setBounds( x, by, bw, 16 );
x += bw;
m_btnPlay->setBounds( x, by, bw, 16 );
x += bw;
m_pPlaybackRate->setBounds( x, by, 100, 16 );
RepositionHSlider();
iret = 1;
}
break;
case mxEvent::MouseDown:
{
iret = 1;
CPhonemeTag *pt;
CWordTag *wt;
pt = GetPhonemeTagUnderMouse( (short)event->x, (short)event->y );
wt = GetWordTagUnderMouse( (short)event->x, (short)event->y );
bool ctrldown = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;
bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
if ( event->buttons & mxEvent::MouseRightButton )
{
RECT rc;
GetWorkspaceRect( rc );
if ( IsMouseOverWordRow( (short)event->y ) )
{
ShowWordMenu( wt, (short)event->x, (short)event->y );
}
else if ( IsMouseOverPhonemeRow( (short)event->y ) )
{
ShowPhonemeMenu( pt, (short)event->x, (short)event->y );
}
else if ( IsMouseOverTagRow( (short)event->y ) )
{
ShowTagMenu( (short)event->x, (short)event->y );
}
else if ( IsMouseOverScrubArea( event ) )
{
float t = GetTimeForPixel( (short)event->x );
ClampTimeToSelectionInterval( t );
SetScrubTime( t );
SetScrubTargetTime( t );
redraw();
}
else
{
ShowContextMenu( (short)event->x, (short)event->y );
}
return iret;
}
if ( m_nDragType == DRAGTYPE_NONE )
{
CountSelected();
int type = IsMouseOverBoundary( event );
if ( IsMouseOverScrubArea( event ) )
{
if ( IsMouseOverScrubHandle( event ) )
{
StartDragging( DRAGTYPE_SCRUBBER,
(short)event->x,
(short)event->y,
LoadCursor( NULL, IDC_SIZEWE ) );
float t = GetTimeForPixel( (short)event->x );
m_flScrubberTimeOffset = m_flScrub - t;
float maxoffset = 0.5f * (float)SCRUBBER_HANDLE_WIDTH / GetPixelsPerSecond();
m_flScrubberTimeOffset = clamp( m_flScrubberTimeOffset, -maxoffset, maxoffset );
t += m_flScrubberTimeOffset;
ClampTimeToSelectionInterval( t );
SetScrubTime( t );
SetScrubTargetTime( t );
DrawScrubHandle();
iret = true;
}
else
{
float t = GetTimeForPixel( (short)event->x );
ClampTimeToSelectionInterval( t );
SetScrubTargetTime( t );
iret = true;
}
return iret;
}
else if ( GetMode() == MODE_EMPHASIS )
{
CEmphasisSample *sample = Emphasis_GetSampleUnderMouse( event );
if ( sample )
{
if ( shiftdown )
{
sample->selected = !sample->selected;
redraw();
}
else if ( sample->selected )
{
StartDragging( DRAGTYPE_EMPHASIS_MOVE, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
}
else
{
if ( !shiftdown )
{
Emphasis_DeselectAll();
redraw();
}
StartDragging( DRAGTYPE_EMPHASIS_SELECT, (short)event->x, (short)event->y, NULL );
}
return true;
}
else if ( ctrldown )
{
// Add a sample point
float t = GetTimeForPixel( (short)event->x );
RECT rcWork;
GetWorkspaceRect( rcWork );
RECT rcEmphasis;
Emphasis_GetRect( rcWork, rcEmphasis );
int eh = rcEmphasis.bottom - rcEmphasis.top;
int dy = (short)event->y - rcEmphasis.top;
CEmphasisSample sample;
sample.time = t;
Assert( eh >= 0 );
sample.value = (float)( dy ) / ( float ) eh;
sample.value = 1.0f - clamp( sample.value, 0.0f, 1.0f );
sample.selected = false;
Emphasis_AddSample( sample );
redraw();
return true;
}
else
{
if ( !shiftdown )
{
Emphasis_DeselectAll();
redraw();
}
StartDragging( DRAGTYPE_EMPHASIS_SELECT, (short)event->x, (short)event->y, NULL );
return true;
}
}
else
{
if ( type == BOUNDARY_PHONEME && m_nSelectedPhonemeCount <= 1 )
{
StartDragging( DRAGTYPE_PHONEME, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
return true;
}
else if ( type == BOUNDARY_WORD && m_nSelectedWordCount <= 1 )
{
StartDragging( DRAGTYPE_WORD, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
return true;
}
else if ( IsMouseOverSamples( (short)event->x, (short)event->y ) )
{
if ( !m_bSelectionActive )
{
StartDragging( DRAGTYPE_SELECTSAMPLES, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
}
else
{
// Either move, move edge if ctrl key is held, or deselect
if ( IsMouseOverSelection( (short)event->x, (short)event->y ) )
{
if ( IsMouseOverSelectionStartEdge( event ) )
{
StartDragging( DRAGTYPE_MOVESELECTIONSTART, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverSelectionEndEdge( event ) )
{
StartDragging( DRAGTYPE_MOVESELECTIONEND, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
}
else
{
if ( shiftdown )
{
StartDragging( DRAGTYPE_MOVESELECTION, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
}
}
}
else
{
Deselect();
redraw();
return iret;
}
}
return true;
}
}
if ( IsMouseOverTag( (short)event->x, (short)event->y ) )
{
StartDragging( DRAGTYPE_EVENTTAG_MOVE, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
return true;
}
else
{
if ( pt )
{
// Can only move when holding down shift key
if ( shiftdown )
{
pt->m_bSelected = true;
StartDragging( DRAGTYPE_MOVEPHONEME,
(short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
}
else
{
// toggle the selection
pt->m_bSelected = !pt->m_bSelected;
}
m_bWordsActive = false;
redraw();
return true;
}
else if ( wt )
{
// Can only move when holding down shift key
if ( shiftdown )
{
wt->m_bSelected = true;
StartDragging( DRAGTYPE_MOVEWORD,
(short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
}
else
{
// toggle the selection
wt->m_bSelected = !wt->m_bSelected;
}
m_bWordsActive = true;
redraw();
return true;
}
else if ( type == BOUNDARY_NONE )
{
DeselectPhonemes();
DeselectWords();
redraw();
return true;
}
}
}
}
break;
case mxEvent::MouseMove:
case mxEvent::MouseDrag:
{
OnMouseMove( event );
iret = 1;
}
break;
case mxEvent::MouseUp:
{
if ( m_nDragType != DRAGTYPE_NONE )
{
int mx = (short)event->x;
LimitDrag( mx );
event->x = (short)mx;
DrawFocusRect( "finish" );
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = 0;
}
switch ( m_nDragType )
{
case DRAGTYPE_WORD:
FinishWordMove( m_nStartX, (short)event->x );
break;
case DRAGTYPE_PHONEME:
FinishPhonemeMove( m_nStartX, (short)event->x );
break;
case DRAGTYPE_SELECTSAMPLES:
FinishSelect( m_nStartX, (short)event->x );
break;
case DRAGTYPE_MOVESELECTION:
FinishMoveSelection( m_nStartX, (short)event->x );
break;
case DRAGTYPE_MOVESELECTIONSTART:
FinishMoveSelectionStart( m_nStartX, (short)event->x );
break;
case DRAGTYPE_MOVESELECTIONEND:
FinishMoveSelectionEnd( m_nStartX, (short)event->x );
break;
case DRAGTYPE_MOVEWORD:
FinishWordDrag( m_nStartX, (short)event->x );
break;
case DRAGTYPE_MOVEPHONEME:
FinishPhonemeDrag( m_nStartX, (short)event->x );
break;
case DRAGTYPE_EVENTTAG_MOVE:
FinishEventTagDrag( m_nStartX, (short)event->x );
break;
case DRAGTYPE_EMPHASIS_MOVE:
{
Emphasis_MouseDrag( (short)event->x, (short)event->y );
m_Tags.Resort();
PushRedo();
redraw();
}
break;
case DRAGTYPE_EMPHASIS_SELECT:
{
Emphasis_SelectPoints();
redraw();
}
break;
case DRAGTYPE_SCRUBBER:
{
float t = GetTimeForPixel( (short)event->x );
t += m_flScrubberTimeOffset;
m_flScrubberTimeOffset = 0.0f;
ClampTimeToSelectionInterval( t );
SetScrubTime( t );
SetScrubTargetTime( t );
sound->Flush();
DrawScrubHandle();
}
break;
default:
break;
}
m_nDragType = DRAGTYPE_NONE;
}
iret = 1;
}
break;
case mxEvent::KeyUp:
{
bool shiftDown = GetAsyncKeyState( VK_SHIFT ) ? true : false;
bool ctrlDown = GetAsyncKeyState( VK_CONTROL ) ? true : false;
switch( event->key )
{
case VK_TAB:
{
int direction = shiftDown ? -1 : 1;
SelectNextWord( direction );
}
break;
case VK_NEXT:
case VK_PRIOR:
{
m_bWordsActive = event->key == VK_PRIOR ? true : false;
redraw();
}
break;
case VK_UP:
case VK_RETURN:
if ( m_bWordsActive )
{
if ( event->key == VK_UP ||
ctrlDown )
{
CountSelected();
if ( m_nSelectedWordCount == 1 )
{
// Find the selected one
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word || !word->m_bSelected )
continue;
EditWord( word, true );
}
}
}
}
else
{
if ( event->key == VK_UP ||
ctrlDown )
{
CountSelected();
if ( m_nSelectedPhonemeCount == 1 )
{
// Find the selected one
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
if ( !phoneme->m_bSelected )
continue;
EditPhoneme( phoneme, true );
}
}
}
}
}
break;
case VK_DELETE:
if ( GetMode() == MODE_EMPHASIS )
{
Emphasis_Delete();
}
else
{
if ( m_bWordsActive )
{
EditDeleteWord();
}
else
{
EditDeletePhoneme();
}
}
break;
case VK_INSERT:
if ( m_bWordsActive )
{
if ( shiftDown )
{
EditInsertWordBefore();
}
else
{
EditInsertWordAfter();
}
}
else
{
if ( shiftDown )
{
EditInsertPhonemeBefore();
}
else
{
EditInsertPhonemeAfter();
}
}
break;
case VK_SPACE:
if ( m_pWaveFile && sound->IsSoundPlaying( m_pMixer ) )
{
Con_Printf( "Stopping playback\n" );
m_btnPlay->setLabel( "Play (Spacebar)" );
StopPlayback();
}
else
{
Con_Printf( "Playing .wav\n" );
m_btnPlay->setLabel( "Stop[ (Spacebar)" );
PlayEditedWave( m_bSelectionActive );
}
break;
case VK_SHIFT:
case VK_CONTROL:
{
// Force mouse move
POINT pt;
GetCursorPos( &pt );
SetCursorPos( pt.x, pt.y );
return 0;
}
break;
case VK_ESCAPE:
{
// If playing sound, stop it, otherwise, deselect all
if ( !StopPlayback() )
{
Deselect();
DeselectPhonemes();
DeselectWords();
Emphasis_DeselectAll();
redraw();
}
}
break;
case 'O':
{
if ( ctrlDown )
{
LoadWaveFile();
}
}
break;
case 'S':
{
if ( ctrlDown )
{
CommitChanges();
}
}
break;
case 'T':
{
if ( ctrlDown )
{
// Edit sentence text
EditWordList();
}
}
break;
case 'G':
{
if ( ctrlDown )
{
// Commit extraction
CommitExtracted();
}
}
break;
case 'R':
{
if ( ctrlDown )
{
RedoPhonemeExtraction();
}
}
break;
default:
break;
}
SetFocus( (HWND)getHandle() );
iret = 1;
}
break;
case mxEvent::KeyDown:
{
switch ( event->key )
{
case 'Z':
if ( GetAsyncKeyState( VK_CONTROL ) )
{
Undo();
}
break;
case 'Y':
if ( GetAsyncKeyState( VK_CONTROL ) )
{
Redo();
}
break;
case VK_RIGHT:
case VK_LEFT:
{
int direction = event->key == VK_LEFT ? -1 : 1;
if ( !m_bWordsActive )
{
if ( GetAsyncKeyState( VK_CONTROL ) )
{
ExtendSelectedPhonemeEndTime( direction );
}
else if ( GetAsyncKeyState( VK_SHIFT ) )
{
ShiftSelectedPhoneme( direction );
}
else
{
SelectNextPhoneme( direction );
}
}
else
{
if ( GetAsyncKeyState( VK_CONTROL ) )
{
ExtendSelectedWordEndTime( direction );
}
else if ( GetAsyncKeyState( VK_SHIFT ) )
{
ShiftSelectedWord( direction );
}
else
{
SelectNextWord( direction );
}
}
}
break;
case VK_RETURN:
{
}
break;
case VK_SHIFT:
case VK_CONTROL:
{
// Force mouse move
POINT pt;
GetCursorPos( &pt );
//SetCursorPos( pt.x -1, pt.y );
SetCursorPos( pt.x, pt.y );
return 0;
}
break;
default:
break;
}
iret = 1;
}
break;
}
return iret;
}
void PhonemeEditor::DrawWords( CChoreoWidgetDrawHelper& drawHelper, RECT& rcWorkSpace, CSentence& sentence, int type, bool showactive /* = true */ )
{
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
int ypos = rcWorkSpace.top + m_nTickHeight + 2;
if ( type == 1 )
{
ypos += m_nTickHeight + 5;
}
const char *fontName = "Arial";
bool drawselected;
for ( int pass = 0; pass < 2 ; pass++ )
{
drawselected = pass == 0 ? false : true;
for (int k = 0; k < sentence.m_Words.Size(); k++)
{
CWordTag *word = sentence.m_Words[ k ];
if ( !word )
continue;
if ( word->m_bSelected != drawselected )
continue;
bool hasselectedphonemes = false;
for ( int p = 0; p < word->m_Phonemes.Size() && !hasselectedphonemes; p++ )
{
CPhonemeTag *t = word->m_Phonemes[ p ];
if ( t->m_bSelected )
{
hasselectedphonemes = true;
}
}
float t1 = word->m_flStartTime;
float t2 = word->m_flEndTime;
// Tag it
float frac = ( t1 - starttime ) / ( endtime - starttime );
int xpos = ( int )( frac * rcWorkSpace.right );
if ( frac <= 0.0 )
xpos = 0;
// Draw duration
float frac2 = ( t2 - starttime ) / ( endtime - starttime );
if ( frac2 < 0.0 )
continue;
int xpos2 = ( int )( frac2 * rcWorkSpace.right );
// Draw line and vertical ticks
RECT rcWord;
rcWord.left = xpos;
rcWord.right = xpos2;
rcWord.top = ypos - m_nTickHeight + 1;
rcWord.bottom = ypos;
drawHelper.DrawFilledRect(
PEColor( word->m_bSelected ? COLOR_PHONEME_TAG_SELECTED : COLOR_PHONEME_TAG_FILLER_NORMAL ),
rcWord );
COLORREF border = PEColor( word->m_bSelected ? COLOR_PHONEME_TAG_BORDER_SELECTED : COLOR_PHONEME_TAG_BORDER );
if ( showactive && m_bWordsActive )
{
drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_ACTIVE_BORDER ), xpos, ypos - m_nTickHeight, xpos2, ypos - m_nTickHeight + 4 );
}
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos2, ypos );
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos, ypos - m_nTickHeight );
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos2, ypos, xpos2, ypos - m_nTickHeight );
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos - m_nTickHeight, xpos2, ypos - m_nTickHeight );
if ( hasselectedphonemes )
{
drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_SELECTED_BORDER ), xpos, ypos - 3, xpos2, ypos );
}
//if ( frac >= 0.0 && frac <= 1.0 )
{
int fontsize = 9;
RECT rcText;
rcText.left = xpos;
rcText.right = xpos + 500;
rcText.top = ypos - m_nTickHeight + 4;
rcText.bottom = rcText.top + fontsize + 2;
int length = drawHelper.CalcTextWidth( fontName, fontsize, FW_NORMAL, "%s", word->GetWord() );
rcText.right = max( (LONG)xpos2 - 2, rcText.left + length + 1 );
int w = rcText.right - rcText.left;
if ( w > length )
{
rcText.left += ( w - length ) / 2;
}
drawHelper.DrawColoredText(
fontName,
fontsize,
FW_NORMAL,
PEColor( word->m_bSelected ? COLOR_PHONEME_TAG_TEXT_SELECTED : COLOR_PHONEME_TAG_TEXT ),
rcText,
"%s", word->GetWord() );
}
}
}
}
void PhonemeEditor::DrawPhonemes( CChoreoWidgetDrawHelper& drawHelper, RECT& rcWorkSpace, CSentence& sentence, int type, bool showactive /* = true */ )
{
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
int ypos = rcWorkSpace.bottom - m_nTickHeight - 2;
if ( type == 1 )
{
ypos -= ( m_nTickHeight + 5 );
}
const char *fontName = "Arial";
bool drawselected;
for ( int pass = 0; pass < 2 ; pass++ )
{
drawselected = pass == 0 ? false : true;
for ( int i = 0; i < sentence.m_Words.Size(); i++ )
{
CWordTag *w = sentence.m_Words[ i ];
if ( !w )
continue;
if ( w->m_bSelected != drawselected )
continue;
for ( int k = 0; k < w->m_Phonemes.Size(); k++ )
{
CPhonemeTag *pPhoneme = w->m_Phonemes[ k ];
float t1 = pPhoneme->GetStartTime();
float t2 = pPhoneme->GetEndTime();
// Tag it
float frac = ( t1 - starttime ) / ( endtime - starttime );
int xpos = ( int )( frac * rcWorkSpace.right );
if ( frac <= 0.0 )
{
xpos = 0;
}
// Draw duration
float frac2 = ( t2 - starttime ) / ( endtime - starttime );
if ( frac2 < 0.0 )
{
continue;
}
int xpos2 = ( int )( frac2 * rcWorkSpace.right );
RECT rcFrame;
rcFrame.left = xpos;
rcFrame.right = xpos2;
rcFrame.top = ypos - m_nTickHeight + 1;
rcFrame.bottom = ypos;
drawHelper.DrawFilledRect(
PEColor( pPhoneme->m_bSelected ? COLOR_PHONEME_TAG_SELECTED : COLOR_PHONEME_TAG_FILLER_NORMAL ),
rcFrame );
COLORREF border = PEColor( pPhoneme->m_bSelected ? COLOR_PHONEME_TAG_BORDER_SELECTED : COLOR_PHONEME_TAG_BORDER );
if ( showactive && !m_bWordsActive )
{
drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_ACTIVE_BORDER ), xpos, ypos - 3, xpos2, ypos );
}
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos - m_nTickHeight, xpos2, ypos - m_nTickHeight );
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos, ypos - m_nTickHeight );
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos2, ypos, xpos2, ypos - m_nTickHeight );
drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos2, ypos );
if ( w->m_bSelected )
{
drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_SELECTED_BORDER ), xpos, ypos - m_nTickHeight + 1, xpos2, ypos - m_nTickHeight + 4 );
}
//if ( frac >= 0.0 && frac <= 1.0 )
{
int fontsize = 9;
RECT rcText;
rcText.left = xpos;
rcText.right = xpos + 500;
rcText.top = ypos - m_nTickHeight + 4;
rcText.bottom = rcText.top + fontsize + 2;
int length = drawHelper.CalcTextWidth( fontName, fontsize, FW_NORMAL, "%s", ConvertPhoneme( pPhoneme->GetPhonemeCode() ) );
rcText.right = max( (LONG)xpos2 - 2, rcText.left + length + 1 );
int w = rcText.right - rcText.left;
if ( w > length )
{
rcText.left += ( w - length ) / 2;
}
drawHelper.DrawColoredText(
fontName,
fontsize,
FW_NORMAL,
PEColor( pPhoneme->m_bSelected ? COLOR_PHONEME_TAG_TEXT_SELECTED : COLOR_PHONEME_TAG_TEXT ),
rcText,
"%s", ConvertPhoneme( pPhoneme->GetPhonemeCode() ) );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rc -
//-----------------------------------------------------------------------------
void PhonemeEditor::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
{
if ( !m_pEvent || !m_pWaveFile )
return;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, PEColor( COLOR_PHONEME_TIMING_TAG ), rc, "Timing Tags:" );
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
for ( int i = 0; i < m_pEvent->GetNumRelativeTags(); i++ )
{
CEventRelativeTag *tag = m_pEvent->GetRelativeTag( i );
if ( !tag )
continue;
//
float tagtime = tag->GetPercentage() * m_pWaveFile->GetRunningLength();
if ( tagtime < starttime || tagtime > endtime )
continue;
float frac = ( tagtime - starttime ) / ( endtime - starttime );
int left = rc.left + (int)( frac * ( float )( rc.right - rc.left ) + 0.5f );
RECT rcMark;
rcMark = rc;
rcMark.top = rc.bottom - 8;
rcMark.bottom = rc.bottom;
rcMark.left = left - 4;
rcMark.right = left + 4;
drawHelper.DrawTriangleMarker( rcMark, PEColor( COLOR_PHONEME_TIMING_TAG ) );
RECT rcText;
rcText = rc;
rcText.bottom = rc.bottom - 10;
rcText.top = rcText.bottom - 10;
int len = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, tag->GetName() );
rcText.left = left - len / 2;
rcText.right = rcText.left + len + 2;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, PEColor( COLOR_PHONEME_TIMING_TAG ), rcText, tag->GetName() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::redraw( void )
{
if ( !ToolCanDraw() )
return;
CChoreoWidgetDrawHelper drawHelper( this );
HandleToolRedraw( drawHelper );
if ( !m_pWaveFile )
return;
HDC dc = drawHelper.GrabDC();
RECT rc;
GetWorkspaceRect( rc );
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
// Now draw the time legend
RECT rcLabel;
float granularity = 0.5f;
drawHelper.DrawColoredLine( PEColor( COLOR_PHONEME_TIMELINE ), PS_SOLID, 1, rc.left, rc.bottom - m_nTickHeight, rc.right, rc.bottom - m_nTickHeight );
if ( GetMode() != MODE_EMPHASIS )
{
Emphasis_Redraw( drawHelper, rc );
}
sound->RenderWavToDC(
dc,
rc,
PEColor( COLOR_PHONEME_WAVDATA ),
starttime,
endtime,
m_pWaveFile,
m_bSelectionActive,
m_nSelection[ 0 ],
m_nSelection[ 1 ] );
float f = SnapTime( starttime, granularity );
while ( f <= endtime )
{
float frac = ( f - starttime ) / ( endtime - starttime );
if ( frac >= 0.0f && frac <= 1.0f )
{
drawHelper.DrawColoredLine( ( COLOR_PHONEME_TIMELINE_MAJORTICK ), PS_SOLID, 1, (int)( frac * rc.right ), rc.top, (int)( frac * rc.right ), rc.bottom - m_nTickHeight );
rcLabel.left = (int)( frac * rc.right );
rcLabel.bottom = rc.bottom;
rcLabel.top = rcLabel.bottom - 10;
char sz[ 32 ];
sprintf( sz, "%.2f", f );
int textWidth = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );
rcLabel.right = rcLabel.left + textWidth;
OffsetRect( &rcLabel, -textWidth / 2, 0 );
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, PEColor( COLOR_PHONEME_TEXT ), rcLabel, sz );
}
f += granularity;
}
HBRUSH br = CreateSolidBrush( PEColor( COLOR_PHONEME_TEXT ) );
FrameRect( dc, &rc, br );
DeleteObject( br );
RECT rcTags = rc;
rcTags.top = TAG_TOP;
rcTags.bottom = TAG_BOTTOM;
DrawRelativeTags( drawHelper, rcTags );
int fontsize = 9;
RECT rcText = rc;
rcText.top = rcText.bottom + 5;
rcText.left += 5;
rcText.bottom = rcText.top + fontsize + 1;
rcText.right -= 5;
int fontweight = FW_NORMAL;
const char *font = "Arial";
if ( m_nLastExtractionResult != SR_RESULT_NORESULT )
{
COLORREF clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_OTHER );
switch ( m_nLastExtractionResult )
{
case SR_RESULT_ERROR:
clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_ERROR );
break;
case SR_RESULT_SUCCESS:
clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_SUCCESS );
break;
case SR_RESULT_FAILED:
clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_FAIL );
break;
default:
break;
}
drawHelper.DrawColoredText( font, fontsize, fontweight, clr, rcText,
"Last Extraction Result: %s", GetExtractionResultString( m_nLastExtractionResult ) );
OffsetRect( &rcText, 0, fontsize + 1 );
}
if ( m_pEvent && !Q_stristr( m_pEvent->GetParameters(), ".wav" ) )
{
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
"Sound: '%s', file: %s, length %.2f seconds",
m_pEvent->GetParameters(),
m_WorkFile.m_szWaveFile,
m_pWaveFile->GetRunningLength() );
}
else
{
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
"File: %s, length %.2f seconds", m_WorkFile.m_szWaveFile, m_pWaveFile->GetRunningLength() );
}
OffsetRect( &rcText, 0, fontsize + 1 );
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
"Number of samples %i at %ikhz (%i bits/sample) %s", (int) (m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() ), m_pWaveFile->SampleRate(), (m_pWaveFile->SampleSize()<<3), m_Tags.GetVoiceDuck() ? "duck other audio" : "no ducking" );
OffsetRect( &rcText, 0, fontsize + 1 );
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
"[ %i ] Words [ %i ] Phonemes / Zoom %i %%", m_Tags.m_Words.Size(), m_Tags.CountPhonemes(), m_nTimeZoom );
if ( m_pEvent )
{
OffsetRect( &rcText, 0, fontsize + 1 );
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
"Event %s", m_pEvent->GetName() );
}
OffsetRect( &rcText, 0, fontsize + 1 );
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
"Using: %s", GetSpeechAPIName() );
char text[ 4096 ];
sprintf( text, "Sentence Text: %s", m_Tags.GetText() );
int halfwidth = ( rc.right - rc.left ) / 2;
rcText = rc;
rcText.left = halfwidth;
rcText.top = rcText.bottom + 5;
rcText.right = rcText.left + halfwidth * 0.6;
drawHelper.CalcTextRect( font, fontsize, fontweight, halfwidth, rcText, text );
drawHelper.DrawColoredTextMultiline( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
text );
CWordTag *cw = GetSelectedWord();
if ( cw )
{
char wordInfo[ 512 ];
sprintf( wordInfo, "Word: %s, start %.2f end %.2f, duration %.2f ms phonemes %i",
cw->GetWord(), cw->m_flStartTime, cw->m_flEndTime, 1000.0f * ( cw->m_flEndTime - cw->m_flStartTime ),
cw->m_Phonemes.Size() );
int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, wordInfo );
OffsetRect( &rcText, 0, ( rcText.bottom - rcText.top ) + 2 );
rcText.left = rcText.right - length - 10;
rcText.bottom = rcText.top + fontsize + 1;
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText, wordInfo );
}
CPhonemeTag *cp = GetSelectedPhoneme();
if ( cp )
{
char phonemeInfo[ 512 ];
sprintf( phonemeInfo, "Phoneme: %s, start %.2f end %.2f, duration %.2f ms",
ConvertPhoneme( cp->GetPhonemeCode() ), cp->GetStartTime(), cp->GetEndTime(), 1000.0f * ( cp->GetEndTime() - cp->GetStartTime() ) );
int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, phonemeInfo );
OffsetRect( &rcText, 0, ( rcText.bottom - rcText.top ) + 2 );
rcText.left = rcText.right - length - 10;
rcText.bottom = rcText.top + fontsize + 1;
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText, phonemeInfo );
}
// Draw playback rate
{
char sz[ 48 ];
sprintf( sz, "Speed: %.2fx", m_flPlaybackRate );
int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, sz);
rcText = rc;
rcText.top = rc.bottom + 60;
rcText.bottom = rcText.top + fontsize + 1;
rcText.left = m_pPlaybackRate->x() + m_pPlaybackRate->w() - x();
rcText.right = rcText.left + length + 2;
drawHelper.DrawColoredText( font, fontsize, fontweight,
PEColor( COLOR_PHONEME_TEXT ), rcText, sz );
}
if ( m_UndoStack.Size() > 0 )
{
int length = drawHelper.CalcTextWidth( font, fontsize, fontweight,
"Undo levels: %i/%i", m_nUndoLevel, m_UndoStack.Size() );
rcText = rc;
rcText.top = rc.bottom + 60;
rcText.bottom = rcText.top + fontsize + 1;
rcText.right -= 5;
rcText.left = rcText.right - length - 10;
drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_EXTRACTION_RESULT_SUCCESS ), rcText,
"Undo levels: %i/%i", m_nUndoLevel, m_UndoStack.Size() );
}
float endfrac = ( m_pWaveFile->GetRunningLength() - starttime ) / ( endtime - starttime );
if ( endfrac >= 0.0f && endfrac <= 1.0f )
{
int endpos = ( int ) ( rc.right * endfrac );
drawHelper.DrawColoredLine( PEColor( COLOR_PHONEME_WAV_ENDPOINT ), PS_DOT, 2, endpos, rc.top, endpos, rc.bottom - m_nTickHeight );
}
DrawPhonemes( drawHelper, rc, m_Tags, 0 );
DrawPhonemes( drawHelper, rc, m_TagsExt, 1, false );
DrawWords( drawHelper, rc, m_Tags, 0 );
DrawWords( drawHelper, rc, m_TagsExt, 1, false );
if ( GetMode() == MODE_EMPHASIS )
{
Emphasis_Redraw( drawHelper, rc );
}
DrawScrubHandle( drawHelper );
}
#define MOTION_RANGE 3000
#define MOTION_MAXSTEP 500
//-----------------------------------------------------------------------------
// Purpose: Brown noise simulates brownian motion centered around 127.5 but we cap the walking
// to just a couple of units
// Input : *buffer -
// count -
// Output : static void
//-----------------------------------------------------------------------------
static void WriteBrownNoise( void *buffer, int count )
{
int currentValue = 127500;
int maxValue = currentValue + ( MOTION_RANGE / 2 );
int minValue = currentValue - ( MOTION_RANGE / 2 );
unsigned char *pos = ( unsigned char *)buffer;
while ( --count >= 0 )
{
currentValue += random->RandomInt( -MOTION_MAXSTEP, MOTION_MAXSTEP );
currentValue = min( maxValue, currentValue );
currentValue = max( minValue, currentValue );
// Downsample to 0-255 range
*pos++ = (unsigned char)( ( (float)currentValue / 1000.0f ) + 0.5f );
}
}
//-----------------------------------------------------------------------------
// Purpose: Replace with brownian noice parts of the wav file that we dont' want processed by the
// speech recognizer
// Input : store -
// *format -
// chunkname -
// *buffer -
// buffersize -
//-----------------------------------------------------------------------------
void PhonemeEditor::ResampleChunk( IterateOutputRIFF& store, void *format, int chunkname, char *buffer, int buffersize, int start_silence /*=0*/, int end_silence /*=0*/ )
{
WAVEFORMATEX *pFormat = ( WAVEFORMATEX * )format;
Assert( pFormat );
if ( pFormat->wFormatTag == WAVE_FORMAT_PCM )
{
int silience_time = start_silence + end_silence;
// Leave room for silence at start + end
int resamplesize = buffersize + silience_time * pFormat->nSamplesPerSec;
char *resamplebuffer = new char[ resamplesize + 4 ];
memset( resamplebuffer, (unsigned char)128, resamplesize + 4 );
int startpos = (int)( start_silence * pFormat->nSamplesPerSec );
if ( startpos > 0 )
{
WriteBrownNoise( resamplebuffer, startpos );
}
if ( startpos + buffersize < resamplesize )
{
WriteBrownNoise( &resamplebuffer[ startpos + buffersize ], resamplesize - ( startpos + buffersize ) );
}
memcpy( &resamplebuffer[ startpos ], buffer, buffersize );
store.ChunkWriteData( resamplebuffer, resamplesize );
return;
}
store.ChunkWriteData( buffer, buffersize );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::ReadLinguisticTags( void )
{
if ( !m_pWaveFile )
return;
CAudioSource *wave = sound->LoadSound( m_WorkFile.m_szWorkingFile );
if ( !wave )
return;
m_Tags.Reset();
CSentence *sentence = wave->GetSentence();
if ( sentence )
{
// Copy data from sentence to m_Tags
m_Tags.Reset();
m_Tags = *sentence;
}
delete wave;
}
//-----------------------------------------------------------------------------
// Purpose: Switch wave files
// Input : *wavefile -
// force -
//-----------------------------------------------------------------------------
void PhonemeEditor::SetCurrentWaveFile( const char *wavefile, bool force /*=false*/, CChoreoEvent *event /*=NULL*/ )
{
// No change?
if ( !force && !stricmp( m_WorkFile.m_szWaveFile, wavefile ) )
return;
StopPlayback();
if ( GetDirty() )
{
int retval = mxMessageBox( this, va( "Save current changes to %s", m_WorkFile.m_szWaveFile ),
"Phoneme Editor", MX_MB_QUESTION | MX_MB_YESNOCANCEL );
// Cancel
if ( retval == 2 )
return;
// Yes
if ( retval == 0 )
{
CommitChanges();
}
}
ClearExtracted();
m_Tags.Reset();
m_TagsExt.Reset();
Deselect();
if ( m_pWaveFile )
{
char fn[ 512 ];
Q_snprintf( fn, sizeof( fn ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
filesystem->RemoveFile( fn, "GAME" );
}
delete m_pWaveFile;
m_pWaveFile = NULL;
SetDirty( false );
// Set up event and scene
m_pEvent = event;
// Try an dload new sound
m_pWaveFile = sound->LoadSound( wavefile );
Q_strncpy( m_WorkFile.m_szWaveFile, wavefile, sizeof( m_WorkFile.m_szWaveFile ) );
char fullpath[ 512 ];
filesystem->RelativePathToFullPath( wavefile, "GAME", fullpath, sizeof( fullpath ) );
int len = Q_strlen( fullpath );
int charstocopy = len - Q_strlen( wavefile ) + 1;
m_WorkFile.m_szBasePath[ 0 ] = 0;
if ( charstocopy >= 0 )
{
Q_strncpy( m_WorkFile.m_szBasePath, fullpath, charstocopy );
m_WorkFile.m_szBasePath[ charstocopy ] = 0;
}
Q_StripExtension( wavefile, m_WorkFile.m_szWorkingFile, sizeof( m_WorkFile.m_szWorkingFile ) );
Q_strncat( m_WorkFile.m_szWorkingFile, "_work.wav", sizeof( m_WorkFile.m_szWorkingFile ), COPY_ALL_CHARACTERS );
Q_FixSlashes( m_WorkFile.m_szWaveFile );
Q_FixSlashes( m_WorkFile.m_szWorkingFile );
Q_FixSlashes( m_WorkFile.m_szBasePath );
if ( !m_pWaveFile )
{
Con_ErrorPrintf( "Couldn't set current .wav file to %s\n", m_WorkFile.m_szWaveFile );
return;
}
Con_Printf( "Current .wav file set to %s\n", m_WorkFile.m_szWaveFile );
g_pWaveBrowser->SetCurrent( m_WorkFile.m_szWaveFile );
// Copy over and overwrite file
FPCopyFile( m_WorkFile.m_szWaveFile, m_WorkFile.m_szWorkingFile, false );
// Make it writable
MakeFileWriteable( m_WorkFile.m_szWorkingFile );
ReadLinguisticTags();
Deselect();
RepositionHSlider();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : x -
//-----------------------------------------------------------------------------
void PhonemeEditor::MoveTimeSliderToPos( int x )
{
m_nLeftOffset = x;
m_pHorzScrollBar->setValue( m_nLeftOffset );
InvalidateRect( (HWND)m_pHorzScrollBar->getHandle(), NULL, TRUE );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int PhonemeEditor::ComputeHPixelsNeeded( void )
{
int pixels = 0;
if ( m_pWaveFile )
{
float maxtime = m_pWaveFile->GetRunningLength();
maxtime += 1.0f;
pixels = (int)( maxtime * GetPixelsPerSecond() );
}
return pixels;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::RepositionHSlider( void )
{
int pixelsneeded = ComputeHPixelsNeeded();
if ( pixelsneeded <= w2() )
{
m_pHorzScrollBar->setVisible( false );
}
else
{
m_pHorzScrollBar->setVisible( true );
}
m_pHorzScrollBar->setBounds( 0, GetCaptionHeight(), w2(), 12 );
m_pHorzScrollBar->setRange( 0, pixelsneeded );
m_pHorzScrollBar->setValue( 0 );
m_nLeftOffset = 0;
m_pHorzScrollBar->setPagesize( w2() );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float PhonemeEditor::GetPixelsPerSecond( void )
{
return m_flPixelsPerSecond * GetTimeZoomScale();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float PhonemeEditor::GetTimeZoomScale( void )
{
return ( float )m_nTimeZoom / 100.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : scale -
//-----------------------------------------------------------------------------
void PhonemeEditor::SetTimeZoomScale( int scale )
{
m_nTimeZoom = scale;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dt -
//-----------------------------------------------------------------------------
void PhonemeEditor::Think( float dt )
{
if ( !m_pWaveFile )
return;
bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
ScrubThink( dt, scrubbing );
if ( m_pMixer && !sound->IsSoundPlaying( m_pMixer ) )
{
m_pMixer = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
int PhonemeEditor::IsMouseOverBoundary( mxEvent *event )
{
int mx, my;
mx = (short)event->x;
my = (short)event->y;
// Deterime if phoneme boundary is under the cursor
//
if ( !m_pWaveFile )
return BOUNDARY_NONE;
if ( !(event->modifiers & mxEvent::KeyCtrl ) )
{
return BOUNDARY_NONE;
}
RECT rc;
GetWorkspaceRect( rc );
if ( IsMouseOverPhonemeRow( my ) )
{
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
int mouse_tolerance = 3;
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
for ( int k = 0; k < word->m_Phonemes.Size(); k++ )
{
CPhonemeTag *pPhoneme = word->m_Phonemes[ k ];
float t1 = pPhoneme->GetStartTime();
float t2 = pPhoneme->GetEndTime();
// Tag it
float frac1 = ( t1 - starttime ) / ( endtime - starttime );
float frac2 = ( t2 - starttime ) / ( endtime - starttime );
int xpos1 = ( int )( frac1 * w2() );
int xpos2 = ( int )( frac2 * w2() );
if ( abs( xpos1 - mx ) <= mouse_tolerance ||
abs( xpos2 - mx ) <= mouse_tolerance )
{
return BOUNDARY_PHONEME;
}
}
}
}
if ( IsMouseOverWordRow( my ) )
{
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
int mouse_tolerance = 3;
for ( int k = 0; k < m_Tags.m_Words.Size(); k++ )
{
CWordTag *word = m_Tags.m_Words[ k ];
float t1 = word->m_flStartTime;
float t2 = word->m_flEndTime;
// Tag it
float frac1 = ( t1 - starttime ) / ( endtime - starttime );
float frac2 = ( t2 - starttime ) / ( endtime - starttime );
int xpos1 = ( int )( frac1 * w2() );
int xpos2 = ( int )( frac2 * w2() );
if ( ( abs( xpos1 - mx ) <= mouse_tolerance ) ||
( abs( xpos2 - mx ) <= mouse_tolerance ) )
{
return BOUNDARY_WORD;
}
}
}
return BOUNDARY_NONE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::DrawFocusRect( char *reason )
{
HDC dc = GetDC( NULL );
for ( int i = 0; i < m_FocusRects.Size(); i++ )
{
RECT rc = m_FocusRects[ i ].m_rcFocus;
::DrawFocusRect( dc, &rc );
}
ReleaseDC( NULL, dc );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &rc -
//-----------------------------------------------------------------------------
void PhonemeEditor::GetWorkspaceRect( RECT &rc )
{
GetClientRect( (HWND)getHandle(), &rc );
rc.top += TAG_BOTTOM;
rc.bottom = rc.bottom - 75 - MODE_TAB_OFFSET;
InflateRect( &rc, -1, -1 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void PhonemeEditor::ShowWordMenu( CWordTag *word, int mx, int my )
{
CountSelected();
mxPopupMenu *pop = new mxPopupMenu();
Assert( pop );
pop->add( va( "Edit sentence text..." ), IDC_EDITWORDLIST );
if ( m_nSelectedWordCount > 0 && word )
{
pop->addSeparator();
pop->add( va( "Delete %s", m_nSelectedWordCount > 1 ? "words" : va( "'%s'", word->GetWord() ) ), IDC_EDIT_DELETEWORD );
if ( m_nSelectedWordCount == 1 )
{
int index = IndexOfWord( word );
bool valid = false;
if ( index != -1 )
{
SetClickedPhoneme( index, -1 );
valid = true;
}
if ( valid )
{
pop->add( va( "Edit word '%s'...", word->GetWord() ), IDC_EDIT_WORD );
float nextGap = GetTimeGapToNextWord( true, word );
float prevGap = GetTimeGapToNextWord( false, word );
if ( nextGap > MINIMUM_WORD_GAP ||
prevGap > MINIMUM_WORD_GAP )
{
pop->addSeparator();
if ( prevGap > MINIMUM_WORD_GAP )
{
pop->add( va( "Insert word before '%s'...", word->GetWord() ), IDC_EDIT_INSERTWORDBEFORE );
}
if ( nextGap > MINIMUM_WORD_GAP )
{
pop->add( va( "Insert word after '%s'...", word->GetWord() ), IDC_EDIT_INSERTWORDAFTER );
}
}
if ( word->m_Phonemes.Size() == 0 )
{
pop->addSeparator();
pop->add( va( "Add phoneme to '%s'...", word->GetWord() ), IDC_EDIT_INSERTFIRSTPHONEMEOFWORD );
}
pop->addSeparator();
pop->add( va( "Select all words after '%s'", word->GetWord() ), IDC_SELECT_WORDSRIGHT );
pop->add( va( "Select all words before '%s'", word->GetWord() ), IDC_SELECT_WORDSLEFT );
}
}
}
if ( AreSelectedWordsContiguous() && m_nSelectedWordCount > 1 )
{
pop->addSeparator();
pop->add( va( "Merge words" ), IDC_SNAPWORDS );
if ( m_nSelectedWordCount == 2 )
{
pop->add( va( "Separate words" ), IDC_SEPARATEWORDS );
}
}
if ( m_nSelectedWordCount > 0 )
{
pop->addSeparator();
pop->add( va( "Deselect all" ), IDC_DESELECT_PHONEMESANDWORDS );
}
if ( m_Tags.m_Words.Size() > 0 )
{
pop->addSeparator();
pop->add( va( "Cleanup words/phonemes" ), IDC_CLEANUP );
}
if ( m_Tags.m_Words.Size() > 0 )
{
pop->addSeparator();
pop->add( va( "Realign phonemes to words" ), IDC_REALIGNPHONEMES );
}
pop->popup( this, mx, my );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void PhonemeEditor::ShowPhonemeMenu( CPhonemeTag *pho, int mx, int my )
{
CountSelected();
SetClickedPhoneme( -1, -1 );
if ( !pho )
return;
if ( m_Tags.CountPhonemes() == 0 )
{
Con_Printf( "No phonemes, try extracting from .wav first\n" );
return;
}
mxPopupMenu *pop = new mxPopupMenu();
bool valid = false;
CWordTag *tag = m_Tags.GetWordForPhoneme( pho );
if ( tag )
{
int wordNum = IndexOfWord( tag );
int pi = tag->IndexOfPhoneme( pho );
SetClickedPhoneme( wordNum, pi );
valid = true;
}
if ( valid )
{
if ( m_nSelectedPhonemeCount == 1 )
{
pop->add( va( "Edit '%s'...", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_EDIT_PHONEME );
float nextGap = GetTimeGapToNextPhoneme( true, pho );
float prevGap = GetTimeGapToNextPhoneme( false, pho );
if ( nextGap > MINIMUM_PHONEME_GAP ||
prevGap > MINIMUM_PHONEME_GAP )
{
pop->addSeparator();
if ( prevGap > MINIMUM_PHONEME_GAP )
{
pop->add( va( "Insert phoneme before '%s'...", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_EDIT_INSERTPHONEMEBEFORE );
}
if ( nextGap > MINIMUM_PHONEME_GAP )
{
pop->add( va( "Insert phoneme after '%s'...", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_EDIT_INSERTPHONEMEAFTER );
}
}
pop->addSeparator();
pop->add( va( "Select all phonemes after '%s'", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_SELECT_PHONEMESRIGHT );
pop->add( va( "Select all phonemes before '%s'",ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_SELECT_PHONEMESLEFT );
pop->addSeparator();
}
if ( AreSelectedPhonemesContiguous() && m_nSelectedPhonemeCount > 1 )
{
pop->add( va( "Merge phonemes" ), IDC_SNAPPHONEMES );
if ( m_nSelectedPhonemeCount == 2 )
{
pop->add( va( "Separate phonemes" ), IDC_SEPARATEPHONEMES );
}
pop->addSeparator();
}
if ( m_nSelectedPhonemeCount >= 1 )
{
pop->add( va( "Delete %s",
m_nSelectedPhonemeCount == 1 ? va( "'%s'", ConvertPhoneme( pho->GetPhonemeCode() ) ) : "phonemes" ), IDC_EDIT_DELETEPHONEME );
pop->addSeparator();
pop->add( va( "Deselect all" ), IDC_DESELECT_PHONEMESANDWORDS );
}
}
if ( m_Tags.m_Words.Size() > 0 )
{
pop->addSeparator();
pop->add( va( "Cleanup words/phonemes" ), IDC_CLEANUP );
}
if ( m_Tags.m_Words.Size() > 0 )
{
pop->addSeparator();
pop->add( va( "Realign words to phonemes" ), IDC_REALIGNWORDS );
}
pop->popup( this, mx, my );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// Output : float
//-----------------------------------------------------------------------------
float PhonemeEditor::GetTimeForPixel( int mx )
{
RECT rc;
GetWorkspaceRect( rc );
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float time = (float)mx / GetPixelsPerSecond() + starttime;
return time;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
// **pp1 -
// **pp2 -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::FindSpanningPhonemes( float time, CPhonemeTag **pp1, CPhonemeTag **pp2 )
{
Assert( pp1 && pp2 );
*pp1 = NULL;
*pp2 = NULL;
// Three pixels
double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 3;
CPhonemeTag *previous = NULL;
for ( int w = 0; w < m_Tags.m_Words.Size(); w++ )
{
CWordTag *word = m_Tags.m_Words[ w ];
for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
{
CPhonemeTag *current = word->m_Phonemes[ i ];
double dt;
if ( !previous )
{
dt = fabs( current->GetStartTime() - time );
if ( dt < time_epsilon )
{
*pp2 = current;
return true;
}
}
else
{
int found = 0;
dt = fabs( previous->GetEndTime() - time );
if ( dt < time_epsilon )
{
*pp1 = previous;
found++;
}
dt = fabs( current->GetStartTime() - time );
if ( dt < time_epsilon )
{
*pp2 = current;
found++;
}
if ( found != 0 )
{
return true;
}
}
previous = current;
}
}
if ( m_Tags.m_Words.Size() > 0 )
{
// Check last word, but only if it has some phonemes
CWordTag *lastWord = m_Tags.m_Words[ m_Tags.m_Words.Size() - 1 ];
if ( lastWord &&
( lastWord->m_Phonemes.Size() > 0 ) )
{
CPhonemeTag *last = lastWord->m_Phonemes[ lastWord->m_Phonemes.Size() - 1 ];
float dt;
dt = fabs( last->GetEndTime() - time );
if ( dt < time_epsilon )
{
*pp1 = last;
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
// **pp1 -
// **pp2 -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::FindSpanningWords( float time, CWordTag **pp1, CWordTag **pp2 )
{
Assert( pp1 && pp2 );
*pp1 = NULL;
*pp2 = NULL;
// Three pixels
double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 3;
CWordTag *previous = NULL;
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *current = m_Tags.m_Words[ i ];
double dt;
if ( !previous )
{
dt = fabs( current->m_flStartTime - time );
if ( dt < time_epsilon )
{
*pp2 = current;
return true;
}
}
else
{
int found = 0;
dt = fabs( previous->m_flEndTime - time );
if ( dt < time_epsilon )
{
*pp1 = previous;
found++;
}
dt = fabs( current->m_flStartTime - time );
if ( dt < time_epsilon )
{
*pp2 = current;
found++;
}
if ( found != 0 )
{
return true;
}
}
previous = current;
}
if ( m_Tags.m_Words.Size() > 0 )
{
CWordTag *last = m_Tags.m_Words[ m_Tags.m_Words.Size() - 1 ];
float dt;
dt = fabs( last->m_flEndTime - time );
if ( dt < time_epsilon )
{
*pp1 = last;
return true;
}
}
return false;
}
int PhonemeEditor::FindWordForTime( float time )
{
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *pCurrent = m_Tags.m_Words[ i ];
if ( time < pCurrent->m_flStartTime )
continue;
if ( time > pCurrent->m_flEndTime )
continue;
return i;
}
return -1;
}
void PhonemeEditor::FinishWordDrag( int startx, int endx )
{
float clicktime = GetTimeForPixel( startx );
float endtime = GetTimeForPixel( endx );
float dt = endtime - clicktime;
SetDirty( true );
PushUndo();
TraverseWords( &PhonemeEditor::ITER_MoveSelectedWords, dt );
RealignPhonemesToWords( false );
CleanupWordsAndPhonemes( false );
PushRedo();
redraw();
}
void PhonemeEditor::FinishWordMove( int startx, int endx )
{
float clicktime = GetTimeForPixel( startx );
float endtime = GetTimeForPixel( endx );
// Find the phonemes who have the closest start/endtime to the starting click time
CWordTag *current, *next;
if ( !FindSpanningWords( clicktime, &current, &next ) )
{
return;
}
SetDirty( true );
PushUndo();
if ( current && !next )
{
// cap movement
current->m_flEndTime += ( endtime - clicktime );
}
else if ( !current && next )
{
// cap movement
next->m_flStartTime += ( endtime - clicktime );
}
else
{
// cap movement
endtime = min( endtime, next->m_flEndTime - 1.0f / GetPixelsPerSecond() );
endtime = max( endtime, current->m_flStartTime + 1.0f / GetPixelsPerSecond() );
current->m_flEndTime = endtime;
next->m_flStartTime = endtime;
}
RealignPhonemesToWords( false );
CleanupWordsAndPhonemes( false );
PushRedo();
redraw();
}
CPhonemeTag *PhonemeEditor::FindPhonemeForTime( float time )
{
for ( int w = 0 ; w < m_Tags.m_Words.Size(); w++ )
{
CWordTag *word = m_Tags.m_Words[ w ];
for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
{
CPhonemeTag *pCurrent = word->m_Phonemes[ i ];
if ( time < pCurrent->GetStartTime() )
continue;
if ( time > pCurrent->GetEndTime() )
continue;
return pCurrent;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : phoneme -
// startx -
// endx -
//-----------------------------------------------------------------------------
void PhonemeEditor::FinishPhonemeDrag( int startx, int endx )
{
float clicktime = GetTimeForPixel( startx );
float endtime = GetTimeForPixel( endx );
float dt = endtime - clicktime;
SetDirty( true );
PushUndo();
TraversePhonemes( &PhonemeEditor::ITER_MoveSelectedPhonemes, dt );
RealignWordsToPhonemes( false );
CleanupWordsAndPhonemes( false );
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : phoneme -
// startx -
// endx -
//-----------------------------------------------------------------------------
void PhonemeEditor::FinishPhonemeMove( int startx, int endx )
{
float clicktime = GetTimeForPixel( startx );
float endtime = GetTimeForPixel( endx );
// Find the phonemes who have the closest start/endtime to the starting click time
CPhonemeTag *current, *next;
if ( !FindSpanningPhonemes( clicktime, &current, &next ) )
{
return;
}
SetDirty( true );
PushUndo();
if ( current && !next )
{
// cap movement
current->AddEndTime( endtime - clicktime );
}
else if ( !current && next )
{
// cap movement
next->AddStartTime( endtime - clicktime );
}
else
{
// cap movement
endtime = min( endtime, next->GetEndTime() - 1.0f / GetPixelsPerSecond() );
endtime = max( endtime, current->GetStartTime() + 1.0f / GetPixelsPerSecond() );
current->SetEndTime( endtime );
next->SetStartTime( endtime );
}
RealignWordsToPhonemes( false );
CleanupWordsAndPhonemes( false );
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dirty -
//-----------------------------------------------------------------------------
void PhonemeEditor::SetDirty( bool dirty, bool clearundo /*=true*/ )
{
m_WorkFile.m_bDirty = dirty;
if ( !dirty && clearundo )
{
WipeUndo();
redraw();
}
SetPrefix( dirty ? "* " : "" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::GetDirty( void )
{
return m_WorkFile.m_bDirty;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditInsertPhonemeBefore( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CPhonemeTag *cp = GetSelectedPhoneme();
if ( !cp )
return;
float gap = GetTimeGapToNextPhoneme( false, cp );
if ( gap < MINIMUM_PHONEME_GAP )
{
Con_Printf( "Can't insert before, gap of %.2f ms is too small\n", 1000.0f * gap );
return;
}
// Don't have really long phonemes
gap = min( gap, DEFAULT_PHONEME_LENGTH );
CWordTag *word = m_Tags.GetWordForPhoneme( cp );
if ( !word )
{
Con_Printf( "EditInsertPhonemeBefore: phoneme not a member of any known word!!!\n" );
return;
}
int clicked = word->IndexOfPhoneme( cp );
if ( clicked < 0 )
{
Con_Printf( "EditInsertPhonemeBefore: phoneme not a member of any specified word!!!\n" );
Assert( 0 );
return;
}
CPhonemeTag phoneme;
CPhonemeParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
strcpy( params.m_szName, "" );
int iret = PhonemeProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
SetDirty( true );
PushUndo();
phoneme.SetPhonemeCode( TextToPhoneme( params.m_szName ) );
phoneme.SetTag( params.m_szName );
phoneme.SetEndTime( cp->GetStartTime() );
phoneme.SetStartTime( cp->GetStartTime() - gap );
phoneme.m_bSelected = true;
cp->m_bSelected = false;
word->m_Phonemes.InsertBefore( clicked, new CPhonemeTag( phoneme ) );
PushRedo();
// Add it
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditInsertPhonemeAfter( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CPhonemeTag *cp = GetSelectedPhoneme();
if ( !cp )
return;
float gap = GetTimeGapToNextPhoneme( true, cp );
if ( gap < MINIMUM_PHONEME_GAP )
{
Con_Printf( "Can't insert after, gap of %.2f ms is too small\n", 1000.0f * gap );
return;
}
// Don't have really long phonemes
gap = min( gap, DEFAULT_PHONEME_LENGTH );
CWordTag *word = m_Tags.GetWordForPhoneme( cp );
if ( !word )
{
Con_Printf( "EditInsertPhonemeAfter: phoneme not a member of any known word!!!\n" );
return;
}
int clicked = word->IndexOfPhoneme( cp );
if ( clicked < 0 )
{
Con_Printf( "EditInsertPhonemeAfter: phoneme not a member of any specified word!!!\n" );
Assert( 0 );
return;
}
CPhonemeTag phoneme;
CPhonemeParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
strcpy( params.m_szName, "" );
int iret = PhonemeProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
SetDirty( true );
PushUndo();
phoneme.SetPhonemeCode( TextToPhoneme( params.m_szName ) );
phoneme.SetTag( params.m_szName );
phoneme.SetEndTime( cp->GetEndTime() + gap );
phoneme.SetStartTime( cp->GetEndTime() );
phoneme.m_bSelected = true;
cp->m_bSelected = false;
word->m_Phonemes.InsertAfter( clicked, new CPhonemeTag( phoneme ) );
PushRedo();
// Add it
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditInsertWordBefore( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CWordTag *cw = GetSelectedWord();
if ( !cw )
return;
float gap = GetTimeGapToNextWord( false, cw );
if ( gap < MINIMUM_WORD_GAP )
{
Con_Printf( "Can't insert before, gap of %.2f ms is too small\n", 1000.0f * gap );
return;
}
// Don't have really long words
gap = min( gap, DEFAULT_WORD_LENGTH );
int clicked = IndexOfWord( cw );
if ( clicked < 0 )
{
Con_Printf( "EditInsertWordBefore: word not in sentence!!!\n" );
Assert( 0 );
return;
}
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Insert Word" );
strcpy( params.m_szPrompt, "Word:" );
strcpy( params.m_szInputText, "" );
params.m_nLeft = -1;
params.m_nTop = -1;
params.m_bPositionDialog = true;
if ( params.m_bPositionDialog )
{
RECT rcWord;
GetWordRect( cw, rcWord );
// Convert to screen coords
POINT pt;
pt.x = rcWord.left;
pt.y = rcWord.top;
ClientToScreen( (HWND)getHandle(), &pt );
params.m_nLeft = pt.x;
params.m_nTop = pt.y;
}
int iret = InputProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
if ( strlen( params.m_szInputText ) <= 0 )
{
return;
}
int wordCount = CSentence::CountWords( params.m_szInputText );
if ( wordCount > 1 )
{
Con_Printf( "Can only insert one word at a time, %s has %i words in it!\n",
params.m_szInputText, wordCount );
return;
}
SetDirty( true );
PushUndo();
CWordTag newword;
newword.SetWord( params.m_szInputText );
newword.m_flEndTime = cw->m_flStartTime;
newword.m_flStartTime = cw->m_flStartTime - gap;
newword.m_bSelected = true;
cw->m_bSelected = false;
m_Tags.m_Words.InsertBefore( clicked, new CWordTag( newword ) );
PushRedo();
// Add it
redraw();
// Jump to phoneme insertion UI
EditInsertFirstPhonemeOfWord();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditInsertWordAfter( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CWordTag *cw = GetSelectedWord();
if ( !cw )
return;
float gap = GetTimeGapToNextWord( true, cw );
if ( gap < MINIMUM_WORD_GAP )
{
Con_Printf( "Can't insert after, gap of %.2f ms is too small\n", 1000.0f * gap );
return;
}
// Don't have really long words
gap = min( gap, DEFAULT_WORD_LENGTH );
int clicked = IndexOfWord( cw );
if ( clicked < 0 )
{
Con_Printf( "EditInsertWordBefore: word not in sentence!!!\n" );
Assert( 0 );
return;
}
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Insert Word" );
strcpy( params.m_szPrompt, "Word:" );
strcpy( params.m_szInputText, "" );
params.m_nLeft = -1;
params.m_nTop = -1;
params.m_bPositionDialog = true;
if ( params.m_bPositionDialog )
{
RECT rcWord;
GetWordRect( cw, rcWord );
// Convert to screen coords
POINT pt;
pt.x = rcWord.left;
pt.y = rcWord.top;
ClientToScreen( (HWND)getHandle(), &pt );
params.m_nLeft = pt.x;
params.m_nTop = pt.y;
}
int iret = InputProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
if ( strlen( params.m_szInputText ) <= 0 )
{
return;
}
int wordCount = CSentence::CountWords( params.m_szInputText );
if ( wordCount > 1 )
{
Con_Printf( "Can only insert one word at a time, %s has %i words in it!\n",
params.m_szInputText, wordCount );
return;
}
SetDirty( true );
PushUndo();
CWordTag newword;
newword.SetWord( params.m_szInputText );
newword.m_flEndTime = cw->m_flEndTime + gap;
newword.m_flStartTime = cw->m_flEndTime;
newword.m_bSelected = true;
cw->m_bSelected = false;
CWordTag *w = new CWordTag( newword );
Assert( w );
if ( w )
{
m_Tags.m_Words.InsertAfter( clicked, w );
}
PushRedo();
// Add it
redraw();
EditInsertFirstPhonemeOfWord();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditDeletePhoneme( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedPhonemeCount < 1 )
{
return;
}
SetDirty( true );
PushUndo();
for ( int i = m_Tags.m_Words.Size() - 1; i >= 0; i-- )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = word->m_Phonemes.Size() - 1; j >= 0; j-- )
{
CPhonemeTag *p = word->m_Phonemes[ j ];
if ( !p || !p->m_bSelected )
continue;
// Delete it
word->m_Phonemes.Remove( j );
}
}
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditDeleteWord( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedWordCount < 1 )
{
return;
}
SetDirty( true );
PushUndo();
for ( int i = m_Tags.m_Words.Size() - 1; i >= 0; i-- )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word || !word->m_bSelected )
continue;
m_Tags.m_Words.Remove( i );
}
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::PlayEditedWave( bool selection /* = false */ )
{
StopPlayback();
if ( !m_pWaveFile )
return;
// Make sure phonemes are loaded
FacePoser_EnsurePhonemesLoaded();
SaveLinguisticData();
SetScrubTime( 0.0f );
SetScrubTargetTime( m_pWaveFile->GetRunningLength() );
}
typedef struct channel_s
{
int leftvol;
int rightvol;
int rleftvol;
int rrightvol;
float pitch;
} channel_t;
bool PhonemeEditor::CreateCroppedWave( char const *filename, int startsample, int endsample )
{
Assert( sound );
CAudioWaveOutput *pWaveOutput = ( CAudioWaveOutput * )sound->GetAudioOutput();
if ( !pWaveOutput )
return false;
CAudioSource *wave = sound->LoadSound( m_WorkFile.m_szWaveFile );
if ( !wave )
return false;
CAudioMixer *pMixer = wave->CreateMixer();
if ( !pMixer )
return false;
// Create out put file
OutFileRIFF riffout( filename, io_out );
// Create output iterator
IterateOutputRIFF store( riffout );
WAVEFORMATEX format;
format.cbSize = sizeof( format );
format.wFormatTag = WAVE_FORMAT_PCM;
format.nAvgBytesPerSec = (int)wave->SampleRate();
format.nChannels = 1;
format.wBitsPerSample = 8;
format.nSamplesPerSec = (int)wave->SampleRate();
format.nBlockAlign = 1; // (int)wave->SampleSize();
store.ChunkWrite( WAVE_FMT, &format, sizeof( format ) );
// Pull in data and write it out
int currentsample = 0;
store.ChunkStart( WAVE_DATA );
// need a bit of space
short samples[ 2 ];
channel_t channel;
channel.leftvol = 255;
channel.rightvol = 255;
channel.pitch = 1.0;
while ( 1 )
{
pWaveOutput->m_audioDevice.MixBegin();
if ( !pMixer->MixDataToDevice( &pWaveOutput->m_audioDevice, &channel, currentsample, 1, wave->SampleRate(), true ) )
break;
pWaveOutput->m_audioDevice.TransferBufferStereo16( samples, 1 );
currentsample = pMixer->GetSamplePosition();
if ( currentsample >= startsample && currentsample <= endsample )
{
// left + right (2 channels ) * 16 bits
float s1 = (float)( samples[ 0 ] >> 8 );
float s2 = (float)( samples[ 1 ] >> 8 );
float avg = ( s1 + s2 ) / 2.0f;
unsigned char chopped = (unsigned char)( avg + 127.0f );
store.ChunkWriteData( &chopped, sizeof( byte ) );
}
}
store.ChunkFinish();
delete pMixer;
delete wave;
return true;
}
void PhonemeEditor::SentenceFromString( CSentence& sentence, char const *str )
{
sentence.Reset();
if ( !str || !str[0] || CSentence::CountWords( str ) == 0 )
{
return;
}
char word[ 256 ];
unsigned char const *in = (unsigned char *)str;
char *out = word;
while ( *in )
{
if ( *in > 32 )
{
*out++ = *in++;
}
else
{
*out = 0;
while ( *in && *in <= 32 )
{
in++;
}
if ( strlen( word ) > 0 )
{
CWordTag *w = new CWordTag( (char *)word );
Assert( w );
if ( w )
{
sentence.m_Words.AddToTail( w );
}
}
out = word;
}
}
*out = 0;
if ( strlen( word ) > 0 )
{
CWordTag *w = new CWordTag( (char *)word );
Assert( w );
if ( w )
{
sentence.m_Words.AddToTail( w );
}
}
sentence.SetText( str );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::RedoPhonemeExtractionSelected( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( !CheckSpeechAPI() )
return;
if ( !m_pWaveFile )
{
Con_Printf( "Can't redo extraction, no wavefile loaded!\n" );
Assert( 0 );
return;
}
if ( !m_bSelectionActive )
{
Con_Printf( "Please select a portion of the .wav from which to re-extract phonemes\n" );
return;
}
// Now copy data back into original list, offsetting by samplestart time
float numsamples = m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate();
float selectionstarttime = 0.0f;
if ( numsamples > 0.0f )
{
// Convert sample #'s to time
selectionstarttime = ( m_nSelection[ 0 ] / numsamples ) * m_pWaveFile->GetRunningLength();
selectionstarttime = max( 0.0f, selectionstarttime );
}
else
{
Con_Printf( "Original .wav file %s has no samples!!!\n", m_WorkFile.m_szWaveFile );
return;
}
int i;
// Create input array of just selected words
CSentence m_InputWords;
CSentence m_Results;
CountSelected();
bool usingselection = true;
if ( m_nSelectedWordCount == 0 )
{
// Allow user to type in text
// Build word string
char wordstring[ 1024 ];
strcpy( wordstring, "" );
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Phrase Word List" );
strcpy( params.m_szPrompt, "Phrase" );
strcpy( params.m_szInputText, wordstring );
if ( !InputProperties( &params ) )
return;
if ( strlen( params.m_szInputText ) <= 0 )
{
Con_ErrorPrintf( "Edit word list: No words entered!\n" );
return;
}
SentenceFromString( m_InputWords, params.m_szInputText );
if ( m_InputWords.m_Words.Size() == 0 )
{
Con_Printf( "You must either select words, or type in a set of words in order to extract phonemes!\n" );
return;
}
usingselection = false;
}
else
{
if ( !AreSelectedWordsContiguous() )
{
Con_Printf( "Can only redo extraction on a contiguous subset of words\n" );
return;
}
char temp[ 4096 ];
bool killspace = false;
Q_strncpy( temp, m_InputWords.GetText(), sizeof( temp ) );
// Iterate existing words, looking for contiguous selected words
for ( i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word || !word->m_bSelected )
continue;
// Now add "clean slate" to input list
m_InputWords.m_Words.AddToTail( new CWordTag( *word ) );
Q_strncat( temp, word->GetWord(), sizeof( temp ), COPY_ALL_CHARACTERS );
Q_strncat( temp, " ", sizeof( temp ), COPY_ALL_CHARACTERS );
killspace = true;
}
// Kill terminal space character
int len = Q_strlen( temp );
if ( killspace && ( len >= 1 ) )
{
Assert( temp[ len -1 ] == ' ' );
temp[ len - 1 ] = 0;
}
m_InputWords.SetText( temp );
}
m_nLastExtractionResult = SR_RESULT_NORESULT;
char szCroppedFile[ 512 ];
char szBaseFile[ 512 ];
Q_StripExtension( m_WorkFile.m_szWaveFile, szBaseFile, sizeof( szBaseFile ) );
Q_snprintf( szCroppedFile, sizeof( szCroppedFile ), "%s%s_work1.wav", m_WorkFile.m_szBasePath, szBaseFile );
filesystem->RemoveFile( szCroppedFile, "GAME" );
if ( !CreateCroppedWave( szCroppedFile, m_nSelection[ 0 ], m_nSelection[ 1 ] ) )
{
Con_Printf( "Unable to create cropped wave file %s from samples %i to %i\n",
szCroppedFile,
m_nSelection[ 0 ],
m_nSelection[ 1 ] );
return;
}
CAudioSource *m_pCroppedWave = sound->LoadSound( szCroppedFile );
if ( !m_pCroppedWave )
{
Con_Printf( "Unable to load cropped wave file %s from samples %i to %i\n",
szCroppedFile,
m_nSelection[ 0 ],
m_nSelection[ 1 ] );
return;
}
// Save any pending stuff
SaveLinguisticData();
// Store off copy of complete sentence
m_TagsExt = m_Tags;
char filename[ 512 ];
Q_snprintf( filename, sizeof( filename ), "%s%s", m_WorkFile.m_szBasePath, szCroppedFile );
m_nLastExtractionResult = m_pPhonemeExtractor->Extract(
filename,
(int)( m_pCroppedWave->GetRunningLength() * m_pCroppedWave->SampleRate() * m_pCroppedWave->TrueSampleSize() ),
Con_Printf,
m_InputWords,
m_Results );
if ( m_InputWords.m_Words.Size() != m_Results.m_Words.Size() )
{
Con_Printf( "Extraction returned %i words, source had %i, try adjusting selection\n",
m_Results.m_Words.Size(), m_InputWords.m_Words.Size() );
filesystem->RemoveFile( filename, "GAME" );
redraw();
return;
}
float bytespersecond = m_pCroppedWave->SampleRate() * m_pCroppedWave->TrueSampleSize();
// Tracker 57389:
// Total hack to fix a bug where the Lipsinc extractor is messing up the # channels on 16 bit stereo waves
if ( m_pPhonemeExtractor->GetAPIType() == SPEECH_API_LIPSINC &&
m_pCroppedWave->IsStereoWav() &&
m_pCroppedWave->SampleSize() == 16 )
{
bytespersecond *= 2.0f;
}
// Now convert byte offsets to times
for ( i = 0; i < m_Results.m_Words.Size(); i++ )
{
CWordTag *tag = m_Results.m_Words[ i ];
Assert( tag );
if ( !tag )
continue;
tag->m_flStartTime = ( float )(tag->m_uiStartByte ) / bytespersecond;
tag->m_flEndTime = ( float )(tag->m_uiEndByte ) / bytespersecond;
for ( int j = 0; j < tag->m_Phonemes.Size(); j++ )
{
CPhonemeTag *ptag = tag->m_Phonemes[ j ];
Assert( ptag );
if ( !ptag )
continue;
ptag->SetStartTime( ( float )(ptag->m_uiStartByte ) / bytespersecond );
ptag->SetEndTime( ( float )(ptag->m_uiEndByte ) / bytespersecond );
}
}
if ( usingselection )
{
// Copy data into m_TagsExt, offseting times by selectionstarttime
CWordTag *from;
CWordTag *to;
int fromWord = 0;
for ( i = 0; i < m_TagsExt.m_Words.Size() ; i++ )
{
to = m_TagsExt.m_Words[ i ];
if ( !to || !to->m_bSelected )
continue;
// Found start of contiguous run
if ( fromWord >= m_Results.m_Words.Size() )
break;
from = m_Results.m_Words[ fromWord++ ];
Assert( from );
if ( !from )
continue;
// Remove all phonemes from destination
while ( to->m_Phonemes.Size() > 0 )
{
CPhonemeTag *p = to->m_Phonemes[ 0 ];
Assert( p );
to->m_Phonemes.Remove( 0 );
delete p;
}
// Now copy phonemes from source
for ( int j = 0; j < from->m_Phonemes.Size(); j++ )
{
CPhonemeTag *fromPhoneme = from->m_Phonemes[ j ];
Assert( fromPhoneme );
if ( !fromPhoneme )
continue;
CPhonemeTag newPhoneme( *fromPhoneme );
// Offset start time
newPhoneme.AddStartTime( selectionstarttime );
newPhoneme.AddEndTime( selectionstarttime );
// Add it back in with corrected timing data
CPhonemeTag *p = new CPhonemeTag( newPhoneme );
Assert( p );
if ( p )
{
to->m_Phonemes.AddToTail( p );
}
}
// Done
if ( fromWord >= m_Results.m_Words.Size() )
break;
}
}
else
{
// Find word just before starting point of selection and
// place input words into list starting that that point
int startWord = 0;
CWordTag *firstWordOfPhrase = m_Results.m_Words[ 0 ];
Assert( firstWordOfPhrase );
for ( ; startWord < m_TagsExt.m_Words.Size(); startWord++ )
{
CWordTag *w = m_TagsExt.m_Words[ startWord ];
Assert( w );
if ( !w )
continue;
if ( w->m_flStartTime > firstWordOfPhrase->m_flStartTime + selectionstarttime )
break;
}
for ( i = 0; i < m_Results.m_Words.Size(); i++ )
{
CWordTag *from = m_Results.m_Words[ i ];
Assert( from );
if ( !from )
continue;
CWordTag *to = new CWordTag( *from );
Assert( to );
to->m_flStartTime += selectionstarttime;
to->m_flEndTime += selectionstarttime;
// Now adjust phoneme times
for ( int j = 0; j < to->m_Phonemes.Size(); j++ )
{
CPhonemeTag *toPhoneme = to->m_Phonemes[ j ];
Assert( toPhoneme );
if ( !toPhoneme )
continue;
// Offset start time
toPhoneme->AddStartTime( selectionstarttime );
toPhoneme->AddEndTime( selectionstarttime );
}
m_TagsExt.m_Words.InsertBefore( startWord++, to );
}
}
Con_Printf( "Cleaning up...\n" );
filesystem->RemoveFile( filename, "GAME" );
SetFocus( (HWND)getHandle() );
redraw();
}
void PhonemeEditor::RedoPhonemeExtraction( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( !CheckSpeechAPI() )
return;
m_nLastExtractionResult = SR_RESULT_NORESULT;
if ( !m_pWaveFile )
return;
SaveLinguisticData();
// Send m_WorkFile.m_szWorkingFile to extractor and retrieve resulting data
//
m_TagsExt.Reset();
Assert( m_pPhonemeExtractor );
char filename[ 512 ];
Q_snprintf( filename, sizeof( filename ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
m_nLastExtractionResult = m_pPhonemeExtractor->Extract(
filename,
(int)( m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() * m_pWaveFile->TrueSampleSize() ),
Con_Printf,
m_Tags,
m_TagsExt );
float bytespersecond = m_pWaveFile->SampleRate() * m_pWaveFile->TrueSampleSize();
// Now convert byte offsets to times
int i;
for ( i = 0; i < m_TagsExt.m_Words.Size(); i++ )
{
CWordTag *tag = m_TagsExt.m_Words[ i ];
Assert( tag );
if ( !tag )
continue;
tag->m_flStartTime = ( float )(tag->m_uiStartByte ) / bytespersecond;
tag->m_flEndTime = ( float )(tag->m_uiEndByte ) / bytespersecond;
for ( int j = 0; j < tag->m_Phonemes.Size(); j++ )
{
CPhonemeTag *ptag = tag->m_Phonemes[ j ];
Assert( ptag );
if ( !ptag )
continue;
ptag->SetStartTime( ( float )(ptag->m_uiStartByte ) / bytespersecond );
ptag->SetEndTime( ( float )(ptag->m_uiEndByte ) / bytespersecond );
}
}
SetFocus( (HWND)getHandle() );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::Deselect( void )
{
m_nSelection[ 0 ] = m_nSelection[ 1 ] = 0;
m_bSelectionActive = false;
}
void PhonemeEditor::ITER_SelectSpanningWords( CWordTag *word, float amount )
{
Assert( word );
word->m_bSelected = false;
if ( !m_bSelectionActive )
return;
if ( !m_pWaveFile )
return;
float numsamples = m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate();
if ( numsamples > 0.0f )
{
// Convert sample #'s to time
float starttime = ( m_nSelection[ 0 ] / numsamples ) * m_pWaveFile->GetRunningLength();
float endtime = ( m_nSelection[ 1 ] / numsamples ) * m_pWaveFile->GetRunningLength();
if ( word->m_flEndTime >= starttime &&
word->m_flStartTime <= endtime )
{
word->m_bSelected = true;
m_bWordsActive = true;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : start -
// end -
//-----------------------------------------------------------------------------
void PhonemeEditor::SelectSamples( int start, int end )
{
if ( !m_pWaveFile )
return;
// Make sure order is correct
if ( end < start )
{
int temp = end;
end = start;
start = temp;
}
Deselect();
m_nSelection[ 0 ] = start;
m_nSelection[ 1 ] = end;
m_bSelectionActive = true;
// Select any words that span the selection
//
TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
redraw();
}
void PhonemeEditor::FinishMoveSelection( int startx, int mx )
{
if ( !m_pWaveFile )
return;
int sampleStart = GetSampleForMouse( startx );
int sampleEnd = GetSampleForMouse( mx );
int delta = sampleEnd - sampleStart;
for ( int i = 0; i < 2; i++ )
{
m_nSelection[ i ] += delta;
}
// Select any words that span the selection
//
TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
redraw();
}
void PhonemeEditor::FinishMoveSelectionStart( int startx, int mx )
{
if ( !m_pWaveFile )
return;
int sampleStart = GetSampleForMouse( startx );
int sampleEnd = GetSampleForMouse( mx );
int delta = sampleEnd - sampleStart;
m_nSelection[ 0 ] += delta;
if ( m_nSelection[ 0 ] >= m_nSelection[ 1 ] )
{
Deselect();
}
// Select any words that span the selection
//
TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
redraw();
}
void PhonemeEditor::FinishMoveSelectionEnd( int startx, int mx )
{
if ( !m_pWaveFile )
return;
int sampleStart = GetSampleForMouse( startx );
int sampleEnd = GetSampleForMouse( mx );
int delta = sampleEnd - sampleStart;
m_nSelection[ 1 ] += delta;
if ( m_nSelection[ 1 ] <= m_nSelection[ 0 ] )
{
Deselect();
}
// Select any words that span the selection
//
TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : startx -
// mx -
//-----------------------------------------------------------------------------
void PhonemeEditor::FinishSelect( int startx, int mx )
{
if ( !m_pWaveFile )
return;
// Don't select really small areas
if ( abs( startx - mx ) < 2 )
return;
int sampleStart = GetSampleForMouse( startx );
int sampleEnd = GetSampleForMouse( mx );
SelectSamples( sampleStart, sampleEnd );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::IsMouseOverSamples( int mx, int my )
{
if ( GetMode() != MODE_PHONEMES )
return false;
// Deterime if phoneme boundary is under the cursor
//
if ( !m_pWaveFile )
return false;
RECT rc;
GetWorkspaceRect( rc );
// Over tag
if ( my >= TAG_TOP && my <= TAG_BOTTOM )
return false;
if ( IsMouseOverPhonemeRow( my ) )
return false;
if ( IsMouseOverWordRow( my ) )
return false;
RECT rcWord;
GetWordTrayTopBottom( rcWord );
RECT rcPhoneme;
GetPhonemeTrayTopBottom( rcPhoneme );
if ( my < rcWord.bottom )
return false;
if ( my > rcPhoneme.top )
return false;
return true;
}
void PhonemeEditor::GetScreenStartAndEndTime( float &starttime, float& endtime )
{
starttime = m_nLeftOffset / GetPixelsPerSecond();
endtime = w2() / GetPixelsPerSecond() + starttime;
}
float PhonemeEditor::GetTimePerPixel( void )
{
RECT rc;
GetWorkspaceRect( rc );
float starttime, endtime;
GetScreenStartAndEndTime( starttime, endtime );
if ( rc.right - rc.left <= 0 )
{
return ( endtime - starttime );
}
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
return timeperpixel;
}
int PhonemeEditor::GetPixelForSample( int sample )
{
RECT rc;
GetWorkspaceRect( rc );
if ( !m_pWaveFile )
return rc.left;
// Determine start/stop positions
int totalsamples = (int)( m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() );
if ( totalsamples <= 0 )
{
return rc.left;
}
float starttime, endtime;
GetScreenStartAndEndTime( starttime, endtime );
float sampleFrac = (float)sample / (float)totalsamples;
float sampleTime = sampleFrac * (float)m_pWaveFile->GetRunningLength();
if ( endtime - starttime < 0.0f )
{
return rc.left;
}
float windowFrac = ( sampleTime - starttime ) / ( endtime - starttime );
return rc.left + (int)( windowFrac * ( rc.right - rc.left ) );
}
int PhonemeEditor::GetSampleForMouse( int mx )
{
if ( !m_pWaveFile )
return 0;
RECT rc;
GetWorkspaceRect( rc );
// Determine start/stop positions
int totalsamples = (int)( m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() );
float starttime, endtime;
GetScreenStartAndEndTime( starttime, endtime );
if ( GetPixelsPerSecond() <= 0 )
return 0;
// Start and end times
float clickTime = (float)mx / GetPixelsPerSecond() + starttime;
// What sample do these correspond to
if ( (float)m_pWaveFile->GetRunningLength() <= 0.0f )
return 0;
int sampleNumber = (int) ( (float)totalsamples * clickTime / (float)m_pWaveFile->GetRunningLength() );
return sampleNumber;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::IsMouseOverSelection( int mx, int my )
{
if ( GetMode() != MODE_PHONEMES )
return false;
if ( !m_pWaveFile )
return false;
if ( !m_bSelectionActive )
return false;
if ( !IsMouseOverSamples( mx, my ) )
return false;
int sampleNumber = GetSampleForMouse( mx );
if ( sampleNumber >= m_nSelection[ 0 ] - 3 &&
sampleNumber <= m_nSelection[ 1 ] + 3 )
{
return true;
}
return false;
}
bool PhonemeEditor::IsMouseOverSelectionStartEdge( mxEvent *event )
{
if ( GetMode() != MODE_PHONEMES )
return false;
if ( !m_pWaveFile )
return false;
int mx, my;
mx = (short)event->x;
my = (short)event->y;
if ( !(event->modifiers & mxEvent::KeyCtrl ) )
return false;
if ( !IsMouseOverSelection( mx, my ) )
return false;
int sample = GetSampleForMouse( mx );
int mouse_tolerance = 5;
RECT rc;
GetWorkspaceRect( rc );
// Determine start/stop positions
float timeperpixel = GetTimePerPixel();
int samplesperpixel = (int)( timeperpixel * m_pWaveFile->SampleRate() );
if ( abs( sample - m_nSelection[ 0 ] ) < mouse_tolerance * samplesperpixel )
{
return true;
}
return false;
}
bool PhonemeEditor::IsMouseOverSelectionEndEdge( mxEvent *event )
{
if ( GetMode() != MODE_PHONEMES )
return false;
if ( !m_pWaveFile )
return false;
int mx, my;
mx = (short)event->x;
my = (short)event->y;
if ( !(event->modifiers & mxEvent::KeyCtrl ) )
return false;
if ( !IsMouseOverSelection( mx, my ) )
return false;
int sample = GetSampleForMouse( mx );
int mouse_tolerance = 5;
RECT rc;
GetWorkspaceRect( rc );
if ( GetPixelsPerSecond() <= 0.0f )
return false;
if ( ( rc.right - rc.left ) <= 0 )
return false;
// Determine start/stop positions
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
int samplesperpixel = (int)( timeperpixel * m_pWaveFile->SampleRate() );
if ( abs( sample - m_nSelection[ 1 ] ) < mouse_tolerance * samplesperpixel )
{
return true;
}
return false;
}
void PhonemeEditor::OnImport()
{
char filename[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( filename, sizeof( filename ), "sound", "*" WORD_DATA_EXTENSION ) )
{
return;
}
ImportValveDataChunk( filename );
}
void PhonemeEditor::OnExport()
{
if ( !m_pWaveFile )
return;
char filename[ 512 ];
if ( !FacePoser_ShowSaveFileNameDialog( filename, sizeof( filename ), "sound", "*" WORD_DATA_EXTENSION ) )
{
return;
}
Q_SetExtension( filename, WORD_DATA_EXTENSION, sizeof( filename ) );
ExportValveDataChunk( filename );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : store -
//-----------------------------------------------------------------------------
void PhonemeEditor::StoreValveDataChunk( IterateOutputRIFF& store )
{
// Buffer and dump data
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
m_Tags.SaveToBuffer( buf );
// Copy into store
store.ChunkWriteData( buf.Base(), buf.TellPut() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *tempfile -
//-----------------------------------------------------------------------------
void PhonemeEditor::ExportValveDataChunk( char const *tempfile )
{
if ( m_Tags.m_Words.Count() <= 0 )
{
Con_ErrorPrintf( "PhonemeEditor::ExportValveDataChunk: Sentence has no word data\n" );
return;
}
FileHandle_t fh = filesystem->Open( tempfile, "wb" );
if ( !fh )
{
Con_ErrorPrintf( "PhonemeEditor::ExportValveDataChunk: Unable to write to %s (read-only?)\n", tempfile );
return;
}
else
{
// Buffer and dump data
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
m_Tags.SaveToBuffer( buf );
filesystem->Write( buf.Base(), buf.TellPut(), fh );
filesystem->Close(fh);
Con_Printf( "Exported %i words to %s\n", m_Tags.m_Words.Count(), tempfile );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *tempfile -
//-----------------------------------------------------------------------------
void PhonemeEditor::ImportValveDataChunk( char const *tempfile )
{
FileHandle_t fh = filesystem->Open( tempfile, "rb" );
if ( !fh )
{
Con_ErrorPrintf( "PhonemeEditor::ImportValveDataChunk: Unable to read from %s\n", tempfile );
return;
}
int len = filesystem->Size( fh );
if ( len <= 4 )
{
Con_ErrorPrintf( "PhonemeEditor::ImportValveDataChunk: File %s has length 0\n", tempfile );
return;
}
ClearExtracted();
unsigned char *buf = new unsigned char[ len + 1 ];
filesystem->Read( buf, len, fh );
filesystem->Close( fh );
m_TagsExt.InitFromDataChunk( (void *)( buf ), len );
delete[] buf;
Con_Printf( "Imported %i words from %s\n", m_TagsExt.m_Words.Count(), tempfile );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose: Copy file over, but update phoneme lump with new data
//-----------------------------------------------------------------------------
void PhonemeEditor::SaveLinguisticData( void )
{
if ( !m_pWaveFile )
return;
InFileRIFF riff( m_WorkFile.m_szWaveFile, io_in );
Assert( riff.RIFFName() == RIFF_WAVE );
// set up the iterator for the whole file (root RIFF is a chunk)
IterateRIFF walk( riff, riff.RIFFSize() );
char fullout[ 512 ];
Q_snprintf( fullout, sizeof( fullout ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
OutFileRIFF riffout( fullout, io_out );
IterateOutputRIFF store( riffout );
bool formatset = false;
WAVEFORMATEX format;
bool wordtrackwritten = false;
// Walk input chunks and copy to output
while ( walk.ChunkAvailable() )
{
unsigned int originalPos = store.ChunkGetPosition();
store.ChunkStart( walk.ChunkName() );
bool skipchunk = false;
switch ( walk.ChunkName() )
{
case WAVE_VALVEDATA:
// Overwrite data
StoreValveDataChunk( store );
wordtrackwritten = true;
break;
case WAVE_FMT:
{
formatset = true;
char *buffer = new char[ walk.ChunkSize() ];
Assert( buffer );
walk.ChunkRead( buffer );
format = *(WAVEFORMATEX *)buffer;
store.ChunkWriteData( buffer, walk.ChunkSize() );
delete[] buffer;
}
break;
case WAVE_DATA:
{
Assert( formatset );
char *buffer = new char[ walk.ChunkSize() ];
Assert( buffer );
walk.ChunkRead( buffer );
// Resample it
ResampleChunk( store, (void *)&format, walk.ChunkName(), buffer, walk.ChunkSize() );
delete[] buffer;
}
break;
default:
store.CopyChunkData( walk );
break;
}
store.ChunkFinish();
if ( skipchunk )
{
store.ChunkSetPosition( originalPos );
}
walk.ChunkNext();
}
if ( !wordtrackwritten )
{
store.ChunkStart( WAVE_VALVEDATA );
StoreValveDataChunk( store );
store.ChunkFinish();
}
}
//-----------------------------------------------------------------------------
// Purpose: Copy phoneme data in from wave file we sent for resprocessing
//-----------------------------------------------------------------------------
void PhonemeEditor::RetrieveLinguisticData( void )
{
if ( !m_pWaveFile )
return;
m_Tags.Reset();
ReadLinguisticTags();
redraw();
}
bool PhonemeEditor::StopPlayback( void )
{
bool bret = false;
if ( m_pWaveFile )
{
SetScrubTargetTime( m_flScrub );
if ( sound->IsSoundPlaying( m_pMixer ) )
{
sound->StopAll();
bret = true;
}
}
sound->Flush();
return bret;
}
CPhonemeTag *PhonemeEditor::GetPhonemeTagUnderMouse( int mx, int my )
{
if ( GetMode() != MODE_PHONEMES )
return NULL;
if ( !m_pWaveFile )
return NULL;
// FIXME: Don't read from file, read from arrays after LISET finishes
// Deterime if phoneme boundary is under the cursor
//
RECT rc;
GetWorkspaceRect( rc );
if ( !IsMouseOverPhonemeRow( my ) )
return NULL;
if ( GetPixelsPerSecond() <= 0 )
return NULL;
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
if ( endtime - starttime <= 0.0f )
return NULL;
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
Assert( word );
if ( !word )
continue;
for ( int k = 0; k < word->m_Phonemes.Size(); k++ )
{
CPhonemeTag *pPhoneme = word->m_Phonemes[ k ];
Assert( pPhoneme );
if ( !pPhoneme )
continue;
float t1 = pPhoneme->GetStartTime();
float t2 = pPhoneme->GetEndTime();
float frac1 = ( t1 - starttime ) / ( endtime - starttime );
float frac2 = ( t2 - starttime ) / ( endtime - starttime );
frac1 = min( 1.0f, frac1 );
frac1 = max( 0.0f, frac1 );
frac2 = min( 1.0f, frac2 );
frac2 = max( 0.0f, frac2 );
if ( frac1 == frac2 )
continue;
int x1 = ( int )( frac1 * w2() );
int x2 = ( int )( frac2 * w2() );
if ( mx >= x1 && mx <= x2 )
{
return pPhoneme;
}
}
}
return NULL;
}
CWordTag *PhonemeEditor::GetWordTagUnderMouse( int mx, int my )
{
if ( GetMode() != MODE_PHONEMES )
return NULL;
// Deterime if phoneme boundary is under the cursor
//
if ( !m_pWaveFile )
return NULL;
RECT rc;
GetWorkspaceRect( rc );
if ( !IsMouseOverWordRow( my ) )
return NULL;
if ( GetPixelsPerSecond() <= 0 )
return NULL;
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
if ( endtime - starttime <= 0.0f )
return NULL;
for ( int k = 0; k < m_Tags.m_Words.Size(); k++ )
{
CWordTag *word = m_Tags.m_Words[ k ];
Assert( word );
if ( !word )
continue;
float t1 = word->m_flStartTime;
float t2 = word->m_flEndTime;
float frac1 = ( t1 - starttime ) / ( endtime - starttime );
float frac2 = ( t2 - starttime ) / ( endtime - starttime );
frac1 = min( 1.0f, frac1 );
frac1 = max( 0.0f, frac1 );
frac2 = min( 1.0f, frac2 );
frac2 = max( 0.0f, frac2 );
if ( frac1 == frac2 )
continue;
int x1 = ( int )( frac1 * w2() );
int x2 = ( int )( frac2 * w2() );
if ( mx >= x1 && mx <= x2 )
{
return word;
}
}
return NULL;
}
void PhonemeEditor::DeselectWords( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
for ( int i = 0 ; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *w = m_Tags.m_Words[ i ];
Assert( w );
if ( !w )
continue;
w->m_bSelected = false;
}
}
void PhonemeEditor::DeselectPhonemes( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
for ( int w = 0 ; w < m_Tags.m_Words.Size(); w++ )
{
CWordTag *word = m_Tags.m_Words[ w ];
Assert( word );
if ( !word )
continue;
for ( int i = 0 ; i < word->m_Phonemes.Size(); i++ )
{
CPhonemeTag *pt = word->m_Phonemes[ i ];
Assert( pt );
if ( !pt )
continue;
pt->m_bSelected = false;
}
}
}
void PhonemeEditor::SnapWords( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( m_Tags.m_Words.Size() < 2 )
{
Con_Printf( "Can't snap, need at least two contiguous selected words\n" );
return;
}
SetDirty( true );
PushUndo();
for ( int i = 0; i < m_Tags.m_Words.Size() - 1; i++ )
{
CWordTag *current = m_Tags.m_Words[ i ];
CWordTag *next = m_Tags.m_Words[ i + 1 ];
Assert( current && next );
if ( !current->m_bSelected || !next->m_bSelected )
continue;
// Move next word to end of current
next->m_flStartTime = current->m_flEndTime;
}
PushRedo();
redraw();
}
void PhonemeEditor::SeparateWords( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( GetPixelsPerSecond() <= 0.0f )
return;
if ( m_Tags.m_Words.Size() < 2 )
{
Con_Printf( "Can't separate, need at least two contiguous selected words\n" );
return;
}
// Three pixels
double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 6;
SetDirty( true );
PushUndo();
for ( int i = 0; i < m_Tags.m_Words.Size() - 1; i++ )
{
CWordTag *current = m_Tags.m_Words[ i ];
CWordTag *next = m_Tags.m_Words[ i + 1 ];
Assert( current && next );
if ( !current->m_bSelected || !next->m_bSelected )
continue;
// Close enough?
if ( fabs( current->m_flEndTime - next->m_flStartTime ) > time_epsilon )
{
Con_Printf( "Can't split %s and %s, already split apart\n",
current->GetWord(), next->GetWord() );
continue;
}
// Offset next word start time a bit
next->m_flStartTime += time_epsilon;
break;
}
PushRedo();
redraw();
}
void PhonemeEditor::CreateEvenWordDistribution( const char *wordlist )
{
if ( GetMode() != MODE_PHONEMES )
return;
if( !m_pWaveFile )
return;
Assert( wordlist );
if ( !wordlist )
return;
m_Tags.CreateEventWordDistribution( wordlist, m_pWaveFile->GetRunningLength() );
redraw();
}
void PhonemeEditor::EditWordList( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( !m_pWaveFile )
return;
// Build word string
char wordstring[ 1024 ];
V_strcpy_safe( wordstring, m_Tags.GetText() );
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Word List" );
strcpy( params.m_szPrompt, "Sentence:" );
strcpy( params.m_szInputText, wordstring );
if ( !InputProperties( &params ) )
return;
if ( strlen( params.m_szInputText ) <= 0 )
{
// Could be foreign language...
Warning( "Edit word list: No words entered!\n" );
}
SetDirty( true );
PushUndo();
// Clear any current LISET results
ClearExtracted();
// Force text
m_Tags.SetText( params.m_szInputText );
if ( m_Tags.m_Words.Size() == 0 )
{
// First text we've seen, just distribute words evenly
CreateEvenWordDistribution( params.m_szInputText );
// Redo liset
RedoPhonemeExtraction();
}
PushRedo();
SetFocus( (HWND)getHandle() );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose: Overwrite original wave with changes
//-----------------------------------------------------------------------------
void PhonemeEditor::CommitChanges( void )
{
SaveLinguisticData();
// Make it writable - if possible
MakeFileWriteable( m_WorkFile.m_szWaveFile );
//Open a message box to warn the user if the file was unable to be made non-read only
if ( !IsFileWriteable( m_WorkFile.m_szWaveFile ) )
{
mxMessageBox( NULL, va( "Unable to save file '%s'. File is read-only or in use.",
m_WorkFile.m_szWaveFile ), g_appTitle, MX_MB_OK );
}
else
{
// Copy over and overwrite file
FPCopyFile( m_WorkFile.m_szWorkingFile, m_WorkFile.m_szWaveFile, true );
Msg( "Changes saved to '%s'\n", m_WorkFile.m_szWaveFile );
SetDirty( false, false );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::LoadWaveFile( void )
{
char filename[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( filename, sizeof( filename ), "sound", "*.wav" ) )
{
return;
}
StopPlayback();
// Strip out the game directory
SetCurrentWaveFile( filename );
}
void PhonemeEditor::SnapPhonemes( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
SetDirty( true );
PushUndo();
CPhonemeTag *prev = NULL;
for ( int w = 0; w < m_Tags.m_Words.Size(); w++ )
{
CWordTag *word = m_Tags.m_Words[ w ];
Assert( word );
if ( !word )
continue;
for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
{
CPhonemeTag *current = word->m_Phonemes[ i ];
Assert( current );
if ( current->m_bSelected )
{
if (prev)
{
// More start of next to end of previous
prev->SetEndTime( current->GetStartTime() );
}
prev = current;
}
else
{
prev = NULL;
}
}
}
PushRedo();
redraw();
}
void PhonemeEditor::SeparatePhonemes( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
SetDirty( true );
PushUndo();
// Three pixels
double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 6;
CPhonemeTag *prev = NULL;
for ( int w = 0; w < m_Tags.m_Words.Size(); w++ )
{
CWordTag *word = m_Tags.m_Words[ w ];
Assert( word );
if ( !word )
continue;
for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
{
CPhonemeTag *current = word->m_Phonemes[ i ];
Assert( current );
if ( current->m_bSelected )
{
if ( prev )
{
// Close enough?
if ( fabs( prev->GetEndTime() - current->GetStartTime() ) > time_epsilon )
{
Con_Printf( "Can't split already split apart\n" );
continue;
}
current->AddStartTime( time_epsilon );
}
prev = current;
}
else
{
prev = NULL;
}
}
}
PushRedo();
redraw();
}
bool PhonemeEditor::IsMouseOverWordRow( int my )
{
if ( GetMode() != MODE_PHONEMES )
return false;
RECT rc;
GetWordTrayTopBottom( rc );
if ( my < rc.top )
return false;
if ( my > rc.bottom )
return false;
return true;
}
bool PhonemeEditor::IsMouseOverPhonemeRow( int my )
{
if ( GetMode() != MODE_PHONEMES )
return false;
RECT rc;
GetPhonemeTrayTopBottom( rc );
if ( my < rc.top )
return false;
if ( my > rc.bottom )
return false;
return true;
}
void PhonemeEditor::GetPhonemeTrayTopBottom( RECT& rc )
{
RECT wkrc;
GetWorkspaceRect( wkrc );
rc.top = wkrc.bottom - 2 * m_nTickHeight;
rc.bottom = wkrc.bottom - m_nTickHeight;
}
void PhonemeEditor::GetWordTrayTopBottom( RECT& rc )
{
RECT wkrc;
GetWorkspaceRect( wkrc );
rc.top = wkrc.top;
rc.bottom = wkrc.top + m_nTickHeight;
}
int PhonemeEditor::GetMouseForTime( float time )
{
RECT rc;
GetWorkspaceRect( rc );
if ( GetPixelsPerSecond() < 0.0f )
return rc.left;
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
if ( endtime - starttime <= 0.0f )
return rc.left;
float frac;
frac = ( time - starttime ) / ( endtime - starttime );
return rc.left + ( int )( rc.right * frac );
}
void PhonemeEditor::GetWordRect( const CWordTag *tag, RECT& rc )
{
Assert( tag );
GetWordTrayTopBottom( rc );
rc.left = GetMouseForTime( tag->m_flStartTime );
rc.right = GetMouseForTime( tag->m_flEndTime );
}
void PhonemeEditor::GetPhonemeRect( const CPhonemeTag *tag, RECT& rc )
{
Assert( tag );
GetPhonemeTrayTopBottom( rc );
rc.left = GetMouseForTime( tag->GetStartTime() );
rc.right = GetMouseForTime( tag->GetEndTime() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::CommitExtracted( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
m_nLastExtractionResult = SR_RESULT_NORESULT;
if ( !m_TagsExt.m_Words.Size() )
return;
SetDirty( true );
PushUndo();
m_Tags.Reset();
m_Tags = m_TagsExt;
PushRedo();
ClearExtracted();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::ClearExtracted( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
m_nLastExtractionResult = SR_RESULT_NORESULT;
m_TagsExt.Reset();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : resultCode -
// Output : const char
//-----------------------------------------------------------------------------
const char *PhonemeEditor::GetExtractionResultString( int resultCode )
{
switch ( resultCode )
{
case SR_RESULT_NORESULT:
return "no extraction info.";
case SR_RESULT_ERROR:
return "an error occurred during extraction.";
case SR_RESULT_SUCCESS:
return "successful.";
case SR_RESULT_FAILED:
return "results retrieved, but full recognition failed.";
default:
break;
}
return "unknown result code.";
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// Output : CEventRelativeTag
//-----------------------------------------------------------------------------
CEventRelativeTag *PhonemeEditor::GetTagUnderMouse( int mx )
{
if ( GetMode() != MODE_PHONEMES )
return NULL;
// Figure out tag positions
if ( !m_pEvent || !m_pWaveFile )
return NULL;
RECT rc;
GetWorkspaceRect( rc );
RECT rcTags = rc;
if ( GetPixelsPerSecond() <= 0.0f )
return NULL;
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
if ( endtime - starttime < 0 )
return NULL;
for ( int i = 0; i < m_pEvent->GetNumRelativeTags(); i++ )
{
CEventRelativeTag *tag = m_pEvent->GetRelativeTag( i );
if ( !tag )
continue;
//
float tagtime = tag->GetPercentage() * m_pWaveFile->GetRunningLength();
if ( tagtime < starttime || tagtime > endtime )
continue;
float frac = ( tagtime - starttime ) / ( endtime - starttime );
int left = rcTags.left + (int)( frac * ( float )( rcTags.right - rcTags.left ) + 0.5f );
if ( abs( mx - left ) < 10 )
return tag;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::IsMouseOverTag( int mx, int my )
{
if ( GetMode() != MODE_PHONEMES )
return false;
if ( !IsMouseOverTagRow( my ) )
return false;
CEventRelativeTag *tag = GetTagUnderMouse( mx );
if ( !tag )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : startx -
// endx -
//-----------------------------------------------------------------------------
void PhonemeEditor::FinishEventTagDrag( int startx, int endx )
{
if ( !m_pWaveFile )
return;
if ( !m_pWaveFile->GetRunningLength() )
return;
// Find starting tag
CEventRelativeTag *tag = GetTagUnderMouse( startx );
if ( !tag )
return;
if ( GetPixelsPerSecond() <= 0 )
return;
// Convert mouse position to time
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float clicktime = (float)endx / GetPixelsPerSecond() + starttime;
float percent = clicktime / m_pWaveFile->GetRunningLength();
percent = clamp( percent, 0.0f, 1.0f );
tag->SetPercentage( percent );
redraw();
if ( g_pChoreoView )
{
g_pChoreoView->InvalidateLayout();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::IsMouseOverTagRow( int my )
{
if ( GetMode() != MODE_PHONEMES )
return false;
if ( my < TAG_TOP || my > TAG_BOTTOM )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void PhonemeEditor::ShowTagMenu( int mx, int my )
{
if ( GetMode() != MODE_PHONEMES )
return;
// Figure out tag positions
if ( !m_pEvent || !m_pWaveFile )
return;
if ( !IsMouseOverTagRow( my ) )
return;
CEventRelativeTag *tag = GetTagUnderMouse( mx );
mxPopupMenu *pop = new mxPopupMenu();
if ( tag )
{
pop->add( va( "Delete tag '%s'", tag->GetName() ), IDC_DELETETAG );
}
else
{
pop->add( va( "Add tag..." ), IDC_ADDTAG );
}
m_nClickX = mx;
pop->popup( this, mx, my );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::DeleteTag( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
// Figure out tag positions
if ( !m_pEvent )
return;
CEventRelativeTag *tag = GetTagUnderMouse( m_nClickX );
if ( !tag )
return;
// Remove it
m_pEvent->RemoveRelativeTag( tag->GetName() );
g_pChoreoView->InvalidateLayout();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::AddTag( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
// Figure out tag positions
if ( !m_pEvent || !m_pWaveFile )
return;
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Event Tag Name" );
strcpy( params.m_szPrompt, "Name:" );
strcpy( params.m_szInputText, "" );
if ( !InputProperties( &params ) )
return;
if ( strlen( params.m_szInputText ) <= 0 )
{
Con_ErrorPrintf( "Event Tag Name: No name entered!\n" );
return;
}
// Convert mouse position to time
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float clicktime = (float)m_nClickX / GetPixelsPerSecond() + starttime;
float percent = clicktime / m_pWaveFile->GetRunningLength();
percent = min( 1.0f, percent );
percent = max( 0.0f, percent );
m_pEvent->AddRelativeTag( params.m_szInputText, percent );
g_pChoreoView->InvalidateLayout();
SetFocus( (HWND)getHandle() );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::ClearEvent( void )
{
m_pEvent = NULL;
redraw();
}
void PhonemeEditor::TraverseWords( PEWORDITERFUNC pfn, float fparam )
{
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
(this->*pfn)( word, fparam );
}
}
void PhonemeEditor::TraversePhonemes( PEPHONEMEITERFUNC pfn, float fparam )
{
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
(this->*pfn)( phoneme, word, fparam );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : amount -
//-----------------------------------------------------------------------------
void PhonemeEditor::ITER_MoveSelectedWords( CWordTag *word, float amount )
{
if ( !word->m_bSelected )
return;
word->m_flStartTime += amount;
word->m_flEndTime += amount;
}
void PhonemeEditor::ITER_MoveSelectedPhonemes( CPhonemeTag *phoneme, CWordTag *word, float amount )
{
if ( !phoneme->m_bSelected )
return;
phoneme->AddStartTime( amount );
phoneme->AddEndTime( amount );
}
void PhonemeEditor::ITER_ExtendSelectedPhonemeEndTimes( CPhonemeTag *phoneme, CWordTag *word, float amount )
{
if ( !phoneme->m_bSelected )
return;
if ( phoneme->GetEndTime() + amount <= phoneme->GetStartTime() )
return;
phoneme->AddEndTime( amount );
// Fixme, check for extending into next phoneme
}
void PhonemeEditor::ITER_ExtendSelectedWordEndTimes( CWordTag *word, float amount )
{
if ( !word->m_bSelected )
return;
if ( word->m_flEndTime + amount <= word->m_flStartTime )
return;
word->m_flEndTime += amount;
// Fixme, check for extending into next word
}
void PhonemeEditor::ITER_AddFocusRectSelectedWords( CWordTag *word, float amount )
{
if ( !word->m_bSelected )
return;
RECT wordRect;
GetWordRect( word, wordRect );
AddFocusRect( wordRect );
}
void PhonemeEditor::ITER_AddFocusRectSelectedPhonemes( CPhonemeTag *phoneme, CWordTag *word, float amount )
{
if ( !phoneme->m_bSelected )
return;
RECT phonemeRect;
GetPhonemeRect( phoneme, phonemeRect );
AddFocusRect( phonemeRect );
}
void PhonemeEditor::AddFocusRect( RECT& rc )
{
RECT rcFocus = rc;
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &rcFocus, offset.x, offset.y );
// Convert to screen space?
CFocusRect fr;
fr.m_rcFocus = rcFocus;
fr.m_rcOrig = rcFocus;
m_FocusRects.AddToTail( fr );
}
void PhonemeEditor::CountSelected( void )
{
m_nSelectedPhonemeCount = 0;
m_nSelectedWordCount = 0;
TraverseWords( &PhonemeEditor::ITER_CountSelectedWords, 0.0f );
TraversePhonemes( &PhonemeEditor::ITER_CountSelectedPhonemes, 0.0f );
}
void PhonemeEditor::ITER_CountSelectedWords( CWordTag *word, float amount )
{
if ( !word->m_bSelected )
return;
m_nSelectedWordCount++;
}
void PhonemeEditor::ITER_CountSelectedPhonemes( CPhonemeTag *phoneme, CWordTag *word, float amount )
{
if ( !phoneme->m_bSelected )
return;
m_nSelectedPhonemeCount++;
}
// Undo/Redo
void PhonemeEditor::Undo( void )
{
if ( m_UndoStack.Size() > 0 && m_nUndoLevel > 0 )
{
m_nUndoLevel--;
PEUndo *u = m_UndoStack[ m_nUndoLevel ];
Assert( u->undo );
m_Tags = *(u->undo);
SetClickedPhoneme( -1, -1 );
}
redraw();
}
void PhonemeEditor::Redo( void )
{
if ( m_UndoStack.Size() > 0 && m_nUndoLevel <= m_UndoStack.Size() - 1 )
{
PEUndo *u = m_UndoStack[ m_nUndoLevel ];
Assert( u->redo );
m_Tags = *(u->redo);
m_nUndoLevel++;
SetClickedPhoneme( -1, -1 );
}
redraw();
}
void PhonemeEditor::PushUndo( void )
{
Assert( !m_bRedoPending );
m_bRedoPending = true;
WipeRedo();
// Copy current data
CSentence *u = new CSentence();
*u = m_Tags;
PEUndo *undo = new PEUndo;
undo->undo = u;
undo->redo = NULL;
m_UndoStack.AddToTail( undo );
m_nUndoLevel++;
}
void PhonemeEditor::PushRedo( void )
{
Assert( m_bRedoPending );
m_bRedoPending = false;
// Copy current data
CSentence *r = new CSentence();
*r = m_Tags;
PEUndo *undo = m_UndoStack[ m_nUndoLevel - 1 ];
undo->redo = r;
}
void PhonemeEditor::WipeUndo( void )
{
while ( m_UndoStack.Size() > 0 )
{
PEUndo *u = m_UndoStack[ 0 ];
delete u->undo;
delete u->redo;
delete u;
m_UndoStack.Remove( 0 );
}
m_nUndoLevel = 0;
}
void PhonemeEditor::WipeRedo( void )
{
// Wipe everything above level
while ( m_UndoStack.Size() > m_nUndoLevel )
{
PEUndo *u = m_UndoStack[ m_nUndoLevel ];
delete u->undo;
delete u->redo;
delete u;
m_UndoStack.Remove( m_nUndoLevel );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : word -
// phoneme -
//-----------------------------------------------------------------------------
void PhonemeEditor::SetClickedPhoneme( int word, int phoneme )
{
m_nClickedPhoneme = phoneme;
m_nClickedWord = word;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CPhonemeTag
//-----------------------------------------------------------------------------
CPhonemeTag *PhonemeEditor::GetClickedPhoneme( void )
{
if ( m_nClickedPhoneme < 0 || m_nClickedWord < 0 )
return NULL;
if ( m_nClickedWord >= m_Tags.m_Words.Size() )
return NULL;
CWordTag *word = m_Tags.m_Words[ m_nClickedWord ];
if ( !word )
return NULL;
if ( m_nClickedPhoneme >= word->m_Phonemes.Size() )
return NULL;
CPhonemeTag *phoneme = word->m_Phonemes[ m_nClickedPhoneme ];
return phoneme;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CWordTag
//-----------------------------------------------------------------------------
CWordTag *PhonemeEditor::GetClickedWord( void )
{
if ( m_nClickedWord < 0 )
return NULL;
if ( m_nClickedWord >= m_Tags.m_Words.Size() )
return NULL;
CWordTag *word = m_Tags.m_Words[ m_nClickedWord ];
return word;
}
void PhonemeEditor::ShowContextMenu_Phonemes( int mx, int my )
{
CountSelected();
// Construct main
mxPopupMenu *pop = new mxPopupMenu();
if ( m_pWaveFile )
{
mxPopupMenu *play = new mxPopupMenu;
play->add( va( "Original" ), IDC_PHONEME_PLAY_ORIG );
play->add( va( "Edited" ), IDC_PLAY_EDITED );
if ( m_bSelectionActive )
{
play->add( va( "Selection" ), IDC_PLAY_EDITED_SELECTION );
}
pop->addMenu( "Play", play );
if ( sound->IsSoundPlaying( m_pMixer ) )
{
pop->add( va( "Cancel playback" ), IDC_CANCELPLAYBACK );
}
pop->addSeparator();
}
pop->add( va( "Load..." ), IDC_LOADWAVEFILE );
if ( m_pWaveFile )
{
pop->add( va( "Save" ), IDC_SAVE_LINGUISTIC );
}
if ( m_bSelectionActive )
{
pop->addSeparator();
pop->add( va( "Deselect" ), IDC_DESELECT );
}
if ( m_pWaveFile )
{
pop->addSeparator();
pop->add( va( "Redo Extraction" ), IDC_REDO_PHONEMEEXTRACTION );
if ( m_nSelectedWordCount < 1 || AreSelectedWordsContiguous() )
{
pop->add( va( "Redo Extraction of selected words" ), IDC_REDO_PHONEMEEXTRACTION_SELECTION );
}
}
if ( m_pWaveFile && m_TagsExt.m_Words.Size() )
{
pop->addSeparator();
pop->add( va( "Commit extraction" ) , IDC_COMMITEXTRACTED );
pop->add( va( "Clear extraction" ), IDC_CLEAREXTRACTED );
}
if ( m_nUndoLevel != 0 || m_nUndoLevel != m_UndoStack.Size() )
{
pop->addSeparator();
if ( m_nUndoLevel != 0 )
{
pop->add( va( "Undo" ), IDC_UNDO );
}
if ( m_nUndoLevel != m_UndoStack.Size() )
{
pop->add( va( "Redo" ), IDC_REDO );
}
pop->add( va( "Clear Undo Info" ), IDC_CLEARUNDO );
}
if ( m_Tags.m_Words.Size() > 0 )
{
pop->addSeparator();
pop->add( va( "Cleanup words/phonemes" ), IDC_CLEANUP );
}
// Show hierarchical options menu
{
mxPopupMenu *api = 0;
if ( DoesExtractorExistFor( SPEECH_API_SAPI ) )
{
api = new mxPopupMenu();
api->add( "Microsoft Speech API", IDC_API_SAPI );
if ( g_viewerSettings.speechapiindex == SPEECH_API_SAPI )
{
api->setChecked( IDC_API_SAPI, true );
}
}
if ( DoesExtractorExistFor( SPEECH_API_LIPSINC ) )
{
if ( !api )
api = new mxPopupMenu();
api->add( "Lipsinc Speech API", IDC_API_LIPSINC );
if ( g_viewerSettings.speechapiindex == SPEECH_API_LIPSINC )
{
api->setChecked( IDC_API_LIPSINC, true );
}
}
pop->addSeparator();
pop->addMenu( "Change Speech API", api );
}
// Import export menu
if ( m_pWaveFile )
{
pop->addSeparator();
if ( m_Tags.m_Words.Count() > 0 )
{
pop->add( "Export word data to " WORD_DATA_EXTENSION "...", IDC_EXPORT_SENTENCE );
}
pop->add( "Import word data from " WORD_DATA_EXTENSION "...", IDC_IMPORT_SENTENCE );
pop->add( va("%s Voice Duck", m_Tags.GetVoiceDuck() ? "Disable" : "Enable" ), IDC_TOGGLE_VOICEDUCK );
}
pop->popup( this, mx, my );
}
void PhonemeEditor::ShowContextMenu_Emphasis( int mx, int my )
{
Emphasis_CountSelected();
// Construct main
mxPopupMenu *pop = new mxPopupMenu();
pop->add( va( "Select All" ), IDC_EMPHASIS_SELECTALL );
if ( m_nNumSelected > 0 )
{
pop->add( va( "Deselect All" ), IDC_EMPHASIS_DESELECT );
}
if ( m_nUndoLevel != 0 || m_nUndoLevel != m_UndoStack.Size() )
{
pop->addSeparator();
if ( m_nUndoLevel != 0 )
{
pop->add( va( "Undo" ), IDC_UNDO );
}
if ( m_nUndoLevel != m_UndoStack.Size() )
{
pop->add( va( "Redo" ), IDC_REDO );
}
pop->add( va( "Clear Undo Info" ), IDC_CLEARUNDO );
}
pop->popup( this, mx, my );
}
void PhonemeEditor::ShowContextMenu( int mx, int my )
{
switch ( GetMode() )
{
default:
case MODE_PHONEMES:
ShowContextMenu_Phonemes( mx, my );
break;
case MODE_EMPHASIS:
ShowContextMenu_Emphasis( mx, my );
break;
}
}
void PhonemeEditor::ShiftSelectedPhoneme( int direction )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
switch ( m_nSelectedPhonemeCount )
{
case 1:
break;
case 0:
Con_Printf( "Can't shift phonemes, none selected\n" );
return;
default:
Con_Printf( "Can only shift one phoneme at a time via keyboard\n" );
return;
}
RECT rc;
GetWorkspaceRect( rc );
// Determine start/stop positions
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
float movetime = timeperpixel * (float)direction;
float maxmove = ComputeMaxPhonemeShift( direction > 0 ? true : false, false );
if ( direction > 0 )
{
if ( movetime > maxmove )
{
movetime = maxmove;
Con_Printf( "Further shift is blocked on right\n" );
}
}
else
{
if ( movetime < -maxmove )
{
movetime = -maxmove;
Con_Printf( "Further shift is blocked on left\n" );
}
}
if ( fabs( movetime ) < 0.0001f )
return;
SetDirty( true );
PushUndo();
TraversePhonemes( &PhonemeEditor::ITER_MoveSelectedPhonemes, movetime );
PushRedo();
m_bWordsActive = false;
redraw();
Con_Printf( "Shift phoneme %s\n", direction == -1 ? "left" : "right" );
}
void PhonemeEditor::ExtendSelectedPhonemeEndTime( int direction )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedPhonemeCount != 1 )
return;
RECT rc;
GetWorkspaceRect( rc );
// Determine start/stop positions
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
float movetime = timeperpixel * (float)direction;
SetDirty( true );
PushUndo();
TraversePhonemes( &PhonemeEditor::ITER_ExtendSelectedPhonemeEndTimes, movetime );
PushRedo();
m_bWordsActive = false;
redraw();
Con_Printf( "Extend phoneme end %s\n", direction == -1 ? "left" : "right" );
}
void PhonemeEditor::SelectNextPhoneme( int direction )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedPhonemeCount != 1 )
{
if ( m_nSelectedWordCount == 1 )
{
CWordTag *word = GetSelectedWord();
if ( word && word->m_Phonemes.Size() > 0 )
{
m_nSelectedPhonemeCount = 1;
CPhonemeTag *p = word->m_Phonemes[ direction ? word->m_Phonemes.Size() - 1 : 0 ];
p->m_bSelected = true;
}
else
{
return;
}
}
else
{
return;
}
}
Con_Printf( "Move to next phoneme %s\n", direction == -1 ? "left" : "right" );
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
if ( !phoneme->m_bSelected )
continue;
// Deselect this one and move
int nextindex = j + direction;
if ( nextindex < 0 )
{
nextindex = word->m_Phonemes.Size() - 1;
}
else if ( nextindex >= word->m_Phonemes.Size() )
{
nextindex = 0;
}
phoneme->m_bSelected = false;
phoneme = word->m_Phonemes[ nextindex ];
phoneme->m_bSelected = true;
m_bWordsActive = false;
redraw();
return;
}
}
}
bool PhonemeEditor::IsPhonemeSelected( CWordTag *word )
{
for ( int i = 0 ; i < word->m_Phonemes.Size(); i++ )
{
CPhonemeTag *p = word->m_Phonemes[ i ];
if ( !p || !p->m_bSelected )
continue;
return true;
}
return false;
}
void PhonemeEditor::SelectNextWord( int direction )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedWordCount != 1 &&
m_nSelectedPhonemeCount != 1 )
{
// Selected first word then
if ( m_nSelectedWordCount == 0 && m_Tags.m_Words.Size() > 0 )
{
CWordTag *word = m_Tags.m_Words[ direction ? m_Tags.m_Words.Size() - 1 : 0 ];
word->m_bSelected = true;
m_nSelectedWordCount = 1;
}
else
{
return;
}
}
Con_Printf( "Move to next word %s\n", direction == -1 ? "left" : "right" );
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
if ( m_nSelectedWordCount == 1 )
{
if ( !word->m_bSelected )
continue;
}
else
{
if ( !IsPhonemeSelected( word ) )
continue;
}
// Deselect word
word->m_bSelected = false;
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
if ( !phoneme->m_bSelected )
continue;
phoneme->m_bSelected = false;
}
// Deselect this one and move
int nextword = i + direction;
if ( nextword < 0 )
{
nextword = m_Tags.m_Words.Size() - 1;
}
else if ( nextword >= m_Tags.m_Words.Size() )
{
nextword = 0;
}
word = m_Tags.m_Words[ nextword ];
word->m_bSelected = true;
if ( word->m_Phonemes.Size() > 0 )
{
CPhonemeTag *phoneme = NULL;
if ( direction > 0 )
{
phoneme = word->m_Phonemes[ 0 ];
}
else
{
phoneme = word->m_Phonemes[ word->m_Phonemes.Size() - 1 ];
}
phoneme->m_bSelected = true;
}
m_bWordsActive = true;
redraw();
return;
}
}
void PhonemeEditor::ShiftSelectedWord( int direction )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
switch ( m_nSelectedWordCount )
{
case 1:
break;
case 0:
Con_Printf( "Can't shift words, none selected\n" );
return;
default:
Con_Printf( "Can only shift one word at a time via keyboard\n" );
return;
}
RECT rc;
GetWorkspaceRect( rc );
// Determine start/stop positions
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
float movetime = timeperpixel * (float)direction;
float maxmove = ComputeMaxWordShift( direction > 0 ? true : false, false );
if ( direction > 0 )
{
if ( movetime > maxmove )
{
movetime = maxmove;
Con_Printf( "Further shift is blocked on right\n" );
}
}
else
{
if ( movetime < -maxmove )
{
movetime = -maxmove;
Con_Printf( "Further shift is blocked on left\n" );
}
}
if ( fabs( movetime ) < 0.0001f )
return;
SetDirty( true );
PushUndo();
TraverseWords( &PhonemeEditor::ITER_MoveSelectedWords, movetime );
PushRedo();
m_bWordsActive = true;
redraw();
Con_Printf( "Shift word %s\n", direction == -1 ? "left" : "right" );
}
void PhonemeEditor::ExtendSelectedWordEndTime( int direction )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedWordCount != 1 )
return;
RECT rc;
GetWorkspaceRect( rc );
// Determine start/stop positions
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
float movetime = timeperpixel * (float)direction;
SetDirty( true );
PushUndo();
TraverseWords( &PhonemeEditor::ITER_ExtendSelectedWordEndTimes, movetime );
PushRedo();
m_bWordsActive = true;
redraw();
Con_Printf( "Extend word end %s\n", direction == -1 ? "left" : "right" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *word -
// Output : int
//-----------------------------------------------------------------------------
int PhonemeEditor::IndexOfWord( CWordTag *word )
{
for ( int i = 0 ; i < m_Tags.m_Words.Size(); i++ )
{
if ( m_Tags.m_Words[ i ] == word )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : forward -
// *currentWord -
// **nextWord -
// Output : float
//-----------------------------------------------------------------------------
float PhonemeEditor::GetTimeGapToNextWord( bool forward, CWordTag *currentWord, CWordTag **ppNextWord /* = NULL */ )
{
if ( ppNextWord )
{
*ppNextWord = NULL;
}
if ( !currentWord )
return 0.0f;
int wordnum = IndexOfWord( currentWord );
if ( wordnum == -1 )
return 0.0f;
// Go in correct direction
int newwordnum = wordnum + ( forward ? 1 : -1 );
// There is no next word
if ( newwordnum >= m_Tags.m_Words.Size() )
{
return PLENTY_OF_TIME;
}
// There is no previous word
if ( newwordnum < 0 )
{
return PLENTY_OF_TIME;
}
if ( ppNextWord )
{
*ppNextWord = m_Tags.m_Words[ newwordnum ];
}
// Otherwise, figure out time gap
if ( forward )
{
float currentEnd = currentWord->m_flEndTime;
float nextStart = m_Tags.m_Words[ newwordnum ]->m_flStartTime;
return ( nextStart - currentEnd );
}
else
{
float previousEnd = m_Tags.m_Words[ newwordnum ]->m_flEndTime;
float currentStart = currentWord->m_flStartTime;
return ( currentStart - previousEnd );
}
Assert( 0 );
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : forward -
// *currentPhoneme -
// **word -
// **phoneme -
// Output : float
//-----------------------------------------------------------------------------
float PhonemeEditor::GetTimeGapToNextPhoneme( bool forward, CPhonemeTag *currentPhoneme,
CWordTag **ppword /* = NULL */, CPhonemeTag **ppphoneme /* = NULL */ )
{
if ( ppword )
{
*ppword = NULL;
}
if ( ppphoneme )
{
*ppphoneme = NULL;
}
if ( !currentPhoneme )
return 0.0f;
CWordTag *word = m_Tags.GetWordForPhoneme( currentPhoneme );
if ( !word )
return 0.0f;
int wordnum = IndexOfWord( word );
Assert( wordnum != -1 );
int phonemenum = word->IndexOfPhoneme( currentPhoneme );
if ( phonemenum < 0 )
return 0.0f;
CPhonemeTag *nextPhoneme = NULL;
int nextphoneme = phonemenum + ( forward ? 1 : -1 );
// Try last phoneme of previous word
if ( nextphoneme < 0 )
{
wordnum--;
while ( wordnum >= 0 )
{
if ( ppword )
{
*ppword = m_Tags.m_Words[ wordnum ];
}
if ( m_Tags.m_Words.Size() > 0 )
{
if ( m_Tags.m_Words[ wordnum ]->m_Phonemes.Size() > 0 )
{
nextPhoneme = m_Tags.m_Words[ wordnum ]->m_Phonemes[ m_Tags.m_Words[ wordnum ]->m_Phonemes.Size() - 1 ];
break;
}
}
wordnum--;
}
}
// Try first phoneme of next word, if there is one
else if ( nextphoneme >= word->m_Phonemes.Size() )
{
wordnum++;
while ( wordnum < m_Tags.m_Words.Size() )
{
if ( ppword )
{
*ppword = m_Tags.m_Words[ wordnum ];
}
// Really it can't be zero, but check anyway
if ( m_Tags.m_Words.Size() > 0 )
{
if ( m_Tags.m_Words[ wordnum ]->m_Phonemes.Size() > 0 )
{
nextPhoneme = m_Tags.m_Words[ wordnum ]->m_Phonemes[ 0 ];
break;
}
}
wordnum++;
}
}
else
{
nextPhoneme = word->m_Phonemes[ nextphoneme ];
}
if ( !nextPhoneme )
return PLENTY_OF_TIME;
if ( ppphoneme )
{
*ppphoneme = nextPhoneme;
}
// Now compute time delta
float dt = 0.0f;
if ( forward )
{
dt = nextPhoneme->GetStartTime() - currentPhoneme->GetEndTime();
}
else
{
dt = currentPhoneme->GetStartTime() - nextPhoneme->GetEndTime();
}
return dt;
}
CPhonemeTag *PhonemeEditor::GetSelectedPhoneme( void )
{
CountSelected();
if ( m_nSelectedPhonemeCount != 1 )
return NULL;
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *w = m_Tags.m_Words[ i ];
if ( !w )
continue;
for ( int j = 0; j < w->m_Phonemes.Size() ; j++ )
{
CPhonemeTag *p = w->m_Phonemes[ j ];
if ( !p || !p->m_bSelected )
continue;
return p;
}
}
return NULL;
}
CWordTag *PhonemeEditor::GetSelectedWord( void )
{
CountSelected();
if ( m_nSelectedWordCount != 1 )
return NULL;
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *w = m_Tags.m_Words[ i ];
if ( !w || !w->m_bSelected )
continue;
return w;
}
return NULL;
}
void PhonemeEditor::OnMouseMove( mxEvent *event )
{
int mx = (short)event->x;
LimitDrag( mx );
event->x = (short)mx;
if ( m_nDragType != DRAGTYPE_NONE )
{
DrawFocusRect( "moving old" );
for ( int i = 0; i < m_FocusRects.Size(); i++ )
{
CFocusRect *f = &m_FocusRects[ i ];
f->m_rcFocus = f->m_rcOrig;
switch ( m_nDragType )
{
default:
{
// Only X Shifts supported
OffsetRect( &f->m_rcFocus, ( (short)event->x - m_nStartX ),
0 );
}
break;
case DRAGTYPE_EMPHASIS_SELECT:
{
RECT rcWork;
GetWorkspaceRect( rcWork );
RECT rcEmphasis;
Emphasis_GetRect( rcWork, rcEmphasis );
RECT rcFocus;
rcFocus = f->m_rcOrig;
rcFocus.left = m_nStartX < (short)event->x ? m_nStartX : (short)event->x;
rcFocus.right = m_nStartX < (short)event->x ? (short)event->x : m_nStartX;
rcFocus.top = m_nStartY < (short)event->y ? m_nStartY : (short)event->y;
rcFocus.bottom = m_nStartY < (short)event->y ? (short)event->y : m_nStartY;
rcFocus.top = clamp( rcFocus.top, rcEmphasis.top, rcEmphasis.bottom );
rcFocus.bottom = clamp( rcFocus.bottom, rcEmphasis.top, rcEmphasis.bottom );
//OffsetRect( &rcFocus, 0, -rcEmphasis.top );
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &rcFocus, offset.x, offset.y );
f->m_rcFocus = rcFocus;
}
break;
}
}
if ( m_nDragType == DRAGTYPE_EMPHASIS_MOVE )
{
redraw();
}
DrawFocusRect( "moving new" );
}
else
{
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = NULL;
}
CountSelected();
int overhandle = IsMouseOverBoundary( event );
if ( overhandle == BOUNDARY_PHONEME && m_nSelectedPhonemeCount <= 1 )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( overhandle == BOUNDARY_WORD && m_nSelectedWordCount <= 1 )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverSelection( (short)event->x, (short)event->y ) )
{
if ( IsMouseOverSelectionStartEdge( event ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverSelectionEndEdge( event ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else
{
if ( event->modifiers & mxEvent::KeyShift )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
}
}
}
else
{
if ( IsMouseOverTag( (short)event->x, (short)event->y ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
}
else
{
CPhonemeTag *pt = GetPhonemeTagUnderMouse( (short)event->x, (short)event->y );
CWordTag *wt = GetWordTagUnderMouse( (short)event->x, (short)event->y );
if ( wt || pt )
{
if ( pt )
{
// Select it
SelectExpression( pt );
}
if ( event->modifiers & mxEvent::KeyShift )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
}
}
}
}
}
switch ( m_nDragType )
{
default:
break;
case DRAGTYPE_EMPHASIS_MOVE:
{
Emphasis_MouseDrag( (short)event->x, (short)event->y );
m_Tags.Resort();
}
break;
case DRAGTYPE_SCRUBBER:
{
float t = GetTimeForPixel( (short)event->x );
t += m_flScrubberTimeOffset;
ClampTimeToSelectionInterval( t );
float dt = t - m_flScrub;
SetScrubTargetTime( t );
ScrubThink( dt, true );
SetScrubTime( t );
DrawScrubHandle();
}
break;
}
m_nLastX = (short)event->x;
m_nLastY = (short)event->y;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::EditInsertFirstPhonemeOfWord( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
CWordTag *cw = GetSelectedWord();
if ( !cw )
return;
if ( cw->m_Phonemes.Size() != 0 )
{
Con_Printf( "Can't insert first phoneme into %s, already has phonemes\n", cw->GetWord() );
return;
}
CPhonemeParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
strcpy( params.m_szName, "" );
params.m_nLeft = -1;
params.m_nTop = -1;
params.m_bPositionDialog = true;
params.m_bMultiplePhoneme = true;
if ( params.m_bPositionDialog )
{
RECT rcWord;
GetWordRect( cw, rcWord );
// Convert to screen coords
POINT pt;
pt.x = rcWord.left;
pt.y = rcWord.top;
ClientToScreen( (HWND)getHandle(), &pt );
params.m_nLeft = pt.x;
params.m_nTop = pt.y;
}
int iret = PhonemeProperties( &params );
SetFocus( (HWND)getHandle() );
if ( !iret )
{
return;
}
int phonemeCount = CSentence::CountWords( params.m_szName );
if ( phonemeCount <= 0 )
{
return;
}
float wordLength = cw->m_flEndTime - cw->m_flStartTime;
float timePerPhoneme = wordLength / (float)phonemeCount;
float currentTime = cw->m_flStartTime;
SetDirty( true );
PushUndo();
unsigned char *in;
char *out;
char phonemeName[ 128 ];
in = (unsigned char *)params.m_szName;
do
{
out = phonemeName;
while ( *in > 32 )
{
*out++ = *in++;
}
*out = 0;
CPhonemeTag phoneme;
phoneme.SetPhonemeCode( TextToPhoneme( phonemeName ) );
phoneme.SetTag( phonemeName );
phoneme.SetStartTime( currentTime );
phoneme.SetEndTime( currentTime + timePerPhoneme );
phoneme.m_bSelected = false;
cw->m_Phonemes.AddToTail( new CPhonemeTag( phoneme ) );
currentTime += timePerPhoneme;
if ( !*in )
break;
// Skip whitespace
in++;
} while ( 1 );
cw->m_Phonemes[ 0 ]->m_bSelected = true;
PushRedo();
// Add it
redraw();
}
void PhonemeEditor::SelectPhonemes( bool forward )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedPhonemeCount != 1 )
return;
CPhonemeTag *phoneme = GetSelectedPhoneme();
if ( !phoneme )
return;
// Figure out it's word and index
CWordTag *word = m_Tags.GetWordForPhoneme( phoneme );
if ( !word )
return;
int wordNum = IndexOfWord( word );
if ( wordNum == -1 )
return;
// Select remaining phonemes in current word
int i;
i = word->IndexOfPhoneme( phoneme );
if ( i == -1 )
return;
if ( forward )
{
// Start at next one
i++;
for ( ; i < word->m_Phonemes.Size(); i++ )
{
phoneme = word->m_Phonemes[ i ];
phoneme->m_bSelected = true;
}
// Now start at next word
wordNum++;
for ( ; wordNum < m_Tags.m_Words.Size(); wordNum++ )
{
word = m_Tags.m_Words[ wordNum ];
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
phoneme = word->m_Phonemes[ j ];
phoneme->m_bSelected = true;
}
}
}
else
{
// Start at previous
i--;
for ( ; i >= 0; i-- )
{
phoneme = word->m_Phonemes[ i ];
phoneme->m_bSelected = true;
}
// Now start at previous word
wordNum--;
for ( ; wordNum >= 0 ; wordNum-- )
{
word = m_Tags.m_Words[ wordNum ];
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
phoneme = word->m_Phonemes[ j ];
phoneme->m_bSelected = true;
}
}
}
redraw();
}
void PhonemeEditor::SelectWords( bool forward )
{
if ( GetMode() != MODE_PHONEMES )
return;
CountSelected();
if ( m_nSelectedWordCount != 1 )
return;
// Figure out it's word and index
CWordTag *word = GetSelectedWord();
if ( !word )
return;
int wordNum = IndexOfWord( word );
if ( wordNum == -1 )
return;
if ( forward )
{
wordNum++;
for ( ; wordNum < m_Tags.m_Words.Size(); wordNum++ )
{
word = m_Tags.m_Words[ wordNum ];
word->m_bSelected = true;
}
}
else
{
wordNum--;
for ( ; wordNum >= 0; wordNum-- )
{
word = m_Tags.m_Words[ wordNum ];
word->m_bSelected = true;
}
}
redraw();
}
bool PhonemeEditor::AreSelectedWordsContiguous( void )
{
CountSelected();
if ( m_nSelectedWordCount < 1 )
return false;
if ( m_nSelectedWordCount == 1 )
return true;
// Find first selected word
int runcount = 0;
bool parity = false;
for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
if ( word->m_bSelected )
{
if ( !parity )
{
parity = true;
runcount++;
}
}
else
{
if ( parity )
{
parity = false;
}
}
}
if ( runcount == 1 )
return true;
return false;
}
bool PhonemeEditor::AreSelectedPhonemesContiguous( void )
{
CountSelected();
if ( m_nSelectedPhonemeCount < 1 )
return false;
if ( m_nSelectedPhonemeCount == 1 )
return true;
// Find first selected word
int runcount = 0;
bool parity = false;
for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = 0 ; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
if ( phoneme->m_bSelected )
{
if ( !parity )
{
parity = true;
runcount++;
}
}
else
{
if ( parity )
{
parity = false;
}
}
}
}
if ( runcount == 1 )
return true;
return false;
}
void PhonemeEditor::SortWords( bool prepareundo )
{
if ( prepareundo )
{
SetDirty( true );
PushUndo();
}
// Just bubble sort by start time
int c = m_Tags.m_Words.Count();
int i;
// check for start > end
for ( i = 0; i < c; i++ )
{
CWordTag *p1 = m_Tags.m_Words[ i ];
if (p1->m_flStartTime > p1->m_flEndTime )
{
float swap = p1->m_flStartTime;
p1->m_flStartTime = p1->m_flEndTime;
p1->m_flEndTime = swap;
}
}
for ( i = 0; i < c; i++ )
{
for ( int j = i + 1; j < c; j++ )
{
CWordTag *p1 = m_Tags.m_Words[ i ];
CWordTag *p2 = m_Tags.m_Words[ j ];
if ( p1->m_flStartTime < p2->m_flStartTime )
continue;
// Swap them
m_Tags.m_Words[ i ] = p2;
m_Tags.m_Words[ j ] = p1;
}
}
if ( prepareundo )
{
PushRedo();
}
}
void PhonemeEditor::SortPhonemes( bool prepareundo )
{
if ( prepareundo )
{
SetDirty( true );
PushUndo();
}
// Just bubble sort by start time
int wc = m_Tags.m_Words.Count();
for ( int w = 0; w < wc; w++ )
{
CWordTag *word = m_Tags.m_Words[ w ];
Assert( word );
int c = word->m_Phonemes.Count();
int i;
// check for start > end
for ( i = 0; i < c; i++ )
{
CPhonemeTag *p1 = word->m_Phonemes[ i ];
if (p1->GetStartTime() > p1->GetEndTime() )
{
float swap = p1->GetStartTime();
p1->SetStartTime( p1->GetEndTime() );
p1->SetEndTime( swap );
}
}
for ( i = 0; i < c; i++ )
{
for ( int j = i + 1; j < c; j++ )
{
CPhonemeTag *p1 = word->m_Phonemes[ i ];
CPhonemeTag *p2 = word->m_Phonemes[ j ];
if ( p1->GetStartTime() < p2->GetStartTime() )
continue;
// Swap them
word->m_Phonemes[ i ] = p2;
word->m_Phonemes[ j ] = p1;
}
}
}
if ( prepareundo )
{
PushRedo();
}
}
void PhonemeEditor::CleanupWordsAndPhonemes( bool prepareundo )
{
if ( GetMode() != MODE_PHONEMES )
return;
// 2 pixel gap
float snap_epsilon = 2.49f / GetPixelsPerSecond();
if ( prepareundo )
{
SetDirty( true );
PushUndo();
}
SortWords( false );
SortPhonemes( false );
for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
CWordTag *next = NULL;
if ( i < m_Tags.m_Words.Size() - 1 )
{
next = m_Tags.m_Words[ i + 1 ];
}
if ( word && next )
{
// Check for words close enough
float eps = next->m_flStartTime - word->m_flEndTime;
if ( eps && eps <= snap_epsilon )
{
float t = (word->m_flEndTime + next->m_flStartTime) * 0.5;
word->m_flEndTime = t;
next->m_flStartTime = t;
}
}
for ( int j = 0 ; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
CPhonemeTag *next = NULL;
if ( j < word->m_Phonemes.Size() - 1 )
{
next = word->m_Phonemes[ j + 1 ];
}
if ( phoneme && next )
{
float eps = next->GetStartTime() - phoneme->GetEndTime();
if ( eps && eps <= snap_epsilon )
{
float t = (phoneme->GetEndTime() + next->GetStartTime() ) * 0.5;
phoneme->SetEndTime( t );
next->SetStartTime( t );
}
}
}
}
if ( prepareundo )
{
PushRedo();
}
// NOTE: Caller must call "redraw()" to get screen to update
}
void PhonemeEditor::RealignPhonemesToWords( bool prepareundo )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( prepareundo )
{
SetDirty( true );
PushUndo();
}
SortWords( false );
SortPhonemes( false );
for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
CWordTag *next = NULL;
if ( i < m_Tags.m_Words.Size() - 1 )
{
next = m_Tags.m_Words[ i + 1 ];
}
float word_dt = word->m_flEndTime - word->m_flStartTime;
CPhonemeTag *FirstPhoneme = word->m_Phonemes[ 0 ];
if ( !FirstPhoneme )
continue;
CPhonemeTag *LastPhoneme = word->m_Phonemes[ word->m_Phonemes.Size() - 1 ];
if ( !LastPhoneme )
continue;
float phoneme_dt = LastPhoneme->GetEndTime() - FirstPhoneme->GetStartTime();
float phoneme_shift = FirstPhoneme->GetStartTime();
for ( int j = 0 ; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *phoneme = word->m_Phonemes[ j ];
if ( !phoneme )
continue;
CPhonemeTag *next = NULL;
if ( j < word->m_Phonemes.Size() - 1 )
{
next = word->m_Phonemes[ j + 1 ];
}
if (j == 0)
{
float t = (phoneme->GetStartTime() - phoneme_shift ) * (word_dt / phoneme_dt) + word->m_flStartTime;
phoneme->SetStartTime( t );
}
float t = (phoneme->GetEndTime() - phoneme_shift ) * (word_dt / phoneme_dt) + word->m_flStartTime;
phoneme->SetEndTime( t );
if (next)
{
next->SetStartTime( t );
}
}
}
if ( prepareundo )
{
PushRedo();
}
// NOTE: Caller must call "redraw()" to get screen to update
}
void PhonemeEditor::RealignWordsToPhonemes( bool prepareundo )
{
if ( GetMode() != MODE_PHONEMES )
return;
if ( prepareundo )
{
SetDirty( true );
PushUndo();
}
SortWords( false );
SortPhonemes( false );
for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
CPhonemeTag *FirstPhoneme = word->m_Phonemes[ 0 ];
if ( !FirstPhoneme )
continue;
CPhonemeTag *LastPhoneme = word->m_Phonemes[ word->m_Phonemes.Size() - 1 ];
if ( !LastPhoneme )
continue;
word->m_flStartTime = FirstPhoneme->GetStartTime();
word->m_flEndTime = LastPhoneme->GetEndTime();
}
if ( prepareundo )
{
PushRedo();
}
// NOTE: Caller must call "redraw()" to get screen to update
}
float PhonemeEditor::ComputeMaxWordShift( bool forward, bool allowcrop )
{
// skipping selected words, figure out max time shift of words before they selection touches any
// unselected words
// if allowcrop is true, then the maximum extends up to end of next word
float maxshift = PLENTY_OF_TIME;
if ( forward )
{
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *w1 = m_Tags.m_Words[ i ];
if ( !w1 || !w1->m_bSelected )
continue;
CWordTag *w2 = NULL;
for ( int search = i + 1; search < m_Tags.m_Words.Size() ; search++ )
{
CWordTag *check = m_Tags.m_Words[ search ];
if ( !check || check->m_bSelected )
continue;
w2 = check;
break;
}
if ( w2 )
{
float shift;
if ( allowcrop )
{
shift = w2->m_flEndTime - w1->m_flEndTime;
}
else
{
shift = w2->m_flStartTime - w1->m_flEndTime;
}
if ( shift < maxshift )
{
maxshift = shift;
}
}
}
}
else
{
for ( int i = m_Tags.m_Words.Size() -1; i >= 0; i-- )
{
CWordTag *w1 = m_Tags.m_Words[ i ];
if ( !w1 || !w1->m_bSelected )
continue;
CWordTag *w2 = NULL;
for ( int search = i - 1; search >= 0 ; search-- )
{
CWordTag *check = m_Tags.m_Words[ search ];
if ( !check || check->m_bSelected )
continue;
w2 = check;
break;
}
if ( w2 )
{
float shift;
if ( allowcrop )
{
shift = w1->m_flStartTime - w2->m_flStartTime;
}
else
{
shift = w1->m_flStartTime - w2->m_flEndTime;
}
if ( shift < maxshift )
{
maxshift = shift;
}
}
}
}
return maxshift;
}
float PhonemeEditor::ComputeMaxPhonemeShift( bool forward, bool allowcrop )
{
// skipping selected phonemes, figure out max time shift of phonemes before they selection touches any
// unselected words
// if allowcrop is true, then the maximum extends up to end of next word
float maxshift = PLENTY_OF_TIME;
if ( forward )
{
for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
{
CPhonemeTag *p1 = word->m_Phonemes[ j ];
if ( !p1 || !p1->m_bSelected )
continue;
// Find next unselected phoneme
CPhonemeTag *p2 = NULL;
CPhonemeTag *start = p1;
do
{
CPhonemeTag *test = NULL;
GetTimeGapToNextPhoneme( forward, start, NULL, &test );
if ( !test )
break;
if ( test->m_bSelected )
{
start = test;
continue;
}
p2 = test;
break;
} while ( 1 );
if ( p2 )
{
float shift;
if ( allowcrop )
{
shift = p2->GetEndTime() - p1->GetEndTime();
}
else
{
shift = p2->GetStartTime() - p1->GetEndTime();
}
if ( shift < maxshift )
{
maxshift = shift;
}
}
}
}
}
else
{
for ( int i = m_Tags.m_Words.Size() -1; i >= 0; i-- )
{
CWordTag *word = m_Tags.m_Words[ i ];
if ( !word )
continue;
for ( int j = word->m_Phonemes.Size() - 1; j >= 0; j-- )
{
CPhonemeTag *p1 = word->m_Phonemes[ j ];
if ( !p1 || !p1->m_bSelected )
continue;
// Find previous unselected phoneme
CPhonemeTag *p2 = NULL;
CPhonemeTag *start = p1;
do
{
CPhonemeTag *test = NULL;
GetTimeGapToNextPhoneme( forward, start, NULL, &test );
if ( !test )
break;
if ( test->m_bSelected )
{
start = test;
continue;
}
p2 = test;
break;
} while ( 1 );
if ( p2 )
{
float shift;
if ( allowcrop )
{
shift = p1->GetStartTime() - p2->GetStartTime();
}
else
{
shift = p1->GetStartTime() - p2->GetEndTime();
}
if ( shift < maxshift )
{
maxshift = shift;
}
}
}
}
}
return maxshift;
}
int PhonemeEditor::PixelsForDeltaTime( float dt )
{
if ( !dt )
return 0;
RECT rc;
GetWorkspaceRect( rc );
float starttime = m_nLeftOffset / GetPixelsPerSecond();
float endtime = w2() / GetPixelsPerSecond() + starttime;
float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
float pixels = dt / timeperpixel;
return abs( (int)pixels );
}
void PhonemeEditor::ClearDragLimit( void )
{
m_bLimitDrag = false;
m_nLeftLimit = -1;
m_nRightLimit = -1;
}
void PhonemeEditor::SetDragLimit( int dragtype )
{
ClearDragLimit();
float nextW, nextP;
float prevW, prevP;
nextW = ComputeMaxWordShift( true, false );
prevW = ComputeMaxWordShift( false, false );
nextP = ComputeMaxPhonemeShift( true, false );
prevP = ComputeMaxPhonemeShift( false, false );
/*
Con_Printf( "+w %f -w %f +p %f -p %f\n",
1000.0f * nextW,
1000.0f * prevW,
1000.0f * nextP,
1000.0f * prevP );
*/
switch ( dragtype )
{
case DRAGTYPE_MOVEWORD:
m_bLimitDrag = true;
m_nLeftLimit = PixelsForDeltaTime( prevW );
m_nRightLimit = PixelsForDeltaTime( nextW );
break;
case DRAGTYPE_MOVEPHONEME:
m_bLimitDrag = true;
m_nLeftLimit = PixelsForDeltaTime( prevP );
m_nRightLimit = PixelsForDeltaTime( nextP );
break;
default:
ClearDragLimit();
break;
}
}
void PhonemeEditor::LimitDrag( int& mousex )
{
if ( m_nDragType == DRAGTYPE_NONE )
return;
if ( !m_bLimitDrag )
return;
int delta = mousex - m_nStartX;
if ( delta > 0 )
{
if ( m_nRightLimit >= 0 )
{
if ( delta > m_nRightLimit )
{
mousex = m_nStartX + m_nRightLimit;
}
}
}
else if ( delta < 0 )
{
if ( m_nLeftLimit >= 0 )
{
if ( abs( delta ) > abs( m_nLeftLimit ) )
{
mousex = m_nStartX - m_nLeftLimit;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Wipe undo/redo data
//-----------------------------------------------------------------------------
void PhonemeEditor::ClearUndo( void )
{
WipeUndo();
WipeRedo();
SetDirty( false );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *tag -
//-----------------------------------------------------------------------------
void PhonemeEditor::SelectExpression( CPhonemeTag *tag )
{
if ( !models->GetActiveStudioModel() )
return;
CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
if ( !hdr )
return;
// Make sure phonemes are loaded
FacePoser_EnsurePhonemesLoaded();
CExpClass *cl = expressions->FindClass( "phonemes", true );
if ( !cl )
{
Con_Printf( "Couldn't load expressions/phonemes.txt!\n" );
return;
}
if ( expressions->GetActiveClass() != cl )
{
expressions->ActivateExpressionClass( cl );
}
CExpression *exp = cl->FindExpression( ConvertPhoneme( tag->GetPhonemeCode() ) );
if ( !exp )
{
Con_Printf( "Couldn't find phoneme '%s'\n", ConvertPhoneme( tag->GetPhonemeCode() ) );
return;
}
float *settings = exp->GetSettings();
for (LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); i++)
{
int j = hdr->pFlexcontroller( i )->localToGlobal;
models->GetActiveStudioModel()->SetFlexController( i, settings[j] );
}
}
void PhonemeEditor::OnSAPI( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
g_viewerSettings.speechapiindex = SPEECH_API_SAPI;
m_pPhonemeExtractor = NULL;
CheckSpeechAPI();
redraw();
}
void PhonemeEditor::OnLipSinc( void )
{
if ( GetMode() != MODE_PHONEMES )
return;
g_viewerSettings.speechapiindex = SPEECH_API_LIPSINC;
m_pPhonemeExtractor = NULL;
CheckSpeechAPI();
redraw();
}
void PhonemeEditor::LoadPhonemeConverters()
{
m_pPhonemeExtractor = NULL;
// Enumerate modules under bin folder of exe
FileFindHandle_t findHandle;
const char *pFilename = filesystem->FindFirstEx( "phonemeextractors/*.dll", "EXECUTABLE_PATH", &findHandle );
while( pFilename )
{
char fullpath[ 512 ];
Q_snprintf( fullpath, sizeof( fullpath ), "phonemeextractors/%s", pFilename );
Con_Printf( "Loading extractor from %s\n", fullpath );
Extractor e;
e.module = Sys_LoadModule( fullpath );
if ( !e.module )
{
pFilename = filesystem->FindNext( findHandle );
continue;
}
CreateInterfaceFn factory = Sys_GetFactory( e.module );
if ( !factory )
{
pFilename = filesystem->FindNext( findHandle );
continue;
}
e.extractor = ( IPhonemeExtractor * )factory( VPHONEME_EXTRACTOR_INTERFACE, NULL );
if ( !e.extractor )
{
Warning( "Unable to get IPhonemeExtractor interface version %s from %s\n", VPHONEME_EXTRACTOR_INTERFACE, fullpath );
pFilename = filesystem->FindNext( findHandle );
continue;
}
e.apitype = e.extractor->GetAPIType();
g_Extractors.AddToTail( e );
pFilename = filesystem->FindNext( findHandle );
}
filesystem->FindClose( findHandle );
}
void PhonemeEditor::ValidateSpeechAPIIndex()
{
if ( !DoesExtractorExistFor( (PE_APITYPE)g_viewerSettings.speechapiindex ) )
{
if ( g_Extractors.Count() > 0 )
g_viewerSettings.speechapiindex = g_Extractors[0].apitype;
}
}
void PhonemeEditor::UnloadPhonemeConverters()
{
int c = g_Extractors.Count();
for ( int i = c - 1; i >= 0; i-- )
{
Extractor *e = &g_Extractors[ i ];
Sys_UnloadModule( e->module );
}
g_Extractors.RemoveAll();
m_pPhonemeExtractor = NULL;
}
bool PhonemeEditor::CheckSpeechAPI( void )
{
if ( GetMode() != MODE_PHONEMES )
{
return false;
}
if ( !m_pPhonemeExtractor )
{
int c = g_Extractors.Count();
for ( int i = 0; i < c; i++ )
{
Extractor *e = &g_Extractors[ i ];
if ( e->apitype == (PE_APITYPE)g_viewerSettings.speechapiindex )
{
m_pPhonemeExtractor = e->extractor;
break;
}
}
if ( !m_pPhonemeExtractor )
{
Con_ErrorPrintf( "Couldn't find phoneme extractor %i\n",
g_viewerSettings.speechapiindex );
}
}
return m_pPhonemeExtractor != NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
char const *PhonemeEditor::GetSpeechAPIName( void )
{
CheckSpeechAPI();
if ( m_pPhonemeExtractor )
{
return m_pPhonemeExtractor->GetName();
}
return "Unknown Speech API";
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::PaintBackground( void )
{
redraw();
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : PhonemeEditor::EditorMode
//-----------------------------------------------------------------------------
PhonemeEditor::EditorMode PhonemeEditor::GetMode( void ) const
{
return m_CurrentMode;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcWorkSpace -
// rcEmphasis -
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_GetRect( RECT const & rcWorkSpace, RECT& rcEmphasis )
{
rcEmphasis = rcWorkSpace;
int ybottom = rcWorkSpace.bottom - 2 * m_nTickHeight - 2;
int workspaceheight = rcWorkSpace.bottom - rcWorkSpace.top;
// Just past midpoint
rcEmphasis.top = rcWorkSpace.top + workspaceheight / 2 + 2;
// 60 units or
rcEmphasis.bottom = clamp( rcEmphasis.top + 60, rcEmphasis.top + 20, ybottom );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::OnModeChanged( void )
{
// Show/hide controls as necessary
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *parent -
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_Init( void )
{
m_nNumSelected = 0;
}
CEmphasisSample *PhonemeEditor::Emphasis_GetSampleUnderMouse( mxEvent *event )
{
if ( GetMode() != MODE_EMPHASIS )
return NULL;
if ( !m_pWaveFile )
return NULL;
if ( w2() <= 0 )
return NULL;
if ( GetPixelsPerSecond() <= 0 )
return NULL;
float timeperpixel = 1.0f / GetPixelsPerSecond();
float closest_dist = 999999.0f;
CEmphasisSample *bestsample = NULL;
int samples = m_Tags.GetNumSamples();
float clickTime = GetTimeForPixel( (short)event->x );
for ( int i = 0; i < samples; i++ )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
float dist = fabs( sample->time - clickTime );
if ( dist < closest_dist )
{
bestsample = sample;
closest_dist = dist;
}
}
// Not close to any of them!!!
if ( closest_dist > ( 5.0f * timeperpixel ) )
{
return NULL;
}
return bestsample;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_DeselectAll( void )
{
if ( GetMode() != MODE_EMPHASIS )
return;
for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
sample->selected = false;
}
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_SelectAll( void )
{
if ( GetMode() != MODE_EMPHASIS )
return;
for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
sample->selected = true;
}
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_Delete( void )
{
if ( GetMode() != MODE_EMPHASIS )
return;
SetDirty( true );
PushUndo();
for ( int i = m_Tags.GetNumSamples() - 1; i >= 0 ; i-- )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
if ( !sample->selected )
continue;
m_Tags.m_EmphasisSamples.Remove( i );
SetDirty( true );
}
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : sample -
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_AddSample( CEmphasisSample const& sample )
{
if ( GetMode() != MODE_EMPHASIS )
return;
SetDirty( true );
PushUndo();
m_Tags.m_EmphasisSamples.AddToTail( sample );
m_Tags.Resort();
PushRedo();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_CountSelected( void )
{
m_nNumSelected = 0;
for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
if ( !sample || !sample->selected )
continue;
m_nNumSelected++;
}
}
void PhonemeEditor::Emphasis_ShowContextMenu( mxEvent *event )
{
if ( GetMode() != MODE_EMPHASIS )
return;
CountSelected();
// Construct main menu
mxPopupMenu *pop = new mxPopupMenu();
if ( m_nNumSelected > 0 )
{
pop->add( va( "Delete" ), IDC_EMPHASIS_DELETE );
pop->add( "Deselect all", IDC_EMPHASIS_DESELECT );
}
pop->add( "Select all", IDC_EMPHASIS_SELECTALL );
pop->popup( this, (short)event->x, (short)event->y );
}
void PhonemeEditor::Emphasis_MouseDrag( int x, int y )
{
if ( m_nDragType != DRAGTYPE_EMPHASIS_MOVE )
return;
RECT rcWork;
GetWorkspaceRect( rcWork );
RECT rc;
Emphasis_GetRect( rcWork, rc );
int height = rc.bottom - rc.top;
int dx = x - m_nLastX;
int dy = y - m_nLastY;
float dfdx = (float)dx * GetTimePerPixel();
float dfdy = (float)dy / (float)height;
for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
if ( !sample || !sample->selected )
continue;
sample->time += dfdx;
//sample->time = clamp( sample->time, 0.0f, 1.0f );
sample->value -= dfdy;
sample->value = clamp( sample->value, 0.0f, 1.0f );
}
}
void PhonemeEditor::Emphasis_Redraw( CChoreoWidgetDrawHelper& drawHelper, RECT& rcWorkSpace )
{
if ( GetMode() != MODE_EMPHASIS &&
GetMode() != MODE_PHONEMES )
return;
bool fullmode = GetMode() == MODE_EMPHASIS;
RECT rcClient;
Emphasis_GetRect( rcWorkSpace, rcClient );
RECT rcText;
rcText = rcClient;
InflateRect( &rcText, -15, 0 );
OffsetRect( &rcText, 0, -20 );
rcText.bottom = rcText.top + 20;
if ( fullmode )
{
drawHelper.DrawColoredText( "Arial", 15, FW_BOLD, PEColor( COLOR_PHONEME_EMPHASIS_TEXT ), rcText, "Emphasis..." );
}
{
int h = rcClient.bottom - rcClient.top;
int offset = h/3;
RECT rcSpot = rcClient;
rcSpot.bottom = rcSpot.top + offset;
drawHelper.DrawGradientFilledRect(
rcSpot,
PEColor( COLOR_PHONEME_EMPHASIS_BG_STRONG ),
PEColor( COLOR_PHONEME_EMPHASIS_BG ),
true );
OffsetRect( &rcSpot, 0, offset );
drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_EMPHASIS_BG ), rcSpot );
OffsetRect( &rcSpot, 0, offset );
drawHelper.DrawGradientFilledRect(
rcSpot,
PEColor( COLOR_PHONEME_EMPHASIS_BG ),
PEColor( COLOR_PHONEME_EMPHASIS_BG_WEAK ),
true );
}
COLORREF gray = PEColor( COLOR_PHONEME_EMPHASIS_MIDLINE );
drawHelper.DrawOutlinedRect( PEColor( COLOR_PHONEME_EMPHASIS_BORDER ), PS_SOLID, 1, rcClient );
COLORREF lineColor = PEColor( COLOR_PHONEME_EMPHASIS_LINECOLOR );
COLORREF dotColor = PEColor( COLOR_PHONEME_EMPHASIS_DOTCOLOR );
COLORREF dotColorSelected = PEColor( COLOR_PHONEME_EMPHASIS_DOTCOLOR_SELECTED );
int midy = ( rcClient.bottom + rcClient.top ) / 2;
drawHelper.DrawColoredLine( gray, PS_SOLID, 1, rcClient.left, midy,
rcClient.right, midy );
int height = rcClient.bottom - rcClient.top;
int bottom = rcClient.bottom - 1;
if ( !m_pWaveFile )
return;
float running_length = m_pWaveFile->GetRunningLength();
// FIXME: adjust this based on framerate....
float timeperpixel = GetTimePerPixel();
float starttime, endtime;
GetScreenStartAndEndTime( starttime, endtime );
int prevx = 0;
float prev_t = starttime;
float prev_value = m_Tags.GetIntensity( prev_t, running_length );
int dx = 5;
for ( int x = 0; x < ( w2() + dx ); x += dx )
{
float t = GetTimeForPixel( x );
float value = m_Tags.GetIntensity( t, running_length );
// Draw segment
drawHelper.DrawColoredLine( lineColor, PS_SOLID, 1,
prevx,
bottom - prev_value * height,
x,
bottom - value * height );
prev_t = t;
prev_value = value;
prevx = x;
}
int numsamples = m_Tags.GetNumSamples();
for ( int sample = 0; sample < numsamples; sample++ )
{
CEmphasisSample *start = m_Tags.GetSample( sample );
int x = ( start->time - starttime ) / timeperpixel;
float value = m_Tags.GetIntensity( start->time, running_length );
int y = bottom - value * height;
int dotsize = 4;
int dotSizeSelected = 5;
COLORREF clr = dotColor;
COLORREF clrSelected = dotColorSelected;
drawHelper.DrawCircle(
start->selected ? clrSelected : clr,
x, y,
start->selected ? dotSizeSelected : dotsize,
true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::Emphasis_IsValid( void )
{
if ( m_Tags.GetNumSamples() > 0 )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void PhonemeEditor::Emphasis_SelectPoints( void )
{
if ( GetMode() != MODE_EMPHASIS )
return;
RECT rcWork, rcEmphasis;
GetWorkspaceRect( rcWork );
Emphasis_GetRect( rcWork, rcEmphasis );
RECT rcSelection;
rcSelection.left = m_nStartX < m_nLastX ? m_nStartX : m_nLastX;
rcSelection.right = m_nStartX < m_nLastX ? m_nLastX : m_nStartX;
rcSelection.top = m_nStartY < m_nLastY ? m_nStartY : m_nLastY;
rcSelection.bottom = m_nStartY < m_nLastY ? m_nLastY : m_nStartY;
rcSelection.top = max( rcSelection.top, rcEmphasis.top );
rcSelection.bottom = min( rcSelection.bottom, rcEmphasis.bottom );
int eh, ew;
eh = rcEmphasis.bottom - rcEmphasis.top;
ew = rcEmphasis.right - rcEmphasis.left;
InflateRect( &rcSelection, 5, 5 );
if ( !w2() || !h2() )
return;
float fleft = GetTimeForPixel( rcSelection.left );
float fright = GetTimeForPixel( rcSelection.right );
float ftop = (float)( rcSelection.top - rcEmphasis.top ) / (float)eh;
float fbottom = (float)( rcSelection.bottom- rcEmphasis.top ) / (float)eh;
//fleft = clamp( fleft, 0.0f, 1.0f );
//fright = clamp( fright, 0.0f, 1.0f );
ftop = clamp( ftop, 0.0f, 1.0f );
fbottom = clamp( fbottom, 0.0f, 1.0f );
float eps = 0.005;
for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
{
CEmphasisSample *sample = m_Tags.GetSample( i );
if ( sample->time + eps < fleft )
continue;
if ( sample->time - eps > fright )
continue;
if ( (1.0f - sample->value ) + eps < ftop )
continue;
if ( (1.0f - sample->value ) - eps > fbottom )
continue;
sample->selected = true;
}
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcHandle -
//-----------------------------------------------------------------------------
void PhonemeEditor::GetScrubHandleRect( RECT& rcHandle, bool clipped )
{
float pixel = 0.0f;
if ( m_pWaveFile )
{
float currenttime = m_flScrub;
float starttime, endtime;
GetScreenStartAndEndTime( starttime, endtime );
float screenfrac = ( currenttime - starttime ) / ( endtime - starttime );
pixel = screenfrac * w2();
if ( clipped )
{
pixel = clamp( pixel, SCRUBBER_HANDLE_WIDTH/2, w2() - SCRUBBER_HANDLE_WIDTH/2 );
}
}
rcHandle.left = pixel-SCRUBBER_HANDLE_WIDTH/2;
rcHandle.right = pixel + SCRUBBER_HANDLE_WIDTH/2;
rcHandle.top = 2 + GetCaptionHeight() + 12;
rcHandle.bottom = rcHandle.top + SCRUBBER_HANDLE_HEIGHT;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcArea -
//-----------------------------------------------------------------------------
void PhonemeEditor::GetScrubAreaRect( RECT& rcArea )
{
rcArea.left = 0;
rcArea.right = w2();
rcArea.top = 2 + GetCaptionHeight() + 12;
rcArea.bottom = rcArea.top + SCRUBBER_HEIGHT - 4;
}
void PhonemeEditor::DrawScrubHandle()
{
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
rcHandle.left = 0;
rcHandle.right = w2();
CChoreoWidgetDrawHelper drawHelper( this, rcHandle );
DrawScrubHandle( drawHelper );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rcHandle -
//-----------------------------------------------------------------------------
void PhonemeEditor::DrawScrubHandle( CChoreoWidgetDrawHelper& drawHelper )
{
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
HBRUSH br = CreateSolidBrush( RGB( 0, 150, 100 ) );
COLORREF areaBorder = RGB( 230, 230, 220 );
drawHelper.DrawColoredLine( areaBorder,
PS_SOLID, 1, 0, rcHandle.top, w2(), rcHandle.top );
drawHelper.DrawColoredLine( areaBorder,
PS_SOLID, 1, 0, rcHandle.bottom, w2(), rcHandle.bottom );
drawHelper.DrawFilledRect( br, rcHandle );
//
char sz[ 32 ];
sprintf( sz, "%.3f", m_flScrub );
int len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
RECT rcText = rcHandle;
int textw = rcText.right - rcText.left;
rcText.left += ( textw - len ) / 2;
drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 255, 255, 255 ), rcText, sz );
DeleteObject( br );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool PhonemeEditor::IsMouseOverScrubHandle( mxEvent *event )
{
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
InflateRect( &rcHandle, 2, 2 );
POINT pt;
pt.x = (short)event->x;
pt.y = (short)event->y;
if ( PtInRect( &rcHandle, pt ) )
{
return true;
}
return false;
}
bool PhonemeEditor::IsMouseOverScrubArea( mxEvent *event )
{
RECT rcArea;
rcArea.left = 0;
rcArea.right = w2();
rcArea.top = 2 + GetCaptionHeight() + 12;
rcArea.bottom = rcArea.top + 10;
InflateRect( &rcArea, 2, 2 );
POINT pt;
pt.x = (short)event->x;
pt.y = (short)event->y;
if ( PtInRect( &rcArea, pt ) )
{
return true;
}
return false;
}
float PhonemeEditor::GetTimeForSample( int sample )
{
if ( !m_pWaveFile )
{
return 0.0f;
}
float duration = m_pWaveFile->GetRunningLength();
int sampleCount = m_pWaveFile->SampleCount();
if ( sampleCount <= 0 )
return 0.0f;
float frac = (float)sample / (float)sampleCount;
return frac * duration;
}
void PhonemeEditor::ClampTimeToSelectionInterval( float& timeval )
{
if ( !m_pWaveFile )
{
return;
}
if ( !m_pMixer || !sound->IsSoundPlaying( m_pMixer ) )
{
return;
}
if ( !m_bSelectionActive )
return;
float starttime = GetTimeForSample( m_nSelection[ 0 ] );
float endtime = GetTimeForSample( m_nSelection[ 1 ] );
Assert( starttime <= endtime );
timeval = clamp( timeval, starttime, endtime );
}
void PhonemeEditor::ScrubThink( float dt, bool scrubbing )
{
ClampTimeToSelectionInterval( m_flScrub );
ClampTimeToSelectionInterval( m_flScrubTarget );
if ( m_flScrubTarget == m_flScrub && !scrubbing )
{
if ( sound->IsSoundPlaying( m_pMixer ) )
{
sound->StopSound( m_pMixer );
}
return;
}
if ( !m_pWaveFile )
return;
bool newmixer = false;
if ( !m_pMixer || !sound->IsSoundPlaying( m_pMixer ) )
{
m_pMixer = NULL;
SaveLinguisticData();
StudioModel *model = NULL;//models->GetActiveStudioModel();
sound->PlaySound( model, VOL_NORM, m_WorkFile.m_szWorkingFile, &m_pMixer );
newmixer = true;
}
if ( !m_pMixer )
{
return;
}
if ( m_flScrub > m_flScrubTarget )
{
m_pMixer->SetDirection( false );
}
else
{
m_pMixer->SetDirection( true );
}
float duration = m_pWaveFile->GetRunningLength();
if ( !duration )
return;
float d = m_flScrubTarget - m_flScrub;
int sign = d > 0.0f ? 1 : -1;
float maxmove = dt * m_flPlaybackRate;
if ( sign > 0 )
{
if ( d < maxmove )
{
m_flScrub = m_flScrubTarget;
}
else
{
m_flScrub += maxmove;
}
}
else
{
if ( -d < maxmove )
{
m_flScrub = m_flScrubTarget;
}
else
{
m_flScrub -= maxmove;
}
}
int sampleCount = m_pMixer->GetSource()->SampleCount();
int cursample = sampleCount * ( m_flScrub / duration );
int realsample = m_pMixer->GetSamplePosition();
int dsample = cursample - realsample;
int onehundredth = m_pMixer->GetSource()->SampleRate() * 0.01f;
if ( abs( dsample ) > onehundredth )
{
m_pMixer->SetSamplePosition( cursample, true );
}
m_pMixer->SetActive( true );
RECT rcArea;
GetScrubAreaRect( rcArea );
CChoreoWidgetDrawHelper drawHelper( this, rcArea );
DrawScrubHandle( drawHelper );
if ( scrubbing )
{
g_pMatSysWindow->Frame();
}
}
void PhonemeEditor::SetScrubTime( float t )
{
m_flScrub = t;
ClampTimeToSelectionInterval( m_flScrub );
}
void PhonemeEditor::SetScrubTargetTime( float t )
{
m_flScrubTarget = t;
ClampTimeToSelectionInterval( m_flScrubTarget );
}
void PhonemeEditor::OnToggleVoiceDuck()
{
SetDirty( true );
PushUndo();
m_Tags.SetVoiceDuck( !m_Tags.GetVoiceDuck() );
PushRedo();
redraw();
}
void PhonemeEditor::Play()
{
PlayEditedWave( m_bSelectionActive );
}