Mirror-Tools
/
shaka-packager
mirror of https://github.com/shaka-project/shaka-packager.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
shaka-packager/packager/media/formats/mp2t/ts_writer.cc

485 lines
18 KiB
C++
Raw Blame History

// Copyright 2016 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
#include "packager/media/formats/mp2t/ts_writer.h"
#include <algorithm>
#include "packager/base/logging.h"
#include "packager/media/base/audio_stream_info.h"
#include "packager/media/base/buffer_writer.h"
#include "packager/media/base/stream_info.h"
#include "packager/media/base/video_stream_info.h"
namespace edash_packager {
namespace media {
namespace mp2t {
namespace {
enum Pid : uint8_t {
// The pid can be 13 bits long but 8 bits is sufficient for this library.
// This is the minimum PID that can be used for PMT.
kPmtPid = 0x20,
// This is arbitrary number that is not reserved by the spec.
kElementaryPid = 0x50,
};
// Program number is 16 bits but 8 bits is sufficient.
const uint8_t kProgramNumber = 0x01;
const uint8_t kStreamTypeH264 = 0x1B;
const uint8_t kStreamTypeAdtsAac = 0x0F;
// For all the pointer fields in the following PAT and PMTs, they are not really
// part of PAT or PMT but it's there so that TsPacket can point to a memory
// location that starts from pointer field.
const uint8_t kProgramAssociationTableId = 0x00;
const uint8_t kProgramMapTableId = 0x02;
// TODO(rkuroiwa):
// Once encryption is added, another PAT must be used for the encrypted portion
// e.g. version number set to 1.
// But this works for clear lead and for clear segments.
// Write PSI generator.
const uint8_t kPat[] = {
0x00, // pointer field
kProgramAssociationTableId,
0xB0, // The last 2 '00' assumes that this PAT is not very long.
0x0D, // Length of the rest of this array.
0x00, 0x00, // Transport stream ID is 0.
0xC1, // version number 0, current next indicator 1.
0x00, // section number
0x00, // last section number
// program number -> PMT PID mapping.
0x00, 0x01, // program number is 1.
0xE0, // first 3 bits is reserved.
kPmtPid,
// CRC32.
0xF9, 0x62, 0xF5, 0x8B,
};
// Like PAT, with encryption different PMTs are required.
// It might make sense to add a PmtGenerator class.
const uint8_t kPmtH264[] = {
0x00, // pointer field
kProgramMapTableId,
0xB0, // assumes length is <= 256 bytes.
0x12, // length of the rest of this array.
0x00, kProgramNumber,
0xC1, // version 0, current next indicator 1.
0x00, // section number
0x00, // last section number.
0xE0, // first 3 bits reserved.
kElementaryPid, // PCR PID is the elementary streams PID.
0xF0, // first 4 bits reserved.
0x00, // No descriptor at this level.
kStreamTypeH264, 0xE0, kElementaryPid, // stream_type -> PID.
0xF0, 0x00, // Es_info_length is 0.
// CRC32.
0x43, 0x49, 0x97, 0xBE,
};
const uint8_t kPmtAac[] = {
0x00, // pointer field
0x02, // table id must be 0x02.
0xB0, // assumes length is <= 256 bytes.
0x12, // length of the rest of this array.
0x00, kProgramNumber,
0xC1, // version 0, current next indicator 1.
0x00, // section number
0x00, // last section number.
0xE0, // first 3 bits reserved.
kElementaryPid, // PCR PID is the elementary streams PID.
0xF0, // first 4 bits reserved.
0x00, // No descriptor at this level.
kStreamTypeAdtsAac, 0xE0, kElementaryPid, // stream_type -> PID.
0xF0, 0x00, // Es_info_length is 0.
// CRC32.
0xE0, 0x6F, 0x1A, 0x31,
};
const bool kHasPcr = true;
const bool kPayloadUnitStartIndicator = true;
const uint8_t kSyncByte = 0x47;
const int kPcrFieldsSize = 6;
// This is the size of the first few fields in a TS packet, i.e. TS packet size
// without adaptation field or the payload.
const int kTsPacketHeaderSize = 4;
const int kTsPacketSize = 188;
const int kTsPacketMaximumPayloadSize =
kTsPacketSize - kTsPacketHeaderSize;
const size_t kMaxPesPacketLengthValue = 0xFFFF;
// Used for adaptation field padding bytes.
const uint8_t kPaddingBytes[] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
static_assert(arraysize(kPaddingBytes) >= kTsPacketMaximumPayloadSize,
"Padding array is not big enough.");
// |remaining_data_size| is the amount of data that has to be written. This may
// be bigger than a TS packet size.
// |remaining_data_size| matters if it is short and requires padding.
void WriteAdaptationField(bool has_pcr,
uint64_t pcr_base,
size_t remaining_data_size,
BufferWriter* writer) {
// Special case where a TS packet requires 1 byte padding.
if (!has_pcr && remaining_data_size == kTsPacketMaximumPayloadSize - 1) {
writer->AppendInt(static_cast<uint8_t>(0));
return;
}
// The size of the field itself.
const int kAdaptationFieldLengthSize = 1;
// The size of all leading flags (not including the adaptation_field_length).
const int kAdaptationFieldHeaderSize = 1;
int adaptation_field_length =
kAdaptationFieldHeaderSize + (has_pcr ? kPcrFieldsSize : 0);
if (remaining_data_size < kTsPacketMaximumPayloadSize) {
const int current_ts_size = kTsPacketHeaderSize + remaining_data_size +
adaptation_field_length +
kAdaptationFieldLengthSize;
if (current_ts_size < kTsPacketSize) {
adaptation_field_length += kTsPacketSize - current_ts_size;
}
}
writer->AppendInt(static_cast<uint8_t>(adaptation_field_length));
int remaining_bytes = adaptation_field_length;
writer->AppendInt(static_cast<uint8_t>(
// All flags except PCR_flag are 0.
static_cast<uint8_t>(has_pcr) << 4));
remaining_bytes -= 1;
if (has_pcr) {
// program_clock_reference_extension = 0.
const uint32_t most_significant_32bits_pcr =
static_cast<uint32_t>(pcr_base >> 1);
const uint16_t pcr_last_bit_reserved_and_pcr_extension =
((pcr_base & 1) << 15);
writer->AppendInt(most_significant_32bits_pcr);
writer->AppendInt(pcr_last_bit_reserved_and_pcr_extension);
remaining_bytes -= kPcrFieldsSize;
}
DCHECK_GE(remaining_bytes, 0);
if (remaining_bytes == 0)
return;
DCHECK_GE(static_cast<int>(arraysize(kPaddingBytes)), remaining_bytes);
writer->AppendArray(kPaddingBytes, remaining_bytes);
}
// |payload| can be any payload. Most likely raw PSI tables or PES packet
// payload.
void WritePayloadToBufferWriter(const uint8_t* payload,
size_t payload_size,
bool payload_unit_start_indicator,
int pid,
bool has_pcr,
uint64_t pcr_base,
ContinuityCounter* continuity_counter,
BufferWriter* writer) {
size_t payload_bytes_written = 0;
do {
const bool must_write_adaptation_header = has_pcr;
const size_t bytes_left = payload_size - payload_bytes_written;
const bool has_adaptation_field = must_write_adaptation_header ||
bytes_left < kTsPacketMaximumPayloadSize;
writer->AppendInt(kSyncByte);
writer->AppendInt(static_cast<uint16_t>(
// transport_error_indicator and transport_priority are both '0'.
static_cast<int>(payload_unit_start_indicator) << 14 | pid));
const uint8_t adaptation_field_control =
((has_adaptation_field ? 1 : 0) << 1) | ((bytes_left != 0) ? 1 : 0);
// transport_scrambling_control is '00'.
writer->AppendInt(static_cast<uint8_t>(adaptation_field_control << 4 |
continuity_counter->GetNext()));
if (has_adaptation_field) {
const size_t before = writer->Size();
WriteAdaptationField(has_pcr, pcr_base, bytes_left, writer);
const size_t bytes_for_adaptation_field = writer->Size() - before;
const int write_bytes =
kTsPacketMaximumPayloadSize - bytes_for_adaptation_field;
writer->AppendArray(payload + payload_bytes_written, write_bytes);
payload_bytes_written += write_bytes;
} else {
writer->AppendArray(payload + payload_bytes_written,
kTsPacketMaximumPayloadSize);
payload_bytes_written += kTsPacketMaximumPayloadSize;
}
// Once written, not needed for this payload.
has_pcr = false;
payload_unit_start_indicator = false;
} while (payload_bytes_written < payload_size);
}
void WritePatPmtToBuffer(const uint8_t* data,
int data_size,
int pid,
ContinuityCounter* continuity_counter,
BufferWriter* writer) {
WritePayloadToBufferWriter(data, data_size, kPayloadUnitStartIndicator, pid,
!kHasPcr, 0, continuity_counter, writer);
}
void WritePatToBuffer(const uint8_t* pat,
int pat_size,
ContinuityCounter* continuity_counter,
BufferWriter* writer) {
const int kPatPid = 0;
WritePatPmtToBuffer(pat, pat_size, kPatPid, continuity_counter, writer);
}
void WritePmtToBuffer(const uint8_t* pmt,
int pmt_size,
ContinuityCounter* continuity_counter,
BufferWriter* writer) {
WritePatPmtToBuffer(pmt, pmt_size, kPmtPid, continuity_counter, writer);
}
// The only difference between writing PTS or DTS is the leading bits.
void WritePtsOrDts(uint8_t leading_bits,
uint64_t pts_or_dts,
BufferWriter* writer) {
// First byte has 3 MSB of PTS.
uint8_t first_byte =
leading_bits << 4 | (((pts_or_dts >> 30) & 0x07) << 1) | 1;
// Second byte has the next 8 bits of pts.
uint8_t second_byte = (pts_or_dts >> 22) & 0xFF;
// Third byte has the next 7 bits of pts followed by a marker bit.
uint8_t third_byte = (((pts_or_dts >> 15) & 0x7F) << 1) | 1;
// Fourth byte has the next 8 bits of pts.
uint8_t fourth_byte = ((pts_or_dts >> 7) & 0xFF);
// Fifth byte has the last 7 bits of pts followed by a marker bit.
uint8_t fifth_byte = ((pts_or_dts & 0x7F) << 1) | 1;
writer->AppendInt(first_byte);
writer->AppendInt(second_byte);
writer->AppendInt(third_byte);
writer->AppendInt(fourth_byte);
writer->AppendInt(fifth_byte);
}
bool WritePesToFile(const PesPacket& pes,
ContinuityCounter* continuity_counter,
File* file) {
// The size of the length field.
const int kAdaptationFieldLengthSize = 1;
// The size of the flags field.
const int kAdaptationFieldHeaderSize = 1;
const int kPcrFieldSize = 6;
const int kTsPacketMaxPayloadWithPcr =
kTsPacketMaximumPayloadSize - kAdaptationFieldLengthSize -
kAdaptationFieldHeaderSize - kPcrFieldSize;
const uint64_t pcr_base = pes.has_dts() ? pes.dts() : pes.pts();
const int pid = kElementaryPid;
// This writer will hold part of PES packet after PES_packet_length field.
BufferWriter pes_header_writer;
// The first bit must be '10' for PES with video or audio stream id. The other
// flags (bits) don't matter so they are 0.
pes_header_writer.AppendInt(static_cast<uint8_t>(0x80));
pes_header_writer.AppendInt(
static_cast<uint8_t>(static_cast<int>(pes.has_pts()) << 7 |
static_cast<int>(pes.has_dts()) << 6
// Other fields are all 0.
));
uint8_t pes_header_data_length = 0;
if (pes.has_pts())
pes_header_data_length += 5;
if (pes.has_dts())
pes_header_data_length += 5;
pes_header_writer.AppendInt(pes_header_data_length);
if (pes.has_pts() && pes.has_dts()) {
WritePtsOrDts(0x03, pes.pts(), &pes_header_writer);
WritePtsOrDts(0x01, pes.dts(), &pes_header_writer);
} else if (pes.has_pts()) {
WritePtsOrDts(0x02, pes.pts(), &pes_header_writer);
}
// Put the first TS packet's payload into a buffer. This contains the PES
// packet's header.
BufferWriter first_ts_packet_buffer(kTsPacketSize);
first_ts_packet_buffer.AppendNBytes(static_cast<uint64_t>(0x000001), 3);
first_ts_packet_buffer.AppendInt(pes.stream_id());
const size_t pes_packet_length = pes.data().size() + pes_header_writer.Size();
first_ts_packet_buffer.AppendInt(static_cast<uint16_t>(
pes_packet_length > kMaxPesPacketLengthValue ? 0 : pes_packet_length));
first_ts_packet_buffer.AppendBuffer(pes_header_writer);
const int available_payload =
kTsPacketMaxPayloadWithPcr - first_ts_packet_buffer.Size();
const int bytes_consumed =
std::min(static_cast<int>(pes.data().size()), available_payload);
first_ts_packet_buffer.AppendArray(pes.data().data(), bytes_consumed);
BufferWriter output_writer;
WritePayloadToBufferWriter(first_ts_packet_buffer.Buffer(),
first_ts_packet_buffer.Size(),
kPayloadUnitStartIndicator, pid, kHasPcr, pcr_base,
continuity_counter, &output_writer);
const size_t remaining_pes_data_size = pes.data().size() - bytes_consumed;
if (remaining_pes_data_size > 0) {
WritePayloadToBufferWriter(pes.data().data() + bytes_consumed,
remaining_pes_data_size,
!kPayloadUnitStartIndicator, pid, !kHasPcr, 0,
continuity_counter, &output_writer);
}
return output_writer.WriteToFile(file).ok();
}
} // namespace
ContinuityCounter::ContinuityCounter() {}
ContinuityCounter::~ContinuityCounter() {}
int ContinuityCounter::GetNext() {
int ret = counter_;
++counter_;
counter_ %= 16;
return ret;
}
TsWriter::TsWriter() {}
TsWriter::~TsWriter() {}
bool TsWriter::Initialize(const StreamInfo& stream_info) {
// This buffer will hold PMT data after section_length field so that this
// can be used to get the section_length.
time_scale_ = stream_info.time_scale();
if (time_scale_ == 0) {
LOG(ERROR) << "Timescale is 0.";
return false;
}
const StreamType stream_type = stream_info.stream_type();
if (stream_type != StreamType::kStreamVideo &&
stream_type != StreamType::kStreamAudio) {
LOG(ERROR) << "TsWriter cannot handle stream type " << stream_type
<< " yet.";
return false;
}
const uint8_t* pmt = nullptr;
size_t pmt_size = 0u;
if (stream_info.stream_type() == StreamType::kStreamVideo) {
const VideoStreamInfo& video_stream_info =
static_cast<const VideoStreamInfo&>(stream_info);
if (video_stream_info.codec() != VideoCodec::kCodecH264) {
LOG(ERROR) << "TsWriter cannot handle video codec "
<< video_stream_info.codec() << " yet.";
return false;
}
pmt = kPmtH264;
pmt_size = arraysize(kPmtH264);
} else {
DCHECK_EQ(stream_type, StreamType::kStreamAudio);
const AudioStreamInfo& audio_stream_info =
static_cast<const AudioStreamInfo&>(stream_info);
if (audio_stream_info.codec() != AudioCodec::kCodecAAC) {
LOG(ERROR) << "TsWriter cannot handle audio codec "
<< audio_stream_info.codec() << " yet.";
return false;
}
pmt = kPmtAac;
pmt_size = arraysize(kPmtAac);
}
DCHECK(pmt);
DCHECK_GT(pmt_size, 0u);
// Most likely going to fit in 2 TS packets.
BufferWriter psi_writer(kTsPacketSize * 2);
WritePatToBuffer(kPat, arraysize(kPat), &pat_continuity_counter_,
&psi_writer);
WritePmtToBuffer(pmt, pmt_size, &pmt_continuity_counter_, &psi_writer);
psi_writer.SwapBuffer(&psi_ts_packets_);
return true;
}
bool TsWriter::NewSegment(const std::string& file_name) {
DCHECK(!psi_ts_packets_.empty());
if (current_file_) {
LOG(ERROR) << "File " << current_file_->file_name() << " still open.";
return false;
}
current_file_.reset(File::Open(file_name.c_str(), "w"));
if (!current_file_) {
LOG(ERROR) << "Failed to open file " << file_name;
return false;
}
// TODO(kqyang): Add WriteArrayToFile().
BufferWriter psi_writer(psi_ts_packets_.size());
psi_writer.AppendVector(psi_ts_packets_);
if (!psi_writer.WriteToFile(current_file_.get()).ok()) {
LOG(ERROR) << "Failed to write PSI to file.";
return false;
}
return true;
}
bool TsWriter::FinalizeSegment() {
return current_file_.release()->Close();
}
bool TsWriter::AddPesPacket(scoped_ptr<PesPacket> pes_packet) {
if (time_scale_ == 0) {
LOG(ERROR) << "Timescale is 0.";
return false;
}
DCHECK(current_file_);
if (!WritePesToFile(*pes_packet, &elementary_stream_continuity_counter_,
current_file_.get())) {
LOG(ERROR) << "Failed to write pes to file.";
return false;
}
// No need to keep pes_packet around so not passing it anywhere.
return true;
}
} // namespace mp2t
} // namespace media
} // namespace edash_packager
Reference in New Issue View Git Blame Copy Permalink