main.c

   1 /*
   2  * Media controller test application
   3  *
   4  * Copyright (C) 2010 Ideas on board SPRL <laurent.pinchart@ideasonboard.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  */
  19
  20 #include <sys/mman.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/time.h>
  23 #include <sys/stat.h>
  24
  25 #include <ctype.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32
  33 #include <linux/types.h>
  34 #include <linux/media.h>
  35 #include <linux/v4l2-mediabus.h>
  36 #include <linux/v4l2-subdev.h>
  37 #include <linux/videodev2.h>
  38
  39 #include "media.h"
  40 #include "options.h"
  41 #include "subdev.h"
  42
  43 /* -----------------------------------------------------------------------------
  44  * Links setup
  45  */
  46
  47 static struct media_entity_pad *parse_pad(struct media_device *media, const char *p, char **endp)
  48 {
  49         unsigned int entity_id, pad;
  50         struct media_entity *entity;
  51         char *end;
  52
  53         for (; isspace(*p); ++p);
  54
  55         if (*p == '"') {
  56                 for (end = (char *)p + 1; *end && *end != '"'; ++end);
  57                 if (*end != '"')
  58                         return NULL;
  59
  60                 entity = media_get_entity_by_name(media, p + 1, end - p - 1);
  61                 if (entity == NULL)
  62                         return NULL;
  63
  64                 for (++end; isspace(*end); ++end);
  65         } else {
  66                 entity_id = strtoul(p, &end, 10);
  67                 entity = media_get_entity_by_id(media, entity_id);
  68                 if (entity == NULL)
  69                         return NULL;
  70         }
  71
  72         if (*end != ':')
  73                 return NULL;
  74         for (p = end + 1; isspace(*p); ++p);
  75
  76         pad = strtoul(p, &end, 10);
  77         for (p = end; isspace(*p); ++p);
  78
  79         if (pad >= entity->info.pads)
  80                 return NULL;
  81
  82         for (p = end; isspace(*p); ++p);
  83         *endp = (char *)p;
  84
  85         return &entity->pads[pad];
  86 }
  87
  88 static struct media_entity_link *parse_link(struct media_device *media, const char *p, char **endp)
  89 {
  90         struct media_entity_link *link;
  91         struct media_entity_pad *source;
  92         struct media_entity_pad *sink;
  93         unsigned int i;
  94         char *end;
  95
  96         source = parse_pad(media, p, &end);
  97         if (source == NULL)
  98                 return NULL;
  99
 100         if (end[0] != '-' || end[1] != '>')
 101                 return NULL;
 102         p = end + 2;
 103
 104         sink = parse_pad(media, p, &end);
 105         if (sink == NULL)
 106                 return NULL;
 107
 108         *endp = end;
 109
 110         for (i = 0; i < source->entity->info.links; i++) {
 111                 link = &source->entity->links[i];
 112
 113                 if (link->source == source && link->sink == sink)
 114                         return link;
 115         }
 116
 117         return NULL;
 118 }
 119
 120 static int setup_link(struct media_device *media, const char *p, char **endp)
 121 {
 122         struct media_entity_link *link;
 123         __u32 flags;
 124         char *end;
 125
 126         link = parse_link(media, p, &end);
 127         if (link == NULL) {
 128                 printf("Unable to parse link\n");
 129                 return -EINVAL;
 130         }
 131
 132         p = end;
 133         if (*p++ != '[') {
 134                 printf("Unable to parse link flags\n");
 135                 return -EINVAL;
 136         }
 137
 138         flags = strtoul(p, &end, 10);
 139         for (p = end; isspace(*p); p++);
 140         if (*p++ != ']') {
 141                 printf("Unable to parse link flags\n");
 142                 return -EINVAL;
 143         }
 144
 145         for (; isspace(*p); p++);
 146         *endp = (char *)p;
 147
 148         printf("Setting up link %u:%u -> %u:%u [%u]\n",
 149                 link->source->entity->info.id, link->source->index,
 150                 link->sink->entity->info.id, link->sink->index,
 151                 flags);
 152
 153         return media_setup_link(media, link->source, link->sink, flags);
 154 }
 155
 156 static int setup_links(struct media_device *media, const char *p)
 157 {
 158         char *end;
 159         int ret;
 160
 161         do {
 162                 ret = setup_link(media, p, &end);
 163                 if (ret < 0)
 164                         return ret;
 165
 166                 p = end + 1;
 167         } while (*end == ',');
 168
 169         return *end ? -EINVAL : 0;
 170 }
 171
 172 /* -----------------------------------------------------------------------------
 173  * Formats setup
 174  */
 175
 176 static int parse_format(struct v4l2_mbus_framefmt *format, const char *p, char **endp)
 177 {
 178         enum v4l2_mbus_pixelcode code;
 179         unsigned int width, height;
 180         char *end;
 181
 182         for (; isspace(*p); ++p);
 183         for (end = (char *)p; !isspace(*end) && *end != '\0'; ++end);
 184
 185         code = string_to_pixelcode(p, end - p);
 186         if (code == (enum v4l2_mbus_pixelcode)-1)
 187                 return -EINVAL;
 188
 189         for (p = end; isspace(*p); ++p);
 190         width = strtoul(p, &end, 10);
 191         if (*end != 'x')
 192                 return -EINVAL;
 193
 194         p = end + 1;
 195         height = strtoul(p, &end, 10);
 196         *endp = end;
 197
 198         memset(format, 0, sizeof(*format));
 199         format->width = width;
 200         format->height = height;
 201         format->code = code;
 202
 203         return 0;
 204 }
 205
 206 static int parse_crop(struct v4l2_rect *crop, const char *p, char **endp)
 207 {
 208         char *end;
 209
 210         for (; isspace(*p); ++p);
 211
 212         crop->left = strtoul(p, &end, 10);
 213         if (*end != ',')
 214                 return -EINVAL;
 215
 216         p = end + 1;
 217         crop->top = strtoul(p, &end, 10);
 218         if (*end != '/')
 219                 return -EINVAL;
 220
 221         p = end + 1;
 222         crop->width = strtoul(p, &end, 10);
 223         if (*end != 'x')
 224                 return -EINVAL;
 225
 226         p = end + 1;
 227         crop->height = strtoul(p, &end, 10);
 228         *endp = end;
 229
 230         return 0;
 231 }
 232
 233 static struct media_entity_pad *parse_pad_format(struct media_device *media,
 234         struct v4l2_mbus_framefmt *format, struct v4l2_rect *crop,
 235         const char *p, char **endp)
 236 {
 237         struct media_entity_pad *pad;
 238         char *end;
 239         int ret;
 240
 241         for (; isspace(*p); ++p);
 242
 243         pad = parse_pad(media, p, &end);
 244         if (pad == NULL)
 245                 return NULL;
 246
 247         for (p = end; isspace(*p); ++p);
 248         if (*p++ != '[')
 249                 return NULL;
 250
 251         ret = parse_format(format, p, &end);
 252         if (ret < 0)
 253                 return NULL;
 254
 255         for (p = end; isspace(*p); p++);
 256         if (*p != ']') {
 257                 ret = parse_crop(crop, p, &end);
 258                 if (ret < 0)
 259                         return NULL;
 260
 261                 for (p = end; isspace(*p); p++);
 262         }
 263
 264         if (*p != ']')
 265                 return NULL;
 266
 267         *endp = (char *)p + 1;
 268         return pad;
 269 }
 270
 271 static int set_format(struct media_entity_pad *pad, struct v4l2_mbus_framefmt *format)
 272 {
 273         int ret;
 274
 275         printf("Setting up format %s %ux%u on pad %s/%u\n",
 276                 pixelcode_to_string(format->code), format->width, format->height,
 277                 pad->entity->info.name, pad->index);
 278
 279         ret = v4l2_subdev_set_format(pad->entity, format, pad->index,
 280                                      V4L2_SUBDEV_FORMAT_ACTIVE);
 281         if (ret < 0) {
 282                 printf("Unable to set format: %s (%d)\n", strerror(-ret), ret);
 283                 return ret;
 284         }
 285
 286         printf("Format set: %s %ux%u\n",
 287                 pixelcode_to_string(format->code), format->width, format->height);
 288
 289         return 0;
 290 }
 291
 292 static int set_crop(struct media_entity_pad *pad, struct v4l2_rect *crop)
 293 {
 294         int ret;
 295
 296         printf("Setting up crop rectangle %u,%u/%ux%u on pad %s/%u\n",
 297                 crop->left, crop->top, crop->width, crop->height,
 298                 pad->entity->info.name, pad->index);
 299
 300         ret = v4l2_subdev_set_crop(pad->entity, crop, pad->index,
 301                                    V4L2_SUBDEV_FORMAT_ACTIVE);
 302         if (ret < 0) {
 303                 printf("Unable to set crop rectangle: %s (%d)", strerror(-ret), ret);
 304                 return ret;
 305         }
 306
 307         printf("Crop rectangle set: %u,%u/%ux%u\n",
 308                 crop->left, crop->top, crop->width, crop->height);
 309
 310         return 0;
 311 }
 312
 313 static int setup_format(struct media_device *media, const char *p, char **endp)
 314 {
 315         struct v4l2_mbus_framefmt format;
 316         struct media_entity_pad *pad;
 317         struct v4l2_rect crop = { -1, -1, -1, -1 };
 318         unsigned int i;
 319         char *end;
 320         int ret;
 321
 322         pad = parse_pad_format(media, &format, &crop, p, &end);
 323         if (pad == NULL) {
 324                 printf("Unable to parse format\n");
 325                 return -EINVAL;
 326         }
 327
 328         ret = set_format(pad, &format);
 329         if (ret < 0) {
 330                 printf("Unable to set format\n");
 331                 return ret;
 332         }
 333
 334         if (crop.left != -1 && crop.top != -1) {
 335                 ret = set_crop(pad, &crop);
 336                 if (ret < 0) {
 337                         printf("Unable to set crop rectangle\n");
 338                         return ret;
 339                 }
 340         }
 341
 342         /* If the pad is an output pad, automatically set the same format on
 343          * the remote subdev input pads, if any.
 344          */
 345         if (pad->type == MEDIA_PAD_TYPE_OUTPUT) {
 346                 for (i = 0; i < pad->entity->info.links; ++i) {
 347                         struct media_entity_link *link = &pad->entity->links[i];
 348                         struct v4l2_mbus_framefmt remote_format;
 349
 350                         if (!(link->flags & MEDIA_LINK_FLAG_ACTIVE))
 351                                 continue;
 352
 353                         if (link->source == pad &&
 354                             link->sink->entity->info.type == MEDIA_ENTITY_TYPE_SUBDEV) {
 355                                 remote_format = format;
 356                                 set_format(link->sink, &remote_format);
 357                         }
 358                 }
 359         }
 360
 361         *endp = end;
 362         return 0;
 363 }
 364
 365 static int setup_formats(struct media_device *media, const char *p)
 366 {
 367         char *end;
 368         int ret;
 369
 370         do {
 371                 ret = setup_format(media, p, &end);
 372                 if (ret < 0)
 373                         return ret;
 374
 375                 p = end + 1;
 376         } while (*end == ',');
 377
 378         return *end ? -EINVAL : 0;
 379 }
 380
 381 int main(int argc, char **argv)
 382 {
 383         struct media_device *media;
 384
 385         if (parse_cmdline(argc, argv))
 386                 return EXIT_FAILURE;
 387
 388         /* Open the media device and enumerate entities, pads and links. */
 389         media = media_open(media_opts.devname, media_opts.verbose);
 390         if (media == NULL)
 391                 goto out;
 392
 393         if (media_opts.entity) {
 394                 struct media_entity *entity;
 395
 396                 entity = media_get_entity_by_name(media, media_opts.entity,
 397                                                   strlen(media_opts.entity));
 398                 if (entity != NULL)
 399                         printf("%s\n", entity->devname);
 400                 else
 401                         printf("Entity '%s' not found\n", media_opts.entity);
 402         }
 403
 404         if (media_opts.print || media_opts.print_dot) {
 405                 media_print_topology(media, media_opts.print_dot);
 406                 printf("\n");
 407         }
 408
 409         if (media_opts.reset) {
 410                 printf("Resetting all links to inactive\n");
 411                 media_reset_links(media);
 412         }
 413
 414         if (media_opts.links)
 415                 setup_links(media, media_opts.links);
 416
 417         if (media_opts.formats)
 418                 setup_formats(media, media_opts.formats);
 419
 420         if (media_opts.interactive) {
 421                 while (1) {
 422                         char buffer[32];
 423                         char *end;
 424
 425                         printf("Enter a link to modify or enter to stop\n");
 426                         if (fgets(buffer, sizeof buffer, stdin) == NULL)
 427                                 break;
 428
 429                         if (buffer[0] == '\n')
 430                                 break;
 431
 432                         setup_link(media, buffer, &end);
 433                 }
 434         }
 435
 436 out:
 437         if (media)
 438                 media_close(media);
 439
 440         exit(EXIT_SUCCESS);
 441 }
 442