Change ppapi_simple to support pixel format selection.

native_client_sdk/src/examples/demo/earth/earth.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 42 matching lines @@
 int start_tv_retv = gettimeofday(&start_tv, NULL);
 
 inline double getseconds() {
   const double usec_to_sec = 0.000001;
   timeval tv;
   if ((0 == start_tv_retv) && (0 == gettimeofday(&tv, NULL)))
     return (tv.tv_sec - start_tv.tv_sec) + tv.tv_usec * usec_to_sec;
   return 0.0;
 }
 
-// RGBA helper functions.
+// RGBA helper functions, used for extracting color from RGBA source image.
 inline float ExtractR(uint32_t c) {
   return static_cast<float>(c & 0xFF) * kOneOver255;
 }
 
 inline float ExtractG(uint32_t c) {
   return static_cast<float>((c & 0xFF00) >> 8) * kOneOver255;
 }
 
 inline float ExtractB(uint32_t c) {
   return static_cast<float>((c & 0xFF0000) >> 16) * kOneOver255;
 }
 
-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));
 }
 
 // simple container for earth texture
 struct Texture {
   int width, height;
   uint32_t* pixels;
   Texture(int w, int h) : width(w), height(h) {
     pixels = new uint32_t[w * h];
     memset(pixels, 0, sizeof(uint32_t) * w * h);
@@ skipping 259 matching lines @@
 
 
 Planet::Planet() : base_tex_(NULL), night_tex_(NULL), num_threads_(0),
     benchmarking_(false), benchmark_frame_counter_(0) {
 
   Reset();
   RequestTextures();
   // 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);
 }
 
 Planet::~Planet() {
   delete workers_;
   PSContext2DFree(ps_context_);
 }
 
 // Given a region r, derive a rectangle.
 // This rectangle shouldn't overlap with work being done by other workers.
 // If multithreading, this function is only called by the worker threads.
 void Planet::wMakeRect(int r, int *x, int *y, int *w, int *h) {
   *x = 0;
   *w = ps_context_->width;
   *y = r;
   *h = 1;
 }
 
 
 inline uint32_t* Planet::wGetAddr(int x, int y) {
   return ps_context_->data + x + y * ps_context_->stride / sizeof(uint32_t);
 }
 
 // This is the meat of the ray tracer.  Given a pixel span (x0, x1) on
 // scanline y, shoot rays into the scene and render what they hit.  Use
 // scanline coherence to do a few optimizations
 void Planet::wRenderPixelSpan(int x0, int x1, int y) {
   if (!base_tex_ || !night_tex_)
     return;
-  const int kColorBlack = MakeRGBA(0, 0, 0, 0xFF);
+  const int kColorBlack = MakeBGRA(0, 0, 0, 0xFF);
   float width = ps_context_->width;
   float height = ps_context_->height;
   float min_dim = width < height ? width : height;
   float offset_x = width < height ? 0 : (width - min_dim) * 0.5f;
   float offset_y = width < height ? (height - min_dim) * 0.5f : 0;
   float y0 = eye_y_;
   float z0 = eye_z_;
   float y1 = (static_cast<float>(y - offset_y) / min_dim) * 2.0f - 1.0f;
   float z1 = 0.0f;
   float dy = (y1 - y0);
@@ skipping 92 matching lines @@
     uint32_t night_texel = night_tex_->pixels[noffset];
     float nr = ExtractR(night_texel);
     float ng = ExtractG(night_texel);
     float nb = ExtractB(night_texel);
 
     // Final color value is lerp between day and night texels.
     unsigned int ir = Clamp255(pr * tr + nr * ipr);
     unsigned int ig = Clamp255(pg * tg + ng * ipg);
     unsigned int ib = Clamp255(pb * tb + nb * ipb);
 
-    unsigned int color = MakeRGBA(ir, ig, ib, 0xFF);
+    unsigned int color = MakeBGRA(ib, ig, ir, 0xFF);
 
     *pixels = color;
     ++pixels;
   }
 }
 
 // Renders a rectangular area of the screen, scan line at a time
 void Planet::wRenderRect(int x, int y, int w, int h) {
   for (int j = y; j < (y + h); ++j) {
     this->wRenderPixelSpan(x, x + w - 1, j);
@@ skipping 280 matching lines @@
     // Do simulation, render and present.
     earth.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);