mp4.c

   1 /*
   2  * Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
   3  * FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   4  *
   5  * See file COPYING.
   6  */
   7
   8 #include <regex.h>
   9
  10 #include "para.h"
  11 #include "portable_io.h"
  12 #include "string.h"
  13 #include "mp4.h"
  14
  15 struct mp4_track {
  16         bool is_audio;
  17         uint32_t channelCount;
  18         uint16_t sampleRate;
  19
  20         /* stsz */
  21         uint32_t stsz_sample_size;
  22         uint32_t stsz_sample_count;
  23         uint32_t *stsz_table;
  24
  25         /* stts */
  26         uint32_t stts_entry_count;
  27         uint32_t *stts_sample_count;
  28         uint32_t *stts_sample_delta;
  29
  30         /* stsc */
  31         uint32_t stsc_entry_count;
  32         uint32_t *stsc_first_chunk;
  33         uint32_t *stsc_samples_per_chunk;
  34         uint32_t *stsc_sample_desc_index;
  35
  36         /* stsc */
  37         uint32_t stco_entry_count;
  38         uint32_t *stco_chunk_offset;
  39
  40         uint32_t timeScale;
  41         uint64_t duration;
  42 };
  43
  44 #define MAX_TRACKS 1024
  45
  46 struct mp4 {
  47         const struct mp4_callback *cb;
  48         int64_t current_position;
  49
  50         uint64_t moov_offset;
  51         uint64_t moov_size;
  52         uint8_t last_atom;
  53         uint64_t file_size;
  54
  55         uint32_t read_error;
  56         uint32_t error;
  57
  58         /* incremental track index while reading the file */
  59         int32_t total_tracks;
  60
  61         /* track data */
  62         struct mp4_track *track[MAX_TRACKS];
  63
  64         /* metadata */
  65         struct mp4_metadata meta;
  66 };
  67
  68 int32_t mp4_total_tracks(const struct mp4 *f)
  69 {
  70         return f->total_tracks;
  71 }
  72
  73 static int32_t read_data(struct mp4 *f, void *data, uint32_t size)
  74 {
  75         int32_t result = 1;
  76
  77         result = f->cb->read(f->cb->user_data, data, size);
  78
  79         if (result < size)
  80                 f->read_error++;
  81
  82         f->current_position += size;
  83
  84         return result;
  85 }
  86
  87 static uint64_t read_int64(struct mp4 *f)
  88 {
  89         uint8_t data[8];
  90
  91         read_data(f, data, 8);
  92         return read_u64_be(data);
  93 }
  94
  95 static bool atom_compare(int8_t a1, int8_t b1, int8_t c1, int8_t d1,
  96                 int8_t a2, int8_t b2, int8_t c2, int8_t d2)
  97 {
  98         return a1 == a2 && b1 == b2 && c1 == c2 && d1 == d2;
  99 }
 100 enum atoms {
 101         /* atoms with subatoms */
 102         ATOM_MOOV = 1,
 103         ATOM_TRAK = 2,
 104         ATOM_EDTS = 3,
 105         ATOM_MDIA = 4,
 106         ATOM_MINF = 5,
 107         ATOM_STBL = 6,
 108         ATOM_UDTA = 7,
 109         ATOM_ILST = 8, /* iTunes Metadata list */
 110         ATOM_TITLE = 9,
 111         ATOM_ARTIST = 10,
 112         ATOM_WRITER = 11,
 113         ATOM_ALBUM = 12,
 114         ATOM_DATE = 13,
 115         ATOM_TOOL = 14,
 116         ATOM_COMMENT = 15,
 117         ATOM_GENRE1 = 16,
 118         ATOM_TRACK = 17,
 119         ATOM_DISC = 18,
 120         ATOM_COMPILATION = 19,
 121         ATOM_GENRE2 = 20,
 122         ATOM_TEMPO = 21,
 123         ATOM_COVER = 22,
 124         ATOM_DRMS = 23,
 125         ATOM_SINF = 24,
 126         ATOM_SCHI = 25,
 127
 128         SUBATOMIC = 128,
 129
 130         /* atoms without subatoms */
 131         ATOM_FTYP = 129,
 132         ATOM_MDAT = 130,
 133         ATOM_MVHD = 131,
 134         ATOM_TKHD = 132,
 135         ATOM_TREF = 133,
 136         ATOM_MDHD = 134,
 137         ATOM_VMHD = 135,
 138         ATOM_SMHD = 136,
 139         ATOM_HMHD = 137,
 140         ATOM_STSD = 138,
 141         ATOM_STTS = 139,
 142         ATOM_STSZ = 140,
 143         ATOM_STZ2 = 141,
 144         ATOM_STCO = 142,
 145         ATOM_STSC = 143,
 146         ATOM_MP4A = 144,
 147         ATOM_MP4V = 145,
 148         ATOM_MP4S = 146,
 149         ATOM_ESDS = 147,
 150         ATOM_META = 148, /* iTunes Metadata box */
 151         ATOM_NAME = 149, /* iTunes Metadata name box */
 152         ATOM_DATA = 150, /* iTunes Metadata data box */
 153         ATOM_CTTS = 151,
 154         ATOM_FRMA = 152,
 155         ATOM_IVIV = 153,
 156         ATOM_PRIV = 154,
 157         ATOM_USER = 155,
 158         ATOM_KEY = 156,
 159         ATOM_ALBUM_ARTIST = 157,
 160         ATOM_CONTENTGROUP = 158,
 161         ATOM_LYRICS = 159,
 162         ATOM_DESCRIPTION = 160,
 163         ATOM_NETWORK = 161,
 164         ATOM_SHOW = 162,
 165         ATOM_EPISODENAME = 163,
 166         ATOM_SORTTITLE = 164,
 167         ATOM_SORTALBUM = 165,
 168         ATOM_SORTARTIST = 166,
 169         ATOM_SORTALBUMARTIST = 167,
 170         ATOM_SORTWRITER = 168,
 171         ATOM_SORTSHOW = 169,
 172         ATOM_SEASON = 170,
 173         ATOM_EPISODE = 171,
 174         ATOM_PODCAST = 172,
 175
 176         ATOM_UNKNOWN = 255
 177 };
 178
 179 #define ATOM_FREE ATOM_UNKNOWN
 180 #define ATOM_SKIP ATOM_UNKNOWN
 181
 182 #define COPYRIGHT_SYMBOL ((int8_t)0xA9)
 183
 184 static uint8_t atom_name_to_type(int8_t a, int8_t b, int8_t c, int8_t d)
 185 {
 186         if (a == 'm') {
 187                 if (atom_compare(a, b, c, d, 'm', 'o', 'o', 'v'))
 188                         return ATOM_MOOV;
 189                 else if (atom_compare(a, b, c, d, 'm', 'i', 'n', 'f'))
 190                         return ATOM_MINF;
 191                 else if (atom_compare(a, b, c, d, 'm', 'd', 'i', 'a'))
 192                         return ATOM_MDIA;
 193                 else if (atom_compare(a, b, c, d, 'm', 'd', 'a', 't'))
 194                         return ATOM_MDAT;
 195                 else if (atom_compare(a, b, c, d, 'm', 'd', 'h', 'd'))
 196                         return ATOM_MDHD;
 197                 else if (atom_compare(a, b, c, d, 'm', 'v', 'h', 'd'))
 198                         return ATOM_MVHD;
 199                 else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'a'))
 200                         return ATOM_MP4A;
 201                 else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'v'))
 202                         return ATOM_MP4V;
 203                 else if (atom_compare(a, b, c, d, 'm', 'p', '4', 's'))
 204                         return ATOM_MP4S;
 205                 else if (atom_compare(a, b, c, d, 'm', 'e', 't', 'a'))
 206                         return ATOM_META;
 207         } else if (a == 't') {
 208                 if (atom_compare(a, b, c, d, 't', 'r', 'a', 'k'))
 209                         return ATOM_TRAK;
 210                 else if (atom_compare(a, b, c, d, 't', 'k', 'h', 'd'))
 211                         return ATOM_TKHD;
 212                 else if (atom_compare(a, b, c, d, 't', 'r', 'e', 'f'))
 213                         return ATOM_TREF;
 214                 else if (atom_compare(a, b, c, d, 't', 'r', 'k', 'n'))
 215                         return ATOM_TRACK;
 216                 else if (atom_compare(a, b, c, d, 't', 'm', 'p', 'o'))
 217                         return ATOM_TEMPO;
 218                 else if (atom_compare(a, b, c, d, 't', 'v', 'n', 'n'))
 219                         return ATOM_NETWORK;
 220                 else if (atom_compare(a, b, c, d, 't', 'v', 's', 'h'))
 221                         return ATOM_SHOW;
 222                 else if (atom_compare(a, b, c, d, 't', 'v', 'e', 'n'))
 223                         return ATOM_EPISODENAME;
 224                 else if (atom_compare(a, b, c, d, 't', 'v', 's', 'n'))
 225                         return ATOM_SEASON;
 226                 else if (atom_compare(a, b, c, d, 't', 'v', 'e', 's'))
 227                         return ATOM_EPISODE;
 228         } else if (a == 's') {
 229                 if (atom_compare(a, b, c, d, 's', 't', 'b', 'l'))
 230                         return ATOM_STBL;
 231                 else if (atom_compare(a, b, c, d, 's', 'm', 'h', 'd'))
 232                         return ATOM_SMHD;
 233                 else if (atom_compare(a, b, c, d, 's', 't', 's', 'd'))
 234                         return ATOM_STSD;
 235                 else if (atom_compare(a, b, c, d, 's', 't', 't', 's'))
 236                         return ATOM_STTS;
 237                 else if (atom_compare(a, b, c, d, 's', 't', 'c', 'o'))
 238                         return ATOM_STCO;
 239                 else if (atom_compare(a, b, c, d, 's', 't', 's', 'c'))
 240                         return ATOM_STSC;
 241                 else if (atom_compare(a, b, c, d, 's', 't', 's', 'z'))
 242                         return ATOM_STSZ;
 243                 else if (atom_compare(a, b, c, d, 's', 't', 'z', '2'))
 244                         return ATOM_STZ2;
 245                 else if (atom_compare(a, b, c, d, 's', 'k', 'i', 'p'))
 246                         return ATOM_SKIP;
 247                 else if (atom_compare(a, b, c, d, 's', 'i', 'n', 'f'))
 248                         return ATOM_SINF;
 249                 else if (atom_compare(a, b, c, d, 's', 'c', 'h', 'i'))
 250                         return ATOM_SCHI;
 251                 else if (atom_compare(a, b, c, d, 's', 'o', 'n', 'm'))
 252                         return ATOM_SORTTITLE;
 253                 else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'l'))
 254                         return ATOM_SORTALBUM;
 255                 else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'r'))
 256                         return ATOM_SORTARTIST;
 257                 else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'a'))
 258                         return ATOM_SORTALBUMARTIST;
 259                 else if (atom_compare(a, b, c, d, 's', 'o', 'c', 'o'))
 260                         return ATOM_SORTWRITER;
 261                 else if (atom_compare(a, b, c, d, 's', 'o', 's', 'n'))
 262                         return ATOM_SORTSHOW;
 263         } else if (a == COPYRIGHT_SYMBOL) {
 264                 if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'n', 'a', 'm'))
 265                         return ATOM_TITLE;
 266                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'A', 'R', 'T'))
 267                         return ATOM_ARTIST;
 268                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'w', 'r', 't'))
 269                         return ATOM_WRITER;
 270                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'a', 'l', 'b'))
 271                         return ATOM_ALBUM;
 272                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'd', 'a', 'y'))
 273                         return ATOM_DATE;
 274                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 't', 'o', 'o'))
 275                         return ATOM_TOOL;
 276                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'c', 'm', 't'))
 277                         return ATOM_COMMENT;
 278                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'e', 'n'))
 279                         return ATOM_GENRE1;
 280                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'r', 'p'))
 281                         return ATOM_CONTENTGROUP;
 282                 else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'l', 'y', 'r'))
 283                         return ATOM_LYRICS;
 284         }
 285
 286         if (atom_compare(a, b, c, d, 'e', 'd', 't', 's'))
 287                 return ATOM_EDTS;
 288         else if (atom_compare(a, b, c, d, 'e', 's', 'd', 's'))
 289                 return ATOM_ESDS;
 290         else if (atom_compare(a, b, c, d, 'f', 't', 'y', 'p'))
 291                 return ATOM_FTYP;
 292         else if (atom_compare(a, b, c, d, 'f', 'r', 'e', 'e'))
 293                 return ATOM_FREE;
 294         else if (atom_compare(a, b, c, d, 'h', 'm', 'h', 'd'))
 295                 return ATOM_HMHD;
 296         else if (atom_compare(a, b, c, d, 'v', 'm', 'h', 'd'))
 297                 return ATOM_VMHD;
 298         else if (atom_compare(a, b, c, d, 'u', 'd', 't', 'a'))
 299                 return ATOM_UDTA;
 300         else if (atom_compare(a, b, c, d, 'i', 'l', 's', 't'))
 301                 return ATOM_ILST;
 302         else if (atom_compare(a, b, c, d, 'n', 'a', 'm', 'e'))
 303                 return ATOM_NAME;
 304         else if (atom_compare(a, b, c, d, 'd', 'a', 't', 'a'))
 305                 return ATOM_DATA;
 306         else if (atom_compare(a, b, c, d, 'd', 'i', 's', 'k'))
 307                 return ATOM_DISC;
 308         else if (atom_compare(a, b, c, d, 'g', 'n', 'r', 'e'))
 309                 return ATOM_GENRE2;
 310         else if (atom_compare(a, b, c, d, 'c', 'o', 'v', 'r'))
 311                 return ATOM_COVER;
 312         else if (atom_compare(a, b, c, d, 'c', 'p', 'i', 'l'))
 313                 return ATOM_COMPILATION;
 314         else if (atom_compare(a, b, c, d, 'c', 't', 't', 's'))
 315                 return ATOM_CTTS;
 316         else if (atom_compare(a, b, c, d, 'd', 'r', 'm', 's'))
 317                 return ATOM_DRMS;
 318         else if (atom_compare(a, b, c, d, 'f', 'r', 'm', 'a'))
 319                 return ATOM_FRMA;
 320         else if (atom_compare(a, b, c, d, 'p', 'r', 'i', 'v'))
 321                 return ATOM_PRIV;
 322         else if (atom_compare(a, b, c, d, 'i', 'v', 'i', 'v'))
 323                 return ATOM_IVIV;
 324         else if (atom_compare(a, b, c, d, 'u', 's', 'e', 'r'))
 325                 return ATOM_USER;
 326         else if (atom_compare(a, b, c, d, 'k', 'e', 'y', ' '))
 327                 return ATOM_KEY;
 328         else if (atom_compare(a, b, c, d, 'a', 'A', 'R', 'T'))
 329                 return ATOM_ALBUM_ARTIST;
 330         else if (atom_compare(a, b, c, d, 'd', 'e', 's', 'c'))
 331                 return ATOM_DESCRIPTION;
 332         else if (atom_compare(a, b, c, d, 'p', 'c', 's', 't'))
 333                 return ATOM_PODCAST;
 334         else
 335                 return ATOM_UNKNOWN;
 336 }
 337
 338 /* read atom header, return atom size, atom size is with header included */
 339 static uint64_t atom_read_header(struct mp4 *f, uint8_t * atom_type,
 340                                 uint8_t * header_size)
 341 {
 342         uint64_t size;
 343         int32_t ret;
 344         int8_t atom_header[8];
 345
 346         ret = read_data(f, atom_header, 8);
 347         if (ret != 8)
 348                 return 0;
 349
 350         size = read_u32_be(atom_header);
 351         *header_size = 8;
 352
 353         /* check for 64 bit atom size */
 354         if (size == 1) {
 355                 *header_size = 16;
 356                 size = read_int64(f);
 357         }
 358         *atom_type = atom_name_to_type(atom_header[4], atom_header[5],
 359                 atom_header[6], atom_header[7]);
 360         return size;
 361 }
 362
 363 static int64_t get_position(const struct mp4 *f)
 364 {
 365         return f->current_position;
 366 }
 367
 368 static int need_parse_when_meta_only(uint8_t atom_type)
 369 {
 370         switch (atom_type) {
 371         case ATOM_EDTS:
 372         case ATOM_DRMS:
 373         case ATOM_SINF:
 374         case ATOM_SCHI:
 375         case ATOM_STTS:
 376         case ATOM_STSZ:
 377         case ATOM_STZ2:
 378         case ATOM_STCO:
 379         case ATOM_STSC:
 380         case ATOM_FRMA:
 381         case ATOM_IVIV:
 382         case ATOM_PRIV:
 383                 return 0;
 384         default:
 385                 return 1;
 386         }
 387 }
 388
 389 static int32_t set_position(struct mp4 *f, int64_t position)
 390 {
 391         f->cb->seek(f->cb->user_data, position);
 392         f->current_position = position;
 393
 394         return 0;
 395 }
 396
 397 static void track_add(struct mp4 *f)
 398 {
 399         f->total_tracks++;
 400
 401         if (f->total_tracks > MAX_TRACKS) {
 402                 f->total_tracks = 0;
 403                 f->error++;
 404                 return;
 405         }
 406         f->track[f->total_tracks - 1] = para_calloc(sizeof(struct mp4_track));
 407 }
 408
 409 static uint8_t read_char(struct mp4 *f)
 410 {
 411         uint8_t output;
 412         read_data(f, &output, 1);
 413         return output;
 414 }
 415
 416 static uint32_t read_int24(struct mp4 *f)
 417 {
 418         int8_t data[4];
 419
 420         read_data(f, data, 3);
 421         return read_u24_be(data);
 422 }
 423
 424 static uint32_t read_int32(struct mp4 *f)
 425 {
 426         int8_t data[4];
 427
 428         read_data(f, data, 4);
 429         return read_u32_be(data);
 430 }
 431
 432 static int32_t read_stsz(struct mp4 *f)
 433 {
 434         int32_t i;
 435         struct mp4_track *t;
 436
 437         if (f->total_tracks == 0)
 438                 return f->error++;
 439         t = f->track[f->total_tracks - 1];
 440         read_char(f);   /* version */
 441         read_int24(f);  /* flags */
 442         t->stsz_sample_size = read_int32(f);
 443         t->stsz_sample_count = read_int32(f);
 444         if (t->stsz_sample_size != 0)
 445                 return 0;
 446         t->stsz_table = para_malloc(t->stsz_sample_count * sizeof(int32_t));
 447         for (i = 0; i < t->stsz_sample_count && !f->read_error; i++)
 448                 t->stsz_table[i] = read_int32(f);
 449         return 0;
 450 }
 451
 452 static int32_t read_stts(struct mp4 *f)
 453 {
 454         int32_t i;
 455         struct mp4_track *t;
 456
 457         /* CVE-2017-9223 */
 458         if (f->total_tracks == 0)
 459                 return f->error++;
 460         t = f->track[f->total_tracks - 1];
 461         if (t->stts_entry_count)
 462                 return 0;
 463         read_char(f);   /* version */
 464         read_int24(f);  /* flags */
 465         t->stts_entry_count = read_int32(f);
 466
 467         t->stts_sample_count = para_malloc(t->stts_entry_count
 468                 * sizeof(int32_t));
 469         t->stts_sample_delta = para_malloc(t->stts_entry_count
 470                 * sizeof (int32_t));
 471         /* CVE-2017-9254 */
 472         for (i = 0; i < t->stts_entry_count && !f->read_error; i++) {
 473                 t->stts_sample_count[i] = read_int32(f);
 474                 t->stts_sample_delta[i] = read_int32(f);
 475         }
 476         return 1;
 477 }
 478
 479 static int32_t read_stsc(struct mp4 *f)
 480 {
 481         int32_t i;
 482         struct mp4_track *t;
 483
 484         if (f->total_tracks == 0)
 485                 return f->error++;
 486         t = f->track[f->total_tracks - 1];
 487
 488         read_char(f);   /* version */
 489         read_int24(f);  /* flags */
 490         t->stsc_entry_count = read_int32(f);
 491         t->stsc_first_chunk = para_malloc(t->stsc_entry_count * sizeof(int32_t));
 492         t->stsc_samples_per_chunk = para_malloc(t->stsc_entry_count
 493                 * sizeof (int32_t));
 494         t->stsc_sample_desc_index = para_malloc(t->stsc_entry_count *
 495                 sizeof (int32_t));
 496
 497         /* CVE-2017-9255 */
 498         for (i = 0; i < t->stsc_entry_count && !f->read_error; i++) {
 499                 t->stsc_first_chunk[i] = read_int32(f);
 500                 t->stsc_samples_per_chunk[i] = read_int32(f);
 501                 t->stsc_sample_desc_index[i] = read_int32(f);
 502         }
 503         return 0;
 504 }
 505
 506 static int32_t read_stco(struct mp4 *f)
 507 {
 508         int32_t i;
 509         struct mp4_track *t;
 510
 511         if (f->total_tracks == 0)
 512                 return f->error++;
 513         t = f->track[f->total_tracks - 1];
 514
 515         read_char(f);   /* version */
 516         read_int24(f);  /* flags */
 517         t->stco_entry_count = read_int32(f);
 518         t->stco_chunk_offset = para_malloc(t->stco_entry_count
 519                 * sizeof(int32_t));
 520         /* CVE-2017-9256 */
 521         for (i = 0; i < t->stco_entry_count && !f->read_error; i++)
 522                 t->stco_chunk_offset[i] = read_int32(f);
 523         return 0;
 524 }
 525
 526 static uint16_t read_int16(struct mp4 *f)
 527 {
 528         int8_t data[2];
 529
 530         read_data(f, data, 2);
 531         return read_u16_be(data);
 532 }
 533
 534 static int32_t read_mp4a(struct mp4 *f)
 535 {
 536         int32_t i;
 537         uint8_t atom_type = 0;
 538         uint8_t header_size = 0;
 539         struct mp4_track *t;
 540
 541         if (f->total_tracks == 0)
 542                 return f->error++;
 543         t = f->track[f->total_tracks - 1];
 544
 545         for (i = 0; i < 6; i++) {
 546                 read_char(f);   /* reserved */
 547         }
 548         /* data_reference_index */ read_int16(f);
 549
 550         read_int32(f);  /* reserved */
 551         read_int32(f);  /* reserved */
 552
 553         t->channelCount = read_int16(f);
 554         read_int16(f);
 555
 556         read_int16(f);
 557         read_int16(f);
 558
 559         t->sampleRate = read_int16(f);
 560
 561         read_int16(f);
 562
 563         atom_read_header(f, &atom_type, &header_size);
 564         return 0;
 565 }
 566
 567 static int32_t read_stsd(struct mp4 *f)
 568 {
 569         int32_t i, entry_count;
 570         uint8_t header_size = 0;
 571         struct mp4_track *t;
 572
 573         /* CVE-2017-9218 */
 574         if (f->total_tracks == 0)
 575                 return f->error++;
 576         t = f->track[f->total_tracks - 1];
 577
 578         read_char(f);   /* version */
 579         read_int24(f);  /* flags */
 580
 581         entry_count = read_int32(f);
 582
 583         /* CVE-2017-9253 */
 584         for (i = 0; i < entry_count && !f->read_error; i++) {
 585                 uint64_t skip = get_position(f);
 586                 uint64_t size;
 587                 uint8_t atom_type = 0;
 588                 size = atom_read_header(f, &atom_type, &header_size);
 589                 skip += size;
 590                 t->is_audio = atom_type == ATOM_MP4A;
 591                 if (t->is_audio)
 592                         read_mp4a(f);
 593                 set_position(f, skip);
 594         }
 595
 596         return 0;
 597 }
 598
 599 static int32_t tag_add_field(struct mp4_metadata *meta, const char *item,
 600                 const char *value, int32_t len)
 601 {
 602         meta->tags = para_realloc(meta->tags,
 603                 (meta->count + 1) * sizeof(struct mp4_tag));
 604         meta->tags[meta->count].item = para_strdup(item);
 605         meta->tags[meta->count].len = len;
 606         if (len >= 0) {
 607                 meta->tags[meta->count].value = para_malloc(len + 1);
 608                 memcpy(meta->tags[meta->count].value, value, len);
 609                 meta->tags[meta->count].value[len] = 0;
 610         } else {
 611                 meta->tags[meta->count].value = para_strdup(value);
 612         }
 613         meta->count++;
 614         return 1;
 615 }
 616
 617 static char *read_string(struct mp4 *f, uint32_t length)
 618 {
 619         char *str = para_malloc(length + 1);
 620         if ((uint32_t)read_data(f, str, length) != length) {
 621                 free(str);
 622                 str = NULL;
 623         } else
 624                 str[length] = 0;
 625         return str;
 626 }
 627
 628 static const char *get_metadata_name(uint8_t atom_type)
 629 {
 630         switch (atom_type) {
 631         case ATOM_TITLE: return "title";
 632         case ATOM_ARTIST: return "artist";
 633         case ATOM_ALBUM: return "album";
 634         case ATOM_DATE: return "date";
 635         case ATOM_COMMENT: return "comment";
 636         default: return "unknown";
 637         }
 638 }
 639
 640 static void parse_tag(struct mp4 *f, uint8_t parent, int32_t size)
 641 {
 642         uint64_t subsize, sumsize;
 643         char *data = NULL;
 644         uint32_t len = 0;
 645         uint64_t destpos;
 646
 647         for (
 648                 sumsize = 0;
 649                 sumsize < size && !f->read_error; /* CVE-2017-9222 */
 650                 set_position(f, destpos), sumsize += subsize
 651         ) {
 652                 uint8_t atom_type;
 653                 uint8_t header_size = 0;
 654                 subsize = atom_read_header(f, &atom_type, &header_size);
 655                 destpos = get_position(f) + subsize - header_size;
 656                 if (atom_type != ATOM_DATA)
 657                         continue;
 658                 read_char(f);   /* version */
 659                 read_int24(f);  /* flags */
 660                 read_int32(f);  /* reserved */
 661                 free(data);
 662                 data = read_string(f, subsize - (header_size + 8));
 663                 len = subsize - (header_size + 8);
 664         }
 665         if (!data)
 666                 return;
 667         tag_add_field(&f->meta, get_metadata_name(parent), data, len);
 668         free(data);
 669 }
 670
 671 static int32_t read_mdhd(struct mp4 *f)
 672 {
 673         uint32_t version;
 674         struct mp4_track *t;
 675
 676         /* CVE-2017-9221 */
 677         if (f->total_tracks == 0)
 678                 return f->error++;
 679         t = f->track[f->total_tracks - 1];
 680
 681         version = read_int32(f);
 682         if (version == 1) {
 683                 read_int64(f); //creation-time
 684                 read_int64(f); //modification-time
 685                 t->timeScale = read_int32(f); //timescale
 686                 t->duration = read_int64(f); //duration
 687         } else { //version == 0
 688                 uint32_t temp;
 689
 690                 read_int32(f);  //creation-time
 691                 read_int32(f);  //modification-time
 692                 t->timeScale = read_int32(f); //timescale
 693                 temp = read_int32(f);
 694                 t->duration = (temp == (uint32_t) (-1))?
 695                         (uint64_t) (-1) : (uint64_t) (temp);
 696         }
 697         read_int16(f);
 698         read_int16(f);
 699         return 1;
 700 }
 701
 702 static int32_t read_ilst(struct mp4 *f, int32_t size)
 703 {
 704         uint64_t sumsize = 0;
 705
 706         while (sumsize < size) {
 707                 uint8_t atom_type;
 708                 uint64_t subsize, destpos;
 709                 uint8_t header_size = 0;
 710                 subsize = atom_read_header(f, &atom_type, &header_size);
 711                 if (subsize == 0)
 712                         break;
 713                 destpos = get_position(f) + subsize - header_size;
 714                 switch (atom_type) {
 715                 case ATOM_ARTIST:
 716                 case ATOM_TITLE:
 717                 case ATOM_ALBUM:
 718                 case ATOM_COMMENT:
 719                 case ATOM_DATE:
 720                         parse_tag(f, atom_type, subsize - header_size);
 721                 }
 722                 set_position(f, destpos);
 723                 sumsize += subsize;
 724         }
 725
 726         return 0;
 727 }
 728
 729 static int32_t read_meta(struct mp4 *f, uint64_t size)
 730 {
 731         uint64_t subsize, sumsize = 0;
 732         uint8_t atom_type;
 733         uint8_t header_size = 0;
 734
 735         read_char(f);   /* version */
 736         read_int24(f);  /* flags */
 737
 738         while (sumsize < (size - (header_size + 4))) {
 739                 subsize = atom_read_header(f, &atom_type, &header_size);
 740                 if (subsize <= header_size + 4)
 741                         return 1;
 742                 if (atom_type == ATOM_ILST)
 743                         read_ilst(f, subsize - (header_size + 4));
 744                 else
 745                         set_position(f, get_position(f) + subsize - header_size);
 746                 sumsize += subsize;
 747         }
 748
 749         return 0;
 750 }
 751
 752 static int32_t atom_read(struct mp4 *f, int32_t size, uint8_t atom_type)
 753 {
 754         uint64_t dest_position = get_position(f) + size - 8;
 755         if (atom_type == ATOM_STSZ) {
 756                 /* sample size box */
 757                 read_stsz(f);
 758         } else if (atom_type == ATOM_STTS) {
 759                 /* time to sample box */
 760                 read_stts(f);
 761         } else if (atom_type == ATOM_STSC) {
 762                 /* sample to chunk box */
 763                 read_stsc(f);
 764         } else if (atom_type == ATOM_STCO) {
 765                 /* chunk offset box */
 766                 read_stco(f);
 767         } else if (atom_type == ATOM_STSD) {
 768                 /* sample description box */
 769                 read_stsd(f);
 770         } else if (atom_type == ATOM_MDHD) {
 771                 /* track header */
 772                 read_mdhd(f);
 773         } else if (atom_type == ATOM_META) {
 774                 /* iTunes Metadata box */
 775                 read_meta(f, size);
 776         }
 777
 778         set_position(f, dest_position);
 779         return 0;
 780 }
 781
 782 /* parse atoms that are sub atoms of other atoms */
 783 static int32_t parse_sub_atoms(struct mp4 *f, uint64_t total_size, int meta_only)
 784 {
 785         uint64_t size;
 786         uint8_t atom_type = 0;
 787         uint64_t counted_size = 0;
 788         uint8_t header_size = 0;
 789
 790         while (counted_size < total_size) {
 791                 size = atom_read_header(f, &atom_type, &header_size);
 792                 counted_size += size;
 793
 794                 /* check for end of file */
 795                 if (size == 0)
 796                         break;
 797
 798                 /* we're starting to read a new track, update index,
 799                  * so that all data and tables get written in the right place
 800                  */
 801                 if (atom_type == ATOM_TRAK)
 802                         track_add(f);
 803                 /* parse subatoms */
 804                 if (meta_only && !need_parse_when_meta_only(atom_type)) {
 805                         set_position(f, get_position(f) + size - header_size);
 806                 } else if (atom_type < SUBATOMIC) {
 807                         parse_sub_atoms(f, size - header_size, meta_only);
 808                 } else {
 809                         atom_read(f, (uint32_t) size, atom_type);
 810                 }
 811         }
 812
 813         return 0;
 814 }
 815
 816 /* parse root atoms */
 817 static int32_t parse_atoms(struct mp4 *f, int meta_only)
 818 {
 819         uint64_t size;
 820         uint8_t atom_type = 0;
 821         uint8_t header_size = 0;
 822
 823         f->file_size = 0;
 824         f->read_error = 0;
 825
 826         while ((size =
 827                 atom_read_header(f, &atom_type, &header_size)) != 0) {
 828                 f->file_size += size;
 829                 f->last_atom = atom_type;
 830
 831                 if (atom_type == ATOM_MOOV && size > header_size) {
 832                         f->moov_offset = get_position(f) - header_size;
 833                         f->moov_size = size;
 834                 }
 835
 836                 /* parse subatoms */
 837                 if (meta_only && !need_parse_when_meta_only(atom_type)) {
 838                         set_position(f, get_position(f) + size - header_size);
 839                 } else if (atom_type < SUBATOMIC) {
 840                         parse_sub_atoms(f, size - header_size, meta_only);
 841                 } else {
 842                         /* skip this atom */
 843                         set_position(f, get_position(f) + size - header_size);
 844                 }
 845         }
 846
 847         return 0;
 848 }
 849
 850 struct mp4 *mp4_open_read(const struct mp4_callback *cb)
 851 {
 852         struct mp4 *f = para_calloc(sizeof(struct mp4));
 853
 854         f->cb = cb;
 855         parse_atoms(f, 0);
 856         if (f->error) {
 857                 free(f);
 858                 f = NULL;
 859         }
 860         return f;
 861 }
 862
 863 void mp4_close(struct mp4 *f)
 864 {
 865         int32_t i;
 866
 867         for (i = 0; i < f->total_tracks; i++) {
 868                 if (f->track[i]) {
 869                         free(f->track[i]->stsz_table);
 870                         free(f->track[i]->stts_sample_count);
 871                         free(f->track[i]->stts_sample_delta);
 872                         free(f->track[i]->stsc_first_chunk);
 873                         free(f->track[i]->stsc_samples_per_chunk);
 874                         free(f->track[i]->stsc_sample_desc_index);
 875                         free(f->track[i]->stco_chunk_offset);
 876                         free(f->track[i]);
 877                 }
 878         }
 879         for (i = 0; i < f->meta.count; i++) {
 880                 free(f->meta.tags[i].item);
 881                 free(f->meta.tags[i].value);
 882         }
 883         free(f->meta.tags);
 884         free(f);
 885 }
 886
 887 static int32_t chunk_of_sample(const struct mp4 *f, int32_t track,
 888                 int32_t sample, int32_t *chunk_sample, int32_t *chunk)
 889 {
 890         int32_t total_entries = 0;
 891         int32_t chunk2entry;
 892         int32_t chunk1, chunk2, chunk1samples, range_samples, total = 0;
 893
 894         *chunk_sample = 0;
 895         *chunk = 1;
 896         if (f->track[track] == NULL) {
 897                 return -1;
 898         }
 899
 900         total_entries = f->track[track]->stsc_entry_count;
 901
 902         chunk1 = 1;
 903         chunk1samples = 0;
 904         chunk2entry = 0;
 905
 906         do {
 907                 chunk2 = f->track[track]->stsc_first_chunk[chunk2entry];
 908                 *chunk = chunk2 - chunk1;
 909                 range_samples = *chunk * chunk1samples;
 910
 911                 if (sample < total + range_samples)
 912                         break;
 913
 914                 chunk1samples = f->track[track]->stsc_samples_per_chunk[chunk2entry];
 915                 chunk1 = chunk2;
 916
 917                 if (chunk2entry < total_entries) {
 918                         chunk2entry++;
 919                         total += range_samples;
 920                 }
 921         } while (chunk2entry < total_entries);
 922
 923         if (chunk1samples)
 924                 *chunk = (sample - total) / chunk1samples + chunk1;
 925         else
 926                 *chunk = 1;
 927
 928         *chunk_sample = total + (*chunk - chunk1) * chunk1samples;
 929
 930         return 0;
 931 }
 932
 933 static int32_t chunk_to_offset(const struct mp4 *f, int32_t track,
 934                 int32_t chunk)
 935 {
 936         const struct mp4_track *p_track = f->track[track];
 937
 938         if (p_track->stco_entry_count && (chunk > p_track->stco_entry_count)) {
 939                 return p_track->stco_chunk_offset[p_track->stco_entry_count -
 940                                                   1];
 941         } else if (p_track->stco_entry_count) {
 942                 return p_track->stco_chunk_offset[chunk - 1];
 943         } else {
 944                 return 8;
 945         }
 946
 947         return 0;
 948 }
 949
 950 static int32_t sample_range_size(const struct mp4 *f, int32_t track,
 951                 int32_t chunk_sample, int32_t sample)
 952 {
 953         int32_t i, total;
 954         const struct mp4_track *p_track = f->track[track];
 955
 956         if (p_track->stsz_sample_size) {
 957                 return (sample - chunk_sample) * p_track->stsz_sample_size;
 958         } else {
 959                 if (sample >= p_track->stsz_sample_count)
 960                         return 0;       //error
 961
 962                 for (i = chunk_sample, total = 0; i < sample; i++) {
 963                         total += p_track->stsz_table[i];
 964                 }
 965         }
 966
 967         return total;
 968 }
 969
 970 static int32_t sample_to_offset(const struct mp4 *f, int32_t track,
 971                 int32_t sample)
 972 {
 973         int32_t chunk, chunk_sample, chunk_offset1, chunk_offset2;
 974
 975         chunk_of_sample(f, track, sample, &chunk_sample, &chunk);
 976
 977         chunk_offset1 = chunk_to_offset(f, track, chunk);
 978         chunk_offset2 = chunk_offset1 + sample_range_size(f,
 979                 track, chunk_sample, sample);
 980         return chunk_offset2;
 981 }
 982
 983 /**
 984  * Return the number of milliseconds of the given track.
 985  *
 986  * \param f As returned by \ref mp4_open_read(), must not be NULL.
 987  * \param track Between zero and the value returned by \ref mp4_total_tracks().
 988  *
 989  * The function returns zero if the audio file is of zero length or contains a
 990  * corrupt track header.
 991  */
 992 uint64_t mp4_get_duration(const struct mp4 *f, int32_t track)
 993 {
 994         const struct mp4_track *t = f->track[track];
 995
 996         if (t->timeScale == 0)
 997                 return 0;
 998         return t->duration * 1000 / t->timeScale;
 999 }
1000
1001 /**
1002  * Check whether the given track number corresponds to an audio track.
1003  *
1004  * \param f See \ref mp4_get_duration().
1005  * \param track See \ref mp4_get_duration().
1006  *
1007  * Besides audio tracks, an mp4 file may contain video and system tracks. For
1008  * those the function returns false.
1009  */
1010 bool mp4_is_audio_track(const struct mp4 *f, int32_t track)
1011 {
1012         return f->track[track]->is_audio;
1013 }
1014
1015 void mp4_set_sample_position(struct mp4 *f, int32_t track, int32_t sample)
1016 {
1017         int32_t offset = sample_to_offset(f, track, sample);
1018         set_position(f, offset);
1019 }
1020
1021 int32_t mp4_get_sample_size(const struct mp4 *f, int track, int sample)
1022 {
1023         const struct mp4_track *t = f->track[track];
1024
1025         if (t->stsz_sample_size != 0)
1026                 return t->stsz_sample_size;
1027         return t->stsz_table[sample];
1028 }
1029
1030 uint32_t mp4_get_sample_rate(const struct mp4 *f, int32_t track)
1031 {
1032         return f->track[track]->sampleRate;
1033 }
1034
1035 uint32_t mp4_get_channel_count(const struct mp4 *f, int32_t track)
1036 {
1037         return f->track[track]->channelCount;
1038 }
1039
1040 int32_t mp4_num_samples(const struct mp4 *f, int32_t track)
1041 {
1042         int32_t i;
1043         int32_t total = 0;
1044
1045         for (i = 0; i < f->track[track]->stts_entry_count; i++) {
1046                 total += f->track[track]->stts_sample_count[i];
1047         }
1048         return total;
1049 }
1050
1051 struct mp4 *mp4_open_meta(const struct mp4_callback *cb)
1052 {
1053         struct mp4 *f = para_calloc(sizeof(struct mp4));
1054
1055         f->cb = cb;
1056         parse_atoms(f, 1);
1057         if (f->error) {
1058                 free(f);
1059                 f = NULL;
1060         }
1061         return f;
1062 }
1063
1064 /**
1065  * Return the metadata of an mp4 file.
1066  *
1067  * \param f As returned by either \ref mp4_open_read() or \ref mp4_open_meta().
1068  *
1069  * The caller is allowed to add, delete or modify the entries of the returned
1070  * structure in order to pass the modified version to \ref mp4_meta_update().
1071  */
1072 struct mp4_metadata *mp4_get_meta(struct mp4 *f)
1073 {
1074         return &f->meta;
1075 }
1076
1077 static uint32_t find_atom(struct mp4 *f, uint64_t base, uint32_t size,
1078                           const char *name)
1079 {
1080         uint32_t remaining = size;
1081         uint64_t atom_offset = base;
1082         for (;;) {
1083                 char atom_name[4];
1084                 uint32_t atom_size;
1085
1086                 set_position(f, atom_offset);
1087
1088                 if (remaining < 8)
1089                         break;
1090                 atom_size = read_int32(f);
1091                 if (atom_size > remaining || atom_size < 8)
1092                         break;
1093                 read_data(f, atom_name, 4);
1094
1095                 if (!memcmp(atom_name, name, 4)) {
1096                         set_position(f, atom_offset);
1097                         return 1;
1098                 }
1099
1100                 remaining -= atom_size;
1101                 atom_offset += atom_size;
1102         }
1103         return 0;
1104 }
1105
1106 static uint32_t find_atom_v2(struct mp4 *f, uint64_t base, uint32_t size,
1107                 const char *name, uint32_t extraheaders, const char *name_inside)
1108 {
1109         uint64_t first_base = (uint64_t) (-1);
1110         while (find_atom(f, base, size, name))  //try to find atom <name> with atom <name_inside> in it
1111         {
1112                 uint64_t mybase = get_position(f);
1113                 uint32_t mysize = read_int32(f);
1114
1115                 if (first_base == (uint64_t) (-1))
1116                         first_base = mybase;
1117
1118                 if (mysize < 8 + extraheaders)
1119                         break;
1120
1121                 if (find_atom (f, mybase + (8 + extraheaders),
1122                                 mysize - (8 + extraheaders), name_inside)) {
1123                         set_position(f, mybase);
1124                         return 2;
1125                 }
1126                 base += mysize;
1127                 if (size <= mysize) {
1128                         size = 0;
1129                         break;
1130                 }
1131                 size -= mysize;
1132         }
1133
1134         if (first_base != (uint64_t) (-1))      //wanted atom inside not found
1135         {
1136                 set_position(f, first_base);
1137                 return 1;
1138         } else
1139                 return 0;
1140 }
1141
1142 struct membuffer {
1143         void *data;
1144         unsigned written;
1145         unsigned allocated;
1146 };
1147
1148 static struct membuffer *membuffer_create(void)
1149 {
1150         struct membuffer *buf = para_calloc(sizeof(*buf));
1151
1152         buf->allocated = 256;
1153         buf->data = para_malloc(buf->allocated);
1154         return buf;
1155 }
1156
1157 static void membuffer_write(struct membuffer *buf, const void *ptr,
1158                 unsigned bytes)
1159 {
1160         unsigned dest_size = buf->written + bytes;
1161
1162         if (dest_size > buf->allocated) {
1163                 do {
1164                         buf->allocated <<= 1;
1165                 } while (dest_size > buf->allocated);
1166                 buf->data = para_realloc(buf->data, buf->allocated);
1167         }
1168
1169         if (ptr)
1170                 memcpy((char *) buf->data + buf->written, ptr, bytes);
1171         buf->written += bytes;
1172 }
1173
1174 static void membuffer_write_atom_name(struct membuffer *buf, const char *data)
1175 {
1176         membuffer_write(buf, data, 4);
1177 }
1178
1179 static void membuffer_write_int32(struct membuffer *buf, uint32_t data)
1180 {
1181         uint8_t temp[4];
1182         write_u32_be(temp, data);
1183         membuffer_write(buf, temp, 4);
1184 }
1185
1186 static void membuffer_write_std_tag(struct membuffer *buf, const char *name,
1187                 const char *value)
1188 {
1189         uint32_t len = strlen(value);
1190         membuffer_write_int32(buf, 8 /* atom header */
1191                 + 8 /* data atom header */
1192                 + 8 /* flags + reserved */
1193                 + len);
1194         membuffer_write_atom_name(buf, name);
1195         membuffer_write_int32(buf, 8 /* data atom header */
1196                 + 8 /* flags + reserved */
1197                 + len);
1198         membuffer_write_atom_name(buf, "data");
1199         membuffer_write_int32(buf, 1);  /* flags */
1200         membuffer_write_int32(buf, 0);  /* reserved */
1201         membuffer_write(buf, value, len);
1202 }
1203
1204 static unsigned membuffer_get_size(const struct membuffer *buf)
1205 {
1206         return buf->written;
1207 }
1208
1209 static void *membuffer_detach(struct membuffer *buf)
1210 {
1211         void *ret = para_realloc(buf->data, buf->written);
1212         free(buf);
1213         return ret;
1214 }
1215
1216 struct stdmeta_entry {
1217         const char *atom;
1218         const char *name;
1219 };
1220
1221 static const char *find_standard_meta(const char *name)
1222 {
1223         const struct stdmeta_entry stdmetas[] = {
1224                 {"\xA9" "nam", "title"},
1225                 {"\xA9" "ART", "artist"},
1226                 {"\xA9" "alb", "album"},
1227                 {"\xA9" "day", "date"},
1228                 {"\xA9" "cmt", "comment"},
1229         };
1230
1231         for (unsigned n = 0; n < ARRAY_SIZE(stdmetas); n++)
1232                 if (!strcasecmp(name, stdmetas[n].name))
1233                         return stdmetas[n].atom;
1234         return NULL;
1235 }
1236
1237 static uint32_t create_ilst(const struct mp4_metadata *meta, void **out_buffer,
1238                 uint32_t * out_size)
1239 {
1240         struct membuffer *buf = membuffer_create();
1241         unsigned metaptr;
1242
1243         for (metaptr = 0; metaptr < meta->count; metaptr++) {
1244                 struct mp4_tag *tag = meta->tags + metaptr;
1245                 const char *std_meta_atom = find_standard_meta(tag->item);
1246                 if (std_meta_atom)
1247                         membuffer_write_std_tag(buf, std_meta_atom, tag->value);
1248                 else
1249                         PARA_ERROR_LOG("invalid tag item: %s\n", tag->item);
1250         }
1251         *out_size = membuffer_get_size(buf);
1252         *out_buffer = membuffer_detach(buf);
1253         return 1;
1254 }
1255
1256 static void membuffer_write_atom(struct membuffer *buf, const char *name, unsigned size,
1257                           const void *data)
1258 {
1259         membuffer_write_int32(buf, size + 8);
1260         membuffer_write_atom_name(buf, name);
1261         membuffer_write(buf, data, size);
1262 }
1263
1264 static void *membuffer_get_ptr(const struct membuffer *buf)
1265 {
1266         return buf->data;
1267 }
1268
1269 static bool membuffer_transfer_from_file(struct membuffer *buf, struct mp4 *src,
1270                 unsigned bytes)
1271 {
1272         unsigned oldsize = membuffer_get_size(buf);
1273         char *bufptr;
1274
1275         membuffer_write(buf, 0, bytes);
1276         bufptr = membuffer_get_ptr(buf);
1277         if (read_data(src, bufptr + oldsize, bytes) != bytes) {
1278                 free(buf->data);
1279                 free(buf);
1280                 return false;
1281         }
1282         return true;
1283 }
1284
1285 static uint32_t create_meta(const struct mp4_metadata *meta, void **out_buffer,
1286                 uint32_t * out_size)
1287 {
1288         struct membuffer *buf;
1289         uint32_t ilst_size;
1290         void *ilst_buffer;
1291
1292         if (!create_ilst(meta, &ilst_buffer, &ilst_size))
1293                 return 0;
1294
1295         buf = membuffer_create();
1296
1297         membuffer_write_int32(buf, 0);
1298         membuffer_write_atom(buf, "ilst", ilst_size, ilst_buffer);
1299         free(ilst_buffer);
1300
1301         *out_size = membuffer_get_size(buf);
1302         *out_buffer = membuffer_detach(buf);
1303         return 1;
1304 }
1305
1306 static uint32_t create_udta(const struct mp4_metadata *meta, void **out_buffer,
1307 uint32_t * out_size)
1308 {
1309         struct membuffer *buf;
1310         uint32_t meta_size;
1311         void *meta_buffer;
1312
1313         if (!create_meta(meta, &meta_buffer, &meta_size))
1314                 return 0;
1315
1316         buf = membuffer_create();
1317
1318         membuffer_write_atom(buf, "meta", meta_size, meta_buffer);
1319
1320         free(meta_buffer);
1321
1322         *out_size = membuffer_get_size(buf);
1323         *out_buffer = membuffer_detach(buf);
1324         return 1;
1325 }
1326
1327 static uint32_t fix_byte_order_32(uint32_t src)
1328 {
1329         return read_u32_be(&src);
1330 }
1331
1332 static void *modify_moov(struct mp4 *f, uint32_t *out_size)
1333 {
1334         uint64_t total_base = f->moov_offset + 8;
1335         uint32_t total_size = (uint32_t) (f->moov_size - 8);
1336
1337         uint64_t udta_offset, meta_offset, ilst_offset;
1338         uint32_t udta_size, meta_size, ilst_size;
1339
1340         uint32_t new_ilst_size;
1341         void *new_ilst_buffer, *out_buffer;
1342
1343         uint8_t *p_out;
1344         int32_t size_delta;
1345
1346         if (!find_atom_v2(f, total_base, total_size, "udta", 0, "meta")) {
1347                 struct membuffer *buf;
1348                 void *new_udta_buffer;
1349                 uint32_t new_udta_size;
1350                 if (!create_udta(&f->meta, &new_udta_buffer, &new_udta_size))
1351                         return NULL;
1352
1353                 buf = membuffer_create();
1354                 set_position(f, total_base);
1355                 if (!membuffer_transfer_from_file(buf, f, total_size)) {
1356                         free(new_udta_buffer);
1357                         return NULL;
1358                 }
1359                 membuffer_write_atom(buf, "udta", new_udta_size,
1360                         new_udta_buffer);
1361
1362                 free(new_udta_buffer);
1363
1364                 *out_size = membuffer_get_size(buf);
1365                 return membuffer_detach(buf);
1366         }
1367         udta_offset = get_position(f);
1368         udta_size = read_int32(f);
1369         if (!find_atom_v2 (f, udta_offset + 8, udta_size - 8, "meta", 4, "ilst")) {
1370                 struct membuffer *buf;
1371                 void *new_meta_buffer;
1372                 uint32_t new_meta_size;
1373
1374                 if (!create_meta(&f->meta, &new_meta_buffer, &new_meta_size))
1375                         return NULL;
1376
1377                 buf = membuffer_create();
1378                 set_position(f, total_base);
1379                 if (!membuffer_transfer_from_file(buf, f,
1380                                 udta_offset - total_base)) {
1381                         free(new_meta_buffer);
1382                         return NULL;
1383                 }
1384
1385                 membuffer_write_int32(buf, udta_size + 8 + new_meta_size);
1386                 membuffer_write_atom_name(buf, "udta");
1387                 if (!membuffer_transfer_from_file(buf, f, udta_size)) {
1388                         free(new_meta_buffer);
1389                         return NULL;
1390                 }
1391
1392                 membuffer_write_atom(buf, "meta", new_meta_size,
1393                         new_meta_buffer);
1394                 free(new_meta_buffer);
1395
1396                 *out_size = membuffer_get_size(buf);
1397                 return membuffer_detach(buf);
1398         }
1399         meta_offset = get_position(f);
1400         meta_size = read_int32(f);
1401         /* shouldn't happen, find_atom_v2 above takes care of it */
1402         if (!find_atom(f, meta_offset + 12, meta_size - 12, "ilst"))
1403                 return NULL;
1404         ilst_offset = get_position(f);
1405         ilst_size = read_int32(f);
1406         if (!create_ilst(&f->meta, &new_ilst_buffer, &new_ilst_size))
1407                 return NULL;
1408         size_delta = new_ilst_size - (ilst_size - 8);
1409         *out_size = total_size + size_delta;
1410         out_buffer = para_malloc(*out_size);
1411         p_out = out_buffer;
1412         set_position(f, total_base);
1413         read_data(f, p_out, (uint32_t) (udta_offset - total_base));
1414         p_out += (uint32_t) (udta_offset - total_base);
1415         *(uint32_t *)p_out = fix_byte_order_32(read_int32(f) + size_delta);
1416         p_out += 4;
1417         read_data(f, p_out, 4);
1418         p_out += 4;
1419         read_data(f, p_out, (uint32_t) (meta_offset - udta_offset - 8));
1420         p_out += (uint32_t) (meta_offset - udta_offset - 8);
1421         *(uint32_t *)p_out = fix_byte_order_32(read_int32(f) + size_delta);
1422         p_out += 4;
1423         read_data(f, p_out, 4);
1424         p_out += 4;
1425         read_data(f, p_out, (uint32_t) (ilst_offset - meta_offset - 8));
1426         p_out += (uint32_t) (ilst_offset - meta_offset - 8);
1427         *(uint32_t *)p_out = fix_byte_order_32(read_int32(f) + size_delta);
1428         p_out += 4;
1429         read_data(f, p_out, 4);
1430         p_out += 4;
1431         memcpy(p_out, new_ilst_buffer, new_ilst_size);
1432         p_out += new_ilst_size;
1433         set_position(f, ilst_offset + ilst_size);
1434         read_data(f, p_out, (uint32_t) (total_size
1435                 - (ilst_offset - total_base) - ilst_size));
1436         free(new_ilst_buffer);
1437         return out_buffer;
1438 }
1439
1440 static int32_t write_data(struct mp4 *f, void *data, uint32_t size)
1441 {
1442         int32_t result = 1;
1443
1444         result = f->cb->write(f->cb->user_data, data, size);
1445
1446         f->current_position += size;
1447
1448         return result;
1449 }
1450
1451 static int32_t write_int32(struct mp4 *f, uint32_t data)
1452 {
1453         int8_t temp[4];
1454         write_u32_be(temp, data);
1455         return write_data(f, temp, sizeof(temp));
1456 }
1457
1458 int32_t mp4_meta_update(struct mp4 *f)
1459 {
1460         void *new_moov_data;
1461         uint32_t new_moov_size;
1462
1463         set_position(f, 0);
1464         new_moov_data = modify_moov(f, &new_moov_size);
1465         if (!new_moov_data ) {
1466                 mp4_close(f);
1467                 return 0;
1468         }
1469         /* copy moov atom to end of the file */
1470         if (f->last_atom != ATOM_MOOV) {
1471                 char *free_data = "free";
1472
1473                 /* rename old moov to free */
1474                 set_position(f, f->moov_offset + 4);
1475                 write_data(f, free_data, 4);
1476
1477                 set_position(f, f->file_size);
1478                 write_int32(f, new_moov_size + 8);
1479                 write_data(f, "moov", 4);
1480                 write_data(f, new_moov_data, new_moov_size);
1481         } else {
1482                 set_position(f, f->moov_offset);
1483                 write_int32(f, new_moov_size + 8);
1484                 write_data(f, "moov", 4);
1485                 write_data(f, new_moov_data, new_moov_size);
1486         }
1487         free(new_moov_data);
1488         f->cb->truncate(f->cb->user_data);
1489         return 1;
1490 }
1491
1492 static char *meta_find_by_name(const struct mp4 *f, const char *item)
1493 {
1494         uint32_t i;
1495
1496         for (i = 0; i < f->meta.count; i++)
1497                 if (!strcasecmp(f->meta.tags[i].item, item))
1498                         return para_strdup(f->meta.tags[i].value);
1499         return NULL;
1500 }
1501
1502 /**
1503  * Return the value of the artist meta tag of an mp4 file.
1504  *
1505  * \param f Must not be NULL.
1506  *
1507  * \return If the file does not contain this metadata tag, the function returns
1508  * NULL. Otherwise, a copy of the tag value is returned. The caller should free
1509  * this memory when it is no longer needed.
1510  */
1511 char *mp4_meta_get_artist(const struct mp4 *f)
1512 {
1513         return meta_find_by_name(f, "artist");
1514 }
1515
1516 /**
1517  * Return the value of the title meta tag of an mp4 file.
1518  *
1519  * \param f See \ref mp4_meta_get_artist().
1520  * \return See \ref mp4_meta_get_artist().
1521  */
1522 char *mp4_meta_get_title(const struct mp4 *f)
1523 {
1524         return meta_find_by_name(f, "title");
1525 }
1526
1527 /**
1528  * Return the value of the date meta tag of an mp4 file.
1529  *
1530  * \param f See \ref mp4_meta_get_artist().
1531  * \return See \ref mp4_meta_get_artist().
1532  */
1533 char *mp4_meta_get_date(const struct mp4 *f)
1534 {
1535         return meta_find_by_name(f, "date");
1536 }
1537
1538 /**
1539  * Return the value of the album meta tag of an mp4 file.
1540  *
1541  * \param f See \ref mp4_meta_get_artist().
1542  * \return See \ref mp4_meta_get_artist().
1543  */
1544 char *mp4_meta_get_album(const struct mp4 *f)
1545 {
1546         return meta_find_by_name(f, "album");
1547 }
1548
1549 /**
1550  * Return the value of the comment meta tag of an mp4 file.
1551  *
1552  * \param f See \ref mp4_meta_get_artist().
1553  * \return See \ref mp4_meta_get_artist().
1554  */
1555 char *mp4_meta_get_comment(const struct mp4 *f)
1556 {
1557         return meta_find_by_name(f, "comment");
1558 }