sm64coopdx/tools/audiofile-0.3.6/libaudiofile/debug.cpp

273 lines
6.4 KiB
C++
Raw Normal View History

2020-05-07 20:21:22 +02:00
/*
Audio File Library
Copyright (C) 1998-2000, Michael Pruett <michael@68k.org>
Copyright (C) 2000, Silicon Graphics, Inc.
This library 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 2.1 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., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301 USA
*/
/*
debug.cpp
This file contains debugging routines for the Audio File
Library.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <assert.h>
#include "audiofile.h"
#include "aupvlist.h"
#include "FileHandle.h"
#include "Setup.h"
#include "Track.h"
#include "afinternal.h"
#include "aupvinternal.h"
#include "byteorder.h"
#include "compression.h"
#include "debug.h"
#include "units.h"
#include "util.h"
void _af_print_pvlist (AUpvlist list)
{
assert(list);
printf("list.valid: %d\n", list->valid);
printf("list.count: %zu\n", list->count);
for (unsigned i=0; i<list->count; i++)
{
printf("item %u valid %d, should be %d\n",
i, list->items[i].valid, _AU_VALID_PVITEM);
switch (list->items[i].type)
{
case AU_PVTYPE_LONG:
printf("item #%u, parameter %d, long: %ld\n",
i, list->items[i].parameter,
list->items[i].value.l);
break;
case AU_PVTYPE_DOUBLE:
printf("item #%u, parameter %d, double: %f\n",
i, list->items[i].parameter,
list->items[i].value.d);
break;
case AU_PVTYPE_PTR:
printf("item #%u, parameter %d, pointer: %p\n",
i, list->items[i].parameter,
list->items[i].value.v);
break;
default:
printf("item #%u, invalid type %d\n", i,
list->items[i].type);
assert(false);
break;
}
}
}
void _af_print_audioformat (AudioFormat *fmt)
{
/* sampleRate, channelCount */
printf("{ %7.2f Hz %d ch ", fmt->sampleRate, fmt->channelCount);
/* sampleFormat, sampleWidth */
switch (fmt->sampleFormat)
{
case AF_SAMPFMT_TWOSCOMP:
printf("%db 2 ", fmt->sampleWidth);
break;
case AF_SAMPFMT_UNSIGNED:
printf("%db u ", fmt->sampleWidth);
break;
case AF_SAMPFMT_FLOAT:
printf("flt ");
break;
case AF_SAMPFMT_DOUBLE:
printf("dbl ");
break;
default:
printf("%dsampfmt? ", fmt->sampleFormat);
}
/* pcm */
printf("(%.30g+-%.30g [%.30g,%.30g]) ",
fmt->pcm.intercept, fmt->pcm.slope,
fmt->pcm.minClip, fmt->pcm.maxClip);
/* byteOrder */
switch (fmt->byteOrder)
{
case AF_BYTEORDER_BIGENDIAN:
printf("big ");
break;
case AF_BYTEORDER_LITTLEENDIAN:
printf("little ");
break;
default:
printf("%dbyteorder? ", fmt->byteOrder);
break;
}
/* compression */
{
const CompressionUnit *unit = _af_compression_unit_from_id(fmt->compressionType);
if (!unit)
printf("%dcompression?", fmt->compressionType);
else if (fmt->compressionType == AF_COMPRESSION_NONE)
printf("pcm");
else
printf("%s", unit->label);
}
printf(" }");
}
void _af_print_tracks (AFfilehandle filehandle)
{
for (int i=0; i<filehandle->m_trackCount; i++)
{
Track *track = &filehandle->m_tracks[i];
printf("track %d\n", i);
printf(" id %d\n", track->id);
printf(" sample format\n");
_af_print_audioformat(&track->f);
printf(" virtual format\n");
_af_print_audioformat(&track->v);
printf(" total file frames: %jd\n",
(intmax_t) track->totalfframes);
printf(" total virtual frames: %jd\n",
(intmax_t) track->totalvframes);
printf(" next file frame: %jd\n",
(intmax_t) track->nextfframe);
printf(" next virtual frame: %jd\n",
(intmax_t) track->nextvframe);
printf(" frames to ignore: %jd\n",
(intmax_t) track->frames2ignore);
printf(" data_size: %jd\n",
(intmax_t) track->data_size);
printf(" fpos_first_frame: %jd\n",
(intmax_t) track->fpos_first_frame);
printf(" fpos_next_frame: %jd\n",
(intmax_t) track->fpos_next_frame);
printf(" fpos_after_data: %jd\n",
(intmax_t) track->fpos_after_data);
printf(" channel matrix:");
_af_print_channel_matrix(track->channelMatrix,
track->f.channelCount, track->v.channelCount);
printf("\n");
printf(" marker count: %d\n", track->markerCount);
}
}
void _af_print_filehandle (AFfilehandle filehandle)
{
printf("file handle: 0x%p\n", filehandle);
if (filehandle->m_valid == _AF_VALID_FILEHANDLE)
printf("valid\n");
else
printf("invalid!\n");
printf(" access: ");
if (filehandle->m_access == _AF_READ_ACCESS)
putchar('r');
else
putchar('w');
printf(" fileFormat: %d\n", filehandle->m_fileFormat);
printf(" instrument count: %d\n", filehandle->m_instrumentCount);
printf(" instruments: 0x%p\n", filehandle->m_instruments);
printf(" miscellaneous count: %d\n", filehandle->m_miscellaneousCount);
printf(" miscellaneous: 0x%p\n", filehandle->m_miscellaneous);
printf(" trackCount: %d\n", filehandle->m_trackCount);
printf(" tracks: 0x%p\n", filehandle->m_tracks);
_af_print_tracks(filehandle);
}
void _af_print_channel_matrix (double *matrix, int fchans, int vchans)
{
int v, f;
if (!matrix)
{
printf("NULL");
return;
}
printf("{");
for (v=0; v < vchans; v++)
{
if (v) printf(" ");
printf("{");
for (f=0; f < fchans; f++)
{
if (f) printf(" ");
printf("%5.2f", *(matrix + v*fchans + f));
}
printf("}");
}
printf("}");
}
void _af_print_frame (AFframecount frameno, double *frame, int nchannels,
char *formatstring, int numberwidth,
double slope, double intercept, double minclip, double maxclip)
{
char linebuf[81];
int wavewidth = 78 - numberwidth*nchannels - 6;
int c;
memset(linebuf, ' ', 80);
linebuf[0] = '|';
linebuf[wavewidth-1] = '|';
linebuf[wavewidth] = 0;
printf("%05jd ", (intmax_t) frameno);
for (c=0; c < nchannels; c++)
{
double pcm = frame[c];
printf(formatstring, pcm);
}
for (c=0; c < nchannels; c++)
{
double pcm = frame[c], volts;
if (maxclip > minclip)
{
if (pcm < minclip) pcm = minclip;
if (pcm > maxclip) pcm = maxclip;
}
volts = (pcm - intercept) / slope;
linebuf[(int)((volts/2 + 0.5)*(wavewidth-3)) + 1] = '0' + c;
}
printf("%s\n", linebuf);
}