hinawa-tascam-fw-console-cli

#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-3.0-or-later
# Copyright (C) 2018 Takashi Sakamoto

from hinawa_utils.misc.cli_kit import CliKit
from hinawa_utils.tscm.tscm_console_unit import TscmConsoleUnit


def handle_clock_source(unit, args):
    ops = ('set', 'get')
    if len(args) > 0 and args[0] in ops:
        op = args[0]
        if op == ops[0] and len(args) == 2:
            if unit.get_property('is-locked'):
                print('Packet is-locked started.')
                return False
            source = args[1]
            unit.set_clock_source(source)
        else:
            print(unit.get_clock_source())
        return True
    print('Arguments for clock-source command:')
    print('  clock-source OP [SRC]')
    print('    OP:     [{0}]'.format('|'.join(ops)))
    print('    SRC:    [{0}]'.format('|'.join(unit.supported_clock_sources)))
    return False


def handle_sampling_rate(unit, args):
    ops = ('set', 'get')
    if len(args) > 0 and args[0] in ops:
        op = args[0]
        if op == ops[0] and len(args) == 2:
            rate = int(args[1])
            unit.set_sampling_rate(rate)
        else:
            print(unit.get_sampling_rate())
        return True
    print('Arguments for sampling-rate command:')
    print('  sampling-rate OP [RATE]')
    print('    OP:     [{0}]'.format('|'.join(ops)))
    rates = [str(r) for r in unit.supported_sampling_rates]
    print('    RATE:   [{0}]'.format('|'.join(rates)))
    return False


def handle_firmware_versions(unit, args):
    info = unit.get_firmware_versions()
    for name, value in info.items():
        print('{0}: {1}'.format(name, value))
    return True


def handle_routing(unit, args, cmd, labels, set_func, get_func):
    ops = ('set', 'get')
    if len(args) > 0 and args[0] in ops:
        op = args[0]
        if op == ops[0] and len(args) == 2 and args[1] in labels:
            src = args[1]
            set_func(src)
            return True
        elif op == 'get':
            print(get_func())
            return True
    print('Arguments for {0} command:'.format(cmd))
    print('  {0} OP [SRC]'.format(cmd))
    print('    OP:     [{0}]'.format('|'.join(ops)))
    print('    SRC:    [{0}]'.format('|'.join(labels)))
    return False


def handle_coax_out_src(unit, args):
    return handle_routing(unit, args, 'coaxial-out-source',
                          unit.get_coax_out_src_labels(),
                          unit.set_coax_out_src,
                          unit.get_coax_out_src)


def handle_opt_out_src(unit, args):
    return handle_routing(unit, args, 'optical-out-source',
                          unit.get_opt_out_src_labels(),
                          unit.set_opt_out_src,
                          unit.get_opt_out_src)


def handle_stream_spdif_in_src(unit, args):
    return handle_routing(unit, args, 'stream-spdif-in-source',
                          unit.get_stream_spdif_in_src_labels(),
                          unit.set_stream_spdif_in_src,
                          unit.get_stream_spdif_in_src)


def handle_input_threshold(unit, args):
    ops = ('set', 'get')

    if len(args) >= 1 and args[0] in ops:
        op = args[0]
        if op == 'set' and len(args) >= 2:
            level = float(args[1])
            unit.set_input_threshold(level)
            return True
        elif op == 'get':
            level = unit.get_input_threshold()
            print('{:.3f}'.format(level))
            return True
    print('Arguments for input-threshold command:')
    print('  input-threshold OP [LEVEL]')
    print('    OP:     [{0}]'.format('|'.join(ops)))
    print('    LEVEL:  [-inf, -90..0]')
    return True


def handle_master_fader(unit, args):
    ops = ('set', 'get')
    modes = ('False', 'True')
    if len(args) > 0 and args[0] in ops:
        op = args[0]
        if op == 'set' and len(args) == 2 and args[1] in modes:
            mode = args[1] == 'True'
            unit.set_master_fader(mode)
        elif op == 'get':
            print(unit.get_master_fader())
        return True
    print('Arguments for master-fader command:')
    print('  master-fader OP [MODE]')
    print('    OP:     [{0}]'.format('|'.join(ops)))
    print('    MODE:   [{0}]'.format('|'.join(modes)))
    return False


def handle_bright_led(unit, args):
    if len(args) > 1:
        pos = int(args[0])
        state = args[1]
        unit.bright_led(pos, state)
        return True
    print('Arguments for bright-led command:')
    print('  bright-led POS STATE')
    print('    POS:    [0-???]')
    print('    STATE:  [{0}]'.format('|'.join(unit.supported_led_status)))
    return False


cmds = {
    'clock-source':         handle_clock_source,
    'sampling-rate':        handle_sampling_rate,
    'firmware-versions':    handle_firmware_versions,
    'coaxial-out-source':   handle_coax_out_src,
    'stream-spdif-in-source': handle_stream_spdif_in_src,

    'master-fader':         handle_master_fader,
    'bright-led':           handle_bright_led,
}

fullpath = CliKit.seek_snd_unit_path()
if fullpath:
    with TscmConsoleUnit(fullpath) as unit:
        if unit.model_name == 'FW-1884':
            cmds['optical-out-source'] = handle_opt_out_src
        CliKit.dispatch_command(unit, cmds)