Video Color Managament

media/video/gpu_memory_buffer_video_frame_pool.cc

 // Copyright 2015 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/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <list>
 #include <memory>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/containers/stack_container.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/video_color_space.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gl/trace_util.h"
 
 namespace media {
 
 // Implementation of a pool of GpuMemoryBuffers used to back VideoFrames.
 class GpuMemoryBufferVideoFramePool::PoolImpl
     : public base::RefCountedThreadSafe<
@@ skipping 394 matching lines @@
   return true;
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::OnCopiesDone(
     const scoped_refptr<VideoFrame>& video_frame,
     FrameResources* frame_resources,
     const FrameReadyCB& frame_ready_cb) {
   for (const auto& plane_resource : frame_resources->plane_resources) {
     if (plane_resource.gpu_memory_buffer)
       plane_resource.gpu_memory_buffer->Unmap();
   }

[ccameron, 2016/07/21 18:38:13]

At this point we would call

plane_resource.gpu_memory_buffer->SetColorSpace(/* the color space from the
frame */)

That would go all the way down to the IOSurface for CALayer overlays.

[hubbe, 2016/07/21 19:05:30]

Are you suggesting that we don't set the color space on the video frame? If so,
what happens in those cases when we can't use a gpu memory buffer?

 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PoolImpl::BindAndCreateMailboxesHardwareFrameResources, this,
                  video_frame, frame_resources, frame_ready_cb));
 }
 
 // Copies |video_frame| into |frame_resources| asynchronously, posting n tasks
 // that will be synchronized by a barrier.
 // After the barrier is passed OnCopiesDone will be called.
@@ skipping 141 matching lines @@
       frame_format, mailbox_holders, release_mailbox_callback, coded_size,
       gfx::Rect(visible_size), video_frame->natural_size(),
       video_frame->timestamp());
 
   if (!frame) {
     release_mailbox_callback.Run(gpu::SyncToken());
     frame_ready_cb.Run(video_frame);
     return;
   }
 
+  VideoColorSpace video_color_space(video_frame);
+  video_color_space.SetVideoFrameColorSpace(frame);
+
   bool allow_overlay = false;
   switch (output_format_) {
     case PIXEL_FORMAT_I420:
       allow_overlay =
           video_frame->metadata()->IsTrue(VideoFrameMetadata::ALLOW_OVERLAY);
       break;
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_UYVY:
       allow_overlay = true;
       break;
@@ skipping 143 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media