JNIEXPORT jint JNICALL Java_org_thoughtcrime_redphone_codec_SpeexCodec_decode (JNIEnv *env, jobject obj, jbyteArray encArr, jshortArray decArr, jint encLen ){
cenv = env;
if( !initialized ) {
logv(env, "tried to decode without initializing" );
return -1;
}
if (decArr == NULL) {
logv(env, "Speex decode passed a null decode buffer" );
return -1;
}
jint dec_buffer_len = env->GetArrayLength( decArr );
int dec_buffer_idx = 0;
jbyte *jb_enc_stream;
char *enc_stream;
SpeexBits *dbits = NULL; //if this is null, speex will do PLC for us
if( !env->IsSameObject( encArr, NULL ) ) {
jb_enc_stream = env->GetByteArrayElements( encArr, NULL );
enc_stream = (char *)jb_enc_stream;
speex_bits_read_from( &dec_bits, enc_stream, encLen );
env->ReleaseByteArrayElements( encArr, jb_enc_stream, JNI_ABORT );
dbits = &dec_bits;
} else {
// logv( env, "null encArr" );
}
while( 0 == speex_decode_int( dec, dbits, dec_buffer+dec_buffer_idx ) ) {
dec_buffer_idx += dec_frame_size;
if( dec_buffer_idx + dec_frame_size >= dec_buffer_len ) {
logv( env, "out of space in the decArr buffer, idx=%d", dec_buffer_idx );
break;
}
if( dec_buffer_idx + dec_frame_size >= dec_frame_size * MAX_DEC_FRAMES ) {
logv( env, "out of space in the dec_buffer buffer, idx=%d", dec_buffer_idx );
break;
}
if( dbits == NULL ) {
// logv(env, "did PLC" );
break;//only generate one frame for PLC...
}
}
env->SetShortArrayRegion( decArr, 0, dec_buffer_idx, dec_buffer );
return dec_buffer_idx;
}
VideoDecoder* CreateVideoDecoder(void)
{
VideoDecoderContext* p;
logv("CreateVideoDecoder");
p = (VideoDecoderContext*)malloc(sizeof(VideoDecoderContext));
if(p == NULL)
{
loge("memory alloc fail.");
AdpaterRelease(0);
return NULL;
}
memset(p, 0, sizeof(VideoDecoderContext));
//* the partialStreamDataInfo is for data submit status recording.
p->partialStreamDataInfo.nStreamIndex = 0;
p->partialStreamDataInfo.nPts = -1;
p->partialStreamDataInfo.nStreamIndex = 1;
p->partialStreamDataInfo.nPts = -1;
logv("create a video decoder with handle=%p", p);
return (VideoDecoder*)p;
}
void rpl_debug::warn(const char *fmt, ...)
{
va_list vargs;
va_start(vargs,fmt);
logv(LOG_WARNING, fmt, vargs);
}
void rpl_debug::info(const char *fmt, ...)
{
va_list vargs;
va_start(vargs,fmt);
logv(LOG_INFO, fmt, vargs);
}
void logv(const char *file, const char *function, const int line, logging_level logLevel, const char* title, const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
logv(file, function, line, logLevel, title, fmt, ap);
va_end(ap);
}
void Logger::error(const char* fmt, ...){
// print_stack();
va_list vl;
va_start(vl, fmt);
logv(Logger::ERROR, fmt, vl);
va_end(vl);
}
void rpl_debug::error(const char *fmt, ...)
{
va_list vargs;
va_start(vargs,fmt);
logv(LOG_ERR, fmt, vargs);
}
void Log::errorf(const std::string& tag, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
logv(LogLevel::Error, tag, fmt, args);
va_end(args);
}
void loge(ELogLevel level, const char* fmt, ...)
{
va_list argp;
va_start(argp, fmt);
logv(level, fmt, argp);
va_end(argp);
}
void ResetVideoDecoder(VideoDecoder* pDecoder)
{
int i;
VideoDecoderContext* p;
logv("ResetVideoDecoder, pDecoder=%p", pDecoder);
p = (VideoDecoderContext*)pDecoder;
//* reset the video engine.
if(p->pVideoEngine)
{
AdapterLockVideoEngine();
VideoEngineReset(p->pVideoEngine);
AdapterUnLockVideoEngine();
}
if(p->pFbm==NULL && p->pVideoEngine != NULL)
{
AdapterLockVideoEngine();
p->pFbm = VideoEngineGetFbm(p->pVideoEngine, 0);
AdapterUnLockVideoEngine();
}
if(p->pFbm != NULL)
FbmFlush(p->pFbm);
//* flush stream data.
if(p->pSbm != NULL)
SbmReset(p->pSbm);
//* clear the partialStreamDataInfo.
memset(&p->partialStreamDataInfo, 0, sizeof(VideoStreamDataInfo));
return;
}
void Log::logf(LogLevel level, const std::string& tag, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
logv(level, tag, fmt, args);
va_end(args);
}
void Log::warningf(const std::string& tag, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
logv(LogLevel::Warning, tag, fmt, args);
va_end(args);
}
void DestroyVideoDecoder(VideoDecoder* pDecoder)
{
VideoDecoderContext* p;
logv("DestroyVideoDecoder, pDecoder=%p", pDecoder);
p = (VideoDecoderContext*)pDecoder;
//* Destroy the video engine first.
if(p->pVideoEngine != NULL)
{
AdapterLockVideoEngine();
VideoEngineDestroy(p->pVideoEngine);
AdapterUnLockVideoEngine();
}
//* the memory space for codec specific data was allocated in InitializeVideoDecoder.
if(p->videoStreamInfo.pCodecSpecificData != NULL)
free(p->videoStreamInfo.pCodecSpecificData);
//* Destroy the stream buffer manager.
if(p->pSbm != NULL)
SbmDestroy(p->pSbm);
if(p->pSbm != NULL)
SbmDestroy(p->pSbm);
AdpaterRelease();
free(p);
return;
}
/** Logs a formatted error message to a log file(also outputs to stderr).
* \param[in] pszStr - format string for the given parameters
*/
void log_file::loges(const tchar_t* pszStr, ...)
{
va_list va;
va_start(va, pszStr);
logv(level_error, true, pszStr, va);
va_end(va);
}
int GetVideoStreamInfo(VideoDecoder* pDecoder, VideoStreamInfo* pVideoInfo)
{
VideoDecoderContext* p;
logv("GetVideoStreamInfo, pDecoder=%p, pVideoInfo=%p", pDecoder, pVideoInfo);
p = (VideoDecoderContext*)pDecoder;
//* set the video stream information.
pVideoInfo->eCodecFormat = p->videoStreamInfo.eCodecFormat;
pVideoInfo->nWidth = p->videoStreamInfo.nWidth;
pVideoInfo->nHeight = p->videoStreamInfo.nHeight;
pVideoInfo->nFrameRate = p->videoStreamInfo.nFrameRate;
pVideoInfo->nFrameDuration = p->videoStreamInfo.nFrameDuration;
pVideoInfo->nAspectRatio = p->videoStreamInfo.nAspectRatio;
//* print video stream information.
{
logi("Video Stream Information:");
logi(" codec = %s", strCodecFormat[pVideoInfo->eCodecFormat - VIDEO_CODEC_FORMAT_MIN]);
logi(" width = %d pixels", pVideoInfo->nWidth);
logi(" height = %d pixels", pVideoInfo->nHeight);
logi(" frame rate = %d", pVideoInfo->nFrameRate);
logi(" frame duration = %d us", pVideoInfo->nFrameDuration);
logi(" aspect ratio = %d", pVideoInfo->nAspectRatio);
}
return 0;
}
JNIEXPORT jint JNICALL Java_org_thoughtcrime_redphone_codec_SpeexCodec_encode (JNIEnv *env, jobject obj, jshortArray decArr, jbyteArray encArr, jint rawLen ){
if( !initialized ) {
logv( env, "tried to encode without initializing" );
return -1;
}
// logv( env, "entered encode %d", rawLen );
// logv( env, "encoding %d samples", rawLen );
jshort *raw_stream = env->GetShortArrayElements( decArr, NULL );
speex_bits_reset( &enc_bits );
// logv( env, "bits reset" );
// speex_preprocess_run( prepState, (spx_int16_t *)raw_stream );
speex_encode_int( enc, (spx_int16_t *)raw_stream, &enc_bits );
// logv( env, "encode complete" );
env->ReleaseShortArrayElements( decArr, raw_stream, JNI_ABORT );
// logv( env, "writing up to %d bytes to buffer", enc_frame_size );
int nbytes = speex_bits_write( &enc_bits, enc_buffer, enc_frame_size );
// logv( env, "wrote %d bytes to buffer", nbytes );
env->SetByteArrayRegion( encArr, 0, nbytes, (jbyte*)enc_buffer );
// logv( env, "wrote back to java buffer" );
return (jint)nbytes;
}
void Logger::fatal(const char* fmt, ...){
print_stack();
va_list vl;
va_start(vl, fmt);
logv(Logger::FATAL, fmt, vl);
va_end(vl);
abort();
}
int log_write(int level, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
int ret = logv(level, fmt, ap);
va_end(ap);
return ret;
}
void rpl_debug::debug(unsigned int level, const char *fmt, ...)
{
va_list vargs;
va_start(vargs,fmt);
if(flag_set(level)) {
logv(LOG_DEBUG, fmt, vargs);
}
}
void rpl_debug::log(const char *fmt, ...)
{
va_list vargs;
va_start(vargs,fmt);
if(flag) {
logv(LOG_INFO, fmt, vargs);
}
}
void log(LogLevel prio, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
logv(prio, fmt, ap);
va_end(ap);
}
/** Logs a formatted error message to a log file(also outputs to stderr).
* As an addition the first string %err is replaced with a given error
* followed by the error description (system-based).
* This function differ from logerr() with logging the output string
* also to the stderr.
* \param[in] pszStr - format string for the given parameters
* \param[in] iSysErr - system error to be shown
*/
void log_file::logerrs(const tchar_t* pszStr, int_t iSysErr, ...)
{
tchar_t szNewFmt[2048];
if (prepare_fmt(pszStr, iSysErr, szNewFmt))
{
va_list va;
va_start(va, iSysErr);
logv(level_error, true, szNewFmt, va);
va_end(va);
}
else
{
va_list va;
va_start(va, iSysErr);
logv(level_error, true, pszStr, va);
va_end(va);
}
}
void rpl_debug::verbose(const char *fmt, ...)
{
va_list vargs;
va_start(vargs,fmt);
if(flag) {
logv(LOG_DEBUG, fmt, vargs);
}
}
/** Logs a formatted warning message to a log file(also outputs to stdout).
* \param[in] pszStr - format string for the given parameters
*/
void log_file::logws(const tchar_t* pszStr, ...)
{
if (m_iLogLevel > level_warning)
return;
va_list va;
va_start(va, pszStr);
logv(level_warning, true, pszStr, va);
va_end(va);
}
/** Output a message to the log. */
void
_log(int severity, log_domain_mask_t domain, const char *format, ...)
{
va_list ap;
if (severity > _log_global_min_severity)
return;
va_start(ap,format);
logv(severity, domain, NULL, format, ap);
va_end(ap);
}
/** Logs a formatted informational message to a log file.
* \param[in] pszStr - format string for the given parameters
*/
void log_file::logiv(const tchar_t* pszStr, ...)
{
if (m_iLogLevel > level_info)
return;
va_list va;
va_start(va, pszStr);
logv(level_info, false, pszStr, va);
va_end(va);
}
/** Logs a formatted message to a log file.
* \param[in] iType - type of the log message (LT_*)
* \param[in] bStd - log also to stdout/stderr if true
* \param[in] pszStr - format string for the following parameters
*/
void log_file::log(int_t iType, bool bStd, const tchar_t* pszStr, ...)
{
if (iType < m_iLogLevel)
return;
va_list va;
va_start(va, pszStr);
logv(iType, bStd, pszStr, va);
va_end(va);
}
void hs_log(hs_log_level level, const char *fmt, ...)
{
assert(fmt);
va_list ap;
va_start(ap, fmt);
logv(level, fmt, ap);
va_end(ap);
}
void Log::log(Level level, const char* objectName, size_t objectNameSize, const char* message, ...) {
va_list args;
if(!wouldLog(level))
return;
va_start(args, message);
logv(level, objectName, objectNameSize, message, args);
va_end(args);
}
JNIEXPORT void JNICALL Java_org_thoughtcrime_redphone_codec_SpeexCodec_closeSpeex (JNIEnv *env, jobject obj ){
if( !initialized ) {
logv( env, "tried to shut down speex before initialization" );
return;
}
logv( env, "speex shutdown" );
speex_bits_destroy( &enc_bits );
speex_bits_destroy( &dec_bits );
logv( env, "bits destroyed" );
speex_encoder_destroy( enc );
speex_decoder_destroy( dec );
// jitter_buffer_destroy( jitter );
logv( env, "codecs destroyed" );
}
