@next2d/builder 0.1.6 → 0.1.8

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

@@ -13,6 +13,7 @@
 #include "ImageSource.h"
 #include "EventTarget.h"
 #include "v8/V8Util.h"
+#include "v8/WeakHandle.h"
 
 #include <mfapi.h>
 #include <mfidl.h>
@@ -47,6 +48,24 @@ struct VideoDecoder {
     bool playing = false;
     bool ended = false;
     double duration = 0.0;
+    double position = 0.0;        // 現在位置 (秒, サンプルタイムスタンプ由来)
+
+    // 先頭 (または指定秒) へシークする。loop 再生と currentTime 設定で使用。
+    bool Seek(double seconds)
+    {
+        if (!reader) return false;
+        PROPVARIANT var;
+        PropVariantInit(&var);
+        var.vt = VT_I8;
+        var.hVal.QuadPart = static_cast<LONGLONG>(seconds * 1e7);   // s -> 100ns
+        const bool ok = SUCCEEDED(reader->SetCurrentPosition(GUID_NULL, var));
+        PropVariantClear(&var);
+        if (ok) {
+            ended = false;
+            position = seconds;
+        }
+        return ok;
+    }
 
     bool Open(const std::vector<uint8_t>& bytes)
     {
@@ -87,13 +106,15 @@ struct VideoDecoder {
     {
         if (!reader) return false;
         DWORD flags = 0;
+        LONGLONG timestamp = 0;
         ComPtr<IMFSample> sample;
         if (FAILED(reader->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
-                                      nullptr, &flags, nullptr, &sample))) {
+                                      nullptr, &flags, &timestamp, &sample))) {
             return false;
         }
         if (flags & MF_SOURCE_READERF_ENDOFSTREAM) { ended = true; return false; }
         if (!sample) return false;
+        position = static_cast<double>(timestamp) / 1e7;   // 100ns -> s
 
         ComPtr<IMFMediaBuffer> buffer;
         sample->ConvertToContiguousBuffer(&buffer);
@@ -112,8 +133,6 @@ struct VideoDecoder {
     }
 };
 
-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());
@@ -144,7 +163,10 @@ void LoadVideo(v8::Isolate* isolate, v8::Local<v8::Object> self, const std::stri
         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));
+        // player は loadedmetadata / progress / canplaythrough を購読する
+        // (VideoRegisterEventUseCase)。ローカル読み込みは即完了のため順に発火する。
         FireVideoEvent(isolate, self, "loadedmetadata");
+        FireVideoEvent(isolate, self, "progress");
         FireVideoEvent(isolate, self, "canplaythrough");
     } else {
         FireVideoEvent(isolate, self, "error");
@@ -162,7 +184,20 @@ bool GetVideoFramePixels(v8::Isolate* isolate, v8::Local<v8::Object> obj,
     if (dec->playing && !dec->ended) {
         dec->ReadNextFrame();  // 描画のたびに次フレームへ進める(簡易フレーム進行)
         if (dec->ended) {
-            FireVideoEvent(isolate, obj, "ended");
+            // loop 指定時は先頭へ戻して継続、そうでなければ ended を通知
+            v8::Local<v8::Value> loop_v;
+            const bool loop =
+                obj->Get(isolate->GetCurrentContext(),
+                         v8util::Str(isolate, "loop")).ToLocal(&loop_v) &&
+                loop_v->BooleanValue(isolate);
+            if (loop && dec->Seek(0.0)) {
+                dec->ReadNextFrame();
+            } else {
+                dec->playing = false;
+                SetValue(isolate, obj, "ended", v8::Boolean::New(isolate, true));
+                SetValue(isolate, obj, "paused", v8::Boolean::New(isolate, true));
+                FireVideoEvent(isolate, obj, "ended");
+            }
         }
     }
     *out_rgba = dec->frame.data();
@@ -180,19 +215,69 @@ v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*ho
 
     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);
+    v8util::AttachWeak(isolate, self, dec);
 
     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, "paused", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "ended", v8::Boolean::New(isolate, false));
+    SetValue(isolate, self, "muted", v8::Boolean::New(isolate, false));
+    SetValue(isolate, self, "volume", v8::Number::New(isolate, 1.0));
+    SetValue(isolate, self, "autoplay", v8::Boolean::New(isolate, false));
     SetValue(isolate, self, "style", v8::Object::New(isolate));
     InstallEventTarget(isolate, self);
 
+    // currentTime: 取得はデコーダの現在位置、設定はシーク
+    self->SetNativeDataProperty(ctx, Str(isolate, "currentTime"),
+        [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
+            VideoDecoder* d = Decoder(info.This());
+            info.GetReturnValue().Set(
+                v8::Number::New(info.GetIsolate(), d ? d->position : 0.0));
+        },
+        [](v8::Local<v8::Name>, v8::Local<v8::Value> value,
+           const v8::PropertyCallbackInfo<void>& info) {
+            if (!value->IsNumber()) return;
+            VideoDecoder* d = Decoder(info.This());
+            if (d) {
+                d->Seek(value.As<v8::Number>()->Value());
+            }
+        }).Check();
+
+    // setAttribute / getAttribute (player は playsinline を設定する)
+    SetMethod(isolate, self, "setAttribute",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            if (a.Length() < 2) return;
+            v8::Isolate* iso = a.GetIsolate();
+            v8::Local<v8::Context> c = iso->GetCurrentContext();
+            v8::Local<v8::Value> attrs;
+            v8::Local<v8::Object> store;
+            if (a.This()->Get(c, v8util::Str(iso, "__attrs")).ToLocal(&attrs) && attrs->IsObject()) {
+                store = attrs.As<v8::Object>();
+            } else {
+                store = v8::Object::New(iso);
+                SetValue(iso, a.This(), "__attrs", store);
+            }
+            store->Set(c, a[0], a[1]).Check();
+        });
+    SetMethod(isolate, self, "getAttribute",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            a.GetReturnValue().SetNull();
+            if (a.Length() < 1) return;
+            v8::Isolate* iso = a.GetIsolate();
+            v8::Local<v8::Context> c = iso->GetCurrentContext();
+            v8::Local<v8::Value> attrs;
+            if (a.This()->Get(c, v8util::Str(iso, "__attrs")).ToLocal(&attrs) && attrs->IsObject()) {
+                v8::Local<v8::Value> v;
+                if (attrs.As<v8::Object>()->Get(c, a[0]).ToLocal(&v) && !v->IsUndefined()) {
+                    a.GetReturnValue().Set(v);
+                }
+            }
+        });
+
     // src セッター: 代入で読み込み開始
     self->SetNativeDataProperty(ctx, Str(isolate, "src"),
         [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ -218,12 +303,16 @@ v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*ho
     SetMethod(isolate, self, "play", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
         v8::Isolate* iso = a.GetIsolate();
         Decoder(a.This())->playing = true;
+        SetValue(iso, a.This(), "paused", v8::Boolean::New(iso, false));
+        SetValue(iso, a.This(), "ended", v8::Boolean::New(iso, false));
         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) {
+        v8::Isolate* iso = a.GetIsolate();
         Decoder(a.This())->playing = false;
+        SetValue(iso, a.This(), "paused", v8::Boolean::New(iso, true));
     });
     SetMethod(isolate, self, "canPlayType", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
         a.GetReturnValue().Set(Str(a.GetIsolate(), "maybe"));