static void
twolame_encoder_close(struct encoder *_encoder)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
twolame_close(&encoder->options);
}
static bool
twolame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
GError **error)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
audio_format->format = SAMPLE_FORMAT_S16;
audio_format->channels = 2;
encoder->audio_format = *audio_format;
encoder->options = twolame_init();
if (encoder->options == NULL) {
g_set_error(error, twolame_encoder_quark(), 0,
"twolame_init() failed");
return false;
}
if (!twolame_encoder_setup(encoder, error)) {
twolame_close(&encoder->options);
return false;
}
encoder->buffer_length = 0;
encoder->flush = false;
return true;
}
static void
gst_two_lame_release_memory (GstTwoLame * twolame)
{
if (twolame->glopts) {
twolame_close (&twolame->glopts);
twolame->glopts = NULL;
}
}
MastCodec_MPA::~MastCodec_MPA()
{
if (twolame) {
// De-initialise twolame
twolame_close( &twolame );
}
}
/*****************************************************************************
* CloseEncoder: twolame encoder destruction
*****************************************************************************/
static void CloseEncoder( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys = p_enc->p_sys;
twolame_close( &p_sys->p_twolame );
free( p_sys );
}
AUDMEncoder_Twolame::~AUDMEncoder_Twolame()
{
printf("[TwoLame] Deleting TwoLame\n");
if(_twolameOptions)
{
twolame_close((twolame_options_struct **)&_twolameOptions);
}
_twolameOptions=NULL;
};
static gboolean
gst_two_lame_get_default_settings (void)
{
twolame_options *glopts = NULL;
glopts = twolame_init ();
if (glopts == NULL) {
GST_ERROR ("Couldn't initialize TwoLAME");
return FALSE;
}
twolame_set_num_channels (glopts, 2);
twolame_set_in_samplerate (glopts, 44100);
if (twolame_init_params (glopts) != 0) {
GST_ERROR ("Couldn't set default parameters");
return FALSE;
}
gst_two_lame_default_settings.mode = TWOLAME_JOINT_STEREO; /* twolame_get_mode (glopts); */
gst_two_lame_default_settings.psymodel = twolame_get_psymodel (glopts);
gst_two_lame_default_settings.bitrate = twolame_get_bitrate (glopts);
gst_two_lame_default_settings.padding = twolame_get_padding (glopts);
gst_two_lame_default_settings.energy_level_extension =
twolame_get_energy_levels (glopts);
gst_two_lame_default_settings.emphasis = twolame_get_emphasis (glopts);
gst_two_lame_default_settings.error_protection =
twolame_get_error_protection (glopts);
gst_two_lame_default_settings.copyright = twolame_get_copyright (glopts);
gst_two_lame_default_settings.original = twolame_get_original (glopts);
gst_two_lame_default_settings.vbr = twolame_get_VBR (glopts);
gst_two_lame_default_settings.vbr_level = twolame_get_VBR_level (glopts);
gst_two_lame_default_settings.ath_level = twolame_get_ATH_level (glopts);
gst_two_lame_default_settings.vbr_max_bitrate =
twolame_get_VBR_max_bitrate_kbps (glopts);
gst_two_lame_default_settings.quick_mode = twolame_get_quick_mode (glopts);
gst_two_lame_default_settings.quick_mode_count =
twolame_get_quick_count (glopts);
twolame_close (&glopts);
return TRUE;
}
int ExportMP2::Export(AudacityProject *project,
int channels, const wxString &fName,
bool selectionOnly, double t0, double t1, MixerSpec *mixerSpec, const Tags *metadata,
int WXUNUSED(subformat))
{
bool stereo = (channels == 2);
long bitrate = gPrefs->Read(wxT("/FileFormats/MP2Bitrate"), 160);
double rate = project->GetRate();
const TrackList *tracks = project->GetTracks();
wxLogNull logNo; /* temporarily disable wxWidgets error messages */
twolame_options *encodeOptions;
encodeOptions = twolame_init();
twolame_set_in_samplerate(encodeOptions, (int)(rate + 0.5));
twolame_set_out_samplerate(encodeOptions, (int)(rate + 0.5));
twolame_set_bitrate(encodeOptions, bitrate);
twolame_set_num_channels(encodeOptions, stereo ? 2 : 1);
if (twolame_init_params(encodeOptions) != 0)
{
wxMessageBox(_("Cannot export MP2 with this sample rate and bit rate"),
_("Error"), wxICON_STOP);
twolame_close(&encodeOptions);
return false;
}
// Put ID3 tags at beginning of file
if (metadata == NULL)
metadata = project->GetTags();
FileIO outFile(fName, FileIO::Output);
if (!outFile.IsOpened()) {
wxMessageBox(_("Unable to open target file for writing"));
twolame_close(&encodeOptions);
return false;
}
char *id3buffer = NULL;
int id3len;
bool endOfFile;
id3len = AddTags(project, &id3buffer, &endOfFile, metadata);
if (id3len && !endOfFile)
outFile.Write(id3buffer, id3len);
// Values taken from the twolame simple encoder sample
const int pcmBufferSize = 9216 / 2; // number of samples
const int mp2BufferSize = 16384; // bytes
// We allocate a buffer which is twice as big as the
// input buffer, which should always be enough.
// We have to multiply by 4 because one sample is 2 bytes wide!
unsigned char* mp2Buffer = new unsigned char[mp2BufferSize];
const WaveTrackConstArray waveTracks =
tracks->GetWaveTrackConstArray(selectionOnly, false);
int updateResult = eProgressSuccess;
{
auto mixer = CreateMixer(waveTracks,
tracks->GetTimeTrack(),
t0, t1,
stereo ? 2 : 1, pcmBufferSize, true,
rate, int16Sample, true, mixerSpec);
ProgressDialog progress(wxFileName(fName).GetName(),
selectionOnly ?
wxString::Format(_("Exporting selected audio at %ld kbps"), bitrate) :
wxString::Format(_("Exporting entire file at %ld kbps"), bitrate));
while (updateResult == eProgressSuccess) {
sampleCount pcmNumSamples = mixer->Process(pcmBufferSize);
if (pcmNumSamples == 0)
break;
short *pcmBuffer = (short *)mixer->GetBuffer();
int mp2BufferNumBytes = twolame_encode_buffer_interleaved(
encodeOptions,
pcmBuffer,
pcmNumSamples,
mp2Buffer,
mp2BufferSize);
outFile.Write(mp2Buffer, mp2BufferNumBytes);
updateResult = progress.Update(mixer->MixGetCurrentTime() - t0, t1 - t0);
}
}
int mp2BufferNumBytes = twolame_encode_flush(
encodeOptions,
mp2Buffer,
mp2BufferSize);
if (mp2BufferNumBytes > 0)
outFile.Write(mp2Buffer, mp2BufferNumBytes);
twolame_close(&encodeOptions);
delete[] mp2Buffer;
/* Write ID3 tag if it was supposed to be at the end of the file */
if (id3len && endOfFile)
outFile.Write(id3buffer, id3len);
if (id3buffer) {
free(id3buffer);
}
/* Close file */
outFile.Close();
return updateResult;
}
int
main(int argc, char **argv)
{
twolame_options *encopts = NULL;
SNDFILE *inputfile = NULL;
FILE *outputfile = NULL;
short int *pcmaudio = NULL;
int samples_read = 0;
unsigned int frame_count = 0;
unsigned char *mp2buffer = NULL;
int mp2fill_size = 0;
int audioReadSize = 0;
// Allocate memory for the PCM audio data
if ((pcmaudio = (short int *) calloc(AUDIOBUFSIZE, sizeof(short int))) == NULL) {
fprintf(stderr, "Error: pcmaudio memory allocation failed\n");
exit(ERR_MEM_ALLOC);
}
// Allocate memory for the encoded MP2 audio data
if ((mp2buffer = (unsigned char *) calloc(MP2BUFSIZE, sizeof(unsigned char))) == NULL) {
fprintf(stderr, "Error: mp2buffer memory allocation failed\n");
exit(ERR_MEM_ALLOC);
}
// Initialise Encoder Options Structure
encopts = twolame_init();
if (encopts == NULL) {
fprintf(stderr, "Error: initializing libtwolame encoder failed.\n");
exit(ERR_MEM_ALLOC);
}
// Get options and parameters from the command line
parse_args(argc, argv, encopts);
// Open the input file
inputfile = open_input_file( inputfilename );
twolame_set_num_channels( encopts, sfinfo.channels );
twolame_set_in_samplerate( encopts, sfinfo.samplerate );
// Open the output file
outputfile = open_output_file( outputfilename );
// display file settings
print_file_config( inputfile, twolame_get_verbosity(encopts) );
// initialise twolame with this set of options
if (twolame_init_params( encopts ) != 0) {
fprintf(stderr, "Error: configuring libtwolame encoder failed.\n");
exit(ERR_INVALID_PARAM);
}
// display encoder settings
twolame_print_config( encopts );
// Only encode a single frame of mpeg audio ?
if (single_frame_mode) audioReadSize = 1152;
else audioReadSize = AUDIOBUFSIZE;
// Now do the reading/encoding/writing
while ((samples_read = sf_read_short( inputfile, pcmaudio, audioReadSize )) > 0) {
int bytes_out = 0;
// Force byte swapping if requested
if (byteswap) {
int i;
for (i = 0; i<samples_read; i++) {
short tmp = pcmaudio[i];
char *src = (char*)&tmp;
char *dst = (char*)&pcmaudio[i];
dst[0] = src[1];
dst[1] = src[0];
}
}
// Calculate the number of samples we have (per channel)
samples_read /= sfinfo.channels;
// Do swapping of left and right channels if requested
if (channelswap && sfinfo.channels == 2) {
int i;
for(i=0; i<samples_read; i++) {
short tmp = pcmaudio[(2*i)];
pcmaudio[(2*i)] = pcmaudio[(2*i)+1];
pcmaudio[(2*i)+1] = tmp;
}
}
// Encode the audio to MP2
mp2fill_size = twolame_encode_buffer_interleaved( encopts, pcmaudio, samples_read, mp2buffer, MP2BUFSIZE);
// Stop if we don't have any bytes (probably don't have enough audio for a full frame of mpeg audio)
if (mp2fill_size==0) break;
if (mp2fill_size<0) {
fprintf(stderr,"error while encoding audio: %d\n", mp2fill_size);
exit(ERR_WRITING_OUTPUT);
}
// Write the encoded audio out
bytes_out = fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outputfile);
if (bytes_out<=0) {
perror("error while writing to output file");
exit(ERR_WRITING_OUTPUT);
}
// Only single frame ?
if (single_frame_mode) break;
// Display Progress
frame_count += (samples_read / 1152);
if (twolame_get_verbosity(encopts)>0) {
fprintf(stderr, "[%04i", frame_count);
//fprintf(stderr, "/%04i", (int)(sfinfo.frames / sfinfo.channels / 1152));
fprintf(stderr, "]\r");
fflush(stderr);
}
}
//
// flush any remaining audio. (don't send any new audio data) There
// should only ever be a max of 1 frame on a flush. There may be zero
// frames if the audio data was an exact multiple of 1152
//
mp2fill_size = twolame_encode_flush( encopts, mp2buffer, MP2BUFSIZE);
if (mp2fill_size>0) {
int bytes_out = fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outputfile);
if (bytes_out<=0) {
perror("error while writing to output file");
exit(ERR_WRITING_OUTPUT);
}
}
if (twolame_get_verbosity(encopts)>1) {
fprintf(stderr, "\nEncoding Finished.\n");
}
// Close input and output files
sf_close( inputfile );
fclose( outputfile );
// Close the libtwolame encoder
twolame_close(&encopts);
// Free up memory
free(pcmaudio);
free(mp2buffer);
return (ERR_NO_ERROR);
}
int main(int argc, char **argv)
{
twolame_options *encodeOptions;
char *inputfilename = argv[1];
char *outputfilename = argv[2];
FILE *outfile, *fpSrc = NULL;
short int *pcmaudio;
unsigned char *mp2buffer;
int num_samples = 0;
int mp2fill_size = 0;
int frames = 0;
wave_info_t *wave_info = NULL;
int nReadSize = 0;
if (argc != 3)
usage();
/* Allocate some space for the PCM audio data */
if ((pcmaudio = (short *) calloc(AUDIOBUFSIZE, sizeof(short))) == NULL) {
fprintf(stderr, "pcmaudio alloc failed\n");
exit(99);
}
/* Allocate some space for the encoded MP2 audio data */
if ((mp2buffer = (unsigned char *) calloc(MP2BUFSIZE, sizeof(unsigned char))) == NULL) {
fprintf(stderr, "mp2buffer alloc failed\n");
exit(99);
}
/* grab a set of default encode options */
encodeOptions = twolame_init();
printf("Using libtwolame version %s.\n", get_twolame_version());
/* Open the wave file */
if ((wave_info = wave_init(inputfilename)) == NULL) {
fprintf(stderr, "Not a recognised WAV file.\n");
exit(99);
}
// Use sound file to over-ride preferences for
// mono/stereo and sampling-frequency
twolame_set_num_channels(encodeOptions, wave_info->channels);
if (wave_info->channels == 1) {
twolame_set_mode(encodeOptions, TWOLAME_MONO);
} else {
twolame_set_mode(encodeOptions, TWOLAME_STEREO);
}
/* Set the input and output sample rate to the same */
twolame_set_in_samplerate(encodeOptions, wave_info->samplerate);
twolame_set_out_samplerate(encodeOptions, wave_info->samplerate);
/* Set the bitrate to 192 kbps */
twolame_set_bitrate(encodeOptions, 64);
/* initialise twolame with this set of options */
if (twolame_init_params(encodeOptions) != 0) {
fprintf(stderr, "Error: configuring libtwolame encoder failed.\n");
exit(99);
}
/* Open the output file for the encoded MP2 data */
if ((outfile = fopen(outputfilename, "wb")) == 0) {
fprintf(stderr, "error opening output file %s\n", outputfilename);
exit(99);
}
// Read num_samples of audio data *per channel* from the input file
//while ((num_samples = wave_get_samples(wave_info, pcmaudio, AUDIOBUFSIZE/2)) != 0) {
fpSrc = fopen( "a2002011001-e02.wav", "rb" );
while(1)
{
num_samples = fread( pcmaudio, sizeof( char ), AUDIOBUFSIZE/2, fpSrc );
// Encode the audio!2024*4
if( num_samples != AUDIOBUFSIZE/2 )
break;
num_samples /= 2;
mp2fill_size =
twolame_encode_buffer_interleaved(encodeOptions, pcmaudio, num_samples/2, mp2buffer,
MP2BUFSIZE);
// Write the MPEG bitstream to the file
fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outfile);
// Display the number of MPEG audio frames we have encoded
frames += (num_samples / TWOLAME_SAMPLES_PER_FRAME);
printf("[%04i]\r", frames);
fflush(stdout);
}
/* flush any remaining audio. (don't send any new audio data) There should only ever be a max
of 1 frame on a flush. There may be zero frames if the audio data was an exact multiple of
1152 */
mp2fill_size = twolame_encode_flush(encodeOptions, mp2buffer, MP2BUFSIZE);
fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outfile);
twolame_close(&encodeOptions);
free(pcmaudio);
printf("\nFinished nicely.\n");
return (0);
}
int main(int argc, char **argv)
{
twolame_options *encopts = NULL;
audioin_t *inputfile = NULL;
FILE *outputfile = NULL;
short int *pcmaudio = NULL;
unsigned int frame_count = 0;
unsigned int total_frames = 0;
unsigned int frame_len = 0;
unsigned int total_bytes = 0;
unsigned char *mp2buffer = NULL;
int samples_read = 0;
int mp2fill_size = 0;
int audioReadSize = 0;
// Allocate memory for the PCM audio data
if ((pcmaudio = (short int *) calloc(AUDIO_BUF_SIZE, sizeof(short int))) == NULL) {
fprintf(stderr, "Error: pcmaudio memory allocation failed\n");
exit(ERR_MEM_ALLOC);
}
// Allocate memory for the encoded MP2 audio data
if ((mp2buffer = (unsigned char *) calloc(MP2_BUF_SIZE, sizeof(unsigned char))) == NULL) {
fprintf(stderr, "Error: mp2buffer memory allocation failed\n");
exit(ERR_MEM_ALLOC);
}
// Initialise Encoder Options Structure
encopts = twolame_init();
if (encopts == NULL) {
fprintf(stderr, "Error: initializing libtwolame encoder failed.\n");
exit(ERR_MEM_ALLOC);
}
// Get options and parameters from the command line
parse_args(argc, argv, encopts);
// Display the filenames
print_filenames(twolame_get_verbosity(encopts));
// Open the input file
if (use_raw) {
// use raw input handler
inputfile = open_audioin_raw(inputfilename, &sfinfo, sample_size);
} else {
// use libsndfile
inputfile = open_audioin_sndfile(inputfilename, &sfinfo);
}
// Display input information
if (twolame_get_verbosity(encopts) > 1) {
inputfile->print_info(inputfile);
}
// Use information from input file to configure libtwolame
twolame_set_num_channels(encopts, sfinfo.channels);
twolame_set_in_samplerate(encopts, sfinfo.samplerate);
// Open the output file
outputfile = open_output_file(outputfilename);
// initialise twolame with this set of options
if (twolame_init_params(encopts) != 0) {
fprintf(stderr, "Error: configuring libtwolame encoder failed.\n");
exit(ERR_INVALID_PARAM);
}
// display encoder settings
twolame_print_config(encopts);
// Only encode a single frame of mpeg audio ?
if (single_frame_mode)
audioReadSize = TWOLAME_SAMPLES_PER_FRAME;
else
audioReadSize = AUDIO_BUF_SIZE;
// Calculate the size and number of frames we are going to encode
frame_len = twolame_get_framelength(encopts);
if (sfinfo.frames)
total_frames = sfinfo.frames / TWOLAME_SAMPLES_PER_FRAME;
// Now do the reading/encoding/writing
while ((samples_read = inputfile->read(inputfile, pcmaudio, audioReadSize)) > 0) {
int bytes_out = 0;
// Force byte swapping if requested
if (byteswap) {
int i;
for (i = 0; i < samples_read; i++) {
short tmp = pcmaudio[i];
char *src = (char *) &tmp;
char *dst = (char *) &pcmaudio[i];
dst[0] = src[1];
dst[1] = src[0];
}
}
// Calculate the number of samples we have (per channel)
samples_read /= sfinfo.channels;
// Do swapping of left and right channels if requested
if (channelswap && sfinfo.channels == 2) {
int i;
for (i = 0; i < samples_read; i++) {
short tmp = pcmaudio[(2 * i)];
pcmaudio[(2 * i)] = pcmaudio[(2 * i) + 1];
pcmaudio[(2 * i) + 1] = tmp;
}
}
// Encode the audio to MP2
mp2fill_size =
twolame_encode_buffer_interleaved(encopts, pcmaudio, samples_read, mp2buffer,
MP2_BUF_SIZE);
// Stop if we don't have any bytes (probably don't have enough audio for a full frame of
// mpeg audio)
if (mp2fill_size == 0)
break;
if (mp2fill_size < 0) {
fprintf(stderr, "error while encoding audio: %d\n", mp2fill_size);
exit(ERR_ENCODING);
}
// Check that a whole number of frame was written
// if (mp2fill_size % frame_len != 0) {
// fprintf(stderr,"error while encoding audio: non-whole number of frames written\n");
// exit(ERR_ENCODING);
// }
// Write the encoded audio out
bytes_out = fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outputfile);
if (bytes_out != mp2fill_size) {
perror("error while writing to output file");
exit(ERR_WRITING_OUTPUT);
}
total_bytes += bytes_out;
// Only single frame ?
if (single_frame_mode)
break;
// Display Progress
frame_count += (mp2fill_size / frame_len);
if (twolame_get_verbosity(encopts) > 0) {
fprintf(stderr, "\rEncoding frame: %i", frame_count);
if (total_frames) {
fprintf(stderr, "/%i (%i%%)", total_frames, (frame_count * 100) / total_frames);
}
fflush(stderr);
}
}
// Was there an error reading the audio?
if (inputfile->error_str(inputfile)) {
fprintf(stderr, "Error reading from input file: %s\n", inputfile->error_str(inputfile));
}
//
// flush any remaining audio. (don't send any new audio data) There
// should only ever be a max of 1 frame on a flush. There may be zero
// frames if the audio data was an exact multiple of 1152
//
mp2fill_size = twolame_encode_flush(encopts, mp2buffer, MP2_BUF_SIZE);
if (mp2fill_size > 0) {
int bytes_out = fwrite(mp2buffer, sizeof(unsigned char), mp2fill_size, outputfile);
frame_count++;
if (bytes_out <= 0) {
perror("error while writing to output file");
exit(ERR_WRITING_OUTPUT);
}
total_bytes += bytes_out;
}
if (twolame_get_verbosity(encopts) > 1) {
char *filesize = format_filesize_string(total_bytes);
fprintf(stderr, "\nEncoding Finished.\n");
fprintf(stderr, "Total bytes written: %s.\n", filesize);
free(filesize);
}
// Close input and output streams
inputfile->close(inputfile);
fclose(outputfile);
// Close the libtwolame encoder
twolame_close(&encopts);
// Free up memory
free(pcmaudio);
free(mp2buffer);
return (ERR_NO_ERROR);
}
