Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 1 | #include <stdio.h> |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 2 | #include <unistd.h> |
| 3 | #include <stdlib.h> |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 4 | #include <pthread.h> |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 5 | #include <string.h> |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 6 | #include "dvr_types.h" |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 7 | #include "dvr_record.h" |
| 8 | #include "dvr_crypto.h" |
| 9 | #include "record_device.h" |
| 10 | #include "segment.h" |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 11 | #include <sys/time.h> |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 12 | |
hualing chen | 5605eed | 2020-05-26 18:18:06 +0800 | [diff] [blame] | 13 | //#define DEBUG_PERFORMANCE |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 14 | #define MAX_DVR_RECORD_SESSION_COUNT 2 |
hualing chen | 266b950 | 2020-04-04 17:39:39 +0800 | [diff] [blame] | 15 | #define RECORD_BLOCK_SIZE (256 * 1024) |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 16 | |
| 17 | /**\brief DVR index file type*/ |
| 18 | typedef enum { |
| 19 | DVR_INDEX_TYPE_PCR, /**< DVR index file use pcr*/ |
| 20 | DVR_INDEX_TYPE_LOCAL_CLOCK, /**< DVR index file use local clock*/ |
| 21 | DVR_INDEX_TYPE_INVALID /**< DVR index file type invalid type*/ |
| 22 | } DVR_IndexType_t; |
| 23 | |
| 24 | /**\brief DVR VOD context*/ |
| 25 | typedef struct { |
| 26 | pthread_mutex_t mutex; /**< VOD mutex lock*/ |
| 27 | pthread_cond_t cond; /**< VOD condition*/ |
| 28 | void *buffer; /**< VOD buffer*/ |
| 29 | uint32_t buf_len; /**< VOD buffer len*/ |
| 30 | } DVR_VodContext_t; |
| 31 | |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 32 | /**\brief DVR record secure mode buffer*/ |
| 33 | typedef struct { |
| 34 | uint32_t addr; /**< Secure mode record buffer address*/ |
| 35 | uint32_t len; /**< Secure mode record buffer length*/ |
| 36 | } DVR_SecureBuffer_t; |
| 37 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 38 | /**\brief DVR record context*/ |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 39 | typedef struct { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 40 | pthread_t thread; /**< DVR thread handle*/ |
| 41 | Record_DeviceHandle_t dev_handle; /**< DVR device handle*/ |
| 42 | Segment_Handle_t segment_handle; /**< DVR segment handle*/ |
| 43 | DVR_RecordState_t state; /**< DVR record state*/ |
| 44 | char location[DVR_MAX_LOCATION_SIZE]; /**< DVR record file location*/ |
| 45 | DVR_RecordSegmentStartParams_t segment_params; /**< DVR record start parameters*/ |
| 46 | DVR_RecordSegmentInfo_t segment_info; /**< DVR record current segment info*/ |
| 47 | size_t notification_size; /**< DVR record nogification size*/ |
| 48 | DVR_RecordEventFunction_t event_notify_fn; /**< DVR record event notify function*/ |
| 49 | void *event_userdata; /**< DVR record event userdata*/ |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 50 | //DVR_VodContext_t vod; /**< DVR record vod context*/ |
| 51 | int is_vod; /**< Indicate current mode is VOD record mode*/ |
pengfei.liu | 27cc4ec | 2020-04-03 16:28:16 +0800 | [diff] [blame] | 52 | DVR_CryptoFunction_t enc_func; /**< Encrypt function*/ |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 53 | void *enc_userdata; /**< Encrypt userdata*/ |
| 54 | int is_secure_mode; /**< Record session run in secure pipeline */ |
hualing chen | 2615aa8 | 2020-04-02 21:32:51 +0800 | [diff] [blame] | 55 | size_t last_send_size; /**< Last send notify segment size */ |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 56 | uint32_t block_size; /**< DVR record block size */ |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 57 | } DVR_RecordContext_t; |
| 58 | |
| 59 | static DVR_RecordContext_t record_ctx[MAX_DVR_RECORD_SESSION_COUNT] = { |
| 60 | { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 61 | .state = DVR_RECORD_STATE_CLOSED |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 62 | }, |
| 63 | { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 64 | .state = DVR_RECORD_STATE_CLOSED |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 65 | } |
| 66 | }; |
| 67 | |
Zhiqiang Han | 51646a0 | 2020-04-05 18:43:22 +0800 | [diff] [blame] | 68 | static int record_is_valid_pid(DVR_RecordContext_t *p_ctx, int pid) |
| 69 | { |
| 70 | int i; |
| 71 | |
| 72 | for (i = 0; i < p_ctx->segment_info.nb_pids; i++) { |
| 73 | if (pid == p_ctx->segment_info.pids[i].pid) |
| 74 | return 1; |
| 75 | } |
| 76 | return 0; |
| 77 | } |
| 78 | |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 79 | static int record_save_pcr(DVR_RecordContext_t *p_ctx, uint8_t *buf, loff_t pos) |
| 80 | { |
| 81 | uint8_t *p = buf; |
| 82 | int len; |
| 83 | uint8_t afc; |
| 84 | uint64_t pcr = 0; |
| 85 | int has_pcr = 0; |
| 86 | int pid; |
| 87 | int adp_field_len; |
| 88 | |
| 89 | pid = ((p[1] & 0x1f) << 8) | p[2]; |
Zhiqiang Han | 51646a0 | 2020-04-05 18:43:22 +0800 | [diff] [blame] | 90 | if (pid == 0x1fff || !record_is_valid_pid(p_ctx, pid)) |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 91 | return has_pcr; |
| 92 | |
| 93 | //scramble = p[3] >> 6; |
| 94 | //cc = p[3] & 0x0f; |
| 95 | afc = (p[3] >> 4) & 0x03; |
| 96 | |
| 97 | p += 4; |
| 98 | len = 184; |
| 99 | |
| 100 | if (afc & 2) { |
| 101 | adp_field_len = p[0]; |
| 102 | /* Skip adaptation len */ |
| 103 | p++; |
| 104 | len--; |
| 105 | /* Parse pcr field, see 13818 spec table I-2-6,adaptation_field */ |
hualing chen | 5605eed | 2020-05-26 18:18:06 +0800 | [diff] [blame] | 106 | if (p[0] & 0x10 && len >= 6 && adp_field_len >= 6) { |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 107 | /* get pcr value,pcr is 33bit value */ |
| 108 | pcr = (((uint64_t)(p[1])) << 25) |
| 109 | | (((uint64_t)p[2]) << 17) |
| 110 | | (((uint64_t)(p[3])) << 9) |
| 111 | | (((uint64_t)p[4]) << 1) |
| 112 | | ((((uint64_t)p[5]) & 0x80) >> 7); |
| 113 | has_pcr = 1; |
| 114 | } |
| 115 | |
| 116 | p += adp_field_len; |
| 117 | len -= adp_field_len; |
| 118 | |
| 119 | if (len < 0) { |
| 120 | DVR_DEBUG(1, "parser pcr: illegal adaptation field length"); |
| 121 | return 0; |
| 122 | } |
| 123 | } |
| 124 | |
| 125 | if (has_pcr) { |
| 126 | segment_update_pts(p_ctx->segment_handle, pcr/90, pos); |
| 127 | } |
| 128 | return has_pcr; |
| 129 | } |
| 130 | |
| 131 | static int record_do_pcr_index(DVR_RecordContext_t *p_ctx, uint8_t *buf, int len) |
| 132 | { |
| 133 | uint8_t *p = buf; |
| 134 | int left = len; |
| 135 | loff_t pos; |
| 136 | int has_pcr = 0; |
| 137 | |
| 138 | pos = segment_tell_position(p_ctx->segment_handle); |
| 139 | while (left >= 188) { |
| 140 | if (*p == 0x47) { |
| 141 | has_pcr |= record_save_pcr(p_ctx, p, pos); |
| 142 | p += 188; |
| 143 | left -= 188; |
| 144 | pos += 188; |
| 145 | } else { |
| 146 | p++; |
| 147 | left --; |
| 148 | pos++; |
| 149 | } |
| 150 | } |
| 151 | return has_pcr; |
| 152 | } |
| 153 | |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 154 | static int get_diff_time(struct timeval start_tv, struct timeval end_tv) |
| 155 | { |
| 156 | return end_tv.tv_sec * 1000 + end_tv.tv_usec / 1000 - start_tv.tv_sec * 1000 - start_tv.tv_usec / 1000; |
| 157 | } |
| 158 | |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 159 | void *record_thread(void *arg) |
| 160 | { |
| 161 | DVR_RecordContext_t *p_ctx = (DVR_RecordContext_t *)arg; |
| 162 | ssize_t len; |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 163 | uint8_t *buf, *buf_out; |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 164 | uint32_t block_size = p_ctx->block_size; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 165 | loff_t pos = 0; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 166 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 167 | struct timespec start_ts, end_ts; |
| 168 | DVR_RecordStatus_t record_status; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 169 | int has_pcr; |
| 170 | int index_type = DVR_INDEX_TYPE_INVALID; |
hualing chen | 87072a8 | 2020-03-12 16:20:12 +0800 | [diff] [blame] | 171 | time_t pre_time = 0; |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 172 | #define DVR_STORE_INFO_TIME (400) |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 173 | DVR_SecureBuffer_t secure_buf; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 174 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 175 | buf = (uint8_t *)malloc(block_size); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 176 | if (!buf) { |
| 177 | DVR_DEBUG(1, "%s, malloc failed", __func__); |
| 178 | return NULL; |
| 179 | } |
| 180 | |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 181 | buf_out = (uint8_t *)malloc(block_size + 188); |
| 182 | if (!buf_out) { |
| 183 | DVR_DEBUG(1, "%s, malloc failed", __func__); |
Pengfei Liu | faf38e4 | 2020-05-22 00:28:02 +0800 | [diff] [blame] | 184 | free(buf); |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 185 | return NULL; |
| 186 | } |
| 187 | |
hualing chen | 266b950 | 2020-04-04 17:39:39 +0800 | [diff] [blame] | 188 | memset(&record_status, 0, sizeof(record_status)); |
| 189 | record_status.state = DVR_RECORD_STATE_STARTED; |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 190 | if (p_ctx->event_notify_fn) { |
hualing chen | 4b7c15d | 2020-04-07 16:13:48 +0800 | [diff] [blame] | 191 | record_status.info.id = p_ctx->segment_info.id; |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 192 | p_ctx->event_notify_fn(DVR_RECORD_EVENT_STATUS, &record_status, p_ctx->event_userdata); |
hualing chen | 4b7c15d | 2020-04-07 16:13:48 +0800 | [diff] [blame] | 193 | DVR_DEBUG(1, "%s line %d notify record status, state:%d id=%lld", |
| 194 | __func__,__LINE__, record_status.state, p_ctx->segment_info.id); |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 195 | } |
| 196 | DVR_DEBUG(1, "%s, secure_mode:%d, block_size:%d", __func__, p_ctx->is_secure_mode, block_size); |
hualing chen | 266b950 | 2020-04-04 17:39:39 +0800 | [diff] [blame] | 197 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 198 | clock_gettime(CLOCK_MONOTONIC, &start_ts); |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 199 | |
| 200 | struct timeval t1, t2, t3, t4, t5, t6, t7; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 201 | while (p_ctx->state == DVR_RECORD_STATE_STARTED) { |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 202 | gettimeofday(&t1, NULL); |
hualing chen | c70a8df | 2020-05-12 19:23:11 +0800 | [diff] [blame] | 203 | |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 204 | /* data from dmx, normal dvr case */ |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 205 | if (p_ctx->is_secure_mode) { |
| 206 | memset(&secure_buf, 0, sizeof(secure_buf)); |
| 207 | len = record_device_read(p_ctx->dev_handle, &secure_buf, sizeof(secure_buf), 1000); |
hualing chen | 266b950 | 2020-04-04 17:39:39 +0800 | [diff] [blame] | 208 | if (len != DVR_FAILURE) { |
| 209 | DVR_DEBUG(1, "%s, secure_buf:%#x, size:%#x", __func__, secure_buf.addr, secure_buf.len); |
| 210 | } |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 211 | } else { |
| 212 | len = record_device_read(p_ctx->dev_handle, buf, block_size, 1000); |
| 213 | } |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 214 | if (len == DVR_FAILURE) { |
hualing chen | 6c12638 | 2020-04-13 15:47:51 +0800 | [diff] [blame] | 215 | //usleep(10*1000); |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 216 | DVR_DEBUG(1, "%s, start_read error", __func__); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 217 | continue; |
| 218 | } |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 219 | gettimeofday(&t2, NULL); |
hualing chen | c70a8df | 2020-05-12 19:23:11 +0800 | [diff] [blame] | 220 | |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 221 | /* Got data from device, record it */ |
| 222 | if (p_ctx->enc_func) { |
| 223 | /* Encrypt record data */ |
pengfei.liu | 27cc4ec | 2020-04-03 16:28:16 +0800 | [diff] [blame] | 224 | DVR_CryptoParams_t crypto_params; |
| 225 | |
| 226 | memset(&crypto_params, 0, sizeof(crypto_params)); |
| 227 | crypto_params.type = DVR_CRYPTO_TYPE_ENCRYPT; |
hualing chen | 7a56cba | 2020-04-14 14:09:27 +0800 | [diff] [blame] | 228 | memcpy(crypto_params.location, p_ctx->location, sizeof(p_ctx->location)); |
pengfei.liu | 27cc4ec | 2020-04-03 16:28:16 +0800 | [diff] [blame] | 229 | crypto_params.segment_id = p_ctx->segment_info.id; |
| 230 | crypto_params.offset = p_ctx->segment_info.size; |
| 231 | |
| 232 | if (p_ctx->is_secure_mode) { |
| 233 | crypto_params.input_buffer.type = DVR_BUFFER_TYPE_SECURE; |
| 234 | crypto_params.input_buffer.addr = secure_buf.addr; |
| 235 | crypto_params.input_buffer.size = secure_buf.len; |
| 236 | } else { |
| 237 | crypto_params.input_buffer.type = DVR_BUFFER_TYPE_NORMAL; |
| 238 | crypto_params.input_buffer.addr = (size_t)buf; |
| 239 | crypto_params.input_buffer.size = len; |
| 240 | } |
| 241 | |
| 242 | crypto_params.output_buffer.type = DVR_BUFFER_TYPE_NORMAL; |
| 243 | crypto_params.output_buffer.addr = (size_t)buf_out; |
| 244 | crypto_params.output_buffer.size = block_size + 188; |
| 245 | |
| 246 | p_ctx->enc_func(&crypto_params, p_ctx->enc_userdata); |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 247 | gettimeofday(&t3, NULL); |
pengfei.liu | 27cc4ec | 2020-04-03 16:28:16 +0800 | [diff] [blame] | 248 | /* Out buffer length may not equal in buffer length */ |
| 249 | ret = segment_write(p_ctx->segment_handle, buf_out, crypto_params.output_size); |
| 250 | len = crypto_params.output_size; |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 251 | } else { |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 252 | gettimeofday(&t3, NULL); |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 253 | ret = segment_write(p_ctx->segment_handle, buf, len); |
| 254 | } |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 255 | gettimeofday(&t4, NULL); |
hualing chen | 626204e | 2020-04-07 11:55:08 +0800 | [diff] [blame] | 256 | //add DVR_RECORD_EVENT_WRITE_ERROR event if write error |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 257 | if (ret == -1 && len > 0 && p_ctx->event_notify_fn) { |
hualing chen | 626204e | 2020-04-07 11:55:08 +0800 | [diff] [blame] | 258 | //send write event |
hualing chen | 9b434f0 | 2020-06-10 15:06:54 +0800 | [diff] [blame] | 259 | if (p_ctx->event_notify_fn) { |
hualing chen | 4b7c15d | 2020-04-07 16:13:48 +0800 | [diff] [blame] | 260 | memset(&record_status, 0, sizeof(record_status)); |
hualing chen | fbf8e02 | 2020-06-15 13:43:11 +0800 | [diff] [blame] | 261 | DVR_DEBUG(1, "%s,send event write error", __func__,__LINE__); |
hualing chen | 4b7c15d | 2020-04-07 16:13:48 +0800 | [diff] [blame] | 262 | p_ctx->event_notify_fn(DVR_RECORD_EVENT_WRITE_ERROR, &record_status, p_ctx->event_userdata); |
| 263 | } |
hualing chen | c70a8df | 2020-05-12 19:23:11 +0800 | [diff] [blame] | 264 | DVR_DEBUG(1, "%s,write error %d", __func__,__LINE__); |
hualing chen | 626204e | 2020-04-07 11:55:08 +0800 | [diff] [blame] | 265 | goto end; |
| 266 | } |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 267 | /* Do time index */ |
| 268 | uint8_t *index_buf = p_ctx->enc_func ? buf_out : buf; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 269 | pos = segment_tell_position(p_ctx->segment_handle); |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 270 | has_pcr = record_do_pcr_index(p_ctx, index_buf, len); |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 271 | if (has_pcr == 0 && index_type == DVR_INDEX_TYPE_INVALID) { |
| 272 | clock_gettime(CLOCK_MONOTONIC, &end_ts); |
| 273 | if ((end_ts.tv_sec*1000 + end_ts.tv_nsec/1000000) - |
| 274 | (start_ts.tv_sec*1000 + start_ts.tv_nsec/1000000) > 40) { |
| 275 | /* PCR interval threshlod > 40 ms*/ |
| 276 | DVR_DEBUG(1, "%s use local clock time index", __func__); |
| 277 | index_type = DVR_INDEX_TYPE_LOCAL_CLOCK; |
| 278 | } |
| 279 | } else if (has_pcr && index_type == DVR_INDEX_TYPE_INVALID){ |
| 280 | DVR_DEBUG(1, "%s use pcr time index", __func__); |
| 281 | index_type = DVR_INDEX_TYPE_PCR; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 282 | } |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 283 | gettimeofday(&t5, NULL); |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 284 | |
| 285 | /* Update segment info */ |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 286 | p_ctx->segment_info.size += len; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 287 | /*Duration need use pcr to calculate, todo...*/ |
| 288 | if (index_type == DVR_INDEX_TYPE_PCR) { |
pengfei.liu | 8b56329 | 2020-02-26 15:49:02 +0800 | [diff] [blame] | 289 | p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle); |
hualing chen | 87072a8 | 2020-03-12 16:20:12 +0800 | [diff] [blame] | 290 | if (pre_time == 0) |
| 291 | pre_time = p_ctx->segment_info.duration; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 292 | } else if (index_type == DVR_INDEX_TYPE_LOCAL_CLOCK) { |
| 293 | clock_gettime(CLOCK_MONOTONIC, &end_ts); |
| 294 | p_ctx->segment_info.duration = (end_ts.tv_sec*1000 + end_ts.tv_nsec/1000000) - |
| 295 | (start_ts.tv_sec*1000 + start_ts.tv_nsec/1000000); |
hualing chen | 87072a8 | 2020-03-12 16:20:12 +0800 | [diff] [blame] | 296 | if (pre_time == 0) |
| 297 | pre_time = p_ctx->segment_info.duration; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 298 | segment_update_pts(p_ctx->segment_handle, p_ctx->segment_info.duration, pos); |
| 299 | } else { |
| 300 | DVR_DEBUG(1, "%s can NOT do time index", __func__); |
| 301 | } |
| 302 | p_ctx->segment_info.nb_packets = p_ctx->segment_info.size/188; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 303 | |
hualing chen | 87072a8 | 2020-03-12 16:20:12 +0800 | [diff] [blame] | 304 | if (p_ctx->segment_info.duration - pre_time > DVR_STORE_INFO_TIME) { |
| 305 | pre_time = p_ctx->segment_info.duration + DVR_STORE_INFO_TIME; |
hualing chen | c70a8df | 2020-05-12 19:23:11 +0800 | [diff] [blame] | 306 | segment_store_info(p_ctx->segment_handle, &(p_ctx->segment_info)); |
hualing chen | 87072a8 | 2020-03-12 16:20:12 +0800 | [diff] [blame] | 307 | } |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 308 | gettimeofday(&t6, NULL); |
hualing chen | 87072a8 | 2020-03-12 16:20:12 +0800 | [diff] [blame] | 309 | /*Event notification*/ |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 310 | if (p_ctx->notification_size && |
| 311 | p_ctx->event_notify_fn && |
hualing chen | 2615aa8 | 2020-04-02 21:32:51 +0800 | [diff] [blame] | 312 | /*!(p_ctx->segment_info.size % p_ctx->notification_size)*/ |
| 313 | (p_ctx->segment_info.size -p_ctx->last_send_size) >= p_ctx->notification_size&& |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 314 | p_ctx->segment_info.duration > 0) { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 315 | memset(&record_status, 0, sizeof(record_status)); |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 316 | //clock_gettime(CLOCK_MONOTONIC, &end_ts); |
hualing chen | 2615aa8 | 2020-04-02 21:32:51 +0800 | [diff] [blame] | 317 | p_ctx->last_send_size = p_ctx->segment_info.size; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 318 | record_status.state = p_ctx->state; |
| 319 | record_status.info.id = p_ctx->segment_info.id; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 320 | record_status.info.duration = p_ctx->segment_info.duration; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 321 | record_status.info.size = p_ctx->segment_info.size; |
| 322 | record_status.info.nb_packets = p_ctx->segment_info.size/188; |
| 323 | p_ctx->event_notify_fn(DVR_RECORD_EVENT_STATUS, &record_status, p_ctx->event_userdata); |
| 324 | DVR_DEBUG(1, "%s notify record status, state:%d, id:%lld, duration:%ld ms, size:%zu", |
| 325 | __func__, record_status.state, record_status.info.id, record_status.info.duration, record_status.info.size); |
| 326 | } |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 327 | gettimeofday(&t7, NULL); |
| 328 | #ifdef DEBUG_PERFORMANCE |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 329 | DVR_DEBUG(1, "record count, read:%dms, encrypt:%dms, write:%dms, index:%dms, store:%dms, notify:%dms total:%dms read len:%zd ", |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 330 | get_diff_time(t1, t2), get_diff_time(t2, t3), get_diff_time(t3, t4), get_diff_time(t4, t5), |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 331 | get_diff_time(t5, t6), get_diff_time(t6, t7), get_diff_time(t1, t5), len); |
pengfei.liu | 567d6d8 | 2020-04-17 16:48:59 +0800 | [diff] [blame] | 332 | #endif |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 333 | } |
hualing chen | 626204e | 2020-04-07 11:55:08 +0800 | [diff] [blame] | 334 | end: |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 335 | free((void *)buf); |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 336 | free((void *)buf_out); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 337 | DVR_DEBUG(1, "exit %s", __func__); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 338 | return NULL; |
| 339 | } |
| 340 | |
| 341 | int dvr_record_open(DVR_RecordHandle_t *p_handle, DVR_RecordOpenParams_t *params) |
| 342 | { |
| 343 | DVR_RecordContext_t *p_ctx; |
| 344 | Record_DeviceOpenParams_t dev_open_params; |
| 345 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 346 | uint32_t i; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 347 | |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 348 | DVR_RETURN_IF_FALSE(p_handle); |
| 349 | DVR_RETURN_IF_FALSE(params); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 350 | |
| 351 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 352 | if (record_ctx[i].state == DVR_RECORD_STATE_CLOSED) { |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 353 | break; |
| 354 | } |
| 355 | } |
Pengfei Liu | faf38e4 | 2020-05-22 00:28:02 +0800 | [diff] [blame] | 356 | DVR_RETURN_IF_FALSE(i < MAX_DVR_RECORD_SESSION_COUNT); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 357 | DVR_RETURN_IF_FALSE(record_ctx[i].state == DVR_RECORD_STATE_CLOSED); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 358 | p_ctx = &record_ctx[i]; |
hualing chen | fbf8e02 | 2020-06-15 13:43:11 +0800 | [diff] [blame] | 359 | DVR_DEBUG(1, "%s , current state:%d, dmx_id:%d, notification_size:%zu ", __func__, |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 360 | p_ctx->state, params->dmx_dev_id, params->notification_size); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 361 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 362 | /*Process event params*/ |
| 363 | p_ctx->notification_size = params->notification_size; |
| 364 | p_ctx->event_notify_fn = params->event_fn; |
| 365 | p_ctx->event_userdata = params->event_userdata; |
hualing chen | 2615aa8 | 2020-04-02 21:32:51 +0800 | [diff] [blame] | 366 | p_ctx->last_send_size = 0; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 367 | /*Process crypto params, todo*/ |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 368 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 369 | memset((void *)&dev_open_params, 0, sizeof(dev_open_params)); |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 370 | if (params->data_from_memory) { |
| 371 | /* data from memory, VOD case */ |
| 372 | p_ctx->is_vod = 1; |
| 373 | } else { |
| 374 | p_ctx->is_vod = 0; |
| 375 | /* data from dmx, normal dvr case */ |
hualing chen | 958fe4c | 2020-03-24 17:35:07 +0800 | [diff] [blame] | 376 | dev_open_params.dmx_dev_id = params->dmx_dev_id; |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 377 | dev_open_params.buf_size = (params->flush_size > 0 ? params->flush_size : RECORD_BLOCK_SIZE); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 378 | |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 379 | ret = record_device_open(&p_ctx->dev_handle, &dev_open_params); |
| 380 | if (ret != DVR_SUCCESS) { |
| 381 | DVR_DEBUG(1, "%s, open record devices failed", __func__); |
| 382 | return DVR_FAILURE; |
| 383 | } |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 384 | } |
| 385 | |
pengfei.liu | fda2a97 | 2020-04-09 14:47:15 +0800 | [diff] [blame] | 386 | p_ctx->block_size = (params->flush_size > 0 ? params->flush_size : RECORD_BLOCK_SIZE); |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 387 | p_ctx->enc_func = NULL; |
| 388 | p_ctx->enc_userdata = NULL; |
| 389 | p_ctx->is_secure_mode = 0; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 390 | p_ctx->state = DVR_RECORD_STATE_OPENED; |
| 391 | |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 392 | *p_handle = p_ctx; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 393 | return DVR_SUCCESS; |
| 394 | } |
| 395 | |
| 396 | int dvr_record_close(DVR_RecordHandle_t handle) |
| 397 | { |
| 398 | DVR_RecordContext_t *p_ctx; |
| 399 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 400 | uint32_t i; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 401 | |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 402 | p_ctx = (DVR_RecordContext_t *)handle; |
| 403 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 404 | if (p_ctx == &record_ctx[i]) |
| 405 | break; |
| 406 | } |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 407 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 408 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 409 | DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 410 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 411 | |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 412 | if (p_ctx->is_vod) { |
| 413 | ret = DVR_SUCCESS; |
| 414 | } else { |
| 415 | ret = record_device_close(p_ctx->dev_handle); |
| 416 | if (ret != DVR_SUCCESS) { |
| 417 | DVR_DEBUG(1, "%s, failed", __func__); |
| 418 | } |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 419 | } |
| 420 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 421 | p_ctx->state = DVR_RECORD_STATE_CLOSED; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 422 | return ret; |
| 423 | } |
| 424 | |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 425 | #if 0 |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 426 | int dvr_record_register_encryption(DVR_RecordHandle_t handle, |
| 427 | DVR_CryptoFunction_t cb, |
| 428 | DVR_CryptoParams_t params, |
| 429 | void *userdata) |
| 430 | { |
| 431 | return DVR_SUCCESS; |
| 432 | } |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 433 | #endif |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 434 | |
| 435 | int dvr_record_start_segment(DVR_RecordHandle_t handle, DVR_RecordStartParams_t *params) |
| 436 | { |
| 437 | DVR_RecordContext_t *p_ctx; |
| 438 | Segment_OpenParams_t open_params; |
| 439 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 440 | uint32_t i; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 441 | |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 442 | p_ctx = (DVR_RecordContext_t *)handle; |
| 443 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 444 | if (p_ctx == &record_ctx[i]) |
| 445 | break; |
| 446 | } |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 447 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 448 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 449 | DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 450 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STARTED); |
| 451 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED); |
| 452 | DVR_RETURN_IF_FALSE(params); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 453 | |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 454 | DVR_RETURN_IF_FALSE(strlen((const char *)params->location) < DVR_MAX_LOCATION_SIZE); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 455 | memset(&open_params, 0, sizeof(open_params)); |
hualing chen | 7a56cba | 2020-04-14 14:09:27 +0800 | [diff] [blame] | 456 | memcpy(open_params.location, params->location, sizeof(params->location)); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 457 | open_params.segment_id = params->segment.segment_id; |
| 458 | open_params.mode = SEGMENT_MODE_WRITE; |
| 459 | |
| 460 | ret = segment_open(&open_params, &p_ctx->segment_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 461 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 462 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 463 | /*process params*/ |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 464 | { |
hualing chen | 7a56cba | 2020-04-14 14:09:27 +0800 | [diff] [blame] | 465 | memcpy(p_ctx->location, params->location, sizeof(params->location)); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 466 | //need all params?? |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 467 | memcpy(&p_ctx->segment_params, ¶ms->segment, sizeof(params->segment)); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 468 | /*save current segment info*/ |
| 469 | memset(&p_ctx->segment_info, 0, sizeof(p_ctx->segment_info)); |
| 470 | p_ctx->segment_info.id = params->segment.segment_id; |
| 471 | p_ctx->segment_info.nb_pids = params->segment.nb_pids; |
| 472 | memcpy(p_ctx->segment_info.pids, params->segment.pids, params->segment.nb_pids*sizeof(DVR_StreamPid_t)); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 473 | } |
| 474 | |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 475 | if (!p_ctx->is_vod) { |
| 476 | /* normal dvr case */ |
| 477 | for (i = 0; i < params->segment.nb_pids; i++) { |
| 478 | ret = record_device_add_pid(p_ctx->dev_handle, params->segment.pids[i].pid); |
| 479 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
| 480 | } |
| 481 | ret = record_device_start(p_ctx->dev_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 482 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 483 | } |
| 484 | |
Zhiqiang Han | 5ebad99 | 2020-04-28 18:19:59 +0800 | [diff] [blame] | 485 | ret = segment_store_info(p_ctx->segment_handle, &p_ctx->segment_info); |
| 486 | |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 487 | p_ctx->state = DVR_RECORD_STATE_STARTED; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 488 | if (!p_ctx->is_vod) |
| 489 | pthread_create(&p_ctx->thread, NULL, record_thread, p_ctx); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 490 | |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 491 | return DVR_SUCCESS; |
| 492 | } |
| 493 | |
| 494 | int dvr_record_next_segment(DVR_RecordHandle_t handle, DVR_RecordStartParams_t *params, DVR_RecordSegmentInfo_t *p_info) |
| 495 | { |
| 496 | DVR_RecordContext_t *p_ctx; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 497 | Segment_OpenParams_t open_params; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 498 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 499 | uint32_t i; |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 500 | loff_t pos; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 501 | |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 502 | p_ctx = (DVR_RecordContext_t *)handle; |
| 503 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 504 | if (p_ctx == &record_ctx[i]) |
| 505 | break; |
| 506 | } |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 507 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 508 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 509 | DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 510 | DVR_RETURN_IF_FALSE(p_ctx->state == DVR_RECORD_STATE_STARTED); |
| 511 | //DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED); |
| 512 | DVR_RETURN_IF_FALSE(params); |
| 513 | DVR_RETURN_IF_FALSE(p_info); |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 514 | DVR_RETURN_IF_FALSE(!p_ctx->is_vod); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 515 | |
| 516 | /*Stop the on going record segment*/ |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 517 | //ret = record_device_stop(p_ctx->dev_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 518 | //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 519 | p_ctx->state = DVR_RECORD_STATE_STOPPED; |
| 520 | pthread_join(p_ctx->thread, NULL); |
| 521 | |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 522 | //add index file store |
| 523 | pos = segment_tell_position(p_ctx->segment_handle); |
| 524 | segment_update_pts_force(p_ctx->segment_handle, p_ctx->segment_info.duration, pos); |
| 525 | |
| 526 | p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 527 | /*Update segment info*/ |
| 528 | memcpy(p_info, &p_ctx->segment_info, sizeof(p_ctx->segment_info)); |
| 529 | |
| 530 | ret = segment_store_info(p_ctx->segment_handle, p_info); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 531 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 532 | |
hualing chen | a540a7e | 2020-03-27 16:44:05 +0800 | [diff] [blame] | 533 | 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", |
| 534 | __func__, p_info->id, p_info->nb_pids, p_info->duration, p_info->size, p_info->nb_packets, params->segment.nb_pids); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 535 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 536 | /*Close current segment*/ |
| 537 | ret = segment_close(p_ctx->segment_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 538 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 539 | /*Open the new record segment*/ |
| 540 | memset(&open_params, 0, sizeof(open_params)); |
hualing chen | 7a56cba | 2020-04-14 14:09:27 +0800 | [diff] [blame] | 541 | memcpy(open_params.location, p_ctx->location, sizeof(p_ctx->location)); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 542 | open_params.segment_id = params->segment.segment_id; |
| 543 | open_params.mode = SEGMENT_MODE_WRITE; |
hualing chen | 7a56cba | 2020-04-14 14:09:27 +0800 | [diff] [blame] | 544 | DVR_DEBUG(1, "%s: p_ctx->location:%s params->location:%s", __func__, p_ctx->location,params->location); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 545 | |
| 546 | ret = segment_open(&open_params, &p_ctx->segment_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 547 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 548 | /*process params*/ |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 549 | { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 550 | //need all params?? |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 551 | memcpy(&p_ctx->segment_params, ¶ms->segment, sizeof(params->segment)); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 552 | /*save current segment info*/ |
| 553 | memset(&p_ctx->segment_info, 0, sizeof(p_ctx->segment_info)); |
| 554 | p_ctx->segment_info.id = params->segment.segment_id; |
| 555 | memcpy(p_ctx->segment_info.pids, params->segment.pids, params->segment.nb_pids*sizeof(DVR_StreamPid_t)); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 556 | } |
| 557 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 558 | p_ctx->segment_info.nb_pids = 0; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 559 | for (i = 0; i < params->segment.nb_pids; i++) { |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 560 | switch (params->segment.pid_action[i]) { |
| 561 | case DVR_RECORD_PID_CREATE: |
| 562 | DVR_DEBUG(1, "%s create pid:%d", __func__, params->segment.pids[i].pid); |
| 563 | ret = record_device_add_pid(p_ctx->dev_handle, params->segment.pids[i].pid); |
| 564 | p_ctx->segment_info.nb_pids++; |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 565 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 566 | break; |
| 567 | case DVR_RECORD_PID_KEEP: |
| 568 | DVR_DEBUG(1, "%s keep pid:%d", __func__, params->segment.pids[i].pid); |
| 569 | p_ctx->segment_info.nb_pids++; |
| 570 | break; |
| 571 | case DVR_RECORD_PID_CLOSE: |
| 572 | DVR_DEBUG(1, "%s close pid:%d", __func__, params->segment.pids[i].pid); |
| 573 | ret = record_device_remove_pid(p_ctx->dev_handle, params->segment.pids[i].pid); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 574 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 575 | break; |
| 576 | default: |
| 577 | DVR_DEBUG(1, "%s wrong action pid:%d", __func__, params->segment.pids[i].pid); |
| 578 | return DVR_FAILURE; |
| 579 | } |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 580 | } |
| 581 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 582 | //ret = record_device_start(p_ctx->dev_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 583 | //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
hualing chen | 4b7c15d | 2020-04-07 16:13:48 +0800 | [diff] [blame] | 584 | /*Update segment info*/ |
| 585 | ret = segment_store_info(p_ctx->segment_handle, &p_ctx->segment_info); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 586 | |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 587 | p_ctx->state = DVR_RECORD_STATE_STARTED; |
Zhiqiang Han | 0d60f2b | 2020-05-26 14:39:54 +0800 | [diff] [blame] | 588 | pthread_create(&p_ctx->thread, NULL, record_thread, p_ctx); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 589 | return DVR_SUCCESS; |
| 590 | } |
| 591 | |
| 592 | int dvr_record_stop_segment(DVR_RecordHandle_t handle, DVR_RecordSegmentInfo_t *p_info) |
| 593 | { |
| 594 | DVR_RecordContext_t *p_ctx; |
| 595 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 596 | uint32_t i; |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 597 | loff_t pos; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 598 | |
Pengfei Liu | 47ed6c9 | 2020-01-17 11:23:41 +0800 | [diff] [blame] | 599 | p_ctx = (DVR_RecordContext_t *)handle; |
| 600 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 601 | if (p_ctx == &record_ctx[i]) |
| 602 | break; |
| 603 | } |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 604 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 605 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 606 | DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 607 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STOPPED); |
| 608 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED); |
Zhiqiang Han | 2d8cd82 | 2020-03-16 13:58:10 +0800 | [diff] [blame] | 609 | DVR_RETURN_IF_FALSE(p_info);/*should support NULL*/ |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 610 | |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 611 | p_ctx->state = DVR_RECORD_STATE_STOPPED; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 612 | if (p_ctx->is_vod) { |
pengfei.liu | 8b56329 | 2020-02-26 15:49:02 +0800 | [diff] [blame] | 613 | p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle); |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 614 | p_ctx->segment_info.duration = 10*1000; //debug, should delete it |
| 615 | } else { |
| 616 | ret = record_device_stop(p_ctx->dev_handle); |
Zhiqiang Han | 5c805cf | 2020-05-09 16:51:08 +0800 | [diff] [blame] | 617 | //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
| 618 | if (ret != DVR_SUCCESS) |
| 619 | goto end; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 620 | //p_ctx->state = DVR_RECORD_STATE_STOPPED; |
| 621 | pthread_join(p_ctx->thread, NULL); |
| 622 | } |
| 623 | |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 624 | //add index file store |
| 625 | pos = segment_tell_position(p_ctx->segment_handle); |
| 626 | segment_update_pts_force(p_ctx->segment_handle, p_ctx->segment_info.duration, pos); |
hualing chen | e41f437 | 2020-06-06 16:29:17 +0800 | [diff] [blame] | 627 | p_ctx->segment_info.duration = segment_tell_total_time(p_ctx->segment_handle); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 628 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 629 | /*Update segment info*/ |
| 630 | memcpy(p_info, &p_ctx->segment_info, sizeof(p_ctx->segment_info)); |
| 631 | |
| 632 | ret = segment_store_info(p_ctx->segment_handle, p_info); |
Zhiqiang Han | 5c805cf | 2020-05-09 16:51:08 +0800 | [diff] [blame] | 633 | //DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
| 634 | if (ret != DVR_SUCCESS) |
| 635 | goto end; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 636 | |
| 637 | DVR_DEBUG(1, "%s dump segment info, id:%lld, nb_pids:%d, duration:%ld ms, size:%zu, nb_packets:%d", |
| 638 | __func__, p_info->id, p_info->nb_pids, p_info->duration, p_info->size, p_info->nb_packets); |
| 639 | |
Zhiqiang Han | 5c805cf | 2020-05-09 16:51:08 +0800 | [diff] [blame] | 640 | end: |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 641 | ret = segment_close(p_ctx->segment_handle); |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 642 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 643 | return DVR_SUCCESS; |
| 644 | } |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 645 | |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 646 | int dvr_record_resume_segment(DVR_RecordHandle_t handle, DVR_RecordStartParams_t *params, uint64_t *p_resume_size) |
| 647 | { |
| 648 | DVR_RecordContext_t *p_ctx; |
| 649 | uint32_t i; |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 650 | int ret; |
Pengfei Liu | b473423 | 2020-01-17 18:25:10 +0800 | [diff] [blame] | 651 | |
| 652 | p_ctx = (DVR_RecordContext_t *)handle; |
| 653 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 654 | if (p_ctx == &record_ctx[i]) |
| 655 | break; |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 656 | } |
Pengfei Liu | 3b1a820 | 2020-02-12 23:04:21 +0800 | [diff] [blame] | 657 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
| 658 | DVR_RETURN_IF_FALSE(params); |
| 659 | DVR_RETURN_IF_FALSE(p_resume_size); |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 660 | |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 661 | DVR_DEBUG(1, "%s , current state:%d, resume size:%lld", __func__, p_ctx->state, *p_resume_size); |
| 662 | ret = dvr_record_start_segment(handle, params); |
| 663 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
| 664 | |
| 665 | p_ctx->segment_info.size = *p_resume_size; |
| 666 | |
| 667 | return DVR_SUCCESS; |
| 668 | } |
| 669 | |
| 670 | int dvr_record_get_status(DVR_RecordHandle_t handle, DVR_RecordStatus_t *p_status) |
| 671 | { |
| 672 | DVR_RecordContext_t *p_ctx; |
| 673 | int i; |
| 674 | |
| 675 | p_ctx = (DVR_RecordContext_t *)handle; |
| 676 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 677 | if (p_ctx == &record_ctx[i]) |
| 678 | break; |
| 679 | } |
| 680 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
| 681 | DVR_RETURN_IF_FALSE(p_status); |
| 682 | |
| 683 | //lock |
| 684 | p_status->state = p_ctx->state; |
| 685 | p_status->info.id = p_ctx->segment_info.id; |
| 686 | p_status->info.duration = p_ctx->segment_info.duration; |
| 687 | p_status->info.size = p_ctx->segment_info.size; |
| 688 | p_status->info.nb_packets = p_ctx->segment_info.size/188; |
| 689 | |
| 690 | return DVR_SUCCESS; |
| 691 | } |
| 692 | |
| 693 | int dvr_record_write(DVR_RecordHandle_t handle, void *buffer, uint32_t len) |
| 694 | { |
| 695 | DVR_RecordContext_t *p_ctx; |
| 696 | uint32_t i; |
| 697 | off_t pos = 0; |
| 698 | int ret; |
| 699 | int has_pcr; |
| 700 | |
| 701 | p_ctx = (DVR_RecordContext_t *)handle; |
| 702 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 703 | if (p_ctx == &record_ctx[i]) |
| 704 | break; |
| 705 | } |
| 706 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
| 707 | DVR_RETURN_IF_FALSE(buffer); |
| 708 | DVR_RETURN_IF_FALSE(len); |
| 709 | |
| 710 | pos = segment_tell_position(p_ctx->segment_handle); |
| 711 | has_pcr = record_do_pcr_index(p_ctx, buffer, len); |
| 712 | if (has_pcr == 0) { |
| 713 | /* Pull VOD record shoud use PCR time index */ |
| 714 | DVR_DEBUG(1, "%s has no pcr, can NOT do time index", __func__); |
| 715 | } |
| 716 | ret = segment_write(p_ctx->segment_handle, buffer, len); |
hualing chen | 2932d37 | 2020-04-29 13:44:00 +0800 | [diff] [blame] | 717 | if (ret != len) { |
| 718 | DVR_DEBUG(1, "%s write error ret:%d len:%d", __func__, ret, len); |
| 719 | } |
pengfei.liu | ab5a226 | 2020-02-14 17:33:40 +0800 | [diff] [blame] | 720 | p_ctx->segment_info.size += len; |
| 721 | p_ctx->segment_info.nb_packets = p_ctx->segment_info.size/188; |
| 722 | |
Pengfei Liu | c181a98 | 2020-01-07 19:27:13 +0800 | [diff] [blame] | 723 | return DVR_SUCCESS; |
| 724 | } |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 725 | |
pengfei.liu | 27cc4ec | 2020-04-03 16:28:16 +0800 | [diff] [blame] | 726 | int dvr_record_set_encrypt_callback(DVR_RecordHandle_t handle, DVR_CryptoFunction_t func, void *userdata) |
pengfei.liu | 07ddc8a | 2020-03-24 23:36:53 +0800 | [diff] [blame] | 727 | { |
| 728 | DVR_RecordContext_t *p_ctx; |
| 729 | uint32_t i; |
| 730 | |
| 731 | p_ctx = (DVR_RecordContext_t *)handle; |
| 732 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 733 | if (p_ctx == &record_ctx[i]) |
| 734 | break; |
| 735 | } |
| 736 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
| 737 | DVR_RETURN_IF_FALSE(func); |
| 738 | |
| 739 | DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state); |
| 740 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STARTED); |
| 741 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED); |
| 742 | |
| 743 | p_ctx->enc_func = func; |
| 744 | p_ctx->enc_userdata = userdata; |
| 745 | return DVR_SUCCESS; |
| 746 | } |
| 747 | |
| 748 | int dvr_record_set_secure_buffer(DVR_RecordHandle_t handle, uint8_t *p_secure_buf, uint32_t len) |
| 749 | { |
| 750 | DVR_RecordContext_t *p_ctx; |
| 751 | uint32_t i; |
| 752 | int ret; |
| 753 | |
| 754 | p_ctx = (DVR_RecordContext_t *)handle; |
| 755 | for (i = 0; i < MAX_DVR_RECORD_SESSION_COUNT; i++) { |
| 756 | if (p_ctx == &record_ctx[i]) |
| 757 | break; |
| 758 | } |
| 759 | DVR_RETURN_IF_FALSE(p_ctx == &record_ctx[i]); |
| 760 | DVR_RETURN_IF_FALSE(p_secure_buf); |
| 761 | DVR_RETURN_IF_FALSE(len); |
| 762 | |
| 763 | DVR_DEBUG(1, "%s , current state:%d", __func__, p_ctx->state); |
| 764 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_STARTED); |
| 765 | DVR_RETURN_IF_FALSE(p_ctx->state != DVR_RECORD_STATE_CLOSED); |
| 766 | |
| 767 | ret = record_device_set_secure_buffer(p_ctx->dev_handle, p_secure_buf, len); |
| 768 | DVR_RETURN_IF_FALSE(ret == DVR_SUCCESS); |
| 769 | |
| 770 | p_ctx->is_secure_mode = 1; |
| 771 | return ret; |
| 772 | } |