Build AVC decoder configuration record

content/common/gpu/media/mac_video_decode_accelerator.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_MAC_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_MAC_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <CoreVideo/CoreVideo.h>
 #include <map>
 #include <list>
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
+#include "content/common/gpu/media/avc_config_record_builder.h"
+#include "content/common/gpu/media/h264_parser.h"
 #include "media/video/video_decode_accelerator.h"
 
 namespace base {
 class RefCountedBytes;
 }
 namespace gfx {
 class GLContext;
 class VideoDecodeAccelerationSupport;
 }
 
 class GpuCommandBufferStub;
 
 class MacVideoDecodeAccelerator : public media::VideoDecodeAccelerator {
  public:
   // Does not take ownership of |client| which must outlive |*this|.
   MacVideoDecodeAccelerator(media::VideoDecodeAccelerator::Client* client);
 
   // Set the OpenGL context to use.
   void SetGLContext(void* gl_context);
 
-  // Set extra data required to initialize the H.264 video decoder.
-  // TODO(sail): Move this into Initialize.
-  bool SetConfigInfo(uint32_t frame_width,
-                     uint32_t frame_height,
-                     const std::vector<uint8_t>& avc_data);
-
   // media::VideoDecodeAccelerator implementation.
   virtual bool Initialize(media::VideoCodecProfile profile) OVERRIDE;
   virtual void Decode(const media::BitstreamBuffer& bitstream_buffer) OVERRIDE;
   virtual void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) OVERRIDE;
   virtual void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void Flush() OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void Destroy() OVERRIDE;
 
  private:
   virtual ~MacVideoDecodeAccelerator();
 
   // Callback for a completed frame.
   void OnFrameReady(int32 bitstream_buffer_id,
                     scoped_refptr<base::RefCountedBytes> bytes,
                     CVImageBufferRef image,
                     int status);
 
   // Sends available decoded frames to the client.
   void SendImages();
 
   // Calls the client's flush completed callback.
   void NotifyFlushDone();
 
   // Calls the client's reset completed callback.
   void NotifyResetDone();
 
+  // Create the decoder.
+  void CreateDecoder();
+
+  // Send the given NALU to the decoder.
+  void DecodeNALU(const content::H264NALU* nalu,

[Ami GONE FROM CHROMIUM, 2012/05/23 19:41:19]

const* is non-idiomatic in chromium (or google) style.
Switch to const&.

[sail, 2012/05/28 21:45:46]

Done.

+                  int32 bitstream_buffer_id);
+
+
   // To expose client callbacks from VideoDecodeAccelerator.
   Client* client_;
   // C++ wrapper around the Mac VDA API.
   scoped_refptr<gfx::VideoDecodeAccelerationSupport> vda_;
   // Picture buffers that are available for use by the decoder to draw decoded
   // video frames on.
   std::list<media::PictureBuffer> available_pictures_;
 
   // Maps ids to picture buffers that are in use by the client.
   struct PendingPictureInfo {
     PendingPictureInfo(media::PictureBuffer pic);
     ~PendingPictureInfo();
     media::PictureBuffer picture_buffer;
     base::mac::ScopedCFTypeRef<CVImageBufferRef> image;
   };
   std::map<int32, PendingPictureInfo> pending_pictures_;
 
   // List of decoded images waiting to be sent to the client.
   struct DecodedImageInfo {
     DecodedImageInfo();
     ~DecodedImageInfo();
     base::mac::ScopedCFTypeRef<CVImageBufferRef> image;
     int32 bitstream_buffer_id;
   };
   std::list<DecodedImageInfo> decoded_images_;
 
   // The context to use to perform OpenGL operations.
   CGLContextObj cgl_context_;
 
-  // The number of bytes used to store the frame buffer size.
-  size_t nalu_len_field_size_;
+  // Flag to check if AVC decoder configuration record has been built.
+  bool did_build_config_record_;
 
-  // Width of a video frame.
-  uint32_t frame_width_;
-  // Height of a video frame.
-  uint32_t frame_height_;
-  // Flag to check if pictures have been requested from the client.
-  bool did_request_pictures_;
+  // Parser for the H264 stream.
+  content::H264Parser h264_parser_;
+
+  // Utility to build the AVC configuration record.
+  content::AVCConfigRecordBuilder config_record_builder_;
 };
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VIDEO_DECODE_ACCELERATOR_MAC_H_