Home | History | Annotate | Download | only in videoencoder
      1 /*
      2 * Copyright (c) 2009-2011 Intel Corporation.  All rights reserved.
      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 "IntelMetadataBuffer"
     19 #include <wrs_omxil_core/log.h>
     20 
     21 #include "IntelMetadataBuffer.h"
     22 #include <string.h>
     23 #include <stdio.h>
     24 
     25 #ifdef INTEL_VIDEO_XPROC_SHARING
     26 #include <binder/IServiceManager.h>
     27 #include <binder/MemoryBase.h>
     28 #include <binder/Parcel.h>
     29 #include <utils/List.h>
     30 #include <utils/threads.h>
     31 #include <ui/GraphicBuffer.h>
     32 
     33 //#define TEST
     34 
     35 struct ShareMemMap {
     36     uint32_t sessionflag;
     37     intptr_t value;
     38     intptr_t value_backup;
     39     uint32_t type;
     40     sp<MemoryBase> membase;
     41     sp<GraphicBuffer> gbuffer;
     42 };
     43 
     44 List <ShareMemMap *> gShareMemMapList;
     45 Mutex gShareMemMapListLock;
     46 
     47 enum {
     48     SHARE_MEM = IBinder::FIRST_CALL_TRANSACTION,
     49     GET_MEM,
     50     CLEAR_MEM,
     51 };
     52 
     53 enum {
     54     ST_MEMBASE = 0,
     55     ST_GFX,
     56     ST_MAX,
     57 };
     58 
     59 #define REMOTE_PROVIDER 0x80000000
     60 #define REMOTE_CONSUMER 0x40000000
     61 
     62 static ShareMemMap* ReadMemObjFromBinder(const Parcel& data, uint32_t sessionflag, intptr_t value) {
     63 
     64     uint32_t type = data.readInt32();
     65     if (type >= ST_MAX)
     66         return NULL;
     67 
     68     ShareMemMap* map = new ShareMemMap;
     69     map->sessionflag = sessionflag;
     70     map->type = type;
     71     map->value_backup = value;
     72     map->membase = NULL;
     73     map->gbuffer= NULL;
     74 
     75 //    LOGI("ReadMemObjFromBinder");
     76 
     77     if (type == ST_MEMBASE) /*offset, size, heap*/
     78     {
     79         ssize_t offset = data.readInt32();
     80         size_t size = data.readInt32();
     81 
     82         sp<IMemoryHeap> heap = interface_cast<IMemoryHeap>(data.readStrongBinder());
     83 
     84         sp<MemoryBase> mem = new MemoryBase(heap, offset, size);
     85         if (mem == NULL)
     86         {
     87             delete map;
     88             return NULL;
     89         }
     90 
     91         map->value = (intptr_t)( mem->pointer() + 0x0FFF) & ~0x0FFF;
     92         map->membase = mem;
     93 
     94 #ifdef TEST
     95         ALOGI("membase heapID:%d, pointer:%x data:%x, aligned value:%x", \
     96            heap->getHeapID(), mem->pointer(), *((intptr_t *)(mem->pointer())), map->value);
     97 #endif
     98 
     99     }
    100     else if (type == ST_GFX) /*graphicbuffer*/
    101     {
    102         sp<GraphicBuffer> buffer = new GraphicBuffer();
    103         if (buffer == NULL)
    104         {
    105             delete map;
    106             return NULL;
    107         }
    108         data.read(*buffer);
    109 
    110         map->value = (intptr_t)buffer->handle;
    111         map->gbuffer = buffer;
    112 
    113 #ifdef TEST
    114         void* usrptr[3];
    115         buffer->lock(GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_SW_READ_OFTEN, &usrptr[0]);
    116         buffer->unlock();
    117         ALOGI("gfx handle:%p data:%x", (intptr_t)buffer->handle, *((intptr_t *)usrptr[0]));
    118 #endif
    119     }
    120 
    121     gShareMemMapListLock.lock();
    122     gShareMemMapList.push_back(map);
    123     gShareMemMapListLock.unlock();
    124     return map;
    125 }
    126 
    127 static status_t WriteMemObjToBinder(Parcel& data, ShareMemMap* smem) {
    128 
    129     if (smem->type >= ST_MAX)
    130         return BAD_VALUE;
    131 
    132 //    LOGI("WriteMemObjToBinder");
    133 
    134     data.writeInt32(smem->type);
    135 
    136     if (smem->type == ST_MEMBASE) /*offset, size, heap*/
    137     {
    138         ssize_t offset;
    139         size_t size;
    140         sp<IMemoryHeap> heap = smem->membase->getMemory(&offset, &size);
    141         data.writeInt32(offset);
    142         data.writeInt32(size);
    143         data.writeStrongBinder(heap->asBinder());
    144 #ifdef TEST
    145         ALOGI("membase heapID:%d pointer:%x data:%x", \
    146             heap->getHeapID(), smem->membase->pointer(), *((int *)(smem->membase->pointer())));
    147 #endif
    148     }
    149     else if (smem->type == ST_GFX) /*graphicbuffer*/
    150         data.write(*(smem->gbuffer));
    151 
    152     return NO_ERROR;
    153 }
    154 
    155 static void ClearLocalMem(uint32_t sessionflag)
    156 {
    157     List<ShareMemMap *>::iterator node;
    158 
    159     gShareMemMapListLock.lock();
    160 
    161     for(node = gShareMemMapList.begin(); node != gShareMemMapList.end(); )
    162     {
    163         if ((*node)->sessionflag == sessionflag) //remove all buffers belong to this session
    164         {
    165             (*node)->membase = NULL;
    166             (*node)->gbuffer = NULL;
    167             delete (*node);
    168             node = gShareMemMapList.erase(node);
    169         }
    170         else
    171             node ++;
    172     }
    173 
    174     gShareMemMapListLock.unlock();
    175 }
    176 
    177 static ShareMemMap* FindShareMem(uint32_t sessionflag, intptr_t value, bool isBackup)
    178 {
    179     List<ShareMemMap *>::iterator node;
    180 
    181     gShareMemMapListLock.lock();
    182     for(node = gShareMemMapList.begin(); node !=  gShareMemMapList.end(); node++)
    183     {
    184         if (isBackup)
    185         {
    186             if ((*node)->sessionflag == sessionflag && (*node)->value_backup == value)
    187             {
    188                 gShareMemMapListLock.unlock();
    189                 return (*node);
    190             }
    191         }
    192         else if ((*node)->sessionflag == sessionflag && (*node)->value == value)
    193         {
    194             gShareMemMapListLock.unlock();
    195             return (*node);
    196         }
    197     }
    198     gShareMemMapListLock.unlock();
    199 
    200     return NULL;
    201 }
    202 
    203 static ShareMemMap* PopShareMem(uint32_t sessionflag, intptr_t value)
    204 {
    205     List<ShareMemMap *>::iterator node;
    206 
    207     gShareMemMapListLock.lock();
    208     for(node = gShareMemMapList.begin(); node != gShareMemMapList.end(); node++)
    209     {
    210         if ((*node)->sessionflag == sessionflag && (*node)->value == value)
    211         {
    212             gShareMemMapList.erase(node);
    213             gShareMemMapListLock.unlock();
    214             return (*node);
    215         }
    216     }
    217     gShareMemMapListLock.unlock();
    218 
    219     return NULL;
    220 }
    221 
    222 static void PushShareMem(ShareMemMap* &smem)
    223 {
    224     gShareMemMapListLock.lock();
    225     gShareMemMapList.push_back(smem);
    226     gShareMemMapListLock.unlock();
    227 }
    228 
    229 static sp<IBinder> GetIntelBufferSharingService() {
    230 
    231     sp<IServiceManager> sm = defaultServiceManager();
    232     sp<IBinder> binder = sm->checkService(String16("media.IntelBufferSharing"));
    233 
    234     if (binder == 0)
    235         ALOGE("media.IntelBufferSharing service is not published");
    236 
    237     return binder;
    238 }
    239 
    240 IntelBufferSharingService* IntelBufferSharingService::gBufferService = NULL;
    241 
    242 status_t IntelBufferSharingService::instantiate(){
    243     status_t ret = NO_ERROR;
    244 
    245     if (gBufferService == NULL) {
    246         gBufferService = new IntelBufferSharingService();
    247         ret = defaultServiceManager()->addService(String16("media.IntelBufferSharing"), gBufferService);
    248         LOGI("IntelBufferSharingService::instantiate() ret = %d\n", ret);
    249     }
    250 
    251     return ret;
    252 }
    253 
    254 status_t IntelBufferSharingService::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
    255 
    256     //TODO: if pid is int32?
    257     pid_t pid = data.readInt32();
    258     uint32_t sessionflag = data.readInt32();
    259 
    260     switch(code)
    261     {
    262         case SHARE_MEM:
    263         {
    264 
    265             if (pid == getpid()) //in same process, should not use binder
    266             {
    267                 ALOGE("onTransact in same process, wrong sessionflag?");
    268                 return UNKNOWN_ERROR;
    269             }
    270 
    271             intptr_t value = data.readIntPtr();
    272 
    273 //            LOGI("onTransact SHARE_MEM value=%x", value);
    274 
    275             //different process
    276             ShareMemMap* map = ReadMemObjFromBinder(data, sessionflag, value);
    277             if (map == NULL)
    278                 return UNKNOWN_ERROR;
    279 
    280             reply->writeIntPtr(map->value);
    281 
    282             return NO_ERROR;
    283         }
    284         case CLEAR_MEM:
    285         {
    286 //            LOGI("onTransact CLEAR_MEM sessionflag=%x", sessionflag);
    287 
    288             if (pid == getpid()) //in same process, should not use binder
    289             {
    290                 //same process, return same pointer in data
    291                 ALOGE("onTransact CLEAR_MEM in same process, wrong sessionflag?");
    292                 return UNKNOWN_ERROR;
    293             }
    294 
    295             ClearLocalMem(sessionflag);
    296             return NO_ERROR;
    297         }
    298         case GET_MEM:
    299         {
    300 
    301             if (pid == getpid()) //in same process, should not use binder
    302             {
    303                 ALOGE("onTransact GET_MEM in same process, wrong sessionflag?");
    304                 return UNKNOWN_ERROR;
    305             }
    306 
    307             intptr_t value = data.readIntPtr();
    308 
    309 //            LOGI("onTransact GET_MEM value=%x", value);
    310 
    311             ShareMemMap* smem = FindShareMem(sessionflag, value, false);
    312             if (smem && (NO_ERROR == WriteMemObjToBinder(*reply, smem)))
    313                 return NO_ERROR;
    314             else
    315                 ALOGE("onTransact GET_MEM: Not find mem");
    316 
    317             return UNKNOWN_ERROR;
    318         }
    319         default:
    320             return BBinder::onTransact(code, data, reply, flags);
    321 
    322     }
    323     return NO_ERROR;
    324 }
    325 #endif
    326 
    327 IntelMetadataBuffer::IntelMetadataBuffer()
    328 {
    329     mType = IntelMetadataBufferTypeCameraSource;
    330     mValue = 0;
    331     mInfo = NULL;
    332     mExtraValues = NULL;
    333     mExtraValues_Count = 0;
    334     mBytes = NULL;
    335     mSize = 0;
    336 #ifdef INTEL_VIDEO_XPROC_SHARING
    337     mSessionFlag = 0;
    338 #endif
    339 }
    340 
    341 IntelMetadataBuffer::IntelMetadataBuffer(IntelMetadataBufferType type, intptr_t value)
    342 {
    343     mType = type;
    344     mValue = value;
    345     mInfo = NULL;
    346     mExtraValues = NULL;
    347     mExtraValues_Count = 0;
    348     mBytes = NULL;
    349     mSize = 0;
    350 #ifdef INTEL_VIDEO_XPROC_SHARING
    351     mSessionFlag = 0;
    352 #endif
    353 }
    354 
    355 IntelMetadataBuffer::~IntelMetadataBuffer()
    356 {
    357     if (mInfo)
    358         delete mInfo;
    359 
    360     if (mExtraValues)
    361         delete[] mExtraValues;
    362 
    363     if (mBytes)
    364         delete[] mBytes;
    365 }
    366 
    367 
    368 IntelMetadataBuffer::IntelMetadataBuffer(const IntelMetadataBuffer& imb)
    369      :mType(imb.mType), mValue(imb.mValue), mInfo(NULL), mExtraValues(NULL),
    370       mExtraValues_Count(imb.mExtraValues_Count), mBytes(NULL), mSize(imb.mSize)
    371 #ifdef INTEL_VIDEO_XPROC_SHARING
    372       ,mSessionFlag(imb.mSessionFlag)
    373 #endif
    374 {
    375     if (imb.mInfo)
    376         mInfo = new ValueInfo(*imb.mInfo);
    377 
    378     if (imb.mExtraValues)
    379     {
    380         mExtraValues = new intptr_t[mExtraValues_Count];
    381         memcpy(mExtraValues, imb.mExtraValues, sizeof(mValue) * mExtraValues_Count);
    382     }
    383 
    384     if (imb.mBytes)
    385     {
    386         mBytes = new uint8_t[mSize];
    387         memcpy(mBytes, imb.mBytes, mSize);
    388     }
    389 }
    390 
    391 const IntelMetadataBuffer& IntelMetadataBuffer::operator=(const IntelMetadataBuffer& imb)
    392 {
    393     mType = imb.mType;
    394     mValue = imb.mValue;
    395     mInfo = NULL;
    396     mExtraValues = NULL;
    397     mExtraValues_Count = imb.mExtraValues_Count;
    398     mBytes = NULL;
    399     mSize = imb.mSize;
    400 #ifdef INTEL_VIDEO_XPROC_SHARING
    401     mSessionFlag = imb.mSessionFlag;
    402 #endif
    403 
    404     if (imb.mInfo)
    405         mInfo = new ValueInfo(*imb.mInfo);
    406 
    407     if (imb.mExtraValues)
    408     {
    409         mExtraValues = new intptr_t[mExtraValues_Count];
    410         memcpy(mExtraValues, imb.mExtraValues, sizeof(mValue) * mExtraValues_Count);
    411     }
    412 
    413     if (imb.mBytes)
    414     {
    415         mBytes = new uint8_t[mSize];
    416         memcpy(mBytes, imb.mBytes, mSize);
    417     }
    418 
    419     return *this;
    420 }
    421 
    422 IMB_Result IntelMetadataBuffer::GetType(IntelMetadataBufferType& type)
    423 {
    424     type = mType;
    425 
    426     return IMB_SUCCESS;
    427 }
    428 
    429 IMB_Result IntelMetadataBuffer::SetType(IntelMetadataBufferType type)
    430 {
    431     if (type < IntelMetadataBufferTypeLast)
    432         mType = type;
    433     else
    434         return IMB_INVAL_PARAM;
    435 
    436     return IMB_SUCCESS;
    437 }
    438 
    439 IMB_Result IntelMetadataBuffer::GetValue(intptr_t& value)
    440 {
    441     value = mValue;
    442 
    443 #ifndef INTEL_VIDEO_XPROC_SHARING
    444     return IMB_SUCCESS;
    445 #else
    446     if ((mSessionFlag & REMOTE_CONSUMER) == 0) //no sharing or is local consumer
    447         return IMB_SUCCESS;
    448 
    449     //try to find if it is already cached.
    450     ShareMemMap* smem = FindShareMem(mSessionFlag, mValue, true);
    451     if(smem)
    452     {
    453         value = smem->value;
    454         return IMB_SUCCESS;
    455     }
    456 
    457     //is remote provider and not find from cache, then pull from service
    458     sp<IBinder> binder = GetIntelBufferSharingService();
    459     if (binder == 0)
    460         return IMB_NO_SERVICE;
    461 
    462     //Detect IntelBufferSharingService, share mem to service
    463     Parcel data, reply;
    464 
    465     //send pid, sessionflag, and memtype
    466     pid_t pid = getpid();
    467     //TODO: if pid is int32?
    468     data.writeInt32(pid);
    469     data.writeInt32(mSessionFlag);
    470     data.writeIntPtr(mValue);
    471 
    472     //do transcation
    473     if (binder->transact(GET_MEM, data, &reply) != NO_ERROR)
    474         return IMB_SERVICE_FAIL;
    475 
    476     //get type/Mem OBJ
    477     smem = ReadMemObjFromBinder(reply, mSessionFlag, mValue);
    478     if (smem)
    479         value = smem->value;
    480     else
    481         return IMB_SERVICE_FAIL;
    482 
    483     return IMB_SUCCESS;
    484 #endif
    485 }
    486 
    487 IMB_Result IntelMetadataBuffer::SetValue(intptr_t value)
    488 {
    489     mValue = value;
    490 
    491     return IMB_SUCCESS;
    492 }
    493 
    494 IMB_Result IntelMetadataBuffer::GetValueInfo(ValueInfo* &info)
    495 {
    496     info = mInfo;
    497 
    498     return IMB_SUCCESS;
    499 }
    500 
    501 IMB_Result IntelMetadataBuffer::SetValueInfo(ValueInfo* info)
    502 {
    503     if (info)
    504     {
    505         if (mInfo == NULL)
    506             mInfo = new ValueInfo;
    507 
    508         memcpy(mInfo, info, sizeof(ValueInfo));
    509     }
    510     else
    511         return IMB_INVAL_PARAM;
    512 
    513     return IMB_SUCCESS;
    514 }
    515 
    516 IMB_Result IntelMetadataBuffer::GetExtraValues(intptr_t* &values, uint32_t& num)
    517 {
    518     values = mExtraValues;
    519     num = mExtraValues_Count;
    520 
    521     return IMB_SUCCESS;
    522 }
    523 
    524 IMB_Result IntelMetadataBuffer::SetExtraValues(intptr_t* values, uint32_t num)
    525 {
    526     if (values && num > 0)
    527     {
    528         if (mExtraValues && mExtraValues_Count != num)
    529         {
    530             delete[] mExtraValues;
    531             mExtraValues = NULL;
    532         }
    533 
    534         if (mExtraValues == NULL)
    535             mExtraValues = new intptr_t[num];
    536 
    537         memcpy(mExtraValues, values, sizeof(intptr_t) * num);
    538         mExtraValues_Count = num;
    539     }
    540     else
    541         return IMB_INVAL_PARAM;
    542 
    543     return IMB_SUCCESS;
    544 }
    545 
    546 IMB_Result IntelMetadataBuffer::UnSerialize(uint8_t* data, uint32_t size)
    547 {
    548     if (!data || size == 0)
    549         return IMB_INVAL_PARAM;
    550 
    551     IntelMetadataBufferType type;
    552     intptr_t value;
    553     uint32_t extrasize = size - sizeof(type) - sizeof(value);
    554     ValueInfo* info = NULL;
    555     intptr_t* ExtraValues = NULL;
    556     uint32_t ExtraValues_Count = 0;
    557 
    558     memcpy(&type, data, sizeof(type));
    559     data += sizeof(type);
    560     memcpy(&value, data, sizeof(value));
    561     data += sizeof(value);
    562 
    563     switch (type)
    564     {
    565         case IntelMetadataBufferTypeCameraSource:
    566         case IntelMetadataBufferTypeEncoder:
    567         case IntelMetadataBufferTypeUser:
    568         {
    569             if (extrasize >0 && extrasize < sizeof(ValueInfo))
    570                 return IMB_INVAL_BUFFER;
    571 
    572             if (extrasize > sizeof(ValueInfo)) //has extravalues
    573             {
    574                 if ( (extrasize - sizeof(ValueInfo)) % sizeof(mValue) != 0 )
    575                     return IMB_INVAL_BUFFER;
    576                 ExtraValues_Count = (extrasize - sizeof(ValueInfo)) / sizeof(mValue);
    577             }
    578 
    579             if (extrasize > 0)
    580             {
    581                 info = new ValueInfo;
    582                 memcpy(info, data, sizeof(ValueInfo));
    583                 data += sizeof(ValueInfo);
    584             }
    585 
    586             if (ExtraValues_Count > 0)
    587             {
    588                 ExtraValues = new intptr_t[ExtraValues_Count];
    589                 memcpy(ExtraValues, data, ExtraValues_Count * sizeof(mValue));
    590             }
    591 
    592             break;
    593         }
    594         case IntelMetadataBufferTypeGrallocSource:
    595             if (extrasize > 0)
    596                 return IMB_INVAL_BUFFER;
    597 
    598             break;
    599         default:
    600             return IMB_INVAL_BUFFER;
    601     }
    602 
    603     //store data
    604     mType = type;
    605     mValue = value;
    606     if (mInfo)
    607         delete mInfo;
    608     mInfo = info;
    609     if (mExtraValues)
    610         delete[] mExtraValues;
    611     mExtraValues = ExtraValues;
    612     mExtraValues_Count = ExtraValues_Count;
    613 #ifdef INTEL_VIDEO_XPROC_SHARING
    614     if (mInfo != NULL)
    615         mSessionFlag = mInfo->sessionFlag;
    616 #endif
    617     return IMB_SUCCESS;
    618 }
    619 
    620 IMB_Result IntelMetadataBuffer::Serialize(uint8_t* &data, uint32_t& size)
    621 {
    622     if (mBytes == NULL)
    623     {
    624         if (mType == IntelMetadataBufferTypeGrallocSource && mInfo)
    625             return IMB_INVAL_PARAM;
    626 
    627         //assemble bytes according members
    628         mSize = sizeof(mType) + sizeof(mValue);
    629         if (mInfo)
    630         {
    631             mSize += sizeof(ValueInfo);
    632             if (mExtraValues)
    633                 mSize += sizeof(mValue) * mExtraValues_Count;
    634         }
    635 
    636         mBytes = new uint8_t[mSize];
    637         uint8_t *ptr = mBytes;
    638         memcpy(ptr, &mType, sizeof(mType));
    639         ptr += sizeof(mType);
    640         memcpy(ptr, &mValue, sizeof(mValue));
    641         ptr += sizeof(mValue);
    642 
    643         if (mInfo)
    644         {
    645         #ifdef INTEL_VIDEO_XPROC_SHARING
    646             mInfo->sessionFlag = mSessionFlag;
    647         #endif
    648             memcpy(ptr, mInfo, sizeof(ValueInfo));
    649             ptr += sizeof(ValueInfo);
    650 
    651             if (mExtraValues)
    652                 memcpy(ptr, mExtraValues, mExtraValues_Count * sizeof(mValue));
    653         }
    654     }
    655 
    656     data = mBytes;
    657     size = mSize;
    658 
    659     return IMB_SUCCESS;
    660 }
    661 
    662 uint32_t IntelMetadataBuffer::GetMaxBufferSize()
    663 {
    664     return 256;
    665 }
    666 
    667 #ifdef INTEL_VIDEO_XPROC_SHARING
    668 IMB_Result IntelMetadataBuffer::GetSessionFlag(uint32_t& sessionflag)
    669 {
    670     sessionflag = mSessionFlag;
    671 
    672     return IMB_SUCCESS;
    673 }
    674 
    675 IMB_Result IntelMetadataBuffer::SetSessionFlag(uint32_t sessionflag)
    676 {
    677     mSessionFlag = sessionflag;
    678 
    679     return IMB_SUCCESS;
    680 }
    681 
    682 IMB_Result IntelMetadataBuffer::ShareValue(sp<MemoryBase> mem)
    683 {
    684     mValue = (intptr_t)((intptr_t) ( mem->pointer() + 0x0FFF) & ~0x0FFF);
    685 
    686     if ( !(mSessionFlag & REMOTE_PROVIDER) && !(mSessionFlag & REMOTE_CONSUMER)) //no sharing
    687         return IMB_SUCCESS;
    688 
    689     if (mSessionFlag & REMOTE_PROVIDER) //is remote provider
    690     {
    691         sp<IBinder> binder = GetIntelBufferSharingService();
    692         if (binder == 0)
    693             return IMB_NO_SERVICE;
    694 
    695         //Detect IntelBufferSharingService, share mem to service
    696         Parcel data, reply;
    697 
    698         //send pid, sessionflag, and value
    699         pid_t pid = getpid();
    700         //TODO: if pid is int32?
    701         data.writeInt32(pid);
    702         data.writeInt32(mSessionFlag);
    703         data.writeIntPtr(mValue);
    704 
    705         //send type/obj (offset/size/MemHeap)
    706         ShareMemMap smem;
    707         smem.membase = mem;
    708         smem.type = ST_MEMBASE;
    709         if (WriteMemObjToBinder(data, &smem) != NO_ERROR)
    710             return IMB_SERVICE_FAIL;
    711 
    712         //do transcation
    713         if (binder->transact(SHARE_MEM, data, &reply) != NO_ERROR)
    714             return IMB_SERVICE_FAIL;
    715 
    716         //set new value gotten from peer
    717         mValue = reply.readIntPtr();
    718 //        LOGI("ShareValue(membase) Get reply from sevice, new value:%x\n", mValue);
    719     }
    720     else  //is local provider , direct access list
    721     {
    722         ShareMemMap* smem = new ShareMemMap;
    723         smem->sessionflag = mSessionFlag;
    724         smem->value = mValue;
    725         smem->value_backup = mValue;
    726         smem->type = ST_MEMBASE;
    727         smem->membase = mem;
    728         smem->gbuffer = NULL;
    729         PushShareMem(smem);
    730     }
    731 
    732     return IMB_SUCCESS;
    733 }
    734 
    735 IMB_Result IntelMetadataBuffer::ShareValue(sp<GraphicBuffer> gbuffer)
    736 {
    737     mValue = (intptr_t)gbuffer->handle;
    738 
    739     if ( !(mSessionFlag & REMOTE_PROVIDER) && !(mSessionFlag & REMOTE_CONSUMER)) //no sharing
    740         return IMB_SUCCESS;
    741 
    742     if (mSessionFlag & REMOTE_PROVIDER == 0) //is remote provider
    743     {
    744         sp<IBinder> binder = GetIntelBufferSharingService();
    745         if (binder == 0)
    746             return IMB_NO_SERVICE;
    747 
    748         Parcel data, reply;
    749 
    750         //send pid, sessionflag, and memtype
    751         pid_t pid = getpid();
    752         //TODO: if pid is int32 ?
    753         data.writeInt32(pid);
    754         data.writeInt32(mSessionFlag);
    755         data.writeIntPtr(mValue);
    756 
    757         //send value/graphicbuffer obj
    758         ShareMemMap smem;
    759         smem.gbuffer = gbuffer;
    760         smem.type = ST_GFX;
    761         if (WriteMemObjToBinder(data, &smem) != NO_ERROR)
    762             return IMB_SERVICE_FAIL;
    763 
    764         //do transcation
    765         if (binder->transact(SHARE_MEM, data, &reply) != NO_ERROR)
    766             return IMB_SERVICE_FAIL;
    767 
    768         //set new value gotten from peer
    769         mValue = reply.readIntPtr();
    770 //        LOGI("ShareValue(gfx) Get reply from sevice, new value:%x\n", mValue);
    771     }
    772     else //is local provider, direct access list
    773     {
    774         ShareMemMap* smem = new ShareMemMap;
    775         smem->sessionflag = mSessionFlag;
    776         smem->value = mValue;
    777         smem->value_backup = mValue;
    778         smem->type = ST_GFX;
    779         smem->membase = NULL;
    780         smem->gbuffer = gbuffer;
    781         PushShareMem(smem);
    782     }
    783 
    784     return IMB_SUCCESS;
    785 }
    786 
    787 IMB_Result IntelMetadataBuffer::ClearContext(uint32_t sessionflag, bool isProvider)
    788 {
    789     if ( !(sessionflag & REMOTE_PROVIDER) && !(sessionflag & REMOTE_CONSUMER)) //no sharing
    790         return IMB_SUCCESS;
    791 
    792     //clear local firstly
    793     ClearLocalMem(sessionflag);
    794 
    795     //clear mem on service if it is remote user
    796     if ((isProvider && (sessionflag & REMOTE_PROVIDER)) || (!isProvider && (sessionflag & REMOTE_CONSUMER)))
    797     {
    798 //        LOGI("CLEAR_MEM sessionflag=%x", sessionflag);
    799 
    800         sp<IBinder> binder = GetIntelBufferSharingService();
    801         if (binder == 0)
    802             return IMB_NO_SERVICE;
    803 
    804         //Detect IntelBufferSharingService, unshare mem from service
    805         Parcel data, reply;
    806 
    807         //send pid and sessionflag
    808         pid_t pid = getpid();
    809         //TODO: if pid is int32?
    810         data.writeInt32(pid);
    811         data.writeInt32(sessionflag);
    812 
    813         if (binder->transact(CLEAR_MEM, data, &reply) != NO_ERROR)
    814             return IMB_SERVICE_FAIL;
    815     }
    816 
    817     return IMB_SUCCESS;
    818 }
    819 
    820 uint32_t IntelMetadataBuffer::MakeSessionFlag(bool romoteProvider, bool remoteConsumer, uint16_t sindex)
    821 {
    822     uint32_t sessionflag = 0;
    823 
    824     if (romoteProvider)
    825         sessionflag |= REMOTE_PROVIDER;
    826 
    827     if (remoteConsumer)
    828         sessionflag |= REMOTE_CONSUMER;
    829 
    830     return sessionflag + sindex;
    831 }
    832 #endif
    833