eden-emu/opus
19
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merged Koen's encoder changes

Browse source
This commit is contained in:
Jean-Marc Valin 2011-02-01 10:35:23 -05:00
parent a70729c0b4
commit 2b68ea9a11
5 changed files with 191 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

37
src/opus.h
View file

@ -64,15 +64,40 @@ extern "C" {
#define OPUS_GET_MODE_REQUEST 1 #define OPUS_GET_MODE_REQUEST 1
#define OPUS_GET_MODE(x) OPUS_GET_MODE_REQUEST, __check_int_ptr(x) #define OPUS_GET_MODE(x) OPUS_GET_MODE_REQUEST, __check_int_ptr(x)
#define OPUS_SET_BANDWIDTH_REQUEST 2 #define OPUS_SET_BITRATE_REQUEST 2
#define OPUS_SET_BITRATE(x) OPUS_SET_BITRATE_REQUEST, __check_int(x)
#define OPUS_GET_BITRATE_REQUEST 3
#define OPUS_GET_BITRATE(x) OPUS_GET_BITRATE_REQUEST, __check_int_ptr(x)
#define OPUS_SET_VBR_FLAG_REQUEST 6
#define OPUS_SET_VBR_FLAG(x) OPUS_SET_VBR_FLAG_REQUEST, __check_int(x)
#define OPUS_GET_VBR_FLAG_REQUEST 7
#define OPUS_GET_VBR_FLAG(x) OPUS_GET_VBR_FLAG_REQUEST, __check_int_ptr(x)
#define OPUS_SET_BANDWIDTH_REQUEST 8
#define OPUS_SET_BANDWIDTH(x) OPUS_SET_BANDWIDTH_REQUEST, __check_int(x) #define OPUS_SET_BANDWIDTH(x) OPUS_SET_BANDWIDTH_REQUEST, __check_int(x)
#define OPUS_GET_BANDWIDTH_REQUEST 3 #define OPUS_GET_BANDWIDTH_REQUEST 9
#define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __check_int_ptr(x) #define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __check_int_ptr(x)
#define OPUS_SET_VBR_RATE_REQUEST 4 #define OPUS_SET_COMPLEXITY_REQUEST 10
#define OPUS_SET_VBR_RATE(x) OPUS_SET_VBR_RATE_REQUEST, __check_int(x) #define OPUS_SET_COMPLEXITY(x) OPUS_SET_COMPLEXITY_REQUEST, __check_int(x)
#define OPUS_GET_VBR_RATE_REQUEST 5 #define OPUS_GET_COMPLEXITY_REQUEST 11
#define OPUS_GET_VBR_RATE(x) OPUS_GET_VBR_RATE_REQUEST, __check_int_ptr(x) #define OPUS_GET_COMPLEXITY(x) OPUS_GET_COMPLEXITY_REQUEST, __check_int_ptr(x)
#define OPUS_SET_INBAND_FEC_FLAG_REQUEST 12
#define OPUS_SET_INBAND_FEC_FLAG(x) OPUS_SET_INBAND_FEC_FLAG_REQUEST, __check_int(x)
#define OPUS_GET_INBAND_FEC_FLAG_REQUEST 13
#define OPUS_GET_INBAND_FEC_FLAG(x) OPUS_GET_INBAND_FEC_FLAG_REQUEST, __check_int_ptr(x)
#define OPUS_SET_PACKET_LOSS_PERC_REQUEST 14
#define OPUS_SET_PACKET_LOSS_PERC(x) OPUS_SET_PACKET_LOSS_PERC_REQUEST, __check_int(x)
#define OPUS_GET_PACKET_LOSS_PERC_REQUEST 15
#define OPUS_GET_PACKET_LOSS_PERC(x) OPUS_GET_PACKET_LOSS_PERC_REQUEST, __check_int_ptr(x)
#define OPUS_SET_DTX_FLAG_REQUEST 16
#define OPUS_SET_DTX_FLAG(x) OPUS_SET_DTX_FLAG_REQUEST, __check_int(x)
#define OPUS_GET_DTX_FLAG_REQUEST 17
#define OPUS_GET_DTX_FLAG(x) OPUS_GET_DTX_FLAG_REQUEST, __check_int_ptr(x)
typedef struct OpusEncoder OpusEncoder; typedef struct OpusEncoder OpusEncoder;
typedef struct OpusDecoder OpusDecoder; typedef struct OpusDecoder OpusDecoder;

3
src/opus_enc.c
View file

@ -106,9 +106,6 @@ int main(int argc, char *argv[])
opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(BANDWIDTH_FULLBAND)); opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(BANDWIDTH_FULLBAND));
opus_encoder_ctl(enc, OPUS_SET_MODE(mode)); opus_encoder_ctl(enc, OPUS_SET_MODE(mode));
if (vbr)
opus_encoder_ctl(enc, OPUS_SET_VBR_RATE(vbr));
in = (short*)malloc(frame_size*channels*sizeof(short)); in = (short*)malloc(frame_size*channels*sizeof(short));
while (!stop) while (!stop)
{ {

232
src/opus_encoder.c
View file

@ -46,7 +46,6 @@ OpusEncoder *opus_encoder_create(int Fs, int channels)
char *raw_state; char *raw_state;
OpusEncoder *st; OpusEncoder *st;
int ret, silkEncSizeBytes, celtEncSizeBytes; int ret, silkEncSizeBytes, celtEncSizeBytes;
SKP_SILK_SDK_EncControlStruct encControl;
/* Create SILK encoder */ /* Create SILK encoder */
ret = SKP_Silk_SDK_Get_Encoder_Size( &silkEncSizeBytes ); ret = SKP_Silk_SDK_Get_Encoder_Size( &silkEncSizeBytes );
@ -62,29 +61,35 @@ OpusEncoder *opus_encoder_create(int Fs, int channels)
st->Fs = Fs; st->Fs = Fs;
/*encControl.API_sampleRate = st->Fs; ret = SKP_Silk_SDK_InitEncoder( st->silk_enc, &st->silk_mode );
encControl.packetLossPercentage = 0;
encControl.useInBandFEC = 0;
encControl.useDTX = 0;
encControl.complexity = 2;*/
ret = SKP_Silk_SDK_InitEncoder( st->silk_enc, &encControl );
if( ret ) { if( ret ) {
/* Handle error */ /* Handle error */
} }
/* default SILK parameters */
st->silk_mode.API_sampleRate = st->Fs;
st->silk_mode.maxInternalSampleRate = 16000;
st->silk_mode.minInternalSampleRate = 8000;
st->silk_mode.payloadSize_ms = 20;
st->silk_mode.packetLossPercentage = 0;
st->silk_mode.useInBandFEC = 0;
st->silk_mode.useDTX = 0;
st->silk_mode.complexity = 2;
/* Create CELT encoder */ /* Create CELT encoder */
/* Initialize CELT encoder */ /* Initialize CELT encoder */
st->celt_enc = celt_encoder_init(st->celt_enc, Fs, channels, NULL); st->celt_enc = celt_encoder_init(st->celt_enc, Fs, channels, NULL);
st->mode = MODE_HYBRID; st->mode = MODE_HYBRID;
st->bandwidth = BANDWIDTH_FULLBAND; st->bandwidth = BANDWIDTH_FULLBAND;
st->vbr_rate = 0; st->use_vbr = 0;
st->bitrate_bps = 32000;
return st; return st;
} }
int opus_encode(OpusEncoder *st, const short *pcm, int frame_size, int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
unsigned char *data, int bytes_per_packet) unsigned char *data, int max_data_bytes)
{ {
int i; int i;
int ret=0; int ret=0;
@ -93,64 +98,64 @@ int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
ec_byte_buffer buf; ec_byte_buffer buf;
SKP_SILK_SDK_EncControlStruct encControl; SKP_SILK_SDK_EncControlStruct encControl;
int framerate, period; int framerate, period;
int silk_internal_bandwidth;
int bytes_target;
bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
bytes_per_packet -= 1;
data += 1; data += 1;
ec_byte_writeinit_buffer(&buf, data, bytes_per_packet); ec_byte_writeinit_buffer(&buf, data, max_data_bytes-1);
ec_enc_init(&enc,&buf); ec_enc_init(&enc,&buf);
if (st->mode != MODE_CELT_ONLY) /* SILK processing */
{ if (st->mode != MODE_CELT_ONLY)
/* Set Encoder parameters */ {
encControl.API_sampleRate = st->Fs; st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
encControl.packetLossPercentage = 2; if( st->mode == MODE_HYBRID ) {
encControl.useInBandFEC = 0; /* FIXME: Tune this offset */
encControl.useDTX = 0; st->silk_mode.bitRate = (st->silk_mode.bitRate + 12000) / 2;
encControl.complexity = 2; /* FIXME: Adjust for 10 ms frames */
}
if (st->vbr_rate != 0) st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
encControl.bitRate = (st->vbr_rate+6000)/2; if (st->bandwidth == BANDWIDTH_NARROWBAND) {
else { st->silk_mode.maxInternalSampleRate = 8000;
encControl.bitRate = (bytes_per_packet*8*(celt_int32)st->Fs/frame_size+6000)/2; } else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
if (st->Fs == 100 * frame_size) st->silk_mode.maxInternalSampleRate = 12000;
encControl.bitRate -= 5000; } else {
} SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == BANDWIDTH_WIDEBAND );
encControl.payloadSize_ms = 1000 * frame_size / st->Fs; st->silk_mode.maxInternalSampleRate = 16000;
}
if( st->mode == MODE_HYBRID ) {
/* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
st->silk_mode.minInternalSampleRate = st->silk_mode.maxInternalSampleRate ;
}
if (st->mode == MODE_HYBRID) /* Call SILK encoder for the low band */
encControl.minInternalSampleRate = 16000; nBytes = max_data_bytes-1;
else ret = SKP_Silk_SDK_Encode( st->silk_enc, &st->silk_mode, pcm, frame_size, &enc, &nBytes );
encControl.minInternalSampleRate = 8000; if( ret ) {
fprintf (stderr, "SILK encode error: %d\n", ret);
/* Handle error */
}
/* Extract SILK internal bandwidth for signaling in first byte */
if( st->mode == MODE_SILK_ONLY ) {
if( st->silk_mode.internalSampleRate == 8000 ) {
silk_internal_bandwidth = BANDWIDTH_NARROWBAND;
} else if( st->silk_mode.internalSampleRate == 12000 ) {
silk_internal_bandwidth = BANDWIDTH_MEDIUMBAND;
} else if( st->silk_mode.internalSampleRate == 16000 ) {
silk_internal_bandwidth = BANDWIDTH_WIDEBAND;
}
}
}
if (st->bandwidth == BANDWIDTH_NARROWBAND) /* CELT processing */
encControl.maxInternalSampleRate = 8000; if (st->mode != MODE_SILK_ONLY)
else if (st->bandwidth == BANDWIDTH_MEDIUMBAND)
encControl.maxInternalSampleRate = 12000;
else
encControl.maxInternalSampleRate = 16000;
/* Call SILK encoder for the low band */
nBytes = bytes_per_packet;
ret = SKP_Silk_SDK_Encode( st->silk_enc, &encControl, pcm, frame_size, &enc, &nBytes );
if( ret ) {
fprintf (stderr, "SILK encode error %d\n", ret);
/* Handle error */
}
ret = (ec_enc_tell(&enc, 0)+7)>>3;
}
if (st->mode == MODE_HYBRID)
{
/* This should be adjusted based on the SILK bandwidth */
celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(17));
} else {
celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
}
if (st->mode != MODE_SILK_ONLY && st->bandwidth > BANDWIDTH_WIDEBAND)
{ {
int endband; int endband;
short pcm_buf[960*2]; short pcm_buf[960*2];
int nb_compr_bytes;
switch(st->bandwidth) switch(st->bandwidth)
{ {
@ -170,28 +175,37 @@ int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
celt_encoder_ctl(st->celt_enc, CELT_SET_END_BAND(endband)); celt_encoder_ctl(st->celt_enc, CELT_SET_END_BAND(endband));
celt_encoder_ctl(st->celt_enc, CELT_SET_CHANNELS(st->stream_channels)); celt_encoder_ctl(st->celt_enc, CELT_SET_CHANNELS(st->stream_channels));
if (st->mode == MODE_HYBRID)
{
int len;
celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(17));
len = (ec_enc_tell(&enc, 0)+7)>>3;
if( st->use_vbr ) {
nb_compr_bytes = len + (st->bitrate_bps - 12000) * frame_size / (2 * 8 * st->Fs);
} else {
/* check if SILK used up too much */
nb_compr_bytes = len > bytes_target ? len : bytes_target;
}
} else {
celt_encoder_ctl(st->celt_enc, CELT_SET_START_BAND(0));
nb_compr_bytes = bytes_target;
}
for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++) for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++)
pcm_buf[i] = st->delay_buffer[i]; pcm_buf[i] = st->delay_buffer[i];
for (;i<frame_size*st->channels;i++) for (;i<frame_size*st->channels;i++)
pcm_buf[i] = pcm[i-ENCODER_DELAY_COMPENSATION*st->channels]; pcm_buf[i] = pcm[i-ENCODER_DELAY_COMPENSATION*st->channels];
celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(1)); ec_byte_shrink(&buf, nb_compr_bytes);
if (st->vbr_rate != 0)
{
int tmp;
tmp = (st->mode == MODE_HYBRID) ? (st->vbr_rate-6000)/2 : st->vbr_rate;
tmp = ((ec_enc_tell(&enc, 0)+4)>>3) + tmp * frame_size/(8*st->Fs);
if (tmp <= bytes_per_packet)
bytes_per_packet = tmp;
ec_byte_shrink(&buf, bytes_per_packet);
}
/* Encode high band with CELT */ /* Encode high band with CELT */
ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, bytes_per_packet, &enc); ret = celt_encode_with_ec(st->celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++) for (i=0;i<ENCODER_DELAY_COMPENSATION*st->channels;i++)
st->delay_buffer[i] = pcm[frame_size*st->channels-ENCODER_DELAY_COMPENSATION*st->channels+i]; st->delay_buffer[i] = pcm[frame_size*st->channels-ENCODER_DELAY_COMPENSATION*st->channels+i];
} else { } else {
ret = (ec_enc_tell(&enc, 0)+7)>>3;
ec_enc_done(&enc); ec_enc_done(&enc);
} }
@ -206,7 +220,7 @@ int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
} }
if (st->mode == MODE_SILK_ONLY) if (st->mode == MODE_SILK_ONLY)
{ {
data[0] = (st->bandwidth-BANDWIDTH_NARROWBAND)<<5; data[0] = (silk_internal_bandwidth-BANDWIDTH_NARROWBAND)<<5;
data[0] |= (period-2)<<3; data[0] |= (period-2)<<3;
} else if (st->mode == MODE_CELT_ONLY) } else if (st->mode == MODE_CELT_ONLY)
{ {
@ -216,7 +230,7 @@ int opus_encode(OpusEncoder *st, const short *pcm, int frame_size,
data[0] = 0x80; data[0] = 0x80;
data[0] |= tmp << 5; data[0] |= tmp << 5;
data[0] |= period<<3; data[0] |= period<<3;
} else /* Opus */ } else /* Hybrid */
{ {
data[0] = 0x60; data[0] = 0x60;
data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4; data[0] |= (st->bandwidth-BANDWIDTH_SUPERWIDEBAND)<<4;
@ -248,10 +262,29 @@ void opus_encoder_ctl(OpusEncoder *st, int request, ...)
*value = st->mode; *value = st->mode;
} }
break; break;
case OPUS_SET_BITRATE_REQUEST:
{
int value = va_arg(ap, int);
st->bitrate_bps = value;
}
break;
case OPUS_GET_BITRATE_REQUEST:
{
int *value = va_arg(ap, int*);
*value = st->bitrate_bps;
}
break;
case OPUS_SET_BANDWIDTH_REQUEST: case OPUS_SET_BANDWIDTH_REQUEST:
{ {
int value = va_arg(ap, int); int value = va_arg(ap, int);
st->bandwidth = value; st->bandwidth = value;
if (st->bandwidth == BANDWIDTH_NARROWBAND) {
st->silk_mode.maxInternalSampleRate = 8000;
} else if (st->bandwidth == BANDWIDTH_MEDIUMBAND) {
st->silk_mode.maxInternalSampleRate = 12000;
} else {
st->silk_mode.maxInternalSampleRate = 16000;
}
} }
break; break;
case OPUS_GET_BANDWIDTH_REQUEST: case OPUS_GET_BANDWIDTH_REQUEST:
@ -260,16 +293,65 @@ void opus_encoder_ctl(OpusEncoder *st, int request, ...)
*value = st->bandwidth; *value = st->bandwidth;
} }
break; break;
case OPUS_SET_VBR_RATE_REQUEST: case OPUS_SET_DTX_FLAG_REQUEST:
{ {
int value = va_arg(ap, int); int value = va_arg(ap, int);
st->vbr_rate = value; st->silk_mode.useDTX = value;
} }
break; break;
case OPUS_GET_VBR_RATE_REQUEST: case OPUS_GET_DTX_FLAG_REQUEST:
{ {
int *value = va_arg(ap, int*); int *value = va_arg(ap, int*);
*value = st->vbr_rate; *value = st->silk_mode.useDTX;
}
break;
case OPUS_SET_COMPLEXITY_REQUEST:
{
int value = va_arg(ap, int);
st->silk_mode.complexity = value;
}
break;
case OPUS_GET_COMPLEXITY_REQUEST:
{
int *value = va_arg(ap, int*);
*value = st->silk_mode.complexity;
}
break;
case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
{
int value = va_arg(ap, int);
st->silk_mode.useInBandFEC = value;
}
break;
case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
{
int *value = va_arg(ap, int*);
*value = st->silk_mode.useInBandFEC;
}
break;
case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
{
int value = va_arg(ap, int);
st->silk_mode.packetLossPercentage = value;
}
break;
case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
{
int *value = va_arg(ap, int*);
*value = st->silk_mode.packetLossPercentage;
}
break;
case OPUS_SET_VBR_FLAG_REQUEST:
{
int value = va_arg(ap, int);
st->use_vbr = value;
st->silk_mode.useCBR = 1-value;
}
break;
case OPUS_GET_VBR_FLAG_REQUEST:
{
int *value = va_arg(ap, int*);
*value = st->use_vbr;
} }
break; break;
default: default:

4
src/opus_encoder.h
View file

@ -41,15 +41,17 @@
struct OpusEncoder { struct OpusEncoder {
CELTEncoder *celt_enc; CELTEncoder *celt_enc;
SKP_SILK_SDK_EncControlStruct silk_mode;
void *silk_enc; void *silk_enc;
int channels; int channels;
int stream_channels; int stream_channels;
int mode; int mode;
int bandwidth; int bandwidth;
int vbr_rate;
/* Sampling rate (at the API level) */ /* Sampling rate (at the API level) */
int Fs; int Fs;
int use_vbr;
int bitrate_bps;
short delay_buffer[ENCODER_DELAY_COMPENSATION*2]; short delay_buffer[ENCODER_DELAY_COMPENSATION*2];
}; };

3
src/test_opus.c
View file

@ -112,9 +112,6 @@ int main(int argc, char *argv[])
opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(BANDWIDTH_FULLBAND)); opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(BANDWIDTH_FULLBAND));
opus_encoder_ctl(enc, OPUS_SET_MODE(mode)); opus_encoder_ctl(enc, OPUS_SET_MODE(mode));
if (vbr)
opus_encoder_ctl(enc, OPUS_SET_VBR_RATE(vbr));
skip = 5*rate/1000 + 10; skip = 5*rate/1000 + 10;
in = (short*)malloc(frame_size*channels*sizeof(short)); in = (short*)malloc(frame_size*channels*sizeof(short));