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

Sharing more macros between the Opus code and the CELT low-level code

Browse source
This commit is contained in:
Jean-Marc Valin 2011-08-31 17:47:48 -04:00
parent 875f8dbd56
commit f9e701ad24
8 changed files with 244 additions and 242 deletions
Download patch file Download diff file Expand all files Collapse all files

88
libcelt/celt.c
View file

@ -203,7 +203,7 @@ CELTEncoder *celt_encoder_create_custom(const CELTMode *mode, int channels, int
CELTEncoder *st = (CELTEncoder *)opus_alloc(celt_encoder_get_size_custom(mode, channels)); CELTEncoder *st = (CELTEncoder *)opus_alloc(celt_encoder_get_size_custom(mode, channels));
/* init will handle the NULL case */ /* init will handle the NULL case */
ret = celt_encoder_init_custom(st, mode, channels); ret = celt_encoder_init_custom(st, mode, channels);
if (ret != CELT_OK) if (ret != OPUS_OK)
{ {
celt_encoder_destroy(st); celt_encoder_destroy(st);
st = NULL; st = NULL;
@ -217,22 +217,22 @@ int celt_encoder_init(CELTEncoder *st, int sampling_rate, int channels)
{ {
int ret; int ret;
ret = celt_encoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels); ret = celt_encoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels);
if (ret != CELT_OK) if (ret != OPUS_OK)
return ret; return ret;
st->upsample = resampling_factor(sampling_rate); st->upsample = resampling_factor(sampling_rate);
if (st->upsample==0) if (st->upsample==0)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
else else
return CELT_OK; return OPUS_OK;
} }
int celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int channels) int celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int channels)
{ {
if (channels < 0 || channels > 2) if (channels < 0 || channels > 2)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
if (st==NULL || mode==NULL) if (st==NULL || mode==NULL)
return CELT_ALLOC_FAIL; return OPUS_ALLOC_FAIL;
OPUS_CLEAR((char*)st, celt_encoder_get_size_custom(mode, channels)); OPUS_CLEAR((char*)st, celt_encoder_get_size_custom(mode, channels));
@ -259,7 +259,7 @@ int celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int channels
st->tapset_decision = 0; st->tapset_decision = 0;
st->complexity = 5; st->complexity = 5;
return CELT_OK; return OPUS_OK;
} }
void celt_encoder_destroy(CELTEncoder *st) void celt_encoder_destroy(CELTEncoder *st)
@ -919,14 +919,14 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
ALLOC_STACK; ALLOC_STACK;
if (nbCompressedBytes<2 || pcm==NULL) if (nbCompressedBytes<2 || pcm==NULL)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
frame_size *= st->upsample; frame_size *= st->upsample;
for (LM=0;LM<=st->mode->maxLM;LM++) for (LM=0;LM<=st->mode->maxLM;LM++)
if (st->mode->shortMdctSize<<LM==frame_size) if (st->mode->shortMdctSize<<LM==frame_size)
break; break;
if (LM>st->mode->maxLM) if (LM>st->mode->maxLM)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
M=1<<LM; M=1<<LM;
N = M*st->mode->shortMdctSize; N = M*st->mode->shortMdctSize;
@ -956,7 +956,7 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
{ {
int c0 = toOpus(compressed[0]); int c0 = toOpus(compressed[0]);
if (c0<0) if (c0<0)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
compressed[0] = c0; compressed[0] = c0;
} }
compressed++; compressed++;
@ -1641,7 +1641,7 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
RESTORE_STACK; RESTORE_STACK;
if (ec_get_error(enc)) if (ec_get_error(enc))
return CELT_INTERNAL_ERROR; return OPUS_INTERNAL_ERROR;
else else
return nbCompressedBytes; return nbCompressedBytes;
} }
@ -1662,7 +1662,7 @@ int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_si
ALLOC_STACK; ALLOC_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
C = CHANNELS(st->channels); C = CHANNELS(st->channels);
N = frame_size; N = frame_size;
@ -1689,7 +1689,7 @@ int celt_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_siz
ALLOC_STACK; ALLOC_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
C=CHANNELS(st->channels); C=CHANNELS(st->channels);
N=frame_size; N=frame_size;
@ -1721,7 +1721,7 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
va_start(ap, request); va_start(ap, request);
switch (request) switch (request)
{ {
case CELT_SET_COMPLEXITY_REQUEST: case OPUS_SET_COMPLEXITY_REQUEST:
{ {
int value = va_arg(ap, opus_int32); int value = va_arg(ap, opus_int32);
if (value<0 || value>10) if (value<0 || value>10)
@ -1754,7 +1754,7 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
st->force_intra = value==0; st->force_intra = value==0;
} }
break; break;
case CELT_SET_LOSS_PERC_REQUEST: case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
{ {
int value = va_arg(ap, opus_int32); int value = va_arg(ap, opus_int32);
if (value<0 || value>100) if (value<0 || value>100)
@ -1762,19 +1762,19 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
st->loss_rate = value; st->loss_rate = value;
} }
break; break;
case CELT_SET_VBR_CONSTRAINT_REQUEST: case OPUS_SET_VBR_CONSTRAINT_REQUEST:
{ {
opus_int32 value = va_arg(ap, opus_int32); opus_int32 value = va_arg(ap, opus_int32);
st->constrained_vbr = value; st->constrained_vbr = value;
} }
break; break;
case CELT_SET_VBR_REQUEST: case OPUS_SET_VBR_REQUEST:
{ {
opus_int32 value = va_arg(ap, opus_int32); opus_int32 value = va_arg(ap, opus_int32);
st->vbr = value; st->vbr = value;
} }
break; break;
case CELT_SET_BITRATE_REQUEST: case OPUS_SET_BITRATE_REQUEST:
{ {
opus_int32 value = va_arg(ap, opus_int32); opus_int32 value = va_arg(ap, opus_int32);
if (value<=500 && value!=-1) if (value<=500 && value!=-1)
@ -1791,7 +1791,7 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
st->stream_channels = value; st->stream_channels = value;
} }
break; break;
case CELT_RESET_STATE: case OPUS_RESET_STATE:
{ {
OPUS_CLEAR((char*)&st->ENCODER_RESET_START, OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
celt_encoder_get_size_custom(st->mode, st->channels)- celt_encoder_get_size_custom(st->mode, st->channels)-
@ -1823,7 +1823,7 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
*value=st->mode; *value=st->mode;
} }
break; break;
case CELT_GET_RANGE_REQUEST: case OPUS_GET_FINAL_RANGE_REQUEST:
{ {
opus_uint32 * value = va_arg(ap, opus_uint32 *); opus_uint32 * value = va_arg(ap, opus_uint32 *);
if (value==0) if (value==0)
@ -1836,13 +1836,13 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
goto bad_request; goto bad_request;
} }
va_end(ap); va_end(ap);
return CELT_OK; return OPUS_OK;
bad_arg: bad_arg:
va_end(ap); va_end(ap);
return CELT_BAD_ARG; return OPUS_BAD_ARG;
bad_request: bad_request:
va_end(ap); va_end(ap);
return CELT_UNIMPLEMENTED; return OPUS_UNIMPLEMENTED;
} }
/**********************************************************************/ /**********************************************************************/
@ -1909,7 +1909,7 @@ CELTDecoder *celt_decoder_create_custom(const CELTMode *mode, int channels, int
int ret; int ret;
CELTDecoder *st = (CELTDecoder *)opus_alloc(celt_decoder_get_size_custom(mode, channels)); CELTDecoder *st = (CELTDecoder *)opus_alloc(celt_decoder_get_size_custom(mode, channels));
ret = celt_decoder_init_custom(st, mode, channels); ret = celt_decoder_init_custom(st, mode, channels);
if (ret != CELT_OK) if (ret != OPUS_OK)
{ {
celt_decoder_destroy(st); celt_decoder_destroy(st);
st = NULL; st = NULL;
@ -1923,22 +1923,22 @@ int celt_decoder_init(CELTDecoder *st, int sampling_rate, int channels)
{ {
int ret; int ret;
ret = celt_decoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels); ret = celt_decoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels);
if (ret != CELT_OK) if (ret != OPUS_OK)
return ret; return ret;
st->downsample = resampling_factor(sampling_rate); st->downsample = resampling_factor(sampling_rate);
if (st->downsample==0) if (st->downsample==0)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
else else
return CELT_OK; return OPUS_OK;
} }
int celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int channels) int celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int channels)
{ {
if (channels < 0 || channels > 2) if (channels < 0 || channels > 2)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
if (st==NULL) if (st==NULL)
return CELT_ALLOC_FAIL; return OPUS_ALLOC_FAIL;
OPUS_CLEAR((char*)st, celt_decoder_get_size_custom(mode, channels)); OPUS_CLEAR((char*)st, celt_decoder_get_size_custom(mode, channels));
@ -1953,7 +1953,7 @@ int celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int channels
st->loss_count = 0; st->loss_count = 0;
return CELT_OK; return OPUS_OK;
} }
void celt_decoder_destroy(CELTDecoder *st) void celt_decoder_destroy(CELTDecoder *st)
@ -2280,7 +2280,7 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
{ {
data0 = fromOpus(data0); data0 = fromOpus(data0);
if (data0<0) if (data0<0)
return CELT_CORRUPTED_DATA; return OPUS_CORRUPTED_DATA;
} }
st->end = IMAX(1, st->mode->effEBands-2*(data0>>5)); st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
LM = (data0>>3)&0x3; LM = (data0>>3)&0x3;
@ -2288,9 +2288,9 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
data++; data++;
len--; len--;
if (LM>st->mode->maxLM) if (LM>st->mode->maxLM)
return CELT_CORRUPTED_DATA; return OPUS_CORRUPTED_DATA;
if (frame_size < st->mode->shortMdctSize<<LM) if (frame_size < st->mode->shortMdctSize<<LM)
return CELT_BUFFER_TOO_SMALL; return OPUS_BUFFER_TOO_SMALL;
else else
frame_size = st->mode->shortMdctSize<<LM; frame_size = st->mode->shortMdctSize<<LM;
} else { } else {
@ -2298,12 +2298,12 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
if (st->mode->shortMdctSize<<LM==frame_size) if (st->mode->shortMdctSize<<LM==frame_size)
break; break;
if (LM>st->mode->maxLM) if (LM>st->mode->maxLM)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
} }
M=1<<LM; M=1<<LM;
if (len<0 || len>1275 || pcm==NULL) if (len<0 || len>1275 || pcm==NULL)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
N = M*st->mode->shortMdctSize; N = M*st->mode->shortMdctSize;
@ -2575,7 +2575,7 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
st->loss_count = 0; st->loss_count = 0;
RESTORE_STACK; RESTORE_STACK;
if (ec_tell(dec) > 8*len) if (ec_tell(dec) > 8*len)
return CELT_INTERNAL_ERROR; return OPUS_INTERNAL_ERROR;
if(ec_get_error(dec)) if(ec_get_error(dec))
st->error = 1; st->error = 1;
return frame_size/st->downsample; return frame_size/st->downsample;
@ -2597,7 +2597,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
ALLOC_STACK; ALLOC_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
C = CHANNELS(st->channels); C = CHANNELS(st->channels);
N = frame_size; N = frame_size;
@ -2627,7 +2627,7 @@ int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, o
ALLOC_STACK; ALLOC_STACK;
if (pcm==NULL) if (pcm==NULL)
return CELT_BAD_ARG; return OPUS_BAD_ARG;
C = CHANNELS(st->channels); C = CHANNELS(st->channels);
N = frame_size; N = frame_size;
@ -2686,7 +2686,7 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
st->error = 0; st->error = 0;
} }
break; break;
case CELT_GET_LOOKAHEAD_REQUEST: case OPUS_GET_LOOKAHEAD_REQUEST:
{ {
int *value = va_arg(ap, int*); int *value = va_arg(ap, int*);
if (value==NULL) if (value==NULL)
@ -2694,7 +2694,7 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
*value = st->overlap/st->downsample; *value = st->overlap/st->downsample;
} }
break; break;
case CELT_RESET_STATE: case OPUS_RESET_STATE:
{ {
OPUS_CLEAR((char*)&st->DECODER_RESET_START, OPUS_CLEAR((char*)&st->DECODER_RESET_START,
celt_decoder_get_size_custom(st->mode, st->channels)- celt_decoder_get_size_custom(st->mode, st->channels)-
@ -2716,7 +2716,7 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
st->signalling = value; st->signalling = value;
} }
break; break;
case CELT_GET_RANGE_REQUEST: case OPUS_GET_FINAL_RANGE_REQUEST:
{ {
opus_uint32 * value = va_arg(ap, opus_uint32 *); opus_uint32 * value = va_arg(ap, opus_uint32 *);
if (value==0) if (value==0)
@ -2729,13 +2729,13 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
goto bad_request; goto bad_request;
} }
va_end(ap); va_end(ap);
return CELT_OK; return OPUS_OK;
bad_arg: bad_arg:
va_end(ap); va_end(ap);
return CELT_BAD_ARG; return OPUS_BAD_ARG;
bad_request: bad_request:
va_end(ap); va_end(ap);
return CELT_UNIMPLEMENTED; return OPUS_UNIMPLEMENTED;
} }
const char *celt_strerror(int error) const char *celt_strerror(int error)

67
libcelt/celt.h
View file

@ -36,6 +36,7 @@
#define CELT_H #define CELT_H
#include "opus_types.h" #include "opus_types.h"
#include "opus_defines.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -49,81 +50,35 @@ extern "C" {
#define CELT_EXPORT #define CELT_EXPORT
#endif #endif
#define _celt_check_int(x) (((void)((x) == (opus_int32)0)), (opus_int32)(x))
#define _celt_check_mode_ptr_ptr(ptr) ((ptr) + ((ptr) - (const CELTMode**)(ptr))) #define _celt_check_mode_ptr_ptr(ptr) ((ptr) + ((ptr) - (const CELTMode**)(ptr)))
#define _celt_check_int_ptr(ptr) ((ptr) + ((ptr) - (opus_int32*)(ptr)))
#define _celt_check_uint_ptr(ptr) ((ptr) + ((ptr) - (opus_uint32*)(ptr)))
/* Error codes */
/** No error */
#define CELT_OK 0
/** An (or more) invalid argument (e.g. out of range) */
#define CELT_BAD_ARG -1
/** The mode struct passed is invalid */
#define CELT_BUFFER_TOO_SMALL -2
/** An internal error was detected */
#define CELT_INTERNAL_ERROR -3
/** The data passed (e.g. compressed data to decoder) is corrupted */
#define CELT_CORRUPTED_DATA -4
/** Invalid/unsupported request number */
#define CELT_UNIMPLEMENTED -5
/** An encoder or decoder structure is invalid or already freed */
#define CELT_INVALID_STATE -6
/** Memory allocation has failed */
#define CELT_ALLOC_FAIL -7
/* Encoder/decoder Requests */ /* Encoder/decoder Requests */
#define CELT_SET_COMPLEXITY_REQUEST 2 #define CELT_SET_PREDICTION_REQUEST 3002
/** Controls the complexity from 0-10 (int) */
#define CELT_SET_COMPLEXITY(x) CELT_SET_COMPLEXITY_REQUEST, _celt_check_int(x)
#define CELT_SET_PREDICTION_REQUEST 4
/** Controls the use of interframe prediction. /** Controls the use of interframe prediction.
0=Independent frames 0=Independent frames
1=Short term interframe prediction allowed 1=Short term interframe prediction allowed
2=Long term prediction allowed 2=Long term prediction allowed
*/ */
#define CELT_SET_PREDICTION(x) CELT_SET_PREDICTION_REQUEST, _celt_check_int(x) #define CELT_SET_PREDICTION(x) CELT_SET_PREDICTION_REQUEST, __opus_check_int(x)
#define CELT_SET_BITRATE_REQUEST 6 #define CELT_SET_INPUT_CLIPPING_REQUEST 3004
/** Set the target VBR rate in bits per second(int); 0=CBR (default) */ #define CELT_SET_INPUT_CLIPPING(x) CELT_SET_INPUT_CLIPPING_REQUEST, __opus_check_int(x)
#define CELT_SET_BITRATE(x) CELT_SET_BITRATE_REQUEST, _celt_check_int(x)
#define CELT_RESET_STATE_REQUEST 8 #define CELT_GET_AND_CLEAR_ERROR_REQUEST 3005
/** Reset the encoder/decoder memories to zero*/ #define CELT_GET_AND_CLEAR_ERROR(x) CELT_GET_AND_CLEAR_ERROR_REQUEST, __opus_check_int_ptr(x)
#define CELT_RESET_STATE CELT_RESET_STATE_REQUEST
#define CELT_SET_VBR_CONSTRAINT_REQUEST 10 #define CELT_SET_CHANNELS_REQUEST 3008
#define CELT_SET_VBR_CONSTRAINT(x) CELT_SET_VBR_CONSTRAINT_REQUEST, _celt_check_int(x) #define CELT_SET_CHANNELS(x) CELT_SET_CHANNELS_REQUEST, __opus_check_int(x)
#define CELT_SET_VBR_REQUEST 12
#define CELT_SET_VBR(x) CELT_SET_VBR_REQUEST, _celt_check_int(x)
#define CELT_SET_INPUT_CLIPPING_REQUEST 14
#define CELT_SET_INPUT_CLIPPING(x) CELT_SET_INPUT_CLIPPING_REQUEST, _celt_check_int(x)
#define CELT_GET_AND_CLEAR_ERROR_REQUEST 15
#define CELT_GET_AND_CLEAR_ERROR(x) CELT_GET_AND_CLEAR_ERROR_REQUEST, _celt_check_int_ptr(x)
#define CELT_GET_LOOKAHEAD_REQUEST 17
#define CELT_GET_LOOKAHEAD(x) CELT_GET_LOOKAHEAD_REQUEST, _celt_check_int_ptr(x)
#define CELT_SET_CHANNELS_REQUEST 18
#define CELT_SET_CHANNELS(x) CELT_SET_CHANNELS_REQUEST, _celt_check_int(x)
#define CELT_SET_LOSS_PERC_REQUEST 20
#define CELT_SET_LOSS_PERC(x) CELT_SET_LOSS_PERC_REQUEST, _celt_check_int(x)
/* Internal */ /* Internal */
#define CELT_SET_START_BAND_REQUEST 10000 #define CELT_SET_START_BAND_REQUEST 10000
#define CELT_SET_START_BAND(x) CELT_SET_START_BAND_REQUEST, _celt_check_int(x) #define CELT_SET_START_BAND(x) CELT_SET_START_BAND_REQUEST, __opus_check_int(x)
#define CELT_SET_END_BAND_REQUEST 10001 #define CELT_SET_END_BAND_REQUEST 10001
#define CELT_SET_END_BAND(x) CELT_SET_END_BAND_REQUEST, _celt_check_int(x) #define CELT_SET_END_BAND(x) CELT_SET_END_BAND_REQUEST, __opus_check_int(x)
#define CELT_GET_RANGE_REQUEST 10002
#define CELT_GET_RANGE(x) CELT_GET_RANGE_REQUEST, _celt_check_uint_ptr(x)
/** Contains the state of an encoder. One encoder state is needed /** Contains the state of an encoder. One encoder state is needed
for each stream. It is initialised once at the beginning of the for each stream. It is initialised once at the beginning of the

16
libcelt/modes.c
View file

@ -246,7 +246,7 @@ CELTMode *celt_mode_create(opus_int32 Fs, int frame_size, int *error)
(frame_size<<j) == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts) (frame_size<<j) == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
{ {
if (error) if (error)
*error = CELT_OK; *error = OPUS_OK;
return (CELTMode*)static_mode_list[i]; return (CELTMode*)static_mode_list[i];
} }
} }
@ -255,7 +255,7 @@ CELTMode *celt_mode_create(opus_int32 Fs, int frame_size, int *error)
#ifndef CUSTOM_MODES #ifndef CUSTOM_MODES
if (error) if (error)
*error = CELT_BAD_ARG; *error = OPUS_BAD_ARG;
return NULL; return NULL;
#else #else
@ -264,20 +264,20 @@ CELTMode *celt_mode_create(opus_int32 Fs, int frame_size, int *error)
if (Fs < 8000 || Fs > 96000) if (Fs < 8000 || Fs > 96000)
{ {
if (error) if (error)
*error = CELT_BAD_ARG; *error = OPUS_BAD_ARG;
return NULL; return NULL;
} }
if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0) if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
{ {
if (error) if (error)
*error = CELT_BAD_ARG; *error = OPUS_BAD_ARG;
return NULL; return NULL;
} }
/* Frames of less than 1ms are not supported. */ /* Frames of less than 1ms are not supported. */
if ((opus_int32)frame_size*1000 < Fs) if ((opus_int32)frame_size*1000 < Fs)
{ {
if (error) if (error)
*error = CELT_BAD_ARG; *error = OPUS_BAD_ARG;
return NULL; return NULL;
} }
@ -299,7 +299,7 @@ CELTMode *celt_mode_create(opus_int32 Fs, int frame_size, int *error)
if ((opus_int32)(frame_size>>LM)*300 > Fs) if ((opus_int32)(frame_size>>LM)*300 > Fs)
{ {
if (error) if (error)
*error = CELT_BAD_ARG; *error = OPUS_BAD_ARG;
return NULL; return NULL;
} }
@ -385,12 +385,12 @@ CELTMode *celt_mode_create(opus_int32 Fs, int frame_size, int *error)
goto failure; goto failure;
if (error) if (error)
*error = CELT_OK; *error = OPUS_OK;
return mode; return mode;
failure: failure:
if (error) if (error)
*error = CELT_ALLOC_FAIL; *error = OPUS_ALLOC_FAIL;
if (mode!=NULL) if (mode!=NULL)
celt_mode_destroy(mode); celt_mode_destroy(mode);
return NULL; return NULL;

2
libcelt/modes.h
View file

@ -95,7 +95,7 @@ struct CELTMode {
#ifdef OPUS_BUILD #ifdef OPUS_BUILD
#define CELT_SET_SIGNALLING_REQUEST 10003 #define CELT_SET_SIGNALLING_REQUEST 10003
#define CELT_SET_SIGNALLING(x) CELT_SET_SIGNALLING_REQUEST, _celt_check_int(x) #define CELT_SET_SIGNALLING(x) CELT_SET_SIGNALLING_REQUEST, __opus_check_int(x)
#define CELT_GET_MODE_REQUEST 10004 #define CELT_GET_MODE_REQUEST 10004
/** Get the CELTMode used by an encoder or decoder */ /** Get the CELTMode used by an encoder or decoder */

157
libcelt/opus_defines.h Normal file
View file

@ -0,0 +1,157 @@
/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
Written by Jean-Marc Valin and Koen Vos */
/*
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef OPUS_DEFINES_H
#define OPUS_DEFINES_H
#include "opus_types.h"
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__GNUC__) && defined(OPUS_BUILD)
# define OPUS_EXPORT __attribute__ ((visibility ("default")))
#elif defined(WIN32)
# ifdef OPUS_BUILD
# define OPUS_EXPORT __declspec(dllexport)
# else
# define OPUS_EXPORT __declspec(dllimport)
# endif
#else
# define OPUS_EXPORT
#endif
#define __opus_check_int(x) (((void)((x) == (opus_int32)0)), (opus_int32)(x))
#define __opus_check_int_ptr(ptr) ((ptr) + ((ptr) - (opus_int32*)(ptr)))
#define __opus_check_uint_ptr(ptr) ((ptr) + ((ptr) - (opus_uint32*)(ptr)))
/* Error codes */
/** No error */
#define OPUS_OK 0
/** An (or more) invalid argument (e.g. out of range) */
#define OPUS_BAD_ARG -1
/** The mode struct passed is invalid */
#define OPUS_BUFFER_TOO_SMALL -2
/** An internal error was detected */
#define OPUS_INTERNAL_ERROR -3
/** The data passed (e.g. compressed data to decoder) is corrupted */
#define OPUS_CORRUPTED_DATA -4
/** Invalid/unsupported request number */
#define OPUS_UNIMPLEMENTED -5
/** An encoder or decoder structure is invalid or already freed */
#define OPUS_INVALID_STATE -6
/** Memory allocation has failed */
#define OPUS_ALLOC_FAIL -7
/* OPUS_APPLICATION_VOIP or OPUS_APPLICATION_AUDIO */
#define OPUS_SET_APPLICATION_REQUEST 0
#define OPUS_SET_APPLICATION(x) OPUS_SET_APPLICATION_REQUEST, __opus_check_int(x)
#define OPUS_GET_APPLICATION_REQUEST 1
#define OPUS_GET_APPLICATION(x) OPUS_GET_APPLICATION_REQUEST, __opus_check_int_ptr(x)
/* Coding bit-rate in bit/second */
#define OPUS_SET_BITRATE_REQUEST 2
#define OPUS_SET_BITRATE(x) OPUS_SET_BITRATE_REQUEST, __opus_check_int(x)
#define OPUS_GET_BITRATE_REQUEST 3
#define OPUS_GET_BITRATE(x) OPUS_GET_BITRATE_REQUEST, __opus_check_int_ptr(x)
/* 0 for CBR, 1 for VBR */
#define OPUS_SET_VBR_REQUEST 6
#define OPUS_SET_VBR(x) OPUS_SET_VBR_REQUEST, __opus_check_int(x)
#define OPUS_GET_VBR_REQUEST 7
#define OPUS_GET_VBR(x) OPUS_GET_VBR_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_BANDWIDTH_REQUEST 8
#define OPUS_SET_BANDWIDTH(x) OPUS_SET_BANDWIDTH_REQUEST, __opus_check_int(x)
#define OPUS_GET_BANDWIDTH_REQUEST 9
#define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_COMPLEXITY_REQUEST 10
#define OPUS_SET_COMPLEXITY(x) OPUS_SET_COMPLEXITY_REQUEST, __opus_check_int(x)
#define OPUS_GET_COMPLEXITY_REQUEST 11
#define OPUS_GET_COMPLEXITY(x) OPUS_GET_COMPLEXITY_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_INBAND_FEC_REQUEST 12
#define OPUS_SET_INBAND_FEC(x) OPUS_SET_INBAND_FEC_REQUEST, __opus_check_int(x)
#define OPUS_GET_INBAND_FEC_REQUEST 13
#define OPUS_GET_INBAND_FEC(x) OPUS_GET_INBAND_FEC_REQUEST, __opus_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, __opus_check_int(x)
#define OPUS_GET_PACKET_LOSS_PERC_REQUEST 15
#define OPUS_GET_PACKET_LOSS_PERC(x) OPUS_GET_PACKET_LOSS_PERC_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_DTX_REQUEST 16
#define OPUS_SET_DTX(x) OPUS_SET_DTX_REQUEST, __opus_check_int(x)
#define OPUS_GET_DTX_REQUEST 17
#define OPUS_GET_DTX(x) OPUS_GET_DTX_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_VOICE_RATIO_REQUEST 18
#define OPUS_SET_VOICE_RATIO(x) OPUS_SET_VOICE_RATIO_REQUEST, __opus_check_int(x)
#define OPUS_GET_VOICE_RATIO_REQUEST 19
#define OPUS_GET_VOICE_RATIO(x) OPUS_GET_VOICE_RATIO_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_VBR_CONSTRAINT_REQUEST 20
#define OPUS_SET_VBR_CONSTRAINT(x) OPUS_SET_VBR_CONSTRAINT_REQUEST, __opus_check_int(x)
#define OPUS_GET_VBR_CONSTRAINT_REQUEST 21
#define OPUS_GET_VBR_CONSTRAINT(x) OPUS_GET_VBR_CONSTRAINT_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_FORCE_MONO_REQUEST 22
#define OPUS_SET_FORCE_MONO(x) OPUS_SET_FORCE_MONO_REQUEST, __opus_check_int(x)
#define OPUS_GET_FORCE_MONO_REQUEST 23
#define OPUS_GET_FORCE_MONO(x) OPUS_GET_FORCE_MONO_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_SIGNAL_REQUEST 24
#define OPUS_SET_SIGNAL(x) OPUS_SET_SIGNAL_REQUEST, __opus_check_int(x)
#define OPUS_GET_SIGNAL_REQUEST 25
#define OPUS_GET_SIGNAL(x) OPUS_GET_SIGNAL_REQUEST, __opus_check_int_ptr(x)
#define OPUS_GET_LOOKAHEAD_REQUEST 27
#define OPUS_GET_LOOKAHEAD(x) OPUS_GET_LOOKAHEAD_REQUEST, __opus_check_int_ptr(x)
#define OPUS_RESET_STATE 28
/* For testing purposes: the encoder and decoder state should
always be identical after coding a payload */
#define OPUS_GET_FINAL_RANGE_REQUEST 29
#define OPUS_GET_FINAL_RANGE(x) OPUS_GET_FINAL_RANGE_REQUEST, __opus_check_uint_ptr(x)
#ifdef __cplusplus
}
#endif
#endif /* OPUS_H */

112
src/opus.h
View file

@ -29,50 +29,12 @@
#define OPUS_H #define OPUS_H
#include "opus_types.h" #include "opus_types.h"
#include "opus_defines.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if defined(__GNUC__) && defined(OPUS_BUILD)
# define OPUS_EXPORT __attribute__ ((visibility ("default")))
#elif defined(WIN32)
# ifdef OPUS_BUILD
# define OPUS_EXPORT __declspec(dllexport)
# else
# define OPUS_EXPORT __declspec(dllimport)
# endif
#else
# define OPUS_EXPORT
#endif
#define __opus_check_int(x) (((void)((x) == (opus_int32)0)), (opus_int32)(x))
#define __opus_check_int_ptr(ptr) ((ptr) + ((ptr) - (opus_int32*)(ptr)))
#define __opus_check_uint_ptr(ptr) ((ptr) + ((ptr) - (opus_uint32*)(ptr)))
/* Error codes */
/** No error */
#define OPUS_OK 0
/** An (or more) invalid argument (e.g. out of range) */
#define OPUS_BAD_ARG -1
/** The mode struct passed is invalid */
#define OPUS_BUFFER_TOO_SMALL -2
/** An internal error was detected */
#define OPUS_INTERNAL_ERROR -3
/** The data passed (e.g. compressed data to decoder) is corrupted */
#define OPUS_CORRUPTED_DATA -4
/** Invalid/unsupported request number */
#define OPUS_UNIMPLEMENTED -5
/** An encoder or decoder structure is invalid or already freed */
#define OPUS_INVALID_STATE -6
/** Memory allocation has failed */
#define OPUS_ALLOC_FAIL -7
#define OPUS_BITRATE_AUTO -1 #define OPUS_BITRATE_AUTO -1
@ -91,78 +53,6 @@ extern "C" {
#define OPUS_BANDWIDTH_FULLBAND 1105 #define OPUS_BANDWIDTH_FULLBAND 1105
/* OPUS_APPLICATION_VOIP or OPUS_APPLICATION_AUDIO */
#define OPUS_SET_APPLICATION_REQUEST 0
#define OPUS_SET_APPLICATION(x) OPUS_SET_APPLICATION_REQUEST, __opus_check_int(x)
#define OPUS_GET_APPLICATION_REQUEST 1
#define OPUS_GET_APPLICATION(x) OPUS_GET_APPLICATION_REQUEST, __opus_check_int_ptr(x)
/* Coding bit-rate in bit/second */
#define OPUS_SET_BITRATE_REQUEST 2
#define OPUS_SET_BITRATE(x) OPUS_SET_BITRATE_REQUEST, __opus_check_int(x)
#define OPUS_GET_BITRATE_REQUEST 3
#define OPUS_GET_BITRATE(x) OPUS_GET_BITRATE_REQUEST, __opus_check_int_ptr(x)
/* 0 for CBR, 1 for VBR */
#define OPUS_SET_VBR_REQUEST 6
#define OPUS_SET_VBR(x) OPUS_SET_VBR_REQUEST, __opus_check_int(x)
#define OPUS_GET_VBR_REQUEST 7
#define OPUS_GET_VBR(x) OPUS_GET_VBR_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_BANDWIDTH_REQUEST 8
#define OPUS_SET_BANDWIDTH(x) OPUS_SET_BANDWIDTH_REQUEST, __opus_check_int(x)
#define OPUS_GET_BANDWIDTH_REQUEST 9
#define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_COMPLEXITY_REQUEST 10
#define OPUS_SET_COMPLEXITY(x) OPUS_SET_COMPLEXITY_REQUEST, __opus_check_int(x)
#define OPUS_GET_COMPLEXITY_REQUEST 11
#define OPUS_GET_COMPLEXITY(x) OPUS_GET_COMPLEXITY_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_INBAND_FEC_REQUEST 12
#define OPUS_SET_INBAND_FEC(x) OPUS_SET_INBAND_FEC_REQUEST, __opus_check_int(x)
#define OPUS_GET_INBAND_FEC_REQUEST 13
#define OPUS_GET_INBAND_FEC(x) OPUS_GET_INBAND_FEC_REQUEST, __opus_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, __opus_check_int(x)
#define OPUS_GET_PACKET_LOSS_PERC_REQUEST 15
#define OPUS_GET_PACKET_LOSS_PERC(x) OPUS_GET_PACKET_LOSS_PERC_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_DTX_REQUEST 16
#define OPUS_SET_DTX(x) OPUS_SET_DTX_REQUEST, __opus_check_int(x)
#define OPUS_GET_DTX_REQUEST 17
#define OPUS_GET_DTX(x) OPUS_GET_DTX_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_VOICE_RATIO_REQUEST 18
#define OPUS_SET_VOICE_RATIO(x) OPUS_SET_VOICE_RATIO_REQUEST, __opus_check_int(x)
#define OPUS_GET_VOICE_RATIO_REQUEST 19
#define OPUS_GET_VOICE_RATIO(x) OPUS_GET_VOICE_RATIO_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_VBR_CONSTRAINT_REQUEST 20
#define OPUS_SET_VBR_CONSTRAINT(x) OPUS_SET_VBR_CONSTRAINT_REQUEST, __opus_check_int(x)
#define OPUS_GET_VBR_CONSTRAINT_REQUEST 21
#define OPUS_GET_VBR_CONSTRAINT(x) OPUS_GET_VBR_CONSTRAINT_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_FORCE_MONO_REQUEST 22
#define OPUS_SET_FORCE_MONO(x) OPUS_SET_FORCE_MONO_REQUEST, __opus_check_int(x)
#define OPUS_GET_FORCE_MONO_REQUEST 23
#define OPUS_GET_FORCE_MONO(x) OPUS_GET_FORCE_MONO_REQUEST, __opus_check_int_ptr(x)
#define OPUS_SET_SIGNAL_REQUEST 24
#define OPUS_SET_SIGNAL(x) OPUS_SET_SIGNAL_REQUEST, __opus_check_int(x)
#define OPUS_GET_SIGNAL_REQUEST 25
#define OPUS_GET_SIGNAL(x) OPUS_GET_SIGNAL_REQUEST, __opus_check_int_ptr(x)
#define OPUS_GET_LOOKAHEAD_REQUEST 27
#define OPUS_GET_LOOKAHEAD(x) OPUS_GET_LOOKAHEAD_REQUEST, __opus_check_int_ptr(x)
#define OPUS_RESET_STATE 28
/* For testing purposes: the encoder and decoder state should
always be identical after coding a payload */
#define OPUS_GET_FINAL_RANGE_REQUEST 29
#define OPUS_GET_FINAL_RANGE(x) OPUS_GET_FINAL_RANGE_REQUEST, __opus_check_uint_ptr(x)
typedef struct OpusEncoder OpusEncoder; typedef struct OpusEncoder OpusEncoder;
typedef struct OpusDecoder OpusDecoder; typedef struct OpusDecoder OpusDecoder;

14
src/opus_decoder.c
View file

@ -110,7 +110,7 @@ int opus_decoder_init(OpusDecoder *st, int Fs, int channels)
/* Initialize CELT decoder */ /* Initialize CELT decoder */
ret = celt_decoder_init(celt_dec, Fs, channels); ret = celt_decoder_init(celt_dec, Fs, channels);
if (ret != CELT_OK) if (ret != OPUS_OK)
goto failure; goto failure;
celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0)); celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));
@ -373,15 +373,15 @@ static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
{ {
celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)); celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL); celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
celt_decoder_ctl(celt_dec, CELT_GET_RANGE(&redundant_rng)); celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
celt_decoder_ctl(celt_dec, CELT_RESET_STATE); celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
} }
/* MUST be after PLC */ /* MUST be after PLC */
celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band)); celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band));
if (transition) if (transition)
celt_decoder_ctl(celt_dec, CELT_RESET_STATE); celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
if (mode != MODE_SILK_ONLY) if (mode != MODE_SILK_ONLY)
{ {
@ -413,11 +413,11 @@ static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
/* 5 ms redundant frame for SILK->CELT */ /* 5 ms redundant frame for SILK->CELT */
if (redundancy && !celt_to_silk) if (redundancy && !celt_to_silk)
{ {
celt_decoder_ctl(celt_dec, CELT_RESET_STATE); celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)); celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0));
celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL); celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL);
celt_decoder_ctl(celt_dec, CELT_GET_RANGE(&redundant_rng)); celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng));
smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5, smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,
pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs); pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);
} }
@ -766,7 +766,7 @@ int opus_decoder_ctl(OpusDecoder *st, int request, ...)
opus_decoder_get_size(st->channels)- opus_decoder_get_size(st->channels)-
((char*)&st->OPUS_DECODER_RESET_START - (char*)st)); ((char*)&st->OPUS_DECODER_RESET_START - (char*)st));
celt_decoder_ctl(celt_dec, CELT_RESET_STATE); celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);
silk_InitDecoder( silk_dec ); silk_InitDecoder( silk_dec );
st->stream_channels = st->channels; st->stream_channels = st->channels;
st->frame_size = st->Fs/400; st->frame_size = st->Fs/400;

30
src/opus_encoder.c
View file

@ -155,7 +155,7 @@ int opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
/* Create CELT encoder */ /* Create CELT encoder */
/* Initialize CELT encoder */ /* Initialize CELT encoder */
err = celt_encoder_init(celt_enc, Fs, channels); err = celt_encoder_init(celt_enc, Fs, channels);
if (err != CELT_OK) if (err != OPUS_OK)
goto failure; goto failure;
celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0)); celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
@ -593,12 +593,12 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
} }
if (st->mode != MODE_SILK_ONLY) if (st->mode != MODE_SILK_ONLY)
{ {
celt_encoder_ctl(celt_enc, CELT_SET_VBR(0)); celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(-1)); celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(-1));
if (st->prev_mode == MODE_SILK_ONLY) if (st->prev_mode == MODE_SILK_ONLY)
{ {
unsigned char dummy[10]; unsigned char dummy[10];
celt_encoder_ctl(celt_enc, CELT_RESET_STATE); celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
/* TODO: This wastes CPU a bit compared to just prefilling the buffer */ /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
@ -621,9 +621,9 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
} else { } else {
if (st->use_vbr) if (st->use_vbr)
{ {
celt_encoder_ctl(celt_enc, CELT_SET_VBR(1)); celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
celt_encoder_ctl(celt_enc, CELT_SET_VBR_CONSTRAINT(st->vbr_constraint)); celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
celt_encoder_ctl(celt_enc, CELT_SET_BITRATE(st->bitrate_bps)); celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
nb_compr_bytes = max_data_bytes-1; nb_compr_bytes = max_data_bytes-1;
} else { } else {
nb_compr_bytes = bytes_target; nb_compr_bytes = bytes_target;
@ -703,10 +703,10 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
if (redundancy && celt_to_silk) if (redundancy && celt_to_silk)
{ {
celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
celt_encoder_ctl(celt_enc, CELT_SET_VBR(0)); celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL); celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng)); celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
celt_encoder_ctl(celt_enc, CELT_RESET_STATE); celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
} }
celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band)); celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
@ -723,7 +723,7 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
N2 = st->Fs/200; N2 = st->Fs/200;
N4 = st->Fs/400; N4 = st->Fs/400;
celt_encoder_ctl(celt_enc, CELT_RESET_STATE); celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
@ -731,7 +731,7 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL); celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL); celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
celt_encoder_ctl(celt_enc, CELT_GET_RANGE(&redundant_rng)); celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
} }
@ -894,7 +894,7 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
{ {
opus_int32 value = va_arg(ap, opus_int32); opus_int32 value = va_arg(ap, opus_int32);
st->silk_mode.complexity = value; st->silk_mode.complexity = value;
celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value)); celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
} }
break; break;
case OPUS_GET_COMPLEXITY_REQUEST: case OPUS_GET_COMPLEXITY_REQUEST:
@ -921,7 +921,7 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
if (value < 0 || value > 100) if (value < 0 || value > 100)
return OPUS_BAD_ARG; return OPUS_BAD_ARG;
st->silk_mode.packetLossPercentage = value; st->silk_mode.packetLossPercentage = value;
celt_encoder_ctl(celt_enc, CELT_SET_LOSS_PERC(value)); celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
} }
break; break;
case OPUS_GET_PACKET_LOSS_PERC_REQUEST: case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
@ -1003,7 +1003,7 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
opus_encoder_get_size(st->channels)- opus_encoder_get_size(st->channels)-
((char*)&st->OPUS_ENCODER_RESET_START - (char*)st)); ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
celt_encoder_ctl(celt_enc, CELT_RESET_STATE); celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
silk_InitEncoder( silk_enc, &dummy ); silk_InitEncoder( silk_enc, &dummy );
st->stream_channels = st->channels; st->stream_channels = st->channels;
st->hybrid_stereo_width_Q14 = 1 << 14; st->hybrid_stereo_width_Q14 = 1 << 14;