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"
+
+// VP8 is more likely to work on different versions of Chrome. Undefine this
+// to decode H264.
+#define USE_VP8_TESTDATA_INSTEAD_OF_H264
 #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 USE_VP8_TESTDATA_INSTEAD_OF_H264
+
+// 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 = kData[current_pos] + (kData[current_pos + 1] << 8) +
+                        (kData[current_pos + 2] << 16) +
+                        (kData[current_pos + 3] << 24);
+  current_pos += 12;  // Skip frame header.
+  *start_pos = current_pos;
+  *end_pos = current_pos + frame_size;
+}
+
+#else  // !USE_VP8_TESTDATA_INSTEAD_OF_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;
   }
 }
 
+#endif  // USE_VP8_TESTDATA_INSTEAD_OF_H264
+
 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) {
+// TODO(bbudge) Remove this for final patch.
+#if defined USE_VP8_TESTDATA_INSTEAD_OF_H264
+  const PP_VideoProfile kBitstreamProfile = PP_VIDEOPROFILE_VP8MAIN;
+#else
+  const PP_VideoProfile kBitstreamProfile = PP_VIDEOPROFILE_H264MAIN;
+#endif
+
   assert(!decoder_->is_null());
-  const PP_VideoProfile profile = PP_VIDEOPROFILE_H264MAIN;
   decoder_->Initialize(graphics_3d,
-                       profile,
-                       PP_FALSE /* allow_software_fallback */,
+                       kBitstreamProfile,
+                       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++) {
+          if (video_decoders_[i]->decoding())
+            video_decoders_[i]->Reset();
+        }
+      }
+      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