fragmenter.h

// Copyright 2014 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

#ifndef PACKAGER_MEDIA_FORMATS_MP4_FRAGMENTER_H_
#define PACKAGER_MEDIA_FORMATS_MP4_FRAGMENTER_H_

#include <memory>
#include <vector>

#include "packager/base/logging.h"
#include "packager/status.h"

namespace shaka {
namespace media {

class BufferWriter;
class MediaSample;
class StreamInfo;

namespace mp4 {

struct KeyFrameInfo;
struct SegmentReference;
struct TrackFragment;

class Fragmenter {
 public:
  Fragmenter(std::shared_ptr<const StreamInfo> info,
             TrackFragment* traf,
             int64_t edit_list_offset);

  ~Fragmenter();

  Status AddSample(const MediaSample& sample);

  Status InitializeFragment(int64_t first_sample_dts);

  Status FinalizeFragment();

  void GenerateSegmentReference(SegmentReference* reference) const;

  void ClearFragmentFinalized() { fragment_finalized_ = false; }

  uint64_t fragment_duration() const { return fragment_duration_; }
  uint64_t first_sap_time() const { return first_sap_time_; }
  uint64_t earliest_presentation_time() const {
    return earliest_presentation_time_;
  }
  bool fragment_initialized() const { return fragment_initialized_; }
  bool fragment_finalized() const { return fragment_finalized_; }
  BufferWriter* data() { return data_.get(); }
  const std::vector<KeyFrameInfo>& key_frame_infos() const {
    return key_frame_infos_;
  }

 protected:
  TrackFragment* traf() { return traf_; }

  template <typename T>
  bool OptimizeSampleEntries(std::vector<T>* entries, T* default_value);

 private:
  Status FinalizeFragmentForEncryption();
  // Check if the current fragment starts with SAP.
  bool StartsWithSAP() const;

  std::shared_ptr<const StreamInfo> stream_info_;
  TrackFragment* traf_ = nullptr;
  int64_t edit_list_offset_ = 0;
  int64_t seek_preroll_ = 0;
  bool fragment_initialized_ = false;
  bool fragment_finalized_ = false;
  int64_t fragment_duration_ = 0;
  int64_t earliest_presentation_time_ = 0;
  int64_t first_sap_time_ = 0;
  std::unique_ptr<BufferWriter> data_;
  // Saves key frames information, for Video.
  std::vector<KeyFrameInfo> key_frame_infos_;

  DISALLOW_COPY_AND_ASSIGN(Fragmenter);
};

template <typename T>
bool Fragmenter::OptimizeSampleEntries(std::vector<T>* entries,
                                       T* default_value) {
  DCHECK(entries);
  DCHECK(default_value);
  DCHECK(!entries->empty());

  typename std::vector<T>::const_iterator it = entries->begin();
  T value = *it;
  for (; it < entries->end(); ++it)
    if (value != *it)
      return false;

  // Clear |entries| if it contains only one value.
  entries->clear();
  *default_value = value;
  return true;
}

}  // namespace mp4
}  // namespace media
}  // namespace shaka

#endif  // PACKAGER_MEDIA_FORMATS_MP4_FRAGMENTER_H_