1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef MEDIA_BASE_ANDROID_MEDIA_CODEC_BRIDGE_H_ 6 #define MEDIA_BASE_ANDROID_MEDIA_CODEC_BRIDGE_H_ 7 8 #include <jni.h> 9 #include <string> 10 11 #include "base/android/scoped_java_ref.h" 12 #include "base/time/time.h" 13 #include "media/base/audio_decoder_config.h" 14 #include "media/base/video_decoder_config.h" 15 #include "ui/gfx/size.h" 16 17 namespace media { 18 19 struct SubsampleEntry; 20 21 // These must be in sync with MediaCodecBridge.MEDIA_CODEC_XXX constants in 22 // MediaCodecBridge.java. 23 enum MediaCodecStatus { 24 MEDIA_CODEC_OK, 25 MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER, 26 MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER, 27 MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED, 28 MEDIA_CODEC_OUTPUT_FORMAT_CHANGED, 29 MEDIA_CODEC_INPUT_END_OF_STREAM, 30 MEDIA_CODEC_OUTPUT_END_OF_STREAM, 31 MEDIA_CODEC_NO_KEY, 32 MEDIA_CODEC_STOPPED, 33 MEDIA_CODEC_ERROR 34 }; 35 36 // Codec direction. Keep this in sync with MediaCodecBridge.java. 37 enum MediaCodecDirection { 38 MEDIA_CODEC_DECODER, 39 MEDIA_CODEC_ENCODER, 40 }; 41 42 // This class serves as a bridge for native code to call java functions inside 43 // Android MediaCodec class. For more information on Android MediaCodec, check 44 // http://developer.android.com/reference/android/media/MediaCodec.html 45 // Note: MediaCodec is only available on JB and greater. 46 // Use AudioCodecBridge or VideoCodecBridge to create an instance of this 47 // object. 48 // 49 // TODO(fischman,xhwang): replace this (and the enums that go with it) with 50 // chromium's JNI auto-generation hotness. 51 class MEDIA_EXPORT MediaCodecBridge { 52 public: 53 // Returns true if MediaCodec is available on the device. 54 // All other static methods check IsAvailable() internally. There's no need 55 // to check IsAvailable() explicitly before calling them. 56 static bool IsAvailable(); 57 58 // Returns true if MediaCodec.setParameters() is available on the device. 59 static bool SupportsSetParameters(); 60 61 // Returns whether MediaCodecBridge has a decoder that |is_secure| and can 62 // decode |codec| type. 63 static bool CanDecode(const std::string& codec, bool is_secure); 64 65 // Represents supported codecs on android. 66 // TODO(qinmin): Currently the codecs string only contains one codec. Do we 67 // need to support codecs separated by comma. (e.g. "vp8" -> "vp8, vp8.0")? 68 struct CodecsInfo { 69 std::string codecs; // E.g. "vp8" or "avc1". 70 std::string name; // E.g. "OMX.google.vp8.decoder". 71 MediaCodecDirection direction; 72 }; 73 74 // Get a list of supported codecs. 75 static std::vector<CodecsInfo> GetCodecsInfo(); 76 77 virtual ~MediaCodecBridge(); 78 79 // Resets both input and output, all indices previously returned in calls to 80 // DequeueInputBuffer() and DequeueOutputBuffer() become invalid. 81 // Please note that this clears all the inputs in the media codec. In other 82 // words, there will be no outputs until new input is provided. 83 // Returns MEDIA_CODEC_ERROR if an unexpected error happens, or Media_CODEC_OK 84 // otherwise. 85 MediaCodecStatus Reset(); 86 87 // Finishes the decode/encode session. The instance remains active 88 // and ready to be StartAudio/Video()ed again. HOWEVER, due to the buggy 89 // vendor's implementation , b/8125974, Stop() -> StartAudio/Video() may not 90 // work on some devices. For reliability, Stop() -> delete and recreate new 91 // instance -> StartAudio/Video() is recommended. 92 void Stop(); 93 94 // Used for getting output format. This is valid after DequeueInputBuffer() 95 // returns a format change by returning INFO_OUTPUT_FORMAT_CHANGED 96 void GetOutputFormat(int* width, int* height); 97 98 // Returns the number of input buffers used by the codec. 99 int GetInputBuffersCount(); 100 101 // Submits a byte array to the given input buffer. Call this after getting an 102 // available buffer from DequeueInputBuffer(). If |data| is NULL, assume the 103 // input buffer has already been populated (but still obey |size|). 104 // |data_size| must be less than kint32max (because Java). 105 MediaCodecStatus QueueInputBuffer(int index, 106 const uint8* data, 107 size_t data_size, 108 const base::TimeDelta& presentation_time); 109 110 // Similar to the above call, but submits a buffer that is encrypted. Note: 111 // NULL |subsamples| indicates the whole buffer is encrypted. If |data| is 112 // NULL, assume the input buffer has already been populated (but still obey 113 // |data_size|). |data_size| must be less than kint32max (because Java). 114 MediaCodecStatus QueueSecureInputBuffer( 115 int index, 116 const uint8* data, 117 size_t data_size, 118 const uint8* key_id, 119 int key_id_size, 120 const uint8* iv, 121 int iv_size, 122 const SubsampleEntry* subsamples, 123 int subsamples_size, 124 const base::TimeDelta& presentation_time); 125 126 // Submits an empty buffer with a EOS (END OF STREAM) flag. 127 void QueueEOS(int input_buffer_index); 128 129 // Returns: 130 // MEDIA_CODEC_OK if an input buffer is ready to be filled with valid data, 131 // MEDIA_CODEC_ENQUEUE_INPUT_AGAIN_LATER if no such buffer is available, or 132 // MEDIA_CODEC_ERROR if unexpected error happens. 133 // Note: Never use infinite timeout as this would block the decoder thread and 134 // prevent the decoder job from being released. 135 MediaCodecStatus DequeueInputBuffer(const base::TimeDelta& timeout, 136 int* index); 137 138 // Dequeues an output buffer, block at most timeout_us microseconds. 139 // Returns the status of this operation. If OK is returned, the output 140 // parameters should be populated. Otherwise, the values of output parameters 141 // should not be used. Output parameters other than index/offset/size are 142 // optional and only set if not NULL. 143 // Note: Never use infinite timeout as this would block the decoder thread and 144 // prevent the decoder job from being released. 145 // TODO(xhwang): Can we drop |end_of_stream| and return 146 // MEDIA_CODEC_OUTPUT_END_OF_STREAM? 147 MediaCodecStatus DequeueOutputBuffer(const base::TimeDelta& timeout, 148 int* index, 149 size_t* offset, 150 size_t* size, 151 base::TimeDelta* presentation_time, 152 bool* end_of_stream, 153 bool* key_frame); 154 155 // Returns the buffer to the codec. If you previously specified a surface when 156 // configuring this video decoder you can optionally render the buffer. 157 void ReleaseOutputBuffer(int index, bool render); 158 159 // Returns the number of output buffers used by the codec. 160 int GetOutputBuffersCount(); 161 162 // Returns the capacity of each output buffer used by the codec. 163 size_t GetOutputBuffersCapacity(); 164 165 // Gets output buffers from media codec and keeps them inside the java class. 166 // To access them, use DequeueOutputBuffer(). Returns whether output buffers 167 // were successfully obtained. 168 bool GetOutputBuffers() WARN_UNUSED_RESULT; 169 170 // Returns an input buffer's base pointer and capacity. 171 void GetInputBuffer(int input_buffer_index, uint8** data, size_t* capacity); 172 173 // Copy |dst_size| bytes from output buffer |index|'s |offset| onwards into 174 // |*dst|. 175 bool CopyFromOutputBuffer(int index, size_t offset, void* dst, int dst_size); 176 177 static bool RegisterMediaCodecBridge(JNIEnv* env); 178 179 protected: 180 // Returns true if |mime_type| is known to be unaccelerated (i.e. backed by a 181 // software codec instead of a hardware one). 182 static bool IsKnownUnaccelerated(const std::string& mime_type, 183 MediaCodecDirection direction); 184 185 MediaCodecBridge(const std::string& mime, 186 bool is_secure, 187 MediaCodecDirection direction); 188 189 // Calls start() against the media codec instance. Used in StartXXX() after 190 // configuring media codec. Returns whether media codec was successfully 191 // started. 192 bool StartInternal() WARN_UNUSED_RESULT; 193 194 jobject media_codec() { return j_media_codec_.obj(); } 195 MediaCodecDirection direction_; 196 197 private: 198 // Fills a particular input buffer; returns false if |data_size| exceeds the 199 // input buffer's capacity (and doesn't touch the input buffer in that case). 200 bool FillInputBuffer(int index, 201 const uint8* data, 202 size_t data_size) WARN_UNUSED_RESULT; 203 204 // Java MediaCodec instance. 205 base::android::ScopedJavaGlobalRef<jobject> j_media_codec_; 206 207 DISALLOW_COPY_AND_ASSIGN(MediaCodecBridge); 208 }; 209 210 class AudioCodecBridge : public MediaCodecBridge { 211 public: 212 // Returns an AudioCodecBridge instance if |codec| is supported, or a NULL 213 // pointer otherwise. 214 static AudioCodecBridge* Create(const AudioCodec& codec); 215 216 // See MediaCodecBridge::IsKnownUnaccelerated(). 217 static bool IsKnownUnaccelerated(const AudioCodec& codec); 218 219 // Start the audio codec bridge. 220 bool Start(const AudioCodec& codec, int sample_rate, int channel_count, 221 const uint8* extra_data, size_t extra_data_size, 222 bool play_audio, jobject media_crypto) WARN_UNUSED_RESULT; 223 224 // Play the output buffer. This call must be called after 225 // DequeueOutputBuffer() and before ReleaseOutputBuffer. Returns the playback 226 // head position expressed in frames. 227 int64 PlayOutputBuffer(int index, size_t size); 228 229 // Set the volume of the audio output. 230 void SetVolume(double volume); 231 232 private: 233 explicit AudioCodecBridge(const std::string& mime); 234 235 // Configure the java MediaFormat object with the extra codec data passed in. 236 bool ConfigureMediaFormat(jobject j_format, const AudioCodec& codec, 237 const uint8* extra_data, size_t extra_data_size); 238 }; 239 240 class MEDIA_EXPORT VideoCodecBridge : public MediaCodecBridge { 241 public: 242 // See MediaCodecBridge::IsKnownUnaccelerated(). 243 static bool IsKnownUnaccelerated(const VideoCodec& codec, 244 MediaCodecDirection direction); 245 246 // Create, start, and return a VideoCodecBridge decoder or NULL on failure. 247 static VideoCodecBridge* CreateDecoder( 248 const VideoCodec& codec, // e.g. media::kCodecVP8 249 bool is_secure, 250 const gfx::Size& size, // Output frame size. 251 jobject surface, // Output surface, optional. 252 jobject media_crypto); // MediaCrypto object, optional. 253 254 // Create, start, and return a VideoCodecBridge encoder or NULL on failure. 255 static VideoCodecBridge* CreateEncoder( 256 const VideoCodec& codec, // e.g. media::kCodecVP8 257 const gfx::Size& size, // input frame size 258 int bit_rate, // bits/second 259 int frame_rate, // frames/second 260 int i_frame_interval, // count 261 int color_format); // MediaCodecInfo.CodecCapabilities. 262 263 void SetVideoBitrate(int bps); 264 void RequestKeyFrameSoon(); 265 266 // Returns whether adaptive playback is supported for this object given 267 // the new size. 268 bool IsAdaptivePlaybackSupported(int width, int height); 269 270 // Test-only method to set the return value of IsAdaptivePlaybackSupported(). 271 // Without this function, the return value of that function will be device 272 // dependent. If |adaptive_playback_supported| is equal to 0, the return value 273 // will be false. If |adaptive_playback_supported| is larger than 0, the 274 // return value will be true. 275 void set_adaptive_playback_supported_for_testing( 276 int adaptive_playback_supported) { 277 adaptive_playback_supported_for_testing_ = adaptive_playback_supported; 278 } 279 280 private: 281 VideoCodecBridge(const std::string& mime, 282 bool is_secure, 283 MediaCodecDirection direction); 284 285 int adaptive_playback_supported_for_testing_; 286 }; 287 288 } // namespace media 289 290 #endif // MEDIA_BASE_ANDROID_MEDIA_CODEC_BRIDGE_H_ 291
