es_descriptor.h

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef PACKAGER_MEDIA_CODECS_ES_DESCRIPTOR_H_
#define PACKAGER_MEDIA_CODECS_ES_DESCRIPTOR_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include <vector>
 
namespace shaka {
namespace media {
 
class BitReader;
class BufferWriter;
 
// The following values are extracted from ISO 14496 Part 1 Table 5 -
// objectTypeIndication Values. Only values currently in use are included.
enum class ObjectType : uint8_t {
  kForbidden = 0,
  kISO_14496_3 = 0x40,         // MPEG4 AAC
  kISO_13818_7_AAC_LC = 0x67,  // MPEG2 AAC-LC
  kISO_13818_3_MPEG1 = 0x69,   // MPEG1 ISO/IEC 13818-3, 16,22.05,24kHz
  kISO_11172_3_MPEG1 = 0x6B,   // MPEG1 ISO/IEC 11172-3, 32,44.1,48kHz
  kDTSC = 0xA9,                // DTS Coherent Acoustics audio
  kDTSE = 0xAC,                // DTS Express low bit rate audio
  kDTSH = 0xAA,                // DTS-HD High Resolution Audio
  kDTSL = 0xAB,                // DTS-HD Master Audio
};
 
enum class DescriptorTag {
  kForbidden = 0,
  kES = 0x03,
  kDecoderConfig = 0x04,
  kDecoderSpecificInfo = 0x05,
  kSLConfig = 0x06,
};
 
class BaseDescriptor {
 public:
  explicit BaseDescriptor(DescriptorTag tag) : tag_(tag) {}
 
  bool Parse(const std::vector<uint8_t>& data);
 
  bool Read(BitReader* reader);
 
  void Write(BufferWriter* writer);
 
  size_t ComputeSize();
 
 protected:
  void WriteHeader(BufferWriter* writer);
 
  size_t data_size() const { return data_size_; }
 
 private:
  // Read the descriptor data (header is already read).
  virtual bool ReadData(BitReader* reader) = 0;
  // Write the descriptor. The descriptor data size should already be updated.
  virtual void WriteInternal(BufferWriter* writer) = 0;
  // Compute the data size, with child descriptors included.
  virtual size_t ComputeDataSize() = 0;
 
  DescriptorTag tag_ = DescriptorTag::kForbidden;
  size_t data_size_ = 0;
};
 
class DecoderSpecificInfoDescriptor : public BaseDescriptor {
 public:
  DecoderSpecificInfoDescriptor()
      : BaseDescriptor(DescriptorTag::kDecoderSpecificInfo) {}
 
  const std::vector<uint8_t>& data() const { return data_; }
 
  void set_data(const std::vector<uint8_t>& data) { data_ = data; }
 
 private:
  bool ReadData(BitReader* reader) override;
  void WriteInternal(BufferWriter* writer) override;
  size_t ComputeDataSize() override;
 
  std::vector<uint8_t> data_;
};
 
class DecoderConfigDescriptor : public BaseDescriptor {
 public:
  DecoderConfigDescriptor() : BaseDescriptor(DescriptorTag::kDecoderConfig) {}
 
  uint32_t buffer_size_db() const { return buffer_size_db_; }
  void set_buffer_size_db(uint32_t buffer_size_db) {
    buffer_size_db_ = buffer_size_db;
  }
 
  uint32_t max_bitrate() const { return max_bitrate_; }
  void set_max_bitrate(uint32_t max_bitrate) { max_bitrate_ = max_bitrate; }
 
  uint32_t avg_bitrate() const { return avg_bitrate_; }
  void set_avg_bitrate(uint32_t avg_bitrate) { avg_bitrate_ = avg_bitrate; }
 
  ObjectType object_type() const { return object_type_; }
  void set_object_type(ObjectType object_type) { object_type_ = object_type; }
 
  bool IsAAC() const {
    return object_type_ == ObjectType::kISO_14496_3 ||
           object_type_ == ObjectType::kISO_13818_7_AAC_LC;
  }
 
  bool IsDTS() const {
    return object_type_ == ObjectType::kDTSC ||
           object_type_ == ObjectType::kDTSE ||
           object_type_ == ObjectType::kDTSH ||
           object_type_ == ObjectType::kDTSL;
  }
 
  const DecoderSpecificInfoDescriptor& decoder_specific_info_descriptor()
      const {
    return decoder_specific_info_descriptor_;
  }
 
  DecoderSpecificInfoDescriptor* mutable_decoder_specific_info_descriptor() {
    return &decoder_specific_info_descriptor_;
  }
 
 private:
  bool ReadData(BitReader* reader) override;
  void WriteInternal(BufferWriter* writer) override;
  size_t ComputeDataSize() override;
 
  ObjectType object_type_ = ObjectType::kForbidden;
  uint32_t buffer_size_db_ = 0;
  uint32_t max_bitrate_ = 0;
  uint32_t avg_bitrate_ = 0;
  DecoderSpecificInfoDescriptor decoder_specific_info_descriptor_;
};
 
class SLConfigDescriptor : public BaseDescriptor {
 public:
  SLConfigDescriptor() : BaseDescriptor(DescriptorTag::kSLConfig) {}
 
 private:
  bool ReadData(BitReader* reader) override;
  void WriteInternal(BufferWriter* writer) override;
  size_t ComputeDataSize() override;
};
 
class ESDescriptor : public BaseDescriptor {
 public:
  ESDescriptor() : BaseDescriptor(DescriptorTag::kES) {}
 
  uint16_t esid() const { return esid_; }
 
  const DecoderConfigDescriptor& decoder_config_descriptor() const {
    return decoder_config_descriptor_;
  }
 
  DecoderConfigDescriptor* mutable_decoder_config_descriptor() {
    return &decoder_config_descriptor_;
  }
 
 private:
  bool ReadData(BitReader* reader) override;
  void WriteInternal(BufferWriter* writer) override;
  size_t ComputeDataSize() override;
 
  uint16_t esid_ = 0;  // Elementary Stream ID.
 
  DecoderConfigDescriptor decoder_config_descriptor_;
  SLConfigDescriptor sl_config_descriptor_;
};
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_CODECS_ES_DESCRIPTOR_H_