blob: 33cca72a1fd3c7a5fd67d2504e3609270d110e77 [file] [log] [blame]
Pengfei Liuc181a982020-01-07 19:27:13 +08001#include <stdio.h>
Pengfei Liu3b1a8202020-02-12 23:04:21 +08002#include <unistd.h>
3#include <stdlib.h>
Pengfei Liub4734232020-01-17 18:25:10 +08004#include <string.h>
Zhiqiang Hane0a1c382021-06-08 11:28:05 +08005#include <errno.h>
Pengfei Liub4734232020-01-17 18:25:10 +08006#include <pthread.h>
Pengfei Liuc181a982020-01-07 19:27:13 +08007#include "dvr_segment.h"
Pengfei Liub4734232020-01-17 18:25:10 +08008#include <segment.h>
Pengfei Liuc181a982020-01-07 19:27:13 +08009
Pengfei Liub4734232020-01-17 18:25:10 +080010/**\brief DVR segment file information*/
11typedef struct {
12 char location[DVR_MAX_LOCATION_SIZE]; /**< DVR record file location*/
13 uint64_t id; /**< DVR Segment id*/
14} DVR_SegmentFile_t;
15
16void *dvr_segment_thread(void *arg)
17{
Pengfei Liub4734232020-01-17 18:25:10 +080018 int ret;
hualing chene83bf812020-04-23 13:42:37 +080019 DVR_SegmentFile_t *segment_file = (DVR_SegmentFile_t*)arg;
Wentao MA16f870e2022-09-09 11:00:22 +080020 if (segment_file == NULL) {
21 DVR_ERROR("Invalid segment_file pointer");
22 return NULL;
23 }
Pengfei Liub4734232020-01-17 18:25:10 +080024
hualing chen31140872020-03-25 12:29:26 +080025 pthread_detach(pthread_self());
Wentao MA96f68962022-06-15 19:45:35 +080026 DVR_INFO("%s try to delete [%s-%lld]", __func__, segment_file->location, segment_file->id);
hualing chene83bf812020-04-23 13:42:37 +080027 ret = segment_delete(segment_file->location, segment_file->id);
Wentao MA96f68962022-06-15 19:45:35 +080028 DVR_INFO("%s delete segment [%s-%lld] %s", __func__, segment_file->location, segment_file->id,
Pengfei Liub4734232020-01-17 18:25:10 +080029 ret == DVR_SUCCESS ? "success" : "failed");
hualing chene83bf812020-04-23 13:42:37 +080030 if (segment_file != NULL) {
31 //malloc at delete api.free at this
32 free(segment_file);
33 segment_file = NULL;
34 }
Pengfei Liub4734232020-01-17 18:25:10 +080035 return NULL;
36}
Pengfei Liu3b1a8202020-02-12 23:04:21 +080037
Pengfei Liuc181a982020-01-07 19:27:13 +080038int dvr_segment_delete(const char *location, uint64_t segment_id)
39{
hualing chen6d24aa92020-03-23 18:43:47 +080040
Pengfei Liub4734232020-01-17 18:25:10 +080041 pthread_t thread;
hualing chene83bf812020-04-23 13:42:37 +080042 DVR_SegmentFile_t *segment;
43 //this segment will be free at del thread when used end.if thread
44 //creat error.will be free now.
45 segment = (DVR_SegmentFile_t *)malloc(sizeof(DVR_SegmentFile_t));
Pengfei Liub4734232020-01-17 18:25:10 +080046
Wentao MA96f68962022-06-15 19:45:35 +080047 DVR_INFO("%s in, %s,id:%lld", __func__, location, segment_id);
hualing chene83bf812020-04-23 13:42:37 +080048 DVR_RETURN_IF_FALSE(segment);
Pengfei Liu3b1a8202020-02-12 23:04:21 +080049 DVR_RETURN_IF_FALSE(location);
50 DVR_RETURN_IF_FALSE(strlen(location) < DVR_MAX_LOCATION_SIZE);
hualing chene83bf812020-04-23 13:42:37 +080051 memset(segment->location, 0, sizeof(segment->location));
52 memcpy(segment->location, location, strlen(location));
53 segment->id = segment_id;
Zhiqiang Han2d8cd822020-03-16 13:58:10 +080054
hualing chene83bf812020-04-23 13:42:37 +080055 int ret = pthread_create(&thread, NULL, dvr_segment_thread, segment);
56 if (ret != 0) {
57 //creat thread error,need free segment
58 if (segment != NULL) {
59 free(segment);
60 segment = NULL;
61 }
62 }
Pengfei Liub4734232020-01-17 18:25:10 +080063 return DVR_SUCCESS;
Pengfei Liuc181a982020-01-07 19:27:13 +080064}
65
hualing chen4b7c15d2020-04-07 16:13:48 +080066int dvr_segment_del_by_location(const char *location)
67{
68 FILE *fp;
hualing chenb270cfa2020-08-19 15:04:35 +080069 char cmd[DVR_MAX_LOCATION_SIZE + 64];
hualing chen4b7c15d2020-04-07 16:13:48 +080070
71 DVR_RETURN_IF_FALSE(location);
72
Wentao MA96f68962022-06-15 19:45:35 +080073 DVR_INFO("%s location:%s", __func__, location);
hualing chen4b7c15d2020-04-07 16:13:48 +080074 {
75 /* del file */
76 memset(cmd, 0, sizeof(cmd));
hualing chen926a8ec2021-12-20 20:38:24 +080077 sprintf(cmd, "rm %s-* %s.list %s.stats %s.odb %s.dat", location, location, location, location, location);
hualing chen4b7c15d2020-04-07 16:13:48 +080078 fp = popen(cmd, "r");
79 DVR_RETURN_IF_FALSE(fp);
80 }
Zhiqiang Han5c805cf2020-05-09 16:51:08 +080081 pclose(fp);
Wentao MA96f68962022-06-15 19:45:35 +080082 DVR_INFO("%s location:%s end", __func__, location);
hualing chen4b7c15d2020-04-07 16:13:48 +080083 return DVR_SUCCESS;
84}
85
Pengfei Liuc181a982020-01-07 19:27:13 +080086int dvr_segment_get_list(const char *location, uint32_t *p_segment_nb, uint64_t **pp_segment_ids)
87{
Pengfei Liu3b1a8202020-02-12 23:04:21 +080088 FILE *fp;
89 char fpath[DVR_MAX_LOCATION_SIZE];
Zhiqiang Hanee5ac412020-05-07 20:54:32 +080090 uint32_t i = 0, j = 0, n = 0;
hualing chenb270cfa2020-08-19 15:04:35 +080091 char buf[DVR_MAX_LOCATION_SIZE + 10];
Pengfei Liu3b1a8202020-02-12 23:04:21 +080092 uint64_t *p = NULL;
hualing chenb270cfa2020-08-19 15:04:35 +080093 char cmd[DVR_MAX_LOCATION_SIZE + 64];
Pengfei Liu3b1a8202020-02-12 23:04:21 +080094
95 DVR_RETURN_IF_FALSE(location);
96 DVR_RETURN_IF_FALSE(p_segment_nb);
97 DVR_RETURN_IF_FALSE(pp_segment_ids);
98
Wentao MA96f68962022-06-15 19:45:35 +080099 //DVR_INFO("%s location:%s", __func__, location);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800100 memset(fpath, 0, sizeof(fpath));
101 sprintf(fpath, "%s.list", location);
102
103 if (access(fpath, 0) != -1) {
104 /*the list file is exist*/
105 fp = fopen(fpath, "r");
106 DVR_RETURN_IF_FALSE(fp);
107 /*get segment numbers*/
hualing chenb270cfa2020-08-19 15:04:35 +0800108 while (fgets(buf, sizeof(buf), fp) != NULL) {
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800109 i++;
110 }
111 *p_segment_nb = i;
112 rewind(fp);
113 /*malloc*/
114 p = malloc(i * sizeof(uint64_t));
115 i = 0;
116 /*set value*/
117 memset(buf, 0, sizeof(buf));
hualing chenb270cfa2020-08-19 15:04:35 +0800118 while (fgets(buf, sizeof(buf), fp) != NULL) {
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800119 p[i++] = strtoull(buf, NULL, 10);
120 memset(buf, 0, sizeof(buf));
121 }
122 *pp_segment_ids = p;
123 fclose(fp);
Wentao MA96f68962022-06-15 19:45:35 +0800124 DVR_INFO("%s location:%s segments:%d", __func__, location, i);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800125 } else {
hualing chenb270cfa2020-08-19 15:04:35 +0800126 uint32_t id = 0;
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800127 /*the list file does not exist*/
128 memset(cmd, 0, sizeof(cmd));
Zhiqiang Hanade34ff2020-04-17 16:50:59 +0800129 sprintf(cmd, "ls -l %s-*.ts | wc -l", location);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800130 fp = popen(cmd, "r");
131 DVR_RETURN_IF_FALSE(fp);
132 memset(buf, 0, sizeof(buf));
133 if (fgets(buf, sizeof(buf), fp) != NULL) {
134 i = strtoull(buf, NULL, 10);
135 pclose(fp);
136 } else {
137 pclose(fp);
Wentao MA96f68962022-06-15 19:45:35 +0800138 DVR_INFO("%s location:%s get null", __func__, location);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800139 return DVR_FAILURE;
140 }
Wentao MA96f68962022-06-15 19:45:35 +0800141 //DVR_INFO("%s location:%s i: %d ls buf:%s", __func__, location, i, buf);
Zhiqiang Hanee5ac412020-05-07 20:54:32 +0800142 n = i;
143 p = malloc(n * sizeof(uint64_t));
Zhiqiang Han8dd08b32020-05-13 16:50:04 +0800144 /*try to get the 1st segment id*/
145 memset(cmd, 0, sizeof(cmd));
hualing chenb270cfa2020-08-19 15:04:35 +0800146 sprintf(cmd, "ls %s-*.ts", location);
Zhiqiang Han8dd08b32020-05-13 16:50:04 +0800147 fp = popen(cmd, "r");
148 DVR_RETURN_IF_FALSE(fp);
149 memset(buf, 0, sizeof(buf));
hualing chenb270cfa2020-08-19 15:04:35 +0800150 j = 0;
151 snprintf(fpath, sizeof(fpath), "%s-%%d.ts", location);
152 while (fgets(buf, sizeof(buf), fp) != NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800153 //DVR_INFO("%s buf:%s", __func__, buf);
hualing chenb270cfa2020-08-19 15:04:35 +0800154 if (sscanf(buf, fpath, &id) != 1) {
Wentao MA96f68962022-06-15 19:45:35 +0800155 DVR_INFO("%s location:%s buf:%s not get id", __func__, location, buf);
hualing chenb270cfa2020-08-19 15:04:35 +0800156 id = 0;
157 n = n -1;
158 } else {
Wentao MA96f68962022-06-15 19:45:35 +0800159 //DVR_INFO("%s location:%s buf:%s get id:%d", __func__, location, buf, id);
hualing chenb270cfa2020-08-19 15:04:35 +0800160 p[j++] = id;
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800161 }
hualing chenb270cfa2020-08-19 15:04:35 +0800162 memset(buf, 0, sizeof(buf));
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800163 }
Wentao MA96f68962022-06-15 19:45:35 +0800164 DVR_DEBUG("%s location:%s n=%d j=%d end", __func__, location, n, j);
hualing chenb270cfa2020-08-19 15:04:35 +0800165 pclose(fp);
166 *p_segment_nb = n;
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800167 *pp_segment_ids = p;
168 }
Pengfei Liufaf38e42020-05-22 00:28:02 +0800169
Pengfei Liub4734232020-01-17 18:25:10 +0800170 return DVR_SUCCESS;
Pengfei Liuc181a982020-01-07 19:27:13 +0800171}
172
Pengfei Liub4734232020-01-17 18:25:10 +0800173int dvr_segment_get_info(const char *location, uint64_t segment_id, DVR_RecordSegmentInfo_t *p_info)
Pengfei Liuc181a982020-01-07 19:27:13 +0800174{
Pengfei Liub4734232020-01-17 18:25:10 +0800175 int ret;
176 Segment_OpenParams_t open_params;
177 Segment_Handle_t segment_handle;
178
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800179 DVR_RETURN_IF_FALSE(location);
180 DVR_RETURN_IF_FALSE(p_info);
181 DVR_RETURN_IF_FALSE(strlen((const char *)location) < DVR_MAX_LOCATION_SIZE);
Pengfei Liub4734232020-01-17 18:25:10 +0800182
183 memset(&open_params, 0, sizeof(open_params));
184 memcpy(open_params.location, location, strlen(location));
185 open_params.segment_id = segment_id;
186 open_params.mode = SEGMENT_MODE_READ;
187 ret = segment_open(&open_params, &segment_handle);
Zhiqiang Han5c805cf2020-05-09 16:51:08 +0800188 if (ret == DVR_SUCCESS) {
189 ret = segment_load_info(segment_handle, p_info);
190 }
Wentao MA96f68962022-06-15 19:45:35 +0800191 DVR_DEBUG("%s, id:%lld, nb_pids:%d, duration:%ld ms, size:%zu, nb_packets:%d",
hualing chen926a8ec2021-12-20 20:38:24 +0800192 __func__, p_info->id, p_info->nb_pids, p_info->duration, p_info->size, p_info->nb_packets);
hualing chenb2242352021-05-18 17:16:16 +0800193 //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800194 ret = segment_close(segment_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800195 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800196
197 return DVR_SUCCESS;
Pengfei Liuc181a982020-01-07 19:27:13 +0800198}
199
hualing chenb9a02922021-12-14 11:29:47 +0800200int dvr_segment_get_allInfo(const char *location, struct list_head *list)
201{
202 int ret;
203 Segment_OpenParams_t open_params;
204 Segment_Handle_t segment_handle;
205
206 DVR_RETURN_IF_FALSE(location);
207 DVR_RETURN_IF_FALSE(list);
208 DVR_RETURN_IF_FALSE(strlen((const char *)location) < DVR_MAX_LOCATION_SIZE);
209
210 memset(&open_params, 0, sizeof(open_params));
211 memcpy(open_params.location, location, strlen(location));
212 open_params.segment_id = 0;
213 open_params.mode = SEGMENT_MODE_READ;
214 ret = segment_open(&open_params, &segment_handle);
215 if (ret == DVR_SUCCESS) {
216 ret = segment_load_allInfo(segment_handle, list);
hualing chen926a8ec2021-12-20 20:38:24 +0800217 if (ret == DVR_FAILURE) {
218 segment_close(segment_handle);
219 return DVR_FAILURE;
220 }
hualing chenb9a02922021-12-14 11:29:47 +0800221 }
222 ret = segment_close(segment_handle);
223 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
224
225 return DVR_SUCCESS;
226}
227
228
Pengfei Liuc181a982020-01-07 19:27:13 +0800229int dvr_segment_link(const char *location, uint32_t nb_segments, uint64_t *p_segment_ids)
230{
Wentao MAe8ba5172022-08-09 11:18:17 +0800231 return dvr_segment_link_op(location, nb_segments, p_segment_ids, SEGMENT_OP_NEW);
Zhiqiang Hane0a1c382021-06-08 11:28:05 +0800232}
233
234int dvr_segment_link_op(const char *location, uint32_t nb_segments, uint64_t *p_segment_ids, int op)
235{
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800236 FILE *fp;
237 char fpath[DVR_MAX_LOCATION_SIZE];
238 uint32_t i;
hualing chenb270cfa2020-08-19 15:04:35 +0800239 char buf[DVR_MAX_LOCATION_SIZE + 64];
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800240
241 DVR_RETURN_IF_FALSE(location);
242 DVR_RETURN_IF_FALSE(p_segment_ids);
243 DVR_RETURN_IF_FALSE(strlen((const char *)location) < DVR_MAX_LOCATION_SIZE);
244
Wentao MA96f68962022-06-15 19:45:35 +0800245 DVR_INFO("%s op[%d] location:%s, nb_segments:%d", __func__, op, location, nb_segments);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800246 memset(fpath, 0, sizeof(fpath));
247 sprintf(fpath, "%s.list", location);
Wentao MAe8ba5172022-08-09 11:18:17 +0800248 fp = fopen(fpath, (op == SEGMENT_OP_ADD) ? "a+" : "w+");
Zhiqiang Hane0a1c382021-06-08 11:28:05 +0800249 if (!fp) {
Wentao MA96f68962022-06-15 19:45:35 +0800250 DVR_INFO("failed to open list file, err:%d:%s", errno, strerror(errno));
Zhiqiang Hane0a1c382021-06-08 11:28:05 +0800251 return DVR_FAILURE;
252 }
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800253 for (i = 0; i< nb_segments; i++) {
254 memset(buf, 0, sizeof(buf));
Zhiqiang Hane0a1c382021-06-08 11:28:05 +0800255 sprintf(buf, "%lld\n", p_segment_ids[i]);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800256 fwrite(buf, 1, strlen(buf), fp);
257 }
258
259 fflush(fp);
260 fsync(fileno(fp));
261 fclose(fp);
Pengfei Liub4734232020-01-17 18:25:10 +0800262 return DVR_SUCCESS;
Pengfei Liuc181a982020-01-07 19:27:13 +0800263}