Lines Matching defs:psf
40 static int exif_subchunk_parse (SF_PRIVATE *psf, uint32_t length) ;
124 wavlike_read_fmt_chunk (SF_PRIVATE *psf, int fmtsize)
129 if ((wpriv = psf->container_data) == NULL)
138 /* assume psf->rwf_endian is already properly set */
141 bytesread = psf_binheader_readf (psf, "224422",
146 psf_log_printf (psf, " Format : 0x%X => %s\n", wav_fmt->format, wavlike_format_str (wav_fmt->format)) ;
147 psf_log_printf (psf, " Channels : %d\n", wav_fmt->min.channels) ;
148 psf_log_printf (psf, " Sample Rate : %d\n", wav_fmt->min.samplerate) ;
154 psf_log_printf (psf, " Block Align : 0 (should be %d)\n", wav_fmt->min.blockalign) ;
157 psf_log_printf (psf, " Block Align : %d\n", wav_fmt->min.blockalign) ;
161 { psf_log_printf (psf, " Bit Width : 24\n") ;
163 psf_log_printf (psf, "\n"
177 psf_log_printf (psf, " Bit Width : %d\n", wav_fmt->min.bitwidth) ;
180 psf_log_printf (psf, " Bit Width : %d (should not be 0)\n", wav_fmt->min.bitwidth) ;
188 psf_log_printf (psf, " Bit Width : %d (should be 0)\n", wav_fmt->min.bitwidth) ;
191 psf_log_printf (psf, " Bit Width : %d\n", wav_fmt->min.bitwidth) ;
195 psf->sf.samplerate = wav_fmt->min.samplerate ;
196 psf->sf.frames = 0 ; /* Correct this when reading data chunk. */
197 psf->sf.channels = wav_fmt->min.channels ;
204 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
206 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->min.bytespersec) ;
208 psf->bytewidth = BITWIDTH2BYTES (wav_fmt->min.bitwidth) ;
214 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->min.bytespersec, wav_fmt->min.samplerate * wav_fmt->min.blockalign) ;
216 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->min.bytespersec) ;
218 psf->bytewidth = 1 ;
220 { bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->size20.extrabytes)) ;
221 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->size20.extrabytes) ;
231 bytesread += psf_binheader_readf (psf, "22", &(wav_fmt->ima.extrabytes), &(wav_fmt->ima.samplesperblock)) ;
232 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->ima.extrabytes) ;
234 { psf_log_printf (psf, " Samples/Block : %d (should be > 0)\n", wav_fmt->ima.samplesperblock) ;
238 psf_log_printf (psf, " Samples/Block : %d\n", wav_fmt->ima.samplesperblock) ;
242 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->ima.bytespersec, bytespersec) ;
244 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->ima.bytespersec) ;
254 bytesread += psf_binheader_readf (psf, "222", &(wav_fmt->msadpcm.extrabytes),
257 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->msadpcm.extrabytes) ;
259 { psf_log_printf (psf, " Samples/Block : %d (should be > 0)\n", wav_fmt->ima.samplesperblock) ;
263 psf_log_printf (psf, " Samples/Block : %d\n", wav_fmt->ima.samplesperblock) ;
267 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->min.bytespersec) ;
269 psf_log_printf (psf, " Bytes/sec : %d (should be %d (MS BUG!))\n", wav_fmt->min.bytespersec, bytespersec) ;
271 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
274 { psf_log_printf (psf, " No. of Coeffs : %d (should be <= %d)\n", wav_fmt->msadpcm.numcoeffs, ARRAY_LEN (wav_fmt->msadpcm.coeffs)) ;
278 psf_log_printf (psf, " No. of Coeffs : %d\n", wav_fmt->msadpcm.numcoeffs) ;
280 psf_log_printf (psf, " Index Coeffs1 Coeffs2\n") ;
285 psf_binheader_readf (psf, "22", &(wav_fmt->msadpcm.coeffs [k].coeff1), &(wav_fmt->msadpcm.coeffs [k].coeff2)) ;
287 psf_log_printf (psf, buffer) ;
296 psf_binheader_readf (psf, "22", &(wav_fmt->gsm610.extrabytes), &(wav_fmt->gsm610.samplesperblock)) ;
303 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->gsm610.bytespersec, bytespersec) ;
305 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->gsm610.bytespersec) ;
307 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->gsm610.extrabytes) ;
308 psf_log_printf (psf, " Samples/Block : %d\n", wav_fmt->gsm610.samplesperblock) ;
312 bytesread += psf_binheader_readf (psf, "24222", &(wav_fmt->mpeg3.extrabytes),
316 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->mpeg3.bytespersec) ;
317 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->mpeg3.extrabytes) ;
319 psf_log_printf (psf, " ID : %d (unknown, should be 1)\n", wav_fmt->mpeg3.id) ;
321 psf_log_printf (psf, " ID : MPEGLAYER3_ID_MPEG\n") ;
322 psf_log_printf (psf, " Flags : 0x%08x\n", wav_fmt->mpeg3.flags) ;
323 psf_log_printf (psf, " Block Size : %d\n", wav_fmt->mpeg3.blocksize) ;
324 psf_log_printf (psf, " Samples/Block : %d\n", wav_fmt->mpeg3.samplesperblock) ;
325 psf_log_printf (psf, " Codec Delay : %d samples\n", wav_fmt->mpeg3.codecdelay) ;
330 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->ext.bytespersec, wav_fmt->ext.samplerate * wav_fmt->ext.blockalign) ;
332 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->ext.bytespersec) ;
335 psf_binheader_readf (psf, "224", &(wav_fmt->ext.extrabytes), &(wav_fmt->ext.validbits),
338 psf_log_printf (psf, " Valid Bits : %d\n", wav_fmt->ext.validbits) ;
341 psf_log_printf (psf, " Channel Mask : 0x0 (should not be zero)\n") ;
349 free (psf->channel_map) ;
351 if ((psf->channel_map = calloc (psf->sf.channels, sizeof (psf->channel_map [0]))) == NULL)
357 for (bit = k = 0 ; bit < ARRAY_LEN (channel_mask_bits) && k < psf->sf.channels ; bit++)
360 { if (k > psf->sf.channels)
361 { psf_log_printf (psf, "*** More channel map bits than there are channels.\n") ;
365 psf->channel_map [k++] = channel_mask_bits [bit].id ;
377 if (k != psf->sf.channels)
378 { psf_log_printf (psf, " Channel Mask : 0x%X\n", wav_fmt->ext.channelmask) ;
379 psf_log_printf (psf, "*** Less channel map bits than there are channels.\n") ;
382 psf_log_printf (psf, " Channel Mask : 0x%X (%s)\n", wav_fmt->ext.channelmask, buffer) ;
385 bytesread += psf_binheader_readf (psf, "422", &(wav_fmt->ext.esf.esf_field1), &(wav_fmt->ext.esf.esf_field2), &(wav_fmt->ext.esf.esf_field3)) ;
388 psf_log_printf (psf, " Subformat\n") ;
389 psf_log_printf (psf, " esf_field1 : 0x%X\n", wav_fmt->ext.esf.esf_field1) ;
390 psf_log_printf (psf, " esf_field2 : 0x%X\n", wav_fmt->ext.esf.esf_field2) ;
391 psf_log_printf (psf, " esf_field3 : 0x%X\n", wav_fmt->ext.esf.esf_field3) ;
392 psf_log_printf (psf, " esf_field4 : ") ;
394 { bytesread += psf_binheader_readf (psf, "1", &(wav_fmt->ext.esf.esf_field4 [k])) ;
395 psf_log_printf (psf, "0x%X ", wav_fmt->ext.esf.esf_field4 [k] & 0xFF) ;
397 psf_log_printf (psf, "\n") ;
398 psf->bytewidth = BITWIDTH2BYTES (wav_fmt->ext.bitwidth) ;
402 { psf->sf.format = SF_FORMAT_WAVEX | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
403 psf_log_printf (psf, " format : pcm\n") ;
406 { psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_MS_ADPCM) ;
407 psf_log_printf (psf, " format : ms adpcm\n") ;
410 { psf->sf.format = SF_FORMAT_WAVEX | ((psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT) ;
411 psf_log_printf (psf, " format : IEEE float\n") ;
414 { psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_ALAW) ;
415 psf_log_printf (psf, " format : A-law\n") ;
418 { psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_ULAW) ;
419 psf_log_printf (psf, " format : u-law\n") ;
422 { psf->sf.format = SF_FORMAT_WAVEX | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
423 psf_log_printf (psf, " format : pcm (Ambisonic B)\n") ;
427 { psf->sf.format = SF_FORMAT_WAVEX | ((psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT) ;
428 psf_log_printf (psf, " format : IEEE float (Ambisonic B)\n") ;
437 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->g72x.bytespersec) ;
439 { bytesread += psf_binheader_readf (psf, "22", &(wav_fmt->g72x.extrabytes), &(wav_fmt->g72x.auxblocksize)) ;
441 psf_log_printf (psf, " Extra Bytes : %d (should be 2)\n", wav_fmt->g72x.extrabytes) ;
443 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->g72x.extrabytes) ;
444 psf_log_printf (psf, " Aux Blk Size : %d\n", wav_fmt->g72x.auxblocksize) ;
447 { bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->g72x.extrabytes)) ;
448 psf_log_printf (psf, " Extra Bytes : %d%s\n", wav_fmt->g72x.extrabytes, wav_fmt->g72x.extrabytes != 0 ? " (should be 0)" : "") ;
451 psf_log_printf (psf, "*** 'fmt ' chunk should be bigger than this!\n") ;
460 psf_log_printf (psf, " Bytes/sec : %d\n", wav_fmt->min.bytespersec) ;
462 psf_log_printf (psf, " Bytes/sec : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
464 { bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->size20.extrabytes)) ;
465 psf_log_printf (psf, " Extra Bytes : %d\n", wav_fmt->size20.extrabytes) ;
470 psf_log_printf (psf, "*** No 'fmt ' chunk dumper for this format!\n") ;
475 { psf_log_printf (psf, "*** wavlike_read_fmt_chunk (bytesread > fmtsize)\n") ;
479 psf_binheader_readf (psf, "j", fmtsize - bytesread) ;
481 psf->blockwidth = wav_fmt->min.channels * psf->bytewidth ;
487 wavlike_write_guid (SF_PRIVATE *psf, const EXT_SUBFORMAT * subformat)
489 psf_binheader_writef (psf, "422b", BHW4 (subformat->esf_field1),
523 wavlike_analyze (SF_PRIVATE *psf)
528 if (psf->is_pipe)
529 { psf_log_printf (psf, "*** Error : Reading from a pipe. Can't analyze data section to figure out real data format.\n\n") ;
533 psf_log_printf (psf, "---------------------------------------------------\n"
538 ad.channels = psf->sf.channels ;
540 psf_fseek (psf, 3 * 4 * 50, SEEK_SET) ;
542 while (psf_fread (buffer, 1, sizeof (buffer), psf) == sizeof (buffer))
543 { format = audio_detect (psf, &ad, buffer, sizeof (buffer)) ;
549 psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
552 { psf_log_printf (psf, "wavlike_analyze : detection failed.\n") ;
559 psf_log_printf (psf, "wavlike_analyze : found format : 0x%X\n", format) ;
560 psf->sf.format = (psf->sf.format & ~SF_FORMAT_SUBMASK) + format ;
561 psf->bytewidth = 4 ;
562 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
566 psf_log_printf (psf, "wavlike_analyze : found format : 0x%X\n", format) ;
567 psf->sf.format = (psf->sf.format & ~SF_FORMAT_SUBMASK) + format ;
568 psf->bytewidth = 3 ;
569 psf->blockwidth = psf->sf.channels * psf->bytewidth ;
573 psf_log_printf (psf, "wavlike_analyze : unhandled format : 0x%X\n", format) ;
737 wavlike_read_bext_chunk (SF_PRIVATE *psf, uint32_t chunksize)
743 { psf_log_printf (psf, "bext : %u (should be >= %d)\n", chunksize, WAV_BEXT_MIN_CHUNK_SIZE) ;
744 psf_binheader_readf (psf, "j", chunksize) ;
749 { psf_log_printf (psf, "bext : %u (should be < %d)\n", chunksize, WAV_BEXT_MAX_CHUNK_SIZE) ;
750 psf_binheader_readf (psf, "j", chunksize) ;
755 { psf_log_printf (psf, "bext : %u too big to be handled\n", chunksize) ;
756 psf_binheader_readf (psf, "j", chunksize) ;
760 psf_log_printf (psf, "bext : %u\n", chunksize) ;
762 if (!psf->broadcast_16k)
763 { psf->broadcast_16k = broadcast_var_alloc () ;
764 if (!psf->broadcast_16k)
765 { psf->error = SFE_MALLOC_FAILED ;
766 return psf->error ;
770 { psf_log_printf (psf, "bext : found more than one bext chunk, using last one.\n") ;
771 memset (psf->broadcast_16k, 0, sizeof (SF_BROADCAST_INFO_16K)) ;
774 b = psf->broadcast_16k ;
776 bytes += psf_binheader_readf (psf, "b", b->description, sizeof (b->description)) ;
777 bytes += psf_binheader_readf (psf, "b", b->originator, sizeof (b->originator)) ;
778 bytes += psf_binheader_readf (psf, "b", b->originator_reference, sizeof (b->originator_reference)) ;
779 bytes += psf_binheader_readf (psf, "b", b->origination_date, sizeof (b->origination_date)) ;
780 bytes += psf_binheader_readf (psf, "b", b->origination_time, sizeof (b->origination_time)) ;
781 bytes += psf_binheader_readf (psf, "442", &b->time_reference_low, &b->time_reference_high, &b->version) ;
782 bytes += psf_binheader_readf (psf, "b", &b->umid, sizeof (b->umid)) ;
783 bytes += psf_binheader_readf (psf, "22", &b->loudness_value, &b->loudness_range) ;
784 bytes += psf_binheader_readf (psf, "222", &b->max_true_peak_level, &b->max_momentary_loudness, &b->max_shortterm_loudness) ;
785 bytes += psf_binheader_readf (psf, "j", 180) ;
793 bytes += psf_binheader_readf (psf, "b", BHWv (b->coding_history), BHWz (b->coding_history_size)) ;
797 psf_binheader_readf (psf, "j", BHWj (chunksize - bytes)) ;
803 wavlike_write_bext_chunk (SF_PRIVATE *psf)
806 if (psf->broadcast_16k == NULL)
809 b = psf->broadcast_16k ;
811 psf_binheader_writef (psf, "m4", BHWm (bext_MARKER), BHW4 (WAV_BEXT_MIN_CHUNK_SIZE + b->coding_history_size)) ;
818 psf_binheader_writef (psf, "b", BHWv (b->description), BHWz (sizeof (b->description))) ;
819 psf_binheader_writef (psf, "b", BHWv (b->originator), BHWz (sizeof (b->originator))) ;
820 psf_binheader_writef (psf, "b", BHWv (b->originator_reference), BHWz (sizeof (b->originator_reference))) ;
821 psf_binheader_writef (psf, "b", BHWv (b->origination_date), BHWz (sizeof (b->origination_date))) ;
822 psf_binheader_writef (psf, "b", BHWv (b->origination_time), BHWz (sizeof (b->origination_time))) ;
823 psf_binheader_writef (psf, "442", BHW4 (b->time_reference_low), BHW4 (b->time_reference_high), BHW2 (b->version)) ;
824 psf_binheader_writef (psf, "b", BHWv (b->umid), BHWz (sizeof (b->umid))) ;
825 psf_binheader_writef (psf, "22", BHW2 (b->loudness_value), BHW2 (b->loudness_range)) ;
826 psf_binheader_writef (psf, "222", BHW2 (b->max_true_peak_level), BHW2 (b->max_momentary_loudness), BHW2 (b->max_shortterm_loudness)) ;
827 psf_binheader_writef (psf, "z", BHWz (180)) ;
830 psf_binheader_writef (psf, "b", BHWv (b->coding_history), BHWz (b->coding_history_size)) ;
836 wavlike_read_cart_chunk (SF_PRIVATE *psf, uint32_t chunksize)
842 { psf_log_printf (psf, "cart : %u (should be >= %d)\n", chunksize, WAV_CART_MIN_CHUNK_SIZE) ;
843 psf_binheader_readf (psf, "j", chunksize) ;
847 { psf_log_printf (psf, "cart : %u (should be < %d)\n", chunksize, WAV_CART_MAX_CHUNK_SIZE) ;
848 psf_binheader_readf (psf, "j", chunksize) ;
857 { psf_log_printf (psf, "cart : %u too big to be handled\n", chunksize) ;
858 psf_binheader_readf (psf, "j", chunksize) ;
862 psf_log_printf (psf, "cart : %u\n", chunksize) ;
864 if (psf->cart_16k)
865 { psf_log_printf (psf, " Found more than one cart chunk, using last one.\n") ;
866 free (psf->cart_16k) ;
867 psf->cart_16k = NULL ;
870 if ((psf->cart_16k = cart_var_alloc ()) == NULL)
871 { psf->error = SFE_MALLOC_FAILED ;
872 return psf->error ;
875 c = psf->cart_16k ;
876 bytes += psf_binheader_readf (psf, "b", c->version, sizeof (c->version)) ;
877 bytes += psf_binheader_readf (psf, "b", c->title, sizeof (c->title)) ;
878 bytes += psf_binheader_readf (psf, "b", c->artist, sizeof (c->artist)) ;
879 bytes += psf_binheader_readf (psf, "b", c->cut_id, sizeof (c->cut_id)) ;
880 bytes += psf_binheader_readf (psf, "b", c->client_id, sizeof (c->client_id)) ;
881 bytes += psf_binheader_readf (psf, "b", c->category, sizeof (c->category)) ;
882 bytes += psf_binheader_readf (psf, "b", c->classification, sizeof (c->classification)) ;
883 bytes += psf_binheader_readf (psf, "b", c->out_cue, sizeof (c->out_cue)) ;
884 bytes += psf_binheader_readf (psf, "b", c->start_date, sizeof (c->start_date)) ;
885 bytes += psf_binheader_readf (psf, "b", c->start_time, sizeof (c->start_time)) ;
886 bytes += psf_binheader_readf (psf, "b", c->end_date, sizeof (c->end_date)) ;
887 bytes += psf_binheader_readf (psf, "b", c->end_time, sizeof (c->end_time)) ;
888 bytes += psf_binheader_readf (psf, "b", c->producer_app_id, sizeof (c->producer_app_id)) ;
889 bytes += psf_binheader_readf (psf, "b", c->producer_app_version, sizeof (c->producer_app_version)) ;
890 bytes += psf_binheader_readf (psf, "b", c->user_def, sizeof (c->user_def)) ;
891 bytes += psf_binheader_readf (psf, "e4", &c->level_reference, sizeof (c->level_reference)) ;
894 bytes += psf_binheader_readf (psf, "b4", &c->post_timers [k].usage, make_size_t (4), &c->post_timers [k].value) ;
896 bytes += psf_binheader_readf (psf, "b", c->reserved, sizeof (c->reserved)) ;
897 bytes += psf_binheader_readf (psf, "b", c->url, sizeof (c->url)) ;
902 bytes += psf_binheader_readf (psf, "b", c->tag_text, make_size_t (c->tag_text_size)) ;
906 psf_log_printf (psf, " %d trailing bytes in cart chunk.\n", chunksize - bytes) ;
912 wavlike_write_cart_chunk (SF_PRIVATE *psf)
916 if (psf->cart_16k == NULL)
919 c = psf->cart_16k ;
920 psf_binheader_writef (psf, "m4", BHWm (cart_MARKER), BHW4 (WAV_CART_MIN_CHUNK_SIZE + c->tag_text_size)) ;
925 psf_binheader_writef (psf, "b", BHWv (c->version), BHWz (sizeof (c->version))) ;
926 psf_binheader_writef (psf, "b", BHWv (c->title), BHWz (sizeof (c->title))) ;
927 psf_binheader_writef (psf, "b", BHWv (c->artist), BHWz (sizeof (c->artist))) ;
928 psf_binheader_writef (psf, "b", BHWv (c->cut_id), BHWz (sizeof (c->cut_id))) ;
929 psf_binheader_writef (psf, "b", BHWv (c->client_id), BHWz (sizeof (c->client_id))) ;
930 psf_binheader_writef (psf, "b", BHWv (c->category), BHWz (sizeof (c->category))) ;
931 psf_binheader_writef (psf, "b", BHWv (c->classification), BHWz (sizeof (c->classification))) ;
932 psf_binheader_writef (psf, "b", BHWv (c->out_cue), BHWz (sizeof (c->out_cue))) ;
933 psf_binheader_writef (psf, "b", BHWv (c->start_date), BHWz (sizeof (c->start_date))) ;
934 psf_binheader_writef (psf, "b", BHWv (c->start_time), BHWz (sizeof (c->start_time))) ;
935 psf_binheader_writef (psf, "b", BHWv (c->end_date), BHWz (sizeof (c->end_date))) ;
936 psf_binheader_writef (psf, "b", BHWv (c->end_time), BHWz (sizeof (c->end_time))) ;
937 psf_binheader_writef (psf, "b", BHWv (c->producer_app_id), BHWz (sizeof (c->producer_app_id))) ;
938 psf_binheader_writef (psf, "b", BHWv (c->producer_app_version), BHWz (sizeof (c->producer_app_version))) ;
939 psf_binheader_writef (psf, "b", BHWv (c->user_def), BHWz (sizeof (c->user_def))) ;
940 psf_binheader_writef (psf, "e4", BHW4 (c->level_reference)) ;
943 psf_binheader_writef (psf, "b4", BHWv (c->post_timers [k].usage), BHWz (4), BHW4 (c->post_timers [k].value)) ;
945 psf_binheader_writef (psf, "z", BHWz (sizeof (c->reserved))) ; // just write zeros, we don't have any other use for it
946 psf_binheader_writef (psf, "b", BHWv (c->url), BHWz (sizeof (c->url))) ;
949 psf_binheader_writef (psf, "b", BHWv (c->tag_text), BHWz (c->tag_text_size)) ;
955 wavlike_subchunk_parse (SF_PRIVATE *psf, int chunk, uint32_t chunk_length)
960 current_pos = psf_fseek (psf, 0, SEEK_CUR) ;
964 psf_log_printf (psf, "%M : %u (weird length)\n", chunk, chunk_length) ;
965 psf_binheader_readf (psf, "mj", &chunk, chunk_length - 4) ;
966 psf_log_printf (psf, " %M\n", chunk) ;
970 if (current_pos + chunk_length > psf->filelength)
971 { psf_log_printf (psf, "%M : %u (should be %d)\n", chunk, chunk_length, (int) (psf->filelength - current_pos)) ;
972 chunk_length = psf->filelength - current_pos ;
975 psf_log_printf (psf, "%M : %u\n", chunk, chunk_length) ;
980 if ((thisread = psf_binheader_readf (psf, "m", &chunk)) == 0)
988 psf_log_printf (psf, " %M\n", chunk) ;
992 psf_log_printf (psf, " %M\n", chunk) ;
994 bytesread += exif_subchunk_parse (psf, chunk_length - bytesread) ;
998 psf_log_printf (psf, " %M inside a LIST block??? Backing out.\n", chunk) ;
1000 psf_binheader_readf (psf, "j", -4) ;
1008 psf_log_printf (psf, " *** Found weird-ass zero marker. Jumping to end of chunk.\n") ;
1030 bytesread += psf_binheader_readf (psf, "4", &chunk_size) ;
1033 { psf_log_printf (psf, " *** %M : %u (too big)\n", chunk, chunk_size) ;
1037 bytesread += psf_binheader_readf (psf, "b", buffer, chunk_size) ;
1039 psf_log_printf (psf, " %M : %s\n", chunk, buffer) ;
1045 bytesread += psf_binheader_readf (psf, "44", &chunk_size, &mark_id) ;
1049 { psf_log_printf (psf, " *** %M : %u (too big)\n", chunk, chunk_size) ;
1053 bytesread += psf_binheader_readf (psf, "b", buffer, chunk_size) ;
1057 psf_log_printf (psf, " %M : %u : %s\n", chunk, mark_id, buffer) ;
1059 psf_log_printf (psf, " (Skipping)\n") ;
1061 if (psf->cues)
1065 while (i < psf->cues->cue_count && psf->cues->cue_points [i].indx != mark_id)
1068 if (i < psf->cues->cue_count)
1069 memcpy (psf->cues->cue_points [i].name, buffer, sizeof (psf->cues->cue_points [i].name)) ;
1077 bytesread += psf_binheader_readf (psf, "4", &chunk_size) ;
1080 { psf_log_printf (psf, " *** %M : %u (too big)\n", chunk, chunk_size) ;
1084 psf_log_printf (psf, " %M : %u\n", chunk, chunk_size) ;
1088 bytesread += psf_binheader_readf (psf, "4", &chunk_size) ;
1091 { psf_log_printf (psf, " *** %M : %u (too big)\n", chunk, chunk_size) ;
1095 { psf_log_printf (psf, " %M : %u\n", chunk, chunk_size) ;
1096 bytesread += psf_binheader_readf (psf, "j", chunk_size) ;
1103 psf_store_string (psf, SF_STR_SOFTWARE, buffer) ;
1106 psf_store_string (psf, SF_STR_COPYRIGHT, buffer) ;
1109 psf_store_string (psf, SF_STR_TITLE, buffer) ;
1112 psf_store_string (psf, SF_STR_ARTIST, buffer) ;
1115 psf_store_string (psf, SF_STR_COMMENT, buffer) ;
1118 psf_store_string (psf, SF_STR_DATE, buffer) ;
1121 psf_store_string (psf, SF_STR_GENRE, buffer) ;
1124 psf_store_string (psf, SF_STR_ALBUM, buffer) ;
1127 psf_store_string (psf, SF_STR_TRACKNUMBER, buffer) ;
1135 bytesread += psf_binheader_readf (psf, "j", chunk_length - bytesread) ;
1141 wavlike_write_strings (SF_PRIVATE *psf, int location)
1144 if (psf_location_string_count (psf, location) == 0)
1147 prev_head_index = psf->header.indx + 4 ;
1149 psf_binheader_writef (psf, "m4m", BHWm (LIST_MARKER), BHW4 (0xBADBAD), BHWm (INFO_MARKER)) ;
1152 { if (psf->strings.data [k].type == 0)
1154 if (psf->strings.data [k].type < 0 || psf->strings.data [k].flags != location)
1157 switch (psf->strings.data [k].type)
1159 psf_binheader_writef (psf, "ms", BHWm (ISFT_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1163 psf_binheader_writef (psf, "ms", BHWm (INAM_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1167 psf_binheader_writef (psf, "ms", BHWm (ICOP_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1171 psf_binheader_writef (psf, "ms", BHWm (IART_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1175 psf_binheader_writef (psf, "ms", BHWm (ICMT_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1179 psf_binheader_writef (psf, "ms", BHWm (ICRD_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1183 psf_binheader_writef (psf, "ms", BHWm (IGNR_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1187 psf_binheader_writef (psf, "ms", BHWm (IPRD_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1191 psf_binheader_writef (psf, "ms", BHWm (ITRK_MARKER), BHWs (psf->strings.storage + psf->strings.data [k].offset)) ;
1199 saved_head_index = psf->header.indx ;
1200 psf->header.indx = prev_head_index ;
1201 psf_binheader_writef (psf, "4", BHW4 (saved_head_index - prev_head_index - 4)) ;
1202 psf->header.indx = saved_head_index ;
1207 wavlike_read_peak_chunk (SF_PRIVATE * psf, size_t chunk_size)
1211 if (chunk_size != WAVLIKE_PEAK_CHUNK_SIZE (psf->sf.channels))
1212 { psf_binheader_readf (psf, "j", chunk_size) ;
1213 psf_log_printf (psf, "*** File PEAK chunk size doesn't fit with number of channels (%d).\n", psf->sf.channels) ;
1217 if (psf->peak_info)
1218 { psf_log_printf (psf, "*** Found existing peak info, using last one.\n") ;
1219 free (psf->peak_info) ;
1220 psf->peak_info = NULL ;
1222 if ((psf->peak_info = peak_info_calloc (psf->sf.channels)) == NULL)
1226 psf_binheader_readf (psf, "44", & (psf->peak_info->version), & (psf->peak_info->timestamp)) ;
1228 if (psf->peak_info->version != 1)
1229 psf_log_printf (psf, " version : %d *** (should be version 1)\n", psf->peak_info->version) ;
1231 psf_log_printf (psf, " version : %d\n", psf->peak_info->version) ;
1233 psf_log_printf (psf, " time stamp : %d\n", psf->peak_info->timestamp) ;
1234 psf_log_printf (psf, " Ch Position Value\n") ;
1236 for (uk = 0 ; uk < (uint32_t) psf->sf.channels ; uk++)
1240 psf_binheader_readf (psf, "f4", &value, &position) ;
1241 psf->peak_info->peaks [uk].value = value ;
1242 psf->peak_info->peaks [uk].position = position ;
1245 uk, psf->peak_info->peaks [uk].position, psf->peak_info->peaks [uk].value) ;
1247 psf_log_printf (psf, "%s", buffer) ;
1254 wavlike_write_peak_chunk (SF_PRIVATE * psf)
1257 if (psf->peak_info == NULL)
1260 psf_binheader_writef (psf, "m4", BHWm (PEAK_MARKER), BHW4 (WAVLIKE_PEAK_CHUNK_SIZE (psf->sf.channels))) ;
1261 psf_binheader_writef (psf, "44", BHW4 (1), BHW4 (time (NULL))) ;
1262 for (k = 0 ; k < psf->sf.channels ; k++)
1263 psf_binheader_writef (psf, "ft8", BHWf (psf->peak_info->peaks [k].value), BHW8 (psf->peak_info->peaks [k].position)) ;
1270 exif_fill_and_sink (SF_PRIVATE *psf, char* buf, size_t bufsz, size_t toread)
1278 bytesread = psf_binheader_readf (psf, "b", buf, bufsz) ;
1282 bytesread += psf_binheader_readf (psf, "j", toread - bufsz) ;
1292 exif_subchunk_parse (SF_PRIVATE *psf, uint32_t length)
1299 if ((thisread = psf_binheader_readf (psf, "m", &marker)) == 0)
1309 bytesread += psf_binheader_readf (psf, "j4", 4, &dword) ;
1312 psf_log_printf (psf, " EXIF Version : %u.%02u\n", vmajor, vminor) ;
1316 bytesread += psf_binheader_readf (psf, "4", &dword) ;
1317 psf_log_printf (psf, "%M : %u\n", marker, dword) ;
1321 bytesread += psf_binheader_readf (psf, "j", dword) ;
1330 bytesread += psf_binheader_readf (psf, "4", &dword) ;
1335 { psf_log_printf (psf, "*** Marker '%M' is too big %u\n\n", marker, dword) ;
1339 bytesread += exif_fill_and_sink (psf, buf, sizeof (buf), dword) ;
1345 { psf_log_printf (psf, " *** field size too small for string (sinking 2 bytes)\n") ;
1346 bytesread += psf_binheader_readf (psf, "j", 2) ;
1349 psf_log_printf (psf, " %M : %u (%s)\n", marker, dword, buf) ;
1355 psf_log_printf (psf, " *** %M (%u): -- ignored --\n", marker, marker) ;
1364 wavlike_write_custom_chunks (SF_PRIVATE * psf)
1367 for (k = 0 ; k < psf->wchunks.used ; k++)
1368 psf_binheader_writef (psf, "m4b", BHWm (psf->wchunks.chunks [k].mark32), BHW4 (psf->wchunks.chunks [k].len),
1369 BHWv (psf->wchunks.chunks [k].data), BHWz (psf->wchunks.chunks [k].len)) ;