Move H264Parser and H264BitReader to media/filters.

media/filters/h264_parser.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 "content/common/gpu/media/h264_parser.h"
-
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 
-namespace content {
+#include "media/filters/h264_parser.h"
+
+namespace media {
 
 bool H264SliceHeader::IsPSlice() const {
   return (slice_type % 5 == kPSlice);
 }
 
 bool H264SliceHeader::IsBSlice() const {
   return (slice_type % 5 == kBSlice);
 }
 
 bool H264SliceHeader::IsISlice() const {
@@ skipping 21 matching lines @@
 }
 
 H264SliceHeader::H264SliceHeader() {
   memset(this, 0, sizeof(*this));
 }
 
 H264SEIMessage::H264SEIMessage() {
   memset(this, 0, sizeof(*this));
 }
 
-#define READ_BITS_OR_RETURN(num_bits, out)                                    \
-do {                                                                          \
-  int _out;                                                                   \
-  if (!br_.ReadBits(num_bits, &_out)) {                                       \
-    DVLOG(1) << "Error in stream: unexpected EOS while trying to read " #out; \
-    return kInvalidStream;                                                    \
-  }                                                                           \
-  *out = _out;                                                                \
-} while (0)
+#define READ_BITS_OR_RETURN(num_bits, out)                                 \
+  do {                                                                     \
+    int _out;                                                              \
+    if (!br_.ReadBits(num_bits, &_out)) {                                  \
+      DVLOG(1)                                                             \
+          << "Error in stream: unexpected EOS while trying to read " #out; \
+      return kInvalidStream;                                               \
+    }                                                                      \
+    *out = _out;                                                           \
+  } while (0)
 
-#define READ_BOOL_OR_RETURN(out)                                              \
-do {                                                                          \
-  int _out;                                                                   \
-  if (!br_.ReadBits(1, &_out)) {                                              \
-    DVLOG(1) << "Error in stream: unexpected EOS while trying to read " #out; \
-    return kInvalidStream;                                                    \
-  }                                                                           \
-  *out = _out != 0;                                                           \
-} while (0)
+#define READ_BOOL_OR_RETURN(out)                                           \
+  do {                                                                     \
+    int _out;                                                              \
+    if (!br_.ReadBits(1, &_out)) {                                         \
+      DVLOG(1)                                                             \
+          << "Error in stream: unexpected EOS while trying to read " #out; \
+      return kInvalidStream;                                               \
+    }                                                                      \
+    *out = _out != 0;                                                      \
+  } while (0)
 
-#define READ_UE_OR_RETURN(out)                                               \
-do {                                                                         \
-  if (ReadUE(out) != kOk) {                                                  \
-    DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
-    return kInvalidStream;                                                   \
-  }                                                                          \
-} while (0)
+#define READ_UE_OR_RETURN(out)                                                 \
+  do {                                                                         \
+    if (ReadUE(out) != kOk) {                                                  \
+      DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
+      return kInvalidStream;                                                   \
+    }                                                                          \
+  } while (0)
 
-#define READ_SE_OR_RETURN(out)                                               \
-do {                                                                         \
-  if (ReadSE(out) != kOk) {                                                  \
-    DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
-    return kInvalidStream;                                                   \
-  }                                                                          \
-} while (0)
+#define READ_SE_OR_RETURN(out)                                                 \
+  do {                                                                         \
+    if (ReadSE(out) != kOk) {                                                  \
+      DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
+      return kInvalidStream;                                                   \
+    }                                                                          \
+  } while (0)
 
-#define IN_RANGE_OR_RETURN(val, min, max)                                 \
-do {                                                                      \
-  if ((val) < (min) || (val) > (max)) {                                   \
-    DVLOG(1) << "Error in stream: invalid value, expected " #val " to be" \
-             << " in range [" << (min) << ":" << (max) << "]"             \
-             << " found " << (val) << " instead";                         \
-    return kInvalidStream;                                                \
-  }                                                                       \
-} while (0)
+#define IN_RANGE_OR_RETURN(val, min, max)                                   \
+  do {                                                                      \
+    if ((val) < (min) || (val) > (max)) {                                   \
+      DVLOG(1) << "Error in stream: invalid value, expected " #val " to be" \
+               << " in range [" << (min) << ":" << (max) << "]"             \
+               << " found " << (val) << " instead";                         \
+      return kInvalidStream;                                                \
+    }                                                                       \
+  } while (0)
 
-#define TRUE_OR_RETURN(a)                                          \
-do {                                                               \
-  if (!(a)) {                                                      \
-    DVLOG(1) << "Error in stream: invalid value, expected " << #a; \
-    return kInvalidStream;                                         \
-  }                                                                \
-} while (0)
+#define TRUE_OR_RETURN(a)                                            \
+  do {                                                               \
+    if (!(a)) {                                                      \
+      DVLOG(1) << "Error in stream: invalid value, expected " << #a; \
+      return kInvalidStream;                                         \
+    }                                                                \
+  } while (0)
 
 H264Parser::H264Parser() {
   Reset();
 }
 
 H264Parser::~H264Parser() {
   STLDeleteValues(&active_SPSes_);
   STLDeleteValues(&active_PPSes_);
 }
 
@@ skipping 125 matching lines @@
     return res;
 
   if (ue % 2 == 0)
     *val = -(ue / 2);
   else
     *val = ue / 2 + 1;
 
   return kOk;
 }
 
-H264Parser::Result H264Parser::AdvanceToNextNALU(H264NALU *nalu) {
+H264Parser::Result H264Parser::AdvanceToNextNALU(H264NALU* nalu) {
   int data;
   off_t off_to_nalu_start;
 
   if (!LocateNALU(stream_, bytes_left_, &off_to_nalu_start, &nalu->size)) {
     DVLOG(4) << "Could not find next NALU, bytes left in stream: "
              << bytes_left_;
     return kEOStream;
   }
 
   nalu->data = stream_ + off_to_nalu_start;
@@ skipping 22 matching lines @@
   DVLOG(4) << "NALU type: " << static_cast<int>(nalu->nal_unit_type)
            << " at: " << reinterpret_cast<const void*>(nalu->data)
            << " size: " << nalu->size
            << " ref: " << static_cast<int>(nalu->nal_ref_idc);
 
   return kOk;
 }
 
 // Default scaling lists (per spec).
 static const int kDefault4x4Intra[kH264ScalingList4x4Length] = {
-  6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42, };
+    6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42, };
 
 static const int kDefault4x4Inter[kH264ScalingList4x4Length] = {
-  10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34, };
+    10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34, };
 
 static const int kDefault8x8Intra[kH264ScalingList8x8Length] = {
-  6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 23,
-  23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27,
-  27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
-  31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42, };
+    6,  10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 23,
+    23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27,
+    27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
+    31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42, };
 
 static const int kDefault8x8Inter[kH264ScalingList8x8Length] = {
-  9, 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21,
-  21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24,
-  24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27,
-  27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35, };
+    9,  13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21,
+    21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24,
+    24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27,
+    27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35, };
 
 static inline void DefaultScalingList4x4(
     int i,
     int scaling_list4x4[][kH264ScalingList4x4Length]) {
   DCHECK_LT(i, 6);
 
   if (i < 3)
     memcpy(scaling_list4x4[i], kDefault4x4Intra, sizeof(kDefault4x4Intra));
   else if (i < 6)
     memcpy(scaling_list4x4[i], kDefault4x4Inter, sizeof(kDefault4x4Inter));
 }
 
 static inline void DefaultScalingList8x8(
     int i,
     int scaling_list8x8[][kH264ScalingList8x8Length]) {
   DCHECK_LT(i, 6);
 
   if (i % 2 == 0)
     memcpy(scaling_list8x8[i], kDefault8x8Intra, sizeof(kDefault8x8Intra));
   else
     memcpy(scaling_list8x8[i], kDefault8x8Inter, sizeof(kDefault8x8Inter));
 }
 
 static void FallbackScalingList4x4(
     int i,
     const int default_scaling_list_intra[],
     const int default_scaling_list_inter[],
     int scaling_list4x4[][kH264ScalingList4x4Length]) {
-  static const int kScalingList4x4ByteSize = sizeof(scaling_list4x4[0][0]) *
-      kH264ScalingList4x4Length;
+  static const int kScalingList4x4ByteSize =
+      sizeof(scaling_list4x4[0][0]) * kH264ScalingList4x4Length;
 
   switch (i) {
     case 0:
       memcpy(scaling_list4x4[i], default_scaling_list_intra,
              kScalingList4x4ByteSize);
       break;
 
     case 1:
-      memcpy(scaling_list4x4[i], scaling_list4x4[0],
-             kScalingList4x4ByteSize);
+      memcpy(scaling_list4x4[i], scaling_list4x4[0], kScalingList4x4ByteSize);
       break;
 
     case 2:
-      memcpy(scaling_list4x4[i], scaling_list4x4[1],
-             kScalingList4x4ByteSize);
+      memcpy(scaling_list4x4[i], scaling_list4x4[1], kScalingList4x4ByteSize);
       break;
 
     case 3:
       memcpy(scaling_list4x4[i], default_scaling_list_inter,
              kScalingList4x4ByteSize);
       break;
 
     case 4:
-      memcpy(scaling_list4x4[i], scaling_list4x4[3],
-             kScalingList4x4ByteSize);
+      memcpy(scaling_list4x4[i], scaling_list4x4[3], kScalingList4x4ByteSize);
       break;
 
     case 5:
-      memcpy(scaling_list4x4[i], scaling_list4x4[4],
-             kScalingList4x4ByteSize);
+      memcpy(scaling_list4x4[i], scaling_list4x4[4], kScalingList4x4ByteSize);
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 static void FallbackScalingList8x8(
     int i,
     const int default_scaling_list_intra[],
     const int default_scaling_list_inter[],
     int scaling_list8x8[][kH264ScalingList8x8Length]) {
-  static const int kScalingList8x8ByteSize = sizeof(scaling_list8x8[0][0]) *
-      kH264ScalingList8x8Length;
+  static const int kScalingList8x8ByteSize =
+      sizeof(scaling_list8x8[0][0]) * kH264ScalingList8x8Length;
 
   switch (i) {
     case 0:
       memcpy(scaling_list8x8[i], default_scaling_list_intra,
              kScalingList8x8ByteSize);
       break;
 
     case 1:
       memcpy(scaling_list8x8[i], default_scaling_list_inter,
              kScalingList8x8ByteSize);
       break;
 
     case 2:
-      memcpy(scaling_list8x8[i], scaling_list8x8[0],
-             kScalingList8x8ByteSize);
+      memcpy(scaling_list8x8[i], scaling_list8x8[0], kScalingList8x8ByteSize);
       break;
 
     case 3:
-      memcpy(scaling_list8x8[i], scaling_list8x8[1],
-             kScalingList8x8ByteSize);
+      memcpy(scaling_list8x8[i], scaling_list8x8[1], kScalingList8x8ByteSize);
       break;
 
     case 4:
-      memcpy(scaling_list8x8[i], scaling_list8x8[2],
-             kScalingList8x8ByteSize);
+      memcpy(scaling_list8x8[i], scaling_list8x8[2], kScalingList8x8ByteSize);
       break;
 
     case 5:
-      memcpy(scaling_list8x8[i], scaling_list8x8[3],
-             kScalingList8x8ByteSize);
+      memcpy(scaling_list8x8[i], scaling_list8x8[3], kScalingList8x8ByteSize);
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 H264Parser::Result H264Parser::ParseScalingList(int size,
                                                 int* scaling_list,
@@ skipping 29 matching lines @@
   bool seq_scaling_list_present_flag;
   bool use_default;
   Result res;
 
   // Parse scaling_list4x4.
   for (int i = 0; i < 6; ++i) {
     READ_BOOL_OR_RETURN(&seq_scaling_list_present_flag);
 
     if (seq_scaling_list_present_flag) {
       res = ParseScalingList(arraysize(sps->scaling_list4x4[i]),
-                             sps->scaling_list4x4[i], &use_default);
+                             sps->scaling_list4x4[i],
+                             &use_default);
       if (res != kOk)
         return res;
 
       if (use_default)
         DefaultScalingList4x4(i, sps->scaling_list4x4);
 
     } else {
-        FallbackScalingList4x4(i, kDefault4x4Intra, kDefault4x4Inter,
-                               sps->scaling_list4x4);
+      FallbackScalingList4x4(
+          i, kDefault4x4Intra, kDefault4x4Inter, sps->scaling_list4x4);
     }
   }
 
   // Parse scaling_list8x8.
   for (int i = 0; i < ((sps->chroma_format_idc != 3) ? 2 : 6); ++i) {
     READ_BOOL_OR_RETURN(&seq_scaling_list_present_flag);
 
     if (seq_scaling_list_present_flag) {
       res = ParseScalingList(arraysize(sps->scaling_list8x8[i]),
-                             sps->scaling_list8x8[i], &use_default);
+                             sps->scaling_list8x8[i],
+                             &use_default);
       if (res != kOk)
         return res;
 
       if (use_default)
         DefaultScalingList8x8(i, sps->scaling_list8x8);
 
     } else {
-        FallbackScalingList8x8(i, kDefault8x8Intra, kDefault8x8Inter,
-                              sps->scaling_list8x8);
+      FallbackScalingList8x8(
+          i, kDefault8x8Intra, kDefault8x8Inter, sps->scaling_list8x8);
     }
   }
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParsePPSScalingLists(const H264SPS& sps,
                                                     H264PPS* pps) {
   // See 7.4.2.2.
   bool pic_scaling_list_present_flag;
   bool use_default;
   Result res;
 
   for (int i = 0; i < 6; ++i) {
     READ_BOOL_OR_RETURN(&pic_scaling_list_present_flag);
 
     if (pic_scaling_list_present_flag) {
       res = ParseScalingList(arraysize(pps->scaling_list4x4[i]),
-                             pps->scaling_list4x4[i], &use_default);
+                             pps->scaling_list4x4[i],
+                             &use_default);
       if (res != kOk)
         return res;
 
       if (use_default)
         DefaultScalingList4x4(i, pps->scaling_list4x4);
 
     } else {
       if (sps.seq_scaling_matrix_present_flag) {
         // Table 7-2 fallback rule A in spec.
-        FallbackScalingList4x4(i, kDefault4x4Intra, kDefault4x4Inter,
-                               pps->scaling_list4x4);
+        FallbackScalingList4x4(
+            i, kDefault4x4Intra, kDefault4x4Inter, pps->scaling_list4x4);
       } else {
         // Table 7-2 fallback rule B in spec.
-        FallbackScalingList4x4(i, sps.scaling_list4x4[0],
-                               sps.scaling_list4x4[3], pps->scaling_list4x4);
+        FallbackScalingList4x4(i,
+                               sps.scaling_list4x4[0],
+                               sps.scaling_list4x4[3],
+                               pps->scaling_list4x4);
       }
     }
   }
 
   if (pps->transform_8x8_mode_flag) {
     for (int i = 0; i < ((sps.chroma_format_idc != 3) ? 2 : 6); ++i) {
       READ_BOOL_OR_RETURN(&pic_scaling_list_present_flag);
 
       if (pic_scaling_list_present_flag) {
         res = ParseScalingList(arraysize(pps->scaling_list8x8[i]),
-                               pps->scaling_list8x8[i], &use_default);
+                               pps->scaling_list8x8[i],
+                               &use_default);
         if (res != kOk)
           return res;
 
         if (use_default)
           DefaultScalingList8x8(i, pps->scaling_list8x8);
 
       } else {
         if (sps.seq_scaling_matrix_present_flag) {
           // Table 7-2 fallback rule A in spec.
-          FallbackScalingList8x8(i, kDefault8x8Intra,
-                                 kDefault8x8Inter, pps->scaling_list8x8);
+          FallbackScalingList8x8(
+              i, kDefault8x8Intra, kDefault8x8Inter, pps->scaling_list8x8);
         } else {
           // Table 7-2 fallback rule B in spec.
-          FallbackScalingList8x8(i, sps.scaling_list8x8[0],
-                                 sps.scaling_list8x8[1], pps->scaling_list8x8);
+          FallbackScalingList8x8(i,
+                                 sps.scaling_list8x8[0],
+                                 sps.scaling_list8x8[1],
+                                 pps->scaling_list8x8);
         }
       }
     }
   }
   return kOk;
 }
 
 static void FillDefaultSeqScalingLists(H264SPS* sps) {
   for (int i = 0; i < 6; ++i)
     for (int j = 0; j < kH264ScalingList4x4Length; ++j)
@@ skipping 15 matching lines @@
 
   READ_BITS_OR_RETURN(8, &sps->profile_idc);
   READ_BITS_OR_RETURN(6, &sps->constraint_setx_flag);
   READ_BITS_OR_RETURN(2, &data);
   READ_BITS_OR_RETURN(8, &sps->level_idc);
   READ_UE_OR_RETURN(&sps->seq_parameter_set_id);
   TRUE_OR_RETURN(sps->seq_parameter_set_id < 32);
 
   if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
       sps->profile_idc == 122 || sps->profile_idc == 244 ||
-      sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
-      sps->profile_idc ==  86 || sps->profile_idc == 118 ||
+      sps->profile_idc == 44 || sps->profile_idc == 83 ||
+      sps->profile_idc == 86 || sps->profile_idc == 118 ||
       sps->profile_idc == 128) {
     READ_UE_OR_RETURN(&sps->chroma_format_idc);
     TRUE_OR_RETURN(sps->chroma_format_idc < 4);
 
     if (sps->chroma_format_idc == 3)
       READ_BOOL_OR_RETURN(&sps->separate_colour_plane_flag);
 
     READ_UE_OR_RETURN(&sps->bit_depth_luma_minus8);
     TRUE_OR_RETURN(sps->bit_depth_luma_minus8 < 7);
 
@@ skipping 290 matching lines @@
                                 shdr->luma_log2_weight_denom,
                                 shdr->chroma_log2_weight_denom,
                                 &shdr->pred_weight_table_l1);
     if (res != kOk)
       return res;
   }
 
   return kOk;
 }
 
-H264Parser::Result H264Parser::ParseDecRefPicMarking(H264SliceHeader *shdr) {
+H264Parser::Result H264Parser::ParseDecRefPicMarking(H264SliceHeader* shdr) {
   if (shdr->idr_pic_flag) {
     READ_BOOL_OR_RETURN(&shdr->no_output_of_prior_pics_flag);
     READ_BOOL_OR_RETURN(&shdr->long_term_reference_flag);
   } else {
     READ_BOOL_OR_RETURN(&shdr->adaptive_ref_pic_marking_mode_flag);
 
     H264DecRefPicMarking* marking;
     if (shdr->adaptive_ref_pic_marking_mode_flag) {
       size_t i;
       for (i = 0; i < arraysize(shdr->ref_pic_marking); ++i) {
@@ skipping 55 matching lines @@
   TRUE_OR_RETURN(pps);
 
   sps = GetSPS(pps->seq_parameter_set_id);
   TRUE_OR_RETURN(sps);
 
   if (sps->separate_colour_plane_flag) {
     DVLOG(1) << "Interlaced streams not supported";
     return kUnsupportedStream;
   }
 
-  READ_BITS_OR_RETURN(sps->log2_max_frame_num_minus4 + 4,
-                      &shdr->frame_num);
+  READ_BITS_OR_RETURN(sps->log2_max_frame_num_minus4 + 4, &shdr->frame_num);
   if (!sps->frame_mbs_only_flag) {
     READ_BOOL_OR_RETURN(&shdr->field_pic_flag);
     if (shdr->field_pic_flag) {
       DVLOG(1) << "Interlaced streams not supported";
       return kUnsupportedStream;
     }
   }
 
   if (shdr->idr_pic_flag)
     READ_UE_OR_RETURN(&shdr->idr_pic_id);
@@ skipping 58 matching lines @@
     if (res != kOk)
       return res;
   }
 
   if (nalu.nal_ref_idc != 0) {
     res = ParseDecRefPicMarking(shdr);
     if (res != kOk)
       return res;
   }
 
-  if (pps->entropy_coding_mode_flag &&
-      !shdr->IsISlice() && !shdr->IsSISlice()) {
+  if (pps->entropy_coding_mode_flag && !shdr->IsISlice() &&
+      !shdr->IsSISlice()) {
     READ_UE_OR_RETURN(&shdr->cabac_init_idc);
     TRUE_OR_RETURN(shdr->cabac_init_idc < 3);
   }
 
   READ_SE_OR_RETURN(&shdr->slice_qp_delta);
 
   if (shdr->IsSPSlice() || shdr->IsSISlice()) {
     if (shdr->IsSPSlice())
       READ_BOOL_OR_RETURN(&shdr->sp_for_switch_flag);
     READ_SE_OR_RETURN(&shdr->slice_qs_delta);
@@ skipping 43 matching lines @@
   sei_msg->payload_size += byte;
 
   DVLOG(4) << "Found SEI message type: " << sei_msg->type
            << " payload size: " << sei_msg->payload_size;
 
   switch (sei_msg->type) {
     case H264SEIMessage::kSEIRecoveryPoint:
       READ_UE_OR_RETURN(&sei_msg->recovery_point.recovery_frame_cnt);
       READ_BOOL_OR_RETURN(&sei_msg->recovery_point.exact_match_flag);
       READ_BOOL_OR_RETURN(&sei_msg->recovery_point.broken_link_flag);
-      READ_BITS_OR_RETURN(2,
-          &sei_msg->recovery_point.changing_slice_group_idc);
+      READ_BITS_OR_RETURN(2, &sei_msg->recovery_point.changing_slice_group_idc);
       break;
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
-}  // namespace content
+}  // namespace media