initial commit

zhangzengfei

2022-07-20 c90c3e794bdd95127d0c34ff1d9e8759d18a0445

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
#include <stdarg.h> 
#include <netinet/in.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <signal.h> 
#include <unistd.h> 
#include <sys/stat.h> 
#include <sys/types.h> 
 
#include <stdio.h> 
#include "tool.h" 
 
 
static const char base64Char[] = 
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 
 
char* base64MyEncode(char const* origSigned, unsigned origLength)  
{ 
  unsigned char const* orig = (unsigned char const*)origSigned; // in case any input bytes have the MSB set 
  if (orig == NULL) return NULL; 
 
  unsigned const numOrig24BitValues = origLength/3; 
  bool havePadding = origLength > numOrig24BitValues*3; 
  bool havePadding2 = origLength == numOrig24BitValues*3 + 2; 
  unsigned const numResultBytes = 4*(numOrig24BitValues + havePadding); 
  char* result = new char[numResultBytes+1]; // allow for trailing '\0' 
 
  // Map each full group of 3 input bytes into 4 output base-64 characters: 
  unsigned i; 
  for (i = 0; i < numOrig24BitValues; ++i) { 
    result[4*i+0] = base64Char[(orig[3*i]>>2)&0x3F]; 
    result[4*i+1] = base64Char[(((orig[3*i]&0x3)<<4) | (orig[3*i+1]>>4))&0x3F]; 
    result[4*i+2] = base64Char[((orig[3*i+1]<<2) | (orig[3*i+2]>>6))&0x3F]; 
    result[4*i+3] = base64Char[orig[3*i+2]&0x3F]; 
  } 
 
  // Now, take padding into account.  (Note: i == numOrig24BitValues) 
  if (havePadding) { 
    result[4*i+0] = base64Char[(orig[3*i]>>2)&0x3F]; 
    if (havePadding2) { 
      result[4*i+1] = base64Char[(((orig[3*i]&0x3)<<4) | (orig[3*i+1]>>4))&0x3F]; 
      result[4*i+2] = base64Char[(orig[3*i+1]<<2)&0x3F]; 
    } else { 
      result[4*i+1] = base64Char[((orig[3*i]&0x3)<<4)&0x3F]; 
      result[4*i+2] = '='; 
    } 
    result[4*i+3] = '='; 
  } 
 
  result[numResultBytes] = '\0'; 
  return result; 
} 
 
int GetClockTime() 
{ 
    struct timespec times; 
     
    clock_gettime(CLOCK_MONOTONIC, &times); 
 
    return times.tv_sec; 
} 
 
bool IsVideoPayloadType(int type) 
{ 
    if(type >= 96 && type <= 127) 
    { 
        return true; 
    } 
    return false; 
} 
 
bool IsPsHeader(unsigned char *data) 
{
    if(data[0] == 0 && data[1] == 0 && data[2] == 1 && data[3] == 0xBA) 
        return true;
    return false;
} 
 
 
char* strMyDup(char const* str) { 
  if (str == NULL) return NULL; 
  size_t len = strlen(str) + 1; 
  char* copy = new char[len]; 
 
  if (copy != NULL) { 
    memcpy(copy, str, len); 
  } 
  return copy; 
} 
 
char* strMyDupSize(char const* str) { 
  size_t dummy; 
 
  return strMyDupSize2(str, dummy); 
} 
 
char* strMyDupSize2(char const* str, size_t& resultBufSize) { 
  if (str == NULL) { 
    resultBufSize = 0; 
    return NULL; 
  } 
 
  resultBufSize = strlen(str) + 1; 
  char* copy = new char[resultBufSize]; 
 
  return copy; 
}