blob: 3caf0a66bb6b937be2f96b38710f84f4197f5e43 [file] [log] [blame]
hualing chenb31a6c62020-01-13 17:27:00 +08001#include <stdio.h>
2#include <stdlib.h>
3
hualing chen5cbe1a62020-02-10 16:36:36 +08004#include <string.h>
hualing chenb31a6c62020-01-13 17:27:00 +08005#include <sys/types.h>
6#include <sys/stat.h>
7#include <sys/ioctl.h>
Wentao MA361eaac2023-03-21 13:12:28 +08008#include <sys/prctl.h>
hualing chenb31a6c62020-01-13 17:27:00 +08009#include <fcntl.h>
10#include <unistd.h>
11#include <poll.h>
12#include <errno.h>
13#include <signal.h>
14#include <pthread.h>
hualing chenb5cd42e2020-04-15 17:03:34 +080015#include <errno.h>
hualing chen03fd4942021-07-15 15:56:41 +080016#include "dvr_utils.h"
17#include "dvr_types.h"
hualing chenb31a6c62020-01-13 17:27:00 +080018#include "dvr_playback.h"
Yahui Han1fbf3292021-11-08 18:17:19 +080019#include "am_crypt.h"
hualing chenb31a6c62020-01-13 17:27:00 +080020
Wentao MA96f68962022-06-15 19:45:35 +080021#define PB_LOG_TAG "libdvr-playback"
22#define DVR_PB_DEBUG(...) DVR_LOG_PRINT(LOG_LV_DEBUG, PB_LOG_TAG, __VA_ARGS__)
23#define DVR_PB_INFO(...) DVR_LOG_PRINT(LOG_LV_INFO, PB_LOG_TAG, __VA_ARGS__)
24#define DVR_PB_WARN(...) DVR_LOG_PRINT(LOG_LV_WARN, PB_LOG_TAG, __VA_ARGS__)
25#define DVR_PB_ERROR(...) DVR_LOG_PRINT(LOG_LV_ERROR, PB_LOG_TAG, __VA_ARGS__)
26#define DVR_PB_FATAL(...) DVR_LOG_PRINT(LOG_LV_FATAL, PB_LOG_TAG, __VA_ARGS__)
hualing chena540a7e2020-03-27 16:44:05 +080027
hualing chenb31a6c62020-01-13 17:27:00 +080028#define VALID_PID(_pid_) ((_pid_)>0 && (_pid_)<0x1fff)
hualing chena540a7e2020-03-27 16:44:05 +080029
hualing chena540a7e2020-03-27 16:44:05 +080030#define FF_SPEED (2.0f)
31#define FB_SPEED (-1.0f)
32#define IS_FFFB(_SPEED_) ((_SPEED_) > FF_SPEED && (_SPEED_) < FB_SPEED)
hualing chene41f4372020-06-06 16:29:17 +080033#define IS_FB(_SPEED_) ((_SPEED_) <= FB_SPEED)
hualing chena540a7e2020-03-27 16:44:05 +080034
35#define IS_KERNEL_SPEED(_SPEED_) (((_SPEED_) == PLAYBACK_SPEED_X2) || ((_SPEED_) == PLAYBACK_SPEED_X1) || ((_SPEED_) == PLAYBACK_SPEED_S2) || ((_SPEED_) == PLAYBACK_SPEED_S4) || ((_SPEED_) == PLAYBACK_SPEED_S8))
36#define IS_FAST_SPEED(_SPEED_) (((_SPEED_) == PLAYBACK_SPEED_X2) || ((_SPEED_) == PLAYBACK_SPEED_S2) || ((_SPEED_) == PLAYBACK_SPEED_S4) || ((_SPEED_) == PLAYBACK_SPEED_S8))
37
Wentao MA907b6432022-08-01 06:23:08 +000038#define DVR_PLAYER_CHANGE_STATE(player,newstate)\
39 DVR_PB_INFO("%s:%d player %p changes state from %s to %s",__func__,__LINE__,\
40 player,_dvr_playback_state_toString(player->state),_dvr_playback_state_toString(newstate));\
41 player->state=newstate;
42
Wentao MA75775d22023-09-25 16:53:24 +080043//#define FOR_SKYWORTH_FETCH_RDK
hualing chenb31a6c62020-01-13 17:27:00 +080044
hualing chenb5cd42e2020-04-15 17:03:34 +080045#define FFFB_SLEEP_TIME (1000)//500ms
hualing chene41f4372020-06-06 16:29:17 +080046#define FB_DEFAULT_LEFT_TIME (3000)
hualing chen31140872020-03-25 12:29:26 +080047//if tsplayer delay time < 200 and no data can read, we will pause
48#define MIN_TSPLAYER_DELAY_TIME (200)
49
hualing chen041c4092020-04-05 15:11:50 +080050#define MAX_CACHE_TIME (30000)
hualing chen43a89bc2022-01-19 14:31:20 +080051//used pcr to control avsync,default not used
52//#define AVSYNC_USED_PCR 1
hualing chena540a7e2020-03-27 16:44:05 +080053static int write_success = 0;
hualing chen5cbe1a62020-02-10 16:36:36 +080054//
55static int _dvr_playback_fffb(DVR_PlaybackHandle_t handle);
Wentao MA6dcdc342023-01-30 17:03:19 +080056static int _do_handle_pid_update(DVR_PlaybackHandle_t handle, DVR_PlaybackPids_t now_pids, DVR_PlaybackPids_t pids, int type);
hualing chencc91e1c2020-02-28 13:26:17 +080057static int _dvr_get_cur_time(DVR_PlaybackHandle_t handle);
58static int _dvr_get_end_time(DVR_PlaybackHandle_t handle);
hualing chen2aba4022020-03-02 13:49:55 +080059static int _dvr_playback_calculate_seekpos(DVR_PlaybackHandle_t handle);
hualing chen87072a82020-03-12 16:20:12 +080060static int _dvr_playback_replay(DVR_PlaybackHandle_t handle, DVR_Bool_t trick) ;
hualing chen2932d372020-04-29 13:44:00 +080061static int _dvr_playback_get_status(DVR_PlaybackHandle_t handle,
62 DVR_PlaybackStatus_t *p_status, DVR_Bool_t is_lock);
hualing chene41f4372020-06-06 16:29:17 +080063static int _dvr_playback_sent_transition_ok(DVR_PlaybackHandle_t handle, DVR_Bool_t is_lock);
hualing chen7ea70a72021-09-09 11:25:13 +080064static uint32_t dvr_playback_calculate_last_valid_segment(
65 DVR_PlaybackHandle_t handle, uint64_t *segmentid, uint32_t *pos);
Wentao MA804bab12022-11-29 10:01:26 +080066static int get_effective_tsplayer_delay_time(DVR_Playback_t* playback, int *time);
Wentao MA92a14892023-09-12 18:54:47 +080067static int _dvr_get_play_cur_time(DVR_PlaybackHandle_t handle, uint64_t *id);
hualing chen87072a82020-03-12 16:20:12 +080068
hualing chenbcada022020-04-22 14:27:01 +080069
hualing chena5f03222021-12-02 11:22:35 +080070
hualing chenbcada022020-04-22 14:27:01 +080071static char* _cmd_toString(int cmd)
72{
73
74 char *string[DVR_PLAYBACK_CMD_NONE+1]={
75 "start",
76 "stop",
Wentao MA270dc0f2022-08-23 13:17:26 +080077 "v_start",
78 "a_start",
79 "v_stop",
80 "a_stop",
81 "v_restart",
82 "a_restart",
83 "av_restart",
84 "v_stop_a_start",
85 "a_stop_v_start",
86 "v_stop_a_restart",
87 "a_stop_v_restart",
88 "v_start_a_restart",
89 "a_start_v_restart",
hualing chenbcada022020-04-22 14:27:01 +080090 "pause",
91 "resume",
92 "seek",
93 "ff",
94 "fb",
95 "NONE"
96 };
97
98 if (cmd > DVR_PLAYBACK_CMD_NONE) {
Wentao MA270dc0f2022-08-23 13:17:26 +080099 return "unknown";
hualing chenbcada022020-04-22 14:27:01 +0800100 } else {
101 return string[cmd];
102 }
103}
104
105
Wentao MA907b6432022-08-01 06:23:08 +0000106static char* _dvr_playback_state_toString(int state)
hualing chen6d24aa92020-03-23 18:43:47 +0800107{
Wentao MA907b6432022-08-01 06:23:08 +0000108 char *strings[5]={
109 "START",
110 "STOP",
111 "PAUSE",
112 "FF",
113 "FB",
hualing chen6d24aa92020-03-23 18:43:47 +0800114 };
115
Wentao MA907b6432022-08-01 06:23:08 +0000116 if (state >= 5 || state < 0) {
117 return "UNKNOWN";
hualing chen6d24aa92020-03-23 18:43:47 +0800118 }
Wentao MA907b6432022-08-01 06:23:08 +0000119 return strings[state];
hualing chen6d24aa92020-03-23 18:43:47 +0800120}
hualing chena540a7e2020-03-27 16:44:05 +0800121
122static DVR_Bool_t _dvr_support_speed(int speed) {
123
124 DVR_Bool_t ret = DVR_FALSE;
125
126 switch (speed) {
hualing chene41f4372020-06-06 16:29:17 +0800127 case PLAYBACK_SPEED_FBX1:
hualing chena540a7e2020-03-27 16:44:05 +0800128 case PLAYBACK_SPEED_FBX2:
129 case PLAYBACK_SPEED_FBX4:
130 case PLAYBACK_SPEED_FBX8:
hualing chen041c4092020-04-05 15:11:50 +0800131 case PLAYBACK_SPEED_FBX16:
132 case PLAYBACK_SPEED_FBX12:
133 case PLAYBACK_SPEED_FBX32:
134 case PLAYBACK_SPEED_FBX48:
135 case PLAYBACK_SPEED_FBX64:
136 case PLAYBACK_SPEED_FBX128:
hualing chena540a7e2020-03-27 16:44:05 +0800137 case PLAYBACK_SPEED_S2:
138 case PLAYBACK_SPEED_S4:
139 case PLAYBACK_SPEED_S8:
140 case PLAYBACK_SPEED_X1:
141 case PLAYBACK_SPEED_X2:
142 case PLAYBACK_SPEED_X4:
hualing chena540a7e2020-03-27 16:44:05 +0800143 case PLAYBACK_SPEED_X3:
144 case PLAYBACK_SPEED_X5:
145 case PLAYBACK_SPEED_X6:
146 case PLAYBACK_SPEED_X7:
hualing chen041c4092020-04-05 15:11:50 +0800147 case PLAYBACK_SPEED_X8:
148 case PLAYBACK_SPEED_X12:
149 case PLAYBACK_SPEED_X16:
150 case PLAYBACK_SPEED_X32:
151 case PLAYBACK_SPEED_X48:
152 case PLAYBACK_SPEED_X64:
153 case PLAYBACK_SPEED_X128:
hualing chena540a7e2020-03-27 16:44:05 +0800154 ret = DVR_TRUE;
155 break;
156 default:
Wentao MA96f68962022-06-15 19:45:35 +0800157 DVR_PB_INFO("not support speed is set [%d]", speed);
hualing chena540a7e2020-03-27 16:44:05 +0800158 break;
159 }
160 return ret;
161}
Wentao MA907b6432022-08-01 06:23:08 +0000162
hualing chen6e4bfa52020-03-13 14:37:11 +0800163void _dvr_tsplayer_callback_test(void *user_data, am_tsplayer_event *event)
164{
Wentao MA96f68962022-06-15 19:45:35 +0800165 DVR_PB_INFO("in callback test ");
hualing chen6e4bfa52020-03-13 14:37:11 +0800166 DVR_Playback_t *player = NULL;
167 if (user_data != NULL) {
hualing chena540a7e2020-03-27 16:44:05 +0800168 player = (DVR_Playback_t *) user_data;
Wentao MA96f68962022-06-15 19:45:35 +0800169 DVR_PB_INFO("play speed [%f] in callback test ", player->speed);
hualing chen6e4bfa52020-03-13 14:37:11 +0800170 }
171 switch (event->type) {
172 case AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED:
173 {
Wentao MA96f68962022-06-15 19:45:35 +0800174 DVR_PB_INFO("[evt] test AM_TSPLAYER_EVENT_TYPE_VIDEO_CHANGED: %d x %d @%d\n",
hualing chen6e4bfa52020-03-13 14:37:11 +0800175 event->event.video_format.frame_width,
176 event->event.video_format.frame_height,
177 event->event.video_format.frame_rate);
178 break;
179 }
hualing chen6e4bfa52020-03-13 14:37:11 +0800180 case AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME:
181 {
Wentao MA16f870e2022-09-09 11:00:22 +0800182 if (player == NULL) {
183 DVR_PB_WARN("player is null at line %d",__LINE__);
184 break;
185 }
Wentao MA96f68962022-06-15 19:45:35 +0800186 DVR_PB_INFO("[evt] test AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME\n");
hualing chena540a7e2020-03-27 16:44:05 +0800187 player->first_frame = 1;
hualing chen6e4bfa52020-03-13 14:37:11 +0800188 break;
189 }
190 default:
191 break;
192 }
193}
Wentao MA804bab12022-11-29 10:01:26 +0800194
hualing chen2aba4022020-03-02 13:49:55 +0800195void _dvr_tsplayer_callback(void *user_data, am_tsplayer_event *event)
196{
Wentao MA804bab12022-11-29 10:01:26 +0800197 DVR_Playback_t *play = (DVR_Playback_t*)user_data;
198 if (play == NULL) {
199 DVR_PB_WARN("play is invalid in %s",__func__);
200 return;
hualing chen6e4bfa52020-03-13 14:37:11 +0800201 }
hualing chen2aba4022020-03-02 13:49:55 +0800202 switch (event->type) {
hualing chen6e4bfa52020-03-13 14:37:11 +0800203 case AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME:
Wentao MA804bab12022-11-29 10:01:26 +0800204 DVR_PB_INFO("Received AM_TSPLAYER_EVENT_TYPE_FIRST_FRAME");
205 if (play->first_trans_ok == DVR_FALSE) {
206 play->first_trans_ok = DVR_TRUE;
207 _dvr_playback_sent_transition_ok((DVR_PlaybackHandle_t)play, DVR_FALSE);
208 }
209 play->first_frame = 1;
210 play->seek_pause = DVR_FALSE;
211 break;
hualing chen487ae6d2020-07-22 10:34:11 +0800212 case AM_TSPLAYER_EVENT_TYPE_DECODE_FIRST_FRAME_AUDIO:
Wentao MA804bab12022-11-29 10:01:26 +0800213 DVR_PB_INFO("Received AM_TSPLAYER_EVENT_TYPE_DECODE_FIRST_FRAME_AUDIO");
214 if (play->first_trans_ok == DVR_FALSE && play->has_video == DVR_FALSE) {
215 play->first_trans_ok = DVR_TRUE;
216 _dvr_playback_sent_transition_ok((DVR_PlaybackHandle_t)play, DVR_FALSE);
217 }
218 if (play->has_video == DVR_FALSE) {
219 play->first_frame = 1;
220 play->seek_pause = DVR_FALSE;
221 }
hualing chen487ae6d2020-07-22 10:34:11 +0800222 break;
hualing chen6e4bfa52020-03-13 14:37:11 +0800223 default:
224 break;
225 }
Wentao MA804bab12022-11-29 10:01:26 +0800226 if (play->player_callback_func == NULL) {
227 DVR_PB_WARN("play callback function %p is invalid",play->player_callback_func);
228 return;
hualing chen2aba4022020-03-02 13:49:55 +0800229 }
Wentao MA804bab12022-11-29 10:01:26 +0800230 play->player_callback_func(play->player_callback_userdata, event);
hualing chen2aba4022020-03-02 13:49:55 +0800231}
hualing chencc91e1c2020-02-28 13:26:17 +0800232
hualing chen5cbe1a62020-02-10 16:36:36 +0800233//convert video and audio fmt
234static int _dvr_convert_stream_fmt(int fmt, DVR_Bool_t is_audio) {
235 int format = 0;
236 if (is_audio == DVR_FALSE) {
237 //for video fmt
238 switch (fmt)
239 {
240 case DVR_VIDEO_FORMAT_MPEG1:
hualing chen2aba4022020-03-02 13:49:55 +0800241 format = AV_VIDEO_CODEC_MPEG1;
hualing chen5cbe1a62020-02-10 16:36:36 +0800242 break;
243 case DVR_VIDEO_FORMAT_MPEG2:
hualing chen2aba4022020-03-02 13:49:55 +0800244 format = AV_VIDEO_CODEC_MPEG2;
hualing chen5cbe1a62020-02-10 16:36:36 +0800245 break;
246 case DVR_VIDEO_FORMAT_HEVC:
hualing chen2aba4022020-03-02 13:49:55 +0800247 format = AV_VIDEO_CODEC_H265;
hualing chen5cbe1a62020-02-10 16:36:36 +0800248 break;
249 case DVR_VIDEO_FORMAT_H264:
hualing chen2aba4022020-03-02 13:49:55 +0800250 format = AV_VIDEO_CODEC_H264;
hualing chen5cbe1a62020-02-10 16:36:36 +0800251 break;
hualing chena540a7e2020-03-27 16:44:05 +0800252 case DVR_VIDEO_FORMAT_VP9:
253 format = AV_VIDEO_CODEC_VP9;
254 break;
hualing chen5cbe1a62020-02-10 16:36:36 +0800255 }
256 } else {
257 //for audio fmt
258 switch (fmt)
259 {
260 case DVR_AUDIO_FORMAT_MPEG:
hualing chen2aba4022020-03-02 13:49:55 +0800261 format = AV_AUDIO_CODEC_MP2;
hualing chen5cbe1a62020-02-10 16:36:36 +0800262 break;
263 case DVR_AUDIO_FORMAT_AC3:
hualing chen2aba4022020-03-02 13:49:55 +0800264 format = AV_AUDIO_CODEC_AC3;
hualing chen5cbe1a62020-02-10 16:36:36 +0800265 break;
266 case DVR_AUDIO_FORMAT_EAC3:
hualing chen2aba4022020-03-02 13:49:55 +0800267 format = AV_AUDIO_CODEC_EAC3;
hualing chen5cbe1a62020-02-10 16:36:36 +0800268 break;
269 case DVR_AUDIO_FORMAT_DTS:
hualing chen2aba4022020-03-02 13:49:55 +0800270 format = AV_AUDIO_CODEC_DTS;
hualing chen5cbe1a62020-02-10 16:36:36 +0800271 break;
hualing chena540a7e2020-03-27 16:44:05 +0800272 case DVR_AUDIO_FORMAT_AAC:
273 format = AV_AUDIO_CODEC_AAC;
274 break;
275 case DVR_AUDIO_FORMAT_LATM:
276 format = AV_AUDIO_CODEC_LATM;
277 break;
278 case DVR_AUDIO_FORMAT_PCM:
279 format = AV_AUDIO_CODEC_PCM;
280 break;
hualing chenee0e52b2021-04-09 16:58:44 +0800281 case DVR_AUDIO_FORMAT_AC4:
282 format = AV_AUDIO_CODEC_AC4;
283 break;
hualing chen5cbe1a62020-02-10 16:36:36 +0800284 }
285 }
286 return format;
287}
hualing chen040df222020-01-17 13:35:02 +0800288static int _dvr_playback_get_trick_stat(DVR_PlaybackHandle_t handle)
hualing chen86e7d482020-01-16 15:13:33 +0800289{
hualing chen040df222020-01-17 13:35:02 +0800290 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen86e7d482020-01-16 15:13:33 +0800291
Gong Ke2a0ebbe2021-05-25 15:22:50 +0800292 if (player == NULL || player->handle == (am_tsplayer_handle)NULL)
hualing chen86e7d482020-01-16 15:13:33 +0800293 return -1;
294
hualing chena540a7e2020-03-27 16:44:05 +0800295 return player->first_frame;
hualing chen86e7d482020-01-16 15:13:33 +0800296}
hualing chena540a7e2020-03-27 16:44:05 +0800297
hualing chen7ea70a72021-09-09 11:25:13 +0800298
299//get sys time sec
300static uint32_t _dvr_getClock_sec(void)
hualing chen5cbe1a62020-02-10 16:36:36 +0800301{
302 struct timespec ts;
hualing chen7ea70a72021-09-09 11:25:13 +0800303 uint32_t s;
hualing chen03fd4942021-07-15 15:56:41 +0800304 clock_gettime(CLOCK_REALTIME, &ts);
hualing chen7ea70a72021-09-09 11:25:13 +0800305 s = (uint32_t)(ts.tv_sec);
Wentao MA96f68962022-06-15 19:45:35 +0800306 DVR_PB_INFO("n:%u", s);
hualing chen7ea70a72021-09-09 11:25:13 +0800307 return s;
hualing chen5cbe1a62020-02-10 16:36:36 +0800308}
hualing chen86e7d482020-01-16 15:13:33 +0800309
hualing chen7ea70a72021-09-09 11:25:13 +0800310//get sys time ms
311static uint32_t _dvr_time_getClock(void)
312{
313 struct timespec ts;
314 uint32_t ms;
Zhiqiang Han71703652023-09-18 11:05:34 +0800315 clock_gettime(CLOCK_MONOTONIC, &ts);
hualing chen7ea70a72021-09-09 11:25:13 +0800316 ms = (uint32_t)(ts.tv_sec*1000+ts.tv_nsec/1000000);
317 return ms;
318}
hualing chenb31a6c62020-01-13 17:27:00 +0800319
Wentao MA270dc0f2022-08-23 13:17:26 +0800320//timeout wait signal
hualing chen040df222020-01-17 13:35:02 +0800321static int _dvr_playback_timeoutwait(DVR_PlaybackHandle_t handle , int ms)
hualing chenb31a6c62020-01-13 17:27:00 +0800322{
hualing chen040df222020-01-17 13:35:02 +0800323 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chenb31a6c62020-01-13 17:27:00 +0800324
hualing chena540a7e2020-03-27 16:44:05 +0800325
326 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800327 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800328 return DVR_FAILURE;
329 }
330
hualing chen86e7d482020-01-16 15:13:33 +0800331 struct timespec ts;
332 clock_gettime(CLOCK_MONOTONIC, &ts);
333 //ms为毫秒,换算成秒
334 ts.tv_sec += ms/1000;
335 //在outtime的基础上,增加ms毫秒
336 //outtime.tv_nsec为纳秒,1微秒=1000纳秒
337 //tv_nsec此值再加上剩余的毫秒数 ms%1000,有可能超过1秒。需要特殊处理
338 uint64_t us = ts.tv_nsec/1000 + 1000 * (ms % 1000); //微秒
339 //us的值有可能超过1秒,
340 ts.tv_sec += us / 1000000;
341 us = us % 1000000;
342 ts.tv_nsec = us * 1000;//换算成纳秒
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +0800343
344 int val = dvr_mutex_save(&player->lock);
345 pthread_cond_timedwait(&player->cond, &player->lock.lock, &ts);
346 dvr_mutex_restore(&player->lock, val);
hualing chen86e7d482020-01-16 15:13:33 +0800347 return 0;
hualing chenb31a6c62020-01-13 17:27:00 +0800348}
Wentao MA804bab12022-11-29 10:01:26 +0800349
hualing chenb31a6c62020-01-13 17:27:00 +0800350//send signal
hualing chen040df222020-01-17 13:35:02 +0800351static int _dvr_playback_sendSignal(DVR_PlaybackHandle_t handle)
hualing chenb31a6c62020-01-13 17:27:00 +0800352{
hualing chen87072a82020-03-12 16:20:12 +0800353 DVR_Playback_t *player = (DVR_Playback_t *) handle;\
hualing chena540a7e2020-03-27 16:44:05 +0800354
355 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800356 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800357 return DVR_FAILURE;
358 }
Wentao MA96f68962022-06-15 19:45:35 +0800359 DVR_PB_DEBUG("lock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +0800360 dvr_mutex_lock(&player->lock);
hualing chen87072a82020-03-12 16:20:12 +0800361 pthread_cond_signal(&player->cond);
Wentao MA96f68962022-06-15 19:45:35 +0800362 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +0800363 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +0800364 return 0;
hualing chenb31a6c62020-01-13 17:27:00 +0800365}
366
hualing chen2932d372020-04-29 13:44:00 +0800367//send playback event, need check is need lock first
368static int _dvr_playback_sent_event(DVR_PlaybackHandle_t handle, DVR_PlaybackEvent_t evt, DVR_Play_Notify_t *notify, DVR_Bool_t is_lock) {
hualing chencc91e1c2020-02-28 13:26:17 +0800369
370 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +0800371
372 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800373 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800374 return DVR_FAILURE;
375 }
376
hualing chencc91e1c2020-02-28 13:26:17 +0800377 switch (evt) {
378 case DVR_PLAYBACK_EVENT_ERROR:
hualing chen2932d372020-04-29 13:44:00 +0800379 _dvr_playback_get_status(handle, &(notify->play_status), is_lock);
hualing chencc91e1c2020-02-28 13:26:17 +0800380 break;
381 case DVR_PLAYBACK_EVENT_TRANSITION_OK:
382 //GET STATE
Wentao MA96f68962022-06-15 19:45:35 +0800383 DVR_PB_INFO("trans ok EVENT");
hualing chen2932d372020-04-29 13:44:00 +0800384 _dvr_playback_get_status(handle, &(notify->play_status), is_lock);
hualing chencc91e1c2020-02-28 13:26:17 +0800385 break;
386 case DVR_PLAYBACK_EVENT_TRANSITION_FAILED:
387 break;
388 case DVR_PLAYBACK_EVENT_KEY_FAILURE:
389 break;
390 case DVR_PLAYBACK_EVENT_NO_KEY:
391 break;
392 case DVR_PLAYBACK_EVENT_REACHED_BEGIN:
hualing chen2aba4022020-03-02 13:49:55 +0800393 //GET STATE
Wentao MA96f68962022-06-15 19:45:35 +0800394 DVR_PB_INFO("reached begin EVENT");
hualing chen2932d372020-04-29 13:44:00 +0800395 _dvr_playback_get_status(handle, &(notify->play_status), is_lock);
hualing chencc91e1c2020-02-28 13:26:17 +0800396 break;
397 case DVR_PLAYBACK_EVENT_REACHED_END:
398 //GET STATE
Wentao MA96f68962022-06-15 19:45:35 +0800399 DVR_PB_INFO("reached end EVENT");
hualing chen2932d372020-04-29 13:44:00 +0800400 _dvr_playback_get_status(handle, &(notify->play_status), is_lock);
hualing chencc91e1c2020-02-28 13:26:17 +0800401 break;
hualing chen6e4bfa52020-03-13 14:37:11 +0800402 case DVR_PLAYBACK_EVENT_NOTIFY_PLAYTIME:
hualing chen2932d372020-04-29 13:44:00 +0800403 _dvr_playback_get_status(handle, &(notify->play_status), is_lock);
hualing chen6e4bfa52020-03-13 14:37:11 +0800404 break;
hualing chencc91e1c2020-02-28 13:26:17 +0800405 default:
406 break;
407 }
408 if (player->openParams.event_fn != NULL)
409 player->openParams.event_fn(evt, (void*)notify, player->openParams.event_userdata);
hualing chencc91e1c2020-02-28 13:26:17 +0800410 return DVR_SUCCESS;
411}
hualing chen2932d372020-04-29 13:44:00 +0800412static int _dvr_playback_sent_transition_ok(DVR_PlaybackHandle_t handle, DVR_Bool_t is_lock)
hualing chencc91e1c2020-02-28 13:26:17 +0800413{
414 DVR_Play_Notify_t notify;
415 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
416 notify.event = DVR_PLAYBACK_EVENT_TRANSITION_OK;
417 //get play statue not here
hualing chen2932d372020-04-29 13:44:00 +0800418 _dvr_playback_sent_event(handle, DVR_PLAYBACK_EVENT_TRANSITION_OK, &notify, is_lock);
hualing chencc91e1c2020-02-28 13:26:17 +0800419 return DVR_SUCCESS;
420}
421
hualing chen2932d372020-04-29 13:44:00 +0800422static int _dvr_playback_sent_playtime(DVR_PlaybackHandle_t handle, DVR_Bool_t is_lock)
hualing chen6e4bfa52020-03-13 14:37:11 +0800423{
424 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +0800425
Wentao MA16f870e2022-09-09 11:00:22 +0800426 if (player == NULL) {
427 DVR_PB_ERROR("player is NULL");
428 return DVR_FAILURE;
429 }
hualing chene3797f02021-01-13 14:53:28 +0800430 if (player->openParams.is_notify_time == DVR_FALSE) {
shenghui.gengbec6a462023-01-12 15:21:02 +0800431 if (player->control_speed_enable == 0)
hualing chend241c7a2021-06-22 13:34:27 +0800432 return DVR_SUCCESS;
hualing chen4b7c15d2020-04-07 16:13:48 +0800433 }
hualing chena540a7e2020-03-27 16:44:05 +0800434
hualing chen03fd4942021-07-15 15:56:41 +0800435 if (player->send_time == 0) {
shenghui.gengbec6a462023-01-12 15:21:02 +0800436 if (player->control_speed_enable == 0)
hualing chend241c7a2021-06-22 13:34:27 +0800437 player->send_time = _dvr_time_getClock() + 500;
438 else
439 player->send_time = _dvr_time_getClock() + 20;
hualing chen0888c032020-12-18 17:54:57 +0800440 } else if (player->send_time >= _dvr_time_getClock()) {
hualing chen56c0a162022-01-27 17:01:50 +0800441 if ((player->send_time - _dvr_time_getClock()) > 1000) {
442 player->send_time = _dvr_time_getClock() + 500;
Wentao MA96f68962022-06-15 19:45:35 +0800443 DVR_PB_INFO("player send time occur system time changed!!!!!");
hualing chen56c0a162022-01-27 17:01:50 +0800444 } else {
445 return DVR_SUCCESS;
446 }
hualing chen6e4bfa52020-03-13 14:37:11 +0800447 }
shenghui.gengbec6a462023-01-12 15:21:02 +0800448 if (player->control_speed_enable == 0)
hualing chend241c7a2021-06-22 13:34:27 +0800449 player->send_time = _dvr_time_getClock() + 500;
450 else
451 player->send_time = _dvr_time_getClock() + 20;
452
hualing chen6e4bfa52020-03-13 14:37:11 +0800453 DVR_Play_Notify_t notify;
454 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
455 notify.event = DVR_PLAYBACK_EVENT_NOTIFY_PLAYTIME;
456 //get play statue not here
hualing chen2932d372020-04-29 13:44:00 +0800457 _dvr_playback_sent_event(handle, DVR_PLAYBACK_EVENT_NOTIFY_PLAYTIME, &notify, is_lock);
hualing chen6e4bfa52020-03-13 14:37:11 +0800458 return DVR_SUCCESS;
459}
460
hualing chen4b7c15d2020-04-07 16:13:48 +0800461static int _dvr_init_fffb_t(DVR_PlaybackHandle_t handle) {
462 DVR_Playback_t *player = (DVR_Playback_t *) handle;
463 player->fffb_start = _dvr_time_getClock();
Wentao MA96f68962022-06-15 19:45:35 +0800464 DVR_PB_INFO(" player->fffb_start:%u", player->fffb_start);
hualing chen4b7c15d2020-04-07 16:13:48 +0800465 player->fffb_current = player->fffb_start;
466 //get segment current time pos
467 player->fffb_start_pcr = _dvr_get_cur_time(handle);
hualing chen4b7c15d2020-04-07 16:13:48 +0800468 player->next_fffb_time = _dvr_time_getClock();
469
470 return DVR_SUCCESS;
471}
472
hualing chen2aba4022020-03-02 13:49:55 +0800473static int _dvr_init_fffb_time(DVR_PlaybackHandle_t handle) {
474 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen4b7c15d2020-04-07 16:13:48 +0800475 player->fffb_start = _dvr_time_getClock();
Wentao MA96f68962022-06-15 19:45:35 +0800476 DVR_PB_INFO(" player->fffb_start:%u", player->fffb_start);
hualing chen4b7c15d2020-04-07 16:13:48 +0800477 player->fffb_current = player->fffb_start;
478 //get segment current time pos
479 player->fffb_start_pcr = _dvr_get_cur_time(handle);
hualing chen03fd4942021-07-15 15:56:41 +0800480
hualing chen2aba4022020-03-02 13:49:55 +0800481 player->next_fffb_time = _dvr_time_getClock();
hualing chen4b7c15d2020-04-07 16:13:48 +0800482 player->last_send_time_id = UINT64_MAX;
hualing chen2aba4022020-03-02 13:49:55 +0800483 return DVR_SUCCESS;
484}
hualing chencc91e1c2020-02-28 13:26:17 +0800485//get next segment id
hualing chen87072a82020-03-12 16:20:12 +0800486static int _dvr_has_next_segmentId(DVR_PlaybackHandle_t handle, int segmentid) {
487
488 DVR_Playback_t *player = (DVR_Playback_t *) handle;
489 DVR_PlaybackSegmentInfo_t *segment;
490 DVR_PlaybackSegmentInfo_t *pre_segment = NULL;
491
hualing chena540a7e2020-03-27 16:44:05 +0800492 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800493 DVR_PB_INFO(" player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800494 return DVR_FAILURE;
495 }
496
hualing chen87072a82020-03-12 16:20:12 +0800497 int found = 0;
498 int found_eq_id = 0;
wentao.mafd5283f2022-10-14 09:51:13 +0800499 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +0800500 // prefetch() here incurring self_assign is used to avoid some compiling
501 // warnings.
502 // coverity[self_assign]
hualing chen87072a82020-03-12 16:20:12 +0800503 list_for_each_entry(segment, &player->segment_list, head)
504 {
505 if (player->segment_is_open == DVR_FALSE) {
506 //get first segment from list, case segment is not open
507 if (!IS_FB(player->speed))
508 found = 1;
509 } else if (segment->segment_id == segmentid) {
510 //find cur segment, we need get next one
511 found_eq_id = 1;
512 if (!IS_FB(player->speed)) {
513 found = 1;
514 continue;
515 } else {
516 //if is fb mode.we need used pre segment
517 if (pre_segment != NULL) {
518 found = 1;
519 } else {
520 //not find next id.
Wentao MA96f68962022-06-15 19:45:35 +0800521 DVR_PB_INFO("not has find next segment on fb mode");
hualing chen87072a82020-03-12 16:20:12 +0800522 return DVR_FAILURE;
523 }
524 }
525 }
526 if (found == 1) {
527 found = 2;
528 break;
529 }
hualing chenc7aa4c82021-02-03 15:41:37 +0800530 pre_segment = segment;
hualing chen87072a82020-03-12 16:20:12 +0800531 }
532 if (found != 2) {
533 //list is null or reache list end
Wentao MA96f68962022-06-15 19:45:35 +0800534 DVR_PB_INFO("not found next segment return failure");
hualing chen87072a82020-03-12 16:20:12 +0800535 return DVR_FAILURE;
536 }
Wentao MA96f68962022-06-15 19:45:35 +0800537 DVR_PB_INFO("found next segment return success");
hualing chen87072a82020-03-12 16:20:12 +0800538 return DVR_SUCCESS;
539}
540
541//get next segment id
hualing chen040df222020-01-17 13:35:02 +0800542static int _dvr_get_next_segmentId(DVR_PlaybackHandle_t handle) {
hualing chenb31a6c62020-01-13 17:27:00 +0800543
hualing chen040df222020-01-17 13:35:02 +0800544 DVR_Playback_t *player = (DVR_Playback_t *) handle;
545 DVR_PlaybackSegmentInfo_t *segment;
hualing chen2aba4022020-03-02 13:49:55 +0800546 DVR_PlaybackSegmentInfo_t *pre_segment = NULL;
hualing chen03fd4942021-07-15 15:56:41 +0800547 uint64_t segmentid;
hualing chen7ea70a72021-09-09 11:25:13 +0800548 uint32_t pos;
hualing chena540a7e2020-03-27 16:44:05 +0800549 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800550 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800551 return DVR_FAILURE;
552 }
553
hualing chen03fd4942021-07-15 15:56:41 +0800554 if (IS_FB(player->speed)
555 && dvr_playback_check_limit(handle)) {
556 dvr_playback_calculate_last_valid_segment(handle, &segmentid, &pos);
557 //case cur id < segment id
558 if (player->cur_segment_id <= segmentid) {
559 //expired ts data is player,return error
Wentao MA96f68962022-06-15 19:45:35 +0800560 DVR_PB_INFO("reach start segment ,return error");
hualing chen03fd4942021-07-15 15:56:41 +0800561 return DVR_FAILURE;
562 }
Wentao MA96f68962022-06-15 19:45:35 +0800563 DVR_PB_INFO("has segment to fb play [%lld][%u]", segmentid, pos);
hualing chen03fd4942021-07-15 15:56:41 +0800564 }
565
hualing chen86e7d482020-01-16 15:13:33 +0800566 int found = 0;
hualing chen2aba4022020-03-02 13:49:55 +0800567 int found_eq_id = 0;
hualing chena540a7e2020-03-27 16:44:05 +0800568
wentao.mafd5283f2022-10-14 09:51:13 +0800569 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +0800570 // prefetch() here incurring self_assign is used to avoid some compiling
571 // warnings.
572 // coverity[self_assign]
hualing chen040df222020-01-17 13:35:02 +0800573 list_for_each_entry(segment, &player->segment_list, head)
hualing chen86e7d482020-01-16 15:13:33 +0800574 {
hualing chencc91e1c2020-02-28 13:26:17 +0800575 if (player->segment_is_open == DVR_FALSE) {
hualing chen2aba4022020-03-02 13:49:55 +0800576 //get first segment from list, case segment is not open
577 if (!IS_FB(player->speed))
578 found = 1;
hualing chen040df222020-01-17 13:35:02 +0800579 } else if (segment->segment_id == player->cur_segment_id) {
580 //find cur segment, we need get next one
hualing chen2aba4022020-03-02 13:49:55 +0800581 found_eq_id = 1;
582 if (!IS_FB(player->speed)) {
583 found = 1;
584 continue;
585 } else {
586 //if is fb mode.we need used pre segment
587 if (pre_segment != NULL) {
588 found = 1;
589 } else {
590 //not find next id.
Wentao MA96f68962022-06-15 19:45:35 +0800591 DVR_PB_INFO("not find next segment on fb mode");
hualing chen2aba4022020-03-02 13:49:55 +0800592 return DVR_FAILURE;
593 }
594 }
hualing chen86e7d482020-01-16 15:13:33 +0800595 }
596 if (found == 1) {
hualing chen2aba4022020-03-02 13:49:55 +0800597 if (IS_FB(player->speed)) {
598 //used pre segment
599 segment = pre_segment;
600 }
hualing chencc91e1c2020-02-28 13:26:17 +0800601 //save segment info
602 player->last_segment_id = player->cur_segment_id;
Wentao MAf35c3882023-04-17 12:36:19 +0800603 if (player->segment_handle) {
604 player->last_segment_total = segment_tell_total_time(player->segment_handle);
605 }
hualing chen87072a82020-03-12 16:20:12 +0800606 player->last_segment.segment_id = player->cur_segment.segment_id;
607 player->last_segment.flags = player->cur_segment.flags;
hualing chencc91e1c2020-02-28 13:26:17 +0800608 memcpy(player->last_segment.location, player->cur_segment.location, DVR_MAX_LOCATION_SIZE);
609 //pids
610 memcpy(&player->last_segment.pids, &player->cur_segment.pids, sizeof(DVR_PlaybackPids_t));
611
hualing chen5cbe1a62020-02-10 16:36:36 +0800612 //get segment info
hualing chencc91e1c2020-02-28 13:26:17 +0800613 player->segment_is_open = DVR_TRUE;
hualing chen040df222020-01-17 13:35:02 +0800614 player->cur_segment_id = segment->segment_id;
615 player->cur_segment.segment_id = segment->segment_id;
616 player->cur_segment.flags = segment->flags;
Wentao MA96f68962022-06-15 19:45:35 +0800617 DVR_PB_INFO("set cur id cur flag[0x%x]segment->flags flag[0x%x] id [%lld]", player->cur_segment.flags, segment->flags, segment->segment_id);
hualing chen5cbe1a62020-02-10 16:36:36 +0800618 memcpy(player->cur_segment.location, segment->location, DVR_MAX_LOCATION_SIZE);
hualing chen86e7d482020-01-16 15:13:33 +0800619 //pids
hualing chen040df222020-01-17 13:35:02 +0800620 memcpy(&player->cur_segment.pids, &segment->pids, sizeof(DVR_PlaybackPids_t));
hualing chen86e7d482020-01-16 15:13:33 +0800621 found = 2;
hualing chen2aba4022020-03-02 13:49:55 +0800622 break;
hualing chen86e7d482020-01-16 15:13:33 +0800623 }
hualing chen2aba4022020-03-02 13:49:55 +0800624 pre_segment = segment;
625 }
626 if (player->segment_is_open == DVR_FALSE && IS_FB(player->speed)) {
627 //used the last one segment to open
628 //get segment info
629 player->segment_is_open = DVR_TRUE;
630 player->cur_segment_id = pre_segment->segment_id;
631 player->cur_segment.segment_id = pre_segment->segment_id;
632 player->cur_segment.flags = pre_segment->flags;
Wentao MA96f68962022-06-15 19:45:35 +0800633 DVR_PB_INFO("set cur id fb last one cur flag[0x%x]segment->flags flag[0x%x] id [%lld]", player->cur_segment.flags, pre_segment->flags, pre_segment->segment_id);
hualing chen2aba4022020-03-02 13:49:55 +0800634 memcpy(player->cur_segment.location, pre_segment->location, DVR_MAX_LOCATION_SIZE);
635 //pids
636 memcpy(&player->cur_segment.pids, &pre_segment->pids, sizeof(DVR_PlaybackPids_t));
637 return DVR_SUCCESS;
hualing chen86e7d482020-01-16 15:13:33 +0800638 }
639 if (found != 2) {
640 //list is null or reache list end
hualing chen2aba4022020-03-02 13:49:55 +0800641 return DVR_FAILURE;
hualing chen86e7d482020-01-16 15:13:33 +0800642 }
643 return DVR_SUCCESS;
644}
hualing chen040df222020-01-17 13:35:02 +0800645//open next segment to play,if reach list end return errro.
646static int _change_to_next_segment(DVR_PlaybackHandle_t handle)
hualing chen86e7d482020-01-16 15:13:33 +0800647{
hualing chen040df222020-01-17 13:35:02 +0800648 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen86e7d482020-01-16 15:13:33 +0800649 Segment_OpenParams_t params;
650 int ret = DVR_SUCCESS;
651
hualing chena540a7e2020-03-27 16:44:05 +0800652 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800653 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800654 return DVR_FAILURE;
655 }
hualing chen4b7c15d2020-04-07 16:13:48 +0800656 pthread_mutex_lock(&player->segment_lock);
hualing chen926a8ec2021-12-20 20:38:24 +0800657retry:
hualing chena540a7e2020-03-27 16:44:05 +0800658 ret = _dvr_get_next_segmentId(handle);
659 if (ret == DVR_FAILURE) {
Wentao MA96f68962022-06-15 19:45:35 +0800660 DVR_PB_INFO("not found segment info");
hualing chen4b7c15d2020-04-07 16:13:48 +0800661 pthread_mutex_unlock(&player->segment_lock);
hualing chen5cbe1a62020-02-10 16:36:36 +0800662 return DVR_FAILURE;
hualing chen86e7d482020-01-16 15:13:33 +0800663 }
664
Wentao MAf35c3882023-04-17 12:36:19 +0800665 if (player->segment_handle != NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800666 DVR_PB_INFO("close segment");
Wentao MAf35c3882023-04-17 12:36:19 +0800667 segment_close(player->segment_handle);
668 player->segment_handle = NULL;
hualing chen86e7d482020-01-16 15:13:33 +0800669 }
670
Wentao MA4d85ff32022-09-23 11:36:18 +0800671 memset((void*)&params,0,sizeof(params));
Wentao MA270dc0f2022-08-23 13:17:26 +0800672 //cp current segment path to location
hualing chen5cbe1a62020-02-10 16:36:36 +0800673 memcpy(params.location, player->cur_segment.location, DVR_MAX_LOCATION_SIZE);
hualing chen040df222020-01-17 13:35:02 +0800674 params.segment_id = (uint64_t)player->cur_segment.segment_id;
hualing chen86e7d482020-01-16 15:13:33 +0800675 params.mode = SEGMENT_MODE_READ;
Wentao MA96f68962022-06-15 19:45:35 +0800676 DVR_PB_INFO("open segment location[%s]id[%lld]flag[0x%x]", params.location, params.segment_id, player->cur_segment.flags);
hualing chen4b7c15d2020-04-07 16:13:48 +0800677
Wentao MAf35c3882023-04-17 12:36:19 +0800678 ret = segment_open(&params, &(player->segment_handle));
hualing chen4b7c15d2020-04-07 16:13:48 +0800679 if (ret == DVR_FAILURE) {
Wentao MA96f68962022-06-15 19:45:35 +0800680 DVR_PB_INFO("open segment error");
hualing chen926a8ec2021-12-20 20:38:24 +0800681 goto retry;
hualing chen4b7c15d2020-04-07 16:13:48 +0800682 }
Wentao MA01de0e62022-01-10 18:48:23 +0800683 // Keep the start segment_id when the first segment_open is called during a playback
684 if (player->first_start_id == UINT64_MAX) {
685 player->first_start_id = player->cur_segment.segment_id;
686 }
hualing chen87072a82020-03-12 16:20:12 +0800687 pthread_mutex_unlock(&player->segment_lock);
688 int total = _dvr_get_end_time( handle);
689 pthread_mutex_lock(&player->segment_lock);
hualing chen2aba4022020-03-02 13:49:55 +0800690 if (IS_FB(player->speed)) {
691 //seek end pos -FB_DEFAULT_LEFT_TIME
hualing chen5605eed2020-05-26 18:18:06 +0800692 player->ts_cache_len = 0;
Wentao MAf35c3882023-04-17 12:36:19 +0800693 segment_seek(player->segment_handle, total - FB_DEFAULT_LEFT_TIME, player->openParams.block_size);
Wentao MA96f68962022-06-15 19:45:35 +0800694 DVR_PB_INFO("seek pos [%d]", total - FB_DEFAULT_LEFT_TIME);
hualing chen2aba4022020-03-02 13:49:55 +0800695 }
hualing chen87072a82020-03-12 16:20:12 +0800696 player->dur = total;
wentao.mafdba9a02023-01-17 16:43:26 +0800697 player->con_spe.ply_dur = 0;
698 player->con_spe.ply_sta = 0;
699 player->con_spe.sys_dur = 0;
700 player->con_spe.sys_sta = 0;
hualing chen2aba4022020-03-02 13:49:55 +0800701 pthread_mutex_unlock(&player->segment_lock);
Wentao MA96f68962022-06-15 19:45:35 +0800702 DVR_PB_INFO("next segment dur [%d] flag [0x%x]", player->dur, player->cur_segment.flags);
hualing chen86e7d482020-01-16 15:13:33 +0800703 return ret;
704}
705
hualing chen5cbe1a62020-02-10 16:36:36 +0800706//open next segment to play,if reach list end return errro.
707static int _dvr_open_segment(DVR_PlaybackHandle_t handle, uint64_t segment_id)
708{
709 DVR_Playback_t *player = (DVR_Playback_t *) handle;
710 Segment_OpenParams_t params;
711 int ret = DVR_SUCCESS;
hualing chena540a7e2020-03-27 16:44:05 +0800712 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800713 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800714 return DVR_FAILURE;
715 }
hualing chencc91e1c2020-02-28 13:26:17 +0800716 if (segment_id == player->cur_segment_id && player->segment_is_open == DVR_TRUE) {
hualing chen87072a82020-03-12 16:20:12 +0800717 return DVR_SUCCESS;
hualing chen5cbe1a62020-02-10 16:36:36 +0800718 }
hualing chencc91e1c2020-02-28 13:26:17 +0800719 uint64_t id = segment_id;
Wentao MA07d3d742022-09-06 09:58:05 +0800720 DVR_PB_INFO("start finding segment[%lld] info", id);
hualing chen2aba4022020-03-02 13:49:55 +0800721 pthread_mutex_lock(&player->segment_lock);
hualing chen5cbe1a62020-02-10 16:36:36 +0800722
723 DVR_PlaybackSegmentInfo_t *segment;
724
725 int found = 0;
hualing chencc91e1c2020-02-28 13:26:17 +0800726
wentao.mafd5283f2022-10-14 09:51:13 +0800727 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +0800728 // prefetch() here incurring self_assign is used to avoid some compiling
729 // warnings.
730 // coverity[self_assign]
hualing chen5cbe1a62020-02-10 16:36:36 +0800731 list_for_each_entry(segment, &player->segment_list, head)
732 {
Wentao MA96f68962022-06-15 19:45:35 +0800733 DVR_PB_INFO("see 1 location [%s]id[%lld]flag[%x]segment_id[%lld]", segment->location, segment->segment_id, segment->flags, segment_id);
hualing chen5cbe1a62020-02-10 16:36:36 +0800734 if (segment->segment_id == segment_id) {
735 found = 1;
736 }
737 if (found == 1) {
Wentao MA96f68962022-06-15 19:45:35 +0800738 DVR_PB_INFO("found [%s]id[%lld]flag[%x]segment_id[%lld]", segment->location, segment->segment_id, segment->flags, segment_id);
hualing chen5cbe1a62020-02-10 16:36:36 +0800739 //get segment info
hualing chencc91e1c2020-02-28 13:26:17 +0800740 player->segment_is_open = DVR_TRUE;
hualing chen5cbe1a62020-02-10 16:36:36 +0800741 player->cur_segment_id = segment->segment_id;
742 player->cur_segment.segment_id = segment->segment_id;
743 player->cur_segment.flags = segment->flags;
Wentao MAe88ad702022-09-02 10:35:00 +0800744 const int len = strlen(segment->location);
745 if (len >= DVR_MAX_LOCATION_SIZE || len <= 0) {
746 DVR_PB_ERROR("Invalid segment.location length %d",len);
747 pthread_mutex_unlock(&player->segment_lock);
748 return DVR_FAILURE;
749 }
750 strncpy(player->cur_segment.location, segment->location, len+1);
hualing chen5cbe1a62020-02-10 16:36:36 +0800751 //pids
752 memcpy(&player->cur_segment.pids, &segment->pids, sizeof(DVR_PlaybackPids_t));
Wentao MA96f68962022-06-15 19:45:35 +0800753 DVR_PB_INFO("cur found location [%s]id[%lld]flag[%x]", player->cur_segment.location, player->cur_segment.segment_id,player->cur_segment.flags);
hualing chencc91e1c2020-02-28 13:26:17 +0800754 break;
hualing chen5cbe1a62020-02-10 16:36:36 +0800755 }
756 }
hualing chencc91e1c2020-02-28 13:26:17 +0800757 if (found == 0) {
Wentao MA96f68962022-06-15 19:45:35 +0800758 DVR_PB_INFO("not found segment info.error..");
hualing chen2aba4022020-03-02 13:49:55 +0800759 pthread_mutex_unlock(&player->segment_lock);
hualing chencc91e1c2020-02-28 13:26:17 +0800760 return DVR_FAILURE;
761 }
Wentao MA4d85ff32022-09-23 11:36:18 +0800762 memset((void*)&params,0,sizeof(params));
Wentao MAe88ad702022-09-02 10:35:00 +0800763
764 const int len2 = strlen(player->cur_segment.location);
765 if (len2 >= DVR_MAX_LOCATION_SIZE || len2 <= 0) {
766 DVR_PB_ERROR("Invalid cur_segment.location length %d",len2);
767 pthread_mutex_unlock(&player->segment_lock);
768 return DVR_FAILURE;
769 }
770 strncpy(params.location, player->cur_segment.location, len2+1);
hualing chen5cbe1a62020-02-10 16:36:36 +0800771 params.segment_id = (uint64_t)player->cur_segment.segment_id;
772 params.mode = SEGMENT_MODE_READ;
Wentao MA96f68962022-06-15 19:45:35 +0800773 DVR_PB_INFO("open segment location[%s][%lld]cur flag[0x%x]", params.location, params.segment_id, player->cur_segment.flags);
Wentao MAf35c3882023-04-17 12:36:19 +0800774 if (player->segment_handle != NULL) {
775 segment_close(player->segment_handle);
776 player->segment_handle = NULL;
hualing chen2aba4022020-03-02 13:49:55 +0800777 }
Wentao MAf35c3882023-04-17 12:36:19 +0800778 ret = segment_open(&params, &(player->segment_handle));
hualing chen4b7c15d2020-04-07 16:13:48 +0800779 if (ret == DVR_FAILURE) {
Wentao MA270dc0f2022-08-23 13:17:26 +0800780 DVR_PB_INFO("segment open error");
hualing chen4b7c15d2020-04-07 16:13:48 +0800781 }
Wentao MA01de0e62022-01-10 18:48:23 +0800782 // Keep the start segment_id when the first segment_open is called during a playback
783 if (player->first_start_id == UINT64_MAX) {
784 player->first_start_id = player->cur_segment.segment_id;
785 }
hualing chen2aba4022020-03-02 13:49:55 +0800786 pthread_mutex_unlock(&player->segment_lock);
hualing chen87072a82020-03-12 16:20:12 +0800787 player->dur = _dvr_get_end_time(handle);
hualing chencc91e1c2020-02-28 13:26:17 +0800788
Wentao MA96f68962022-06-15 19:45:35 +0800789 DVR_PB_INFO("player->dur [%d]cur id [%lld]cur flag [0x%x]\r\n", player->dur,player->cur_segment.segment_id, player->cur_segment.flags);
hualing chen5cbe1a62020-02-10 16:36:36 +0800790 return ret;
791}
792
793
794//get play info by segment id
795static int _dvr_playback_get_playinfo(DVR_PlaybackHandle_t handle,
796 uint64_t segment_id,
Wentao MA270dc0f2022-08-23 13:17:26 +0800797 am_tsplayer_video_params *video_param,
798 am_tsplayer_audio_params *audio_param, am_tsplayer_audio_params *ad_param) {
hualing chen5cbe1a62020-02-10 16:36:36 +0800799
800 DVR_Playback_t *player = (DVR_Playback_t *) handle;
801 DVR_PlaybackSegmentInfo_t *segment;
hualing chena540a7e2020-03-27 16:44:05 +0800802 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800803 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800804 return DVR_FAILURE;
805 }
hualing chen5cbe1a62020-02-10 16:36:36 +0800806
807 int found = 0;
808
wentao.mafd5283f2022-10-14 09:51:13 +0800809 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +0800810 // prefetch() here incurring self_assign is used to avoid some compiling
811 // warnings.
812 // coverity[self_assign]
hualing chen5cbe1a62020-02-10 16:36:36 +0800813 list_for_each_entry(segment, &player->segment_list, head)
814 {
hualing chen87072a82020-03-12 16:20:12 +0800815 if (segment_id == UINT64_MAX) {
hualing chen5cbe1a62020-02-10 16:36:36 +0800816 //get first segment from list
817 found = 1;
818 }
819 if (segment->segment_id == segment_id) {
820 found = 1;
821 }
822 if (found == 1) {
823 //get segment info
hualing chen87072a82020-03-12 16:20:12 +0800824 if (player->cur_segment_id != UINT64_MAX)
hualing chen5cbe1a62020-02-10 16:36:36 +0800825 player->cur_segment_id = segment->segment_id;
hualing chen5cbe1a62020-02-10 16:36:36 +0800826 player->cur_segment.segment_id = segment->segment_id;
827 player->cur_segment.flags = segment->flags;
828 //pids
hualing chen2aba4022020-03-02 13:49:55 +0800829 player->cur_segment.pids.video.pid = segment->pids.video.pid;
830 player->cur_segment.pids.video.format = segment->pids.video.format;
831 player->cur_segment.pids.video.type = segment->pids.video.type;
832 player->cur_segment.pids.audio.pid = segment->pids.audio.pid;
833 player->cur_segment.pids.audio.format = segment->pids.audio.format;
834 player->cur_segment.pids.audio.type = segment->pids.audio.type;
835 player->cur_segment.pids.ad.pid = segment->pids.ad.pid;
836 player->cur_segment.pids.ad.format = segment->pids.ad.format;
837 player->cur_segment.pids.ad.type = segment->pids.ad.type;
838 player->cur_segment.pids.pcr.pid = segment->pids.pcr.pid;
hualing chen5cbe1a62020-02-10 16:36:36 +0800839 //
Wentao MA270dc0f2022-08-23 13:17:26 +0800840 video_param->codectype = _dvr_convert_stream_fmt(segment->pids.video.format, DVR_FALSE);
841 video_param->pid = segment->pids.video.pid;
842 audio_param->codectype = _dvr_convert_stream_fmt(segment->pids.audio.format, DVR_TRUE);
843 audio_param->pid = segment->pids.audio.pid;
844 ad_param->codectype =_dvr_convert_stream_fmt(segment->pids.ad.format, DVR_TRUE);
845 ad_param->pid =segment->pids.ad.pid;
Wentao MA804bab12022-11-29 10:01:26 +0800846 DVR_PB_DEBUG("get_playinfo, segment_id:%lld, vpid[0x%x], apid[0x%x], vfmt[%d], afmt[%d]",
847 player->cur_segment_id, video_param->pid, audio_param->pid,
848 video_param->codectype, audio_param->codectype);
hualing chen5cbe1a62020-02-10 16:36:36 +0800849 found = 2;
hualing chencc91e1c2020-02-28 13:26:17 +0800850 break;
hualing chen5cbe1a62020-02-10 16:36:36 +0800851 }
852 }
hualing chencc91e1c2020-02-28 13:26:17 +0800853 if (found != 2) {
854 //list is null or reache list end
Wentao MA96f68962022-06-15 19:45:35 +0800855 DVR_PB_INFO("get play info fail");
hualing chencc91e1c2020-02-28 13:26:17 +0800856 return DVR_FAILURE;
857 }
hualing chen5cbe1a62020-02-10 16:36:36 +0800858
859 return DVR_SUCCESS;
860}
hualing chencc91e1c2020-02-28 13:26:17 +0800861static int _dvr_replay_changed_pid(DVR_PlaybackHandle_t handle) {
862 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +0800863 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800864 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800865 return DVR_FAILURE;
866 }
hualing chen5cbe1a62020-02-10 16:36:36 +0800867
hualing chencc91e1c2020-02-28 13:26:17 +0800868 //compare cur segment
869 //if (player->cmd.state == DVR_PLAYBACK_STATE_START)
870 {
871 //check video pids, stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +0800872 _do_handle_pid_update(handle, player->last_segment.pids, player->cur_segment.pids, 0);
hualing chencc91e1c2020-02-28 13:26:17 +0800873 //check sub audio pids stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +0800874 _do_handle_pid_update(handle, player->last_segment.pids, player->cur_segment.pids, 2);
hualing chen969fe7b2021-05-26 15:13:17 +0800875 //check audio pids stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +0800876 _do_handle_pid_update(handle, player->last_segment.pids, player->cur_segment.pids, 1);
Wentao MA96f68962022-06-15 19:45:35 +0800877 DVR_PB_INFO(":last apid: %d set apid: %d", player->last_segment.pids.audio.pid,player->cur_segment.pids.audio.pid);
hualing chencc91e1c2020-02-28 13:26:17 +0800878 //check pcr pids stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +0800879 _do_handle_pid_update(handle, player->last_segment.pids, player->cur_segment.pids, 3);
hualing chencc91e1c2020-02-28 13:26:17 +0800880 }
hualing chena540a7e2020-03-27 16:44:05 +0800881 return DVR_SUCCESS;
hualing chencc91e1c2020-02-28 13:26:17 +0800882}
hualing chen5cbe1a62020-02-10 16:36:36 +0800883
hualing chend241c7a2021-06-22 13:34:27 +0800884static int _dvr_check_speed_con(DVR_PlaybackHandle_t handle)
885{
886 DVR_Playback_t *player = (DVR_Playback_t *) handle;
887 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800888 DVR_PB_INFO("player is NULL");
hualing chend241c7a2021-06-22 13:34:27 +0800889 return DVR_TRUE;
890 }
hualing chend241c7a2021-06-22 13:34:27 +0800891
wentao.mafdba9a02023-01-17 16:43:26 +0800892 DVR_PB_INFO(":play speed: %f ply dur: %d sys_dur: %u",
hualing chen03fd4942021-07-15 15:56:41 +0800893 player->speed,
894 player->con_spe.ply_dur,
895 player->con_spe.sys_dur);
hualing chend241c7a2021-06-22 13:34:27 +0800896
897 if (player->speed != 1.0f)
898 return DVR_TRUE;
899
900 if (player->con_spe.ply_dur > 0
hualing chen03fd4942021-07-15 15:56:41 +0800901 && 2 * player->con_spe.ply_dur > 3 * player->con_spe.sys_dur)
hualing chend241c7a2021-06-22 13:34:27 +0800902 return DVR_FALSE;
903
904 return DVR_TRUE;
905}
906
hualing chencc91e1c2020-02-28 13:26:17 +0800907static int _dvr_check_cur_segment_flag(DVR_PlaybackHandle_t handle)
908{
909 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +0800910 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800911 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800912 return DVR_FAILURE;
913 }
Wentao MA292380e2022-12-14 14:46:19 +0800914 if (player->vendor != DVR_PLAYBACK_VENDOR_DEF) {
915 DVR_PB_INFO("In case of vendor Amlogic/Amazon, do not control AV display");
hualing chenf43b8ba2020-07-28 13:11:42 +0800916 return DVR_SUCCESS;
917 }
Wentao MA96f68962022-06-15 19:45:35 +0800918 DVR_PB_INFO("flag[0x%x]id[%lld]last[0x%x][%llu]",
hualing chen03fd4942021-07-15 15:56:41 +0800919 player->cur_segment.flags,
920 player->cur_segment.segment_id,
921 player->last_segment.flags,
922 player->last_segment.segment_id);
hualing chen87072a82020-03-12 16:20:12 +0800923 if ((player->cur_segment.flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == DVR_PLAYBACK_SEGMENT_DISPLAYABLE &&
924 (player->last_segment.flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == 0) {
hualing chencc91e1c2020-02-28 13:26:17 +0800925 //enable display
Wentao MA96f68962022-06-15 19:45:35 +0800926 DVR_PB_INFO("unmute");
hualing chen2aba4022020-03-02 13:49:55 +0800927 AmTsPlayer_showVideo(player->handle);
928 AmTsPlayer_setAudioMute(player->handle, 0, 0);
hualing chen87072a82020-03-12 16:20:12 +0800929 } else if ((player->cur_segment.flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == 0 &&
930 (player->last_segment.flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == DVR_PLAYBACK_SEGMENT_DISPLAYABLE) {
hualing chen2aba4022020-03-02 13:49:55 +0800931 //disable display
Wentao MA96f68962022-06-15 19:45:35 +0800932 DVR_PB_INFO("mute");
hualing chen2aba4022020-03-02 13:49:55 +0800933 AmTsPlayer_hideVideo(player->handle);
934 AmTsPlayer_setAudioMute(player->handle, 1, 1);
hualing chencc91e1c2020-02-28 13:26:17 +0800935 }
936 return DVR_SUCCESS;
937}
hualing chene3797f02021-01-13 14:53:28 +0800938/*
Wentao MA270dc0f2022-08-23 13:17:26 +0800939if decode success first time.
940success: return true
hualing chene3797f02021-01-13 14:53:28 +0800941fail: return false
942*/
Wentao MA270dc0f2022-08-23 13:17:26 +0800943static DVR_Bool_t _dvr_pauselive_decode_success(DVR_PlaybackHandle_t handle) {
hualing chena540a7e2020-03-27 16:44:05 +0800944 DVR_Playback_t *player = (DVR_Playback_t *) handle;
945 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +0800946 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +0800947 return DVR_TRUE;
948 }
hualing chene3797f02021-01-13 14:53:28 +0800949 if (player->first_frame == 1) {
hualing chena540a7e2020-03-27 16:44:05 +0800950 return DVR_TRUE;
hualing chene3797f02021-01-13 14:53:28 +0800951 } else {
952 return DVR_FALSE;
hualing chena540a7e2020-03-27 16:44:05 +0800953 }
954}
hualing chen86e7d482020-01-16 15:13:33 +0800955static void* _dvr_playback_thread(void *arg)
956{
hualing chen040df222020-01-17 13:35:02 +0800957 DVR_Playback_t *player = (DVR_Playback_t *) arg;
hualing chencc91e1c2020-02-28 13:26:17 +0800958 //int need_open_segment = 1;
Wentao MA270dc0f2022-08-23 13:17:26 +0800959 am_tsplayer_input_buffer input_buffer;
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800960 am_tsplayer_input_buffer dec_bufs;
hualing chen5cbe1a62020-02-10 16:36:36 +0800961 int ret = DVR_SUCCESS;
hualing chen86e7d482020-01-16 15:13:33 +0800962
hualing chen39628212020-05-14 10:35:13 +0800963 #define MAX_REACHEND_TIMEOUT (3000)
964 int reach_end_timeout = 0;//ms
965 int cache_time = 0;
hualing chen40dd5462021-11-26 19:56:20 +0800966 int check_no_data_time = 4;
hualing chen040df222020-01-17 13:35:02 +0800967 int buf_len = player->openParams.block_size > 0 ? player->openParams.block_size : (256 * 1024);
hualing chen266b9502020-04-04 17:39:39 +0800968 DVR_Bool_t b_writed_whole_block = player->openParams.block_size > 0 ? DVR_TRUE:DVR_FALSE;
hualing chen40dd5462021-11-26 19:56:20 +0800969 int first_write = 0;
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800970 int dec_buf_size = buf_len + 188;
hualing chen86e7d482020-01-16 15:13:33 +0800971 int real_read = 0;
hualing chen2aba4022020-03-02 13:49:55 +0800972 DVR_Bool_t goto_rewrite = DVR_FALSE;
wentao ma7d642782022-10-23 18:26:16 -0700973 int read = 0;
yinming ding0ce94922021-09-08 15:09:15 +0800974
Wentao MA361eaac2023-03-21 13:12:28 +0800975 prctl(PR_SET_NAME,"DvrPlayback");
976
wentao ma7d642782022-10-23 18:26:16 -0700977 const uint64_t write_timeout_ms = (uint64_t)dvr_prop_read_int("vendor.tv.libdvr.writetm",50);
978 const int timeout = dvr_prop_read_int("vendor.tv.libdvr.waittm",200);
hualing chen56c0a162022-01-27 17:01:50 +0800979
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800980 if (player->is_secure_mode) {
981 if (dec_buf_size > player->secure_buffer_size) {
Wentao MA96f68962022-06-15 19:45:35 +0800982 DVR_PB_INFO("playback blocksize too large");
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800983 return NULL;
984 }
985 }
wentao.maa210e5e2022-10-12 16:10:03 +0800986
987 uint8_t *buf = malloc(buf_len);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800988 if (!buf) {
Wentao MA96f68962022-06-15 19:45:35 +0800989 DVR_PB_INFO("Malloc buffer failed");
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800990 return NULL;
991 }
Wentao MA270dc0f2022-08-23 13:17:26 +0800992 input_buffer.buf_type = TS_INPUT_BUFFER_TYPE_NORMAL;
993 input_buffer.buf_size = 0;
hualing chencc91e1c2020-02-28 13:26:17 +0800994
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800995 dec_bufs.buf_data = malloc(dec_buf_size);
996 if (!dec_bufs.buf_data) {
Wentao MA96f68962022-06-15 19:45:35 +0800997 DVR_PB_INFO("Malloc dec buffer failed");
Pengfei Liufaf38e42020-05-22 00:28:02 +0800998 free(buf);
pengfei.liu07ddc8a2020-03-24 23:36:53 +0800999 return NULL;
1000 }
1001 dec_bufs.buf_type = TS_INPUT_BUFFER_TYPE_NORMAL;
1002 dec_bufs.buf_size = dec_buf_size;
1003
hualing chencc91e1c2020-02-28 13:26:17 +08001004 if (player->segment_is_open == DVR_FALSE) {
hualing chen5cbe1a62020-02-10 16:36:36 +08001005 ret = _change_to_next_segment((DVR_PlaybackHandle_t)player);
1006 }
hualing chen86e7d482020-01-16 15:13:33 +08001007
hualing chen86e7d482020-01-16 15:13:33 +08001008 if (ret != DVR_SUCCESS) {
1009 if (buf != NULL) {
1010 free(buf);
hualing chen86e7d482020-01-16 15:13:33 +08001011 }
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001012 free(dec_bufs.buf_data);
Wentao MA96f68962022-06-15 19:45:35 +08001013 DVR_PB_INFO("get segment error");
hualing chenb31a6c62020-01-13 17:27:00 +08001014 return NULL;
hualing chen86e7d482020-01-16 15:13:33 +08001015 }
Wentao MA96f68962022-06-15 19:45:35 +08001016 DVR_PB_INFO("--player->vendor %d,player->has_video[%d] bufsize[0x%x]whole block[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08001017 player->vendor, player->has_video, buf_len, b_writed_whole_block);
hualing chenfbf8e022020-06-15 13:43:11 +08001018 //get play statue not here,send ok event when vendor is aml or only audio channel if not send ok event
1019 if (((player->first_trans_ok == DVR_FALSE) && (player->vendor == DVR_PLAYBACK_VENDOR_AML) ) ||
1020 (player->first_trans_ok == DVR_FALSE && player->has_video == DVR_FALSE)) {
1021 player->first_trans_ok = DVR_TRUE;
1022 _dvr_playback_sent_transition_ok((DVR_PlaybackHandle_t)player, DVR_TRUE);
1023 }
hualing chencc91e1c2020-02-28 13:26:17 +08001024 _dvr_check_cur_segment_flag((DVR_PlaybackHandle_t)player);
hualing chen6d24aa92020-03-23 18:43:47 +08001025 //set video show
1026 AmTsPlayer_showVideo(player->handle);
hualing chen40dd5462021-11-26 19:56:20 +08001027 if (player->vendor == DVR_PLAYBACK_VENDOR_AMAZON)
1028 check_no_data_time = 8;
hualing chen86e7d482020-01-16 15:13:33 +08001029 int trick_stat = 0;
1030 while (player->is_running/* || player->cmd.last_cmd != player->cmd.cur_cmd*/) {
hualing chenb31a6c62020-01-13 17:27:00 +08001031
hualing chen86e7d482020-01-16 15:13:33 +08001032 //check trick stat
Wentao MA96f68962022-06-15 19:45:35 +08001033 //DVR_PB_INFO("lock check_no_data_time:%d", check_no_data_time);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001034 dvr_mutex_lock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08001035
Wentao MA907b6432022-08-01 06:23:08 +00001036 {
Wentao MA9a164002022-08-29 11:20:24 +08001037 static struct timespec _prev_ts={0,0};
Wentao MA907b6432022-08-01 06:23:08 +00001038 struct timespec _nowts,_diffts;
1039 clock_gettime(CLOCK_MONOTONIC, &_nowts);
Wentao MA9a164002022-08-29 11:20:24 +08001040 clock_timespec_subtract(&_nowts,&_prev_ts,&_diffts);
Wentao MA907b6432022-08-01 06:23:08 +00001041 if (_diffts.tv_sec>0) {
1042 char _logbuf[512]={0};
1043 char* _pbuf=_logbuf;
1044 int _nchar=0;
1045 DVR_PlaybackSegmentInfo_t* _segment;
wentao.mafd5283f2022-10-14 09:51:13 +08001046 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08001047 // prefetch() here incurring self_assign is used to avoid some compiling
1048 // warnings.
1049 // coverity[self_assign]
Wentao MA907b6432022-08-01 06:23:08 +00001050 list_for_each_entry(_segment, &player->segment_list, head) {
1051 if (player->cur_segment_id == _segment->segment_id) {
Wentao MAf35c3882023-04-17 12:36:19 +08001052 int seg_size = segment_get_cur_segment_size(player->segment_handle);
1053 int read_ptr = segment_tell_position(player->segment_handle);
Wentao MA907b6432022-08-01 06:23:08 +00001054 float progress = -1.0f;
Wentao MA9a164002022-08-29 11:20:24 +08001055 if (seg_size>0) {
1056 progress = (float)read_ptr*100/seg_size;
Wentao MA907b6432022-08-01 06:23:08 +00001057 }
Wentao MA4d85ff32022-09-23 11:36:18 +08001058 _nchar=sprintf(_pbuf,"%lld(%.1f%%), ",_segment->segment_id,progress);
Wentao MA907b6432022-08-01 06:23:08 +00001059 } else {
1060 _nchar=sprintf(_pbuf,"%lld, ",_segment->segment_id);
1061 }
1062 if (_nchar<0) {
1063 break;
1064 }
1065 _pbuf+=_nchar;
1066 if (_pbuf-_logbuf+10 >= sizeof(_logbuf)) {
1067 sprintf(_pbuf,"...");
1068 break;
1069 }
1070 }
Wentao MA9a164002022-08-29 11:20:24 +08001071 DVR_PB_INFO("clk: %08u, seg_list: %s",_nowts.tv_sec,_logbuf);
1072 _prev_ts=_nowts;
Wentao MA907b6432022-08-01 06:23:08 +00001073 }
1074 }
1075
hualing chen2aba4022020-03-02 13:49:55 +08001076 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_SEEK ||
1077 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
hualing chen31140872020-03-25 12:29:26 +08001078 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB ||
hualing chena540a7e2020-03-27 16:44:05 +08001079 player->speed > FF_SPEED ||player->speed <= FB_SPEED ||
hualing chen39628212020-05-14 10:35:13 +08001080 (player->state == DVR_PLAYBACK_STATE_PAUSE) ||
hualing chen31140872020-03-25 12:29:26 +08001081 (player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE)
hualing chen86e7d482020-01-16 15:13:33 +08001082 {
hualing chen2aba4022020-03-02 13:49:55 +08001083 trick_stat = _dvr_playback_get_trick_stat((DVR_PlaybackHandle_t)player);
dongsheng.Li98c618a2023-12-13 04:02:32 +00001084 if (trick_stat > 0 || (trick_stat <= 0 && _dvr_time_getClock() > player->next_fffb_time)) {
1085 DVR_PB_INFO("trick stat[%d], cur cmd[%d]last cmd[%d]flag[0x%x], now[%u]>next_fffb_time[%u]",
1086 trick_stat, player->cmd.cur_cmd, player->cmd.last_cmd, player->play_flag, _dvr_time_getClock(), player->next_fffb_time);
hualing chen87072a82020-03-12 16:20:12 +08001087 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_SEEK || (player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE) {
hualing chen2aba4022020-03-02 13:49:55 +08001088 //check last cmd
hualing chenbcada022020-04-22 14:27:01 +08001089 if (player->cmd.last_cmd == DVR_PLAYBACK_CMD_PAUSE
hualing chen31140872020-03-25 12:29:26 +08001090 || ((player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE
hualing chen87072a82020-03-12 16:20:12 +08001091 && ( player->cmd.cur_cmd == DVR_PLAYBACK_CMD_START
Wentao MA270dc0f2022-08-23 13:17:26 +08001092 ||player->cmd.last_cmd == DVR_PLAYBACK_CMD_V_START
1093 || player->cmd.last_cmd == DVR_PLAYBACK_CMD_A_START
hualing chen2aba4022020-03-02 13:49:55 +08001094 || player->cmd.last_cmd == DVR_PLAYBACK_CMD_START))) {
Wentao MA96f68962022-06-15 19:45:35 +08001095 DVR_PB_INFO("pause play-------cur cmd[%d]last cmd[%d]flag[0x%x]",
hualing chen03fd4942021-07-15 15:56:41 +08001096 player->cmd.cur_cmd, player->cmd.last_cmd, player->play_flag);
hualing chen2aba4022020-03-02 13:49:55 +08001097 //need change to pause state
1098 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_PAUSE;
1099 player->cmd.state = DVR_PLAYBACK_STATE_PAUSE;
Wentao MA907b6432022-08-01 06:23:08 +00001100 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_PAUSE);
hualing chen87072a82020-03-12 16:20:12 +08001101 //clear flag
hualing chen31140872020-03-25 12:29:26 +08001102 player->play_flag = player->play_flag & (~DVR_PLAYBACK_STARTED_PAUSEDLIVE);
hualing chena540a7e2020-03-27 16:44:05 +08001103 player->first_frame = 0;
hualing chen10cdb162021-02-05 10:44:41 +08001104 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
hualing chen2aba4022020-03-02 13:49:55 +08001105 AmTsPlayer_pauseVideoDecoding(player->handle);
1106 AmTsPlayer_pauseAudioDecoding(player->handle);
Wentao MA6dcdc342023-01-30 17:03:19 +08001107
1108 // Audio is unmuted here, for it was muted before receiving first frame event.
1109 if (player->cur_segment.flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) {
1110 AmTsPlayer_setAudioMute(player->handle,0,0);
1111 }
hualing chen2bd8a7a2020-04-02 11:31:03 +08001112 } else {
Wentao MA96f68962022-06-15 19:45:35 +08001113 DVR_PB_INFO("clear first frame value-------");
hualing chen2bd8a7a2020-04-02 11:31:03 +08001114 player->first_frame = 0;
hualing chen2aba4022020-03-02 13:49:55 +08001115 }
1116 } else if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF
1117 || player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB
hualing chena540a7e2020-03-27 16:44:05 +08001118 ||player->speed > FF_SPEED ||player->speed < FB_SPEED) {
hualing chen2aba4022020-03-02 13:49:55 +08001119 //restart play stream if speed > 2
hualing chenb5cd42e2020-04-15 17:03:34 +08001120 if (player->state == DVR_PLAYBACK_STATE_PAUSE) {
Wentao MA96f68962022-06-15 19:45:35 +08001121 DVR_PB_INFO("fffb pause state----speed[%f] fffb cur[%u] cur sys[%u] [%s] [%u]",
hualing chen03fd4942021-07-15 15:56:41 +08001122 player->speed,
1123 player->fffb_current,
1124 _dvr_time_getClock(),
1125 _dvr_playback_state_toString(player->state),
1126 player->next_fffb_time);
hualing chen2aba4022020-03-02 13:49:55 +08001127 //used timeout wait need lock first,so we unlock and lock
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001128 //dvr_mutex_unlock(&player->lock);
1129 //dvr_mutex_lock(&player->lock);
hualing chen2aba4022020-03-02 13:49:55 +08001130 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
Wentao MA96f68962022-06-15 19:45:35 +08001131 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001132 dvr_mutex_unlock(&player->lock);
hualing chen2aba4022020-03-02 13:49:55 +08001133 continue;
hualing chenb5cd42e2020-04-15 17:03:34 +08001134 } else if (_dvr_time_getClock() < player->next_fffb_time) {
Wentao MA96f68962022-06-15 19:45:35 +08001135 DVR_PB_INFO("fffb timeout-to pause video---speed[%f] fffb cur[%u] cur sys[%u] [%s] [%u]",
hualing chen03fd4942021-07-15 15:56:41 +08001136 player->speed,
1137 player->fffb_current,
1138 _dvr_time_getClock(),
1139 _dvr_playback_state_toString(player->state),
1140 player->next_fffb_time);
hualing chenb5cd42e2020-04-15 17:03:34 +08001141 //used timeout wait need lock first,so we unlock and lock
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001142 //dvr_mutex_unlock(&player->lock);
1143 //dvr_mutex_lock(&player->lock);
hualing chenb5cd42e2020-04-15 17:03:34 +08001144 AmTsPlayer_pauseVideoDecoding(player->handle);
1145 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
Wentao MA96f68962022-06-15 19:45:35 +08001146 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001147 dvr_mutex_unlock(&player->lock);
hualing chenb5cd42e2020-04-15 17:03:34 +08001148 continue;
hualing chen2aba4022020-03-02 13:49:55 +08001149 }
Wentao MA96f68962022-06-15 19:45:35 +08001150 DVR_PB_INFO("fffb play-------speed[%f][%d][%d][%s][%d]",
hualing chen03fd4942021-07-15 15:56:41 +08001151 player->speed,
1152 goto_rewrite,
1153 real_read,
1154 _dvr_playback_state_toString(player->state),
1155 player->cmd.cur_cmd);
hualing chen2aba4022020-03-02 13:49:55 +08001156 goto_rewrite = DVR_FALSE;
hualing chen87072a82020-03-12 16:20:12 +08001157 real_read = 0;
hualing chena540a7e2020-03-27 16:44:05 +08001158 player->play_flag = player->play_flag & (~DVR_PLAYBACK_STARTED_PAUSEDLIVE);
1159 player->first_frame = 0;
Wentao MA96f68962022-06-15 19:45:35 +08001160 DVR_PB_INFO("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001161 dvr_mutex_unlock(&player->lock);
1162
hualing chen2aba4022020-03-02 13:49:55 +08001163 _dvr_playback_fffb((DVR_PlaybackHandle_t)player);
Wentao MA96f68962022-06-15 19:45:35 +08001164 DVR_PB_DEBUG("lock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001165 dvr_mutex_lock(&player->lock);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001166 player->fffb_play = DVR_FALSE;
hualing chen1ffd85b2021-08-16 15:18:43 +08001167 } else if(player->state == DVR_PLAYBACK_STATE_PAUSE) {
1168 //on pause state,user seek to new pos,we need pause and wait
1169 //user to resume
Wentao MA96f68962022-06-15 19:45:35 +08001170 DVR_PB_INFO("pause, when got first frame event when user seek end");
hualing chen1ffd85b2021-08-16 15:18:43 +08001171 player->first_frame = 0;
1172 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
1173 AmTsPlayer_pauseVideoDecoding(player->handle);
1174 AmTsPlayer_pauseAudioDecoding(player->handle);
hualing chen86e7d482020-01-16 15:13:33 +08001175 }
hualing chen1ffd85b2021-08-16 15:18:43 +08001176 } else if (player->fffb_play == DVR_TRUE){
hualing chen4b7c15d2020-04-07 16:13:48 +08001177 //for first into fffb when reset speed
1178 if (player->state == DVR_PLAYBACK_STATE_PAUSE ||
1179 _dvr_time_getClock() < player->next_fffb_time) {
Wentao MA96f68962022-06-15 19:45:35 +08001180 DVR_PB_INFO("fffb timeout-fffb play---speed[%f] fffb cur[%u] cur sys[%u] [%s] [%u]",
hualing chen03fd4942021-07-15 15:56:41 +08001181 player->speed,
1182 player->fffb_current,
1183 _dvr_time_getClock(),
1184 _dvr_playback_state_toString(player->state),
1185 player->next_fffb_time);
hualing chen4b7c15d2020-04-07 16:13:48 +08001186 //used timeout wait need lock first,so we unlock and lock
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001187 //dvr_mutex_unlock(&player->lock);
1188 //dvr_mutex_lock(&player->lock);
hualing chen4b7c15d2020-04-07 16:13:48 +08001189 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
Wentao MA96f68962022-06-15 19:45:35 +08001190 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001191 dvr_mutex_unlock(&player->lock);
hualing chen4b7c15d2020-04-07 16:13:48 +08001192 continue;
1193 }
Wentao MA96f68962022-06-15 19:45:35 +08001194 DVR_PB_INFO("fffb replay-------speed[%f][%d][%d][%s][%d]player->fffb_play[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08001195 player->speed,
1196 goto_rewrite,
1197 real_read,
1198 _dvr_playback_state_toString(player->state),
1199 player->cmd.cur_cmd,
1200 player->fffb_play);
Wentao MA96f68962022-06-15 19:45:35 +08001201 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001202 dvr_mutex_unlock(&player->lock);
hualing chen4b7c15d2020-04-07 16:13:48 +08001203 goto_rewrite = DVR_FALSE;
1204 real_read = 0;
Wentao MA63c6cba2022-09-20 10:14:29 +08001205 pthread_mutex_lock(&player->segment_lock);
hualing chen5605eed2020-05-26 18:18:06 +08001206 player->ts_cache_len = 0;
hualing chen4b7c15d2020-04-07 16:13:48 +08001207 player->play_flag = player->play_flag & (~DVR_PLAYBACK_STARTED_PAUSEDLIVE);
1208 player->first_frame = 0;
Wentao MA63c6cba2022-09-20 10:14:29 +08001209 pthread_mutex_unlock(&player->segment_lock);
hualing chen4b7c15d2020-04-07 16:13:48 +08001210 _dvr_playback_fffb((DVR_PlaybackHandle_t)player);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001211 dvr_mutex_lock(&player->lock);
hualing chen4b7c15d2020-04-07 16:13:48 +08001212 player->fffb_play = DVR_FALSE;
hualing chen2aba4022020-03-02 13:49:55 +08001213 }
hualing chenb31a6c62020-01-13 17:27:00 +08001214 }
hualing chen86e7d482020-01-16 15:13:33 +08001215
hualing chen30423862021-04-16 14:39:12 +08001216 if (player->state == DVR_PLAYBACK_STATE_PAUSE
1217 && player->seek_pause == DVR_FALSE) {
hualing chen6e4bfa52020-03-13 14:37:11 +08001218 //check is need send time send end
Wentao MA96f68962022-06-15 19:45:35 +08001219 DVR_PB_INFO("pause, continue");
1220 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001221 dvr_mutex_unlock(&player->lock);
hualing chen2932d372020-04-29 13:44:00 +08001222 _dvr_playback_sent_playtime((DVR_PlaybackHandle_t)player, DVR_FALSE);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001223 dvr_mutex_lock(&player->lock);
hualing chen87072a82020-03-12 16:20:12 +08001224 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
Wentao MA96f68962022-06-15 19:45:35 +08001225 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001226 dvr_mutex_unlock(&player->lock);
hualing chen87072a82020-03-12 16:20:12 +08001227 continue;
1228 }
hualing chen266b9502020-04-04 17:39:39 +08001229 //when seek action is done. we need drop write timeout data.
1230 if (player->drop_ts == DVR_TRUE) {
1231 goto_rewrite = DVR_FALSE;
1232 real_read = 0;
1233 player->drop_ts = DVR_FALSE;
1234 }
hualing chen2aba4022020-03-02 13:49:55 +08001235 if (goto_rewrite == DVR_TRUE) {
1236 goto_rewrite = DVR_FALSE;
Wentao MA96f68962022-06-15 19:45:35 +08001237 //DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001238 dvr_mutex_unlock(&player->lock);
hualing chen3bcf3be2021-12-22 20:15:01 +08001239 _dvr_playback_sent_playtime((DVR_PlaybackHandle_t)player, DVR_FALSE);
Wentao MA96f68962022-06-15 19:45:35 +08001240 //DVR_PB_INFO("rewrite-player->speed[%f]", player->speed);
hualing chen2aba4022020-03-02 13:49:55 +08001241 goto rewrite;
1242 }
hualing chen6e4bfa52020-03-13 14:37:11 +08001243 //.check is need send time send end
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001244 dvr_mutex_unlock(&player->lock);
hualing chen2932d372020-04-29 13:44:00 +08001245 _dvr_playback_sent_playtime((DVR_PlaybackHandle_t)player, DVR_FALSE);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001246 dvr_mutex_lock(&player->lock);
hualing chen4b7c15d2020-04-07 16:13:48 +08001247 pthread_mutex_lock(&player->segment_lock);
Wentao MA96f68962022-06-15 19:45:35 +08001248 //DVR_PB_INFO("start read");
Wentao MAf35c3882023-04-17 12:36:19 +08001249 read = segment_read(player->segment_handle, buf + real_read, buf_len - real_read);
hualing chen21a40372021-10-29 11:07:26 +08001250 real_read = real_read + read;
1251 player->ts_cache_len = real_read;
Wentao MA96f68962022-06-15 19:45:35 +08001252 //DVR_PB_INFO("start read end [%d]", read);
hualing chen4b7c15d2020-04-07 16:13:48 +08001253 pthread_mutex_unlock(&player->segment_lock);
Wentao MA96f68962022-06-15 19:45:35 +08001254 //DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001255 dvr_mutex_unlock(&player->lock);
hualing chenb5cd42e2020-04-15 17:03:34 +08001256 if (read < 0 && errno == EIO) {
1257 //EIO ERROR, EXIT THRAD
Wentao MA96f68962022-06-15 19:45:35 +08001258 DVR_PB_INFO("read error.EIO error, exit thread");
hualing chenb5cd42e2020-04-15 17:03:34 +08001259 DVR_Play_Notify_t notify;
1260 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
1261 notify.event = DVR_PLAYBACK_EVENT_ERROR;
hualing chen9b434f02020-06-10 15:06:54 +08001262 notify.info.error_reason = DVR_ERROR_REASON_READ;
hualing chen2932d372020-04-29 13:44:00 +08001263 _dvr_playback_sent_event((DVR_PlaybackHandle_t)player,DVR_PLAYBACK_EVENT_ERROR, &notify, DVR_TRUE);
hualing chenb5cd42e2020-04-15 17:03:34 +08001264 goto end;
1265 } else if (read < 0) {
Wentao MA96f68962022-06-15 19:45:35 +08001266 DVR_PB_INFO("read error.:%d EIO:%d", errno, EIO);
hualing chenb5cd42e2020-04-15 17:03:34 +08001267 }
hualing chen87072a82020-03-12 16:20:12 +08001268 //if on fb mode and read file end , we need calculate pos to retry read.
1269 if (read == 0 && IS_FB(player->speed) && real_read == 0) {
Wentao MA96f68962022-06-15 19:45:35 +08001270 DVR_PB_INFO("recalculate read [%d] readed [%d]buf_len[%d]speed[%f]id=[%llu]",
hualing chen03fd4942021-07-15 15:56:41 +08001271 read,
1272 real_read,
1273 buf_len,
1274 player->speed,
1275 player->cur_segment_id);
hualing chen87072a82020-03-12 16:20:12 +08001276 _dvr_playback_calculate_seekpos((DVR_PlaybackHandle_t)player);
Wentao MA96f68962022-06-15 19:45:35 +08001277 DVR_PB_DEBUG("lock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001278 dvr_mutex_lock(&player->lock);
hualing chen2aba4022020-03-02 13:49:55 +08001279 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
Wentao MA96f68962022-06-15 19:45:35 +08001280 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001281 dvr_mutex_unlock(&player->lock);
hualing chen2aba4022020-03-02 13:49:55 +08001282 continue;
1283 }
Wentao MA96f68962022-06-15 19:45:35 +08001284 //DVR_PB_INFO("read ts [%d]buf_len[%d]speed[%f]real_read:%d", read, buf_len, player->speed, real_read);
hualing chen86e7d482020-01-16 15:13:33 +08001285 if (read == 0) {
hualing chen2aba4022020-03-02 13:49:55 +08001286 //file end.need to play next segment
hualing chene41f4372020-06-06 16:29:17 +08001287 #define MIN_CACHE_TIME (3000)
Wentao MA804bab12022-11-29 10:01:26 +08001288 int delay = 0;
1289 get_effective_tsplayer_delay_time(player,&delay);
hualing chene3797f02021-01-13 14:53:28 +08001290 /*if cache time is > min cache time ,not read next segment,wait cache data to play*/
Wentao MA804bab12022-11-29 10:01:26 +08001291 if (delay > MIN_CACHE_TIME) {
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001292 //dvr_mutex_lock(&player->lock);
hualing chene3797f02021-01-13 14:53:28 +08001293 /*if cache time > 20s , we think get time is error,*/
Wentao MA804bab12022-11-29 10:01:26 +08001294 if (delay - MIN_CACHE_TIME > 20 * 1000) {
1295 DVR_PB_WARN("read end but cache time is %d > 20s, this is an error at media_hal", delay);
hualing chene3797f02021-01-13 14:53:28 +08001296 }
hualing chene41f4372020-06-06 16:29:17 +08001297 }
hualing chen969fe7b2021-05-26 15:13:17 +08001298
hualing chen040df222020-01-17 13:35:02 +08001299 int ret = _change_to_next_segment((DVR_PlaybackHandle_t)player);
hualing chen2aba4022020-03-02 13:49:55 +08001300 //init fffb time if change segment
hualing chen041c4092020-04-05 15:11:50 +08001301 _dvr_init_fffb_time((DVR_PlaybackHandle_t)player);
hualing chen31140872020-03-25 12:29:26 +08001302
Wentao MA804bab12022-11-29 10:01:26 +08001303 get_effective_tsplayer_delay_time(player,&delay);
hualing chen1679f812021-11-08 15:17:46 +08001304 if (ret != DVR_SUCCESS && delay < MIN_TSPLAYER_DELAY_TIME) {
1305 player->noData++;
Wentao MA96f68962022-06-15 19:45:35 +08001306 DVR_PB_INFO("playback nodata[%d]", player->noData);
hualing chen40dd5462021-11-26 19:56:20 +08001307 if (player->noData == check_no_data_time) {
Wentao MA96f68962022-06-15 19:45:35 +08001308 DVR_PB_INFO("playback send nodata event nodata[%d]", player->noData);
hualing chene3797f02021-01-13 14:53:28 +08001309 //send event here and pause
1310 DVR_Play_Notify_t notify;
1311 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
1312 notify.event = DVR_PLAYBACK_EVENT_NODATA;
Wentao MA96f68962022-06-15 19:45:35 +08001313 DVR_PB_INFO("send event DVR_PLAYBACK_EVENT_NODATA--");
hualing chene3797f02021-01-13 14:53:28 +08001314 //get play statue not here
1315 _dvr_playback_sent_event((DVR_PlaybackHandle_t)player, DVR_PLAYBACK_EVENT_NODATA, &notify, DVR_FALSE);
1316 }
1317 }
Wentao MAa0b9c002022-11-10 17:47:27 +08001318
1319 DVR_Bool_t cond1 = (ret != DVR_SUCCESS);
1320 DVR_Bool_t cond2 = (player->vendor != DVR_PLAYBACK_VENDOR_AMAZON);
1321 DVR_Bool_t cond3 = (delay <= MIN_TSPLAYER_DELAY_TIME);
1322 DVR_Bool_t cond4 = (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF);
1323 DVR_Bool_t cond5 = (player->delay_is_effective == DVR_TRUE);
1324 DVR_Bool_t cond6 = (reach_end_timeout >= MAX_REACHEND_TIMEOUT);
1325 if ((cond1 && cond2 && (cond3 || cond4) && cond5) || cond6) {
1326 DVR_PB_INFO("REACHED_END conditions: cond1:%d, cond2:%d, (cond3:%d, cond4:%d),"
1327 " cond5:%d, cond6:%d. delay:%d, reach_end_timeout:%d",
1328 (int)cond1,(int)cond2,(int)cond3,(int)cond4,(int)cond5,(int)cond6,
1329 delay,reach_end_timeout);
Wentao MA804bab12022-11-29 10:01:26 +08001330 DVR_Play_Notify_t notify;
1331 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
1332 notify.event = DVR_PLAYBACK_EVENT_REACHED_END;
1333 dvr_playback_pause((DVR_PlaybackHandle_t)player, DVR_FALSE);
1334 _dvr_playback_sent_event((DVR_PlaybackHandle_t)player, DVR_PLAYBACK_EVENT_REACHED_END, &notify, DVR_TRUE);
1335 dvr_mutex_lock(&player->lock);
1336 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
1337 dvr_mutex_unlock(&player->lock);
1338 continue;
1339 } else if (ret != DVR_SUCCESS) {
1340 DVR_PB_INFO("delay:%d pauselive:%d", delay, _dvr_pauselive_decode_success((DVR_PlaybackHandle_t)player));
1341 dvr_mutex_lock(&player->lock);
1342 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
1343 dvr_mutex_unlock(&player->lock);
1344
1345 get_effective_tsplayer_delay_time(player,&delay);
1346 //not send event and pause,sleep and go to next time to recheck
1347 if (delay < cache_time) {
1348 //delay time is changed and then has data to play, so not start timeout
1349 reach_end_timeout = 0;
1350 } else {
1351 reach_end_timeout = reach_end_timeout + timeout;
1352 }
1353 cache_time = delay;
1354 continue;
1355 }
hualing chen39628212020-05-14 10:35:13 +08001356 reach_end_timeout = 0;
1357 cache_time = 0;
hualing chen2932d372020-04-29 13:44:00 +08001358 //change next segment success case
1359 _dvr_playback_sent_transition_ok((DVR_PlaybackHandle_t)player, DVR_FALSE);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001360 dvr_mutex_lock(&player->lock);
hualing chen40dd5462021-11-26 19:56:20 +08001361 player->noData = 0;
Wentao MA96f68962022-06-15 19:45:35 +08001362 DVR_PB_INFO("_dvr_replay_changed_pid:start");
hualing chencc91e1c2020-02-28 13:26:17 +08001363 _dvr_replay_changed_pid((DVR_PlaybackHandle_t)player);
1364 _dvr_check_cur_segment_flag((DVR_PlaybackHandle_t)player);
hualing chen21a40372021-10-29 11:07:26 +08001365 pthread_mutex_lock(&player->segment_lock);
Wentao MAf35c3882023-04-17 12:36:19 +08001366 read = segment_read(player->segment_handle, buf + real_read, buf_len - real_read);
hualing chen21a40372021-10-29 11:07:26 +08001367 real_read = real_read + read;
1368 player->ts_cache_len = real_read;
1369 pthread_mutex_unlock(&player->segment_lock);
1370
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001371 dvr_mutex_unlock(&player->lock);
hualing chene3797f02021-01-13 14:53:28 +08001372 }//read len 0 check end
Wentao MA92a14892023-09-12 18:54:47 +08001373
1374#ifdef FOR_SKYWORTH_FETCH_RDK
1375 if (player->openParams.is_timeshift == DVR_TRUE && player->speed >= FF_SPEED)
1376 {
1377 DVR_PlaybackSegmentInfo_t *newest_segment
1378 = list_last_entry(&player->segment_list, DVR_PlaybackSegmentInfo_t, head);
1379 DVR_Bool_t cond1 = (player->cur_segment_id == newest_segment->segment_id);
1380 int32_t time_end = _dvr_get_end_time((DVR_PlaybackHandle_t)player);
1381 uint64_t cur_seg_id = 0;
1382 int32_t time_cur = _dvr_get_play_cur_time((DVR_PlaybackHandle_t)player, &cur_seg_id);
1383 DVR_Bool_t cond2 = (cur_seg_id == player->cur_segment_id && time_end - time_cur < 1000);
1384 if (cond1 && cond2)
1385 {
1386 DVR_PlaybackSpeed_t normal_speed = {PLAYBACK_SPEED_X1,0};
1387 DVR_PB_INFO("Change to normal speed due to FF reaching end");
1388 dvr_playback_set_speed((DVR_PlaybackHandle_t)player,normal_speed);
Wentao MA9e31f692023-09-26 17:42:18 +08001389
1390 DVR_Play_Notify_t notify;
1391 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
1392 notify.event = DVR_PLAYBACK_EVENT_TIMESHIFT_FF_REACHED_END;
1393 _dvr_playback_sent_event((DVR_PlaybackHandle_t)player, notify.event, &notify, 0);
Wentao MA92a14892023-09-12 18:54:47 +08001394 }
1395 }
1396#endif
1397
hualing chen40dd5462021-11-26 19:56:20 +08001398 if (player->noData >= check_no_data_time) {
hualing chene3797f02021-01-13 14:53:28 +08001399 player->noData = 0;
Wentao MA96f68962022-06-15 19:45:35 +08001400 DVR_PB_INFO("playback send data event resume[%d]", player->noData);
hualing chene3797f02021-01-13 14:53:28 +08001401 //send event here and pause
1402 DVR_Play_Notify_t notify;
1403 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
1404 notify.event = DVR_PLAYBACK_EVENT_DATARESUME;
Wentao MA96f68962022-06-15 19:45:35 +08001405 DVR_PB_INFO("----send event DVR_PLAYBACK_EVENT_DATARESUME");
hualing chene3797f02021-01-13 14:53:28 +08001406 //get play statue not here
1407 _dvr_playback_sent_event((DVR_PlaybackHandle_t)player, DVR_PLAYBACK_EVENT_DATARESUME, &notify, DVR_FALSE);
hualing chen86e7d482020-01-16 15:13:33 +08001408 }
hualing chen39628212020-05-14 10:35:13 +08001409 reach_end_timeout = 0;
hualing chen21a40372021-10-29 11:07:26 +08001410 //real_read = real_read + read;
Wentao MA270dc0f2022-08-23 13:17:26 +08001411 input_buffer.buf_size = real_read;
1412 input_buffer.buf_data = buf;
hualing chen5605eed2020-05-26 18:18:06 +08001413
Wentao MA270dc0f2022-08-23 13:17:26 +08001414 //check read data len,if len < 0, we need continue
1415 if (input_buffer.buf_size <= 0 || input_buffer.buf_data == NULL) {
1416 DVR_PB_INFO("error occur read_read [%d],buf=[%p]",input_buffer.buf_size, input_buffer.buf_data);
hualing chen5cbe1a62020-02-10 16:36:36 +08001417 real_read = 0;
Wentao MA63c6cba2022-09-20 10:14:29 +08001418 pthread_mutex_lock(&player->segment_lock);
hualing chen5605eed2020-05-26 18:18:06 +08001419 player->ts_cache_len = 0;
Wentao MA63c6cba2022-09-20 10:14:29 +08001420 pthread_mutex_unlock(&player->segment_lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08001421 continue;
hualing chena540a7e2020-03-27 16:44:05 +08001422 }
hualing chen266b9502020-04-04 17:39:39 +08001423 //if need write whole block size, we need check read buf len is eq block size.
Wentao MAa0b9c002022-11-10 17:47:27 +08001424 if (b_writed_whole_block == DVR_TRUE
1425 && (player->has_video || player->dec_func || player->cryptor)) {
hualing chen266b9502020-04-04 17:39:39 +08001426 //buf_len is block size value.
1427 if (real_read < buf_len) {
Wentao MA270dc0f2022-08-23 13:17:26 +08001428 //continue to read data from file
Wentao MA96f68962022-06-15 19:45:35 +08001429 DVR_PB_INFO("read buf len[%d] is < block size [%d]", real_read, buf_len);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001430 dvr_mutex_lock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08001431 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
1432 dvr_mutex_unlock(&player->lock);
1433 DVR_PB_INFO("read buf len[%d] is < block size [%d] continue", real_read, buf_len);
hualing chen266b9502020-04-04 17:39:39 +08001434 continue;
1435 } else if (real_read > buf_len) {
Wentao MA96f68962022-06-15 19:45:35 +08001436 DVR_PB_INFO("read buf len[%d] is > block size [%d],this error occur", real_read, buf_len);
hualing chen266b9502020-04-04 17:39:39 +08001437 }
1438 }
1439
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001440 if (player->dec_func) {
pengfei.liu27cc4ec2020-04-03 16:28:16 +08001441 DVR_CryptoParams_t crypto_params;
1442
1443 memset(&crypto_params, 0, sizeof(crypto_params));
1444 crypto_params.type = DVR_CRYPTO_TYPE_DECRYPT;
1445 memcpy(crypto_params.location, player->cur_segment.location, strlen(player->cur_segment.location));
1446 crypto_params.segment_id = player->cur_segment.segment_id;
Wentao MAf35c3882023-04-17 12:36:19 +08001447 crypto_params.offset = segment_tell_position(player->segment_handle) - input_buffer.buf_size;
hualing chenbafc62d2020-11-02 15:44:05 +08001448 if ((crypto_params.offset % (player->openParams.block_size)) != 0)
Wentao MA96f68962022-06-15 19:45:35 +08001449 DVR_PB_INFO("offset is not block_size %d", player->openParams.block_size);
pengfei.liu27cc4ec2020-04-03 16:28:16 +08001450 crypto_params.input_buffer.type = DVR_BUFFER_TYPE_NORMAL;
1451 crypto_params.input_buffer.addr = (size_t)buf;
1452 crypto_params.input_buffer.size = real_read;
1453
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001454 if (player->is_secure_mode) {
1455 crypto_params.output_buffer.type = DVR_BUFFER_TYPE_SECURE;
1456 crypto_params.output_buffer.addr = (size_t)player->secure_buffer;
1457 crypto_params.output_buffer.size = dec_buf_size;
1458 ret = player->dec_func(&crypto_params, player->dec_userdata);
Wentao MA270dc0f2022-08-23 13:17:26 +08001459 input_buffer.buf_data = player->secure_buffer;
1460 input_buffer.buf_type = TS_INPUT_BUFFER_TYPE_SECURE;
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001461 if (ret != DVR_SUCCESS) {
Wentao MA96f68962022-06-15 19:45:35 +08001462 DVR_PB_INFO("decrypt failed");
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001463 }
Wentao MA270dc0f2022-08-23 13:17:26 +08001464 input_buffer.buf_size = crypto_params.output_size;
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001465 } else { // only for NAGRA
1466 crypto_params.output_buffer.type = crypto_params.input_buffer.type;
1467 crypto_params.output_buffer.addr = (size_t)dec_bufs.buf_data;
1468 crypto_params.output_buffer.size = crypto_params.input_buffer.size;
1469 ret = player->dec_func(&crypto_params, player->dec_userdata);
Wentao MA270dc0f2022-08-23 13:17:26 +08001470 input_buffer.buf_data = (uint8_t*)crypto_params.output_buffer.addr;
1471 input_buffer.buf_type = TS_INPUT_BUFFER_TYPE_NORMAL;
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001472 if (ret != DVR_SUCCESS) {
Wentao MA96f68962022-06-15 19:45:35 +08001473 DVR_PB_INFO("decrypt failed");
weishi.zhang0a6d5c82021-12-13 14:05:31 +08001474 }
Wentao MA270dc0f2022-08-23 13:17:26 +08001475 input_buffer.buf_size = crypto_params.output_buffer.size;
pengfei.liu27cc4ec2020-04-03 16:28:16 +08001476 }
Yahui Han1fbf3292021-11-08 18:17:19 +08001477 } else if (player->cryptor) {
Yahui Han63b23b42021-12-07 15:37:46 +08001478 int len = real_read;
Yahui Han1fbf3292021-11-08 18:17:19 +08001479 am_crypt_des_crypt(player->cryptor, dec_bufs.buf_data, buf, &len, 1);
Wentao MA270dc0f2022-08-23 13:17:26 +08001480 input_buffer.buf_data = dec_bufs.buf_data;
1481 input_buffer.buf_type = TS_INPUT_BUFFER_TYPE_NORMAL;
1482 input_buffer.buf_size = len;
pengfei.liu27cc4ec2020-04-03 16:28:16 +08001483 }
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001484rewrite:
hualing chenbcada022020-04-22 14:27:01 +08001485 if (player->drop_ts == DVR_TRUE) {
1486 //need drop ts data when seek occur.we need read next loop,drop this ts data
1487 goto_rewrite = DVR_FALSE;
1488 real_read = 0;
Wentao MA63c6cba2022-09-20 10:14:29 +08001489 pthread_mutex_lock(&player->segment_lock);
hualing chen5605eed2020-05-26 18:18:06 +08001490 player->ts_cache_len = 0;
hualing chenbcada022020-04-22 14:27:01 +08001491 player->drop_ts = DVR_FALSE;
Wentao MA63c6cba2022-09-20 10:14:29 +08001492 pthread_mutex_unlock(&player->segment_lock);
1493 DVR_PB_INFO("----drop ts");
hualing chenbcada022020-04-22 14:27:01 +08001494 continue;
1495 }
hualing chen21a40372021-10-29 11:07:26 +08001496
1497 pthread_mutex_lock(&player->segment_lock);
hualing chen5605eed2020-05-26 18:18:06 +08001498 player->ts_cache_len = real_read;
hualing chenb9a02922021-12-14 11:29:47 +08001499 //used for printf first write data time.
1500 //to check change channel kpi.
1501 if (first_write == 0) {
1502 first_write++;
Wentao MA270dc0f2022-08-23 13:17:26 +08001503 DVR_PB_INFO("----first write ts data");
hualing chenb9a02922021-12-14 11:29:47 +08001504 }
1505
Wentao MA270dc0f2022-08-23 13:17:26 +08001506 ret = AmTsPlayer_writeData(player->handle, &input_buffer, write_timeout_ms);
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001507 if (ret == AM_TSPLAYER_OK) {
hualing chen5605eed2020-05-26 18:18:06 +08001508 player->ts_cache_len = 0;
hualing chen21a40372021-10-29 11:07:26 +08001509 pthread_mutex_unlock(&player->segment_lock);
hualing chena540a7e2020-03-27 16:44:05 +08001510 real_read = 0;
1511 write_success++;
shenghui.gengbec6a462023-01-12 15:21:02 +08001512 if (player->control_speed_enable == 1) {
hualing chend241c7a2021-06-22 13:34:27 +08001513check0:
Yahui Hanc7ab63d2022-08-29 15:59:08 +08001514 if (!player->is_running) {
Yahui Han28c66ed2022-09-08 10:32:33 +08001515 //DVR_PB_DEBUG(1, "playback thread exit");
Yahui Hanc7ab63d2022-08-29 15:59:08 +08001516 break;
1517 }
hualing chend241c7a2021-06-22 13:34:27 +08001518 if (_dvr_check_speed_con((DVR_PlaybackHandle_t)player) == DVR_FALSE){
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001519 dvr_mutex_lock(&player->lock);
hualing chend241c7a2021-06-22 13:34:27 +08001520 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, 50);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001521 dvr_mutex_unlock(&player->lock);
hualing chend241c7a2021-06-22 13:34:27 +08001522 _dvr_playback_sent_playtime((DVR_PlaybackHandle_t)player, DVR_FALSE);
1523 goto check0;
1524 }
1525 }
Wentao MA270dc0f2022-08-23 13:17:26 +08001526 //DVR_PB_INFO("write write_success:%d input_buffer.buf_size:%d", write_success, input_buffer.buf_size);
hualing chen87072a82020-03-12 16:20:12 +08001527 } else {
Wentao MA804bab12022-11-29 10:01:26 +08001528 pthread_mutex_unlock(&player->segment_lock);
wentao.ma4ee43022022-12-14 13:22:57 +08001529 DVR_PB_DEBUG("write time out write_success:%d buf_size:%d systime:%u",
1530 write_success, input_buffer.buf_size, _dvr_time_getClock());
hualing chena540a7e2020-03-27 16:44:05 +08001531 write_success = 0;
shenghui.gengbec6a462023-01-12 15:21:02 +08001532 if (player->control_speed_enable == 1) {
hualing chend241c7a2021-06-22 13:34:27 +08001533check1:
Yahui Hanc7ab63d2022-08-29 15:59:08 +08001534 if (!player->is_running) {
Yahui Han28c66ed2022-09-08 10:32:33 +08001535 //DVR_PB_DEBUG(1, "playback thread exit");
Yahui Hanc7ab63d2022-08-29 15:59:08 +08001536 break;
1537 }
hualing chend241c7a2021-06-22 13:34:27 +08001538 if (_dvr_check_speed_con((DVR_PlaybackHandle_t)player) == DVR_FALSE){
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001539 dvr_mutex_lock(&player->lock);
hualing chend241c7a2021-06-22 13:34:27 +08001540 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, 50);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001541 dvr_mutex_unlock(&player->lock);
hualing chend241c7a2021-06-22 13:34:27 +08001542 _dvr_playback_sent_playtime((DVR_PlaybackHandle_t)player, DVR_FALSE);
1543 goto check1;
1544 }
1545 }
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001546 dvr_mutex_lock(&player->lock);
hualing chen040df222020-01-17 13:35:02 +08001547 _dvr_playback_timeoutwait((DVR_PlaybackHandle_t)player, timeout);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001548 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08001549 if (!player->is_running) {
Wentao MA96f68962022-06-15 19:45:35 +08001550 DVR_PB_INFO("playback thread exit");
hualing chen86e7d482020-01-16 15:13:33 +08001551 break;
1552 }
hualing chen2aba4022020-03-02 13:49:55 +08001553 goto_rewrite = DVR_TRUE;
1554 //goto rewrite;
hualing chen86e7d482020-01-16 15:13:33 +08001555 }
1556 }
hualing chenb5cd42e2020-04-15 17:03:34 +08001557end:
Wentao MA96f68962022-06-15 19:45:35 +08001558 DVR_PB_INFO("playback thread is end");
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001559 free(buf);
1560 free(dec_bufs.buf_data);
hualing chen86e7d482020-01-16 15:13:33 +08001561 return NULL;
hualing chenb31a6c62020-01-13 17:27:00 +08001562}
1563
1564
hualing chen040df222020-01-17 13:35:02 +08001565static int _start_playback_thread(DVR_PlaybackHandle_t handle)
hualing chenb31a6c62020-01-13 17:27:00 +08001566{
hualing chen040df222020-01-17 13:35:02 +08001567 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08001568
1569 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08001570 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08001571 return DVR_FAILURE;
1572 }
Wentao MA96f68962022-06-15 19:45:35 +08001573 DVR_PB_INFO("start thread is_running:[%d]", player->is_running);
hualing chencc91e1c2020-02-28 13:26:17 +08001574 if (player->is_running == DVR_TRUE) {
hualing chen4b7c15d2020-04-07 16:13:48 +08001575 return 0;
hualing chen86e7d482020-01-16 15:13:33 +08001576 }
hualing chen5cbe1a62020-02-10 16:36:36 +08001577 player->is_running = DVR_TRUE;
hualing chen86e7d482020-01-16 15:13:33 +08001578 int rc = pthread_create(&player->playback_thread, NULL, _dvr_playback_thread, (void*)player);
hualing chen5cbe1a62020-02-10 16:36:36 +08001579 if (rc < 0)
1580 player->is_running = DVR_FALSE;
hualing chen86e7d482020-01-16 15:13:33 +08001581 return 0;
hualing chenb31a6c62020-01-13 17:27:00 +08001582}
1583
1584
hualing chen040df222020-01-17 13:35:02 +08001585static int _stop_playback_thread(DVR_PlaybackHandle_t handle)
hualing chen86e7d482020-01-16 15:13:33 +08001586{
hualing chen040df222020-01-17 13:35:02 +08001587 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08001588
1589 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08001590 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08001591 return DVR_FAILURE;
1592 }
1593
Wentao MA96f68962022-06-15 19:45:35 +08001594 DVR_PB_INFO("stopthread------[%d]", player->is_running);
hualing chencc91e1c2020-02-28 13:26:17 +08001595 if (player->is_running == DVR_TRUE)
hualing chen86e7d482020-01-16 15:13:33 +08001596 {
1597 player->is_running = DVR_FALSE;
hualing chen87072a82020-03-12 16:20:12 +08001598 _dvr_playback_sendSignal(handle);
hualing chen86e7d482020-01-16 15:13:33 +08001599 pthread_join(player->playback_thread, NULL);
1600 }
Wentao MAf35c3882023-04-17 12:36:19 +08001601 if (player->segment_handle) {
1602 segment_close(player->segment_handle);
1603 player->segment_handle = NULL;
hualing chen86e7d482020-01-16 15:13:33 +08001604 }
Wentao MA96f68962022-06-15 19:45:35 +08001605 DVR_PB_INFO(":end");
hualing chen86e7d482020-01-16 15:13:33 +08001606 return 0;
1607}
1608
hualing chen1679f812021-11-08 15:17:46 +08001609static int getFakePid()
1610{
wentao ma7d642782022-10-23 18:26:16 -07001611 return dvr_prop_read_int("vendor.tv.dtv.fake_pid",0xffff);
hualing chen1679f812021-11-08 15:17:46 +08001612}
1613
1614void dvr_playback_change_seek_state(DVR_PlaybackHandle_t handle,int pid) {
1615
1616 DVR_ASSERT(handle);
1617 DVR_Playback_t *player = (DVR_Playback_t *) handle;
1618 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08001619 DVR_PB_INFO("player is NULL");
hualing chen1679f812021-11-08 15:17:46 +08001620 return ;
1621 }
1622 if (player->need_seek_start == DVR_FALSE) {
Wentao MA96f68962022-06-15 19:45:35 +08001623 DVR_PB_INFO("player need_seek_start is false");
hualing chen1679f812021-11-08 15:17:46 +08001624 return ;
1625 }
1626
hualing chena5f03222021-12-02 11:22:35 +08001627 if (pid != player->fake_pid) {
hualing chen1679f812021-11-08 15:17:46 +08001628 player->need_seek_start = DVR_FALSE;
1629 }
Wentao MA96f68962022-06-15 19:45:35 +08001630 DVR_PB_INFO("player player->need_seek_start=%d", player->need_seek_start);
hualing chen1679f812021-11-08 15:17:46 +08001631}
1632
hualing chenb31a6c62020-01-13 17:27:00 +08001633/**\brief Open an dvr palyback
1634 * \param[out] p_handle dvr playback addr
1635 * \param[in] params dvr playback open parameters
1636 * \retval DVR_SUCCESS On success
1637 * \return Error code
1638 */
hualing chen040df222020-01-17 13:35:02 +08001639int dvr_playback_open(DVR_PlaybackHandle_t *p_handle, DVR_PlaybackOpenParams_t *params) {
hualing chenb31a6c62020-01-13 17:27:00 +08001640
hualing chen040df222020-01-17 13:35:02 +08001641 DVR_Playback_t *player;
hualing chen86e7d482020-01-16 15:13:33 +08001642 pthread_condattr_t cattr;
hualing chenb31a6c62020-01-13 17:27:00 +08001643
Zhiqiang Han2d8cd822020-03-16 13:58:10 +08001644 player = (DVR_Playback_t*)calloc(1, sizeof(DVR_Playback_t));
wentao.maa22bc852022-10-13 12:18:06 +08001645 DVR_RETURN_IF_FALSE(player);
hualing chenb31a6c62020-01-13 17:27:00 +08001646
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001647 dvr_mutex_init(&player->lock);
hualing chen2aba4022020-03-02 13:49:55 +08001648 pthread_mutex_init(&player->segment_lock, NULL);
hualing chen86e7d482020-01-16 15:13:33 +08001649 pthread_condattr_init(&cattr);
1650 pthread_condattr_setclock(&cattr, CLOCK_MONOTONIC);
1651 pthread_cond_init(&player->cond, &cattr);
1652 pthread_condattr_destroy(&cattr);
hualing chenb31a6c62020-01-13 17:27:00 +08001653
hualing chen5cbe1a62020-02-10 16:36:36 +08001654 //init segment list head
hualing chen040df222020-01-17 13:35:02 +08001655 INIT_LIST_HEAD(&player->segment_list);
1656 player->cmd.last_cmd = DVR_PLAYBACK_CMD_STOP;
1657 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_STOP;
hualing chen5cbe1a62020-02-10 16:36:36 +08001658 player->cmd.speed.speed.speed = PLAYBACK_SPEED_X1;
hualing chen040df222020-01-17 13:35:02 +08001659 player->cmd.state = DVR_PLAYBACK_STATE_STOP;
Wentao MA907b6432022-08-01 06:23:08 +00001660 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_STOP);
hualing chen86e7d482020-01-16 15:13:33 +08001661 player->cmd.pos = 0;
hualing chen31140872020-03-25 12:29:26 +08001662 player->speed = 1.0f;
hualing chene41f4372020-06-06 16:29:17 +08001663 player->first_trans_ok = DVR_FALSE;
hualing chen2aba4022020-03-02 13:49:55 +08001664
hualing chen86e7d482020-01-16 15:13:33 +08001665 //store open params
hualing chen040df222020-01-17 13:35:02 +08001666 player->openParams.dmx_dev_id = params->dmx_dev_id;
1667 player->openParams.block_size = params->block_size;
Wentao MA96f68962022-06-15 19:45:35 +08001668 DVR_PB_INFO("playback open block_size:[%d]",params->block_size);
hualing chen86e7d482020-01-16 15:13:33 +08001669 player->openParams.is_timeshift = params->is_timeshift;
hualing chencc91e1c2020-02-28 13:26:17 +08001670 player->openParams.event_fn = params->event_fn;
1671 player->openParams.event_userdata = params->event_userdata;
hualing chene3797f02021-01-13 14:53:28 +08001672 player->openParams.is_notify_time = params->is_notify_time;
hualing chenfbf8e022020-06-15 13:43:11 +08001673 player->vendor = params->vendor;
hualing chencc91e1c2020-02-28 13:26:17 +08001674
hualing chen5cbe1a62020-02-10 16:36:36 +08001675 player->has_pids = params->has_pids;
1676
hualing chen2aba4022020-03-02 13:49:55 +08001677 player->handle = params->player_handle ;
shenghui.gengbec6a462023-01-12 15:21:02 +08001678 player->control_speed_enable = params->control_speed_enable;
hualing chen6e4bfa52020-03-13 14:37:11 +08001679
1680 AmTsPlayer_getCb(player->handle, &player->player_callback_func, &player->player_callback_userdata);
1681 //for test get callback
1682 if (0 && player->player_callback_func == NULL) {
1683 AmTsPlayer_registerCb(player->handle, _dvr_tsplayer_callback_test, player);
1684 AmTsPlayer_getCb(player->handle, &player->player_callback_func, &player->player_callback_userdata);
Wentao MA96f68962022-06-15 19:45:35 +08001685 DVR_PB_INFO("playback open get callback[%p][%p][%p][%p]",
hualing chen03fd4942021-07-15 15:56:41 +08001686 player->player_callback_func,
1687 player->player_callback_userdata,
1688 _dvr_tsplayer_callback_test,
1689 player);
hualing chen6e4bfa52020-03-13 14:37:11 +08001690 }
1691 AmTsPlayer_registerCb(player->handle, _dvr_tsplayer_callback, player);
hualing chen040df222020-01-17 13:35:02 +08001692
hualing chen86e7d482020-01-16 15:13:33 +08001693 //init has audio and video
1694 player->has_video = DVR_FALSE;
1695 player->has_audio = DVR_FALSE;
hualing chen87072a82020-03-12 16:20:12 +08001696 player->cur_segment_id = UINT64_MAX;
hualing chencc91e1c2020-02-28 13:26:17 +08001697 player->last_segment_id = 0LL;
1698 player->segment_is_open = DVR_FALSE;
Wentao MA5629ad82022-08-24 10:03:02 +08001699 player->audio_presentation_id = -1;
hualing chenb31a6c62020-01-13 17:27:00 +08001700
hualing chen5cbe1a62020-02-10 16:36:36 +08001701 //init ff fb time
hualing chen7ea70a72021-09-09 11:25:13 +08001702 player->fffb_current = 0;
1703 player->fffb_start = 0;
hualing chen03fd4942021-07-15 15:56:41 +08001704 player->fffb_start_pcr = 0;
hualing chen5cbe1a62020-02-10 16:36:36 +08001705 //seek time
1706 player->seek_time = 0;
hualing chen6e4bfa52020-03-13 14:37:11 +08001707 player->send_time = 0;
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001708
Yahui Han1fbf3292021-11-08 18:17:19 +08001709 //allocate cryptor if have clearkey
1710 if (params->keylen > 0) {
1711 player->cryptor = am_crypt_des_open((uint8_t *)params->clearkey,
hualing chen002e5b92022-02-23 17:51:21 +08001712 (uint8_t *)params->cleariv,
1713 params->keylen * 8);
Yahui Han1fbf3292021-11-08 18:17:19 +08001714 if (!player->cryptor) {
Wentao MA96f68962022-06-15 19:45:35 +08001715 DVR_INFO("%s , open des cryptor failed!!!\n", __func__);
Yahui Han1fbf3292021-11-08 18:17:19 +08001716 }
1717 } else {
1718 player->cryptor = NULL;
1719 }
1720
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001721 //init secure stuff
1722 player->dec_func = NULL;
1723 player->dec_userdata = NULL;
1724 player->is_secure_mode = 0;
1725 player->secure_buffer = NULL;
1726 player->secure_buffer_size = 0;
hualing chen266b9502020-04-04 17:39:39 +08001727 player->drop_ts = DVR_FALSE;
pengfei.liu07ddc8a2020-03-24 23:36:53 +08001728
hualing chen4b7c15d2020-04-07 16:13:48 +08001729 player->fffb_play = DVR_FALSE;
1730
1731 player->last_send_time_id = UINT64_MAX;
1732 player->last_cur_time = 0;
hualing chen30423862021-04-16 14:39:12 +08001733 player->seek_pause = DVR_FALSE;
hualing chen4b7c15d2020-04-07 16:13:48 +08001734
hualing chend241c7a2021-06-22 13:34:27 +08001735 //speed con init
shenghui.gengbec6a462023-01-12 15:21:02 +08001736 if (player->control_speed_enable == 1) {
hualing chend241c7a2021-06-22 13:34:27 +08001737 player->con_spe.ply_dur = 0;
hualing chen7ea70a72021-09-09 11:25:13 +08001738 player->con_spe.ply_sta = 0;
hualing chend241c7a2021-06-22 13:34:27 +08001739 player->con_spe.sys_dur = 0;
1740 player->con_spe.sys_sta = 0;
1741 }
1742
hualing chen03fd4942021-07-15 15:56:41 +08001743 //limit info
1744 player->rec_start = 0;
hualing chen7ea70a72021-09-09 11:25:13 +08001745 player->limit = 0;
hualing chen8a657f32021-08-30 13:12:49 +08001746 //need seek to start pos
1747 player->first_start_time = 0;
Wentao MA01de0e62022-01-10 18:48:23 +08001748 player->first_start_id = UINT64_MAX;
Wentao MAa0b9c002022-11-10 17:47:27 +08001749 player->delay_is_effective = DVR_FALSE;
hualing chen8a657f32021-08-30 13:12:49 +08001750 player->need_seek_start = DVR_TRUE;
hualing chena5f03222021-12-02 11:22:35 +08001751 //fake_pid init
1752 player->fake_pid = getFakePid();
hualing chen86e7d482020-01-16 15:13:33 +08001753 *p_handle = player;
1754 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08001755}
1756
1757/**\brief Close an dvr palyback
1758 * \param[in] handle playback handle
1759 * \retval DVR_SUCCESS On success
1760 * \return Error code
1761 */
hualing chen040df222020-01-17 13:35:02 +08001762int dvr_playback_close(DVR_PlaybackHandle_t handle) {
hualing chenb31a6c62020-01-13 17:27:00 +08001763
hualing chen86e7d482020-01-16 15:13:33 +08001764 DVR_ASSERT(handle);
Wentao MA96f68962022-06-15 19:45:35 +08001765 DVR_PB_INFO(":into");
hualing chen040df222020-01-17 13:35:02 +08001766 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08001767 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08001768 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08001769 return DVR_FAILURE;
1770 }
1771
hualing chencc91e1c2020-02-28 13:26:17 +08001772 if (player->state != DVR_PLAYBACK_STATE_STOP)
1773 {
Wentao MA96f68962022-06-15 19:45:35 +08001774 DVR_PB_INFO("player->state %s", _dvr_playback_state_toString(player->state));
Yahui Han1fbf3292021-11-08 18:17:19 +08001775 if (player->cryptor) {
1776 am_crypt_des_close(player->cryptor);
1777 player->cryptor = NULL;
1778 }
hualing chencc91e1c2020-02-28 13:26:17 +08001779 dvr_playback_stop(handle, DVR_TRUE);
Wentao MA96f68962022-06-15 19:45:35 +08001780 DVR_PB_INFO("player->state %s", _dvr_playback_state_toString(player->state));
hualing chenb96aa2c2020-04-15 14:13:53 +08001781 } else {
Wentao MA96f68962022-06-15 19:45:35 +08001782 DVR_PB_INFO(":is stoped state");
hualing chencc91e1c2020-02-28 13:26:17 +08001783 }
Wentao MA96f68962022-06-15 19:45:35 +08001784 DVR_PB_INFO(":into");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001785 dvr_mutex_destroy(&player->lock);
Zhiqiang Hanc9513462022-06-21 09:55:23 +08001786 pthread_mutex_destroy(&player->segment_lock);
hualing chen86e7d482020-01-16 15:13:33 +08001787 pthread_cond_destroy(&player->cond);
hualing chen040df222020-01-17 13:35:02 +08001788
1789 if (player) {
1790 free(player);
hualing chen040df222020-01-17 13:35:02 +08001791 }
Wentao MA96f68962022-06-15 19:45:35 +08001792 DVR_PB_INFO(":end");
hualing chen86e7d482020-01-16 15:13:33 +08001793 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08001794}
1795
Wentao MA270dc0f2022-08-23 13:17:26 +08001796/**\brief Start play audio and video, used start audio api and start video api
hualing chenb31a6c62020-01-13 17:27:00 +08001797 * \param[in] handle playback handle
1798 * \param[in] params audio playback params,contains fmt and pid...
1799 * \retval DVR_SUCCESS On success
1800 * \return Error code
1801 */
hualing chen040df222020-01-17 13:35:02 +08001802int dvr_playback_start(DVR_PlaybackHandle_t handle, DVR_PlaybackFlag_t flag) {
1803 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MA270dc0f2022-08-23 13:17:26 +08001804 am_tsplayer_video_params video_params;
1805 am_tsplayer_audio_params audio_params;
1806 am_tsplayer_audio_params ad_params;
hualing chena540a7e2020-03-27 16:44:05 +08001807
Wentao MA270dc0f2022-08-23 13:17:26 +08001808 memset(&video_params, 0, sizeof(video_params));
1809 memset(&audio_params, 0, sizeof(audio_params));
jiangfei.hanb8fbad42021-07-29 15:04:48 +08001810
hualing chena540a7e2020-03-27 16:44:05 +08001811 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08001812 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08001813 return DVR_FAILURE;
1814 }
hualing chencc91e1c2020-02-28 13:26:17 +08001815 uint64_t segment_id = player->cur_segment_id;
Wentao MA96f68962022-06-15 19:45:35 +08001816 DVR_PB_INFO("[%p]segment_id:[%lld]", handle, segment_id);
hualing chenb31a6c62020-01-13 17:27:00 +08001817
hualing chena540a7e2020-03-27 16:44:05 +08001818 player->first_frame = 0;
hualing chencc91e1c2020-02-28 13:26:17 +08001819 //can used start api to resume playback
1820 if (player->cmd.state == DVR_PLAYBACK_STATE_PAUSE) {
1821 return dvr_playback_resume(handle);
1822 }
hualing chen87072a82020-03-12 16:20:12 +08001823 if (player->cmd.state == DVR_PLAYBACK_STATE_START) {
Wentao MA270dc0f2022-08-23 13:17:26 +08001824 //if flag is paused and not decode first frame. if user resume, we need
hualing chen9b434f02020-06-10 15:06:54 +08001825 //clear flag and set trickmode none
1826 if ((player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE) {
Wentao MA96f68962022-06-15 19:45:35 +08001827 DVR_PB_INFO("[%p]clear pause live flag and clear trick mode", handle);
hualing chen9b434f02020-06-10 15:06:54 +08001828 player->play_flag = player->play_flag & (~DVR_PLAYBACK_STARTED_PAUSEDLIVE);
1829 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
1830 }
Wentao MA96f68962022-06-15 19:45:35 +08001831 DVR_PB_INFO("stat is start, not need into start play");
hualing chen87072a82020-03-12 16:20:12 +08001832 return DVR_SUCCESS;
1833 }
hualing chen86e7d482020-01-16 15:13:33 +08001834 player->play_flag = flag;
hualing chene41f4372020-06-06 16:29:17 +08001835 player->first_trans_ok = DVR_FALSE;
hualing chen5cbe1a62020-02-10 16:36:36 +08001836 //get segment info and audio video pid fmt ;
Wentao MA96f68962022-06-15 19:45:35 +08001837 DVR_PB_INFO("lock flag:0x%x", flag);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001838 dvr_mutex_lock(&player->lock);
Wentao MA270dc0f2022-08-23 13:17:26 +08001839 _dvr_playback_get_playinfo(handle, segment_id, &video_params, &audio_params, &ad_params);
hualing chen86e7d482020-01-16 15:13:33 +08001840 //start audio and video
Wentao MA270dc0f2022-08-23 13:17:26 +08001841 if (video_params.pid != player->fake_pid && !VALID_PID(video_params.pid) && !VALID_PID(audio_params.pid)) {
1842 //audio and video pids are all invalid, return error.
1843 DVR_PB_ERROR("unlock dvr play back start error, not found audio and video info [0x%x]", video_params.pid);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001844 dvr_mutex_unlock(&player->lock);
hualing chencc91e1c2020-02-28 13:26:17 +08001845 DVR_Play_Notify_t notify;
1846 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
1847 notify.event = DVR_PLAYBACK_EVENT_TRANSITION_FAILED;
1848 notify.info.error_reason = DVR_PLAYBACK_PID_ERROR;
1849 notify.info.transition_failed_data.segment_id = segment_id;
1850 //get play statue not here
hualing chen2932d372020-04-29 13:44:00 +08001851 _dvr_playback_sent_event(handle, DVR_PLAYBACK_EVENT_TRANSITION_FAILED, &notify, DVR_TRUE);
hualing chen86e7d482020-01-16 15:13:33 +08001852 return -1;
1853 }
hualing chen31140872020-03-25 12:29:26 +08001854
hualing chencc91e1c2020-02-28 13:26:17 +08001855 {
Wentao MA270dc0f2022-08-23 13:17:26 +08001856 if (VALID_PID(video_params.pid)) {
hualing chen86e7d482020-01-16 15:13:33 +08001857 player->has_video = DVR_TRUE;
hualing chen86e7d482020-01-16 15:13:33 +08001858 //if set flag is pause live, we need set trick mode
hualing chen31140872020-03-25 12:29:26 +08001859 if ((player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE) {
Wentao MA96f68962022-06-15 19:45:35 +08001860 DVR_PB_INFO("set trick mode -pauselive flag--");
hualing chen31140872020-03-25 12:29:26 +08001861 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_PAUSE_NEXT);
1862 } else if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB
hualing chen2aba4022020-03-02 13:49:55 +08001863 || player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF) {
Wentao MA96f68962022-06-15 19:45:35 +08001864 DVR_PB_INFO("set trick mode -fffb--at pause live");
hualing chen2aba4022020-03-02 13:49:55 +08001865 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_PAUSE_NEXT);
hualing chen87072a82020-03-12 16:20:12 +08001866 } else {
Wentao MA96f68962022-06-15 19:45:35 +08001867 DVR_PB_INFO("set trick mode ---none");
hualing chen87072a82020-03-12 16:20:12 +08001868 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
hualing chen2aba4022020-03-02 13:49:55 +08001869 }
hualing chena93bbbc2020-12-22 17:23:42 +08001870 AmTsPlayer_showVideo(player->handle);
Wentao MA270dc0f2022-08-23 13:17:26 +08001871 AmTsPlayer_setVideoParams(player->handle, &video_params);
hualing chen21a40372021-10-29 11:07:26 +08001872 AmTsPlayer_setVideoBlackOut(player->handle, 1);
hualing chen2aba4022020-03-02 13:49:55 +08001873 AmTsPlayer_startVideoDecoding(player->handle);
hualing chenb31a6c62020-01-13 17:27:00 +08001874 }
hualing chena540a7e2020-03-27 16:44:05 +08001875
Wentao MA270dc0f2022-08-23 13:17:26 +08001876 DVR_PB_INFO("player->cmd.cur_cmd:%d vpid[0x%x]apis[0x%x]", player->cmd.cur_cmd, video_params.pid, audio_params.pid);
hualing chen4b7c15d2020-04-07 16:13:48 +08001877 player->last_send_time_id = UINT64_MAX;
hualing chencc91e1c2020-02-28 13:26:17 +08001878 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB
1879 || player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF) {
1880 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00001881 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
hualing chencc91e1c2020-02-28 13:26:17 +08001882 } else {
1883 player->cmd.last_cmd = player->cmd.cur_cmd;
1884 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_START;
hualing chena540a7e2020-03-27 16:44:05 +08001885 if (IS_FAST_SPEED(player->cmd.speed.speed.speed)) {
hualing chen31140872020-03-25 12:29:26 +08001886 //set fast play
Wentao MA96f68962022-06-15 19:45:35 +08001887 DVR_PB_INFO("start fast");
hualing chen31140872020-03-25 12:29:26 +08001888 AmTsPlayer_startFast(player->handle, (float)player->cmd.speed.speed.speed/100.0f);
hualing chena540a7e2020-03-27 16:44:05 +08001889 } else {
Wentao MA270dc0f2022-08-23 13:17:26 +08001890 if (VALID_PID(ad_params.pid)) {
hualing chendf118dd2020-05-21 15:49:11 +08001891 player->has_ad_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08001892 DVR_PB_INFO("start ad audio");
Wentao MA270dc0f2022-08-23 13:17:26 +08001893 dvr_playback_change_seek_state(handle, ad_params.pid);
1894 AmTsPlayer_setADParams(player->handle, &ad_params);
hualing chendf118dd2020-05-21 15:49:11 +08001895 AmTsPlayer_enableADMix(player->handle);
1896 }
Wentao MA270dc0f2022-08-23 13:17:26 +08001897 if (VALID_PID(audio_params.pid)) {
Wentao MA96f68962022-06-15 19:45:35 +08001898 DVR_PB_INFO("start audio");
hualing chen969fe7b2021-05-26 15:13:17 +08001899 player->has_audio = DVR_TRUE;
Wentao MA270dc0f2022-08-23 13:17:26 +08001900 dvr_playback_change_seek_state(handle, audio_params.pid);
1901 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08001902 if (player->audio_presentation_id > -1) {
1903 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
1904 }
hualing chen969fe7b2021-05-26 15:13:17 +08001905 AmTsPlayer_startAudioDecoding(player->handle);
1906 }
hualing chen31140872020-03-25 12:29:26 +08001907 }
hualing chencc91e1c2020-02-28 13:26:17 +08001908 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00001909 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
hualing chencc91e1c2020-02-28 13:26:17 +08001910 }
hualing chen86e7d482020-01-16 15:13:33 +08001911 }
hualing chen43a89bc2022-01-19 14:31:20 +08001912#ifdef AVSYNC_USED_PCR
1913 if (player && VALID_PID(player->cur_segment.pids.pcr.pid)) {
Wentao MA96f68962022-06-15 19:45:35 +08001914 DVR_PB_INFO("start set pcr [%d]", player->cur_segment.pids.pcr.pid);
hualing chen43a89bc2022-01-19 14:31:20 +08001915 AmTsPlayer_setPcrPid(player->handle, player->cur_segment.pids.pcr.pid);
1916 }
1917#endif
Wentao MA96f68962022-06-15 19:45:35 +08001918 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001919 dvr_mutex_unlock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08001920 _start_playback_thread(handle);
hualing chen86e7d482020-01-16 15:13:33 +08001921 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08001922}
hualing chen040df222020-01-17 13:35:02 +08001923/**\brief dvr play back add segment info to segment list
hualing chenb31a6c62020-01-13 17:27:00 +08001924 * \param[in] handle playback handle
hualing chen040df222020-01-17 13:35:02 +08001925 * \param[in] info added segment info,con vpid fmt apid fmt.....
hualing chenb31a6c62020-01-13 17:27:00 +08001926 * \retval DVR_SUCCESS On success
1927 * \return Error code
1928 */
hualing chen040df222020-01-17 13:35:02 +08001929int dvr_playback_add_segment(DVR_PlaybackHandle_t handle, DVR_PlaybackSegmentInfo_t *info) {
1930 DVR_Playback_t *player = (DVR_Playback_t *) handle;
wentao.maa22bc852022-10-13 12:18:06 +08001931 DVR_RETURN_IF_FALSE(player);
hualing chena540a7e2020-03-27 16:44:05 +08001932
Wentao MA96f68962022-06-15 19:45:35 +08001933 DVR_PB_INFO("add segment id: %lld %p", info->segment_id, handle);
hualing chen040df222020-01-17 13:35:02 +08001934 DVR_PlaybackSegmentInfo_t *segment;
hualing chenb31a6c62020-01-13 17:27:00 +08001935
hualing chen040df222020-01-17 13:35:02 +08001936 segment = malloc(sizeof(DVR_PlaybackSegmentInfo_t));
wentao.maa22bc852022-10-13 12:18:06 +08001937 DVR_RETURN_IF_FALSE(segment);
hualing chen040df222020-01-17 13:35:02 +08001938 memset(segment, 0, sizeof(DVR_PlaybackSegmentInfo_t));
hualing chenb31a6c62020-01-13 17:27:00 +08001939
Wentao MA270dc0f2022-08-23 13:17:26 +08001940 //not memcpy chunk info.
hualing chen040df222020-01-17 13:35:02 +08001941 segment->segment_id = info->segment_id;
hualing chen86e7d482020-01-16 15:13:33 +08001942 //cp location
hualing chen040df222020-01-17 13:35:02 +08001943 memcpy(segment->location, info->location, DVR_MAX_LOCATION_SIZE);
hualing chencc91e1c2020-02-28 13:26:17 +08001944
Wentao MA96f68962022-06-15 19:45:35 +08001945 DVR_PB_INFO("add location [%s]id[%lld]flag[%x]", segment->location, segment->segment_id, info->flags);
hualing chen040df222020-01-17 13:35:02 +08001946 segment->flags = info->flags;
hualing chen5cbe1a62020-02-10 16:36:36 +08001947
1948 //pids
hualing chencc91e1c2020-02-28 13:26:17 +08001949 segment->pids.video.pid = info->pids.video.pid;
1950 segment->pids.video.format = info->pids.video.format;
1951 segment->pids.video.type = info->pids.video.type;
1952
hualing chen2aba4022020-03-02 13:49:55 +08001953 segment->pids.audio.pid = info->pids.audio.pid;
1954 segment->pids.audio.format = info->pids.audio.format;
1955 segment->pids.audio.type = info->pids.audio.type;
hualing chencc91e1c2020-02-28 13:26:17 +08001956
hualing chen2aba4022020-03-02 13:49:55 +08001957 segment->pids.ad.pid = info->pids.ad.pid;
1958 segment->pids.ad.format = info->pids.ad.format;
1959 segment->pids.ad.type = info->pids.ad.type;
hualing chencc91e1c2020-02-28 13:26:17 +08001960
1961 segment->pids.pcr.pid = info->pids.pcr.pid;
1962
Wentao MA96f68962022-06-15 19:45:35 +08001963 DVR_PB_INFO("lock pid [0x%x][0x%x][0x%x][0x%x]", segment->pids.video.pid,segment->pids.audio.pid, info->pids.video.pid,info->pids.audio.pid);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001964 dvr_mutex_lock(&player->lock);
wentao.maa22bc852022-10-13 12:18:06 +08001965 list_add_tail(segment, &player->segment_list);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001966 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08001967 DVR_PB_DEBUG("unlock");
hualing chenb31a6c62020-01-13 17:27:00 +08001968
hualing chen5cbe1a62020-02-10 16:36:36 +08001969 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08001970}
hualing chen040df222020-01-17 13:35:02 +08001971/**\brief dvr play back remove segment info by segment_id
hualing chenb31a6c62020-01-13 17:27:00 +08001972 * \param[in] handle playback handle
hualing chen040df222020-01-17 13:35:02 +08001973 * \param[in] segment_id need removed segment id
hualing chenb31a6c62020-01-13 17:27:00 +08001974 * \retval DVR_SUCCESS On success
1975 * \return Error code
1976 */
hualing chen5cbe1a62020-02-10 16:36:36 +08001977int dvr_playback_remove_segment(DVR_PlaybackHandle_t handle, uint64_t segment_id) {
hualing chen040df222020-01-17 13:35:02 +08001978 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MA96f68962022-06-15 19:45:35 +08001979 DVR_PB_INFO("remove segment id: %lld", segment_id);
hualing chena540a7e2020-03-27 16:44:05 +08001980 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08001981 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08001982 return DVR_FAILURE;
1983 }
1984
hualing chencc91e1c2020-02-28 13:26:17 +08001985 if (segment_id == player->cur_segment_id) {
Wentao MA9a164002022-08-29 11:20:24 +08001986 DVR_PB_INFO("not support remove current segment id: %lld", segment_id);
hualing chencc91e1c2020-02-28 13:26:17 +08001987 return DVR_FAILURE;
1988 }
Wentao MA96f68962022-06-15 19:45:35 +08001989 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08001990 dvr_mutex_lock(&player->lock);
hualing chena540a7e2020-03-27 16:44:05 +08001991 DVR_PlaybackSegmentInfo_t *segment = NULL;
1992 DVR_PlaybackSegmentInfo_t *segment_tmp = NULL;
1993 list_for_each_entry_safe(segment, segment_tmp, &player->segment_list, head)
hualing chen86e7d482020-01-16 15:13:33 +08001994 {
hualing chen040df222020-01-17 13:35:02 +08001995 if (segment->segment_id == segment_id) {
1996 list_del(&segment->head);
1997 free(segment);
hualing chen86e7d482020-01-16 15:13:33 +08001998 break;
hualing chenb31a6c62020-01-13 17:27:00 +08001999 }
hualing chen86e7d482020-01-16 15:13:33 +08002000 }
Wentao MA96f68962022-06-15 19:45:35 +08002001 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002002 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002003
2004 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002005}
hualing chen040df222020-01-17 13:35:02 +08002006/**\brief dvr play back add segment info
hualing chenb31a6c62020-01-13 17:27:00 +08002007 * \param[in] handle playback handle
hualing chen040df222020-01-17 13:35:02 +08002008 * \param[in] info added segment info,con vpid fmt apid fmt.....
hualing chenb31a6c62020-01-13 17:27:00 +08002009 * \retval DVR_SUCCESS On success
2010 * \return Error code
2011 */
hualing chen040df222020-01-17 13:35:02 +08002012int dvr_playback_update_segment_flags(DVR_PlaybackHandle_t handle,
hualing chen5cbe1a62020-02-10 16:36:36 +08002013 uint64_t segment_id, DVR_PlaybackSegmentFlag_t flags) {
hualing chen040df222020-01-17 13:35:02 +08002014 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MA96f68962022-06-15 19:45:35 +08002015 DVR_PB_INFO("update segment id: %lld flag:%d", segment_id, flags);
hualing chena540a7e2020-03-27 16:44:05 +08002016 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002017 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002018 return DVR_FAILURE;
2019 }
Wentao MA292380e2022-12-14 14:46:19 +08002020 if (player->vendor != DVR_PLAYBACK_VENDOR_DEF) {
2021 DVR_PB_INFO("In case of vendor Amlogic/Amazon, do not control AV display");
hualing chenf43b8ba2020-07-28 13:11:42 +08002022 return DVR_SUCCESS;
2023 }
hualing chena540a7e2020-03-27 16:44:05 +08002024
hualing chen040df222020-01-17 13:35:02 +08002025 DVR_PlaybackSegmentInfo_t *segment;
Wentao MA96f68962022-06-15 19:45:35 +08002026 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002027 dvr_mutex_lock(&player->lock);
wentao.mafd5283f2022-10-14 09:51:13 +08002028 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08002029 // prefetch() here incurring self_assign is used to avoid some compiling
2030 // warnings.
2031 // coverity[self_assign]
hualing chen040df222020-01-17 13:35:02 +08002032 list_for_each_entry(segment, &player->segment_list, head)
hualing chen86e7d482020-01-16 15:13:33 +08002033 {
hualing chen040df222020-01-17 13:35:02 +08002034 if (segment->segment_id != segment_id) {
hualing chen86e7d482020-01-16 15:13:33 +08002035 continue;
hualing chenb31a6c62020-01-13 17:27:00 +08002036 }
hualing chen86e7d482020-01-16 15:13:33 +08002037 // if encramble to free, only set flag and return;
2038
2039 //if displayable to none, we need mute audio and video
hualing chen040df222020-01-17 13:35:02 +08002040 if (segment_id == player->cur_segment_id) {
hualing chen5cbe1a62020-02-10 16:36:36 +08002041 if ((segment->flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == DVR_PLAYBACK_SEGMENT_DISPLAYABLE
2042 && (flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == 0) {
hualing chencc91e1c2020-02-28 13:26:17 +08002043 //disable display, mute
Wentao MA96f68962022-06-15 19:45:35 +08002044 DVR_PB_INFO("mute av");
hualing chen2aba4022020-03-02 13:49:55 +08002045 AmTsPlayer_hideVideo(player->handle);
2046 AmTsPlayer_setAudioMute(player->handle, 1, 1);
hualing chen5cbe1a62020-02-10 16:36:36 +08002047 } else if ((segment->flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == 0 &&
2048 (flags & DVR_PLAYBACK_SEGMENT_DISPLAYABLE) == DVR_PLAYBACK_SEGMENT_DISPLAYABLE) {
hualing chencc91e1c2020-02-28 13:26:17 +08002049 //enable display, unmute
Wentao MA96f68962022-06-15 19:45:35 +08002050 DVR_PB_INFO("unmute av");
hualing chen2aba4022020-03-02 13:49:55 +08002051 AmTsPlayer_showVideo(player->handle);
2052 AmTsPlayer_setAudioMute(player->handle, 0, 0);
hualing chen86e7d482020-01-16 15:13:33 +08002053 } else {
2054 //do nothing
2055 }
2056 } else {
2057 //do nothing
2058 }
2059 //continue , only set flag
hualing chen040df222020-01-17 13:35:02 +08002060 segment->flags = flags;
hualing chen86e7d482020-01-16 15:13:33 +08002061 }
Wentao MA96f68962022-06-15 19:45:35 +08002062 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002063 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002064 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002065}
2066
2067
Wentao MA6dcdc342023-01-30 17:03:19 +08002068static int _do_handle_pid_update(DVR_PlaybackHandle_t handle, DVR_PlaybackPids_t now_pids, DVR_PlaybackPids_t set_pids, int type) {
hualing chen040df222020-01-17 13:35:02 +08002069 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen275379e2021-06-15 17:57:21 +08002070 DVR_StreamInfo_t set_pid;
hualing chen99508642021-10-18 15:41:17 +08002071 DVR_StreamInfo_t now_pid;
hualing chen275379e2021-06-15 17:57:21 +08002072
Wentao MA6dcdc342023-01-30 17:03:19 +08002073 if (player == NULL) {
2074 DVR_PB_INFO("player is NULL");
2075 return DVR_FAILURE;
2076 }
2077
hualing chen275379e2021-06-15 17:57:21 +08002078 if (type == 0) {
2079 set_pid = set_pids.video;
hualing chen99508642021-10-18 15:41:17 +08002080 now_pid = now_pids.video;
hualing chen275379e2021-06-15 17:57:21 +08002081 } else if (type == 1) {
2082 set_pid = set_pids.audio;
hualing chen99508642021-10-18 15:41:17 +08002083 now_pid = now_pids.audio;
hualing chen275379e2021-06-15 17:57:21 +08002084 } else if (type == 2) {
2085 set_pid = set_pids.ad;
hualing chen99508642021-10-18 15:41:17 +08002086 now_pid = now_pids.ad;
hualing chen275379e2021-06-15 17:57:21 +08002087 } else {
2088 set_pid = set_pids.pcr;
hualing chen99508642021-10-18 15:41:17 +08002089 now_pid = now_pids.pcr;
hualing chen275379e2021-06-15 17:57:21 +08002090 }
2091
Wentao MA6dcdc342023-01-30 17:03:19 +08002092 if (type == 1 && VALID_PID(set_pid.pid) && player->cmd.state == DVR_PLAYBACK_STATE_START
2093 && player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) {
2094 // Here we mute audio no matter it is displayable or not in starting phase of a playback.
2095 // Audio will be unmuted shortly on receiving first frame event.
2096 AmTsPlayer_setAudioMute(player->handle,1,1);
hualing chena540a7e2020-03-27 16:44:05 +08002097 }
Wentao MA6dcdc342023-01-30 17:03:19 +08002098
hualing chen86e7d482020-01-16 15:13:33 +08002099 if (now_pid.pid == set_pid.pid) {
2100 //do nothing
hualing chenb31a6c62020-01-13 17:27:00 +08002101 return 0;
hualing chen5cbe1a62020-02-10 16:36:36 +08002102 } else if (player->cmd.state == DVR_PLAYBACK_STATE_START) {
hualing chen86e7d482020-01-16 15:13:33 +08002103 if (VALID_PID(now_pid.pid)) {
2104 //stop now stream
2105 if (type == 0) {
Wentao MA270dc0f2022-08-23 13:17:26 +08002106 //stop video
hualing chenc70a8df2020-05-12 19:23:11 +08002107 if (player->has_video == DVR_TRUE) {
Wentao MA96f68962022-06-15 19:45:35 +08002108 DVR_PB_INFO("stop video");
hualing chenc70a8df2020-05-12 19:23:11 +08002109 AmTsPlayer_stopVideoDecoding(player->handle);
2110 player->has_video = DVR_FALSE;
2111 }
hualing chen86e7d482020-01-16 15:13:33 +08002112 } else if (type == 1) {
2113 //stop audio
hualing chenc70a8df2020-05-12 19:23:11 +08002114 if (player->has_audio == DVR_TRUE) {
Wentao MA96f68962022-06-15 19:45:35 +08002115 DVR_PB_INFO("stop audio");
hualing chenc70a8df2020-05-12 19:23:11 +08002116 AmTsPlayer_stopAudioDecoding(player->handle);
2117 player->has_audio = DVR_FALSE;
2118 }
hualing chen86e7d482020-01-16 15:13:33 +08002119 } else if (type == 2) {
2120 //stop sub audio
Wentao MA96f68962022-06-15 19:45:35 +08002121 DVR_PB_INFO("stop ad");
hualing chena540a7e2020-03-27 16:44:05 +08002122 AmTsPlayer_disableADMix(player->handle);
hualing chen86e7d482020-01-16 15:13:33 +08002123 } else if (type == 3) {
2124 //pcr
2125 }
2126 }
2127 if (VALID_PID(set_pid.pid)) {
2128 //start
2129 if (type == 0) {
Wentao MA270dc0f2022-08-23 13:17:26 +08002130 //start video
2131 am_tsplayer_video_params video_params;
2132 video_params.pid = set_pid.pid;
2133 video_params.codectype = _dvr_convert_stream_fmt(set_pid.format, DVR_FALSE);
hualing chen5cbe1a62020-02-10 16:36:36 +08002134 player->has_video = DVR_TRUE;
Wentao MA270dc0f2022-08-23 13:17:26 +08002135 DVR_PB_INFO("start video pid[%d]fmt[%d]",video_params.pid, video_params.codectype);
2136 AmTsPlayer_setVideoParams(player->handle, &video_params);
hualing chen2aba4022020-03-02 13:49:55 +08002137 AmTsPlayer_startVideoDecoding(player->handle);
Wentao MA270dc0f2022-08-23 13:17:26 +08002138 //playback_device_video_start(player->handle,&video_params);
hualing chen86e7d482020-01-16 15:13:33 +08002139 } else if (type == 1) {
2140 //start audio
Gong Ke2a0ebbe2021-05-25 15:22:50 +08002141 if (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1) {
hualing chen275379e2021-06-15 17:57:21 +08002142 if (VALID_PID(set_pids.ad.pid)) {
Wentao MA270dc0f2022-08-23 13:17:26 +08002143 am_tsplayer_audio_params ad_params;
2144 ad_params.pid = set_pids.ad.pid;
2145 ad_params.codectype= _dvr_convert_stream_fmt(set_pids.ad.format, DVR_TRUE);
2146 DVR_PB_INFO("start ad audio pid[%d]fmt[%d]",ad_params.pid, ad_params.codectype);
2147 AmTsPlayer_setADParams(player->handle, &ad_params);
hualing chen275379e2021-06-15 17:57:21 +08002148 AmTsPlayer_enableADMix(player->handle);
2149 }
2150
Wentao MA270dc0f2022-08-23 13:17:26 +08002151 am_tsplayer_audio_params audio_params;
jiangfei.hanb8fbad42021-07-29 15:04:48 +08002152
Wentao MA270dc0f2022-08-23 13:17:26 +08002153 memset(&audio_params, 0, sizeof(audio_params));
jiangfei.hanb8fbad42021-07-29 15:04:48 +08002154
Wentao MA270dc0f2022-08-23 13:17:26 +08002155 audio_params.pid = set_pid.pid;
2156 audio_params.codectype= _dvr_convert_stream_fmt(set_pid.format, DVR_TRUE);
hualing chenc70a8df2020-05-12 19:23:11 +08002157 player->has_audio = DVR_TRUE;
Wentao MA270dc0f2022-08-23 13:17:26 +08002158 DVR_PB_INFO("start audio pid[%d]fmt[%d]",audio_params.pid, audio_params.codectype);
2159 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08002160 if (player->audio_presentation_id > -1) {
2161 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
2162 }
Wentao MA6dcdc342023-01-30 17:03:19 +08002163
hualing chenc70a8df2020-05-12 19:23:11 +08002164 AmTsPlayer_startAudioDecoding(player->handle);
Wentao MA270dc0f2022-08-23 13:17:26 +08002165 //playback_device_audio_start(player->handle,&audio_params);
hualing chenc70a8df2020-05-12 19:23:11 +08002166 }
hualing chen86e7d482020-01-16 15:13:33 +08002167 } else if (type == 2) {
Gong Ke2a0ebbe2021-05-25 15:22:50 +08002168 if (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1) {
hualing chen99508642021-10-18 15:41:17 +08002169 if (set_pids.audio.pid == now_pids.audio.pid) {
2170 //stop audio if audio pid not change
Wentao MA96f68962022-06-15 19:45:35 +08002171 DVR_PB_INFO("stop audio when start ad");
hualing chen99508642021-10-18 15:41:17 +08002172 AmTsPlayer_stopAudioDecoding(player->handle);
2173 }
Wentao MA270dc0f2022-08-23 13:17:26 +08002174 am_tsplayer_audio_params audio_params;
jiangfei.hanb8fbad42021-07-29 15:04:48 +08002175
Wentao MA270dc0f2022-08-23 13:17:26 +08002176 memset(&audio_params, 0, sizeof(audio_params));
2177 audio_params.pid = set_pid.pid;
2178 audio_params.codectype= _dvr_convert_stream_fmt(set_pid.format, DVR_TRUE);
hualing chenc70a8df2020-05-12 19:23:11 +08002179 player->has_audio = DVR_TRUE;
Wentao MA270dc0f2022-08-23 13:17:26 +08002180 DVR_PB_INFO("start ad audio pid[%d]fmt[%d]",audio_params.pid, audio_params.codectype);
2181 AmTsPlayer_setADParams(player->handle, &audio_params);
hualing chenc70a8df2020-05-12 19:23:11 +08002182 AmTsPlayer_enableADMix(player->handle);
hualing chen99508642021-10-18 15:41:17 +08002183
2184 if (set_pids.audio.pid == now_pids.audio.pid) {
Wentao MA270dc0f2022-08-23 13:17:26 +08002185 am_tsplayer_audio_params audio_params;
hualing chen99508642021-10-18 15:41:17 +08002186
Wentao MA270dc0f2022-08-23 13:17:26 +08002187 memset(&audio_params, 0, sizeof(audio_params));
hualing chen99508642021-10-18 15:41:17 +08002188
Wentao MA270dc0f2022-08-23 13:17:26 +08002189 audio_params.pid = set_pids.audio.pid;
2190 audio_params.codectype= _dvr_convert_stream_fmt(set_pids.audio.format, DVR_TRUE);
hualing chen99508642021-10-18 15:41:17 +08002191 player->has_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08002192 DVR_PB_INFO("restart audio when start ad");
Wentao MA270dc0f2022-08-23 13:17:26 +08002193 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08002194 if (player->audio_presentation_id > -1) {
2195 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
2196 }
hualing chen99508642021-10-18 15:41:17 +08002197 AmTsPlayer_startAudioDecoding(player->handle);
2198 }
hualing chenc70a8df2020-05-12 19:23:11 +08002199 }
hualing chen86e7d482020-01-16 15:13:33 +08002200 } else if (type == 3) {
2201 //pcr
Wentao MA96f68962022-06-15 19:45:35 +08002202 DVR_PB_INFO("start set pcr [%d]", set_pid.pid);
hualing chen2aba4022020-03-02 13:49:55 +08002203 AmTsPlayer_setPcrPid(player->handle, set_pid.pid);
hualing chen86e7d482020-01-16 15:13:33 +08002204 }
hualing chen5cbe1a62020-02-10 16:36:36 +08002205 //audio and video all close
2206 if (!player->has_audio && !player->has_video) {
Wentao MA907b6432022-08-01 06:23:08 +00002207 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_STOP);
hualing chen5cbe1a62020-02-10 16:36:36 +08002208 }
hualing chen43a89bc2022-01-19 14:31:20 +08002209 } else if (type == 2) {
2210 //case disable ad
Wentao MA96f68962022-06-15 19:45:35 +08002211 DVR_PB_INFO("restart audio when stop ad");
hualing chen43a89bc2022-01-19 14:31:20 +08002212 if (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1) {
Wentao MA6d045b32022-02-18 18:47:25 +08002213 if (VALID_PID(now_pids.audio.pid)) {
2214 //stop audio if audio pid not change
Wentao MA96f68962022-06-15 19:45:35 +08002215 DVR_PB_INFO("stop audio when stop ad pid [0x%x]", now_pids.audio.pid);
Wentao MA6d045b32022-02-18 18:47:25 +08002216 AmTsPlayer_stopAudioDecoding(player->handle);
Wentao MA270dc0f2022-08-23 13:17:26 +08002217 am_tsplayer_audio_params audio_params;
hualing chen43a89bc2022-01-19 14:31:20 +08002218
Wentao MA270dc0f2022-08-23 13:17:26 +08002219 memset(&audio_params, 0, sizeof(audio_params));
hualing chen43a89bc2022-01-19 14:31:20 +08002220
Wentao MA270dc0f2022-08-23 13:17:26 +08002221 audio_params.pid = now_pids.audio.pid;
2222 audio_params.codectype= _dvr_convert_stream_fmt(now_pids.audio.format, DVR_TRUE);
Wentao MA6d045b32022-02-18 18:47:25 +08002223 player->has_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08002224 DVR_PB_INFO("restart audio when stop ad");
Wentao MA270dc0f2022-08-23 13:17:26 +08002225 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08002226 if (player->audio_presentation_id > -1) {
2227 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
2228 }
Wentao MA6d045b32022-02-18 18:47:25 +08002229 AmTsPlayer_startAudioDecoding(player->handle);
hualing chen43a89bc2022-01-19 14:31:20 +08002230 }
Wentao MA6d045b32022-02-18 18:47:25 +08002231 }
hualing chen86e7d482020-01-16 15:13:33 +08002232 }
2233 }
2234 return 0;
hualing chenb31a6c62020-01-13 17:27:00 +08002235}
hualing chena5f03222021-12-02 11:22:35 +08002236/**\brief dvr play back only update segment pids info
2237 * only update pid info not to start stop codec.
2238 * \param[in] handle playback handle
2239 * \param[in] segment_id need updated pids segment id
2240 * \param[in] p_pids need updated pids
2241 * \retval DVR_SUCCESS On success
2242 * \return Error code
2243 */
2244int dvr_playback_only_update_segment_pids(DVR_PlaybackHandle_t handle, uint64_t segment_id, DVR_PlaybackPids_t *p_pids) {
2245 DVR_Playback_t *player = (DVR_Playback_t *) handle;
2246 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002247 DVR_PB_INFO("player is NULL");
hualing chena5f03222021-12-02 11:22:35 +08002248 return DVR_FAILURE;
2249 }
2250
2251 DVR_PlaybackSegmentInfo_t *segment;
Wentao MA96f68962022-06-15 19:45:35 +08002252 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002253 dvr_mutex_lock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08002254 DVR_PB_INFO("get lock update segment id: %lld cur id %lld", segment_id, player->cur_segment_id);
wentao.mafd5283f2022-10-14 09:51:13 +08002255 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08002256 // prefetch() here incurring self_assign is used to avoid some compiling
2257 // warnings.
2258 // coverity[self_assign]
hualing chena5f03222021-12-02 11:22:35 +08002259 list_for_each_entry(segment, &player->segment_list, head)
2260 {
2261 if (segment->segment_id == segment_id) {
2262 if (player->cur_segment_id == segment_id) {
2263 if (player->cmd.state == DVR_PLAYBACK_STATE_FF
Wentao MA16f870e2022-09-09 11:00:22 +08002264 || player->cmd.state == DVR_PLAYBACK_STATE_FB) {
hualing chena5f03222021-12-02 11:22:35 +08002265 //do nothing when ff fb
Wentao MA96f68962022-06-15 19:45:35 +08002266 DVR_PB_INFO("unlock now is ff fb, not to update cur segment info\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002267 dvr_mutex_unlock(&player->lock);
hualing chena5f03222021-12-02 11:22:35 +08002268 return 0;
2269 }
2270 memcpy(&player->cur_segment.pids, p_pids, sizeof(DVR_PlaybackPids_t));
2271 }
2272 //save pids info
Wentao MA96f68962022-06-15 19:45:35 +08002273 DVR_PB_INFO(":apid :%d %d", segment->pids.audio.pid, p_pids->audio.pid);
hualing chena5f03222021-12-02 11:22:35 +08002274 memcpy(&segment->pids, p_pids, sizeof(DVR_PlaybackPids_t));
Wentao MA96f68962022-06-15 19:45:35 +08002275 DVR_PB_INFO(":cp apid :%d %d", segment->pids.audio.pid, p_pids->audio.pid);
hualing chena5f03222021-12-02 11:22:35 +08002276 break;
2277 }
2278 }
Wentao MA96f68962022-06-15 19:45:35 +08002279 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002280 dvr_mutex_unlock(&player->lock);
hualing chena5f03222021-12-02 11:22:35 +08002281 return DVR_SUCCESS;
2282}
2283
hualing chen5cbe1a62020-02-10 16:36:36 +08002284/**\brief dvr play back update segment pids
2285 * if updated segment is ongoing segment, we need start new
hualing chenb31a6c62020-01-13 17:27:00 +08002286 * add pid stream and stop remove pid stream.
2287 * \param[in] handle playback handle
hualing chen5cbe1a62020-02-10 16:36:36 +08002288 * \param[in] segment_id need updated pids segment id
hualing chenb31a6c62020-01-13 17:27:00 +08002289 * \retval DVR_SUCCESS On success
2290 * \return Error code
2291 */
hualing chen5cbe1a62020-02-10 16:36:36 +08002292int dvr_playback_update_segment_pids(DVR_PlaybackHandle_t handle, uint64_t segment_id, DVR_PlaybackPids_t *p_pids) {
hualing chen040df222020-01-17 13:35:02 +08002293 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08002294 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002295 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002296 return DVR_FAILURE;
2297 }
2298
hualing chen040df222020-01-17 13:35:02 +08002299 DVR_PlaybackSegmentInfo_t *segment;
Wentao MA96f68962022-06-15 19:45:35 +08002300 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002301 dvr_mutex_lock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08002302 DVR_PB_INFO("get lock update segment id: %lld cur id %lld", segment_id, player->cur_segment_id);
hualing chencc91e1c2020-02-28 13:26:17 +08002303
wentao.mafd5283f2022-10-14 09:51:13 +08002304 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08002305 // prefetch() here incurring self_assign is used to avoid some compiling
2306 // warnings.
2307 // coverity[self_assign]
hualing chen040df222020-01-17 13:35:02 +08002308 list_for_each_entry(segment, &player->segment_list, head)
hualing chen86e7d482020-01-16 15:13:33 +08002309 {
hualing chen040df222020-01-17 13:35:02 +08002310 if (segment->segment_id == segment_id) {
hualing chen5cbe1a62020-02-10 16:36:36 +08002311
2312 if (player->cur_segment_id == segment_id) {
2313 if (player->cmd.state == DVR_PLAYBACK_STATE_FF
Wentao MA16f870e2022-09-09 11:00:22 +08002314 || player->cmd.state == DVR_PLAYBACK_STATE_FB) {
hualing chen5cbe1a62020-02-10 16:36:36 +08002315 //do nothing when ff fb
Wentao MA96f68962022-06-15 19:45:35 +08002316 DVR_PB_INFO("unlock now is ff fb, not to update cur segment info\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002317 dvr_mutex_unlock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08002318 return 0;
2319 }
2320
2321 //if segment is on going segment,we need stop start stream
2322 if (player->cmd.state == DVR_PLAYBACK_STATE_START) {
Wentao MA96f68962022-06-15 19:45:35 +08002323 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002324 dvr_mutex_unlock(&player->lock);
hualing chen8a657f32021-08-30 13:12:49 +08002325 if (segment->pids.audio.pid != p_pids->audio.pid &&
2326 segment->pids.audio.pid == 0x1fff) {
hualing chena5f03222021-12-02 11:22:35 +08002327 //not used this to seek to start pos.we will
Wentao MA9a164002022-08-29 11:20:24 +08002328 //add update only api. if need seek to start
hualing chena5f03222021-12-02 11:22:35 +08002329 //pos, we will call only update api and used seek api
2330 //to start and stop av codec
2331 if (0 && player->need_seek_start == DVR_TRUE) {
hualing chen8a657f32021-08-30 13:12:49 +08002332 player->need_seek_start = DVR_FALSE;
2333 pthread_mutex_lock(&player->segment_lock);
2334 player->drop_ts = DVR_TRUE;
2335 player->ts_cache_len = 0;
2336 if (player->first_start_time > 0)
2337 player->first_start_time = player->first_start_time - 1;
Wentao MAf35c3882023-04-17 12:36:19 +08002338 segment_seek(player->segment_handle, (uint64_t)(player->first_start_time), player->openParams.block_size);
Wentao MA96f68962022-06-15 19:45:35 +08002339 DVR_PB_ERROR("unlock segment update need seek time_offset %llu [0x%x][0x%x]", player->first_start_time, segment->pids.audio.pid, segment->pids.ad.pid);
hualing chen8a657f32021-08-30 13:12:49 +08002340 pthread_mutex_unlock(&player->segment_lock);
2341 }
2342 }
hualing chen1679f812021-11-08 15:17:46 +08002343 //check video pids, stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +08002344 _do_handle_pid_update((DVR_PlaybackHandle_t)player, segment->pids, *p_pids, 0);
hualing chen1679f812021-11-08 15:17:46 +08002345 //check sub audio pids stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +08002346 _do_handle_pid_update((DVR_PlaybackHandle_t)player, segment->pids, *p_pids, 2);
hualing chen1679f812021-11-08 15:17:46 +08002347 //check audio pids stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +08002348 _do_handle_pid_update((DVR_PlaybackHandle_t)player, segment->pids, *p_pids, 1);
hualing chen1679f812021-11-08 15:17:46 +08002349 //check pcr pids stop or restart
Wentao MA6dcdc342023-01-30 17:03:19 +08002350 _do_handle_pid_update((DVR_PlaybackHandle_t)player, segment->pids, *p_pids, 3);
hualing chen1679f812021-11-08 15:17:46 +08002351
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002352 dvr_mutex_lock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08002353 } else if (player->cmd.state == DVR_PLAYBACK_STATE_PAUSE) {
2354 //if state is pause, we need process at resume api. we only record change info
2355 int v_cmd = DVR_PLAYBACK_CMD_NONE;
2356 int a_cmd = DVR_PLAYBACK_CMD_NONE;
Zhiqiang Han83923642023-11-03 12:06:48 +08002357
2358 #define CHECK_IF_NEED_RESTART(_now, _next, _cmd, _v_cmd) \
2359 if (VALID_PID(_now) && VALID_PID(_next) && (_now) != (_next)) \
2360 (_cmd) = (_v_cmd);
2361
2362 #define CHECK_IF_NEED_STOP(_now, _next, _cmd, _v_cmd) \
2363 if (VALID_PID(_now) && !VALID_PID(_next)) \
2364 (_cmd) = (_v_cmd);
2365
2366 #define CHECK_IF_NEED_START(_now, _next, _cmd, _v_cmd) \
2367 if (!VALID_PID(_now) && VALID_PID(_next)) \
2368 (_cmd) = (_v_cmd);
2369
2370 CHECK_IF_NEED_RESTART(segment->pids.video.pid, p_pids->video.pid, v_cmd, DVR_PLAYBACK_CMD_V_RESTART);
2371 CHECK_IF_NEED_STOP(segment->pids.video.pid, p_pids->video.pid, v_cmd, DVR_PLAYBACK_CMD_V_STOP);
2372 CHECK_IF_NEED_START(segment->pids.video.pid, p_pids->video.pid, v_cmd, DVR_PLAYBACK_CMD_V_START);
2373
2374 CHECK_IF_NEED_RESTART(segment->pids.audio.pid, p_pids->audio.pid, a_cmd, DVR_PLAYBACK_CMD_A_RESTART);
2375 CHECK_IF_NEED_STOP(segment->pids.audio.pid, p_pids->audio.pid, a_cmd, DVR_PLAYBACK_CMD_A_STOP);
2376 CHECK_IF_NEED_START(segment->pids.audio.pid, p_pids->audio.pid, a_cmd, DVR_PLAYBACK_CMD_A_START);
Zhiqiang Han400e2a12023-10-23 09:12:32 +08002377
2378 /*process the ad, if main audio exists, but no action*/
2379 if (a_cmd == DVR_PLAYBACK_CMD_NONE && VALID_PID(p_pids->audio.pid)) {
2380
Zhiqiang Han83923642023-11-03 12:06:48 +08002381 CHECK_IF_NEED_RESTART(segment->pids.ad.pid, p_pids->ad.pid, a_cmd, DVR_PLAYBACK_CMD_A_RESTART);
2382 CHECK_IF_NEED_STOP(segment->pids.ad.pid, p_pids->ad.pid, a_cmd, DVR_PLAYBACK_CMD_A_RESTART);
2383 CHECK_IF_NEED_START(segment->pids.ad.pid, p_pids->ad.pid, a_cmd, DVR_PLAYBACK_CMD_A_RESTART);
Zhiqiang Han400e2a12023-10-23 09:12:32 +08002384
2385 }
2386
Zhiqiang Han83923642023-11-03 12:06:48 +08002387 DVR_PB_INFO("%s, v_cmd[%#x] a_cmd[%#x]", __func__, v_cmd, a_cmd);
hualing chen5cbe1a62020-02-10 16:36:36 +08002388
Zhiqiang Han83923642023-11-03 12:06:48 +08002389 if (player->cmd.last_cmd == DVR_PLAYBACK_CMD_PAUSE
2390 && player->cmd.cur_cmd != DVR_PLAYBACK_CMD_NONE) {
2391 /*another cmd coming in pause mode, should check and merge with last cmd*/
2392 player->cmd.cur_cmd |= a_cmd | v_cmd;
2393 } else {
2394 player->cmd.cur_cmd = a_cmd | v_cmd;
hualing chen5cbe1a62020-02-10 16:36:36 +08002395 }
Zhiqiang Han83923642023-11-03 12:06:48 +08002396 player->cmd.last_cmd = DVR_PLAYBACK_CMD_PAUSE;
2397
2398 DVR_PB_INFO("%s, last_cmd[%#x] cur_cmd[%#x]", __func__, player->cmd.last_cmd, player->cmd.cur_cmd);
hualing chen5cbe1a62020-02-10 16:36:36 +08002399 }
Zhiqiang Han83923642023-11-03 12:06:48 +08002400
hualing chene10666f2020-04-14 13:58:37 +08002401 memcpy(&player->cur_segment.pids, p_pids, sizeof(DVR_PlaybackPids_t));
hualing chen5cbe1a62020-02-10 16:36:36 +08002402 }
hualing chen86e7d482020-01-16 15:13:33 +08002403 //save pids info
Zhiqiang Han83923642023-11-03 12:06:48 +08002404 DVR_PB_INFO(":vpid :%d -> %d", segment->pids.video.pid, p_pids->video.pid);
2405 DVR_PB_INFO(":apid :%d -> %d", segment->pids.audio.pid, p_pids->audio.pid);
2406 DVR_PB_INFO(":adpid :%d -> %d", segment->pids.ad.pid, p_pids->ad.pid);
hualing chen040df222020-01-17 13:35:02 +08002407 memcpy(&segment->pids, p_pids, sizeof(DVR_PlaybackPids_t));
hualing chen86e7d482020-01-16 15:13:33 +08002408 break;
hualing chenb31a6c62020-01-13 17:27:00 +08002409 }
hualing chen86e7d482020-01-16 15:13:33 +08002410 }
Wentao MA96f68962022-06-15 19:45:35 +08002411 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002412 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002413 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002414}
2415/**\brief Stop play, will stop video and audio
2416 * \param[in] handle playback handle
2417 * \param[in] clear is clear last frame
2418 * \retval DVR_SUCCESS On success
2419 * \return Error code
2420 */
hualing chen040df222020-01-17 13:35:02 +08002421int dvr_playback_stop(DVR_PlaybackHandle_t handle, DVR_Bool_t clear) {
2422 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MAe8ba5172022-08-09 11:18:17 +08002423 DVR_UNUSED(clear);
hualing chena540a7e2020-03-27 16:44:05 +08002424 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002425 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002426 return DVR_FAILURE;
2427 }
hualing chenb96aa2c2020-04-15 14:13:53 +08002428 if (player->state == DVR_PLAYBACK_STATE_STOP) {
Wentao MA96f68962022-06-15 19:45:35 +08002429 DVR_PB_INFO(":playback is stoped");
hualing chenb96aa2c2020-04-15 14:13:53 +08002430 return DVR_SUCCESS;
2431 }
Ke Gong3c0caba2020-04-21 22:58:18 -07002432 if (player->state == DVR_PLAYBACK_STATE_STOP) {
Wentao MA96f68962022-06-15 19:45:35 +08002433 DVR_PB_INFO(":playback is stoped");
Ke Gong3c0caba2020-04-21 22:58:18 -07002434 return DVR_SUCCESS;
2435 }
hualing chen87072a82020-03-12 16:20:12 +08002436 _stop_playback_thread(handle);
Wentao MA96f68962022-06-15 19:45:35 +08002437 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002438 dvr_mutex_lock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08002439 DVR_PB_INFO(":get lock into stop fast");
hualing chen31140872020-03-25 12:29:26 +08002440 AmTsPlayer_stopFast(player->handle);
hualing chen266b9502020-04-04 17:39:39 +08002441 if (player->has_video) {
2442 AmTsPlayer_resumeVideoDecoding(player->handle);
2443 }
2444 if (player->has_audio) {
2445 AmTsPlayer_resumeAudioDecoding(player->handle);
2446 }
2447 if (player->has_video) {
2448 player->has_video = DVR_FALSE;
hualing chen10cdb162021-02-05 10:44:41 +08002449 AmTsPlayer_hideVideo(player->handle);
hualing chen266b9502020-04-04 17:39:39 +08002450 AmTsPlayer_stopVideoDecoding(player->handle);
2451 }
2452 if (player->has_audio) {
2453 player->has_audio = DVR_FALSE;
2454 AmTsPlayer_stopAudioDecoding(player->handle);
2455 }
hualing chendf118dd2020-05-21 15:49:11 +08002456 if (player->has_ad_audio) {
2457 player->has_ad_audio =DVR_FALSE;
2458 AmTsPlayer_disableADMix(player->handle);
2459 }
hualing chen266b9502020-04-04 17:39:39 +08002460
hualing chen86e7d482020-01-16 15:13:33 +08002461 player->cmd.last_cmd = player->cmd.cur_cmd;
hualing chen040df222020-01-17 13:35:02 +08002462 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_STOP;
2463 player->cmd.state = DVR_PLAYBACK_STATE_STOP;
Wentao MA907b6432022-08-01 06:23:08 +00002464 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_STOP);
hualing chen87072a82020-03-12 16:20:12 +08002465 player->cur_segment_id = UINT64_MAX;
2466 player->segment_is_open = DVR_FALSE;
Wentao MA96f68962022-06-15 19:45:35 +08002467 DVR_PB_DEBUG("unlock");
2468 DVR_PB_INFO("player->state %s", _dvr_playback_state_toString(player->state));
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002469 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002470 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002471}
2472/**\brief Start play audio
2473 * \param[in] handle playback handle
2474 * \param[in] params audio playback params,contains fmt and pid...
2475 * \retval DVR_SUCCESS On success
2476 * \return Error code
2477 */
hualing chen2aba4022020-03-02 13:49:55 +08002478
Wentao MA270dc0f2022-08-23 13:17:26 +08002479int dvr_playback_audio_start(DVR_PlaybackHandle_t handle, am_tsplayer_audio_params *param, am_tsplayer_audio_params *ad_param) {
hualing chen040df222020-01-17 13:35:02 +08002480 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08002481
2482 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002483 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002484 return DVR_FAILURE;
2485 }
hualing chen86e7d482020-01-16 15:13:33 +08002486 _start_playback_thread(handle);
2487 //start audio and video
Wentao MA96f68962022-06-15 19:45:35 +08002488 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002489 dvr_mutex_lock(&player->lock);
hualing chendf118dd2020-05-21 15:49:11 +08002490
Wentao MA270dc0f2022-08-23 13:17:26 +08002491 if (VALID_PID(ad_param->pid)) {
hualing chendf118dd2020-05-21 15:49:11 +08002492 player->has_ad_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08002493 DVR_PB_INFO("start ad audio");
Wentao MA270dc0f2022-08-23 13:17:26 +08002494 AmTsPlayer_setADParams(player->handle, ad_param);
hualing chendf118dd2020-05-21 15:49:11 +08002495 AmTsPlayer_enableADMix(player->handle);
2496 }
hualing chen969fe7b2021-05-26 15:13:17 +08002497 if (VALID_PID(param->pid)) {
Wentao MA96f68962022-06-15 19:45:35 +08002498 DVR_PB_INFO("start audio");
hualing chen969fe7b2021-05-26 15:13:17 +08002499 player->has_audio = DVR_TRUE;
2500 AmTsPlayer_setAudioParams(player->handle, param);
Wentao MA5629ad82022-08-24 10:03:02 +08002501 if (player->audio_presentation_id > -1) {
2502 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
2503 }
hualing chen969fe7b2021-05-26 15:13:17 +08002504 AmTsPlayer_startAudioDecoding(player->handle);
2505 }
hualing chendf118dd2020-05-21 15:49:11 +08002506
hualing chen86e7d482020-01-16 15:13:33 +08002507 player->cmd.last_cmd = player->cmd.cur_cmd;
Wentao MA270dc0f2022-08-23 13:17:26 +08002508 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_A_START;
hualing chen040df222020-01-17 13:35:02 +08002509 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00002510 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
Wentao MA96f68962022-06-15 19:45:35 +08002511 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002512 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002513 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002514}
2515/**\brief Stop play audio
2516 * \param[in] handle playback handle
2517 * \retval DVR_SUCCESS On success
2518 * \return Error code
2519 */
hualing chen040df222020-01-17 13:35:02 +08002520int dvr_playback_audio_stop(DVR_PlaybackHandle_t handle) {
2521 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08002522
2523 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002524 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002525 return DVR_FAILURE;
2526 }
2527
hualing chen2aba4022020-03-02 13:49:55 +08002528 //playback_device_audio_stop(player->handle);
hualing chen86e7d482020-01-16 15:13:33 +08002529 if (player->has_video == DVR_FALSE) {
hualing chen040df222020-01-17 13:35:02 +08002530 player->cmd.state = DVR_PLAYBACK_STATE_STOP;
Wentao MA907b6432022-08-01 06:23:08 +00002531 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_STOP);
Wentao MA9a164002022-08-29 11:20:24 +08002532 //destroy thread
hualing chen86e7d482020-01-16 15:13:33 +08002533 _stop_playback_thread(handle);
2534 } else {
2535 //do nothing.video is playing
2536 }
Wentao MA96f68962022-06-15 19:45:35 +08002537 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002538 dvr_mutex_lock(&player->lock);
hualing chen7a56cba2020-04-14 14:09:27 +08002539
hualing chenf00cdc82020-06-10 14:23:35 +08002540 if (player->has_audio) {
hualing chendf118dd2020-05-21 15:49:11 +08002541 player->has_audio = DVR_FALSE;
2542 AmTsPlayer_stopAudioDecoding(player->handle);
2543 }
hualing chen87072a82020-03-12 16:20:12 +08002544
hualing chendf118dd2020-05-21 15:49:11 +08002545 if (player->has_ad_audio) {
2546 player->has_ad_audio =DVR_FALSE;
2547 AmTsPlayer_disableADMix(player->handle);
2548 }
2549
hualing chen87072a82020-03-12 16:20:12 +08002550 player->cmd.last_cmd = player->cmd.cur_cmd;
Wentao MA270dc0f2022-08-23 13:17:26 +08002551 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_A_STOP;
hualing chen87072a82020-03-12 16:20:12 +08002552
Wentao MA96f68962022-06-15 19:45:35 +08002553 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002554 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002555 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002556}
2557/**\brief Start play video
2558 * \param[in] handle playback handle
2559 * \param[in] params video playback params,contains fmt and pid...
2560 * \retval DVR_SUCCESS On success
2561 * \return Error code
2562 */
hualing chen2aba4022020-03-02 13:49:55 +08002563int dvr_playback_video_start(DVR_PlaybackHandle_t handle, am_tsplayer_video_params *param) {
hualing chen040df222020-01-17 13:35:02 +08002564 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08002565
2566 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002567 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002568 return DVR_FAILURE;
2569 }
2570
hualing chen86e7d482020-01-16 15:13:33 +08002571 _start_playback_thread(handle);
2572 //start audio and video
Wentao MA96f68962022-06-15 19:45:35 +08002573 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002574 dvr_mutex_lock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08002575 player->has_video = DVR_TRUE;
hualing chena540a7e2020-03-27 16:44:05 +08002576 AmTsPlayer_setVideoParams(player->handle, param);
hualing chen21a40372021-10-29 11:07:26 +08002577 AmTsPlayer_setVideoBlackOut(player->handle, 1);
hualing chena540a7e2020-03-27 16:44:05 +08002578 AmTsPlayer_startVideoDecoding(player->handle);
hualing chen2aba4022020-03-02 13:49:55 +08002579
2580 //playback_device_video_start(player->handle , param);
hualing chen86e7d482020-01-16 15:13:33 +08002581 //if set flag is pause live, we need set trick mode
hualing chen5cbe1a62020-02-10 16:36:36 +08002582 if ((player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE) {
Wentao MA96f68962022-06-15 19:45:35 +08002583 DVR_PB_INFO("settrick mode at video start");
hualing chen2aba4022020-03-02 13:49:55 +08002584 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_PAUSE_NEXT);
2585 //playback_device_trick_mode(player->handle, 1);
hualing chen86e7d482020-01-16 15:13:33 +08002586 }
2587 player->cmd.last_cmd = player->cmd.cur_cmd;
Wentao MA270dc0f2022-08-23 13:17:26 +08002588 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_V_START;
hualing chen040df222020-01-17 13:35:02 +08002589 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00002590 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
Wentao MA96f68962022-06-15 19:45:35 +08002591 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002592 dvr_mutex_unlock(&player->lock);
hualing chenb31a6c62020-01-13 17:27:00 +08002593 return DVR_SUCCESS;
2594}
2595/**\brief Stop play video
2596 * \param[in] handle playback handle
2597 * \retval DVR_SUCCESS On success
2598 * \return Error code
2599 */
hualing chen040df222020-01-17 13:35:02 +08002600int dvr_playback_video_stop(DVR_PlaybackHandle_t handle) {
2601 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08002602
2603 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002604 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002605 return DVR_FAILURE;
2606 }
2607
hualing chen86e7d482020-01-16 15:13:33 +08002608 if (player->has_audio == DVR_FALSE) {
hualing chen040df222020-01-17 13:35:02 +08002609 player->cmd.state = DVR_PLAYBACK_STATE_STOP;
Wentao MA907b6432022-08-01 06:23:08 +00002610 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_STOP);
Wentao MA9a164002022-08-29 11:20:24 +08002611 //destroy thread
hualing chen86e7d482020-01-16 15:13:33 +08002612 _stop_playback_thread(handle);
2613 } else {
2614 //do nothing.audio is playing
2615 }
hualing chen7a56cba2020-04-14 14:09:27 +08002616
Wentao MA96f68962022-06-15 19:45:35 +08002617 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002618 dvr_mutex_lock(&player->lock);
hualing chen7a56cba2020-04-14 14:09:27 +08002619
hualing chen87072a82020-03-12 16:20:12 +08002620 player->has_video = DVR_FALSE;
2621
2622 AmTsPlayer_stopVideoDecoding(player->handle);
2623 //playback_device_video_stop(player->handle);
2624
2625 player->cmd.last_cmd = player->cmd.cur_cmd;
Wentao MA270dc0f2022-08-23 13:17:26 +08002626 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_V_STOP;
hualing chen87072a82020-03-12 16:20:12 +08002627
Wentao MA96f68962022-06-15 19:45:35 +08002628 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002629 dvr_mutex_unlock(&player->lock);
hualing chenb31a6c62020-01-13 17:27:00 +08002630 return DVR_SUCCESS;
2631}
2632/**\brief Pause play
2633 * \param[in] handle playback handle
2634 * \param[in] flush whether its internal buffers should be flushed
2635 * \retval DVR_SUCCESS On success
2636 * \return Error code
2637 */
hualing chen040df222020-01-17 13:35:02 +08002638int dvr_playback_pause(DVR_PlaybackHandle_t handle, DVR_Bool_t flush) {
2639 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MAe8ba5172022-08-09 11:18:17 +08002640 DVR_UNUSED(flush);
hualing chena540a7e2020-03-27 16:44:05 +08002641 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002642 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002643 return DVR_FAILURE;
2644 }
hualing chenf00cdc82020-06-10 14:23:35 +08002645 if (player->state == DVR_PLAYBACK_STATE_PAUSE ||player->state == DVR_PLAYBACK_STATE_STOP ) {
Wentao MA96f68962022-06-15 19:45:35 +08002646 DVR_PB_INFO("player state is [%d] pause or stop", player->state);
hualing chenbd977fd2020-06-29 19:14:18 +08002647 return DVR_SUCCESS;
hualing chenf00cdc82020-06-10 14:23:35 +08002648 }
Wentao MA96f68962022-06-15 19:45:35 +08002649 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002650 dvr_mutex_lock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08002651 DVR_PB_DEBUG("get lock");
hualing chen266b9502020-04-04 17:39:39 +08002652 if (player->has_video)
2653 AmTsPlayer_pauseVideoDecoding(player->handle);
hualing chene41f4372020-06-06 16:29:17 +08002654 if (player->has_audio)
hualing chen266b9502020-04-04 17:39:39 +08002655 AmTsPlayer_pauseAudioDecoding(player->handle);
hualing chen2aba4022020-03-02 13:49:55 +08002656
2657 //playback_device_pause(player->handle);
hualing chen87072a82020-03-12 16:20:12 +08002658 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
2659 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB) {
2660 player->cmd.state = DVR_PLAYBACK_STATE_PAUSE;
Wentao MA907b6432022-08-01 06:23:08 +00002661 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_PAUSE);
hualing chen87072a82020-03-12 16:20:12 +08002662 } else {
2663 player->cmd.last_cmd = player->cmd.cur_cmd;
2664 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_PAUSE;
2665 player->cmd.state = DVR_PLAYBACK_STATE_PAUSE;
Wentao MA907b6432022-08-01 06:23:08 +00002666 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_PAUSE);
hualing chen87072a82020-03-12 16:20:12 +08002667 }
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002668 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08002669 DVR_PB_DEBUG("unlock");
hualing chen2aba4022020-03-02 13:49:55 +08002670
hualing chen86e7d482020-01-16 15:13:33 +08002671 return DVR_SUCCESS;
hualing chenb31a6c62020-01-13 17:27:00 +08002672}
2673
hualing chen5cbe1a62020-02-10 16:36:36 +08002674//not add lock
2675static int _dvr_cmd(DVR_PlaybackHandle_t handle, int cmd)
2676{
2677 DVR_Playback_t *player = (DVR_Playback_t *) handle;
2678
hualing chena540a7e2020-03-27 16:44:05 +08002679 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002680 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002681 return DVR_FAILURE;
2682 }
2683
hualing chen5cbe1a62020-02-10 16:36:36 +08002684 //get video params and audio params
Wentao MA96f68962022-06-15 19:45:35 +08002685 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002686 dvr_mutex_lock(&player->lock);
Wentao MA270dc0f2022-08-23 13:17:26 +08002687 am_tsplayer_video_params video_params;
2688 am_tsplayer_audio_params audio_params;
2689 am_tsplayer_audio_params ad_params;
hualing chencc91e1c2020-02-28 13:26:17 +08002690 uint64_t segmentid = player->cur_segment_id;
hualing chen5cbe1a62020-02-10 16:36:36 +08002691
Wentao MA270dc0f2022-08-23 13:17:26 +08002692 memset(&video_params, 0, sizeof(video_params));
2693 memset(&audio_params, 0, sizeof(audio_params));
jiangfei.hanb8fbad42021-07-29 15:04:48 +08002694
Wentao MA270dc0f2022-08-23 13:17:26 +08002695 _dvr_playback_get_playinfo(handle, segmentid, &video_params, &audio_params, &ad_params);
Zhiqiang Han83923642023-11-03 12:06:48 +08002696 DVR_PB_INFO("unlock, _dvr_cmd: %#x", cmd);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002697 dvr_mutex_unlock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08002698
Zhiqiang Han83923642023-11-03 12:06:48 +08002699 if (DVR_PLAYBACK_CMD_IS_V_RESTART(cmd) && DVR_PLAYBACK_CMD_IS_A_RESTART(cmd)) {
2700
2701 DVR_PB_INFO("do_cmd av_restart");
2702 _dvr_playback_replay((DVR_PlaybackHandle_t)player, DVR_FALSE);
2703
2704 } else if (cmd == DVR_PLAYBACK_CMD_FF || cmd == DVR_PLAYBACK_CMD_FB) {
2705
2706 _dvr_playback_fffb((DVR_PlaybackHandle_t)player);
2707
2708 } else if (cmd == DVR_PLAYBACK_CMD_START || cmd == DVR_PLAYBACK_CMD_STOP) {
2709
2710 //nop
2711
2712 } else {
2713
2714 if (DVR_PLAYBACK_CMD_IS_A_STOP(cmd)) {
2715 DVR_PB_INFO("do_cmd a_stop");
2716 dvr_playback_audio_stop((DVR_PlaybackHandle_t)player);
2717 }
2718
2719 if (DVR_PLAYBACK_CMD_IS_V_STOP(cmd)) {
2720 DVR_PB_INFO("do_cmd v_stop");
hualing chen2aba4022020-03-02 13:49:55 +08002721 dvr_playback_video_stop((DVR_PlaybackHandle_t)player);
Zhiqiang Han83923642023-11-03 12:06:48 +08002722 }
2723
2724 if (DVR_PLAYBACK_CMD_IS_V_START(cmd)) {
2725 DVR_PB_INFO("do_cmd v_start");
Wentao MA270dc0f2022-08-23 13:17:26 +08002726 dvr_playback_video_start((DVR_PlaybackHandle_t)player, &video_params);
Zhiqiang Han83923642023-11-03 12:06:48 +08002727 }
2728
2729 if (DVR_PLAYBACK_CMD_IS_A_START(cmd)) {
2730 DVR_PB_INFO("do_cmd a_start");
Wentao MA270dc0f2022-08-23 13:17:26 +08002731 dvr_playback_audio_start((DVR_PlaybackHandle_t)player, &audio_params, &ad_params);
Zhiqiang Han83923642023-11-03 12:06:48 +08002732 }
hualing chen5cbe1a62020-02-10 16:36:36 +08002733 }
Zhiqiang Han83923642023-11-03 12:06:48 +08002734
hualing chen5cbe1a62020-02-10 16:36:36 +08002735 return DVR_SUCCESS;
2736}
2737
2738/**\brief Resume play
hualing chenb31a6c62020-01-13 17:27:00 +08002739 * \param[in] handle playback handle
hualing chenb31a6c62020-01-13 17:27:00 +08002740 * \retval DVR_SUCCESS On success
2741 * \return Error code
2742 */
hualing chen5cbe1a62020-02-10 16:36:36 +08002743int dvr_playback_resume(DVR_PlaybackHandle_t handle) {
2744 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen7ea70a72021-09-09 11:25:13 +08002745 uint32_t pos = 0;
hualing chen03fd4942021-07-15 15:56:41 +08002746 uint64_t segmentid = 0;
hualing chena540a7e2020-03-27 16:44:05 +08002747 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002748 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002749 return DVR_FAILURE;
2750 }
2751
hualing chena991aa82021-08-16 10:21:15 +08002752 if (dvr_playback_check_limit(handle)) {
2753 //get id and pos to check if we can seek to this pos
Wentao MA96f68962022-06-15 19:45:35 +08002754 DVR_PB_INFO("player start calculate time");
hualing chena991aa82021-08-16 10:21:15 +08002755 dvr_playback_calculate_last_valid_segment(handle, &segmentid, &pos);
2756 if (segmentid != player->cur_segment_id ||
2757 (segmentid == player->cur_segment_id &&
2758 pos > _dvr_get_cur_time(handle))) {
2759 //first to seek new pos and to resume
Wentao MA96f68962022-06-15 19:45:35 +08002760 DVR_PB_INFO("seek new pos and to resume");
hualing chena991aa82021-08-16 10:21:15 +08002761 dvr_playback_seek(handle, segmentid, pos);
2762 }
hualing chen7ea70a72021-09-09 11:25:13 +08002763 } else {
Wentao MA96f68962022-06-15 19:45:35 +08002764 DVR_PB_INFO("player is not set limit");
hualing chen03fd4942021-07-15 15:56:41 +08002765 }
hualing chena991aa82021-08-16 10:21:15 +08002766
hualing chen5cbe1a62020-02-10 16:36:36 +08002767 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_PAUSE) {
Wentao MA96f68962022-06-15 19:45:35 +08002768 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002769 dvr_mutex_lock(&player->lock);
hualing chen1ffd85b2021-08-16 15:18:43 +08002770 player->first_frame = 0;
2771 if (player->has_video)
2772 AmTsPlayer_pauseVideoDecoding(player->handle);
2773 if (player->has_audio)
2774 AmTsPlayer_pauseAudioDecoding(player->handle);
2775
hualing chen266b9502020-04-04 17:39:39 +08002776 if (player->has_video) {
Wentao MA96f68962022-06-15 19:45:35 +08002777 DVR_PB_INFO("dvr_playback_resume set trick mode none");
hualing chen266b9502020-04-04 17:39:39 +08002778 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
2779 AmTsPlayer_resumeVideoDecoding(player->handle);
2780 }
2781 if (player->has_audio) {
2782 AmTsPlayer_resumeAudioDecoding(player->handle);
2783 }
2784 //check is has audio param,if has audio .we need start audio,
2785 //we will stop audio when ff fb, if reach end, we will pause.so we need
2786 //start audio when resume play
2787
Wentao MA270dc0f2022-08-23 13:17:26 +08002788 am_tsplayer_video_params video_params;
2789 am_tsplayer_audio_params audio_params;
2790 am_tsplayer_audio_params ad_params;
hualing chen266b9502020-04-04 17:39:39 +08002791 uint64_t segmentid = player->cur_segment_id;
jiangfei.hanb8fbad42021-07-29 15:04:48 +08002792
Wentao MA270dc0f2022-08-23 13:17:26 +08002793 memset(&video_params, 0, sizeof(video_params));
2794 memset(&audio_params, 0, sizeof(audio_params));
2795 _dvr_playback_get_playinfo(handle, segmentid, &video_params, &audio_params, &ad_params);
hualing chen266b9502020-04-04 17:39:39 +08002796 //valid audio pid, start audio
Wentao MA270dc0f2022-08-23 13:17:26 +08002797 if (player->has_ad_audio == DVR_FALSE && VALID_PID(ad_params.pid) && (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1)) {
hualing chen969fe7b2021-05-26 15:13:17 +08002798 player->has_ad_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08002799 DVR_PB_INFO("start ad audio");
Wentao MA270dc0f2022-08-23 13:17:26 +08002800 dvr_playback_change_seek_state(handle, ad_params.pid);
2801 AmTsPlayer_setADParams(player->handle, &ad_params);
hualing chen969fe7b2021-05-26 15:13:17 +08002802 AmTsPlayer_enableADMix(player->handle);
2803 }
2804
Wentao MA270dc0f2022-08-23 13:17:26 +08002805 if (player->has_audio == DVR_FALSE && VALID_PID(audio_params.pid) && (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1)) {
hualing chen266b9502020-04-04 17:39:39 +08002806 player->has_audio = DVR_TRUE;
Wentao MA270dc0f2022-08-23 13:17:26 +08002807 dvr_playback_change_seek_state(handle, audio_params.pid);
2808 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08002809 if (player->audio_presentation_id > -1) {
2810 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
2811 }
hualing chen266b9502020-04-04 17:39:39 +08002812 AmTsPlayer_startAudioDecoding(player->handle);
2813 } else {
Wentao MA270dc0f2022-08-23 13:17:26 +08002814 DVR_PB_INFO("audio_params.pid:%d player->has_audio:%d speed:%d", audio_params.pid, player->has_audio, player->cmd.speed.speed.speed);
hualing chen266b9502020-04-04 17:39:39 +08002815 }
hualing chendf118dd2020-05-21 15:49:11 +08002816
hualing chen87072a82020-03-12 16:20:12 +08002817 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
2818 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB) {
2819 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00002820 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
hualing chen87072a82020-03-12 16:20:12 +08002821 } else {
2822 player->cmd.last_cmd = player->cmd.cur_cmd;
2823 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_RESUME;
2824 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00002825 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
hualing chen87072a82020-03-12 16:20:12 +08002826 }
Wentao MA96f68962022-06-15 19:45:35 +08002827 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002828 dvr_mutex_unlock(&player->lock);
hualing chen041c4092020-04-05 15:11:50 +08002829 } else if (player->state == DVR_PLAYBACK_STATE_PAUSE){
Wentao MA96f68962022-06-15 19:45:35 +08002830 DVR_PB_INFO("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002831 dvr_mutex_lock(&player->lock);
hualing chen1ffd85b2021-08-16 15:18:43 +08002832 player->first_frame = 0;
2833 if (player->has_video)
2834 AmTsPlayer_pauseVideoDecoding(player->handle);
2835 if (player->has_audio)
2836 AmTsPlayer_pauseAudioDecoding(player->handle);
2837
hualing chene41f4372020-06-06 16:29:17 +08002838 if (player->has_video) {
Wentao MA96f68962022-06-15 19:45:35 +08002839 DVR_PB_INFO("dvr_playback_resume set trick mode none 1");
hualing chene41f4372020-06-06 16:29:17 +08002840 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
hualing chen041c4092020-04-05 15:11:50 +08002841 AmTsPlayer_resumeVideoDecoding(player->handle);
hualing chene41f4372020-06-06 16:29:17 +08002842 }
hualing chen041c4092020-04-05 15:11:50 +08002843 if (player->has_audio)
2844 AmTsPlayer_resumeAudioDecoding(player->handle);
Wentao MA96f68962022-06-15 19:45:35 +08002845 DVR_PB_INFO("set start state cur cmd[%d]", player->cmd.cur_cmd);
hualing chen9811b212020-10-29 11:21:44 +08002846 if (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1)
2847 _dvr_cmd(handle, player->cmd.cur_cmd);
hualing chend1686e52022-01-05 17:10:42 +08002848 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00002849 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
Wentao MA96f68962022-06-15 19:45:35 +08002850 DVR_PB_INFO("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002851 dvr_mutex_unlock(&player->lock);
hualing chen041c4092020-04-05 15:11:50 +08002852 } else {
2853 if ((player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE)
2854 {
Wentao MA96f68962022-06-15 19:45:35 +08002855 DVR_PB_DEBUG("lock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002856 dvr_mutex_lock(&player->lock);
hualing chen1ffd85b2021-08-16 15:18:43 +08002857 player->first_frame = 0;
2858 if (player->has_video)
2859 AmTsPlayer_pauseVideoDecoding(player->handle);
2860 if (player->has_audio)
2861 AmTsPlayer_pauseAudioDecoding(player->handle);
hualing chen041c4092020-04-05 15:11:50 +08002862 //clear flag
Wentao MA96f68962022-06-15 19:45:35 +08002863 DVR_PB_INFO("clear pause live flag cur cmd[%d]", player->cmd.cur_cmd);
hualing chen041c4092020-04-05 15:11:50 +08002864 player->play_flag = player->play_flag & (~DVR_PLAYBACK_STARTED_PAUSEDLIVE);
2865 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
hualing chen05d09432021-01-25 15:26:55 +08002866 if (player->has_video) {
2867 AmTsPlayer_resumeVideoDecoding(player->handle);
2868 }
2869 if (player->has_audio)
2870 AmTsPlayer_resumeAudioDecoding(player->handle);
Wentao MA96f68962022-06-15 19:45:35 +08002871 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002872 dvr_mutex_unlock(&player->lock);
hualing chen041c4092020-04-05 15:11:50 +08002873 }
hualing chen5cbe1a62020-02-10 16:36:36 +08002874 }
2875 return DVR_SUCCESS;
2876}
2877
hualing chena540a7e2020-03-27 16:44:05 +08002878static DVR_Bool_t _dvr_check_playinfo_changed(DVR_PlaybackHandle_t handle, int segment_id, int set_seg_id){
2879
2880 DVR_Playback_t *player = (DVR_Playback_t *) handle;
2881 DVR_PlaybackSegmentInfo_t *segment = NULL;
2882 DVR_PlaybackSegmentInfo_t *cur_segment = NULL;
2883 DVR_PlaybackSegmentInfo_t *set_segment = NULL;
2884
wentao.mafd5283f2022-10-14 09:51:13 +08002885 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08002886 // prefetch() here incurring self_assign is used to avoid some compiling
2887 // warnings.
2888 // coverity[self_assign]
hualing chena540a7e2020-03-27 16:44:05 +08002889 list_for_each_entry(segment, &player->segment_list, head)
2890 {
2891 if (segment->segment_id == segment_id) {
2892 cur_segment = segment;
2893 }
2894 if (segment->segment_id == set_seg_id) {
2895 set_segment = segment;
2896 }
2897 if (cur_segment != NULL && set_segment != NULL) {
2898 break;
2899 }
2900 }
2901 if (cur_segment == NULL || set_segment == NULL) {
Wentao MA270dc0f2022-08-23 13:17:26 +08002902 DVR_PB_INFO("set segment or cur segment is null");
hualing chena540a7e2020-03-27 16:44:05 +08002903 return DVR_TRUE;
2904 }
2905 if (cur_segment->pids.video.format != set_segment->pids.video.format ||
2906 cur_segment->pids.video.pid != set_segment->pids.video.pid ||
2907 cur_segment->pids.audio.format != set_segment->pids.audio.format ||
2908 cur_segment->pids.audio.pid != set_segment->pids.audio.pid) {
Wentao MA96f68962022-06-15 19:45:35 +08002909 DVR_PB_INFO("cur v[%d]a[%d] set v[%d]a[%d]",cur_segment->pids.video.pid,cur_segment->pids.audio.pid,set_segment->pids.video.pid,set_segment->pids.audio.pid);
hualing chena540a7e2020-03-27 16:44:05 +08002910 return DVR_TRUE;
2911 }
Wentao MA96f68962022-06-15 19:45:35 +08002912 DVR_PB_INFO("play info not change");
hualing chena540a7e2020-03-27 16:44:05 +08002913 return DVR_FALSE;
2914}
2915
hualing chen03fd4942021-07-15 15:56:41 +08002916/**\brief set limit
2917 * \param[in] handle playback handle
2918 * \param[in] rec start time ms
2919 * \param[in] rec limit time ms
2920 * \retval DVR_SUCCESS On success
2921 * \return Error code
2922 */
hualing chen7ea70a72021-09-09 11:25:13 +08002923int dvr_playback_setlimit(DVR_PlaybackHandle_t handle, uint32_t time, uint32_t limit)
hualing chen03fd4942021-07-15 15:56:41 +08002924{ DVR_Playback_t *player = (DVR_Playback_t *) handle;
2925
2926 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002927 DVR_PB_INFO("player is NULL");
hualing chen03fd4942021-07-15 15:56:41 +08002928 return DVR_FAILURE;
2929 }
hualing chen7ea70a72021-09-09 11:25:13 +08002930 _dvr_getClock_sec();
Wentao MA96f68962022-06-15 19:45:35 +08002931 DVR_PB_INFO("lock time %lu limit: %u player->state:%d", time, limit, player->state);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002932 dvr_mutex_lock(&player->lock);
hualing chen03fd4942021-07-15 15:56:41 +08002933 player->rec_start = time;
2934 player->limit = limit;
Wentao MA96f68962022-06-15 19:45:35 +08002935 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002936 dvr_mutex_unlock(&player->lock);
hualing chen03fd4942021-07-15 15:56:41 +08002937 return DVR_SUCCESS;
2938}
2939
hualing chen5cbe1a62020-02-10 16:36:36 +08002940/**\brief seek
2941 * \param[in] handle playback handle
2942 * \param[in] time_offset time offset base cur segment
2943 * \retval DVR_SUCCESS On success
2944 * \return Error code
2945 */
hualing chencc91e1c2020-02-28 13:26:17 +08002946int dvr_playback_seek(DVR_PlaybackHandle_t handle, uint64_t segment_id, uint32_t time_offset) {
hualing chen040df222020-01-17 13:35:02 +08002947 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen03fd4942021-07-15 15:56:41 +08002948 int ret = DVR_SUCCESS;
hualing chena540a7e2020-03-27 16:44:05 +08002949 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08002950 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08002951 return DVR_FAILURE;
2952 }
2953
Wentao MA96f68962022-06-15 19:45:35 +08002954 DVR_PB_INFO("lock segment_id %llu cur id %llu time_offset %u cur end: %d player->state:%d", segment_id,player->cur_segment_id, (uint32_t)time_offset, _dvr_get_end_time(handle), player->state);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002955 dvr_mutex_lock(&player->lock);
hualing chen87072a82020-03-12 16:20:12 +08002956
hualing chena540a7e2020-03-27 16:44:05 +08002957 DVR_Bool_t replay = _dvr_check_playinfo_changed(handle, player->cur_segment_id, segment_id);
Wentao MA96f68962022-06-15 19:45:35 +08002958 DVR_PB_INFO("player->state[%d]-replay[%d]--get lock-", player->state, replay);
hualing chena540a7e2020-03-27 16:44:05 +08002959
hualing chen5cbe1a62020-02-10 16:36:36 +08002960 //open segment if id is not current segment
hualing chen03fd4942021-07-15 15:56:41 +08002961 ret = _dvr_open_segment(handle, segment_id);
hualing chen87072a82020-03-12 16:20:12 +08002962 if (ret ==DVR_FAILURE) {
wentao.maa210e5e2022-10-12 16:10:03 +08002963 DVR_PB_ERROR("unlock seek error at open segment");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08002964 dvr_mutex_unlock(&player->lock);
hualing chen87072a82020-03-12 16:20:12 +08002965 return DVR_FAILURE;
2966 }
2967 if (time_offset >_dvr_get_end_time(handle) &&_dvr_has_next_segmentId(handle, segment_id) == DVR_FAILURE) {
Wentao MAf35c3882023-04-17 12:36:19 +08002968 if (segment_ongoing(player->segment_handle) == DVR_SUCCESS) {
Wentao MA96f68962022-06-15 19:45:35 +08002969 DVR_PB_INFO("is ongoing segment when seek end, need return success");
hualing chen87072a82020-03-12 16:20:12 +08002970 time_offset = _dvr_get_end_time(handle);
2971 } else {
wentao.maa210e5e2022-10-12 16:10:03 +08002972 DVR_PB_ERROR("is not ongoing segment when seek end, return failure");
Zhiqiang Han447cff02022-12-15 11:13:41 +08002973 dvr_mutex_unlock(&player->lock);
wentao.maa210e5e2022-10-12 16:10:03 +08002974 return DVR_FAILURE;
hualing chen87072a82020-03-12 16:20:12 +08002975 }
2976 }
2977
Wentao MA96f68962022-06-15 19:45:35 +08002978 DVR_PB_INFO("seek open id[%lld]flag[0x%x] time_offset %u",
hualing chen03fd4942021-07-15 15:56:41 +08002979 player->cur_segment.segment_id,
2980 player->cur_segment.flags,
2981 time_offset);
hualing chen86e7d482020-01-16 15:13:33 +08002982 //get file offset by time
hualing chen2aba4022020-03-02 13:49:55 +08002983 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB) {
2984 //forward playback.not seek end of file
2985 if (time_offset != 0 && time_offset > FB_DEFAULT_LEFT_TIME) {
2986 //default -2000ms
2987 time_offset = time_offset -FB_DEFAULT_LEFT_TIME;
2988 }
hualing chen86e7d482020-01-16 15:13:33 +08002989 }
Wentao MA01de0e62022-01-10 18:48:23 +08002990 // Seek can be regarded as a new playback, so keep the start segment_id for it also
hualing chen8a657f32021-08-30 13:12:49 +08002991 if (player->need_seek_start == DVR_TRUE) {
2992 player->first_start_time = (uint64_t)time_offset + 1;//set first start time not eq 0
Wentao MA01de0e62022-01-10 18:48:23 +08002993 player->first_start_id = player->cur_segment.segment_id;
hualing chen8a657f32021-08-30 13:12:49 +08002994 }
hualing chen2aba4022020-03-02 13:49:55 +08002995 pthread_mutex_lock(&player->segment_lock);
hualing chen266b9502020-04-04 17:39:39 +08002996 player->drop_ts = DVR_TRUE;
hualing chen5605eed2020-05-26 18:18:06 +08002997 player->ts_cache_len = 0;
Wentao MAf35c3882023-04-17 12:36:19 +08002998 int offset = segment_seek(player->segment_handle, (uint64_t)time_offset, player->openParams.block_size);
Wentao MA96f68962022-06-15 19:45:35 +08002999 DVR_PB_ERROR("seek get offset by time offset, offset=%d time_offset %u",offset, time_offset);
hualing chen2aba4022020-03-02 13:49:55 +08003000 pthread_mutex_unlock(&player->segment_lock);
hualing chen86e7d482020-01-16 15:13:33 +08003001 player->offset = offset;
hualing chen87072a82020-03-12 16:20:12 +08003002
hualing chen2aba4022020-03-02 13:49:55 +08003003 _dvr_get_end_time(handle);
Zhiqiang Han8e4e6db2020-05-15 10:52:20 +08003004
3005 player->last_send_time_id = UINT64_MAX;
Wentao MA270dc0f2022-08-23 13:17:26 +08003006 player->last_segment_total = 0LL;
hualing chen03fd4942021-07-15 15:56:41 +08003007 player->last_segment_id = 0LL;
hualing chen2aba4022020-03-02 13:49:55 +08003008 //init fffb time
hualing chen87072a82020-03-12 16:20:12 +08003009 player->fffb_current = _dvr_time_getClock();
3010 player->fffb_start = player->fffb_current;
3011 player->fffb_start_pcr = _dvr_get_cur_time(handle);
3012 player->next_fffb_time = player->fffb_current;
hualing chena540a7e2020-03-27 16:44:05 +08003013 //pause state if need to replayer false
hualing chen39628212020-05-14 10:35:13 +08003014 if (player->state == DVR_PLAYBACK_STATE_STOP) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003015 //only seek file,not start
Wentao MA96f68962022-06-15 19:45:35 +08003016 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003017 dvr_mutex_unlock(&player->lock);
hualing chen87072a82020-03-12 16:20:12 +08003018 return DVR_SUCCESS;
hualing chen5cbe1a62020-02-10 16:36:36 +08003019 }
hualing chen86e7d482020-01-16 15:13:33 +08003020 //stop play
Wentao MA96f68962022-06-15 19:45:35 +08003021 DVR_PB_ERROR("seek stop play, not inject data has video[%d]audio[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08003022 player->has_video, player->has_audio);
hualing chen1ffd85b2021-08-16 15:18:43 +08003023
hualing chen266b9502020-04-04 17:39:39 +08003024 if (player->has_video) {
hualing chen7e14e532021-09-23 11:23:28 +08003025 //player->has_video = DVR_FALSE;
hualing chen21a40372021-10-29 11:07:26 +08003026 AmTsPlayer_setVideoBlackOut(player->handle, 0);
hualing chen2aba4022020-03-02 13:49:55 +08003027 AmTsPlayer_stopVideoDecoding(player->handle);
hualing chen266b9502020-04-04 17:39:39 +08003028 }
3029
hualing chen40dd5462021-11-26 19:56:20 +08003030
hualing chen266b9502020-04-04 17:39:39 +08003031 if (player->has_audio) {
3032 player->has_audio =DVR_FALSE;
hualing chen2aba4022020-03-02 13:49:55 +08003033 AmTsPlayer_stopAudioDecoding(player->handle);
hualing chen266b9502020-04-04 17:39:39 +08003034 }
hualing chendf118dd2020-05-21 15:49:11 +08003035 if (player->has_ad_audio) {
3036 player->has_ad_audio =DVR_FALSE;
3037 AmTsPlayer_disableADMix(player->handle);
3038 }
3039
hualing chen86e7d482020-01-16 15:13:33 +08003040 //start play
Wentao MA270dc0f2022-08-23 13:17:26 +08003041 am_tsplayer_video_params video_params;
3042 am_tsplayer_audio_params audio_params;
3043 am_tsplayer_audio_params ad_params;
hualing chenb31a6c62020-01-13 17:27:00 +08003044
Wentao MA270dc0f2022-08-23 13:17:26 +08003045 memset(&video_params, 0, sizeof(video_params));
3046 memset(&audio_params, 0, sizeof(audio_params));
jiangfei.hanb8fbad42021-07-29 15:04:48 +08003047
hualing chen040df222020-01-17 13:35:02 +08003048 player->cur_segment_id = segment_id;
3049
3050 int sync = DVR_PLAYBACK_SYNC;
hualing chen5cbe1a62020-02-10 16:36:36 +08003051 //get segment info and audio video pid fmt ;
Wentao MA270dc0f2022-08-23 13:17:26 +08003052 _dvr_playback_get_playinfo(handle, segment_id, &video_params, &audio_params, &ad_params);
hualing chen86e7d482020-01-16 15:13:33 +08003053 //start audio and video
Wentao MA270dc0f2022-08-23 13:17:26 +08003054 if (video_params.pid != player->fake_pid && !VALID_PID(video_params.pid) && !VALID_PID(audio_params.pid)) {
hualing chena5f03222021-12-02 11:22:35 +08003055 //audio and video pid is all invalid, return error.
Wentao MA270dc0f2022-08-23 13:17:26 +08003056 DVR_PB_ERROR("unlock seek start dvr play back start error, not found audio and video info [0x%x]", video_params.pid);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003057 dvr_mutex_unlock(&player->lock);
hualing chen86e7d482020-01-16 15:13:33 +08003058 return -1;
3059 }
Wentao MA270dc0f2022-08-23 13:17:26 +08003060 DVR_PB_ERROR("seek start[0x%x]", video_params.pid);
hualing chen86e7d482020-01-16 15:13:33 +08003061 //add
Zhiqiang Hand48afcd2023-04-03 18:26:27 +08003062 int v_restarted = 0;
3063 int a_restarted = 0;
hualing chen040df222020-01-17 13:35:02 +08003064 if (sync == DVR_PLAYBACK_SYNC) {
Wentao MA270dc0f2022-08-23 13:17:26 +08003065 if (VALID_PID(video_params.pid)) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003066 //player->has_video;
hualing chen2aba4022020-03-02 13:49:55 +08003067 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_PAUSE ||
hualing chene41f4372020-06-06 16:29:17 +08003068 player->state == DVR_PLAYBACK_STATE_PAUSE ||
hualing chendf118dd2020-05-21 15:49:11 +08003069 player->speed > 2.0f||
hualing chen31140872020-03-25 12:29:26 +08003070 player->speed <= -1.0f) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003071 //if is pause state. we need set trick mode.
Wentao MA96f68962022-06-15 19:45:35 +08003072 DVR_PB_INFO("seek set trick mode player->speed [%f]", player->speed);
hualing chen2aba4022020-03-02 13:49:55 +08003073 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_PAUSE_NEXT);
hualing chen5cbe1a62020-02-10 16:36:36 +08003074 }
Wentao MA96f68962022-06-15 19:45:35 +08003075 DVR_PB_INFO("start video");
Wentao MA270dc0f2022-08-23 13:17:26 +08003076 AmTsPlayer_setVideoParams(player->handle, &video_params);
hualing chen21a40372021-10-29 11:07:26 +08003077 AmTsPlayer_setVideoBlackOut(player->handle, 1);
hualing chen2aba4022020-03-02 13:49:55 +08003078 AmTsPlayer_startVideoDecoding(player->handle);
Zhiqiang Hand48afcd2023-04-03 18:26:27 +08003079 v_restarted = 1;
hualing chene41f4372020-06-06 16:29:17 +08003080 if (IS_KERNEL_SPEED(player->cmd.speed.speed.speed) &&
3081 player->cmd.speed.speed.speed != PLAYBACK_SPEED_X1) {
3082 AmTsPlayer_startFast(player->handle, (float)player->cmd.speed.speed.speed/(float)100);
3083 } else if (player->cmd.speed.speed.speed == PLAYBACK_SPEED_X1) {
3084 AmTsPlayer_stopFast(player->handle);
3085 }
hualing chen266b9502020-04-04 17:39:39 +08003086 player->has_video = DVR_TRUE;
hualing chen7e14e532021-09-23 11:23:28 +08003087 } else {
3088 player->has_video = DVR_FALSE;
hualing chenb31a6c62020-01-13 17:27:00 +08003089 }
Wentao MA270dc0f2022-08-23 13:17:26 +08003090 if (VALID_PID(ad_params.pid) && player->speed == 1.0) {
hualing chendf118dd2020-05-21 15:49:11 +08003091 player->has_ad_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08003092 DVR_PB_INFO("start ad audio");
Wentao MA270dc0f2022-08-23 13:17:26 +08003093 dvr_playback_change_seek_state(handle, ad_params.pid);
3094 AmTsPlayer_setADParams(player->handle, &ad_params);
hualing chendf118dd2020-05-21 15:49:11 +08003095 AmTsPlayer_enableADMix(player->handle);
3096 }
Wentao MA270dc0f2022-08-23 13:17:26 +08003097 if (VALID_PID(audio_params.pid) && player->speed == 1.0) {
Wentao MA96f68962022-06-15 19:45:35 +08003098 DVR_PB_INFO("start audio seek");
Wentao MA270dc0f2022-08-23 13:17:26 +08003099 dvr_playback_change_seek_state(handle, audio_params.pid);
3100 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08003101 if (player->audio_presentation_id > -1) {
3102 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
3103 }
hualing chen969fe7b2021-05-26 15:13:17 +08003104 AmTsPlayer_startAudioDecoding(player->handle);
Zhiqiang Hand48afcd2023-04-03 18:26:27 +08003105 a_restarted = 1;
hualing chen969fe7b2021-05-26 15:13:17 +08003106 player->has_audio = DVR_TRUE;
3107 }
hualing chen43a89bc2022-01-19 14:31:20 +08003108#ifdef AVSYNC_USED_PCR
3109 if (player && VALID_PID(player->cur_segment.pids.pcr.pid)) {
Wentao MA96f68962022-06-15 19:45:35 +08003110 DVR_PB_INFO("start set pcr [%d]", player->cur_segment.pids.pcr.pid);
hualing chen43a89bc2022-01-19 14:31:20 +08003111 AmTsPlayer_setPcrPid(player->handle, player->cur_segment.pids.pcr.pid);
3112 }
3113#endif
hualing chen86e7d482020-01-16 15:13:33 +08003114 }
hualing chen1ffd85b2021-08-16 15:18:43 +08003115 if (player->state == DVR_PLAYBACK_STATE_PAUSE) {
Zhiqiang Han83923642023-11-03 12:06:48 +08003116
Zhiqiang Hand48afcd2023-04-03 18:26:27 +08003117 if (v_restarted) {
Zhiqiang Han83923642023-11-03 12:06:48 +08003118 DVR_PLAYBACK_CMD_RESET_V(player->cmd.cur_cmd);
Zhiqiang Hand48afcd2023-04-03 18:26:27 +08003119 }
3120 if (a_restarted) {
Zhiqiang Han83923642023-11-03 12:06:48 +08003121 DVR_PLAYBACK_CMD_RESET_A(player->cmd.cur_cmd);
Zhiqiang Hand48afcd2023-04-03 18:26:27 +08003122 }
Zhiqiang Han83923642023-11-03 12:06:48 +08003123
hualing chen2aba4022020-03-02 13:49:55 +08003124 player->cmd.state = DVR_PLAYBACK_STATE_PAUSE;
Wentao MA907b6432022-08-01 06:23:08 +00003125 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_PAUSE);
Wentao MA270dc0f2022-08-23 13:17:26 +08003126 if (VALID_PID(audio_params.pid) || VALID_PID(video_params.pid))
hualing chena5f03222021-12-02 11:22:35 +08003127 player->seek_pause = DVR_TRUE;
Wentao MA270dc0f2022-08-23 13:17:26 +08003128 DVR_PB_INFO("set state pause in seek vpid[0x%x]apid[0x%x]",video_params.pid, audio_params.pid);
hualing chen87072a82020-03-12 16:20:12 +08003129 } else if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
Wentao MA16f870e2022-09-09 11:00:22 +08003130 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB ||
hualing chen31140872020-03-25 12:29:26 +08003131 player->speed > 1.0f||
3132 player->speed <= -1.0f) {
Wentao MA96f68962022-06-15 19:45:35 +08003133 DVR_PB_INFO("not set cmd to seek");
hualing chen87072a82020-03-12 16:20:12 +08003134 //not pause state, we need not set cur cmd
hualing chen2aba4022020-03-02 13:49:55 +08003135 } else {
Wentao MA96f68962022-06-15 19:45:35 +08003136 DVR_PB_INFO("set cmd to seek");
hualing chen2aba4022020-03-02 13:49:55 +08003137 player->cmd.last_cmd = player->cmd.cur_cmd;
3138 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_SEEK;
3139 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00003140 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
hualing chen2aba4022020-03-02 13:49:55 +08003141 }
hualing chen4b7c15d2020-04-07 16:13:48 +08003142 player->last_send_time_id = UINT64_MAX;
Wentao MA96f68962022-06-15 19:45:35 +08003143 DVR_PB_DEBUG("unlock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003144 dvr_mutex_unlock(&player->lock);
hualing chenb31a6c62020-01-13 17:27:00 +08003145
3146 return DVR_SUCCESS;
3147}
hualing chen5cbe1a62020-02-10 16:36:36 +08003148
Wentao MAac5ea062022-08-11 11:44:27 +08003149// Get current playback time position of the ongoing segment.
3150// Notice the return value may be negative. This is because previous segment's
3151// data cached in demux buffer need to be considered.
hualing chen5cbe1a62020-02-10 16:36:36 +08003152static int _dvr_get_cur_time(DVR_PlaybackHandle_t handle) {
3153 //get cur time of segment
3154 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08003155
Gong Ke2a0ebbe2021-05-25 15:22:50 +08003156 if (player == NULL || player->handle == (am_tsplayer_handle)NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003157 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003158 return DVR_FAILURE;
3159 }
3160
Wentao MA270dc0f2022-08-23 13:17:26 +08003161 int64_t cache = 0;//default es buf cache 500ms
hualing chen2aba4022020-03-02 13:49:55 +08003162 pthread_mutex_lock(&player->segment_lock);
Wentao MAf35c3882023-04-17 12:36:19 +08003163 loff_t pos = segment_tell_position(player->segment_handle) -player->ts_cache_len;
hualing chena5f03222021-12-02 11:22:35 +08003164 uint64_t cur = 0;
3165 if (player->ts_cache_len > 0 && pos < 0) {
3166 //this case is open new segment end,but cache data is last segment.
3167 //we need used last segment len to send play time.
3168 cur = 0;
3169 } else {
Wentao MAf35c3882023-04-17 12:36:19 +08003170 cur = segment_tell_position_time(player->segment_handle, pos);
hualing chena5f03222021-12-02 11:22:35 +08003171 }
hualing chen21a40372021-10-29 11:07:26 +08003172 AmTsPlayer_getDelayTime(player->handle, &cache);
hualing chen2aba4022020-03-02 13:49:55 +08003173 pthread_mutex_unlock(&player->segment_lock);
Wentao MA96f68962022-06-15 19:45:35 +08003174 DVR_PB_INFO("get cur time [%lld] cache:%lld cur id [%lld]last id [%lld] pb cache len [%d] [%lld]", cur, cache, player->cur_segment_id,player->last_send_time_id, player->ts_cache_len, pos);
hualing chen87072a82020-03-12 16:20:12 +08003175 if (player->state == DVR_PLAYBACK_STATE_STOP) {
3176 cache = 0;
3177 }
hualing chen4b7c15d2020-04-07 16:13:48 +08003178 int cur_time = (int)(cur > cache ? cur - cache : 0);
3179 return cur_time;
hualing chencc91e1c2020-02-28 13:26:17 +08003180}
3181
Wentao MAac5ea062022-08-11 11:44:27 +08003182// Get current playback time position of the ongoing segment.
3183// Notice the return value may be negative. This is because previous segment's
3184// data cached in demux buffer need to be considered.
hualing chen969fe7b2021-05-26 15:13:17 +08003185static int _dvr_get_play_cur_time(DVR_PlaybackHandle_t handle, uint64_t *id) {
3186 //get cur time of segment
3187 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MA804bab12022-11-29 10:01:26 +08003188 DVR_RETURN_IF_FALSE(player != NULL);
Wentao MAf35c3882023-04-17 12:36:19 +08003189 DVR_RETURN_IF_FALSE(player->segment_handle != NULL);
hualing chen969fe7b2021-05-26 15:13:17 +08003190
hualing chen969fe7b2021-05-26 15:13:17 +08003191 pthread_mutex_lock(&player->segment_lock);
Wentao MAf35c3882023-04-17 12:36:19 +08003192 const loff_t pos = segment_tell_position(player->segment_handle);
3193 const uint64_t cur = segment_tell_position_time(player->segment_handle, pos);
hualing chen969fe7b2021-05-26 15:13:17 +08003194 pthread_mutex_unlock(&player->segment_lock);
Wentao MA01de0e62022-01-10 18:48:23 +08003195
Wentao MA804bab12022-11-29 10:01:26 +08003196 int cache = 0;
3197 get_effective_tsplayer_delay_time(player, &cache);
Wentao MA01de0e62022-01-10 18:48:23 +08003198
hualing chen969fe7b2021-05-26 15:13:17 +08003199 if (player->state == DVR_PLAYBACK_STATE_STOP) {
3200 cache = 0;
3201 }
Wentao MA804bab12022-11-29 10:01:26 +08003202
Wentao MA3e2dc452022-12-20 11:17:16 +08003203 int cur_time = (int)(cur - cache);
Wentao MA804bab12022-11-29 10:01:26 +08003204 *id = player->cur_segment_id;
hualing chen8a657f32021-08-30 13:12:49 +08003205
Wentao MA3e2dc452022-12-20 11:17:16 +08003206 if (*id == 0 && cur_time<0) {
3207 cur_time = 0;
3208 }
3209
Wentao MA80179512022-11-03 12:20:03 +08003210 DVR_PB_INFO("***get playback slider position within segment. segment_id [%lld],"
wentao.ma4ee43022022-12-14 13:22:57 +08003211 " segment_slider_pos[%7d ms] = segment_read_pos[%7lld ms] - tsplayer_cache_len[%5ld ms],"
Wentao MA80179512022-11-03 12:20:03 +08003212 " last id [%lld] pos [%lld]",
3213 player->cur_segment_id,cur_time,cur,cache,player->last_send_time_id,pos);
Wentao MA804bab12022-11-29 10:01:26 +08003214
hualing chen969fe7b2021-05-26 15:13:17 +08003215 return cur_time;
3216}
3217
hualing chencc91e1c2020-02-28 13:26:17 +08003218//get current segment current pcr time of read pos
3219static int _dvr_get_end_time(DVR_PlaybackHandle_t handle) {
3220 //get cur time of segment
3221 DVR_Playback_t *player = (DVR_Playback_t *) handle;
Wentao MAf35c3882023-04-17 12:36:19 +08003222 DVR_RETURN_IF_FALSE(player != NULL);
3223 DVR_RETURN_IF_FALSE(player->segment_handle != NULL);
hualing chena540a7e2020-03-27 16:44:05 +08003224
3225 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003226 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003227 return DVR_FAILURE;
3228 }
3229
hualing chen2aba4022020-03-02 13:49:55 +08003230 pthread_mutex_lock(&player->segment_lock);
Wentao MAf35c3882023-04-17 12:36:19 +08003231 uint64_t end = segment_tell_total_time(player->segment_handle);
hualing chen2aba4022020-03-02 13:49:55 +08003232 pthread_mutex_unlock(&player->segment_lock);
3233 return (int)end;
hualing chen5cbe1a62020-02-10 16:36:36 +08003234}
3235
hualing chen03fd4942021-07-15 15:56:41 +08003236DVR_Bool_t dvr_playback_check_limit(DVR_PlaybackHandle_t handle)
3237{
3238 //check is set limit info
3239 DVR_Playback_t *player = (DVR_Playback_t *) handle;
3240
3241 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003242 DVR_PB_INFO("player is NULL");
hualing chen03fd4942021-07-15 15:56:41 +08003243 return DVR_FALSE;
3244 }
3245 if (player->rec_start > 0 || player->limit > 0) {
3246 return DVR_TRUE;
3247 }
3248 return DVR_FALSE;
3249}
3250
3251/**\brief set DVR playback calculate expired time len
3252 * \param[in] handle, DVR playback session handle
3253 * \return DVR_SUCCESS on success
3254 * \return error code on failure
3255 */
hualing chen7ea70a72021-09-09 11:25:13 +08003256uint32_t dvr_playback_calculate_expiredlen(DVR_PlaybackHandle_t handle)
hualing chen03fd4942021-07-15 15:56:41 +08003257{
3258 //calculate expired time to play
3259 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen7ea70a72021-09-09 11:25:13 +08003260 uint32_t cur_time;
3261 uint32_t tmp_time;
3262 uint32_t expired = 0;
hualing chen03fd4942021-07-15 15:56:41 +08003263 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003264 DVR_PB_INFO("player is NULL");
hualing chen03fd4942021-07-15 15:56:41 +08003265 return expired;
3266 }
hualing chen7ea70a72021-09-09 11:25:13 +08003267 if (player->rec_start == 0 || player->limit == 0) {
Wentao MA96f68962022-06-15 19:45:35 +08003268 DVR_PB_INFO("rec limit 0");
hualing chen03fd4942021-07-15 15:56:41 +08003269 return expired;
3270 }
3271 //get system time
hualing chen7ea70a72021-09-09 11:25:13 +08003272 cur_time = _dvr_getClock_sec();
3273 if ((cur_time - player->rec_start) > player->limit) {
3274 tmp_time = (uint32_t)((cur_time - player->rec_start) - player->limit) * 1000U;
3275 expired = *(int*)&tmp_time;
Wentao MA96f68962022-06-15 19:45:35 +08003276 DVR_PB_INFO("cur_time:%u, rec start:%u limit:%d c_r_diff:%u expired:%u tmp_time:%u",
hualing chen03fd4942021-07-15 15:56:41 +08003277 cur_time,
3278 player->rec_start,
3279 player->limit,
hualing chen7ea70a72021-09-09 11:25:13 +08003280 (uint32_t)(cur_time - player->rec_start - player->limit), expired, tmp_time);
3281 }
hualing chen03fd4942021-07-15 15:56:41 +08003282 return expired;
3283}
3284
3285/**\brief set DVR playback obsolete time
3286 * \param[in] handle, DVR playback session handle
3287 * \param[in] obsolete, obsolete len
3288 * \return DVR_SUCCESS on success
3289 * \return error code on failure
3290 */
3291int dvr_playback_set_obsolete(DVR_PlaybackHandle_t handle, int obsolete)
3292{
3293 int expired = 0;
3294 //calculate expired time to play
3295 DVR_Playback_t *player = (DVR_Playback_t *) handle;
3296
3297 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003298 DVR_PB_INFO("player is NULL");
hualing chen03fd4942021-07-15 15:56:41 +08003299 return DVR_FALSE;
3300 }
3301 //get system time
Wentao MA96f68962022-06-15 19:45:35 +08003302 DVR_PB_DEBUG("lock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003303 dvr_mutex_lock(&player->lock);
hualing chen03fd4942021-07-15 15:56:41 +08003304 player->obsolete = obsolete;
Wentao MA96f68962022-06-15 19:45:35 +08003305 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003306 dvr_mutex_unlock(&player->lock);
hualing chen03fd4942021-07-15 15:56:41 +08003307 return expired;
3308}
3309
3310/**\brief update DVR playback newest segment duration
3311 * \param[in] handle, DVR playback session handle
3312 * \param[in] segmentid, newest segment id
3313 * \param[in] dur dur time ms
3314 * \return DVR_SUCCESS on success
3315 * \return error code on failure
3316 */
3317int dvr_playback_update_duration(DVR_PlaybackHandle_t handle,
3318uint64_t segmentid, int dur)
3319{
3320 DVR_Playback_t *player = (DVR_Playback_t *) handle;
3321 DVR_PlaybackSegmentInfo_t *segment;
3322 DVR_PlaybackSegmentInfo_t *pre_segment = NULL;
3323
3324 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003325 DVR_PB_INFO(" player is NULL");
hualing chen03fd4942021-07-15 15:56:41 +08003326 return DVR_FAILURE;
3327 }
3328 //update the newest segment duration on timeshift mode
wentao.mafd5283f2022-10-14 09:51:13 +08003329 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08003330 // prefetch() here incurring self_assign is used to avoid some compiling
3331 // warnings.
3332 // coverity[self_assign]
hualing chen03fd4942021-07-15 15:56:41 +08003333 list_for_each_entry(segment, &player->segment_list, head)
3334 {
3335 if (segment->segment_id == segmentid) {
3336 segment->duration = dur;
3337 break;
3338 }
3339 pre_segment = segment;
3340 }
3341
3342 return DVR_SUCCESS;
3343}
3344
hualing chen7ea70a72021-09-09 11:25:13 +08003345static uint32_t dvr_playback_calculate_last_valid_segment(
3346 DVR_PlaybackHandle_t handle, uint64_t *segmentid, uint32_t *pos)
hualing chen03fd4942021-07-15 15:56:41 +08003347{
hualing chen7ea70a72021-09-09 11:25:13 +08003348 uint32_t off = 0;
hualing chen03fd4942021-07-15 15:56:41 +08003349 uint64_t segment_id = 0;
hualing chen7ea70a72021-09-09 11:25:13 +08003350 uint32_t pre_off = 0;
hualing chen03fd4942021-07-15 15:56:41 +08003351 uint64_t last_segment_id = 0;
hualing chen7ea70a72021-09-09 11:25:13 +08003352 uint32_t expired = 0;
hualing chen03fd4942021-07-15 15:56:41 +08003353 DVR_Playback_t *player = (DVR_Playback_t *) handle;
3354
3355 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003356 DVR_PB_INFO("player is NULL");
hualing chen03fd4942021-07-15 15:56:41 +08003357 return DVR_FAILURE;
3358 }
3359 expired = dvr_playback_calculate_expiredlen(handle);
hualing chen7e14e532021-09-23 11:23:28 +08003360 if (expired == 0) {
3361 *segmentid = player->cur_segment_id;
3362 *pos = 0;
3363 return DVR_SUCCESS;
3364 }
Wentao MA270dc0f2022-08-23 13:17:26 +08003365 DVR_PlaybackSegmentInfo_t *p_seg;
wentao.mafd5283f2022-10-14 09:51:13 +08003366 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08003367 // prefetch() here incurring self_assign is used to avoid some compiling
3368 // warnings.
3369 // coverity[self_assign]
Wentao MA270dc0f2022-08-23 13:17:26 +08003370 list_for_each_entry_reverse(p_seg, &player->segment_list, head) {
3371 segment_id = p_seg->segment_id;
hualing chen03fd4942021-07-15 15:56:41 +08003372
Wentao MA270dc0f2022-08-23 13:17:26 +08003373 if ((player->obsolete + pre_off + p_seg->duration) > expired)
hualing chen03fd4942021-07-15 15:56:41 +08003374 break;
3375
Wentao MA270dc0f2022-08-23 13:17:26 +08003376 last_segment_id = p_seg->segment_id;
3377 pre_off += p_seg->duration;
hualing chen03fd4942021-07-15 15:56:41 +08003378 }
3379
3380 if (last_segment_id == segment_id) {
3381 /*1.only one seg with id:0, 2.offset exceeds the total duration*/
3382 off = expired;
3383 } else if (player->obsolete >= expired) {
3384 off = 0;
3385 } else {
3386 off = expired - pre_off - player->obsolete;
3387 }
3388 *segmentid = segment_id;
3389 *pos = off;
3390 return DVR_SUCCESS;
3391}
3392
hualing chen4b7c15d2020-04-07 16:13:48 +08003393#define FB_MIX_SEEK_TIME 2000
hualing chen5cbe1a62020-02-10 16:36:36 +08003394//start replay
3395static int _dvr_playback_calculate_seekpos(DVR_PlaybackHandle_t handle) {
3396
3397 DVR_Playback_t *player = (DVR_Playback_t *) handle;
3398 //calculate pcr seek time
3399 int t_diff = 0;
3400 int seek_time = 0;
hualing chen03fd4942021-07-15 15:56:41 +08003401 uint64_t segmentid = 0;
3402 int pos = 0;
hualing chena540a7e2020-03-27 16:44:05 +08003403 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003404 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003405 return DVR_FAILURE;
3406 }
3407
hualing chen5cbe1a62020-02-10 16:36:36 +08003408 if (player->fffb_start == -1) {
3409 //set fffb start time ms
3410 player->fffb_start = _dvr_time_getClock();
3411 player->fffb_current = player->fffb_start;
3412 //get segment current time pos
3413 player->fffb_start_pcr = _dvr_get_cur_time(handle);
Wentao MA96f68962022-06-15 19:45:35 +08003414 DVR_PB_INFO("calculate seek pos player->fffb_start_pcr[%d]ms, speed[%f]",
hualing chen03fd4942021-07-15 15:56:41 +08003415 player->fffb_start_pcr, player->speed);
hualing chene41f4372020-06-06 16:29:17 +08003416 //default first time 2s seek
hualing chen87072a82020-03-12 16:20:12 +08003417 seek_time = FB_MIX_SEEK_TIME;
hualing chen5cbe1a62020-02-10 16:36:36 +08003418 } else {
3419 player->fffb_current = _dvr_time_getClock();
3420 t_diff = player->fffb_current - player->fffb_start;
hualing chen2aba4022020-03-02 13:49:55 +08003421 //if speed is < 0, cmd is fb.
hualing chen5cbe1a62020-02-10 16:36:36 +08003422 seek_time = player->fffb_start_pcr + t_diff *player->speed;
hualing chen2aba4022020-03-02 13:49:55 +08003423 if (seek_time <= 0) {
3424 //need seek to pre one segment
3425 seek_time = 0;
3426 }
hualing chen5cbe1a62020-02-10 16:36:36 +08003427 //seek segment pos
Wentao MAf35c3882023-04-17 12:36:19 +08003428 if (player->segment_handle) {
hualing chen2aba4022020-03-02 13:49:55 +08003429 pthread_mutex_lock(&player->segment_lock);
hualing chen5605eed2020-05-26 18:18:06 +08003430 player->ts_cache_len = 0;
hualing chene41f4372020-06-06 16:29:17 +08003431 if (seek_time < FB_MIX_SEEK_TIME && IS_FB(player->speed)) {
3432 //set seek time to 0;
Wentao MA96f68962022-06-15 19:45:35 +08003433 DVR_PB_INFO("segment seek to 0 at fb mode [%d]id[%lld]",
hualing chen03fd4942021-07-15 15:56:41 +08003434 seek_time,
3435 player->cur_segment_id);
hualing chene41f4372020-06-06 16:29:17 +08003436 seek_time = 0;
3437 }
hualing chen03fd4942021-07-15 15:56:41 +08003438 if (IS_FB(player->speed)
3439 && dvr_playback_check_limit(handle)) {
3440 //fb case.check expired time
3441 //get id and pos to check if we can seek to this pos
3442 dvr_playback_calculate_last_valid_segment(handle, &segmentid, &pos);
3443 //case cur id < segment id
3444 if (player->cur_segment_id < segmentid) {
3445 //expired ts data is player,return error
3446 //
3447 pthread_mutex_unlock(&player->segment_lock);
3448 return 0;
3449 } else if (player->cur_segment_id == segmentid) {
3450 //id is same,compare seek pos
3451 if (seek_time < pos) {
3452 //expired ts data is player,return error
3453 //
3454 pthread_mutex_unlock(&player->segment_lock);
3455 return 0;
3456 }
3457 }
3458 //case can play
3459 }
Wentao MAf35c3882023-04-17 12:36:19 +08003460 if (segment_seek(player->segment_handle, seek_time, player->openParams.block_size) == DVR_FAILURE) {
hualing chen041c4092020-04-05 15:11:50 +08003461 seek_time = 0;
3462 }
hualing chen2aba4022020-03-02 13:49:55 +08003463 pthread_mutex_unlock(&player->segment_lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08003464 } else {
3465 //
Wentao MA96f68962022-06-15 19:45:35 +08003466 DVR_PB_INFO("segment not open,can not seek");
hualing chen5cbe1a62020-02-10 16:36:36 +08003467 }
Wentao MA96f68962022-06-15 19:45:35 +08003468 DVR_PB_INFO("calculate seek pos seek_time[%d]ms, speed[%f]id[%lld]cur [%d]",
hualing chen03fd4942021-07-15 15:56:41 +08003469 seek_time,
3470 player->speed,
3471 player->cur_segment_id,
3472 _dvr_get_cur_time(handle));
hualing chen5cbe1a62020-02-10 16:36:36 +08003473 }
hualing chen2aba4022020-03-02 13:49:55 +08003474 return seek_time;
hualing chen5cbe1a62020-02-10 16:36:36 +08003475}
3476
3477
3478//start replay
3479static int _dvr_playback_fffb_replay(DVR_PlaybackHandle_t handle) {
3480 //
3481 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08003482
3483 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003484 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003485 return DVR_FAILURE;
3486 }
3487
hualing chen5cbe1a62020-02-10 16:36:36 +08003488 //stop
hualing chen2aba4022020-03-02 13:49:55 +08003489 if (player->has_video) {
Wentao MA96f68962022-06-15 19:45:35 +08003490 DVR_PB_INFO("fffb stop video");
hualing chen21a40372021-10-29 11:07:26 +08003491 AmTsPlayer_setVideoBlackOut(player->handle, 0);
hualing chen2aba4022020-03-02 13:49:55 +08003492 AmTsPlayer_stopVideoDecoding(player->handle);
3493 }
3494 if (player->has_audio) {
Wentao MA96f68962022-06-15 19:45:35 +08003495 DVR_PB_INFO("fffb stop audio");
hualing chen266b9502020-04-04 17:39:39 +08003496 player->has_audio =DVR_FALSE;
hualing chen2aba4022020-03-02 13:49:55 +08003497 AmTsPlayer_stopAudioDecoding(player->handle);
3498 }
hualing chendf118dd2020-05-21 15:49:11 +08003499 if (player->has_ad_audio) {
Wentao MA96f68962022-06-15 19:45:35 +08003500 DVR_PB_INFO("fffb stop audio");
hualing chendf118dd2020-05-21 15:49:11 +08003501 player->has_ad_audio =DVR_FALSE;
3502 AmTsPlayer_disableADMix(player->handle);
3503 }
hualing chen2aba4022020-03-02 13:49:55 +08003504
hualing chen5cbe1a62020-02-10 16:36:36 +08003505 //start video and audio
3506
Wentao MA270dc0f2022-08-23 13:17:26 +08003507 am_tsplayer_video_params video_params;
3508 am_tsplayer_audio_params audio_params;
3509 am_tsplayer_audio_params ad_params;
jiangfei.hanb8fbad42021-07-29 15:04:48 +08003510
Wentao MA270dc0f2022-08-23 13:17:26 +08003511 memset(&video_params, 0, sizeof(video_params));
3512 memset(&audio_params, 0, sizeof(audio_params));
jiangfei.hanb8fbad42021-07-29 15:04:48 +08003513
hualing chen87072a82020-03-12 16:20:12 +08003514 uint64_t segment_id = player->cur_segment_id;
hualing chen5cbe1a62020-02-10 16:36:36 +08003515
3516 //get segment info and audio video pid fmt ;
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003517 //dvr_mutex_lock(&player->lock);
Wentao MA270dc0f2022-08-23 13:17:26 +08003518 _dvr_playback_get_playinfo(handle, segment_id, &video_params, &audio_params, &ad_params);
hualing chen5cbe1a62020-02-10 16:36:36 +08003519 //start audio and video
Wentao MA270dc0f2022-08-23 13:17:26 +08003520 if (!VALID_PID(video_params.pid) && !VALID_PID(audio_params.pid)) {
3521 //audio and video pids are all invalid, return error.
Wentao MA96f68962022-06-15 19:45:35 +08003522 DVR_PB_ERROR("dvr play back restart error, not found audio and video info");
hualing chen5cbe1a62020-02-10 16:36:36 +08003523 return -1;
3524 }
3525
Wentao MA270dc0f2022-08-23 13:17:26 +08003526 if (VALID_PID(video_params.pid)) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003527 player->has_video = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08003528 DVR_PB_INFO("fffb start video");
3529 //DVR_PB_INFO("fffb start video and save last frame");
hualing chen0888c032020-12-18 17:54:57 +08003530 //AmTsPlayer_setVideoBlackOut(player->handle, 0);
hualing chen31140872020-03-25 12:29:26 +08003531 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
hualing chen2aba4022020-03-02 13:49:55 +08003532 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_PAUSE_NEXT);
Wentao MA270dc0f2022-08-23 13:17:26 +08003533 AmTsPlayer_setVideoParams(player->handle, &video_params);
hualing chen21a40372021-10-29 11:07:26 +08003534 AmTsPlayer_setVideoBlackOut(player->handle, 1);
hualing chen2aba4022020-03-02 13:49:55 +08003535 AmTsPlayer_startVideoDecoding(player->handle);
Wentao MA270dc0f2022-08-23 13:17:26 +08003536 //playback_device_video_start(player->handle , &video_params);
hualing chen5cbe1a62020-02-10 16:36:36 +08003537 //if set flag is pause live, we need set trick mode
hualing chen2aba4022020-03-02 13:49:55 +08003538 //playback_device_trick_mode(player->handle, 1);
hualing chen5cbe1a62020-02-10 16:36:36 +08003539 }
hualing chen31140872020-03-25 12:29:26 +08003540 //fffb mode need stop fast;
Wentao MA96f68962022-06-15 19:45:35 +08003541 DVR_PB_INFO("stop fast");
hualing chen31140872020-03-25 12:29:26 +08003542 AmTsPlayer_stopFast(player->handle);
hualing chen5cbe1a62020-02-10 16:36:36 +08003543 return 0;
3544}
3545
3546static int _dvr_playback_fffb(DVR_PlaybackHandle_t handle) {
3547 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08003548 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003549 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003550 return DVR_FAILURE;
3551 }
3552
3553 player->first_frame = 0;
Wentao MA96f68962022-06-15 19:45:35 +08003554 DVR_PB_INFO("lock speed [%f]", player->speed);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003555 dvr_mutex_lock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08003556
hualing chen2aba4022020-03-02 13:49:55 +08003557 int seek_time = _dvr_playback_calculate_seekpos(handle);
Wentao MA96f68962022-06-15 19:45:35 +08003558 DVR_PB_INFO("get lock speed [%f]id [%lld]seek_time[%d]", player->speed, player->cur_segment_id, seek_time);
hualing chen041c4092020-04-05 15:11:50 +08003559
hualing chen87072a82020-03-12 16:20:12 +08003560 if (_dvr_has_next_segmentId(handle, player->cur_segment_id) == DVR_FAILURE && seek_time < FB_MIX_SEEK_TIME && IS_FB(player->speed)) {
3561 //seek time set 0
3562 seek_time = 0;
3563 }
hualing chen041c4092020-04-05 15:11:50 +08003564 if (seek_time == 0) {
hualing chen2aba4022020-03-02 13:49:55 +08003565 //for fb cmd, we need open pre segment.if reach first one segment, send begin event
3566 int ret = _change_to_next_segment((DVR_PlaybackHandle_t)player);
hualing chen041c4092020-04-05 15:11:50 +08003567 if (ret != DVR_SUCCESS && IS_FB(player->speed)) {
wentao.ma4ee43022022-12-14 13:22:57 +08003568
3569 // An fffb_replay is required here to help finish the last FB play
3570 // at beginning position of a recording. In addition to function
3571 // correctness, another benefit is that after play, demux buffer
3572 // is cleared due to stopVideoDecoding invocation in the process.
3573 // The following resume operation will not be affected by the invalid
3574 // cache length.
3575 player->next_fffb_time =_dvr_time_getClock() + FFFB_SLEEP_TIME;
3576 _dvr_playback_fffb_replay(handle);
3577
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003578 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08003579 DVR_PB_DEBUG("unlock");
Wentao MA75775d22023-09-25 16:53:24 +08003580#ifdef FOR_SKYWORTH_FETCH_RDK
3581 DVR_PlaybackSpeed_t normal_speed = {PLAYBACK_SPEED_X1,0};
3582 DVR_PB_INFO("Change to normal speed due to FB reaching beginning");
3583 dvr_playback_set_speed((DVR_PlaybackHandle_t)player,normal_speed);
Wentao MA9e31f692023-09-26 17:42:18 +08003584
3585 {
3586 DVR_Play_Notify_t notify;
3587 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
3588 notify.event = DVR_PLAYBACK_EVENT_TIMESHIFT_FR_REACHED_BEGIN;
3589 _dvr_playback_sent_event((DVR_PlaybackHandle_t)player, notify.event, &notify, 0);
3590 }
Wentao MA75775d22023-09-25 16:53:24 +08003591#else
Wentao MA9e31f692023-09-26 17:42:18 +08003592 DVR_PB_INFO("Change to pause due to FB reaching beginning");
hualing chen87072a82020-03-12 16:20:12 +08003593 dvr_playback_pause(handle, DVR_FALSE);
Wentao MA75775d22023-09-25 16:53:24 +08003594#endif
Wentao MA9e31f692023-09-26 17:42:18 +08003595 {
3596 //send event here and pause
3597 DVR_Play_Notify_t notify;
3598 memset(&notify, 0 , sizeof(DVR_Play_Notify_t));
3599 notify.event = DVR_PLAYBACK_EVENT_REACHED_BEGIN;
3600 //get play statue not here
3601 _dvr_playback_sent_event(handle, DVR_PLAYBACK_EVENT_REACHED_BEGIN, &notify, DVR_TRUE);
3602 DVR_PB_INFO("*******************send begin event speed [%f] cur [%d]", player->speed, _dvr_get_cur_time(handle));
3603 }
hualing chen2aba4022020-03-02 13:49:55 +08003604 return DVR_SUCCESS;
3605 }
hualing chen2932d372020-04-29 13:44:00 +08003606 _dvr_playback_sent_transition_ok(handle, DVR_FALSE);
hualing chen2aba4022020-03-02 13:49:55 +08003607 _dvr_init_fffb_time(handle);
Wentao MA96f68962022-06-15 19:45:35 +08003608 DVR_PB_INFO("*******************send trans ok event speed [%f]", player->speed);
hualing chen2aba4022020-03-02 13:49:55 +08003609 }
3610 player->next_fffb_time =_dvr_time_getClock() + FFFB_SLEEP_TIME;
hualing chen5cbe1a62020-02-10 16:36:36 +08003611 _dvr_playback_fffb_replay(handle);
3612
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003613 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08003614 DVR_PB_DEBUG("unlock");
hualing chen2aba4022020-03-02 13:49:55 +08003615
hualing chen5cbe1a62020-02-10 16:36:36 +08003616 return DVR_SUCCESS;
3617}
3618
hualing chen87072a82020-03-12 16:20:12 +08003619//start replay, need get lock at extern
hualing chen2aba4022020-03-02 13:49:55 +08003620static int _dvr_playback_replay(DVR_PlaybackHandle_t handle, DVR_Bool_t trick) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003621 //
3622 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08003623
3624 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003625 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003626 return DVR_FAILURE;
3627 }
3628
hualing chen5cbe1a62020-02-10 16:36:36 +08003629 //stop
hualing chen2aba4022020-03-02 13:49:55 +08003630 if (player->has_video) {
hualing chen266b9502020-04-04 17:39:39 +08003631 player->has_video = DVR_FALSE;
hualing chen21a40372021-10-29 11:07:26 +08003632 AmTsPlayer_setVideoBlackOut(player->handle, 0);
hualing chen2aba4022020-03-02 13:49:55 +08003633 AmTsPlayer_stopVideoDecoding(player->handle);
hualing chen2aba4022020-03-02 13:49:55 +08003634 }
3635
3636 if (player->has_audio) {
hualing chen266b9502020-04-04 17:39:39 +08003637 player->has_audio = DVR_FALSE;
hualing chen2aba4022020-03-02 13:49:55 +08003638 AmTsPlayer_stopAudioDecoding(player->handle);
hualing chen2aba4022020-03-02 13:49:55 +08003639 }
hualing chen5cbe1a62020-02-10 16:36:36 +08003640 //start video and audio
3641
Wentao MA270dc0f2022-08-23 13:17:26 +08003642 am_tsplayer_video_params video_params;
3643 am_tsplayer_audio_params audio_params;
3644 am_tsplayer_audio_params ad_params;
hualing chen87072a82020-03-12 16:20:12 +08003645 uint64_t segment_id = player->cur_segment_id;
hualing chen5cbe1a62020-02-10 16:36:36 +08003646
Wentao MA270dc0f2022-08-23 13:17:26 +08003647 memset(&video_params, 0, sizeof(video_params));
3648 memset(&audio_params, 0, sizeof(audio_params));
jiangfei.hanb8fbad42021-07-29 15:04:48 +08003649
hualing chen5cbe1a62020-02-10 16:36:36 +08003650 //get segment info and audio video pid fmt ;
Wentao MA96f68962022-06-15 19:45:35 +08003651 DVR_PB_INFO("into");
Wentao MA270dc0f2022-08-23 13:17:26 +08003652 _dvr_playback_get_playinfo(handle, segment_id, &video_params, &audio_params, &ad_params);
hualing chen5cbe1a62020-02-10 16:36:36 +08003653 //start audio and video
Wentao MA270dc0f2022-08-23 13:17:26 +08003654 if (!VALID_PID(video_params.pid) && !VALID_PID(audio_params.pid)) {
hualing chen2aba4022020-03-02 13:49:55 +08003655 //audio and video pis is all invalid, return error.
Wentao MA96f68962022-06-15 19:45:35 +08003656 DVR_PB_ERROR("dvr play back restart error, not found audio and video info");
hualing chen5cbe1a62020-02-10 16:36:36 +08003657 return -1;
3658 }
3659
Wentao MA270dc0f2022-08-23 13:17:26 +08003660 if (VALID_PID(video_params.pid)) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003661 player->has_video = DVR_TRUE;
hualing chen87072a82020-03-12 16:20:12 +08003662 if (trick == DVR_TRUE) {
Wentao MA96f68962022-06-15 19:45:35 +08003663 DVR_PB_INFO("settrick mode at replay");
hualing chen2aba4022020-03-02 13:49:55 +08003664 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_PAUSE_NEXT);
hualing chen87072a82020-03-12 16:20:12 +08003665 }
hualing chen266b9502020-04-04 17:39:39 +08003666 else {
hualing chen2aba4022020-03-02 13:49:55 +08003667 AmTsPlayer_setTrickMode(player->handle, AV_VIDEO_TRICK_MODE_NONE);
hualing chen266b9502020-04-04 17:39:39 +08003668 }
Wentao MA270dc0f2022-08-23 13:17:26 +08003669 AmTsPlayer_setVideoParams(player->handle, &video_params);
hualing chen21a40372021-10-29 11:07:26 +08003670 AmTsPlayer_setVideoBlackOut(player->handle, 1);
hualing chen2aba4022020-03-02 13:49:55 +08003671 AmTsPlayer_startVideoDecoding(player->handle);
hualing chen5cbe1a62020-02-10 16:36:36 +08003672 }
hualing chena540a7e2020-03-27 16:44:05 +08003673
3674 if (IS_FAST_SPEED(player->cmd.speed.speed.speed)) {
Wentao MA96f68962022-06-15 19:45:35 +08003675 DVR_PB_INFO("start fast");
hualing chen31140872020-03-25 12:29:26 +08003676 AmTsPlayer_startFast(player->handle, (float)player->cmd.speed.speed.speed/(float)100);
hualing chena540a7e2020-03-27 16:44:05 +08003677 player->speed = (float)player->cmd.speed.speed.speed/100.0f;
hualing chen31140872020-03-25 12:29:26 +08003678 } else {
Wentao MA270dc0f2022-08-23 13:17:26 +08003679 if (VALID_PID(ad_params.pid)) {
hualing chendf118dd2020-05-21 15:49:11 +08003680 player->has_ad_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08003681 DVR_PB_INFO("start ad audio");
Wentao MA270dc0f2022-08-23 13:17:26 +08003682 AmTsPlayer_setADParams(player->handle, &ad_params);
hualing chendf118dd2020-05-21 15:49:11 +08003683 AmTsPlayer_enableADMix(player->handle);
3684 }
Wentao MA270dc0f2022-08-23 13:17:26 +08003685 if (VALID_PID(audio_params.pid)) {
hualing chen969fe7b2021-05-26 15:13:17 +08003686 player->has_audio = DVR_TRUE;
Wentao MA96f68962022-06-15 19:45:35 +08003687 DVR_PB_INFO("start audio");
Wentao MA270dc0f2022-08-23 13:17:26 +08003688 AmTsPlayer_setAudioParams(player->handle, &audio_params);
Wentao MA5629ad82022-08-24 10:03:02 +08003689 if (player->audio_presentation_id > -1) {
3690 AmTsPlayer_setParams(player->handle, AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &player->audio_presentation_id);
3691 }
hualing chen969fe7b2021-05-26 15:13:17 +08003692 AmTsPlayer_startAudioDecoding(player->handle);
3693 }
hualing chendf118dd2020-05-21 15:49:11 +08003694
Wentao MA96f68962022-06-15 19:45:35 +08003695 DVR_PB_INFO("stop fast");
hualing chen31140872020-03-25 12:29:26 +08003696 AmTsPlayer_stopFast(player->handle);
3697 player->cmd.speed.speed.speed = PLAYBACK_SPEED_X1;
3698 player->speed = (float)PLAYBACK_SPEED_X1/100.0f;
3699 }
hualing chen43a89bc2022-01-19 14:31:20 +08003700#ifdef AVSYNC_USED_PCR
3701 if (player && VALID_PID(player->cur_segment.pids.pcr.pid)) {
Wentao MA96f68962022-06-15 19:45:35 +08003702 DVR_PB_INFO("start set pcr [%d]", player->cur_segment.pids.pcr.pid);
hualing chen43a89bc2022-01-19 14:31:20 +08003703 AmTsPlayer_setPcrPid(player->handle, player->cur_segment.pids.pcr.pid);
3704 }
3705#endif
hualing chen2aba4022020-03-02 13:49:55 +08003706 player->cmd.last_cmd = player->cmd.cur_cmd;
3707 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_START;
hualing chen2aba4022020-03-02 13:49:55 +08003708 player->cmd.state = DVR_PLAYBACK_STATE_START;
Wentao MA907b6432022-08-01 06:23:08 +00003709 DVR_PLAYER_CHANGE_STATE(player,DVR_PLAYBACK_STATE_START);
hualing chen5cbe1a62020-02-10 16:36:36 +08003710 return 0;
3711}
3712
3713
hualing chenb31a6c62020-01-13 17:27:00 +08003714/**\brief Set play speed
3715 * \param[in] handle playback handle
3716 * \param[in] speed playback speed
3717 * \retval DVR_SUCCESS On success
3718 * \return Error code
3719 */
hualing chen5cbe1a62020-02-10 16:36:36 +08003720int dvr_playback_set_speed(DVR_PlaybackHandle_t handle, DVR_PlaybackSpeed_t speed) {
3721
3722 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chena540a7e2020-03-27 16:44:05 +08003723
3724 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003725 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003726 return DVR_FAILURE;
3727 }
3728
hualing chena540a7e2020-03-27 16:44:05 +08003729 if (_dvr_support_speed(speed.speed.speed) == DVR_FALSE) {
Wentao MA96f68962022-06-15 19:45:35 +08003730 DVR_PB_INFO(" func: not support speed [%d]", speed.speed.speed);
hualing chena540a7e2020-03-27 16:44:05 +08003731 return DVR_FAILURE;
3732 }
hualing chenf00cdc82020-06-10 14:23:35 +08003733 if (speed.speed.speed == player->cmd.speed.speed.speed) {
Wentao MA96f68962022-06-15 19:45:35 +08003734 DVR_PB_INFO(" func: eq speed [%d]", speed.speed.speed);
hualing chenf00cdc82020-06-10 14:23:35 +08003735 return DVR_SUCCESS;
3736 }
Wentao MA96f68962022-06-15 19:45:35 +08003737 DVR_PB_INFO("lock func: speed [%d]", speed.speed.speed);
hualing chen1679f812021-11-08 15:17:46 +08003738
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003739 dvr_mutex_lock(&player->lock);
hualing chen5cbe1a62020-02-10 16:36:36 +08003740 if (player->cmd.cur_cmd != DVR_PLAYBACK_CMD_FF
3741 && player->cmd.cur_cmd != DVR_PLAYBACK_CMD_FB) {
3742 player->cmd.last_cmd = player->cmd.cur_cmd;
3743 }
hualing chene41f4372020-06-06 16:29:17 +08003744
hualing chen31140872020-03-25 12:29:26 +08003745 if (player->state != DVR_PLAYBACK_STATE_PAUSE &&
hualing chenf00cdc82020-06-10 14:23:35 +08003746 IS_KERNEL_SPEED(speed.speed.speed) ) {
3747 //case 1. not start play.only set speed
3748 if (player->state == DVR_PLAYBACK_STATE_STOP) {
3749 //only set speed.and return;
3750 player->cmd.speed.mode = DVR_PLAYBACK_KERNEL_SUPPORT;
3751 player->cmd.speed.speed = speed.speed;
3752 player->speed = (float)speed.speed.speed/(float)100;
3753 player->fffb_play = DVR_FALSE;
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003754 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08003755 DVR_PB_DEBUG("unlock");
hualing chenf00cdc82020-06-10 14:23:35 +08003756 return DVR_SUCCESS;
3757 }
3758 //case 2. cur speed is 100,set 200 50 25 12 .
hualing chena540a7e2020-03-27 16:44:05 +08003759 //we think x1 and x2 s1/2 s 1/4 s 1/8 is normal speed. is not ff fb.
3760 if (IS_KERNEL_SPEED(player->cmd.speed.speed.speed)) {
hualing chen87072a82020-03-12 16:20:12 +08003761 //if last speed is x2 or s2, we need stop fast
hualing chen2bd8a7a2020-04-02 11:31:03 +08003762 if (speed.speed.speed == PLAYBACK_SPEED_X1) {
3763 // resume audio and stop fast play
Wentao MA96f68962022-06-15 19:45:35 +08003764 DVR_PB_INFO("stop fast");
hualing chen2bd8a7a2020-04-02 11:31:03 +08003765 AmTsPlayer_stopFast(player->handle);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003766 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08003767 DVR_PB_DEBUG("unlock ---\r\n");
Wentao MA270dc0f2022-08-23 13:17:26 +08003768 _dvr_cmd(handle, DVR_PLAYBACK_CMD_A_START);
Wentao MA96f68962022-06-15 19:45:35 +08003769 DVR_PB_DEBUG("lock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003770 dvr_mutex_lock(&player->lock);
hualing chen2bd8a7a2020-04-02 11:31:03 +08003771 } else {
3772 //set play speed and if audio is start, stop audio.
3773 if (player->has_audio) {
Wentao MA96f68962022-06-15 19:45:35 +08003774 DVR_PB_INFO("fast play stop audio");
hualing chen2bd8a7a2020-04-02 11:31:03 +08003775 AmTsPlayer_stopAudioDecoding(player->handle);
3776 player->has_audio = DVR_FALSE;
3777 }
Wentao MA96f68962022-06-15 19:45:35 +08003778 DVR_PB_INFO("start fast");
hualing chen2bd8a7a2020-04-02 11:31:03 +08003779 AmTsPlayer_startFast(player->handle, (float)speed.speed.speed/(float)100);
hualing chena540a7e2020-03-27 16:44:05 +08003780 }
hualing chenbcada022020-04-22 14:27:01 +08003781 player->fffb_play = DVR_FALSE;
hualing chena540a7e2020-03-27 16:44:05 +08003782 player->cmd.speed.mode = DVR_PLAYBACK_KERNEL_SUPPORT;
hualing chen31140872020-03-25 12:29:26 +08003783 player->cmd.speed.speed = speed.speed;
3784 player->speed = (float)speed.speed.speed/(float)100;
Wentao MA96f68962022-06-15 19:45:35 +08003785 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003786 dvr_mutex_unlock(&player->lock);
hualing chen31140872020-03-25 12:29:26 +08003787 return DVR_SUCCESS;
3788 }
hualing chen31140872020-03-25 12:29:26 +08003789 //case 3 fffb mode
3790 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
3791 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB) {
3792 //restart play at normal speed exit ff fb
Wentao MA96f68962022-06-15 19:45:35 +08003793 DVR_PB_INFO("set speed normal and replay playback");
hualing chena540a7e2020-03-27 16:44:05 +08003794 player->cmd.speed.mode = DVR_PLAYBACK_KERNEL_SUPPORT;
hualing chen31140872020-03-25 12:29:26 +08003795 player->cmd.speed.speed = speed.speed;
3796 player->speed = (float)speed.speed.speed/(float)100;
3797 _dvr_playback_replay(handle, DVR_FALSE);
hualing chenbcada022020-04-22 14:27:01 +08003798 player->fffb_play = DVR_FALSE;
Wentao MA96f68962022-06-15 19:45:35 +08003799 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003800 dvr_mutex_unlock(&player->lock);
hualing chen31140872020-03-25 12:29:26 +08003801 return DVR_SUCCESS;
3802 }
3803 }
3804 else if (player->state == DVR_PLAYBACK_STATE_PAUSE &&
hualing chena540a7e2020-03-27 16:44:05 +08003805 IS_KERNEL_SPEED(speed.speed.speed)) {
3806 //case 1. cur speed is kernel support speed,set kernel speed.
3807 if (IS_KERNEL_SPEED(player->cmd.speed.speed.speed)) {
hualing chen31140872020-03-25 12:29:26 +08003808 //if last speed is x2 or s2, we need stop fast
hualing chen2bd8a7a2020-04-02 11:31:03 +08003809 if (speed.speed.speed == PLAYBACK_SPEED_X1) {
3810 // resume audio and stop fast play
Wentao MA96f68962022-06-15 19:45:35 +08003811 DVR_PB_INFO("stop fast");
hualing chen2bd8a7a2020-04-02 11:31:03 +08003812 AmTsPlayer_stopFast(player->handle);
Wentao MA270dc0f2022-08-23 13:17:26 +08003813 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_A_START;
hualing chen2bd8a7a2020-04-02 11:31:03 +08003814 } else {
3815 //set play speed and if audio is start, stop audio.
3816 if (player->has_audio) {
Wentao MA96f68962022-06-15 19:45:35 +08003817 DVR_PB_INFO("fast play stop audio at pause");
hualing chen2bd8a7a2020-04-02 11:31:03 +08003818 AmTsPlayer_stopAudioDecoding(player->handle);
3819 player->has_audio = DVR_FALSE;
3820 }
Wentao MA96f68962022-06-15 19:45:35 +08003821 DVR_PB_INFO("start fast");
hualing chenf00cdc82020-06-10 14:23:35 +08003822 AmTsPlayer_startFast(player->handle, (float)speed.speed.speed/(float)100);
hualing chen2bd8a7a2020-04-02 11:31:03 +08003823 }
hualing chena540a7e2020-03-27 16:44:05 +08003824 player->cmd.speed.mode = DVR_PLAYBACK_KERNEL_SUPPORT;
hualing chen31140872020-03-25 12:29:26 +08003825 player->cmd.speed.speed = speed.speed;
3826 player->speed = (float)speed.speed.speed/(float)100;
hualing chenbcada022020-04-22 14:27:01 +08003827 player->fffb_play = DVR_FALSE;
Wentao MA96f68962022-06-15 19:45:35 +08003828 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003829 dvr_mutex_unlock(&player->lock);
hualing chen31140872020-03-25 12:29:26 +08003830 return DVR_SUCCESS;
3831 }
3832 //case 2 fffb mode
3833 if (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
3834 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB) {
3835 //restart play at normal speed exit ff fb
Wentao MA96f68962022-06-15 19:45:35 +08003836 DVR_PB_INFO("set speed x1 s2 and replay playback");
hualing chena540a7e2020-03-27 16:44:05 +08003837 player->cmd.speed.mode = DVR_PLAYBACK_KERNEL_SUPPORT;
hualing chen31140872020-03-25 12:29:26 +08003838 player->cmd.speed.speed = speed.speed;
3839 player->speed = (float)speed.speed.speed/(float)100;
Wentao MA270dc0f2022-08-23 13:17:26 +08003840 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_AV_RESTART;
hualing chenbcada022020-04-22 14:27:01 +08003841 player->fffb_play = DVR_FALSE;
Wentao MA96f68962022-06-15 19:45:35 +08003842 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003843 dvr_mutex_unlock(&player->lock);
hualing chen31140872020-03-25 12:29:26 +08003844 return DVR_SUCCESS;
3845 }
hualing chen31140872020-03-25 12:29:26 +08003846 }
hualing chena540a7e2020-03-27 16:44:05 +08003847 if (IS_KERNEL_SPEED(speed.speed.speed)) {
3848 //we think x1 and s2 s4 s8 x2is normal speed. is not ff fb.
hualing chenbcada022020-04-22 14:27:01 +08003849 player->fffb_play = DVR_FALSE;
hualing chen87072a82020-03-12 16:20:12 +08003850 } else {
hualing chen31140872020-03-25 12:29:26 +08003851 if ((float)speed.speed.speed > 1.0f)
hualing chen87072a82020-03-12 16:20:12 +08003852 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_FF;
3853 else
3854 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_FB;
hualing chen4b7c15d2020-04-07 16:13:48 +08003855 player->fffb_play = DVR_TRUE;
3856 }
3857 DVR_Bool_t init_last_time = DVR_FALSE;
3858 if (player->speed > 0.0f && speed.speed.speed < 0) {
3859 init_last_time = DVR_TRUE;
3860 } else if (player->speed < 0.0f && speed.speed.speed > 0) {
3861 init_last_time = DVR_TRUE;
hualing chen87072a82020-03-12 16:20:12 +08003862 }
hualing chen5cbe1a62020-02-10 16:36:36 +08003863 player->cmd.speed.mode = speed.mode;
3864 player->cmd.speed.speed = speed.speed;
hualing chen31140872020-03-25 12:29:26 +08003865 player->speed = (float)speed.speed.speed/(float)100;
3866 //reset fffb time, if change speed value
hualing chen4b7c15d2020-04-07 16:13:48 +08003867 _dvr_init_fffb_t(handle);
3868 if (init_last_time == DVR_TRUE)
3869 player->last_send_time_id = UINT64_MAX;
3870
hualing chen87072a82020-03-12 16:20:12 +08003871 if (speed.speed.speed == PLAYBACK_SPEED_X1 &&
hualing chen6d24aa92020-03-23 18:43:47 +08003872 (player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FF ||
3873 player->cmd.cur_cmd == DVR_PLAYBACK_CMD_FB)) {
hualing chen87072a82020-03-12 16:20:12 +08003874 //restart play at normal speed exit ff fb
Wentao MA96f68962022-06-15 19:45:35 +08003875 DVR_PB_INFO("set speed normal and replay playback");
hualing chen87072a82020-03-12 16:20:12 +08003876 _dvr_playback_replay(handle, DVR_FALSE);
3877 } else if (speed.speed.speed == PLAYBACK_SPEED_X1 &&
3878 (player->state == DVR_PLAYBACK_STATE_PAUSE)) {
Wentao MA270dc0f2022-08-23 13:17:26 +08003879 player->cmd.cur_cmd = DVR_PLAYBACK_CMD_AV_RESTART;
Wentao MA96f68962022-06-15 19:45:35 +08003880 DVR_PB_INFO("set speed normal at pause state ,set cur cmd");
hualing chen87072a82020-03-12 16:20:12 +08003881 }
Wentao MA96f68962022-06-15 19:45:35 +08003882 DVR_PB_INFO("unlock speed[%f]cmd[%d]", player->speed, player->cmd.cur_cmd);
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003883 dvr_mutex_unlock(&player->lock);
hualing chenb31a6c62020-01-13 17:27:00 +08003884 return DVR_SUCCESS;
3885}
hualing chen2932d372020-04-29 13:44:00 +08003886
hualing chenb31a6c62020-01-13 17:27:00 +08003887/**\brief Get playback status
3888 * \param[in] handle playback handle
3889 * \param[out] p_status playback status
3890 * \retval DVR_SUCCESS On success
3891 * \return Error code
3892 */
hualing chen2932d372020-04-29 13:44:00 +08003893static int _dvr_playback_get_status(DVR_PlaybackHandle_t handle,
3894 DVR_PlaybackStatus_t *p_status, DVR_Bool_t is_lock) {
hualing chen5cbe1a62020-02-10 16:36:36 +08003895//
3896 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chen969fe7b2021-05-26 15:13:17 +08003897 uint64_t segment_id = 0LL;
hualing chena540a7e2020-03-27 16:44:05 +08003898 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08003899 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08003900 return DVR_FAILURE;
3901 }
hualing chen1679f812021-11-08 15:17:46 +08003902 if (is_lock ==DVR_TRUE) {
Wentao MA96f68962022-06-15 19:45:35 +08003903 DVR_PB_DEBUG("lock");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003904 dvr_mutex_lock(&player->lock);
hualing chen1679f812021-11-08 15:17:46 +08003905 }
3906
hualing chen5cbe1a62020-02-10 16:36:36 +08003907 p_status->state = player->state;
hualing chen31140872020-03-25 12:29:26 +08003908 //when got first frame we will change to pause state.this only from start play to got first frame
hualing chen87072a82020-03-12 16:20:12 +08003909 if ((player->play_flag&DVR_PLAYBACK_STARTED_PAUSEDLIVE) == DVR_PLAYBACK_STARTED_PAUSEDLIVE &&
3910 player->state == DVR_PLAYBACK_STATE_START) {
3911 p_status->state = DVR_PLAYBACK_STATE_PAUSE;
3912 }
hualing chen041c4092020-04-05 15:11:50 +08003913
hualing chencc91e1c2020-02-28 13:26:17 +08003914 p_status->time_end = _dvr_get_end_time(handle);
hualing chen969fe7b2021-05-26 15:13:17 +08003915 p_status->time_cur = _dvr_get_play_cur_time(handle, &segment_id);
hualing chend241c7a2021-06-22 13:34:27 +08003916
shenghui.gengbec6a462023-01-12 15:21:02 +08003917 if (player->control_speed_enable == 1) {
hualing chen7ea70a72021-09-09 11:25:13 +08003918 if (player->con_spe.ply_sta == 0) {
wentao.mafdba9a02023-01-17 16:43:26 +08003919 DVR_PB_INFO("player dur[%d] sta[%d] cur[%d] -----reinit",
hualing chen03fd4942021-07-15 15:56:41 +08003920 player->con_spe.ply_dur,
3921 player->con_spe.ply_sta,
3922 p_status->time_cur);
hualing chend241c7a2021-06-22 13:34:27 +08003923 player->con_spe.ply_sta = p_status->time_cur;
3924 } else if (player->speed == 1.0f && player->con_spe.ply_sta < p_status->time_cur) {
3925 player->con_spe.ply_dur += (p_status->time_cur - player->con_spe.ply_sta);
wentao.mafdba9a02023-01-17 16:43:26 +08003926 DVR_PB_INFO("player dur[%d] sta[%d] cur[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08003927 player->con_spe.ply_dur,
3928 player->con_spe.ply_sta,
3929 p_status->time_cur);
hualing chend241c7a2021-06-22 13:34:27 +08003930 player->con_spe.ply_sta = p_status->time_cur;
3931 }
3932
3933 if (player->con_spe.sys_sta == 0) {
3934 player->con_spe.sys_sta = _dvr_time_getClock();
3935 } else if (player->speed == 1.0f && player->con_spe.sys_sta > 0) {
3936 player->con_spe.sys_dur += (_dvr_time_getClock() - player->con_spe.sys_sta);
3937 player->con_spe.sys_sta = _dvr_time_getClock();
3938 }
3939 }
3940
hualing chen4b7c15d2020-04-07 16:13:48 +08003941 if (player->last_send_time_id == UINT64_MAX) {
3942 player->last_send_time_id = player->cur_segment_id;
3943 player->last_cur_time = p_status->time_cur;
3944 }
3945 if (player->last_send_time_id == player->cur_segment_id) {
Wentao MA80179512022-11-03 12:20:03 +08003946 if (player->speed > 1.0f ) {
hualing chen4b7c15d2020-04-07 16:13:48 +08003947 //ff
3948 if (p_status->time_cur < player->last_cur_time ) {
Wentao MA96f68962022-06-15 19:45:35 +08003949 DVR_PB_INFO("get ff time error last[%d]cur[%d]diff[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08003950 player->last_cur_time,
3951 p_status->time_cur,
3952 player->last_cur_time - p_status->time_cur);
hualing chen4b7c15d2020-04-07 16:13:48 +08003953 p_status->time_cur = player->last_cur_time;
3954 } else {
3955 player->last_cur_time = p_status->time_cur;
3956 }
hualing chene41f4372020-06-06 16:29:17 +08003957 } else if (player->speed <= -1.0f){
hualing chen4b7c15d2020-04-07 16:13:48 +08003958 //fb
3959 if (p_status->time_cur > player->last_cur_time ) {
Wentao MA96f68962022-06-15 19:45:35 +08003960 DVR_PB_INFO("get fb time error last[%d]cur[%d]diff[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08003961 player->last_cur_time,
3962 p_status->time_cur,
3963 p_status->time_cur - player->last_cur_time );
hualing chen4b7c15d2020-04-07 16:13:48 +08003964 p_status->time_cur = player->last_cur_time;
3965 } else {
3966 player->last_cur_time = p_status->time_cur;
3967 }
3968 }
hualing chend241c7a2021-06-22 13:34:27 +08003969 } else {
hualing chen4b7c15d2020-04-07 16:13:48 +08003970 player->last_cur_time = p_status->time_cur;
3971 }
hualing chen969fe7b2021-05-26 15:13:17 +08003972 player->last_send_time_id = segment_id;
3973 p_status->segment_id = segment_id;
hualing chen2aba4022020-03-02 13:49:55 +08003974
hualing chen5cbe1a62020-02-10 16:36:36 +08003975 memcpy(&p_status->pids, &player->cur_segment.pids, sizeof(DVR_PlaybackPids_t));
hualing chencc91e1c2020-02-28 13:26:17 +08003976 p_status->speed = player->cmd.speed.speed.speed;
hualing chen5cbe1a62020-02-10 16:36:36 +08003977 p_status->flags = player->cur_segment.flags;
Wentao MA96f68962022-06-15 19:45:35 +08003978 DVR_PB_INFO("player real state[%s]state[%s]cur[%d]end[%d] id[%lld]playflag[%d]speed[%f]is_lock[%d]",
hualing chen03fd4942021-07-15 15:56:41 +08003979 _dvr_playback_state_toString(player->state),
3980 _dvr_playback_state_toString(p_status->state),
3981 p_status->time_cur, p_status->time_end,
3982 p_status->segment_id,player->play_flag,
3983 player->speed,
3984 is_lock);
hualing chen1679f812021-11-08 15:17:46 +08003985 if (is_lock ==DVR_TRUE) {
Wentao MA96f68962022-06-15 19:45:35 +08003986 DVR_PB_DEBUG("unlock ---\r\n");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08003987 dvr_mutex_unlock(&player->lock);
hualing chen1679f812021-11-08 15:17:46 +08003988 }
hualing chen2932d372020-04-29 13:44:00 +08003989 return DVR_SUCCESS;
3990}
3991
3992
3993/**\brief Get playback status
3994 * \param[in] handle playback handle
3995 * \param[out] p_status playback status
3996 * \retval DVR_SUCCESS On success
3997 * \return Error code
3998 */
3999int dvr_playback_get_status(DVR_PlaybackHandle_t handle,
4000 DVR_PlaybackStatus_t *p_status) {
4001//
4002 DVR_Playback_t *player = (DVR_Playback_t *) handle;
4003
Zhiqiang Han9adc9722020-11-11 18:38:10 +08004004 _dvr_playback_get_status(handle, p_status, DVR_TRUE);
4005
hualing chen2932d372020-04-29 13:44:00 +08004006 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08004007 DVR_PB_INFO("player is NULL");
hualing chen2932d372020-04-29 13:44:00 +08004008 return DVR_FAILURE;
4009 }
Wentao MA96f68962022-06-15 19:45:35 +08004010 DVR_PB_DEBUG("lock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08004011 dvr_mutex_lock(&player->lock);
Zhiqiang Han9adc9722020-11-11 18:38:10 +08004012 if (!player->has_video && !player->has_audio)
4013 p_status->time_cur = 0;
Wentao MA96f68962022-06-15 19:45:35 +08004014 DVR_PB_DEBUG("unlock---");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08004015 dvr_mutex_unlock(&player->lock);
hualing chen2932d372020-04-29 13:44:00 +08004016
hualing chenb31a6c62020-01-13 17:27:00 +08004017 return DVR_SUCCESS;
4018}
4019
hualing chen040df222020-01-17 13:35:02 +08004020void _dvr_dump_segment(DVR_PlaybackSegmentInfo_t *segment) {
4021 if (segment != NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08004022 DVR_PB_INFO("segment id: %lld", segment->segment_id);
4023 DVR_PB_INFO("segment flag: %d", segment->flags);
4024 DVR_PB_INFO("segment location: [%s]", segment->location);
4025 DVR_PB_INFO("segment vpid: 0x%x vfmt:0x%x", segment->pids.video.pid,segment->pids.video.format);
4026 DVR_PB_INFO("segment apid: 0x%x afmt:0x%x", segment->pids.audio.pid,segment->pids.audio.format);
4027 DVR_PB_INFO("segment pcr pid: 0x%x pcr fmt:0x%x", segment->pids.pcr.pid,segment->pids.pcr.format);
4028 DVR_PB_INFO("segment sub apid: 0x%x sub afmt:0x%x", segment->pids.ad.pid,segment->pids.ad.format);
hualing chen86e7d482020-01-16 15:13:33 +08004029 }
hualing chenb31a6c62020-01-13 17:27:00 +08004030}
4031
hualing chen5cbe1a62020-02-10 16:36:36 +08004032int dvr_dump_segmentinfo(DVR_PlaybackHandle_t handle, uint64_t segment_id) {
hualing chen040df222020-01-17 13:35:02 +08004033 DVR_Playback_t *player = (DVR_Playback_t *) handle;
hualing chenb31a6c62020-01-13 17:27:00 +08004034
hualing chena540a7e2020-03-27 16:44:05 +08004035 if (player == NULL) {
Wentao MA96f68962022-06-15 19:45:35 +08004036 DVR_PB_INFO("player is NULL");
hualing chena540a7e2020-03-27 16:44:05 +08004037 return DVR_FAILURE;
4038 }
4039
hualing chen040df222020-01-17 13:35:02 +08004040 DVR_PlaybackSegmentInfo_t *segment;
wentao.mafd5283f2022-10-14 09:51:13 +08004041 // This error is suppressed as the macro code is picked from kernel.
wentao.maa22bc852022-10-13 12:18:06 +08004042 // prefetch() here incurring self_assign is used to avoid some compiling
4043 // warnings.
4044 // coverity[self_assign]
hualing chen040df222020-01-17 13:35:02 +08004045 list_for_each_entry(segment, &player->segment_list, head)
hualing chen86e7d482020-01-16 15:13:33 +08004046 {
Wentao MA07d3d742022-09-06 09:58:05 +08004047 if (segment->segment_id == segment_id) {
hualing chen040df222020-01-17 13:35:02 +08004048 _dvr_dump_segment(segment);
Wentao MA07d3d742022-09-06 09:58:05 +08004049 break;
hualing chen86e7d482020-01-16 15:13:33 +08004050 }
4051 }
4052 return 0;
hualing chenb31a6c62020-01-13 17:27:00 +08004053}
pengfei.liu07ddc8a2020-03-24 23:36:53 +08004054
pengfei.liu27cc4ec2020-04-03 16:28:16 +08004055int dvr_playback_set_decrypt_callback(DVR_PlaybackHandle_t handle, DVR_CryptoFunction_t func, void *userdata)
pengfei.liu07ddc8a2020-03-24 23:36:53 +08004056{
4057 DVR_Playback_t *player = (DVR_Playback_t *) handle;
4058 DVR_RETURN_IF_FALSE(player);
4059 DVR_RETURN_IF_FALSE(func);
4060
Wentao MA96f68962022-06-15 19:45:35 +08004061 DVR_PB_INFO("in ");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08004062 dvr_mutex_lock(&player->lock);
pengfei.liu07ddc8a2020-03-24 23:36:53 +08004063
4064 player->dec_func = func;
4065 player->dec_userdata = userdata;
4066
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08004067 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08004068 DVR_PB_INFO("out ");
pengfei.liu07ddc8a2020-03-24 23:36:53 +08004069 return DVR_SUCCESS;
4070}
4071
4072int dvr_playback_set_secure_buffer(DVR_PlaybackHandle_t handle, uint8_t *p_secure_buf, uint32_t len)
4073{
4074 DVR_Playback_t *player = (DVR_Playback_t *) handle;
4075 DVR_RETURN_IF_FALSE(player);
4076 DVR_RETURN_IF_FALSE(p_secure_buf);
4077 DVR_RETURN_IF_FALSE(len);
4078
Wentao MA96f68962022-06-15 19:45:35 +08004079 DVR_PB_INFO("in ");
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08004080 dvr_mutex_lock(&player->lock);
pengfei.liu07ddc8a2020-03-24 23:36:53 +08004081
4082 player->is_secure_mode = 1;
4083 player->secure_buffer = p_secure_buf;
4084 player->secure_buffer_size = len;
4085
Zhiqiang Hanf9c0e272022-06-14 13:54:03 +08004086 dvr_mutex_unlock(&player->lock);
Wentao MA96f68962022-06-15 19:45:35 +08004087 DVR_PB_INFO("out");
pengfei.liu07ddc8a2020-03-24 23:36:53 +08004088 return DVR_SUCCESS;
4089}
Wentao MA5629ad82022-08-24 10:03:02 +08004090
4091int dvr_playback_set_ac4_preselection_id(DVR_PlaybackHandle_t handle, int presel_id)
4092{
4093 DVR_Playback_t *player = (DVR_Playback_t *) handle;
wentao.maa210e5e2022-10-12 16:10:03 +08004094 DVR_RETURN_IF_FALSE(player != NULL);
Wentao MA5629ad82022-08-24 10:03:02 +08004095
4096 player->audio_presentation_id = presel_id;
4097 am_tsplayer_result ret = AmTsPlayer_setParams(player->handle,
4098 AM_TSPLAYER_KEY_AUDIO_PRESENTATION_ID, &presel_id);
4099 DVR_RETURN_IF_FALSE(ret == AM_TSPLAYER_OK);
4100
4101 return DVR_SUCCESS;
4102}
Wentao MAa0b9c002022-11-10 17:47:27 +08004103
4104// This function ensures a valid TsPlayer delay time is provided or else it
4105// returns DVR_FAILURE. It is designed to workaround a weakness of
4106// AmTsPlayer_getDelayTime at starting phase of a playback in a short period
4107// of 20ms or less. During the said period, getDelayTime does NOT work as
4108// expect to return real delay length because demux isn't actually running
4109// to provide valid pts to TsPlayer.
Wentao MA804bab12022-11-29 10:01:26 +08004110static int get_effective_tsplayer_delay_time(DVR_Playback_t* play, int *time)
Wentao MAa0b9c002022-11-10 17:47:27 +08004111{
4112 int64_t delay=0;
4113 uint64_t pts_a=0;
4114 uint64_t pts_v=0;
4115
Wentao MA804bab12022-11-29 10:01:26 +08004116 DVR_RETURN_IF_FALSE(play != NULL);
4117 DVR_RETURN_IF_FALSE(play->handle != NULL);
Wentao MAa0b9c002022-11-10 17:47:27 +08004118
Wentao MA804bab12022-11-29 10:01:26 +08004119 AmTsPlayer_getDelayTime(play->handle, &delay);
4120 // In scambled stream situation, the returned TsPlayer delay time is
4121 // invalid and dirty. An additional time check agaginst 15 minutes (900s)
4122 // is introduced to insure such error condition is handled properly.
4123 DVR_RETURN_IF_FALSE((delay >= 0) && (delay <= 900*1000));
Wentao MAa0b9c002022-11-10 17:47:27 +08004124
Wentao MA804bab12022-11-29 10:01:26 +08004125 if (play->delay_is_effective) {
4126 *time = (int)delay;
Wentao MAa0b9c002022-11-10 17:47:27 +08004127 return DVR_SUCCESS;
4128 } else if (delay > 0) {
Wentao MA804bab12022-11-29 10:01:26 +08004129 *time = (int)delay;
4130 play->delay_is_effective=DVR_TRUE;
Wentao MAa0b9c002022-11-10 17:47:27 +08004131 return DVR_SUCCESS;
4132 }
4133
Wentao MA804bab12022-11-29 10:01:26 +08004134 AmTsPlayer_getPts(play->handle, TS_STREAM_AUDIO, &pts_a);
4135 AmTsPlayer_getPts(play->handle, TS_STREAM_VIDEO, &pts_v);
Wentao MAa0b9c002022-11-10 17:47:27 +08004136 if ((int64_t)pts_a > 0 || (int64_t)pts_v > 0) {
Wentao MA804bab12022-11-29 10:01:26 +08004137 *time = (int)delay;
4138 play->delay_is_effective=DVR_TRUE;
Wentao MAa0b9c002022-11-10 17:47:27 +08004139 return DVR_SUCCESS;
4140 }
4141
4142 return DVR_FAILURE;
4143}
4144