samples/BrowserPlugin/jni/audio/AudioPlugin.cpp - platform/development - Git at Google

 /*
  * Copyright 2008, The Android Open Source Project
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *  * Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "AudioPlugin.h"

 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <time.h>
 #include <math.h>
 #include <string.h>

 extern NPNetscapeFuncs*         browser;
 extern ANPLogInterfaceV0        gLogI;
 extern ANPCanvasInterfaceV0     gCanvasI;
 extern ANPPaintInterfaceV0      gPaintI;
 extern ANPAudioTrackInterfaceV0 gSoundI;
 extern ANPTypefaceInterfaceV0   gTypefaceI;


 static void inval(NPP instance) {
     browser->invalidaterect(instance, NULL);
 }

 static uint16_t rnd16(float x, int inset) {
     int ix = (int)roundf(x) + inset;
     if (ix < 0) {
         ix = 0;
     }
     return static_cast<uint16_t>(ix);
 }

 static void inval(NPP instance, const ANPRectF& r, bool doAA) {
     const int inset = doAA ? -1 : 0;

     PluginObject *obj = reinterpret_cast<PluginObject*>(instance->pdata);
     NPRect inval;
     inval.left = rnd16(r.left, inset);
     inval.top = rnd16(r.top, inset);
     inval.right = rnd16(r.right, -inset);
     inval.bottom = rnd16(r.bottom, -inset);
     browser->invalidaterect(instance, &inval);
 }

 static void audioCallback(ANPAudioEvent evt, void* user, ANPAudioBuffer* buffer) {
     switch (evt) {
         case kMoreData_ANPAudioEvent: {
             SoundPlay* play = reinterpret_cast<SoundPlay*>(user);
             size_t amount = fread(buffer->bufferData, 1, buffer->size, play->file);
             buffer->size = amount;
             if (amount == 0) {
                 gSoundI.stop(play->track);
                 fclose(play->file);
                 play->file = NULL;
                 // TODO need to notify our main thread to delete the track now
             }

             if (play->fileSize > 0) {
                 // TODO we need to properly update the progress value
                 play->progress = 1;
                 inval(play->instance);
             }


             break;
         }
         default:
             break;
     }
 }

 ///////////////////////////////////////////////////////////////////////////////

 AudioPlugin::AudioPlugin(NPP inst) : SubPlugin(inst) {

     const char path[] = "/sdcard/sample.raw";

     // open a file stream
     FILE* f = fopen(path, "r");
     gLogI.log(kDebug_ANPLogType, "--- path %s FILE %p", path, f);

     // setup our private audio struct's default values
     m_soundPlay = new SoundPlay;
     m_soundPlay->instance = inst;
     m_soundPlay->progress = 0;
     m_soundPlay->fileSize = 0;
     m_soundPlay->file = f;
     m_soundPlay->track = NULL;

     // create the audio track
     if (f) {
         m_soundPlay->track = gSoundI.newTrack(44100, kPCM16Bit_ANPSampleFormat, 2, audioCallback, m_soundPlay);
         if (!m_soundPlay->track) {
             fclose(f);
             m_soundPlay->file = NULL;
         }
     }

     // get the audio file's size
     int fileDescriptor = open(path, O_RDONLY);
     struct stat fileStatus;

     if(fileDescriptor <= 0) {
         gLogI.log(kError_ANPLogType, "fopen error");
     }
     else if (fstat(fileDescriptor, &fileStatus) != 0) {
         gLogI.log(kDebug_ANPLogType, "File Size: %d", fileStatus.st_size);
         m_soundPlay->fileSize = fileStatus.st_size;
     } else {
         gLogI.log(kError_ANPLogType, "fstat error");
     }

     // configure the UI elements
     m_activeTouch = false;

     memset(&m_trackRect, 0, sizeof(m_trackRect));
     memset(&m_playRect,  0, sizeof(m_playRect));
     memset(&m_pauseRect, 0, sizeof(m_pauseRect));
     memset(&m_stopRect,  0, sizeof(m_stopRect));

     m_paintTrack = gPaintI.newPaint();
     gPaintI.setFlags(m_paintTrack, gPaintI.getFlags(m_paintTrack) | kAntiAlias_ANPPaintFlag);
     gPaintI.setColor(m_paintTrack, 0xFFC0C0C0);

     m_paintRect = gPaintI.newPaint();
     gPaintI.setFlags(m_paintRect, gPaintI.getFlags(m_paintRect) | kAntiAlias_ANPPaintFlag);
     gPaintI.setColor(m_paintRect, 0xFFA8A8A8);

     m_paintText = gPaintI.newPaint();
     gPaintI.setFlags(m_paintText, gPaintI.getFlags(m_paintText) | kAntiAlias_ANPPaintFlag);
     gPaintI.setColor(m_paintText, 0xFF2F4F4F);
     gPaintI.setTextSize(m_paintText, 18);

     m_paintTrackProgress = gPaintI.newPaint();
     gPaintI.setFlags(m_paintTrackProgress, gPaintI.getFlags(m_paintTrackProgress) | kAntiAlias_ANPPaintFlag);
     gPaintI.setColor(m_paintTrackProgress, 0xFF545454);

     m_paintActiveRect = gPaintI.newPaint();
     gPaintI.setFlags(m_paintActiveRect, gPaintI.getFlags(m_paintActiveRect) | kAntiAlias_ANPPaintFlag);
     gPaintI.setColor(m_paintActiveRect, 0xFF545454);

     ANPTypeface* tf = gTypefaceI.createFromName("serif", kItalic_ANPTypefaceStyle);
     gPaintI.setTypeface(m_paintText, tf);
     gTypefaceI.unref(tf);

     //register for touch events
     ANPEventFlags flags = kTouch_ANPEventFlag;
     NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);
     if (err != NPERR_NO_ERROR) {
         gLogI.log(kError_ANPLogType, "Error selecting input events.");
     }
 }

 AudioPlugin::~AudioPlugin() {
     gPaintI.deletePaint(m_paintTrack);
     gPaintI.deletePaint(m_paintRect);
     gPaintI.deletePaint(m_paintText);
     gPaintI.deletePaint(m_paintTrackProgress);
     gPaintI.deletePaint(m_paintActiveRect);
     if(m_soundPlay->track)
         gSoundI.deleteTrack(m_soundPlay->track);
     delete m_soundPlay;
 }

 bool AudioPlugin::supportsDrawingModel(ANPDrawingModel model) {
     return (model == kBitmap_ANPDrawingModel);
 }

 void AudioPlugin::drawPlugin(const ANPBitmap& bitmap, const ANPRectI& clip) {
     ANPCanvas* canvas = gCanvasI.newCanvas(&bitmap);

     ANPRectF clipR;
     clipR.left = clip.left;
     clipR.top = clip.top;
     clipR.right = clip.right;
     clipR.bottom = clip.bottom;
     gCanvasI.clipRect(canvas, &clipR);

     draw(canvas);
     gCanvasI.deleteCanvas(canvas);
 }

 void AudioPlugin::draw(ANPCanvas* canvas) {

     PluginObject *obj = (PluginObject*) this->inst()->pdata;

     gLogI.log(kError_ANPLogType, "Drawing");

     const float trackHeight = 30;
     const float buttonWidth = 60;
     const float buttonHeight = 30;
     const int W = obj->window->width;
     const int H = obj->window->height;

     // color the plugin canvas
     gCanvasI.drawColor(canvas, 0xFFCDCDCD);

     // get font metrics
     ANPFontMetrics fontMetrics;
     gPaintI.getFontMetrics(m_paintText, &fontMetrics);

     // draw the track box (1 px from the edge)
     m_trackRect.left = 1;
     m_trackRect.top = 1;
     m_trackRect.right = W - 2;
     m_trackRect.bottom = 1 + trackHeight;
     gCanvasI.drawRect(canvas, &m_trackRect, m_paintTrack);

     // draw the progress bar
     if (m_soundPlay->progress > 0) {
         // TODO need to draw progress bar to cover the proper percentage of the track bar
         gCanvasI.drawRect(canvas, &m_trackRect, m_paintTrackProgress);
     }

     // draw the play box (under track box)
     m_playRect.left = m_trackRect.left + 5;
     m_playRect.top = m_trackRect.bottom + 10;
     m_playRect.right = m_playRect.left + buttonWidth;
     m_playRect.bottom = m_playRect.top + buttonHeight;
     gCanvasI.drawRect(canvas, &m_playRect, getPaint(&m_playRect));
     // draw the play box (under track box)
     const char playText[] = "Play";
     gCanvasI.drawText(canvas, playText, sizeof(playText)-1, m_playRect.left + 5,
                       m_playRect.top - fontMetrics.fTop, m_paintText);

     // draw the pause box (under track box)
     m_pauseRect.left = m_playRect.right + 20;
     m_pauseRect.top = m_trackRect.bottom + 10;
     m_pauseRect.right = m_pauseRect.left + buttonWidth;
     m_pauseRect.bottom = m_pauseRect.top + buttonHeight;
     gCanvasI.drawRect(canvas, &m_pauseRect, getPaint(&m_pauseRect));
     // draw the text in the pause box
     const char pauseText[] = "Pause";
     gCanvasI.drawText(canvas, pauseText, sizeof(pauseText)-1, m_pauseRect.left + 5,
                       m_pauseRect.top - fontMetrics.fTop, m_paintText);

     // draw the stop box (under track box)
     m_stopRect.left = m_pauseRect.right + 20;
     m_stopRect.top = m_trackRect.bottom + 10;
     m_stopRect.right = m_stopRect.left + buttonWidth;
     m_stopRect.bottom = m_stopRect.top + buttonHeight;
     gCanvasI.drawRect(canvas, &m_stopRect, getPaint(&m_stopRect));
     // draw the text in the pause box
     const char stopText[] = "Stop";
     gCanvasI.drawText(canvas, stopText, sizeof(stopText)-1, m_stopRect.left + 5,
                       m_stopRect.top - fontMetrics.fTop, m_paintText);
 }

 ANPPaint* AudioPlugin::getPaint(ANPRectF* input) {
     return (input == m_activeRect) ? m_paintActiveRect : m_paintRect;
 }

 int16_t AudioPlugin::handleEvent(const ANPEvent* evt) {
     NPP instance = this->inst();

     switch (evt->eventType) {
         case kDraw_ANPEventType:
             switch (evt->data.draw.model) {
                 case kBitmap_ANPDrawingModel:
                     drawPlugin(evt->data.draw.data.bitmap, evt->data.draw.clip);
                     return 1;
                 default:
                     break;   // unknown drawing model
             }

         case kTouch_ANPEventType: {
             int x = evt->data.touch.x;
             int y = evt->data.touch.y;
             if (kDown_ANPTouchAction == evt->data.touch.action) {

                 m_activeTouchRect = validTouch(x,y);
                 if(m_activeTouchRect) {
                     m_activeTouch = true;
                     return 1;
                 }

             } else if (kUp_ANPTouchAction == evt->data.touch.action && m_activeTouch) {
                 handleTouch(x, y);
                 m_activeTouch = false;
                 return 1;
             } else if (kCancel_ANPTouchAction == evt->data.touch.action) {
                 m_activeTouch = false;
             }
             break;
         }
         default:
             break;
     }
     return 0;   // unknown or unhandled event
 }

 void AudioPlugin::invalActiveRect() {

 }

 ANPRectF* AudioPlugin::validTouch(int x, int y) {

     if (m_playRect.left && x < m_playRect.right && y > m_playRect.top && y < m_playRect.bottom)
         return &m_playRect;
     else if (m_pauseRect.left && x < m_pauseRect.right && y > m_pauseRect.top && y < m_pauseRect.bottom)
         return &m_pauseRect;
     else if (x > m_stopRect.left && x < m_stopRect.right && y > m_stopRect.top && y < m_stopRect.bottom)
         return &m_stopRect;
     else
         return NULL;
 }

 void AudioPlugin::handleTouch(int x, int y) {
     NPP instance = this->inst();

     // if the track is null then return
     if (NULL == m_soundPlay->track) {
         gLogI.log(kError_ANPLogType, "---- %p unable to create track",
                   instance);
         return;
     }

     // check to make sure the currentRect matches the activeRect
     ANPRectF* currentRect = validTouch(x,y);
     if (m_activeTouchRect != currentRect)
         return;

     if (currentRect == &m_playRect) {

         gLogI.log(kDebug_ANPLogType, "---- %p starting track (%d)",
                   m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));

         if (gSoundI.isStopped(m_soundPlay->track)) {
             gSoundI.start(m_soundPlay->track);
         }
     }
     else if (currentRect == &m_pauseRect) {

         gLogI.log(kDebug_ANPLogType, "---- %p pausing track (%d)",
                   m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));

         if (!gSoundI.isStopped(m_soundPlay->track)) {
             gSoundI.pause(m_soundPlay->track);
         }
     }
     else if (currentRect == &m_stopRect) {

         gLogI.log(kDebug_ANPLogType, "---- %p stopping track (%d)",
                   m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));

         if (!gSoundI.isStopped(m_soundPlay->track)) {
             gSoundI.stop(m_soundPlay->track);
         }
         if (m_soundPlay->file) {
             fseek(m_soundPlay->file, 0, SEEK_SET);
         }
     }
     else {
         return;
     }

     // set the currentRect to be the activeRect
     m_activeRect = currentRect;
     inval(instance);
 }
	/*
	* Copyright 2008, The Android Open Source Project
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "AudioPlugin.h"

	#include <fcntl.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <time.h>
	#include <math.h>
	#include <string.h>

	extern NPNetscapeFuncs* browser;
	extern ANPLogInterfaceV0 gLogI;
	extern ANPCanvasInterfaceV0 gCanvasI;
	extern ANPPaintInterfaceV0 gPaintI;
	extern ANPAudioTrackInterfaceV0 gSoundI;
	extern ANPTypefaceInterfaceV0 gTypefaceI;


	static void inval(NPP instance) {
	browser->invalidaterect(instance, NULL);
	}

	static uint16_t rnd16(float x, int inset) {
	int ix = (int)roundf(x) + inset;
	if (ix < 0) {
	ix = 0;
	}
	return static_cast<uint16_t>(ix);
	}

	static void inval(NPP instance, const ANPRectF& r, bool doAA) {
	const int inset = doAA ? -1 : 0;

	PluginObject obj = reinterpret_cast<PluginObject>(instance->pdata);
	NPRect inval;
	inval.left = rnd16(r.left, inset);
	inval.top = rnd16(r.top, inset);
	inval.right = rnd16(r.right, -inset);
	inval.bottom = rnd16(r.bottom, -inset);
	browser->invalidaterect(instance, &inval);
	}

	static void audioCallback(ANPAudioEvent evt, void* user, ANPAudioBuffer* buffer) {
	switch (evt) {
	case kMoreData_ANPAudioEvent: {
	SoundPlay* play = reinterpret_cast<SoundPlay*>(user);
	size_t amount = fread(buffer->bufferData, 1, buffer->size, play->file);
	buffer->size = amount;
	if (amount == 0) {
	gSoundI.stop(play->track);
	fclose(play->file);
	play->file = NULL;
	// TODO need to notify our main thread to delete the track now
	}

	if (play->fileSize > 0) {
	// TODO we need to properly update the progress value
	play->progress = 1;
	inval(play->instance);
	}


	break;
	}
	default:
	break;
	}
	}

	///////////////////////////////////////////////////////////////////////////////

	AudioPlugin::AudioPlugin(NPP inst) : SubPlugin(inst) {

	const char path[] = "/sdcard/sample.raw";

	// open a file stream
	FILE* f = fopen(path, "r");
	gLogI.log(kDebug_ANPLogType, "--- path %s FILE %p", path, f);

	// setup our private audio struct's default values
	m_soundPlay = new SoundPlay;
	m_soundPlay->instance = inst;
	m_soundPlay->progress = 0;
	m_soundPlay->fileSize = 0;
	m_soundPlay->file = f;
	m_soundPlay->track = NULL;

	// create the audio track
	if (f) {
	m_soundPlay->track = gSoundI.newTrack(44100, kPCM16Bit_ANPSampleFormat, 2, audioCallback, m_soundPlay);
	if (!m_soundPlay->track) {
	fclose(f);
	m_soundPlay->file = NULL;
	}
	}

	// get the audio file's size
	int fileDescriptor = open(path, O_RDONLY);
	struct stat fileStatus;

	if(fileDescriptor <= 0) {
	gLogI.log(kError_ANPLogType, "fopen error");
	}
	else if (fstat(fileDescriptor, &fileStatus) != 0) {
	gLogI.log(kDebug_ANPLogType, "File Size: %d", fileStatus.st_size);
	m_soundPlay->fileSize = fileStatus.st_size;
	} else {
	gLogI.log(kError_ANPLogType, "fstat error");
	}

	// configure the UI elements
	m_activeTouch = false;

	memset(&m_trackRect, 0, sizeof(m_trackRect));
	memset(&m_playRect, 0, sizeof(m_playRect));
	memset(&m_pauseRect, 0, sizeof(m_pauseRect));
	memset(&m_stopRect, 0, sizeof(m_stopRect));

	m_paintTrack = gPaintI.newPaint();
	gPaintI.setFlags(m_paintTrack, gPaintI.getFlags(m_paintTrack) \| kAntiAlias_ANPPaintFlag);
	gPaintI.setColor(m_paintTrack, 0xFFC0C0C0);

	m_paintRect = gPaintI.newPaint();
	gPaintI.setFlags(m_paintRect, gPaintI.getFlags(m_paintRect) \| kAntiAlias_ANPPaintFlag);
	gPaintI.setColor(m_paintRect, 0xFFA8A8A8);

	m_paintText = gPaintI.newPaint();
	gPaintI.setFlags(m_paintText, gPaintI.getFlags(m_paintText) \| kAntiAlias_ANPPaintFlag);
	gPaintI.setColor(m_paintText, 0xFF2F4F4F);
	gPaintI.setTextSize(m_paintText, 18);

	m_paintTrackProgress = gPaintI.newPaint();
	gPaintI.setFlags(m_paintTrackProgress, gPaintI.getFlags(m_paintTrackProgress) \| kAntiAlias_ANPPaintFlag);
	gPaintI.setColor(m_paintTrackProgress, 0xFF545454);

	m_paintActiveRect = gPaintI.newPaint();
	gPaintI.setFlags(m_paintActiveRect, gPaintI.getFlags(m_paintActiveRect) \| kAntiAlias_ANPPaintFlag);
	gPaintI.setColor(m_paintActiveRect, 0xFF545454);

	ANPTypeface* tf = gTypefaceI.createFromName("serif", kItalic_ANPTypefaceStyle);
	gPaintI.setTypeface(m_paintText, tf);
	gTypefaceI.unref(tf);

	//register for touch events
	ANPEventFlags flags = kTouch_ANPEventFlag;
	NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags);
	if (err != NPERR_NO_ERROR) {
	gLogI.log(kError_ANPLogType, "Error selecting input events.");
	}
	}

	AudioPlugin::~AudioPlugin() {
	gPaintI.deletePaint(m_paintTrack);
	gPaintI.deletePaint(m_paintRect);
	gPaintI.deletePaint(m_paintText);
	gPaintI.deletePaint(m_paintTrackProgress);
	gPaintI.deletePaint(m_paintActiveRect);
	if(m_soundPlay->track)
	gSoundI.deleteTrack(m_soundPlay->track);
	delete m_soundPlay;
	}

	bool AudioPlugin::supportsDrawingModel(ANPDrawingModel model) {
	return (model == kBitmap_ANPDrawingModel);
	}

	void AudioPlugin::drawPlugin(const ANPBitmap& bitmap, const ANPRectI& clip) {
	ANPCanvas* canvas = gCanvasI.newCanvas(&bitmap);

	ANPRectF clipR;
	clipR.left = clip.left;
	clipR.top = clip.top;
	clipR.right = clip.right;
	clipR.bottom = clip.bottom;
	gCanvasI.clipRect(canvas, &clipR);

	draw(canvas);
	gCanvasI.deleteCanvas(canvas);
	}

	void AudioPlugin::draw(ANPCanvas* canvas) {

	PluginObject obj = (PluginObject) this->inst()->pdata;

	gLogI.log(kError_ANPLogType, "Drawing");

	const float trackHeight = 30;
	const float buttonWidth = 60;
	const float buttonHeight = 30;
	const int W = obj->window->width;
	const int H = obj->window->height;

	// color the plugin canvas
	gCanvasI.drawColor(canvas, 0xFFCDCDCD);

	// get font metrics
	ANPFontMetrics fontMetrics;
	gPaintI.getFontMetrics(m_paintText, &fontMetrics);

	// draw the track box (1 px from the edge)
	m_trackRect.left = 1;
	m_trackRect.top = 1;
	m_trackRect.right = W - 2;
	m_trackRect.bottom = 1 + trackHeight;
	gCanvasI.drawRect(canvas, &m_trackRect, m_paintTrack);

	// draw the progress bar
	if (m_soundPlay->progress > 0) {
	// TODO need to draw progress bar to cover the proper percentage of the track bar
	gCanvasI.drawRect(canvas, &m_trackRect, m_paintTrackProgress);
	}

	// draw the play box (under track box)
	m_playRect.left = m_trackRect.left + 5;
	m_playRect.top = m_trackRect.bottom + 10;
	m_playRect.right = m_playRect.left + buttonWidth;
	m_playRect.bottom = m_playRect.top + buttonHeight;
	gCanvasI.drawRect(canvas, &m_playRect, getPaint(&m_playRect));
	// draw the play box (under track box)
	const char playText[] = "Play";
	gCanvasI.drawText(canvas, playText, sizeof(playText)-1, m_playRect.left + 5,
	m_playRect.top - fontMetrics.fTop, m_paintText);

	// draw the pause box (under track box)
	m_pauseRect.left = m_playRect.right + 20;
	m_pauseRect.top = m_trackRect.bottom + 10;
	m_pauseRect.right = m_pauseRect.left + buttonWidth;
	m_pauseRect.bottom = m_pauseRect.top + buttonHeight;
	gCanvasI.drawRect(canvas, &m_pauseRect, getPaint(&m_pauseRect));
	// draw the text in the pause box
	const char pauseText[] = "Pause";
	gCanvasI.drawText(canvas, pauseText, sizeof(pauseText)-1, m_pauseRect.left + 5,
	m_pauseRect.top - fontMetrics.fTop, m_paintText);

	// draw the stop box (under track box)
	m_stopRect.left = m_pauseRect.right + 20;
	m_stopRect.top = m_trackRect.bottom + 10;
	m_stopRect.right = m_stopRect.left + buttonWidth;
	m_stopRect.bottom = m_stopRect.top + buttonHeight;
	gCanvasI.drawRect(canvas, &m_stopRect, getPaint(&m_stopRect));
	// draw the text in the pause box
	const char stopText[] = "Stop";
	gCanvasI.drawText(canvas, stopText, sizeof(stopText)-1, m_stopRect.left + 5,
	m_stopRect.top - fontMetrics.fTop, m_paintText);
	}

	ANPPaint* AudioPlugin::getPaint(ANPRectF* input) {
	return (input == m_activeRect) ? m_paintActiveRect : m_paintRect;
	}

	int16_t AudioPlugin::handleEvent(const ANPEvent* evt) {
	NPP instance = this->inst();

	switch (evt->eventType) {
	case kDraw_ANPEventType:
	switch (evt->data.draw.model) {
	case kBitmap_ANPDrawingModel:
	drawPlugin(evt->data.draw.data.bitmap, evt->data.draw.clip);
	return 1;
	default:
	break; // unknown drawing model
	}

	case kTouch_ANPEventType: {
	int x = evt->data.touch.x;
	int y = evt->data.touch.y;
	if (kDown_ANPTouchAction == evt->data.touch.action) {

	m_activeTouchRect = validTouch(x,y);
	if(m_activeTouchRect) {
	m_activeTouch = true;
	return 1;
	}

	} else if (kUp_ANPTouchAction == evt->data.touch.action && m_activeTouch) {
	handleTouch(x, y);
	m_activeTouch = false;
	return 1;
	} else if (kCancel_ANPTouchAction == evt->data.touch.action) {
	m_activeTouch = false;
	}
	break;
	}
	default:
	break;
	}
	return 0; // unknown or unhandled event
	}

	void AudioPlugin::invalActiveRect() {

	}

	ANPRectF* AudioPlugin::validTouch(int x, int y) {

	if (m_playRect.left && x < m_playRect.right && y > m_playRect.top && y < m_playRect.bottom)
	return &m_playRect;
	else if (m_pauseRect.left && x < m_pauseRect.right && y > m_pauseRect.top && y < m_pauseRect.bottom)
	return &m_pauseRect;
	else if (x > m_stopRect.left && x < m_stopRect.right && y > m_stopRect.top && y < m_stopRect.bottom)
	return &m_stopRect;
	else
	return NULL;
	}

	void AudioPlugin::handleTouch(int x, int y) {
	NPP instance = this->inst();

	// if the track is null then return
	if (NULL == m_soundPlay->track) {
	gLogI.log(kError_ANPLogType, "---- %p unable to create track",
	instance);
	return;
	}

	// check to make sure the currentRect matches the activeRect
	ANPRectF* currentRect = validTouch(x,y);
	if (m_activeTouchRect != currentRect)
	return;

	if (currentRect == &m_playRect) {

	gLogI.log(kDebug_ANPLogType, "---- %p starting track (%d)",
	m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));

	if (gSoundI.isStopped(m_soundPlay->track)) {
	gSoundI.start(m_soundPlay->track);
	}
	}
	else if (currentRect == &m_pauseRect) {

	gLogI.log(kDebug_ANPLogType, "---- %p pausing track (%d)",
	m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));

	if (!gSoundI.isStopped(m_soundPlay->track)) {
	gSoundI.pause(m_soundPlay->track);
	}
	}
	else if (currentRect == &m_stopRect) {

	gLogI.log(kDebug_ANPLogType, "---- %p stopping track (%d)",
	m_soundPlay->track, gSoundI.isStopped(m_soundPlay->track));

	if (!gSoundI.isStopped(m_soundPlay->track)) {
	gSoundI.stop(m_soundPlay->track);
	}
	if (m_soundPlay->file) {
	fseek(m_soundPlay->file, 0, SEEK_SET);
	}
	}
	else {
	return;
	}

	// set the currentRect to be the activeRect
	m_activeRect = currentRect;
	inval(instance);
	}