Import Cobalt 16.154703
diff --git a/src/starboard/shared/ffmpeg/ffmpeg.gyp b/src/starboard/shared/ffmpeg/ffmpeg.gyp
new file mode 100644
index 0000000..bb08955
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg.gyp
@@ -0,0 +1,89 @@
+# Copyright 2018 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+{
+ 'target_defaults': {
+ 'defines': [
+ 'STARBOARD_IMPLEMENTATION',
+ ],
+ },
+ 'variables': {
+ 'ffmpeg_specialization_sources': [
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_common.h',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h',
+ ],
+ 'ffmpeg_dispatch_sources': [
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_audio_decoder.h',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_dispatch.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_dispatch.h',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_video_decoder.h',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_video_decoder_internal.cc',
+ ],
+ },
+ 'targets': [
+ {
+ 'target_name': 'libav.54.35.1',
+ 'type': '<(library)',
+ 'sources': [ '<@(ffmpeg_specialization_sources)' ],
+ 'dependencies': [
+ '<(DEPTH)/third_party/ffmpeg_includes/ffmpeg_includes.gyp:libav.54.35.1',
+ ],
+ },
+ {
+ 'target_name': 'libav.56.1.0',
+ 'type': '<(library)',
+ 'sources': [ '<@(ffmpeg_specialization_sources)' ],
+ 'dependencies': [
+ '<(DEPTH)/third_party/ffmpeg_includes/ffmpeg_includes.gyp:libav.56.1.0',
+ ],
+ },
+ {
+ 'target_name': 'ffmpeg.57.107.100',
+ 'type': '<(library)',
+ 'sources': [ '<@(ffmpeg_specialization_sources)' ],
+ 'dependencies': [
+ '<(DEPTH)/third_party/ffmpeg_includes/ffmpeg_includes.gyp:ffmpeg.57.107.100',
+ ],
+ },
+ {
+ 'target_name': 'ffmpeg_dynamic_load',
+ 'type': '<(library)',
+ 'sources': [
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_dynamic_load_audio_decoder_impl.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_dynamic_load_video_decoder_impl.cc',
+ '<@(ffmpeg_dispatch_sources)',
+ ],
+ 'dependencies': [
+ 'ffmpeg.57.107.100',
+ 'libav.54.35.1',
+ 'libav.56.1.0',
+ ],
+ },
+ {
+ 'target_name': 'ffmpeg_linked',
+ 'type': '<(library)',
+ 'sources': [
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_linked_audio_decoder_impl.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_linked_dispatch_impl.cc',
+ '<(DEPTH)/starboard/shared/ffmpeg/ffmpeg_linked_video_decoder_impl.cc',
+ '<@(ffmpeg_dispatch_sources)',
+ '<@(ffmpeg_specialization_sources)',
+ ],
+ },
+ ],
+}
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc
deleted file mode 100644
index 3d94a3e..0000000
--- a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.cc
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder.h"
-
-#include "starboard/audio_sink.h"
-#include "starboard/log.h"
-#include "starboard/memory.h"
-#include "starboard/shared/starboard/media/media_util.h"
-
-namespace starboard {
-namespace shared {
-namespace ffmpeg {
-
-namespace {
-
-SbMediaAudioSampleType GetSupportedSampleType() {
- if (SbAudioSinkIsAudioSampleTypeSupported(kSbMediaAudioSampleTypeFloat32)) {
- return kSbMediaAudioSampleTypeFloat32;
- }
- return kSbMediaAudioSampleTypeInt16;
-}
-
-AVCodecID GetFfmpegCodecIdByMediaCodec(SbMediaAudioCodec audio_codec) {
- switch (audio_codec) {
- case kSbMediaAudioCodecAac:
- return AV_CODEC_ID_AAC;
- case kSbMediaAudioCodecOpus:
- return AV_CODEC_ID_OPUS;
- default:
- return AV_CODEC_ID_NONE;
- }
-}
-
-} // namespace
-
-AudioDecoder::AudioDecoder(SbMediaAudioCodec audio_codec,
- const SbMediaAudioHeader& audio_header)
- : audio_codec_(audio_codec),
- codec_context_(NULL),
- av_frame_(NULL),
- stream_ended_(false),
- audio_header_(audio_header) {
- SB_DCHECK(GetFfmpegCodecIdByMediaCodec(audio_codec) != AV_CODEC_ID_NONE)
- << "Unsupported audio codec " << audio_codec;
-
- InitializeCodec();
-}
-
-AudioDecoder::~AudioDecoder() {
- TeardownCodec();
-}
-
-void AudioDecoder::Initialize(const OutputCB& output_cb,
- const ErrorCB& error_cb) {
- SB_DCHECK(BelongsToCurrentThread());
- SB_DCHECK(output_cb);
- SB_DCHECK(!output_cb_);
- SB_DCHECK(error_cb);
- SB_DCHECK(!error_cb_);
-
- output_cb_ = output_cb;
- error_cb_ = error_cb;
-}
-
-void AudioDecoder::Decode(const scoped_refptr<InputBuffer>& input_buffer,
- const ConsumedCB& consumed_cb) {
- SB_DCHECK(BelongsToCurrentThread());
- SB_DCHECK(input_buffer);
- SB_DCHECK(output_cb_);
- SB_CHECK(codec_context_ != NULL);
-
- Schedule(consumed_cb);
-
- if (stream_ended_) {
- SB_LOG(ERROR) << "Decode() is called after WriteEndOfStream() is called.";
- return;
- }
-
- AVPacket packet;
- av_init_packet(&packet);
- packet.data = const_cast<uint8_t*>(input_buffer->data());
- packet.size = input_buffer->size();
-
-#if LIBAVUTIL_VERSION_MAJOR > 52
- av_frame_unref(av_frame_);
-#else // LIBAVUTIL_VERSION_MAJOR > 52
- avcodec_get_frame_defaults(av_frame_);
-#endif // LIBAVUTIL_VERSION_MAJOR > 52
- int frame_decoded = 0;
- int result =
- avcodec_decode_audio4(codec_context_, av_frame_, &frame_decoded, &packet);
- if (result != input_buffer->size() || frame_decoded != 1) {
- // TODO: Consider fill it with silence.
- SB_DLOG(WARNING) << "avcodec_decode_audio4() failed with result: " << result
- << " with input buffer size: " << input_buffer->size()
- << " and frame decoded: " << frame_decoded;
- error_cb_();
- return;
- }
-
- int decoded_audio_size = av_samples_get_buffer_size(
- NULL, codec_context_->channels, av_frame_->nb_samples,
- codec_context_->sample_fmt, 1);
- audio_header_.samples_per_second = codec_context_->sample_rate;
-
- if (decoded_audio_size > 0) {
- scoped_refptr<DecodedAudio> decoded_audio = new DecodedAudio(
- codec_context_->channels, GetSampleType(), GetStorageType(),
- input_buffer->pts(),
- codec_context_->channels * av_frame_->nb_samples *
- starboard::media::GetBytesPerSample(GetSampleType()));
- if (GetStorageType() == kSbMediaAudioFrameStorageTypeInterleaved) {
- SbMemoryCopy(decoded_audio->buffer(), *av_frame_->extended_data,
- decoded_audio->size());
- } else {
- SB_DCHECK(GetStorageType() == kSbMediaAudioFrameStorageTypePlanar);
- const int per_channel_size_in_bytes =
- decoded_audio->size() / decoded_audio->channels();
- for (int i = 0; i < decoded_audio->channels(); ++i) {
- SbMemoryCopy(decoded_audio->buffer() + per_channel_size_in_bytes * i,
- av_frame_->extended_data[i], per_channel_size_in_bytes);
- }
- }
- decoded_audios_.push(decoded_audio);
- Schedule(output_cb_);
- } else {
- // TODO: Consider fill it with silence.
- SB_LOG(ERROR) << "Decoded audio frame is empty.";
- }
-}
-
-void AudioDecoder::WriteEndOfStream() {
- SB_DCHECK(BelongsToCurrentThread());
- SB_DCHECK(output_cb_);
-
- // AAC has no dependent frames so we needn't flush the decoder. Set the flag
- // to ensure that Decode() is not called when the stream is ended.
- stream_ended_ = true;
- // Put EOS into the queue.
- decoded_audios_.push(new DecodedAudio);
-
- Schedule(output_cb_);
-}
-
-scoped_refptr<AudioDecoder::DecodedAudio> AudioDecoder::Read() {
- SB_DCHECK(BelongsToCurrentThread());
- SB_DCHECK(output_cb_);
- SB_DCHECK(!decoded_audios_.empty());
-
- scoped_refptr<DecodedAudio> result;
- if (!decoded_audios_.empty()) {
- result = decoded_audios_.front();
- decoded_audios_.pop();
- }
- return result;
-}
-
-void AudioDecoder::Reset() {
- SB_DCHECK(BelongsToCurrentThread());
-
- stream_ended_ = false;
- while (!decoded_audios_.empty()) {
- decoded_audios_.pop();
- }
-
- CancelPendingJobs();
-}
-
-SbMediaAudioSampleType AudioDecoder::GetSampleType() const {
- SB_DCHECK(BelongsToCurrentThread());
-
- if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16 ||
- codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P) {
- return kSbMediaAudioSampleTypeInt16;
- } else if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT ||
- codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP) {
- return kSbMediaAudioSampleTypeFloat32;
- }
-
- SB_NOTREACHED();
-
- return kSbMediaAudioSampleTypeFloat32;
-}
-
-SbMediaAudioFrameStorageType AudioDecoder::GetStorageType() const {
- SB_DCHECK(BelongsToCurrentThread());
-
- if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16 ||
- codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
- return kSbMediaAudioFrameStorageTypeInterleaved;
- }
- if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P ||
- codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP) {
- return kSbMediaAudioFrameStorageTypePlanar;
- }
-
- SB_NOTREACHED();
- return kSbMediaAudioFrameStorageTypeInterleaved;
-}
-
-int AudioDecoder::GetSamplesPerSecond() const {
- return audio_header_.samples_per_second;
-}
-
-void AudioDecoder::InitializeCodec() {
- InitializeFfmpeg();
-
- codec_context_ = avcodec_alloc_context3(NULL);
-
- if (codec_context_ == NULL) {
- SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
- return;
- }
-
- codec_context_->codec_type = AVMEDIA_TYPE_AUDIO;
- codec_context_->codec_id = GetFfmpegCodecIdByMediaCodec(audio_codec_);
- // Request_sample_fmt is set by us, but sample_fmt is set by the decoder.
- if (GetSupportedSampleType() == kSbMediaAudioSampleTypeInt16) {
- codec_context_->request_sample_fmt = AV_SAMPLE_FMT_S16;
- } else {
- codec_context_->request_sample_fmt = AV_SAMPLE_FMT_FLT;
- }
-
- codec_context_->channels = audio_header_.number_of_channels;
- codec_context_->sample_rate = audio_header_.samples_per_second;
-
- codec_context_->extradata = NULL;
- codec_context_->extradata_size = 0;
-
- AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
-
- if (codec == NULL) {
- SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
- TeardownCodec();
- return;
- }
-
- int rv = OpenCodec(codec_context_, codec);
- if (rv < 0) {
- SB_LOG(ERROR) << "Unable to open codec";
- TeardownCodec();
- return;
- }
-
-#if LIBAVUTIL_VERSION_MAJOR > 52
- av_frame_ = av_frame_alloc();
-#else // LIBAVUTIL_VERSION_MAJOR > 52
- av_frame_ = avcodec_alloc_frame();
-#endif // LIBAVUTIL_VERSION_MAJOR > 52
- if (av_frame_ == NULL) {
- SB_LOG(ERROR) << "Unable to allocate audio frame";
- TeardownCodec();
- }
-}
-
-void AudioDecoder::TeardownCodec() {
- if (codec_context_) {
- CloseCodec(codec_context_);
- av_free(codec_context_);
- codec_context_ = NULL;
- }
- if (av_frame_) {
- av_free(av_frame_);
- av_frame_ = NULL;
- }
-}
-
-} // namespace ffmpeg
-} // namespace shared
-} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.h b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.h
index 45e466e..f6d715a 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.h
+++ b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder.h
@@ -15,54 +15,21 @@
#ifndef STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_DECODER_H_
#define STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_DECODER_H_
-#include <queue>
-
-#include "starboard/common/ref_counted.h"
#include "starboard/media.h"
-#include "starboard/shared/ffmpeg/ffmpeg_common.h"
#include "starboard/shared/internal_only.h"
-#include "starboard/shared/starboard/player/decoded_audio_internal.h"
#include "starboard/shared/starboard/player/filter/audio_decoder_internal.h"
-#include "starboard/shared/starboard/player/job_queue.h"
namespace starboard {
namespace shared {
namespace ffmpeg {
-class AudioDecoder : public starboard::player::filter::AudioDecoder,
- private starboard::player::JobQueue::JobOwner {
+class AudioDecoder : public starboard::player::filter::AudioDecoder {
public:
- AudioDecoder(SbMediaAudioCodec audio_codec,
- const SbMediaAudioHeader& audio_header);
- ~AudioDecoder() override;
-
- void Initialize(const OutputCB& output_cb, const ErrorCB& error_cb) override;
- void Decode(const scoped_refptr<InputBuffer>& input_buffer,
- const ConsumedCB& consumed_cb) override;
- void WriteEndOfStream() override;
- scoped_refptr<DecodedAudio> Read() override;
- void Reset() override;
- SbMediaAudioSampleType GetSampleType() const override;
- SbMediaAudioFrameStorageType GetStorageType() const override;
- int GetSamplesPerSecond() const override;
-
- bool is_valid() const { return codec_context_ != NULL; }
-
- private:
- void InitializeCodec();
- void TeardownCodec();
-
- static const int kMaxDecodedAudiosSize = 64;
-
- OutputCB output_cb_;
- ErrorCB error_cb_;
- SbMediaAudioCodec audio_codec_;
- AVCodecContext* codec_context_;
- AVFrame* av_frame_;
-
- bool stream_ended_;
- std::queue<scoped_refptr<DecodedAudio> > decoded_audios_;
- SbMediaAudioHeader audio_header_;
+ // Create an audio decoder for the currently loaded ffmpeg library.
+ static AudioDecoder* Create(SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header);
+ // Returns true if the audio decoder is initialized successfully.
+ virtual bool is_valid() const = 0;
};
} // namespace ffmpeg
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.cc
new file mode 100644
index 0000000..ec1f8f9
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.cc
@@ -0,0 +1,327 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains the explicit specialization of the AudioDecoderImpl class
+// for the value 'FFMPEG'.
+
+#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h"
+
+#include "starboard/audio_sink.h"
+#include "starboard/log.h"
+#include "starboard/memory.h"
+#include "starboard/shared/starboard/media/media_util.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+namespace {
+
+SbMediaAudioSampleType GetSupportedSampleType() {
+ if (SbAudioSinkIsAudioSampleTypeSupported(kSbMediaAudioSampleTypeFloat32)) {
+ return kSbMediaAudioSampleTypeFloat32;
+ }
+ return kSbMediaAudioSampleTypeInt16Deprecated;
+}
+
+AVCodecID GetFfmpegCodecIdByMediaCodec(SbMediaAudioCodec audio_codec) {
+ switch (audio_codec) {
+ case kSbMediaAudioCodecAac:
+ return AV_CODEC_ID_AAC;
+ case kSbMediaAudioCodecOpus:
+ return AV_CODEC_ID_OPUS;
+ default:
+ return AV_CODEC_ID_NONE;
+ }
+}
+
+const bool g_registered =
+ FFMPEGDispatch::RegisterSpecialization(FFMPEG,
+ LIBAVCODEC_VERSION_MAJOR,
+ LIBAVFORMAT_VERSION_MAJOR,
+ LIBAVUTIL_VERSION_MAJOR);
+
+} // namespace
+
+AudioDecoderImpl<FFMPEG>::AudioDecoderImpl(
+ SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header)
+ : audio_codec_(audio_codec),
+ codec_context_(NULL),
+ av_frame_(NULL),
+ stream_ended_(false),
+ audio_header_(audio_header) {
+ SB_DCHECK(g_registered) << "Decoder Specialization registration failed.";
+ SB_DCHECK(GetFfmpegCodecIdByMediaCodec(audio_codec) != AV_CODEC_ID_NONE)
+ << "Unsupported audio codec " << audio_codec;
+ ffmpeg_ = FFMPEGDispatch::GetInstance();
+ SB_DCHECK(ffmpeg_);
+ if ((ffmpeg_->specialization_version()) == FFMPEG) {
+ InitializeCodec();
+ }
+}
+
+AudioDecoderImpl<FFMPEG>::~AudioDecoderImpl() {
+ TeardownCodec();
+}
+
+// static
+AudioDecoder* AudioDecoderImpl<FFMPEG>::Create(
+ SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header) {
+ return new AudioDecoderImpl<FFMPEG>(audio_codec, audio_header);
+}
+
+void AudioDecoderImpl<FFMPEG>::Initialize(const OutputCB& output_cb,
+ const ErrorCB& error_cb) {
+ SB_DCHECK(BelongsToCurrentThread());
+ SB_DCHECK(output_cb);
+ SB_DCHECK(!output_cb_);
+ SB_DCHECK(error_cb);
+ SB_DCHECK(!error_cb_);
+
+ output_cb_ = output_cb;
+ error_cb_ = error_cb;
+}
+
+void AudioDecoderImpl<FFMPEG>::Decode(
+ const scoped_refptr<InputBuffer>& input_buffer,
+ const ConsumedCB& consumed_cb) {
+ SB_DCHECK(BelongsToCurrentThread());
+ SB_DCHECK(input_buffer);
+ SB_DCHECK(output_cb_);
+ SB_CHECK(codec_context_ != NULL);
+
+ Schedule(consumed_cb);
+
+ if (stream_ended_) {
+ SB_LOG(ERROR) << "Decode() is called after WriteEndOfStream() is called.";
+ return;
+ }
+
+ AVPacket packet;
+ ffmpeg_->av_init_packet(&packet);
+ packet.data = const_cast<uint8_t*>(input_buffer->data());
+ packet.size = input_buffer->size();
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ ffmpeg_->av_frame_unref(av_frame_);
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ ffmpeg_->avcodec_get_frame_defaults(av_frame_);
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ int frame_decoded = 0;
+ int result = ffmpeg_->avcodec_decode_audio4(codec_context_, av_frame_,
+ &frame_decoded, &packet);
+ if (result != input_buffer->size()) {
+ // TODO: Consider fill it with silence.
+ SB_DLOG(WARNING) << "avcodec_decode_audio4() failed with result: " << result
+ << " with input buffer size: " << input_buffer->size()
+ << " and frame decoded: " << frame_decoded;
+ error_cb_();
+ return;
+ }
+
+ if (frame_decoded != 1) {
+ // TODO: Adjust timestamp accordingly when decoding result is shifted.
+ SB_DCHECK(frame_decoded == 0);
+ SB_DLOG(WARNING) << "avcodec_decode_audio4() returns with 0 frames decoded";
+ return;
+ }
+
+ int decoded_audio_size = ffmpeg_->av_samples_get_buffer_size(
+ NULL, codec_context_->channels, av_frame_->nb_samples,
+ codec_context_->sample_fmt, 1);
+ audio_header_.samples_per_second = codec_context_->sample_rate;
+
+ if (decoded_audio_size > 0) {
+ scoped_refptr<DecodedAudio> decoded_audio = new DecodedAudio(
+ codec_context_->channels, GetSampleType(), GetStorageType(),
+ input_buffer->timestamp(),
+ codec_context_->channels * av_frame_->nb_samples *
+ starboard::media::GetBytesPerSample(GetSampleType()));
+ if (GetStorageType() == kSbMediaAudioFrameStorageTypeInterleaved) {
+ SbMemoryCopy(decoded_audio->buffer(), *av_frame_->extended_data,
+ decoded_audio->size());
+ } else {
+ SB_DCHECK(GetStorageType() == kSbMediaAudioFrameStorageTypePlanar);
+ const int per_channel_size_in_bytes =
+ decoded_audio->size() / decoded_audio->channels();
+ for (int i = 0; i < decoded_audio->channels(); ++i) {
+ SbMemoryCopy(decoded_audio->buffer() + per_channel_size_in_bytes * i,
+ av_frame_->extended_data[i], per_channel_size_in_bytes);
+ }
+ }
+ decoded_audios_.push(decoded_audio);
+ Schedule(output_cb_);
+ } else {
+ // TODO: Consider fill it with silence.
+ SB_LOG(ERROR) << "Decoded audio frame is empty.";
+ }
+}
+
+void AudioDecoderImpl<FFMPEG>::WriteEndOfStream() {
+ SB_DCHECK(BelongsToCurrentThread());
+ SB_DCHECK(output_cb_);
+
+ // AAC has no dependent frames so we needn't flush the decoder. Set the flag
+ // to ensure that Decode() is not called when the stream is ended.
+ stream_ended_ = true;
+ // Put EOS into the queue.
+ decoded_audios_.push(new DecodedAudio);
+
+ Schedule(output_cb_);
+}
+
+scoped_refptr<AudioDecoderImpl<FFMPEG>::DecodedAudio>
+AudioDecoderImpl<FFMPEG>::Read() {
+ SB_DCHECK(BelongsToCurrentThread());
+ SB_DCHECK(output_cb_);
+ SB_DCHECK(!decoded_audios_.empty());
+
+ scoped_refptr<DecodedAudio> result;
+ if (!decoded_audios_.empty()) {
+ result = decoded_audios_.front();
+ decoded_audios_.pop();
+ }
+ return result;
+}
+
+void AudioDecoderImpl<FFMPEG>::Reset() {
+ SB_DCHECK(BelongsToCurrentThread());
+
+ stream_ended_ = false;
+ while (!decoded_audios_.empty()) {
+ decoded_audios_.pop();
+ }
+
+ CancelPendingJobs();
+}
+
+bool AudioDecoderImpl<FFMPEG>::is_valid() const {
+ return (ffmpeg_ != NULL) && ffmpeg_->is_valid() && (codec_context_ != NULL);
+}
+
+SbMediaAudioSampleType AudioDecoderImpl<FFMPEG>::GetSampleType() const {
+ SB_DCHECK(BelongsToCurrentThread());
+
+ if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16 ||
+ codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P) {
+ return kSbMediaAudioSampleTypeInt16Deprecated;
+ } else if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT ||
+ codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP) {
+ return kSbMediaAudioSampleTypeFloat32;
+ }
+
+ SB_NOTREACHED();
+
+ return kSbMediaAudioSampleTypeFloat32;
+}
+
+SbMediaAudioFrameStorageType AudioDecoderImpl<FFMPEG>::GetStorageType() const {
+ SB_DCHECK(BelongsToCurrentThread());
+
+ if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16 ||
+ codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
+ return kSbMediaAudioFrameStorageTypeInterleaved;
+ }
+ if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P ||
+ codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP) {
+ return kSbMediaAudioFrameStorageTypePlanar;
+ }
+
+ SB_NOTREACHED();
+ return kSbMediaAudioFrameStorageTypeInterleaved;
+}
+
+int AudioDecoderImpl<FFMPEG>::GetSamplesPerSecond() const {
+ return audio_header_.samples_per_second;
+}
+
+void AudioDecoderImpl<FFMPEG>::InitializeCodec() {
+ codec_context_ = ffmpeg_->avcodec_alloc_context3(NULL);
+
+ if (codec_context_ == NULL) {
+ SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
+ return;
+ }
+
+ codec_context_->codec_type = AVMEDIA_TYPE_AUDIO;
+ codec_context_->codec_id = GetFfmpegCodecIdByMediaCodec(audio_codec_);
+ // Request_sample_fmt is set by us, but sample_fmt is set by the decoder.
+ if (GetSupportedSampleType() == kSbMediaAudioSampleTypeInt16Deprecated) {
+ codec_context_->request_sample_fmt = AV_SAMPLE_FMT_S16;
+ } else {
+ codec_context_->request_sample_fmt = AV_SAMPLE_FMT_FLT;
+ }
+
+ codec_context_->channels = audio_header_.number_of_channels;
+ codec_context_->sample_rate = audio_header_.samples_per_second;
+ codec_context_->extradata = NULL;
+ codec_context_->extradata_size = 0;
+
+ if (codec_context_->codec_id == AV_CODEC_ID_OPUS &&
+ audio_header_.audio_specific_config_size > 0) {
+ // AV_INPUT_BUFFER_PADDING_SIZE is not defined in ancient avcodec.h. Use a
+ // large enough padding here explicitly.
+ const int kAvInputBufferPaddingSize = 256;
+ codec_context_->extradata_size = audio_header_.audio_specific_config_size;
+ codec_context_->extradata = static_cast<uint8_t*>(ffmpeg_->av_malloc(
+ codec_context_->extradata_size + kAvInputBufferPaddingSize));
+ SB_DCHECK(codec_context_->extradata);
+ SbMemoryCopy(codec_context_->extradata, audio_header_.audio_specific_config,
+ codec_context_->extradata_size);
+ SbMemorySet(codec_context_->extradata + codec_context_->extradata_size, 0,
+ kAvInputBufferPaddingSize);
+ }
+
+ AVCodec* codec = ffmpeg_->avcodec_find_decoder(codec_context_->codec_id);
+
+ if (codec == NULL) {
+ SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
+ TeardownCodec();
+ return;
+ }
+
+ int rv = ffmpeg_->OpenCodec(codec_context_, codec);
+ if (rv < 0) {
+ SB_LOG(ERROR) << "Unable to open codec";
+ TeardownCodec();
+ return;
+ }
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ av_frame_ = ffmpeg_->av_frame_alloc();
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ av_frame_ = ffmpeg_->avcodec_alloc_frame();
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ if (av_frame_ == NULL) {
+ SB_LOG(ERROR) << "Unable to allocate audio frame";
+ TeardownCodec();
+ }
+}
+
+void AudioDecoderImpl<FFMPEG>::TeardownCodec() {
+ if (codec_context_) {
+ ffmpeg_->CloseCodec(codec_context_);
+ if (codec_context_->extradata_size) {
+ ffmpeg_->av_freep(&codec_context_->extradata);
+ }
+ ffmpeg_->av_freep(&codec_context_);
+ }
+ ffmpeg_->av_freep(&av_frame_);
+}
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h
new file mode 100644
index 0000000..17ab6ae
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h
@@ -0,0 +1,94 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_DECODER_IMPL_H_
+#define STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_DECODER_IMPL_H_
+
+#include <queue>
+
+#include "starboard/common/ref_counted.h"
+#include "starboard/media.h"
+#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder.h"
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "starboard/shared/internal_only.h"
+#include "starboard/shared/starboard/player/decoded_audio_internal.h"
+#include "starboard/shared/starboard/player/filter/audio_decoder_internal.h"
+#include "starboard/shared/starboard/player/job_queue.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+// For each version V that is supported, there will be an implementation of an
+// explicit specialization of the AudioDecoder class.
+template <int V>
+class AudioDecoderImpl : public AudioDecoder {
+ public:
+ static AudioDecoder* Create(SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header);
+};
+
+// Forward class declaration of the explicit specialization with value FFMPEG.
+template <>
+class AudioDecoderImpl<FFMPEG>;
+
+// Declare the explicit specialization of the class with value FFMPEG.
+template <>
+class AudioDecoderImpl<FFMPEG> : public AudioDecoder,
+ private starboard::player::JobQueue::JobOwner {
+ public:
+ AudioDecoderImpl(SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header);
+ ~AudioDecoderImpl() override;
+
+ // From: AudioDecoder
+ static AudioDecoder* Create(SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header);
+ bool is_valid() const override;
+
+ // From: starboard::player::filter::AudioDecoder
+ void Initialize(const OutputCB& output_cb, const ErrorCB& error_cb) override;
+ void Decode(const scoped_refptr<InputBuffer>& input_buffer,
+ const ConsumedCB& consumed_cb) override;
+ void WriteEndOfStream() override;
+ scoped_refptr<DecodedAudio> Read() override;
+ void Reset() override;
+ SbMediaAudioSampleType GetSampleType() const override;
+ SbMediaAudioFrameStorageType GetStorageType() const override;
+ int GetSamplesPerSecond() const override;
+
+ private:
+ void InitializeCodec();
+ void TeardownCodec();
+
+ static const int kMaxDecodedAudiosSize = 64;
+
+ FFMPEGDispatch* ffmpeg_;
+ OutputCB output_cb_;
+ ErrorCB error_cb_;
+ SbMediaAudioCodec audio_codec_;
+ AVCodecContext* codec_context_;
+ AVFrame* av_frame_;
+
+ bool stream_ended_;
+ std::queue<scoped_refptr<DecodedAudio> > decoded_audios_;
+ SbMediaAudioHeader audio_header_;
+};
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_DECODER_IMPL_H_
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_resampler.cc b/src/starboard/shared/ffmpeg/ffmpeg_audio_resampler.cc
deleted file mode 100644
index 3892b04..0000000
--- a/src/starboard/shared/ffmpeg/ffmpeg_audio_resampler.cc
+++ /dev/null
@@ -1,226 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "starboard/shared/ffmpeg/ffmpeg_audio_resampler.h"
-
-#include "starboard/log.h"
-#include "starboard/memory.h"
-#include "starboard/shared/starboard/media/media_util.h"
-
-namespace starboard {
-namespace shared {
-namespace ffmpeg {
-
-namespace {
-
-const int kMaxChannels = 8;
-const int kMaxCachedSamples = 65536;
-
-int GetChannelLayoutFromChannels(int channels) {
- if (channels == 1) {
- return AV_CH_LAYOUT_MONO;
- }
- if (channels == 2) {
- return AV_CH_LAYOUT_STEREO;
- }
- if (channels == 6) {
- return AV_CH_LAYOUT_5POINT1;
- }
- if (channels == 8) {
- return AV_CH_LAYOUT_7POINT1;
- }
- SB_NOTREACHED() << "Unsupported channel count: " << channels;
- return AV_CH_LAYOUT_STEREO;
-}
-
-int GetSampleFormatBySampleTypeAndStorageType(
- SbMediaAudioSampleType sample_type,
- SbMediaAudioFrameStorageType storage_type) {
- if (sample_type == kSbMediaAudioSampleTypeInt16 &&
- storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
- return AV_SAMPLE_FMT_S16;
- }
- if (sample_type == kSbMediaAudioSampleTypeFloat32 &&
- storage_type == kSbMediaAudioFrameStorageTypeInterleaved) {
- return AV_SAMPLE_FMT_FLT;
- }
- if (sample_type == kSbMediaAudioSampleTypeInt16 &&
- storage_type == kSbMediaAudioFrameStorageTypePlanar) {
- return AV_SAMPLE_FMT_S16P;
- }
- if (sample_type == kSbMediaAudioSampleTypeFloat32 &&
- storage_type == kSbMediaAudioFrameStorageTypePlanar) {
- return AV_SAMPLE_FMT_FLTP;
- }
- SB_NOTREACHED() << "Unsupported sample type (" << sample_type << ") and "
- << " storage type (" << storage_type << ") combination";
- return AV_SAMPLE_FMT_FLT;
-}
-
-} // namespace
-
-AudioResampler::AudioResampler(
- SbMediaAudioSampleType source_sample_type,
- SbMediaAudioFrameStorageType source_storage_type,
- int source_sample_rate,
- SbMediaAudioSampleType destination_sample_type,
- SbMediaAudioFrameStorageType destination_storage_type,
- int destination_sample_rate,
- int channels)
- : source_sample_type_(source_sample_type),
- source_storage_type_(source_storage_type),
- destination_sample_type_(destination_sample_type),
- destination_storage_type_(destination_storage_type),
- destination_sample_rate_(destination_sample_rate),
- channels_(channels),
- start_pts_(-1),
- samples_returned_(0),
- eos_reached_(false) {
- SB_DCHECK(channels_ <= kMaxChannels);
-
- context_ = avresample_alloc_context();
- SB_DCHECK(context_ != NULL);
-
- av_opt_set_int(context_, "in_channel_layout",
- GetChannelLayoutFromChannels(channels_), 0);
- av_opt_set_int(context_, "out_channel_layout",
- GetChannelLayoutFromChannels(channels_), 0);
- av_opt_set_int(context_, "in_sample_rate", source_sample_rate, 0);
- av_opt_set_int(context_, "out_sample_rate", destination_sample_rate, 0);
- av_opt_set_int(context_, "in_sample_fmt",
- GetSampleFormatBySampleTypeAndStorageType(source_sample_type,
- source_storage_type),
- 0);
- av_opt_set_int(context_, "out_sample_fmt",
- GetSampleFormatBySampleTypeAndStorageType(
- destination_sample_type, destination_storage_type),
- 0);
- av_opt_set_int(context_, "internal_sample_fmt", AV_SAMPLE_FMT_S16P, 0);
-
- int result = avresample_open(context_);
- SB_DCHECK(!result);
-}
-
-AudioResampler::~AudioResampler() {
- SB_DCHECK(thread_checker_.CalledOnValidThread());
- avresample_close(context_);
- av_free(context_);
-}
-
-scoped_refptr<AudioResampler::DecodedAudio> AudioResampler::Resample(
- const scoped_refptr<DecodedAudio>& audio_data) {
- SB_DCHECK(thread_checker_.CalledOnValidThread());
- SB_DCHECK(audio_data);
- SB_DCHECK(audio_data->sample_type() == source_sample_type_);
- SB_DCHECK(audio_data->storage_type() == source_storage_type_);
- SB_DCHECK(audio_data->channels() == channels_);
- SB_DCHECK(!eos_reached_);
-
- if (channels_ > kMaxChannels) {
- return new DecodedAudio;
- }
-
- if (eos_reached_) {
- return new DecodedAudio;
- }
-
- if (start_pts_ < 0) {
- start_pts_ = audio_data->pts();
- }
-
- uint8_t* input_buffers[kMaxChannels] = {
- const_cast<uint8_t*>(audio_data->buffer())};
- if (source_storage_type_ == kSbMediaAudioFrameStorageTypePlanar) {
- for (int i = 1; i < channels_; ++i) {
- input_buffers[i] = const_cast<uint8_t*>(
- audio_data->buffer() + audio_data->size() / channels_ * i);
- }
- }
-
- int result = avresample_convert(context_, NULL, 0, 0, input_buffers, 0,
- audio_data->frames());
- SB_DCHECK(result == 0);
-
- return RetrieveOutput();
-}
-
-scoped_refptr<AudioResampler::DecodedAudio> AudioResampler::WriteEndOfStream() {
- SB_DCHECK(thread_checker_.CalledOnValidThread());
- SB_DCHECK(!eos_reached_);
-
- eos_reached_ = true;
- int result = avresample_convert(context_, NULL, 0, 0, NULL, 0, 0);
- SB_DCHECK(result == 0);
-
- return RetrieveOutput();
-}
-
-scoped_refptr<AudioResampler::DecodedAudio> AudioResampler::RetrieveOutput() {
- SB_DCHECK(thread_checker_.CalledOnValidThread());
-
- int frames_in_buffer = avresample_available(context_);
- SbMediaTime pts = start_pts_ + samples_returned_ * kSbMediaTimeSecond /
- destination_sample_rate_;
- int bytes_per_sample =
- starboard::media::GetBytesPerSample(destination_sample_type_);
- scoped_refptr<DecodedAudio> decoded_audio = new DecodedAudio(
- channels_, destination_sample_type_, destination_storage_type_, pts,
- frames_in_buffer * bytes_per_sample * channels_);
- samples_returned_ += frames_in_buffer;
-
- if (frames_in_buffer > 0) {
- uint8_t* output_buffers[kMaxChannels] = {
- const_cast<uint8_t*>(decoded_audio->buffer())};
- if (destination_storage_type_ == kSbMediaAudioFrameStorageTypePlanar) {
- for (int i = 1; i < channels_; ++i) {
- output_buffers[i] = const_cast<uint8_t*>(
- decoded_audio->buffer() + decoded_audio->size() / channels_ * i);
- }
- }
-
- int frames_read =
- avresample_read(context_, output_buffers, frames_in_buffer);
- SB_DCHECK(frames_read == frames_in_buffer);
- }
-
- return decoded_audio;
-}
-
-} // namespace ffmpeg
-
-namespace starboard {
-namespace player {
-namespace filter {
-
-// static
-scoped_ptr<AudioResampler> AudioResampler::Create(
- SbMediaAudioSampleType source_sample_type,
- SbMediaAudioFrameStorageType source_storage_type,
- int source_sample_rate,
- SbMediaAudioSampleType destination_sample_type,
- SbMediaAudioFrameStorageType destination_storage_type,
- int destination_sample_rate,
- int channels) {
- return scoped_ptr<AudioResampler>(new ffmpeg::AudioResampler(
- source_sample_type, source_storage_type, source_sample_rate,
- destination_sample_type, destination_storage_type,
- destination_sample_rate, channels));
-}
-
-} // namespace filter
-} // namespace player
-} // namespace starboard
-
-} // namespace shared
-} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_audio_resampler.h b/src/starboard/shared/ffmpeg/ffmpeg_audio_resampler.h
deleted file mode 100644
index dac58a4..0000000
--- a/src/starboard/shared/ffmpeg/ffmpeg_audio_resampler.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_RESAMPLER_H_
-#define STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_RESAMPLER_H_
-
-#include <queue>
-
-#include "starboard/media.h"
-#include "starboard/shared/ffmpeg/ffmpeg_common.h"
-#include "starboard/shared/internal_only.h"
-#include "starboard/shared/starboard/player/decoded_audio_internal.h"
-#include "starboard/shared/starboard/player/filter/audio_resampler.h"
-#include "starboard/shared/starboard/thread_checker.h"
-
-namespace starboard {
-namespace shared {
-namespace ffmpeg {
-
-class AudioResampler : public starboard::player::filter::AudioResampler {
- public:
- AudioResampler(SbMediaAudioSampleType source_sample_type,
- SbMediaAudioFrameStorageType source_storage_type,
- int source_sample_rate,
- SbMediaAudioSampleType destination_sample_type,
- SbMediaAudioFrameStorageType destination_storage_type,
- int destination_sample_rate,
- int channels);
- ~AudioResampler() override;
-
- scoped_refptr<DecodedAudio> Resample(
- const scoped_refptr<DecodedAudio>& audio_data) override;
- scoped_refptr<DecodedAudio> WriteEndOfStream() override;
-
- private:
- scoped_refptr<DecodedAudio> RetrieveOutput();
-
- shared::starboard::ThreadChecker thread_checker_;
-
- SbMediaAudioSampleType source_sample_type_;
- SbMediaAudioFrameStorageType source_storage_type_;
- SbMediaAudioSampleType destination_sample_type_;
- SbMediaAudioFrameStorageType destination_storage_type_;
- int destination_sample_rate_; // Used for timestamp adjustment.
- int channels_;
- SbMediaTime start_pts_;
- int samples_returned_;
- bool eos_reached_;
- AVAudioResampleContext* context_;
-};
-
-} // namespace ffmpeg
-} // namespace shared
-} // namespace starboard
-
-#endif // STARBOARD_SHARED_FFMPEG_FFMPEG_AUDIO_RESAMPLER_H_
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_common.cc b/src/starboard/shared/ffmpeg/ffmpeg_common.cc
deleted file mode 100644
index b3fd3b6..0000000
--- a/src/starboard/shared/ffmpeg/ffmpeg_common.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "starboard/shared/ffmpeg/ffmpeg_common.h"
-
-#include "starboard/log.h"
-#include "starboard/mutex.h"
-#include "starboard/once.h"
-
-namespace starboard {
-namespace shared {
-namespace ffmpeg {
-
-namespace {
-
-SbOnceControl ffmpeg_initialization_once = SB_ONCE_INITIALIZER;
-SbMutex codec_mutex = SB_MUTEX_INITIALIZER;
-
-} // namespace
-
-void InitializeFfmpeg() {
- bool initialized = SbOnce(&ffmpeg_initialization_once, av_register_all);
- SB_DCHECK(initialized);
-}
-
-int OpenCodec(AVCodecContext* codec_context, const AVCodec* codec) {
- SbMutexAcquire(&codec_mutex);
- int result = avcodec_open2(codec_context, codec, NULL);
- SbMutexRelease(&codec_mutex);
- return result;
-}
-
-void CloseCodec(AVCodecContext* codec_context) {
- SbMutexAcquire(&codec_mutex);
- avcodec_close(codec_context);
- SbMutexRelease(&codec_mutex);
-}
-
-} // namespace ffmpeg
-} // namespace shared
-} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_common.h b/src/starboard/shared/ffmpeg/ffmpeg_common.h
index 9c63c1d..86f0169 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_common.h
+++ b/src/starboard/shared/ffmpeg/ffmpeg_common.h
@@ -37,22 +37,23 @@
#define PIX_FMT_YUVJ420P AV_PIX_FMT_YUVJ420P
#endif // LIBAVUTIL_VERSION_MAJOR > 52
-namespace starboard {
-namespace shared {
-namespace ffmpeg {
+#if !defined(LIBAVCODEC_VERSION_MAJOR)
+#error "LIBAVCODEC_VERSION_MAJOR not defined"
+#endif // !defined(LIBAVCODEC_VERSION_MAJOR)
-void InitializeFfmpeg();
+#if !defined(LIBAVCODEC_VERSION_MICRO)
+#error "LIBAVCODEC_VERSION_MICRO not defined"
+#endif // !defined(LIBAVCODEC_VERSION_MICRO)
-// In Ffmpeg, the calls to avcodec_open2() and avcodec_close() are not
-// synchronized internally so it is the responsibility of its user to ensure
-// that these calls don't overlap. The following functions acquires a lock
-// internally before calling avcodec_open2() and avcodec_close() to enforce
-// this.
-int OpenCodec(AVCodecContext* codec_context, const AVCodec* codec);
-void CloseCodec(AVCodecContext* codec_context);
+#if LIBAVCODEC_VERSION_MICRO >= 100
+#define LIBAVCODEC_LIBRARY_IS_FFMPEG 1
+#else
+#define LIBAVCODEC_LIBRARY_IS_FFMPEG 0
+#endif // LIBAVCODEC_VERSION_MICRO >= 100
-} // namespace ffmpeg
-} // namespace shared
-} // namespace starboard
+// Use the major version number of libavcodec plus a single digit distinguishing
+// between ffmpeg and libav as the template parameter for the
+// explicit specialization of the audio and video decoder classes.
+#define FFMPEG ((LIBAVCODEC_VERSION_MAJOR * 10) + LIBAVCODEC_LIBRARY_IS_FFMPEG)
#endif // STARBOARD_SHARED_FFMPEG_FFMPEG_COMMON_H_
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_dispatch.cc b/src/starboard/shared/ffmpeg/ffmpeg_dispatch.cc
new file mode 100644
index 0000000..384baf2
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_dispatch.cc
@@ -0,0 +1,47 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file implements the FFMPEGDispatch interface with dynamic loading of
+// the libraries.
+
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+
+#include "starboard/mutex.h"
+#include "starboard/once.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+namespace {
+SbMutex g_codec_mutex = SB_MUTEX_INITIALIZER;
+} // namespace
+
+int FFMPEGDispatch::OpenCodec(AVCodecContext* codec_context,
+ const AVCodec* codec) {
+ SbMutexAcquire(&g_codec_mutex);
+ int result = avcodec_open2(codec_context, codec, NULL);
+ SbMutexRelease(&g_codec_mutex);
+ return result;
+}
+
+void FFMPEGDispatch::CloseCodec(AVCodecContext* codec_context) {
+ SbMutexAcquire(&g_codec_mutex);
+ avcodec_close(codec_context);
+ SbMutexRelease(&g_codec_mutex);
+}
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_dispatch.h b/src/starboard/shared/ffmpeg/ffmpeg_dispatch.h
new file mode 100644
index 0000000..4d1713f
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_dispatch.h
@@ -0,0 +1,114 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This class defines an interface for dispatching calls to the ffmpeg
+// libraries.
+
+#ifndef STARBOARD_SHARED_FFMPEG_FFMPEG_DISPATCH_H_
+#define STARBOARD_SHARED_FFMPEG_FFMPEG_DISPATCH_H_
+
+#include "starboard/mutex.h"
+#include "starboard/types.h"
+
+struct AVCodec;
+struct AVCodecContext;
+struct AVDictionary;
+struct AVFrame;
+struct AVPacket;
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+class FFMPEGDispatch {
+ public:
+ FFMPEGDispatch();
+ ~FFMPEGDispatch();
+
+ static FFMPEGDispatch* GetInstance();
+
+ // Register an ffmpeg decoder specialization for the given combination of
+ // major versions of the libavcodec, libavformat, and libavutil libraries.
+ // Returns true if the specialization did not exist yet, or if it matched
+ // an already existing registration.
+ static bool RegisterSpecialization(int specialization,
+ int avcodec,
+ int avformat,
+ int avutil);
+
+ bool is_valid() const;
+
+ unsigned (*avutil_version)(void);
+ void* (*av_malloc)(size_t size);
+ void (*av_freep)(void* ptr);
+ AVFrame* (*av_frame_alloc)(void);
+ void (*av_frame_unref)(AVFrame* frame);
+ int (*av_samples_get_buffer_size)(int* linesize,
+ int nb_channels,
+ int nb_samples,
+ int sample_fmt,
+ int align);
+ int (*av_opt_set_int)(void* obj,
+ const char* name,
+ int64_t val,
+ int search_flags);
+ int (*av_image_check_size)(unsigned int w,
+ unsigned int h,
+ int log_offset,
+ void* log_ctx);
+ void* (*av_buffer_create)(uint8_t* data,
+ int size,
+ void (*free)(void* opaque, uint8_t* data),
+ void* opaque,
+ int flags);
+
+ unsigned (*avcodec_version)(void);
+ AVCodecContext* (*avcodec_alloc_context3)(const AVCodec* codec);
+ AVCodec* (*avcodec_find_decoder)(int id);
+ int (*avcodec_close)(AVCodecContext* avctx);
+ int (*avcodec_open2)(AVCodecContext* avctx,
+ const AVCodec* codec,
+ AVDictionary** options);
+ void (*av_init_packet)(AVPacket* pkt);
+ int (*avcodec_decode_audio4)(AVCodecContext* avctx,
+ AVFrame* frame,
+ int* got_frame_ptr,
+ const AVPacket* avpkt);
+ int (*avcodec_decode_video2)(AVCodecContext* avctx,
+ AVFrame* picture,
+ int* got_picture_ptr,
+ const AVPacket* avpkt);
+ void (*avcodec_flush_buffers)(AVCodecContext* avctx);
+ AVFrame* (*avcodec_alloc_frame)(void);
+ void (*avcodec_get_frame_defaults)(AVFrame* frame);
+
+ unsigned (*avformat_version)(void);
+ void (*av_register_all)(void);
+
+ int specialization_version() const;
+
+ // In Ffmpeg, the calls to avcodec_open2() and avcodec_close() are not
+ // synchronized internally so it is the responsibility of its user to ensure
+ // that these calls don't overlap. The following functions acquires a lock
+ // internally before calling avcodec_open2() and avcodec_close() to enforce
+ // this.
+ int OpenCodec(AVCodecContext* codec_context, const AVCodec* codec);
+ void CloseCodec(AVCodecContext* codec_context);
+};
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_SHARED_FFMPEG_FFMPEG_DISPATCH_H_
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_audio_decoder_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_audio_decoder_impl.cc
new file mode 100644
index 0000000..2a8dcaf
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_audio_decoder_impl.cc
@@ -0,0 +1,60 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains the creation of the specialized AudioDecoderImpl object
+// corresponding to the version of the dynamically loaded ffmpeg library.
+
+#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder.h"
+
+#include "starboard/memory.h"
+#include "starboard/player.h"
+#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+// static
+AudioDecoder* AudioDecoder::Create(SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header) {
+ FFMPEGDispatch* ffmpeg = FFMPEGDispatch::GetInstance();
+ if (!ffmpeg || !ffmpeg->is_valid()) {
+ SB_NOTREACHED();
+ return NULL;
+ }
+
+ AudioDecoder* audio_decoder = NULL;
+ switch (ffmpeg->specialization_version()) {
+ case 540:
+ audio_decoder = AudioDecoderImpl<540>::Create(audio_codec, audio_header);
+ break;
+ case 550:
+ case 560:
+ audio_decoder = AudioDecoderImpl<560>::Create(audio_codec, audio_header);
+ break;
+ case 571:
+ audio_decoder = AudioDecoderImpl<571>::Create(audio_codec, audio_header);
+ break;
+ default:
+ SB_NOTREACHED() << "Unsupported FFMPEG specialization " << std::hex
+ << ffmpeg->specialization_version();
+ break;
+ }
+ return audio_decoder;
+}
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc
new file mode 100644
index 0000000..8afa042
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc
@@ -0,0 +1,279 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file implements the FFMPEGDispatch interface with dynamic loading of
+// the libraries.
+
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+
+#include <dlfcn.h>
+#include <map>
+
+#include "starboard/common/scoped_ptr.h"
+#include "starboard/log.h"
+#include "starboard/once.h"
+#include "starboard/shared/starboard/lazy_initialization_internal.h"
+#include "starboard/string.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+namespace {
+
+const char kAVCodecLibraryName[] = "libavcodec.so";
+const char kAVFormatLibraryName[] = "libavformat.so";
+const char kAVUtilLibraryName[] = "libavutil.so";
+
+SbOnceControl g_dynamic_load_once = SB_ONCE_INITIALIZER;
+
+struct LibraryMajorVersions {
+ int avcodec;
+ int avformat;
+ int avutil;
+ LibraryMajorVersions(int avcodec, int avformat, int avutil)
+ : avcodec(avcodec), avformat(avformat), avutil(avutil) {}
+};
+
+// Map containing the major version for all combinations of libraries in
+// supported ffmpeg installations. The index is the specialization version
+// matching the template parameter for the available specialization.
+typedef std::map<int, LibraryMajorVersions> LibraryMajorVersionsMap;
+
+class FFMPEGDispatchImpl {
+ public:
+ FFMPEGDispatchImpl();
+ ~FFMPEGDispatchImpl();
+
+ static FFMPEGDispatchImpl* GetInstance();
+
+ bool RegisterSpecialization(int specialization,
+ int avcodec,
+ int avformat,
+ int avutil);
+
+ bool is_valid() const { return avcodec_ && avformat_ && avutil_; }
+
+ FFMPEGDispatch* get_ffmpeg_dispatch();
+
+ private:
+ SbMutex mutex_;
+ FFMPEGDispatch* ffmpeg_;
+ // Load the ffmpeg shared libraries, return true if successful.
+ bool OpenLibraries();
+ // Load the symbols from the shared libraries.
+ void LoadSymbols();
+
+ void* avcodec_;
+ void* avformat_;
+ void* avutil_;
+ LibraryMajorVersionsMap versions_;
+};
+
+FFMPEGDispatchImpl* g_ffmpeg_dispatch_impl;
+
+void construct_ffmpeg_dispatch_impl() {
+ g_ffmpeg_dispatch_impl = new FFMPEGDispatchImpl();
+}
+
+FFMPEGDispatchImpl::FFMPEGDispatchImpl()
+ : mutex_(SB_MUTEX_INITIALIZER),
+ ffmpeg_(NULL),
+ avcodec_(NULL),
+ avformat_(NULL),
+ avutil_(NULL) {}
+
+FFMPEGDispatchImpl::~FFMPEGDispatchImpl() {
+ delete ffmpeg_;
+ if (avformat_) {
+ dlclose(avformat_);
+ }
+ if (avcodec_) {
+ dlclose(avcodec_);
+ }
+ if (avutil_) {
+ dlclose(avutil_);
+ }
+}
+
+// static
+FFMPEGDispatchImpl* FFMPEGDispatchImpl::GetInstance() {
+ bool initialized =
+ SbOnce(&g_dynamic_load_once, construct_ffmpeg_dispatch_impl);
+ SB_DCHECK(initialized);
+ return g_ffmpeg_dispatch_impl;
+}
+
+bool FFMPEGDispatchImpl::RegisterSpecialization(int specialization,
+ int avcodec,
+ int avformat,
+ int avutil) {
+ SbMutexAcquire(&mutex_);
+ auto result = versions_.insert(std::make_pair(
+ specialization, LibraryMajorVersions(avcodec, avformat, avutil)));
+ bool success = result.second;
+ if (!success) {
+ // Element was not inserted because an entry with the same key already
+ // exists. Registration is still successful if the parameters are the same.
+ const LibraryMajorVersions& existing_versions = result.first->second;
+ success = existing_versions.avcodec == avcodec &&
+ existing_versions.avformat == avformat &&
+ existing_versions.avutil == avutil;
+ }
+ SbMutexRelease(&mutex_);
+ return success;
+}
+
+FFMPEGDispatch* FFMPEGDispatchImpl::get_ffmpeg_dispatch() {
+ SbMutexAcquire(&mutex_);
+ if (!ffmpeg_) {
+ ffmpeg_ = new FFMPEGDispatch();
+ // Dynamically load the libraries and retrieve the function pointers.
+ if (OpenLibraries()) {
+ LoadSymbols();
+ ffmpeg_->av_register_all();
+ }
+ }
+ SbMutexRelease(&mutex_);
+ return ffmpeg_;
+}
+
+const int kMaxVersionedLibraryNameLength = 32;
+
+std::string GetVersionedLibraryName(const char* name, const int version) {
+ char s[kMaxVersionedLibraryNameLength];
+ SbStringFormatF(s, kMaxVersionedLibraryNameLength, "%s.%d", name, version);
+ return std::string(s);
+}
+
+bool FFMPEGDispatchImpl::OpenLibraries() {
+ for (auto version_iterator = versions_.rbegin();
+ version_iterator != versions_.rend(); ++version_iterator) {
+ LibraryMajorVersions& versions = version_iterator->second;
+ avutil_ = dlopen(
+ GetVersionedLibraryName(kAVUtilLibraryName, versions.avutil).c_str(),
+ RTLD_NOW | RTLD_GLOBAL);
+ if (!avutil_) {
+ SB_DLOG(WARNING) << "Unable to open shared library "
+ << kAVUtilLibraryName;
+ continue;
+ }
+
+ avcodec_ = dlopen(
+ GetVersionedLibraryName(kAVCodecLibraryName, versions.avcodec).c_str(),
+ RTLD_NOW | RTLD_GLOBAL);
+ if (!avcodec_) {
+ SB_DLOG(WARNING) << "Unable to open shared library "
+ << kAVCodecLibraryName;
+ dlclose(avutil_);
+ avutil_ = NULL;
+ continue;
+ }
+
+ avformat_ =
+ dlopen(GetVersionedLibraryName(kAVFormatLibraryName, versions.avformat)
+ .c_str(),
+ RTLD_NOW | RTLD_GLOBAL);
+ if (!avformat_) {
+ SB_DLOG(WARNING) << "Unable to open shared library "
+ << kAVFormatLibraryName;
+ dlclose(avcodec_);
+ avcodec_ = NULL;
+ dlclose(avutil_);
+ avutil_ = NULL;
+ continue;
+ }
+ SB_DCHECK(is_valid());
+ break;
+ }
+ return is_valid();
+}
+
+void FFMPEGDispatchImpl::LoadSymbols() {
+ SB_DCHECK(is_valid());
+// Load the desired symbols from the shared libraries. Note: If a symbol is
+// listed as a '.text' entry in the output of 'objdump -T' on the shared
+// library file, then it is directly available from it.
+
+#define INITSYMBOL(library, symbol) \
+ ffmpeg_->symbol = reinterpret_cast<decltype(FFMPEGDispatch::symbol)>( \
+ dlsym(library, #symbol));
+
+ // Load symbols from the avutil shared library.
+ INITSYMBOL(avutil_, avutil_version);
+ SB_DCHECK(ffmpeg_->avutil_version);
+ INITSYMBOL(avutil_, av_malloc);
+ INITSYMBOL(avutil_, av_freep);
+ INITSYMBOL(avutil_, av_frame_alloc);
+ INITSYMBOL(avutil_, av_frame_unref);
+ INITSYMBOL(avutil_, av_samples_get_buffer_size);
+ INITSYMBOL(avutil_, av_opt_set_int);
+ INITSYMBOL(avutil_, av_image_check_size);
+ INITSYMBOL(avutil_, av_buffer_create);
+
+ // Load symbols from the avcodec shared library.
+ INITSYMBOL(avcodec_, avcodec_version);
+ SB_DCHECK(ffmpeg_->avcodec_version);
+ INITSYMBOL(avcodec_, avcodec_alloc_context3);
+ INITSYMBOL(avcodec_, avcodec_find_decoder);
+ INITSYMBOL(avcodec_, avcodec_close);
+ INITSYMBOL(avcodec_, avcodec_open2);
+ INITSYMBOL(avcodec_, av_init_packet);
+ INITSYMBOL(avcodec_, avcodec_decode_audio4);
+ INITSYMBOL(avcodec_, avcodec_decode_video2);
+ INITSYMBOL(avcodec_, avcodec_flush_buffers);
+ INITSYMBOL(avcodec_, avcodec_alloc_frame);
+ INITSYMBOL(avcodec_, avcodec_get_frame_defaults);
+
+ // Load symbols from the avformat shared library.
+ INITSYMBOL(avformat_, avformat_version);
+ SB_DCHECK(ffmpeg_->avformat_version);
+ INITSYMBOL(avformat_, av_register_all);
+ SB_DCHECK(ffmpeg_->av_register_all);
+
+#undef INITSYMBOL
+}
+} // namespace
+
+FFMPEGDispatch::FFMPEGDispatch() {}
+FFMPEGDispatch::~FFMPEGDispatch() {}
+
+// static
+FFMPEGDispatch* FFMPEGDispatch::GetInstance() {
+ return FFMPEGDispatchImpl::GetInstance()->get_ffmpeg_dispatch();
+}
+
+// static
+bool FFMPEGDispatch::RegisterSpecialization(int specialization,
+ int avcodec,
+ int avformat,
+ int avutil) {
+ return FFMPEGDispatchImpl::GetInstance()->RegisterSpecialization(
+ specialization, avcodec, avformat, avutil);
+}
+
+bool FFMPEGDispatch::is_valid() const {
+ return FFMPEGDispatchImpl::GetInstance()->is_valid();
+}
+
+int FFMPEGDispatch::specialization_version() const {
+ // Return the specialization version, which is the major version of the
+ // avcodec library plus a single digit indicating if it's ffmpeg or libav,
+ // derived from the libavcodec micro version number.
+ return (avcodec_version() >> 16) * 10 + ((avcodec_version() & 0xFF) >= 100);
+}
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_video_decoder_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_video_decoder_impl.cc
new file mode 100644
index 0000000..7825b72
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_dynamic_load_video_decoder_impl.cc
@@ -0,0 +1,65 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains the creation of the specialized VideoDecoderImpl object
+// corresponding to the version of the dynamically loaded ffmpeg library.
+
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder.h"
+
+#include "starboard/memory.h"
+#include "starboard/player.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+// static
+VideoDecoder* VideoDecoder::Create(
+ SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider) {
+ FFMPEGDispatch* ffmpeg = FFMPEGDispatch::GetInstance();
+ if (!ffmpeg || !ffmpeg->is_valid()) {
+ SB_NOTREACHED();
+ return NULL;
+ }
+
+ VideoDecoder* video_decoder = NULL;
+ switch (ffmpeg->specialization_version()) {
+ case 540:
+ video_decoder = VideoDecoderImpl<540>::Create(
+ video_codec, output_mode, decode_target_graphics_context_provider);
+ break;
+ case 550:
+ case 560:
+ video_decoder = VideoDecoderImpl<560>::Create(
+ video_codec, output_mode, decode_target_graphics_context_provider);
+ break;
+ case 571:
+ video_decoder = VideoDecoderImpl<571>::Create(
+ video_codec, output_mode, decode_target_graphics_context_provider);
+ break;
+ default:
+ SB_NOTREACHED() << "Unsupported FFMPEG version " << std::hex
+ << ffmpeg->avutil_version();
+ break;
+ }
+ return video_decoder;
+}
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_linked_audio_decoder_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_linked_audio_decoder_impl.cc
new file mode 100644
index 0000000..7c667b3
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_linked_audio_decoder_impl.cc
@@ -0,0 +1,42 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains the creation of the specialized AudioDecoderImpl object
+// corresponding to the version of the linked ffmpeg library.
+
+#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder.h"
+
+#include "starboard/memory.h"
+#include "starboard/player.h"
+#include "starboard/shared/ffmpeg/ffmpeg_audio_decoder_impl.h"
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+// static
+AudioDecoder* AudioDecoder::Create(SbMediaAudioCodec audio_codec,
+ const SbMediaAudioHeader& audio_header) {
+ FFMPEGDispatch* ffmpeg = FFMPEGDispatch::GetInstance();
+ SB_DCHECK(ffmpeg && ffmpeg->is_valid());
+ SB_DCHECK(FFMPEG == ffmpeg->specialization_version());
+
+ return AudioDecoderImpl<FFMPEG>::Create(audio_codec, audio_header);
+}
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_linked_dispatch_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_linked_dispatch_impl.cc
new file mode 100644
index 0000000..181e224
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_linked_dispatch_impl.cc
@@ -0,0 +1,128 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file implements the FFMPEGDispatch interface for a library linked
+// directly, or which the symbols are already available in the global namespace.
+
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+
+#include <dlfcn.h>
+#include <map>
+
+#include "starboard/common/scoped_ptr.h"
+#include "starboard/log.h"
+#include "starboard/once.h"
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/starboard/lazy_initialization_internal.h"
+#include "starboard/string.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+namespace {
+
+FFMPEGDispatch* g_ffmpeg_dispatch_impl;
+SbOnceControl g_construct_ffmpeg_dispatch_once = SB_ONCE_INITIALIZER;
+
+void construct_ffmpeg_dispatch() {
+ g_ffmpeg_dispatch_impl = new FFMPEGDispatch();
+}
+
+void LoadSymbols(FFMPEGDispatch* ffmpeg) {
+ SB_DCHECK(ffmpeg->is_valid());
+// Load the desired symbols from the shared libraries. Note: If a symbol is
+// listed as a '.text' entry in the output of 'objdump -T' on the shared
+// library file, then it is directly available from it.
+
+#define INITSYMBOL(symbol) \
+ ffmpeg->symbol = reinterpret_cast<decltype(FFMPEGDispatch::symbol)>(symbol);
+
+ // Load symbols from the avutil shared library.
+ INITSYMBOL(avutil_version);
+ SB_DCHECK(ffmpeg->avutil_version);
+ INITSYMBOL(av_malloc);
+ INITSYMBOL(av_freep);
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ INITSYMBOL(av_frame_alloc);
+ INITSYMBOL(av_frame_unref);
+#endif
+ INITSYMBOL(av_samples_get_buffer_size);
+ INITSYMBOL(av_opt_set_int);
+ INITSYMBOL(av_image_check_size);
+ INITSYMBOL(av_buffer_create);
+
+ // Load symbols from the avcodec shared library.
+ INITSYMBOL(avcodec_version);
+ SB_DCHECK(ffmpeg->avcodec_version);
+ INITSYMBOL(avcodec_alloc_context3);
+ INITSYMBOL(avcodec_find_decoder);
+ INITSYMBOL(avcodec_close);
+ INITSYMBOL(avcodec_open2);
+ INITSYMBOL(av_init_packet);
+ INITSYMBOL(avcodec_decode_audio4);
+ INITSYMBOL(avcodec_decode_video2);
+ INITSYMBOL(avcodec_flush_buffers);
+#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(52, 8, 0)
+ INITSYMBOL(avcodec_alloc_frame);
+ INITSYMBOL(avcodec_get_frame_defaults);
+#endif
+
+ // Load symbols from the avformat shared library.
+ INITSYMBOL(avformat_version);
+ SB_DCHECK(ffmpeg->avformat_version);
+ INITSYMBOL(av_register_all);
+ SB_DCHECK(ffmpeg->av_register_all);
+
+#undef INITSYMBOL
+}
+} // namespace
+
+FFMPEGDispatch::FFMPEGDispatch() {
+ LoadSymbols(this);
+ av_register_all();
+}
+
+FFMPEGDispatch::~FFMPEGDispatch() {}
+
+// static
+FFMPEGDispatch* FFMPEGDispatch::GetInstance() {
+ bool initialized =
+ SbOnce(&g_construct_ffmpeg_dispatch_once, construct_ffmpeg_dispatch);
+ SB_DCHECK(initialized);
+ return g_ffmpeg_dispatch_impl;
+}
+
+// static
+bool FFMPEGDispatch::RegisterSpecialization(int specialization,
+ int avcodec,
+ int avformat,
+ int avutil) {
+ // There is always only a single version of the library linked to the
+ // application, so there is no need to explicitly track multiple versions.
+ return true;
+}
+
+bool FFMPEGDispatch::is_valid() const {
+ // Loading of a linked library is always successful.
+ return true;
+}
+
+int FFMPEGDispatch::specialization_version() const {
+ // There is only one version of ffmpeg linked to the binary.
+ return FFMPEG;
+}
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_linked_video_decoder_impl.cc b/src/starboard/shared/ffmpeg/ffmpeg_linked_video_decoder_impl.cc
new file mode 100644
index 0000000..eb13a07
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_linked_video_decoder_impl.cc
@@ -0,0 +1,45 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains the creation of the specialized VideoDecoderImpl object
+// corresponding to the version of the linked ffmpeg library.
+
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder.h"
+
+#include "starboard/memory.h"
+#include "starboard/player.h"
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+// static
+VideoDecoder* VideoDecoder::Create(
+ SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider) {
+ FFMPEGDispatch* ffmpeg = FFMPEGDispatch::GetInstance();
+ SB_DCHECK(ffmpeg && ffmpeg->is_valid());
+ SB_DCHECK(FFMPEG == ffmpeg->specialization_version());
+
+ return VideoDecoderImpl<FFMPEG>::Create(
+ video_codec, output_mode, decode_target_graphics_context_provider);
+}
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.h b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.h
index 83a527b..64227c5 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.h
+++ b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.h
@@ -15,16 +15,10 @@
#ifndef STARBOARD_SHARED_FFMPEG_FFMPEG_VIDEO_DECODER_H_
#define STARBOARD_SHARED_FFMPEG_FFMPEG_VIDEO_DECODER_H_
-#include "starboard/common/ref_counted.h"
-#include "starboard/log.h"
#include "starboard/media.h"
-#include "starboard/queue.h"
-#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/player.h"
#include "starboard/shared/internal_only.h"
-#include "starboard/shared/starboard/player/filter/cpu_video_frame.h"
#include "starboard/shared/starboard/player/filter/video_decoder_internal.h"
-#include "starboard/shared/starboard/player/input_buffer_internal.h"
-#include "starboard/thread.h"
namespace starboard {
namespace shared {
@@ -32,98 +26,14 @@
class VideoDecoder : public starboard::player::filter::VideoDecoder {
public:
- VideoDecoder(SbMediaVideoCodec video_codec,
- SbPlayerOutputMode output_mode,
- SbDecodeTargetGraphicsContextProvider*
- decode_target_graphics_context_provider);
- ~VideoDecoder() override;
+ // Create a video decoder for the currently loaded ffmpeg library.
+ static VideoDecoder* Create(SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider);
- void Initialize(const DecoderStatusCB& decoder_status_cb,
- const ErrorCB& error_cb) override;
- size_t GetPrerollFrameCount() const override { return 8; }
- SbTime GetPrerollTimeout() const override { return kSbTimeMax; }
-
- void WriteInputBuffer(const scoped_refptr<InputBuffer>& input_buffer)
- override;
- void WriteEndOfStream() override;
- void Reset() override;
-
- bool is_valid() const { return codec_context_ != NULL; }
-
- private:
- typedef ::starboard::shared::starboard::player::filter::CpuVideoFrame
- CpuVideoFrame;
-
- enum EventType {
- kInvalid,
- kReset,
- kWriteInputBuffer,
- kWriteEndOfStream,
- };
-
- struct Event {
- EventType type;
- // |input_buffer| is only used when |type| is kWriteInputBuffer.
- scoped_refptr<InputBuffer> input_buffer;
-
- explicit Event(EventType type = kInvalid) : type(type) {
- SB_DCHECK(type != kWriteInputBuffer);
- }
-
- explicit Event(const scoped_refptr<InputBuffer>& input_buffer)
- : type(kWriteInputBuffer), input_buffer(input_buffer) {}
- };
-
- static void* ThreadEntryPoint(void* context);
- void DecoderThreadFunc();
-
- bool DecodePacket(AVPacket* packet);
- void InitializeCodec();
- void TeardownCodec();
- SbDecodeTarget GetCurrentDecodeTarget() override;
-
- bool UpdateDecodeTarget(const scoped_refptr<CpuVideoFrame>& frame);
-
- // |video_codec_| will be initialized inside ctor and won't be changed during
- // the life time of this class.
- const SbMediaVideoCodec video_codec_;
- // The following callbacks will be initialized in Initialize() and won't be
- // changed during the life time of this class.
- DecoderStatusCB decoder_status_cb_;
- ErrorCB error_cb_;
-
- Queue<Event> queue_;
-
- // The AV related classes will only be created and accessed on the decoder
- // thread.
- AVCodecContext* codec_context_;
- AVFrame* av_frame_;
-
- bool stream_ended_;
- bool error_occured_;
-
- // Working thread to avoid lengthy decoding work block the player thread.
- SbThread decoder_thread_;
-
- // Decode-to-texture related state.
- SbPlayerOutputMode output_mode_;
-
- SbDecodeTargetGraphicsContextProvider*
- decode_target_graphics_context_provider_;
-
- // If decode-to-texture is enabled, then we store the decode target texture
- // inside of this |decode_target_| member.
- SbDecodeTarget decode_target_;
-
- // GetCurrentDecodeTarget() needs to be called from an arbitrary thread
- // to obtain the current decode target (which ultimately ends up being a
- // copy of |decode_target_|), we need to safe-guard access to |decode_target_|
- // and we do so through this mutex.
- Mutex decode_target_mutex_;
- // Mutex frame_mutex_;
-
- // int frame_last_rendered_pts_;
- // scoped_refptr<VideoFrame> frame_;
+ // Returns true if the video decoder is initialized successfully.
+ virtual bool is_valid() const = 0;
};
} // namespace ffmpeg
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.cc
similarity index 65%
rename from src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
rename to src/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.cc
index 3def412..233b93e 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
+++ b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.cc
@@ -1,4 +1,4 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
+// Copyright 2018 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -12,7 +12,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "starboard/shared/ffmpeg/ffmpeg_video_decoder.h"
+// This file contains the explicit specialization of the VideoDecoderImpl class
+// for the value 'FFMPEG'.
+
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h"
#include "starboard/linux/shared/decode_target_internal.h"
#include "starboard/memory.h"
@@ -39,21 +42,365 @@
return width * height * 3 / 2;
}
-#if LIBAVUTIL_VERSION_MAJOR > 52
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
void ReleaseBuffer(void* opaque, uint8_t* data) {
SbMemoryDeallocate(data);
}
-int AllocateBuffer(AVCodecContext* codec_context, AVFrame* frame, int flags) {
+int AllocateBufferCallback(AVCodecContext* codec_context,
+ AVFrame* frame,
+ int flags) {
+ VideoDecoderImpl<FFMPEG>* video_decoder =
+ static_cast<VideoDecoderImpl<FFMPEG>*>(codec_context->opaque);
+ return video_decoder->AllocateBuffer(codec_context, frame, flags);
+}
+
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+
+int AllocateBufferCallback(AVCodecContext* codec_context, AVFrame* frame) {
+ VideoDecoderImpl<FFMPEG>* video_decoder =
+ static_cast<VideoDecoderImpl<FFMPEG>*>(codec_context->opaque);
+ return video_decoder->AllocateBuffer(codec_context, frame);
+}
+
+void ReleaseBuffer(AVCodecContext*, AVFrame* frame) {
+ SbMemoryDeallocate(frame->opaque);
+ frame->opaque = NULL;
+
+ // The FFmpeg API expects us to zero the data pointers in this callback.
+ SbMemorySet(frame->data, 0, sizeof(frame->data));
+}
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+
+const bool g_registered =
+ FFMPEGDispatch::RegisterSpecialization(FFMPEG,
+ LIBAVCODEC_VERSION_MAJOR,
+ LIBAVFORMAT_VERSION_MAJOR,
+ LIBAVUTIL_VERSION_MAJOR);
+
+} // namespace
+
+VideoDecoderImpl<FFMPEG>::VideoDecoderImpl(
+ SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider)
+ : video_codec_(video_codec),
+ codec_context_(NULL),
+ av_frame_(NULL),
+ stream_ended_(false),
+ error_occured_(false),
+ decoder_thread_(kSbThreadInvalid),
+ output_mode_(output_mode),
+ decode_target_graphics_context_provider_(
+ decode_target_graphics_context_provider),
+ decode_target_(kSbDecodeTargetInvalid) {
+ SB_DCHECK(g_registered) << "Decoder Specialization registration failed.";
+ ffmpeg_ = FFMPEGDispatch::GetInstance();
+ SB_DCHECK(ffmpeg_);
+ if ((ffmpeg_->specialization_version()) == FFMPEG) {
+ InitializeCodec();
+ }
+}
+
+VideoDecoderImpl<FFMPEG>::~VideoDecoderImpl() {
+ Reset();
+ TeardownCodec();
+}
+
+// static
+VideoDecoder* VideoDecoderImpl<FFMPEG>::Create(
+ SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider) {
+ return new VideoDecoderImpl<FFMPEG>(video_codec, output_mode,
+ decode_target_graphics_context_provider);
+}
+
+void VideoDecoderImpl<FFMPEG>::Initialize(
+ const DecoderStatusCB& decoder_status_cb,
+ const ErrorCB& error_cb) {
+ SB_DCHECK(decoder_status_cb);
+ SB_DCHECK(!decoder_status_cb_);
+ SB_DCHECK(error_cb);
+ SB_DCHECK(!error_cb_);
+
+ decoder_status_cb_ = decoder_status_cb;
+ error_cb_ = error_cb;
+}
+
+void VideoDecoderImpl<FFMPEG>::WriteInputBuffer(
+ const scoped_refptr<InputBuffer>& input_buffer) {
+ SB_DCHECK(input_buffer);
+ SB_DCHECK(queue_.Poll().type == kInvalid);
+ SB_DCHECK(decoder_status_cb_);
+
+ if (stream_ended_) {
+ SB_LOG(ERROR) << "WriteInputFrame() was called after WriteEndOfStream().";
+ return;
+ }
+
+ if (!SbThreadIsValid(decoder_thread_)) {
+ decoder_thread_ = SbThreadCreate(
+ 0, kSbThreadPriorityHigh, kSbThreadNoAffinity, true, "ff_video_dec",
+ &VideoDecoderImpl<FFMPEG>::ThreadEntryPoint, this);
+ SB_DCHECK(SbThreadIsValid(decoder_thread_));
+ }
+
+ queue_.Put(Event(input_buffer));
+}
+
+void VideoDecoderImpl<FFMPEG>::WriteEndOfStream() {
+ SB_DCHECK(decoder_status_cb_);
+
+ // We have to flush the decoder to decode the rest frames and to ensure that
+ // Decode() is not called when the stream is ended.
+ stream_ended_ = true;
+
+ if (!SbThreadIsValid(decoder_thread_)) {
+ // In case there is no WriteInputBuffer() call before WriteEndOfStream(),
+ // don't create the decoder thread and send the EOS frame directly.
+ decoder_status_cb_(kBufferFull, VideoFrame::CreateEOSFrame());
+ return;
+ }
+
+ queue_.Put(Event(kWriteEndOfStream));
+}
+
+void VideoDecoderImpl<FFMPEG>::Reset() {
+ // Join the thread to ensure that all callbacks in process are finished.
+ if (SbThreadIsValid(decoder_thread_)) {
+ queue_.Put(Event(kReset));
+ SbThreadJoin(decoder_thread_, NULL);
+ }
+
+ if (codec_context_ != NULL) {
+ ffmpeg_->avcodec_flush_buffers(codec_context_);
+ }
+
+ decoder_thread_ = kSbThreadInvalid;
+ stream_ended_ = false;
+
+ if (output_mode_ == kSbPlayerOutputModeDecodeToTexture) {
+ TeardownCodec();
+ InitializeCodec();
+ }
+}
+
+bool VideoDecoderImpl<FFMPEG>::is_valid() const {
+ return (ffmpeg_ != NULL) && ffmpeg_->is_valid() && (codec_context_ != NULL);
+}
+
+// static
+void* VideoDecoderImpl<FFMPEG>::ThreadEntryPoint(void* context) {
+ SB_DCHECK(context);
+ VideoDecoderImpl<FFMPEG>* decoder =
+ reinterpret_cast<VideoDecoderImpl<FFMPEG>*>(context);
+ decoder->DecoderThreadFunc();
+ return NULL;
+}
+
+void VideoDecoderImpl<FFMPEG>::DecoderThreadFunc() {
+ for (;;) {
+ Event event = queue_.Get();
+ if (event.type == kReset) {
+ return;
+ }
+ if (error_occured_) {
+ continue;
+ }
+ if (event.type == kWriteInputBuffer) {
+ // Send |input_buffer| to ffmpeg and try to decode one frame.
+ AVPacket packet;
+ ffmpeg_->av_init_packet(&packet);
+ packet.data = const_cast<uint8_t*>(event.input_buffer->data());
+ packet.size = event.input_buffer->size();
+ packet.pts = event.input_buffer->timestamp();
+ codec_context_->reordered_opaque = packet.pts;
+
+ DecodePacket(&packet);
+ decoder_status_cb_(kNeedMoreInput, NULL);
+ } else {
+ SB_DCHECK(event.type == kWriteEndOfStream);
+ // Stream has ended, try to decode any frames left in ffmpeg.
+ AVPacket packet;
+ do {
+ ffmpeg_->av_init_packet(&packet);
+ packet.data = NULL;
+ packet.size = 0;
+ packet.pts = 0;
+ } while (DecodePacket(&packet));
+
+ decoder_status_cb_(kBufferFull, VideoFrame::CreateEOSFrame());
+ }
+ }
+}
+
+bool VideoDecoderImpl<FFMPEG>::DecodePacket(AVPacket* packet) {
+ SB_DCHECK(packet != NULL);
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ ffmpeg_->av_frame_unref(av_frame_);
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ ffmpeg_->avcodec_get_frame_defaults(av_frame_);
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ int frame_decoded = 0;
+ int decode_result = ffmpeg_->avcodec_decode_video2(codec_context_, av_frame_,
+ &frame_decoded, packet);
+ if (decode_result < 0) {
+ SB_DLOG(ERROR) << "avcodec_decode_video2() failed with result "
+ << decode_result;
+ error_cb_();
+ error_occured_ = true;
+ return false;
+ }
+ if (frame_decoded == 0) {
+ return false;
+ }
+
+ if (av_frame_->opaque == NULL) {
+ SB_DLOG(ERROR) << "Video frame was produced yet has invalid frame data.";
+ error_cb_();
+ error_occured_ = true;
+ return false;
+ }
+
+ int pitch = AlignUp(av_frame_->width, kAlignment * 2);
+
+ scoped_refptr<CpuVideoFrame> frame = CpuVideoFrame::CreateYV12Frame(
+ av_frame_->width, av_frame_->height, pitch, av_frame_->reordered_opaque,
+ av_frame_->data[0], av_frame_->data[1], av_frame_->data[2]);
+
+ bool result = true;
+ if (output_mode_ == kSbPlayerOutputModeDecodeToTexture) {
+ result = UpdateDecodeTarget(frame);
+ }
+
+ decoder_status_cb_(kBufferFull, frame);
+
+ return result;
+}
+
+bool VideoDecoderImpl<FFMPEG>::UpdateDecodeTarget(
+ const scoped_refptr<CpuVideoFrame>& frame) {
+ SbDecodeTarget decode_target = DecodeTargetCreate(
+ decode_target_graphics_context_provider_, frame, decode_target_);
+
+ // Lock only after the post to the renderer thread, to prevent deadlock.
+ ScopedLock lock(decode_target_mutex_);
+ decode_target_ = decode_target;
+
+ if (!SbDecodeTargetIsValid(decode_target)) {
+ SB_LOG(ERROR) << "Could not acquire a decode target from provider.";
+ return false;
+ }
+
+ return true;
+}
+
+void VideoDecoderImpl<FFMPEG>::InitializeCodec() {
+ codec_context_ = ffmpeg_->avcodec_alloc_context3(NULL);
+
+ if (codec_context_ == NULL) {
+ SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
+ return;
+ }
+
+ codec_context_->codec_type = AVMEDIA_TYPE_VIDEO;
+ codec_context_->codec_id = AV_CODEC_ID_H264;
+ codec_context_->profile = FF_PROFILE_UNKNOWN;
+ codec_context_->coded_width = 0;
+ codec_context_->coded_height = 0;
+ codec_context_->pix_fmt = PIX_FMT_NONE;
+
+ codec_context_->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
+ codec_context_->thread_count = 2;
+ codec_context_->opaque = this;
+ codec_context_->flags |= CODEC_FLAG_EMU_EDGE;
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ codec_context_->get_buffer2 = AllocateBufferCallback;
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ codec_context_->get_buffer = AllocateBufferCallback;
+ codec_context_->release_buffer = ReleaseBuffer;
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+
+ codec_context_->extradata = NULL;
+ codec_context_->extradata_size = 0;
+
+ AVCodec* codec = ffmpeg_->avcodec_find_decoder(codec_context_->codec_id);
+
+ if (codec == NULL) {
+ SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
+ TeardownCodec();
+ return;
+ }
+
+ int rv = ffmpeg_->OpenCodec(codec_context_, codec);
+ if (rv < 0) {
+ SB_LOG(ERROR) << "Unable to open codec";
+ TeardownCodec();
+ return;
+ }
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ av_frame_ = ffmpeg_->av_frame_alloc();
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ av_frame_ = ffmpeg_->avcodec_alloc_frame();
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ if (av_frame_ == NULL) {
+ SB_LOG(ERROR) << "Unable to allocate audio frame";
+ TeardownCodec();
+ }
+}
+
+void VideoDecoderImpl<FFMPEG>::TeardownCodec() {
+ if (codec_context_) {
+ ffmpeg_->CloseCodec(codec_context_);
+ ffmpeg_->av_freep(&codec_context_);
+ }
+ ffmpeg_->av_freep(&av_frame_);
+
+ if (output_mode_ == kSbPlayerOutputModeDecodeToTexture) {
+ ScopedLock lock(decode_target_mutex_);
+ if (SbDecodeTargetIsValid(decode_target_)) {
+ DecodeTargetRelease(decode_target_graphics_context_provider_,
+ decode_target_);
+ decode_target_ = kSbDecodeTargetInvalid;
+ }
+ }
+}
+
+// When in decode-to-texture mode, this returns the current decoded video frame.
+SbDecodeTarget VideoDecoderImpl<FFMPEG>::GetCurrentDecodeTarget() {
+ SB_DCHECK(output_mode_ == kSbPlayerOutputModeDecodeToTexture);
+
+ // We must take a lock here since this function can be called from a
+ // separate thread.
+ ScopedLock lock(decode_target_mutex_);
+ if (SbDecodeTargetIsValid(decode_target_)) {
+ // Make a disposable copy, since the state is internally reused by this
+ // class (to avoid recreating GL objects).
+ return DecodeTargetCopy(decode_target_);
+ } else {
+ return kSbDecodeTargetInvalid;
+ }
+}
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+
+int VideoDecoderImpl<FFMPEG>::AllocateBuffer(AVCodecContext* codec_context,
+ AVFrame* frame,
+ int flags) {
if (codec_context->pix_fmt != PIX_FMT_YUV420P &&
codec_context->pix_fmt != PIX_FMT_YUVJ420P) {
SB_DLOG(WARNING) << "Unsupported pix_fmt " << codec_context->pix_fmt;
return AVERROR(EINVAL);
}
- int ret =
- av_image_check_size(codec_context->width, codec_context->height, 0, NULL);
+ int ret = ffmpeg_->av_image_check_size(codec_context->width,
+ codec_context->height, 0, NULL);
if (ret < 0) {
return ret;
}
@@ -82,23 +429,24 @@
frame->reordered_opaque = codec_context->reordered_opaque;
- frame->buf[0] = av_buffer_create(frame_buffer,
- GetYV12SizeInBytes(y_stride, aligned_height),
- &ReleaseBuffer, frame->opaque, 0);
+ frame->buf[0] = static_cast<AVBufferRef*>(ffmpeg_->av_buffer_create(
+ frame_buffer, GetYV12SizeInBytes(y_stride, aligned_height),
+ &ReleaseBuffer, frame->opaque, 0));
return 0;
}
-#else // LIBAVUTIL_VERSION_MAJOR > 52
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
-int AllocateBuffer(AVCodecContext* codec_context, AVFrame* frame) {
+int VideoDecoderImpl<FFMPEG>::AllocateBuffer(AVCodecContext* codec_context,
+ AVFrame* frame) {
if (codec_context->pix_fmt != PIX_FMT_YUV420P &&
codec_context->pix_fmt != PIX_FMT_YUVJ420P) {
SB_DLOG(WARNING) << "Unsupported pix_fmt " << codec_context->pix_fmt;
return AVERROR(EINVAL);
}
- int ret =
- av_image_check_size(codec_context->width, codec_context->height, 0, NULL);
+ int ret = ffmpeg_->av_image_check_size(codec_context->width,
+ codec_context->height, 0, NULL);
if (ret < 0) {
return ret;
}
@@ -135,339 +483,8 @@
return 0;
}
-
-void ReleaseBuffer(AVCodecContext*, AVFrame* frame) {
- SbMemoryDeallocate(frame->opaque);
- frame->opaque = NULL;
-
- // The FFmpeg API expects us to zero the data pointers in this callback.
- SbMemorySet(frame->data, 0, sizeof(frame->data));
-}
-
-#endif // LIBAVUTIL_VERSION_MAJOR > 52
-} // namespace
-
-VideoDecoder::VideoDecoder(SbMediaVideoCodec video_codec,
- SbPlayerOutputMode output_mode,
- SbDecodeTargetGraphicsContextProvider*
- decode_target_graphics_context_provider)
- : video_codec_(video_codec),
- codec_context_(NULL),
- av_frame_(NULL),
- stream_ended_(false),
- error_occured_(false),
- decoder_thread_(kSbThreadInvalid),
- output_mode_(output_mode),
- decode_target_graphics_context_provider_(
- decode_target_graphics_context_provider),
- decode_target_(kSbDecodeTargetInvalid) {
- InitializeCodec();
-}
-
-VideoDecoder::~VideoDecoder() {
- Reset();
- TeardownCodec();
-}
-
-void VideoDecoder::Initialize(const DecoderStatusCB& decoder_status_cb,
- const ErrorCB& error_cb) {
- SB_DCHECK(decoder_status_cb);
- SB_DCHECK(!decoder_status_cb_);
- SB_DCHECK(error_cb);
- SB_DCHECK(!error_cb_);
-
- decoder_status_cb_ = decoder_status_cb;
- error_cb_ = error_cb;
-}
-
-void VideoDecoder::WriteInputBuffer(
- const scoped_refptr<InputBuffer>& input_buffer) {
- SB_DCHECK(input_buffer);
- SB_DCHECK(queue_.Poll().type == kInvalid);
- SB_DCHECK(decoder_status_cb_);
-
- if (stream_ended_) {
- SB_LOG(ERROR) << "WriteInputFrame() was called after WriteEndOfStream().";
- return;
- }
-
- if (!SbThreadIsValid(decoder_thread_)) {
- decoder_thread_ =
- SbThreadCreate(0, kSbThreadPriorityHigh, kSbThreadNoAffinity, true,
- "ff_video_dec", &VideoDecoder::ThreadEntryPoint, this);
- SB_DCHECK(SbThreadIsValid(decoder_thread_));
- }
-
- queue_.Put(Event(input_buffer));
-}
-
-void VideoDecoder::WriteEndOfStream() {
- SB_DCHECK(decoder_status_cb_);
-
- // We have to flush the decoder to decode the rest frames and to ensure that
- // Decode() is not called when the stream is ended.
- stream_ended_ = true;
-
- if (!SbThreadIsValid(decoder_thread_)) {
- // In case there is no WriteInputBuffer() call before WriteEndOfStream(),
- // don't create the decoder thread and send the EOS frame directly.
- decoder_status_cb_(kBufferFull, VideoFrame::CreateEOSFrame());
- return;
- }
-
- queue_.Put(Event(kWriteEndOfStream));
-}
-
-void VideoDecoder::Reset() {
- // Join the thread to ensure that all callbacks in process are finished.
- if (SbThreadIsValid(decoder_thread_)) {
- queue_.Put(Event(kReset));
- SbThreadJoin(decoder_thread_, NULL);
- }
-
- if (codec_context_ != NULL) {
- avcodec_flush_buffers(codec_context_);
- }
-
- decoder_thread_ = kSbThreadInvalid;
- stream_ended_ = false;
-
- if (output_mode_ == kSbPlayerOutputModeDecodeToTexture) {
- TeardownCodec();
- InitializeCodec();
- }
-}
-
-// static
-void* VideoDecoder::ThreadEntryPoint(void* context) {
- SB_DCHECK(context);
- VideoDecoder* decoder = reinterpret_cast<VideoDecoder*>(context);
- decoder->DecoderThreadFunc();
- return NULL;
-}
-
-void VideoDecoder::DecoderThreadFunc() {
- for (;;) {
- Event event = queue_.Get();
- if (event.type == kReset) {
- return;
- }
- if (error_occured_) {
- continue;
- }
- if (event.type == kWriteInputBuffer) {
- // Send |input_buffer| to ffmpeg and try to decode one frame.
- AVPacket packet;
- av_init_packet(&packet);
- packet.data = const_cast<uint8_t*>(event.input_buffer->data());
- packet.size = event.input_buffer->size();
- packet.pts = event.input_buffer->pts();
- codec_context_->reordered_opaque = packet.pts;
-
- DecodePacket(&packet);
- decoder_status_cb_(kNeedMoreInput, NULL);
- } else {
- SB_DCHECK(event.type == kWriteEndOfStream);
- // Stream has ended, try to decode any frames left in ffmpeg.
- AVPacket packet;
- do {
- av_init_packet(&packet);
- packet.data = NULL;
- packet.size = 0;
- packet.pts = 0;
- } while (DecodePacket(&packet));
-
- decoder_status_cb_(kBufferFull, VideoFrame::CreateEOSFrame());
- }
- }
-}
-
-bool VideoDecoder::DecodePacket(AVPacket* packet) {
- SB_DCHECK(packet != NULL);
-
-#if LIBAVUTIL_VERSION_MAJOR > 52
- av_frame_unref(av_frame_);
-#else // LIBAVUTIL_VERSION_MAJOR > 52
- avcodec_get_frame_defaults(av_frame_);
-#endif // LIBAVUTIL_VERSION_MAJOR > 52
- int frame_decoded = 0;
- int decode_result =
- avcodec_decode_video2(codec_context_, av_frame_, &frame_decoded, packet);
- if (decode_result < 0) {
- SB_DLOG(ERROR) << "avcodec_decode_video2() failed with result "
- << decode_result;
- error_cb_();
- error_occured_ = true;
- return false;
- }
- if (frame_decoded == 0) {
- return false;
- }
-
- if (av_frame_->opaque == NULL) {
- SB_DLOG(ERROR) << "Video frame was produced yet has invalid frame data.";
- error_cb_();
- error_occured_ = true;
- return false;
- }
-
- int pitch = AlignUp(av_frame_->width, kAlignment * 2);
-
- scoped_refptr<CpuVideoFrame> frame = CpuVideoFrame::CreateYV12Frame(
- av_frame_->width, av_frame_->height, pitch, av_frame_->reordered_opaque,
- av_frame_->data[0], av_frame_->data[1], av_frame_->data[2]);
-
- bool result = true;
- if (output_mode_ == kSbPlayerOutputModeDecodeToTexture) {
- result = UpdateDecodeTarget(frame);
- }
-
- decoder_status_cb_(kBufferFull, frame);
-
- return result;
-}
-
-bool VideoDecoder::UpdateDecodeTarget(
- const scoped_refptr<CpuVideoFrame>& frame) {
- SbDecodeTarget decode_target = DecodeTargetCreate(
- decode_target_graphics_context_provider_, frame, decode_target_);
-
- // Lock only after the post to the renderer thread, to prevent deadlock.
- ScopedLock lock(decode_target_mutex_);
- decode_target_ = decode_target;
-
- if (!SbDecodeTargetIsValid(decode_target)) {
- SB_LOG(ERROR) << "Could not acquire a decode target from provider.";
- return false;
- }
-
- return true;
-}
-
-void VideoDecoder::InitializeCodec() {
- InitializeFfmpeg();
-
- codec_context_ = avcodec_alloc_context3(NULL);
-
- if (codec_context_ == NULL) {
- SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
- return;
- }
-
- codec_context_->codec_type = AVMEDIA_TYPE_VIDEO;
- codec_context_->codec_id = AV_CODEC_ID_H264;
- codec_context_->profile = FF_PROFILE_UNKNOWN;
- codec_context_->coded_width = 0;
- codec_context_->coded_height = 0;
- codec_context_->pix_fmt = PIX_FMT_NONE;
-
- codec_context_->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
- codec_context_->thread_count = 2;
- codec_context_->opaque = this;
- codec_context_->flags |= CODEC_FLAG_EMU_EDGE;
-#if LIBAVUTIL_VERSION_MAJOR > 52
- codec_context_->get_buffer2 = AllocateBuffer;
-#else // LIBAVUTIL_VERSION_MAJOR > 52
- codec_context_->get_buffer = AllocateBuffer;
- codec_context_->release_buffer = ReleaseBuffer;
-#endif // LIBAVUTIL_VERSION_MAJOR > 52
-
- codec_context_->extradata = NULL;
- codec_context_->extradata_size = 0;
-
- AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
-
- if (codec == NULL) {
- SB_LOG(ERROR) << "Unable to allocate ffmpeg codec context";
- TeardownCodec();
- return;
- }
-
- int rv = OpenCodec(codec_context_, codec);
- if (rv < 0) {
- SB_LOG(ERROR) << "Unable to open codec";
- TeardownCodec();
- return;
- }
-
-#if LIBAVUTIL_VERSION_MAJOR > 52
- av_frame_ = av_frame_alloc();
-#else // LIBAVUTIL_VERSION_MAJOR > 52
- av_frame_ = avcodec_alloc_frame();
-#endif // LIBAVUTIL_VERSION_MAJOR > 52
- if (av_frame_ == NULL) {
- SB_LOG(ERROR) << "Unable to allocate audio frame";
- TeardownCodec();
- }
-}
-
-void VideoDecoder::TeardownCodec() {
- if (codec_context_) {
- CloseCodec(codec_context_);
- av_free(codec_context_);
- codec_context_ = NULL;
- }
- if (av_frame_) {
- av_free(av_frame_);
- av_frame_ = NULL;
- }
-
- if (output_mode_ == kSbPlayerOutputModeDecodeToTexture) {
- ScopedLock lock(decode_target_mutex_);
- if (SbDecodeTargetIsValid(decode_target_)) {
- DecodeTargetRelease(decode_target_graphics_context_provider_,
- decode_target_);
- decode_target_ = kSbDecodeTargetInvalid;
- }
- }
-}
-
-// When in decode-to-texture mode, this returns the current decoded video frame.
-SbDecodeTarget VideoDecoder::GetCurrentDecodeTarget() {
- SB_DCHECK(output_mode_ == kSbPlayerOutputModeDecodeToTexture);
-
- // We must take a lock here since this function can be called from a
- // separate thread.
- ScopedLock lock(decode_target_mutex_);
- if (SbDecodeTargetIsValid(decode_target_)) {
- // Make a disposable copy, since the state is internally reused by this
- // class (to avoid recreating GL objects).
- return DecodeTargetCopy(decode_target_);
- } else {
- return kSbDecodeTargetInvalid;
- }
-}
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
} // namespace ffmpeg
-
-namespace starboard {
-namespace player {
-namespace filter {
-
-// static
-bool VideoDecoder::OutputModeSupported(SbPlayerOutputMode output_mode,
- SbMediaVideoCodec codec,
- SbDrmSystem drm_system) {
- SB_UNREFERENCED_PARAMETER(codec);
- SB_UNREFERENCED_PARAMETER(drm_system);
-
-#if defined(SB_FORCE_DECODE_TO_TEXTURE_ONLY)
- // Starboard lib targets may not draw directly to the window, so punch through
- // video is not made available.
- return output_mode == kSbPlayerOutputModeDecodeToTexture;
-#endif // defined(SB_FORCE_DECODE_TO_TEXTURE_ONLY)
-
- if (output_mode == kSbPlayerOutputModePunchOut ||
- output_mode == kSbPlayerOutputModeDecodeToTexture) {
- return true;
- }
-
- return false;
-}
-
-} // namespace filter
-} // namespace player
-} // namespace starboard
-
} // namespace shared
} // namespace starboard
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h
new file mode 100644
index 0000000..86f2cd6
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_impl.h
@@ -0,0 +1,166 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_FFMPEG_FFMPEG_VIDEO_DECODER_IMPL_H_
+#define STARBOARD_SHARED_FFMPEG_FFMPEG_VIDEO_DECODER_IMPL_H_
+
+#include "starboard/common/ref_counted.h"
+#include "starboard/log.h"
+#include "starboard/media.h"
+#include "starboard/queue.h"
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder.h"
+#include "starboard/shared/internal_only.h"
+#include "starboard/shared/starboard/player/filter/cpu_video_frame.h"
+#include "starboard/shared/starboard/player/filter/video_decoder_internal.h"
+#include "starboard/shared/starboard/player/input_buffer_internal.h"
+#include "starboard/thread.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+// For each version V that is supported, there will be an explicit
+// specialization of the VideoDecoder class.
+template <int V>
+class VideoDecoderImpl : public VideoDecoder {
+ public:
+ static VideoDecoder* Create(SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider);
+};
+
+// Forward class declaration of the explicit specialization with value FFMPEG.
+template <>
+class VideoDecoderImpl<FFMPEG>;
+
+// Declare the explicit specialization of the class with value FFMPEG.
+template <>
+class VideoDecoderImpl<FFMPEG> : public VideoDecoder {
+ public:
+ VideoDecoderImpl(SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider);
+ ~VideoDecoderImpl() override;
+
+ // From: VideoDecoder
+ static VideoDecoder* Create(SbMediaVideoCodec video_codec,
+ SbPlayerOutputMode output_mode,
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider);
+ bool is_valid() const override;
+
+ // From: starboard::player::filter::VideoDecoder
+ void Initialize(const DecoderStatusCB& decoder_status_cb,
+ const ErrorCB& error_cb) override;
+ size_t GetPrerollFrameCount() const override { return 8; }
+ SbTime GetPrerollTimeout() const override { return kSbTimeMax; }
+
+ void WriteInputBuffer(
+ const scoped_refptr<InputBuffer>& input_buffer) override;
+ void WriteEndOfStream() override;
+ void Reset() override;
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ int AllocateBuffer(AVCodecContext* codec_context, AVFrame* frame, int flags);
+#else // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+ int AllocateBuffer(AVCodecContext* codec_context, AVFrame* frame);
+#endif // LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 8, 0)
+
+ private:
+ typedef ::starboard::shared::starboard::player::filter::CpuVideoFrame
+ CpuVideoFrame;
+
+ enum EventType {
+ kInvalid,
+ kReset,
+ kWriteInputBuffer,
+ kWriteEndOfStream,
+ };
+
+ struct Event {
+ EventType type;
+ // |input_buffer| is only used when |type| is kWriteInputBuffer.
+ scoped_refptr<InputBuffer> input_buffer;
+
+ explicit Event(EventType type = kInvalid) : type(type) {
+ SB_DCHECK(type != kWriteInputBuffer);
+ }
+
+ explicit Event(const scoped_refptr<InputBuffer>& input_buffer)
+ : type(kWriteInputBuffer), input_buffer(input_buffer) {}
+ };
+
+ static void* ThreadEntryPoint(void* context);
+ void DecoderThreadFunc();
+
+ bool DecodePacket(AVPacket* packet);
+ void InitializeCodec();
+ void TeardownCodec();
+ SbDecodeTarget GetCurrentDecodeTarget() override;
+
+ bool UpdateDecodeTarget(const scoped_refptr<CpuVideoFrame>& frame);
+
+ FFMPEGDispatch* ffmpeg_;
+
+ // |video_codec_| will be initialized inside ctor and won't be changed during
+ // the life time of this class.
+ const SbMediaVideoCodec video_codec_;
+ // The following callbacks will be initialized in Initialize() and won't be
+ // changed during the life time of this class.
+ DecoderStatusCB decoder_status_cb_;
+ ErrorCB error_cb_;
+
+ Queue<Event> queue_;
+
+ // The AV related classes will only be created and accessed on the decoder
+ // thread.
+ AVCodecContext* codec_context_;
+ AVFrame* av_frame_;
+
+ bool stream_ended_;
+ bool error_occured_;
+
+ // Working thread to avoid lengthy decoding work block the player thread.
+ SbThread decoder_thread_;
+
+ // Decode-to-texture related state.
+ SbPlayerOutputMode output_mode_;
+
+ SbDecodeTargetGraphicsContextProvider*
+ decode_target_graphics_context_provider_;
+
+ // If decode-to-texture is enabled, then we store the decode target texture
+ // inside of this |decode_target_| member.
+ SbDecodeTarget decode_target_;
+
+ // GetCurrentDecodeTarget() needs to be called from an arbitrary thread
+ // to obtain the current decode target (which ultimately ends up being a
+ // copy of |decode_target_|), we need to safe-guard access to |decode_target_|
+ // and we do so through this mutex.
+ Mutex decode_target_mutex_;
+ // Mutex frame_mutex_;
+
+ // int frame_last_rendered_pts_;
+ // scoped_refptr<VideoFrame> frame_;
+};
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_SHARED_FFMPEG_FFMPEG_VIDEO_DECODER_IMPL_H_
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_internal.cc b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_internal.cc
new file mode 100644
index 0000000..7ad130e
--- /dev/null
+++ b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder_internal.cc
@@ -0,0 +1,53 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains the implementation of methods from
+// starboard::player::filter::VideoDecoder for the VideoDecoder class that are
+// the same for dynamically loaded and linked implementation for the ffmpeg
+// library.
+
+#include "starboard/shared/ffmpeg/ffmpeg_video_decoder.h"
+
+namespace starboard {
+namespace shared {
+namespace starboard {
+namespace player {
+namespace filter {
+
+// static
+bool VideoDecoder::OutputModeSupported(SbPlayerOutputMode output_mode,
+ SbMediaVideoCodec codec,
+ SbDrmSystem drm_system) {
+ SB_UNREFERENCED_PARAMETER(codec);
+ SB_UNREFERENCED_PARAMETER(drm_system);
+
+#if defined(SB_FORCE_DECODE_TO_TEXTURE_ONLY)
+ // Starboard lib targets may not draw directly to the window, so punch through
+ // video is not made available.
+ return output_mode == kSbPlayerOutputModeDecodeToTexture;
+#endif // defined(SB_FORCE_DECODE_TO_TEXTURE_ONLY)
+
+ if (output_mode == kSbPlayerOutputModePunchOut ||
+ output_mode == kSbPlayerOutputModeDecodeToTexture) {
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace filter
+} // namespace player
+} // namespace starboard
+} // namespace shared
+} // namespace starboard
