Strip IVF headers from VP8 streams before sending them to the OMX decoder.

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 221 matching lines @@
   bool decoder_deleted() { return !decoder_.get(); }
 
  private:
   typedef std::map<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
 
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
 
-  // Compute & return in |*end_pos| the end position for the next batch of
-  // fragments to ship to the decoder (based on |start_pos| &
-  // |num_fragments_per_decode_|).
-  void GetRangeForNextFragments(size_t start_pos, size_t* end_pos);
+  // Compute & return the next encoded bytes to send to the decoder (based on
+  // |start_pos| & |num_fragments_per_decode_|).
+  std::string GetBytesForNextFragments(size_t start_pos, size_t* end_pos);
   // Helpers for GetRangeForNextFragments above.
-  void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);  // For h.264.
-  void GetRangeForNextFrames(size_t start_pos, size_t* end_pos);  // For VP8.
+  void GetBytesForNextNALUs(size_t start_pos, size_t* end_pos);  // For h.264.
+  std::string GetBytesForNextFrames(
+      size_t start_pos, size_t* end_pos);  // For VP8.
 
   // Request decode of the next batch of fragments in the encoded data.
   void DecodeNextFragments();
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
   std::string encoded_data_;
   const int num_fragments_per_decode_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
@@ skipping 126 matching lines @@
 }
 
 void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   CHECK_LT(state_, CS_RESET);
 
   if (decoder_deleted())
     return;
   last_frame_delivered_ticks_ = base::TimeTicks::Now();
 
-  // Because we feed the decoder a limited number of fragments at a time, we can
-  // be sure that the bitstream buffer from which a frame comes has a limited
-  // range.  Assert that.

[Ami GONE FROM CHROMIUM, 2012/07/25 22:41:15]

More crack removal.  This logic relied on the decoder never needing to buffer
input packets past their input bitstream buffer, but that's silly.

-  CHECK_GE((picture.bitstream_buffer_id() + 1) * num_fragments_per_decode_,
-           num_decoded_frames_);
   CHECK_LE(picture.bitstream_buffer_id(), next_bitstream_buffer_id_);
   ++num_decoded_frames_;
 
   // Mid-stream reset applies only to the last play-through per constructor
   // comment.
   if (remaining_play_throughs_ == 1 &&
       reset_after_frame_num_ == num_decoded_frames_) {
     reset_after_frame_num_ = MID_STREAM_RESET;
     decoder_->Reset();
     // Re-start decoding from the beginning of the stream to avoid needing to
@@ skipping 88 matching lines @@
   for (std::set<int>::iterator it = outstanding_texture_ids_.begin();
        it != outstanding_texture_ids_.end(); ++it) {
     rendering_helper_->DeleteTexture(*it);
   }
   outstanding_texture_ids_.clear();
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
 
-void GLRenderingVDAClient::GetRangeForNextFragments(
+std::string GLRenderingVDAClient::GetBytesForNextFragments(
     size_t start_pos, size_t* end_pos) {
   if (profile_ < media::H264PROFILE_MAX) {
-    GetRangeForNextNALUs(start_pos, end_pos);
-    return;
+    GetBytesForNextNALUs(start_pos, end_pos);
+    return encoded_data_.substr(start_pos, *end_pos - start_pos);
   }
   DCHECK_LE(profile_, media::VP8PROFILE_MAX);
-  GetRangeForNextFrames(start_pos, end_pos);
+  return GetBytesForNextFrames(start_pos, end_pos);
 }
 
-void GLRenderingVDAClient::GetRangeForNextNALUs(
+void GLRenderingVDAClient::GetBytesForNextNALUs(
     size_t start_pos, size_t* end_pos) {
   *end_pos = start_pos;
   CHECK(LookingAtNAL(encoded_data_, start_pos));
   for (int i = 0; i < num_fragments_per_decode_; ++i) {
     *end_pos += 4;
     while (*end_pos + 3 < encoded_data_.size() &&
            !LookingAtNAL(encoded_data_, *end_pos)) {
       ++*end_pos;
     }
     if (*end_pos + 3 >= encoded_data_.size()) {
       *end_pos = encoded_data_.size();
       return;
     }
   }
 }
 
-void GLRenderingVDAClient::GetRangeForNextFrames(
+std::string GLRenderingVDAClient::GetBytesForNextFrames(
     size_t start_pos, size_t* end_pos) {
   // Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
+  std::string bytes;
+  if (start_pos == 0)
+    start_pos = 32;  // Skip IVF header.
   *end_pos = start_pos;
-  if (start_pos == 0)
-    *end_pos = 32;
   for (int i = 0; i < num_fragments_per_decode_; ++i) {
     uint32 frame_size = *reinterpret_cast<uint32*>(&encoded_data_[*end_pos]);
     *end_pos += 12;  // Skip frame header.
+    bytes.append(encoded_data_.substr(*end_pos, *end_pos + frame_size));
     *end_pos += frame_size;
     if (*end_pos + 12 >= encoded_data_.size())
-      return;
+      return bytes;
   }
+  return bytes;
 }
 
 void GLRenderingVDAClient::DecodeNextFragments() {
   if (decoder_deleted())
     return;
   if (encoded_data_next_pos_to_decode_ == encoded_data_.size()) {
     if (outstanding_decodes_ == 0) {
       decoder_->Flush();
       SetState(CS_FLUSHING);
     }
     return;
   }
-  size_t start_pos = encoded_data_next_pos_to_decode_;
   size_t end_pos;
-  GetRangeForNextFragments(start_pos, &end_pos);
+  std::string next_fragment_bytes =
+      GetBytesForNextFragments(encoded_data_next_pos_to_decode_, &end_pos);
+  size_t next_fragment_size = next_fragment_bytes.size();
 
   // Populate the shared memory buffer w/ the fragments, duplicate its handle,
   // and hand it off to the decoder.
   base::SharedMemory shm;
-  CHECK(shm.CreateAndMapAnonymous(end_pos - start_pos))
-      << start_pos << ", " << end_pos;
-  memcpy(shm.memory(), encoded_data_.data() + start_pos, end_pos - start_pos);
+  CHECK(shm.CreateAndMapAnonymous(next_fragment_size));
+  memcpy(shm.memory(), next_fragment_bytes.data(), next_fragment_size);
   base::SharedMemoryHandle dup_handle;
   CHECK(shm.ShareToProcess(base::Process::Current().handle(), &dup_handle));
   media::BitstreamBuffer bitstream_buffer(
-      next_bitstream_buffer_id_++, dup_handle, end_pos - start_pos);
+      next_bitstream_buffer_id_++, dup_handle, next_fragment_size);
   decoder_->Decode(bitstream_buffer);
   ++outstanding_decodes_;
   encoded_data_next_pos_to_decode_ = end_pos;
 
   if (!remaining_play_throughs_ &&
       -delete_decoder_state_ == next_bitstream_buffer_id_) {
     DeleteDecoder();
   }
 }
 
@@ skipping 307 matching lines @@
 
   base::ShadowingAtExitManager at_exit_manager;
   RenderingHelper::InitializePlatform();
 
 #if defined(OS_WIN)
   DXVAVideoDecodeAccelerator::PreSandboxInitialization();
 #endif
 
   return RUN_ALL_TESTS();
 }