audio_codec.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa AKIYAMA
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_PLAYER_AUDIO_CODEC_H
#define RCSC_PLAYER_AUDIO_CODEC_H
 
#include <rcsc/geom/vector_2d.h>
 
#include <unordered_map>
#include <vector>
#include <string>
#include <cmath>
#include <cstdint>
 
namespace rcsc {
 
class AudioCodec {
public:
    typedef std::unordered_map< char, int > CharToIntCont; 
    typedef std::vector< char > IntToCharCont; 
 
    static const double ERROR_VALUE;
 
private:
 
    std::string M_char_set;
 
    CharToIntCont M_char_to_int_map;
 
    IntToCharCont M_int_to_char_map;
 
    AudioCodec();
 
public:
 
    static AudioCodec & instance();
 
    static const AudioCodec & i();
 
    void createMap( const int shift );
 
private:
 
    std::int32_t posToBit18( const Vector2D & pos ) const;
 
    void bit18ToPos( const std::int32_t & val,
                     Vector2D * pos ) const;
 
    std::int32_t posToBit19( const Vector2D & pos ) const;
 
    void bit19ToPos( const std::int32_t & val,
                     Vector2D * pos ) const;
 
    std::int32_t posVelToBit31( const Vector2D & pos,
                                  const Vector2D & vel ) const;
 
    void bit31ToPosVel( const std::int32_t & val,
                        Vector2D * pos,
                        Vector2D * vel ) const;
 
public:
 
    const CharToIntCont & charToIntMap() const
      {
          return M_char_to_int_map;
      }
 
    const IntToCharCont & intToCharMap() const
      {
          return M_int_to_char_map;
      }
 
    bool encodeInt64ToStr( const std::int64_t & ival,
                           const int len,
                           std::string & to ) const;
 
    bool decodeStrToInt64( const std::string & from,
                           std::int64_t * to ) const;
 
 
    char encodePercentageToChar( const double & value ) const;
 
    double decodeCharToPercentage( const char ch ) const;
 
    bool encodePosVelToStr5( const Vector2D & pos,
                             const Vector2D & vel,
                             std::string & to ) const;
 
    bool decodeStr5ToPosVel( const std::string & from,
                             Vector2D * pos,
                             Vector2D * vel ) const;
 
    bool encodePosToStr3( const Vector2D & pos,
                          std::string & to ) const;
 
    bool decodeStr3ToPos( const std::string & from,
                          Vector2D * pos ) const;
 
 
    bool encodeUnumPosToStr4( const int unum,
                              const Vector2D & pos,
                              std::string & to ) const;
 
    bool decodeStr4ToUnumPos( const std::string & from,
                              int * unum,
                              Vector2D * pos ) const;
 
    std::string encodeCoordToStr2( const double & xy,
                                   const double & norm_factor ) const;
 
    double decodeStr2ToCoord( const char ch1,
                              const char ch2,
                              const double & norm_factor ) const;
 
    std::string encodePosToStr4( const Vector2D & pos ) const;
 
    Vector2D decodeStr4ToPos( const std::string & from ) const;
 
    char encodeSpeedToChar( const double & xy ) const;
 
    double decodeCharToSpeed( const char ch ) const;
 
    static
    char unum2hex( const int unum );
 
 
    static
    int hex2unum( const char hex );
};
 
}
 
#endif