---

/home/vlg/develop/gwavmerger/raven/WavInfo.cpp

Go to the documentation of this file.

// -*- c++ -*-
// Generated by assa-genesis
//------------------------------------------------------------------------------
// $Id: WavInfo.cpp,v 1.4 2003/02/07 05:15:08 vlg Exp $
//------------------------------------------------------------------------------
//                            WavInfo.cpp
//------------------------------------------------------------------------------
//
// Author : Vladislav Grinchenko
// Date   : Sun Dec 16 18:27:08 2001
//
// History:
//
// When        Who  What
// ----------  ---  --------------------------
// 12/16/01    VLG  Created
//
//------------------------------------------------------------------------------

#include <iostream>
#include <audiofile.h>

#include "WavInfo-main.h"
#include "WavInfo.h"

using ASSA::APP;
using ASSA::ERROR;

// Static declarations mandated by Singleton class

WavInfo* ASSA::Singleton<WavInfo>::m_instance;
ASSA::Destroyer<WavInfo> ASSA::Singleton<WavInfo>::m_destroyer;

WavInfo::WavInfo ()
    : m_pos_arg_count (0),
      m_exit_value (0),
      m_silent (false)
{
    // ---Configuration---
    rm_opt ('f', "config-file"  );
    rm_opt ('n', "instance"     );
    rm_opt ('p', "port"         );

    // ---Process bookkeeping---
    rm_opt ('b', "daemon"       );
    rm_opt ('l', "pidfile"      );
    rm_opt ('L', "ommit-pidfile");

    add_flag_opt (0, "silent", &m_silent);

    m_log_file = "/dev/null";
    m_debug_mask = 0;
}

void
WavInfo::pos_arg (const char* arg_)
{
    trace("WavInfo::pos_arg");

    switch(m_pos_arg_count) {
    case 0:
        m_wav_file = arg_;
        break;

    default:
        std::cerr << "Error: unexpected argument " << arg_ << '\n'
                  << "Try `WavInfo --help` for more information.\n";
        Assert_exit (false);
    }
    m_pos_arg_count++;
}

void
WavInfo::initServer ()
{
    trace("WavInfo::initServer");
    ASSA::Log::disable_timestamp ();

    if (m_pos_arg_count != 1) {
        std::cerr << "WavPause: missing wav file\n"
                  << "Try `WavPause --help` for more information.\n";
        set_exit_value (1);
        return;
    }

    if (m_silent) {
        close (1);
        close (2);
        pid_t nullfd = 0;
        nullfd = open("/dev/null", O_WRONLY | O_CREAT, 0666);
        (void) dup2 (nullfd, 1);
        (void) dup2 (nullfd, 2);
        (void) close (nullfd);
    }
    DL((APP,"Service has been initialized\n"));
}

void
WavInfo::processServer ()
{
    trace("WavInfo::processServer");
    
    if (stopServer ()) {
        return;
    }

    AFfilehandle in_file;
    in_file = afOpenFile (m_wav_file.c_str (), "r", NULL);

    if (in_file == NULL) {
        EL((ERROR,"File \"%s\" open error\n", m_wav_file.c_str ()));
        set_exit_value (1);
        return;
    }

    char* formatstring;
    char* labelstring;
    int in_file_format = -1;
    int version;

    in_file_format = afGetFileFormat (in_file, &version);

    formatstring = 
        (char *) afQueryPointer (AF_QUERYTYPE_FILEFMT,
                                 AF_QUERY_DESC,
                                 in_file_format,
                                 0, 0);
    labelstring = 
        (char *) afQueryPointer (AF_QUERYTYPE_FILEFMT,
                                 AF_QUERY_LABEL,
                                 in_file_format,
                                 0, 0);

    if (formatstring == NULL || labelstring == NULL) {
        EL((ERROR,"Corrupted header in \"%s\"\n", m_wav_file.c_str ()));
        set_exit_value (1);
        return;
    }

    std::cout << '\n'
              << "File Name:     " << m_wav_file << '\n'
              << "File Format:   " << formatstring << " (" 
              << labelstring << ")\n";

    int sampleFormat;
    int sampleWidth;
    int byteOrder;
    int compressionType;

    afGetSampleFormat(in_file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
    byteOrder = afGetByteOrder(in_file, AF_DEFAULT_TRACK);

    std::cout << "Data Format:   ";

    compressionType = afGetCompression (in_file, AF_DEFAULT_TRACK);

    if (compressionType == AF_COMPRESSION_NONE) {
        switch (sampleFormat) {
        case AF_SAMPFMT_TWOSCOMP:
            std::cout << sampleWidth << "-bit integer (2's complement, " 
                      << (byteOrder == AF_BYTEORDER_BIGENDIAN ? 
                          "big endian" : "little endian")
                      << ")";
            break;

        case AF_SAMPFMT_UNSIGNED:
            std::cout << sampleWidth << "-bit integer (unsigned, " 
                      << (byteOrder == AF_BYTEORDER_BIGENDIAN ?
                          "big endian" : "little endian")
                      << ")";
            break;

        case AF_SAMPFMT_FLOAT:
            std::cout << "single-precision (32-bit) floating point, "
                      << (byteOrder == AF_BYTEORDER_BIGENDIAN ?
                          "big endian" : "little endian");
            break;

        case AF_SAMPFMT_DOUBLE:
            std::cout << "double-precision (64-bit) floating point, "
                      << (byteOrder == AF_BYTEORDER_BIGENDIAN ?
                          "big endian" : "little endian");
            break;

        default:
            std::cout << "unknown";
            break;
        }
    }
    else {
        char* compressionName;
        compressionName = (char*) afQueryPointer (AF_QUERYTYPE_COMPRESSION,
                                                  AF_QUERY_NAME, 
                                                  compressionType,
                                                  0, 0);
        if (compressionName == NULL) {
            std::cout << "unknown compression";
        }
        else {
            std::cout << compressionName << " compression";
        }
    }
    std::cout << "\n";

    std::cout << "Audio Data:    "
              << afGetTrackBytes(in_file, AF_DEFAULT_TRACK)
              << " bytes begins at offset "
              << afGetDataOffset(in_file, AF_DEFAULT_TRACK)
              << '(' << std::hex << afGetDataOffset(in_file, AF_DEFAULT_TRACK)
              <<  " hex)\n";

    AFframecount total_frames = afGetFrameCount (in_file, AF_DEFAULT_TRACK);
    int frame_size = (int)afGetVirtualFrameSize (in_file, AF_DEFAULT_TRACK, 1);
    
    int channel_count = afGetChannels(in_file, AF_DEFAULT_TRACK);

    std::cout << "               " << channel_count << " channel" 
              << (afGetChannels(in_file, AF_DEFAULT_TRACK) > 1 ? "s, " : ", ")
              << std::dec << total_frames << " frames\n";

    double sample_rate = afGetRate(in_file, AF_DEFAULT_TRACK);
    std::cout << "Sampling Rate: " << sample_rate << " Hz\n";

    double duration = afGetFrameCount(in_file, AF_DEFAULT_TRACK) / 
        afGetRate(in_file, AF_DEFAULT_TRACK);

    std::cout << "Duration:      " << duration  << " seconds\n"
              << '\n';

    afCloseFile (in_file);
    m_reactor.stopReactor ();
    DL((APP,"Service stopped!\n"));
}

---