FLAC__StreamEncoderWriteStatus SoftFlacEncoder::onEncodedFlacAvailable( const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame) { UNUSED_UNLESS_VERBOSE(current_frame); ALOGV("SoftFlacEncoder::onEncodedFlacAvailable(bytes=%zu, samples=%u, curr_frame=%u)", bytes, samples, current_frame); #ifdef WRITE_FLAC_HEADER_IN_FIRST_BUFFER if (samples == 0) { ALOGI(" saving %zu bytes of header", bytes); memcpy(mHeader + mHeaderOffset, buffer, bytes); mHeaderOffset += bytes;// will contain header size when finished receiving header return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; } #endif if ((samples == 0) || !mEncoderWriteData) { // called by the encoder because there's header data to save, but it's not the role // of this component (unless WRITE_FLAC_HEADER_IN_FIRST_BUFFER is defined) ALOGV("ignoring %zu bytes of header data (samples=%d)", bytes, samples); return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; } List<BufferInfo *> &outQueue = getPortQueue(1); CHECK(!outQueue.empty()); BufferInfo *outInfo = *outQueue.begin(); OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; #ifdef WRITE_FLAC_HEADER_IN_FIRST_BUFFER if (!mWroteHeader) { ALOGI(" writing %d bytes of header on output port", mHeaderOffset); memcpy(outHeader->pBuffer + outHeader->nOffset + outHeader->nFilledLen, mHeader, mHeaderOffset); outHeader->nFilledLen += mHeaderOffset; outHeader->nOffset += mHeaderOffset; mWroteHeader = true; } #endif // write encoded data ALOGV(" writing %zu bytes of encoded data on output port", bytes); if (bytes > outHeader->nAllocLen - outHeader->nOffset - outHeader->nFilledLen) { ALOGE(" not enough space left to write encoded data, dropping %zu bytes", bytes); // a fatal error would stop the encoding return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; } memcpy(outHeader->pBuffer + outHeader->nOffset, buffer, bytes); outHeader->nTimeStamp = mCurrentInputTimeStamp; outHeader->nOffset = 0; outHeader->nFilledLen += bytes; outHeader->nFlags = 0; mEncoderReturnedEncodedData = true; mEncoderReturnedNbBytes += bytes; return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; }
void CameraSourceListener::notify(int32_t msgType, int32_t ext1, int32_t ext2) { UNUSED_UNLESS_VERBOSE(msgType); UNUSED_UNLESS_VERBOSE(ext1); UNUSED_UNLESS_VERBOSE(ext2); ALOGV("notify(%d, %d, %d)", msgType, ext1, ext2); }
void SoftFlacEncoder::onQueueFilled(OMX_U32 portIndex) { UNUSED_UNLESS_VERBOSE(portIndex); ALOGV("SoftFlacEncoder::onQueueFilled(portIndex=%d)", portIndex); if (mSignalledError) { return; } List<BufferInfo *> &inQueue = getPortQueue(0); List<BufferInfo *> &outQueue = getPortQueue(1); 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) { 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 (inHeader->nFilledLen > kMaxInputBufferSize) { ALOGE("input buffer too large (%d).", inHeader->nFilledLen); mSignalledError = true; notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); return; } assert(mNumChannels != 0); mEncoderWriteData = true; mEncoderReturnedEncodedData = false; mEncoderReturnedNbBytes = 0; mCurrentInputTimeStamp = inHeader->nTimeStamp; const unsigned nbInputFrames = inHeader->nFilledLen / (2 * mNumChannels); const unsigned nbInputSamples = inHeader->nFilledLen / 2; const OMX_S16 * const pcm16 = reinterpret_cast<OMX_S16 *>(inHeader->pBuffer); CHECK_LE(nbInputSamples, 2 * kMaxNumSamplesPerFrame); for (unsigned i=0 ; i < nbInputSamples ; i++) { mInputBufferPcm32[i] = (FLAC__int32) pcm16[i]; } ALOGV(" about to encode %u samples per channel", nbInputFrames); FLAC__bool ok = FLAC__stream_encoder_process_interleaved( mFlacStreamEncoder, mInputBufferPcm32, nbInputFrames /*samples per channel*/ ); if (ok) { if (mEncoderReturnedEncodedData && (mEncoderReturnedNbBytes != 0)) { ALOGV(" dequeueing buffer on output port after writing data"); outInfo->mOwnedByUs = false; outQueue.erase(outQueue.begin()); outInfo = NULL; notifyFillBufferDone(outHeader); outHeader = NULL; mEncoderReturnedEncodedData = false; } else { ALOGV(" encoder process_interleaved returned without data to write"); } } else { ALOGE(" error encountered during encoding"); mSignalledError = true; notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); return; } inInfo->mOwnedByUs = false; inQueue.erase(inQueue.begin()); inInfo = NULL; notifyEmptyBufferDone(inHeader); inHeader = NULL; } }