GetYUV format is NV12

zhangmeng

2023-12-26 18a05d269516a5e33d8460291c2f93e73d95adce

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include "filesystem.hpp"
 
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
 
extern "C"{
#include "../thirdparty/whereami/whereami.h"
}
 
#include "../ffmpeg/log/log.hpp"
using namespace logif;
 
namespace common{
 
    bool getExecutablePath(std::string &exec_path){
        char* path = NULL;
        int length, dirname_length;
        int i;
        
        length = wai_getExecutablePath(NULL, 0, &dirname_length);
        if (length > 0)
        {
            path = (char*)malloc(length + 1);
            if (!path)
                return false;
            wai_getExecutablePath(path, length, &dirname_length);
            path[length] = '\0';
            exec_path = path;
 
            // printf("executable path: %s\n", path);
            // path[dirname_length] = '\0';
            // printf("  dirname: %s\n", path);
            // printf("  basename: %s\n", path + dirname_length + 1);
            free(path);
        }
        return true;
    }
 
    bool getExecutableDirectory(std::string &exec_dir){
        char* path = NULL;
        int length, dirname_length;
        int i;
        
        length = wai_getExecutablePath(NULL, 0, &dirname_length);
        if (length > 0)
        {
            path = (char*)malloc(length + 1);
            if (!path)
                return false;
            wai_getExecutablePath(path, length, &dirname_length);
            path[length] = '\0';
 
            // printf("executable path: %s\n", path);
            path[dirname_length] = '\0';
            // printf("  dirname: %s\n", path);
            // printf("  basename: %s\n", path + dirname_length + 1);
 
            exec_dir = path;
 
            free(path);
        }
        return true;
    }
 
    bool makeDirectory(std::string &dir){
        if(dir == "." || dir == "./" || dir == ".." || dir == "../"){
            return true;
        }
        std::string str_dir(dir);  
        if(str_dir.find("/") == std::string::npos){
            std::string temp;
            const bool ret = getExecutableDirectory(temp);
            if(ret){
                str_dir = temp + "/" + dir;
            }
        }
        
        char   DirName[256];  
        strcpy(DirName,   str_dir.c_str()); 
        int i = 0;
        int len   =   strlen(DirName);
        if(DirName[len-1]!='/'){
            strcat(DirName,   "/"); 
            
            len   =   strlen(DirName);
        }
         
         
        for(i=1;   i<len;   i++)  
        {  
            if(DirName[i]=='/')  
            {  
                DirName[i]   =   0;  
                if(  access(DirName,   NULL)!=0   )  
                {  
                    if(mkdir(DirName,   0777)==-1)  
                    {   
                        logIt("record mkdir error\n");  
                        return false; 
                    }  
                }  
                DirName[i]   =   '/';  
            }  
        }  
         
        return true;
    }
 
    std::string getTimeStampString(){
        time_t now;
        struct tm *now_time;
        time(&now);
        now_time = localtime(&now);
        char timestamp[64];
        snprintf(timestamp, 64, "%d%02d%02d%02d%02d%02d",
            now_time->tm_year+1900, now_time->tm_mon+1,
            now_time->tm_mday, now_time->tm_hour, 
            now_time->tm_min,now_time->tm_sec);
        return timestamp;
    }
 
}