Merge pull request #9 from MengLi619/dsk

MengLi619 · web-flow · commit d027c8976b16 · 2020-11-16T21:58:58.000+08:00
add dsk
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -32,6 +32,8 @@ SET(OBS_NODE_SOURCES
     src/cpp/scene.cpp
     src/cpp/display.h
     src/cpp/display.cpp
+    src/cpp/dsk.h
+    src/cpp/dsk.cpp
     src/cpp/platform/platform.h)
 
 if (WIN32)
diff --git a/src/cpp/dsk.cpp b/src/cpp/dsk.cpp
@@ -0,0 +1,21 @@
+#include "dsk.h"
+
+Dsk::Dsk(std::string &id, std::string &position, std::string &url, int left, int top, int width, int height) :
+    position(position),
+    url(url),
+    left(left),
+    top(top),
+    width(width),
+    height(height) {
+    obs_data_t *obs_data = obs_data_create();
+    obs_data_set_string(obs_data, "file", url.c_str());
+    obs_data_set_bool(obs_data, "unload", false);
+    obs_source = obs_source_create("image_source", id.c_str(), obs_data, nullptr);
+    obs_data_release(obs_data);
+}
+
+Dsk::~Dsk() {
+    if (obs_source) {
+        obs_source_release(obs_source);
+    }
+}
diff --git a/src/cpp/dsk.h b/src/cpp/dsk.h
@@ -0,0 +1,31 @@
+#pragma once
+#include <string>
+#include <obs.h>
+
+class Dsk {
+
+public:
+    Dsk(std::string &id, std::string &position, std::string &url, int left, int top, int width, int height);
+    ~Dsk();
+
+    std::string &getPosition() { return position; }
+
+    int getLeft() const { return left; }
+
+    int getTop() const { return top; }
+
+    int getWidth() const { return width; }
+
+    int getHeight() const { return height; }
+
+    obs_source_t *getObsSource() { return obs_source; }
+
+private:
+    obs_source_t *obs_source;
+    std::string position;
+    std::string url;
+    int left;
+    int top;
+    int width;
+    int height;
+};
diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp
@@ -63,6 +63,18 @@ Napi::Value updateSource(const Napi::CallbackInfo &info) {
     return info.Env().Undefined();
 }
 
+Napi::Value addDSK(const Napi::CallbackInfo &info) {
+    std::string id = info[0].As<Napi::String>();
+    std::string position = info[1].As<Napi::String>();
+    std::string url = info[2].As<Napi::String>();
+    int left = info[3].As<Napi::Number>();
+    int top = info[4].As<Napi::Number>();
+    int width = info[5].As<Napi::Number>();
+    int height = info[6].As<Napi::Number>();
+    TRY_METHOD(studio->addDSK(id, position, url, left, top, width, height))
+    return info.Env().Undefined();
+}
+
 Napi::Value muteSource(const Napi::CallbackInfo &info) {
     std::string sceneId = info[0].As<Napi::String>();
     std::string sourceId = info[1].As<Napi::String>();
@@ -135,6 +147,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "createDisplay"), Napi::Function::New(env, createDisplay));
     exports.Set(Napi::String::New(env, "destroyDisplay"), Napi::Function::New(env, destroyDisplay));
     exports.Set(Napi::String::New(env, "moveDisplay"), Napi::Function::New(env, moveDisplay));
+    exports.Set(Napi::String::New(env, "addDSK"), Napi::Function::New(env, addDSK));
     return exports;
 }
 
diff --git a/src/cpp/scene.cpp b/src/cpp/scene.cpp
@@ -1,9 +1,21 @@
 #include "scene.h"
+#include "dsk.h"
+#include <map>
 
 Scene::Scene(std::string &id, Settings *settings) :
         id(id),
         settings(settings),
-        obs_scene(createObsScene(id)) {
+        obs_scene(createObsScene(id)),
+        obs_output_scene(nullptr) {
+}
+
+Scene::~Scene() {
+    if (obs_scene) {
+        obs_scene_release(obs_scene);
+    }
+    if (obs_output_scene) {
+        obs_scene_release(obs_scene);
+    }
 }
 
 void Scene::addSource(std::string &sourceId, SourceType sourceType, std::string &sourceUrl) {
@@ -47,6 +59,65 @@ obs_scene_t *Scene::createObsScene(std::string &sceneId) {
     return scene;
 }
 
+obs_scene_t *Scene::getObsOutputScene(std::map<std::string, Dsk*> &dsks) {
+    if (obs_output_scene) {
+        obs_scene_release(obs_output_scene);
+        obs_output_scene = nullptr;
+    }
+
+    // create duplicate scene
+    obs_output_scene = obs_scene_duplicate(obs_scene, (id + "_output").c_str(), OBS_SCENE_DUP_REFS);
+
+    // add dsks
+    for (auto &dsk : dsks) {
+        // Add the source to the scene
+        obs_scene_item *obs_scene_item = obs_scene_add(obs_output_scene, dsk.second->getObsSource());
+        if (!obs_scene_item) {
+            throw std::runtime_error("Failed to add scene item.");
+        }
+
+        // set position
+        struct vec2 pos = {};
+        pos.x = (float)dsk.second->getLeft();
+        pos.y = (float)dsk.second->getTop();
+        obs_sceneitem_set_pos(obs_scene_item, &pos);
+
+        // set align
+        std::string position = dsk.second->getPosition();
+        uint32_t align = 0;
+        if (position == "top") {
+            align = OBS_ALIGN_TOP;
+        } else if (position == "top-right") {
+            align = OBS_ALIGN_TOP + OBS_ALIGN_RIGHT;
+        } else if (position == "right") {
+            align = OBS_ALIGN_RIGHT;
+        } else if (position == "bottom-right") {
+            align = OBS_ALIGN_BOTTOM + OBS_ALIGN_RIGHT;
+        } else if (position == "bottom") {
+            align = OBS_ALIGN_BOTTOM;
+        } else if (position == "bottom-left") {
+            align = OBS_ALIGN_BOTTOM + OBS_ALIGN_LEFT;
+        } else if (position == "left") {
+            align = OBS_ALIGN_LEFT;
+        } else if (position == "top-left") {
+            align = OBS_ALIGN_TOP + OBS_ALIGN_LEFT;
+        }
+        obs_sceneitem_set_bounds_alignment(obs_scene_item, align);
+
+        // set size
+        struct vec2 bounds = {};
+        bounds.x = (float)dsk.second->getWidth();
+        bounds.y = (float)dsk.second->getHeight();
+        obs_sceneitem_set_bounds_type(obs_scene_item, OBS_BOUNDS_SCALE_INNER);
+        obs_sceneitem_set_bounds(obs_scene_item, &bounds);
+
+        // set top most
+        obs_sceneitem_set_order(obs_scene_item, OBS_ORDER_MOVE_TOP);
+    }
+
+    return obs_output_scene;
+}
+
 Napi::Object Scene::getNapiScene(const Napi::Env &env) {
     auto napiScene = Napi::Object::New(env);
     auto napiSources = Napi::Array::New(env, sources.size());
diff --git a/src/cpp/scene.h b/src/cpp/scene.h
@@ -2,20 +2,20 @@
 
 #include "settings.h"
 #include "source.h"
+#include "dsk.h"
 #include <string>
 #include <map>
 #include <obs.h>
 
 class Scene {
 public:
     Scene(std::string &id, Settings *settings);
+    ~Scene();
 
     std::string getId() { return id; }
 
     obs_scene_t *getObsScene() { return obs_scene; }
 
-    const std::map<std::string, Source *> &getSources() { return sources; }
-
     void addSource(std::string &sourceId, SourceType sourceType, std::string &sourceUrl);
 
     void updateSource(std::string &sourceId, std::string &sourceUrl);
@@ -24,6 +24,8 @@ class Scene {
 
     void restartSource(std::string &sourceId);
 
+    obs_scene_t *getObsOutputScene(std::map<std::string, Dsk*> &dsks);
+
     Napi::Object getNapiScene(const Napi::Env &env);
 
 private:
@@ -32,5 +34,6 @@ class Scene {
     std::string id;
     Settings *settings;
     obs_scene_t *obs_scene;
+    obs_scene_t *obs_output_scene;
     std::map<std::string, Source *> sources;
 };
diff --git a/src/cpp/source.cpp b/src/cpp/source.cpp
@@ -45,8 +45,8 @@ void Source::start() {
         if (settings->videoDecoder) {
             obs_data_set_bool(obs_data, "hw_decode", settings->videoDecoder->hardwareEnable);
         }
-        obs_data_set_bool(obs_data, "close_when_inactive", false);
-        obs_data_set_bool(obs_data, "restart_on_activate", false);
+        obs_data_set_bool(obs_data, "close_when_inactive", false);  // make source always read
+        obs_data_set_bool(obs_data, "restart_on_activate", false);  // make source always read
         obs_source = obs_source_create("ffmpeg_source", this->id.c_str(), obs_data, nullptr);
     }
 
diff --git a/src/cpp/studio.cpp b/src/cpp/studio.cpp
@@ -262,6 +262,15 @@ void Studio::restartSource(std::string &sceneId, std::string &sourceId) {
     scene->restartSource(sourceId);
 }
 
+void Studio::addDSK(std::string &id, std::string &position, std::string &url, int left, int top, int width, int height) {
+    auto found = dsks.find(id);
+    if (found != dsks.end()) {
+        throw std::logic_error("Dsk " + id + " already existed");
+    }
+    auto *dsk = new Dsk(id, position, url, left, top, width, height);
+    dsks[id] = dsk;
+}
+
 void Studio::switchToScene(std::string &sceneId, std::string &transitionType, int transitionMs) {
     Scene *next = findScene(sceneId);
     if (next == nullptr) {
@@ -284,7 +293,7 @@ void Studio::switchToScene(std::string &sceneId, std::string &transitionType, in
 
     obs_source_t *transition = transitions[transitionType];
     if (currentScene) {
-        obs_transition_set(transition, obs_scene_get_source(currentScene->getObsScene()));
+        obs_transition_set(transition, obs_scene_get_source(currentScene->getObsOutputScene(dsks)));
     }
 
     obs_set_output_source(0, transition);
@@ -293,7 +302,7 @@ void Studio::switchToScene(std::string &sceneId, std::string &transitionType, in
             transition,
             OBS_TRANSITION_MODE_AUTO,
             transitionMs,
-            obs_scene_get_source(next->getObsScene())
+            obs_scene_get_source(next->getObsOutputScene(dsks))
     );
 
     if (!ret) {
diff --git a/src/cpp/studio.h b/src/cpp/studio.h
@@ -17,6 +17,7 @@ class Studio {
     void updateSource(std::string &sceneId, std::string &sourceId, std::string &sourceUrl);
     void muteSource(std::string &sceneId, std::string &sourceId, bool mute);
     void restartSource(std::string &sceneId, std::string &sourceId);
+    void addDSK(std::string &id, std::string &position, std::string &url, int left, int top, int width, int height);
     void switchToScene(std::string &sceneId, std::string &transitionType, int transitionMs);
     const std::map<std::string, Scene*>& getScenes();
     void createDisplay(std::string &displayName, void *parentHandle, int scaleFactor, std::string &sourceId);
@@ -35,6 +36,7 @@ class Studio {
     std::map<std::string, Scene*> scenes;
     std::map<std::string, obs_source_t*> transitions;
     std::map<std::string, Display*> displays;
+    std::map<std::string, Dsk*> dsks;
     Scene *currentScene;
     obs_encoder_t *video_encoder;
     obs_encoder_t *audio_encoder;
diff --git a/src/index.ts b/src/index.ts
@@ -22,10 +22,12 @@ obs.setObsPath(obsPath);
 
 declare namespace obs {
 
-    export type RateControl = 'CBR';
+    export type RateControl = 'CBR' | 'VBR';
 
     export type SourceType = 'Image' | 'MediaSource';
 
+    export type Position = 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'left' | 'top-left' | 'center';
+
     export type TransitionType = 'cut_transition' | 'fade_transition' | 'swipe_transition' | 'slide_transition';
 
     export interface Scene {
@@ -87,13 +89,6 @@ declare namespace obs {
         output?: OutputSettings;
     }
 
-    export interface Bounds {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }
-
     export interface ObsNode {
         setObsPath(obsPath: string): void
         startup(settings: Settings): void;
@@ -108,6 +103,7 @@ declare namespace obs {
         createDisplay(name: string, parentWindow: Buffer, scaleFactor: number, sourceId: string);
         destroyDisplay(name: string);
         moveDisplay(name: string, x: number, y: number, width: number, height: number);
+        addDSK(id: string, position: Position, url: string, left: number, top: number, width: number, height: number): void;
     }
 }
 
diff --git a/test/test.ts b/test/test.ts
@@ -1,11 +1,10 @@
 import * as obs from '../src';
-import {SourceType} from '../src';
 import * as readline from 'readline';
 
 interface Source {
     sceneId: string;
     sourceId: string;
-    sourceType: SourceType;
+    sourceType: obs.SourceType;
     sourceUrl: string;
 }
 
@@ -44,6 +43,18 @@ const settings: obs.Settings = {
     },
 };
 
+const dsks = [
+    {
+        id: "dsk1",
+        position: "top-left",
+        url: "https://bjcbt-test.oss-cn-beijing.aliyuncs.com/demo-show/logo.png",
+        left: 100,
+        top: 100,
+        width: 256,
+        height: 256,
+    }
+];
+
 const sources: Source[] = [
     {
         sceneId: 'scene1',
@@ -64,6 +75,9 @@ sources.forEach(s => {
     obs.addScene(s.sceneId);
     obs.addSource(s.sceneId, s.sourceId, s.sourceType, s.sourceUrl);
 });
+dsks.forEach(dsk => {
+   obs.addDSK(dsk.id, dsk.position as obs.Position, dsk.url, dsk.left, dsk.top, dsk.width, dsk.height);
+});
 
 console.log(`Obs scenes: ${JSON.stringify(obs.getScenes())}`);
 

Original file line number	Diff line number	Diff line change
`@@ -45,8 +45,8 @@ void Source::start() {`
`45`	`45`	`if (settings->videoDecoder) {`
`46`	`46`	`obs_data_set_bool(obs_data, "hw_decode", settings->videoDecoder->hardwareEnable);`
`47`	`47`	`}`
`48`		`- obs_data_set_bool(obs_data, "close_when_inactive", false);`
`49`		`- obs_data_set_bool(obs_data, "restart_on_activate", false);`
	`48`	`+ obs_data_set_bool(obs_data, "close_when_inactive", false); // make source always read`
	`49`	`+ obs_data_set_bool(obs_data, "restart_on_activate", false); // make source always read`
`50`	`50`	`obs_source = obs_source_create("ffmpeg_source", this->id.c_str(), obs_data, nullptr);`
`51`	`51`	`}`
`52`	`52`