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