20#include <freerdp/config.h>
22#include <winpr/assert.h>
29#include <freerdp/types.h>
30#include <freerdp/log.h>
31#include <freerdp/codec/dsp.h>
35#if defined(WITH_FDK_AAC)
36#include "dsp_fdk_aac.h"
39#if !defined(WITH_DSP_FFMPEG)
51#define OPUS_MAX_FRAMES 5760
54#if defined(WITH_FAAD2)
67#include "dsp_ffmpeg.h"
70#if !defined(WITH_DSP_FFMPEG)
72#define TAG FREERDP_TAG("dsp")
91struct S_FREERDP_DSP_CONTEXT
100#if defined(WITH_LAME)
104#if defined(WITH_OPUS)
105 OpusDecoder* opus_decoder;
106 OpusEncoder* opus_encoder;
108#if defined(WITH_FAAD2)
113#if defined(WITH_FAAC)
115 unsigned long faacInputSamples;
116 unsigned long faacMaxOutputBytes;
119#if defined(WITH_SOXR)
124#if defined(WITH_OPUS)
125static BOOL opus_is_valid_samplerate(
const AUDIO_FORMAT* WINPR_RESTRICT format)
127 WINPR_ASSERT(format);
129 switch (format->nSamplesPerSec)
143static INT16 read_int16(
const BYTE* WINPR_RESTRICT src)
145 return (INT16)(src[0] | (src[1] << 8));
148static BOOL freerdp_dsp_channel_mix(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
149 const BYTE* WINPR_RESTRICT src,
size_t size,
151 const BYTE** WINPR_RESTRICT data,
size_t* WINPR_RESTRICT length)
153 if (!context || !data || !length)
156 if (srcFormat->wFormatTag != WAVE_FORMAT_PCM)
159 const UINT32 bpp = srcFormat->wBitsPerSample > 8 ? 2 : 1;
160 const size_t samples = size / bpp / srcFormat->nChannels;
162 if (context->common.format.nChannels == srcFormat->nChannels)
169 Stream_SetPosition(context->common.channelmix, 0);
172 if (context->common.format.nChannels > srcFormat->nChannels)
174 switch (srcFormat->nChannels)
177 if (!Stream_EnsureCapacity(context->common.channelmix, size * 2))
180 for (
size_t x = 0; x < samples; x++)
182 for (
size_t y = 0; y < bpp; y++)
183 Stream_Write_UINT8(context->common.channelmix, src[x * bpp + y]);
185 for (
size_t y = 0; y < bpp; y++)
186 Stream_Write_UINT8(context->common.channelmix, src[x * bpp + y]);
189 Stream_SealLength(context->common.channelmix);
190 *data = Stream_Buffer(context->common.channelmix);
191 *length = Stream_Length(context->common.channelmix);
201 switch (srcFormat->nChannels)
204 if (!Stream_EnsureCapacity(context->common.channelmix, size / 2))
209 for (
size_t x = 0; x < samples; x++)
211 for (
size_t y = 0; y < bpp; y++)
212 Stream_Write_UINT8(context->common.channelmix, src[2 * x * bpp + y]);
215 Stream_SealLength(context->common.channelmix);
216 *data = Stream_Buffer(context->common.channelmix);
217 *length = Stream_Length(context->common.channelmix);
233static BOOL freerdp_dsp_resample(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
234 const BYTE* WINPR_RESTRICT src,
size_t size,
236 const BYTE** WINPR_RESTRICT data,
size_t* WINPR_RESTRICT length)
238#if defined(WITH_SOXR)
241 size_t sframes, rframes;
243 size_t sbytes, rbytes;
246 size_t srcBytesPerFrame, dstBytesPerFrame;
250 if (srcFormat->wFormatTag != WAVE_FORMAT_PCM)
252 WLog_ERR(TAG,
"requires %s for sample input, got %s",
253 audio_format_get_tag_string(WAVE_FORMAT_PCM),
254 audio_format_get_tag_string(srcFormat->wFormatTag));
260 format.wFormatTag = WAVE_FORMAT_UNKNOWN;
261 format.wBitsPerSample = 0;
263 if (audio_format_compatible(&format, &context->common.format))
270#if defined(WITH_SOXR)
271 srcBytesPerFrame = (srcFormat->wBitsPerSample > 8) ? 2 : 1;
272 dstBytesPerFrame = (context->common.format.wBitsPerSample > 8) ? 2 : 1;
273 srcChannels = srcFormat->nChannels;
274 dstChannels = context->common.format.nChannels;
275 sbytes = srcChannels * srcBytesPerFrame;
276 sframes = size / sbytes;
277 rbytes = dstBytesPerFrame * dstChannels;
280 (sframes * context->common.format.nSamplesPerSec + (srcFormat->nSamplesPerSec + 1) / 2) /
281 srcFormat->nSamplesPerSec;
282 rsize = rframes * rbytes;
284 if (!Stream_EnsureCapacity(context->common.resample, rsize))
288 soxr_process(context->sox, src, sframes, &idone, Stream_Buffer(context->common.resample),
289 Stream_Capacity(context->common.resample) / rbytes, &odone);
290 Stream_SetLength(context->common.resample, odone * rbytes);
291 *data = Stream_Buffer(context->common.resample);
292 *length = Stream_Length(context->common.resample);
293 return (error == 0) ? TRUE : FALSE;
295 WLog_ERR(TAG,
"Missing resample support, recompile -DWITH_SOXR=ON or -DWITH_DSP_FFMPEG=ON");
307static const INT16 ima_step_index_table[] = {
308 -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8
311static const INT16 ima_step_size_table[] = {
312 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23,
313 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80,
314 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279,
315 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963,
316 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
317 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487,
318 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
321static UINT16 dsp_decode_ima_adpcm_sample(ADPCM* WINPR_RESTRICT adpcm,
unsigned int channel,
324 const INT32 ss = ima_step_size_table[adpcm->ima.last_step[channel]];
339 d += adpcm->ima.last_sample[channel];
346 adpcm->ima.last_sample[channel] = (INT16)d;
347 adpcm->ima.last_step[channel] += ima_step_index_table[sample];
349 if (adpcm->ima.last_step[channel] < 0)
350 adpcm->ima.last_step[channel] = 0;
351 else if (adpcm->ima.last_step[channel] > 88)
352 adpcm->ima.last_step[channel] = 88;
357static BOOL freerdp_dsp_decode_ima_adpcm(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
358 const BYTE* WINPR_RESTRICT src,
size_t size,
361 size_t out_size = size * 4;
362 const UINT32 block_size = context->common.format.nBlockAlign;
363 const UINT32 channels = context->common.format.nChannels;
365 if (!Stream_EnsureCapacity(out, out_size))
370 if (size % block_size == 0)
372 context->adpcm.ima.last_sample[0] =
373 (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));
374 context->adpcm.ima.last_step[0] = (INT16)(*(src + 2));
381 context->adpcm.ima.last_sample[1] =
382 (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));
383 context->adpcm.ima.last_step[1] = (INT16)(*(src + 2));
392 for (
size_t i = 0; i < 8; i++)
394 BYTE* dst = Stream_Pointer(out);
396 const int channel = (i < 4 ? 0 : 1);
398 const BYTE sample = ((*src) & 0x0f);
399 const UINT16 decoded =
400 dsp_decode_ima_adpcm_sample(&context->adpcm, channel, sample);
401 dst[((i & 3) << 3) + (channel << 1)] = (decoded & 0xFF);
402 dst[((i & 3) << 3) + (channel << 1) + 1] = (decoded >> 8);
405 const BYTE sample = ((*src) >> 4);
406 const UINT16 decoded =
407 dsp_decode_ima_adpcm_sample(&context->adpcm, channel, sample);
408 dst[((i & 3) << 3) + (channel << 1) + 4] = (decoded & 0xFF);
409 dst[((i & 3) << 3) + (channel << 1) + 5] = (decoded >> 8);
414 if (!Stream_SafeSeek(out, 32))
420 BYTE* dst = Stream_Pointer(out);
421 if (!Stream_SafeSeek(out, 4))
425 const BYTE sample = ((*src) & 0x0f);
426 const UINT16 decoded = dsp_decode_ima_adpcm_sample(&context->adpcm, 0, sample);
427 *dst++ = (decoded & 0xFF);
428 *dst++ = (decoded >> 8);
431 const BYTE sample = ((*src) >> 4);
432 const UINT16 decoded = dsp_decode_ima_adpcm_sample(&context->adpcm, 0, sample);
433 *dst++ = (decoded & 0xFF);
434 *dst++ = (decoded >> 8);
445static BOOL freerdp_dsp_decode_gsm610(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
446 const BYTE* WINPR_RESTRICT src,
size_t size,
451 while (offset < size)
454 gsm_signal gsmBlockBuffer[160] = { 0 };
455 rc = gsm_decode(context->gsm, (gsm_byte*) &src[offset],
461 if ((offset % 65) == 0)
466 if (!Stream_EnsureRemainingCapacity(out,
sizeof(gsmBlockBuffer)))
469 Stream_Write(out, (
void*)gsmBlockBuffer,
sizeof(gsmBlockBuffer));
475static BOOL freerdp_dsp_encode_gsm610(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
476 const BYTE* WINPR_RESTRICT src,
size_t size,
481 while (offset < size)
483 const gsm_signal* signal = (
const gsm_signal*)&src[offset];
485 if (!Stream_EnsureRemainingCapacity(out,
sizeof(gsm_frame)))
488 gsm_encode(context->gsm, (gsm_signal*) signal,
489 Stream_Pointer(out));
491 if ((offset % 65) == 0)
492 Stream_Seek(out, 33);
494 Stream_Seek(out, 32);
503#if defined(WITH_LAME)
504static BOOL freerdp_dsp_decode_mp3(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
505 const BYTE* WINPR_RESTRICT src,
size_t size,
513 if (!context || !src || !out)
516 buffer_size = 2 * context->common.format.nChannels * context->common.format.nSamplesPerSec;
518 if (!Stream_EnsureCapacity(context->common.buffer, 2 * buffer_size))
521 pcm_l = Stream_BufferAs(context->common.buffer,
short);
522 pcm_r = Stream_BufferAs(context->common.buffer,
short) + buffer_size;
523 rc = hip_decode(context->hip, (
unsigned char*) src, size,
529 if (!Stream_EnsureRemainingCapacity(out, (
size_t)rc * context->common.format.nChannels * 2))
532 for (
size_t x = 0; x < rc; x++)
534 Stream_Write_UINT16(out, (UINT16)pcm_l[x]);
535 Stream_Write_UINT16(out, (UINT16)pcm_r[x]);
541static BOOL freerdp_dsp_encode_mp3(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
542 const BYTE* WINPR_RESTRICT src,
size_t size,
545 size_t samples_per_channel;
548 if (!context || !src || !out)
551 samples_per_channel =
552 size / context->common.format.nChannels / context->common.format.wBitsPerSample / 8;
555 if (!Stream_EnsureRemainingCapacity(out, 5 / 4 * samples_per_channel + 7200))
558 samples_per_channel = size / 2 / context->common.format.nChannels;
559 rc = lame_encode_buffer_interleaved(context->lame, (
short*)src, samples_per_channel,
560 Stream_Pointer(out), Stream_GetRemainingCapacity(out));
565 Stream_Seek(out, (
size_t)rc);
570#if defined(WITH_FAAC)
571static BOOL freerdp_dsp_encode_faac(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
572 const BYTE* WINPR_RESTRICT src,
size_t size,
575 const int16_t* inSamples = (
const int16_t*)src;
580 if (!context || !src || !out)
583 bpp = context->common.format.wBitsPerSample / 8;
584 nrSamples = size / bpp;
586 if (!Stream_EnsureRemainingCapacity(context->common.buffer, nrSamples *
sizeof(int16_t)))
589 for (
size_t x = 0; x < nrSamples; x++)
591 Stream_Write_INT16(context->common.buffer, inSamples[x]);
592 if (Stream_GetPosition(context->common.buffer) / bpp >= context->faacInputSamples)
594 if (!Stream_EnsureRemainingCapacity(out, context->faacMaxOutputBytes))
596 rc = faacEncEncode(context->faac, Stream_BufferAs(context->common.buffer, int32_t),
597 context->faacInputSamples, Stream_Pointer(out),
598 Stream_GetRemainingCapacity(out));
602 Stream_Seek(out, (
size_t)rc);
603 Stream_SetPosition(context->common.buffer, 0);
611#if defined(WITH_OPUS)
612static BOOL freerdp_dsp_decode_opus(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
613 const BYTE* WINPR_RESTRICT src,
size_t size,
616 size_t max_size = 5760;
619 if (!context || !src || !out)
623 max_size = OPUS_MAX_FRAMES * context->common.format.nChannels *
sizeof(int16_t);
624 if (!Stream_EnsureRemainingCapacity(context->common.buffer, max_size))
627 frames = opus_decode(context->opus_decoder, src, WINPR_ASSERTING_INT_CAST(opus_int32, size),
628 Stream_Pointer(out), OPUS_MAX_FRAMES, 0);
632 Stream_Seek(out, frames * context->common.format.nChannels *
sizeof(int16_t));
637static BOOL freerdp_dsp_encode_opus(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
638 const BYTE* WINPR_RESTRICT src,
size_t size,
641 if (!context || !src || !out)
645 const size_t max_size = OPUS_MAX_FRAMES * context->common.format.nChannels *
sizeof(int16_t);
646 if (!Stream_EnsureRemainingCapacity(context->common.buffer, max_size))
649 const size_t src_frames = size /
sizeof(opus_int16) / context->common.format.nChannels;
650 const opus_int16* src_data = (
const opus_int16*)src;
651 const int frames = opus_encode(
652 context->opus_encoder, src_data, WINPR_ASSERTING_INT_CAST(opus_int32, src_frames),
653 Stream_Pointer(out), WINPR_ASSERTING_INT_CAST(opus_int32, max_size));
656 return Stream_SafeSeek(out, frames * context->common.format.nChannels *
sizeof(int16_t));
660#if defined(WITH_FAAD2)
661static BOOL freerdp_dsp_decode_faad(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
662 const BYTE* WINPR_RESTRICT src,
size_t size,
665 NeAACDecFrameInfo info;
668 if (!context || !src || !out)
671 if (!context->faadSetup)
678 unsigned long samplerate;
679 unsigned char channels;
682 err = NeAACDecInit(context->faad, cnv.pv, size,
683 &samplerate, &channels);
688 if (channels != context->common.format.nChannels)
691 if (samplerate != context->common.format.nSamplesPerSec)
694 context->faadSetup = TRUE;
697 while (offset < size)
706 outSize = context->common.format.nSamplesPerSec * context->common.format.nChannels *
707 context->common.format.wBitsPerSample / 8;
709 if (!Stream_EnsureRemainingCapacity(out, outSize))
712 sample_buffer = Stream_Pointer(out);
714 cnv.cpv = &src[offset];
715 NeAACDecDecode2(context->faad, &info, cnv.pv, size - offset, &sample_buffer,
716 Stream_GetRemainingCapacity(out));
721 offset += info.bytesconsumed;
723 if (info.samples == 0)
726 Stream_Seek(out, info.samples * context->common.format.wBitsPerSample / 8);
745} ima_stereo_encode_map[] = { { 0, 0 }, { 4, 0 }, { 0, 4 }, { 4, 4 }, { 1, 0 }, { 5, 0 },
746 { 1, 4 }, { 5, 4 }, { 2, 0 }, { 6, 0 }, { 2, 4 }, { 6, 4 },
747 { 3, 0 }, { 7, 0 }, { 3, 4 }, { 7, 4 } };
749static BYTE dsp_encode_ima_adpcm_sample(ADPCM* WINPR_RESTRICT adpcm,
int channel, INT16 sample)
751 INT32 ss = ima_step_size_table[adpcm->ima.last_step[channel]];
752 INT32 e = sample - adpcm->ima.last_sample[channel];
754 INT32 diff = ss >> 3;
790 diff += adpcm->ima.last_sample[channel];
794 else if (diff > 32767)
797 adpcm->ima.last_sample[channel] = (INT16)diff;
798 adpcm->ima.last_step[channel] += ima_step_index_table[enc];
800 if (adpcm->ima.last_step[channel] < 0)
801 adpcm->ima.last_step[channel] = 0;
802 else if (adpcm->ima.last_step[channel] > 88)
803 adpcm->ima.last_step[channel] = 88;
808static BOOL freerdp_dsp_encode_ima_adpcm(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
809 const BYTE* WINPR_RESTRICT src,
size_t size,
812 if (!Stream_EnsureRemainingCapacity(out, size))
814 if (!Stream_EnsureRemainingCapacity(context->common.buffer, size + 64))
817 const size_t align = (context->common.format.nChannels > 1) ? 32 : 4;
819 while (size >= align)
821 if (Stream_GetPosition(context->common.buffer) % context->common.format.nBlockAlign == 0)
823 Stream_Write_UINT8(context->common.buffer, context->adpcm.ima.last_sample[0] & 0xFF);
824 Stream_Write_UINT8(context->common.buffer,
825 (context->adpcm.ima.last_sample[0] >> 8) & 0xFF);
826 Stream_Write_UINT8(context->common.buffer, (BYTE)context->adpcm.ima.last_step[0]);
827 Stream_Write_UINT8(context->common.buffer, 0);
829 if (context->common.format.nChannels > 1)
831 Stream_Write_UINT8(context->common.buffer,
832 context->adpcm.ima.last_sample[1] & 0xFF);
833 Stream_Write_UINT8(context->common.buffer,
834 (context->adpcm.ima.last_sample[1] >> 8) & 0xFF);
835 Stream_Write_UINT8(context->common.buffer, (BYTE)context->adpcm.ima.last_step[1]);
836 Stream_Write_UINT8(context->common.buffer, 0);
840 if (context->common.format.nChannels > 1)
842 BYTE* dst = Stream_Pointer(context->common.buffer);
845 for (
size_t i = 0; i < 16; i++)
847 const INT16 sample = (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));
849 const BYTE encoded = dsp_encode_ima_adpcm_sample(&context->adpcm, i % 2, sample);
850 dst[ima_stereo_encode_map[i].byte_num] |= encoded
851 << ima_stereo_encode_map[i].byte_shift;
854 if (!Stream_SafeSeek(context->common.buffer, 8))
860 INT16 sample = (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));
862 BYTE encoded = dsp_encode_ima_adpcm_sample(&context->adpcm, 0, sample);
863 sample = (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));
865 encoded |= dsp_encode_ima_adpcm_sample(&context->adpcm, 0, sample) << 4;
866 Stream_Write_UINT8(context->common.buffer, encoded);
870 if (Stream_GetPosition(context->common.buffer) >= context->adpcm.ima.packet_size)
872 BYTE* bsrc = Stream_Buffer(context->common.buffer);
873 Stream_Write(out, bsrc, context->adpcm.ima.packet_size);
874 Stream_SetPosition(context->common.buffer, 0);
887static const INT32 ms_adpcm_adaptation_table[] = { 230, 230, 230, 230, 307, 409, 512, 614,
888 768, 614, 512, 409, 307, 230, 230, 230 };
890static const INT32 ms_adpcm_coeffs1[7] = { 256, 512, 0, 192, 240, 460, 392 };
892static const INT32 ms_adpcm_coeffs2[7] = { 0, -256, 0, 64, 0, -208, -232 };
894static INLINE INT16 freerdp_dsp_decode_ms_adpcm_sample(ADPCM* WINPR_RESTRICT adpcm, BYTE sample,
897 const INT8 nibble = (sample & 0x08 ? (INT8)sample - 16 : (INT8)sample);
899 ((adpcm->ms.sample1[channel] * ms_adpcm_coeffs1[adpcm->ms.predictor[channel]]) +
900 (adpcm->ms.sample2[channel] * ms_adpcm_coeffs2[adpcm->ms.predictor[channel]])) /
902 presample += nibble * adpcm->ms.delta[channel];
904 if (presample > 32767)
906 else if (presample < -32768)
909 adpcm->ms.sample2[channel] = adpcm->ms.sample1[channel];
910 adpcm->ms.sample1[channel] = presample;
911 adpcm->ms.delta[channel] = adpcm->ms.delta[channel] * ms_adpcm_adaptation_table[sample] / 256;
913 if (adpcm->ms.delta[channel] < 16)
914 adpcm->ms.delta[channel] = 16;
916 return (INT16)presample;
919static BOOL freerdp_dsp_decode_ms_adpcm(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
920 const BYTE* WINPR_RESTRICT src,
size_t size,
923 const size_t out_size = size * 4;
924 const UINT32 channels = context->common.format.nChannels;
925 const UINT32 block_size = context->common.format.nBlockAlign;
927 if (!Stream_EnsureCapacity(out, out_size))
932 if (size % block_size == 0)
936 context->adpcm.ms.predictor[0] = *src++;
937 context->adpcm.ms.predictor[1] = *src++;
938 context->adpcm.ms.delta[0] = read_int16(src);
940 context->adpcm.ms.delta[1] = read_int16(src);
942 context->adpcm.ms.sample1[0] = read_int16(src);
944 context->adpcm.ms.sample1[1] = read_int16(src);
946 context->adpcm.ms.sample2[0] = read_int16(src);
948 context->adpcm.ms.sample2[1] = read_int16(src);
951 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample2[0]);
952 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample2[1]);
953 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample1[0]);
954 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample1[1]);
958 context->adpcm.ms.predictor[0] = *src++;
959 context->adpcm.ms.delta[0] = read_int16(src);
961 context->adpcm.ms.sample1[0] = read_int16(src);
963 context->adpcm.ms.sample2[0] = read_int16(src);
966 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample2[0]);
967 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample1[0]);
974 const BYTE sample = *src++;
977 out, freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample >> 4, 0));
979 out, freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample & 0x0F, 1));
982 const BYTE sample = *src++;
985 out, freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample >> 4, 0));
987 out, freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample & 0x0F, 1));
992 const BYTE sample = *src++;
994 Stream_Write_INT16(out,
995 freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample >> 4, 0));
997 out, freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample & 0x0F, 0));
1004static BYTE freerdp_dsp_encode_ms_adpcm_sample(ADPCM* WINPR_RESTRICT adpcm, INT32 sample,
1008 ((adpcm->ms.sample1[channel] * ms_adpcm_coeffs1[adpcm->ms.predictor[channel]]) +
1009 (adpcm->ms.sample2[channel] * ms_adpcm_coeffs2[adpcm->ms.predictor[channel]])) /
1011 INT32 errordelta = (sample - presample) / adpcm->ms.delta[channel];
1013 if ((sample - presample) % adpcm->ms.delta[channel] > adpcm->ms.delta[channel] / 2)
1018 else if (errordelta < -8)
1021 presample += adpcm->ms.delta[channel] * errordelta;
1023 if (presample > 32767)
1025 else if (presample < -32768)
1028 adpcm->ms.sample2[channel] = adpcm->ms.sample1[channel];
1029 adpcm->ms.sample1[channel] = presample;
1030 adpcm->ms.delta[channel] =
1031 adpcm->ms.delta[channel] * ms_adpcm_adaptation_table[(((BYTE)errordelta) & 0x0F)] / 256;
1033 if (adpcm->ms.delta[channel] < 16)
1034 adpcm->ms.delta[channel] = 16;
1036 return ((BYTE)errordelta) & 0x0F;
1039static BOOL freerdp_dsp_encode_ms_adpcm(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
1040 const BYTE* WINPR_RESTRICT src,
size_t size,
1043 const size_t step = 8 + ((context->common.format.nChannels > 1) ? 4 : 0);
1045 if (!Stream_EnsureRemainingCapacity(out, size))
1048 const size_t start = Stream_GetPosition(out);
1050 if (context->adpcm.ms.delta[0] < 16)
1051 context->adpcm.ms.delta[0] = 16;
1053 if (context->adpcm.ms.delta[1] < 16)
1054 context->adpcm.ms.delta[1] = 16;
1056 while (size >= step)
1058 if ((Stream_GetPosition(out) - start) % context->common.format.nBlockAlign == 0)
1060 if (context->common.format.nChannels > 1)
1062 Stream_Write_UINT8(out, context->adpcm.ms.predictor[0]);
1063 Stream_Write_UINT8(out, context->adpcm.ms.predictor[1]);
1064 Stream_Write_UINT8(out, (context->adpcm.ms.delta[0] & 0xFF));
1065 Stream_Write_UINT8(out, ((context->adpcm.ms.delta[0] >> 8) & 0xFF));
1066 Stream_Write_UINT8(out, (context->adpcm.ms.delta[1] & 0xFF));
1067 Stream_Write_UINT8(out, ((context->adpcm.ms.delta[1] >> 8) & 0xFF));
1069 context->adpcm.ms.sample1[0] = read_int16(src + 4);
1070 context->adpcm.ms.sample1[1] = read_int16(src + 6);
1071 context->adpcm.ms.sample2[0] = read_int16(src + 0);
1072 context->adpcm.ms.sample2[1] = read_int16(src + 2);
1074 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample1[0]);
1075 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample1[1]);
1076 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample2[0]);
1077 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample2[1]);
1084 Stream_Write_UINT8(out, context->adpcm.ms.predictor[0]);
1085 Stream_Write_UINT8(out, (BYTE)(context->adpcm.ms.delta[0] & 0xFF));
1086 Stream_Write_UINT8(out, (BYTE)((context->adpcm.ms.delta[0] >> 8) & 0xFF));
1088 context->adpcm.ms.sample1[0] = read_int16(src + 2);
1089 context->adpcm.ms.sample2[0] = read_int16(src + 0);
1091 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample1[0]);
1092 Stream_Write_INT16(out, (INT16)context->adpcm.ms.sample2[0]);
1099 const INT16 sample = read_int16(src);
1102 out, (freerdp_dsp_encode_ms_adpcm_sample(&context->adpcm, sample, 0) << 4) & 0xFF);
1105 const INT16 sample = read_int16(src);
1109 Stream_Read_UINT8(out, val);
1110 val += freerdp_dsp_encode_ms_adpcm_sample(&context->adpcm, sample,
1111 context->common.format.nChannels > 1 ? 1 : 0);
1112 Stream_Write_UINT8(out, val);
1122FREERDP_DSP_CONTEXT* freerdp_dsp_context_new(BOOL encoder)
1124#if defined(WITH_DSP_FFMPEG)
1125 return freerdp_dsp_ffmpeg_context_new(encoder);
1127 FREERDP_DSP_CONTEXT* context = calloc(1,
sizeof(FREERDP_DSP_CONTEXT));
1132 if (!freerdp_dsp_common_context_init(&context->common, encoder))
1135#if defined(WITH_GSM)
1136 context->gsm = gsm_create();
1144 rc = gsm_option(context->gsm, GSM_OPT_WAV49, &val);
1150#if defined(WITH_LAME)
1154 context->lame = lame_init();
1161 context->hip = hip_decode_init();
1168#if defined(WITH_FAAD2)
1172 context->faad = NeAACDecOpen();
1181 freerdp_dsp_context_free(context);
1186void freerdp_dsp_context_free(FREERDP_DSP_CONTEXT* context)
1191#if defined(WITH_FDK_AAC)
1194 fdk_aac_dsp_uninit(ctx);
1197#if defined(WITH_DSP_FFMPEG)
1198 freerdp_dsp_ffmpeg_context_free(context);
1201 freerdp_dsp_common_context_uninit(&context->common);
1203#if defined(WITH_GSM)
1204 gsm_destroy(context->gsm);
1206#if defined(WITH_LAME)
1208 if (context->common.encoder)
1209 lame_close(context->lame);
1211 hip_decode_exit(context->hip);
1214#if defined(WITH_OPUS)
1216 if (context->opus_decoder)
1217 opus_decoder_destroy(context->opus_decoder);
1218 if (context->opus_encoder)
1219 opus_encoder_destroy(context->opus_encoder);
1222#if defined(WITH_FAAD2)
1224 if (!context->common.encoder)
1225 NeAACDecClose(context->faad);
1228#if defined(WITH_FAAC)
1231 faacEncClose(context->faac);
1234#if defined(WITH_SOXR)
1235 soxr_delete(context->sox);
1242BOOL freerdp_dsp_encode(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
1244 const BYTE* WINPR_RESTRICT pdata,
size_t length,
1247#if defined(WITH_FDK_AAC)
1250 switch (ctx->format.wFormatTag)
1252 case WAVE_FORMAT_AAC_MS:
1253 return fdk_aac_dsp_encode(ctx, srcFormat, pdata, length, out);
1259#if defined(WITH_DSP_FFMPEG)
1260 return freerdp_dsp_ffmpeg_encode(context, srcFormat, pdata, length, out);
1262 if (!context || !context->common.encoder || !srcFormat || !pdata || !out)
1266 const BYTE* resampleData = NULL;
1267 size_t resampleLength = 0;
1269 if (!freerdp_dsp_channel_mix(context, pdata, length, srcFormat, &resampleData, &resampleLength))
1272 format.nChannels = context->common.format.nChannels;
1274 const BYTE* data = NULL;
1275 if (!freerdp_dsp_resample(context, resampleData, resampleLength, &format, &data, &length))
1278 switch (context->common.format.wFormatTag)
1280 case WAVE_FORMAT_PCM:
1281 if (!Stream_EnsureRemainingCapacity(out, length))
1284 Stream_Write(out, data, length);
1287 case WAVE_FORMAT_ADPCM:
1288 return freerdp_dsp_encode_ms_adpcm(context, data, length, out);
1290 case WAVE_FORMAT_DVI_ADPCM:
1291 return freerdp_dsp_encode_ima_adpcm(context, data, length, out);
1292#if defined(WITH_GSM)
1294 case WAVE_FORMAT_GSM610:
1295 return freerdp_dsp_encode_gsm610(context, data, length, out);
1297#if defined(WITH_LAME)
1299 case WAVE_FORMAT_MPEGLAYER3:
1300 return freerdp_dsp_encode_mp3(context, data, length, out);
1302#if defined(WITH_FAAC)
1304 case WAVE_FORMAT_AAC_MS:
1305 return freerdp_dsp_encode_faac(context, data, length, out);
1307#if defined(WITH_OPUS)
1309 case WAVE_FORMAT_OPUS:
1310 return freerdp_dsp_encode_opus(context, data, length, out);
1320BOOL freerdp_dsp_decode(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
1322 const BYTE* WINPR_RESTRICT data,
size_t length,
wStream* WINPR_RESTRICT out)
1324#if defined(WITH_FDK_AAC)
1327 switch (ctx->format.wFormatTag)
1329 case WAVE_FORMAT_AAC_MS:
1330 return fdk_aac_dsp_decode(ctx, srcFormat, data, length, out);
1336#if defined(WITH_DSP_FFMPEG)
1337 return freerdp_dsp_ffmpeg_decode(context, srcFormat, data, length, out);
1340 if (!context || context->common.encoder || !srcFormat || !data || !out)
1343 switch (context->common.format.wFormatTag)
1345 case WAVE_FORMAT_PCM:
1346 if (!Stream_EnsureRemainingCapacity(out, length))
1349 Stream_Write(out, data, length);
1352 case WAVE_FORMAT_ADPCM:
1353 return freerdp_dsp_decode_ms_adpcm(context, data, length, out);
1355 case WAVE_FORMAT_DVI_ADPCM:
1356 return freerdp_dsp_decode_ima_adpcm(context, data, length, out);
1357#if defined(WITH_GSM)
1359 case WAVE_FORMAT_GSM610:
1360 return freerdp_dsp_decode_gsm610(context, data, length, out);
1362#if defined(WITH_LAME)
1364 case WAVE_FORMAT_MPEGLAYER3:
1365 return freerdp_dsp_decode_mp3(context, data, length, out);
1367#if defined(WITH_FAAD2)
1369 case WAVE_FORMAT_AAC_MS:
1370 return freerdp_dsp_decode_faad(context, data, length, out);
1373#if defined(WITH_OPUS)
1374 case WAVE_FORMAT_OPUS:
1375 return freerdp_dsp_decode_opus(context, data, length, out);
1385BOOL freerdp_dsp_supports_format(
const AUDIO_FORMAT* WINPR_RESTRICT format, BOOL encode)
1387#if defined(WITH_FDK_AAC)
1388 switch (format->wFormatTag)
1390 case WAVE_FORMAT_AAC_MS:
1398#if defined(WITH_DSP_FFMPEG)
1399 return freerdp_dsp_ffmpeg_supports_format(format, encode);
1402#if !defined(WITH_DSP_EXPERIMENTAL)
1403 WINPR_UNUSED(encode);
1405 switch (format->wFormatTag)
1407 case WAVE_FORMAT_PCM:
1409#if defined(WITH_DSP_EXPERIMENTAL)
1411 case WAVE_FORMAT_ADPCM:
1413 case WAVE_FORMAT_DVI_ADPCM:
1416#if defined(WITH_GSM)
1418 case WAVE_FORMAT_GSM610:
1419#if defined(WITH_DSP_EXPERIMENTAL)
1425#if defined(WITH_LAME)
1427 case WAVE_FORMAT_MPEGLAYER3:
1428#if defined(WITH_DSP_EXPERIMENTAL)
1435 case WAVE_FORMAT_AAC_MS:
1436#if defined(WITH_FAAD2)
1441#if defined(WITH_FAAC)
1447#if defined(WITH_OPUS)
1450 case WAVE_FORMAT_OPUS:
1451 return opus_is_valid_samplerate(format);
1463BOOL freerdp_dsp_context_reset(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,
1465 WINPR_ATTR_UNUSED UINT32 FramesPerPacket)
1467#if defined(WITH_FDK_AAC)
1468 WINPR_ASSERT(targetFormat);
1469 if (targetFormat->wFormatTag == WAVE_FORMAT_AAC_MS)
1472 fdk_aac_dsp_uninit(ctx);
1473 ctx->format = *targetFormat;
1474 return fdk_aac_dsp_init(ctx, FramesPerPacket);
1478#if defined(WITH_DSP_FFMPEG)
1479 return freerdp_dsp_ffmpeg_context_reset(context, targetFormat);
1482 if (!context || !targetFormat)
1485 context->common.format = *targetFormat;
1487 if (context->common.format.wFormatTag == WAVE_FORMAT_DVI_ADPCM)
1489 size_t min_frame_data = 1ull * context->common.format.wBitsPerSample *
1490 context->common.format.nChannels * FramesPerPacket;
1491 size_t data_per_block =
1492 (1ULL * context->common.format.nBlockAlign - 4ULL * context->common.format.nChannels) *
1494 size_t nb_block_per_packet = min_frame_data / data_per_block;
1496 if (min_frame_data % data_per_block)
1497 nb_block_per_packet++;
1499 context->adpcm.ima.packet_size = nb_block_per_packet * context->common.format.nBlockAlign;
1500 Stream_EnsureCapacity(context->common.buffer, context->adpcm.ima.packet_size);
1501 Stream_SetPosition(context->common.buffer, 0);
1504#if defined(WITH_OPUS)
1506 if (opus_is_valid_samplerate(&context->common.format))
1508 if (!context->common.encoder)
1510 int opus_error = OPUS_OK;
1512 context->opus_decoder =
1513 opus_decoder_create(context->common.format.nSamplesPerSec,
1514 context->common.format.nChannels, &opus_error);
1515 if (opus_error != OPUS_OK)
1520 int opus_error = OPUS_OK;
1522 context->opus_encoder = opus_encoder_create(context->common.format.nSamplesPerSec,
1523 context->common.format.nChannels,
1524 OPUS_APPLICATION_VOIP, &opus_error);
1525 if (opus_error != OPUS_OK)
1529 opus_encoder_ctl(context->opus_encoder,
1530 OPUS_SET_BITRATE(context->common.format.nAvgBytesPerSec * 8));
1531 if (opus_error != OPUS_OK)
1537#if defined(WITH_FAAD2)
1538 context->faadSetup = FALSE;
1540#if defined(WITH_FAAC)
1542 if (context->common.encoder)
1544 faacEncConfigurationPtr cfg;
1547 faacEncClose(context->faac);
1549 context->faac = faacEncOpen(targetFormat->nSamplesPerSec, targetFormat->nChannels,
1550 &context->faacInputSamples, &context->faacMaxOutputBytes);
1555 cfg = faacEncGetCurrentConfiguration(context->faac);
1556 cfg->inputFormat = FAAC_INPUT_16BIT;
1557 cfg->outputFormat = 0;
1558 cfg->mpegVersion = MPEG4;
1560 cfg->bandWidth = targetFormat->nAvgBytesPerSec;
1561 faacEncSetConfiguration(context->faac, cfg);
1565#if defined(WITH_SOXR)
1567 soxr_io_spec_t iospec = soxr_io_spec(SOXR_INT16, SOXR_INT16);
1569 soxr_delete(context->sox);
1571 soxr_create(context->common.format.nSamplesPerSec, targetFormat->nSamplesPerSec,
1572 targetFormat->nChannels, &error, &iospec, NULL, NULL);
1574 if (!context->sox || (error != 0))
1584 WINPR_ASSERT(context);
1585 context->encoder = encode;
1586 context->buffer = Stream_New(NULL, 1024);
1587 if (!context->buffer)
1590 context->channelmix = Stream_New(NULL, 1024);
1591 if (!context->channelmix)
1594 context->resample = Stream_New(NULL, 1024);
1595 if (!context->resample)
1601 freerdp_dsp_common_context_uninit(context);
1607 WINPR_ASSERT(context);
1609 Stream_Free(context->buffer, TRUE);
1610 Stream_Free(context->channelmix, TRUE);
1611 Stream_Free(context->resample, TRUE);
1613 context->buffer = NULL;
1614 context->channelmix = NULL;
1615 context->resample = NULL;