v4l2_ctrl.cpp

Cleanup and VBI and audio in/out options

                ctrl.id = qctrl.id;
                if (ioctl(fd, VIDIOC_G_CTRL, &ctrl)) {
                        printf("error %d getting ctrl %s\n",
                                        errno, qctrl.name);
                        return 0;
                }
                ext_ctrl.value = ctrl.value;
        }
        print_qctrl(fd, &qctrl, &ext_ctrl, show_menus);
        return 1;
}
static void list_controls(int fd, int show_menus)
{
        struct v4l2_queryctrl qctrl = { V4L2_CTRL_FLAG_NEXT_CTRL };
        int id;
        while (ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
                        print_control(fd, qctrl, show_menus);
                qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
        }
        if (qctrl.id != V4L2_CTRL_FLAG_NEXT_CTRL)
                return;
        for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
                qctrl.id = id;
                if (ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0)
                        print_control(fd, qctrl, show_menus);
        }
        for (qctrl.id = V4L2_CID_PRIVATE_BASE;
                        ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
                print_control(fd, qctrl, show_menus);
        }
}
static void find_controls(int fd)
{
        struct v4l2_queryctrl qctrl = { V4L2_CTRL_FLAG_NEXT_CTRL };
        int id;
        while (ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
                if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS) {
                        ctrl_str2id[name2var(qctrl.name)] = qctrl.id;
                        ctrl_id2str[qctrl.id] = name2var(qctrl.name);
                }
                qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
        }
        if (qctrl.id != V4L2_CTRL_FLAG_NEXT_CTRL)
                return;
        for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
                qctrl.id = id;
                if (ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0)
                        ctrl_str2id[name2var(qctrl.name)] = qctrl.id;
        }
        for (qctrl.id = V4L2_CID_PRIVATE_BASE;
                        ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
                ctrl_str2id[name2var(qctrl.name)] = qctrl.id;
        }
}
int printfmt(struct v4l2_format vfmt)
{
        printf("Format:\n");
        switch (vfmt.type) {
        case 1:
                printf("\tType   : Video Capture\n");
                printf("\tWidth  : %d\n", vfmt.fmt.pix.width);
                printf("\tHeight : %d\n", vfmt.fmt.pix.height);
                break;
        case 2:
                printf("\tType   : Video Output\n");
                break;
        case 3:
                printf("\tType   : Video Overlay\n");
                break;
        case 4:
                printf("\tType   : VBI Capture\n");
                break;
        case 5:
                printf("\tType   : VBI Output\n");
                break;
        case 0x80:
                printf("\tType   : Private\n");
                break;
        default:
                printf("\tType   : Unknown: %d\n", vfmt.type);
                return -1;
                break;
        }
        return 0;
}
char *pts_to_string(char *str, unsigned long pts)
{
        static char buf[256];
        int hours, minutes, seconds, fracsec;
        float fps;
        int frame;
        char *p = (str) ? str : buf;
        static const int MPEG_CLOCK_FREQ = 90000;
        seconds = pts / MPEG_CLOCK_FREQ;
        fracsec = pts % MPEG_CLOCK_FREQ;
        minutes = seconds / 60;
        seconds = seconds % 60;
        hours = minutes / 60;
        minutes = minutes % 60;
        fps = 30;
        frame = (int)ceilf(((float)fracsec / (float)MPEG_CLOCK_FREQ) * fps);
        snprintf(p, sizeof(buf), "%d:%02d:%02d:%d", hours, minutes, seconds,
                 frame);
        return p;
}
static const char *audmode2s(int audmode)
{
        switch (audmode) {
                case V4L2_TUNER_MODE_STEREO: return "stereo";
                case V4L2_TUNER_MODE_LANG1: return "lang1";
                case V4L2_TUNER_MODE_LANG2: return "lang2";
                case V4L2_TUNER_MODE_LANG1_LANG2: return "bilingual";
                case V4L2_TUNER_MODE_MONO: return "mono";
                default: return "unknown";
        }
}
static std::string rxsubchans2s(int rxsubchans)
{
        std::string s;
        if (rxsubchans & V4L2_TUNER_SUB_MONO)
                s += "mono ";
        if (rxsubchans & V4L2_TUNER_SUB_STEREO)
                s += "stereo ";
        if (rxsubchans & V4L2_TUNER_SUB_LANG1)
                s += "lang1 ";
        if (rxsubchans & V4L2_TUNER_SUB_LANG2)
                s += "lang2 ";
        return s;
}
static std::string tcap2s(unsigned cap)
{
        std::string s;
        if (cap & V4L2_TUNER_CAP_LOW)
                s += "62.5 Hz ";
        else
                s += "62.5 kHz ";
        if (cap & V4L2_TUNER_CAP_NORM)
                s += "multi-standard ";
        if (cap & V4L2_TUNER_CAP_STEREO)
                s += "stereo ";
        if (cap & V4L2_TUNER_CAP_LANG1)
                s += "lang1 ";
        if (cap & V4L2_TUNER_CAP_LANG2)
                s += "lang2 ";
        return s;
}
static std::string cap2s(unsigned cap)
{
        std::string s;
        if (cap & V4L2_CAP_VIDEO_CAPTURE)
                s += "\t\tVideo Capture\n";
        if (cap & V4L2_CAP_VIDEO_OUTPUT)
                s += "\t\tVideo Output\n";
        if (cap & V4L2_CAP_VIDEO_OVERLAY)
                s += "\t\tVideo Overlay\n";
        if (cap & V4L2_CAP_VBI_CAPTURE)
                s += "\t\tVBI Capture\n";
        if (cap & V4L2_CAP_VBI_OUTPUT)
                s += "\t\tVBI Output\n";
        if (cap & V4L2_CAP_SLICED_VBI_CAPTURE)
                s += "\t\tSliced VBI Capture\n";
        if (cap & V4L2_CAP_SLICED_VBI_OUTPUT)
                s += "\t\tSliced VBI Output\n";
        if (cap & V4L2_CAP_RDS_CAPTURE)
                s += "\t\tRDS Capture\n";
        if (cap & V4L2_CAP_TUNER)
                s += "\t\tTuner\n";
        if (cap & V4L2_CAP_AUDIO)
                s += "\t\tAudio\n";
        if (cap & V4L2_CAP_RADIO)
                s += "\t\tRadio\n";
        if (cap & V4L2_CAP_READWRITE)
                s += "\t\tRead/Write\n";
        if (cap & V4L2_CAP_ASYNCIO)
                s += "\t\tAsync I/O\n";
        if (cap & V4L2_CAP_STREAMING)
                s += "\t\tStreaming\n";
        return s;
}
static v4l2_std_id parse_pal(const char *pal)
{
        if (pal[0] == '-') {
                switch (pal[1]) {
                        case 'b':
                        case 'B':
                        case 'g':
                        case 'G':
                                return V4L2_STD_PAL_BG;
                        case 'h':
                        case 'H':
                                return V4L2_STD_PAL_H;
                        case 'n':
                        case 'N':
                                if (pal[2] == 'c' || pal[2] == 'C')
                                        return V4L2_STD_PAL_Nc;
                                return V4L2_STD_PAL_N;
                        case 'i':
                        case 'I':
                                return V4L2_STD_PAL_I;
                        case 'd':
                        case 'D':
                        case 'k':
                        case 'K':
                                return V4L2_STD_PAL_DK;
                        case 'M':
                        case 'm':
                                return V4L2_STD_PAL_M;
                        case '-':
                                break;
                }
        }
        fprintf(stderr, "pal specifier not recognised\n");
        return 0;
}
static v4l2_std_id parse_secam(const char *secam)
{
        if (secam[0] == '-') {
                switch (secam[1]) {
                        case 'b':
                        case 'B':
                        case 'g':
                        case 'G':
                        case 'h':
                        case 'H':
                                return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
                        case 'd':
                        case 'D':
                        case 'k':
                        case 'K':
                                return V4L2_STD_SECAM_DK;
                        case 'l':
                        case 'L':
                                if (secam[2] == 'C' || secam[2] == 'c')
                                        return V4L2_STD_SECAM_LC;
                                return V4L2_STD_SECAM_L;
                        case '-':
                                break;
                }
        }
        fprintf(stderr, "secam specifier not recognised\n");
        return 0;
}
static v4l2_std_id parse_ntsc(const char *ntsc)
{
        if (ntsc[0] == '-') {
                switch (ntsc[1]) {
                        case 'm':
                        case 'M':
                                return V4L2_STD_NTSC_M;
                        case 'j':
                        case 'J':
                                return V4L2_STD_NTSC_M_JP;
                        case 'k':
                        case 'K':
                                return V4L2_STD_NTSC_M_KR;
                        case '-':
                                break;
                }
        }
        fprintf(stderr, "ntsc specifier not recognised\n");
        return 0;
}
static int doioctl(int fd, int request, void *parm, const char *name)
{
        int retVal;
        if (!option_verbose) return ioctl(fd, request, parm);
        retVal = ioctl(fd, request, parm);
        if (retVal < 0)
                printf("failed: %s\n", strerror(errno));
        else
                printf("ok\n");
        return retVal;
}
static int parse_subopt(char **subs, char * const *subopts, char **value)
{
        int opt = getsubopt(subs, subopts, value);
        if (opt == -1) {
                fprintf(stderr, "Invalid suboptions specified\n");
                usage();
                exit(1);
        }
        if (value == NULL) {
                fprintf(stderr, "No value given to suboption <%s>\n",
                                subopts[opt]);
                usage();