Switch to standard integer types in media/.

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/ffmpeg_audio_decoder.h"
 
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
@@ skipping 24 matching lines @@
 #if defined(CHROMIUM_NO_AVFRAME_CHANNELS)
   // When use_system_ffmpeg==1, libav's AVFrame doesn't have channels field.
   return av_get_channel_layout_nb_channels(frame->channel_layout);
 #else
   return frame->channels;
 #endif
 }
 
 // Called by FFmpeg's allocation routine to free a buffer. |opaque| is the
 // AudioBuffer allocated, so unref it.
-static void ReleaseAudioBufferImpl(void* opaque, uint8* data) {
+static void ReleaseAudioBufferImpl(void* opaque, uint8_t* data) {
   scoped_refptr<AudioBuffer> buffer;
   buffer.swap(reinterpret_cast<AudioBuffer**>(&opaque));
 }
 
 // Called by FFmpeg's allocation routine to allocate a buffer. Uses
 // AVCodecContext.opaque to get the object reference in order to call
 // GetAudioBuffer() to do the actual allocation.
 static int GetAudioBuffer(struct AVCodecContext* s, AVFrame* frame, int flags) {
   DCHECK(s->codec->capabilities & CODEC_CAP_DR1);
   DCHECK_EQ(s->codec_type, AVMEDIA_TYPE_AUDIO);
@@ skipping 45 matching lines @@
   // allocated for AudioBuffer. |number_of_planes| will be 1 for interleaved
   // audio and equal to |channels| for planar audio.
   int number_of_planes = buffer->channel_data().size();
   if (number_of_planes <= AV_NUM_DATA_POINTERS) {
     DCHECK_EQ(frame->extended_data, frame->data);
     for (int i = 0; i < number_of_planes; ++i)
       frame->data[i] = buffer->channel_data()[i];
   } else {
     // There are more channels than can fit into data[], so allocate
     // extended_data[] and fill appropriately.
-    frame->extended_data = static_cast<uint8**>(
+    frame->extended_data = static_cast<uint8_t**>(
         av_malloc(number_of_planes * sizeof(*frame->extended_data)));
     int i = 0;
     for (; i < AV_NUM_DATA_POINTERS; ++i)
       frame->extended_data[i] = frame->data[i] = buffer->channel_data()[i];
     for (; i < number_of_planes; ++i)
       frame->extended_data[i] = buffer->channel_data()[i];
   }
 
   // Now create an AVBufferRef for the data just allocated. It will own the
   // reference to the AudioBuffer object.
@@ skipping 122 matching lines @@
     const scoped_refptr<DecoderBuffer>& buffer,
     bool* has_produced_frame) {
   DCHECK(!*has_produced_frame);
 
   AVPacket packet;
   av_init_packet(&packet);
   if (buffer->end_of_stream()) {
     packet.data = NULL;
     packet.size = 0;
   } else {
-    packet.data = const_cast<uint8*>(buffer->data());
+    packet.data = const_cast<uint8_t*>(buffer->data());
     packet.size = buffer->data_size();
   }
 
   // Each audio packet may contain several frames, so we must call the decoder
   // until we've exhausted the packet.  Regardless of the packet size we always
   // want to hand it to the decoder at least once, otherwise we would end up
   // skipping end of stream packets since they have a size of zero.
   do {
     int frame_decoded = 0;
     const int result = avcodec_decode_audio4(
@@ skipping 120 matching lines @@
   return true;
 }
 
 void FFmpegAudioDecoder::ResetTimestampState() {
   discard_helper_.reset(new AudioDiscardHelper(config_.samples_per_second(),
                                                config_.codec_delay()));
   discard_helper_->Reset(config_.codec_delay());
 }
 
 }  // namespace media