调整ssrc值生成规则；调整API返回消息结构

GB28181Server.js

 //GB28181 SIP服务器
 class NodeSIPServer {
     constructor(config) {
-		console.log(config);
+		//console.log(config);
         this.listen = config.GB28181.sipServer.listen || 5060;
         this.host = config.GB28181.sipServer.host || '127.0.0.1';//SIP服务器主机地址
         this.defaultPassword = config.GB28181.sipServer.password || '12345678';
             }
         });
 
-        Logger.log(`Node Media GB28181 Sip-Server started on port: ${this.listen}`);
+        Logger.log(`GB28181 Sip Server Started on Port: ${this.listen}`);
     }
 
     stop() {

GB28181Session.js

             //0: udp,1:tcp/passive ,2:tcp/active
             let selectMode = mode || 0;
 
-            let ssrc = "0" + channelId.substring(16, 20) + channelId.substring(3, 8);
+            //ssrc is here  -- by ntv wangjian
+            //let ssrc = "0" + channelId.substring(16, 20) + channelId.substring(3, 8);
+            let ssed = channelId.substring(13, 20);
+            let ised = '' + (parseInt(ssed)*13+10000);
+            let ssrc = "0" + ssed + ised.substring(3,5);
 
             let host = rhost || "127.0.0.1";
 
 
                 if (session.bye && session.port === rport && session.host === rhost && session.channelId === channelId && session.play === 'realplay') {
 
-                    context.nodeEvent.emit('stopPlayed', session.ssrc);
-
+                    //ntv 挪到回调中，TODO 这个指令发不成功！
+                    //context.nodeEvent.emit('stopPlayed', session.ssrc);
                     this.uas.send(session.bye, (response) => {
                         Logger.log(`[${this.id}] StopRealPlay status=${response.status}`);
-                        delete this.dialogs[key];
+                        
+                        if(response.status==200){
+                            //ntv add 真正结束了才能执行这两句
+                            context.nodeEvent.emit('stopPlayed', session.ssrc);
+                            delete this.dialogs[key];
+                        }
                     });
 
+                    //ntv
+                    this.playmode='';
+
                     result.result = true;
                     result.message = 'OK';
                 }
         // 通知
         if (content.hasOwnProperty('Notify')) {
 
-            Logger.log(`[${this.id}] Notify CmdType=${content.Notify.CmdType} SN=${content.Notify.SN} length=${request.content.length}`);
+            //ntv remove notify log
+            //Logger.log(`[${this.id}] Notify CmdType=${content.Notify.CmdType} SN=${content.Notify.SN} length=${request.content.length}`);
 
             switch (content.Notify.CmdType) {
                 //保活消息

api.txt

 /api/v1/vag/devices/{deviceID}/{channelID}/realplay/{action}/{mediaHost}/{mediaPort}/{streamMode}
+
+播放和停止
 /api/v1/vag/devices/10000000000000000002/34020000001320000002/realplay/start/8.131.101.81/9000/1
 /api/v1/vag/devices/10000000000000000002/34020000001320000002/realplay/stop/8.131.101.81/9000/1
+
+
+获取列表，后面deviceid可选：
+/api/v1/vag/devices/10000000000000000003

config.js

         },
         streamServer: {
             enable: true,         //是否启用内置流媒体服务 接收/转码/RTMP推送功能，如有支持GB PS RTP 收流服务器，可以设置为flase
-            listen: 9000,         //接收设备端rtp流的多路复用端口
+            listen: 9200,         //接收设备端rtp流的多路复用端口
             audio_enable: false,  //是否转发音频流
             rtp_idle_timeout: 30, //rtp包空闲等待时间，如果指定时间没有收到任何包,rtp监听连接自动停止，发送BYE命令
-            rtp_mix_port: 58200,  //rtp接收监听端口范围，最小值
-            rtp_max_port: 58300,  //rtp接收监听端口范围，最大值           
+            rtp_mix_port: 9300,  //rtp接收监听端口范围，最小值
+            rtp_max_port: 9400,  //rtp接收监听端口范围，最大值           
             invite_port_fixed: true, //设备将流发送的端口，是否固定,true:发送流到多路复用端口 如9200,false:动从rtp_mix_port - rtp_max_port 之间的值中选一个可以用的端口
             host: '0.0.0.0',         //本地地址
             rtmpServer: 'rtmp://60.205.164.47/liveshow'  //RTMP服务器基地址
     },
     VAG: {
         http: {
-            port: 1985,
+            port: 82,
             allow_origin: '*'
         },
         auth: {
-            api: true,
+            api: false,          // true to open base auth
             api_user: 'admin', //default admin
             api_pass: 'admin', //default admin
             play: true,

stream/server.js

         if (this.udpServer) {
             //TCP
             this.tcpServer.listen(this.listen, () => {
-                Logger.log(`Node Media GB28181-Stream/TCP Server started on port: ${this.listen}`);
+                Logger.log(`GB28181-Media Server started on TCP port: ${this.listen}`);
             });
             this.tcpServer.on('error', (e) => {
-                Logger.error(`Node Media GB28181-Stream/TCP Server ${e}`);
+                Logger.error(`GB28181-Media Server ${e}`);
             });
             this.tcpServer.on('close', () => {
-                Logger.log('Node Media GB28181-Stream/TCP Server Close.');
+                Logger.log('GB28181-Media Server Close.');
             });
         }
 
         if (this.udpServer) {
             //UDP
             this.udpServer.on("listening", () => {
-                Logger.log(`Node Media GB28181-Stream/UDP Server started on port: ${this.listen}`);
+                Logger.log(`GB28181-Media Server started on UDP port: ${this.listen}`);
             });
 
             this.udpServer.on("message", (msg, info) => {
     }
 
     //创建TCP主动取流客户端
+    //ntv 该逻辑没有被使用
     createTCPClient(ssrc, host, port) {
 
         if (!this.tcpClients[ssrc]) {
         if (!context.publishers.has(ssrc)) {
             var rtmpClient = new NodeRtmpClient(`${this.rtmpServer}/${ssrc}`);
             rtmpClient.startPush();
-
+            Logger.log("Publish to rtmp server ",this.rtmpServer,ssrc);
             //RTMP 发布流状态
             rtmpClient.on('status', (info) => {
-                if (info.code === 'NetStream.Publish.Start')
+                if (info.code === 'NetStream.Publish.Start'){
                     rtmpClient.isPublishStart = true;
+                    Logger.log("rtmp stream start ",ssrc);
+                }
             });
 
             //连接关闭
             rtmpClient.on('close', () => {
+                Logger.log("rtmp stream closed ",ssrc);
                 context.nodeEvent.emit('rtmpClientClose', ssrc);
             });
 

stream/session.js

             this.stop();
             return;
         }
+
     }
 
     stop() {
 
             let rtpData = this.cache.slice(2, rtplength + 2);
 
-            NodeGB28181StreamServerSession.parseRTPacket(rtpData);
+            //ntv add 传输this
+            NodeGB28181StreamServerSession.parseRTPacket(rtpData,this);
 
             this.cache = this.cache.slice(rtplength + 2);
         }
     }
 
     //处理UDP/RTP包
-    static parseRTPacket(cache) {
+    static parseRTPacket(cache,that) {
 
         let rtpPacket = new RtpPacket(cache);
         let ssrc = rtpPacket.getSSRC();
 
         let session = this.rtpPackets.get(ssrc);
 
-        Logger.log(`[${ssrc}] RTP Packet: timestamp:${timestamp} seqNumber:${seqNumber} length:${playload.length} `);
+		//ntv-wangjian
+        //Logger.log(`[${ssrc}] RTP Packet: timestamp:${timestamp} seqNumber:${seqNumber} length:${playload.length} `);
 
         switch (playloadType) {
             //PS封装
                             context.nodeEvent.emit('rtpReadyed', this.PrefixInteger(ssrc, 10), second[0] - first[0], packet);
                         }
                         catch (error) {
-                            Logger.log(`PS Packet Parse Fail.${error}`);
+                            Logger.log(`PS Packet Parse Fail! ${error}`);
                         }
                     }
                 }