IOMX.cpp revision c1c50e7b47784c5e6978eda67db68ef4951144c6 
1/*
2 * Copyright (c) 2009 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 "IOMX"
19#include <utils/Log.h>
20
21#include <sys/mman.h>
22
23#include <binder/IMemory.h>
24#include <binder/Parcel.h>
25#include <media/IOMX.h>
26#include <media/stagefright/foundation/ADebug.h>
27#include <media/openmax/OMX_IndexExt.h>
28
29namespace android {
30
31enum {
32    CONNECT = IBinder::FIRST_CALL_TRANSACTION,
33    LIVES_LOCALLY,
34    LIST_NODES,
35    ALLOCATE_NODE,
36    FREE_NODE,
37    SEND_COMMAND,
38    GET_PARAMETER,
39    SET_PARAMETER,
40    GET_CONFIG,
41    SET_CONFIG,
42    GET_STATE,
43    ENABLE_GRAPHIC_BUFFERS,
44    USE_BUFFER,
45    USE_GRAPHIC_BUFFER,
46    CREATE_INPUT_SURFACE,
47    CREATE_PERSISTENT_INPUT_SURFACE,
48    SET_INPUT_SURFACE,
49    SIGNAL_END_OF_INPUT_STREAM,
50    STORE_META_DATA_IN_BUFFERS,
51    PREPARE_FOR_ADAPTIVE_PLAYBACK,
52    ALLOC_BUFFER,
53    ALLOC_BUFFER_WITH_BACKUP,
54    FREE_BUFFER,
55    FILL_BUFFER,
56    EMPTY_BUFFER,
57    GET_EXTENSION_INDEX,
58    OBSERVER_ON_MSG,
59    GET_GRAPHIC_BUFFER_USAGE,
60    SET_INTERNAL_OPTION,
61    UPDATE_GRAPHIC_BUFFER_IN_META,
62    CONFIGURE_VIDEO_TUNNEL_MODE,
63};
64
65class BpOMX : public BpInterface<IOMX> {
66public:
67    BpOMX(const sp<IBinder> &impl)
68        : BpInterface<IOMX>(impl) {
69    }
70
71    virtual bool livesLocally(node_id node, pid_t pid) {
72        Parcel data, reply;
73        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
74        data.writeInt32((int32_t)node);
75        data.writeInt32(pid);
76        remote()->transact(LIVES_LOCALLY, data, &reply);
77
78        return reply.readInt32() != 0;
79    }
80
81    virtual status_t listNodes(List<ComponentInfo> *list) {
82        list->clear();
83
84        Parcel data, reply;
85        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
86        remote()->transact(LIST_NODES, data, &reply);
87
88        int32_t n = reply.readInt32();
89        for (int32_t i = 0; i < n; ++i) {
90            list->push_back(ComponentInfo());
91            ComponentInfo &info = *--list->end();
92
93            info.mName = reply.readString8();
94            int32_t numRoles = reply.readInt32();
95            for (int32_t j = 0; j < numRoles; ++j) {
96                info.mRoles.push_back(reply.readString8());
97            }
98        }
99
100        return OK;
101    }
102
103    virtual status_t allocateNode(
104            const char *name, const sp<IOMXObserver> &observer, node_id *node) {
105        Parcel data, reply;
106        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
107        data.writeCString(name);
108        data.writeStrongBinder(IInterface::asBinder(observer));
109        remote()->transact(ALLOCATE_NODE, data, &reply);
110
111        status_t err = reply.readInt32();
112        if (err == OK) {
113            *node = (node_id)reply.readInt32();
114        } else {
115            *node = 0;
116        }
117
118        return err;
119    }
120
121    virtual status_t freeNode(node_id node) {
122        Parcel data, reply;
123        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
124        data.writeInt32((int32_t)node);
125        remote()->transact(FREE_NODE, data, &reply);
126
127        return reply.readInt32();
128    }
129
130    virtual status_t sendCommand(
131            node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) {
132        Parcel data, reply;
133        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
134        data.writeInt32((int32_t)node);
135        data.writeInt32(cmd);
136        data.writeInt32(param);
137        remote()->transact(SEND_COMMAND, data, &reply);
138
139        return reply.readInt32();
140    }
141
142    virtual status_t getParameter(
143            node_id node, OMX_INDEXTYPE index,
144            void *params, size_t size) {
145        Parcel data, reply;
146        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
147        data.writeInt32((int32_t)node);
148        data.writeInt32(index);
149        data.writeInt64(size);
150        data.write(params, size);
151        remote()->transact(GET_PARAMETER, data, &reply);
152
153        status_t err = reply.readInt32();
154        if (err != OK) {
155            return err;
156        }
157
158        reply.read(params, size);
159
160        return OK;
161    }
162
163    virtual status_t setParameter(
164            node_id node, OMX_INDEXTYPE index,
165            const void *params, size_t size) {
166        Parcel data, reply;
167        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
168        data.writeInt32((int32_t)node);
169        data.writeInt32(index);
170        data.writeInt64(size);
171        data.write(params, size);
172        remote()->transact(SET_PARAMETER, data, &reply);
173
174        return reply.readInt32();
175    }
176
177    virtual status_t getConfig(
178            node_id node, OMX_INDEXTYPE index,
179            void *params, size_t size) {
180        Parcel data, reply;
181        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
182        data.writeInt32((int32_t)node);
183        data.writeInt32(index);
184        data.writeInt64(size);
185        data.write(params, size);
186        remote()->transact(GET_CONFIG, data, &reply);
187
188        status_t err = reply.readInt32();
189        if (err != OK) {
190            return err;
191        }
192
193        reply.read(params, size);
194
195        return OK;
196    }
197
198    virtual status_t setConfig(
199            node_id node, OMX_INDEXTYPE index,
200            const void *params, size_t size) {
201        Parcel data, reply;
202        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
203        data.writeInt32((int32_t)node);
204        data.writeInt32(index);
205        data.writeInt64(size);
206        data.write(params, size);
207        remote()->transact(SET_CONFIG, data, &reply);
208
209        return reply.readInt32();
210    }
211
212    virtual status_t getState(
213            node_id node, OMX_STATETYPE* state) {
214        Parcel data, reply;
215        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
216        data.writeInt32((int32_t)node);
217        remote()->transact(GET_STATE, data, &reply);
218
219        *state = static_cast<OMX_STATETYPE>(reply.readInt32());
220        return reply.readInt32();
221    }
222
223    virtual status_t enableGraphicBuffers(
224            node_id node, OMX_U32 port_index, OMX_BOOL enable) {
225        Parcel data, reply;
226        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
227        data.writeInt32((int32_t)node);
228        data.writeInt32(port_index);
229        data.writeInt32((uint32_t)enable);
230        remote()->transact(ENABLE_GRAPHIC_BUFFERS, data, &reply);
231
232        status_t err = reply.readInt32();
233        return err;
234    }
235
236    virtual status_t getGraphicBufferUsage(
237            node_id node, OMX_U32 port_index, OMX_U32* usage) {
238        Parcel data, reply;
239        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
240        data.writeInt32((int32_t)node);
241        data.writeInt32(port_index);
242        remote()->transact(GET_GRAPHIC_BUFFER_USAGE, data, &reply);
243
244        status_t err = reply.readInt32();
245        *usage = reply.readInt32();
246        return err;
247    }
248
249    virtual status_t useBuffer(
250            node_id node, OMX_U32 port_index, const sp<IMemory> &params,
251            buffer_id *buffer, OMX_U32 allottedSize) {
252        Parcel data, reply;
253        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
254        data.writeInt32((int32_t)node);
255        data.writeInt32(port_index);
256        data.writeStrongBinder(IInterface::asBinder(params));
257        data.writeInt32(allottedSize);
258        remote()->transact(USE_BUFFER, data, &reply);
259
260        status_t err = reply.readInt32();
261        if (err != OK) {
262            *buffer = 0;
263
264            return err;
265        }
266
267        *buffer = (buffer_id)reply.readInt32();
268
269        return err;
270    }
271
272
273    virtual status_t useGraphicBuffer(
274            node_id node, OMX_U32 port_index,
275            const sp<GraphicBuffer> &graphicBuffer, buffer_id *buffer) {
276        Parcel data, reply;
277        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
278        data.writeInt32((int32_t)node);
279        data.writeInt32(port_index);
280        data.write(*graphicBuffer);
281        remote()->transact(USE_GRAPHIC_BUFFER, data, &reply);
282
283        status_t err = reply.readInt32();
284        if (err != OK) {
285            *buffer = 0;
286
287            return err;
288        }
289
290        *buffer = (buffer_id)reply.readInt32();
291
292        return err;
293    }
294
295    virtual status_t updateGraphicBufferInMeta(
296            node_id node, OMX_U32 port_index,
297            const sp<GraphicBuffer> &graphicBuffer, buffer_id buffer) {
298        Parcel data, reply;
299        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
300        data.writeInt32((int32_t)node);
301        data.writeInt32(port_index);
302        data.write(*graphicBuffer);
303        data.writeInt32((int32_t)buffer);
304        remote()->transact(UPDATE_GRAPHIC_BUFFER_IN_META, data, &reply);
305
306        status_t err = reply.readInt32();
307        return err;
308    }
309
310    virtual status_t createInputSurface(
311            node_id node, OMX_U32 port_index,
312            sp<IGraphicBufferProducer> *bufferProducer, MetadataBufferType *type) {
313        Parcel data, reply;
314        status_t err;
315        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
316        data.writeInt32((int32_t)node);
317        data.writeInt32(port_index);
318        err = remote()->transact(CREATE_INPUT_SURFACE, data, &reply);
319        if (err != OK) {
320            ALOGW("binder transaction failed: %d", err);
321            return err;
322        }
323
324        // read type even if createInputSurface failed
325        int negotiatedType = reply.readInt32();
326        if (type != NULL) {
327            *type = (MetadataBufferType)negotiatedType;
328        }
329
330        err = reply.readInt32();
331        if (err != OK) {
332            return err;
333        }
334
335        *bufferProducer = IGraphicBufferProducer::asInterface(
336                reply.readStrongBinder());
337
338        return err;
339    }
340
341    virtual status_t createPersistentInputSurface(
342            sp<IGraphicBufferProducer> *bufferProducer,
343            sp<IGraphicBufferConsumer> *bufferConsumer) {
344        Parcel data, reply;
345        status_t err;
346        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
347        err = remote()->transact(CREATE_PERSISTENT_INPUT_SURFACE, data, &reply);
348        if (err != OK) {
349            ALOGW("binder transaction failed: %d", err);
350            return err;
351        }
352
353        err = reply.readInt32();
354        if (err != OK) {
355            return err;
356        }
357
358        *bufferProducer = IGraphicBufferProducer::asInterface(
359                reply.readStrongBinder());
360        *bufferConsumer = IGraphicBufferConsumer::asInterface(
361                reply.readStrongBinder());
362
363        return err;
364    }
365
366    virtual status_t setInputSurface(
367            node_id node, OMX_U32 port_index,
368            const sp<IGraphicBufferConsumer> &bufferConsumer, MetadataBufferType *type) {
369        Parcel data, reply;
370        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
371        status_t err;
372        data.writeInt32((int32_t)node);
373        data.writeInt32(port_index);
374        data.writeStrongBinder(IInterface::asBinder(bufferConsumer));
375
376        err = remote()->transact(SET_INPUT_SURFACE, data, &reply);
377
378        if (err != OK) {
379            ALOGW("binder transaction failed: %d", err);
380            return err;
381        }
382
383        // read type even if setInputSurface failed
384        int negotiatedType = reply.readInt32();
385        if (type != NULL) {
386            *type = (MetadataBufferType)negotiatedType;
387        }
388
389        return reply.readInt32();
390    }
391
392    virtual status_t signalEndOfInputStream(node_id node) {
393        Parcel data, reply;
394        status_t err;
395        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
396        data.writeInt32((int32_t)node);
397        err = remote()->transact(SIGNAL_END_OF_INPUT_STREAM, data, &reply);
398        if (err != OK) {
399            ALOGW("binder transaction failed: %d", err);
400            return err;
401        }
402
403        return reply.readInt32();
404    }
405
406    virtual status_t storeMetaDataInBuffers(
407            node_id node, OMX_U32 port_index, OMX_BOOL enable, MetadataBufferType *type) {
408        Parcel data, reply;
409        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
410        data.writeInt32((int32_t)node);
411        data.writeInt32(port_index);
412        data.writeInt32((uint32_t)enable);
413        remote()->transact(STORE_META_DATA_IN_BUFFERS, data, &reply);
414
415        // read type even storeMetaDataInBuffers failed
416        int negotiatedType = reply.readInt32();
417        if (type != NULL) {
418            *type = (MetadataBufferType)negotiatedType;
419        }
420
421        return reply.readInt32();
422    }
423
424    virtual status_t prepareForAdaptivePlayback(
425            node_id node, OMX_U32 port_index, OMX_BOOL enable,
426            OMX_U32 max_width, OMX_U32 max_height) {
427        Parcel data, reply;
428        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
429        data.writeInt32((int32_t)node);
430        data.writeInt32(port_index);
431        data.writeInt32((int32_t)enable);
432        data.writeInt32(max_width);
433        data.writeInt32(max_height);
434        remote()->transact(PREPARE_FOR_ADAPTIVE_PLAYBACK, data, &reply);
435
436        status_t err = reply.readInt32();
437        return err;
438    }
439
440    virtual status_t configureVideoTunnelMode(
441            node_id node, OMX_U32 portIndex, OMX_BOOL tunneled,
442            OMX_U32 audioHwSync, native_handle_t **sidebandHandle ) {
443        Parcel data, reply;
444        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
445        data.writeInt32((int32_t)node);
446        data.writeInt32(portIndex);
447        data.writeInt32((int32_t)tunneled);
448        data.writeInt32(audioHwSync);
449        remote()->transact(CONFIGURE_VIDEO_TUNNEL_MODE, data, &reply);
450
451        status_t err = reply.readInt32();
452        if (err == OK && sidebandHandle) {
453            *sidebandHandle = (native_handle_t *)reply.readNativeHandle();
454        }
455        return err;
456    }
457
458
459    virtual status_t allocateBuffer(
460            node_id node, OMX_U32 port_index, size_t size,
461            buffer_id *buffer, void **buffer_data) {
462        Parcel data, reply;
463        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
464        data.writeInt32((int32_t)node);
465        data.writeInt32(port_index);
466        data.writeInt64(size);
467        remote()->transact(ALLOC_BUFFER, data, &reply);
468
469        status_t err = reply.readInt32();
470        if (err != OK) {
471            *buffer = 0;
472
473            return err;
474        }
475
476        *buffer = (buffer_id)reply.readInt32();
477        *buffer_data = (void *)reply.readInt64();
478
479        return err;
480    }
481
482    virtual status_t allocateBufferWithBackup(
483            node_id node, OMX_U32 port_index, const sp<IMemory> &params,
484            buffer_id *buffer, OMX_U32 allottedSize) {
485        Parcel data, reply;
486        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
487        data.writeInt32((int32_t)node);
488        data.writeInt32(port_index);
489        data.writeStrongBinder(IInterface::asBinder(params));
490        data.writeInt32(allottedSize);
491        remote()->transact(ALLOC_BUFFER_WITH_BACKUP, data, &reply);
492
493        status_t err = reply.readInt32();
494        if (err != OK) {
495            *buffer = 0;
496
497            return err;
498        }
499
500        *buffer = (buffer_id)reply.readInt32();
501
502        return err;
503    }
504
505    virtual status_t freeBuffer(
506            node_id node, OMX_U32 port_index, buffer_id buffer) {
507        Parcel data, reply;
508        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
509        data.writeInt32((int32_t)node);
510        data.writeInt32(port_index);
511        data.writeInt32((int32_t)buffer);
512        remote()->transact(FREE_BUFFER, data, &reply);
513
514        return reply.readInt32();
515    }
516
517    virtual status_t fillBuffer(node_id node, buffer_id buffer, int fenceFd) {
518        Parcel data, reply;
519        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
520        data.writeInt32((int32_t)node);
521        data.writeInt32((int32_t)buffer);
522        data.writeInt32(fenceFd >= 0);
523        if (fenceFd >= 0) {
524            data.writeFileDescriptor(fenceFd, true /* takeOwnership */);
525        }
526        remote()->transact(FILL_BUFFER, data, &reply);
527
528        return reply.readInt32();
529    }
530
531    virtual status_t emptyBuffer(
532            node_id node,
533            buffer_id buffer,
534            OMX_U32 range_offset, OMX_U32 range_length,
535            OMX_U32 flags, OMX_TICKS timestamp, int fenceFd) {
536        Parcel data, reply;
537        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
538        data.writeInt32((int32_t)node);
539        data.writeInt32((int32_t)buffer);
540        data.writeInt32(range_offset);
541        data.writeInt32(range_length);
542        data.writeInt32(flags);
543        data.writeInt64(timestamp);
544        data.writeInt32(fenceFd >= 0);
545        if (fenceFd >= 0) {
546            data.writeFileDescriptor(fenceFd, true /* takeOwnership */);
547        }
548        remote()->transact(EMPTY_BUFFER, data, &reply);
549
550        return reply.readInt32();
551    }
552
553    virtual status_t getExtensionIndex(
554            node_id node,
555            const char *parameter_name,
556            OMX_INDEXTYPE *index) {
557        Parcel data, reply;
558        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
559        data.writeInt32((int32_t)node);
560        data.writeCString(parameter_name);
561
562        remote()->transact(GET_EXTENSION_INDEX, data, &reply);
563
564        status_t err = reply.readInt32();
565        if (err == OK) {
566            *index = static_cast<OMX_INDEXTYPE>(reply.readInt32());
567        } else {
568            *index = OMX_IndexComponentStartUnused;
569        }
570
571        return err;
572    }
573
574    virtual status_t setInternalOption(
575            node_id node,
576            OMX_U32 port_index,
577            InternalOptionType type,
578            const void *optionData,
579            size_t size) {
580        Parcel data, reply;
581        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
582        data.writeInt32((int32_t)node);
583        data.writeInt32(port_index);
584        data.writeInt64(size);
585        data.write(optionData, size);
586        data.writeInt32(type);
587        remote()->transact(SET_INTERNAL_OPTION, data, &reply);
588
589        return reply.readInt32();
590    }
591};
592
593IMPLEMENT_META_INTERFACE(OMX, "android.hardware.IOMX");
594
595////////////////////////////////////////////////////////////////////////////////
596
597#define CHECK_OMX_INTERFACE(interface, data, reply) \
598        do { if (!data.enforceInterface(interface::getInterfaceDescriptor())) { \
599            ALOGW("Call incorrectly routed to " #interface); \
600            return PERMISSION_DENIED; \
601        } } while (0)
602
603status_t BnOMX::onTransact(
604    uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
605    switch (code) {
606        case LIVES_LOCALLY:
607        {
608            CHECK_OMX_INTERFACE(IOMX, data, reply);
609            node_id node = (node_id)data.readInt32();
610            pid_t pid = (pid_t)data.readInt32();
611            reply->writeInt32(livesLocally(node, pid));
612
613            return OK;
614        }
615
616        case LIST_NODES:
617        {
618            CHECK_OMX_INTERFACE(IOMX, data, reply);
619
620            List<ComponentInfo> list;
621            listNodes(&list);
622
623            reply->writeInt32(list.size());
624            for (List<ComponentInfo>::iterator it = list.begin();
625                 it != list.end(); ++it) {
626                ComponentInfo &cur = *it;
627
628                reply->writeString8(cur.mName);
629                reply->writeInt32(cur.mRoles.size());
630                for (List<String8>::iterator role_it = cur.mRoles.begin();
631                     role_it != cur.mRoles.end(); ++role_it) {
632                    reply->writeString8(*role_it);
633                }
634            }
635
636            return NO_ERROR;
637        }
638
639        case ALLOCATE_NODE:
640        {
641            CHECK_OMX_INTERFACE(IOMX, data, reply);
642
643            const char *name = data.readCString();
644
645            sp<IOMXObserver> observer =
646                interface_cast<IOMXObserver>(data.readStrongBinder());
647
648            node_id node;
649
650            status_t err = allocateNode(name, observer, &node);
651            reply->writeInt32(err);
652            if (err == OK) {
653                reply->writeInt32((int32_t)node);
654            }
655
656            return NO_ERROR;
657        }
658
659        case FREE_NODE:
660        {
661            CHECK_OMX_INTERFACE(IOMX, data, reply);
662
663            node_id node = (node_id)data.readInt32();
664
665            reply->writeInt32(freeNode(node));
666
667            return NO_ERROR;
668        }
669
670        case SEND_COMMAND:
671        {
672            CHECK_OMX_INTERFACE(IOMX, data, reply);
673
674            node_id node = (node_id)data.readInt32();
675
676            OMX_COMMANDTYPE cmd =
677                static_cast<OMX_COMMANDTYPE>(data.readInt32());
678
679            OMX_S32 param = data.readInt32();
680            reply->writeInt32(sendCommand(node, cmd, param));
681
682            return NO_ERROR;
683        }
684
685        case GET_PARAMETER:
686        case SET_PARAMETER:
687        case GET_CONFIG:
688        case SET_CONFIG:
689        case SET_INTERNAL_OPTION:
690        {
691            CHECK_OMX_INTERFACE(IOMX, data, reply);
692
693            node_id node = (node_id)data.readInt32();
694            OMX_INDEXTYPE index = static_cast<OMX_INDEXTYPE>(data.readInt32());
695
696            size_t size = data.readInt64();
697
698            status_t err = NOT_ENOUGH_DATA;
699            void *params = NULL;
700            size_t pageSize = 0;
701            size_t allocSize = 0;
702            if ((index == (OMX_INDEXTYPE) OMX_IndexParamConsumerUsageBits && size < 4) ||
703                    (code != SET_INTERNAL_OPTION && size < 8)) {
704                // we expect the structure to contain at least the size and
705                // version, 8 bytes total
706                ALOGE("b/27207275 (%zu)", size);
707                android_errorWriteLog(0x534e4554, "27207275");
708            } else {
709                err = NO_MEMORY;
710                pageSize = (size_t) sysconf(_SC_PAGE_SIZE);
711                if (size > SIZE_MAX - (pageSize * 2)) {
712                    ALOGE("requested param size too big");
713                } else {
714                    allocSize = (size + pageSize * 2) & ~(pageSize - 1);
715                    params = mmap(NULL, allocSize, PROT_READ | PROT_WRITE,
716                            MAP_PRIVATE | MAP_ANONYMOUS, -1 /* fd */, 0 /* offset */);
717                }
718                if (params != MAP_FAILED) {
719                    err = data.read(params, size);
720                    if (err != OK) {
721                        android_errorWriteLog(0x534e4554, "26914474");
722                    } else {
723                        err = NOT_ENOUGH_DATA;
724                        OMX_U32 declaredSize = *(OMX_U32*)params;
725                        if (code != SET_INTERNAL_OPTION &&
726                                index != (OMX_INDEXTYPE) OMX_IndexParamConsumerUsageBits &&
727                                declaredSize > size) {
728                            // the buffer says it's bigger than it actually is
729                            ALOGE("b/27207275 (%u/%zu)", declaredSize, size);
730                            android_errorWriteLog(0x534e4554, "27207275");
731                        } else {
732                            // mark the last page as inaccessible, to avoid exploitation
733                            // of codecs that access past the end of the allocation because
734                            // they didn't check the size
735                            mprotect((char*)params + allocSize - pageSize, pageSize, PROT_NONE);
736                            switch (code) {
737                                case GET_PARAMETER:
738                                    err = getParameter(node, index, params, size);
739                                    break;
740                                case SET_PARAMETER:
741                                    err = setParameter(node, index, params, size);
742                                    break;
743                                case GET_CONFIG:
744                                    err = getConfig(node, index, params, size);
745                                    break;
746                                case SET_CONFIG:
747                                    err = setConfig(node, index, params, size);
748                                    break;
749                                case SET_INTERNAL_OPTION:
750                                {
751                                    InternalOptionType type =
752                                        (InternalOptionType)data.readInt32();
753
754                                    err = setInternalOption(node, index, type, params, size);
755                                    break;
756                                }
757
758                                default:
759                                    TRESPASS();
760                            }
761                        }
762                    }
763                } else {
764                    ALOGE("couldn't map: %s", strerror(errno));
765                }
766            }
767
768            reply->writeInt32(err);
769
770            if ((code == GET_PARAMETER || code == GET_CONFIG) && err == OK) {
771                reply->write(params, size);
772            }
773
774            if (params) {
775                munmap(params, allocSize);
776            }
777            params = NULL;
778
779            return NO_ERROR;
780        }
781
782        case GET_STATE:
783        {
784            CHECK_OMX_INTERFACE(IOMX, data, reply);
785
786            node_id node = (node_id)data.readInt32();
787            OMX_STATETYPE state = OMX_StateInvalid;
788
789            status_t err = getState(node, &state);
790            reply->writeInt32(state);
791            reply->writeInt32(err);
792
793            return NO_ERROR;
794        }
795
796        case ENABLE_GRAPHIC_BUFFERS:
797        {
798            CHECK_OMX_INTERFACE(IOMX, data, reply);
799
800            node_id node = (node_id)data.readInt32();
801            OMX_U32 port_index = data.readInt32();
802            OMX_BOOL enable = (OMX_BOOL)data.readInt32();
803
804            status_t err = enableGraphicBuffers(node, port_index, enable);
805            reply->writeInt32(err);
806
807            return NO_ERROR;
808        }
809
810        case GET_GRAPHIC_BUFFER_USAGE:
811        {
812            CHECK_OMX_INTERFACE(IOMX, data, reply);
813
814            node_id node = (node_id)data.readInt32();
815            OMX_U32 port_index = data.readInt32();
816
817            OMX_U32 usage = 0;
818            status_t err = getGraphicBufferUsage(node, port_index, &usage);
819            reply->writeInt32(err);
820            reply->writeInt32(usage);
821
822            return NO_ERROR;
823        }
824
825        case USE_BUFFER:
826        {
827            CHECK_OMX_INTERFACE(IOMX, data, reply);
828
829            node_id node = (node_id)data.readInt32();
830            OMX_U32 port_index = data.readInt32();
831            sp<IMemory> params =
832                interface_cast<IMemory>(data.readStrongBinder());
833            OMX_U32 allottedSize = data.readInt32();
834
835            buffer_id buffer;
836            status_t err = useBuffer(node, port_index, params, &buffer, allottedSize);
837            reply->writeInt32(err);
838
839            if (err == OK) {
840                reply->writeInt32((int32_t)buffer);
841            }
842
843            return NO_ERROR;
844        }
845
846        case USE_GRAPHIC_BUFFER:
847        {
848            CHECK_OMX_INTERFACE(IOMX, data, reply);
849
850            node_id node = (node_id)data.readInt32();
851            OMX_U32 port_index = data.readInt32();
852            sp<GraphicBuffer> graphicBuffer = new GraphicBuffer();
853            data.read(*graphicBuffer);
854
855            buffer_id buffer;
856            status_t err = useGraphicBuffer(
857                    node, port_index, graphicBuffer, &buffer);
858            reply->writeInt32(err);
859
860            if (err == OK) {
861                reply->writeInt32((int32_t)buffer);
862            }
863
864            return NO_ERROR;
865        }
866
867        case UPDATE_GRAPHIC_BUFFER_IN_META:
868        {
869            CHECK_OMX_INTERFACE(IOMX, data, reply);
870
871            node_id node = (node_id)data.readInt32();
872            OMX_U32 port_index = data.readInt32();
873            sp<GraphicBuffer> graphicBuffer = new GraphicBuffer();
874            data.read(*graphicBuffer);
875            buffer_id buffer = (buffer_id)data.readInt32();
876
877            status_t err = updateGraphicBufferInMeta(
878                    node, port_index, graphicBuffer, buffer);
879            reply->writeInt32(err);
880
881            return NO_ERROR;
882        }
883
884        case CREATE_INPUT_SURFACE:
885        {
886            CHECK_OMX_INTERFACE(IOMX, data, reply);
887
888            node_id node = (node_id)data.readInt32();
889            OMX_U32 port_index = data.readInt32();
890
891            sp<IGraphicBufferProducer> bufferProducer;
892            MetadataBufferType type = kMetadataBufferTypeInvalid;
893            status_t err = createInputSurface(node, port_index, &bufferProducer, &type);
894
895            if ((err != OK) && (type == kMetadataBufferTypeInvalid)) {
896                android_errorWriteLog(0x534e4554, "26324358");
897            }
898
899            reply->writeInt32(type);
900            reply->writeInt32(err);
901
902            if (err == OK) {
903                reply->writeStrongBinder(IInterface::asBinder(bufferProducer));
904            }
905
906            return NO_ERROR;
907        }
908
909        case CREATE_PERSISTENT_INPUT_SURFACE:
910        {
911            CHECK_OMX_INTERFACE(IOMX, data, reply);
912
913            sp<IGraphicBufferProducer> bufferProducer;
914            sp<IGraphicBufferConsumer> bufferConsumer;
915            status_t err = createPersistentInputSurface(
916                    &bufferProducer, &bufferConsumer);
917
918            reply->writeInt32(err);
919
920            if (err == OK) {
921                reply->writeStrongBinder(IInterface::asBinder(bufferProducer));
922                reply->writeStrongBinder(IInterface::asBinder(bufferConsumer));
923            }
924
925            return NO_ERROR;
926        }
927
928        case SET_INPUT_SURFACE:
929        {
930            CHECK_OMX_INTERFACE(IOMX, data, reply);
931
932            node_id node = (node_id)data.readInt32();
933            OMX_U32 port_index = data.readInt32();
934
935            sp<IGraphicBufferConsumer> bufferConsumer =
936                    interface_cast<IGraphicBufferConsumer>(data.readStrongBinder());
937
938            MetadataBufferType type = kMetadataBufferTypeInvalid;
939            status_t err = setInputSurface(node, port_index, bufferConsumer, &type);
940
941            if ((err != OK) && (type == kMetadataBufferTypeInvalid)) {
942                android_errorWriteLog(0x534e4554, "26324358");
943            }
944
945            reply->writeInt32(type);
946            reply->writeInt32(err);
947            return NO_ERROR;
948        }
949
950        case SIGNAL_END_OF_INPUT_STREAM:
951        {
952            CHECK_OMX_INTERFACE(IOMX, data, reply);
953
954            node_id node = (node_id)data.readInt32();
955
956            status_t err = signalEndOfInputStream(node);
957            reply->writeInt32(err);
958
959            return NO_ERROR;
960        }
961
962        case STORE_META_DATA_IN_BUFFERS:
963        {
964            CHECK_OMX_INTERFACE(IOMX, data, reply);
965
966            node_id node = (node_id)data.readInt32();
967            OMX_U32 port_index = data.readInt32();
968            OMX_BOOL enable = (OMX_BOOL)data.readInt32();
969
970            MetadataBufferType type = kMetadataBufferTypeInvalid;
971            status_t err = storeMetaDataInBuffers(node, port_index, enable, &type);
972
973            reply->writeInt32(type);
974            reply->writeInt32(err);
975
976            return NO_ERROR;
977        }
978
979        case PREPARE_FOR_ADAPTIVE_PLAYBACK:
980        {
981            CHECK_OMX_INTERFACE(IOMX, data, reply);
982
983            node_id node = (node_id)data.readInt32();
984            OMX_U32 port_index = data.readInt32();
985            OMX_BOOL enable = (OMX_BOOL)data.readInt32();
986            OMX_U32 max_width = data.readInt32();
987            OMX_U32 max_height = data.readInt32();
988
989            status_t err = prepareForAdaptivePlayback(
990                    node, port_index, enable, max_width, max_height);
991            reply->writeInt32(err);
992
993            return NO_ERROR;
994        }
995
996        case CONFIGURE_VIDEO_TUNNEL_MODE:
997        {
998            CHECK_OMX_INTERFACE(IOMX, data, reply);
999
1000            node_id node = (node_id)data.readInt32();
1001            OMX_U32 port_index = data.readInt32();
1002            OMX_BOOL tunneled = (OMX_BOOL)data.readInt32();
1003            OMX_U32 audio_hw_sync = data.readInt32();
1004
1005            native_handle_t *sideband_handle = NULL;
1006            status_t err = configureVideoTunnelMode(
1007                    node, port_index, tunneled, audio_hw_sync, &sideband_handle);
1008            reply->writeInt32(err);
1009            if(err == OK){
1010                reply->writeNativeHandle(sideband_handle);
1011            }
1012
1013            return NO_ERROR;
1014        }
1015
1016        case ALLOC_BUFFER:
1017        {
1018            CHECK_OMX_INTERFACE(IOMX, data, reply);
1019
1020            node_id node = (node_id)data.readInt32();
1021            OMX_U32 port_index = data.readInt32();
1022            if (!isSecure(node) || port_index != 0 /* kPortIndexInput */) {
1023                ALOGE("b/24310423");
1024                reply->writeInt32(INVALID_OPERATION);
1025                return NO_ERROR;
1026            }
1027
1028            size_t size = data.readInt64();
1029
1030            buffer_id buffer;
1031            void *buffer_data;
1032            status_t err = allocateBuffer(
1033                    node, port_index, size, &buffer, &buffer_data);
1034            reply->writeInt32(err);
1035
1036            if (err == OK) {
1037                reply->writeInt32((int32_t)buffer);
1038                reply->writeInt64((uintptr_t)buffer_data);
1039            }
1040
1041            return NO_ERROR;
1042        }
1043
1044        case ALLOC_BUFFER_WITH_BACKUP:
1045        {
1046            CHECK_OMX_INTERFACE(IOMX, data, reply);
1047
1048            node_id node = (node_id)data.readInt32();
1049            OMX_U32 port_index = data.readInt32();
1050            sp<IMemory> params =
1051                interface_cast<IMemory>(data.readStrongBinder());
1052            OMX_U32 allottedSize = data.readInt32();
1053
1054            buffer_id buffer;
1055            status_t err = allocateBufferWithBackup(
1056                    node, port_index, params, &buffer, allottedSize);
1057
1058            reply->writeInt32(err);
1059
1060            if (err == OK) {
1061                reply->writeInt32((int32_t)buffer);
1062            }
1063
1064            return NO_ERROR;
1065        }
1066
1067        case FREE_BUFFER:
1068        {
1069            CHECK_OMX_INTERFACE(IOMX, data, reply);
1070
1071            node_id node = (node_id)data.readInt32();
1072            OMX_U32 port_index = data.readInt32();
1073            buffer_id buffer = (buffer_id)data.readInt32();
1074            reply->writeInt32(freeBuffer(node, port_index, buffer));
1075
1076            return NO_ERROR;
1077        }
1078
1079        case FILL_BUFFER:
1080        {
1081            CHECK_OMX_INTERFACE(IOMX, data, reply);
1082
1083            node_id node = (node_id)data.readInt32();
1084            buffer_id buffer = (buffer_id)data.readInt32();
1085            bool haveFence = data.readInt32();
1086            int fenceFd = haveFence ? ::dup(data.readFileDescriptor()) : -1;
1087            reply->writeInt32(fillBuffer(node, buffer, fenceFd));
1088
1089            return NO_ERROR;
1090        }
1091
1092        case EMPTY_BUFFER:
1093        {
1094            CHECK_OMX_INTERFACE(IOMX, data, reply);
1095
1096            node_id node = (node_id)data.readInt32();
1097            buffer_id buffer = (buffer_id)data.readInt32();
1098            OMX_U32 range_offset = data.readInt32();
1099            OMX_U32 range_length = data.readInt32();
1100            OMX_U32 flags = data.readInt32();
1101            OMX_TICKS timestamp = data.readInt64();
1102            bool haveFence = data.readInt32();
1103            int fenceFd = haveFence ? ::dup(data.readFileDescriptor()) : -1;
1104            reply->writeInt32(emptyBuffer(
1105                    node, buffer, range_offset, range_length, flags, timestamp, fenceFd));
1106
1107            return NO_ERROR;
1108        }
1109
1110        case GET_EXTENSION_INDEX:
1111        {
1112            CHECK_OMX_INTERFACE(IOMX, data, reply);
1113
1114            node_id node = (node_id)data.readInt32();
1115            const char *parameter_name = data.readCString();
1116
1117            OMX_INDEXTYPE index;
1118            status_t err = getExtensionIndex(node, parameter_name, &index);
1119
1120            reply->writeInt32(err);
1121
1122            if (err == OK) {
1123                reply->writeInt32(index);
1124            }
1125
1126            return OK;
1127        }
1128
1129        default:
1130            return BBinder::onTransact(code, data, reply, flags);
1131    }
1132}
1133
1134////////////////////////////////////////////////////////////////////////////////
1135
1136class BpOMXObserver : public BpInterface<IOMXObserver> {
1137public:
1138    BpOMXObserver(const sp<IBinder> &impl)
1139        : BpInterface<IOMXObserver>(impl) {
1140    }
1141
1142    virtual void onMessages(const std::list<omx_message> &messages) {
1143        Parcel data, reply;
1144        std::list<omx_message>::const_iterator it = messages.cbegin();
1145        bool first = true;
1146        while (it != messages.cend()) {
1147            const omx_message &msg = *it++;
1148            if (first) {
1149                data.writeInterfaceToken(IOMXObserver::getInterfaceDescriptor());
1150                data.writeInt32(msg.node);
1151                first = false;
1152            }
1153            data.writeInt32(msg.fenceFd >= 0);
1154            if (msg.fenceFd >= 0) {
1155                data.writeFileDescriptor(msg.fenceFd, true /* takeOwnership */);
1156            }
1157            data.writeInt32(msg.type);
1158            data.write(&msg.u, sizeof(msg.u));
1159            ALOGV("onMessage writing message %d, size %zu", msg.type, sizeof(msg));
1160        }
1161        if (!first) {
1162            data.writeInt32(-1); // mark end
1163            remote()->transact(OBSERVER_ON_MSG, data, &reply, IBinder::FLAG_ONEWAY);
1164        }
1165    }
1166};
1167
1168IMPLEMENT_META_INTERFACE(OMXObserver, "android.hardware.IOMXObserver");
1169
1170status_t BnOMXObserver::onTransact(
1171    uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
1172    switch (code) {
1173        case OBSERVER_ON_MSG:
1174        {
1175            CHECK_OMX_INTERFACE(IOMXObserver, data, reply);
1176            IOMX::node_id node = data.readInt32();
1177            std::list<omx_message> messages;
1178            status_t err = FAILED_TRANSACTION; // must receive at least one message
1179            do {
1180                int haveFence = data.readInt32();
1181                if (haveFence < 0) { // we use -1 to mark end of messages
1182                    break;
1183                }
1184                omx_message msg;
1185                msg.node = node;
1186                msg.fenceFd = haveFence ? ::dup(data.readFileDescriptor()) : -1;
1187                msg.type = (typeof(msg.type))data.readInt32();
1188                err = data.read(&msg.u, sizeof(msg.u));
1189                ALOGV("onTransact reading message %d, size %zu", msg.type, sizeof(msg));
1190                messages.push_back(msg);
1191            } while (err == OK);
1192
1193            if (err == OK) {
1194                onMessages(messages);
1195            }
1196
1197            return err;
1198        }
1199
1200        default:
1201            return BBinder::onTransact(code, data, reply, flags);
1202    }
1203}
1204
1205}  // namespace android
1206