131 lines
4.5 KiB
C++
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
|