update ffmpeg

zhangmeng

2019-09-20 be9c1d1f659b0ff31f656424c478e83a4f7c53b5

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
125
126
127
128
129
130
131
132
133
134
135
136
#ifdef __cplusplus
extern "C"{
#endif
 
#include <dlfcn.h>
#include <stdlib.h>
#include <stdio.h>
 
#include "libcffmpeg.h"
 
#ifdef __cplusplus
}
#endif
 
#define release_if_err(fn, lib) do{if(!fn){dlclose(lib); return NULL;}}while(0)
 
libcffmpeg init_libcffmpeg(const char *so_file){
    libcffmpeg lib = dlopen(so_file, RTLD_LAZY);
    if(lib){
        fn_create = (lib_cffmpeg_create)dlsym(lib, "c_ffmpeg_create");
        release_if_err(fn_create, lib);
        fn_destroy = (lib_cffmpeg_destroy)dlsym(lib, "c_ffmpeg_destroy");
        release_if_err(fn_destroy, lib);
        fn_run = (lib_cffmpeg_run)dlsym(lib, "c_ffmpeg_run");
        release_if_err(fn_run, lib);
        fn_scale = (lib_cffmpeg_scale)dlsym(lib, "c_ffmpeg_scale");
        release_if_err(fn_scale, lib);
        fn_gb28181 = (lib_cffmpeg_gb28181)dlsym(lib, "c_ffmpeg_run_gb28181");
        release_if_err(fn_gb28181, lib);
        fn_cpu = (lib_cffmpeg_cpu)dlsym(lib, "c_ffmepg_use_cpu");
        release_if_err(fn_cpu, lib);
        fn_recorder = (lib_cffmpeg_recorder)dlsym(lib, "c_ffmpeg_build_recorder");
        release_if_err(fn_recorder, lib);
        fn_fire_recorder = (lib_cffmpeg_fire_recorder)dlsym(lib, "c_ffmpeg_fire_recorder");
        release_if_err(fn_fire_recorder, lib);
        fn_info_recorder = (lib_cffmpeg_info_recorder)dlsym(lib, "c_ffmpeg_get_info_recorder");
        release_if_err(fn_info_recorder, lib);
        fn_decoder = (lib_cffmpeg_decoder)dlsym(lib, "c_ffmpeg_build_decoder");
        release_if_err(fn_decoder, lib);
        fn_decoder_pic = (lib_cffmpeg_pic)dlsym(lib, "c_ffmpeg_get_pic_decoder");
        release_if_err(fn_decoder_pic, lib);
        fn_get_avpacket = (lib_cffmpeg_avpacket)dlsym(lib, "c_ffmpeg_get_avpacket");
        release_if_err(fn_get_avpacket, lib);
        fn_dec_jpeg = (lib_cffmpeg_decode_jpeg)dlsym(lib, "c_ffmpeg_decode_jpeg");
        release_if_err(fn_dec_jpeg, lib);
 
        fn_create_encoder = (lib_cffmpeg_create_encoder)dlsym(lib, "c_ffmpeg_create_encoder");
        release_if_err(fn_create_encoder, lib);
        fn_destroy_encoder = (lib_cffmpeg_destroy_encoder)dlsym(lib, "c_ffmpeg_destroy_encoder");
        release_if_err(fn_destroy_encoder, lib);
        fn_encode = (lib_cffmpeg_encode)dlsym(lib, "c_ffmpeg_encode");
        release_if_err(fn_encode, lib);
 
    }else{
        printf("dlopen - %s\n", dlerror());  
    }
    return lib;
}
 
void release_libcffmpeg(libcffmpeg lib){
    if(lib){
        dlclose(lib);
    }
}
 
cffmpeg wrap_fn_create(){
    return fn_create();
}
 
void wrap_fn_destroy(const cffmpeg h){
    fn_destroy(h);
}
 
void wrap_fn_run(const cffmpeg h, const char* input){
    fn_run(h, input);
}
 
void wrap_fn_scale(const cffmpeg h, const int wid, const int hei, const int flags){
    fn_scale(h, wid, hei, flags);
}
 
void wrap_fn_run_gb28181(const cffmpeg h){
    fn_gb28181(h);
}
 
void wrap_fn_use_cpu(const cffmpeg h){
    fn_cpu(h);
}
 
void wrap_fn_recorder(const cffmpeg h, const char* id, const char* dir, int mind, int maxd, int audio){
    fn_recorder(h, id, dir, mind, maxd, audio);
}
 
void wrap_fn_fire_recorder(const cffmpeg h, const char* sid, const int64_t id){
    fn_fire_recorder(h, sid, id);
}
 
void wrap_fn_info_recorder(const cffmpeg h, int* index, char** recid, int* recidLen, char** fpath, int* pathLen){
    return fn_info_recorder(h, index, recid, recidLen, fpath, pathLen);
}
 
void wrap_fn_decoder(const cffmpeg h){
    fn_decoder(h);
}
 
void* wrap_fn_decoder_pic(const cffmpeg h, int* wid, int* hei, int64_t *id){
    return fn_decoder_pic(h, wid, hei, id);
}
 
void* wrap_fn_get_avpacket(const cffmpeg h, int* size, int* key){
    return fn_get_avpacket(h, size, key);
}
 
void* wrap_fn_decode_jpeg(const char* file, int* wid, int* hei){
    return fn_dec_jpeg(file, wid, hei);
}
 
// for encoder
cencoder wrap_fn_create_encoder(const int w, const int h, const int fps, const int br, const int scale_flag, const int gi){
    return fn_create_encoder(w, h, fps, br, scale_flag, gi);
}
 
void wrap_fn_destroy_encoder(const cencoder h){
    fn_destroy_encoder(h);
}
 
void* wrap_fn_encode(cencoder hdl, void *in, const int w, const int h, int *out_size, int *key){
    uint8_t *out = NULL;
    const int flag = fn_encode(hdl, (uint8_t*)in, w, h, &out, out_size, key);
    if (flag > 0 && out != NULL) {
        return out;
    }
    *out_size = 0;
    *key = 0;
    return NULL;
}