static void celt_destroy_decoder(const struct PluginCodec_Definition * codec, void * context)
{
CELTContext * celt = (CELTContext *)context;
celt_decoder_destroy(celt->decoder_state);
celt_mode_destroy(celt->mode);
free(celt);
}
JNIEXPORT void JNICALL Native_NATIVE(celt_1decoder_1destroy)
(JNIEnv *env, jclass that, jlong arg0)
{
Native_NATIVE_ENTER(env, that, Native_celt_1decoder_1destroy_FUNC);
celt_decoder_destroy((CELTDecoder *)(intptr_t)arg0);
Native_NATIVE_EXIT(env, that, Native_celt_1decoder_1destroy_FUNC);
}
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 void JNICALL Java_com_morlunk_jumble_audio_celt11_CELT11JNI_celt_1decoder_1destroy(JNIEnv *jenv, jclass jcls, jlong jarg1) {
CELTDecoder *arg1 = (CELTDecoder *) 0 ;
(void)jenv;
(void)jcls;
arg1 = *(CELTDecoder **)&jarg1;
celt_decoder_destroy(arg1);
}
static void celt_destructor(void *arg)
{
struct aucodec_st *st = arg;
if (st->enc)
celt_encoder_destroy(st->enc);
if (st->dec)
celt_decoder_destroy(st->dec);
if (st->mode)
celt_mode_destroy(st->mode);
mem_deref(st->ac);
}
CeltCodec::~CeltCodec()
{
if (celtMode)
{
if (encoder)
{
celt_encoder_destroy(encoder);
encoder = 0;
}
if (decoder)
{
celt_decoder_destroy(decoder);
decoder = 0;
}
celt_mode_destroy(const_cast<CELTMode*>(celtMode));
}
celtMode = 0;
}
static void
gst_celt_dec_reset (GstCeltDec * dec)
{
gst_segment_init (&dec->segment, GST_FORMAT_UNDEFINED);
dec->granulepos = -1;
dec->packetno = 0;
dec->frame_size = 0;
dec->frame_duration = 0;
if (dec->state) {
celt_decoder_destroy (dec->state);
dec->state = NULL;
}
if (dec->mode) {
celt_mode_destroy (dec->mode);
dec->mode = NULL;
}
memset (&dec->header, 0, sizeof (dec->header));
}
void netjack_detach( netjack_driver_state_t *netj )
{
JSList * node;
for (node = netj->capture_ports; node; node = jack_slist_next (node))
jack_port_unregister (netj->client,
((jack_port_t *) node->data));
jack_slist_free (netj->capture_ports);
netj->capture_ports = NULL;
for (node = netj->capture_srcs; node; node = jack_slist_next (node))
{
#if HAVE_CELT
if( netj->bitdepth == CELT_MODE )
{
CELTDecoder * decoder = node->data;
celt_decoder_destroy(decoder);
}
else
#endif
{
#if HAVE_SAMPLERATE
SRC_STATE * src = node->data;
src_delete(src);
#endif
}
}
jack_slist_free (netj->capture_srcs);
netj->playback_srcs = NULL;
for (node = netj->playback_ports; node; node = jack_slist_next (node))
jack_port_unregister (netj->client,
((jack_port_t *) node->data));
jack_slist_free (netj->playback_ports);
netj->playback_ports = NULL;
for (node = netj->playback_srcs; node; node = jack_slist_next (node))
{
#if HAVE_CELT
if( netj->bitdepth == CELT_MODE )
{
CELTEncoder * encoder = node->data;
celt_encoder_destroy(encoder);
}
else
#endif
{
#if HAVE_SAMPLERATE
SRC_STATE * src = node->data;
src_delete(src);
#endif
}
}
jack_slist_free (netj->playback_srcs);
netj->playback_srcs = NULL;
#if HAVE_CELT
if( netj->bitdepth == CELT_MODE )
celt_mode_destroy(netj->celt_mode);
#endif
}
int main(int argc, char **argv)
{
int c;
int option_index = 0;
char *inFile, *outFile;
FILE *fin, *fout=NULL;
short out[MAX_FRAME_SIZE];
short output[MAX_FRAME_SIZE];
int frame_size=0, granule_frame_size=0;
void *st=NULL;
CELTMode *mode=NULL;
int packet_count=0;
int stream_init = 0;
int quiet = 0;
ogg_int64_t page_granule=0, last_granule=0;
int skip_samples=0, page_nb_packets;
struct option long_options[] =
{
{"help", no_argument, NULL, 0},
{"quiet", no_argument, NULL, 0},
{"version", no_argument, NULL, 0},
{"version-short", no_argument, NULL, 0},
{"rate", required_argument, NULL, 0},
{"mono", no_argument, NULL, 0},
{"stereo", no_argument, NULL, 0},
{"packet-loss", required_argument, NULL, 0},
{0, 0, 0, 0}
};
ogg_sync_state oy;
ogg_page og;
ogg_packet op;
ogg_stream_state os;
int enh_enabled;
int nframes=2;
int print_bitrate=0;
int close_in=0;
int eos=0;
int forceMode=-1;
int audio_size=0;
float loss_percent=-1;
int channels=-1;
int rate=0;
int extra_headers=0;
int wav_format=0;
int lookahead=0;
int celt_serialno = -1;
int firstpacket = 1;
enh_enabled = 1;
/*Process options*/
while(1)
{
c = getopt_long (argc, argv, "hvV",
long_options, &option_index);
if (c==-1)
break;
switch(c)
{
case 0:
if (strcmp(long_options[option_index].name,"help")==0)
{
usage();
exit(0);
} else if (strcmp(long_options[option_index].name,"quiet")==0)
{
quiet = 1;
} else if (strcmp(long_options[option_index].name,"version")==0)
{
version();
exit(0);
} else if (strcmp(long_options[option_index].name,"version-short")==0)
{
version_short();
exit(0);
} else if (strcmp(long_options[option_index].name,"mono")==0)
{
channels=1;
} else if (strcmp(long_options[option_index].name,"stereo")==0)
{
channels=2;
} else if (strcmp(long_options[option_index].name,"rate")==0)
{
rate=atoi (optarg);
} else if (strcmp(long_options[option_index].name,"packet-loss")==0)
{
loss_percent = atof(optarg);
}
break;
case 'h':
usage();
exit(0);
break;
case 'v':
version();
exit(0);
break;
case 'V':
print_bitrate=1;
break;
case '?':
usage();
exit(1);
break;
}
}
if (argc-optind!=2 && argc-optind!=1)
{
usage();
exit(1);
}
inFile=argv[optind];
if (argc-optind==2)
outFile=argv[optind+1];
else
outFile = "";
wav_format = strlen(outFile)>=4 && (
strcmp(outFile+strlen(outFile)-4,".wav")==0
|| strcmp(outFile+strlen(outFile)-4,".WAV")==0);
/*Open input file*/
if (strcmp(inFile, "-")==0)
{
#if defined WIN32 || defined _WIN32
_setmode(_fileno(stdin), _O_BINARY);
#endif
fin=stdin;
}
else
{
fin = fopen(inFile, "rb");
if (!fin)
{
perror(inFile);
exit(1);
}
close_in=1;
}
/*Init Ogg data struct*/
ogg_sync_init(&oy);
/*Main decoding loop*/
while (1)
{
char *data;
int i, nb_read;
/*Get the ogg buffer for writing*/
data = ogg_sync_buffer(&oy, 200);
/*Read bitstream from input file*/
nb_read = fread(data, sizeof(char), 200, fin);
ogg_sync_wrote(&oy, nb_read);
/*Loop for all complete pages we got (most likely only one)*/
while (ogg_sync_pageout(&oy, &og)==1)
{
if (stream_init == 0) {
ogg_stream_init(&os, ogg_page_serialno(&og));
stream_init = 1;
}
if (ogg_page_serialno(&og) != os.serialno) {
/* so all streams are read. */
ogg_stream_reset_serialno(&os, ogg_page_serialno(&og));
}
/*Add page to the bitstream*/
ogg_stream_pagein(&os, &og);
page_granule = ogg_page_granulepos(&og);
page_nb_packets = ogg_page_packets(&og);
if (page_granule>0 && frame_size)
{
/* FIXME: shift the granule values if --force-* is specified */
skip_samples = frame_size*(page_nb_packets*granule_frame_size*nframes - (page_granule-last_granule))/granule_frame_size;
if (ogg_page_eos(&og))
skip_samples = -skip_samples;
/*else if (!ogg_page_bos(&og))
skip_samples = 0;*/
} else
{
skip_samples = 0;
}
/*printf ("page granulepos: %d %d %d\n", skip_samples, page_nb_packets, (int)page_granule);*/
last_granule = page_granule;
/*Extract all available packets*/
while (!eos && ogg_stream_packetout(&os, &op) == 1 && op.bytes>=8)
{
if (!memcmp(op.packet, "CELT ", 8)) {
celt_serialno = os.serialno;
}
if (celt_serialno == -1 || os.serialno != celt_serialno)
break;
/*If first packet, process as CELT header*/
if (packet_count==0)
{
st = process_header(&op, enh_enabled, &frame_size, &granule_frame_size, &rate, &nframes, forceMode, &channels, &lookahead, &extra_headers, quiet, &mode);
if (!st)
exit(1);
if (!nframes)
nframes=1;
fout = out_file_open(outFile, rate, &channels);
} else if (packet_count==1)
{
if (!quiet)
print_comments((char*)op.packet, op.bytes);
} else if (packet_count<=1+extra_headers)
{
/* Ignore extra headers */
} else {
int lost=0;
if (loss_percent>0 && 100*((float)rand())/RAND_MAX<loss_percent)
lost=1;
/*End of stream condition*/
if (op.e_o_s && os.serialno == celt_serialno) /* don't care for anything except celt eos */
eos=1;
{
int ret;
/*Decode frame*/
if (!lost)
ret = celt_decode(st, (unsigned char*)op.packet, op.bytes, output);
else
ret = celt_decode(st, NULL, 0, output);
/*for (i=0;i<frame_size*channels;i++)
printf ("%d\n", (int)output[i]);*/
if (ret!=0)
{
fprintf (stderr, "Decoding error: corrupted stream?\n");
break;
}
if (print_bitrate) {
celt_int32 tmp=op.bytes;
char ch=13;
fputc (ch, stderr);
fprintf (stderr, "Bitrate in use: %d bytes/packet ", tmp);
}
/*Convert to short and save to output file*/
if (strlen(outFile)!=0)
{
for (i=0;i<frame_size*channels;i++)
out[i]=le_short(output[i]);
} else {
for (i=0;i<frame_size*channels;i++)
out[i]=output[i];
}
{
int frame_offset = 0;
int new_frame_size = frame_size;
/*printf ("packet %d %d\n", packet_no, skip_samples);*/
/*fprintf (stderr, "packet %d %d %d\n", packet_no, skip_samples, lookahead);*/
if (firstpacket == 1)
{
/*printf ("chopping first packet\n");*/
new_frame_size -= lookahead;
frame_offset = lookahead;
firstpacket = 0;
}
if (new_frame_size>0)
{
#if defined WIN32 || defined _WIN32
if (strlen(outFile)==0)
WIN_Play_Samples (out+frame_offset*channels, sizeof(short) * new_frame_size*channels);
else
#endif
fwrite(out+frame_offset*channels, sizeof(short), new_frame_size*channels, fout);
audio_size+=sizeof(short)*new_frame_size*channels;
}
}
}
}
packet_count++;
}
}
if (feof(fin))
break;
}
if (fout && wav_format)
{
if (fseek(fout,4,SEEK_SET)==0)
{
int tmp;
tmp = le_int(audio_size+36);
fwrite(&tmp,4,1,fout);
if (fseek(fout,32,SEEK_CUR)==0)
{
tmp = le_int(audio_size);
fwrite(&tmp,4,1,fout);
} else
{
fprintf (stderr, "First seek worked, second didn't\n");
}
} else {
fprintf (stderr, "Cannot seek on wave file, size will be incorrect\n");
}
}
if (st)
{
celt_decoder_destroy(st);
celt_mode_destroy(mode);
} else {
fprintf (stderr, "This doesn't look like a CELT file\n");
}
if (stream_init)
ogg_stream_clear(&os);
ogg_sync_clear(&oy);
#if defined WIN32 || defined _WIN32
if (strlen(outFile)==0)
WIN_Audio_close ();
#endif
if (close_in)
fclose(fin);
if (fout != NULL)
fclose(fout);
return 0;
}
int main(int argc, char *argv[])
{
int err;
char *inFile, *outFile;
FILE *fin, *fout;
CELTMode *mode=NULL;
CELTEncoder *enc;
CELTDecoder *dec;
int len;
celt_int32 frame_size, channels;
int bytes_per_packet;
unsigned char data[MAX_PACKET];
int rate;
int complexity;
#if !(defined (FIXED_POINT) && !defined(CUSTOM_MODES)) && defined(RESYNTH)
int i;
double rmsd = 0;
#endif
int count = 0;
celt_int32 skip;
celt_int16 *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, frame_size, NULL);
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_custom(mode, channels, &err);
if (err != 0)
{
fprintf(stderr, "Failed to create the encoder: %s\n", celt_strerror(err));
return 1;
}
dec = celt_decoder_create_custom(mode, channels, &err);
if (err != 0)
{
fprintf(stderr, "Failed to create the decoder: %s\n", celt_strerror(err));
return 1;
}
celt_decoder_ctl(dec, CELT_GET_LOOKAHEAD(&skip));
if (argc>7)
{
complexity=atoi(argv[5]);
celt_encoder_ctl(enc,CELT_SET_COMPLEXITY(complexity));
}
in = (celt_int16*)malloc(frame_size*channels*sizeof(celt_int16));
out = (celt_int16*)malloc(frame_size*channels*sizeof(celt_int16));
while (!feof(fin))
{
int ret;
err = fread(in, sizeof(short), frame_size*channels, fin);
if (feof(fin))
break;
len = celt_encode(enc, in, frame_size, data, bytes_per_packet);
if (len <= 0)
fprintf (stderr, "celt_encode() failed: %s\n", celt_strerror(len));
/* 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))*/
ret = celt_decode(dec, NULL, len, out, frame_size);
else
ret = celt_decode(dec, data, len, out, frame_size);
if (ret < 0)
fprintf(stderr, "celt_decode() failed: %s\n", celt_strerror(ret));
#else
for (i=0;i<ret*channels;i++)
out[i] = in[i];
#endif
#if !(defined (FIXED_POINT) && !defined(CUSTOM_MODES)) && defined(RESYNTH)
for (i=0;i<ret*channels;i++)
{
rmsd += (in[i]-out[i])*1.0*(in[i]-out[i]);
/*out[i] -= in[i];*/
}
#endif
count++;
fwrite(out+skip*channels, sizeof(short), (ret-skip)*channels, fout);
skip = 0;
}
PRINT_MIPS(stderr);
celt_encoder_destroy(enc);
celt_decoder_destroy(dec);
fclose(fin);
fclose(fout);
celt_mode_destroy(mode);
free(in);
free(out);
#if !(defined (FIXED_POINT) && !defined(CUSTOM_MODES)) && defined(RESYNTH)
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
return 0;
}