Merge "bridge_softmix / res_rtp_asterisk: Fix packet loss and renegotiation issues."
[asterisk/asterisk.git] / bridges / bridge_softmix.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2011, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  * David Vossel <dvossel@digium.com>
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19
20 /*! \file
21  *
22  * \brief Multi-party software based channel mixing
23  *
24  * \author Joshua Colp <jcolp@digium.com>
25  * \author David Vossel <dvossel@digium.com>
26  *
27  * \ingroup bridges
28  */
29
30 /*** MODULEINFO
31         <support_level>core</support_level>
32  ***/
33
34 #include "asterisk.h"
35
36 #include "asterisk/stream.h"
37 #include "asterisk/test.h"
38 #include "asterisk/vector.h"
39 #include "bridge_softmix/include/bridge_softmix_internal.h"
40
41 /*! The minimum sample rate of the bridge. */
42 #define SOFTMIX_MIN_SAMPLE_RATE 8000    /* 8 kHz sample rate */
43
44 /*! \brief Interval at which mixing will take place. Valid options are 10, 20, and 40. */
45 #define DEFAULT_SOFTMIX_INTERVAL 20
46
47 /*! \brief Size of the buffer used for sample manipulation */
48 #define SOFTMIX_DATALEN(rate, interval) ((rate/50) * (interval / 10))
49
50 /*! \brief Number of samples we are dealing with */
51 #define SOFTMIX_SAMPLES(rate, interval) (SOFTMIX_DATALEN(rate, interval) / 2)
52
53 /*! \brief Number of mixing iterations to perform between gathering statistics. */
54 #define SOFTMIX_STAT_INTERVAL 100
55
56 /* This is the threshold in ms at which a channel's own audio will stop getting
57  * mixed out its own write audio stream because it is not talking. */
58 #define DEFAULT_SOFTMIX_SILENCE_THRESHOLD 2500
59 #define DEFAULT_SOFTMIX_TALKING_THRESHOLD 160
60
61 #define SOFTBRIDGE_VIDEO_DEST_PREFIX "softbridge_dest"
62 #define SOFTBRIDGE_VIDEO_DEST_LEN strlen(SOFTBRIDGE_VIDEO_DEST_PREFIX)
63 #define SOFTBRIDGE_VIDEO_DEST_SEPARATOR '_'
64
65 struct softmix_stats {
66         /*! Each index represents a sample rate used above the internal rate. */
67         unsigned int sample_rates[16];
68         /*! Each index represents the number of channels using the same index in the sample_rates array.  */
69         unsigned int num_channels[16];
70         /*! The number of channels above the internal sample rate */
71         unsigned int num_above_internal_rate;
72         /*! The number of channels at the internal sample rate */
73         unsigned int num_at_internal_rate;
74         /*! The absolute highest sample rate preferred by any channel in the bridge */
75         unsigned int highest_supported_rate;
76         /*! Is the sample rate locked by the bridge, if so what is that rate.*/
77         unsigned int locked_rate;
78 };
79
80 struct softmix_translate_helper_entry {
81         int num_times_requested; /*!< Once this entry is no longer requested, free the trans_pvt
82                                       and re-init if it was usable. */
83         struct ast_format *dst_format; /*!< The destination format for this helper */
84         struct ast_trans_pvt *trans_pvt; /*!< the translator for this slot. */
85         struct ast_frame *out_frame; /*!< The output frame from the last translation */
86         AST_LIST_ENTRY(softmix_translate_helper_entry) entry;
87 };
88
89 struct softmix_translate_helper {
90         struct ast_format *slin_src; /*!< the source format expected for all the translators */
91         AST_LIST_HEAD_NOLOCK(, softmix_translate_helper_entry) entries;
92 };
93
94 static struct softmix_translate_helper_entry *softmix_translate_helper_entry_alloc(struct ast_format *dst)
95 {
96         struct softmix_translate_helper_entry *entry;
97         if (!(entry = ast_calloc(1, sizeof(*entry)))) {
98                 return NULL;
99         }
100         entry->dst_format = ao2_bump(dst);
101         /* initialize this to one so that the first time through the cleanup code after
102            allocation it won't be removed from the entry list */
103         entry->num_times_requested = 1;
104         return entry;
105 }
106
107 static void *softmix_translate_helper_free_entry(struct softmix_translate_helper_entry *entry)
108 {
109         ao2_cleanup(entry->dst_format);
110
111         if (entry->trans_pvt) {
112                 ast_translator_free_path(entry->trans_pvt);
113         }
114         if (entry->out_frame) {
115                 ast_frfree(entry->out_frame);
116         }
117         ast_free(entry);
118         return NULL;
119 }
120
121 static void softmix_translate_helper_init(struct softmix_translate_helper *trans_helper, unsigned int sample_rate)
122 {
123         memset(trans_helper, 0, sizeof(*trans_helper));
124         trans_helper->slin_src = ast_format_cache_get_slin_by_rate(sample_rate);
125 }
126
127 static void softmix_translate_helper_destroy(struct softmix_translate_helper *trans_helper)
128 {
129         struct softmix_translate_helper_entry *entry;
130
131         while ((entry = AST_LIST_REMOVE_HEAD(&trans_helper->entries, entry))) {
132                 softmix_translate_helper_free_entry(entry);
133         }
134 }
135
136 static void softmix_translate_helper_change_rate(struct softmix_translate_helper *trans_helper, unsigned int sample_rate)
137 {
138         struct softmix_translate_helper_entry *entry;
139
140         trans_helper->slin_src = ast_format_cache_get_slin_by_rate(sample_rate);
141         AST_LIST_TRAVERSE_SAFE_BEGIN(&trans_helper->entries, entry, entry) {
142                 if (entry->trans_pvt) {
143                         ast_translator_free_path(entry->trans_pvt);
144                         if (!(entry->trans_pvt = ast_translator_build_path(entry->dst_format, trans_helper->slin_src))) {
145                                 AST_LIST_REMOVE_CURRENT(entry);
146                                 entry = softmix_translate_helper_free_entry(entry);
147                         }
148                 }
149         }
150         AST_LIST_TRAVERSE_SAFE_END;
151 }
152
153 /*!
154  * \internal
155  * \brief Get the next available audio on the softmix channel's read stream
156  * and determine if it should be mixed out or not on the write stream.
157  *
158  * \retval pointer to buffer containing the exact number of samples requested on success.
159  * \retval NULL if no samples are present
160  */
161 static int16_t *softmix_process_read_audio(struct softmix_channel *sc, unsigned int num_samples)
162 {
163         if ((ast_slinfactory_available(&sc->factory) >= num_samples) &&
164                 ast_slinfactory_read(&sc->factory, sc->our_buf, num_samples)) {
165                 sc->have_audio = 1;
166                 return sc->our_buf;
167         }
168         sc->have_audio = 0;
169         return NULL;
170 }
171
172 /*!
173  * \internal
174  * \brief Process a softmix channel's write audio
175  *
176  * \details This function will remove the channel's talking from its own audio if present and
177  * possibly even do the channel's write translation for it depending on how many other
178  * channels use the same write format.
179  */
180 static void softmix_process_write_audio(struct softmix_translate_helper *trans_helper,
181         struct ast_format *raw_write_fmt,
182         struct softmix_channel *sc, unsigned int default_sample_size)
183 {
184         struct softmix_translate_helper_entry *entry = NULL;
185         int i;
186
187         /* If we provided audio that was not determined to be silence,
188          * then take it out while in slinear format. */
189         if (sc->have_audio && sc->talking && !sc->binaural) {
190                 for (i = 0; i < sc->write_frame.samples; i++) {
191                         ast_slinear_saturated_subtract(&sc->final_buf[i], &sc->our_buf[i]);
192                 }
193                 /* check to see if any entries exist for the format. if not we'll want
194                    to remove it during cleanup */
195                 AST_LIST_TRAVERSE(&trans_helper->entries, entry, entry) {
196                         if (ast_format_cmp(entry->dst_format, raw_write_fmt) == AST_FORMAT_CMP_EQUAL) {
197                                 ++entry->num_times_requested;
198                                 break;
199                         }
200                 }
201                 /* do not do any special write translate optimization if we had to make
202                  * a special mix for them to remove their own audio. */
203                 return;
204         } else if (sc->have_audio && sc->talking && sc->binaural > 0) {
205                 /*
206                  * Binaural audio requires special saturated substract since we have two
207                  * audio signals per channel now.
208                  */
209                 softmix_process_write_binaural_audio(sc, default_sample_size);
210                 return;
211         }
212
213         /* Attempt to optimize channels using the same translation path/codec. Build a list of entries
214            of translation paths and track the number of references for each type. Each one of the same
215            type should be able to use the same out_frame. Since the optimization is only necessary for
216            multiple channels (>=2) using the same codec make sure resources are allocated only when
217            needed and released when not (see also softmix_translate_helper_cleanup */
218         AST_LIST_TRAVERSE(&trans_helper->entries, entry, entry) {
219                 if (sc->binaural != 0) {
220                         continue;
221                 }
222                 if (ast_format_cmp(entry->dst_format, raw_write_fmt) == AST_FORMAT_CMP_EQUAL) {
223                         entry->num_times_requested++;
224                 } else {
225                         continue;
226                 }
227                 if (!entry->trans_pvt && (entry->num_times_requested > 1)) {
228                         entry->trans_pvt = ast_translator_build_path(entry->dst_format, trans_helper->slin_src);
229                 }
230                 if (entry->trans_pvt && !entry->out_frame) {
231                         entry->out_frame = ast_translate(entry->trans_pvt, &sc->write_frame, 0);
232                 }
233                 if (entry->out_frame && entry->out_frame->frametype == AST_FRAME_VOICE
234                                 && entry->out_frame->datalen < MAX_DATALEN) {
235                         ao2_replace(sc->write_frame.subclass.format, entry->out_frame->subclass.format);
236                         memcpy(sc->final_buf, entry->out_frame->data.ptr, entry->out_frame->datalen);
237                         sc->write_frame.datalen = entry->out_frame->datalen;
238                         sc->write_frame.samples = entry->out_frame->samples;
239                 }
240                 break;
241         }
242
243         /* add new entry into list if this format destination was not matched. */
244         if (!entry && (entry = softmix_translate_helper_entry_alloc(raw_write_fmt))) {
245                 AST_LIST_INSERT_HEAD(&trans_helper->entries, entry, entry);
246         }
247 }
248
249 static void softmix_translate_helper_cleanup(struct softmix_translate_helper *trans_helper)
250 {
251         struct softmix_translate_helper_entry *entry;
252
253         AST_LIST_TRAVERSE_SAFE_BEGIN(&trans_helper->entries, entry, entry) {
254                 /* if it hasn't been requested then remove it */
255                 if (!entry->num_times_requested) {
256                         AST_LIST_REMOVE_CURRENT(entry);
257                         softmix_translate_helper_free_entry(entry);
258                         continue;
259                 }
260
261                 if (entry->out_frame) {
262                         ast_frfree(entry->out_frame);
263                         entry->out_frame = NULL;
264                 }
265
266                 /* nothing is optimized for a single path reference, so there is
267                    no reason to continue to hold onto the codec */
268                 if (entry->num_times_requested == 1 && entry->trans_pvt) {
269                         ast_translator_free_path(entry->trans_pvt);
270                         entry->trans_pvt = NULL;
271                 }
272
273                 /* for each iteration (a mixing run) in the bridge softmix thread the number
274                    of references to a given entry is recalculated, so reset the number of
275                    times requested */
276                 entry->num_times_requested = 0;
277         }
278         AST_LIST_TRAVERSE_SAFE_END;
279 }
280
281 static void set_softmix_bridge_data(int rate, int interval, struct ast_bridge_channel *bridge_channel, int reset, int set_binaural, int binaural_pos_id, int is_announcement)
282 {
283         struct softmix_channel *sc = bridge_channel->tech_pvt;
284         struct ast_format *slin_format;
285         int setup_fail;
286
287 #ifdef BINAURAL_RENDERING
288         if (interval != BINAURAL_MIXING_INTERVAL) {
289                 interval = BINAURAL_MIXING_INTERVAL;
290         }
291 #endif
292
293         /* The callers have already ensured that sc is never NULL. */
294         ast_assert(sc != NULL);
295
296         slin_format = ast_format_cache_get_slin_by_rate(rate);
297
298         ast_mutex_lock(&sc->lock);
299         if (reset) {
300                 ast_slinfactory_destroy(&sc->factory);
301                 ast_dsp_free(sc->dsp);
302         }
303
304         /* Setup write frame parameters */
305         sc->write_frame.frametype = AST_FRAME_VOICE;
306         /*
307          * NOTE: The write_frame format holds a reference because translation
308          * could be needed and the format changed to the translated format
309          * for the channel.  The translated format may not be a
310          * static cached format.
311          */
312         ao2_replace(sc->write_frame.subclass.format, slin_format);
313         sc->write_frame.data.ptr = sc->final_buf;
314         sc->write_frame.datalen = SOFTMIX_DATALEN(rate, interval);
315         sc->write_frame.samples = SOFTMIX_SAMPLES(rate, interval);
316
317         /* We will store the rate here cause we need to set the data again when a channel is unsuspended */
318         sc->rate = rate;
319
320         /* If the channel will contain binaural data we will set a identifier in the channel
321          * if set_binaural == -1 this is just a sample rate update, will ignore it. */
322         if (set_binaural == 1) {
323                 sc->binaural = 1;
324         } else if (set_binaural == 0) {
325                 sc->binaural = 0;
326         }
327
328         /* Setting the binaural position. This doesn't require a change of the overlaying channel infos
329          * and doesn't have to be done if we just updating sample rates. */
330         if (binaural_pos_id != -1) {
331                 sc->binaural_pos = binaural_pos_id;
332         }
333         if (is_announcement != -1) {
334                 sc->is_announcement = is_announcement;
335         }
336
337         /*
338          * NOTE: The read_slin_format does not hold a reference because it
339          * will always be a signed linear format.
340          */
341         sc->read_slin_format = slin_format;
342
343         /* Setup smoother */
344         setup_fail = ast_slinfactory_init_with_format(&sc->factory, slin_format);
345
346         /* set new read and write formats on channel. */
347         ast_channel_lock(bridge_channel->chan);
348         setup_fail |= ast_set_read_format_path(bridge_channel->chan,
349                 ast_channel_rawreadformat(bridge_channel->chan), slin_format);
350         ast_channel_unlock(bridge_channel->chan);
351
352         /* If channel contains binaural data we will set it here for the trans_pvt. */
353         if (set_binaural == 1 || (set_binaural == -1 && sc->binaural == 1)) {
354                 setup_fail |= ast_set_write_format_interleaved_stereo(bridge_channel->chan, slin_format);
355         } else if (set_binaural == 0) {
356                 setup_fail |= ast_set_write_format(bridge_channel->chan, slin_format);
357         }
358
359         /* set up new DSP.  This is on the read side only right before the read frame enters the smoother.  */
360         sc->dsp = ast_dsp_new_with_rate(rate);
361         if (setup_fail || !sc->dsp) {
362                 /* Bad news.  Could not setup the channel for softmix. */
363                 ast_mutex_unlock(&sc->lock);
364                 ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, 0);
365                 return;
366         }
367
368         /* we want to aggressively detect silence to avoid feedback */
369         if (bridge_channel->tech_args.talking_threshold) {
370                 ast_dsp_set_threshold(sc->dsp, bridge_channel->tech_args.talking_threshold);
371         } else {
372                 ast_dsp_set_threshold(sc->dsp, DEFAULT_SOFTMIX_TALKING_THRESHOLD);
373         }
374
375         ast_mutex_unlock(&sc->lock);
376 }
377
378 /*!
379  * \internal
380  * \brief Poke the mixing thread in case it is waiting for an active channel.
381  * \since 12.0.0
382  *
383  * \param softmix_data Bridge mixing data.
384  *
385  * \return Nothing
386  */
387 static void softmix_poke_thread(struct softmix_bridge_data *softmix_data)
388 {
389         ast_mutex_lock(&softmix_data->lock);
390         ast_cond_signal(&softmix_data->cond);
391         ast_mutex_unlock(&softmix_data->lock);
392 }
393
394 /*! \brief Function called when a channel is unsuspended from the bridge */
395 static void softmix_bridge_unsuspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
396 {
397 #ifdef BINAURAL_RENDERING
398         struct softmix_channel *sc = bridge_channel->tech_pvt;
399         if (sc->binaural) {
400                 /* Restore some usefull data if it was a binaural channel */
401                 struct ast_format *slin_format;
402
403                 slin_format = ast_format_cache_get_slin_by_rate(sc->rate);
404                 ast_set_write_format_interleaved_stereo(bridge_channel->chan, slin_format);
405         }
406 #endif
407         if (bridge->tech_pvt) {
408                 softmix_poke_thread(bridge->tech_pvt);
409         }
410 }
411
412 /*!
413  * \brief Determine if a stream is a video source stream.
414  *
415  * \param stream The stream to test
416  * \retval 1 The stream is a video source
417  * \retval 0 The stream is not a video source
418  */
419 static int is_video_source(const struct ast_stream *stream)
420 {
421         if (ast_stream_get_type(stream) == AST_MEDIA_TYPE_VIDEO &&
422                 strncmp(ast_stream_get_name(stream), SOFTBRIDGE_VIDEO_DEST_PREFIX,
423                         SOFTBRIDGE_VIDEO_DEST_LEN)) {
424                 return 1;
425         }
426
427         return 0;
428 }
429
430 /*!
431  * \brief Determine if a stream is a video destination stream.
432  *
433  * A source channel name can be provided to narrow this to a destination stream
434  * for a particular source channel. Further, a source stream name can be provided
435  * to narrow this to a particular source stream's destination. However, empty strings
436  * can be provided to match any destination video stream, regardless of source channel
437  * or source stream.
438  *
439  * \param stream The stream to test
440  * \param source_channel_name The name of a source video channel to match
441  * \param source_stream_name The name of the source video stream to match
442  * \retval 1 The stream is a video destination stream
443  * \retval 0 The stream is not a video destination stream
444  */
445 static int is_video_dest(const struct ast_stream *stream, const char *source_channel_name,
446         const char *source_stream_name)
447 {
448         char *dest_video_name;
449         size_t dest_video_name_len;
450
451         if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_VIDEO) {
452                 return 0;
453         }
454
455         dest_video_name_len = SOFTBRIDGE_VIDEO_DEST_LEN + 1;
456
457         if (!ast_strlen_zero(source_channel_name)) {
458                 dest_video_name_len += strlen(source_channel_name) + 1;
459                 if (!ast_strlen_zero(source_stream_name)) {
460                         dest_video_name_len += strlen(source_stream_name) + 1;
461                 }
462         }
463         dest_video_name = ast_alloca(dest_video_name_len);
464
465         if (!ast_strlen_zero(source_channel_name)) {
466                 if (!ast_strlen_zero(source_stream_name)) {
467                         snprintf(dest_video_name, dest_video_name_len, "%s%c%s%c%s",
468                                 SOFTBRIDGE_VIDEO_DEST_PREFIX, SOFTBRIDGE_VIDEO_DEST_SEPARATOR,
469                                 source_channel_name, SOFTBRIDGE_VIDEO_DEST_SEPARATOR,
470                                 source_stream_name);
471                         return !strcmp(ast_stream_get_name(stream), dest_video_name);
472                 } else {
473                         snprintf(dest_video_name, dest_video_name_len, "%s%c%s",
474                                 SOFTBRIDGE_VIDEO_DEST_PREFIX, SOFTBRIDGE_VIDEO_DEST_SEPARATOR,
475                                 source_channel_name);
476                         return !strncmp(ast_stream_get_name(stream), dest_video_name, dest_video_name_len - 1);
477                 }
478         } else {
479                 snprintf(dest_video_name, dest_video_name_len, "%s",
480                         SOFTBRIDGE_VIDEO_DEST_PREFIX);
481                 return !strncmp(ast_stream_get_name(stream), dest_video_name, dest_video_name_len - 1);
482         }
483
484         return 0;
485 }
486
487 static int append_source_streams(struct ast_stream_topology *dest,
488         const char *channel_name,
489         const struct ast_stream_topology *source)
490 {
491         int i;
492
493         for (i = 0; i < ast_stream_topology_get_count(source); ++i) {
494                 struct ast_stream *stream;
495                 struct ast_stream *stream_clone;
496                 char *stream_clone_name;
497                 size_t stream_clone_name_len;
498
499                 stream = ast_stream_topology_get_stream(source, i);
500                 if (!is_video_source(stream)) {
501                         continue;
502                 }
503
504                 /* The +3 is for the two underscore separators and null terminator */
505                 stream_clone_name_len = SOFTBRIDGE_VIDEO_DEST_LEN + strlen(channel_name) + strlen(ast_stream_get_name(stream)) + 3;
506                 stream_clone_name = ast_alloca(stream_clone_name_len);
507                 snprintf(stream_clone_name, stream_clone_name_len, "%s_%s_%s", SOFTBRIDGE_VIDEO_DEST_PREFIX,
508                         channel_name, ast_stream_get_name(stream));
509
510                 stream_clone = ast_stream_clone(stream, stream_clone_name);
511                 if (!stream_clone) {
512                         return -1;
513                 }
514                 if (ast_stream_topology_append_stream(dest, stream_clone) < 0) {
515                         ast_stream_free(stream_clone);
516                         return -1;
517                 }
518         }
519
520         return 0;
521 }
522
523 static int append_all_streams(struct ast_stream_topology *dest,
524         const struct ast_stream_topology *source)
525 {
526         int i;
527         int dest_index = 0;
528
529         for (i = 0; i < ast_stream_topology_get_count(source); ++i) {
530                 struct ast_stream *clone;
531                 int added = 0;
532
533                 clone = ast_stream_clone(ast_stream_topology_get_stream(source, i), NULL);
534                 if (!clone) {
535                         return -1;
536                 }
537
538                 /* If we can reuse an existing removed stream then do so */
539                 while (dest_index < ast_stream_topology_get_count(dest)) {
540                         struct ast_stream *stream = ast_stream_topology_get_stream(dest, dest_index);
541
542                         dest_index++;
543
544                         if (ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
545                                 ast_stream_topology_set_stream(dest, dest_index - 1, clone);
546                                 added = 1;
547                                 break;
548                         }
549                 }
550
551                 /* If no removed stream exists that we took the place of append the stream */
552                 if (!added && ast_stream_topology_append_stream(dest, clone) < 0) {
553                         ast_stream_free(clone);
554                         return -1;
555                 }
556         }
557
558         return 0;
559 }
560
561 /*!
562  * \brief Issue channel stream topology change requests.
563  *
564  * When in SFU mode, each participant needs to be able to
565  * send video directly to other participants in the bridge.
566  * This means that all participants need to have their topologies
567  * updated. The joiner needs to have destination streams for
568  * all current participants, and the current participants need
569  * to have destinations streams added for the joiner's sources.
570  *
571  * \param joiner The channel that is joining the softmix bridge
572  * \param participants The current participants in the softmix bridge
573  */
574 static void sfu_topologies_on_join(struct ast_bridge_channel *joiner, struct ast_bridge_channels_list *participants)
575 {
576         struct ast_stream_topology *joiner_topology = NULL;
577         struct ast_stream_topology *joiner_video = NULL;
578         struct ast_stream_topology *existing_video = NULL;
579         struct ast_bridge_channel *participant;
580
581         joiner_video = ast_stream_topology_alloc();
582         if (!joiner_video) {
583                 return;
584         }
585
586         if (append_source_streams(joiner_video, ast_channel_name(joiner->chan), ast_channel_get_stream_topology(joiner->chan))) {
587                 goto cleanup;
588         }
589
590         existing_video = ast_stream_topology_alloc();
591         if (!existing_video) {
592                 goto cleanup;
593         }
594
595         AST_LIST_TRAVERSE(participants, participant, entry) {
596                 if (participant == joiner) {
597                         continue;
598                 }
599                 if (append_source_streams(existing_video, ast_channel_name(participant->chan),
600                                 ast_channel_get_stream_topology(participant->chan))) {
601                         goto cleanup;
602                 }
603         }
604
605         joiner_topology = ast_stream_topology_clone(ast_channel_get_stream_topology(joiner->chan));
606         if (!joiner_topology) {
607                 goto cleanup;
608         }
609         if (append_all_streams(joiner_topology, existing_video)) {
610                 goto cleanup;
611         }
612         ast_channel_request_stream_topology_change(joiner->chan, joiner_topology, NULL);
613
614         AST_LIST_TRAVERSE(participants, participant, entry) {
615                 struct ast_stream_topology *participant_topology;
616
617                 if (participant == joiner) {
618                         continue;
619                 }
620                 participant_topology = ast_stream_topology_clone(ast_channel_get_stream_topology(participant->chan));
621                 if (!participant_topology) {
622                         goto cleanup;
623                 }
624                 if (append_all_streams(participant_topology, joiner_video)) {
625                         ast_stream_topology_free(participant_topology);
626                         goto cleanup;
627                 }
628                 ast_channel_request_stream_topology_change(participant->chan, participant_topology, NULL);
629                 ast_stream_topology_free(participant_topology);
630         }
631
632 cleanup:
633         ast_stream_topology_free(joiner_video);
634         ast_stream_topology_free(existing_video);
635         ast_stream_topology_free(joiner_topology);
636 }
637
638 /*! \brief Function called when a channel is joined into the bridge */
639 static int softmix_bridge_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
640 {
641         struct softmix_channel *sc;
642         struct softmix_bridge_data *softmix_data;
643         int set_binaural = 0;
644         /*
645          * If false, the channel will be convolved, but since it is a non stereo channel, output
646          * will be mono.
647          */
648         int skip_binaural_output = 1;
649         int pos_id;
650         int is_announcement = 0;
651         int samplerate_change;
652
653         softmix_data = bridge->tech_pvt;
654         if (!softmix_data) {
655                 return -1;
656         }
657
658         /* Create a new softmix_channel structure and allocate various things on it */
659         if (!(sc = ast_calloc(1, sizeof(*sc)))) {
660                 return -1;
661         }
662
663         samplerate_change = softmix_data->internal_rate;
664         pos_id = -1;
665         if (bridge->softmix.binaural_active) {
666                 if (strncmp(ast_channel_name(bridge_channel->chan), "CBAnn", 5) != 0) {
667                         set_binaural = ast_format_get_channel_count(bridge_channel->write_format) > 1 ? 1 : 0;
668                         if (set_binaural) {
669                                 softmix_data->internal_rate = samplerate_change;
670                         }
671                         skip_binaural_output = 0;
672                 } else {
673                         is_announcement = 1;
674                 }
675                 if (set_binaural) {
676                         softmix_data->convolve.binaural_active = 1;
677                 }
678                 if (!skip_binaural_output)      {
679                         pos_id = set_binaural_data_join(&softmix_data->convolve, softmix_data->default_sample_size);
680                         if (pos_id == -1) {
681                                 ast_log(LOG_ERROR, "Bridge %s: Failed to join channel %s. "
682                                                 "Could not allocate enough memory.\n", bridge->uniqueid,
683                                                 ast_channel_name(bridge_channel->chan));
684                                 return -1;
685                         }
686                 }
687         }
688
689         /* Can't forget the lock */
690         ast_mutex_init(&sc->lock);
691
692         /* Can't forget to record our pvt structure within the bridged channel structure */
693         bridge_channel->tech_pvt = sc;
694
695         set_softmix_bridge_data(softmix_data->internal_rate,
696                 softmix_data->internal_mixing_interval
697                         ? softmix_data->internal_mixing_interval
698                         : DEFAULT_SOFTMIX_INTERVAL,
699                 bridge_channel, 0, set_binaural, pos_id, is_announcement);
700
701         if (bridge->softmix.video_mode.mode == AST_BRIDGE_VIDEO_MODE_SFU) {
702                 sfu_topologies_on_join(bridge_channel, &bridge->channels);
703         }
704
705         softmix_poke_thread(softmix_data);
706         return 0;
707 }
708
709 static int remove_destination_streams(struct ast_stream_topology *dest,
710         const char *channel_name,
711         const struct ast_stream_topology *source)
712 {
713         int i;
714
715         for (i = 0; i < ast_stream_topology_get_count(source); ++i) {
716                 struct ast_stream *stream;
717                 struct ast_stream *stream_clone;
718
719                 stream = ast_stream_topology_get_stream(source, i);
720
721                 stream_clone = ast_stream_clone(stream, NULL);
722                 if (!stream_clone) {
723                         continue;
724                 }
725
726                 if (is_video_dest(stream, channel_name, NULL)) {
727                         ast_stream_set_state(stream_clone, AST_STREAM_STATE_REMOVED);
728                 }
729
730                 if (ast_stream_topology_append_stream(dest, stream_clone) < 0) {
731                         ast_stream_free(stream_clone);
732                 }
733         }
734
735         return 0;
736 }
737
738 static int sfu_topologies_on_leave(struct ast_bridge_channel *leaver, struct ast_bridge_channels_list *participants)
739 {
740         struct ast_stream_topology *leaver_topology;
741         struct ast_bridge_channel *participant;
742
743         leaver_topology = ast_stream_topology_alloc();
744         if (!leaver_topology) {
745                 return -1;
746         }
747
748         AST_LIST_TRAVERSE(participants, participant, entry) {
749                 struct ast_stream_topology *participant_topology;
750
751                 participant_topology = ast_stream_topology_alloc();
752                 if (!participant_topology) {
753                         continue;
754                 }
755
756                 remove_destination_streams(participant_topology, ast_channel_name(leaver->chan), ast_channel_get_stream_topology(participant->chan));
757                 ast_channel_request_stream_topology_change(participant->chan, participant_topology, NULL);
758                 ast_stream_topology_free(participant_topology);
759         }
760
761         remove_destination_streams(leaver_topology, "", ast_channel_get_stream_topology(leaver->chan));
762         ast_channel_request_stream_topology_change(leaver->chan, leaver_topology, NULL);
763         ast_stream_topology_free(leaver_topology);
764
765         return 0;
766 }
767
768 /*! \brief Function called when a channel leaves the bridge */
769 static void softmix_bridge_leave(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
770 {
771         struct softmix_channel *sc;
772         struct softmix_bridge_data *softmix_data;
773         softmix_data = bridge->tech_pvt;
774         sc = bridge_channel->tech_pvt;
775
776         if (bridge->softmix.video_mode.mode == AST_BRIDGE_VIDEO_MODE_SFU) {
777                 sfu_topologies_on_leave(bridge_channel, &bridge->channels);
778         }
779
780         if (!sc) {
781                 return;
782         }
783
784         if (bridge->softmix.binaural_active) {
785                 if (sc->binaural) {
786                         set_binaural_data_leave(&softmix_data->convolve, sc->binaural_pos,
787                                         softmix_data->default_sample_size);
788                 }
789         }
790
791         bridge_channel->tech_pvt = NULL;
792
793         /* Drop mutex lock */
794         ast_mutex_destroy(&sc->lock);
795
796         /* Drop the factory */
797         ast_slinfactory_destroy(&sc->factory);
798
799         /* Drop any formats on the frames */
800         ao2_cleanup(sc->write_frame.subclass.format);
801
802         /* Drop the DSP */
803         ast_dsp_free(sc->dsp);
804
805         /* Eep! drop ourselves */
806         ast_free(sc);
807 }
808
809 static void softmix_pass_video_top_priority(struct ast_bridge *bridge, struct ast_frame *frame)
810 {
811         struct ast_bridge_channel *cur;
812
813         AST_LIST_TRAVERSE(&bridge->channels, cur, entry) {
814                 if (cur->suspended) {
815                         continue;
816                 }
817                 if (ast_bridge_is_video_src(bridge, cur->chan) == 1) {
818                         ast_bridge_channel_queue_frame(cur, frame);
819                         break;
820                 }
821         }
822 }
823
824 /*!
825  * \internal
826  * \brief Determine what to do with a video frame.
827  * \since 12.0.0
828  *
829  * \param bridge Which bridge is getting the frame
830  * \param bridge_channel Which channel is writing the frame.
831  * \param frame What is being written.
832  *
833  * \return Nothing
834  */
835 static void softmix_bridge_write_video(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
836 {
837         struct softmix_channel *sc;
838         int video_src_priority;
839
840         /* Determine if the video frame should be distributed or not */
841         switch (bridge->softmix.video_mode.mode) {
842         case AST_BRIDGE_VIDEO_MODE_NONE:
843                 break;
844         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
845                 video_src_priority = ast_bridge_is_video_src(bridge, bridge_channel->chan);
846                 if (video_src_priority == 1) {
847                         /* Pass to me and everyone else. */
848                         ast_bridge_queue_everyone_else(bridge, NULL, frame);
849                 }
850                 break;
851         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
852                 sc = bridge_channel->tech_pvt;
853                 ast_mutex_lock(&sc->lock);
854                 ast_bridge_update_talker_src_video_mode(bridge, bridge_channel->chan,
855                         sc->video_talker.energy_average,
856                         frame->subclass.frame_ending);
857                 ast_mutex_unlock(&sc->lock);
858                 video_src_priority = ast_bridge_is_video_src(bridge, bridge_channel->chan);
859                 if (video_src_priority == 1) {
860                         int num_src = ast_bridge_number_video_src(bridge);
861                         int echo = num_src > 1 ? 0 : 1;
862
863                         ast_bridge_queue_everyone_else(bridge, echo ? NULL : bridge_channel, frame);
864                 } else if (video_src_priority == 2) {
865                         softmix_pass_video_top_priority(bridge, frame);
866                 }
867                 break;
868         case AST_BRIDGE_VIDEO_MODE_SFU:
869                 /* Nothing special to do here, the bridge channel stream map will ensure the
870                  * video goes everywhere it needs to
871                  */
872                 ast_bridge_queue_everyone_else(bridge, bridge_channel, frame);
873                 break;
874         }
875 }
876
877 /*!
878  * \internal
879  * \brief Determine what to do with a voice frame.
880  * \since 12.0.0
881  *
882  * \param bridge Which bridge is getting the frame
883  * \param bridge_channel Which channel is writing the frame.
884  * \param frame What is being written.
885  *
886  * \return Nothing
887  */
888 static void softmix_bridge_write_voice(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
889 {
890         struct softmix_channel *sc = bridge_channel->tech_pvt;
891         struct softmix_bridge_data *softmix_data = bridge->tech_pvt;
892         int totalsilence = 0;
893         int cur_energy = 0;
894         int silence_threshold = bridge_channel->tech_args.silence_threshold ?
895                 bridge_channel->tech_args.silence_threshold :
896                 DEFAULT_SOFTMIX_SILENCE_THRESHOLD;
897         char update_talking = -1;  /* if this is set to 0 or 1, tell the bridge that the channel has started or stopped talking. */
898
899         /* Write the frame into the conference */
900         ast_mutex_lock(&sc->lock);
901
902         if (ast_format_cmp(frame->subclass.format, sc->read_slin_format) != AST_FORMAT_CMP_EQUAL) {
903                 /*
904                  * The incoming frame is not the expected format.  Update
905                  * the channel's translation path to get us slinear from
906                  * the new format for the next frame.
907                  *
908                  * There is the possibility that this frame is an old slinear
909                  * rate frame that was in flight when the softmix bridge
910                  * changed rates.  If so it will self correct on subsequent
911                  * frames.
912                  */
913                 ast_channel_lock(bridge_channel->chan);
914                 ast_debug(1, "Channel %s wrote unexpected format into bridge.  Got %s, expected %s.\n",
915                         ast_channel_name(bridge_channel->chan),
916                         ast_format_get_name(frame->subclass.format),
917                         ast_format_get_name(sc->read_slin_format));
918                 ast_set_read_format_path(bridge_channel->chan, frame->subclass.format,
919                         sc->read_slin_format);
920                 ast_channel_unlock(bridge_channel->chan);
921         }
922
923         /* The channel will be leaving soon if there is no dsp. */
924         if (sc->dsp) {
925                 ast_dsp_silence_with_energy(sc->dsp, frame, &totalsilence, &cur_energy);
926         }
927
928         if (bridge->softmix.video_mode.mode == AST_BRIDGE_VIDEO_MODE_TALKER_SRC) {
929                 int cur_slot = sc->video_talker.energy_history_cur_slot;
930
931                 sc->video_talker.energy_accum -= sc->video_talker.energy_history[cur_slot];
932                 sc->video_talker.energy_accum += cur_energy;
933                 sc->video_talker.energy_history[cur_slot] = cur_energy;
934                 sc->video_talker.energy_average = sc->video_talker.energy_accum / DEFAULT_ENERGY_HISTORY_LEN;
935                 sc->video_talker.energy_history_cur_slot++;
936                 if (sc->video_talker.energy_history_cur_slot == DEFAULT_ENERGY_HISTORY_LEN) {
937                         sc->video_talker.energy_history_cur_slot = 0; /* wrap around */
938                 }
939         }
940
941         if (totalsilence < silence_threshold) {
942                 if (!sc->talking) {
943                         update_talking = 1;
944                 }
945                 sc->talking = 1; /* tell the write process we have audio to be mixed out */
946         } else {
947                 if (sc->talking) {
948                         update_talking = 0;
949                 }
950                 sc->talking = 0;
951         }
952
953         /* Before adding audio in, make sure we haven't fallen behind. If audio has fallen
954          * behind 4 times the amount of samples mixed on every iteration of the mixer, Re-sync
955          * the audio by flushing the buffer before adding new audio in. */
956         if (ast_slinfactory_available(&sc->factory) > (4 * SOFTMIX_SAMPLES(softmix_data->internal_rate, softmix_data->internal_mixing_interval))) {
957                 ast_slinfactory_flush(&sc->factory);
958         }
959
960         /* If a frame was provided add it to the smoother, unless drop silence is enabled and this frame
961          * is not determined to be talking. */
962         if (!(bridge_channel->tech_args.drop_silence && !sc->talking)) {
963                 ast_slinfactory_feed(&sc->factory, frame);
964         }
965
966         /* Alllll done */
967         ast_mutex_unlock(&sc->lock);
968
969         if (update_talking != -1) {
970                 ast_bridge_channel_notify_talking(bridge_channel, update_talking);
971         }
972 }
973
974 /*!
975  * \internal
976  * \brief Determine what to do with a control frame.
977  * \since 12.0.0
978  *
979  * \param bridge Which bridge is getting the frame
980  * \param bridge_channel Which channel is writing the frame.
981  * \param frame What is being written.
982  *
983  * \retval 0 Frame accepted into the bridge.
984  * \retval -1 Frame needs to be deferred.
985  */
986 static int softmix_bridge_write_control(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
987 {
988         struct softmix_bridge_data *softmix_data = bridge->tech_pvt;
989
990         /*
991          * XXX Softmix needs to use channel roles to determine what to
992          * do with control frames.
993          */
994
995         switch (frame->subclass.integer) {
996         case AST_CONTROL_VIDUPDATE:
997                 if (!bridge->softmix.video_mode.video_update_discard ||
998                         ast_tvdiff_ms(ast_tvnow(), softmix_data->last_video_update) > bridge->softmix.video_mode.video_update_discard) {
999                         ast_bridge_queue_everyone_else(bridge, NULL, frame);
1000                         softmix_data->last_video_update = ast_tvnow();
1001                 }
1002                 break;
1003         default:
1004                 break;
1005         }
1006
1007         return 0;
1008 }
1009
1010 /*!
1011  * \internal
1012  * \brief Determine what to do with a frame written into the bridge.
1013  * \since 12.0.0
1014  *
1015  * \param bridge Which bridge is getting the frame
1016  * \param bridge_channel Which channel is writing the frame.
1017  * \param frame What is being written.
1018  *
1019  * \retval 0 Frame accepted into the bridge.
1020  * \retval -1 Frame needs to be deferred.
1021  *
1022  * \note On entry, bridge is already locked.
1023  */
1024 static int softmix_bridge_write(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
1025 {
1026         int res = 0;
1027
1028         if (!bridge->tech_pvt || !bridge_channel || !bridge_channel->tech_pvt) {
1029                 /* "Accept" the frame and discard it. */
1030                 return 0;
1031         }
1032
1033         /*
1034          * XXX Softmix needs to use channel roles to determine who gets
1035          * what frame.  Possible roles: announcer, recorder, agent,
1036          * supervisor.
1037          */
1038         switch (frame->frametype) {
1039         case AST_FRAME_NULL:
1040                 /* "Accept" the frame and discard it. */
1041                 break;
1042         case AST_FRAME_DTMF_BEGIN:
1043         case AST_FRAME_DTMF_END:
1044                 res = ast_bridge_queue_everyone_else(bridge, bridge_channel, frame);
1045                 break;
1046         case AST_FRAME_VOICE:
1047                 if (bridge_channel) {
1048                         softmix_bridge_write_voice(bridge, bridge_channel, frame);
1049                 }
1050                 break;
1051         case AST_FRAME_VIDEO:
1052                 if (bridge_channel) {
1053                         softmix_bridge_write_video(bridge, bridge_channel, frame);
1054                 }
1055                 break;
1056         case AST_FRAME_CONTROL:
1057                 res = softmix_bridge_write_control(bridge, bridge_channel, frame);
1058                 break;
1059         case AST_FRAME_BRIDGE_ACTION:
1060                 res = ast_bridge_queue_everyone_else(bridge, bridge_channel, frame);
1061                 break;
1062         case AST_FRAME_BRIDGE_ACTION_SYNC:
1063                 ast_log(LOG_ERROR, "Synchronous bridge action written to a softmix bridge.\n");
1064                 ast_assert(0);
1065         default:
1066                 ast_debug(3, "Frame type %u unsupported\n", frame->frametype);
1067                 /* "Accept" the frame and discard it. */
1068                 break;
1069         }
1070
1071         return res;
1072 }
1073
1074 static void gather_softmix_stats(struct softmix_stats *stats,
1075         const struct softmix_bridge_data *softmix_data,
1076         struct ast_bridge_channel *bridge_channel)
1077 {
1078         int channel_native_rate;
1079
1080         /* Gather stats about channel sample rates. */
1081         ast_channel_lock(bridge_channel->chan);
1082         channel_native_rate = MAX(SOFTMIX_MIN_SAMPLE_RATE,
1083                 ast_format_get_sample_rate(ast_channel_rawreadformat(bridge_channel->chan)));
1084         ast_channel_unlock(bridge_channel->chan);
1085
1086         if (stats->highest_supported_rate < channel_native_rate) {
1087                 stats->highest_supported_rate = channel_native_rate;
1088         }
1089         if (softmix_data->internal_rate < channel_native_rate) {
1090                 int i;
1091
1092                 for (i = 0; i < ARRAY_LEN(stats->sample_rates); i++) {
1093                         if (stats->sample_rates[i] == channel_native_rate) {
1094                                 stats->num_channels[i]++;
1095                                 break;
1096                         } else if (!stats->sample_rates[i]) {
1097                                 stats->sample_rates[i] = channel_native_rate;
1098                                 stats->num_channels[i]++;
1099                                 break;
1100                         }
1101                 }
1102                 stats->num_above_internal_rate++;
1103         } else if (softmix_data->internal_rate == channel_native_rate) {
1104                 stats->num_at_internal_rate++;
1105         }
1106 }
1107
1108 /*!
1109  * \internal
1110  * \brief Analyse mixing statistics and change bridges internal rate
1111  * if necessary.
1112  *
1113  * \retval 0, no changes to internal rate
1114  * \retval 1, internal rate was changed, update all the channels on the next mixing iteration.
1115  */
1116 static unsigned int analyse_softmix_stats(struct softmix_stats *stats,
1117                 struct softmix_bridge_data *softmix_data, int binaural_active)
1118 {
1119         int i;
1120
1121         if (binaural_active) {
1122                 stats->locked_rate = SOFTMIX_BINAURAL_SAMPLE_RATE;
1123         }
1124
1125         /*
1126          * Re-adjust the internal bridge sample rate if
1127          * 1. The bridge's internal sample rate is locked in at a sample
1128          *    rate other than the current sample rate being used.
1129          * 2. two or more channels support a higher sample rate
1130          * 3. no channels support the current sample rate or a higher rate
1131          */
1132         if (stats->locked_rate) {
1133                 /* if the rate is locked by the bridge, only update it if it differs
1134                  * from the current rate we are using. */
1135                 if (softmix_data->internal_rate != stats->locked_rate) {
1136                         ast_debug(1, "Locking at new rate.  Bridge changed from %u to %u.\n",
1137                                 softmix_data->internal_rate, stats->locked_rate);
1138                         softmix_data->internal_rate = stats->locked_rate;
1139                         return 1;
1140                 }
1141         } else if (stats->num_above_internal_rate >= 2) {
1142                 /* the highest rate is just used as a starting point */
1143                 unsigned int best_rate = stats->highest_supported_rate;
1144                 int best_index = -1;
1145
1146                 for (i = 0; i < ARRAY_LEN(stats->num_channels); i++) {
1147                         if (stats->num_channels[i]) {
1148                                 break;
1149                         }
1150                         if (2 <= stats->num_channels[i]) {
1151                                 /* Two or more channels support this rate. */
1152                                 if (best_index == -1
1153                                         || stats->sample_rates[best_index] < stats->sample_rates[i]) {
1154                                         /*
1155                                          * best_rate starts out being the first sample rate
1156                                          * greater than the internal sample rate that two or
1157                                          * more channels support.
1158                                          *
1159                                          * or
1160                                          *
1161                                          * There are multiple rates above the internal rate
1162                                          * and this rate is higher than the previous rate two
1163                                          * or more channels support.
1164                                          */
1165                                         best_rate = stats->sample_rates[i];
1166                                         best_index = i;
1167                                 }
1168                         } else if (best_index == -1) {
1169                                 /*
1170                                  * It is possible that multiple channels exist with native sample
1171                                  * rates above the internal sample rate, but none of those channels
1172                                  * have the same rate in common.  In this case, the lowest sample
1173                                  * rate among those channels is picked. Over time as additional
1174                                  * statistic runs are made the internal sample rate number will
1175                                  * adjust to the most optimal sample rate, but it may take multiple
1176                                  * iterations.
1177                                  */
1178                                 best_rate = MIN(best_rate, stats->sample_rates[i]);
1179                         }
1180                 }
1181
1182                 ast_debug(1, "Multiple above internal rate.  Bridge changed from %u to %u.\n",
1183                         softmix_data->internal_rate, best_rate);
1184                 softmix_data->internal_rate = best_rate;
1185                 return 1;
1186         } else if (!stats->num_at_internal_rate && !stats->num_above_internal_rate) {
1187                 /* In this case, the highest supported rate is actually lower than the internal rate */
1188                 ast_debug(1, "All below internal rate.  Bridge changed from %u to %u.\n",
1189                         softmix_data->internal_rate, stats->highest_supported_rate);
1190                 softmix_data->internal_rate = stats->highest_supported_rate;
1191                 return 1;
1192         }
1193         return 0;
1194 }
1195
1196 static int softmix_mixing_array_init(struct softmix_mixing_array *mixing_array,
1197                 unsigned int starting_num_entries, unsigned int binaural_active)
1198 {
1199         memset(mixing_array, 0, sizeof(*mixing_array));
1200         mixing_array->max_num_entries = starting_num_entries;
1201         if (!(mixing_array->buffers = ast_calloc(mixing_array->max_num_entries, sizeof(int16_t *)))) {
1202                 ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure.\n");
1203                 return -1;
1204         }
1205         if (binaural_active) {
1206                 if (!(mixing_array->chan_pairs = ast_calloc(mixing_array->max_num_entries,
1207                                 sizeof(struct convolve_channel_pair *)))) {
1208                         ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure.\n");
1209                         return -1;
1210                 }
1211         }
1212         return 0;
1213 }
1214
1215 static void softmix_mixing_array_destroy(struct softmix_mixing_array *mixing_array,
1216                 unsigned int binaural_active)
1217 {
1218         ast_free(mixing_array->buffers);
1219         if (binaural_active) {
1220                 ast_free(mixing_array->chan_pairs);
1221         }
1222 }
1223
1224 static int softmix_mixing_array_grow(struct softmix_mixing_array *mixing_array,
1225                 unsigned int num_entries, unsigned int binaural_active)
1226 {
1227         int16_t **tmp;
1228
1229         /* give it some room to grow since memory is cheap but allocations can be expensive */
1230         mixing_array->max_num_entries = num_entries;
1231         if (!(tmp = ast_realloc(mixing_array->buffers, (mixing_array->max_num_entries * sizeof(int16_t *))))) {
1232                 ast_log(LOG_NOTICE, "Failed to re-allocate softmix mixing structure.\n");
1233                 return -1;
1234         }
1235         if (binaural_active) {
1236                 struct convolve_channel_pair **tmp2;
1237                 if (!(tmp2 = ast_realloc(mixing_array->chan_pairs,
1238                                 (mixing_array->max_num_entries * sizeof(struct convolve_channel_pair *))))) {
1239                         ast_log(LOG_NOTICE, "Failed to re-allocate softmix mixing structure.\n");
1240                         return -1;
1241                 }
1242                 mixing_array->chan_pairs = tmp2;
1243         }
1244         mixing_array->buffers = tmp;
1245         return 0;
1246 }
1247
1248 /*!
1249  * \brief Mixing loop.
1250  *
1251  * \retval 0 on success
1252  * \retval -1 on failure
1253  */
1254 static int softmix_mixing_loop(struct ast_bridge *bridge)
1255 {
1256         struct softmix_stats stats = { { 0 }, };
1257         struct softmix_mixing_array mixing_array;
1258         struct softmix_bridge_data *softmix_data = bridge->tech_pvt;
1259         struct ast_timer *timer;
1260         struct softmix_translate_helper trans_helper;
1261         int16_t buf[MAX_DATALEN];
1262 #ifdef BINAURAL_RENDERING
1263         int16_t bin_buf[MAX_DATALEN];
1264         int16_t ann_buf[MAX_DATALEN];
1265 #endif
1266         unsigned int stat_iteration_counter = 0; /* counts down, gather stats at zero and reset. */
1267         int timingfd;
1268         int update_all_rates = 0; /* set this when the internal sample rate has changed */
1269         unsigned int idx;
1270         unsigned int x;
1271         int res = -1;
1272
1273         timer = softmix_data->timer;
1274         timingfd = ast_timer_fd(timer);
1275         softmix_translate_helper_init(&trans_helper, softmix_data->internal_rate);
1276         ast_timer_set_rate(timer, (1000 / softmix_data->internal_mixing_interval));
1277
1278         /* Give the mixing array room to grow, memory is cheap but allocations are expensive. */
1279         if (softmix_mixing_array_init(&mixing_array, bridge->num_channels + 10,
1280                         bridge->softmix.binaural_active)) {
1281                 goto softmix_cleanup;
1282         }
1283
1284         /*
1285          * XXX Softmix needs to use channel roles to determine who gets
1286          * what audio mixed.
1287          */
1288         while (!softmix_data->stop && bridge->num_active) {
1289                 struct ast_bridge_channel *bridge_channel;
1290                 int timeout = -1;
1291                 struct ast_format *cur_slin = ast_format_cache_get_slin_by_rate(softmix_data->internal_rate);
1292                 unsigned int softmix_samples = SOFTMIX_SAMPLES(softmix_data->internal_rate, softmix_data->internal_mixing_interval);
1293                 unsigned int softmix_datalen = SOFTMIX_DATALEN(softmix_data->internal_rate, softmix_data->internal_mixing_interval);
1294
1295                 if (softmix_datalen > MAX_DATALEN) {
1296                         /* This should NEVER happen, but if it does we need to know about it. Almost
1297                          * all the memcpys used during this process depend on this assumption.  Rather
1298                          * than checking this over and over again through out the code, this single
1299                          * verification is done on each iteration. */
1300                         ast_log(LOG_WARNING,
1301                                 "Bridge %s: Conference mixing error, requested mixing length greater than mixing buffer.\n",
1302                                 bridge->uniqueid);
1303                         goto softmix_cleanup;
1304                 }
1305
1306                 /* Grow the mixing array buffer as participants are added. */
1307                 if (mixing_array.max_num_entries < bridge->num_channels
1308                         && softmix_mixing_array_grow(&mixing_array, bridge->num_channels + 5,
1309                                         bridge->softmix.binaural_active)) {
1310                         goto softmix_cleanup;
1311                 }
1312
1313                 /* init the number of buffers stored in the mixing array to 0.
1314                  * As buffers are added for mixing, this number is incremented. */
1315                 mixing_array.used_entries = 0;
1316
1317                 /* These variables help determine if a rate change is required */
1318                 if (!stat_iteration_counter) {
1319                         memset(&stats, 0, sizeof(stats));
1320                         stats.locked_rate = bridge->softmix.internal_sample_rate;
1321                 }
1322
1323                 /* If the sample rate has changed, update the translator helper */
1324                 if (update_all_rates) {
1325                         softmix_translate_helper_change_rate(&trans_helper, softmix_data->internal_rate);
1326                 }
1327
1328 #ifdef BINAURAL_RENDERING
1329                 check_binaural_position_change(bridge, softmix_data, bridge_channel);
1330 #endif
1331
1332                 /* Go through pulling audio from each factory that has it available */
1333                 AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1334                         struct softmix_channel *sc = bridge_channel->tech_pvt;
1335
1336                         if (!sc) {
1337                                 /* This channel failed to join successfully. */
1338                                 continue;
1339                         }
1340
1341                         /* Update the sample rate to match the bridge's native sample rate if necessary. */
1342                         if (update_all_rates) {
1343                                 set_softmix_bridge_data(softmix_data->internal_rate,
1344                                                 softmix_data->internal_mixing_interval, bridge_channel, 1, -1, -1, -1);
1345                         }
1346
1347                         /* If stat_iteration_counter is 0, then collect statistics during this mixing interation */
1348                         if (!stat_iteration_counter) {
1349                                 gather_softmix_stats(&stats, softmix_data, bridge_channel);
1350                         }
1351
1352                         /* if the channel is suspended, don't check for audio, but still gather stats */
1353                         if (bridge_channel->suspended) {
1354                                 continue;
1355                         }
1356
1357                         /* Try to get audio from the factory if available */
1358                         ast_mutex_lock(&sc->lock);
1359                         if ((mixing_array.buffers[mixing_array.used_entries] = softmix_process_read_audio(sc, softmix_samples))) {
1360 #ifdef BINAURAL_RENDERING
1361                                 add_binaural_mixing(bridge, softmix_data, softmix_samples, &mixing_array, sc,
1362                                                 ast_channel_name(bridge_channel->chan));
1363 #endif
1364                                 mixing_array.used_entries++;
1365                         }
1366                         ast_mutex_unlock(&sc->lock);
1367                 }
1368
1369                 /* mix it like crazy (non binaural channels)*/
1370                 memset(buf, 0, softmix_datalen);
1371                 for (idx = 0; idx < mixing_array.used_entries; ++idx) {
1372                         for (x = 0; x < softmix_samples; ++x) {
1373                                 ast_slinear_saturated_add(buf + x, mixing_array.buffers[idx] + x);
1374                         }
1375                 }
1376
1377 #ifdef BINAURAL_RENDERING
1378                 binaural_mixing(bridge, softmix_data, &mixing_array, bin_buf, ann_buf);
1379 #endif
1380
1381                 /* Next step go through removing the channel's own audio and creating a good frame... */
1382                 AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1383                         struct softmix_channel *sc = bridge_channel->tech_pvt;
1384
1385                         if (!sc || bridge_channel->suspended) {
1386                                 /* This channel failed to join successfully or is suspended. */
1387                                 continue;
1388                         }
1389
1390                         ast_mutex_lock(&sc->lock);
1391
1392                         /* Make SLINEAR write frame from local buffer */
1393                         ao2_t_replace(sc->write_frame.subclass.format, cur_slin,
1394                                 "Replace softmix channel slin format");
1395 #ifdef BINAURAL_RENDERING
1396                         if (bridge->softmix.binaural_active && softmix_data->convolve.binaural_active
1397                                         && sc->binaural) {
1398                                 create_binaural_frame(bridge_channel, sc, bin_buf, ann_buf, softmix_datalen,
1399                                                 softmix_samples, buf);
1400                         } else
1401 #endif
1402                         {
1403                                 sc->write_frame.datalen = softmix_datalen;
1404                                 sc->write_frame.samples = softmix_samples;
1405                                 memcpy(sc->final_buf, buf, softmix_datalen);
1406                         }
1407                         /* process the softmix channel's new write audio */
1408                         softmix_process_write_audio(&trans_helper,
1409                                         ast_channel_rawwriteformat(bridge_channel->chan), sc,
1410                                         softmix_data->default_sample_size);
1411
1412                         ast_mutex_unlock(&sc->lock);
1413
1414                         /* A frame is now ready for the channel. */
1415                         ast_bridge_channel_queue_frame(bridge_channel, &sc->write_frame);
1416                 }
1417
1418                 update_all_rates = 0;
1419                 if (!stat_iteration_counter) {
1420                         update_all_rates = analyse_softmix_stats(&stats, softmix_data,
1421                                         bridge->softmix.binaural_active);
1422                         stat_iteration_counter = SOFTMIX_STAT_INTERVAL;
1423                 }
1424                 stat_iteration_counter--;
1425
1426                 ast_bridge_unlock(bridge);
1427                 /* cleanup any translation frame data from the previous mixing iteration. */
1428                 softmix_translate_helper_cleanup(&trans_helper);
1429                 /* Wait for the timing source to tell us to wake up and get things done */
1430                 ast_waitfor_n_fd(&timingfd, 1, &timeout, NULL);
1431                 if (ast_timer_ack(timer, 1) < 0) {
1432                         ast_log(LOG_ERROR, "Bridge %s: Failed to acknowledge timer in softmix.\n",
1433                                 bridge->uniqueid);
1434                         ast_bridge_lock(bridge);
1435                         goto softmix_cleanup;
1436                 }
1437                 ast_bridge_lock(bridge);
1438
1439                 /* make sure to detect mixing interval changes if they occur. */
1440                 if (bridge->softmix.internal_mixing_interval
1441                         && (bridge->softmix.internal_mixing_interval != softmix_data->internal_mixing_interval)) {
1442                         softmix_data->internal_mixing_interval = bridge->softmix.internal_mixing_interval;
1443                         ast_timer_set_rate(timer, (1000 / softmix_data->internal_mixing_interval));
1444                         update_all_rates = 1; /* if the interval changes, the rates must be adjusted as well just to be notified new interval.*/
1445                 }
1446         }
1447
1448         res = 0;
1449
1450 softmix_cleanup:
1451         softmix_translate_helper_destroy(&trans_helper);
1452         softmix_mixing_array_destroy(&mixing_array, bridge->softmix.binaural_active);
1453         return res;
1454 }
1455
1456 /*!
1457  * \internal
1458  * \brief Mixing thread.
1459  * \since 12.0.0
1460  *
1461  * \note The thread does not have its own reference to the
1462  * bridge.  The lifetime of the thread is tied to the lifetime
1463  * of the mixing technology association with the bridge.
1464  */
1465 static void *softmix_mixing_thread(void *data)
1466 {
1467         struct softmix_bridge_data *softmix_data = data;
1468         struct ast_bridge *bridge = softmix_data->bridge;
1469
1470         ast_bridge_lock(bridge);
1471         if (bridge->callid) {
1472                 ast_callid_threadassoc_add(bridge->callid);
1473         }
1474
1475         ast_debug(1, "Bridge %s: starting mixing thread\n", bridge->uniqueid);
1476
1477         while (!softmix_data->stop) {
1478                 if (!bridge->num_active) {
1479                         /* Wait for something to happen to the bridge. */
1480                         ast_bridge_unlock(bridge);
1481                         ast_mutex_lock(&softmix_data->lock);
1482                         if (!softmix_data->stop) {
1483                                 ast_cond_wait(&softmix_data->cond, &softmix_data->lock);
1484                         }
1485                         ast_mutex_unlock(&softmix_data->lock);
1486                         ast_bridge_lock(bridge);
1487                         continue;
1488                 }
1489
1490                 if (bridge->softmix.binaural_active && !softmix_data->binaural_init) {
1491 #ifndef BINAURAL_RENDERING
1492                         ast_bridge_lock(bridge);
1493                         bridge->softmix.binaural_active = 0;
1494                         ast_bridge_unlock(bridge);
1495                         ast_log(LOG_WARNING, "Bridge: %s: Binaural rendering active by config but not "
1496                                         "compiled.\n", bridge->uniqueid);
1497 #else
1498                         /* Set and init binaural data if binaural is activated in the configuration. */
1499                         softmix_data->internal_rate = SOFTMIX_BINAURAL_SAMPLE_RATE;
1500                         softmix_data->default_sample_size = SOFTMIX_SAMPLES(softmix_data->internal_rate,
1501                                         softmix_data->internal_mixing_interval);
1502                         /* If init for binaural processing fails we will fall back to mono audio processing. */
1503                         if (init_convolve_data(&softmix_data->convolve, softmix_data->default_sample_size)
1504                                         == -1) {
1505                                 ast_bridge_lock(bridge);
1506                                 bridge->softmix.binaural_active = 0;
1507                                 ast_bridge_unlock(bridge);
1508                                 ast_log(LOG_ERROR, "Bridge: %s: Unable to allocate memory for "
1509                                                 "binaural processing,  Will only process mono audio.\n",
1510                                                 bridge->uniqueid);
1511                         }
1512                         softmix_data->binaural_init = 1;
1513 #endif
1514                 }
1515
1516                 if (softmix_mixing_loop(bridge)) {
1517                         /*
1518                          * A mixing error occurred.  Sleep and try again later so we
1519                          * won't flood the logs.
1520                          */
1521                         ast_bridge_unlock(bridge);
1522                         sleep(1);
1523                         ast_bridge_lock(bridge);
1524                 }
1525         }
1526
1527         ast_bridge_unlock(bridge);
1528
1529         ast_debug(1, "Bridge %s: stopping mixing thread\n", bridge->uniqueid);
1530
1531         return NULL;
1532 }
1533
1534 static void softmix_bridge_data_destroy(struct softmix_bridge_data *softmix_data)
1535 {
1536         if (softmix_data->timer) {
1537                 ast_timer_close(softmix_data->timer);
1538                 softmix_data->timer = NULL;
1539         }
1540         ast_mutex_destroy(&softmix_data->lock);
1541         ast_cond_destroy(&softmix_data->cond);
1542         ast_free(softmix_data);
1543 }
1544
1545 /*! \brief Function called when a bridge is created */
1546 static int softmix_bridge_create(struct ast_bridge *bridge)
1547 {
1548         struct softmix_bridge_data *softmix_data;
1549
1550         softmix_data = ast_calloc(1, sizeof(*softmix_data));
1551         if (!softmix_data) {
1552                 return -1;
1553         }
1554         softmix_data->bridge = bridge;
1555         ast_mutex_init(&softmix_data->lock);
1556         ast_cond_init(&softmix_data->cond, NULL);
1557         softmix_data->timer = ast_timer_open();
1558         if (!softmix_data->timer) {
1559                 ast_log(AST_LOG_WARNING, "Failed to open timer for softmix bridge\n");
1560                 softmix_bridge_data_destroy(softmix_data);
1561                 return -1;
1562         }
1563         /* start at minimum rate, let it grow from there */
1564         softmix_data->internal_rate = SOFTMIX_MIN_SAMPLE_RATE;
1565         softmix_data->internal_mixing_interval = DEFAULT_SOFTMIX_INTERVAL;
1566
1567 #ifdef BINAURAL_RENDERING
1568         softmix_data->default_sample_size = SOFTMIX_SAMPLES(softmix_data->internal_rate,
1569                         softmix_data->internal_mixing_interval);
1570 #endif
1571
1572         bridge->tech_pvt = softmix_data;
1573
1574         /* Start the mixing thread. */
1575         if (ast_pthread_create(&softmix_data->thread, NULL, softmix_mixing_thread,
1576                 softmix_data)) {
1577                 softmix_data->thread = AST_PTHREADT_NULL;
1578                 softmix_bridge_data_destroy(softmix_data);
1579                 bridge->tech_pvt = NULL;
1580                 return -1;
1581         }
1582
1583         return 0;
1584 }
1585
1586 /*!
1587  * \internal
1588  * \brief Request the softmix mixing thread stop.
1589  * \since 12.0.0
1590  *
1591  * \param bridge Which bridge is being stopped.
1592  *
1593  * \return Nothing
1594  */
1595 static void softmix_bridge_stop(struct ast_bridge *bridge)
1596 {
1597         struct softmix_bridge_data *softmix_data;
1598
1599         softmix_data = bridge->tech_pvt;
1600         if (!softmix_data) {
1601                 return;
1602         }
1603
1604         ast_mutex_lock(&softmix_data->lock);
1605         softmix_data->stop = 1;
1606         ast_mutex_unlock(&softmix_data->lock);
1607 }
1608
1609 /*! \brief Function called when a bridge is destroyed */
1610 static void softmix_bridge_destroy(struct ast_bridge *bridge)
1611 {
1612         struct softmix_bridge_data *softmix_data;
1613         pthread_t thread;
1614
1615         softmix_data = bridge->tech_pvt;
1616         if (!softmix_data) {
1617                 return;
1618         }
1619
1620         /* Stop the mixing thread. */
1621         ast_mutex_lock(&softmix_data->lock);
1622         softmix_data->stop = 1;
1623         ast_cond_signal(&softmix_data->cond);
1624         thread = softmix_data->thread;
1625         softmix_data->thread = AST_PTHREADT_NULL;
1626         ast_mutex_unlock(&softmix_data->lock);
1627         if (thread != AST_PTHREADT_NULL) {
1628                 ast_debug(1, "Bridge %s: Waiting for mixing thread to die.\n", bridge->uniqueid);
1629                 pthread_join(thread, NULL);
1630         }
1631 #ifdef BINAURAL_RENDERING
1632         free_convolve_data(&softmix_data->convolve);
1633 #endif
1634         softmix_bridge_data_destroy(softmix_data);
1635         bridge->tech_pvt = NULL;
1636 }
1637
1638 /*!
1639  * \brief Map a source stream to all of its destination streams.
1640  *
1641  * \param source_stream_name Name of the source stream
1642  * \param source_channel_name Name of channel where the source stream originates
1643  * \param bridge_stream_position The slot in the bridge where source video will come from
1644  * \param participants The bridge_channels in the bridge
1645  */
1646 static void map_source_to_destinations(const char *source_stream_name, const char *source_channel_name,
1647         size_t bridge_stream_position, struct ast_bridge_channels_list *participants)
1648 {
1649         struct ast_bridge_channel *participant;
1650
1651         AST_LIST_TRAVERSE(participants, participant, entry) {
1652                 int i;
1653                 struct ast_stream_topology *topology;
1654
1655                 if (!strcmp(source_channel_name, ast_channel_name(participant->chan))) {
1656                         continue;
1657                 }
1658
1659                 ast_bridge_channel_lock(participant);
1660                 topology = ast_channel_get_stream_topology(participant->chan);
1661
1662                 for (i = 0; i < ast_stream_topology_get_count(topology); ++i) {
1663                         struct ast_stream *stream;
1664
1665                         stream = ast_stream_topology_get_stream(topology, i);
1666                         if (is_video_dest(stream, source_channel_name, source_stream_name)) {
1667                                 AST_VECTOR_REPLACE(&participant->stream_map.to_channel, bridge_stream_position, i);
1668                                 break;
1669                         }
1670                 }
1671                 ast_bridge_channel_unlock(participant);
1672         }
1673 }
1674
1675 /*\brief stream_topology_changed callback
1676  *
1677  * For most video modes, nothing beyond the ordinary is required.
1678  * For the SFU case, though, we need to completely remap the streams
1679  * in order to ensure video gets directed where it is expected to go.
1680  *
1681  * \param bridge The bridge
1682  * \param bridge_channel Channel whose topology has changed
1683  */
1684 static void softmix_bridge_stream_topology_changed(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
1685 {
1686         struct ast_bridge_channel *participant;
1687         struct ast_vector_int media_types;
1688         int nths[AST_MEDIA_TYPE_END] = {0};
1689
1690         switch (bridge->softmix.video_mode.mode) {
1691         case AST_BRIDGE_VIDEO_MODE_NONE:
1692         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
1693         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
1694         default:
1695                 ast_bridge_channel_stream_map(bridge_channel);
1696                 return;
1697         case AST_BRIDGE_VIDEO_MODE_SFU:
1698                 break;
1699         }
1700
1701         AST_VECTOR_INIT(&media_types, AST_MEDIA_TYPE_END);
1702
1703         /* First traversal: re-initialize all of the participants' stream maps */
1704         AST_LIST_TRAVERSE(&bridge->channels, participant, entry) {
1705                 int size;
1706
1707                 ast_bridge_channel_lock(participant);
1708                 size = ast_stream_topology_get_count(ast_channel_get_stream_topology(participant->chan));
1709
1710                 AST_VECTOR_FREE(&participant->stream_map.to_channel);
1711                 AST_VECTOR_FREE(&participant->stream_map.to_bridge);
1712
1713                 AST_VECTOR_INIT(&participant->stream_map.to_channel, size);
1714                 AST_VECTOR_INIT(&participant->stream_map.to_bridge, size);
1715                 ast_bridge_channel_unlock(participant);
1716         }
1717
1718         /* Second traversal: Map specific video channels from their source to their destinations.
1719          *
1720          * This is similar to what is done in ast_stream_topology_map(), except that
1721          * video channels are handled differently. Each video source has it's own
1722          * unique index on the bridge. this way, a particular channel's source video
1723          * can be distributed to the appropriate destination streams on the other
1724          * channels
1725          */
1726         AST_LIST_TRAVERSE(&bridge->channels, participant, entry) {
1727                 int i;
1728                 struct ast_stream_topology *topology;
1729
1730                 topology = ast_channel_get_stream_topology(participant->chan);
1731
1732                 for (i = 0; i < ast_stream_topology_get_count(topology); ++i) {
1733                         struct ast_stream *stream = ast_stream_topology_get_stream(topology, i);
1734                         ast_bridge_channel_lock(participant);
1735                         if (is_video_source(stream)) {
1736                                 AST_VECTOR_APPEND(&media_types, AST_MEDIA_TYPE_VIDEO);
1737                                 AST_VECTOR_REPLACE(&participant->stream_map.to_bridge, i, AST_VECTOR_SIZE(&media_types) - 1);
1738                                 AST_VECTOR_REPLACE(&participant->stream_map.to_channel, AST_VECTOR_SIZE(&media_types) - 1, -1);
1739                                 /* Unlock the participant to prevent potential deadlock
1740                                  * in map_source_to_destinations
1741                                  */
1742                                 ast_bridge_channel_unlock(participant);
1743                                 map_source_to_destinations(ast_stream_get_name(stream), ast_channel_name(participant->chan),
1744                                         AST_VECTOR_SIZE(&media_types) - 1, &bridge->channels);
1745                                 ast_bridge_channel_lock(participant);
1746                         } else if (is_video_dest(stream, NULL, NULL)) {
1747                                 /* We expect to never read media from video destination channels, but just
1748                                  * in case, we should set their to_bridge value to -1.
1749                                  */
1750                                 AST_VECTOR_REPLACE(&participant->stream_map.to_bridge, i, -1);
1751                         } else {
1752                                 /* XXX This is copied from ast_stream_topology_map(). This likely could
1753                                  * be factored out in some way
1754                                  */
1755                                 enum ast_media_type type = ast_stream_get_type(stream);
1756                                 int index = AST_VECTOR_GET_INDEX_NTH(&media_types, ++nths[type],
1757                                         type, AST_VECTOR_ELEM_DEFAULT_CMP);
1758
1759                                 if (index == -1) {
1760                                         AST_VECTOR_APPEND(&media_types, type);
1761                                         index = AST_VECTOR_SIZE(&media_types) - 1;
1762                                 }
1763
1764                                 AST_VECTOR_REPLACE(&participant->stream_map.to_bridge, i, index);
1765                                 AST_VECTOR_REPLACE(&participant->stream_map.to_channel, index, i);
1766                         }
1767                         ast_bridge_channel_unlock(participant);
1768                 }
1769         }
1770 }
1771
1772 static struct ast_bridge_technology softmix_bridge = {
1773         .name = "softmix",
1774         .capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX,
1775         .preference = AST_BRIDGE_PREFERENCE_BASE_MULTIMIX,
1776         .create = softmix_bridge_create,
1777         .stop = softmix_bridge_stop,
1778         .destroy = softmix_bridge_destroy,
1779         .join = softmix_bridge_join,
1780         .leave = softmix_bridge_leave,
1781         .unsuspend = softmix_bridge_unsuspend,
1782         .write = softmix_bridge_write,
1783         .stream_topology_changed = softmix_bridge_stream_topology_changed,
1784 };
1785
1786 #ifdef TEST_FRAMEWORK
1787 struct stream_parameters {
1788         const char *name;
1789         const char *formats;
1790         enum ast_media_type type;
1791 };
1792
1793 static struct ast_stream_topology *build_topology(const struct stream_parameters *params, size_t num_streams)
1794 {
1795         struct ast_stream_topology *topology;
1796         size_t i;
1797
1798         topology = ast_stream_topology_alloc();
1799         if (!topology) {
1800                 return NULL;
1801         }
1802
1803         for (i = 0; i < num_streams; ++i) {
1804                 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
1805                 struct ast_stream *stream;
1806
1807                 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1808                 if (!caps) {
1809                         goto fail;
1810                 }
1811                 if (ast_format_cap_update_by_allow_disallow(caps, params[i].formats, 1) < 0) {
1812                         goto fail;
1813                 }
1814                 stream = ast_stream_alloc(params[i].name, params[i].type);
1815                 if (!stream) {
1816                         goto fail;
1817                 }
1818                 ast_stream_set_formats(stream, caps);
1819                 if (ast_stream_topology_append_stream(topology, stream) < 0) {
1820                         ast_stream_free(stream);
1821                         goto fail;
1822                 }
1823         }
1824
1825         return topology;
1826
1827 fail:
1828         ast_stream_topology_free(topology);
1829         return NULL;
1830 }
1831
1832 static int validate_stream(struct ast_test *test, struct ast_stream *stream,
1833         const struct stream_parameters *params)
1834 {
1835         struct ast_format_cap *stream_caps;
1836         struct ast_format_cap *params_caps;
1837
1838         if (ast_stream_get_type(stream) != params->type) {
1839                 ast_test_status_update(test, "Expected stream type '%s' but got type '%s'\n",
1840                         ast_codec_media_type2str(params->type),
1841                         ast_codec_media_type2str(ast_stream_get_type(stream)));
1842                 return -1;
1843         }
1844         if (strcmp(ast_stream_get_name(stream), params->name)) {
1845                 ast_test_status_update(test, "Expected stream name '%s' but got type '%s'\n",
1846                         params->name, ast_stream_get_name(stream));
1847                 return -1;
1848         }
1849
1850         stream_caps = ast_stream_get_formats(stream);
1851         params_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1852         if (!params_caps) {
1853                 ast_test_status_update(test, "Allocation error on capabilities\n");
1854                 return -1;
1855         }
1856         ast_format_cap_update_by_allow_disallow(params_caps, params->formats, 1);
1857
1858         if (ast_format_cap_identical(stream_caps, params_caps)) {
1859                 ast_test_status_update(test, "Formats are not as expected on stream '%s'\n",
1860                         ast_stream_get_name(stream));
1861                 ao2_cleanup(params_caps);
1862                 return -1;
1863         }
1864
1865         ao2_cleanup(params_caps);
1866         return 0;
1867 }
1868
1869 static int validate_original_streams(struct ast_test *test, struct ast_stream_topology *topology,
1870         const struct stream_parameters *params, size_t num_streams)
1871 {
1872         int i;
1873
1874         if (ast_stream_topology_get_count(topology) < num_streams) {
1875                 ast_test_status_update(test, "Topology only has %d streams. Needs to have at least %zu\n",
1876                         ast_stream_topology_get_count(topology), num_streams);
1877                 return -1;
1878         }
1879
1880         for (i = 0; i < ARRAY_LEN(params); ++i) {
1881                 if (validate_stream(test, ast_stream_topology_get_stream(topology, i), &params[i])) {
1882                         return -1;
1883                 }
1884         }
1885
1886         return 0;
1887 }
1888
1889 AST_TEST_DEFINE(sfu_append_source_streams)
1890 {
1891         enum ast_test_result_state res = AST_TEST_FAIL;
1892         static const struct stream_parameters bob_streams[] = {
1893                 { "bob_audio", "ulaw,alaw,g722,opus", AST_MEDIA_TYPE_AUDIO, },
1894                 { "bob_video", "h264,vp8", AST_MEDIA_TYPE_VIDEO, },
1895         };
1896         static const struct stream_parameters alice_streams[] = {
1897                 { "alice_audio", "ulaw,opus", AST_MEDIA_TYPE_AUDIO, },
1898                 { "alice_video", "vp8", AST_MEDIA_TYPE_VIDEO, },
1899         };
1900         static const struct stream_parameters alice_dest_stream = {
1901                 "softbridge_dest_PJSIP/Bob-00000001_bob_video", "vp8", AST_MEDIA_TYPE_VIDEO,
1902         };
1903         static const struct stream_parameters bob_dest_stream = {
1904                 "softbridge_dest_PJSIP/Alice-00000000_alice_video", "h264,vp8", AST_MEDIA_TYPE_VIDEO,
1905         };
1906         struct ast_stream_topology *topology_alice = NULL;
1907         struct ast_stream_topology *topology_bob = NULL;
1908
1909         switch (cmd) {
1910         case TEST_INIT:
1911                 info->name = "sfu_append_source_streams";
1912                 info->category = "/bridges/bridge_softmix/";
1913                 info->summary = "Test appending of video streams";
1914                 info->description =
1915                         "This tests does stuff.";
1916                 return AST_TEST_NOT_RUN;
1917         case TEST_EXECUTE:
1918                 break;
1919         }
1920
1921         topology_alice = build_topology(alice_streams, ARRAY_LEN(alice_streams));
1922         if (!topology_alice) {
1923                 goto end;
1924         }
1925
1926         topology_bob = build_topology(bob_streams, ARRAY_LEN(bob_streams));
1927         if (!topology_bob) {
1928                 goto end;
1929         }
1930
1931         if (append_source_streams(topology_alice, "PJSIP/Bob-00000001", topology_bob)) {
1932                 ast_test_status_update(test, "Failed to append Bob's streams to Alice\n");
1933                 goto end;
1934         }
1935
1936         if (ast_stream_topology_get_count(topology_alice) != 3) {
1937                 ast_test_status_update(test, "Alice's topology isn't large enough! It's %d but needs to be %d\n",
1938                         ast_stream_topology_get_count(topology_alice), 3);
1939                 goto end;
1940         }
1941
1942         if (validate_original_streams(test, topology_alice, alice_streams, ARRAY_LEN(alice_streams))) {
1943                 goto end;
1944         }
1945
1946         if (validate_stream(test, ast_stream_topology_get_stream(topology_alice, 2), &alice_dest_stream)) {
1947                 goto end;
1948         }
1949
1950         if (append_source_streams(topology_bob, "PJSIP/Alice-00000000", topology_alice)) {
1951                 ast_test_status_update(test, "Failed to append Alice's streams to Bob\n");
1952                 goto end;
1953         }
1954
1955         if (ast_stream_topology_get_count(topology_bob) != 3) {
1956                 ast_test_status_update(test, "Bob's topology isn't large enough! It's %d but needs to be %d\n",
1957                         ast_stream_topology_get_count(topology_bob), 3);
1958                 goto end;
1959         }
1960
1961         if (validate_original_streams(test, topology_bob, bob_streams, ARRAY_LEN(bob_streams))) {
1962                 goto end;
1963         }
1964
1965         if (validate_stream(test, ast_stream_topology_get_stream(topology_bob, 2), &bob_dest_stream)) {
1966                 goto end;
1967         }
1968
1969         res = AST_TEST_PASS;
1970
1971 end:
1972         ast_stream_topology_free(topology_alice);
1973         ast_stream_topology_free(topology_bob);
1974         return res;
1975 }
1976
1977 AST_TEST_DEFINE(sfu_remove_destination_streams)
1978 {
1979         enum ast_test_result_state res = AST_TEST_FAIL;
1980         static const struct stream_parameters params[] = {
1981                 { "alice_audio", "ulaw,alaw,g722,opus", AST_MEDIA_TYPE_AUDIO, },
1982                 { "alice_video", "h264,vp8", AST_MEDIA_TYPE_VIDEO, },
1983                 { "softbridge_dest_PJSIP/Bob-00000001_video", "vp8", AST_MEDIA_TYPE_VIDEO, },
1984                 { "softbridge_dest_PJSIP/Carol-00000002_video", "h264", AST_MEDIA_TYPE_VIDEO, },
1985         };
1986         static const struct {
1987                 const char *channel_name;
1988                 int num_streams;
1989                 int params_index[4];
1990         } removal_results[] = {
1991                 { "PJSIP/Bob-00000001", 4, { 0, 1, 2, 3 }, },
1992                 { "PJSIP/Edward-00000004", 4, { 0, 1, 2, 3 }, },
1993                 { "", 4, { 0, 1, 2, 3 }, },
1994         };
1995         struct ast_stream_topology *orig = NULL;
1996         struct ast_stream_topology *result = NULL;
1997         int i;
1998
1999         switch (cmd) {
2000         case TEST_INIT:
2001                 info->name = "sfu_remove_destination_streams";
2002                 info->category = "/bridges/bridge_softmix/";
2003                 info->summary = "Test removal of destination video streams";
2004                 info->description =
2005                         "This tests does stuff.";
2006                 return AST_TEST_NOT_RUN;
2007         case TEST_EXECUTE:
2008                 break;
2009         }
2010
2011         orig = build_topology(params, ARRAY_LEN(params));
2012         if (!orig) {
2013                 ast_test_status_update(test, "Unable to build initial stream topology\n");
2014                 goto end;
2015         }
2016
2017         for (i = 0; i < ARRAY_LEN(removal_results); ++i) {
2018                 int j;
2019
2020                 result = ast_stream_topology_alloc();
2021                 if (!result) {
2022                         ast_test_status_update(test, "Unable to allocate result stream topology\n");
2023                         goto end;
2024                 }
2025
2026                 if (remove_destination_streams(result, removal_results[i].channel_name, orig)) {
2027                         ast_test_status_update(test, "Failure while attempting to remove video streams\n");
2028                         goto end;
2029                 }
2030
2031                 if (ast_stream_topology_get_count(result) != removal_results[i].num_streams) {
2032                         ast_test_status_update(test, "Resulting topology has %d streams, when %d are expected\n",
2033                                 ast_stream_topology_get_count(result), removal_results[i].num_streams);
2034                         goto end;
2035                 }
2036
2037                 for (j = 0; j < removal_results[i].num_streams; ++j) {
2038                         struct ast_stream *actual;
2039                         struct ast_stream *expected;
2040                         int orig_index;
2041
2042                         actual = ast_stream_topology_get_stream(result, j);
2043
2044                         orig_index = removal_results[i].params_index[j];
2045                         expected = ast_stream_topology_get_stream(orig, orig_index);
2046
2047                         if (!ast_format_cap_identical(ast_stream_get_formats(actual),
2048                                 ast_stream_get_formats(expected))) {
2049                                 struct ast_str *expected_str;
2050                                 struct ast_str *actual_str;
2051
2052                                 expected_str = ast_str_alloca(64);
2053                                 actual_str = ast_str_alloca(64);
2054
2055                                 ast_test_status_update(test, "Mismatch between expected (%s) and actual (%s) stream formats\n",
2056                                         ast_format_cap_get_names(ast_stream_get_formats(expected), &expected_str),
2057                                         ast_format_cap_get_names(ast_stream_get_formats(actual), &actual_str));
2058                                 goto end;
2059                         }
2060
2061                         if (is_video_dest(actual, removal_results[i].channel_name, NULL) &&
2062                                 ast_stream_get_state(actual) != AST_STREAM_STATE_REMOVED) {
2063                                 ast_test_status_update(test, "Removed stream %s does not have a state of removed\n", ast_stream_get_name(actual));
2064                                 goto end;
2065                         }
2066                 }
2067         }
2068
2069         res = AST_TEST_PASS;
2070
2071 end:
2072         ast_stream_topology_free(orig);
2073         ast_stream_topology_free(result);
2074         return res;
2075 }
2076
2077 #endif
2078
2079 static int unload_module(void)
2080 {
2081         ast_bridge_technology_unregister(&softmix_bridge);
2082         AST_TEST_UNREGISTER(sfu_append_source_streams);
2083         AST_TEST_UNREGISTER(sfu_remove_destination_streams);
2084         return 0;
2085 }
2086
2087 static int load_module(void)
2088 {
2089         if (ast_bridge_technology_register(&softmix_bridge)) {
2090                 unload_module();
2091                 return AST_MODULE_LOAD_DECLINE;
2092         }
2093         AST_TEST_REGISTER(sfu_append_source_streams);
2094         AST_TEST_REGISTER(sfu_remove_destination_streams);
2095         return AST_MODULE_LOAD_SUCCESS;
2096 }
2097
2098 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Multi-party software based channel mixing");