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 MEDIA_FORMATS_MP4_FRAGMENTER_H_
#define MEDIA_FORMATS_MP4_FRAGMENTER_H_

#include <memory>
#include <vector>

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

namespace shaka {
namespace media {

class BufferWriter;
class MediaSample;
class StreamInfo;

namespace mp4 {

struct SegmentReference;
struct TrackFragment;

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

  ~Fragmenter();

  Status AddSample(std::shared_ptr<MediaSample> sample);

  Status InitializeFragment(int64_t first_sample_dts);

  Status FinalizeFragment();

  void GenerateSegmentReference(SegmentReference* reference);

  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(); }

  void set_use_decoding_timestamp_in_timeline(
      bool use_decoding_timestamp_in_timeline) {
    use_decoding_timestamp_in_timeline_ = use_decoding_timestamp_in_timeline;
  }

 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();

  std::shared_ptr<StreamInfo> stream_info_;
  bool use_decoding_timestamp_in_timeline_;
  TrackFragment* traf_;
  uint64_t seek_preroll_;
  bool fragment_initialized_;
  bool fragment_finalized_;
  uint64_t fragment_duration_;
  int64_t earliest_presentation_time_;
  int64_t first_sap_time_;
  std::unique_ptr<BufferWriter> data_;

  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  // MEDIA_FORMATS_MP4_FRAGMENTER_H_