void ExtendedCodec::configureVideoDecoder(
const sp<AMessage> &msg, const char* mime, sp<IOMX> OMXhandle,
const uint32_t flags, IOMX::node_id nodeID, const char* componentName ) {
if (strncmp(componentName, "OMX.qcom.", 9)) {
//do nothing for non QC component
return;
}
setDIVXFormat(msg, mime, OMXhandle, nodeID, kPortIndexOutput);
AString fileFormat;
const char *fileFormatCStr = NULL;
bool success = msg->findString(getMsgKey(kKeyFileFormat), &fileFormat);
if (success) {
fileFormatCStr = fileFormat.c_str();
}
// Enable timestamp reordering for AVI file type, mpeg4 and vc1 codec types
if (!strcmp(componentName, "OMX.qcom.video.decoder.vc1") ||
!strcmp(componentName, "OMX.qcom.video.decoder.mpeg4") ||
(fileFormatCStr!= NULL && !strncmp(fileFormatCStr, "video/avi", 9))) {
ALOGI("Enabling timestamp reordering");
QOMX_INDEXTIMESTAMPREORDER reorder;
InitOMXParams(&reorder);
reorder.nPortIndex = kPortIndexOutput;
reorder.bEnable = OMX_TRUE;
status_t err = OMXhandle->setParameter(nodeID,
(OMX_INDEXTYPE)OMX_QcomIndexParamEnableTimeStampReorder,
(void *)&reorder, sizeof(reorder));
if(err != OK) {
ALOGW("Failed to enable timestamp reordering");
}
}
// Enable Sync-frame decode mode for thumbnails
if (flags & OMXCodec::kClientNeedsFramebuffer) {
ALOGV("Enabling thumbnail mode.");
QOMX_ENABLETYPE enableType;
OMX_INDEXTYPE indexType;
status_t err = OMXhandle->getExtensionIndex(
nodeID, OMX_QCOM_INDEX_PARAM_VIDEO_SYNCFRAMEDECODINGMODE,
&indexType);
if(err != OK) {
ALOGW("Failed to get extension for SYNCFRAMEDECODINGMODE");
return;
}
enableType.bEnable = OMX_TRUE;
err = OMXhandle->setParameter(nodeID,indexType,
(void *)&enableType, sizeof(enableType));
if(err != OK) {
ALOGW("Failed to get extension for SYNCFRAMEDECODINGMODE");
return;
}
ALOGI("Thumbnail mode enabled.");
}
}
sp<ABuffer> ExtendedCodec::getAacCodecSpecificData(
const sp<AMessage> &msg) {
sp<ABuffer> buffer;
if (msg->findBuffer(getMsgKey(kKeyAacCodecSpecificData), &buffer)) {
ALOGV("ACodec found kKeyAacCodecSpecificData of size %d\n", buffer->size());
return buffer;
}
return NULL;
}
INT4 CPortEventReportor::report(CSmartPtr<CSwitch> sw, UINT4 port_no, INT4 event, INT4 reason, INT4 type, INT4 state, INT4 stateNew)
{
if (sw.isNull())
return BNC_ERR;
if ((EVENT_TYPE_PORT_DOWN < event) || (EVENT_TYPE_PORT_UP > event))
return BNC_ERR;
if ((PORT_EVENT_DELETE < type) || (PORT_EVENT_ADD > type))
return BNC_ERR;
CPortEvent* evt = new CPortEvent(event, reason, type, sw->getSockfd(), sw->getDpid(), port_no);
if (NULL == evt)
{
LOG_ERROR_FMT("new CPortEvent failed[%d]!", errno);
return BNC_ERR;
}
CMsgPath path = getMsgPath(event);
evt->setPath(path);
CMsgKey key = getMsgKey(sw->getDpid(), port_no);
evt->setKey(key);
evt->setState(state);
evt->setStateNew(stateNew);
INT1 descStr[1024];
if (PORT_EVENT_ADD == type)
snprintf(descStr, sizeof(descStr),
"Reported event[0x%x][%s] with reason[0x%x] on switch[%llx], port[%u] with state[%d] added",
event, path.c_str(), reason, sw->getDpid(), port_no, stateNew);
else if (PORT_EVENT_MODIFY == type)
snprintf(descStr, sizeof(descStr),
"Reported event[0x%x][%s] with reason[0x%x] on switch[%llx], "
"state of port[%u] changed from %d to %d, when %s happened",
event, path.c_str(), reason, sw->getDpid(), port_no, state, stateNew, g_eventTypeString[type]);
else if (PORT_EVENT_DELETE == type)
snprintf(descStr, sizeof(descStr),
"Reported event[0x%x][%s] with reason[0x%x] on switch[%llx], port[%u] with state[%d] deleted",
event, path.c_str(), reason, sw->getDpid(), port_no, state);
LOG_WARN(descStr);
CEventDesc desc(descStr);
evt->setDesc(desc);
return CEventReportor::report(evt);
}
void ExtendedCodec::overrideComponentName(
uint32_t quirks, const sp<AMessage> &msg, AString* componentName) {
if(quirks & kRequiresWMAProComponent)
{
int32_t version = 0;
if(msg->findInt32(getMsgKey(kKeyWMAVersion), &version)) {
if(version==kTypeWMA) {
componentName->setTo("OMX.qcom.audio.decoder.wma");
} else if(version==kTypeWMAPro) {
componentName->setTo("OMX.qcom.audio.decoder.wma10Pro");
} else if(version==kTypeWMALossLess) {
componentName->setTo("OMX.qcom.audio.decoder.wmaLossLess");
}
}
}
}
void ExtendedCodec::configureFramePackingFormat(
const sp<AMessage> &msg, sp<IOMX> OMXhandle, IOMX::node_id nodeID) {
int32_t arbitraryMode = 0;
bool success = msg->findInt32(getMsgKey(kKeyUseArbitraryMode), &arbitraryMode);
bool useFrameByFrameMode = true; //default option
if (success && arbitraryMode) {
useFrameByFrameMode = false;
}
if (useFrameByFrameMode) {
ALOGI("Enable frame by frame mode");
OMX_QCOM_PARAM_PORTDEFINITIONTYPE portFmt;
portFmt.nPortIndex = kPortIndexInput;
portFmt.nFramePackingFormat = OMX_QCOM_FramePacking_OnlyOneCompleteFrame;
status_t err = OMXhandle->setParameter(
nodeID, (OMX_INDEXTYPE)OMX_QcomIndexPortDefn, (void *)&portFmt, sizeof(portFmt));
if(err != OK) {
ALOGW("Failed to set frame packing format on component");
}
} else {
ALOGI("Decoder should be in arbitrary mode");
}
}
status_t ExtendedCodec::setDIVXFormat(
const sp<AMessage> &msg, const char* mime, sp<IOMX> OMXhandle,
IOMX::node_id nodeID, int port_index) {
status_t err = OK;
if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_DIVX, mime) ||
!strcasecmp(MEDIA_MIMETYPE_VIDEO_DIVX4, mime) ||
!strcasecmp(MEDIA_MIMETYPE_VIDEO_DIVX311, mime)) {
ALOGV("Setting the QOMX_VIDEO_PARAM_DIVXTYPE params ");
QOMX_VIDEO_PARAM_DIVXTYPE paramDivX;
InitOMXParams(¶mDivX);
paramDivX.nPortIndex = port_index;
int32_t DivxVersion = 0;
CHECK(msg->findInt32(getMsgKey(kKeyDivXVersion),&DivxVersion));
ALOGV("Divx Version Type %d\n",DivxVersion);
if(DivxVersion == kTypeDivXVer_4) {
paramDivX.eFormat = QOMX_VIDEO_DIVXFormat4;
} else if(DivxVersion == kTypeDivXVer_5) {
paramDivX.eFormat = QOMX_VIDEO_DIVXFormat5;
} else if(DivxVersion == kTypeDivXVer_6) {
paramDivX.eFormat = QOMX_VIDEO_DIVXFormat6;
} else if(DivxVersion == kTypeDivXVer_3_11 ) {
paramDivX.eFormat = QOMX_VIDEO_DIVXFormat311;
} else {
paramDivX.eFormat = QOMX_VIDEO_DIVXFormatUnused;
}
paramDivX.eProfile = (QOMX_VIDEO_DIVXPROFILETYPE)0; //Not used for now.
err = OMXhandle->setParameter(nodeID,
(OMX_INDEXTYPE)OMX_QcomIndexParamVideoDivx,
¶mDivX, sizeof(paramDivX));
}
return err;
}
status_t ExtendedCodec::setWMAFormat(
const sp<AMessage> &msg, sp<IOMX> OMXhandle,
IOMX::node_id nodeID, bool isEncoder ) {
ALOGV("setWMAFormat Called");
if (isEncoder) {
ALOGE("WMA encoding not supported");
return OK;
} else {
int32_t version;
OMX_AUDIO_PARAM_WMATYPE paramWMA;
QOMX_AUDIO_PARAM_WMA10PROTYPE paramWMA10;
CHECK(msg->findInt32(getMsgKey(kKeyWMAVersion), &version));
int32_t numChannels;
int32_t bitRate;
int32_t sampleRate;
int32_t encodeOptions;
int32_t blockAlign;
int32_t bitspersample;
int32_t formattag;
int32_t advencopt1;
int32_t advencopt2;
int32_t VirtualPktSize;
if(version==kTypeWMAPro || version==kTypeWMALossLess) {
CHECK(msg->findInt32(getMsgKey(kKeyWMABitspersample), &bitspersample));
CHECK(msg->findInt32(getMsgKey(kKeyWMAFormatTag), &formattag));
CHECK(msg->findInt32(getMsgKey(kKeyWMAAdvEncOpt1), &advencopt1));
CHECK(msg->findInt32(getMsgKey(kKeyWMAAdvEncOpt2), &advencopt2));
CHECK(msg->findInt32(getMsgKey(kKeyWMAVirPktSize), &VirtualPktSize));
}
if(version==kTypeWMA) {
InitOMXParams(¶mWMA);
paramWMA.nPortIndex = kPortIndexInput;
} else if(version==kTypeWMAPro || version==kTypeWMALossLess) {
InitOMXParams(¶mWMA10);
paramWMA10.nPortIndex = kPortIndexInput;
}
CHECK(msg->findInt32("channel-count", &numChannels));
CHECK(msg->findInt32("sample-rate", &sampleRate));
CHECK(msg->findInt32(getMsgKey(kKeyBitRate), &bitRate));
CHECK(msg->findInt32(getMsgKey(kKeyWMAEncodeOpt), &encodeOptions));
CHECK(msg->findInt32(getMsgKey(kKeyWMABlockAlign), &blockAlign));
ALOGV("Channels: %d, SampleRate: %d, BitRate; %d"
"EncodeOptions: %d, blockAlign: %d", numChannels,
sampleRate, bitRate, encodeOptions, blockAlign);
if(sampleRate>48000 || numChannels>2)
{
ALOGE("Unsupported samplerate/channels");
return ERROR_UNSUPPORTED;
}
if(version==kTypeWMAPro || version==kTypeWMALossLess)
{
ALOGV("Bitspersample: %d, wmaformattag: %d,"
"advencopt1: %d, advencopt2: %d VirtualPktSize %d", bitspersample,
formattag, advencopt1, advencopt2, VirtualPktSize);
}
status_t err = OK;
OMX_INDEXTYPE index;
if(version==kTypeWMA) {
err = OMXhandle->getParameter(
nodeID, OMX_IndexParamAudioWma, ¶mWMA, sizeof(paramWMA));
} else if(version==kTypeWMAPro || version==kTypeWMALossLess) {
OMXhandle->getExtensionIndex(nodeID,"OMX.Qualcomm.index.audio.wma10Pro",&index);
err = OMXhandle->getParameter(
nodeID, index, ¶mWMA10, sizeof(paramWMA10));
}
CHECK_EQ(err, (status_t)OK);
if(version==kTypeWMA) {
paramWMA.nChannels = numChannels;
paramWMA.nSamplingRate = sampleRate;
paramWMA.nEncodeOptions = encodeOptions;
paramWMA.nBitRate = bitRate;
paramWMA.nBlockAlign = blockAlign;
} else if(version==kTypeWMAPro || version==kTypeWMALossLess) {
paramWMA10.nChannels = numChannels;
paramWMA10.nSamplingRate = sampleRate;
paramWMA10.nEncodeOptions = encodeOptions;
paramWMA10.nBitRate = bitRate;
paramWMA10.nBlockAlign = blockAlign;
}
if(version==kTypeWMAPro || version==kTypeWMALossLess) {
paramWMA10.advancedEncodeOpt = advencopt1;
paramWMA10.advancedEncodeOpt2 = advencopt2;
paramWMA10.formatTag = formattag;
paramWMA10.validBitsPerSample = bitspersample;
paramWMA10.nVirtualPktSize = VirtualPktSize;
}
if(version==kTypeWMA) {
err = OMXhandle->setParameter(
nodeID, OMX_IndexParamAudioWma, ¶mWMA, sizeof(paramWMA));
} else if(version==kTypeWMAPro || version==kTypeWMALossLess) {
err = OMXhandle->setParameter(
nodeID, index, ¶mWMA10, sizeof(paramWMA10));
}
return err;
}
return OK;
}
