Init mpv-joc

This commit is contained in:
TheM14 committed 2026-10-18 21:31:38 +08:00
commit 126e2cd233
52 files changed
+11035

No files matched your search

+453
View File
@@ -0,0 +1,453 @@
#include "eac3_scan.h"
#include <cstring>
namespace joc_eac3 {
namespace {
constexpr std::uint16_t kEac3Syncword = 0x0B77;
constexpr std::uint16_t kEmdfSyncword = 0x5838;
constexpr std::uint8_t kIdOamd = 11;
constexpr std::uint8_t kIdJoc = 14;
constexpr std::size_t kMaxPayloads = 16;
// MSB-first bit reader with an explicit limit, matching the core's reader
// semantics (reads past the limit fail rather than returning zeros).
class BitReader {
public:
BitReader(const std::uint8_t* data, std::size_t limit_bits, std::size_t start_bit)
: data_(data), limit_(limit_bits), position_(start_bit) {}
std::uint32_t read(unsigned count) {
std::uint32_t value = 0;
for (unsigned i = 0; i < count; ++i) {
if (position_ >= limit_) {
failed_ = true;
return 0;
}
const unsigned byte = data_[position_ >> 3];
value = (value << 1) | ((byte >> (7u - (position_ & 7u))) & 1u);
++position_;
}
return value;
}
bool skip(std::size_t count) {
if (position_ + count > limit_) {
failed_ = true;
return false;
}
position_ += count;
return true;
}
// value, then a continuation bit; an unterminated chain is a syntax error.
bool variable_bits(unsigned width, unsigned max_groups, std::uint32_t* out) {
std::uint32_t value = 0;
for (unsigned group = 0; group < max_groups; ++group) {
value += read(width);
if (failed_) return false;
const std::uint32_t more = read(1);
if (failed_) return false;
if (more == 0u) {
if (out != nullptr) *out = value;
return true;
}
value = (value + 1u) << width;
}
failed_ = true;
return false;
}
std::size_t position() const { return position_; }
bool failed() const { return failed_; }
void set_failed() { failed_ = true; }
private:
const std::uint8_t* data_ = nullptr;
std::size_t limit_ = 0;
std::size_t position_ = 0;
bool failed_ = false;
};
struct Payload {
std::uint8_t id = 0;
std::size_t bit_offset = 0;
std::size_t size = 0;
};
struct Container {
std::size_t start_bit = 0;
std::size_t raw_size = 0;
std::size_t payload_count = 0;
Payload payloads[kMaxPayloads] = {};
bool has(std::uint8_t id) const {
for (std::size_t i = 0; i < payload_count; ++i) {
if (payloads[i].id == id) return true;
}
return false;
}
};
bool parse_container(const std::uint8_t* data, std::size_t size_bits, std::size_t start_bit,
Container* out) {
if (start_bit + 16u > size_bits) return false;
BitReader reader(data, size_bits, start_bit);
if (reader.read(16) != kEmdfSyncword) return false;
const std::uint32_t length = reader.read(16);
const std::size_t body_start = reader.position();
const std::size_t body_end = body_start + static_cast<std::size_t>(length) * 8u;
if (reader.failed() || body_end > size_bits) return false;
BitReader body(data, body_end, body_start);
std::uint32_t version = body.read(2);
if (body.failed()) return false;
if (version == 3u) {
std::uint32_t extra = 0;
if (!body.variable_bits(2, 8, &extra)) return false;
version += extra;
}
std::uint32_t key_id = body.read(3);
if (body.failed()) return false;
if (key_id == 7u) {
std::uint32_t extra = 0;
if (!body.variable_bits(3, 8, &extra)) return false;
key_id += extra;
}
// TS 103 420 JOC is version 0 / key_id 0; the strict check also rejects
// false 0x5838 markers that happen to sit inside audio data.
if (version != 0u || key_id != 0u) return false;
Container container;
container.start_bit = start_bit;
bool terminated = false;
while (body.position() + 5u <= body_end) {
std::uint32_t payload_id = body.read(5);
if (body.failed()) return false;
if (payload_id == 0u) {
terminated = true;
break;
}
if (payload_id == 0x1Fu) {
std::uint32_t extra = 0;
if (!body.variable_bits(5, 8, &extra)) return false;
payload_id += extra;
}
for (std::size_t i = 0; i < container.payload_count; ++i) {
if (container.payloads[i].id == static_cast<std::uint8_t>(payload_id)) return false;
}
if (container.payload_count >= kMaxPayloads) return false;
const std::uint32_t has_sample_offset = body.read(1);
if (body.failed()) return false;
if (has_sample_offset != 0u) {
(void)body.read(12);
}
if (body.read(1) != 0u) {
std::uint32_t ignored = 0;
if (!body.variable_bits(11, 8, &ignored)) return false;
}
if (body.read(1) != 0u) {
std::uint32_t ignored = 0;
if (!body.variable_bits(2, 8, &ignored)) return false;
}
if (body.read(1) != 0u) {
if (!body.skip(8)) return false;
}
if (body.failed()) return false;
if (body.read(1) == 0u) {
bool frame_aligned = false;
if (has_sample_offset == 0u) {
frame_aligned = body.read(1) != 0u;
if (frame_aligned && !body.skip(2)) return false;
}
if ((has_sample_offset != 0u || frame_aligned) && !body.skip(7)) return false;
}
if (body.failed()) return false;
std::uint32_t payload_size = 0;
if (!body.variable_bits(8, 8, &payload_size)) return false;
const std::size_t payload_bits = static_cast<std::size_t>(payload_size) * 8u;
if (body.position() + payload_bits > body_end) return false;
Payload& entry = container.payloads[container.payload_count++];
entry.id = static_cast<std::uint8_t>(payload_id);
entry.bit_offset = body.position();
entry.size = payload_size;
if (!body.skip(payload_bits)) return false;
}
if (!terminated) return false;
container.raw_size = 4u + static_cast<std::size_t>(length);
*out = container;
return true;
}
// Candidate 0x5838 positions over the eight bit alignments, ascending.
void marker_offsets(const std::uint8_t* data, std::size_t size, std::size_t* out,
std::size_t capacity, std::size_t* count) {
*count = 0;
if (size < 4u) return;
for (std::size_t shift = 0; shift < 8u; ++shift) {
const std::size_t aligned_len = (shift == 0u) ? size : (size - 1u);
for (std::size_t i = 0; i + 1u < aligned_len; ++i) {
std::uint8_t first = 0;
std::uint8_t second = 0;
if (shift == 0u) {
first = data[i];
second = data[i + 1u];
} else {
first = static_cast<std::uint8_t>(
((static_cast<std::uint16_t>(data[i]) << shift) |
(static_cast<std::uint16_t>(data[i + 1u]) >> (8u - shift))) &
0xFFu);
second = static_cast<std::uint8_t>(
((static_cast<std::uint16_t>(data[i + 1u]) << shift) |
(static_cast<std::uint16_t>(data[i + 2u]) >> (8u - shift))) &
0xFFu);
}
if (first == 0x58u && second == 0x38u) {
if (*count < capacity) out[(*count)++] = i * 8u + shift;
}
}
}
}
bool contains_payload(const std::uint8_t* frame, std::size_t size, std::uint8_t wanted,
std::size_t* first_bit) {
for (std::size_t at = 0; at + 1u < size; ++at) {
if (frame[at] != 0x58u || frame[at + 1u] != 0x38u) continue;
Container container;
if (parse_container(frame, size * 8u, at * 8u, &container) && container.has(wanted)) {
if (first_bit != nullptr) *first_bit = at * 8u;
return true;
}
}
for (std::size_t shift = 1; shift < 8u; ++shift) {
const std::size_t aligned_len = size - 1u;
for (std::size_t i = 0; i + 1u < aligned_len; ++i) {
const std::uint8_t first = static_cast<std::uint8_t>(
((static_cast<std::uint16_t>(frame[i]) << shift) |
(static_cast<std::uint16_t>(frame[i + 1u]) >> (8u - shift))) &
0xFFu);
const std::uint8_t second = static_cast<std::uint8_t>(
((static_cast<std::uint16_t>(frame[i + 1u]) << shift) |
(static_cast<std::uint16_t>(frame[i + 2u]) >> (8u - shift))) &
0xFFu);
if (first != 0x58u || second != 0x38u) continue;
Container container;
if (parse_container(frame, size * 8u, i * 8u + shift, &container) &&
container.has(wanted)) {
if (first_bit != nullptr) *first_bit = i * 8u + shift;
return true;
}
}
}
return false;
}
} // namespace
namespace {
std::uint32_t read_bits(const std::uint8_t* data, std::size_t start, std::size_t count) {
std::uint32_t value = 0;
for (std::size_t index = start; index < start + count; ++index) {
value = (value << 1) | ((data[index >> 3] >> (7u - (index & 7u))) & 1u);
}
return value;
}
// AC-3 syncframe length in 16-bit words, indexed by fscod then frmsizecod.
const std::uint16_t kAc3FrameWords[3][38] = {
{64, 64, 80, 80, 96, 96, 112, 112, 128, 128, 160, 160, 192, 192, 224, 224,
256, 256, 320, 320, 384, 384, 448, 448, 512, 512, 640, 640, 768, 768,
896, 896, 1024, 1024, 1152, 1152, 1280, 1280},
{69, 70, 87, 88, 104, 105, 121, 122, 139, 140, 174, 175, 208, 209, 243, 244,
278, 278, 348, 348, 417, 418, 487, 487, 557, 557, 696, 696, 835, 835,
975, 975, 1114, 1114, 1253, 1253, 1393, 1393},
{96, 96, 120, 120, 144, 144, 168, 168, 192, 192, 240, 240, 288, 288, 336, 336,
384, 384, 480, 480, 576, 576, 672, 672, 768, 768, 960, 960, 1152, 1152,
1344, 1344, 1536, 1536, 1728, 1728, 1920, 1920},
};
} // namespace
std::size_t frame_header_at(const std::uint8_t* data, std::size_t size, std::size_t offset,
FrameHeader* out) {
if (data == nullptr || offset + 6u > size) return 0;
const std::uint16_t syncword =
static_cast<std::uint16_t>((static_cast<std::uint16_t>(data[offset]) << 8) | data[offset + 1]);
if (syncword != kEac3Syncword) return 0;
const std::size_t base = offset * 8u;
const std::uint32_t bsid = read_bits(data, base + 40u, 5u);
if (bsid <= 8u) {
const std::uint32_t fscod = read_bits(data, base + 32u, 2u);
const std::uint32_t frmsizecod = read_bits(data, base + 34u, 6u);
if (fscod > 2u || frmsizecod >= 38u) return 0;
if (out != nullptr) {
out->frame_bytes = static_cast<std::size_t>(kAc3FrameWords[fscod][frmsizecod]) * 2u;
out->offset = offset;
out->codec = 0;
out->strmtyp = 0;
out->substreamid = 0;
}
return static_cast<std::size_t>(kAc3FrameWords[fscod][frmsizecod]) * 2u;
}
const std::size_t words =
(static_cast<std::size_t>(data[offset + 2] & 0x07u) << 8) | data[offset + 3];
if (out != nullptr) {
out->frame_bytes = (words + 1u) * 2u;
out->offset = offset;
out->codec = 1;
out->strmtyp = static_cast<std::uint8_t>(read_bits(data, base + 16u, 2u));
out->substreamid = static_cast<std::uint8_t>(read_bits(data, base + 18u, 3u));
}
return (words + 1u) * 2u;
}
std::size_t frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset) {
return frame_header_at(data, size, offset, nullptr);
}
std::size_t audio_frame_bytes_at(const std::uint8_t* data, std::size_t size, std::size_t offset,
bool end_of_stream) {
constexpr std::size_t kMaxSubstreams = 8;
FrameHeader seen[kMaxSubstreams];
std::size_t count = 0;
std::size_t consumed = 0;
while (count < kMaxSubstreams) {
FrameHeader header;
const std::size_t bytes = frame_header_at(data, size, offset + consumed, &header);
if (bytes == 0 || offset + consumed + bytes > size) break;
bool repeats = false;
for (std::size_t index = 0; index < count; ++index) {
if (seen[index].same_stream(header)) {
repeats = true;
break;
}
}
if (repeats) return consumed;
seen[count++] = header;
consumed += bytes;
}
if (count != 0u && consumed != 0u && end_of_stream) return consumed;
return 0;
}
bool joc_config_idx(const std::uint8_t* frame, std::size_t frame_bytes, unsigned* out) {
if (out == nullptr || frame == nullptr || frame_bytes < 8u) return false;
std::size_t offsets[4096];
std::size_t count = 0;
marker_offsets(frame, frame_bytes, offsets, 4096, &count);
for (std::size_t i = 0; i < count; ++i) {
Container candidate;
if (!parse_container(frame, frame_bytes * 8u, offsets[i], &candidate)) continue;
if (!candidate.has(kIdOamd) || !candidate.has(kIdJoc)) continue;
for (std::size_t p = 0; p < candidate.payload_count; ++p) {
if (candidate.payloads[p].id != kIdJoc) continue;
// joc_dmx_config_idx is the first 3 bits of the JOC payload, followed by
// joc_num_objects_bits (6) and joc_ext_config_idx (3).
const std::size_t bit = candidate.payloads[p].bit_offset;
std::uint32_t value = 0;
for (unsigned index = 0; index < 3u; ++index) {
const std::size_t position = bit + index;
if (position / 8u >= frame_bytes) return false;
value = (value << 1) | ((frame[position / 8u] >> (7u - (position % 8u))) & 1u);
}
*out = value;
return true;
}
}
return false;
}
bool frame_has_joc(const std::uint8_t* frame, std::size_t frame_bytes) {
if (frame == nullptr || frame_bytes < 8u) return false;
std::size_t offsets[4096];
std::size_t count = 0;
marker_offsets(frame, frame_bytes, offsets, 4096, &count);
Container matches[16];
std::size_t match_count = 0;
for (std::size_t i = 0; i < count; ++i) {
Container candidate;
if (!parse_container(frame, frame_bytes * 8u, offsets[i], &candidate)) continue;
if (candidate.has(kIdOamd) && candidate.has(kIdJoc)) {
if (match_count < 16) matches[match_count++] = candidate;
}
}
if (match_count == 0) return false;
// A payload may contain bytes that look like another container; only
// top-level ones count.
Container top_level[16];
std::size_t top_count = 0;
for (std::size_t i = 0; i < match_count; ++i) {
bool nested = false;
for (std::size_t j = 0; j < top_count; ++j) {
if (top_level[j].start_bit < matches[i].start_bit &&
matches[i].start_bit < top_level[j].start_bit + top_level[j].raw_size * 8u) {
nested = true;
break;
}
}
if (!nested && top_count < 16) top_level[top_count++] = matches[i];
}
// Exactly one is what the core requires; more than one is ambiguous there.
return top_count == 1u;
}
ScanResult scan(const std::uint8_t* data, std::size_t size, std::size_t max_frames) {
ScanResult result;
if (data == nullptr || size < 8u) {
result.detail = "buffer too small";
return result;
}
std::size_t offset = 0;
std::size_t frames = 0;
std::size_t with_joc = 0;
bool first = true;
while (frames < max_frames) {
const std::size_t frame_bytes = frame_bytes_at(data, size, offset);
if (frame_bytes == 0) {
result.detail = frames == 0 ? "no E-AC-3 syncword at the start" : "stream walk ended";
break;
}
if (offset + frame_bytes > size) {
result.detail = "buffer ends inside a syncframe";
break;
}
if (first) {
result.first_frame_bytes = frame_bytes;
first = false;
} else if (frame_bytes != result.first_frame_bytes) {
result.all_frames_same_size = false;
}
if (frame_has_joc(data + offset, frame_bytes)) ++with_joc;
++frames;
offset += frame_bytes;
}
result.frames_examined = frames;
result.frames_with_joc = with_joc;
if (frames == 0) {
result.joc = JocState::kUnknown;
if (result.detail[0] == '\0') result.detail = "no syncframes";
} else if (with_joc != 0) {
result.joc = JocState::kYes;
result.detail = (with_joc == frames)
? "every examined syncframe carries the JOC EMDF container"
: "the JOC EMDF container is present in part of the examined "
"audio frames (dependent substream or a late first frame)";
} else {
result.joc = JocState::kNo;
result.detail = "no examined syncframe carries a JOC EMDF container";
}
return result;
}
} // namespace joc_eac3