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 int parse_frame_interval(struct v4l2_fract *interval, const char *p, char **endp)
 234 {
 235         char *end;
 236
 237         for (; isspace(*p); ++p);
 238
 239         interval->numerator = strtoul(p, &end, 10);
 240
 241         for (p = end; isspace(*p); ++p);
 242         if (*p++ != '/')
 243                 return -EINVAL;
 244
 245         for (; isspace(*p); ++p);
 246         interval->denominator = strtoul(p, &end, 10);
 247
 248         *endp = end;
 249         return 0;
 250 }
 251
 252 static struct media_entity_pad *parse_pad_format(struct media_device *media,
 253         struct v4l2_mbus_framefmt *format, struct v4l2_rect *crop,
 254         struct v4l2_fract *interval, const char *p, char **endp)
 255 {
 256         struct media_entity_pad *pad;
 257         char *end;
 258         int ret;
 259
 260         for (; isspace(*p); ++p);
 261
 262         pad = parse_pad(media, p, &end);
 263         if (pad == NULL)
 264                 return NULL;
 265
 266         for (p = end; isspace(*p); ++p);
 267         if (*p++ != '[')
 268                 return NULL;
 269
 270         ret = parse_format(format, p, &end);
 271         if (ret < 0)
 272                 return NULL;
 273
 274         for (p = end; isspace(*p); p++);
 275         if (isdigit(*p)) {
 276                 ret = parse_crop(crop, p, &end);
 277                 if (ret < 0)
 278                         return NULL;
 279
 280                 for (p = end; isspace(*p); p++);
 281         }
 282
 283         if (*p == '@') {
 284                 ret = parse_frame_interval(interval, ++p, &end);
 285                 if (ret < 0)
 286                         return NULL;
 287
 288                 for (p = end; isspace(*p); p++);
 289         }
 290
 291         if (*p != ']')
 292                 return NULL;
 293
 294         *endp = (char *)p + 1;
 295         return pad;
 296 }
 297
 298 static int set_format(struct media_entity_pad *pad, struct v4l2_mbus_framefmt *format)
 299 {
 300         int ret;
 301
 302         printf("Setting up format %s %ux%u on pad %s/%u\n",
 303                 pixelcode_to_string(format->code), format->width, format->height,
 304                 pad->entity->info.name, pad->index);
 305
 306         ret = v4l2_subdev_set_format(pad->entity, format, pad->index,
 307                                      V4L2_SUBDEV_FORMAT_ACTIVE);
 308         if (ret < 0) {
 309                 printf("Unable to set format: %s (%d)\n", strerror(-ret), ret);
 310                 return ret;
 311         }
 312
 313         printf("Format set: %s %ux%u\n",
 314                 pixelcode_to_string(format->code), format->width, format->height);
 315
 316         return 0;
 317 }
 318
 319 static int set_crop(struct media_entity_pad *pad, struct v4l2_rect *crop)
 320 {
 321         int ret;
 322
 323         printf("Setting up crop rectangle %u,%u/%ux%u on pad %s/%u\n",
 324                 crop->left, crop->top, crop->width, crop->height,
 325                 pad->entity->info.name, pad->index);
 326
 327         ret = v4l2_subdev_set_crop(pad->entity, crop, pad->index,
 328                                    V4L2_SUBDEV_FORMAT_ACTIVE);
 329         if (ret < 0) {
 330                 printf("Unable to set crop rectangle: %s (%d)", strerror(-ret), ret);
 331                 return ret;
 332         }
 333
 334         printf("Crop rectangle set: %u,%u/%ux%u\n",
 335                 crop->left, crop->top, crop->width, crop->height);
 336
 337         return 0;
 338 }
 339
 340 static int set_frame_interval(struct media_entity *entity, struct v4l2_fract *interval)
 341 {
 342         int ret;
 343
 344         printf("Setting up frame interval %u/%u on entity %s\n",
 345                 interval->numerator, interval->denominator, entity->info.name);
 346
 347         ret = v4l2_subdev_set_frame_interval(entity, interval);
 348         if (ret < 0) {
 349                 printf("Unable to set frame interval: %s (%d)", strerror(-ret), ret);
 350                 return ret;
 351         }
 352
 353         printf("Frame interval set: %u/%u\n",
 354                 interval->numerator, interval->denominator);
 355
 356         return 0;
 357 }
 358
 359
 360 static int setup_format(struct media_device *media, const char *p, char **endp)
 361 {
 362         struct v4l2_mbus_framefmt format;
 363         struct media_entity_pad *pad;
 364         struct v4l2_rect crop = { -1, -1, -1, -1 };
 365         struct v4l2_fract interval = { 0, 0 };
 366         unsigned int i;
 367         char *end;
 368         int ret;
 369
 370         pad = parse_pad_format(media, &format, &crop, &interval, p, &end);
 371         if (pad == NULL) {
 372                 printf("Unable to parse format\n");
 373                 return -EINVAL;
 374         }
 375
 376         ret = set_format(pad, &format);
 377         if (ret < 0) {
 378                 printf("Unable to set format\n");
 379                 return ret;
 380         }
 381
 382         if (crop.left != -1 && crop.top != -1) {
 383                 ret = set_crop(pad, &crop);
 384                 if (ret < 0) {
 385                         printf("Unable to set crop rectangle\n");
 386                         return ret;
 387                 }
 388         }
 389
 390         if (interval.numerator != 0) {
 391                 ret = set_frame_interval(pad->entity, &interval);
 392                 if (ret < 0) {
 393                         printf("Unable to set frame interval\n");
 394                         return ret;
 395                 }
 396         }
 397
 398         /* If the pad is an output pad, automatically set the same format on
 399          * the remote subdev input pads, if any.
 400          */
 401         if (pad->type == MEDIA_PAD_TYPE_OUTPUT) {
 402                 for (i = 0; i < pad->entity->info.links; ++i) {
 403                         struct media_entity_link *link = &pad->entity->links[i];
 404                         struct v4l2_mbus_framefmt remote_format;
 405
 406                         if (!(link->flags & MEDIA_LINK_FLAG_ACTIVE))
 407                                 continue;
 408
 409                         if (link->source == pad &&
 410                             link->sink->entity->info.type == MEDIA_ENTITY_TYPE_SUBDEV) {
 411                                 remote_format = format;
 412                                 set_format(link->sink, &remote_format);
 413                         }
 414                 }
 415         }
 416
 417         *endp = end;
 418         return 0;
 419 }
 420
 421 static int setup_formats(struct media_device *media, const char *p)
 422 {
 423         char *end;
 424         int ret;
 425
 426         do {
 427                 ret = setup_format(media, p, &end);
 428                 if (ret < 0)
 429                         return ret;
 430
 431                 p = end + 1;
 432         } while (*end == ',');
 433
 434         return *end ? -EINVAL : 0;
 435 }
 436
 437 int main(int argc, char **argv)
 438 {
 439         struct media_device *media;
 440
 441         if (parse_cmdline(argc, argv))
 442                 return EXIT_FAILURE;
 443
 444         /* Open the media device and enumerate entities, pads and links. */
 445         media = media_open(media_opts.devname, media_opts.verbose);
 446         if (media == NULL)
 447                 goto out;
 448
 449         if (media_opts.entity) {
 450                 struct media_entity *entity;
 451
 452                 entity = media_get_entity_by_name(media, media_opts.entity,
 453                                                   strlen(media_opts.entity));
 454                 if (entity != NULL)
 455                         printf("%s\n", entity->devname);
 456                 else
 457                         printf("Entity '%s' not found\n", media_opts.entity);
 458         }
 459
 460         if (media_opts.print || media_opts.print_dot) {
 461                 media_print_topology(media, media_opts.print_dot);
 462                 printf("\n");
 463         }
 464
 465         if (media_opts.reset) {
 466                 printf("Resetting all links to inactive\n");
 467                 media_reset_links(media);
 468         }
 469
 470         if (media_opts.links)
 471                 setup_links(media, media_opts.links);
 472
 473         if (media_opts.formats)
 474                 setup_formats(media, media_opts.formats);
 475
 476         if (media_opts.interactive) {
 477                 while (1) {
 478                         char buffer[32];
 479                         char *end;
 480
 481                         printf("Enter a link to modify or enter to stop\n");
 482                         if (fgets(buffer, sizeof buffer, stdin) == NULL)
 483                                 break;
 484
 485                         if (buffer[0] == '\n')
 486                                 break;
 487
 488                         setup_link(media, buffer, &end);
 489                 }
 490         }
 491
 492 out:
 493         if (media)
 494                 media_close(media);
 495
 496         exit(EXIT_SUCCESS);
 497 }
 498