bool UBWindowsMediaFile::close()
{
bool result = true;
if (mWMWriter)
{
if (FAILED(mWMWriter->EndWriting()))
{
result = false;
}
}
if (mPushSink)
{
mPushSink->Disconnect();
mPushSink->EndSession();
mPushSink->Release();
}
if(mChapters.length() > 0)
{
IWMMetadataEditor *editor = 0;
IWMHeaderInfo *headerInfo = 0;
WMCreateEditor(&editor);
editor->Open((LPCTSTR) mVideoFileName.utf16());
editor->QueryInterface(IID_IWMHeaderInfo, (void**)&headerInfo);
foreach(MarkerInfo mi, mChapters)
{
headerInfo->AddMarker((LPWSTR)mi.label.utf16(), msToSampleTime(mi.timestamp));
}
bool WMA::Close()
{
m_bOpen = false;
if(m_hWaitEvent) {
if(m_pReader) {
m_pReader->Stop();
}
SetEvent(m_hWaitEvent);
EnterCriticalSection(&m_csTerm);
LeaveCriticalSection(&m_csTerm);
DeleteCriticalSection(&m_csTerm);
}
if(m_hWaitEvent)
{
CloseHandle(m_hWaitEvent);
m_hWaitEvent = 0;
}
if(m_hRespondEvent)
{
CloseHandle(m_hRespondEvent);
m_hRespondEvent = 0;
}
if(m_pHeaderInfo) {
m_pHeaderInfo->Release();
m_pHeaderInfo = 0;
}
if(m_pReaderAdvanced2) {
m_pReaderAdvanced2->Release();
m_pReaderAdvanced2 = 0;
}
if(m_pReaderAdvanced) {
m_pReaderAdvanced->Release();
m_pReaderAdvanced = 0;
}
if(m_pReader) {
m_pReader->Release();
m_pReader = 0;
}
if(m_pBuffer) {
delete [] m_pBuffer;
m_pBuffer = 0;
}
Clear();
return true;
}
bool WMA::PostOpen()
{
WaitForSingleObject( m_hRespondEvent, INFINITE );
if( FAILED(m_hrCallbackResult) ) {
return false;
}
uint32_t nOutputCount;
HRESULT hr = m_pReader->GetOutputCount( &nOutputCount );
if( FAILED(hr) ) {
return false;
}
//ensure this is audio only
if( nOutputCount != 1 ) {
return false;
}
uint32_t nOutputFormatCount;
hr = m_pReader->GetOutputFormatCount(0, &nOutputFormatCount);
if(FAILED(hr)) {
return FALSE;
}
uint32_t nFormatSize = 0;
BYTE* pBuf = 0;
IWMOutputMediaProps* pProps = 0;
for( uint32_t j = 0; j < nOutputFormatCount; j++ ) {
hr = m_pReader->GetOutputFormat( 0, j, &pProps );
if(FAILED(hr)) {
continue;
}
//get required size of the media type structure
uint32_t nNewSize = 0;
hr = pProps->GetMediaType( NULL, & nNewSize );
if( FAILED(hr) ) {
continue;
}
if(nNewSize > nFormatSize)
{
if( pBuf ) {
delete [] pBuf;
pBuf = 0;
}
nFormatSize = nNewSize;
pBuf = new BYTE[nFormatSize];
}
WM_MEDIA_TYPE* pType = (WM_MEDIA_TYPE*) pBuf;
hr = pProps->GetMediaType(pType, & nFormatSize);
if(FAILED(hr))
continue;
if(pType->formattype == WMFORMAT_WaveFormatEx)
{
memcpy( &m_WaveFormatEx, pType->pbFormat, pType->cbFormat );
if((m_WaveFormatEx.nChannels == 2) && (m_WaveFormatEx.wBitsPerSample == 16) && (m_WaveFormatEx.nSamplesPerSec == 44100)) {
break;
}
}
if(pProps) {
pProps->Release();
pProps = 0;
}
}
if(pBuf) {
delete [] pBuf;
pBuf = 0;
}
m_pReader->SetOutputProps( 0, pProps );
if(FAILED(hr)) {
return false;
}
if(pProps) {
pProps->Release();
pProps = 0;
}
//tells it to read as fast possible
//hr = m_pReaderAdvanced->SetUserProvidedClock(true);
if(FAILED(hr)) {
return false;
}
WORD wStreamNum = 0;
WMT_ATTR_DATATYPE Type;
QWORD dwDuration = 0;
WORD wLength = 8;
hr = m_pHeaderInfo->GetAttributeByName(&wStreamNum, g_wszWMDuration, &Type, (BYTE*)&dwDuration, &wLength);
if(FAILED(hr)) {
return false;
}
//divide by 10 million to get seconds
double fTime = double(dwDuration) / 10000000.0f;
m_nStreamSize = fTime * m_WaveFormatEx.nAvgBytesPerSec * 1.5;
//create a default 1.5 second scratch buffer for seconding streams
m_pBuffer = new uint8_t[m_WaveFormatEx.nAvgBytesPerSec * 1.5];
m_nBufferSize = m_WaveFormatEx.nAvgBytesPerSec * 1.5;
m_nTargetPtr = 0;
m_nWritePtr = 0;
m_bOpen = true;
return true;
}
//------------------------------------------------------------------------------
// Name: ShowAttributes()
// Desc: Display all attributes for the specified stream,
// using IWMHeaderInfo.
//------------------------------------------------------------------------------
HRESULT ShowAttributes( __in LPWSTR pwszInFile, WORD wStreamNum )
{
HRESULT hr = S_OK;
IWMMetadataEditor * pEditor = NULL;
IWMHeaderInfo* pHeaderInfo = NULL;
WCHAR * pwszAttribName = NULL;
WORD wAttribNameLen = 0;
WMT_ATTR_DATATYPE wAttribType;
BYTE * pbAttribValue = NULL;
WORD wAttribValueLen = 0;
do
{
hr = EditorOpenFile( pwszInFile, &pEditor, &pHeaderInfo, NULL );
if(FAILED( hr ) )
{
break;
}
WORD wAttributeCount = 0;
hr = pHeaderInfo->GetAttributeCount( wStreamNum, &wAttributeCount );
if(FAILED( hr ) )
{
_tprintf( _T( "GetAttributeCount failed for stream = %d ( hr=0x%08x ).\n" ),
wStreamNum, hr );
break;
}
PrintListHeader();
for( WORD wAttribIndex = 0; wAttribIndex < wAttributeCount; wAttribIndex++ )
{
SAFE_ARRAYDELETE( pwszAttribName );
SAFE_ARRAYDELETE( pbAttribValue );
hr = pHeaderInfo->GetAttributeByIndex( wAttribIndex,
&wStreamNum,
pwszAttribName,
&wAttribNameLen,
&wAttribType,
pbAttribValue,
&wAttribValueLen );
if( FAILED( hr ) )
{
_tprintf( _T( "GetAttributeByIndex failed for index = %d ( hr=0x%08x ).\n" ),
wAttribIndex, hr );
break;
}
pwszAttribName = new WCHAR[ wAttribNameLen ];
if( NULL == pwszAttribName )
{
hr = E_OUTOFMEMORY;
break;
}
pbAttribValue = new BYTE[ wAttribValueLen ];
if( NULL == pbAttribValue )
{
hr = E_OUTOFMEMORY;
break;
}
hr = pHeaderInfo->GetAttributeByIndex( wAttribIndex,
&wStreamNum,
pwszAttribName,
&wAttribNameLen,
&wAttribType,
pbAttribValue,
&wAttribValueLen );
if( FAILED( hr ) )
{
_tprintf( _T( "GetAttributeByIndex failed for index = %d ( hr=0x%08x ).\n" ),
wAttribIndex, hr );
break;
}
hr = PrintAttribute( wAttribIndex,
wStreamNum,
pwszAttribName,
wAttribType,
0,
pbAttribValue,
wAttribValueLen );
if( FAILED( hr ) )
{
break;
}
}
hr = pEditor->Close();
if( FAILED( hr ) )
{
_tprintf( _T( "Could not close the file %ws ( hr=0x%08x ).\n" ), pwszInFile, hr );
break;
}
}
while( FALSE );
SAFE_RELEASE( pHeaderInfo );
SAFE_RELEASE( pEditor );
SAFE_ARRAYDELETE( pwszAttribName );
SAFE_ARRAYDELETE( pbAttribValue );
return( hr );
}
//------------------------------------------------------------------------------
// Name: SetAttrib()
// Desc: Adds an attribute by using IWMHeaderInfo::SetAttribute.
//------------------------------------------------------------------------------
HRESULT SetAttrib( __in LPWSTR pwszInFile,
WORD wStreamNum,
__in LPWSTR pwszAttribName,
WORD wAttribType,
__in LPWSTR pwszAttribValue )
{
if( ( NULL == pwszInFile ) ||
( NULL == pwszAttribName ) ||
( NULL == pwszAttribValue ) )
{
return( E_INVALIDARG );
}
HRESULT hr = S_OK;
IWMMetadataEditor * pEditor = NULL;
IWMHeaderInfo * pHeaderInfo = NULL;
BYTE* pbAttribValue = NULL;
WORD wAttribValueLen = 0;
WMT_ATTR_DATATYPE AttribDataType = ( WMT_ATTR_DATATYPE ) wAttribType;
DWORD dwAttribValue = 0;
WORD wAttribValue = 0;
QWORD qwAttribValue = 0;
BOOL fAttribValue = 0;
do
{
hr = EditorOpenFile( pwszInFile, &pEditor, &pHeaderInfo, NULL);
if(FAILED( hr ) )
{
break;
}
switch( AttribDataType )
{
case WMT_TYPE_DWORD:
dwAttribValue = _wtoi( pwszAttribValue );
wAttribValueLen = sizeof( DWORD );
pbAttribValue = (BYTE *)&dwAttribValue;
break;
case WMT_TYPE_WORD:
wAttribValue = (WORD)_wtoi( pwszAttribValue );
wAttribValueLen = sizeof(WORD);
pbAttribValue = (BYTE *)&wAttribValue;
break;
case WMT_TYPE_QWORD:
qwAttribValue = _wtoi64( pwszAttribValue );
wAttribValueLen = sizeof(QWORD );
pbAttribValue = (BYTE *)&qwAttribValue;
break;
case WMT_TYPE_STRING:
wAttribValueLen = ( wcslen( pwszAttribValue ) + 1 )* sizeof( WCHAR );
pbAttribValue = (BYTE *)pwszAttribValue;
break;
case WMT_TYPE_BOOL:
fAttribValue = (BOOL)_wtoi( pwszAttribValue );
wAttribValueLen = sizeof(BOOL);
pbAttribValue = (BYTE *)&fAttribValue;
break;
default:
_tprintf( _T( "Unsupported data type for SetAttribute\n" ) );
hr = E_INVALIDARG;
break;
}
hr = pHeaderInfo->SetAttribute( wStreamNum,
pwszAttribName,
AttribDataType,
pbAttribValue,
wAttribValueLen );
if( FAILED( hr ) )
{
_tprintf( _T( "SetAttribute failed for Attribute name %ws ( hr=0x%08x ).\n" ),
pwszAttribName, hr );
break;
}
hr = pEditor->Flush();
if( FAILED( hr ) )
{
_tprintf( _T( "Could not flush the file %ws ( hr=0x%08x ).\n" ),
pwszInFile, hr );
break;
}
hr = pEditor->Close();
if( FAILED( hr ) )
{
_tprintf( _T( "Could not close the file %ws ( hr=0x%08x ).\n" ),
pwszInFile, hr );
break;
}
}
while( FALSE );
SAFE_RELEASE( pHeaderInfo );
SAFE_RELEASE( pEditor );
return( hr );
}
int tagread(const string fname, struct fennec_audiotag *rtag)
{
struct fennec_audiotag_item* ct;
HRESULT hres;
IWMHeaderInfo* wminfo;
WORD wmistream = 0;
IWMSyncReader* wmreader;
BOOL sdef = 1;
if(!rtag)return 0;
CoInitialize(0);
if(!fname)
{
if(rtag->tag_title.tsize ) { free(rtag->tag_title.tdata ); rtag->tag_title.tsize = 0; }
if(rtag->tag_album.tsize ) { free(rtag->tag_album.tdata ); rtag->tag_album.tsize = 0; }
if(rtag->tag_artist.tsize ) { free(rtag->tag_artist.tdata ); rtag->tag_artist.tsize = 0; }
if(rtag->tag_origartist.tsize ) { free(rtag->tag_origartist.tdata ); rtag->tag_origartist.tsize = 0; }
if(rtag->tag_composer.tsize ) { free(rtag->tag_composer.tdata ); rtag->tag_composer.tsize = 0; }
if(rtag->tag_lyricist.tsize ) { free(rtag->tag_lyricist.tdata ); rtag->tag_lyricist.tsize = 0; }
if(rtag->tag_band.tsize ) { free(rtag->tag_band.tdata ); rtag->tag_band.tsize = 0; }
if(rtag->tag_copyright.tsize ) { free(rtag->tag_copyright.tdata ); rtag->tag_copyright.tsize = 0; }
if(rtag->tag_publish.tsize ) { free(rtag->tag_publish.tdata ); rtag->tag_publish.tsize = 0; }
if(rtag->tag_encodedby.tsize ) { free(rtag->tag_encodedby.tdata ); rtag->tag_encodedby.tsize = 0; }
if(rtag->tag_genre.tsize ) { free(rtag->tag_genre.tdata ); rtag->tag_genre.tsize = 0; }
if(rtag->tag_year.tsize ) { free(rtag->tag_year.tdata ); rtag->tag_year.tsize = 0; }
if(rtag->tag_url.tsize ) { free(rtag->tag_url.tdata ); rtag->tag_url.tsize = 0; }
if(rtag->tag_offiartisturl.tsize ) { free(rtag->tag_offiartisturl.tdata ); rtag->tag_offiartisturl.tsize = 0; }
//if(rtag->tag_filepath.tsize ) { free(rtag->tag_filepath.tdata ); rtag->tag_filepath.tsize = 0; }
//if(rtag->tag_filename.tsize ) { free(rtag->tag_filename.tdata ); rtag->tag_filename.tsize = 0; }
if(rtag->tag_comments.tsize ) { free(rtag->tag_comments.tdata ); rtag->tag_comments.tsize = 0; }
if(rtag->tag_lyric.tsize ) { free(rtag->tag_lyric.tdata ); rtag->tag_lyric.tsize = 0; }
if(rtag->tag_bpm.tsize ) { free(rtag->tag_bpm.tdata ); rtag->tag_bpm.tsize = 0; }
if(rtag->tag_tracknum.tsize ) { free(rtag->tag_tracknum.tdata ); rtag->tag_tracknum.tsize = 0; }
}else{
hres = WMCreateSyncReader(0, 0, &wmreader);
if(FAILED(hres))return 0;
hres = wmreader->Open(fname);
/* get information */
hres = wmreader->QueryInterface(IID_IWMHeaderInfo, (VOID **)&wminfo);
if(FAILED(hres))return 0;
wmistream = 0;
ct = &rtag->tag_title;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMTitle);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_album;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMAlbumTitle);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_artist;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMAuthor);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_origartist;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMOriginalArtist);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_composer;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMComposer);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_lyricist;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMWriter);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_band;
ct->tdata = 0;
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_copyright;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMCopyright);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_publish;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMPublisher);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_encodedby;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMEncodedBy);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_genre;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMGenre);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_year;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMYear);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_url;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMUserWebURL);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_offiartisturl;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMAuthorURL);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_comments;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMDescription);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_lyric;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMLyrics);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) + 2 : 0;
ct = &rtag->tag_bpm;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMBeatsPerMinute);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
ct = &rtag->tag_tracknum;
ct->tdata = WM_GetTagString(wminfo, &wmistream, g_wszWMTrack);
ct->tdatai = 0;
ct->tmode = ct->tdata ? tag_memmode_dynamic : tag_memmode_static;
ct->tsize = ct->tdata ? (unsigned int)str_size(ct->tdata) : 0;
wminfo->Release();
wmreader->Close();
wmreader->Release();
}
return 1;
}
int tagwrite(const string fname, struct fennec_audiotag *wtag)
{
HRESULT hres;
IWMHeaderInfo* wminfo;
WORD wmistream = 0;
BOOL sdef = 1;
IWMMetadataEditor *pEdit = 0;
IWMHeaderInfo *pInfo = 0;
int twrote = 1;
if(!wtag)return 0;
CoInitialize(0);
hres = WMCreateEditor(&pEdit);
hres = pEdit->Open(fname);
pEdit->QueryInterface(IID_IWMHeaderInfo, (VOID **)(&wminfo));
if(wtag->tag_title.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMTitle ,wtag->tag_title.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMTitle , 0); }
if(wtag->tag_album.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMAlbumTitle ,wtag->tag_album.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMAlbumTitle , 0); }
if(wtag->tag_artist.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMAuthor ,wtag->tag_artist.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMAuthor , 0); }
if(wtag->tag_origartist.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMOriginalArtist ,wtag->tag_origartist.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMOriginalArtist , 0); }
if(wtag->tag_composer.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMComposer ,wtag->tag_composer.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMComposer , 0); }
if(wtag->tag_lyricist.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMLyrics ,wtag->tag_lyricist.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMWriter , 0); }
/* band: not used */
if(wtag->tag_copyright.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMCopyright ,wtag->tag_copyright.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMCopyright , 0); }
if(wtag->tag_publish.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMPublisher ,wtag->tag_publish.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMPublisher , 0); }
if(wtag->tag_encodedby.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMEncodedBy ,wtag->tag_encodedby.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMEncodedBy , 0); }
if(wtag->tag_genre.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMGenre ,wtag->tag_genre.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMGenre , 0); }
if(wtag->tag_year.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMYear ,wtag->tag_year.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMYear , 0); }
if(wtag->tag_url.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMUserWebURL ,wtag->tag_url.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMUserWebURL , 0); }
if(wtag->tag_offiartisturl.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMAuthorURL ,wtag->tag_offiartisturl.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMAuthorURL , 0); }
if(wtag->tag_comments.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMDescription ,wtag->tag_comments.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMDescription , 0); }
if(wtag->tag_lyric.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMLyrics ,wtag->tag_lyric.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMLyrics , 0); }
if(wtag->tag_bpm.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMBeatsPerMinute ,wtag->tag_bpm.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMBeatsPerMinute , 0); }
if(wtag->tag_tracknum.tsize ){ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMTrack ,wtag->tag_tracknum.tdata ); }
else{ twrote = WM_SetTagString(wminfo, &wmistream, g_wszWMTrack , 0); }
if(!twrote)
{
MessageBox(0, uni("Couldn't set tag(s), if you're setting tags on currently playing media, try stopping it."), uni("Error on tagging"), MB_ICONQUESTION);
}
pEdit->Flush();
pEdit->Close();
wminfo->Release();
pEdit->Release();
return 1;
}
int decoder_load(unsigned long id, const string sname)
{
HRESULT hres;
IWMOutputMediaProps* ppProps;
WM_MEDIA_TYPE* wmt = 0;
DWORD wmpz = 0;
WAVEFORMATEX wfx;
DWORD i, outcount = 0;
IWMHeaderInfo* wminfo;
WORD wmistream = 0;
WMT_ATTR_DATATYPE Type;
WORD wmilen;
CoInitialize(0);
hres = WMCreateSyncReader(0, 0, &pstreams[id].wmreader);
if(FAILED(hres))return 0;
hres = pstreams[id].wmreader->Open(sname);
pstreams[id].wmreader->GetOutputCount(&outcount);
for(i=0; i<outcount; i++)
{
hres = pstreams[id].wmreader->GetOutputProps(i, &ppProps);
if(FAILED(hres))
{
ppProps->Release();
continue;
}
hres = ppProps->GetMediaType(0, &wmpz);
if(FAILED(hres))
{
ppProps->Release();
continue;
}
wmt = (WM_MEDIA_TYPE*) malloc(wmpz);
hres = ppProps->GetMediaType(wmt, &wmpz);
if(WMMEDIATYPE_Audio != wmt->majortype)
{
ppProps->Release();
free(wmt);
continue;
}
memcpy(&wfx, wmt->pbFormat, wmt->cbFormat);
pstreams[id].channels = wfx.nChannels;
pstreams[id].frequency = wfx.nSamplesPerSec;
pstreams[id].bitspersample = wfx.wBitsPerSample;
pstreams[id].wmaudioout = i;
free(wmt);
ppProps->Release();
break;
}
pstreams[id].buffer = 0;
pstreams[id].buffersize = 0;
/* get information */
hres = pstreams[id].wmreader->QueryInterface(IID_IWMHeaderInfo, (VOID **)&wminfo);
if(FAILED(hres))return 0;
wmistream = 0;
hres = wminfo->GetAttributeByName(&wmistream, g_wszWMDuration, &Type, 0, &wmilen);
if(hres == S_OK)
{
QWORD dur;
wminfo->GetAttributeByName(&wmistream, g_wszWMDuration, &Type, (BYTE*)&dur,&wmilen);
pstreams[id].duration = (DWORD)(dur / 10000);
}
wminfo->Release();
return 1;
}
HRESULT GetMediaMetadata(const TCHAR *szFileName,const TCHAR *szAttribute,BYTE **pszOutput)
{
typedef HRESULT (WINAPI *WMCREATEEDITOR_PROC)(IWMMetadataEditor **);
WMCREATEEDITOR_PROC pWMCreateEditor = NULL;
HMODULE hWMVCore;
IWMMetadataEditor *pEditor = NULL;
IWMHeaderInfo *pWMHeaderInfo = NULL;
HRESULT hr = E_FAIL;
hWMVCore = LoadLibrary(_T("wmvcore.dll"));
if(hWMVCore != NULL)
{
pWMCreateEditor = (WMCREATEEDITOR_PROC)GetProcAddress(hWMVCore,"WMCreateEditor");
if(pWMCreateEditor != NULL)
{
hr = pWMCreateEditor(&pEditor);
if(SUCCEEDED(hr))
{
hr = pEditor->Open(szFileName);
if(SUCCEEDED(hr))
{
hr = pEditor->QueryInterface(IID_PPV_ARGS(&pWMHeaderInfo));
if(SUCCEEDED(hr))
{
WORD wStreamNum;
WMT_ATTR_DATATYPE Type;
WORD cbLength;
/* Any stream. Should be zero for MP3 files. */
wStreamNum = 0;
hr = pWMHeaderInfo->GetAttributeByName(&wStreamNum,szAttribute,&Type,NULL,&cbLength);
if(SUCCEEDED(hr))
{
*pszOutput = (BYTE *)malloc(cbLength);
if(*pszOutput != NULL)
{
hr = pWMHeaderInfo->GetAttributeByName(&wStreamNum,szAttribute,&Type,
*pszOutput,&cbLength);
}
}
pWMHeaderInfo->Release();
}
}
pEditor->Release();
}
}
FreeLibrary(hWMVCore);
}
return hr;
}
void DirectShowMetaDataControl::updateMetadata(IFilterGraph2 *graph, IBaseFilter *source, const QString &fileSrc)
{
m_metadata.clear();
#ifndef QT_NO_SHELLITEM
if (!sHCreateItemFromParsingName) {
QSystemLibrary lib(QStringLiteral("shell32"));
sHCreateItemFromParsingName = (q_SHCreateItemFromParsingName)(lib.resolve("SHCreateItemFromParsingName"));
}
if (!fileSrc.isEmpty() && sHCreateItemFromParsingName) {
IShellItem2* shellItem = 0;
if (sHCreateItemFromParsingName(reinterpret_cast<const WCHAR*>(fileSrc.utf16()),
0, IID_PPV_ARGS(&shellItem)) == S_OK) {
IPropertyStore *pStore = 0;
if (shellItem->GetPropertyStore(GPS_DEFAULT, IID_PPV_ARGS(&pStore)) == S_OK) {
DWORD cProps;
if (SUCCEEDED(pStore->GetCount(&cProps))) {
for (DWORD i = 0; i < cProps; ++i)
{
PROPERTYKEY key;
PROPVARIANT var;
PropVariantInit(&var);
if (FAILED(pStore->GetAt(i, &key)))
continue;
if (FAILED(pStore->GetValue(key, &var)))
continue;
if (IsEqualPropertyKey(key, PKEY_Author)) {
m_metadata.insert(QMediaMetaData::Author, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Title)) {
m_metadata.insert(QMediaMetaData::Title, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_SubTitle)) {
m_metadata.insert(QMediaMetaData::SubTitle, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_ParentalRating)) {
m_metadata.insert(QMediaMetaData::ParentalRating, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Comment)) {
m_metadata.insert(QMediaMetaData::Description, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Copyright)) {
m_metadata.insert(QMediaMetaData::Copyright, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_ProviderStyle)) {
m_metadata.insert(QMediaMetaData::Genre, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Year)) {
m_metadata.insert(QMediaMetaData::Year, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_DateEncoded)) {
m_metadata.insert(QMediaMetaData::Date, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Rating)) {
m_metadata.insert(QMediaMetaData::UserRating,
int((convertValue(var).toUInt() - 1) / qreal(98) * 100));
} else if (IsEqualPropertyKey(key, PKEY_Keywords)) {
m_metadata.insert(QMediaMetaData::Keywords, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Language)) {
m_metadata.insert(QMediaMetaData::Language, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Publisher)) {
m_metadata.insert(QMediaMetaData::Publisher, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Duration)) {
m_metadata.insert(QMediaMetaData::Duration,
(convertValue(var).toLongLong() + 10000) / 10000);
} else if (IsEqualPropertyKey(key, PKEY_Audio_EncodingBitrate)) {
m_metadata.insert(QMediaMetaData::AudioBitRate, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_AverageLevel)) {
m_metadata.insert(QMediaMetaData::AverageLevel, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Audio_ChannelCount)) {
m_metadata.insert(QMediaMetaData::ChannelCount, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Audio_PeakValue)) {
m_metadata.insert(QMediaMetaData::PeakValue, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Audio_SampleRate)) {
m_metadata.insert(QMediaMetaData::SampleRate, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_AlbumTitle)) {
m_metadata.insert(QMediaMetaData::AlbumTitle, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_AlbumArtist)) {
m_metadata.insert(QMediaMetaData::AlbumArtist, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Artist)) {
m_metadata.insert(QMediaMetaData::ContributingArtist, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Composer)) {
m_metadata.insert(QMediaMetaData::Composer, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Conductor)) {
m_metadata.insert(QMediaMetaData::Conductor, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Lyrics)) {
m_metadata.insert(QMediaMetaData::Lyrics, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Mood)) {
m_metadata.insert(QMediaMetaData::Mood, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_TrackNumber)) {
m_metadata.insert(QMediaMetaData::TrackNumber, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Genre)) {
m_metadata.insert(QMediaMetaData::Genre, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_ThumbnailStream)) {
m_metadata.insert(QMediaMetaData::ThumbnailImage, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Video_FrameHeight)) {
QSize res;
res.setHeight(convertValue(var).toUInt());
if (SUCCEEDED(pStore->GetValue(PKEY_Video_FrameWidth, &var)))
res.setWidth(convertValue(var).toUInt());
m_metadata.insert(QMediaMetaData::Resolution, res);
} else if (IsEqualPropertyKey(key, PKEY_Video_HorizontalAspectRatio)) {
QSize aspectRatio;
aspectRatio.setWidth(convertValue(var).toUInt());
if (SUCCEEDED(pStore->GetValue(PKEY_Video_VerticalAspectRatio, &var)))
aspectRatio.setHeight(convertValue(var).toUInt());
m_metadata.insert(QMediaMetaData::PixelAspectRatio, aspectRatio);
} else if (IsEqualPropertyKey(key, PKEY_Video_FrameRate)) {
m_metadata.insert(QMediaMetaData::VideoFrameRate,
convertValue(var).toReal() / 1000);
} else if (IsEqualPropertyKey(key, PKEY_Video_EncodingBitrate)) {
m_metadata.insert(QMediaMetaData::VideoBitRate, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Video_Director)) {
m_metadata.insert(QMediaMetaData::Director, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Writer)) {
m_metadata.insert(QMediaMetaData::Writer, convertValue(var));
}
PropVariantClear(&var);
}
}
pStore->Release();
}
shellItem->Release();
}
}
if (!m_metadata.isEmpty())
goto send_event;
#endif
#ifndef QT_NO_WMSDK
IWMHeaderInfo *info = com_cast<IWMHeaderInfo>(source, IID_IWMHeaderInfo);
if (info) {
Q_FOREACH (const QWMMetaDataKey &key, *qt_wmMetaDataKeys()) {
QVariant var = getValue(info, key.wmName);
if (var.isValid()) {
if (key.qtName == QMediaMetaData::Duration) {
// duration is provided in 100-nanosecond units, convert to milliseconds
var = (var.toLongLong() + 10000) / 10000;
} else if (key.qtName == QMediaMetaData::Resolution) {
QSize res;
res.setHeight(var.toUInt());
res.setWidth(getValue(info, L"WM/VideoWidth").toUInt());
var = res;
} else if (key.qtName == QMediaMetaData::VideoFrameRate) {
var = var.toReal() / 1000.f;
} else if (key.qtName == QMediaMetaData::PixelAspectRatio) {
QSize aspectRatio;
aspectRatio.setWidth(var.toUInt());
aspectRatio.setHeight(getValue(info, L"AspectRatioY").toUInt());
var = aspectRatio;
} else if (key.qtName == QMediaMetaData::UserRating) {
var = (var.toUInt() - 1) / qreal(98) * 100;
}
m_metadata.insert(key.qtName, var);
}
}
info->Release();
}
if (!m_metadata.isEmpty())
goto send_event;
#endif
{
IAMMediaContent *content = 0;
if ((!graph || graph->QueryInterface(
IID_IAMMediaContent, reinterpret_cast<void **>(&content)) != S_OK)
&& (!source || source->QueryInterface(
IID_IAMMediaContent, reinterpret_cast<void **>(&content)) != S_OK)) {
content = 0;
}
if (content) {
BSTR string = 0;
if (content->get_AuthorName(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Author, convertBSTR(&string));
if (content->get_Title(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Title, convertBSTR(&string));
if (content->get_Description(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Description, convertBSTR(&string));
if (content->get_Rating(&string) == S_OK)
m_metadata.insert(QMediaMetaData::UserRating, convertBSTR(&string));
if (content->get_Copyright(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Copyright, convertBSTR(&string));
content->Release();
}
}
send_event:
// DirectShowMediaPlayerService holds a lock at this point so defer emitting signals to a later
// time.
QCoreApplication::postEvent(this, new QEvent(QEvent::Type(MetaDataChanged)));
}
