src/metaflac/operations_shorthand_picture.c

   1 /* metaflac - Command-line FLAC metadata editor
   2  * Copyright (C) 2001-2009  Josh Coalson
   3  * Copyright (C) 2011-2013  Xiph.Org Foundation
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 #  include <config.h>
  22 #endif
  23
  24 #include <errno.h>
  25 #include <string.h>
  26 #include "options.h"
  27 #include "utils.h"
  28 #include "FLAC/assert.h"
  29 #include "share/grabbag.h" /* for grabbag__picture_parse_specification() etc */
  30
  31 #include "operations_shorthand.h"
  32
  33 static FLAC__bool import_pic_from(const char *filename, FLAC__StreamMetadata **picture, const char *specification, FLAC__bool *needs_write);
  34 static FLAC__bool export_pic_to(const char *filename, const FLAC__StreamMetadata *picture, const char *pic_filename);
  35
  36 FLAC__bool do_shorthand_operation__picture(const char *filename, FLAC__Metadata_Chain *chain, const Operation *operation, FLAC__bool *needs_write)
  37 {
  38         FLAC__bool ok = true, has_type1 = false, has_type2 = false;
  39         FLAC__StreamMetadata *picture = 0;
  40         FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
  41
  42         if(0 == iterator)
  43                 die("out of memory allocating iterator");
  44
  45         FLAC__metadata_iterator_init(iterator, chain);
  46
  47         switch(operation->type) {
  48                 case OP__IMPORT_PICTURE_FROM:
  49                         ok = import_pic_from(filename, &picture, operation->argument.specification.value, needs_write);
  50                         if(ok) {
  51                                 /* append PICTURE block */
  52                                 while(FLAC__metadata_iterator_next(iterator))
  53                                         ;
  54                                 if(!FLAC__metadata_iterator_insert_block_after(iterator, picture)) {
  55                                         print_error_with_chain_status(chain, "%s: ERROR: adding new PICTURE block to metadata", filename);
  56                                         FLAC__metadata_object_delete(picture);
  57                                         ok = false;
  58                                 }
  59                         }
  60                         if(ok) {
  61                                 /* check global PICTURE constraints (max 1 block each of type=1 and type=2) */
  62                                 while(FLAC__metadata_iterator_prev(iterator))
  63                                         ;
  64                                 do {
  65                                         FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(iterator);
  66                                         if(block->type == FLAC__METADATA_TYPE_PICTURE) {
  67                                                 if(block->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) {
  68                                                         if(has_type1) {
  69                                                                 print_error_with_chain_status(chain, "%s: ERROR: FLAC stream can only have one 32x32 standard icon (type=1) PICTURE block", filename);
  70                                                                 ok = false;
  71                                                         }
  72                                                         has_type1 = true;
  73                                                 }
  74                                                 else if(block->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) {
  75                                                         if(has_type2) {
  76                                                                 print_error_with_chain_status(chain, "%s: ERROR: FLAC stream can only have one icon (type=2) PICTURE block", filename);
  77                                                                 ok = false;
  78                                                         }
  79                                                         has_type2 = true;
  80                                                 }
  81                                         }
  82                                 } while(FLAC__metadata_iterator_next(iterator));
  83                         }
  84                         break;
  85                 case OP__EXPORT_PICTURE_TO:
  86                         {
  87                                 const Argument_BlockNumber *a = operation->argument.export_picture_to.block_number_link;
  88                                 int block_number = (a && a->num_entries > 0)? (int)a->entries[0] : -1;
  89                                 unsigned i = 0;
  90                                 do {
  91                                         FLAC__StreamMetadata *block = FLAC__metadata_iterator_get_block(iterator);
  92                                         if(block->type == FLAC__METADATA_TYPE_PICTURE && (block_number < 0 || i == (unsigned)block_number))
  93                                                 picture = block;
  94                                         i++;
  95                                 } while(FLAC__metadata_iterator_next(iterator) && 0 == picture);
  96                                 if(0 == picture) {
  97                                         if(block_number < 0)
  98                                                 flac_fprintf(stderr, "%s: ERROR: FLAC file has no PICTURE block\n", filename);
  99                                         else
 100                                                 flac_fprintf(stderr, "%s: ERROR: FLAC file has no PICTURE block at block #%d\n", filename, block_number);
 101                                         ok = false;
 102                                 }
 103                                 else
 104                                         ok = export_pic_to(filename, picture, operation->argument.filename.value);
 105                         }
 106                         break;
 107                 default:
 108                         ok = false;
 109                         FLAC__ASSERT(0);
 110                         break;
 111         };
 112
 113         FLAC__metadata_iterator_delete(iterator);
 114         return ok;
 115 }
 116
 117 /*
 118  * local routines
 119  */
 120
 121 FLAC__bool import_pic_from(const char *filename, FLAC__StreamMetadata **picture, const char *specification, FLAC__bool *needs_write)
 122 {
 123         const char *error_message;
 124
 125         if(0 == specification || strlen(specification) == 0) {
 126                 flac_fprintf(stderr, "%s: ERROR: empty picture specification\n", filename);
 127                 return false;
 128         }
 129
 130         *picture = grabbag__picture_parse_specification(specification, &error_message);
 131
 132         if(0 == *picture) {
 133                 flac_fprintf(stderr, "%s: ERROR: while parsing picture specification \"%s\": %s\n", filename, specification, error_message);
 134                 return false;
 135         }
 136
 137         if(!FLAC__format_picture_is_legal(&(*picture)->data.picture, &error_message)) {
 138                 flac_fprintf(stderr, "%s: ERROR: new PICTURE block for \"%s\" is illegal: %s\n", filename, specification, error_message);
 139                 return false;
 140         }
 141
 142         *needs_write = true;
 143         return true;
 144 }
 145
 146 FLAC__bool export_pic_to(const char *filename, const FLAC__StreamMetadata *picture, const char *pic_filename)
 147 {
 148         FILE *f;
 149         const FLAC__uint32 len = picture->data.picture.data_length;
 150
 151         if(0 == pic_filename || strlen(pic_filename) == 0) {
 152                 flac_fprintf(stderr, "%s: ERROR: empty export file name\n", filename);
 153                 return false;
 154         }
 155         if(0 == strcmp(pic_filename, "-"))
 156                 f = grabbag__file_get_binary_stdout();
 157         else
 158                 f = flac_fopen(pic_filename, "wb");
 159
 160         if(0 == f) {
 161                 flac_fprintf(stderr, "%s: ERROR: can't open export file %s: %s\n", filename, pic_filename, strerror(errno));
 162                 return false;
 163         }
 164
 165         if(fwrite(picture->data.picture.data, 1, len, f) != len) {
 166                 flac_fprintf(stderr, "%s: ERROR: writing PICTURE data to file\n", filename);
 167                 if(f != stdout)
 168                         fclose(f);
 169                 return false;
 170         }
 171
 172         if(f != stdout)
 173                 fclose(f);
 174
 175         return true;
 176 }