git.sesse.net Git - vlc/blob - modules/demux/mp4/mp4.h

   1 /*****************************************************************************
   2  * mp4.h : MP4 file input module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2001 VideoLAN
   5  * $Id: mp4.h,v 1.9 2003/11/27 12:32:51 fenrir Exp $
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23
  24 /*****************************************************************************
  25  * Contain all information about a chunk
  26  *****************************************************************************/
  27 typedef struct chunk_data_mp4_s
  28 {
  29     uint64_t     i_offset; /* absolute position of this chunk in the file */
  30     uint32_t     i_sample_description_index; /* index for SampleEntry to use */
  31     uint32_t     i_sample_count; /* how many samples in this chunk */
  32     uint32_t     i_sample_first; /* index of the first sample in this chunk */
  33
  34     /* now provide way to calculate pts, dts, and offset without to
  35         much memory and with fast acces */
  36
  37     /* with this we can calculate dts/pts without waste memory */
  38     uint64_t     i_first_dts;
  39     uint32_t     *p_sample_count_dts;
  40     uint32_t     *p_sample_delta_dts; /* dts delta */
  41
  42     /* TODO if needed add pts
  43         but quickly *add* support for edts and seeking */
  44
  45 } chunk_data_mp4_t;
  46
  47
  48 /*****************************************************************************
  49  * Contain all needed information for read all track with vlc
  50  *****************************************************************************/
  51 typedef struct track_data_mp4_s
  52 {
  53     int i_track_ID;     /* this should be unique */
  54
  55     int b_ok;           /* The track is usable */
  56     int b_enable;       /* is the trak enable by default */
  57     vlc_bool_t b_selected;     /* is the trak being played */
  58
  59     es_format_t fmt;
  60     es_out_id_t *p_es;
  61
  62     /* display size only ! */
  63     int i_width;
  64     int i_height;
  65
  66     /* more internal data */
  67     uint64_t         i_timescale;  /* time scale for this track only */
  68
  69     /* give the next sample to read, i_chunk is to find quickly where
  70       the sample is located */
  71     uint32_t         i_sample;       /* next sample to read */
  72     uint32_t         i_chunk;        /* chunk where next sample is stored */
  73     /* total count of chunk and sample */
  74     uint32_t         i_chunk_count;
  75     uint32_t         i_sample_count;
  76
  77     chunk_data_mp4_t    *chunk; /* always defined  for each chunk */
  78
  79     /* sample size, p_sample_size defined only if i_sample_size == 0
  80         else i_sample_size is size for all sample */
  81     uint32_t         i_sample_size;
  82     uint32_t         *p_sample_size; /* XXX perhaps add file offset if take
  83                                     too much time to do sumations each time*/
  84
  85     MP4_Box_t *p_stbl;  /* will contain all timing information */
  86     MP4_Box_t *p_stsd;  /* will contain all data to initialize decoder */
  87     MP4_Box_t *p_sample;/* point on actual sdsd */
  88
  89 } track_data_mp4_t;
  90
  91
  92 /*****************************************************************************
  93  *
  94  *****************************************************************************/
  95 struct demux_sys_t
  96 {
  97     MP4_Box_t    *p_root;      /* container for the whole file */
  98
  99     mtime_t      i_pcr;
 100
 101     uint64_t     i_time;        /* time position of the presentation
 102                                  * in movie timescale */
 103     uint64_t     i_timescale;   /* movie time scale */
 104     uint64_t     i_duration;    /* movie duration */
 105     unsigned int i_tracks;      /* number of tracks */
 106     track_data_mp4_t *track;    /* array of track */
 107 };
 108
 109 #if 0
 110 static inline uint64_t MP4_GetTrackPos( track_data_mp4_t *p_track )
 111 {
 112     unsigned int i_sample;
 113     uint64_t i_pos;
 114
 115
 116     i_pos = p_track->chunk[p_track->i_chunk].i_offset;
 117
 118     if( p_track->i_sample_size )
 119     {
 120         i_pos += ( p_track->i_sample -
 121                         p_track->chunk[p_track->i_chunk].i_sample_first ) *
 122                                 p_track->i_sample_size;
 123     }
 124     else
 125     {
 126         for( i_sample = p_track->chunk[p_track->i_chunk].i_sample_first;
 127                 i_sample < p_track->i_sample; i_sample++ )
 128         {
 129             i_pos += p_track->p_sample_size[i_sample];
 130         }
 131
 132     }
 133     return( i_pos );
 134 }
 135 #endif
 136
 137 /* Return time in µs of a track */
 138 static inline mtime_t MP4_GetTrackPTS( track_data_mp4_t *p_track )
 139 {
 140     unsigned int i_sample;
 141     unsigned int i_index;
 142     uint64_t i_dts;
 143
 144     i_sample = p_track->i_sample - p_track->chunk[p_track->i_chunk].i_sample_first;
 145     i_dts = p_track->chunk[p_track->i_chunk].i_first_dts;
 146     i_index = 0;
 147     while( i_sample > 0 )
 148     {
 149         if( i_sample > p_track->chunk[p_track->i_chunk].p_sample_count_dts[i_index] )
 150         {
 151             i_dts += p_track->chunk[p_track->i_chunk].p_sample_count_dts[i_index] *
 152                         p_track->chunk[p_track->i_chunk].p_sample_delta_dts[i_index];
 153             i_sample -= p_track->chunk[p_track->i_chunk].p_sample_count_dts[i_index];
 154             i_index++;
 155         }
 156         else
 157         {
 158             i_dts += i_sample *
 159                         p_track->chunk[p_track->i_chunk].p_sample_delta_dts[i_index];
 160             i_sample = 0;
 161             break;
 162         }
 163     }
 164     return( (mtime_t)(
 165                 (mtime_t)1000000 *
 166                 (mtime_t)i_dts /
 167                 (mtime_t)p_track->i_timescale ) );
 168 }
 169
 170 static inline mtime_t MP4_GetMoviePTS(demux_sys_t *p_demux )
 171 {
 172     return( (mtime_t)(
 173                 (mtime_t)1000000 *
 174                 (mtime_t)p_demux->i_time /
 175                 (mtime_t)p_demux->i_timescale )
 176           );
 177 }