media/filters/h264_to_annex_b_bitstream_converter.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_FILTERS_H264_TO_ANNEX_B_BITSTREAM_CONVERTER_H_
   6 #define MEDIA_FILTERS_H264_TO_ANNEX_B_BITSTREAM_CONVERTER_H_
   7
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "media/base/media_export.h"
  12
  13 namespace media {
  14
  15 namespace mp4 {
  16 struct AVCDecoderConfigurationRecord;
  17 }
  18
  19 // H264ToAnnexBBitstreamConverter is a class to convert H.264 bitstream from
  20 // MP4 format (as specified in ISO/IEC 14496-15) into H.264 bytestream
  21 // (as specified in ISO/IEC 14496-10 Annex B).
  22 class MEDIA_EXPORT H264ToAnnexBBitstreamConverter {
  23  public:
  24   H264ToAnnexBBitstreamConverter();
  25   ~H264ToAnnexBBitstreamConverter();
  26
  27   // Parses the global AVCDecoderConfigurationRecord from the file format's
  28   // headers. Converter will remember the field length from the configuration
  29   // headers after this.
  30   //
  31   // Parameters
  32   //   configuration_record
  33   //     Pointer to buffer containing AVCDecoderConfigurationRecord.
  34   //   configuration_record_size
  35   //     Size of the buffer in bytes.
  36   //   avc_config
  37   //     Pointer to place the parsed AVCDecoderConfigurationRecord data into.
  38   //
  39   // Returns
  40   //   Returns true if |configuration_record| was successfully parsed. False
  41   //   is returned if a parsing error occurred.
  42   //   |avc_config| only contains valid data when true is returned.
  43   bool ParseConfiguration(
  44       const uint8* configuration_record,
  45       int configuration_record_size,
  46       mp4::AVCDecoderConfigurationRecord* avc_config);
  47
  48   // Returns the buffer size needed to store the parameter sets in |avc_config|
  49   // in Annex B form.
  50   uint32 GetConfigSize(
  51       const mp4::AVCDecoderConfigurationRecord& avc_config) const;
  52
  53   // Calculates needed buffer size for the bitstream converted into bytestream.
  54   // Lightweight implementation that does not do the actual conversion.
  55   //
  56   // Parameters
  57   //   input
  58   //     Pointer to buffer containing NAL units in MP4 format.
  59   //   input_size
  60   //     Size of the buffer in bytes.
  61   //   avc_config
  62   //     The AVCDecoderConfigurationRecord that contains the parameter sets that
  63   //     will be inserted into the output. NULL if no parameter sets need to be
  64   //     inserted.
  65   //
  66   // Returns
  67   //   Required buffer size for the output NAL unit buffer when converted
  68   //   to bytestream format, or 0 if could not determine the size of
  69   //   the output buffer from the data in |input| and |avc_config|.
  70   uint32 CalculateNeededOutputBufferSize(
  71       const uint8* input,
  72       uint32 input_size,
  73       const mp4::AVCDecoderConfigurationRecord* avc_config) const;
  74
  75   // ConvertAVCDecoderConfigToByteStream converts the
  76   // AVCDecoderConfigurationRecord from the MP4 headers to bytestream format.
  77   // Client is responsible for making sure the output buffer is large enough
  78   // to hold the output data. Client can precalculate the needed output buffer
  79   // size by using GetConfigSize().
  80   //
  81   // Parameters
  82   //   avc_config
  83   //     The AVCDecoderConfigurationRecord that contains the parameter sets that
  84   //     will be written to |output|.
  85   //   output
  86   //     Pointer to buffer where the output should be written to.
  87   //   output_size (i/o)
  88   //     Pointer to the size of the output buffer. Will contain the number of
  89   //     bytes written to output after successful call.
  90   //
  91   // Returns
  92   //    true  if successful conversion|
  93   //    false if conversion not successful (|output_size| will hold the amount
  94   //          of converted data)
  95   bool ConvertAVCDecoderConfigToByteStream(
  96       const mp4::AVCDecoderConfigurationRecord& avc_config,
  97       uint8* output,
  98       uint32* output_size);
  99
 100   // ConvertNalUnitStreamToByteStream converts the NAL unit from MP4 format
 101   // to bytestream format. Client is responsible for making sure the output
 102   // buffer is large enough to hold the output data. Client can precalculate the
 103   // needed output buffer size by using CalculateNeededOutputBufferSize.
 104   //
 105   // Parameters
 106   //   input
 107   //     Pointer to buffer containing NAL units in MP4 format.
 108   //   input_size
 109   //     Size of the buffer in bytes.
 110   //   avc_config
 111   //     The AVCDecoderConfigurationRecord that contains the parameter sets to
 112   //     insert into the output. NULL if no parameter sets need to be inserted.
 113   //   output
 114   //     Pointer to buffer where the output should be written to.
 115   //   output_size (i/o)
 116   //     Pointer to the size of the output buffer. Will contain the number of
 117   //     bytes written to output after successful call.
 118   //
 119   // Returns
 120   //    true  if successful conversion
 121   //    false if conversion not successful (output_size will hold the amount
 122   //          of converted data)
 123   bool ConvertNalUnitStreamToByteStream(
 124       const uint8* input,
 125       uint32 input_size,
 126       const mp4::AVCDecoderConfigurationRecord* avc_config,
 127       uint8* output,
 128       uint32* output_size);
 129
 130  private:
 131   // Writes Annex B start code and |param_set| to |*out|.
 132   //  |*out| - Is the memory location to write the parameter set.
 133   //  |*out_size| - Number of bytes available for the parameter set.
 134   // Returns true if the start code and param set were successfully
 135   // written. On a successful write, |*out| is updated to point to the first
 136   // byte after the data that was written. |*out_size| is updated to reflect
 137   // the new number of bytes left in |*out|.
 138   bool WriteParamSet(const std::vector<uint8>& param_set,
 139                      uint8** out,
 140                      uint32* out_size) const;
 141
 142   // Flag for indicating whether global parameter sets have been processed.
 143   bool configuration_processed_;
 144   // Flag for indicating whether next NAL unit starts new access unit.
 145   bool first_nal_unit_in_access_unit_;
 146   // Variable to hold interleaving field's length in bytes.
 147   uint8 nal_unit_length_field_width_;
 148
 149   DISALLOW_COPY_AND_ASSIGN(H264ToAnnexBBitstreamConverter);
 150 };
 151
 152 }  // namespace media
 153
 154 #endif  // MEDIA_FILTERS_H264_TO_ANNEX_B_BITSTREAM_CONVERTER_H_