Implement software fallback for PPB_VideoDecoder.

ppapi/examples/video_decode/video_decode.cc

 // Copyright (c) 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 <stdio.h>
 #include <string.h>
 
 #include <iostream>
 #include <queue>
 #include <sstream>
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/cpp/graphics_3d.h"
 #include "ppapi/cpp/graphics_3d_client.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/video_decoder.h"
+
+// One of these should be defined.
+//#define TEST_H264
+#define TEST_VP8

[Ami GONE FROM CHROMIUM, 2014/06/05 00:06:24]

If you made these USE_VP8_TESTDATA_INSTEAD_OF_H264 then:
- you wouldn't have to edit the _dev.cc example
- you wouldn't risk someone defining both, which is invalid
- you woulnd't risk colliding with far-flung defines from other places since
nobody in their right mind would use such an unwieldy macro name.

[bbudge, 2014/06/06 02:03:45]

I like it. Done.

 #include "ppapi/examples/video_decode/testdata.h"
+
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
 #include "ppapi/lib/gl/include/GLES2/gl2ext.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 // Use assert as a poor-man's CHECK, even in non-debug mode.
 // Since <assert.h> redefines assert on every inclusion (it doesn't use
 // include-guards), make sure this is the last file #include'd in this file.
 #undef NDEBUG
 #include <assert.h>
 
@@ skipping 15 matching lines @@
 class MyInstance;
 
 class MyInstance : public pp::Instance, public pp::Graphics3DClient {
  public:
   MyInstance(PP_Instance instance, pp::Module* module);
   virtual ~MyInstance();
 
   // pp::Instance implementation.
   virtual void DidChangeView(const pp::Rect& position,
                              const pp::Rect& clip_ignored);
+  virtual bool HandleInputEvent(const pp::InputEvent& event);
 
   // pp::Graphics3DClient implementation.
   virtual void Graphics3DContextLost() {
     // TODO(vrk/fischman): Properly reset after a lost graphics context.  In
     // particular need to delete context_ and re-create textures.
     // Probably have to recreate the decoder from scratch, because old textures
     // can still be outstanding in the decoder!
     assert(false && "Unexpectedly lost graphics context");
   }
 
@@ skipping 63 matching lines @@
 };
 
 class Decoder {
  public:
   Decoder(MyInstance* instance, int id, const pp::Graphics3D& graphics_3d);
   ~Decoder();
 
   int id() const { return id_; }
   bool decoding() const { return !flushing_ && !resetting_; }
 
-  void Seek(int frame);
+  void Reset();
   void RecyclePicture(const PP_VideoPicture& picture);
 
  private:
   void InitializeDone(int32_t result);
-  void Start(int frame);
+  void Start();
   void DecodeNextFrame();
   void DecodeDone(int32_t result);
   void PictureReady(int32_t result, PP_VideoPicture picture);
   void FlushDone(int32_t result);
   void ResetDone(int32_t result);
 
   MyInstance* instance_;
   int id_;
 
   pp::VideoDecoder* decoder_;
   pp::CompletionCallbackFactory<Decoder> callback_factory_;
 
   size_t encoded_data_next_pos_to_decode_;
   int next_picture_id_;
-  int seek_frame_;
   bool flushing_;
   bool resetting_;
 };
 
+#if defined(TEST_H264)
+
 // Returns true if the current position is at the start of a NAL unit.
 static bool LookingAtNAL(const unsigned char* encoded, size_t pos) {
   // H264 frames start with 0, 0, 0, 1 in our test data.
   return pos + 3 < kDataLen && encoded[pos] == 0 && encoded[pos + 1] == 0 &&
          encoded[pos + 2] == 0 && encoded[pos + 3] == 1;
 }
 
-// Find the start and end of the next frame.
 static void GetNextFrame(size_t* start_pos, size_t* end_pos) {
   assert(LookingAtNAL(kData, *start_pos));
   *end_pos = *start_pos;
   *end_pos += 4;
   while (*end_pos < kDataLen && !LookingAtNAL(kData, *end_pos)) {
     ++*end_pos;
   }
 }
 
+#elif defined(TEST_VP8)  // VP8
+
+// VP8 is stored in an IVF container.
+// Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
+
+static void GetNextFrame(size_t* start_pos, size_t* end_pos) {
+  size_t current_pos = *start_pos;
+  if (current_pos == 0)
+    current_pos = 32;  // Skip stream header.
+  uint32_t frame_size = *reinterpret_cast<const uint32_t*>(&kData[current_pos]);

[Ami GONE FROM CHROMIUM, 2014/06/05 00:06:24]

This is a type-punning violation; please see base/macros.h:bit_cast's commentary
for a description of the problem.
You probably just want to construct the uint32 with bit-shifts and addition,
instead of replicating bit_cast's memcpy strategy.

[bbudge, 2014/06/06 02:03:45]

Done.

+  current_pos += 12;  // Skip frame header.
+  *start_pos = current_pos;
+  *end_pos = current_pos + frame_size;
+}
+
+#endif

[Ami GONE FROM CHROMIUM, 2014/06/05 00:06:24]

#else
#error Oops!

unless you take my suggestion above.

[bbudge, 2014/06/06 02:03:45]

Done.

+
 Decoder::Decoder(MyInstance* instance,
                  int id,
                  const pp::Graphics3D& graphics_3d)
     : instance_(instance),
       id_(id),
       decoder_(new pp::VideoDecoder(instance)),
       callback_factory_(this),
       encoded_data_next_pos_to_decode_(0),
       next_picture_id_(0),
-      seek_frame_(0),
       flushing_(false),
       resetting_(false) {
   assert(!decoder_->is_null());
-  const PP_VideoProfile profile = PP_VIDEOPROFILE_H264MAIN;
+  const PP_VideoProfile profile =
+#if defined(TEST_H264)
+      PP_VIDEOPROFILE_H264MAIN;

[Ami GONE FROM CHROMIUM, 2014/06/05 00:06:24]

This should probably be part of the header file alongside its data.

[bbudge, 2014/06/06 02:03:46]

Done.

+#elif defined(TEST_VP8)
+      PP_VIDEOPROFILE_VP8MAIN;
+#endif
   decoder_->Initialize(graphics_3d,
                        profile,
-                       PP_FALSE /* allow_software_fallback */,
+                       PP_TRUE /* allow_software_fallback */,
                        callback_factory_.NewCallback(&Decoder::InitializeDone));
 }
 
 Decoder::~Decoder() {
   delete decoder_;
 }
 
 void Decoder::InitializeDone(int32_t result) {
   assert(decoder_);
   assert(result == PP_OK);
   assert(decoding());
-  Start(0);
+  Start();
 }
 
-void Decoder::Start(int frame) {
+void Decoder::Start() {
   assert(decoder_);
 
-  // Skip to |frame|.
-  size_t start_pos = 0;
-  size_t end_pos = 0;
-  for (int i = 0; i < frame; i++)
-    GetNextFrame(&start_pos, &end_pos);
-  encoded_data_next_pos_to_decode_ = end_pos;
+  encoded_data_next_pos_to_decode_ = 0;
 
   // Register callback to get the first picture. We call GetPicture again in
   // PictureReady to continuously receive pictures as they're decoded.
   decoder_->GetPicture(
       callback_factory_.NewCallbackWithOutput(&Decoder::PictureReady));
 
   // Start the decode loop.
   DecodeNextFrame();
 }
 
-void Decoder::Seek(int frame) {
+void Decoder::Reset() {
   assert(decoder_);
-  seek_frame_ = frame;
   resetting_ = true;
   decoder_->Reset(callback_factory_.NewCallback(&Decoder::ResetDone));
 }
 
 void Decoder::RecyclePicture(const PP_VideoPicture& picture) {
   assert(decoder_);
   decoder_->RecyclePicture(picture);
 }
 
 void Decoder::DecodeNextFrame() {
@@ skipping 45 matching lines @@
 void Decoder::FlushDone(int32_t result) {
   assert(decoder_);
   assert(result == PP_OK || result == PP_ERROR_ABORTED);
   flushing_ = false;
 }
 
 void Decoder::ResetDone(int32_t result) {
   assert(decoder_);
   assert(result == PP_OK);
   resetting_ = false;
+
+  Start();
 }
 
 MyInstance::MyInstance(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::Graphics3DClient(this),
       is_painting_(false),
       num_frames_rendered_(0),
       first_frame_delivered_ticks_(-1),
       last_swap_request_ticks_(-1),
       swap_ticks_(0),
@@ skipping 34 matching lines @@
     assert(position.size() == plugin_size_);
     return;
   }
   plugin_size_ = position.size();
 
   // Initialize graphics.
   InitGL();
   InitializeDecoders();
 }
 
+bool MyInstance::HandleInputEvent(const pp::InputEvent& event) {
+  switch (event.GetType()) {
+    case PP_INPUTEVENT_TYPE_MOUSEDOWN: {
+      pp::MouseInputEvent mouse_event(event);
+      // Reset all decoders on mouse down.
+      if (mouse_event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_LEFT) {
+        for (size_t i = 0; i < video_decoders_.size(); i++)
+          video_decoders_[i]->Reset();

[Ami GONE FROM CHROMIUM, 2014/06/05 00:06:24]

I'm surprised you don't end up having to pause/cancel any other things like
decode or pictureready waiting.

[bbudge, 2014/06/06 02:03:46]

The example won't call Decode after Reset, since any completed Decodes are
aborted after that.

I did play with clearing pending paints. That causes one decoder to hang. I
think it's because of the way the example paints. It brings up an interesting
question: Are any textures the plugin holds valid after Reset? Looking at the
implementation, the textures are implicitly recycled back to the proxy, but they
remain valid for rendering until the plugin starts calling Decode again.

+      }
+      return true;
+    }
+
+    default:
+      return false;
+  }
+}
+
 void MyInstance::InitializeDecoders() {
   assert(video_decoders_.empty());
   // Create two decoders with ids 0 and 1.
   video_decoders_.push_back(new Decoder(this, 0, *context_));
   video_decoders_.push_back(new Decoder(this, 1, *context_));
 }
 
 void MyInstance::PaintPicture(Decoder* decoder,
                               const PP_VideoPicture& picture) {
   if (first_frame_delivered_ticks_ == -1)
@@ skipping 234 matching lines @@
 };
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 }  // namespace pp