starboard/android/shared/media_codec_bridge.h - cobalt - Git at Google

 // Copyright 2017 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_ANDROID_SHARED_MEDIA_CODEC_BRIDGE_H_
 #define STARBOARD_ANDROID_SHARED_MEDIA_CODEC_BRIDGE_H_

 #include <string>

 #include "starboard/android/shared/jni_env_ext.h"
 #include "starboard/android/shared/jni_utils.h"
 #include "starboard/android/shared/media_common.h"
 #include "starboard/common/optional.h"
 #include "starboard/common/scoped_ptr.h"
 #include "starboard/shared/starboard/media/media_util.h"

 namespace starboard {
 namespace android {
 namespace shared {

 // These must be in sync with MediaCodecWrapper.MEDIA_CODEC_XXX constants in
 // MediaCodecBridge.java.
 const jint MEDIA_CODEC_OK = 0;
 const jint MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER = 1;
 const jint MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER = 2;
 const jint MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED = 3;
 const jint MEDIA_CODEC_OUTPUT_FORMAT_CHANGED = 4;
 const jint MEDIA_CODEC_INPUT_END_OF_STREAM = 5;
 const jint MEDIA_CODEC_OUTPUT_END_OF_STREAM = 6;
 const jint MEDIA_CODEC_NO_KEY = 7;
 const jint MEDIA_CODEC_INSUFFICIENT_OUTPUT_PROTECTION = 8;
 const jint MEDIA_CODEC_ABORT = 9;
 const jint MEDIA_CODEC_ERROR = 10;

 const jint BUFFER_FLAG_CODEC_CONFIG = 2;
 const jint BUFFER_FLAG_END_OF_STREAM = 4;

 const jint CRYPTO_MODE_UNENCRYPTED = 0;
 const jint CRYPTO_MODE_AES_CTR = 1;
 const jint CRYPTO_MODE_AES_CBC = 2;

 struct DequeueInputResult {
   jint status;
   jint index;
 };

 struct DequeueOutputResult {
   jint status;
   jint index;
   jint flags;
   jint offset;
   jlong presentation_time_microseconds;
   jint num_bytes;
 };

 struct FrameSize {
   jint texture_width;
   jint texture_height;

   // Crop values can be set to -1 when they are not provided by the platform
   jint crop_left = -1;
   jint crop_top = -1;
   jint crop_right = -1;
   jint crop_bottom = -1;

   bool has_crop_values() const {
     return crop_left >= 0 && crop_top >= 0 && crop_right >= 0 &&
            crop_bottom >= 0;
   }

   jint display_width() const {
     if (has_crop_values()) {
       return crop_right - crop_left + 1;
     }

     return texture_width;
   }

   jint display_height() const {
     if (has_crop_values()) {
       return crop_bottom - crop_top + 1;
     }

     return texture_height;
   }

   void DCheckValid() const {
     SB_DCHECK(texture_width >= 0) << texture_width;
     SB_DCHECK(texture_height >= 0) << texture_height;

     if (crop_left >= 0 || crop_top >= 0 || crop_right >= 0 ||
         crop_bottom >= 0) {
       // If there is at least one crop value set, all of them should be set.
       SB_DCHECK(crop_left >= 0) << crop_left;
       SB_DCHECK(crop_top >= 0) << crop_top;
       SB_DCHECK(crop_right >= 0) << crop_right;
       SB_DCHECK(crop_bottom >= 0) << crop_bottom;
       SB_DCHECK(has_crop_values());
       SB_DCHECK(display_width() >= 0) << display_width();
       SB_DCHECK(display_height() >= 0) << display_height();
     }
   }
 };

 struct AudioOutputFormatResult {
   jint status;
   jint sample_rate;
   jint channel_count;
 };

 class MediaCodecBridge {
  public:
   typedef ::starboard::shared::starboard::media::AudioStreamInfo
       AudioStreamInfo;

   // The methods are called on the default Looper.  They won't get called after
   // Flush() is returned.
   class Handler {
    public:
     virtual void OnMediaCodecError(bool is_recoverable,
                                    bool is_transient,
                                    const std::string& diagnostic_info) = 0;
     virtual void OnMediaCodecInputBufferAvailable(int buffer_index) = 0;
     virtual void OnMediaCodecOutputBufferAvailable(int buffer_index,
                                                    int flags,
                                                    int offset,
                                                    int64_t presentation_time_us,
                                                    int size) = 0;
     virtual void OnMediaCodecOutputFormatChanged() = 0;
     // This is only called on video decoder when tunnel mode is enabled.
     virtual void OnMediaCodecFrameRendered(int64_t frame_timestamp) = 0;

    protected:
     ~Handler() {}
   };

   static scoped_ptr<MediaCodecBridge> CreateAudioMediaCodecBridge(
       const AudioStreamInfo& audio_stream_info,
       Handler* handler,
       jobject j_media_crypto);

   // `max_width` and `max_height` can be set to positive values to specify the
   // maximum resolutions the video can be adapted to.
   // When they are not set, MediaCodecBridge will set them to the maximum
   // resolutions the platform can decode.
   // Both of them have to be set at the same time (i.e. we cannot set one of
   // them without the other), which will be checked in the function.
   static scoped_ptr<MediaCodecBridge> CreateVideoMediaCodecBridge(
       SbMediaVideoCodec video_codec,
       // `width_hint` and `height_hint` are used to create the Android video
       // format, which don't have to be directly related to the resolution of
       // the video.
       int width_hint,
       int height_hint,
       int fps,
       optional<int> max_width,
       optional<int> max_height,
       Handler* handler,
       jobject j_surface,
       jobject j_media_crypto,
       const SbMediaColorMetadata* color_metadata,
       bool require_secured_decoder,
       bool require_software_codec,
       int tunnel_mode_audio_session_id,
       bool force_big_endian_hdr_metadata,
       int max_video_input_size,
       std::string* error_message);

   ~MediaCodecBridge();

   // It is the responsibility of the client to manage the lifetime of the
   // jobject that |GetInputBuffer| returns.
   jobject GetInputBuffer(jint index);
   jint QueueInputBuffer(jint index,
                         jint offset,
                         jint size,
                         jlong presentation_time_microseconds,
                         jint flags);
   jint QueueSecureInputBuffer(jint index,
                               jint offset,
                               const SbDrmSampleInfo& drm_sample_info,
                               jlong presentation_time_microseconds);

   // It is the responsibility of the client to manage the lifetime of the
   // jobject that |GetOutputBuffer| returns.
   jobject GetOutputBuffer(jint index);
   void ReleaseOutputBuffer(jint index, jboolean render);
   void ReleaseOutputBufferAtTimestamp(jint index, jlong render_timestamp_ns);

   void SetPlaybackRate(double playback_rate);
   bool Start();
   jint Flush();
   FrameSize GetOutputSize();
   AudioOutputFormatResult GetAudioOutputFormat();

   void OnMediaCodecError(bool is_recoverable,
                          bool is_transient,
                          const std::string& diagnostic_info);
   void OnMediaCodecInputBufferAvailable(int buffer_index);
   void OnMediaCodecOutputBufferAvailable(int buffer_index,
                                          int flags,
                                          int offset,
                                          int64_t presentation_time_us,
                                          int size);
   void OnMediaCodecOutputFormatChanged();
   void OnMediaCodecFrameRendered(int64_t frame_timestamp);

  private:
   // |MediaCodecBridge|s must only be created through its factory methods.
   explicit MediaCodecBridge(Handler* handler);
   void Initialize(jobject j_media_codec_bridge);

   Handler* handler_ = NULL;
   jobject j_media_codec_bridge_ = NULL;

   // Profiling and allocation tracking has identified this area to be hot,
   // and, capable of enough to cause GC times to raise high enough to impact
   // playback.  We mitigate this by reusing these output objects between calls
   // to |DequeueInputBuffer|, |DequeueOutputBuffer|, and
   // |GetOutputDimensions|.
   jobject j_reused_get_output_format_result_ = NULL;

   MediaCodecBridge(const MediaCodecBridge&) = delete;
   void operator=(const MediaCodecBridge&) = delete;
 };

 }  // namespace shared
 }  // namespace android
 }  // namespace starboard

 #endif  // STARBOARD_ANDROID_SHARED_MEDIA_CODEC_BRIDGE_H_
	// Copyright 2017 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_ANDROID_SHARED_MEDIA_CODEC_BRIDGE_H_
	#define STARBOARD_ANDROID_SHARED_MEDIA_CODEC_BRIDGE_H_

	#include <string>

	#include "starboard/android/shared/jni_env_ext.h"
	#include "starboard/android/shared/jni_utils.h"
	#include "starboard/android/shared/media_common.h"
	#include "starboard/common/optional.h"
	#include "starboard/common/scoped_ptr.h"
	#include "starboard/shared/starboard/media/media_util.h"

	namespace starboard {
	namespace android {
	namespace shared {

	// These must be in sync with MediaCodecWrapper.MEDIA_CODEC_XXX constants in
	// MediaCodecBridge.java.
	const jint MEDIA_CODEC_OK = 0;
	const jint MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER = 1;
	const jint MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER = 2;
	const jint MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED = 3;
	const jint MEDIA_CODEC_OUTPUT_FORMAT_CHANGED = 4;
	const jint MEDIA_CODEC_INPUT_END_OF_STREAM = 5;
	const jint MEDIA_CODEC_OUTPUT_END_OF_STREAM = 6;
	const jint MEDIA_CODEC_NO_KEY = 7;
	const jint MEDIA_CODEC_INSUFFICIENT_OUTPUT_PROTECTION = 8;
	const jint MEDIA_CODEC_ABORT = 9;
	const jint MEDIA_CODEC_ERROR = 10;

	const jint BUFFER_FLAG_CODEC_CONFIG = 2;
	const jint BUFFER_FLAG_END_OF_STREAM = 4;

	const jint CRYPTO_MODE_UNENCRYPTED = 0;
	const jint CRYPTO_MODE_AES_CTR = 1;
	const jint CRYPTO_MODE_AES_CBC = 2;

	struct DequeueInputResult {
	jint status;
	jint index;
	};

	struct DequeueOutputResult {
	jint status;
	jint index;
	jint flags;
	jint offset;
	jlong presentation_time_microseconds;
	jint num_bytes;
	};

	struct FrameSize {
	jint texture_width;
	jint texture_height;

	// Crop values can be set to -1 when they are not provided by the platform
	jint crop_left = -1;
	jint crop_top = -1;
	jint crop_right = -1;
	jint crop_bottom = -1;

	bool has_crop_values() const {
	return crop_left >= 0 && crop_top >= 0 && crop_right >= 0 &&
	crop_bottom >= 0;
	}

	jint display_width() const {
	if (has_crop_values()) {
	return crop_right - crop_left + 1;
	}

	return texture_width;
	}

	jint display_height() const {
	if (has_crop_values()) {
	return crop_bottom - crop_top + 1;
	}

	return texture_height;
	}

	void DCheckValid() const {
	SB_DCHECK(texture_width >= 0) << texture_width;
	SB_DCHECK(texture_height >= 0) << texture_height;

	if (crop_left >= 0 \|\| crop_top >= 0 \|\| crop_right >= 0 \|\|
	crop_bottom >= 0) {
	// If there is at least one crop value set, all of them should be set.
	SB_DCHECK(crop_left >= 0) << crop_left;
	SB_DCHECK(crop_top >= 0) << crop_top;
	SB_DCHECK(crop_right >= 0) << crop_right;
	SB_DCHECK(crop_bottom >= 0) << crop_bottom;
	SB_DCHECK(has_crop_values());
	SB_DCHECK(display_width() >= 0) << display_width();
	SB_DCHECK(display_height() >= 0) << display_height();
	}
	}
	};

	struct AudioOutputFormatResult {
	jint status;
	jint sample_rate;
	jint channel_count;
	};

	class MediaCodecBridge {
	public:
	typedef ::starboard::shared::starboard::media::AudioStreamInfo
	AudioStreamInfo;

	// The methods are called on the default Looper. They won't get called after
	// Flush() is returned.
	class Handler {
	public:
	virtual void OnMediaCodecError(bool is_recoverable,
	bool is_transient,
	const std::string& diagnostic_info) = 0;
	virtual void OnMediaCodecInputBufferAvailable(int buffer_index) = 0;
	virtual void OnMediaCodecOutputBufferAvailable(int buffer_index,
	int flags,
	int offset,
	int64_t presentation_time_us,
	int size) = 0;
	virtual void OnMediaCodecOutputFormatChanged() = 0;
	// This is only called on video decoder when tunnel mode is enabled.
	virtual void OnMediaCodecFrameRendered(int64_t frame_timestamp) = 0;

	protected:
	~Handler() {}
	};

	static scoped_ptr<MediaCodecBridge> CreateAudioMediaCodecBridge(
	const AudioStreamInfo& audio_stream_info,
	Handler* handler,
	jobject j_media_crypto);

	// `max_width` and `max_height` can be set to positive values to specify the
	// maximum resolutions the video can be adapted to.
	// When they are not set, MediaCodecBridge will set them to the maximum
	// resolutions the platform can decode.
	// Both of them have to be set at the same time (i.e. we cannot set one of
	// them without the other), which will be checked in the function.
	static scoped_ptr<MediaCodecBridge> CreateVideoMediaCodecBridge(
	SbMediaVideoCodec video_codec,
	// `width_hint` and `height_hint` are used to create the Android video
	// format, which don't have to be directly related to the resolution of
	// the video.
	int width_hint,
	int height_hint,
	int fps,
	optional<int> max_width,
	optional<int> max_height,
	Handler* handler,
	jobject j_surface,
	jobject j_media_crypto,
	const SbMediaColorMetadata* color_metadata,
	bool require_secured_decoder,
	bool require_software_codec,
	int tunnel_mode_audio_session_id,
	bool force_big_endian_hdr_metadata,
	int max_video_input_size,
	std::string* error_message);

	~MediaCodecBridge();

	// It is the responsibility of the client to manage the lifetime of the
	// jobject that \|GetInputBuffer\| returns.
	jobject GetInputBuffer(jint index);
	jint QueueInputBuffer(jint index,
	jint offset,
	jint size,
	jlong presentation_time_microseconds,
	jint flags);
	jint QueueSecureInputBuffer(jint index,
	jint offset,
	const SbDrmSampleInfo& drm_sample_info,
	jlong presentation_time_microseconds);

	// It is the responsibility of the client to manage the lifetime of the
	// jobject that \|GetOutputBuffer\| returns.
	jobject GetOutputBuffer(jint index);
	void ReleaseOutputBuffer(jint index, jboolean render);
	void ReleaseOutputBufferAtTimestamp(jint index, jlong render_timestamp_ns);

	void SetPlaybackRate(double playback_rate);
	bool Start();
	jint Flush();
	FrameSize GetOutputSize();
	AudioOutputFormatResult GetAudioOutputFormat();

	void OnMediaCodecError(bool is_recoverable,
	bool is_transient,
	const std::string& diagnostic_info);
	void OnMediaCodecInputBufferAvailable(int buffer_index);
	void OnMediaCodecOutputBufferAvailable(int buffer_index,
	int flags,
	int offset,
	int64_t presentation_time_us,
	int size);
	void OnMediaCodecOutputFormatChanged();
	void OnMediaCodecFrameRendered(int64_t frame_timestamp);

	private:
	// \|MediaCodecBridge\|s must only be created through its factory methods.
	explicit MediaCodecBridge(Handler* handler);
	void Initialize(jobject j_media_codec_bridge);

	Handler* handler_ = NULL;
	jobject j_media_codec_bridge_ = NULL;

	// Profiling and allocation tracking has identified this area to be hot,
	// and, capable of enough to cause GC times to raise high enough to impact
	// playback. We mitigate this by reusing these output objects between calls
	// to \|DequeueInputBuffer\|, \|DequeueOutputBuffer\|, and
	// \|GetOutputDimensions\|.
	jobject j_reused_get_output_format_result_ = NULL;

	MediaCodecBridge(const MediaCodecBridge&) = delete;
	void operator=(const MediaCodecBridge&) = delete;
	};

	} // namespace shared
	} // namespace android
	} // namespace starboard

	#endif // STARBOARD_ANDROID_SHARED_MEDIA_CODEC_BRIDGE_H_