diff --git a/src/export/ExportMP3.cpp b/src/export/ExportMP3.cpp
index 8f9ea8bfd..00817f6fb 100644
--- a/src/export/ExportMP3.cpp
+++ b/src/export/ExportMP3.cpp
@@ -700,20 +700,20 @@ typedef lame_global_flags *lame_init_t(void);
 typedef int lame_init_params_t(lame_global_flags*);
 typedef const char* get_lame_version_t(void);
 
-typedef int lame_encode_buffer_t (
-      lame_global_flags* gf,
-      const short int    buffer_l [],
-      const short int    buffer_r [],
-      const int          nsamples,
-      unsigned char *    mp3buf,
-      const int          mp3buf_size );
+typedef int CDECL lame_encode_buffer_ieee_float_t(
+      lame_t          gfp,
+      const float     pcm_l[],
+      const float     pcm_r[],
+      const int       nsamples,
+      unsigned char * mp3buf,
+      const int       mp3buf_size);
 
-typedef int lame_encode_buffer_interleaved_t(
-      lame_global_flags* gf,
-      short int          pcm[],
-      int                num_samples,   /* per channel */
-      unsigned char*     mp3buf,
-      int                mp3buf_size );
+typedef int CDECL lame_encode_buffer_interleaved_ieee_float_t(
+      lame_t          gfp,
+      const float     pcm[],
+      const int       nsamples,
+      unsigned char * mp3buf,
+      const int       mp3buf_size);
 
 typedef int lame_encode_flush_t(
       lame_global_flags *gf,
@@ -826,12 +826,12 @@ public:
    int GetOutBufferSize();
 
    /* returns the number of bytes written. input is interleaved if stereo*/
-   int EncodeBuffer(short int inbuffer[], unsigned char outbuffer[]);
-   int EncodeRemainder(short int inbuffer[], int nSamples,
+   int EncodeBuffer(float inbuffer[], unsigned char outbuffer[]);
+   int EncodeRemainder(float inbuffer[], int nSamples,
                        unsigned char outbuffer[]);
 
-   int EncodeBufferMono(short int inbuffer[], unsigned char outbuffer[]);
-   int EncodeRemainderMono(short int inbuffer[], int nSamples,
+   int EncodeBufferMono(float inbuffer[], unsigned char outbuffer[]);
+   int EncodeRemainderMono(float inbuffer[], int nSamples,
                            unsigned char outbuffer[]);
 
    int FinishStream(unsigned char outbuffer[]);
@@ -863,8 +863,8 @@ private:
    /* function pointers to the symbols we get from the library */
    lame_init_t* lame_init;
    lame_init_params_t* lame_init_params;
-   lame_encode_buffer_t* lame_encode_buffer;
-   lame_encode_buffer_interleaved_t* lame_encode_buffer_interleaved;
+   lame_encode_buffer_ieee_float_t* lame_encode_buffer_ieee_float;
+   lame_encode_buffer_interleaved_ieee_float_t* lame_encode_buffer_interleaved_ieee_float;
    lame_encode_flush_t* lame_encode_flush;
    lame_close_t* lame_close;
    get_lame_version_t* get_lame_version;
@@ -1085,8 +1085,8 @@ bool MP3Exporter::InitLibraryInternal()
    lame_init = ::lame_init;
    get_lame_version = ::get_lame_version;
    lame_init_params = ::lame_init_params;
-   lame_encode_buffer = ::lame_encode_buffer;
-   lame_encode_buffer_interleaved = ::lame_encode_buffer_interleaved;
+   lame_encode_buffer_ieee_float = ::lame_encode_buffer_ieee_float;
+   lame_encode_buffer_interleaved_ieee_float = ::lame_encode_buffer_interleaved_ieee_float;
    lame_encode_flush = ::lame_encode_flush;
    lame_close = ::lame_close;
 
@@ -1146,10 +1146,10 @@ bool MP3Exporter::InitLibraryExternal(wxString libpath)
       lame_lib.GetSymbol(wxT("get_lame_version"));
    lame_init_params = (lame_init_params_t *)
       lame_lib.GetSymbol(wxT("lame_init_params"));
-   lame_encode_buffer = (lame_encode_buffer_t *)
-      lame_lib.GetSymbol(wxT("lame_encode_buffer"));
-   lame_encode_buffer_interleaved = (lame_encode_buffer_interleaved_t *)
-      lame_lib.GetSymbol(wxT("lame_encode_buffer_interleaved"));
+   lame_encode_buffer_ieee_float = (lame_encode_buffer_ieee_float_t *)
+      lame_lib.GetSymbol(wxT("lame_encode_buffer_ieee_float"));
+   lame_encode_buffer_interleaved_ieee_float = (lame_encode_buffer_interleaved_ieee_float_t *)
+      lame_lib.GetSymbol(wxT("lame_encode_buffer_interleaved_ieee_float_t"));
    lame_encode_flush = (lame_encode_flush_t *)
       lame_lib.GetSymbol(wxT("lame_encode_flush"));
    lame_close = (lame_close_t *)
@@ -1199,8 +1199,8 @@ bool MP3Exporter::InitLibraryExternal(wxString libpath)
    if (!lame_init ||
       !get_lame_version ||
       !lame_init_params ||
-      !lame_encode_buffer ||
-      !lame_encode_buffer_interleaved ||
+      !lame_encode_buffer_ieee_float ||
+      !lame_encode_buffer_interleaved_ieee_float ||
       !lame_encode_flush ||
       !lame_close ||
       !lame_set_in_samplerate ||
@@ -1386,45 +1386,45 @@ int MP3Exporter::GetOutBufferSize()
    return mOutBufferSize;
 }
 
-int MP3Exporter::EncodeBuffer(short int inbuffer[], unsigned char outbuffer[])
+int MP3Exporter::EncodeBuffer(float inbuffer[], unsigned char outbuffer[])
 {
    if (!mEncoding) {
       return -1;
    }
 
-   return lame_encode_buffer_interleaved(mGF, inbuffer, mSamplesPerChunk,
+   return lame_encode_buffer_interleaved_ieee_float(mGF, inbuffer, mSamplesPerChunk,
       outbuffer, mOutBufferSize);
 }
 
-int MP3Exporter::EncodeRemainder(short int inbuffer[], int nSamples,
+int MP3Exporter::EncodeRemainder(float inbuffer[], int nSamples,
                   unsigned char outbuffer[])
 {
    if (!mEncoding) {
       return -1;
    }
 
-   return lame_encode_buffer_interleaved(mGF, inbuffer, nSamples, outbuffer,
+   return lame_encode_buffer_interleaved_ieee_float(mGF, inbuffer, nSamples, outbuffer,
       mOutBufferSize);
 }
 
-int MP3Exporter::EncodeBufferMono(short int inbuffer[], unsigned char outbuffer[])
+int MP3Exporter::EncodeBufferMono(float inbuffer[], unsigned char outbuffer[])
 {
    if (!mEncoding) {
       return -1;
    }
 
-   return lame_encode_buffer(mGF, inbuffer,inbuffer, mSamplesPerChunk,
+   return lame_encode_buffer_ieee_float(mGF, inbuffer,inbuffer, mSamplesPerChunk,
       outbuffer, mOutBufferSize);
 }
 
-int MP3Exporter::EncodeRemainderMono(short int inbuffer[], int nSamples,
+int MP3Exporter::EncodeRemainderMono(float inbuffer[], int nSamples,
                   unsigned char outbuffer[])
 {
    if (!mEncoding) {
       return -1;
    }
 
-   return lame_encode_buffer(mGF, inbuffer, inbuffer, nSamples, outbuffer,
+   return lame_encode_buffer_ieee_float(mGF, inbuffer, inbuffer, nSamples, outbuffer,
       mOutBufferSize);
 }
 
@@ -1914,7 +1914,7 @@ ProgressResult ExportMP3::Export(AudacityProject *project,
       auto mixer = CreateMixer(tracks, selectionOnly,
          t0, t1,
          channels, inSamples, true,
-         rate, int16Sample, true, mixerSpec);
+         rate, floatSample, true, mixerSpec);
 
       TranslatableString title;
       if (rmode == MODE_SET) {
@@ -1946,7 +1946,7 @@ ProgressResult ExportMP3::Export(AudacityProject *project,
             break;
          }
 
-         short *mixed = (short *)mixer->GetBuffer();
+         float *mixed = (float *)mixer->GetBuffer();
 
          if ((int)blockLen < inSamples) {
             if (channels > 1) {