1 /* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 // System dependencies
31 #include <pthread.h>
32 #include <stdlib.h>
33 #define TIME_H <SYSTEM_HEADER_PREFIX/time.h>
34 #include TIME_H
35
36 // JPEG dependencies
37 #include "mm_jpeg_interface.h"
38 #include "mm_jpeg_ionbuf.h"
39
40 // Camera dependencies
41 #include "mm_camera_dbg.h"
42
43 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
44 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
45 #define CLAMP(x, min, max) MIN(MAX((x), (min)), (max))
46
47 #define TIME_IN_US(r) ((uint64_t)r.tv_sec * 1000000LL + (uint64_t)r.tv_usec)
48 struct timeval dtime[2];
49
50
51 /** DUMP_TO_FILE:
52 * @filename: file name
53 * @p_addr: address of the buffer
54 * @len: buffer length
55 *
56 * dump the image to the file
57 **/
58 #define DUMP_TO_FILE(filename, p_addr, len) ({ \
59 size_t rc = 0; \
60 FILE *fp = fopen(filename, "w+"); \
61 if (fp) { \
62 rc = fwrite(p_addr, 1, len, fp); \
63 fclose(fp); \
64 } else { \
65 LOGE("cannot dump image"); \
66 } \
67 })
68
69 static int g_count = 1, g_i;
70
71 typedef struct {
72 char *filename;
73 int width;
74 int height;
75 char *out_filename;
76 int format;
77 } jpeg_test_input_t;
78
79 typedef struct {
80 char *filename;
81 int width;
82 int height;
83 char *out_filename;
84 pthread_mutex_t lock;
85 pthread_cond_t cond;
86 buffer_t input;
87 buffer_t output;
88 int use_ion;
89 uint32_t handle;
90 mm_jpegdec_ops_t ops;
91 uint32_t job_id[5];
92 mm_jpeg_decode_params_t params;
93 mm_jpeg_job_t job;
94 uint32_t session_id;
95 } mm_jpegdec_intf_test_t;
96
97 typedef struct {
98 char *format_str;
99 int eColorFormat;
100 } mm_jpegdec_col_fmt_t;
101
102 #define ARR_SZ(a) (sizeof(a)/sizeof(a[0]))
103
104 static const mm_jpegdec_col_fmt_t col_formats[] =
105 {
106 { "YCRCBLP_H2V2", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2 },
107 { "YCBCRLP_H2V2", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2 },
108 { "YCRCBLP_H2V1", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1 },
109 { "YCBCRLP_H2V1", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1 },
110 { "YCRCBLP_H1V2", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2 },
111 { "YCBCRLP_H1V2", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2 },
112 { "YCRCBLP_H1V1", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1 },
113 { "YCBCRLP_H1V1", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1 }
114 };
115
mm_jpegdec_decode_callback(jpeg_job_status_t status,uint32_t client_hdl,uint32_t jobId,mm_jpeg_output_t * p_output,void * userData)116 static void mm_jpegdec_decode_callback(jpeg_job_status_t status,
117 uint32_t client_hdl,
118 uint32_t jobId,
119 mm_jpeg_output_t *p_output,
120 void *userData)
121 {
122 mm_jpegdec_intf_test_t *p_obj = (mm_jpegdec_intf_test_t *)userData;
123
124 if (status == JPEG_JOB_STATUS_ERROR) {
125 LOGE("Decode error");
126 } else {
127 gettimeofday(&dtime[1], NULL);
128 LOGE("Decode time %llu ms",
129 ((TIME_IN_US(dtime[1]) - TIME_IN_US(dtime[0]))/1000));
130
131 LOGE("Decode success file%s addr %p len %zu",
132 p_obj->out_filename,
133 p_output->buf_vaddr, p_output->buf_filled_len);
134 DUMP_TO_FILE(p_obj->out_filename, p_output->buf_vaddr, p_output->buf_filled_len);
135 }
136 g_i++;
137 if (g_i >= g_count) {
138 LOGE("Signal the thread");
139 pthread_cond_signal(&p_obj->cond);
140 }
141 }
142
mm_jpegdec_test_alloc(buffer_t * p_buffer,int use_pmem)143 int mm_jpegdec_test_alloc(buffer_t *p_buffer, int use_pmem)
144 {
145 int ret = 0;
146 /*Allocate buffers*/
147 if (use_pmem) {
148 p_buffer->addr = (uint8_t *)buffer_allocate(p_buffer, 0);
149 if (NULL == p_buffer->addr) {
150 LOGE("Error");
151 return -1;
152 }
153 } else {
154 /* Allocate heap memory */
155 p_buffer->addr = (uint8_t *)malloc(p_buffer->size);
156 if (NULL == p_buffer->addr) {
157 LOGE("Error");
158 return -1;
159 }
160 }
161 return ret;
162 }
163
mm_jpegdec_test_free(buffer_t * p_buffer)164 void mm_jpegdec_test_free(buffer_t *p_buffer)
165 {
166 if (p_buffer->addr == NULL)
167 return;
168
169 if (p_buffer->p_pmem_fd >= 0)
170 buffer_deallocate(p_buffer);
171 else
172 free(p_buffer->addr);
173
174 memset(p_buffer, 0x0, sizeof(buffer_t));
175 }
176
mm_jpegdec_test_read(mm_jpegdec_intf_test_t * p_obj)177 int mm_jpegdec_test_read(mm_jpegdec_intf_test_t *p_obj)
178 {
179 int rc = 0;
180 FILE *fp = NULL;
181 size_t file_size = 0;
182 fp = fopen(p_obj->filename, "rb");
183 if (!fp) {
184 LOGE("error");
185 return -1;
186 }
187 fseek(fp, 0, SEEK_END);
188 file_size = (size_t)ftell(fp);
189 fseek(fp, 0, SEEK_SET);
190
191 LOGE("input file size is %zu",
192 file_size);
193
194 p_obj->input.size = file_size;
195
196 /* allocate buffers */
197 rc = mm_jpegdec_test_alloc(&p_obj->input, p_obj->use_ion);
198 if (rc) {
199 LOGE("Error");
200 return -1;
201 }
202
203 fread(p_obj->input.addr, 1, p_obj->input.size, fp);
204 fclose(fp);
205 return 0;
206 }
207
chromaScale(mm_jpeg_color_format format,double * cScale)208 void chromaScale(mm_jpeg_color_format format, double *cScale)
209 {
210 double scale;
211
212 switch(format) {
213 case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2:
214 case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2:
215 scale = 1.5;
216 break;
217 case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1:
218 case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1:
219 case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2:
220 case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2:
221 scale = 2.0;
222 break;
223 case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1:
224 case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1:
225 scale = 3.0;
226 break;
227 case MM_JPEG_COLOR_FORMAT_MONOCHROME:
228 scale = 1.0;
229 break;
230 default:
231 scale = 0;
232 LOGE("color format Error");
233 }
234
235 *cScale = scale;
236 }
237
decode_init(jpeg_test_input_t * p_input,mm_jpegdec_intf_test_t * p_obj)238 static int decode_init(jpeg_test_input_t *p_input, mm_jpegdec_intf_test_t *p_obj)
239 {
240 int rc = -1;
241 size_t size = (size_t)(CEILING16(p_input->width) * CEILING16(p_input->height));
242 double cScale;
243 mm_jpeg_decode_params_t *p_params = &p_obj->params;
244 mm_jpeg_decode_job_t *p_job_params = &p_obj->job.decode_job;
245
246 p_obj->filename = p_input->filename;
247 p_obj->width = p_input->width;
248 p_obj->height = p_input->height;
249 p_obj->out_filename = p_input->out_filename;
250 p_obj->use_ion = 1;
251
252 pthread_mutex_init(&p_obj->lock, NULL);
253 pthread_cond_init(&p_obj->cond, NULL);
254
255 chromaScale(p_input->format, &cScale);
256 p_obj->output.size = (size_t)((double)size * cScale);
257 rc = mm_jpegdec_test_alloc(&p_obj->output, p_obj->use_ion);
258 if (rc) {
259 LOGE("Error");
260 return -1;
261 }
262
263 rc = mm_jpegdec_test_read(p_obj);
264 if (rc) {
265 LOGE("Error");
266 return -1;
267 }
268
269 /* set encode parameters */
270 p_params->jpeg_cb = mm_jpegdec_decode_callback;
271 p_params->userdata = p_obj;
272 p_params->color_format = p_input->format;
273
274 /* dest buffer config */
275 p_params->dest_buf[0].buf_size = p_obj->output.size;
276 p_params->dest_buf[0].buf_vaddr = p_obj->output.addr;
277 p_params->dest_buf[0].fd = p_obj->output.p_pmem_fd;
278 p_params->dest_buf[0].format = MM_JPEG_FMT_YUV;
279 p_params->dest_buf[0].offset.mp[0].len = (uint32_t)size;
280 p_params->dest_buf[0].offset.mp[1].len =
281 (uint32_t)((double)size * (cScale - 1.0));
282 p_params->dest_buf[0].offset.mp[0].stride = CEILING16(p_input->width);
283 p_params->dest_buf[0].offset.mp[0].scanline = CEILING16(p_input->height);
284 p_params->dest_buf[0].offset.mp[1].stride = CEILING16(p_input->width);
285 p_params->dest_buf[0].offset.mp[1].scanline = CEILING16(p_input->height);
286 p_params->dest_buf[0].index = 0;
287 p_params->num_dst_bufs = 1;
288
289 /* src buffer config*/
290 p_params->src_main_buf[0].buf_size = p_obj->input.size;
291 p_params->src_main_buf[0].buf_vaddr = p_obj->input.addr;
292 p_params->src_main_buf[0].fd = p_obj->input.p_pmem_fd;
293 p_params->src_main_buf[0].index = 0;
294 p_params->src_main_buf[0].format = MM_JPEG_FMT_BITSTREAM;
295 /*
296 p_params->src_main_buf[0].offset.mp[0].len = size;
297 p_params->src_main_buf[0].offset.mp[1].len = size >> 1;
298 */
299 p_params->num_src_bufs = 1;
300
301 p_job_params->dst_index = 0;
302 p_job_params->src_index = 0;
303 p_job_params->rotation = 0;
304
305 /* main dimension */
306 p_job_params->main_dim.src_dim.width = p_obj->width;
307 p_job_params->main_dim.src_dim.height = p_obj->height;
308 p_job_params->main_dim.dst_dim.width = p_obj->width;
309 p_job_params->main_dim.dst_dim.height = p_obj->height;
310 p_job_params->main_dim.crop.top = 0;
311 p_job_params->main_dim.crop.left = 0;
312 p_job_params->main_dim.crop.width = p_obj->width;
313 p_job_params->main_dim.crop.height = p_obj->height;
314
315
316 return 0;
317 }
318
omx_test_dec_print_usage()319 void omx_test_dec_print_usage()
320 {
321 fprintf(stderr, "Usage: program_name [options]\n");
322 fprintf(stderr, "Mandatory options:\n");
323 fprintf(stderr, " -I FILE\t\tPath to the input file.\n");
324 fprintf(stderr, " -O FILE\t\tPath for the output file.\n");
325 fprintf(stderr, " -W WIDTH\t\tOutput image width\n");
326 fprintf(stderr, " -H HEIGHT\t\tOutput image height\n");
327 fprintf(stderr, "Optional:\n");
328 fprintf(stderr, " -F FORMAT\t\tDefault image format:\n");
329 fprintf(stderr, "\t\t\t\t%s (0), %s (1), %s (2) %s (3)\n"
330 "%s (4), %s (5), %s (6) %s (7)\n",
331 col_formats[0].format_str, col_formats[1].format_str,
332 col_formats[2].format_str, col_formats[3].format_str,
333 col_formats[4].format_str, col_formats[5].format_str,
334 col_formats[6].format_str, col_formats[7].format_str
335 );
336
337 fprintf(stderr, "\n");
338 }
339
mm_jpegdec_test_get_input(int argc,char * argv[],jpeg_test_input_t * p_test)340 static int mm_jpegdec_test_get_input(int argc, char *argv[],
341 jpeg_test_input_t *p_test)
342 {
343 int c;
344
345 while ((c = getopt(argc, argv, "I:O:W:H:F:")) != -1) {
346 switch (c) {
347 case 'O':
348 p_test->out_filename = optarg;
349 fprintf(stderr, "%-25s%s\n", "Output image path",
350 p_test->out_filename);
351 break;
352 case 'I':
353 p_test->filename = optarg;
354 fprintf(stderr, "%-25s%s\n", "Input image path", p_test->filename);
355 break;
356 case 'W':
357 p_test->width = atoi(optarg);
358 fprintf(stderr, "%-25s%d\n", "Default width", p_test->width);
359 break;
360 case 'H':
361 p_test->height = atoi(optarg);
362 fprintf(stderr, "%-25s%d\n", "Default height", p_test->height);
363 break;
364 case 'F': {
365 int format = 0;
366 format = atoi(optarg);
367 int num_formats = ARR_SZ(col_formats);
368 format = CLAMP(format, 0, num_formats);
369 p_test->format = col_formats[format].eColorFormat;
370 fprintf(stderr, "%-25s%s\n", "Default image format",
371 col_formats[format].format_str);
372 break;
373 }
374 default:;
375 }
376 }
377 if (!p_test->filename || !p_test->filename || !p_test->width ||
378 !p_test->height) {
379 fprintf(stderr, "Missing required arguments.\n");
380 omx_test_dec_print_usage();
381 return -1;
382 }
383 return 0;
384 }
385
decode_test(jpeg_test_input_t * p_input)386 static int decode_test(jpeg_test_input_t *p_input)
387 {
388 int rc = 0;
389 mm_jpegdec_intf_test_t jpeg_obj;
390 int i = 0;
391
392 memset(&jpeg_obj, 0x0, sizeof(jpeg_obj));
393 rc = decode_init(p_input, &jpeg_obj);
394 if (rc) {
395 LOGE("Error");
396 return -1;
397 }
398
399 jpeg_obj.handle = jpegdec_open(&jpeg_obj.ops);
400 if (jpeg_obj.handle == 0) {
401 LOGE("Error");
402 goto end;
403 }
404
405 rc = jpeg_obj.ops.create_session(jpeg_obj.handle, &jpeg_obj.params,
406 &jpeg_obj.job.decode_job.session_id);
407 if (jpeg_obj.job.decode_job.session_id == 0) {
408 LOGE("Error");
409 goto end;
410 }
411
412 for (i = 0; i < g_count; i++) {
413 jpeg_obj.job.job_type = JPEG_JOB_TYPE_DECODE;
414
415 LOGE("Starting decode job");
416 gettimeofday(&dtime[0], NULL);
417
418 fprintf(stderr, "Starting decode of %s into %s outw %d outh %d\n\n",
419 p_input->filename, p_input->out_filename,
420 p_input->width, p_input->height);
421 rc = jpeg_obj.ops.start_job(&jpeg_obj.job, &jpeg_obj.job_id[i]);
422 if (rc) {
423 LOGE("Error");
424 goto end;
425 }
426 }
427
428 /*
429 usleep(5);
430 jpeg_obj.ops.abort_job(jpeg_obj.job_id[0]);
431 */
432 pthread_mutex_lock(&jpeg_obj.lock);
433 pthread_cond_wait(&jpeg_obj.cond, &jpeg_obj.lock);
434 pthread_mutex_unlock(&jpeg_obj.lock);
435
436 fprintf(stderr, "Decode time %llu ms\n",
437 ((TIME_IN_US(dtime[1]) - TIME_IN_US(dtime[0]))/1000));
438
439
440 jpeg_obj.ops.destroy_session(jpeg_obj.job.decode_job.session_id);
441
442 jpeg_obj.ops.close(jpeg_obj.handle);
443
444
445 end:
446 mm_jpegdec_test_free(&jpeg_obj.input);
447 mm_jpegdec_test_free(&jpeg_obj.output);
448 return 0;
449 }
450
451 /** main:
452 *
453 * Arguments:
454 * @argc
455 * @argv
456 *
457 * Return:
458 * 0 or -ve values
459 *
460 * Description:
461 * main function
462 *
463 **/
main(int argc,char * argv[])464 int main(int argc, char* argv[])
465 {
466 jpeg_test_input_t dec_test_input;
467 int ret;
468
469 memset(&dec_test_input, 0, sizeof(dec_test_input));
470 ret = mm_jpegdec_test_get_input(argc, argv, &dec_test_input);
471
472 if (ret) {
473 return -1;
474 }
475
476 return decode_test(&dec_test_input);
477 }
478
479
480