Import Cobalt 23.lts.1.308479
diff --git a/cobalt/content/licenses/platform/android/licenses_cobalt.txt b/cobalt/content/licenses/platform/android/licenses_cobalt.txt
index 022c76b..c92392b 100644
--- a/cobalt/content/licenses/platform/android/licenses_cobalt.txt
+++ b/cobalt/content/licenses/platform/android/licenses_cobalt.txt
@@ -2467,6 +2467,36 @@
+ zlib
+
+ /* zlib.h -- interface of the 'zlib' general purpose compression library
+ version 1.2.4, March 14th, 2010
+
+ Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly
+ Mark Adler
+
+ */
+
+
+
woff2
Copyright (c) 2013-2017 by the WOFF2 Authors.
diff --git a/cobalt/content/licenses/platform/default/licenses_cobalt.txt b/cobalt/content/licenses/platform/default/licenses_cobalt.txt
index 7ab54cf..7dddfd2 100644
--- a/cobalt/content/licenses/platform/default/licenses_cobalt.txt
+++ b/cobalt/content/licenses/platform/default/licenses_cobalt.txt
@@ -2755,6 +2755,36 @@
+ zlib
+
+ /* zlib.h -- interface of the 'zlib' general purpose compression library
+ version 1.2.4, March 14th, 2010
+
+ Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly
+ Mark Adler
+
+ */
+
+
+
woff2
Copyright (c) 2013-2017 by the WOFF2 Authors.
diff --git a/cobalt/content/licenses/platform/evergreen/licenses_cobalt.txt b/cobalt/content/licenses/platform/evergreen/licenses_cobalt.txt
index a85d482..2f63709 100644
--- a/cobalt/content/licenses/platform/evergreen/licenses_cobalt.txt
+++ b/cobalt/content/licenses/platform/evergreen/licenses_cobalt.txt
@@ -2647,6 +2647,36 @@
+ zlib
+
+ /* zlib.h -- interface of the 'zlib' general purpose compression library
+ version 1.2.4, March 14th, 2010
+
+ Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly
+ Mark Adler
+
+ */
+
+
+
woff2
Copyright (c) 2013-2017 by the WOFF2 Authors.
diff --git a/cobalt/extension/demuxer.h b/cobalt/extension/demuxer.h
new file mode 100644
index 0000000..59a3055
--- /dev/null
+++ b/cobalt/extension/demuxer.h
@@ -0,0 +1,408 @@
+// Copyright 2022 The Cobalt Authors. 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.
+//
+// Contains extension code allowing partners to provide their own demuxer.
+// CobaltExtensionDemuxerApi is the main API.
+
+#ifndef COBALT_EXTENSION_DEMUXER_H_
+#define COBALT_EXTENSION_DEMUXER_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "starboard/time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define kCobaltExtensionDemuxerApi "dev.cobalt.extension.Demuxer"
+
+// This must stay in sync with ::media::PipelineStatus. Missing values are
+// either irrelevant to the demuxer or are deprecated values of PipelineStatus.
+typedef enum CobaltExtensionDemuxerStatus {
+ kCobaltExtensionDemuxerOk = 0,
+ kCobaltExtensionDemuxerErrorNetwork = 2,
+ kCobaltExtensionDemuxerErrorAbort = 5,
+ kCobaltExtensionDemuxerErrorInitializationFailed = 6,
+ kCobaltExtensionDemuxerErrorRead = 9,
+ kCobaltExtensionDemuxerErrorInvalidState = 11,
+ kCobaltExtensionDemuxerErrorCouldNotOpen = 12,
+ kCobaltExtensionDemuxerErrorCouldNotParse = 13,
+ kCobaltExtensionDemuxerErrorNoSupportedStreams = 14
+} CobaltExtensionDemuxerStatus;
+
+// Type of side data associated with a buffer.
+typedef enum CobaltExtensionDemuxerSideDataType {
+ kCobaltExtensionDemuxerUnknownSideDataType = 0,
+ kCobaltExtensionDemuxerMatroskaBlockAdditional = 1,
+} CobaltExtensionDemuxerSideDataType;
+
+// This must stay in sync with ::media::AudioCodec.
+typedef enum CobaltExtensionDemuxerAudioCodec {
+ kCobaltExtensionDemuxerCodecUnknownAudio = 0,
+ kCobaltExtensionDemuxerCodecAAC = 1,
+ kCobaltExtensionDemuxerCodecMP3 = 2,
+ kCobaltExtensionDemuxerCodecPCM = 3,
+ kCobaltExtensionDemuxerCodecVorbis = 4,
+ kCobaltExtensionDemuxerCodecFLAC = 5,
+ kCobaltExtensionDemuxerCodecAMR_NB = 6,
+ kCobaltExtensionDemuxerCodecAMR_WB = 7,
+ kCobaltExtensionDemuxerCodecPCM_MULAW = 8,
+ kCobaltExtensionDemuxerCodecGSM_MS = 9,
+ kCobaltExtensionDemuxerCodecPCM_S16BE = 10,
+ kCobaltExtensionDemuxerCodecPCM_S24BE = 11,
+ kCobaltExtensionDemuxerCodecOpus = 12,
+ kCobaltExtensionDemuxerCodecEAC3 = 13,
+ kCobaltExtensionDemuxerCodecPCM_ALAW = 14,
+ kCobaltExtensionDemuxerCodecALAC = 15,
+ kCobaltExtensionDemuxerCodecAC3 = 16
+} CobaltExtensionDemuxerAudioCodec;
+
+// This must stay in sync with ::media::VideoCodec.
+typedef enum CobaltExtensionDemuxerVideoCodec {
+ kCobaltExtensionDemuxerCodecUnknownVideo = 0,
+ kCobaltExtensionDemuxerCodecH264,
+ kCobaltExtensionDemuxerCodecVC1,
+ kCobaltExtensionDemuxerCodecMPEG2,
+ kCobaltExtensionDemuxerCodecMPEG4,
+ kCobaltExtensionDemuxerCodecTheora,
+ kCobaltExtensionDemuxerCodecVP8,
+ kCobaltExtensionDemuxerCodecVP9,
+ kCobaltExtensionDemuxerCodecHEVC,
+ kCobaltExtensionDemuxerCodecDolbyVision,
+ kCobaltExtensionDemuxerCodecAV1,
+} CobaltExtensionDemuxerVideoCodec;
+
+// This must stay in sync with ::media::SampleFormat.
+typedef enum CobaltExtensionDemuxerSampleFormat {
+ kCobaltExtensionDemuxerSampleFormatUnknown = 0,
+ kCobaltExtensionDemuxerSampleFormatU8, // Unsigned 8-bit w/ bias of 128.
+ kCobaltExtensionDemuxerSampleFormatS16, // Signed 16-bit.
+ kCobaltExtensionDemuxerSampleFormatS32, // Signed 32-bit.
+ kCobaltExtensionDemuxerSampleFormatF32, // Float 32-bit.
+ kCobaltExtensionDemuxerSampleFormatPlanarS16, // Signed 16-bit planar.
+ kCobaltExtensionDemuxerSampleFormatPlanarF32, // Float 32-bit planar.
+ kCobaltExtensionDemuxerSampleFormatPlanarS32, // Signed 32-bit planar.
+ kCobaltExtensionDemuxerSampleFormatS24, // Signed 24-bit.
+} CobaltExtensionDemuxerSampleFormat;
+
+// This must stay in sync with ::media::ChannelLayout.
+typedef enum CobaltExtensionDemuxerChannelLayout {
+ kCobaltExtensionDemuxerChannelLayoutNone = 0,
+ kCobaltExtensionDemuxerChannelLayoutUnsupported = 1,
+ kCobaltExtensionDemuxerChannelLayoutMono = 2,
+ kCobaltExtensionDemuxerChannelLayoutStereo = 3,
+ kCobaltExtensionDemuxerChannelLayout2_1 = 4,
+ kCobaltExtensionDemuxerChannelLayoutSurround = 5,
+ kCobaltExtensionDemuxerChannelLayout4_0 = 6,
+ kCobaltExtensionDemuxerChannelLayout2_2 = 7,
+ kCobaltExtensionDemuxerChannelLayoutQuad = 8,
+ kCobaltExtensionDemuxerChannelLayout5_0 = 9,
+ kCobaltExtensionDemuxerChannelLayout5_1 = 10,
+ kCobaltExtensionDemuxerChannelLayout5_0Back = 11,
+ kCobaltExtensionDemuxerChannelLayout5_1Back = 12,
+ kCobaltExtensionDemuxerChannelLayout7_0 = 13,
+ kCobaltExtensionDemuxerChannelLayout7_1 = 14,
+ kCobaltExtensionDemuxerChannelLayout7_1Wide = 15,
+ kCobaltExtensionDemuxerChannelLayoutStereoDownmix = 16,
+ kCobaltExtensionDemuxerChannelLayout2point1 = 17,
+ kCobaltExtensionDemuxerChannelLayout3_1 = 18,
+ kCobaltExtensionDemuxerChannelLayout4_1 = 19,
+ kCobaltExtensionDemuxerChannelLayout6_0 = 20,
+ kCobaltExtensionDemuxerChannelLayout6_0Front = 21,
+ kCobaltExtensionDemuxerChannelLayoutHexagonal = 22,
+ kCobaltExtensionDemuxerChannelLayout6_1 = 23,
+ kCobaltExtensionDemuxerChannelLayout6_1Back = 24,
+ kCobaltExtensionDemuxerChannelLayout6_1Front = 25,
+ kCobaltExtensionDemuxerChannelLayout7_0Front = 26,
+ kCobaltExtensionDemuxerChannelLayout7_1WideBack = 27,
+ kCobaltExtensionDemuxerChannelLayoutOctagonal = 28,
+ kCobaltExtensionDemuxerChannelLayoutDiscrete = 29,
+ kCobaltExtensionDemuxerChannelLayoutStereoAndKeyboardMic = 30,
+ kCobaltExtensionDemuxerChannelLayout4_1QuadSide = 31,
+ kCobaltExtensionDemuxerChannelLayoutBitstream = 32
+} CobaltExtensionDemuxerChannelLayout;
+
+// This must stay in sync with ::media::VideoCodecProfile.
+typedef enum CobaltExtensionDemuxerVideoCodecProfile {
+ kCobaltExtensionDemuxerVideoCodecProfileUnknown = -1,
+ kCobaltExtensionDemuxerH264ProfileMin = 0,
+ kCobaltExtensionDemuxerH264ProfileBaseline =
+ kCobaltExtensionDemuxerH264ProfileMin,
+ kCobaltExtensionDemuxerH264ProfileMain = 1,
+ kCobaltExtensionDemuxerH264ProfileExtended = 2,
+ kCobaltExtensionDemuxerH264ProfileHigh = 3,
+ kCobaltExtensionDemuxerH264ProfileHigh10Profile = 4,
+ kCobaltExtensionDemuxerH264ProfileHigh422Profile = 5,
+ kCobaltExtensionDemuxerH264ProfileHigh444PredictiveProfile = 6,
+ kCobaltExtensionDemuxerH264ProfileScalableBaseline = 7,
+ kCobaltExtensionDemuxerH264ProfileScalableHigh = 8,
+ kCobaltExtensionDemuxerH264ProfileStereoHigh = 9,
+ kCobaltExtensionDemuxerH264ProfileMultiviewHigh = 10,
+ kCobaltExtensionDemuxerH264ProfileMax =
+ kCobaltExtensionDemuxerH264ProfileMultiviewHigh,
+ kCobaltExtensionDemuxerVp8ProfileMin = 11,
+ kCobaltExtensionDemuxerVp8ProfileAny = kCobaltExtensionDemuxerVp8ProfileMin,
+ kCobaltExtensionDemuxerVp8ProfileMax = kCobaltExtensionDemuxerVp8ProfileAny,
+ kCobaltExtensionDemuxerVp9ProfileMin = 12,
+ kCobaltExtensionDemuxerVp9ProfileProfile0 =
+ kCobaltExtensionDemuxerVp9ProfileMin,
+ kCobaltExtensionDemuxerVp9ProfileProfile1 = 13,
+ kCobaltExtensionDemuxerVp9ProfileProfile2 = 14,
+ kCobaltExtensionDemuxerVp9ProfileProfile3 = 15,
+ kCobaltExtensionDemuxerVp9ProfileMax =
+ kCobaltExtensionDemuxerVp9ProfileProfile3,
+ kCobaltExtensionDemuxerHevcProfileMin = 16,
+ kCobaltExtensionDemuxerHevcProfileMain =
+ kCobaltExtensionDemuxerHevcProfileMin,
+ kCobaltExtensionDemuxerHevcProfileMain10 = 17,
+ kCobaltExtensionDemuxerHevcProfileMainStillPicture = 18,
+ kCobaltExtensionDemuxerHevcProfileMax =
+ kCobaltExtensionDemuxerHevcProfileMainStillPicture,
+ kCobaltExtensionDemuxerDolbyVisionProfile0 = 19,
+ kCobaltExtensionDemuxerDolbyVisionProfile4 = 20,
+ kCobaltExtensionDemuxerDolbyVisionProfile5 = 21,
+ kCobaltExtensionDemuxerDolbyVisionProfile7 = 22,
+ kCobaltExtensionDemuxerTheoraProfileMin = 23,
+ kCobaltExtensionDemuxerTheoraProfileAny =
+ kCobaltExtensionDemuxerTheoraProfileMin,
+ kCobaltExtensionDemuxerTheoraProfileMax =
+ kCobaltExtensionDemuxerTheoraProfileAny,
+ kCobaltExtensionDemuxerAv1ProfileMin = 24,
+ kCobaltExtensionDemuxerAv1ProfileProfileMain =
+ kCobaltExtensionDemuxerAv1ProfileMin,
+ kCobaltExtensionDemuxerAv1ProfileProfileHigh = 25,
+ kCobaltExtensionDemuxerAv1ProfileProfilePro = 26,
+ kCobaltExtensionDemuxerAv1ProfileMax =
+ kCobaltExtensionDemuxerAv1ProfileProfilePro,
+ kCobaltExtensionDemuxerDolbyVisionProfile8 = 27,
+ kCobaltExtensionDemuxerDolbyVisionProfile9 = 28,
+} CobaltExtensionDemuxerVideoCodecProfile;
+
+// This must be kept in sync with gfx::ColorSpace::RangeID.
+typedef enum CobaltExtensionDemuxerColorSpaceRangeId {
+ kCobaltExtensionDemuxerColorSpaceRangeIdInvalid = 0,
+ kCobaltExtensionDemuxerColorSpaceRangeIdLimited = 1,
+ kCobaltExtensionDemuxerColorSpaceRangeIdFull = 2,
+ kCobaltExtensionDemuxerColorSpaceRangeIdDerived = 3
+} CobaltExtensionDemuxerColorSpaceRangeId;
+
+// This must be kept in sync with media::VideoDecoderConfig::AlphaMode.
+typedef enum CobaltExtensionDemuxerAlphaMode {
+ kCobaltExtensionDemuxerHasAlpha,
+ kCobaltExtensionDemuxerIsOpaque
+} CobaltExtensionDemuxerAlphaMode;
+
+// This must be kept in sync with ::media::DemuxerStream::Type.
+typedef enum CobaltExtensionDemuxerStreamType {
+ kCobaltExtensionDemuxerStreamTypeUnknown,
+ kCobaltExtensionDemuxerStreamTypeAudio,
+ kCobaltExtensionDemuxerStreamTypeVideo,
+ kCobaltExtensionDemuxerStreamTypeText
+} CobaltExtensionDemuxerStreamType;
+
+// This must be kept in sync with media::EncryptionScheme.
+typedef enum CobaltExtensionDemuxerEncryptionScheme {
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted,
+ kCobaltExtensionDemuxerEncryptionSchemeCenc,
+ kCobaltExtensionDemuxerEncryptionSchemeCbcs,
+} CobaltExtensionDemuxerEncryptionScheme;
+
+typedef struct CobaltExtensionDemuxerAudioDecoderConfig {
+ CobaltExtensionDemuxerAudioCodec codec;
+ CobaltExtensionDemuxerSampleFormat sample_format;
+ CobaltExtensionDemuxerChannelLayout channel_layout;
+ CobaltExtensionDemuxerEncryptionScheme encryption_scheme;
+ int samples_per_second;
+
+ uint8_t* extra_data; // Not owned by this struct.
+ int64_t extra_data_size;
+} CobaltExtensionDemuxerAudioDecoderConfig;
+
+typedef struct CobaltExtensionDemuxerVideoDecoderConfig {
+ CobaltExtensionDemuxerVideoCodec codec;
+ CobaltExtensionDemuxerVideoCodecProfile profile;
+
+ // These fields represent the color space.
+ int color_space_primaries;
+ int color_space_transfer;
+ int color_space_matrix;
+ CobaltExtensionDemuxerColorSpaceRangeId color_space_range_id;
+
+ CobaltExtensionDemuxerAlphaMode alpha_mode;
+
+ // These fields represent the coded size.
+ int coded_width;
+ int coded_height;
+
+ // These fields represent the visible rectangle.
+ int visible_rect_x;
+ int visible_rect_y;
+ int visible_rect_width;
+ int visible_rect_height;
+
+ // These fields represent the natural size.
+ int natural_width;
+ int natural_height;
+
+ CobaltExtensionDemuxerEncryptionScheme encryption_scheme;
+
+ uint8_t* extra_data; // Not owned by this struct.
+ int64_t extra_data_size;
+} CobaltExtensionDemuxerVideoDecoderConfig;
+
+typedef struct CobaltExtensionDemuxerSideData {
+ uint8_t* data; // Not owned by this struct.
+ // Number of bytes in |data|.
+ int64_t data_size;
+ // Specifies the format of |data|.
+ CobaltExtensionDemuxerSideDataType type;
+} CobaltExtensionDemuxerSideData;
+
+typedef struct CobaltExtensionDemuxerBuffer {
+ // The media data for this buffer. Ownership is not transferred via this
+ // struct.
+ uint8_t* data;
+ // Number of bytes in |data|.
+ int64_t data_size;
+ // An array of side data elements containing any side data for this buffer.
+ // Ownership is not transferred via this struct.
+ CobaltExtensionDemuxerSideData* side_data;
+ // Number of elements in |side_data|.
+ int64_t side_data_elements;
+ // Playback time in microseconds.
+ SbTime pts;
+ // Duration of this buffer in microseconds.
+ SbTime duration;
+ // True if this buffer contains a keyframe.
+ bool is_keyframe;
+ // Signifies the end of the stream. If this is true, the other fields will be
+ // ignored.
+ bool end_of_stream;
+} CobaltExtensionDemuxerBuffer;
+
+// Note: |buffer| is the input to this function, not the output. Cobalt
+// implements this function to read media data provided by the implementer of
+// CobaltExtensionDemuxer.
+typedef void (*CobaltExtensionDemuxerReadCB)(
+ CobaltExtensionDemuxerBuffer* buffer, void* user_data);
+
+// A fully synchronous demuxer API. Threading concerns are handled by the code
+// that uses this API.
+// When calling the defined functions, the |user_data| argument must be the
+// void* user_data field stored in this struct.
+typedef struct CobaltExtensionDemuxer {
+ // Initialize must only be called once for a demuxer; subsequent calls can
+ // fail.
+ CobaltExtensionDemuxerStatus (*Initialize)(void* user_data);
+
+ CobaltExtensionDemuxerStatus (*Seek)(SbTime seek_time, void* user_data);
+
+ // Returns the starting time for the media file; it is always positive.
+ SbTime (*GetStartTime)(void* user_data);
+
+ // Returns the time -- in microseconds since Windows epoch -- represented by
+ // presentation timestamp 0. If the timestamps are not associated with a time,
+ // returns 0.
+ SbTime (*GetTimelineOffset)(void* user_data);
+
+ // Calls |read_cb| with a buffer of type |type| and the user data provided by
+ // |read_cb_user_data|. |read_cb| is a synchronous function, so the data
+ // passed to it can safely be freed after |read_cb| returns. |read_cb| must be
+ // called exactly once, and it must be called before Read returns.
+ //
+ // An error can be handled in one of two ways:
+ // 1. Pass a null buffer to read_cb. This will cause the pipeline to handle
+ // the situation as an error. Alternatively,
+ // 2. Pass an "end of stream" buffer to read_cb. This will cause the relevant
+ // stream to end normally.
+ void (*Read)(CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb, void* read_cb_user_data,
+ void* user_data);
+
+ // Returns true and populates |audio_config| if an audio stream is present;
+ // returns false otherwise. |config| must not be null.
+ bool (*GetAudioConfig)(CobaltExtensionDemuxerAudioDecoderConfig* config,
+ void* user_data);
+
+ // Returns true and populates |video_config| if a video stream is present;
+ // returns false otherwise. |config| must not be null.
+ bool (*GetVideoConfig)(CobaltExtensionDemuxerVideoDecoderConfig* config,
+ void* user_data);
+
+ // Returns the duration, in microseconds.
+ SbTime (*GetDuration)(void* user_data);
+
+ // Will be passed to all functions.
+ void* user_data;
+} CobaltExtensionDemuxer;
+
+typedef struct CobaltExtensionDemuxerDataSource {
+ // Reads up to |bytes_requested|, writing the data into |data| and returning
+ // the number of bytes read. |data| must be able to store at least
+ // |bytes_requested| bytes. Calling BlockingRead advances the read position.
+ int (*BlockingRead)(uint8_t* data, int bytes_requested, void* user_data);
+
+ // Seeks to |position| (specified in bytes) in the data source.
+ void (*SeekTo)(int position, void* user_data);
+
+ // Returns the offset into the data source, in bytes.
+ int64_t (*GetPosition)(void* user_data);
+
+ // Returns the size of the data source, in bytes.
+ int64_t (*GetSize)(void* user_data);
+
+ // Whether this represents a streaming data source.
+ bool is_streaming;
+
+ // Will be passed to all functions.
+ void* user_data;
+} CobaltExtensionDemuxerDataSource;
+
+typedef struct CobaltExtensionDemuxerApi {
+ // Name should be the string |kCobaltExtensionDemuxerApi|.
+ // This helps to validate that the extension API is correct.
+ const char* name;
+
+ // This specifies the version of the API that is implemented.
+ uint32_t version;
+
+ // The fields below this point were added in version 1 or later.
+
+ // Creates a demuxer for the content provided by |data_source|. Ownership of
+ // |data_source| is not transferred to this function.
+ //
+ // Ownership of the returned demuxer is transferred to the caller, but it must
+ // be deleted via DestroyDemuxer (below). The caller must not manually delete
+ // the demuxer.
+ CobaltExtensionDemuxer* (*CreateDemuxer)(
+ CobaltExtensionDemuxerDataSource* data_source,
+ CobaltExtensionDemuxerAudioCodec* supported_audio_codecs,
+ int64_t supported_audio_codecs_size,
+ CobaltExtensionDemuxerVideoCodec* supported_video_codecs,
+ int64_t supported_video_codecs_size);
+
+ // Destroys |demuxer|. After calling this, |demuxer| must not be dereferenced
+ // or deleted by the caller.
+ void (*DestroyDemuxer)(CobaltExtensionDemuxer* demuxer);
+} CobaltExtensionDemuxerApi;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+
+#endif // COBALT_EXTENSION_DEMUXER_H_
diff --git a/cobalt/media/BUILD.gn b/cobalt/media/BUILD.gn
index 50a4629..e7e4b0c 100644
--- a/cobalt/media/BUILD.gn
+++ b/cobalt/media/BUILD.gn
@@ -64,6 +64,8 @@
"progressive/avc_parser.h",
"progressive/data_source_reader.cc",
"progressive/data_source_reader.h",
+ "progressive/demuxer_extension_wrapper.cc",
+ "progressive/demuxer_extension_wrapper.h",
"progressive/mp4_map.cc",
"progressive/mp4_map.h",
"progressive/mp4_parser.cc",
@@ -106,6 +108,7 @@
testonly = true
sources = [
+ "progressive/demuxer_extension_wrapper_test.cc",
"progressive/mock_data_source_reader.h",
"progressive/mp4_map_unittest.cc",
"progressive/rbsp_stream_unittest.cc",
@@ -120,5 +123,6 @@
"//cobalt/test:run_all_unittests",
"//testing/gmock",
"//testing/gtest",
+ "//third_party/chromium/media:media",
]
}
diff --git a/cobalt/media/player/web_media_player_impl.cc b/cobalt/media/player/web_media_player_impl.cc
index 19aec68..197a9a1 100644
--- a/cobalt/media/player/web_media_player_impl.cc
+++ b/cobalt/media/player/web_media_player_impl.cc
@@ -4,6 +4,7 @@
#include "cobalt/media/player/web_media_player_impl.h"
#include <cmath>
+#include <cstring>
#include <limits>
#include <memory>
#include <string>
@@ -21,7 +22,10 @@
#include "cobalt/base/instance_counter.h"
#include "cobalt/media/base/drm_system.h"
#include "cobalt/media/player/web_media_player_proxy.h"
+#include "cobalt/media/progressive/data_source_reader.h"
+#include "cobalt/media/progressive/demuxer_extension_wrapper.h"
#include "cobalt/media/progressive/progressive_demuxer.h"
+#include "starboard/system.h"
#include "starboard/types.h"
#include "third_party/chromium/media/base/bind_to_current_loop.h"
#include "third_party/chromium/media/base/limits.h"
@@ -275,8 +279,19 @@
is_local_source_ = !url.SchemeIs("http") && !url.SchemeIs("https");
- progressive_demuxer_.reset(new ProgressiveDemuxer(
- pipeline_thread_.task_runner(), proxy_->data_source(), media_log_));
+ // Attempt to use the demuxer provided via Cobalt Extension, if available.
+ progressive_demuxer_ = DemuxerExtensionWrapper::Create(
+ proxy_->data_source(), pipeline_thread_.task_runner());
+
+ if (progressive_demuxer_) {
+ LOG(INFO) << "Using DemuxerExtensionWrapper.";
+ } else {
+ // Either the demuxer Cobalt extension was not provided, or it failed to
+ // create a demuxer; fall back to the ProgressiveDemuxer.
+ LOG(INFO) << "Using ProgressiveDemuxer.";
+ progressive_demuxer_.reset(new ProgressiveDemuxer(
+ pipeline_thread_.task_runner(), proxy_->data_source(), media_log_));
+ }
state_.is_progressive = true;
StartPipeline(progressive_demuxer_.get());
diff --git a/cobalt/media/progressive/demuxer_extension_wrapper.cc b/cobalt/media/progressive/demuxer_extension_wrapper.cc
new file mode 100644
index 0000000..f4c8139
--- /dev/null
+++ b/cobalt/media/progressive/demuxer_extension_wrapper.cc
@@ -0,0 +1,1121 @@
+// Copyright 2022 The Cobalt Authors. 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 "cobalt/media/progressive/demuxer_extension_wrapper.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/task/post_task.h"
+#include "base/task_runner_util.h"
+#include "cobalt/extension/demuxer.h"
+#include "starboard/system.h"
+#include "third_party/chromium/media/base/audio_codecs.h"
+#include "third_party/chromium/media/base/bind_to_current_loop.h"
+#include "third_party/chromium/media/base/encryption_scheme.h"
+#include "third_party/chromium/media/base/sample_format.h"
+#include "third_party/chromium/media/base/starboard_utils.h"
+#include "third_party/chromium/media/base/video_types.h"
+#include "third_party/chromium/media/cobalt/ui/gfx/color_space.h"
+#include "third_party/chromium/media/cobalt/ui/gfx/geometry/rect.h"
+#include "third_party/chromium/media/cobalt/ui/gfx/geometry/size.h"
+#include "third_party/chromium/media/filters/h264_to_annex_b_bitstream_converter.h"
+#include "third_party/chromium/media/formats/mp4/box_definitions.h"
+
+namespace cobalt {
+namespace media {
+
+using ::media::AudioCodec;
+using ::media::AudioDecoderConfig;
+using ::media::ChannelLayout;
+using ::media::DecoderBuffer;
+using ::media::DemuxerHost;
+using ::media::DemuxerStream;
+using ::media::EncryptionScheme;
+using ::media::H264ToAnnexBBitstreamConverter;
+using ::media::MediaTrack;
+using ::media::PipelineStatus;
+using ::media::PipelineStatusCallback;
+using ::media::PipelineStatusCB;
+using ::media::Ranges;
+using ::media::SampleFormat;
+using ::media::VideoCodec;
+using ::media::VideoCodecProfile;
+using ::media::VideoColorSpace;
+using ::media::VideoDecoderConfig;
+using ::media::VideoPixelFormat;
+using ::media::VideoTransformation;
+using ::media::mp4::AVCDecoderConfigurationRecord;
+
+// Used to convert a lambda to a pure C function.
+// |user_data| is a callback of type T, which takes a U*.
+template <typename T, typename U>
+static void CallCB(U* u, void* user_data) {
+ (*static_cast<T*>(user_data))(u);
+}
+
+// Converts AVCC h.264 frames to Annex B. This is necessary because the decoder
+// expects packets in Annex B format.
+class DemuxerExtensionWrapper::H264AnnexBConverter {
+ public:
+ // Creates an H264AnnexBConverter from the MP4 file's header data.
+ static std::unique_ptr<H264AnnexBConverter> Create(const uint8_t* extra_data,
+ size_t extra_data_size) {
+ if (!extra_data || extra_data_size == 0) {
+ LOG(ERROR) << "Invalid inputs to H264AnnexBConverter::Create.";
+ return nullptr;
+ }
+ AVCDecoderConfigurationRecord config;
+ std::unique_ptr<H264ToAnnexBBitstreamConverter> converter(
+ new H264ToAnnexBBitstreamConverter);
+ if (!converter->ParseConfiguration(
+ extra_data, static_cast<int>(extra_data_size), &config)) {
+ LOG(ERROR) << "Could not parse AVCC config.";
+ return nullptr;
+ }
+ return std::unique_ptr<H264AnnexBConverter>(
+ new H264AnnexBConverter(std::move(config), std::move(converter)));
+ }
+
+ // Disallow copy and assign.
+ H264AnnexBConverter(const H264AnnexBConverter&) = delete;
+ H264AnnexBConverter& operator=(const H264AnnexBConverter&) = delete;
+
+ ~H264AnnexBConverter() = default;
+
+ // Attempts to convert the data in |data| from AVCC to AnnexB format,
+ // returning the data as a DecoderBuffer. Upon failure, the data will be
+ // returned unmodified in the DecoderBuffer.
+ scoped_refptr<DecoderBuffer> Convert(const uint8_t* data, size_t data_size) {
+ const auto* const config = config_.has_value() ? &*config_ : nullptr;
+
+ std::vector<uint8_t> rewritten(
+ converter_->CalculateNeededOutputBufferSize(data, data_size, config));
+
+ uint32_t rewritten_size = rewritten.size();
+ if (rewritten.empty() ||
+ !converter_->ConvertNalUnitStreamToByteStream(
+ data, data_size, config, rewritten.data(), &rewritten_size)) {
+ // TODO(b/231994311): Add the buffer's side_data here, for HDR10+ support.
+ return DecoderBuffer::CopyFrom(data, data_size);
+ } else {
+ // The data was successfully rewritten.
+
+ // The SPS and PPS NALUs -- generated from the config -- should only be
+ // sent with the first real NALU.
+ config_ = base::nullopt;
+
+ // TODO(b/231994311): Add the buffer's side_data here, for HDR10+ support.
+ return DecoderBuffer::CopyFrom(rewritten.data(), rewritten.size());
+ }
+ }
+
+ private:
+ explicit H264AnnexBConverter(
+ AVCDecoderConfigurationRecord config,
+ std::unique_ptr<H264ToAnnexBBitstreamConverter> converter)
+ : config_(std::move(config)), converter_(std::move(converter)) {}
+
+ // This config data is only sent with the first NALU (as SPS and PPS NALUs).
+ base::Optional<AVCDecoderConfigurationRecord> config_;
+ std::unique_ptr<H264ToAnnexBBitstreamConverter> converter_;
+};
+
+DemuxerExtensionStream::DemuxerExtensionStream(
+ CobaltExtensionDemuxer* demuxer,
+ scoped_refptr<base::SequencedTaskRunner> message_loop,
+ CobaltExtensionDemuxerVideoDecoderConfig config)
+ : demuxer_(demuxer), message_loop_(std::move(message_loop)) {
+ CHECK(demuxer_);
+ CHECK(message_loop_);
+ std::vector<uint8_t> extra_data;
+ if (config.extra_data_size > 0 && config.extra_data != nullptr) {
+ extra_data.assign(config.extra_data,
+ config.extra_data + config.extra_data_size);
+ }
+
+ video_config_.emplace(
+ static_cast<VideoCodec>(config.codec),
+ static_cast<VideoCodecProfile>(config.profile),
+ static_cast<VideoDecoderConfig::AlphaMode>(config.alpha_mode),
+ VideoColorSpace(
+ config.color_space_primaries, config.color_space_transfer,
+ config.color_space_matrix,
+ static_cast<gfx::ColorSpace::RangeID>(config.color_space_range_id)),
+ VideoTransformation(), gfx::Size(config.coded_width, config.coded_height),
+ gfx::Rect(config.visible_rect_x, config.visible_rect_y,
+ config.visible_rect_width, config.visible_rect_height),
+ gfx::Size(config.natural_width, config.natural_height), extra_data,
+ static_cast<EncryptionScheme>(config.encryption_scheme));
+
+ LOG_IF(ERROR, !video_config_->IsValidConfig())
+ << "Video config is not valid!";
+}
+
+DemuxerExtensionStream::DemuxerExtensionStream(
+ CobaltExtensionDemuxer* demuxer,
+ scoped_refptr<base::SequencedTaskRunner> message_loop,
+ CobaltExtensionDemuxerAudioDecoderConfig config)
+ : demuxer_(demuxer), message_loop_(std::move(message_loop)) {
+ CHECK(demuxer_);
+ CHECK(message_loop_);
+ std::vector<uint8_t> extra_data;
+ if (config.extra_data_size > 0 && config.extra_data != nullptr) {
+ extra_data.assign(config.extra_data,
+ config.extra_data + config.extra_data_size);
+ }
+
+ audio_config_.emplace(
+ static_cast<AudioCodec>(config.codec),
+ static_cast<SampleFormat>(config.sample_format),
+ static_cast<ChannelLayout>(config.channel_layout),
+ config.samples_per_second, extra_data,
+ static_cast<EncryptionScheme>(config.encryption_scheme));
+
+ LOG_IF(ERROR, !audio_config_->IsValidConfig())
+ << "Audio config is not valid!";
+}
+
+void DemuxerExtensionStream::Read(ReadCB read_cb) {
+ DCHECK(!read_cb.is_null());
+ base::AutoLock auto_lock(lock_);
+ if (stopped_) {
+ LOG(INFO) << "Already stopped.";
+ std::move(read_cb).Run(
+ DemuxerStream::kOk,
+ scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
+ return;
+ }
+
+ // Buffers are only queued when there are no pending reads.
+ CHECK(buffer_queue_.empty() || read_queue_.empty());
+
+ if (buffer_queue_.empty()) {
+ read_queue_.push_back(std::move(read_cb));
+ return;
+ }
+
+ // We already have a buffer queued. Send the oldest buffer back.
+ scoped_refptr<DecoderBuffer> buffer = buffer_queue_.front();
+ if (!buffer->end_of_stream()) {
+ // Do not pop EOS buffers, so that subsequent read requests also get EOS.
+ total_buffer_size_ -= buffer->data_size();
+ buffer_queue_.pop_front();
+ }
+
+ std::move(read_cb).Run(DemuxerStream::kOk, buffer);
+}
+
+AudioDecoderConfig DemuxerExtensionStream::audio_decoder_config() {
+ DCHECK(audio_config_.has_value());
+ return *audio_config_;
+}
+
+VideoDecoderConfig DemuxerExtensionStream::video_decoder_config() {
+ DCHECK(video_config_.has_value());
+ return *video_config_;
+}
+
+DemuxerStream::Type DemuxerExtensionStream::type() const {
+ const uint8_t is_audio = static_cast<int>(audio_config_.has_value());
+ const uint8_t is_video = static_cast<int>(video_config_.has_value());
+ DCHECK((is_audio ^ is_video) == 1);
+ return is_audio ? Type::AUDIO : Type::VIDEO;
+}
+
+Ranges<base::TimeDelta> DemuxerExtensionStream::GetBufferedRanges() {
+ return buffered_ranges_;
+}
+
+void DemuxerExtensionStream::EnqueueBuffer(
+ scoped_refptr<DecoderBuffer> buffer) {
+ base::AutoLock auto_lock(lock_);
+
+ if (stopped_) {
+ // It is possible due to pipelining -- both downstream and within the
+ // demuxer -- that several pipelined reads will be enqueuing packets on a
+ // stopped stream. These will be dropped.
+ LOG(WARNING) << "attempted to enqueue packet on stopped stream";
+ return;
+ }
+
+ if (buffer->end_of_stream()) {
+ LOG(INFO) << "Received EOS";
+ } else if (buffer->timestamp() != ::media::kNoTimestamp) {
+ if (last_buffer_timestamp_ != ::media::kNoTimestamp &&
+ last_buffer_timestamp_ < buffer->timestamp()) {
+ buffered_ranges_.Add(last_buffer_timestamp_, buffer->timestamp());
+ }
+ last_buffer_timestamp_ = buffer->timestamp();
+ } else {
+ LOG(WARNING) << "Bad timestamp info on enqueued buffer.";
+ }
+
+ if (read_queue_.empty()) {
+ buffer_queue_.push_back(buffer);
+ if (!buffer->end_of_stream()) {
+ total_buffer_size_ += buffer->data_size();
+ }
+ return;
+ }
+
+ // A pending read implies that the buffer queue was empty; otherwise it should
+ // never have been added to the read queue in the first place.
+ CHECK_EQ(buffer_queue_.size(), 0);
+ ReadCB read_cb(std::move(read_queue_.front()));
+ read_queue_.pop_front();
+ std::move(read_cb).Run(DemuxerStream::kOk, std::move(buffer));
+}
+
+void DemuxerExtensionStream::FlushBuffers() {
+ base::AutoLock auto_lock(lock_);
+ buffer_queue_.clear();
+ total_buffer_size_ = 0;
+ last_buffer_timestamp_ = ::media::kNoTimestamp;
+}
+
+void DemuxerExtensionStream::Stop() {
+ DCHECK(message_loop_->RunsTasksInCurrentSequence());
+
+ base::AutoLock auto_lock(lock_);
+ buffer_queue_.clear();
+ total_buffer_size_ = 0;
+ last_buffer_timestamp_ = ::media::kNoTimestamp;
+ // Fulfill any pending callbacks with EOS buffers set to end timestamp.
+ for (auto& read_cb : read_queue_) {
+ std::move(read_cb).Run(
+ DemuxerStream::kOk,
+ scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
+ }
+ read_queue_.clear();
+ stopped_ = true;
+}
+
+base::TimeDelta DemuxerExtensionStream::GetLastBufferTimestamp() const {
+ base::AutoLock auto_lock(lock_);
+ return last_buffer_timestamp_;
+}
+
+size_t DemuxerExtensionStream::GetTotalBufferSize() const {
+ base::AutoLock auto_lock(lock_);
+ return total_buffer_size_;
+}
+
+PositionalDataSource::PositionalDataSource(
+ scoped_refptr<DataSourceReader> reader)
+ : reader_(std::move(reader)), position_(0) {
+ CHECK(reader_);
+}
+
+PositionalDataSource::~PositionalDataSource() = default;
+
+void PositionalDataSource::Stop() { reader_->Stop(); }
+
+int PositionalDataSource::BlockingRead(uint8_t* data, int bytes_requested) {
+ const int bytes_read =
+ reader_->BlockingRead(position_, bytes_requested, data);
+ if (bytes_read != DataSourceReader::kReadError) {
+ position_ += bytes_read;
+ }
+ return bytes_read;
+}
+
+void PositionalDataSource::SeekTo(int position) { position_ = position; }
+
+int64_t PositionalDataSource::GetPosition() const { return position_; }
+
+int64_t PositionalDataSource::GetSize() { return reader_->FileSize(); }
+
+// Functions for converting a PositionalDataSource to
+// CobaltExtensionDemuxerDataSource.
+static int CobaltExtensionDemuxerDataSource_BlockingReadRead(
+ uint8_t* data, int bytes_requested, void* user_data) {
+ return static_cast<PositionalDataSource*>(user_data)->BlockingRead(
+ data, bytes_requested);
+}
+
+static void CobaltExtensionDemuxerDataSource_SeekTo(int position,
+ void* user_data) {
+ static_cast<PositionalDataSource*>(user_data)->SeekTo(position);
+}
+
+static int64_t CobaltExtensionDemuxerDataSource_GetPosition(void* user_data) {
+ return static_cast<PositionalDataSource*>(user_data)->GetPosition();
+}
+
+static int64_t CobaltExtensionDemuxerDataSource_GetSize(void* user_data) {
+ return static_cast<PositionalDataSource*>(user_data)->GetSize();
+}
+
+std::unique_ptr<DemuxerExtensionWrapper> DemuxerExtensionWrapper::Create(
+ DataSource* data_source,
+ scoped_refptr<base::SequencedTaskRunner> message_loop,
+ const CobaltExtensionDemuxerApi* demuxer_api) {
+ if (demuxer_api == nullptr) {
+ // Attempt to use the Cobalt extension.
+ demuxer_api = static_cast<const CobaltExtensionDemuxerApi*>(
+ SbSystemGetExtension(kCobaltExtensionDemuxerApi));
+ if (!demuxer_api ||
+ strcmp(demuxer_api->name, kCobaltExtensionDemuxerApi) != 0) {
+ return nullptr;
+ }
+ }
+
+ DCHECK(demuxer_api);
+ if (demuxer_api->version < 1) {
+ LOG(ERROR) << "Demuxer API version is too low: " << demuxer_api->version;
+ return nullptr;
+ }
+
+ if (!data_source || !message_loop) {
+ LOG(ERROR) << "data_source and message_loop cannot be null.";
+ return nullptr;
+ }
+
+ scoped_refptr<DataSourceReader> reader = new DataSourceReader;
+ reader->SetDataSource(data_source);
+
+ std::unique_ptr<PositionalDataSource> positional_data_source(
+ new PositionalDataSource(std::move(reader)));
+
+ std::unique_ptr<CobaltExtensionDemuxerDataSource> c_data_source(
+ new CobaltExtensionDemuxerDataSource{
+ /*BlockingRead=*/&CobaltExtensionDemuxerDataSource_BlockingReadRead,
+ /*SeekTo=*/&CobaltExtensionDemuxerDataSource_SeekTo,
+ /*GetPosition=*/&CobaltExtensionDemuxerDataSource_GetPosition,
+ /*GetSize=*/&CobaltExtensionDemuxerDataSource_GetSize,
+ /*is_streaming=*/false,
+ /*user_data=*/positional_data_source.get()});
+
+ // TODO(b/231632632): Populate these vectors.
+ std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+ std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+ CobaltExtensionDemuxer* demuxer = demuxer_api->CreateDemuxer(
+ c_data_source.get(), supported_audio_codecs.data(),
+ supported_audio_codecs.size(), supported_video_codecs.data(),
+ supported_video_codecs.size());
+
+ if (!demuxer) {
+ LOG(ERROR) << "Failed to create a CobaltExtensionDemuxer.";
+ return nullptr;
+ }
+
+ return std::unique_ptr<DemuxerExtensionWrapper>(new DemuxerExtensionWrapper(
+ demuxer_api, demuxer, std::move(positional_data_source),
+ std::move(c_data_source), std::move(message_loop)));
+}
+
+DemuxerExtensionWrapper::DemuxerExtensionWrapper(
+ const CobaltExtensionDemuxerApi* demuxer_api,
+ CobaltExtensionDemuxer* demuxer,
+ std::unique_ptr<PositionalDataSource> data_source,
+ std::unique_ptr<CobaltExtensionDemuxerDataSource> c_data_source,
+ scoped_refptr<base::SequencedTaskRunner> message_loop)
+ : demuxer_api_(demuxer_api),
+ impl_(demuxer),
+ data_source_(std::move(data_source)),
+ c_data_source_(std::move(c_data_source)),
+ blocking_thread_("DemuxerExtensionWrapperBlockingThread"),
+ message_loop_(std::move(message_loop)) {
+ CHECK(demuxer_api_);
+ CHECK(impl_);
+ CHECK(data_source_);
+ CHECK(c_data_source_);
+ CHECK(message_loop_);
+}
+
+DemuxerExtensionWrapper::~DemuxerExtensionWrapper() {
+ if (impl_) {
+ demuxer_api_->DestroyDemuxer(impl_);
+ }
+ // Explicitly stop |blocking_thread_| to ensure that it stops before the
+ // destruction of any other members.
+ blocking_thread_.Stop();
+}
+
+std::vector<DemuxerStream*> DemuxerExtensionWrapper::GetAllStreams() {
+ std::vector<DemuxerStream*> streams;
+ if (audio_stream_.has_value()) {
+ streams.push_back(&*audio_stream_);
+ }
+ if (video_stream_.has_value()) {
+ streams.push_back(&*video_stream_);
+ }
+ return streams;
+}
+
+std::string DemuxerExtensionWrapper::GetDisplayName() const {
+ return "DemuxerExtensionWrapper";
+}
+void DemuxerExtensionWrapper::Initialize(DemuxerHost* host,
+ PipelineStatusCallback status_cb) {
+ DCHECK(message_loop_->RunsTasksInCurrentSequence());
+ host_ = host;
+
+ // Start the blocking thread and have it download and parse the media config.
+ if (!blocking_thread_.Start()) {
+ LOG(ERROR) << "Unable to start blocking thread";
+ std::move(status_cb).Run(::media::DEMUXER_ERROR_COULD_NOT_PARSE);
+ return;
+ }
+
+ // |status_cb| cannot be called until this function returns, so we post a task
+ // here.
+ base::PostTaskAndReplyWithResult(
+ blocking_thread_.message_loop()->task_runner().get(), FROM_HERE,
+ base::BindOnce(impl_->Initialize, impl_->user_data),
+ base::BindOnce(&DemuxerExtensionWrapper::OnInitializeDone,
+ base::Unretained(this), std::move(status_cb)));
+}
+
+void DemuxerExtensionWrapper::OnInitializeDone(
+ PipelineStatusCallback status_cb, CobaltExtensionDemuxerStatus status) {
+ if (status == kCobaltExtensionDemuxerOk) {
+ // Set up the stream(s) on this end.
+ CobaltExtensionDemuxerAudioDecoderConfig audio_config = {};
+ if (impl_->GetAudioConfig(&audio_config, impl_->user_data)) {
+ if (audio_config.encryption_scheme !=
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted) {
+ // TODO(b/232957482): Determine whether we need to handle this case.
+ LOG(ERROR)
+ << "Encrypted audio is not supported for progressive playback.";
+ std::move(status_cb).Run(::media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+ return;
+ }
+ audio_stream_.emplace(impl_, message_loop_, std::move(audio_config));
+ }
+ CobaltExtensionDemuxerVideoDecoderConfig video_config = {};
+ if (impl_->GetVideoConfig(&video_config, impl_->user_data)) {
+ if (video_config.encryption_scheme !=
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted) {
+ // TODO(b/232957482): Determine whether we need to handle this case.
+ LOG(ERROR)
+ << "Encrypted video is not supported for progressive playback.";
+ std::move(status_cb).Run(::media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+ return;
+ }
+ if (video_config.extra_data && video_config.extra_data_size > 0 &&
+ video_config.codec == kCobaltExtensionDemuxerCodecH264) {
+ // This is probably an AVCC stream. We'll need to convert each packet
+ // from AVCC to AnnexB, so we create the converter based on the "extra
+ // data". This extra data will be passed in the form of SPS and PPS NALU
+ // packets in the AnnexB stream.
+ h264_converter_ = H264AnnexBConverter::Create(
+ video_config.extra_data, video_config.extra_data_size);
+ video_config.extra_data = nullptr;
+ video_config.extra_data_size = 0;
+ }
+ video_stream_.emplace(impl_, message_loop_, std::move(video_config));
+ }
+
+ if (!audio_stream_.has_value() && !video_stream_.has_value()) {
+ // Even though initialization seems to have succeeded, something is wrong
+ // if there are no streams.
+ LOG(ERROR) << "No streams are present";
+ std::move(status_cb).Run(::media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+ return;
+ }
+
+ host_->SetDuration(base::TimeDelta::FromMicroseconds(
+ impl_->GetDuration(impl_->user_data)));
+
+ // Begin downloading data.
+ Request(audio_stream_.has_value() ? DemuxerStream::AUDIO
+ : DemuxerStream::VIDEO);
+ } else {
+ LOG(ERROR) << "Initialization failed with status " << status;
+ }
+ std::move(status_cb).Run(static_cast<PipelineStatus>(status));
+}
+
+void DemuxerExtensionWrapper::AbortPendingReads() {}
+
+void DemuxerExtensionWrapper::StartWaitingForSeek(base::TimeDelta seek_time) {}
+
+void DemuxerExtensionWrapper::CancelPendingSeek(base::TimeDelta seek_time) {}
+
+void DemuxerExtensionWrapper::Seek(base::TimeDelta time,
+ PipelineStatusCallback status_cb) {
+ // It's safe to use base::Unretained here because blocking_thread_ will be
+ // stopped in this class's destructor.
+ blocking_thread_.message_loop()->task_runner()->PostTask(
+ FROM_HERE,
+ base::BindOnce(&DemuxerExtensionWrapper::SeekTask, base::Unretained(this),
+ time, BindToCurrentLoop(std::move(status_cb))));
+}
+
+// TODO(b/232984963): Determine whether it's OK to have reads and seeks on the
+// same thread.
+void DemuxerExtensionWrapper::SeekTask(base::TimeDelta time,
+ PipelineStatusCallback status_cb) {
+ CHECK(blocking_thread_.message_loop()
+ ->task_runner()
+ ->RunsTasksInCurrentSequence());
+
+ // clear any enqueued buffers on demuxer streams
+ if (video_stream_.has_value()) video_stream_->FlushBuffers();
+ if (audio_stream_.has_value()) audio_stream_->FlushBuffers();
+
+ const CobaltExtensionDemuxerStatus status =
+ impl_->Seek(time.InMicroseconds(), impl_->user_data);
+
+ if (status != kCobaltExtensionDemuxerOk) {
+ LOG(ERROR) << "Seek failed with status " << status;
+ std::move(status_cb).Run(::media::PIPELINE_ERROR_READ);
+ return;
+ }
+
+ // If all streams had finished downloading, we need to restart the request.
+ const bool issue_new_request =
+ (!video_stream_.has_value() || video_reached_eos_) &&
+ (!audio_stream_.has_value() || audio_reached_eos_);
+ audio_reached_eos_ = false;
+ video_reached_eos_ = false;
+ flushing_ = true;
+ std::move(status_cb).Run(::media::PIPELINE_OK);
+
+ if (issue_new_request) {
+ IssueNextRequest();
+ }
+}
+
+Ranges<base::TimeDelta> DemuxerExtensionWrapper::GetBufferedRanges() {
+ DCHECK(audio_stream_.has_value() || video_stream_.has_value());
+
+ if (!audio_stream_.has_value()) {
+ return video_stream_->GetBufferedRanges();
+ }
+ if (!video_stream_.has_value()) {
+ return audio_stream_->GetBufferedRanges();
+ }
+ return video_stream_->GetBufferedRanges().IntersectionWith(
+ audio_stream_->GetBufferedRanges());
+}
+
+void DemuxerExtensionWrapper::Stop() {
+ DCHECK(message_loop_->RunsTasksInCurrentSequence());
+ {
+ base::AutoLock lock(lock_for_stopped_);
+ stopped_ = true;
+ }
+ data_source_->Stop();
+}
+
+base::TimeDelta DemuxerExtensionWrapper::GetStartTime() const {
+ return base::TimeDelta::FromMicroseconds(
+ impl_->GetStartTime(impl_->user_data));
+}
+
+base::Time DemuxerExtensionWrapper::GetTimelineOffset() const {
+ const SbTime reported_time = impl_->GetTimelineOffset(impl_->user_data);
+ return reported_time == 0
+ ? base::Time()
+ : base::Time::FromDeltaSinceWindowsEpoch(
+ base::TimeDelta::FromMicroseconds(reported_time));
+}
+
+int64_t DemuxerExtensionWrapper::GetMemoryUsage() const {
+ NOTREACHED();
+ return 0;
+}
+
+void DemuxerExtensionWrapper::OnEnabledAudioTracksChanged(
+ const std::vector<MediaTrack::Id>& track_ids, base::TimeDelta curr_time,
+ TrackChangeCB change_completed_cb) {
+ NOTREACHED();
+}
+
+void DemuxerExtensionWrapper::OnSelectedVideoTrackChanged(
+ const std::vector<MediaTrack::Id>& track_ids, base::TimeDelta curr_time,
+ TrackChangeCB change_completed_cb) {
+ NOTREACHED();
+}
+
+void DemuxerExtensionWrapper::Request(DemuxerStream::Type type) {
+ static const auto kRequestDelay = base::TimeDelta::FromMilliseconds(100);
+
+ if (type == DemuxerStream::AUDIO) {
+ DCHECK(audio_stream_.has_value());
+ } else {
+ DCHECK(video_stream_.has_value());
+ }
+
+ if (!blocking_thread_.task_runner()->BelongsToCurrentThread()) {
+ blocking_thread_.task_runner()->PostTask(
+ FROM_HERE, base::Bind(&DemuxerExtensionWrapper::Request,
+ base::Unretained(this), type));
+ return;
+ }
+
+ if (HasStopped()) {
+ return;
+ }
+
+ const size_t total_buffer_size =
+ (audio_stream_.has_value() ? audio_stream_->GetTotalBufferSize() : 0) +
+ (video_stream_.has_value() ? video_stream_->GetTotalBufferSize() : 0);
+
+ int progressive_budget = 0;
+ if (video_stream_.has_value()) {
+ const VideoDecoderConfig video_config =
+ video_stream_->video_decoder_config();
+ // Only sdr video is supported in progressive mode.
+ // TODO(b/231994311): Figure out how to set this value properly.
+ constexpr int kBitDepth = 8;
+ progressive_budget = SbMediaGetProgressiveBufferBudget(
+ MediaVideoCodecToSbMediaVideoCodec(video_config.codec()),
+ video_config.visible_rect().size().width(),
+ video_config.visible_rect().size().height(), kBitDepth);
+ } else {
+ progressive_budget = SbMediaGetAudioBufferBudget();
+ }
+
+ if (total_buffer_size >= progressive_budget) {
+ // Retry after a delay.
+ blocking_thread_.message_loop()->task_runner()->PostDelayedTask(
+ FROM_HERE,
+ base::Bind(&DemuxerExtensionWrapper::Request, base::Unretained(this),
+ type),
+ kRequestDelay);
+ return;
+ }
+
+ scoped_refptr<DecoderBuffer> decoder_buffer;
+ bool called_cb = false;
+ auto read_cb = [this, type, &decoder_buffer,
+ &called_cb](CobaltExtensionDemuxerBuffer* buffer) {
+ called_cb = true;
+ if (!buffer) {
+ return;
+ }
+
+ if (buffer->end_of_stream) {
+ decoder_buffer = DecoderBuffer::CreateEOSBuffer();
+ return;
+ }
+
+ if (h264_converter_ && type == DemuxerExtensionStream::VIDEO) {
+ // This converts from AVCC to AnnexB format for h.264 video.
+ decoder_buffer =
+ h264_converter_->Convert(buffer->data, buffer->data_size);
+ } else {
+ // TODO(b/231994311): Add the buffer's side_data here, for HDR10+ support.
+ decoder_buffer = DecoderBuffer::CopyFrom(buffer->data, buffer->data_size);
+ }
+
+ decoder_buffer->set_timestamp(
+ base::TimeDelta::FromMicroseconds(buffer->pts));
+ decoder_buffer->set_duration(
+ base::TimeDelta::FromMicroseconds(buffer->duration));
+ decoder_buffer->set_is_key_frame(buffer->is_keyframe);
+ };
+ impl_->Read(static_cast<CobaltExtensionDemuxerStreamType>(type),
+ &CallCB<decltype(read_cb), CobaltExtensionDemuxerBuffer>,
+ &read_cb, impl_->user_data);
+
+ if (!called_cb) {
+ LOG(ERROR)
+ << "Demuxer extension implementation did not call the read callback.";
+ host_->OnDemuxerError(::media::PIPELINE_ERROR_READ);
+ return;
+ }
+ if (!decoder_buffer) {
+ LOG(ERROR) << "Received a null buffer from the demuxer.";
+ host_->OnDemuxerError(::media::PIPELINE_ERROR_READ);
+ return;
+ }
+
+ auto& stream =
+ (type == DemuxerStream::AUDIO) ? *audio_stream_ : *video_stream_;
+ bool& eos_status =
+ (type == DemuxerStream::AUDIO) ? audio_reached_eos_ : video_reached_eos_;
+
+ eos_status = decoder_buffer->end_of_stream();
+ stream.EnqueueBuffer(std::move(decoder_buffer));
+ if (!eos_status) {
+ host_->OnBufferedTimeRangesChanged(GetBufferedRanges());
+ }
+
+ // If we reach this point, enqueueing the buffer was successful.
+ IssueNextRequest();
+ return;
+}
+
+void DemuxerExtensionWrapper::IssueNextRequest() {
+ {
+ base::AutoLock lock(lock_for_stopped_);
+ if (stopped_) {
+ LOG(INFO) << "Already stopped; request loop is stopping.";
+ return;
+ }
+ }
+
+ DemuxerStream::Type type = DemuxerStream::UNKNOWN;
+ if (audio_reached_eos_ || video_reached_eos_) {
+ // If we have eos in one or both buffers, the decision is easy.
+ if ((audio_reached_eos_ && video_reached_eos_) ||
+ (audio_reached_eos_ && !video_stream_.has_value()) ||
+ (video_reached_eos_ && !audio_stream_.has_value())) {
+ LOG(INFO) << "All streams at EOS, request loop is stopping.";
+ return;
+ }
+ // Only one of two streams is at eos; download data for the stream NOT at
+ // eos.
+ type = audio_reached_eos_ ? DemuxerStream::VIDEO : DemuxerStream::AUDIO;
+ } else if (!audio_stream_.has_value() || !video_stream_.has_value()) {
+ // If only one stream is present and not at eos, just download that data.
+ type =
+ audio_stream_.has_value() ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
+ } else {
+ // Both streams are present, and neither is at eos. Priority order for
+ // figuring out what to download next.
+ const base::TimeDelta audio_stamp = audio_stream_->GetLastBufferTimestamp();
+ const base::TimeDelta video_stamp = video_stream_->GetLastBufferTimestamp();
+ // If the audio demuxer stream is empty, always fill it first.
+ if (audio_stamp == ::media::kNoTimestamp) {
+ type = DemuxerStream::AUDIO;
+ } else if (video_stamp == ::media::kNoTimestamp) {
+ // The video demuxer stream is empty; we need data for it.
+ type = DemuxerStream::VIDEO;
+ } else if (video_stamp < audio_stamp) {
+ // Video is earlier; fill it first.
+ type = DemuxerStream::VIDEO;
+ } else {
+ type = DemuxerStream::AUDIO;
+ }
+ }
+
+ DCHECK_NE(type, DemuxerStream::UNKNOWN);
+ // We cannot call Request() directly even if this function is also run on
+ // |blocking_thread_| as otherwise it is possible that this function is
+ // running in a tight loop and seek/stop requests would have no chance to kick
+ // in.
+ blocking_thread_.task_runner()->PostTask(
+ FROM_HERE, base::Bind(&DemuxerExtensionWrapper::Request,
+ base::Unretained(this), type));
+}
+
+bool DemuxerExtensionWrapper::HasStopped() {
+ base::AutoLock lock(lock_for_stopped_);
+ return stopped_;
+}
+
+namespace {
+
+// Ensure that the demuxer extension's enums match up with the internal enums.
+// This doesn't affect any code, but prevents compilation if there's a mismatch
+// somewhere.
+#define DEMUXER_EXTENSION_ENUM_EQ(a, b) \
+ COMPILE_ASSERT(static_cast<int>(a) == static_cast<int>(b), mismatching_enums)
+
+// Pipeline status.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerOk, ::media::PIPELINE_OK);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorNetwork,
+ ::media::PIPELINE_ERROR_NETWORK);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorAbort,
+ ::media::PIPELINE_ERROR_ABORT);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorInitializationFailed,
+ ::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorRead,
+ ::media::PIPELINE_ERROR_READ);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorInvalidState,
+ ::media::PIPELINE_ERROR_INVALID_STATE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorCouldNotOpen,
+ ::media::DEMUXER_ERROR_COULD_NOT_OPEN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorCouldNotParse,
+ ::media::DEMUXER_ERROR_COULD_NOT_PARSE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerErrorNoSupportedStreams,
+ ::media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+
+// Audio codecs.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecUnknownAudio,
+ ::media::AudioCodec::kUnknown);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecAAC,
+ ::media::AudioCodec::kAAC);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecMP3,
+ ::media::AudioCodec::kMP3);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecPCM,
+ ::media::AudioCodec::kPCM);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecVorbis,
+ ::media::AudioCodec::kVorbis);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecFLAC,
+ ::media::AudioCodec::kFLAC);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecAMR_NB,
+ ::media::AudioCodec::kAMR_NB);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecAMR_WB,
+ ::media::AudioCodec::kAMR_WB);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecPCM_MULAW,
+ ::media::AudioCodec::kPCM_MULAW);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecGSM_MS,
+ ::media::AudioCodec::kGSM_MS);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecPCM_S16BE,
+ ::media::AudioCodec::kPCM_S16BE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecPCM_S24BE,
+ ::media::AudioCodec::kPCM_S24BE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecOpus,
+ ::media::AudioCodec::kOpus);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecEAC3,
+ ::media::AudioCodec::kEAC3);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecPCM_ALAW,
+ ::media::AudioCodec::kPCM_ALAW);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecALAC,
+ ::media::AudioCodec::kALAC);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecAC3,
+ ::media::AudioCodec::kAC3);
+
+
+// Video codecs.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecUnknownVideo,
+ ::media::VideoCodec::kUnknown);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecH264,
+ ::media::VideoCodec::kH264);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecVC1,
+ ::media::VideoCodec::kVC1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecMPEG2,
+ ::media::VideoCodec::kMPEG2);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecMPEG4,
+ ::media::VideoCodec::kMPEG4);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecTheora,
+ ::media::VideoCodec::kTheora);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecVP8,
+ ::media::VideoCodec::kVP8);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecVP9,
+ ::media::VideoCodec::kVP9);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecHEVC,
+ ::media::VideoCodec::kHEVC);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecDolbyVision,
+ ::media::VideoCodec::kDolbyVision);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerCodecAV1,
+ ::media::VideoCodec::kAV1);
+
+// Sample formats.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatUnknown,
+ ::media::kUnknownSampleFormat);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatU8,
+ ::media::kSampleFormatU8);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatS16,
+ ::media::kSampleFormatS16);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatS32,
+ ::media::kSampleFormatS32);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatF32,
+ ::media::kSampleFormatF32);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatPlanarS16,
+ ::media::kSampleFormatPlanarS16);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatPlanarF32,
+ ::media::kSampleFormatPlanarF32);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatPlanarS32,
+ ::media::kSampleFormatPlanarS32);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerSampleFormatS24,
+ ::media::kSampleFormatS24);
+
+
+// Channel layouts.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutNone,
+ ::media::CHANNEL_LAYOUT_NONE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutUnsupported,
+ ::media::CHANNEL_LAYOUT_UNSUPPORTED);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutMono,
+ ::media::CHANNEL_LAYOUT_MONO);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutStereo,
+ ::media::CHANNEL_LAYOUT_STEREO);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout2_1,
+ ::media::CHANNEL_LAYOUT_2_1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutSurround,
+ ::media::CHANNEL_LAYOUT_SURROUND);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout4_0,
+ ::media::CHANNEL_LAYOUT_4_0);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout2_2,
+ ::media::CHANNEL_LAYOUT_2_2);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutQuad,
+ ::media::CHANNEL_LAYOUT_QUAD);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout5_0,
+ ::media::CHANNEL_LAYOUT_5_0);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout5_1,
+ ::media::CHANNEL_LAYOUT_5_1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout5_0Back,
+ ::media::CHANNEL_LAYOUT_5_0_BACK);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout5_1Back,
+ ::media::CHANNEL_LAYOUT_5_1_BACK);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout7_0,
+ ::media::CHANNEL_LAYOUT_7_0);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout7_1,
+ ::media::CHANNEL_LAYOUT_7_1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout7_1Wide,
+ ::media::CHANNEL_LAYOUT_7_1_WIDE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutStereoDownmix,
+ ::media::CHANNEL_LAYOUT_STEREO_DOWNMIX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout2point1,
+ ::media::CHANNEL_LAYOUT_2POINT1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout3_1,
+ ::media::CHANNEL_LAYOUT_3_1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout4_1,
+ ::media::CHANNEL_LAYOUT_4_1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout6_0,
+ ::media::CHANNEL_LAYOUT_6_0);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout6_0Front,
+ ::media::CHANNEL_LAYOUT_6_0_FRONT);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutHexagonal,
+ ::media::CHANNEL_LAYOUT_HEXAGONAL);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout6_1,
+ ::media::CHANNEL_LAYOUT_6_1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout6_1Back,
+ ::media::CHANNEL_LAYOUT_6_1_BACK);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout6_1Front,
+ ::media::CHANNEL_LAYOUT_6_1_FRONT);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout7_0Front,
+ ::media::CHANNEL_LAYOUT_7_0_FRONT);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout7_1WideBack,
+ ::media::CHANNEL_LAYOUT_7_1_WIDE_BACK);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutOctagonal,
+ ::media::CHANNEL_LAYOUT_OCTAGONAL);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutDiscrete,
+ ::media::CHANNEL_LAYOUT_DISCRETE);
+DEMUXER_EXTENSION_ENUM_EQ(
+ kCobaltExtensionDemuxerChannelLayoutStereoAndKeyboardMic,
+ ::media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayout4_1QuadSide,
+ ::media::CHANNEL_LAYOUT_4_1_QUAD_SIDE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerChannelLayoutBitstream,
+ ::media::CHANNEL_LAYOUT_BITSTREAM);
+
+// Video codec profiles.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVideoCodecProfileUnknown,
+ ::media::VIDEO_CODEC_PROFILE_UNKNOWN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileMin,
+ ::media::H264PROFILE_MIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileBaseline,
+ ::media::H264PROFILE_BASELINE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileMain,
+ ::media::H264PROFILE_MAIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileExtended,
+ ::media::H264PROFILE_EXTENDED);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileHigh,
+ ::media::H264PROFILE_HIGH);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileHigh10Profile,
+ ::media::H264PROFILE_HIGH10PROFILE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileHigh422Profile,
+ ::media::H264PROFILE_HIGH422PROFILE);
+DEMUXER_EXTENSION_ENUM_EQ(
+ kCobaltExtensionDemuxerH264ProfileHigh444PredictiveProfile,
+ ::media::H264PROFILE_HIGH444PREDICTIVEPROFILE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileScalableBaseline,
+ ::media::H264PROFILE_SCALABLEBASELINE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileScalableHigh,
+ ::media::H264PROFILE_SCALABLEHIGH);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileStereoHigh,
+ ::media::H264PROFILE_STEREOHIGH);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileMultiviewHigh,
+ ::media::H264PROFILE_MULTIVIEWHIGH);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerH264ProfileMax,
+ ::media::H264PROFILE_MAX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp8ProfileMin,
+ ::media::VP8PROFILE_MIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp8ProfileAny,
+ ::media::VP8PROFILE_ANY);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp8ProfileMax,
+ ::media::VP8PROFILE_MAX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp9ProfileMin,
+ ::media::VP9PROFILE_MIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp9ProfileProfile0,
+ ::media::VP9PROFILE_PROFILE0);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp9ProfileProfile1,
+ ::media::VP9PROFILE_PROFILE1);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp9ProfileProfile2,
+ ::media::VP9PROFILE_PROFILE2);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp9ProfileProfile3,
+ ::media::VP9PROFILE_PROFILE3);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerVp9ProfileMax,
+ ::media::VP9PROFILE_MAX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerHevcProfileMin,
+ ::media::HEVCPROFILE_MIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerHevcProfileMain,
+ ::media::HEVCPROFILE_MAIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerHevcProfileMain10,
+ ::media::HEVCPROFILE_MAIN10);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerHevcProfileMainStillPicture,
+ ::media::HEVCPROFILE_MAIN_STILL_PICTURE);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerHevcProfileMax,
+ ::media::HEVCPROFILE_MAX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerDolbyVisionProfile0,
+ ::media::DOLBYVISION_PROFILE0);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerDolbyVisionProfile4,
+ ::media::DOLBYVISION_PROFILE4);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerDolbyVisionProfile5,
+ ::media::DOLBYVISION_PROFILE5);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerDolbyVisionProfile7,
+ ::media::DOLBYVISION_PROFILE7);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerTheoraProfileMin,
+ ::media::THEORAPROFILE_MIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerTheoraProfileAny,
+ ::media::THEORAPROFILE_ANY);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerTheoraProfileMax,
+ ::media::THEORAPROFILE_MAX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerAv1ProfileMin,
+ ::media::AV1PROFILE_MIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerAv1ProfileProfileMain,
+ ::media::AV1PROFILE_PROFILE_MAIN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerAv1ProfileProfileHigh,
+ ::media::AV1PROFILE_PROFILE_HIGH);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerAv1ProfileProfilePro,
+ ::media::AV1PROFILE_PROFILE_PRO);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerAv1ProfileMax,
+ ::media::AV1PROFILE_MAX);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerDolbyVisionProfile8,
+ ::media::DOLBYVISION_PROFILE8);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerDolbyVisionProfile9,
+ ::media::DOLBYVISION_PROFILE9);
+
+// Color range IDs.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerColorSpaceRangeIdInvalid,
+ gfx::ColorSpace::RangeID::INVALID);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerColorSpaceRangeIdLimited,
+ gfx::ColorSpace::RangeID::LIMITED);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerColorSpaceRangeIdFull,
+ gfx::ColorSpace::RangeID::FULL);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerColorSpaceRangeIdDerived,
+ gfx::ColorSpace::RangeID::DERIVED);
+
+// Alpha modes.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerHasAlpha,
+ ::media::VideoDecoderConfig::AlphaMode::kHasAlpha);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerIsOpaque,
+ ::media::VideoDecoderConfig::AlphaMode::kIsOpaque);
+
+// Demuxer stream types.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerStreamTypeUnknown,
+ ::media::DemuxerStream::Type::UNKNOWN);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerStreamTypeAudio,
+ ::media::DemuxerStream::Type::AUDIO);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerStreamTypeVideo,
+ ::media::DemuxerStream::Type::VIDEO);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerStreamTypeText,
+ ::media::DemuxerStream::Type::TEXT);
+
+// Encryption schemes.
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerEncryptionSchemeUnencrypted,
+ ::media::EncryptionScheme::kUnencrypted);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerEncryptionSchemeCenc,
+ ::media::EncryptionScheme::kCenc);
+DEMUXER_EXTENSION_ENUM_EQ(kCobaltExtensionDemuxerEncryptionSchemeCbcs,
+ ::media::EncryptionScheme::kCbcs);
+
+#undef DEMUXER_EXTENSION_ENUM_EQ
+
+} // namespace
+
+} // namespace media
+} // namespace cobalt
diff --git a/cobalt/media/progressive/demuxer_extension_wrapper.h b/cobalt/media/progressive/demuxer_extension_wrapper.h
new file mode 100644
index 0000000..138b922
--- /dev/null
+++ b/cobalt/media/progressive/demuxer_extension_wrapper.h
@@ -0,0 +1,248 @@
+// Copyright 2022 The Cobalt Authors. 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.
+//
+// Contains classes that wrap the Demuxer Cobalt Extension, providing an
+// implementation of a Cobalt demuxer. The main API is DemuxerExtensionWrapper.
+
+#ifndef COBALT_MEDIA_PROGRESSIVE_DEMUXER_EXTENSION_WRAPPER_H_
+#define COBALT_MEDIA_PROGRESSIVE_DEMUXER_EXTENSION_WRAPPER_H_
+
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/memory/scoped_refptr.h"
+#include "base/optional.h"
+#include "base/sequence_checker.h"
+#include "base/threading/thread.h"
+#include "cobalt/extension/demuxer.h"
+#include "cobalt/media/progressive/data_source_reader.h"
+#include "third_party/chromium/media/base/audio_decoder_config.h"
+#include "third_party/chromium/media/base/decoder_buffer.h"
+#include "third_party/chromium/media/base/demuxer.h"
+#include "third_party/chromium/media/base/pipeline_status.h"
+#include "third_party/chromium/media/base/ranges.h"
+#include "third_party/chromium/media/base/video_decoder_config.h"
+
+namespace cobalt {
+namespace media {
+
+// Represents an audio or video stream. Reads data via the demuxer Cobalt
+// Extension.
+class DemuxerExtensionStream : public ::media::DemuxerStream {
+ public:
+ // Represents a video stream.
+ explicit DemuxerExtensionStream(
+ CobaltExtensionDemuxer* demuxer,
+ scoped_refptr<base::SequencedTaskRunner> message_loop,
+ CobaltExtensionDemuxerVideoDecoderConfig config);
+ // Represents an audio stream.
+ explicit DemuxerExtensionStream(
+ CobaltExtensionDemuxer* demuxer,
+ scoped_refptr<base::SequencedTaskRunner> message_loop,
+ CobaltExtensionDemuxerAudioDecoderConfig config);
+
+ // Disallow copy and assign.
+ DemuxerExtensionStream(const DemuxerExtensionStream&) = delete;
+ DemuxerExtensionStream& operator=(const DemuxerExtensionStream&) = delete;
+
+ ~DemuxerExtensionStream() = default;
+
+ // Functions used by DemuxerExtensionWrapper.
+ ::media::Ranges<base::TimeDelta> GetBufferedRanges();
+ void EnqueueBuffer(scoped_refptr<::media::DecoderBuffer> buffer);
+ void FlushBuffers();
+ void Stop();
+ base::TimeDelta GetLastBufferTimestamp() const;
+ size_t GetTotalBufferSize() const;
+
+ // DemuxerStream implementation:
+ void Read(ReadCB read_cb) override;
+ ::media::AudioDecoderConfig audio_decoder_config() override;
+ ::media::VideoDecoderConfig video_decoder_config() override;
+ Type type() const override;
+
+ void EnableBitstreamConverter() override { NOTIMPLEMENTED(); }
+
+ bool SupportsConfigChanges() override { return false; }
+
+ private:
+ typedef std::deque<scoped_refptr<::media::DecoderBuffer>> BufferQueue;
+ typedef std::deque<ReadCB> ReadQueue;
+
+ CobaltExtensionDemuxer* demuxer_ = nullptr; // Not owned.
+ base::Optional<::media::VideoDecoderConfig> video_config_;
+ base::Optional<::media::AudioDecoderConfig> audio_config_;
+
+ // Protects everything below.
+ mutable base::Lock lock_;
+ // Keeps track of all time ranges this object has seen since creation.
+ // The demuxer uses these ranges to update the pipeline about what data
+ // it has demuxed.
+ ::media::Ranges<base::TimeDelta> buffered_ranges_;
+ // The last timestamp of buffer enqueued. This is used in two places:
+ // 1. Used with the timestamp of the current frame to calculate the
+ // buffer range.
+ // 2. Used by the demuxer to deteminate what type of frame to get next.
+ base::TimeDelta last_buffer_timestamp_ = ::media::kNoTimestamp;
+ bool stopped_ = false;
+
+ BufferQueue buffer_queue_;
+ ReadQueue read_queue_;
+
+ scoped_refptr<base::SequencedTaskRunner> message_loop_;
+
+ size_t total_buffer_size_ = 0;
+};
+
+// Wraps a DataSourceReader in an even simpler API, where each read increments
+// the read location. This better matches the C data source API.
+class PositionalDataSource {
+ public:
+ explicit PositionalDataSource(scoped_refptr<DataSourceReader> reader);
+
+ // Disallow copy and assign.
+ PositionalDataSource(const PositionalDataSource&) = delete;
+ PositionalDataSource& operator=(const PositionalDataSource&) = delete;
+
+ ~PositionalDataSource();
+
+ void Stop();
+
+ // Reads up to |bytes_requested|, writing the data into |data|.
+ int BlockingRead(uint8_t* data, int bytes_requested);
+
+ // Seeks to |position|.
+ void SeekTo(int position);
+
+ // Returns the current read position.
+ int64_t GetPosition() const;
+
+ // Returns the size of the file.
+ //
+ // TODO(b/231744342): investigate whether we need to fix
+ // DataSourceReader::FileSize(). In testing, it sometimes returned inaccurate
+ // results before a file was fully downloaded. That behavior affects what this
+ // function returns.
+ int64_t GetSize();
+
+ private:
+ scoped_refptr<DataSourceReader> reader_;
+ int64_t position_ = 0;
+};
+
+// Wraps the demuxer Cobalt Extension in the internal media::Demuxer API.
+// Instances should be created via the Create method.
+class DemuxerExtensionWrapper : public ::media::Demuxer {
+ public:
+ // Constructs a new DemuxerExtensionWrapper, returning null on failure. If
+ // |data_source| or |message_loop| is null, or if a demuxer cannot be created,
+ // this will return null. If |demuxer_api| is null, we will attempt to use the
+ // corresponding Cobalt extension.
+ static std::unique_ptr<DemuxerExtensionWrapper> Create(
+ DataSource* data_source,
+ scoped_refptr<base::SequencedTaskRunner> message_loop,
+ const CobaltExtensionDemuxerApi* demuxer_api = nullptr);
+
+ // Disallow copy and assign.
+ DemuxerExtensionWrapper(const DemuxerExtensionWrapper&) = delete;
+ DemuxerExtensionWrapper& operator=(const DemuxerExtensionWrapper&) = delete;
+
+ ~DemuxerExtensionWrapper() override;
+
+ // Demuxer implementation:
+ std::vector<::media::DemuxerStream*> GetAllStreams() override;
+ std::string GetDisplayName() const override;
+ void Initialize(::media::DemuxerHost* host,
+ ::media::PipelineStatusCallback status_cb) override;
+ void AbortPendingReads() override;
+ void StartWaitingForSeek(base::TimeDelta seek_time) override;
+ void CancelPendingSeek(base::TimeDelta seek_time) override;
+ void Seek(base::TimeDelta time,
+ ::media::PipelineStatusCallback status_cb) override;
+ void Stop() override;
+ base::TimeDelta GetStartTime() const override;
+ base::Time GetTimelineOffset() const override;
+ int64_t GetMemoryUsage() const override;
+ void OnEnabledAudioTracksChanged(
+ const std::vector<::media::MediaTrack::Id>& track_ids,
+ base::TimeDelta curr_time, TrackChangeCB change_completed_cb) override;
+ void OnSelectedVideoTrackChanged(
+ const std::vector<::media::MediaTrack::Id>& track_ids,
+ base::TimeDelta curr_time, TrackChangeCB change_completed_cb) override;
+
+ absl::optional<::media::container_names::MediaContainerName>
+ GetContainerForMetrics() const override {
+ NOTREACHED();
+ return absl::nullopt;
+ }
+
+ private:
+ // Only a forward declaration here, since the specifics of this class are an
+ // implementation detail.
+ class H264AnnexBConverter;
+
+ // Arguments must not be null.
+ explicit DemuxerExtensionWrapper(
+ const CobaltExtensionDemuxerApi* demuxer_api,
+ CobaltExtensionDemuxer* demuxer,
+ std::unique_ptr<PositionalDataSource> data_source,
+ std::unique_ptr<CobaltExtensionDemuxerDataSource> c_data_source,
+ scoped_refptr<base::SequencedTaskRunner> message_loop);
+
+ void OnInitializeDone(::media::PipelineStatusCallback status_cb,
+ CobaltExtensionDemuxerStatus status);
+ void Request(::media::DemuxerStream::Type type);
+ bool HasStopped();
+ void IssueNextRequest();
+ void SeekTask(base::TimeDelta time,
+ ::media::PipelineStatusCallback status_cb);
+
+ // Returns the range of buffered data. If both audio and video streams are
+ // present, this is the intersection of their buffered ranges; otherwise, it
+ // is whatever range of data is buffered.
+ ::media::Ranges<base::TimeDelta> GetBufferedRanges();
+
+ const CobaltExtensionDemuxerApi* demuxer_api_ = nullptr; // Not owned.
+ // Owned by this class. Construction/destruction is done via demuxer_api_.
+ CobaltExtensionDemuxer* impl_ = nullptr;
+ std::unique_ptr<PositionalDataSource> data_source_;
+ std::unique_ptr<CobaltExtensionDemuxerDataSource> c_data_source_;
+ ::media::DemuxerHost* host_ = nullptr;
+ mutable base::Lock lock_for_stopped_;
+ // Indicates whether Stop has been called.
+ bool stopped_ = false;
+ bool video_reached_eos_ = false;
+ bool audio_reached_eos_ = false;
+ bool flushing_ = false;
+
+ base::Optional<DemuxerExtensionStream> video_stream_;
+ base::Optional<DemuxerExtensionStream> audio_stream_;
+
+ std::unique_ptr<H264AnnexBConverter> h264_converter_;
+
+ // Thread for blocking I/O operations.
+ base::Thread blocking_thread_;
+
+ scoped_refptr<base::SequencedTaskRunner> message_loop_;
+
+ SEQUENCE_CHECKER(sequence_checker_);
+ base::WeakPtrFactory<DemuxerExtensionWrapper> weak_factory_{this};
+};
+
+} // namespace media
+} // namespace cobalt
+
+#endif // COBALT_MEDIA_PROGRESSIVE_DEMUXER_EXTENSION_WRAPPER_H_
diff --git a/cobalt/media/progressive/demuxer_extension_wrapper_test.cc b/cobalt/media/progressive/demuxer_extension_wrapper_test.cc
new file mode 100644
index 0000000..3aae16a
--- /dev/null
+++ b/cobalt/media/progressive/demuxer_extension_wrapper_test.cc
@@ -0,0 +1,701 @@
+// Copyright 2022 The Cobalt Authors. 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 "cobalt/media/progressive/demuxer_extension_wrapper.h"
+
+#include <cstdint>
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include "base/synchronization/waitable_event.h"
+#include "base/test/mock_callback.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/threading/platform_thread.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/time/time.h"
+#include "cobalt/extension/demuxer.h"
+#include "cobalt/media/decoder_buffer_allocator.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/chromium/media/base/demuxer.h"
+
+namespace cobalt {
+namespace media {
+namespace {
+
+using ::testing::_;
+using ::testing::AtMost;
+using ::testing::ElementsAreArray;
+using ::testing::ExplainMatchResult;
+using ::testing::Invoke;
+using ::testing::InvokeWithoutArgs;
+using ::testing::NiceMock;
+using ::testing::NotNull;
+using ::testing::Pointee;
+using ::testing::Return;
+using ::testing::UnorderedElementsAre;
+
+// Matches a DemuxerStream and verifies that the type is |type|.
+MATCHER_P(TypeIs, type, "") { return arg.type() == type; }
+
+// Matches a DecoderBuffer and verifies that the data in the buffer is |data|.
+MATCHER_P(BufferHasData, data, "") {
+ return ExplainMatchResult(
+ ElementsAreArray(data),
+ std::tuple<const uint8_t*, size_t>{arg.data(), arg.data_size()},
+ result_listener);
+}
+
+class MockDemuxerHost : public ::media::DemuxerHost {
+ public:
+ MockDemuxerHost() = default;
+
+ MockDemuxerHost(const MockDemuxerHost&) = delete;
+ MockDemuxerHost& operator=(const MockDemuxerHost&) = delete;
+
+ ~MockDemuxerHost() override = default;
+
+ MOCK_METHOD1(OnBufferedTimeRangesChanged,
+ void(const ::media::Ranges<base::TimeDelta>&));
+ MOCK_METHOD1(SetDuration, void(base::TimeDelta duration));
+ MOCK_METHOD1(OnDemuxerError, void(::media::PipelineStatus error));
+};
+
+class MockDataSource : public DataSource {
+ public:
+ MockDataSource() {
+ // Set reasonable default behavior for functions that are expected to
+ // interact with callbacks and/or output parameters.
+ ON_CALL(*this, Read(_, _, _, _))
+ .WillByDefault(Invoke(+[](int64_t position, int size, uint8_t* data,
+ const DataSource::ReadCB& read_cb) {
+ memset(data, 0, size);
+ read_cb.Run(size);
+ }));
+ ON_CALL(*this, GetSize(_)).WillByDefault(Invoke(+[](int64_t* size_out) {
+ *size_out = 0;
+ return true;
+ }));
+ }
+
+ ~MockDataSource() override = default;
+
+ MOCK_METHOD4(Read, void(int64_t position, int size, uint8_t* data,
+ const DataSource::ReadCB& read_cb));
+ MOCK_METHOD0(Stop, void());
+ MOCK_METHOD0(Abort, void());
+ MOCK_METHOD1(GetSize, bool(int64_t* size_out));
+ MOCK_METHOD0(IsStreaming, bool());
+ MOCK_METHOD1(SetBitrate, void(int bitrate));
+};
+
+// Mock class for receiving calls to the Cobalt Extension demuxer. Based on the
+// CobaltExtensionDemuxer struct.
+class MockCobaltExtensionDemuxer {
+ public:
+ MOCK_METHOD0(Initialize, CobaltExtensionDemuxerStatus());
+ MOCK_METHOD1(Seek, CobaltExtensionDemuxerStatus(int64_t seek_time_us));
+ MOCK_METHOD0(GetStartTime, SbTime());
+ MOCK_METHOD0(GetTimelineOffset, SbTime());
+ MOCK_METHOD3(Read, void(CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data));
+ MOCK_METHOD1(GetAudioConfig,
+ bool(CobaltExtensionDemuxerAudioDecoderConfig* config));
+ MOCK_METHOD1(GetVideoConfig,
+ bool(CobaltExtensionDemuxerVideoDecoderConfig* config));
+ MOCK_METHOD0(GetDuration, SbTime());
+
+ // Pure C functions to be used in CobaltExtensionDemuxer. These expect
+ // |user_data| to be a pointer to a MockCobaltExtensionDemuxer.
+ static CobaltExtensionDemuxerStatus InitializeImpl(void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)->Initialize();
+ }
+
+ static CobaltExtensionDemuxerStatus SeekImpl(int64_t seek_time_us,
+ void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)->Seek(
+ seek_time_us);
+ }
+
+ static SbTime GetStartTimeImpl(void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)->GetStartTime();
+ }
+
+ static SbTime GetTimelineOffsetImpl(void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)
+ ->GetTimelineOffset();
+ }
+ static void ReadImpl(CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data, void* user_data) {
+ static_cast<MockCobaltExtensionDemuxer*>(user_data)->Read(
+ type, read_cb, read_cb_user_data);
+ }
+
+ static bool GetAudioConfigImpl(
+ CobaltExtensionDemuxerAudioDecoderConfig* config, void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)->GetAudioConfig(
+ config);
+ }
+
+ static bool GetVideoConfigImpl(
+ CobaltExtensionDemuxerVideoDecoderConfig* config, void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)->GetVideoConfig(
+ config);
+ }
+
+ static SbTime GetDurationImpl(void* user_data) {
+ return static_cast<MockCobaltExtensionDemuxer*>(user_data)->GetDuration();
+ }
+};
+
+// Forward declaration for the purpose of defining GetMockDemuxerApi. Defined
+// below.
+class MockDemuxerApi;
+
+// Returns a pointer to a MockDemuxerApi with static storage duration. The
+// returned pointer should not be deleted. Defined below.
+MockDemuxerApi* GetMockDemuxerApi();
+
+// Mock class for receiving calls to the Cobalt Extension demuxer API. Based on
+// the CobaltExtensionDemuxerApi struct.
+class MockDemuxerApi {
+ public:
+ MOCK_METHOD5(CreateDemuxer,
+ CobaltExtensionDemuxer*(
+ CobaltExtensionDemuxerDataSource* data_source,
+ CobaltExtensionDemuxerAudioCodec* supported_audio_codecs,
+ int64_t supported_audio_codecs_size,
+ CobaltExtensionDemuxerVideoCodec* supported_video_codecs,
+ int64_t supported_video_codecs_size));
+ MOCK_METHOD1(DestroyDemuxer, void(CobaltExtensionDemuxer* demuxer));
+
+ // Pure C functions to be used in CobaltExtensionDemuxer. These expect
+ // |user_data| to be a pointer to a MockDemuxerApi.
+ static CobaltExtensionDemuxer* CreateDemuxerImpl(
+ CobaltExtensionDemuxerDataSource* data_source,
+ CobaltExtensionDemuxerAudioCodec* supported_audio_codecs,
+ int64_t supported_audio_codecs_size,
+ CobaltExtensionDemuxerVideoCodec* supported_video_codecs,
+ int64_t supported_video_codecs_size) {
+ return GetMockDemuxerApi()->CreateDemuxer(
+ data_source, supported_audio_codecs, supported_audio_codecs_size,
+ supported_video_codecs, supported_video_codecs_size);
+ }
+
+ static void DestroyDemuxerImpl(CobaltExtensionDemuxer* demuxer) {
+ GetMockDemuxerApi()->DestroyDemuxer(demuxer);
+ }
+};
+
+MockDemuxerApi* GetMockDemuxerApi() {
+ static auto* const demuxer_api = []() {
+ auto* inner_demuxer_api = new MockDemuxerApi;
+ // This mock won't be destructed.
+ testing::Mock::AllowLeak(inner_demuxer_api);
+ return inner_demuxer_api;
+ }();
+
+ return demuxer_api;
+}
+
+CobaltExtensionDemuxer* CreateCDemuxer(
+ MockCobaltExtensionDemuxer* mock_demuxer) {
+ CHECK(mock_demuxer);
+ return new CobaltExtensionDemuxer{
+ &MockCobaltExtensionDemuxer::InitializeImpl,
+ &MockCobaltExtensionDemuxer::SeekImpl,
+ &MockCobaltExtensionDemuxer::GetStartTimeImpl,
+ &MockCobaltExtensionDemuxer::GetTimelineOffsetImpl,
+ &MockCobaltExtensionDemuxer::ReadImpl,
+ &MockCobaltExtensionDemuxer::GetAudioConfigImpl,
+ &MockCobaltExtensionDemuxer::GetVideoConfigImpl,
+ &MockCobaltExtensionDemuxer::GetDurationImpl,
+ mock_demuxer};
+}
+
+// A test fixture is used to verify and clear the global mock demuxer, and to
+// manage the lifetime of the ScopedTaskEnvironment.
+class DemuxerExtensionWrapperTest : public ::testing::Test {
+ protected:
+ DemuxerExtensionWrapperTest() = default;
+
+ ~DemuxerExtensionWrapperTest() override {
+ testing::Mock::VerifyAndClearExpectations(GetMockDemuxerApi());
+ }
+
+ // Waits |time_limit| for |done| to occur. Returns true if the event occurred,
+ // false otherwise. While waiting, allows other threads to run and runs the
+ // task runner until idle.
+ bool WaitForEvent(base::WaitableEvent& done,
+ base::TimeDelta time_limit = base::Seconds(1)) {
+ const base::Time deadline = base::Time::Now() + base::Seconds(1);
+ while (base::Time::Now() < deadline) {
+ task_environment_.RunUntilIdle();
+ base::PlatformThread::YieldCurrentThread();
+ if (done.IsSignaled()) {
+ break;
+ }
+ }
+ return done.IsSignaled();
+ }
+
+ // This must be deleted last.
+ base::test::ScopedTaskEnvironment task_environment_{
+ base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME};
+ // This is necessary in order to allocate DecoderBuffers. This is done
+ // internally in DemuxerExtensionWrapper.
+ DecoderBufferAllocator allocator_;
+};
+
+TEST_F(DemuxerExtensionWrapperTest, SuccessfullyInitializes) {
+ // This must outlive the DemuxerExtensionWrapper.
+ NiceMock<MockDemuxerHost> mock_host;
+ MockDataSource data_source;
+ MockDemuxerApi* mock_demuxer_api = GetMockDemuxerApi(); // Not owned.
+ NiceMock<MockCobaltExtensionDemuxer> mock_demuxer;
+
+ // In this test we don't care about what data is read.
+ ON_CALL(mock_demuxer, Read(_, _, _))
+ .WillByDefault(Invoke([](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Simulate EOS.
+ CobaltExtensionDemuxerBuffer eos_buffer = {};
+ eos_buffer.end_of_stream = true;
+ read_cb(&eos_buffer, read_cb_user_data);
+ }));
+
+ const CobaltExtensionDemuxerApi api = {
+ /*name=*/kCobaltExtensionDemuxerApi,
+ /*version=*/1,
+ /*CreateDemuxer=*/&MockDemuxerApi::CreateDemuxerImpl,
+ /*DestroyDemuxer=*/&MockDemuxerApi::DestroyDemuxerImpl,
+ };
+
+ auto c_demuxer =
+ std::unique_ptr<CobaltExtensionDemuxer>(CreateCDemuxer(&mock_demuxer));
+ EXPECT_CALL(*mock_demuxer_api, CreateDemuxer(_, _, _, _, _))
+ .WillOnce(Return(c_demuxer.get()));
+ EXPECT_CALL(*mock_demuxer_api, DestroyDemuxer(c_demuxer.get())).Times(1);
+
+ std::unique_ptr<DemuxerExtensionWrapper> demuxer_wrapper =
+ DemuxerExtensionWrapper::Create(
+ &data_source, base::SequencedTaskRunnerHandle::Get(), &api);
+
+ ASSERT_THAT(demuxer_wrapper, NotNull());
+
+ base::WaitableEvent init_done;
+ base::MockCallback<base::OnceCallback<void(::media::PipelineStatus)>>
+ initialize_cb;
+ EXPECT_CALL(mock_demuxer, Initialize())
+ .WillOnce(Return(kCobaltExtensionDemuxerOk));
+ // Simulate an audio file.
+ EXPECT_CALL(mock_demuxer, GetAudioConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerAudioDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecAAC;
+ config->sample_format = kCobaltExtensionDemuxerSampleFormatF32;
+ config->channel_layout = kCobaltExtensionDemuxerChannelLayoutStereo;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->samples_per_second = 44100;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(mock_demuxer, GetVideoConfig(NotNull())).WillOnce(Return(false));
+ EXPECT_CALL(initialize_cb, Run(::media::PIPELINE_OK))
+ .WillOnce(InvokeWithoutArgs([&init_done]() { init_done.Signal(); }));
+
+ demuxer_wrapper->Initialize(&mock_host, initialize_cb.Get());
+
+ EXPECT_TRUE(WaitForEvent(init_done));
+}
+
+TEST_F(DemuxerExtensionWrapperTest, ProvidesAudioAndVideoStreams) {
+ // This must outlive the DemuxerExtensionWrapper.
+ NiceMock<MockDemuxerHost> mock_host;
+ MockDataSource data_source;
+ MockDemuxerApi* mock_demuxer_api = GetMockDemuxerApi(); // Not owned.
+ NiceMock<MockCobaltExtensionDemuxer> mock_demuxer;
+
+ // In this test we don't care about what data is read.
+ ON_CALL(mock_demuxer, Read(_, _, _))
+ .WillByDefault(Invoke([](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Simulate EOS.
+ CobaltExtensionDemuxerBuffer eos_buffer = {};
+ eos_buffer.end_of_stream = true;
+ read_cb(&eos_buffer, read_cb_user_data);
+ }));
+
+ const CobaltExtensionDemuxerApi api = {
+ /*name=*/kCobaltExtensionDemuxerApi,
+ /*version=*/1,
+ /*CreateDemuxer=*/&MockDemuxerApi::CreateDemuxerImpl,
+ /*DestroyDemuxer=*/&MockDemuxerApi::DestroyDemuxerImpl,
+ };
+
+ auto c_demuxer =
+ std::unique_ptr<CobaltExtensionDemuxer>(CreateCDemuxer(&mock_demuxer));
+ EXPECT_CALL(*mock_demuxer_api, CreateDemuxer(_, _, _, _, _))
+ .WillOnce(Return(c_demuxer.get()));
+ EXPECT_CALL(*mock_demuxer_api, DestroyDemuxer(c_demuxer.get())).Times(1);
+
+ std::unique_ptr<DemuxerExtensionWrapper> demuxer_wrapper =
+ DemuxerExtensionWrapper::Create(
+ &data_source, base::SequencedTaskRunnerHandle::Get(), &api);
+
+ ASSERT_THAT(demuxer_wrapper, NotNull());
+
+ base::WaitableEvent init_done;
+ base::MockCallback<base::OnceCallback<void(::media::PipelineStatus)>>
+ initialize_cb;
+ EXPECT_CALL(mock_demuxer, Initialize())
+ .WillOnce(Return(kCobaltExtensionDemuxerOk));
+ // Simulate an audio+video file.
+ EXPECT_CALL(mock_demuxer, GetAudioConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerAudioDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecAAC;
+ config->sample_format = kCobaltExtensionDemuxerSampleFormatF32;
+ config->channel_layout = kCobaltExtensionDemuxerChannelLayoutStereo;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->samples_per_second = 44100;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(mock_demuxer, GetVideoConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerVideoDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecH264;
+ config->profile = kCobaltExtensionDemuxerH264ProfileMain;
+ config->color_space_primaries = 1;
+ config->color_space_transfer = 1;
+ config->color_space_matrix = 1;
+ config->color_space_range_id =
+ kCobaltExtensionDemuxerColorSpaceRangeIdFull;
+ config->alpha_mode = kCobaltExtensionDemuxerHasAlpha;
+ config->coded_width = 1920;
+ config->coded_height = 1080;
+ config->visible_rect_x = 0;
+ config->visible_rect_y = 0;
+ config->visible_rect_width = 1920;
+ config->visible_rect_height = 1080;
+ config->natural_width = 1920;
+ config->natural_height = 1080;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(initialize_cb, Run(::media::PIPELINE_OK))
+ .WillOnce(InvokeWithoutArgs([&init_done]() { init_done.Signal(); }));
+
+ demuxer_wrapper->Initialize(&mock_host, initialize_cb.Get());
+
+ EXPECT_TRUE(WaitForEvent(init_done));
+
+ std::vector<::media::DemuxerStream*> streams =
+ demuxer_wrapper->GetAllStreams();
+ EXPECT_THAT(streams,
+ UnorderedElementsAre(
+ Pointee(TypeIs(::media::DemuxerStream::Type::AUDIO)),
+ Pointee(TypeIs(::media::DemuxerStream::Type::VIDEO))));
+}
+
+TEST_F(DemuxerExtensionWrapperTest, ReadsAudioData) {
+ // This must outlive the DemuxerExtensionWrapper.
+ NiceMock<MockDemuxerHost> mock_host;
+ MockDataSource data_source;
+ MockDemuxerApi* mock_demuxer_api = GetMockDemuxerApi(); // Not owned.
+ NiceMock<MockCobaltExtensionDemuxer> mock_demuxer;
+
+ const CobaltExtensionDemuxerApi api = {
+ /*name=*/kCobaltExtensionDemuxerApi,
+ /*version=*/1,
+ /*CreateDemuxer=*/&MockDemuxerApi::CreateDemuxerImpl,
+ /*DestroyDemuxer=*/&MockDemuxerApi::DestroyDemuxerImpl,
+ };
+
+ auto c_demuxer =
+ std::unique_ptr<CobaltExtensionDemuxer>(CreateCDemuxer(&mock_demuxer));
+ EXPECT_CALL(*mock_demuxer_api, CreateDemuxer(_, _, _, _, _))
+ .WillOnce(Return(c_demuxer.get()));
+ EXPECT_CALL(*mock_demuxer_api, DestroyDemuxer(c_demuxer.get())).Times(1);
+
+ std::unique_ptr<DemuxerExtensionWrapper> demuxer_wrapper =
+ DemuxerExtensionWrapper::Create(
+ &data_source, base::SequencedTaskRunnerHandle::Get(), &api);
+
+ ASSERT_THAT(demuxer_wrapper, NotNull());
+
+ base::WaitableEvent init_done;
+ base::MockCallback<base::OnceCallback<void(::media::PipelineStatus)>>
+ initialize_cb;
+ EXPECT_CALL(mock_demuxer, Initialize())
+ .WillOnce(Return(kCobaltExtensionDemuxerOk));
+ // Simulate an audio+video file.
+ EXPECT_CALL(mock_demuxer, GetAudioConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerAudioDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecAAC;
+ config->sample_format = kCobaltExtensionDemuxerSampleFormatF32;
+ config->channel_layout = kCobaltExtensionDemuxerChannelLayoutStereo;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->samples_per_second = 44100;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(mock_demuxer, GetVideoConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerVideoDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecH264;
+ config->profile = kCobaltExtensionDemuxerH264ProfileMain;
+ config->color_space_primaries = 1;
+ config->color_space_transfer = 1;
+ config->color_space_matrix = 1;
+ config->color_space_range_id =
+ kCobaltExtensionDemuxerColorSpaceRangeIdFull;
+ config->alpha_mode = kCobaltExtensionDemuxerHasAlpha;
+ config->coded_width = 1920;
+ config->coded_height = 1080;
+ config->visible_rect_x = 0;
+ config->visible_rect_y = 0;
+ config->visible_rect_width = 1920;
+ config->visible_rect_height = 1080;
+ config->natural_width = 1920;
+ config->natural_height = 1080;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(initialize_cb, Run(::media::PIPELINE_OK))
+ .WillOnce(InvokeWithoutArgs([&init_done]() { init_done.Signal(); }));
+
+ std::vector<uint8_t> buffer_data = {1, 2, 3, 4, 5};
+ EXPECT_CALL(mock_demuxer, Read(kCobaltExtensionDemuxerStreamTypeAudio, _, _))
+ .WillOnce(Invoke([&buffer_data](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Send one "real" buffer.
+ CobaltExtensionDemuxerBuffer buffer = {};
+ buffer.data = buffer_data.data();
+ buffer.data_size = buffer_data.size();
+ buffer.side_data = nullptr;
+ buffer.side_data_elements = 0;
+ buffer.pts = 0;
+ buffer.duration = 1000;
+ buffer.is_keyframe = true;
+ buffer.end_of_stream = false;
+ read_cb(&buffer, read_cb_user_data);
+ }))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Simulate the audio stream being done.
+ CobaltExtensionDemuxerBuffer eos_buffer = {};
+ eos_buffer.end_of_stream = true;
+ read_cb(&eos_buffer, read_cb_user_data);
+ }));
+
+ // The impl may or may not try reading video data. If it does, return EOS.
+ EXPECT_CALL(mock_demuxer, Read(kCobaltExtensionDemuxerStreamTypeVideo, _, _))
+ .Times(AtMost(1))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Simulate the video stream being done.
+ CobaltExtensionDemuxerBuffer eos_buffer = {};
+ eos_buffer.end_of_stream = true;
+ read_cb(&eos_buffer, read_cb_user_data);
+ }));
+
+ demuxer_wrapper->Initialize(&mock_host, initialize_cb.Get());
+
+ EXPECT_TRUE(WaitForEvent(init_done));
+
+ std::vector<::media::DemuxerStream*> streams =
+ demuxer_wrapper->GetAllStreams();
+ ASSERT_THAT(streams,
+ UnorderedElementsAre(
+ Pointee(TypeIs(::media::DemuxerStream::Type::AUDIO)),
+ Pointee(TypeIs(::media::DemuxerStream::Type::VIDEO))));
+ ::media::DemuxerStream* audio_stream =
+ streams[0]->type() == ::media::DemuxerStream::Type::AUDIO ? streams[0]
+ : streams[1];
+
+ base::MockCallback<base::OnceCallback<void(
+ ::media::DemuxerStream::Status, scoped_refptr<::media::DecoderBuffer>)>>
+ read_cb;
+ base::WaitableEvent read_done;
+ EXPECT_CALL(read_cb, Run(::media::DemuxerStream::kOk,
+ Pointee(BufferHasData(buffer_data))))
+ .WillOnce(InvokeWithoutArgs([&read_done]() { read_done.Signal(); }));
+
+ audio_stream->Read(read_cb.Get());
+ EXPECT_TRUE(WaitForEvent(read_done));
+}
+
+TEST_F(DemuxerExtensionWrapperTest, ReadsVideoData) {
+ // This must outlive the DemuxerExtensionWrapper.
+ NiceMock<MockDemuxerHost> mock_host;
+ MockDataSource data_source;
+ MockDemuxerApi* mock_demuxer_api = GetMockDemuxerApi(); // Not owned.
+ NiceMock<MockCobaltExtensionDemuxer> mock_demuxer;
+
+ const CobaltExtensionDemuxerApi api = {
+ /*name=*/kCobaltExtensionDemuxerApi,
+ /*version=*/1,
+ /*CreateDemuxer=*/&MockDemuxerApi::CreateDemuxerImpl,
+ /*DestroyDemuxer=*/&MockDemuxerApi::DestroyDemuxerImpl,
+ };
+
+ auto c_demuxer =
+ std::unique_ptr<CobaltExtensionDemuxer>(CreateCDemuxer(&mock_demuxer));
+ EXPECT_CALL(*mock_demuxer_api, CreateDemuxer(_, _, _, _, _))
+ .WillOnce(Return(c_demuxer.get()));
+ EXPECT_CALL(*mock_demuxer_api, DestroyDemuxer(c_demuxer.get())).Times(1);
+
+ std::unique_ptr<DemuxerExtensionWrapper> demuxer_wrapper =
+ DemuxerExtensionWrapper::Create(
+ &data_source, base::SequencedTaskRunnerHandle::Get(), &api);
+
+ ASSERT_THAT(demuxer_wrapper, NotNull());
+
+ base::WaitableEvent init_done;
+ base::MockCallback<base::OnceCallback<void(::media::PipelineStatus)>>
+ initialize_cb;
+ EXPECT_CALL(mock_demuxer, Initialize())
+ .WillOnce(Return(kCobaltExtensionDemuxerOk));
+ // Simulate an audio+video file.
+ EXPECT_CALL(mock_demuxer, GetAudioConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerAudioDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecAAC;
+ config->sample_format = kCobaltExtensionDemuxerSampleFormatF32;
+ config->channel_layout = kCobaltExtensionDemuxerChannelLayoutStereo;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->samples_per_second = 44100;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(mock_demuxer, GetVideoConfig(NotNull()))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerVideoDecoderConfig* config) {
+ config->codec = kCobaltExtensionDemuxerCodecH264;
+ config->profile = kCobaltExtensionDemuxerH264ProfileMain;
+ config->color_space_primaries = 1;
+ config->color_space_transfer = 1;
+ config->color_space_matrix = 1;
+ config->color_space_range_id =
+ kCobaltExtensionDemuxerColorSpaceRangeIdFull;
+ config->alpha_mode = kCobaltExtensionDemuxerHasAlpha;
+ config->coded_width = 1920;
+ config->coded_height = 1080;
+ config->visible_rect_x = 0;
+ config->visible_rect_y = 0;
+ config->visible_rect_width = 1920;
+ config->visible_rect_height = 1080;
+ config->natural_width = 1920;
+ config->natural_height = 1080;
+ config->encryption_scheme =
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted;
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+
+ return true;
+ }));
+ EXPECT_CALL(initialize_cb, Run(::media::PIPELINE_OK))
+ .WillOnce(InvokeWithoutArgs([&init_done]() { init_done.Signal(); }));
+
+ std::vector<uint8_t> buffer_data = {1, 2, 3, 4, 5};
+ EXPECT_CALL(mock_demuxer, Read(kCobaltExtensionDemuxerStreamTypeVideo, _, _))
+ .WillOnce(Invoke([&buffer_data](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Send one "real" buffer.
+ CobaltExtensionDemuxerBuffer buffer = {};
+ buffer.data = buffer_data.data();
+ buffer.data_size = buffer_data.size();
+ buffer.side_data = nullptr;
+ buffer.side_data_elements = 0;
+ buffer.pts = 0;
+ buffer.duration = 1000;
+ buffer.is_keyframe = true;
+ buffer.end_of_stream = false;
+ read_cb(&buffer, read_cb_user_data);
+ }))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Simulate the video stream being done.
+ CobaltExtensionDemuxerBuffer eos_buffer = {};
+ eos_buffer.end_of_stream = true;
+ read_cb(&eos_buffer, read_cb_user_data);
+ }));
+
+ // The impl may or may not try reading audio data. If it does, return EOS.
+ EXPECT_CALL(mock_demuxer, Read(kCobaltExtensionDemuxerStreamTypeAudio, _, _))
+ .Times(AtMost(1))
+ .WillOnce(Invoke([](CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ // Simulate the audio stream being done.
+ CobaltExtensionDemuxerBuffer eos_buffer = {};
+ eos_buffer.end_of_stream = true;
+ read_cb(&eos_buffer, read_cb_user_data);
+ }));
+
+ demuxer_wrapper->Initialize(&mock_host, initialize_cb.Get());
+
+ EXPECT_TRUE(WaitForEvent(init_done));
+
+ std::vector<::media::DemuxerStream*> streams =
+ demuxer_wrapper->GetAllStreams();
+ ASSERT_THAT(streams,
+ UnorderedElementsAre(
+ Pointee(TypeIs(::media::DemuxerStream::Type::AUDIO)),
+ Pointee(TypeIs(::media::DemuxerStream::Type::VIDEO))));
+ ::media::DemuxerStream* video_stream =
+ streams[0]->type() == ::media::DemuxerStream::Type::VIDEO ? streams[0]
+ : streams[1];
+
+ base::MockCallback<base::OnceCallback<void(
+ ::media::DemuxerStream::Status, scoped_refptr<::media::DecoderBuffer>)>>
+ read_cb;
+ base::WaitableEvent read_done;
+ EXPECT_CALL(read_cb, Run(::media::DemuxerStream::kOk,
+ Pointee(BufferHasData(buffer_data))))
+ .WillOnce(InvokeWithoutArgs([&read_done]() { read_done.Signal(); }));
+
+ video_stream->Read(read_cb.Get());
+ EXPECT_TRUE(WaitForEvent(read_done));
+}
+
+} // namespace
+} // namespace media
+} // namespace cobalt
diff --git a/cobalt/media_integration_tests/functionality/general_playback.py b/cobalt/media_integration_tests/functionality/general_playback.py
index 8b3ea3a..95b1e1a 100644
--- a/cobalt/media_integration_tests/functionality/general_playback.py
+++ b/cobalt/media_integration_tests/functionality/general_playback.py
@@ -16,7 +16,7 @@
import logging
from cobalt.media_integration_tests.test_case import TestCase
-from cobalt.media_integration_tests.test_util import PlaybackUrls, MimeStrings
+from cobalt.media_integration_tests.test_util import PlaybackUrls
class GeneralPlaybackTest(TestCase):
@@ -40,19 +40,19 @@
TEST_PARAMETERS = [
('H264', PlaybackUrls.H264_ONLY, None),
- # TODO(b/223856877) -- find out why Progressive still broken
+ # TODO(b/223856877) -- renable these when tests are stable.
#('PROGRESSIVE', PlaybackUrls.PROGRESSIVE, None),
- ('ENCRYPTED', PlaybackUrls.ENCRYPTED, None),
- ('VR', PlaybackUrls.VR, None),
- ('VP9', PlaybackUrls.VP9, MimeStrings.VP9),
- ('VP9_HFR', PlaybackUrls.VP9_HFR, MimeStrings.VP9_HFR),
- ('AV1', PlaybackUrls.AV1, MimeStrings.AV1),
- ('AV1_HFR', PlaybackUrls.AV1_HFR, MimeStrings.AV1_HFR),
- ('VERTICAL', PlaybackUrls.VERTICAL, None),
- ('SHORT', PlaybackUrls.SHORT, None),
- ('VP9_HDR_HLG', PlaybackUrls.VP9_HDR_HLG, MimeStrings.VP9_HDR_HLG),
- ('VP9_HDR_PQ', PlaybackUrls.VP9_HDR_PQ, MimeStrings.VP9_HDR_PQ),
- ('HDR_PQ_HFR', PlaybackUrls.HDR_PQ_HFR, MimeStrings.VP9_HDR_PQ_HFR),
+ #('ENCRYPTED', PlaybackUrls.ENCRYPTED, None),
+ #('VR', PlaybackUrls.VR, None),
+ #('VP9', PlaybackUrls.VP9, MimeStrings.VP9),
+ #('VP9_HFR', PlaybackUrls.VP9_HFR, MimeStrings.VP9_HFR),
+ #('AV1', PlaybackUrls.AV1, MimeStrings.AV1),
+ #('AV1_HFR', PlaybackUrls.AV1_HFR, MimeStrings.AV1_HFR),
+ #('VERTICAL', PlaybackUrls.VERTICAL, None),
+ #('SHORT', PlaybackUrls.SHORT, None),
+ #('VP9_HDR_HLG', PlaybackUrls.VP9_HDR_HLG, MimeStrings.VP9_HDR_HLG),
+ #('VP9_HDR_PQ', PlaybackUrls.VP9_HDR_PQ, MimeStrings.VP9_HDR_PQ),
+ #('HDR_PQ_HFR', PlaybackUrls.HDR_PQ_HFR, MimeStrings.VP9_HDR_PQ_HFR),
]
for name, playback_url, mime_str in TEST_PARAMETERS:
diff --git a/cobalt/version.h b/cobalt/version.h
index 18d66ee..3f59478 100644
--- a/cobalt/version.h
+++ b/cobalt/version.h
@@ -35,6 +35,6 @@
// release is cut.
//.
-#define COBALT_VERSION "23.master.0"
+#define COBALT_VERSION "23.lts.1"
#endif // COBALT_VERSION_H_
diff --git a/starboard/android/shared/cobalt/configuration.py b/starboard/android/shared/cobalt/configuration.py
index df2e568..c606d82 100644
--- a/starboard/android/shared/cobalt/configuration.py
+++ b/starboard/android/shared/cobalt/configuration.py
@@ -64,7 +64,8 @@
],
'crypto_unittests': ['P224.*'],
'renderer_test': [
- # TODO(b/236034292): These tests load the wrong fonts sometimes.
+ # TODO(b/215739322): Using the android fonts breaks these tests. They
+ # make use of fonts that are not bundled on Android.
'PixelTest.SimpleTextInRed40PtChineseFont',
'PixelTest.SimpleTextInRed40PtThaiFont',
diff --git a/starboard/linux/shared/BUILD.gn b/starboard/linux/shared/BUILD.gn
index 8e4a107..74986a73 100644
--- a/starboard/linux/shared/BUILD.gn
+++ b/starboard/linux/shared/BUILD.gn
@@ -84,6 +84,8 @@
"//starboard/shared/alsa/alsa_util.h",
"//starboard/shared/deviceauth/deviceauth_internal.cc",
"//starboard/shared/egl/system_egl.cc",
+ "//starboard/shared/ffmpeg/ffmpeg_demuxer.cc",
+ "//starboard/shared/ffmpeg/ffmpeg_demuxer.h",
"//starboard/shared/gcc/atomic_gcc_public.h",
"//starboard/shared/gles/system_gles2.cc",
"//starboard/shared/iso/character_is_alphanumeric.cc",
diff --git a/starboard/linux/shared/system_get_extensions.cc b/starboard/linux/shared/system_get_extensions.cc
index 3c44ffd..fba44bd 100644
--- a/starboard/linux/shared/system_get_extensions.cc
+++ b/starboard/linux/shared/system_get_extensions.cc
@@ -16,13 +16,16 @@
#include "cobalt/extension/configuration.h"
#include "cobalt/extension/crash_handler.h"
+#include "cobalt/extension/demuxer.h"
#include "cobalt/extension/free_space.h"
#include "cobalt/extension/memory_mapped_file.h"
#include "cobalt/extension/platform_service.h"
#include "starboard/common/string.h"
#include "starboard/linux/shared/soft_mic_platform_service.h"
+#include "starboard/shared/ffmpeg/ffmpeg_demuxer.h"
#include "starboard/shared/posix/free_space.h"
#include "starboard/shared/posix/memory_mapped_file.h"
+#include "starboard/shared/starboard/application.h"
#include "starboard/shared/starboard/crash_handler.h"
#if SB_IS(EVERGREEN_COMPATIBLE)
#include "starboard/elf_loader/evergreen_config.h"
@@ -56,5 +59,13 @@
if (strcmp(name, kCobaltExtensionFreeSpaceName) == 0) {
return starboard::shared::posix::GetFreeSpaceApi();
}
+ if (strcmp(name, kCobaltExtensionDemuxerApi) == 0) {
+ auto command_line =
+ starboard::shared::starboard::Application::Get()->GetCommandLine();
+ const bool use_ffmpeg_demuxer =
+ command_line->HasSwitch("enable_demuxer_extension");
+ return use_ffmpeg_demuxer ? starboard::shared::ffmpeg::GetFFmpegDemuxerApi()
+ : NULL;
+ }
return NULL;
}
diff --git a/starboard/nplb/player_create_test.cc b/starboard/nplb/player_create_test.cc
index f3038b1..87c3e65 100644
--- a/starboard/nplb/player_create_test.cc
+++ b/starboard/nplb/player_create_test.cc
@@ -54,6 +54,26 @@
SbPlayerOutputMode output_mode_;
};
+void DummyDeallocateSampleFunc(SbPlayer player,
+ void* context,
+ const void* sample_buffer) {}
+
+void DummyDecoderStatusFunc(SbPlayer player,
+ void* context,
+ SbMediaType type,
+ SbPlayerDecoderState state,
+ int ticket) {}
+
+void DummyStatusFunc(SbPlayer player,
+ void* context,
+ SbPlayerState state,
+ int ticket) {}
+
+void DummyErrorFunc(SbPlayer player,
+ void* context,
+ SbPlayerError error,
+ const char* message) {}
+
TEST_P(SbPlayerTest, SunnyDay) {
SbMediaAudioSampleInfo audio_sample_info =
CreateAudioSampleInfo(kSbMediaAudioCodecAac);
@@ -67,7 +87,7 @@
fake_graphics_context_provider_.window(), kSbMediaVideoCodecH264,
kSbMediaAudioCodecAac, kSbDrmSystemInvalid, &audio_sample_info,
"" /* max_video_capabilities */, DummyDeallocateSampleFunc,
- DummyDecoderStatusFunc, DummyPlayerStatusFunc, DummyErrorFunc,
+ DummyDecoderStatusFunc, DummyStatusFunc, DummyErrorFunc,
NULL /* context */, output_mode_,
fake_graphics_context_provider_.decoder_target_provider());
EXPECT_TRUE(SbPlayerIsValid(player));
@@ -91,7 +111,7 @@
fake_graphics_context_provider_.window(), kSbMediaVideoCodecH264,
kSbMediaAudioCodecAac, kSbDrmSystemInvalid, &audio_sample_info,
"" /* max_video_capabilities */, NULL /* deallocate_sample_func */,
- DummyDecoderStatusFunc, DummyPlayerStatusFunc, DummyErrorFunc,
+ DummyDecoderStatusFunc, DummyStatusFunc, DummyErrorFunc,
NULL /* context */, output_mode_,
fake_graphics_context_provider_.decoder_target_provider());
EXPECT_FALSE(SbPlayerIsValid(player));
@@ -104,7 +124,7 @@
fake_graphics_context_provider_.window(), kSbMediaVideoCodecH264,
kSbMediaAudioCodecAac, kSbDrmSystemInvalid, &audio_sample_info,
"" /* max_video_capabilities */, DummyDeallocateSampleFunc,
- NULL /* decoder_status_func */, DummyPlayerStatusFunc, DummyErrorFunc,
+ NULL /* decoder_status_func */, DummyStatusFunc, DummyErrorFunc,
NULL /* context */, output_mode_,
fake_graphics_context_provider_.decoder_target_provider());
EXPECT_FALSE(SbPlayerIsValid(player));
@@ -129,9 +149,8 @@
SbPlayer player = CallSbPlayerCreate(
fake_graphics_context_provider_.window(), kSbMediaVideoCodecH264,
kSbMediaAudioCodecAac, kSbDrmSystemInvalid, &audio_sample_info, "",
- DummyDeallocateSampleFunc, DummyDecoderStatusFunc,
- DummyPlayerStatusFunc, NULL /* error_func */, NULL /* context */,
- output_mode_,
+ DummyDeallocateSampleFunc, DummyDecoderStatusFunc, DummyStatusFunc,
+ NULL /* error_func */, NULL /* context */, output_mode_,
fake_graphics_context_provider_.decoder_target_provider());
EXPECT_FALSE(SbPlayerIsValid(player));
@@ -149,7 +168,7 @@
fake_graphics_context_provider_.window(), kSbMediaVideoCodecH264,
kSbMediaAudioCodecNone, kSbDrmSystemInvalid, NULL /* audio_sample_info */,
"" /* max_video_capabilities */, DummyDeallocateSampleFunc,
- DummyDecoderStatusFunc, DummyPlayerStatusFunc, DummyErrorFunc,
+ DummyDecoderStatusFunc, DummyStatusFunc, DummyErrorFunc,
NULL /* context */, output_mode_,
fake_graphics_context_provider_.decoder_target_provider());
EXPECT_TRUE(SbPlayerIsValid(player));
@@ -172,7 +191,7 @@
fake_graphics_context_provider_.window(), kSbMediaVideoCodecNone,
kSbMediaAudioCodecAac, kSbDrmSystemInvalid, &audio_sample_info,
"" /* max_video_capabilities */, DummyDeallocateSampleFunc,
- DummyDecoderStatusFunc, DummyPlayerStatusFunc, DummyErrorFunc,
+ DummyDecoderStatusFunc, DummyStatusFunc, DummyErrorFunc,
NULL /* context */, output_mode_,
fake_graphics_context_provider_.decoder_target_provider());
EXPECT_TRUE(SbPlayerIsValid(player));
@@ -250,7 +269,7 @@
fake_graphics_context_provider_.window(), kVideoCodecs[l],
kAudioCodecs[k], kSbDrmSystemInvalid, &audio_sample_info,
"" /* max_video_capabilities */, DummyDeallocateSampleFunc,
- DummyDecoderStatusFunc, DummyPlayerStatusFunc, DummyErrorFunc,
+ DummyDecoderStatusFunc, DummyStatusFunc, DummyErrorFunc,
NULL /* context */, kOutputModes[j],
fake_graphics_context_provider_.decoder_target_provider()));
if (!SbPlayerIsValid(created_players.back())) {
diff --git a/starboard/shared/ffmpeg/BUILD.gn b/starboard/shared/ffmpeg/BUILD.gn
index e6bc469..096087b 100644
--- a/starboard/shared/ffmpeg/BUILD.gn
+++ b/starboard/shared/ffmpeg/BUILD.gn
@@ -90,3 +90,20 @@
public_configs = [ "//starboard/build/config:starboard_implementation" ]
}
+
+target(gtest_target_type, "ffmpeg_demuxer_test") {
+ testonly = true
+ configs += [ "//starboard/build/config:starboard_implementation" ]
+ sources = ffmpeg_specialization_sources + [
+ "ffmpeg_demuxer.h",
+ "ffmpeg_demuxer.cc",
+ "ffmpeg_demuxer_test.cc",
+ ]
+ deps = [
+ "//cobalt/test:run_all_unittests",
+ "//starboard",
+ "//starboard/common",
+ "//testing/gmock",
+ "//testing/gtest",
+ ]
+}
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer.cc b/starboard/shared/ffmpeg/ffmpeg_demuxer.cc
new file mode 100644
index 0000000..38df873
--- /dev/null
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer.cc
@@ -0,0 +1,1054 @@
+// Copyright 2022 The Cobalt Authors. 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_demuxer.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "starboard/time.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+namespace {
+
+constexpr int64_t kNoFFmpegTimestamp = static_cast<int64_t>(AV_NOPTS_VALUE);
+constexpr int kAvioBufferSize = 4 * 1024; // 4KB.
+
+// For testing, this can be overridden via TestOnlySetFFmpegDispatch below.
+// Aside from that function and GetDispatch, no code should access this global
+// directly. Instead, calls to the dispatch should go through GetDispatch().
+FFMPEGDispatch* g_test_dispatch = nullptr;
+
+const FFMPEGDispatch* GetDispatch() {
+ if (g_test_dispatch) {
+ return g_test_dispatch;
+ }
+
+ static const auto* const dispatch = FFMPEGDispatch::GetInstance();
+ return dispatch;
+}
+
+struct ScopedPtrAVFreeContext {
+ void operator()(void* ptr) const {
+ if (!ptr) {
+ return;
+ }
+ auto* codec_context = static_cast<AVCodecContext*>(ptr);
+ GetDispatch()->avcodec_free_context(&codec_context);
+ }
+};
+
+struct ScopedPtrAVFree {
+ void operator()(void* ptr) const {
+ if (!ptr) {
+ return;
+ }
+ GetDispatch()->av_free(ptr);
+ }
+};
+
+struct ScopedPtrAVFreePacket {
+ void operator()(void* ptr) const {
+ if (!ptr) {
+ return;
+ }
+ auto* packet = static_cast<AVPacket*>(ptr);
+ GetDispatch()->av_packet_free(&packet);
+ }
+};
+
+using ScopedAVPacket = std::unique_ptr<AVPacket, ScopedPtrAVFreePacket>;
+
+CobaltExtensionDemuxerAudioCodec AvCodecIdToAudioCodec(AVCodecID codec) {
+ switch (codec) {
+ case AV_CODEC_ID_AAC:
+ return kCobaltExtensionDemuxerCodecAAC;
+ case AV_CODEC_ID_MP3:
+ return kCobaltExtensionDemuxerCodecMP3;
+ case AV_CODEC_ID_PCM_U8:
+ case AV_CODEC_ID_PCM_S16LE:
+ case AV_CODEC_ID_PCM_S24LE:
+ case AV_CODEC_ID_PCM_S32LE:
+ case AV_CODEC_ID_PCM_F32LE:
+ return kCobaltExtensionDemuxerCodecPCM;
+ case AV_CODEC_ID_VORBIS:
+ return kCobaltExtensionDemuxerCodecVorbis;
+ case AV_CODEC_ID_FLAC:
+ return kCobaltExtensionDemuxerCodecFLAC;
+ case AV_CODEC_ID_AMR_NB:
+ return kCobaltExtensionDemuxerCodecAMR_NB;
+ case AV_CODEC_ID_AMR_WB:
+ return kCobaltExtensionDemuxerCodecAMR_WB;
+ case AV_CODEC_ID_PCM_MULAW:
+ return kCobaltExtensionDemuxerCodecPCM_MULAW;
+ case AV_CODEC_ID_PCM_S16BE:
+ return kCobaltExtensionDemuxerCodecPCM_S16BE;
+ case AV_CODEC_ID_PCM_S24BE:
+ return kCobaltExtensionDemuxerCodecPCM_S24BE;
+ case AV_CODEC_ID_OPUS:
+ return kCobaltExtensionDemuxerCodecOpus;
+ case AV_CODEC_ID_EAC3:
+ return kCobaltExtensionDemuxerCodecEAC3;
+ case AV_CODEC_ID_PCM_ALAW:
+ return kCobaltExtensionDemuxerCodecPCM_ALAW;
+ case AV_CODEC_ID_ALAC:
+ return kCobaltExtensionDemuxerCodecALAC;
+ case AV_CODEC_ID_AC3:
+ return kCobaltExtensionDemuxerCodecAC3;
+ default:
+ return kCobaltExtensionDemuxerCodecUnknownAudio;
+ }
+}
+
+CobaltExtensionDemuxerVideoCodec AvCodecIdToVideoCodec(AVCodecID codec) {
+ switch (codec) {
+ case AV_CODEC_ID_H264:
+ return kCobaltExtensionDemuxerCodecH264;
+ case AV_CODEC_ID_VC1:
+ return kCobaltExtensionDemuxerCodecVC1;
+ case AV_CODEC_ID_MPEG2VIDEO:
+ return kCobaltExtensionDemuxerCodecMPEG2;
+ case AV_CODEC_ID_MPEG4:
+ return kCobaltExtensionDemuxerCodecMPEG4;
+ case AV_CODEC_ID_THEORA:
+ return kCobaltExtensionDemuxerCodecTheora;
+ case AV_CODEC_ID_VP8:
+ return kCobaltExtensionDemuxerCodecVP8;
+ case AV_CODEC_ID_VP9:
+ return kCobaltExtensionDemuxerCodecVP9;
+ case AV_CODEC_ID_HEVC:
+ return kCobaltExtensionDemuxerCodecHEVC;
+ case AV_CODEC_ID_AV1:
+ return kCobaltExtensionDemuxerCodecAV1;
+ default:
+ return kCobaltExtensionDemuxerCodecUnknownVideo;
+ }
+}
+
+CobaltExtensionDemuxerSampleFormat AvSampleFormatToSampleFormat(
+ AVSampleFormat sample_format) {
+ switch (sample_format) {
+ case AV_SAMPLE_FMT_U8:
+ return kCobaltExtensionDemuxerSampleFormatU8;
+ case AV_SAMPLE_FMT_S16:
+ return kCobaltExtensionDemuxerSampleFormatS16;
+ case AV_SAMPLE_FMT_S32:
+ return kCobaltExtensionDemuxerSampleFormatS32;
+ case AV_SAMPLE_FMT_FLT:
+ return kCobaltExtensionDemuxerSampleFormatF32;
+ case AV_SAMPLE_FMT_S16P:
+ return kCobaltExtensionDemuxerSampleFormatPlanarS16;
+ case AV_SAMPLE_FMT_S32P:
+ return kCobaltExtensionDemuxerSampleFormatPlanarS32;
+ case AV_SAMPLE_FMT_FLTP:
+ return kCobaltExtensionDemuxerSampleFormatPlanarF32;
+ default:
+ return kCobaltExtensionDemuxerSampleFormatUnknown;
+ }
+}
+
+CobaltExtensionDemuxerChannelLayout GuessChannelLayout(int channels) {
+ switch (channels) {
+ case 1:
+ return kCobaltExtensionDemuxerChannelLayoutMono;
+ case 2:
+ return kCobaltExtensionDemuxerChannelLayoutStereo;
+ case 3:
+ return kCobaltExtensionDemuxerChannelLayoutSurround;
+ case 4:
+ return kCobaltExtensionDemuxerChannelLayoutQuad;
+ case 5:
+ return kCobaltExtensionDemuxerChannelLayout5_0;
+ case 6:
+ return kCobaltExtensionDemuxerChannelLayout5_1;
+ case 7:
+ return kCobaltExtensionDemuxerChannelLayout6_1;
+ case 8:
+ return kCobaltExtensionDemuxerChannelLayout7_1;
+ default:
+ std::cerr << "Unsupported channel count: " << channels << std::endl;
+ }
+ return kCobaltExtensionDemuxerChannelLayoutUnsupported;
+}
+
+CobaltExtensionDemuxerChannelLayout AvChannelLayoutToChannelLayout(
+ uint64_t channel_layout,
+ int num_channels) {
+ if (num_channels > 8) {
+ return kCobaltExtensionDemuxerChannelLayoutDiscrete;
+ }
+
+ switch (channel_layout) {
+ case AV_CH_LAYOUT_MONO:
+ return kCobaltExtensionDemuxerChannelLayoutMono;
+ case AV_CH_LAYOUT_STEREO:
+ return kCobaltExtensionDemuxerChannelLayoutStereo;
+ case AV_CH_LAYOUT_2_1:
+ return kCobaltExtensionDemuxerChannelLayout2_1;
+ case AV_CH_LAYOUT_SURROUND:
+ return kCobaltExtensionDemuxerChannelLayoutSurround;
+ case AV_CH_LAYOUT_4POINT0:
+ return kCobaltExtensionDemuxerChannelLayout4_0;
+ case AV_CH_LAYOUT_2_2:
+ return kCobaltExtensionDemuxerChannelLayout2_2;
+ case AV_CH_LAYOUT_QUAD:
+ return kCobaltExtensionDemuxerChannelLayoutQuad;
+ case AV_CH_LAYOUT_5POINT0:
+ return kCobaltExtensionDemuxerChannelLayout5_0;
+ case AV_CH_LAYOUT_5POINT1:
+ return kCobaltExtensionDemuxerChannelLayout5_1;
+ case AV_CH_LAYOUT_5POINT0_BACK:
+ return kCobaltExtensionDemuxerChannelLayout5_0Back;
+ case AV_CH_LAYOUT_5POINT1_BACK:
+ return kCobaltExtensionDemuxerChannelLayout5_1Back;
+ case AV_CH_LAYOUT_7POINT0:
+ return kCobaltExtensionDemuxerChannelLayout7_0;
+ case AV_CH_LAYOUT_7POINT1:
+ return kCobaltExtensionDemuxerChannelLayout7_1;
+ case AV_CH_LAYOUT_7POINT1_WIDE:
+ return kCobaltExtensionDemuxerChannelLayout7_1Wide;
+ case AV_CH_LAYOUT_STEREO_DOWNMIX:
+ return kCobaltExtensionDemuxerChannelLayoutStereoDownmix;
+ case AV_CH_LAYOUT_2POINT1:
+ return kCobaltExtensionDemuxerChannelLayout2point1;
+ case AV_CH_LAYOUT_3POINT1:
+ return kCobaltExtensionDemuxerChannelLayout3_1;
+ case AV_CH_LAYOUT_4POINT1:
+ return kCobaltExtensionDemuxerChannelLayout4_1;
+ case AV_CH_LAYOUT_6POINT0:
+ return kCobaltExtensionDemuxerChannelLayout6_0;
+ case AV_CH_LAYOUT_6POINT0_FRONT:
+ return kCobaltExtensionDemuxerChannelLayout6_0Front;
+ case AV_CH_LAYOUT_HEXAGONAL:
+ return kCobaltExtensionDemuxerChannelLayoutHexagonal;
+ case AV_CH_LAYOUT_6POINT1:
+ return kCobaltExtensionDemuxerChannelLayout6_1;
+ case AV_CH_LAYOUT_6POINT1_BACK:
+ return kCobaltExtensionDemuxerChannelLayout6_1Back;
+ case AV_CH_LAYOUT_6POINT1_FRONT:
+ return kCobaltExtensionDemuxerChannelLayout6_1Front;
+ case AV_CH_LAYOUT_7POINT0_FRONT:
+ return kCobaltExtensionDemuxerChannelLayout7_0Front;
+ case AV_CH_LAYOUT_7POINT1_WIDE_BACK:
+ return kCobaltExtensionDemuxerChannelLayout7_1WideBack;
+ case AV_CH_LAYOUT_OCTAGONAL:
+ return kCobaltExtensionDemuxerChannelLayoutOctagonal;
+ default:
+ return GuessChannelLayout(num_channels);
+ }
+}
+
+CobaltExtensionDemuxerVideoCodecProfile ProfileIDToVideoCodecProfile(
+ int profile) {
+ // Clear out the CONSTRAINED & INTRA flags which are strict subsets of the
+ // corresponding profiles with which they're used.
+ profile &= ~FF_PROFILE_H264_CONSTRAINED;
+ profile &= ~FF_PROFILE_H264_INTRA;
+ switch (profile) {
+ case FF_PROFILE_H264_BASELINE:
+ return kCobaltExtensionDemuxerH264ProfileBaseline;
+ case FF_PROFILE_H264_MAIN:
+ return kCobaltExtensionDemuxerH264ProfileMain;
+ case FF_PROFILE_H264_EXTENDED:
+ return kCobaltExtensionDemuxerH264ProfileExtended;
+ case FF_PROFILE_H264_HIGH:
+ return kCobaltExtensionDemuxerH264ProfileHigh;
+ case FF_PROFILE_H264_HIGH_10:
+ return kCobaltExtensionDemuxerH264ProfileHigh10Profile;
+ case FF_PROFILE_H264_HIGH_422:
+ return kCobaltExtensionDemuxerH264ProfileHigh422Profile;
+ case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
+ return kCobaltExtensionDemuxerH264ProfileHigh444PredictiveProfile;
+ default:
+ std::cerr << "Unknown profile id: " << profile << std::endl;
+ return kCobaltExtensionDemuxerVideoCodecProfileUnknown;
+ }
+}
+
+int AVIOReadOperation(void* opaque, uint8_t* buf, int buf_size) {
+ auto* data_source = static_cast<CobaltExtensionDemuxerDataSource*>(opaque);
+ const int bytes_read =
+ data_source->BlockingRead(buf, buf_size, data_source->user_data);
+
+ if (bytes_read == 0) {
+ return AVERROR_EOF;
+ } else if (bytes_read < 0) {
+ return AVERROR(EIO);
+ } else {
+ return bytes_read;
+ }
+}
+
+int64_t AVIOSeekOperation(void* opaque, int64_t offset, int whence) {
+ auto* data_source = static_cast<CobaltExtensionDemuxerDataSource*>(opaque);
+ switch (whence) {
+ case SEEK_SET: {
+ data_source->SeekTo(offset, data_source->user_data);
+ break;
+ }
+ case SEEK_CUR: {
+ const int64_t current_position =
+ data_source->GetPosition(data_source->user_data);
+ data_source->SeekTo(current_position + offset, data_source->user_data);
+ break;
+ }
+ case SEEK_END: {
+ const int64_t size = data_source->GetSize(data_source->user_data);
+ data_source->SeekTo(size + offset, data_source->user_data);
+ break;
+ }
+ case AVSEEK_SIZE: {
+ return data_source->GetSize(data_source->user_data);
+ }
+ default: {
+ std::cerr << "Invalid whence: " << whence << std::endl;
+ return AVERROR(EIO);
+ }
+ }
+
+ // In the case where we did a real seek, return the new position.
+ return data_source->GetPosition(data_source->user_data);
+}
+
+int64_t ConvertFromTimeBaseToMicros(AVRational time_base, int64_t timestamp) {
+ return GetDispatch()->av_rescale_rnd(timestamp, time_base.num * kSbTimeSecond,
+ time_base.den,
+ static_cast<int>(AV_ROUND_NEAR_INF));
+}
+
+int64_t ConvertMicrosToTimeBase(AVRational time_base, int64_t timestamp_us) {
+ return GetDispatch()->av_rescale_rnd(timestamp_us, time_base.den,
+ time_base.num * kSbTimeSecond,
+ static_cast<int>(AV_ROUND_NEAR_INF));
+}
+
+CobaltExtensionDemuxerEncryptionScheme GetEncryptionScheme(
+ const AVStream& stream) {
+ return GetDispatch()->av_dict_get(stream.metadata, "enc_key_id", nullptr,
+ 0) == nullptr
+ ? kCobaltExtensionDemuxerEncryptionSchemeUnencrypted
+ : kCobaltExtensionDemuxerEncryptionSchemeCenc;
+}
+
+int64_t ExtractStartTime(AVStream* stream) {
+ int64_t start_time = 0;
+ if (stream->start_time != kNoFFmpegTimestamp) {
+ start_time =
+ ConvertFromTimeBaseToMicros(stream->time_base, stream->start_time);
+ }
+
+ if (stream->first_dts != kNoFFmpegTimestamp &&
+ stream->codecpar->codec_id != AV_CODEC_ID_HEVC &&
+ stream->codecpar->codec_id != AV_CODEC_ID_H264 &&
+ stream->codecpar->codec_id != AV_CODEC_ID_MPEG4) {
+ const int64_t first_pts =
+ ConvertFromTimeBaseToMicros(stream->time_base, stream->first_dts);
+ start_time = std::min(first_pts, start_time);
+ }
+
+ return start_time;
+}
+
+// Recursively splits |s| around |delimiter| characters.
+std::vector<std::string> Split(const std::string& s, char delimiter) {
+ // Work from right to left, since it's faster to append to the end of a
+ // vector.
+ const size_t pos = s.rfind(delimiter);
+ if (pos == std::string::npos) {
+ // Base case.
+ return {s};
+ }
+
+ // Recursive case.
+ std::vector<std::string> previous_splits = Split(s.substr(0, pos), delimiter);
+ previous_splits.push_back(s.substr(pos + 1));
+ return previous_splits;
+}
+
+int64_t ExtractTimelineOffset(AVFormatContext* format_context) {
+ const std::vector<std::string> input_formats =
+ Split(format_context->iformat->name, ',');
+
+ // The name for ff_matroska_demuxer contains "webm" in its comma-separated
+ // list.
+ const bool is_webm = std::any_of(
+ input_formats.cbegin(), input_formats.cend(),
+ +[](const std::string& format) -> bool { return format == "webm"; });
+
+ if (is_webm) {
+ const AVDictionaryEntry* entry = GetDispatch()->av_dict_get(
+ format_context->metadata, "creation_time", nullptr, 0);
+
+ // TODO(b/231634260): properly implement this if necessary. We need to
+ // return microseconds since epoch for the given date string in UTC, which
+ // is harder than it sounds in pure C++.
+ return 0;
+ }
+ return 0;
+}
+
+// A demuxer implemented via FFmpeg. Calls to FFmpeg go through GetDispatch()
+// (defined above).
+// The API of this class mirrors that of CobaltExtensionDemuxer; those calls get
+// forwarded to an instance of this class.
+class FFmpegDemuxer {
+ public:
+ explicit FFmpegDemuxer(CobaltExtensionDemuxerDataSource* data_source)
+ : data_source_(data_source) {
+ assert(data_source_);
+ }
+
+ // Disallow copy and assign.
+ FFmpegDemuxer(const FFmpegDemuxer&) = delete;
+ FFmpegDemuxer& operator=(const FFmpegDemuxer&) = delete;
+
+ ~FFmpegDemuxer() {
+ if (format_context_) {
+ GetDispatch()->avformat_close_input(&format_context_);
+ }
+ }
+
+ CobaltExtensionDemuxerStatus Initialize() {
+ assert(format_context_ == nullptr);
+
+ if (initialized_) {
+ std::cerr
+ << "Multiple calls to FFmpegDemuxer::Initialize are not allowed."
+ << std::endl;
+ return kCobaltExtensionDemuxerErrorInitializationFailed;
+ }
+ initialized_ = true;
+
+ avio_context_.reset(GetDispatch()->avio_alloc_context(
+ static_cast<unsigned char*>(GetDispatch()->av_malloc(kAvioBufferSize)),
+ kAvioBufferSize, 0,
+ /*opaque=*/data_source_, &AVIOReadOperation, nullptr,
+ &AVIOSeekOperation));
+ avio_context_->seekable =
+ data_source_->is_streaming ? 0 : AVIO_SEEKABLE_NORMAL;
+ avio_context_->write_flag = 0;
+
+ format_context_ = GetDispatch()->avformat_alloc_context();
+ format_context_->flags |= AVFMT_FLAG_CUSTOM_IO;
+ format_context_->flags |= AVFMT_FLAG_FAST_SEEK;
+ format_context_->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
+ format_context_->error_recognition |= AV_EF_EXPLODE;
+ format_context_->pb = avio_context_.get();
+
+ if (GetDispatch()->avformat_open_input(&format_context_, nullptr, nullptr,
+ nullptr) < 0) {
+ std::cerr << "avformat_open_input failed." << std::endl;
+ return kCobaltExtensionDemuxerErrorCouldNotOpen;
+ }
+ if (GetDispatch()->avformat_find_stream_info(format_context_, nullptr) <
+ 0) {
+ std::cerr << "avformat_find_stream_info failed." << std::endl;
+ return kCobaltExtensionDemuxerErrorCouldNotParse;
+ }
+
+ // Find the first audio stream and video stream, if present.
+ // TODO(b/231632632): pick a stream based on supported codecs, not the first
+ // stream present.
+ for (int i = 0; i < format_context_->nb_streams; ++i) {
+ AVStream* stream = format_context_->streams[i];
+ const AVCodecParameters* codec_parameters = stream->codecpar;
+ const AVMediaType codec_type = codec_parameters->codec_type;
+ const AVCodecID codec_id = codec_parameters->codec_id;
+ // Skip streams which are not properly detected.
+ if (codec_id == AV_CODEC_ID_NONE) {
+ stream->discard = AVDISCARD_ALL;
+ continue;
+ }
+
+ if (codec_type == AVMEDIA_TYPE_AUDIO) {
+ if (audio_stream_) {
+ continue;
+ }
+ audio_stream_ = stream;
+ } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
+ if (video_stream_)
+ continue;
+ video_stream_ = stream;
+ }
+ }
+
+ if (!audio_stream_ && !video_stream_) {
+ std::cerr << "No audio or video stream was present." << std::endl;
+ return kCobaltExtensionDemuxerErrorNoSupportedStreams;
+ }
+
+ if (audio_stream_ && !ParseAudioConfig(audio_stream_, &audio_config_)) {
+ return kCobaltExtensionDemuxerErrorInitializationFailed;
+ }
+ if (video_stream_ && !ParseVideoConfig(video_stream_, &video_config_)) {
+ return kCobaltExtensionDemuxerErrorInitializationFailed;
+ }
+
+ if (format_context_->duration != kNoFFmpegTimestamp) {
+ duration_us_ = ConvertFromTimeBaseToMicros(
+ /*time_base=*/{1, AV_TIME_BASE}, format_context_->duration);
+ }
+
+ start_time_ = std::min(audio_stream_ ? ExtractStartTime(audio_stream_)
+ : std::numeric_limits<int64_t>::max(),
+ video_stream_ ? ExtractStartTime(video_stream_)
+ : std::numeric_limits<int64_t>::max());
+
+ timeline_offset_us_ = ExtractTimelineOffset(format_context_);
+
+ return kCobaltExtensionDemuxerOk;
+ }
+
+ bool HasAudioStream() const { return audio_stream_ != nullptr; }
+
+ const CobaltExtensionDemuxerAudioDecoderConfig& GetAudioConfig() const {
+ return audio_config_;
+ }
+
+ bool HasVideoStream() const { return video_stream_ != nullptr; }
+
+ const CobaltExtensionDemuxerVideoDecoderConfig& GetVideoConfig() const {
+ return video_config_;
+ }
+
+ SbTime GetDuration() const { return duration_us_; }
+
+ SbTime GetStartTime() const { return start_time_; }
+
+ SbTime GetTimelineOffset() const { return timeline_offset_us_; }
+
+ void Read(CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data) {
+ assert(type == kCobaltExtensionDemuxerStreamTypeAudio ||
+ type == kCobaltExtensionDemuxerStreamTypeVideo);
+
+ if (type == kCobaltExtensionDemuxerStreamTypeAudio) {
+ assert(audio_stream_);
+ } else {
+ assert(video_stream_);
+ }
+
+ const AVRational time_base = type == kCobaltExtensionDemuxerStreamTypeAudio
+ ? audio_stream_->time_base
+ : video_stream_->time_base;
+
+ CobaltExtensionDemuxerBuffer buffer = {};
+ ScopedAVPacket packet = GetNextPacket(type);
+ if (!packet) {
+ // Either an error occurred or we reached EOS. Treat as EOS.
+ buffer.end_of_stream = true;
+ read_cb(&buffer, read_cb_user_data);
+ return;
+ }
+
+ // NOTE: subtracting start_time_ is necessary because the rest of the cobalt
+ // pipeline never calls the demuxer's GetStartTime() to handle the offset
+ // (it assumes 0 offset).
+ //
+ // TODO(b/231634475): don't subtract start_time_ here if the rest of the
+ // pipeline is updated to handle nonzero start times.
+ buffer.pts =
+ ConvertFromTimeBaseToMicros(time_base, packet->pts) - start_time_;
+ buffer.duration = ConvertFromTimeBaseToMicros(time_base, packet->duration);
+ buffer.is_keyframe = packet->flags & AV_PKT_FLAG_KEY;
+ buffer.end_of_stream = false;
+ buffer.data = packet->data;
+ buffer.data_size = packet->size;
+
+ std::vector<CobaltExtensionDemuxerSideData> side_data;
+ for (int i = 0; i < packet->side_data_elems; ++i) {
+ const AVPacketSideData& packet_side_data = packet->side_data[i];
+ if (packet_side_data.type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) {
+ CobaltExtensionDemuxerSideData extension_side_data = {};
+ extension_side_data.data = packet_side_data.data;
+ extension_side_data.data_size = packet_side_data.size;
+ extension_side_data.type =
+ kCobaltExtensionDemuxerMatroskaBlockAdditional;
+ side_data.push_back(std::move(extension_side_data));
+ }
+ // TODO(b/231635220): support other types of side data, if necessary.
+ }
+
+ if (side_data.empty()) {
+ buffer.side_data = nullptr;
+ buffer.side_data_elements = 0;
+ } else {
+ buffer.side_data = side_data.data();
+ buffer.side_data_elements = side_data.size();
+ }
+
+ read_cb(&buffer, read_cb_user_data);
+ }
+
+ CobaltExtensionDemuxerStatus Seek(int64_t seek_time_us) {
+ // Clear any buffered packets and seek via FFmpeg.
+ video_packets_.clear();
+ audio_packets_.clear();
+
+ AVStream* const stream = video_stream_ ? video_stream_ : audio_stream_;
+ GetDispatch()->av_seek_frame(
+ format_context_, stream->index,
+ ConvertMicrosToTimeBase(stream->time_base, seek_time_us),
+ AVSEEK_FLAG_BACKWARD);
+
+ return kCobaltExtensionDemuxerOk;
+ }
+
+ private:
+ // Returns the next packet of type |type|, or nullptr if EoS has been reached
+ // or an error was encountered.
+ ScopedAVPacket GetNextPacket(CobaltExtensionDemuxerStreamType type) {
+ // Handle the simple case: if we already have a packet buffered, just return
+ // it.
+ ScopedAVPacket packet = GetBufferedPacket(type);
+ if (packet)
+ return packet;
+
+ // Read another packet from FFmpeg. We may have to discard a packet if it's
+ // not from the right stream. Additionally, if we hit end-of-file or an
+ // error, we need to return null.
+ packet.reset(GetDispatch()->av_packet_alloc());
+ while (true) {
+ int result = GetDispatch()->av_read_frame(format_context_, packet.get());
+ if (result < 0) {
+ // The packet will be unref-ed when ScopedAVPacket's destructor runs.
+ return nullptr;
+ }
+
+ // Determine whether to drop the packet. In that case, we need to manually
+ // unref the packet, since new data will be written to it.
+ if (video_stream_ && packet->stream_index == video_stream_->index) {
+ if (type == kCobaltExtensionDemuxerStreamTypeVideo) {
+ // We found the packet that the caller was looking for.
+ return packet;
+ }
+
+ // The caller doesn't need a video packet; just buffer it and allocate a
+ // new packet.
+ BufferPacket(std::move(packet), kCobaltExtensionDemuxerStreamTypeVideo);
+ packet.reset(GetDispatch()->av_packet_alloc());
+ continue;
+ } else if (audio_stream_ &&
+ packet->stream_index == audio_stream_->index) {
+ if (type == kCobaltExtensionDemuxerStreamTypeAudio) {
+ // We found the packet that the caller was looking for.
+ return packet;
+ }
+
+ // The caller doesn't need an audio packet; just buffer it and allocate
+ // a new packet.
+ BufferPacket(std::move(packet), kCobaltExtensionDemuxerStreamTypeAudio);
+ packet.reset(GetDispatch()->av_packet_alloc());
+ continue;
+ }
+
+ // This is a packet for a stream we don't care about. Unref it and keep
+ // searching.
+ GetDispatch()->av_packet_unref(packet.get());
+ }
+
+ // We should never reach this point.
+ assert(false);
+ return nullptr;
+ }
+
+ // Returns a buffered packet of type |type|, or nullptr if no buffered packet
+ // is available.
+ ScopedAVPacket GetBufferedPacket(CobaltExtensionDemuxerStreamType type) {
+ if (type == kCobaltExtensionDemuxerStreamTypeVideo) {
+ if (video_packets_.empty()) {
+ return nullptr;
+ }
+ ScopedAVPacket packet = std::move(video_packets_.front());
+ video_packets_.pop_front();
+ return packet;
+ } else {
+ if (audio_packets_.empty()) {
+ return nullptr;
+ }
+ ScopedAVPacket packet = std::move(audio_packets_.front());
+ audio_packets_.pop_front();
+ return packet;
+ }
+ }
+
+ // Pushes |packet| into the queue specified by |type|.
+ void BufferPacket(ScopedAVPacket packet,
+ CobaltExtensionDemuxerStreamType type) {
+ if (type == kCobaltExtensionDemuxerStreamTypeVideo) {
+ video_packets_.push_back(std::move(packet));
+ } else {
+ audio_packets_.push_back(std::move(packet));
+ }
+ }
+
+ bool ParseAudioConfig(AVStream* audio_stream,
+ CobaltExtensionDemuxerAudioDecoderConfig* config) {
+ if (!config) {
+ return false;
+ }
+
+ config->encryption_scheme = GetEncryptionScheme(*audio_stream);
+
+ std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext> codec_context(
+ GetDispatch()->avcodec_alloc_context3(nullptr));
+ if (!codec_context) {
+ std::cerr << "Could not allocate codec context." << std::endl;
+ return false;
+ }
+ if (GetDispatch()->avcodec_parameters_to_context(
+ codec_context.get(), audio_stream->codecpar) < 0) {
+ return false;
+ }
+
+ config->codec = AvCodecIdToAudioCodec(codec_context->codec_id);
+ config->sample_format =
+ AvSampleFormatToSampleFormat(codec_context->sample_fmt);
+ config->channel_layout = AvChannelLayoutToChannelLayout(
+ codec_context->channel_layout, codec_context->channels);
+ config->samples_per_second = codec_context->sample_rate;
+
+ // Catch a potential FFmpeg bug. See http://crbug.com/517163 for more info.
+ if ((codec_context->extradata_size == 0) !=
+ (codec_context->extradata == nullptr)) {
+ std::cerr << (codec_context->extradata == nullptr ? " NULL" : " Non-NULL")
+ << " extra data cannot have size of "
+ << codec_context->extradata_size << "." << std::endl;
+ return false;
+ }
+
+ if (codec_context->extradata_size > 0) {
+ extra_audio_data_.assign(
+ codec_context->extradata,
+ codec_context->extradata + codec_context->extradata_size);
+ config->extra_data = extra_audio_data_.data();
+ config->extra_data_size = extra_audio_data_.size();
+ } else {
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+ }
+
+ // The spec for AC3/EAC3 audio is ETSI TS 102 366. According to sections
+ // F.3.1 and F.5.1 in that spec, the sample format must be 16 bits.
+ if (config->codec == kCobaltExtensionDemuxerCodecAC3 ||
+ config->codec == kCobaltExtensionDemuxerCodecEAC3) {
+ config->sample_format = kCobaltExtensionDemuxerSampleFormatS16;
+ }
+
+ // TODO(b/231637692): If we need to support MPEG-H, the channel layout and
+ // sample format need to be set here.
+ return true;
+ }
+
+ bool ParseVideoConfig(AVStream* video_stream,
+ CobaltExtensionDemuxerVideoDecoderConfig* config) {
+ std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext> codec_context(
+ GetDispatch()->avcodec_alloc_context3(nullptr));
+ if (!codec_context) {
+ std::cerr << "Could not allocate codec context." << std::endl;
+ return false;
+ }
+ if (GetDispatch()->avcodec_parameters_to_context(
+ codec_context.get(), video_stream->codecpar) < 0) {
+ return false;
+ }
+
+ config->visible_rect_x = 0;
+ config->visible_rect_y = 0;
+ config->visible_rect_width = codec_context->width;
+ config->visible_rect_height = codec_context->height;
+
+ config->coded_width = codec_context->width;
+ config->coded_height = codec_context->height;
+
+ auto get_aspect_ratio = +[](AVRational rational) -> double {
+ return rational.den == 0
+ ? 0.0
+ : static_cast<double>(rational.num) / rational.den;
+ };
+
+ const double aspect_ratio =
+ video_stream->sample_aspect_ratio.num
+ ? get_aspect_ratio(video_stream->sample_aspect_ratio)
+ : codec_context->sample_aspect_ratio.num
+ ? get_aspect_ratio(codec_context->sample_aspect_ratio)
+ : 0.0;
+ {
+ double width = config->visible_rect_width;
+ double height = config->visible_rect_height;
+ if (aspect_ratio >= 1) {
+ // Wide pixels; grow width.
+ width = width * aspect_ratio;
+ } else {
+ // Narrow pixels; grow height.
+ height = height / aspect_ratio;
+ }
+
+ width = std::round(width);
+ height = std::round(height);
+ if (width < 1.0 || width > std::numeric_limits<int>::max() ||
+ height < 1.0 || height > std::numeric_limits<int>::max()) {
+ // Invalid width and height. Just use the visible width and height.
+ config->natural_width = config->visible_rect_width;
+ config->natural_height = config->visible_rect_height;
+ } else {
+ config->natural_width = static_cast<int>(width);
+ config->natural_height = static_cast<int>(height);
+ }
+ }
+ config->codec = AvCodecIdToVideoCodec(codec_context->codec_id);
+
+ // Without the ffmpeg decoder configured, libavformat is unable to get the
+ // profile, format, or coded size. So choose sensible defaults and let
+ // decoders fail later if the configuration is actually unsupported.
+ config->profile = kCobaltExtensionDemuxerVideoCodecProfileUnknown;
+
+ switch (config->codec) {
+ case kCobaltExtensionDemuxerCodecH264: {
+ config->profile = ProfileIDToVideoCodecProfile(codec_context->profile);
+ if (config->profile ==
+ kCobaltExtensionDemuxerVideoCodecProfileUnknown &&
+ codec_context->extradata && codec_context->extradata_size) {
+ // TODO(b/231631898): handle the extra data here, if necessary.
+ std::cerr << "Extra data is not currently handled." << std::endl;
+ }
+ break;
+ }
+ case kCobaltExtensionDemuxerCodecHEVC: {
+ int hevc_profile = FF_PROFILE_UNKNOWN;
+ if ((codec_context->profile < FF_PROFILE_HEVC_MAIN ||
+ codec_context->profile > FF_PROFILE_HEVC_REXT) &&
+ codec_context->extradata && codec_context->extradata_size) {
+ // TODO(b/231631898): handle the extra data here, if necessary.
+ std::cerr << "Extra data is not currently handled." << std::endl;
+ } else {
+ hevc_profile = codec_context->profile;
+ }
+ switch (hevc_profile) {
+ case FF_PROFILE_HEVC_MAIN:
+ config->profile = kCobaltExtensionDemuxerHevcProfileMain;
+ break;
+ case FF_PROFILE_HEVC_MAIN_10:
+ config->profile = kCobaltExtensionDemuxerHevcProfileMain10;
+ break;
+ case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:
+ config->profile =
+ kCobaltExtensionDemuxerHevcProfileMainStillPicture;
+ break;
+ default:
+ // Always assign a default if all heuristics fail.
+ config->profile = kCobaltExtensionDemuxerHevcProfileMain;
+ break;
+ }
+ break;
+ }
+ case kCobaltExtensionDemuxerCodecVP8:
+ config->profile = kCobaltExtensionDemuxerVp8ProfileAny;
+ break;
+ case kCobaltExtensionDemuxerCodecVP9:
+ switch (codec_context->profile) {
+ case FF_PROFILE_VP9_0:
+ config->profile = kCobaltExtensionDemuxerVp9ProfileProfile0;
+ break;
+ case FF_PROFILE_VP9_1:
+ config->profile = kCobaltExtensionDemuxerVp9ProfileProfile1;
+ break;
+ case FF_PROFILE_VP9_2:
+ config->profile = kCobaltExtensionDemuxerVp9ProfileProfile2;
+ break;
+ case FF_PROFILE_VP9_3:
+ config->profile = kCobaltExtensionDemuxerVp9ProfileProfile3;
+ break;
+ default:
+ config->profile = kCobaltExtensionDemuxerVp9ProfileMin;
+ break;
+ }
+ break;
+ case kCobaltExtensionDemuxerCodecAV1:
+ config->profile = kCobaltExtensionDemuxerAv1ProfileProfileMain;
+ break;
+ case kCobaltExtensionDemuxerCodecTheora:
+ config->profile = kCobaltExtensionDemuxerTheoraProfileAny;
+ break;
+ default:
+ config->profile = ProfileIDToVideoCodecProfile(codec_context->profile);
+ }
+
+ config->color_space_primaries = codec_context->color_primaries;
+ config->color_space_transfer = codec_context->color_trc;
+ config->color_space_matrix = codec_context->colorspace;
+ config->color_space_range_id =
+ codec_context->color_range == AVCOL_RANGE_JPEG
+ ? kCobaltExtensionDemuxerColorSpaceRangeIdFull
+ : kCobaltExtensionDemuxerColorSpaceRangeIdLimited;
+
+ // Catch a potential FFmpeg bug.
+ if ((codec_context->extradata_size == 0) !=
+ (codec_context->extradata == nullptr)) {
+ std::cerr << (codec_context->extradata == nullptr ? " NULL" : " Non-NULL")
+ << " extra data cannot have size of "
+ << codec_context->extradata_size << "." << std::endl;
+ return false;
+ }
+
+ if (codec_context->extradata_size > 0) {
+ extra_video_data_.assign(
+ codec_context->extradata,
+ codec_context->extradata + codec_context->extradata_size);
+ config->extra_data = extra_video_data_.data();
+ config->extra_data_size = extra_video_data_.size();
+ } else {
+ config->extra_data = nullptr;
+ config->extra_data_size = 0;
+ }
+
+ config->encryption_scheme = GetEncryptionScheme(*video_stream);
+
+ return true;
+ }
+
+ CobaltExtensionDemuxerDataSource* data_source_ = nullptr;
+ AVStream* video_stream_ = nullptr;
+ AVStream* audio_stream_ = nullptr;
+ std::deque<ScopedAVPacket> video_packets_;
+ std::deque<ScopedAVPacket> audio_packets_;
+
+ std::vector<uint8_t> extra_audio_data_;
+ std::vector<uint8_t> extra_video_data_;
+
+ // These will only be properly populated if the corresponding AVStream is not
+ // null.
+ CobaltExtensionDemuxerAudioDecoderConfig audio_config_ = {};
+ CobaltExtensionDemuxerVideoDecoderConfig video_config_ = {};
+
+ bool initialized_ = false;
+ int64_t start_time_ = 0L;
+ int64_t duration_us_ = 0L;
+ int64_t timeline_offset_us_ = 0L;
+
+ // FFmpeg-related structs.
+ std::unique_ptr<AVIOContext, ScopedPtrAVFree> avio_context_;
+ AVFormatContext* format_context_ = nullptr;
+};
+
+CobaltExtensionDemuxerStatus FFmpegDemuxer_Initialize(void* user_data) {
+ return static_cast<FFmpegDemuxer*>(user_data)->Initialize();
+}
+
+CobaltExtensionDemuxerStatus FFmpegDemuxer_Seek(int64_t seek_time_us,
+ void* user_data) {
+ return static_cast<FFmpegDemuxer*>(user_data)->Seek(seek_time_us);
+}
+
+SbTime FFmpegDemuxer_GetStartTime(void* user_data) {
+ return static_cast<FFmpegDemuxer*>(user_data)->GetStartTime();
+}
+
+SbTime FFmpegDemuxer_GetTimelineOffset(void* user_data) {
+ return static_cast<FFmpegDemuxer*>(user_data)->GetTimelineOffset();
+}
+
+void FFmpegDemuxer_Read(CobaltExtensionDemuxerStreamType type,
+ CobaltExtensionDemuxerReadCB read_cb,
+ void* read_cb_user_data,
+ void* user_data) {
+ static_cast<FFmpegDemuxer*>(user_data)->Read(type, read_cb,
+ read_cb_user_data);
+}
+
+bool FFmpegDemuxer_GetAudioConfig(
+ CobaltExtensionDemuxerAudioDecoderConfig* config,
+ void* user_data) {
+ auto* ffmpeg_demuxer = static_cast<FFmpegDemuxer*>(user_data);
+ if (!ffmpeg_demuxer->HasAudioStream()) {
+ return false;
+ }
+ *config = ffmpeg_demuxer->GetAudioConfig();
+ return true;
+}
+
+bool FFmpegDemuxer_GetVideoConfig(
+ CobaltExtensionDemuxerVideoDecoderConfig* config,
+ void* user_data) {
+ auto* ffmpeg_demuxer = static_cast<FFmpegDemuxer*>(user_data);
+ if (!ffmpeg_demuxer->HasVideoStream()) {
+ return false;
+ }
+ *config = ffmpeg_demuxer->GetVideoConfig();
+ return true;
+}
+
+SbTime FFmpegDemuxer_GetDuration(void* user_data) {
+ return static_cast<FFmpegDemuxer*>(user_data)->GetDuration();
+}
+
+CobaltExtensionDemuxer* CreateFFmpegDemuxer(
+ CobaltExtensionDemuxerDataSource* data_source,
+ CobaltExtensionDemuxerAudioCodec* supported_audio_codecs,
+ int64_t supported_audio_codecs_size,
+ CobaltExtensionDemuxerVideoCodec* supported_video_codecs,
+ int64_t supported_video_codecs_size) {
+ // TODO(b/231632632): utilize supported_audio_codecs and
+ // supported_video_codecs. They should ultimately be passed to FFmpegDemuxer's
+ // ctor (as vectors), and the demuxer should fail fast for unsupported codecs.
+ return new CobaltExtensionDemuxer{
+ &FFmpegDemuxer_Initialize, &FFmpegDemuxer_Seek,
+ &FFmpegDemuxer_GetStartTime, &FFmpegDemuxer_GetTimelineOffset,
+ &FFmpegDemuxer_Read, &FFmpegDemuxer_GetAudioConfig,
+ &FFmpegDemuxer_GetVideoConfig, &FFmpegDemuxer_GetDuration,
+ new FFmpegDemuxer(data_source)};
+}
+
+void DestroyFFmpegDemuxer(CobaltExtensionDemuxer* demuxer) {
+ auto* ffmpeg_demuxer = static_cast<FFmpegDemuxer*>(demuxer->user_data);
+ delete ffmpeg_demuxer;
+ delete demuxer;
+}
+
+const CobaltExtensionDemuxerApi kDemuxerApi = {
+ /*name=*/kCobaltExtensionDemuxerApi,
+ /*version=*/1,
+ /*CreateDemuxer=*/&CreateFFmpegDemuxer,
+ /*DestroyDemuxer=*/&DestroyFFmpegDemuxer};
+
+} // namespace
+
+const CobaltExtensionDemuxerApi* GetFFmpegDemuxerApi() {
+ return &kDemuxerApi;
+}
+
+#if !defined(COBALT_BUILD_TYPE_GOLD)
+void TestOnlySetFFmpegDispatch(FFMPEGDispatch* dispatch) {
+ g_test_dispatch = dispatch;
+}
+#endif
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer.h b/starboard/shared/ffmpeg/ffmpeg_demuxer.h
new file mode 100644
index 0000000..cc90fc6
--- /dev/null
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer.h
@@ -0,0 +1,39 @@
+// Copyright 2022 The Cobalt Authors. 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_DEMUXER_H_
+#define STARBOARD_SHARED_FFMPEG_FFMPEG_DEMUXER_H_
+
+#include "cobalt/extension/demuxer.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+
+class FFMPEGDispatch;
+
+// Returns a demuxer implementation based on FFmpeg.
+const CobaltExtensionDemuxerApi* GetFFmpegDemuxerApi();
+
+#if !defined(COBALT_BUILD_TYPE_GOLD)
+// For testing purposes, the FFMPEGDispatch -- through which all FFmpeg calls go
+// -- can be overridden. This should never be called in production code.
+void TestOnlySetFFmpegDispatch(FFMPEGDispatch* dispatch);
+#endif
+
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_SHARED_FFMPEG_FFMPEG_DEMUXER_H_
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc b/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc
new file mode 100644
index 0000000..ae66ec7
--- /dev/null
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc
@@ -0,0 +1,761 @@
+// Copyright 2022 The Cobalt Authors. 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_demuxer.h"
+
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include "starboard/shared/ffmpeg/ffmpeg_common.h"
+#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace shared {
+namespace ffmpeg {
+namespace {
+
+using ::testing::_;
+using ::testing::AllArgs;
+using ::testing::ElementsAreArray;
+using ::testing::Eq;
+using ::testing::ExplainMatchResult;
+using ::testing::Invoke;
+using ::testing::IsNull;
+using ::testing::MockFunction;
+using ::testing::NotNull;
+using ::testing::Pointee;
+using ::testing::Pointwise;
+using ::testing::Return;
+using ::testing::SaveArg;
+using ::testing::WithArg;
+
+// Compares two CobaltExtensionDemuxerSideData structs. Deep equality is
+// checked; in other words, the actual side data is inspected (not just the ptr
+// addresses).
+MATCHER_P(SideDataEq, expected, "") {
+ return arg.type == expected.type && arg.data_size == expected.data_size &&
+ ExplainMatchResult(
+ ElementsAreArray(expected.data,
+ static_cast<size_t>(expected.data_size)),
+ std::tuple<uint8_t*, size_t>{arg.data, arg.data_size},
+ result_listener);
+}
+
+// Compares two CobaltExtensionDemuxerBuffers. Deep equality is checked; the
+// side data and data are checked element-by-element, rather than simply
+// checking ptr addresses.
+MATCHER_P(BufferMatches, expected_buffer, "") {
+ if (expected_buffer.end_of_stream) {
+ // For EoS buffers, we don't care about the other values.
+ return arg.end_of_stream;
+ }
+
+ if (arg.data_size != expected_buffer.data_size) {
+ return false;
+ }
+ if (!ExplainMatchResult(
+ ElementsAreArray(expected_buffer.data,
+ static_cast<size_t>(expected_buffer.data_size)),
+ std::tuple<uint8_t*, size_t>{arg.data, arg.data_size},
+ result_listener)) {
+ return false;
+ }
+ if (arg.side_data_elements != expected_buffer.side_data_elements) {
+ return false;
+ }
+ // Note: ::testing::Pointwise doesn't support pointer/count as a
+ // representation of an array, so we manually check each side data element.
+ for (int i = 0; i < expected_buffer.side_data_elements; ++i) {
+ if (!ExplainMatchResult(SideDataEq(expected_buffer.side_data[i]),
+ arg.side_data[i], result_listener)) {
+ return false;
+ }
+ }
+ return (arg.pts == expected_buffer.pts &&
+ arg.duration == expected_buffer.duration &&
+ arg.is_keyframe == expected_buffer.is_keyframe &&
+ arg.end_of_stream == expected_buffer.end_of_stream);
+}
+
+// Streaming is not supported.
+constexpr bool kIsStreaming = false;
+
+// Used to convert a MockFn to a pure C function.
+template <typename T, typename U>
+void CallMockCB(U* u, void* user_data) {
+ static_cast<T*>(user_data)->AsStdFunction()(u);
+}
+
+// A mock class for receiving FFmpeg calls. The API mimics the relevant parts of
+// the real FFmpeg API.
+class MockFFmpegImpl {
+ public:
+ MOCK_METHOD1(AVCodecFreeContext, void(AVCodecContext** avctx));
+ MOCK_METHOD1(AVFree, void(void* ptr));
+ MOCK_METHOD4(AVRescaleRnd, int64_t(int64_t a, int64_t b, int64_t c, int rnd));
+ MOCK_METHOD4(AVDictGet,
+ AVDictionaryEntry*(const AVDictionary* m,
+ const char* key,
+ const AVDictionaryEntry* prev,
+ int flags));
+ MOCK_METHOD4(AVFormatOpenInput,
+ int(AVFormatContext** ps,
+ const char* filename,
+ AVInputFormat* fmt,
+ AVDictionary** options));
+ MOCK_METHOD1(AVFormatCloseInput, void(AVFormatContext** s));
+ MOCK_METHOD7(
+ AVIOAllocContext,
+ AVIOContext*(
+ unsigned char* buffer,
+ int buffer_size,
+ int write_flag,
+ void* opaque,
+ int (*read_packet)(void* opaque, uint8_t* buf, int buf_size),
+ int (*write_packet)(void* opaque, uint8_t* buf, int buf_size),
+ int64_t (*seek)(void* opaque, int64_t offset, int whence)));
+ MOCK_METHOD1(AVMalloc, void*(size_t size));
+ MOCK_METHOD0(AVFormatAllocContext, AVFormatContext*());
+ MOCK_METHOD2(AVFormatFindStreamInfo,
+ int(AVFormatContext* ic, AVDictionary** options));
+ MOCK_METHOD4(
+ AVSeekFrame,
+ int(AVFormatContext* s, int stream_index, int64_t timestamp, int flags));
+ MOCK_METHOD0(AVPacketAlloc, AVPacket*());
+ MOCK_METHOD1(AVPacketFree, void(AVPacket** pkt));
+ MOCK_METHOD1(AVPacketUnref, void(AVPacket* pkt));
+ MOCK_METHOD2(AVReadFrame, int(AVFormatContext* s, AVPacket* pkt));
+ MOCK_METHOD1(AVCodecAllocContext3, AVCodecContext*(const AVCodec* codec));
+ MOCK_METHOD2(AVCodecParametersToContext,
+ int(AVCodecContext* codec, const AVCodecParameters* par));
+};
+
+// Returns a MockFFmpegImpl instance. It should not be deleted by the caller.
+MockFFmpegImpl* GetMockFFmpegImpl() {
+ static auto* const ffmpeg_wrapper = []() {
+ auto* wrapper = new MockFFmpegImpl;
+ // This mock won't be destructed.
+ testing::Mock::AllowLeak(wrapper);
+ return wrapper;
+ }();
+ return ffmpeg_wrapper;
+}
+
+// Pure C functions that call the static mock.
+void mock_avcodec_free_context(AVCodecContext** avctx) {
+ GetMockFFmpegImpl()->AVCodecFreeContext(avctx);
+}
+
+void mock_av_free(void* ptr) {
+ GetMockFFmpegImpl()->AVFree(ptr);
+}
+
+int64_t mock_av_rescale_rnd(int64_t a, int64_t b, int64_t c, int rnd) {
+ return GetMockFFmpegImpl()->AVRescaleRnd(a, b, c, rnd);
+}
+
+AVDictionaryEntry* mock_av_dict_get(const AVDictionary* m,
+ const char* key,
+ const AVDictionaryEntry* prev,
+ int flags) {
+ return GetMockFFmpegImpl()->AVDictGet(m, key, prev, flags);
+}
+
+int mock_avformat_open_input(AVFormatContext** ps,
+ const char* filename,
+ AVInputFormat* fmt,
+ AVDictionary** options) {
+ return GetMockFFmpegImpl()->AVFormatOpenInput(ps, filename, fmt, options);
+}
+
+void mock_avformat_close_input(AVFormatContext** s) {
+ GetMockFFmpegImpl()->AVFormatCloseInput(s);
+}
+
+AVIOContext* mock_avio_alloc_context(
+ unsigned char* buffer,
+ int buffer_size,
+ int write_flag,
+ void* opaque,
+ int (*read_packet)(void* opaque, uint8_t* buf, int buf_size),
+ int (*write_packet)(void* opaque, uint8_t* buf, int buf_size),
+ int64_t (*seek)(void* opaque, int64_t offset, int whence)) {
+ return GetMockFFmpegImpl()->AVIOAllocContext(
+ buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek);
+}
+
+void* mock_av_malloc(size_t size) {
+ return GetMockFFmpegImpl()->AVMalloc(size);
+}
+
+AVFormatContext* mock_avformat_alloc_context() {
+ return GetMockFFmpegImpl()->AVFormatAllocContext();
+}
+
+int mock_avformat_find_stream_info(AVFormatContext* ic,
+ AVDictionary** options) {
+ return GetMockFFmpegImpl()->AVFormatFindStreamInfo(ic, options);
+}
+
+int mock_av_seek_frame(AVFormatContext* s,
+ int stream_index,
+ int64_t timestamp,
+ int flags) {
+ return GetMockFFmpegImpl()->AVSeekFrame(s, stream_index, timestamp, flags);
+}
+
+AVPacket* mock_av_packet_alloc() {
+ return GetMockFFmpegImpl()->AVPacketAlloc();
+}
+
+void mock_av_packet_free(AVPacket** pkt) {
+ GetMockFFmpegImpl()->AVPacketFree(pkt);
+}
+
+void mock_av_packet_unref(AVPacket* pkt) {
+ GetMockFFmpegImpl()->AVPacketUnref(pkt);
+}
+
+int mock_av_read_frame(AVFormatContext* s, AVPacket* pkt) {
+ return GetMockFFmpegImpl()->AVReadFrame(s, pkt);
+}
+
+AVCodecContext* mock_avcodec_alloc_context3(const AVCodec* codec) {
+ return GetMockFFmpegImpl()->AVCodecAllocContext3(codec);
+}
+
+int mock_avcodec_parameters_to_context(AVCodecContext* codec,
+ const AVCodecParameters* par) {
+ return GetMockFFmpegImpl()->AVCodecParametersToContext(codec, par);
+}
+
+// Returns an FFMPEGDispatch instance that forwards calls to the mock stored in
+// GetMockFFmpegImpl() above. The returned FFMPEGDispatch should not be
+// deleted; it has static storage duration.
+FFMPEGDispatch* GetFFMPEGDispatch() {
+ static auto* const ffmpeg_dispatch = []() -> FFMPEGDispatch* {
+ auto* dispatch = new FFMPEGDispatch;
+ dispatch->avcodec_free_context = &mock_avcodec_free_context;
+ dispatch->av_free = &mock_av_free;
+ dispatch->av_rescale_rnd = &mock_av_rescale_rnd;
+ dispatch->av_dict_get = &mock_av_dict_get;
+ dispatch->avformat_open_input = &mock_avformat_open_input;
+ dispatch->avformat_close_input = &mock_avformat_close_input;
+ dispatch->avio_alloc_context = &mock_avio_alloc_context;
+ dispatch->av_malloc = &mock_av_malloc;
+ dispatch->avformat_alloc_context = &mock_avformat_alloc_context;
+ dispatch->avformat_find_stream_info = &mock_avformat_find_stream_info;
+ dispatch->av_seek_frame = &mock_av_seek_frame;
+ dispatch->av_packet_alloc = &mock_av_packet_alloc;
+ dispatch->av_packet_free = &mock_av_packet_free;
+ dispatch->av_packet_unref = &mock_av_packet_unref;
+ dispatch->av_read_frame = &mock_av_read_frame;
+ dispatch->avcodec_alloc_context3 = &mock_avcodec_alloc_context3;
+ dispatch->avcodec_parameters_to_context =
+ &mock_avcodec_parameters_to_context;
+ return dispatch;
+ }();
+
+ return ffmpeg_dispatch;
+}
+
+// A mock class representing a data source passed to the cobalt extension
+// demuxer.
+class MockDataSource {
+ public:
+ MOCK_METHOD2(BlockingRead, int(uint8_t* data, int bytes_requested));
+ MOCK_METHOD1(SeekTo, void(int position));
+ MOCK_METHOD0(GetPosition, int64_t());
+ MOCK_METHOD0(GetSize, int64_t());
+};
+
+// These functions forward calls to a MockDataSource.
+int MockBlockingRead(uint8_t* data, int bytes_requested, void* user_data) {
+ return static_cast<MockDataSource*>(user_data)->BlockingRead(data,
+ bytes_requested);
+}
+
+void MockSeekTo(int position, void* user_data) {
+ static_cast<MockDataSource*>(user_data)->SeekTo(position);
+}
+
+int64_t MockGetPosition(void* user_data) {
+ return static_cast<MockDataSource*>(user_data)->GetPosition();
+}
+
+int64_t MockGetSize(void* user_data) {
+ return static_cast<MockDataSource*>(user_data)->GetSize();
+}
+
+// A test fixture is used to ensure that the (static) mock is checked and reset
+// between tests.
+class FFmpegDemuxerTest : public ::testing::Test {
+ public:
+ FFmpegDemuxerTest() { TestOnlySetFFmpegDispatch(GetFFMPEGDispatch()); }
+
+ ~FFmpegDemuxerTest() override {
+ testing::Mock::VerifyAndClearExpectations(GetMockFFmpegImpl());
+ }
+};
+
+TEST_F(FFmpegDemuxerTest, InitializeAllocatesContextAndOpensInput) {
+ auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
+
+ AVFormatContext format_context = {};
+ AVInputFormat iformat = {};
+ iformat.name = "mp4";
+ format_context.iformat = &iformat;
+
+ std::vector<AVStream> streams = {AVStream{}};
+ std::vector<AVStream*> stream_ptrs = {&streams[0]};
+ std::vector<AVCodecParameters> stream_params = {AVCodecParameters{}};
+ stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
+ stream_params[0].codec_id = AV_CODEC_ID_AAC;
+
+ AVIOContext avio_context = {};
+ AVCodecContext codec_context = {};
+
+ // Sanity checks; if any of these fail, the test has a bug.
+ SB_CHECK(streams.size() == stream_ptrs.size());
+ SB_CHECK(streams.size() == stream_params.size());
+
+ for (int i = 0; i < streams.size(); ++i) {
+ streams[i].codecpar = &stream_params[i];
+ streams[i].time_base.num = 1;
+ streams[i].time_base.den = 1000000;
+ streams[i].start_time = 0;
+ }
+
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
+ .WillOnce(Return(&format_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatCloseInput(Pointee(Eq(&format_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
+ .WillOnce(Return(&avio_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
+ .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
+ context->nb_streams = stream_ptrs.size();
+ context->streams = stream_ptrs.data();
+ context->duration = 120 * AV_TIME_BASE;
+ return 0;
+ })));
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
+ .WillOnce(Return(&codec_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecFreeContext(Pointee(Eq(&codec_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecParametersToContext(&codec_context, streams[0].codecpar))
+ .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
+ context->codec_id = AV_CODEC_ID_AAC;
+ context->sample_fmt = AV_SAMPLE_FMT_FLT;
+ context->channel_layout = AV_CH_LAYOUT_STEREO;
+ context->channels = 2;
+ context->sample_rate = 44100;
+ return 0;
+ })));
+
+ const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+ MockDataSource data_source;
+ CobaltExtensionDemuxerDataSource c_data_source{
+ &MockBlockingRead, &MockSeekTo, &MockGetPosition,
+ &MockGetSize, kIsStreaming, &data_source};
+ std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+ std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+ CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+ &c_data_source, supported_audio_codecs.data(),
+ supported_audio_codecs.size(), supported_video_codecs.data(),
+ supported_video_codecs.size());
+
+ ASSERT_THAT(api, NotNull());
+ EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+
+ api->DestroyDemuxer(demuxer);
+}
+
+TEST_F(FFmpegDemuxerTest, ReadsDataFromDataSource) {
+ auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
+ constexpr size_t kReadSize = 5;
+
+ AVFormatContext format_context = {};
+ AVInputFormat iformat = {};
+ iformat.name = "mp4";
+ format_context.iformat = &iformat;
+
+ std::vector<AVStream> streams = {AVStream{}};
+ std::vector<AVStream*> stream_ptrs = {&streams[0]};
+ std::vector<AVCodecParameters> stream_params = {AVCodecParameters{}};
+ stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
+ stream_params[0].codec_id = AV_CODEC_ID_AAC;
+
+ AVIOContext avio_context = {};
+ AVCodecContext codec_context = {};
+
+ // Sanity checks; if any of these fail, the test has a bug.
+ SB_CHECK(streams.size() == stream_ptrs.size());
+ SB_CHECK(streams.size() == stream_params.size());
+
+ for (int i = 0; i < streams.size(); ++i) {
+ streams[i].codecpar = &stream_params[i];
+ streams[i].time_base.num = 1;
+ streams[i].time_base.den = 1000000;
+ streams[i].start_time = 0;
+ streams[i].index = i;
+ }
+
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
+ .WillOnce(Return(&format_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatCloseInput(Pointee(Eq(&format_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
+
+ // We will capture the AVIO read operation passed to FFmpeg, so that we can
+ // simulate FFmpeg reading data from the data source.
+ int (*read_packet)(void*, uint8_t*, int) = nullptr;
+ // Data blob that will be passed to read_packet.
+ void* opaque_read_packet = nullptr;
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
+ .WillOnce(DoAll(SaveArg<3>(&opaque_read_packet), SaveArg<4>(&read_packet),
+ Return(&avio_context)));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
+ .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
+ context->nb_streams = stream_ptrs.size();
+ context->streams = stream_ptrs.data();
+ context->duration = 120 * AV_TIME_BASE;
+ return 0;
+ })));
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
+ .WillOnce(Return(&codec_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecFreeContext(Pointee(Eq(&codec_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecParametersToContext(&codec_context, streams[0].codecpar))
+ .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
+ context->codec_id = AV_CODEC_ID_AAC;
+ context->sample_fmt = AV_SAMPLE_FMT_FLT;
+ context->channel_layout = AV_CH_LAYOUT_STEREO;
+ context->channels = 2;
+ context->sample_rate = 44100;
+ return 0;
+ })));
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVReadFrame(&format_context, _))
+ .WillOnce(WithArg<1>(Invoke([&opaque_read_packet, &read_packet,
+ kReadSize](AVPacket* packet) {
+ SB_CHECK(read_packet != nullptr)
+ << "FFmpeg's read operation should be set via avio_alloc_context "
+ "before av_read_frame is called.";
+ // This will be freed when av_packet_free is called (which eventually
+ // calls AVPacketFree).
+ packet->data =
+ static_cast<uint8_t*>(malloc(kReadSize * sizeof(uint8_t)));
+ packet->size = kReadSize;
+ read_packet(opaque_read_packet, packet->data, kReadSize);
+ return 0;
+ })));
+
+ const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+ ASSERT_THAT(api, NotNull());
+
+ std::vector<uint8_t> expected_data = {0, 1, 2, 3, 4};
+ SB_CHECK(expected_data.size() == kReadSize);
+
+ MockDataSource data_source;
+ EXPECT_CALL(data_source, BlockingRead(_, kReadSize))
+ .WillOnce(WithArg<0>(Invoke([expected_data](uint8_t* buffer) {
+ for (int i = 0; i < expected_data.size(); ++i) {
+ buffer[i] = expected_data[i];
+ }
+ return kReadSize;
+ })));
+ CobaltExtensionDemuxerDataSource c_data_source{
+ &MockBlockingRead, &MockSeekTo, &MockGetPosition,
+ &MockGetSize, kIsStreaming, &data_source};
+ std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+ std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+ CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+ &c_data_source, supported_audio_codecs.data(),
+ supported_audio_codecs.size(), supported_video_codecs.data(),
+ supported_video_codecs.size());
+
+ EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+
+ const CobaltExtensionDemuxerBuffer expected_buffer = {
+ expected_data.data(),
+ static_cast<int64_t>(expected_data.size()),
+ nullptr,
+ 0,
+ 0,
+ 0,
+ false,
+ false};
+
+ MockFunction<void(CobaltExtensionDemuxerBuffer*)> read_cb;
+ AVPacket av_packet = {};
+
+ // This is the main check: we ensure that the expected buffer is passed to us
+ // via the read callback.
+ EXPECT_CALL(read_cb, Call(Pointee(BufferMatches(expected_buffer)))).Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVPacketAlloc())
+ .WillOnce(Return(&av_packet));
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVPacketFree(Pointee(Eq(&av_packet))))
+ .WillOnce(Invoke([](AVPacket** av_packet) { free((*av_packet)->data); }));
+
+ demuxer->Read(kCobaltExtensionDemuxerStreamTypeAudio,
+ &CallMockCB<decltype(read_cb), CobaltExtensionDemuxerBuffer>,
+ &read_cb, demuxer->user_data);
+
+ api->DestroyDemuxer(demuxer);
+}
+
+TEST_F(FFmpegDemuxerTest, ReturnsAudioConfig) {
+ auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
+
+ AVFormatContext format_context = {};
+ AVInputFormat iformat = {};
+ iformat.name = "mp4";
+ format_context.iformat = &iformat;
+
+ std::vector<AVStream> streams = {AVStream{}};
+ std::vector<AVStream*> stream_ptrs = {&streams[0]};
+ std::vector<AVCodecParameters> stream_params = {AVCodecParameters{}};
+ stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
+ stream_params[0].codec_id = AV_CODEC_ID_AAC;
+
+ AVIOContext avio_context = {};
+ AVCodecContext codec_context = {};
+
+ // Sanity checks; if any of these fail, the test has a bug.
+ SB_CHECK(streams.size() == stream_ptrs.size());
+ SB_CHECK(streams.size() == stream_params.size());
+
+ for (int i = 0; i < streams.size(); ++i) {
+ streams[i].codecpar = &stream_params[i];
+ streams[i].time_base.num = 1;
+ streams[i].time_base.den = 1000000;
+ streams[i].start_time = 0;
+ }
+
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
+ .WillOnce(Return(&format_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatCloseInput(Pointee(Eq(&format_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
+ .WillOnce(Return(&avio_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
+ .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
+ context->nb_streams = stream_ptrs.size();
+ context->streams = stream_ptrs.data();
+ context->duration = 120 * AV_TIME_BASE;
+ return 0;
+ })));
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
+ .WillOnce(Return(&codec_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecFreeContext(Pointee(Eq(&codec_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecParametersToContext(&codec_context, streams[0].codecpar))
+ .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
+ context->codec_id = AV_CODEC_ID_AAC;
+ context->sample_fmt = AV_SAMPLE_FMT_FLT;
+ context->channel_layout = AV_CH_LAYOUT_STEREO;
+ context->channels = 2;
+ context->sample_rate = 44100;
+ return 0;
+ })));
+
+ const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+ MockDataSource data_source;
+ CobaltExtensionDemuxerDataSource c_data_source{
+ &MockBlockingRead, &MockSeekTo, &MockGetPosition,
+ &MockGetSize, kIsStreaming, &data_source};
+ std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+ std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+ CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+ &c_data_source, supported_audio_codecs.data(),
+ supported_audio_codecs.size(), supported_video_codecs.data(),
+ supported_video_codecs.size());
+
+ ASSERT_THAT(api, NotNull());
+ EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+
+ CobaltExtensionDemuxerAudioDecoderConfig actual_audio_config = {};
+ demuxer->GetAudioConfig(&actual_audio_config, demuxer->user_data);
+
+ // These values are derived from those set via AVCodecParametersToContext.
+ EXPECT_EQ(actual_audio_config.codec, kCobaltExtensionDemuxerCodecAAC);
+ EXPECT_EQ(actual_audio_config.sample_format,
+ kCobaltExtensionDemuxerSampleFormatF32);
+ EXPECT_EQ(actual_audio_config.channel_layout,
+ kCobaltExtensionDemuxerChannelLayoutStereo);
+ EXPECT_EQ(actual_audio_config.encryption_scheme,
+ kCobaltExtensionDemuxerEncryptionSchemeUnencrypted);
+ EXPECT_EQ(actual_audio_config.samples_per_second, 44100);
+ EXPECT_THAT(actual_audio_config.extra_data, IsNull());
+ EXPECT_EQ(actual_audio_config.extra_data_size, 0);
+
+ api->DestroyDemuxer(demuxer);
+}
+
+TEST_F(FFmpegDemuxerTest, ReturnsVideoConfig) {
+ auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
+
+ AVFormatContext format_context = {};
+ AVInputFormat iformat = {};
+ iformat.name = "mp4";
+ format_context.iformat = &iformat;
+
+ // In this test we simulate both an audio stream and a video stream being
+ // present.
+ std::vector<AVStream> streams = {AVStream{}, AVStream{}};
+ std::vector<AVStream*> stream_ptrs = {&streams[0], &streams[1]};
+ std::vector<AVCodecParameters> stream_params = {AVCodecParameters{},
+ AVCodecParameters{}};
+ stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
+ stream_params[0].codec_id = AV_CODEC_ID_AAC;
+ stream_params[1].codec_type = AVMEDIA_TYPE_VIDEO;
+ stream_params[1].codec_id = AV_CODEC_ID_H264;
+
+ AVIOContext avio_context = {};
+ AVCodecContext codec_context_1 = {};
+ AVCodecContext codec_context_2 = {};
+
+ // Sanity checks; if any of these fail, the test has a bug.
+ SB_CHECK(streams.size() == stream_ptrs.size());
+ SB_CHECK(streams.size() == stream_params.size());
+
+ for (int i = 0; i < streams.size(); ++i) {
+ streams[i].codecpar = &stream_params[i];
+ streams[i].time_base.num = 1;
+ streams[i].time_base.den = 1000000;
+ streams[i].start_time = 0;
+ }
+
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
+ .WillOnce(Return(&format_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatCloseInput(Pointee(Eq(&format_context))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
+ .WillOnce(Return(&avio_context));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
+ .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
+ context->nb_streams = stream_ptrs.size();
+ context->streams = stream_ptrs.data();
+ context->duration = 120 * AV_TIME_BASE;
+ return 0;
+ })));
+ EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
+ .WillOnce(Return(&codec_context_1))
+ .WillOnce(Return(&codec_context_2));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecFreeContext(Pointee(Eq(&codec_context_1))))
+ .Times(1);
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecFreeContext(Pointee(Eq(&codec_context_2))))
+ .Times(1);
+
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecParametersToContext(_, streams[0].codecpar))
+ .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
+ context->codec_id = AV_CODEC_ID_AAC;
+ context->sample_fmt = AV_SAMPLE_FMT_FLT;
+ context->channel_layout = AV_CH_LAYOUT_STEREO;
+ context->channels = 2;
+ context->sample_rate = 44100;
+ return 0;
+ })));
+ EXPECT_CALL(*mock_ffmpeg_wrapper,
+ AVCodecParametersToContext(_, streams[1].codecpar))
+ .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
+ context->codec_id = AV_CODEC_ID_H264;
+ context->width = 1920;
+ context->height = 1080;
+ context->sample_aspect_ratio.num = 1;
+ context->sample_aspect_ratio.den = 1;
+ context->profile = FF_PROFILE_H264_BASELINE;
+ context->pix_fmt = AV_PIX_FMT_YUVJ420P;
+ context->colorspace = AVCOL_SPC_BT709;
+ context->color_range = AVCOL_RANGE_MPEG;
+ return 0;
+ })));
+
+ const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+ MockDataSource data_source;
+ CobaltExtensionDemuxerDataSource c_data_source{
+ &MockBlockingRead, &MockSeekTo, &MockGetPosition,
+ &MockGetSize, kIsStreaming, &data_source};
+ std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+ std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+ CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+ &c_data_source, supported_audio_codecs.data(),
+ supported_audio_codecs.size(), supported_video_codecs.data(),
+ supported_video_codecs.size());
+
+ ASSERT_THAT(api, NotNull());
+ EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+
+ CobaltExtensionDemuxerVideoDecoderConfig actual_video_config = {};
+ demuxer->GetVideoConfig(&actual_video_config, demuxer->user_data);
+
+ // These values are derived from those set via AVCodecParametersToContext.
+ EXPECT_EQ(actual_video_config.codec, kCobaltExtensionDemuxerCodecH264);
+ EXPECT_EQ(actual_video_config.profile,
+ kCobaltExtensionDemuxerH264ProfileBaseline);
+ EXPECT_EQ(actual_video_config.coded_width, 1920);
+ EXPECT_EQ(actual_video_config.coded_height, 1080);
+ EXPECT_EQ(actual_video_config.visible_rect_x, 0);
+ EXPECT_EQ(actual_video_config.visible_rect_y, 0);
+ EXPECT_EQ(actual_video_config.visible_rect_width, 1920);
+ EXPECT_EQ(actual_video_config.visible_rect_height, 1080);
+ EXPECT_EQ(actual_video_config.natural_width, 1920);
+ EXPECT_EQ(actual_video_config.natural_height, 1080);
+ EXPECT_THAT(actual_video_config.extra_data, IsNull());
+ EXPECT_EQ(actual_video_config.extra_data_size, 0);
+
+ api->DestroyDemuxer(demuxer);
+}
+
+} // namespace
+} // namespace ffmpeg
+} // namespace shared
+} // namespace starboard
diff --git a/starboard/shared/ffmpeg/ffmpeg_dispatch.h b/starboard/shared/ffmpeg/ffmpeg_dispatch.h
index 4d70b66..1b46ff6 100644
--- a/starboard/shared/ffmpeg/ffmpeg_dispatch.h
+++ b/starboard/shared/ffmpeg/ffmpeg_dispatch.h
@@ -23,8 +23,13 @@
struct AVCodec;
struct AVCodecContext;
+struct AVCodecParameters;
struct AVDictionary;
+struct AVDictionaryEntry;
+struct AVFormatContext;
struct AVFrame;
+struct AVInputFormat;
+struct AVIOContext;
struct AVPacket;
namespace starboard {
@@ -99,12 +104,46 @@
AVFrame* (*avcodec_alloc_frame)(void);
void (*avcodec_get_frame_defaults)(AVFrame* frame);
void (*avcodec_align_dimensions2)(AVCodecContext* avctx,
- int* width, int* height,
+ int* width,
+ int* height,
int linesize_align[]);
unsigned (*avformat_version)(void);
void (*av_register_all)(void);
+ void (*av_free)(void* ptr);
+ AVPacket* (*av_packet_alloc)(void);
+ void (*av_packet_free)(AVPacket** pkt);
+ AVDictionaryEntry* (*av_dict_get)(const AVDictionary* m,
+ const char* key,
+ const AVDictionaryEntry* prev,
+ int flags);
+ // Note: |rnd| represents type enum AVRounding.
+ int64_t (*av_rescale_rnd)(int64_t a, int64_t b, int64_t c, int rnd);
+ int (*av_seek_frame)(AVFormatContext* s,
+ int stream_index,
+ int64_t timestamp,
+ int flags);
+ int (*av_read_frame)(AVFormatContext* s, AVPacket* pkt);
+ void (*av_packet_unref)(AVPacket* pkt);
+ int (*avformat_open_input)(AVFormatContext** ps,
+ const char* filename,
+ AVInputFormat* fmt,
+ AVDictionary** options);
+ void (*avformat_close_input)(AVFormatContext** s);
+ AVFormatContext* (*avformat_alloc_context)(void);
+ int (*avformat_find_stream_info)(AVFormatContext* ic, AVDictionary** options);
+ AVIOContext* (*avio_alloc_context)(
+ unsigned char* buffer,
+ int buffer_size,
+ int write_flag,
+ void* opaque,
+ int (*read_packet)(void* opaque, uint8_t* buf, int buf_size),
+ int (*write_packet)(void* opaque, uint8_t* buf, int buf_size),
+ int64_t (*seek)(void* opaque, int64_t offset, int whence));
+ int (*avcodec_parameters_to_context)(AVCodecContext* codec,
+ const AVCodecParameters* par);
+
int specialization_version() const;
// In Ffmpeg, the calls to avcodec_open2() and avcodec_close() are not
diff --git a/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc b/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc
index 4f8aec4..748d897 100644
--- a/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc
+++ b/starboard/shared/ffmpeg/ffmpeg_dynamic_load_dispatch_impl.cc
@@ -261,6 +261,9 @@
INITSYMBOL(avutil_, av_malloc);
INITSYMBOL(avutil_, av_freep);
INITSYMBOL(avutil_, av_frame_alloc);
+ INITSYMBOL(avutil_, av_free);
+ INITSYMBOL(avutil_, av_dict_get);
+ INITSYMBOL(avutil_, av_rescale_rnd);
#if LIBAVUTIL_VERSION_INT >= LIBAVUTIL_VERSION_52_8
INITSYMBOL(avutil_, av_frame_free);
#endif // LIBAVUTIL_VERSION_INT >= LIBAVUTIL_VERSION_52_8
@@ -287,12 +290,23 @@
INITSYMBOL(avcodec_, avcodec_alloc_frame);
INITSYMBOL(avcodec_, avcodec_get_frame_defaults);
INITSYMBOL(avcodec_, avcodec_align_dimensions2);
+ INITSYMBOL(avcodec_, av_packet_alloc);
+ INITSYMBOL(avcodec_, av_packet_free);
+ INITSYMBOL(avcodec_, av_packet_unref);
+ INITSYMBOL(avcodec_, avcodec_parameters_to_context);
// 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);
+ INITSYMBOL(avformat_, av_read_frame);
+ INITSYMBOL(avformat_, av_seek_frame);
+ INITSYMBOL(avformat_, avformat_open_input);
+ INITSYMBOL(avformat_, avformat_close_input);
+ INITSYMBOL(avformat_, avformat_alloc_context);
+ INITSYMBOL(avformat_, avformat_find_stream_info);
+ INITSYMBOL(avformat_, avio_alloc_context);
#undef INITSYMBOL
}
