Merge "bridge_softmix: Use removed stream spots when renegotiating."
[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         /*
989          * XXX Softmix needs to use channel roles to determine what to
990          * do with control frames.
991          */
992
993         switch (frame->subclass.integer) {
994         case AST_CONTROL_VIDUPDATE:
995                 ast_bridge_queue_everyone_else(bridge, NULL, frame);
996                 break;
997         default:
998                 break;
999         }
1000
1001         return 0;
1002 }
1003
1004 /*!
1005  * \internal
1006  * \brief Determine what to do with a frame written into the bridge.
1007  * \since 12.0.0
1008  *
1009  * \param bridge Which bridge is getting the frame
1010  * \param bridge_channel Which channel is writing the frame.
1011  * \param frame What is being written.
1012  *
1013  * \retval 0 Frame accepted into the bridge.
1014  * \retval -1 Frame needs to be deferred.
1015  *
1016  * \note On entry, bridge is already locked.
1017  */
1018 static int softmix_bridge_write(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
1019 {
1020         int res = 0;
1021
1022         if (!bridge->tech_pvt || !bridge_channel || !bridge_channel->tech_pvt) {
1023                 /* "Accept" the frame and discard it. */
1024                 return 0;
1025         }
1026
1027         /*
1028          * XXX Softmix needs to use channel roles to determine who gets
1029          * what frame.  Possible roles: announcer, recorder, agent,
1030          * supervisor.
1031          */
1032         switch (frame->frametype) {
1033         case AST_FRAME_NULL:
1034                 /* "Accept" the frame and discard it. */
1035                 break;
1036         case AST_FRAME_DTMF_BEGIN:
1037         case AST_FRAME_DTMF_END:
1038                 res = ast_bridge_queue_everyone_else(bridge, bridge_channel, frame);
1039                 break;
1040         case AST_FRAME_VOICE:
1041                 if (bridge_channel) {
1042                         softmix_bridge_write_voice(bridge, bridge_channel, frame);
1043                 }
1044                 break;
1045         case AST_FRAME_VIDEO:
1046                 if (bridge_channel) {
1047                         softmix_bridge_write_video(bridge, bridge_channel, frame);
1048                 }
1049                 break;
1050         case AST_FRAME_CONTROL:
1051                 res = softmix_bridge_write_control(bridge, bridge_channel, frame);
1052                 break;
1053         case AST_FRAME_BRIDGE_ACTION:
1054                 res = ast_bridge_queue_everyone_else(bridge, bridge_channel, frame);
1055                 break;
1056         case AST_FRAME_BRIDGE_ACTION_SYNC:
1057                 ast_log(LOG_ERROR, "Synchronous bridge action written to a softmix bridge.\n");
1058                 ast_assert(0);
1059         default:
1060                 ast_debug(3, "Frame type %u unsupported\n", frame->frametype);
1061                 /* "Accept" the frame and discard it. */
1062                 break;
1063         }
1064
1065         return res;
1066 }
1067
1068 static void gather_softmix_stats(struct softmix_stats *stats,
1069         const struct softmix_bridge_data *softmix_data,
1070         struct ast_bridge_channel *bridge_channel)
1071 {
1072         int channel_native_rate;
1073
1074         /* Gather stats about channel sample rates. */
1075         ast_channel_lock(bridge_channel->chan);
1076         channel_native_rate = MAX(SOFTMIX_MIN_SAMPLE_RATE,
1077                 ast_format_get_sample_rate(ast_channel_rawreadformat(bridge_channel->chan)));
1078         ast_channel_unlock(bridge_channel->chan);
1079
1080         if (stats->highest_supported_rate < channel_native_rate) {
1081                 stats->highest_supported_rate = channel_native_rate;
1082         }
1083         if (softmix_data->internal_rate < channel_native_rate) {
1084                 int i;
1085
1086                 for (i = 0; i < ARRAY_LEN(stats->sample_rates); i++) {
1087                         if (stats->sample_rates[i] == channel_native_rate) {
1088                                 stats->num_channels[i]++;
1089                                 break;
1090                         } else if (!stats->sample_rates[i]) {
1091                                 stats->sample_rates[i] = channel_native_rate;
1092                                 stats->num_channels[i]++;
1093                                 break;
1094                         }
1095                 }
1096                 stats->num_above_internal_rate++;
1097         } else if (softmix_data->internal_rate == channel_native_rate) {
1098                 stats->num_at_internal_rate++;
1099         }
1100 }
1101
1102 /*!
1103  * \internal
1104  * \brief Analyse mixing statistics and change bridges internal rate
1105  * if necessary.
1106  *
1107  * \retval 0, no changes to internal rate
1108  * \retval 1, internal rate was changed, update all the channels on the next mixing iteration.
1109  */
1110 static unsigned int analyse_softmix_stats(struct softmix_stats *stats,
1111                 struct softmix_bridge_data *softmix_data, int binaural_active)
1112 {
1113         int i;
1114
1115         if (binaural_active) {
1116                 stats->locked_rate = SOFTMIX_BINAURAL_SAMPLE_RATE;
1117         }
1118
1119         /*
1120          * Re-adjust the internal bridge sample rate if
1121          * 1. The bridge's internal sample rate is locked in at a sample
1122          *    rate other than the current sample rate being used.
1123          * 2. two or more channels support a higher sample rate
1124          * 3. no channels support the current sample rate or a higher rate
1125          */
1126         if (stats->locked_rate) {
1127                 /* if the rate is locked by the bridge, only update it if it differs
1128                  * from the current rate we are using. */
1129                 if (softmix_data->internal_rate != stats->locked_rate) {
1130                         ast_debug(1, "Locking at new rate.  Bridge changed from %u to %u.\n",
1131                                 softmix_data->internal_rate, stats->locked_rate);
1132                         softmix_data->internal_rate = stats->locked_rate;
1133                         return 1;
1134                 }
1135         } else if (stats->num_above_internal_rate >= 2) {
1136                 /* the highest rate is just used as a starting point */
1137                 unsigned int best_rate = stats->highest_supported_rate;
1138                 int best_index = -1;
1139
1140                 for (i = 0; i < ARRAY_LEN(stats->num_channels); i++) {
1141                         if (stats->num_channels[i]) {
1142                                 break;
1143                         }
1144                         if (2 <= stats->num_channels[i]) {
1145                                 /* Two or more channels support this rate. */
1146                                 if (best_index == -1
1147                                         || stats->sample_rates[best_index] < stats->sample_rates[i]) {
1148                                         /*
1149                                          * best_rate starts out being the first sample rate
1150                                          * greater than the internal sample rate that two or
1151                                          * more channels support.
1152                                          *
1153                                          * or
1154                                          *
1155                                          * There are multiple rates above the internal rate
1156                                          * and this rate is higher than the previous rate two
1157                                          * or more channels support.
1158                                          */
1159                                         best_rate = stats->sample_rates[i];
1160                                         best_index = i;
1161                                 }
1162                         } else if (best_index == -1) {
1163                                 /*
1164                                  * It is possible that multiple channels exist with native sample
1165                                  * rates above the internal sample rate, but none of those channels
1166                                  * have the same rate in common.  In this case, the lowest sample
1167                                  * rate among those channels is picked. Over time as additional
1168                                  * statistic runs are made the internal sample rate number will
1169                                  * adjust to the most optimal sample rate, but it may take multiple
1170                                  * iterations.
1171                                  */
1172                                 best_rate = MIN(best_rate, stats->sample_rates[i]);
1173                         }
1174                 }
1175
1176                 ast_debug(1, "Multiple above internal rate.  Bridge changed from %u to %u.\n",
1177                         softmix_data->internal_rate, best_rate);
1178                 softmix_data->internal_rate = best_rate;
1179                 return 1;
1180         } else if (!stats->num_at_internal_rate && !stats->num_above_internal_rate) {
1181                 /* In this case, the highest supported rate is actually lower than the internal rate */
1182                 ast_debug(1, "All below internal rate.  Bridge changed from %u to %u.\n",
1183                         softmix_data->internal_rate, stats->highest_supported_rate);
1184                 softmix_data->internal_rate = stats->highest_supported_rate;
1185                 return 1;
1186         }
1187         return 0;
1188 }
1189
1190 static int softmix_mixing_array_init(struct softmix_mixing_array *mixing_array,
1191                 unsigned int starting_num_entries, unsigned int binaural_active)
1192 {
1193         memset(mixing_array, 0, sizeof(*mixing_array));
1194         mixing_array->max_num_entries = starting_num_entries;
1195         if (!(mixing_array->buffers = ast_calloc(mixing_array->max_num_entries, sizeof(int16_t *)))) {
1196                 ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure.\n");
1197                 return -1;
1198         }
1199         if (binaural_active) {
1200                 if (!(mixing_array->chan_pairs = ast_calloc(mixing_array->max_num_entries,
1201                                 sizeof(struct convolve_channel_pair *)))) {
1202                         ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure.\n");
1203                         return -1;
1204                 }
1205         }
1206         return 0;
1207 }
1208
1209 static void softmix_mixing_array_destroy(struct softmix_mixing_array *mixing_array,
1210                 unsigned int binaural_active)
1211 {
1212         ast_free(mixing_array->buffers);
1213         if (binaural_active) {
1214                 ast_free(mixing_array->chan_pairs);
1215         }
1216 }
1217
1218 static int softmix_mixing_array_grow(struct softmix_mixing_array *mixing_array,
1219                 unsigned int num_entries, unsigned int binaural_active)
1220 {
1221         int16_t **tmp;
1222
1223         /* give it some room to grow since memory is cheap but allocations can be expensive */
1224         mixing_array->max_num_entries = num_entries;
1225         if (!(tmp = ast_realloc(mixing_array->buffers, (mixing_array->max_num_entries * sizeof(int16_t *))))) {
1226                 ast_log(LOG_NOTICE, "Failed to re-allocate softmix mixing structure.\n");
1227                 return -1;
1228         }
1229         if (binaural_active) {
1230                 struct convolve_channel_pair **tmp2;
1231                 if (!(tmp2 = ast_realloc(mixing_array->chan_pairs,
1232                                 (mixing_array->max_num_entries * sizeof(struct convolve_channel_pair *))))) {
1233                         ast_log(LOG_NOTICE, "Failed to re-allocate softmix mixing structure.\n");
1234                         return -1;
1235                 }
1236                 mixing_array->chan_pairs = tmp2;
1237         }
1238         mixing_array->buffers = tmp;
1239         return 0;
1240 }
1241
1242 /*!
1243  * \brief Mixing loop.
1244  *
1245  * \retval 0 on success
1246  * \retval -1 on failure
1247  */
1248 static int softmix_mixing_loop(struct ast_bridge *bridge)
1249 {
1250         struct softmix_stats stats = { { 0 }, };
1251         struct softmix_mixing_array mixing_array;
1252         struct softmix_bridge_data *softmix_data = bridge->tech_pvt;
1253         struct ast_timer *timer;
1254         struct softmix_translate_helper trans_helper;
1255         int16_t buf[MAX_DATALEN];
1256 #ifdef BINAURAL_RENDERING
1257         int16_t bin_buf[MAX_DATALEN];
1258         int16_t ann_buf[MAX_DATALEN];
1259 #endif
1260         unsigned int stat_iteration_counter = 0; /* counts down, gather stats at zero and reset. */
1261         int timingfd;
1262         int update_all_rates = 0; /* set this when the internal sample rate has changed */
1263         unsigned int idx;
1264         unsigned int x;
1265         int res = -1;
1266
1267         timer = softmix_data->timer;
1268         timingfd = ast_timer_fd(timer);
1269         softmix_translate_helper_init(&trans_helper, softmix_data->internal_rate);
1270         ast_timer_set_rate(timer, (1000 / softmix_data->internal_mixing_interval));
1271
1272         /* Give the mixing array room to grow, memory is cheap but allocations are expensive. */
1273         if (softmix_mixing_array_init(&mixing_array, bridge->num_channels + 10,
1274                         bridge->softmix.binaural_active)) {
1275                 goto softmix_cleanup;
1276         }
1277
1278         /*
1279          * XXX Softmix needs to use channel roles to determine who gets
1280          * what audio mixed.
1281          */
1282         while (!softmix_data->stop && bridge->num_active) {
1283                 struct ast_bridge_channel *bridge_channel;
1284                 int timeout = -1;
1285                 struct ast_format *cur_slin = ast_format_cache_get_slin_by_rate(softmix_data->internal_rate);
1286                 unsigned int softmix_samples = SOFTMIX_SAMPLES(softmix_data->internal_rate, softmix_data->internal_mixing_interval);
1287                 unsigned int softmix_datalen = SOFTMIX_DATALEN(softmix_data->internal_rate, softmix_data->internal_mixing_interval);
1288
1289                 if (softmix_datalen > MAX_DATALEN) {
1290                         /* This should NEVER happen, but if it does we need to know about it. Almost
1291                          * all the memcpys used during this process depend on this assumption.  Rather
1292                          * than checking this over and over again through out the code, this single
1293                          * verification is done on each iteration. */
1294                         ast_log(LOG_WARNING,
1295                                 "Bridge %s: Conference mixing error, requested mixing length greater than mixing buffer.\n",
1296                                 bridge->uniqueid);
1297                         goto softmix_cleanup;
1298                 }
1299
1300                 /* Grow the mixing array buffer as participants are added. */
1301                 if (mixing_array.max_num_entries < bridge->num_channels
1302                         && softmix_mixing_array_grow(&mixing_array, bridge->num_channels + 5,
1303                                         bridge->softmix.binaural_active)) {
1304                         goto softmix_cleanup;
1305                 }
1306
1307                 /* init the number of buffers stored in the mixing array to 0.
1308                  * As buffers are added for mixing, this number is incremented. */
1309                 mixing_array.used_entries = 0;
1310
1311                 /* These variables help determine if a rate change is required */
1312                 if (!stat_iteration_counter) {
1313                         memset(&stats, 0, sizeof(stats));
1314                         stats.locked_rate = bridge->softmix.internal_sample_rate;
1315                 }
1316
1317                 /* If the sample rate has changed, update the translator helper */
1318                 if (update_all_rates) {
1319                         softmix_translate_helper_change_rate(&trans_helper, softmix_data->internal_rate);
1320                 }
1321
1322 #ifdef BINAURAL_RENDERING
1323                 check_binaural_position_change(bridge, softmix_data, bridge_channel);
1324 #endif
1325
1326                 /* Go through pulling audio from each factory that has it available */
1327                 AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1328                         struct softmix_channel *sc = bridge_channel->tech_pvt;
1329
1330                         if (!sc) {
1331                                 /* This channel failed to join successfully. */
1332                                 continue;
1333                         }
1334
1335                         /* Update the sample rate to match the bridge's native sample rate if necessary. */
1336                         if (update_all_rates) {
1337                                 set_softmix_bridge_data(softmix_data->internal_rate,
1338                                                 softmix_data->internal_mixing_interval, bridge_channel, 1, -1, -1, -1);
1339                         }
1340
1341                         /* If stat_iteration_counter is 0, then collect statistics during this mixing interation */
1342                         if (!stat_iteration_counter) {
1343                                 gather_softmix_stats(&stats, softmix_data, bridge_channel);
1344                         }
1345
1346                         /* if the channel is suspended, don't check for audio, but still gather stats */
1347                         if (bridge_channel->suspended) {
1348                                 continue;
1349                         }
1350
1351                         /* Try to get audio from the factory if available */
1352                         ast_mutex_lock(&sc->lock);
1353                         if ((mixing_array.buffers[mixing_array.used_entries] = softmix_process_read_audio(sc, softmix_samples))) {
1354 #ifdef BINAURAL_RENDERING
1355                                 add_binaural_mixing(bridge, softmix_data, softmix_samples, &mixing_array, sc,
1356                                                 ast_channel_name(bridge_channel->chan));
1357 #endif
1358                                 mixing_array.used_entries++;
1359                         }
1360                         ast_mutex_unlock(&sc->lock);
1361                 }
1362
1363                 /* mix it like crazy (non binaural channels)*/
1364                 memset(buf, 0, softmix_datalen);
1365                 for (idx = 0; idx < mixing_array.used_entries; ++idx) {
1366                         for (x = 0; x < softmix_samples; ++x) {
1367                                 ast_slinear_saturated_add(buf + x, mixing_array.buffers[idx] + x);
1368                         }
1369                 }
1370
1371 #ifdef BINAURAL_RENDERING
1372                 binaural_mixing(bridge, softmix_data, &mixing_array, bin_buf, ann_buf);
1373 #endif
1374
1375                 /* Next step go through removing the channel's own audio and creating a good frame... */
1376                 AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1377                         struct softmix_channel *sc = bridge_channel->tech_pvt;
1378
1379                         if (!sc || bridge_channel->suspended) {
1380                                 /* This channel failed to join successfully or is suspended. */
1381                                 continue;
1382                         }
1383
1384                         ast_mutex_lock(&sc->lock);
1385
1386                         /* Make SLINEAR write frame from local buffer */
1387                         ao2_t_replace(sc->write_frame.subclass.format, cur_slin,
1388                                 "Replace softmix channel slin format");
1389 #ifdef BINAURAL_RENDERING
1390                         if (bridge->softmix.binaural_active && softmix_data->convolve.binaural_active
1391                                         && sc->binaural) {
1392                                 create_binaural_frame(bridge_channel, sc, bin_buf, ann_buf, softmix_datalen,
1393                                                 softmix_samples, buf);
1394                         } else
1395 #endif
1396                         {
1397                                 sc->write_frame.datalen = softmix_datalen;
1398                                 sc->write_frame.samples = softmix_samples;
1399                                 memcpy(sc->final_buf, buf, softmix_datalen);
1400                         }
1401                         /* process the softmix channel's new write audio */
1402                         softmix_process_write_audio(&trans_helper,
1403                                         ast_channel_rawwriteformat(bridge_channel->chan), sc,
1404                                         softmix_data->default_sample_size);
1405
1406                         ast_mutex_unlock(&sc->lock);
1407
1408                         /* A frame is now ready for the channel. */
1409                         ast_bridge_channel_queue_frame(bridge_channel, &sc->write_frame);
1410                 }
1411
1412                 update_all_rates = 0;
1413                 if (!stat_iteration_counter) {
1414                         update_all_rates = analyse_softmix_stats(&stats, softmix_data,
1415                                         bridge->softmix.binaural_active);
1416                         stat_iteration_counter = SOFTMIX_STAT_INTERVAL;
1417                 }
1418                 stat_iteration_counter--;
1419
1420                 ast_bridge_unlock(bridge);
1421                 /* cleanup any translation frame data from the previous mixing iteration. */
1422                 softmix_translate_helper_cleanup(&trans_helper);
1423                 /* Wait for the timing source to tell us to wake up and get things done */
1424                 ast_waitfor_n_fd(&timingfd, 1, &timeout, NULL);
1425                 if (ast_timer_ack(timer, 1) < 0) {
1426                         ast_log(LOG_ERROR, "Bridge %s: Failed to acknowledge timer in softmix.\n",
1427                                 bridge->uniqueid);
1428                         ast_bridge_lock(bridge);
1429                         goto softmix_cleanup;
1430                 }
1431                 ast_bridge_lock(bridge);
1432
1433                 /* make sure to detect mixing interval changes if they occur. */
1434                 if (bridge->softmix.internal_mixing_interval
1435                         && (bridge->softmix.internal_mixing_interval != softmix_data->internal_mixing_interval)) {
1436                         softmix_data->internal_mixing_interval = bridge->softmix.internal_mixing_interval;
1437                         ast_timer_set_rate(timer, (1000 / softmix_data->internal_mixing_interval));
1438                         update_all_rates = 1; /* if the interval changes, the rates must be adjusted as well just to be notified new interval.*/
1439                 }
1440         }
1441
1442         res = 0;
1443
1444 softmix_cleanup:
1445         softmix_translate_helper_destroy(&trans_helper);
1446         softmix_mixing_array_destroy(&mixing_array, bridge->softmix.binaural_active);
1447         return res;
1448 }
1449
1450 /*!
1451  * \internal
1452  * \brief Mixing thread.
1453  * \since 12.0.0
1454  *
1455  * \note The thread does not have its own reference to the
1456  * bridge.  The lifetime of the thread is tied to the lifetime
1457  * of the mixing technology association with the bridge.
1458  */
1459 static void *softmix_mixing_thread(void *data)
1460 {
1461         struct softmix_bridge_data *softmix_data = data;
1462         struct ast_bridge *bridge = softmix_data->bridge;
1463
1464         ast_bridge_lock(bridge);
1465         if (bridge->callid) {
1466                 ast_callid_threadassoc_add(bridge->callid);
1467         }
1468
1469         ast_debug(1, "Bridge %s: starting mixing thread\n", bridge->uniqueid);
1470
1471         while (!softmix_data->stop) {
1472                 if (!bridge->num_active) {
1473                         /* Wait for something to happen to the bridge. */
1474                         ast_bridge_unlock(bridge);
1475                         ast_mutex_lock(&softmix_data->lock);
1476                         if (!softmix_data->stop) {
1477                                 ast_cond_wait(&softmix_data->cond, &softmix_data->lock);
1478                         }
1479                         ast_mutex_unlock(&softmix_data->lock);
1480                         ast_bridge_lock(bridge);
1481                         continue;
1482                 }
1483
1484                 if (bridge->softmix.binaural_active && !softmix_data->binaural_init) {
1485 #ifndef BINAURAL_RENDERING
1486                         ast_bridge_lock(bridge);
1487                         bridge->softmix.binaural_active = 0;
1488                         ast_bridge_unlock(bridge);
1489                         ast_log(LOG_WARNING, "Bridge: %s: Binaural rendering active by config but not "
1490                                         "compiled.\n", bridge->uniqueid);
1491 #else
1492                         /* Set and init binaural data if binaural is activated in the configuration. */
1493                         softmix_data->internal_rate = SOFTMIX_BINAURAL_SAMPLE_RATE;
1494                         softmix_data->default_sample_size = SOFTMIX_SAMPLES(softmix_data->internal_rate,
1495                                         softmix_data->internal_mixing_interval);
1496                         /* If init for binaural processing fails we will fall back to mono audio processing. */
1497                         if (init_convolve_data(&softmix_data->convolve, softmix_data->default_sample_size)
1498                                         == -1) {
1499                                 ast_bridge_lock(bridge);
1500                                 bridge->softmix.binaural_active = 0;
1501                                 ast_bridge_unlock(bridge);
1502                                 ast_log(LOG_ERROR, "Bridge: %s: Unable to allocate memory for "
1503                                                 "binaural processing,  Will only process mono audio.\n",
1504                                                 bridge->uniqueid);
1505                         }
1506                         softmix_data->binaural_init = 1;
1507 #endif
1508                 }
1509
1510                 if (softmix_mixing_loop(bridge)) {
1511                         /*
1512                          * A mixing error occurred.  Sleep and try again later so we
1513                          * won't flood the logs.
1514                          */
1515                         ast_bridge_unlock(bridge);
1516                         sleep(1);
1517                         ast_bridge_lock(bridge);
1518                 }
1519         }
1520
1521         ast_bridge_unlock(bridge);
1522
1523         ast_debug(1, "Bridge %s: stopping mixing thread\n", bridge->uniqueid);
1524
1525         return NULL;
1526 }
1527
1528 static void softmix_bridge_data_destroy(struct softmix_bridge_data *softmix_data)
1529 {
1530         if (softmix_data->timer) {
1531                 ast_timer_close(softmix_data->timer);
1532                 softmix_data->timer = NULL;
1533         }
1534         ast_mutex_destroy(&softmix_data->lock);
1535         ast_cond_destroy(&softmix_data->cond);
1536         ast_free(softmix_data);
1537 }
1538
1539 /*! \brief Function called when a bridge is created */
1540 static int softmix_bridge_create(struct ast_bridge *bridge)
1541 {
1542         struct softmix_bridge_data *softmix_data;
1543
1544         softmix_data = ast_calloc(1, sizeof(*softmix_data));
1545         if (!softmix_data) {
1546                 return -1;
1547         }
1548         softmix_data->bridge = bridge;
1549         ast_mutex_init(&softmix_data->lock);
1550         ast_cond_init(&softmix_data->cond, NULL);
1551         softmix_data->timer = ast_timer_open();
1552         if (!softmix_data->timer) {
1553                 ast_log(AST_LOG_WARNING, "Failed to open timer for softmix bridge\n");
1554                 softmix_bridge_data_destroy(softmix_data);
1555                 return -1;
1556         }
1557         /* start at minimum rate, let it grow from there */
1558         softmix_data->internal_rate = SOFTMIX_MIN_SAMPLE_RATE;
1559         softmix_data->internal_mixing_interval = DEFAULT_SOFTMIX_INTERVAL;
1560
1561 #ifdef BINAURAL_RENDERING
1562         softmix_data->default_sample_size = SOFTMIX_SAMPLES(softmix_data->internal_rate,
1563                         softmix_data->internal_mixing_interval);
1564 #endif
1565
1566         bridge->tech_pvt = softmix_data;
1567
1568         /* Start the mixing thread. */
1569         if (ast_pthread_create(&softmix_data->thread, NULL, softmix_mixing_thread,
1570                 softmix_data)) {
1571                 softmix_data->thread = AST_PTHREADT_NULL;
1572                 softmix_bridge_data_destroy(softmix_data);
1573                 bridge->tech_pvt = NULL;
1574                 return -1;
1575         }
1576
1577         return 0;
1578 }
1579
1580 /*!
1581  * \internal
1582  * \brief Request the softmix mixing thread stop.
1583  * \since 12.0.0
1584  *
1585  * \param bridge Which bridge is being stopped.
1586  *
1587  * \return Nothing
1588  */
1589 static void softmix_bridge_stop(struct ast_bridge *bridge)
1590 {
1591         struct softmix_bridge_data *softmix_data;
1592
1593         softmix_data = bridge->tech_pvt;
1594         if (!softmix_data) {
1595                 return;
1596         }
1597
1598         ast_mutex_lock(&softmix_data->lock);
1599         softmix_data->stop = 1;
1600         ast_mutex_unlock(&softmix_data->lock);
1601 }
1602
1603 /*! \brief Function called when a bridge is destroyed */
1604 static void softmix_bridge_destroy(struct ast_bridge *bridge)
1605 {
1606         struct softmix_bridge_data *softmix_data;
1607         pthread_t thread;
1608
1609         softmix_data = bridge->tech_pvt;
1610         if (!softmix_data) {
1611                 return;
1612         }
1613
1614         /* Stop the mixing thread. */
1615         ast_mutex_lock(&softmix_data->lock);
1616         softmix_data->stop = 1;
1617         ast_cond_signal(&softmix_data->cond);
1618         thread = softmix_data->thread;
1619         softmix_data->thread = AST_PTHREADT_NULL;
1620         ast_mutex_unlock(&softmix_data->lock);
1621         if (thread != AST_PTHREADT_NULL) {
1622                 ast_debug(1, "Bridge %s: Waiting for mixing thread to die.\n", bridge->uniqueid);
1623                 pthread_join(thread, NULL);
1624         }
1625 #ifdef BINAURAL_RENDERING
1626         free_convolve_data(&softmix_data->convolve);
1627 #endif
1628         softmix_bridge_data_destroy(softmix_data);
1629         bridge->tech_pvt = NULL;
1630 }
1631
1632 /*!
1633  * \brief Map a source stream to all of its destination streams.
1634  *
1635  * \param source_stream_name Name of the source stream
1636  * \param source_channel_name Name of channel where the source stream originates
1637  * \param bridge_stream_position The slot in the bridge where source video will come from
1638  * \param participants The bridge_channels in the bridge
1639  */
1640 static void map_source_to_destinations(const char *source_stream_name, const char *source_channel_name,
1641         size_t bridge_stream_position, struct ast_bridge_channels_list *participants)
1642 {
1643         struct ast_bridge_channel *participant;
1644
1645         AST_LIST_TRAVERSE(participants, participant, entry) {
1646                 int i;
1647                 struct ast_stream_topology *topology;
1648
1649                 if (!strcmp(source_channel_name, ast_channel_name(participant->chan))) {
1650                         continue;
1651                 }
1652
1653                 ast_bridge_channel_lock(participant);
1654                 topology = ast_channel_get_stream_topology(participant->chan);
1655
1656                 for (i = 0; i < ast_stream_topology_get_count(topology); ++i) {
1657                         struct ast_stream *stream;
1658
1659                         stream = ast_stream_topology_get_stream(topology, i);
1660                         if (is_video_dest(stream, source_channel_name, source_stream_name)) {
1661                                 AST_VECTOR_REPLACE(&participant->stream_map.to_channel, bridge_stream_position, i);
1662                                 break;
1663                         }
1664                 }
1665                 ast_bridge_channel_unlock(participant);
1666         }
1667 }
1668
1669 /*\brief stream_topology_changed callback
1670  *
1671  * For most video modes, nothing beyond the ordinary is required.
1672  * For the SFU case, though, we need to completely remap the streams
1673  * in order to ensure video gets directed where it is expected to go.
1674  *
1675  * \param bridge The bridge
1676  * \param bridge_channel Channel whose topology has changed
1677  */
1678 static void softmix_bridge_stream_topology_changed(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
1679 {
1680         struct ast_bridge_channel *participant;
1681         struct ast_vector_int media_types;
1682         int nths[AST_MEDIA_TYPE_END] = {0};
1683
1684         switch (bridge->softmix.video_mode.mode) {
1685         case AST_BRIDGE_VIDEO_MODE_NONE:
1686         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
1687         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
1688         default:
1689                 ast_bridge_channel_stream_map(bridge_channel);
1690                 return;
1691         case AST_BRIDGE_VIDEO_MODE_SFU:
1692                 break;
1693         }
1694
1695         AST_VECTOR_INIT(&media_types, AST_MEDIA_TYPE_END);
1696
1697         /* First traversal: re-initialize all of the participants' stream maps */
1698         AST_LIST_TRAVERSE(&bridge->channels, participant, entry) {
1699                 int size;
1700
1701                 ast_bridge_channel_lock(participant);
1702                 size = ast_stream_topology_get_count(ast_channel_get_stream_topology(participant->chan));
1703
1704                 AST_VECTOR_FREE(&participant->stream_map.to_channel);
1705                 AST_VECTOR_FREE(&participant->stream_map.to_bridge);
1706
1707                 AST_VECTOR_INIT(&participant->stream_map.to_channel, size);
1708                 AST_VECTOR_INIT(&participant->stream_map.to_bridge, size);
1709                 ast_bridge_channel_unlock(participant);
1710         }
1711
1712         /* Second traversal: Map specific video channels from their source to their destinations.
1713          *
1714          * This is similar to what is done in ast_stream_topology_map(), except that
1715          * video channels are handled differently. Each video source has it's own
1716          * unique index on the bridge. this way, a particular channel's source video
1717          * can be distributed to the appropriate destination streams on the other
1718          * channels
1719          */
1720         AST_LIST_TRAVERSE(&bridge->channels, participant, entry) {
1721                 int i;
1722                 struct ast_stream_topology *topology;
1723
1724                 topology = ast_channel_get_stream_topology(participant->chan);
1725
1726                 for (i = 0; i < ast_stream_topology_get_count(topology); ++i) {
1727                         struct ast_stream *stream = ast_stream_topology_get_stream(topology, i);
1728                         ast_bridge_channel_lock(participant);
1729                         if (is_video_source(stream)) {
1730                                 AST_VECTOR_APPEND(&media_types, AST_MEDIA_TYPE_VIDEO);
1731                                 AST_VECTOR_REPLACE(&participant->stream_map.to_bridge, i, AST_VECTOR_SIZE(&media_types) - 1);
1732                                 AST_VECTOR_REPLACE(&participant->stream_map.to_channel, AST_VECTOR_SIZE(&media_types) - 1, -1);
1733                                 /* Unlock the participant to prevent potential deadlock
1734                                  * in map_source_to_destinations
1735                                  */
1736                                 ast_bridge_channel_unlock(participant);
1737                                 map_source_to_destinations(ast_stream_get_name(stream), ast_channel_name(participant->chan),
1738                                         AST_VECTOR_SIZE(&media_types) - 1, &bridge->channels);
1739                                 ast_bridge_channel_lock(participant);
1740                         } else if (is_video_dest(stream, NULL, NULL)) {
1741                                 /* We expect to never read media from video destination channels, but just
1742                                  * in case, we should set their to_bridge value to -1.
1743                                  */
1744                                 AST_VECTOR_REPLACE(&participant->stream_map.to_bridge, i, -1);
1745                         } else {
1746                                 /* XXX This is copied from ast_stream_topology_map(). This likely could
1747                                  * be factored out in some way
1748                                  */
1749                                 enum ast_media_type type = ast_stream_get_type(stream);
1750                                 int index = AST_VECTOR_GET_INDEX_NTH(&media_types, ++nths[type],
1751                                         type, AST_VECTOR_ELEM_DEFAULT_CMP);
1752
1753                                 if (index == -1) {
1754                                         AST_VECTOR_APPEND(&media_types, type);
1755                                         index = AST_VECTOR_SIZE(&media_types) - 1;
1756                                 }
1757
1758                                 AST_VECTOR_REPLACE(&participant->stream_map.to_bridge, i, index);
1759                                 AST_VECTOR_REPLACE(&participant->stream_map.to_channel, index, i);
1760                         }
1761                         ast_bridge_channel_unlock(participant);
1762                 }
1763         }
1764 }
1765
1766 static struct ast_bridge_technology softmix_bridge = {
1767         .name = "softmix",
1768         .capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX,
1769         .preference = AST_BRIDGE_PREFERENCE_BASE_MULTIMIX,
1770         .create = softmix_bridge_create,
1771         .stop = softmix_bridge_stop,
1772         .destroy = softmix_bridge_destroy,
1773         .join = softmix_bridge_join,
1774         .leave = softmix_bridge_leave,
1775         .unsuspend = softmix_bridge_unsuspend,
1776         .write = softmix_bridge_write,
1777         .stream_topology_changed = softmix_bridge_stream_topology_changed,
1778 };
1779
1780 #ifdef TEST_FRAMEWORK
1781 struct stream_parameters {
1782         const char *name;
1783         const char *formats;
1784         enum ast_media_type type;
1785 };
1786
1787 static struct ast_stream_topology *build_topology(const struct stream_parameters *params, size_t num_streams)
1788 {
1789         struct ast_stream_topology *topology;
1790         size_t i;
1791
1792         topology = ast_stream_topology_alloc();
1793         if (!topology) {
1794                 return NULL;
1795         }
1796
1797         for (i = 0; i < num_streams; ++i) {
1798                 RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
1799                 struct ast_stream *stream;
1800
1801                 caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1802                 if (!caps) {
1803                         goto fail;
1804                 }
1805                 if (ast_format_cap_update_by_allow_disallow(caps, params[i].formats, 1) < 0) {
1806                         goto fail;
1807                 }
1808                 stream = ast_stream_alloc(params[i].name, params[i].type);
1809                 if (!stream) {
1810                         goto fail;
1811                 }
1812                 ast_stream_set_formats(stream, caps);
1813                 if (ast_stream_topology_append_stream(topology, stream) < 0) {
1814                         ast_stream_free(stream);
1815                         goto fail;
1816                 }
1817         }
1818
1819         return topology;
1820
1821 fail:
1822         ast_stream_topology_free(topology);
1823         return NULL;
1824 }
1825
1826 static int validate_stream(struct ast_test *test, struct ast_stream *stream,
1827         const struct stream_parameters *params)
1828 {
1829         struct ast_format_cap *stream_caps;
1830         struct ast_format_cap *params_caps;
1831
1832         if (ast_stream_get_type(stream) != params->type) {
1833                 ast_test_status_update(test, "Expected stream type '%s' but got type '%s'\n",
1834                         ast_codec_media_type2str(params->type),
1835                         ast_codec_media_type2str(ast_stream_get_type(stream)));
1836                 return -1;
1837         }
1838         if (strcmp(ast_stream_get_name(stream), params->name)) {
1839                 ast_test_status_update(test, "Expected stream name '%s' but got type '%s'\n",
1840                         params->name, ast_stream_get_name(stream));
1841                 return -1;
1842         }
1843
1844         stream_caps = ast_stream_get_formats(stream);
1845         params_caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1846         if (!params_caps) {
1847                 ast_test_status_update(test, "Allocation error on capabilities\n");
1848                 return -1;
1849         }
1850         ast_format_cap_update_by_allow_disallow(params_caps, params->formats, 1);
1851
1852         if (ast_format_cap_identical(stream_caps, params_caps)) {
1853                 ast_test_status_update(test, "Formats are not as expected on stream '%s'\n",
1854                         ast_stream_get_name(stream));
1855                 ao2_cleanup(params_caps);
1856                 return -1;
1857         }
1858
1859         ao2_cleanup(params_caps);
1860         return 0;
1861 }
1862
1863 static int validate_original_streams(struct ast_test *test, struct ast_stream_topology *topology,
1864         const struct stream_parameters *params, size_t num_streams)
1865 {
1866         int i;
1867
1868         if (ast_stream_topology_get_count(topology) < num_streams) {
1869                 ast_test_status_update(test, "Topology only has %d streams. Needs to have at least %zu\n",
1870                         ast_stream_topology_get_count(topology), num_streams);
1871                 return -1;
1872         }
1873
1874         for (i = 0; i < ARRAY_LEN(params); ++i) {
1875                 if (validate_stream(test, ast_stream_topology_get_stream(topology, i), &params[i])) {
1876                         return -1;
1877                 }
1878         }
1879
1880         return 0;
1881 }
1882
1883 AST_TEST_DEFINE(sfu_append_source_streams)
1884 {
1885         enum ast_test_result_state res = AST_TEST_FAIL;
1886         static const struct stream_parameters bob_streams[] = {
1887                 { "bob_audio", "ulaw,alaw,g722,opus", AST_MEDIA_TYPE_AUDIO, },
1888                 { "bob_video", "h264,vp8", AST_MEDIA_TYPE_VIDEO, },
1889         };
1890         static const struct stream_parameters alice_streams[] = {
1891                 { "alice_audio", "ulaw,opus", AST_MEDIA_TYPE_AUDIO, },
1892                 { "alice_video", "vp8", AST_MEDIA_TYPE_VIDEO, },
1893         };
1894         static const struct stream_parameters alice_dest_stream = {
1895                 "softbridge_dest_PJSIP/Bob-00000001_bob_video", "vp8", AST_MEDIA_TYPE_VIDEO,
1896         };
1897         static const struct stream_parameters bob_dest_stream = {
1898                 "softbridge_dest_PJSIP/Alice-00000000_alice_video", "h264,vp8", AST_MEDIA_TYPE_VIDEO,
1899         };
1900         struct ast_stream_topology *topology_alice = NULL;
1901         struct ast_stream_topology *topology_bob = NULL;
1902
1903         switch (cmd) {
1904         case TEST_INIT:
1905                 info->name = "sfu_append_source_streams";
1906                 info->category = "/bridges/bridge_softmix/";
1907                 info->summary = "Test appending of video streams";
1908                 info->description =
1909                         "This tests does stuff.";
1910                 return AST_TEST_NOT_RUN;
1911         case TEST_EXECUTE:
1912                 break;
1913         }
1914
1915         topology_alice = build_topology(alice_streams, ARRAY_LEN(alice_streams));
1916         if (!topology_alice) {
1917                 goto end;
1918         }
1919
1920         topology_bob = build_topology(bob_streams, ARRAY_LEN(bob_streams));
1921         if (!topology_bob) {
1922                 goto end;
1923         }
1924
1925         if (append_source_streams(topology_alice, "PJSIP/Bob-00000001", topology_bob)) {
1926                 ast_test_status_update(test, "Failed to append Bob's streams to Alice\n");
1927                 goto end;
1928         }
1929
1930         if (ast_stream_topology_get_count(topology_alice) != 3) {
1931                 ast_test_status_update(test, "Alice's topology isn't large enough! It's %d but needs to be %d\n",
1932                         ast_stream_topology_get_count(topology_alice), 3);
1933                 goto end;
1934         }
1935
1936         if (validate_original_streams(test, topology_alice, alice_streams, ARRAY_LEN(alice_streams))) {
1937                 goto end;
1938         }
1939
1940         if (validate_stream(test, ast_stream_topology_get_stream(topology_alice, 2), &alice_dest_stream)) {
1941                 goto end;
1942         }
1943
1944         if (append_source_streams(topology_bob, "PJSIP/Alice-00000000", topology_alice)) {
1945                 ast_test_status_update(test, "Failed to append Alice's streams to Bob\n");
1946                 goto end;
1947         }
1948
1949         if (ast_stream_topology_get_count(topology_bob) != 3) {
1950                 ast_test_status_update(test, "Bob's topology isn't large enough! It's %d but needs to be %d\n",
1951                         ast_stream_topology_get_count(topology_bob), 3);
1952                 goto end;
1953         }
1954
1955         if (validate_original_streams(test, topology_bob, bob_streams, ARRAY_LEN(bob_streams))) {
1956                 goto end;
1957         }
1958
1959         if (validate_stream(test, ast_stream_topology_get_stream(topology_bob, 2), &bob_dest_stream)) {
1960                 goto end;
1961         }
1962
1963         res = AST_TEST_PASS;
1964
1965 end:
1966         ast_stream_topology_free(topology_alice);
1967         ast_stream_topology_free(topology_bob);
1968         return res;
1969 }
1970
1971 AST_TEST_DEFINE(sfu_remove_destination_streams)
1972 {
1973         enum ast_test_result_state res = AST_TEST_FAIL;
1974         static const struct stream_parameters params[] = {
1975                 { "alice_audio", "ulaw,alaw,g722,opus", AST_MEDIA_TYPE_AUDIO, },
1976                 { "alice_video", "h264,vp8", AST_MEDIA_TYPE_VIDEO, },
1977                 { "softbridge_dest_PJSIP/Bob-00000001_video", "vp8", AST_MEDIA_TYPE_VIDEO, },
1978                 { "softbridge_dest_PJSIP/Carol-00000002_video", "h264", AST_MEDIA_TYPE_VIDEO, },
1979         };
1980         static const struct {
1981                 const char *channel_name;
1982                 int num_streams;
1983                 int params_index[4];
1984         } removal_results[] = {
1985                 { "PJSIP/Bob-00000001", 4, { 0, 1, 2, 3 }, },
1986                 { "PJSIP/Edward-00000004", 4, { 0, 1, 2, 3 }, },
1987                 { "", 4, { 0, 1, 2, 3 }, },
1988         };
1989         struct ast_stream_topology *orig = NULL;
1990         struct ast_stream_topology *result = NULL;
1991         int i;
1992
1993         switch (cmd) {
1994         case TEST_INIT:
1995                 info->name = "sfu_remove_destination_streams";
1996                 info->category = "/bridges/bridge_softmix/";
1997                 info->summary = "Test removal of destination video streams";
1998                 info->description =
1999                         "This tests does stuff.";
2000                 return AST_TEST_NOT_RUN;
2001         case TEST_EXECUTE:
2002                 break;
2003         }
2004
2005         orig = build_topology(params, ARRAY_LEN(params));
2006         if (!orig) {
2007                 ast_test_status_update(test, "Unable to build initial stream topology\n");
2008                 goto end;
2009         }
2010
2011         for (i = 0; i < ARRAY_LEN(removal_results); ++i) {
2012                 int j;
2013
2014                 result = ast_stream_topology_alloc();
2015                 if (!result) {
2016                         ast_test_status_update(test, "Unable to allocate result stream topology\n");
2017                         goto end;
2018                 }
2019
2020                 if (remove_destination_streams(result, removal_results[i].channel_name, orig)) {
2021                         ast_test_status_update(test, "Failure while attempting to remove video streams\n");
2022                         goto end;
2023                 }
2024
2025                 if (ast_stream_topology_get_count(result) != removal_results[i].num_streams) {
2026                         ast_test_status_update(test, "Resulting topology has %d streams, when %d are expected\n",
2027                                 ast_stream_topology_get_count(result), removal_results[i].num_streams);
2028                         goto end;
2029                 }
2030
2031                 for (j = 0; j < removal_results[i].num_streams; ++j) {
2032                         struct ast_stream *actual;
2033                         struct ast_stream *expected;
2034                         int orig_index;
2035
2036                         actual = ast_stream_topology_get_stream(result, j);
2037
2038                         orig_index = removal_results[i].params_index[j];
2039                         expected = ast_stream_topology_get_stream(orig, orig_index);
2040
2041                         if (!ast_format_cap_identical(ast_stream_get_formats(actual),
2042                                 ast_stream_get_formats(expected))) {
2043                                 struct ast_str *expected_str;
2044                                 struct ast_str *actual_str;
2045
2046                                 expected_str = ast_str_alloca(64);
2047                                 actual_str = ast_str_alloca(64);
2048
2049                                 ast_test_status_update(test, "Mismatch between expected (%s) and actual (%s) stream formats\n",
2050                                         ast_format_cap_get_names(ast_stream_get_formats(expected), &expected_str),
2051                                         ast_format_cap_get_names(ast_stream_get_formats(actual), &actual_str));
2052                                 goto end;
2053                         }
2054
2055                         if (is_video_dest(actual, removal_results[i].channel_name, NULL) &&
2056                                 ast_stream_get_state(actual) != AST_STREAM_STATE_REMOVED) {
2057                                 ast_test_status_update(test, "Removed stream %s does not have a state of removed\n", ast_stream_get_name(actual));
2058                                 goto end;
2059                         }
2060                 }
2061         }
2062
2063         res = AST_TEST_PASS;
2064
2065 end:
2066         ast_stream_topology_free(orig);
2067         ast_stream_topology_free(result);
2068         return res;
2069 }
2070
2071 #endif
2072
2073 static int unload_module(void)
2074 {
2075         ast_bridge_technology_unregister(&softmix_bridge);
2076         AST_TEST_UNREGISTER(sfu_append_source_streams);
2077         AST_TEST_UNREGISTER(sfu_remove_destination_streams);
2078         return 0;
2079 }
2080
2081 static int load_module(void)
2082 {
2083         if (ast_bridge_technology_register(&softmix_bridge)) {
2084                 unload_module();
2085                 return AST_MODULE_LOAD_DECLINE;
2086         }
2087         AST_TEST_REGISTER(sfu_append_source_streams);
2088         AST_TEST_REGISTER(sfu_remove_destination_streams);
2089         return AST_MODULE_LOAD_SUCCESS;
2090 }
2091
2092 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Multi-party software based channel mixing");