From 63288c072109d62e63d8778ad03f64338710a275 Mon Sep 17 00:00:00 2001 From: YoungHun Kim Date: Tue, 21 Aug 2012 20:36:05 +0900 Subject: [PATCH] update latest --- TC/_export_env.sh | 8 + TC/_export_target_env.sh | 7 + TC/build.sh | 16 + TC/clean.sh | 11 + TC/config.default | 3 + TC/execute.sh | 15 + TC/testcase/Makefile | 25 ++ TC/testcase/sample.jpg | Bin 0 -> 38184 bytes TC/testcase/tslist | 3 + TC/testcase/utc_image_util_jpeg.c | 469 ++++++++++++++++++++ TC/testcase/utc_media_image_util_basic.c | 543 +++++++++++++++++++++++ TC/tet_scen | 7 + TC/tetbuild.cfg | 5 + TC/tetclean.cfg | 5 + TC/tetexec.cfg | 5 + debian/changelog | 66 ++- include/image_util.h | 97 +++- packaging/capi-media-image-util.spec | 6 +- src/image_util.c | 66 ++- test/multimeida_image_util_test.c | 141 +++--- 20 files changed, 1391 insertions(+), 107 deletions(-) create mode 100755 TC/_export_env.sh create mode 100755 TC/_export_target_env.sh create mode 100755 TC/build.sh create mode 100755 TC/clean.sh create mode 100755 TC/config.default create mode 100755 TC/execute.sh create mode 100755 TC/testcase/Makefile create mode 100755 TC/testcase/sample.jpg create mode 100755 TC/testcase/tslist create mode 100755 TC/testcase/utc_image_util_jpeg.c create mode 100755 TC/testcase/utc_media_image_util_basic.c create mode 100755 TC/tet_scen create mode 100755 TC/tetbuild.cfg create mode 100755 TC/tetclean.cfg create mode 100755 TC/tetexec.cfg diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..72a11ec --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..5ddaa53 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,7 @@ +#!/bin/sh +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +RESULT_DIR=results + +tcc -c -p ./ # executing tcc, with clean option (-c) +rm -r $RESULT_DIR +rm -r tet_tmp_dir +rm testcase/tet_captured diff --git a/TC/config.default b/TC/config.default new file mode 100755 index 0000000..12ac1e2 --- /dev/null +++ b/TC/config.default @@ -0,0 +1,3 @@ +CAPI_PROJECT_ROOT=/home/abyss/capi +TET_INSTALL_HOST_PATH=/home/abyss/TETware +TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..a4f6095 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +. ./_export_target_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile new file mode 100755 index 0000000..fbb2cbe --- /dev/null +++ b/TC/testcase/Makefile @@ -0,0 +1,25 @@ +CC ?= gcc + +C_FILES = $(shell ls *.c) + +PKGS = capi-media-image-util dlog glib-2.0 + +LDFLAGS = `pkg-config --libs $(PKGS)` +LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s + +CFLAGS = -I. `pkg-config --cflags $(PKGS)` +CFLAGS += -I$(TET_ROOT)/inc/tet3 +CFLAGS += -Wall + +#TARGETS = $(C_FILES:%.c=tc-%) +TCS := $(shell ls -1 *.c | cut -d. -f1) + +all: $(TCS) + +%: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean: + rm -f $(TCS) diff --git a/TC/testcase/sample.jpg b/TC/testcase/sample.jpg new file mode 100755 index 0000000000000000000000000000000000000000..7222371eaebf895c2f96d8fbb4059dc677fb13b9 GIT binary patch literal 38184 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 literal 0 HcmV?d00001 diff --git a/TC/testcase/tslist b/TC/testcase/tslist new file mode 100755 index 0000000..becb7ea --- /dev/null +++ b/TC/testcase/tslist @@ -0,0 +1,3 @@ +/testcase/utc_image_util_jpeg +/testcase/utc_media_image_util_basic + diff --git a/TC/testcase/utc_image_util_jpeg.c b/TC/testcase/utc_image_util_jpeg.c new file mode 100755 index 0000000..9b692c5 --- /dev/null +++ b/TC/testcase/utc_image_util_jpeg.c @@ -0,0 +1,469 @@ +/* +* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + + +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +#define SAMPLE_JPEG "sample.jpg" +#define WRONG_PATH "" +#define OUTPUT_JPEG "test_output.jpg" + +image_util_colorspace_e SUPPORTED_COLORSPACE; +image_util_colorspace_e NOT_SUPPORTED_COLORSPACE; +image_util_colorspace_e FIRST_COLORSPACE; +image_util_colorspace_e LAST_COLORSPACE; + +/** + * @brief Global struct for raw image data + */ +struct{ + unsigned char *buffer; + int size; + int w; + int h; +}raw_image = {NULL, 0, 0, 0}; + + +/** + * @brief Global struct for jpeg image + */ +struct{ + unsigned char *buffer; + int size; +}jpeg_image = {NULL, 0}; + + +#define API_NAME_IMAGE_UTIL_DECODE_JPEG "image_util_decode_jpeg" +#define API_NAME_IMAGE_UTIL_ENCODE_JPEG "image_util_encode_jpeg" +#define API_NAME_IMAGE_UTIL_DECODE_JPEG_FROM_MEMORY "image_util_decode_jpeg_from_memory" +#define API_NAME_IMAGE_UTIL_ENCODE_JPEG_TO_MEMORY "image_util_encode_jpeg_to_memory" + +static void utc_image_util_decode_jpeg_n_1(void); +static void utc_image_util_decode_jpeg_n_2(void); +static void utc_image_util_decode_jpeg_n_3(void); +static void utc_image_util_decode_jpeg_n_4(void); +static void utc_image_util_decode_jpeg_n_5(void); +static void utc_image_util_decode_jpeg_p(void); +static void utc_image_util_decode_jpeg_from_memory_n_1(void); +static void utc_image_util_decode_jpeg_from_memory_n_2(void); +static void utc_image_util_decode_jpeg_from_memory_n_3(void); +static void utc_image_util_decode_jpeg_from_memory_n_4(void); +static void utc_image_util_decode_jpeg_from_memory_p(void); +static void utc_image_util_encode_jpeg_n_1(void); +static void utc_image_util_encode_jpeg_n_2(void); +static void utc_image_util_encode_jpeg_n_3(void); +static void utc_image_util_encode_jpeg_n_4(void); +static void utc_image_util_encode_jpeg_n_5(void); +static void utc_image_util_encode_jpeg_p(void); +static void utc_image_util_encode_jpeg_to_memory_n_1(void); +static void utc_image_util_encode_jpeg_to_memory_n_2(void); +static void utc_image_util_encode_jpeg_to_memory_n_3(void); +static void utc_image_util_encode_jpeg_to_memory_n_4(void); +static void utc_image_util_encode_jpeg_to_memory_p(void); + +enum +{ + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { +/** + * image_util_decode_jpeg + */ + { utc_image_util_decode_jpeg_n_1, 1 }, + { utc_image_util_decode_jpeg_n_2, 2 }, + { utc_image_util_decode_jpeg_n_3, 3 }, + { utc_image_util_decode_jpeg_n_4, 4 }, + { utc_image_util_decode_jpeg_n_5, 5 }, + { utc_image_util_decode_jpeg_p, 6}, + +/** + * image_util_encode_jpeg + */ + { utc_image_util_encode_jpeg_n_1, 7 }, + { utc_image_util_encode_jpeg_n_2, 8 }, + { utc_image_util_encode_jpeg_n_3, 9 }, + { utc_image_util_encode_jpeg_n_4, 10 }, + { utc_image_util_encode_jpeg_n_5, 11 }, + { utc_image_util_encode_jpeg_p, 12}, + +/** + * image_util_encode_jpeg_to_memory + */ + { utc_image_util_encode_jpeg_to_memory_n_1, 13 }, + { utc_image_util_encode_jpeg_to_memory_n_2, 14 }, + { utc_image_util_encode_jpeg_to_memory_n_3, 15 }, + { utc_image_util_encode_jpeg_to_memory_n_4, 16 }, + { utc_image_util_encode_jpeg_to_memory_p, 17 }, + +/** + * image_util_decode_jpeg_from_memory + */ + { utc_image_util_decode_jpeg_from_memory_n_1, 18 }, + { utc_image_util_decode_jpeg_from_memory_n_2, 19 }, + { utc_image_util_decode_jpeg_from_memory_n_3, 20 },// SIGSEGV from api + { utc_image_util_decode_jpeg_from_memory_n_4, 21 }, + { utc_image_util_decode_jpeg_from_memory_p, 22 }, // SIGSEGV from api + { NULL, 0 }, +}; + +/** + * @brief Callback to find first supported colorspace + */ +static bool find_first_supported_colorspace_cb( image_util_colorspace_e colorspace, void * user_data) +{ + *(int*)user_data = colorspace; + return false; +} + +static void startup(void) +{ + /* start of TC */ + tet_printf("\n TC start"); + // set first not supportes colorspace + image_util_foreach_supported_jpeg_colorspace( find_first_supported_colorspace_cb , (void*)(&SUPPORTED_COLORSPACE) ); + + // set oher colorspaces + NOT_SUPPORTED_COLORSPACE = IMAGE_UTIL_COLORSPACE_YUV422; //TODO: FIND NOT SUPPORTED FORMAT + FIRST_COLORSPACE = IMAGE_UTIL_COLORSPACE_YV12; + LAST_COLORSPACE = IMAGE_UTIL_COLORSPACE_BGRX8888; + + // prepare buffers for raw and jpeg images + if(image_util_decode_jpeg(SAMPLE_JPEG, SUPPORTED_COLORSPACE, &raw_image.buffer, &raw_image.w, &raw_image.h, &raw_image.size) == IMAGE_UTIL_ERROR_NONE){ + tet_printf("\n raw_image initialization OK"); + if(image_util_encode_jpeg_to_memory(raw_image.buffer, raw_image.w , raw_image.h , SUPPORTED_COLORSPACE, 100, &jpeg_image.buffer, &jpeg_image.size) == IMAGE_UTIL_ERROR_NONE) + tet_printf("\n jpeg_image initialization OK"); + else + tet_printf("\n jpeg_image initialization FAILED"); + } + else + tet_printf("\n raw_image initialization FAILED"); +} + +static void cleanup(void) +{ + /* end of TC */ + free(raw_image.buffer); + free(jpeg_image.buffer); + tet_printf("\n TC end"); +} + +/** + * @brief Negative test case of image_util_decode_jpeg(). Invalid path or image_buffer parameters; + */ +static void utc_image_util_decode_jpeg_n_1(void) +{ + int r; + int w, h; + int size; + + r = image_util_decode_jpeg(NULL, SUPPORTED_COLORSPACE, NULL, &w, &h, &size); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_decode_jpeg(). Parameter colorspace over the range. + */ +static void utc_image_util_decode_jpeg_n_2(void) +{ + int r; + int w, h; + int size; + unsigned char *buffer = NULL; + + r = image_util_decode_jpeg(SAMPLE_JPEG, LAST_COLORSPACE + 1, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_decode_jpeg(). Parameter colorspace below the range. + */ +static void utc_image_util_decode_jpeg_n_3(void) +{ + int r; + int w, h; + int size; + unsigned char *buffer = NULL; + + r = image_util_decode_jpeg(SAMPLE_JPEG, FIRST_COLORSPACE - 1, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_decode_jpeg(). Not supported format. + */ +static void utc_image_util_decode_jpeg_n_4(void) +{ + int r; + int w, h; + int size; + unsigned char *buffer = NULL; + + r = image_util_decode_jpeg(SAMPLE_JPEG, NOT_SUPPORTED_COLORSPACE, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG, r, IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT); +} + +/** + * @brief Negative test case of image_util_decode_jpeg(). Wrong image file path. (Incomplete documentation!) + */ +static void utc_image_util_decode_jpeg_n_5(void) +{ + int r; + int w, h; + int size; + unsigned char *buffer = NULL; + + r = image_util_decode_jpeg(WRONG_PATH, SUPPORTED_COLORSPACE, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG, r, IMAGE_UTIL_ERROR_NO_SUCH_FILE); +} + + +/** + * @brief Positive test case of image_util_decode_jpeg(). Al parameters OK, Success expected. + */ +static void utc_image_util_decode_jpeg_p(void) +{ + int r; + unsigned char *buffer = NULL; + int w, h; + int size; + + r = image_util_decode_jpeg(SAMPLE_JPEG, SUPPORTED_COLORSPACE, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG, r, IMAGE_UTIL_ERROR_NONE); +} + + +/** + * @brief Negative test case of image_util_decode_jpeg_from_memory(). Invalid jpeg_buffer or image_buffer parameters; + */ +static void utc_image_util_decode_jpeg_from_memory_n_1(void) +{ + int r; + int w, h; + int size; + + r = image_util_decode_jpeg_from_memory(NULL, jpeg_image.size, SUPPORTED_COLORSPACE, NULL, &w, &h, &size); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG_FROM_MEMORY, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_decode_jpeg_from_memory(). Parameter colorspace below the range. + */ +static void utc_image_util_decode_jpeg_from_memory_n_2(void) +{ + int r; + unsigned char *buffer = NULL; + int w, h; + int size; + + r = image_util_decode_jpeg_from_memory(jpeg_image.buffer, jpeg_image.size, FIRST_COLORSPACE -1, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG_FROM_MEMORY, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_decode_jpeg_from_memory(). Parameter colorspace over the range. + */ +static void utc_image_util_decode_jpeg_from_memory_n_3(void) +{ + int r; + unsigned char *buffer = NULL; + int w, h; + int size; + + r = image_util_decode_jpeg_from_memory(jpeg_image.buffer, jpeg_image.size, LAST_COLORSPACE + 1, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG_FROM_MEMORY, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_decode_jpeg_from_memory(). Not supported format. + */ +static void utc_image_util_decode_jpeg_from_memory_n_4(void) +{ + int r; + unsigned char *buffer = NULL; + int w, h; + int size; + + r = image_util_decode_jpeg_from_memory(jpeg_image.buffer, jpeg_image.size, NOT_SUPPORTED_COLORSPACE, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG_FROM_MEMORY, r, IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT); +} + + +/** + * @brief Positive test image_util_decode_jpeg_from_memory(). Al parameters OK, Success expected. + */ +static void utc_image_util_decode_jpeg_from_memory_p(void) +{ + int r; + unsigned char *buffer = NULL; + int w, h; + int size; + + r = image_util_decode_jpeg_from_memory(jpeg_image.buffer, jpeg_image.size, SUPPORTED_COLORSPACE, &buffer, &w, &h, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_DECODE_JPEG_FROM_MEMORY, r, IMAGE_UTIL_ERROR_NONE); +} +/** + * @brief Negative test case of image_util_encode_jpeg(). Invalid path or buffer parameters; + */ +static void utc_image_util_encode_jpeg_n_1(void) +{ + int r; + + r = image_util_encode_jpeg(NULL, raw_image.w , raw_image.h , SUPPORTED_COLORSPACE, 100, NULL); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_encode_jpeg(). Parameter colorspace over the range. + */ +static void utc_image_util_encode_jpeg_n_2(void) +{ + int r; + + r = image_util_encode_jpeg(raw_image.buffer, raw_image.w , raw_image.h , LAST_COLORSPACE + 1, 100, OUTPUT_JPEG); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} +/** + * @brief Negative test case of image_util_encode_jpeg(). Parameter colorspace below the range. + */ +static void utc_image_util_encode_jpeg_n_3(void) +{ + int r; + + r = image_util_encode_jpeg(raw_image.buffer, raw_image.w , raw_image.h , FIRST_COLORSPACE -1, 100, OUTPUT_JPEG); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_encode_jpeg(). Not supported format. + */ +static void utc_image_util_encode_jpeg_n_4(void) +{ + int r; + + r = image_util_encode_jpeg(raw_image.buffer, raw_image.w , raw_image.h , NOT_SUPPORTED_COLORSPACE, 100, OUTPUT_JPEG); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG, r, IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT); +} + + +/** + * @brief Negative test case of image_util_encode_jpeg(). Wrong image file path. + */ +static void utc_image_util_encode_jpeg_n_5(void) +{ + int r; + + r = image_util_encode_jpeg(raw_image.buffer, raw_image.w , raw_image.h , SUPPORTED_COLORSPACE, 100, WRONG_PATH); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG, r, IMAGE_UTIL_ERROR_NO_SUCH_FILE); +} + + +/** + * @brief Positive test case of image_util_encode_jpeg(). Al parameters OK, Success expected. + */ +static void utc_image_util_encode_jpeg_p(void) +{ + int r; + + r = image_util_encode_jpeg(raw_image.buffer, raw_image.w , raw_image.h , SUPPORTED_COLORSPACE, 100, OUTPUT_JPEG); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG, r, IMAGE_UTIL_ERROR_NONE); +} + +/** + * @brief Negative test case of image_util_encode_jpeg_to_memory(). Invalid path or image_buffer or jpeg_buffer parameters; + */ +static void utc_image_util_encode_jpeg_to_memory_n_1(void) +{ + int r; + int size; + + r = image_util_encode_jpeg_to_memory(NULL, 5 , 5 , SUPPORTED_COLORSPACE, 100, NULL, &size); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG_TO_MEMORY, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_encode_jpeg_to_memory(). Parameter colorspace over the range. + */ +static void utc_image_util_encode_jpeg_to_memory_n_2(void) +{ + int r; + unsigned char *buffer = NULL; + int size; + + r = image_util_encode_jpeg_to_memory(raw_image.buffer, raw_image.w , raw_image.h , FIRST_COLORSPACE - 1, 100, &buffer, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG_TO_MEMORY, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_encode_jpeg_to_memory(). Parameter colorspace below the range. + */ +static void utc_image_util_encode_jpeg_to_memory_n_3(void) +{ + int r; + unsigned char *buffer = NULL; + int size; + + r = image_util_encode_jpeg_to_memory(raw_image.buffer, raw_image.w , raw_image.h , LAST_COLORSPACE + 1, 100, &buffer, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG_TO_MEMORY, r, IMAGE_UTIL_ERROR_INVALID_PARAMETER); +} + +/** + * @brief Negative test case of image_util_encode_jpeg_to_memory(). Not supported format. + */ +static void utc_image_util_encode_jpeg_to_memory_n_4(void) +{ + int r; + unsigned char *buffer = NULL; + int size; + + r = image_util_encode_jpeg_to_memory(raw_image.buffer, raw_image.w , raw_image.h , NOT_SUPPORTED_COLORSPACE, 100, &buffer, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG_TO_MEMORY, r, IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT); +} + +/** + * @brief Positive test case of image_util_encode_jpeg_to_memory(). Al parameters OK, Success expected. + */ +static void utc_image_util_encode_jpeg_to_memory_p(void) +{ + int r; + unsigned char *buffer = NULL; + int size; + + r = image_util_encode_jpeg_to_memory(raw_image.buffer, raw_image.w , raw_image.h , SUPPORTED_COLORSPACE, 100, &buffer, &size); + free(buffer); + dts_check_eq(API_NAME_IMAGE_UTIL_ENCODE_JPEG_TO_MEMORY, r, IMAGE_UTIL_ERROR_NONE); +} diff --git a/TC/testcase/utc_media_image_util_basic.c b/TC/testcase/utc_media_image_util_basic.c new file mode 100755 index 0000000..cfaf7aa --- /dev/null +++ b/TC/testcase/utc_media_image_util_basic.c @@ -0,0 +1,543 @@ +/* +* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include +#include +#include + + + +#define API_NAME_IMAGEUTIL_COLORSPACE "image_util_colorspace" +#define API_NAME_IMAGEUTIL_COLOR_CONVERT "image_util_color_convert" +#define API_NAME_IMAGEUTIL_BUFFER_SIZE "image_util_buffer_size" +#define API_NAME_IMAGEUTIL_TRANSFORM "image_util_color_transform" + +#define SAMPLE_FILENAME "./sample.jpg" + +#define LAST_COLORSPACE IMAGE_UTIL_COLORSPACE_BGRX8888 + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +//Retrieves all supported JPEG encoding/decoding colorspace by invoking a callback function once for each one. +static void utc_image_util_supported_jpeg_colorspace_p(void); // how many colorspaces are available +static void utc_image_util_supported_jpeg_colorspace_2_p(void); // does ,,foreach'' return pass? +static void utc_image_util_supported_jpeg_colorspace_3_p(void); // does ,,foreach'' return pass for all cases? + +//Convert the image's colorspace. +static void utc_image_util_convert_colorspace_p(void); +static void utc_image_util_convert_colorspace_1_n(void); +static void utc_image_util_convert_colorspace_2_n(void); + +//Calculates the size of image buffer for the specified resolution and colorspace. +static void utc_image_util_calculate_bufsize_result_p(void); +static void utc_image_util_calculate_bufsize_result_1_n(void); +static void utc_image_util_calculate_bufsize_result_2_n(void); +static void utc_image_util_calculate_bufsize_result_3_n(void); +static void utc_image_util_calculate_bufsize_result_4_p(void); +static void utc_image_util_calculate_bufsize_result_5_p(void); + + +//Transforms the image to with the specified destination width and height and angle in degrees. +static void utc_image_util_file_rotate_p(void); +static void utc_image_util_file_rotate_2_p(void); +static void utc_image_util_file_rotate_3_p(void); + + + + +static bool jpeg_colorspace_cb( image_util_colorspace_e colorspace, void * user_data); +static bool jpeg_colorspace_quit_cb( image_util_colorspace_e colorspace, void * user_data); +static bool jpeg_colorspace_size_cb( image_util_colorspace_e colorspace, void * user_data); + + +//available transforms +#define AT_COUTN 4 +const int avail_trans[AT_COUTN] = +{ + IMAGE_UTIL_COLORSPACE_YV12, + IMAGE_UTIL_COLORSPACE_I420, + IMAGE_UTIL_COLORSPACE_NV12, + IMAGE_UTIL_COLORSPACE_RGB888, +}; + + + +enum +{ + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + + + + +struct tet_testlist tet_testlist[] = { + { utc_image_util_supported_jpeg_colorspace_p, 1}, + { utc_image_util_supported_jpeg_colorspace_2_p, 2}, + { utc_image_util_supported_jpeg_colorspace_3_p, 3}, + { utc_image_util_calculate_bufsize_result_p, 4}, + { utc_image_util_calculate_bufsize_result_1_n, 5}, + { utc_image_util_calculate_bufsize_result_2_n, 6}, + { utc_image_util_calculate_bufsize_result_3_n, 7}, + { utc_image_util_calculate_bufsize_result_4_p, 8}, + { utc_image_util_calculate_bufsize_result_5_p, 9}, + { utc_image_util_convert_colorspace_p, 10}, + { utc_image_util_convert_colorspace_1_n, 11}, + { utc_image_util_convert_colorspace_2_n, 12}, + { utc_image_util_file_rotate_p, 13}, + { utc_image_util_file_rotate_2_p, 14}, + { utc_image_util_file_rotate_3_p, 15}, + { NULL, 0}, +}; + + +static void startup(void) +{ + // TC start +} + +static void cleanup(void) +{ + // TC end +} + + + +static bool jpeg_colorspace_cb( image_util_colorspace_e colorspace, void * user_data) +{ + return true; +} + + +static bool jpeg_colorspace_quit_cb( image_util_colorspace_e colorspace, void * user_data) +{ + int last = *((int*)user_data); + return (int)colorspace == last ? false : true; +} + + + +static bool jpeg_colorspace_size_cb( image_util_colorspace_e colorspace, void * user_data) +{ + int * result = (int*)user_data; + + const int W = 480, H = 320; // these values are taken from test file - sample.jpg + int width = 0, height = 0; + int size_decode = 0; + unsigned int size_calc = 0; + unsigned char * img_buf = 0; + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, colorspace, &img_buf, &width, &height, &size_decode ); + + // prepare buffers + image_util_calculate_buffer_size( W, H, colorspace, &size_calc ); + + free( img_buf ); + + *result = (size_decode == size_calc); + + // if false then callbacks stop + return *result; +} + + + + + +/** + * @brief how many colorspaces are available + */ +static void utc_image_util_supported_jpeg_colorspace_p(void) +{ + int pointer = 0; + int ret = image_util_foreach_supported_jpeg_colorspace( NULL , (void*)(&pointer) ); + dts_check_eq( API_NAME_IMAGEUTIL_COLORSPACE, ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER ); +} + + + + + + + +/** + * @brief does ,,foreach'' return pass? + */ +static void utc_image_util_supported_jpeg_colorspace_2_p(void) +{ + int err = image_util_foreach_supported_jpeg_colorspace( jpeg_colorspace_cb , (void*)NULL ); + dts_check_eq( API_NAME_IMAGEUTIL_COLORSPACE, err, IMAGE_UTIL_ERROR_NONE ); +} + + + + + + + +/** + * @brief does ,,foreach'' return pass for all cases? + */ +static void utc_image_util_supported_jpeg_colorspace_3_p(void) +{ + int err; + char buf[100] = { '\0' }; + snprintf( buf, 100, "%s", API_NAME_IMAGEUTIL_COLORSPACE ); + + // parameter i decides when loop of callbacks should break + int i; + for( i = 0; i < LAST_COLORSPACE; ++i ) + { + err = image_util_foreach_supported_jpeg_colorspace( jpeg_colorspace_quit_cb , (void*)(&i) ); + if( err != 0 ) + { + sprintf( buf, " [error: colorspace_2_p on position %d]", i ); + break; + } + } + + dts_check_eq( buf, err, 0 ); +} + + + + + + +/** + * @brief check the buffer size calculation with correct parameters + */ +static void utc_image_util_calculate_bufsize_result_p(void) +{ + int width = 100, height = 20; + unsigned int size = 0; + + int err = image_util_calculate_buffer_size( width, height, IMAGE_UTIL_COLORSPACE_RGB888, &size ); + dts_check_eq( API_NAME_IMAGEUTIL_BUFFER_SIZE, err, 0 ); +} + + + + + +/** + * @brief check the buffer size calculation with uncorrect parameters + */ +static void utc_image_util_calculate_bufsize_result_1_n(void) +{ + int width = 100, height = 20; + unsigned int size = 0; + const int colorspace = IMAGE_UTIL_COLORSPACE_BGRX8888 + 1; // after last one + + int err = image_util_calculate_buffer_size( width, height, colorspace, &size ); + dts_check_ne( API_NAME_IMAGEUTIL_BUFFER_SIZE, err, 0 ); +} + + + + + + +/** + * @brief check the buffer size calculation with uncorrect parameters + */ +static void utc_image_util_calculate_bufsize_result_2_n(void) +{ + int width = -100, height = 20; // wrong parameter + unsigned int size = 0; + const int colorspace = IMAGE_UTIL_COLORSPACE_BGRX8888; + + int err = image_util_calculate_buffer_size( width, height, colorspace, &size ); + dts_check_ne( API_NAME_IMAGEUTIL_BUFFER_SIZE, err, 0 ); +} + + + + + + +/** + * @brief check the buffer size calculation with uncorrect parameters + */ +static void utc_image_util_calculate_bufsize_result_3_n(void) +{ + int width = 0, height = 0; // wrong parameter + unsigned int size = 0; + const int colorspace = IMAGE_UTIL_COLORSPACE_BGRX8888; + + int err = image_util_calculate_buffer_size( width, height, colorspace, &size ); + dts_check_ne( API_NAME_IMAGEUTIL_BUFFER_SIZE, err, 0 ); +} + + + + + +/** + * @brief do the buffer size calculation and check if + * this is the same like with decode_jpeg function + */ +static void utc_image_util_calculate_bufsize_result_4_p(void) +{ + const int W = 480, H = 320; // these values are taken from original file sample.jpg + int width = 0, height = 0; + int size_decode = 0; + unsigned int size_calc = 0; + unsigned char * img_buf = 0; + const image_util_colorspace_e colorspace = IMAGE_UTIL_COLORSPACE_RGB888; + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, colorspace, &img_buf, &width, &height, &size_decode ); + + // prepare buffers + image_util_calculate_buffer_size( W, H, colorspace, &size_calc ); + + free( img_buf ); + + dts_check_eq( API_NAME_IMAGEUTIL_BUFFER_SIZE, (int)size_calc, size_decode ); +} + + + + +/** + * @brief do the buffer size calculation for all colorspaces + * this is similar like ..._calculate_bufsize_result_4_p + */ +static void utc_image_util_calculate_bufsize_result_5_p(void) +{ + int result = -1; + + // do the loop for all colorspaces and check bufsize there inside + image_util_foreach_supported_jpeg_colorspace( jpeg_colorspace_size_cb, (void*)(&result) ); + + // result is taken from inside the colorspace callbacks loop, + // there is compared buffor size + // result takes true or false + dts_check_eq( API_NAME_IMAGEUTIL_BUFFER_SIZE, result, 1 ); +} + + +/** + * @brief check if color conversion returns positive + */ +static void utc_image_util_convert_colorspace_p(void) +{ + int width = 0, height = 0; + unsigned int size_decode = 0; + unsigned char * img_target = 0; + unsigned char * img_source = 0; + const image_util_colorspace_e cs_target = IMAGE_UTIL_COLORSPACE_RGB888; + const image_util_colorspace_e cs_source = IMAGE_UTIL_COLORSPACE_YV12; + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, cs_source, &img_source, &width, &height, &size_decode ); + image_util_calculate_buffer_size(width, height, cs_target , &size_decode); + img_target = malloc( size_decode ); + + // do conversion + int ret = image_util_convert_colorspace( img_target, cs_target, + img_source, width, height, cs_source ); + free( img_target ); + free( img_source ); + + dts_check_eq( API_NAME_IMAGEUTIL_COLOR_CONVERT, ret, IMAGE_UTIL_ERROR_NONE ); +} + + + + + + +/** + * @brief check if color conversion function has the verification of input parameters + */ +static void utc_image_util_convert_colorspace_1_n(void) +{ + int width = 0, height = 0; + unsigned char * img_target = 0; // NULL pointer! + unsigned char * img_source = 0; // NULL pointer! + const image_util_colorspace_e cs_target = IMAGE_UTIL_COLORSPACE_RGB888; + const image_util_colorspace_e cs_source = IMAGE_UTIL_COLORSPACE_YV12; + + // do conversion + int ret = image_util_convert_colorspace( img_target, cs_target, + img_source, width, height, cs_source ); + + dts_check_ne( API_NAME_IMAGEUTIL_COLOR_CONVERT, ret, IMAGE_UTIL_ERROR_NONE ); +} + + + +/** + * @brief check if color conversion has verification of input parameters + */ +static void utc_image_util_convert_colorspace_2_n(void) +{ + int width = 0, height = 0; + int size_decode = 0; + unsigned char * img_target = 0; + unsigned char * img_source = 0; + const image_util_colorspace_e cs_target = IMAGE_UTIL_COLORSPACE_BGRX8888 + 1; // out of the scope! + const image_util_colorspace_e cs_source = IMAGE_UTIL_COLORSPACE_YV12; + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, cs_source, &img_source, &width, &height, &size_decode ); + + // do conversion + int ret = image_util_convert_colorspace( img_target, cs_target, + img_source, width, height, cs_source ); + free( img_target ); + free( img_source ); + + dts_check_ne( API_NAME_IMAGEUTIL_COLOR_CONVERT, ret, IMAGE_UTIL_ERROR_NONE ); +} + + + + +/** + * @brief Simple use of transformation + */ +static void utc_image_util_file_rotate_p(void) +{ + int width = 0, height = 0; + int size_decode = 0; + unsigned char * img_target = 0; + unsigned char * img_source = 0; + + image_util_rotation_e dest_rotation = IMAGE_UTIL_ROTATION_90; + + const image_util_colorspace_e colorspace = IMAGE_UTIL_COLORSPACE_RGB888; + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, colorspace, &img_source, &width, &height, &size_decode ); + + image_util_calculate_buffer_size(width, height, colorspace , &size_decode); + + img_target = malloc( size_decode ); + + // do rotation + int ret = image_util_rotate( img_target, &width, &height, dest_rotation, + img_source, width, height, colorspace ); + + free( img_target ); + free( img_source ); + + dts_check_eq( API_NAME_IMAGEUTIL_TRANSFORM, ret, IMAGE_UTIL_ERROR_NONE ); +} + + + + + +/** + * @brief Image transformation for all rotation types + */ +static void utc_image_util_file_rotate_2_p(void) +{ + int ret = -1; + + int width = 0, height = 0; + int target_width , target_height = 0; + int size_decode = 0; + unsigned char * img_target = 0; + unsigned char * img_source = 0; + + const image_util_colorspace_e colorspace = IMAGE_UTIL_COLORSPACE_RGB888; + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, colorspace, &img_source, &width, &height, &size_decode ); + image_util_calculate_buffer_size(width, height, colorspace , &size_decode); + + img_target = malloc( size_decode ); + + image_util_rotation_e rot; + for( rot = IMAGE_UTIL_ROTATION_NONE; + rot <= IMAGE_UTIL_ROTATION_FLIP_VERT; ++rot ) + { + // do rotation + ret = image_util_rotate( img_target, &target_width, &target_height, rot, + img_source, width, height, colorspace ); + + if( ret != 0 ) + break; + } + + free( img_target ); + free( img_source ); + + dts_check_eq( API_NAME_IMAGEUTIL_TRANSFORM, ret, IMAGE_UTIL_ERROR_NONE ); +} + + + + + +/** + * @brief Image transformation for all available colorspaces + */ +static void utc_image_util_file_rotate_3_p(void) +{ + int ret = -1; + + // loop uses all colorspaces for one transformation + int i; + for( i = 0; i < AT_COUTN; ++i ) + { + int width = 0, height = 0; + int size_decode = 0; + unsigned char * img_target = 0; + unsigned char * img_source_converted = 0; + unsigned char * img_source = 0; + + + // load jpeg sample file + image_util_decode_jpeg( SAMPLE_FILENAME, IMAGE_UTIL_COLORSPACE_RGB888 , &img_source, &width, &height, &size_decode ); + // convert target format + if( IMAGE_UTIL_COLORSPACE_RGB888 != avail_trans[i] ){ + image_util_calculate_buffer_size(width, height, avail_trans[i], &size_decode); + img_source_converted = malloc(size_decode); + image_util_convert_colorspace(img_source_converted , avail_trans[i] , img_source , width, height, IMAGE_UTIL_COLORSPACE_RGB888); + free(img_source); + img_source = img_source_converted; + } + + + + image_util_calculate_buffer_size(width, height, avail_trans[i] , &size_decode); + img_target = malloc( size_decode ); + + // do rotation + ret = image_util_rotate( img_target, &width, &height, IMAGE_UTIL_ROTATION_180, + img_source, width, height, avail_trans[i] ); + + free( img_target ); + free( img_source ); + + if( ret != 0 ) + break; + } + + + + dts_check_eq( API_NAME_IMAGEUTIL_TRANSFORM, ret, IMAGE_UTIL_ERROR_NONE ); +} diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..03f029a --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/testcase/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100755 index 0000000..f7eda55 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option for build operation checking +TET_BUILD_TOOL=make # build with using make command +TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build +TET_API_COMPLIANT=True # use TET API in Test Case ? +TET_PASS_TC_NAME=True # report passed TC name in Journal file? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100755 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option +TET_CLEAN_TOOL= make clean # clean tool +TET_CLEAN_FILE= Makefile # file for clean +TET_API_COMPLIANT=True # TET API useage +TET_PASS_TC_NAME=True # showing name , passed TC diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100755 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capturing execution or not +TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional +TET_EXEC_FILE= # ex) exectool : execution file/ Optional +TET_API_COMPLIANT=True # Test case or Tool usesTET API? +TET_PASS_TC_NAME=True # showing Passed TC name ? diff --git a/debian/changelog b/debian/changelog index 54d74d6..a4b16ad 100755 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,19 @@ +capi-media-image-util (0.1.0-11) unstable; urgency=low + + * Add const to the unmodifying input parameter + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-11 + + -- Seungkeun Lee Wed, 23 May 2012 09:13:34 +0900 + +capi-media-image-util (0.1.0-10) unstable; urgency=low + + * remove transform, add rotate/resize/crop , change name YUV420 -> YV12 + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-10 + + -- Seungkeun Lee Wed, 16 May 2012 14:48:40 +0900 + capi-media-image-util (0.1.0-9) unstable; urgency=low * Fix dependency @@ -18,26 +34,54 @@ capi-media-image-util (0.1.0-7) unstable; urgency=low * boundary check update * Git: slp-source.sec.samsung.net:slp/api/image-util - * Tag: capi-media-image-util_0.1.0-7 + * Tag: capi-media-image-util_0.1.0-7 - -- Seungkeun Lee Tue, 31 Jan 2012 14:04:32 +0900 + -- Seungkeun Lee Fri, 27 Jan 2012 14:18:01 +0900 capi-media-image-util (0.1.0-6) unstable; urgency=low - * update image_util_decode_jpeg_from_memory impl. - * Git: api/image-util - * capi-media-image-util_0.1.0-6 + * Update image_util_decode_jpeg_from_memory + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-6 - -- Seungkeun Lee Fri, 23 Dec 2011 17:41:46 +0900 + -- Seungkeun Lee Fri, 06 Jan 2012 17:05:17 +0900 capi-media-image-util (0.1.0-5) unstable; urgency=low - * update version + * Update size parameter types + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-5 + + -- Seungkeun Lee Tue, 06 Dec 2011 11:29:46 +0900 - -- Seungkeun Lee Thu, 15 Dec 2011 12:57:39 +0900 +capi-media-image-util (0.1.0-4) unstable; urgency=low -capi-media-image-util (0.0.1-1) unstable; urgency=low + * update error none value + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-4 - * Initial release. + -- Seungkeun Lee Mon, 05 Dec 2011 11:02:41 +0900 + +capi-media-image-util (0.1.0-3) unstable; urgency=low + + * Update Log formatting + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-3 + + -- Seungkeun Lee Sun, 27 Nov 2011 14:14:10 +0900 + +capi-media-image-util (0.1.0-2) unstable; urgency=low + + * update namespace + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-2 + + -- Seungkeun Lee Wed, 23 Nov 2011 15:07:09 +0900 + +capi-media-image-util (0.1.0-1) unstable; urgency=low + + * SLP API Baseline + * Git: slp-source.sec.samsung.net:slp/api/image-util + * Tag: capi-media-image-util_0.1.0-1 - -- Seungkeun Lee Wed, 07 Dec 2011 12:45:39 +0900 + -- Seungkeun Lee Tue, 27 Sep 2011 17:55:13 +0900 diff --git a/include/image_util.h b/include/image_util.h index be91ff4..ff61a1a 100755 --- a/include/image_util.h +++ b/include/image_util.h @@ -58,13 +58,13 @@ typedef enum */ typedef enum { - IMAGE_UTIL_COLORSPACE_YUV420, /**< YUV420 */ - IMAGE_UTIL_COLORSPACE_YUV422, /**< YUV422 */ - IMAGE_UTIL_COLORSPACE_I420, /**< I420 */ - IMAGE_UTIL_COLORSPACE_NV12, /**< NV12 */ + IMAGE_UTIL_COLORSPACE_YV12, /**< YV12 - YCrCb planar format */ + IMAGE_UTIL_COLORSPACE_YUV422, /**< YUV422 - planer */ + IMAGE_UTIL_COLORSPACE_I420, /**< I420 - planer */ + IMAGE_UTIL_COLORSPACE_NV12, /**< NV12- planer */ - IMAGE_UTIL_COLORSPACE_UYVY, /**< UYVY */ - IMAGE_UTIL_COLORSPACE_YUYV, /**< YUYV */ + IMAGE_UTIL_COLORSPACE_UYVY, /**< UYVY - packed */ + IMAGE_UTIL_COLORSPACE_YUYV, /**< YUYV - packed */ IMAGE_UTIL_COLORSPACE_RGB565, /**< RGB565, high-byte is Blue */ IMAGE_UTIL_COLORSPACE_RGB888, /**< RGB888, high-byte is Blue */ @@ -124,7 +124,7 @@ typedef bool (*image_util_supported_jpeg_colorspace_cb)( image_util_colorspace_e * @see image_util_encode_jpeg() * @see image_util_encode_jpeg_to_memory() * @see image_util_decode_jpeg() - * @see image_util_decode_jpeg_to_memory() + * @see image_util_decode_jpeg_from_memory() */ int image_util_foreach_supported_jpeg_colorspace(image_util_supported_jpeg_colorspace_cb callback, void * user_data); @@ -133,7 +133,7 @@ int image_util_foreach_supported_jpeg_colorspace(image_util_supported_jpeg_color * * @remarks To get @a dest buffer size uses image_util_calculate_buffer_size() * - * @param[out] dest The image buffer for result. Must be allocated by you + * @param[in/out] dest The image buffer for result. Must be allocated by you * @param[in] dest_colorspace The colorspace to be converted * @param[in] src The source image buffer * @param[in] width The width of source image @@ -146,7 +146,7 @@ int image_util_foreach_supported_jpeg_colorspace(image_util_supported_jpeg_color * * @see image_util_calculate_buffer_size() */ -int image_util_convert_colorspace( unsigned char * dest , image_util_colorspace_e dest_colorspace , unsigned char * src , int width, int height, image_util_colorspace_e src_colorspace); +int image_util_convert_colorspace( unsigned char * dest , image_util_colorspace_e dest_colorspace , const unsigned char * src , int width, int height, image_util_colorspace_e src_colorspace); /** * @brief Calculates the size of image buffer for the specified resolution and colorspace @@ -166,20 +166,76 @@ int image_util_convert_colorspace( unsigned char * dest , image_util_colorspace_ int image_util_calculate_buffer_size(int width , int height, image_util_colorspace_e colorspace , unsigned int *size); /** - * @brief Transforms the image to with the specified destination width and height and angle in degrees. + * @brief Resize the image to with the specified destination width and height * - * @remarks Because image processing constraints, the destination image size can be adjusted.\n + * @remarks Because padding of YUV format, the destination image size can be adjusted.\n + * + * @param[in/out] dest The image buffer for result. Must be allocated by you + * @param[in/out] dest_width The image width to resize, and resized width + * @param[in/out] dest_height The image height to resize, and resized height + * @param[in] src The image buffer for origin image + * @param[in] src_width The origin image width + * @param[in] src_height The origin image height + * @param[in] colorspace The image colorspace + * + * @return 0 on success, otherwise a negative error value. + * @retval #IMAGE_UTIL_ERROR_NONE Successful + * @retval #IMAGE_UTIL_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #IMAGE_UTIL_ERROR_INVALID_OPERATION Invalid operation + * + * @see image_util_calculate_buffer_size() + */ +int image_util_resize(unsigned char * dest, int *dest_width , int *dest_height, const unsigned char * src, int src_width, int src_height , image_util_colorspace_e colorspace); + +/** + * @brief Rotate the image to with the specified angle in degrees. + * + * @remarks Because padding of YUV format, the destination image size can be adjusted.\n * Rotations are supported only in these colorspaces\n - * #IMAGE_UTIL_COLORSPACE_YUV420 \n + * #IMAGE_UTIL_COLORSPACE_YV12 \n * #IMAGE_UTIL_COLORSPACE_I420 \n * #IMAGE_UTIL_COLORSPACE_NV12 \n * #IMAGE_UTIL_COLORSPACE_RGB888 \n - * @param[out] dest The image buffer for result. Must be allocated by you - * @param[in/out] dest_width The image width to resize, and changed width - * @param[in/out] dest_height The image height to resize, and changed height + * + * @param[in/out] dest The image buffer for result. Must be allocated by you + * @param[out] dest_width The rotated image width + * @param[out] dest_height The rotated image height * @param[in] dest_rotation The angle to rotate * @param[in] src The image buffer for origin image * @param[in] src_width The origin image width + * @param[in] src_height The origin image height + * @param[in] colorspace The image colorspace + * + * @return 0 on success, otherwise a negative error value. + * @retval #IMAGE_UTIL_ERROR_NONE Successful + * @retval #IMAGE_UTIL_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #IMAGE_UTIL_ERROR_INVALID_OPERATION Invalid operation + * + * @see image_util_calculate_buffer_size() + */ +int image_util_rotate(unsigned char * dest, int *dest_width, int *dest_height, image_util_rotation_e dest_rotation, const unsigned char * src, int src_width, int src_height, image_util_colorspace_e colorspace); + +/** + * @brief Crop the image to with the specified point and dimension + * + * @remarks Because padding of YUV format, the destination image size can be adjusted.\n + * Crop is supported only in these colorspaces\n + * #IMAGE_UTIL_COLORSPACE_YV12 \n + * #IMAGE_UTIL_COLORSPACE_I420 \n + * #IMAGE_UTIL_COLORSPACE_RGB888 \n + * #IMAGE_UTIL_COLORSPACE_RGB565 \n + * #IMAGE_UTIL_COLORSPACE_ARGB8888\n + * #IMAGE_UTIL_COLORSPACE_BGRA8888\n + * #IMAGE_UTIL_COLORSPACE_RGBA8888\n + * #IMAGE_UTIL_COLORSPACE_BGRX8888\n + * + * @param[in/out] dest The image buffer for result. Must be allocated by you + * @param[in] x The starting x-axis of crop + * @param[in] y The starting y-axis of crop + * @param[in/out] width The image width to crop, and cropped width + * @param[in/out] height The image height to crop, and cropped height + * @param[in] src The image buffer for origin image + * @param[in] src_width The origin image width * @param[in] src_height The origin image height * @param[in] colorspace The image colorspace * @@ -188,9 +244,10 @@ int image_util_calculate_buffer_size(int width , int height, image_util_colorspa * @retval #IMAGE_UTIL_ERROR_INVALID_PARAMETER Invalid parameter * @retval #IMAGE_UTIL_ERROR_INVALID_OPERATION Invalid operation * - * @see image_util_calculated_buffer_size() + * @see image_util_calculate_buffer_size() */ -int image_util_transform( unsigned char * dest , int *dest_width , int *dest_height , image_util_rotation_e dest_rotation , unsigned char * src , int src_width, int src_height , image_util_colorspace_e colorspace); +int image_util_crop(unsigned char * dest, int x , int y, int* width, int *height, const unsigned char *src, int src_width, int src_height, image_util_colorspace_e colorspace); + @@ -243,7 +300,7 @@ int image_util_decode_jpeg( const char *path , image_util_colorspace_e colorspac * @see image_util_decode_jpeg() * @see image_util_foreach_supported_jpeg_colorspace() */ -int image_util_decode_jpeg_from_memory( unsigned char * jpeg_buffer , int jpeg_size , image_util_colorspace_e colorspace, unsigned char ** image_buffer , int *width , int *height , unsigned int *size); +int image_util_decode_jpeg_from_memory( const unsigned char * jpeg_buffer , int jpeg_size , image_util_colorspace_e colorspace, unsigned char ** image_buffer , int *width , int *height , unsigned int *size); /** * @brief Encodes image to the jpeg image @@ -266,7 +323,7 @@ int image_util_decode_jpeg_from_memory( unsigned char * jpeg_buffer , int jpeg_s * @see image_util_foreach_supported_jpeg_colorspace() * @see image_util_encode_jpeg_to_memory() */ -int image_util_encode_jpeg( unsigned char *buffer, int width, int height, image_util_colorspace_e colorspace, int quality, const char *path); +int image_util_encode_jpeg( const unsigned char *buffer, int width, int height, image_util_colorspace_e colorspace, int quality, const char *path); /** * @brief Encodes image to the jpeg image @@ -292,7 +349,7 @@ int image_util_encode_jpeg( unsigned char *buffer, int width, int height, image_ * @see image_util_foreach_supported_jpeg_colorspace() * @see image_util_encode_jpeg() */ -int image_util_encode_jpeg_to_memory(unsigned char *image_buffer, int width, int height, image_util_colorspace_e colorspace, int quality, unsigned char** jpeg_buffer, unsigned int *jpeg_size); +int image_util_encode_jpeg_to_memory(const unsigned char *image_buffer, int width, int height, image_util_colorspace_e colorspace, int quality, unsigned char** jpeg_buffer, unsigned int *jpeg_size); diff --git a/packaging/capi-media-image-util.spec b/packaging/capi-media-image-util.spec index 9cfb38b..80efa01 100755 --- a/packaging/capi-media-image-util.spec +++ b/packaging/capi-media-image-util.spec @@ -1,9 +1,9 @@ Name: capi-media-image-util Summary: A Image Utility library in Tizen Native API Version: 0.1.0 -Release: 9 -Group: TO_BE/FILLED_IN -License: Apache-2.0 +Release: 11 +Group: TO_BE_FILLED +License: TO_BE_FILLED Source0: %{name}-%{version}.tar.gz BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(mm-common) diff --git a/src/image_util.c b/src/image_util.c index a375271..7644ebc 100755 --- a/src/image_util.c +++ b/src/image_util.c @@ -111,7 +111,7 @@ int image_util_foreach_supported_jpeg_colorspace(image_util_supported_jpeg_color return IMAGE_UTIL_ERROR_NONE; } -int image_util_convert_colorspace( unsigned char * dest , image_util_colorspace_e dest_colorspace , unsigned char * src , int width, int height, image_util_colorspace_e src_colorspace){ +int image_util_convert_colorspace( unsigned char * dest , image_util_colorspace_e dest_colorspace , const unsigned char * src , int width, int height, image_util_colorspace_e src_colorspace){ int ret; if( dest == NULL || src == NULL ) @@ -137,31 +137,71 @@ int image_util_calculate_buffer_size(int width , int height, image_util_colorspa return _convert_image_util_error_code(__func__, ret); } -int image_util_transform( unsigned char * dest , int *dest_width , int *dest_height , image_util_rotation_e dest_rotation , unsigned char * src , int src_width, int src_height , image_util_colorspace_e colorspace){ +int image_util_resize(unsigned char * dest, int *dest_width , int *dest_height, const unsigned char * src, int src_width, int src_height , image_util_colorspace_e colorspace){ int ret; if( dest == NULL || src == NULL ) return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); if( colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl)/sizeof(int)) return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); - if( dest_rotation < 0 || dest_rotation > IMAGE_UTIL_ROTATION_FLIP_VERT ) - return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); if( dest_width == NULL || dest_height == NULL) return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); - if( *dest_width <= 0 || *dest_height <= 0 ) + if( *dest_width <= 0 || dest_height <= 0 ) return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); unsigned int dest_w, dest_h; dest_w = *dest_width; dest_h = *dest_height; + ret = mm_util_resize_image(src, src_width, src_height, _convert_colorspace_tbl[colorspace], dest,&dest_w, &dest_h); + if( ret == 0){ + *dest_width = dest_w; + *dest_height = dest_h; + } + + return _convert_image_util_error_code(__func__, ret); +} + +int image_util_rotate(unsigned char * dest, int *dest_width, int *dest_height, image_util_rotation_e dest_rotation, const unsigned char * src, int src_width, int src_height, image_util_colorspace_e colorspace){ + int ret; + if( dest == NULL || src == NULL ) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + if( colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl)/sizeof(int)) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + if( dest_rotation < 0 || dest_rotation > IMAGE_UTIL_ROTATION_FLIP_VERT ) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + if( dest_width == NULL || dest_height == NULL) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + + unsigned int dest_w, dest_h; ret = mm_util_rotate_image(src, src_width, src_height, _convert_colorspace_tbl[colorspace], dest,&dest_w, &dest_h, dest_rotation); if( ret == 0){ *dest_width = dest_w; - *dest_height = dest_h; + *dest_height = dest_h; } - - - return _convert_image_util_error_code(__func__, ret); + return _convert_image_util_error_code(__func__, ret); +} + +int image_util_crop(unsigned char * dest, int x , int y, int* width, int* height, const unsigned char *src, int src_width, int src_height, image_util_colorspace_e colorspace){ + int ret; + if( dest == NULL || src == NULL ) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + if( colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl)/sizeof(int)) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + if( width == NULL ) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + if( src_width <= x || src_height <= y || src_width < x+*width || src_height< y+*height) + return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); + + unsigned int dest_w, dest_h; + dest_w = *width; + dest_h = *height; + ret = mm_util_crop_image( src, src_width, src_height, _convert_colorspace_tbl[colorspace], x, y, &dest_w, &dest_h, dest); + if( ret == 0){ + *width = dest_w; + *height = dest_h; + } + + return _convert_image_util_error_code(__func__, ret); } int image_util_decode_jpeg( const char *path , image_util_colorspace_e colorspace, unsigned char ** image_buffer , int *width , int *height , unsigned int *size){ @@ -189,7 +229,7 @@ int image_util_decode_jpeg( const char *path , image_util_colorspace_e colorspac return _convert_image_util_error_code(__func__, ret); } -int image_util_decode_jpeg_from_memory( unsigned char * jpeg_buffer , int jpeg_size , image_util_colorspace_e colorspace, unsigned char ** image_buffer , int *width , int *height , unsigned int *size){ +int image_util_decode_jpeg_from_memory( const unsigned char * jpeg_buffer , int jpeg_size , image_util_colorspace_e colorspace, unsigned char ** image_buffer , int *width , int *height , unsigned int *size){ int ret; if( jpeg_buffer == NULL || image_buffer == NULL || size == NULL) return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); @@ -215,7 +255,7 @@ int image_util_decode_jpeg_from_memory( unsigned char * jpeg_buffer , int jpeg_s return _convert_image_util_error_code(__func__, ret); } -int image_util_encode_jpeg( unsigned char *buffer, int width, int height, image_util_colorspace_e colorspace, int quality, const char *path){ +int image_util_encode_jpeg( const unsigned char *buffer, int width, int height, image_util_colorspace_e colorspace, int quality, const char *path){ int ret; if( path == NULL || buffer == NULL ) return _convert_image_util_error_code(__func__, IMAGE_UTIL_ERROR_INVALID_PARAMETER); @@ -224,11 +264,11 @@ int image_util_encode_jpeg( unsigned char *buffer, int width, int height, image_ if( _convert_encode_colorspace_tbl[colorspace] == -1 ) return _convert_image_util_error_code(__func__, MM_ERROR_IMAGE_NOT_SUPPORT_FORMAT); - ret = mm_util_jpeg_encode_to_file((char*)path, buffer, width, height, _convert_encode_colorspace_tbl[colorspace], quality); + ret = mm_util_jpeg_encode_to_file(path, buffer, width, height, _convert_encode_colorspace_tbl[colorspace], quality); return _convert_image_util_error_code(__func__, ret); } -int image_util_encode_jpeg_to_memory(unsigned char *image_buffer, int width, int height, image_util_colorspace_e colorspace, int quality, unsigned char** jpeg_buffer, unsigned int *jpeg_size){ +int image_util_encode_jpeg_to_memory( const unsigned char *image_buffer, int width, int height, image_util_colorspace_e colorspace, int quality, unsigned char** jpeg_buffer, unsigned int *jpeg_size){ int ret; int isize; if( jpeg_buffer == NULL || image_buffer == NULL || jpeg_size == NULL ) diff --git a/test/multimeida_image_util_test.c b/test/multimeida_image_util_test.c index 74a0324..0830084 100755 --- a/test/multimeida_image_util_test.c +++ b/test/multimeida_image_util_test.c @@ -22,6 +22,43 @@ #include #include +/* + * Function displaying image on canva + */ +static void _display_buffer_as_efl_image(Evas_Object *img, unsigned char *buf, int w, int h, image_util_colorspace_e colorspace) +{ + unsigned int sizeBGRA8888; + int err; + + /* + * Calculates the size of image buffer for the specified resolution and colorspace + */ + err = image_util_calculate_buffer_size(w, h, IMAGE_UTIL_COLORSPACE_BGRA8888, &sizeBGRA8888); + if ( IMAGE_UTIL_ERROR_NONE != err) + return; + static unsigned char *new_buff; + free(new_buff); + new_buff = malloc(sizeBGRA8888); + + /* + * Convert the image's colorspace + */ + err = image_util_convert_colorspace(new_buff, IMAGE_UTIL_COLORSPACE_BGRA8888, buf, w, h, colorspace); + if ( IMAGE_UTIL_ERROR_NONE != err) { + free(new_buff); + return; + } + + evas_object_hide(img); + evas_object_image_size_set(img, w, h); + evas_object_image_colorspace_set(img, EVAS_COLORSPACE_ARGB8888); + evas_object_image_data_copy_set(img, (void*)new_buff); + evas_object_image_reload(img); + + evas_object_image_data_update_add(img,0,0, w, h); + evas_object_show(img); +} + struct raw_image{ unsigned char *buffer; int size; @@ -32,7 +69,7 @@ struct raw_image{ Evas_Object* img; char *colorspace_str_tbl[] = { - "IMAGE_UTIL_COLORSPACE_YUV420", /**< YUV420 */ + "IMAGE_UTIL_COLORSPACE_YV12", /**< YV12 */ "IMAGE_UTIL_COLORSPACE_YUV422", /**< YUV422 */ "IMAGE_UTIL_COLORSPACE_I420", /**< I420 */ "IMAGE_UTIL_COLORSPACE_NV12", /**< NV12 */ @@ -67,26 +104,9 @@ bool decode_jpeg_cb( image_util_colorspace_e colorspace , void * user_data){ printf("image (%dx%d) - %dbyte , ret = %d(%x)\n", w,h, size, ret, ret); if( ret != 0 ) return true; - - - evas_object_image_size_set(img, w, h); - unsigned char *bgra8888_image = evas_object_image_data_get(img, true); - ret = image_util_convert_colorspace(bgra8888_image , IMAGE_UTIL_COLORSPACE_BGRA8888, buffer , w, h, colorspace ); - printf("convert %d\n", ret); - free(buffer); - - evas_object_image_data_set(img, bgra8888_image); - - evas_object_hide(img); - evas_object_resize(img, w,h); - evas_object_image_fill_set(img, 0, 0, w, h); - evas_object_image_data_update_add(img,0,0, w, h); - evas_object_show(img); - - - sleep(1); - + _display_buffer_as_efl_image( img, buffer, w, h, colorspace); + sleep(2); return true; } @@ -110,7 +130,6 @@ bool encode_jpeg_cb( image_util_colorspace_e colorspace , void * user_data){ char filename[255]; printf("jpeg encode from [%s]\n", colorspace_str_tbl[colorspace] ); - image_util_calculate_buffer_size(img_data->w,img_data->h, colorspace, &size); buffer = malloc(size); @@ -163,7 +182,7 @@ void colorspace_convert_test( const char *path ){ int j; int ret; - for( i = IMAGE_UTIL_COLORSPACE_YUV420 ; i <= IMAGE_UTIL_COLORSPACE_BGRX8888 ; i++ ){ + for( i = IMAGE_UTIL_COLORSPACE_YV12 ; i <= IMAGE_UTIL_COLORSPACE_BGRX8888 ; i++ ){ unsigned char *buffer; unsigned int size; @@ -175,7 +194,7 @@ void colorspace_convert_test( const char *path ){ ret = image_util_convert_colorspace(buffer, i , origin_buffer, w, h, IMAGE_UTIL_COLORSPACE_BGRA8888); printf("[%d] convert %s -> %s\n", ret , colorspace_str_tbl[IMAGE_UTIL_COLORSPACE_BGRA8888], colorspace_str_tbl[i]); - for( j = IMAGE_UTIL_COLORSPACE_YUV420 ; j <= IMAGE_UTIL_COLORSPACE_BGRX8888 ; j++){ + for( j = IMAGE_UTIL_COLORSPACE_YV12 ; j <= IMAGE_UTIL_COLORSPACE_BGRX8888 ; j++){ if( i == j ) continue; unsigned char *buffer2; @@ -203,47 +222,49 @@ void colorspace_convert_test( const char *path ){ } - -void transform_test( const char *path ){ +void rotate_test( const char *path ){ printf("****************\n"); - printf("transform_test TEST - start\n"); + printf("rotate_test TEST - start\n"); printf("****************\n"); - - - int w,h; - evas_object_image_file_set(img, path, NULL); - unsigned char* origin_buffer = evas_object_image_data_get(img, false); - evas_object_image_size_get(img, &w, &h); - evas_object_resize(img, w,h); - + int w,h,dw,dh; int ret; - - - unsigned char *buffer; + unsigned char *origin_buffer; unsigned int size; - int dw, dh; - - dh = 800; - dw = 200; - - image_util_calculate_buffer_size(dw, dh, IMAGE_UTIL_COLORSPACE_BGRA8888 , &size); - buffer = malloc(size); - - printf("%d, %d\n", dw, dh); - ret = image_util_transform(buffer , &dw, &dh , IMAGE_UTIL_ROTATION_NONE , origin_buffer, w, h, IMAGE_UTIL_COLORSPACE_BGRA8888); - printf("[%d] image_util_transform\n", ret); - - printf("%d, %d\n", dw, dh); - - evas_object_hide(img); - evas_object_resize(img, dw,dh); - evas_object_image_size_set(img, dw, dh); - evas_object_image_data_set(img, buffer); + int i; - evas_object_image_fill_set(img, 0, 0, dw, dh); - evas_object_image_data_update_add(img,0,0, dw, dh); - evas_object_show(img); + w = h = 0; + ret = image_util_decode_jpeg( path ,IMAGE_UTIL_COLORSPACE_RGB888, &origin_buffer, &w, &h , &size ); + printf("image (%dx%d) - %dbyte , ret = %d(%x)\n", w,h, size, ret, ret); + + _display_buffer_as_efl_image(img, origin_buffer, w,h, IMAGE_UTIL_COLORSPACE_RGB888); + sleep(2); + + unsigned char *dest_buffer = NULL; + unsigned int nsize; + dw = h; + dh = w; + image_util_calculate_buffer_size( dw,dh, IMAGE_UTIL_COLORSPACE_RGB888 , &nsize); + dest_buffer = malloc(nsize); + + for( i = 0 ; i < 10 ; i ++ ){ + ret = image_util_rotate(dest_buffer, &dw,&dh, IMAGE_UTIL_ROTATION_90, origin_buffer, w,h, IMAGE_UTIL_COLORSPACE_RGB888); + printf("image_util_rotate ret = %d\n", ret); + printf("%x%x%x\n", dest_buffer[0], dest_buffer[20], dest_buffer[44]); + _display_buffer_as_efl_image(img, dest_buffer, dw,dh, IMAGE_UTIL_COLORSPACE_RGB888); + sleep(2); + int tw, th; + unsigned char *tmp_buffer; + tmp_buffer = dest_buffer; + dest_buffer = origin_buffer; + origin_buffer = tmp_buffer; + tw = dw; + th = dh; + dw = w; + dh = h; + w = tw; + h = th; + } printf("****************\n"); printf("transform_test TEST - end\n"); @@ -252,10 +273,10 @@ void transform_test( const char *path ){ } void* test_main(void *arg){ - //jpeg_decode_test("sample.jpg"); + jpeg_decode_test("sample.jpg"); //jpeg_encode_test("sample.jpg"); //colorspace_convert_test("sample.jpg"); - transform_test("sample.jpg"); + rotate_test("sample.jpg"); return NULL; -- 2.34.1