stats.cc

Go to the documentation of this file.

// Copyright 2020 Google LLC
//
// 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
//
//     https://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.
//
// AUTO-GENERATED: DO NOT EDIT

#include "shaka/stats.h"

#include "src/js/stats.h"

namespace shaka {

class TrackChoice::Impl {
 public:
  const double timestamp{};
  const double id{};
  const std::string type{};
  const bool fromAdaptation{};
  const shaka::optional<double> bandwidth{};

  Impl() {}
  Impl(js::TrackChoice&& internal)
    : timestamp(std::move(internal.timestamp)),
      id(std::move(internal.id)),
      type(std::move(internal.type)),
      fromAdaptation(std::move(internal.fromAdaptation)),
      bandwidth(std::move(internal.bandwidth)) {}
};

TrackChoice::TrackChoice() : impl_(new Impl) {}
TrackChoice::TrackChoice(js::TrackChoice&& internal) : impl_(new Impl{std::move(internal)}) {}
TrackChoice::TrackChoice(const TrackChoice&) = default;
TrackChoice::TrackChoice(TrackChoice&&) = default;
TrackChoice::~TrackChoice() {}

TrackChoice& TrackChoice::operator=(const TrackChoice&) = default;
TrackChoice& TrackChoice::operator=(TrackChoice&&) = default;

double TrackChoice::timestamp() const {
  return impl_->timestamp;
}

double TrackChoice::id() const {
  return impl_->id;
}

const std::string& TrackChoice::type() const {
  return impl_->type;
}

bool TrackChoice::from_adaptation() const {
  return impl_->fromAdaptation;
}

shaka::optional<double> TrackChoice::bandwidth() const {
  return impl_->bandwidth;
}


js::TrackChoice TrackChoice::GetInternal() const {
  js::TrackChoice ret;
  ret.timestamp = impl_->timestamp;
  ret.id = impl_->id;
  ret.type = impl_->type;
  ret.fromAdaptation = impl_->fromAdaptation;
  ret.bandwidth = impl_->bandwidth;
  return ret;
}


class StateChange::Impl {
 public:
  const double timestamp{};
  const std::string state{};
  const double duration{};

  Impl() {}
  Impl(js::StateChange&& internal)
    : timestamp(std::move(internal.timestamp)),
      state(std::move(internal.state)),
      duration(std::move(internal.duration)) {}
};

StateChange::StateChange() : impl_(new Impl) {}
StateChange::StateChange(js::StateChange&& internal) : impl_(new Impl{std::move(internal)}) {}
StateChange::StateChange(const StateChange&) = default;
StateChange::StateChange(StateChange&&) = default;
StateChange::~StateChange() {}

StateChange& StateChange::operator=(const StateChange&) = default;
StateChange& StateChange::operator=(StateChange&&) = default;

double StateChange::timestamp() const {
  return impl_->timestamp;
}

const std::string& StateChange::state() const {
  return impl_->state;
}

double StateChange::duration() const {
  return impl_->duration;
}


js::StateChange StateChange::GetInternal() const {
  js::StateChange ret;
  ret.timestamp = impl_->timestamp;
  ret.state = impl_->state;
  ret.duration = impl_->duration;
  return ret;
}


class Stats::Impl {
 public:
  const double width{};
  const double height{};
  const double streamBandwidth{};
  const double decodedFrames{};
  const double droppedFrames{};
  const double estimatedBandwidth{};
  const double loadLatency{};
  const double playTime{};
  const double bufferingTime{};
  const std::vector<shaka::TrackChoice> switchHistory{};
  const std::vector<shaka::StateChange> stateHistory{};

  Impl() {}
  Impl(js::Stats&& internal)
    : width(std::move(internal.width)),
      height(std::move(internal.height)),
      streamBandwidth(std::move(internal.streamBandwidth)),
      decodedFrames(std::move(internal.decodedFrames)),
      droppedFrames(std::move(internal.droppedFrames)),
      estimatedBandwidth(std::move(internal.estimatedBandwidth)),
      loadLatency(std::move(internal.loadLatency)),
      playTime(std::move(internal.playTime)),
      bufferingTime(std::move(internal.bufferingTime)),
      switchHistory(std::make_move_iterator(internal.switchHistory.begin()), std::make_move_iterator(internal.switchHistory.end())),
      stateHistory(std::make_move_iterator(internal.stateHistory.begin()), std::make_move_iterator(internal.stateHistory.end())) {}
};

Stats::Stats() : impl_(new Impl) {}
Stats::Stats(js::Stats&& internal) : impl_(new Impl{std::move(internal)}) {}
Stats::Stats(const Stats&) = default;
Stats::Stats(Stats&&) = default;
Stats::~Stats() {}

Stats& Stats::operator=(const Stats&) = default;
Stats& Stats::operator=(Stats&&) = default;

double Stats::width() const {
  return impl_->width;
}

double Stats::height() const {
  return impl_->height;
}

double Stats::stream_bandwidth() const {
  return impl_->streamBandwidth;
}

double Stats::decoded_frames() const {
  return impl_->decodedFrames;
}

double Stats::dropped_frames() const {
  return impl_->droppedFrames;
}

double Stats::estimated_bandwidth() const {
  return impl_->estimatedBandwidth;
}

double Stats::load_latency() const {
  return impl_->loadLatency;
}

double Stats::play_time() const {
  return impl_->playTime;
}

double Stats::buffering_time() const {
  return impl_->bufferingTime;
}

const std::vector<shaka::TrackChoice>& Stats::switch_history() const {
  return impl_->switchHistory;
}

const std::vector<shaka::StateChange>& Stats::state_history() const {
  return impl_->stateHistory;
}


js::Stats Stats::GetInternal() const {
  js::Stats ret;
  ret.width = impl_->width;
  ret.height = impl_->height;
  ret.streamBandwidth = impl_->streamBandwidth;
  ret.decodedFrames = impl_->decodedFrames;
  ret.droppedFrames = impl_->droppedFrames;
  ret.estimatedBandwidth = impl_->estimatedBandwidth;
  ret.loadLatency = impl_->loadLatency;
  ret.playTime = impl_->playTime;
  ret.bufferingTime = impl_->bufferingTime;
  for (const auto& item : impl_->switchHistory) {
    ret.switchHistory.emplace_back(item.GetInternal());
  }
  for (const auto& item : impl_->stateHistory) {
    ret.stateHistory.emplace_back(item.GetInternal());
  }
  return ret;
}



} // namespace shaka