/* * Decodes a file. */ static void wavpack_filedecode(struct decoder *decoder, const char *fname) { char error[ERRORLEN]; WavpackContext *wpc; struct replay_gain_info *replay_gain_info; wpc = WavpackOpenFileInput( fname, error, OPEN_TAGS | OPEN_WVC | OPEN_2CH_MAX | OPEN_NORMALIZE, 23 ); if (wpc == NULL) { g_warning( "failed to open WavPack file \"%s\": %s\n", fname, error ); return; } replay_gain_info = wavpack_replaygain(wpc); wavpack_decode(decoder, wpc, true, replay_gain_info); if (replay_gain_info) { replay_gain_info_free(replay_gain_info); } WavpackCloseFile(wpc); }
static Tuple * wv_probe_for_tuple(const char * filename, VFSFile * fd) { WavpackContext *ctx; Tuple *tu; char error[1024]; ctx = WavpackOpenFileInputEx(&wv_readers, fd, NULL, error, OPEN_TAGS, 0); if (ctx == NULL) return NULL; AUDDBG("starting probe of %p\n", (void *) fd); vfs_rewind(fd); tu = tuple_new_from_filename(filename); vfs_rewind(fd); tag_tuple_read(tu, fd); tuple_set_int(tu, FIELD_LENGTH, NULL, ((uint64_t) WavpackGetNumSamples(ctx) * 1000) / (uint64_t) WavpackGetSampleRate(ctx)); tuple_set_str(tu, FIELD_CODEC, NULL, "WavPack"); char * quality = wv_get_quality (ctx); tuple_set_str (tu, FIELD_QUALITY, NULL, quality); str_unref (quality); WavpackCloseFile(ctx); AUDDBG("returning tuple %p for file %p\n", (void *) tu, (void *) fd); return tu; }
void delete_tag(char *filename) { WavpackContext *ctx; char error_buff [80]; char text [256]; ctx = WavpackOpenFileInput (filename, error_buff, OPEN_TAGS | OPEN_EDIT_TAGS, 0); if (!ctx) { sprintf(text, "File \"%s\" not found or is read protected!\n", filename); xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL, NULL); return; } while (WavpackGetTagItemIndexed (ctx, 0, text, sizeof (text))) WavpackDeleteTagItem (ctx, text); if (!WavpackWriteTag (ctx)) { char text[256]; sprintf(text, "Couldn't write tag to \"%s\"!\n", filename); xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL, NULL); } WavpackCloseFile (ctx); }
void WvDecoder::Close() { if (m_Ctx != nullptr) { WavpackCloseFile(m_Ctx); m_Ctx = nullptr; } }
static gboolean gst_wavpack_enc_sink_event (GstPad * pad, GstEvent * event) { GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad)); gboolean ret = TRUE; GST_DEBUG ("Received %s event on sinkpad", GST_EVENT_TYPE_NAME (event)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: /* Encode all remaining samples and flush them to the src pads */ WavpackFlushSamples (enc->wp_context); /* Drop all remaining data, this is no complete block otherwise * it would've been pushed already */ if (enc->pending_buffer) { gst_object_unref (enc->pending_buffer); enc->pending_buffer = NULL; enc->pending_offset = 0; } /* write the MD5 sum if we have to write one */ if ((enc->md5) && (enc->md5_context)) { guchar md5_digest[16]; MD5Final (md5_digest, enc->md5_context); WavpackStoreMD5Sum (enc->wp_context, md5_digest); } /* Try to rewrite the first frame with the correct sample number */ if (enc->first_block) gst_wavpack_enc_rewrite_first_block (enc); /* close the context if not already happened */ if (enc->wp_context) { WavpackCloseFile (enc->wp_context); enc->wp_context = NULL; } ret = gst_pad_event_default (pad, event); break; case GST_EVENT_NEWSEGMENT: if (enc->wp_context) { GST_WARNING_OBJECT (enc, "got NEWSEGMENT after encoding " "already started"); } /* drop NEWSEGMENT events, we create our own when pushing * the first buffer to the pads */ gst_event_unref (event); ret = TRUE; break; default: ret = gst_pad_event_default (pad, event); break; } gst_object_unref (enc); return ret; }
static void wav_close (void *prv_data) { struct wavpack_data *data = (struct wavpack_data *)prv_data; if (data->ok) { WavpackCloseFile (data->wpc); } decoder_error_clear (&data->error); free (data); logit ("File closed"); }
static void wav_info (const char *file_name, struct file_tags *info, const int tags_sel) { char wv_error[100]; char *tag; int tag_len; WavpackContext *wpc; wpc = WavpackOpenFileInput (file_name, wv_error, OPEN_TAGS, 0); if (wpc == NULL) { logit ("wv_open error: %s", wv_error); return; } int duration = WavpackGetNumSamples (wpc) / WavpackGetSampleRate (wpc); if(tags_sel & TAGS_TIME) { info->time = duration; info->filled |= TAGS_TIME; } if(tags_sel & TAGS_COMMENTS) { if ((tag_len = WavpackGetTagItem (wpc, "title", NULL, 0)) > 0) { info->title = (char *)xmalloc (++tag_len); WavpackGetTagItem (wpc, "title", info->title, tag_len); } if ((tag_len = WavpackGetTagItem (wpc, "artist", NULL, 0)) > 0) { info->artist = (char *)xmalloc (++tag_len); WavpackGetTagItem (wpc, "artist", info->artist, tag_len); } if ((tag_len = WavpackGetTagItem (wpc, "album", NULL, 0)) > 0) { info->album = (char *)xmalloc (++tag_len); WavpackGetTagItem (wpc, "album", info->album, tag_len); } if ((tag_len = WavpackGetTagItem (wpc, "track", NULL, 0)) > 0) { tag = (char *)xmalloc (++tag_len); WavpackGetTagItem (wpc, "track", tag, tag_len); info->track = atoi (tag); free (tag); } info->filled |= TAGS_COMMENTS; } WavpackCloseFile (wpc); }
/* * Reads metainfo from the specified file. */ static struct tag * wavpack_tagdup(const char *fname) { WavpackContext *wpc; struct tag *tag; char error[ERRORLEN]; char *s; int size, allocated_size; wpc = WavpackOpenFileInput(fname, error, OPEN_TAGS, 0); if (wpc == NULL) { g_warning( "failed to open WavPack file \"%s\": %s\n", fname, error ); return NULL; } tag = tag_new(); tag->time = WavpackGetNumSamples(wpc); tag->time /= WavpackGetSampleRate(wpc); allocated_size = 0; s = NULL; for (unsigned i = 0; i < G_N_ELEMENTS(tagtypes); ++i) { size = WavpackGetTagItem(wpc, tagtypes[i].name, NULL, 0); if (size > 0) { ++size; /* EOS */ if (s == NULL) { s = g_malloc(size); allocated_size = size; } else if (size > allocated_size) { char *t = (char *)g_realloc(s, size); allocated_size = size; s = t; } WavpackGetTagItem(wpc, tagtypes[i].name, s, size); tag_add_item(tag, tagtypes[i].type, s); } } g_free(s); WavpackCloseFile(wpc); return tag; }
void soundfile_close(soundfile_t *sf) { dp(30, "sf=%p \n", sf); if (sf->t == sft_libsndfile) { sf_close(sf->p); } else { if (sf->m == sft_write) { if (!WavpackFlushSamples(sf->p)) die("WavpackFlushSamples failed: %s\n", WavpackGetErrorMessage(sf->p)); WavpackCloseFile(sf->p); fclose(sf->file); } } }
~WavpackDecoder() { if (input != NULL) { free(input); input = NULL; } if (output != NULL) { free(output); output = NULL; } if (ctx != NULL) { WavpackCloseFile(ctx); ctx = NULL; } }
void wavpack_buffer_decoder_free(wavpack_buffer_decoder* wbd) { if(wbd != NULL) { frame_stream_reader_free(wbd->fsr); wbd->fsr = NULL; frame_stream_reader_free(wbd->fsrc); wbd->fsrc = NULL; if(wbd->wpc != NULL) { WavpackCloseFile(wbd->wpc); wbd->wpc = NULL; } wp_free(wbd); } }
static gboolean gst_wavpack_dec_stop (GstAudioDecoder * dec) { GstWavpackDec *wpdec = GST_WAVPACK_DEC (dec); GST_DEBUG_OBJECT (dec, "stop"); if (wpdec->context) { WavpackCloseFile (wpdec->context); wpdec->context = NULL; } gst_wavpack_dec_reset (wpdec); return TRUE; }
void SoundSourceWV::close() { if (m_wpc) { WavpackCloseFile(m_wpc); m_wpc = nullptr; } if (m_pWVFile) { m_pWVFile->close(); delete m_pWVFile; m_pWVFile = nullptr; } if (m_pWVCFile) { m_pWVCFile->close(); delete m_pWVCFile; m_pWVCFile = nullptr; } }
static void xmms_wavpack_free_data (xmms_wavpack_data_t *data) { if (!data) { return; } if (data->buf) { g_free (data->buf); } if (data->ctx) { WavpackCloseFile (data->ctx); } g_free (data); }
void SoundSourceWV::close() { if (m_wpc) { WavpackCloseFile(m_wpc); m_wpc = nullptr; } if (m_pWVFile) { m_pWVFile->close(); delete m_pWVFile; m_pWVFile = nullptr; } if (m_pWVCFile) { m_pWVCFile->close(); delete m_pWVCFile; m_pWVCFile = nullptr; } m_curFrameIndex = getMinFrameIndex(); }
bool WavPackDecoder::Close(CFErrorRef */*error*/) { if(!IsOpen()) { LOGGER_WARNING("org.sbooth.AudioEngine.AudioDecoder.WavPack", "Close() called on an AudioDecoder that hasn't been opened"); return true; } memset(&mStreamReader, 0, sizeof(mStreamReader)); if(mWPC) WavpackCloseFile(mWPC), mWPC = nullptr; if(mBuffer) free(mBuffer), mBuffer = nullptr; mIsOpen = false; return true; }
static void wv_get_song_info(char *filename, char **title, int *length) { assert(filename != NULL); char error_buff[80]; WavpackContext *ctx = WavpackOpenFileInput(filename, error_buff, OPEN_TAGS | OPEN_WVC, 0); if (ctx == NULL) { printf("wavpack: Error opening file: \"%s: %s\"\n", filename, error_buff); return; } int sample_rate = WavpackGetSampleRate(ctx); int num_channels = WavpackGetNumChannels(ctx); DBG("reading %s at %d rate with %d channels\n", filename, sample_rate, num_channels); *length = (int)(WavpackGetNumSamples(ctx) / sample_rate) * 1000, *title = generate_title(filename, ctx); DBG("title for %s = %s\n", filename, *title); WavpackCloseFile(ctx); }
bool WavPackDecoder::Close(CFErrorRef */*error*/) { if(!IsOpen()) { log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioDecoder.WavPack"); LOG4CXX_WARN(logger, "Close() called on an AudioDecoder that hasn't been opened"); return true; } memset(&mStreamReader, 0, sizeof(mStreamReader)); if(mWPC) WavpackCloseFile(mWPC), mWPC = NULL; if(mBuffer) free(mBuffer), mBuffer = NULL; mIsOpen = false; return true; }
static void gst_wavpack_enc_reset (GstWavpackEnc * enc) { /* close and free everything stream related if we already did something */ if (enc->wp_context) { WavpackCloseFile (enc->wp_context); enc->wp_context = NULL; } if (enc->wp_config) { g_free (enc->wp_config); enc->wp_config = NULL; } if (enc->first_block) { g_free (enc->first_block); enc->first_block = NULL; } enc->first_block_size = 0; if (enc->md5_context) { g_checksum_free (enc->md5_context); enc->md5_context = NULL; } if (enc->pending_buffer) { gst_buffer_unref (enc->pending_buffer); enc->pending_buffer = NULL; enc->pending_offset = 0; } /* reset the last returns to GST_FLOW_OK. This is only set to something else * while WavpackPackSamples() or more specific gst_wavpack_enc_push_block() * so not valid anymore */ enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK; /* reset stream information */ enc->samplerate = 0; enc->depth = 0; enc->channels = 0; enc->channel_mask = 0; enc->need_channel_remap = FALSE; enc->timestamp_offset = GST_CLOCK_TIME_NONE; enc->next_ts = GST_CLOCK_TIME_NONE; }
static void wv_free (DB_fileinfo_t *_info) { if (_info) { wvctx_t *info = (wvctx_t *)_info; if (info->file) { deadbeef->fclose (info->file); info->file = NULL; } #ifndef TINYWV if (info->c_file) { deadbeef->fclose (info->c_file); info->c_file = NULL; } #endif if (info->ctx) { WavpackCloseFile (info->ctx); info->ctx = NULL; } free (_info); } }
gboolean Wavpack_Header_Read_File_Info(gchar *filename, ET_File_Info *ETFileInfo) { WavpackContext *wpc; wpc = WavpackOpenFileInput(filename, NULL, 0, 0); if ( wpc == NULL ) { return FALSE; } ETFileInfo->version = WavpackGetVersion(wpc); /* .wvc correction file not counted */ ETFileInfo->bitrate = WavpackGetAverageBitrate(wpc, 0)/1000; ETFileInfo->samplerate = WavpackGetSampleRate(wpc); ETFileInfo->mode = WavpackGetNumChannels(wpc); ETFileInfo->size = WavpackGetFileSize(wpc); ETFileInfo->duration = WavpackGetNumSamples(wpc)/ETFileInfo->samplerate; WavpackCloseFile(wpc); return TRUE; }
/* * Decodes a stream. */ static void wavpack_streamdecode(struct decoder * decoder, struct input_stream *is) { char error[ERRORLEN]; WavpackContext *wpc; struct input_stream *is_wvc; int open_flags = OPEN_NORMALIZE; struct wavpack_input isp, isp_wvc; bool can_seek = is->seekable; is_wvc = wavpack_open_wvc(decoder, is->uri, &isp_wvc); if (is_wvc != NULL) { open_flags |= OPEN_WVC; can_seek &= is_wvc->seekable; } if (!can_seek) { open_flags |= OPEN_STREAMING; } wavpack_input_init(&isp, decoder, is); wpc = WavpackOpenFileInputEx( &mpd_is_reader, &isp, open_flags & OPEN_WVC ? &isp_wvc : NULL, error, open_flags, 23 ); if (wpc == NULL) { g_warning("failed to open WavPack stream: %s\n", error); return; } wavpack_decode(decoder, wpc, can_seek); WavpackCloseFile(wpc); if (open_flags & OPEN_WVC) { input_stream_close(is_wvc); } }
static GstStateChangeReturn gst_wavpack_dec_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstWavpackDec *dec = GST_WAVPACK_DEC (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: if (dec->context) { WavpackCloseFile (dec->context); dec->context = NULL; } gst_wavpack_dec_reset (dec); break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; }
void read_wavpack_file (gchar *filename) { WavpackContext *wpc; gchar *field; guint length; int open_flags = OPEN_TAGS; wpc = WavpackOpenFileInput(filename, NULL, open_flags, 0); if ( wpc == NULL ) { fprintf (stderr, "Error: open %s as wavpack failed\n", filename); return; } /* title */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "title", field, MAXLEN); if ( length > 0 ) printf ("title: %s\n", field); g_free (field); WavpackCloseFile(wpc); }
gboolean Wavpack_Tag_Write_File_Tag (ET_File *ETFile) { WavpackContext *wpc; gchar *filename = ((File_Name *)((GList *)ETFile->FileNameCur)->data)->value; File_Tag *FileTag = (File_Tag *)ETFile->FileTag->data; gchar *buffer; int open_flags = OPEN_EDIT_TAGS; g_return_val_if_fail (ETFile != NULL && ETFile->FileTag != NULL, FALSE); wpc = WavpackOpenFileInput(filename, NULL, open_flags, 0); if ( wpc == NULL ) { return FALSE; } /* * Title */ if (FileTag->title && WavpackAppendTagItem(wpc, "title", FileTag->title, strlen(FileTag->title)) == 0) { return FALSE; } /* * Artist */ if (FileTag->artist && WavpackAppendTagItem(wpc, "artist", FileTag->artist, strlen(FileTag->artist)) == 0) { return FALSE; } /* * Album */ if (FileTag->album && WavpackAppendTagItem(wpc, "album", FileTag->album, strlen(FileTag->album)) == 0) { return FALSE; } /* * Discnumber */ if (FileTag->disc_number && FileTag->disc_total) { buffer = g_strdup_printf ("%s/%s", FileTag->disc_number, FileTag->disc_total); if (WavpackAppendTagItem (wpc, "part", buffer, strlen (buffer)) == 0) { g_free (buffer); return FALSE; } else { g_free (buffer); } } else { if (FileTag->disc_number && WavpackAppendTagItem (wpc, "part", FileTag->disc_number, strlen (FileTag->disc_number)) == 0) { return FALSE; } } /* * Year */ if (FileTag->year && WavpackAppendTagItem(wpc, "year", FileTag->year, strlen(FileTag->year)) == 0) { return FALSE; } /* * Tracknumber + tracktotal */ if (FileTag->track_total) { buffer = g_strdup_printf("%s/%s", FileTag->track, FileTag->track_total); if (FileTag->track && WavpackAppendTagItem(wpc, "track", buffer, strlen(buffer)) == 0) { g_free(buffer); return FALSE; } else { g_free(buffer); } } else { if (FileTag->track && WavpackAppendTagItem(wpc, "track", FileTag->track, strlen(FileTag->track)) == 0) { return FALSE; } } /* * Genre */ if (FileTag->genre && WavpackAppendTagItem(wpc, "genre", FileTag->genre, strlen(FileTag->genre)) == 0) { return FALSE; } /* * Comment */ if (FileTag->comment && WavpackAppendTagItem(wpc, "comment", FileTag->comment, strlen(FileTag->comment)) == 0) { return FALSE; } /* * Composer */ if (FileTag->composer && WavpackAppendTagItem(wpc, "composer", FileTag->composer, strlen(FileTag->composer)) == 0) { return FALSE; } /* * Original artist */ if (FileTag->orig_artist && WavpackAppendTagItem(wpc, "original artist", FileTag->orig_artist, strlen(FileTag->orig_artist)) == 0) { return FALSE; } /* * Copyright */ if (FileTag->copyright && WavpackAppendTagItem(wpc, "copyright", FileTag->copyright, strlen(FileTag->copyright)) == 0) { return FALSE; } /* * URL */ if (FileTag->url && WavpackAppendTagItem(wpc, "copyright url", FileTag->url, strlen(FileTag->url)) == 0) { return FALSE; } /* * Encoded by */ if (FileTag->encoded_by && WavpackAppendTagItem(wpc, "encoded by", FileTag->encoded_by, strlen(FileTag->encoded_by)) == 0) { return FALSE; } WavpackWriteTag(wpc); WavpackCloseFile(wpc); return TRUE; }
/* * Read tag data from a Wavpack file. */ gboolean Wavpack_Tag_Read_File_Tag (gchar *filename, File_Tag *FileTag) { WavpackContext *wpc; gchar *field, *field2; guint length; int open_flags = OPEN_TAGS; g_return_val_if_fail (filename != NULL && FileTag != NULL, FALSE); wpc = WavpackOpenFileInput(filename, NULL, open_flags, 0); if ( wpc == NULL ) { return FALSE; } /* * Title */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "title", field, MAXLEN); if ( length > 0 && FileTag->title == NULL ) { FileTag->title = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Artist */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "artist", field, MAXLEN); if ( length > 0 && FileTag->artist == NULL) { FileTag->artist = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Album */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "album", field, MAXLEN); if ( length > 0 && FileTag->album == NULL ) { FileTag->album = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Discnumber + Disctotal. */ field = g_malloc0 (sizeof (char) * MAXLEN); length = WavpackGetTagItem (wpc, "part", field, MAXLEN); field2 = g_utf8_strchr (field, -1, '/'); /* Need to cut off the total tracks if present */ if (field2) { *field2 = 0; field2++; } if (field2 && FileTag->disc_total == NULL) { FileTag->disc_total = et_disc_number_to_string (atoi (Try_To_Validate_Utf8_String (field2))); } if (length > 0 && FileTag->disc_number == NULL) { FileTag->disc_number = et_disc_number_to_string (atoi (Try_To_Validate_Utf8_String (field))); } g_free (field); /* * Year */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "year", field, MAXLEN); if ( length > 0 && FileTag->year == NULL ) { FileTag->year = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Tracknumber + tracktotal */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "track", field, MAXLEN); field2 = g_utf8_strchr(field, -1, '/'); /* Need to cut off the total tracks if present */ if (field2) { *field2 = 0; field2++; } if (field2 && FileTag->track_total == NULL) { FileTag->track_total = et_track_number_to_string (atoi (Try_To_Validate_Utf8_String (field2))); } if (length > 0 && FileTag->track == NULL) { FileTag->track = et_track_number_to_string (atoi (Try_To_Validate_Utf8_String (field))); } g_free (field); /* * Genre */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "genre", field, MAXLEN); if ( length > 0 && FileTag->genre == NULL ) { FileTag->genre = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Comment */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "comment", field, MAXLEN); if ( length > 0 && FileTag->comment == NULL ) { FileTag->comment = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Composer */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "composer", field, MAXLEN); if ( length > 0 && FileTag->composer == NULL ) { FileTag->composer = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Original artist */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "original artist", field, MAXLEN); if ( length > 0 && FileTag->orig_artist == NULL ) { FileTag->orig_artist = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Copyright */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "copyright", field, MAXLEN); if ( length > 0 && FileTag->copyright == NULL ) { FileTag->copyright = Try_To_Validate_Utf8_String(field); } g_free (field); /* * URL */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "copyright url", field, MAXLEN); if ( length > 0 && FileTag->url == NULL ) { FileTag->url = Try_To_Validate_Utf8_String(field); } g_free (field); /* * Encoded by */ field = g_malloc0(sizeof(char) * MAXLEN); length = WavpackGetTagItem(wpc, "encoded by", field, MAXLEN); if ( length > 0 && FileTag->encoded_by == NULL ) { FileTag->encoded_by = Try_To_Validate_Utf8_String(field); } g_free (field); WavpackCloseFile(wpc); return TRUE; }
void SoundSourceWV::close() { if (m_wpc) { WavpackCloseFile(m_wpc); m_wpc = NULL; } }
static void wv_deattach (VFSFile * wvc_input, WavpackContext * ctx) { if (wvc_input != NULL) vfs_fclose(wvc_input); WavpackCloseFile(ctx); }
static GstFlowReturn gst_wavpack_enc_chain (GstPad * pad, GstBuffer * buf) { GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad)); uint32_t sample_count = GST_BUFFER_SIZE (buf) / 4; GstFlowReturn ret; /* reset the last returns to GST_FLOW_OK. This is only set to something else * while WavpackPackSamples() or more specific gst_wavpack_enc_push_block() * so not valid anymore */ enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK; GST_DEBUG ("got %u raw samples", sample_count); /* check if we already have a valid WavpackContext, otherwise make one */ if (!enc->wp_context) { /* create raw context */ enc->wp_context = WavpackOpenFileOutput (gst_wavpack_enc_push_block, &enc->wv_id, (enc->correction_mode > 0) ? &enc->wvc_id : NULL); if (!enc->wp_context) { GST_ELEMENT_ERROR (enc, LIBRARY, INIT, (NULL), ("error creating Wavpack context")); gst_object_unref (enc); gst_buffer_unref (buf); return GST_FLOW_ERROR; } /* set the WavpackConfig according to our parameters */ gst_wavpack_enc_set_wp_config (enc); /* set the configuration to the context now that we know everything * and initialize the encoder */ if (!WavpackSetConfiguration (enc->wp_context, enc->wp_config, (uint32_t) (-1)) || !WavpackPackInit (enc->wp_context)) { GST_ELEMENT_ERROR (enc, LIBRARY, SETTINGS, (NULL), ("error setting up wavpack encoding context")); WavpackCloseFile (enc->wp_context); gst_object_unref (enc); gst_buffer_unref (buf); return GST_FLOW_ERROR; } GST_DEBUG ("setup of encoding context successfull"); } /* Save the timestamp of the first buffer. This will be later * used as offset for all following buffers */ if (enc->timestamp_offset == GST_CLOCK_TIME_NONE) { if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) { enc->timestamp_offset = GST_BUFFER_TIMESTAMP (buf); enc->next_ts = GST_BUFFER_TIMESTAMP (buf); } else { enc->timestamp_offset = 0; enc->next_ts = 0; } } /* Check if we have a continous stream, if not drop some samples or the buffer or * insert some silence samples */ if (enc->next_ts != GST_CLOCK_TIME_NONE && GST_BUFFER_TIMESTAMP (buf) < enc->next_ts) { guint64 diff = enc->next_ts - GST_BUFFER_TIMESTAMP (buf); guint64 diff_bytes; GST_WARNING_OBJECT (enc, "Buffer is older than previous " "timestamp + duration (%" GST_TIME_FORMAT "< %" GST_TIME_FORMAT "), cannot handle. Clipping buffer.", GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_TIME_ARGS (enc->next_ts)); diff_bytes = GST_CLOCK_TIME_TO_FRAMES (diff, enc->samplerate) * enc->channels * 2; if (diff_bytes >= GST_BUFFER_SIZE (buf)) { gst_buffer_unref (buf); return GST_FLOW_OK; } buf = gst_buffer_make_metadata_writable (buf); GST_BUFFER_DATA (buf) += diff_bytes; GST_BUFFER_SIZE (buf) -= diff_bytes; GST_BUFFER_TIMESTAMP (buf) += diff; if (GST_BUFFER_DURATION_IS_VALID (buf)) GST_BUFFER_DURATION (buf) -= diff; } /* Allow a diff of at most 5 ms */ if (enc->next_ts != GST_CLOCK_TIME_NONE && GST_BUFFER_TIMESTAMP_IS_VALID (buf)) { if (GST_BUFFER_TIMESTAMP (buf) != enc->next_ts && GST_BUFFER_TIMESTAMP (buf) - enc->next_ts > 5 * GST_MSECOND) { GST_WARNING_OBJECT (enc, "Discontinuity detected: %" G_GUINT64_FORMAT " > %" G_GUINT64_FORMAT, GST_BUFFER_TIMESTAMP (buf) - enc->next_ts, 5 * GST_MSECOND); WavpackFlushSamples (enc->wp_context); enc->timestamp_offset += (GST_BUFFER_TIMESTAMP (buf) - enc->next_ts); } } if (GST_BUFFER_TIMESTAMP_IS_VALID (buf) && GST_BUFFER_DURATION_IS_VALID (buf)) enc->next_ts = GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf); else enc->next_ts = GST_CLOCK_TIME_NONE; if (enc->need_channel_remap) { buf = gst_buffer_make_writable (buf); gst_wavpack_enc_fix_channel_order (enc, (gint32 *) GST_BUFFER_DATA (buf), sample_count); } /* if we want to append the MD5 sum to the stream update it here * with the current raw samples */ if (enc->md5) { g_checksum_update (enc->md5_context, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); } /* encode and handle return values from encoding */ if (WavpackPackSamples (enc->wp_context, (int32_t *) GST_BUFFER_DATA (buf), sample_count / enc->channels)) { GST_DEBUG ("encoding samples successful"); ret = GST_FLOW_OK; } else { if ((enc->srcpad_last_return == GST_FLOW_RESEND) || (enc->wvcsrcpad_last_return == GST_FLOW_RESEND)) { ret = GST_FLOW_RESEND; } else if ((enc->srcpad_last_return == GST_FLOW_OK) || (enc->wvcsrcpad_last_return == GST_FLOW_OK)) { ret = GST_FLOW_OK; } else if ((enc->srcpad_last_return == GST_FLOW_NOT_LINKED) && (enc->wvcsrcpad_last_return == GST_FLOW_NOT_LINKED)) { ret = GST_FLOW_NOT_LINKED; } else if ((enc->srcpad_last_return == GST_FLOW_WRONG_STATE) && (enc->wvcsrcpad_last_return == GST_FLOW_WRONG_STATE)) { ret = GST_FLOW_WRONG_STATE; } else { GST_ELEMENT_ERROR (enc, LIBRARY, ENCODE, (NULL), ("encoding samples failed")); ret = GST_FLOW_ERROR; } } gst_buffer_unref (buf); gst_object_unref (enc); return ret; }
void update_tag(ape_tag *tag, char *filename) { WavpackContext *ctx; char error_buff [80]; ctx = WavpackOpenFileInput (filename, error_buff, OPEN_TAGS | OPEN_EDIT_TAGS, 0); if (!ctx) { char text[256]; sprintf(text, "File \"%s\" not found or is read protected!\n", filename); xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL, NULL); return; } if (strlen (tag->album)) WavpackAppendTagItem (ctx, "Album", tag->album, strlen (tag->album)); else WavpackDeleteTagItem (ctx, "Album"); if (strlen (tag->artist)) WavpackAppendTagItem (ctx, "Artist", tag->artist, strlen (tag->artist)); else WavpackDeleteTagItem (ctx, "Artist"); if (strlen (tag->comment)) WavpackAppendTagItem (ctx, "Comment", tag->comment, strlen (tag->comment)); else WavpackDeleteTagItem (ctx, "Comment"); if (strlen (tag->genre)) WavpackAppendTagItem (ctx, "Genre", tag->genre, strlen (tag->genre)); else WavpackDeleteTagItem (ctx, "Genre"); if (strlen (tag->title)) WavpackAppendTagItem (ctx, "Title", tag->title, strlen (tag->title)); else WavpackDeleteTagItem (ctx, "Title"); if (strlen (tag->track)) WavpackAppendTagItem (ctx, "Track", tag->track, strlen (tag->track)); else WavpackDeleteTagItem (ctx, "Track"); if (strlen (tag->year)) WavpackAppendTagItem (ctx, "Year", tag->year, strlen (tag->year)); else WavpackDeleteTagItem (ctx, "Year"); if (!WavpackWriteTag (ctx)) { char text[256]; sprintf(text, "Couldn't write tag to \"%s\"!\n", filename); xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL, NULL); } WavpackCloseFile (ctx); }