diff options
Diffstat (limited to 'audio/xmcd')
| -rw-r--r-- | audio/xmcd/Makefile | 4 | ||||
| -rw-r--r-- | audio/xmcd/files/patch-ak | 519 |
2 files changed, 521 insertions, 2 deletions
diff --git a/audio/xmcd/Makefile b/audio/xmcd/Makefile index ee8a251a13d9..5a0ab89ce338 100644 --- a/audio/xmcd/Makefile +++ b/audio/xmcd/Makefile @@ -7,7 +7,7 @@ PORTNAME= xmcd PORTVERSION= 3.3.2 -PORTREVISION= 6 +PORTREVISION= 7 CATEGORIES= audio MASTER_SITES= http://www.ibiblio.org/tkan/download/xmcd/3.3.2/src/ @@ -15,7 +15,7 @@ MAINTAINER= eischen@vigrid.com COMMENT= Motif CD player LIB_DEPENDS+= vorbis.4:${PORTSDIR}/audio/libvorbis \ - FLAC.7:${PORTSDIR}/audio/flac + FLAC.10:${PORTSDIR}/audio/flac RUN_DEPENDS+= lame:${PORTSDIR}/audio/lame USE_MOTIF= yes diff --git a/audio/xmcd/files/patch-ak b/audio/xmcd/files/patch-ak new file mode 100644 index 000000000000..3dcc0de9352c --- /dev/null +++ b/audio/xmcd/files/patch-ak @@ -0,0 +1,519 @@ +--- cdda_d/if_flac.c.orig 2008-04-06 21:14:40.000000000 +0200 ++++ cdda_d/if_flac.c 2008-04-06 22:11:17.000000000 +0200 +@@ -57,7 +57,6 @@ typedef float FLAC__real; + #include <FLAC/format.h> + #include <FLAC/metadata.h> + #include <FLAC/stream_encoder.h> +-#include <FLAC/seekable_stream_encoder.h> + + + extern appdata_t app_data; +@@ -86,7 +85,6 @@ extern char *tagcomment; /* Tag commen + /* Container union for encoder instance pointers */ + typedef union { + FLAC__StreamEncoder *st; /* Stream encoder */ +- FLAC__SeekableStreamEncoder *sk; /* Seekable stream encoder */ + } flac_desc_t; + + +@@ -153,76 +151,10 @@ if_flac_write_callback( + + + /* +- * if_flac_seekable_write_callback +- * FLAC seekable stream encoder write callback function +- * +- * Args: +- * skp - Seekable stream encoder instance descriptor +- * buf - Output data buffer +- * len - data length +- * samples - number of samples +- * frame - Current frame +- * client_data - Callback data +- * +- * Return: +- * FLAC__STREAM_ENCODER_WRITE_STATUS_OK - success +- * FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR - failure +- */ +-/*ARGSUSED*/ +-STATIC FLAC__StreamEncoderWriteStatus +-if_flac_seekable_write_callback( +- const FLAC__SeekableStreamEncoder *skp, +- const FLAC__byte *buf, +- unsigned int len, +- unsigned int samples, +- unsigned int frame, +- void *client_data +-) +-{ +- gen_desc_t *gdp = (gen_desc_t *) client_data; +- +- if (buf == NULL || len == 0) +- /* Nothing to do */ +- return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; +- +- /* Write out the encoded data */ +- gdp->flags |= GDESC_WRITEOUT; +- if (!gen_write_chunk(gdp, (byte_t *) buf, (size_t) len)) +- return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; +- +- return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; +-} +- +- +-/* + * if_flac_metadata_callback + * FLAC stream encoder metadata callback function + * + * Args: +- * stp - Encoder instance descriptor +- * data - Metadata buffer +- * client_data - Callback data +- * +- * Return: +- * Nothing. +- */ +-/*ARGSUSED*/ +-STATIC void +-if_flac_metadata_callback( +- const FLAC__StreamEncoder *stp, +- const FLAC__StreamMetadata *meta, +- void *client_data +-) +-{ +- /* Do nothing: can't seek on a pipe */ +-} +- +- +-/* +- * if_flac_seek_callback +- * FLAC seekable stream encoder seek callback function +- * +- * Args: + * skp - Encoder instance descriptor + * data - Metadata buffer + * client_data - Callback data +@@ -231,9 +163,9 @@ if_flac_metadata_callback( + * Nothing. + */ + /*ARGSUSED*/ +-STATIC FLAC__SeekableStreamEncoderSeekStatus +-if_flac_seek_callback( +- const FLAC__SeekableStreamEncoder *skp, ++STATIC FLAC__StreamEncoderSeekStatus ++if_flac_metadata_callback( ++ const FLAC__StreamEncoder *skp, + FLAC__uint64 offset, + void *client_data + ) +@@ -244,9 +176,9 @@ if_flac_seek_callback( + val = (off_t) ASSIGN32(offset); + + if (gen_seek(gdp, val, SEEK_SET)) +- return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK; ++ return FLAC__STREAM_ENCODER_SEEK_STATUS_OK; + else +- return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR; ++ return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR; + } + + +@@ -635,16 +567,9 @@ if_flac_addmeta(gen_desc_t *gdp, flac_de + if (flac_mblks == 0) + return; /* No metadata to set */ + +- if ((gdp->flags & GDESC_ISPIPE) != 0) { +- ret = FLAC__stream_encoder_set_metadata( +- ufdp->st, flac_mlist, flac_mblks +- ); +- } +- else { +- ret = FLAC__seekable_stream_encoder_set_metadata( +- ufdp->sk, flac_mlist, flac_mblks +- ); +- } ++ ret = FLAC__stream_encoder_set_metadata( ++ ufdp->st, flac_mlist, flac_mblks ++ ); + if (!ret) { + (void) strcpy(gdp->cdp->i->msgbuf, + "if_flac_addmeta: Failed setting metadata."); +@@ -655,7 +580,7 @@ if_flac_addmeta(gen_desc_t *gdp, flac_de + + /* + * if_flac_encoder_setup +- * Create and set up the FLAC stream encoder (used for pipe output). ++ * Create and set up the FLAC stream encoder. + * + * Args: + * gdp - Pointer to the gen_desc_t structure +@@ -836,43 +761,12 @@ if_flac_encoder_setup( + /* Initialize and add metadata to FLAC output */ + if_flac_addmeta(gdp, ufdp); + +- /* Register write callback function */ +- ret = FLAC__stream_encoder_set_write_callback( +- stp, if_flac_write_callback +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_encoder_setup: " +- "Failed setting write callback."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Register metadata callback function */ +- ret = FLAC__stream_encoder_set_metadata_callback( +- stp, if_flac_metadata_callback +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_encoder_setup: " +- "Failed setting metadata callback."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Set callback argument */ +- ret = FLAC__stream_encoder_set_client_data(stp, gdp); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_encoder_setup: " +- "Failed setting client data."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- + /* Initialize FLAC encoder */ +- enc_state = FLAC__stream_encoder_init(stp); +- if (enc_state != FLAC__STREAM_ENCODER_OK) { ++ enc_state = FLAC__stream_encoder_init_stream( ++ stp, if_flac_write_callback, NULL, NULL, ++ if_flac_metadata_callback, gdp ++ ); ++ if (enc_state != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { + (void) sprintf(gdp->cdp->i->msgbuf, + "if_flac_encoder_setup: Encoder init error: %s", + FLAC__stream_encoder_get_resolved_state_string(stp) +@@ -908,271 +802,6 @@ if_flac_encoder_setup( + + + /* +- * if_flac_seekable_encoder_setup +- * Create and set up the FLAC seekable stream encoder (used for file +- * output). +- * +- * Args: +- * gdp - Pointer to the gen_desc_t structure +- * ufdp - Pointer to the flac_desc_t structure +- * pp - Pointer to the flac_parms_t structure +- * +- * Return: +- * TRUE - success +- * FALSE - failure +- */ +-STATIC bool_t +-if_flac_seekable_encoder_setup( +- gen_desc_t *gdp, +- flac_desc_t *ufdp, +- flac_parms_t *pp +-) +-{ +- FLAC__SeekableStreamEncoder *skp; +- FLAC__SeekableStreamEncoderState enc_state; +- FLAC__uint64 val; +- FLAC__bool ret; +- +- ufdp->sk = skp = FLAC__seekable_stream_encoder_new(); +- if (skp == NULL) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "FLAC encoder instantiation failed."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Set some basic parameters */ +- +- ret = FLAC__seekable_stream_encoder_set_channels(skp, 2); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting channels."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_bits_per_sample(skp, 16); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting bits per sample."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_sample_rate(skp, 44100); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting sample rate."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- val = ASSIGN64(gdp->datalen >> 2); +- ret = FLAC__seekable_stream_encoder_set_total_samples_estimate( +- skp, val +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting samples estimate."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_streamable_subset(skp, TRUE); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting streamable subset."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search( +- skp, pp->qlp_srch +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting LP coefficient quantization search." +- ); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Just use default for now +- ret = FLAC__seekable_stream_encoder_set_qlp_coeff_precision(skp, 0); +- */ +- +- ret = FLAC__seekable_stream_encoder_set_verify(skp, pp->vfy_mode); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting verify mode."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_max_lpc_order( +- skp, pp->lpc_order +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting max LPC order."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_blocksize(skp, pp->block_sz); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting block size."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_do_mid_side_stereo( +- skp, pp->mid_side +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting M/S stereo."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- ret = FLAC__seekable_stream_encoder_set_loose_mid_side_stereo( +- skp, pp->adap_ms +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting adaptive M/S stereo."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- if (pp->min_rpo >= 0) { +- ret = FLAC__seekable_stream_encoder_set_min_residual_partition_order( +- skp, (unsigned int) pp->min_rpo +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting minimum RPO."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- } +- +- if (pp->max_rpo >= 0) { +- ret = FLAC__seekable_stream_encoder_set_max_residual_partition_order( +- skp, (unsigned int) pp->max_rpo +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting maximum RPO."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- } +- +- ret = FLAC__seekable_stream_encoder_set_do_exhaustive_model_search( +- skp, pp->exh_srch +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting exhaustive model search."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Initialize and add metadata to FLAC output */ +- if_flac_addmeta(gdp, ufdp); +- +- /* Register write callback function */ +- ret = FLAC__seekable_stream_encoder_set_write_callback( +- skp, if_flac_seekable_write_callback +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting write callback."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Register seek callback function */ +- ret = FLAC__seekable_stream_encoder_set_seek_callback( +- skp, if_flac_seek_callback +- ); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting seek callback."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Set callback argument */ +- ret = FLAC__seekable_stream_encoder_set_client_data(skp, gdp); +- if (!ret) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Failed setting client data."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Initialize FLAC encoder */ +- enc_state = FLAC__seekable_stream_encoder_init(skp); +- if (enc_state != FLAC__SEEKABLE_STREAM_ENCODER_OK) { +- (void) sprintf(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: Encoder init error: %s", +- FLAC__seekable_stream_encoder_get_resolved_state_string(skp) +- ); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- /* Allocate wide samples buffers for the two channels */ +- fenc_buf[0] = (FLAC__int32 *) MEM_ALLOC( +- "fenc_buf0", +- (size_t) gdp->cdp->cds->chunk_bytes +- ); +- if (fenc_buf[0] == NULL) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Out of memory."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- fenc_buf[1] = (FLAC__int32 *) MEM_ALLOC( +- "fenc_buf1", +- (size_t) gdp->cdp->cds->chunk_bytes +- ); +- if (fenc_buf[1] == NULL) { +- (void) strcpy(gdp->cdp->i->msgbuf, +- "if_flac_seekable_encoder_setup: " +- "Out of memory."); +- DBGPRN(DBG_SND)(errfp, "%s\n", gdp->cdp->i->msgbuf); +- return FALSE; +- } +- +- return TRUE; +-} +- +- +-/* + * if_flac_init + * Initialize FLAC encoder and set up encoding parameters + * +@@ -1300,10 +929,7 @@ if_flac_init(gen_desc_t *gdp) + } + + /* Set up encoder */ +- if ((gdp->flags & GDESC_ISPIPE) != 0) +- ret = if_flac_encoder_setup(gdp, ufdp, &parms); +- else +- ret = if_flac_seekable_encoder_setup(gdp, ufdp, &parms); ++ ret = if_flac_encoder_setup(gdp, ufdp, &parms); + + return (ret); + } +@@ -1351,16 +977,9 @@ if_flac_encode_chunk(gen_desc_t *gdp, by + + DBGPRN(DBG_SND)(errfp, "\nEncoding %d samples\n", samples); + +- if ((gdp->flags & GDESC_ISPIPE) != 0) { +- ret = FLAC__stream_encoder_process( +- ufdp->st, (void *) fenc_buf, (unsigned int) samples +- ); +- } +- else { +- ret = FLAC__seekable_stream_encoder_process( +- ufdp->sk, (void *) fenc_buf, (unsigned int) samples +- ); +- } ++ ret = FLAC__stream_encoder_process( ++ ufdp->st, (void *) fenc_buf, (unsigned int) samples ++ ); + if (!ret) { + (void) strcpy(gdp->cdp->i->msgbuf, + "if_flac_encode_chunk: Process encoding failed."); +@@ -1393,14 +1012,8 @@ if_flac_halt(gen_desc_t *gdp) + + ufdp = (flac_desc_t *) gdp->aux; + +- if ((gdp->flags & GDESC_ISPIPE) != 0) { +- FLAC__stream_encoder_finish(ufdp->st); +- FLAC__stream_encoder_delete(ufdp->st); +- } +- else { +- FLAC__seekable_stream_encoder_finish(ufdp->sk); +- FLAC__seekable_stream_encoder_delete(ufdp->sk); +- } ++ FLAC__stream_encoder_finish(ufdp->st); ++ FLAC__stream_encoder_delete(ufdp->st); + + MEM_FREE(ufdp); + gdp->aux = NULL; |