1/* 2 * Copyright 2016, 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//#define LOG_NDEBUG 0 18#define LOG_TAG "OMXBuffer" 19 20#include <media/stagefright/foundation/ADebug.h> 21#include <media/MediaCodecBuffer.h> 22#include <media/OMXBuffer.h> 23#include <binder/IMemory.h> 24#include <binder/Parcel.h> 25#include <ui/GraphicBuffer.h> 26#include <utils/NativeHandle.h> 27 28namespace android { 29 30//static 31OMXBuffer OMXBuffer::sPreset(static_cast<sp<MediaCodecBuffer> >(NULL)); 32 33OMXBuffer::OMXBuffer() 34 : mBufferType(kBufferTypeInvalid) { 35} 36 37OMXBuffer::OMXBuffer(const sp<MediaCodecBuffer>& codecBuffer) 38 : mBufferType(kBufferTypePreset), 39 mRangeOffset(codecBuffer != NULL ? codecBuffer->offset() : 0), 40 mRangeLength(codecBuffer != NULL ? codecBuffer->size() : 0) { 41} 42 43OMXBuffer::OMXBuffer(OMX_U32 rangeOffset, OMX_U32 rangeLength) 44 : mBufferType(kBufferTypePreset), 45 mRangeOffset(rangeOffset), 46 mRangeLength(rangeLength) { 47} 48 49OMXBuffer::OMXBuffer(const sp<IMemory> &mem) 50 : mBufferType(kBufferTypeSharedMem), 51 mMem(mem) { 52} 53 54OMXBuffer::OMXBuffer(const sp<GraphicBuffer> &gbuf) 55 : mBufferType(kBufferTypeANWBuffer), 56 mGraphicBuffer(gbuf) { 57} 58 59OMXBuffer::OMXBuffer(const sp<NativeHandle> &handle) 60 : mBufferType(kBufferTypeNativeHandle), 61 mNativeHandle(handle) { 62} 63 64OMXBuffer::OMXBuffer(const hidl_memory &hidlMemory) 65 : mBufferType(kBufferTypeHidlMemory), 66 mHidlMemory(hidlMemory) { 67} 68 69OMXBuffer::~OMXBuffer() { 70} 71 72status_t OMXBuffer::writeToParcel(Parcel *parcel) const { 73 CHECK(mBufferType != kBufferTypeHidlMemory); 74 parcel->writeInt32(mBufferType); 75 76 switch(mBufferType) { 77 case kBufferTypePreset: 78 { 79 status_t err = parcel->writeUint32(mRangeOffset); 80 if (err != OK) { 81 return err; 82 } 83 return parcel->writeUint32(mRangeLength); 84 } 85 86 case kBufferTypeSharedMem: 87 { 88 return parcel->writeStrongBinder(IInterface::asBinder(mMem)); 89 } 90 91 case kBufferTypeANWBuffer: 92 { 93 if (mGraphicBuffer == NULL) { 94 return parcel->writeBool(false); 95 } 96 status_t err = parcel->writeBool(true); 97 if (err != OK) { 98 return err; 99 } 100 return parcel->write(*mGraphicBuffer); 101 } 102 103 case kBufferTypeNativeHandle: 104 { 105 return parcel->writeNativeHandle(mNativeHandle->handle()); 106 } 107 108 default: 109 return BAD_VALUE; 110 } 111 return BAD_VALUE; 112} 113 114status_t OMXBuffer::readFromParcel(const Parcel *parcel) { 115 BufferType bufferType = (BufferType) parcel->readInt32(); 116 CHECK(bufferType != kBufferTypeHidlMemory); 117 118 switch(bufferType) { 119 case kBufferTypePreset: 120 { 121 status_t err = parcel->readUint32(&mRangeOffset); 122 if (err != OK) { 123 return err; 124 } 125 err = parcel->readUint32(&mRangeLength); 126 if (err != OK) { 127 return err; 128 } 129 break; 130 } 131 132 case kBufferTypeSharedMem: 133 { 134 mMem = interface_cast<IMemory>(parcel->readStrongBinder()); 135 break; 136 } 137 138 case kBufferTypeANWBuffer: 139 { 140 bool notNull; 141 status_t err = parcel->readBool(¬Null); 142 if (err != OK) { 143 return err; 144 } 145 if (notNull) { 146 sp<GraphicBuffer> buffer = new GraphicBuffer(); 147 status_t err = parcel->read(*buffer); 148 if (err != OK) { 149 return err; 150 } 151 mGraphicBuffer = buffer; 152 } else { 153 mGraphicBuffer = nullptr; 154 } 155 break; 156 } 157 158 case kBufferTypeNativeHandle: 159 { 160 sp<NativeHandle> handle = NativeHandle::create( 161 parcel->readNativeHandle(), true /* ownsHandle */); 162 163 mNativeHandle = handle; 164 break; 165 } 166 167 default: 168 return BAD_VALUE; 169 } 170 171 mBufferType = bufferType; 172 return OK; 173} 174 175OMXBuffer& OMXBuffer::operator=(OMXBuffer&& source) { 176 mBufferType = std::move(source.mBufferType); 177 mRangeOffset = std::move(source.mRangeOffset); 178 mRangeLength = std::move(source.mRangeLength); 179 mMem = std::move(source.mMem); 180 mGraphicBuffer = std::move(source.mGraphicBuffer); 181 mNativeHandle = std::move(source.mNativeHandle); 182 mHidlMemory = std::move(source.mHidlMemory); 183 return *this; 184} 185 186} // namespace android 187 188 189 190 191