Mpeg2 TS stream parser for media source.

media/mpeg2/es_parser_adts.cc

+// Copyright (c) 2013 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 "media/mpeg2/es_parser_adts.h"
+
+#include <list>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/bit_reader.h"
+#include "media/base/buffers.h"
+#include "media/base/channel_layout.h"
+#include "media/base/stream_parser_buffer.h"
+#include "media/mpeg2/mpeg2ts_common.h"
+
+namespace {
+// Adts header is at least 7 bytes (can be 9 bytes).
+const int kAdtsHeaderMinSize = 7;

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: Please use static here and below instead of an anon namespace to be
consistent with the majority of the media/ code.

[damienv1, 2013/09/09 23:29:45]

Done.

+
+const int adts_frequency_table[16] = {
+  96000,
+  88200,
+  64000,
+  48000,
+  44100,
+  32000,
+  24000,
+  22050,
+  16000,
+  12000,
+  11025,
+  8000,
+  7350,
+  0,
+  0,
+  0,
+};
+const int kMaxSupportedFrequencyIndex = 12;
+
+media::ChannelLayout adts_channel_layout[8] = {
+  media::CHANNEL_LAYOUT_NONE,
+  media::CHANNEL_LAYOUT_MONO,
+  media::CHANNEL_LAYOUT_STEREO,
+  media::CHANNEL_LAYOUT_SURROUND,
+  media::CHANNEL_LAYOUT_4_0,
+  media::CHANNEL_LAYOUT_5_0_BACK,
+  media::CHANNEL_LAYOUT_5_1_BACK,
+  media::CHANNEL_LAYOUT_7_1,
+};
+
+// Number of samples per frame.
+const int kNumberSamplesPerAACFrame = 1024;
+const int kNumberSamplesPerHeAACFrame = 2048;

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: This and the one below do not appear to be getting used. Please remove or
update the code to use them.

[damienv1, 2013/09/09 23:29:45]

Done.

+const int kNumberSamplesPerAACLcFrame = 960;
+
+int ExtractAdtsFrameSize(const uint8* adts_header) {
+  int frame_size =

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: The local vars aren't needed here and below. Just return the values.

[damienv1, 2013/09/09 23:29:45]

Done.

+      (static_cast<int>(adts_header[5]) >> 5) |
+      (static_cast<int>(adts_header[4]) << 3) |
+      ((static_cast<int>(adts_header[3]) & 0x3) << 11);
+  return frame_size;
+}
+
+int ExtractAdtsFrequencyIndex(const uint8* adts_header) {
+  int frequency_index =
+      (adts_header[2] >> 2) & 0xf;
+  return frequency_index;
+}
+
+int ExtractAdtsChannelConfig(const uint8* adts_header) {
+  int channel_config =
+      ((adts_header[3] >> 6) & 0x3) |
+      ((adts_header[2] & 0x1) << 2);
+  return channel_config;
+}
+
+// Look for an ADTS syncword.
+// |new_pos| returns
+// - either the byte position of the ADTS frame (if found)
+// - or the byte position of 1st byte that was not processed (if not found).
+// |frame_sz| returns the size of the ADTS frame (if found).
+// Return whether a syncword was found.
+bool LookForSyncWord(const uint8* raw_es, int raw_es_size,
+                     int pos,
+                     int* new_pos, int* frame_sz) {
+  int max_offset = raw_es_size - kAdtsHeaderMinSize;
+  if (max_offset < 0)
+    max_offset = 0;
+
+  for (int offset = pos; offset < max_offset; offset++) {
+    const uint8* cur_buf = &raw_es[offset];
+
+    if ((cur_buf[0] != 0xff) || ((cur_buf[1] & 0xf6) != 0xf0))
+      // The first 12 bits must be 1.
+      // The layer field (2 bits) must be set to 0.
+      continue;
+
+    int frequency_index = ExtractAdtsFrequencyIndex(cur_buf);
+    if (frequency_index > kMaxSupportedFrequencyIndex) {
+      // Frequency index 13 & 14 are reserved
+      // while 15 means that the frequency is explicitly written
+      // (not supported).
+      continue;

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

If these aren't supported, shouldn't we trigger an error? Otherwise we'll just
keep consuming content that can't be played w/o the user knowing why. At least
signalling an error indicates that the content is not playable.

In general we should be strict about what we accept and clearly error out when
we encounter situations we don't support.

[damienv1, 2013/09/09 23:29:45]

Done.

+    }
+
+    int frame_size = ExtractAdtsFrameSize(cur_buf);
+    if (frame_size < kAdtsHeaderMinSize)
+      // Too short to be an ADTS frame.
+      continue;
+
+    // Check whether there is another frame
+    // |size| apart from the current one.
+    int remaining_size = raw_es_size - offset;
+    if (remaining_size >= frame_size + 2) {
+      if ((cur_buf[frame_size] != 0xff) ||
+          (cur_buf[frame_size + 1] & 0xf6) != 0xf0)
+        continue;
+    }
+
+    *new_pos = offset;
+    *frame_sz = frame_size;
+    return true;
+  }
+
+  *new_pos = max_offset;
+  return false;
+}
+
+}  // namespace
+
+namespace media {
+namespace mpeg2ts {
+
+EsParserAdts::EsParserAdts(
+    NewAudioConfigCB new_audio_config_cb,
+    EmitBufferCB emit_buffer_cb)
+  : new_audio_config_cb_(new_audio_config_cb),
+    emit_buffer_cb_(emit_buffer_cb),
+    first_frame_(true),
+    is_audio_config_known_(false),
+    sampling_frequency_(0),
+    channel_configuration_(0) {
+}
+
+EsParserAdts::~EsParserAdts() {
+}
+
+void EsParserAdts::Parse(const uint8* buf, int size,
+                         base::TimeDelta pts,
+                         base::TimeDelta dts) {
+  int raw_es_size = 0;
+  const uint8* raw_es = NULL;
+
+  // The incoming PTS applies to the access unit that comes just after
+  // the beginning of |buf|.
+  if (pts != kNoTimestamp()) {
+    es_byte_queue_.Peek(&raw_es, &raw_es_size);
+    pts_list_.push_back(EsPts(raw_es_size, pts));
+  }
+
+  // Copy the input data to the ES buffer.
+  es_byte_queue_.Push(buf, size);
+  es_byte_queue_.Peek(&raw_es, &raw_es_size);
+
+  // Look for every ADTS frame in the ES buffer starting at offset = 0
+  int es_position = 0;
+  int frame_size;
+  while (LookForSyncWord(raw_es, raw_es_size, es_position,
+                         &es_position, &frame_size)) {
+    DVLOG(LOG_LEVEL_ES) << "ADTS syncword @ pos=" << es_position
+                        << " frame_size=" << frame_size;
+    DVLOG(LOG_LEVEL_ES) << "ADTS header: "
+                        << base::HexEncode(&raw_es[es_position], 7);
+
+    // Do not process the frame if this one is a partial frame.
+    int remaining_size = raw_es_size - es_position;
+    if (frame_size > remaining_size) {

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: remove unnecessary {}

[damienv1, 2013/09/09 23:29:45]

Done.

+      break;
+    }
+
+    // Update the audio configuration if needed.
+    DCHECK_GE(frame_size, kAdtsHeaderMinSize);
+    UpdateAudioConfiguration(&raw_es[es_position]);
+
+    // Get the PTS & the duration of this access unit.
+    base::TimeDelta current_pts = estimated_pts_;
+    while (!pts_list_.empty() &&
+           pts_list_.front().first <= es_position) {
+      current_pts = pts_list_.front().second;
+      pts_list_.pop_front();
+    }
+    DVLOG(LOG_LEVEL_ES)
+        << "Current PTS: " << current_pts.InMilliseconds()
+        << " Estimated PTS: " << estimated_pts_.InMilliseconds();
+
+    base::TimeDelta frame_duration =

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: Use AudioTimestampHelper for these computations. Since this code always
rounds down you'll run into cases where timestamp() + duration() does not equal
the timestamp() on the next buffer. AudioTimestampHelper allows you to avoid
this problem and construct buffer timestamps and durations that have the proper
rounding.

[damienv1, 2013/09/09 23:29:45]

That's correct. However, I am not sure the AudioTimestampHelper is correct
either: to avoid any rounding issue, it should not use "double" at all, all the
operations should be integer operations.
I agree this is an implementation issue.

+        base::TimeDelta::FromMicroseconds(
+            (1000000 * kNumberSamplesPerAACFrame) / sampling_frequency_);
+
+    // Verify that PTS is increasing.
+    if (!first_frame_ && current_pts < last_frame_pts_) {

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: remove first_frame_ & last_frame_pts_ if you are really intending to rely
on SourceBuffer to handle non-increasing PTS.

[damienv1, 2013/09/09 23:29:45]

Removed (I used it mainly for my own debugging).

+      LOG(WARNING) << "ADTS: pts not monotonic";
+    }
+    first_frame_ = false;
+    last_frame_pts_ = current_pts;
+
+    // Emit an audio frame.
+    bool is_key_frame = true;
+    scoped_refptr<StreamParserBuffer> stream_parser_buffer =
+        StreamParserBuffer::CopyFrom(
+            &raw_es[es_position],
+            frame_size,
+            is_key_frame);
+    stream_parser_buffer->SetDecodeTimestamp(current_pts);
+    stream_parser_buffer->set_timestamp(current_pts);
+    stream_parser_buffer->set_duration(frame_duration);
+    emit_buffer_cb_.Run(stream_parser_buffer);
+
+    // Update the PTS of the next frame.
+    estimated_pts_ = current_pts + frame_duration;

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

Replace this with AudioTimestampHelper for more accurate timestamp generation.

[damienv1, 2013/09/09 23:29:45]

ok.

+
+    // Skip the current frame.
+    es_position += frame_size;
+  }
+
+  // Discard all the bytes that have been processed.
+  DiscardEs(es_position);
+}
+
+void EsParserAdts::Flush() {
+  // All the complete frames have been emitted,
+  // so just clear the ES buffer.
+  es_byte_queue_.Reset();
+  pts_list_.clear();
+}
+
+void EsParserAdts::UpdateAudioConfiguration(const uint8* adts_header) {
+  int frequency_index = ExtractAdtsFrequencyIndex(adts_header);
+  DCHECK_LE(frequency_index, kMaxSupportedFrequencyIndex);
+
+  // TODO(damienv): support HE-AAC frequency doubling (SBR)
+  // based on the incoming ADTS profile.
+  int samples_per_second = adts_frequency_table[frequency_index];
+
+  int channel_configuration = ExtractAdtsChannelConfig(adts_header);
+  int adts_profile = (adts_header[2] >> 6) & 0x3;
+
+  if (!is_audio_config_known_ ||
+      sampling_frequency_ != samples_per_second ||
+      channel_configuration_ != channel_configuration) {
+    is_audio_config_known_ = true;
+    sampling_frequency_ = samples_per_second;
+    channel_configuration_ = channel_configuration;
+
+    LOG(INFO) << "Sampling frequency: " << samples_per_second;

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: Use DVLOG

[damienv1, 2013/09/09 23:29:45]

Done.

+    LOG(INFO) << "Channel config: " << channel_configuration;
+    LOG(INFO) << "Adts profile: " << adts_profile;
+    AudioDecoderConfig audio_decoder_config(
+        kCodecAAC,
+        kSampleFormatS16,
+        adts_channel_layout[channel_configuration],
+        samples_per_second,
+        NULL, 0,
+        false);
+    new_audio_config_cb_.Run(audio_decoder_config);
+  }
+}
+
+void EsParserAdts::DiscardEs(int nbytes) {
+  if (nbytes <= 0)

[acolwell GONE FROM CHROMIUM, 2013/09/05 18:29:10]

nit: Add DCHECK_GE(nbytes, 0) since a negative value is an error in the code.

[damienv1, 2013/09/09 23:29:45]

Done.

+    return;
+
+  // Adjust the ES position of each PTS.
+  for (EsPtsList::iterator it = pts_list_.begin(); it != pts_list_.end(); ++it)
+    it->first -= nbytes;
+
+  // Discard |nbytes| of ES.
+  es_byte_queue_.Pop(nbytes);
+}
+
+}  // namespace mpeg2ts
+}  // namespace media