1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.example.android.common.media; 18 19 import android.media.*; 20 import android.os.Handler; 21 import android.os.Looper; 22 import android.view.Surface; 23 24 import java.nio.ByteBuffer; 25 import java.util.ArrayDeque; 26 import java.util.Queue; 27 28 /** 29 * Simplifies the MediaCodec interface by wrapping around the buffer processing operations. 30 */ 31 public class MediaCodecWrapper { 32 33 // Handler to use for {@code OutputSampleListener} and {code OutputFormatChangedListener} 34 // callbacks 35 private Handler mHandler; 36 37 38 // Callback when media output format changes. 39 public interface OutputFormatChangedListener { 40 void outputFormatChanged(MediaCodecWrapper sender, MediaFormat newFormat); 41 } 42 43 private OutputFormatChangedListener mOutputFormatChangedListener = null; 44 45 /** 46 * Callback for decodes frames. Observers can register a listener for optional stream 47 * of decoded data 48 */ 49 public interface OutputSampleListener { 50 void outputSample(MediaCodecWrapper sende r, MediaCodec.BufferInfo info, ByteBuffer buffer); 51 } 52 53 /** 54 * The {@link MediaCodec} that is managed by this class. 55 */ 56 private MediaCodec mDecoder; 57 58 // References to the internal buffers managed by the codec. The codec 59 // refers to these buffers by index, never by reference so it's up to us 60 // to keep track of which buffer is which. 61 private ByteBuffer[] mInputBuffers; 62 private ByteBuffer[] mOutputBuffers; 63 64 // Indices of the input buffers that are currently available for writing. We'll 65 // consume these in the order they were dequeued from the codec. 66 private Queue<Integer> mAvailableInputBuffers; 67 68 // Indices of the output buffers that currently hold valid data, in the order 69 // they were produced by the codec. 70 private Queue<Integer> mAvailableOutputBuffers; 71 72 // Information about each output buffer, by index. Each entry in this array 73 // is valid if and only if its index is currently contained in mAvailableOutputBuffers. 74 private MediaCodec.BufferInfo[] mOutputBufferInfo; 75 76 // An (optional) stream that will receive decoded data. 77 private OutputSampleListener mOutputSampleListener; 78 79 private MediaCodecWrapper(MediaCodec codec) { 80 mDecoder = codec; 81 codec.start(); 82 mInputBuffers = codec.getInputBuffers(); 83 mOutputBuffers = codec.getOutputBuffers(); 84 mOutputBufferInfo = new MediaCodec.BufferInfo[mOutputBuffers.length]; 85 mAvailableInputBuffers = new ArrayDeque<Integer>(mOutputBuffers.length); 86 mAvailableOutputBuffers = new ArrayDeque<Integer>(mInputBuffers.length); 87 } 88 89 /** 90 * Releases resources and ends the encoding/decoding session. 91 */ 92 public void stopAndRelease() { 93 mDecoder.stop(); 94 mDecoder.release(); 95 mDecoder = null; 96 mHandler = null; 97 } 98 99 /** 100 * Getter for the registered {@link OutputFormatChangedListener} 101 */ 102 public OutputFormatChangedListener getOutputFormatChangedListener() { 103 return mOutputFormatChangedListener; 104 } 105 106 /** 107 * 108 * @param outputFormatChangedListener the listener for callback. 109 * @param handler message handler for posting the callback. 110 */ 111 public void setOutputFormatChangedListener(final OutputFormatChangedListener 112 outputFormatChangedListener, Handler handler) { 113 mOutputFormatChangedListener = outputFormatChangedListener; 114 115 // Making sure we don't block ourselves due to a bad implementation of the callback by 116 // using a handler provided by client. 117 Looper looper; 118 mHandler = handler; 119 if (outputFormatChangedListener != null && mHandler == null) { 120 if ((looper = Looper.myLooper()) != null) { 121 mHandler = new Handler(); 122 } else { 123 throw new IllegalArgumentException( 124 "Looper doesn't exist in the calling thread"); 125 } 126 } 127 } 128 129 /** 130 * Constructs the {@link MediaCodecWrapper} wrapper object around the video codec. 131 * The codec is created using the encapsulated information in the 132 * {@link MediaFormat} object. 133 * 134 * @param trackFormat The format of the media object to be decoded. 135 * @param surface Surface to render the decoded frames. 136 * @return 137 */ 138 public static MediaCodecWrapper fromVideoFormat(final MediaFormat trackFormat, 139 Surface surface) { 140 MediaCodecWrapper result = null; 141 MediaCodec videoCodec = null; 142 144 final String mimeType = trackFormat.getString(MediaFormat.KEY_MIME); 145 146 // Check to see if this is actually a video mime type. If it is, then create 147 // a codec that can decode this mime type. 148 if (mimeType.contains("video/")) { 149 videoCodec = MediaCodec.createDecoderByType(mimeType); 150 videoCodec.configure(trackFormat, surface, null, 0); 151 152 } 153 154 // If codec creation was successful, then create a wrapper object around the 155 // newly created codec. 156 if (videoCodec != null) { 157 result = new MediaCodecWrapper(videoCodec); 158 } 160 161 return result; 162 } 163 164 165 /** 166 * Write a media sample to the decoder. 167 * 168 * A "sample" here refers to a single atomic access unit in the media stream. The definition 169 * of "access unit" is dependent on the type of encoding used, but it typically refers to 170 * a single frame of video or a few seconds of audio. {@link android.media.MediaExtractor} 171 * extracts data from a stream one sample at a time. 172 * 173 * @param input A ByteBuffer containing the input data for one sample. The buffer must be set 174 * up for reading, with its position set to the beginning of the sample data and its limit 175 * set to the end of the sample data. 176 * 177 * @param presentationTimeUs The time, relative to the beginning of the media stream, 178 * at which this buffer should be rendered. 179 * 180 * @param flags Flags to pass to the decoder. See {@link MediaCodec#queueInputBuffer(int, 181 * int, int, long, int)} 182 * 183 * @throws MediaCodec.CryptoException 184 */ 185 public boolean writeSample(final ByteBuffer input, 186 final MediaCodec.CryptoInfo crypto, 187 final long presentationTimeUs, 188 final int flags) throws MediaCodec.CryptoException, WriteException { 189 boolean result = false; 190 int size = input.remaining(); 191 192 // check if we have dequed input buffers available from the codec 193 if (size > 0 && !mAvailableInputBuffers.isEmpty()) { 194 int index = mAvailableInputBuffers.remove(); 195 ByteBuffer buffer = mInputBuffers[index]; 196 197 // we can't write our sample to a lesser capacity input buffer. 198 if (size > buffer.capacity()) { 199 throw new MediaCodecWrapper.WriteException(String.format( 200 "Insufficient capacity in MediaCodec buffer: " 201 + "tried to write %d, buffer capacity is %d.", 202 input.remaining(), 203 buffer.capacity())); 204 } 205 206 buffer.clear(); 207 buffer.put(input); 208 209 // Submit the buffer to the codec for decoding. The presentationTimeUs 210 // indicates the position (play time) for the current sample. 211 if (crypto == null) { 212 mDecoder.queueInputBuffer(index, 0, size, presentationTimeUs, flags); 213 } else { 214 mDecoder.queueSecureInputBuffer(index, 0, crypto, presentationTimeUs, flags); 215 } 216 result = true; 217 } 218 return result; 219 } 220 221 static MediaCodec.CryptoInfo cryptoInfo= new MediaCodec.CryptoInfo(); 222 223 /** 224 * Write a media sample to the decoder. 225 * 226 * A "sample" here refers to a single atomic access unit in the media stream. The definition 227 * of "access unit" is dependent on the type of encoding used, but it typically refers to 228 * a single frame of video or a few seconds of audio. {@link android.media.MediaExtractor} 229 * extracts data from a stream one sample at a time. 230 * 231 * @param extractor Instance of {@link android.media.MediaExtractor} wrapping the media. 232 * 233 * @param presentationTimeUs The time, relative to the beginning of the media stream, 234 * at which this buffer should be rendered. 235 * 236 * @param flags Flags to pass to the decoder. See {@link MediaCodec#queueInputBuffer(int, 237 * int, int, long, int)} 238 * 239 * @throws MediaCodec.CryptoException 240 */ 241 public boolean writeSample(final MediaExtractor extractor, 242 final boolean isSecure, 243 final long presentationTimeUs, 244 int flags) { 245 boolean result = false; 246 boolean isEos = false; 247 248 if (!mAvailableInputBuffers.isEmpty()) { 249 int index = mAvailableInputBuffers.remove(); 250 ByteBuffer buffer = mInputBuffers[index]; 251 252 // reads the sample from the file using extractor into the buffer 253 int size = extractor.readSampleData(buffer, 0); 254 if (size <= 0) { 255 flags |= MediaCodec.BUFFER_FLAG_END_OF_STREAM; 256 } 257 258 // Submit the buffer to the codec for decoding. The presentationTimeUs 259 // indicates the position (play time) for the current sample. 260 if (!isSecure) { 261 mDecoder.queueInputBuffer(index, 0, size, presentationTimeUs, flags); 262 } else { 263 extractor.getSampleCryptoInfo(cryptoInfo); 264 mDecoder.queueSecureInputBuffer(index, 0, cryptoInfo, presentationTimeUs, flags); 265 } 266 267 result = true; 268 } 269 return result; 270 } 271 272 /** 273 * Performs a peek() operation in the queue to extract media info for the buffer ready to be 274 * released i.e. the head element of the queue. 275 * 276 * @param out_bufferInfo An output var to hold the buffer info. 277 * 278 * @return True, if the peek was successful. 279 */ 280 public boolean peekSample(MediaCodec.BufferInfo out_bufferInfo) { 281 // dequeue available buffers and synchronize our data structures with the codec. 282 update(); 283 boolean result = false; 284 if (!mAvailableOutputBuffers.isEmpty()) { 285 int index = mAvailableOutputBuffers.peek(); 286 MediaCodec.BufferInfo info = mOutputBufferInfo[index]; 287 // metadata of the sample 288 out_bufferInfo.set( 289 info.offset, 290 info.size, 291 info.presentationTimeUs, 292 info.flags); 293 result = true; 294 } 295 return result; 296 } 297 298 /** 299 * Processes, releases and optionally renders the output buffer available at the head of the 300 * queue. All observers are notified with a callback. See {@link 301 * OutputSampleListener#outputSample(MediaCodecWrapper, android.media.MediaCodec.BufferInfo, 302 * java.nio.ByteBuffer)} 303 * 304 * @param render True, if the buffer is to be rendered on the {@link Surface} configured 305 * 306 */ 307 public void popSample(boolean render) { 308 // dequeue available buffers and synchronize our data structures with the codec. 309 update(); 310 if (!mAvailableOutputBuffers.isEmpty()) { 311 int index = mAvailableOutputBuffers.remove(); 312 313 if (render && mOutputSampleListener != null) { 314 ByteBuffer buffer = mOutputBuffers[index]; 315 MediaCodec.BufferInfo info = mOutputBufferInfo[index]; 316 mOutputSampleListener.outputSample(this, info, buffer); 317 } 318 319 // releases the buffer back to the codec 320 mDecoder.releaseOutputBuffer(index, render); 321 } 322 } 323 324 /** 325 * Synchronize this object's state with the internal state of the wrapped 326 * MediaCodec. 327 */ 328 private void update() { 330 int index; 331 332 // Get valid input buffers from the codec to fill later in the same order they were 333 // made available by the codec. 334 while ((index = mDecoder.dequeueInputBuffer(0)) != MediaCodec.INFO_TRY_AGAIN_LATER) { 335 mAvailableInputBuffers.add(index); 336 } 337 338 339 // Likewise with output buffers. If the output buffers have changed, start using the 340 // new set of output buffers. If the output format has changed, notify listeners. 341 MediaCodec.BufferInfo info = new MediaCodec.BufferInfo(); 342 while ((index = mDecoder.dequeueOutputBuffer(info, 0)) != MediaCodec.INFO_TRY_AGAIN_LATER) { 343 switch (index) { 344 case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED: 345 mOutputBuffers = mDecoder.getOutputBuffers(); 346 mOutputBufferInfo = new MediaCodec.BufferInfo[mOutputBuffers.length]; 347 mAvailableOutputBuffers.clear(); 348 break; 349 case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED: 350 if (mOutputFormatChangedListener != null) { 351 mHandler.post(new Runnable() { 352 @Override 353 public void run() { 354 mOutputFormatChangedListener 355 .outputFormatChanged(MediaCodecWrapper.this, 356 mDecoder.getOutputFormat()); 357 358 } 359 }); 360 } 361 break; 362 default: 363 // Making sure the index is valid before adding to output buffers. We've already 364 // handled INFO_TRY_AGAIN_LATER, INFO_OUTPUT_FORMAT_CHANGED & 365 // INFO_OUTPUT_BUFFERS_CHANGED i.e all the other possible return codes but 366 // asserting index value anyways for future-proofing the code. 367 if(index >= 0) { 368 mOutputBufferInfo[index] = info; 369 mAvailableOutputBuffers.add(index); 370 } else { 371 throw new IllegalStateException("Unknown status from dequeueOutputBuffer"); 372 } 373 break; 374 } 375 376 } 378 379 } 380 381 private class WriteException extends Throwable { 382 private WriteException(final String detailMessage) { 383 super(detailMessage); 384 } 385 } 386 }