| 1 |
/* |
| 2 |
* Blade DLL Interface for LAME. |
| 3 |
* |
| 4 |
* Copyright (c) 1999 - 2002 A.L. Faber |
| 5 |
* |
| 6 |
* This library is free software; you can redistribute it and/or |
| 7 |
* modify it under the terms of the GNU Library General Public |
| 8 |
* License as published by the Free Software Foundation; either |
| 9 |
* version 2 of the License, or (at your option) any later version. |
| 10 |
* |
| 11 |
* This library is distributed in the hope that it will be useful, |
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 |
* Library General Public License for more details. |
| 15 |
* |
| 16 |
* You should have received a copy of the GNU Library General Public |
| 17 |
* License along with this library; if not, write to the |
| 18 |
* Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 19 |
* Boston, MA 02111-1307, USA. |
| 20 |
*/ |
| 21 |
|
| 22 |
#include <windows.h> |
| 23 |
#include <Windef.h> |
| 24 |
#include "BladeMP3EncDLL.h" |
| 25 |
#include <assert.h> |
| 26 |
#include <stdio.h> |
| 27 |
|
| 28 |
#include <lame.h> |
| 29 |
|
| 30 |
#ifdef __cplusplus |
| 31 |
extern "C" { |
| 32 |
#endif |
| 33 |
|
| 34 |
#define Min(A, B) ((A) < (B) ? (A) : (B)) |
| 35 |
#define Max(A, B) ((A) > (B) ? (A) : (B)) |
| 36 |
|
| 37 |
#define _RELEASEDEBUG 0 |
| 38 |
|
| 39 |
// lame_enc DLL version number |
| 40 |
const BYTE MAJORVERSION = 1; |
| 41 |
const BYTE MINORVERSION = 32; |
| 42 |
|
| 43 |
|
| 44 |
// Local variables |
| 45 |
static DWORD dwSampleBufferSize=0; |
| 46 |
static HMODULE gs_hModule=NULL; |
| 47 |
static BOOL gs_bLogFile=FALSE; |
| 48 |
static lame_global_flags* gfp_save = NULL; |
| 49 |
|
| 50 |
// Local function prototypes |
| 51 |
static void dump_config( lame_global_flags* gfp ); |
| 52 |
static void DebugPrintf( const char* pzFormat, ... ); |
| 53 |
static void DispErr( char const* strErr ); |
| 54 |
static void PresetOptions( lame_global_flags *gfp, LONG myPreset ); |
| 55 |
|
| 56 |
|
| 57 |
static void DebugPrintf(const char* pzFormat, ...) |
| 58 |
{ |
| 59 |
char szBuffer[1024]={'\0',}; |
| 60 |
char szFileName[MAX_PATH+1]={'\0',}; |
| 61 |
va_list ap; |
| 62 |
|
| 63 |
// Get the full module (DLL) file name |
| 64 |
GetModuleFileNameA( gs_hModule, |
| 65 |
szFileName, |
| 66 |
sizeof( szFileName ) ); |
| 67 |
|
| 68 |
// change file name extention |
| 69 |
szFileName[ strlen(szFileName) - 3 ] = 't'; |
| 70 |
szFileName[ strlen(szFileName) - 2 ] = 'x'; |
| 71 |
szFileName[ strlen(szFileName) - 1 ] = 't'; |
| 72 |
|
| 73 |
// start at beginning of the list |
| 74 |
va_start(ap, pzFormat); |
| 75 |
|
| 76 |
// copy it to the string buffer |
| 77 |
_vsnprintf(szBuffer, sizeof(szBuffer), pzFormat, ap); |
| 78 |
|
| 79 |
// log it to the file? |
| 80 |
if ( gs_bLogFile ) |
| 81 |
{ |
| 82 |
FILE* fp = NULL; |
| 83 |
|
| 84 |
// try to open the log file |
| 85 |
fp=fopen( szFileName, "a+" ); |
| 86 |
|
| 87 |
// check file open result |
| 88 |
if (fp) |
| 89 |
{ |
| 90 |
// write string to the file |
| 91 |
fputs(szBuffer,fp); |
| 92 |
|
| 93 |
// close the file |
| 94 |
fclose(fp); |
| 95 |
} |
| 96 |
} |
| 97 |
|
| 98 |
#if defined _DEBUG || defined _RELEASEDEBUG |
| 99 |
OutputDebugStringA( szBuffer ); |
| 100 |
#endif |
| 101 |
|
| 102 |
va_end(ap); |
| 103 |
} |
| 104 |
|
| 105 |
|
| 106 |
static void PresetOptions( lame_global_flags *gfp, LONG myPreset ) |
| 107 |
{ |
| 108 |
switch (myPreset) |
| 109 |
{ |
| 110 |
/*-1*/case LQP_NOPRESET: |
| 111 |
break; |
| 112 |
|
| 113 |
/*0*/case LQP_NORMAL_QUALITY: |
| 114 |
/* lame_set_quality( gfp, 5 );*/ |
| 115 |
break; |
| 116 |
|
| 117 |
/*1*/case LQP_LOW_QUALITY: |
| 118 |
lame_set_quality( gfp, 9 ); |
| 119 |
break; |
| 120 |
|
| 121 |
/*2*/case LQP_HIGH_QUALITY: |
| 122 |
lame_set_quality( gfp, 2 ); |
| 123 |
break; |
| 124 |
|
| 125 |
/*3*/case LQP_VOICE_QUALITY: // --voice flag for experimental voice mode |
| 126 |
lame_set_mode( gfp, MONO ); |
| 127 |
lame_set_preset( gfp, 56); |
| 128 |
break; |
| 129 |
|
| 130 |
/*4*/case LQP_R3MIX: // --R3MIX |
| 131 |
lame_set_preset( gfp, R3MIX); |
| 132 |
break; |
| 133 |
|
| 134 |
/*5*/case LQP_VERYHIGH_QUALITY: |
| 135 |
lame_set_quality( gfp, 0 ); |
| 136 |
break; |
| 137 |
|
| 138 |
/*6*/case LQP_STANDARD: // --PRESET STANDARD |
| 139 |
lame_set_preset( gfp, STANDARD); |
| 140 |
break; |
| 141 |
|
| 142 |
/*7*/case LQP_FAST_STANDARD: // --PRESET FAST STANDARD |
| 143 |
lame_set_preset( gfp, STANDARD_FAST); |
| 144 |
break; |
| 145 |
|
| 146 |
/*8*/case LQP_EXTREME: // --PRESET EXTREME |
| 147 |
lame_set_preset( gfp, EXTREME); |
| 148 |
break; |
| 149 |
|
| 150 |
/*9*/case LQP_FAST_EXTREME: // --PRESET FAST EXTREME: |
| 151 |
lame_set_preset( gfp, EXTREME_FAST); |
| 152 |
break; |
| 153 |
|
| 154 |
/*10*/case LQP_INSANE: // --PRESET INSANE |
| 155 |
lame_set_preset( gfp, INSANE); |
| 156 |
break; |
| 157 |
|
| 158 |
/*11*/case LQP_ABR: // --PRESET ABR |
| 159 |
// handled in beInitStream |
| 160 |
break; |
| 161 |
|
| 162 |
/*12*/case LQP_CBR: // --PRESET CBR |
| 163 |
// handled in beInitStream |
| 164 |
break; |
| 165 |
|
| 166 |
/*13*/case LQP_MEDIUM: // --PRESET MEDIUM |
| 167 |
lame_set_preset( gfp, MEDIUM); |
| 168 |
break; |
| 169 |
|
| 170 |
/*14*/case LQP_FAST_MEDIUM: // --PRESET FAST MEDIUM |
| 171 |
lame_set_preset( gfp, MEDIUM_FAST); |
| 172 |
break; |
| 173 |
|
| 174 |
/*1000*/case LQP_PHONE: |
| 175 |
lame_set_mode( gfp, MONO ); |
| 176 |
lame_set_preset( gfp, 16); |
| 177 |
break; |
| 178 |
|
| 179 |
/*2000*/case LQP_SW: |
| 180 |
lame_set_mode( gfp, MONO ); |
| 181 |
lame_set_preset( gfp, 24); |
| 182 |
break; |
| 183 |
|
| 184 |
/*3000*/case LQP_AM: |
| 185 |
lame_set_mode( gfp, MONO ); |
| 186 |
lame_set_preset( gfp, 40); |
| 187 |
break; |
| 188 |
|
| 189 |
/*4000*/case LQP_FM: |
| 190 |
lame_set_preset( gfp, 112); |
| 191 |
break; |
| 192 |
|
| 193 |
/*5000*/case LQP_VOICE: |
| 194 |
lame_set_mode( gfp, MONO ); |
| 195 |
lame_set_preset( gfp, 56); |
| 196 |
break; |
| 197 |
|
| 198 |
/*6000*/case LQP_RADIO: |
| 199 |
lame_set_preset( gfp, 112); |
| 200 |
break; |
| 201 |
|
| 202 |
/*7000*/case LQP_TAPE: |
| 203 |
lame_set_preset( gfp, 112); |
| 204 |
break; |
| 205 |
|
| 206 |
/*8000*/case LQP_HIFI: |
| 207 |
lame_set_preset( gfp, 160); |
| 208 |
break; |
| 209 |
|
| 210 |
/*9000*/case LQP_CD: |
| 211 |
lame_set_preset( gfp, 192); |
| 212 |
break; |
| 213 |
|
| 214 |
/*10000*/case LQP_STUDIO: |
| 215 |
lame_set_preset( gfp, 256); |
| 216 |
break; |
| 217 |
|
| 218 |
} |
| 219 |
} |
| 220 |
|
| 221 |
|
| 222 |
__declspec(dllexport) BE_ERR beInitStream(PBE_CONFIG pbeConfig, PDWORD dwSamples, PDWORD dwBufferSize, PHBE_STREAM phbeStream) |
| 223 |
{ |
| 224 |
int actual_bitrate; |
| 225 |
//2001-12-18 |
| 226 |
BE_CONFIG lameConfig = { 0, }; |
| 227 |
int nInitReturn = 0; |
| 228 |
lame_global_flags* gfp = NULL; |
| 229 |
|
| 230 |
// Init the global flags structure |
| 231 |
gfp = lame_init(); |
| 232 |
*phbeStream = (HBE_STREAM)gfp; |
| 233 |
|
| 234 |
// clear out structure |
| 235 |
memset(&lameConfig,0x00,CURRENT_STRUCT_SIZE); |
| 236 |
|
| 237 |
// Check if this is a regular BLADE_ENCODER header |
| 238 |
if (pbeConfig->dwConfig!=BE_CONFIG_LAME) |
| 239 |
{ |
| 240 |
int nCRC=pbeConfig->format.mp3.bCRC; |
| 241 |
int nVBR=(nCRC>>12)&0x0F; |
| 242 |
|
| 243 |
// Copy parameter from old Blade structure |
| 244 |
lameConfig.format.LHV1.dwSampleRate =pbeConfig->format.mp3.dwSampleRate; |
| 245 |
//for low bitrates, LAME will automatically downsample for better |
| 246 |
//sound quality. Forcing output samplerate = input samplerate is not a good idea |
| 247 |
//unless the user specifically requests it: |
| 248 |
//lameConfig.format.LHV1.dwReSampleRate=pbeConfig->format.mp3.dwSampleRate; |
| 249 |
lameConfig.format.LHV1.nMode =(pbeConfig->format.mp3.byMode&0x0F); |
| 250 |
lameConfig.format.LHV1.dwBitrate =pbeConfig->format.mp3.wBitrate; |
| 251 |
lameConfig.format.LHV1.bPrivate =pbeConfig->format.mp3.bPrivate; |
| 252 |
lameConfig.format.LHV1.bOriginal =pbeConfig->format.mp3.bOriginal; |
| 253 |
lameConfig.format.LHV1.bCRC =nCRC&0x01; |
| 254 |
lameConfig.format.LHV1.bCopyright =pbeConfig->format.mp3.bCopyright; |
| 255 |
|
| 256 |
// Fill out the unknowns |
| 257 |
lameConfig.format.LHV1.dwStructSize=CURRENT_STRUCT_SIZE; |
| 258 |
lameConfig.format.LHV1.dwStructVersion=CURRENT_STRUCT_VERSION; |
| 259 |
|
| 260 |
// Get VBR setting from fourth nibble |
| 261 |
if ( nVBR>0 ) |
| 262 |
{ |
| 263 |
lameConfig.format.LHV1.bWriteVBRHeader = TRUE; |
| 264 |
lameConfig.format.LHV1.bEnableVBR = TRUE; |
| 265 |
lameConfig.format.LHV1.nVBRQuality = nVBR-1; |
| 266 |
} |
| 267 |
|
| 268 |
// Get Quality from third nibble |
| 269 |
lameConfig.format.LHV1.nPreset=((nCRC>>8)&0x0F); |
| 270 |
|
| 271 |
} |
| 272 |
else |
| 273 |
{ |
| 274 |
// Copy the parameters |
| 275 |
memcpy(&lameConfig,pbeConfig,pbeConfig->format.LHV1.dwStructSize); |
| 276 |
} |
| 277 |
|
| 278 |
// --------------- Set arguments to LAME encoder ------------------------- |
| 279 |
|
| 280 |
// Set input sample frequency |
| 281 |
lame_set_in_samplerate( gfp, lameConfig.format.LHV1.dwSampleRate ); |
| 282 |
|
| 283 |
// disable INFO/VBR tag by default. |
| 284 |
// if this tag is used, the calling program must call beWriteVBRTag() |
| 285 |
// after encoding. But the original DLL documentation does not |
| 286 |
// require the |
| 287 |
// app to call beWriteVBRTag() unless they have specifically |
| 288 |
// set LHV1.bWriteVBRHeader=TRUE. Thus the default setting should |
| 289 |
// be disabled. |
| 290 |
lame_set_bWriteVbrTag( gfp, 0 ); |
| 291 |
|
| 292 |
//2001-12-18 Dibrom's ABR preset stuff |
| 293 |
|
| 294 |
if(lameConfig.format.LHV1.nPreset == LQP_ABR) // --ALT-PRESET ABR |
| 295 |
{ |
| 296 |
actual_bitrate = lameConfig.format.LHV1.dwVbrAbr_bps / 1000; |
| 297 |
|
| 298 |
// limit range |
| 299 |
if( actual_bitrate > 320) |
| 300 |
{ |
| 301 |
actual_bitrate = 320; |
| 302 |
} |
| 303 |
|
| 304 |
if( actual_bitrate < 8 ) |
| 305 |
{ |
| 306 |
actual_bitrate = 8; |
| 307 |
} |
| 308 |
|
| 309 |
lame_set_preset( gfp, actual_bitrate ); |
| 310 |
} |
| 311 |
|
| 312 |
// end Dibrom's ABR preset 2001-12-18 ****** START OF CBR |
| 313 |
|
| 314 |
if(lameConfig.format.LHV1.nPreset == LQP_CBR) // --ALT-PRESET CBR |
| 315 |
{ |
| 316 |
actual_bitrate = lameConfig.format.LHV1.dwBitrate; |
| 317 |
lame_set_preset(gfp, actual_bitrate); |
| 318 |
lame_set_VBR(gfp, vbr_off); |
| 319 |
} |
| 320 |
|
| 321 |
// end Dibrom's CBR preset 2001-12-18 |
| 322 |
|
| 323 |
// The following settings only used when preset is not one of the LAME QUALITY Presets |
| 324 |
if ( (int)lameConfig.format.LHV1.nPreset < (int) LQP_STANDARD ) |
| 325 |
{ |
| 326 |
switch ( lameConfig.format.LHV1.nMode ) |
| 327 |
{ |
| 328 |
case BE_MP3_MODE_STEREO: |
| 329 |
lame_set_mode( gfp, STEREO ); |
| 330 |
lame_set_num_channels( gfp, 2 ); |
| 331 |
break; |
| 332 |
case BE_MP3_MODE_JSTEREO: |
| 333 |
lame_set_mode( gfp, JOINT_STEREO ); |
| 334 |
//lame_set_force_ms( gfp, bForceMS ); // no check box to force this? |
| 335 |
lame_set_num_channels( gfp, 2 ); |
| 336 |
break; |
| 337 |
case BE_MP3_MODE_MONO: |
| 338 |
lame_set_mode( gfp, MONO ); |
| 339 |
lame_set_num_channels( gfp, 1 ); |
| 340 |
break; |
| 341 |
case BE_MP3_MODE_DUALCHANNEL: |
| 342 |
lame_set_mode( gfp, DUAL_CHANNEL ); |
| 343 |
lame_set_num_channels( gfp, 2 ); |
| 344 |
break; |
| 345 |
default: |
| 346 |
{ |
| 347 |
DebugPrintf("Invalid lameConfig.format.LHV1.nMode, value is %d\n",lameConfig.format.LHV1.nMode); |
| 348 |
return BE_ERR_INVALID_FORMAT_PARAMETERS; |
| 349 |
} |
| 350 |
} |
| 351 |
|
| 352 |
if ( lameConfig.format.LHV1.bEnableVBR ) |
| 353 |
{ |
| 354 |
/* set VBR quality */ |
| 355 |
lame_set_VBR_q( gfp, lameConfig.format.LHV1.nVBRQuality ); |
| 356 |
|
| 357 |
/* select proper VBR method */ |
| 358 |
switch ( lameConfig.format.LHV1.nVbrMethod) |
| 359 |
{ |
| 360 |
case VBR_METHOD_NONE: |
| 361 |
lame_set_VBR( gfp, vbr_off ); |
| 362 |
break; |
| 363 |
|
| 364 |
case VBR_METHOD_DEFAULT: |
| 365 |
lame_set_VBR( gfp, vbr_default ); |
| 366 |
break; |
| 367 |
|
| 368 |
case VBR_METHOD_OLD: |
| 369 |
lame_set_VBR( gfp, vbr_rh ); |
| 370 |
break; |
| 371 |
|
| 372 |
case VBR_METHOD_MTRH: |
| 373 |
case VBR_METHOD_NEW: |
| 374 |
/* |
| 375 |
* the --vbr-mtrh commandline switch is obsolete. |
| 376 |
* now --vbr-mtrh is known as --vbr-new |
| 377 |
*/ |
| 378 |
lame_set_VBR( gfp, vbr_mtrh ); |
| 379 |
break; |
| 380 |
|
| 381 |
case VBR_METHOD_ABR: |
| 382 |
lame_set_VBR( gfp, vbr_abr ); |
| 383 |
break; |
| 384 |
|
| 385 |
default: |
| 386 |
/* unsupported VBR method */ |
| 387 |
assert( FALSE ); |
| 388 |
} |
| 389 |
} |
| 390 |
else |
| 391 |
{ |
| 392 |
/* use CBR encoding method, so turn off VBR */ |
| 393 |
lame_set_VBR( gfp, vbr_off ); |
| 394 |
} |
| 395 |
|
| 396 |
/* Set bitrate. (CDex users always specify bitrate=Min bitrate when using VBR) */ |
| 397 |
lame_set_brate( gfp, lameConfig.format.LHV1.dwBitrate ); |
| 398 |
|
| 399 |
/* check if we have to use ABR, in order to backwards compatible, this |
| 400 |
* condition should still be checked indepedent of the nVbrMethod method |
| 401 |
*/ |
| 402 |
if (lameConfig.format.LHV1.dwVbrAbr_bps > 0 ) |
| 403 |
{ |
| 404 |
/* set VBR method to ABR */ |
| 405 |
lame_set_VBR( gfp, vbr_abr ); |
| 406 |
|
| 407 |
/* calculate to kbps, round to nearest kbps */ |
| 408 |
lame_set_VBR_mean_bitrate_kbps( gfp, ( lameConfig.format.LHV1.dwVbrAbr_bps + 500 ) / 1000 ); |
| 409 |
|
| 410 |
/* limit range */ |
| 411 |
if( lame_get_VBR_mean_bitrate_kbps( gfp ) > 320) |
| 412 |
{ |
| 413 |
lame_set_VBR_mean_bitrate_kbps( gfp, 320 ); |
| 414 |
} |
| 415 |
|
| 416 |
if( lame_get_VBR_mean_bitrate_kbps( gfp ) < 8 ) |
| 417 |
{ |
| 418 |
lame_set_VBR_mean_bitrate_kbps( gfp, 8 ); |
| 419 |
} |
| 420 |
} |
| 421 |
|
| 422 |
} |
| 423 |
|
| 424 |
// First set all the preset options |
| 425 |
if ( LQP_NOPRESET != lameConfig.format.LHV1.nPreset ) |
| 426 |
{ |
| 427 |
PresetOptions( gfp, lameConfig.format.LHV1.nPreset ); |
| 428 |
} |
| 429 |
|
| 430 |
|
| 431 |
// Set frequency resampling rate, if specified |
| 432 |
if ( lameConfig.format.LHV1.dwReSampleRate > 0 ) |
| 433 |
{ |
| 434 |
lame_set_out_samplerate( gfp, lameConfig.format.LHV1.dwReSampleRate ); |
| 435 |
} |
| 436 |
|
| 437 |
|
| 438 |
switch ( lameConfig.format.LHV1.nMode ) |
| 439 |
{ |
| 440 |
case BE_MP3_MODE_MONO: |
| 441 |
lame_set_mode( gfp, MONO ); |
| 442 |
lame_set_num_channels( gfp, 1 ); |
| 443 |
break; |
| 444 |
|
| 445 |
default: |
| 446 |
break; |
| 447 |
} |
| 448 |
|
| 449 |
|
| 450 |
// Use strict ISO encoding? |
| 451 |
lame_set_strict_ISO( gfp, ( lameConfig.format.LHV1.bStrictIso ) ? 1 : 0 ); |
| 452 |
|
| 453 |
// Set copyright flag? |
| 454 |
if ( lameConfig.format.LHV1.bCopyright ) |
| 455 |
{ |
| 456 |
lame_set_copyright( gfp, 1 ); |
| 457 |
} |
| 458 |
|
| 459 |
// Do we have to tag it as non original |
| 460 |
if ( !lameConfig.format.LHV1.bOriginal ) |
| 461 |
{ |
| 462 |
lame_set_original( gfp, 0 ); |
| 463 |
} |
| 464 |
else |
| 465 |
{ |
| 466 |
lame_set_original( gfp, 1 ); |
| 467 |
} |
| 468 |
|
| 469 |
// Add CRC? |
| 470 |
if ( lameConfig.format.LHV1.bCRC ) |
| 471 |
{ |
| 472 |
lame_set_error_protection( gfp, 1 ); |
| 473 |
} |
| 474 |
else |
| 475 |
{ |
| 476 |
lame_set_error_protection( gfp, 0 ); |
| 477 |
} |
| 478 |
|
| 479 |
// Set private bit? |
| 480 |
if ( lameConfig.format.LHV1.bPrivate ) |
| 481 |
{ |
| 482 |
lame_set_extension( gfp, 1 ); |
| 483 |
} |
| 484 |
else |
| 485 |
{ |
| 486 |
lame_set_extension( gfp, 0 ); |
| 487 |
} |
| 488 |
|
| 489 |
|
| 490 |
// Set VBR min bitrate, if specified |
| 491 |
if ( lameConfig.format.LHV1.dwBitrate > 0 ) |
| 492 |
{ |
| 493 |
lame_set_VBR_min_bitrate_kbps( gfp, lameConfig.format.LHV1.dwBitrate ); |
| 494 |
} |
| 495 |
|
| 496 |
// Set Maxbitrate, if specified |
| 497 |
if ( lameConfig.format.LHV1.dwMaxBitrate > 0 ) |
| 498 |
{ |
| 499 |
lame_set_VBR_max_bitrate_kbps( gfp, lameConfig.format.LHV1.dwMaxBitrate ); |
| 500 |
} |
| 501 |
// Set bit resovoir option |
| 502 |
if ( lameConfig.format.LHV1.bNoRes ) |
| 503 |
{ |
| 504 |
lame_set_disable_reservoir( gfp,1 ); |
| 505 |
} |
| 506 |
|
| 507 |
// check if the VBR tag is required |
| 508 |
if ( lameConfig.format.LHV1.bWriteVBRHeader ) |
| 509 |
{ |
| 510 |
lame_set_bWriteVbrTag( gfp, 1 ); |
| 511 |
} |
| 512 |
else |
| 513 |
{ |
| 514 |
lame_set_bWriteVbrTag( gfp, 0 ); |
| 515 |
} |
| 516 |
|
| 517 |
// Override Quality setting, use HIGHBYTE = NOT LOWBYTE to be backwards compatible |
| 518 |
if ( ( lameConfig.format.LHV1.nQuality & 0xFF ) == |
| 519 |
((~( lameConfig.format.LHV1.nQuality >> 8 )) & 0xFF) ) |
| 520 |
{ |
| 521 |
lame_set_quality( gfp, lameConfig.format.LHV1.nQuality & 0xFF ); |
| 522 |
} |
| 523 |
|
| 524 |
if ( 0 != ( nInitReturn = lame_init_params( gfp ) ) ) |
| 525 |
{ |
| 526 |
return nInitReturn; |
| 527 |
} |
| 528 |
|
| 529 |
//LAME encoding call will accept any number of samples. |
| 530 |
if ( 0 == lame_get_version( gfp ) ) |
| 531 |
{ |
| 532 |
// For MPEG-II, only 576 samples per frame per channel |
| 533 |
*dwSamples= 576 * lame_get_num_channels( gfp ); |
| 534 |
} |
| 535 |
else |
| 536 |
{ |
| 537 |
// For MPEG-I, 1152 samples per frame per channel |
| 538 |
*dwSamples= 1152 * lame_get_num_channels( gfp ); |
| 539 |
} |
| 540 |
|
| 541 |
// Set the input sample buffer size, so we know what we can expect |
| 542 |
dwSampleBufferSize = *dwSamples; |
| 543 |
|
| 544 |
// Set MP3 buffer size, conservative estimate |
| 545 |
*dwBufferSize=(DWORD)( 1.25 * ( *dwSamples / lame_get_num_channels( gfp ) ) + 7200 ); |
| 546 |
|
| 547 |
// For debugging purposes |
| 548 |
dump_config( gfp ); |
| 549 |
|
| 550 |
// Everything went OK, thus return SUCCESSFUL |
| 551 |
return BE_ERR_SUCCESSFUL; |
| 552 |
} |
| 553 |
|
| 554 |
|
| 555 |
|
| 556 |
__declspec(dllexport) BE_ERR beFlushNoGap(HBE_STREAM hbeStream, PBYTE pOutput, PDWORD pdwOutput) |
| 557 |
{ |
| 558 |
int nOutputSamples = 0; |
| 559 |
|
| 560 |
lame_global_flags* gfp = (lame_global_flags*)hbeStream; |
| 561 |
|
| 562 |
// Init the global flags structure |
| 563 |
nOutputSamples = lame_encode_flush_nogap( gfp, pOutput, LAME_MAXMP3BUFFER ); |
| 564 |
|
| 565 |
if ( nOutputSamples < 0 ) |
| 566 |
{ |
| 567 |
*pdwOutput = 0; |
| 568 |
return BE_ERR_BUFFER_TOO_SMALL; |
| 569 |
} |
| 570 |
else |
| 571 |
{ |
| 572 |
*pdwOutput = nOutputSamples; |
| 573 |
} |
| 574 |
|
| 575 |
return BE_ERR_SUCCESSFUL; |
| 576 |
} |
| 577 |
|
| 578 |
__declspec(dllexport) BE_ERR beDeinitStream(HBE_STREAM hbeStream, PBYTE pOutput, PDWORD pdwOutput) |
| 579 |
{ |
| 580 |
int nOutputSamples = 0; |
| 581 |
|
| 582 |
lame_global_flags* gfp = (lame_global_flags*)hbeStream; |
| 583 |
|
| 584 |
nOutputSamples = lame_encode_flush( gfp, pOutput, 0 ); |
| 585 |
|
| 586 |
if ( nOutputSamples < 0 ) |
| 587 |
{ |
| 588 |
*pdwOutput = 0; |
| 589 |
return BE_ERR_BUFFER_TOO_SMALL; |
| 590 |
} |
| 591 |
else |
| 592 |
{ |
| 593 |
*pdwOutput = nOutputSamples; |
| 594 |
} |
| 595 |
|
| 596 |
return BE_ERR_SUCCESSFUL; |
| 597 |
} |
| 598 |
|
| 599 |
|
| 600 |
__declspec(dllexport) BE_ERR beCloseStream(HBE_STREAM hbeStream) |
| 601 |
{ |
| 602 |
lame_global_flags* gfp = (lame_global_flags*)hbeStream; |
| 603 |
|
| 604 |
// lame will be close in VbrWriteTag function |
| 605 |
if ( !lame_get_bWriteVbrTag( gfp ) ) |
| 606 |
{ |
| 607 |
// clean up of allocated memory |
| 608 |
lame_close( gfp ); |
| 609 |
|
| 610 |
gfp_save = NULL; |
| 611 |
} |
| 612 |
else |
| 613 |
{ |
| 614 |
gfp_save = (lame_global_flags*)hbeStream; |
| 615 |
} |
| 616 |
|
| 617 |
// DeInit encoder |
| 618 |
return BE_ERR_SUCCESSFUL; |
| 619 |
} |
| 620 |
|
| 621 |
|
| 622 |
|
| 623 |
__declspec(dllexport) VOID beVersion(PBE_VERSION pbeVersion) |
| 624 |
{ |
| 625 |
// DLL Release date |
| 626 |
char lpszDate[20] = { '\0', }; |
| 627 |
char lpszTemp[5] = { '\0', }; |
| 628 |
lame_version_t lv = { 0, }; |
| 629 |
|
| 630 |
|
| 631 |
// Set DLL interface version |
| 632 |
pbeVersion->byDLLMajorVersion=MAJORVERSION; |
| 633 |
pbeVersion->byDLLMinorVersion=MINORVERSION; |
| 634 |
|
| 635 |
get_lame_version_numerical ( &lv ); |
| 636 |
|
| 637 |
// Set Engine version number (Same as Lame version) |
| 638 |
pbeVersion->byMajorVersion = (BYTE)lv.major; |
| 639 |
pbeVersion->byMinorVersion = (BYTE)lv.minor; |
| 640 |
pbeVersion->byAlphaLevel = (BYTE)lv.alpha; |
| 641 |
pbeVersion->byBetaLevel = (BYTE)lv.beta; |
| 642 |
|
| 643 |
#ifdef MMX_choose_table |
| 644 |
pbeVersion->byMMXEnabled=1; |
| 645 |
#else |
| 646 |
pbeVersion->byMMXEnabled=0; |
| 647 |
#endif |
| 648 |
|
| 649 |
memset( pbeVersion->btReserved, 0, sizeof( pbeVersion->btReserved ) ); |
| 650 |
|
| 651 |
// Get compilation date |
| 652 |
strcpy(lpszDate,__DATE__); |
| 653 |
|
| 654 |
// Get the first three character, which is the month |
| 655 |
strncpy(lpszTemp,lpszDate,3); |
| 656 |
lpszTemp[3] = '\0'; |
| 657 |
pbeVersion->byMonth=1; |
| 658 |
|
| 659 |
// Set month |
| 660 |
if (strcmp(lpszTemp,"Jan")==0) pbeVersion->byMonth = 1; |
| 661 |
if (strcmp(lpszTemp,"Feb")==0) pbeVersion->byMonth = 2; |
| 662 |
if (strcmp(lpszTemp,"Mar")==0) pbeVersion->byMonth = 3; |
| 663 |
if (strcmp(lpszTemp,"Apr")==0) pbeVersion->byMonth = 4; |
| 664 |
if (strcmp(lpszTemp,"May")==0) pbeVersion->byMonth = 5; |
| 665 |
if (strcmp(lpszTemp,"Jun")==0) pbeVersion->byMonth = 6; |
| 666 |
if (strcmp(lpszTemp,"Jul")==0) pbeVersion->byMonth = 7; |
| 667 |
if (strcmp(lpszTemp,"Aug")==0) pbeVersion->byMonth = 8; |
| 668 |
if (strcmp(lpszTemp,"Sep")==0) pbeVersion->byMonth = 9; |
| 669 |
if (strcmp(lpszTemp,"Oct")==0) pbeVersion->byMonth = 10; |
| 670 |
if (strcmp(lpszTemp,"Nov")==0) pbeVersion->byMonth = 11; |
| 671 |
if (strcmp(lpszTemp,"Dec")==0) pbeVersion->byMonth = 12; |
| 672 |
|
| 673 |
// Get day of month string (char [4..5]) |
| 674 |
pbeVersion->byDay = (BYTE) atoi( lpszDate + 4 ); |
| 675 |
|
| 676 |
// Get year of compilation date (char [7..10]) |
| 677 |
pbeVersion->wYear = (WORD) atoi( lpszDate + 7 ); |
| 678 |
|
| 679 |
memset( pbeVersion->zHomepage, 0x00, BE_MAX_HOMEPAGE ); |
| 680 |
|
| 681 |
strcpy( pbeVersion->zHomepage, "https://lame.sourceforge.io/" ); |
| 682 |
} |
| 683 |
|
| 684 |
__declspec(dllexport) BE_ERR beEncodeChunk(HBE_STREAM hbeStream, DWORD nSamples, |
| 685 |
PSHORT pSamples, PBYTE pOutput, PDWORD pdwOutput) |
| 686 |
{ |
| 687 |
// Encode it |
| 688 |
int dwSamples; |
| 689 |
int nOutputSamples = 0; |
| 690 |
lame_global_flags* gfp = (lame_global_flags*)hbeStream; |
| 691 |
|
| 692 |
dwSamples = nSamples / lame_get_num_channels( gfp ); |
| 693 |
|
| 694 |
// old versions of lame_enc.dll required exactly 1152 samples |
| 695 |
// and worked even if nSamples accidently set to 2304 |
| 696 |
// simulate this behavoir: |
| 697 |
if ( 1 == lame_get_num_channels( gfp ) && nSamples == 2304) |
| 698 |
{ |
| 699 |
dwSamples/= 2; |
| 700 |
} |
| 701 |
|
| 702 |
|
| 703 |
if ( 1 == lame_get_num_channels( gfp ) ) |
| 704 |
{ |
| 705 |
nOutputSamples = lame_encode_buffer(gfp,pSamples,pSamples,dwSamples,pOutput,0); |
| 706 |
} |
| 707 |
else |
| 708 |
{ |
| 709 |
nOutputSamples = lame_encode_buffer_interleaved(gfp,pSamples,dwSamples,pOutput,0); |
| 710 |
} |
| 711 |
|
| 712 |
|
| 713 |
if ( nOutputSamples < 0 ) |
| 714 |
{ |
| 715 |
*pdwOutput=0; |
| 716 |
return BE_ERR_BUFFER_TOO_SMALL; |
| 717 |
} |
| 718 |
else |
| 719 |
{ |
| 720 |
*pdwOutput = (DWORD)nOutputSamples; |
| 721 |
} |
| 722 |
|
| 723 |
return BE_ERR_SUCCESSFUL; |
| 724 |
} |
| 725 |
|
| 726 |
|
| 727 |
// accept floating point audio samples, scaled to the range of a signed 16-bit |
| 728 |
// integer (within +/- 32768), in non-interleaved channels -- DSPguru, jd |
| 729 |
__declspec(dllexport) BE_ERR beEncodeChunkFloatS16NI(HBE_STREAM hbeStream, DWORD nSamples, |
| 730 |
PFLOAT buffer_l, PFLOAT buffer_r, PBYTE pOutput, PDWORD pdwOutput) |
| 731 |
{ |
| 732 |
int nOutputSamples; |
| 733 |
lame_global_flags* gfp = (lame_global_flags*)hbeStream; |
| 734 |
|
| 735 |
nOutputSamples = lame_encode_buffer_float(gfp,buffer_l,buffer_r,nSamples,pOutput,0); |
| 736 |
|
| 737 |
if ( nOutputSamples >= 0 ) |
| 738 |
{ |
| 739 |
*pdwOutput = (DWORD) nOutputSamples; |
| 740 |
} |
| 741 |
else |
| 742 |
{ |
| 743 |
*pdwOutput=0; |
| 744 |
return BE_ERR_BUFFER_TOO_SMALL; |
| 745 |
} |
| 746 |
|
| 747 |
return BE_ERR_SUCCESSFUL; |
| 748 |
} |
| 749 |
|
| 750 |
static int |
| 751 |
maybeSyncWord(FILE* fpStream) |
| 752 |
{ |
| 753 |
unsigned char mp3_frame_header[4]; |
| 754 |
size_t nbytes = fread(mp3_frame_header, 1, sizeof(mp3_frame_header), fpStream); |
| 755 |
if ( nbytes != sizeof(mp3_frame_header) ) { |
| 756 |
return -1; |
| 757 |
} |
| 758 |
if ( mp3_frame_header[0] != 0xffu ) { |
| 759 |
return -1; /* doesn't look like a sync word */ |
| 760 |
} |
| 761 |
if ( (mp3_frame_header[1] & 0xE0u) != 0xE0u ) { |
| 762 |
return -1; /* doesn't look like a sync word */ |
| 763 |
} |
| 764 |
return 0; |
| 765 |
} |
| 766 |
|
| 767 |
static int |
| 768 |
skipId3v2(FILE * fpStream, size_t lametag_frame_size) |
| 769 |
{ |
| 770 |
size_t nbytes; |
| 771 |
size_t id3v2TagSize = 0; |
| 772 |
unsigned char id3v2Header[10]; |
| 773 |
|
| 774 |
/* seek to the beginning of the stream */ |
| 775 |
if (fseek(fpStream, 0, SEEK_SET) != 0) { |
| 776 |
return -2; /* not seekable, abort */ |
| 777 |
} |
| 778 |
/* read 10 bytes in case there's an ID3 version 2 header here */ |
| 779 |
nbytes = fread(id3v2Header, 1, sizeof(id3v2Header), fpStream); |
| 780 |
if (nbytes != sizeof(id3v2Header)) { |
| 781 |
return -3; /* not readable, maybe opened Write-Only */ |
| 782 |
} |
| 783 |
/* does the stream begin with the ID3 version 2 file identifier? */ |
| 784 |
if (!strncmp((char *) id3v2Header, "ID3", 3)) { |
| 785 |
/* the tag size (minus the 10-byte header) is encoded into four |
| 786 |
* bytes where the most significant bit is clear in each byte |
| 787 |
*/ |
| 788 |
id3v2TagSize = (((id3v2Header[6] & 0x7f) << 21) |
| 789 |
| ((id3v2Header[7] & 0x7f) << 14) |
| 790 |
| ((id3v2Header[8] & 0x7f) << 7) |
| 791 |
| (id3v2Header[9] & 0x7f)) |
| 792 |
+ sizeof id3v2Header; |
| 793 |
} |
| 794 |
/* Seek to the beginning of the audio stream */ |
| 795 |
if ( fseek(fpStream, id3v2TagSize, SEEK_SET) != 0 ) { |
| 796 |
return -2; |
| 797 |
} |
| 798 |
if ( maybeSyncWord(fpStream) != 0) { |
| 799 |
return -1; |
| 800 |
} |
| 801 |
if ( fseek(fpStream, id3v2TagSize+lametag_frame_size, SEEK_SET) != 0 ) { |
| 802 |
return -2; |
| 803 |
} |
| 804 |
if ( maybeSyncWord(fpStream) != 0) { |
| 805 |
return -1; |
| 806 |
} |
| 807 |
/* OK, it seems we found our LAME-Tag/Xing frame again */ |
| 808 |
/* Seek to the beginning of the audio stream */ |
| 809 |
if ( fseek(fpStream, id3v2TagSize, SEEK_SET) != 0 ) { |
| 810 |
return -2; |
| 811 |
} |
| 812 |
return 0; |
| 813 |
} |
| 814 |
|
| 815 |
static BE_ERR |
| 816 |
updateLameTagFrame(lame_global_flags* gfp, FILE* fpStream) |
| 817 |
{ |
| 818 |
size_t n = lame_get_lametag_frame( gfp, 0, 0 ); /* ask for bufer size */ |
| 819 |
|
| 820 |
if ( n > 0 ) |
| 821 |
{ |
| 822 |
unsigned char* buffer = 0; |
| 823 |
size_t m = 1; |
| 824 |
|
| 825 |
if ( 0 != skipId3v2(fpStream, n) ) |
| 826 |
{ |
| 827 |
DispErr( "Error updating LAME-tag frame:\n\n" |
| 828 |
"can't locate old frame\n" ); |
| 829 |
return BE_ERR_INVALID_FORMAT_PARAMETERS; |
| 830 |
} |
| 831 |
|
| 832 |
buffer = (unsigned char*)malloc( n ); |
| 833 |
|
| 834 |
if ( buffer == 0 ) |
| 835 |
{ |
| 836 |
DispErr( "Error updating LAME-tag frame:\n\n" |
| 837 |
"can't allocate frame buffer\n" ); |
| 838 |
return BE_ERR_INVALID_FORMAT_PARAMETERS; |
| 839 |
} |
| 840 |
|
| 841 |
/* Put it all to disk again */ |
| 842 |
n = lame_get_lametag_frame( gfp, buffer, n ); |
| 843 |
if ( n > 0 ) |
| 844 |
{ |
| 845 |
m = fwrite( buffer, n, 1, fpStream ); |
| 846 |
} |
| 847 |
free( buffer ); |
| 848 |
|
| 849 |
if ( m != 1 ) |
| 850 |
{ |
| 851 |
DispErr( "Error updating LAME-tag frame:\n\n" |
| 852 |
"couldn't write frame into file\n" ); |
| 853 |
return BE_ERR_INVALID_FORMAT_PARAMETERS; |
| 854 |
} |
| 855 |
} |
| 856 |
return BE_ERR_SUCCESSFUL; |
| 857 |
} |
| 858 |
|
| 859 |
__declspec(dllexport) BE_ERR beWriteInfoTag( HBE_STREAM hbeStream, |
| 860 |
LPCSTR lpszFileName ) |
| 861 |
{ |
| 862 |
FILE* fpStream = NULL; |
| 863 |
BE_ERR beResult = BE_ERR_SUCCESSFUL; |
| 864 |
|
| 865 |
lame_global_flags* gfp = (lame_global_flags*)hbeStream; |
| 866 |
|
| 867 |
if ( NULL != gfp ) |
| 868 |
{ |
| 869 |
// Do we have to write the VBR tag? |
| 870 |
if ( lame_get_bWriteVbrTag( gfp ) ) |
| 871 |
{ |
| 872 |
// Try to open the file |
| 873 |
fpStream=fopen( lpszFileName, "rb+" ); |
| 874 |
|
| 875 |
// Check file open result |
| 876 |
if ( NULL == fpStream ) |
| 877 |
{ |
| 878 |
beResult = BE_ERR_INVALID_FORMAT_PARAMETERS; |
| 879 |
DispErr( "Error updating LAME-tag frame:\n\n" |
| 880 |
"can't open file for reading and writing\n" ); |
| 881 |
} |
| 882 |
else |
| 883 |
{ |
| 884 |
beResult = updateLameTagFrame( gfp, fpStream ); |
| 885 |
|
| 886 |
// Close the file stream |
| 887 |
fclose( fpStream ); |
| 888 |
} |
| 889 |
} |
| 890 |
|
| 891 |
// clean up of allocated memory |
| 892 |
lame_close( gfp ); |
| 893 |
} |
| 894 |
else |
| 895 |
{ |
| 896 |
beResult = BE_ERR_INVALID_FORMAT_PARAMETERS; |
| 897 |
} |
| 898 |
|
| 899 |
// return result |
| 900 |
return beResult; |
| 901 |
} |
| 902 |
|
| 903 |
// for backwards compatiblity |
| 904 |
__declspec(dllexport) BE_ERR beWriteVBRHeader(LPCSTR lpszFileName) |
| 905 |
{ |
| 906 |
return beWriteInfoTag( (HBE_STREAM)gfp_save, lpszFileName ); |
| 907 |
} |
| 908 |
|
| 909 |
|
| 910 |
BOOL APIENTRY DllMain(HANDLE hModule, |
| 911 |
DWORD ul_reason_for_call, |
| 912 |
LPVOID lpReserved) |
| 913 |
{ |
| 914 |
(void) lpReserved; |
| 915 |
gs_hModule = (HMODULE) hModule; |
| 916 |
|
| 917 |
switch( ul_reason_for_call ) |
| 918 |
{ |
| 919 |
case DLL_PROCESS_ATTACH: |
| 920 |
// Enable debug/logging? |
| 921 |
gs_bLogFile = GetPrivateProfileIntA("Debug","WriteLogFile",gs_bLogFile,"lame_enc.ini"); |
| 922 |
break; |
| 923 |
case DLL_THREAD_ATTACH: |
| 924 |
break; |
| 925 |
case DLL_THREAD_DETACH: |
| 926 |
break; |
| 927 |
case DLL_PROCESS_DETACH: |
| 928 |
break; |
| 929 |
} |
| 930 |
return TRUE; |
| 931 |
} |
| 932 |
|
| 933 |
|
| 934 |
static void dump_config( lame_global_flags* gfp ) |
| 935 |
{ |
| 936 |
DebugPrintf("\n\nLame_enc configuration options:\n"); |
| 937 |
DebugPrintf("==========================================================\n"); |
| 938 |
|
| 939 |
DebugPrintf("version =%d\n",lame_get_version( gfp ) ); |
| 940 |
DebugPrintf("Layer =3\n"); |
| 941 |
DebugPrintf("mode ="); |
| 942 |
switch ( lame_get_mode( gfp ) ) |
| 943 |
{ |
| 944 |
case STEREO: DebugPrintf( "Stereo\n" ); break; |
| 945 |
case JOINT_STEREO: DebugPrintf( "Joint-Stereo\n" ); break; |
| 946 |
case DUAL_CHANNEL: DebugPrintf( "Forced Stereo\n" ); break; |
| 947 |
case MONO: DebugPrintf( "Mono\n" ); break; |
| 948 |
case NOT_SET: /* FALLTROUGH */ |
| 949 |
default: DebugPrintf( "Error (unknown)\n" ); break; |
| 950 |
} |
| 951 |
|
| 952 |
DebugPrintf("Input sample rate =%.1f kHz\n", lame_get_in_samplerate( gfp ) /1000.0 ); |
| 953 |
DebugPrintf("Output sample rate =%.1f kHz\n", lame_get_out_samplerate( gfp ) /1000.0 ); |
| 954 |
|
| 955 |
DebugPrintf("bitrate =%d kbps\n", lame_get_brate( gfp ) ); |
| 956 |
DebugPrintf("Quality Setting =%d\n", lame_get_quality( gfp ) ); |
| 957 |
|
| 958 |
DebugPrintf("Low pass frequency =%d\n", lame_get_lowpassfreq( gfp ) ); |
| 959 |
DebugPrintf("Low pass width =%d\n", lame_get_lowpasswidth( gfp ) ); |
| 960 |
|
| 961 |
DebugPrintf("High pass frequency =%d\n", lame_get_highpassfreq( gfp ) ); |
| 962 |
DebugPrintf("High pass width =%d\n", lame_get_highpasswidth( gfp ) ); |
| 963 |
|
| 964 |
DebugPrintf("No short blocks =%d\n", lame_get_no_short_blocks( gfp ) ); |
| 965 |
DebugPrintf("Force short blocks =%d\n", lame_get_force_short_blocks( gfp ) ); |
| 966 |
|
| 967 |
DebugPrintf("de-emphasis =%d\n", lame_get_emphasis( gfp ) ); |
| 968 |
DebugPrintf("private flag =%d\n", lame_get_extension( gfp ) ); |
| 969 |
|
| 970 |
DebugPrintf("copyright flag =%d\n", lame_get_copyright( gfp ) ); |
| 971 |
DebugPrintf("original flag =%d\n", lame_get_original( gfp ) ); |
| 972 |
DebugPrintf("CRC =%s\n", lame_get_error_protection( gfp ) ? "on" : "off" ); |
| 973 |
DebugPrintf("Fast mode =%s\n", ( lame_get_quality( gfp ) )? "enabled" : "disabled" ); |
| 974 |
DebugPrintf("Force mid/side stereo =%s\n", ( lame_get_force_ms( gfp ) )?"enabled":"disabled" ); |
| 975 |
DebugPrintf("Disable Reservoir =%d\n", lame_get_disable_reservoir( gfp ) ); |
| 976 |
DebugPrintf("Allow diff-short =%d\n", lame_get_allow_diff_short( gfp ) ); |
| 977 |
DebugPrintf("Interchannel masking =%f\n", lame_get_interChRatio( gfp ) ); |
| 978 |
DebugPrintf("Strict ISO Encoding =%s\n", ( lame_get_strict_ISO( gfp ) ) ?"Yes":"No"); |
| 979 |
DebugPrintf("Scale =%5.2f\n", lame_get_scale( gfp ) ); |
| 980 |
|
| 981 |
DebugPrintf("VBR =%s, VBR_q =%d, VBR method =", |
| 982 |
( lame_get_VBR( gfp ) !=vbr_off ) ? "enabled": "disabled", |
| 983 |
lame_get_VBR_q( gfp ) ); |
| 984 |
|
| 985 |
switch ( lame_get_VBR( gfp ) ) |
| 986 |
{ |
| 987 |
case vbr_off: DebugPrintf( "vbr_off\n" ); break; |
| 988 |
case vbr_mt : DebugPrintf( "vbr_mt \n" ); break; |
| 989 |
case vbr_rh : DebugPrintf( "vbr_rh \n" ); break; |
| 990 |
case vbr_mtrh: DebugPrintf( "vbr_mtrh \n" ); break; |
| 991 |
case vbr_abr: |
| 992 |
DebugPrintf( "vbr_abr (average bitrate %d kbps)\n", lame_get_VBR_mean_bitrate_kbps( gfp ) ); |
| 993 |
break; |
| 994 |
default: |
| 995 |
DebugPrintf("error, unknown VBR setting\n"); |
| 996 |
break; |
| 997 |
} |
| 998 |
|
| 999 |
DebugPrintf("Vbr Min bitrate =%d kbps\n", lame_get_VBR_min_bitrate_kbps( gfp ) ); |
| 1000 |
DebugPrintf("Vbr Max bitrate =%d kbps\n", lame_get_VBR_max_bitrate_kbps( gfp ) ); |
| 1001 |
|
| 1002 |
DebugPrintf("Write VBR Header =%s\n", ( lame_get_bWriteVbrTag( gfp ) ) ?"Yes":"No"); |
| 1003 |
DebugPrintf("VBR Hard min =%d\n", lame_get_VBR_hard_min( gfp ) ); |
| 1004 |
|
| 1005 |
DebugPrintf("ATH Only =%d\n", lame_get_ATHonly( gfp ) ); |
| 1006 |
DebugPrintf("ATH short =%d\n", lame_get_ATHshort( gfp ) ); |
| 1007 |
DebugPrintf("ATH no =%d\n", lame_get_noATH( gfp ) ); |
| 1008 |
DebugPrintf("ATH type =%d\n", lame_get_ATHtype( gfp ) ); |
| 1009 |
DebugPrintf("ATH lower =%f\n", lame_get_ATHlower( gfp ) ); |
| 1010 |
DebugPrintf("ATH aa =%d\n", lame_get_athaa_type( gfp ) ); |
| 1011 |
//DebugPrintf("ATH aa loudapprox =%d\n", lame_get_athaa_loudapprox( gfp ) ); |
| 1012 |
DebugPrintf("ATH aa sensitivity =%f\n", lame_get_athaa_sensitivity( gfp ) ); |
| 1013 |
|
| 1014 |
DebugPrintf("Experimental nspsytune =%d\n", lame_get_exp_nspsytune( gfp ) ); |
| 1015 |
DebugPrintf("Experimental X =%d\n", lame_get_experimentalX( gfp ) ); |
| 1016 |
DebugPrintf("Experimental Y =%d\n", lame_get_experimentalY( gfp ) ); |
| 1017 |
DebugPrintf("Experimental Z =%d\n", lame_get_experimentalZ( gfp ) ); |
| 1018 |
} |
| 1019 |
|
| 1020 |
|
| 1021 |
static void DispErr(char const* strErr) |
| 1022 |
{ |
| 1023 |
MessageBoxA(NULL,strErr,"LAME_ENC.DLL",MB_OK|MB_ICONHAND); |
| 1024 |
} |
| 1025 |
|
| 1026 |
#ifdef __cplusplus |
| 1027 |
} |
| 1028 |
#endif |