コード例 #1
0
        //-------------------------------------------------------------------------
        // FMEをすべてコロ助
        //-------------------------------------------------------------------------
        public static bool Kill()
        {
            Process[] ps = Process.GetProcessesByName("FlashMediaLiveEncoder");
            if (ps.Length > 0)
            {
                foreach (System.Diagnostics.Process p in ps)
                {
                    p.Kill();
                }
                using (Bouyomi bm = new Bouyomi())
                {
                    bm.Talk("えふえむいー配信を停止しました");
                }
            }

            // すべてのFMEがいなくなったことを確認する
            do
            {
                System.Threading.Thread.Sleep(1000);
                ps = Process.GetProcessesByName("FlashMediaLiveEncoder");
            } while (ps.Length > 0);

            // セッションファイルを殺す
            FMLE.DeleteSessionfile();

            if (mFMEprocess != null)
            {
                mFMEprocess.Close();
                mFMEprocess = null;
            }
            mFMEStarted = false;

            return(ps.Length > 0);
        }
コード例 #2
0
        //-------------------------------------------
        // process をスタート
        //-------------------------------------------
        public static bool Start(Dictionary <string, string> iParams)
        {
            try
            {
                // 現在、動作しているプロセスをすべてコロ助
                Kill();

                // プロセスをスタートさせる

                // プロファイルのパス
                //string profile_path = Path.GetTempPath() + "nicovideo_fme.xml";
                string profile_path = Properties.Settings.Default.fmle_profile_path + "\\" + Properties.Settings.Default.fmle_default_profile;


                // FlashMediaEncoderのパス
                string path = Properties.Settings.Default.fmle_path.Replace("FMLECmd", "FlashMediaLiveEncoder");

                // プロファイル作成
                if (!FMLE.MakeProfile(profile_path, iParams))
                {
                    mFMEStarted = false;
                    return(false);
                }

                // FMLECmd起動
                string args = " /g /p \"" + profile_path + "\"";
                mFMEprocess = System.Diagnostics.Process.Start(path, args);
                // ウインドウハンドルが生成されるまで待つ
                mFMEprocess.WaitForInputIdle();

                // 立ち上がるのを待つ
                using (Bouyomi bm = new Bouyomi())
                {
                    bm.Talk("えふえむいー起動中です");
                }
                System.Threading.Thread.Sleep(8000);

                return(PushStart());
            }
            catch (Exception e)
            {
                Utils.WriteLog(e.ToString());
                return(false);
            }
        }
コード例 #3
0
        //-------------------------------------------------------------------------
        // 開始
        //-------------------------------------------------------------------------
        public static void Start(Dictionary <string, string> iParams, string profile_path)
        {
            DeleteSessionfile();
            if (Properties.Settings.Default.fme_gui)
            {
                Thread th = new Thread(delegate()
                {
                    mFMEStarted = FMEGUI.Start(iParams);
                });
                th.Name = "NivoLive.FMLE.Start(): gui";
                th.Start();
            }
            else
            {
                if (hasFME())
                {
                    return;
                }
                // FMLECmdのパス
                string APP_PATH = Properties.Settings.Default.fmle_path;
                // プロファイルのパス
                //string profile_path = Path.GetTempPath() + "nicovideo_fme.xml";

                Thread th = new Thread(delegate()
                {
                    // プロファイル作成
                    if (!MakeProfile(profile_path, iParams))
                    {
                        mFMEStarted = false;
                        return;
                    }

                    // FMLECmd起動
                    string args = " /p \"" + profile_path + "\"";

                    if (Properties.Settings.Default.fme_dos)
                    {
                        ProcessStartInfo psInfo = new ProcessStartInfo();
                        psInfo.FileName         = APP_PATH;
                        psInfo.CreateNoWindow   = false;
                        psInfo.UseShellExecute  = true;
                        if (Properties.Settings.Default.fme_dos_min)
                        {
                            psInfo.WindowStyle = ProcessWindowStyle.Minimized;
                        }
                        psInfo.Arguments = args;
                        Process.Start(psInfo);
                    }
                    else
                    {
                        ProcessStartInfo psInfo = new ProcessStartInfo();
                        psInfo.FileName         = APP_PATH;
                        psInfo.CreateNoWindow   = true;
                        psInfo.UseShellExecute  = false;
                        psInfo.Arguments        = args;
                        Process.Start(psInfo);
                    }
                    using (Bouyomi bm = new Bouyomi())
                    {
                        bm.Talk("えふえむいー配信を開始しました");
                    }
                    mFMEStarted = true;
                });
                th.Name = "NivoLive.FMLE.Start(): cui";
                th.Start();
            }
        }
コード例 #4
0
        //
        //  この関数を定期的に呼ぶ
        //
        public static void HandlingStatus(string id, Form mf)
        {
            // 停止は、idなくても可能
            if (require_status != XSplit_Status.XS_NEED_STOP)
            {
                //if (id == null) return;
                //if (id.Length < 2) return;
            }

            // XSplitのプロセスが無いときは、何も出来ない。
            if (IsAlive)
            {
                if (require_status == XSplit_Status.XS_IDLE)
                {
                    return;
                }

                string caption = Text;
                if (caption == null)
                {
                    return;
                }

                // 過渡状態では、ダイアログのお掃除のみ
                if (caption.Contains("配信を初期化しています"))
                {
                    SweepDialogs();
                    return;
                }

                switch (require_status)
                {
                case XSplit_Status.XS_NEED_START:
                    if (caption.Contains("Streaming Live - NicoVideo - "))
                    {
                        require_status = XSplit_Status.XS_NEED_CHECK_CLIPBOARD;

                        return;
                    }
                    if (caption.Contains("XSplit Broadcaster - 配信中"))
                    {
                        require_status = XSplit_Status.XS_NEED_CHECK_CLIPBOARD;
                        return;
                    }

                    // 配信開始
                    if (Properties.Settings.Default.use_xsplit_shortcut)
                    {
                        PushShortcutKeys2();
                    }
                    else
                    {
                        StartNicoLive(mf);
                    }
                    break;

                case XSplit_Status.XS_NEED_CHECK_CLIPBOARD:
                    if (caption.Equals("XSplit Broadcaster"))
                    {
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("エックスプリット、ニコ生接続失敗");
                        }
                        require_status = XSplit_Status.XS_IDLE;
                        return;
                    }
                    if (Clipboard.ContainsText())
                    {
                        if (Clipboard.GetText().Contains(id))
                        {
                            require_status = XSplit_Status.XS_IDLE;
                        }
                        else
                        {
                            require_status = XSplit_Status.XS_NEED_RESTART;
                        }
                    }
                    break;

                case XSplit_Status.XS_NEED_RESTART:
                    if (caption.Length == 0)
                    {
                        require_status = XSplit_Status.XS_NEED_START;
                        return;
                    }
                    if (caption.Equals("XSplit Broadcaster"))
                    {
                        require_status = XSplit_Status.XS_NEED_START;
                        return;
                    }
                    if (caption.Contains("Streaming Live - NicoVideo - "))
                    {
                        // 配信停止
                        if (Properties.Settings.Default.use_xsplit_shortcut)
                        {
                            PushShortcutKeys2();
                        }
                        else
                        {
                            StartNicoLive(mf);
                        }
                    }
                    break;

                case XSplit_Status.XS_NEED_STOP:
                    if (caption.Length == 0)
                    {
                        require_status = XSplit_Status.XS_IDLE;
                        return;
                    }
                    if (caption.Equals("XSplit Broadcaster"))
                    {
                        require_status = XSplit_Status.XS_IDLE;
                        return;
                    }
                    if (caption.Contains("Streaming Live - NicoVideo - "))
                    {
                        // 配信停止
                        if (Properties.Settings.Default.use_xsplit_shortcut)
                        {
                            PushShortcutKeys2();
                        }
                        else
                        {
                            StartNicoLive(mf);
                        }
                    }
                    break;
                }
            }
            else
            {
                require_status = XSplit_Status.XS_IDLE;
            }
        }
コード例 #5
0
        public static void StartNicoLive(Form mainForm)
        {
            Clipboard.Clear();

            const int padding  = 3;
            const int padding2 = 3;

            FindXSplitMainWindow();

            IntPtr hAfterWnd = IntPtr.Zero;

            // ウインドウが最小化状態だったか否か
            bool original_iconic = IsIconic(hXSplitWnd);

            if (!original_iconic)
            {
                hAfterWnd = GetWindow(hXSplitWnd, (uint)GetWindow_Cmd.GW_HWNDPREV);
                while (hAfterWnd != IntPtr.Zero && !IsWindowVisible(hAfterWnd))
                {
                    hAfterWnd = GetWindow(hAfterWnd, (uint)GetWindow_Cmd.GW_HWNDPREV);
                }
            }

            // クライアント領域のスクリーンをキャプチャする
            Bitmap bmp = null;

            //// ウィンドウを元に戻す
            ShowWindow(hXSplitWnd, SW_RESTORE);
            System.Threading.Thread.Sleep(500);

            //// ウインドウをフォアグラウンドに
            SetForegroundWindow(hXSplitWnd);  // アクティブにする
            System.Threading.Thread.Sleep(500);

            //// ウインドウが表示されるまで待つ
            WINDOWPLACEMENT wndplace = new WINDOWPLACEMENT();

            do
            {
                System.Threading.Thread.Sleep(500);
                GetWindowPlacement(hXSplitWnd, ref wndplace);
            } while ((wndplace.showCmd != SW_SHOWNORMAL));


            bool bStartPushed = false;

            using (ScreenCapture scr = new ScreenCapture())
            {
                // クライアント領域のサイズを取得
                RECT      clientrect = new RECT();
                POINT     p1, p2;
                Rectangle iRect;

                // クライアント領域の取得
                GetClientRect(hXSplitWnd, ref clientrect);

                p1.x = clientrect.left;
                p1.y = clientrect.top;
                p2.x = clientrect.right;
                p2.y = clientrect.bottom;

                //クライアント領域座標をスクリーン座標に変換
                ClientToScreen(hXSplitWnd, ref p1);
                ClientToScreen(hXSplitWnd, ref p2);

                //取り込む座標を矩形領域に設定
                iRect = new Rectangle(p1.x, p1.y, p2.x - p1.x + 1, p2.y - p1.y + 1);

                Point outPos       = new Point();
                Point haishin_offs = new Point(100, 0);
                Point nico_offs    = new Point(120, 20);

                int i;
                // 配信メニューを押す
                for (i = 0; i < 60; i++)
                {
                    bmp = scr.Capture(iRect);
                    //bmp.Save("C:\\start_wait.png");
                    if (ContainBitmap(mHaishinBmp, bmp, haishin_offs.X, haishin_offs.Y, haishin_offs.X + 50, haishin_offs.Y + 30, ref outPos, 5))
                    {
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("配信メニュー選択");
                        }
                        System.Threading.Thread.Sleep(500);
                        //MouseClick(p1.x + 139, p1.y + 13);
                        bStartPushed = true;
                        // 立ち上がるのを待つ
                        break;
                    }
                    bmp.Dispose();
                    bmp = null;
                    //// ウィンドウを元に戻す
                    ShowWindow(hXSplitWnd, SW_RESTORE);
                    // アクティブにする
                    SetForegroundWindow(hXSplitWnd);

                    // ウエイト
                    System.Threading.Thread.Sleep(500);

                    // クライアント領域を再取得
                    GetClientRect(hXSplitWnd, ref clientrect);

                    p1.x = clientrect.left;
                    p1.y = clientrect.top;
                    p2.x = clientrect.right;
                    p2.y = clientrect.bottom;

                    //クライアント領域座標をスクリーン座標に変換
                    ClientToScreen(hXSplitWnd, ref p1);
                    ClientToScreen(hXSplitWnd, ref p2);

                    //取り込む座標を矩形領域に設定
                    iRect = new Rectangle(p1.x, p1.y, p2.x - p1.x + 1, p2.y - p1.y + 1);
                }

                //// ニコ生を押す
                if (bStartPushed)
                {
                    for (i = 0; i < 60; i++)
                    {
                        // ここでマウスクリック
                        MouseClick(p1.x + 110, p1.y + 10);

                        System.Threading.Thread.Sleep(500);
                        // もはや、座標は変えられない
                        bmp = scr.Capture(iRect);
                        //bmp.Save("C:\\nico_wait.png");
                        if (ContainBitmap(mNicoBmp, bmp, nico_offs.X - padding2, nico_offs.Y - padding, nico_offs.X + padding2, nico_offs.Y + 64 + padding, ref outPos, 10))
                        {
                            using (Bouyomi bm = new Bouyomi())
                            {
                                bm.Talk("ニコ生プッシュ");
                            }
                            MouseClick(p1.x + outPos.X + 8, p1.y + outPos.Y + 14);
                            //                            MouseClick(p1.x + 151, p1.y + 38);

                            break;  // 押し下げ成功
                        }
                        bmp.Dispose();
                        bmp = null;

                        //// ウィンドウを元に戻す
                        ShowWindow(hXSplitWnd, SW_RESTORE);
                        // アクティブにする
                        SetForegroundWindow(hXSplitWnd);

                        System.Threading.Thread.Sleep(500);

                        // クライアント領域を再取得
                        GetClientRect(hXSplitWnd, ref clientrect);

                        p1.x = clientrect.left;
                        p1.y = clientrect.top;
                        p2.x = clientrect.right;
                        p2.y = clientrect.bottom;

                        //クライアント領域座標をスクリーン座標に変換
                        ClientToScreen(hXSplitWnd, ref p1);
                        ClientToScreen(hXSplitWnd, ref p2);

                        //取り込む座標を矩形領域に設定
                        iRect = new Rectangle(p1.x, p1.y, p2.x - p1.x + 1, p2.y - p1.y + 1);
                    }
                }
            }

            System.Threading.Thread.Sleep(2000);

            // ウインドウを最小化する
            if (original_iconic)
            {
                ShowWindow(hXSplitWnd, SW_MINIMIZE);
            }
            else
            {
                Thread th = new Thread(delegate()
                {
                    Thread.Sleep(5000);
                    mainForm.Invoke((Action) delegate()
                    {
                        mainForm.Activate();
                    });

                    //if (hAfterWnd != null && hAfterWnd != (IntPtr)(-1) && hAfterWnd != (IntPtr)(-2))
                    //{
                    //    SetWindowPos(hXSplitWnd, hAfterWnd, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE);
                    //}
                });
                th.Name = "NivoLive.Xsplit.StartNicoLive()";
                th.Start();
            }
        }
コード例 #6
0
        //-------------------------------------------
        // PushStart
        //-------------------------------------------
        public static bool PushStart()
        {
            const int padding  = 10;
            const int padding2 = 10;

            mFMEStarted = false;

            // プロセスが確保されていなければ、リターン
            if (mFMEprocess == null)
            {
                return(false);
            }

            // プロセスが存在しても、終了していれば、リターン
            if (mFMEprocess.HasExited)
            {
                return(false);
            }

            // ウインドウのサイズをあわせる
            FitWindowSize();

            RECT clientrect = new RECT();


            // クライアント領域のスクリーンをキャプチャする
            Bitmap bmp = null;


            bool bStartPushed   = false;
            bool bStartComplete = false;

            using (ScreenCapture scr = new ScreenCapture())
            {
                int   i;
                Point outPos = new Point();

                Point start_offs = new Point(417, 512);
                Point stop_offs  = new Point(556, 512);
                Point ng_offs    = new Point(489, 357);


                // スタートボタンを探して押す
                for (i = 0; i < 60; i++)
                {
                    // ウインドウをフォアグラウンドに
                    SetForegroundWindow(m_fme_hwnd);  // アクティブにする

                    // クライアント領域のサイズを取得
                    GetClientRect(m_fme_hwnd, ref clientrect);
                    POINT p1, p2;
                    p1.x = clientrect.left;
                    p1.y = clientrect.top;
                    p2.x = clientrect.right;
                    p2.y = clientrect.bottom;

                    //クライアント領域座標をスクリーン座標に変換
                    ClientToScreen(m_fme_hwnd, ref p1);
                    ClientToScreen(m_fme_hwnd, ref p2);

                    // クライアント領域のレクトアングルを設定
                    Rectangle iRect = new Rectangle(p1.x, p1.y, p2.x - p1.x + 1, p2.y - p1.y + 1);

                    bmp = scr.Capture(iRect);
                    if (ContainBitmap(mStartBmp, bmp, start_offs.X - padding2, start_offs.Y - padding, start_offs.X + padding2, start_offs.Y + padding, ref outPos, 5))
                    {
                        MouseClick(p1.x + outPos.X + 18, p1.y + outPos.Y + 14);
                        bStartPushed = true;
                        // 立ち上がるのを待つ
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("スタートボタン、プッシュ");
                        }
                        break;
                    }

                    bmp.Dispose();
                    bmp = null;
                    FitWindowSize();
                    // 0.5[s] wait
                    System.Threading.Thread.Sleep(500);
                }

                // スタートボタンが押せなかった場合
                if (!bStartPushed)
                {
                    if (bmp != null)
                    {
                        bmp.Dispose();
                        bmp = null;
                    }
                    // 立ち上がるのを待つ
                    using (Bouyomi bm = new Bouyomi())
                    {
                        bm.Talk("スタートボタンを代わりに押してください");
                    }
                }

                // スタートできたかのチェック
                for (i = 0; i < 40; i++)
                {
                    // ウインドウをフォアグラウンドに
                    SetForegroundWindow(m_fme_hwnd);  // アクティブにする

                    GetClientRect(m_fme_hwnd, ref clientrect);
                    POINT p1, p2;
                    p1.x = clientrect.left;
                    p1.y = clientrect.top;
                    p2.x = clientrect.right;
                    p2.y = clientrect.bottom;

                    //クライアント領域座標をスクリーン座標に変換
                    ClientToScreen(m_fme_hwnd, ref p1);
                    ClientToScreen(m_fme_hwnd, ref p2);

                    Rectangle iRect = new Rectangle(p1.x, p1.y, p2.x - p1.x + 1, p2.y - p1.y + 1);

                    bmp = scr.Capture(iRect);

                    // Stop が押せるようになれば、とりあえず成功判定
                    if (ContainBitmap(mStopBmp, bmp, stop_offs.X - padding2, stop_offs.Y - padding, stop_offs.X + padding2, stop_offs.Y + padding, ref outPos, 5))
                    {
                        // 立ち上がるのを待つ
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("ストップボタン、点灯確認");
                        }
                        bStartComplete = true;
                        mFMEStarted    = true;
                        bmp.Dispose();
                        bmp = null;
                        break;
                    }

                    // NGダイアログが出てきたら、NG判定
                    if (ContainBitmap(mNgBmp, bmp, ng_offs.X - padding2, ng_offs.Y - padding, ng_offs.X + padding2, ng_offs.Y + padding, ref outPos, 5))
                    {
                        MouseClick(p1.x + outPos.X + 10, p1.y + outPos.Y + 10);
                        if (bmp != null)
                        {
                            bmp.Dispose();
                            bmp = null;
                        }

                        // NG ダイアログが消えるのを待つ
                        int j;
                        for (j = 0; j < 10; j++)
                        {
                            GetClientRect(m_fme_hwnd, ref clientrect);

                            p1.x = clientrect.left;
                            p1.y = clientrect.top;
                            p2.x = clientrect.right;
                            p2.y = clientrect.bottom;

                            //クライアント領域座標をスクリーン座標に変換
                            ClientToScreen(m_fme_hwnd, ref p1);
                            ClientToScreen(m_fme_hwnd, ref p2);

                            iRect = new Rectangle(p1.x, p1.y, p2.x - p1.x + 1, p2.y - p1.y + 1);

                            bmp = scr.Capture(iRect);
                            if (!ContainBitmap(mNgBmp, bmp, ng_offs.X - padding2, ng_offs.Y - padding, ng_offs.X + padding2, ng_offs.Y + padding, ref outPos, 5))
                            {
                                if (bmp != null)
                                {
                                    bmp.Dispose();
                                    bmp = null;
                                }
                                break;
                            }
                            // 0.5[s] wait
                            System.Threading.Thread.Sleep(500);
                        }
                        break;
                    }
                    if (bmp != null)
                    {
                        bmp.Dispose();
                        bmp = null;
                    }

                    // 0.5[s] wait
                    FitWindowSize();
                    System.Threading.Thread.Sleep(500);
                }
            }

            //// Start領域
            //iRect = new Rectangle(p1.x+417, p1.y+512, 36, 28);
            //bmp = scr.Capture(iRect);
            //filePath = @"F:\FMEstart.bmp";
            //bmp.Save(filePath, ImageFormat.Bmp);

            //// Stop領域
            //iRect = new Rectangle(p1.x + 556, p1.y + 512, 34, 28);
            //bmp = scr.Capture(iRect);
            //filePath = @"F:\FMEstop.bmp";
            //bmp.Save(filePath, ImageFormat.Bmp);

            //// NG領域
            //iRect = new Rectangle(p1.x + 489, p1.y + 357, 21, 19);
            //bmp = scr.Capture(iRect);
            //filePath = @"F:\FMEng.bmp";
            //bmp.Save(filePath, ImageFormat.Bmp);

            //filePath = @"F:\screen.bmp";
            //Process.Start(filePath);

            //一秒間(1000ミリ秒)停止する
            System.Threading.Thread.Sleep(2000);

            if (bStartComplete)
            {
                using (Bouyomi bm = new Bouyomi())
                {
                    bm.Talk("えふえむいー配信を開始しました");
                }
            }
            else
            {
                using (Bouyomi bm = new Bouyomi())
                {
                    bm.Talk("えふえむいー起動失敗しました");
                }
                FMEGUI.Kill();
            }

            // ウインドウを最小化する
            ShowWindow(m_fme_hwnd, SW_MINIMIZE);
            return(bStartComplete);
        }
コード例 #7
0
ファイル: HQ.cs プロジェクト: meronpan3419/nicolive-kai-plus
        //-------------------------------------------------------------------------
        // 外部エンコーダー起動
        //-------------------------------------------------------------------------
        public static void Exec(string LiveID)
        {
            Thread th = new Thread(delegate()
            {
                // NLE
                if (Properties.Settings.Default.use_nle)
                {
                    if (NLE.IsAlive)
                    {
                        NLE.Start();
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("えぬえるいー配信を開始します。");
                        }
                    }
                    else
                    {
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("えぬえるいー配信なんてなかった。");
                        }
                    }
                    return;
                }

                // XSplit
                if (Properties.Settings.Default.use_xsplit)
                {
                    XSplit.Start();
                    using (Bouyomi bm = new Bouyomi())
                    {
                        bm.Talk("エックスプリット配信を開始します。");
                    }
                    return;
                }


                // FME
                if (Properties.Settings.Default.use_fme)
                {
                    string path = Properties.Settings.Default.fmle_profile_path + "\\" + Properties.Settings.Default.fmle_default_profile;;

                    if (!File.Exists(path) && !Properties.Settings.Default.use_xsplit && !Properties.Settings.Default.use_nle)
                    {
                        using (Bouyomi bm = new Bouyomi())
                        {
                            bm.Talk("えふえむいープロファイルが見つかりませんでした");
                        }
                        return;
                    }
                    Nico nico = Nico.Instance;
                    string fmle_profile_path = Properties.Settings.Default.fmle_profile_path + "\\" + Properties.Settings.Default.fmle_default_profile;

                    string lv = LiveID;
                    if (lv.Length > 2)
                    {
                        Dictionary <string, string> fme_profiles = nico.GetFMEProfile(lv);
                        if (fme_profiles == null)
                        {
                            return;
                        }
                        if (fme_profiles.Count <= 1)
                        {
                            return;
                        }
                        if (fme_profiles["status"].Equals("ok"))
                        {
                            FMLE.Start(fme_profiles, fmle_profile_path);
                        }
                    }
                }
            });

            th.Name = "NivoLive.HQ.Exec(): FME";
            th.Start();
        }