view libmpcodecs/ad_flac.c @ 11131:8b2d7d006bdd

-colorkey documented.

/*
 * This is FLAC decoder for MPlayer using stream_decoder from libFLAC
 * (directly or from libmpflac).
 * This file is part of MPlayer, see http://mplayerhq.hu/ for info.  
 * Copyright (C) 2003  Dmitry Baryshkov <mitya at school.ioffe.ru>
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * parse_double_, grabbag__replaygain_load_from_vorbiscomment, grabbag__replaygain_compute_scale_factor
 * functions are imported from FLAC project (from grabbag lib sources (replaygain.c)) and are
 * Copyright (C) 2002,2003  Josh Coalson under the terms of GPL.
 */

/*
 * TODO:
 * in demux_audio use data from seektable block for seeking.
 * support FLAC-in-Ogg.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>

#include "config.h"
#ifdef HAVE_FLAC
#include "ad_internal.h"
#include "mp_msg.h"

static ad_info_t info =  {
	"FLAC audio decoder",  // name of the driver
	"flac",    // driver name. should be the same as filename without ad_
	"Dmitry Baryshkov",     // writer/maintainer of _this_ file
	"http://flac.sf.net/",          // writer/maintainer/site of the _codec_
	""           // comments
};

LIBAD_EXTERN(flac)

#ifdef USE_MPFLAC_DECODER
#include "FLAC_stream_decoder.h"
#include "FLAC_assert.h"
#include "FLAC_metadata.h"
#else
#include "FLAC/stream_decoder.h"
#include "FLAC/assert.h"
#include "FLAC/metadata.h"
#endif

/* dithering & replaygain always from libmpflac */
#include "dither.h"
#include "replaygain_synthesis.h"

/* Some global constants. Thay have to be configurable, so leaved them as globals. */
static const FLAC__bool album_mode = true;
static const int preamp = 0;
static const FLAC__bool hard_limit = false;
static const int noise_shaping = 1;
static const FLAC__bool dither = true;
typedef struct flac_struct_st
{
	FLAC__StreamDecoder *flac_dec; /*decoder handle*/
	sh_audio_t *sh; /* link back to corresponding sh */
	
	/* set this fields before calling FLAC__stream_decoder_process_single */
	unsigned char *buf; 
	int minlen;
	int maxlen;
	/* Here goes number written at write_callback */
	int written;

	/* replaygain and dithering via plugin_common */
	FLAC__bool has_replaygain;
	double replay_scale;
	DitherContext dither_context;
	int bits_per_sample;
} flac_struct_t;

FLAC__StreamDecoderReadStatus flac_read_callback (const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
	int b = demux_read_data(((flac_struct_t*)client_data)->sh->ds, buffer,  *bytes);
	mp_msg(MSGT_DECAUDIO, MSGL_DBG2, "\nread %d bytes\n", b);
	*bytes = b;
	if (b <= 0)
		return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
	return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}

/*FIXME: we need to support format conversion:(flac specs allow bits/sample to be from 4 to 32. Not only 8 and 16 !!!)*/
FLAC__StreamDecoderWriteStatus flac_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
{
	FLAC__byte *buf = ((flac_struct_t*)(client_data))->buf;
	int channel, sample;
	int bps = ((flac_struct_t*)(client_data))->sh->samplesize;
	mp_msg(MSGT_DECAUDIO, MSGL_DBG2, "\nWrite callback (%d bytes)!!!!\n", bps*frame->header.blocksize*frame->header.channels);
	if (buf == NULL)
	{
		/* This is used in control for skipping 1 audio frame */
		return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
	}
#if 0
	for (sample = 0; sample < frame->header.blocksize; sample ++)
		for (channel = 0; channel < frame->header.channels; channel ++)
			switch (bps)
			{
				case 3:
					buf[bps*(sample*frame->header.channels+channel)+2] = (FLAC__byte)(buffer[channel][sample]>>16);
				case 2:
					buf[bps*(sample*frame->header.channels+channel)+1] = (FLAC__byte)(buffer[channel][sample]>>8);
					buf[bps*(sample*frame->header.channels+channel)+0] = (FLAC__byte)(buffer[channel][sample]);
					break;
				case 1:
					buf[bps*(sample*frame->header.channels+channel)] = buffer[channel][sample]^0x80;
					break;
			}
#else
	FLAC__plugin_common__apply_gain(
				buf,
				buffer,
				frame->header.blocksize,
				frame->header.channels,
				((flac_struct_t*)(client_data))->bits_per_sample,
				((flac_struct_t*)(client_data))->sh->samplesize * 8,
				((flac_struct_t*)(client_data))->replay_scale,
				hard_limit,
				dither,
				&(((flac_struct_t*)(client_data))->dither_context)
		);
#endif
	((flac_struct_t*)(client_data))->written += bps*frame->header.blocksize*frame->header.channels;
	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}

#ifdef local_min
#undef local_min
#endif
#define local_min(a,b) ((a)<(b)?(a):(b))

static FLAC__bool parse_double_(const FLAC__StreamMetadata_VorbisComment_Entry *entry, double *val)
{
	char s[32], *end;
	const char *p, *q;
	double v;

	FLAC__ASSERT(0 != entry);
	FLAC__ASSERT(0 != val);

	p = (const char *)entry->entry;
	q = strchr(p, '=');
	if(0 == q)
		return false;
	q++;
	memset(s, 0, sizeof(s)-1);
	strncpy(s, q, local_min(sizeof(s)-1, entry->length - (q-p)));

	v = strtod(s, &end);
	if(end == s)
		return false;

	*val = v;
	return true;
}

FLAC__bool grabbag__replaygain_load_from_vorbiscomment(const FLAC__StreamMetadata *block, FLAC__bool album_mode, double *gain, double *peak)
{
	int gain_offset, peak_offset;
static const FLAC__byte *tag_title_gain_ = "REPLAYGAIN_TRACK_GAIN";
static const FLAC__byte *tag_title_peak_ = "REPLAYGAIN_TRACK_PEAK";
static const FLAC__byte *tag_album_gain_ = "REPLAYGAIN_ALBUM_GAIN";
static const FLAC__byte *tag_album_peak_ = "REPLAYGAIN_ALBUM_PEAK";

	FLAC__ASSERT(0 != block);
	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);

	if(0 > (gain_offset = FLAC__metadata_object_vorbiscomment_find_entry_from(block, /*offset=*/0, (const char *)(album_mode? tag_album_gain_ : tag_title_gain_))))
		return false;
	if(0 > (peak_offset = FLAC__metadata_object_vorbiscomment_find_entry_from(block, /*offset=*/0, (const char *)(album_mode? tag_album_peak_ : tag_title_peak_))))
		return false;

	if(!parse_double_(block->data.vorbis_comment.comments + gain_offset, gain))
		return false;
	if(!parse_double_(block->data.vorbis_comment.comments + peak_offset, peak))
		return false;

	return true;
}

double grabbag__replaygain_compute_scale_factor(double peak, double gain, double preamp, FLAC__bool prevent_clipping)
{
	double scale;
	FLAC__ASSERT(peak >= 0.0);
 	gain += preamp;
	scale = (float) pow(10.0, gain * 0.05);
	if(prevent_clipping && peak > 0.0) {
		const double max_scale = (float)(1.0 / peak);
		if(scale > max_scale)
			scale = max_scale;
	}
	return scale;
}

void flac_metadata_callback (const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
	int i, j;
	sh_audio_t *sh = ((flac_struct_t*)client_data)->sh;
	mp_msg(MSGT_DECAUDIO, MSGL_DBG2, "Metadata received\n");
	switch (metadata->type)
	{
		case FLAC__METADATA_TYPE_STREAMINFO:
			mp_msg(MSGT_DECAUDIO, MSGL_V, "STREAMINFO block (%u bytes):\n", metadata->length);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "min_blocksize: %u samples\n", metadata->data.stream_info.min_blocksize);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "max_blocksize: %u samples\n", metadata->data.stream_info.max_blocksize);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "min_framesize: %u bytes\n", metadata->data.stream_info.min_framesize);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "max_framesize: %u bytes\n", metadata->data.stream_info.max_framesize);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "sample_rate: %u Hz\n", metadata->data.stream_info.sample_rate);
			sh->samplerate = metadata->data.stream_info.sample_rate;
			mp_msg(MSGT_DECAUDIO, MSGL_V, "channels: %u\n", metadata->data.stream_info.channels);
			sh->channels = metadata->data.stream_info.channels;
			mp_msg(MSGT_DECAUDIO, MSGL_V, "bits_per_sample: %u\n", metadata->data.stream_info.bits_per_sample);
			((flac_struct_t*)client_data)->bits_per_sample = metadata->data.stream_info.bits_per_sample;
			sh->samplesize = (metadata->data.stream_info.bits_per_sample<=8)?1:2;
			/* FIXME: need to support dithering to samplesize 4 */
			sh->sample_format=(sh->samplesize==1)?AFMT_U8:AFMT_S16_LE; // sample format, see libao2/afmt.h
			sh->o_bps = sh->samplesize * metadata->data.stream_info.channels * metadata->data.stream_info.sample_rate;
			sh->i_bps = metadata->data.stream_info.bits_per_sample * metadata->data.stream_info.channels * metadata->data.stream_info.sample_rate / 8 / 2;
			// input data rate (compressed bytes per second)
			// Compression rate is near 0.5 
			mp_msg(MSGT_DECAUDIO, MSGL_V, "total_samples: %llu\n", metadata->data.stream_info.total_samples);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "md5sum: ");
			for (i = 0; i < 16; i++)
				mp_msg(MSGT_DECAUDIO, MSGL_V, "%02hhx", metadata->data.stream_info.md5sum[i]);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "\n");
			
			break;
		case FLAC__METADATA_TYPE_PADDING:
			mp_msg(MSGT_DECAUDIO, MSGL_V, "PADDING block (%u bytes)\n", metadata->length);
			break;
		case FLAC__METADATA_TYPE_APPLICATION:
			mp_msg(MSGT_DECAUDIO, MSGL_V, "APPLICATION block (%u bytes):\n", metadata->length);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "Application id: 0x");
			for (i = 0; i < 4; i++)
				mp_msg(MSGT_DECAUDIO, MSGL_V, "%02hhx", metadata->data.application.id[i]);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "\nData: \n");
			for (i = 0; i < (metadata->length-4)/8; i++)
			{
				for(j = 0; j < 8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%c", (unsigned char)metadata->data.application.data[i*8+j]<0x20?'.':metadata->data.application.data[i*8+j]);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "  |  ");
				for(j = 0; j < 8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%#02hhx ", metadata->data.application.data[i*8+j]);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "\n");
			}
			if (metadata->length-4-i*8 != 0)
			{
				for(j = 0; j < metadata->length-4-i*8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%c", (unsigned char)metadata->data.application.data[i*8+j]<0x20?'.':metadata->data.application.data[i*8+j]);
				for(; j <8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, " ");
				mp_msg(MSGT_DECAUDIO, MSGL_V, "  |  ");
				for(j = 0; j < metadata->length-4-i*8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%#02hhx ", metadata->data.application.data[i*8+j]);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "\n");
			}
			break;
		case FLAC__METADATA_TYPE_SEEKTABLE:
			mp_msg(MSGT_DECAUDIO, MSGL_V, "SEEKTABLE block (%u bytes):\n", metadata->length);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "%d seekpoints:\n", metadata->data.seek_table.num_points);
			for (i = 0; i < metadata->data.seek_table.num_points; i++)
				if (metadata->data.seek_table.points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "  %3d) sample_number=%llu stream_offset=%llu frame_samples=%u\n", i,
						metadata->data.seek_table.points[i].sample_number,
						metadata->data.seek_table.points[i].stream_offset,
						metadata->data.seek_table.points[i].frame_samples);
				else
					mp_msg(MSGT_DECAUDIO, MSGL_V, "  %3d) PLACEHOLDER\n", i);
			break;
		case FLAC__METADATA_TYPE_VORBIS_COMMENT:
			mp_msg(MSGT_DECAUDIO, MSGL_V, "VORBISCOMMENT block (%u bytes):\n", metadata->length);
			{
				char entry[metadata->data.vorbis_comment.vendor_string.length+1];
				memcpy(&entry, metadata->data.vorbis_comment.vendor_string.entry, metadata->data.vorbis_comment.vendor_string.length);
				entry[metadata->data.vorbis_comment.vendor_string.length] = '\0';
				mp_msg(MSGT_DECAUDIO, MSGL_V, "vendor_string: %s\n", entry);
			}
			mp_msg(MSGT_DECAUDIO, MSGL_V, "%d comment(s):\n",  metadata->data.vorbis_comment.num_comments);
			for (i = 0; i < metadata->data.vorbis_comment.num_comments; i++)
			{
				char entry[metadata->data.vorbis_comment.comments[i].length];
				memcpy(&entry, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length);
				entry[metadata->data.vorbis_comment.comments[i].length] = '\0';
				mp_msg(MSGT_DECAUDIO, MSGL_V, "%s\n", entry);
			}
			{
				double gain, peak;
				if(grabbag__replaygain_load_from_vorbiscomment(metadata, album_mode, &gain, &peak))
				{
					((flac_struct_t*)client_data)->has_replaygain = true;
					((flac_struct_t*)client_data)->replay_scale = grabbag__replaygain_compute_scale_factor(peak, gain, (double)preamp, /*prevent_clipping=*/!hard_limit);
					mp_msg(MSGT_DECAUDIO, MSGL_V, "calculated replay_scale: %lf\n", ((flac_struct_t*)client_data)->replay_scale);
				}
			}
			break;
		case FLAC__METADATA_TYPE_CUESHEET:
			mp_msg(MSGT_DECAUDIO, MSGL_V, "CUESHEET block (%u bytes):\n", metadata->length);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "mcn: '%s'\n", metadata->data.cue_sheet.media_catalog_number);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "lead_in: %llu\n", metadata->data.cue_sheet.lead_in);
			mp_msg(MSGT_DECAUDIO, MSGL_V, "is_cd: %s\n", metadata->data.cue_sheet.is_cd?"true":"false");
			mp_msg(MSGT_DECAUDIO, MSGL_V, "num_tracks: %u\n", metadata->data.cue_sheet.num_tracks);
			for (i = 0; i < metadata->data.cue_sheet.num_tracks; i++)
			{
				mp_msg(MSGT_DECAUDIO, MSGL_V, "track[%d]:\n", i);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "offset: %llu\n", metadata->data.cue_sheet.tracks[i].offset);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "number: %hhu%s\n", metadata->data.cue_sheet.tracks[i].number, metadata->data.cue_sheet.tracks[i].number==170?"(LEAD-OUT)":"");
				mp_msg(MSGT_DECAUDIO, MSGL_V, "isrc: '%s'\n", metadata->data.cue_sheet.tracks[i].isrc);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "type: %s\n", metadata->data.cue_sheet.tracks[i].type?"non-audio":"audio");
				mp_msg(MSGT_DECAUDIO, MSGL_V, "pre_emphasis: %s\n", metadata->data.cue_sheet.tracks[i].pre_emphasis?"true":"false");
				mp_msg(MSGT_DECAUDIO, MSGL_V, "num_indices: %hhu\n", metadata->data.cue_sheet.tracks[i].num_indices);
				for (j = 0; j < metadata->data.cue_sheet.tracks[i].num_indices; j++)
				{
					mp_msg(MSGT_DECAUDIO, MSGL_V, "index[%d]:\n", j);
					mp_msg(MSGT_DECAUDIO, MSGL_V, "offset:%llu\n", metadata->data.cue_sheet.tracks[i].indices[j].offset);
					mp_msg(MSGT_DECAUDIO, MSGL_V, "number:%hhu\n", metadata->data.cue_sheet.tracks[i].indices[j].number);
				}
			}
			break;
		default: if (metadata->type >= FLAC__METADATA_TYPE_UNDEFINED)
			mp_msg(MSGT_DECAUDIO, MSGL_V, "UNKNOWN block (%u bytes):\n", metadata->length);
			else
			mp_msg(MSGT_DECAUDIO, MSGL_V, "Strange block: UNKNOWN #%d < FLAC__METADATA_TYPE_UNDEFINED (%u bytes):\n", metadata->type, metadata->length);
			for (i = 0; i < (metadata->length)/8; i++)
			{
				for(j = 0; j < 8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%c", (unsigned char)metadata->data.unknown.data[i*8+j]<0x20?'.':metadata->data.unknown.data[i*8+j]);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "  |  ");
				for(j = 0; j < 8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%#02hhx ", metadata->data.unknown.data[i*8+j]);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "\n");
			}
			if (metadata->length-i*8 != 0)
			{
				for(j = 0; j < metadata->length-i*8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%c", (unsigned char)metadata->data.unknown.data[i*8+j]<0x20?'.':metadata->data.unknown.data[i*8+j]);
				for(; j <8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, " ");
				mp_msg(MSGT_DECAUDIO, MSGL_V, "  |  ");
				for(j = 0; j < metadata->length-i*8; j++)
					mp_msg(MSGT_DECAUDIO, MSGL_V, "%#02hhx ", metadata->data.unknown.data[i*8+j]);
				mp_msg(MSGT_DECAUDIO, MSGL_V, "\n");
			}
			break;
	}
}

void flac_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
{
	if (status != FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC)
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "\nError callback called (%s)!!!\n", FLAC__StreamDecoderErrorStatusString[status]);
}

static int preinit(sh_audio_t *sh){
  // there are default values set for buffering, but you can override them:
  
  sh->audio_out_minsize=8*4*65535; // due to specs: we assume max 8 channels,
                                  // 4 bytes/sample and 65535 samples/frame
				  // So allocating 2Mbytes buffer :)
  
  // minimum input buffer size (set only if you need input buffering)
  // (should be the max compressed frame size)
  sh->audio_in_minsize=2048; // Default: 0 (no input buffer)
  
  // if you set audio_in_minsize non-zero, the buffer will be allocated
  // before the init() call by the core, and you can access it via
  // pointer: sh->audio_in_buffer
  // it will free'd after uninit(), so you don't have to use malloc/free here!

  return 1; // return values: 1=OK 0=ERROR
}

static int init(sh_audio_t *sh_audio){
	flac_struct_t *context = (flac_struct_t*)calloc(sizeof(flac_struct_t), 1);
  
	sh_audio->context = context;
	context->sh = sh_audio;
	if (context == NULL)
	{
		mp_msg(MSGT_DECAUDIO, MSGL_FATAL, "flac_init: error allocating context.\n");
		return 0;
	}

	context->flac_dec = FLAC__stream_decoder_new();
	if (context->flac_dec == NULL)
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "flac_init: error allocaing FLAC decoder.\n");
		return 0;
	}
  
	if (!FLAC__stream_decoder_set_client_data(context->flac_dec, context))
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "error setting private data for callbacks.\n");
		return 0;
	}

	if (!FLAC__stream_decoder_set_read_callback(context->flac_dec, &flac_read_callback))
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "error setting read callback.\n");
		return 0;
	}

	if (!FLAC__stream_decoder_set_write_callback(context->flac_dec, &flac_write_callback))
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "error setting write callback.\n");
		return 0;
	}

	if (!FLAC__stream_decoder_set_metadata_callback(context->flac_dec, &flac_metadata_callback))
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "error setting metadata callback.\n");
		return 0;
	}

	if (!FLAC__stream_decoder_set_error_callback(context->flac_dec, &flac_error_callback))
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "error setting error callback.\n");
		return 0;
	}

	if (!FLAC__stream_decoder_set_metadata_respond_all(context->flac_dec))
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "error during setting metadata_respond_all.\n");
		return 0;
	}

	if (FLAC__stream_decoder_init(context->flac_dec) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
	{
		mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Error initializing decoder!\n");
		return 0;
	}

	context->buf = NULL;
	context->minlen = context->maxlen = 0;
	context->replay_scale = 1.0;

	FLAC__stream_decoder_process_until_end_of_metadata(context->flac_dec);

	FLAC__plugin_common__init_dither_context(&(context->dither_context), sh_audio->samplesize * 8, noise_shaping);
	
	return 1; // return values: 1=OK 0=ERROR
}

static void uninit(sh_audio_t *sh){
  // uninit the decoder etc...
  FLAC__stream_decoder_finish(((flac_struct_t*)(sh->context))->flac_dec);
  FLAC__stream_decoder_delete(((flac_struct_t*)(sh->context))->flac_dec);
  // again: you don't have to free() a_in_buffer here! it's done by the core.
}

static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen){
	FLAC__StreamDecoderState decstate;
	FLAC__bool status;

  // audio decoding. the most important thing :)
  // parameters you get:
  //  buf = pointer to the output buffer, you have to store uncompressed 
  //        samples there
  //  minlen = requested minimum size (in bytes!) of output. it's just a
  //        _recommendation_, you can decode more or less, it just tell you that
  //        the caller process needs 'minlen' bytes. if it gets less, it will
  //        call decode_audio() again.
  //  maxlen = maximum size (bytes) of output. you MUST NOT write more to the
  //        buffer, it's the upper-most limit!
  //        note: maxlen will be always greater or equal to sh->audio_out_minsize

// Store params in private context for callback:
	((flac_struct_t*)(sh_audio->context))->buf = buf;
	((flac_struct_t*)(sh_audio->context))->minlen = minlen;
	((flac_struct_t*)(sh_audio->context))->maxlen = maxlen;
	((flac_struct_t*)(sh_audio->context))->written = 0;

	status = FLAC__stream_decoder_process_single(((flac_struct_t*)(sh_audio->context))->flac_dec);
	decstate = FLAC__stream_decoder_get_state(((flac_struct_t*)(sh_audio->context))->flac_dec);
	if (!status || (
		decstate != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA &&
		decstate != FLAC__STREAM_DECODER_READ_METADATA &&
		decstate != FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC &&
		decstate != FLAC__STREAM_DECODER_READ_FRAME
		))
	{
		if (decstate == FLAC__STREAM_DECODER_END_OF_STREAM)
		{
			/* return what we have decoded */
			if (((flac_struct_t*)(sh_audio->context))->written != 0)
				return ((flac_struct_t*)(sh_audio->context))->written;
			mp_msg(MSGT_DECAUDIO, MSGL_V, "End of stream.\n");
			return -1;
		}
		mp_msg(MSGT_DECAUDIO, MSGL_WARN, "process_single problem: returned %s, state is %s!\n", status?"true":"false", FLAC__StreamDecoderStateString[decstate]);
		FLAC__stream_decoder_flush(((flac_struct_t*)(sh_audio->context))->flac_dec);
		return -1;
	}


  return ((flac_struct_t*)(sh_audio->context))->written; // return value: number of _bytes_ written to output buffer,
              // or -1 for EOF (or uncorrectable error)
}

static int control(sh_audio_t *sh,int cmd,void* arg, ...){
    switch(cmd){
      case ADCTRL_RESYNC_STREAM:
        // it is called once after seeking, to resync.
	// Note: sh_audio->a_in_buffer_len=0; is done _before_ this call!
	FLAC__stream_decoder_flush (((flac_struct_t*)(sh->context))->flac_dec);
	return CONTROL_TRUE;
      case ADCTRL_SKIP_FRAME:
        // it is called to skip (jump over) small amount (1/10 sec or 1 frame)
	// of audio data - used to sync audio to video after seeking
	// if you don't return CONTROL_TRUE, it will defaults to:
	//      ds_fill_buffer(sh_audio->ds);  // skip 1 demux packet
	((flac_struct_t*)(sh->context))->buf = NULL;
	((flac_struct_t*)(sh->context))->minlen =
	((flac_struct_t*)(sh->context))->maxlen = 0;
	FLAC__stream_decoder_process_single(((flac_struct_t*)(sh->context))->flac_dec);
	return CONTROL_TRUE;
    }
  return CONTROL_UNKNOWN;
}
#endif