elementary_stream_packet.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// Copyright (c) 2016, Samsung Electronics Co., Ltd
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM
// , OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// @author Tomasz Borkowski
//
// ----------------------------------------------------------------------------

#ifndef SRC_PLAYER_ES_DASH_PLAYER_DEMUXER_ELEMENTARY_STREAM_PACKET_H_
#define SRC_PLAYER_ES_DASH_PLAYER_DEMUXER_ELEMENTARY_STREAM_PACKET_H_

#include <vector>

#include "nacl_player/media_common.h"


class ElementaryStreamPacket {
 public:
  ElementaryStreamPacket(uint8_t* data, uint32_t size);

  ElementaryStreamPacket(const ElementaryStreamPacket&) = delete;

  ElementaryStreamPacket(ElementaryStreamPacket&& other) = default;

  ~ElementaryStreamPacket() = default;

  ElementaryStreamPacket& operator=(const ElementaryStreamPacket&) = delete;

  ElementaryStreamPacket& operator=(ElementaryStreamPacket&& other) = default;

  const Samsung::NaClPlayer::ESPacket& GetESPacket() const;

  const Samsung::NaClPlayer::ESPacketEncryptionInfo& GetEncryptionInfo() const;

  bool IsEncrypted() const;

  bool IsKeyFrame() const { return es_packet_.is_key_frame; }

  uint32_t GetDataSize() const { return data_.size(); }

  Samsung::NaClPlayer::TimeTicks GetPts() const { return es_packet_.pts; }

  Samsung::NaClPlayer::TimeTicks GetDts() const { return es_packet_.dts; }

  Samsung::NaClPlayer::TimeTicks GetDuration() const {
    return es_packet_.duration;
  }

  void SetKeyFrame(bool key_frame) { es_packet_.is_key_frame = key_frame; }

  void SetPts(Samsung::NaClPlayer::TimeTicks pts) { es_packet_.pts = pts; }

  void SetDts(Samsung::NaClPlayer::TimeTicks dts) { es_packet_.dts = dts; }

  void SetDuration(Samsung::NaClPlayer::TimeTicks duration) {
    es_packet_.duration = duration;
  }

  void SetKeyId(uint8_t* key_id, uint32_t key_id_size);

  void SetIv(uint8_t* iv, uint32_t iv_size);

  void ClearSubsamples();

  void AddSubsample(uint32_t clear_bytes, uint32_t cipher_bytes);

 private:
  // assumption: Address returned by vector::data() method is invariant under
  //             move operations

  // invariants:

  // es_packet.data == data_.data() && es_packet.size == data.size()
  void FixDataInvariant();

  // encryption_info.key_id == key_id_.data()
  // encryption_info.key_id_size == key_id_.size()
  void FixKeyIdInvariant();

  // encryption_info.iv == key_id_.data()
  // encryption_info.iv_size == key_id_.size()
  void FixIvInvariant();

  // encryption_info.subsamples == subsamples_.data()
  // encryption_info.num_subsamples == subsamples_.size()
  void FixSubsamplesInvariant();

  std::vector<uint8_t> data_;
  Samsung::NaClPlayer::ESPacket es_packet_;

  std::vector<uint8_t> key_id_;
  std::vector<uint8_t> iv_;
  std::vector<Samsung::NaClPlayer::EncryptedSubsampleDescription> subsamples_;
  Samsung::NaClPlayer::ESPacketEncryptionInfo encryption_info_;
};

#endif  // SRC_PLAYER_ES_DASH_PLAYER_DEMUXER_ELEMENTARY_STREAM_PACKET_H_