vaseboot/VasEBoot-core/commands/i386/pc/play.c

/* play.c - command to play a tune  */
/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2005,2007,2009  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

/* Lots of this file is borrowed from GNU/Hurd generic-speaker driver.  */

#include <VasEBoot/dl.h>
#include <VasEBoot/file.h>
#include <VasEBoot/disk.h>
#include <VasEBoot/term.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/cpu/io.h>
#include <VasEBoot/command.h>
#include <VasEBoot/i18n.h>
#include <VasEBoot/time.h>
#include <VasEBoot/speaker.h>

VAS_EBOOT_MOD_LICENSE ("GPLv3+");

#define BASE_TEMPO (60 * 1000)


#define T_REST			((VasEBoot_uint16_t) 0)
#define T_FINE			((VasEBoot_uint16_t) -1)

struct note
{
  VasEBoot_uint16_t pitch;
  VasEBoot_uint16_t duration;
};

/* Returns whether playing should continue.  */
static int
play (unsigned tempo, struct note *note)
{
  VasEBoot_uint64_t to;

  if (note->pitch == T_FINE || VasEBoot_getkey_noblock () != VAS_EBOOT_TERM_NO_KEY)
    return 1;

  VasEBoot_dprintf ("play", "pitch = %d, duration = %d\n", note->pitch,
                note->duration);

  switch (note->pitch)
    {
      case T_REST:
        VasEBoot_speaker_beep_off ();
        break;

      default:
        VasEBoot_speaker_beep_on (note->pitch);
        break;
    }

  to = VasEBoot_get_time_ms () + BASE_TEMPO * note->duration / tempo;
  while ((VasEBoot_get_time_ms () <= to)
	 && (VasEBoot_getkey_noblock () == VAS_EBOOT_TERM_NO_KEY));

  return 0;
}

static VasEBoot_err_t
VasEBoot_cmd_play (VasEBoot_command_t cmd __attribute__ ((unused)),
	       int argc, char **args)
{

  if (argc < 1)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
		       /* TRANSLATORS: It's musical notes, not the notes
			  you take. Play command expects arguments which can
			  be either a filename or tempo+notes.
			  This error happens if none is specified.  */
		       N_("filename or tempo and notes expected"));

  if (argc == 1)
    {
      struct note buf;
      VasEBoot_uint32_t tempo;
      VasEBoot_file_t file;

      file = VasEBoot_file_open (args[0], VAS_EBOOT_FILE_TYPE_AUDIO);

      if (! file)
        return VasEBoot_errno;

      if (VasEBoot_file_read (file, &tempo, sizeof (tempo)) != sizeof (tempo))
        {
          VasEBoot_file_close (file);
	  if (!VasEBoot_errno)
	    VasEBoot_error (VAS_EBOOT_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
			args[0]);
          return VasEBoot_errno;
        }

      if (!tempo)
        {
          VasEBoot_file_close (file);
	  VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("Invalid tempo in %s"),
		      args[0]);
          return VasEBoot_errno;
        }

      tempo = VasEBoot_le_to_cpu32 (tempo);
      VasEBoot_dprintf ("play","tempo = %d\n", tempo);

      while (VasEBoot_file_read (file, &buf,
                             sizeof (struct note)) == sizeof (struct note))
        {
          buf.pitch = VasEBoot_le_to_cpu16 (buf.pitch);
          buf.duration = VasEBoot_le_to_cpu16 (buf.duration);

          if (play (tempo, &buf))
            break;
        }

      VasEBoot_file_close (file);
    }
  else
    {
      const char *end;
      unsigned tempo;
      struct note note;
      int i;

      tempo = VasEBoot_strtoul (args[0], &end, 0);

      if (!tempo)
        {
	  VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("Invalid tempo in %s"),
		      args[0]);
          return VasEBoot_errno;
        }

      if (*end)
        /* Was not a number either, assume it was supposed to be a file name.  */
        return VasEBoot_error (VAS_EBOOT_ERR_FILE_NOT_FOUND, N_("file `%s' not found"), args[0]);

      VasEBoot_dprintf ("play","tempo = %d\n", tempo);

      for (i = 1; i + 1 < argc; i += 2)
        {
          note.pitch = VasEBoot_strtoul (args[i], &end, 0);
	  if (VasEBoot_errno)
	    break;
          if (*end)
            {
              VasEBoot_error (VAS_EBOOT_ERR_BAD_NUMBER, N_("unrecognized number"));
              break;
            }

          note.duration = VasEBoot_strtoul (args[i + 1], &end, 0);
	  if (VasEBoot_errno)
	    break;
          if (*end)
            {
              VasEBoot_error (VAS_EBOOT_ERR_BAD_NUMBER, N_("unrecognized number"));
              break;
            }

          if (play (tempo, &note))
            break;
        }
    }

  VasEBoot_speaker_beep_off ();

  return 0;
}

static VasEBoot_command_t cmd;

VAS_EBOOT_MOD_INIT(play)
{
  cmd = VasEBoot_register_command ("play", VasEBoot_cmd_play,
			       N_("FILE | TEMPO [PITCH1 DURATION1] [PITCH2 DURATION2] ... "),
			       N_("Play a tune."));
}

VAS_EBOOT_MOD_FINI(play)
{
  VasEBoot_unregister_command (cmd);
}