Add audio buffer size notification to NaCl proxy....

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_audio.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 "native_client/src/shared/ppapi_proxy/plugin_ppb_audio.h"
 
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/errno.h>
 #include <sys/mman.h>
 #include "native_client/src/include/nacl_scoped_ptr.h"
 #include "native_client/src/include/portability.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_globals.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_resource.h"
 #include "native_client/src/shared/ppapi_proxy/utility.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/cpp/module_impl.h"
 #include "srpcgen/ppb_rpc.h"
 #include "srpcgen/ppp_rpc.h"
 
 namespace ppapi_proxy {
 namespace {
 
-// round size up to next 64k
+// Round size up to next 64k; required for NaCl's version of mmap().
 size_t ceil64k(size_t n) {
   return (n + 0xFFFF) & (~0xFFFF);
 }
 
+// The following two functions (TotalSharedMemorySizeInBytes,
+// SetActualDataSizeInBytes) are copied & similar to audio_util.cc.
+
+uint32_t TotalSharedMemorySizeInBytes(size_t packet_size) {
+  // Need to reserve extra 4 bytes for size of data.
+  return ceil64k(packet_size + sizeof(uint32_t));
+}
+
+void SetActualDataSizeInBytes(void* audio_buffer,
+                              uint32_t buffer_size_in_bytes,
+                              uint32_t actual_size_in_bytes) {
+  char* end = static_cast<char*>(audio_buffer) + buffer_size_in_bytes;
+  DCHECK(0 == (reinterpret_cast<size_t>(end) & 3));
+  volatile uint32_t* end32 = reinterpret_cast<volatile uint32_t*>(end);
+  // Set actual data size at the end of the buffer.
+  __sync_synchronize();
+  *end32 = actual_size_in_bytes;
+}
+
 }  // namespace
 
 PluginAudio::PluginAudio() :
     resource_(kInvalidResourceId),
     socket_(-1),
     shm_(-1),
     shm_size_(0),
     shm_buffer_(NULL),
     state_(AUDIO_INCOMPLETE),
     thread_id_(),
     thread_active_(false),
     user_callback_(NULL),
     user_data_(NULL) {
   DebugPrintf("PluginAudio::PluginAudio\n");
 }
 
 PluginAudio::~PluginAudio() {
   DebugPrintf("PluginAudio::~PluginAudio\n");
   // Ensure audio thread is not active.
   if (resource_ != kInvalidResourceId)
     GetInterface()->StopPlayback(resource_);
   // Unmap the shared memory buffer, if present.
   if (shm_buffer_) {
-    munmap(shm_buffer_, ceil64k(shm_size_));
+    munmap(shm_buffer_, TotalSharedMemorySizeInBytes(shm_size_));
     shm_buffer_ = NULL;
     shm_size_ = 0;
   }
   // Close the handles.
   if (shm_ != -1) {
     close(shm_);
     shm_ = -1;
   }
   if (socket_ != -1) {
     close(socket_);
     socket_ = -1;
   }
 }
 
 bool PluginAudio::InitFromBrowserResource(PP_Resource resource) {
   DebugPrintf("PluginAudio::InitFromBrowserResource: resource=%"NACL_PRId32"\n",
               resource);
   resource_ = resource;
   return true;
 }
 
 void PluginAudio::AudioThread(void* self) {
   PluginAudio* audio = static_cast<PluginAudio*>(self);
   DebugPrintf("PluginAudio::AudioThread: self=%p\n", self);
   while (true) {
     int32_t sync_value;
-    // block on socket read
+    // Block on socket read.
     ssize_t r = read(audio->socket_, &sync_value, sizeof(sync_value));
-    // StopPlayback() will send a value of -1 over the sync_socket
+    // StopPlayback() will send a value of -1 over the sync_socket.
     if ((sizeof(sync_value) != r) || (-1 == sync_value))
       break;
-    // invoke user callback, get next buffer of audio data
+    // Invoke user callback, get next buffer of audio data.
     audio->user_callback_(audio->shm_buffer_,
                           audio->shm_size_,
                           audio->user_data_);
+    // Signal audio backend by writing buffer length at end of buffer.
+    // (Note: NaCl applications will always write the entire buffer.)
+    SetActualDataSizeInBytes(audio->shm_buffer_,
+                             audio->shm_size_,
+                             audio->shm_size_);
   }
 }
 
 void PluginAudio::StreamCreated(NaClSrpcImcDescType socket,
       NaClSrpcImcDescType shm, size_t shm_size) {
   DebugPrintf("PluginAudio::StreamCreated: shm=%"NACL_PRIu32""
               " shm_size=%"NACL_PRIuS"\n", shm, shm_size);
   socket_ = socket;
   shm_ = shm;
   shm_size_ = shm_size;
   shm_buffer_ = mmap(NULL,
-                     ceil64k(shm_size),
+                     TotalSharedMemorySizeInBytes(shm_size),
                      PROT_READ | PROT_WRITE,
                      MAP_SHARED,
                      shm,
                      0);
   if (MAP_FAILED != shm_buffer_) {
     if (state() == AUDIO_PENDING) {
       StartAudioThread();
     } else {
       set_state(AUDIO_READY);
     }
@@ skipping 195 matching lines @@
       GetAs<ppapi_proxy::PluginAudio>(audio_resource);
   if (NULL == audio.get()) {
     // Ignore if no audio_resource -> audio_instance mapping exists,
     // the app may have shutdown audio before StreamCreated() invoked.
     rpc->result = NACL_SRPC_RESULT_OK;
     return;
   }
   audio->StreamCreated(sync_socket, shm, shm_size);
   rpc->result = NACL_SRPC_RESULT_OK;
 }