--- a/media/libcubeb/src/cubeb_mixer.cpp
+++ b/media/libcubeb/src/cubeb_mixer.cpp
@@ -583,17 +583,17 @@ int MixerContext::init()
       }
     }
     _matrix_ch[i][0] = ch_in;
   }
 
   return 0;
 }
 
-static int rematrix(const MixerContext * s, void * out, void * in, uint32_t frames)
+static int rematrix(const MixerContext * s, void * out, const void * in, uint32_t frames)
 {
   for (uint32_t out_i = 0; out_i < s->_out_ch_count; out_i++) {
     switch (s->_matrix_ch[out_i][0]) {
       case 0:
         if (s->_format == CUBEB_SAMPLE_FLOAT32NE) {
           float* outf = static_cast<float*>(out) + out_i;
           for (uint32_t i = 0; i < frames; i++) {
             outf[i * s->_out_ch_count] = 0;
@@ -605,27 +605,27 @@ static int rematrix(const MixerContext *
             outi[i * s->_out_ch_count] = 0;
           }
         }
         break;
       case 1: {
         int in_i = s->_matrix_ch[out_i][1];
         if (s->_format == CUBEB_SAMPLE_FLOAT32NE) {
           float* outf = static_cast<float*>(out) + out_i;
-          float* inf = static_cast<float*>(in) + in_i;
+          const float* inf = static_cast<const float*>(in) + in_i;
           copy(outf,
                s->_out_ch_count,
                inf,
                s->_in_ch_count,
                s->_matrix_flt[out_i][in_i],
                frames);
         } else {
           assert(s->_format == CUBEB_SAMPLE_S16NE);
           int16_t* outi = static_cast<int16_t*>(out) + out_i;
-          int16_t* ini = static_cast<int16_t*>(in) + in_i;
+          const int16_t* ini = static_cast<const int16_t*>(in) + in_i;
           if (s->_clipping) {
             copy<int16_t, int, true>(outi,
                                      s->_out_ch_count,
                                      ini,
                                      s->_in_ch_count,
                                      s->_matrix32[out_i][in_i],
                                      frames);
           } else {
@@ -636,31 +636,31 @@ static int rematrix(const MixerContext *
                                       s->_matrix32[out_i][in_i],
                                       frames);
           }
         }
       } break;
       case 2:
         if (s->_format == CUBEB_SAMPLE_FLOAT32NE) {
           float* outf = static_cast<float*>(out) + out_i;
-          float* inf1 = static_cast<float*>(in) + s->_matrix_ch[out_i][1];
-          float* inf2 = static_cast<float*>(in) + s->_matrix_ch[out_i][2];
+          const float* inf1 = static_cast<const float*>(in) + s->_matrix_ch[out_i][1];
+          const float* inf2 = static_cast<const float*>(in) + s->_matrix_ch[out_i][2];
           sum2(outf,
                s->_out_ch_count,
                inf1,
                inf2,
                s->_in_ch_count,
                s->_matrix_flt[out_i][s->_matrix_ch[out_i][1]],
                s->_matrix_flt[out_i][s->_matrix_ch[out_i][2]],
                frames);
         } else {
           assert(s->_format == CUBEB_SAMPLE_S16NE);
           int16_t* outi = static_cast<int16_t*>(out) + out_i;
-          int16_t* ini1 = static_cast<int16_t*>(in) + s->_matrix_ch[out_i][1];
-          int16_t* ini2 = static_cast<int16_t*>(in) + s->_matrix_ch[out_i][2];
+          const int16_t* ini1 = static_cast<const int16_t*>(in) + s->_matrix_ch[out_i][1];
+          const int16_t* ini2 = static_cast<const int16_t*>(in) + s->_matrix_ch[out_i][2];
           if (s->_clipping) {
             sum2<int16_t, int, true>(
               outi,
               s->_out_ch_count,
               ini1,
               ini2,
               s->_in_ch_count,
               s->_matrix32[out_i][s->_matrix_ch[out_i][1]],
@@ -677,30 +677,30 @@ static int rematrix(const MixerContext *
               s->_matrix32[out_i][s->_matrix_ch[out_i][2]],
               frames);
           }
         }
         break;
       default:
         if (s->_format == CUBEB_SAMPLE_FLOAT32NE) {
           float* outf = static_cast<float*>(out) + out_i;
-          float* inf = static_cast<float*>(in);
+          const float* inf = static_cast<const float*>(in);
           for (uint32_t i = 0; i < frames; i++) {
             float v = 0;
             for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
               uint32_t in_i = s->_matrix_ch[out_i][1 + j];
               v += *(inf + in_i + i * s->_in_ch_count) *
                    s->_matrix_flt[out_i][in_i];
             }
             outf[i * s->_out_ch_count] = v;
           }
         } else {
           assert(s->_format == CUBEB_SAMPLE_S16NE);
           int16_t* outi = static_cast<int16_t*>(out) + out_i;
-          int16_t* ini = static_cast<int16_t*>(in);
+          const int16_t* ini = static_cast<const int16_t*>(in);
           for (uint32_t i = 0; i < frames; i++) {
             int v = 0;
             for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
               uint32_t in_i = s->_matrix_ch[out_i][1 + j];
               v +=
                 *(ini + in_i + i * s->_in_ch_count) * s->_matrix32[out_i][in_i];
             }
             if (s->_clipping) {
@@ -723,18 +723,18 @@ struct cubeb_mixer
               uint32_t out_channels,
               cubeb_channel_layout out_layout)
     : _context(format, in_channels, in_layout, out_channels, out_layout)
   {
   }
 
   template<typename T>
   void copy_and_trunc(unsigned long frames,
-                      T* input_buffer,
-                      T* output_buffer) const
+                      const T * input_buffer,
+                      T * output_buffer) const
   {
     if (_context._in_ch_count <= _context._out_ch_count) {
       // Not enough channels to copy, fill the gaps with silence.
       for (uint32_t i = 0; i < frames; i++) {
         PodCopy(output_buffer, input_buffer, _context._in_ch_count);
         output_buffer += _context._in_ch_count;
         input_buffer += _context._in_ch_count;
         PodZero(output_buffer, _context._out_ch_count - _context._in_ch_count);
@@ -745,17 +745,17 @@ struct cubeb_mixer
         PodCopy(output_buffer, input_buffer, _context._out_ch_count);
         output_buffer += _context._out_ch_count;
         input_buffer += _context._in_ch_count;
       }
     }
   }
 
   int mix(unsigned long frames,
-          void * input_buffer,
+          const void * input_buffer,
           unsigned long input_buffer_size,
           void * output_buffer,
           unsigned long output_buffer_size) const
   {
     if (frames <= 0 || _context._out_ch_count == 0) {
       return 0;
     }
 
@@ -771,23 +771,23 @@ struct cubeb_mixer
       return -1;
     }
 
     if (!valid()) {
       // The channel layouts were invalid or unsupported, instead we will simply
       // either drop the extra channels, or fill with silence the missing ones
       if (_context._format == CUBEB_SAMPLE_FLOAT32NE) {
         copy_and_trunc(frames,
-                       reinterpret_cast<float*>(input_buffer),
-                       reinterpret_cast<float*>(output_buffer));
+                       static_cast<const float*>(input_buffer),
+                       static_cast<float*>(output_buffer));
       } else {
         assert(_context._format == CUBEB_SAMPLE_S16NE);
         copy_and_trunc(frames,
-                       reinterpret_cast<int16_t*>(input_buffer),
-                       reinterpret_cast<int16_t*>(output_buffer));
+                       static_cast<const int16_t*>(input_buffer),
+                       static_cast<int16_t*>(output_buffer));
       }
     }
 
     return rematrix(&_context, output_buffer, input_buffer, frames);
   }
 
   // Return false if any of the input or ouput layout were invalid.
   bool valid() const { return _context._valid; }
@@ -809,16 +809,16 @@ cubeb_mixer* cubeb_mixer_create(cubeb_sa
 
 void cubeb_mixer_destroy(cubeb_mixer * mixer)
 {
   delete mixer;
 }
 
 int cubeb_mixer_mix(cubeb_mixer * mixer,
                     unsigned long frames,
-                    void* input_buffer,
+                    const void * input_buffer,
                     unsigned long input_buffer_size,
-                    void* output_buffer,
+                    void * output_buffer,
                     unsigned long output_buffer_size)
 {
   return mixer->mix(
     frames, input_buffer, input_buffer_size, output_buffer, output_buffer_size);
 }

--- a/media/libcubeb/src/cubeb_mixer.h
+++ b/media/libcubeb/src/cubeb_mixer.h
@@ -18,17 +18,17 @@ typedef struct cubeb_mixer cubeb_mixer;
 cubeb_mixer * cubeb_mixer_create(cubeb_sample_format format,
                                  uint32_t in_channels,
                                  cubeb_channel_layout in_layout,
                                  uint32_t out_channels,
                                  cubeb_channel_layout out_layout);
 void cubeb_mixer_destroy(cubeb_mixer * mixer);
 int cubeb_mixer_mix(cubeb_mixer * mixer,
                     unsigned long frames,
-                    void * input_buffer,
+                    const void * input_buffer,
                     unsigned long input_buffer_size,
                     void * output_buffer,
                     unsigned long output_buffer_size);
 
 unsigned int cubeb_channel_layout_nb_channels(cubeb_channel_layout channel_layout);
 
 #if defined(__cplusplus)
 }