Unverified Commit 413af62f authored by Karl Linden's avatar Karl Linden
Browse files

Fix building with celt in non-standard prefix.

This moves the celt parts of JackNetTool into JackNetCelt so celt
headers are not undeliberately included from JackNetDriver (which is
compiled without celt).
parent c75cc6e3
/*
Copyright (C) 2008-2011 Romain Moret at Grame
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "JackNetCelt.h"
#include "JackError.h"
namespace Jack
{
#define KPS 32
#define KPS_DIV 8
NetCeltAudioBuffer::NetCeltAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps)
:NetAudioBuffer(params, nports, net_buffer)
{
fCeltMode = new CELTMode*[fNPorts];
fCeltEncoder = new CELTEncoder*[fNPorts];
fCeltDecoder = new CELTDecoder*[fNPorts];
memset(fCeltMode, 0, fNPorts * sizeof(CELTMode*));
memset(fCeltEncoder, 0, fNPorts * sizeof(CELTEncoder*));
memset(fCeltDecoder, 0, fNPorts * sizeof(CELTDecoder*));
int error = CELT_OK;
for (int i = 0; i < fNPorts; i++) {
fCeltMode[i] = celt_mode_create(params->fSampleRate, params->fPeriodSize, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_mode_create err = %d", error);
goto error;
}
#if HAVE_CELT_API_0_11
fCeltEncoder[i] = celt_encoder_create_custom(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_encoder_create_custom err = %d", error);
goto error;
}
celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
fCeltDecoder[i] = celt_decoder_create_custom(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_decoder_create_custom err = %d", error);
goto error;
}
celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
fCeltEncoder[i] = celt_encoder_create(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_mode_create err = %d", error);
goto error;
}
celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
fCeltDecoder[i] = celt_decoder_create(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_decoder_create err = %d", error);
goto error;
}
celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
#else
fCeltEncoder[i] = celt_encoder_create(fCeltMode[i]);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_encoder_create err = %d", error);
goto error;
}
celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
fCeltDecoder[i] = celt_decoder_create(fCeltMode[i]);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_decoder_create err = %d", error);
goto error;
}
celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
#endif
}
{
fPeriodSize = params->fPeriodSize;
fCompressedSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
jack_log("NetCeltAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
fCompressedBuffer = new unsigned char* [fNPorts];
for (int port_index = 0; port_index < fNPorts; port_index++) {
fCompressedBuffer[port_index] = new unsigned char[fCompressedSizeByte];
memset(fCompressedBuffer[port_index], 0, fCompressedSizeByte * sizeof(char));
}
int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
fNumPackets = (res1) ? (res2 + 1) : res2;
jack_log("NetCeltAudioBuffer res1 = %d res2 = %d", res1, res2);
fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
jack_log("NetCeltAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate);
fCycleBytesSize = params->fMtu * fNumPackets;
fLastSubCycle = -1;
return;
}
error:
FreeCelt();
throw std::bad_alloc();
}
NetCeltAudioBuffer::~NetCeltAudioBuffer()
{
FreeCelt();
for (int port_index = 0; port_index < fNPorts; port_index++) {
delete [] fCompressedBuffer[port_index];
}
delete [] fCompressedBuffer;
}
void NetCeltAudioBuffer::FreeCelt()
{
for (int i = 0; i < fNPorts; i++) {
if (fCeltEncoder[i]) {
celt_encoder_destroy(fCeltEncoder[i]);
}
if (fCeltDecoder[i]) {
celt_decoder_destroy(fCeltDecoder[i]);
}
if (fCeltMode[i]) {
celt_mode_destroy(fCeltMode[i]);
}
}
delete [] fCeltMode;
delete [] fCeltEncoder;
delete [] fCeltDecoder;
}
size_t NetCeltAudioBuffer::GetCycleSize()
{
return fCycleBytesSize;
}
float NetCeltAudioBuffer::GetCycleDuration()
{
return fCycleDuration;
}
int NetCeltAudioBuffer::GetNumPackets(int active_ports)
{
return fNumPackets;
}
int NetCeltAudioBuffer::RenderFromJackPorts(int nframes)
{
float buffer[BUFFER_SIZE_MAX];
for (int port_index = 0; port_index < fNPorts; port_index++) {
if (fPortBuffer[port_index]) {
memcpy(buffer, fPortBuffer[port_index], fPeriodSize * sizeof(sample_t));
} else {
memset(buffer, 0, fPeriodSize * sizeof(sample_t));
}
#if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
//int res = celt_encode_float(fCeltEncoder[port_index], buffer, fPeriodSize, fCompressedBuffer[port_index], fCompressedSizeByte);
int res = celt_encode_float(fCeltEncoder[port_index], buffer, nframes, fCompressedBuffer[port_index], fCompressedSizeByte);
#else
int res = celt_encode_float(fCeltEncoder[port_index], buffer, NULL, fCompressedBuffer[port_index], fCompressedSizeByte);
#endif
if (res != fCompressedSizeByte) {
jack_error("celt_encode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
}
}
// All ports active
return fNPorts;
}
void NetCeltAudioBuffer::RenderToJackPorts(int nframes)
{
for (int port_index = 0; port_index < fNPorts; port_index++) {
if (fPortBuffer[port_index]) {
#if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
//int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], fPeriodSize);
int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], nframes);
#else
int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index]);
#endif
if (res != CELT_OK) {
jack_error("celt_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
}
}
}
NextCycle();
}
//network<->buffer
int NetCeltAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num)
{
// Cleanup all JACK ports at the beginning of the cycle
if (sub_cycle == 0) {
Cleanup();
}
if (port_num > 0) {
int sub_period_bytes_size;
// Last packet of the cycle
if (sub_cycle == fNumPackets - 1) {
sub_period_bytes_size = fLastSubPeriodBytesSize;
} else {
sub_period_bytes_size = fSubPeriodBytesSize;
}
for (int port_index = 0; port_index < fNPorts; port_index++) {
memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * sub_period_bytes_size, sub_period_bytes_size);
}
}
return CheckPacket(cycle, sub_cycle);
}
int NetCeltAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num)
{
int sub_period_bytes_size;
// Last packet of the cycle
if (sub_cycle == fNumPackets - 1) {
sub_period_bytes_size = fLastSubPeriodBytesSize;
} else {
sub_period_bytes_size = fSubPeriodBytesSize;
}
for (int port_index = 0; port_index < fNPorts; port_index++) {
memcpy(fNetBuffer + port_index * sub_period_bytes_size, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, sub_period_bytes_size);
}
return fNPorts * sub_period_bytes_size;
}
}
/*
Copyright (C) 2008-2011 Romain Moret at Grame
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __JackNetCelt__
#define __JackNetCelt__
#include "JackNetTool.h"
#include <celt/celt.h>
namespace Jack
{
class SERVER_EXPORT NetCeltAudioBuffer : public NetAudioBuffer
{
private:
CELTMode** fCeltMode;
CELTEncoder** fCeltEncoder;
CELTDecoder** fCeltDecoder;
int fCompressedSizeByte;
unsigned char** fCompressedBuffer;
size_t fLastSubPeriodBytesSize;
void FreeCelt();
public:
NetCeltAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps);
virtual ~NetCeltAudioBuffer();
// needed size in bytes for an entire cycle
size_t GetCycleSize();
// cycle duration in sec
float GetCycleDuration();
int GetNumPackets(int active_ports);
//jack<->buffer
int RenderFromJackPorts(int nframes);
void RenderToJackPorts(int nframes);
//network<->buffer
int RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num);
int RenderToNetwork(int sub_cycle, uint32_t port_num);
};
}
#endif
......@@ -20,6 +20,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#include "JackException.h"
#include "JackError.h"
#if HAVE_CELT
#include "JackNetCelt.h"
#endif
#if HAVE_OPUS
#include "JackNetOpus.h"
#endif
......
......@@ -472,255 +472,6 @@ namespace Jack
memcpy(net_buffer, fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize - sizeof(int));
}
#endif
// Celt audio buffer *********************************************************************************
#if HAVE_CELT
#define KPS 32
#define KPS_DIV 8
NetCeltAudioBuffer::NetCeltAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps)
:NetAudioBuffer(params, nports, net_buffer)
{
fCeltMode = new CELTMode*[fNPorts];
fCeltEncoder = new CELTEncoder*[fNPorts];
fCeltDecoder = new CELTDecoder*[fNPorts];
memset(fCeltMode, 0, fNPorts * sizeof(CELTMode*));
memset(fCeltEncoder, 0, fNPorts * sizeof(CELTEncoder*));
memset(fCeltDecoder, 0, fNPorts * sizeof(CELTDecoder*));
int error = CELT_OK;
for (int i = 0; i < fNPorts; i++) {
fCeltMode[i] = celt_mode_create(params->fSampleRate, params->fPeriodSize, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_mode_create err = %d", error);
goto error;
}
#if HAVE_CELT_API_0_11
fCeltEncoder[i] = celt_encoder_create_custom(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_encoder_create_custom err = %d", error);
goto error;
}
celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
fCeltDecoder[i] = celt_decoder_create_custom(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_decoder_create_custom err = %d", error);
goto error;
}
celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
fCeltEncoder[i] = celt_encoder_create(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_mode_create err = %d", error);
goto error;
}
celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
fCeltDecoder[i] = celt_decoder_create(fCeltMode[i], 1, &error);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_decoder_create err = %d", error);
goto error;
}
celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
#else
fCeltEncoder[i] = celt_encoder_create(fCeltMode[i]);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_encoder_create err = %d", error);
goto error;
}
celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
fCeltDecoder[i] = celt_decoder_create(fCeltMode[i]);
if (error != CELT_OK) {
jack_log("NetCeltAudioBuffer celt_decoder_create err = %d", error);
goto error;
}
celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
#endif
}
{
fPeriodSize = params->fPeriodSize;
fCompressedSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
jack_log("NetCeltAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
fCompressedBuffer = new unsigned char* [fNPorts];
for (int port_index = 0; port_index < fNPorts; port_index++) {
fCompressedBuffer[port_index] = new unsigned char[fCompressedSizeByte];
memset(fCompressedBuffer[port_index], 0, fCompressedSizeByte * sizeof(char));
}
int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
fNumPackets = (res1) ? (res2 + 1) : res2;
jack_log("NetCeltAudioBuffer res1 = %d res2 = %d", res1, res2);
fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
jack_log("NetCeltAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate);
fCycleBytesSize = params->fMtu * fNumPackets;
fLastSubCycle = -1;
return;
}
error:
FreeCelt();
throw std::bad_alloc();
}
NetCeltAudioBuffer::~NetCeltAudioBuffer()
{
FreeCelt();
for (int port_index = 0; port_index < fNPorts; port_index++) {
delete [] fCompressedBuffer[port_index];
}
delete [] fCompressedBuffer;
}
void NetCeltAudioBuffer::FreeCelt()
{
for (int i = 0; i < fNPorts; i++) {
if (fCeltEncoder[i]) {
celt_encoder_destroy(fCeltEncoder[i]);
}
if (fCeltDecoder[i]) {
celt_decoder_destroy(fCeltDecoder[i]);
}
if (fCeltMode[i]) {
celt_mode_destroy(fCeltMode[i]);
}
}
delete [] fCeltMode;
delete [] fCeltEncoder;
delete [] fCeltDecoder;
}
size_t NetCeltAudioBuffer::GetCycleSize()
{
return fCycleBytesSize;
}
float NetCeltAudioBuffer::GetCycleDuration()
{
return fCycleDuration;
}
int NetCeltAudioBuffer::GetNumPackets(int active_ports)
{
return fNumPackets;
}
int NetCeltAudioBuffer::RenderFromJackPorts(int nframes)
{
float buffer[BUFFER_SIZE_MAX];
for (int port_index = 0; port_index < fNPorts; port_index++) {
if (fPortBuffer[port_index]) {
memcpy(buffer, fPortBuffer[port_index], fPeriodSize * sizeof(sample_t));
} else {
memset(buffer, 0, fPeriodSize * sizeof(sample_t));
}
#if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
//int res = celt_encode_float(fCeltEncoder[port_index], buffer, fPeriodSize, fCompressedBuffer[port_index], fCompressedSizeByte);
int res = celt_encode_float(fCeltEncoder[port_index], buffer, nframes, fCompressedBuffer[port_index], fCompressedSizeByte);
#else
int res = celt_encode_float(fCeltEncoder[port_index], buffer, NULL, fCompressedBuffer[port_index], fCompressedSizeByte);
#endif
if (res != fCompressedSizeByte) {
jack_error("celt_encode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
}
}
// All ports active
return fNPorts;
}
void NetCeltAudioBuffer::RenderToJackPorts(int nframes)
{
for (int port_index = 0; port_index < fNPorts; port_index++) {
if (fPortBuffer[port_index]) {
#if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
//int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], fPeriodSize);
int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], nframes);
#else
int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index]);
#endif
if (res != CELT_OK) {
jack_error("celt_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
}
}
}
NextCycle();
}
//network<->buffer
int NetCeltAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num)
{
// Cleanup all JACK ports at the beginning of the cycle
if (sub_cycle == 0) {
Cleanup();
}
if (port_num > 0) {
int sub_period_bytes_size;
// Last packet of the cycle
if (sub_cycle == fNumPackets - 1) {
sub_period_bytes_size = fLastSubPeriodBytesSize;
} else {
sub_period_bytes_size = fSubPeriodBytesSize;
}
for (int port_index = 0; port_index < fNPorts; port_index++) {
memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * sub_period_bytes_size, sub_period_bytes_size);
}
}
return CheckPacket(cycle, sub_cycle);
}
int NetCeltAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num)
{
int sub_period_bytes_size;
// Last packet of the cycle
if (sub_cycle == fNumPackets - 1) {
sub_period_bytes_size = fLastSubPeriodBytesSize;
} else {
sub_period_bytes_size = fSubPeriodBytesSize;
}
for (int port_index = 0; port_index < fNPorts; port_index++) {
memcpy(fNetBuffer + port_index * sub_period_bytes_size, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, sub_period_bytes_size);
}
return fNPorts * sub_period_bytes_size;
}
#endif
......
......@@ -369,48 +369,6 @@ namespace Jack
};
#if HAVE_CELT
#include <celt/celt.h>
class SERVER_EXPORT NetCeltAudioBuffer : public NetAudioBuffer
{