mpeg1_audio_stream_parser.cc 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261
  1. // Copyright 2014 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. #include "media/formats/mpeg/mpeg1_audio_stream_parser.h"
  5. #include "media/base/media_log.h"
  6. namespace media {
  7. namespace {
  8. constexpr uint32_t kMPEG1StartCodeMask = 0xffe00000;
  9. // Maps version and layer information in the frame header
  10. // into an index for the |kBitrateMap|.
  11. // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
  12. constexpr int kVersionLayerMap[4][4] = {
  13. // { reserved, L3, L2, L1 }
  14. {5, 4, 4, 3}, // MPEG 2.5
  15. {5, 5, 5, 5}, // reserved
  16. {5, 4, 4, 3}, // MPEG 2
  17. {5, 2, 1, 0} // MPEG 1
  18. };
  19. // Maps the bitrate index field in the header and an index
  20. // from |kVersionLayerMap| to a frame bitrate.
  21. // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
  22. constexpr int kBitrateMap[16][6] = {
  23. // { V1L1, V1L2, V1L3, V2L1, V2L2 & V2L3, reserved }
  24. {0, 0, 0, 0, 0, 0}, {32, 32, 32, 32, 8, 0},
  25. {64, 48, 40, 48, 16, 0}, {96, 56, 48, 56, 24, 0},
  26. {128, 64, 56, 64, 32, 0}, {160, 80, 64, 80, 40, 0},
  27. {192, 96, 80, 96, 48, 0}, {224, 112, 96, 112, 56, 0},
  28. {256, 128, 112, 128, 64, 0}, {288, 160, 128, 144, 80, 0},
  29. {320, 192, 160, 160, 96, 0}, {352, 224, 192, 176, 112, 0},
  30. {384, 256, 224, 192, 128, 0}, {416, 320, 256, 224, 144, 0},
  31. {448, 384, 320, 256, 160, 0}, {0, 0, 0, 0, 0}};
  32. // Maps the sample rate index and version fields from the frame header
  33. // to a sample rate.
  34. // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
  35. constexpr int kSampleRateMap[4][4] = {
  36. // { V2.5, reserved, V2, V1 }
  37. {11025, 0, 22050, 44100},
  38. {12000, 0, 24000, 48000},
  39. {8000, 0, 16000, 32000},
  40. {0, 0, 0, 0}};
  41. // Offset in bytes from the end of the MP3 header to "Xing" or "Info" tags which
  42. // indicate a frame is silent metadata frame. Values taken from FFmpeg.
  43. constexpr int kXingHeaderMap[2][2] = {{32, 17}, {17, 9}};
  44. // Frame header field constants.
  45. constexpr int kBitrateFree = 0;
  46. constexpr int kBitrateBad = 0xf;
  47. constexpr int kSampleRateReserved = 3;
  48. constexpr int kCodecDelay = 529;
  49. } // namespace
  50. // static
  51. bool MPEG1AudioStreamParser::ParseHeader(MediaLog* media_log,
  52. size_t* media_log_limit,
  53. const uint8_t* data,
  54. Header* header) {
  55. BitReader reader(data, kHeaderSize);
  56. int sync;
  57. int version;
  58. int layer;
  59. int is_protected;
  60. int bitrate_index;
  61. int sample_rate_index;
  62. int has_padding;
  63. int is_private;
  64. int channel_mode;
  65. int other_flags;
  66. if (!reader.ReadBits(11, &sync) || !reader.ReadBits(2, &version) ||
  67. !reader.ReadBits(2, &layer) || !reader.ReadBits(1, &is_protected) ||
  68. !reader.ReadBits(4, &bitrate_index) ||
  69. !reader.ReadBits(2, &sample_rate_index) ||
  70. !reader.ReadBits(1, &has_padding) || !reader.ReadBits(1, &is_private) ||
  71. !reader.ReadBits(2, &channel_mode) || !reader.ReadBits(6, &other_flags)) {
  72. return false;
  73. }
  74. DVLOG(2) << "Header data :" << std::hex << " sync 0x" << sync << " version 0x"
  75. << version << " layer 0x" << layer << " bitrate_index 0x"
  76. << bitrate_index << " sample_rate_index 0x" << sample_rate_index
  77. << " channel_mode 0x" << channel_mode;
  78. if (sync != 0x7ff || version == kVersionReserved || layer == kLayerReserved ||
  79. bitrate_index == kBitrateFree || bitrate_index == kBitrateBad ||
  80. sample_rate_index == kSampleRateReserved) {
  81. if (media_log) {
  82. LIMITED_MEDIA_LOG(DEBUG, media_log, *media_log_limit, 5)
  83. << "Invalid MP3 header data :" << std::hex << " sync 0x" << sync
  84. << " version 0x" << version << " layer 0x" << layer
  85. << " bitrate_index 0x" << bitrate_index << " sample_rate_index 0x"
  86. << sample_rate_index << " channel_mode 0x" << channel_mode;
  87. }
  88. return false;
  89. }
  90. // Note: For MPEG2 we don't check if a given bitrate or channel layout is
  91. // allowed per spec since all tested decoders don't seem to care.
  92. int bitrate = kBitrateMap[bitrate_index][kVersionLayerMap[version][layer]];
  93. if (bitrate == 0) {
  94. if (media_log) {
  95. LIMITED_MEDIA_LOG(DEBUG, media_log, *media_log_limit, 5)
  96. << "Invalid MP3 bitrate :" << std::hex << " version " << version
  97. << " layer " << layer << " bitrate_index " << bitrate_index;
  98. }
  99. return false;
  100. }
  101. DVLOG(2) << " bitrate " << bitrate;
  102. int frame_sample_rate = kSampleRateMap[sample_rate_index][version];
  103. if (frame_sample_rate == 0) {
  104. if (media_log) {
  105. LIMITED_MEDIA_LOG(DEBUG, media_log, *media_log_limit, 5)
  106. << "Invalid MP3 sample rate :" << std::hex << " version " << version
  107. << " sample_rate_index " << sample_rate_index;
  108. }
  109. return false;
  110. }
  111. // http://teslabs.com/openplayer/docs/docs/specs/mp3_structure2.pdf
  112. // Table 2.1.5
  113. int samples_per_frame;
  114. switch (layer) {
  115. case kLayer1:
  116. samples_per_frame = 384;
  117. break;
  118. case kLayer2:
  119. samples_per_frame = 1152;
  120. break;
  121. case kLayer3:
  122. if (version == kVersion2 || version == kVersion2_5) {
  123. samples_per_frame = 576;
  124. } else {
  125. samples_per_frame = 1152;
  126. }
  127. break;
  128. default:
  129. return false;
  130. }
  131. if (!header)
  132. return true;
  133. header->sample_rate = frame_sample_rate;
  134. header->sample_count = samples_per_frame;
  135. // http://teslabs.com/openplayer/docs/docs/specs/mp3_structure2.pdf
  136. // Text just below Table 2.1.5.
  137. if (layer == kLayer1) {
  138. // This formulation is a slight variation on the equation below,
  139. // but has slightly different truncation characteristics to deal
  140. // with the fact that Layer 1 has 4 byte "slots" instead of single
  141. // byte ones.
  142. header->frame_size = 4 * (12 * bitrate * 1000 / frame_sample_rate);
  143. } else {
  144. header->frame_size =
  145. ((samples_per_frame / 8) * bitrate * 1000) / frame_sample_rate;
  146. }
  147. if (has_padding)
  148. header->frame_size += (layer == kLayer1) ? 4 : 1;
  149. // Map Stereo(0), Joint Stereo(1), and Dual Channel (2) to
  150. // CHANNEL_LAYOUT_STEREO and Single Channel (3) to CHANNEL_LAYOUT_MONO.
  151. header->channel_layout =
  152. (channel_mode == 3) ? CHANNEL_LAYOUT_MONO : CHANNEL_LAYOUT_STEREO;
  153. header->version = static_cast<Version>(version);
  154. header->layer = static_cast<Layer>(layer);
  155. header->channel_mode = channel_mode;
  156. return true;
  157. }
  158. MPEG1AudioStreamParser::MPEG1AudioStreamParser()
  159. : MPEGAudioStreamParserBase(kMPEG1StartCodeMask,
  160. AudioCodec::kMP3,
  161. kCodecDelay) {}
  162. MPEG1AudioStreamParser::~MPEG1AudioStreamParser() = default;
  163. int MPEG1AudioStreamParser::ParseFrameHeader(const uint8_t* data,
  164. int size,
  165. int* frame_size,
  166. int* sample_rate,
  167. ChannelLayout* channel_layout,
  168. int* sample_count,
  169. bool* metadata_frame,
  170. std::vector<uint8_t>* extra_data) {
  171. DCHECK(data);
  172. DCHECK_GE(size, 0);
  173. DCHECK(frame_size);
  174. if (size < kHeaderSize)
  175. return 0;
  176. Header header;
  177. if (!ParseHeader(media_log(), &mp3_parse_error_limit_, data, &header))
  178. return -1;
  179. *frame_size = header.frame_size;
  180. if (sample_rate)
  181. *sample_rate = header.sample_rate;
  182. if (sample_count)
  183. *sample_count = header.sample_count;
  184. if (channel_layout)
  185. *channel_layout = header.channel_layout;
  186. if (metadata_frame)
  187. *metadata_frame = false;
  188. const int header_bytes_read = kHeaderSize;
  189. if (header.layer != kLayer3)
  190. return header_bytes_read;
  191. // Check if this is a XING frame and tell the base parser to skip it if so.
  192. const int xing_header_index =
  193. kXingHeaderMap[header.version == kVersion2 ||
  194. header.version == kVersion2_5][header.channel_mode == 3];
  195. uint32_t tag = 0;
  196. // It's not a XING frame if the frame isn't big enough to be one.
  197. if (*frame_size <
  198. header_bytes_read + xing_header_index + static_cast<int>(sizeof(tag))) {
  199. return header_bytes_read;
  200. }
  201. // If we don't have enough data available to check, return 0 so frame parsing
  202. // will be retried once more data is available.
  203. BitReader reader(data + header_bytes_read, size - header_bytes_read);
  204. if (!reader.SkipBits(xing_header_index * 8) ||
  205. !reader.ReadBits(sizeof(tag) * 8, &tag)) {
  206. return 0;
  207. }
  208. // Check to see if the tag contains 'Xing' or 'Info'
  209. if (tag == 0x496e666f || tag == 0x58696e67) {
  210. MEDIA_LOG(DEBUG, media_log()) << "Skipping XING header.";
  211. if (metadata_frame)
  212. *metadata_frame = true;
  213. return header_bytes_read + reader.bits_read() / 8;
  214. }
  215. // If it wasn't a XING frame, just return the number consumed bytes.
  216. return header_bytes_read;
  217. }
  218. } // namespace media