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)
48struct 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
69static int g_count = 1, g_i;
70
71typedef struct {
72  char *filename;
73  int width;
74  int height;
75  char *out_filename;
76  int format;
77} jpeg_test_input_t;
78
79typedef 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
97typedef 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
104static 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
116static 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
143int 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
164void 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
177int 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
208void 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
238static 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
319void 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
340static 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
386static 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
445end:
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 **/
464int 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