diff --git a/src/audio/capture/alsa.c b/src/audio/capture/alsa.c
index 2f200f649..09107dd3b 100644
--- a/src/audio/capture/alsa.c
+++ b/src/audio/capture/alsa.c
@@ -146,7 +146,7 @@ static void * audio_cap_alsa_init(const char *cfg)
         gettimeofday(&s->start_time, NULL);
         s->frame.bps = audio_capture_bps;
         s->frame.sample_rate = audio_capture_sample_rate;
-        s->min_device_channels = s->frame.ch_count = audio_capture_channels;
+        s->min_device_channels = s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
         s->tmp_data = NULL;
 
         /* Set period size to 128 frames or more. */
@@ -218,7 +218,7 @@ static void * audio_cap_alsa_init(const char *cfg)
         if (!snd_pcm_hw_params_test_access(s->handle, params, SND_PCM_ACCESS_RW_INTERLEAVED)) {
                 s->non_interleaved = false;
         } else if (!snd_pcm_hw_params_test_access(s->handle, params, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
-                if (audio_capture_channels > 1) {
+                if (s->frame.ch_count > 1) {
                         log_msg(LOG_LEVEL_ERROR, MOD_NAME "Non-interleaved mode "
                                         "available only when capturing mono!\n");
                         goto error;
@@ -339,7 +339,7 @@ static struct audio_frame *audio_cap_alsa_read(void *state)
         }
 
         if (s->non_interleaved) {
-                assert(audio_capture_channels == 1);
+                assert(s->frame.ch_count == 1);
                 discard_data = (char *) alloca(s->frames * s->frame.bps * (s->min_device_channels-1));
                 for (unsigned int i = 1; i < s->min_device_channels; ++i) {
                         read_ptr[i] = discard_data + (i - 1) * s->frames * s->frame.bps;
diff --git a/src/audio/capture/coreaudio.m b/src/audio/capture/coreaudio.m
index 05bafeec0..b26a53785 100644
--- a/src/audio/capture/coreaudio.m
+++ b/src/audio/capture/coreaudio.m
@@ -276,7 +276,7 @@ static void * audio_cap_ca_init(const char *cfg)
         s->boss_waiting = FALSE;
         s->data_ready = FALSE;
         s->frame.bps = audio_capture_bps ? audio_capture_bps : 2;
-        s->frame.ch_count = audio_capture_channels;
+        s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
 
         double rate;
         size = sizeof(double);
diff --git a/src/audio/capture/jack.c b/src/audio/capture/jack.c
index c2801d729..c2d2c5d7e 100644
--- a/src/audio/capture/jack.c
+++ b/src/audio/capture/jack.c
@@ -206,14 +206,14 @@ static void * audio_cap_jack_init(const char *cfg)
         i = 0;
         while(ports[i]) i++;
 
-        if(i < (int) audio_capture_channels) {
+        s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
+        if (i < s->frame.ch_count) {
                 log_msg(LOG_LEVEL_ERROR, MOD_NAME "Requested channel count %d not found (matching pattern %s).\n",
-                                audio_capture_channels, cfg);
+                                s->frame.ch_count, cfg);
                 goto release_client;
 
         }
 
-        s->frame.ch_count = audio_capture_channels;
         s->frame.bps = 4;
         if (audio_capture_sample_rate) {
                 log_msg(LOG_LEVEL_WARNING, "[JACK capture] Ignoring user specified sample rate!\n");
diff --git a/src/audio/capture/portaudio.c b/src/audio/capture/portaudio.c
index 02039d28f..6b74f3118 100644
--- a/src/audio/capture/portaudio.c
+++ b/src/audio/capture/portaudio.c
@@ -219,11 +219,10 @@ static void * audio_cap_portaudio_init(const char *cfg)
                 return NULL;
         }
 
-        if((int) audio_capture_channels <= device_info->maxInputChannels) {
-                inputParameters.channelCount = audio_capture_channels;
-        } else {
+        inputParameters.channelCount = s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : MAX(device_info->maxInputChannels, DEFAULT_AUDIO_CAPTURE_CHANNELS);
+        if (s->frame.ch_count > device_info->maxInputChannels) {
                 fprintf(stderr, MODULE_NAME "Requested %d input channels, device offers only %d.\n",
-                                audio_capture_channels,
+                                s->frame.ch_count,
                                 device_info->maxInputChannels);
                 free(s);
 		return NULL;
@@ -258,7 +257,6 @@ static void * audio_cap_portaudio_init(const char *cfg)
 		return NULL;
 	}
 
-        s->frame.ch_count = inputParameters.channelCount;
         s->frame.max_size = (s->frame.bps * s->frame.ch_count) * s->frame.sample_rate / 1000 * BUF_MS;
         
         s->frame.data = (char*)malloc(s->frame.max_size);
diff --git a/src/audio/capture/testcard.cpp b/src/audio/capture/testcard.cpp
index 005175336..ffc0223ae 100644
--- a/src/audio/capture/testcard.cpp
+++ b/src/audio/capture/testcard.cpp
@@ -220,7 +220,7 @@ static void * audio_cap_testcard_init(const char *cfg)
         case EBU:
         case SILENCE:
         {
-                s->audio.ch_count = audio_capture_channels;
+                s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
                 s->audio.sample_rate = audio_capture_sample_rate ? audio_capture_sample_rate :
                         DEFAULT_AUDIO_SAMPLE_RATE;
                 s->audio.bps = audio_capture_bps ? audio_capture_bps : DEFAULT_AUDIO_BPS;
diff --git a/src/audio/capture/wasapi.cpp b/src/audio/capture/wasapi.cpp
index 7bd88a9ab..2a1a22b2e 100644
--- a/src/audio/capture/wasapi.cpp
+++ b/src/audio/capture/wasapi.cpp
@@ -265,7 +265,7 @@ static void * audio_cap_wasapi_init(const char *cfg)
                 // get the mixer format
                 THROW_IF_FAILED(s->pAudioClient->GetMixFormat(&pwfx));
                 // set our preferences
-                if (audio_capture_channels) {
+                if (audio_capture_channels != 0) {
                         pwfx->nChannels = audio_capture_channels;
                 }
                 if (audio_capture_sample_rate) {
@@ -327,9 +327,8 @@ static void * audio_cap_wasapi_init(const char *cfg)
 
         } catch (ug_runtime_error &e) {
                 LOG(LOG_LEVEL_ERROR) << MOD_NAME << e.what() << "\n";
-                if (audio_capture_channels != DEFAULT_AUDIO_CAPTURE_CHANNELS) {
-                        LOG(LOG_LEVEL_INFO) << MOD_NAME << "Maybe wrong number of channels? Default: "
-                                << DEFAULT_AUDIO_CAPTURE_CHANNELS << ", requested: " << audio_capture_channels << "\n";
+                if (audio_capture_channels != 0) {
+                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Maybe wrong number of channels? Try using default.";
                 }
                 CoUninitialize();
                 delete s;
diff --git a/src/host.cpp b/src/host.cpp
index 2fe86905d..f5953dd13 100644
--- a/src/host.cpp
+++ b/src/host.cpp
@@ -84,7 +84,7 @@
 using rang::style;
 using namespace std;
 
-unsigned int audio_capture_channels = DEFAULT_AUDIO_CAPTURE_CHANNELS;
+unsigned int audio_capture_channels = 0;
 unsigned int audio_capture_bps = 0;
 unsigned int audio_capture_sample_rate = 0;
 
diff --git a/src/host.h b/src/host.h
index 1b8b5eb27..980c7e5fd 100644
--- a/src/host.h
+++ b/src/host.h
@@ -83,7 +83,8 @@ void error(int status);
 void exit_uv(int status);
 
 #define DEFAULT_AUDIO_CAPTURE_CHANNELS 1
-extern unsigned int audio_capture_channels;
+extern unsigned int audio_capture_channels;    ///< user-specified chan. count, if zero, module should choose
+                                               ///< best/native or DEFAULT_AUDIO_CAPTURE_CHANNELS
 extern unsigned int audio_capture_bps;         // user-specified bps, if zero, module should choose
                                                // best bps by itself
 extern unsigned int audio_capture_sample_rate; // user-specified sample rate, if zero, module should
diff --git a/src/video_capture/aja.cpp b/src/video_capture/aja.cpp
index ddffbb44b..ac6bff5e0 100644
--- a/src/video_capture/aja.cpp
+++ b/src/video_capture/aja.cpp
@@ -713,9 +713,10 @@ AJAStatus vidcap_state_aja::SetupAudio (void)
 #endif
 
         mMaxAudioChannels = ::NTV2DeviceGetMaxAudioChannels (mDeviceID);
-        if (mMaxAudioChannels < (int) *aja_audio_capture_channels) {
+        mAudio.ch_count = *aja_audio_capture_channels > 0 ? *aja_audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
+        if (mMaxAudioChannels < mAudio.ch_count) {
                 LOG(LOG_LEVEL_ERROR) << MOD_NAME "Invalid number of capture channels requested. Requested " <<
-                        *aja_audio_capture_channels << ", maximum " << mMaxAudioChannels << endl;
+                        mAudio.ch_count << ", maximum " << mMaxAudioChannels << endl;
                 return AJA_STATUS_FAIL;
         }
         if (!mDevice.SetNumberAudioChannels (mMaxAudioChannels, NTV2InputSourceToAudioSystem(mInputSource))) {
@@ -747,7 +748,6 @@ AJAStatus vidcap_state_aja::SetupAudio (void)
         mAudio.bps = 4;
         mAudio.sample_rate = 48000;
         mAudio.data = (char *) malloc(NTV2_AUDIOSIZE_MAX);
-        mAudio.ch_count = *aja_audio_capture_channels;
         mAudio.max_size = NTV2_AUDIOSIZE_MAX;
 
 #ifndef _MSC_VER
diff --git a/src/video_capture/bluefish444.cpp b/src/video_capture/bluefish444.cpp
index eecd0aa49..8247a83c7 100644
--- a/src/video_capture/bluefish444.cpp
+++ b/src/video_capture/bluefish444.cpp
@@ -377,9 +377,10 @@ static bool setup_audio(struct vidcap_bluefish444_state *s, unsigned int flags)
 {
         memset(&s->objHancDecode, 0, sizeof(s->objHancDecode));
 
+        s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
         s->objHancDecode.audio_ch_required_mask = 0;
         /* MONO_CHANNEL_9 and _10 are used for analog output */
-        switch(audio_capture_channels) {
+        switch (s->audio.ch_count) {
                 case 16:
                         s->objHancDecode.audio_ch_required_mask |= MONO_CHANNEL_18;
                         // fall through
@@ -444,7 +445,6 @@ static bool setup_audio(struct vidcap_bluefish444_state *s, unsigned int flags)
         }
 
         s->audio.bps = 2;
-        s->audio.ch_count = audio_capture_channels;
         s->audio.sample_rate = 48000; // perhaps the driver does not support different
         s->audio.max_size = 4*4096*16;
 
diff --git a/src/video_capture/decklink.cpp b/src/video_capture/decklink.cpp
index 1b12dcdc5..2c60b72e8 100644
--- a/src/video_capture/decklink.cpp
+++ b/src/video_capture/decklink.cpp
@@ -9,7 +9,7 @@
  *          Dalibor Matura   <255899@mail.muni.cz>
  *          Ian Wesley-Smith <iwsmith@cct.lsu.edu>
  *
- * Copyright (c) 2005-2019 CESNET z.s.p.o.
+ * Copyright (c) 2005-2020 CESNET z.s.p.o.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, is permitted provided that the following conditions
@@ -52,6 +52,7 @@
 #include "config_unix.h"
 #include "config_win32.h"
 
+#include <algorithm>
 #include <cassert>
 #include <condition_variable>
 #include <chrono>
@@ -63,7 +64,6 @@
 #include <set>
 #include <string>
 #include <vector>
-#include <algorithm>
 
 #include "blackmagic_common.h"
 #include "audio/audio.h"
@@ -302,7 +302,7 @@ public:
                                         bmdAudioSampleRate48kHz,
                                         s->audio.bps == 2 ? bmdAudioSampleType16bitInteger :
                                                 bmdAudioSampleType32bitInteger,
-                                        audio_capture_channels == 1 ? 2 : audio_capture_channels); // BMD isn't able to grab single channel
+                                        max(s->audio.ch_count, 2)); // BMD isn't able to grab single channel
                         }
                         //deckLinkInput->SetCallback(s->state[i].delegate);
                         deckLinkInput->FlushStreams();
@@ -1085,7 +1085,7 @@ vidcap_decklink_init(struct vidcap_params *params, void **state)
                                 log_msg(LOG_LEVEL_WARNING, "[Decklink] Ignoring unsupported sample rate!\n");
                 }
                 s->audio.sample_rate = 48000;
-                s->audio.ch_count = audio_capture_channels;
+                s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
                 s->audio.max_size = (s->audio.sample_rate / 10) * s->audio.ch_count * s->audio.bps;
                 s->audio.data = (char *) malloc(s->audio.max_size);
         } else {
@@ -1354,12 +1354,12 @@ vidcap_decklink_init(struct vidcap_params *params, void **state)
                                 fprintf(stderr, "[Decklink capture] Unable to set audio input!!! Please check if it is OK. Continuing anyway.\n");
 
                         }
-                        if (audio_capture_channels != 1 &&
-                                        audio_capture_channels != 2 &&
-                                        audio_capture_channels != 8 &&
-                                        audio_capture_channels != 16) {
+                        if (s->audio.ch_count != 1 &&
+                                        s->audio.ch_count != 2 &&
+                                        s->audio.ch_count != 8 &&
+                                        s->audio.ch_count != 16) {
                                 fprintf(stderr, "[DeckLink] Decklink cannot grab %d audio channels. "
-                                                "Only 1, 2, 8 or 16 are possible.", audio_capture_channels);
+                                                "Only 1, 2, 8 or 16 are possible.", s->audio.ch_count);
                                 goto error;
                         }
                         if (s->audio_consumer_levels != -1) {
@@ -1372,7 +1372,7 @@ vidcap_decklink_init(struct vidcap_params *params, void **state)
                         CALL_AND_CHECK(deckLinkInput->EnableAudioInput(
                                                 bmdAudioSampleRate48kHz,
                                                 s->audio.bps == 2 ? bmdAudioSampleType16bitInteger : bmdAudioSampleType32bitInteger,
-                                                audio_capture_channels == 1 ? 2 : audio_capture_channels),
+                                                max(s->audio.ch_count, 2)), // capture at least 2
                                         "EnableAudioInput",
                                         "Decklink audio capture initialized sucessfully: " << audio_desc_from_frame(&s->audio));
                 }
@@ -1541,7 +1541,7 @@ static audio_frame *process_new_audio_packets(struct vidcap_decklink_state *s) {
                 void *audioFrame = nullptr;
                 audioPacket->GetBytes(&audioFrame);
 
-                if(audio_capture_channels == 1) { // there are actually 2 channels grabbed
+                if (s->audio.ch_count == 1) { // there are actually 2 channels grabbed
                         if (s->audio.data_len + audioPacket->GetSampleFrameCount() * 1U * s->audio.bps <= static_cast<unsigned>(s->audio.max_size)) {
                                 demux_channel(s->audio.data + s->audio.data_len, static_cast<char *>(audioFrame), s->audio.bps, min<int64_t>(audioPacket->GetSampleFrameCount() * 2 /* channels */ * s->audio.bps, INT_MAX), 2 /* channels (originally) */, 0 /* we want first channel */);
                                 s->audio.data_len = min<int64_t>(s->audio.data_len + audioPacket->GetSampleFrameCount() * 1 * s->audio.bps, INT_MAX);
@@ -1549,9 +1549,9 @@ static audio_frame *process_new_audio_packets(struct vidcap_decklink_state *s) {
                                 LOG(LOG_LEVEL_WARNING) << "[DeckLink] Audio frame too small!\n";
                         }
                 } else {
-                        if (s->audio.data_len + audioPacket->GetSampleFrameCount() * audio_capture_channels * s->audio.bps <= static_cast<unsigned>(s->audio.max_size)) {
-                                memcpy(s->audio.data + s->audio.data_len, audioFrame, audioPacket->GetSampleFrameCount() * audio_capture_channels * s->audio.bps);
-                                s->audio.data_len = min<int64_t>(s->audio.data_len + audioPacket->GetSampleFrameCount() * audio_capture_channels * s->audio.bps, INT_MAX);
+                        if (s->audio.data_len + audioPacket->GetSampleFrameCount() * s->audio.ch_count * s->audio.bps <= static_cast<unsigned>(s->audio.max_size)) {
+                                memcpy(s->audio.data + s->audio.data_len, audioFrame, audioPacket->GetSampleFrameCount() * s->audio.ch_count * s->audio.bps);
+                                s->audio.data_len = min<int64_t>(s->audio.data_len + audioPacket->GetSampleFrameCount() * s->audio.ch_count * s->audio.bps, INT_MAX);
                         } else {
                                 LOG(LOG_LEVEL_WARNING) << "[DeckLink] Audio frame too small!\n";
                         }
diff --git a/src/video_capture/deltacast.cpp b/src/video_capture/deltacast.cpp
index 1fe8c40b7..22c96c552 100644
--- a/src/video_capture/deltacast.cpp
+++ b/src/video_capture/deltacast.cpp
@@ -52,6 +52,7 @@
 #include "audio/utils.h"
 #include "deltacast_common.hpp"
 
+#include <algorithm>
 #include <stdio.h>
 #include <stdlib.h>
 #include <fcntl.h>
@@ -279,21 +280,17 @@ static bool wait_for_channel(struct vidcap_deltacast_state *s)
         }
 
         if ((s->initialize_flags & VIDCAP_FLAG_AUDIO_EMBEDDED) == 0u) {
-                if(audio_capture_channels != 1 &&
-                                audio_capture_channels != 2) {
+                s->audio_frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : max(DEFAULT_AUDIO_CAPTURE_CHANNELS, 2);
+                if (s->audio_frame.ch_count != 1 &&
+                                s->audio_frame.ch_count != 2) {
                         log_msg(LOG_LEVEL_ERROR, "[DELTACAST capture] Unable to handle channel count other than 1 or 2.\n");
                         throw delta_init_exception();
                 }
                 s->audio_frame.bps = 3;
                 s->audio_frame.sample_rate = 48000;
-                s->audio_frame.ch_count = audio_capture_channels;
                 memset(&s->AudioInfo, 0, sizeof(VHD_AUDIOINFO));
                 s->pAudioChn = &s->AudioInfo.pAudioGroups[0].pAudioChannels[0];
-                if(audio_capture_channels == 1) {
-                        s->pAudioChn->Mode = s->AudioInfo.pAudioGroups[0].pAudioChannels[1].Mode=VHD_AM_MONO;
-                } else if(audio_capture_channels == 2) {
-                        s->pAudioChn->Mode = s->AudioInfo.pAudioGroups[0].pAudioChannels[1].Mode=VHD_AM_STEREO;
-                } else abort();
+                s->pAudioChn->Mode = s->AudioInfo.pAudioGroups[0].pAudioChannels[1].Mode= s->audio_frame.ch_count == 1 ? VHD_AM_MONO : VHD_AM_STEREO;
                 s->pAudioChn->BufferFormat = s->AudioInfo.pAudioGroups[0].pAudioChannels[1].BufferFormat=VHD_AF_24;
 
                 /* Get the biggest audio frame size */
diff --git a/src/video_capture/dvs.c b/src/video_capture/dvs.c
index 86fd46da3..475cebb3e 100644
--- a/src/video_capture/dvs.c
+++ b/src/video_capture/dvs.c
@@ -482,17 +482,17 @@ static int vidcap_dvs_init(struct vidcap_params *params, void **state)
                 if (res != SV_OK) {
                         goto error;
                 }
-                if(audio_capture_channels != 2 && audio_capture_channels != 1) {
+                s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
+                if (s->audio.ch_count != 2 && s->audio.ch_count != 1) {
                         fprintf(stderr, "[DVS cap.] Invalid channel count %d. "
                                         "Currently only 1 or 2 channels are supported.\n",
-                                        audio_capture_channels);
+                                        s->audio.ch_count);
                         goto error;
                 }
                 res = sv_option(s->sv, SV_OPTION_AUDIOCHANNELS, 1); // one pair
                 if (res != SV_OK) {
                         goto error;
                 }
-                s->audio.ch_count = audio_capture_channels;
 
                 sv_query(s->sv, SV_QUERY_AUDIOBITS, 0, &i);
                 s->audio.bps = i / 8;
@@ -504,7 +504,7 @@ static int vidcap_dvs_init(struct vidcap_params *params, void **state)
                 s->audio_bufs[0] = malloc(s->audio.sample_rate * 2 * s->audio.bps);
                 s->audio_bufs[1] = malloc(s->audio.sample_rate * 2 * s->audio.bps);
 
-                if(audio_capture_channels == 1) {
+                if (s->audio.ch_count == 1) {
                         // data need to be demultiplexed
                         s->audio.max_size = s->audio.sample_rate * s->audio.bps;
                         s->audio.data = (char *) malloc(s->audio.max_size);
diff --git a/src/video_capture/ndi.cpp b/src/video_capture/ndi.cpp
index 29ca2c551..2d13518b7 100644
--- a/src/video_capture/ndi.cpp
+++ b/src/video_capture/ndi.cpp
@@ -49,6 +49,7 @@
 #endif
 
 #include <Processing.NDI.Lib.h>
+#include <algorithm>
 #include <array>
 #include <chrono>
 #include <iostream>
@@ -70,8 +71,11 @@
 #include "video.h"
 #include "video_capture.h"
 
+static constexpr const char *MOD_NAME = "[NDI] ";
+
 using std::array;
 using std::cout;
+using std::max;
 using std::string;
 using std::chrono::duration_cast;
 using std::chrono::steady_clock;
@@ -199,22 +203,27 @@ static void vidcap_ndi_done(void *state)
 
 static void audio_append(struct vidcap_state_ndi *s, NDIlib_audio_frame_v2_t *frame)
 {
-        struct audio_desc d{4, frame->sample_rate, static_cast<int>(audio_capture_channels), AC_PCM};
+        struct audio_desc d{4, frame->sample_rate, static_cast<int>(audio_capture_channels > 0 ? audio_capture_channels : frame->no_channels), AC_PCM};
         if (!audio_desc_eq(d, audio_desc_from_audio_frame(&s->audio[s->audio_buf_idx]))) {
                 free(s->audio[s->audio_buf_idx].data);
                 s->audio[s->audio_buf_idx].bps = 4;
                 s->audio[s->audio_buf_idx].sample_rate = frame->sample_rate;
-                s->audio[s->audio_buf_idx].ch_count = audio_capture_channels;
+                s->audio[s->audio_buf_idx].ch_count = d.ch_count;
                 s->audio[s->audio_buf_idx].data_len = 0;
                 s->audio[s->audio_buf_idx].max_size =
-                        4 * audio_capture_channels * frame->sample_rate / 5; // 200 ms
+                        4 * d.ch_count * frame->sample_rate / 5; // 200 ms
                 s->audio[s->audio_buf_idx].data = static_cast<char *>(malloc(s->audio[s->audio_buf_idx].max_size));
         }
 
+        if (frame->no_channels > s->audio[s->audio_buf_idx].ch_count) {
+                LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Requested " << s->audio[s->audio_buf_idx].ch_count << " channels, stream has only "
+                        << frame->no_channels << "!\n";
+        }
+
         for (int i = 0; i < frame->no_samples; ++i) {
                 float *in = frame->p_data + i;
-                int32_t *out = (int32_t *) s->audio[s->audio_buf_idx].data + i * audio_capture_channels;
-                for (int j = 0; j < static_cast<int>(audio_capture_channels); ++j) {
+                int32_t *out = (int32_t *) s->audio[s->audio_buf_idx].data + i * d.ch_count;
+                for (int j = 0; j < max(d.ch_count, frame->no_channels); ++j) {
                         if (s->audio[s->audio_buf_idx].data_len >= s->audio[s->audio_buf_idx].max_size) {
                                 LOG(LOG_LEVEL_WARNING) << "[NDI] Audio frame too small!\n";
                                 return;
diff --git a/src/video_capture/testcard.cpp b/src/video_capture/testcard.cpp
index f672c6b27..334254751 100644
--- a/src/video_capture/testcard.cpp
+++ b/src/video_capture/testcard.cpp
@@ -85,7 +85,7 @@
 #define AUDIO_BPS 2
 #define BUFFER_SEC 1
 #define AUDIO_BUFFER_SIZE (AUDIO_SAMPLE_RATE * AUDIO_BPS * \
-                audio_capture_channels * BUFFER_SEC)
+                s->audio.ch_count * BUFFER_SEC)
 #define MOD_NAME "[testcard] "
 constexpr video_desc default_format = { 1920, 1080, UYVY, 25.0, INTERLACED_MERGED, 1 };
 constexpr size_t headroom = 128; // headroom for cases when dst color_spec has wider block size
@@ -316,10 +316,17 @@ static int configure_audio(struct testcard_state *s)
         Mix_Music *music;
         ssize_t bytes_written = 0l;
 
+        s->audio_data = (char *) calloc(1, AUDIO_BUFFER_SIZE /* 1 sec */);
+        s->audio_start = 0;
+        s->audio_end = 0;
+        s->audio.bps = AUDIO_BPS;
+        s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
+        s->audio.sample_rate = AUDIO_SAMPLE_RATE;
+
         SDL_Init(SDL_INIT_AUDIO);
 
         if( Mix_OpenAudio( AUDIO_SAMPLE_RATE, AUDIO_S16LSB,
-                        audio_capture_channels, 4096 ) == -1 ) {
+                        s->audio.ch_count, 4096 ) == -1 ) {
                 fprintf(stderr,"[testcard] error initalizing sound\n");
                 return -1;
         }
@@ -340,13 +347,6 @@ static int configure_audio(struct testcard_state *s)
         close(fd);
         music = Mix_LoadMUS(filename);
 
-        s->audio_data = (char *) calloc(1, AUDIO_BUFFER_SIZE /* 1 sec */);
-        s->audio_start = 0;
-        s->audio_end = 0;
-        s->audio.bps = AUDIO_BPS;
-        s->audio.ch_count = audio_capture_channels;
-        s->audio.sample_rate = AUDIO_SAMPLE_RATE;
-
         // register grab as a postmix processor
         if(!Mix_RegisterEffect(MIX_CHANNEL_POST, grab_audio, NULL, s)) {
                 printf("[testcard] Mix_RegisterEffect: %s\n", Mix_GetError());
diff --git a/src/video_capture/testcard2.c b/src/video_capture/testcard2.c
index bcca31a04..88c1b7472 100644
--- a/src/video_capture/testcard2.c
+++ b/src/video_capture/testcard2.c
@@ -67,7 +67,7 @@
 #define AUDIO_BPS 2
 #define BUFFER_SEC 1
 #define AUDIO_BUFFER_SIZE (AUDIO_SAMPLE_RATE * AUDIO_BPS * \
-                audio_capture_channels * BUFFER_SEC)
+                s->audio.ch_count * BUFFER_SEC)
 
 void * vidcap_testcard2_thread(void *args);
 void rgb2yuv422(unsigned char *in, unsigned int width, unsigned int height);
@@ -100,22 +100,19 @@ struct testcard_state2 {
 
 static int configure_audio(struct testcard_state2 *s)
 {
-        int i;
+        s->audio.bps = AUDIO_BPS;
+        s->audio.ch_count = audio_capture_channels > 0 > audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
+        s->audio.sample_rate = AUDIO_SAMPLE_RATE;
         
         s->audio_silence = calloc(1, AUDIO_BUFFER_SIZE /* 1 sec */);
         
         s->audio_tone = calloc(1, AUDIO_BUFFER_SIZE /* 1 sec */);
         short int * data = (short int *) s->audio_tone;
-        for( i=0; i < (int) AUDIO_BUFFER_SIZE/2; i+=2 )
+        for(int i=0; i < (int) AUDIO_BUFFER_SIZE/2; i+=2 )
         {
                 data[i] = data[i+1] = (float) sin( ((double)i/(double)200) * M_PI * 2. ) * SHRT_MAX;
         }
 
-        
-        s->audio.bps = AUDIO_BPS;
-        s->audio.ch_count = audio_capture_channels;
-        s->audio.sample_rate = AUDIO_SAMPLE_RATE;
-        
         printf("[testcard2] playing audio\n");
         
         return 0;
@@ -499,7 +496,7 @@ static void grab_audio(struct testcard_state2 *s)
         
         s->audio_remained = (seconds + s->audio_remained) * AUDIO_SAMPLE_RATE - s->audio.data_len;
         s->audio_remained /= AUDIO_SAMPLE_RATE;
-        s->audio.data_len *= audio_capture_channels * AUDIO_BPS;
+        s->audio.data_len *= s->audio.ch_count * AUDIO_BPS;
         
         s->last_audio_time = curr_time;
 }