Move H264Parser and H264BitReader to media/filters.

media/filters/h264_parser.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.
 //
 // This file contains an implementation of an H264 Annex-B video stream parser.
 
-#ifndef CONTENT_COMMON_GPU_MEDIA_H264_PARSER_H_
-#define CONTENT_COMMON_GPU_MEDIA_H264_PARSER_H_
+#ifndef MEDIA_FILTERS_H264_PARSER_H_
+#define MEDIA_FILTERS_H264_PARSER_H_
 
 #include <sys/types.h>
 
 #include <map>
 
 #include "base/basictypes.h"
-#include "content/common/content_export.h"
-#include "content/common/gpu/media/h264_bit_reader.h"
+#include "media/base/media_export.h"
+#include "media/filters/h264_bit_reader.h"
 
-namespace content {
+namespace media {
 
 // For explanations of each struct and its members, see H.264 specification
 // at http://www.itu.int/rec/T-REC-H.264.
-struct CONTENT_EXPORT H264NALU {
+struct MEDIA_EXPORT H264NALU {
   H264NALU();
 
   enum Type {
     kUnspecified = 0,
     kNonIDRSlice = 1,
     kIDRSlice = 5,
     kSEIMessage = 6,
     kSPS = 7,
     kPPS = 8,
     kEOSeq = 9,
     kEOStream = 11,
     kCodedSliceExtension = 20,
   };
 
   // After (without) start code; we don't own the underlying memory
   // and a shallow copy should be made when copying this struct.
   const uint8* data;
   off_t size;  // From after start code to start code of next NALU (or EOS).
 
   int nal_ref_idc;
   int nal_unit_type;
 };
 
-enum { kH264ScalingList4x4Length = 16, kH264ScalingList8x8Length = 64, };
+enum {
+  kH264ScalingList4x4Length = 16,
+  kH264ScalingList8x8Length = 64,
+};
 
-struct CONTENT_EXPORT H264SPS {
+struct MEDIA_EXPORT H264SPS {
   H264SPS();
 
   int profile_idc;
   int constraint_setx_flag;
   int level_idc;
   int seq_parameter_set_id;
 
   int chroma_format_idc;
   bool separate_colour_plane_flag;
   int bit_depth_luma_minus8;
   int bit_depth_chroma_minus8;
   bool qpprime_y_zero_transform_bypass_flag;
 
   bool seq_scaling_matrix_present_flag;
   int scaling_list4x4[6][kH264ScalingList4x4Length];
   int scaling_list8x8[6][kH264ScalingList8x8Length];
 
   int log2_max_frame_num_minus4;
   int pic_order_cnt_type;
   int log2_max_pic_order_cnt_lsb_minus4;
   bool delta_pic_order_always_zero_flag;
   int offset_for_non_ref_pic;
   int offset_for_top_to_bottom_field;
   int num_ref_frames_in_pic_order_cnt_cycle;
-  int expected_delta_per_pic_order_cnt_cycle; // calculated
+  int expected_delta_per_pic_order_cnt_cycle;  // calculated
   int offset_for_ref_frame[255];
   int max_num_ref_frames;
   bool gaps_in_frame_num_value_allowed_flag;
   int pic_width_in_mbs_minus1;
   int pic_height_in_map_units_minus1;
   bool frame_mbs_only_flag;
   bool mb_adaptive_frame_field_flag;
   bool direct_8x8_inference_flag;
   bool frame_cropping_flag;
   int frame_crop_left_offset;
   int frame_crop_right_offset;
   int frame_crop_top_offset;
   int frame_crop_bottom_offset;
   bool vui_parameters_present_flag;
   int chroma_array_type;
 };
 
-struct CONTENT_EXPORT H264PPS {
+struct MEDIA_EXPORT H264PPS {
   H264PPS();
 
   int pic_parameter_set_id;
   int seq_parameter_set_id;
   bool entropy_coding_mode_flag;
   bool bottom_field_pic_order_in_frame_present_flag;
   int num_slice_groups_minus1;
   // TODO(posciak): Slice groups not implemented, could be added at some point.
   int num_ref_idx_l0_default_active_minus1;
   int num_ref_idx_l1_default_active_minus1;
   bool weighted_pred_flag;
   int weighted_bipred_idc;
   int pic_init_qp_minus26;
   int pic_init_qs_minus26;
   int chroma_qp_index_offset;
   bool deblocking_filter_control_present_flag;
   bool constrained_intra_pred_flag;
   bool redundant_pic_cnt_present_flag;
   bool transform_8x8_mode_flag;
 
   bool pic_scaling_matrix_present_flag;
   int scaling_list4x4[6][kH264ScalingList4x4Length];
   int scaling_list8x8[6][kH264ScalingList8x8Length];
 
   int second_chroma_qp_index_offset;
 };
 
-struct CONTENT_EXPORT H264ModificationOfPicNum {
+struct MEDIA_EXPORT H264ModificationOfPicNum {
   int modification_of_pic_nums_idc;
   union {
     int abs_diff_pic_num_minus1;
     int long_term_pic_num;
   };
 };
 
-struct CONTENT_EXPORT H264WeightingFactors {
+struct MEDIA_EXPORT H264WeightingFactors {
   bool luma_weight_flag;
   bool chroma_weight_flag;
   int luma_weight[32];
   int luma_offset[32];
   int chroma_weight[32][2];
   int chroma_offset[32][2];
 };
 
-struct CONTENT_EXPORT H264DecRefPicMarking {
+struct MEDIA_EXPORT H264DecRefPicMarking {
   int memory_mgmnt_control_operation;
   int difference_of_pic_nums_minus1;
   int long_term_pic_num;
   int long_term_frame_idx;
   int max_long_term_frame_idx_plus1;
 };
 
-struct CONTENT_EXPORT H264SliceHeader {
+struct MEDIA_EXPORT H264SliceHeader {
   H264SliceHeader();
 
   enum {
     kRefListSize = 32,
     kRefListModSize = kRefListSize
   };
 
   enum Type {
     kPSlice = 0,
     kBSlice = 1,
     kISlice = 2,
     kSPSlice = 3,
     kSISlice = 4,
   };
 
   bool IsPSlice() const;
   bool IsBSlice() const;
   bool IsISlice() const;
   bool IsSPSlice() const;
   bool IsSISlice() const;
 
-  bool idr_pic_flag;  // from NAL header
-  int nal_ref_idc;  // from NAL header
+  bool idr_pic_flag;       // from NAL header
+  int nal_ref_idc;         // from NAL header
   const uint8* nalu_data;  // from NAL header
-  off_t nalu_size;  // from NAL header
-  off_t header_bit_size;  // calculated
+  off_t nalu_size;         // from NAL header
+  off_t header_bit_size;   // calculated
 
   int first_mb_in_slice;
   int slice_type;
   int pic_parameter_set_id;
   int colour_plane_id;  // TODO(posciak): use this!  http://crbug.com/139878
   int frame_num;
   bool field_pic_flag;
   bool bottom_field_flag;
   int idr_pic_id;
   int pic_order_cnt_lsb;
@@ skipping 36 matching lines @@
   int slice_beta_offset_div2;
 };
 
 struct H264SEIRecoveryPoint {
   int recovery_frame_cnt;
   bool exact_match_flag;
   bool broken_link_flag;
   int changing_slice_group_idc;
 };
 
-struct CONTENT_EXPORT H264SEIMessage {
+struct MEDIA_EXPORT H264SEIMessage {
   H264SEIMessage();
 
   enum Type {
     kSEIRecoveryPoint = 6,
   };
 
   int type;
   int payload_size;
   union {
     // Placeholder; in future more supported types will contribute to more
     // union members here.
     H264SEIRecoveryPoint recovery_point;
   };
 };
 
 // Class to parse an Annex-B H.264 stream,
 // as specified in chapters 7 and Annex B of the H.264 spec.
-class CONTENT_EXPORT H264Parser {
+class MEDIA_EXPORT H264Parser {
  public:
   enum Result {
     kOk,
-    kInvalidStream,     // error in stream
-    kUnsupportedStream, // stream not supported by the parser
-    kEOStream,          // end of stream
+    kInvalidStream,      // error in stream
+    kUnsupportedStream,  // stream not supported by the parser
+    kEOStream,           // end of stream
   };
 
   H264Parser();
   ~H264Parser();
 
   void Reset();
   // Set current stream pointer to |stream| of |stream_size| in bytes,
   // |stream| owned by caller.
   void SetStream(const uint8* stream, off_t stream_size);
 
@@ skipping 62 matching lines @@
   Result ParsePredWeightTable(const H264SPS& sps, H264SliceHeader* shdr);
 
   // Parse weighting factors (see spec).
   Result ParseWeightingFactors(int num_ref_idx_active_minus1,
                                int chroma_array_type,
                                int luma_log2_weight_denom,
                                int chroma_log2_weight_denom,
                                H264WeightingFactors* w_facts);
 
   // Parse decoded reference picture marking information (see spec).
-  Result ParseDecRefPicMarking(H264SliceHeader *shdr);
+  Result ParseDecRefPicMarking(H264SliceHeader* shdr);
 
   // Pointer to the current NALU in the stream.
   const uint8* stream_;
 
   // Bytes left in the stream after the current NALU.
   off_t bytes_left_;
 
   H264BitReader br_;
 
   // PPSes and SPSes stored for future reference.
   typedef std::map<int, H264SPS*> SPSById;
   typedef std::map<int, H264PPS*> PPSById;
   SPSById active_SPSes_;
   PPSById active_PPSes_;
 
   DISALLOW_COPY_AND_ASSIGN(H264Parser);
 };
 
-}  // namespace content
+}  // namespace media
 
-#endif  // CONTENT_COMMON_GPU_MEDIA_H264_PARSER_H_
+#endif  // MEDIA_FILTERS_H264_PARSER_H_