feedbackhandler.cpp

来自「一个非常好用的MP3音乐播放控件」· C++ 代码 · 共 750 行 · 第 1/2 页

    m_BitmapInfo.bmiHeader.biBitCount      = 32; 
    m_BitmapInfo.bmiHeader.biCompression   = BI_RGB; 
    m_BitmapInfo.bmiHeader.biSizeImage     = 0; 
    m_BitmapInfo.bmiHeader.biXPelsPerMeter = 0; 
    m_BitmapInfo.bmiHeader.biYPelsPerMeter = 0; 
    m_BitmapInfo.bmiHeader.biClrUsed       = 0; 
    m_BitmapInfo.bmiHeader.biClrImportant  = 0; 

    // clear pixel bits 
    ClearPixels();
}

/*----------------------------------------------------------------------
|       PaintBox::~PaintBox
+---------------------------------------------------------------------*/
PaintBox::~PaintBox()
{
    delete[] m_Bits;
}

/*----------------------------------------------------------------------
|       PaintBox::ClearPixels
+---------------------------------------------------------------------*/
void
PaintBox::ClearPixels() 
{
    memset((void *)m_Bits, 0, m_Width*m_Height*sizeof(DWORD));
}

/*----------------------------------------------------------------------
|       PaintBox::DrawRectangle
+---------------------------------------------------------------------*/
void
PaintBox::DrawRectangle(unsigned int x, 
                        unsigned int y, 
                        unsigned int width, 
                        unsigned int height,
                        DWORD color)
{
    if (x+width >= m_Width ||
        y+height >= m_Height) {
        return;
    }

    DWORD *line = &m_Bits[x+m_Width*y];
    for (unsigned int i=0; i<height; i++) {
        DWORD *pixel = line;
        for (unsigned int j=0; j<width; j++) {
            *pixel++ = color;
        }
        line +=m_Width;
    }
}

/*----------------------------------------------------------------------
|       PaintBox::DrawBar
+---------------------------------------------------------------------*/
void
PaintBox::DrawBar(unsigned int x, 
                  unsigned int y, 
				  unsigned int bar_value,
                  unsigned int bar_width,
				  unsigned int peak_value,
				  unsigned int peak_height)
{
    // draw the bands
	DrawRectangle(x, y,            bar_width, bar_value,   0x008080FF);
	DrawRectangle(x, y+peak_value, bar_width, peak_height, 0x00FF8080);
}

/*----------------------------------------------------------------------
|       PaintBox::Paint
+---------------------------------------------------------------------*/
void
PaintBox::Paint(int x, int y)
{
    if (m_DC) {
        SetDIBitsToDevice(m_DC, 0, 0, m_Width, m_Height, 
                          0, 0, 0, m_Height, 
                          m_Bits, &m_BitmapInfo, DIB_RGB_COLORS);
    }
}

/*----------------------------------------------------------------------
|       Band::PaintBar
+---------------------------------------------------------------------*/
void
Band::Paint(PaintBox &box, int x, int y)
{
	box.DrawBar(x, y, m_Value, m_Width, 
                m_Peak, m_PeakBarThickness);
}

/*----------------------------------------------------------------------
|       Band::SetValue
+---------------------------------------------------------------------*/
void
Band::SetValue(unsigned int value)
{
    // clip value to range
    if (value > m_Range) value = m_Range;

	m_Value = (value+m_Value)/2;
	if (m_Value >= m_Peak) {
		m_Peak = m_Value;
        m_Decay = 0;
	} else {
		if (m_Peak > m_Decay) {
			m_Peak -= m_Decay/4;
            m_Decay ++;
		} else {
			m_Peak = 0;
		}
	}
}

/*----------------------------------------------------------------------
|       BandDisplay::BandDisplay
+---------------------------------------------------------------------*/
BandDisplay::BandDisplay(PaintBox &box,
                         unsigned int nb_bands, 
                         unsigned int band_width,
                         unsigned int band_spacing,
                         unsigned int band_range) :
                         m_PaintBox(box),
                         m_Bands(new Band[nb_bands]),
                         m_NbBands(nb_bands),
                         m_BandWidth(band_width),
                         m_BandSpacing(band_spacing)
{
    // set the band parameters
    for (unsigned int i=0; i<nb_bands; i++) {
        m_Bands[i].SetWidth(band_width);
        m_Bands[i].SetRange(band_range);
    }
}

/*----------------------------------------------------------------------
|       BandDisplay::~BandDisplay
+---------------------------------------------------------------------*/
BandDisplay::~BandDisplay()
{
	delete[] m_Bands;
}

/*----------------------------------------------------------------------
|       BandDisplay::Paint
+---------------------------------------------------------------------*/
void
BandDisplay::Paint(int x, int y)
{
    // clear drawing area 
    m_PaintBox.ClearPixels();

    // draw each bar
	for (unsigned int i=0; i<m_NbBands; i++) {
		m_Bands[i].Paint(m_PaintBox, i*(m_BandWidth+m_BandSpacing), 0);
	}

    // refresh display
    m_PaintBox.Paint(x, y);
}

/*----------------------------------------------------------------------
|       BandDisplay::SetBandValue
+---------------------------------------------------------------------*/
void
BandDisplay::SetBandValue(unsigned int i, unsigned int value)
{
	if (i<m_NbBands) {
		m_Bands[i].SetValue(value);
	}
}

/*----------------------------------------------------------------------
|       LineDisplay::LineDisplay
+---------------------------------------------------------------------*/
LineDisplay::LineDisplay(PaintBox &box,
                         unsigned int width, 
                         unsigned int height) :
                         m_PaintBox(box), 
                         m_Points(new unsigned int[width]),
                         m_Width(width), 
                         m_Height(height)
{
}

/*----------------------------------------------------------------------
|       LineDisplay::~LineDisplay
+---------------------------------------------------------------------*/
LineDisplay::~LineDisplay()
{
	delete[] m_Points;
}

/*----------------------------------------------------------------------
|       LineDisplay::SetPoint
+---------------------------------------------------------------------*/
void
LineDisplay::SetPoint(unsigned int x, unsigned int y)
{
    m_PaintBox.SetPixel(x, m_Points[x], 0);
    m_Points[x] = y;
    m_PaintBox.SetPixel(x, y, 0x00FFFFFF);
}

/*----------------------------------------------------------------------
|       LineDisplay::Paint
+---------------------------------------------------------------------*/
void
LineDisplay::Paint(int x, int y)
{
    m_PaintBox.Paint(x, y);
}

/*----------------------------------------------------------------------
|       feedback_module_probe
+---------------------------------------------------------------------*/
static int
feedback_module_probe(const char *name)
{
    // accept then name "sample-xxxxx"
    if (strncmp(name, "sample-spectrum", 15) == 0 ||
        strncmp(name, "sample-vu", 9) == 0 ||
        strncmp(name, "sample-oscilloscope", 19) == 0) {
        return XA_SUCCESS;
    } else {
        return XA_FAILURE;
    }
}

/*----------------------------------------------------------------------
|       feedback_module_query
+---------------------------------------------------------------------*/
static int
feedback_module_query(XA_FeedbackHandlerModuleQuery *query, 
                      unsigned long query_mask)
{
    if (query_mask & XA_FEEDBACK_HANDLER_QUERY_MODULE_NAME) {
        strcpy(query->name, "Sample Feedback Module");
        strcpy(query->description, "Version " FEEDBACK_MODULE_VERSION);
    }

    if (query_mask & XA_FEEDBACK_HANDLER_QUERY_NB_HANDLERS) {
        query->index = 1;
    }
    
    // if we're asked for the module name, stop here
    if (query_mask & XA_FEEDBACK_HANDLER_QUERY_MODULE_NAME) return XA_SUCCESS;

    if (query_mask & XA_FEEDBACK_HANDLER_QUERY_HANDLER_NAME) {
        switch(query->index) {
          default: return XA_ERROR_INVALID_PARAMETERS;
          case 0:
            strcpy(query->name, "sample-spectrum");
            strcpy(query->description, "sample feedback handler");
            query->flags = 0;
            break;
          case 1:
            strcpy(query->name, "sample-vu");
            strcpy(query->description, "sample feedback handler");
            query->flags = 0;
            break;
          case 2:
            strcpy(query->name, "sample-oscilloscope");
            strcpy(query->description, "sample feedback handler");
            query->flags = 0;
            break;
        }
    }
    
    return XA_SUCCESS;
}

/*----------------------------------------------------------------------
|       feedback_new
+---------------------------------------------------------------------*/
static int 
feedback_new(XA_FeedbackHandlerInstance       **ret_handler, 
             const char                        *name,
             XA_FeedbackHandlerModuleClassInfo *class_info,
             XA_FeedbackHandlerCallbackClient  *client,
             XA_FeedbackHandlerCallbackTable   *callbacks)
{
    // get window handle from application
    HWND window = NULL;
    int  status;
    status = callbacks->get_environment_integer(client, 
                                                "CLIENT.FEEDBACK-WINDOW", 
                                                (long *)&window);
    if (status) return status;

    // allocate a new feedback object
    Handler *handler;
    if (strcmp(name, "sample-spectrum") == 0) {
        handler = new SpectrumHandler(window, FEEDBACK_DISPLAY_WIDTH, FEEDBACK_DISPLAY_HEIGHT);
    } else if (strcmp(name, "sample-vu") == 0) {
        handler = new VUHandler(window, FEEDBACK_DISPLAY_WIDTH, FEEDBACK_DISPLAY_HEIGHT);
    } else if (strcmp(name, "sample-oscilloscope") == 0) {
        handler = new OscilloscopeHandler(window, FEEDBACK_DISPLAY_WIDTH, FEEDBACK_DISPLAY_HEIGHT);
    } else {
        *ret_handler = NULL;
        return XA_FAILURE;
    }

    *ret_handler = (XA_FeedbackHandlerInstance *)handler;

    return XA_SUCCESS;
}

/*----------------------------------------------------------------------
|       feedback_delete
+---------------------------------------------------------------------*/
static int
feedback_delete(XA_FeedbackHandlerInstance *instance)
{
    Handler *handler = (Handler *)instance;

    // delete the object
    delete handler;

    return XA_SUCCESS;
}

/*----------------------------------------------------------------------
|       feedback_start
+---------------------------------------------------------------------*/
static int
feedback_start(XA_FeedbackHandlerInstance *handler)
{
    return XA_SUCCESS;
}

/*----------------------------------------------------------------------
|       feedback_stop
+---------------------------------------------------------------------*/
static int
feedback_stop(XA_FeedbackHandlerInstance *handler)
{
    return XA_SUCCESS;
}

/*----------------------------------------------------------------------
|       feedback_event
+---------------------------------------------------------------------*/
static int
feedback_event(XA_FeedbackHandlerInstance *instance, XA_AudioEvent *event)
{
    Handler *handler = (Handler *)instance;

    // process the event
    handler->ProcessEvent(event);

    return XA_SUCCESS;
}

/*----------------------------------------------------------------------
|       feedback_module_register
+---------------------------------------------------------------------*/
int XA_EXPORT
feedback_module_register(XA_FeedbackHandlerModule *module)
{
    module->api_version_id                = XA_ASYNC_API_VERSION;
    module->feedback_handler_module_probe = feedback_module_probe;
    module->feedback_handler_module_query = feedback_module_query;
    module->feedback_handler_new          = feedback_new;
    module->feedback_handler_delete       = feedback_delete;
    module->feedback_handler_start        = feedback_start;
    module->feedback_handler_stop         = feedback_stop;
    module->feedback_handler_send_message = NULL;
    module->feedback_handler_event        = feedback_event;

    return XA_SUCCESS;
}