prMALError
exSDKPostProcessParams(
exportStdParms *stdParmsP,
exPostProcessParamsRec *postProcessParamsRecP)
{
prMALError result = malNoError;
ExportSettings *lRec = reinterpret_cast<ExportSettings *>(postProcessParamsRecP->privateData);
PrSDKExportParamSuite *exportParamSuite = lRec->exportParamSuite;
//PrSDKExportInfoSuite *exportInfoSuite = lRec->exportInfoSuite;
PrSDKTimeSuite *timeSuite = lRec->timeSuite;
csSDK_int32 exID = postProcessParamsRecP->exporterPluginID;
csSDK_int32 gIdx = 0;
prUTF16Char paramString[256];
// Image Settings group
utf16ncpy(paramString, "Image Settings", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEBasicVideoGroup, paramString);
// Match source
utf16ncpy(paramString, "Match source", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoMatchSource, paramString);
// width
utf16ncpy(paramString, "Width", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoWidth, paramString);
exParamValues widthValues;
exportParamSuite->GetParamValue(exID, gIdx, ADBEVideoWidth, &widthValues);
widthValues.rangeMin.intValue = 16;
widthValues.rangeMax.intValue = 8192;
exportParamSuite->ChangeParam(exID, gIdx, ADBEVideoWidth, &widthValues);
// height
utf16ncpy(paramString, "Height", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoHeight, paramString);
exParamValues heightValues;
exportParamSuite->GetParamValue(exID, gIdx, ADBEVideoHeight, &heightValues);
heightValues.rangeMin.intValue = 16;
heightValues.rangeMax.intValue = 8192;
exportParamSuite->ChangeParam(exID, gIdx, ADBEVideoHeight, &heightValues);
// pixel aspect ratio
utf16ncpy(paramString, "Pixel Aspect Ratio", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoAspect, paramString);
csSDK_int32 PARs[][2] = {{1, 1}, {10, 11}, {40, 33}, {768, 702},
{1024, 702}, {2, 1}, {4, 3}, {3, 2}};
const char *PARStrings[] = {"Square pixels (1.0)",
"D1/DV NTSC (0.9091)",
"D1/DV NTSC Widescreen 16:9 (1.2121)",
"D1/DV PAL (1.0940)",
"D1/DV PAL Widescreen 16:9 (1.4587)",
"Anamorphic 2:1 (2.0)",
"HD Anamorphic 1080 (1.3333)",
"DVCPRO HD (1.5)"};
exportParamSuite->ClearConstrainedValues(exID, gIdx, ADBEVideoAspect);
exOneParamValueRec tempPAR;
for(csSDK_int32 i=0; i < sizeof (PARs) / sizeof(PARs[0]); i++)
{
tempPAR.ratioValue.numerator = PARs[i][0];
tempPAR.ratioValue.denominator = PARs[i][1];
utf16ncpy(paramString, PARStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, ADBEVideoAspect, &tempPAR, paramString);
}
// field type
utf16ncpy(paramString, "Field Type", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoFieldType, paramString);
csSDK_int32 fieldOrders[] = { prFieldsUpperFirst,
prFieldsLowerFirst,
prFieldsNone};
const char *fieldOrderStrings[] = { "Upper First",
"Lower First",
"None"};
exportParamSuite->ClearConstrainedValues(exID, gIdx, ADBEVideoFieldType);
exOneParamValueRec tempFieldOrder;
for(int i=0; i < 3; i++)
{
tempFieldOrder.intValue = fieldOrders[i];
utf16ncpy(paramString, fieldOrderStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, ADBEVideoFieldType, &tempFieldOrder, paramString);
}
// frame rate
utf16ncpy(paramString, "Frame Rate", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoFPS, paramString);
PrTime frameRates[] = { 10, 15, 23,
24, 25, 29,
30, 50, 59,
60};
PrTime frameRateNumDens[][2] = {{10, 1}, {15, 1}, {24000, 1001},
{24, 1}, {25, 1}, {30000, 1001},
{30, 1}, {50, 1}, {60000, 1001},
{60, 1}};
const char *frameRateStrings[] = { "10",
"15",
"23.976",
"24",
"25 (PAL)",
"29.97 (NTSC)",
"30",
"50",
"59.94",
"60"};
PrTime ticksPerSecond = 0;
timeSuite->GetTicksPerSecond (&ticksPerSecond);
for(csSDK_int32 i=0; i < sizeof(frameRates) / sizeof (PrTime); i++)
{
frameRates[i] = ticksPerSecond / frameRateNumDens[i][0] * frameRateNumDens[i][1];
}
exportParamSuite->ClearConstrainedValues(exID, gIdx, ADBEVideoFPS);
exOneParamValueRec tempFrameRate;
for(csSDK_int32 i=0; i < sizeof(frameRates) / sizeof (PrTime); i++)
{
tempFrameRate.timeValue = frameRates[i];
utf16ncpy(paramString, frameRateStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, ADBEVideoFPS, &tempFrameRate, paramString);
}
// Alpha channel
utf16ncpy(paramString, "Include Alpha Channel", 255);
//exportParamSuite->SetParamName(exID, gIdx, ADBEVideoAlpha, paramString);
// Video codec settings
utf16ncpy(paramString, "Codec settings", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEVideoCodecGroup, paramString);
// Codec
utf16ncpy(paramString, "Codec", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMVideoCodec, paramString);
WebM_Video_Codec codecs[] = { WEBM_CODEC_VP8,
WEBM_CODEC_VP9 };
const char *codecStrings[] = { "VP8",
"VP9" };
exportParamSuite->ClearConstrainedValues(exID, gIdx, WebMVideoCodec);
exOneParamValueRec tempCodec;
for(int i=0; i < 2; i++)
{
tempCodec.intValue = codecs[i];
utf16ncpy(paramString, codecStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, WebMVideoCodec, &tempCodec, paramString);
}
// Method
utf16ncpy(paramString, "Method", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMVideoMethod, paramString);
int vidMethods[] = { WEBM_METHOD_QUALITY,
WEBM_METHOD_BITRATE,
WEBM_METHOD_VBR };
const char *vidMethodStrings[] = { "Constant Quality",
"Constant Bitrate",
"Variable Bitrate (2-pass)" };
exportParamSuite->ClearConstrainedValues(exID, gIdx, WebMVideoMethod);
exOneParamValueRec tempEncodingMethod;
for(int i=0; i < 3; i++)
{
tempEncodingMethod.intValue = vidMethods[i];
utf16ncpy(paramString, vidMethodStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, WebMVideoMethod, &tempEncodingMethod, paramString);
}
// Quality
utf16ncpy(paramString, "Quality", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMVideoQuality, paramString);
exParamValues videoQualityValues;
exportParamSuite->GetParamValue(exID, gIdx, WebMVideoQuality, &videoQualityValues);
videoQualityValues.rangeMin.intValue = 0;
videoQualityValues.rangeMax.intValue = 100;
exportParamSuite->ChangeParam(exID, gIdx, WebMVideoQuality, &videoQualityValues);
// Bitrate
utf16ncpy(paramString, "Bitrate (kb/s)", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMVideoBitrate, paramString);
exParamValues bitrateValues;
exportParamSuite->GetParamValue(exID, gIdx, WebMVideoBitrate, &bitrateValues);
bitrateValues.rangeMin.intValue = 1;
bitrateValues.rangeMax.intValue = 9999;
exportParamSuite->ChangeParam(exID, gIdx, WebMVideoBitrate, &bitrateValues);
// Encoding
utf16ncpy(paramString, "Encoding", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMVideoEncoding, paramString);
int vidQualities[] = { WEBM_ENCODING_REALTIME,
WEBM_ENCODING_GOOD,
WEBM_ENCODING_BEST };
const char *vidQualityStrings[] = { "Realtime",
"Good",
"Best" };
exportParamSuite->ClearConstrainedValues(exID, gIdx, WebMVideoEncoding);
exOneParamValueRec tempEncodingQuality;
for(int i=0; i < 3; i++)
{
tempEncodingQuality.intValue = vidQualities[i];
utf16ncpy(paramString, vidQualityStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, WebMVideoEncoding, &tempEncodingQuality, paramString);
}
// Custom settings
utf16ncpy(paramString, "Custom settings", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMCustomGroup, paramString);
utf16ncpy(paramString, "Custom args", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMCustomArgs, paramString);
// Audio Settings group
utf16ncpy(paramString, "Audio Settings", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEBasicAudioGroup, paramString);
// Sample rate
utf16ncpy(paramString, "Sample Rate", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEAudioRatePerSecond, paramString);
float sampleRates[] = { 8000.0f, 16000.0f, 32000.0f, 44100.0f, 48000.0f, 96000.0f };
const char *sampleRateStrings[] = { "8000 Hz", "16000 Hz", "32000 Hz", "44100 Hz", "48000 Hz", "96000 Hz" };
exportParamSuite->ClearConstrainedValues(exID, gIdx, ADBEAudioRatePerSecond);
exOneParamValueRec tempSampleRate;
for(csSDK_int32 i=0; i < sizeof(sampleRates) / sizeof(float); i++)
{
tempSampleRate.floatValue = sampleRates[i];
utf16ncpy(paramString, sampleRateStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, ADBEAudioRatePerSecond, &tempSampleRate, paramString);
}
// Channels
utf16ncpy(paramString, "Channels", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEAudioNumChannels, paramString);
csSDK_int32 channelTypes[] = { kPrAudioChannelType_Mono,
kPrAudioChannelType_Stereo,
kPrAudioChannelType_51 };
const char *channelTypeStrings[] = { "Mono", "Stereo", "Dolby 5.1" };
exportParamSuite->ClearConstrainedValues(exID, gIdx, ADBEAudioNumChannels);
exOneParamValueRec tempChannelType;
for(csSDK_int32 i=0; i < sizeof(channelTypes) / sizeof(csSDK_int32); i++)
{
tempChannelType.intValue = channelTypes[i];
utf16ncpy(paramString, channelTypeStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, ADBEAudioNumChannels, &tempChannelType, paramString);
}
// Audio codec settings
utf16ncpy(paramString, "Vorbis settings", 255);
exportParamSuite->SetParamName(exID, gIdx, ADBEAudioCodecGroup, paramString);
// Method
utf16ncpy(paramString, "Method", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMAudioMethod, paramString);
int audioMethods[] = { OGG_QUALITY,
OGG_BITRATE };
const char *audioMethodStrings[] = { "Quality",
"Bitrate" };
exportParamSuite->ClearConstrainedValues(exID, gIdx, WebMAudioMethod);
exOneParamValueRec tempAudioEncodingMethod;
for(int i=0; i < 2; i++)
{
tempAudioEncodingMethod.intValue = audioMethods[i];
utf16ncpy(paramString, audioMethodStrings[i], 255);
exportParamSuite->AddConstrainedValuePair(exID, gIdx, WebMAudioMethod, &tempAudioEncodingMethod, paramString);
}
// Quality
utf16ncpy(paramString, "Quality", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMAudioQuality, paramString);
exParamValues qualityValues;
exportParamSuite->GetParamValue(exID, gIdx, WebMAudioQuality, &qualityValues);
qualityValues.rangeMin.floatValue = -0.1f;
qualityValues.rangeMax.floatValue = 1.f;
exportParamSuite->ChangeParam(exID, gIdx, WebMAudioQuality, &qualityValues);
// Bitrate
utf16ncpy(paramString, "Bitrate (kb/s)", 255);
exportParamSuite->SetParamName(exID, gIdx, WebMAudioBitrate, paramString);
exParamValues audioBitrateValues;
exportParamSuite->GetParamValue(exID, gIdx, WebMAudioBitrate, &audioBitrateValues);
audioBitrateValues.rangeMin.intValue = 40;
audioBitrateValues.rangeMax.intValue = 1000;
exportParamSuite->ChangeParam(exID, gIdx, WebMAudioBitrate, &audioBitrateValues);
return result;
}
prMALError
exSDKValidateParamChanged (
exportStdParms *stdParmsP,
exParamChangedRec *validateParamChangedRecP)
{
ExportSettings *privateData = reinterpret_cast<ExportSettings*>(validateParamChangedRecP->privateData);
PrSDKExportParamSuite *paramSuite = privateData->exportParamSuite;
csSDK_int32 exID = validateParamChangedRecP->exporterPluginID;
csSDK_int32 gIdx = validateParamChangedRecP->multiGroupIndex;
std::string param = validateParamChangedRecP->changedParamIdentifier;
if(param == ADBEVideoMatchSource)
{
exParamValues matchSourceP, widthP, heightP, pixelAspectRatioP, fieldTypeP, frameRateP;
paramSuite->GetParamValue(exID, gIdx, ADBEVideoMatchSource, &matchSourceP);
paramSuite->GetParamValue(exID, gIdx, ADBEVideoWidth, &widthP);
paramSuite->GetParamValue(exID, gIdx, ADBEVideoHeight, &heightP);
paramSuite->GetParamValue(exID, gIdx, ADBEVideoAspect, &pixelAspectRatioP);
paramSuite->GetParamValue(exID, gIdx, ADBEVideoFieldType, &fieldTypeP);
paramSuite->GetParamValue(exID, gIdx, ADBEVideoFPS, &frameRateP);
bool disabled = (matchSourceP.value.intValue != 0);
widthP.disabled = heightP.disabled = pixelAspectRatioP.disabled = fieldTypeP.disabled = frameRateP.disabled = disabled;
paramSuite->ChangeParam(exID, gIdx, ADBEVideoWidth, &widthP);
paramSuite->ChangeParam(exID, gIdx, ADBEVideoHeight, &heightP);
paramSuite->ChangeParam(exID, gIdx, ADBEVideoAspect, &pixelAspectRatioP);
paramSuite->ChangeParam(exID, gIdx, ADBEVideoFieldType, &fieldTypeP);
paramSuite->ChangeParam(exID, gIdx, ADBEVideoFPS, &frameRateP);
}
else if(param == WebMVideoMethod)
{
exParamValues methodValue, videoQualityValue, videoBitrateValue;
paramSuite->GetParamValue(exID, gIdx, WebMVideoMethod, &methodValue);
paramSuite->GetParamValue(exID, gIdx, WebMVideoQuality, &videoQualityValue);
paramSuite->GetParamValue(exID, gIdx, WebMVideoBitrate, &videoBitrateValue);
videoQualityValue.hidden = !(methodValue.value.intValue == WEBM_METHOD_QUALITY);
videoBitrateValue.hidden = (methodValue.value.intValue == WEBM_METHOD_QUALITY);
paramSuite->ChangeParam(exID, gIdx, WebMVideoQuality, &videoQualityValue);
paramSuite->ChangeParam(exID, gIdx, WebMVideoBitrate, &videoBitrateValue);
}
else if(param == WebMAudioMethod)
{
exParamValues audioMethodP, audioQualityP, audioBitrateP;
paramSuite->GetParamValue(exID, gIdx, WebMAudioMethod, &audioMethodP);
paramSuite->GetParamValue(exID, gIdx, WebMAudioQuality, &audioQualityP);
paramSuite->GetParamValue(exID, gIdx, WebMAudioBitrate, &audioBitrateP);
audioQualityP.hidden = (audioMethodP.value.intValue == OGG_BITRATE);
audioBitrateP.hidden = !audioQualityP.hidden;
paramSuite->ChangeParam(exID, gIdx, WebMAudioQuality, &audioQualityP);
paramSuite->ChangeParam(exID, gIdx, WebMAudioBitrate, &audioBitrateP);
}
return malNoError;
}