mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 14:16:50 +00:00
8800 lines
190 KiB
C++
8800 lines
190 KiB
C++
//========= 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( ¶ms, 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( ¶ms );
|
|
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( ¶ms, 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( ¶ms );
|
|
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, ¤t, &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, ¤t, &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( ¶ms, 0, sizeof( params ) );
|
|
strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
|
|
strcpy( params.m_szName, "" );
|
|
|
|
int iret = PhonemeProperties( ¶ms );
|
|
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( ¶ms, 0, sizeof( params ) );
|
|
strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
|
|
strcpy( params.m_szName, "" );
|
|
|
|
int iret = PhonemeProperties( ¶ms );
|
|
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( ¶ms, 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( ¶ms );
|
|
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( ¶ms, 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( ¶ms );
|
|
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( ¶ms, 0, sizeof( params ) );
|
|
strcpy( params.m_szDialogTitle, "Phrase Word List" );
|
|
strcpy( params.m_szPrompt, "Phrase" );
|
|
|
|
strcpy( params.m_szInputText, wordstring );
|
|
|
|
if ( !InputProperties( ¶ms ) )
|
|
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( ¶ms, 0, sizeof( params ) );
|
|
strcpy( params.m_szDialogTitle, "Word List" );
|
|
strcpy( params.m_szPrompt, "Sentence:" );
|
|
|
|
strcpy( params.m_szInputText, wordstring );
|
|
|
|
if ( !InputProperties( ¶ms ) )
|
|
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( ¶ms, 0, sizeof( params ) );
|
|
strcpy( params.m_szDialogTitle, "Event Tag Name" );
|
|
strcpy( params.m_szPrompt, "Name:" );
|
|
strcpy( params.m_szInputText, "" );
|
|
|
|
if ( !InputProperties( ¶ms ) )
|
|
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( ¶ms, 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( ¶ms );
|
|
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 );
|
|
}
|
|
|
|
|
|
|
|
|
|
|