track.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/track.h"

#include "src/js/track.h"

namespace shaka {

class Track::Impl {
 public:
  const double id{};
  const bool active{};
  const std::string type{};
  const double bandwidth{};
  const std::string language{};
  const shaka::optional<std::string> label{};
  const shaka::optional<std::string> kind{};
  const shaka::optional<double> width{};
  const shaka::optional<double> height{};
  const shaka::optional<double> frameRate{};
  const shaka::optional<std::string> mimeType{};
  const shaka::optional<std::string> codecs{};
  const shaka::optional<std::string> audioCodec{};
  const shaka::optional<std::string> videoCodec{};
  const bool primary{};
  const std::vector<std::string> roles{};
  const shaka::optional<double> videoId{};
  const shaka::optional<double> audioId{};
  const shaka::optional<double> channelsCount{};
  const shaka::optional<double> audioBandwidth{};
  const shaka::optional<double> videoBandwidth{};

  Impl() {}
  Impl(js::Track&& internal)
    : id(std::move(internal.id)),
      active(std::move(internal.active)),
      type(std::move(internal.type)),
      bandwidth(std::move(internal.bandwidth)),
      language(std::move(internal.language)),
      label(std::move(internal.label)),
      kind(std::move(internal.kind)),
      width(std::move(internal.width)),
      height(std::move(internal.height)),
      frameRate(std::move(internal.frameRate)),
      mimeType(std::move(internal.mimeType)),
      codecs(std::move(internal.codecs)),
      audioCodec(std::move(internal.audioCodec)),
      videoCodec(std::move(internal.videoCodec)),
      primary(std::move(internal.primary)),
      roles(std::make_move_iterator(internal.roles.begin()), std::make_move_iterator(internal.roles.end())),
      videoId(std::move(internal.videoId)),
      audioId(std::move(internal.audioId)),
      channelsCount(std::move(internal.channelsCount)),
      audioBandwidth(std::move(internal.audioBandwidth)),
      videoBandwidth(std::move(internal.videoBandwidth)) {}
};

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

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

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

bool Track::active() const {
  return impl_->active;
}

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

double Track::bandwidth() const {
  return impl_->bandwidth;
}

const std::string& Track::language() const {
  return impl_->language;
}

shaka::optional<std::string> Track::label() const {
  return impl_->label;
}

shaka::optional<std::string> Track::kind() const {
  return impl_->kind;
}

shaka::optional<double> Track::width() const {
  return impl_->width;
}

shaka::optional<double> Track::height() const {
  return impl_->height;
}

shaka::optional<double> Track::frame_rate() const {
  return impl_->frameRate;
}

shaka::optional<std::string> Track::mime_type() const {
  return impl_->mimeType;
}

shaka::optional<std::string> Track::codecs() const {
  return impl_->codecs;
}

shaka::optional<std::string> Track::audio_codec() const {
  return impl_->audioCodec;
}

shaka::optional<std::string> Track::video_codec() const {
  return impl_->videoCodec;
}

bool Track::primary() const {
  return impl_->primary;
}

const std::vector<std::string>& Track::roles() const {
  return impl_->roles;
}

shaka::optional<double> Track::video_id() const {
  return impl_->videoId;
}

shaka::optional<double> Track::audio_id() const {
  return impl_->audioId;
}

shaka::optional<double> Track::channels_count() const {
  return impl_->channelsCount;
}

shaka::optional<double> Track::audio_bandwidth() const {
  return impl_->audioBandwidth;
}

shaka::optional<double> Track::video_bandwidth() const {
  return impl_->videoBandwidth;
}


js::Track Track::GetInternal() const {
  js::Track ret;
  ret.id = impl_->id;
  ret.active = impl_->active;
  ret.type = impl_->type;
  ret.bandwidth = impl_->bandwidth;
  ret.language = impl_->language;
  ret.label = impl_->label;
  ret.kind = impl_->kind;
  ret.width = impl_->width;
  ret.height = impl_->height;
  ret.frameRate = impl_->frameRate;
  ret.mimeType = impl_->mimeType;
  ret.codecs = impl_->codecs;
  ret.audioCodec = impl_->audioCodec;
  ret.videoCodec = impl_->videoCodec;
  ret.primary = impl_->primary;
  ret.roles = impl_->roles;
  ret.videoId = impl_->videoId;
  ret.audioId = impl_->audioId;
  ret.channelsCount = impl_->channelsCount;
  ret.audioBandwidth = impl_->audioBandwidth;
  ret.videoBandwidth = impl_->videoBandwidth;
  return ret;
}



} // namespace shaka