src/mp4ff/mp4ff.c

   1 /*
   2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU General Public License as published by
   7 ** the Free Software Foundation; either version 2 of the License, or
   8 ** (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
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 **
  19 ** Any non-GPL usage of this software or parts of this software is strictly
  20 ** forbidden.
  21 **
  22 ** Commercial non-GPL licensing of this software is possible.
  23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  24 **
  25 ** $Id: mp4ff.c,v 1.15 2004/01/11 15:52:18 menno Exp $
  26 **/
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include "mp4ffint.h"
  31
  32 #include "drms.h"
  33
  34 int64_t mp4ff_get_track_duration_use_offsets(const mp4ff_t *f, const int32_t track);
  35
  36 mp4ff_t *mp4ff_open_read(mp4ff_callback_t *f)
  37 {
  38     mp4ff_t *ff = malloc(sizeof(mp4ff_t));
  39
  40     memset(ff, 0, sizeof(mp4ff_t));
  41
  42     ff->stream = f;
  43
  44     parse_atoms(ff);
  45
  46     return ff;
  47 }
  48
  49 void mp4ff_close(mp4ff_t *ff)
  50 {
  51     int32_t i;
  52
  53     for (i = 0; i < ff->total_tracks; i++)
  54     {
  55         if (ff->track[i])
  56         {
  57             if (ff->track[i]->stsz_table)
  58                 free(ff->track[i]->stsz_table);
  59             if (ff->track[i]->stts_sample_count)
  60                 free(ff->track[i]->stts_sample_count);
  61             if (ff->track[i]->stts_sample_delta)
  62                 free(ff->track[i]->stts_sample_delta);
  63             if (ff->track[i]->stsc_first_chunk)
  64                 free(ff->track[i]->stsc_first_chunk);
  65             if (ff->track[i]->stsc_samples_per_chunk)
  66                 free(ff->track[i]->stsc_samples_per_chunk);
  67             if (ff->track[i]->stsc_sample_desc_index)
  68                 free(ff->track[i]->stsc_sample_desc_index);
  69             if (ff->track[i]->stco_chunk_offset)
  70                 free(ff->track[i]->stco_chunk_offset);
  71             if (ff->track[i]->decoderConfig)
  72                 free(ff->track[i]->decoderConfig);
  73                         if (ff->track[i]->ctts_sample_count)
  74                                 free(ff->track[i]->ctts_sample_count);
  75                         if (ff->track[i]->ctts_sample_offset)
  76                                 free(ff->track[i]->ctts_sample_offset);
  77 #ifdef ITUNES_DRM
  78             if (ff->track[i]->p_drms)
  79                 drms_free(ff->track[i]->p_drms);
  80 #endif
  81             free(ff->track[i]);
  82         }
  83     }
  84
  85 #ifdef USE_TAGGING
  86     mp4ff_tag_delete(&(ff->tags));
  87 #endif
  88
  89     if (ff) free(ff);
  90 }
  91
  92 static void mp4ff_track_add(mp4ff_t *f)
  93 {
  94     f->total_tracks++;
  95
  96     f->track[f->total_tracks - 1] = malloc(sizeof(mp4ff_track_t));
  97
  98     memset(f->track[f->total_tracks - 1], 0, sizeof(mp4ff_track_t));
  99 }
 100
 101 /* parse atoms that are sub atoms of other atoms */
 102 int32_t parse_sub_atoms(mp4ff_t *f, const uint64_t total_size)
 103 {
 104     uint64_t size;
 105     uint8_t atom_type = 0;
 106     uint64_t counted_size = 0;
 107     uint8_t header_size = 0;
 108
 109     while (counted_size < total_size)
 110     {
 111         size = mp4ff_atom_read_header(f, &atom_type, &header_size);
 112         counted_size += size;
 113
 114         /* check for end of file */
 115         if (size == 0)
 116             break;
 117
 118         /* we're starting to read a new track, update index,
 119          * so that all data and tables get written in the right place
 120          */
 121         if (atom_type == ATOM_TRAK)
 122         {
 123             mp4ff_track_add(f);
 124         }
 125
 126         /* parse subatoms */
 127         if (atom_type < SUBATOMIC)
 128         {
 129             parse_sub_atoms(f, size-header_size);
 130         } else {
 131             mp4ff_atom_read(f, (uint32_t)size, atom_type);
 132         }
 133     }
 134
 135     return 0;
 136 }
 137
 138 /* parse root atoms */
 139 int32_t parse_atoms(mp4ff_t *f)
 140 {
 141     uint64_t size;
 142     uint8_t atom_type = 0;
 143     uint8_t header_size = 0;
 144
 145     f->file_size = 0;
 146
 147     while ((size = mp4ff_atom_read_header(f, &atom_type, &header_size)) != 0)
 148     {
 149         f->file_size += size;
 150         f->last_atom = atom_type;
 151
 152         if (atom_type == ATOM_MDAT && f->moov_read)
 153         {
 154             /* moov atom is before mdat, we can stop reading when mdat is encountered */
 155             /* file position will stay at beginning of mdat data */
 156 //            break;
 157         }
 158
 159         if (atom_type == ATOM_MOOV && size > header_size)
 160         {
 161             f->moov_read = 1;
 162             f->moov_offset = mp4ff_position(f)-header_size;
 163             f->moov_size = size;
 164         }
 165
 166         /* parse subatoms */
 167         if (atom_type < SUBATOMIC)
 168         {
 169             parse_sub_atoms(f, size-header_size);
 170         } else {
 171             /* skip this atom */
 172             mp4ff_set_position(f, mp4ff_position(f)+size-header_size);
 173         }
 174     }
 175
 176     return 0;
 177 }
 178
 179 int32_t mp4ff_get_decoder_config(const mp4ff_t *f, const int32_t track,
 180                                  uint8_t** ppBuf, uint32_t* pBufSize)
 181 {
 182     if (track >= f->total_tracks)
 183     {
 184         *ppBuf = NULL;
 185         *pBufSize = 0;
 186         return 1;
 187     }
 188
 189     if (f->track[track]->decoderConfig == NULL || f->track[track]->decoderConfigLen == 0)
 190     {
 191         *ppBuf = NULL;
 192         *pBufSize = 0;
 193     } else {
 194         *ppBuf = malloc(f->track[track]->decoderConfigLen);
 195         if (*ppBuf == NULL)
 196         {
 197             *pBufSize = 0;
 198             return 1;
 199         }
 200         memcpy(*ppBuf, f->track[track]->decoderConfig, f->track[track]->decoderConfigLen);
 201         *pBufSize = f->track[track]->decoderConfigLen;
 202     }
 203
 204     return 0;
 205 }
 206
 207 static int32_t mp4ff_get_track_type(const mp4ff_t *f, const int track)
 208 {
 209         return f->track[track]->type;
 210 }
 211
 212 int32_t mp4ff_total_tracks(const mp4ff_t *f)
 213 {
 214     return f->total_tracks;
 215 }
 216
 217 int32_t mp4ff_time_scale(const mp4ff_t *f, const int32_t track)
 218 {
 219     return f->track[track]->timeScale;
 220 }
 221
 222 static uint32_t mp4ff_get_avg_bitrate(const mp4ff_t *f, const int32_t track)
 223 {
 224         return f->track[track]->avgBitrate;
 225 }
 226
 227 static uint32_t mp4ff_get_max_bitrate(const mp4ff_t *f, const int32_t track)
 228 {
 229         return f->track[track]->maxBitrate;
 230 }
 231
 232 static int64_t mp4ff_get_track_duration(const mp4ff_t *f, const int32_t track)
 233 {
 234         return f->track[track]->duration;
 235 }
 236
 237 int64_t mp4ff_get_track_duration_use_offsets(const mp4ff_t *f, const int32_t track)
 238 {
 239         int64_t duration = mp4ff_get_track_duration(f,track);
 240         if (duration!=-1)
 241         {
 242                 int64_t offset = mp4ff_get_sample_offset(f,track,0);
 243                 if (offset > duration) duration = 0;
 244                 else duration -= offset;
 245         }
 246         return duration;
 247 }
 248
 249
 250 int32_t mp4ff_num_samples(const mp4ff_t *f, const int32_t track)
 251 {
 252     int32_t i;
 253     int32_t total = 0;
 254
 255     for (i = 0; i < f->track[track]->stts_entry_count; i++)
 256     {
 257         total += f->track[track]->stts_sample_count[i];
 258     }
 259     return total;
 260 }
 261
 262
 263
 264
 265 static uint32_t mp4ff_get_sample_rate(const mp4ff_t *f, const int32_t track)
 266 {
 267         return f->track[track]->sampleRate;
 268 }
 269
 270 static uint32_t mp4ff_get_channel_count(const mp4ff_t * f,const int32_t track)
 271 {
 272         return f->track[track]->channelCount;
 273 }
 274
 275 static uint32_t mp4ff_get_audio_type(const mp4ff_t * f,const int32_t track)
 276 {
 277         return f->track[track]->audioType;
 278 }
 279
 280 static int32_t mp4ff_get_sample_duration_use_offsets(const mp4ff_t *f, const int32_t track, const int32_t sample)
 281 {
 282         int32_t d,o;
 283         d = mp4ff_get_sample_duration(f,track,sample);
 284         if (d!=-1)
 285         {
 286                 o = mp4ff_get_sample_offset(f,track,sample);
 287                 if (o>d) d = 0;
 288                 else d -= o;
 289         }
 290         return d;
 291 }
 292
 293 int32_t mp4ff_get_sample_duration(const mp4ff_t *f, const int32_t track, const int32_t sample)
 294 {
 295     int32_t i, co = 0;
 296
 297     for (i = 0; i < f->track[track]->stts_entry_count; i++)
 298     {
 299                 int32_t delta = f->track[track]->stts_sample_count[i];
 300                 if (sample < co + delta)
 301                         return f->track[track]->stts_sample_delta[i];
 302                 co += delta;
 303     }
 304     return (int32_t)(-1);
 305 }
 306
 307 int64_t mp4ff_get_sample_position(const mp4ff_t *f, const int32_t track, const int32_t sample)
 308 {
 309     int32_t i, co = 0;
 310         int64_t acc = 0;
 311
 312     for (i = 0; i < f->track[track]->stts_entry_count; i++)
 313     {
 314                 int32_t delta = f->track[track]->stts_sample_count[i];
 315                 if (sample < co + delta)
 316                 {
 317                         acc += f->track[track]->stts_sample_delta[i] * (sample - co);
 318                         return acc;
 319                 }
 320                 else
 321                 {
 322                         acc += f->track[track]->stts_sample_delta[i] * delta;
 323                 }
 324                 co += delta;
 325     }
 326     return (int64_t)(-1);
 327 }
 328
 329 int32_t mp4ff_get_sample_offset(const mp4ff_t *f, const int32_t track, const int32_t sample)
 330 {
 331     int32_t i, co = 0;
 332
 333     for (i = 0; i < f->track[track]->ctts_entry_count; i++)
 334     {
 335                 int32_t delta = f->track[track]->ctts_sample_count[i];
 336                 if (sample < co + delta)
 337                         return f->track[track]->ctts_sample_offset[i];
 338                 co += delta;
 339     }
 340     return 0;
 341 }
 342
 343 int32_t mp4ff_find_sample(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip)
 344 {
 345         int32_t i, co = 0;
 346         int64_t offset_total = 0;
 347         mp4ff_track_t * p_track = f->track[track];
 348
 349         for (i = 0; i < p_track->stts_entry_count; i++)
 350         {
 351                 int32_t sample_count = p_track->stts_sample_count[i];
 352                 int32_t sample_delta = p_track->stts_sample_delta[i];
 353                 int64_t offset_delta = (int64_t)sample_delta * (int64_t)sample_count;
 354                 if (offset < offset_total + offset_delta)
 355                 {
 356                         int64_t offset_fromstts = offset - offset_total;
 357                         if (toskip) *toskip = (int32_t)(offset_fromstts % sample_delta);
 358                         return co + (int32_t)(offset_fromstts / sample_delta);
 359                 }
 360                 else
 361                 {
 362                         offset_total += offset_delta;
 363                 }
 364                 co += sample_count;
 365         }
 366         return (int32_t)(-1);
 367 }
 368
 369 static int32_t mp4ff_find_sample_use_offsets(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip)
 370 {
 371         return mp4ff_find_sample(f,track,offset + mp4ff_get_sample_offset(f,track,0),toskip);
 372 }
 373
 374 int32_t mp4ff_read_sample(mp4ff_t *f, const int32_t track, const int32_t sample,
 375                           uint8_t **audio_buffer,  uint32_t *bytes)
 376 {
 377     int32_t result = 0;
 378
 379     *bytes = mp4ff_audio_frame_size(f, track, sample);
 380
 381         if (*bytes==0) return 0;
 382
 383     *audio_buffer = (uint8_t*)malloc(*bytes);
 384
 385     mp4ff_set_sample_position(f, track, sample);
 386
 387     result = mp4ff_read_data(f, *audio_buffer, *bytes);
 388
 389     if (!result)
 390         {
 391                 free(*audio_buffer);
 392                 *audio_buffer = 0;
 393         return 0;
 394         }
 395
 396 #ifdef ITUNES_DRM
 397     if (f->track[track]->p_drms != NULL)
 398     {
 399         drms_decrypt(f->track[track]->p_drms, (uint32_t*)*audio_buffer, *bytes);
 400     }
 401 #endif
 402
 403     return *bytes;
 404 }
 405
 406
 407 static int32_t mp4ff_read_sample_v2(mp4ff_t *f, const int track, const int sample,unsigned char *buffer)
 408 {
 409     int32_t result = 0;
 410         int32_t size = mp4ff_audio_frame_size(f,track,sample);
 411         if (size<=0) return 0;
 412         mp4ff_set_sample_position(f, track, sample);
 413         result = mp4ff_read_data(f,buffer,size);
 414
 415 #ifdef ITUNES_DRM
 416     if (f->track[track]->p_drms != NULL)
 417     {
 418         drms_decrypt(f->track[track]->p_drms, (uint32_t*)buffer, size);
 419     }
 420 #endif
 421
 422     return result;
 423 }
 424
 425 static int32_t mp4ff_read_sample_getsize(mp4ff_t *f, const int track, const int sample)
 426 {
 427         int32_t temp = mp4ff_audio_frame_size(f, track, sample);
 428         if (temp<0) temp = 0;
 429         return temp;
 430 }