this->omxNode = _nl;
})
.isOk());
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
ASSERT_NE(omxNode, nullptr);
ASSERT_NE(gEnv->getRole().empty(), true) << "Invalid Component Role";
struct StringToName {
ASSERT_EQ(status,
::android::hardware::media::omx::V1_0::Status::OK);
*nChannels = param.nChannels;
+ // NOTE: For amrnb sample rate is 8k and amrwb sample rate is 16k.
+ // There is no nSampleRate field in OMX_AUDIO_PARAM_AMRTYPE. Just
+ // return 8k to avoid returning uninit variable.
*nSampleRate = 8000;
break;
}
// set Port Params
int32_t nChannels;
int32_t nSampleRate;
- getInputChannelInfo(omxNode, kPortIndexInput, eEncoding, &nChannels,
- &nSampleRate);
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(
+ omxNode, kPortIndexInput, eEncoding, &nChannels, &nSampleRate));
// Configure output port
// SPECIAL CASE: Soft Vorbis, Opus and Raw Decoders do not offer way
- // to
- // configure output PCM port. The port undergoes auto configuration
- // internally basing on parsed elementary stream information.
+ // to configure output PCM port. The port undergoes auto
+ // configuration internally basing on parsed elementary stream
+ // information.
if (comp != AudioDecHidlTest::standardComp::vorbis &&
comp != AudioDecHidlTest::standardComp::opus &&
comp != AudioDecHidlTest::standardComp::raw) {
nSampleRate);
}
- // If you can disable a port, then you should be able to
- // enable
- // it as well
+ // If you can disable a port, then you should be able to enable it
+ // as well
status = omxNode->sendCommand(
toRawCommandType(OMX_CommandPortEnable), kPortIndexOutput);
ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
ASSERT_EQ(status,
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
- allocatePortBuffers(omxNode, oBuffer, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(
+ allocatePortBuffers(omxNode, oBuffer, kPortIndexOutput));
status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT, iBuffer,
oBuffer);
ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
// dispatch output buffers
for (size_t i = 0; i < oBuffer->size(); i++) {
- dispatchOutputBuffer(omxNode, oBuffer, i);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, i));
}
} else {
ASSERT_TRUE(false);
}
} else {
- EXPECT_TRUE(false);
- return;
+ ASSERT_TRUE(false);
}
}
status =
observer->dequeueMessage(&msg, DEFAULT_TIMEOUT_Q, iBuffer, oBuffer);
if (status == android::hardware::media::omx::V1_0::Status::OK) {
- EXPECT_EQ(msg.type, Message::Type::EVENT);
+ ASSERT_EQ(msg.type, Message::Type::EVENT);
packedArgs audioArgs = {eEncoding, comp};
- portReconfiguration(omxNode, observer, iBuffer, oBuffer,
- kPortIndexInput, kPortIndexOutput, msg,
- PortMode::PRESET_BYTE_BUFFER, &audioArgs);
+ ASSERT_NO_FATAL_FAILURE(
+ portReconfiguration(omxNode, observer, iBuffer, oBuffer,
+ kPortIndexInput, kPortIndexOutput, msg,
+ PortMode::PRESET_BYTE_BUFFER, &audioArgs));
}
// status == TIMED_OUT, it could be due to process time being large
// than DEFAULT_TIMEOUT or component needs output buffers to start
// Dispatch an output buffer assuming outQueue.empty() is true
size_t index;
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index));
timeOut = TIMEOUT_COUNTER_Q;
}
}
if (status == android::hardware::media::omx::V1_0::Status::OK &&
msg.type == Message::Type::EVENT) {
packedArgs audioArgs = {eEncoding, comp};
- portReconfiguration(omxNode, observer, iBuffer, oBuffer,
- kPortIndexInput, kPortIndexOutput, msg,
- PortMode::PRESET_BYTE_BUFFER, &audioArgs);
+ ASSERT_NO_FATAL_FAILURE(
+ portReconfiguration(omxNode, observer, iBuffer, oBuffer,
+ kPortIndexInput, kPortIndexOutput, msg,
+ PortMode::PRESET_BYTE_BUFFER, &audioArgs));
}
if (frameID == (int)Info->size() || frameID == (offset + range)) break;
if (signalEOS && ((frameID == (int)Info->size() - 1) ||
(frameID == (offset + range - 1))))
flags |= OMX_BUFFERFLAG_EOS;
- dispatchInputBuffer(omxNode, iBuffer, index,
- (*Info)[frameID].bytesCount, flags,
- (*Info)[frameID].timestamp);
+ ASSERT_NO_FATAL_FAILURE(dispatchInputBuffer(
+ omxNode, iBuffer, index, (*Info)[frameID].bytesCount, flags,
+ (*Info)[frameID].timestamp));
frameID++;
iQueued = true;
}
// Dispatch output buffer
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index));
oQueued = true;
}
// Reset Counters when either input or output buffer is dispatched
else
timeOut--;
if (timeOut == 0) {
- EXPECT_TRUE(false) << "Wait on Input/Output is found indefinite";
- break;
+ ASSERT_TRUE(false) << "Wait on Input/Output is found indefinite";
}
}
}
setDefaultPortParam(omxNode, kPortIndexInput, eEncoding, 1, 8000,
OMX_AUDIO_PCMModeLinear, OMX_NumericalDataSigned,
32);
- getInputChannelInfo(omxNode, kPortIndexInput, eEncoding, &nChannels,
- &nSampleRate);
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(
+ omxNode, kPortIndexInput, eEncoding, &nChannels, &nSampleRate));
// Configure output port
// SPECIAL CASE: Soft Vorbis, Opus and Raw Decoders do not offer way to
// configure output PCM port. The port undergoes auto configuration
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// Port Reconfiguration
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, eleStream, &Info, 0,
- (int)Info.size(), compName);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, eEncoding, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(), compName));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, compName);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
+ kPortIndexInput, kPortIndexOutput, compName));
packedArgs audioArgs = {eEncoding, compName};
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, nullptr,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs);
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, nullptr,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs));
if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// end of sequence test
setDefaultPortParam(omxNode, kPortIndexInput, eEncoding, 1, 8000,
OMX_AUDIO_PCMModeLinear, OMX_NumericalDataSigned,
32);
- getInputChannelInfo(omxNode, kPortIndexInput, eEncoding, &nChannels,
- &nSampleRate);
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(
+ omxNode, kPortIndexInput, eEncoding, &nChannels, &nSampleRate));
// Configure output port
// SPECIAL CASE: Soft Vorbis, Opus and Raw Decoders do not offer way to
// configure output PCM port. The port undergoes auto configuration
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// request EOS at the start
packedArgs audioArgs = {eEncoding, compName};
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, nullptr,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, nullptr,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
EXPECT_GE(framesReceived, 0U);
framesReceived = 0;
timestampUs = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
+
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// end of sequence test
setDefaultPortParam(omxNode, kPortIndexInput, eEncoding, 1, 8000,
OMX_AUDIO_PCMModeLinear, OMX_NumericalDataSigned,
32);
- getInputChannelInfo(omxNode, kPortIndexInput, eEncoding, &nChannels,
- &nSampleRate);
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(
+ omxNode, kPortIndexInput, eEncoding, &nChannels, &nSampleRate));
// Configure output port
// SPECIAL CASE: Soft Vorbis, Opus and Raw Decoders do not offer way to
// configure output PCM port. The port undergoes auto configuration
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// request EOS for thumbnail
// signal EOS flag with last frame
while (!(Info[i].flags & OMX_BUFFERFLAG_SYNCFRAME)) i++;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, eleStream, &Info, 0, i + 1,
- compName);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, eEncoding, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, i + 1, compName));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, compName);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
+ kPortIndexInput, kPortIndexOutput, compName));
packedArgs audioArgs = {eEncoding, compName};
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, nullptr,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, nullptr,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
EXPECT_GE(framesReceived, 1U);
framesReceived = 0;
timestampUs = 0;
// signal EOS flag after last frame
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, eleStream, &Info, 0, i + 1,
- compName, false);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, eEncoding, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, i + 1, compName, false));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, compName);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, nullptr,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
+ kPortIndexInput, kPortIndexOutput, compName));
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, nullptr,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
EXPECT_GE(framesReceived, 1U);
framesReceived = 0;
timestampUs = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// end of sequence test
setDefaultPortParam(omxNode, kPortIndexInput, eEncoding, 1, 8000,
OMX_AUDIO_PCMModeLinear, OMX_NumericalDataSigned,
32);
- getInputChannelInfo(omxNode, kPortIndexInput, eEncoding, &nChannels,
- &nSampleRate);
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(
+ omxNode, kPortIndexInput, eEncoding, &nChannels, &nSampleRate));
// Configure output port
// SPECIAL CASE: Soft Vorbis, Opus and Raw Decoders do not offer way to
// configure output PCM port. The port undergoes auto configuration
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// request EOS at the end
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, eleStream, &Info, 0,
- (int)Info.size(), compName, false);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
+ eEncoding, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0,
+ (int)Info.size(), compName, false));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, compName);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
+ kPortIndexInput, kPortIndexOutput, compName));
packedArgs audioArgs = {eEncoding, compName};
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, nullptr,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, nullptr,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, &audioArgs));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
framesReceived = 0;
timestampUs = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// test input/output port flush
setDefaultPortParam(omxNode, kPortIndexInput, eEncoding, 1, 8000,
OMX_AUDIO_PCMModeLinear, OMX_NumericalDataSigned,
32);
- getInputChannelInfo(omxNode, kPortIndexInput, eEncoding, &nChannels,
- &nSampleRate);
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(
+ omxNode, kPortIndexInput, eEncoding, &nChannels, &nSampleRate));
// Configure output port
// SPECIAL CASE: Soft Vorbis, Opus and Raw Decoders do not offer way to
// configure output PCM port. The port undergoes auto configuration
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// Decode 128 frames and flush. here 128 is chosen to ensure there is a key
// frame after this so that the below section can be convered for all
int nFrames = 128;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, eleStream, &Info, 0,
- nFrames, compName, false);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, eEncoding, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, nFrames, compName, false));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
framesReceived = 0;
// Seek to next key frame and start decoding till the end
index++;
}
if (keyFrame) {
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
- kPortIndexInput, kPortIndexOutput, eleStream, &Info,
- index, Info.size() - index, compName, false);
+ ASSERT_NO_FATAL_FAILURE(
+ decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, eEncoding,
+ kPortIndexInput, kPortIndexOutput, eleStream, &Info,
+ index, Info.size() - index, compName, false));
}
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
framesReceived = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
int main(int argc, char** argv) {
this->omxNode = _nl;
})
.isOk());
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
ASSERT_NE(omxNode, nullptr);
ASSERT_NE(gEnv->getRole().empty(), true) << "Invalid Component Role";
struct StringToName {
size_t i = 0;
status =
observer->dequeueMessage(&msg, DEFAULT_TIMEOUT_Q, iBuffer, oBuffer);
- EXPECT_EQ(status,
+ ASSERT_EQ(status,
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
// status == TIMED_OUT, it could be due to process time being large
// than DEFAULT_TIMEOUT or component needs output buffers to start
// Dispatch an output buffer assuming outQueue.empty() is true
size_t index;
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index));
timeOut = TIMEOUT_COUNTER_Q;
}
}
if (eleStream.gcount() != bytesCount) break;
flags = OMX_BUFFERFLAG_ENDOFFRAME;
if (signalEOS && (nFrames == 1)) flags |= OMX_BUFFERFLAG_EOS;
- dispatchInputBuffer(omxNode, iBuffer, index, bytesCount, flags,
- timestamp);
+ ASSERT_NO_FATAL_FAILURE(dispatchInputBuffer(
+ omxNode, iBuffer, index, bytesCount, flags, timestamp));
timestamp += timestampIncr;
nFrames--;
iQueued = true;
}
// Dispatch output buffer
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index));
oQueued = true;
}
// Reset Counters when either input or output buffer is dispatched
else
timeOut--;
if (timeOut == 0) {
- EXPECT_TRUE(false) << "Wait on Input/Output is found indefinite";
- break;
+ ASSERT_TRUE(false) << "Wait on Input/Output is found indefinite";
}
}
}
}
setupPCMPort(omxNode, kPortIndexInput, nChannels, OMX_NumericalDataSigned,
16, nSampleRate, OMX_AUDIO_PCMModeLinear);
+
// Configure output port
- setDefaultPortParam(omxNode, kPortIndexOutput, eEncoding, compName,
- nChannels, nSampleRate, nBitRate);
+ ASSERT_NO_FATAL_FAILURE(setDefaultPortParam(omxNode, kPortIndexOutput,
+ eEncoding, compName, nChannels,
+ nSampleRate, nBitRate));
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- encodeNFrames(omxNode, observer, &iBuffer, &oBuffer, 128, samplesPerFrame,
- nChannels, nSampleRate, eleStream);
+ ASSERT_NO_FATAL_FAILURE(encodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
+ 128, samplesPerFrame, nChannels,
+ nSampleRate, eleStream));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer));
+ ASSERT_NO_FATAL_FAILURE(
+ testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag));
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
int main(int argc, char** argv) {
error = _s;
descriptor = _n1;
});
- EXPECT_EQ(error, android::hardware::graphics::mapper::V2_0::Error::NONE);
+ ASSERT_EQ(error, android::hardware::graphics::mapper::V2_0::Error::NONE);
static volatile int32_t nextId = 0;
uint64_t id = static_cast<uint64_t>(getpid()) << 32;
} else if (portMode == PortMode::PRESET_BYTE_BUFFER ||
portMode == PortMode::DYNAMIC_ANW_BUFFER) {
sp<IAllocator> allocator = IAllocator::getService("ashmem");
- EXPECT_NE(allocator.get(), nullptr);
+ ASSERT_NE(allocator.get(), nullptr);
buffer->owner = client;
buffer->omxBuffer.type = CodecBuffer::Type::SHARED_MEM;
OMX_PARAM_PORTDEFINITIONTYPE portDef;
status = getPortParam(omxNode, OMX_IndexParamPortDefinition, portIndex,
&portDef);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
int32_t nStride;
buffer->owner = client;
buffer->omxBuffer.type = CodecBuffer::Type::ANW_BUFFER;
- allocateGraphicBuffers(omxNode, portIndex, buffer,
- portDef.format.video.nFrameWidth,
- portDef.format.video.nFrameHeight, &nStride,
- portDef.format.video.eColorFormat);
+ ASSERT_NO_FATAL_FAILURE(allocateGraphicBuffers(
+ omxNode, portIndex, buffer, portDef.format.video.nFrameWidth,
+ portDef.format.video.nFrameHeight, &nStride,
+ portDef.format.video.eColorFormat));
omxNode->useBuffer(
portIndex, buffer->omxBuffer,
[&status, &buffer](android::hardware::media::omx::V1_0::Status _s,
for (size_t i = 0; i < portDef.nBufferCountActual; i++) {
BufferInfo buffer;
- allocateBuffer(omxNode, &buffer, portIndex, portDef.nBufferSize,
- portMode);
+ ASSERT_NO_FATAL_FAILURE(allocateBuffer(omxNode, &buffer, portIndex,
+ portDef.nBufferSize, portMode));
if (allocGrap && portMode == PortMode::DYNAMIC_ANW_BUFFER) {
int32_t nStride;
- allocateGraphicBuffers(omxNode, portIndex, &buffer,
- portDef.format.video.nFrameWidth,
- portDef.format.video.nFrameHeight, &nStride,
- portDef.format.video.eColorFormat);
+ ASSERT_NO_FATAL_FAILURE(allocateGraphicBuffers(
+ omxNode, portIndex, &buffer, portDef.format.video.nFrameWidth,
+ portDef.format.video.nFrameHeight, &nStride,
+ portDef.format.video.eColorFormat));
}
buffArray->push(buffer);
}
ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::TIMED_OUT);
// allocate buffers on input port
- allocatePortBuffers(omxNode, iBuffer, kPortIndexInput, pm[0], allocGrap);
+ ASSERT_NO_FATAL_FAILURE(allocatePortBuffers(
+ omxNode, iBuffer, kPortIndexInput, pm[0], allocGrap));
// Dont switch states until the ports are populated
status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT, iBuffer, oBuffer);
ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::TIMED_OUT);
// allocate buffers on output port
- allocatePortBuffers(omxNode, oBuffer, kPortIndexOutput, pm[1], allocGrap);
+ ASSERT_NO_FATAL_FAILURE(allocatePortBuffers(
+ omxNode, oBuffer, kPortIndexOutput, pm[1], allocGrap));
// As the ports are populated, check if the state transition is complete
status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT, iBuffer, oBuffer);
if (signalEOS) {
if ((i = getEmptyBufferID(iBuffer)) < iBuffer->size()) {
// signal an empty buffer with flag set to EOS
- dispatchInputBuffer(omxNode, iBuffer, i, 0, OMX_BUFFERFLAG_EOS, 0);
+ ASSERT_NO_FATAL_FAILURE(dispatchInputBuffer(omxNode, iBuffer, i, 0,
+ OMX_BUFFERFLAG_EOS, 0));
} else {
ASSERT_TRUE(false);
}
// Dispatch all client owned output buffers to recover remaining frames
while (1) {
if ((i = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, i, pm[1]);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, i, pm[1]));
// if dispatch is successful, perhaps there is a latency
// in the component. Dont be in a haste to leave. reset timeout
// counter
if (status == android::hardware::media::omx::V1_0::Status::OK) {
if (msg.data.eventData.event == OMX_EventPortSettingsChanged) {
if (fptr) {
- (*fptr)(omxNode, observer, iBuffer, oBuffer,
- kPortIndexInput, kPortIndexOutput, msg, pm[1],
- args);
+ ASSERT_NO_FATAL_FAILURE((*fptr)(
+ omxNode, observer, iBuffer, oBuffer, kPortIndexInput,
+ kPortIndexOutput, msg, pm[1], args));
} else {
// something unexpected happened
- EXPECT_TRUE(false);
+ ASSERT_TRUE(false);
}
} else {
// something unexpected happened
- EXPECT_TRUE(false);
+ ASSERT_TRUE(false);
}
}
if (eosFlag == true) break;
/*
- * Copyright 2016, The Android Open Source Project
+ * Copyright 2017, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
this->omxNode = _nl;
})
.isOk());
+ ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
ASSERT_NE(omxNode, nullptr);
ASSERT_NE(gEnv->getRole().empty(), true) << "Invalid Component Role";
struct StringToClass {
break;
}
}
- return;
}
// test dispatch message API call
std::cerr << "[ ERROR ] port direction has to be read only "
"but is changeable \n";
}
+ EXPECT_EQ(portDef.eDir, mirror.eDir);
setPortParam(omxNode, OMX_IndexParamPortDefinition, i, &mirror);
// Port Min BufferCount - Read Only
EXPECT_EQ(portDef.nBufferCountActual,
mirror.nBufferCountActual + 1);
}
+ setPortParam(omxNode, OMX_IndexParamPortDefinition, i, &mirror);
// Port BufferSize is although read only as per OMX-IL 1.2, android
// doesnt abide by this.
for (size_t i = 0; i < portDef.nBufferCountActual; i++) {
BufferInfo buffer;
- allocateBuffer(omxNode, &buffer, portBase, nBufferSize,
- PortMode::PRESET_BYTE_BUFFER);
+ ASSERT_NO_FATAL_FAILURE(allocateBuffer(omxNode, &buffer, portBase,
+ nBufferSize,
+ PortMode::PRESET_BYTE_BUFFER));
pBuffer.push(buffer);
}
PortMode portMode[2];
initPortMode(portMode, isSecure, compClass);
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// dispatch buffers
for (size_t i = 0; i < oBuffer.size(); i++) {
- dispatchOutputBuffer(omxNode, &oBuffer, i, portMode[1]);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, &oBuffer, i, portMode[1]));
}
// flush port
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
+#if 0
// TODO: Sending empty input buffers is slightly tricky.
// Components sometimes process input buffers even when output buffers are
// not dispatched. For instance Parsing sequence header does not require
// output buffers. In such instances sending 0 size input buffers might
// make component to send error events. so lets skip this aspect of testing.
// dispatch buffers
- // for (size_t i = 0; i < iBuffer.size(); i++) {
- // dispatchInputBuffer(omxNode, &iBuffer, i, 0, 0, 0, portMode[0]);
- // }
- // // flush ports
- // flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- // kPortIndexOutput);
+ for (size_t i = 0; i < iBuffer.size(); i++) {
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchInputBuffer(omxNode, &iBuffer, i, 0, 0, 0, portMode[0]));
+ }
+ // flush ports
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
+#endif
+
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to loaded
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// Flush test - monkeying
PortMode portMode[2];
initPortMode(portMode, isSecure, compClass);
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// // Flush all ports ; receive error OMX_ErrorIncorrectStateOperation
// status = omxNode->sendCommand(toRawCommandType(OMX_CommandFlush),
// ASSERT_NE(status, android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// // Flush all ports ; receive error OMX_ErrorIncorrectStateOperation
// status = omxNode->sendCommand(toRawCommandType(OMX_CommandFlush),
// ASSERT_NE(status, android::hardware::media::omx::V1_0::Status::OK);
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
+
// dispatch buffers
for (size_t i = 0; i < oBuffer.size(); i++) {
- dispatchOutputBuffer(omxNode, &oBuffer, i, portMode[1]);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, &oBuffer, i, portMode[1]));
}
// // flush invalid port, expecting OMX_ErrorBadPortIndex
}
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to loaded
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// test port mode configuration when the component is in various states
PortMode portMode[2];
initPortMode(portMode, isSecure, compClass);
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// Only Allow Port Mode configuration in loaded state
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
EXPECT_NE(status, ::android::hardware::media::omx::V1_0::Status::OK);
EXPECT_NE(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// Only Allow Port Mode configuration in loaded state
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
EXPECT_NE(status, ::android::hardware::media::omx::V1_0::Status::OK);
EXPECT_NE(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to loaded
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
PortMode portMode[2];
initPortMode(portMode, isSecure, compClass);
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
status = omxNode->sendCommand(toRawCommandType(OMX_CommandStateSet),
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
BufferInfo buffer;
- allocateBuffer(omxNode, &buffer, j, def.nBufferSize,
- portMode[j - portBase]);
+ ASSERT_NO_FATAL_FAILURE(allocateBuffer(
+ omxNode, &buffer, j, def.nBufferSize, portMode[j - portBase]));
pBuffer[j - portBase].push(buffer);
}
}
ASSERT_EQ(msg.data.eventData.data2, OMX_StateIdle);
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// dispatch buffers
for (size_t i = 0; i < pBuffer[1].size(); i++) {
- dispatchOutputBuffer(omxNode, &pBuffer[1], i, portMode[1]);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, &pBuffer[1], i, portMode[1]));
}
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]);
- // // set state to executing
- // changeStateIdletoExecute(omxNode, observer);
- // // TODO: Sending empty input buffers is slightly tricky.
- // // dispatch buffers
- // for (size_t i = 0; i < pBuffer[0].size(); i++) {
- // dispatchInputBuffer(omxNode, &pBuffer[0], i, 0, 0, 0,
- // portMode[0]);
- // }
- // // set state to idle
- // changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]));
+#if 0
+ // set state to executing
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
+ // TODO: Sending empty input buffers is slightly tricky.
+ // dispatch buffers
+ for (size_t i = 0; i < pBuffer[0].size(); i++) {
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchInputBuffer(omxNode, &pBuffer[0], i, 0, 0, 0, portMode[0]));
+ }
+ // set state to idle
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]));
+#endif
// set state to loaded
status = omxNode->sendCommand(toRawCommandType(OMX_CommandStateSet),
EXPECT_NE(status, android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
// set state to idle ; receive error OMX_ErrorSameState
status = omxNode->sendCommand(toRawCommandType(OMX_CommandStateSet),
EXPECT_NE(status, android::hardware::media::omx::V1_0::Status::OK);
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// set state to executing ; receive error OMX_ErrorSameState
status = omxNode->sendCommand(toRawCommandType(OMX_CommandStateSet),
OMX_StateLoaded);
EXPECT_NE(status, android::hardware::media::omx::V1_0::Status::OK);
- // set state to Idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-
- // set state to Loaded
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ // set state to idle
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
+ // set state to loaded
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// port enable disable test
PortMode portMode[2];
initPortMode(portMode, isSecure, compClass);
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1],
- kPortIndexInput, kPortIndexOutput, portMode);
-
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1],
+ kPortIndexInput, kPortIndexOutput, portMode));
for (size_t i = portBase; i < portBase + 2; i++) {
status =
omxNode->sendCommand(toRawCommandType(OMX_CommandPortDisable), i);
ASSERT_EQ(status,
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
- allocatePortBuffers(omxNode, &pBuffer[i - portBase], i,
- portMode[i - portBase]);
+ ASSERT_NO_FATAL_FAILURE(allocatePortBuffers(
+ omxNode, &pBuffer[i - portBase], i, portMode[i - portBase]));
status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT,
&pBuffer[0], &pBuffer[1]);
ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
}
// set state to Loaded
- changeStateIdletoLoaded(omxNode, observer, &pBuffer[0], &pBuffer[1],
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateIdletoLoaded(omxNode, observer, &pBuffer[0], &pBuffer[1],
+ kPortIndexInput, kPortIndexOutput));
}
// port enable disable test
PortMode portMode[2];
initPortMode(portMode, isSecure, compClass);
status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
- EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1],
- kPortIndexInput, kPortIndexOutput, portMode);
-
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1],
+ kPortIndexInput, kPortIndexOutput, portMode));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
-
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// dispatch buffers
for (size_t i = 0; i < pBuffer[1].size(); i++) {
- dispatchOutputBuffer(omxNode, &pBuffer[1], i, portMode[1]);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, &pBuffer[1], i, portMode[1]));
}
for (size_t i = portBase; i < portBase + 2; i++) {
ASSERT_EQ(status,
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
- allocatePortBuffers(omxNode, &pBuffer[i - portBase], i,
- portMode[i - portBase]);
+ ASSERT_NO_FATAL_FAILURE(allocatePortBuffers(
+ omxNode, &pBuffer[i - portBase], i, portMode[i - portBase]));
status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT,
&pBuffer[0], &pBuffer[1]);
ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
}
}
- // set state to Idle
- changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]);
-
- // set state to Loaded
- changeStateIdletoLoaded(omxNode, observer, &pBuffer[0], &pBuffer[1],
- kPortIndexInput, kPortIndexOutput);
+ // set state to idle
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]));
+ // set state to loaded
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateIdletoLoaded(omxNode, observer, &pBuffer[0], &pBuffer[1],
+ kPortIndexInput, kPortIndexOutput));
}
// port enable disable test - monkeying
attributes = _nl;
})
.isOk());
+ ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
if (attributes.size() == 0) ALOGV("Warning, Attribute list empty");
}
nodeList = _nl;
})
.isOk());
+ ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
if (nodeList.size() == 0)
ALOGV("Warning, ComponentInfo list empty");
else {
omxNode = _nl;
})
.isOk());
+ ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
if (omxNode == nullptr) {
isPass = false;
std::cerr << "[ !OK ] " << nodeList[i].mName.c_str()
this->omxNode = _nl;
})
.isOk());
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
ASSERT_NE(omxNode, nullptr);
ASSERT_NE(gEnv->getRole().empty(), true) << "Invalid Component Role";
struct StringToName {
nFrameWidth, nFrameHeight, 0, xFramerate);
// If you can disable a port, then you should be able to
- // enable
- // it as well
+ // enable it as well
status = omxNode->sendCommand(
toRawCommandType(OMX_CommandPortEnable), kPortIndexOutput);
ASSERT_EQ(status,
status,
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
- allocatePortBuffers(omxNode, oBuffer, kPortIndexOutput,
- oPortMode, true);
+ ASSERT_NO_FATAL_FAILURE(allocatePortBuffers(
+ omxNode, oBuffer, kPortIndexOutput, oPortMode, true));
status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT,
iBuffer, oBuffer);
ASSERT_EQ(status,
// dispatch output buffers
for (size_t i = 0; i < oBuffer->size(); i++) {
- dispatchOutputBuffer(omxNode, oBuffer, i, oPortMode);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, i, oPortMode));
}
} else {
ASSERT_TRUE(false);
} else if (msg.data.eventData.event == OMX_EventError) {
std::cerr << "[ ERROR ] OMX_EventError/ "
"Decode Frame Call might be failed \n";
- return;
+ ASSERT_TRUE(false);
} else {
// something unexpected happened
ASSERT_TRUE(false);
status =
observer->dequeueMessage(&msg, DEFAULT_TIMEOUT_Q, iBuffer, oBuffer);
if (status == android::hardware::media::omx::V1_0::Status::OK) {
- EXPECT_EQ(msg.type, Message::Type::EVENT);
- portReconfiguration(omxNode, observer, iBuffer, oBuffer,
- kPortIndexInput, kPortIndexOutput, msg,
- oPortMode, nullptr);
+ ASSERT_EQ(msg.type, Message::Type::EVENT);
+ ASSERT_NO_FATAL_FAILURE(portReconfiguration(
+ omxNode, observer, iBuffer, oBuffer, kPortIndexInput,
+ kPortIndexOutput, msg, oPortMode, nullptr));
}
// status == TIMED_OUT, it could be due to process time being large
// than DEFAULT_TIMEOUT or component needs output buffers to start
// Dispatch an output buffer assuming outQueue.empty() is true
size_t index;
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index, oPortMode);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index, oPortMode));
timeOut = TIMEOUT_COUNTER_Q;
}
}
// Port Reconfiguration
if (status == android::hardware::media::omx::V1_0::Status::OK &&
msg.type == Message::Type::EVENT) {
- portReconfiguration(omxNode, observer, iBuffer, oBuffer,
- kPortIndexInput, kPortIndexOutput, msg,
- oPortMode, nullptr);
+ ASSERT_NO_FATAL_FAILURE(portReconfiguration(
+ omxNode, observer, iBuffer, oBuffer, kPortIndexInput,
+ kPortIndexOutput, msg, oPortMode, nullptr));
}
if (frameID == (int)Info->size() || frameID == (offset + range)) break;
if (signalEOS && ((frameID == (int)Info->size() - 1) ||
(frameID == (offset + range - 1))))
flags |= OMX_BUFFERFLAG_EOS;
- dispatchInputBuffer(omxNode, iBuffer, index,
- (*Info)[frameID].bytesCount, flags,
- (*Info)[frameID].timestamp);
+ ASSERT_NO_FATAL_FAILURE(dispatchInputBuffer(
+ omxNode, iBuffer, index, (*Info)[frameID].bytesCount, flags,
+ (*Info)[frameID].timestamp));
frameID++;
iQueued = true;
}
// Dispatch output buffer
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index, oPortMode);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index, oPortMode));
oQueued = true;
}
// Reset Counters when either input or output buffer is dispatched
else
timeOut--;
if (timeOut == 0) {
- EXPECT_TRUE(false) << "Wait on Input/Output is found indefinite";
- break;
+ ASSERT_TRUE(false) << "Wait on Input/Output is found indefinite";
}
}
}
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode, true);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, portMode, true));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// Port Reconfiguration
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
- portMode[1]);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(), portMode[1]));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode[1]);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode[1]));
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr));
if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// Test for adaptive playback support
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode, true);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, portMode, true));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
timestampDevTest = true;
uint32_t timestampOffset = 0;
// Port Reconfiguration
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
- portMode[1], false);
+ ASSERT_NO_FATAL_FAILURE(
+ decodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, eleStream, &Info,
+ 0, (int)Info.size(), portMode[1], false));
eleStream.close();
getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
}
portSettingsChange = false;
}
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode[1]);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode[1]));
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr));
if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// end of sequence test
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode, true);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, portMode, true));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// request EOS at the start
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
EXPECT_GE(framesReceived, 0U);
framesReceived = 0;
timestampUs = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// end of sequence test
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode, true);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, portMode, true));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// request EOS for thumbnail
size_t i = 0;
while (!(Info[i].flags & OMX_BUFFERFLAG_SYNCFRAME)) i++;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1]);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1]));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode[1]);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode[1]));
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
EXPECT_GE(framesReceived, 1U);
framesReceived = 0;
timestampUs = 0;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1],
- false);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1], false));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode[1]);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode[1]));
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
EXPECT_GE(framesReceived, 1U);
framesReceived = 0;
timestampUs = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// end of sequence test
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode, true);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, portMode, true));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// request EOS at the end
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
- portMode[1], false);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput,
+ eleStream, &Info, 0, (int)Info.size(),
+ portMode[1], false));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode[1]);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
- portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode[1]));
+ ASSERT_NO_FATAL_FAILURE(testEOS(
+ omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+ portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
framesReceived = 0;
timestampUs = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// test input/output port flush
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode, true);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, portMode, true));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// Decode 128 frames and flush. here 128 is chosen to ensure there is a key
// frame after this so that the below section can be convered for all
int nFrames = 128;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, 0, nFrames, portMode[1],
- false);
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(
+ omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+ kPortIndexOutput, eleStream, &Info, 0, nFrames, portMode[1], false));
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
framesReceived = 0;
// Seek to next key frame and start decoding till the end
index++;
}
if (keyFrame) {
- decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput, eleStream, &Info, index,
- Info.size() - index, portMode[1], false);
+ ASSERT_NO_FATAL_FAILURE(
+ decodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, eleStream, &Info,
+ index, Info.size() - index, portMode[1], false));
}
eleStream.close();
- flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(flushPorts(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput));
framesReceived = 0;
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
int main(int argc, char** argv) {
this->omxNode = _nl;
})
.isOk());
+ ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
ASSERT_NE(omxNode, nullptr);
ASSERT_NE(gEnv->getRole().empty(), true) << "Invalid Component Role";
struct StringToName {
size_t i = 0;
status =
observer->dequeueMessage(&msg, DEFAULT_TIMEOUT_Q, iBuffer, oBuffer);
- EXPECT_EQ(status,
+ ASSERT_EQ(status,
android::hardware::media::omx::V1_0::Status::TIMED_OUT);
// status == TIMED_OUT, it could be due to process time being large
// than DEFAULT_TIMEOUT or component needs output buffers to start
// Dispatch an output buffer assuming outQueue.empty() is true
size_t index;
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index));
timeOut = TIMEOUT_COUNTER_Q;
}
}
ASSERT_EQ(msg.data.eventData.data2,
OMX_IndexConfigAndroidIntraRefresh);
} else if (msg.data.eventData.event == OMX_EventError) {
- EXPECT_TRUE(false) << "Received OMX_EventError, not sure why";
- break;
+ ASSERT_TRUE(false) << "Received OMX_EventError, not sure why";
} else if (msg.data.eventData.event == OMX_EventDataSpaceChanged) {
// TODO: how am i supposed to respond now?
std::cout << "[ INFO ] OMX_EventDataSpaceChanged \n";
if (inputDataIsMeta) {
if (listener->freeBuffers > listener->minUnDequeuedCount) {
if (dispatchGraphicBuffer(omxNode, producer, listener, iBuffer,
- portIndexInput, eleStream, timestamp))
- break;
+ portIndexInput, eleStream,
+ timestamp)) {
+ if (::testing::Test::HasFailure())
+ ASSERT_TRUE(false);
+ else
+ break;
+ }
timestamp += timestampIncr;
nFrames--;
ipCount++;
break;
flags = OMX_BUFFERFLAG_ENDOFFRAME;
if (signalEOS && (nFrames == 1)) flags |= OMX_BUFFERFLAG_EOS;
- dispatchInputBuffer(omxNode, iBuffer, index, bytesCount, flags,
- timestamp);
+ ASSERT_NO_FATAL_FAILURE(dispatchInputBuffer(
+ omxNode, iBuffer, index, bytesCount, flags, timestamp));
if (timestampUslist) timestampUslist->push_back(timestamp);
timestamp += timestampIncr;
nFrames--;
}
// Dispatch output buffer
if ((index = getEmptyBufferID(oBuffer)) < oBuffer->size()) {
- dispatchOutputBuffer(omxNode, oBuffer, index);
+ ASSERT_NO_FATAL_FAILURE(
+ dispatchOutputBuffer(omxNode, oBuffer, index));
oQueued = true;
}
// Reset Counters when either input or output buffer is dispatched
else
timeOut--;
if (timeOut == 0) {
- EXPECT_TRUE(false) << "Wait on Input/Output is found indefinite";
- break;
+ ASSERT_TRUE(false) << "Wait on Input/Output is found indefinite";
}
// Runtime Param Configuration
if (ipCount == 15) {
xFramerate, eColorFormat);
sp<DummyBufferSource> buffersource = new DummyBufferSource(omxNode);
- EXPECT_NE(buffersource, nullptr);
+ ASSERT_NE(buffersource, nullptr);
status = omxNode->setInputSurface(buffersource);
ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &buffersource->iBuffer,
- &buffersource->oBuffer, kPortIndexInput,
- kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(changeStateLoadedtoIdle(
+ omxNode, observer, &buffersource->iBuffer, &buffersource->oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
- testEOS(omxNode, observer, &buffersource->iBuffer, &buffersource->oBuffer,
- false, eosFlag);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
+ ASSERT_NO_FATAL_FAILURE(testEOS(omxNode, observer, &buffersource->iBuffer,
+ &buffersource->oBuffer, false, eosFlag));
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &buffersource->iBuffer,
- &buffersource->oBuffer);
+ ASSERT_NO_FATAL_FAILURE(changeStateExecutetoIdle(
+ omxNode, observer, &buffersource->iBuffer, &buffersource->oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &buffersource->iBuffer,
- &buffersource->oBuffer, kPortIndexInput,
- kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(
+ omxNode, observer, &buffersource->iBuffer, &buffersource->oBuffer,
+ kPortIndexInput, kPortIndexOutput));
// test for callbacks
EXPECT_EQ(buffersource->callback, 31);
}
// Configure output port
uint32_t nBitRate = 512000;
- setDefaultPortParam(omxNode, kPortIndexOutput, eCompressionFormat,
- nFrameWidth, nFrameHeight, nBitRate, xFramerate);
+ ASSERT_NO_FATAL_FAILURE(
+ setDefaultPortParam(omxNode, kPortIndexOutput, eCompressionFormat,
+ nFrameWidth, nFrameHeight, nBitRate, xFramerate));
setRefreshPeriod(omxNode, kPortIndexOutput, 0);
unsigned int index;
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- encodeNFrames(omxNode, observer, kPortIndexInput, kPortIndexOutput,
- &iBuffer, &oBuffer, 32, xFramerate,
- (nFrameWidth * nFrameHeight * 3) >> 1, eleStream,
- ×tampUslist);
+ ASSERT_NO_FATAL_FAILURE(encodeNFrames(
+ omxNode, observer, kPortIndexInput, kPortIndexOutput, &iBuffer,
+ &oBuffer, 32, xFramerate, (nFrameWidth * nFrameHeight * 3) >> 1,
+ eleStream, ×tampUslist));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag);
+ ASSERT_NO_FATAL_FAILURE(
+ waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer));
+ ASSERT_NO_FATAL_FAILURE(
+ testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag));
if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
}
// test raw stream encode (input is ANW buffers)
// Configure output port
uint32_t nBitRate = 512000;
- setDefaultPortParam(omxNode, kPortIndexOutput, eCompressionFormat,
- nFrameWidth, nFrameHeight, nBitRate, xFramerate);
-
+ ASSERT_NO_FATAL_FAILURE(
+ setDefaultPortParam(omxNode, kPortIndexOutput, eCompressionFormat,
+ nFrameWidth, nFrameHeight, nBitRate, xFramerate));
// CreateInputSurface
EXPECT_TRUE(omx->createInputSurface(
[&](android::hardware::media::omx::V1_0::Status _s,
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
- encodeNFrames(omxNode, observer, kPortIndexInput, kPortIndexOutput,
- &iBuffer, &oBuffer, 1024, xFramerate,
- (nFrameWidth * nFrameHeight * 3) >> 1, eleStream, nullptr,
- false, true, producer, listener);
+ ASSERT_NO_FATAL_FAILURE(encodeNFrames(
+ omxNode, observer, kPortIndexInput, kPortIndexOutput, &iBuffer,
+ &oBuffer, 1024, xFramerate, (nFrameWidth * nFrameHeight * 3) >> 1,
+ eleStream, nullptr, false, true, producer, listener));
eleStream.close();
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, true,
- listener);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag);
+ ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(omxNode, observer, &iBuffer,
+ &oBuffer, true, listener));
+ ASSERT_NO_FATAL_FAILURE(
+ testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag));
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
EXPECT_EQ(portDef.nBufferCountActual, listener->freeBuffers);
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
returnval = producer->disconnect(
NATIVE_WINDOW_API_CPU, IGraphicBufferProducer::DisconnectMode::API);
android::Vector<BufferInfo> iBuffer, oBuffer;
// set state to idle
- changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput, portMode);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+ kPortIndexInput, kPortIndexOutput, portMode));
// set state to executing
- changeStateIdletoExecute(omxNode, observer);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoExecute(omxNode, observer));
// send EOS
status = source->signalEndOfInputStream();
ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
- waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer, true,
- listener);
- testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag);
+ ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(omxNode, observer, &iBuffer,
+ &oBuffer, true, listener));
+ ASSERT_NO_FATAL_FAILURE(
+ testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag));
// set state to idle
- changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+ ASSERT_NO_FATAL_FAILURE(
+ changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer));
EXPECT_EQ(portDef.nBufferCountActual, listener->freeBuffers);
// set state to executing
- changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
- kPortIndexInput, kPortIndexOutput);
+ ASSERT_NO_FATAL_FAILURE(changeStateIdletoLoaded(omxNode, observer, &iBuffer,
+ &oBuffer, kPortIndexInput,
+ kPortIndexOutput));
returnval = producer->disconnect(
NATIVE_WINDOW_API_CPU, IGraphicBufferProducer::DisconnectMode::API);
OSDN Git Service
