blob: f1fd4bb949344cc6bde69771b2a7da7218553b06 [file] [log] [blame]
Pengfei Liuc181a982020-01-07 19:27:13 +08001#include <stdio.h>
Pengfei Liub4734232020-01-17 18:25:10 +08002#include <unistd.h>
3#include <stdlib.h>
Pengfei Liuc181a982020-01-07 19:27:13 +08004#include <pthread.h>
Pengfei Liub4734232020-01-17 18:25:10 +08005#include <string.h>
Pengfei Liu47ed6c92020-01-17 11:23:41 +08006#include "dvr_types.h"
Pengfei Liuc181a982020-01-07 19:27:13 +08007#include "dvr_record.h"
8#include "dvr_crypto.h"
Gong Ke2a0ebbe2021-05-25 15:22:50 +08009#include "dvb_utils.h"
Pengfei Liuc181a982020-01-07 19:27:13 +080010#include "record_device.h"
11#include "segment.h"
pengfei.liu567d6d82020-04-17 16:48:59 +080012#include <sys/time.h>
Yahui Han1fbf3292021-11-08 18:17:19 +080013#include "am_crypt.h"
Pengfei Liuc181a982020-01-07 19:27:13 +080014
hualing chend241c7a2021-06-22 13:34:27 +080015#define CONTROL_SPEED_ENABLE 0
16
hualing chenc7aa4c82021-02-03 15:41:37 +080017//#define DEBUG_PERFORMANCE
Yahui Han10993892021-11-02 14:27:33 +080018#define MAX_DVR_RECORD_SESSION_COUNT 4
hualing chen266b9502020-04-04 17:39:39 +080019#define RECORD_BLOCK_SIZE (256 * 1024)
Yahui Hance15e9c2020-12-08 18:08:32 +080020#define NEW_DEVICE_RECORD_BLOCK_SIZE (1024 * 188)
pengfei.liuab5a2262020-02-14 17:33:40 +080021
22/**\brief DVR index file type*/
23typedef enum {
24 DVR_INDEX_TYPE_PCR, /**< DVR index file use pcr*/
25 DVR_INDEX_TYPE_LOCAL_CLOCK, /**< DVR index file use local clock*/
26 DVR_INDEX_TYPE_INVALID /**< DVR index file type invalid type*/
27} DVR_IndexType_t;
28
29/**\brief DVR VOD context*/
30typedef struct {
31 pthread_mutex_t mutex; /**< VOD mutex lock*/
32 pthread_cond_t cond; /**< VOD condition*/
33 void *buffer; /**< VOD buffer*/
34 uint32_t buf_len; /**< VOD buffer len*/
35} DVR_VodContext_t;
36
pengfei.liu07ddc8a2020-03-24 23:36:53 +080037/**\brief DVR record secure mode buffer*/
38typedef struct {
39 uint32_t addr; /**< Secure mode record buffer address*/
40 uint32_t len; /**< Secure mode record buffer length*/
41} DVR_SecureBuffer_t;
42
hualing chenf9867402020-09-23 17:06:20 +080043/**\brief DVR record new dmx secure mode buffer*/
44typedef struct {
45 uint32_t buf_start; /**< Secure mode record buffer address*/
46 uint32_t buf_end; /**< Secure mode record buffer length*/
47 uint32_t data_start; /**< Secure mode record buffer address*/
48 uint32_t data_end; /**< Secure mode record buffer length*/
49} DVR_NewDmxSecureBuffer_t;
50
Pengfei Liub4734232020-01-17 18:25:10 +080051/**\brief DVR record context*/
Pengfei Liuc181a982020-01-07 19:27:13 +080052typedef struct {
Pengfei Liub4734232020-01-17 18:25:10 +080053 pthread_t thread; /**< DVR thread handle*/
54 Record_DeviceHandle_t dev_handle; /**< DVR device handle*/
55 Segment_Handle_t segment_handle; /**< DVR segment handle*/
56 DVR_RecordState_t state; /**< DVR record state*/
57 char location[DVR_MAX_LOCATION_SIZE]; /**< DVR record file location*/
58 DVR_RecordSegmentStartParams_t segment_params; /**< DVR record start parameters*/
59 DVR_RecordSegmentInfo_t segment_info; /**< DVR record current segment info*/
60 size_t notification_size; /**< DVR record nogification size*/
61 DVR_RecordEventFunction_t event_notify_fn; /**< DVR record event notify function*/
62 void *event_userdata; /**< DVR record event userdata*/
pengfei.liuab5a2262020-02-14 17:33:40 +080063 //DVR_VodContext_t vod; /**< DVR record vod context*/
64 int is_vod; /**< Indicate current mode is VOD record mode*/
pengfei.liu27cc4ec2020-04-03 16:28:16 +080065 DVR_CryptoFunction_t enc_func; /**< Encrypt function*/
pengfei.liu07ddc8a2020-03-24 23:36:53 +080066 void *enc_userdata; /**< Encrypt userdata*/
67 int is_secure_mode; /**< Record session run in secure pipeline */
Yahui Han1fbf3292021-11-08 18:17:19 +080068 void *cryptor; /**< Cryptor for encrypted PVR on FTA.*/
hualing chen2615aa82020-04-02 21:32:51 +080069 size_t last_send_size; /**< Last send notify segment size */
pengfei.liufda2a972020-04-09 14:47:15 +080070 uint32_t block_size; /**< DVR record block size */
hualing chenf9867402020-09-23 17:06:20 +080071 DVR_Bool_t is_new_dmx; /**< DVR is used new dmx driver */
hualing chen40accc32021-04-21 15:58:09 +080072 int index_type; /**< DVR is used pcr or local time */
Pengfei Liuc181a982020-01-07 19:27:13 +080073} DVR_RecordContext_t;
74
Gong Ke2a0ebbe2021-05-25 15:22:50 +080075extern ssize_t record_device_read_ext(Record_DeviceHandle_t handle, size_t *buf, size_t *len);
76
Pengfei Liuc181a982020-01-07 19:27:13 +080077static DVR_RecordContext_t record_ctx[MAX_DVR_RECORD_SESSION_COUNT] = {
78 {
Pengfei Liub4734232020-01-17 18:25:10 +080079 .state = DVR_RECORD_STATE_CLOSED
Pengfei Liuc181a982020-01-07 19:27:13 +080080 },
81 {
Pengfei Liub4734232020-01-17 18:25:10 +080082 .state = DVR_RECORD_STATE_CLOSED
Pengfei Liuc181a982020-01-07 19:27:13 +080083 }
84};
85
Zhiqiang Han51646a02020-04-05 18:43:22 +080086static int record_is_valid_pid(DVR_RecordContext_t *p_ctx, int pid)
87{
88 int i;
89
90 for (i = 0; i < p_ctx->segment_info.nb_pids; i++) {
91 if (pid == p_ctx->segment_info.pids[i].pid)
92 return 1;
93 }
94 return 0;
95}
96
pengfei.liuab5a2262020-02-14 17:33:40 +080097static int record_save_pcr(DVR_RecordContext_t *p_ctx, uint8_t *buf, loff_t pos)
98{
99 uint8_t *p = buf;
100 int len;
101 uint8_t afc;
102 uint64_t pcr = 0;
103 int has_pcr = 0;
104 int pid;
105 int adp_field_len;
106
107 pid = ((p[1] & 0x1f) << 8) | p[2];
Zhiqiang Han51646a02020-04-05 18:43:22 +0800108 if (pid == 0x1fff || !record_is_valid_pid(p_ctx, pid))
pengfei.liuab5a2262020-02-14 17:33:40 +0800109 return has_pcr;
110
111 //scramble = p[3] >> 6;
112 //cc = p[3] & 0x0f;
113 afc = (p[3] >> 4) & 0x03;
114
115 p += 4;
116 len = 184;
117
118 if (afc & 2) {
119 adp_field_len = p[0];
120 /* Skip adaptation len */
121 p++;
122 len--;
123 /* Parse pcr field, see 13818 spec table I-2-6,adaptation_field */
hualing chen5605eed2020-05-26 18:18:06 +0800124 if (p[0] & 0x10 && len >= 6 && adp_field_len >= 6) {
pengfei.liuab5a2262020-02-14 17:33:40 +0800125 /* get pcr value,pcr is 33bit value */
126 pcr = (((uint64_t)(p[1])) << 25)
127 | (((uint64_t)p[2]) << 17)
128 | (((uint64_t)(p[3])) << 9)
129 | (((uint64_t)p[4]) << 1)
130 | ((((uint64_t)p[5]) & 0x80) >> 7);
131 has_pcr = 1;
132 }
133
134 p += adp_field_len;
135 len -= adp_field_len;
136
137 if (len < 0) {
138 DVR_DEBUG(1, "parser pcr: illegal adaptation field length");
139 return 0;
140 }
141 }
142
hualing chen40accc32021-04-21 15:58:09 +0800143 if (has_pcr && p_ctx->index_type == DVR_INDEX_TYPE_PCR) {
pengfei.liuab5a2262020-02-14 17:33:40 +0800144 segment_update_pts(p_ctx->segment_handle, pcr/90, pos);
145 }
146 return has_pcr;
147}
148
149static int record_do_pcr_index(DVR_RecordContext_t *p_ctx, uint8_t *buf, int len)
150{
151 uint8_t *p = buf;
152 int left = len;
153 loff_t pos;
154 int has_pcr = 0;
155
156 pos = segment_tell_position(p_ctx->segment_handle);
hualing chena5f03222021-12-02 11:22:35 +0800157
pengfei.liuab5a2262020-02-14 17:33:40 +0800158 while (left >= 188) {
159 if (*p == 0x47) {
160 has_pcr |= record_save_pcr(p_ctx, p, pos);
161 p += 188;
162 left -= 188;
163 pos += 188;
164 } else {
165 p++;
166 left --;
167 pos++;
168 }
169 }
170 return has_pcr;
171}
172
pengfei.liu567d6d82020-04-17 16:48:59 +0800173static int get_diff_time(struct timeval start_tv, struct timeval end_tv)
174{
175 return end_tv.tv_sec * 1000 + end_tv.tv_usec / 1000 - start_tv.tv_sec * 1000 - start_tv.tv_usec / 1000;
176}
177
Pengfei Liuc181a982020-01-07 19:27:13 +0800178void *record_thread(void *arg)
179{
180 DVR_RecordContext_t *p_ctx = (DVR_RecordContext_t *)arg;
181 ssize_t len;
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800182 uint8_t *buf, *buf_out;
pengfei.liufda2a972020-04-09 14:47:15 +0800183 uint32_t block_size = p_ctx->block_size;
pengfei.liuab5a2262020-02-14 17:33:40 +0800184 loff_t pos = 0;
Pengfei Liuc181a982020-01-07 19:27:13 +0800185 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800186 struct timespec start_ts, end_ts;
187 DVR_RecordStatus_t record_status;
pengfei.liuab5a2262020-02-14 17:33:40 +0800188 int has_pcr;
hualing chen40accc32021-04-21 15:58:09 +0800189
hualing chen87072a82020-03-12 16:20:12 +0800190 time_t pre_time = 0;
hualing chen2932d372020-04-29 13:44:00 +0800191 #define DVR_STORE_INFO_TIME (400)
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800192 DVR_SecureBuffer_t secure_buf;
hualing chenf9867402020-09-23 17:06:20 +0800193 DVR_NewDmxSecureBuffer_t new_dmx_secure_buf;
hualing chena5f03222021-12-02 11:22:35 +0800194 int first_read = 0;
hualing chend241c7a2021-06-22 13:34:27 +0800195 if (CONTROL_SPEED_ENABLE == 0)
196 p_ctx->index_type = DVR_INDEX_TYPE_INVALID;
197 else
198 p_ctx->index_type = DVR_INDEX_TYPE_LOCAL_CLOCK;
Pengfei Liuc181a982020-01-07 19:27:13 +0800199
Pengfei Liub4734232020-01-17 18:25:10 +0800200 buf = (uint8_t *)malloc(block_size);
Pengfei Liuc181a982020-01-07 19:27:13 +0800201 if (!buf) {
202 DVR_DEBUG(1, "%s, malloc failed", __func__);
203 return NULL;
204 }
205
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800206 buf_out = (uint8_t *)malloc(block_size + 188);
207 if (!buf_out) {
208 DVR_DEBUG(1, "%s, malloc failed", __func__);
Pengfei Liufaf38e42020-05-22 00:28:02 +0800209 free(buf);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800210 return NULL;
211 }
212
hualing chen266b9502020-04-04 17:39:39 +0800213 memset(&record_status, 0, sizeof(record_status));
214 record_status.state = DVR_RECORD_STATE_STARTED;
pengfei.liufda2a972020-04-09 14:47:15 +0800215 if (p_ctx->event_notify_fn) {
hualing chen4b7c15d2020-04-07 16:13:48 +0800216 record_status.info.id = p_ctx->segment_info.id;
pengfei.liufda2a972020-04-09 14:47:15 +0800217 p_ctx->event_notify_fn(DVR_RECORD_EVENT_STATUS, &record_status, p_ctx->event_userdata);
hualing chen4b7c15d2020-04-07 16:13:48 +0800218 DVR_DEBUG(1, "%s line %d notify record status, state:%d id=%lld",
219 __func__,__LINE__, record_status.state, p_ctx->segment_info.id);
pengfei.liufda2a972020-04-09 14:47:15 +0800220 }
Yahui Han1fbf3292021-11-08 18:17:19 +0800221 DVR_DEBUG(1, "%s, secure_mode:%d, block_size:%d, cryptor:%p",
222 __func__, p_ctx->is_secure_mode,
223 block_size, p_ctx->cryptor);
Pengfei Liub4734232020-01-17 18:25:10 +0800224 clock_gettime(CLOCK_MONOTONIC, &start_ts);
pengfei.liu567d6d82020-04-17 16:48:59 +0800225
226 struct timeval t1, t2, t3, t4, t5, t6, t7;
hualing chen03fd4942021-07-15 15:56:41 +0800227 while (p_ctx->state == DVR_RECORD_STATE_STARTED ||
228 p_ctx->state == DVR_RECORD_STATE_PAUSE) {
229
230 if (p_ctx->state == DVR_RECORD_STATE_PAUSE) {
231 //wait resume record
232 usleep(20*1000);
233 continue;
234 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800235 gettimeofday(&t1, NULL);
hualing chenc70a8df2020-05-12 19:23:11 +0800236
pengfei.liuab5a2262020-02-14 17:33:40 +0800237 /* data from dmx, normal dvr case */
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800238 if (p_ctx->is_secure_mode) {
hualing chenf9867402020-09-23 17:06:20 +0800239 if (p_ctx->is_new_dmx) {
Yahui Hance15e9c2020-12-08 18:08:32 +0800240
241 /* We resolve the below invoke for dvbcore to be under safety status */
hualing chenf9867402020-09-23 17:06:20 +0800242 memset(&new_dmx_secure_buf, 0, sizeof(new_dmx_secure_buf));
Yahui Hance15e9c2020-12-08 18:08:32 +0800243 len = record_device_read(p_ctx->dev_handle, &new_dmx_secure_buf, sizeof(new_dmx_secure_buf), 10);
244 if (len == DVR_FAILURE) {
Gong Ke2a0ebbe2021-05-25 15:22:50 +0800245 DVR_DEBUG(1, "handle[%p] ret:%d\n", p_ctx->dev_handle, ret);
Yahui Hance15e9c2020-12-08 18:08:32 +0800246 /*For the second recording, poll always failed which we should check
247 * dvbcore further. For now, Just ignore the fack poll fail, I think
248 * it won't influce anything. But we need adjust the poll timeout
249 * from 1000ms to 10ms.
250 */
251 //continue;
252 }
253
254 /* Read data from secure demux TA */
255 len = record_device_read_ext(p_ctx->dev_handle, &secure_buf.addr,
256 &secure_buf.len);
257
hualing chenf9867402020-09-23 17:06:20 +0800258 } else {
259 memset(&secure_buf, 0, sizeof(secure_buf));
260 len = record_device_read(p_ctx->dev_handle, &secure_buf, sizeof(secure_buf), 1000);
261 }
262 if (len != DVR_FAILURE) {
hualing chen4fe3bee2020-10-23 13:58:52 +0800263 //DVR_DEBUG(1, "%s, secure_buf:%#x, size:%#x", __func__, secure_buf.addr, secure_buf.len);
hualing chenf9867402020-09-23 17:06:20 +0800264 }
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800265 } else {
266 len = record_device_read(p_ctx->dev_handle, buf, block_size, 1000);
267 }
Pengfei Liub4734232020-01-17 18:25:10 +0800268 if (len == DVR_FAILURE) {
hualing chen6c126382020-04-13 15:47:51 +0800269 //usleep(10*1000);
hualing chen2932d372020-04-29 13:44:00 +0800270 DVR_DEBUG(1, "%s, start_read error", __func__);
Pengfei Liub4734232020-01-17 18:25:10 +0800271 continue;
272 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800273 gettimeofday(&t2, NULL);
hualing chenc70a8df2020-05-12 19:23:11 +0800274
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800275 /* Got data from device, record it */
Yahui Han1fbf3292021-11-08 18:17:19 +0800276 if (p_ctx->is_secure_mode && p_ctx->enc_func) {
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800277 /* Encrypt record data */
pengfei.liu27cc4ec2020-04-03 16:28:16 +0800278 DVR_CryptoParams_t crypto_params;
279
280 memset(&crypto_params, 0, sizeof(crypto_params));
281 crypto_params.type = DVR_CRYPTO_TYPE_ENCRYPT;
hualing chen7a56cba2020-04-14 14:09:27 +0800282 memcpy(crypto_params.location, p_ctx->location, sizeof(p_ctx->location));
pengfei.liu27cc4ec2020-04-03 16:28:16 +0800283 crypto_params.segment_id = p_ctx->segment_info.id;
284 crypto_params.offset = p_ctx->segment_info.size;
285
286 if (p_ctx->is_secure_mode) {
287 crypto_params.input_buffer.type = DVR_BUFFER_TYPE_SECURE;
Yahui Han1fbf3292021-11-08 18:17:19 +0800288 crypto_params.input_buffer.addr = secure_buf.addr;
289 crypto_params.input_buffer.size = secure_buf.len;
pengfei.liu27cc4ec2020-04-03 16:28:16 +0800290 } else {
291 crypto_params.input_buffer.type = DVR_BUFFER_TYPE_NORMAL;
292 crypto_params.input_buffer.addr = (size_t)buf;
293 crypto_params.input_buffer.size = len;
294 }
295
296 crypto_params.output_buffer.type = DVR_BUFFER_TYPE_NORMAL;
297 crypto_params.output_buffer.addr = (size_t)buf_out;
298 crypto_params.output_buffer.size = block_size + 188;
hualing chen9811b212020-10-29 11:21:44 +0800299
pengfei.liu27cc4ec2020-04-03 16:28:16 +0800300 p_ctx->enc_func(&crypto_params, p_ctx->enc_userdata);
pengfei.liu567d6d82020-04-17 16:48:59 +0800301 gettimeofday(&t3, NULL);
pengfei.liu27cc4ec2020-04-03 16:28:16 +0800302 /* Out buffer length may not equal in buffer length */
hualing chenf9867402020-09-23 17:06:20 +0800303 if (crypto_params.output_size > 0) {
304 ret = segment_write(p_ctx->segment_handle, buf_out, crypto_params.output_size);
305 len = crypto_params.output_size;
hualing chenbafc62d2020-11-02 15:44:05 +0800306 } else {
307 len = 0;
hualing chenf9867402020-09-23 17:06:20 +0800308 }
Yahui Han1fbf3292021-11-08 18:17:19 +0800309 } else if (p_ctx->cryptor) {
310 /* Encrypt with clear key */
Yahui Han63b23b42021-12-07 15:37:46 +0800311 int crypt_len = len;
312 am_crypt_des_crypt(p_ctx->cryptor, buf_out, buf, &crypt_len, 0);
313 len = crypt_len;
Yahui Han1fbf3292021-11-08 18:17:19 +0800314 gettimeofday(&t3, NULL);
315 ret = segment_write(p_ctx->segment_handle, buf_out, len);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800316 } else {
hualing chena5f03222021-12-02 11:22:35 +0800317 if (first_read == 0) {
318 first_read = 1;
319 DVR_DEBUG(1, "%s:%d,first read ts", __func__,__LINE__);
320 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800321 gettimeofday(&t3, NULL);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800322 ret = segment_write(p_ctx->segment_handle, buf, len);
323 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800324 gettimeofday(&t4, NULL);
hualing chen626204e2020-04-07 11:55:08 +0800325 //add DVR_RECORD_EVENT_WRITE_ERROR event if write error
pengfei.liufda2a972020-04-09 14:47:15 +0800326 if (ret == -1 && len > 0 && p_ctx->event_notify_fn) {
hualing chen626204e2020-04-07 11:55:08 +0800327 //send write event
hualing chen9b434f02020-06-10 15:06:54 +0800328 if (p_ctx->event_notify_fn) {
hualing chen4b7c15d2020-04-07 16:13:48 +0800329 memset(&record_status, 0, sizeof(record_status));
hualing chen4fe3bee2020-10-23 13:58:52 +0800330 DVR_DEBUG(1, "%s:%d,send event write error", __func__,__LINE__);
hualing chen9ce7d942021-06-30 13:31:01 +0800331 record_status.info.id = p_ctx->segment_info.id;
hualing chen4b7c15d2020-04-07 16:13:48 +0800332 p_ctx->event_notify_fn(DVR_RECORD_EVENT_WRITE_ERROR, &record_status, p_ctx->event_userdata);
333 }
hualing chenc70a8df2020-05-12 19:23:11 +0800334 DVR_DEBUG(1, "%s,write error %d", __func__,__LINE__);
hualing chen626204e2020-04-07 11:55:08 +0800335 goto end;
336 }
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800337 /* Do time index */
Yahui Han1fbf3292021-11-08 18:17:19 +0800338 uint8_t *index_buf = (p_ctx->enc_func || p_ctx->cryptor)? buf_out : buf;
pengfei.liuab5a2262020-02-14 17:33:40 +0800339 pos = segment_tell_position(p_ctx->segment_handle);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800340 has_pcr = record_do_pcr_index(p_ctx, index_buf, len);
hualing chen40accc32021-04-21 15:58:09 +0800341 if (has_pcr == 0 && p_ctx->index_type == DVR_INDEX_TYPE_INVALID) {
pengfei.liuab5a2262020-02-14 17:33:40 +0800342 clock_gettime(CLOCK_MONOTONIC, &end_ts);
343 if ((end_ts.tv_sec*1000 + end_ts.tv_nsec/1000000) -
344 (start_ts.tv_sec*1000 + start_ts.tv_nsec/1000000) > 40) {
345 /* PCR interval threshlod > 40 ms*/
346 DVR_DEBUG(1, "%s use local clock time index", __func__);
hualing chen40accc32021-04-21 15:58:09 +0800347 p_ctx->index_type = DVR_INDEX_TYPE_LOCAL_CLOCK;
pengfei.liuab5a2262020-02-14 17:33:40 +0800348 }
hualing chen40accc32021-04-21 15:58:09 +0800349 } else if (has_pcr && p_ctx->index_type == DVR_INDEX_TYPE_INVALID){
pengfei.liuab5a2262020-02-14 17:33:40 +0800350 DVR_DEBUG(1, "%s use pcr time index", __func__);
hualing chen40accc32021-04-21 15:58:09 +0800351 p_ctx->index_type = DVR_INDEX_TYPE_PCR;
Pengfei Liuc181a982020-01-07 19:27:13 +0800352 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800353 gettimeofday(&t5, NULL);
pengfei.liuab5a2262020-02-14 17:33:40 +0800354
355 /* Update segment info */
Pengfei Liub4734232020-01-17 18:25:10 +0800356 p_ctx->segment_info.size += len;
pengfei.liuab5a2262020-02-14 17:33:40 +0800357 /*Duration need use pcr to calculate, todo...*/
hualing chen40accc32021-04-21 15:58:09 +0800358 if (p_ctx->index_type == DVR_INDEX_TYPE_PCR) {
pengfei.liu8b563292020-02-26 15:49:02 +0800359 p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle);
hualing chen87072a82020-03-12 16:20:12 +0800360 if (pre_time == 0)
361 pre_time = p_ctx->segment_info.duration;
hualing chen40accc32021-04-21 15:58:09 +0800362 } else if (p_ctx->index_type == DVR_INDEX_TYPE_LOCAL_CLOCK) {
pengfei.liuab5a2262020-02-14 17:33:40 +0800363 clock_gettime(CLOCK_MONOTONIC, &end_ts);
364 p_ctx->segment_info.duration = (end_ts.tv_sec*1000 + end_ts.tv_nsec/1000000) -
365 (start_ts.tv_sec*1000 + start_ts.tv_nsec/1000000);
hualing chen87072a82020-03-12 16:20:12 +0800366 if (pre_time == 0)
367 pre_time = p_ctx->segment_info.duration;
pengfei.liuab5a2262020-02-14 17:33:40 +0800368 segment_update_pts(p_ctx->segment_handle, p_ctx->segment_info.duration, pos);
369 } else {
370 DVR_DEBUG(1, "%s can NOT do time index", __func__);
371 }
372 p_ctx->segment_info.nb_packets = p_ctx->segment_info.size/188;
Pengfei Liub4734232020-01-17 18:25:10 +0800373
hualing chen87072a82020-03-12 16:20:12 +0800374 if (p_ctx->segment_info.duration - pre_time > DVR_STORE_INFO_TIME) {
375 pre_time = p_ctx->segment_info.duration + DVR_STORE_INFO_TIME;
hualing chenf9867402020-09-23 17:06:20 +0800376 segment_store_info(p_ctx->segment_handle, &(p_ctx->segment_info));
hualing chen87072a82020-03-12 16:20:12 +0800377 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800378 gettimeofday(&t6, NULL);
hualing chen87072a82020-03-12 16:20:12 +0800379 /*Event notification*/
Pengfei Liub4734232020-01-17 18:25:10 +0800380 if (p_ctx->notification_size &&
381 p_ctx->event_notify_fn &&
hualing chen2615aa82020-04-02 21:32:51 +0800382 /*!(p_ctx->segment_info.size % p_ctx->notification_size)*/
383 (p_ctx->segment_info.size -p_ctx->last_send_size) >= p_ctx->notification_size&&
hualing chenbe68d642021-09-09 13:06:36 +0800384 p_ctx->segment_info.duration > 0 &&
385 p_ctx->state == DVR_RECORD_STATE_STARTED) {
Pengfei Liub4734232020-01-17 18:25:10 +0800386 memset(&record_status, 0, sizeof(record_status));
pengfei.liuab5a2262020-02-14 17:33:40 +0800387 //clock_gettime(CLOCK_MONOTONIC, &end_ts);
hualing chen2615aa82020-04-02 21:32:51 +0800388 p_ctx->last_send_size = p_ctx->segment_info.size;
Pengfei Liub4734232020-01-17 18:25:10 +0800389 record_status.state = p_ctx->state;
390 record_status.info.id = p_ctx->segment_info.id;
pengfei.liuab5a2262020-02-14 17:33:40 +0800391 record_status.info.duration = p_ctx->segment_info.duration;
Pengfei Liub4734232020-01-17 18:25:10 +0800392 record_status.info.size = p_ctx->segment_info.size;
393 record_status.info.nb_packets = p_ctx->segment_info.size/188;
394 p_ctx->event_notify_fn(DVR_RECORD_EVENT_STATUS, &record_status, p_ctx->event_userdata);
hualing chen4fe3bee2020-10-23 13:58:52 +0800395 DVR_DEBUG(1, "%s notify record status, state:%d, id:%lld, duration:%ld ms, size:%zu loc[%s]",
396 __func__, record_status.state,
397 record_status.info.id, record_status.info.duration,
398 record_status.info.size, p_ctx->location);
Pengfei Liub4734232020-01-17 18:25:10 +0800399 }
pengfei.liu567d6d82020-04-17 16:48:59 +0800400 gettimeofday(&t7, NULL);
401#ifdef DEBUG_PERFORMANCE
hualing chen2932d372020-04-29 13:44:00 +0800402 DVR_DEBUG(1, "record count, read:%dms, encrypt:%dms, write:%dms, index:%dms, store:%dms, notify:%dms total:%dms read len:%zd ",
pengfei.liu567d6d82020-04-17 16:48:59 +0800403 get_diff_time(t1, t2), get_diff_time(t2, t3), get_diff_time(t3, t4), get_diff_time(t4, t5),
hualing chen2932d372020-04-29 13:44:00 +0800404 get_diff_time(t5, t6), get_diff_time(t6, t7), get_diff_time(t1, t5), len);
pengfei.liu567d6d82020-04-17 16:48:59 +0800405#endif
Pengfei Liuc181a982020-01-07 19:27:13 +0800406 }
hualing chen626204e2020-04-07 11:55:08 +0800407end:
Pengfei Liub4734232020-01-17 18:25:10 +0800408 free((void *)buf);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800409 free((void *)buf_out);
Pengfei Liub4734232020-01-17 18:25:10 +0800410 DVR_DEBUG(1, "exit %s", __func__);
Pengfei Liuc181a982020-01-07 19:27:13 +0800411 return NULL;
412}
413
414int dvr_record_open(DVR_RecordHandle_t *p_handle, DVR_RecordOpenParams_t *params)
415{
416 DVR_RecordContext_t *p_ctx;
417 Record_DeviceOpenParams_t dev_open_params;
418 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800419 uint32_t i;
Pengfei Liuc181a982020-01-07 19:27:13 +0800420
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800421 DVR_RETURN_IF_FALSE(p_handle);
422 DVR_RETURN_IF_FALSE(params);
Pengfei Liuc181a982020-01-07 19:27:13 +0800423
424 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
Pengfei Liub4734232020-01-17 18:25:10 +0800425 if (record_ctx[i].state == DVR_RECORD_STATE_CLOSED) {
Pengfei Liuc181a982020-01-07 19:27:13 +0800426 break;
427 }
428 }
Pengfei Liufaf38e42020-05-22 00:28:02 +0800429 DVR_RETURN_IF_FALSE(i < MAX_DVR_RECORD_SESSION_COUNT);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800430 DVR_RETURN_IF_FALSE(record_ctx[i].state == DVR_RECORD_STATE_CLOSED);
Pengfei Liuc181a982020-01-07 19:27:13 +0800431 p_ctx = &record_ctx[i];
Yahui Han1fbf3292021-11-08 18:17:19 +0800432 DVR_DEBUG(1, "%s , current state:%d, dmx_id:%d, notification_size:%zu, flags:%d, keylen:%d ",
433 __func__, p_ctx->state, params->dmx_dev_id,
434 params->notification_size,
435 params->flags, params->keylen);
Pengfei Liuc181a982020-01-07 19:27:13 +0800436
Pengfei Liub4734232020-01-17 18:25:10 +0800437 /*Process event params*/
438 p_ctx->notification_size = params->notification_size;
439 p_ctx->event_notify_fn = params->event_fn;
440 p_ctx->event_userdata = params->event_userdata;
hualing chen2615aa82020-04-02 21:32:51 +0800441 p_ctx->last_send_size = 0;
Yahui Han1fbf3292021-11-08 18:17:19 +0800442
443 if (params->keylen > 0) {
444 p_ctx->cryptor = am_crypt_des_open(params->clearkey,
445 params->cleariv,
446 params->keylen * 8);
447 if (!p_ctx->cryptor)
448 DVR_DEBUG(1, "%s , open des cryptor failed!!!\n", __func__);
449 } else {
450 p_ctx->cryptor = NULL;
451 }
452
hualing chenf9867402020-09-23 17:06:20 +0800453 //check is new driver
454 p_ctx->is_new_dmx = dvr_check_dmx_isNew();
Pengfei Liub4734232020-01-17 18:25:10 +0800455 /*Process crypto params, todo*/
Pengfei Liub4734232020-01-17 18:25:10 +0800456 memset((void *)&dev_open_params, 0, sizeof(dev_open_params));
pengfei.liuab5a2262020-02-14 17:33:40 +0800457 if (params->data_from_memory) {
458 /* data from memory, VOD case */
459 p_ctx->is_vod = 1;
460 } else {
461 p_ctx->is_vod = 0;
462 /* data from dmx, normal dvr case */
hualing chen958fe4c2020-03-24 17:35:07 +0800463 dev_open_params.dmx_dev_id = params->dmx_dev_id;
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800464 dev_open_params.buf_size = (params->flush_size > 0 ? params->flush_size : RECORD_BLOCK_SIZE);
hualing chen03fd4942021-07-15 15:56:41 +0800465 dev_open_params.ringbuf_size = params->ringbuf_size;
hualing chen9811b212020-10-29 11:21:44 +0800466 if (p_ctx->is_new_dmx)
hualing cheneceb37e2021-01-18 16:07:48 +0800467 dev_open_params.buf_size = NEW_DEVICE_RECORD_BLOCK_SIZE * 30;
pengfei.liuab5a2262020-02-14 17:33:40 +0800468 ret = record_device_open(&p_ctx->dev_handle, &dev_open_params);
469 if (ret != DVR_SUCCESS) {
470 DVR_DEBUG(1, "%s, open record devices failed", __func__);
471 return DVR_FAILURE;
472 }
Pengfei Liuc181a982020-01-07 19:27:13 +0800473 }
474
pengfei.liufda2a972020-04-09 14:47:15 +0800475 p_ctx->block_size = (params->flush_size > 0 ? params->flush_size : RECORD_BLOCK_SIZE);
hualing chen9811b212020-10-29 11:21:44 +0800476 if (p_ctx->is_new_dmx)
Yahui Hance15e9c2020-12-08 18:08:32 +0800477 p_ctx->block_size = NEW_DEVICE_RECORD_BLOCK_SIZE * 30;
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800478 p_ctx->enc_func = NULL;
479 p_ctx->enc_userdata = NULL;
480 p_ctx->is_secure_mode = 0;
Pengfei Liuc181a982020-01-07 19:27:13 +0800481 p_ctx->state = DVR_RECORD_STATE_OPENED;
hualing chen9811b212020-10-29 11:21:44 +0800482 DVR_DEBUG(1, "%s, block_size:%d is_new:%d", __func__, p_ctx->block_size, p_ctx->is_new_dmx);
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800483 *p_handle = p_ctx;
Pengfei Liuc181a982020-01-07 19:27:13 +0800484 return DVR_SUCCESS;
485}
486
487int dvr_record_close(DVR_RecordHandle_t handle)
488{
489 DVR_RecordContext_t *p_ctx;
490 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800491 uint32_t i;
Pengfei Liuc181a982020-01-07 19:27:13 +0800492
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800493 p_ctx = (DVR_RecordContext_t *)handle;
494 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
495 if (p_ctx == &record_ctx[i])
496 break;
497 }
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800498 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
Pengfei Liuc181a982020-01-07 19:27:13 +0800499
Pengfei Liub4734232020-01-17 18:25:10 +0800500 DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800501 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
Yahui Han1fbf3292021-11-08 18:17:19 +0800502 if (p_ctx->cryptor) {
503 am_crypt_des_close(p_ctx->cryptor);
504 p_ctx->cryptor = NULL;
505 }
pengfei.liuab5a2262020-02-14 17:33:40 +0800506 if (p_ctx->is_vod) {
507 ret = DVR_SUCCESS;
508 } else {
509 ret = record_device_close(p_ctx->dev_handle);
510 if (ret != DVR_SUCCESS) {
511 DVR_DEBUG(1, "%s, failed", __func__);
512 }
Pengfei Liuc181a982020-01-07 19:27:13 +0800513 }
514
Pengfei Liub4734232020-01-17 18:25:10 +0800515 p_ctx->state = DVR_RECORD_STATE_CLOSED;
Pengfei Liuc181a982020-01-07 19:27:13 +0800516 return ret;
517}
518
hualing chen03fd4942021-07-15 15:56:41 +0800519int dvr_record_pause(DVR_RecordHandle_t handle)
520{
521 DVR_RecordContext_t *p_ctx;
522 int ret;
523 uint32_t i;
524
525 p_ctx = (DVR_RecordContext_t *)handle;
526 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
527 if (p_ctx == &record_ctx[i])
528 break;
529 }
530 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
531
532 DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state);
533 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
534
535 if (p_ctx->is_vod) {
536 ret = DVR_SUCCESS;
537 }
538 //set pause state,will not store ts into segment
539 p_ctx->state = DVR_RECORD_STATE_PAUSE;
540 return ret;
541}
542
543int dvr_record_resume(DVR_RecordHandle_t handle)
544{
545 DVR_RecordContext_t *p_ctx;
546 int ret;
547 uint32_t i;
548
549 p_ctx = (DVR_RecordContext_t *)handle;
550 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
551 if (p_ctx == &record_ctx[i])
552 break;
553 }
554 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
555
556 DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state);
557 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
558
559 if (p_ctx->is_vod) {
560 ret = DVR_SUCCESS;
561 }
562 //set stated state,will resume store ts into segment
563 p_ctx->state = DVR_RECORD_STATE_STARTED;
564 return ret;
565}
566
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800567#if 0
Pengfei Liuc181a982020-01-07 19:27:13 +0800568int dvr_record_register_encryption(DVR_RecordHandle_t handle,
569 DVR_CryptoFunction_t cb,
570 DVR_CryptoParams_t params,
571 void *userdata)
572{
573 return DVR_SUCCESS;
574}
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800575#endif
Pengfei Liuc181a982020-01-07 19:27:13 +0800576
577int dvr_record_start_segment(DVR_RecordHandle_t handle, DVR_RecordStartParams_t *params)
578{
579 DVR_RecordContext_t *p_ctx;
580 Segment_OpenParams_t open_params;
581 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800582 uint32_t i;
Pengfei Liuc181a982020-01-07 19:27:13 +0800583
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800584 p_ctx = (DVR_RecordContext_t *)handle;
585 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
586 if (p_ctx == &record_ctx[i])
587 break;
588 }
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800589 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
Pengfei Liuc181a982020-01-07 19:27:13 +0800590
hualing chen4fe3bee2020-10-23 13:58:52 +0800591 DVR_DEBUG(1, "%s , current state:%d pids:%d params->location:%s", __func__, p_ctx->state, params->segment.nb_pids, params->location);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800592 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STARTED);
593 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
594 DVR_RETURN_IF_FALSE(params);
Pengfei Liuc181a982020-01-07 19:27:13 +0800595
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800596 DVR_RETURN_IF_FALSE(strlen((const char *)params->location) < DVR_MAX_LOCATION_SIZE);
Pengfei Liuc181a982020-01-07 19:27:13 +0800597 memset(&open_params, 0, sizeof(open_params));
hualing chen7a56cba2020-04-14 14:09:27 +0800598 memcpy(open_params.location, params->location, sizeof(params->location));
Pengfei Liuc181a982020-01-07 19:27:13 +0800599 open_params.segment_id = params->segment.segment_id;
600 open_params.mode = SEGMENT_MODE_WRITE;
601
602 ret = segment_open(&open_params, &p_ctx->segment_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800603 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liuc181a982020-01-07 19:27:13 +0800604
Pengfei Liub4734232020-01-17 18:25:10 +0800605 /*process params*/
Pengfei Liuc181a982020-01-07 19:27:13 +0800606 {
hualing chen7a56cba2020-04-14 14:09:27 +0800607 memcpy(p_ctx->location, params->location, sizeof(params->location));
Pengfei Liub4734232020-01-17 18:25:10 +0800608 //need all params??
Pengfei Liuc181a982020-01-07 19:27:13 +0800609 memcpy(&p_ctx->segment_params, &params->segment, sizeof(params->segment));
Pengfei Liub4734232020-01-17 18:25:10 +0800610 /*save current segment info*/
611 memset(&p_ctx->segment_info, 0, sizeof(p_ctx->segment_info));
612 p_ctx->segment_info.id = params->segment.segment_id;
613 p_ctx->segment_info.nb_pids = params->segment.nb_pids;
614 memcpy(p_ctx->segment_info.pids, params->segment.pids, params->segment.nb_pids*sizeof(DVR_StreamPid_t));
Pengfei Liuc181a982020-01-07 19:27:13 +0800615 }
616
pengfei.liuab5a2262020-02-14 17:33:40 +0800617 if (!p_ctx->is_vod) {
618 /* normal dvr case */
619 for (i = 0; i < params->segment.nb_pids; i++) {
620 ret = record_device_add_pid(p_ctx->dev_handle, params->segment.pids[i].pid);
621 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
622 }
623 ret = record_device_start(p_ctx->dev_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800624 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liuc181a982020-01-07 19:27:13 +0800625 }
626
Zhiqiang Han5ebad992020-04-28 18:19:59 +0800627 ret = segment_store_info(p_ctx->segment_handle, &p_ctx->segment_info);
628
Pengfei Liuc181a982020-01-07 19:27:13 +0800629 p_ctx->state = DVR_RECORD_STATE_STARTED;
pengfei.liuab5a2262020-02-14 17:33:40 +0800630 if (!p_ctx->is_vod)
631 pthread_create(&p_ctx->thread, NULL, record_thread, p_ctx);
Pengfei Liub4734232020-01-17 18:25:10 +0800632
Pengfei Liuc181a982020-01-07 19:27:13 +0800633 return DVR_SUCCESS;
634}
635
636int dvr_record_next_segment(DVR_RecordHandle_t handle, DVR_RecordStartParams_t *params, DVR_RecordSegmentInfo_t *p_info)
637{
638 DVR_RecordContext_t *p_ctx;
Pengfei Liub4734232020-01-17 18:25:10 +0800639 Segment_OpenParams_t open_params;
Pengfei Liuc181a982020-01-07 19:27:13 +0800640 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800641 uint32_t i;
hualing chen2932d372020-04-29 13:44:00 +0800642 loff_t pos;
Pengfei Liuc181a982020-01-07 19:27:13 +0800643
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800644 p_ctx = (DVR_RecordContext_t *)handle;
645 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
646 if (p_ctx == &record_ctx[i])
647 break;
648 }
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800649 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
Pengfei Liuc181a982020-01-07 19:27:13 +0800650
hualing chen4fe3bee2020-10-23 13:58:52 +0800651 DVR_DEBUG(1, "%s , current state:%d p_ctx->location:%s", __func__, p_ctx->state, p_ctx->location);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800652 DVR_RETURN_IF_FALSE(p_ctx->state == DVR_RECORD_STATE_STARTED);
653 //DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
654 DVR_RETURN_IF_FALSE(params);
655 DVR_RETURN_IF_FALSE(p_info);
pengfei.liuab5a2262020-02-14 17:33:40 +0800656 DVR_RETURN_IF_FALSE(!p_ctx->is_vod);
Pengfei Liuc181a982020-01-07 19:27:13 +0800657
658 /*Stop the on going record segment*/
Pengfei Liub4734232020-01-17 18:25:10 +0800659 //ret = record_device_stop(p_ctx->dev_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800660 //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liuc181a982020-01-07 19:27:13 +0800661 p_ctx->state = DVR_RECORD_STATE_STOPPED;
662 pthread_join(p_ctx->thread, NULL);
663
hualing chen2932d372020-04-29 13:44:00 +0800664 //add index file store
665 pos = segment_tell_position(p_ctx->segment_handle);
666 segment_update_pts_force(p_ctx->segment_handle, p_ctx->segment_info.duration, pos);
667
668 p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle);
Pengfei Liub4734232020-01-17 18:25:10 +0800669 /*Update segment info*/
670 memcpy(p_info, &p_ctx->segment_info, sizeof(p_ctx->segment_info));
671
672 ret = segment_store_info(p_ctx->segment_handle, p_info);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800673 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
hualing chenb9a02922021-12-14 11:29:47 +0800674 ret = segment_store_allInfo(p_ctx->segment_handle, p_info);
hualing chena540a7e2020-03-27 16:44:05 +0800675 DVR_DEBUG(1, "%s dump segment info, id:%lld, nb_pids:%d, duration:%ld ms, size:%zu, nb_packets:%d params->segment.nb_pids:%d",
676 __func__, p_info->id, p_info->nb_pids, p_info->duration, p_info->size, p_info->nb_packets, params->segment.nb_pids);
Pengfei Liuc181a982020-01-07 19:27:13 +0800677
Pengfei Liub4734232020-01-17 18:25:10 +0800678 /*Close current segment*/
679 ret = segment_close(p_ctx->segment_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800680 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800681 /*Open the new record segment*/
682 memset(&open_params, 0, sizeof(open_params));
hualing chen7a56cba2020-04-14 14:09:27 +0800683 memcpy(open_params.location, p_ctx->location, sizeof(p_ctx->location));
Pengfei Liub4734232020-01-17 18:25:10 +0800684 open_params.segment_id = params->segment.segment_id;
685 open_params.mode = SEGMENT_MODE_WRITE;
hualing chen7a56cba2020-04-14 14:09:27 +0800686 DVR_DEBUG(1, "%s: p_ctx->location:%s params->location:%s", __func__, p_ctx->location,params->location);
Pengfei Liub4734232020-01-17 18:25:10 +0800687
688 ret = segment_open(&open_params, &p_ctx->segment_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800689 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800690 /*process params*/
Pengfei Liuc181a982020-01-07 19:27:13 +0800691 {
Pengfei Liub4734232020-01-17 18:25:10 +0800692 //need all params??
Pengfei Liuc181a982020-01-07 19:27:13 +0800693 memcpy(&p_ctx->segment_params, &params->segment, sizeof(params->segment));
Pengfei Liub4734232020-01-17 18:25:10 +0800694 /*save current segment info*/
695 memset(&p_ctx->segment_info, 0, sizeof(p_ctx->segment_info));
696 p_ctx->segment_info.id = params->segment.segment_id;
697 memcpy(p_ctx->segment_info.pids, params->segment.pids, params->segment.nb_pids*sizeof(DVR_StreamPid_t));
Pengfei Liuc181a982020-01-07 19:27:13 +0800698 }
699
Pengfei Liub4734232020-01-17 18:25:10 +0800700 p_ctx->segment_info.nb_pids = 0;
Pengfei Liuc181a982020-01-07 19:27:13 +0800701 for (i = 0; i < params->segment.nb_pids; i++) {
Pengfei Liub4734232020-01-17 18:25:10 +0800702 switch (params->segment.pid_action[i]) {
703 case DVR_RECORD_PID_CREATE:
704 DVR_DEBUG(1, "%s create pid:%d", __func__, params->segment.pids[i].pid);
705 ret = record_device_add_pid(p_ctx->dev_handle, params->segment.pids[i].pid);
706 p_ctx->segment_info.nb_pids++;
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800707 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800708 break;
709 case DVR_RECORD_PID_KEEP:
710 DVR_DEBUG(1, "%s keep pid:%d", __func__, params->segment.pids[i].pid);
711 p_ctx->segment_info.nb_pids++;
712 break;
713 case DVR_RECORD_PID_CLOSE:
714 DVR_DEBUG(1, "%s close pid:%d", __func__, params->segment.pids[i].pid);
715 ret = record_device_remove_pid(p_ctx->dev_handle, params->segment.pids[i].pid);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800716 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800717 break;
718 default:
719 DVR_DEBUG(1, "%s wrong action pid:%d", __func__, params->segment.pids[i].pid);
720 return DVR_FAILURE;
721 }
Pengfei Liuc181a982020-01-07 19:27:13 +0800722 }
723
Pengfei Liub4734232020-01-17 18:25:10 +0800724 //ret = record_device_start(p_ctx->dev_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800725 //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
hualing chen4b7c15d2020-04-07 16:13:48 +0800726 /*Update segment info*/
727 ret = segment_store_info(p_ctx->segment_handle, &p_ctx->segment_info);
Pengfei Liuc181a982020-01-07 19:27:13 +0800728
Pengfei Liuc181a982020-01-07 19:27:13 +0800729 p_ctx->state = DVR_RECORD_STATE_STARTED;
Zhiqiang Han0d60f2b2020-05-26 14:39:54 +0800730 pthread_create(&p_ctx->thread, NULL, record_thread, p_ctx);
Pengfei Liuc181a982020-01-07 19:27:13 +0800731 return DVR_SUCCESS;
732}
733
734int dvr_record_stop_segment(DVR_RecordHandle_t handle, DVR_RecordSegmentInfo_t *p_info)
735{
736 DVR_RecordContext_t *p_ctx;
737 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800738 uint32_t i;
hualing chen2932d372020-04-29 13:44:00 +0800739 loff_t pos;
Pengfei Liuc181a982020-01-07 19:27:13 +0800740
Pengfei Liu47ed6c92020-01-17 11:23:41 +0800741 p_ctx = (DVR_RecordContext_t *)handle;
742 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
743 if (p_ctx == &record_ctx[i])
744 break;
745 }
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800746 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
Pengfei Liuc181a982020-01-07 19:27:13 +0800747
hualing chen4fe3bee2020-10-23 13:58:52 +0800748 DVR_DEBUG(1, "%s , current state:%d p_ctx->location:%s", __func__, p_ctx->state, p_ctx->location);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800749 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STOPPED);
750 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
Zhiqiang Han2d8cd822020-03-16 13:58:10 +0800751 DVR_RETURN_IF_FALSE(p_info);/*should support NULL*/
Pengfei Liuc181a982020-01-07 19:27:13 +0800752
Pengfei Liuc181a982020-01-07 19:27:13 +0800753 p_ctx->state = DVR_RECORD_STATE_STOPPED;
pengfei.liuab5a2262020-02-14 17:33:40 +0800754 if (p_ctx->is_vod) {
pengfei.liu8b563292020-02-26 15:49:02 +0800755 p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle);
pengfei.liuab5a2262020-02-14 17:33:40 +0800756 p_ctx->segment_info.duration = 10*1000; //debug, should delete it
757 } else {
758 ret = record_device_stop(p_ctx->dev_handle);
Zhiqiang Han5c805cf2020-05-09 16:51:08 +0800759 //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
760 if (ret != DVR_SUCCESS)
761 goto end;
pengfei.liuab5a2262020-02-14 17:33:40 +0800762 //p_ctx->state = DVR_RECORD_STATE_STOPPED;
763 pthread_join(p_ctx->thread, NULL);
764 }
765
hualing chen2932d372020-04-29 13:44:00 +0800766 //add index file store
767 pos = segment_tell_position(p_ctx->segment_handle);
768 segment_update_pts_force(p_ctx->segment_handle, p_ctx->segment_info.duration, pos);
hualing chene41f4372020-06-06 16:29:17 +0800769 p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle);
Pengfei Liuc181a982020-01-07 19:27:13 +0800770
Pengfei Liub4734232020-01-17 18:25:10 +0800771 /*Update segment info*/
772 memcpy(p_info, &p_ctx->segment_info, sizeof(p_ctx->segment_info));
773
774 ret = segment_store_info(p_ctx->segment_handle, p_info);
Zhiqiang Han5c805cf2020-05-09 16:51:08 +0800775 //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
776 if (ret != DVR_SUCCESS)
777 goto end;
Pengfei Liub4734232020-01-17 18:25:10 +0800778
hualing chenb9a02922021-12-14 11:29:47 +0800779 segment_store_allInfo(p_ctx->segment_handle, p_info);
780
Pengfei Liub4734232020-01-17 18:25:10 +0800781 DVR_DEBUG(1, "%s dump segment info, id:%lld, nb_pids:%d, duration:%ld ms, size:%zu, nb_packets:%d",
782 __func__, p_info->id, p_info->nb_pids, p_info->duration, p_info->size, p_info->nb_packets);
783
Zhiqiang Han5c805cf2020-05-09 16:51:08 +0800784end:
Pengfei Liuc181a982020-01-07 19:27:13 +0800785 ret = segment_close(p_ctx->segment_handle);
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800786 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
Pengfei Liub4734232020-01-17 18:25:10 +0800787 return DVR_SUCCESS;
788}
Pengfei Liuc181a982020-01-07 19:27:13 +0800789
Pengfei Liub4734232020-01-17 18:25:10 +0800790int dvr_record_resume_segment(DVR_RecordHandle_t handle, DVR_RecordStartParams_t *params, uint64_t *p_resume_size)
791{
792 DVR_RecordContext_t *p_ctx;
793 uint32_t i;
pengfei.liuab5a2262020-02-14 17:33:40 +0800794 int ret;
Pengfei Liub4734232020-01-17 18:25:10 +0800795
796 p_ctx = (DVR_RecordContext_t *)handle;
797 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
798 if (p_ctx == &record_ctx[i])
799 break;
Pengfei Liuc181a982020-01-07 19:27:13 +0800800 }
Pengfei Liu3b1a8202020-02-12 23:04:21 +0800801 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
802 DVR_RETURN_IF_FALSE(params);
803 DVR_RETURN_IF_FALSE(p_resume_size);
Pengfei Liuc181a982020-01-07 19:27:13 +0800804
pengfei.liuab5a2262020-02-14 17:33:40 +0800805 DVR_DEBUG(1, "%s , current state:%d, resume size:%lld", __func__, p_ctx->state, *p_resume_size);
806 ret = dvr_record_start_segment(handle, params);
807 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
808
809 p_ctx->segment_info.size = *p_resume_size;
810
811 return DVR_SUCCESS;
812}
813
814int dvr_record_get_status(DVR_RecordHandle_t handle, DVR_RecordStatus_t *p_status)
815{
816 DVR_RecordContext_t *p_ctx;
817 int i;
818
819 p_ctx = (DVR_RecordContext_t *)handle;
820 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
821 if (p_ctx == &record_ctx[i])
822 break;
823 }
824 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
825 DVR_RETURN_IF_FALSE(p_status);
826
827 //lock
828 p_status->state = p_ctx->state;
829 p_status->info.id = p_ctx->segment_info.id;
830 p_status->info.duration = p_ctx->segment_info.duration;
831 p_status->info.size = p_ctx->segment_info.size;
832 p_status->info.nb_packets = p_ctx->segment_info.size/188;
833
834 return DVR_SUCCESS;
835}
836
837int dvr_record_write(DVR_RecordHandle_t handle, void *buffer, uint32_t len)
838{
839 DVR_RecordContext_t *p_ctx;
840 uint32_t i;
841 off_t pos = 0;
842 int ret;
843 int has_pcr;
844
845 p_ctx = (DVR_RecordContext_t *)handle;
846 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
847 if (p_ctx == &record_ctx[i])
848 break;
849 }
850 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
851 DVR_RETURN_IF_FALSE(buffer);
852 DVR_RETURN_IF_FALSE(len);
853
854 pos = segment_tell_position(p_ctx->segment_handle);
855 has_pcr = record_do_pcr_index(p_ctx, buffer, len);
856 if (has_pcr == 0) {
857 /* Pull VOD record shoud use PCR time index */
858 DVR_DEBUG(1, "%s has no pcr, can NOT do time index", __func__);
859 }
860 ret = segment_write(p_ctx->segment_handle, buffer, len);
hualing chen2932d372020-04-29 13:44:00 +0800861 if (ret != len) {
862 DVR_DEBUG(1, "%s write error ret:%d len:%d", __func__, ret, len);
863 }
pengfei.liuab5a2262020-02-14 17:33:40 +0800864 p_ctx->segment_info.size += len;
865 p_ctx->segment_info.nb_packets = p_ctx->segment_info.size/188;
866
Pengfei Liuc181a982020-01-07 19:27:13 +0800867 return DVR_SUCCESS;
868}
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800869
pengfei.liu27cc4ec2020-04-03 16:28:16 +0800870int dvr_record_set_encrypt_callback(DVR_RecordHandle_t handle, DVR_CryptoFunction_t func, void *userdata)
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800871{
872 DVR_RecordContext_t *p_ctx;
873 uint32_t i;
874
875 p_ctx = (DVR_RecordContext_t *)handle;
876 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
877 if (p_ctx == &record_ctx[i])
878 break;
879 }
880 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
881 DVR_RETURN_IF_FALSE(func);
882
883 DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state);
884 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STARTED);
885 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
886
887 p_ctx->enc_func = func;
888 p_ctx->enc_userdata = userdata;
889 return DVR_SUCCESS;
890}
891
892int dvr_record_set_secure_buffer(DVR_RecordHandle_t handle, uint8_t *p_secure_buf, uint32_t len)
893{
894 DVR_RecordContext_t *p_ctx;
895 uint32_t i;
896 int ret;
897
898 p_ctx = (DVR_RecordContext_t *)handle;
899 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
900 if (p_ctx == &record_ctx[i])
901 break;
902 }
903 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
904 DVR_RETURN_IF_FALSE(p_secure_buf);
905 DVR_RETURN_IF_FALSE(len);
906
907 DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state);
908 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STARTED);
909 DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED);
910
911 ret = record_device_set_secure_buffer(p_ctx->dev_handle, p_secure_buf, len);
912 DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS);
913
914 p_ctx->is_secure_mode = 1;
915 return ret;
916}
hualing chen4fe3bee2020-10-23 13:58:52 +0800917
918int dvr_record_is_secure_mode(DVR_RecordHandle_t handle)
919{
920 DVR_RecordContext_t *p_ctx;
921 uint32_t i;
922 int ret;
923
924 p_ctx = (DVR_RecordContext_t *)handle;
925 for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) {
926 if (p_ctx == &record_ctx[i])
927 break;
928 }
929 DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]);
930
931 if (p_ctx->is_secure_mode == 1)
932 ret = 1;
933 else
934 ret = 0;
935 return ret;
Yahui Hance15e9c2020-12-08 18:08:32 +0800936}