[PPAPI] Pepper MediaStream API audio track implementation and example.

ppapi/proxy/audio_frame_resource.cc

 // Copyright 2014 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 "ppapi/proxy/video_frame_resource.h"
+#include "ppapi/proxy/audio_frame_resource.h"
 
-#include "base/logging.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 namespace proxy {
 
-VideoFrameResource::VideoFrameResource(PP_Instance instance,
+AudioFrameResource::AudioFrameResource(PP_Instance instance,
                                        int32_t index,
                                        MediaStreamFrame* frame)
     : Resource(OBJECT_IS_PROXY, instance),
       index_(index),
       frame_(frame) {
-  DCHECK_EQ(frame_->header.type, MediaStreamFrame::TYPE_VIDEO);
+  DCHECK_EQ(frame_->header.type, MediaStreamFrame::TYPE_AUDIO);
 }
 
-VideoFrameResource::~VideoFrameResource() {
+AudioFrameResource::~AudioFrameResource() {
   CHECK(!frame_) << "An unused (or unrecycled) frame is destroyed.";
 }
 
-thunk::PPB_VideoFrame_API* VideoFrameResource::AsPPB_VideoFrame_API() {
+thunk::PPB_AudioFrame_API* AudioFrameResource::AsPPB_AudioFrame_API() {
   return this;
 }
 
-PP_TimeDelta VideoFrameResource::GetTimestamp() {
+PP_TimeDelta AudioFrameResource::GetTimestamp() {
   if (!frame_) {
     VLOG(1) << "Frame is invalid";
     return 0.0;
   }
-  return frame_->video.timestamp;
+  return frame_->audio.timestamp;
 }
 
-void VideoFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
+void AudioFrameResource::SetTimestamp(PP_TimeDelta timestamp) {
   if (!frame_) {
     VLOG(1) << "Frame is invalid";
     return;
   }
-  frame_->video.timestamp = timestamp;
+  frame_->audio.timestamp = timestamp;
 }
 
-PP_VideoFrame_Format VideoFrameResource::GetFormat() {
+PP_AudioSampleRate AudioFrameResource::GetSampleRate() {
   if (!frame_) {
     VLOG(1) << "Frame is invalid";
-    return PP_VIDEOFRAME_FORMAT_UNKNOWN;
+    return PP_AUDIOSAMPLERATE_NONE;
   }
-  return frame_->video.format;
+  return frame_->audio.sample_rate;
 }
 
-PP_Bool VideoFrameResource::GetSize(PP_Size* size) {
+uint32_t AudioFrameResource::GetSampleSize() {
   if (!frame_) {
     VLOG(1) << "Frame is invalid";
-    return PP_FALSE;
+    return 0;
   }
-  *size = frame_->video.size;
-  return PP_TRUE;
+  return 2;
 }
 
-void* VideoFrameResource::GetDataBuffer() {
+uint32_t AudioFrameResource::GetNumberOfChannels() {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return 0;
+  }
+  return frame_->audio.number_of_channels;
+}
+
+uint32_t AudioFrameResource::GetNumberOfSamples() {
+  if (!frame_) {
+    VLOG(1) << "Frame is invalid";
+    return 0;
+  }
+  return frame_->audio.number_of_samples;
+}
+
+void* AudioFrameResource::GetDataBuffer() {
   if (!frame_) {
     VLOG(1) << "Frame is invalid";
     return NULL;
   }
-  return frame_->video.data;
+  return frame_->audio.data;
 }
 
-uint32_t VideoFrameResource::GetDataBufferSize() {
+uint32_t AudioFrameResource::GetDataBufferSize() {
   if (!frame_) {
     VLOG(1) << "Frame is invalid";
     return 0;
   }
-  return frame_->video.data_size;
+  return frame_->audio.data_size;
 }
 
-MediaStreamFrame* VideoFrameResource::GetFrameBuffer() {
+MediaStreamFrame* AudioFrameResource::GetFrameBuffer() {
   return frame_;
 }
 
-int32_t VideoFrameResource::GetFrameBufferIndex() {
+int32_t AudioFrameResource::GetFrameBufferIndex() {
   return index_;
 }
 
-void VideoFrameResource::Invalidate() {
+void AudioFrameResource::Invalidate() {
   DCHECK(frame_);
   DCHECK_GE(index_, 0);
   frame_ = NULL;
   index_ = -1;
 }
 
 }  // namespace proxy
 }  // namespace ppapi