status_t SoftAMRNBEncoder::initEncoder() {
if (AMREncodeInit(&mEncState, &mSidState, false /* dtx_enable */) != 0) {
return UNKNOWN_ERROR;
}
return OK;
}
status_t AMRNBEncoder::start(MetaData *params) {
if (mStarted) {
LOGW("Call start() when encoder already started");
return OK;
}
mBufferGroup = new MediaBufferGroup;
mBufferGroup->add_buffer(new MediaBuffer(32));
CHECK_EQ(AMREncodeInit(
&mEncState, &mSidState, false /* dtx_enable */),
0);
mSource->start(params);
mAnchorTimeUs = 0;
mNumFramesOutput = 0;
mStarted = true;
mNumInputSamples = 0;
int32_t bitrate;
if (params && params->findInt32(kKeyBitRate, &bitrate)) {
mMode = PickModeFromBitrate(bitrate);
} else {
mMode = MR475;
}
return OK;
}
OSCL_EXPORT_REF int32 CPvGsmAmrEncoder::InitializeEncoder(int32 aMaxOutputBufferSize, TEncodeProperties* aProps)
{
if (aProps == NULL)
{
// use default parameters
TEncodeProperties dfltProps;
aProps = &dfltProps;
dfltProps.iInBitsPerSample = KDFLT_GAMR_BITS_PER_SAMPLE;
dfltProps.iInSamplingRate = KDFLT_GAMR_SAMPLING_RATE;
dfltProps.iInClockRate = dfltProps.iInSamplingRate;
dfltProps.iInNumChannels = KDFLT_GAMR_NUM_CHANNELS;
iGsmAmrMode = (GSM_AMR_MODES)KDFLT_GAMR_MODE;
iBitStreamFormat = AMR_TX_WMF;
}
else
{
// check first if input parameters are valid
if ((IsModeValid(aProps->iMode) == false) ||
(aProps->iInBitsPerSample == 0) ||
(aProps->iInClockRate == 0) ||
(aProps->iInSamplingRate == 0) ||
(aProps->iInNumChannels == 0))
{
return GSMAMR_ENC_INVALID_PARAM;
}
// set AMR mode (bits per second)
iGsmAmrMode = (GSM_AMR_MODES)aProps->iMode;
if (aProps->iBitStreamFormat == AMR_TX_WMF)
{
iBitStreamFormat = AMR_TX_WMF;
}
else if (aProps->iBitStreamFormat == AMR_TX_IF2)
{
iBitStreamFormat = AMR_TX_IF2;
}
else
{
iBitStreamFormat = AMR_TX_ETS;
}
}
iBytesPerSample = aProps->iInBitsPerSample / 8;
// set maximum buffer size for encoded data
iMaxOutputBufferSize = aMaxOutputBufferSize;
// return output parameters that will be used
aProps->iOutSamplingRate = KDFLT_GAMR_SAMPLING_RATE;
aProps->iOutNumChannels = KDFLT_GAMR_NUM_CHANNELS;
aProps->iOutClockRate = aProps->iOutSamplingRate;
// initialize AMR encoder
int32 nResult = AMREncodeInit(&iEncState, &iSidState, false);
if (nResult < 0) return(GSMAMR_ENC_CODEC_INIT_FAILURE);
return GSMAMR_ENC_NO_ERROR;
}
// USELESS METHOD
PJ_DECL(pj_status_t) test_audio_dev(unsigned int clock_rate, unsigned int ptime) {
pj_status_t status = PJ_SUCCESS;
void * handle = dlopen("libstagefright.so", RTLD_LAZY);
unsigned int (* AMREncodeInit) (void**, void**, int) = dlsym(handle, "AMREncodeInit");
PJ_LOG(1,(THIS_FILE, "Performing test.. %x, %x", handle, AMREncodeInit));
if(AMREncodeInit != NULL){
void* encState;
void* sidState;
int test = AMREncodeInit(&encState, &sidState, 0);
PJ_LOG(1,(THIS_FILE, "Performing test : %d, %x", test, encState));
}
dlclose(handle);
/*
PJ_LOG(3,(THIS_FILE, "Performing test.."));
pjmedia_aud_param param;
pjmedia_aud_test_results result;
pjmedia_dir dir = PJMEDIA_DIR_ENCODING_DECODING;
if (dir & PJMEDIA_DIR_CAPTURE) {
status = pjmedia_aud_dev_default_param(0, ¶m);
} else {
status = pjmedia_aud_dev_default_param(0, ¶m);
}
if (status != PJ_SUCCESS) {
PJ_LOG(1, (THIS_FILE, "pjmedia_aud_dev_default_param() %d", status));
return status;
}
param.dir = dir;
param.rec_id = 0;
param.play_id = 0;
param.clock_rate = clock_rate;
param.channel_count = 1;
param.samples_per_frame = clock_rate * 1 * ptime / 1000;
// Latency settings
param.flags |= (PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY
| PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY);
param.input_latency_ms = PJMEDIA_SND_DEFAULT_REC_LATENCY;
param.output_latency_ms = PJMEDIA_SND_DEFAULT_PLAY_LATENCY;
PJ_LOG(3,(THIS_FILE, "Performing test.."));
status = pjmedia_aud_test(¶m, &result);
if (status != PJ_SUCCESS) {
PJ_LOG(1, (THIS_FILE, "Test has completed with error %d", status));
return status;
}
PJ_LOG(3,(THIS_FILE, "Done. Result:"));
if (dir & PJMEDIA_DIR_CAPTURE) {
if (result.rec.frame_cnt == 0) {
PJ_LOG(1,(THIS_FILE, "Error: no frames captured!"));
} else {
PJ_LOG(3,(THIS_FILE, " %-20s: interval (min/max/avg/dev)=%u/%u/%u/%u, burst=%u",
"Recording result",
result.rec.min_interval,
result.rec.max_interval,
result.rec.avg_interval,
result.rec.dev_interval,
result.rec.max_burst));
}
}
if (dir & PJMEDIA_DIR_PLAYBACK) {
if (result.play.frame_cnt == 0) {
PJ_LOG(1,(THIS_FILE, "Error: no playback!"));
} else {
PJ_LOG(3,(THIS_FILE, " %-20s: interval (min/max/avg/dev)=%u/%u/%u/%u, burst=%u",
"Playback result",
result.play.min_interval,
result.play.max_interval,
result.play.avg_interval,
result.play.dev_interval,
result.play.max_burst));
}
}
if (dir == PJMEDIA_DIR_CAPTURE_PLAYBACK) {
if (result.rec_drift_per_sec == 0) {
PJ_LOG(3,(THIS_FILE, " No clock drift detected"));
} else {
const char *which = result.rec_drift_per_sec >= 0 ? "faster"
: "slower";
unsigned drift =
result.rec_drift_per_sec >= 0 ? result.rec_drift_per_sec
: -result.rec_drift_per_sec;
PJ_LOG(3,(THIS_FILE, " Clock drifts detected. Capture device "
"is running %d samples per second %s "
"than the playback device",
drift, which));
}
}
*/
return status;
}
int encode(int mode, const char *srcFile, const char *dstFile) {
int retVal = EXIT_SUCCESS;
FILE *fSrc = NULL;
FILE *fDst = NULL;
int frameNum = 0;
bool eofReached = false;
uint16_t *inputBuf = NULL;
uint8_t *outputBuf = NULL;
AmrNbEncState *amr = NULL;
clock_t start, finish;
double duration = 0.0;
// Open input file.
fSrc = fopen(srcFile, "rb");
if (fSrc == NULL) {
fprintf(stderr, "Error opening input file\n");
retVal = EXIT_FAILURE;
goto safe_exit;
}
// Open output file.
fDst = fopen(dstFile, "wb");
if (fDst == NULL) {
fprintf(stderr, "Error opening output file\n");
retVal = EXIT_FAILURE;
goto safe_exit;
}
// Allocate input buffer.
inputBuf = (uint16_t*) malloc(kInputSize);
assert(inputBuf != NULL);
// Allocate output buffer.
outputBuf = (uint8_t*) malloc(kOutputSize);
assert(outputBuf != NULL);
// Initialize encoder.
amr = (AmrNbEncState*) malloc(sizeof(AmrNbEncState));
AMREncodeInit(&amr->encCtx, &amr->pidSyncCtx, 0);
// Write file header.
fwrite("#!AMR\n", 1, 6, fDst);
while (1) {
// Read next input frame.
int bytesRead;
bytesRead = fread(inputBuf, 1, kInputSize, fSrc);
if (bytesRead != kInputSize && !feof(fSrc)) {
retVal = EXIT_FAILURE; // Invalid magic number.
fprintf(stderr, "Error reading input file\n");
goto safe_exit;
} else if (feof(fSrc) && bytesRead == 0) {
eofReached = true;
break;
}
start = clock();
// Encode the frame.
Frame_Type_3GPP frame_type = (Frame_Type_3GPP) mode;
int bytesGenerated;
bytesGenerated = AMREncode(amr->encCtx, amr->pidSyncCtx, (Mode)mode,
(Word16*)inputBuf, outputBuf, &frame_type,
AMR_TX_WMF);
// Convert from WMF to RFC 3267 format.
if (bytesGenerated > 0) {
outputBuf[0] = ((outputBuf[0] << 3) | 4) & 0x7c;
}
finish = clock();
duration += finish - start;
if (bytesGenerated < 0) {
retVal = EXIT_FAILURE;
fprintf(stderr, "Encoding error\n");
goto safe_exit;
}
frameNum++;
printf(" Frames processed: %d\n", frameNum);
// Write the output.
fwrite(outputBuf, 1, bytesGenerated, fDst);
}
// Dump the time taken by encode.
printf("\n%2.5lf seconds\n", (double)duration/CLOCKS_PER_SEC);
safe_exit:
// Free the encoder instance.
if (amr) {
AMREncodeExit(&amr->encCtx, &amr->pidSyncCtx);
free(amr);
}
// Free input and output buffer.
free(inputBuf);
free(outputBuf);
// Close the input and output files.
if (fSrc) {
fclose(fSrc);
}
if (fDst) {
fclose(fDst);
}
return retVal;
}
void* Encoder_Interface_init(int dtx) {
struct encoder_state* state = (struct encoder_state*) malloc(sizeof(struct encoder_state));
AMREncodeInit(&state->encCtx, &state->pidSyncCtx, dtx);
return state;
}
