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

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

Windows CE

开发平台：

C/C++

metadata_object.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 <stdlib.h>
  33. #include <string.h>
  35. #include "private/metadata.h"
  37. #include "FLAC/assert.h"
  39. /****************************************************************************
  40.  *
  41.  * Local routines
  42.  *
  43.  ***************************************************************************/
  45. static FLAC__bool copy_bytes_(FLAC__byte **to, const FLAC__byte *from, unsigned bytes)
  46. {
  47. if(bytes > 0 && 0 != from) {
  48. FLAC__byte *x;
  49. if(0 == (x = (FLAC__byte*)malloc(bytes)))
  50. return false;
  51. memcpy(x, from, bytes);
  52. *to = x;
  53. }
  54. else {
  55. FLAC__ASSERT(0 == from);
  56. FLAC__ASSERT(bytes == 0);
  57. *to = 0;
  58. }
  59. return true;
  60. }
  62. static FLAC__bool ensure_null_terminated_(FLAC__byte **entry, unsigned length)
  63. {
  64. FLAC__byte *x = (FLAC__byte*)realloc(*entry, length+1);
  65. if(0 != x) {
  66. x[length] = '';
  67. *entry = x;
  68. return true;
  69. }
  70. else
  71. return false;
  72. }
  74. static FLAC__bool copy_vcentry_(FLAC__StreamMetadata_VorbisComment_Entry *to, const FLAC__StreamMetadata_VorbisComment_Entry *from)
  75. {
  76. to->length = from->length;
  77. if(0 == from->entry) {
  78. FLAC__ASSERT(from->length == 0);
  79. to->entry = 0;
  80. }
  81. else {
  82. FLAC__byte *x;
  83. FLAC__ASSERT(from->length > 0);
  84. if(0 == (x = (FLAC__byte*)malloc(from->length+1)))
  85. return false;
  86. memcpy(x, from->entry, from->length);
  87. x[from->length] = '';
  88. to->entry = x;
  89. }
  90. return true;
  91. }
  93. static FLAC__bool copy_track_(FLAC__StreamMetadata_CueSheet_Track *to, const FLAC__StreamMetadata_CueSheet_Track *from)
  94. {
  95. memcpy(to, from, sizeof(FLAC__StreamMetadata_CueSheet_Track));
  96. if(0 == from->indices) {
  97. FLAC__ASSERT(from->num_indices == 0);
  98. }
  99. else {
  100. FLAC__StreamMetadata_CueSheet_Index *x;
  101. FLAC__ASSERT(from->num_indices > 0);
  102. if(0 == (x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index))))
  103. return false;
  104. memcpy(x, from->indices, from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
  105. to->indices = x;
  106. }
  107. return true;
  108. }
  110. static void seektable_calculate_length_(FLAC__StreamMetadata *object)
  111. {
  112. FLAC__ASSERT(0 != object);
  113. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  115. object->length = object->data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
  116. }
  118. static FLAC__StreamMetadata_SeekPoint *seekpoint_array_new_(unsigned num_points)
  119. {
  120. FLAC__StreamMetadata_SeekPoint *object_array;
  122. FLAC__ASSERT(num_points > 0);
  124. object_array = (FLAC__StreamMetadata_SeekPoint*)malloc(num_points * sizeof(FLAC__StreamMetadata_SeekPoint));
  126. if(0 != object_array) {
  127. unsigned i;
  128. for(i = 0; i < num_points; i++) {
  129. object_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  130. object_array[i].stream_offset = 0;
  131. object_array[i].frame_samples = 0;
  132. }
  133. }
  135. return object_array;
  136. }
  138. static void vorbiscomment_calculate_length_(FLAC__StreamMetadata *object)
  139. {
  140. unsigned i;
  142. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  144. object->length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN) / 8;
  145. object->length += object->data.vorbis_comment.vendor_string.length;
  146. object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN) / 8;
  147. for(i = 0; i < object->data.vorbis_comment.num_comments; i++) {
  148. object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8);
  149. object->length += object->data.vorbis_comment.comments[i].length;
  150. }
  151. }
  153. static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_new_(unsigned num_comments)
  154. {
  155. FLAC__ASSERT(num_comments > 0);
  157. return (FLAC__StreamMetadata_VorbisComment_Entry*)calloc(num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
  158. }
  160. static void vorbiscomment_entry_array_delete_(FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
  161. {
  162. unsigned i;
  164. FLAC__ASSERT(0 != object_array && num_comments > 0);
  166. for(i = 0; i < num_comments; i++)
  167. if(0 != object_array[i].entry)
  168. free(object_array[i].entry);
  170. if(0 != object_array)
  171. free(object_array);
  172. }
  174. static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_copy_(const FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
  175. {
  176. FLAC__StreamMetadata_VorbisComment_Entry *return_array;
  178. FLAC__ASSERT(0 != object_array);
  179. FLAC__ASSERT(num_comments > 0);
  181. return_array = vorbiscomment_entry_array_new_(num_comments);
  183. if(0 != return_array) {
  184. unsigned i;
  186. for(i = 0; i < num_comments; i++) {
  187. if(!copy_vcentry_(return_array+i, object_array+i)) {
  188. vorbiscomment_entry_array_delete_(return_array, num_comments);
  189. return 0;
  190. }
  191. }
  192. }
  194. return return_array;
  195. }
  197. static FLAC__bool vorbiscomment_set_entry_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry *dest, const FLAC__StreamMetadata_VorbisComment_Entry *src, FLAC__bool copy)
  198. {
  199. FLAC__byte *save;
  201. FLAC__ASSERT(0 != object);
  202. FLAC__ASSERT(0 != dest);
  203. FLAC__ASSERT(0 != src);
  204. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  205. FLAC__ASSERT((0 != src->entry && src->length > 0) || (0 == src->entry && src->length == 0));
  207. save = dest->entry;
  209. if(0 != src->entry && src->length > 0) {
  210. if(copy) {
  211. /* do the copy first so that if we fail we leave the dest object untouched */
  212. if(!copy_vcentry_(dest, src))
  213. return false;
  214. }
  215. else {
  216. /* we have to make sure that the string we're taking over is null-terminated */
  218. /*
  219.  * Stripping the const from src->entry is OK since we're taking
  220.  * ownership of the pointer.  This is a hack around a deficiency
  221.  * in the API where the same function is used for 'copy' and
  222.  * 'own', but the source entry is a const pointer.  If we were
  223.  * precise, the 'own' flavor would be a separate function with a
  224.  * non-const source pointer.  But it's not, so we hack away.
  225.  */
  226. if(!ensure_null_terminated_((FLAC__byte**)(&src->entry), src->length))
  227. return false;
  228. *dest = *src;
  229. }
  230. }
  231. else {
  232. /* the src is null */
  233. *dest = *src;
  234. }
  236. if(0 != save)
  237. free(save);
  239. vorbiscomment_calculate_length_(object);
  240. return true;
  241. }
  243. static int vorbiscomment_find_entry_from_(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name, unsigned field_name_length)
  244. {
  245. unsigned i;
  247. FLAC__ASSERT(0 != object);
  248. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  249. FLAC__ASSERT(0 != field_name);
  251. for(i = offset; i < object->data.vorbis_comment.num_comments; i++) {
  252. if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length))
  253. return (int)i;
  254. }
  256. return -1;
  257. }
  259. static void cuesheet_calculate_length_(FLAC__StreamMetadata *object)
  260. {
  261. unsigned i;
  263. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  265. object->length = (
  266. FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
  267. FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
  268. FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
  269. FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
  270. FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
  271. ) / 8;
  273. object->length += object->data.cue_sheet.num_tracks * (
  274. FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
  275. FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
  276. FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
  277. FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
  278. FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
  279. FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
  280. FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
  281. ) / 8;
  283. for(i = 0; i < object->data.cue_sheet.num_tracks; i++) {
  284. object->length += object->data.cue_sheet.tracks[i].num_indices * (
  285. FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
  286. FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
  287. FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
  288. ) / 8;
  289. }
  290. }
  292. static FLAC__StreamMetadata_CueSheet_Index *cuesheet_track_index_array_new_(unsigned num_indices)
  293. {
  294. FLAC__ASSERT(num_indices > 0);
  296. return (FLAC__StreamMetadata_CueSheet_Index*)calloc(num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index));
  297. }
  299. static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_new_(unsigned num_tracks)
  300. {
  301. FLAC__ASSERT(num_tracks > 0);
  303. return (FLAC__StreamMetadata_CueSheet_Track*)calloc(num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track));
  304. }
  306. static void cuesheet_track_array_delete_(FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks)
  307. {
  308. unsigned i;
  310. FLAC__ASSERT(0 != object_array && num_tracks > 0);
  312. for(i = 0; i < num_tracks; i++) {
  313. if(0 != object_array[i].indices) {
  314. FLAC__ASSERT(object_array[i].num_indices > 0);
  315. free(object_array[i].indices);
  316. }
  317. }
  319. if(0 != object_array)
  320. free(object_array);
  321. }
  323. static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_copy_(const FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks)
  324. {
  325. FLAC__StreamMetadata_CueSheet_Track *return_array;
  327. FLAC__ASSERT(0 != object_array);
  328. FLAC__ASSERT(num_tracks > 0);
  330. return_array = cuesheet_track_array_new_(num_tracks);
  332. if(0 != return_array) {
  333. unsigned i;
  335. for(i = 0; i < num_tracks; i++) {
  336. if(!copy_track_(return_array+i, object_array+i)) {
  337. cuesheet_track_array_delete_(return_array, num_tracks);
  338. return 0;
  339. }
  340. }
  341. }
  343. return return_array;
  344. }
  346. static FLAC__bool cuesheet_set_track_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_CueSheet_Track *dest, const FLAC__StreamMetadata_CueSheet_Track *src, FLAC__bool copy)
  347. {
  348. FLAC__StreamMetadata_CueSheet_Index *save;
  350. FLAC__ASSERT(0 != object);
  351. FLAC__ASSERT(0 != dest);
  352. FLAC__ASSERT(0 != src);
  353. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  354. FLAC__ASSERT((0 != src->indices && src->num_indices > 0) || (0 == src->indices && src->num_indices == 0));
  356. save = dest->indices;
  358. /* do the copy first so that if we fail we leave the object untouched */
  359. if(copy) {
  360. if(!copy_track_(dest, src))
  361. return false;
  362. }
  363. else {
  364. *dest = *src;
  365. }
  367. if(0 != save)
  368. free(save);
  370. cuesheet_calculate_length_(object);
  371. return true;
  372. }
  375. /****************************************************************************
  376.  *
  377.  * Metadata object routines
  378.  *
  379.  ***************************************************************************/
  381. FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type)
  382. {
  383. FLAC__StreamMetadata *object;
  385. if(type > FLAC__MAX_METADATA_TYPE_CODE)
  386. return 0;
  388. object = (FLAC__StreamMetadata*)calloc(1, sizeof(FLAC__StreamMetadata));
  389. if(0 != object) {
  390. object->is_last = false;
  391. object->type = type;
  392. switch(type) {
  393. case FLAC__METADATA_TYPE_STREAMINFO:
  394. object->length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
  395. break;
  396. case FLAC__METADATA_TYPE_PADDING:
  397. /* calloc() took care of this for us:
  398. object->length = 0;
  399. */
  400. break;
  401. case FLAC__METADATA_TYPE_APPLICATION:
  402. object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
  403. /* calloc() took care of this for us:
  404. object->data.application.data = 0;
  405. */
  406. break;
  407. case FLAC__METADATA_TYPE_SEEKTABLE:
  408. /* calloc() took care of this for us:
  409. object->length = 0;
  410. object->data.seek_table.num_points = 0;
  411. object->data.seek_table.points = 0;
  412. */
  413. break;
  414. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  415. {
  416. object->data.vorbis_comment.vendor_string.length = (unsigned)strlen(FLAC__VENDOR_STRING);
  417. if(!copy_bytes_(&object->data.vorbis_comment.vendor_string.entry, (const FLAC__byte*)FLAC__VENDOR_STRING, object->data.vorbis_comment.vendor_string.length+1)) {
  418. free(object);
  419. return 0;
  420. }
  421. vorbiscomment_calculate_length_(object);
  422. }
  423. break;
  424. case FLAC__METADATA_TYPE_CUESHEET:
  425. cuesheet_calculate_length_(object);
  426. break;
  427. default:
  428. /* calloc() took care of this for us:
  429. object->length = 0;
  430. object->data.unknown.data = 0;
  431. */
  432. break;
  433. }
  434. }
  436. return object;
  437. }
  439. FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object)
  440. {
  441. FLAC__StreamMetadata *to;
  443. FLAC__ASSERT(0 != object);
  445. if(0 != (to = FLAC__metadata_object_new(object->type))) {
  446. to->is_last = object->is_last;
  447. to->type = object->type;
  448. to->length = object->length;
  449. switch(to->type) {
  450. case FLAC__METADATA_TYPE_STREAMINFO:
  451. memcpy(&to->data.stream_info, &object->data.stream_info, sizeof(FLAC__StreamMetadata_StreamInfo));
  452. break;
  453. case FLAC__METADATA_TYPE_PADDING:
  454. break;
  455. case FLAC__METADATA_TYPE_APPLICATION:
  456. memcpy(&to->data.application.id, &object->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8);
  457. if(!copy_bytes_(&to->data.application.data, object->data.application.data, object->length - FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)) {
  458. FLAC__metadata_object_delete(to);
  459. return 0;
  460. }
  461. break;
  462. case FLAC__METADATA_TYPE_SEEKTABLE:
  463. to->data.seek_table.num_points = object->data.seek_table.num_points;
  464. if(!copy_bytes_((FLAC__byte**)&to->data.seek_table.points, (FLAC__byte*)object->data.seek_table.points, object->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint))) {
  465. FLAC__metadata_object_delete(to);
  466. return 0;
  467. }
  468. break;
  469. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  470. if(0 != to->data.vorbis_comment.vendor_string.entry) {
  471. free(to->data.vorbis_comment.vendor_string.entry);
  472. to->data.vorbis_comment.vendor_string.entry = 0;
  473. }
  474. if(!copy_vcentry_(&to->data.vorbis_comment.vendor_string, &object->data.vorbis_comment.vendor_string)) {
  475. FLAC__metadata_object_delete(to);
  476. return 0;
  477. }
  478. if(object->data.vorbis_comment.num_comments == 0) {
  479. FLAC__ASSERT(0 == object->data.vorbis_comment.comments);
  480. to->data.vorbis_comment.comments = 0;
  481. }
  482. else {
  483. FLAC__ASSERT(0 != object->data.vorbis_comment.comments);
  484. to->data.vorbis_comment.comments = vorbiscomment_entry_array_copy_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments);
  485. if(0 == to->data.vorbis_comment.comments) {
  486. FLAC__metadata_object_delete(to);
  487. return 0;
  488. }
  489. }
  490. to->data.vorbis_comment.num_comments = object->data.vorbis_comment.num_comments;
  491. break;
  492. case FLAC__METADATA_TYPE_CUESHEET:
  493. memcpy(&to->data.cue_sheet, &object->data.cue_sheet, sizeof(FLAC__StreamMetadata_CueSheet));
  494. if(object->data.cue_sheet.num_tracks == 0) {
  495. FLAC__ASSERT(0 == object->data.cue_sheet.tracks);
  496. }
  497. else {
  498. FLAC__ASSERT(0 != object->data.cue_sheet.tracks);
  499. to->data.cue_sheet.tracks = cuesheet_track_array_copy_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks);
  500. if(0 == to->data.cue_sheet.tracks) {
  501. FLAC__metadata_object_delete(to);
  502. return 0;
  503. }
  504. }
  505. break;
  506. default:
  507. if(!copy_bytes_(&to->data.unknown.data, object->data.unknown.data, object->length)) {
  508. FLAC__metadata_object_delete(to);
  509. return 0;
  510. }
  511. break;
  512. }
  513. }
  515. return to;
  516. }
  518. void FLAC__metadata_object_delete_data(FLAC__StreamMetadata *object)
  519. {
  520. FLAC__ASSERT(0 != object);
  522. switch(object->type) {
  523. case FLAC__METADATA_TYPE_STREAMINFO:
  524. case FLAC__METADATA_TYPE_PADDING:
  525. break;
  526. case FLAC__METADATA_TYPE_APPLICATION:
  527. if(0 != object->data.application.data) {
  528. free(object->data.application.data);
  529. object->data.application.data = 0;
  530. }
  531. break;
  532. case FLAC__METADATA_TYPE_SEEKTABLE:
  533. if(0 != object->data.seek_table.points) {
  534. free(object->data.seek_table.points);
  535. object->data.seek_table.points = 0;
  536. }
  537. break;
  538. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  539. if(0 != object->data.vorbis_comment.vendor_string.entry) {
  540. free(object->data.vorbis_comment.vendor_string.entry);
  541. object->data.vorbis_comment.vendor_string.entry = 0;
  542. }
  543. if(0 != object->data.vorbis_comment.comments) {
  544. FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0);
  545. vorbiscomment_entry_array_delete_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments);
  546. }
  547. break;
  548. case FLAC__METADATA_TYPE_CUESHEET:
  549. if(0 != object->data.cue_sheet.tracks) {
  550. FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0);
  551. cuesheet_track_array_delete_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks);
  552. }
  553. break;
  554. default:
  555. if(0 != object->data.unknown.data) {
  556. free(object->data.unknown.data);
  557. object->data.unknown.data = 0;
  558. }
  559. break;
  560. }
  561. }
  563. FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object)
  564. {
  565. FLAC__metadata_object_delete_data(object);
  566. free(object);
  567. }
  569. static FLAC__bool compare_block_data_streaminfo_(const FLAC__StreamMetadata_StreamInfo *block1, const FLAC__StreamMetadata_StreamInfo *block2)
  570. {
  571. if(block1->min_blocksize != block2->min_blocksize)
  572. return false;
  573. if(block1->max_blocksize != block2->max_blocksize)
  574. return false;
  575. if(block1->min_framesize != block2->min_framesize)
  576. return false;
  577. if(block1->max_framesize != block2->max_framesize)
  578. return false;
  579. if(block1->sample_rate != block2->sample_rate)
  580. return false;
  581. if(block1->channels != block2->channels)
  582. return false;
  583. if(block1->bits_per_sample != block2->bits_per_sample)
  584. return false;
  585. if(block1->total_samples != block2->total_samples)
  586. return false;
  587. if(0 != memcmp(block1->md5sum, block2->md5sum, 16))
  588. return false;
  589. return true;
  590. }
  592. static FLAC__bool compare_block_data_application_(const FLAC__StreamMetadata_Application *block1, const FLAC__StreamMetadata_Application *block2, unsigned block_length)
  593. {
  594. FLAC__ASSERT(0 != block1);
  595. FLAC__ASSERT(0 != block2);
  596. FLAC__ASSERT(block_length >= sizeof(block1->id));
  598. if(0 != memcmp(block1->id, block2->id, sizeof(block1->id)))
  599. return false;
  600. if(0 != block1->data && 0 != block2->data)
  601. return 0 == memcmp(block1->data, block2->data, block_length - sizeof(block1->id));
  602. else
  603. return block1->data == block2->data;
  604. }
  606. static FLAC__bool compare_block_data_seektable_(const FLAC__StreamMetadata_SeekTable *block1, const FLAC__StreamMetadata_SeekTable *block2)
  607. {
  608. unsigned i;
  610. FLAC__ASSERT(0 != block1);
  611. FLAC__ASSERT(0 != block2);
  613. if(block1->num_points != block2->num_points)
  614. return false;
  616. if(0 != block1->points && 0 != block2->points) {
  617. for(i = 0; i < block1->num_points; i++) {
  618. if(block1->points[i].sample_number != block2->points[i].sample_number)
  619. return false;
  620. if(block1->points[i].stream_offset != block2->points[i].stream_offset)
  621. return false;
  622. if(block1->points[i].frame_samples != block2->points[i].frame_samples)
  623. return false;
  624. }
  625. return true;
  626. }
  627. else
  628. return block1->points == block2->points;
  629. }
  631. static FLAC__bool compare_block_data_vorbiscomment_(const FLAC__StreamMetadata_VorbisComment *block1, const FLAC__StreamMetadata_VorbisComment *block2)
  632. {
  633. unsigned i;
  635. if(block1->vendor_string.length != block2->vendor_string.length)
  636. return false;
  638. if(0 != block1->vendor_string.entry && 0 != block2->vendor_string.entry) {
  639. if(0 != memcmp(block1->vendor_string.entry, block2->vendor_string.entry, block1->vendor_string.length))
  640. return false;
  641. }
  642. else if(block1->vendor_string.entry != block2->vendor_string.entry)
  643. return false;
  645. if(block1->num_comments != block2->num_comments)
  646. return false;
  648. for(i = 0; i < block1->num_comments; i++) {
  649. if(0 != block1->comments[i].entry && 0 != block2->comments[i].entry) {
  650. if(0 != memcmp(block1->comments[i].entry, block2->comments[i].entry, block1->comments[i].length))
  651. return false;
  652. }
  653. else if(block1->comments[i].entry != block2->comments[i].entry)
  654. return false;
  655. }
  656. return true;
  657. }
  659. static FLAC__bool compare_block_data_cuesheet_(const FLAC__StreamMetadata_CueSheet *block1, const FLAC__StreamMetadata_CueSheet *block2)
  660. {
  661. unsigned i, j;
  663. if(0 != strcmp(block1->media_catalog_number, block2->media_catalog_number))
  664. return false;
  666. if(block1->lead_in != block2->lead_in)
  667. return false;
  669. if(block1->is_cd != block2->is_cd)
  670. return false;
  672. if(block1->num_tracks != block2->num_tracks)
  673. return false;
  675. if(0 != block1->tracks && 0 != block2->tracks) {
  676. FLAC__ASSERT(block1->num_tracks > 0);
  677. for(i = 0; i < block1->num_tracks; i++) {
  678. if(block1->tracks[i].offset != block2->tracks[i].offset)
  679. return false;
  680. if(block1->tracks[i].number != block2->tracks[i].number)
  681. return false;
  682. if(0 != memcmp(block1->tracks[i].isrc, block2->tracks[i].isrc, sizeof(block1->tracks[i].isrc)))
  683. return false;
  684. if(block1->tracks[i].type != block2->tracks[i].type)
  685. return false;
  686. if(block1->tracks[i].pre_emphasis != block2->tracks[i].pre_emphasis)
  687. return false;
  688. if(block1->tracks[i].num_indices != block2->tracks[i].num_indices)
  689. return false;
  690. if(0 != block1->tracks[i].indices && 0 != block2->tracks[i].indices) {
  691. FLAC__ASSERT(block1->tracks[i].num_indices > 0);
  692. for(j = 0; j < block1->tracks[i].num_indices; j++) {
  693. if(block1->tracks[i].indices[j].offset != block2->tracks[i].indices[j].offset)
  694. return false;
  695. if(block1->tracks[i].indices[j].number != block2->tracks[i].indices[j].number)
  696. return false;
  697. }
  698. }
  699. else if(block1->tracks[i].indices != block2->tracks[i].indices)
  700. return false;
  701. }
  702. }
  703. else if(block1->tracks != block2->tracks)
  704. return false;
  705. return true;
  706. }
  708. static FLAC__bool compare_block_data_unknown_(const FLAC__StreamMetadata_Unknown *block1, const FLAC__StreamMetadata_Unknown *block2, unsigned block_length)
  709. {
  710. FLAC__ASSERT(0 != block1);
  711. FLAC__ASSERT(0 != block2);
  713. if(0 != block1->data && 0 != block2->data)
  714. return 0 == memcmp(block1->data, block2->data, block_length);
  715. else
  716. return block1->data == block2->data;
  717. }
  719. FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2)
  720. {
  721. FLAC__ASSERT(0 != block1);
  722. FLAC__ASSERT(0 != block2);
  724. if(block1->type != block2->type) {
  725. return false;
  726. }
  727. if(block1->is_last != block2->is_last) {
  728. return false;
  729. }
  730. if(block1->length != block2->length) {
  731. return false;
  732. }
  733. switch(block1->type) {
  734. case FLAC__METADATA_TYPE_STREAMINFO:
  735. return compare_block_data_streaminfo_(&block1->data.stream_info, &block2->data.stream_info);
  736. case FLAC__METADATA_TYPE_PADDING:
  737. return true; /* we don't compare the padding guts */
  738. case FLAC__METADATA_TYPE_APPLICATION:
  739. return compare_block_data_application_(&block1->data.application, &block2->data.application, block1->length);
  740. case FLAC__METADATA_TYPE_SEEKTABLE:
  741. return compare_block_data_seektable_(&block1->data.seek_table, &block2->data.seek_table);
  742. case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  743. return compare_block_data_vorbiscomment_(&block1->data.vorbis_comment, &block2->data.vorbis_comment);
  744. case FLAC__METADATA_TYPE_CUESHEET:
  745. return compare_block_data_cuesheet_(&block1->data.cue_sheet, &block2->data.cue_sheet);
  746. default:
  747. return compare_block_data_unknown_(&block1->data.unknown, &block2->data.unknown, block1->length);
  748. }
  749. }
  751. FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy)
  752. {
  753. FLAC__byte *save;
  755. FLAC__ASSERT(0 != object);
  756. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_APPLICATION);
  757. FLAC__ASSERT((0 != data && length > 0) || (0 == data && length == 0 && copy == false));
  759. save = object->data.application.data;
  761. /* do the copy first so that if we fail we leave the object untouched */
  762. if(copy) {
  763. if(!copy_bytes_(&object->data.application.data, data, length))
  764. return false;
  765. }
  766. else {
  767. object->data.application.data = data;
  768. }
  770. if(0 != save)
  771. free(save);
  773. object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8 + length;
  774. return true;
  775. }
  777. FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points)
  778. {
  779. FLAC__ASSERT(0 != object);
  780. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  782. if(0 == object->data.seek_table.points) {
  783. FLAC__ASSERT(object->data.seek_table.num_points == 0);
  784. if(0 == new_num_points)
  785. return true;
  786. else if(0 == (object->data.seek_table.points = seekpoint_array_new_(new_num_points)))
  787. return false;
  788. }
  789. else {
  790. const unsigned old_size = object->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint);
  791. const unsigned new_size = new_num_points * sizeof(FLAC__StreamMetadata_SeekPoint);
  793. FLAC__ASSERT(object->data.seek_table.num_points > 0);
  795. if(new_size == 0) {
  796. free(object->data.seek_table.points);
  797. object->data.seek_table.points = 0;
  798. }
  799. else if(0 == (object->data.seek_table.points = (FLAC__StreamMetadata_SeekPoint*)realloc(object->data.seek_table.points, new_size)))
  800. return false;
  802. /* if growing, set new elements to placeholders */
  803. if(new_size > old_size) {
  804. unsigned i;
  805. for(i = object->data.seek_table.num_points; i < new_num_points; i++) {
  806. object->data.seek_table.points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  807. object->data.seek_table.points[i].stream_offset = 0;
  808. object->data.seek_table.points[i].frame_samples = 0;
  809. }
  810. }
  811. }
  813. object->data.seek_table.num_points = new_num_points;
  815. seektable_calculate_length_(object);
  816. return true;
  817. }
  819. FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point)
  820. {
  821. FLAC__ASSERT(0 != object);
  822. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  823. FLAC__ASSERT(point_num < object->data.seek_table.num_points);
  825. object->data.seek_table.points[point_num] = point;
  826. }
  828. FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point)
  829. {
  830. int i;
  832. FLAC__ASSERT(0 != object);
  833. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  834. FLAC__ASSERT(point_num <= object->data.seek_table.num_points);
  836. if(!FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points+1))
  837. return false;
  839. /* move all points >= point_num forward one space */
  840. for(i = (int)object->data.seek_table.num_points-1; i > (int)point_num; i--)
  841. object->data.seek_table.points[i] = object->data.seek_table.points[i-1];
  843. FLAC__metadata_object_seektable_set_point(object, point_num, point);
  844. seektable_calculate_length_(object);
  845. return true;
  846. }
  848. FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num)
  849. {
  850. unsigned i;
  852. FLAC__ASSERT(0 != object);
  853. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  854. FLAC__ASSERT(point_num < object->data.seek_table.num_points);
  856. /* move all points > point_num backward one space */
  857. for(i = point_num; i < object->data.seek_table.num_points-1; i++)
  858. object->data.seek_table.points[i] = object->data.seek_table.points[i+1];
  860. return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points-1);
  861. }
  863. FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object)
  864. {
  865. FLAC__ASSERT(0 != object);
  866. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  868. return FLAC__format_seektable_is_legal(&object->data.seek_table);
  869. }
  871. FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num)
  872. {
  873. FLAC__ASSERT(0 != object);
  874. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  876. if(num > 0)
  877. /* WATCHOUT: we rely on the fact that growing the array adds PLACEHOLDERS at the end */
  878. return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points + num);
  879. else
  880. return true;
  881. }
  883. FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number)
  884. {
  885. FLAC__StreamMetadata_SeekTable *seek_table;
  887. FLAC__ASSERT(0 != object);
  888. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  890. seek_table = &object->data.seek_table;
  892. if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + 1))
  893. return false;
  895. seek_table->points[seek_table->num_points - 1].sample_number = sample_number;
  896. seek_table->points[seek_table->num_points - 1].stream_offset = 0;
  897. seek_table->points[seek_table->num_points - 1].frame_samples = 0;
  899. return true;
  900. }
  902. FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num)
  903. {
  904. FLAC__ASSERT(0 != object);
  905. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  906. FLAC__ASSERT(0 != sample_numbers || num == 0);
  908. if(num > 0) {
  909. FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
  910. unsigned i, j;
  912. i = seek_table->num_points;
  914. if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num))
  915. return false;
  917. for(j = 0; j < num; i++, j++) {
  918. seek_table->points[i].sample_number = sample_numbers[j];
  919. seek_table->points[i].stream_offset = 0;
  920. seek_table->points[i].frame_samples = 0;
  921. }
  922. }
  924. return true;
  925. }
  927. FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples)
  928. {
  929. FLAC__ASSERT(0 != object);
  930. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  931. FLAC__ASSERT(total_samples > 0);
  933. if(num > 0) {
  934. FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
  935. unsigned i, j;
  937. i = seek_table->num_points;
  939. if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num))
  940. return false;
  942. for(j = 0; j < num; i++, j++) {
  943. seek_table->points[i].sample_number = total_samples * (FLAC__uint64)j / (FLAC__uint64)num;
  944. seek_table->points[i].stream_offset = 0;
  945. seek_table->points[i].frame_samples = 0;
  946. }
  947. }
  949. return true;
  950. }
  952. FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact)
  953. {
  954. unsigned unique;
  956. FLAC__ASSERT(0 != object);
  957. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
  959. unique = FLAC__format_seektable_sort(&object->data.seek_table);
  961. return !compact || FLAC__metadata_object_seektable_resize_points(object, unique);
  962. }
  964. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
  965. {
  966. if(!FLAC__format_vorbiscomment_entry_value_is_legal(entry.entry, entry.length))
  967. return false;
  968. return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.vendor_string, &entry, copy);
  969. }
  971. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments)
  972. {
  973. FLAC__ASSERT(0 != object);
  974. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  976. if(0 == object->data.vorbis_comment.comments) {
  977. FLAC__ASSERT(object->data.vorbis_comment.num_comments == 0);
  978. if(0 == new_num_comments)
  979. return true;
  980. else if(0 == (object->data.vorbis_comment.comments = vorbiscomment_entry_array_new_(new_num_comments)))
  981. return false;
  982. }
  983. else {
  984. const unsigned old_size = object->data.vorbis_comment.num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry);
  985. const unsigned new_size = new_num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry);
  987. FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0);
  989. /* if shrinking, free the truncated entries */
  990. if(new_num_comments < object->data.vorbis_comment.num_comments) {
  991. unsigned i;
  992. for(i = new_num_comments; i < object->data.vorbis_comment.num_comments; i++)
  993. if(0 != object->data.vorbis_comment.comments[i].entry)
  994. free(object->data.vorbis_comment.comments[i].entry);
  995. }
  997. if(new_size == 0) {
  998. free(object->data.vorbis_comment.comments);
  999. object->data.vorbis_comment.comments = 0;
  1000. }
  1001. else if(0 == (object->data.vorbis_comment.comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(object->data.vorbis_comment.comments, new_size)))
  1002. return false;
  1004. /* if growing, zero all the length/pointers of new elements */
  1005. if(new_size > old_size)
  1006. memset(object->data.vorbis_comment.comments + object->data.vorbis_comment.num_comments, 0, new_size - old_size);
  1007. }
  1009. object->data.vorbis_comment.num_comments = new_num_comments;
  1011. vorbiscomment_calculate_length_(object);
  1012. return true;
  1013. }
  1015. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
  1016. {
  1017. FLAC__ASSERT(0 != object);
  1018. FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments);
  1020. if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
  1021. return false;
  1022. return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.comments[comment_num], &entry, copy);
  1023. }
  1025. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
  1026. {
  1027. FLAC__StreamMetadata_VorbisComment *vc;
  1029. FLAC__ASSERT(0 != object);
  1030. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1031. FLAC__ASSERT(comment_num <= object->data.vorbis_comment.num_comments);
  1033. if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
  1034. return false;
  1036. vc = &object->data.vorbis_comment;
  1038. if(!FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments+1))
  1039. return false;
  1041. /* move all comments >= comment_num forward one space */
  1042. memmove(&vc->comments[comment_num+1], &vc->comments[comment_num], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-1-comment_num));
  1043. vc->comments[comment_num].length = 0;
  1044. vc->comments[comment_num].entry = 0;
  1046. return FLAC__metadata_object_vorbiscomment_set_comment(object, comment_num, entry, copy);
  1047. }
  1049. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
  1050. {
  1051. FLAC__ASSERT(0 != object);
  1052. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1053. return FLAC__metadata_object_vorbiscomment_insert_comment(object, object->data.vorbis_comment.num_comments, entry, copy);
  1054. }
  1056. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool all, FLAC__bool copy)
  1057. {
  1058. FLAC__ASSERT(0 != entry.entry && entry.length > 0);
  1060. if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
  1061. return false;
  1063. {
  1064. int i;
  1065. unsigned field_name_length;
  1066. const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length);
  1068. FLAC__ASSERT(0 != eq);
  1070. if(0 == eq)
  1071. return false; /* double protection */
  1073. field_name_length = eq-entry.entry;
  1075. if((i = vorbiscomment_find_entry_from_(object, 0, entry.entry, field_name_length)) >= 0) {
  1076. unsigned index = (unsigned)i;
  1077. if(!FLAC__metadata_object_vorbiscomment_set_comment(object, index, entry, copy))
  1078. return false;
  1079. if(all && (index+1 < object->data.vorbis_comment.num_comments)) {
  1080. for(i = vorbiscomment_find_entry_from_(object, index+1, entry.entry, field_name_length); i >= 0; ) {
  1081. if(!FLAC__metadata_object_vorbiscomment_delete_comment(object, (unsigned)i))
  1082. return false;
  1083. if((unsigned)i < object->data.vorbis_comment.num_comments)
  1084. i = vorbiscomment_find_entry_from_(object, (unsigned)i, entry.entry, field_name_length);
  1085. else
  1086. i = -1;
  1087. }
  1088. }
  1089. return true;
  1090. }
  1091. else
  1092. return FLAC__metadata_object_vorbiscomment_append_comment(object, entry, copy);
  1093. }
  1094. }
  1096. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num)
  1097. {
  1098. FLAC__StreamMetadata_VorbisComment *vc;
  1100. FLAC__ASSERT(0 != object);
  1101. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1102. FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments);
  1104. vc = &object->data.vorbis_comment;
  1106. /* free the comment at comment_num */
  1107. if(0 != vc->comments[comment_num].entry)
  1108. free(vc->comments[comment_num].entry);
  1110. /* move all comments > comment_num backward one space */
  1111. memmove(&vc->comments[comment_num], &vc->comments[comment_num+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-comment_num-1));
  1112. vc->comments[vc->num_comments-1].length = 0;
  1113. vc->comments[vc->num_comments-1].entry = 0;
  1115. return FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments-1);
  1116. }
  1118. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field_name, const char *field_value)
  1119. {
  1120. FLAC__ASSERT(0 != entry);
  1121. FLAC__ASSERT(0 != field_name);
  1122. FLAC__ASSERT(0 != field_value);
  1124. if(!FLAC__format_vorbiscomment_entry_name_is_legal(field_name))
  1125. return false;
  1126. if(!FLAC__format_vorbiscomment_entry_value_is_legal(field_value, (unsigned)(-1)))
  1127. return false;
  1129. {
  1130. const size_t nn = strlen(field_name);
  1131. const size_t nv = strlen(field_value);
  1132. entry->length = nn + 1 /*=*/ + nv;
  1133. if(0 == (entry->entry = (FLAC__byte*)malloc(entry->length+1)))
  1134. return false;
  1135. memcpy(entry->entry, field_name, nn);
  1136. entry->entry[nn] = '=';
  1137. memcpy(entry->entry+nn+1, field_value, nv);
  1138. entry->entry[entry->length] = '';
  1139. }
  1141. return true;
  1142. }
  1144. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(const FLAC__StreamMetadata_VorbisComment_Entry entry, char **field_name, char **field_value)
  1145. {
  1146. FLAC__ASSERT(0 != entry.entry && entry.length > 0);
  1147. FLAC__ASSERT(0 != field_name);
  1148. FLAC__ASSERT(0 != field_value);
  1150. if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
  1151. return false;
  1153. {
  1154. const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length);
  1155. const size_t nn = eq-entry.entry;
  1156. const size_t nv = entry.length-nn-1; /* -1 for the '=' */
  1157. FLAC__ASSERT(0 != eq);
  1158. if(0 == eq)
  1159. return false; /* double protection */
  1160. if(0 == (*field_name = (char*)malloc(nn+1)))
  1161. return false;
  1162. if(0 == (*field_value = (char*)malloc(nv+1))) {
  1163. free(*field_name);
  1164. return false;
  1165. }
  1166. memcpy(*field_name, entry.entry, nn);
  1167. memcpy(*field_value, entry.entry+nn+1, nv);
  1168. (*field_name)[nn] = '';
  1169. (*field_value)[nv] = '';
  1170. }
  1172. return true;
  1173. }
  1175. FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, unsigned field_name_length)
  1176. {
  1177. FLAC__ASSERT(0 != entry.entry && entry.length > 0);
  1178. {
  1179. const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length);
  1180. #if defined _MSC_VER || defined __MINGW32__
  1181. #define FLAC__STRNCASECMP _strnicmp
  1182. #elif defined __palmos__
  1183. #define FLAC__STRNCASECMP tcsnicmp
  1184. #else
  1185. #define FLAC__STRNCASECMP strncasecmp
  1186. #endif
  1187. return (0 != eq && (unsigned)(eq-entry.entry) == field_name_length && 0 == FLAC__STRNCASECMP(field_name, (const char *)entry.entry, field_name_length));
  1188. #undef FLAC__STRNCASECMP
  1189. }
  1190. }
  1192. FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name)
  1193. {
  1194. FLAC__ASSERT(0 != field_name);
  1196. return vorbiscomment_find_entry_from_(object, offset, field_name, strlen(field_name));
  1197. }
  1199. FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name)
  1200. {
  1201. const unsigned field_name_length = strlen(field_name);
  1202. unsigned i;
  1204. FLAC__ASSERT(0 != object);
  1205. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1207. for(i = 0; i < object->data.vorbis_comment.num_comments; i++) {
  1208. if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) {
  1209. if(!FLAC__metadata_object_vorbiscomment_delete_comment(object, i))
  1210. return -1;
  1211. else
  1212. return 1;
  1213. }
  1214. }
  1216. return 0;
  1217. }
  1219. FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name)
  1220. {
  1221. FLAC__bool ok = true;
  1222. unsigned matching = 0;
  1223. const unsigned field_name_length = strlen(field_name);
  1224. int i;
  1226. FLAC__ASSERT(0 != object);
  1227. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
  1229. /* must delete from end to start otherwise it will interfere with our iteration */
  1230. for(i = (int)object->data.vorbis_comment.num_comments - 1; ok && i >= 0; i--) {
  1231. if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) {
  1232. matching++;
  1233. ok &= FLAC__metadata_object_vorbiscomment_delete_comment(object, (unsigned)i);
  1234. }
  1235. }
  1237. return ok? (int)matching : -1;
  1238. }
  1240. FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new()
  1241. {
  1242. return (FLAC__StreamMetadata_CueSheet_Track*)calloc(1, sizeof(FLAC__StreamMetadata_CueSheet_Track));
  1243. }
  1245. FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object)
  1246. {
  1247. FLAC__StreamMetadata_CueSheet_Track *to;
  1249. FLAC__ASSERT(0 != object);
  1251. if(0 != (to = FLAC__metadata_object_cuesheet_track_new())) {
  1252. if(!copy_track_(to, object)) {
  1253. FLAC__metadata_object_cuesheet_track_delete(to);
  1254. return 0;
  1255. }
  1256. }
  1258. return to;
  1259. }
  1261. void FLAC__metadata_object_cuesheet_track_delete_data(FLAC__StreamMetadata_CueSheet_Track *object)
  1262. {
  1263. FLAC__ASSERT(0 != object);
  1265. if(0 != object->indices) {
  1266. FLAC__ASSERT(object->num_indices > 0);
  1267. free(object->indices);
  1268. }
  1269. }
  1271. FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object)
  1272. {
  1273. FLAC__metadata_object_cuesheet_track_delete_data(object);
  1274. free(object);
  1275. }
  1277. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices)
  1278. {
  1279. FLAC__StreamMetadata_CueSheet_Track *track;
  1280. FLAC__ASSERT(0 != object);
  1281. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1282. FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
  1284. track = &object->data.cue_sheet.tracks[track_num];
  1286. if(0 == track->indices) {
  1287. FLAC__ASSERT(track->num_indices == 0);
  1288. if(0 == new_num_indices)
  1289. return true;
  1290. else if(0 == (track->indices = cuesheet_track_index_array_new_(new_num_indices)))
  1291. return false;
  1292. }
  1293. else {
  1294. const unsigned old_size = track->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index);
  1295. const unsigned new_size = new_num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index);
  1297. FLAC__ASSERT(track->num_indices > 0);
  1299. if(new_size == 0) {
  1300. free(track->indices);
  1301. track->indices = 0;
  1302. }
  1303. else if(0 == (track->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(track->indices, new_size)))
  1304. return false;
  1306. /* if growing, zero all the lengths/pointers of new elements */
  1307. if(new_size > old_size)
  1308. memset(track->indices + track->num_indices, 0, new_size - old_size);
  1309. }
  1311. track->num_indices = new_num_indices;
  1313. cuesheet_calculate_length_(object);
  1314. return true;
  1315. }
  1317. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num, FLAC__StreamMetadata_CueSheet_Index index)
  1318. {
  1319. FLAC__StreamMetadata_CueSheet_Track *track;
  1321. FLAC__ASSERT(0 != object);
  1322. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1323. FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
  1324. FLAC__ASSERT(index_num <= object->data.cue_sheet.tracks[track_num].num_indices);
  1326. track = &object->data.cue_sheet.tracks[track_num];
  1328. if(!FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices+1))
  1329. return false;
  1331. /* move all indices >= index_num forward one space */
  1332. memmove(&track->indices[index_num+1], &track->indices[index_num], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-1-index_num));
  1334. track->indices[index_num] = index;
  1335. cuesheet_calculate_length_(object);
  1336. return true;
  1337. }
  1339. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num)
  1340. {
  1341. FLAC__StreamMetadata_CueSheet_Index index;
  1342. memset(&index, 0, sizeof(index));
  1343. return FLAC__metadata_object_cuesheet_track_insert_index(object, track_num, index_num, index);
  1344. }
  1346. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num)
  1347. {
  1348. FLAC__StreamMetadata_CueSheet_Track *track;
  1350. FLAC__ASSERT(0 != object);
  1351. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1352. FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
  1353. FLAC__ASSERT(index_num < object->data.cue_sheet.tracks[track_num].num_indices);
  1355. track = &object->data.cue_sheet.tracks[track_num];
  1357. /* move all indices > index_num backward one space */
  1358. memmove(&track->indices[index_num], &track->indices[index_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-index_num-1));
  1360. FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices-1);
  1361. cuesheet_calculate_length_(object);
  1362. return true;
  1363. }
  1365. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks)
  1366. {
  1367. FLAC__ASSERT(0 != object);
  1368. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1370. if(0 == object->data.cue_sheet.tracks) {
  1371. FLAC__ASSERT(object->data.cue_sheet.num_tracks == 0);
  1372. if(0 == new_num_tracks)
  1373. return true;
  1374. else if(0 == (object->data.cue_sheet.tracks = cuesheet_track_array_new_(new_num_tracks)))
  1375. return false;
  1376. }
  1377. else {
  1378. const unsigned old_size = object->data.cue_sheet.num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track);
  1379. const unsigned new_size = new_num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track);
  1381. FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0);
  1383. /* if shrinking, free the truncated entries */
  1384. if(new_num_tracks < object->data.cue_sheet.num_tracks) {
  1385. unsigned i;
  1386. for(i = new_num_tracks; i < object->data.cue_sheet.num_tracks; i++)
  1387. if(0 != object->data.cue_sheet.tracks[i].indices)
  1388. free(object->data.cue_sheet.tracks[i].indices);
  1389. }
  1391. if(new_size == 0) {
  1392. free(object->data.cue_sheet.tracks);
  1393. object->data.cue_sheet.tracks = 0;
  1394. }
  1395. else if(0 == (object->data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(object->data.cue_sheet.tracks, new_size)))
  1396. return false;
  1398. /* if growing, zero all the lengths/pointers of new elements */
  1399. if(new_size > old_size)
  1400. memset(object->data.cue_sheet.tracks + object->data.cue_sheet.num_tracks, 0, new_size - old_size);
  1401. }
  1403. object->data.cue_sheet.num_tracks = new_num_tracks;
  1405. cuesheet_calculate_length_(object);
  1406. return true;
  1407. }
  1409. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy)
  1410. {
  1411. FLAC__ASSERT(0 != object);
  1412. FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
  1414. return cuesheet_set_track_(object, object->data.cue_sheet.tracks + track_num, track, copy);
  1415. }
  1417. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy)
  1418. {
  1419. FLAC__StreamMetadata_CueSheet *cs;
  1421. FLAC__ASSERT(0 != object);
  1422. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1423. FLAC__ASSERT(track_num <= object->data.cue_sheet.num_tracks);
  1425. cs = &object->data.cue_sheet;
  1427. if(!FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks+1))
  1428. return false;
  1430. /* move all tracks >= track_num forward one space */
  1431. memmove(&cs->tracks[track_num+1], &cs->tracks[track_num], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-1-track_num));
  1432. cs->tracks[track_num].num_indices = 0;
  1433. cs->tracks[track_num].indices = 0;
  1435. return FLAC__metadata_object_cuesheet_set_track(object, track_num, track, copy);
  1436. }
  1438. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num)
  1439. {
  1440. FLAC__StreamMetadata_CueSheet_Track track;
  1441. memset(&track, 0, sizeof(track));
  1442. return FLAC__metadata_object_cuesheet_insert_track(object, track_num, &track, /*copy=*/false);
  1443. }
  1445. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num)
  1446. {
  1447. FLAC__StreamMetadata_CueSheet *cs;
  1449. FLAC__ASSERT(0 != object);
  1450. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1451. FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
  1453. cs = &object->data.cue_sheet;
  1455. /* free the track at track_num */
  1456. if(0 != cs->tracks[track_num].indices)
  1457. free(cs->tracks[track_num].indices);
  1459. /* move all tracks > track_num backward one space */
  1460. memmove(&cs->tracks[track_num], &cs->tracks[track_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-track_num-1));
  1461. cs->tracks[cs->num_tracks-1].num_indices = 0;
  1462. cs->tracks[cs->num_tracks-1].indices = 0;
  1464. return FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks-1);
  1465. }
  1467. FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation)
  1468. {
  1469. FLAC__ASSERT(0 != object);
  1470. FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
  1472. return FLAC__format_cuesheet_is_legal(&object->data.cue_sheet, check_cd_da_subset, violation);
  1473. }