@next2d/builder 0.1.5 → 0.1.7

package/templates/xbox/src/bindings/RasterCore.h

@@ -0,0 +1,265 @@
+// Canvas2D のソフトウェアラスタライザ純ロジック。
+// V8 / Windows API に依存しないため、macOS/Linux でも単体テストできる
+// (tests/raster_test.cpp)。Canvas2D.cpp はこのヘッダの薄いバインディング層。
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace next2d::raster {
+
+inline constexpr double kPi = 3.14159265358979323846;
+
+struct Mat { double a=1,b=0,c=0,d=1,e=0,f=0; };
+
+struct Point { double x, y; };
+
+struct SubPath {
+    std::vector<Point> pts;
+    bool closed = false;
+};
+
+struct RGBA { uint8_t r=0,g=0,b=0,a=255; };
+
+// クリップ矩形 (デバイス座標, [x0,x1) x [y0,y1))。active=false なら無制限。
+struct ClipRect {
+    bool   active = false;
+    double x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+};
+
+// RGBA8 のピクセルバッファ。
+struct Surface {
+    int width = 0;
+    int height = 0;
+    std::vector<uint8_t> pixels;
+
+    Surface(int w, int h)
+        : width(w), height(h), pixels(static_cast<size_t>(w) * h * 4, 0) {}
+};
+
+inline Point Apply(const Mat& m, double x, double y)
+{
+    return { m.a * x + m.c * y + m.e, m.b * x + m.d * y + m.f };
+}
+
+inline Mat Multiply(const Mat& m, const Mat& n)
+{
+    return {
+        m.a * n.a + m.c * n.b,
+        m.b * n.a + m.d * n.b,
+        m.a * n.c + m.c * n.d,
+        m.b * n.c + m.d * n.d,
+        m.a * n.e + m.c * n.f + m.e,
+        m.b * n.e + m.d * n.f + m.f,
+    };
+}
+
+// "bold 24px sans-serif" 等から px を抽出 (近似メトリクス用)
+inline double FontPixelSize(const std::string& font)
+{
+    const auto pos = font.find("px");
+    if (pos == std::string::npos) return 10.0;
+    size_t start = pos;
+    while (start > 0 && (isdigit(static_cast<unsigned char>(font[start - 1])) || font[start - 1] == '.')) --start;
+    try { return std::stod(font.substr(start, pos - start)); } catch (...) { return 10.0; }
+}
+
+// #rgb / #rrggbb / rgb(...) / rgba(...) を解析する。
+inline RGBA ParseColor(const std::string& s)
+{
+    RGBA c;
+    if (s.empty()) return c;
+    if (s[0] == '#') {
+        auto hex = [&](int i, int n) {
+            return static_cast<uint8_t>(std::stoi(s.substr(i, n), nullptr, 16) * (n == 1 ? 17 : 1));
+        };
+        if (s.size() == 4) { c.r = hex(1,1); c.g = hex(2,1); c.b = hex(3,1); }
+        else if (s.size() >= 7) { c.r = hex(1,2); c.g = hex(3,2); c.b = hex(5,2); }
+        return c;
+    }
+    if (s.rfind("rgb", 0) == 0) {
+        double vals[4] = {0,0,0,1};
+        int n = 0; size_t i = s.find('(');
+        while (i != std::string::npos && n < 4) {
+            i++;
+            try { vals[n++] = std::stod(s.substr(i)); } catch (...) { break; }
+            i = s.find(',', i);
+        }
+        c.r = static_cast<uint8_t>(vals[0]); c.g = static_cast<uint8_t>(vals[1]);
+        c.b = static_cast<uint8_t>(vals[2]); c.a = static_cast<uint8_t>(vals[3] * 255);
+    }
+    return c;
+}
+
+// 1 ピクセルをアルファ合成する。クリップ矩形の外は書き込まない。
+inline void Blend(Surface& s, const ClipRect& clip, int x, int y, const RGBA& col, double alpha)
+{
+    if (x < 0 || y < 0 || x >= s.width || y >= s.height) return;
+    if (clip.active && (x < clip.x0 || x >= clip.x1 || y < clip.y0 || y >= clip.y1)) return;
+    size_t i = (static_cast<size_t>(y) * s.width + x) * 4;
+    double a = (col.a / 255.0) * alpha;
+    s.pixels[i+0] = static_cast<uint8_t>(col.r * a + s.pixels[i+0] * (1 - a));
+    s.pixels[i+1] = static_cast<uint8_t>(col.g * a + s.pixels[i+1] * (1 - a));
+    s.pixels[i+2] = static_cast<uint8_t>(col.b * a + s.pixels[i+2] * (1 - a));
+    s.pixels[i+3] = static_cast<uint8_t>(255 * a + s.pixels[i+3] * (1 - a));
+}
+
+// スキャンライン塗り (nonzero winding)。
+// HTML Canvas 仕様どおり、未クローズのサブパスも塗りでは暗黙にクローズする
+// (isPointInPath と同じ扱い)。
+inline void FillPath(Surface& s, const ClipRect& clip,
+                     const std::vector<SubPath>& path, const RGBA& col, double alpha)
+{
+    double miny = 1e18, maxy = -1e18;
+    for (auto& sp : path) for (auto& p : sp.pts) { miny = std::min(miny,p.y); maxy = std::max(maxy,p.y); }
+    if (maxy < miny) return;
+    int y0 = std::max(0, static_cast<int>(std::floor(miny)));
+    int y1 = std::min(s.height - 1, static_cast<int>(std::ceil(maxy)));
+    for (int y = y0; y <= y1; ++y) {
+        double sy = y + 0.5;
+        std::vector<std::pair<double,int>> xs; // x, winding dir
+        for (auto& sp : path) {
+            size_t n = sp.pts.size();
+            if (n < 2) continue;
+            for (size_t i = 0; i < n; ++i) {
+                Point a = sp.pts[i];
+                Point b = sp.pts[(i+1) % n];
+                if ((a.y <= sy && b.y > sy) || (b.y <= sy && a.y > sy)) {
+                    double t = (sy - a.y) / (b.y - a.y);
+                    xs.push_back({a.x + t * (b.x - a.x), a.y < b.y ? 1 : -1});
+                }
+            }
+        }
+        std::sort(xs.begin(), xs.end());
+        int wind = 0;
+        for (size_t i = 0; i + 1 < xs.size(); ++i) {
+            wind += xs[i].second;
+            if (wind != 0) {
+                int xa = std::max(0, static_cast<int>(std::floor(xs[i].first)));
+                int xb = std::min(s.width - 1, static_cast<int>(std::ceil(xs[i+1].first)));
+                for (int x = xa; x <= xb; ++x) Blend(s, clip, x, y, col, alpha);
+            }
+        }
+    }
+}
+
+// 単純な線分描画 (太さは近似)。stroke は未クローズのサブパスを閉じない。
+inline void StrokePath(Surface& s, const ClipRect& clip,
+                       const std::vector<SubPath>& path, const RGBA& col, double alpha)
+{
+    for (auto& sp : path) {
+        size_t n = sp.pts.size();
+        size_t last = sp.closed ? n : (n > 0 ? n - 1 : 0);
+        for (size_t i = 0; i < last; ++i) {
+            Point a0 = sp.pts[i], b0 = sp.pts[(i+1) % n];
+            int steps = static_cast<int>(std::hypot(b0.x - a0.x, b0.y - a0.y)) + 1;
+            for (int st = 0; st <= steps; ++st) {
+                double t = static_cast<double>(st) / steps;
+                Blend(s, clip, static_cast<int>(a0.x + (b0.x-a0.x)*t),
+                               static_cast<int>(a0.y + (b0.y-a0.y)*t), col, alpha);
+            }
+        }
+    }
+}
+
+// nonzero winding の点内包判定。ヒット判定の中核。
+inline bool PointInPath(const std::vector<SubPath>& path, double px, double py)
+{
+    int wind = 0;
+    for (auto& sp : path) {
+        size_t n = sp.pts.size();
+        if (n < 2) continue;
+        for (size_t i = 0; i < n; ++i) {
+            Point A = sp.pts[i];
+            Point B = sp.pts[(i+1) % n];
+            if ((A.y <= py && B.y > py) || (B.y <= py && A.y > py)) {
+                double t = (py - A.y) / (B.y - A.y);
+                double xcross = A.x + t * (B.x - A.x);
+                if (xcross > px) wind += (A.y < B.y) ? 1 : -1;
+            }
+        }
+    }
+    return wind != 0;
+}
+
+// パス全点の外接矩形。点が無ければ false。
+inline bool PathBounds(const std::vector<SubPath>& path,
+                       double* minx, double* miny, double* maxx, double* maxy)
+{
+    bool any = false;
+    *minx = 1e18; *miny = 1e18; *maxx = -1e18; *maxy = -1e18;
+    for (auto& sp : path) for (auto& p : sp.pts) {
+        *minx = std::min(*minx, p.x); *maxx = std::max(*maxx, p.x);
+        *miny = std::min(*miny, p.y); *maxy = std::max(*maxy, p.y);
+        any = true;
+    }
+    return any;
+}
+
+// クリップ矩形へ [nx0,nx1)x[ny0,ny1) を積集合で反映する (clip() の実体)。
+inline void IntersectClip(ClipRect& clip, double nx0, double ny0, double nx1, double ny1)
+{
+    if (clip.active) {
+        clip.x0 = std::max(clip.x0, nx0);
+        clip.y0 = std::max(clip.y0, ny0);
+        clip.x1 = std::min(clip.x1, nx1);
+        clip.y1 = std::min(clip.y1, ny1);
+    } else {
+        clip.active = true;
+        clip.x0 = nx0; clip.y0 = ny0; clip.x1 = nx1; clip.y1 = ny1;
+    }
+}
+
+// 3次ベジェを現在サブパスへフラット化して追記する。p0 は変換済みの直前点。
+inline void FlattenCubic(std::vector<Point>& out,
+                         Point p0, Point p1, Point p2, Point p3, int steps = 16)
+{
+    for (int i = 1; i <= steps; ++i) {
+        double t = static_cast<double>(i) / steps, u = 1 - t;
+        out.push_back({
+            u*u*u*p0.x + 3*u*u*t*p1.x + 3*u*t*t*p2.x + t*t*t*p3.x,
+            u*u*u*p0.y + 3*u*u*t*p1.y + 3*u*t*t*p2.y + t*t*t*p3.y });
+    }
+}
+
+// 2次ベジェを現在サブパスへフラット化して追記する。
+inline void FlattenQuadratic(std::vector<Point>& out, Point p0, Point p1, Point p2, int steps = 12)
+{
+    for (int i = 1; i <= steps; ++i) {
+        double t = static_cast<double>(i) / steps, u = 1 - t;
+        out.push_back({
+            u*u*p0.x + 2*u*t*p1.x + t*t*p2.x,
+            u*u*p0.y + 2*u*t*p1.y + t*t*p2.y });
+    }
+}
+
+// arc() を変換適用済みの点列へフラット化して追記する。ccw の巻き戻しも処理。
+inline void FlattenArc(std::vector<Point>& out, const Mat& m,
+                       double cx, double cy, double r,
+                       double start, double end, bool ccw, int steps = 32)
+{
+    if (ccw && end > start) end -= 2 * kPi;
+    if (!ccw && end < start) end += 2 * kPi;
+    for (int i = 0; i <= steps; ++i) {
+        double t = start + (end - start) * (static_cast<double>(i) / steps);
+        out.push_back(Apply(m, cx + std::cos(t) * r, cy + std::sin(t) * r));
+    }
+}
+
+// clearRect: 矩形を透明で塗りつぶす (クリップ非適用、Canvas 仕様どおり全消去)。
+inline void ClearRect(Surface& s, double x, double y, double w, double h)
+{
+    for (int yy = static_cast<int>(y); yy < y + h; ++yy)
+        for (int xx = static_cast<int>(x); xx < x + w; ++xx)
+            if (xx >= 0 && yy >= 0 && xx < s.width && yy < s.height) {
+                size_t i = (static_cast<size_t>(yy) * s.width + xx) * 4;
+                s.pixels[i] = s.pixels[i+1] = s.pixels[i+2] = s.pixels[i+3] = 0;
+            }
+}
+
+} // namespace next2d::raster

package/templates/xbox/src/bindings/Timers.cpp

@@ -0,0 +1,87 @@
+#include "Bindings.h"
+
+#include "HostContext.h"
+#include "EventLoop.h"
+#include "v8/V8Util.h"
+
+namespace next2d {
+
+namespace {
+
+EventLoop* Loop(v8::Isolate* isolate)
+{
+    // 実行中の Context (main / worker) に紐づく EventLoop を返す。
+    return CurrentEventLoop(isolate);
+}
+
+// setTimeout(fn, delay) / setInterval(fn, delay)
+template <bool Repeat>
+void SetTimer(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() < 1 || !args[0]->IsFunction()) {
+        v8util::ThrowTypeError(isolate, "callback function required");
+        return;
+    }
+
+    v8::Local<v8::Function> callback = args[0].As<v8::Function>();
+    double delay = 0.0;
+    if (args.Length() >= 2 && args[1]->IsNumber()) {
+        delay = args[1].As<v8::Number>()->Value();
+    }
+
+    const uint32_t id = Loop(isolate)->SetTimer(callback, delay, Repeat);
+    args.GetReturnValue().Set(v8::Integer::NewFromUnsigned(isolate, id));
+}
+
+void ClearTimer(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() >= 1 && args[0]->IsNumber()) {
+        Loop(isolate)->ClearTimer(args[0].As<v8::Uint32>()->Value());
+    }
+}
+
+void RequestAnimationFrame(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() < 1 || !args[0]->IsFunction()) {
+        v8util::ThrowTypeError(isolate, "callback function required");
+        return;
+    }
+    const uint32_t id = Loop(isolate)->RequestAnimationFrame(args[0].As<v8::Function>());
+    args.GetReturnValue().Set(v8::Integer::NewFromUnsigned(isolate, id));
+}
+
+void CancelAnimationFrame(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() >= 1 && args[0]->IsNumber()) {
+        Loop(isolate)->CancelAnimationFrame(args[0].As<v8::Uint32>()->Value());
+    }
+}
+
+void PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    args.GetReturnValue().Set(v8::Number::New(isolate, Loop(isolate)->Now()));
+}
+
+} // namespace
+
+void InstallTimers(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* /*host*/)
+{
+    v8util::SetMethod(isolate, global, "setTimeout",  SetTimer<false>);
+    v8util::SetMethod(isolate, global, "setInterval", SetTimer<true>);
+    v8util::SetMethod(isolate, global, "clearTimeout",  ClearTimer);
+    v8util::SetMethod(isolate, global, "clearInterval", ClearTimer);
+    v8util::SetMethod(isolate, global, "requestAnimationFrame", RequestAnimationFrame);
+    v8util::SetMethod(isolate, global, "cancelAnimationFrame",  CancelAnimationFrame);
+
+    // performance.now()
+    v8::Local<v8::Object> performance = v8::Object::New(isolate);
+    v8util::SetMethod(isolate, performance, "now", PerformanceNow);
+    v8util::SetValue(isolate, global, "performance", performance);
+}
+
+} // namespace next2d

package/templates/xbox/src/bindings/Video.cpp

@@ -0,0 +1,235 @@
+// HTMLVideoElement の最小実装 (Media Foundation)。
+//
+// player は document.createElement("video") で生成し、描画ループ中に
+// ctx2d.drawImage(videoElement) でフレームを OffscreenCanvas に描いて GPU へ渡す
+// (VideoGenerateRenderQueueUseCase)。よって video 要素は「画像ソース」として
+// 現在フレームの RGBA を返せる必要がある (GetImageSourcePixels が __isVideoElement を扱う)。
+//
+// NOTE: フレーム精度・シーク・音声同期・ストリーミングは最小限。実機で要検証。
+#include "Bindings.h"
+
+#include "HostContext.h"
+#include "AssetLoader.h"
+#include "ImageSource.h"
+#include "EventTarget.h"
+#include "v8/V8Util.h"
+
+#include <mfapi.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <shlwapi.h>
+#include <wrl/client.h>
+
+#include <string>
+#include <vector>
+
+#pragma comment(lib, "mfplat.lib")
+#pragma comment(lib, "mfreadwrite.lib")
+#pragma comment(lib, "mfuuid.lib")
+#pragma comment(lib, "shlwapi.lib")
+
+using Microsoft::WRL::ComPtr;
+
+namespace next2d {
+
+using v8util::Str;
+using v8util::SetMethod;
+using v8util::SetValue;
+using v8util::ToStdString;
+
+namespace {
+
+struct VideoDecoder {
+    ComPtr<IMFSourceReader> reader;
+    uint32_t width = 0;
+    uint32_t height = 0;
+    std::vector<uint8_t> frame;   // RGBA8 (現在フレーム)
+    bool playing = false;
+    bool ended = false;
+    double duration = 0.0;
+
+    bool Open(const std::vector<uint8_t>& bytes)
+    {
+        MFStartup(MF_VERSION);
+        ComPtr<IStream> stream = SHCreateMemStream(bytes.data(), static_cast<UINT>(bytes.size()));
+        if (!stream) return false;
+        ComPtr<IMFByteStream> byte_stream;
+        if (FAILED(MFCreateMFByteStreamOnStream(stream.Get(), &byte_stream))) return false;
+        if (FAILED(MFCreateSourceReaderFromByteStream(byte_stream.Get(), nullptr, &reader))) return false;
+
+        // 出力を RGB32 (BGRX) に指定
+        ComPtr<IMFMediaType> out;
+        MFCreateMediaType(&out);
+        out->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
+        out->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32);
+        if (FAILED(reader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, out.Get()))) {
+            return false;
+        }
+
+        ComPtr<IMFMediaType> actual;
+        reader->GetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, &actual);
+        UINT32 w = 0, h = 0;
+        MFGetAttributeSize(actual.Get(), MF_MT_FRAME_SIZE, &w, &h);
+        width = w; height = h;
+        frame.assign(static_cast<size_t>(w) * h * 4, 0);
+
+        PROPVARIANT var;
+        if (SUCCEEDED(reader->GetPresentationAttribute(MF_SOURCE_READER_MEDIASOURCE,
+                                                       MF_PD_DURATION, &var))) {
+            duration = static_cast<double>(var.uhVal.QuadPart) / 1e7;  // 100ns -> s
+            PropVariantClear(&var);
+        }
+        return width > 0 && height > 0;
+    }
+
+    // 次サンプルを RGBA へデコードして frame を更新する。
+    bool ReadNextFrame()
+    {
+        if (!reader) return false;
+        DWORD flags = 0;
+        ComPtr<IMFSample> sample;
+        if (FAILED(reader->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
+                                      nullptr, &flags, nullptr, &sample))) {
+            return false;
+        }
+        if (flags & MF_SOURCE_READERF_ENDOFSTREAM) { ended = true; return false; }
+        if (!sample) return false;
+
+        ComPtr<IMFMediaBuffer> buffer;
+        sample->ConvertToContiguousBuffer(&buffer);
+        BYTE* data = nullptr; DWORD len = 0;
+        buffer->Lock(&data, nullptr, &len);
+        // RGB32 = BGRX。上下反転して RGBA へ (MF は bottom-up の場合がある → ここでは top-down 前提)
+        const size_t px = static_cast<size_t>(width) * height;
+        for (size_t i = 0; i < px && (i * 4 + 3) < len; ++i) {
+            frame[i*4+0] = data[i*4+2]; // R <- B 位置
+            frame[i*4+1] = data[i*4+1]; // G
+            frame[i*4+2] = data[i*4+0]; // B <- R 位置
+            frame[i*4+3] = 255;
+        }
+        buffer->Unlock();
+        return true;
+    }
+};
+
+void ReleaseVideo(const v8::WeakCallbackInfo<VideoDecoder>& info) { delete info.GetParameter(); }
+
+VideoDecoder* Decoder(v8::Local<v8::Object> obj)
+{
+    return static_cast<VideoDecoder*>(obj->GetInternalField(0).As<v8::External>()->Value());
+}
+
+void FireVideoEvent(v8::Isolate* isolate, v8::Local<v8::Object> self, const char* type)
+{
+    v8::Local<v8::Object> ev = v8::Object::New(isolate);
+    SetValue(isolate, ev, "type", Str(isolate, type));
+    SetValue(isolate, ev, "target", self);
+    DispatchEvent(isolate, self, ev);
+}
+
+void LoadVideo(v8::Isolate* isolate, v8::Local<v8::Object> self, const std::string& url)
+{
+    HostContext* host = HostContext::From(isolate);
+    std::vector<uint8_t> bytes;
+    std::string text;
+    if (url.rfind("blob:", 0) == 0 && ResolveObjectURL(url, &text)) {
+        bytes.assign(text.begin(), text.end());
+    } else if (host->assets) {
+        auto b = host->assets->ReadBinary(url);
+        if (b) bytes = std::move(*b);
+    }
+    VideoDecoder* dec = Decoder(self);
+    if (!bytes.empty() && dec->Open(bytes)) {
+        SetValue(isolate, self, "videoWidth", v8::Integer::NewFromUnsigned(isolate, dec->width));
+        SetValue(isolate, self, "videoHeight", v8::Integer::NewFromUnsigned(isolate, dec->height));
+        SetValue(isolate, self, "duration", v8::Number::New(isolate, dec->duration));
+        SetValue(isolate, self, "readyState", v8::Integer::New(isolate, 4));
+        FireVideoEvent(isolate, self, "loadedmetadata");
+        FireVideoEvent(isolate, self, "canplaythrough");
+    } else {
+        FireVideoEvent(isolate, self, "error");
+    }
+}
+
+} // namespace
+
+// GetImageSourcePixels (Image.cpp) から呼ばれる: video の現在フレーム RGBA を返す。
+bool GetVideoFramePixels(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                         const uint8_t** out_rgba, uint32_t* out_w, uint32_t* out_h)
+{
+    VideoDecoder* dec = Decoder(obj);
+    if (!dec || dec->width == 0) return false;
+    if (dec->playing && !dec->ended) {
+        dec->ReadNextFrame();  // 描画のたびに次フレームへ進める(簡易フレーム進行)
+        if (dec->ended) {
+            FireVideoEvent(isolate, obj, "ended");
+        }
+    }
+    *out_rgba = dec->frame.data();
+    *out_w = dec->width;
+    *out_h = dec->height;
+    return true;
+}
+
+v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*host*/)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
+    tmpl->SetInternalFieldCount(1);
+    v8::Local<v8::Object> self = tmpl->NewInstance(ctx).ToLocalChecked();
+
+    auto* dec = new VideoDecoder();
+    self->SetInternalField(0, v8::External::New(isolate, dec));
+    auto* handle = new v8::Global<v8::Object>(isolate, self);
+    handle->SetWeak(dec, ReleaseVideo, v8::WeakCallbackType::kParameter);
+
+    SetValue(isolate, self, "__isVideoElement", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "tagName", Str(isolate, "VIDEO"));
+    SetValue(isolate, self, "videoWidth", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "videoHeight", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "currentTime", v8::Number::New(isolate, 0));
+    SetValue(isolate, self, "readyState", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "loop", v8::Boolean::New(isolate, false));
+    SetValue(isolate, self, "style", v8::Object::New(isolate));
+    InstallEventTarget(isolate, self);
+
+    // src セッター: 代入で読み込み開始
+    self->SetNativeDataProperty(ctx, Str(isolate, "src"),
+        [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
+            v8::Local<v8::Value> v;
+            if (info.This()->Get(info.GetIsolate()->GetCurrentContext(),
+                v8util::Str(info.GetIsolate(), "__src")).ToLocal(&v)) {
+                info.GetReturnValue().Set(v);
+            }
+        },
+        [](v8::Local<v8::Name>, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) {
+            v8::Isolate* iso = info.GetIsolate();
+            SetValue(iso, info.This(), "__src", value);
+            LoadVideo(iso, info.This(), ToStdString(iso, value));
+        }).Check();
+
+    SetMethod(isolate, self, "load", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        v8::Isolate* iso = a.GetIsolate();
+        v8::Local<v8::Value> src;
+        if (a.This()->Get(iso->GetCurrentContext(), Str(iso, "__src")).ToLocal(&src) && src->IsString()) {
+            LoadVideo(iso, a.This(), ToStdString(iso, src));
+        }
+    });
+    SetMethod(isolate, self, "play", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        v8::Isolate* iso = a.GetIsolate();
+        Decoder(a.This())->playing = true;
+        auto r = v8::Promise::Resolver::New(iso->GetCurrentContext()).ToLocalChecked();
+        r->Resolve(iso->GetCurrentContext(), v8::Undefined(iso)).Check();
+        a.GetReturnValue().Set(r->GetPromise());
+    });
+    SetMethod(isolate, self, "pause", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        Decoder(a.This())->playing = false;
+    });
+    SetMethod(isolate, self, "canPlayType", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        a.GetReturnValue().Set(Str(a.GetIsolate(), "maybe"));
+    });
+
+    return self;
+}
+
+} // namespace next2d