2025年10月10日 / 最終更新日時 : 2025年10月10日 info プログラミング

GoProから緯度経度情報等のメタ情報の取り出し方

GoPro動画→GPX抽出・1Hz整形・720p再エンコード・進捗可視化・メタデータ継承ツール（ソース付き）

このスクリプトは何をする？（ソース付き解説）

GoProの動画からGPS軌跡（GPX）を抜き出し、1秒間隔に整形。動画は1280×720 / 6Mbpsで QSV/AMF/MF いずれかのハードウェアエンコーダで再エンコード。
エンコード進捗をCSV/SVGで保存し、最後にExifToolでメタデータを完成MP4へ丸コピーします。

処理の全体像

GPXテンプレ生成 → GPS抽出（ExifTool）。
1Hz整形（各秒の先頭点を採用、速度/高度は数値抽出）。
example.gpx互換でGPXを書き出し。
720p/6Mbpsでハードウェア再エンコード（libx264へは落とさない方針）。
進捗ログ（CSV/SVG）を自動生成。
メタデータを元動画から新MP4へコピー。

使い方（例）

python gopro_gpx_720p.py "F:\videos\gopro_session" --overwrite --hwenc auto

path：動画ファイル or フォルダ（.mp4/.mov/.m4v を再帰探索）
–ffmpeg / –exiftool：同梱しない場合は明示パス可
–overwrite：既存の _1280_720.* を上書き
–hwenc：auto/qsv/amf/mf（libx264には落ちません）
–no-progress：進捗CSV/SVGを作らない

要点と注意

注意：引数に nvenc はありますが、候補列挙は h264_qsv / h264_amf / h264_mf のみ。
NVIDIA専用にしたい場合は pick_encoder_list() に h264_nvenc のエントリを追加してください。

ソースコード（全文）

クリックで折りたたみ／展開

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

“””
GoPro → (1) ExifToolテンプレでGPX吸出し → (2) example.gpx互換に整形＋1Hz間引き
→ (3) H.264 1280×720 / 6Mbps（libx264不使用・QSV→AMF→MF）→ (4) 進捗CSV/SVG
→ (5) 出力MP4へメタデータ丸コピー（ExifTool -TagsFromFile）

出力:
  <元名>_1280_720.gpx
  <元名>_1280_720.mp4
  <元名>_1280_720_progress.csv / .svg

同梱想定:
  tools/ffmpeg/ffmpeg.exe
  tools/exiftool/exiftool.exe
“””

import argparse
import csv
import os
import re
import sys
import subprocess
import tempfile
import time
from pathlib import Path
from typing import Optional, List, Tuple, Dict
from shutil import which as shutil_which
from datetime import datetime

# ———————- ランタイム補助 ———————-

def runtime_base_dir() -> Path:
    base = os.environ.get(“NUITKA_ONEFILE_TEMP_DIR”)
    if base:
        return Path(base)
    if hasattr(sys, “_MEIPASS”):
        return Path(getattr(sys, “_MEIPASS”))
    if getattr(sys, “frozen”, False):
        return Path(sys.executable).resolve().parent
    return Path(__file__).resolve().parent

def which(cmd: str) -> Optional[str]:
    exts = os.environ.get(“PATHEXT”, “.EXE;.BAT;.CMD”).split(“;”)
    paths = os.environ.get(“PATH”, “”).split(os.pathsep)
    p = Path(cmd)
    if p.exists():
        return str(p)
    cand = [cmd] if p.suffix else [cmd + ext for ext in exts] + [cmd]
    for d in paths:
        for c in cand:
            f = Path(d) / c
            if f.exists() and f.is_file():
                return str(f)
    return None

def resolve_tool(name: str, cli_path: Optional[str], bundled_rel: Path) -> str:
    # 1) CLI明示 → 2) 同梱 → 3) PATH
    if cli_path:
        if Path(cli_path).exists():
            return str(Path(cli_path))
        sys.exit(f”ERROR: {name} が見つかりません: {cli_path}”)
    base = runtime_base_dir()
    cand = base / bundled_rel
    if cand.exists():
        return str(cand)
    found = which(name)
    if found:
        return found
    sys.exit(
        f”ERROR: {name} が見つかりません。PATHへ追加するか –{name} で明示、”
        f”または tools/{name}/{name}.exe を同梱してください。”
    )

def resolve_ffprobe_path(ffmpeg_path: str) -> str:
    # ffmpeg.exe と同じフォルダを最優先で探す
    p = Path(ffmpeg_path)
    for nm in (“ffprobe.exe”, “ffprobe”):
        cand = p.with_name(nm)
        if cand.exists():
            return str(cand)
    w = shutil_which(“ffprobe”)
    if w:
        return w
    sys.exit(“ERROR: ffprobe が見つかりません。ffmpeg と同梱するか PATH に通してください。”)

# ———————- 共通ロジック ———————-

def is_video(p: Path) -> bool:
    return p.suffix.lower() in {“.mp4”, “.mov”, “.m4v”}

def build_gpx_template() -> Path:
    # ★あなたの「取れていた」テンプレそのまま
    gpx_text = “””#[HEAD]<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.1" creator="ExifTool"
 xmlns="http://www.topografix.com/GPX/1/1"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.topografix.com/GPX/1/1
 http://www.topografix.com/GPX/1/1/gpx.xsd">
<trk><name>$FileName</name><trkseg>
#[BODY]<trkpt lat="$GPSLatitude#" lon="$GPSLongitude#"><time>$GPSDateTime</time><ele>$GPSAltitude</ele><speed>$GPSSpeed</speed></trkpt>
#[TAIL]</trkseg></trk></gpx>
“””
    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=”.fmt”, mode=”w”, encoding=”utf-8″)
    tmp.write(gpx_text)
    tmp.close()
    return Path(tmp.name)

def ffmpeg_has_encoder(ffmpeg: str, enc: str) -> bool:
    try:
        res = subprocess.run([ffmpeg, “-hide_banner”, “-encoders”], capture_output=True, text=True, check=True)
        return f” {enc} ” in res.stdout
    except Exception:
        return False

def pick_encoder_list(ffmpeg: str, forced: str) -> List[Tuple[str, List[str]]]:
    # 6 Mbps 固定（libx264は含めない）
    br, maxrate, buf = “6M”, “6M”, “12M”

    if forced == “qsv”:
        return [(“h264_qsv”, [“-c:v”, “h264_qsv”, “-b:v”, br, “-maxrate”, maxrate, “-bufsize”, buf])]
    if forced == “amf”:
        return [(“h264_amf”, [“-c:v”, “h264_amf”, “-b:v”, br, “-maxrate”, maxrate, “-bufsize”, buf])]
    if forced == “mf”:
        return [(“h264_mf”,  [“-c:v”, “h264_mf”,  “-b:v”, br])]

    cands: List[Tuple[str, List[str]]] = []
    if ffmpeg_has_encoder(ffmpeg, “h264_qsv”):
        cands.append((“h264_qsv”, [“-c:v”, “h264_qsv”, “-b:v”, br, “-maxrate”, maxrate, “-bufsize”, buf]))
    if ffmpeg_has_encoder(ffmpeg, “h264_amf”):
        cands.append((“h264_amf”, [“-c:v”, “h264_amf”, “-b:v”, br, “-maxrate”, maxrate, “-bufsize”, buf]))
    if ffmpeg_has_encoder(ffmpeg, “h264_mf”):
        cands.append((“h264_mf”,  [“-c:v”, “h264_mf”,  “-b:v”, br]))
    return cands

def build_filters() -> List[str]:
    # SWスケール+padで常に 1280×720（互換性のため yuv420p）
    vf = “scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2”
    return [“-vf”, vf, “-pix_fmt”, “yuv420p”]

# ———————- 進捗取得＆可視化 ———————-

def _run_ffprobe_val(ffprobe: str, args: List[str]) -> Optional[float]:
    try:
        res = subprocess.run([ffprobe] + args, capture_output=True, text=True, check=True)
        s = res.stdout.strip()
        if not s:
            return None
        val = float(s)
        if val > 0 and val != float(“inf”):
            return val
    except Exception:
        return None
    return None

def ffprobe_duration_sec(ffmpeg: str, src: Path) -> Optional[float]:
    ffprobe = resolve_ffprobe_path(ffmpeg)
    # 1) format.duration
    dur = _run_ffprobe_val(ffprobe, [
        “-v”, “error”,
        “-show_entries”, “format=duration”,
        “-of”, “default=nk=1:nw=1”,
        str(src),
    ])
    if dur:
        return dur
    # 2) stream.duration（動画ストリーム）
    dur = _run_ffprobe_val(ffprobe, [
        “-v”, “error”,
        “-select_streams”, “v:0”,
        “-show_entries”, “stream=duration”,
        “-of”, “default=nk=1:nw=1”,
        str(src),
    ])
    if dur:
        return dur
    # 3) nb_frames / avg_frame_rate から推定
    try:
        nb = subprocess.run([ffprobe, “-v”, “error”, “-select_streams”, “v:0”,
                             “-show_entries”, “stream=nb_frames”,
                             “-of”, “default=nk=1:nw=1”, str(src)],
                            capture_output=True, text=True, check=True).stdout.strip()
        fps_s = subprocess.run([ffprobe, “-v”, “error”, “-select_streams”, “v:0”,
                                “-show_entries”, “stream=avg_frame_rate”,
                                “-of”, “default=nk=1:nw=1”, str(src)],
                               capture_output=True, text=True, check=True).stdout.strip()
        if nb and fps_s and “/” in fps_s:
            num, den = fps_s.split(“/”, 1)
            num = float(num); den = float(den) if float(den) != 0 else 1.0
            fps = num / den if den != 0 else float(num)
            frames = float(nb)
            if fps > 0 and frames > 0:
                return frames / fps
    except Exception:
        pass
    return None

def write_progress_csv(csv_path: Path, samples: List[Tuple[float, float]]) -> None:
    lines = [“time_sec,percent”]
    lines += [f”{t:.3f},{p:.3f}” for t, p in samples]
    csv_path.write_text(“\n”.join(lines), encoding=”utf-8″)

def write_progress_svg(svg_path: Path, samples: List[Tuple[float, float]]) -> None:
    if not samples:
        svg_path.write_text(“<svg xmlns='http://www.w3.org/2000/svg' width='800' height='240'></svg>“, encoding=”utf-8″)
        return
    W, H, P = 800, 240, 32
    xs = [t for t, _ in samples]
    ys = [p for _, p in samples]
    tmax = max(xs) if max(xs) > 0 else 1.0
    def sx(t): return P + (W – 2*P) * (t / tmax)
    def sy(p): return H – P – (H – 2*P) * (p / 100.0)
    pts = ” “.join([f”{sx(t):.1f},{sy(p):.1f}” for t, p in samples])
    grid = []
    for k in [0,25,50,75,100]:
        y = sy(k)
        grid.append(f”<line x1='{P}' y1='{y:.1f}' x2='{W-P}' y2='{y:.1f}' stroke='#ddd'/>“)
        grid.append(f”<text x='5' y='{y+4:.1f}' font-size='10' fill='#555'>{k}%</text>“)
    frame = f”<rect x='{P}' y='{P}' width='{W-2*P}' height='{H-2*P}' fill='none' stroke='#888'/>”
    lastp = ys[-1]
    label = f”<text x='{W-60}' y='{P+14}' font-size='12' fill='#222'>final: {lastp:.1f}%</text>”
    svg = f”””<svg xmlns='http://www.w3.org/2000/svg' width='{W}' height='{H}'>
  <rect width='100%' height='100%' fill='white'/>
  {”.join(grid)}
  {frame}
  <polyline fill='none' stroke='#0b79d0' stroke-width='2' points='{pts}'/>
  {label}
</svg>“””
    svg_path.write_text(svg, encoding=”utf-8″)

def run_ffmpeg_with_progress(ffmpeg: str, src: Path, dst_mp4: Path, vopts: List[str],
                             enable_progress: bool = True) -> None:
    csv_path = dst_mp4.with_name(dst_mp4.stem + “_progress.csv”)
    svg_path = dst_mp4.with_name(dst_mp4.stem + “_progress.svg”)

    duration = ffprobe_duration_sec(ffmpeg, src) or 0.0

    base = [ffmpeg, “-y”, “-hide_banner”, “-loglevel”, “error”]
    filters = build_filters()
    common_tail = [
        “-c:a”, “aac”, “-b:a”, “160k”,
        “-movflags”, “+faststart”,
        “-map_metadata”, “0”,
        “-progress”, “pipe:1”,
        str(dst_mp4),
    ]
    cmd = base + [“-i”, str(src)] + filters + vopts + common_tail

    samples: List[Tuple[float, float]] = []
    start = time.monotonic()
    out_time_ms = 0.0

    with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1) as proc:
        if enable_progress and proc.stdout is not None:
            for raw in proc.stdout:
                line = raw.strip()
                if line.startswith(“out_time_ms=”):
                    try:
                        out_time_ms = float(line.split(“=”, 1)[1])
                        tsec = out_time_ms / 1_000_000.0
                        if duration > 0:
                            pct = max(0.0, min(100.0, (tsec / duration) * 100.0))
                        else:
                            # duration不明なら「経過時間で右肩上がり」だが 100% は end で付与
                            elapsed = time.monotonic() – start
                            pct = min(99.0, elapsed % 99.0)  # 擬似（見た目用）
                        elapsed = time.monotonic() – start
                        samples.append((elapsed, pct))
                        print(f”    progress: {pct:5.1f}%  (t={tsec:7.2f}s / dur={duration:7.2f}s)”, end=”\r”)
                    except Exception:
                        pass
                elif line == “progress=end”:
                    elapsed = time.monotonic() – start
                    samples.append((elapsed, 100.0))
        ret = proc.wait()

    print()  # 行末整形

    if ret != 0:
        try:
            if csv_path.exists(): csv_path.unlink()
            if svg_path.exists(): svg_path.unlink()
        except Exception:
            pass
        raise subprocess.CalledProcessError(ret, cmd)

    try:
        write_progress_csv(csv_path, samples)
        write_progress_svg(svg_path, samples)
        print(f”  progress: {csv_path.name}, {svg_path.name}”)
    except Exception as e:
        print(f”  WARN: 進捗ファイルの作成に失敗: {e}”)

# ———————- メタデータ丸コピー ———————-

def copy_metadata_to_output(exiftool: str, src: Path, dst: Path) -> bool:
    cmd = [
        exiftool, “-q”, “-m”, “-P”, “-overwrite_original”,
        “-TagsFromFile”, str(src),
        “-all:all”, “-time:all”, “-XMP:all”, “-Keys:all”, “-UserData:all”,
        str(dst),
    ]
    res = subprocess.run(cmd, capture_output=True)
    return res.returncode == 0

# ———————- GPX 吸出し→整形→1Hz間引き ———————-

def run_exiftool_template_raw(exiftool: str, src: Path, fmt: Path) -> Optional[str]:
    “””テンプレで“生GPX”を標準出力に吐かせて文字列で返す（あなたの実績ある方式）。”””
    cmd = [exiftool, “-q”, “-ee”, “-p”, str(fmt), str(src)]
    res = subprocess.run(cmd, check=False, capture_output=True)
    if res.returncode != 0:
        return None
    text = res.stdout.decode(“utf-8″, errors=”replace”)
    return text if “<trkpt " in text else None

def parse_trkpts_from_raw_gpx(xml: str) -> List[Dict[str, str]]:
    “””テンプレGPX(<trkpt>)から lat/lon/time/ele/speed を素朴抽出。”””
    pts: List[Dict[str,str]] = []
    for block in xml.split(“<trkpt ")[1:]:
        try:
            frag = block.split("</trkpt>“, 1)[0]
            lat = frag.split(‘lat=”‘,1)[1].split(‘”‘,1)[0]
            lon = frag.split(‘lon=”‘,1)[1].split(‘”‘,1)[0]
            t   = frag.split(“<time>“,1)[1].split(“</time>“,1)[0]
            ele = frag.split(“<ele>“,1)[1].split(“</ele>“,1)[0]
            spd = frag.split(“<speed>“,1)[1].split(“</speed>“,1)[0]
            pts.append({“lat”:lat,”lon”:lon,”time”:t,”ele”:ele,”speed”:spd})
        except Exception:
            continue
    return pts

def _parse_dt_any(tstr: str) -> Optional[datetime]:
    t = tstr.strip().replace(” “, “T”).replace(“/”, “-“)
    # 代表的な表記を幅広く許容
    for fmt in (“%Y-%m-%dT%H:%M:%S.%fZ”, “%Y-%m-%dT%H:%M:%S.%f”,
                “%Y-%m-%dT%H:%M:%SZ”, “%Y-%m-%dT%H:%M:%S”,
                “%Y:%m:%dT%H:%M:%S.%f”, “%Y:%m:%dT%H:%M:%S”):
        try:
            return datetime.strptime(t, fmt)
        except Exception:
            continue
    return None

_num_pat = re.compile(r”[-+]?\d+(?:\.\d+)?”)

def _to_numeric_str(val: str, default: str=”0″) -> str:
    “””‘123.4 m/s’ のような文字列から数値部分だけを抜き出して返す。”””
    if val is None:
        return default
    m = _num_pat.search(str(val))
    return m.group(0) if m else default

def decimate_to_1hz(points: List[Dict[str,str]]) -> List[Dict[str,str]]:
    “””1秒ごとに最初の点を採用（floor秒）。ele/speedは数値抽出して出力。”””
    per_sec: Dict[int, Dict[str,str]] = {}
    for r in points:
        if not r.get(“lat”) or not r.get(“lon”) or not r.get(“time”):
            continue
        dt = _parse_dt_any(r[“time”])
        if not dt:
            continue
        dt_floor = dt.replace(microsecond=0)
        sec_key = int(dt_floor.timestamp())
        if sec_key in per_sec:
            continue
        per_sec[sec_key] = {
            “lat”: r[“lat”],
            “lon”: r[“lon”],
            “ele”: _to_numeric_str(r.get(“ele”,”0″)),
            “speed”: _to_numeric_str(r.get(“speed”,”0″)),
            “time”: dt_floor.strftime(“%Y-%m-%dT%H:%M:%S.%f”),  # 例に合わせて6桁小数
        }
    return [per_sec[k] for k in sorted(per_sec.keys())]

def write_gpx_like_example(dst_gpx: Path, points_1hz: List[Dict[str,str]]) -> bool:
    “””example.gpx互換：gpxtpx名前空間＋二重<extensions>＋creator文字列などを再構成。”””
    if not points_1hz:
        return False
    head = “””<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.1"
 xmlns="http://www.topografix.com/GPX/1/1"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:gpxtpx="http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
 xsi:schemaLocation="http://www.topografix.com/GPX/1/1
 http://www.topografix.com/GPX/1/1/gpx.xsd
 http://www.garmin.com/xmlschemas/TrackPointExtension/v1
 http://www.garmin.com/xmlschemas/TrackPointExtensionv1.xsd"
 creator="gpx.py -- https://github.com/tkrajina/gpxpy">
  <trk>
    <trkseg>
“””
    tail = “””    </trkseg>
  </trk>
</gpx>
“””
    lines = [head]
    for p in points_1hz:
        lines.append(
f”””      <trkpt lat="{p['lat']}" lon="{p['lon']}">
        <ele>{p[‘ele’]}</ele>
        <time>{p[‘time’]}</time>
        <extensions>
          <extensions>
            <gpxtpx:TrackPointExtension>
              <gpxtpx:hr>0</gpxtpx:hr>
              <gpxtpx:cad>0</gpxtpx:cad>
              <gpxtpx:speed>{p[‘speed’]}</gpxtpx:speed>
              <gpxtpx:distance>0</gpxtpx:distance>
            </gpxtpx:TrackPointExtension>
          </extensions>
        </extensions>
      </trkpt>
“””
        )
    lines.append(tail)
    dst_gpx.write_text(“”.join(lines), encoding=”utf-8″)
    return True

# ———————- メイン処理（GPX→エンコード） ———————-

def process_one(src: Path, ffmpeg: str, exiftool: str, fmt: Path,
                overwrite: bool, hwenc: str, progress: bool) -> None:
    if not is_video(src):
        print(f”SKIP (拡張子非対応): {src}”)
        return

    stem = src.stem
    out_mp4 = src.with_name(f”{stem}_1280_720.mp4」
    out_gpx = src.with_name(f”{stem}_1280_720.gpx”)

    # —- (1) 吸出し → (2) 整形＋1Hz 間引き（先にGPXを確定）
    if out_gpx.exists() and not overwrite:
        print(f”EXIST: {out_gpx.name} -> 上書きしません (–overwrite)”)
    else:
        print(f”[GPX]    {src.name} -> {out_gpx.name} (extract→format→1Hz)”)
        raw_xml = run_exiftool_template_raw(exiftool, src, fmt)
        if not raw_xml:
            try:
                if out_gpx.exists(): out_gpx.unlink()
            except Exception: pass
            print(”  WARN: GPSトラックが見つからないか抽出ゼロ (GPX未作成)”)
        else:
            pts = parse_trkpts_from_raw_gpx(raw_xml)
            pts_1hz = decimate_to_1hz(pts)
            if write_gpx_like_example(out_gpx, pts_1hz):
                print(f”  OK: {out_gpx.name}  (points: {len(pts)} → 1Hz: {len(pts_1hz)})”)
            else:
                try:
                    if out_gpx.exists(): out_gpx.unlink()
                except Exception: pass
                print(”  WARN: 整形/間引きで有効点なし (GPX未作成)”)

    # —- (3) エンコード（6Mbps固定、libx264不使用）
    if out_mp4.exists() and not overwrite:
        print(f”EXIST: {out_mp4.name} -> 上書きしません (–overwrite)”)
    else:
        print(f”[Encode] {src.name} -> {out_mp4.name}”)
        candidates = pick_encoder_list(ffmpeg, hwenc)
        last_err = None
        for name, vopts in candidates:
            print(f”  -> 試行: {name}”)
            try:
                run_ffmpeg_with_progress(ffmpeg, src, out_mp4, vopts, enable_progress=progress)
                print(f”  OK: {name} を使用 (6Mbps)”)
                # —- (5) メタデータ丸コピー
                if not copy_metadata_to_output(exiftool, src, out_mp4):
                    print(”  WARN: メタデータのコピーに一部失敗（必要タグが足りない可能性）”)
                else:
                    print(”  META: 元動画のタグをコピー済み”)
                break
            except subprocess.CalledProcessError as e:
                last_err = e
                print(f”     失敗: {name}（次候補へ）”)
                try:
                    if out_mp4.exists():
                        out_mp4.unlink()
                except Exception:
                    pass
        else:
            if last_err:
                raise last_err
            raise RuntimeError(“エンコード全滅”)

def collect_targets(path: Path):
    if path.is_dir():
        return [p for p in path.rglob(“*”) if p.is_file() and is_video(p)]
    elif path.is_file():
        return [path]
    else:
        sys.exit(f”ERROR: パスが存在しません: {path}”)

def main():
    ap = argparse.ArgumentParser(description=”GoPro: GPX先行(整形+1Hz) → H.264 1280×720/6Mbps（libx264不使用）”)
    ap.add_argument(“path”, help=”動画ファイル or フォルダ”)
    ap.add_argument(“–ffmpeg”, dest=”ffmpeg_path”, default=None, help=”ffmpeg.exe のパス（未指定: 同梱→PATH）”)
    ap.add_argument(“–exiftool”, dest=”exiftool_path”, default=None, help=”exiftool.exe のパス（未指定: 同梱→PATH）”)
    ap.add_argument(“–overwrite”, action=”store_true”, help=”既存出力を上書き”)
    ap.add_argument(“–hwenc”, default=”auto”, choices=[“auto”,”nvenc”,”qsv”,”amf”,”mf”],
                    help=”エンコーダ選択: auto(既定) / qsv / nvenc / amf / mf（libx264には落ちません）”)
    ap.add_argument(“–no-progress”, action=”store_true”, help=”進捗CSV/SVGを出力しない”)
    args = ap.parse_args()

    ffmpeg = resolve_tool(“ffmpeg”, args.ffmpeg_path, Path(“tools/ffmpeg/ffmpeg.exe”))
    exiftool = resolve_tool(“exiftool”, args.exiftool_path, Path(“tools/exiftool/exiftool.exe”))

    fmt = build_gpx_template()
    try:
        targets = collect_targets(Path(args.path))
        if not targets:
            print(“対象動画が見つかりません（.mp4 .mov .m4v）。”)
            return
        for i, src in enumerate(targets, 1):
            print(f”\n[{i}/{len(targets)}] {src}”)
            try:
                process_one(
                    src, ffmpeg, exiftool, fmt,
                    overwrite=args.overwrite,
                    hwenc=args.hwenc,
                    progress=(not args.no_progress),
                )
            except subprocess.CalledProcessError as e:
                print(f”ERROR: {src.name} の処理に失敗: {e}”)
    finally:
        try:
            fmt.unlink()
        except Exception:
            pass

if __name__ == “__main__”:
    main()

最後にひとこと

「GPS付きGoPro素材を、地図連携しやすいGPXと配信用の軽い動画に一発で分解したい」――そのニーズに直球で応えるツールです。欠けているのはNVENCサポートくらい。必要なら一行追加でOK。遠回りせず、実務で“すぐ使える”設計になっています。

カテゴリー: プログラミング

タグ: 動画処理画像処理

GoProから緯度経度情報等のメタ情報の取り出し方

このスクリプトは何をする？（ソース付き解説）

処理の全体像

使い方（例）

要点と注意

ソースコード（全文）

最後にひとこと

コメントを残すコメントをキャンセル

物体検出の評価指標「AP」と「AR」をやさしく解説New!!

処理の全体像

使い方（例）

要点と注意

ソースコード（全文）

最後にひとこと

コメントを残す コメントをキャンセル

物体検出の評価指標「AP」と「AR」をやさしく解説New!!

コメントを残すコメントをキャンセル