static void SBCELT_DecodeSingleFrame() {
unsigned char *src = &workpage->encbuf[0];
float *dst = &workpage->decbuf[0];
int idx = workpage->slot;
struct SBCELTDecoderSlot *slot = &decpage->slots[idx];
CELTMode *m = modes[idx];
CELTDecoder *d = decoders[idx];
if (slot->dispose && m != NULL && d != NULL) {
debugf("disposed of mode & decoder for slot=%i", idx);
celt_mode_destroy(m);
celt_decoder_destroy(d);
m = modes[idx] = celt_mode_create(SAMPLE_RATE, SAMPLE_RATE / 100, NULL);
d = decoders[idx] = celt_decoder_create(m, 1, NULL);
slot->dispose = 0;
}
if (m == NULL && d == NULL) {
debugf("created mode & decoder for slot=%i", idx);
m = modes[idx] = celt_mode_create(SAMPLE_RATE, SAMPLE_RATE / 100, NULL);
d = decoders[idx] = celt_decoder_create(m, 1, NULL);
}
debugf("got work for slot=%i", idx);
unsigned int len = workpage->len;
debugf("to decode: %p, %p, %u, %p", d, src, len, dst);
if (len == 0) {
celt_decode_float(d, NULL, 0, dst);
} else {
celt_decode_float(d, src, len, dst);
}
debugf("decoded len=%u", len);
}
SWIGEXPORT jlong JNICALL Java_com_morlunk_jumble_audio_celt11_CELT11JNI_celt_1decoder_1create(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jintArray jarg3) {
jlong jresult = 0 ;
int arg1 ;
int arg2 ;
int *arg3 = (int *) 0 ;
int temp3 ;
CELTDecoder *result = 0 ;
(void)jenv;
(void)jcls;
arg1 = (int)jarg1;
arg2 = (int)jarg2;
{
if (!jarg3) {
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
return 0;
}
if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
return 0;
}
temp3 = (int)0;
arg3 = &temp3;
}
result = (CELTDecoder *)celt_decoder_create(arg1,arg2,arg3);
*(CELTDecoder **)&jresult = result;
{
jint jvalue = (jint)temp3;
(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
}
return jresult;
}
static CELTDecoder *process_header(ogg_packet *op, celt_int32 enh_enabled, celt_int32 *frame_size, int *granule_frame_size, celt_int32 *rate, int *nframes, int forceMode, int *channels, int *overlap, int *extra_headers, int quiet, CELTMode **mode)
{
CELTDecoder *st;
CELTHeader header;
int bitstream;
celt_header_from_packet(op->packet, op->bytes, &header);
if (header.nb_channels>2 || header.nb_channels<1)
{
fprintf (stderr, "Unsupported number of channels: %d\n", header.nb_channels);
return NULL;
}
*mode = celt_mode_create(header.sample_rate, header.frame_size, NULL);
if (*mode == NULL)
{
fprintf (stderr, "Mode initialization failed.\n");
return NULL;
}
celt_mode_info(*mode, CELT_GET_BITSTREAM_VERSION, &bitstream);
if (bitstream!=header.version_id)
fprintf(stderr, "WARNING: Input was encoded with a CELT bitstream version %d. This decoder uses %d. Output will probably be corrupted.\n",header.version_id,bitstream);
*channels = header.nb_channels;
*overlap=header.overlap;
st = celt_decoder_create(*mode, header.nb_channels, NULL);
if (!st)
{
fprintf (stderr, "Decoder initialization failed.\n");
return NULL;
}
celt_mode_info(*mode, CELT_GET_FRAME_SIZE, frame_size);
*granule_frame_size = *frame_size;
if (!*rate)
*rate = header.sample_rate;
*nframes = 1;
if (!quiet)
{
fprintf (stderr, "Decoding %d Hz audio in", *rate);
if (*channels==1)
fprintf (stderr, " (mono");
else
fprintf (stderr, " (stereo");
fprintf(stderr, ")\n");
}
*extra_headers = header.extra_headers;
return st;
}
static switch_status_t switch_celt_init(switch_codec_t *codec, switch_codec_flag_t flags, const switch_codec_settings_t *codec_settings)
{
struct celt_context *context = NULL;
int encoding = (flags & SWITCH_CODEC_FLAG_ENCODE);
int decoding = (flags & SWITCH_CODEC_FLAG_DECODE);
if (!(encoding || decoding) || (!(context = switch_core_alloc(codec->memory_pool, sizeof(*context))))) {
return SWITCH_STATUS_FALSE;
}
context->frame_size = codec->implementation->samples_per_packet;
context->mode_object = celt_mode_create(codec->implementation->actual_samples_per_second, context->frame_size, NULL);
context->bytes_per_packet = (codec->implementation->bits_per_second * context->frame_size / codec->implementation->actual_samples_per_second + 4) / 8;
/*
if (codec->fmtp_in) {
int x, argc;
char *argv[10];
argc = switch_separate_string(codec->fmtp_in, ';', argv, (sizeof(argv) / sizeof(argv[0])));
for (x = 0; x < argc; x++) {
char *data = argv[x];
char *arg;
switch_assert(data);
while (*data == ' ') {
data++;
}
if ((arg = strchr(data, '='))) {
*arg++ = '\0';
if (!strcasecmp(data, "bitrate")) {
bit_rate = atoi(arg);
}
}
}
}
codec->fmtp_out = switch_core_sprintf(codec->memory_pool, "bitrate=%d", bit_rate);
*/
if (encoding) {
context->encoder_object = celt_encoder_create(context->mode_object, 1, NULL);
}
if (decoding) {
context->decoder_object = celt_decoder_create(context->mode_object, 1, NULL);
}
codec->private_info = context;
return SWITCH_STATUS_SUCCESS;
}
static void * celt_create_decoder(const struct PluginCodec_Definition * codec)
{
CELTContext * celt = malloc(sizeof(CELTContext));
if (celt == NULL)
return NULL;
if (init_mode(celt, codec) == FALSE) {
free(celt);
return NULL;
}
celt->decoder_state = celt_decoder_create(celt->mode);
if (celt->decoder_state == NULL ) {
celt_mode_destroy(celt->mode);
free(celt);
return NULL;
}
return celt;
}
/**
* This Function allocates all the I/O Ports which are added the lists.
*/
void
alloc_ports (int n_capture_audio, int n_playback_audio, int n_capture_midi, int n_playback_midi)
{
int port_flags = JackPortIsOutput;
int chn;
jack_port_t *port;
char buf[32];
capture_ports = NULL;
/* Allocate audio capture channels */
for (chn = 0; chn < n_capture_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
printf( "jack_netsource: cannot register %s port\n", buf);
break;
}
if (bitdepth == 1000) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create_custom( celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), 1, jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode ) );
#endif
#endif
} else if (bitdepth == 999) {
#if HAVE_OPUS
int err;
OpusCustomMode *opus_mode = opus_custom_mode_create(jack_get_sample_rate( client ), jack_get_buffer_size(client), &err);
if (err != OPUS_OK) { printf("OPUS MODE FAILED\n"); }
OpusCustomDecoder *decoder = opus_custom_decoder_create(opus_mode, 1, &err);
if (err != OPUS_OK) { printf("OPUS DECODER FAILED\n"); }
opus_custom_decoder_init(decoder, opus_mode, 1);
capture_srcs = jack_slist_append(capture_srcs, decoder);
#endif
} else {
#if HAVE_SAMPLERATE
capture_srcs = jack_slist_append (capture_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
capture_ports = jack_slist_append (capture_ports, port);
}
/* Allocate midi capture channels */
for (chn = n_capture_audio; chn < n_capture_midi + n_capture_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port) {
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
capture_ports = jack_slist_append(capture_ports, port);
}
/* Allocate audio playback channels */
port_flags = JackPortIsInput;
playback_ports = NULL;
for (chn = 0; chn < n_playback_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
if( bitdepth == 1000 ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create_custom( celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), 1, jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else if( bitdepth == 999 ) {
#if HAVE_OPUS
const int kbps = factor;
printf("new opus encoder %d kbps\n", kbps);
int err;
OpusCustomMode *opus_mode = opus_custom_mode_create(jack_get_sample_rate (client), jack_get_buffer_size(client), &err ); // XXX free me
if (err != OPUS_OK) { printf("OPUS MODE FAILED\n"); }
OpusCustomEncoder *oe = opus_custom_encoder_create( opus_mode, 1, &err );
if (err != OPUS_OK) { printf("OPUS ENCODER FAILED\n"); }
opus_custom_encoder_ctl(oe, OPUS_SET_BITRATE(kbps*1024)); // bits per second
opus_custom_encoder_ctl(oe, OPUS_SET_COMPLEXITY(10));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
opus_custom_encoder_init(oe, opus_mode, 1);
playback_srcs = jack_slist_append(playback_srcs, oe);
#endif
} else {
#if HAVE_SAMPLERATE
playback_srcs = jack_slist_append (playback_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
playback_ports = jack_slist_append (playback_ports, port);
}
/* Allocate midi playback channels */
for (chn = n_playback_audio; chn < n_playback_midi + n_playback_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port) {
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
playback_ports = jack_slist_append (playback_ports, port);
}
}
void netjack_attach( netjack_driver_state_t *netj )
{
//puts ("net_driver_attach");
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if( netj->bitdepth == CELT_MODE )
{
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
celt_int32 lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
#else
celt_int32_t lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
#endif
celt_mode_info( netj->celt_mode, CELT_GET_LOOKAHEAD, &lookahead );
netj->codec_latency = 2*lookahead;
#endif
}
if (netj->handle_transport_sync)
jack_set_sync_callback(netj->client, (JackSyncCallback) net_driver_sync_cb, NULL);
port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->capture_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode, 1, NULL ) );
#else
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
netj->capture_srcs = jack_slist_append(netj->capture_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->capture_channels_audio; chn < netj->capture_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
}
port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->playback_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
netj->playback_srcs = jack_slist_append(netj->playback_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->playback_channels_audio; chn < netj->playback_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
}
jack_activate (netj->client);
}
void netjack_attach( netjack_driver_state_t *netj )
{
//puts ("net_driver_attach");
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
celt_int32 lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
#else
celt_int32_t lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
#endif
celt_mode_info( netj->celt_mode, CELT_GET_LOOKAHEAD, &lookahead );
netj->codec_latency = 2 * lookahead;
#endif
}
if( netj->bitdepth == OPUS_MODE ) {
#if HAVE_OPUS
netj->opus_mode = opus_custom_mode_create(netj->sample_rate, netj->period_size, NULL);
#endif
}
if (netj->handle_transport_sync)
jack_set_sync_callback(netj->client, (JackSyncCallback) net_driver_sync_cb, NULL);
port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->capture_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create_custom( netj->celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode, 1, NULL ) );
#else
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode ) );
#endif
#endif
} else if( netj->bitdepth == OPUS_MODE ) {
#if HAVE_OPUS
OpusCustomDecoder *decoder = opus_custom_decoder_create( netj->opus_mode, 1, NULL );
netj->capture_srcs = jack_slist_append(netj->capture_srcs, decoder );
#endif
} else {
#if HAVE_SAMPLERATE
netj->capture_srcs = jack_slist_append(netj->capture_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->capture_channels_audio; chn < netj->capture_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
}
port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->playback_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_decoder_create_custom( celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else if( netj->bitdepth == OPUS_MODE ) {
#if HAVE_OPUS
const int kbps = netj->resample_factor;
jack_log( "OPUS %dkbps\n", kbps);
OpusCustomMode *opus_mode = opus_custom_mode_create( netj->sample_rate, netj->period_size, NULL ); // XXX free me in the end
OpusCustomEncoder *oe = opus_custom_encoder_create( opus_mode, 1, NULL );
opus_custom_encoder_ctl(oe, OPUS_SET_BITRATE(kbps*1024)); // bits per second
opus_custom_encoder_ctl(oe, OPUS_SET_COMPLEXITY(10));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
netj->playback_srcs = jack_slist_append(netj->playback_srcs, oe );
#endif
} else {
#if HAVE_SAMPLERATE
netj->playback_srcs = jack_slist_append(netj->playback_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->playback_channels_audio; chn < netj->playback_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
}
jack_activate (netj->client);
}
static int alloc(struct aucodec_st **stp, struct aucodec *ac,
struct aucodec_prm *encp, struct aucodec_prm *decp,
const char *fmtp)
{
struct aucodec_st *st;
const uint32_t srate = aucodec_srate(ac);
const uint8_t ch = aucodec_ch(ac);
int err = 0;
(void)decp;
st = mem_zalloc(sizeof(*st), celt_destructor);
if (!st)
return ENOMEM;
st->ac = mem_ref(ac);
st->bitrate = DEFAULT_BITRATE;
st->low_overhead = celt_low_overhead;
if (encp && encp->ptime) {
st->frame_size = srate * ch * encp->ptime / 1000;
DEBUG_NOTICE("calc ptime=%u ---> frame_size=%u\n",
encp->ptime, st->frame_size);
}
else {
st->frame_size = DEFAULT_FRAME_SIZE;
}
if (str_isset(fmtp))
decode_params(st, fmtp);
/* Common mode */
st->mode = celt_mode_create(srate, st->frame_size, NULL);
if (!st->mode) {
DEBUG_WARNING("alloc: could not create CELT mode\n");
err = EPROTO;
goto out;
}
#ifdef CELT_GET_FRAME_SIZE
celt_mode_info(st->mode, CELT_GET_FRAME_SIZE, &st->frame_size);
#endif
st->fsize = 2 * st->frame_size * ch;
st->bytes_per_packet = (st->bitrate * st->frame_size / srate + 4)/8;
DEBUG_NOTICE("alloc: frame_size=%u bitrate=%ubit/s fsize=%u"
" bytes_per_packet=%u\n",
st->frame_size, st->bitrate, st->fsize,
st->bytes_per_packet);
/* Encoder */
#ifdef CELT_OLD_API
st->enc = celt_encoder_create(st->mode, ch, NULL);
#else
st->enc = celt_encoder_create(srate, ch, NULL);
#endif
if (!st->enc) {
DEBUG_WARNING("alloc: could not create CELT encoder\n");
err = EPROTO;
goto out;
}
/* Decoder */
#ifdef CELT_OLD_API
st->dec = celt_decoder_create(st->mode, ch, NULL);
#else
st->dec = celt_decoder_create(srate, ch, NULL);
#endif
if (!st->dec) {
DEBUG_WARNING("alloc: could not create CELT decoder\n");
err = EPROTO;
goto out;
}
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
static GstFlowReturn
celt_dec_chain_parse_header (GstCeltDec * dec, GstBuffer * buf)
{
GstCaps *caps;
gint error = CELT_OK;
/* get the header */
celt_header_from_packet ((const unsigned char *) GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf), &dec->header);
if (memcmp (dec->header.codec_id, "CELT ", 8) != 0)
goto invalid_header;
dec->mode =
celt_mode_create (dec->header.sample_rate, dec->header.nb_channels,
dec->header.frame_size, &error);
if (!dec->mode)
goto mode_init_failed;
/* initialize the decoder */
dec->state = celt_decoder_create (dec->mode);
if (!dec->state)
goto init_failed;
celt_mode_info (dec->mode, CELT_GET_FRAME_SIZE, &dec->frame_size);
dec->frame_duration = gst_util_uint64_scale_int (dec->frame_size,
GST_SECOND, dec->header.sample_rate);
/* set caps */
caps = gst_caps_new_simple ("audio/x-raw-int",
"rate", G_TYPE_INT, dec->header.sample_rate,
"channels", G_TYPE_INT, dec->header.nb_channels,
"signed", G_TYPE_BOOLEAN, TRUE,
"endianness", G_TYPE_INT, G_BYTE_ORDER,
"width", G_TYPE_INT, 16, "depth", G_TYPE_INT, 16, NULL);
if (!gst_pad_set_caps (dec->srcpad, caps))
goto nego_failed;
gst_caps_unref (caps);
return GST_FLOW_OK;
/* ERRORS */
invalid_header:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("Invalid header"));
return GST_FLOW_ERROR;
}
mode_init_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("Mode initialization failed: %d", error));
return GST_FLOW_ERROR;
}
init_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't initialize decoder"));
return GST_FLOW_ERROR;
}
nego_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't negotiate format"));
gst_caps_unref (caps);
return GST_FLOW_NOT_NEGOTIATED;
}
}
int main(int argc, char** argv)
{
int current, pos;
celt_int16 * sample_buffer;
unsigned char * encoded_buffer;
double * out_buffer;
int sample_rate;
int sample_bits;
int sample_channels;
int sample_buffer_size;
int sample;
int sample_msec;
int sample_size;
float freq;
double ampl, phase, frequency;
int i, j, k;
uint32_t frames; // FIXME! 4 byte!
FILE * fd;
int bad;
int badbytes, lostbytes, totalbytes;
struct Chord chord;
// Sound output through libao
struct AOutput * device;
CELTMode * cm;
CELTEncoder * ce;
CELTDecoder * cd;
int * error;
int compressed;
srand(time(NULL));
// Opening sound file for reading source data
fd = fopen("rex.wav", "rb");
fseek(fd, 40, SEEK_SET);
fread(&frames, sizeof(uint64_t), 1, fd);
frames = 800000000;
printf("%d\n", frames);
// Hardcoded parameters for DSP
sample_rate = 44100; // Desc. frequency, Hz
sample_bits = 16; // Bits per sample
sample_channels = 2; // Stereo
// sample_msec = 10; // Size of sample, 100 ms for 10 Hz FFT freq. resolution
sample_size = 1024;
//sample_size = (int)(sample_rate * (sample_msec / 1000.0F));
sample_buffer_size = sample_size * sample_bits/8 * sample_channels;
sample_buffer = (celt_int16 *) calloc(sample_buffer_size, sizeof(char));
encoded_buffer = (unsigned char *) calloc(sample_buffer_size, sizeof(char));
out_buffer = (double *) calloc(sample_buffer_size / (sample_bits/8), sizeof(double));
device = aout_init();
cm = celt_mode_create(sample_rate, sample_size, NULL);
//printf("1\n");
ce = celt_encoder_create(cm, sample_channels, NULL);
cd = celt_decoder_create(cm, sample_channels, NULL);
//printf("2\n");
celt_encoder_ctl(ce, CELT_SET_COMPLEXITY(10));
celt_encoder_ctl(ce, CELT_SET_PREDICTION(2));
celt_encoder_ctl(ce, CELT_SET_VBR_RATE(160000));
// Reading util end of file (frames - number of frames in WAV)
badbytes = totalbytes = lostbytes = 0;
for (i = 0; i < (sample_rate / sample_size) * (frames / (sample_rate * sample_channels * (sample_bits / 8))) ; ++i) {
// Reading sample from file
read_sample_into_buffer(fd, (char *)sample_buffer, sample_size);
printf("%d %d \n", (sample_rate / sample_size) * (frames / (sample_rate * sample_channels * (sample_bits / 8))) , i);
printf("Sample_buffer_size: %d\n", sample_buffer_size);
compressed = celt_encode(ce, sample_buffer, NULL, encoded_buffer, 1024);
printf("Compressed bytes: %d, bitrate: %d kbps\n", compressed, (int)((sample_rate * sample_bits * sample_channels / 1024) * (compressed * 1.0F / sample_buffer_size)));
memset(sample_buffer, 0, sample_buffer_size);
if (rand() > (int)(0.95 * RAND_MAX)) {
bad = rand() % (compressed / 4) + 5;
printf("Packet error, wiped %d bytes\n", bad);
memcpy(encoded_buffer + 2 * (compressed / 3) + 4, encoded_buffer, bad);
badbytes += bad;
}
if (rand() > (int)(0.0075 * RAND_MAX)) {
celt_decode(cd, encoded_buffer, compressed, sample_buffer);
aout_play(device, sample_buffer, sample_buffer_size);
} else {
usleep(sample_size * 1000000 / sample_rate);
printf("Packet was lost\n");
lostbytes += compressed;
}
totalbytes += compressed;
printf("Total kbytes: %d, lost: %d (%.3f proc), damaged: %d (%.3f proc)\n", totalbytes / 1024, lostbytes / 1024, lostbytes * 100.0F / totalbytes , badbytes / 1024, badbytes * 100.0F / totalbytes );
}
aout_close(device);
return 0;
}
/**
* This Function allocates all the I/O Ports which are added the lists.
*/
void
alloc_ports (int n_capture_audio, int n_playback_audio, int n_capture_midi, int n_playback_midi)
{
int port_flags = JackPortIsOutput;
int chn;
jack_port_t *port;
char buf[32];
capture_ports = NULL;
/* Allocate audio capture channels */
for (chn = 0; chn < n_capture_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port)
{
printf( "jack_netsource: cannot register %s port\n", buf);
break;
}
if( bitdepth == 1000 ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), 1, jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
capture_srcs = jack_slist_append (capture_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
capture_ports = jack_slist_append (capture_ports, port);
}
/* Allocate midi capture channels */
for (chn = n_capture_audio; chn < n_capture_midi + n_capture_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port)
{
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
capture_ports = jack_slist_append(capture_ports, port);
}
/* Allocate audio playback channels */
port_flags = JackPortIsInput;
playback_ports = NULL;
for (chn = 0; chn < n_playback_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port)
{
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
if( bitdepth == 1000 ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), 1, jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
playback_srcs = jack_slist_append (playback_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
playback_ports = jack_slist_append (playback_ports, port);
}
/* Allocate midi playback channels */
for (chn = n_playback_audio; chn < n_playback_midi + n_playback_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port)
{
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
playback_ports = jack_slist_append (playback_ports, port);
}
}
int main(int argc, char **argv)
{
int sd, rc, n, tmp;
char msg[MAX_MSG];
int nfds;
int send_timestamp = 0;
int recv_started = 0;
struct pollfd *pfds;
struct alsa_dev *dev;
CELTEncoder *enc_state;
CELTDecoder *dec_state;
CELTMode *mode;
struct sched_param param;
JitterBuffer *jitter;
SpeexEchoState *echo_state;
char mac_own[6], mac_remote[6];
if (argc != 4)
panic("Usage %s plughw:0,0 <lmac in xx:xx:xx:xx:xx:xx> <rmac>\n", argv[0]);
register_signal(SIGINT, sighandler);
hack_mac(mac_own, argv[2], strlen(argv[2]));
hack_mac(mac_remote, argv[3], strlen(argv[3]));
sd = socket(AF_LANA, SOCK_RAW, 0);
if (sd < 0)
panic("%s: cannot open socket \n", argv[0]);
printf("If ready hit key!\n"); //user must do binding
getchar();
dev = alsa_open(argv[1], SAMPLING_RATE, CHANNELS, FRAME_SIZE);
mode = celt_mode_create(SAMPLING_RATE, FRAME_SIZE, NULL);
enc_state = celt_encoder_create(mode, CHANNELS, NULL);
dec_state = celt_decoder_create(mode, CHANNELS, NULL);
param.sched_priority = sched_get_priority_min(SCHED_FIFO);
if (sched_setscheduler(0, SCHED_FIFO, ¶m))
whine("sched_setscheduler error!\n");
/* Setup all file descriptors for poll()ing */
nfds = alsa_nfds(dev);
pfds = xmalloc(sizeof(*pfds) * (nfds + 1));
alsa_getfds(dev, pfds, nfds);
pfds[nfds].fd = sd;
pfds[nfds].events = POLLIN;
/* Setup jitter buffer using decoder */
jitter = jitter_buffer_init(FRAME_SIZE);
tmp = FRAME_SIZE;
jitter_buffer_ctl(jitter, JITTER_BUFFER_SET_MARGIN, &tmp);
/* Echo canceller with 200 ms tail length */
echo_state = speex_echo_state_init(FRAME_SIZE, 10 * FRAME_SIZE);
tmp = SAMPLING_RATE;
speex_echo_ctl(echo_state, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
alsa_start(dev);
printf("ALSA started!\n");
itimer.it_interval.tv_sec = 0;
itimer.it_interval.tv_usec = interval;
itimer.it_value.tv_sec = 0;
itimer.it_value.tv_usec = interval;
setitimer(ITIMER_REAL, &itimer, NULL);
while (!sigint) {
poll(pfds, nfds + 1, -1);
/* Received packets */
if (pfds[nfds].revents & POLLIN) {
memset(msg, 0, MAX_MSG);
n = recv(sd, msg, MAX_MSG, 0);
if (n <= 0)
goto do_alsa;
pkts_in++;
int recv_timestamp;
memcpy(&recv_timestamp, msg, sizeof(recv_timestamp));
JitterBufferPacket packet;
packet.data = msg+4/*+6+6+2*/;
packet.len = n-4/*-6-6-2*/;
packet.timestamp = recv_timestamp;
packet.span = FRAME_SIZE;
packet.sequence = 0;
/* Put content of the packet into the jitter buffer,
except for the pseudo-header */
jitter_buffer_put(jitter, &packet);
recv_started = 1;
}
do_alsa:
/* Ready to play a frame (playback) */
if (alsa_play_ready(dev, pfds, nfds)) {
short pcm[FRAME_SIZE * CHANNELS] = {0};
if (recv_started) {
JitterBufferPacket packet;
/* Get audio from the jitter buffer */
packet.data = msg;
packet.len = MAX_MSG;
jitter_buffer_tick(jitter);
jitter_buffer_get(jitter, &packet, FRAME_SIZE,
NULL);
if (packet.len == 0)
packet.data=NULL;
celt_decode(dec_state, (const unsigned char *)
packet.data, packet.len, pcm);
}
/* Playback the audio and reset the echo canceller
if we got an underrun */
alsa_write(dev, pcm, FRAME_SIZE);
// if (alsa_write(dev, pcm, FRAME_SIZE))
// speex_echo_state_reset(echo_state);
/* Put frame into playback buffer */
// speex_echo_playback(echo_state, pcm);
}
/* Audio available from the soundcard (capture) */
if (alsa_cap_ready(dev, pfds, nfds)) {
short pcm[FRAME_SIZE * CHANNELS];
//pcm2[FRAME_SIZE * CHANNELS];
char outpacket[MAX_MSG];
alsa_read(dev, pcm, FRAME_SIZE);
/* Perform echo cancellation */
// speex_echo_capture(echo_state, pcm, pcm2);
// for (i = 0; i < FRAME_SIZE * CHANNELS; ++i)
// pcm[i] = pcm2[i];
celt_encode(enc_state, pcm, NULL, (unsigned char *)
(outpacket+4+6+6+2), PACKETSIZE);
/* Pseudo header: four null bytes and a 32-bit
timestamp; XXX hack */
memcpy(outpacket,mac_remote,6);
memcpy(outpacket+6,mac_own,6);
outpacket[6+6] = (uint8_t) 0xac;
outpacket[6+6+1] = (uint8_t) 0xdc;
memcpy(outpacket+6+6+2, &send_timestamp, sizeof(send_timestamp));
send_timestamp += FRAME_SIZE;
rc = sendto(sd, outpacket, PACKETSIZE+4+6+6+2, 0, NULL, 0);
if (rc < 0)
panic("cannot send to socket");
pkts_out++;
}
}
itimer.it_interval.tv_sec = 0;
itimer.it_interval.tv_usec = 0;
itimer.it_value.tv_sec = 0;
itimer.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &itimer, NULL);
close(sd);
return 0;
}
int main(int argc, char *argv[])
{
char *inFile, *outFile;
FILE *fin, *fout;
CELTMode *mode=NULL;
CELTEncoder *enc;
CELTDecoder *dec;
int len;
celt_int32_t frame_size, channels;
int bytes_per_packet;
unsigned char data[MAX_PACKET];
int rate;
int complexity;
#if !(defined (FIXED_POINT) && defined(STATIC_MODES))
int i;
double rmsd = 0;
#endif
int count = 0;
celt_int32_t skip;
celt_int16_t *in, *out;
if (argc != 9 && argc != 8 && argc != 7)
{
fprintf (stderr, "Usage: testcelt <rate> <channels> <frame size> "
" <bytes per packet> [<complexity> [packet loss rate]] "
"<input> <output>\n");
return 1;
}
rate = atoi(argv[1]);
channels = atoi(argv[2]);
frame_size = atoi(argv[3]);
mode = celt_mode_create(rate, channels, frame_size, NULL);
celt_mode_info(mode, CELT_GET_LOOKAHEAD, &skip);
if (mode == NULL)
{
fprintf(stderr, "failed to create a mode\n");
return 1;
}
bytes_per_packet = atoi(argv[4]);
if (bytes_per_packet < 0 || bytes_per_packet > MAX_PACKET)
{
fprintf (stderr, "bytes per packet must be between 0 and %d\n",
MAX_PACKET);
return 1;
}
inFile = argv[argc-2];
fin = fopen(inFile, "rb");
if (!fin)
{
fprintf (stderr, "Could not open input file %s\n", argv[argc-2]);
return 1;
}
outFile = argv[argc-1];
fout = fopen(outFile, "wb+");
if (!fout)
{
fprintf (stderr, "Could not open output file %s\n", argv[argc-1]);
return 1;
}
enc = celt_encoder_create(mode);
dec = celt_decoder_create(mode);
if (argc>7)
{
complexity=atoi(argv[5]);
celt_encoder_ctl(enc,CELT_SET_COMPLEXITY(complexity));
}
celt_mode_info(mode, CELT_GET_FRAME_SIZE, &frame_size);
celt_mode_info(mode, CELT_GET_NB_CHANNELS, &channels);
in = (celt_int16_t*)malloc(frame_size*channels*sizeof(celt_int16_t));
out = (celt_int16_t*)malloc(frame_size*channels*sizeof(celt_int16_t));
while (!feof(fin))
{
fread(in, sizeof(short), frame_size*channels, fin);
if (feof(fin))
break;
len = celt_encode(enc, in, in, data, bytes_per_packet);
if (len <= 0)
{
fprintf (stderr, "celt_encode() returned %d\n", len);
return 1;
}
/* This is for simulating bit errors */
#if 0
int errors = 0;
int eid = 0;
/* This simulates random bit error */
for (i=0;i<len*8;i++)
{
if (rand()%atoi(argv[8])==0)
{
if (i<64)
{
errors++;
eid = i;
}
data[i/8] ^= 1<<(7-(i%8));
}
}
if (errors == 1)
data[eid/8] ^= 1<<(7-(eid%8));
else if (errors%2 == 1)
data[rand()%8] ^= 1<<rand()%8;
#endif
#if 1 /* Set to zero to use the encoder's output instead */
/* This is to simulate packet loss */
if (argc==9 && rand()%1000<atoi(argv[argc-3]))
/*if (errors && (errors%2==0))*/
celt_decode(dec, NULL, len, out);
else
celt_decode(dec, data, len, out);
#else
for (i=0;i<frame_size*channels;i++)
out[i] = in[i];
#endif
#if !(defined (FIXED_POINT) && defined(STATIC_MODES))
for (i=0;i<frame_size*channels;i++)
{
rmsd += (in[i]-out[i])*1.0*(in[i]-out[i]);
/*out[i] -= in[i];*/
}
#endif
count++;
fwrite(out+skip, sizeof(short), (frame_size-skip)*channels, fout);
skip = 0;
}
PRINT_MIPS(stderr);
celt_encoder_destroy(enc);
celt_decoder_destroy(dec);
fclose(fin);
fclose(fout);
#if !(defined (FIXED_POINT) && defined(STATIC_MODES))
if (rmsd > 0)
{
rmsd = sqrt(rmsd/(1.0*frame_size*channels*count));
fprintf (stderr, "Error: encoder doesn't match decoder\n");
fprintf (stderr, "RMS mismatch is %f\n", rmsd);
return 1;
} else {
fprintf (stderr, "Encoder matches decoder!!\n");
}
#endif
celt_mode_destroy(mode);
free(in);
free(out);
return 0;
}
