quicktime/udta.c

   1 #include "funcprotos.h"
   2 #include "quicktime.h"
   3
   4 #define DEFAULT_INFO "Made with Quicktime for Linux"
   5 static unsigned char cpy_tag[] = {0xa9, 'c', 'p', 'y'};
   6 static unsigned char nam_tag[] = {0xa9, 'n', 'a', 'm'};
   7 static unsigned char inf_tag[] = {0xa9, 'i', 'n', 'f'};
   8 static unsigned char req_tag[] = {0xa9, 'r', 'e', 'q'};
   9 static unsigned char enc_tag[] = {0xa9, 'e', 'n', 'c'};
  10
  11 int quicktime_udta_init(quicktime_udta_t *udta)
  12 {
  13         udta->copyright = 0;
  14         udta->copyright_len = 0;
  15         udta->name = 0;
  16         udta->name_len = 0;
  17         udta->require = 0;
  18         udta->require_len = 0;
  19         udta->encoder = 0;
  20         udta->encoder_len = 0;
  21
  22         udta->info = malloc(strlen(DEFAULT_INFO) + 1);
  23         udta->info_len = strlen(DEFAULT_INFO);
  24         sprintf(udta->info, DEFAULT_INFO);
  25         return 0;
  26 }
  27
  28 int quicktime_udta_delete(quicktime_udta_t *udta)
  29 {
  30         if(udta->copyright_len)
  31         {
  32                 free(udta->copyright);
  33         }
  34         if(udta->name_len)
  35         {
  36                 free(udta->name);
  37         }
  38         if(udta->info_len)
  39         {
  40                 free(udta->info);
  41         }
  42         if(udta->require_len)
  43         {
  44                 free(udta->require);
  45         }
  46         if(udta->encoder_len)
  47         {
  48                 free(udta->encoder);
  49         }
  50 //      quicktime_udta_init(udta);
  51         return 0;
  52 }
  53
  54 void quicktime_udta_dump(quicktime_udta_t *udta)
  55 {
  56         printf(" user data (udta)\n");
  57         if(udta->copyright_len) printf("  copyright -> %s\n", udta->copyright);
  58         if(udta->name_len) printf("  name -> %s\n", udta->name);
  59         if(udta->info_len) printf("  info -> %s\n", udta->info);
  60         if(udta->require_len) printf("  require -> %s\n", udta->require);
  61         if(udta->encoder_len) printf("  encoder -> %s\n", udta->encoder);
  62 }
  63
  64 int quicktime_read_udta(quicktime_t *file, quicktime_udta_t *udta, quicktime_atom_t *udta_atom)
  65 {
  66         quicktime_atom_t leaf_atom;
  67         int result = 0;
  68
  69         do
  70         {
  71                 quicktime_atom_read_header(file, &leaf_atom);
  72
  73
  74                 if(quicktime_atom_is(&leaf_atom, cpy_tag))
  75                 {
  76                         result += quicktime_read_udta_string(file, &(udta->copyright), &(udta->copyright_len));
  77                 }
  78                 else
  79                 if(quicktime_atom_is(&leaf_atom, nam_tag))
  80                 {
  81                         result += quicktime_read_udta_string(file, &(udta->name), &(udta->name_len));
  82                 }
  83                 else
  84                 if(quicktime_atom_is(&leaf_atom, inf_tag))
  85                 {
  86                         result += quicktime_read_udta_string(file, &(udta->info), &(udta->info_len));
  87                 }
  88                 else
  89                 if(quicktime_atom_is(&leaf_atom, req_tag))
  90                 {
  91                         result += quicktime_read_udta_string(file, &(udta->require), &(udta->require_len));
  92                 }
  93                 else
  94                 if(quicktime_atom_is(&leaf_atom, enc_tag))
  95                 {
  96                         result += quicktime_read_udta_string(file, &(udta->encoder), &(udta->encoder_len));
  97                 }
  98                 else
  99                 {
 100                         quicktime_atom_skip(file, &leaf_atom);
 101                 }
 102         }while(quicktime_position(file) < udta_atom->end);
 103
 104
 105         return result;
 106 }
 107
 108 void quicktime_write_udta(quicktime_t *file, quicktime_udta_t *udta)
 109 {
 110         quicktime_atom_t atom, subatom;
 111         quicktime_atom_write_header(file, &atom, "udta");
 112
 113         if(udta->copyright_len)
 114         {
 115                 quicktime_atom_write_header(file, &subatom, cpy_tag);
 116                 quicktime_write_udta_string(file, udta->copyright, udta->copyright_len);
 117                 quicktime_atom_write_footer(file, &subatom);
 118         }
 119
 120         if(udta->name_len)
 121         {
 122                 quicktime_atom_write_header(file, &subatom, nam_tag);
 123                 quicktime_write_udta_string(file, udta->name, udta->name_len);
 124                 quicktime_atom_write_footer(file, &subatom);
 125         }
 126
 127         if(udta->info_len)
 128         {
 129                 quicktime_atom_write_header(file, &subatom, inf_tag);
 130                 quicktime_write_udta_string(file, udta->info, udta->info_len);
 131                 quicktime_atom_write_footer(file, &subatom);
 132         }
 133
 134         if(udta->require_len)
 135         {
 136                 quicktime_atom_write_header(file, &subatom, req_tag);
 137                 quicktime_write_udta_string(file, udta->require, udta->require_len);
 138                 quicktime_atom_write_footer(file, &subatom);
 139         }
 140
 141         if(udta->encoder_len)
 142         {
 143                 quicktime_atom_write_header(file, &subatom, enc_tag);
 144                 quicktime_write_udta_string(file, udta->encoder, udta->encoder_len);
 145                 quicktime_atom_write_footer(file, &subatom);
 146         }
 147
 148         quicktime_atom_write_footer(file, &atom);
 149 }
 150
 151 int quicktime_read_udta_string(quicktime_t *file, char **string, int *size)
 152 {
 153         int result;
 154
 155         if(*size) free(*string);
 156         *size = quicktime_read_int16(file);  /* Size of string */
 157         quicktime_read_int16(file);  /* Discard language code */
 158         *string = malloc(*size + 1);
 159         result = quicktime_read_data(file, *string, *size);
 160         (*string)[*size] = 0;
 161         return !result;
 162 }
 163
 164 int quicktime_write_udta_string(quicktime_t *file, char *string, int size)
 165 {
 166         int new_size = strlen(string);
 167         int result;
 168
 169         quicktime_write_int16(file, new_size);    /* String size */
 170         quicktime_write_int16(file, 0);    /* Language code */
 171         result = quicktime_write_data(file, string, new_size);
 172         return !result;
 173 }
 174
 175 int quicktime_set_udta_string(char **string, int *size, char *new_string)
 176 {
 177         if(*size) free(*string);
 178         *size = strlen(new_string) + 1;
 179         *string = malloc(*size);
 180         strcpy(*string, new_string);
 181         return 0;
 182 }