tirtc-devtools-cli 0.0.1

package/vendor/runtime/script/prepare_runtime_media_dataset.sh

@@ -0,0 +1,427 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+print_usage() {
+  cat <<'USAGE'
+Usage:
+  prepare_runtime_media_dataset.sh --source <mp4> --output-root <dir> [--output-dir <dir>] [--overwrite]
+
+Options:
+  --source <mp4>              source mp4 file
+  --output-root <dir>         root directory that stores prepared local assets
+  --output-dir <dir>          exact prepared local assets directory (overrides hashed subdir)
+  --overwrite                 rebuild prepared assets even when cache entry exists
+  -h, --help                  show help
+USAGE
+}
+
+fail() {
+  echo "[prepare_runtime_media_dataset] error: $*" >&2
+  exit 1
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1 || fail "missing required command: $1"
+}
+
+sha256_file() {
+  local file="$1"
+  if command -v shasum >/dev/null 2>&1; then
+    shasum -a 256 "$file" | awk '{print $1}'
+    return
+  fi
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$file" | awk '{print $1}'
+    return
+  fi
+  if command -v openssl >/dev/null 2>&1; then
+    openssl dgst -sha256 "$file" | awk '{print $NF}'
+    return
+  fi
+  fail "no sha256 tool found (shasum/sha256sum/openssl)"
+}
+
+json_escape() {
+  local input="$1"
+  input="${input//\\/\\\\}"
+  input="${input//\"/\\\"}"
+  input="${input//$'\n'/\\n}"
+  input="${input//$'\r'/\\r}"
+  input="${input//$'\t'/\\t}"
+  printf '%s' "$input"
+}
+
+emit_result() {
+  local assets_dir="$1"
+  local manifest_path="$2"
+  local cache_hit="$3"
+  printf '{"assets_dir":"%s","manifest_path":"%s","cache_hit":%s}\n' \
+    "$(json_escape "$assets_dir")" \
+    "$(json_escape "$manifest_path")" \
+    "$cache_hit"
+}
+
+SOURCE=""
+OUTPUT_ROOT=""
+OUTPUT_DIR=""
+OVERWRITE=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --source)
+      SOURCE="${2:-}"
+      shift 2
+      ;;
+    --output-root)
+      OUTPUT_ROOT="${2:-}"
+      shift 2
+      ;;
+    --output-dir)
+      OUTPUT_DIR="${2:-}"
+      shift 2
+      ;;
+    --overwrite)
+      OVERWRITE=1
+      shift
+      ;;
+    -h|--help)
+      print_usage
+      exit 0
+      ;;
+    *)
+      fail "unknown argument: $1"
+      ;;
+  esac
+done
+
+[[ -n "$SOURCE" ]] || fail "--source is required"
+[[ -n "$OUTPUT_ROOT" ]] || fail "--output-root is required"
+[[ -f "$SOURCE" ]] || fail "source not found: $SOURCE"
+[[ "$SOURCE" == *.mp4 ]] || fail "source must be an .mp4 file: $SOURCE"
+
+require_cmd node
+
+FFMPEG_BIN="ffmpeg"
+FFPROBE_BIN="ffprobe"
+if [[ -n "${TIRTC_ENSURE_FFMPEG_SCRIPT:-}" ]]; then
+  [[ -x "$TIRTC_ENSURE_FFMPEG_SCRIPT" ]] || fail "ffmpeg bootstrap script is not executable: $TIRTC_ENSURE_FFMPEG_SCRIPT"
+  FFMPEG_TOOLS_JSON="$($TIRTC_ENSURE_FFMPEG_SCRIPT)" || fail "ffmpeg bootstrap failed"
+  FFMPEG_FIELDS="$(FFMPEG_TOOLS_JSON="$FFMPEG_TOOLS_JSON" node <<'NODE'
+const payload = process.env.FFMPEG_TOOLS_JSON;
+if (!payload) {
+  throw new Error('missing FFMPEG_TOOLS_JSON');
+}
+const parsed = JSON.parse(payload);
+if (!parsed.ffmpeg || !parsed.ffprobe) {
+  throw new Error('ffmpeg bootstrap returned incomplete result');
+}
+process.stdout.write(String(parsed.ffmpeg) + '	' + String(parsed.ffprobe));
+NODE
+)"
+  IFS=$'	' read -r FFMPEG_BIN FFPROBE_BIN <<EOF
+$FFMPEG_FIELDS
+EOF
+fi
+
+require_cmd "$FFMPEG_BIN"
+require_cmd "$FFPROBE_BIN"
+
+SOURCE_ABS="$(cd "$(dirname "$SOURCE")" && pwd)/$(basename "$SOURCE")"
+SOURCE_FILE_NAME="$(basename "$SOURCE_ABS")"
+
+readonly k_schema_version=1
+readonly k_tool_version="runtime_local_assets_prepare_v4"
+readonly k_video_max_width=1280
+readonly k_video_max_height=720
+readonly k_video_fps=15
+readonly k_audio_sample_rate_hz=8000
+readonly k_audio_channels=1
+readonly k_audio_packet_duration_ms=40
+readonly k_loop_policy="continuous_pts"
+readonly k_video_codec="h264_annexb"
+readonly k_audio_codec="g711a"
+readonly k_output_audio_format="pcm_s16"
+readonly k_output_video_format="rgba8888"
+
+VIDEO_STREAM_FIELDS="$(
+  VIDEO_STREAM_JSON="$("$FFPROBE_BIN" -v error -select_streams v:0 \
+    -show_entries stream=width,height,bit_rate -of json "$SOURCE_ABS")" \
+    MAX_WIDTH="$k_video_max_width" \
+    MAX_HEIGHT="$k_video_max_height" \
+    node <<'NODE'
+const payload = process.env.VIDEO_STREAM_JSON;
+if (!payload) {
+  throw new Error('missing VIDEO_STREAM_JSON');
+}
+const maxWidth = Number(process.env.MAX_WIDTH || '1280');
+const maxHeight = Number(process.env.MAX_HEIGHT || '720');
+if (!Number.isFinite(maxWidth) || maxWidth <= 0 || !Number.isFinite(maxHeight) || maxHeight <= 0) {
+  throw new Error('invalid target video bound');
+}
+const parsed = JSON.parse(payload);
+const stream = Array.isArray(parsed.streams) ? parsed.streams[0] : null;
+if (!stream) {
+  throw new Error('source mp4 is missing a video stream');
+}
+const width = Number(stream.width || 0);
+const height = Number(stream.height || 0);
+if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0) {
+  throw new Error('source video dimensions are invalid');
+}
+const bitRate = Number(stream.bit_rate || 0);
+const bitrateKbps = Number.isFinite(bitRate) && bitRate > 0 ? Math.max(1, Math.ceil(bitRate / 1000)) : 0;
+const scale = Math.min(1, maxWidth / width, maxHeight / height);
+let targetWidth = Math.floor(width * scale);
+let targetHeight = Math.floor(height * scale);
+if ((targetWidth % 2) !== 0 && targetWidth > 2) {
+  targetWidth -= 1;
+}
+if ((targetHeight % 2) !== 0 && targetHeight > 2) {
+  targetHeight -= 1;
+}
+targetWidth = Math.max(2, targetWidth);
+targetHeight = Math.max(2, targetHeight);
+const scaledBitrateKbps = bitrateKbps > 0
+  ? Math.max(1, Math.ceil(bitrateKbps * ((targetWidth * targetHeight) / (width * height))))
+  : 0;
+process.stdout.write([
+  String(width),
+  String(height),
+  String(bitrateKbps),
+  String(targetWidth),
+  String(targetHeight),
+  String(scaledBitrateKbps),
+].join('\t'));
+NODE
+)"
+IFS=$'\t' read -r SOURCE_VIDEO_WIDTH SOURCE_VIDEO_HEIGHT SOURCE_VIDEO_BITRATE_KBPS TARGET_VIDEO_WIDTH TARGET_VIDEO_HEIGHT TARGET_VIDEO_BITRATE_KBPS <<EOF
+$VIDEO_STREAM_FIELDS
+EOF
+
+[[ "$SOURCE_VIDEO_WIDTH" -gt 0 ]] || fail "failed to resolve source video width"
+[[ "$SOURCE_VIDEO_HEIGHT" -gt 0 ]] || fail "failed to resolve source video height"
+[[ "$TARGET_VIDEO_WIDTH" -gt 0 ]] || fail "failed to resolve target video width"
+[[ "$TARGET_VIDEO_HEIGHT" -gt 0 ]] || fail "failed to resolve target video height"
+
+mkdir -p "$OUTPUT_ROOT"
+SOURCE_SHA256="$(sha256_file "$SOURCE_ABS")"
+ASSETS_ID="${SOURCE_SHA256}_s${k_schema_version}_${k_tool_version}"
+ASSETS_DIR="$OUTPUT_ROOT/$ASSETS_ID"
+if [[ -n "$OUTPUT_DIR" ]]; then
+  ASSETS_DIR="$OUTPUT_DIR"
+fi
+MANIFEST_PATH="$ASSETS_DIR/manifest.json"
+
+if [[ -f "$MANIFEST_PATH" && "$OVERWRITE" -ne 1 ]]; then
+  emit_result "$ASSETS_DIR" "$MANIFEST_PATH" true
+  exit 0
+fi
+
+if [[ -e "$ASSETS_DIR" ]]; then
+  rm -rf "$ASSETS_DIR"
+fi
+
+mkdir -p "$ASSETS_DIR/video"
+mkdir -p "$ASSETS_DIR/audio"
+
+VIDEO_PATH="$ASSETS_DIR/video/video.h264"
+VIDEO_PACKET_INDEX_PATH="$ASSETS_DIR/video/video_packets.csv"
+AUDIO_PATH="$ASSETS_DIR/audio/audio.g711a"
+AUDIO_PACKET_INDEX_PATH="$ASSETS_DIR/audio/audio_packets.csv"
+
+video_encode_args=(
+  -vf "fps=${k_video_fps},scale=${TARGET_VIDEO_WIDTH}:${TARGET_VIDEO_HEIGHT}:flags=lanczos"
+  -c:v libx264
+  -preset medium
+  -tune zerolatency
+  -pix_fmt yuv420p
+  -bf 0
+  -g "${k_video_fps}"
+  -keyint_min "${k_video_fps}"
+  -sc_threshold 0
+  -x264-params repeat-headers=1:aud=1
+)
+if [[ "$TARGET_VIDEO_BITRATE_KBPS" -gt 0 ]]; then
+  video_encode_args+=(
+    -b:v "${TARGET_VIDEO_BITRATE_KBPS}k"
+    -maxrate "${TARGET_VIDEO_BITRATE_KBPS}k"
+    -bufsize "$((TARGET_VIDEO_BITRATE_KBPS * 2))k"
+  )
+else
+  video_encode_args+=(-crf 18)
+fi
+
+"$FFMPEG_BIN" -hide_banner -loglevel error -y \
+  -i "$SOURCE_ABS" \
+  -an \
+  "${video_encode_args[@]}" \
+  -f h264 \
+  "$VIDEO_PATH"
+
+"$FFMPEG_BIN" -hide_banner -loglevel error -y \
+  -i "$SOURCE_ABS" \
+  -vn \
+  -ac ${k_audio_channels} \
+  -ar ${k_audio_sample_rate_hz} \
+  -c:a pcm_alaw \
+  -f alaw \
+  "$AUDIO_PATH"
+
+VIDEO_PACKET_INDEX_PATH="$VIDEO_PACKET_INDEX_PATH" \
+VIDEO_PATH="$VIDEO_PATH" \
+VIDEO_FPS="$k_video_fps" \
+node <<'NODE'
+const fs = require('fs');
+
+const videoPath = process.env.VIDEO_PATH;
+const outputPath = process.env.VIDEO_PACKET_INDEX_PATH;
+const fps = Number(process.env.VIDEO_FPS || '15');
+
+if (!videoPath || !outputPath || !Number.isFinite(fps) || fps <= 0) {
+  throw new Error('video packet index env is incomplete');
+}
+
+const data = fs.readFileSync(videoPath);
+const starts = [];
+for (let index = 0; index < data.length - 3; index += 1) {
+  if (data[index] === 0 && data[index + 1] === 0) {
+    if (data[index + 2] === 1) {
+      starts.push({offset: index, prefix: 3});
+      index += 2;
+      continue;
+    }
+    if (index + 3 < data.length && data[index + 2] === 0 && data[index + 3] === 1) {
+      starts.push({offset: index, prefix: 4});
+      index += 3;
+    }
+  }
+}
+
+if (starts.length === 0) {
+  throw new Error('video bitstream missing annexb start codes');
+}
+
+const packetOffsets = [];
+let currentPacketStart = 0;
+let currentPacketHasData = false;
+let currentPacketKeyFrame = false;
+
+for (let index = 0; index < starts.length; index += 1) {
+  const start = starts[index];
+  const nextOffset = index + 1 < starts.length ? starts[index + 1].offset : data.length;
+  const nalHeaderOffset = start.offset + start.prefix;
+  if (nalHeaderOffset >= nextOffset) {
+    continue;
+  }
+
+  const nalType = data[nalHeaderOffset] & 0x1f;
+  if (nalType === 9) {
+    if (currentPacketHasData) {
+      packetOffsets.push({
+        offset: currentPacketStart,
+        size: start.offset - currentPacketStart,
+        keyFrame: currentPacketKeyFrame,
+      });
+    }
+    currentPacketStart = start.offset;
+    currentPacketHasData = true;
+    currentPacketKeyFrame = false;
+    continue;
+  }
+
+  if (!currentPacketHasData) {
+    currentPacketStart = start.offset;
+    currentPacketHasData = true;
+    currentPacketKeyFrame = false;
+  }
+  if (nalType === 5) {
+    currentPacketKeyFrame = true;
+  }
+}
+
+if (currentPacketHasData && currentPacketStart < data.length) {
+  packetOffsets.push({
+    offset: currentPacketStart,
+    size: data.length - currentPacketStart,
+    keyFrame: currentPacketKeyFrame,
+  });
+}
+
+if (packetOffsets.length === 0) {
+  throw new Error('video packet index is empty');
+}
+
+const frameDurationUs = Math.round(1_000_000 / fps);
+const lines = ['pts_us,offset,size,is_key_frame'];
+for (let index = 0; index < packetOffsets.length; index += 1) {
+  const entry = packetOffsets[index];
+  lines.push(`${index * frameDurationUs},${entry.offset},${entry.size},${entry.keyFrame ? 1 : 0}`);
+}
+fs.writeFileSync(outputPath, `${lines.join('\n')}\n`, 'utf8');
+NODE
+
+AUDIO_BYTES="$(wc -c < "$AUDIO_PATH" | tr -d '[:space:]')"
+AUDIO_PACKET_BYTES=$((k_audio_sample_rate_hz * k_audio_packet_duration_ms / 1000))
+[[ "$AUDIO_PACKET_BYTES" -gt 0 ]] || fail "invalid audio packet bytes"
+AUDIO_REMAINDER=$((AUDIO_BYTES % AUDIO_PACKET_BYTES))
+if [[ "$AUDIO_REMAINDER" -ne 0 ]]; then
+  AUDIO_ALIGNED_BYTES=$((AUDIO_BYTES - AUDIO_REMAINDER))
+  [[ "$AUDIO_ALIGNED_BYTES" -gt 0 ]] || fail "audio output is too short for one full packet"
+  echo "[prepare_runtime_media_dataset] trim trailing audio bytes to packet boundary: removed=${AUDIO_REMAINDER}" >&2
+  AUDIO_PATH="$AUDIO_PATH" AUDIO_ALIGNED_BYTES="$AUDIO_ALIGNED_BYTES" node <<'NODE'
+const fs = require('fs');
+const audioPath = process.env.AUDIO_PATH;
+const alignedBytes = Number(process.env.AUDIO_ALIGNED_BYTES || '0');
+if (!audioPath || !Number.isFinite(alignedBytes) || alignedBytes <= 0) {
+  throw new Error('audio trim env is incomplete');
+}
+fs.truncateSync(audioPath, alignedBytes);
+NODE
+  AUDIO_BYTES="$AUDIO_ALIGNED_BYTES"
+fi
+AUDIO_PACKET_COUNT=$((AUDIO_BYTES / AUDIO_PACKET_BYTES))
+[[ "$AUDIO_PACKET_COUNT" -gt 0 ]] || fail "generated audio packets are empty"
+
+{
+  echo "pts_us,offset,size"
+  for ((i = 0; i < AUDIO_PACKET_COUNT; i += 1)); do
+    pts_us=$((i * k_audio_packet_duration_ms * 1000))
+    offset=$((i * AUDIO_PACKET_BYTES))
+    echo "${pts_us},${offset},${AUDIO_PACKET_BYTES}"
+  done
+} > "$AUDIO_PACKET_INDEX_PATH"
+
+cat > "$MANIFEST_PATH" <<JSON
+{
+  "schema_version": ${k_schema_version},
+  "tool_version": "${k_tool_version}",
+  "source": {
+    "file_name": "${SOURCE_FILE_NAME}",
+    "sha256": "${SOURCE_SHA256}"
+  },
+  "video": {
+    "path": "video/video.h264",
+    "packet_index_path": "video/video_packets.csv",
+    "codec": "${k_video_codec}",
+    "width": ${TARGET_VIDEO_WIDTH},
+    "height": ${TARGET_VIDEO_HEIGHT},
+    "fps": ${k_video_fps},
+    "bitrate_kbps": ${TARGET_VIDEO_BITRATE_KBPS}
+  },
+  "audio": {
+    "path": "audio/audio.g711a",
+    "packet_index_path": "audio/audio_packets.csv",
+    "codec": "${k_audio_codec}",
+    "sample_rate_hz": ${k_audio_sample_rate_hz},
+    "channels": ${k_audio_channels},
+    "packet_duration_ms": ${k_audio_packet_duration_ms}
+  },
+  "output": {
+    "audio_format": "${k_output_audio_format}",
+    "video_format": "${k_output_video_format}"
+  },
+  "loop_policy": "${k_loop_policy}"
+}
+JSON
+
+emit_result "$ASSETS_DIR" "$MANIFEST_PATH" false