1 // Copyright (C) 2022 Beken Corporation
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <os/os.h>
16 #include <os/str.h>
17 #include <os/mem.h>
18 #include <components/log.h>
19 #include <common/bk_include.h>
20 #include <driver/int.h>
21 #include <driver/dvp_camera_types.h>
22
23 #include <components/video_transfer.h>
24
25
26 #include "media_core.h"
27 #include "media_evt.h"
28 #include "media_app.h"
29 #include "transfer_act.h"
30 #include "camera_act.h"
31 #include "lcd_act.h"
32
33 #include "wlan_ui_pub.h"
34
35 #define TAG "media_app"
36
37 #define LOGI(...) BK_LOGI(TAG, ##__VA_ARGS__)
38 #define LOGW(...) BK_LOGW(TAG, ##__VA_ARGS__)
39 #define LOGE(...) BK_LOGE(TAG, ##__VA_ARGS__)
40 #define LOGD(...) BK_LOGD(TAG, ##__VA_ARGS__)
41
42 static beken_thread_t media_app_th_hd = NULL;
43 static beken_queue_t media_app_msg_queue = NULL;
44
45 extern void rwnxl_set_video_transfer_flag(uint32_t video_transfer_flag);
46
media_send_msg_sync(uint32_t event,uint32_t param)47 bk_err_t media_send_msg_sync(uint32_t event, uint32_t param)
48 {
49 int ret = kGeneralErr;
50 param_pak_t *param_pak = (param_pak_t *) os_malloc(sizeof(param_pak_t));
51 media_msg_t msg;
52
53 if (param_pak == NULL)
54 {
55 LOGE("%s malloc param_pak_t failed\n", __func__);
56 goto out;
57 }
58
59 ret = rtos_init_semaphore_ex(¶m_pak->sem, 1, 0);
60
61 if (ret != kNoErr)
62 {
63 LOGE("%s init semaphore failed\n", __func__);
64 goto out;
65 }
66
67 param_pak->param = param;
68
69 msg.event = event;
70 msg.param = (uint32_t)param_pak;
71
72 media_send_msg(&msg);
73
74 ret = rtos_get_semaphore(¶m_pak->sem, BEKEN_WAIT_FOREVER);
75
76 if (ret != kNoErr)
77 {
78 LOGE("%s wait semaphore failed\n", __func__);
79 goto out;
80 }
81
82 ret = param_pak->ret;
83
84 rtos_deinit_semaphore(¶m_pak->sem);
85
86 out:
87
88 if (param_pak)
89 {
90 os_free(param_pak);
91 }
92
93 return ret;
94 }
95
96
media_app_camera_open(app_camera_type_t type,media_ppi_t ppi)97 bk_err_t media_app_camera_open(app_camera_type_t type, media_ppi_t ppi)
98 {
99 int ret = kGeneralErr;
100
101 LOGI("%s\n", __func__);
102
103 if (type == APP_CAMERA_DVP)
104 {
105 if (CAMERA_STATE_DISABLED != get_camera_state())
106 {
107 LOGI("%s already opened\n", __func__);
108 return kNoErr;
109 }
110
111 ret = media_send_msg_sync(EVENT_CAM_DVP_JPEG_OPEN_IND, ppi);
112 }
113 else if (type == APP_CAMERA_YUV)
114 {
115 if (CAMERA_STATE_DISABLED != get_camera_state())
116 {
117 LOGI("%s already opened\n", __func__);
118 return kNoErr;
119 }
120
121 ret = media_send_msg_sync(EVENT_CAM_DVP_YUV_OPEN_IND, ppi);
122 }
123 else if (type == APP_CAMERA_UVC)
124 {
125
126 #if (CONFIG_USB_UVC)
127 if (CAMERA_STATE_DISABLED != get_camera_state())
128 {
129 LOGI("%s already opened\n", __func__);
130 return kNoErr;
131 }
132
133 ret = media_send_msg_sync(EVENT_CAM_UVC_OPEN_IND, ppi);
134 #endif
135 }
136
137 return ret;
138 }
139
media_app_camera_close(app_camera_type_t type)140 bk_err_t media_app_camera_close(app_camera_type_t type)
141 {
142 int ret = kGeneralErr;
143
144 LOGI("%s\n", __func__);
145
146 if (type == APP_CAMERA_DVP)
147 {
148 if (CAMERA_STATE_ENABLED != get_camera_state())
149 {
150 LOGI("%s already closed\n", __func__);
151 return kNoErr;
152 }
153
154 ret = media_send_msg_sync(EVENT_CAM_DVP_CLOSE_IND, DVP_MODE_JPG);
155 }
156 else if (type == APP_CAMERA_YUV)
157 {
158 if (CAMERA_STATE_ENABLED != get_camera_state())
159 {
160 LOGI("%s already closed\n", __func__);
161 return kNoErr;
162 }
163
164 ret = media_send_msg_sync(EVENT_CAM_DVP_CLOSE_IND, DVP_MODE_YUV);
165 }
166 else if (type == APP_CAMERA_UVC)
167 {
168
169
170 #if (CONFIG_USB_UVC)
171
172 if (CAMERA_STATE_DISABLED == get_camera_state())
173 {
174 LOGI("%s already opened\n", __func__);
175 return kNoErr;
176 }
177
178 ret = media_send_msg_sync(EVENT_CAM_UVC_CLOSE_IND, 0);
179 #endif
180 }
181
182 return ret;
183 }
184
media_app_mailbox_test(void)185 bk_err_t media_app_mailbox_test(void)
186 {
187 bk_err_t ret = BK_FAIL;
188 uint32_t param = 0x88888888;
189
190 LOGI("%s +++\n", __func__);
191
192 ret = media_send_msg_sync(EVENT_LCD_DEFAULT_CMD, param);
193
194 LOGI("%s ---\n", __func__);
195
196 return ret;
197 }
198
media_app_transfer_open(void * setup_cfg)199 bk_err_t media_app_transfer_open(void *setup_cfg)
200 {
201 int ret = kNoErr;
202 video_setup_t *ptr = NULL;
203
204 LOGI("%s, %p\n", __func__, ((video_setup_t *)setup_cfg)->send_func);
205
206 bk_wlan_ps_disable();
207
208 rwnxl_set_video_transfer_flag(true);
209
210 if (TRS_STATE_DISABLED != get_transfer_state())
211 {
212 LOGI("%s already opened\n", __func__);
213 return ret;
214 }
215
216 ptr = (video_setup_t *)os_malloc(sizeof(video_setup_t));
217 os_memcpy(ptr, (video_setup_t *)setup_cfg, sizeof(video_setup_t));
218
219 ret = media_send_msg_sync(EVENT_TRANSFER_OPEN_IND, (uint32_t)ptr);
220
221 os_free(ptr);
222
223 return ret;
224 }
225
media_app_transfer_pause(bool pause)226 bk_err_t media_app_transfer_pause(bool pause)
227 {
228 return media_send_msg_sync(EVENT_TRANSFER_PAUSE_IND, pause);
229 }
230
media_app_transfer_close(void)231 bk_err_t media_app_transfer_close(void)
232 {
233 if (TRS_STATE_ENABLED != get_transfer_state())
234 {
235 LOGI("%s already closed\n", __func__);
236 return kNoErr;
237 }
238
239 return media_send_msg_sync(EVENT_TRANSFER_CLOSE_IND, 0);
240 }
241
media_app_lcd_rotate(bool enable)242 bk_err_t media_app_lcd_rotate(bool enable)
243 {
244 LOGI("%s\n", __func__);
245
246 return media_send_msg_sync(EVENT_LCD_ROTATE_ENABLE_IND, enable);
247 }
248
media_app_lcd_open(uint32_t lcd_ppi)249 bk_err_t media_app_lcd_open(uint32_t lcd_ppi)
250 {
251 if (LCD_STATE_DISABLED != get_lcd_state())
252 {
253 LOGI("%s already opened\n", __func__);
254 return kNoErr;
255 }
256
257 return media_send_msg_sync(EVENT_LCD_OPEN_IND, lcd_ppi);
258 }
259
media_app_lcd_close(void)260 bk_err_t media_app_lcd_close(void)
261 {
262 if (LCD_STATE_ENABLED != get_lcd_state())
263 {
264 LOGI("%s already closed\n", __func__);
265 return kNoErr;
266 }
267
268 return media_send_msg_sync(EVENT_LCD_CLOSE_IND, 0);
269 }
270
271
media_app_lcd_set_backlight(uint8_t level)272 bk_err_t media_app_lcd_set_backlight(uint8_t level)
273 {
274 if (LCD_STATE_ENABLED != get_lcd_state())
275 {
276 LOGI("%s not open\n", __func__);
277 return kNoErr;
278 }
279
280 return media_send_msg_sync(EVENT_LCD_SET_BACKLIGHT_IND, level);
281 }
282
283
media_app_send_msg(media_msg_t * msg)284 bk_err_t media_app_send_msg(media_msg_t *msg)
285 {
286 bk_err_t ret;
287
288 if (media_app_msg_queue)
289 {
290 ret = rtos_push_to_queue(&media_app_msg_queue, msg, BEKEN_NO_WAIT);
291
292 if (kNoErr != ret)
293 {
294 LOGE("%s failed\n", __func__);
295 return kOverrunErr;
296 }
297
298 return ret;
299 }
300 return kNoResourcesErr;
301 }
302
media_app_capture(char * name)303 bk_err_t media_app_capture(char *name)
304 {
305 int ret;
306 char *capture_name = NULL;
307
308 LOGI("%s, %s\n", __func__, name);
309
310 if (name != NULL)
311 {
312 uint32_t len = os_strlen(name) + 1;
313
314 if (len > 31)
315 {
316 len = 31;
317 }
318
319 capture_name = (char *)os_malloc(len);
320 os_memset(capture_name, 0, len);
321 os_memcpy(capture_name, name, len);
322 capture_name[len - 1] = '\0';
323 }
324
325 ret = media_send_msg_sync(EVENT_STORAGE_CAPTURE_IND, (uint32_t)capture_name);
326 os_free(capture_name);
327
328 return ret;
329 }
330
331
media_app_message_handle(void)332 static void media_app_message_handle(void)
333 {
334 bk_err_t ret = BK_OK;
335 media_msg_t msg;
336
337 while (1)
338 {
339 ret = rtos_pop_from_queue(&media_app_msg_queue, &msg, BEKEN_WAIT_FOREVER);
340
341 if (kNoErr == ret)
342 {
343 switch (msg.event)
344 {
345 case EVENT_APP_DVP_OPEN:
346 break;
347
348 case EVENT_APP_EXIT:
349 goto exit;
350 break;
351
352 default:
353 break;
354 }
355 }
356 }
357
358 exit:
359
360 /* delate msg queue */
361 ret = rtos_deinit_queue(&media_app_msg_queue);
362
363 if (ret != kNoErr)
364 {
365 LOGE("delate message queue fail\n");
366 }
367
368 media_app_msg_queue = NULL;
369
370 LOGE("delate message queue complete\n");
371
372 /* delate task */
373 media_app_th_hd = NULL;
374 rtos_delete_thread(NULL);
375
376 LOGE("delate task complete\n");
377 }
378
379
media_app_init(void)380 bk_err_t media_app_init(void)
381 {
382 bk_err_t ret = BK_OK;
383
384 if (media_app_msg_queue != NULL)
385 {
386 ret = kNoErr;
387 LOGE("%s, media_app_msg_queue allready init, exit!\n");
388 goto error;
389 }
390
391 if (media_app_th_hd != NULL)
392 {
393 ret = kNoErr;
394 LOGE("%s, media_app_th_hd allready init, exit!\n");
395 goto error;
396 }
397
398 ret = rtos_init_queue(&media_app_msg_queue,
399 "media_app_msg_queue",
400 sizeof(media_msg_t),
401 MEDIA_MINOR_MSG_QUEUE_SIZE);
402
403 if (ret != kNoErr)
404 {
405 LOGE("%s, ceate media minor message queue failed\n");
406 goto error;
407 }
408
409 ret = rtos_create_thread(&media_app_th_hd,
410 BEKEN_DEFAULT_WORKER_PRIORITY,
411 "media_app_thread",
412 (beken_thread_function_t)media_app_message_handle,
413 4096,
414 NULL);
415
416 if (ret != kNoErr)
417 {
418 LOGE("create media app thread fail\n");
419 goto error;
420 }
421
422
423 LOGI("media minor thread startup complete\n");
424
425 return kNoErr;
426 error:
427
428 if (media_app_msg_queue)
429 {
430 rtos_deinit_queue(&media_app_msg_queue);
431 media_app_msg_queue = NULL;
432 }
433
434 return ret;
435 }
436
media_app_dump_display_frame(void)437 bk_err_t media_app_dump_display_frame(void)
438 {
439 return media_send_msg_sync(EVENT_LCD_DUMP_DISPLAY_IND, 0);
440 }
441
media_app_dump_decoder_frame(void)442 bk_err_t media_app_dump_decoder_frame(void)
443 {
444 return media_send_msg_sync(EVENT_LCD_DUMP_DECODER_IND, 0);
445 }
446
media_app_dump_jpeg_frame(void)447 bk_err_t media_app_dump_jpeg_frame(void)
448 {
449 return media_send_msg_sync(EVENT_LCD_DUMP_JPEG_IND, 0);
450 }
451
media_app_lcd_step_mode(bool enable)452 bk_err_t media_app_lcd_step_mode(bool enable)
453 {
454 return media_send_msg_sync(EVENT_LCD_STEP_MODE_IND, enable);
455 }
456
media_app_lcd_step_trigger(void)457 bk_err_t media_app_lcd_step_trigger(void)
458 {
459 return media_send_msg_sync(EVENT_LCD_STEP_TRIGGER_IND, 0);
460 }
461
462