scottk/UltraGrid
1
0
Fork 0
mirror of https://github.com/outbackdingo/UltraGrid.git synced 2026-03-21 23:40:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

audio_capture_channels is now 0 for default

Browse Source 
Capturers may decide by themselves or capture DEFAULT_AUDIO_CAPTURE_CHANNELS
(as until now). This fixes default behavior of WASAPI with Realtek sound cards
that is unable to capture single channel.
This commit is contained in:
Martin Pulec
2020-09-09 14:27:26 +02:00
parent 87bd2cf368
commit 89747981da
16 changed files with 74 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/audio/capture/alsa.c
View File

@@ -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;

2
src/audio/capture/coreaudio.m
View File

@@ -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);

6
src/audio/capture/jack.c
View File

@@ -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");

8
src/audio/capture/portaudio.c
View File

@@ -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);

2
src/audio/capture/testcard.cpp
View File

@@ -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;

7
src/audio/capture/wasapi.cpp
View File

@@ -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;

2
src/host.cpp
View File

@@ -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;

3
src/host.h
View File

@@ -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

6
src/video_capture/aja.cpp
View File

@@ -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

4
src/video_capture/bluefish444.cpp
View File

@@ -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;

28
src/video_capture/decklink.cpp
View File

@@ -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";
}

13
src/video_capture/deltacast.cpp
View File

@@ -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 */

8
src/video_capture/dvs.c
View File

@@ -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);

19
src/video_capture/ndi.cpp
View File

@@ -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;

18
src/video_capture/testcard.cpp
View File

@@ -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());

15
src/video_capture/testcard2.c
View File

@@ -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;
}