## リファレンス

### Header <hamigaki/audio/vorbis/comment.hpp>

    namespace hamigaki {
      namespace audio {
        namespace vorbis {
          class comment_iterator;
          std::string comment_value(const std::pair<const char**, const char**>&,
                                    const std::string&);
        }
      }
    }

### Header <hamigaki/audio/aiff_file.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename SeekableSource> class basic_aiff_file_source;
        template<typename SeekableSource>
          basic_aiff_file_source<SeekableSource>
          make_aiff_file_source(const SeekableSource&);
        class aiff_file_source;
        template<typename SeekableSink> class basic_aiff_file_sink;
        template<typename SeekableSink>
          basic_aiff_file_sink<SeekableSink>
          make_aiff_file_sink(const SeekableSink&, const pcm_format&);
        class aiff_file_sink;
      }
    }

### Header <hamigaki/audio/amplify.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename Source> class amplifier;
        template<typename Source> amplifier<Source> amplify(const Source&, float);
      }
    }

### Header <hamigaki/audio/asio.hpp>

    namespace hamigaki {
      namespace audio {
        struct asio_buffer_info;

        class asio_source;
        class asio_sink;
        class asio_device;
      }
    }

### Header <hamigaki/audio/background_player.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename ExceptionStorage = hamigaki::thread::exception_storage>
          class basic_background_player;

        typedef basic_background_player<> background_player;
      }
    }

### Header <hamigaki/audio/direct_sound.hpp>

    namespace hamigaki {
      namespace audio {
        class direct_sound_sink;
        class direct_sound_device;
        class direct_sound_source;
        class direct_sound_capture;
      }
    }

### Header <hamigaki/audio/pcm_device.hpp>

    namespace hamigaki {
      namespace audio {
        class pcm_sink;
        class pcm_source;
      }
    }

### Header <hamigaki/audio/pcm_format.hpp>

    namespace hamigaki {
      namespace audio {
        struct pcm_format;
      }
    }

### Header <hamigaki/audio/sample_format.hpp>

    namespace hamigaki {
      namespace audio {
        enum sample_format_type;
        int sample_bits(sample_format_type);
        std::streamsize sample_size(sample_format_type);
        template<typename T> sample_format_type sample_format_of(const T&);
      }
    }

### Header <hamigaki/audio/sine_wave.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename CharT = float> class basic_sine_wave_source;

        typedef basic_sine_wave_source<> sine_wave_source;
      }
    }

### Header <hamigaki/audio/square_wave.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename CharT = float> class basic_square_wave_source;

        typedef basic_square_wave_source<> square_wave_source;
      }
    }

### Header <hamigaki/audio/virtual_device.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename Device> class virtual_device;
        template<typename Device>
          virtual_device<Device>
          make_virtual_device(const Device&, const pcm_format&);
      }
    }

### Header <hamigaki/audio/vorbis_encoder.hpp>

    namespace hamigaki {
      namespace audio {
        struct vorbis_encode_params;

        template<typename Sink> class basic_vorbis_file_sink;
        template<typename Sink>
          basic_vorbis_file_sink<Sink>
          make_vorbis_file_sink(const Sink&, long, long, float = 0.1f);
        template<typename Sink>
          basic_vorbis_file_sink<Sink>
          make_vorbis_file_sink(const Sink&, long, long,
                                const vorbis_encode_params&);
        class vorbis_file_sink;
      }
    }

### Header <hamigaki/audio/vorbis_file.hpp>

    namespace hamigaki {
      namespace audio {
        struct vorbis_info;

        template<typename Source> class basic_vorbis_file_source;
        template<typename Source>
          basic_vorbis_file_source<Source> make_vorbis_file_source(const Source&);
        class vorbis_file_source;
      }
    }

### Header <hamigaki/audio/wave_file.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename SeekableSource> class basic_wave_file_source;
        template<typename SeekableSource>
          basic_wave_file_source<SeekableSource>
          make_wave_file_source(const SeekableSource&);
        class wave_file_source;
        template<typename SeekableSink> class basic_wave_file_sink;
        template<typename SeekableSink>
          basic_wave_file_sink<SeekableSink>
          make_wave_file_sink(const SeekableSink&, const pcm_format&);
        class wave_file_sink;
      }
    }

### Header <hamigaki/audio/wide_adaptor.hpp>

    namespace hamigaki {
      namespace audio {
        template<typename CharT, typename Device> class wide_adaptor;
        template<typename CharT, typename Device>
          wide_adaptor<CharT, Device> widen(const Device&);
      }
    }

| 製作著作 © 2006-2008 Takeshi Mouri