Fix HEVC codec string encoding

Author: mondain

src/mp4_box.cpp

@@ -115,6 +115,32 @@ std::string hex_byte(std::uint8_t value) {
     return out.str();
 }
 
+std::string trim_trailing_zero_nibbles(std::uint32_t value) {
+    std::ostringstream out;
+    out << std::uppercase << std::hex << value;
+    std::string text = out.str();
+    while (text.size() > 1 && text.back() == '0') {
+        text.pop_back();
+    }
+    return text;
+}
+
+std::string hevc_constraint_string(std::span<const std::uint8_t, 6> constraint_bytes) {
+    std::size_t last_non_zero = constraint_bytes.size();
+    while (last_non_zero > 0 && constraint_bytes[last_non_zero - 1] == 0) {
+        --last_non_zero;
+    }
+    if (last_non_zero == 0) {
+        return {};
+    }
+
+    std::ostringstream out;
+    for (std::size_t index = 0; index < last_non_zero; ++index) {
+        out << hex_byte(constraint_bytes[index]);
+    }
+    return out.str();
+}
+
 std::size_t find_child_box_offset(const Mp4Box& sample_entry,
                                   std::span<const std::uint8_t> bytes,
                                   std::size_t child_offset,
@@ -172,32 +198,27 @@ std::string hevc_codec_string(const Mp4Box& sample_entry, std::span<const std::u
     const char profile_space = (profile_byte >> 6U) == 1 ? 'A' : (profile_byte >> 6U) == 2 ? 'B' : (profile_byte >> 6U) == 3 ? 'C' : '\0';
     const std::uint8_t profile_idc = profile_byte & 0x1FU;
     const std::uint32_t compatibility_flags = read_be32(bytes, hvcc_offset + 10);
-    const std::uint64_t constraint_indicator =
-        (static_cast<std::uint64_t>(bytes[hvcc_offset + 14]) << 40U) |
-        (static_cast<std::uint64_t>(bytes[hvcc_offset + 15]) << 32U) |
-        (static_cast<std::uint64_t>(bytes[hvcc_offset + 16]) << 24U) |
-        (static_cast<std::uint64_t>(bytes[hvcc_offset + 17]) << 16U) |
-        (static_cast<std::uint64_t>(bytes[hvcc_offset + 18]) << 8U) |
-        static_cast<std::uint64_t>(bytes[hvcc_offset + 19]);
     const std::uint8_t level_idc = bytes[hvcc_offset + 20];
+    const std::array<std::uint8_t, 6> constraint_bytes = {
+        bytes[hvcc_offset + 14],
+        bytes[hvcc_offset + 15],
+        bytes[hvcc_offset + 16],
+        bytes[hvcc_offset + 17],
+        bytes[hvcc_offset + 18],
+        bytes[hvcc_offset + 19],
+    };
 
     std::ostringstream out;
     out << sample_entry.type << '.';
     if (profile_space != '\0') {
         out << profile_space;
     }
     out << static_cast<unsigned int>(profile_idc) << '.'
-        << std::uppercase << std::hex << compatibility_flags << '.'
-        << ((bytes[hvcc_offset + 13] & 0x20U) != 0 ? 'H' : 'L') << static_cast<unsigned int>(level_idc);
-    if (constraint_indicator != 0) {
-        out << '.';
-        for (int shift = 40; shift >= 0; shift -= 8) {
-            const auto component = static_cast<std::uint8_t>((constraint_indicator >> shift) & 0xFFU);
-            if (component == 0 && shift != 0) {
-                continue;
-            }
-            out << hex_byte(component);
-        }
+        << trim_trailing_zero_nibbles(compatibility_flags) << '.'
+        << ((profile_byte & 0x20U) != 0 ? 'H' : 'L') << static_cast<unsigned int>(level_idc);
+    const std::string constraint_string = hevc_constraint_string(constraint_bytes);
+    if (!constraint_string.empty()) {
+        out << '.' << constraint_string;
     }
     return out.str();
 }

tests/cmaf_segmenter_test.cpp

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <iostream>
 #include <map>
+#include <array>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -236,6 +237,45 @@ std::vector<std::uint8_t> make_multitrack_init_mp4() {
     return concat({ftyp, moov});
 }
 
+std::vector<std::uint8_t> make_hevc_init_mp4(std::uint8_t general_profile_byte,
+                                             std::uint32_t compatibility_flags,
+                                             std::array<std::uint8_t, 6> constraint_bytes,
+                                             std::uint8_t level_idc) {
+    const auto ftyp = make_box("ftyp", {'i', 's', 'o', '6', 0, 0, 0, 1, 'i', 's', 'o', '6', 'c', 'm', 'f', 'c'});
+    const auto tkhd = make_full_box("tkhd",
+                                    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0});
+    const auto hdlr = make_full_box("hdlr", {0, 0, 0, 0, 'v', 'i', 'd', 'e', 0, 0, 0, 0});
+    auto video_header = std::vector<std::uint8_t>(70, 0);
+    video_header[24] = 0x01;
+    video_header[25] = 0x40;
+    video_header[26] = 0x00;
+    video_header[27] = 0xf0;
+
+    std::vector<std::uint8_t> hvcc_payload = {
+        0x01,
+        general_profile_byte,
+        static_cast<std::uint8_t>((compatibility_flags >> 24U) & 0xFFU),
+        static_cast<std::uint8_t>((compatibility_flags >> 16U) & 0xFFU),
+        static_cast<std::uint8_t>((compatibility_flags >> 8U) & 0xFFU),
+        static_cast<std::uint8_t>(compatibility_flags & 0xFFU),
+        constraint_bytes[0],
+        constraint_bytes[1],
+        constraint_bytes[2],
+        constraint_bytes[3],
+        constraint_bytes[4],
+        constraint_bytes[5],
+        level_idc,
+    };
+    const auto sample_entry = make_box("hev1", concat({video_header, make_box("hvcC", hvcc_payload)}));
+    const auto stsd = make_full_box("stsd", concat({std::vector<std::uint8_t>{0, 0, 0, 1}, sample_entry}));
+    const auto stbl = make_box("stbl", stsd);
+    const auto minf = make_box("minf", stbl);
+    const auto mdia = make_box("mdia", concat({hdlr, minf}));
+    const auto trak = make_box("trak", concat({tkhd, mdia}));
+    const auto moov = make_box("moov", trak);
+    return concat({ftyp, moov});
+}
+
 std::size_t find_after(std::string_view haystack, std::string_view needle, std::size_t start = 0) {
     const std::size_t pos = haystack.find(needle, start);
     return pos == std::string_view::npos ? pos : pos + needle.size();
@@ -485,5 +525,16 @@ int main() {
     ok &= expect(audio_init_boxes[0].type == "ftyp" && audio_init_boxes[1].type == "moov",
                  "expected audio initData to contain ftyp and moov boxes");
 
+    const auto hevc_main_bytes = make_hevc_init_mp4(0x01, 0x60000000, {0xB0, 0x00, 0x00, 0x00, 0x00, 0x00}, 90);
+    const auto hevc_high_bytes = make_hevc_init_mp4(0x22, 0x40000000, {0xB0, 0x00, 0x00, 0x00, 0x00, 0x00}, 150);
+    const auto hevc_main_tracks = extract_tracks(parse_mp4_boxes(hevc_main_bytes), hevc_main_bytes);
+    const auto hevc_high_tracks = extract_tracks(parse_mp4_boxes(hevc_high_bytes), hevc_high_bytes);
+    ok &= expect(hevc_main_tracks.size() == 1, "expected one HEVC main-profile track");
+    ok &= expect(hevc_high_tracks.size() == 1, "expected one HEVC high-tier track");
+    ok &= expect(hevc_main_tracks.front().codec == "hev1.1.6.L90.B0",
+                 "expected compact RFC 6381 HEVC main-profile codec string");
+    ok &= expect(hevc_high_tracks.front().codec == "hev1.2.4.H150.B0",
+                 "expected compact RFC 6381 HEVC high-tier codec string");
+
     return ok ? 0 : 1;
 }