Exemplo n.º 1
0
static int
c_main(int argc, char *argv[])
{
    lame_t  gf;
    int     ret;

#if macintosh
    argc = ccommand(&argv);
#endif
#ifdef __EMX__
    /* This gives wildcard expansion on Non-POSIX shells with OS/2 */
    _wildcard(&argc, &argv);
#endif
#if defined( _WIN32 ) && !defined(__MINGW32__)
    set_process_affinity();
#endif

    frontend_open_console();    
    gf = lame_init(); /* initialize libmp3lame */
    if (NULL == gf) {
        error_printf("fatal error during initialization\n");
        ret = 1;
    }
    else {
        ret = lame_main(gf, argc, argv);
        lame_close(gf);
    }
    frontend_close_console();
    return ret;
}
Exemplo n.º 2
0
    MP3Encoder(UINT bitRate)
    {
        curBitRate = bitRate;

        lgf = lame_init();
        if(!lgf)
            CrashError(TEXT("Unable to open mp3 encoder"));

        lame_set_in_samplerate(lgf, App->GetSampleRateHz());
        lame_set_out_samplerate(lgf, App->GetSampleRateHz());
        lame_set_num_channels(lgf, 2);
        lame_set_mode(lgf, STEREO);
        lame_set_disable_reservoir(lgf, TRUE); //bit reservoir has to be disabled for seamless streaming
        lame_set_VBR(lgf, vbr_off);
        lame_set_brate(lgf, bitRate);
        lame_init_params(lgf);

        outputFrameSize = lame_get_framesize(lgf); //1152 usually
        dwMP3MaxSize = DWORD(1.25*double(outputFrameSize*audioBlockSize) + 7200.0);
        MP3OutputBuffer.SetSize(dwMP3MaxSize+1);
        MP3OutputBuffer[0] = 0x2f;

        bFirstPacket = true;

        Log(TEXT("------------------------------------------"));
        Log(TEXT("%s"), GetInfoString().Array());
    }
Exemplo n.º 3
0
void
Java_com_test_lame_TestLameActivity_convertMP3(JNIEnv*  env,jobject  thiz,jstring inFile ,jstring outFile, 
          jstring progF,  int sampleRate, int bitRate){

  userCancel=0;
  totBytes=0;
  lame_global_flags *gf = lame_init();
  lame_set_num_channels(gf, 1);
  lame_set_in_samplerate(gf,sampleRate);
  lame_set_brate(gf,bitRate);
  lame_set_bWriteVbrTag(gf,0);
  int ipr = lame_init_params(gf);

  const char* outfs;
  outfs = (*env)->GetStringUTFChars(env, outFile, NULL);

  const char* infs;
  infs = (*env)->GetStringUTFChars(env,inFile, NULL);
  int     enc_delay = -1;
  int     enc_padding = -1;

  const char* progfs;
  progfs = (*env)->GetStringUTFChars(env, progF, NULL);
  //set the global progress file variable to be accessed in lame_encoder()
  progFile = fopen(progfs,"w");
  FILE *outf = init_files(gf,infs,outfs,&enc_delay,&enc_padding);
  lame_encoder(gf, outf,0 ,infs ,outfs );
}
Exemplo n.º 4
0
static bool
lame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
		  GError **error)
{
	struct lame_encoder *encoder = (struct lame_encoder *)_encoder;

	audio_format->format = SAMPLE_FORMAT_S16;
	audio_format->channels = 2;

	encoder->audio_format = *audio_format;

	encoder->gfp = lame_init();
	if (encoder->gfp == NULL) {
		g_set_error(error, lame_encoder_quark(), 0,
			    "lame_init() failed");
		return false;
	}

	if (!lame_encoder_setup(encoder, error)) {
		lame_close(encoder->gfp);
		return false;
	}

	encoder->buffer_length = 0;

	return true;
}
Exemplo n.º 5
0
int CLameDecoder::Init()
{
	m_lame = lame_init();
	if(m_lame == NULL)
	{
		m_pDebug->Format("[lame_init] failed");
		return -1;
	}
	//set lame parameters
	lame_set_decode_only(m_lame, 1);
	lame_set_num_samples(m_lame, MAX_U_32_NUM);
	
	//init decoder
	m_hip = hip_decode_init();
	if(m_hip == NULL)
	{
		m_pDebug->Format("[hip_decode_init] failed");
		return -1;
	}

	m_is = new BlockBufferInputStream();
	
	//other internal parameters
	m_nDelay = -1;
	m_nPadding = -1;
	m_nState = STATE_INIT;
	m_nTotalSamples = 0;
	
	return 0;
}
Exemplo n.º 6
0
int doInit(LameConf* conf) {
	int result;

	conf->gf=lame_init();
	if (conf->gf==NULL) {
		//throwRuntimeException(env, "out of memory");
		return org_tritonus_lowlevel_lame_Lame_OUT_OF_MEMORY;
	}

	lame_set_num_channels(conf->gf, conf->channels);
	lame_set_in_samplerate(conf->gf, conf->sampleRate);
	if (conf->mode!=org_tritonus_lowlevel_lame_Lame_CHANNEL_MODE_AUTO) {
		lame_set_mode(conf->gf, conf->mode);
	}
	if (conf->VBR) {
		lame_set_VBR(conf->gf, vbr_default);
		lame_set_VBR_q(conf->gf, conf->quality);
	} else {
		if (conf->bitrate!=org_tritonus_lowlevel_lame_Lame_BITRATE_AUTO) {
		    lame_set_brate(conf->gf, conf->bitrate);
		}
	}
	lame_set_quality(conf->gf, conf->quality);
	result=lame_init_params(conf->gf);

	// return effective values
	conf->sampleRate=lame_get_out_samplerate(conf->gf);
	conf->bitrate=lame_get_brate(conf->gf);
	conf->mode=lame_get_mode(conf->gf);
	conf->VBR=lame_get_VBR(conf->gf);
	conf->quality=(conf->VBR)?lame_get_VBR_q(conf->gf):lame_get_quality(conf->gf);
	conf->mpegVersion=lame_get_version(conf->gf);

	return result;
}
Exemplo n.º 7
0
int lame_enc_init(lame_enc *lame)
{
    int rc;
    char info_buf[256];

    lame->gfp = lame_init();

    lame_set_num_channels(lame->gfp, lame->channel);
    lame_set_in_samplerate(lame->gfp, lame->samplerate_in);
    lame_set_out_samplerate(lame->gfp, lame->samplerate_out);
    lame_set_brate(lame->gfp, lame->bitrate);

    if((rc = lame_init_params(lame->gfp)) < 0)
    {
        printf("bitrate: %d\n", lame->bitrate);
        snprintf(info_buf, sizeof(info_buf),
                "unable to init lame params %d", rc);

        print_info(info_buf, 1);
        return 1;
    }

    lame->state = LAME_READY;
    return 0;
}
Exemplo n.º 8
0
int enclameInit( hb_work_object_t * w, hb_job_t * job )
{
    hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
    hb_audio_t * audio = w->audio;

    w->private_data = pv;

    pv->job   = job;

    hb_log( "enclame: opening libmp3lame" );

    pv->lame = lame_init();
    // use ABR
    lame_set_scale( pv->lame, 32768.0 );
    if( audio->config.out.compression_level >= 0 )
    {
        lame_set_quality( pv->lame, audio->config.out.compression_level );
    }
    if( audio->config.out.bitrate > 0 )
    {
        lame_set_VBR( pv->lame, vbr_abr );
        lame_set_VBR_mean_bitrate_kbps( pv->lame, audio->config.out.bitrate );
    }
    else if( audio->config.out.quality >= 0 )
    {
        lame_set_brate( pv->lame, 0 );
        lame_set_VBR( pv->lame, vbr_default );
        lame_set_VBR_quality( pv->lame, audio->config.out.quality );
    }
    lame_set_in_samplerate( pv->lame, audio->config.out.samplerate );
    lame_set_out_samplerate( pv->lame, audio->config.out.samplerate );

    pv->out_discrete_channels = hb_mixdown_get_discrete_channel_count( audio->config.out.mixdown );
    // Lame's default encoding mode is JOINT_STEREO.  This subtracts signal
    // that is "common" to left and right (within some threshold) and encodes
    // it separately.  This improves quality at low bitrates, but hurts 
    // imaging (channel separation) at higher bitrates.  So if the bitrate
    // is suffeciently high, use regular STEREO mode.
    if ( pv->out_discrete_channels == 1 )
    {
        lame_set_mode( pv->lame, MONO );
        lame_set_num_channels( pv->lame, 1 );
    }
    else if ( audio->config.out.bitrate >= 128 )
    {
        lame_set_mode( pv->lame, STEREO );
    }
    lame_init_params( pv->lame );

    pv->input_samples = 1152 * pv->out_discrete_channels;
    pv->output_bytes = LAME_MAXMP3BUFFER;
    pv->buf  = malloc( pv->input_samples * sizeof( float ) );
    audio->config.out.samples_per_frame = 1152;

    pv->list = hb_list_init();
    pv->pts  = -1;

    return 0;
}
Exemplo n.º 9
0
int main(int argc, char** argv)
{
	if(argc != 2)
	{
		printf("Usage: %s <wav file>\n", argv[0]);
		exit(0);
	}

	lame_global_flags *gfp;
	
	
	//set params
	gfp = lame_init();
	
	lame_set_num_channels(gfp,2);
	lame_set_in_samplerate(gfp,44100);
	lame_set_brate(gfp,128);
	lame_set_mode(gfp,1);
	lame_set_quality(gfp,2); 
	
	int ret_code = lame_init_params(gfp);
	if(ret_code < 0)
	{
		printf("ret_code < 0\n");
		exit(-1);
	}
	
	//read input file
	int read, write;
	FILE* pcm = fopen(argv[1], "rb");
	
	char* outPath;
	outPath = strdup(argv[1]);
	sprintf(outPath+strlen(argv[1])-3, "mp3");
	
	FILE* mp3 = fopen(outPath, "wb");
	

	
	short int pcm_buffer[PCM_SIZE * 2];
	unsigned char mp3_buffer[MP3_SIZE];
	
	do
	{
		read = fread(pcm_buffer, 2*sizeof(short int), PCM_SIZE, pcm);
		if(read == 0)
			write = lame_encode_flush(gfp, mp3_buffer, MP3_SIZE);
		else
			write = lame_encode_buffer_interleaved(gfp, pcm_buffer, read, mp3_buffer, MP3_SIZE);
		fwrite(mp3_buffer, write, sizeof (unsigned char), mp3);
	}
	while (read != 0);
	
	lame_close(gfp);
	fclose(mp3);
	fclose(pcm);
	
	exit(0);
}
Exemplo n.º 10
0
bool LameAudioWriter::open_private()
{
	m_fid = fopen(m_fileName.toUtf8().data(), "w+");
	if (!m_fid) {
		return false;
	}
	
	m_lameInfo->flags = lame_init();
	
	if (m_lameInfo->flags == 0) {
		PERROR("lame_init failed.");
		return false;
	}
	
	if (m_channels == 1) {
		lame_set_mode(m_lameInfo->flags, MONO);
	}
	
	lame_set_num_channels(m_lameInfo->flags, m_channels);
	lame_set_in_samplerate(m_lameInfo->flags, m_rate);
	lame_set_out_samplerate(m_lameInfo->flags, m_rate);
	
	if(m_method == 0) {
		// Constant Bitrate
		lame_set_VBR(m_lameInfo->flags, vbr_off);
		lame_set_brate(m_lameInfo->flags, m_maxBitrate);
	}
	else if (m_method == 1) {
		// Average Bitrate
		lame_set_VBR(m_lameInfo->flags, vbr_abr);
		lame_set_VBR_mean_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
	}
	else if (m_method == 2) {
		// Variable Bitrate (old)
		lame_set_VBR(m_lameInfo->flags, vbr_default);
		lame_set_VBR_min_bitrate_kbps(m_lameInfo->flags, m_minBitrate);
		lame_set_VBR_max_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
	}
	else if (m_method == 3) {
		// Variable Bitrate (new)
		lame_set_VBR(m_lameInfo->flags, vbr_default);
		lame_set_VBR_min_bitrate_kbps(m_lameInfo->flags, m_minBitrate);
		lame_set_VBR_max_bitrate_kbps(m_lameInfo->flags, m_maxBitrate);
	}

	lame_set_quality(m_lameInfo->flags, m_quality);
	
	
	//
	// file options
	//
	lame_set_copyright(m_lameInfo->flags, false);
	lame_set_original(m_lameInfo->flags, true);
	lame_set_strict_ISO(m_lameInfo->flags, false);
	lame_set_error_protection(m_lameInfo->flags, false);
	
	return (lame_init_params(m_lameInfo->flags ) != -1);
}
Exemplo n.º 11
0
/// 创建编码器
BOOL CMp3Encoder::Create(void)
{
	if(NULL != m_hHandleEncoder)
		return FALSE;

	m_hHandleEncoder = lame_init();
	
	return (NULL != m_hHandleEncoder);
}
Exemplo n.º 12
0
long MP3_create(const char* format_parameters, amci_codec_fmt_info_t* format_description) {
  mp3_coder_state* coder_state;
  int ret_code;
  
  coder_state = malloc(sizeof(mp3_coder_state));
  if (!coder_state) {
    ERROR("no memory for allocating mp3 coder state\n");
    return -1;
  }
  
  DBG("MP3: creating lame %s\n", get_lame_version());
  format_description[0].id = 0; 
  coder_state->gfp = lame_init(); 
    
  if (!coder_state->gfp) {
    ERROR("initialiting lame\n");
    free(coder_state);
    return -1;
  }

  lame_set_errorf(coder_state->gfp, &no_output);
  lame_set_debugf(coder_state->gfp, &no_output);
  lame_set_msgf(coder_state->gfp, &no_output);
  
  lame_set_num_channels(coder_state->gfp,1);
  lame_set_in_samplerate(coder_state->gfp,8000);
  lame_set_brate(coder_state->gfp,16);
  lame_set_mode(coder_state->gfp,3); // mono
  lame_set_quality(coder_state->gfp,2);   /* 2=high  5 = medium  7=low */ 
  
  id3tag_init(coder_state->gfp);
  id3tag_set_title(coder_state->gfp, "mp3 voicemail by iptel.org");
  ret_code = lame_init_params(coder_state->gfp);
  
  if (ret_code < 0) {
    ERROR("lame encoder init failed: return code is %d\n", ret_code);
    free(coder_state);
    return -1;
  }
  

#ifdef WITH_MPG123DECODER
  coder_state->mpg123_h = mpg123_new(NULL, NULL);
  if (!coder_state->mpg123_h) {
    ERROR("initializing mpg123 decoder instance\n");
    return -1;
  }

  /* suppress output */
  mpg123_param(coder_state->mpg123_h, MPG123_FLAGS, MPG123_QUIET /* | MPG123_FORCE_MONO */,0);

/*   mpg123_param(coder_state->mpg123_h, MPG123_VERBOSE, 0, 0); */

#endif

  return (long)coder_state;
}
Exemplo n.º 13
0
JNIEXPORT jint JNICALL JNIDEFINE(nativeOpenEncoder)(JNIEnv* env, jclass clz) {
    
    lame = lame_init();
    lame_set_in_samplerate(lame, 44100);
    //lame_set_num_channels(lame, 1);
    lame_set_VBR(lame, vbr_default);
    lame_init_params(lame);
    
    return 0;
}
Exemplo n.º 14
0
void AudioReader::exportAudioDataToMP3(const char* data)
{
    QSettings settings;
    emit TCMessage("Exporting MP3...");
    int read, write;
    FILE *pcm = fopen("TCTemp.wav", "wb");
    fwrite(data,1,format.chunkSize,pcm);
    fflush(pcm);
    pcm = fopen("TCTemp.wav", "rb");
    f = fopen(this->outfile.toLocal8Bit().constData(), "wb");

    const int PCM_SIZE = 8192;
    const int MP3_SIZE = 8192*2;

    short int pcm_buffer[PCM_SIZE*2];
    unsigned char mp3_buffer[MP3_SIZE];

    lame_t lame = lame_init();
    lame_set_in_samplerate(lame, format.SampleRate);
    lame_set_VBR(lame, (vbr_mode)settings.value("vbr",0).toInt());

    if(lame_get_VBR(lame)) {
        lame_set_VBR_min_bitrate_kbps(lame,settings.value("min",128).toInt());
        lame_set_VBR_max_bitrate_kbps(lame,settings.value("max",192).toInt());

    }
    else
    {
        lame_set_brate(lame,settings.value("min",128).toInt());
    }
    lame_set_num_channels(lame,(int)format.Channels);
    lame_set_quality(lame,0);
    if(format.Channels==1)lame_set_mode(lame,MONO);
    else                  lame_set_mode(lame,STEREO);

    lame_init_params(lame);
    do {
        if(!knock->running)break;
        read = fread(pcm_buffer, 2*byte_size, PCM_SIZE, pcm);
        fflush(f);
        if (read == 0)
            write = lame_encode_flush(lame, mp3_buffer, MP3_SIZE);
        else
            write = lame_encode_buffer_interleaved(lame, pcm_buffer, read, mp3_buffer, MP3_SIZE);
        fwrite(mp3_buffer, write, 1, f);
        fflush(f);
    } while (read != 0);
    lame_close(lame);
    fclose(pcm);
    if(unlink("TCTemp.wav")!=0) {
        emit TCColor("color: red;");
        emit TCMessage(QString("Error while removing TCTemp.wav"));
    }
}
Exemplo n.º 15
0
/*
 * Class:     com_example_mp3encodedemo_JNIMp3Encode
 * Method:    init
 * Signature: (III)V
 */
JNIEXPORT void JNICALL Java_com_example_soundtouchdemo_JNIMp3Encode_init
  (JNIEnv *env, jobject obj, jint channel, jint sampleRate, jint brate)
{
	lame = lame_init();
	lame_set_num_channels(lame, channel);
	lame_set_in_samplerate(lame, sampleRate);
	lame_set_brate(lame, brate);
	lame_set_mode(lame, 1);
	lame_set_quality(lame, 2);
	lame_init_params(lame);
}
Exemplo n.º 16
0
/* initialize the lame library */
static void mp3streamout_tilde_lame_init(t_mp3streamout *x)
{
    int    ret;
    x->lgfp = lame_init(); /* set default parameters for now */

#ifdef _WIN32
    /* load lame_enc.dll library */
    HINSTANCE dll;
    dll=LoadLibrary("lame_enc.dll");
    if(dll==NULL)
    {
        error("mp3streamout~: error loading lame_enc.dll");
        closesocket(x->x_fd);
        x->x_fd = -1;
        outlet_float(x->x_obj.ob_outlet, 0);
        post("mp3streamout~: connection closed");
        return;
    }
#endif
    {
        const char *lameVersion = get_lame_version();
        logpost(NULL, 4,  "mp3streamout~ : using lame version : %s", lameVersion );
    }

    /* setting lame parameters */
    lame_set_num_channels( x->lgfp, 2);
    lame_set_in_samplerate( x->lgfp, sys_getsr() );
    lame_set_out_samplerate( x->lgfp, x->x_samplerate );
    lame_set_brate( x->lgfp, x->x_bitrate );
    lame_set_mode( x->lgfp, x->x_mp3mode );
    lame_set_quality( x->lgfp, x->x_mp3quality );
    lame_set_emphasis( x->lgfp, 1 );
    lame_set_original( x->lgfp, 1 );
    lame_set_copyright( x->lgfp, 1 ); /* viva free music societies !!! */
    lame_set_disable_reservoir( x->lgfp, 0 );
    //lame_set_padding_type( x->lgfp, PAD_NO ); /* deprecated in LAME */
    ret = lame_init_params( x->lgfp );
    if ( ret<0 )
    {
        post( "mp3streamout~ : error : lame params initialization returned : %d", ret );
    }
    else
    {
        x->x_lame=1;
        /* magic formula copied from windows dll for MPEG-I */
        x->x_lamechunk = 2*1152;

        post( "mp3streamout~ : lame initialization done. (%d)", x->x_lame );
    }
    lame_init_bitstream( x->lgfp );
}
Exemplo n.º 17
0
__declspec(dllexport) BE_ERR	beInitStream(PBE_CONFIG pbeConfig, PDWORD dwSamples, PDWORD dwBufferSize, PHBE_STREAM phbeStream)
{
    int actual_bitrate;
    //2001-12-18
    int					nDllArgC = 0;
    BE_CONFIG			lameConfig = { 0, };
    int					nInitReturn = 0;
    lame_global_flags*	gfp = NULL;

    // Init the global flags structure
    gfp = lame_init();
    *phbeStream = (HBE_STREAM)gfp;

    // clear out structure
    memset(&lameConfig,0x00,CURRENT_STRUCT_SIZE);

    // Check if this is a regular BLADE_ENCODER header
    if (pbeConfig->dwConfig!=BE_CONFIG_LAME)
    {
        int nCRC=pbeConfig->format.mp3.bCRC;
        int nVBR=(nCRC>>12)&0x0F;

        // Copy parameter from old Blade structure
        lameConfig.format.LHV1.dwSampleRate	=pbeConfig->format.mp3.dwSampleRate;
        //for low bitrates, LAME will automatically downsample for better
        //sound quality.  Forcing output samplerate = input samplerate is not a good idea 
        //unless the user specifically requests it:
        //lameConfig.format.LHV1.dwReSampleRate=pbeConfig->format.mp3.dwSampleRate;
        lameConfig.format.LHV1.nMode		=(pbeConfig->format.mp3.byMode&0x0F);
        lameConfig.format.LHV1.dwBitrate	=pbeConfig->format.mp3.wBitrate;
        lameConfig.format.LHV1.bPrivate		=pbeConfig->format.mp3.bPrivate;
        lameConfig.format.LHV1.bOriginal	=pbeConfig->format.mp3.bOriginal;
        lameConfig.format.LHV1.bCRC		=nCRC&0x01;
        lameConfig.format.LHV1.bCopyright	=pbeConfig->format.mp3.bCopyright;

        // Fill out the unknowns
        lameConfig.format.LHV1.dwStructSize=CURRENT_STRUCT_SIZE;
        lameConfig.format.LHV1.dwStructVersion=CURRENT_STRUCT_VERSION;

        // Get VBR setting from fourth nibble
        if ( nVBR>0 )
        {
            lameConfig.format.LHV1.bWriteVBRHeader = TRUE;
            lameConfig.format.LHV1.bEnableVBR = TRUE;
            lameConfig.format.LHV1.nVBRQuality = nVBR-1;
        }

        // Get Quality from third nibble
        lameConfig.format.LHV1.nPreset=((nCRC>>8)&0x0F);

    }
Exemplo n.º 18
0
//this is an attempt to convert raw data frame by frame, if anyone can find a solution, send a patch.
void
Java_com_test_lame_TestLameActivity_convertMP3Realtime(JNIEnv*  env,jobject  thiz,jstring aaa,jstring outF, jshortArray inBytes,
          int sampleRate, int bitRate){

  userCancel=0;
  lame_global_flags *gf = lame_init();
  lame_set_num_channels(gf, 1);
  lame_set_in_samplerate(gf,sampleRate);
  lame_set_brate(gf,bitRate);
  lame_set_bWriteVbrTag(gf,0);
  int ipr = lame_init_params(gf);

  const char* outfs;
  outfs = (*env)->GetStringUTFChars(env, outF, NULL);

  int     enc_delay = -1;
  int     enc_padding = -1;

  FILE * outf;
  int outFopen=0;
  if(outFopen == 0) {
    outf = fopen(outfs,"a+b");
    unsigned char mp3buffer[LAME_MAXMP3BUFFER];
    int imp3 = lame_get_id3v2_tag(gf, mp3buffer, sizeof(mp3buffer));
    fwrite(mp3buffer, 1, imp3, outf);
    outFopen =1;
  }  
  
  jshort* jInBytes = (*env)->GetShortArrayElements(env,inBytes,NULL);
  jsize sizeIn = (*env)->GetArrayLength(env,inBytes); 
  short inInts[sizeIn];
  int totRead=0; 
  int amountRead; 
  
   while(totRead < sizeIn) {
  	 if(sizeIn - totRead < 1152) {
  	   amountRead = sizeIn -totRead;
     } else {
       amountRead = 1152;
     }
     int i;
     for(i=0;i< amountRead;i++) {
       inInts[i] = jInBytes[i];
   	   totRead++;
  	 }
     lame_realtime_encoder(gf, outf,0 ,inInts,amountRead);
  }
  
  //failing on JNI: unpinPrimitiveArray() failed to find entry (valid=0)
  //(*env)->ReleaseByteArrayElements(env,jInBytes,inBytes,0);
}
Exemplo n.º 19
0
JNIEXPORT void JNICALL Java_com_czt_mp3recorder_util_LameUtil_init(
		JNIEnv *env, jclass cls, jint inSamplerate, jint inChannel, jint outSamplerate, jint outBitrate, jint quality) {
	if (lame != NULL) {
		lame_close(lame);
		lame = NULL;
	}
	lame = lame_init();
	lame_set_in_samplerate(lame, inSamplerate);
	lame_set_num_channels(lame, inChannel);//输入流的声道
	lame_set_out_samplerate(lame, outSamplerate);
	lame_set_brate(lame, outBitrate);
	lame_set_quality(lame, quality);
	lame_init_params(lame);
}
JNIEXPORT void JNICALL Java_cn_net_xyd_videoaudiodemo_mp3lame_SimpleLame_init(
        JNIEnv *env, jclass cls, jint inSamplerate, jint outChannel,
        jint outSamplerate, jint outBitrate, jint quality) {
if (glf != NULL) {
lame_close(glf);
glf = NULL;
}
glf = lame_init();
lame_set_in_samplerate(glf, inSamplerate);
lame_set_num_channels(glf, outChannel);
lame_set_out_samplerate(glf, outSamplerate);
lame_set_brate(glf, outBitrate);
lame_set_quality(glf, quality);
lame_init_params(glf);
}
Exemplo n.º 21
0
JNIEXPORT void JNICALL Java_com_xiong_richard_greyparrot_SimpleLame_init(
		JNIEnv *env, jclass cls, jint inSamplerate, jint outChannel,
		jint outSamplerate, jint outBitrate, jint quality) {
	if (glf != NULL) {
		lame_close(glf);
		glf = NULL;
	}
	glf = lame_init();
	lame_set_in_samplerate(glf, inSamplerate);
	lame_set_num_channels(glf, outChannel);
	lame_set_out_samplerate(glf, outSamplerate);
	lame_set_brate(glf, outBitrate);
	lame_set_quality(glf, quality);
	lame_init_params(glf);
}
void Java_ice_caster_android_shout_Lame_init(
		JNIEnv *env, jclass cls, jint inSamplerate, jint outChannel,
		jint outSamplerate, jint outBitrate, jint quality) {
	if (glf != NULL) {
		lame_close(glf);
		glf = NULL;
	}
	glf = lame_init();
	lame_set_in_samplerate(glf, inSamplerate);
	lame_set_num_channels(glf, outChannel);
	lame_set_out_samplerate(glf, outSamplerate);
	lame_set_brate(glf, outBitrate);
	lame_set_quality(glf, quality);
	lame_init_params(glf);
}
JNIEXPORT void JNICALL Java_org_proof_recorder_service_jni_SimpleLame_init(
		JNIEnv *env, jclass cls, jint inSamplerate, jint outChannel,
		jint outSamplerate, jint outBitrate, jint quality) {
	if (glf != NULL) {
		lame_close(glf);
		glf = NULL;
	}
	glf = lame_init();
	lame_set_in_samplerate(glf, inSamplerate);
	lame_set_num_channels(glf, outChannel);
	lame_set_out_samplerate(glf, outSamplerate);
	lame_set_brate(glf, outBitrate);
	lame_set_quality(glf, quality);
	lame_init_params(glf);
}
JNIEXPORT void JNICALL Java_com_anhuioss_crowdroid_util_RecordVoiceToMp3Lame_init(
		JNIEnv *env, jclass cls, jint inSamplerate, jint outChannel,
		jint outSamplerate, jint outBitrate, jint quality) {
	if (glf != NULL) {
		lame_close(glf);
		glf = NULL;
	}
	glf = lame_init();
	lame_set_in_samplerate(glf, inSamplerate);
	lame_set_num_channels(glf, outChannel);
	lame_set_out_samplerate(glf, outSamplerate);
	lame_set_brate(glf, outBitrate);
	lame_set_quality(glf, quality);
	lame_init_params(glf);
}
Exemplo n.º 25
0
void Encoder(char* src, char* dst){
 
           //printf("Inside Encoder : %s \n",src);
           //printf("Inside Encoder : %s \n",dst);
           if(src == NULL || dst == NULL)
              return;

           int read, write;
           FILE* wav;
           FILE* mp3;
           wav = fopen(src, "rb");
           if(wav == NULL){
              printf(" Unable to open the file %s \n", src);
              return;
            }
           mp3 = fopen(dst, "wb");
           if(mp3 == NULL){
              printf(" Unable to open the file %s \n", dst);
              return;
           } 
           const int PCM_SIZE = 8192;
           const int MP3_SIZE = 8192;
           
           short int PCM_BUFFER[2*PCM_SIZE];
           char MP3_BUFFER[MP3_SIZE];

           lame_t lame = lame_init();
           lame_set_in_samplerate(lame, 44100);
           lame_set_VBR(lame, vbr_default);
           lame_init_params(lame);
           do {
                read = fread(PCM_BUFFER, 2*sizeof(short int), PCM_SIZE, wav);
                if (read == 0)
                write = lame_encode_flush(lame, MP3_BUFFER, MP3_SIZE);
                else
                write = lame_encode_buffer_interleaved(lame, PCM_BUFFER, read, MP3_BUFFER, MP3_SIZE);
                fwrite(MP3_BUFFER, write, 1, mp3);
                } while (read != 0);

           lame_close(lame);
           fclose(wav);
           fclose(mp3);
  
            }
Exemplo n.º 26
0
void Java_com_iliayugai_zapp_utils_CommonUtils_initEncoder(JNIEnv *env,
		jobject jobj, jint in_num_channels, jint in_samplerate, jint in_brate,
		jint in_mode, jint in_quality) {
	lame = lame_init();

	LOGD("Init parameters:");
	lame_set_num_channels(lame, in_num_channels);
	LOGD("Number of channels: %d", in_num_channels);
	lame_set_in_samplerate(lame, in_samplerate);
	LOGD("Sample rate: %d", in_samplerate);
	lame_set_brate(lame, in_brate);
	LOGD("Bitrate: %d", in_brate);
	lame_set_mode(lame, in_mode);
	LOGD("Mode: %d", in_mode);
	lame_set_quality(lame, in_quality);
	LOGD("Quality: %d", in_quality);

	int res = lame_init_params(lame);
	LOGD("Init returned: %d", res);
}
void Java_mobi_cangol_mobile_utils_LameUtils_initEncoder(JNIEnv *env,
														 jobject jobj, jint in_num_channels, jint in_samplerate, jint in_brate,
														 jint in_mode, jint in_quality) {
	lame = lame_init();

	LOGD("Init parameters:",NULL);
	lame_set_num_channels(lame, in_num_channels);
	LOGD("Number of channels: %d", in_num_channels);
	lame_set_in_samplerate(lame, in_samplerate);
	LOGD("Sample rate: %d", in_samplerate);
	lame_set_brate(lame, in_brate);
	LOGD("Bitrate: %d", in_brate);
	lame_set_mode(lame, in_mode);
	LOGD("Mode: %d", in_mode);
	lame_set_quality(lame, in_quality);
	LOGD("Quality: %d", in_quality);

	int res = lame_init_params(lame);
	LOGD("Init returned: %d", res);
}
Exemplo n.º 28
0
bool KRecExport_MP3::initialize( const QString &filename ) {
kdDebug( 60005 ) << k_funcinfo << endl;
	if ( !_file &&
	     !( bits()!=16 && channels()!=2 &&
	        KMessageBox::warningContinueCancel( KRecGlobal::the()->mainWidget(),
	          i18n( "At this time MP3-Export only supports files in stereo and 16bit." )
	        ) == KMessageBox::Cancel
	     )
	) {
		KMessageBox::information( KRecGlobal::the()->mainWidget(),
		  i18n( "Please note that this plugin takes its qualitysettings from" \
		        " the corresponding section of the Audio CDs Control Center module" \
			" configuration. Make use" \
		        " of the Control Center to configure these settings." ),
		  i18n( "Quality Configuration" ), "qualityinfo_mp3" );
		_file = new QFile( filename );
		if ( _file->open( IO_Raw|IO_WriteOnly ) ) {
			if ( ! init_done ) {
				gfp = lame_init();
				setLameParameters();
				if ( write_id3 ) {
					id3tag_init( gfp );
					id3tag_v1_only ( gfp );
					id3tag_set_album  ( gfp, "" );
					id3tag_set_artist ( gfp, "" );
					id3tag_set_title  ( gfp, "" );
					id3tag_set_comment( gfp, "krec" );
				}
				/// Set input parameters right
				lame_set_in_samplerate( gfp, this->samplingRate() );
				lame_set_num_channels( gfp, this->channels() );
				lame_init_params( gfp );
			}
			if ( _file->size() >= 128 )
				_file->at( _file->size() - 128 );
			else
				_file->at( _file->size() );
		} else return false;
		return true;
	} else return false;
}
Exemplo n.º 29
0
bool Mp3Writer::open(const QString &fn, long sr, bool s) {
	bool b = AudioFileWriter::open(fn + ".mp3", sr, s);

	if (!b)
		return false;

	lame = lame_init();
	if (!lame)
		return false;

	bitRate = preferences.get(Pref::OutputFormatMp3Bitrate).toInt();

	lame_set_in_samplerate(lame, sampleRate);
	lame_set_num_channels(lame, stereo ? 2 : 1);
	lame_set_out_samplerate(lame, sampleRate);
	// TODO: do we need this?
	lame_set_bWriteVbrTag(lame, 0);
	lame_set_mode(lame, stereo ? STEREO : MONO);
	lame_set_brate(lame, bitRate);
	if (lame_init_params(lame) == -1)
		return false;

	return true;
}
Exemplo n.º 30
0
static switch_status_t shout_file_open(switch_file_handle_t *handle, const char *path)
{
	shout_context_t *context;
	char *host, *file;
	char *username, *password, *port;
	char *err = NULL;
	const char *mpg123err = NULL;
	int portno = 0;

	if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) {
		return SWITCH_STATUS_MEMERR;
	}

	if (!handle->samplerate) {
		handle->samplerate = 8000;
	}

	context->memory_pool = handle->memory_pool;
	context->samplerate = handle->samplerate;
	context->handle = handle;

	switch_thread_rwlock_create(&(context->rwlock), context->memory_pool);

	switch_thread_rwlock_rdlock(context->rwlock);

	switch_mutex_init(&context->audio_mutex, SWITCH_MUTEX_NESTED, context->memory_pool);

	if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
		if (switch_buffer_create_dynamic(&context->audio_buffer, TC_BUFFER_SIZE, TC_BUFFER_SIZE * 2, 0) != SWITCH_STATUS_SUCCESS) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
			goto error;
		}

		context->mh = our_mpg123_new(NULL, NULL);
		if (mpg123_format_all(context->mh) != MPG123_OK) {
			MPGERROR();
		}
		if (mpg123_param(context->mh, MPG123_FORCE_RATE, context->samplerate, 0) != MPG123_OK) {
			MPGERROR();
		}

		if (handle->handler) {
			if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_SEEKBUFFER | MPG123_MONO_MIX, 0) != MPG123_OK) {
				MPGERROR();
			}
			if (mpg123_open_feed(context->mh) != MPG123_OK) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening mpg feed\n");
				mpg123err = mpg123_strerror(context->mh);
				goto error;
			}
			context->stream_url = switch_core_sprintf(context->memory_pool, "http://%s", path);
			context->prebuf = handle->prebuf;
			launch_read_stream_thread(context);
		} else {
			handle->seekable = 1;
			if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_MONO_MIX, 0) != MPG123_OK) {
				MPGERROR();
			}
			if (mpg123_open(context->mh, path) != MPG123_OK) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path);
				mpg123err = mpg123_strerror(context->mh);
				goto error;
			}

		}
	} else if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
		if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND)) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Appending to MP3 not supported.\n");
		}
		if (!(context->gfp = lame_init())) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
			goto error;
		}

		if (!handle->handler) {
			id3tag_init(context->gfp);
			id3tag_v2_only(context->gfp);
			id3tag_pad_v2(context->gfp);

		}
		context->channels = handle->channels;
		lame_set_brate(context->gfp, 16 * (handle->samplerate / 8000) * handle->channels);
		lame_set_num_channels(context->gfp, handle->channels);
		lame_set_in_samplerate(context->gfp, handle->samplerate);
		lame_set_out_samplerate(context->gfp, handle->samplerate);

		if (handle->channels == 2) {
			lame_set_mode(context->gfp, STEREO);
		} else {
			lame_set_mode(context->gfp, MONO);
		}
		lame_set_quality(context->gfp, 2);	/* 2=high  5 = medium  7=low */

		lame_set_errorf(context->gfp, log_error);
		lame_set_debugf(context->gfp, log_debug);
		lame_set_msgf(context->gfp, log_msg);

		if (handle->handler) {
			if (switch_buffer_create_dynamic(&context->audio_buffer, MY_BLOCK_SIZE, MY_BUF_LEN, 0) != SWITCH_STATUS_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
				goto error;
			}
			lame_set_bWriteVbrTag(context->gfp, 0);
			lame_mp3_tags_fid(context->gfp, NULL);

			username = switch_core_strdup(handle->memory_pool, path);
			if (!(password = strchr(username, ':'))) {
				err = "invalid url";
				goto error;
			}
			*password++ = '\0';

			if (!(host = strchr(password, '@'))) {
				err = "invalid url";
				goto error;
			}
			*host++ = '\0';

			if ((file = strchr(host, '/'))) {
				*file++ = '\0';
			} else {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid URL: %s\n", path);
				goto error;
			}

			if ((port = strchr(host, ':'))) {
				*port++ = '\0';
				if (port) {
					portno = atoi(port);
				}
			}

			if (!portno) {
				portno = 8000;
			}

			if (!(context->shout = shout_new())) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate shout_t\n");
				goto error;
			}

			if (shout_set_host(context->shout, host) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting hostname: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_protocol(context->shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting protocol: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_port(context->shout, portno) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting port: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_password(context->shout, password) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting password: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_mount(context->shout, file) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting mount: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_user(context->shout, username) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting user: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_url(context->shout, "http://www.freeswitch.org") != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting name: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_description(context->shout, "FreeSWITCH mod_shout Broadcasting Module") != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting description: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_audio_info(context->shout, "bitrate", "24000") != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting bitrate: %s\n", shout_get_error(context->shout));
				goto error;
			}

			if (shout_set_format(context->shout, SHOUT_FORMAT_MP3) != SHOUTERR_SUCCESS) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting format: %s\n", shout_get_error(context->shout));
				goto error;
			}

		} else {
			/* lame being lame and all has FILE * coded into it's API for some functions so we gotta use it */
			if (!(context->fp = fopen(path, "wb+"))) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path);
				goto error;
			}
		}
	}

	handle->samples = 0;
	handle->format = 0;
	handle->sections = 0;
	handle->speed = 0;
	handle->private_info = context;
	switch_thread_rwlock_unlock(context->rwlock);

	return SWITCH_STATUS_SUCCESS;

  error:
	switch_thread_rwlock_unlock(context->rwlock);
	if (err) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: %s\n", err);
	}
	if (mpg123err) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error from mpg123: %s\n", mpg123err);
	}
	free_context(context);
	return SWITCH_STATUS_GENERR;

}