jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3686 Commits
7 Branches
47MB
Tree: 3f778bec03
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3f778bec03'
${ noResults }
jack2/linux/avb/mrpClient_interface.c

248 lines
8.1KB
Raw Blame History 

  1. #include "mrpClient_interface.h"

  2. 

  3. 

  4. extern int errno;

  5. 

  6. 

  7. int mrpClient_getDomain(FILE* filepointer, mrp_ctx_t *mrp_ctx)

  8. {

  9. 	int ret=0;

  10. 

  11.     /*

  12.      * we may not get a notification if we are joining late,

  13.      * so query for what is already there ...

  14.      */

  15. 	char* msgbuf= malloc(1500);

  16.     if (NULL == msgbuf){

  17.         fprintf(filepointer,  "failed to create msgbuf. %d %s\n",  errno, strerror(errno));fflush(filepointer);

  18.         return RETURN_VALUE_FAILURE;

  19.     }

  20. 

  21.     memset(msgbuf, 0, 1500);

  22.     sprintf(msgbuf, "S??");

  23. 	fprintf(filepointer, "Get Domain %s\n",msgbuf);fflush(filepointer);

  24.     ret = mrpClient_send_mrp_msg( filepointer, mrpClient_get_Control_socket(), msgbuf, 1500);

  25. 

  26. 

  27.     fprintf(filepointer,  "Query SRP Domain: %s\n",  msgbuf);fflush(filepointer);

  28.     free(msgbuf);

  29.     if (ret != 1500){

  30.         fprintf(filepointer,  "failed to create socket. %d %s\n",  errno, strerror(errno));fflush(filepointer);

  31.         return RETURN_VALUE_FAILURE;

  32.     }

  33. 

  34. 

  35.     while ( (mrp_ctx->domain_a_valid == 0) || (mrp_ctx->domain_b_valid == 0 ) ||

  36.                 (mrp_ctx->domain_class_a_vid == 0) || (mrp_ctx->domain_class_b_vid == 0) ){

  37.         usleep(20000);

  38.     }

  39. 

  40. //    if (mrp_ctx->domain_a_valid > 0) {

  41. //        class_a->id = mrp_ctx->domain_class_a_id;

  42. //        class_a->priority = mrp_ctx->domain_class_a_priority;

  43. //        class_a->vid = mrp_ctx->domain_class_a_vid;

  44. //    }

  45. //    if (mrp_ctx->domain_b_valid > 0) {

  46. //        class_b->id = mrp_ctx->domain_class_b_id;

  47. //        class_b->priority = mrp_ctx->domain_class_b_priority;

  48. //        class_b->vid = mrp_ctx->domain_class_b_vid;

  49. //    }

  50. 

  51. 	return RETURN_VALUE_SUCCESS;

  52. }

  53. 

  54. 

  55. int mrpClient_report_domain_status(FILE* filepointer, mrp_ctx_t *mrp_ctx)

  56. {

  57. 	char* msgbuf= malloc(1500);

  58. 	int rc=0;

  59. 

  60. 

  61. 	if (NULL == msgbuf){

  62. 		fprintf(filepointer,  "mrp_listener_report_domain_status - NULL == msgbuf \t LISTENER_FAILED \n");fflush(filepointer);

  63. 		mrp_ctx->mrp_status = LISTENER_FAILED;

  64. 

  65. 

  66. 		return RETURN_VALUE_FAILURE;

  67. 	}

  68. 	memset(msgbuf, 0, 1500);

  69. 	sprintf(msgbuf, "S+D:C=%d,P=%d,V=%04x", mrp_ctx->domain_class_a_id, mrp_ctx->domain_class_a_priority, mrp_ctx->domain_class_a_vid);

  70. 	fprintf(filepointer, "Report Domain Status %s\n",msgbuf);fflush(filepointer);

  71. 	rc = mrpClient_send_mrp_msg( filepointer, mrpClient_get_Control_socket(), msgbuf, 1500);

  72. 	free(msgbuf);

  73. 

  74. 	if (rc != 1500){

  75. 		fprintf(filepointer,  "mrp_listener_report_domain_status - rc != 1500 \t LISTENER_FAILED \n");fflush(filepointer);

  76. 		mrp_ctx->mrp_status = LISTENER_FAILED;

  77. 

  78. 		return RETURN_VALUE_FAILURE;

  79. 	}

  80. 

  81.     fprintf(filepointer,  "mrp_listener_report_domain_status\t LISTENER_IDLE \n");fflush(filepointer);

  82.     mrp_ctx->mrp_status = LISTENER_IDLE;

  83. 

  84. 	return RETURN_VALUE_SUCCESS;

  85. }

  86. 

  87. 

  88. 

  89. 

  90. int mrpClient_joinVLAN(FILE* filepointer, mrp_ctx_t *mrp_ctx)

  91. {

  92. 	char* msgbuf= malloc(1500);

  93. 	int rc=0;

  94. 

  95. 	if (NULL == msgbuf)		return RETURN_VALUE_FAILURE;

  96. 

  97. 	memset(msgbuf, 0, 1500);

  98. 	sprintf(msgbuf, "V++:I=%04x",mrp_ctx->domain_class_a_vid);

  99. 	fprintf(filepointer, "Joing VLAN %s\n",msgbuf);fflush(filepointer);

  100. 

  101.     rc = mrpClient_send_mrp_msg( filepointer, mrpClient_get_Control_socket(), msgbuf, 1500);

  102.     free(msgbuf);

  103. 

  104.     if( rc != 1500){

  105.         fprintf(filepointer,  "int mrp_listener_join_vlan - rc != 1500\t LISTENER_FAILED\n");fflush(filepointer);

  106.         mrp_ctx->mrp_status = LISTENER_FAILED;

  107.         return RETURN_VALUE_FAILURE;

  108.     } else {

  109.         fprintf(filepointer,  "int mrp_listener_join_vlan - rc != 1500\t LISTENER_IDLE\n");fflush(filepointer);

  110.         mrp_ctx->mrp_status = LISTENER_IDLE;

  111.         return RETURN_VALUE_SUCCESS;

  112.     }

  113. 

  114. 

  115.     return RETURN_VALUE_FAILURE;

  116. }

  117. 

  118. 

  119. 

  120. int mrpClient_getDomain_joinVLAN(FILE* filepointer, ieee1722_avtp_driver_state_t **ieee1722mc, mrp_ctx_t *mrp_ctx)

  121. {

  122.     fprintf(filepointer,  "calling mrp_get_domain()\n");fflush(filepointer);

  123. 

  124.     if ( mrpClient_getDomain( filepointer, mrp_ctx) > RETURN_VALUE_FAILURE)	{

  125.         fprintf(filepointer,  "success calling mrp_get_domain()\n");fflush(filepointer);

  126.     } else {

  127.         fprintf(filepointer,  "failed calling mrp_get_domain()\n");fflush(filepointer);

  128.         return RETURN_VALUE_FAILURE;

  129.     }

  130. 

  131.     fprintf(filepointer,  "detected domain Class A PRIO=%d VID=%04x...\n",mrp_ctx->domain_class_a_priority,

  132.                                                                             mrp_ctx->domain_class_a_vid);fflush(filepointer);

  133. 

  134.     if ( mrpClient_report_domain_status( filepointer, mrp_ctx) > RETURN_VALUE_FAILURE ) {

  135.         fprintf(filepointer,  "report_domain_status success\n");fflush(filepointer);

  136.     } else {

  137.         fprintf(filepointer,  "report_domain_status failed\n");fflush(filepointer);

  138. 

  139.         return RETURN_VALUE_FAILURE;

  140.     }

  141. 

  142.     if ( mrpClient_joinVLAN( filepointer, mrp_ctx) > RETURN_VALUE_FAILURE) {

  143.         fprintf(filepointer,  "join_vlan success\n");fflush(filepointer);

  144.     } else {

  145.         fprintf(filepointer,  "join_vlan failed\n");fflush(filepointer);

  146. 

  147.         return RETURN_VALUE_FAILURE;

  148.     }

  149. 

  150. 

  151. 	return RETURN_VALUE_SUCCESS;

  152. }

  153. 

  154. 

  155. 

  156. 

  157. 

  158. 

  159. int mrpClient_listener_await_talker(FILE* filepointer, ieee1722_avtp_driver_state_t **ieee1722mc, mrp_ctx_t *mrp_ctx)

  160. {

  161.     if( mrp_ctx->mrp_status  == LISTENER_READY)   {

  162.         fprintf(filepointer,  "Already connected to a talker...\n");fflush(filepointer);

  163.         return RETURN_VALUE_FAILURE;

  164.     } else {

  165.         mrp_ctx->mrp_status = LISTENER_WAITING;

  166.         fprintf(filepointer,  "Waiting for talker...\n");fflush(filepointer);

  167.         fprintf(filepointer,  "int mrp_listener_await_talker - rc != 1500\t LISTENER_WAITING\n");fflush(filepointer);

  168. 

  169.         struct timespec tim, tim2;

  170.         tim.tv_sec = 0;

  171.         tim.tv_nsec = MILISLEEP_TIME * 5;

  172.         while(mrp_ctx->mrp_status == LISTENER_WAITING

  173.                 && mrp_ctx->mrp_status != LISTENER_READY ){

  174.             nanosleep(&tim , &tim2);

  175.         }

  176. 

  177.         if ( mrpClient_listener_send_ready( filepointer, ieee1722mc, mrp_ctx ) > RETURN_VALUE_FAILURE) {

  178.             fprintf(filepointer,  "send_ready success\n");fflush(filepointer);

  179.             return RETURN_VALUE_SUCCESS;

  180.         }

  181.     }

  182. 

  183.     return RETURN_VALUE_FAILURE;

  184. }

  185. 

  186. int mrpClient_listener_send_ready(FILE* filepointer, ieee1722_avtp_driver_state_t **ieee1722mc, mrp_ctx_t *mrp_ctx)

  187. {

  188. 	char *databuf= malloc(1500);

  189. 	int rc=0;

  190. 

  191. 	if (NULL == databuf) return RETURN_VALUE_FAILURE;

  192. 

  193. 	memset(databuf, 0, 1500);

  194. 	sprintf(databuf, "S+L:L=%02x%02x%02x%02x%02x%02x%02x%02x,D=2",

  195. 			(*ieee1722mc)->streamid8[0], (*ieee1722mc)->streamid8[1],

  196. 			(*ieee1722mc)->streamid8[2], (*ieee1722mc)->streamid8[3],

  197. 			 (*ieee1722mc)->streamid8[4], (*ieee1722mc)->streamid8[5],

  198. 			 (*ieee1722mc)->streamid8[6], (*ieee1722mc)->streamid8[7]);

  199. 	rc = mrpClient_send_mrp_msg( filepointer, mrpClient_get_Control_socket(), databuf, 1500);

  200. 	fprintf(filepointer, "Send Ready %s\n",databuf);fflush(filepointer);

  201. 	free(databuf);

  202. 

  203. 	if (rc != 1500){

  204.         fprintf(filepointer,  "mrp_listener_send_ready - rc != 1500\t LISTENER_FAILED\n");fflush(filepointer);

  205. 		mrp_ctx->mrp_status = LISTENER_FAILED;

  206. 

  207. 		return RETURN_VALUE_FAILURE;

  208. 	}

  209. 

  210.     fprintf(filepointer,  "mrp_listener_send_ready - rc != 1500\t LISTENER_IDLE\n");fflush(filepointer);

  211. 

  212. 	return RETURN_VALUE_SUCCESS;

  213. }

  214. 

  215. 

  216. int mrpClient_listener_send_leave(FILE* filepointer, ieee1722_avtp_driver_state_t **ieee1722mc, mrp_ctx_t *mrp_ctx)

  217. {

  218. 	char *databuf= malloc(1500);

  219. 	int rc=0;

  220. 

  221. 	if (NULL == databuf){

  222. 		return RETURN_VALUE_FAILURE;

  223. 	}

  224. 	memset(databuf, 0, 1500);

  225. 	sprintf(databuf, "S-L:L=%02x%02x%02x%02x%02x%02x%02x%02x,D=3",

  226. 			(*ieee1722mc)->streamid8[0], (*ieee1722mc)->streamid8[1],

  227. 			 (*ieee1722mc)->streamid8[2], (*ieee1722mc)->streamid8[3],

  228. 			 (*ieee1722mc)->streamid8[4], (*ieee1722mc)->streamid8[5],

  229. 			 (*ieee1722mc)->streamid8[6], (*ieee1722mc)->streamid8[7]);

  230. 	rc = mrpClient_send_mrp_msg(filepointer, mrpClient_get_Control_socket(), databuf, 1500);

  231. 	fprintf(filepointer, "Send Leave %s\n",databuf);fflush(filepointer);

  232. 	free(databuf);

  233. 

  234. 	if (rc != 1500){

  235. 		fprintf(filepointer,  "mrp_listener_send_leave - rc != 1500\t LISTENER_FAILED\n");fflush(filepointer);

  236. 		mrp_ctx->mrp_status = LISTENER_FAILED;

  237. 

  238. 		return RETURN_VALUE_FAILURE;

  239. 	} else {

  240.         fprintf(filepointer,  "mrp_listener_send_leave - rc != 1500\t LISTENER_IDLE\n");fflush(filepointer);

  241. 		mrp_ctx->mrp_status = LISTENER_IDLE;

  242. 

  243.         return RETURN_VALUE_SUCCESS;

  244. 	}

  245. }

  246.