Build AVC decoder configuration record

content/common/gpu/media/mac_video_decode_accelerator.mm

 // 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 "content/common/gpu/media/mac_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #import "base/mac/foundation_util.h"
 #import "base/memory/ref_counted_memory.h"
@@ skipping 77 matching lines @@
           0) != kCGLNoError) {
     DVLOG(1) << "Failed to bind image to texture.";
     return false;
   }
   return glGetError() == GL_NO_ERROR;
 }
 
 MacVideoDecodeAccelerator::MacVideoDecodeAccelerator(
     media::VideoDecodeAccelerator::Client* client)
     : client_(client),
-      cgl_context_(NULL),
-      nalu_len_field_size_(0),
-      did_request_pictures_(false) {
+      cgl_context_(NULL) {
 }
 
 void MacVideoDecodeAccelerator::SetCGLContext(CGLContextObj cgl_context) {
   DCHECK(CalledOnValidThread());
   cgl_context_ = cgl_context;
 }
 
-bool MacVideoDecodeAccelerator::SetConfigInfo(
-    uint32_t frame_width,
-    uint32_t frame_height,
-    const std::vector<uint8_t>& avc_data) {
-  DCHECK(CalledOnValidThread());
-  frame_size_ = gfx::Size(frame_width, frame_height);
-  nalu_len_field_size_ = (avc_data[4] & 0x03) + 1;
-
-  DCHECK(!vda_support_.get());
-  vda_support_ = new gfx::VideoDecodeAccelerationSupport();
-  gfx::VideoDecodeAccelerationSupport::Status status = vda_support_->Create(
-      frame_size_.width(), frame_size_.height(), kCVPixelFormatType_422YpCbCr8,
-      &avc_data.front(), avc_data.size());
-  RETURN_ON_FAILURE(status == gfx::VideoDecodeAccelerationSupport::SUCCESS,
-                    "Creating video decoder failed with error: " << status,
-                    PLATFORM_FAILURE, false);
-  return true;
-}
-
 bool MacVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile) {
   DCHECK(CalledOnValidThread());
 
   IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
   if (!io_surface_support)
     return false;
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &MacVideoDecodeAccelerator::NotifyInitializeDone, this));
   return true;
 }
 
 void MacVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to Decode() during invalid state.", ILLEGAL_STATE,);
 
   base::SharedMemory memory(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(memory.Map(bitstream_buffer.size()),
                     "Failed to SharedMemory::Map().", UNREADABLE_INPUT,);
 
-  size_t buffer_size = bitstream_buffer.size();
-  RETURN_ON_FAILURE(buffer_size > nalu_len_field_size_,
-                    "Bitstream contains invalid data.", INVALID_ARGUMENT,);
-
-  // The decoder can only handle slice types 1-5.
-  const uint8_t* buffer = static_cast<const uint8_t*>(memory.memory());
-  uint8_t nalu_type = buffer[nalu_len_field_size_] & 0x1f;
-  if (nalu_type < 1 || nalu_type > 5) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &MacVideoDecodeAccelerator::NotifyInputBufferRead, this,
-        bitstream_buffer.id()));
-    return;
-  }
-
-  // Keep a ref counted copy of the buffer.
-  std::vector<uint8_t> vbuffer(buffer, buffer + buffer_size);
-  scoped_refptr<base::RefCountedBytes> bytes(
-      base::RefCountedBytes::TakeVector(&vbuffer));
-
-  // Store the buffer size at the beginning of the buffer as the decoder
-  // expects.
-  size_t frame_buffer_size = buffer_size - nalu_len_field_size_;
-  const uint64_t max_frame_buffer_size =
-      (1llu << (nalu_len_field_size_ * 8)) - 1;
-  DCHECK_LE(nalu_len_field_size_, 4u);
-  RETURN_ON_FAILURE(frame_buffer_size <= max_frame_buffer_size,
-                    "Bitstream  buffer is too large.", INVALID_ARGUMENT,);
-  for (size_t i = 0; i < nalu_len_field_size_; ++i) {
-    size_t shift = nalu_len_field_size_ * 8 - (i + 1) * 8;
-    bytes->data()[i] = (frame_buffer_size >> shift) & 0xff;
-  }
-
-  vda_support_->Decode(bytes->front(), bytes->size(),
-                       base::Bind(&MacVideoDecodeAccelerator::OnFrameReady,
-                                  this, bitstream_buffer.id(), bytes));
-
-  if (!did_request_pictures_) {
-    did_request_pictures_ = true;
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &MacVideoDecodeAccelerator::RequestPictures, this));
+  h264_parser_.SetStream(static_cast<const uint8_t*>(memory.memory()),
+                         bitstream_buffer.size());
+  while (true) {
+    content::H264NALU nalu;
+    content::H264Parser::Result result = h264_parser_.AdvanceToNextNALU(&nalu);
+    if (result == content::H264Parser::kEOStream) {
+      client_->NotifyEndOfBitstreamBuffer(bitstream_buffer.id());

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

Isn't this (prematurely) duplicating the NEOBB notification?

[sail, 2012/06/02 21:05:49]

Yea, this code doesn't handle multiple NALUs in a single call to Decode(). I'll
fix this as a part of bug 130355.

+      return;
+    }
+    RETURN_ON_FAILURE(result = content::H264Parser::kOk,

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

Assignment instead of comparison.

[sail, 2012/06/02 21:05:49]

Done.

+                      "Unable to parse bitstream.", UNREADABLE_INPUT,);
+    if (!did_build_config_record_) {
+      bool did_consume_nalu = false;

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

unused

[sail, 2012/06/02 21:05:49]

Done.

+      std::vector<uint8_t> config_record;
+      RETURN_ON_FAILURE(config_record_builder_.ProcessNALU(&h264_parser_, nalu,
+                                                           &config_record),
+                        "Unable to build AVC configuraiton record.",
+                        UNREADABLE_INPUT,);
+      if (!config_record.empty()) {
+        did_build_config_record_ = true;
+        if (!CreateDecoder(config_record))
+          return;
+      }
+      if (did_consume_nalu)
+        continue;

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

unreachable

[sail, 2012/06/02 21:05:49]

Done.

+    }
+    // If the decoder has been created and this is a slice type then pass it
+    // to the decoder.
+    if (vda_support_.get() && nalu.nal_unit_type >= 1 &&
+        nalu.nal_unit_type <= 5) {
+      DecodeNALU(nalu, bitstream_buffer.id());
+    }
   }
 }
 
 void MacVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to AssignPictureBuffers() during invalid state.",

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

This pattern generally is incorrect because of queuing.
For example if the client queues two IPCs and the first errors out, the
component will be in an error state when the second is executed, even though the
client couldn't have retracted it by the time the error was reported.

                     ILLEGAL_STATE,);
   available_pictures_.insert(
       available_pictures_.end(), buffers.begin(), buffers.end());
   SendImages();
 }
 
 void MacVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to ReusePictureBuffe() during invalid state.",
                     ILLEGAL_STATE,);
 
   std::map<int32, UsedPictureInfo>::iterator it =
       used_pictures_.find(picture_buffer_id);
   RETURN_ON_FAILURE(it != used_pictures_.end(),
                     "Missing picture buffer id: " << picture_buffer_id,
                     INVALID_ARGUMENT,);
   UsedPictureInfo info = it->second;
   used_pictures_.erase(it);
   available_pictures_.push_back(info.picture_buffer);
   SendImages();
 }
 
 void MacVideoDecodeAccelerator::Flush() {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

did you mean to s/client_/vda_support_/ (here and elsewhere)?

[sail, 2012/06/02 21:05:49]

Done.

                     "Call to Flush() during invalid state.", ILLEGAL_STATE,);
   vda_support_->Flush(true);
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &MacVideoDecodeAccelerator::NotifyFlushDone, this));
 }
 
 void MacVideoDecodeAccelerator::Reset() {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to Reset() during invalid state.", ILLEGAL_STATE,);
@@ skipping 28 matching lines @@
                     PLATFORM_FAILURE,);
   if (!client_)
     return;
   if (image) {
     DecodedImageInfo info;
     info.image.reset(image, base::mac::RETAIN);
     info.bitstream_buffer_id = bitstream_buffer_id;
     decoded_images_.push_back(info);
     SendImages();
   }
   // TODO(sail): this assumes Decode() is handed a single NALU at a time. Make

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

Isn't this assumption tripped up by the vda_unittest case that feeds multiple
NALUs at once?

[sail, 2012/06/02 21:05:49]

Yea, currently the tests that use multiple NALUs at once don't pass.

   // that assumption go away.
   client_->NotifyEndOfBitstreamBuffer(bitstream_buffer_id);
 }
 
 void MacVideoDecodeAccelerator::SendImages() {
   if (!client_) {
     DCHECK(decoded_images_.empty());
     return;
   }
 
@@ skipping 14 matching lines @@
   }
 }
 
 void MacVideoDecodeAccelerator::StopOnError(
     media::VideoDecodeAccelerator::Error error) {
   if (client_)
     client_->NotifyError(error);
   Destroy();
 }
 
+bool MacVideoDecodeAccelerator::CreateDecoder(
+    const std::vector<uint8_t>& extra_data) {
+  DCHECK(client_);

[Ami GONE FROM CHROMIUM, 2012/05/30 00:07:55]

client_ might be gone if a parse error occurs before the AVC config has been
found.

[sail, 2012/06/02 21:05:49]

The code only sets client_ to NULL using the RETURN_ON_FAILURE macro. This
should mean that we should never make it this far if a parse error occurred.

+  DCHECK(!vda_support_.get());
+
+  vda_support_ = new gfx::VideoDecodeAccelerationSupport();
+  gfx::VideoDecodeAccelerationSupport::Status status = vda_support_->Create(
+      config_record_builder_.coded_width(),
+      config_record_builder_.coded_height(),
+      kCVPixelFormatType_422YpCbCr8,
+      &extra_data[0], extra_data.size());
+  RETURN_ON_FAILURE(status == gfx::VideoDecodeAccelerationSupport::SUCCESS,
+                    "Creating video decoder failed with error: " << status,
+                    PLATFORM_FAILURE, false);
+
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+      &MacVideoDecodeAccelerator::RequestPictures, this));
+  return true;
+}
+
+void MacVideoDecodeAccelerator::DecodeNALU(const content::H264NALU& nalu,
+                                           int32 bitstream_buffer_id) {
+  // Assume the NALU length field size is 4 bytes.
+  const int kNALULengthFieldSize = 4;
+  std::vector<uint8_t> data(kNALULengthFieldSize + nalu.size);
+
+  // Store the buffer size at the beginning of the buffer as the decoder
+  // expects.
+  for (size_t i = 0; i < kNALULengthFieldSize; ++i) {
+    size_t shift = kNALULengthFieldSize * 8 - (i + 1) * 8;
+    data[i] = (nalu.size >> shift) & 0xff;
+  }
+
+  // Copy the NALU data.
+  memcpy(&data[kNALULengthFieldSize], nalu.data, nalu.size);
+
+  // Keep a ref counted copy of the buffer.
+  scoped_refptr<base::RefCountedBytes> bytes(
+      base::RefCountedBytes::TakeVector(&data));
+  vda_support_->Decode(bytes->front(), bytes->size(),
+                       base::Bind(&MacVideoDecodeAccelerator::OnFrameReady,
+                                  this, bitstream_buffer_id, bytes));
+}
+
 void MacVideoDecodeAccelerator::NotifyInitializeDone() {
   if (client_)
     client_->NotifyInitializeDone();
 }
 
 void MacVideoDecodeAccelerator::RequestPictures() {
-  if (client_)
-    client_->ProvidePictureBuffers(kNumPictureBuffers, frame_size_);
+  if (client_) {
+    client_->ProvidePictureBuffers(
+        kNumPictureBuffers,
+        gfx::Size(config_record_builder_.coded_width(),
+                  config_record_builder_.coded_height()));
+  }
 }
 
 void MacVideoDecodeAccelerator::NotifyFlushDone() {
   if (client_)
     client_->NotifyFlushDone();
 }
 
 void MacVideoDecodeAccelerator::NotifyResetDone() {
   decoded_images_.clear();
   if (client_)
@@ skipping 13 matching lines @@
 }
 
 MacVideoDecodeAccelerator::UsedPictureInfo::~UsedPictureInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::DecodedImageInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::~DecodedImageInfo() {
 }