js/rtp 解析/rtpCheck.js

@@ -0,0 +1,190 @@
+// 读取 rtpPack1.txt 文件，解析其中的 rtp 包，检查其中的序列号是否连续
+const path = require("path");
+const loadTxt = require("./loadTxt");
+const rtp = require("./rtpParse");
+function handle(promise){
+    return promise.then(data=>[null,data]).catch(err=>[err,null])
+}
+let filePath1 = path.join(__dirname, 'rtpPack1.txt');
+let filePath2 = path.join(__dirname, 'rtpPack2.txt');
+
+async function parseRtpPackTxt(filePath) {
+    let rtpPacks = [];
+    let [err,lines] = await handle( loadTxt.loadFileLines(filePath) );
+    if (err){
+        return console.log(err);
+    }
+    // 读取一行,跳过一行
+    for (let i = 0; i < lines.length; i+=2) {
+        let line = lines[i];
+        if (line === "***end***"){
+            console.log("文件解析结束");
+            return rtpPacks;
+        }
+        rtpPacks.push(line);
+    }
+    return rtpPacks;
+}
+
+// 格式化输出内容 用于打印表格 例如
+// 表单长度 用于打印表格 例如 [20,20] 则再打印表格时，每个单元格的长度为 20
+let tbLen = [50, 50];
+let lineLen = 2;
+function printf() {
+    let str = "";
+    str += "|";
+    for (let i = 0; i < lineLen; i++) {
+        let arg = arguments[i] || "";
+        let len = tbLen[i];
+        let argLen = arg.length;
+        let spaceLen = len - argLen;
+        let space = "";
+        for (let j = 0; j < spaceLen; j++) {
+            space += " ";
+        }
+        //
+        // 如果长度超过了表单长度，则截取字符串
+        if (argLen > len){
+            arg = arg.substr(0,len);
+        }
+        str += arg + space + "|";
+
+    }
+    console.log(str);
+}
+
+// 解析剩余数据
+let last_data = ["",""];
+let bitLen = 2;
+
+// rtp over tcp 包的前两个字节为rtp包的长度
+function parseRtpOverTcp(no, package){
+    // 合并旧数据
+    if(last_data[no] !== ""){
+        package = last_data[no] + package;
+        last_data[no] = "";
+    }
+    let allLen = package.length;
+    console.log(`---*-*-*-*-*------ allLen: ${allLen} ------*-*-*-*-*-*---`)
+    let len = 0;
+    // 读取包长度
+    let packageLenStr = package.substr(0,4);
+    let packageLen = parseInt(packageLenStr,16);
+    console.log(`packageLenStr: ${packageLenStr} >>> ${packageLen}`);
+    // package_len + i  <= left_len + data_len
+    while ( (len + packageLen) * 2 <= allLen ){
+
+        console.log('----')
+        // 解析rtp包
+        let rtpPackage = package.substr(len * 2 + 4, packageLen * bitLen);
+        let rtpHeaderInfo = rtp.parseRtpHeader(rtpPackage.substr(0,24));
+        console.log(rtpHeaderInfo)
+        // i += package_len + 2;
+
+        // 读取下一个包长度
+
+        len += packageLen + 2;
+        console.log(`len: ${len}`)
+        packageLenStr = package.substr(len * 2, 4);
+        packageLen = parseInt(packageLenStr,16);
+        console.log(`packageLenStr: ${packageLenStr} >>> ${packageLen} `);
+
+
+
+        // 如果剩余数据不足以解析一个包，则跳出循环
+
+    }
+    // 读取剩余数据
+    last_data[no] = package.substr(len * 2 );
+    console.log(`last_data: ${last_data[no].length}`);
+}
+
+async function main(){
+    let rtpPackages_1 = await parseRtpPackTxt(filePath2);
+    let rtpPackages_2 = await parseRtpPackTxt(filePath2);
+    printf(" black"," ok");
+    printf("------------------------------","------------------------------");
+    // 开始解析rtp数据
+    for (let i = 0; i < rtpPackages_1.length; i++) {
+        console.log(`---*-*-*-*-*------ ${i} ------*-*-*-*-*-*---`)
+        let rtpPackage_1 = rtpPackages_1[i];
+        // 输出前10个字节
+        console.log(rtpPackage_1.substr(0,20));
+        let rtpPackage_2 = rtpPackages_2[i];
+        // rtpPackage_1 = rtpPackage_1.substr(4,24);
+        // rtpPackage_2 = rtpPackage_2.substr(4,24);
+        // printf(
+        //     `   ${rtpPackage_1}`,
+        //     `   ${rtpPackage_2}`,
+        // );
+        let rtpHeaderInfo_1 = parseRtpOverTcp(0, rtpPackage_1);
+        // let rtpHeaderInfo_2 = rtp.parseRtpOverTcp(1, rtpPackage_2);
+        let rtpHeaderInfo_2 = {};
+        // printf(
+        //     `${i} version: ${rtpHeaderInfo_1.version}`,
+        //     `${i} version: ${rtpHeaderInfo_2.version}`,
+        // );
+        //
+        // printf(
+        //     `${i} padding: ${rtpHeaderInfo_1.padding}`,
+        //     `${i} padding: ${rtpHeaderInfo_2.padding}`,
+        // );
+        //
+        // printf(
+        //     `${i} extension: ${rtpHeaderInfo_1.extension}`,
+        //     `${i} extension: ${rtpHeaderInfo_2.extension}`,
+        // );
+        //
+        // printf(
+        //     `${i} csrcCount: ${rtpHeaderInfo_1.csrcCount}`,
+        //     `${i} csrcCount: ${rtpHeaderInfo_2.csrcCount}`,
+        // );
+        //
+        // printf(
+        //     `${i} csrcCount: ${rtpHeaderInfo_1.csrcCount}`,
+        //     `${i} csrcCount: ${rtpHeaderInfo_2.csrcCount}`,
+        // );
+        //
+        // printf(
+        //     `${i} marker: ${rtpHeaderInfo_1.marker}`,
+        //     `${i} marker: ${rtpHeaderInfo_2.marker}`,
+        // );
+        //
+        // printf(
+        //     `${i} payloadType: ${rtpHeaderInfo_1.payloadType}`,
+        //     `${i} payloadType: ${rtpHeaderInfo_2.payloadType}`,
+        // );
+        //
+        // printf(
+        //     `${i} sequenceNumber: ${rtpHeaderInfo_1.sequenceNumber}`,
+        //     `${i} sequenceNumber: ${rtpHeaderInfo_2.sequenceNumber}`,
+        // );
+        //
+        // printf(
+        //     `${i} timestamp: ${rtpHeaderInfo_1.timestamp}`,
+        //     `${i} timestamp: ${rtpHeaderInfo_2.timestamp}`,
+        // );
+        //
+        // printf(
+        //     `${i} ssrc: ${rtpHeaderInfo_1.ssrc}`,
+        //     `${i} ssrc: ${rtpHeaderInfo_2.ssrc}`,
+        // );
+        //
+        // printf(
+        //     `${i} csrc: ${rtpHeaderInfo_1.csrc}`,
+        //     `${i} csrc: ${rtpHeaderInfo_2.csrc}`,
+        // );
+        //
+        // printf(
+        //     `${i} time: ${rtpHeaderInfo_1.time}`,
+        //     `${i} time: ${rtpHeaderInfo_2.time}`,
+        // );
+        //
+        // printf("------------------------------","------------------------------");
+        // printf("------------------------------","------------------------------");
+        // printf("------------------------------","------------------------------");
+    }
+
+}
+
+main()

js/rtp 解析/rtpParse.js

@@ -1,4 +1,4 @@
-const time = require('./time.js');
+const time = require('../time.js');
 function hexStrToBitStr(str){
     // 移除0x 以及空格
     str = str.replace(/0x/g,'').replace(/\s/g,'');
@@ -7,6 +7,7 @@ function hexStrToBitStr(str){
 }
 
 function parseRtpHeader(hexStr){
+    // console.log(hexStr);
     let bitStr = hexStrToBitStr(hexStr);
     let version = parseInt(bitStr.substr(0,2),2);
     let padding = bitStr.substr(2,1);
@@ -35,6 +36,9 @@ function parseRtpHeader(hexStr){
     }
 }
 
+
+
 module.exports = {
-    parseRtpHeader
+    parseRtpHeader,
+
 }

js/数独计算器.js

@@ -0,0 +1,47 @@
+// 杀手数独计算器
+//
+// 规则
+// 1. 杀手框内的数字不能重复
+// 2. 杀手框内的数字之和等于杀手框的和
+
+/**
+ * 计算杀手框 中可能的组合
+ * @param sum 总和
+ * @param itemNum 元素数量
+ */
+function cal(sum, itemNum){
+    let result = [];
+    let arr = [];
+    let temp = [];
+    for(let i = 1; i <= 9; i++){
+        arr.push(i);
+    }
+    // console.log(arr);
+    function dfs(arr, temp, sum, itemNum){
+        if(temp.length === itemNum){
+            if(temp.reduce((a, b) => a + b, 0) === sum){
+                result.push(temp.slice());
+            }
+            return;
+        }
+        for(let i = 0; i < arr.length; i++){
+            temp.push(arr[i]);
+            dfs(arr.slice(i + 1), temp, sum, itemNum);
+            temp.pop();
+        }
+    }
+    dfs(arr, temp, sum, itemNum);
+    return result;
+}
+
+console.log(cal(6, 3));// 1, 2, 3
+console.log(cal(7, 2));//1,6 | 2,5 | 3,4
+console.log(cal(8, 2));// 1,7 | 2,6 | 3,5
+
+console.log(cal(12, 2));// 3, 9  | 4, 8  | 5, 7
+
+console.log(cal(13, 2));//4,9 | 5,8 | 6,7
+console.log(cal(16, 4));
+console.log(cal(24, 3));// 7,8,9
+console.log(cal(24, 4))//1689,25892679
+

js/进制转换/test.js

@@ -34,20 +34,66 @@ function parseRtpHeader(hexStr){
         time: _time
     }
 }
-console.log(parseInt(hexStrToBitStr('80 08'),2));
-console.log(parseInt(hexStrToBitStr('00 5b'),2));
-console.log(parseInt(hexStrToBitStr('00 5d'),2));
-console.log(parseInt(hexStrToBitStr('01 e2'),2));
-console.log(parseInt(hexStrToBitStr('00 5a'),2));
-console.log(parseInt(hexStrToBitStr('00 5a'),2));
-console.log(parseInt(hexStrToBitStr('00 5a'),2));
-
-console.log(parseRtpHeader('80080106b387a72000000194'));
-console.log(parseRtpHeader('80080108b387a86000000194'));
-console.log(parseRtpHeader('8008010bb387aa4000000194'));
-console.log(parseRtpHeader('8008010cb387aae000000194'));
-console.log(parseRtpHeader('8008010db387ab8000000194'));
-console.log(parseRtpHeader('8008010eb387ac2000000194'));
+console.log(parseInt(hexStrToBitStr('00 10'),2));
+// console.log(parseInt(hexStrToBitStr('00 5b'),2));
+// console.log(parseInt(hexStrToBitStr('00 5d'),2));
+// console.log(parseInt(hexStrToBitStr('01 e2'),2));
+// console.log(parseInt(hexStrToBitStr('00 5a'),2));
+// console.log(parseInt(hexStrToBitStr('00 5a'),2));
+// console.log(parseInt(hexStrToBitStr('00 5a'),2));
+
+let lineStr = "| 黑屏设备包头解析 | 不黑屏设备解析 |"
+console.log(lineStr);
+
+// rtp黑屏
+// 00 10 80 e0 00 02 00 00 46 50 01 e1 5e 79 68 ce 31 b2 00 11 80 e0 00 03 00 00 69 78 01 e1 5e 79 06 e5 01 42 80 05 78 80 60 00 04 00
+//
+
+
+// console.log(parseRtpHeader('00 10 80 e0 00 02 00 00 46 50 01 e1 5e 79 68 ce 31 b2 00 11 80 e0 00'));
+// console.log(parseRtpHeader('80 e0 00 02 00 00 46 50 01 e1 5e 79 68 ce 31 b2'));
+console.log(parseRtpHeader('80 e0 00 02 00 00 46 50 01 e1 5e 79'));
+// {
+//     version: 2,
+//     padding: '0',
+//     extension: '0',
+//     csrcCount: '0000',
+//     marker: '1',
+//     payloadType: 96,
+//     sequenceNumber: 2,
+//     timestamp: 18432,
+//     ssrc: '00000000000000000000000000000000',
+//     csrc: '',
+//     time: '1970-01-01 08:00:18'
+// }
+
+// 正常播放
+// 00 10 80 60 00 02 3b 09 a5 d0 01 df 5a d9 68 ee 31 b2 00 11 80 60 00 03 3b 09 a5 d0 01 df 5a d9 06 e5 01 cb 80 05 86 80 60 00 04 3b
+// console.log(parseRtpHeader('00 10 80 60 00 02 3b 09 a5 d0 01 df 5a d9 68 ee 31 b2 00 11 80 60 00'));
+// console.log(parseRtpHeader('00 10 80 60 00 02 3b 09 a5 d0 01 df 5a d9 68 ee'));
+console.log(parseRtpHeader('80 60 00 02 3b 09 a5 d0 01 df 01'));
+
+// {
+//     version: 2,
+//     padding: '0',
+//     extension: '0',
+//     csrcCount: '0000',
+//     marker: '0',
+//     payloadType: 96,
+//     sequenceNumber: 2,
+//     timestamp: 990488576,
+//     ssrc: '000000000000000000000000',
+//     csrc: '',
+//     time: '1970-01-12 19:08:08'
+// }
+
+
+
+// console.log(parseRtpHeader('80080108b387a86000000194'));
+// console.log(parseRtpHeader('8008010bb387aa4000000194'));
+// console.log(parseRtpHeader('8008010cb387aae000000194'));
+// console.log(parseRtpHeader('8008010db387ab8000000194'));
+// console.log(parseRtpHeader('8008010eb387ac2000000194'));
 
 // console.log(parseRtpHeader('00 04 d4 91 5e 08 07 27 11 e8 d6 d4'));
 // console.log(parseRtpHeader('00 05 d4 91 5e a8 07 27 11 e8 d5 57'));

linux/常用命令.md

@@ -1,5 +1,5 @@
 # linux 下常用命令笔记
-## cp
+## 复制 `cp`
 ### 作用
 复制文件或目录至指定位置
 ### 示例 复制目录
@@ -25,21 +25,20 @@ cp /home/abc /home/def /home/ghi /home/jkl # 复制多个文件至指定目录
 ```
 
 ### 可选参数
-#### -r
-1. 作用  
-> 复制目录,复制目录时必须加上此参数
-2. 示例
+#### 复制目录 `-r`
+##### `#d` 目录复制  
+复制目录,复制目录时必须加上此参数
 ```shell
 cp -r /home/abc /home/def # 复制目录
 ```
-#### -f
-1. 作用
-> 强制复制,如果目标文件已经存在,不会询问用户,直接覆盖
+#### 强制复制 `-f`
+##### `#d` 强制复制
+如果目标文件已经存在,不会询问用户,会直接覆盖
 2. 示例
 ```shell
 cp -f /home/abc /home/def # 强制复制
 ```
-#### -i
+#### 交互式操作 `-i`
 1. 作用
 > 交互式复制,在覆盖已存在的目标文件之前提示用户
 2. 示例
@@ -47,3 +46,8 @@ cp -f /home/abc /home/def # 强制复制
 cp -i /home/abc /home/def # 交互式复制
 ```
 
+## 管理磁盘空间 
+### 查询指定目录下文件占用大小
+```shell
+sudo du -lh /home/ubuntu/ --max-depth=2
+```

安卓开发/安卓开发记录.md

@@ -0,0 +1,5 @@
+# 安卓开发记录踩坑
+
+## 页面布局管理
+### 需要注意的事项
+1. 在安卓项目