int flush();
int decode(bundle buffer);
+ int decode_fd(bundle buffer, array<file_desc> fd);
int encode(bundle buffer, array<file_desc> fd);
int release_output_buffer(int buffer_index);
### main package #########
Name: %{name}
Summary: %{name} interface
-Version: 1.6.0
+Version: 1.6.1
Release: 0
Group: Development/Libraries
License: Apache-2.0
for (i = 0 ; i < fd_size ; i++) {
hal_buffer->memory.fd[i] = fd[i];
+ if (hal_buffer->meta.flags & HAL_CODEC_BUFFER_FLAG_SECURE)
+ continue;
+
if (fd_size == 1)
mmap_length = hal_buffer->size;
else
}
}
- if (fd_size != (int)hal_buffer->planes.num_planes) {
+ if (!(hal_buffer->meta.flags & HAL_CODEC_BUFFER_FLAG_SECURE) &&
+ fd_size != (int)hal_buffer->planes.num_planes) {
for (i = 1 ; i < (int)hal_buffer->planes.num_planes ; i++)
hal_buffer->planes.plane[i].data = hal_buffer->planes.plane[i - 1].data + hal_buffer->planes.plane[i - 1].size;
}
- SLOGD("[DECODER][OUTPUT] buffer[%d] fd[%d:%d] data[%p:%p] size[%u:%u]",
- hal_buffer->index, fd[0], fd_size > 1 ? fd[1] : 0,
+ SLOGD("[DECODER][OUTPUT] buffer[%d][flag:0x%x] fd[%d:%d] data[%p:%p] size[%u:%u]",
+ hal_buffer->index, hal_buffer->meta.flags, fd[0], fd_size > 1 ? fd[1] : 0,
hal_buffer->planes.plane[0].data, hal_buffer->planes.plane[1].data,
hal_buffer->planes.plane[0].size, hal_buffer->planes.plane[1].size);
SLOGW(" invalid fd[%u] %d", i, hal_buffer->memory.fd[i]);
}
+ if (hal_buffer->meta.flags & HAL_CODEC_BUFFER_FLAG_SECURE)
+ continue;
+
if (hal_buffer->memory.num_fd == 1)
unmap_size = hal_buffer->size;
else
}
+static rpc_port_proxy_array_file_desc_h __hal_codec_ipc_fd_handle_new(uint32_t num_fd, int *fd)
+{
+ int ipc_ret = 0;
+ rpc_port_proxy_array_file_desc_h fd_handle = NULL;
+
+ ipc_ret = rpc_port_proxy_array_file_desc_create(&fd_handle);
+ if (ipc_ret != RPC_PORT_ERROR_NONE) {
+ SLOGE("fd handle create failed[0x%x]", ipc_ret);
+ return NULL;
+ }
+
+ SLOGD("num_fd[%u]: fd[0] %d, fd[1] %d", num_fd, fd[0], fd[1]);
+
+ if (num_fd == 0)
+ return fd_handle;
+
+ ipc_ret = rpc_port_proxy_array_file_desc_set(fd_handle, fd, num_fd);
+ if (ipc_ret != RPC_PORT_ERROR_NONE) {
+ SLOGE("fd set failed[0x%x]", ipc_ret);
+ rpc_port_proxy_array_file_desc_destroy(fd_handle);
+ return NULL;
+ }
+
+ return fd_handle;
+}
+
+
int hal_codec_ipc_decode(void *codec_handle, hal_codec_buffer_s *buffer)
{
int ret = HAL_CODEC_ERROR_NONE;
hal_codec_message_s hal_message = {0, };
rpc_port_proxy_codec_async_return_type_e type = RPC_PORT_PROXY_ASYNC_RETURN_TYPE_CODEC_DECODE;
+ rpc_port_proxy_array_file_desc_h fd_handle = NULL;
bundle *b_buffer = NULL;
HAL_CODEC_RETURN_VAL_IF_FAILED(handle, HAL_CODEC_ERROR_INVALID_PARAMETER);
(const char *)buffer, sizeof(hal_codec_buffer_s));
if (ipc_ret != BUNDLE_ERROR_NONE) {
SLOGE("add byte failed for buffer");
- bundle_free(b_buffer);
- return HAL_CODEC_ERROR_OUT_OF_MEMORY;
+ ret = HAL_CODEC_ERROR_OUT_OF_MEMORY;
+ goto _IPC_DECODE_DONE;
}
- ipc_ret = bundle_add_byte(b_buffer, HAL_CODEC_IPC_PARAM_KEY_PLANE0_DATA,
- (const char *)buffer->planes.plane[0].data, buffer->planes.plane[0].size);
- if (ipc_ret != BUNDLE_ERROR_NONE) {
- SLOGE("add byte failed for buffer[%d] size[%u]", buffer->index, buffer->planes.plane[0].size);
- bundle_free(b_buffer);
- return HAL_CODEC_ERROR_OUT_OF_MEMORY;
+ if (buffer->meta.flags & HAL_CODEC_BUFFER_FLAG_SECURE) {
+ fd_handle = __hal_codec_ipc_fd_handle_new(buffer->memory.num_fd, buffer->memory.fd);
+ if (!fd_handle) {
+ SLOGE("fd handle create failed[0x%x]", ipc_ret);
+ ret = HAL_CODEC_ERROR_OUT_OF_MEMORY;
+ goto _IPC_DECODE_DONE;
+ }
+ } else {
+ ipc_ret = bundle_add_byte(b_buffer, HAL_CODEC_IPC_PARAM_KEY_PLANE0_DATA,
+ (const char *)buffer->planes.plane[0].data, buffer->planes.plane[0].size);
+ if (ipc_ret != BUNDLE_ERROR_NONE) {
+ SLOGE("add byte failed for buffer[%d] size[%u]", buffer->index, buffer->planes.plane[0].size);
+ ret = HAL_CODEC_ERROR_OUT_OF_MEMORY;
+ goto _IPC_DECODE_DONE;
+ }
}
if (__hal_codec_ipc_input_buffer_push(ipc_buffer, buffer) != HAL_CODEC_ERROR_NONE) {
- bundle_free(b_buffer);
- return HAL_CODEC_ERROR_INTERNAL;
+ ret = HAL_CODEC_ERROR_INTERNAL;
+ goto _IPC_DECODE_DONE;
}
g_mutex_lock(&ipc_async_return->lock[type]);
g_mutex_unlock(&ipc_message->lock);
g_mutex_unlock(&ipc_async_return->lock[type]);
- bundle_free(b_buffer);
- return HAL_CODEC_ERROR_NONE;
+ ret = HAL_CODEC_ERROR_NONE;
+ goto _IPC_DECODE_DONE;
}
- ret = rpc_port_proxy_codec_invoke_decode(handle->rpc_handle, b_buffer);
+ if (fd_handle)
+ ret = rpc_port_proxy_codec_invoke_decode_fd(handle->rpc_handle, b_buffer, fd_handle);
+ else
+ ret = rpc_port_proxy_codec_invoke_decode(handle->rpc_handle, b_buffer);
+
if (ret == HAL_CODEC_ERROR_NONE) {
ipc_async_return->wait_result[type] = true;
end_time = g_get_monotonic_time() + G_TIME_SPAN_SECOND;
__hal_codec_ipc_input_buffer_pop(ipc_buffer, buffer->index);
}
+_IPC_DECODE_DONE:
+ if (fd_handle)
+ rpc_port_proxy_array_file_desc_destroy(fd_handle);
bundle_free(b_buffer);
return ret;
goto _IPC_ENCODE_DONE;
}
- ipc_ret = rpc_port_proxy_array_file_desc_create(&fd_handle);
- if (ipc_ret != RPC_PORT_ERROR_NONE) {
+ fd_handle = __hal_codec_ipc_fd_handle_new(buffer->memory.num_fd, buffer->memory.fd);
+ if (!fd_handle) {
SLOGE("fd handle create failed[0x%x]", ipc_ret);
ret = HAL_CODEC_ERROR_OUT_OF_MEMORY;
goto _IPC_ENCODE_DONE;
}
- if (buffer->memory.num_fd > 0) {
- SLOGD("num_fd[%u] fd[%d/%d/%d/%d]", buffer->memory.num_fd,
- buffer->memory.fd[0], buffer->memory.fd[1], buffer->memory.fd[2], buffer->memory.fd[3]);
-
- ipc_ret = rpc_port_proxy_array_file_desc_set(fd_handle, buffer->memory.fd, buffer->memory.num_fd);
- if (ipc_ret != RPC_PORT_ERROR_NONE) {
- SLOGE("fd set failed[0x%x]", ipc_ret);
- ret = HAL_CODEC_ERROR_INTERNAL;
- goto _IPC_ENCODE_DONE;
- }
- }
-
if (__hal_codec_ipc_input_buffer_push(ipc_buffer, buffer) != HAL_CODEC_ERROR_NONE) {
ret = HAL_CODEC_ERROR_INTERNAL;
goto _IPC_ENCODE_DONE;
bundle_add_byte(b_msg, HAL_CODEC_IPC_PARAM_KEY_BUFFER, (const void *)buffer, sizeof(hal_codec_buffer_s));
if (service_handle->type == HAL_CODEC_TYPE_DECODER) {
- for (i = 0 ; i < buffer->planes.num_planes ; i++) {
- if (!buffer->planes.plane[i].data) {
- HAL_CODEC_SERVICE_LOGW("invalid ptr: buffer[%d][plane:%d] %p",
- buffer->index, i, buffer->planes.plane[i].data);
- continue;
- }
-
- HAL_CODEC_SERVICE_LOGD("[DECODER] free INPUT_BUFFER: buffer[%d][plane:%d] %p",
- buffer->index, i, buffer->planes.plane[i].data);
+ if (buffer->meta.flags & HAL_CODEC_BUFFER_FLAG_SECURE) {
+ for (i = 0 ; i < buffer->memory.num_fd ; i++) {
+ if (buffer->memory.fd[i] < 0) {
+ HAL_CODEC_SERVICE_LOGW("invalid fd: buffer[%d] fd[%u] %d",
+ buffer->index, i, buffer->memory.fd[i]);
+ continue;
+ }
+
+ HAL_CODEC_SERVICE_LOGD("[DECODER] close INPUT_BUFFER: buffer[%d] fd[%u] %d",
+ buffer->index, i, buffer->memory.fd[i]);
- g_free(buffer->planes.plane[i].data);
+ close(buffer->memory.fd[i]);
+ }
+ } else {
+ for (i = 0 ; i < buffer->planes.num_planes ; i++) {
+ if (!buffer->planes.plane[i].data) {
+ HAL_CODEC_SERVICE_LOGW("invalid ptr: buffer[%d][plane:%d] %p",
+ buffer->index, i, buffer->planes.plane[i].data);
+ continue;
+ }
+
+ HAL_CODEC_SERVICE_LOGD("[DECODER] free INPUT_BUFFER: buffer[%d][plane:%d] %p",
+ buffer->index, i, buffer->planes.plane[i].data);
+
+ g_free(buffer->planes.plane[i].data);
+ }
}
} else {
for (i = 0 ; i < buffer->memory.num_fd ; i++) {
}
-static int _hal_codec_service_backend_encode(rpc_port_stub_codec_context_h context,
- bundle *b_buffer, rpc_port_stub_array_file_desc_h fd_handle, void *user_data)
+static int __hal_codec_service_process_fd(hal_codec_service_s *service_handle,
+ bundle *b_buffer, rpc_port_stub_array_file_desc_h fd_handle, hal_codec_service_task_cmd_e command)
{
int i = 0;
int ipc_ret = 0;
void *b_data = NULL;
size_t b_size = 0;
hal_codec_buffer_s *buffer = NULL;
- hal_codec_service_s *service_handle = __hal_codec_service_get_handle(context);
- HAL_CODEC_SERVICE_RETURN_VAL_IF_FAILED_CONTEXT(service_handle, HAL_CODEC_ERROR_INTERNAL);
- HAL_CODEC_SERVICE_RETURN_VAL_IF_FAILED_CONTEXT(fd_handle, HAL_CODEC_ERROR_INTERNAL);
+ HAL_CODEC_SERVICE_RETURN_VAL_IF_FAILED(service_handle, HAL_CODEC_ERROR_INTERNAL);
+ HAL_CODEC_SERVICE_RETURN_VAL_IF_FAILED(fd_handle, HAL_CODEC_ERROR_INTERNAL);
ipc_ret = bundle_get_byte(b_buffer, HAL_CODEC_IPC_PARAM_KEY_BUFFER, &b_data, &b_size);
if (ipc_ret != BUNDLE_ERROR_NONE || b_data == NULL || b_size != sizeof(hal_codec_buffer_s)) {
- HAL_CODEC_SERVICE_LOGE_CONTEXT("get data to encode failed[0x%x,%p,%zu/%zu]",
- ipc_ret, b_data, b_size, sizeof(hal_codec_buffer_s));
+ HAL_CODEC_SERVICE_LOGE("command[%d] get data failed[0x%x,%p,%zu/%zu]",
+ command, ipc_ret, b_data, b_size, sizeof(hal_codec_buffer_s));
return HAL_CODEC_ERROR_INTERNAL;
}
ipc_ret = rpc_port_stub_array_file_desc_get(fd_handle, &fd, &fd_size);
if (ipc_ret != RPC_PORT_ERROR_NONE || !fd || buffer->memory.num_fd != (uint32_t)fd_size) {
- HAL_CODEC_SERVICE_LOGE_CONTEXT("get fd failed[0x%x,%p], num_fd[%u] vs fd_size[%d]",
- ipc_ret, fd, buffer->memory.num_fd, fd_size);
+ HAL_CODEC_SERVICE_LOGE("command[%d] get fd failed[0x%x,%p], num_fd[%u] vs fd_size[%d]",
+ command, ipc_ret, fd, buffer->memory.num_fd, fd_size);
g_free(buffer);
return HAL_CODEC_ERROR_INTERNAL;
}
for (i = 0 ; i < fd_size ; i++) {
- HAL_CODEC_SERVICE_LOGD_CONTEXT("fd[%d] %d", i, fd[i]);
+ HAL_CODEC_SERVICE_LOGD("command[%d] fd[%d] %d", command, i, fd[i]);
buffer->memory.fd[i] = fd[i];
/* NOTE: no need to set virtual address, fd will be used only. */
}
- HAL_CODEC_SERVICE_TASK_PUSH_JOB(service_handle->task, HAL_CODEC_SERVICE_TASK_CMD_ENCODE, buffer, -1, SLOGD);
+ HAL_CODEC_SERVICE_LOGD("command[%d] buffer[%d] size[%u] bytesused[%u]",
+ command, buffer->index, buffer->planes.plane[0].size, buffer->planes.plane[0].bytesused);
+
+ HAL_CODEC_SERVICE_TASK_PUSH_JOB(service_handle->task, command, buffer, -1, SLOGD);
return HAL_CODEC_ERROR_NONE;
}
+static int _hal_codec_service_backend_decode_fd(rpc_port_stub_codec_context_h context,
+ bundle *b_buffer, rpc_port_stub_array_file_desc_h fd_handle, void *user_data)
+{
+ return __hal_codec_service_process_fd(__hal_codec_service_get_handle(context),
+ b_buffer, fd_handle, HAL_CODEC_SERVICE_TASK_CMD_DECODE);
+}
+
+
+static int _hal_codec_service_backend_encode(rpc_port_stub_codec_context_h context,
+ bundle *b_buffer, rpc_port_stub_array_file_desc_h fd_handle, void *user_data)
+{
+ return __hal_codec_service_process_fd(__hal_codec_service_get_handle(context),
+ b_buffer, fd_handle, HAL_CODEC_SERVICE_TASK_CMD_ENCODE);
+}
+
+
static int _hal_codec_service_backend_release_output_buffer(rpc_port_stub_codec_context_h context, int buffer_index, void *user_data)
{
hal_codec_service_s *service_handle = __hal_codec_service_get_handle(context);
.stop = _hal_codec_service_backend_stop,
.flush = _hal_codec_service_backend_flush,
.decode = _hal_codec_service_backend_decode,
+ .decode_fd = _hal_codec_service_backend_decode_fd,
.encode = _hal_codec_service_backend_encode,
.release_output_buffer = _hal_codec_service_backend_release_output_buffer,
.get_state = _hal_codec_service_backend_get_state
#define DECODE_FRAME_WIDTH 1920
#define DECODE_FRAME_HEIGHT 1080
+#define DECODE_FRAME_BO_ALLOC_SIZE (1024 * 1024)
#define ENCODE_FRAME_WIDTH 1920
#define ENCODE_FRAME_HEIGHT 1080
#define ENCODE_FRAME_TEST_NUM 60
}
ReleaseContents();
+ }
- return;
+ void AllocMemoryForFd()
+ {
+ bufmgr = tbm_bufmgr_init(-1);
+
+ cout << "Alloc bo for decode_fd test - buffer size: " << DECODE_FRAME_BO_ALLOC_SIZE << endl;
+
+ for (int i = 0 ; i < CONTENTS_H264_FRAME_NUM ; i++) {
+ bo[i] = tbm_bo_alloc(bufmgr, DECODE_FRAME_BO_ALLOC_SIZE, TBM_BO_DEFAULT);
+ fd[i] = tbm_bo_export_fd(bo[i]);
+ cout << "[" << i << "] bo " << bo[i] << ", fd " << fd[i] << endl;
+ }
}
- int FeedDataDecode(void)
+ void ReleaseMemoryForFd()
+ {
+ cout << "Release bo for decode_fd test - buffer size: " << DECODE_FRAME_BO_ALLOC_SIZE << endl;
+
+ for (int i = 0 ; i < CONTENTS_H264_FRAME_NUM ; i++) {
+ cout << "[" << i << "] bo " << bo[i] << ", fd " << fd[i] << endl;
+
+ if (fd[i] > 0)
+ close(fd[i]);
+
+ if (bo[i])
+ tbm_bo_unref(bo[i]);
+ }
+
+ tbm_bufmgr_deinit(bufmgr);
+ }
+
+ int FeedDataDecode()
{
memset(&buffer_[gFeedCount], 0x0, sizeof(hal_codec_buffer_s));
buffer_[gFeedCount].planes.plane[0].data = (unsigned char *)(mappedFileContents_ + mappedFileOffset_);
buffer_[gFeedCount].planes.plane[0].size = buffer_[gFeedCount].size;
buffer_[gFeedCount].planes.plane[0].bytesused = buffer_[gFeedCount].size;
+ if (useFd) {
+ tbm_bo_handle bo_handle = {nullptr, };
+
+ buffer_[gFeedCount].memory.num_fd = 1;
+ buffer_[gFeedCount].memory.fd[0] = fd[gFeedCount];
+
+ bo_handle = tbm_bo_get_handle(bo[gFeedCount], TBM_DEVICE_CPU);
+ memcpy(bo_handle.ptr, buffer_[gFeedCount].planes.plane[0].data, buffer_[gFeedCount].size);
+
+ buffer_[gFeedCount].meta.flags |= HAL_CODEC_BUFFER_FLAG_SECURE;
+ }
cout << "[FeedDataDecode] buffer[" << gFeedCount << "] " << &buffer_[gFeedCount];
cout << " size[" << buffer_[gFeedCount].planes.plane[0].bytesused << "]" << endl;
return G_SOURCE_CONTINUE;
}
+ void DecodeTestCommon()
+ {
+ DECODER_SUPPORT_CHECK;
+
+ ASSERT_NE(gHalHandleDec, nullptr);
+ ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
+ ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_INITIALIZED));
+
+ ret = hal_codec_configure(gHalHandleDec, DECODE_FRAME_WIDTH, DECODE_FRAME_HEIGHT,
+ HAL_CODEC_FORMAT_H264, HAL_CODEC_FORMAT_NV12, false);
+ ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
+ ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_CONFIGURED));
+
+ ret = hal_codec_start(gHalHandleDec, CodecHalTestDecoder::MessageCb, gHalHandleDec);
+ ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
+ ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_STARTED));
+
+ ret = GetContents(CONTENTS_H264_PATH);
+ ASSERT_EQ(ret, 0);
+
+ gMainLoop = g_main_loop_new(nullptr, TRUE);
+
+ gFeedCount = 0;
+ gOutputCount = 0;
+
+ g_timeout_add(50, [](gpointer user_data) -> gboolean {
+ CodecHalTestDecoder *self = (CodecHalTestDecoder *)user_data;
+ return self->FeedDataDecode();
+ }, this);
+
+ gTimeoutSourceID = g_timeout_add(3000, [](gpointer user_data) -> gboolean {
+ cout << "[DECODE] timeout(3000ms) decoded count: " << gOutputCount << endl;
+ g_main_loop_quit(gMainLoop);
+ return G_SOURCE_REMOVE;
+ }, nullptr);
+
+ cout << "[DECODE] timeout source id " << gTimeoutSourceID << endl;
+
+ g_main_loop_run(gMainLoop);
+
+ g_main_loop_unref(gMainLoop);
+ gMainLoop = nullptr;
+
+ ASSERT_NE(gOutputCount, 0);
+
+ ReleaseContents();
+
+ ret = hal_codec_stop(gHalHandleDec);
+ ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
+ ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_CONFIGURED));
+
+ ret = hal_codec_release(gHalHandleDec);
+ ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
+ ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_INITIALIZED));
+ }
+
hal_codec_buffer_s buffer_[CONTENTS_H264_FRAME_NUM + 1] {};
+ tbm_bufmgr bufmgr {};
+ tbm_bo bo[CONTENTS_H264_FRAME_NUM] {};
+ int fd[CONTENTS_H264_FRAME_NUM] {};
+ bool useFd;
};
*/
TEST_F(CodecHalTestDecoder, DecoderDecodeP)
{
- DECODER_SUPPORT_CHECK;
-
- ASSERT_NE(gHalHandleDec, nullptr);
- ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
- ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_INITIALIZED));
-
- ret = hal_codec_configure(gHalHandleDec, DECODE_FRAME_WIDTH, DECODE_FRAME_HEIGHT,
- HAL_CODEC_FORMAT_H264, HAL_CODEC_FORMAT_NV12, false);
- ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
- ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_CONFIGURED));
-
- ret = hal_codec_start(gHalHandleDec, CodecHalTestDecoder::MessageCb, gHalHandleDec);
- ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
- ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_STARTED));
-
- ret = GetContents(CONTENTS_H264_PATH);
- ASSERT_EQ(ret, 0);
-
- gMainLoop = g_main_loop_new(nullptr, TRUE);
-
- gFeedCount = 0;
- gOutputCount = 0;
-
- g_timeout_add(50, [](gpointer user_data) -> gboolean {
- CodecHalTestDecoder *self = (CodecHalTestDecoder *)user_data;
- return self->FeedDataDecode();
- }, this);
-
- gTimeoutSourceID = g_timeout_add(3000, [](gpointer user_data) -> gboolean {
- cout << "[DECODE] timeout(3000ms) decoded count: " << gOutputCount << endl;
- g_main_loop_quit(gMainLoop);
- return G_SOURCE_REMOVE;
- }, nullptr);
-
- cout << "[DECODE] timeout source id " << gTimeoutSourceID << endl;
-
- g_main_loop_run(gMainLoop);
-
- g_main_loop_unref(gMainLoop);
- gMainLoop = nullptr;
-
- ASSERT_NE(gOutputCount, 0);
-
- ReleaseContents();
-
- ret = hal_codec_stop(gHalHandleDec);
- ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
- ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_CONFIGURED));
+ useFd = false;
+ DecodeTestCommon();
+}
- ret = hal_codec_release(gHalHandleDec);
- ASSERT_EQ(ret, HAL_CODEC_ERROR_NONE);
- ASSERT_TRUE(CheckCurrentState(gHalHandleDec, HAL_CODEC_STATE_INITIALIZED));
+/**
+ * @testcase DecoderDecodeFdP
+ * @since_tizen 10.0
+ * @author SR(jm80.yang)
+ * @reviewer SR(heechul.jeon)
+ * @type auto
+ * @description Positive, Decode buffer
+ * @apicovered hal_codec_decode
+ * @passcase when hal_codec_decode returns HAL_CODEC_ERROR_NONE and get decoded buffers
+ * @failcase when hal_codec_decode does not return HAL_CODEC_ERROR_NONE or decoded buffer is not come
+ * @precondition None
+ * @postcondition None
+ */
+TEST_F(CodecHalTestDecoder, DecoderDecodeFdP)
+{
+ useFd = true;
+ AllocMemoryForFd();
+ DecodeTestCommon();
+ ReleaseMemoryForFd();
}
/**
projects / platform / hal / api / codec.git / commitdiff