android13/packages/services/Car/cpp/computepipe/runner/input_manager/VideoInputManager.cpp

131 lines
4.5 KiB
C++

// Copyright 2020 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.
#include <android-base/logging.h>
#include <fcntl.h>
#include <chrono>
#include "VideoInputManager.h"
namespace android {
namespace automotive {
namespace computepipe {
namespace runner {
namespace input_manager {
VideoInputManager::VideoInputManager(const proto::InputConfig& inputConfig,
const proto::InputConfig& /*overrideConfig*/,
std::shared_ptr<InputEngineInterface> inputEngineInterface) :
mEngine(inputEngineInterface),
mInputConfig(inputConfig) {}
VideoInputManager::~VideoInputManager() {}
std::unique_ptr<VideoInputManager> VideoInputManager::createVideoInputManager(
const proto::InputConfig& inputConfig, const proto::InputConfig& overrideConfig,
std::shared_ptr<InputEngineInterface> inputEngineInterface) {
return std::make_unique<VideoInputManager>(inputConfig, overrideConfig, inputEngineInterface);
}
Status VideoInputManager::handleExecutionPhase(const RunnerEvent& e) {
if (e.isTransitionComplete()) {
return Status::SUCCESS;
}
if (e.isPhaseEntry()) {
populateDecoders();
if (mVideoDecoders.empty() || mVideoDecoders.size() != mInputConfig.input_stream_size()) {
resetDecoders();
LOG(ERROR) << "Created " << mVideoDecoders.size() << " video decoders, while expecting "
<< mInputConfig.input_stream_size() << " video decoders.";
return Status::INTERNAL_ERROR;
}
Status status = startDecoders();
if (status != Status::SUCCESS) {
resetDecoders();
}
return status;
}
// e.isPhaseAborted();
resetDecoders();
return Status::SUCCESS;
}
Status VideoInputManager::handleStopImmediatePhase(const RunnerEvent& /*e*/) {
resetDecoders();
return Status::SUCCESS;
}
Status VideoInputManager::handleStopWithFlushPhase(const RunnerEvent& /*e*/) {
resetDecoders();
return Status::SUCCESS;
}
Status VideoInputManager::handleResetPhase(const RunnerEvent& /*e*/) {
resetDecoders();
return Status::SUCCESS;
}
void VideoInputManager::populateDecoders() {
for (const auto& config : mInputConfig.input_stream()) {
if (config.has_video_config() && config.video_config().has_file_path() &&
!config.video_config().file_path().empty()) {
mVideoDecoders.emplace_back(std::make_unique<VideoDecoder>(config, mEngine));
}
}
}
Status VideoInputManager::startDecoders() {
if (mVideoDecoders.empty()) {
return Status::INTERNAL_ERROR;
}
float decoder0Rate = mVideoDecoders[0]->getPlaybackFrameRate();
for (int i = 1; i < mVideoDecoders.size(); i++) {
float currentDecoderRate = mVideoDecoders[i]->getPlaybackFrameRate();
if (std::fabs(decoder0Rate - currentDecoderRate) > std::numeric_limits<float>::epsilon()) {
LOG(ERROR) << "Different playback frame rate between streams (0, " << i
<< "), frame rates - " << decoder0Rate << ", " << currentDecoderRate;
return Status::INTERNAL_ERROR;
}
}
auto timePoint = std::chrono::system_clock::now();
int64_t timestamp = std::chrono::time_point_cast<std::chrono::microseconds>(timePoint)
.time_since_epoch()
.count();
LOG(ERROR) << "Initial time is " << timestamp;
for (int i = 0; i < mVideoDecoders.size(); i++) {
mVideoDecoders[i]->setInitialTimestamp(timestamp);
Status status = mVideoDecoders[i]->startDecoding();
if (status != Status::SUCCESS) {
return status;
}
}
return Status::SUCCESS;
}
void VideoInputManager::resetDecoders() {
for (int i = 0; i < mVideoDecoders.size(); i++) {
mVideoDecoders[i]->stopDecoding();
}
mVideoDecoders.clear();
}
} // namespace input_manager
} // namespace runner
} // namespace computepipe
} // namespace automotive
} // namespace android