debian/changelog: package upstream version v0.1.4
[libam7xxx.git] / examples / picoproj.c
1 /* picoproj - test program for libam7xxx
2  *
3  * Copyright (C) 2012  Antonio Ospite <ospite@studenti.unina.it>
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 /**
20  * @example examples/picoproj.c
21  * A minimal example to show how to use libam7xxx to display a static image.
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <errno.h>
32
33 #include "am7xxx.h"
34
35 static void usage(char *name)
36 {
37         printf("usage: %s [OPTIONS]\n\n", name);
38         printf("OPTIONS:\n");
39         printf("\t-d <index>\t\tthe device index (default is 0)\n");
40         printf("\t-f <filename>\t\tthe image file to upload\n");
41         printf("\t-F <format>\t\tthe image format to use (default is JPEG)\n");
42         printf("\t\t\t\tSUPPORTED FORMATS:\n");
43         printf("\t\t\t\t\t1 - JPEG\n");
44         printf("\t\t\t\t\t2 - NV12\n");
45         printf("\t-l <log level>\t\tthe verbosity level of libam7xxx output (0-5)\n");
46         printf("\t-p <power mode>\t\tthe power mode of device, between %d (off) and %d (turbo)\n",
47                AM7XXX_POWER_OFF, AM7XXX_POWER_TURBO);
48         printf("\t\t\t\tWARNING: Level 2 and greater require the master AND\n");
49         printf("\t\t\t\t         the slave connector to be plugged in.\n");
50         printf("\t-z <zoom mode>\t\tthe display zoom mode, between %d (original) and %d (test)\n",
51                AM7XXX_ZOOM_ORIGINAL, AM7XXX_ZOOM_TEST);
52         printf("\t-W <image width>\tthe width of the image to upload\n");
53         printf("\t-H <image height>\tthe height of the image to upload\n");
54         printf("\t-h \t\t\tthis help message\n");
55         printf("\n\nEXAMPLE OF USE:\n");
56         printf("\t%s -f file.jpg -F 1 -l 5 -W 800 -H 480\n", name);
57 }
58
59 int main(int argc, char *argv[])
60 {
61         int ret;
62         int opt;
63
64         char filename[FILENAME_MAX] = {0};
65         FILE *image_fp;
66         struct stat st;
67         am7xxx_context *ctx;
68         am7xxx_device *dev;
69         int log_level = AM7XXX_LOG_INFO;
70         int device_index = 0;
71         int power_mode = AM7XXX_POWER_LOW;
72         int zoom = AM7XXX_ZOOM_ORIGINAL;
73         int format = AM7XXX_IMAGE_FORMAT_JPEG;
74         int width = 800;
75         int height = 480;
76         unsigned char *image;
77         off_t size;
78         am7xxx_device_info device_info;
79
80         while ((opt = getopt(argc, argv, "d:f:F:l:p:z:W:H:h")) != -1) {
81                 switch (opt) {
82                 case 'd':
83                         device_index = atoi(optarg);
84                         if (device_index < 0) {
85                                 fprintf(stderr, "Unsupported device index\n");
86                                 ret = -EINVAL;
87                                 goto out;
88                         }
89                         break;
90                 case 'f':
91                         if (filename[0] != '\0')
92                                 fprintf(stderr, "Warning: image file already specified\n");
93                         strncpy(filename, optarg, FILENAME_MAX);
94                         break;
95                 case 'F':
96                         format = atoi(optarg);
97                         switch(format) {
98                         case AM7XXX_IMAGE_FORMAT_JPEG:
99                                 fprintf(stdout, "JPEG format\n");
100                                 break;
101                         case AM7XXX_IMAGE_FORMAT_NV12:
102                                 fprintf(stdout, "NV12 format\n");
103                                 break;
104                         default:
105                                 fprintf(stderr, "Unsupported format\n");
106                                 ret = -EINVAL;
107                                 goto out;
108                         }
109                         break;
110                 case 'l':
111                         log_level = atoi(optarg);
112                         if (log_level < AM7XXX_LOG_FATAL || log_level > AM7XXX_LOG_TRACE) {
113                                 fprintf(stderr, "Unsupported log level, falling back to AM7XXX_LOG_ERROR\n");
114                                 log_level = AM7XXX_LOG_ERROR;
115                         }
116                         break;
117                 case 'p':
118                         power_mode = atoi(optarg);
119                         switch(power_mode) {
120                         case AM7XXX_POWER_OFF:
121                         case AM7XXX_POWER_LOW:
122                         case AM7XXX_POWER_MIDDLE:
123                         case AM7XXX_POWER_HIGH:
124                         case AM7XXX_POWER_TURBO:
125                                 fprintf(stdout, "Power mode: %d\n", power_mode);
126                                 break;
127                         default:
128                                 fprintf(stderr, "Invalid power mode value, must be between %d and %d\n",
129                                         AM7XXX_POWER_OFF, AM7XXX_POWER_TURBO);
130                                 ret = -EINVAL;
131                                 goto out;
132                         }
133                         break;
134                 case 'z':
135                         zoom = atoi(optarg);
136                         switch(zoom) {
137                         case AM7XXX_ZOOM_ORIGINAL:
138                         case AM7XXX_ZOOM_H:
139                         case AM7XXX_ZOOM_H_V:
140                         case AM7XXX_ZOOM_TEST:
141                                 fprintf(stdout, "Zoom: %d\n", zoom);
142                                 break;
143                         default:
144                                 fprintf(stderr, "Invalid zoom mode value, must be between %d and %d\n",
145                                         AM7XXX_ZOOM_ORIGINAL, AM7XXX_ZOOM_TEST);
146                                 ret = -EINVAL;
147                                 goto out;
148                         }
149                         break;
150                 case 'W':
151                         width = atoi(optarg);
152                         if (width < 0) {
153                                 fprintf(stderr, "Unsupported width\n");
154                                 ret = -EINVAL;
155                                 goto out;
156                         }
157                         break;
158                 case 'H':
159                         height = atoi(optarg);
160                         if (height < 0) {
161                                 fprintf(stderr, "Unsupported height\n");
162                                 ret = -EINVAL;
163                                 goto out;
164                         }
165                         break;
166                 case 'h':
167                         usage(argv[0]);
168                         ret = 0;
169                         goto out;
170                 default: /* '?' */
171                         usage(argv[0]);
172                         ret = -EINVAL;
173                         goto out;
174                 }
175         }
176
177         if (filename[0] == '\0') {
178                 fprintf(stderr, "An image file MUST be specified with the -f option.\n\n");
179                 usage(argv[0]);
180                 ret = -EINVAL;
181                 goto out;
182         }
183
184         image_fp = fopen(filename, "rb");
185         if (image_fp == NULL) {
186                 perror("fopen");
187                 ret = -EINVAL;
188                 goto out;
189         }
190         ret = fstat(fileno(image_fp), &st);
191         if (ret < 0) {
192                 perror("fstat");
193                 goto out_close_image_fp;
194         }
195         size = st.st_size;
196
197         image = malloc(size * sizeof(unsigned char));
198         if (image == NULL) {
199                 perror("malloc");
200                 ret = -ENOMEM;
201                 goto out_close_image_fp;
202         }
203
204         ret = (int)fread(image, size, 1, image_fp);
205         if (ret != 1) {
206                 if (feof(image_fp))
207                         fprintf(stderr, "Unexpected end of file.\n");
208                 else if (ferror(image_fp))
209                         perror("fread");
210                 else
211                         fprintf(stderr, "Unexpected error condition.\n");
212
213                 if (ret >= 0)
214                         ret = -EINVAL;
215                 goto out_free_image;
216         }
217
218         ret = am7xxx_init(&ctx);
219         if (ret < 0) {
220                 perror("am7xxx_init");
221                 goto out_free_image;
222         }
223
224         am7xxx_set_log_level(ctx, log_level);
225
226         ret = am7xxx_open_device(ctx, &dev, 0);
227         if (ret < 0) {
228                 perror("am7xxx_open_device");
229                 goto cleanup;
230         }
231
232         ret = am7xxx_close_device(dev);
233         if (ret < 0) {
234                 perror("am7xxx_close_device");
235                 goto cleanup;
236         }
237
238         ret = am7xxx_open_device(ctx, &dev, device_index);
239         if (ret < 0) {
240                 perror("am7xxx_open_device");
241                 goto cleanup;
242         }
243
244         ret = am7xxx_get_device_info(dev, &device_info);
245         if (ret < 0) {
246                 perror("am7xxx_get_device_info");
247                 goto cleanup;
248         }
249         printf("Native resolution: %dx%d\n",
250                device_info.native_width, device_info.native_height);
251
252         ret = am7xxx_set_zoom_mode(dev, zoom);
253         if (ret < 0) {
254                 perror("am7xxx_set_zoom_mode");
255                 goto cleanup;
256         }
257
258         ret = am7xxx_set_power_mode(dev, power_mode);
259         if (ret < 0) {
260                 perror("am7xxx_set_power_mode");
261                 goto cleanup;
262         }
263
264         /* When setting AM7XXX_ZOOM_TEST don't display the actual image */
265         if (zoom == AM7XXX_ZOOM_TEST) {
266                 printf("AM7XXX_ZOOM_TEST requested, not sending actual image.\n");
267                 goto cleanup;
268         }
269
270         if ((unsigned int)width > device_info.native_width ||
271             (unsigned int)height > device_info.native_height)
272                 fprintf(stderr,
273                         "WARNING: image is %dx%d, not fitting the native resolution, it may be displayed wrongly!\n",
274                         width, height);
275
276         ret = am7xxx_send_image(dev, format, width, height, image, (unsigned int)size);
277         if (ret < 0) {
278                 perror("am7xxx_send_image");
279                 goto cleanup;
280         }
281
282         ret = 0;
283
284 cleanup:
285         am7xxx_shutdown(ctx);
286
287 out_free_image:
288         free(image);
289
290 out_close_image_fp:
291         if (fclose(image_fp) == EOF)
292                 perror("fclose");
293
294 out:
295         return ret;
296 }