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/dvb/dvb_sub_parser.cc

484 lines
16 KiB
C++
Raw Blame History

// Copyright 2020 Google LLC. 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/dvb/dvb_sub_parser.h>
#include <algorithm>
#include <glog/logging.h>
#include <packager/media/formats/mp2t/mp2t_common.h>
namespace shaka {
namespace media {
namespace {
RgbaColor ConvertYuv(uint8_t Y, uint8_t Cr, uint8_t Cb, uint8_t T) {
// Converts based on ITU-R BT.601.
// See https://en.wikipedia.org/wiki/YCbCr
//
// Note that the T value should be interpolated based on a full transparency
// being 256. This means that T=255 should not be fully transparent. Y=0 is
// used to signal full transparency.
// Values for Y<16 (except Y=0) are invalid, so clamp to 16.
RgbaColor color;
const double y_transform = 255.0 / 219 * (std::max<uint8_t>(Y, 16) - 16);
const double cb_transform = 255.0 / 244 * 1.772 * (Cb - 128);
const double cr_transform = 255.0 / 244 * 1.402 * (Cr - 128);
const double f1 = 0.114 / 0.587;
const double f2 = 0.299 / 0.587;
color.r = static_cast<uint8_t>(y_transform + cr_transform);
color.g =
static_cast<uint8_t>(y_transform - cb_transform * f1 - cr_transform * f2);
color.b = static_cast<uint8_t>(y_transform + cb_transform);
color.a = Y == 0 ? 0 : (T == 0 ? 255 : 256 - T);
return color;
}
} // namespace
DvbSubParser::DvbSubParser() : last_pts_(0), timeout_(0) {}
DvbSubParser::~DvbSubParser() {}
bool DvbSubParser::Parse(DvbSubSegmentType segment_type,
int64_t pts,
const uint8_t* payload,
size_t size,
std::vector<std::shared_ptr<TextSample>>* samples) {
switch (segment_type) {
case DvbSubSegmentType::kPageComposition:
return ParsePageComposition(pts, payload, size, samples);
case DvbSubSegmentType::kRegionComposition:
return ParseRegionComposition(payload, size);
case DvbSubSegmentType::kClutDefinition:
return ParseClutDefinition(payload, size);
case DvbSubSegmentType::kObjectData:
return ParseObjectData(pts, payload, size);
case DvbSubSegmentType::kDisplayDefinition:
return ParseDisplayDefinition(payload, size);
case DvbSubSegmentType::kEndOfDisplay:
// This signals all the current objects are available. But we need to
// know the end time, so we do nothing for now.
return true;
default:
LOG(WARNING) << "Unknown DVB-sub segment_type=0x" << std::hex
<< static_cast<uint32_t>(segment_type);
return true;
}
}
bool DvbSubParser::Flush(std::vector<std::shared_ptr<TextSample>>* samples) {
RCHECK(composer_.GetSamples(last_pts_, last_pts_ + timeout_ * kMpeg2Timescale,
samples));
composer_.ClearObjects();
return true;
}
const DvbImageColorSpace* DvbSubParser::GetColorSpace(uint8_t clut_id) {
return composer_.GetColorSpace(clut_id);
}
const DvbImageBuilder* DvbSubParser::GetImageForObject(uint16_t object_id) {
return composer_.GetObjectImage(object_id);
}
bool DvbSubParser::ParsePageComposition(
int64_t pts,
const uint8_t* data,
size_t size,
std::vector<std::shared_ptr<TextSample>>* samples) {
// See ETSI EN 300 743 Section 7.2.2.
BitReader reader(data, size);
uint8_t page_state;
RCHECK(reader.ReadBits(8, &timeout_));
RCHECK(reader.SkipBits(4)); // page_version_number
RCHECK(reader.ReadBits(2, &page_state));
RCHECK(reader.SkipBits(2)); // reserved
if (page_state == 0x1 || page_state == 0x2) {
// If this is a "acquisition point" or a "mode change", then this is a new
// page and we should clear the old data.
RCHECK(composer_.GetSamples(last_pts_, pts, samples));
composer_.ClearObjects();
last_pts_ = pts;
}
while (reader.bits_available() > 0u) {
uint8_t region_id;
uint16_t x, y;
RCHECK(reader.ReadBits(8, &region_id));
RCHECK(reader.SkipBits(8)); // reserved
RCHECK(reader.ReadBits(16, &x));
RCHECK(reader.ReadBits(16, &y));
RCHECK(composer_.SetRegionPosition(region_id, x, y));
}
return true;
}
bool DvbSubParser::ParseRegionComposition(const uint8_t* data, size_t size) {
// See ETSI EN 300 743 Section 7.2.3.
BitReader reader(data, size);
uint8_t region_id, clut_id;
uint16_t region_width, region_height;
bool region_fill_flag;
int background_pixel_code;
RCHECK(reader.ReadBits(8, &region_id));
RCHECK(reader.SkipBits(4)); // region_version_number
RCHECK(reader.ReadBits(1, &region_fill_flag));
RCHECK(reader.SkipBits(3)); // reserved
RCHECK(reader.ReadBits(16, &region_width));
RCHECK(reader.ReadBits(16, &region_height));
RCHECK(reader.SkipBits(3)); // region_level_of_compatibility
RCHECK(reader.SkipBits(3)); // region_depth
RCHECK(reader.SkipBits(2)); // reserved
RCHECK(reader.ReadBits(8, &clut_id));
RCHECK(reader.ReadBits(8, &background_pixel_code));
RCHECK(reader.SkipBits(4)); // region_4-bit_pixel_code
RCHECK(reader.SkipBits(2)); // region_2-bit_pixel_code
RCHECK(reader.SkipBits(2)); // reserved
RCHECK(
composer_.SetRegionInfo(region_id, clut_id, region_width, region_height));
if (!region_fill_flag)
background_pixel_code = -1;
while (reader.bits_available() > 0) {
uint16_t object_id, x, y;
uint8_t object_type;
RCHECK(reader.ReadBits(16, &object_id));
RCHECK(reader.ReadBits(2, &object_type));
RCHECK(reader.SkipBits(2)); // object_provider_flag
RCHECK(reader.ReadBits(12, &x));
RCHECK(reader.SkipBits(4)); // reserved
RCHECK(reader.ReadBits(12, &y));
if (object_type == 0x01 || object_type == 0x02) {
RCHECK(reader.SkipBits(8)); // foreground_pixel_code
RCHECK(reader.SkipBits(8)); // background_pixel_code
}
RCHECK(composer_.SetObjectInfo(object_id, region_id, x, y,
background_pixel_code));
}
return true;
}
bool DvbSubParser::ParseClutDefinition(const uint8_t* data, size_t size) {
// See ETSI EN 300 743 Section 7.2.4.
BitReader reader(data, size);
uint8_t clut_id;
RCHECK(reader.ReadBits(8, &clut_id));
auto* color_space = composer_.GetColorSpace(clut_id);
RCHECK(reader.SkipBits(4)); // CLUT_version_number
RCHECK(reader.SkipBits(4)); // reserved
while (reader.bits_available() > 0) {
uint8_t clut_entry_id;
uint8_t has_2_bit;
uint8_t has_4_bit;
uint8_t has_8_bit;
uint8_t full_range_flag;
RCHECK(reader.ReadBits(8, &clut_entry_id));
RCHECK(reader.ReadBits(1, &has_2_bit));
RCHECK(reader.ReadBits(1, &has_4_bit));
RCHECK(reader.ReadBits(1, &has_8_bit));
RCHECK(reader.SkipBits(4)); // reserved
RCHECK(reader.ReadBits(1, &full_range_flag));
if (has_2_bit + has_4_bit + has_8_bit != 1) {
LOG(ERROR) << "Must specify exactly one bit depth in CLUT definition";
return false;
}
const BitDepth bit_depth =
has_2_bit ? BitDepth::k2Bit
: (has_4_bit ? BitDepth::k4Bit : BitDepth::k8Bit);
uint8_t Y, Cr, Cb, T;
if (full_range_flag) {
RCHECK(reader.ReadBits(8, &Y));
RCHECK(reader.ReadBits(8, &Cr));
RCHECK(reader.ReadBits(8, &Cb));
RCHECK(reader.ReadBits(8, &T));
} else {
// These store the most-significant bits, so shift them up.
RCHECK(reader.ReadBits(6, &Y));
Y <<= 2;
RCHECK(reader.ReadBits(4, &Cr));
Cr <<= 4;
RCHECK(reader.ReadBits(4, &Cb));
Cb <<= 4;
RCHECK(reader.ReadBits(2, &T));
T <<= 6;
}
color_space->SetColor(bit_depth, clut_entry_id, ConvertYuv(Y, Cr, Cb, T));
}
return true;
}
bool DvbSubParser::ParseObjectData(int64_t pts,
const uint8_t* data,
size_t size) {
// See ETSI EN 300 743 Section 7.2.5 Table 17.
BitReader reader(data, size);
uint16_t object_id;
uint8_t object_coding_method;
RCHECK(reader.ReadBits(16, &object_id));
RCHECK(reader.SkipBits(4)); // object_version_number
RCHECK(reader.ReadBits(2, &object_coding_method));
RCHECK(reader.SkipBits(1)); // non_modifying_colour_flag
RCHECK(reader.SkipBits(1)); // reserved
auto* image = composer_.GetObjectImage(object_id);
auto* color_space = composer_.GetColorSpaceForObject(object_id);
if (!image || !color_space)
return false;
if (object_coding_method == 0) {
uint16_t top_field_length;
uint16_t bottom_field_length;
RCHECK(reader.ReadBits(16, &top_field_length));
RCHECK(reader.ReadBits(16, &bottom_field_length));
RCHECK(ParsePixelDataSubObject(top_field_length, true, &reader, color_space,
image));
RCHECK(ParsePixelDataSubObject(bottom_field_length, false, &reader,
color_space, image));
// Ignore 8_stuff_bits since we don't need to read to the end.
if (bottom_field_length == 0) {
// If there are no bottom rows, then the top rows are used instead. See
// beginning of section 7.2.5.1.
image->MirrorToBottomRows();
}
} else {
LOG(ERROR) << "Unsupported DVB-sub object coding method: "
<< static_cast<int>(object_coding_method);
return false;
}
return true;
}
bool DvbSubParser::ParseDisplayDefinition(const uint8_t* data, size_t size) {
// See ETSI EN 300 743 Section 7.2.1.
BitReader reader(data, size);
uint16_t width, height;
RCHECK(reader.SkipBits(4)); // dds_version_number
RCHECK(reader.SkipBits(1)); // display_window_flag
RCHECK(reader.SkipBits(3)); // reserved
RCHECK(reader.ReadBits(16, &width));
RCHECK(reader.ReadBits(16, &height));
// Size is stored as -1.
composer_.SetDisplaySize(width + 1, height + 1);
return true;
}
bool DvbSubParser::ParsePixelDataSubObject(size_t sub_object_length,
bool is_top_fields,
BitReader* reader,
DvbImageColorSpace* color_space,
DvbImageBuilder* image) {
const size_t start = reader->bit_position() / 8;
while (reader->bit_position() / 8 < start + sub_object_length) {
// See ETSI EN 300 743 Section 7.2.5.1 Table 20
uint8_t data_type;
RCHECK(reader->ReadBits(8, &data_type));
uint8_t temp[16];
switch (data_type) {
case 0x10:
RCHECK(Parse2BitPixelData(is_top_fields, reader, image));
reader->SkipToNextByte();
break;
case 0x11:
RCHECK(Parse4BitPixelData(is_top_fields, reader, image));
reader->SkipToNextByte();
break;
case 0x12:
RCHECK(Parse8BitPixelData(is_top_fields, reader, image));
break;
case 0x20:
for (int i = 0; i < 4; i++) {
RCHECK(reader->ReadBits(4, &temp[i]));
}
color_space->Set2To4BitDepthMap(temp);
break;
case 0x21:
for (int i = 0; i < 4; i++) {
RCHECK(reader->ReadBits(8, &temp[i]));
}
color_space->Set2To8BitDepthMap(temp);
break;
case 0x22:
for (int i = 0; i < 16; i++) {
RCHECK(reader->ReadBits(8, &temp[i]));
}
color_space->Set4To8BitDepthMap(temp);
break;
case 0xf0:
image->NewRow(is_top_fields);
break;
default:
LOG(ERROR) << "Unsupported DVB-sub pixel data format: 0x" << std::hex
<< static_cast<int>(data_type);
return false;
}
}
return true;
}
bool DvbSubParser::Parse2BitPixelData(bool is_top_fields,
BitReader* reader,
DvbImageBuilder* image) {
// 2-bit/pixel code string, Section 7.2.5.2.1, Table 22.
while (true) {
uint8_t peek;
RCHECK(reader->ReadBits(2, &peek));
if (peek != 0) {
RCHECK(image->AddPixel(BitDepth::k2Bit, peek, is_top_fields));
} else {
uint8_t switch_1;
RCHECK(reader->ReadBits(1, &switch_1));
if (switch_1 == 1) {
uint8_t count_minus_3;
RCHECK(reader->ReadBits(3, &count_minus_3));
RCHECK(reader->ReadBits(2, &peek));
for (uint8_t i = 0; i < count_minus_3 + 3; i++)
RCHECK(image->AddPixel(BitDepth::k2Bit, peek, is_top_fields));
} else {
uint8_t switch_2;
RCHECK(reader->ReadBits(1, &switch_2));
if (switch_2 == 1) {
RCHECK(image->AddPixel(BitDepth::k2Bit, 0, is_top_fields));
} else {
uint8_t switch_3;
RCHECK(reader->ReadBits(2, &switch_3));
if (switch_3 == 0) {
break;
} else if (switch_3 == 1) {
RCHECK(image->AddPixel(BitDepth::k2Bit, 0, is_top_fields));
RCHECK(image->AddPixel(BitDepth::k2Bit, 0, is_top_fields));
} else if (switch_3 == 2) {
uint8_t count_minus_12;
RCHECK(reader->ReadBits(4, &count_minus_12));
RCHECK(reader->ReadBits(2, &peek));
for (uint8_t i = 0; i < count_minus_12 + 12; i++)
RCHECK(image->AddPixel(BitDepth::k2Bit, peek, is_top_fields));
} else if (switch_3 == 3) {
uint8_t count_minus_29;
RCHECK(reader->ReadBits(8, &count_minus_29));
RCHECK(reader->ReadBits(2, &peek));
for (uint8_t i = 0; i < count_minus_29 + 29; i++)
RCHECK(image->AddPixel(BitDepth::k2Bit, peek, is_top_fields));
}
}
}
}
}
return true;
}
bool DvbSubParser::Parse4BitPixelData(bool is_top_fields,
BitReader* reader,
DvbImageBuilder* image) {
// 4-bit/pixel code string, Section 7.2.5.2.2, Table 24.
DCHECK(reader->bits_available() % 8 == 0);
while (true) {
uint8_t peek;
RCHECK(reader->ReadBits(4, &peek));
if (peek != 0) {
RCHECK(image->AddPixel(BitDepth::k4Bit, peek, is_top_fields));
} else {
uint8_t switch_1;
RCHECK(reader->ReadBits(1, &switch_1));
if (switch_1 == 0) {
RCHECK(reader->ReadBits(3, &peek));
if (peek != 0) {
for (int i = 0; i < peek + 2; i++)
RCHECK(image->AddPixel(BitDepth::k4Bit, 0, is_top_fields));
} else {
break;
}
} else {
uint8_t switch_2;
RCHECK(reader->ReadBits(1, &switch_2));
if (switch_2 == 0) {
RCHECK(reader->ReadBits(2, &peek)); // run_length_4-7
uint8_t code;
RCHECK(reader->ReadBits(4, &code));
for (int i = 0; i < peek + 4; i++)
RCHECK(image->AddPixel(BitDepth::k4Bit, code, is_top_fields));
} else {
uint8_t switch_3;
RCHECK(reader->ReadBits(2, &switch_3));
if (switch_3 == 0) {
RCHECK(image->AddPixel(BitDepth::k4Bit, 0, is_top_fields));
} else if (switch_3 == 1) {
RCHECK(image->AddPixel(BitDepth::k4Bit, 0, is_top_fields));
RCHECK(image->AddPixel(BitDepth::k4Bit, 0, is_top_fields));
} else if (switch_3 == 2) {
RCHECK(reader->ReadBits(4, &peek)); // run_length_9-24
uint8_t code;
RCHECK(reader->ReadBits(4, &code));
for (int i = 0; i < peek + 9; i++)
RCHECK(image->AddPixel(BitDepth::k4Bit, code, is_top_fields));
} else {
// switch_3 == 3
RCHECK(reader->ReadBits(8, &peek)); // run_length_25-280
uint8_t code;
RCHECK(reader->ReadBits(4, &code));
for (int i = 0; i < peek + 25; i++)
RCHECK(image->AddPixel(BitDepth::k4Bit, code, is_top_fields));
}
}
}
}
}
return true;
}
bool DvbSubParser::Parse8BitPixelData(bool is_top_fields,
BitReader* reader,
DvbImageBuilder* image) {
// 8-bit/pixel code string, Section 7.2.5.2.3, Table 26.
while (true) {
uint8_t peek;
RCHECK(reader->ReadBits(8, &peek));
if (peek != 0) {
RCHECK(image->AddPixel(BitDepth::k8Bit, peek, is_top_fields));
} else {
uint8_t switch_1;
RCHECK(reader->ReadBits(1, &switch_1));
if (switch_1 == 0) {
RCHECK(reader->ReadBits(7, &peek));
if (peek != 0) {
for (uint8_t i = 0; i < peek; i++)
RCHECK(image->AddPixel(BitDepth::k8Bit, 0, is_top_fields));
} else {
break;
}
} else {
uint8_t count;
RCHECK(reader->ReadBits(7, &count));
RCHECK(reader->ReadBits(8, &peek));
for (uint8_t i = 0; i < count; i++)
RCHECK(image->AddPixel(BitDepth::k8Bit, peek, is_top_fields));
}
}
}
return true;
}
} // namespace media
} // namespace shaka
Reference in New Issue View Git Blame Copy Permalink