/*
Adds the video and audio stream to the H.264 writer sink.
*/
HRESULT ConfigureEncoder(IMFMediaType *pVideoType, DWORD *videoStreamIndex, DWORD *audioStreamIndex, IMFSinkWriter *pWriter)
{
IMFMediaType *pVideoOutType = NULL;
IMFMediaType *pAudioOutType = NULL;
// Configure the video stream.
CHECK_HR(MFCreateMediaType(&pVideoOutType), L"Configure encoder failed to create media type for video output sink.");
CHECK_HR(pVideoOutType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video), L"Failed to set video writer attribute, media type.");
CHECK_HR(pVideoOutType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264), L"Failed to set video writer attribute, video format (H.264).");
CHECK_HR(pVideoOutType->SetUINT32(MF_MT_AVG_BITRATE, 240 * 1000), L"Failed to set video writer attribute, bit rate.");
CHECK_HR(CopyAttribute(pVideoType, pVideoOutType, MF_MT_FRAME_SIZE), L"Failed to set video writer attribute, frame size.");
CHECK_HR(CopyAttribute(pVideoType, pVideoOutType, MF_MT_FRAME_RATE), L"Failed to set video writer attribute, frame rate.");
CHECK_HR(CopyAttribute(pVideoType, pVideoOutType, MF_MT_PIXEL_ASPECT_RATIO), L"Failed to set video writer attribute, aspect ratio.");
CHECK_HR(CopyAttribute(pVideoType, pVideoOutType, MF_MT_INTERLACE_MODE), L"Failed to set video writer attribute, interlace mode.");;
CHECK_HR(pWriter->AddStream(pVideoOutType, videoStreamIndex), L"Failed to add the video stream to the sink writer.");
pVideoOutType->Release();
// Configure the audio stream.
// See http://msdn.microsoft.com/en-us/library/windows/desktop/dd742785(v=vs.85).aspx for AAC encoder settings.
// http://msdn.microsoft.com/en-us/library/ff819476%28VS.85%29.aspx
CHECK_HR(MFCreateMediaType(&pAudioOutType), L"Configure encoder failed to create media type for audio output sink.");
CHECK_HR(pAudioOutType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio), L"Failed to set audio writer attribute, media type.");
CHECK_HR(pAudioOutType->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_AAC), L"Failed to set audio writer attribute, audio format (AAC).");
CHECK_HR(pAudioOutType->SetUINT32(MF_MT_AUDIO_NUM_CHANNELS, 2), L"Failed to set audio writer attribute, number of channels.");
CHECK_HR(pAudioOutType->SetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16), L"Failed to set audio writer attribute, bits per sample.");
CHECK_HR(pAudioOutType->SetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100), L"Failed to set audio writer attribute, samples per second.");
CHECK_HR(pAudioOutType->SetUINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 16000), L"Failed to set audio writer attribute, average bytes per second.");
//CHECK_HR( pAudioOutType->SetUINT32( MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0x29 ), L"Failed to set audio writer attribute, level indication.");
CHECK_HR(pWriter->AddStream(pAudioOutType, audioStreamIndex), L"Failed to add the audio stream to the sink writer.");
pAudioOutType->Release();
return S_OK;
}
HRESULT ConfigureEncoder(
const EncodingParameters& params,
IMFMediaType *pType,
IMFSinkWriter *pWriter,
DWORD *pdwStreamIndex
)
{
HRESULT hr = S_OK;
IMFMediaType *pType2 = NULL;
hr = MFCreateMediaType(&pType2);
if (SUCCEEDED(hr))
{
hr = pType2->SetGUID( MF_MT_MAJOR_TYPE, MFMediaType_Video );
}
if (SUCCEEDED(hr))
{
hr = pType2->SetGUID(MF_MT_SUBTYPE, params.subtype);
}
if (SUCCEEDED(hr))
{
hr = pType2->SetUINT32(MF_MT_AVG_BITRATE, params.bitrate);
}
if (SUCCEEDED(hr))
{
hr = CopyAttribute(pType, pType2, MF_MT_FRAME_SIZE);
}
if (SUCCEEDED(hr))
{
hr = CopyAttribute(pType, pType2, MF_MT_FRAME_RATE);
}
if (SUCCEEDED(hr))
{
hr = CopyAttribute(pType, pType2, MF_MT_PIXEL_ASPECT_RATIO);
}
if (SUCCEEDED(hr))
{
hr = CopyAttribute(pType, pType2, MF_MT_INTERLACE_MODE);
}
if (SUCCEEDED(hr))
{
hr = pWriter->AddStream(pType2, pdwStreamIndex);
}
SafeRelease(&pType2);
return hr;
}
HRESULT CloneVideoMediaType(IMFMediaType *pSrcMediaType, REFGUID guidSubType, IMFMediaType **ppNewMediaType)
{
IMFMediaType *pNewMediaType = NULL;
HRESULT hr = MFCreateMediaType(&pNewMediaType);
if (FAILED(hr))
{
goto done;
}
hr = pNewMediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
if (FAILED(hr))
{
goto done;
}
hr = pNewMediaType->SetGUID(MF_MT_SUBTYPE, guidSubType);
if (FAILED(hr))
{
goto done;
}
hr = CopyAttribute(pSrcMediaType, pNewMediaType, MF_MT_FRAME_SIZE);
if (FAILED(hr))
{
goto done;
}
hr = CopyAttribute(pSrcMediaType, pNewMediaType, MF_MT_FRAME_RATE);
if (FAILED(hr))
{
goto done;
}
hr = CopyAttribute(pSrcMediaType, pNewMediaType, MF_MT_PIXEL_ASPECT_RATIO);
if (FAILED(hr))
{
goto done;
}
hr = CopyAttribute(pSrcMediaType, pNewMediaType, MF_MT_INTERLACE_MODE);
if (FAILED(hr))
{
goto done;
}
*ppNewMediaType = pNewMediaType;
(*ppNewMediaType)->AddRef();
done:
SafeRelease(&pNewMediaType);
return hr;
}
HRESULT CreatePhotoMediaType(IMFMediaType *pSrcMediaType, IMFMediaType **ppPhotoMediaType)
{
*ppPhotoMediaType = NULL;
const UINT32 uiFrameRateNumerator = 30;
const UINT32 uiFrameRateDenominator = 1;
IMFMediaType *pPhotoMediaType = NULL;
HRESULT hr = MFCreateMediaType(&pPhotoMediaType);
if (FAILED(hr))
{
goto done;
}
hr = pPhotoMediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Image);
if (FAILED(hr))
{
goto done;
}
hr = pPhotoMediaType->SetGUID(MF_MT_SUBTYPE, GUID_ContainerFormatJpeg);
if (FAILED(hr))
{
goto done;
}
hr = CopyAttribute(pSrcMediaType, pPhotoMediaType, MF_MT_FRAME_SIZE);
if (FAILED(hr))
{
goto done;
}
*ppPhotoMediaType = pPhotoMediaType;
(*ppPhotoMediaType)->AddRef();
done:
SafeRelease(&pPhotoMediaType);
return hr;
}
ClassAd *CollectorEngine::
collect (int command,ClassAd *clientAd,const condor_sockaddr& from,int &insert,Sock *sock)
{
ClassAd *retVal;
ClassAd *pvtAd;
int insPvt;
AdNameHashKey hk;
HashString hashString;
static int repeatStartdAds = -1; // for debugging
ClassAd *clientAdToRepeat = NULL;
_condor_auto_accum_runtime<collector_runtime_probe> rt(CollectorEngine_rucc_runtime);
double rt_last = rt.begin;
if (repeatStartdAds == -1) {
repeatStartdAds = param_integer("COLLECTOR_REPEAT_STARTD_ADS",0);
}
if( !ValidateClassAd(command,clientAd,sock) ) {
return NULL;
}
CollectorEngine_rucc_validateAd_runtime.Add(rt.tick(rt_last));
// mux on command
switch (command)
{
case UPDATE_STARTD_AD:
case UPDATE_STARTD_AD_WITH_ACK:
if ( repeatStartdAds > 0 ) {
clientAdToRepeat = new ClassAd(*clientAd);
}
if (!makeStartdAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
CollectorEngine_rucc_makeHashKey_runtime.Add(rt.tick(rt_last));
retVal=updateClassAd (StartdAds, "StartdAd ", "Start",
clientAd, hk, hashString, insert, from );
if (last_updateClassAd_was_insert) { CollectorEngine_rucc_insertAd_runtime.Add(rt.tick(rt_last));
} else { CollectorEngine_rucc_updateAd_runtime.Add(rt.tick(rt_last)); }
// if we want to store private ads
if (!sock)
{
dprintf (D_ALWAYS, "Want private ads, but no socket given!\n");
break;
}
else
{
if (!(pvtAd = new ClassAd))
{
EXCEPT ("Memory error!");
}
if( !getClassAd(sock, *pvtAd) )
{
dprintf(D_FULLDEBUG,"\t(Could not get startd's private ad)\n");
delete pvtAd;
break;
}
// Fix up some stuff in the private ad that we depend on.
// We started doing this in 7.2.0, so once we no longer
// care about compatibility with stuff from before then,
// the startd could stop bothering to send these attributes.
// Queries of private ads depend on the following:
SetMyTypeName( *pvtAd, STARTD_ADTYPE );
// Negotiator matches up private ad with public ad by
// using the following.
if( retVal ) {
CopyAttribute( ATTR_MY_ADDRESS, *pvtAd, *retVal );
CopyAttribute( ATTR_NAME, *pvtAd, *retVal );
}
CollectorEngine_rucc_getPvtAd_runtime.Add(rt.tick(rt_last));
// insert the private ad into its hashtable --- use the same
// hash key as the public ad
(void) updateClassAd (StartdPrivateAds, "StartdPvtAd ",
"StartdPvt", pvtAd, hk, hashString, insPvt,
from );
if (last_updateClassAd_was_insert) { CollectorEngine_rucc_insertPvtAd_runtime.Add(rt.tick(rt_last));
} else { CollectorEngine_rucc_updatePvtAd_runtime.Add(rt.tick(rt_last)); }
}
// create fake duplicates of this ad, each with a different name, if
// we are told to do so. this feature exists for developer
// scalability testing.
if ( repeatStartdAds > 0 && clientAdToRepeat ) {
ClassAd *fakeAd;
int n;
char newname[150],oldname[130];
oldname[0] = '\0';
clientAdToRepeat->LookupString("Name",oldname,sizeof(oldname));
for (n=0;n<repeatStartdAds;n++) {
fakeAd = new ClassAd(*clientAdToRepeat);
snprintf(newname,sizeof(newname),
"Name=\"fake%d-%s\"",n,oldname);
fakeAd->Insert(newname);
makeStartdAdHashKey (hk, fakeAd);
hashString.Build( hk );
if (! updateClassAd (StartdAds, "StartdAd ", "Start",
fakeAd, hk, hashString, insert, from ) )
{
// don't leak memory if there is some failure
delete fakeAd;
}
}
delete clientAdToRepeat;
clientAdToRepeat = NULL;
CollectorEngine_rucc_repeatAd_runtime.Add(rt.tick(rt_last));
}
break;
case MERGE_STARTD_AD:
if (!makeStartdAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=mergeClassAd (StartdAds, "StartdAd ", "Start",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_SCHEDD_AD:
if (!makeScheddAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (ScheddAds, "ScheddAd ", "Schedd",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_SUBMITTOR_AD:
// use the same hashkey function as a schedd ad
if (!makeScheddAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
// since submittor ads always follow a schedd ad, and a master check is
// performed for schedd ads, we don't need a master check in here
hashString.Build( hk );
retVal=updateClassAd (SubmittorAds, "SubmittorAd ", "Submittor",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_LICENSE_AD:
// use the same hashkey function as a schedd ad
if (!makeLicenseAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
// since submittor ads always follow a schedd ad, and a master check is
// performed for schedd ads, we don't need a master check in here
hashString.Build( hk );
retVal=updateClassAd (LicenseAds, "LicenseAd ", "License",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_MASTER_AD:
if (!makeMasterAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (MasterAds, "MasterAd ", "Master",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_CKPT_SRVR_AD:
if (!makeCkptSrvrAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (CkptServerAds, "CkptSrvrAd ", "CkptSrvr",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_COLLECTOR_AD:
if (!makeCollectorAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (CollectorAds, "CollectorAd ", "Collector",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_STORAGE_AD:
if (!makeStorageAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (StorageAds, "StorageAd ", "Storage",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_ACCOUNTING_AD:
if (!makeAccountingAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (AccountingAds, "AccountingAd ", "Accouting",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_NEGOTIATOR_AD:
if (!makeNegotiatorAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
if (m_allowOnlyOneNegotiator) {
// first, purge all the existing negotiator ads, since we
// want to enforce that *ONLY* 1 negotiator is in the
// collector any given time.
purgeHashTable( NegotiatorAds );
}
retVal=updateClassAd (NegotiatorAds, "NegotiatorAd ", "Negotiator",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_HAD_AD:
if (!makeHadAdHashKey (hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (HadAds, "HadAd ", "HAD",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_GRID_AD:
if (!makeGridAdHashKey(hk, clientAd))
{
dprintf (D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build( hk );
retVal=updateClassAd (GridAds, "GridAd ", "Grid",
clientAd, hk, hashString, insert, from );
break;
case UPDATE_AD_GENERIC:
{
const char *type_str = GetMyTypeName(*clientAd);
if (type_str == NULL) {
dprintf(D_ALWAYS, "collect: UPDATE_AD_GENERIC: ad has no type\n");
insert = -3;
retVal = 0;
break;
}
MyString type(type_str);
CollectorHashTable *cht = findOrCreateTable(type);
if (cht == NULL) {
dprintf(D_ALWAYS, "collect: findOrCreateTable failed\n");
insert = -3;
retVal = 0;
break;
}
if (!makeGenericAdHashKey (hk, clientAd))
{
dprintf(D_ALWAYS, "Could not make hashkey --- ignoring ad\n");
insert = -3;
retVal = 0;
break;
}
hashString.Build(hk);
retVal = updateClassAd(*cht, type_str, type_str, clientAd,
hk, hashString, insert, from);
break;
}
case QUERY_STARTD_ADS:
case QUERY_SCHEDD_ADS:
case QUERY_MASTER_ADS:
case QUERY_SUBMITTOR_ADS:
case QUERY_CKPT_SRVR_ADS:
case QUERY_STARTD_PVT_ADS:
case QUERY_COLLECTOR_ADS:
case QUERY_NEGOTIATOR_ADS:
case QUERY_HAD_ADS:
case QUERY_GENERIC_ADS:
case INVALIDATE_STARTD_ADS:
case INVALIDATE_SCHEDD_ADS:
case INVALIDATE_MASTER_ADS:
case INVALIDATE_CKPT_SRVR_ADS:
case INVALIDATE_SUBMITTOR_ADS:
case INVALIDATE_COLLECTOR_ADS:
case INVALIDATE_NEGOTIATOR_ADS:
case INVALIDATE_HAD_ADS:
case INVALIDATE_ADS_GENERIC:
// these are not implemented in the engine, but we allow another
// daemon to detect that these commands have been given
insert = -2;
retVal = 0;
break;
default:
dprintf (D_ALWAYS, "Received illegal command: %d\n", command);
insert = -1;
retVal = 0;
}
if (command != UPDATE_STARTD_AD && command != UPDATE_STARTD_AD_WITH_ACK) {
CollectorEngine_rucc_other_runtime.Add(rt.tick(rt_last));
}
// return the updated ad
return retVal;
}
