This is an automatic generated email to let you know that the following patch 
were queued at the 
http://git.linuxtv.org/cgit.cgi/v4l-utils.git tree:

Subject: media-info: various improvements
Author:  Hans Verkuil <hans.verk...@cisco.com>
Date:    Mon Jul 2 09:29:52 2018 +0200

- consistently use the mi_ prefix for the exported functions
- add missing MEDIA_TYPE_DTV_CA
- add mi_func_requires_intf() and test for this in v4l2-compliance

Signed-off-by: Hans Verkuil <hans.verk...@cisco.com>

 utils/common/media-info.cpp               | 47 +++++++++++++++++++++----------
 utils/common/media-info.h                 | 18 +++++++-----
 utils/v4l2-compliance/v4l2-compliance.cpp |  2 +-
 utils/v4l2-compliance/v4l2-test-media.cpp | 31 +++++++++++++-------
 utils/v4l2-ctl/v4l2-ctl.cpp               |  2 +-
 5 files changed, 66 insertions(+), 34 deletions(-)

---

http://git.linuxtv.org/cgit.cgi/v4l-utils.git/commit/?id=47593771ad61f52d3670ef35373f24f85d5da267
diff --git a/utils/common/media-info.cpp b/utils/common/media-info.cpp
index f3aefe10b31f..b735d143cc55 100644
--- a/utils/common/media-info.cpp
+++ b/utils/common/media-info.cpp
@@ -49,10 +49,11 @@ static struct {
        { "demux", MEDIA_TYPE_DVB_DEMUX },
        { "dvr", MEDIA_TYPE_DVB_DVR },
        { "net", MEDIA_TYPE_DVB_NET },
+       { "ca", MEDIA_TYPE_DTV_CA },
        { NULL, MEDIA_TYPE_UNKNOWN }
 };
 
-media_type media_detect_type(const char *device)
+media_type mi_media_detect_type(const char *device)
 {
        struct stat sb;
 
@@ -97,7 +98,7 @@ media_type media_detect_type(const char *device)
        return MEDIA_TYPE_UNKNOWN;
 }
 
-std::string media_get_device(__u32 major, __u32 minor)
+std::string mi_media_get_device(__u32 major, __u32 minor)
 {
        char fmt[32];
        std::string uevent_path("/sys/dev/char/");
@@ -236,7 +237,7 @@ static const flag_def entity_flags_def[] = {
        { 0, NULL }
 };
 
-std::string entflags2s(__u32 flags)
+std::string mi_entflags2s(__u32 flags)
 {
        return flags2s(flags, entity_flags_def);
 }
@@ -266,7 +267,7 @@ static const flag_def interface_types_def[] = {
        { 0, NULL }
 };
 
-std::string ifacetype2s(__u32 type)
+std::string mi_ifacetype2s(__u32 type)
 {
        for (unsigned i = 0; interface_types_def[i].str; i++)
                if (type == interface_types_def[i].flag)
@@ -310,7 +311,7 @@ static const flag_def entity_functions_def[] = {
        { 0, NULL }
 };
 
-std::string entfunction2s(__u32 function, bool *is_invalid)
+std::string mi_entfunction2s(__u32 function, bool *is_invalid)
 {
        std::string s;
 
@@ -349,6 +350,22 @@ std::string entfunction2s(__u32 function, bool *is_invalid)
        return "Unknown Function (" + num2s(function) + ")";
 }
 
+bool mi_func_requires_intf(__u32 function)
+{
+       switch (function) {
+       case MEDIA_ENT_F_DTV_DEMOD:
+       case MEDIA_ENT_F_TS_DEMUX:
+       case MEDIA_ENT_F_DTV_CA:
+       case MEDIA_ENT_F_IO_DTV:
+       case MEDIA_ENT_F_IO_V4L:
+       case MEDIA_ENT_F_IO_VBI:
+       case MEDIA_ENT_F_IO_SWRADIO:
+               return true;
+       default:
+               return false;
+       }
+}
+
 static const flag_def pad_flags_def[] = {
        { MEDIA_PAD_FL_SINK, "Sink" },
        { MEDIA_PAD_FL_SOURCE, "Source" },
@@ -356,7 +373,7 @@ static const flag_def pad_flags_def[] = {
        { 0, NULL }
 };
 
-std::string padflags2s(__u32 flags)
+std::string mi_padflags2s(__u32 flags)
 {
        return flags2s(flags, pad_flags_def);
 }
@@ -368,7 +385,7 @@ static const flag_def link_flags_def[] = {
        { 0, NULL }
 };
 
-std::string linkflags2s(__u32 flags)
+std::string mi_linkflags2s(__u32 flags)
 {
        std::string s = flags2s(flags & ~MEDIA_LNK_FL_LINK_TYPE, 
link_flags_def);
 
@@ -447,11 +464,11 @@ static __u32 read_topology(int media_fd, __u32 major, 
__u32 minor, bool *is_inva
 
        printf("Interface Info:\n");
        printf("\tID               : 0x%08x\n", iface.id);
-       printf("\tType             : %s\n", 
ifacetype2s(iface.intf_type).c_str());
+       printf("\tType             : %s\n", 
mi_ifacetype2s(iface.intf_type).c_str());
        printf("Entity Info:\n");
        printf("\tID               : 0x%08x (%u)\n", ent.id, ent.id);
        printf("\tName             : %s\n", ent.name);
-       printf("\tFunction         : %s\n", entfunction2s(ent.function, 
is_invalid).c_str());
+       printf("\tFunction         : %s\n", mi_entfunction2s(ent.function, 
is_invalid).c_str());
 
        // Yes, I know, lots of nested for-loops. If we get really complex
        // devices with such large topologies that this becomes too inefficient
@@ -463,7 +480,7 @@ static __u32 read_topology(int media_fd, __u32 major, __u32 
minor, bool *is_inva
                if (pad.entity_id != ent.id)
                        continue;
                printf("\tPad 0x%08x   : %s\n",
-                      pad.id, padflags2s(pad.flags).c_str());
+                      pad.id, mi_padflags2s(pad.flags).c_str());
                for (j = 0; j < topology.num_links; j++) {
                        const media_v2_link &link = v2_links[j];
                        __u32 type = link.flags & MEDIA_LNK_FL_LINK_TYPE;
@@ -502,7 +519,7 @@ static __u32 read_topology(int media_fd, __u32 major, __u32 
minor, bool *is_inva
                        }
                        printf("\t  Link 0x%08x: %s remote pad 0x%x of entity 
'%s': %s\n",
                               link.id, is_sink ? "from" : "to", remote_pad,
-                              remote_ent->name, 
linkflags2s(link.flags).c_str());
+                              remote_ent->name, 
mi_linkflags2s(link.flags).c_str());
                }
        }
        return ent.id;
@@ -567,9 +584,9 @@ __u32 mi_media_info_for_fd(int media_fd, int fd, bool 
*is_invalid)
        printf("Entity Info:\n");
        printf("\tID               : %u\n", ent.id);
        printf("\tName             : %s\n", ent.name);
-       printf("\tType             : %s\n", entfunction2s(ent.type).c_str());
+       printf("\tType             : %s\n", mi_entfunction2s(ent.type).c_str());
        if (ent.flags)
-               printf("\tFlags            : %s\n", 
entflags2s(ent.flags).c_str());
+               printf("\tFlags            : %s\n", 
mi_entflags2s(ent.flags).c_str());
        if (ent.flags & MEDIA_ENT_FL_DEFAULT) {
                printf("\tMajor            : %u\n", ent.dev.major);
                printf("\tMinor            : %u\n", ent.dev.minor);
@@ -588,11 +605,11 @@ __u32 mi_media_info_for_fd(int media_fd, int fd, bool 
*is_invalid)
 
        for (unsigned i = 0; i < ent.pads; i++)
                printf("\tPad              : %u: %s\n", pads[i].index,
-                      padflags2s(pads[i].flags).c_str());
+                      mi_padflags2s(pads[i].flags).c_str());
        for (unsigned i = 0; i < ent.links; i++)
                printf("\tLink             : %u->%u: %s\n",
                       links[i].source.entity,
                       links[i].sink.entity,
-                      linkflags2s(links[i].flags).c_str());
+                      mi_linkflags2s(links[i].flags).c_str());
        return ent.id;
 }
diff --git a/utils/common/media-info.h b/utils/common/media-info.h
index 979b5884f85e..5cb6a66f23aa 100644
--- a/utils/common/media-info.h
+++ b/utils/common/media-info.h
@@ -19,18 +19,19 @@ enum media_type {
        MEDIA_TYPE_DVB_DEMUX,
        MEDIA_TYPE_DVB_DVR,
        MEDIA_TYPE_DVB_NET,
+       MEDIA_TYPE_DTV_CA,
        MEDIA_TYPE_MEDIA,
 };
 
 /*
  * Detect what type the device is.
  */
-media_type media_detect_type(const char *device);
+media_type mi_media_detect_type(const char *device);
 
 /*
  * Return the device name given the major and minor numbers.
  */
-std::string media_get_device(__u32 major, __u32 minor);
+std::string mi_media_get_device(__u32 major, __u32 minor);
 
 /*
  * For a given device fd retrieve the dev_t (major/minor) value.
@@ -53,19 +54,22 @@ std::string mi_get_devpath_from_dev_t(dev_t dev);
 int mi_get_media_fd(int fd);
 
 /* Return entity flags description */
-std::string entflags2s(__u32 flags);
+std::string mi_entflags2s(__u32 flags);
 
 /* Return interface flags description */
-std::string ifacetype2s(__u32 type);
+std::string mi_ifacetype2s(__u32 type);
+
+/* Return true if this function requires an interface */
+bool mi_func_requires_intf(__u32 function);
 
 /* Return function description */
-std::string entfunction2s(__u32 function, bool *is_invalid = NULL);
+std::string mi_entfunction2s(__u32 function, bool *is_invalid = NULL);
 
 /* Return pad flags description */
-std::string padflags2s(__u32 flags);
+std::string mi_padflags2s(__u32 flags);
 
 /* Return link flags description */
-std::string linkflags2s(__u32 flags);
+std::string mi_linkflags2s(__u32 flags);
 
 /*
  * Show media controller information media_fd and (if >= 0) the
diff --git a/utils/v4l2-compliance/v4l2-compliance.cpp 
b/utils/v4l2-compliance/v4l2-compliance.cpp
index 2bd7b2e2aba8..7167f549d0af 100644
--- a/utils/v4l2-compliance/v4l2-compliance.cpp
+++ b/utils/v4l2-compliance/v4l2-compliance.cpp
@@ -1258,7 +1258,7 @@ int main(int argc, char **argv)
        int fd;
 
        if (type == MEDIA_TYPE_UNKNOWN)
-               type = media_detect_type(device);
+               type = mi_media_detect_type(device);
        if (type == MEDIA_TYPE_CANT_STAT) {
                fprintf(stderr, "Cannot open device %s, exiting.\n",
                        device);
diff --git a/utils/v4l2-compliance/v4l2-test-media.cpp 
b/utils/v4l2-compliance/v4l2-test-media.cpp
index 4856f6c946c2..6bd09018edb0 100644
--- a/utils/v4l2-compliance/v4l2-test-media.cpp
+++ b/utils/v4l2-compliance/v4l2-test-media.cpp
@@ -158,7 +158,7 @@ int testMediaTopology(struct node *node)
 
                if (show_info)
                        printf("\t\tEntity: 0x%08x (Name: '%s', Function: 
%s)\n",
-                              ent.id, ent.name, 
entfunction2s(ent.function).c_str());
+                              ent.id, ent.name, 
mi_entfunction2s(ent.function).c_str());
                fail_on_test(check_0(ent.reserved, sizeof(ent.reserved)));
                fail_on_test(check_string(ent.name, sizeof(ent.name)));
                fail_on_test(!ent.id);
@@ -176,7 +176,7 @@ int testMediaTopology(struct node *node)
 
                if (show_info)
                        printf("\t\tInterface: 0x%08x (Type: %s, DevPath: 
%s)\n",
-                              iface.id, ifacetype2s(iface.intf_type).c_str(),
+                              iface.id, 
mi_ifacetype2s(iface.intf_type).c_str(),
                               devpath.c_str());
                fail_on_test(devpath.empty());
                fail_on_test(check_0(iface.reserved, sizeof(iface.reserved)));
@@ -198,7 +198,7 @@ int testMediaTopology(struct node *node)
                if (show_info)
                        printf("\t\tPad: 0x%08x (%s, %s)\n", pad.id,
                               v2_entity_map[pad.entity_id]->name,
-                              padflags2s(pad.flags).c_str());
+                              mi_padflags2s(pad.flags).c_str());
                fail_on_test(check_0(pad.reserved, sizeof(pad.reserved)));
                fail_on_test(!pad.id);
                fail_on_test(!pad.entity_id);
@@ -211,6 +211,9 @@ int testMediaTopology(struct node *node)
                entity_num_pads[pad.entity_id]++;
                v2_pad_map[pad.id] = &pad;
        }
+
+       std::set<__u32> ents_with_intf;
+
        for (unsigned i = 0; i < topology.num_links; i++) {
                media_v2_link &link = v2_links[i];
                bool is_iface = link.flags & MEDIA_LNK_FL_LINK_TYPE;
@@ -228,11 +231,12 @@ int testMediaTopology(struct node *node)
                        media_v2_interface &iface = 
*v2_iface_map[link.source_id];
                        dev_t dev = makedev(iface.devnode.major, 
iface.devnode.minor);
                        std::string devpath = mi_get_devpath_from_dev_t(dev);
+                       media_v2_entity &ent = *v2_entity_map[link.sink_id];
 
                        if (show_info)
                                printf("\t\tLink: 0x%08x (%s to interface 
%s)\n", link.id,
-                                      v2_entity_map[link.sink_id]->name,
-                                      devpath.c_str());
+                                      ent.name, devpath.c_str());
+                       ents_with_intf.insert(ent.id);
                } else {
                        fail_on_test(v2_pads_set.find(link.source_id) == 
v2_pads_set.end());
                        fail_on_test(v2_pads_set.find(link.sink_id) == 
v2_pads_set.end());
@@ -242,9 +246,16 @@ int testMediaTopology(struct node *node)
                                printf("\t\tLink: 0x%08x (%s -> %s, %s)\n", 
link.id,
                                       
v2_entity_map[v2_pad_map[link.source_id]->entity_id]->name,
                                       
v2_entity_map[v2_pad_map[link.sink_id]->entity_id]->name,
-                                      linkflags2s(link.flags).c_str());
+                                      mi_linkflags2s(link.flags).c_str());
                }
        }
+
+       for (unsigned i = 0; i < topology.num_entities; i++) {
+               media_v2_entity &ent = v2_ents[i];
+
+               fail_on_test(mi_func_requires_intf(ent.function) &&
+                            ents_with_intf.find(ent.id) == 
ents_with_intf.end());
+       }
        node->topology = &topology;
        return 0;
 }
@@ -279,7 +290,7 @@ int testMediaEnum(struct node *node)
 
                if (show_info) {
                        printf("\t\tEntity: 0x%08x (Name: '%s', Type: %s",
-                              ent.id, ent.name, 
entfunction2s(ent.type).c_str());
+                              ent.id, ent.name, 
mi_entfunction2s(ent.type).c_str());
                        if (!devpath.empty())
                                printf(", DevPath: %s", devpath.c_str());
                        printf(")\n");
@@ -465,14 +476,14 @@ void walkTopology(struct node &node, struct node 
&expbuf_node, unsigned frame_co
 
        for (unsigned i = 0; i < topology.num_interfaces; i++) {
                media_v2_interface &iface = v2_ifaces[i];
-               std::string dev = media_get_device(iface.devnode.major,
-                                                  iface.devnode.minor);
+               std::string dev = mi_media_get_device(iface.devnode.major,
+                                                     iface.devnode.minor);
                if (dev.empty())
                        continue;
 
                
printf("--------------------------------------------------------------------------------\n");
 
-               media_type type = media_detect_type(dev.c_str());
+               media_type type = mi_media_detect_type(dev.c_str());
                if (type == MEDIA_TYPE_CANT_STAT) {
                        fprintf(stderr, "\nCannot open device %s, 
skipping.\n\n",
                                dev.c_str());
diff --git a/utils/v4l2-ctl/v4l2-ctl.cpp b/utils/v4l2-ctl/v4l2-ctl.cpp
index 92697e6e14ce..d94210662caf 100644
--- a/utils/v4l2-ctl/v4l2-ctl.cpp
+++ b/utils/v4l2-ctl/v4l2-ctl.cpp
@@ -989,7 +989,7 @@ int main(int argc, char **argv)
                return 1;
        }
 
-       media_type type = media_detect_type(device);
+       media_type type = mi_media_detect_type(device);
        if (type == MEDIA_TYPE_CANT_STAT) {
                fprintf(stderr, "Cannot open device %s, exiting.\n",
                        device);

_______________________________________________
linuxtv-commits mailing list
linuxtv-commits@linuxtv.org
https://www.linuxtv.org/cgi-bin/mailman/listinfo/linuxtv-commits

Reply via email to