2010-01-31  Echo Choi  <echo@firefly>

	* Reverted to use num_chan as output number of channel for AAC.

2010-01-29  Echo Choi  <echo@firefly>

	* Fixed Audio Manager setting.
	* Updated version to 0.4.1 since API changes since 0.3.5.

2010-01-25  Echo Choi  <echo@firefly>

	* Updated MixCommon dependency to 0.1.8.
	* Updated version to 0.3.6.

2010-01-24  Echo Choi  <echo@firefly>

	* Sync MixIOVec between capture and decode.

2010-01-22  Echo Choi  <echo@firefly>

	* Updated MixIOVec definition.
	* Updated API sync with 0.79 doc.

2010-01-20  Echo Choi  <echo@firefly>

	* Updated API doc 0.79 sync up.

2010-01-18  Echo Choi  <echo@firefly>
 
	* Updated version to 0.3.5 and submit for build.
	* Updated call to Audio Manager to use stream name.
	* Removed the check to allow decode to be called during PAUSE.

2010-01-11  Echo Choi  <echo@firefly>

	* Updated version to 0.3.4
	* Updated MixCommon dependency to v 0.1.6.
	* Updated the parameter conversion code for AAC to detect codec value from parameters.
	* Fixed and added more enum types for AAC parameters definitions.
	* Added methods to replace AAC parameters direct accessing.
	* Added psPresentFlag for AAC param object.
	* Updated gtk-doc documentation.
	* Added get_stream_byte_decoded API.

2010-01-04  Echo Choi  <echo@firefly>

        * Fixed code review issues: declare const for char*
        * Fixed code review issues: array size calculation.

2009-12-23  Echo Choi  <echo@firefly>

        * Added aac core operating frequency param for AAC Param object. Needed to configure HE-AAC decoder.
        * Fixed the log message category for DRAIN debug log.

2009-11-19  Echo Choi  <echo@firefly>

        * Added more utility function to populate param object.
	* Added MixAudio API to read output configuration (get params)

2009-11-18  Echo Choi  <echo@firefly>

	* Added return code that inform caller to interpret errno for error.
	* Fixed more error checkings.

2009-11-17  Echo Choi  <echo@firefly>

	* Added default invalid value for various enumerations.
	* Fixed some bugs in type declarations.
	* Cleaned up code. Added pointer checks, state checks.

2009-11-15  Echo Choi  <echo@firefly>

	* Updated version to 0.3.3 and package for build.
	* Fixed DRAIN state test condition.

2009-11-13  Echo Choi  <echo@firefly>

	* Updated MixCommon version dependency as MixAudio is using new definitions from MixCommon.
	* Fixed issues reported by klocwork.

2009-11-11  Echo Choi  <echo@firefly>

	* Fixed a mem leak in the stub code.

2009-11-01  Echo Choi  <echo@firefly>

	* Increased version number to 0.3.2 and package for build.

2009-10-28  Echo Choi  <echo@firefly>

	* Renamed MPEG_FORMAT member of AAC params to MPEG_ID.

2009-10-23  Echo Choi  <echo@firefly>

	* Updated version to 0.3.1 for build.
	* Added code to assign op_align to sst structure in deterministic case.
	* Added stub code to write input  bytes to file during dnr request.
	* Fixed MixAudio::decode() method to use correct 64-bit type for decode consumed/produced.

2009-10-18  Echo Choi  <echo@firefly>

	* Added dbus-glib dependency.
	* Updated AAC param object to include additonal fields for HE-AAC support.

2009-10-16  Echo Choi  <echo@firefly>

	* Moved mixdrmparams.* to MixCommon package.
	* Changed mix_audio_decode API to include output parameters for bytes consumed and produceds
	* Updated version to 0.3.0 to reflect API change in mix_audio_decode.

2009-10-08  Echo Choi  <echo@firefly>

	* Package for 0.2.6 build.

2009-10-02  Echo Choi  <echo@firefly>

	* Updated version number to 0.2.6
	* Defined new range for error code that encapsulate errno when system calls to SST API shall fail.
	* Added internal states to track PAUSED_DRAINING, and added code to deal with this state.

2009-08-17  Echo Choi  <echo@firefly>

	* Updated SST API struct to align with build 0.04.008.
	* Added bit-mask based runtime log mechanism.

2009-08-14  Echo Choi  <echo@firefly>

	* Fixed return value check after DROP call.
	* Added method to dump status upon SST call failure.

2009-08-13  Echo Choi  <echo@firefly>

	* Updated API definitions to sync with v0.5 documentation.

2009-08-10  Echo Choi  <echo@firefly>

	* Fixed stop_drop so it is called even if the state is STOPPED
	

