Revert of 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 Reset();
+  void Seek(int frame);
   void RecyclePicture(const PP_VideoPicture& picture);
 
  private:
   void InitializeDone(int32_t result);
-  void Start();
+  void Start(int frame);
   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,
-                       kBitstreamProfile,
-                       PP_TRUE /* allow_software_fallback */,
+                       profile,
+                       PP_FALSE /* 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();
+  Start(0);
 }
 
-void Decoder::Start() {
+void Decoder::Start(int frame) {
   assert(decoder_);
 
-  encoded_data_next_pos_to_decode_ = 0;
+  // 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;
 
   // 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::Reset() {
+void Decoder::Seek(int frame) {
   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