diff options
author | mannol <eniz_vukovic@hotmail.com> | 2014-02-15 21:29:41 +0100 |
---|---|---|
committer | mannol <eniz_vukovic@hotmail.com> | 2014-02-16 19:11:55 -0500 |
commit | 3ae37315e154152daa9051d2c0a58fbcea0230e0 (patch) | |
tree | b823ab87be481f16d9d4a0fb9e212cce323c13f4 | |
parent | 393433ce9910c3dffed9090c7965654f23a8e7a8 (diff) |
Added comments...
-rw-r--r-- | toxav/toxav.c | 204 | ||||
-rw-r--r-- | toxav/toxav.h | 177 |
2 files changed, 334 insertions, 47 deletions
diff --git a/toxav/toxav.c b/toxav/toxav.c index 5683795e..daf6fe77 100644 --- a/toxav/toxav.c +++ b/toxav/toxav.c | |||
@@ -56,39 +56,24 @@ typedef struct _ToxAv | |||
56 | 56 | ||
57 | RTPSession* rtp_sessions[2]; /* Audio is first and video is second */ | 57 | RTPSession* rtp_sessions[2]; /* Audio is first and video is second */ |
58 | 58 | ||
59 | /* TODO: Add media session */ | ||
60 | struct jitter_buffer* j_buf; | 59 | struct jitter_buffer* j_buf; |
61 | CodecState* cs; | 60 | CodecState* cs; |
62 | /* TODO: Add media session threads */ | ||
63 | |||
64 | 61 | ||
65 | void* agent_handler; | 62 | void* agent_handler; |
66 | } ToxAv; | 63 | } ToxAv; |
67 | 64 | ||
68 | 65 | /** | |
69 | 66 | * @brief Start new A/V session. There can only be one session at the time. If you register more | |
70 | 67 | * it will result in undefined behaviour. | |
71 | |||
72 | /******************************************************************************************************************** | ||
73 | ******************************************************************************************************************** | ||
74 | ******************************************************************************************************************** | ||
75 | ******************************************************************************************************************** | ||
76 | ******************************************************************************************************************** | ||
77 | * | ||
78 | * | ||
79 | * | 68 | * |
80 | * PUBLIC API FUNCTIONS IMPLEMENTATIONS | 69 | * @param messenger The messenger handle. |
81 | * | 70 | * @param useragent The agent handling A/V session (i.e. phone). |
82 | * | 71 | * @param ua_name Useragent name. |
83 | * | 72 | * @param video_width Width of video frame. |
84 | ******************************************************************************************************************** | 73 | * @param video_height Height of video frame. |
85 | ******************************************************************************************************************** | 74 | * @return ToxAv* |
86 | ******************************************************************************************************************** | 75 | * @retval NULL On error. |
87 | ******************************************************************************************************************** | 76 | */ |
88 | ********************************************************************************************************************/ | ||
89 | |||
90 | |||
91 | |||
92 | ToxAv* toxav_new( Tox* messenger, void* useragent, const char* ua_name , uint16_t video_width, uint16_t video_height) | 77 | ToxAv* toxav_new( Tox* messenger, void* useragent, const char* ua_name , uint16_t video_width, uint16_t video_height) |
93 | { | 78 | { |
94 | ToxAv* av = calloc ( sizeof(ToxAv), 1); | 79 | ToxAv* av = calloc ( sizeof(ToxAv), 1); |
@@ -112,6 +97,12 @@ ToxAv* toxav_new( Tox* messenger, void* useragent, const char* ua_name , uint16_ | |||
112 | return av; | 97 | return av; |
113 | } | 98 | } |
114 | 99 | ||
100 | /** | ||
101 | * @brief Remove A/V session. | ||
102 | * | ||
103 | * @param av Handler. | ||
104 | * @return void | ||
105 | */ | ||
115 | void toxav_kill ( ToxAv* av ) | 106 | void toxav_kill ( ToxAv* av ) |
116 | { | 107 | { |
117 | msi_terminate_session(av->msi_session); | 108 | msi_terminate_session(av->msi_session); |
@@ -129,13 +120,29 @@ void toxav_kill ( ToxAv* av ) | |||
129 | free(av); | 120 | free(av); |
130 | } | 121 | } |
131 | 122 | ||
123 | /** | ||
124 | * @brief Register callback for call state. | ||
125 | * | ||
126 | * @param callback The callback | ||
127 | * @param id One of the ToxAvCallbackID values | ||
128 | * @return void | ||
129 | */ | ||
132 | void toxav_register_callstate_callback ( ToxAVCallback callback, ToxAvCallbackID id ) | 130 | void toxav_register_callstate_callback ( ToxAVCallback callback, ToxAvCallbackID id ) |
133 | { | 131 | { |
134 | msi_register_callback((MSICallback)callback, (MSICallbackID) id); | 132 | msi_register_callback((MSICallback)callback, (MSICallbackID) id); |
135 | } | 133 | } |
136 | 134 | ||
137 | 135 | /** | |
138 | 136 | * @brief Call user. Use its friend_id. | |
137 | * | ||
138 | * @param av Handler. | ||
139 | * @param user The user. | ||
140 | * @param call_type Call type. | ||
141 | * @param ringing_seconds Ringing timeout. | ||
142 | * @return int | ||
143 | * @retval 0 Success. | ||
144 | * @retval ToxAvError On error. | ||
145 | */ | ||
139 | int toxav_call (ToxAv* av, int user, ToxAvCallType call_type, int ringing_seconds ) | 146 | int toxav_call (ToxAv* av, int user, ToxAvCallType call_type, int ringing_seconds ) |
140 | { | 147 | { |
141 | if ( av->msi_session->call ) { | 148 | if ( av->msi_session->call ) { |
@@ -145,6 +152,14 @@ int toxav_call (ToxAv* av, int user, ToxAvCallType call_type, int ringing_second | |||
145 | return msi_invite(av->msi_session, call_type, ringing_seconds * 1000, user); | 152 | return msi_invite(av->msi_session, call_type, ringing_seconds * 1000, user); |
146 | } | 153 | } |
147 | 154 | ||
155 | /** | ||
156 | * @brief Hangup active call. | ||
157 | * | ||
158 | * @param av Handler. | ||
159 | * @return int | ||
160 | * @retval 0 Success. | ||
161 | * @retval ToxAvError On error. | ||
162 | */ | ||
148 | int toxav_hangup ( ToxAv* av ) | 163 | int toxav_hangup ( ToxAv* av ) |
149 | { | 164 | { |
150 | if ( !av->msi_session->call ) { | 165 | if ( !av->msi_session->call ) { |
@@ -158,6 +173,15 @@ int toxav_hangup ( ToxAv* av ) | |||
158 | return msi_hangup(av->msi_session); | 173 | return msi_hangup(av->msi_session); |
159 | } | 174 | } |
160 | 175 | ||
176 | /** | ||
177 | * @brief Answer incomming call. | ||
178 | * | ||
179 | * @param av Handler. | ||
180 | * @param call_type Answer with... | ||
181 | * @return int | ||
182 | * @retval 0 Success. | ||
183 | * @retval ToxAvError On error. | ||
184 | */ | ||
161 | int toxav_answer ( ToxAv* av, ToxAvCallType call_type ) | 185 | int toxav_answer ( ToxAv* av, ToxAvCallType call_type ) |
162 | { | 186 | { |
163 | if ( !av->msi_session->call ) { | 187 | if ( !av->msi_session->call ) { |
@@ -171,6 +195,15 @@ int toxav_answer ( ToxAv* av, ToxAvCallType call_type ) | |||
171 | return msi_answer(av->msi_session, call_type); | 195 | return msi_answer(av->msi_session, call_type); |
172 | } | 196 | } |
173 | 197 | ||
198 | /** | ||
199 | * @brief Reject incomming call. | ||
200 | * | ||
201 | * @param av Handler. | ||
202 | * @param reason Optional reason. Set NULL if none. | ||
203 | * @return int | ||
204 | * @retval 0 Success. | ||
205 | * @retval ToxAvError On error. | ||
206 | */ | ||
174 | int toxav_reject ( ToxAv* av, const char* reason ) | 207 | int toxav_reject ( ToxAv* av, const char* reason ) |
175 | { | 208 | { |
176 | if ( !av->msi_session->call ) { | 209 | if ( !av->msi_session->call ) { |
@@ -184,6 +217,15 @@ int toxav_reject ( ToxAv* av, const char* reason ) | |||
184 | return msi_reject(av->msi_session, (const uint8_t*) reason); | 217 | return msi_reject(av->msi_session, (const uint8_t*) reason); |
185 | } | 218 | } |
186 | 219 | ||
220 | /** | ||
221 | * @brief Cancel outgoing request. | ||
222 | * | ||
223 | * @param av Handler. | ||
224 | * @param reason Optional reason. | ||
225 | * @return int | ||
226 | * @retval 0 Success. | ||
227 | * @retval ToxAvError On error. | ||
228 | */ | ||
187 | int toxav_cancel ( ToxAv* av, const char* reason ) | 229 | int toxav_cancel ( ToxAv* av, const char* reason ) |
188 | { | 230 | { |
189 | if ( !av->msi_session->call ) { | 231 | if ( !av->msi_session->call ) { |
@@ -193,7 +235,14 @@ int toxav_cancel ( ToxAv* av, const char* reason ) | |||
193 | return msi_cancel(av->msi_session, 0, (const uint8_t*)reason); | 235 | return msi_cancel(av->msi_session, 0, (const uint8_t*)reason); |
194 | } | 236 | } |
195 | 237 | ||
196 | /* You can stop the call at any state */ | 238 | /** |
239 | * @brief Terminate transmission. Note that transmission will be terminated without informing remote peer. | ||
240 | * | ||
241 | * @param av Handler. | ||
242 | * @return int | ||
243 | * @retval 0 Success. | ||
244 | * @retval ToxAvError On error. | ||
245 | */ | ||
197 | int toxav_stop_call ( ToxAv* av ) | 246 | int toxav_stop_call ( ToxAv* av ) |
198 | { | 247 | { |
199 | if ( !av->msi_session->call ) { | 248 | if ( !av->msi_session->call ) { |
@@ -203,7 +252,14 @@ int toxav_stop_call ( ToxAv* av ) | |||
203 | return msi_stopcall(av->msi_session); | 252 | return msi_stopcall(av->msi_session); |
204 | } | 253 | } |
205 | 254 | ||
206 | 255 | /** | |
256 | * @brief Must be call before any RTP transmission occurs. | ||
257 | * | ||
258 | * @param av Handler. | ||
259 | * @return int | ||
260 | * @retval 0 Success. | ||
261 | * @retval ToxAvError On error. | ||
262 | */ | ||
207 | int toxav_prepare_transmission ( ToxAv* av ) | 263 | int toxav_prepare_transmission ( ToxAv* av ) |
208 | { | 264 | { |
209 | assert(av->msi_session); | 265 | assert(av->msi_session); |
@@ -246,7 +302,14 @@ int toxav_prepare_transmission ( ToxAv* av ) | |||
246 | return ErrorNone; | 302 | return ErrorNone; |
247 | } | 303 | } |
248 | 304 | ||
249 | 305 | /** | |
306 | * @brief Call this at the end of the transmission. | ||
307 | * | ||
308 | * @param av Handler. | ||
309 | * @return int | ||
310 | * @retval 0 Success. | ||
311 | * @retval ToxAvError On error. | ||
312 | */ | ||
250 | int toxav_kill_transmission ( ToxAv* av ) | 313 | int toxav_kill_transmission ( ToxAv* av ) |
251 | { | 314 | { |
252 | /* Both sessions should be active at any time */ | 315 | /* Both sessions should be active at any time */ |
@@ -268,6 +331,17 @@ int toxav_kill_transmission ( ToxAv* av ) | |||
268 | } | 331 | } |
269 | 332 | ||
270 | 333 | ||
334 | /** | ||
335 | * @brief Send RTP payload. | ||
336 | * | ||
337 | * @param av Handler. | ||
338 | * @param type Type of payload. | ||
339 | * @param payload The payload. | ||
340 | * @param length Size of it. | ||
341 | * @return int | ||
342 | * @retval 0 Success. | ||
343 | * @retval -1 Failure. | ||
344 | */ | ||
271 | inline__ int toxav_send_rtp_payload ( ToxAv* av, ToxAvCallType type, const uint8_t* payload, uint16_t length ) | 345 | inline__ int toxav_send_rtp_payload ( ToxAv* av, ToxAvCallType type, const uint8_t* payload, uint16_t length ) |
272 | { | 346 | { |
273 | if ( av->rtp_sessions[type - TypeAudio] ) | 347 | if ( av->rtp_sessions[type - TypeAudio] ) |
@@ -275,6 +349,16 @@ inline__ int toxav_send_rtp_payload ( ToxAv* av, ToxAvCallType type, const uint8 | |||
275 | else return -1; | 349 | else return -1; |
276 | } | 350 | } |
277 | 351 | ||
352 | /** | ||
353 | * @brief Receive RTP payload. | ||
354 | * | ||
355 | * @param av Handler. | ||
356 | * @param type Type of the payload. | ||
357 | * @param dest Storage. | ||
358 | * @return int | ||
359 | * @retval ToxAvError On Error. | ||
360 | * @retval >=0 Size of received payload. | ||
361 | */ | ||
278 | inline__ int toxav_recv_rtp_payload ( ToxAv* av, ToxAvCallType type, uint8_t* dest ) | 362 | inline__ int toxav_recv_rtp_payload ( ToxAv* av, ToxAvCallType type, uint8_t* dest ) |
279 | { | 363 | { |
280 | if ( !dest ) return ErrorInternal; | 364 | if ( !dest ) return ErrorInternal; |
@@ -316,6 +400,15 @@ inline__ int toxav_recv_rtp_payload ( ToxAv* av, ToxAvCallType type, uint8_t* de | |||
316 | return 0; | 400 | return 0; |
317 | } | 401 | } |
318 | 402 | ||
403 | /** | ||
404 | * @brief Receive decoded video packet. | ||
405 | * | ||
406 | * @param av Handler. | ||
407 | * @param output Storage. | ||
408 | * @return int | ||
409 | * @retval 0 Success. | ||
410 | * @retval ToxAvError On Error. | ||
411 | */ | ||
319 | inline__ int toxav_recv_video ( ToxAv* av, vpx_image_t **output) | 412 | inline__ int toxav_recv_video ( ToxAv* av, vpx_image_t **output) |
320 | { | 413 | { |
321 | if ( !output ) return ErrorInternal; | 414 | if ( !output ) return ErrorInternal; |
@@ -337,6 +430,15 @@ inline__ int toxav_recv_video ( ToxAv* av, vpx_image_t **output) | |||
337 | return 0; | 430 | return 0; |
338 | } | 431 | } |
339 | 432 | ||
433 | /** | ||
434 | * @brief Encode and send video packet. | ||
435 | * | ||
436 | * @param av Handler. | ||
437 | * @param input The packet. | ||
438 | * @return int | ||
439 | * @retval 0 Success. | ||
440 | * @retval ToxAvError On error. | ||
441 | */ | ||
340 | inline__ int toxav_send_video ( ToxAv* av, vpx_image_t *input) | 442 | inline__ int toxav_send_video ( ToxAv* av, vpx_image_t *input) |
341 | { | 443 | { |
342 | if (vpx_codec_encode(&av->cs->v_encoder, input, av->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US) != VPX_CODEC_OK) { | 444 | if (vpx_codec_encode(&av->cs->v_encoder, input, av->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US) != VPX_CODEC_OK) { |
@@ -360,6 +462,17 @@ inline__ int toxav_send_video ( ToxAv* av, vpx_image_t *input) | |||
360 | return ErrorInternal; | 462 | return ErrorInternal; |
361 | } | 463 | } |
362 | 464 | ||
465 | /** | ||
466 | * @brief Receive decoded audio frame. | ||
467 | * | ||
468 | * @param av Handler. | ||
469 | * @param frame_size ... | ||
470 | * @param dest Destination of the packet. Make sure it has enough space for | ||
471 | * RTP_PAYLOAD_SIZE bytes. | ||
472 | * @return int | ||
473 | * @retval >=0 Size of received packet. | ||
474 | * @retval ToxAvError On error. | ||
475 | */ | ||
363 | inline__ int toxav_recv_audio ( ToxAv* av, int frame_size, int16_t* dest ) | 476 | inline__ int toxav_recv_audio ( ToxAv* av, int frame_size, int16_t* dest ) |
364 | { | 477 | { |
365 | if ( !dest ) return ErrorInternal; | 478 | if ( !dest ) return ErrorInternal; |
@@ -373,10 +486,20 @@ inline__ int toxav_recv_audio ( ToxAv* av, int frame_size, int16_t* dest ) | |||
373 | } else if ( recved_size ){ | 486 | } else if ( recved_size ){ |
374 | return opus_decode(av->cs->audio_decoder, packet, recved_size, dest, frame_size, 0); | 487 | return opus_decode(av->cs->audio_decoder, packet, recved_size, dest, frame_size, 0); |
375 | } else { | 488 | } else { |
376 | return ErrorInternal; | 489 | return 0; /* Nothing received */ |
377 | } | 490 | } |
378 | } | 491 | } |
379 | 492 | ||
493 | /** | ||
494 | * @brief Encode and send audio frame. | ||
495 | * | ||
496 | * @param av Handler. | ||
497 | * @param frame The frame. | ||
498 | * @param frame_size It's size. | ||
499 | * @return int | ||
500 | * @retval 0 Success. | ||
501 | * @retval ToxAvError On error. | ||
502 | */ | ||
380 | inline__ int toxav_send_audio ( ToxAv* av, const int16_t* frame, int frame_size) | 503 | inline__ int toxav_send_audio ( ToxAv* av, const int16_t* frame, int frame_size) |
381 | { | 504 | { |
382 | uint8_t temp_data[RTP_PAYLOAD_SIZE]; | 505 | uint8_t temp_data[RTP_PAYLOAD_SIZE]; |
@@ -387,6 +510,15 @@ inline__ int toxav_send_audio ( ToxAv* av, const int16_t* frame, int frame_size) | |||
387 | return toxav_send_rtp_payload(av, TypeAudio, temp_data, ret); | 510 | return toxav_send_rtp_payload(av, TypeAudio, temp_data, ret); |
388 | } | 511 | } |
389 | 512 | ||
513 | /** | ||
514 | * @brief Get peer transmission type. It can either be audio or video. | ||
515 | * | ||
516 | * @param av Handler. | ||
517 | * @param peer The peer | ||
518 | * @return int | ||
519 | * @retval ToxAvCallType On success. | ||
520 | * @retval ToxAvError On error. | ||
521 | */ | ||
390 | int toxav_get_peer_transmission_type ( ToxAv* av, int peer ) | 522 | int toxav_get_peer_transmission_type ( ToxAv* av, int peer ) |
391 | { | 523 | { |
392 | assert(av->msi_session); | 524 | assert(av->msi_session); |
@@ -396,6 +528,12 @@ int toxav_get_peer_transmission_type ( ToxAv* av, int peer ) | |||
396 | return av->msi_session->call->type_peer[peer]; | 528 | return av->msi_session->call->type_peer[peer]; |
397 | } | 529 | } |
398 | 530 | ||
531 | /** | ||
532 | * @brief Get reference to an object that is handling av session. | ||
533 | * | ||
534 | * @param av Handler. | ||
535 | * @return void* | ||
536 | */ | ||
399 | void* toxav_get_agent_handler ( ToxAv* av ) | 537 | void* toxav_get_agent_handler ( ToxAv* av ) |
400 | { | 538 | { |
401 | return av->agent_handler; | 539 | return av->agent_handler; |
diff --git a/toxav/toxav.h b/toxav/toxav.h index 63dbf162..4863f8eb 100644 --- a/toxav/toxav.h +++ b/toxav/toxav.h | |||
@@ -63,7 +63,7 @@ typedef struct Tox Tox; | |||
63 | 63 | ||
64 | 64 | ||
65 | /** | 65 | /** |
66 | * @brief Callbacks ids that handle the call states | 66 | * @brief Callbacks ids that handle the call states. |
67 | */ | 67 | */ |
68 | typedef enum { | 68 | typedef enum { |
69 | /* Requests */ | 69 | /* Requests */ |
@@ -94,6 +94,10 @@ typedef enum { | |||
94 | } ToxAvCallType; | 94 | } ToxAvCallType; |
95 | 95 | ||
96 | 96 | ||
97 | /** | ||
98 | * @brief Error indicators. | ||
99 | * | ||
100 | */ | ||
97 | typedef enum { | 101 | typedef enum { |
98 | ErrorNone = 0, | 102 | ErrorNone = 0, |
99 | ErrorInternal = -1, /* Internal error */ | 103 | ErrorInternal = -1, /* Internal error */ |
@@ -111,42 +115,187 @@ typedef enum { | |||
111 | } ToxAvError; | 115 | } ToxAvError; |
112 | 116 | ||
113 | 117 | ||
114 | ToxAv* toxav_new(Tox* messenger, void* useragent, const char* ua_name, uint16_t video_width, uint16_t video_height) ; | 118 | /** |
119 | * @brief Start new A/V session. There can only be one session at the time. If you register more | ||
120 | * it will result in undefined behaviour. | ||
121 | * | ||
122 | * @param messenger The messenger handle. | ||
123 | * @param useragent The agent handling A/V session (i.e. phone). | ||
124 | * @param ua_name Useragent name. | ||
125 | * @param video_width Width of video frame. | ||
126 | * @param video_height Height of video frame. | ||
127 | * @return ToxAv* | ||
128 | * @retval NULL On error. | ||
129 | */ | ||
130 | ToxAv* toxav_new(Tox* messenger, void* useragent, const char* ua_name, uint16_t video_width, uint16_t video_height); | ||
131 | |||
132 | /** | ||
133 | * @brief Remove A/V session. | ||
134 | * | ||
135 | * @param av Handler. | ||
136 | * @return void | ||
137 | */ | ||
115 | void toxav_kill(ToxAv* av); | 138 | void toxav_kill(ToxAv* av); |
116 | 139 | ||
140 | /** | ||
141 | * @brief Register callback for call state. | ||
142 | * | ||
143 | * @param callback The callback | ||
144 | * @param id One of the ToxAvCallbackID values | ||
145 | * @return void | ||
146 | */ | ||
117 | void toxav_register_callstate_callback (ToxAVCallback callback, ToxAvCallbackID id); | 147 | void toxav_register_callstate_callback (ToxAVCallback callback, ToxAvCallbackID id); |
118 | 148 | ||
119 | 149 | /** | |
150 | * @brief Call user. Use its friend_id. | ||
151 | * | ||
152 | * @param av Handler. | ||
153 | * @param user The user. | ||
154 | * @param call_type Call type. | ||
155 | * @param ringing_seconds Ringing timeout. | ||
156 | * @return int | ||
157 | * @retval 0 Success. | ||
158 | * @retval ToxAvError On error. | ||
159 | */ | ||
120 | int toxav_call(ToxAv* av, int user, ToxAvCallType call_type, int ringing_seconds); | 160 | int toxav_call(ToxAv* av, int user, ToxAvCallType call_type, int ringing_seconds); |
161 | |||
162 | /** | ||
163 | * @brief Hangup active call. | ||
164 | * | ||
165 | * @param av Handler. | ||
166 | * @return int | ||
167 | * @retval 0 Success. | ||
168 | * @retval ToxAvError On error. | ||
169 | */ | ||
121 | int toxav_hangup(ToxAv* av); | 170 | int toxav_hangup(ToxAv* av); |
171 | |||
172 | /** | ||
173 | * @brief Answer incomming call. | ||
174 | * | ||
175 | * @param av Handler. | ||
176 | * @param call_type Answer with... | ||
177 | * @return int | ||
178 | * @retval 0 Success. | ||
179 | * @retval ToxAvError On error. | ||
180 | */ | ||
122 | int toxav_answer(ToxAv* av, ToxAvCallType call_type ); | 181 | int toxav_answer(ToxAv* av, ToxAvCallType call_type ); |
182 | |||
183 | /** | ||
184 | * @brief Reject incomming call. | ||
185 | * | ||
186 | * @param av Handler. | ||
187 | * @param reason Optional reason. Set NULL if none. | ||
188 | * @return int | ||
189 | * @retval 0 Success. | ||
190 | * @retval ToxAvError On error. | ||
191 | */ | ||
123 | int toxav_reject(ToxAv* av, const char* reason); | 192 | int toxav_reject(ToxAv* av, const char* reason); |
193 | |||
194 | /** | ||
195 | * @brief Cancel outgoing request. | ||
196 | * | ||
197 | * @param av Handler. | ||
198 | * @param reason Optional reason. | ||
199 | * @return int | ||
200 | * @retval 0 Success. | ||
201 | * @retval ToxAvError On error. | ||
202 | */ | ||
124 | int toxav_cancel(ToxAv* av, const char* reason); | 203 | int toxav_cancel(ToxAv* av, const char* reason); |
204 | |||
205 | /** | ||
206 | * @brief Terminate transmission. Note that transmission will be terminated without informing remote peer. | ||
207 | * | ||
208 | * @param av Handler. | ||
209 | * @return int | ||
210 | * @retval 0 Success. | ||
211 | * @retval ToxAvError On error. | ||
212 | */ | ||
125 | int toxav_stop_call(ToxAv* av); | 213 | int toxav_stop_call(ToxAv* av); |
126 | 214 | ||
215 | /** | ||
216 | * @brief Must be call before any RTP transmission occurs. | ||
217 | * | ||
218 | * @param av Handler. | ||
219 | * @return int | ||
220 | * @retval 0 Success. | ||
221 | * @retval ToxAvError On error. | ||
222 | */ | ||
127 | int toxav_prepare_transmission(ToxAv* av); | 223 | int toxav_prepare_transmission(ToxAv* av); |
128 | int toxav_kill_transmission(ToxAv* av); | ||
129 | |||
130 | |||
131 | |||
132 | 224 | ||
133 | /* Return length of received packet. Returns 0 if nothing recved. Dest has to have | 225 | /** |
134 | * MAX_RTP_PAYLOAD_SIZE space available. Returns -1 if packet is not ready (ready < 1) for deque. | 226 | * @brief Call this at the end of the transmission. |
135 | * For video packets set 'ready' at _any_ value. | 227 | * |
228 | * @param av Handler. | ||
229 | * @return int | ||
230 | * @retval 0 Success. | ||
231 | * @retval ToxAvError On error. | ||
136 | */ | 232 | */ |
233 | int toxav_kill_transmission(ToxAv* av); | ||
137 | 234 | ||
138 | /* returns 0 on success */ | 235 | /** |
236 | * @brief Receive decoded video packet. | ||
237 | * | ||
238 | * @param av Handler. | ||
239 | * @param output Storage. | ||
240 | * @return int | ||
241 | * @retval 0 Success. | ||
242 | * @retval ToxAvError On Error. | ||
243 | */ | ||
139 | int toxav_recv_video ( ToxAv* av, vpx_image_t **output); | 244 | int toxav_recv_video ( ToxAv* av, vpx_image_t **output); |
140 | 245 | ||
246 | /** | ||
247 | * @brief Receive decoded audio frame. | ||
248 | * | ||
249 | * @param av Handler. | ||
250 | * @param frame_size ... | ||
251 | * @param dest Destination of the packet. Make sure it has enough space for | ||
252 | * RTP_PAYLOAD_SIZE bytes. | ||
253 | * @return int | ||
254 | * @retval >=0 Size of received packet. | ||
255 | * @retval ToxAvError On error. | ||
256 | */ | ||
141 | int toxav_recv_audio( ToxAv* av, int frame_size, int16_t* dest ); | 257 | int toxav_recv_audio( ToxAv* av, int frame_size, int16_t* dest ); |
142 | 258 | ||
259 | /** | ||
260 | * @brief Encode and send video packet. | ||
261 | * | ||
262 | * @param av Handler. | ||
263 | * @param input The packet. | ||
264 | * @return int | ||
265 | * @retval 0 Success. | ||
266 | * @retval ToxAvError On error. | ||
267 | */ | ||
143 | int toxav_send_video ( ToxAv* av, vpx_image_t *input); | 268 | int toxav_send_video ( ToxAv* av, vpx_image_t *input); |
144 | /* Encode and send audio frame. */ | ||
145 | int toxav_send_audio ( ToxAv* av, const int16_t* frame, int frame_size); | ||
146 | |||
147 | 269 | ||
270 | /** | ||
271 | * @brief Encode and send audio frame. | ||
272 | * | ||
273 | * @param av Handler. | ||
274 | * @param frame The frame. | ||
275 | * @param frame_size It's size. | ||
276 | * @return int | ||
277 | * @retval 0 Success. | ||
278 | * @retval ToxAvError On error. | ||
279 | */ | ||
280 | int toxav_send_audio ( ToxAv* av, const int16_t* frame, int frame_size); | ||
148 | 281 | ||
282 | /** | ||
283 | * @brief Get peer transmission type. It can either be audio or video. | ||
284 | * | ||
285 | * @param av Handler. | ||
286 | * @param peer The peer | ||
287 | * @return int | ||
288 | * @retval ToxAvCallType On success. | ||
289 | * @retval ToxAvError On error. | ||
290 | */ | ||
149 | int toxav_get_peer_transmission_type ( ToxAv* av, int peer ); | 291 | int toxav_get_peer_transmission_type ( ToxAv* av, int peer ); |
292 | |||
293 | /** | ||
294 | * @brief Get reference to an object that is handling av session. | ||
295 | * | ||
296 | * @param av Handler. | ||
297 | * @return void* | ||
298 | */ | ||
150 | void* toxav_get_agent_handler ( ToxAv* av ); | 299 | void* toxav_get_agent_handler ( ToxAv* av ); |
151 | 300 | ||
152 | #endif /* __TOXAV */ \ No newline at end of file | 301 | #endif /* __TOXAV */ \ No newline at end of file |