Merge 217400 "Change ppapi_simple to support pixel format select..."

native_client_sdk/src/examples/demo/voronoi/voronoi.cc

 // Copyright (c) 2013 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 <assert.h>
 #include <math.h>
 #include <ppapi/c/ppb_input_event.h>
 #include <ppapi/cpp/input_event.h>
 #include <ppapi/cpp/var.h>
 #include <ppapi/cpp/var_array.h>
@@ skipping 55 matching lines @@
 }
 
 inline double getseconds() {
   const double usec_to_sec = 0.000001;
   timeval tv;
   if (0 == gettimeofday(&tv, NULL))
     return tv.tv_sec + tv.tv_usec * usec_to_sec;
   return 0.0;
 }
 
-inline uint32_t MakeRGBA(uint32_t r, uint32_t g, uint32_t b, uint32_t a) {
+// BGRA helper function, for constructing a pixel for a BGRA buffer.
+inline uint32_t MakeBGRA(uint32_t b, uint32_t g, uint32_t r, uint32_t a) {
   return (((a) << 24) | ((r) << 16) | ((g) << 8) | (b));
 }
 }  // namespace
 
 // Vec2, simple 2D vector
 struct Vec2 {
   float x, y;
   Vec2() {}
   Vec2(float px, float py) {
     x = px;
@@ skipping 68 matching lines @@
     // random initial start position
     const float x = frand();
     const float y = frand();
     positions_[i].Set(x, y);
     // random directional velocity ( -1..1, -1..1 )
     const float speed = 0.0005f;
     const float u = (frand() * 2.0f - 1.0f) * speed;
     const float v = (frand() * 2.0f - 1.0f) * speed;
     velocities_[i].Set(u, v);
     // 'unique' color (well... unique enough for our purposes)
-    colors_[i] = MakeRGBA(rand255(), rand255(), rand255(), 255);
+    colors_[i] = MakeBGRA(rand255(), rand255(), rand255(), 255);
   }
 }
 
 Voronoi::Voronoi() : num_regions_(kDefaultNumRegions), num_threads_(0),
     point_count_(kStartPointCount), draw_points_(true), draw_interiors_(true),
     benchmark_frame_counter_(0), benchmarking_(false)  {
   Reset();
   // By default, render from the dispatch thread.
   workers_ = new ThreadPool(num_threads_);
   PSEventSetFilter(PSE_ALL);
-  ps_context_ = PSContext2DAllocate();
+  ps_context_ = PSContext2DAllocate(PP_IMAGEDATAFORMAT_BGRA_PREMUL);
 }
 
 Voronoi::~Voronoi() {
   delete workers_;
   PSContext2DFree(ps_context_);
 }
 
 inline uint32_t* Voronoi::wGetAddr(int x, int y) {
   return ps_context_->data + x + y * ps_context_->stride / sizeof(uint32_t);
 }
@@ skipping 49 matching lines @@
   // all 4 corners belong to the same cell
   *m = m0;
   return true;
 }
 
 // Quickly fill a span of pixels with a solid color.  Assumes
 // span width is divisible by 4.
 // If multithreading, this function is only called by the worker threads.
 inline void Voronoi::wFillSpan(uint32_t* pixels, uint32_t color, int width) {
   if (!draw_interiors_) {
-    const uint32_t gray = MakeRGBA(128, 128, 128, 255);
+    const uint32_t gray = MakeBGRA(128, 128, 128, 255);
     color = gray;
   }
   for (int i = 0; i < width; i += 4) {
     *pixels++ = color;
     *pixels++ = color;
     *pixels++ = color;
     *pixels++ = color;
   }
 }
 
@@ skipping 130 matching lines @@
   // render dot as a small diamond
   *pixel = color1;
   *(pixel - 1) = color2;
   *(pixel + 1) = color2;
   *(pixel - stride_in_pixels) = color2;
   *(pixel + stride_in_pixels) = color2;
 }
 
 // Superimposes dots on the positions.
 void Voronoi::SuperimposePositions() {
-  const uint32_t white = MakeRGBA(255, 255, 255, 255);
-  const uint32_t gray = MakeRGBA(192, 192, 192, 255);
+  const uint32_t white = MakeBGRA(255, 255, 255, 255);
+  const uint32_t gray = MakeBGRA(192, 192, 192, 255);
   for (int i = 0; i < point_count_; i++) {
     RenderDot(
         screen_positions_[i].x, screen_positions_[i].y, white, gray);
   }
 }
 
 // Renders the Voronoi diagram, dispatching the work to multiple threads.
 void Voronoi::Render() {
   workers_->Dispatch(num_regions_, wRenderRegionEntry, this);
   if (draw_points_)
@@ skipping 106 matching lines @@
     // Do simulation, render and present.
     voronoi.Update();
   }
 
   return 0;
 }
 
 // Register the function to call once the Instance Object is initialized.
 // see: pappi_simple/ps_main.h
 PPAPI_SIMPLE_REGISTER_MAIN(example_main);