CmmbResult CmmbFtAutoScan(CMMB_AUTOSCAN_CALLBACK scanProc)
{
CmmbResult ret;
if (scanProc == null)
return CMMB_E_INVALID_ARG;
for (int ch = CMMB_CHANNEL_MIN; ch <= CMMB_CHANNEL_MAX; ch++)
{
SP_LOGE( "scan test channel: %d", ch);
ret = CmmbFtChannelTest(ch);
if (ret == CMMB_S_OK)
{
SP_LOGE( "channel: %d has signal", ch);
int freq = CmmbFreqFromChannel(ch);
if (scanProc(ch, freq) == 0)
break;
}
else if(ret == CMMB_E_TIMEOUT){ // tune fail,stop auto scan
return ret;
}
}
return CMMB_S_OK;
}
void Camera3StreamSplitter::onFrameAvailable(const BufferItem& /*item*/) {
ATRACE_CALL();
Mutex::Autolock lock(mMutex);
// Acquire and detach the buffer from the input
BufferItem bufferItem;
status_t res = mConsumer->acquireBuffer(&bufferItem, /* presentWhen */ 0);
if (res != NO_ERROR) {
SP_LOGE("%s: Acquiring buffer from input failed (%d)", __FUNCTION__, res);
mOnFrameAvailableRes.store(res);
return;
}
if (mBuffers.find(bufferItem.mGraphicBuffer->getId()) == mBuffers.end()) {
SP_LOGE("%s: Acquired buffer doesn't exist in attached buffer map",
__FUNCTION__);
mOnFrameAvailableRes.store(INVALID_OPERATION);
return;
}
SP_LOGV("acquired buffer %" PRId64 " from input at slot %d",
bufferItem.mGraphicBuffer->getId(), bufferItem.mSlot);
res = mConsumer->detachBuffer(bufferItem.mSlot);
if (res != NO_ERROR) {
SP_LOGE("%s: detaching buffer from input failed (%d)", __FUNCTION__, res);
mOnFrameAvailableRes.store(res);
return;
}
// Attach and queue the buffer to each of the outputs
BufferTracker& tracker = *(mBuffers[bufferItem.mGraphicBuffer->getId()]);
SP_LOGV("%s: BufferTracker for buffer %" PRId64 ", number of requests %zu",
__FUNCTION__, bufferItem.mGraphicBuffer->getId(), tracker.requestedSurfaces().size());
for (const auto id : tracker.requestedSurfaces()) {
LOG_ALWAYS_FATAL_IF(id >= mOutputs.size(),
"requested surface id exceeding max registered ids");
res = outputBufferLocked(mOutputs[id], bufferItem);
if (res != OK) {
SP_LOGE("%s: outputBufferLocked failed %d", __FUNCTION__, res);
mOnFrameAvailableRes.store(res);
// If we fail to send buffer to certain output, keep sending to
// other outputs.
continue;
}
}
mOnFrameAvailableRes.store(res);
}
CmmbResult GetSystemStatus(CmmbProps* props)
{
#if 0
UINT32 status = 0;
inno_sys_state state = inno_sys_state();
state.stattype = statId;
INNO_RET ret = InnoGetSysStatus(&state);
SP_LOGE("stattype: %d, InnoGetSysStatus return %d", statId, ret);
if (ret ==INNO_NO_ERROR)
{
SP_LOGE(" status: %d", state.statdata.signal_quality);
status = state.statdata.signal_quality;
}
return status;
#else
UINT32 status = 0;
INNO_RET ret;
inno_sys_state state = inno_sys_state();
//get signal strength
state.stattype = STATTYPE_SIGNAL_STRENGTH;
ret = InnoGetSysStatus(&state);
SP_LOGE("stattype: %d, InnoGetSysStatus return %d", STATTYPE_SIGNAL_STRENGTH, ret);
if (ret !=INNO_NO_ERROR)
{
SP_LOGE(" Fail InnoGetSysStatus STATTYPE_SIGNAL_STRENGTH: %d" );
return ErrCodeFromInno(ret);
}
props->RSSI=state.statdata.signal_strength;
//get SNR
state.stattype = STATTYPE_SNR_COUNT;
ret = InnoGetSysStatus(&state);
SP_LOGE("stattype: %d, InnoGetSysStatus return %d", STATTYPE_SNR_COUNT, ret);
if (ret !=INNO_NO_ERROR)
{
SP_LOGE(" Fail InnoGetSysStatus STATTYPE_SNR_COUNT: %d" );
return ErrCodeFromInno(ret);
}
props->SNR=state.statdata.SNR;
//get ber
state.stattype = STATTYPE_BER_COUNT;
ret = InnoGetSysStatus(&state);
SP_LOGE("stattype: %d, InnoGetSysStatus return %d", STATTYPE_BER_COUNT, ret);
if (ret !=INNO_NO_ERROR)
{
SP_LOGE(" Fail InnoGetSysStatus STATTYPE_BER_COUNT: %d" );
return ErrCodeFromInno(ret);
}
props->PRE_BER=state.statdata.BER;
return ErrCodeFromInno(ret);
#endif
}
void Camera3StreamSplitter::onBufferReleasedByOutputLocked(
const sp<IGraphicBufferProducer>& from) {
ATRACE_CALL();
sp<GraphicBuffer> buffer;
sp<Fence> fence;
status_t res = from->detachNextBuffer(&buffer, &fence);
if (res == NO_INIT) {
// If we just discovered that this output has been abandoned, note that,
// but we can't do anything else, since buffer is invalid
onAbandonedLocked();
return;
} else if (res == NO_MEMORY) {
SP_LOGV("%s: No free buffers", __FUNCTION__);
return;
} else if (res != OK) {
SP_LOGE("%s: detaching buffer from output failed (%d)", __FUNCTION__, res);
return;
}
BufferTracker& tracker = *(mBuffers[buffer->getId()]);
// Merge the release fence of the incoming buffer so that the fence we send
// back to the input includes all of the outputs' fences
if (fence != nullptr && fence->isValid()) {
tracker.mergeFence(fence);
}
SP_LOGV("detached buffer %" PRId64 " %p from output %p",
buffer->getId(), buffer.get(), from.get());
// Check to see if this is the last outstanding reference to this buffer
decrementBufRefCountLocked(buffer->getId(), from);
}
CmmbResult StartTs0()
{
CmmbResult errCode;
INNO_RET res;
g_curReq = REQ_START_TS0;
g_rspEvent.Clear();
startTs0 = true;
// send request
res = InnoSetChannelConfig(0, 0, 1, TS0_BPSK_DEMOD, 0);
if (res == INNO_NO_ERROR)
{
// wait for response
errCode = g_rspEvent.Wait(CMMB_CMD_RES_MAX_TIME);
g_curReq = REQ_NONE;
}
else
errCode = ErrCodeFromInno(res);
SP_LOGE("res: %d", res);
startTs0 = false;
return errCode;
}
CmmbResult StopTs0()
{
INNO_RET res;
res = InnoCloseChannel(0);
SP_LOGE( "res: %d", res);
return ErrCodeFromInno(res);
}
//CmmbResult CmmbFtGetProp(int propId, int* propVal)
CmmbResult CmmbFtGetProp(CmmbProps* props)
{
#if 0
if (propVal == null)
return CMMB_E_INVALID_ARG;
int statId = 0;
switch (propId)
{
case CMMB_PROP_SNR:
statId = STATTYPE_SIGNAL_STRENGTH;
break;
case CMMB_PROP_PRE_BER:
statId = STATTYPE_BER_COUNT;
break;
case CMMB_PROP_RSSI:
statId = STATTYPE_SNR_COUNT;
break;
default:
SP_LOGE( "error! unknown property ID");
return CMMB_E_INVALID_ARG;
}
*propVal = GetSystemStatus(statId);
#else
CmmbResult ret;
ret = GetSystemStatus(props);
#endif
return CMMB_S_OK;
}
void Camera3StreamSplitter::decrementBufRefCountLocked(uint64_t id,
const sp<IGraphicBufferProducer>& from) {
ATRACE_CALL();
size_t referenceCount = mBuffers[id]->decrementReferenceCountLocked();
removeSlotForOutputLocked(from, mBuffers[id]->getBuffer());
if (referenceCount > 0) {
return;
}
// We no longer need to track the buffer now that it is being returned to the
// input. Note that this should happen before we unlock the mutex and call
// releaseBuffer, to avoid the case where the same bufferId is acquired in
// attachBufferToOutputs resulting in a new BufferTracker with same bufferId
// overwrites the current one.
std::unique_ptr<BufferTracker> tracker_ptr = std::move(mBuffers[id]);
mBuffers.erase(id);
// Attach and release the buffer back to the input
int consumerSlot = BufferItem::INVALID_BUFFER_SLOT;
status_t res = mConsumer->attachBuffer(&consumerSlot, tracker_ptr->getBuffer());
if (res != NO_ERROR) {
SP_LOGE("%s: attaching buffer to input failed (%d)", __FUNCTION__, res);
return;
}
// Temporarily unlock mutex to avoid circular lock:
// 1. This function holds splitter lock, calls releaseBuffer which triggers
// onBufferReleased in Camera3OutputStream. onBufferReleased waits on the
// OutputStream lock
// 2. Camera3SharedOutputStream::getBufferLocked calls
// attachBufferToOutputs, which holds the stream lock, and waits for the
// splitter lock.
sp<IGraphicBufferConsumer> consumer(mConsumer);
mMutex.unlock();
if (consumer != nullptr) {
res = consumer->releaseBuffer(consumerSlot, /* frameNumber */ 0,
EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, tracker_ptr->getMergedFence());
} else {
SP_LOGE("%s: consumer has become null!", __FUNCTION__);
}
mMutex.lock();
// If the producer of this queue is disconnected, -22 error will occur
if (res != NO_ERROR) {
SP_LOGE("%s: releaseBuffer returns %d", __FUNCTION__, res);
}
}
CmmbResult StartService(int serviceId)
{
SP_LOGE( "INNO enter");
// get service information from service ID
MTKCmmbParserMpxFrame* mpxFrm = FindMpxFrameInfo(serviceId);
if (mpxFrm == null)
{
SP_LOGE( "FindMpxFrameInfo failed!");
return CMMB_E_INVALID_ARG;
}
// find channel
BYTE channel_id = 0xFF;
if (channelState[1])
channel_id = 1;
else if (channelState[0])
channel_id = 0;
else
{
SP_LOGE( "error: has no empty channel!");
return CMMB_E_WRONGSTATE;
}
// start service
INNO_RET res;
BYTE demod = GetMpxFrameDemod(*mpxFrm);
SP_LOGE( "channel_id: %d, firtsTS: %d, ts count: %d, demod: %d", channel_id, mpxFrm->FirstTimeslot, mpxFrm->NumTimeSlots, demod);
res = InnoSetChannelConfig(channel_id, mpxFrm->FirstTimeslot, mpxFrm->NumTimeSlots, demod, 0);
if (res == INNO_NO_ERROR)
{
channelState[channel_id] = false;
// save service handle
g_curSrvHdl = channel_id+SERVICE_HANDLE_OFFSET;
}
return ErrCodeFromInno(res);
}
CmmbResult CmmbFtInit()
{
CmmbResult errCode;
// initialize host library
errCode = HostLibInit();
cmmb_build_crc_table();
if (errCode == CMMB_S_OK)
{
// update service provider state
g_cmmbState = CMMB_IDLE;
SP_LOGE( "CmmbFtInit() OK");
}
else
{
SP_LOGE( "CmmbInit() error");
}
return errCode;
}
int Camera3StreamSplitter::getSlotForOutputLocked(const sp<IGraphicBufferProducer>& gbp,
const sp<GraphicBuffer>& gb) {
auto& outputSlots = *mOutputSlots[gbp];
for (size_t i = 0; i < outputSlots.size(); i++) {
if (outputSlots[i] == gb) {
return (int)i;
}
}
SP_LOGE("%s: Cannot find slot for gb %p on output %p", __FUNCTION__, gb.get(),
gbp.get());
return BufferItem::INVALID_BUFFER_SLOT;
}
status_t Camera3StreamSplitter::addOutput(const sp<Surface>& outputQueue) {
ATRACE_CALL();
Mutex::Autolock lock(mMutex);
status_t res = addOutputLocked(outputQueue);
if (res != OK) {
SP_LOGE("%s: addOutputLocked failed %d", __FUNCTION__, res);
return res;
}
res = mConsumer->setMaxAcquiredBufferCount(mMaxConsumerBuffers+1);
return res;
}
status_t Camera3StreamSplitter::removeSlotForOutputLocked(const sp<IGraphicBufferProducer>& gbp,
const sp<GraphicBuffer>& gb) {
auto& outputSlots = *mOutputSlots[gbp];
for (size_t i = 0; i < outputSlots.size(); i++) {
if (outputSlots[i] == gb) {
outputSlots[i].clear();
return NO_ERROR;
}
}
SP_LOGE("%s: Cannot find slot for gb %p on output %p", __FUNCTION__, gb.get(),
gbp.get());
return BAD_VALUE;
}
status_t Camera3StreamSplitter::outputBufferLocked(const sp<IGraphicBufferProducer>& output,
const BufferItem& bufferItem) {
ATRACE_CALL();
status_t res;
IGraphicBufferProducer::QueueBufferInput queueInput(
bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp,
bufferItem.mDataSpace, bufferItem.mCrop,
static_cast<int32_t>(bufferItem.mScalingMode),
bufferItem.mTransform, bufferItem.mFence);
IGraphicBufferProducer::QueueBufferOutput queueOutput;
uint64_t bufferId = bufferItem.mGraphicBuffer->getId();
const BufferTracker& tracker = *(mBuffers[bufferId]);
int slot = getSlotForOutputLocked(output, tracker.getBuffer());
// In case the output BufferQueue has its own lock, if we hold splitter lock while calling
// queueBuffer (which will try to acquire the output lock), the output could be holding its
// own lock calling releaseBuffer (which will try to acquire the splitter lock), running into
// circular lock situation.
mMutex.unlock();
res = output->queueBuffer(slot, queueInput, &queueOutput);
mMutex.lock();
SP_LOGV("%s: Queuing buffer to buffer queue %p slot %d returns %d",
__FUNCTION__, output.get(), slot, res);
if (res != OK) {
if (res != NO_INIT && res != DEAD_OBJECT) {
SP_LOGE("Queuing buffer to output failed (%d)", res);
}
// If we just discovered that this output has been abandoned, note
// that, increment the release count so that we still release this
// buffer eventually, and move on to the next output
onAbandonedLocked();
decrementBufRefCountLocked(bufferItem.mGraphicBuffer->getId(), output);
return res;
}
// If the queued buffer replaces a pending buffer in the async
// queue, no onBufferReleased is called by the buffer queue.
// Proactively trigger the callback to avoid buffer loss.
if (queueOutput.bufferReplaced) {
onBufferReleasedByOutputLocked(output);
}
return res;
}
status_t Camera3StreamSplitter::attachBufferToOutputs(ANativeWindowBuffer* anb,
const std::vector<size_t>& surface_ids) {
ATRACE_CALL();
status_t res = OK;
Mutex::Autolock lock(mMutex);
sp<GraphicBuffer> gb(static_cast<GraphicBuffer*>(anb));
uint64_t bufferId = gb->getId();
// Initialize buffer tracker for this input buffer
auto tracker = std::make_unique<BufferTracker>(gb, surface_ids);
for (auto& surface_id : surface_ids) {
sp<IGraphicBufferProducer>& gbp = mOutputs[surface_id];
int slot = BufferItem::INVALID_BUFFER_SLOT;
//Temporarly Unlock the mutex when trying to attachBuffer to the output
//queue, because attachBuffer could block in case of a slow consumer. If
//we block while holding the lock, onFrameAvailable and onBufferReleased
//will block as well because they need to acquire the same lock.
mMutex.unlock();
res = gbp->attachBuffer(&slot, gb);
mMutex.lock();
if (res != OK) {
SP_LOGE("%s: Cannot acquireBuffer from GraphicBufferProducer %p: %s (%d)",
__FUNCTION__, gbp.get(), strerror(-res), res);
return res;
}
auto& outputSlots = *mOutputSlots[gbp];
if (outputSlots[slot] != nullptr) {
// If the buffer is attached to a slot which already contains a buffer,
// the previous buffer will be removed from the output queue. Decrement
// the reference count accordingly.
decrementBufRefCountLocked(outputSlots[slot]->getId(), gbp);
}
SP_LOGV("%s: Attached buffer %p to slot %d on output %p.",__FUNCTION__, gb.get(),
slot, gbp.get());
outputSlots[slot] = gb;
}
mBuffers[bufferId] = std::move(tracker);
return res;
}
status_t Camera3StreamSplitter::connect(const std::vector<sp<Surface> >& surfaces,
uint64_t consumerUsage, size_t halMaxBuffers, sp<Surface>* consumer) {
ATRACE_CALL();
if (consumer == nullptr) {
SP_LOGE("%s: consumer pointer is NULL", __FUNCTION__);
return BAD_VALUE;
}
Mutex::Autolock lock(mMutex);
status_t res = OK;
if (mOutputs.size() > 0 || mConsumer != nullptr) {
SP_LOGE("%s: already connected", __FUNCTION__);
return BAD_VALUE;
}
if (mBuffers.size() > 0) {
SP_LOGE("%s: still has %zu pending buffers", __FUNCTION__, mBuffers.size());
return BAD_VALUE;
}
mMaxHalBuffers = halMaxBuffers;
mConsumerName = getUniqueConsumerName();
// Add output surfaces. This has to be before creating internal buffer queue
// in order to get max consumer side buffers.
for (size_t i = 0; i < surfaces.size(); i++) {
if (surfaces[i] == nullptr) {
SP_LOGE("%s: Fatal: surface is NULL", __FUNCTION__);
return BAD_VALUE;
}
res = addOutputLocked(surfaces[i]);
if (res != OK) {
SP_LOGE("%s: Failed to add output surface: %s(%d)",
__FUNCTION__, strerror(-res), res);
return res;
}
}
// Create BufferQueue for input
BufferQueue::createBufferQueue(&mProducer, &mConsumer);
// Allocate 1 extra buffer to handle the case where all buffers are detached
// from input, and attached to the outputs. In this case, the input queue's
// dequeueBuffer can still allocate 1 extra buffer before being blocked by
// the output's attachBuffer().
mBufferItemConsumer = new BufferItemConsumer(mConsumer, consumerUsage,
mMaxConsumerBuffers+1);
if (mBufferItemConsumer == nullptr) {
return NO_MEMORY;
}
mConsumer->setConsumerName(mConsumerName);
*consumer = new Surface(mProducer);
if (*consumer == nullptr) {
return NO_MEMORY;
}
res = mConsumer->consumerConnect(this, /* controlledByApp */ false);
SP_LOGV("%s: connected", __FUNCTION__);
return res;
}
status_t Camera3StreamSplitter::addOutputLocked(const sp<Surface>& outputQueue) {
ATRACE_CALL();
if (outputQueue == nullptr) {
SP_LOGE("addOutput: outputQueue must not be NULL");
return BAD_VALUE;
}
sp<IGraphicBufferProducer> gbp = outputQueue->getIGraphicBufferProducer();
// Connect to the buffer producer
sp<OutputListener> listener(new OutputListener(this, gbp));
IInterface::asBinder(gbp)->linkToDeath(listener);
status_t res = outputQueue->connect(NATIVE_WINDOW_API_CAMERA, listener);
if (res != NO_ERROR) {
SP_LOGE("addOutput: failed to connect (%d)", res);
return res;
}
// Query consumer side buffer count, and update overall buffer count
int maxConsumerBuffers = 0;
res = static_cast<ANativeWindow*>(outputQueue.get())->query(
outputQueue.get(),
NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
if (res != OK) {
SP_LOGE("%s: Unable to query consumer undequeued buffer count"
" for surface", __FUNCTION__);
return res;
}
SP_LOGV("%s: Consumer wants %d buffers, Producer wants %zu", __FUNCTION__,
maxConsumerBuffers, mMaxHalBuffers);
size_t totalBufferCount = maxConsumerBuffers + mMaxHalBuffers;
res = native_window_set_buffer_count(outputQueue.get(),
totalBufferCount);
if (res != OK) {
SP_LOGE("%s: Unable to set buffer count for surface %p",
__FUNCTION__, outputQueue.get());
return res;
}
// Set dequeueBuffer/attachBuffer timeout if the consumer is not hw composer or hw texture.
// We need skip these cases as timeout will disable the non-blocking (async) mode.
uint64_t usage = 0;
res = native_window_get_consumer_usage(static_cast<ANativeWindow*>(outputQueue.get()), &usage);
if (!(usage & (GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_TEXTURE))) {
outputQueue->setDequeueTimeout(kDequeueBufferTimeout);
}
res = gbp->allowAllocation(false);
if (res != OK) {
SP_LOGE("%s: Failed to turn off allocation for outputQueue", __FUNCTION__);
return res;
}
// Add new entry into mOutputs
mOutputs.push_back(gbp);
mNotifiers[gbp] = listener;
mOutputSlots[gbp] = std::make_unique<OutputSlots>(totalBufferCount);
mMaxConsumerBuffers += maxConsumerBuffers;
return NO_ERROR;
}
