Added aac bitstream converter

media/filters/ffmpeg_demuxer.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 "media/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 10 matching lines @@
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/video_decoder_config.h"
 #include "media/ffmpeg/ffmpeg_common.h"
+#include "media/filters/ffmpeg_aac_bitstream_converter.h"
+#include "media/filters/ffmpeg_bitstream_converter.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_h264_to_annex_b_bitstream_converter.h"
 #include "media/filters/webvtt_util.h"
 #include "media/formats/webm/webm_crypto_helpers.h"
 
 namespace media {
 
 static base::Time ExtractTimelineOffset(AVFormatContext* format_context) {
   if (strstr(format_context->iformat->name, "webm") ||
       strstr(format_context->iformat->name, "matroska")) {
@@ skipping 47 matching lines @@
 FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
                                          AVStream* stream)
     : demuxer_(demuxer),
       task_runner_(base::MessageLoopProxy::current()),
       stream_(stream),
       type_(UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
       last_packet_duration_(kNoTimestamp()),
       video_rotation_(VIDEO_ROTATION_0),
-      bitstream_converter_enabled_(false),
       fixup_negative_ogg_timestamps_(false) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
   int rotation = 0;
   AVDictionaryEntry* rotation_entry = NULL;
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
@@ skipping 32 matching lines @@
       type_ = TEXT;
       break;
     default:
       NOTREACHED();
       break;
   }
 
   // Calculate the duration.
   duration_ = ConvertStreamTimestamp(stream->time_base, stream->duration);
 
-#if defined(USE_PROPRIETARY_CODECS)
-  if (stream_->codec->codec_id == AV_CODEC_ID_H264) {
-    bitstream_converter_.reset(
-        new FFmpegH264ToAnnexBBitstreamConverter(stream_->codec));
-  }
-#endif
-
   if (is_encrypted) {
     AVDictionaryEntry* key = av_dict_get(stream->metadata, "enc_key_id", NULL,
                                          0);
     DCHECK(key);
     DCHECK(key->value);
     if (!key || !key->value)
       return;
     base::StringPiece base64_key_id(key->value);
     std::string enc_key_id;
     base::Base64Decode(base64_key_id, &enc_key_id);
     DCHECK(!enc_key_id.empty());
     if (enc_key_id.empty())
       return;
 
     encryption_key_id_.assign(enc_key_id);
     demuxer_->FireNeedKey(kWebMInitDataType, enc_key_id);
   }
 }
 
 void FFmpegDemuxerStream::EnqueuePacket(ScopedAVPacket packet) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!demuxer_ || end_of_stream_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return;
   }
 
 #if defined(USE_PROPRIETARY_CODECS)
   // Convert the packet if there is a bitstream filter.
-  if (packet->data && bitstream_converter_enabled_ &&
+  if (packet->data && bitstream_converter_ &&
       !bitstream_converter_->ConvertPacket(packet.get())) {
     LOG(ERROR) << "Format conversion failed.";
   }
 #endif
 
   // Get side data if any. For now, the only type of side_data is VP8 Alpha. We
   // keep this generic so that other side_data types in the future can be
   // handled the same way as well.
   av_packet_split_side_data(packet.get());
 
@@ skipping 178 matching lines @@
 void FFmpegDemuxerStream::SetEndOfStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   end_of_stream_ = true;
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::FlushBuffers() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(read_cb_.is_null()) << "There should be no pending read";
 
-  // H264 requires that we resend the header after flush.
-  // Reset its bitstream for converter to do so.
+  // H264 and AAC require that we resend the header after flush.
+  // Reset bitstream for converter to do so.
   // This is related to chromium issue 140371 (http://crbug.com/140371).
   ResetBitstreamConverter();
 
   buffer_queue_.Clear();
   end_of_stream_ = false;
   last_packet_timestamp_ = kNoTimestamp();
   last_packet_duration_ = kNoTimestamp();
 }
 
 void FFmpegDemuxerStream::Stop() {
@@ skipping 28 matching lines @@
     return;
   }
 
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::EnableBitstreamConverter() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
 #if defined(USE_PROPRIETARY_CODECS)
-  CHECK(bitstream_converter_.get());
-  bitstream_converter_enabled_ = true;
+  InitBitstreamConverter();
 #else
   NOTREACHED() << "Proprietary codecs not enabled.";
 #endif
 }
 
 void FFmpegDemuxerStream::ResetBitstreamConverter() {
 #if defined(USE_PROPRIETARY_CODECS)
-  if (!bitstream_converter_enabled_ || !bitstream_converter_)
-    return;
-
-  bitstream_converter_.reset(
-      new FFmpegH264ToAnnexBBitstreamConverter(stream_->codec));
+  if (bitstream_converter_)
+    InitBitstreamConverter();
 #endif  // defined(USE_PROPRIETARY_CODECS)
 }
 
+void FFmpegDemuxerStream::InitBitstreamConverter() {
+#if defined(USE_PROPRIETARY_CODECS)
+  if (stream_->codec->codec_id == AV_CODEC_ID_H264) {
+    bitstream_converter_.reset(
+        new FFmpegH264ToAnnexBBitstreamConverter(stream_->codec));
+  } else if (stream_->codec->codec_id == AV_CODEC_ID_AAC) {
+    bitstream_converter_.reset(
+        new FFmpegAACBitstreamConverter(stream_->codec));
+  }
+#endif  // defined(USE_PROPRIETARY_CODECS)
+}
+
 bool FFmpegDemuxerStream::SupportsConfigChanges() { return false; }
 
 AudioDecoderConfig FFmpegDemuxerStream::audio_decoder_config() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK_EQ(type_, AUDIO);
   return audio_config_;
 }
 
 VideoDecoderConfig FFmpegDemuxerStream::video_decoder_config() {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 801 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media