Move H264Parser and H264BitReader to media/filters.

content/common/gpu/media/v4l2_video_decode_accelerator.cc

 // Copyright 2014 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 <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <libdrm/drm_fourcc.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
-#include "content/common/gpu/media/h264_parser.h"
 #include "content/common/gpu/media/v4l2_video_decode_accelerator.h"
+#include "media/filters/h264_parser.h"
 #include "ui/gl/scoped_binders.h"
 
 namespace content {
 
 #define NOTIFY_ERROR(x)                                               \
   do {                                                                \
     SetDecoderState(kError);                                          \
     DLOG(ERROR) << "calling NotifyError(): " << x;                    \
     NotifyError(x);                                                   \
   } while (0)
@@ skipping 290 matching lines @@
 
   // Subscribe to the resolution change event.
   struct v4l2_event_subscription sub;
   memset(&sub, 0, sizeof(sub));
   sub.type = V4L2_EVENT_RESOLUTION_CHANGE;
   IOCTL_OR_ERROR_RETURN_FALSE(fd_, VIDIOC_SUBSCRIBE_EVENT, &sub);
 
   // Initialize format-specific bits.
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
-    decoder_h264_parser_.reset(new content::H264Parser());
+    decoder_h264_parser_.reset(new media::H264Parser());
   }
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): decoder thread failed to start";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
 
   SetDecoderState(kInitialized);
 
@@ skipping 301 matching lines @@
 
 bool V4L2VideoDecodeAccelerator::AdvanceFrameFragment(
     const uint8* data,
     size_t size,
     size_t* endpos) {
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     // For H264, we need to feed HW one frame at a time.  This is going to take
     // some parsing of our input stream.
     decoder_h264_parser_->SetStream(data, size);
-    content::H264NALU nalu;
-    content::H264Parser::Result result;
+    media::H264NALU nalu;
+    media::H264Parser::Result result;
     *endpos = 0;
 
     // Keep on peeking the next NALs while they don't indicate a frame
     // boundary.
     for (;;) {
       bool end_of_frame = false;
       result = decoder_h264_parser_->AdvanceToNextNALU(&nalu);
-      if (result == content::H264Parser::kInvalidStream ||
-          result == content::H264Parser::kUnsupportedStream)
+      if (result == media::H264Parser::kInvalidStream ||
+          result == media::H264Parser::kUnsupportedStream)
         return false;
-      if (result == content::H264Parser::kEOStream) {
+      if (result == media::H264Parser::kEOStream) {
         // We've reached the end of the buffer before finding a frame boundary.
         decoder_partial_frame_pending_ = true;
         return true;
       }
       switch (nalu.nal_unit_type) {
-        case content::H264NALU::kNonIDRSlice:
-        case content::H264NALU::kIDRSlice:
+        case media::H264NALU::kNonIDRSlice:
+        case media::H264NALU::kIDRSlice:
           if (nalu.size < 1)
             return false;
           // For these two, if the "first_mb_in_slice" field is zero, start a
           // new frame and return.  This field is Exp-Golomb coded starting on
           // the eighth data bit of the NAL; a zero value is encoded with a
           // leading '1' bit in the byte, which we can detect as the byte being
           // (unsigned) greater than or equal to 0x80.
           if (nalu.data[1] >= 0x80) {
             end_of_frame = true;
             break;
           }
           break;
-        case content::H264NALU::kSPS:
-        case content::H264NALU::kPPS:
-        case content::H264NALU::kEOSeq:
-        case content::H264NALU::kEOStream:
+        case media::H264NALU::kSPS:
+        case media::H264NALU::kPPS:
+        case media::H264NALU::kEOSeq:
+        case media::H264NALU::kEOStream:
           // These unconditionally signal a frame boundary.
           end_of_frame = true;
           break;
         default:
           // For all others, keep going.
           break;
       }
       if (end_of_frame) {
         if (!decoder_partial_frame_pending_ && *endpos == 0) {
           // The frame was previously restarted, and we haven't filled the
@@ skipping 707 matching lines @@
 
   // We might have received a resolution change event while we were waiting
   // for the reset to finish. The codec will not post another event if the
   // resolution after reset remains the same as the one to which were just
   // about to switch, so preserve the event across reset so we can address
   // it after resuming.
 
   // Reset format-specific bits.
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
-    decoder_h264_parser_.reset(new content::H264Parser());
+    decoder_h264_parser_.reset(new media::H264Parser());
   }
 
   // Jobs drained, we're finished resetting.
   DCHECK_EQ(decoder_state_, kResetting);
   decoder_state_ = kAfterReset;
   decoder_partial_frame_pending_ = false;
   decoder_delay_bitstream_buffer_id_ = -1;
   child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &Client::NotifyResetDone, client_));
 
@@ skipping 555 matching lines @@
 
 void V4L2VideoDecodeAccelerator::PictureCleared() {
   DVLOG(3) << "PictureCleared(). clearing count=" << picture_clearing_count_;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_GT(picture_clearing_count_, 0);
   picture_clearing_count_--;
   SendPictureReady();
 }
 
 }  // namespace content