Änderungen Gruppe 30_10_2022 V2
This commit is contained in:
@@ -0,0 +1,20 @@
|
||||
add_library (mmal_omx ${LIBRARY_TYPE}
|
||||
mmalomx_core.c
|
||||
mmalomx_logging.c
|
||||
mmalomx_commands.c
|
||||
mmalomx_buffer.c
|
||||
mmalomx_marks.c
|
||||
mmalomx_roles.c
|
||||
mmalomx_parameters.c
|
||||
mmalomx_registry.c
|
||||
)
|
||||
|
||||
add_library (mmal_omxutil ${LIBRARY_TYPE}
|
||||
mmalomx_util_params.c
|
||||
mmalomx_util_params_audio.c
|
||||
mmalomx_util_params_video.c
|
||||
mmalomx_util_params_camera.c
|
||||
mmalomx_util_params_misc.c
|
||||
)
|
||||
|
||||
target_link_libraries (mmal_omx mmal_omxutil mmal_core mmal_util vcos)
|
||||
@@ -0,0 +1,130 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL
|
||||
*/
|
||||
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Core.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Component.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Video.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Audio.h"
|
||||
#include <mmal.h>
|
||||
#include <util/mmal_il.h>
|
||||
|
||||
/* Define this to 1 if you want to log all buffer transfers */
|
||||
#define ENABLE_MMAL_EXTRA_LOGGING 0
|
||||
|
||||
#ifndef MMALOMX_EXPORT
|
||||
# define MMALOMX_EXPORT(a) a
|
||||
#endif
|
||||
#ifndef MMALOMX_IMPORT
|
||||
# define MMALOMX_IMPORT(a) a
|
||||
#endif
|
||||
|
||||
#define MAX_MARKS_NUM 2
|
||||
#define MAX_ENCODINGS_NUM 20
|
||||
|
||||
/** Per-port context data */
|
||||
typedef struct MMALOMX_PORT_T
|
||||
{
|
||||
struct MMALOMX_COMPONENT_T *component;
|
||||
MMAL_PORT_T *mmal;
|
||||
OMX_DIRTYPE direction;
|
||||
unsigned int index;
|
||||
unsigned int buffers;
|
||||
unsigned int buffers_in_transit;
|
||||
|
||||
MMAL_BOOL_T buffers_allocated:1;
|
||||
MMAL_BOOL_T enabled:1;
|
||||
MMAL_BOOL_T populated:1;
|
||||
MMAL_BOOL_T zero_copy:1;
|
||||
MMAL_BOOL_T no_cropping:1;
|
||||
MMAL_BOOL_T format_changed:1;
|
||||
MMAL_POOL_T *pool;
|
||||
|
||||
uint32_t actions;
|
||||
|
||||
OMX_MARKTYPE marks[MAX_MARKS_NUM];
|
||||
unsigned int marks_first:8;
|
||||
unsigned int marks_num:8;
|
||||
|
||||
OMX_FORMAT_PARAM_TYPE format_param;
|
||||
|
||||
MMAL_PARAMETER_HEADER_T encodings_header;
|
||||
MMAL_FOURCC_T encodings[MAX_ENCODINGS_NUM];
|
||||
unsigned int encodings_num;
|
||||
|
||||
} MMALOMX_PORT_T;
|
||||
|
||||
/** Component context data */
|
||||
typedef struct MMALOMX_COMPONENT_T {
|
||||
OMX_COMPONENTTYPE omx; /**< OMX component type structure */
|
||||
|
||||
unsigned int registry_id;
|
||||
const char *name;
|
||||
uint32_t role;
|
||||
OMX_CALLBACKTYPE callbacks;
|
||||
OMX_PTR callbacks_data;
|
||||
|
||||
struct MMAL_COMPONENT_T *mmal;
|
||||
OMX_STATETYPE state;
|
||||
unsigned int state_transition;
|
||||
|
||||
MMALOMX_PORT_T *ports;
|
||||
unsigned int ports_num;
|
||||
unsigned int ports_domain_num[4];
|
||||
|
||||
MMAL_BOOL_T actions_running;
|
||||
|
||||
OMX_U32 group_id;
|
||||
OMX_U32 group_priority;
|
||||
|
||||
/* Support for command queues */
|
||||
MMAL_POOL_T *cmd_pool;
|
||||
MMAL_QUEUE_T *cmd_queue;
|
||||
VCOS_THREAD_T cmd_thread;
|
||||
MMAL_BOOL_T cmd_thread_used;
|
||||
VCOS_SEMAPHORE_T cmd_sema;
|
||||
|
||||
VCOS_MUTEX_T lock; /**< Used to protect component state */
|
||||
VCOS_MUTEX_T lock_port; /**< Used to protect port state */
|
||||
|
||||
} MMALOMX_COMPONENT_T;
|
||||
|
||||
OMX_ERRORTYPE mmalomx_callback_event_handler(
|
||||
MMALOMX_COMPONENT_T *component,
|
||||
OMX_EVENTTYPE eEvent,
|
||||
OMX_U32 nData1,
|
||||
OMX_U32 nData2,
|
||||
OMX_PTR pEventData);
|
||||
|
||||
#define MMALOMX_LOCK(a) vcos_mutex_lock(&a->lock)
|
||||
#define MMALOMX_UNLOCK(a) vcos_mutex_unlock(&a->lock)
|
||||
#define MMALOMX_LOCK_PORT(a,b) vcos_mutex_lock(&a->lock_port)
|
||||
#define MMALOMX_UNLOCK_PORT(a,b) vcos_mutex_unlock(&a->lock_port)
|
||||
|
||||
+235
@@ -0,0 +1,235 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_buffer.h"
|
||||
#include "mmalomx_commands.h"
|
||||
#include "mmalomx_marks.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
#include <util/mmal_util.h>
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_buffer_send(
|
||||
MMALOMX_COMPONENT_T *component,
|
||||
OMX_BUFFERHEADERTYPE *omx_buffer,
|
||||
OMX_DIRTYPE direction)
|
||||
{
|
||||
OMX_ERRORTYPE status = OMX_ErrorNone;
|
||||
MMAL_BUFFER_HEADER_T *mmal_buffer;
|
||||
MMAL_STATUS_T mmal_status;
|
||||
MMALOMX_PORT_T *port;
|
||||
unsigned int index;
|
||||
|
||||
/* Sanity checks */
|
||||
if (!component)
|
||||
return OMX_ErrorInvalidComponent;
|
||||
if (component->state == OMX_StateInvalid)
|
||||
return OMX_ErrorInvalidState;
|
||||
|
||||
if (!omx_buffer || omx_buffer->nSize != sizeof(OMX_BUFFERHEADERTYPE) ||
|
||||
omx_buffer->nOffset + omx_buffer->nFilledLen > omx_buffer->nAllocLen)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
index = direction == OMX_DirInput ? omx_buffer->nInputPortIndex : omx_buffer->nOutputPortIndex;
|
||||
if (index >= component->ports_num)
|
||||
return OMX_ErrorBadPortIndex;
|
||||
|
||||
port = &component->ports[index];
|
||||
if (port->direction != direction)
|
||||
return OMX_ErrorBadPortIndex;
|
||||
|
||||
MMALOMX_LOCK_PORT(component, port);
|
||||
|
||||
if (component->state != OMX_StatePause && component->state != OMX_StateExecuting)
|
||||
status = OMX_ErrorIncorrectStateOperation;
|
||||
if (!port->enabled /* FIXME: || flushing || pending idle */)
|
||||
status = OMX_ErrorIncorrectStateOperation;
|
||||
if (status != OMX_ErrorNone)
|
||||
goto error;
|
||||
|
||||
mmal_buffer = mmal_queue_get( port->pool->queue );
|
||||
if (!vcos_verify(mmal_buffer)) /* Should never happen */
|
||||
{
|
||||
status = OMX_ErrorUndefined;
|
||||
goto error;
|
||||
}
|
||||
|
||||
mmalomx_mark_process_incoming(component, port, omx_buffer);
|
||||
|
||||
mmal_buffer->user_data = (void *)omx_buffer;
|
||||
mmalil_buffer_header_to_mmal(mmal_buffer, omx_buffer);
|
||||
|
||||
mmal_status = mmal_port_send_buffer(port->mmal, mmal_buffer);
|
||||
if (!vcos_verify(mmal_status == MMAL_SUCCESS))
|
||||
{
|
||||
LOG_ERROR("failed to send buffer on %s", port->mmal->name);
|
||||
mmal_queue_put_back( port->pool->queue, mmal_buffer );
|
||||
status = mmalil_error_to_omx(mmal_status);
|
||||
}
|
||||
else
|
||||
{
|
||||
port->buffers_in_transit++;
|
||||
}
|
||||
|
||||
error:
|
||||
MMALOMX_UNLOCK_PORT(component, port);
|
||||
return status;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
static void mmalomx_buffer_event(
|
||||
MMALOMX_PORT_T *port,
|
||||
MMAL_BUFFER_HEADER_T *mmal_buffer)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = port->component;
|
||||
MMAL_EVENT_FORMAT_CHANGED_T *event;
|
||||
|
||||
LOG_TRACE("hComponent %p, port %i, event %4.4s", component, port->index,
|
||||
(char *)&mmal_buffer->cmd);
|
||||
|
||||
if (mmal_buffer->cmd == MMAL_EVENT_ERROR )
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventError,
|
||||
mmalil_error_to_omx(*(MMAL_STATUS_T *)mmal_buffer->data), 0, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
event = mmal_event_format_changed_get(mmal_buffer);
|
||||
if (event && port->mmal->type == MMAL_PORT_TYPE_OUTPUT &&
|
||||
port->mmal->format->type == MMAL_ES_TYPE_VIDEO)
|
||||
{
|
||||
uint32_t diff = mmal_format_compare(event->format, port->mmal->format);
|
||||
MMAL_ES_FORMAT_T *format = port->mmal->format;
|
||||
MMAL_VIDEO_FORMAT_T video = format->es->video;
|
||||
|
||||
/* Update the port settings with the new values */
|
||||
mmal_format_copy(format, event->format);
|
||||
port->mmal->buffer_num_min = event->buffer_num_min;
|
||||
port->mmal->buffer_size_min = event->buffer_size_min;
|
||||
port->format_changed = MMAL_TRUE;
|
||||
|
||||
if ((diff & MMAL_ES_FORMAT_COMPARE_FLAG_VIDEO_ASPECT_RATIO) &&
|
||||
/* Do not report a change if going from unspecified to 1:1 */
|
||||
!(format->es->video.par.num == format->es->video.par.den && !video.par.num))
|
||||
{
|
||||
LOG_DEBUG("aspect ratio change %ix%i->%ix%i", (int)video.par.num, (int)video.par.den,
|
||||
(int)format->es->video.par.num, (int)format->es->video.par.den);
|
||||
mmalomx_callback_event_handler(component, OMX_EventPortSettingsChanged,
|
||||
port->index, OMX_IndexParamBrcmPixelAspectRatio, NULL);
|
||||
}
|
||||
|
||||
if (diff & (MMAL_ES_FORMAT_COMPARE_FLAG_ENCODING|
|
||||
MMAL_ES_FORMAT_COMPARE_FLAG_VIDEO_RESOLUTION|
|
||||
MMAL_ES_FORMAT_COMPARE_FLAG_VIDEO_CROPPING))
|
||||
{
|
||||
LOG_DEBUG("format change %ix%i(%ix%i) -> %ix%i(%ix%i)",
|
||||
(int)video.width, (int)video.height,
|
||||
(int)video.crop.width, (int)video.crop.height,
|
||||
(int)format->es->video.width, (int)format->es->video.height,
|
||||
(int)format->es->video.crop.width, (int)format->es->video.crop.height);
|
||||
mmalomx_callback_event_handler(component, OMX_EventPortSettingsChanged,
|
||||
port->index, 0, NULL);
|
||||
}
|
||||
}
|
||||
else if (event && port->mmal->type == MMAL_PORT_TYPE_OUTPUT &&
|
||||
port->mmal->format->type == MMAL_ES_TYPE_AUDIO)
|
||||
{
|
||||
uint32_t diff = mmal_format_compare(event->format, port->mmal->format);
|
||||
MMAL_ES_FORMAT_T *format = port->mmal->format;
|
||||
MMAL_AUDIO_FORMAT_T audio = format->es->audio;
|
||||
|
||||
/* Update the port settings with the new values */
|
||||
mmal_format_copy(format, event->format);
|
||||
port->mmal->buffer_num_min = event->buffer_num_min;
|
||||
port->mmal->buffer_size_min = event->buffer_size_min;
|
||||
port->format_changed = MMAL_TRUE;
|
||||
|
||||
if (diff)
|
||||
{
|
||||
LOG_DEBUG("format change %ich, %iHz, %ibps -> %ich, %iHz, %ibps",
|
||||
(int)audio.channels, (int)audio.sample_rate,
|
||||
(int)audio.bits_per_sample,
|
||||
(int)format->es->audio.channels,
|
||||
(int)format->es->audio.sample_rate,
|
||||
(int)format->es->audio.bits_per_sample);
|
||||
mmalomx_callback_event_handler(component, OMX_EventPortSettingsChanged,
|
||||
port->index, 0, NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_buffer_return(
|
||||
MMALOMX_PORT_T *port,
|
||||
MMAL_BUFFER_HEADER_T *mmal_buffer)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = port->component;
|
||||
OMX_BUFFERHEADERTYPE *omx_buffer = (OMX_BUFFERHEADERTYPE *)mmal_buffer->user_data;
|
||||
MMAL_BOOL_T signal;
|
||||
|
||||
if (mmal_buffer->cmd)
|
||||
{
|
||||
mmalomx_buffer_event(port, mmal_buffer);
|
||||
mmal_buffer_header_release(mmal_buffer);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
if (ENABLE_MMAL_EXTRA_LOGGING)
|
||||
LOG_TRACE("hComponent %p, port %i, pBuffer %p", component,
|
||||
port->index, omx_buffer);
|
||||
|
||||
vcos_assert(omx_buffer->pBuffer == mmal_buffer->data);
|
||||
mmalil_buffer_header_to_omx(omx_buffer, mmal_buffer);
|
||||
mmal_buffer_header_release(mmal_buffer);
|
||||
|
||||
if ((omx_buffer->nFlags & OMX_BUFFERFLAG_EOS) && port->direction == OMX_DirOutput)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventBufferFlag,
|
||||
port->index, omx_buffer->nFlags, NULL);
|
||||
}
|
||||
|
||||
mmalomx_mark_process_outgoing(component, port, omx_buffer);
|
||||
|
||||
if (port->direction == OMX_DirInput)
|
||||
component->callbacks.EmptyBufferDone((OMX_HANDLETYPE)&component->omx,
|
||||
component->callbacks_data, omx_buffer );
|
||||
else
|
||||
component->callbacks.FillBufferDone((OMX_HANDLETYPE)&component->omx,
|
||||
component->callbacks_data, omx_buffer );
|
||||
|
||||
MMALOMX_LOCK_PORT(component, port);
|
||||
signal = port->actions & MMALOMX_ACTION_CHECK_FLUSHED;
|
||||
port->buffers_in_transit--;
|
||||
MMALOMX_UNLOCK_PORT(component, port);
|
||||
|
||||
if (signal)
|
||||
mmalomx_commands_actions_signal(component);
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Buffer related functions
|
||||
*/
|
||||
|
||||
OMX_ERRORTYPE mmalomx_buffer_send(
|
||||
MMALOMX_COMPONENT_T *component,
|
||||
OMX_BUFFERHEADERTYPE *omx_buffer,
|
||||
OMX_DIRTYPE direction);
|
||||
|
||||
OMX_ERRORTYPE mmalomx_buffer_return(
|
||||
MMALOMX_PORT_T *port,
|
||||
MMAL_BUFFER_HEADER_T *mmal_buffer);
|
||||
+462
@@ -0,0 +1,462 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_commands.h"
|
||||
#include "mmalomx_buffer.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
typedef struct {
|
||||
OMX_STATETYPE state;
|
||||
OMX_STATETYPE request;
|
||||
uint32_t actions;
|
||||
} MMALOMX_STATE_TRANSITION_T;
|
||||
|
||||
MMALOMX_STATE_TRANSITION_T state_transition_table[] =
|
||||
{
|
||||
{OMX_StateInvalid, OMX_StateInvalid, 0},
|
||||
{OMX_StateLoaded, OMX_StateIdle, MMALOMX_ACTION_CHECK_ALLOCATED|MMALOMX_ACTION_ENABLE},
|
||||
{OMX_StateLoaded, OMX_StateWaitForResources, 0},
|
||||
{OMX_StateWaitForResources, OMX_StateLoaded, 0},
|
||||
{OMX_StateWaitForResources, OMX_StateIdle, MMALOMX_ACTION_CHECK_ALLOCATED|MMALOMX_ACTION_ENABLE},
|
||||
{OMX_StateIdle, OMX_StateLoaded, MMALOMX_ACTION_CHECK_DEALLOCATED|MMALOMX_ACTION_DISABLE},
|
||||
{OMX_StateIdle, OMX_StateExecuting, 0},
|
||||
{OMX_StateIdle, OMX_StatePause, 0},
|
||||
{OMX_StateExecuting, OMX_StateIdle, MMALOMX_ACTION_FLUSH|MMALOMX_ACTION_CHECK_FLUSHED},
|
||||
{OMX_StateExecuting, OMX_StatePause, 0},
|
||||
{OMX_StatePause, OMX_StateIdle, 0},
|
||||
{OMX_StatePause, OMX_StateExecuting, 0},
|
||||
{OMX_StateMax, OMX_StateMax, 0}
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
static unsigned int mmalomx_state_transition_get(OMX_STATETYPE state, OMX_STATETYPE request)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; state_transition_table[i].state != OMX_StateMax; i++)
|
||||
if (state_transition_table[i].state == state &&
|
||||
state_transition_table[i].request == request)
|
||||
break;
|
||||
|
||||
return state_transition_table[i].state != OMX_StateMax ? i : 0;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
static void mmalomx_buffer_cb_io(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
|
||||
{
|
||||
mmalomx_buffer_return((MMALOMX_PORT_T *)port->userdata, buffer);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
static void mmalomx_commands_check_port_actions(MMALOMX_COMPONENT_T *component,
|
||||
MMALOMX_PORT_T *port)
|
||||
{
|
||||
uint32_t exec_actions = 0;
|
||||
MMAL_STATUS_T status;
|
||||
|
||||
MMALOMX_LOCK_PORT(component, port);
|
||||
if (!port->actions)
|
||||
{
|
||||
MMALOMX_UNLOCK_PORT(component, port);
|
||||
return;
|
||||
}
|
||||
|
||||
if (port->actions & MMALOMX_ACTION_FLUSH)
|
||||
{
|
||||
port->actions &= ~MMALOMX_ACTION_FLUSH;
|
||||
port->actions |= MMALOMX_ACTION_PENDING_FLUSH;
|
||||
exec_actions |= MMALOMX_ACTION_PENDING_FLUSH;
|
||||
}
|
||||
if ((port->actions & MMALOMX_ACTION_DISABLE) &&
|
||||
(!port->buffers_in_transit ||
|
||||
!(port->actions & MMALOMX_ACTION_CHECK_FLUSHED)))
|
||||
{
|
||||
port->actions &= ~MMALOMX_ACTION_DISABLE;
|
||||
port->actions |= MMALOMX_ACTION_PENDING_DISABLE;
|
||||
exec_actions |= MMALOMX_ACTION_PENDING_DISABLE;
|
||||
}
|
||||
if ((port->actions & MMALOMX_ACTION_ENABLE) &&
|
||||
port->buffers)
|
||||
{
|
||||
/* We defer enabling the mmal port until the first buffer allocation
|
||||
* has been done. Only at that point do we know for sure whether we
|
||||
* are going to use shared memory or not.
|
||||
* We might want to delay it to just before sending the event to the client ???
|
||||
*/
|
||||
port->actions &= ~MMALOMX_ACTION_ENABLE;
|
||||
port->actions |= MMALOMX_ACTION_PENDING_ENABLE;
|
||||
exec_actions |= MMALOMX_ACTION_PENDING_ENABLE;
|
||||
}
|
||||
MMALOMX_UNLOCK_PORT(component, port);
|
||||
|
||||
if (exec_actions & MMALOMX_ACTION_PENDING_FLUSH)
|
||||
mmal_port_flush(port->mmal);
|
||||
|
||||
if (exec_actions & MMALOMX_ACTION_PENDING_DISABLE)
|
||||
{
|
||||
mmal_port_disable(port->mmal);
|
||||
|
||||
/* If there was a port format changed event, we need to make sure
|
||||
* the new format has been committed */
|
||||
if (port->format_changed)
|
||||
{
|
||||
status = mmal_port_format_commit(port->mmal);
|
||||
if (status != MMAL_SUCCESS)
|
||||
LOG_WARN("could not commit new format (%i)", status);
|
||||
port->format_changed = MMAL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
if (exec_actions & MMALOMX_ACTION_PENDING_ENABLE)
|
||||
{
|
||||
status = mmal_port_enable(port->mmal, mmalomx_buffer_cb_io);
|
||||
if (status == MMAL_SUCCESS)
|
||||
status = mmal_pool_resize(port->pool, port->mmal->buffer_num, 0);
|
||||
if (status != MMAL_SUCCESS)
|
||||
mmalomx_callback_event_handler(component, OMX_EventError, mmalil_error_to_omx(status), 0, NULL);
|
||||
/* FIXME: we're still going to generate a cmd complete. Not sure if that's an issue. */
|
||||
}
|
||||
|
||||
MMALOMX_LOCK_PORT(component, port);
|
||||
|
||||
port->actions &= ~exec_actions;
|
||||
if ((port->actions & MMALOMX_ACTION_CHECK_ALLOCATED) && port->populated)
|
||||
port->actions &= ~MMALOMX_ACTION_CHECK_ALLOCATED;
|
||||
if ((port->actions & MMALOMX_ACTION_CHECK_DEALLOCATED) && !port->buffers)
|
||||
port->actions &= ~MMALOMX_ACTION_CHECK_DEALLOCATED;
|
||||
if ((port->actions & MMALOMX_ACTION_CHECK_FLUSHED) && !port->buffers_in_transit)
|
||||
port->actions &= ~MMALOMX_ACTION_CHECK_FLUSHED;
|
||||
exec_actions = port->actions;
|
||||
|
||||
if (port->actions == MMALOMX_ACTION_NOTIFY_FLUSH ||
|
||||
port->actions == MMALOMX_ACTION_NOTIFY_ENABLE ||
|
||||
port->actions == MMALOMX_ACTION_NOTIFY_DISABLE)
|
||||
port->actions = 0; /* We're done */
|
||||
|
||||
MMALOMX_UNLOCK_PORT(component, port);
|
||||
|
||||
if (exec_actions == MMALOMX_ACTION_NOTIFY_FLUSH)
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete,
|
||||
OMX_CommandFlush, port->index, NULL);
|
||||
else if (exec_actions == MMALOMX_ACTION_NOTIFY_ENABLE)
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete,
|
||||
OMX_CommandPortEnable, port->index, NULL);
|
||||
else if (exec_actions == MMALOMX_ACTION_NOTIFY_DISABLE)
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete,
|
||||
OMX_CommandPortDisable, port->index, NULL);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void mmalomx_commands_actions_check(MMALOMX_COMPONENT_T *component)
|
||||
{
|
||||
uint32_t actions_left = 0;
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
mmalomx_commands_check_port_actions(component, &component->ports[i]);
|
||||
|
||||
MMALOMX_LOCK(component);
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
actions_left |= component->ports[i].actions;
|
||||
|
||||
if (!actions_left && component->state_transition)
|
||||
{
|
||||
component->state = state_transition_table[component->state_transition].request;
|
||||
component->state_transition = 0;
|
||||
actions_left = MMALOMX_ACTION_NOTIFY_STATE;
|
||||
}
|
||||
MMALOMX_UNLOCK(component);
|
||||
|
||||
if (actions_left == MMALOMX_ACTION_NOTIFY_STATE)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete,
|
||||
OMX_CommandStateSet, component->state, NULL);
|
||||
actions_left = 0;
|
||||
}
|
||||
|
||||
/* If we're not currently processing a command, we can start processing
|
||||
* the next one. */
|
||||
if (!actions_left)
|
||||
mmalomx_commands_actions_next(component);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void mmalomx_commands_actions_signal(MMALOMX_COMPONENT_T *component)
|
||||
{
|
||||
if (component->cmd_thread_used)
|
||||
vcos_semaphore_post(&component->cmd_sema);
|
||||
else
|
||||
mmalomx_commands_actions_check(component);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_state_set(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_STATETYPE state)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = (MMALOMX_COMPONENT_T *)hComponent;
|
||||
unsigned int i, transition;
|
||||
|
||||
if (component->state == state)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventError, OMX_ErrorSameState, 0, NULL);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/* We're asked to transition to StateInvalid */
|
||||
if (state == OMX_StateInvalid)
|
||||
{
|
||||
component->state = state;
|
||||
mmalomx_callback_event_handler(component, OMX_EventError, OMX_ErrorInvalidState, 0, NULL);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/* Commands are being queued so we should never get into that state */
|
||||
vcos_assert(!component->state_transition);
|
||||
|
||||
/* Check the transition is valid */
|
||||
transition = mmalomx_state_transition_get(component->state, state);
|
||||
if (!transition)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventError, OMX_ErrorIncorrectStateTransition, 0, NULL);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/* Special case for transition in and out of Executing */
|
||||
if (state == OMX_StateExecuting || component->state == OMX_StateExecuting)
|
||||
{
|
||||
MMAL_STATUS_T status;
|
||||
|
||||
if (state == OMX_StateExecuting)
|
||||
status = mmal_component_enable(component->mmal);
|
||||
else
|
||||
status = mmal_component_disable(component->mmal);
|
||||
|
||||
if (status != MMAL_SUCCESS)
|
||||
{
|
||||
LOG_ERROR("could not %s %s", state == OMX_StateExecuting ? "enable" : "disable", component->name);
|
||||
mmalomx_callback_event_handler(component, OMX_EventError, mmalil_error_to_omx(status), 0, NULL);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
}
|
||||
|
||||
MMALOMX_LOCK(component);
|
||||
component->state_transition = transition;
|
||||
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
{
|
||||
if (!component->ports[i].enabled)
|
||||
continue;
|
||||
|
||||
MMALOMX_LOCK_PORT(component, component->ports + i);
|
||||
component->ports[i].actions = state_transition_table[transition].actions;
|
||||
|
||||
/* If we're transitionning from Idle to Loaded we'd rather do a flush first
|
||||
* to avoid the cmd thread to block for too long (mmal_disable is a
|
||||
* blocking call). */
|
||||
if (state_transition_table[transition].state == OMX_StateIdle &&
|
||||
state_transition_table[transition].request == OMX_StateLoaded &&
|
||||
component->cmd_thread_used)
|
||||
component->ports[i].actions |= MMALOMX_ACTION_FLUSH|MMALOMX_ACTION_CHECK_FLUSHED;
|
||||
MMALOMX_UNLOCK_PORT(component, component->ports + i);
|
||||
}
|
||||
MMALOMX_UNLOCK(component);
|
||||
|
||||
mmalomx_commands_actions_check(component);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_port_mark(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex,
|
||||
OMX_PTR *pCmdData)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = (MMALOMX_COMPONENT_T *)hComponent;
|
||||
OMX_MARKTYPE *mark = (OMX_MARKTYPE *)pCmdData;
|
||||
MMALOMX_PORT_T *port;
|
||||
|
||||
if (nPortIndex >= component->ports_num)
|
||||
return OMX_ErrorBadPortIndex;
|
||||
port = &component->ports[nPortIndex];
|
||||
|
||||
if (port->marks_num == MAX_MARKS_NUM)
|
||||
return OMX_ErrorInsufficientResources;
|
||||
|
||||
port->marks[(port->marks_first + port->marks_num) % MAX_MARKS_NUM] = *mark;
|
||||
port->marks_num++;
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_port_flush(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = (MMALOMX_COMPONENT_T *)hComponent;
|
||||
|
||||
MMALOMX_LOCK_PORT(component, &component->ports[nPortIndex]);
|
||||
component->ports[nPortIndex].actions =
|
||||
MMALOMX_ACTION_FLUSH|MMALOMX_ACTION_CHECK_FLUSHED|MMALOMX_ACTION_NOTIFY_FLUSH;
|
||||
MMALOMX_UNLOCK_PORT(component, &component->ports[nPortIndex]);
|
||||
|
||||
mmalomx_commands_actions_check(component);
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_port_enable(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = (MMALOMX_COMPONENT_T *)hComponent;
|
||||
component->ports[nPortIndex].enabled = MMAL_TRUE;
|
||||
|
||||
if (component->state == OMX_StateLoaded ||
|
||||
component->state == OMX_StateWaitForResources)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete, OMX_CommandPortEnable, nPortIndex, NULL);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
MMALOMX_LOCK_PORT(component, &component->ports[nPortIndex]);
|
||||
component->ports[nPortIndex].actions =
|
||||
MMALOMX_ACTION_CHECK_ALLOCATED|MMALOMX_ACTION_ENABLE|MMALOMX_ACTION_NOTIFY_ENABLE;
|
||||
MMALOMX_UNLOCK_PORT(component, &component->ports[nPortIndex]);
|
||||
|
||||
mmalomx_commands_actions_check(component);
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_port_disable(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex)
|
||||
{
|
||||
MMALOMX_COMPONENT_T *component = (MMALOMX_COMPONENT_T *)hComponent;
|
||||
component->ports[nPortIndex].enabled = MMAL_FALSE;
|
||||
|
||||
if (component->state == OMX_StateLoaded ||
|
||||
component->state == OMX_StateWaitForResources)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete, OMX_CommandPortDisable, nPortIndex, NULL);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
MMALOMX_LOCK_PORT(component, &component->ports[nPortIndex]);
|
||||
component->ports[nPortIndex].actions =
|
||||
MMALOMX_ACTION_DISABLE|MMALOMX_ACTION_CHECK_DEALLOCATED|MMALOMX_ACTION_NOTIFY_DISABLE;
|
||||
if (component->cmd_thread_used)
|
||||
component->ports[nPortIndex].actions |=
|
||||
MMALOMX_ACTION_FLUSH|MMALOMX_ACTION_CHECK_FLUSHED;
|
||||
MMALOMX_UNLOCK_PORT(component, &component->ports[nPortIndex]);
|
||||
|
||||
mmalomx_commands_actions_check(component);
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_queue(
|
||||
MMALOMX_COMPONENT_T *component,
|
||||
OMX_U32 arg1, OMX_U32 arg2)
|
||||
{
|
||||
MMAL_BUFFER_HEADER_T *cmd = mmal_queue_get(component->cmd_pool->queue);
|
||||
|
||||
if (!vcos_verify(cmd))
|
||||
{
|
||||
LOG_ERROR("command queue too small");
|
||||
return OMX_ErrorInsufficientResources;
|
||||
}
|
||||
|
||||
cmd->cmd = arg1;
|
||||
cmd->offset = arg2;
|
||||
mmal_queue_put(component->cmd_queue, cmd);
|
||||
|
||||
mmalomx_commands_actions_signal(component);
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_command_dequeue(
|
||||
MMALOMX_COMPONENT_T *component,
|
||||
OMX_U32 *arg1, OMX_U32 *arg2)
|
||||
{
|
||||
MMAL_BUFFER_HEADER_T *cmd = mmal_queue_get(component->cmd_queue);
|
||||
if (!cmd)
|
||||
return OMX_ErrorNoMore;
|
||||
|
||||
*arg1 = cmd->cmd;
|
||||
*arg2 = cmd->offset;
|
||||
mmal_buffer_header_release(cmd);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void mmalomx_commands_actions_next(MMALOMX_COMPONENT_T *component)
|
||||
{
|
||||
OMX_ERRORTYPE status = OMX_ErrorNone;
|
||||
OMX_COMMANDTYPE cmd;
|
||||
OMX_U32 arg1, arg2, nParam1;
|
||||
unsigned int i;
|
||||
|
||||
status = mmalomx_command_dequeue(component, &arg1, &arg2);
|
||||
if (status != OMX_ErrorNone)
|
||||
return;
|
||||
|
||||
cmd = (OMX_COMMANDTYPE)arg1;
|
||||
nParam1 = arg2;
|
||||
|
||||
if (cmd == OMX_CommandStateSet)
|
||||
{
|
||||
mmalomx_command_state_set((OMX_HANDLETYPE)&component->omx, nParam1);
|
||||
}
|
||||
else if (cmd == OMX_CommandFlush)
|
||||
{
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
if (i == nParam1 || nParam1 == OMX_ALL)
|
||||
mmalomx_command_port_flush((OMX_HANDLETYPE)&component->omx, i);
|
||||
}
|
||||
else if (cmd == OMX_CommandPortEnable)
|
||||
{
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
if (i == nParam1 || nParam1 == OMX_ALL)
|
||||
mmalomx_command_port_enable((OMX_HANDLETYPE)&component->omx, i);
|
||||
}
|
||||
else if (cmd == OMX_CommandPortDisable)
|
||||
{
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
if (i == nParam1 || nParam1 == OMX_ALL)
|
||||
mmalomx_command_port_disable((OMX_HANDLETYPE)&component->omx, i);
|
||||
}
|
||||
}
|
||||
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Commands related functions
|
||||
*/
|
||||
|
||||
OMX_ERRORTYPE mmalomx_command_state_set(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_STATETYPE state);
|
||||
|
||||
OMX_ERRORTYPE mmalomx_command_port_mark(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex,
|
||||
OMX_PTR *pCmdData);
|
||||
|
||||
OMX_ERRORTYPE mmalomx_command_port_flush(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex);
|
||||
|
||||
OMX_ERRORTYPE mmalomx_command_port_enable(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex);
|
||||
|
||||
OMX_ERRORTYPE mmalomx_command_port_disable(
|
||||
OMX_HANDLETYPE hComponent,
|
||||
OMX_U32 nPortIndex);
|
||||
|
||||
#define MMALOMX_ACTION_ENABLE 0x01
|
||||
#define MMALOMX_ACTION_DISABLE 0x02
|
||||
#define MMALOMX_ACTION_FLUSH 0x04
|
||||
|
||||
#define MMALOMX_ACTION_PENDING_ENABLE 0x010
|
||||
#define MMALOMX_ACTION_PENDING_DISABLE 0x020
|
||||
#define MMALOMX_ACTION_PENDING_FLUSH 0x040
|
||||
|
||||
#define MMALOMX_ACTION_CHECK_ALLOCATED 0x0100
|
||||
#define MMALOMX_ACTION_CHECK_DEALLOCATED 0x0200
|
||||
#define MMALOMX_ACTION_CHECK_FLUSHED 0x0400
|
||||
|
||||
#define MMALOMX_ACTION_NOTIFY_DISABLE 0x1000
|
||||
#define MMALOMX_ACTION_NOTIFY_ENABLE 0x2000
|
||||
#define MMALOMX_ACTION_NOTIFY_FLUSH 0x4000
|
||||
#define MMALOMX_ACTION_NOTIFY_STATE 0x8000
|
||||
|
||||
#define MMALOMX_COMMAND_EXIT 0
|
||||
#define MMALOMX_COMMAND_STATE_SET 1
|
||||
#define MMALOMX_COMMAND_PORT_MARK 2
|
||||
#define MMALOMX_COMMAND_PORT_FLUSH 3
|
||||
#define MMALOMX_COMMAND_PORT_ENABLE 4
|
||||
#define MMALOMX_COMMAND_PORT_DISABLE 5
|
||||
|
||||
OMX_ERRORTYPE mmalomx_command_queue(
|
||||
MMALOMX_COMPONENT_T *component, OMX_U32 arg1, OMX_U32 arg2);
|
||||
OMX_ERRORTYPE mmalomx_command_dequeue(
|
||||
MMALOMX_COMPONENT_T *component, OMX_U32 *arg1, OMX_U32 *arg2);
|
||||
|
||||
void mmalomx_commands_actions_check(MMALOMX_COMPONENT_T *component);
|
||||
void mmalomx_commands_actions_signal(MMALOMX_COMPONENT_T *component);
|
||||
void mmalomx_commands_actions_next(MMALOMX_COMPONENT_T *component);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+176
@@ -0,0 +1,176 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Core.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Component.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Video.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Audio.h"
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Broadcom.h"
|
||||
#include "mmalomx_logging.h"
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_util_params.h"
|
||||
#include "interface/vcos/vcos_types.h"
|
||||
|
||||
VCOS_LOG_CAT_T mmalomx_log_category;
|
||||
static VCOS_LOG_LEVEL_T mmalomx_log_level = VCOS_LOG_ERROR;
|
||||
|
||||
#define MMALOMX_SAT(a,b,c) ((a)<(b)?(a):(a)>(c)?(c):(a))
|
||||
|
||||
void mmalomx_logging_init(void)
|
||||
{
|
||||
vcos_log_set_level(VCOS_LOG_CATEGORY, mmalomx_log_level);
|
||||
vcos_log_register("mmalomx", VCOS_LOG_CATEGORY);
|
||||
}
|
||||
|
||||
void mmalomx_logging_deinit(void)
|
||||
{
|
||||
mmalomx_log_level = mmalomx_log_category.level;
|
||||
vcos_log_unregister(VCOS_LOG_CATEGORY);
|
||||
}
|
||||
|
||||
const char *mmalomx_param_to_string(OMX_INDEXTYPE param)
|
||||
{
|
||||
static const struct {
|
||||
const char *string;
|
||||
const OMX_INDEXTYPE param;
|
||||
} param_to_names[] =
|
||||
{
|
||||
{"OMX_IndexParamPriorityMgmt", OMX_IndexParamPriorityMgmt},
|
||||
{"OMX_IndexParamAudioInit", OMX_IndexParamAudioInit},
|
||||
{"OMX_IndexParamImageInit", OMX_IndexParamImageInit},
|
||||
{"OMX_IndexParamVideoInit", OMX_IndexParamVideoInit},
|
||||
{"OMX_IndexParamOtherInit", OMX_IndexParamOtherInit},
|
||||
{"OMX_IndexParamPortDefinition", OMX_IndexParamPortDefinition},
|
||||
{"OMX_IndexParamCompBufferSupplier", OMX_IndexParamCompBufferSupplier},
|
||||
{"OMX_IndexParamAudioPortFormat", OMX_IndexParamAudioPortFormat},
|
||||
{"OMX_IndexParamVideoPortFormat", OMX_IndexParamVideoPortFormat},
|
||||
{"OMX_IndexParamImagePortFormat", OMX_IndexParamImagePortFormat},
|
||||
{"OMX_IndexParamOtherPortFormat", OMX_IndexParamOtherPortFormat},
|
||||
{"OMX_IndexParamAudioPcm", OMX_IndexParamAudioPcm},
|
||||
{"OMX_IndexParamAudioAac", OMX_IndexParamAudioAac},
|
||||
{"OMX_IndexParamAudioMp3", OMX_IndexParamAudioMp3},
|
||||
{"OMX_IndexParamVideoMpeg2", OMX_IndexParamVideoMpeg2},
|
||||
{"OMX_IndexParamVideoMpeg4", OMX_IndexParamVideoMpeg4},
|
||||
{"OMX_IndexParamVideoWmv", OMX_IndexParamVideoWmv},
|
||||
{"OMX_IndexParamVideoRv", OMX_IndexParamVideoRv},
|
||||
{"OMX_IndexParamVideoAvc", OMX_IndexParamVideoAvc},
|
||||
{"OMX_IndexParamVideoH263", OMX_IndexParamVideoH263},
|
||||
{"OMX_IndexParamStandardComponentRole", OMX_IndexParamStandardComponentRole},
|
||||
{"OMX_IndexParamContentURI", OMX_IndexParamContentURI},
|
||||
{"OMX_IndexParamCommonSensorMode", OMX_IndexParamCommonSensorMode},
|
||||
{"OMX_IndexConfigCommonWhiteBalance", OMX_IndexConfigCommonWhiteBalance},
|
||||
{"OMX_IndexConfigCommonDigitalZoom", OMX_IndexConfigCommonDigitalZoom},
|
||||
{"OMX_IndexConfigCommonExposureValue", OMX_IndexConfigCommonExposureValue},
|
||||
{"OMX_IndexConfigCapturing", OMX_IndexConfigCapturing},
|
||||
{"OMX_IndexAutoPauseAfterCapture", OMX_IndexAutoPauseAfterCapture},
|
||||
{"OMX_IndexConfigCommonRotate", OMX_IndexConfigCommonRotate},
|
||||
{"OMX_IndexConfigCommonMirror", OMX_IndexConfigCommonMirror},
|
||||
{"OMX_IndexConfigCommonScale", OMX_IndexConfigCommonScale},
|
||||
{"OMX_IndexConfigCommonInputCrop", OMX_IndexConfigCommonInputCrop},
|
||||
{"OMX_IndexConfigCommonOutputCrop", OMX_IndexConfigCommonOutputCrop},
|
||||
{"OMX_IndexParamNumAvailableStreams", OMX_IndexParamNumAvailableStreams},
|
||||
{"OMX_IndexParamActiveStream", OMX_IndexParamActiveStream},
|
||||
{"OMX_IndexParamVideoBitrate", OMX_IndexParamVideoBitrate},
|
||||
{"OMX_IndexParamVideoProfileLevelQuerySupported", OMX_IndexParamVideoProfileLevelQuerySupported},
|
||||
|
||||
{"OMX_IndexParam unknown", (OMX_INDEXTYPE)0}
|
||||
};
|
||||
const char *name = mmalomx_parameter_name_omx((uint32_t)param);
|
||||
int i;
|
||||
|
||||
if (name)
|
||||
return name;
|
||||
|
||||
for(i = 0; param_to_names[i].param &&
|
||||
param_to_names[i].param != param; i++);
|
||||
|
||||
return param_to_names[i].string;
|
||||
}
|
||||
|
||||
const char *mmalomx_cmd_to_string(OMX_COMMANDTYPE cmd)
|
||||
{
|
||||
static const char *names[] = {
|
||||
"OMX_CommandStateSet", "OMX_CommandFlush", "OMX_CommandPortDisable",
|
||||
"OMX_CommandPortEnable", "OMX_CommandMarkBuffer", "OMX_Command unknown"
|
||||
};
|
||||
|
||||
return names[MMALOMX_SAT((int)cmd, 0, (int)vcos_countof(names)-1)];
|
||||
}
|
||||
|
||||
const char *mmalomx_state_to_string(OMX_STATETYPE state)
|
||||
{
|
||||
static const char *names[] = {
|
||||
"OMX_StateInvalid", "OMX_StateLoaded", "OMX_StateIdle",
|
||||
"OMX_StateExecuting", "OMX_StatePause", "OMX_StateWaitForResources",
|
||||
"OMX_State unknown"
|
||||
};
|
||||
|
||||
return names[MMALOMX_SAT((int)state, 0, (int)vcos_countof(names)-1)];
|
||||
}
|
||||
|
||||
const char *mmalomx_event_to_string(OMX_EVENTTYPE event)
|
||||
{
|
||||
static const char *names[] = {
|
||||
"OMX_EventCmdComplete", "OMX_EventError", "OMX_EventMark",
|
||||
"OMX_EventPortSettingsChanged", "OMX_EventBufferFlag",
|
||||
"OMX_EventResourcesAcquired", "OMX_EventComponentResumed",
|
||||
"OMX_EventDynamicResourcesAvailable", "OMX_EventPortFormatDetected",
|
||||
"OMX_Event unknown"
|
||||
};
|
||||
|
||||
return names[MMALOMX_SAT((int)event, 0, (int)vcos_countof(names)-1)];
|
||||
}
|
||||
|
||||
const char *mmalomx_error_to_string(OMX_ERRORTYPE error)
|
||||
{
|
||||
static const char *names[] = {
|
||||
"OMX_ErrorInsufficientResources", "OMX_ErrorUndefined",
|
||||
"OMX_ErrorInvalidComponentName", "OMX_ErrorComponentNotFound",
|
||||
"OMX_ErrorInvalidComponent", "OMX_ErrorBadParameter",
|
||||
"OMX_ErrorNotImplemented", "OMX_ErrorUnderflow",
|
||||
"OMX_ErrorOverflow", "OMX_ErrorHardware", "OMX_ErrorInvalidState",
|
||||
"OMX_ErrorStreamCorrupt", "OMX_ErrorPortsNotCompatible",
|
||||
"OMX_ErrorResourcesLost", "OMX_ErrorNoMore", "OMX_ErrorVersionMismatch",
|
||||
"OMX_ErrorNotReady", "OMX_ErrorTimeout", "OMX_ErrorSameState",
|
||||
"OMX_ErrorResourcesPreempted", "OMX_ErrorPortUnresponsiveDuringAllocation",
|
||||
"OMX_ErrorPortUnresponsiveDuringDeallocation",
|
||||
"OMX_ErrorPortUnresponsiveDuringStop", "OMX_ErrorIncorrectStateTransition",
|
||||
"OMX_ErrorIncorrectStateOperation", "OMX_ErrorUnsupportedSetting",
|
||||
"OMX_ErrorUnsupportedIndex", "OMX_ErrorBadPortIndex",
|
||||
"OMX_ErrorPortUnpopulated", "OMX_ErrorComponentSuspended",
|
||||
"OMX_ErrorDynamicResourcesUnavailable", "OMX_ErrorMbErrorsInFrame",
|
||||
"OMX_ErrorFormatNotDetected", "OMX_ErrorContentPipeOpenFailed",
|
||||
"OMX_ErrorContentPipeCreationFailed", "OMX_ErrorSeperateTablesUsed",
|
||||
"OMX_ErrorTunnelingUnsupported",
|
||||
"OMX_Error unkown"
|
||||
};
|
||||
|
||||
if(error == OMX_ErrorNone) return "OMX_ErrorNone";
|
||||
|
||||
error -= OMX_ErrorInsufficientResources;
|
||||
return names[MMALOMX_SAT((int)error, 0, (int)vcos_countof(names)-1)];
|
||||
}
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Logging functions
|
||||
*/
|
||||
|
||||
#include "mmal_common.h"
|
||||
#include "interface/vcos/vcos_logging.h"
|
||||
|
||||
#define VCOS_LOG_CATEGORY (&mmalomx_log_category)
|
||||
extern VCOS_LOG_CAT_T mmalomx_log_category;
|
||||
#include <mmal_logging.h>
|
||||
|
||||
void mmalomx_logging_init(void);
|
||||
void mmalomx_logging_deinit(void);
|
||||
|
||||
const char *mmalomx_param_to_string(OMX_INDEXTYPE param);
|
||||
const char *mmalomx_cmd_to_string(OMX_COMMANDTYPE cmd);
|
||||
const char *mmalomx_state_to_string(OMX_STATETYPE state);
|
||||
const char *mmalomx_event_to_string(OMX_EVENTTYPE event);
|
||||
const char *mmalomx_error_to_string(OMX_ERRORTYPE error);
|
||||
@@ -0,0 +1,101 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Marking related functions
|
||||
*
|
||||
* Note that we do not support buffer marks properly other than for conformance
|
||||
* testing. For input ports, we just move the mark over to the output port.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_buffer.h"
|
||||
#include "mmalomx_marks.h"
|
||||
#include "mmalomx_commands.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
#define MMALOMX_GET_MARK(port, mark) \
|
||||
mark = &port->marks[port->marks_first]; \
|
||||
port->marks_num--; \
|
||||
port->marks_first = ++port->marks_first == MAX_MARKS_NUM ? 0 : port->marks_first
|
||||
#define MMALOMX_PUT_MARK(port, mark) \
|
||||
port->marks[(port->marks_first + port->marks_num) % MAX_MARKS_NUM] = *mark; \
|
||||
port->marks_num++;
|
||||
|
||||
void mmalomx_mark_process_incoming(MMALOMX_COMPONENT_T *component,
|
||||
MMALOMX_PORT_T *port, OMX_BUFFERHEADERTYPE *omx_buffer)
|
||||
{
|
||||
/* Tag buffers with OMX marks */
|
||||
if (!omx_buffer->hMarkTargetComponent && port->marks_num > 0 &&
|
||||
port->direction == OMX_DirInput)
|
||||
{
|
||||
OMX_MARKTYPE *mark;
|
||||
MMALOMX_GET_MARK(port, mark);
|
||||
omx_buffer->hMarkTargetComponent = mark->hMarkTargetComponent;
|
||||
omx_buffer->pMarkData = mark->pMarkData;
|
||||
|
||||
mmalomx_callback_event_handler(component, OMX_EventCmdComplete,
|
||||
OMX_CommandMarkBuffer, port->index, NULL);
|
||||
}
|
||||
/* We do not support buffer marks properly other than for conformance testing.
|
||||
* For input ports, we just move the mark over to the output port. */
|
||||
if (port->direction == OMX_DirInput && omx_buffer->hMarkTargetComponent)
|
||||
{
|
||||
OMX_MARKTYPE mark = {omx_buffer->hMarkTargetComponent, omx_buffer->pMarkData};
|
||||
unsigned int i;
|
||||
for (i = 0; i < component->ports_num; i++)
|
||||
{
|
||||
if (component->ports[i].direction != OMX_DirOutput ||
|
||||
component->ports[i].marks_num >= MAX_MARKS_NUM)
|
||||
continue;
|
||||
|
||||
MMALOMX_PUT_MARK((&component->ports[i]), (&mark));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void mmalomx_mark_process_outgoing(MMALOMX_COMPONENT_T *component,
|
||||
MMALOMX_PORT_T *port, OMX_BUFFERHEADERTYPE *omx_buffer)
|
||||
{
|
||||
/* Tag buffers with OMX marks */
|
||||
if (port->direction == OMX_DirOutput &&
|
||||
!omx_buffer->hMarkTargetComponent && port->marks_num)
|
||||
{
|
||||
OMX_MARKTYPE *mark;
|
||||
MMALOMX_GET_MARK(port, mark);
|
||||
omx_buffer->hMarkTargetComponent = mark->hMarkTargetComponent;
|
||||
omx_buffer->pMarkData = mark->pMarkData;
|
||||
}
|
||||
/* Check if we need to trigger a Mark event */
|
||||
if (omx_buffer->hMarkTargetComponent &&
|
||||
omx_buffer->hMarkTargetComponent == (OMX_HANDLETYPE)&component->omx)
|
||||
{
|
||||
mmalomx_callback_event_handler(component, OMX_EventMark, 0, 0, omx_buffer->pMarkData);
|
||||
omx_buffer->hMarkTargetComponent = NULL;
|
||||
omx_buffer->pMarkData = NULL;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Marking related functions
|
||||
*/
|
||||
|
||||
void mmalomx_mark_process_incoming(MMALOMX_COMPONENT_T *component,
|
||||
MMALOMX_PORT_T *port, OMX_BUFFERHEADERTYPE *omx_buffer);
|
||||
void mmalomx_mark_process_outgoing(MMALOMX_COMPONENT_T *component,
|
||||
MMALOMX_PORT_T *port, OMX_BUFFERHEADERTYPE *omx_buffer);
|
||||
|
||||
+578
@@ -0,0 +1,578 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Broadcom.h"
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_parameters.h"
|
||||
#include "mmalomx_util_params.h"
|
||||
#include "mmalomx_roles.h"
|
||||
#include "mmalomx_registry.h"
|
||||
#include "mmalomx_logging.h"
|
||||
#include <util/mmal_util.h>
|
||||
#include <util/mmal_util_params.h>
|
||||
#include <util/mmal_util_rational.h>
|
||||
|
||||
#define PARAM_GET_PORT(port, component, index) \
|
||||
if (index >= component->ports_num) return OMX_ErrorBadPortIndex; \
|
||||
port = &component->ports[index]
|
||||
|
||||
#define MMALOMX_PARAM_GENERIC_MAX 256
|
||||
|
||||
/** A structure capable of holding any OMX parameter that contains a port */
|
||||
typedef struct MMALOMX_PARAM_OMX_GENERIC_T
|
||||
{
|
||||
MMALOMX_PARAM_OMX_HEADER_T header;
|
||||
uint8_t data[MMALOMX_PARAM_GENERIC_MAX];
|
||||
} MMALOMX_PARAM_OMX_GENERIC_T;
|
||||
|
||||
/** A structure capable of holding any OMX parameter that doesn't contain a port */
|
||||
typedef struct MMALOMX_PARAM_OMX_GENERIC_PORTLESS_T
|
||||
{
|
||||
MMALOMX_PARAM_OMX_HEADER_PORTLESS_T hdr;
|
||||
uint8_t data[MMALOMX_PARAM_GENERIC_MAX];
|
||||
} MMALOMX_PARAM_OMX_GENERIC_PORTLESS_T;
|
||||
|
||||
/** A structure capable of holding any MMAL parameter */
|
||||
typedef struct MMALOMX_PARAM_MMAL_GENERIC_T
|
||||
{
|
||||
MMAL_PARAMETER_HEADER_T header;
|
||||
uint8_t data[MMALOMX_PARAM_GENERIC_MAX];
|
||||
} MMALOMX_PARAM_MMAL_GENERIC_T;
|
||||
|
||||
static OMX_ERRORTYPE mmalomx_parameter_set_xlat(MMALOMX_COMPONENT_T *component,
|
||||
OMX_INDEXTYPE nParamIndex, OMX_PTR pParam)
|
||||
{
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat = mmalomx_find_parameter_from_omx_id(nParamIndex);
|
||||
MMALOMX_PARAM_OMX_HEADER_T *omx_header = (MMALOMX_PARAM_OMX_HEADER_T *)pParam;
|
||||
MMALOMX_PARAM_MMAL_GENERIC_T mmal_generic;
|
||||
MMAL_PARAMETER_HEADER_T *mmal_header = &mmal_generic.header;
|
||||
MMAL_PORT_T *mmal_port = component->mmal->control;
|
||||
MMAL_STATUS_T status;
|
||||
|
||||
if (!xlat)
|
||||
{
|
||||
LOG_DEBUG("no translation for omx id 0x%08x", nParamIndex);
|
||||
return OMX_ErrorNotImplemented;
|
||||
}
|
||||
|
||||
if (!xlat->portless)
|
||||
{
|
||||
if (omx_header->nSize < sizeof(*omx_header))
|
||||
return OMX_ErrorBadParameter;
|
||||
if (omx_header->nPortIndex >= component->ports_num)
|
||||
return OMX_ErrorBadPortIndex;
|
||||
mmal_port = component->ports[omx_header->nPortIndex].mmal;
|
||||
}
|
||||
|
||||
if (omx_header->nSize < xlat->omx_size)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
/* Handle the direct case first */
|
||||
if (xlat->type == MMALOMX_PARAM_TRANSLATION_TYPE_DIRECT)
|
||||
{
|
||||
mmal_header = (MMAL_PARAMETER_HEADER_T *)(((uint8_t *)pParam) + (xlat->portless ? 0 : 4));
|
||||
mmal_generic.header = *mmal_header;
|
||||
mmal_header->size = omx_header->nSize - (xlat->portless ? 0 : 4);
|
||||
mmal_header->id = xlat->mmal_id;
|
||||
status = mmal_port_parameter_set(mmal_port, mmal_header);
|
||||
*mmal_header = mmal_generic.header;
|
||||
return mmalil_error_to_omx(status);
|
||||
}
|
||||
|
||||
if (!xlat->fn.generic && !xlat->fn.simple)
|
||||
{
|
||||
// FIXME
|
||||
return OMX_ErrorNotImplemented;
|
||||
}
|
||||
|
||||
// FIXME: check size of mmal_generic is sufficient
|
||||
if (sizeof(mmal_generic) < xlat->mmal_size)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
mmal_header->size = xlat->mmal_size;
|
||||
mmal_header->id = xlat->mmal_id;
|
||||
if (xlat->fn.generic)
|
||||
status = xlat->fn.generic(MMALOMX_PARAM_MAPPING_TO_MMAL, xlat, mmal_header, pParam, mmal_port);
|
||||
else
|
||||
status = xlat->fn.simple(MMALOMX_PARAM_MAPPING_TO_MMAL, mmal_header, pParam);
|
||||
if (status != MMAL_SUCCESS)
|
||||
goto error;
|
||||
|
||||
status = mmal_port_parameter_set(mmal_port, mmal_header);
|
||||
|
||||
error:
|
||||
return mmalil_error_to_omx(status);
|
||||
}
|
||||
|
||||
static OMX_ERRORTYPE mmalomx_parameter_get_xlat(MMALOMX_COMPONENT_T *component,
|
||||
OMX_INDEXTYPE nParamIndex, OMX_PTR pParam)
|
||||
{
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat = mmalomx_find_parameter_from_omx_id(nParamIndex);
|
||||
MMALOMX_PARAM_OMX_HEADER_T *omx_header = (MMALOMX_PARAM_OMX_HEADER_T *)pParam;
|
||||
MMALOMX_PARAM_MMAL_GENERIC_T mmal_generic;
|
||||
MMAL_PARAMETER_HEADER_T *mmal_header = &mmal_generic.header;
|
||||
MMAL_PORT_T *mmal_port = component->mmal->control;
|
||||
MMAL_STATUS_T status = MMAL_SUCCESS;
|
||||
|
||||
if (!xlat)
|
||||
return OMX_ErrorNotImplemented;
|
||||
|
||||
if (!xlat->portless)
|
||||
{
|
||||
if (omx_header->nSize < sizeof(*omx_header))
|
||||
return OMX_ErrorBadParameter;
|
||||
if (omx_header->nPortIndex >= component->ports_num)
|
||||
return OMX_ErrorBadPortIndex;
|
||||
mmal_port = component->ports[omx_header->nPortIndex].mmal;
|
||||
}
|
||||
|
||||
if (omx_header->nSize < xlat->omx_size)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
/* Handle the direct case first */
|
||||
if (xlat->type == MMALOMX_PARAM_TRANSLATION_TYPE_DIRECT)
|
||||
{
|
||||
OMX_U32 size;
|
||||
mmal_header = (MMAL_PARAMETER_HEADER_T *)(((uint8_t *)pParam) + (xlat->portless ? 0 : 4));
|
||||
mmal_generic.header = *mmal_header;
|
||||
mmal_header->size = omx_header->nSize - (xlat->portless ? 0 : 4);
|
||||
mmal_header->id = xlat->mmal_id;
|
||||
status = mmal_port_parameter_get(mmal_port, mmal_header);
|
||||
*mmal_header = mmal_generic.header;
|
||||
size = mmal_header->size + (xlat->portless ? 0 : 4);
|
||||
omx_header->nSize = size;
|
||||
return mmalil_error_to_omx(status);
|
||||
}
|
||||
|
||||
if (xlat->fn.custom)
|
||||
{
|
||||
return xlat->fn.custom(MMALOMX_PARAM_MAPPING_TO_OMX, xlat, mmal_header,
|
||||
pParam, mmal_port);
|
||||
}
|
||||
|
||||
if (xlat->fn.list)
|
||||
{
|
||||
OMX_U32 index, elements;
|
||||
mmal_header = mmal_port_parameter_alloc_get(mmal_port, xlat->mmal_id,
|
||||
10*xlat->mmal_size, &status);
|
||||
if (!mmal_header)
|
||||
return OMX_ErrorInsufficientResources;
|
||||
|
||||
/* Check we're not requesting too much */
|
||||
index = *(OMX_U32 *)(((uint8_t *)pParam) + xlat->xlat_enum_num);
|
||||
elements = (mmal_header->size - sizeof(MMAL_PARAMETER_HEADER_T)) /
|
||||
(xlat->mmal_size - sizeof(MMAL_PARAMETER_HEADER_T));
|
||||
if (index >= elements)
|
||||
{
|
||||
vcos_free(mmal_header);
|
||||
return OMX_ErrorNoMore;
|
||||
}
|
||||
status = xlat->fn.list(MMALOMX_PARAM_MAPPING_TO_OMX, xlat, index, mmal_header, pParam, mmal_port);
|
||||
vcos_free(mmal_header);
|
||||
return mmalil_error_to_omx(status);
|
||||
}
|
||||
|
||||
if (!xlat->fn.generic && !xlat->fn.simple)
|
||||
{
|
||||
// FIXME
|
||||
return OMX_ErrorNotImplemented;
|
||||
}
|
||||
|
||||
// FIXME: check size of mmal_generic is sufficient
|
||||
if (sizeof(mmal_generic) < xlat->mmal_size)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
mmal_header->size = xlat->mmal_size;
|
||||
mmal_header->id = xlat->mmal_id;
|
||||
|
||||
if (xlat->double_translation)
|
||||
{
|
||||
if (xlat->fn.generic)
|
||||
status = xlat->fn.generic(MMALOMX_PARAM_MAPPING_TO_MMAL, xlat, mmal_header, pParam, mmal_port);
|
||||
else
|
||||
status = xlat->fn.simple(MMALOMX_PARAM_MAPPING_TO_MMAL, mmal_header, pParam);
|
||||
}
|
||||
if (status != MMAL_SUCCESS)
|
||||
goto error;
|
||||
|
||||
status = mmal_port_parameter_get(mmal_port, mmal_header);
|
||||
if (status != MMAL_SUCCESS)
|
||||
goto error;
|
||||
|
||||
if (xlat->fn.generic)
|
||||
status = xlat->fn.generic(MMALOMX_PARAM_MAPPING_TO_OMX, xlat, mmal_header, pParam, mmal_port);
|
||||
else
|
||||
status = xlat->fn.simple(MMALOMX_PARAM_MAPPING_TO_OMX, mmal_header, pParam);
|
||||
|
||||
error:
|
||||
return mmalil_error_to_omx(status);
|
||||
}
|
||||
|
||||
OMX_ERRORTYPE mmalomx_parameter_extension_index_get(OMX_STRING cParameterName,
|
||||
OMX_INDEXTYPE *pIndex)
|
||||
{
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat;
|
||||
MMAL_BOOL_T config = MMAL_FALSE;
|
||||
unsigned int i = 0;
|
||||
|
||||
/* Check we're dealing with our extensions */
|
||||
if (!vcos_strncasecmp(cParameterName, MMALOMX_COMPONENT_PREFIX, sizeof(MMALOMX_COMPONENT_PREFIX)-1))
|
||||
return OMX_ErrorNotImplemented;
|
||||
cParameterName += sizeof(MMALOMX_COMPONENT_PREFIX)-1;
|
||||
|
||||
/* Check if we're dealing with a config or param */
|
||||
if (!vcos_strncasecmp(cParameterName, "index.config.", sizeof("index.config.")-1))
|
||||
config = MMAL_TRUE;
|
||||
if (!config && vcos_strncasecmp(cParameterName, "index.param.", sizeof("index.param.")-1))
|
||||
return OMX_ErrorNotImplemented;
|
||||
if (config)
|
||||
cParameterName += sizeof("index.config.")-1;
|
||||
else
|
||||
cParameterName += sizeof("index.param.")-1;
|
||||
|
||||
/* Loop through all the */
|
||||
while ((xlat = mmalomx_find_parameter_enum(i++)) != NULL)
|
||||
{
|
||||
const char *name = xlat->omx_name;
|
||||
|
||||
/* We only report vendor extensions */
|
||||
if (xlat->omx_id < OMX_IndexVendorStartUnused)
|
||||
continue;
|
||||
|
||||
/* Strip out the standard prefix */
|
||||
if (config)
|
||||
{
|
||||
if (!strncmp(name, "OMX_IndexConfigBrcm", sizeof("OMX_IndexConfigBrcm")-1))
|
||||
name += sizeof("OMX_IndexConfigBrcm")-1;
|
||||
else if (!strncmp(name, "OMX_IndexConfig", sizeof("OMX_IndexConfig")-1))
|
||||
name += sizeof("OMX_IndexConfig")-1;
|
||||
else continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!strncmp(name, "OMX_IndexParamBrcm", sizeof("OMX_IndexParamBrcm")-1))
|
||||
name += sizeof("OMX_IndexParamBrcm")-1;
|
||||
else if (!strncmp(name, "OMX_IndexParam", sizeof("OMX_IndexParam")-1))
|
||||
name += sizeof("OMX_IndexParam")-1;
|
||||
else continue;
|
||||
}
|
||||
|
||||
/* Compare the last part of the name */
|
||||
if (!vcos_strcasecmp(name, cParameterName))
|
||||
{
|
||||
*pIndex = xlat->omx_id;
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
}
|
||||
|
||||
return OMX_ErrorNotImplemented;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
static OMX_ERRORTYPE mmalomx_get_video_param(MMALOMX_PORT_T *port,
|
||||
uint32_t *profile, uint32_t *level, uint32_t *intraperiod)
|
||||
{
|
||||
MMAL_PARAMETER_VIDEO_PROFILE_T mmal_param = {{MMAL_PARAMETER_PROFILE, sizeof(mmal_param)},
|
||||
{{(MMAL_VIDEO_PROFILE_T)0, (MMAL_VIDEO_LEVEL_T)0}}};
|
||||
|
||||
*profile = *level = *intraperiod = 0;
|
||||
|
||||
mmal_port_parameter_get_uint32(port->mmal, MMAL_PARAMETER_INTRAPERIOD, intraperiod);
|
||||
|
||||
if (mmal_port_parameter_get(port->mmal, &mmal_param.hdr) == MMAL_SUCCESS)
|
||||
{
|
||||
*profile = mmalil_video_profile_to_omx(mmal_param.profile[0].profile);
|
||||
*level = mmalil_video_level_to_omx(mmal_param.profile[0].level);
|
||||
}
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_parameter_get(MMALOMX_COMPONENT_T *component,
|
||||
OMX_INDEXTYPE nParamIndex, OMX_PTR pParam)
|
||||
{
|
||||
MMALOMX_PORT_T *port = NULL;
|
||||
|
||||
switch(nParamIndex)
|
||||
{
|
||||
/* All OMX_IndexParamVideo parameters are only partially implemented
|
||||
* and we try and use sensible hard-coded values for the rest. */
|
||||
case OMX_IndexParamVideoAvc:
|
||||
{
|
||||
OMX_VIDEO_PARAM_AVCTYPE *param = (OMX_VIDEO_PARAM_AVCTYPE *)pParam;
|
||||
uint32_t profile, level, intraperiod;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
if (param->nSize < sizeof(*param))
|
||||
return OMX_ErrorBadParameter;
|
||||
memset(¶m->nSliceHeaderSpacing, 0,
|
||||
param->nSize - offsetof(OMX_VIDEO_PARAM_AVCTYPE, nSliceHeaderSpacing));
|
||||
|
||||
mmalomx_get_video_param(port, &profile, &level, &intraperiod);
|
||||
param->eProfile = (OMX_VIDEO_AVCPROFILETYPE)profile;
|
||||
param->eLevel = (OMX_VIDEO_AVCLEVELTYPE)level;
|
||||
param->nPFrames = intraperiod - 1;
|
||||
param->bUseHadamard = OMX_TRUE;
|
||||
param->nRefFrames = 1;
|
||||
param->nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
|
||||
param->bFrameMBsOnly = OMX_TRUE;
|
||||
if (param->eProfile != OMX_VIDEO_AVCProfileBaseline)
|
||||
param->bEntropyCodingCABAC = OMX_TRUE;
|
||||
param->eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
|
||||
}
|
||||
return OMX_ErrorNone;
|
||||
case OMX_IndexParamVideoMpeg4:
|
||||
{
|
||||
OMX_VIDEO_PARAM_MPEG4TYPE *param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pParam;
|
||||
uint32_t profile, level, intraperiod;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
if (param->nSize < sizeof(*param))
|
||||
return OMX_ErrorBadParameter;
|
||||
memset(¶m->nSliceHeaderSpacing, 0,
|
||||
param->nSize - offsetof(OMX_VIDEO_PARAM_MPEG4TYPE, nSliceHeaderSpacing));
|
||||
|
||||
mmalomx_get_video_param(port, &profile, &level, &intraperiod);
|
||||
param->eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)profile;
|
||||
param->eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)level;
|
||||
param->nPFrames = intraperiod - 1;
|
||||
param->bACPred = OMX_TRUE;
|
||||
param->nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
|
||||
}
|
||||
return OMX_ErrorNone;
|
||||
case OMX_IndexParamVideoH263:
|
||||
{
|
||||
OMX_VIDEO_PARAM_H263TYPE *param = (OMX_VIDEO_PARAM_H263TYPE *)pParam;
|
||||
uint32_t profile, level, intraperiod;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
if (param->nSize < sizeof(*param))
|
||||
return OMX_ErrorBadParameter;
|
||||
memset(¶m->nPFrames, 0,
|
||||
param->nSize - offsetof(OMX_VIDEO_PARAM_H263TYPE, nPFrames));
|
||||
|
||||
mmalomx_get_video_param(port, &profile, &level, &intraperiod);
|
||||
param->eProfile = (OMX_VIDEO_H263PROFILETYPE)profile;
|
||||
param->eLevel = (OMX_VIDEO_H263LEVELTYPE)level;
|
||||
param->nPFrames = intraperiod - 1;
|
||||
param->nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
|
||||
}
|
||||
return OMX_ErrorNone;
|
||||
case OMX_IndexParamVideoMpeg2:
|
||||
case OMX_IndexParamVideoWmv:
|
||||
case OMX_IndexParamVideoRv:
|
||||
{
|
||||
OMX_FORMAT_PARAM_TYPE *param = (OMX_FORMAT_PARAM_TYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->common.nPortIndex);
|
||||
OMX_U32 offset = offsetof(OMX_PARAM_U32TYPE, nU32);
|
||||
if (param->common.nSize > sizeof(port->format_param) ||
|
||||
param->common.nSize < offset)
|
||||
return OMX_ErrorBadParameter;
|
||||
memcpy(¶m->common.nU32, &port->format_param.common.nU32,
|
||||
param->common.nSize - offset);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexParamAudioPcm:
|
||||
case OMX_IndexParamAudioAac:
|
||||
case OMX_IndexParamAudioMp3:
|
||||
case OMX_IndexParamAudioDdp:
|
||||
{
|
||||
OMX_FORMAT_PARAM_TYPE *param = (OMX_FORMAT_PARAM_TYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->common.nPortIndex);
|
||||
OMX_U32 offset = offsetof(OMX_PARAM_U32TYPE, nU32);
|
||||
if (param->common.nSize > sizeof(port->format_param) ||
|
||||
param->common.nSize < offset)
|
||||
return OMX_ErrorBadParameter;
|
||||
memcpy(¶m->common.nU32, &port->format_param.common.nU32,
|
||||
param->common.nSize - offset);
|
||||
mmalil_format_to_omx_audio_param(param, NULL, port->mmal->format);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexParamBrcmPixelAspectRatio:
|
||||
{
|
||||
OMX_CONFIG_POINTTYPE *param = (OMX_CONFIG_POINTTYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
param->nX = port->mmal->format->es->video.par.num;
|
||||
param->nY = port->mmal->format->es->video.par.den;
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexParamColorSpace:
|
||||
{
|
||||
OMX_PARAM_COLORSPACETYPE *param = (OMX_PARAM_COLORSPACETYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
param->eColorSpace = mmalil_color_space_to_omx(port->mmal->format->es->video.color_space);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexConfigCommonOutputCrop:
|
||||
{
|
||||
OMX_CONFIG_RECTTYPE *param = (OMX_CONFIG_RECTTYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
param->nLeft = port->mmal->format->es->video.crop.x;
|
||||
param->nTop = port->mmal->format->es->video.crop.y;
|
||||
param->nWidth = port->mmal->format->es->video.width;
|
||||
if (port->mmal->format->es->video.crop.width)
|
||||
param->nWidth = port->mmal->format->es->video.crop.width;
|
||||
param->nHeight = port->mmal->format->es->video.height;
|
||||
if (port->mmal->format->es->video.crop.height)
|
||||
param->nHeight = port->mmal->format->es->video.crop.height;
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexConfigCommonScale:
|
||||
{
|
||||
OMX_CONFIG_SCALEFACTORTYPE *param = (OMX_CONFIG_SCALEFACTORTYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
param->xWidth = param->xHeight = 1<<16;
|
||||
if (port->mmal->format->es->video.par.num &&
|
||||
port->mmal->format->es->video.par.den)
|
||||
param->xWidth = mmal_rational_to_fixed_16_16(port->mmal->format->es->video.par);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
default:
|
||||
return mmalomx_parameter_get_xlat(component, nParamIndex, pParam);
|
||||
}
|
||||
|
||||
return OMX_ErrorNotImplemented;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
static OMX_ERRORTYPE mmalomx_set_video_param(MMALOMX_PORT_T *port,
|
||||
uint32_t profile, uint32_t level, uint32_t intraperiod)
|
||||
{
|
||||
MMAL_PARAMETER_VIDEO_PROFILE_T mmal_param = {{MMAL_PARAMETER_PROFILE, sizeof(mmal_param)},
|
||||
{{(MMAL_VIDEO_PROFILE_T)0, (MMAL_VIDEO_LEVEL_T)0}}};
|
||||
OMX_VIDEO_CODINGTYPE coding =
|
||||
mmalil_encoding_to_omx_video_coding(port->mmal->format->encoding);
|
||||
|
||||
if (mmal_port_parameter_set_uint32(port->mmal, MMAL_PARAMETER_INTRAPERIOD,
|
||||
intraperiod) != MMAL_SUCCESS)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
mmal_param.profile[0].profile = (MMAL_VIDEO_PROFILE_T)
|
||||
mmalil_omx_video_profile_to_mmal(profile, coding);
|
||||
mmal_param.profile[0].level = (MMAL_VIDEO_LEVEL_T)
|
||||
mmalil_omx_video_level_to_mmal(level, coding);
|
||||
if (mmal_port_parameter_set(port->mmal, &mmal_param.hdr) != MMAL_SUCCESS)
|
||||
return OMX_ErrorBadParameter;
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
OMX_ERRORTYPE mmalomx_parameter_set(MMALOMX_COMPONENT_T *component,
|
||||
OMX_INDEXTYPE nParamIndex, OMX_PTR pParam)
|
||||
{
|
||||
MMALOMX_PORT_T *port = NULL;
|
||||
|
||||
switch(nParamIndex)
|
||||
{
|
||||
/* All OMX_IndexParamVideo parameters are only partially implemented */
|
||||
case OMX_IndexParamVideoAvc:
|
||||
{
|
||||
OMX_VIDEO_PARAM_AVCTYPE *param = (OMX_VIDEO_PARAM_AVCTYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
if (param->nSize < sizeof(*param))
|
||||
return OMX_ErrorBadParameter;
|
||||
return mmalomx_set_video_param(port, param->eProfile, param->eLevel,
|
||||
param->nPFrames + 1);
|
||||
}
|
||||
case OMX_IndexParamVideoMpeg4:
|
||||
{
|
||||
OMX_VIDEO_PARAM_MPEG4TYPE *param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
if (param->nSize < sizeof(*param))
|
||||
return OMX_ErrorBadParameter;
|
||||
return mmalomx_set_video_param(port, param->eProfile, param->eLevel,
|
||||
param->nPFrames + 1);
|
||||
}
|
||||
case OMX_IndexParamVideoH263:
|
||||
{
|
||||
OMX_VIDEO_PARAM_H263TYPE *param = (OMX_VIDEO_PARAM_H263TYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
if (param->nSize < sizeof(*param))
|
||||
return OMX_ErrorBadParameter;
|
||||
return mmalomx_set_video_param(port, param->eProfile, param->eLevel,
|
||||
param->nPFrames + 1);
|
||||
}
|
||||
case OMX_IndexParamVideoMpeg2:
|
||||
case OMX_IndexParamVideoWmv:
|
||||
case OMX_IndexParamVideoRv:
|
||||
{
|
||||
OMX_FORMAT_PARAM_TYPE *param = (OMX_FORMAT_PARAM_TYPE *)pParam;
|
||||
OMX_U32 offset = offsetof(OMX_PARAM_U32TYPE, nU32);
|
||||
PARAM_GET_PORT(port, component, param->common.nPortIndex);
|
||||
if (param->common.nSize > sizeof(port->format_param) ||
|
||||
param->common.nSize < offset)
|
||||
return OMX_ErrorBadParameter;
|
||||
memcpy(&port->format_param.common.nU32, ¶m->common.nU32,
|
||||
param->common.nSize - offset);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexParamAudioPcm:
|
||||
case OMX_IndexParamAudioAac:
|
||||
case OMX_IndexParamAudioMp3:
|
||||
case OMX_IndexParamAudioDdp:
|
||||
{
|
||||
OMX_FORMAT_PARAM_TYPE *param = (OMX_FORMAT_PARAM_TYPE *)pParam;
|
||||
OMX_U32 offset = offsetof(OMX_PARAM_U32TYPE, nU32);
|
||||
PARAM_GET_PORT(port, component, param->common.nPortIndex);
|
||||
if (param->common.nSize > sizeof(port->format_param) ||
|
||||
param->common.nSize < offset)
|
||||
return OMX_ErrorBadParameter;
|
||||
memcpy(&port->format_param.common.nU32, ¶m->common.nU32,
|
||||
param->common.nSize - offset);
|
||||
mmalil_omx_audio_param_to_format(port->mmal->format,
|
||||
mmalil_omx_audio_param_index_to_coding(nParamIndex), param);
|
||||
mmal_port_format_commit(port->mmal);
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
case OMX_IndexParamBrcmPixelAspectRatio:
|
||||
{
|
||||
OMX_CONFIG_POINTTYPE *param = (OMX_CONFIG_POINTTYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
port->mmal->format->es->video.par.num = param->nX;
|
||||
port->mmal->format->es->video.par.den = param->nY;
|
||||
mmal_rational_simplify(&port->mmal->format->es->video.par);
|
||||
return mmal_port_format_commit(port->mmal);
|
||||
}
|
||||
case OMX_IndexParamColorSpace:
|
||||
{
|
||||
OMX_PARAM_COLORSPACETYPE *param = (OMX_PARAM_COLORSPACETYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
port->mmal->format->es->video.color_space = mmalil_omx_color_space_to_mmal(param->eColorSpace);
|
||||
return mmal_port_format_commit(port->mmal);
|
||||
}
|
||||
case OMX_IndexParamBrcmVideoCroppingDisable:
|
||||
{
|
||||
OMX_CONFIG_PORTBOOLEANTYPE *param = (OMX_CONFIG_PORTBOOLEANTYPE *)pParam;
|
||||
PARAM_GET_PORT(port, component, param->nPortIndex);
|
||||
port->no_cropping = param->bEnabled;
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
default:
|
||||
return mmalomx_parameter_set_xlat(component, nParamIndex, pParam);
|
||||
}
|
||||
|
||||
return OMX_ErrorNotImplemented;
|
||||
}
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Parameters related functions
|
||||
*/
|
||||
|
||||
OMX_ERRORTYPE mmalomx_parameter_get(MMALOMX_COMPONENT_T *component,
|
||||
OMX_INDEXTYPE nParamIndex, OMX_PTR pParam);
|
||||
OMX_ERRORTYPE mmalomx_parameter_set(MMALOMX_COMPONENT_T *component,
|
||||
OMX_INDEXTYPE nParamIndex, OMX_PTR pParam);
|
||||
OMX_ERRORTYPE mmalomx_parameter_extension_index_get(OMX_STRING cParameterName,
|
||||
OMX_INDEXTYPE *pIndex);
|
||||
+159
@@ -0,0 +1,159 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_roles.h"
|
||||
#include "mmalomx_registry.h"
|
||||
#include "mmalomx_logging.h"
|
||||
#include <util/mmal_default_components.h>
|
||||
|
||||
#ifndef ENABLE_MMALOMX_AUDIO_HW_DECODER
|
||||
# define ENABLE_MMALOMX_AUDIO_HW_DECODER 0
|
||||
#endif
|
||||
#ifndef ENABLE_MMALOMX_AUDIO_SPDIF
|
||||
# define ENABLE_MMALOMX_AUDIO_SPDIF 1
|
||||
#endif
|
||||
|
||||
static const struct {
|
||||
const char *omx;
|
||||
const char *omx_prefix;
|
||||
const char *mmal;
|
||||
MMALOMX_ROLE_T roles[MMALOMX_ROLE_MAX];
|
||||
} mmalomx_components[] =
|
||||
{
|
||||
{"video.hw.decoder", 0, MMAL_COMPONENT_DEFAULT_VIDEO_DECODER,
|
||||
{MMALOMX_ROLE_VIDEO_DECODER_H263, MMALOMX_ROLE_VIDEO_DECODER_MPEG2,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_MPEG4, MMALOMX_ROLE_VIDEO_DECODER_AVC,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_WMV, MMALOMX_ROLE_VIDEO_DECODER_VPX,
|
||||
MMALOMX_ROLE_UNDEFINED}},
|
||||
{"video.hw.decoder.secure", 0, "drm_alloc.video_decode",
|
||||
{MMALOMX_ROLE_VIDEO_DECODER_H263, MMALOMX_ROLE_VIDEO_DECODER_MPEG2,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_MPEG4, MMALOMX_ROLE_VIDEO_DECODER_AVC,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_WMV, MMALOMX_ROLE_VIDEO_DECODER_VPX,
|
||||
MMALOMX_ROLE_UNDEFINED}},
|
||||
{"video.hw.decoder.divx_drm", 0, "aggregator.pipeline:divx_drm:vc.video_decode",
|
||||
{MMALOMX_ROLE_VIDEO_DECODER_MPEG4, MMALOMX_ROLE_UNDEFINED}},
|
||||
{"video.vpx.decoder", 0, "libvpx",
|
||||
{MMALOMX_ROLE_VIDEO_DECODER_VPX, MMALOMX_ROLE_UNDEFINED}},
|
||||
|
||||
{"video.hw.encoder", 0, MMAL_COMPONENT_DEFAULT_VIDEO_ENCODER,
|
||||
{MMALOMX_ROLE_VIDEO_ENCODER_H263, MMALOMX_ROLE_VIDEO_ENCODER_MPEG4,
|
||||
MMALOMX_ROLE_VIDEO_ENCODER_AVC, MMALOMX_ROLE_UNDEFINED}},
|
||||
|
||||
{"AIV.play", "", "aivplay",
|
||||
{MMALOMX_ROLE_AIV_PLAY_101, MMALOMX_ROLE_AIV_PLAY_AVCDDP, MMALOMX_ROLE_UNDEFINED}},
|
||||
{"AIV.play.avcddp", "", "aivplay.ddp",
|
||||
{MMALOMX_ROLE_AIV_PLAY_AVCDDP, MMALOMX_ROLE_AIV_PLAY_101, MMALOMX_ROLE_UNDEFINED}},
|
||||
|
||||
#if ENABLE_MMALOMX_AUDIO_HW_DECODER
|
||||
{"audio.hw.decoder", 0, "vc.ril.audio_decode",
|
||||
{MMALOMX_ROLE_AUDIO_DECODER_AAC, MMALOMX_ROLE_AUDIO_DECODER_MPGA_L1,
|
||||
MMALOMX_ROLE_AUDIO_DECODER_MPGA_L2, MMALOMX_ROLE_AUDIO_DECODER_MPGA_L3,
|
||||
MMALOMX_ROLE_AUDIO_DECODER_DDP, MMALOMX_ROLE_UNDEFINED}},
|
||||
#endif
|
||||
|
||||
#if ENABLE_MMALOMX_AUDIO_SPDIF
|
||||
{"audio.spdif", 0, "spdif",
|
||||
{MMALOMX_ROLE_AUDIO_DECODER_DDP, MMALOMX_ROLE_UNDEFINED}},
|
||||
#endif
|
||||
|
||||
{0, 0, 0, {MMALOMX_ROLE_UNDEFINED}}
|
||||
};
|
||||
|
||||
int mmalomx_registry_find_component(const char *name)
|
||||
{
|
||||
int i, prefix_size;
|
||||
const char *prefix;
|
||||
|
||||
for (i = 0; mmalomx_components[i].omx; i++)
|
||||
{
|
||||
/* Check the prefix first */
|
||||
prefix = mmalomx_components[i].omx_prefix;
|
||||
if (!prefix)
|
||||
prefix = MMALOMX_COMPONENT_PREFIX;
|
||||
prefix_size = strlen(prefix);
|
||||
if (strncmp(name, prefix, prefix_size))
|
||||
continue;
|
||||
|
||||
/* Check the rest of the name */
|
||||
if (!strcmp(name + prefix_size, mmalomx_components[i].omx))
|
||||
break;
|
||||
}
|
||||
|
||||
return mmalomx_components[i].mmal ? i : -1;
|
||||
}
|
||||
|
||||
const char *mmalomx_registry_component_mmal(int id)
|
||||
{
|
||||
if (id >= (int)MMAL_COUNTOF(mmalomx_components) || id < 0)
|
||||
id = MMAL_COUNTOF(mmalomx_components) - 1;
|
||||
|
||||
return mmalomx_components[id].mmal;
|
||||
}
|
||||
|
||||
MMALOMX_ROLE_T mmalomx_registry_component_roles(int id, unsigned int index)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
if (id >= (int)MMAL_COUNTOF(mmalomx_components) || id < 0)
|
||||
id = MMAL_COUNTOF(mmalomx_components) - 1;
|
||||
|
||||
for (i = 0; i < index; i++)
|
||||
if (mmalomx_components[id].roles[i] == MMALOMX_ROLE_UNDEFINED)
|
||||
break;
|
||||
|
||||
return mmalomx_components[id].roles[i];
|
||||
}
|
||||
|
||||
MMAL_BOOL_T mmalomx_registry_component_supports_role(int id, MMALOMX_ROLE_T role)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
if (id >= (int)MMAL_COUNTOF(mmalomx_components) || id < 0)
|
||||
id = MMAL_COUNTOF(mmalomx_components) - 1;
|
||||
|
||||
for (i = 0; mmalomx_components[id].roles[i] != MMALOMX_ROLE_UNDEFINED; i++)
|
||||
if (mmalomx_components[id].roles[i] == role)
|
||||
return MMAL_TRUE;
|
||||
|
||||
return MMAL_FALSE;
|
||||
}
|
||||
|
||||
const char *mmalomx_registry_component_name(int id, const char **prefix)
|
||||
{
|
||||
if (id >= (int)MMAL_COUNTOF(mmalomx_components) || id < 0)
|
||||
id = MMAL_COUNTOF(mmalomx_components) - 1;
|
||||
|
||||
if (prefix)
|
||||
{
|
||||
*prefix = mmalomx_components[id].omx_prefix;
|
||||
if (!*prefix)
|
||||
*prefix = MMALOMX_COMPONENT_PREFIX;
|
||||
}
|
||||
|
||||
return mmalomx_components[id].omx;
|
||||
}
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Registry of components
|
||||
*/
|
||||
|
||||
#define MMALOMX_COMPONENT_PREFIX "OMX.brcm."
|
||||
|
||||
int mmalomx_registry_find_component(const char *name);
|
||||
|
||||
const char *mmalomx_registry_component_mmal(int id);
|
||||
|
||||
MMALOMX_ROLE_T mmalomx_registry_component_roles(int id, unsigned int index);
|
||||
MMAL_BOOL_T mmalomx_registry_component_supports_role(int id, MMALOMX_ROLE_T role);
|
||||
|
||||
const char *mmalomx_registry_component_name(int index, const char **prefix);
|
||||
@@ -0,0 +1,210 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_roles.h"
|
||||
#include "mmalomx_registry.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
static const struct {
|
||||
const char *name;
|
||||
MMALOMX_ROLE_T role;
|
||||
} mmalomx_roles[] =
|
||||
{
|
||||
{"video_decoder.h263", MMALOMX_ROLE_VIDEO_DECODER_H263},
|
||||
{"video_decoder.mpeg4", MMALOMX_ROLE_VIDEO_DECODER_MPEG4},
|
||||
{"video_decoder.avc", MMALOMX_ROLE_VIDEO_DECODER_AVC},
|
||||
{"video_decoder.mpeg2", MMALOMX_ROLE_VIDEO_DECODER_MPEG2},
|
||||
{"video_decoder.wmv", MMALOMX_ROLE_VIDEO_DECODER_WMV},
|
||||
{"video_decoder.vpx", MMALOMX_ROLE_VIDEO_DECODER_VPX},
|
||||
|
||||
{"video_encoder.h263", MMALOMX_ROLE_VIDEO_ENCODER_H263},
|
||||
{"video_encoder.mpeg4", MMALOMX_ROLE_VIDEO_ENCODER_MPEG4},
|
||||
{"video_encoder.avc", MMALOMX_ROLE_VIDEO_ENCODER_AVC},
|
||||
|
||||
{"audio_decoder.aac", MMALOMX_ROLE_AUDIO_DECODER_AAC},
|
||||
{"audio_decoder.mp1", MMALOMX_ROLE_AUDIO_DECODER_MPGA_L1},
|
||||
{"audio_decoder.mp2", MMALOMX_ROLE_AUDIO_DECODER_MPGA_L2},
|
||||
{"audio_decoder.mp3", MMALOMX_ROLE_AUDIO_DECODER_MPGA_L3},
|
||||
{"audio_decoder.ddp", MMALOMX_ROLE_AUDIO_DECODER_DDP},
|
||||
|
||||
{"AIV.play.101", MMALOMX_ROLE_AIV_PLAY_101},
|
||||
{"play.avcddp", MMALOMX_ROLE_AIV_PLAY_AVCDDP},
|
||||
|
||||
{0, 0}
|
||||
};
|
||||
|
||||
const char *mmalomx_role_to_name(MMALOMX_ROLE_T role)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; mmalomx_roles[i].name; i++)
|
||||
if (mmalomx_roles[i].role == role)
|
||||
break;
|
||||
return mmalomx_roles[i].name;
|
||||
}
|
||||
|
||||
MMALOMX_ROLE_T mmalomx_role_from_name(const char *name)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; mmalomx_roles[i].name; i++)
|
||||
if (!strcmp(mmalomx_roles[i].name, name))
|
||||
break;
|
||||
return mmalomx_roles[i].role;
|
||||
}
|
||||
|
||||
static void mmalomx_format_encoding_from_role(MMALOMX_ROLE_T role,
|
||||
MMAL_FOURCC_T *encoding, MMAL_ES_TYPE_T *es_type, unsigned int *port)
|
||||
{
|
||||
switch (role)
|
||||
{
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_MPEG4:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_MPEG4:
|
||||
*encoding = MMAL_ENCODING_MP4V;
|
||||
*es_type = MMAL_ES_TYPE_VIDEO;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_AVC:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_AVC:
|
||||
*encoding = MMAL_ENCODING_H264;
|
||||
*es_type = MMAL_ES_TYPE_VIDEO;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_MPEG2:
|
||||
*encoding = MMAL_ENCODING_MP2V;
|
||||
*es_type = MMAL_ES_TYPE_VIDEO;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_WMV:
|
||||
*encoding = MMAL_ENCODING_WMV3;
|
||||
*es_type = MMAL_ES_TYPE_VIDEO;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_VPX:
|
||||
*encoding = MMAL_ENCODING_VP8;
|
||||
*es_type = MMAL_ES_TYPE_VIDEO;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_H263:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_H263:
|
||||
*encoding = MMAL_ENCODING_H263;
|
||||
*es_type = MMAL_ES_TYPE_VIDEO;
|
||||
break;
|
||||
case MMALOMX_ROLE_AUDIO_DECODER_AAC:
|
||||
*encoding = MMAL_ENCODING_MP4A;
|
||||
*es_type = MMAL_ES_TYPE_AUDIO;
|
||||
break;
|
||||
case MMALOMX_ROLE_AUDIO_DECODER_MPGA_L1:
|
||||
case MMALOMX_ROLE_AUDIO_DECODER_MPGA_L2:
|
||||
case MMALOMX_ROLE_AUDIO_DECODER_MPGA_L3:
|
||||
*encoding = MMAL_ENCODING_MPGA;
|
||||
*es_type = MMAL_ES_TYPE_AUDIO;
|
||||
break;
|
||||
|
||||
case MMALOMX_ROLE_AUDIO_DECODER_DDP:
|
||||
*encoding = MMAL_ENCODING_AC3;
|
||||
*es_type = MMAL_ES_TYPE_AUDIO;
|
||||
break;
|
||||
|
||||
default:
|
||||
*encoding = MMAL_ENCODING_UNKNOWN;
|
||||
*es_type = MMAL_ES_TYPE_UNKNOWN;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (role)
|
||||
{
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_H263:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_MPEG4:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_AVC:
|
||||
*port = 1;
|
||||
break;
|
||||
default:
|
||||
*port = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
OMX_ERRORTYPE mmalomx_role_set(MMALOMX_COMPONENT_T *component, const char *name)
|
||||
{
|
||||
const MMALOMX_ROLE_T role = mmalomx_role_from_name(name);
|
||||
MMAL_FOURCC_T encoding = MMAL_ENCODING_UNKNOWN;
|
||||
MMAL_ES_TYPE_T es_type = MMAL_ES_TYPE_UNKNOWN;
|
||||
unsigned int port;
|
||||
MMAL_ES_FORMAT_T *format;
|
||||
|
||||
if (!role || !mmalomx_registry_component_supports_role(component->registry_id, role))
|
||||
return OMX_ErrorUnsupportedSetting;
|
||||
|
||||
component->role = role;
|
||||
|
||||
mmalomx_format_encoding_from_role(role, &encoding, &es_type, &port);
|
||||
if (encoding == MMAL_ENCODING_UNKNOWN)
|
||||
return OMX_ErrorNone;
|
||||
|
||||
format = component->ports[port].mmal->format;
|
||||
format->type = es_type;
|
||||
format->encoding = encoding;
|
||||
format->bitrate = 64000;
|
||||
switch (es_type)
|
||||
{
|
||||
case MMAL_ES_TYPE_VIDEO:
|
||||
format->es->video.width = 176;
|
||||
format->es->video.height = 144;
|
||||
format->es->video.frame_rate.num = 15;
|
||||
format->es->video.frame_rate.den = 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (role)
|
||||
{
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_H263:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_H263:
|
||||
component->ports[port].format_param.h263.eProfile = OMX_VIDEO_H263ProfileBaseline;
|
||||
component->ports[port].format_param.h263.eLevel = OMX_VIDEO_H263Level10;
|
||||
component->ports[port].format_param.h263.bPLUSPTYPEAllowed = OMX_FALSE;
|
||||
component->ports[port].format_param.h263.bForceRoundingTypeToZero = OMX_TRUE;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_MPEG4:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_MPEG4:
|
||||
component->ports[port].format_param.mpeg4.eProfile = OMX_VIDEO_MPEG4ProfileSimple;
|
||||
component->ports[port].format_param.mpeg4.eLevel = OMX_VIDEO_MPEG4Level1;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_AVC:
|
||||
case MMALOMX_ROLE_VIDEO_ENCODER_AVC:
|
||||
component->ports[port].format_param.avc.eProfile = OMX_VIDEO_AVCProfileBaseline;
|
||||
component->ports[port].format_param.avc.eLevel = OMX_VIDEO_AVCLevel1;
|
||||
break;
|
||||
case MMALOMX_ROLE_VIDEO_DECODER_WMV:
|
||||
component->ports[port].format_param.wmv.eFormat = OMX_VIDEO_WMVFormat9;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (mmal_port_format_commit(component->ports[port].mmal) != MMAL_SUCCESS)
|
||||
LOG_ERROR("failed to commit format to %s for role %s",
|
||||
component->ports[port].mmal->name, name);
|
||||
|
||||
return OMX_ErrorNone;
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Role specific functions
|
||||
*/
|
||||
|
||||
#define MMALOMX_MAX_ROLES 16
|
||||
|
||||
typedef enum MMALOMX_ROLE_T {
|
||||
MMALOMX_ROLE_UNDEFINED = 0,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_H263,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_MPEG4,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_AVC,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_MPEG2,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_WMV,
|
||||
MMALOMX_ROLE_VIDEO_DECODER_VPX,
|
||||
|
||||
MMALOMX_ROLE_VIDEO_ENCODER_H263,
|
||||
MMALOMX_ROLE_VIDEO_ENCODER_MPEG4,
|
||||
MMALOMX_ROLE_VIDEO_ENCODER_AVC,
|
||||
|
||||
MMALOMX_ROLE_AUDIO_DECODER_AAC,
|
||||
MMALOMX_ROLE_AUDIO_DECODER_MPGA_L1,
|
||||
MMALOMX_ROLE_AUDIO_DECODER_MPGA_L2,
|
||||
MMALOMX_ROLE_AUDIO_DECODER_MPGA_L3,
|
||||
MMALOMX_ROLE_AUDIO_DECODER_DDP,
|
||||
|
||||
MMALOMX_ROLE_AIV_PLAY_101,
|
||||
MMALOMX_ROLE_AIV_PLAY_AVCDDP,
|
||||
|
||||
MMALOMX_ROLE_MAX
|
||||
} MMALOMX_ROLE_T;
|
||||
|
||||
const char *mmalomx_role_to_name(MMALOMX_ROLE_T role);
|
||||
MMALOMX_ROLE_T mmalomx_role_from_name(const char *name);
|
||||
OMX_ERRORTYPE mmalomx_role_set(struct MMALOMX_COMPONENT_T *component, const char *name);
|
||||
+193
@@ -0,0 +1,193 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Broadcom.h"
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_util_params.h"
|
||||
#include "mmalomx_util_params_common.h"
|
||||
|
||||
static const MMALOMX_PARAM_TRANSLATION_T *mmalomx_param_list[] = {
|
||||
mmalomx_param_xlator_audio, mmalomx_param_xlator_video,
|
||||
mmalomx_param_xlator_camera, mmalomx_param_xlator_misc};
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T *mmalomx_find_parameter_enum(unsigned int index)
|
||||
{
|
||||
unsigned int i, j;
|
||||
|
||||
for (i = 0; i < MMAL_COUNTOF(mmalomx_param_list); i++)
|
||||
{
|
||||
for (j = 0; mmalomx_param_list[i][j].mmal_id != MMAL_PARAMETER_UNUSED; j++)
|
||||
{
|
||||
if (!index--)
|
||||
break;
|
||||
}
|
||||
if (mmalomx_param_list[i][j].mmal_id != MMAL_PARAMETER_UNUSED)
|
||||
break;
|
||||
}
|
||||
|
||||
return i < MMAL_COUNTOF(mmalomx_param_list) ? &mmalomx_param_list[i][j] : NULL;
|
||||
}
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T *mmalomx_find_parameter_from_omx_id(uint32_t id)
|
||||
{
|
||||
unsigned int i, j;
|
||||
|
||||
for (i = 0; i < MMAL_COUNTOF(mmalomx_param_list); i++)
|
||||
{
|
||||
for (j = 0; mmalomx_param_list[i][j].mmal_id != MMAL_PARAMETER_UNUSED; j++)
|
||||
{
|
||||
if (mmalomx_param_list[i][j].omx_id == id)
|
||||
break;
|
||||
}
|
||||
if (mmalomx_param_list[i][j].mmal_id != MMAL_PARAMETER_UNUSED)
|
||||
break;
|
||||
}
|
||||
|
||||
return i < MMAL_COUNTOF(mmalomx_param_list) ? &mmalomx_param_list[i][j] : NULL;
|
||||
}
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T *mmalomx_find_parameter_from_mmal_id(uint32_t id)
|
||||
{
|
||||
unsigned int i, j;
|
||||
|
||||
for (i = 0; i < MMAL_COUNTOF(mmalomx_param_list); i++)
|
||||
{
|
||||
for (j = 0; mmalomx_param_list[i][j].mmal_id != MMAL_PARAMETER_UNUSED; j++)
|
||||
{
|
||||
if (mmalomx_param_list[i][j].mmal_id == id)
|
||||
break;
|
||||
}
|
||||
if (mmalomx_param_list[i][j].mmal_id != MMAL_PARAMETER_UNUSED)
|
||||
break;
|
||||
}
|
||||
|
||||
return i < MMAL_COUNTOF(mmalomx_param_list) ? &mmalomx_param_list[i][j] : NULL;
|
||||
}
|
||||
|
||||
const char *mmalomx_parameter_name_omx(uint32_t id)
|
||||
{
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat = mmalomx_find_parameter_from_omx_id(id);
|
||||
return xlat ? xlat->omx_name : 0;
|
||||
}
|
||||
|
||||
const char *mmalomx_parameter_name_mmal(uint32_t id)
|
||||
{
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat = mmalomx_find_parameter_from_mmal_id(id);
|
||||
return xlat ? xlat->mmal_name : 0;
|
||||
}
|
||||
|
||||
MMAL_STATUS_T mmalomx_param_mapping_generic(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port)
|
||||
{
|
||||
MMALOMX_PARAM_OMX_HEADER_T *omx_header = (MMALOMX_PARAM_OMX_HEADER_T *)omx_param;
|
||||
uint8_t *mmal_data = ((uint8_t *)mmal_param) + sizeof(MMAL_PARAMETER_HEADER_T);
|
||||
uint8_t *omx_data = ((uint8_t *)omx_param) + sizeof(MMALOMX_PARAM_OMX_HEADER_T);
|
||||
unsigned int size = mmal_param->size - sizeof(MMAL_PARAMETER_HEADER_T);
|
||||
MMAL_PARAM_UNUSED(mmal_port);
|
||||
|
||||
if (xlat->portless)
|
||||
omx_data -= sizeof(OMX_U32);
|
||||
|
||||
if (((uint8_t *)omx_param) + omx_header->nSize !=
|
||||
omx_data + size)
|
||||
{
|
||||
VCOS_ALERT("mmalomx_param_mapping_generic: mismatch between mmal and omx paramters for (%u)",
|
||||
(unsigned int)mmal_param->id);
|
||||
return MMAL_EINVAL;
|
||||
}
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
memcpy(mmal_data, omx_data, size);
|
||||
else
|
||||
memcpy(omx_data, mmal_data, size);
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
MMAL_STATUS_T mmalomx_param_enum_generic(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port)
|
||||
{
|
||||
uint32_t *mmal = (uint32_t *)(((uint8_t *)mmal_param) + sizeof(MMAL_PARAMETER_HEADER_T));
|
||||
uint32_t *omx = (uint32_t *)(((uint8_t *)omx_param) + sizeof(MMALOMX_PARAM_OMX_HEADER_T));
|
||||
unsigned int i = 0;
|
||||
MMAL_PARAM_UNUSED(mmal_port);
|
||||
|
||||
if (xlat->portless)
|
||||
omx -= 1;
|
||||
|
||||
/* Find translation entry in lookup table */
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
for (i = 0; i < xlat->xlat_enum_num && xlat->xlat_enum->omx != *omx; i++);
|
||||
else
|
||||
for (i = 0; i < xlat->xlat_enum_num && xlat->xlat_enum->mmal != *mmal; i++);
|
||||
|
||||
if (i == xlat->xlat_enum_num)
|
||||
{
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
VCOS_ALERT("mmalomx_param_enum_generic: omx enum value %u not supported", (unsigned int)*omx);
|
||||
else
|
||||
VCOS_ALERT("mmalomx_param_enum_generic: mmal enum value %u not supported", (unsigned int)*mmal);
|
||||
return MMAL_EINVAL;
|
||||
}
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
*mmal = xlat->xlat_enum[i].mmal;
|
||||
else
|
||||
*omx = xlat->xlat_enum[i].omx;
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
MMAL_STATUS_T mmalomx_param_rational_generic(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port)
|
||||
{
|
||||
MMAL_RATIONAL_T *mmal = (MMAL_RATIONAL_T *)(((uint8_t *)mmal_param) + sizeof(MMAL_PARAMETER_HEADER_T));
|
||||
int32_t *omx = (int32_t *)(((uint8_t *)omx_param) + sizeof(MMALOMX_PARAM_OMX_HEADER_T));
|
||||
MMAL_PARAM_UNUSED(mmal_port);
|
||||
|
||||
if (xlat->portless)
|
||||
omx -= 1;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->num = *omx;
|
||||
mmal->den = xlat->xlat_enum_num;
|
||||
mmal_rational_simplify(mmal);
|
||||
}
|
||||
else
|
||||
{
|
||||
mmal_rational_simplify(mmal);
|
||||
*omx = 0;
|
||||
if (mmal->den)
|
||||
*omx = mmal->num * xlat->xlat_enum_num / mmal->den;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Parameters related functions
|
||||
*/
|
||||
|
||||
#ifndef MMALOMX_UTIL_PARAMS_H
|
||||
#define MMALOMX_UTIL_PARAMS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** The structure that all OMX parameters containing a port start with */
|
||||
typedef struct MMALOMX_PARAM_OMX_HEADER_T
|
||||
{
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_U32 nPortIndex;
|
||||
} MMALOMX_PARAM_OMX_HEADER_T;
|
||||
|
||||
/** The structure that all OMX parameters without a port start with */
|
||||
typedef struct MMALOMX_PARAM_OMX_HEADER_PORTLESS_T
|
||||
{
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
} MMALOMX_PARAM_OMX_HEADER_PORTLESS_T;
|
||||
|
||||
typedef enum {
|
||||
MMALOMX_PARAM_MAPPING_TO_MMAL,
|
||||
MMALOMX_PARAM_MAPPING_TO_OMX
|
||||
} MMALOMX_PARAM_MAPPING_DIRECTION;
|
||||
|
||||
typedef struct MMALOMX_PARAM_ENUM_TRANSLATE_T {
|
||||
uint32_t mmal;
|
||||
uint32_t omx;
|
||||
} MMALOMX_PARAM_ENUM_TRANSLATE_T;
|
||||
|
||||
typedef enum MMALOMX_PARAM_TRANSLATION_TYPE_T {
|
||||
MMALOMX_PARAM_TRANSLATION_TYPE_NONE = 0,
|
||||
MMALOMX_PARAM_TRANSLATION_TYPE_SIMPLE,
|
||||
MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM,
|
||||
MMALOMX_PARAM_TRANSLATION_TYPE_DIRECT,
|
||||
} MMALOMX_PARAM_TRANSLATION_TYPE_T;
|
||||
|
||||
/** MMAL <-> OMX parameter translation information */
|
||||
typedef struct MMALOMX_PARAM_TRANSLATION_T
|
||||
{
|
||||
uint32_t mmal_id; /**< MMAL parameter id */
|
||||
uint32_t omx_id; /**< OpenMAX IL parameter index */
|
||||
unsigned int mmal_size:16;
|
||||
unsigned int omx_size:16;
|
||||
unsigned int portless:1;
|
||||
unsigned int double_translation:1;
|
||||
MMALOMX_PARAM_TRANSLATION_TYPE_T type:4;
|
||||
|
||||
struct {
|
||||
MMAL_STATUS_T (*simple)(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param);
|
||||
MMAL_STATUS_T (*generic)(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const struct MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port);
|
||||
MMAL_STATUS_T (*list)(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const struct MMALOMX_PARAM_TRANSLATION_T *xlat, unsigned int index,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port);
|
||||
MMAL_STATUS_T (*custom)(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const struct MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port);
|
||||
} fn;
|
||||
|
||||
const struct MMALOMX_PARAM_ENUM_TRANSLATE_T *xlat_enum;
|
||||
unsigned int xlat_enum_num;
|
||||
|
||||
const char *mmal_name; /**< MMAL parameter name */
|
||||
const char *omx_name; /**< OMX parameter name */
|
||||
|
||||
} MMALOMX_PARAM_TRANSLATION_T;
|
||||
|
||||
const char *mmalomx_parameter_name_omx(uint32_t id);
|
||||
const char *mmalomx_parameter_name_mmal(uint32_t id);
|
||||
const MMALOMX_PARAM_TRANSLATION_T *mmalomx_find_parameter_from_omx_id(uint32_t id);
|
||||
const MMALOMX_PARAM_TRANSLATION_T *mmalomx_find_parameter_from_mmal_id(uint32_t id);
|
||||
const MMALOMX_PARAM_TRANSLATION_T *mmalomx_find_parameter_enum(unsigned int index);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MMALOMX_UTIL_PARAMS_H */
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_util_params_common.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_audio[] = {
|
||||
MMALOMX_PARAM_TERMINATE()
|
||||
};
|
||||
+556
@@ -0,0 +1,556 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_util_params_common.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_awb_mode[] = {
|
||||
{MMAL_PARAM_AWBMODE_OFF, OMX_WhiteBalControlOff},
|
||||
{MMAL_PARAM_AWBMODE_AUTO, OMX_WhiteBalControlAuto},
|
||||
{MMAL_PARAM_AWBMODE_SUNLIGHT, OMX_WhiteBalControlSunLight},
|
||||
{MMAL_PARAM_AWBMODE_CLOUDY, OMX_WhiteBalControlCloudy},
|
||||
{MMAL_PARAM_AWBMODE_SHADE, OMX_WhiteBalControlShade},
|
||||
{MMAL_PARAM_AWBMODE_TUNGSTEN, OMX_WhiteBalControlTungsten},
|
||||
{MMAL_PARAM_AWBMODE_FLUORESCENT, OMX_WhiteBalControlFluorescent},
|
||||
{MMAL_PARAM_AWBMODE_INCANDESCENT,OMX_WhiteBalControlIncandescent},
|
||||
{MMAL_PARAM_AWBMODE_FLASH, OMX_WhiteBalControlFlash},
|
||||
{MMAL_PARAM_AWBMODE_HORIZON, OMX_WhiteBalControlHorizon},
|
||||
};
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_image_effect[] = {
|
||||
{MMAL_PARAM_IMAGEFX_NONE, OMX_ImageFilterNone},
|
||||
{MMAL_PARAM_IMAGEFX_NEGATIVE, OMX_ImageFilterNegative},
|
||||
{MMAL_PARAM_IMAGEFX_SOLARIZE, OMX_ImageFilterSolarize},
|
||||
{MMAL_PARAM_IMAGEFX_SKETCH, OMX_ImageFilterSketch},
|
||||
{MMAL_PARAM_IMAGEFX_DENOISE, OMX_ImageFilterNoise},
|
||||
{MMAL_PARAM_IMAGEFX_EMBOSS, OMX_ImageFilterEmboss},
|
||||
{MMAL_PARAM_IMAGEFX_OILPAINT, OMX_ImageFilterOilPaint},
|
||||
{MMAL_PARAM_IMAGEFX_HATCH, OMX_ImageFilterHatch},
|
||||
{MMAL_PARAM_IMAGEFX_GPEN, OMX_ImageFilterGpen},
|
||||
{MMAL_PARAM_IMAGEFX_PASTEL, OMX_ImageFilterPastel},
|
||||
{MMAL_PARAM_IMAGEFX_WATERCOLOUR, OMX_ImageFilterWatercolor},
|
||||
{MMAL_PARAM_IMAGEFX_FILM, OMX_ImageFilterFilm},
|
||||
{MMAL_PARAM_IMAGEFX_BLUR, OMX_ImageFilterBlur},
|
||||
{MMAL_PARAM_IMAGEFX_SATURATION, OMX_ImageFilterSaturation},
|
||||
{MMAL_PARAM_IMAGEFX_COLOURSWAP, OMX_ImageFilterColourSwap},
|
||||
{MMAL_PARAM_IMAGEFX_WASHEDOUT, OMX_ImageFilterWashedOut},
|
||||
{MMAL_PARAM_IMAGEFX_POSTERISE, OMX_ImageFilterPosterise},
|
||||
{MMAL_PARAM_IMAGEFX_COLOURPOINT, OMX_ImageFilterColourPoint},
|
||||
{MMAL_PARAM_IMAGEFX_COLOURBALANCE, OMX_ImageFilterColourBalance},
|
||||
{MMAL_PARAM_IMAGEFX_CARTOON, OMX_ImageFilterCartoon},
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_colour_effect(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_COLORENHANCEMENTTYPE *omx = (OMX_CONFIG_COLORENHANCEMENTTYPE *)omx_param;
|
||||
MMAL_PARAMETER_COLOURFX_T *mmal = (MMAL_PARAMETER_COLOURFX_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->enable = omx->bColorEnhancement;
|
||||
mmal->u = omx->nCustomizedU;
|
||||
mmal->v = omx->nCustomizedV;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->bColorEnhancement = mmal->enable;
|
||||
omx->nCustomizedU = mmal->u;
|
||||
omx->nCustomizedV = mmal->v;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_flicker_avoid[] = {
|
||||
{MMAL_PARAM_FLICKERAVOID_OFF, OMX_COMMONFLICKERCANCEL_OFF},
|
||||
{MMAL_PARAM_FLICKERAVOID_AUTO, OMX_COMMONFLICKERCANCEL_AUTO},
|
||||
{MMAL_PARAM_FLICKERAVOID_50HZ, OMX_COMMONFLICKERCANCEL_50},
|
||||
{MMAL_PARAM_FLICKERAVOID_60HZ, OMX_COMMONFLICKERCANCEL_60},
|
||||
};
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_flash[] = {
|
||||
{MMAL_PARAM_FLASH_OFF, OMX_IMAGE_FlashControlOff},
|
||||
{MMAL_PARAM_FLASH_AUTO, OMX_IMAGE_FlashControlAuto},
|
||||
{MMAL_PARAM_FLASH_ON, OMX_IMAGE_FlashControlOn},
|
||||
{MMAL_PARAM_FLASH_REDEYE, OMX_IMAGE_FlashControlRedEyeReduction},
|
||||
{MMAL_PARAM_FLASH_FILLIN, OMX_IMAGE_FlashControlFillin},
|
||||
{MMAL_PARAM_FLASH_TORCH, OMX_IMAGE_FlashControlTorch},
|
||||
};
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_redeye[] = {
|
||||
{MMAL_PARAM_REDEYE_OFF, OMX_RedEyeRemovalNone},
|
||||
{MMAL_PARAM_REDEYE_ON, OMX_RedEyeRemovalOn},
|
||||
{MMAL_PARAM_REDEYE_ON, OMX_RedEyeRemovalAuto},
|
||||
{MMAL_PARAM_REDEYE_SIMPLE, OMX_RedEyeRemovalSimple}
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_focus(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
static const struct MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_focus[] = {
|
||||
{MMAL_PARAM_FOCUS_AUTO, OMX_IMAGE_FocusControlAutoLock},
|
||||
{MMAL_PARAM_FOCUS_CAF, OMX_IMAGE_FocusControlAuto},
|
||||
{MMAL_PARAM_FOCUS_FIXED_INFINITY, OMX_IMAGE_FocusControlInfinityFixed},
|
||||
{MMAL_PARAM_FOCUS_FIXED_HYPERFOCAL, OMX_IMAGE_FocusControlHyperfocal},
|
||||
{MMAL_PARAM_FOCUS_FIXED_NEAR, OMX_IMAGE_FocusControlNearFixed},
|
||||
{MMAL_PARAM_FOCUS_FIXED_MACRO, OMX_IMAGE_FocusControlMacroFixed},
|
||||
{MMAL_PARAM_FOCUS_AUTO_MACRO, OMX_IMAGE_FocusControlAutoLockMacro},
|
||||
{MMAL_PARAM_FOCUS_AUTO_NEAR, OMX_IMAGE_FocusControlAutoLock},
|
||||
{MMAL_PARAM_FOCUS_CAF_NEAR, OMX_IMAGE_FocusControlAutoNear},
|
||||
{MMAL_PARAM_FOCUS_CAF_MACRO, OMX_IMAGE_FocusControlAutoMacro},
|
||||
{MMAL_PARAM_FOCUS_CAF_FAST, OMX_IMAGE_FocusControlAutoFast},
|
||||
{MMAL_PARAM_FOCUS_CAF_MACRO_FAST, OMX_IMAGE_FocusControlAutoMacroFast},
|
||||
{MMAL_PARAM_FOCUS_CAF_NEAR_FAST, OMX_IMAGE_FocusControlAutoNearFast},
|
||||
/* {MMAL_PARAM_FOCUS_EDOF, ???}, */
|
||||
};
|
||||
OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE *omx = (OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE *)omx_param;
|
||||
MMAL_PARAMETER_FOCUS_T *mmal = (MMAL_PARAMETER_FOCUS_T *)mmal_param;
|
||||
MMALOMX_PARAM_ENUM_FIND(struct MMALOMX_PARAM_ENUM_TRANSLATE_T, xlat_enum, mmalomx_param_enum_focus,
|
||||
dir, mmal->value, omx->eFocusControl);
|
||||
|
||||
if (!xlat_enum)
|
||||
return MMAL_EINVAL;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->value = xlat_enum->mmal;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->eFocusControl = xlat_enum->omx;
|
||||
omx->nFocusStepIndex = -1;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_mirror[] = {
|
||||
{MMAL_PARAM_MIRROR_NONE, OMX_MirrorNone},
|
||||
{MMAL_PARAM_MIRROR_VERTICAL, OMX_MirrorVertical},
|
||||
{MMAL_PARAM_MIRROR_HORIZONTAL, OMX_MirrorHorizontal},
|
||||
{MMAL_PARAM_MIRROR_BOTH, OMX_MirrorBoth}
|
||||
};
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_exposure_mode[] = {
|
||||
{MMAL_PARAM_EXPOSUREMODE_OFF, OMX_ExposureControlOff},
|
||||
{MMAL_PARAM_EXPOSUREMODE_AUTO, OMX_ExposureControlAuto},
|
||||
{MMAL_PARAM_EXPOSUREMODE_NIGHT, OMX_ExposureControlNight},
|
||||
{MMAL_PARAM_EXPOSUREMODE_NIGHTPREVIEW, OMX_ExposureControlNightWithPreview},
|
||||
{MMAL_PARAM_EXPOSUREMODE_BACKLIGHT, OMX_ExposureControlBackLight},
|
||||
{MMAL_PARAM_EXPOSUREMODE_SPOTLIGHT, OMX_ExposureControlSpotLight},
|
||||
{MMAL_PARAM_EXPOSUREMODE_SPORTS, OMX_ExposureControlSports},
|
||||
{MMAL_PARAM_EXPOSUREMODE_SNOW, OMX_ExposureControlSnow},
|
||||
{MMAL_PARAM_EXPOSUREMODE_BEACH, OMX_ExposureControlBeach},
|
||||
{MMAL_PARAM_EXPOSUREMODE_VERYLONG, OMX_ExposureControlVeryLong},
|
||||
{MMAL_PARAM_EXPOSUREMODE_FIXEDFPS, OMX_ExposureControlFixedFps},
|
||||
{MMAL_PARAM_EXPOSUREMODE_ANTISHAKE, OMX_ExposureControlAntishake},
|
||||
{MMAL_PARAM_EXPOSUREMODE_FIREWORKS, OMX_ExposureControlFireworks},
|
||||
};
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_capture_status[] = {
|
||||
{MMAL_PARAM_CAPTURE_STATUS_NOT_CAPTURING, OMX_NotCapturing},
|
||||
{MMAL_PARAM_CAPTURE_STATUS_CAPTURE_STARTED, OMX_CaptureStarted},
|
||||
{MMAL_PARAM_CAPTURE_STATUS_CAPTURE_ENDED, OMX_CaptureComplete},
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_face_track(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_face_track[] = {
|
||||
{MMAL_PARAM_FACE_DETECT_NONE, OMX_FaceDetectionControlNone},
|
||||
{MMAL_PARAM_FACE_DETECT_ON, OMX_FaceDetectionControlOn},
|
||||
};
|
||||
OMX_CONFIG_FACEDETECTIONCONTROLTYPE *omx = (OMX_CONFIG_FACEDETECTIONCONTROLTYPE *)omx_param;
|
||||
MMAL_PARAMETER_FACE_TRACK_T *mmal = (MMAL_PARAMETER_FACE_TRACK_T *)mmal_param;
|
||||
MMALOMX_PARAM_ENUM_FIND(MMALOMX_PARAM_ENUM_TRANSLATE_T, xenum, mmalomx_param_enum_face_track,
|
||||
dir, mmal->mode, omx->eMode);
|
||||
|
||||
if (!xenum)
|
||||
return MMAL_EINVAL;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->mode = xenum->mmal;
|
||||
mmal->maxRegions = omx->nMaxRegions;
|
||||
mmal->frames = omx->nFrames;
|
||||
mmal->quality = omx->nQuality;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->eMode = xenum->omx;
|
||||
omx->nMaxRegions = mmal->maxRegions;
|
||||
omx->nFrames = mmal->frames;
|
||||
omx->nQuality = mmal->quality;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_thumb_cfg(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_PARAM_BRCMTHUMBNAILTYPE *omx = (OMX_PARAM_BRCMTHUMBNAILTYPE *)omx_param;
|
||||
MMAL_PARAMETER_THUMBNAIL_CONFIG_T *mmal = (MMAL_PARAMETER_THUMBNAIL_CONFIG_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->enable = !!omx->bEnable;
|
||||
mmal->width = omx->nWidth;
|
||||
mmal->height = omx->nHeight;
|
||||
mmal->quality = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->bEnable = mmal->enable ? OMX_TRUE : OMX_FALSE;
|
||||
omx->bUsePreview = OMX_FALSE;
|
||||
omx->nWidth = mmal->width;
|
||||
omx->nHeight = mmal->height;
|
||||
/* We don't have an API for setting the thumbnail quality */
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_stc[] = {
|
||||
{MMAL_PARAM_STC_MODE_OFF, OMX_TimestampModeZero},
|
||||
{MMAL_PARAM_STC_MODE_RAW, OMX_TimestampModeRawStc},
|
||||
{MMAL_PARAM_STC_MODE_COOKED, OMX_TimestampModeResetStc},
|
||||
};
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_capture_mode[] = {
|
||||
{MMAL_PARAM_CAPTUREMODE_WAIT_FOR_END, OMX_CameraCaptureModeWaitForCaptureEnd},
|
||||
{MMAL_PARAM_CAPTUREMODE_RESUME_VF_IMMEDIATELY, OMX_CameraCaptureModeResumeViewfinderImmediately},
|
||||
/*{MMAL_PARAM_CAPTUREMODE_WAIT_FOR_END_AND_HOLD, OMX_CameraCaptureModeWaitForCaptureEndAndUsePreviousInputImage}, Don't enable for now as not working */
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_sensor_info(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_CAMERAINFOTYPE *omx = (OMX_CONFIG_CAMERAINFOTYPE *)omx_param;
|
||||
MMAL_PARAMETER_SENSOR_INFORMATION_T *mmal = (MMAL_PARAMETER_SENSOR_INFORMATION_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->f_number = mmal_rational_from_fixed_16_16(omx->xFNumber);
|
||||
mmal->focal_length = mmal_rational_from_fixed_16_16(omx->xFocalLength);
|
||||
mmal->model_id = omx->nModelId;
|
||||
mmal->manufacturer_id = omx->nManufacturerId;
|
||||
mmal->revision = omx->nRevNum;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->xFNumber = mmal_rational_to_fixed_16_16(mmal->f_number);
|
||||
omx->xFocalLength = mmal_rational_to_fixed_16_16(mmal->focal_length);
|
||||
omx->nModelId = mmal->model_id;
|
||||
omx->nManufacturerId = mmal->manufacturer_id;
|
||||
omx->nRevNum = mmal->revision;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_flash_select[] = {
|
||||
{MMAL_PARAMETER_CAMERA_INFO_FLASH_TYPE_XENON, OMX_CameraFlashXenon},
|
||||
{MMAL_PARAMETER_CAMERA_INFO_FLASH_TYPE_LED, OMX_CameraFlashLED},
|
||||
{MMAL_PARAMETER_CAMERA_INFO_FLASH_TYPE_OTHER, OMX_CameraFlashNone},
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_fov(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_BRCMFOVTYPE *omx = (OMX_CONFIG_BRCMFOVTYPE *)omx_param;
|
||||
MMAL_PARAMETER_FIELD_OF_VIEW_T *mmal = (MMAL_PARAMETER_FIELD_OF_VIEW_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->fov_h = mmal_rational_from_fixed_16_16(omx->xFieldOfViewHorizontal);
|
||||
mmal->fov_v = mmal_rational_from_fixed_16_16(omx->xFieldOfViewVertical);
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->xFieldOfViewHorizontal = mmal_rational_to_fixed_16_16(mmal->fov_h);
|
||||
omx->xFieldOfViewVertical = mmal_rational_to_fixed_16_16(mmal->fov_v);
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_drc[] = {
|
||||
{MMAL_PARAMETER_DRC_STRENGTH_OFF, OMX_DynRangeExpOff},
|
||||
{MMAL_PARAMETER_DRC_STRENGTH_LOW, OMX_DynRangeExpLow},
|
||||
{MMAL_PARAMETER_DRC_STRENGTH_MEDIUM, OMX_DynRangeExpMedium},
|
||||
{MMAL_PARAMETER_DRC_STRENGTH_HIGH, OMX_DynRangeExpHigh},
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_algo_ctrl(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_algo_ctrl[] = {
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_FACETRACKING, OMX_CameraDisableAlgorithmFacetracking},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_REDEYE_REDUCTION, OMX_CameraDisableAlgorithmRedEyeReduction},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_VIDEO_STABILISATION, OMX_CameraDisableAlgorithmVideoStabilisation},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_WRITE_RAW, OMX_CameraDisableAlgorithmWriteRaw},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_VIDEO_DENOISE, OMX_CameraDisableAlgorithmVideoDenoise},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_STILLS_DENOISE, OMX_CameraDisableAlgorithmStillsDenoise},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_TEMPORAL_DENOISE, OMX_CameraDisableAlgorithmMax},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_ANTISHAKE, OMX_CameraDisableAlgorithmAntiShake},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_IMAGE_EFFECTS, OMX_CameraDisableAlgorithmImageEffects},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_DYNAMIC_RANGE_COMPRESSION,OMX_CameraDisableAlgorithmDynamicRangeExpansion},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_FACE_RECOGNITION, OMX_CameraDisableAlgorithmFaceRecognition},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_FACE_BEAUTIFICATION, OMX_CameraDisableAlgorithmFaceBeautification},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_SCENE_DETECTION, OMX_CameraDisableAlgorithmSceneDetection},
|
||||
{ MMAL_PARAMETER_ALGORITHM_CONTROL_ALGORITHMS_HIGH_DYNAMIC_RANGE, OMX_CameraDisableAlgorithmHighDynamicRange},
|
||||
};
|
||||
OMX_PARAM_CAMERADISABLEALGORITHMTYPE *omx = (OMX_PARAM_CAMERADISABLEALGORITHMTYPE *)omx_param;
|
||||
MMAL_PARAMETER_ALGORITHM_CONTROL_T *mmal = (MMAL_PARAMETER_ALGORITHM_CONTROL_T *)mmal_param;
|
||||
MMALOMX_PARAM_ENUM_FIND(MMALOMX_PARAM_ENUM_TRANSLATE_T, xenum, mmalomx_param_enum_algo_ctrl,
|
||||
dir, mmal->algorithm, omx->eAlgorithm);
|
||||
|
||||
if (!xenum)
|
||||
return MMAL_EINVAL;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->algorithm = xenum->mmal;
|
||||
mmal->enabled = !omx->bDisabled;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->eAlgorithm = xenum->omx;
|
||||
omx->bDisabled = !mmal->enabled;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_image_effect_params(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_IMAGEFILTERPARAMSTYPE *omx = (OMX_CONFIG_IMAGEFILTERPARAMSTYPE *)omx_param;
|
||||
MMAL_PARAMETER_IMAGEFX_PARAMETERS_T *mmal = (MMAL_PARAMETER_IMAGEFX_PARAMETERS_T *)mmal_param;
|
||||
MMALOMX_PARAM_ENUM_FIND(MMALOMX_PARAM_ENUM_TRANSLATE_T, xenum, mmalomx_param_enum_image_effect,
|
||||
dir, mmal->effect, omx->eImageFilter);
|
||||
|
||||
if (!xenum)
|
||||
return MMAL_EINVAL;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
if (omx->nNumParams > MMAL_COUNTOF(mmal->effect_parameter))
|
||||
return MMAL_EINVAL;
|
||||
mmal->effect = xenum->mmal;
|
||||
mmal->num_effect_params = omx->nNumParams;
|
||||
memcpy(mmal->effect_parameter, omx->nParams, sizeof(uint32_t) * omx->nNumParams);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mmal->num_effect_params > MMAL_COUNTOF(omx->nParams))
|
||||
return MMAL_EINVAL;
|
||||
omx->eImageFilter = xenum->omx;
|
||||
omx->nNumParams = mmal->num_effect_params;
|
||||
memcpy(omx->nParams, mmal->effect_parameter, sizeof(uint32_t) * omx->nNumParams);
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_use_case[] = {
|
||||
{MMAL_PARAM_CAMERA_USE_CASE_UNKNOWN, OMX_CameraUseCaseAuto},
|
||||
{MMAL_PARAM_CAMERA_USE_CASE_STILLS_CAPTURE, OMX_CameraUseCaseStills},
|
||||
{MMAL_PARAM_CAMERA_USE_CASE_VIDEO_CAPTURE, OMX_CameraUseCaseVideo},
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_fps_range(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_PARAM_BRCMFRAMERATERANGETYPE *omx = (OMX_PARAM_BRCMFRAMERATERANGETYPE *)omx_param;
|
||||
MMAL_PARAMETER_FPS_RANGE_T *mmal = (MMAL_PARAMETER_FPS_RANGE_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->fps_low = mmal_rational_from_fixed_16_16(omx->xFramerateLow);
|
||||
mmal->fps_high = mmal_rational_from_fixed_16_16(omx->xFramerateLow);
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->xFramerateLow = mmal_rational_to_fixed_16_16(mmal->fps_low);
|
||||
omx->xFramerateLow = mmal_rational_to_fixed_16_16(mmal->fps_high);
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_ev_comp(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_PARAM_S32TYPE *omx = (OMX_PARAM_S32TYPE *)omx_param;
|
||||
MMAL_PARAMETER_INT32_T *mmal = (MMAL_PARAMETER_INT32_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
mmal->value = (omx->nS32 * 6) >> 16;
|
||||
else
|
||||
omx->nS32 = (mmal->value << 16) / 6;
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_camera[] = {
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_ROTATION, MMAL_PARAMETER_INT32_T,
|
||||
OMX_IndexConfigCommonRotate, OMX_CONFIG_ROTATIONTYPE),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_AWB_MODE, MMAL_PARAM_AWBMODE_T,
|
||||
OMX_IndexConfigCommonWhiteBalance, OMX_CONFIG_WHITEBALCONTROLTYPE, mmalomx_param_enum_awb_mode),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_IMAGE_EFFECT, MMAL_PARAMETER_IMAGEFX_T,
|
||||
OMX_IndexConfigCommonImageFilter, OMX_CONFIG_IMAGEFILTERTYPE, mmalomx_param_enum_image_effect),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_COLOUR_EFFECT, MMAL_PARAMETER_COLOURFX_T,
|
||||
OMX_IndexConfigCommonColorEnhancement, OMX_CONFIG_COLORENHANCEMENTTYPE, mmalomx_param_mapping_colour_effect),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_FLICKER_AVOID, MMAL_PARAMETER_FLICKERAVOID_T,
|
||||
OMX_IndexConfigCommonFlickerCancellation, OMX_CONFIG_FLICKERCANCELTYPE, mmalomx_param_enum_flicker_avoid),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_FLASH, MMAL_PARAMETER_FLASH_T,
|
||||
OMX_IndexParamFlashControl, OMX_IMAGE_PARAM_FLASHCONTROLTYPE, mmalomx_param_enum_flash),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_REDEYE, MMAL_PARAMETER_REDEYE_T,
|
||||
OMX_IndexConfigCommonRedEyeRemoval, OMX_CONFIG_REDEYEREMOVALTYPE, mmalomx_param_enum_redeye),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FOCUS, MMAL_PARAMETER_FOCUS_T,
|
||||
OMX_IndexConfigFocusControl, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE, mmalomx_param_mapping_focus),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_REDEYE, MMAL_PARAMETER_REDEYE_T,
|
||||
OMX_IndexConfigCommonRedEyeRemoval, OMX_CONFIG_REDEYEREMOVALTYPE, mmalomx_param_enum_flash),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_ZOOM, MMAL_PARAMETER_SCALEFACTOR_T,
|
||||
OMX_IndexConfigCommonDigitalZoom, OMX_CONFIG_SCALEFACTORTYPE),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_MIRROR, MMAL_PARAMETER_MIRROR_T,
|
||||
OMX_IndexConfigCommonMirror, OMX_CONFIG_MIRRORTYPE, mmalomx_param_enum_mirror),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_CAMERA_NUM, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamCameraDeviceNumber, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_BOOLEAN(MMAL_PARAMETER_CAPTURE,
|
||||
OMX_IndexConfigPortCapturing),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_EXPOSURE_MODE, MMAL_PARAMETER_EXPOSUREMODE_T,
|
||||
OMX_IndexConfigCommonExposure, OMX_CONFIG_EXPOSURECONTROLTYPE, mmalomx_param_enum_exposure_mode),
|
||||
MMALOMX_PARAM_ENUM_PORTLESS(MMAL_PARAMETER_CAPTURE_STATUS, MMAL_PARAMETER_CAPTURE_STATUS_T,
|
||||
OMX_IndexParamCaptureStatus, OMX_PARAM_CAPTURESTATETYPE, mmalomx_param_enum_capture_status),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FACE_TRACK, MMAL_PARAMETER_FACE_TRACK_T,
|
||||
OMX_IndexConfigCommonFaceDetectionControl, OMX_CONFIG_FACEDETECTIONCONTROLTYPE, mmalomx_param_mapping_face_track),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_DRAW_BOX_FACES_AND_FOCUS,
|
||||
OMX_IndexConfigDrawBoxAroundFaces),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_JPEG_Q_FACTOR, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamQFactor, OMX_IMAGE_PARAM_QFACTORTYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_EXIF_DISABLE,
|
||||
OMX_IndexParamBrcmDisableEXIF),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING_PORTLESS(MMAL_PARAMETER_THUMBNAIL_CONFIGURATION, MMAL_PARAMETER_THUMBNAIL_CONFIG_T,
|
||||
OMX_IndexParamBrcmThumbnail, OMX_PARAM_BRCMTHUMBNAILTYPE, mmalomx_param_mapping_thumb_cfg),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_USE_STC, MMAL_PARAMETER_CAMERA_STC_MODE_T,
|
||||
OMX_IndexParamCommonUseStcTimestamps, OMX_PARAM_TIMESTAMPMODETYPE, mmalomx_param_enum_stc),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_STABILISATION, MMAL_PARAMETER_BOOLEAN_T,
|
||||
OMX_IndexConfigCommonFrameStabilisation, OMX_CONFIG_FRAMESTABTYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_ENABLE_DPF_FILE,
|
||||
OMX_IndexParamUseDynamicParameterFile),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_DPF_FAIL_IS_FATAL,
|
||||
OMX_IndexParamDynamicParameterFileFailFatal),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_CAPTURE_MODE, MMAL_PARAMETER_CAPTUREMODE_T,
|
||||
OMX_IndexParamCameraCaptureMode, OMX_PARAM_CAMERACAPTUREMODETYPE, mmalomx_param_enum_capture_mode),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_INPUT_CROP, MMAL_PARAMETER_INPUT_CROP_T,
|
||||
OMX_IndexConfigInputCropPercentages, OMX_CONFIG_INPUTCROPTYPE),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING_PORTLESS(MMAL_PARAMETER_SENSOR_INFORMATION, MMAL_PARAMETER_SENSOR_INFORMATION_T,
|
||||
OMX_IndexConfigCameraInfo, OMX_CONFIG_CAMERAINFOTYPE, mmalomx_param_mapping_sensor_info),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_FLASH_SELECT, MMAL_PARAMETER_FLASH_SELECT_T,
|
||||
OMX_IndexParamCameraFlashType, OMX_PARAM_CAMERAFLASHTYPE, mmalomx_param_enum_flash_select),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FIELD_OF_VIEW, MMAL_PARAMETER_FIELD_OF_VIEW_T,
|
||||
OMX_IndexConfigFieldOfView, OMX_CONFIG_BRCMFOVTYPE, mmalomx_param_mapping_fov),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_HIGH_DYNAMIC_RANGE,
|
||||
OMX_IndexConfigBrcmHighDynamicRange),
|
||||
MMALOMX_PARAM_ENUM_PORTLESS(MMAL_PARAMETER_DYNAMIC_RANGE_COMPRESSION, MMAL_PARAMETER_DRC_T,
|
||||
OMX_IndexConfigDynamicRangeExpansion, OMX_CONFIG_DYNAMICRANGEEXPANSIONTYPE, mmalomx_param_enum_drc),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING_PORTLESS(MMAL_PARAMETER_ALGORITHM_CONTROL, MMAL_PARAMETER_ALGORITHM_CONTROL_T,
|
||||
OMX_IndexParamCameraDisableAlgorithm, OMX_PARAM_CAMERADISABLEALGORITHMTYPE, mmalomx_param_mapping_algo_ctrl),
|
||||
MMALOMX_PARAM_RATIONAL(MMAL_PARAMETER_SHARPNESS, MMAL_PARAMETER_RATIONAL_T,
|
||||
OMX_IndexConfigCommonSharpness, OMX_CONFIG_SHARPNESSTYPE, 100),
|
||||
MMALOMX_PARAM_RATIONAL(MMAL_PARAMETER_CONTRAST, MMAL_PARAMETER_RATIONAL_T,
|
||||
OMX_IndexConfigCommonContrast, OMX_CONFIG_CONTRASTTYPE, 100),
|
||||
MMALOMX_PARAM_RATIONAL(MMAL_PARAMETER_BRIGHTNESS, MMAL_PARAMETER_RATIONAL_T,
|
||||
OMX_IndexConfigCommonContrast, OMX_CONFIG_CONTRASTTYPE, 100),
|
||||
MMALOMX_PARAM_RATIONAL(MMAL_PARAMETER_SATURATION, MMAL_PARAMETER_RATIONAL_T,
|
||||
OMX_IndexConfigCommonSaturation, OMX_CONFIG_SATURATIONTYPE, 100),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_ANTISHAKE,
|
||||
OMX_IndexConfigStillsAntiShakeEnable),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_IMAGE_EFFECT_PARAMETERS, MMAL_PARAMETER_IMAGEFX_PARAMETERS_T,
|
||||
OMX_IndexConfigCommonImageFilterParameters, OMX_CONFIG_IMAGEFILTERPARAMSTYPE, mmalomx_param_mapping_image_effect_params),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_CAMERA_BURST_CAPTURE,
|
||||
OMX_IndexConfigBurstCapture),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_CAMERA_MIN_ISO, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigCameraIsoReferenceValue, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_ENUM_PORTLESS(MMAL_PARAMETER_CAMERA_USE_CASE, MMAL_PARAMETER_CAMERA_USE_CASE_T,
|
||||
OMX_IndexConfigCameraUseCase, OMX_CONFIG_CAMERAUSECASETYPE, mmalomx_param_enum_use_case),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_CAPTURE_STATS_PASS,
|
||||
OMX_IndexConfigCameraEnableStatsPass),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_CAMERA_CUSTOM_SENSOR_CONFIG, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamCameraCustomSensorConfig, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_ENABLE_REGISTER_FILE,
|
||||
OMX_IndexConfigBrcmUseRegisterFile),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_REGISTER_FAIL_IS_FATAL,
|
||||
OMX_IndexConfigBrcmRegisterFileFailFatal),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(MMAL_PARAMETER_CONFIGFILE_REGISTERS, MMAL_PARAMETER_CONFIGFILE_T,
|
||||
OMX_IndexParamBrcmConfigFileRegisters, OMX_PARAM_BRCMCONFIGFILETYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(MMAL_PARAMETER_CONFIGFILE_CHUNK_REGISTERS, MMAL_PARAMETER_CONFIGFILE_CHUNK_T,
|
||||
OMX_IndexParamBrcmConfigFileChunkRegisters, OMX_PARAM_BRCMCONFIGFILECHUNKTYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_JPEG_ATTACH_LOG,
|
||||
OMX_IndexParamBrcmAttachLog),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(MMAL_PARAMETER_ZERO_SHUTTER_LAG, MMAL_PARAMETER_ZEROSHUTTERLAG_T,
|
||||
OMX_IndexParamCameraZeroShutterLag, OMX_CONFIG_ZEROSHUTTERLAGTYPE),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FPS_RANGE, MMAL_PARAMETER_FPS_RANGE_T,
|
||||
OMX_IndexParamBrcmFpsRange, OMX_PARAM_BRCMFRAMERATERANGETYPE, mmalomx_param_mapping_fps_range),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_CAPTURE_EXPOSURE_COMP, MMAL_PARAMETER_INT32_T,
|
||||
OMX_IndexParamCaptureExposureCompensation, OMX_PARAM_S32TYPE, mmalomx_param_mapping_ev_comp),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_SW_SHARPEN_DISABLE,
|
||||
OMX_IndexParamSWSharpenDisable),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_FLASH_REQUIRED,
|
||||
OMX_IndexConfigBrcmFlashRequired),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_SW_SATURATION_DISABLE,
|
||||
OMX_IndexParamSWSaturationDisable),
|
||||
MMALOMX_PARAM_TERMINATE()
|
||||
};
|
||||
|
||||
#if 0 /* Conversions which are still left to implement */
|
||||
MMALOMX_PARAM_CUSTOM(MMAL_PARAMETER_CAMERA_CONFIG, MMAL_PARAMETER_CAMERA_CONFIG_T,
|
||||
0, 0, mmal_ril_param_set_cam_config),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_EXPOSURE_COMP, MMAL_PARAMETER_INT32_T,
|
||||
OMX_IndexConfigCommonExposureValue, OMX_CONFIG_EXPOSUREVALUETYPE, 0),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_EXP_METERING_MODE, MMAL_PARAMETER_EXPOSUREMETERINGMODE_T,
|
||||
OMX_IndexConfigCommonExposureValue, OMX_CONFIG_EXPOSUREVALUETYPE, 0),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_ISO, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigCommonExposureValue, OMX_CONFIG_EXPOSUREVALUETYPE, 0),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FOCUS_STATUS, MMAL_PARAMETER_FOCUS_STATUS_T,
|
||||
OMX_IndexConfigCommonFocusStatus, OMX_PARAM_FOCUSSTATUSTYPE, mmalomx_param_mapping_focus_status),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_EXIF, MMAL_PARAMETER_EXIF_T,
|
||||
OMX_IndexConfigMetadataItem, OMX_CONFIG_METADATAITEMTYPE, 0),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FACE_TRACK_RESULTS, MMAL_PARAMETER_FACE_TRACK_RESULTS_T,
|
||||
OMX_IndexConfigCommonFaceDetectionRegion, OMX_CONFIG_FACEDETECTIONREGIONTYPE, 0),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_ENABLE_RAW_CAPTURE, MMAL_PARAMETER_BOOLEAN_T,
|
||||
OMX_IndexConfigCaptureRawImageURI, OMX_PARAM_CONTENTURITYPE, 0),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(MMAL_PARAMETER_DPF_FILE, MMAL_PARAMETER_URI_T,
|
||||
OMX_IndexParamDynamicParameterFile, OMX_PARAM_CONTENTURITYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(MMAL_PARAMETER_FOCUS_REGIONS, ,
|
||||
OMX_IndexConfigCommonFocusRegionXY, ),
|
||||
#endif
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* OpenMAX IL adaptation layer for MMAL - Parameters related functions
|
||||
*/
|
||||
|
||||
#include "interface/vmcs_host/khronos/IL/OMX_Broadcom.h"
|
||||
#include "mmalomx_util_params.h"
|
||||
#include "util/mmal_util_rational.h"
|
||||
|
||||
/* Sanity check that OMX is defining the right int32 types */
|
||||
vcos_static_assert(sizeof(OMX_U32) == 4);
|
||||
|
||||
MMAL_STATUS_T mmalomx_param_enum_generic(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const struct MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal, OMX_PTR omx, MMAL_PORT_T *mmal_port);
|
||||
MMAL_STATUS_T mmalomx_param_rational_generic(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const struct MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal, OMX_PTR omx, MMAL_PORT_T *mmal_port);
|
||||
MMAL_STATUS_T mmalomx_param_mapping_generic(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const struct MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal, OMX_PTR omx, MMAL_PORT_T *mmal_port);
|
||||
|
||||
extern const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_audio[];
|
||||
extern const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_video[];
|
||||
extern const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_camera[];
|
||||
extern const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_misc[];
|
||||
|
||||
#define MMALOMX_PARAM_ENUM_FIND(TYPE, VAR, TABLE, DIR, MMAL, OMX) \
|
||||
const TYPE *VAR = TABLE; \
|
||||
const TYPE *VAR##_end = VAR + MMAL_COUNTOF(TABLE); \
|
||||
if (DIR == MMALOMX_PARAM_MAPPING_TO_MMAL) \
|
||||
while (VAR < VAR##_end && VAR->omx != OMX) VAR++; \
|
||||
else \
|
||||
while (VAR < VAR##_end && VAR->mmal != MMAL) VAR++; \
|
||||
do { if (VAR == VAR##_end) { \
|
||||
VAR = 0; \
|
||||
if (DIR == MMALOMX_PARAM_MAPPING_TO_MMAL) \
|
||||
VCOS_ALERT("omx enum value %u not supported", (unsigned int)OMX); \
|
||||
else \
|
||||
VCOS_ALERT("mmal enum value %u not supported", (unsigned int)MMAL); \
|
||||
} } while(0)
|
||||
|
||||
#define mmalomx_ct_assert(e) (sizeof(char[1 - 2*!(e)]))
|
||||
|
||||
/** List of macros used to define parameters mapping */
|
||||
#define MMALOMX_PARAM_PASSTHROUGH(a,b,c,d) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), \
|
||||
!(offsetof(d, nPortIndex) | mmalomx_ct_assert(sizeof(b)+4==sizeof(d))), \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_mapping_generic, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_BOOLEAN(a, b) \
|
||||
MMALOMX_PARAM_PASSTHROUGH(a, MMAL_PARAMETER_BOOLEAN_T, b, OMX_CONFIG_PORTBOOLEANTYPE)
|
||||
#define MMALOMX_PARAM_PASSTHROUGH_PORTLESS(a,b,c,d) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), \
|
||||
!!(mmalomx_ct_assert(sizeof(b)==sizeof(d))), \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_mapping_generic, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_BOOLEAN_PORTLESS(a, b) \
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(a, MMAL_PARAMETER_BOOLEAN_T, b, OMX_CONFIG_BOOLEANTYPE)
|
||||
#define MMALOMX_PARAM_PASSTHROUGH_PORTLESS_DOUBLE_TRANSLATION(a,b,c,d) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), \
|
||||
!!(mmalomx_ct_assert(sizeof(b)==sizeof(d))), \
|
||||
1, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_mapping_generic, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_DIRECT_PORTLESS(a,b,c,d) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 1, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_DIRECT, {0, 0, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_STRAIGHT_MAPPING(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), \
|
||||
!offsetof(d, nPortIndex), \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_SIMPLE, {e, 0, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_STRAIGHT_MAPPING_PORTLESS(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 1, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_SIMPLE, {e, 0, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_STRAIGHT_MAPPING_DOUBLE_TRANSLATION(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 0, \
|
||||
1, MMALOMX_PARAM_TRANSLATION_TYPE_SIMPLE, {e, 0, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_ENUM(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 0, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_enum_generic, 0, 0}, e, MMAL_COUNTOF(e), \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_ENUM_PORTLESS(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 1, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_enum_generic, 0, 0}, e, MMAL_COUNTOF(e), \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_RATIONAL(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 0, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_rational_generic, 0, 0}, 0, e, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_RATIONAL_PORTLESS(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 1, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, mmalomx_param_rational_generic, 0, 0}, 0, e, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_CUSTOM(a,b,c,d,e) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 0, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, e, 0, 0}, 0, 0, \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_LIST(a,b,c,d,e,f) \
|
||||
{a, (uint32_t)c, sizeof(b), sizeof(d), 0, \
|
||||
0, MMALOMX_PARAM_TRANSLATION_TYPE_CUSTOM, {0, 0, f, 0}, 0, offsetof(d,e), \
|
||||
MMAL_TO_STRING(a), MMAL_TO_STRING(c)}
|
||||
#define MMALOMX_PARAM_TERMINATE() \
|
||||
{MMAL_PARAMETER_UNUSED, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0}, 0, 0, 0, 0}
|
||||
+157
@@ -0,0 +1,157 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_util_params_common.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_event_request(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_REQUESTCALLBACKTYPE *omx = (OMX_CONFIG_REQUESTCALLBACKTYPE *)omx_param;
|
||||
MMAL_PARAMETER_CHANGE_EVENT_REQUEST_T *mmal = (MMAL_PARAMETER_CHANGE_EVENT_REQUEST_T *)mmal_param;
|
||||
const MMALOMX_PARAM_TRANSLATION_T *change_xlat;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
change_xlat = mmalomx_find_parameter_from_omx_id(omx->nIndex);
|
||||
if (!change_xlat)
|
||||
{
|
||||
VCOS_ALERT("ommalomx_param_mapping_event_request: omx parameter "
|
||||
"0x%08x not recognised", omx->nIndex);
|
||||
return MMAL_EINVAL;
|
||||
}
|
||||
|
||||
mmal->change_id = change_xlat->mmal_id;
|
||||
mmal->enable = omx->bEnable;
|
||||
}
|
||||
else
|
||||
{
|
||||
change_xlat = mmalomx_find_parameter_from_mmal_id(mmal->change_id);
|
||||
if (!change_xlat)
|
||||
{
|
||||
VCOS_ALERT("mmalomx_param_mapping_event_request: mmal parameter "
|
||||
"0x%08x not recognised", mmal->change_id);
|
||||
return MMAL_EINVAL;
|
||||
}
|
||||
|
||||
omx->nIndex = change_xlat->omx_id;
|
||||
omx->bEnable = mmal->enable;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_statistics(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_BRCMPORTSTATSTYPE *omx = (OMX_CONFIG_BRCMPORTSTATSTYPE *)omx_param;
|
||||
MMAL_PARAMETER_STATISTICS_T *mmal = (MMAL_PARAMETER_STATISTICS_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->buffer_count = omx->nBufferCount;
|
||||
mmal->frame_count = omx->nImageCount + omx->nFrameCount;
|
||||
mmal->frames_skipped = omx->nFrameSkips;
|
||||
mmal->frames_discarded = omx->nDiscards;
|
||||
mmal->eos_seen = omx->nEOS;
|
||||
mmal->maximum_frame_bytes = omx->nMaxFrameSize;
|
||||
mmal->total_bytes = omx_ticks_to_s64(omx->nByteCount);
|
||||
mmal->corrupt_macroblocks = omx->nCorruptMBs;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->nBufferCount = mmal->buffer_count;
|
||||
omx->nFrameCount = mmal->frame_count;
|
||||
omx->nImageCount = 0;
|
||||
omx->nFrameSkips = mmal->frames_skipped;
|
||||
omx->nDiscards = mmal->frames_discarded;
|
||||
omx->nEOS = mmal->eos_seen;
|
||||
omx->nMaxFrameSize = mmal->maximum_frame_bytes;
|
||||
omx->nByteCount = omx_ticks_from_s64(mmal->total_bytes);
|
||||
omx->nCorruptMBs = mmal->corrupt_macroblocks;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_buffer_flags(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_PARAM_U32TYPE *omx = (OMX_PARAM_U32TYPE *)omx_param;
|
||||
MMAL_PARAMETER_UINT32_T *mmal = (MMAL_PARAMETER_UINT32_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
mmal->value = mmalil_buffer_flags_to_mmal(omx->nU32);
|
||||
else
|
||||
omx->nU32 = mmalil_buffer_flags_to_omx(mmal->value);
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_time(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_TIME_CONFIG_TIMESTAMPTYPE *omx = (OMX_TIME_CONFIG_TIMESTAMPTYPE *)omx_param;
|
||||
MMAL_PARAMETER_INT64_T *mmal = (MMAL_PARAMETER_INT64_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
mmal->value = omx_ticks_to_s64(omx->nTimestamp);
|
||||
else
|
||||
omx->nTimestamp = omx_ticks_from_s64(mmal->value);
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_misc[] = {
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING_DOUBLE_TRANSLATION(MMAL_PARAMETER_CHANGE_EVENT_REQUEST, MMAL_PARAMETER_CHANGE_EVENT_REQUEST_T,
|
||||
OMX_IndexConfigRequestCallback, OMX_CONFIG_REQUESTCALLBACKTYPE,
|
||||
mmalomx_param_mapping_event_request),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_STATISTICS, MMAL_PARAMETER_STATISTICS_T,
|
||||
OMX_IndexConfigBrcmPortStats, OMX_CONFIG_BRCMPORTSTATSTYPE,
|
||||
mmalomx_param_mapping_statistics),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_MEM_USAGE, MMAL_PARAMETER_MEM_USAGE_T,
|
||||
OMX_IndexConfigBrcmPoolMemAllocSize, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_BUFFER_FLAG_FILTER, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigBrcmBufferFlagFilter, OMX_PARAM_U32TYPE,
|
||||
mmalomx_param_mapping_buffer_flags),
|
||||
MMALOMX_PARAM_BOOLEAN(MMAL_PARAMETER_ZERO_COPY,
|
||||
OMX_IndexParamBrcmZeroCopy),
|
||||
MMALOMX_PARAM_BOOLEAN(MMAL_PARAMETER_LOCKSTEP_ENABLE,
|
||||
OMX_IndexParamBrcmLockStepEnable),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_POWERMON_ENABLE,
|
||||
OMX_IndexConfigBrcmPowerMonitor),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_CLOCK_TIME, MMAL_PARAMETER_INT64_T,
|
||||
OMX_IndexConfigTimeCurrentMediaTime, OMX_TIME_CONFIG_TIMESTAMPTYPE,
|
||||
mmalomx_param_mapping_time),
|
||||
MMALOMX_PARAM_TERMINATE()
|
||||
};
|
||||
|
||||
#if 0
|
||||
/* Conversions which are not done here. Should part of the core. */
|
||||
MMAL_PARAMETER_SUPPORTED_ENCODINGS
|
||||
#endif
|
||||
+277
@@ -0,0 +1,277 @@
|
||||
/*
|
||||
Copyright (c) 2012, Broadcom Europe Ltd
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the copyright holder nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "mmalomx.h"
|
||||
#include "mmalomx_util_params_common.h"
|
||||
#include "mmalomx_logging.h"
|
||||
|
||||
static void rect_to_omx(OMX_DISPLAYRECTTYPE *dst, const MMAL_RECT_T *src)
|
||||
{
|
||||
dst->x_offset = src->x;
|
||||
dst->y_offset = src->y;
|
||||
dst->width = src->width;
|
||||
dst->height = src->height;
|
||||
}
|
||||
|
||||
static void rect_to_mmal(MMAL_RECT_T *dst, const OMX_DISPLAYRECTTYPE *src)
|
||||
{
|
||||
dst->x = src->x_offset;
|
||||
dst->y = src->y_offset;
|
||||
dst->width = src->width;
|
||||
dst->height = src->height;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_displayregion(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_DISPLAYREGIONTYPE *omx = (OMX_CONFIG_DISPLAYREGIONTYPE *)omx_param;
|
||||
MMAL_DISPLAYREGION_T *mmal = (MMAL_DISPLAYREGION_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->set = omx->set;
|
||||
mmal->display_num = omx->num;
|
||||
mmal->fullscreen = omx->fullscreen;
|
||||
mmal->transform = omx->transform;
|
||||
rect_to_mmal(&mmal->dest_rect, &omx->dest_rect);
|
||||
rect_to_mmal(&mmal->src_rect, &omx->src_rect);
|
||||
mmal->noaspect = omx->noaspect;
|
||||
mmal->mode = omx->mode;
|
||||
mmal->pixel_x = omx->pixel_x;
|
||||
mmal->pixel_y = omx->pixel_y;
|
||||
mmal->layer = omx->layer;
|
||||
mmal->copyprotect_required = omx->copyprotect_required;
|
||||
mmal->alpha = omx->alpha;
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->set = mmal->set;
|
||||
omx->num = mmal->display_num;
|
||||
omx->fullscreen = mmal->fullscreen;
|
||||
omx->transform = mmal->transform;
|
||||
rect_to_omx(&omx->dest_rect, &mmal->dest_rect);
|
||||
rect_to_omx(&omx->src_rect, &mmal->src_rect);
|
||||
omx->noaspect = mmal->noaspect;
|
||||
omx->mode = mmal->mode;
|
||||
omx->pixel_x = mmal->pixel_x;
|
||||
omx->pixel_y = mmal->pixel_y;
|
||||
omx->layer = mmal->layer;
|
||||
omx->copyprotect_required = mmal->copyprotect_required;
|
||||
omx->alpha = mmal->alpha;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_list_supported_profiles(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat, unsigned int index,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port)
|
||||
{
|
||||
OMX_VIDEO_PARAM_PROFILELEVELTYPE *omx = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)omx_param;
|
||||
MMAL_PARAMETER_VIDEO_PROFILE_T *mmal = (MMAL_PARAMETER_VIDEO_PROFILE_T *)mmal_param;
|
||||
MMAL_PARAM_UNUSED(xlat);
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
OMX_VIDEO_CODINGTYPE coding = mmalil_encoding_to_omx_video_coding(mmal_port->format->encoding);
|
||||
mmal->profile[index].profile = mmalil_omx_video_profile_to_mmal(omx->eProfile, coding);
|
||||
mmal->profile[index].level = mmalil_omx_video_level_to_mmal(omx->eLevel, coding);
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->eProfile = mmalil_video_profile_to_omx(mmal->profile[index].profile);
|
||||
omx->eLevel = mmalil_video_level_to_omx(mmal->profile[index].level);
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_custom_profile(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port)
|
||||
{
|
||||
OMX_VIDEO_PARAM_PROFILELEVELTYPE *omx = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)omx_param;
|
||||
MMAL_PARAMETER_VIDEO_PROFILE_T *mmal = (MMAL_PARAMETER_VIDEO_PROFILE_T *)mmal_param;
|
||||
MMAL_PARAM_UNUSED(xlat);
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
OMX_VIDEO_CODINGTYPE coding = mmalil_encoding_to_omx_video_coding(mmal_port->format->encoding);
|
||||
mmal->profile[0].profile = mmalil_omx_video_profile_to_mmal(omx->eProfile, coding);
|
||||
mmal->profile[0].level = mmalil_omx_video_level_to_mmal(omx->eLevel, coding);
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->eProfile = mmalil_video_profile_to_omx(mmal->profile[0].profile);
|
||||
omx->eLevel = mmalil_video_level_to_omx(mmal->profile[0].level);
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_custom_ratecontrol(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
const MMALOMX_PARAM_TRANSLATION_T *xlat,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param, MMAL_PORT_T *mmal_port)
|
||||
{
|
||||
OMX_VIDEO_PARAM_BITRATETYPE *omx = (OMX_VIDEO_PARAM_BITRATETYPE *)omx_param;
|
||||
MMAL_PARAMETER_VIDEO_RATECONTROL_T *mmal = (MMAL_PARAMETER_VIDEO_RATECONTROL_T *)mmal_param;
|
||||
MMAL_PARAM_UNUSED(xlat);
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->control = mmalil_omx_video_ratecontrol_to_mmal(omx->eControlRate);
|
||||
/* This does not apply nTargetBitrate but should not be necessary */
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->eControlRate = mmalil_video_ratecontrol_to_omx(mmal->control);
|
||||
omx->nTargetBitrate = mmal_port->format->bitrate; /* Should not really be necessary */
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
static const MMALOMX_PARAM_ENUM_TRANSLATE_T mmalomx_param_enum_nalunitformat[] = {
|
||||
{MMAL_VIDEO_NALUNITFORMAT_STARTCODES, OMX_NaluFormatStartCodes},
|
||||
{MMAL_VIDEO_NALUNITFORMAT_NALUNITPERBUFFER, OMX_NaluFormatOneNaluPerBuffer},
|
||||
{MMAL_VIDEO_NALUNITFORMAT_ONEBYTEINTERLEAVELENGTH, OMX_NaluFormatOneByteInterleaveLength},
|
||||
{MMAL_VIDEO_NALUNITFORMAT_TWOBYTEINTERLEAVELENGTH, OMX_NaluFormatTwoByteInterleaveLength},
|
||||
{MMAL_VIDEO_NALUNITFORMAT_FOURBYTEINTERLEAVELENGTH, OMX_NaluFormatFourByteInterleaveLength},
|
||||
};
|
||||
|
||||
static MMAL_STATUS_T mmalomx_param_mapping_frame_rate(MMALOMX_PARAM_MAPPING_DIRECTION dir,
|
||||
MMAL_PARAMETER_HEADER_T *mmal_param, OMX_PTR omx_param)
|
||||
{
|
||||
OMX_CONFIG_FRAMERATETYPE *omx = (OMX_CONFIG_FRAMERATETYPE *)omx_param;
|
||||
MMAL_PARAMETER_FRAME_RATE_T *mmal = (MMAL_PARAMETER_FRAME_RATE_T *)mmal_param;
|
||||
|
||||
if (dir == MMALOMX_PARAM_MAPPING_TO_MMAL)
|
||||
{
|
||||
mmal->frame_rate.num = omx->xEncodeFramerate;
|
||||
mmal->frame_rate.den = (1<<16);
|
||||
}
|
||||
else
|
||||
{
|
||||
omx->xEncodeFramerate = 0;
|
||||
if (mmal->frame_rate.den)
|
||||
omx->xEncodeFramerate = (((int64_t)mmal->frame_rate.num)<<16)/mmal->frame_rate.den;
|
||||
}
|
||||
|
||||
return MMAL_SUCCESS;
|
||||
}
|
||||
|
||||
const MMALOMX_PARAM_TRANSLATION_T mmalomx_param_xlator_video[] = {
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_DISPLAYREGION, MMAL_DISPLAYREGION_T,
|
||||
OMX_IndexConfigDisplayRegion, OMX_CONFIG_DISPLAYREGIONTYPE,
|
||||
mmalomx_param_mapping_displayregion),
|
||||
MMALOMX_PARAM_LIST(MMAL_PARAMETER_SUPPORTED_PROFILES, MMAL_PARAMETER_VIDEO_PROFILE_T,
|
||||
OMX_IndexParamVideoProfileLevelQuerySupported, OMX_VIDEO_PARAM_PROFILELEVELTYPE,
|
||||
nProfileIndex, mmalomx_param_list_supported_profiles),
|
||||
MMALOMX_PARAM_CUSTOM(MMAL_PARAMETER_PROFILE, MMAL_PARAMETER_VIDEO_PROFILE_T,
|
||||
OMX_IndexParamVideoProfileLevelCurrent, OMX_VIDEO_PARAM_PROFILELEVELTYPE,
|
||||
mmalomx_param_custom_profile),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_INTRAPERIOD, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigBrcmVideoIntraPeriod, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_CUSTOM(MMAL_PARAMETER_RATECONTROL, MMAL_PARAMETER_VIDEO_RATECONTROL_T,
|
||||
OMX_IndexParamVideoBitrate, OMX_VIDEO_PARAM_BITRATETYPE,
|
||||
mmalomx_param_custom_ratecontrol),
|
||||
MMALOMX_PARAM_ENUM(MMAL_PARAMETER_NALUNITFORMAT, MMAL_PARAMETER_VIDEO_NALUNITFORMAT_T,
|
||||
OMX_IndexParamNalStreamFormatSelect, OMX_NALSTREAMFORMATTYPE, mmalomx_param_enum_nalunitformat),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_MINIMISE_FRAGMENTATION,
|
||||
OMX_IndexConfigMinimiseFragmentation),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_MB_ROWS_PER_SLICE, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigBrcmVideoEncoderMBRowsPerSlice, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_LEVEL_EXTENSION, MMAL_PARAMETER_VIDEO_LEVEL_EXTENSION_T,
|
||||
OMX_IndexConfigEncLevelExtension, OMX_VIDEO_CONFIG_LEVEL_EXTEND),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_INTRA_REFRESH, MMAL_PARAMETER_VIDEO_INTRA_REFRESH_T,
|
||||
OMX_IndexConfigBrcmVideoIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_INTRA_REFRESH, MMAL_PARAMETER_VIDEO_INTRA_REFRESH_T,
|
||||
OMX_IndexParamVideoIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_EEDE_ENABLE, MMAL_PARAMETER_VIDEO_EEDE_ENABLE_T,
|
||||
OMX_IndexParamBrcmEEDEEnable, OMX_VIDEO_EEDE_ENABLE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_EEDE_LOSSRATE, MMAL_PARAMETER_VIDEO_EEDE_LOSSRATE_T,
|
||||
OMX_IndexParamBrcmEEDELossRate, OMX_VIDEO_EEDE_LOSSRATE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_REQUEST_I_FRAME,
|
||||
OMX_IndexConfigBrcmVideoRequestIFrame),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_IMMUTABLE_INPUT,
|
||||
OMX_IndexParamBrcmImmutableInput),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_BIT_RATE, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigVideoBitrate, OMX_VIDEO_CONFIG_BITRATETYPE),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_VIDEO_FRAME_RATE, MMAL_PARAMETER_FRAME_RATE_T,
|
||||
OMX_IndexConfigVideoFramerate, OMX_CONFIG_FRAMERATETYPE, mmalomx_param_mapping_frame_rate),
|
||||
MMALOMX_PARAM_STRAIGHT_MAPPING(MMAL_PARAMETER_FRAME_RATE, MMAL_PARAMETER_FRAME_RATE_T,
|
||||
OMX_IndexConfigVideoFramerate, OMX_CONFIG_FRAMERATETYPE, mmalomx_param_mapping_frame_rate),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_MIN_QUANT, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoEncodeMinQuant, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_MAX_QUANT, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoEncodeMaxQuant, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_RC_MODEL, MMAL_PARAMETER_VIDEO_ENCODE_RC_MODEL_T,
|
||||
OMX_IndexParamRateControlModel, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_EXTRA_BUFFERS, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmExtraBuffers, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ALIGN_HORIZ, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmAlignHoriz, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ALIGN_VERT, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmAlignVert, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_DROPPABLE_PFRAMES,
|
||||
OMX_IndexParamBrcmDroppablePFrames),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_INITIAL_QUANT, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoInitialQuant, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_QP_P, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoInitialQuant, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_RC_SLICE_DQUANT, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoRCSliceDQuant, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_FRAME_LIMIT_BITS, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoFrameLimitBits, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_PEAK_RATE, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexParamBrcmVideoPeakRate, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_ENCODE_H264_DISABLE_CABAC,
|
||||
OMX_IndexConfigBrcmVideoH264DisableCABAC),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_ENCODE_H264_LOW_LATENCY,
|
||||
OMX_IndexConfigBrcmVideoH264LowLatency),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_ENCODE_H264_AU_DELIMITERS,
|
||||
OMX_IndexConfigBrcmVideoH264AUDelimiters),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_H264_DEBLOCK_IDC, MMAL_PARAMETER_UINT32_T,
|
||||
OMX_IndexConfigBrcmVideoH264DeblockIDC, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH(MMAL_PARAMETER_VIDEO_ENCODE_H264_MB_INTRA_MODE, MMAL_PARAMETER_VIDEO_ENCODER_H264_MB_INTRA_MODES_T,
|
||||
OMX_IndexConfigBrcmVideoH264IntraMBMode, OMX_PARAM_U32TYPE),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_ENCODE_HEADER_ON_OPEN,
|
||||
OMX_IndexParamBrcmHeaderOnOpen),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_ENCODE_PRECODE_FOR_QP,
|
||||
OMX_IndexParamBrcmVideoPrecodeForQP),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_TIMESTAMP_FIFO,
|
||||
OMX_IndexParamBrcmVideoTimestampFifo),
|
||||
MMALOMX_PARAM_BOOLEAN_PORTLESS(MMAL_PARAMETER_VIDEO_DECODE_ERROR_CONCEALMENT,
|
||||
OMX_IndexParamBrcmVideoDecodeErrorConcealment),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS_DOUBLE_TRANSLATION(MMAL_PARAMETER_VIDEO_DRM_PROTECT_BUFFER, MMAL_PARAMETER_VIDEO_DRM_PROTECT_BUFFER_T,
|
||||
OMX_IndexParamBrcmVideoDrmProtectBuffer, OMX_PARAM_BRCMVIDEODRMPROTECTBUFFERTYPE),
|
||||
MMALOMX_PARAM_PASSTHROUGH_PORTLESS(MMAL_PARAMETER_VIDEO_DECODE_CONFIG_VD3, MMAL_PARAMETER_BYTES_T,
|
||||
OMX_IndexParamBrcmVideoDecodeConfigVD3, OMX_PARAM_BRCMVIDEODECODECONFIGVD3TYPE),
|
||||
MMALOMX_PARAM_BOOLEAN(MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER,
|
||||
OMX_IndexParamBrcmVideoAVCInlineHeaderEnable),
|
||||
MMALOMX_PARAM_TERMINATE()
|
||||
};
|
||||
Reference in New Issue
Block a user