static void parse_freq_seek(char *optarg, struct v4l2_hw_freq_seek &seek) { char *value; char *subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "dir", "wrap", "spacing", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: seek.seek_upward = strtol(value, 0L, 0); break; case 1: seek.wrap_around = strtol(value, 0L, 0); break; case 2: seek.spacing = strtol(value, 0L, 0); break; default: usage_tuner(); exit(1); } } }
void vbi_cmd(int ch, char *optarg) { char *value, *subs; bool found_off = false; v4l2_format *fmt = &vbi_fmt; switch (ch) { case OptSetSlicedVbiOutFormat: case OptTrySlicedVbiOutFormat: fmt = &vbi_fmt_out; /* fall through */ case OptSetSlicedVbiFormat: case OptTrySlicedVbiFormat: fmt->fmt.sliced.service_set = 0; subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "off", "teletext", "cc", "wss", "vps", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: found_off = true; break; case 1: fmt->fmt.sliced.service_set |= V4L2_SLICED_TELETEXT_B; break; case 2: fmt->fmt.sliced.service_set |= V4L2_SLICED_CAPTION_525; break; case 3: fmt->fmt.sliced.service_set |= V4L2_SLICED_WSS_625; break; case 4: fmt->fmt.sliced.service_set |= V4L2_SLICED_VPS; break; default: vbi_usage(); break; } } if (found_off && fmt->fmt.sliced.service_set) { fprintf(stderr, "Sliced VBI mode 'off' cannot be combined with other modes\n"); vbi_usage(); exit(1); } break; } }
void vidcap_cmd(int ch, char *optarg) { __u32 colorspace, xfer_func, ycbcr, quantization; char *value, *subs; switch (ch) { case OptSetVideoFormat: case OptTryVideoFormat: set_fmts = parse_fmt(optarg, width, height, pixfmt, field, colorspace, xfer_func, ycbcr, quantization, flags, bytesperline); if (!set_fmts || (set_fmts & (FmtColorspace | FmtYCbCr | FmtQuantization | FmtXferFunc))) { vidcap_usage(); exit(1); } break; case OptListFrameSizes: if (strlen(optarg) == 4) frmsize.pixel_format = v4l2_fourcc(optarg[0], optarg[1], optarg[2], optarg[3]); else frmsize.pixel_format = strtol(optarg, 0L, 0); break; case OptListFrameIntervals: subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "width", "height", "pixelformat", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: frmival.width = strtol(value, 0L, 0); break; case 1: frmival.height = strtol(value, 0L, 0); break; case 2: if (strlen(value) == 4) frmival.pixel_format = v4l2_fourcc(value[0], value[1], value[2], value[3]); else frmival.pixel_format = strtol(value, 0L, 0); break; default: vidcap_usage(); exit(1); } } break; } }
int main(int argc, char **argv) { char *value, *subs; int i, forcedstride = 0; int fd = -1; /* command args */ int ch; const char *device = "/dev/video0"; /* -d device */ struct v4l2_capability vcap; /* list_cap */ struct v4l2_dbg_register set_reg; struct v4l2_dbg_register get_reg; struct v4l2_dbg_chip_info chip_info; const struct board_list *curr_bd = NULL; char short_options[26 * 2 * 3 + 1]; int idx = 0; std::string reg_min_arg, reg_max_arg; std::string reg_set_arg; unsigned long long reg_min = 0, reg_max = 0; std::vector<std::string> get_regs; struct v4l2_dbg_match match; char *p; match.type = V4L2_CHIP_MATCH_BRIDGE; match.addr = 0; memset(&set_reg, 0, sizeof(set_reg)); memset(&get_reg, 0, sizeof(get_reg)); if (argc == 1) { usage(); return 0; } for (i = 0; long_options[i].name; i++) { if (!isalpha(long_options[i].val)) continue; short_options[idx++] = long_options[i].val; if (long_options[i].has_arg == required_argument) { short_options[idx++] = ':'; } else if (long_options[i].has_arg == optional_argument) { short_options[idx++] = ':'; short_options[idx++] = ':'; } } while (1) { int option_index = 0; short_options[idx] = 0; ch = getopt_long(argc, argv, short_options, long_options, &option_index); if (ch == -1) break; options[(int)ch] = 1; switch (ch) { case OptHelp: usage(); return 0; case OptSetDevice: device = optarg; if (device[0] >= '0' && device[0] <= '9' && strlen(device) <= 3) { static char newdev[20]; sprintf(newdev, "/dev/video%s", device); device = newdev; } break; case OptChip: if (!memcmp(optarg, "subdev", 6) && isdigit(optarg[6])) { match.type = V4L2_CHIP_MATCH_SUBDEV; match.addr = strtoul(optarg + 6, NULL, 0); break; } if (!memcmp(optarg, "bridge", 6)) { match.type = V4L2_CHIP_MATCH_BRIDGE; match.addr = strtoul(optarg + 6, NULL, 0); break; } match.type = V4L2_CHIP_MATCH_BRIDGE; match.addr = 0; break; case OptSetRegister: reg_set_arg = optarg; break; case OptGetRegister: get_regs.push_back(optarg); break; case OptSetStride: forcedstride = strtoull(optarg, 0L, 0); break; case OptListRegisters: subs = optarg; if (subs == NULL) break; while (*subs != '\0') { static const char * const subopts[] = { "min", "max", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: reg_min_arg = value; //if (reg_max == 0) // reg_max = reg_min + 0xff; break; case 1: reg_max_arg = value; break; } } break; case OptListSymbols: break; case ':': fprintf(stderr, "Option `%s' requires a value\n", argv[optind]); usage(); return 1; case '?': fprintf(stderr, "Unknown argument `%s'\n", argv[optind]); usage(); return 1; } } if ((fd = open(device, O_RDWR)) < 0) { fprintf(stderr, "Failed to open %s: %s\n", device, strerror(errno)); exit(1); } doioctl(fd, VIDIOC_QUERYCAP, &vcap, "VIDIOC_QUERYCAP"); capabilities = vcap.capabilities; /* Information Opts */ if (options[OptGetDriverInfo]) { printf("Driver info:\n"); printf("\tDriver name : %s\n", vcap.driver); printf("\tCard type : %s\n", vcap.card); printf("\tBus info : %s\n", vcap.bus_info); printf("\tDriver version: %d.%d.%d\n", vcap.version >> 16, (vcap.version >> 8) & 0xff, vcap.version & 0xff); printf("\tCapabilities : 0x%08X\n", vcap.capabilities); printf("%s", cap2s(vcap.capabilities).c_str()); } chip_info.name[0] = '\0'; if (options[OptChip]) { /* try to figure out which chip it is */ chip_info.match = match; if (doioctl(fd, VIDIOC_DBG_G_CHIP_INFO, &chip_info, "VIDIOC_DBG_G_CHIP_INFO") != 0) chip_info.name[0] = '\0'; if (!strncasecmp(match.name, "ac97", 4)) { curr_bd = &boards[AC97_BOARD]; } else { for (int board = ARRAY_SIZE(boards) - 1; board >= 0; board--) { if (!strcasecmp(chip_info.name, boards[board].name)) { curr_bd = &boards[board]; break; } } } } /* Set options */ if (options[OptSetRegister]) { set_reg.match = match; if (optind >= argc) usage(); set_reg.reg = parse_reg(curr_bd, reg_set_arg); while (optind < argc) { unsigned size = 0; if (doioctl(fd, VIDIOC_DBG_G_REGISTER, &set_reg, "VIDIOC_DBG_G_REGISTER") >= 0) size = set_reg.size; set_reg.val = strtoull(argv[optind++], NULL, 0); if (doioctl(fd, VIDIOC_DBG_S_REGISTER, &set_reg, "VIDIOC_DBG_S_REGISTER") >= 0) { const char *name = reg_name(curr_bd, set_reg.reg); printf("Register "); if (name) printf("%s (0x%08llx)", name, set_reg.reg); else printf("0x%08llx", set_reg.reg); printf(" set to 0x%llx\n", set_reg.val); } else { printf("Failed to set register 0x%08llx value 0x%llx: %s\n", set_reg.reg, set_reg.val, strerror(errno)); } set_reg.reg += size ? : (forcedstride ? : 1); } } if (options[OptScanChips]) { chip_info.match.type = V4L2_CHIP_MATCH_BRIDGE; chip_info.match.addr = 0; while (doioctl(fd, VIDIOC_DBG_G_CHIP_INFO, &chip_info, "VIDIOC_DBG_G_CHIP_INFO") == 0 && chip_info.name[0]) { printf("bridge%d: ", chip_info.match.addr); print_name(&chip_info); chip_info.match.addr++; } chip_info.match.type = V4L2_CHIP_MATCH_SUBDEV; chip_info.match.addr = 0; while (doioctl(fd, VIDIOC_DBG_G_CHIP_INFO, &chip_info, "VIDIOC_DBG_G_CHIP_INFO") == 0 && chip_info.name[0]) { printf("subdev%d: ", chip_info.match.addr++); print_name(&chip_info); } } if (options[OptGetRegister]) { get_reg.match = match; printf("ioctl: VIDIOC_DBG_G_REGISTER\n"); for (std::vector<std::string>::iterator iter = get_regs.begin(); iter != get_regs.end(); ++iter) { get_reg.reg = parse_reg(curr_bd, *iter); if (ioctl(fd, VIDIOC_DBG_G_REGISTER, &get_reg) < 0) fprintf(stderr, "ioctl: VIDIOC_DBG_G_REGISTER " "failed for 0x%llx\n", get_reg.reg); else { const char *name = reg_name(curr_bd, get_reg.reg); printf("Register "); if (name) printf("%s (0x%08llx)", name, get_reg.reg); else printf("0x%08llx", get_reg.reg); printf(" = %llxh (%lldd %sb)\n", get_reg.val, get_reg.val, binary(get_reg.val)); } } } if (options[OptListRegisters]) { std::string name; int stride = 1; get_reg.match = match; if (forcedstride) { stride = forcedstride; } else if (get_reg.match.type == V4L2_CHIP_MATCH_BRIDGE) { stride = 4; } printf("ioctl: VIDIOC_DBG_G_REGISTER\n"); if (curr_bd) { if (reg_min_arg.empty()) reg_min = 0; else reg_min = parse_reg(curr_bd, reg_min_arg); if (reg_max_arg.empty()) reg_max = (1ll << 32) - 1; else reg_max = parse_reg(curr_bd, reg_max_arg); for (int i = 0; i < curr_bd->regs_size; i++) { if (reg_min_arg.empty() || ((curr_bd->regs[i].reg >= reg_min) && curr_bd->regs[i].reg <= reg_max)) { get_reg.reg = curr_bd->regs[i].reg; if (ioctl(fd, VIDIOC_DBG_G_REGISTER, &get_reg) < 0) fprintf(stderr, "ioctl: VIDIOC_DBG_G_REGISTER " "failed for 0x%llx\n", get_reg.reg); else { const char *name = reg_name(curr_bd, get_reg.reg); printf("Register "); if (name) printf("%s (0x%08llx)", name, get_reg.reg); else printf("0x%08llx", get_reg.reg); printf(" = %llxh (%lldd %sb)\n", get_reg.val, get_reg.val, binary(get_reg.val)); } } } goto list_done; } if (!reg_min_arg.empty()) { reg_min = parse_reg(curr_bd, reg_min_arg); if (reg_max_arg.empty()) reg_max = reg_min + 0xff; else reg_max = parse_reg(curr_bd, reg_max_arg); /* Explicit memory range: just do it */ print_regs(fd, &get_reg, reg_min, reg_max, stride); goto list_done; } p = strchr(chip_info.name, ' '); if (p) *p = '\0'; name = chip_info.name; if (name == "saa7115") { print_regs(fd, &get_reg, 0, 0xff, stride); } else if (name == "saa717x") { // FIXME: use correct reg regions print_regs(fd, &get_reg, 0, 0xff, stride); } else if (name == "saa7127") { print_regs(fd, &get_reg, 0, 0x7f, stride); } else if (name == "ov7670") { print_regs(fd, &get_reg, 0, 0x89, stride); } else if (name == "cx25840") { print_regs(fd, &get_reg, 0, 2, stride); print_regs(fd, &get_reg, 0x100, 0x15f, stride); print_regs(fd, &get_reg, 0x200, 0x23f, stride); print_regs(fd, &get_reg, 0x400, 0x4bf, stride); print_regs(fd, &get_reg, 0x800, 0x9af, stride); } else if (name == "cs5345") { print_regs(fd, &get_reg, 1, 0x10, stride); } else if (name == "cx23416") { print_regs(fd, &get_reg, 0x02000000, 0x020000ff, stride); } else if (name == "cx23418") { print_regs(fd, &get_reg, 0x02c40000, 0x02c409c7, stride); } else if (name == "cafe") { print_regs(fd, &get_reg, 0, 0x43, stride); print_regs(fd, &get_reg, 0x88, 0x8f, stride); print_regs(fd, &get_reg, 0xb4, 0xbb, stride); print_regs(fd, &get_reg, 0x3000, 0x300c, stride); } else { /* unknown chip, dump 0-0xff by default */ print_regs(fd, &get_reg, 0, 0xff, stride); } } list_done: if (options[OptLogStatus]) { static char buf[40960]; int len = -1; if (doioctl(fd, VIDIOC_LOG_STATUS, NULL, "VIDIOC_LOG_STATUS") == 0) { printf("\nStatus Log:\n\n"); #ifdef HAVE_KLOGCTL len = klogctl(3, buf, sizeof(buf) - 1); #endif if (len >= 0) { bool found_status = false; char *p = buf; char *q; buf[len] = 0; while ((q = strstr(p, "START STATUS"))) { found_status = true; p = q + 1; } if (found_status) { while (p > buf && *p != '<') p--; q = p; while ((q = strstr(q, "<6>"))) { memcpy(q, " ", 3); } printf("%s", p); } } } } if (options[OptListSymbols]) { if (curr_bd == NULL) { printf("No symbols found for driver %s\n", vcap.driver); } else { printf("Symbols for driver %s:\n", curr_bd->name); for (int i = 0; i < curr_bd->regs_size; i++) printf("0x%08x: %s\n", curr_bd->regs[i].reg, curr_bd->regs[i].name); for (int i = 0; i < curr_bd->alt_regs_size; i++) printf("0x%08x: %s\n", curr_bd->alt_regs[i].reg, curr_bd->alt_regs[i].name); } } close(fd); exit(0); }
static void parse_dv_bt_timings(char *optarg, struct v4l2_dv_timings *dv_timings, bool &query, int &enumerate) { char *value; char *subs = optarg; struct v4l2_bt_timings *bt = &dv_timings->bt; dv_timings->type = V4L2_DV_BT_656_1120; if (!strcmp(subs, "query")) { query = true; return; } while (*subs != '\0') { static const char *const subopts[] = { "width", "height", "interlaced", "polarities", "pixelclock", "hfp", "hs", "hbp", "vfp", "vs", "vbp", "il_vfp", "il_vs", "il_vbp", "index", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: bt->width = atoi(value); break; case 1: bt->height = strtol(value, 0L, 0); break; case 2: bt->interlaced = strtol(value, 0L, 0); break; case 3: bt->polarities = strtol(value, 0L, 0); break; case 4: bt->pixelclock = strtol(value, 0L, 0); break; case 5: bt->hfrontporch = strtol(value, 0L, 0); break; case 6: bt->hsync = strtol(value, 0L, 0); break; case 7: bt->hbackporch = strtol(value, 0L, 0); break; case 8: bt->vfrontporch = strtol(value, 0L, 0); break; case 9: bt->vsync = strtol(value, 0L, 0); break; case 10: bt->vbackporch = strtol(value, 0L, 0); break; case 11: bt->il_vfrontporch = strtol(value, 0L, 0); break; case 12: bt->il_vsync = strtol(value, 0L, 0); break; case 13: bt->il_vbackporch = strtol(value, 0L, 0); break; case 14: enumerate = strtol(value, 0L, 0); break; default: stds_usage(); exit(1); } } }
void overlay_cmd(int ch, char *optarg) { unsigned int *set_overlay_fmt_ptr = NULL; struct v4l2_format *overlay_fmt_ptr = NULL; char *value, *subs; switch (ch) { case OptSetOverlayFormat: case OptTryOverlayFormat: case OptSetOutputOverlayFormat: case OptTryOutputOverlayFormat: switch (ch) { case OptSetOverlayFormat: case OptTryOverlayFormat: set_overlay_fmt_ptr = &set_overlay_fmt; overlay_fmt_ptr = &overlay_fmt; break; case OptSetOutputOverlayFormat: case OptTryOutputOverlayFormat: set_overlay_fmt_ptr = &set_overlay_fmt_out; overlay_fmt_ptr = &overlay_fmt_out; break; } subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "chromakey", "global_alpha", "left", "top", "width", "height", "field", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: overlay_fmt_ptr->fmt.win.chromakey = strtol(value, 0L, 0); *set_overlay_fmt_ptr |= FmtChromaKey; break; case 1: overlay_fmt_ptr->fmt.win.global_alpha = strtol(value, 0L, 0); *set_overlay_fmt_ptr |= FmtGlobalAlpha; break; case 2: overlay_fmt_ptr->fmt.win.w.left = strtol(value, 0L, 0); *set_overlay_fmt_ptr |= FmtLeft; break; case 3: overlay_fmt_ptr->fmt.win.w.top = strtol(value, 0L, 0); *set_overlay_fmt_ptr |= FmtTop; break; case 4: overlay_fmt_ptr->fmt.win.w.width = strtol(value, 0L, 0); *set_overlay_fmt_ptr |= FmtWidth; break; case 5: overlay_fmt_ptr->fmt.win.w.height = strtol(value, 0L, 0); *set_overlay_fmt_ptr |= FmtHeight; break; case 6: overlay_fmt_ptr->fmt.win.field = parse_field(value); *set_overlay_fmt_ptr |= FmtField; break; default: overlay_usage(); break; } } break; case OptSetFBuf: subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "chromakey", "global_alpha", "local_alpha", "local_inv_alpha", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: fbuf.flags |= strtol(value, 0L, 0) ? V4L2_FBUF_FLAG_CHROMAKEY : 0; set_fbuf |= V4L2_FBUF_FLAG_CHROMAKEY; break; case 1: fbuf.flags |= strtol(value, 0L, 0) ? V4L2_FBUF_FLAG_GLOBAL_ALPHA : 0; set_fbuf |= V4L2_FBUF_FLAG_GLOBAL_ALPHA; break; case 2: fbuf.flags |= strtol(value, 0L, 0) ? V4L2_FBUF_FLAG_LOCAL_ALPHA : 0; set_fbuf |= V4L2_FBUF_FLAG_LOCAL_ALPHA; break; case 3: fbuf.flags |= strtol(value, 0L, 0) ? V4L2_FBUF_FLAG_LOCAL_INV_ALPHA : 0; set_fbuf |= V4L2_FBUF_FLAG_LOCAL_INV_ALPHA; break; default: overlay_usage(); break; } } break; case OptOverlay: overlay = strtol(optarg, 0L, 0); break; } }
void misc_cmd(int ch, char *optarg) { char *value, *subs; switch (ch) { case OptSetParm: fps = strtod(optarg, NULL); break; case OptSetOutputParm: output_fps = strtod(optarg, NULL); break; case OptSetJpegComp: subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "app0", "app1", "app2", "app3", "app4", "app5", "app6", "app7", "app8", "app9", "appa", "appb", "appc", "appd", "appe", "appf", "quality", "markers", "comment", NULL }; size_t len; int opt = parse_subopt(&subs, subopts, &value); switch (opt) { case 16: jpegcomp.quality = strtol(value, 0L, 0); break; case 17: if (strstr(value, "dht")) jpegcomp.jpeg_markers |= V4L2_JPEG_MARKER_DHT; if (strstr(value, "dqt")) jpegcomp.jpeg_markers |= V4L2_JPEG_MARKER_DQT; if (strstr(value, "dri")) jpegcomp.jpeg_markers |= V4L2_JPEG_MARKER_DRI; break; case 18: len = strlen(value); if (len > sizeof(jpegcomp.COM_data) - 1) len = sizeof(jpegcomp.COM_data) - 1; jpegcomp.COM_len = len; memcpy(jpegcomp.COM_data, value, len); jpegcomp.COM_data[len] = '\0'; break; default: if (opt < 0 || opt > 15) { misc_usage(); exit(1); } len = strlen(value); if (len > sizeof(jpegcomp.APP_data) - 1) len = sizeof(jpegcomp.APP_data) - 1; if (jpegcomp.APP_len) { fprintf(stderr, "Only one APP segment can be set\n"); break; } jpegcomp.APP_len = len; memcpy(jpegcomp.APP_data, value, len); jpegcomp.APP_data[len] = '\0'; jpegcomp.APPn = opt; break; } } break; case OptEncoderCmd: case OptTryEncoderCmd: subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "cmd", "flags", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: enc_cmd.cmd = parse_cmd(value); break; case 1: enc_cmd.flags = parse_encflags(value); break; default: misc_usage(); exit(1); } } break; case OptDecoderCmd: case OptTryDecoderCmd: subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "cmd", "flags", "stop_pts", "start_speed", "start_format", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: dec_cmd.cmd = parse_cmd(value); break; case 1: dec_cmd.flags = parse_decflags(value); break; case 2: dec_cmd.stop.pts = strtoull(value, 0, 0); break; case 3: dec_cmd.start.speed = strtol(value, 0, 0); break; case 4: if (!strcmp(value, "gop")) dec_cmd.start.format = V4L2_DEC_START_FMT_GOP; else if (!strcmp(value, "none")) dec_cmd.start.format = V4L2_DEC_START_FMT_NONE; break; default: misc_usage(); exit(1); } } break; } }
void edid_cmd(int ch, char *optarg) { char *value, *subs; switch (ch) { case OptSetEdid: memset(&sedid, 0, sizeof(sedid)); file_in = NULL; if (!optarg) break; subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "pad", "edid", "file", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: sedid.pad = strtoul(value, 0, 0); break; case 1: if (!strcmp(value, "dvid")) { sedid.edid = dvid_edid; sedid.blocks = sizeof(dvid_edid) / 128; } else if (!strcmp(value, "vga")) { sedid.edid = vga_edid; sedid.blocks = sizeof(vga_edid) / 128; } else if (!strcmp(value, "hdmi")) { sedid.edid = hdmi_edid; sedid.blocks = sizeof(hdmi_edid) / 128; } else { edid_usage(); exit(1); } if (file_in) { fprintf(stderr, "The edid and file options can't be used together.\n"); exit(1); } break; case 2: if (value) { file_in = value; if (sedid.edid) { fprintf(stderr, "The edid and file options can't be used together.\n"); exit(1); } } break; default: edid_usage(); exit(1); } } break; case OptClearEdid: if (optarg) clear_pad = strtoul(optarg, 0, 0); break; case OptGetEdid: memset(&gedid, 0, sizeof(gedid)); gedid.blocks = 256; /* default all blocks */ gformat = HEX; /* default hex output */ file_out = NULL; if (!optarg) break; subs = optarg; while (*subs != '\0') { static const char *const subopts[] = { "pad", "startblock", "blocks", "format", "file", NULL }; switch (parse_subopt(&subs, subopts, &value)) { case 0: gedid.pad = strtoul(value, 0, 0); break; case 1: gedid.start_block = strtoul(value, 0, 0); if (gedid.start_block > 255) { fprintf(stderr, "startblock %d too large, max 255\n", gedid.start_block); exit(1); } break; case 2: gedid.blocks = strtoul(value, 0, 0); break; case 3: if (!strcmp(value, "hex")) { gformat = HEX; } else if (!strcmp(value, "raw")) { gformat = RAW; } else if (!strcmp(value, "carray")) { gformat = CARRAY; } else { edid_usage(); exit(1); } break; case 4: if (value) file_out = value; break; default: edid_usage(); exit(1); } } if (gedid.start_block + gedid.blocks > 256) gedid.blocks = 256 - gedid.start_block; } }