开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
metadata_iterators.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：95k
源码类别：

Windows CE

开发平台：

C/C++

metadata_iterators.c：源码内容
  1. /* libFLAC - Free Lossless Audio Codec library
  2.  * Copyright (C) 2001,2002,2003,2004,2005  Josh Coalson
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * - Redistributions of source code must retain the above copyright
  9.  * notice, this list of conditions and the following disclaimer.
  10.  *
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  * notice, this list of conditions and the following disclaimer in the
  13.  * documentation and/or other materials provided with the distribution.
  14.  *
  15.  * - Neither the name of the Xiph.org Foundation nor the names of its
  16.  * contributors may be used to endorse or promote products derived from
  17.  * this software without specific prior written permission.
  18.  *
  19.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20.  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22.  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23.  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27.  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28.  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30.  */
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  36. #include "private/metadata.h"
  38. #include "FLAC/assert.h"
  39. #include "FLAC/file_decoder.h"
  41. #ifdef max
  42. #undef max
  43. #endif
  44. #define max(a,b) ((a)>(b)?(a):(b))
  45. #ifdef min
  46. #undef min
  47. #endif
  48. #define min(a,b) ((a)<(b)?(a):(b))
  51. /****************************************************************************
  52.  *
  53.  * Local function declarations
  54.  *
  55.  ***************************************************************************/
  57. static void pack_uint32_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes);
  58. static void pack_uint32_little_endian_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes);
  59. static void pack_uint64_(FLAC__uint64 val, FLAC__byte *b, unsigned bytes);
  60. static FLAC__uint32 unpack_uint32_(FLAC__byte *b, unsigned bytes);
  61. static FLAC__uint32 unpack_uint32_little_endian_(FLAC__byte *b, unsigned bytes);
  62. static FLAC__uint64 unpack_uint64_(FLAC__byte *b, unsigned bytes);
  64. static FLAC__bool read_metadata_block_header_(FLAC__Metadata_SimpleIterator *iterator);
  65. static FLAC__bool read_metadata_block_data_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block);
  66. static FLAC__bool read_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__bool *is_last, FLAC__MetadataType *type, unsigned *length);
  67. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata *block);
  68. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_StreamInfo *block);
  69. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata_Padding *block, unsigned block_length);
  70. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Application *block, unsigned block_length);
  71. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_SeekTable *block, unsigned block_length);
  72. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_entry_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment_Entry *entry);
  73. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment *block);
  74. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_track_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet_Track *track);
  75. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet *block);
  76. static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Unknown *block, unsigned block_length);
  78. static FLAC__bool write_metadata_block_header_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block);
  79. static FLAC__bool write_metadata_block_data_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block);
  80. static FLAC__bool write_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block);
  81. static FLAC__bool write_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block);
  82. static FLAC__bool write_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_StreamInfo *block);
  83. static FLAC__bool write_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Padding *block, unsigned block_length);
  84. static FLAC__bool write_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Application *block, unsigned block_length);
  85. static FLAC__bool write_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_SeekTable *block);
  86. static FLAC__bool write_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_VorbisComment *block);
  87. static FLAC__bool write_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_CueSheet *block);
  88. static FLAC__bool write_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Unknown *block, unsigned block_length);
  90. static FLAC__bool write_metadata_block_stationary_(FLAC__Metadata_SimpleIterator *iterator, const FLAC__StreamMetadata *block);
  91. static FLAC__bool write_metadata_block_stationary_with_padding_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, unsigned padding_length, FLAC__bool padding_is_last);
  92. static FLAC__bool rewrite_whole_file_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool append);
  94. static void simple_iterator_push_(FLAC__Metadata_SimpleIterator *iterator);
  95. static FLAC__bool simple_iterator_pop_(FLAC__Metadata_SimpleIterator *iterator);
  97. static unsigned seek_to_first_metadata_block_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb);
  98. static unsigned seek_to_first_metadata_block_(FILE *f);
  100. static FLAC__bool simple_iterator_copy_file_prefix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, FLAC__bool append);
  101. static FLAC__bool simple_iterator_copy_file_postfix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, int fixup_is_last_code, long fixup_is_last_flag_offset, FLAC__bool backup);
  103. static FLAC__bool copy_n_bytes_from_file_(FILE *file, FILE *tempfile, unsigned bytes/*@@@ 4G limit*/, FLAC__Metadata_SimpleIteratorStatus *status);
  104. static FLAC__bool copy_n_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, unsigned bytes/*@@@ 4G limit*/, FLAC__Metadata_SimpleIteratorStatus *status);
  105. static FLAC__bool copy_remaining_bytes_from_file_(FILE *file, FILE *tempfile, FLAC__Metadata_SimpleIteratorStatus *status);
  106. static FLAC__bool copy_remaining_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Eof eof_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, FLAC__Metadata_SimpleIteratorStatus *status);
  108. static FLAC__bool open_tempfile_(const char *filename, const char *tempfile_path_prefix, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status);
  109. static FLAC__bool transport_tempfile_(const char *filename, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status);
  110. static void cleanup_tempfile_(FILE **tempfile, char **tempfilename);
  112. static FLAC__bool get_file_stats_(const char *filename, struct stat *stats);
  113. static void set_file_stats_(const char *filename, struct stat *stats);
  115. static int fseek_wrapper_(FLAC__IOHandle handle, FLAC__int64 offset, int whence);
  116. static FLAC__int64 ftell_wrapper_(FLAC__IOHandle handle);
  118. static FLAC__Metadata_ChainStatus get_equivalent_status_(FLAC__Metadata_SimpleIteratorStatus status);
  121. #ifdef FLAC__VALGRIND_TESTING
  122. static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
  123. {
  124. size_t ret = fwrite(ptr, size, nmemb, stream);
  125. if(!ferror(stream))
  126. fflush(stream);
  127. return ret;
  128. }
  129. #else
  130. #define local__fwrite fwrite
  131. #endif
  133. /****************************************************************************
  134.  *
  135.  * Level 1 implementation
  136.  *
  137.  ***************************************************************************/
  139. #define SIMPLE_ITERATOR_MAX_PUSH_DEPTH (1+4)
  140. /* 1 for initial offset, +4 for our own personal use */
  142. struct FLAC__Metadata_SimpleIterator {
  143. FILE *file;
  144. char *filename, *tempfile_path_prefix;
  145. FLAC__bool is_writable;
  146. FLAC__Metadata_SimpleIteratorStatus status;
  147. /*@@@ 2G limits here because of the offset type: */
  148. long offset[SIMPLE_ITERATOR_MAX_PUSH_DEPTH];
  149. long first_offset; /* this is the offset to the STREAMINFO block */
  150. unsigned depth;
  151. /* this is the metadata block header of the current block we are pointing to: */
  152. FLAC__bool is_last;
  153. FLAC__MetadataType type;
  154. unsigned length;
  155. };
  157. FLAC_API const char * const FLAC__Metadata_SimpleIteratorStatusString[] = {
  158. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK",
  159. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT",
  160. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE",
  161. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE",
  162. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE",
  163. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA",
  164. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR",
  165. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR",
  166. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR",
  167. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR",
  168. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR",
  169. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR",
  170. "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR"
  171. };
  174. FLAC_API FLAC__Metadata_SimpleIterator *FLAC__metadata_simple_iterator_new()
  175. {
  176. FLAC__Metadata_SimpleIterator *iterator = (FLAC__Metadata_SimpleIterator*)calloc(1, sizeof(FLAC__Metadata_SimpleIterator));
  178. if(0 != iterator) {
  179. iterator->file = 0;
  180. iterator->filename = 0;
  181. iterator->tempfile_path_prefix = 0;
  182. iterator->is_writable = false;
  183. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  184. iterator->first_offset = iterator->offset[0] = -1;
  185. iterator->depth = 0;
  186. }
  188. return iterator;
  189. }
  191. static void simple_iterator_free_guts_(FLAC__Metadata_SimpleIterator *iterator)
  192. {
  193. FLAC__ASSERT(0 != iterator);
  195. if(0 != iterator->file) {
  196. fclose(iterator->file);
  197. iterator->file = 0;
  198. }
  199. if(0 != iterator->filename) {
  200. free(iterator->filename);
  201. iterator->filename = 0;
  202. }
  203. if(0 != iterator->tempfile_path_prefix) {
  204. free(iterator->tempfile_path_prefix);
  205. iterator->tempfile_path_prefix = 0;
  206. }
  207. }
  209. FLAC_API void FLAC__metadata_simple_iterator_delete(FLAC__Metadata_SimpleIterator *iterator)
  210. {
  211. FLAC__ASSERT(0 != iterator);
  213. simple_iterator_free_guts_(iterator);
  214. free(iterator);
  215. }
  217. FLAC_API FLAC__Metadata_SimpleIteratorStatus FLAC__metadata_simple_iterator_status(FLAC__Metadata_SimpleIterator *iterator)
  218. {
  219. FLAC__Metadata_SimpleIteratorStatus status;
  221. FLAC__ASSERT(0 != iterator);
  223. status = iterator->status;
  224. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  225. return status;
  226. }
  228. static FLAC__bool simple_iterator_prime_input_(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool read_only)
  229. {
  230. unsigned ret;
  232. FLAC__ASSERT(0 != iterator);
  234. if(read_only || 0 == (iterator->file = fopen(iterator->filename, "r+b"))) {
  235. iterator->is_writable = false;
  236. if(read_only) {
  237. if(0 == (iterator->file = fopen(iterator->filename, "rb"))) {
  238. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE;
  239. return false;
  240. }
  241. }
  242. else {
  243. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE;
  244. return false;
  245. }
  246. }
  247. else {
  248. iterator->is_writable = true;
  249. }
  251. ret = seek_to_first_metadata_block_(iterator->file);
  252. switch(ret) {
  253. case 0:
  254. iterator->depth = 0;
  255. iterator->first_offset = iterator->offset[iterator->depth] = ftell(iterator->file);
  256. return read_metadata_block_header_(iterator);
  257. case 1:
  258. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  259. return false;
  260. case 2:
  261. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  262. return false;
  263. case 3:
  264. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE;
  265. return false;
  266. default:
  267. FLAC__ASSERT(0);
  268. return false;
  269. }
  270. }
  272. #if 0
  273. @@@ If we decide to finish implementing this, put this comment back in metadata.h
  274. /*
  275.  * The 'tempfile_path_prefix' allows you to specify a directory where
  276.  * tempfiles should go.  Remember that if your metadata edits cause the
  277.  * FLAC file to grow, the entire file will have to be rewritten.  If
  278.  * 'tempfile_path_prefix' is NULL, the temp file will be written in the
  279.  * same directory as the original FLAC file.  This makes replacing the
  280.  * original with the tempfile fast but requires extra space in the same
  281.  * partition for the tempfile.  If space is a problem, you can pass a
  282.  * directory name belonging to a different partition in
  283.  * 'tempfile_path_prefix'.  Note that you should use the forward slash
  284.  * '/' as the directory separator.  A trailing slash is not needed; it
  285.  * will be added automatically.
  286.  */
  287. FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool preserve_file_stats, const char *tempfile_path_prefix);
  288. #endif
  290. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool read_only, FLAC__bool preserve_file_stats)
  291. {
  292. const char *tempfile_path_prefix = 0; /*@@@ search for comments near 'rename(...)' for what it will take to finish implementing this */
  294. FLAC__ASSERT(0 != iterator);
  295. FLAC__ASSERT(0 != filename);
  297. simple_iterator_free_guts_(iterator);
  299. if(0 == (iterator->filename = _strdup(filename))) {
  300. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  301. return false;
  302. }
  303. if(0 != tempfile_path_prefix && 0 == (iterator->tempfile_path_prefix = _strdup(tempfile_path_prefix))) {
  304. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  305. return false;
  306. }
  308. return simple_iterator_prime_input_(iterator, read_only);
  309. }
  311. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_writable(const FLAC__Metadata_SimpleIterator *iterator)
  312. {
  313. FLAC__ASSERT(0 != iterator);
  314. FLAC__ASSERT(0 != iterator->file);
  316. return iterator->is_writable;
  317. }
  319. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_next(FLAC__Metadata_SimpleIterator *iterator)
  320. {
  321. FLAC__ASSERT(0 != iterator);
  322. FLAC__ASSERT(0 != iterator->file);
  324. if(iterator->is_last)
  325. return false;
  327. if(0 != fseek(iterator->file, iterator->length, SEEK_CUR)) {
  328. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  329. return false;
  330. }
  332. iterator->offset[iterator->depth] = ftell(iterator->file);
  334. return read_metadata_block_header_(iterator);
  335. }
  337. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_prev(FLAC__Metadata_SimpleIterator *iterator)
  338. {
  339. long this_offset;
  341. FLAC__ASSERT(0 != iterator);
  342. FLAC__ASSERT(0 != iterator->file);
  344. if(iterator->offset[iterator->depth] == iterator->first_offset)
  345. return false;
  347. if(0 != fseek(iterator->file, iterator->first_offset, SEEK_SET)) {
  348. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  349. return false;
  350. }
  351. this_offset = iterator->first_offset;
  352. if(!read_metadata_block_header_(iterator))
  353. return false;
  355. /* we ignore any error from ftell() and catch it in fseek() */
  356. while(ftell(iterator->file) + (long)iterator->length < iterator->offset[iterator->depth]) {
  357. if(0 != fseek(iterator->file, iterator->length, SEEK_CUR)) {
  358. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  359. return false;
  360. }
  361. this_offset = ftell(iterator->file);
  362. if(!read_metadata_block_header_(iterator))
  363. return false;
  364. }
  366. iterator->offset[iterator->depth] = this_offset;
  368. return true;
  369. }
  371. FLAC_API FLAC__MetadataType FLAC__metadata_simple_iterator_get_block_type(const FLAC__Metadata_SimpleIterator *iterator)
  372. {
  373. FLAC__ASSERT(0 != iterator);
  374. FLAC__ASSERT(0 != iterator->file);
  376. return iterator->type;
  377. }
  379. FLAC_API FLAC__StreamMetadata *FLAC__metadata_simple_iterator_get_block(FLAC__Metadata_SimpleIterator *iterator)
  380. {
  381. FLAC__StreamMetadata *block = FLAC__metadata_object_new(iterator->type);
  383. FLAC__ASSERT(0 != iterator);
  384. FLAC__ASSERT(0 != iterator->file);
  386. if(0 != block) {
  387. block->is_last = iterator->is_last;
  388. block->length = iterator->length;
  390. if(!read_metadata_block_data_(iterator, block)) {
  391. FLAC__metadata_object_delete(block);
  392. return 0;
  393. }
  395. /* back up to the beginning of the block data to stay consistent */
  396. if(0 != fseek(iterator->file, iterator->offset[iterator->depth] + FLAC__STREAM_METADATA_HEADER_LENGTH, SEEK_SET)) {
  397. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  398. FLAC__metadata_object_delete(block);
  399. return 0;
  400. }
  401. }
  402. else
  403. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  405. return block;
  406. }
  408. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_set_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding)
  409. {
  410. FLAC__ASSERT_DECLARATION(long debug_target_offset = iterator->offset[iterator->depth];)
  411. FLAC__bool ret;
  413. FLAC__ASSERT(0 != iterator);
  414. FLAC__ASSERT(0 != iterator->file);
  415. FLAC__ASSERT(0 != block);
  417. if(!iterator->is_writable) {
  418. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE;
  419. return false;
  420. }
  422. if(iterator->type == FLAC__METADATA_TYPE_STREAMINFO || block->type == FLAC__METADATA_TYPE_STREAMINFO) {
  423. if(iterator->type != block->type) {
  424. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT;
  425. return false;
  426. }
  427. }
  429. block->is_last = iterator->is_last;
  431. if(iterator->length == block->length)
  432. return write_metadata_block_stationary_(iterator, block);
  433. else if(iterator->length > block->length) {
  434. if(use_padding && iterator->length >= FLAC__STREAM_METADATA_HEADER_LENGTH + block->length) {
  435. ret = write_metadata_block_stationary_with_padding_(iterator, block, iterator->length - FLAC__STREAM_METADATA_HEADER_LENGTH - block->length, block->is_last);
  436. FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
  437. FLAC__ASSERT(!ret || ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  438. return ret;
  439. }
  440. else {
  441. ret = rewrite_whole_file_(iterator, block, /*append=*/false);
  442. FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
  443. FLAC__ASSERT(!ret || ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  444. return ret;
  445. }
  446. }
  447. else /* iterator->length < block->length */ {
  448. unsigned padding_leftover = 0;
  449. FLAC__bool padding_is_last = false;
  450. if(use_padding) {
  451. /* first see if we can even use padding */
  452. if(iterator->is_last) {
  453. use_padding = false;
  454. }
  455. else {
  456. const unsigned extra_padding_bytes_required = block->length - iterator->length;
  457. simple_iterator_push_(iterator);
  458. if(!FLAC__metadata_simple_iterator_next(iterator)) {
  459. (void)simple_iterator_pop_(iterator);
  460. return false;
  461. }
  462. if(iterator->type != FLAC__METADATA_TYPE_PADDING) {
  463. use_padding = false;
  464. }
  465. else {
  466. if(FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length == extra_padding_bytes_required) {
  467. padding_leftover = 0;
  468. block->is_last = iterator->is_last;
  469. }
  470. else if(iterator->length < extra_padding_bytes_required)
  471. use_padding = false;
  472. else {
  473. padding_leftover = FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length - extra_padding_bytes_required;
  474. padding_is_last = iterator->is_last;
  475. block->is_last = false;
  476. }
  477. }
  478. if(!simple_iterator_pop_(iterator))
  479. return false;
  480. }
  481. }
  482. if(use_padding) {
  483. if(padding_leftover == 0) {
  484. ret = write_metadata_block_stationary_(iterator, block);
  485. FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
  486. FLAC__ASSERT(!ret || ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  487. return ret;
  488. }
  489. else {
  490. FLAC__ASSERT(padding_leftover >= FLAC__STREAM_METADATA_HEADER_LENGTH);
  491. ret = write_metadata_block_stationary_with_padding_(iterator, block, padding_leftover - FLAC__STREAM_METADATA_HEADER_LENGTH, padding_is_last);
  492. FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
  493. FLAC__ASSERT(!ret || ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  494. return ret;
  495. }
  496. }
  497. else {
  498. ret = rewrite_whole_file_(iterator, block, /*append=*/false);
  499. FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
  500. FLAC__ASSERT(!ret || ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  501. return ret;
  502. }
  503. }
  504. }
  506. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_insert_block_after(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding)
  507. {
  508. unsigned padding_leftover = 0;
  509. FLAC__bool padding_is_last = false;
  511. FLAC__ASSERT_DECLARATION(long debug_target_offset = iterator->offset[iterator->depth] + FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length;)
  512. FLAC__bool ret;
  514. FLAC__ASSERT(0 != iterator);
  515. FLAC__ASSERT(0 != iterator->file);
  516. FLAC__ASSERT(0 != block);
  518. if(!iterator->is_writable)
  519. return false;
  521. if(block->type == FLAC__METADATA_TYPE_STREAMINFO) {
  522. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT;
  523. return false;
  524. }
  526. block->is_last = iterator->is_last;
  528. if(use_padding) {
  529. /* first see if we can even use padding */
  530. if(iterator->is_last) {
  531. use_padding = false;
  532. }
  533. else {
  534. simple_iterator_push_(iterator);
  535. if(!FLAC__metadata_simple_iterator_next(iterator)) {
  536. (void)simple_iterator_pop_(iterator);
  537. return false;
  538. }
  539. if(iterator->type != FLAC__METADATA_TYPE_PADDING) {
  540. use_padding = false;
  541. }
  542. else {
  543. if(iterator->length == block->length) {
  544. padding_leftover = 0;
  545. block->is_last = iterator->is_last;
  546. }
  547. else if(iterator->length < FLAC__STREAM_METADATA_HEADER_LENGTH + block->length)
  548. use_padding = false;
  549. else {
  550. padding_leftover = iterator->length - block->length;
  551. padding_is_last = iterator->is_last;
  552. block->is_last = false;
  553. }
  554. }
  555. if(!simple_iterator_pop_(iterator))
  556. return false;
  557. }
  558. }
  559. if(use_padding) {
  560. /* move to the next block, which is suitable padding */
  561. if(!FLAC__metadata_simple_iterator_next(iterator))
  562. return false;
  563. if(padding_leftover == 0) {
  564. ret = write_metadata_block_stationary_(iterator, block);
  565. FLAC__ASSERT(iterator->offset[iterator->depth] == debug_target_offset);
  566. FLAC__ASSERT(ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  567. return ret;
  568. }
  569. else {
  570. FLAC__ASSERT(padding_leftover >= FLAC__STREAM_METADATA_HEADER_LENGTH);
  571. ret = write_metadata_block_stationary_with_padding_(iterator, block, padding_leftover - FLAC__STREAM_METADATA_HEADER_LENGTH, padding_is_last);
  572. FLAC__ASSERT(iterator->offset[iterator->depth] == debug_target_offset);
  573. FLAC__ASSERT(ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  574. return ret;
  575. }
  576. }
  577. else {
  578. ret = rewrite_whole_file_(iterator, block, /*append=*/true);
  579. FLAC__ASSERT(iterator->offset[iterator->depth] == debug_target_offset);
  580. FLAC__ASSERT(ftell(iterator->file) == debug_target_offset + (long)FLAC__STREAM_METADATA_HEADER_LENGTH);
  581. return ret;
  582. }
  583. }
  585. FLAC_API FLAC__bool FLAC__metadata_simple_iterator_delete_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool use_padding)
  586. {
  587. FLAC__ASSERT_DECLARATION(long debug_target_offset = iterator->offset[iterator->depth];)
  588. FLAC__bool ret;
  590. if(iterator->type == FLAC__METADATA_TYPE_STREAMINFO) {
  591. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT;
  592. return false;
  593. }
  595. if(use_padding) {
  596. FLAC__StreamMetadata *padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
  597. if(0 == padding) {
  598. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  599. return false;
  600. }
  601. padding->length = iterator->length;
  602. if(!FLAC__metadata_simple_iterator_set_block(iterator, padding, false)) {
  603. FLAC__metadata_object_delete(padding);
  604. return false;
  605. }
  606. FLAC__metadata_object_delete(padding);
  607. if(!FLAC__metadata_simple_iterator_prev(iterator))
  608. return false;
  609. FLAC__ASSERT(iterator->offset[iterator->depth] + (long)FLAC__STREAM_METADATA_HEADER_LENGTH + (long)iterator->length == debug_target_offset);
  610. FLAC__ASSERT(ftell(iterator->file) + (long)iterator->length == debug_target_offset);
  611. return true;
  612. }
  613. else {
  614. ret = rewrite_whole_file_(iterator, 0, /*append=*/false);
  615. FLAC__ASSERT(iterator->offset[iterator->depth] + (long)FLAC__STREAM_METADATA_HEADER_LENGTH + (long)iterator->length == debug_target_offset);
  616. FLAC__ASSERT(ftell(iterator->file) + (long)iterator->length == debug_target_offset);
  617. return ret;
  618. }
  619. }
  623. /****************************************************************************
  624.  *
  625.  * Level 2 implementation
  626.  *
  627.  ***************************************************************************/
  630. typedef struct FLAC__Metadata_Node {
  631. FLAC__StreamMetadata *data;
  632. struct FLAC__Metadata_Node *prev, *next;
  633. } FLAC__Metadata_Node;
  635. struct FLAC__Metadata_Chain {
  636. char *filename; /* will be NULL if using callbacks */
  637. FLAC__Metadata_Node *head;
  638. FLAC__Metadata_Node *tail;
  639. unsigned nodes;
  640. FLAC__Metadata_ChainStatus status;
  641. long first_offset, last_offset; /*@@@ 2G limit */
  642. /*
  643.  * This is the length of the chain initially read from the FLAC file.
  644.  * it is used to compare against the current length to decide whether
  645.  * or not the whole file has to be rewritten.
  646.  */
  647. unsigned initial_length; /*@@@ 4G limit */
  648. };
  650. struct FLAC__Metadata_Iterator {
  651. FLAC__Metadata_Chain *chain;
  652. FLAC__Metadata_Node *current;
  653. };
  655. FLAC_API const char * const FLAC__Metadata_ChainStatusString[] = {
  656. "FLAC__METADATA_CHAIN_STATUS_OK",
  657. "FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT",
  658. "FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE",
  659. "FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE",
  660. "FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE",
  661. "FLAC__METADATA_CHAIN_STATUS_BAD_METADATA",
  662. "FLAC__METADATA_CHAIN_STATUS_READ_ERROR",
  663. "FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR",
  664. "FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR",
  665. "FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR",
  666. "FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR",
  667. "FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR",
  668. "FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR",
  669. "FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS",
  670. "FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH",
  671. "FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL"
  672. };
  675. static FLAC__Metadata_Node *node_new_()
  676. {
  677. return (FLAC__Metadata_Node*)calloc(1, sizeof(FLAC__Metadata_Node));
  678. }
  680. static void node_delete_(FLAC__Metadata_Node *node)
  681. {
  682. FLAC__ASSERT(0 != node);
  683. if(0 != node->data)
  684. FLAC__metadata_object_delete(node->data);
  685. free(node);
  686. }
  688. static void chain_init_(FLAC__Metadata_Chain *chain)
  689. {
  690. FLAC__ASSERT(0 != chain);
  692. chain->filename = 0;
  693. chain->head = chain->tail = 0;
  694. chain->nodes = 0;
  695. chain->status = FLAC__METADATA_CHAIN_STATUS_OK;
  696. chain->initial_length = 0;
  697. }
  699. static void chain_clear_(FLAC__Metadata_Chain *chain)
  700. {
  701. FLAC__Metadata_Node *node, *next;
  703. FLAC__ASSERT(0 != chain);
  705. for(node = chain->head; node; ) {
  706. next = node->next;
  707. node_delete_(node);
  708. node = next;
  709. }
  711. if(0 != chain->filename)
  712. free(chain->filename);
  714. chain_init_(chain);
  715. }
  717. static void chain_append_node_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
  718. {
  719. FLAC__ASSERT(0 != chain);
  720. FLAC__ASSERT(0 != node);
  721. FLAC__ASSERT(0 != node->data);
  723. node->next = node->prev = 0;
  724. node->data->is_last = true;
  725. if(0 != chain->tail)
  726. chain->tail->data->is_last = false;
  728. if(0 == chain->head)
  729. chain->head = node;
  730. else {
  731. FLAC__ASSERT(0 != chain->tail);
  732. chain->tail->next = node;
  733. node->prev = chain->tail;
  734. }
  735. chain->tail = node;
  736. chain->nodes++;
  737. }
  739. static void chain_remove_node_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
  740. {
  741. FLAC__ASSERT(0 != chain);
  742. FLAC__ASSERT(0 != node);
  744. if(node == chain->head)
  745. chain->head = node->next;
  746. else
  747. node->prev->next = node->next;
  749. if(node == chain->tail)
  750. chain->tail = node->prev;
  751. else
  752. node->next->prev = node->prev;
  754. if(0 != chain->tail)
  755. chain->tail->data->is_last = true;
  757. chain->nodes--;
  758. }
  760. static void chain_delete_node_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
  761. {
  762. chain_remove_node_(chain, node);
  763. node_delete_(node);
  764. }
  766. static unsigned chain_calculate_length_(FLAC__Metadata_Chain *chain)
  767. {
  768. const FLAC__Metadata_Node *node;
  769. unsigned length = 0;
  770. for(node = chain->head; node; node = node->next)
  771. length += (FLAC__STREAM_METADATA_HEADER_LENGTH + node->data->length);
  772. return length;
  773. }
  775. static void iterator_insert_node_(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Node *node)
  776. {
  777. FLAC__ASSERT(0 != node);
  778. FLAC__ASSERT(0 != node->data);
  779. FLAC__ASSERT(0 != iterator);
  780. FLAC__ASSERT(0 != iterator->current);
  781. FLAC__ASSERT(0 != iterator->chain);
  782. FLAC__ASSERT(0 != iterator->chain->head);
  783. FLAC__ASSERT(0 != iterator->chain->tail);
  785. node->data->is_last = false;
  787. node->prev = iterator->current->prev;
  788. node->next = iterator->current;
  790. if(0 == node->prev)
  791. iterator->chain->head = node;
  792. else
  793. node->prev->next = node;
  795. iterator->current->prev = node;
  797. iterator->chain->nodes++;
  798. }
  800. static void iterator_insert_node_after_(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Node *node)
  801. {
  802. FLAC__ASSERT(0 != node);
  803. FLAC__ASSERT(0 != node->data);
  804. FLAC__ASSERT(0 != iterator);
  805. FLAC__ASSERT(0 != iterator->current);
  806. FLAC__ASSERT(0 != iterator->chain);
  807. FLAC__ASSERT(0 != iterator->chain->head);
  808. FLAC__ASSERT(0 != iterator->chain->tail);
  810. iterator->current->data->is_last = false;
  812. node->prev = iterator->current;
  813. node->next = iterator->current->next;
  815. if(0 == node->next)
  816. iterator->chain->tail = node;
  817. else
  818. node->next->prev = node;
  820. node->prev->next = node;
  822. iterator->chain->tail->data->is_last = true;
  824. iterator->chain->nodes++;
  825. }
  827. /* return true iff node and node->next are both padding */
  828. static FLAC__bool chain_merge_adjacent_padding_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
  829. {
  830. if(node->data->type == FLAC__METADATA_TYPE_PADDING && 0 != node->next && node->next->data->type == FLAC__METADATA_TYPE_PADDING) {
  831. const unsigned growth = FLAC__STREAM_METADATA_HEADER_LENGTH + node->next->data->length;
  832. node->data->length += growth;
  834. chain_delete_node_(chain, node->next);
  835. return true;
  836. }
  837. else
  838. return false;
  839. }
  841. /* Returns the new length of the chain, or 0 if there was an error. */
  842. /* WATCHOUT: This can get called multiple times before a write, so
  843.  * it should still work when this happens.
  844.  */
  845. /* WATCHOUT: Make sure to also update the logic in
  846.  * FLAC__metadata_chain_check_if_tempfile_needed() if the logic here changes.
  847.  */
  848. static unsigned chain_prepare_for_write_(FLAC__Metadata_Chain *chain, FLAC__bool use_padding)
  849. {
  850. unsigned current_length = chain_calculate_length_(chain);
  852. if(use_padding) {
  853. /* if the metadata shrank and the last block is padding, we just extend the last padding block */
  854. if(current_length < chain->initial_length && chain->tail->data->type == FLAC__METADATA_TYPE_PADDING) {
  855. const unsigned delta = chain->initial_length - current_length;
  856. chain->tail->data->length += delta;
  857. current_length += delta;
  858. FLAC__ASSERT(current_length == chain->initial_length);
  859. }
  860. /* if the metadata shrank more than 4 bytes then there's room to add another padding block */
  861. else if(current_length + FLAC__STREAM_METADATA_HEADER_LENGTH <= chain->initial_length) {
  862. FLAC__StreamMetadata *padding;
  863. FLAC__Metadata_Node *node;
  864. if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING))) {
  865. chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
  866. return 0;
  867. }
  868. padding->length = chain->initial_length - (FLAC__STREAM_METADATA_HEADER_LENGTH + current_length);
  869. if(0 == (node = node_new_())) {
  870. FLAC__metadata_object_delete(padding);
  871. chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
  872. return 0;
  873. }
  874. node->data = padding;
  875. chain_append_node_(chain, node);
  876. current_length = chain_calculate_length_(chain);
  877. FLAC__ASSERT(current_length == chain->initial_length);
  878. }
  879. /* if the metadata grew but the last block is padding, try cutting the padding to restore the original length so we don't have to rewrite the whole file */
  880. else if(current_length > chain->initial_length) {
  881. const unsigned delta = current_length - chain->initial_length;
  882. if(chain->tail->data->type == FLAC__METADATA_TYPE_PADDING) {
  883. /* if the delta is exactly the size of the last padding block, remove the padding block */
  884. if(chain->tail->data->length + FLAC__STREAM_METADATA_HEADER_LENGTH == delta) {
  885. chain_delete_node_(chain, chain->tail);
  886. current_length = chain_calculate_length_(chain);
  887. FLAC__ASSERT(current_length == chain->initial_length);
  888. }
  889. /* if there is at least 'delta' bytes of padding, trim the padding down */
  890. else if(chain->tail->data->length >= delta) {
  891. chain->tail->data->length -= delta;
  892. current_length -= delta;
  893. FLAC__ASSERT(current_length == chain->initial_length);
  894. }
  895. }
  896. }
  897. }
  899. return current_length;
  900. }
  902. static FLAC__bool chain_read_cb_(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__IOCallback_Tell tell_cb)
  903. {
  904. FLAC__Metadata_Node *node;
  906. FLAC__ASSERT(0 != chain);
  908. /* we assume we're already at the beginning of the file */
  910. switch(seek_to_first_metadata_block_cb_(handle, read_cb, seek_cb)) {
  911. case 0:
  912. break;
  913. case 1:
  914. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
  915. return false;
  916. case 2:
  917. chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  918. return false;
  919. case 3:
  920. chain->status = FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE;
  921. return false;
  922. default:
  923. FLAC__ASSERT(0);
  924. return false;
  925. }
  927. {
  928. FLAC__int64 pos = tell_cb(handle);
  929. if(pos < 0) {
  930. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
  931. return false;
  932. }
  933. chain->first_offset = (long)pos;
  934. }
  936. {
  937. FLAC__bool is_last;
  938. FLAC__MetadataType type;
  939. unsigned length;
  941. do {
  942. node = node_new_();
  943. if(0 == node) {
  944. chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
  945. return false;
  946. }
  948. if(!read_metadata_block_header_cb_(handle, read_cb, &is_last, &type, &length)) {
  949. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
  950. return false;
  951. }
  953. node->data = FLAC__metadata_object_new(type);
  954. if(0 == node->data) {
  955. node_delete_(node);
  956. chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
  957. return false;
  958. }
  960. node->data->is_last = is_last;
  961. node->data->length = length;
  963. chain->status = get_equivalent_status_(read_metadata_block_data_cb_(handle, read_cb, seek_cb, node->data));
  964. if(chain->status != FLAC__METADATA_CHAIN_STATUS_OK) {
  965. node_delete_(node);
  966. return false;
  967. }
  968. chain_append_node_(chain, node);
  969. } while(!is_last);
  970. }
  972. {
  973. FLAC__int64 pos = tell_cb(handle);
  974. if(pos < 0) {
  975. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
  976. return false;
  977. }
  978. chain->last_offset = (long)pos;
  979. }
  981. chain->initial_length = chain_calculate_length_(chain);
  983. return true;
  984. }
  986. static FLAC__bool chain_rewrite_metadata_in_place_cb_(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, FLAC__IOCallback_Seek seek_cb)
  987. {
  988. FLAC__Metadata_Node *node;
  990. FLAC__ASSERT(0 != chain);
  991. FLAC__ASSERT(0 != chain->head);
  993. if(0 != seek_cb(handle, chain->first_offset, SEEK_SET)) {
  994. chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  995. return false;
  996. }
  998. for(node = chain->head; node; node = node->next) {
  999. if(!write_metadata_block_header_cb_(handle, write_cb, node->data)) {
  1000. chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
  1001. return false;
  1002. }
  1003. if(!write_metadata_block_data_cb_(handle, write_cb, node->data)) {
  1004. chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
  1005. return false;
  1006. }
  1007. }
  1009. /*FLAC__ASSERT(fflush(), ftell() == chain->last_offset);*/
  1011. chain->status = FLAC__METADATA_CHAIN_STATUS_OK;
  1012. return true;
  1013. }
  1015. static FLAC__bool chain_rewrite_metadata_in_place_(FLAC__Metadata_Chain *chain)
  1016. {
  1017. FILE *file;
  1018. FLAC__bool ret;
  1020. FLAC__ASSERT(0 != chain->filename);
  1022. if(0 == (file = fopen(chain->filename, "r+b"))) {
  1023. chain->status = FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
  1024. return false;
  1025. }
  1027. /* chain_rewrite_metadata_in_place_cb_() sets chain->status for us */
  1028. ret = chain_rewrite_metadata_in_place_cb_(chain, (FLAC__IOHandle)file, (FLAC__IOCallback_Write)fwrite, fseek_wrapper_);
  1030. fclose(file);
  1032. return ret;
  1033. }
  1035. static FLAC__bool chain_rewrite_file_(FLAC__Metadata_Chain *chain, const char *tempfile_path_prefix)
  1036. {
  1037. FILE *f, *tempfile;
  1038. char *tempfilename;
  1039. FLAC__Metadata_SimpleIteratorStatus status;
  1040. const FLAC__Metadata_Node *node;
  1042. FLAC__ASSERT(0 != chain);
  1043. FLAC__ASSERT(0 != chain->filename);
  1044. FLAC__ASSERT(0 != chain->head);
  1046. /* copy the file prefix (data up to first metadata block */
  1047. if(0 == (f = fopen(chain->filename, "rb"))) {
  1048. chain->status = FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
  1049. return false;
  1050. }
  1051. if(!open_tempfile_(chain->filename, tempfile_path_prefix, &tempfile, &tempfilename, &status)) {
  1052. chain->status = get_equivalent_status_(status);
  1053. cleanup_tempfile_(&tempfile, &tempfilename);
  1054. return false;
  1055. }
  1056. if(!copy_n_bytes_from_file_(f, tempfile, chain->first_offset, &status)) {
  1057. chain->status = get_equivalent_status_(status);
  1058. cleanup_tempfile_(&tempfile, &tempfilename);
  1059. return false;
  1060. }
  1062. /* write the metadata */
  1063. for(node = chain->head; node; node = node->next) {
  1064. if(!write_metadata_block_header_(tempfile, &status, node->data)) {
  1065. chain->status = get_equivalent_status_(status);
  1066. return false;
  1067. }
  1068. if(!write_metadata_block_data_(tempfile, &status, node->data)) {
  1069. chain->status = get_equivalent_status_(status);
  1070. return false;
  1071. }
  1072. }
  1073. /*FLAC__ASSERT(fflush(), ftell() == chain->last_offset);*/
  1075. /* copy the file postfix (everything after the metadata) */
  1076. if(0 != fseek(f, chain->last_offset, SEEK_SET)) {
  1077. cleanup_tempfile_(&tempfile, &tempfilename);
  1078. chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  1079. return false;
  1080. }
  1081. if(!copy_remaining_bytes_from_file_(f, tempfile, &status)) {
  1082. cleanup_tempfile_(&tempfile, &tempfilename);
  1083. chain->status = get_equivalent_status_(status);
  1084. return false;
  1085. }
  1087. /* move the tempfile on top of the original */
  1088. (void)fclose(f);
  1089. if(!transport_tempfile_(chain->filename, &tempfile, &tempfilename, &status))
  1090. return false;
  1092. return true;
  1093. }
  1095. /* assumes 'handle' is already at beginning of file */
  1096. static FLAC__bool chain_rewrite_file_cb_(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__IOCallback_Eof eof_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb)
  1097. {
  1098. FLAC__Metadata_SimpleIteratorStatus status;
  1099. const FLAC__Metadata_Node *node;
  1101. FLAC__ASSERT(0 != chain);
  1102. FLAC__ASSERT(0 == chain->filename);
  1103. FLAC__ASSERT(0 != chain->head);
  1105. /* copy the file prefix (data up to first metadata block */
  1106. if(!copy_n_bytes_from_file_cb_(handle, read_cb, temp_handle, temp_write_cb, chain->first_offset, &status)) {
  1107. chain->status = get_equivalent_status_(status);
  1108. return false;
  1109. }
  1111. /* write the metadata */
  1112. for(node = chain->head; node; node = node->next) {
  1113. if(!write_metadata_block_header_cb_(temp_handle, temp_write_cb, node->data)) {
  1114. chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
  1115. return false;
  1116. }
  1117. if(!write_metadata_block_data_cb_(temp_handle, temp_write_cb, node->data)) {
  1118. chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
  1119. return false;
  1120. }
  1121. }
  1122. /*FLAC__ASSERT(fflush(), ftell() == chain->last_offset);*/
  1124. /* copy the file postfix (everything after the metadata) */
  1125. if(0 != seek_cb(handle, chain->last_offset, SEEK_SET)) {
  1126. chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  1127. return false;
  1128. }
  1129. if(!copy_remaining_bytes_from_file_cb_(handle, read_cb, eof_cb, temp_handle, temp_write_cb, &status)) {
  1130. chain->status = get_equivalent_status_(status);
  1131. return false;
  1132. }
  1134. return true;
  1135. }
  1137. FLAC_API FLAC__Metadata_Chain *FLAC__metadata_chain_new()
  1138. {
  1139. FLAC__Metadata_Chain *chain = (FLAC__Metadata_Chain*)calloc(1, sizeof(FLAC__Metadata_Chain));
  1141. if(0 != chain)
  1142. chain_init_(chain);
  1144. return chain;
  1145. }
  1147. FLAC_API void FLAC__metadata_chain_delete(FLAC__Metadata_Chain *chain)
  1148. {
  1149. FLAC__ASSERT(0 != chain);
  1151. chain_clear_(chain);
  1153. free(chain);
  1154. }
  1156. FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_Chain *chain)
  1157. {
  1158. FLAC__Metadata_ChainStatus status;
  1160. FLAC__ASSERT(0 != chain);
  1162. status = chain->status;
  1163. chain->status = FLAC__METADATA_CHAIN_STATUS_OK;
  1164. return status;
  1165. }
  1167. FLAC_API FLAC__bool FLAC__metadata_chain_read(FLAC__Metadata_Chain *chain, const char *filename)
  1168. {
  1169. FILE *file;
  1170. FLAC__bool ret;
  1172. FLAC__ASSERT(0 != chain);
  1173. FLAC__ASSERT(0 != filename);
  1175. chain_clear_(chain);
  1177. if(0 == (chain->filename = _strdup(filename))) {
  1178. chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
  1179. return false;
  1180. }
  1182. if(0 == (file = fopen(filename, "rb"))) {
  1183. chain->status = FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
  1184. return false;
  1185. }
  1187. /* chain_read_cb_() sets chain->status for us */
  1188. ret = chain_read_cb_(chain, file, (FLAC__IOCallback_Read)fread, fseek_wrapper_, ftell_wrapper_);
  1190. fclose(file);
  1192. return ret;
  1193. }
  1195. FLAC_API FLAC__bool FLAC__metadata_chain_read_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks)
  1196. {
  1197. FLAC__ASSERT(0 != chain);
  1199. chain_clear_(chain);
  1201. if (0 == callbacks.read || 0 == callbacks.seek || 0 == callbacks.tell) {
  1202. chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
  1203. return false;
  1204. }
  1206. /* rewind */
  1207. if(0 != callbacks.seek(handle, 0, SEEK_SET)) {
  1208. chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  1209. return false;
  1210. }
  1212. if(!chain_read_cb_(chain, handle, callbacks.read, callbacks.seek, callbacks.tell))
  1213. return false; /* chain->status is already set by chain_read_cb_ */
  1215. return true;
  1216. }
  1218. FLAC_API FLAC__bool FLAC__metadata_chain_check_if_tempfile_needed(FLAC__Metadata_Chain *chain, FLAC__bool use_padding)
  1219. {
  1220. /* This does all the same checks that are in chain_prepare_for_write_()
  1221.  * but doesn't actually alter the chain.  Make sure to update the logic
  1222.  * here if chain_prepare_for_write_() changes.
  1223.  */
  1224. const unsigned current_length = chain_calculate_length_(chain);
  1226. FLAC__ASSERT(0 != chain);
  1228. if(use_padding) {
  1229. /* if the metadata shrank and the last block is padding, we just extend the last padding block */
  1230. if(current_length < chain->initial_length && chain->tail->data->type == FLAC__METADATA_TYPE_PADDING)
  1231. return false;
  1232. /* if the metadata shrank more than 4 bytes then there's room to add another padding block */
  1233. else if(current_length + FLAC__STREAM_METADATA_HEADER_LENGTH <= chain->initial_length)
  1234. return false;
  1235. /* if the metadata grew but the last block is padding, try cutting the padding to restore the original length so we don't have to rewrite the whole file */
  1236. else if(current_length > chain->initial_length) {
  1237. const unsigned delta = current_length - chain->initial_length;
  1238. if(chain->tail->data->type == FLAC__METADATA_TYPE_PADDING) {
  1239. /* if the delta is exactly the size of the last padding block, remove the padding block */
  1240. if(chain->tail->data->length + FLAC__STREAM_METADATA_HEADER_LENGTH == delta)
  1241. return false;
  1242. /* if there is at least 'delta' bytes of padding, trim the padding down */
  1243. else if(chain->tail->data->length >= delta)
  1244. return false;
  1245. }
  1246. }
  1247. }
  1249. return (current_length != chain->initial_length);
  1250. }
  1252. FLAC_API FLAC__bool FLAC__metadata_chain_write(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__bool preserve_file_stats)
  1253. {
  1254. const char *tempfile_path_prefix = 0;
  1255. unsigned current_length;
  1257. FLAC__ASSERT(0 != chain);
  1259. if (0 == chain->filename) {
  1260. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH;
  1261. return false;
  1262. }
  1264. current_length = chain_prepare_for_write_(chain, use_padding);
  1266. /* a return value of 0 means there was an error; chain->status is already set */
  1267. if (0 == current_length)
  1268. return false;
  1270. if(current_length == chain->initial_length) {
  1271. if(!chain_rewrite_metadata_in_place_(chain))
  1272. return false;
  1273. }
  1274. else {
  1275. if(!chain_rewrite_file_(chain, tempfile_path_prefix))
  1276. return false;
  1278. /* recompute lengths and offsets */
  1279. {
  1280. const FLAC__Metadata_Node *node;
  1281. chain->initial_length = current_length;
  1282. chain->last_offset = chain->first_offset;
  1283. for(node = chain->head; node; node = node->next)
  1284. chain->last_offset += (FLAC__STREAM_METADATA_HEADER_LENGTH + node->data->length);
  1285. }
  1286. }
  1288. return true;
  1289. }
  1291. FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks)
  1292. {
  1293. unsigned current_length;
  1295. FLAC__ASSERT(0 != chain);
  1297. if (0 != chain->filename) {
  1298. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH;
  1299. return false;
  1300. }
  1302. if (0 == callbacks.write || 0 == callbacks.seek) {
  1303. chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
  1304. return false;
  1305. }
  1307. if (FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding)) {
  1308. chain->status = FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL;
  1309. return false;
  1310. }
  1312. current_length = chain_prepare_for_write_(chain, use_padding);
  1314. /* a return value of 0 means there was an error; chain->status is already set */
  1315. if (0 == current_length)
  1316. return false;
  1318. FLAC__ASSERT(current_length == chain->initial_length);
  1320. return chain_rewrite_metadata_in_place_cb_(chain, handle, callbacks.write, callbacks.seek);
  1321. }
  1323. FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks_and_tempfile(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks, FLAC__IOHandle temp_handle, FLAC__IOCallbacks temp_callbacks)
  1324. {
  1325. unsigned current_length;
  1327. FLAC__ASSERT(0 != chain);
  1329. if (0 != chain->filename) {
  1330. chain->status = FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH;
  1331. return false;
  1332. }
  1334. if (0 == callbacks.read || 0 == callbacks.seek || 0 == callbacks.eof) {
  1335. chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
  1336. return false;
  1337. }
  1338. if (0 == temp_callbacks.write) {
  1339. chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
  1340. return false;
  1341. }
  1343. if (!FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding)) {
  1344. chain->status = FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL;
  1345. return false;
  1346. }
  1348. current_length = chain_prepare_for_write_(chain, use_padding);
  1350. /* a return value of 0 means there was an error; chain->status is already set */
  1351. if (0 == current_length)
  1352. return false;
  1354. FLAC__ASSERT(current_length != chain->initial_length);
  1356. /* rewind */
  1357. if(0 != callbacks.seek(handle, 0, SEEK_SET)) {
  1358. chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  1359. return false;
  1360. }
  1362. if(!chain_rewrite_file_cb_(chain, handle, callbacks.read, callbacks.seek, callbacks.eof, temp_handle, temp_callbacks.write))
  1363. return false;
  1365. /* recompute lengths and offsets */
  1366. {
  1367. const FLAC__Metadata_Node *node;
  1368. chain->initial_length = current_length;
  1369. chain->last_offset = chain->first_offset;
  1370. for(node = chain->head; node; node = node->next)
  1371. chain->last_offset += (FLAC__STREAM_METADATA_HEADER_LENGTH + node->data->length);
  1372. }
  1374. return true;
  1375. }
  1377. FLAC_API void FLAC__metadata_chain_merge_padding(FLAC__Metadata_Chain *chain)
  1378. {
  1379. FLAC__Metadata_Node *node;
  1381. FLAC__ASSERT(0 != chain);
  1383. for(node = chain->head; node; ) {
  1384. if(!chain_merge_adjacent_padding_(chain, node))
  1385. node = node->next;
  1386. }
  1387. }
  1389. FLAC_API void FLAC__metadata_chain_sort_padding(FLAC__Metadata_Chain *chain)
  1390. {
  1391. FLAC__Metadata_Node *node, *save;
  1392. unsigned i;
  1394. FLAC__ASSERT(0 != chain);
  1396. /*
  1397.  * Don't try and be too smart... this simple algo is good enough for
  1398.  * the small number of nodes that we deal with.
  1399.  */
  1400. for(i = 0, node = chain->head; i < chain->nodes; i++) {
  1401. if(node->data->type == FLAC__METADATA_TYPE_PADDING) {
  1402. save = node->next;
  1403. chain_remove_node_(chain, node);
  1404. chain_append_node_(chain, node);
  1405. node = save;
  1406. }
  1407. else {
  1408. node = node->next;
  1409. }
  1410. }
  1412. FLAC__metadata_chain_merge_padding(chain);
  1413. }
  1416. FLAC_API FLAC__Metadata_Iterator *FLAC__metadata_iterator_new()
  1417. {
  1418. FLAC__Metadata_Iterator *iterator = (FLAC__Metadata_Iterator*)calloc(1, sizeof(FLAC__Metadata_Iterator));
  1420. /* calloc() implies:
  1421. iterator->current = 0;
  1422. iterator->chain = 0;
  1423. */
  1425. return iterator;
  1426. }
  1428. FLAC_API void FLAC__metadata_iterator_delete(FLAC__Metadata_Iterator *iterator)
  1429. {
  1430. FLAC__ASSERT(0 != iterator);
  1432. free(iterator);
  1433. }
  1435. FLAC_API void FLAC__metadata_iterator_init(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Chain *chain)
  1436. {
  1437. FLAC__ASSERT(0 != iterator);
  1438. FLAC__ASSERT(0 != chain);
  1439. FLAC__ASSERT(0 != chain->head);
  1441. iterator->chain = chain;
  1442. iterator->current = chain->head;
  1443. }
  1445. FLAC_API FLAC__bool FLAC__metadata_iterator_next(FLAC__Metadata_Iterator *iterator)
  1446. {
  1447. FLAC__ASSERT(0 != iterator);
  1449. if(0 == iterator->current || 0 == iterator->current->next)
  1450. return false;
  1452. iterator->current = iterator->current->next;
  1453. return true;
  1454. }
  1456. FLAC_API FLAC__bool FLAC__metadata_iterator_prev(FLAC__Metadata_Iterator *iterator)
  1457. {
  1458. FLAC__ASSERT(0 != iterator);
  1460. if(0 == iterator->current || 0 == iterator->current->prev)
  1461. return false;
  1463. iterator->current = iterator->current->prev;
  1464. return true;
  1465. }
  1467. FLAC_API FLAC__MetadataType FLAC__metadata_iterator_get_block_type(const FLAC__Metadata_Iterator *iterator)
  1468. {
  1469. FLAC__ASSERT(0 != iterator);
  1470. FLAC__ASSERT(0 != iterator->current);
  1471. FLAC__ASSERT(0 != iterator->current->data);
  1473. return iterator->current->data->type;
  1474. }
  1476. FLAC_API FLAC__StreamMetadata *FLAC__metadata_iterator_get_block(FLAC__Metadata_Iterator *iterator)
  1477. {
  1478. FLAC__ASSERT(0 != iterator);
  1479. FLAC__ASSERT(0 != iterator->current);
  1481. return iterator->current->data;
  1482. }
  1484. FLAC_API FLAC__bool FLAC__metadata_iterator_set_block(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block)
  1485. {
  1486. FLAC__ASSERT(0 != iterator);
  1487. FLAC__ASSERT(0 != block);
  1488. return FLAC__metadata_iterator_delete_block(iterator, false) && FLAC__metadata_iterator_insert_block_after(iterator, block);
  1489. }
  1491. FLAC_API FLAC__bool FLAC__metadata_iterator_delete_block(FLAC__Metadata_Iterator *iterator, FLAC__bool replace_with_padding)
  1492. {
  1493. FLAC__Metadata_Node *save;
  1495. FLAC__ASSERT(0 != iterator);
  1496. FLAC__ASSERT(0 != iterator->current);
  1498. if(0 == iterator->current->prev) {
  1499. FLAC__ASSERT(iterator->current->data->type == FLAC__METADATA_TYPE_STREAMINFO);
  1500. return false;
  1501. }
  1503. save = iterator->current->prev;
  1505. if(replace_with_padding) {
  1506. FLAC__metadata_object_delete_data(iterator->current->data);
  1507. iterator->current->data->type = FLAC__METADATA_TYPE_PADDING;
  1508. }
  1509. else {
  1510. chain_delete_node_(iterator->chain, iterator->current);
  1511. }
  1513. iterator->current = save;
  1514. return true;
  1515. }
  1517. FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_before(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block)
  1518. {
  1519. FLAC__Metadata_Node *node;
  1521. FLAC__ASSERT(0 != iterator);
  1522. FLAC__ASSERT(0 != iterator->current);
  1523. FLAC__ASSERT(0 != block);
  1525. if(block->type == FLAC__METADATA_TYPE_STREAMINFO)
  1526. return false;
  1528. if(0 == iterator->current->prev) {
  1529. FLAC__ASSERT(iterator->current->data->type == FLAC__METADATA_TYPE_STREAMINFO);
  1530. return false;
  1531. }
  1533. if(0 == (node = node_new_()))
  1534. return false;
  1536. node->data = block;
  1537. iterator_insert_node_(iterator, node);
  1538. iterator->current = node;
  1539. return true;
  1540. }
  1542. FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_after(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block)
  1543. {
  1544. FLAC__Metadata_Node *node;
  1546. FLAC__ASSERT(0 != iterator);
  1547. FLAC__ASSERT(0 != iterator->current);
  1548. FLAC__ASSERT(0 != block);
  1550. if(block->type == FLAC__METADATA_TYPE_STREAMINFO)
  1551. return false;
  1553. if(0 == (node = node_new_()))
  1554. return false;
  1556. node->data = block;
  1557. iterator_insert_node_after_(iterator, node);
  1558. iterator->current = node;
  1559. return true;
  1560. }
  1563. /****************************************************************************
  1564.  *
  1565.  * Local function definitions
  1566.  *
  1567.  ***************************************************************************/
  1569. void pack_uint32_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes)
  1570. {
  1571. unsigned i;
  1573. b += bytes;
  1575. for(i = 0; i < bytes; i++) {
  1576. *(--b) = (FLAC__byte)(val & 0xff);
  1577. val >>= 8;
  1578. }
  1579. }
  1581. void pack_uint32_little_endian_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes)
  1582. {
  1583. unsigned i;
  1585. for(i = 0; i < bytes; i++) {
  1586. *(b++) = (FLAC__byte)(val & 0xff);
  1587. val >>= 8;
  1588. }
  1589. }
  1591. void pack_uint64_(FLAC__uint64 val, FLAC__byte *b, unsigned bytes)
  1592. {
  1593. unsigned i;
  1595. b += bytes;
  1597. for(i = 0; i < bytes; i++) {
  1598. *(--b) = (FLAC__byte)(val & 0xff);
  1599. val >>= 8;
  1600. }
  1601. }
  1603. FLAC__uint32 unpack_uint32_(FLAC__byte *b, unsigned bytes)
  1604. {
  1605. FLAC__uint32 ret = 0;
  1606. unsigned i;
  1608. for(i = 0; i < bytes; i++)
  1609. ret = (ret << 8) | (FLAC__uint32)(*b++);
  1611. return ret;
  1612. }
  1614. FLAC__uint32 unpack_uint32_little_endian_(FLAC__byte *b, unsigned bytes)
  1615. {
  1616. FLAC__uint32 ret = 0;
  1617. unsigned i;
  1619. b += bytes;
  1621. for(i = 0; i < bytes; i++)
  1622. ret = (ret << 8) | (FLAC__uint32)(*--b);
  1624. return ret;
  1625. }
  1627. FLAC__uint64 unpack_uint64_(FLAC__byte *b, unsigned bytes)
  1628. {
  1629. FLAC__uint64 ret = 0;
  1630. unsigned i;
  1632. for(i = 0; i < bytes; i++)
  1633. ret = (ret << 8) | (FLAC__uint64)(*b++);
  1635. return ret;
  1636. }
  1638. FLAC__bool read_metadata_block_header_(FLAC__Metadata_SimpleIterator *iterator)
  1639. {
  1640. FLAC__ASSERT(0 != iterator);
  1641. FLAC__ASSERT(0 != iterator->file);
  1643. if(!read_metadata_block_header_cb_((FLAC__IOHandle)iterator->file, (FLAC__IOCallback_Read)fread, &iterator->is_last, &iterator->type, &iterator->length)) {
  1644. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1645. return false;
  1646. }
  1648. return true;
  1649. }
  1651. FLAC__bool read_metadata_block_data_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block)
  1652. {
  1653. FLAC__ASSERT(0 != iterator);
  1654. FLAC__ASSERT(0 != iterator->file);
  1656. iterator->status = read_metadata_block_data_cb_((FLAC__IOHandle)iterator->file, (FLAC__IOCallback_Read)fread, fseek_wrapper_, block);
  1658. return (iterator->status == FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK);
  1659. }
  1661. FLAC__bool read_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__bool *is_last, FLAC__MetadataType *type, unsigned *length)
  1662. {
  1663. FLAC__byte raw_header[FLAC__STREAM_METADATA_HEADER_LENGTH];
  1665. if(read_cb(raw_header, 1, FLAC__STREAM_METADATA_HEADER_LENGTH, handle) != FLAC__STREAM_METADATA_HEADER_LENGTH)
  1666. return false;
  1668. *is_last = raw_header[0] & 0x80? true : false;
  1669. *type = (FLAC__MetadataType)(raw_header[0] & 0x7f);
  1670. *length = unpack_uint32_(raw_header + 1, 3);
  1672. /* Note that we don't check:
  1673.  *    if(iterator->type >= FLAC__METADATA_TYPE_UNDEFINED)
  1674.  * we just will read in an opaque block
  1675.  */
  1677. return true;
  1678. }
  1680. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata *block)
  1681. {
  1682. switch(block->type) {
  1683. case FLAC__METADATA_TYPE_STREAMINFO:
  1684. return read_metadata_block_data_streaminfo_cb_(handle, read_cb, &block->data.stream_info);
  1685. case FLAC__METADATA_TYPE_PADDING:
  1686. return read_metadata_block_data_padding_cb_(handle, seek_cb, &block->data.padding, block->length);
  1687. case FLAC__METADATA_TYPE_APPLICATION:
  1688. return read_metadata_block_data_application_cb_(handle, read_cb, &block->data.application, block->length);
  1689. case FLAC__METADATA_TYPE_SEEKTABLE:
  1690. return read_metadata_block_data_seektable_cb_(handle, read_cb, &block->data.seek_table, block->length);
  1691. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  1692. return read_metadata_block_data_vorbis_comment_cb_(handle, read_cb, &block->data.vorbis_comment);
  1693. case FLAC__METADATA_TYPE_CUESHEET:
  1694. return read_metadata_block_data_cuesheet_cb_(handle, read_cb, &block->data.cue_sheet);
  1695. default:
  1696. return read_metadata_block_data_unknown_cb_(handle, read_cb, &block->data.unknown, block->length);
  1697. }
  1698. }
  1700. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_StreamInfo *block)
  1701. {
  1702. FLAC__byte buffer[FLAC__STREAM_METADATA_STREAMINFO_LENGTH], *b;
  1704. if(read_cb(buffer, 1, FLAC__STREAM_METADATA_STREAMINFO_LENGTH, handle) != FLAC__STREAM_METADATA_STREAMINFO_LENGTH)
  1705. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1707. b = buffer;
  1709. /* we are using hardcoded numbers for simplicity but we should
  1710.  * probably eventually write a bit-level unpacker and use the
  1711.  * _STREAMINFO_ constants.
  1712.  */
  1713. block->min_blocksize = unpack_uint32_(b, 2); b += 2;
  1714. block->max_blocksize = unpack_uint32_(b, 2); b += 2;
  1715. block->min_framesize = unpack_uint32_(b, 3); b += 3;
  1716. block->max_framesize = unpack_uint32_(b, 3); b += 3;
  1717. block->sample_rate = (unpack_uint32_(b, 2) << 4) | ((unsigned)(b[2] & 0xf0) >> 4);
  1718. block->channels = (unsigned)((b[2] & 0x0e) >> 1) + 1;
  1719. block->bits_per_sample = ((((unsigned)(b[2] & 0x01)) << 4) | (((unsigned)(b[3] & 0xf0)) >> 4)) + 1;
  1720. block->total_samples = (((FLAC__uint64)(b[3] & 0x0f)) << 32) | unpack_uint64_(b+4, 4);
  1721. memcpy(block->md5sum, b+8, 16);
  1723. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1724. }
  1727. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata_Padding *block, unsigned block_length)
  1728. {
  1729. (void)block; /* nothing to do; we don't care about reading the padding bytes */
  1731. if(0 != seek_cb(handle, block_length, SEEK_CUR))
  1732. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  1734. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1735. }
  1737. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Application *block, unsigned block_length)
  1738. {
  1739. const unsigned id_bytes = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
  1741. if(read_cb(block->id, 1, id_bytes, handle) != id_bytes)
  1742. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1744. block_length -= id_bytes;
  1746. if(block_length == 0) {
  1747. block->data = 0;
  1748. }
  1749. else {
  1750. if(0 == (block->data = (FLAC__byte*)malloc(block_length)))
  1751. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1753. if(read_cb(block->data, 1, block_length, handle) != block_length)
  1754. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1755. }
  1757. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1758. }
  1760. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_SeekTable *block, unsigned block_length)
  1761. {
  1762. unsigned i;
  1763. FLAC__byte buffer[FLAC__STREAM_METADATA_SEEKPOINT_LENGTH];
  1765. FLAC__ASSERT(block_length % FLAC__STREAM_METADATA_SEEKPOINT_LENGTH == 0);
  1767. block->num_points = block_length / FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
  1769. if(block->num_points == 0)
  1770. block->points = 0;
  1771. else if(0 == (block->points = (FLAC__StreamMetadata_SeekPoint*)malloc(block->num_points * sizeof(FLAC__StreamMetadata_SeekPoint))))
  1772. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1774. for(i = 0; i < block->num_points; i++) {
  1775. if(read_cb(buffer, 1, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH, handle) != FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)
  1776. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1777. /* some MAGIC NUMBERs here */
  1778. block->points[i].sample_number = unpack_uint64_(buffer, 8);
  1779. block->points[i].stream_offset = unpack_uint64_(buffer+8, 8);
  1780. block->points[i].frame_samples = unpack_uint32_(buffer+16, 2);
  1781. }
  1783. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1784. }
  1786. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_entry_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment_Entry *entry)
  1787. {
  1788. const unsigned entry_length_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
  1789. FLAC__byte buffer[4]; /* magic number is asserted below */
  1791. FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8 == 4);
  1793. if(read_cb(buffer, 1, entry_length_len, handle) != entry_length_len)
  1794. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1795. entry->length = unpack_uint32_little_endian_(buffer, entry_length_len);
  1797. if(0 != entry->entry)
  1798. free(entry->entry);
  1800. if(entry->length == 0) {
  1801. entry->entry = 0;
  1802. }
  1803. else {
  1804. if(0 == (entry->entry = (FLAC__byte*)malloc(entry->length+1)))
  1805. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1807. if(read_cb(entry->entry, 1, entry->length, handle) != entry->length)
  1808. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1810. entry->entry[entry->length] = '';
  1811. }
  1813. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1814. }
  1816. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment *block)
  1817. {
  1818. unsigned i;
  1819. FLAC__Metadata_SimpleIteratorStatus status;
  1820. const unsigned num_comments_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
  1821. FLAC__byte buffer[4]; /* magic number is asserted below */
  1823. FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8 == 4);
  1825. if(FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK != (status = read_metadata_block_data_vorbis_comment_entry_cb_(handle, read_cb, &(block->vendor_string))))
  1826. return status;
  1828. if(read_cb(buffer, 1, num_comments_len, handle) != num_comments_len)
  1829. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1830. block->num_comments = unpack_uint32_little_endian_(buffer, num_comments_len);
  1832. if(block->num_comments == 0) {
  1833. block->comments = 0;
  1834. }
  1835. else if(0 == (block->comments = (FLAC__StreamMetadata_VorbisComment_Entry*)calloc(block->num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry))))
  1836. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1838. for(i = 0; i < block->num_comments; i++) {
  1839. if(FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK != (status = read_metadata_block_data_vorbis_comment_entry_cb_(handle, read_cb, block->comments + i)))
  1840. return status;
  1841. }
  1843. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1844. }
  1846. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_track_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet_Track *track)
  1847. {
  1848. unsigned i, len;
  1849. FLAC__byte buffer[32]; /* asserted below that this is big enough */
  1851. FLAC__ASSERT(sizeof(buffer) >= sizeof(FLAC__uint64));
  1852. FLAC__ASSERT(sizeof(buffer) >= FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN/8);
  1853. FLAC__ASSERT(sizeof(buffer) >= (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) / 8);
  1855. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN % 8 == 0);
  1856. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN / 8;
  1857. if(read_cb(buffer, 1, len, handle) != len)
  1858. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1859. track->offset = unpack_uint64_(buffer, len);
  1861. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN % 8 == 0);
  1862. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN / 8;
  1863. if(read_cb(buffer, 1, len, handle) != len)
  1864. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1865. track->number = (FLAC__byte)unpack_uint32_(buffer, len);
  1867. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
  1868. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN / 8;
  1869. if(read_cb(track->isrc, 1, len, handle) != len)
  1870. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1872. FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) % 8 == 0);
  1873. len = (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) / 8;
  1874. if(read_cb(buffer, 1, len, handle) != len)
  1875. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1876. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN == 1);
  1877. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN == 1);
  1878. track->type = buffer[0] >> 7;
  1879. track->pre_emphasis = (buffer[0] >> 6) & 1;
  1881. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN % 8 == 0);
  1882. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN / 8;
  1883. if(read_cb(buffer, 1, len, handle) != len)
  1884. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1885. track->num_indices = (FLAC__byte)unpack_uint32_(buffer, len);
  1887. if(track->num_indices == 0) {
  1888. track->indices = 0;
  1889. }
  1890. else if(0 == (track->indices = (FLAC__StreamMetadata_CueSheet_Index*)calloc(track->num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index))))
  1891. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1893. for(i = 0; i < track->num_indices; i++) {
  1894. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN % 8 == 0);
  1895. len = FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN / 8;
  1896. if(read_cb(buffer, 1, len, handle) != len)
  1897. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1898. track->indices[i].offset = unpack_uint64_(buffer, len);
  1900. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN % 8 == 0);
  1901. len = FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN / 8;
  1902. if(read_cb(buffer, 1, len, handle) != len)
  1903. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1904. track->indices[i].number = (FLAC__byte)unpack_uint32_(buffer, len);
  1906. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN % 8 == 0);
  1907. len = FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN / 8;
  1908. if(read_cb(buffer, 1, len, handle) != len)
  1909. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1910. }
  1912. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1913. }
  1915. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet *block)
  1916. {
  1917. unsigned i, len;
  1918. FLAC__Metadata_SimpleIteratorStatus status;
  1919. FLAC__byte buffer[1024]; /* MSVC needs a constant expression so we put a magic number and assert */
  1921. FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN)/8 <= sizeof(buffer));
  1922. FLAC__ASSERT(sizeof(FLAC__uint64) <= sizeof(buffer));
  1924. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
  1925. len = FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN / 8;
  1926. if(read_cb(block->media_catalog_number, 1, len, handle) != len)
  1927. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1929. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN % 8 == 0);
  1930. len = FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN / 8;
  1931. if(read_cb(buffer, 1, len, handle) != len)
  1932. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1933. block->lead_in = unpack_uint64_(buffer, len);
  1935. FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) % 8 == 0);
  1936. len = (FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) / 8;
  1937. if(read_cb(buffer, 1, len, handle) != len)
  1938. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1939. block->is_cd = buffer[0]&0x80? true : false;
  1941. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN % 8 == 0);
  1942. len = FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN / 8;
  1943. if(read_cb(buffer, 1, len, handle) != len)
  1944. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1945. block->num_tracks = unpack_uint32_(buffer, len);
  1947. if(block->num_tracks == 0) {
  1948. block->tracks = 0;
  1949. }
  1950. else if(0 == (block->tracks = (FLAC__StreamMetadata_CueSheet_Track*)calloc(block->num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track))))
  1951. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1953. for(i = 0; i < block->num_tracks; i++) {
  1954. if(FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK != (status = read_metadata_block_data_cuesheet_track_cb_(handle, read_cb, block->tracks + i)))
  1955. return status;
  1956. }
  1958. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1959. }
  1961. FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Unknown *block, unsigned block_length)
  1962. {
  1963. if(block_length == 0) {
  1964. block->data = 0;
  1965. }
  1966. else {
  1967. if(0 == (block->data = (FLAC__byte*)malloc(block_length)))
  1968. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  1970. if(read_cb(block->data, 1, block_length, handle) != block_length)
  1971. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  1972. }
  1974. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1975. }
  1977. FLAC__bool write_metadata_block_header_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block)
  1978. {
  1979. FLAC__ASSERT(0 != file);
  1980. FLAC__ASSERT(0 != status);
  1982. if(!write_metadata_block_header_cb_((FLAC__IOHandle)file, (FLAC__IOCallback_Write)fwrite, block)) {
  1983. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  1984. return false;
  1985. }
  1987. return true;
  1988. }
  1990. FLAC__bool write_metadata_block_data_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block)
  1991. {
  1992. FLAC__ASSERT(0 != file);
  1993. FLAC__ASSERT(0 != status);
  1995. if (write_metadata_block_data_cb_((FLAC__IOHandle)file, (FLAC__IOCallback_Write)fwrite, block)) {
  1996. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
  1997. return true;
  1998. }
  1999. else {
  2000. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  2001. return false;
  2002. }
  2003. }
  2005. FLAC__bool write_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block)
  2006. {
  2007. FLAC__byte buffer[FLAC__STREAM_METADATA_HEADER_LENGTH];
  2009. FLAC__ASSERT(block->length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
  2011. buffer[0] = (block->is_last? 0x80 : 0) | (FLAC__byte)block->type;
  2012. pack_uint32_(block->length, buffer + 1, 3);
  2014. if(write_cb(buffer, 1, FLAC__STREAM_METADATA_HEADER_LENGTH, handle) != FLAC__STREAM_METADATA_HEADER_LENGTH)
  2015. return false;
  2017. return true;
  2018. }
  2020. FLAC__bool write_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block)
  2021. {
  2022. FLAC__ASSERT(0 != block);
  2024. switch(block->type) {
  2025. case FLAC__METADATA_TYPE_STREAMINFO:
  2026. return write_metadata_block_data_streaminfo_cb_(handle, write_cb, &block->data.stream_info);
  2027. case FLAC__METADATA_TYPE_PADDING:
  2028. return write_metadata_block_data_padding_cb_(handle, write_cb, &block->data.padding, block->length);
  2029. case FLAC__METADATA_TYPE_APPLICATION:
  2030. return write_metadata_block_data_application_cb_(handle, write_cb, &block->data.application, block->length);
  2031. case FLAC__METADATA_TYPE_SEEKTABLE:
  2032. return write_metadata_block_data_seektable_cb_(handle, write_cb, &block->data.seek_table);
  2033. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  2034. return write_metadata_block_data_vorbis_comment_cb_(handle, write_cb, &block->data.vorbis_comment);
  2035. case FLAC__METADATA_TYPE_CUESHEET:
  2036. return write_metadata_block_data_cuesheet_cb_(handle, write_cb, &block->data.cue_sheet);
  2037. default:
  2038. return write_metadata_block_data_unknown_cb_(handle, write_cb, &block->data.unknown, block->length);
  2039. }
  2040. }
  2042. FLAC__bool write_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_StreamInfo *block)
  2043. {
  2044. FLAC__byte buffer[FLAC__STREAM_METADATA_STREAMINFO_LENGTH];
  2045. const unsigned channels1 = block->channels - 1;
  2046. const unsigned bps1 = block->bits_per_sample - 1;
  2048. /* we are using hardcoded numbers for simplicity but we should
  2049.  * probably eventually write a bit-level packer and use the
  2050.  * _STREAMINFO_ constants.
  2051.  */
  2052. pack_uint32_(block->min_blocksize, buffer, 2);
  2053. pack_uint32_(block->max_blocksize, buffer+2, 2);
  2054. pack_uint32_(block->min_framesize, buffer+4, 3);
  2055. pack_uint32_(block->max_framesize, buffer+7, 3);
  2056. buffer[10] = (block->sample_rate >> 12) & 0xff;
  2057. buffer[11] = (block->sample_rate >> 4) & 0xff;
  2058. buffer[12] = ((block->sample_rate & 0x0f) << 4) | (channels1 << 1) | (bps1 >> 4);
  2059. buffer[13] = (FLAC__byte)(((bps1 & 0x0f) << 4) | ((block->total_samples >> 32) & 0x0f));
  2060. pack_uint32_((FLAC__uint32)block->total_samples, buffer+14, 4);
  2061. memcpy(buffer+18, block->md5sum, 16);
  2063. if(write_cb(buffer, 1, FLAC__STREAM_METADATA_STREAMINFO_LENGTH, handle) != FLAC__STREAM_METADATA_STREAMINFO_LENGTH)
  2064. return false;
  2066. return true;
  2067. }
  2069. FLAC__bool write_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Padding *block, unsigned block_length)
  2070. {
  2071. unsigned i, n = block_length;
  2072. FLAC__byte buffer[1024];
  2074. (void)block;
  2076. memset(buffer, 0, 1024);
  2078. for(i = 0; i < n/1024; i++)
  2079. if(write_cb(buffer, 1, 1024, handle) != 1024)
  2080. return false;
  2082. n %= 1024;
  2084. if(write_cb(buffer, 1, n, handle) != n)
  2085. return false;
  2087. return true;
  2088. }
  2090. FLAC__bool write_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Application *block, unsigned block_length)
  2091. {
  2092. const unsigned id_bytes = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
  2094. if(write_cb(block->id, 1, id_bytes, handle) != id_bytes)
  2095. return false;
  2097. block_length -= id_bytes;
  2099. if(write_cb(block->data, 1, block_length, handle) != block_length)
  2100. return false;
  2102. return true;
  2103. }
  2105. FLAC__bool write_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_SeekTable *block)
  2106. {
  2107. unsigned i;
  2108. FLAC__byte buffer[FLAC__STREAM_METADATA_SEEKPOINT_LENGTH];
  2110. for(i = 0; i < block->num_points; i++) {
  2111. /* some MAGIC NUMBERs here */
  2112. pack_uint64_(block->points[i].sample_number, buffer, 8);
  2113. pack_uint64_(block->points[i].stream_offset, buffer+8, 8);
  2114. pack_uint32_(block->points[i].frame_samples, buffer+16, 2);
  2115. if(write_cb(buffer, 1, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH, handle) != FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)
  2116. return false;
  2117. }
  2119. return true;
  2120. }
  2122. FLAC__bool write_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_VorbisComment *block)
  2123. {
  2124. unsigned i;
  2125. const unsigned entry_length_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
  2126. const unsigned num_comments_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
  2127. FLAC__byte buffer[4]; /* magic number is asserted below */
  2129. FLAC__ASSERT(max(FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN, FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN) / 8 == 4);
  2131. pack_uint32_little_endian_(block->vendor_string.length, buffer, entry_length_len);
  2132. if(write_cb(buffer, 1, entry_length_len, handle) != entry_length_len)
  2133. return false;
  2134. if(write_cb(block->vendor_string.entry, 1, block->vendor_string.length, handle) != block->vendor_string.length)
  2135. return false;
  2137. pack_uint32_little_endian_(block->num_comments, buffer, num_comments_len);
  2138. if(write_cb(buffer, 1, num_comments_len, handle) != num_comments_len)
  2139. return false;
  2141. for(i = 0; i < block->num_comments; i++) {
  2142. pack_uint32_little_endian_(block->comments[i].length, buffer, entry_length_len);
  2143. if(write_cb(buffer, 1, entry_length_len, handle) != entry_length_len)
  2144. return false;
  2145. if(write_cb(block->comments[i].entry, 1, block->comments[i].length, handle) != block->comments[i].length)
  2146. return false;
  2147. }
  2149. return true;
  2150. }
  2152. FLAC__bool write_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_CueSheet *block)
  2153. {
  2154. unsigned i, j, len;
  2155. FLAC__byte buffer[1024]; /* asserted below that this is big enough */
  2157. FLAC__ASSERT(sizeof(buffer) >= sizeof(FLAC__uint64));
  2158. FLAC__ASSERT(sizeof(buffer) >= FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN/8);
  2159. FLAC__ASSERT(sizeof(buffer) >= (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN)/8);
  2160. FLAC__ASSERT(sizeof(buffer) >= FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN/8);
  2162. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
  2163. len = FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN / 8;
  2164. if(write_cb(block->media_catalog_number, 1, len, handle) != len)
  2165. return false;
  2167. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN % 8 == 0);
  2168. len = FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN / 8;
  2169. pack_uint64_(block->lead_in, buffer, len);
  2170. if(write_cb(buffer, 1, len, handle) != len)
  2171. return false;
  2173. FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) % 8 == 0);
  2174. len = (FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) / 8;
  2175. memset(buffer, 0, len);
  2176. if(block->is_cd)
  2177. buffer[0] |= 0x80;
  2178. if(write_cb(buffer, 1, len, handle) != len)
  2179. return false;
  2181. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN % 8 == 0);
  2182. len = FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN / 8;
  2183. pack_uint32_(block->num_tracks, buffer, len);
  2184. if(write_cb(buffer, 1, len, handle) != len)
  2185. return false;
  2187. for(i = 0; i < block->num_tracks; i++) {
  2188. FLAC__StreamMetadata_CueSheet_Track *track = block->tracks + i;
  2190. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN % 8 == 0);
  2191. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN / 8;
  2192. pack_uint64_(track->offset, buffer, len);
  2193. if(write_cb(buffer, 1, len, handle) != len)
  2194. return false;
  2196. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN % 8 == 0);
  2197. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN / 8;
  2198. pack_uint32_(track->number, buffer, len);
  2199. if(write_cb(buffer, 1, len, handle) != len)
  2200. return false;
  2202. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
  2203. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN / 8;
  2204. if(write_cb(track->isrc, 1, len, handle) != len)
  2205. return false;
  2207. FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) % 8 == 0);
  2208. len = (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) / 8;
  2209. memset(buffer, 0, len);
  2210. buffer[0] = (track->type << 7) | (track->pre_emphasis << 6);
  2211. if(write_cb(buffer, 1, len, handle) != len)
  2212. return false;
  2214. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN % 8 == 0);
  2215. len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN / 8;
  2216. pack_uint32_(track->num_indices, buffer, len);
  2217. if(write_cb(buffer, 1, len, handle) != len)
  2218. return false;
  2220. for(j = 0; j < track->num_indices; j++) {
  2221. FLAC__StreamMetadata_CueSheet_Index *index = track->indices + j;
  2223. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN % 8 == 0);
  2224. len = FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN / 8;
  2225. pack_uint64_(index->offset, buffer, len);
  2226. if(write_cb(buffer, 1, len, handle) != len)
  2227. return false;
  2229. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN % 8 == 0);
  2230. len = FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN / 8;
  2231. pack_uint32_(index->number, buffer, len);
  2232. if(write_cb(buffer, 1, len, handle) != len)
  2233. return false;
  2235. FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN % 8 == 0);
  2236. len = FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN / 8;
  2237. memset(buffer, 0, len);
  2238. if(write_cb(buffer, 1, len, handle) != len)
  2239. return false;
  2240. }
  2241. }
  2243. return true;
  2244. }
  2246. FLAC__bool write_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Unknown *block, unsigned block_length)
  2247. {
  2248. if(write_cb(block->data, 1, block_length, handle) != block_length)
  2249. return false;
  2251. return true;
  2252. }
  2254. FLAC__bool write_metadata_block_stationary_(FLAC__Metadata_SimpleIterator *iterator, const FLAC__StreamMetadata *block)
  2255. {
  2256. if(0 != fseek(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
  2257. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2258. return false;
  2259. }
  2261. if(!write_metadata_block_header_(iterator->file, &iterator->status, block))
  2262. return false;
  2264. if(!write_metadata_block_data_(iterator->file, &iterator->status, block))
  2265. return false;
  2267. if(0 != fseek(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
  2268. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2269. return false;
  2270. }
  2272. return read_metadata_block_header_(iterator);
  2273. }
  2275. FLAC__bool write_metadata_block_stationary_with_padding_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, unsigned padding_length, FLAC__bool padding_is_last)
  2276. {
  2277. FLAC__StreamMetadata *padding;
  2279. if(0 != fseek(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
  2280. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2281. return false;
  2282. }
  2284. block->is_last = false;
  2286. if(!write_metadata_block_header_(iterator->file, &iterator->status, block))
  2287. return false;
  2289. if(!write_metadata_block_data_(iterator->file, &iterator->status, block))
  2290. return false;
  2292. if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
  2293. return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  2295. padding->is_last = padding_is_last;
  2296. padding->length = padding_length;
  2298. if(!write_metadata_block_header_(iterator->file, &iterator->status, padding)) {
  2299. FLAC__metadata_object_delete(padding);
  2300. return false;
  2301. }
  2303. if(!write_metadata_block_data_(iterator->file, &iterator->status, padding)) {
  2304. FLAC__metadata_object_delete(padding);
  2305. return false;
  2306. }
  2308. FLAC__metadata_object_delete(padding);
  2310. if(0 != fseek(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
  2311. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2312. return false;
  2313. }
  2315. return read_metadata_block_header_(iterator);
  2316. }
  2318. FLAC__bool rewrite_whole_file_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool append)
  2319. {
  2320. FILE *tempfile;
  2321. char *tempfilename;
  2322. int fixup_is_last_code = 0; /* 0 => no need to change any is_last flags */
  2323. long fixup_is_last_flag_offset = -1;
  2325. FLAC__ASSERT(0 != block || append == false);
  2327. if(iterator->is_last) {
  2328. if(append) {
  2329. fixup_is_last_code = 1; /* 1 => clear the is_last flag at the following offset */
  2330. fixup_is_last_flag_offset = iterator->offset[iterator->depth];
  2331. }
  2332. else if(0 == block) {
  2333. simple_iterator_push_(iterator);
  2334. if(!FLAC__metadata_simple_iterator_prev(iterator)) {
  2335. (void)simple_iterator_pop_(iterator);
  2336. return false;
  2337. }
  2338. fixup_is_last_code = -1; /* -1 => set the is_last the flag at the following offset */
  2339. fixup_is_last_flag_offset = iterator->offset[iterator->depth];
  2340. if(!simple_iterator_pop_(iterator))
  2341. return false;
  2342. }
  2343. }
  2345. if(!simple_iterator_copy_file_prefix_(iterator, &tempfile, &tempfilename, append))
  2346. return false;
  2348. if(0 != block) {
  2349. if(!write_metadata_block_header_(tempfile, &iterator->status, block)) {
  2350. cleanup_tempfile_(&tempfile, &tempfilename);
  2351. return false;
  2352. }
  2354. if(!write_metadata_block_data_(tempfile, &iterator->status, block)) {
  2355. cleanup_tempfile_(&tempfile, &tempfilename);
  2356. return false;
  2357. }
  2358. }
  2360. if(!simple_iterator_copy_file_postfix_(iterator, &tempfile, &tempfilename, fixup_is_last_code, fixup_is_last_flag_offset, block==0))
  2361. return false;
  2363. if(append)
  2364. return FLAC__metadata_simple_iterator_next(iterator);
  2366. return true;
  2367. }
  2369. void simple_iterator_push_(FLAC__Metadata_SimpleIterator *iterator)
  2370. {
  2371. FLAC__ASSERT(iterator->depth+1 < SIMPLE_ITERATOR_MAX_PUSH_DEPTH);
  2372. iterator->offset[iterator->depth+1] = iterator->offset[iterator->depth];
  2373. iterator->depth++;
  2374. }
  2376. FLAC__bool simple_iterator_pop_(FLAC__Metadata_SimpleIterator *iterator)
  2377. {
  2378. FLAC__ASSERT(iterator->depth > 0);
  2379. iterator->depth--;
  2380. if(0 != fseek(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
  2381. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2382. return false;
  2383. }
  2385. return read_metadata_block_header_(iterator);
  2386. }
  2388. /* return meanings:
  2389.  * 0: ok
  2390.  * 1: read error
  2391.  * 2: seek error
  2392.  * 3: not a FLAC file
  2393.  */
  2394. unsigned seek_to_first_metadata_block_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb)
  2395. {
  2396. FLAC__byte buffer[4];
  2397. size_t n;
  2398. unsigned i;
  2400. FLAC__ASSERT(FLAC__STREAM_SYNC_LENGTH == 4);
  2402. /* skip any id3v2 tag */
  2403. n = read_cb(buffer, 1, 4, handle);
  2404.   if(n != 4)
  2405. return 3;
  2406. else if(0 == memcmp(buffer, "ID3", 3)) {
  2407. unsigned tag_length = 0;
  2409. /* skip to the tag length */
  2410. if(seek_cb(handle, 2, SEEK_CUR) < 0)
  2411. return 2;
  2413. /* read the length */
  2414. for(i = 0; i < 4; i++) {
  2415. if(read_cb(buffer, 1, 1, handle) < 1 || buffer[0] & 0x80)
  2416. return 1;
  2417. tag_length <<= 7;
  2418. tag_length |= (buffer[0] & 0x7f);
  2419. }
  2421. /* skip the rest of the tag */
  2422. if(seek_cb(handle, tag_length, SEEK_CUR) < 0)
  2423. return 2;
  2425. /* read the stream sync code */
  2426. n = read_cb(buffer, 1, 4, handle);
  2427.     if(n != 4)
  2428. return 3;
  2429. }
  2431. /* check for the fLaC signature */
  2432. if(0 == memcmp(FLAC__STREAM_SYNC_STRING, buffer, FLAC__STREAM_SYNC_LENGTH))
  2433. return 0;
  2434. else
  2435. return 3;
  2436. }
  2438. unsigned seek_to_first_metadata_block_(FILE *f)
  2439. {
  2440. return seek_to_first_metadata_block_cb_((FLAC__IOHandle)f, (FLAC__IOCallback_Read)fread, fseek_wrapper_);
  2441. }
  2443. FLAC__bool simple_iterator_copy_file_prefix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, FLAC__bool append)
  2444. {
  2445. const long offset_end = append? iterator->offset[iterator->depth] + (long)FLAC__STREAM_METADATA_HEADER_LENGTH + (long)iterator->length : iterator->offset[iterator->depth];
  2447. if(0 != fseek(iterator->file, 0, SEEK_SET)) {
  2448. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2449. return false;
  2450. }
  2451. if(!open_tempfile_(iterator->filename, iterator->tempfile_path_prefix, tempfile, tempfilename, &iterator->status)) {
  2452. cleanup_tempfile_(tempfile, tempfilename);
  2453. return false;
  2454. }
  2455. if(!copy_n_bytes_from_file_(iterator->file, *tempfile, offset_end, &iterator->status)) {
  2456. cleanup_tempfile_(tempfile, tempfilename);
  2457. return false;
  2458. }
  2460. return true;
  2461. }
  2463. FLAC__bool simple_iterator_copy_file_postfix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, int fixup_is_last_code, long fixup_is_last_flag_offset, FLAC__bool backup)
  2464. {
  2465. long save_offset = iterator->offset[iterator->depth]; /*@@@ 2G limit */
  2466. FLAC__ASSERT(0 != *tempfile);
  2468. if(0 != fseek(iterator->file, save_offset + FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length, SEEK_SET)) {
  2469. cleanup_tempfile_(tempfile, tempfilename);
  2470. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2471. return false;
  2472. }
  2473. if(!copy_remaining_bytes_from_file_(iterator->file, *tempfile, &iterator->status)) {
  2474. cleanup_tempfile_(tempfile, tempfilename);
  2475. return false;
  2476. }
  2478. if(fixup_is_last_code != 0) {
  2479. /*
  2480.  * if code == 1, it means a block was appended to the end so
  2481.  *   we have to clear the is_last flag of the previous block
  2482.  * if code == -1, it means the last block was deleted so
  2483.  *   we have to set the is_last flag of the previous block
  2484.  */
  2485. /* MAGIC NUMBERs here; we know the is_last flag is the high bit of the byte at this location */
  2486. FLAC__byte x;
  2487. if(0 != fseek(*tempfile, fixup_is_last_flag_offset, SEEK_SET)) {
  2488. cleanup_tempfile_(tempfile, tempfilename);
  2489. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2490. return false;
  2491. }
  2492. if(fread(&x, 1, 1, *tempfile) != 1) {
  2493. cleanup_tempfile_(tempfile, tempfilename);
  2494. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  2495. return false;
  2496. }
  2497. if(fixup_is_last_code > 0) {
  2498. FLAC__ASSERT(x & 0x80);
  2499. x &= 0x7f;
  2500. }
  2501. else {
  2502. FLAC__ASSERT(!(x & 0x80));
  2503. x |= 0x80;
  2504. }
  2505. if(0 != fseek(*tempfile, fixup_is_last_flag_offset, SEEK_SET)) {
  2506. cleanup_tempfile_(tempfile, tempfilename);
  2507. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
  2508. return false;
  2509. }
  2510. if(local__fwrite(&x, 1, 1, *tempfile) != 1) {
  2511. cleanup_tempfile_(tempfile, tempfilename);
  2512. iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  2513. return false;
  2514. }
  2515. }
  2517. (void)fclose(iterator->file);
  2519. if(!transport_tempfile_(iterator->filename, tempfile, tempfilename, &iterator->status))
  2520. return false;
  2522. if(!simple_iterator_prime_input_(iterator, !iterator->is_writable))
  2523. return false;
  2524. if(backup) {
  2525. while(iterator->offset[iterator->depth] + (long)FLAC__STREAM_METADATA_HEADER_LENGTH + (long)iterator->length < save_offset)
  2526. if(!FLAC__metadata_simple_iterator_next(iterator))
  2527. return false;
  2528. return true;
  2529. }
  2530. else {
  2531. /* move the iterator to it's original block faster by faking a push, then doing a pop_ */
  2532. FLAC__ASSERT(iterator->depth == 0);
  2533. iterator->offset[0] = save_offset;
  2534. iterator->depth++;
  2535. return simple_iterator_pop_(iterator);
  2536. }
  2537. }
  2539. FLAC__bool copy_n_bytes_from_file_(FILE *file, FILE *tempfile, unsigned bytes/*@@@ 4G limit*/, FLAC__Metadata_SimpleIteratorStatus *status)
  2540. {
  2541. FLAC__byte buffer[8192];
  2542. unsigned n;
  2544. while(bytes > 0) {
  2545. n = min(sizeof(buffer), bytes);
  2546. if(fread(buffer, 1, n, file) != n) {
  2547. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  2548. return false;
  2549. }
  2550. if(local__fwrite(buffer, 1, n, tempfile) != n) {
  2551. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  2552. return false;
  2553. }
  2554. bytes -= n;
  2555. }
  2557. return true;
  2558. }
  2560. FLAC__bool copy_n_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, unsigned bytes/*@@@ 4G limit*/, FLAC__Metadata_SimpleIteratorStatus *status)
  2561. {
  2562. FLAC__byte buffer[8192];
  2563. unsigned n;
  2565. while(bytes > 0) {
  2566. n = min(sizeof(buffer), bytes);
  2567. if(read_cb(buffer, 1, n, handle) != n) {
  2568. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  2569. return false;
  2570. }
  2571. if(temp_write_cb(buffer, 1, n, temp_handle) != n) {
  2572. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  2573. return false;
  2574. }
  2575. bytes -= n;
  2576. }
  2578. return true;
  2579. }
  2581. FLAC__bool copy_remaining_bytes_from_file_(FILE *file, FILE *tempfile, FLAC__Metadata_SimpleIteratorStatus *status)
  2582. {
  2583. FLAC__byte buffer[8192];
  2584. size_t n;
  2586. while(!feof(file)) {
  2587. n = fread(buffer, 1, sizeof(buffer), file);
  2588. if(n == 0 && !feof(file)) {
  2589. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  2590. return false;
  2591. }
  2592. if(n > 0 && local__fwrite(buffer, 1, n, tempfile) != n) {
  2593. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  2594. return false;
  2595. }
  2596. }
  2598. return true;
  2599. }
  2601. FLAC__bool copy_remaining_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Eof eof_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, FLAC__Metadata_SimpleIteratorStatus *status)
  2602. {
  2603. FLAC__byte buffer[8192];
  2604. size_t n;
  2606. while(!eof_cb(handle)) {
  2607. n = read_cb(buffer, 1, sizeof(buffer), handle);
  2608. if(n == 0 && !eof_cb(handle)) {
  2609. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
  2610. return false;
  2611. }
  2612. if(n > 0 && temp_write_cb(buffer, 1, n, temp_handle) != n) {
  2613. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
  2614. return false;
  2615. }
  2616. }
  2618. return true;
  2619. }
  2621. FLAC__bool open_tempfile_(const char *filename, const char *tempfile_path_prefix, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status)
  2622. {
  2623. static const char *tempfile_suffix = ".metadata_edit";
  2624. if(0 == tempfile_path_prefix) {
  2625. if(0 == (*tempfilename = (char*)malloc(strlen(filename) + strlen(tempfile_suffix) + 1))) {
  2626. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  2627. return false;
  2628. }
  2629. strcpy(*tempfilename, filename);
  2630. strcat(*tempfilename, tempfile_suffix);
  2631. }
  2632. else {
  2633. const char *p = strrchr(filename, '/');
  2634. if(0 == p)
  2635. p = filename;
  2636. else
  2637. p++;
  2639. if(0 == (*tempfilename = (char*)malloc(strlen(tempfile_path_prefix) + 1 + strlen(p) + strlen(tempfile_suffix) + 1))) {
  2640. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
  2641. return false;
  2642. }
  2643. strcpy(*tempfilename, tempfile_path_prefix);
  2644. strcat(*tempfilename, "/");
  2645. strcat(*tempfilename, p);
  2646. strcat(*tempfilename, tempfile_suffix);
  2647. }
  2649. if(0 == (*tempfile = fopen(*tempfilename, "w+b"))) {
  2650. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE;
  2651. return false;
  2652. }
  2654. return true;
  2655. }
  2657. FLAC__bool transport_tempfile_(const char *filename, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status)
  2658. {
  2659. FLAC__ASSERT(0 != filename);
  2660. FLAC__ASSERT(0 != tempfile);
  2661. FLAC__ASSERT(0 != *tempfile);
  2662. FLAC__ASSERT(0 != tempfilename);
  2663. FLAC__ASSERT(0 != *tempfilename);
  2664. FLAC__ASSERT(0 != status);
  2666. (void)fclose(*tempfile);
  2667. *tempfile = 0;
  2669. #if defined _MSC_VER || defined __MINGW32__
  2670. if(_unlink(filename) < 0) {
  2671. cleanup_tempfile_(tempfile, tempfilename);
  2672. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR;
  2673. return false;
  2674. }
  2675. #endif
  2677. /*@@@ to fully support the tempfile_path_prefix we need to update this piece to actually copy across filesystems instead of just rename(): */
  2678. if(0 != rename(*tempfilename, filename)) {
  2679. cleanup_tempfile_(tempfile, tempfilename);
  2680. *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR;
  2681. return false;
  2682. }
  2684. cleanup_tempfile_(tempfile, tempfilename);
  2686. return true;
  2687. }
  2689. void cleanup_tempfile_(FILE **tempfile, char **tempfilename)
  2690. {
  2691. if(0 != *tempfile) {
  2692. (void)fclose(*tempfile);
  2693. *tempfile = 0;
  2694. }
  2696. if(0 != *tempfilename) {
  2697. (void)_unlink(*tempfilename);
  2698. free(*tempfilename);
  2699. *tempfilename = 0;
  2700. }
  2701. }
  2703. FLAC__bool get_file_stats_(const char *filename, struct stat *stats)
  2704. {
  2705. FLAC__ASSERT(0 != filename);
  2706. FLAC__ASSERT(0 != stats);
  2707. return (0 == stat(filename, stats));
  2708. }
  2710. /* @@@ WATCHOUT @@@
  2711.  * We cast FLAC__int64 to long and use fseek()/ftell() because
  2712.  * none of our operations on metadata is ever likely to go past
  2713.  * 2 gigabytes.
  2714.  */
  2715. int fseek_wrapper_(FLAC__IOHandle handle, FLAC__int64 offset, int whence)
  2716. {
  2717. FLAC__ASSERT(offset <= 0x7fffffff);
  2718. return fseek((FILE*)handle, (long)offset, whence);
  2719. }
  2721. FLAC__int64 ftell_wrapper_(FLAC__IOHandle handle)
  2722. {
  2723. return (long)ftell((FILE*)handle);
  2724. }
  2726. FLAC__Metadata_ChainStatus get_equivalent_status_(FLAC__Metadata_SimpleIteratorStatus status)
  2727. {
  2728. switch(status) {
  2729. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK:
  2730. return FLAC__METADATA_CHAIN_STATUS_OK;
  2731. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT:
  2732. return FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT;
  2733. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE:
  2734. return FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
  2735. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE:
  2736. return FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE;
  2737. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE:
  2738. return FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE;
  2739. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA:
  2740. return FLAC__METADATA_CHAIN_STATUS_BAD_METADATA;
  2741. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR:
  2742. return FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
  2743. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR:
  2744. return FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
  2745. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR:
  2746. return FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
  2747. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR:
  2748. return FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR;
  2749. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR:
  2750. return FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR;
  2751. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR:
  2752. return FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
  2753. case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR:
  2754. default:
  2755. return FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR;
  2756. }
  2757. }