rendering_helper - Change the layout of the rendering areas.

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 124 matching lines @@
   int height;
   int num_frames;
   int num_fragments;
   int min_fps_render;
   int min_fps_no_render;
   media::VideoCodecProfile profile;
   int reset_after_frame_num;
   std::string data_str;
 };
 
-const gfx::Size kThumbnailsDisplaySize(1366, 768);
 const gfx::Size kThumbnailsPageSize(1600, 1200);
 const gfx::Size kThumbnailSize(160, 120);
 const int kMD5StringLength = 32;
 
 // Read in golden MD5s for the thumbnailed rendering of this video
 void ReadGoldenThumbnailMD5s(const TestVideoFile* video_file,
                              std::vector<std::string>* md5_strings) {
   base::FilePath filepath(video_file->file_name);
   filepath = filepath.AddExtension(FILE_PATH_LITERAL(".md5"));
   std::string all_md5s;
@@ skipping 51 matching lines @@
   // Destroy()'d and deleted and can take values: N<0: delete after -N Decode()
   // calls have been made, N>=0 means interpret as ClientState.
   // Both |reset_after_frame_num| & |delete_decoder_state| apply only to the
   // last play-through (governed by |num_play_throughs|).
   // |suppress_rendering| indicates GL rendering is supressed or not.
   // After |delay_reuse_after_frame_num| frame has been delivered, the client
   // will start delaying the call to ReusePictureBuffer() for kReuseDelay.
   // |decode_calls_per_second| is the number of VDA::Decode calls per second.
   // If |decode_calls_per_second| > 0, |num_in_flight_decodes| must be 1.
   GLRenderingVDAClient(RenderingHelper* rendering_helper,
-                       int rendering_window_id,
                        ClientStateNotification<ClientState>* note,
                        const std::string& encoded_data,
                        int num_in_flight_decodes,
                        int num_play_throughs,
                        int reset_after_frame_num,
                        int delete_decoder_state,
                        int frame_width,
                        int frame_height,
                        media::VideoCodecProfile profile,
                        bool suppress_rendering,
@@ skipping 11 matching lines @@
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   // Simple state changes.
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id) OVERRIDE;
   virtual void NotifyFlushDone() OVERRIDE;
   virtual void NotifyResetDone() OVERRIDE;
   virtual void NotifyError(VideoDecodeAccelerator::Error error) OVERRIDE;
 
   // RenderingHelper::Client implementation.
   virtual void RenderContent(RenderingHelper*) OVERRIDE;
+  virtual const gfx::Size& GetWindowSize() OVERRIDE;
 
   void OutputFrameDeliveryTimes(base::File* output);
 
   void NotifyFrameDropped(int32 picture_buffer_id);
 
   // Simple getters for inspecting the state of the Client.
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_skipped_fragments() { return num_skipped_fragments_; }
   int num_queued_fragments() { return num_queued_fragments_; }
   int num_decoded_frames() { return num_decoded_frames_; }
@@ skipping 21 matching lines @@
   std::string GetBytesForNextFragment(size_t start_pos, size_t* end_pos);
   // Helpers for GetBytesForNextFragment above.
   void GetBytesForNextNALU(size_t start_pos, size_t* end_pos);  // For h.264.
   std::string GetBytesForNextFrame(
       size_t start_pos, size_t* end_pos);  // For VP8.
 
   // Request decode of the next fragment in the encoded data.
   void DecodeNextFragment();
 
   RenderingHelper* rendering_helper_;
-  int rendering_window_id_;
+  gfx::Size frame_size_;
   std::string encoded_data_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification<ClientState>* note_;
   scoped_ptr<VideoDecodeAccelerator> decoder_;
   scoped_ptr<base::WeakPtrFactory<VideoDecodeAccelerator> >
       weak_decoder_factory_;
   std::set<int> outstanding_texture_ids_;
@@ skipping 20 matching lines @@
   int decode_calls_per_second_;
   bool render_as_thumbnails_;
   bool pending_picture_updated_;
   std::deque<int32> pending_picture_buffer_ids_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(GLRenderingVDAClient);
 };
 
 GLRenderingVDAClient::GLRenderingVDAClient(
     RenderingHelper* rendering_helper,
-    int rendering_window_id,
     ClientStateNotification<ClientState>* note,
     const std::string& encoded_data,
     int num_in_flight_decodes,
     int num_play_throughs,
     int reset_after_frame_num,
     int delete_decoder_state,
     int frame_width,
     int frame_height,
     media::VideoCodecProfile profile,
     bool suppress_rendering,
     int delay_reuse_after_frame_num,
     int decode_calls_per_second,
     bool render_as_thumbnails)
     : rendering_helper_(rendering_helper),
-      rendering_window_id_(rendering_window_id),
+      frame_size_(frame_width, frame_height),
       encoded_data_(encoded_data),
       num_in_flight_decodes_(num_in_flight_decodes),
       outstanding_decodes_(0),
       encoded_data_next_pos_to_decode_(0),
       next_bitstream_buffer_id_(0),
       note_(note),
       remaining_play_throughs_(num_play_throughs),
       reset_after_frame_num_(reset_after_frame_num),
       delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
@@ skipping 76 matching lines @@
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
 
   texture_target_ = texture_target;
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     uint32 id = picture_buffers_by_id_.size();
     uint32 texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(
-        rendering_window_id_, texture_target_, &texture_id, &done);
+        texture_target_, &texture_id, dimensions, &done);
     done.Wait();
     CHECK(outstanding_texture_ids_.insert(texture_id).second);
     media::PictureBuffer* buffer =
         new media::PictureBuffer(id, dimensions, texture_id);
     CHECK(picture_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
     buffers.push_back(*buffer);
   }
   decoder_->AssignPictureBuffers(buffers);
 }
 
@@ skipping 32 matching lines @@
                                    picture_buffer->texture_id());
 
   if (pending_picture_buffer_ids_.size() == 1) {
     pending_picture_updated_ = false;
   } else {
     pending_picture_buffer_ids_.pop_front();
     ReturnPicture(buffer_id);
   }
 }
 
+const gfx::Size& GLRenderingVDAClient::GetWindowSize() {
+  return render_as_thumbnails_ ? kThumbnailsPageSize : frame_size_;
+}
+
 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;
 
   base::TimeTicks now = base::TimeTicks::Now();
   // Save the decode time of this picture.
   std::map<int, base::TimeTicks>::iterator it =
@@ skipping 588 matching lines @@
 
   // Suppress GL rendering for all tests when the "--rendering_fps" is 0.
   const bool suppress_rendering = g_rendering_fps == 0;
 
   std::vector<ClientStateNotification<ClientState>*>
       notes(num_concurrent_decoders, NULL);
   std::vector<GLRenderingVDAClient*> clients(num_concurrent_decoders, NULL);
 
   RenderingHelperParams helper_params;
   helper_params.rendering_fps = g_rendering_fps;
-  helper_params.num_windows = num_concurrent_decoders;
   helper_params.render_as_thumbnails = render_as_thumbnails;
   if (render_as_thumbnails) {
     // Only one decoder is supported with thumbnail rendering
     CHECK_EQ(num_concurrent_decoders, 1U);
-    gfx::Size frame_size(test_video_files_[0]->width,
-                         test_video_files_[0]->height);
-    helper_params.frame_dimensions.push_back(frame_size);
-    helper_params.window_dimensions.push_back(kThumbnailsDisplaySize);
     helper_params.thumbnails_page_size = kThumbnailsPageSize;
     helper_params.thumbnail_size = kThumbnailSize;
-  } else {
-    for (size_t index = 0; index < test_video_files_.size(); ++index) {
-      gfx::Size frame_size(test_video_files_[index]->width,
-                           test_video_files_[index]->height);
-      helper_params.frame_dimensions.push_back(frame_size);
-      helper_params.window_dimensions.push_back(frame_size);
-    }
   }
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     TestVideoFile* video_file =
         test_video_files_[index % test_video_files_.size()];
     ClientStateNotification<ClientState>* note =
         new ClientStateNotification<ClientState>();
     notes[index] = note;
 
     int delay_after_frame_num = std::numeric_limits<int>::max();
     if (test_reuse_delay &&
         kMaxFramesToDelayReuse * 2 < video_file->num_frames) {
       delay_after_frame_num = video_file->num_frames - kMaxFramesToDelayReuse;
     }
 
     GLRenderingVDAClient* client =
         new GLRenderingVDAClient(&rendering_helper_,
-                                 index,
                                  note,
                                  video_file->data_str,
                                  num_in_flight_decodes,
                                  num_play_throughs,
                                  video_file->reset_after_frame_num,
                                  delete_decoder_state,
                                  video_file->width,
                                  video_file->height,
                                  video_file->profile,
                                  suppress_rendering,
@@ skipping 223 matching lines @@
     ::testing::Values(
         MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true)));
 
 // Measure the median of the decode time when VDA::Decode is called 30 times per
 // second.
 TEST_F(VideoDecodeAcceleratorTest, TestDecodeTimeMedian) {
   RenderingHelperParams helper_params;
 
   // Disable rendering by setting the rendering_fps = 0.
   helper_params.rendering_fps = 0;
-  helper_params.num_windows = 1;
   helper_params.render_as_thumbnails = false;
-  gfx::Size frame_size(test_video_files_[0]->width,
-                       test_video_files_[0]->height);
-  helper_params.frame_dimensions.push_back(frame_size);
-  helper_params.window_dimensions.push_back(frame_size);
 
   ClientStateNotification<ClientState>* note =
       new ClientStateNotification<ClientState>();
   GLRenderingVDAClient* client =
       new GLRenderingVDAClient(&rendering_helper_,
-                               0,
                                note,
                                test_video_files_[0]->data_str,
                                1,
                                1,
                                test_video_files_[0]->reset_after_frame_num,
                                CS_RESET,
                                test_video_files_[0]->width,
                                test_video_files_[0]->height,
                                test_video_files_[0]->profile,
                                true,
@@ skipping 66 matching lines @@
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 
   return RUN_ALL_TESTS();
 }