chromium/third_party/mediapipe/src/mediapipe/framework/input_stream_handler.cc

// Copyright 2019 The MediaPipe Authors.
//
// 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 "mediapipe/framework/input_stream_handler.h"

#include "absl/log/absl_check.h"
#include "absl/strings/str_join.h"
#include "absl/strings/substitute.h"
#include "mediapipe/framework/collection_item_id.h"
#include "mediapipe/framework/mediapipe_profiling.h"
#include "mediapipe/framework/port/ret_check.h"

namespace mediapipe {
SyncSet;

absl::Status InputStreamHandler::InitializeInputStreamManagers(
    InputStreamManager* flat_input_stream_managers) { … }

InputStreamManager* InputStreamHandler::GetInputStreamManager(
    CollectionItemId id) { … }

absl::Status InputStreamHandler::SetupInputShards(
    InputStreamShardSet* input_shards) { … }

std::vector<std::tuple<std::string, int, int, Timestamp>>
InputStreamHandler::GetMonitoringInfo() { … }

void InputStreamHandler::PrepareForRun(
    std::function<void()> headers_ready_callback,
    std::function<void()> notification_callback,
    std::function<void(CalculatorContext*)> schedule_callback,
    std::function<void(absl::Status)> error_callback) { … }

void InputStreamHandler::SetQueueSizeCallbacks(
    InputStreamManager::QueueSizeCallback becomes_full_callback,
    InputStreamManager::QueueSizeCallback becomes_not_full_callback) { … }

void InputStreamHandler::SetHeader(CollectionItemId id, const Packet& header) { … }

void InputStreamHandler::UpdateInputShardHeaders(
    InputStreamShardSet* input_shards) { … }

void InputStreamHandler::SetMaxQueueSize(CollectionItemId id,
                                         int max_queue_size) { … }

void InputStreamHandler::SetMaxQueueSize(int max_queue_size) { … }

std::string InputStreamHandler::DebugStreamNames() const { … }

bool InputStreamHandler::ScheduleInvocations(int max_allowance,
                                             Timestamp* input_bound) { … }

void InputStreamHandler::FinalizeInputSet(Timestamp timestamp,
                                          InputStreamShardSet* input_set) { … }

// Returns the default CalculatorContext.
CalculatorContext* GetCalculatorContext(CalculatorContextManager* manager) { … }

// Logs the current queue size of an input stream.
void LogQueuedPackets(CalculatorContext* context, InputStreamManager* stream,
                      Packet queue_tail) { … }

void InputStreamHandler::AddPackets(CollectionItemId id,
                                    const std::list<Packet>& packets) { … }

void InputStreamHandler::MovePackets(CollectionItemId id,
                                     std::list<Packet>* packets) { … }

void InputStreamHandler::SetNextTimestampBound(CollectionItemId id,
                                               Timestamp bound) { … }

void InputStreamHandler::ClearCurrentInputs(
    CalculatorContext* calculator_context) { … }

void InputStreamHandler::Close() { … }

void InputStreamHandler::SetBatchSize(int batch_size) { … }

void InputStreamHandler::SetLatePreparation(bool late_preparation) { … }

SyncSet::SyncSet(InputStreamHandler* input_stream_handler,
                 std::vector<CollectionItemId> stream_ids)
    : … { … }

void SyncSet::PrepareForRun() { … }

NodeReadiness SyncSet::GetReadiness(Timestamp* min_stream_timestamp) { … }

Timestamp SyncSet::LastProcessed() const { … }

Timestamp SyncSet::MinPacketTimestamp() const { … }

void SyncSet::FillInputSet(Timestamp input_timestamp,
                           InputStreamShardSet* input_set) { … }

void SyncSet::FillInputBounds(InputStreamShardSet* input_set) { … }

}  // namespace mediapipe