| /* |
| * Copyright 2018 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. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "C2SoftVpxEnc" |
| #include <log/log.h> |
| #include <utils/misc.h> |
| |
| #include <media/hardware/VideoAPI.h> |
| |
| #include <Codec2BufferUtils.h> |
| #include <C2Debug.h> |
| #include "C2SoftVpxEnc.h" |
| |
| #ifndef INT32_MAX |
| #define INT32_MAX 2147483647 |
| #endif |
| |
| namespace android { |
| |
| #if 0 |
| static size_t getCpuCoreCount() { |
| long cpuCoreCount = 1; |
| #if defined(_SC_NPROCESSORS_ONLN) |
| cpuCoreCount = sysconf(_SC_NPROCESSORS_ONLN); |
| #else |
| // _SC_NPROC_ONLN must be defined... |
| cpuCoreCount = sysconf(_SC_NPROC_ONLN); |
| #endif |
| CHECK(cpuCoreCount >= 1); |
| ALOGV("Number of CPU cores: %ld", cpuCoreCount); |
| return (size_t)cpuCoreCount; |
| } |
| #endif |
| |
| C2SoftVpxEnc::C2SoftVpxEnc(const char* name, c2_node_id_t id, |
| const std::shared_ptr<IntfImpl>& intfImpl) |
| : SimpleC2Component( |
| std::make_shared<SimpleInterface<IntfImpl>>(name, id, intfImpl)), |
| mIntf(intfImpl), |
| mCodecContext(nullptr), |
| mCodecConfiguration(nullptr), |
| mCodecInterface(nullptr), |
| mStrideAlign(2), |
| mColorFormat(VPX_IMG_FMT_I420), |
| mBitrateControlMode(VPX_VBR), |
| mErrorResilience(false), |
| mMinQuantizer(0), |
| mMaxQuantizer(0), |
| mTemporalLayers(0), |
| mTemporalPatternType(VPXTemporalLayerPatternNone), |
| mTemporalPatternLength(0), |
| mTemporalPatternIdx(0), |
| mLastTimestamp(0x7FFFFFFFFFFFFFFFull), |
| mSignalledOutputEos(false), |
| mSignalledError(false) { |
| memset(mTemporalLayerBitrateRatio, 0, sizeof(mTemporalLayerBitrateRatio)); |
| mTemporalLayerBitrateRatio[0] = 100; |
| } |
| |
| C2SoftVpxEnc::~C2SoftVpxEnc() { |
| onRelease(); |
| } |
| |
| c2_status_t C2SoftVpxEnc::onInit() { |
| status_t err = initEncoder(); |
| return err == OK ? C2_OK : C2_CORRUPTED; |
| } |
| |
| void C2SoftVpxEnc::onRelease() { |
| if (mCodecContext) { |
| vpx_codec_destroy(mCodecContext); |
| delete mCodecContext; |
| mCodecContext = nullptr; |
| } |
| |
| if (mCodecConfiguration) { |
| delete mCodecConfiguration; |
| mCodecConfiguration = nullptr; |
| } |
| |
| // this one is not allocated by us |
| mCodecInterface = nullptr; |
| } |
| |
| c2_status_t C2SoftVpxEnc::onStop() { |
| onRelease(); |
| mLastTimestamp = 0x7FFFFFFFFFFFFFFFLL; |
| mSignalledOutputEos = false; |
| mSignalledError = false; |
| return C2_OK; |
| } |
| |
| void C2SoftVpxEnc::onReset() { |
| (void)onStop(); |
| } |
| |
| c2_status_t C2SoftVpxEnc::onFlush_sm() { |
| return onStop(); |
| } |
| |
| status_t C2SoftVpxEnc::initEncoder() { |
| vpx_codec_err_t codec_return; |
| status_t result = UNKNOWN_ERROR; |
| { |
| IntfImpl::Lock lock = mIntf->lock(); |
| mSize = mIntf->getSize_l(); |
| mBitrate = mIntf->getBitrate_l(); |
| mBitrateMode = mIntf->getBitrateMode_l(); |
| mFrameRate = mIntf->getFrameRate_l(); |
| mIntraRefresh = mIntf->getIntraRefresh_l(); |
| mRequestSync = mIntf->getRequestSync_l(); |
| mTemporalLayers = mIntf->getTemporalLayers_l()->m.layerCount; |
| } |
| |
| switch (mBitrateMode->value) { |
| case C2Config::BITRATE_CONST: |
| mBitrateControlMode = VPX_CBR; |
| break; |
| case C2Config::BITRATE_VARIABLE: |
| [[fallthrough]]; |
| default: |
| mBitrateControlMode = VPX_VBR; |
| break; |
| } |
| |
| setCodecSpecificInterface(); |
| if (!mCodecInterface) goto CleanUp; |
| |
| ALOGD("VPx: initEncoder. BRMode: %u. TSLayers: %zu. KF: %u. QP: %u - %u", |
| (uint32_t)mBitrateControlMode, mTemporalLayers, mIntf->getSyncFramePeriod(), |
| mMinQuantizer, mMaxQuantizer); |
| |
| mCodecConfiguration = new vpx_codec_enc_cfg_t; |
| if (!mCodecConfiguration) goto CleanUp; |
| codec_return = vpx_codec_enc_config_default(mCodecInterface, |
| mCodecConfiguration, |
| 0); |
| if (codec_return != VPX_CODEC_OK) { |
| ALOGE("Error populating default configuration for vpx encoder."); |
| goto CleanUp; |
| } |
| |
| mCodecConfiguration->g_w = mSize->width; |
| mCodecConfiguration->g_h = mSize->height; |
| //mCodecConfiguration->g_threads = getCpuCoreCount(); |
| mCodecConfiguration->g_threads = 0; |
| mCodecConfiguration->g_error_resilient = mErrorResilience; |
| |
| // timebase unit is microsecond |
| // g_timebase is in seconds (i.e. 1/1000000 seconds) |
| mCodecConfiguration->g_timebase.num = 1; |
| mCodecConfiguration->g_timebase.den = 1000000; |
| // rc_target_bitrate is in kbps, mBitrate in bps |
| mCodecConfiguration->rc_target_bitrate = (mBitrate->value + 500) / 1000; |
| mCodecConfiguration->rc_end_usage = mBitrateControlMode; |
| // Disable frame drop - not allowed in MediaCodec now. |
| mCodecConfiguration->rc_dropframe_thresh = 0; |
| // Disable lagged encoding. |
| mCodecConfiguration->g_lag_in_frames = 0; |
| if (mBitrateControlMode == VPX_CBR) { |
| // Disable spatial resizing. |
| mCodecConfiguration->rc_resize_allowed = 0; |
| // Single-pass mode. |
| mCodecConfiguration->g_pass = VPX_RC_ONE_PASS; |
| // Maximum amount of bits that can be subtracted from the target |
| // bitrate - expressed as percentage of the target bitrate. |
| mCodecConfiguration->rc_undershoot_pct = 100; |
| // Maximum amount of bits that can be added to the target |
| // bitrate - expressed as percentage of the target bitrate. |
| mCodecConfiguration->rc_overshoot_pct = 15; |
| // Initial value of the buffer level in ms. |
| mCodecConfiguration->rc_buf_initial_sz = 500; |
| // Amount of data that the encoder should try to maintain in ms. |
| mCodecConfiguration->rc_buf_optimal_sz = 600; |
| // The amount of data that may be buffered by the decoding |
| // application in ms. |
| mCodecConfiguration->rc_buf_sz = 1000; |
| // Enable error resilience - needed for packet loss. |
| mCodecConfiguration->g_error_resilient = 1; |
| // Maximum key frame interval - for CBR boost to 3000 |
| mCodecConfiguration->kf_max_dist = 3000; |
| // Encoder determines optimal key frame placement automatically. |
| mCodecConfiguration->kf_mode = VPX_KF_AUTO; |
| } |
| |
| // Frames temporal pattern - for now WebRTC like pattern is only supported. |
| switch (mTemporalLayers) { |
| case 0: |
| mTemporalPatternLength = 0; |
| break; |
| case 1: |
| mCodecConfiguration->ts_number_layers = 1; |
| mCodecConfiguration->ts_rate_decimator[0] = 1; |
| mCodecConfiguration->ts_periodicity = 1; |
| mCodecConfiguration->ts_layer_id[0] = 0; |
| mTemporalPattern[0] = kTemporalUpdateLastRefAll; |
| mTemporalPatternLength = 1; |
| break; |
| case 2: |
| mCodecConfiguration->ts_number_layers = 2; |
| mCodecConfiguration->ts_rate_decimator[0] = 2; |
| mCodecConfiguration->ts_rate_decimator[1] = 1; |
| mCodecConfiguration->ts_periodicity = 2; |
| mCodecConfiguration->ts_layer_id[0] = 0; |
| mCodecConfiguration->ts_layer_id[1] = 1; |
| mTemporalPattern[0] = kTemporalUpdateLastAndGoldenRefAltRef; |
| mTemporalPattern[1] = kTemporalUpdateGoldenWithoutDependencyRefAltRef; |
| mTemporalPattern[2] = kTemporalUpdateLastRefAltRef; |
| mTemporalPattern[3] = kTemporalUpdateGoldenRefAltRef; |
| mTemporalPattern[4] = kTemporalUpdateLastRefAltRef; |
| mTemporalPattern[5] = kTemporalUpdateGoldenRefAltRef; |
| mTemporalPattern[6] = kTemporalUpdateLastRefAltRef; |
| mTemporalPattern[7] = kTemporalUpdateNone; |
| mTemporalPatternLength = 8; |
| break; |
| case 3: |
| mCodecConfiguration->ts_number_layers = 3; |
| mCodecConfiguration->ts_rate_decimator[0] = 4; |
| mCodecConfiguration->ts_rate_decimator[1] = 2; |
| mCodecConfiguration->ts_rate_decimator[2] = 1; |
| mCodecConfiguration->ts_periodicity = 4; |
| mCodecConfiguration->ts_layer_id[0] = 0; |
| mCodecConfiguration->ts_layer_id[1] = 2; |
| mCodecConfiguration->ts_layer_id[2] = 1; |
| mCodecConfiguration->ts_layer_id[3] = 2; |
| mTemporalPattern[0] = kTemporalUpdateLastAndGoldenRefAltRef; |
| mTemporalPattern[1] = kTemporalUpdateNoneNoRefGoldenRefAltRef; |
| mTemporalPattern[2] = kTemporalUpdateGoldenWithoutDependencyRefAltRef; |
| mTemporalPattern[3] = kTemporalUpdateNone; |
| mTemporalPattern[4] = kTemporalUpdateLastRefAltRef; |
| mTemporalPattern[5] = kTemporalUpdateNone; |
| mTemporalPattern[6] = kTemporalUpdateGoldenRefAltRef; |
| mTemporalPattern[7] = kTemporalUpdateNone; |
| mTemporalPatternLength = 8; |
| break; |
| default: |
| ALOGE("Wrong number of temporal layers %zu", mTemporalLayers); |
| goto CleanUp; |
| } |
| // Set bitrate values for each layer |
| for (size_t i = 0; i < mCodecConfiguration->ts_number_layers; i++) { |
| mCodecConfiguration->ts_target_bitrate[i] = |
| mCodecConfiguration->rc_target_bitrate * |
| mTemporalLayerBitrateRatio[i] / 100; |
| } |
| if (mIntf->getSyncFramePeriod() >= 0) { |
| mCodecConfiguration->kf_max_dist = mIntf->getSyncFramePeriod(); |
| mCodecConfiguration->kf_min_dist = mIntf->getSyncFramePeriod(); |
| mCodecConfiguration->kf_mode = VPX_KF_AUTO; |
| } |
| if (mMinQuantizer > 0) { |
| mCodecConfiguration->rc_min_quantizer = mMinQuantizer; |
| } |
| if (mMaxQuantizer > 0) { |
| mCodecConfiguration->rc_max_quantizer = mMaxQuantizer; |
| } |
| setCodecSpecificConfiguration(); |
| mCodecContext = new vpx_codec_ctx_t; |
| if (!mCodecContext) goto CleanUp; |
| codec_return = vpx_codec_enc_init(mCodecContext, |
| mCodecInterface, |
| mCodecConfiguration, |
| 0); // flags |
| if (codec_return != VPX_CODEC_OK) { |
| ALOGE("Error initializing vpx encoder"); |
| goto CleanUp; |
| } |
| |
| // Extra CBR settings |
| if (mBitrateControlMode == VPX_CBR) { |
| codec_return = vpx_codec_control(mCodecContext, |
| VP8E_SET_STATIC_THRESHOLD, |
| 1); |
| if (codec_return == VPX_CODEC_OK) { |
| uint32_t rc_max_intra_target = |
| (uint32_t)(mCodecConfiguration->rc_buf_optimal_sz * mFrameRate->value / 20 + 0.5); |
| // Don't go below 3 times per frame bandwidth. |
| if (rc_max_intra_target < 300) { |
| rc_max_intra_target = 300; |
| } |
| codec_return = vpx_codec_control(mCodecContext, |
| VP8E_SET_MAX_INTRA_BITRATE_PCT, |
| rc_max_intra_target); |
| } |
| if (codec_return == VPX_CODEC_OK) { |
| codec_return = vpx_codec_control(mCodecContext, |
| VP8E_SET_CPUUSED, |
| -8); |
| } |
| if (codec_return != VPX_CODEC_OK) { |
| ALOGE("Error setting cbr parameters for vpx encoder."); |
| goto CleanUp; |
| } |
| } |
| |
| codec_return = setCodecSpecificControls(); |
| if (codec_return != VPX_CODEC_OK) goto CleanUp; |
| |
| { |
| uint32_t width = mSize->width; |
| uint32_t height = mSize->height; |
| if (((uint64_t)width * height) > |
| ((uint64_t)INT32_MAX / 3)) { |
| ALOGE("b/25812794, Buffer size is too big, width=%u, height=%u.", width, height); |
| } else { |
| uint32_t stride = (width + mStrideAlign - 1) & ~(mStrideAlign - 1); |
| uint32_t vstride = (height + mStrideAlign - 1) & ~(mStrideAlign - 1); |
| mConversionBuffer = MemoryBlock::Allocate(stride * vstride * 3 / 2); |
| if (!mConversionBuffer.size()) { |
| ALOGE("Allocating conversion buffer failed."); |
| } else { |
| mNumInputFrames = -1; |
| return OK; |
| } |
| } |
| } |
| |
| CleanUp: |
| onRelease(); |
| return result; |
| } |
| |
| vpx_enc_frame_flags_t C2SoftVpxEnc::getEncodeFlags() { |
| vpx_enc_frame_flags_t flags = 0; |
| if (mTemporalPatternLength > 0) { |
| int patternIdx = mTemporalPatternIdx % mTemporalPatternLength; |
| mTemporalPatternIdx++; |
| switch (mTemporalPattern[patternIdx]) { |
| case kTemporalUpdateLast: |
| flags |= VP8_EFLAG_NO_UPD_GF; |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_REF_GF; |
| flags |= VP8_EFLAG_NO_REF_ARF; |
| break; |
| case kTemporalUpdateGoldenWithoutDependency: |
| flags |= VP8_EFLAG_NO_REF_GF; |
| [[fallthrough]]; |
| case kTemporalUpdateGolden: |
| flags |= VP8_EFLAG_NO_REF_ARF; |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_UPD_LAST; |
| break; |
| case kTemporalUpdateAltrefWithoutDependency: |
| flags |= VP8_EFLAG_NO_REF_ARF; |
| flags |= VP8_EFLAG_NO_REF_GF; |
| [[fallthrough]]; |
| case kTemporalUpdateAltref: |
| flags |= VP8_EFLAG_NO_UPD_GF; |
| flags |= VP8_EFLAG_NO_UPD_LAST; |
| break; |
| case kTemporalUpdateNoneNoRefAltref: |
| flags |= VP8_EFLAG_NO_REF_ARF; |
| [[fallthrough]]; |
| case kTemporalUpdateNone: |
| flags |= VP8_EFLAG_NO_UPD_GF; |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_UPD_LAST; |
| flags |= VP8_EFLAG_NO_UPD_ENTROPY; |
| break; |
| case kTemporalUpdateNoneNoRefGoldenRefAltRef: |
| flags |= VP8_EFLAG_NO_REF_GF; |
| flags |= VP8_EFLAG_NO_UPD_GF; |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_UPD_LAST; |
| flags |= VP8_EFLAG_NO_UPD_ENTROPY; |
| break; |
| case kTemporalUpdateGoldenWithoutDependencyRefAltRef: |
| flags |= VP8_EFLAG_NO_REF_GF; |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_UPD_LAST; |
| break; |
| case kTemporalUpdateLastRefAltRef: |
| flags |= VP8_EFLAG_NO_UPD_GF; |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_REF_GF; |
| break; |
| case kTemporalUpdateGoldenRefAltRef: |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_UPD_LAST; |
| break; |
| case kTemporalUpdateLastAndGoldenRefAltRef: |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_REF_GF; |
| break; |
| case kTemporalUpdateLastRefAll: |
| flags |= VP8_EFLAG_NO_UPD_ARF; |
| flags |= VP8_EFLAG_NO_UPD_GF; |
| break; |
| } |
| } |
| return flags; |
| } |
| |
| // TODO: add support for YUV input color formats |
| // TODO: add support for SVC, ARF. SVC and ARF returns multiple frames |
| // (hierarchical / noshow) in one call. These frames should be combined in to |
| // a single buffer and sent back to the client |
| void C2SoftVpxEnc::process( |
| const std::unique_ptr<C2Work> &work, |
| const std::shared_ptr<C2BlockPool> &pool) { |
| // Initialize output work |
| work->result = C2_OK; |
| work->workletsProcessed = 1u; |
| work->worklets.front()->output.flags = work->input.flags; |
| |
| if (mSignalledError || mSignalledOutputEos) { |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| // Initialize encoder if not already |
| if (!mCodecContext && OK != initEncoder()) { |
| ALOGE("Failed to initialize encoder"); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| |
| std::shared_ptr<const C2GraphicView> rView; |
| std::shared_ptr<C2Buffer> inputBuffer; |
| if (!work->input.buffers.empty()) { |
| inputBuffer = work->input.buffers[0]; |
| rView = std::make_shared<const C2GraphicView>( |
| inputBuffer->data().graphicBlocks().front().map().get()); |
| if (rView->error() != C2_OK) { |
| ALOGE("graphic view map err = %d", rView->error()); |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| } else { |
| ALOGV("Empty input Buffer"); |
| uint32_t flags = 0; |
| if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) { |
| flags |= C2FrameData::FLAG_END_OF_STREAM; |
| } |
| work->worklets.front()->output.flags = (C2FrameData::flags_t)flags; |
| work->worklets.front()->output.buffers.clear(); |
| work->worklets.front()->output.ordinal = work->input.ordinal; |
| work->workletsProcessed = 1u; |
| return; |
| } |
| |
| const C2ConstGraphicBlock inBuffer = |
| inputBuffer->data().graphicBlocks().front(); |
| if (inBuffer.width() != mSize->width || |
| inBuffer.height() != mSize->height) { |
| ALOGE("unexpected Input buffer attributes %d(%d) x %d(%d)", |
| inBuffer.width(), mSize->width, inBuffer.height(), |
| mSize->height); |
| mSignalledError = true; |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0); |
| vpx_image_t raw_frame; |
| const C2PlanarLayout &layout = rView->layout(); |
| uint32_t width = rView->width(); |
| uint32_t height = rView->height(); |
| if (width > 0x8000 || height > 0x8000) { |
| ALOGE("Image too big: %u x %u", width, height); |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| uint32_t stride = (width + mStrideAlign - 1) & ~(mStrideAlign - 1); |
| uint32_t vstride = (height + mStrideAlign - 1) & ~(mStrideAlign - 1); |
| switch (layout.type) { |
| case C2PlanarLayout::TYPE_RGB: |
| case C2PlanarLayout::TYPE_RGBA: { |
| ConvertRGBToPlanarYUV(mConversionBuffer.data(), stride, vstride, |
| mConversionBuffer.size(), *rView.get()); |
| vpx_img_wrap(&raw_frame, VPX_IMG_FMT_I420, width, height, |
| mStrideAlign, mConversionBuffer.data()); |
| break; |
| } |
| case C2PlanarLayout::TYPE_YUV: { |
| if (!IsYUV420(*rView)) { |
| ALOGE("input is not YUV420"); |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| |
| if (layout.planes[layout.PLANE_Y].colInc == 1 |
| && layout.planes[layout.PLANE_U].colInc == 1 |
| && layout.planes[layout.PLANE_V].colInc == 1) { |
| // I420 compatible - though with custom offset and stride |
| vpx_img_wrap(&raw_frame, VPX_IMG_FMT_I420, width, height, |
| mStrideAlign, (uint8_t*)rView->data()[0]); |
| raw_frame.planes[1] = (uint8_t*)rView->data()[1]; |
| raw_frame.planes[2] = (uint8_t*)rView->data()[2]; |
| raw_frame.stride[0] = layout.planes[layout.PLANE_Y].rowInc; |
| raw_frame.stride[1] = layout.planes[layout.PLANE_U].rowInc; |
| raw_frame.stride[2] = layout.planes[layout.PLANE_V].rowInc; |
| } else { |
| // copy to I420 |
| MediaImage2 img = CreateYUV420PlanarMediaImage2(width, height, stride, vstride); |
| if (mConversionBuffer.size() >= stride * vstride * 3 / 2) { |
| status_t err = ImageCopy(mConversionBuffer.data(), &img, *rView); |
| if (err != OK) { |
| ALOGE("Buffer conversion failed: %d", err); |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| vpx_img_wrap(&raw_frame, VPX_IMG_FMT_I420, stride, vstride, |
| mStrideAlign, (uint8_t*)rView->data()[0]); |
| vpx_img_set_rect(&raw_frame, 0, 0, width, height); |
| } else { |
| ALOGE("Conversion buffer is too small: %u x %u for %zu", |
| stride, vstride, mConversionBuffer.size()); |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| } |
| break; |
| } |
| default: |
| ALOGE("Unrecognized plane type: %d", layout.type); |
| work->result = C2_BAD_VALUE; |
| return; |
| } |
| |
| vpx_enc_frame_flags_t flags = getEncodeFlags(); |
| // handle dynamic config parameters |
| { |
| IntfImpl::Lock lock = mIntf->lock(); |
| std::shared_ptr<C2StreamIntraRefreshTuning::output> intraRefresh = mIntf->getIntraRefresh_l(); |
| std::shared_ptr<C2StreamBitrateInfo::output> bitrate = mIntf->getBitrate_l(); |
| std::shared_ptr<C2StreamRequestSyncFrameTuning::output> requestSync = mIntf->getRequestSync_l(); |
| lock.unlock(); |
| |
| if (intraRefresh != mIntraRefresh) { |
| mIntraRefresh = intraRefresh; |
| ALOGV("Got mIntraRefresh request"); |
| } |
| |
| if (requestSync != mRequestSync) { |
| // we can handle IDR immediately |
| if (requestSync->value) { |
| // unset request |
| C2StreamRequestSyncFrameTuning::output clearSync(0u, C2_FALSE); |
| std::vector<std::unique_ptr<C2SettingResult>> failures; |
| mIntf->config({ &clearSync }, C2_MAY_BLOCK, &failures); |
| ALOGV("Got sync request"); |
| flags |= VPX_EFLAG_FORCE_KF; |
| } |
| mRequestSync = requestSync; |
| } |
| |
| if (bitrate != mBitrate) { |
| mBitrate = bitrate; |
| mCodecConfiguration->rc_target_bitrate = |
| (mBitrate->value + 500) / 1000; |
| vpx_codec_err_t res = vpx_codec_enc_config_set(mCodecContext, |
| mCodecConfiguration); |
| if (res != VPX_CODEC_OK) { |
| ALOGE("vpx encoder failed to update bitrate: %s", |
| vpx_codec_err_to_string(res)); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| } |
| } |
| |
| uint64_t inputTimeStamp = work->input.ordinal.timestamp.peekull(); |
| uint32_t frameDuration; |
| if (inputTimeStamp > mLastTimestamp) { |
| frameDuration = (uint32_t)(inputTimeStamp - mLastTimestamp); |
| } else { |
| // Use default of 30 fps in case of 0 frame rate. |
| float frameRate = mFrameRate->value; |
| if (frameRate < 0.001) { |
| frameRate = 30; |
| } |
| frameDuration = (uint32_t)(1000000 / frameRate + 0.5); |
| } |
| mLastTimestamp = inputTimeStamp; |
| |
| vpx_codec_err_t codec_return = vpx_codec_encode(mCodecContext, &raw_frame, |
| inputTimeStamp, |
| frameDuration, flags, |
| VPX_DL_REALTIME); |
| if (codec_return != VPX_CODEC_OK) { |
| ALOGE("vpx encoder failed to encode frame"); |
| mSignalledError = true; |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| |
| bool populated = false; |
| vpx_codec_iter_t encoded_packet_iterator = nullptr; |
| const vpx_codec_cx_pkt_t* encoded_packet; |
| while ((encoded_packet = vpx_codec_get_cx_data( |
| mCodecContext, &encoded_packet_iterator))) { |
| if (encoded_packet->kind == VPX_CODEC_CX_FRAME_PKT) { |
| std::shared_ptr<C2LinearBlock> block; |
| C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE }; |
| c2_status_t err = pool->fetchLinearBlock(encoded_packet->data.frame.sz, usage, &block); |
| if (err != C2_OK) { |
| ALOGE("fetchLinearBlock for Output failed with status %d", err); |
| work->result = C2_NO_MEMORY; |
| return; |
| } |
| C2WriteView wView = block->map().get(); |
| if (wView.error()) { |
| ALOGE("write view map failed %d", wView.error()); |
| work->result = C2_CORRUPTED; |
| return; |
| } |
| |
| memcpy(wView.data(), encoded_packet->data.frame.buf, encoded_packet->data.frame.sz); |
| ++mNumInputFrames; |
| |
| ALOGD("bytes generated %zu", encoded_packet->data.frame.sz); |
| uint32_t flags = 0; |
| if (eos) { |
| flags |= C2FrameData::FLAG_END_OF_STREAM; |
| } |
| work->worklets.front()->output.flags = (C2FrameData::flags_t)flags; |
| work->worklets.front()->output.buffers.clear(); |
| std::shared_ptr<C2Buffer> buffer = createLinearBuffer(block); |
| if (encoded_packet->data.frame.flags & VPX_FRAME_IS_KEY) { |
| buffer->setInfo(std::make_shared<C2StreamPictureTypeMaskInfo::output>( |
| 0u /* stream id */, C2Config::SYNC_FRAME)); |
| } |
| work->worklets.front()->output.buffers.push_back(buffer); |
| work->worklets.front()->output.ordinal = work->input.ordinal; |
| work->worklets.front()->output.ordinal.timestamp = encoded_packet->data.frame.pts; |
| work->workletsProcessed = 1u; |
| populated = true; |
| if (eos) { |
| mSignalledOutputEos = true; |
| ALOGV("signalled EOS"); |
| } |
| } |
| } |
| if (!populated) { |
| work->workletsProcessed = 0u; |
| } |
| } |
| |
| c2_status_t C2SoftVpxEnc::drain( |
| uint32_t drainMode, |
| const std::shared_ptr<C2BlockPool> &pool) { |
| (void)pool; |
| if (drainMode == NO_DRAIN) { |
| ALOGW("drain with NO_DRAIN: no-op"); |
| return C2_OK; |
| } |
| if (drainMode == DRAIN_CHAIN) { |
| ALOGW("DRAIN_CHAIN not supported"); |
| return C2_OMITTED; |
| } |
| |
| return C2_OK; |
| } |
| |
| } // namespace android |
