Experimental patch for MediaCodec APIs.

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
 #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 88 matching lines @@
   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;
 }
+#endif
 
 // Find the start and end of the next frame.
 static void GetNextFrame(size_t* start_pos, size_t* end_pos) {
+#if defined(TEST_H264)
   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 is stored in an IVF container.
+  // Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
+  if (*start_pos == 0)
+    *start_pos = 32;  // Skip IVF header.
+  uint32_t frame_size = *reinterpret_cast<const uint32_t*>(&kData[*start_pos]);
+  *start_pos += 12;  // Skip frame header.
+  *end_pos = *start_pos + frame_size;
+#endif
 }
 
 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;
+#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);
 }
 
 void Decoder::Start(int frame) {
   assert(decoder_);
 
   // Skip to |frame|.
   size_t start_pos = 0;
   size_t end_pos = 0;
-  for (int i = 0; i < frame; i++)
+  for (int i = 0; i < frame; i++) {
     GetNextFrame(&start_pos, &end_pos);
+    start_pos = end_pos;
+  }
   encoded_data_next_pos_to_decode_ = end_pos;
+  printf("encoded_data_next_pos_to_decode_=%i\n", (int)encoded_data_next_pos_to_decode_);
 
   // 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();
 }
 
@@ skipping 49 matching lines @@
   // Break out of the get picture loop on abort.
   if (result == PP_ERROR_ABORTED)
     return;
   assert(result == PP_OK);
   decoder_->GetPicture(
       callback_factory_.NewCallbackWithOutput(&Decoder::PictureReady));
   instance_->PaintPicture(this, picture);
 }
 
 void Decoder::FlushDone(int32_t result) {
+  printf("FlushDone:result=%i\n", result);
   assert(decoder_);
   assert(result == PP_OK || result == PP_ERROR_ABORTED);
   flushing_ = false;
 }
 
 void Decoder::ResetDone(int32_t result) {
+  printf("ResetDone:result=%i\n", result);
   assert(decoder_);
   assert(result == PP_OK);
   resetting_ = false;
+
+  Start(seek_frame_);
 }
 
 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 and restart video at a point proportional to the
+      // mouse's horiziontal offset from the left edge of the plugin area.
+      if (mouse_event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_LEFT) {
+        pp::Point mouse_position = mouse_event.GetPosition();
+        const int num_frames = 300;  // TODO figure out real number of frames.
+        int frame =
+            (float)mouse_position.x() / plugin_size_.width() * num_frames;
+        for (size_t i = 0; i < video_decoders_.size(); i++) {
+          video_decoders_[i]->Seek(frame);
+        }
+        printf("Seeking:frame=%i\n", frame);
+      }
+      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