mtmd.hpp

Go to the documentation of this file.

#pragma once
 
// SPDX-License-Identifier: LicenseRef-FSL-1.1-Apache-2.0
// Copyright 2026 Lloyal Labs
 
#include "decode.hpp"
 
#include <mtmd.h>
#include <mtmd-helper.h>
 
#include <algorithm>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <limits>
#include <memory>
#include <numeric>
#include <optional>
#include <span>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace lloyal {
 
// The text struct is filled field by field below; a new upstream field would be
// value-initialised to zero without a word. Fail the build instead: the size on
// 64-bit, and the member count, which padding cannot hide.
#if INTPTR_MAX == INT64_MAX
static_assert(sizeof(mtmd_input_text) == 24, "mtmd_input_text changed shape: revisit MtmdSource's construction");
#endif
namespace shape_guard {
inline void mtmd_input_text_has_four_members() {
  [[maybe_unused]] auto [text, text_len, add_special, parse_special] = mtmd_input_text{};
}
}  // namespace shape_guard
 
struct VideoNote {
  int64_t at_ms = 0;
  std::string_view text;
};
 
struct VideoFrames {
  std::span<const std::span<const uint8_t>> frames;
  std::span<const int64_t> timestamps_ms;
  int64_t timestamp_interval_ms = 5000;
  std::span<const VideoNote> notes;
};
 
struct MediaInput {
  enum class Kind { Image, Audio, Video };
  Kind kind;
  std::span<const uint8_t> bytes;
  VideoFrames video{};
};
 
struct AudioLimits {
  size_t max_bytes = 0;
  size_t max_samples = 0;
};
 
namespace mtmd_detail {
 
inline bool tag(std::span<const uint8_t> bytes, size_t offset, const char* value) {
  return offset <= bytes.size() && bytes.size() - offset >= 4 &&
         std::memcmp(bytes.data() + offset, value, 4) == 0;
}
 
inline uint16_t u16(std::span<const uint8_t> bytes, size_t offset) {
  if (offset > bytes.size() || bytes.size() - offset < 2) {
    throw std::runtime_error("MtmdSource - truncated PCM WAV");
  }
  return static_cast<uint16_t>(bytes[offset] | (uint16_t(bytes[offset + 1]) << 8));
}
 
inline uint32_t u32(std::span<const uint8_t> bytes, size_t offset) {
  return uint32_t(u16(bytes, offset)) | (uint32_t(u16(bytes, offset + 2)) << 16);
}
 
// The pinned helper's audio sniff is private. Refuse its audio signatures on
// the image entry point before it can allocate a decoded recording.
inline bool encoded_audio(std::span<const uint8_t> bytes) {
  if (bytes.size() < 12) return false;
  return (tag(bytes, 0, "RIFF") && tag(bytes, 8, "WAVE")) ||
         tag(bytes, 0, "fLaC") || std::memcmp(bytes.data(), "ID3", 3) == 0 ||
         (bytes[0] == 0xff && (bytes[1] & 0xe0) == 0xe0);
}
 
// Inspect framing only; the existing mtmd/miniaudio helper still owns sample
// conversion and resampling. Restrict the admitted format to integer PCM WAV.
inline size_t wav_sample_bound(std::span<const uint8_t> bytes, uint32_t target_rate) {
  if (bytes.size() < 12 || !tag(bytes, 0, "RIFF") || !tag(bytes, 8, "WAVE") ||
      u32(bytes, 4) != bytes.size() - 8) {
    throw std::runtime_error("MtmdSource - invalid PCM WAV container");
  }
  std::span<const uint8_t> format;
  std::span<const uint8_t> data;
  bool found_data = false;
  for (size_t offset = 12; offset < bytes.size();) {
    if (bytes.size() - offset < 8) {
      throw std::runtime_error("MtmdSource - truncated WAV chunk");
    }
    const size_t length = u32(bytes, offset + 4);
    const size_t remaining = bytes.size() - offset - 8;
    const size_t padding = length & 1;
    if (length > remaining || padding > remaining - length) {
      throw std::runtime_error("MtmdSource - truncated WAV chunk");
    }
    const size_t padded = length + padding;
    const auto chunk = bytes.subspan(offset + 8, length);
    if (tag(bytes, offset, "fmt ")) {
      if (!format.empty() || (length != 16 && length != 18)) {
        throw std::runtime_error("MtmdSource - invalid WAV format chunk");
      }
      format = chunk;
    } else if (tag(bytes, offset, "data")) {
      if (format.empty() || found_data) {
        throw std::runtime_error("MtmdSource - invalid WAV data chunk");
      }
      data = chunk;
      found_data = true;
    } else if (!tag(bytes, offset, "JUNK") &&
               !(tag(bytes, offset, "LIST") && tag(chunk, 0, "INFO"))) {
      throw std::runtime_error("MtmdSource - unsupported WAV chunk");
    }
    offset += 8 + padded;
  }
  if (format.empty() || !found_data || u16(format, 0) != 1 ||
      (format.size() == 18 && u16(format, 16) != 0)) {
    throw std::runtime_error("MtmdSource - expected integer PCM WAV");
  }
  const uint32_t channels = u16(format, 2);
  const uint32_t rate = u32(format, 4);
  const uint32_t bits = u16(format, 14);
  const bool integer_pcm = bits == 8 || bits == 16 || bits == 24 || bits == 32;
  const uint32_t alignment = channels * (bits / 8);
  if (!channels || !rate || !integer_pcm || !alignment ||
      u16(format, 12) != alignment || u32(format, 8) != uint64_t(rate) * alignment ||
      data.size() % alignment != 0) {
    throw std::runtime_error("MtmdSource - inconsistent PCM WAV format");
  }
  const uint64_t frames = data.size() / alignment;
  // b9581's miniaudio may allocate floor(ratio * frames) + 1 after resampling.
  const uint64_t samples = rate == target_rate ? frames : frames * target_rate / rate + 1;
  if (frames < 2 || samples < 2 ||
      samples > std::numeric_limits<int32_t>::max() / sizeof(float)) {
    throw std::runtime_error("MtmdSource - unsupported audio sample count");
  }
  return static_cast<size_t>(samples);
}
 
// The helper's timestamp text, character for character ("[%dm%.2fs]").
inline std::string timestamp_text(int64_t ms) {
  const float elapsed_s = static_cast<float>(ms) / 1000.0f;
  // Minutes as 64-bit: any int64 millisecond count fits, where the helper's int would overflow.
  const int64_t minutes = static_cast<int64_t>(elapsed_s / 60);
  const float seconds = elapsed_s - static_cast<float>(minutes) * 60.0f;
  char buf[48];
  std::snprintf(buf, sizeof buf, "[%lldm%.2fs]", static_cast<long long>(minutes), seconds);
  return buf;
}
 
struct VideoLayout {
  struct Part {
    ::mtmd::bitmap_ptr frame;
    std::string text;
  };
  std::vector<Part> parts;
 
  static int next(size_t i, void* self, mtmd_bitmap** out_bitmap, char** out_text) {
    auto& parts = static_cast<VideoLayout*>(self)->parts;
    if (i >= parts.size()) return -1;
    auto& part = parts[i];
    if (part.frame) {
      *out_bitmap = part.frame.release();
      return 0;
    }
    // mtmd frees the text with free(); malloc is the portable strdup (MSVC deprecates the POSIX name).
    const size_t size = part.text.size() + 1;
    *out_text = static_cast<char*>(std::malloc(size));
    if (!*out_text) return -2;
    std::memcpy(*out_text, part.text.c_str(), size);
    return 0;
  }
};
 
inline VideoLayout video_layout(std::vector<::mtmd::bitmap_ptr> frames, const VideoFrames& video) {
  std::vector<VideoNote> notes(video.notes.begin(), video.notes.end());
  std::stable_sort(notes.begin(), notes.end(),
                   [](const VideoNote& a, const VideoNote& b) { return a.at_ms < b.at_ms; });
  auto note = notes.begin();
  const auto notes_until = [&](auto stop) {
    std::string text;
    for (; note != notes.end() && stop(*note); ++note) text += note->text;
    return text;
  };
 
  VideoLayout layout;
  layout.parts.push_back({nullptr, "Video:"});
  // The next threshold, counted from the first frame (see VideoFrames), or none
  // once it would lie past any time an int64 can hold.
  std::optional<int64_t> next_timestamp_ms =
      video.timestamp_interval_ms > 0 ? std::optional<int64_t>{video.timestamps_ms.front()} : std::nullopt;
  for (size_t i = 0; i < frames.size(); ++i) {
    layout.parts.push_back({std::move(frames[i]), {}});
    const int64_t t = video.timestamps_ms[i];
    if (next_timestamp_ms && t >= *next_timestamp_ms) {
      layout.parts.push_back({nullptr, timestamp_text(t) +
                                       notes_until([t](const VideoNote& n) { return n.at_ms <= t; })});
      const bool exhausted = *next_timestamp_ms > std::numeric_limits<int64_t>::max() - video.timestamp_interval_ms;
      next_timestamp_ms = exhausted ? std::nullopt : std::optional<int64_t>{*next_timestamp_ms + video.timestamp_interval_ms};
    }
  }
  if (auto closing = notes_until([](const VideoNote&) { return true; }); !closing.empty()) {
    layout.parts.push_back({nullptr, std::move(closing)});
  }
  return layout;
}
 
inline std::vector<MediaInput> image_inputs(const std::vector<std::vector<uint8_t>>& images) {
  std::vector<MediaInput> inputs;
  inputs.reserve(images.size());
  for (const auto& bytes : images) inputs.push_back({MediaInput::Kind::Image, bytes});
  return inputs;
}
 
} // namespace mtmd_detail
 
class MtmdSource final : public decode::SegmentSource {
public:
  MtmdSource(mtmd_context* ctx,
             const std::string& prompt,
             const std::vector<std::vector<uint8_t>>& images,
             std::span<const llama_token> sep,
             int32_t n_embd_inp,
             bool add_special = false)
      : MtmdSource(ctx, prompt, mtmd_detail::image_inputs(images), sep, n_embd_inp, {}, add_special) {}
 
  MtmdSource(mtmd_context* ctx,
             const std::string& prompt,
             std::span<const MediaInput> inputs,
             std::span<const llama_token> sep,
             int32_t n_embd_inp,
             AudioLimits limits,
             bool add_special = false)
      : ctx_(ctx), sep_(sep), n_embd_inp_(n_embd_inp) {
    if (!ctx_) throw std::runtime_error("MtmdSource - NULL mtmd context");
    if (n_embd_inp_ <= 0) throw std::runtime_error("MtmdSource - invalid embedding width");
    validate_markers(prompt, inputs.size());
    const auto sample_bounds = validate_inputs(inputs, limits);
 
    // A video is one lazy bitmap at its marker, expanded by mtmd_tokenize into
    // its frames and timestamps: the mechanism llama.cpp's video helper uses.
    std::vector<std::unique_ptr<mtmd_detail::VideoLayout>> videos;
    std::vector<const mtmd_bitmap*> ptrs;
    ptrs.reserve(inputs.size());
    for (size_t i = 0; i < inputs.size(); ++i) {
      const auto& input = inputs[i];
      if (input.kind == MediaInput::Kind::Video) {
        videos.push_back(std::make_unique<mtmd_detail::VideoLayout>(
            mtmd_detail::video_layout(decode_frames(input.video, i), input.video)));
        auto* lazy = mtmd_bitmap_init_lazy(ctx_, "", videos.back().get(),
                                           &mtmd_detail::VideoLayout::next);
        if (!lazy) throw std::runtime_error("MtmdSource - video layout failed");
        bitmaps_.emplace_back(lazy);
        ptrs.push_back(lazy);
        continue;
      }
      auto wrap = decode_media(input.bytes, i);
      bitmaps_.emplace_back(wrap);
      name_input(wrap, i);
      const bool audio = input.kind == MediaInput::Kind::Audio;
      if (mtmd_bitmap_is_audio(wrap) != audio) {
        throw std::runtime_error("MtmdSource - decoded media kind does not match input");
      }
      if (audio && (mtmd_bitmap_get_nx(wrap) < 2 ||
                    mtmd_bitmap_get_nx(wrap) > sample_bounds[i])) {
        throw std::runtime_error("MtmdSource - decoded audio exceeds validated sample bound");
      }
      ptrs.push_back(wrap);
    }
 
    chunks_.reset(mtmd_input_chunks_init());
    // Named on purpose: a positional initialiser compiled unchanged when upstream
    // inserted text_len and silently meant text length false, add_special true.
    mtmd_input_text txt{};
    txt.text = prompt.c_str();
    txt.text_len = prompt.size();
    txt.add_special = add_special;
    txt.parse_special = true;
    if (mtmd_tokenize(ctx_, chunks_.get(), &txt, ptrs.data(), ptrs.size()) != 0) {
      throw std::runtime_error("MtmdSource - media preprocessing failed");
    }
    mrope_ = mtmd_decode_use_mrope(ctx_);
    n_chunks_ = mtmd_input_chunks_size(chunks_.get());
    lead_ = sep_.empty() ? 0 : 1;
    cells_ = 0;
    for (size_t i = 0; i < size(); ++i) {
      if (i >= lead_) {
        const auto kind = mtmd_input_chunk_get_type(chunk_at(i));
        if (kind != MTMD_INPUT_CHUNK_TYPE_TEXT && kind != MTMD_INPUT_CHUNK_TYPE_IMAGE &&
            kind != MTMD_INPUT_CHUNK_TYPE_AUDIO) {
          throw std::runtime_error("MtmdSource - unsupported media chunk");
        }
      }
      const size_t rows = cells_at(i);
      if (rows > std::numeric_limits<int32_t>::max() ||
          rows > std::numeric_limits<size_t>::max() - cells_) {
        throw std::runtime_error("MtmdSource - media token count overflow");
      }
      cells_ += rows;
    }
    map_inputs(inputs.size());
  }
 
  size_t size() override { return lead_ + n_chunks_; }
 
  size_t cells() const override { return cells_; }
 
  int32_t input_of(size_t i) const override { return i < input_of_.size() ? input_of_[i] : -1; }
 
  size_t total_of(int32_t input) const override {
    return input >= 0 && static_cast<size_t>(input) < total_of_.size() ? total_of_[input] : 0;
  }
 
  decode::Segment at(size_t i) override {
    decode::Segment seg;
 
    if (lead_ != 0 && i == 0) {
      seg.kind   = decode::Segment::Kind::Text;
      seg.tokens = sep_;
      return seg;
    }
 
    const mtmd_input_chunk* chunk = chunk_at(i);
    switch (mtmd_input_chunk_get_type(chunk)) {
      case MTMD_INPUT_CHUNK_TYPE_TEXT: {
        size_t n_text = 0;
        const llama_token* toks =
            mtmd_input_chunk_get_tokens_text(chunk, &n_text);
        seg.kind   = decode::Segment::Kind::Text;
        seg.tokens = std::span<const llama_token>(toks, n_text);
        return seg;
      }
 
      case MTMD_INPUT_CHUNK_TYPE_IMAGE:
      case MTMD_INPUT_CHUNK_TYPE_AUDIO: {
        if (mtmd_encode_chunk(ctx_, chunk) != 0) {
          throw std::runtime_error("MtmdSource - media encode failed");
        }
        seg.kind = decode::Segment::Kind::Embd;
        // Context-owned buffer, reused by the next encode — the in-order
        // contract is what makes handing it out safe.
        seg.rows           = mtmd_get_output_embd(ctx_);
        seg.n_rows         = static_cast<int32_t>(
            mtmd_input_chunk_get_n_tokens(chunk));
        seg.n_embd_inp     = n_embd_inp_;
        seg.n_pos          = mtmd_input_chunk_get_n_pos(chunk);
        seg.n_pos_per_embd = mrope_ ? 4 : 1;
        seg.non_causal     = mtmd_decode_use_non_causal(ctx_, chunk);
        return seg;
      }
 
      default:
        throw std::runtime_error("MtmdSource - unsupported media chunk");
    }
  }
 
  void positions(size_t i, llama_pos base, llama_pos* out) override {
    const mtmd_input_chunk* chunk = chunk_at(i);
    const int32_t n =
        static_cast<int32_t>(mtmd_input_chunk_get_n_tokens(chunk));
 
    if (!mrope_ || mtmd_input_chunk_get_type(chunk) == MTMD_INPUT_CHUNK_TYPE_AUDIO) {
      if (int64_t(base) + n > std::numeric_limits<llama_pos>::max()) {
        throw std::runtime_error("MtmdSource - media position overflow");
      }
      const size_t axes = mrope_ ? 4 : 1;
      for (size_t axis = 0; axis < axes; ++axis) {
        std::iota(out + axis * n, out + (axis + 1) * n, base);
      }
      return;
    }
 
    const mtmd_image_tokens* img = mtmd_input_chunk_get_tokens_image(chunk);
    if (!img) {
      throw std::runtime_error("MtmdSource - image tokens missing");
    }
 
    // The impl applies `base` itself (the header's "relative position" note
    // is stale) and the rules differ per model — M-RoPE freezes t and leaves
    // z at 0, HunyuanVL uses row/col — which is exactly why the base is
    // passed in rather than the geometry passed out.
    rel_.resize(static_cast<size_t>(n));
    mtmd_helper_image_get_decoder_pos(img, base, rel_.data());
 
    // Section-major, and note the order: mtmd's decoder convention puts
    // y in section 1 and x in section 2.
    for (int32_t k = 0; k < n; ++k) {
      out[k]                                  = static_cast<llama_pos>(rel_[k].t);
      out[k + n]                              = static_cast<llama_pos>(rel_[k].y);
      out[k + static_cast<size_t>(2) * n]     = static_cast<llama_pos>(rel_[k].x);
      out[k + static_cast<size_t>(3) * n]     = static_cast<llama_pos>(rel_[k].z);
    }
  }
 
private:
  mtmd_bitmap* decode_media(std::span<const uint8_t> bytes, size_t index) const {
    auto wrap = mtmd_helper_bitmap_init_from_buf(
        ctx_, bytes.data(), bytes.size(), /*placeholder*/ false, mtmd_helper_init_opt_default());
    if (wrap.video_ctx) {
      mtmd_helper_video_free(wrap.video_ctx);
      if (wrap.bitmap) mtmd_bitmap_free(wrap.bitmap);
      throw std::runtime_error("MtmdSource - a video container is not an input; pass its frames");
    }
    if (!wrap.bitmap) {
      throw std::runtime_error("MtmdSource - unsupported media bytes at input " + std::to_string(index));
    }
    return wrap.bitmap;
  }
 
  std::vector<::mtmd::bitmap_ptr> decode_frames(const VideoFrames& video, size_t input) const {
    std::vector<::mtmd::bitmap_ptr> frames;
    frames.reserve(video.frames.size());
    for (size_t k = 0; k < video.frames.size(); ++k) {
      frames.emplace_back(decode_media(video.frames[k], k));
      auto* frame = frames.back().get();
      name_input(frame, input);
      if (mtmd_bitmap_is_audio(frame)) {
        throw std::runtime_error("MtmdSource - decoded media kind does not match input");
      }
      if (mtmd_bitmap_get_nx(frame) != mtmd_bitmap_get_nx(frames.front().get()) ||
          mtmd_bitmap_get_ny(frame) != mtmd_bitmap_get_ny(frames.front().get())) {
        throw std::runtime_error("MtmdSource - video frames must share one size");
      }
      mtmd_bitmap_set_mergeable(frame, true);
    }
    return frames;
  }
 
  void validate_video(const VideoFrames& video) const {
    if (!mtmd_support_vision(ctx_)) {
      throw std::runtime_error("MtmdSource - projector does not support image input");
    }
    if (video.frames.empty()) {
      throw std::runtime_error("MtmdSource - a video needs at least one frame");
    }
    if (video.timestamps_ms.size() != video.frames.size()) {
      throw std::runtime_error("MtmdSource - a video needs one timestamp per frame");
    }
    const auto& t = video.timestamps_ms;
    if (t.front() < 0 || std::adjacent_find(t.begin(), t.end(), std::greater_equal<int64_t>()) != t.end()) {
      throw std::runtime_error("MtmdSource - video timestamps must increase");
    }
    if (video.timestamp_interval_ms < 0) {
      throw std::runtime_error("MtmdSource - video timestamp interval must not be negative");
    }
    const int64_t start = t.front();
    if (std::any_of(video.notes.begin(), video.notes.end(), [start](const VideoNote& n) { return n.at_ms < start; })) {
      throw std::runtime_error("MtmdSource - video notes must not precede the clip");
    }
    for (const auto& frame : video.frames) {
      if (mtmd_detail::encoded_audio(frame)) {
        throw std::runtime_error("MtmdSource - audio bytes require a typed audio input");
      }
    }
  }
 
  void validate_markers(const std::string& prompt, size_t count) const {
    const std::string marker = mtmd_get_marker(ctx_);
    size_t markers = 0;
    if (!marker.empty()) {
      for (size_t p = prompt.find(marker); p != std::string::npos;
           p = prompt.find(marker, p + marker.size())) ++markers;
    }
    // Upstream folds a marker mismatch into a generic preprocessing error.
    if (markers != count) {
      throw std::runtime_error("MtmdSource - media marker count (" + std::to_string(markers) +
                               ") does not match media count (" + std::to_string(count) + ")");
    }
  }
 
  std::vector<size_t> validate_inputs(std::span<const MediaInput> inputs, AudioLimits limits) const {
    std::vector<size_t> samples(inputs.size(), 0);
    size_t bytes_left = limits.max_bytes;
    size_t samples_left = limits.max_samples;
    for (size_t i = 0; i < inputs.size(); ++i) {
      const auto& input = inputs[i];
      switch (input.kind) {
        case MediaInput::Kind::Image:
          if (mtmd_detail::encoded_audio(input.bytes)) {
            throw std::runtime_error("MtmdSource - audio bytes require a typed audio input");
          }
          if (!mtmd_support_vision(ctx_)) {
            throw std::runtime_error("MtmdSource - projector does not support image input");
          }
          break;
        case MediaInput::Kind::Video:
          validate_video(input.video);
          break;
        case MediaInput::Kind::Audio:
          if (!mtmd_support_audio(ctx_) || mtmd_get_audio_sample_rate(ctx_) <= 0) {
            throw std::runtime_error("MtmdSource - projector does not support audio input");
          }
          if (!limits.max_bytes || !limits.max_samples) {
            throw std::runtime_error("MtmdSource - audio limits must be positive");
          }
          if (input.bytes.size() > bytes_left) {
            throw std::runtime_error("MtmdSource - audio byte limit exceeded");
          }
          bytes_left -= input.bytes.size();
          samples[i] = mtmd_detail::wav_sample_bound(input.bytes, mtmd_get_audio_sample_rate(ctx_));
          if (samples[i] > samples_left) {
            throw std::runtime_error("MtmdSource - audio sample limit exceeded");
          }
          samples_left -= samples[i];
          break;
        default:
          throw std::runtime_error("MtmdSource - unsupported input kind");
      }
    }
    return samples;
  }
 
  const mtmd_input_chunk* chunk_at(size_t i) const {
    return mtmd_input_chunks_get(chunks_.get(), i - lead_);
  }
 
  static void name_input(mtmd_bitmap* bitmap, size_t input) {
    mtmd_bitmap_set_id(bitmap, std::to_string(input).c_str());
  }
 
  size_t cells_at(size_t i) const {
    if (lead_ != 0 && i == 0) return sep_.size();
    return mtmd_input_chunk_get_n_tokens(chunk_at(i));
  }
 
  void map_inputs(size_t n_inputs) {
    const size_t n = size();
    std::vector<int32_t> media(n, -1);
    for (size_t i = lead_; i < n; ++i) {
      if (const char* id = mtmd_input_chunk_get_id(chunk_at(i))) media[i] = std::stoi(id);
    }
    // The nearest media chunk's input on either side of each segment.
    std::vector<int32_t> before(n, -1), after(n, -1);
    for (size_t i = 1; i < n; ++i) before[i] = media[i - 1] >= 0 ? media[i - 1] : before[i - 1];
    for (size_t i = n; i > 1; --i) after[i - 2] = media[i - 1] >= 0 ? media[i - 1] : after[i - 1];
 
    input_of_.assign(n, -1);
    total_of_.assign(n_inputs, 0);
    for (size_t i = 0; i < n; ++i) {
      const bool inside = before[i] >= 0 && before[i] == after[i];
      input_of_[i] = media[i] >= 0 ? media[i] : (inside ? before[i] : -1);
      if (input_of_[i] >= 0) total_of_[input_of_[i]] += cells_at(i);
    }
  }
 
  mtmd_context* ctx_ = nullptr;
  std::span<const llama_token> sep_;
  int32_t n_embd_inp_ = 0;
 
  std::vector<::mtmd::bitmap_ptr> bitmaps_;
  ::mtmd::input_chunks_ptr chunks_;
  std::vector<mtmd_decoder_pos> rel_;
 
  bool   mrope_    = false;
  size_t n_chunks_ = 0;
  size_t lead_     = 0;
  size_t cells_    = 0;
 
  std::vector<int32_t> input_of_;  // per segment: its input, or -1
  std::vector<size_t> total_of_;   // per input: its cells
};
 
} // namespace lloyal