Lines Matching defs:psf
73 static int alac_reader_init (SF_PRIVATE *psf, const ALAC_DECODER_INFO * info) ;
74 static int alac_writer_init (SF_PRIVATE *psf) ;
76 static sf_count_t alac_reader_calc_frames (SF_PRIVATE *psf, ALAC_PRIVATE *plac) ;
78 static sf_count_t alac_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
79 static sf_count_t alac_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
80 static sf_count_t alac_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
81 static sf_count_t alac_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
83 static sf_count_t alac_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
84 static sf_count_t alac_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
85 static sf_count_t alac_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
86 static sf_count_t alac_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
88 static sf_count_t alac_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;
90 static int alac_close (SF_PRIVATE *psf) ;
91 static int alac_byterate (SF_PRIVATE *psf) ;
93 static int alac_decode_block (SF_PRIVATE *psf, ALAC_PRIVATE *plac) ;
96 static uint32_t alac_kuki_read (SF_PRIVATE * psf, uint32_t kuki_offset, uint8_t * kuki, size_t kuki_maxlen) ;
99 static PAKT_INFO * alac_pakt_read_decode (SF_PRIVATE * psf, uint32_t pakt_offset) ;
101 static uint8_t * alac_pakt_encode (const SF_PRIVATE *psf, uint32_t * pakt_size) ;
111 alac_init (SF_PRIVATE *psf, const ALAC_DECODER_INFO * info)
114 if ((psf->codec_data = calloc (1, sizeof (ALAC_PRIVATE) + psf->sf.channels * sizeof (int) * ALAC_MAX_FRAME_SIZE)) == NULL)
117 psf->codec_close = alac_close ;
119 switch (psf->file.mode)
124 if ((error = alac_reader_init (psf, info)))
129 if ((error = alac_writer_init (psf)))
134 psf_log_printf (psf, "%s : Bad psf->file.mode.\n", __func__) ;
138 psf->byterate = alac_byterate ;
165 alac_close (SF_PRIVATE *psf)
169 plac = psf->codec_data ;
171 if (psf->file.mode == SFM_WRITE)
193 psf_save_write_chunk (&psf->wchunks, &chunk_info) ;
197 chunk_info.data = alac_pakt_encode (psf, &pakt_size) ;
199 psf_save_write_chunk (&psf->wchunks, &chunk_info) ;
204 psf->write_header (psf, 1) ;
210 psf_fwrite (ubuf.ucbuf, 1, readcount, psf) ;
224 alac_byterate (SF_PRIVATE *psf)
226 if (psf->file.mode == SFM_READ)
227 return (psf->datalength * psf->sf.samplerate) / psf->sf.frames ;
237 alac_reader_init (SF_PRIVATE *psf, const ALAC_DECODER_INFO * info)
244 { psf_log_printf (psf, "%s : ALAC_DECODER_INFO is NULL.\n", __func__) ;
249 { psf_log_printf (psf, "*** Error : frames_per_packet (%u) is too big. ***\n", info->frames_per_packet) ;
253 plac = psf->codec_data ;
255 plac->channels = psf->sf.channels ;
261 plac->pakt_info = alac_pakt_read_decode (psf, info->pakt_offset) ;
264 { psf_log_printf (psf, "%s : alac_pkt_read() returns NULL.\n", __func__) ;
269 kuki_size = alac_kuki_read (psf, info->kuki_offset, u.kuki, sizeof (u.kuki)) ;
272 { psf_log_printf (psf, "*** alac_decoder_init() returned %s. ***\n", alac_error_string (error)) ;
277 if (plac->u.decoder.mNumChannels != (unsigned) psf->sf.channels)
278 { psf_log_printf (psf, "*** Initialized decoder has %u channels, but it should be %d. ***\n", plac->u.decoder.mNumChannels, psf->sf.channels) ;
287 psf->read_short = alac_read_s ;
288 psf->read_int = alac_read_i ;
289 psf->read_float = alac_read_f ;
290 psf->read_double = alac_read_d ;
298 psf->codec_close = alac_close ;
299 psf->seek = alac_seek ;
301 psf->sf.frames = alac_reader_calc_frames (psf, plac) ;
302 alac_seek (psf, SFM_READ, 0) ;
308 alac_writer_init (SF_PRIVATE *psf)
312 plac = psf->codec_data ;
314 if (psf->file.mode != SFM_WRITE)
317 plac->channels = psf->sf.channels ;
318 plac->kuki_size = alac_get_magic_cookie_size (psf->sf.channels) ;
320 psf->write_short = alac_write_s ;
321 psf->write_int = alac_write_i ;
322 psf->write_float = alac_write_f ;
323 psf->write_double = alac_write_d ;
325 switch (SF_CODEC (psf->sf.format))
347 psf_log_printf (psf, "%s : Can't figure out bits per sample.\n", __func__) ;
356 { psf_log_printf (psf, "Error : Failed to open temp file '%s' : \n", plac->enctmpname, strerror (errno)) ;
360 alac_encoder_init (&plac->u.encoder, psf->sf.samplerate, psf->sf.channels, alac_format_flags, ALAC_FRAME_LENGTH) ;
377 alac_reader_calc_frames (SF_PRIVATE *psf, ALAC_PRIVATE *plac)
383 while (current_pos < psf->filelength && current_pos > 0)
394 alac_seek (psf, SFM_READ, frames) ;
395 alac_decode_block (psf, plac) ;
404 alac_decode_block (SF_PRIVATE *psf, ALAC_PRIVATE *plac)
412 psf_log_printf (psf, "packet_size is 0 (%d of %d)\n", plac->pakt_info->current, plac->pakt_info->count) ;
416 psf_fseek (psf, plac->input_data_pos, SEEK_SET) ;
419 { psf_log_printf (psf, "%s : bad packet_size (%u)\n", __func__, packet_size) ;
423 if ((packet_size != psf_fread (plac->byte_buffer, 1, packet_size, psf)))
460 alac_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
466 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
470 { if (plac->partial_block_frames >= plac->frames_this_block && alac_decode_block (psf, plac) == 0)
490 alac_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
496 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
500 { if (plac->partial_block_frames >= plac->frames_this_block && alac_decode_block (psf, plac) == 0)
520 alac_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
527 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
530 normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
533 { if (plac->partial_block_frames >= plac->frames_this_block && alac_decode_block (psf, plac) == 0)
553 alac_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
560 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
563 normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
566 { if (plac->partial_block_frames >= plac->frames_this_block && alac_decode_block (psf, plac) == 0)
589 alac_seek (SF_PRIVATE *psf, int mode, sf_count_t offset)
593 if (! psf->codec_data)
595 plac = (ALAC_PRIVATE*) psf->codec_data ;
597 if (psf->datalength < 0 || psf->dataoffset < 0)
598 { psf->error = SFE_BAD_SEEK ;
603 { psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
606 plac->input_data_pos = psf->dataoffset ;
612 { psf->error = SFE_BAD_SEEK ;
620 { plac->input_data_pos = psf->dataoffset + alac_pakt_block_offset (plac->pakt_info, newblock) ;
623 alac_decode_block (psf, plac) ;
628 psf->error = SFE_BAD_SEEK ;
640 alac_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
646 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
671 alac_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
677 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
702 alac_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
709 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
712 convert = (psf->add_clipping) ? psf_f2i_clip_array : psf_f2i_array ;
720 convert (ptr, iptr, writecount, psf->norm_float) ;
735 alac_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
742 if ((plac = (ALAC_PRIVATE*) psf->codec_data) == NULL)
745 convert = (psf->add_clipping) ? psf_d2i_clip_array : psf_d2i_array ;
753 convert (ptr, iptr, writecount, psf->norm_float) ;
804 alac_pakt_read_decode (SF_PRIVATE * psf, uint32_t UNUSED (pakt_offset))
816 if ((chunk_iterator = psf_get_chunk_iterator (psf, chunk_info.id)) == NULL)
817 { psf_log_printf (psf, "%s : no chunk iterator found\n", __func__) ;
823 psf->get_chunk_size (psf, chunk_iterator, &chunk_info) ;
830 if ((bcount = psf->get_chunk_data (psf, chunk_iterator, &chunk_info)) != SF_ERR_NO_ERROR)
832 chunk_iterator = psf->next_chunk_iterator (psf, chunk_iterator) ;
839 chunk_iterator = psf->next_chunk_iterator (psf, chunk_iterator) ;
879 alac_pakt_encode (const SF_PRIVATE *psf, uint32_t * pakt_size_out)
885 plac = psf->codec_data ;
893 psf_put_be64 (data, 8, psf->sf.frames) ;
949 alac_kuki_read (SF_PRIVATE * psf, uint32_t kuki_offset, uint8_t * kuki, size_t kuki_maxlen)
953 if (psf_fseek (psf, kuki_offset, SEEK_SET) != kuki_offset)
956 psf_fread (&marker, 1, sizeof (marker), psf) ;
960 psf_fread (&kuki_size, 1, sizeof (kuki_size), psf) ;
964 { psf_log_printf (psf, "%s : Bad size (%D) of 'kuki' chunk.\n", __func__, kuki_size) ;
968 psf_fread (kuki, 1, kuki_size, psf) ;