Video Capture: extract storage info from pixel format in VideoCaptureFormat.

media/video/capture/fake_video_capture_device.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.
 
 #include "media/video/capture/fake_video_capture_device.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
@@ skipping 84 matching lines @@
       capture_format_.frame_size.SetSize(1920, 1080);
   else if (params.requested_format.frame_size.width() > 640)
       capture_format_.frame_size.SetSize(1280, 720);
   else if (params.requested_format.frame_size.width() > 320)
     capture_format_.frame_size.SetSize(640, 480);
   else
     capture_format_.frame_size.SetSize(320, 240);
 
   if (device_type_ == USING_OWN_BUFFERS ||
       device_type_ == USING_OWN_BUFFERS_TRIPLANAR) {
+    capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
     fake_frame_.reset(new uint8[VideoFrame::AllocationSize(
         VideoFrame::I420, capture_format_.frame_size)]);
     BeepAndScheduleNextCapture(
         base::TimeTicks::Now(),
         base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                    weak_factory_.GetWeakPtr()));
   } else if (device_type_ == USING_CLIENT_BUFFERS_I420 ||
              device_type_ == USING_CLIENT_BUFFERS_GPU) {
     DVLOG(1) << "starting with " << (device_type_ == USING_CLIENT_BUFFERS_I420
                                          ? "Client buffers"
                                          : "GpuMemoryBuffers");
     BeepAndScheduleNextCapture(
         base::TimeTicks::Now(),
         base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
                    weak_factory_.GetWeakPtr(),
                    (device_type_ == USING_CLIENT_BUFFERS_I420
                         ? PIXEL_FORMAT_I420
-                        : PIXEL_FORMAT_GPUMEMORYBUFFER)));
+                        : PIXEL_FORMAT_ARGB),
+                   (device_type_ == USING_CLIENT_BUFFERS_GPU
+                        ? PIXEL_STORAGE_GPUMEMORYBUFFER
+                        : PIXEL_STORAGE_CPU)));
   } else {
     client_->OnError("Unknown Fake Video Capture Device type.");
   }
 }
 
 void FakeVideoCaptureDevice::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_.reset();
 }
 
@@ skipping 29 matching lines @@
         base::TimeTicks::Now());
   }
   BeepAndScheduleNextCapture(
       expected_execution_time,
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     VideoPixelFormat pixel_format,
+    VideoPixelStorage pixel_storage,
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
-      client_->ReserveOutputBuffer(pixel_format, capture_format_.frame_size));
+      client_->ReserveOutputBuffer(capture_format_.frame_size, pixel_format,
+                                   pixel_storage));
   DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
 
   if (capture_buffer.get()) {
     uint8_t* const data_ptr = static_cast<uint8_t*>(capture_buffer->data());
     DCHECK(data_ptr) << "Buffer has NO backing memory";
     DCHECK_EQ(capture_buffer->GetType(), gfx::SHARED_MEMORY_BUFFER);
     memset(data_ptr, 0, capture_buffer->size());
 
-    DrawPacman(
-        (pixel_format == media::PIXEL_FORMAT_GPUMEMORYBUFFER), /* use_argb */
-        data_ptr,
-        frame_count_,
-        kFakeCapturePeriodMs,
-        capture_format_.frame_size);
+    DrawPacman((pixel_format == media::PIXEL_FORMAT_ARGB), /* use_argb */
+               data_ptr,
+               frame_count_,
+               kFakeCapturePeriodMs,
+               capture_format_.frame_size);
 
     // Give the captured frame to the client.
     const VideoCaptureFormat format(capture_format_.frame_size,
                                     capture_format_.frame_rate,
-                                    pixel_format);
+                                    pixel_format,
+                                    pixel_storage);
     client_->OnIncomingCapturedBuffer(capture_buffer.Pass(), format,
                                       base::TimeTicks::Now());
   }
 
   BeepAndScheduleNextCapture(
       expected_execution_time,
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
-                 weak_factory_.GetWeakPtr(), pixel_format));
+                 weak_factory_.GetWeakPtr(), pixel_format, pixel_storage));
 }
 
 void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(
     base::TimeTicks expected_execution_time,
     const base::Callback<void(base::TimeTicks)>& next_capture) {
   // Generate a synchronized beep sound every so many frames.
   if (frame_count_++ % kFakeCaptureBeepCycle == 0)
     FakeAudioInputStream::BeepOnce();
 
   // Reschedule next CaptureTask.
   const base::TimeTicks current_time = base::TimeTicks::Now();
   const base::TimeDelta frame_interval =
       base::TimeDelta::FromMilliseconds(kFakeCapturePeriodMs);
   // Don't accumulate any debt if we are lagging behind - just post the next
   // frame immediately and continue as normal.
   const base::TimeTicks next_execution_time =
       std::max(current_time, expected_execution_time + frame_interval);
   const base::TimeDelta delay = next_execution_time - current_time;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
 }  // namespace media