void SoftVPX::onQueueFilled(OMX_U32 /* portIndex */) {
if (mOutputPortSettingsChange != NONE) {
return;
}
List<BufferInfo *> &inQueue = getPortQueue(0);
List<BufferInfo *> &outQueue = getPortQueue(1);
bool EOSseen = false;
while (!inQueue.empty() && !outQueue.empty()) {
BufferInfo *inInfo = *inQueue.begin();
OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
BufferInfo *outInfo = *outQueue.begin();
OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
EOSseen = true;
if (inHeader->nFilledLen == 0) {
inQueue.erase(inQueue.begin());
inInfo->mOwnedByUs = false;
notifyEmptyBufferDone(inHeader);
outHeader->nFilledLen = 0;
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
outQueue.erase(outQueue.begin());
outInfo->mOwnedByUs = false;
notifyFillBufferDone(outHeader);
return;
}
}
if (mImg == NULL) {
if (vpx_codec_decode(
(vpx_codec_ctx_t *)mCtx,
inHeader->pBuffer + inHeader->nOffset,
inHeader->nFilledLen,
NULL,
0)) {
ALOGE("on2 decoder failed to decode frame.");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
return;
}
vpx_codec_iter_t iter = NULL;
mImg = vpx_codec_get_frame((vpx_codec_ctx_t *)mCtx, &iter);
}
if (mImg != NULL) {
CHECK_EQ(mImg->fmt, VPX_IMG_FMT_I420);
uint32_t width = mImg->d_w;
uint32_t height = mImg->d_h;
bool portWillReset = false;
handlePortSettingsChange(&portWillReset, width, height);
if (portWillReset) {
return;
}
outHeader->nOffset = 0;
outHeader->nFilledLen = (outputBufferWidth() * outputBufferHeight() * 3) / 2;
outHeader->nFlags = EOSseen ? OMX_BUFFERFLAG_EOS : 0;
outHeader->nTimeStamp = inHeader->nTimeStamp;
if (outHeader->nAllocLen >= outHeader->nFilledLen) {
uint8_t *dst = outHeader->pBuffer;
const uint8_t *srcY = (const uint8_t *)mImg->planes[VPX_PLANE_Y];
const uint8_t *srcU = (const uint8_t *)mImg->planes[VPX_PLANE_U];
const uint8_t *srcV = (const uint8_t *)mImg->planes[VPX_PLANE_V];
size_t srcYStride = mImg->stride[VPX_PLANE_Y];
size_t srcUStride = mImg->stride[VPX_PLANE_U];
size_t srcVStride = mImg->stride[VPX_PLANE_V];
copyYV12FrameToOutputBuffer(dst, srcY, srcU, srcV, srcYStride, srcUStride, srcVStride);
} else {
ALOGE("b/27597103, buffer too small");
outHeader->nFilledLen = 0;
}
mImg = NULL;
outInfo->mOwnedByUs = false;
outQueue.erase(outQueue.begin());
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
}
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
}
}
status_t SoftHEVC::initDecoder() {
IV_API_CALL_STATUS_T status;
UWORD32 u4_num_reorder_frames;
UWORD32 u4_num_ref_frames;
UWORD32 u4_share_disp_buf;
WORD32 i4_level;
mNumCores = GetCPUCoreCount();
/* Initialize number of ref and reorder modes (for HEVC) */
u4_num_reorder_frames = 16;
u4_num_ref_frames = 16;
u4_share_disp_buf = 0;
uint32_t displayStride = outputBufferWidth();
uint32_t displayHeight = outputBufferHeight();
uint32_t displaySizeY = displayStride * displayHeight;
if (displaySizeY > (1920 * 1088)) {
i4_level = 50;
} else if (displaySizeY > (1280 * 720)) {
i4_level = 40;
} else if (displaySizeY > (960 * 540)) {
i4_level = 31;
} else if (displaySizeY > (640 * 360)) {
i4_level = 30;
} else if (displaySizeY > (352 * 288)) {
i4_level = 21;
} else {
i4_level = 20;
}
{
iv_num_mem_rec_ip_t s_num_mem_rec_ip;
iv_num_mem_rec_op_t s_num_mem_rec_op;
s_num_mem_rec_ip.u4_size = sizeof(s_num_mem_rec_ip);
s_num_mem_rec_op.u4_size = sizeof(s_num_mem_rec_op);
s_num_mem_rec_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC;
ALOGV("Get number of mem records");
status = ivdec_api_function(mCodecCtx, (void*)&s_num_mem_rec_ip,
(void*)&s_num_mem_rec_op);
if (IV_SUCCESS != status) {
ALOGE("Error in getting mem records: 0x%x",
s_num_mem_rec_op.u4_error_code);
return UNKNOWN_ERROR;
}
mNumMemRecords = s_num_mem_rec_op.u4_num_mem_rec;
}
mMemRecords = (iv_mem_rec_t*)ivd_aligned_malloc(
128, mNumMemRecords * sizeof(iv_mem_rec_t));
if (mMemRecords == NULL) {
ALOGE("Allocation failure");
return NO_MEMORY;
}
memset(mMemRecords, 0, mNumMemRecords * sizeof(iv_mem_rec_t));
{
size_t i;
ivdext_fill_mem_rec_ip_t s_fill_mem_ip;
ivdext_fill_mem_rec_op_t s_fill_mem_op;
iv_mem_rec_t *ps_mem_rec;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_size =
sizeof(ivdext_fill_mem_rec_ip_t);
s_fill_mem_ip.i4_level = i4_level;
s_fill_mem_ip.u4_num_reorder_frames = u4_num_reorder_frames;
s_fill_mem_ip.u4_num_ref_frames = u4_num_ref_frames;
s_fill_mem_ip.u4_share_disp_buf = u4_share_disp_buf;
s_fill_mem_ip.u4_num_extra_disp_buf = 0;
s_fill_mem_ip.e_output_format = mIvColorFormat;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.e_cmd = IV_CMD_FILL_NUM_MEM_REC;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location = mMemRecords;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd = displayStride;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht = displayHeight;
s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_size =
sizeof(ivdext_fill_mem_rec_op_t);
ps_mem_rec = mMemRecords;
for (i = 0; i < mNumMemRecords; i++)
ps_mem_rec[i].u4_size = sizeof(iv_mem_rec_t);
status = ivdec_api_function(mCodecCtx, (void *)&s_fill_mem_ip,
(void *)&s_fill_mem_op);
if (IV_SUCCESS != status) {
ALOGE("Error in filling mem records: 0x%x",
s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_error_code);
return UNKNOWN_ERROR;
}
mNumMemRecords =
s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_num_mem_rec_filled;
ps_mem_rec = mMemRecords;
for (i = 0; i < mNumMemRecords; i++) {
ps_mem_rec->pv_base = ivd_aligned_malloc(
ps_mem_rec->u4_mem_alignment, ps_mem_rec->u4_mem_size);
if (ps_mem_rec->pv_base == NULL) {
ALOGE("Allocation failure for memory record #%zu of size %u",
i, ps_mem_rec->u4_mem_size);
status = IV_FAIL;
return NO_MEMORY;
}
ps_mem_rec++;
}
}
/* Initialize the decoder */
{
ivdext_init_ip_t s_init_ip;
ivdext_init_op_t s_init_op;
void *dec_fxns = (void *)ivdec_api_function;
s_init_ip.s_ivd_init_ip_t.u4_size = sizeof(ivdext_init_ip_t);
s_init_ip.s_ivd_init_ip_t.e_cmd = (IVD_API_COMMAND_TYPE_T)IV_CMD_INIT;
s_init_ip.s_ivd_init_ip_t.pv_mem_rec_location = mMemRecords;
s_init_ip.s_ivd_init_ip_t.u4_frm_max_wd = displayStride;
s_init_ip.s_ivd_init_ip_t.u4_frm_max_ht = displayHeight;
s_init_ip.i4_level = i4_level;
s_init_ip.u4_num_reorder_frames = u4_num_reorder_frames;
s_init_ip.u4_num_ref_frames = u4_num_ref_frames;
s_init_ip.u4_share_disp_buf = u4_share_disp_buf;
s_init_ip.u4_num_extra_disp_buf = 0;
s_init_op.s_ivd_init_op_t.u4_size = sizeof(s_init_op);
s_init_ip.s_ivd_init_ip_t.u4_num_mem_rec = mNumMemRecords;
s_init_ip.s_ivd_init_ip_t.e_output_format = mIvColorFormat;
mCodecCtx = (iv_obj_t*)mMemRecords[0].pv_base;
mCodecCtx->pv_fxns = dec_fxns;
mCodecCtx->u4_size = sizeof(iv_obj_t);
ALOGD("Initializing decoder");
status = ivdec_api_function(mCodecCtx, (void *)&s_init_ip,
(void *)&s_init_op);
if (status != IV_SUCCESS) {
ALOGE("Error in init: 0x%x",
s_init_op.s_ivd_init_op_t.u4_error_code);
return UNKNOWN_ERROR;
}
}
/* Reset the plugin state */
resetPlugin();
/* Set the run time (dynamic) parameters */
setParams(displayStride);
/* Set number of cores/threads to be used by the codec */
setNumCores();
/* Get codec version */
logVersion();
/* Allocate internal picture buffer */
uint32_t bufferSize = displaySizeY * 3 / 2;
mFlushOutBuffer = (uint8_t *)ivd_aligned_malloc(128, bufferSize);
if (NULL == mFlushOutBuffer) {
ALOGE("Could not allocate flushOutputBuffer of size %zu", bufferSize);
return NO_MEMORY;
}
mInitNeeded = false;
mFlushNeeded = false;
return OK;
}
void SoftMPEG4::onQueueFilled(OMX_U32 /* portIndex */) {
if (mSignalledError || mOutputPortSettingsChange != NONE) {
return;
}
List<BufferInfo *> &inQueue = getPortQueue(0);
List<BufferInfo *> &outQueue = getPortQueue(1);
while (!inQueue.empty() && outQueue.size() == kNumOutputBuffers) {
BufferInfo *inInfo = *inQueue.begin();
OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
if (inHeader == NULL) {
inQueue.erase(inQueue.begin());
inInfo->mOwnedByUs = false;
continue;
}
PortInfo *port = editPortInfo(1);
OMX_BUFFERHEADERTYPE *outHeader =
port->mBuffers.editItemAt(mNumSamplesOutput & 1).mHeader;
if (inHeader->nFilledLen == 0) {
inQueue.erase(inQueue.begin());
inInfo->mOwnedByUs = false;
notifyEmptyBufferDone(inHeader);
++mInputBufferCount;
if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
outHeader->nFilledLen = 0;
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
List<BufferInfo *>::iterator it = outQueue.begin();
while ((*it)->mHeader != outHeader) {
++it;
}
BufferInfo *outInfo = *it;
outInfo->mOwnedByUs = false;
outQueue.erase(it);
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
}
return;
}
uint8_t *bitstream = inHeader->pBuffer + inHeader->nOffset;
uint32_t *start_code = (uint32_t *)bitstream;
bool volHeader = *start_code == 0xB0010000;
if (volHeader) {
PVCleanUpVideoDecoder(mHandle);
mInitialized = false;
}
if (!mInitialized) {
uint8_t *vol_data[1];
int32_t vol_size = 0;
vol_data[0] = NULL;
if ((inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG) || volHeader) {
vol_data[0] = bitstream;
vol_size = inHeader->nFilledLen;
}
MP4DecodingMode mode =
(mMode == MODE_MPEG4) ? MPEG4_MODE : H263_MODE;
Bool success = PVInitVideoDecoder(
mHandle, vol_data, &vol_size, 1,
outputBufferWidth(), outputBufferHeight(), mode);
if (!success) {
ALOGW("PVInitVideoDecoder failed. Unsupported content?");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
MP4DecodingMode actualMode = PVGetDecBitstreamMode(mHandle);
if (mode != actualMode) {
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
PVSetPostProcType((VideoDecControls *) mHandle, 0);
bool hasFrameData = false;
if (inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
} else if (volHeader) {
hasFrameData = true;
}
mInitialized = true;
if (mode == MPEG4_MODE && handlePortSettingsChange()) {
return;
}
if (!hasFrameData) {
continue;
}
}
if (!mFramesConfigured) {
PortInfo *port = editPortInfo(1);
OMX_BUFFERHEADERTYPE *outHeader = port->mBuffers.editItemAt(1).mHeader;
OMX_U32 yFrameSize = sizeof(uint8) * mHandle->size;
if ((outHeader->nAllocLen < yFrameSize) ||
(outHeader->nAllocLen - yFrameSize < yFrameSize / 2)) {
ALOGE("Too small output buffer for reference frame: %lu bytes",
(unsigned long)outHeader->nAllocLen);
android_errorWriteLog(0x534e4554, "30033990");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
PVSetReferenceYUV(mHandle, outHeader->pBuffer);
mFramesConfigured = true;
}
uint32_t useExtTimestamp = (inHeader->nOffset == 0);
// decoder deals in ms (int32_t), OMX in us (int64_t)
// so use fake timestamp instead
uint32_t timestamp = 0xFFFFFFFF;
if (useExtTimestamp) {
mPvToOmxTimeMap.add(mPvTime, inHeader->nTimeStamp);
timestamp = mPvTime;
mPvTime++;
}
int32_t bufferSize = inHeader->nFilledLen;
int32_t tmp = bufferSize;
OMX_U32 frameSize;
OMX_U64 yFrameSize = (OMX_U64)mWidth * (OMX_U64)mHeight;
if (yFrameSize > ((OMX_U64)UINT32_MAX / 3) * 2) {
ALOGE("Frame size too large");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
frameSize = (OMX_U32)(yFrameSize + (yFrameSize / 2));
if (outHeader->nAllocLen < frameSize) {
android_errorWriteLog(0x534e4554, "27833616");
ALOGE("Insufficient output buffer size");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
// The PV decoder is lying to us, sometimes it'll claim to only have
// consumed a subset of the buffer when it clearly consumed all of it.
// ignore whatever it says...
if (PVDecodeVideoFrame(
mHandle, &bitstream, ×tamp, &tmp,
&useExtTimestamp,
outHeader->pBuffer) != PV_TRUE) {
ALOGE("failed to decode video frame.");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
// H263 doesn't have VOL header, the frame size information is in short header, i.e. the
// decoder may detect size change after PVDecodeVideoFrame.
if (handlePortSettingsChange()) {
return;
}
// decoder deals in ms, OMX in us.
outHeader->nTimeStamp = mPvToOmxTimeMap.valueFor(timestamp);
mPvToOmxTimeMap.removeItem(timestamp);
inHeader->nOffset += bufferSize;
inHeader->nFilledLen = 0;
if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
} else {
outHeader->nFlags = 0;
}
if (inHeader->nFilledLen == 0) {
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
}
++mInputBufferCount;
outHeader->nOffset = 0;
outHeader->nFilledLen = frameSize;
List<BufferInfo *>::iterator it = outQueue.begin();
while ((*it)->mHeader != outHeader) {
++it;
}
BufferInfo *outInfo = *it;
outInfo->mOwnedByUs = false;
outQueue.erase(it);
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
++mNumSamplesOutput;
}
}
