void OutLame::flush() {
if(!enc_flags) {
error("Lame encoder is not initialized");
return;
}
lock();
encoded = lame_encode_flush_nogap
(enc_flags,(unsigned char*)buffer,ENCBUFFER_SIZE);
shout();
unlock();
}
bool LameFlush(lame_global_flags * gf, PBYTE mp3, int &out)
{
auto written = lame_encode_flush_nogap(gf, mp3, 0);
if(written < 0)
{
out = 0;
return false;
}
out = written;
return true;
}
static void mp3_close(void)
{
if (output_file) {
int imp3, encout;
/* write remaining mp3 data */
encout = lame_encode_flush_nogap(gfp, encbuffer, LAME_MAXMP3BUFFER);
write_output(encbuffer, encout);
/* set gfp->num_samples for valid TLEN tag */
lame_set_num_samples(gfp, numsamples);
/* append v1 tag */
imp3 = lame_get_id3v1_tag(gfp, encbuffer, sizeof(encbuffer));
if (imp3 > 0)
write_output(encbuffer, imp3);
/* update v2 tag */
imp3 = lame_get_id3v2_tag(gfp, encbuffer, sizeof(encbuffer));
if (imp3 > 0) {
if (vfs_fseek(output_file, 0, SEEK_SET) != 0) {
AUDDBG("can't rewind\n");
}
else {
write_output(encbuffer, imp3);
}
}
/* update lame tag */
if (id3v2_size) {
if (vfs_fseek(output_file, id3v2_size, SEEK_SET) != 0) {
AUDDBG("fatal error: can't update LAME-tag frame!\n");
}
else {
imp3 = lame_get_lametag_frame(gfp, encbuffer, sizeof(encbuffer));
write_output(encbuffer, imp3);
}
}
}
g_free (write_buffer);
lame_close(gfp);
AUDDBG("lame_close() done\n");
free_lameid3(&lameid3);
numsamples = 0;
}
static int
lame_encoder_loop(lame_global_flags * gf, FILE * outf, int nogap, char *inPath, char *outPath)
{
unsigned char mp3buffer[LAME_MAXMP3BUFFER];
int Buffer[2][1152];
int iread, imp3, owrite;
size_t id3v2_size;
encoder_progress_begin(gf, inPath, outPath);
id3v2_size = lame_get_id3v2_tag(gf, 0, 0);
if (id3v2_size > 0) {
unsigned char *id3v2tag = malloc(id3v2_size);
if (id3v2tag != 0) {
size_t n_bytes = lame_get_id3v2_tag(gf, id3v2tag, id3v2_size);
size_t written = fwrite(id3v2tag, 1, n_bytes, outf);
free(id3v2tag);
if (written != n_bytes) {
encoder_progress_end(gf);
error_printf("Error writing ID3v2 tag \n");
return 1;
}
}
}
else {
unsigned char* id3v2tag = getOldTag(gf);
id3v2_size = sizeOfOldTag(gf);
if ( id3v2_size > 0 ) {
size_t owrite = fwrite(id3v2tag, 1, id3v2_size, outf);
if (owrite != id3v2_size) {
encoder_progress_end(gf);
error_printf("Error writing ID3v2 tag \n");
return 1;
}
}
}
if (global_writer.flush_write == 1) {
fflush(outf);
}
/* encode until we hit eof */
do {
/* read in 'iread' samples */
iread = get_audio(gf, Buffer);
if (iread >= 0) {
encoder_progress(gf);
/* encode */
imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
mp3buffer, sizeof(mp3buffer));
/* was our output buffer big enough? */
if (imp3 < 0) {
if (imp3 == -1)
error_printf("mp3 buffer is not big enough... \n");
else
error_printf("mp3 internal error: error code=%i\n", imp3);
return 1;
}
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing mp3 output \n");
return 1;
}
}
if (global_writer.flush_write == 1) {
fflush(outf);
}
} while (iread > 0);
if (nogap)
imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
else
imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
if (imp3 < 0) {
if (imp3 == -1)
error_printf("mp3 buffer is not big enough... \n");
else
error_printf("mp3 internal error: error code=%i\n", imp3);
return 1;
}
encoder_progress_end(gf);
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing mp3 output \n");
return 1;
}
if (global_writer.flush_write == 1) {
fflush(outf);
}
imp3 = write_id3v1_tag(gf, outf);
if (global_writer.flush_write == 1) {
fflush(outf);
}
if (imp3) {
return 1;
}
write_xing_frame(gf, outf, id3v2_size);
if (global_writer.flush_write == 1) {
fflush(outf);
}
if (global_ui_config.silent <= 0) {
print_trailing_info(gf);
}
return 0;
}
int
lame_encoder(lame_global_flags * gf, FILE * outf, int nogap, char *inPath,
char *outPath)
{
unsigned char mp3buffer[LAME_MAXMP3BUFFER];
int Buffer[2][1152];
int iread, imp3;
static const char *mode_names[2][4] = {
{"stereo", "j-stereo", "dual-ch", "single-ch"},
{"stereo", "force-ms", "dual-ch", "single-ch"}
};
int frames;
if (silent < 10) {
lame_print_config(gf); /* print useful information about options being used */
fprintf(stderr, "Encoding %s%s to %s\n",
strcmp(inPath, "-") ? inPath : "<stdin>",
strlen(inPath) + strlen(outPath) < 66 ? "" : "\n ",
strcmp(outPath, "-") ? outPath : "<stdout>");
fprintf(stderr,
"Encoding as %g kHz ", 1.e-3 * lame_get_out_samplerate(gf));
{
const char *appendix = "";
switch (lame_get_VBR(gf)) {
case vbr_mt:
case vbr_rh:
case vbr_mtrh:
appendix = "ca. ";
fprintf(stderr, "VBR(q=%i)", lame_get_VBR_q(gf));
break;
case vbr_abr:
fprintf(stderr, "average %d kbps",
lame_get_VBR_mean_bitrate_kbps(gf));
break;
default:
fprintf(stderr, "%3d kbps", lame_get_brate(gf));
break;
}
fprintf(stderr, " %s MPEG-%u%s Layer III (%s%gx) qval=%i\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
appendix,
0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),
lame_get_quality(gf));
}
if (silent <= -10)
lame_print_internals(gf);
fflush(stderr);
}
/* encode until we hit eof */
do {
/* read in 'iread' samples */
iread = get_audio(gf, Buffer);
frames = lame_get_frameNum(gf);
/********************** status display *****************************/
if (silent <= 0) {
if (update_interval > 0) {
timestatus_klemm(gf);
}
else {
if (0 == frames % 50) {
#ifdef BRHIST
brhist_jump_back();
#endif
timestatus(lame_get_out_samplerate(gf),
frames,
lame_get_totalframes(gf),
lame_get_framesize(gf));
#ifdef BRHIST
if (brhist)
brhist_disp(gf);
#endif
}
}
}
/* encode */
imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
mp3buffer, sizeof(mp3buffer));
/* was our output buffer big enough? */
if (imp3 < 0) {
if (imp3 == -1)
fprintf(stderr, "mp3 buffer is not big enough... \n");
else
fprintf(stderr, "mp3 internal error: error code=%i\n", imp3);
return 1;
}
if (fwrite(mp3buffer, 1, imp3, outf) != imp3) {
fprintf(stderr, "Error writing mp3 output \n");
return 1;
}
} while (iread);
if (nogap)
imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
else
imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
if (imp3 < 0) {
if (imp3 == -1)
fprintf(stderr, "mp3 buffer is not big enough... \n");
else
fprintf(stderr, "mp3 internal error: error code=%i\n", imp3);
return 1;
}
if (silent <= 0) {
#ifdef BRHIST
brhist_jump_back();
#endif
frames = lame_get_frameNum(gf);
timestatus(lame_get_out_samplerate(gf),
frames, lame_get_totalframes(gf), lame_get_framesize(gf));
#ifdef BRHIST
if (brhist) {
brhist_disp(gf);
}
brhist_disp_total(gf);
#endif
timestatus_finish();
}
fwrite(mp3buffer, 1, imp3, outf);
return 0;
}
static int
lame_encoder(lame_global_flags * gf, FILE * outf, int nogap, char *inPath, char *outPath)
{
unsigned char mp3buffer[LAME_MAXMP3BUFFER];
int Buffer[2][1152];
int iread, imp3, owrite, id3v2_size;
imp3 = lame_get_id3v2_tag(gf, mp3buffer, sizeof(mp3buffer));
if ((size_t)imp3 > sizeof(mp3buffer)) {
error_printf("Error writing ID3v2 tag: buffer too small: buffer size=%d ID3v2 size=%d\n"
, sizeof(mp3buffer)
, imp3
);
return 1;
}
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing ID3v2 tag \n");
return 1;
}
if (flush_write == 1) {
fflush(outf);
}
id3v2_size = imp3;
/* encode until we hit eof */
do {
/* read in 'iread' samples.
The value of iread is 1152 (2010/07/11) on my nexus one.
*/
iread = get_audio(gf, Buffer);
//needed to add a multiplier of 2 to achieve bytes on my G1. 2010/01/09
totBytes += iread *2;
rewind(progFile);
fprintf(progFile,"%d",totBytes);
if (iread >= 0) {
//char buf[50];
//sprintf(buf,"%i",iread);
//LOGV(buf);
/* encode */
imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
mp3buffer, sizeof(mp3buffer));
/* was our output buffer big enough? */
if (imp3 < 0) {
if (imp3 == -1)
error_printf("mp3 buffer is not big enough... \n");
else
error_printf("mp3 X internal error: error code=%i\n", imp3);
return 1;
}
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing mp3 output \n");
return 1;
}
}
if (flush_write == 1) {
fflush(outf);
}
} while (iread > 0 && userCancel != 1);
if (nogap)
imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
else
imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
if (imp3 < 0) {
if (imp3 == -1)
error_printf("mp3 buffer is not big enough... \n");
else
error_printf("mp3 internal error: error code=%i\n", imp3);
return 1;
}
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing mp3 output \n");
return 1;
}
if (flush_write == 1) {
fflush(outf);
}
imp3 = lame_get_id3v1_tag(gf, mp3buffer, sizeof(mp3buffer));
if ((size_t)imp3 > sizeof(mp3buffer)) {
error_printf("Error writing ID3v1 tag: buffer too small: buffer size=%d ID3v1 size=%d\n"
, sizeof(mp3buffer)
, imp3
);
}
else {
if (imp3 > 0) {
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing ID3v1 tag \n");
return 1;
}
if (flush_write == 1) {
fflush(outf);
}
}
}
if (silent <= 0) {
print_lame_tag_leading_info(gf);
}
if (fseek(outf, id3v2_size, SEEK_SET) != 0) {
error_printf("fatal error: can't update LAME-tag frame!\n");
}
else {
write_xing_frame(gf, outf);
}
if (silent <= 0) {
print_trailing_info(gf);
}
return 0;
}
static int
lame_encoder(lame_global_flags * gf, FILE * outf, int nogap, char *inPath, char *outPath)
{
unsigned char mp3buffer[LAME_MAXMP3BUFFER];
int Buffer[2][1152];
int iread, imp3, owrite, id3v2_size;
encoder_progress_begin(gf, inPath, outPath);
imp3 = lame_get_id3v2_tag(gf, mp3buffer, sizeof(mp3buffer));
if ((size_t)imp3 > sizeof(mp3buffer)) {
encoder_progress_end(gf);
error_printf("Error writing ID3v2 tag: buffer too small: buffer size=%d ID3v2 size=%d\n"
, sizeof(mp3buffer)
, imp3
);
return 1;
}
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
encoder_progress_end(gf);
error_printf("Error writing ID3v2 tag \n");
return 1;
}
if (flush_write == 1) {
fflush(outf);
}
id3v2_size = imp3;
/* encode until we hit eof */
do {
/* read in 'iread' samples */
iread = get_audio(gf, Buffer);
if (iread >= 0) {
encoder_progress(gf);
/* encode */
imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
mp3buffer, sizeof(mp3buffer));
/* was our output buffer big enough? */
if (imp3 < 0) {
if (imp3 == -1)
error_printf("mp3 buffer is not big enough... \n");
else
error_printf("mp3 internal error: error code=%i\n", imp3);
return 1;
}
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing mp3 output \n");
return 1;
}
}
if (flush_write == 1) {
fflush(outf);
}
} while (iread > 0);
if (nogap)
imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
else
imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
if (imp3 < 0) {
if (imp3 == -1)
error_printf("mp3 buffer is not big enough... \n");
else
error_printf("mp3 internal error: error code=%i\n", imp3);
return 1;
}
encoder_progress_end(gf);
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing mp3 output \n");
return 1;
}
if (flush_write == 1) {
fflush(outf);
}
imp3 = lame_get_id3v1_tag(gf, mp3buffer, sizeof(mp3buffer));
if ((size_t)imp3 > sizeof(mp3buffer)) {
error_printf("Error writing ID3v1 tag: buffer too small: buffer size=%d ID3v1 size=%d\n"
, sizeof(mp3buffer)
, imp3
);
}
else {
if (imp3 > 0) {
owrite = (int) fwrite(mp3buffer, 1, imp3, outf);
if (owrite != imp3) {
error_printf("Error writing ID3v1 tag \n");
return 1;
}
if (flush_write == 1) {
fflush(outf);
}
}
}
if (silent <= 0) {
print_lame_tag_leading_info(gf);
}
if (fseek(outf, id3v2_size, SEEK_SET) != 0) {
error_printf("fatal error: can't update LAME-tag frame!\n");
}
else {
write_xing_frame(gf, outf);
}
if (silent <= 0) {
print_trailing_info(gf);
}
return 0;
}
/* ======================================================================= */
BOOL EncodeTrack(PWINDOWHANDLES H, DWORD Index, PCHAR BasePath, HANDLE CDHandle, PCDTRACK CDTrackData, PDWORD DiscCurrent, PDWORD DiscTotal, PDWORD TrackCount)
{
Log(LOG_WRITE, "Encoding track %u/%u; Sector %u-%u/%u", Index+1, *TrackCount, CDTrackData[Index].Address, CDTrackData[Index].Address + CDTrackData[Index].Length - 1, CDTrackData[Index].Length);
CHAR MP3FilePath[MAX_PATH];
CHAR MP3FilePathFancy[MAX_PATH];
HANDLE MP3FileHandle = INVALID_HANDLE_VALUE;
static lame_global_flags *GFP = NULL;
if(OneTrackOnly == 0)
{
_snprintf(MP3FilePath, MAX_PATH, "%s\\Track %u.mp3", BasePath, Index + 1);
MakeFancyPath(MP3FilePath, MP3FilePathFancy, 35);
SetLabel(H->WT, "Creating file %s...", MP3FilePath);
MP3FileHandle = CreateFile(MP3FilePath, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
}
else
{
_snprintf(MP3FilePath, MAX_PATH, "%s\\Audio.mp3", BasePath, Index + 1);
MakeFancyPath(MP3FilePath, MP3FilePathFancy, 35);
switch(OneTrackOnly)
{
case 1:
SetLabel(H->WT, "Creating solid file %s...", MP3FilePath);
MP3FileHandle = CreateFile(MP3FilePath, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
OneTrackOnly = 2;
break;
case 2:
SetLabel(H->WT, "Re-opening file %s...", MP3FilePath);
MP3FileHandle = CreateFile(MP3FilePath, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(MP3FileHandle != INVALID_HANDLE_VALUE)
SetFilePointer(MP3FileHandle, 0, NULL, FILE_END);
break;
}
}
BOOL Success = TRUE;
INT EncoderReturnCode = 0;
if(MP3FileHandle != INVALID_HANDLE_VALUE)
{
Log(LOG_WRITE, "Created file %s", MP3FilePath);
DWORD DiscLastCurrent = *DiscCurrent;
DWORD SectorTotal = CDTrackData[Index].Length/SECTORS_AT_READ;
DWORD MP3BytesWritten;
SendMessage(H->PO, PBM_SETRANGE32, 0, SectorTotal);
SendMessage(H->PO, PBM_SETPOS, 0, 0);
SendMessage(H->PA, PBM_SETRANGE32, 0, *DiscTotal);
if(GFP == NULL)
{
GFP = lame_init();
lame_set_preset(GFP, MP3Quality);
lame_set_copyright(GFP, 1);
lame_set_original(GFP, 1);
lame_set_error_protection(GFP, 1);
lame_set_extension(GFP, 1);
lame_set_quality(GFP, Quality);
EncoderReturnCode = lame_init_params(GFP);
}
if(EncoderReturnCode == 0)
{
DWORD dwWAVBufferSize=(1152 * lame_get_num_channels(GFP));
DWORD dwMP3BufferSize=(DWORD)(1.25*(dwWAVBufferSize/lame_get_num_channels(GFP))+7200);
PBYTE MP3Buffer = new BYTE[dwMP3BufferSize];
PBYTE CDBuffer = new BYTE[SECTORS_AT_READ * RAW_SECTOR_SIZE];
INT nOutputSamples;
DWORD CDBytesWritten;
RAW_READ_INFO Info;
Info.TrackMode = CDDA;
Info.SectorCount = SECTORS_AT_READ;
DWORD SectorCurrent;
TCHAR NumWritten[30];
TCHAR NumWrittenKB[30];
for(SectorCurrent = 0; SectorCurrent < SectorTotal; ++SectorCurrent, ++*DiscCurrent)
{
Info.DiskOffset.QuadPart = (CDTrackData[Index].Address + SectorCurrent*SECTORS_AT_READ) * CD_SECTOR_SIZE;
MP3BytesWritten = SetFilePointer(MP3FileHandle, 0, NULL, FILE_CURRENT);
Comma(MP3BytesWritten, NumWritten, sizeof(NumWritten));
Comma(MP3BytesWritten / 1024, NumWrittenKB, sizeof(NumWrittenKB));
SetLabel(H->WT, "Encoding track %u of %u and sector %u of %u\nTo %s\nWritten %s bytes (%s KB) to file", Index + 1, *TrackCount, SectorCurrent, SectorTotal - 1, MP3FilePathFancy, NumWritten, NumWrittenKB);
if(DeviceIoControl(CDHandle, IOCTL_CDROM_RAW_READ, &Info, sizeof(Info), CDBuffer, SECTORS_AT_READ*RAW_SECTOR_SIZE, &CDBytesWritten, NULL) != 0)
{
if(EncodeAudioBuffer(CDBuffer, CDBytesWritten, dwWAVBufferSize, MP3FileHandle, MP3Buffer, GFP) == FALSE)
{
Log(LOG_WRITE, "Encoding of audio buffer failed");
Success = FALSE;
break;
}
}
else
{
DWORD ErrorCode = GetLastError();
if(ErrorCode == ERROR_INVALID_FUNCTION)
{
Log(LOG_WRITE, "Track %u is not a valid CDDA track", Index + 1);
Success = FALSE;
break;
}
else if(ErrorCode != ERROR_INVALID_PARAMETER)
{
Log(LOG_WRITE, "Error code %u reading track %u!", ErrorCode, Index + 1);
Success = FALSE;
break;
}
}
SendMessage(H->PO, PBM_SETPOS, SectorCurrent, 0);
SendMessage(H->PA, PBM_SETPOS, *DiscCurrent, 0);
Percentage = (float)((float)*DiscCurrent / (float)*DiscTotal) * 100;
}
if(Success == FALSE)
{
*DiscTotal -= SectorTotal;
SectorTotal = 0;
}
else if(OneTrackOnly == 0 || Index+1 == *TrackCount)
{
nOutputSamples = lame_encode_flush_nogap(GFP, MP3Buffer, LAME_MAXMP3BUFFER);
if(nOutputSamples > 0)
{
if(WriteFile(MP3FileHandle, MP3Buffer, nOutputSamples, &MP3BytesWritten, NULL) == FALSE)
{
Log(LOG_WRITE, "Failed to write %u final bytes to file", nOutputSamples);
Success = FALSE;
}
else if(nOutputSamples != (int)MP3BytesWritten)
{
Log(LOG_WRITE, "Written %u final bytes instead of %u bytes to file", MP3BytesWritten, nOutputSamples);
Success = FALSE;
}
}
else if(nOutputSamples < 0)
{
Log(LOG_WRITE, "Error code %d flushing encoded audio buffer", nOutputSamples);
Success = FALSE;
}
}
*DiscCurrent = DiscLastCurrent + SectorTotal;
SendMessage(H->PO, PBM_SETPOS, *DiscCurrent, 0);
}
else
{
Log(LOG_WRITE, "Error code %d initialising audio encoder", EncoderReturnCode);
Success = FALSE;
}
MP3BytesWritten = SetFilePointer(MP3FileHandle, 0, NULL, FILE_CURRENT);
if(CloseHandle(MP3FileHandle) == FALSE)
{
Log(LOG_WRITE, "Error code %u closing file handle");
Success = FALSE;
}
if(OneTrackOnly == 0 && (MP3BytesWritten == 0 || Success == FALSE))
{
if(DeleteFile(MP3FilePath) == FALSE)
Log(LOG_WRITE, "Error code %u deleting file");
else
Log(LOG_WRITE, "Deleted the file due to error");
}
else Log(LOG_WRITE, "Written %u bytes to file", MP3BytesWritten);
}
else
{
Log(LOG_WRITE, "Error code %u creating %s", GetLastError(), MP3FilePath);
Success = FALSE;
}
if(EncoderReturnCode == 0 && (OneTrackOnly == 0 || Index+1 == *TrackCount))
{
lame_close(GFP);
GFP = NULL;
}
return Success;
}
