flatbuffer_to_proto.cc | Explore in Territory

/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.

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 "tensorflow/lite/acceleration/configuration/flatbuffer_to_proto.h"

#include "tensorflow/lite/acceleration/configuration/configuration.pb.h"
#include "tensorflow/lite/acceleration/configuration/configuration_generated.h"
#include "tensorflow/lite/minimal_logging.h"

namespace tflite {
namespace {
proto::ExecutionPreference ConvertExecutionPreference(
    ExecutionPreference preference) { … }

proto::Delegate ConvertDelegate(Delegate delegate) { … }

proto::NNAPIExecutionPreference ConvertNNAPIExecutionPreference(
    NNAPIExecutionPreference preference) { … }

proto::NNAPIExecutionPriority ConvertNNAPIExecutionPriority(
    NNAPIExecutionPriority priority) { … }

proto::GPUBackend ConvertGPUBackend(GPUBackend backend) { … }

proto::GPUInferenceUsage ConvertGPUInferenceUsage(
    GPUInferenceUsage preference) { … }

proto::GPUInferencePriority ConvertGPUInferencePriority(
    GPUInferencePriority priority) { … }

proto::EdgeTpuPowerState ConvertEdgeTpuPowerState(EdgeTpuPowerState state) { … }

proto::FallbackSettings ConvertFallbackSettings(
    const FallbackSettings& settings) { … }

proto::NNAPISettings ConvertNNAPISettings(const NNAPISettings& settings) { … }

proto::GPUSettings ConvertGPUSettings(const GPUSettings& settings) { … }

proto::HexagonSettings ConvertHexagonSettings(const HexagonSettings& settings) { … }

proto::XNNPackSettings ConvertXNNPackSettings(const XNNPackSettings& settings) { … }

proto::CoreMLSettings ConvertCoreMLSettings(const CoreMLSettings& settings) { … }

proto::CPUSettings ConvertCPUSettings(const CPUSettings& settings) { … }

proto::EdgeTpuDeviceSpec ConvertEdgeTpuDeviceSpec(
    const EdgeTpuDeviceSpec& device_spec) { … }

proto::EdgeTpuSettings ConvertEdgeTpuSettings(const EdgeTpuSettings& settings) { … }

proto::StableDelegateLoaderSettings ConvertStableDelegateLoaderSettings(
    const StableDelegateLoaderSettings& settings) { … }

proto::CoralSettings ConvertCoralSettings(const CoralSettings& settings) { … }

proto::GoogleEdgeTpuSettings::Priority ConvertGoogleEdgeTpuPriority(
    GoogleEdgeTpuSettings_::Priority priority) { … }

proto::GoogleEdgeTpuSettings::TriState ConvertGoogleEdgeTpuTriState(
    GoogleEdgeTpuSettings_::TriState tri_state) { … }

proto::GoogleEdgeTpuSettings ConvertGoogleEdgetpuSettings(
    const GoogleEdgeTpuSettings& settings) { … }

proto::CompilationCachingSettings ConvertCompilationCachingSettings(
    const CompilationCachingSettings& settings) { … }

proto::MtkNeuronSettings ConvertMtkNeuronSettings(
    const MtkNeuronSettings& settings) { … }

proto::TFLiteSettings ConvertTfliteSettings(const TFLiteSettings& settings) { … }

proto::ModelFile ConvertModelFile(const ModelFile& model_file) { … }

proto::BenchmarkStoragePaths ConvertBenchmarkStoragePaths(
    const BenchmarkStoragePaths& storage_paths) { … }

proto::MinibenchmarkSettings ConvertMinibenchmarkSettings(
    const MinibenchmarkSettings& settings) { … }

proto::BenchmarkEventType ConvertBenchmarkEventType(BenchmarkEventType type) { … }

proto::BenchmarkMetric ConvertBenchmarkMetric(const BenchmarkMetric& metric) { … }

proto::BenchmarkResult ConvertBenchmarkResult(const BenchmarkResult& result) { … }

proto::BenchmarkStage ConvertBenchmarkStage(BenchmarkStage stage) { … }

proto::ErrorCode ConvertBenchmarkErrorCode(const ErrorCode& code) { … }

proto::BenchmarkError ConvertBenchmarkError(const BenchmarkError& error) { … }

proto::BenchmarkEvent ConvertBenchmarkEvent(const BenchmarkEvent& event) { … }

proto::BestAccelerationDecision ConvertBestAccelerationDecision(
    const BestAccelerationDecision& decision) { … }

proto::BenchmarkInitializationFailure ConvertBenchmarkInitializationFailure(
    const BenchmarkInitializationFailure& init_failure) { … }

}  // namespace

proto::ComputeSettings ConvertFromFlatbuffer(
    const ComputeSettings& settings, bool skip_mini_benchmark_settings) { … }

proto::ComputeSettings ConvertFromFlatbuffer(
    const ComputeSettingsT& settings, bool skip_mini_benchmark_settings) { … }

proto::MiniBenchmarkEvent ConvertFromFlatbuffer(
    const MiniBenchmarkEvent& event) { … }

proto::MiniBenchmarkEvent ConvertFromFlatbuffer(
    const MiniBenchmarkEventT& event) { … }
}  // namespace tflite
chromium/third_party/tflite/src/tensorflow/lite/acceleration/configuration/flatbuffer_to_proto.cc
