* cinepak: add a new fourcc
[vlc.git] / plugins / 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.6 2002/07/23 17:19:02 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 /*****************************************************************************
26  * Structure needed for decoder
27  *****************************************************************************/
28 typedef struct bitmapinfoheader_s
29 {
30     u32 i_size; /* size of header 40 + size of data follwoing this header */
31     u32 i_width;
32     u32 i_height;
33     u16 i_planes;
34     u16 i_bitcount;
35     u32 i_compression;
36     u32 i_sizeimage;
37     u32 i_xpelspermeter;
38     u32 i_ypelspermeter;
39     u32 i_clrused;
40     u32 i_clrimportant;
41 } bitmapinfoheader_t;
42
43 typedef struct waveformatex_s
44 {
45     u16 i_format;
46     u16 i_channels;
47     u32 i_samplepersec;
48     u32 i_avgbytespersec;
49     u16 i_blockalign;
50     u16 i_bitspersample;
51     u16 i_size;          /* This give size of data 
52                             imediatly following this header. */
53 } waveformatex_t;
54
55 /*****************************************************************************
56  * Contain all information about a chunk
57  *****************************************************************************/
58 typedef struct chunk_data_mp4_s
59 {
60     u64     i_offset; /* absolute position of this chunk in the file */
61     u32     i_sample_description_index; /* index for SampleEntry to use */
62     u32     i_sample_count; /* how many samples in this chunk */
63     u32     i_sample_first; /* index of the first sample in this chunk */
64
65     /* now provide way to calculate pts, dts, and offset without to 
66         much memory and with fast acces */
67
68     /* with this we can calculate dts/pts without waste memory */
69     u64     i_first_dts;
70     u32     *p_sample_count_dts;
71     u32     *p_sample_delta_dts; /* dts delta */
72
73     /* TODO if needed add pts 
74         but quickly *add* support for edts and seeking */
75     
76 } chunk_data_mp4_t;
77
78
79 /*****************************************************************************
80  * Contain all needed information for read all track with vlc
81  *****************************************************************************/
82 typedef struct track_data_mp4_s
83 {
84     int b_ok;           /* The track is usable */
85     int i_track_ID;     /* this should be unique */
86     int b_enable;       /* is the trak enable by default */
87
88     int i_cat;          /* Type of the track, VIDEO_ES, AUDIO_ES, UNKNOWN_ES  ... */
89     char        i_language[3];
90
91     /* display size only ! */
92     int         i_width;
93     int         i_height;
94  
95     /* more internal data */    
96     u64         i_timescale;  /* time scale for this track only */
97
98     /* give the next sample to read, i_chunk is to find quickly where 
99       the sample is located */
100     u32         i_sample;       /* next sample to read */
101     u32         i_chunk;        /* chunk where next sample is stored */
102     /* total count of chunk and sample */
103     u32         i_chunk_count;  
104     u32         i_sample_count;
105     
106     chunk_data_mp4_t    *chunk; /* always defined  for each chunk */
107     
108     /* sample size, p_sample_size defined only if i_sample_size == 0 
109         else i_sample_size is size for all sample */
110     u32         i_sample_size;
111     u32         *p_sample_size; /* XXX perhaps add file offset if take 
112                                     too much time to do sumations each time*/
113     
114     es_descriptor_t *p_es; /* vlc es for this track */
115
116     MP4_Box_t *p_stbl;  /* will contain all timing information */
117     MP4_Box_t *p_stsd;  /* will contain all data to initialize decoder */
118     
119     MP4_Box_t *p_sample; /* actual SampleEntry to make life simpler */
120 } track_data_mp4_t;
121
122
123 /*****************************************************************************
124  *
125  *****************************************************************************/
126 typedef struct demux_data_mp4_s
127 {
128
129     MP4_Box_t   box_root;       /* container for the hole file */
130
131     mtime_t     i_pcr;
132     
133     u64         i_time;         /* time position of the presentation in movie timescale */
134     u64         i_timescale;    /* movie time scale */
135     
136     int i_tracks;               /* number of track */  
137     track_data_mp4_t *track; /* array of track */
138     
139   
140 } demux_data_mp4_t;
141
142 static inline u64 MP4_GetTrackPos( track_data_mp4_t *p_track )
143 {
144     int i_sample;
145     u64 i_pos;
146
147
148     i_pos = p_track->chunk[p_track->i_chunk].i_offset;
149
150     if( p_track->i_sample_size )
151     {
152         i_pos += ( p_track->i_sample - 
153                         p_track->chunk[p_track->i_chunk].i_sample_first ) *
154                                 p_track->i_sample_size;
155     }
156     else
157     {
158         for( i_sample = p_track->chunk[p_track->i_chunk].i_sample_first; 
159                 i_sample < p_track->i_sample; i_sample++ )
160         {
161             i_pos += p_track->p_sample_size[i_sample];
162         }
163
164     }
165     return( i_pos );
166 }
167
168 /* Return time in ┬Ás of a track */
169 static inline mtime_t MP4_GetTrackPTS( track_data_mp4_t *p_track )
170 {
171     int i_sample;
172     int i_index;
173     u64 i_dts;
174     
175     i_sample = p_track->i_sample - p_track->chunk[p_track->i_chunk].i_sample_first;
176     i_dts = p_track->chunk[p_track->i_chunk].i_first_dts;
177     i_index = 0;
178     while( i_sample > 0 )
179     {
180         if( i_sample > p_track->chunk[p_track->i_chunk].p_sample_count_dts[i_index] )
181         {
182             i_dts += p_track->chunk[p_track->i_chunk].p_sample_count_dts[i_index] * 
183                         p_track->chunk[p_track->i_chunk].p_sample_delta_dts[i_index];
184             i_sample -= p_track->chunk[p_track->i_chunk].p_sample_count_dts[i_index];
185             i_index++;
186         }
187         else
188         {
189             i_dts += i_sample * 
190                         p_track->chunk[p_track->i_chunk].p_sample_delta_dts[i_index];
191             i_sample = 0;
192             break;
193         }
194     }
195     return( (mtime_t)( 
196                 (mtime_t)1000000 *
197                 (mtime_t)i_dts / 
198                 (mtime_t)p_track->i_timescale ) );
199 }
200
201 static inline mtime_t MP4_GetMoviePTS(demux_data_mp4_t *p_demux )
202 {
203     return( (mtime_t)(
204                 (mtime_t)1000000 *
205                 (mtime_t)p_demux->i_time /
206                 (mtime_t)p_demux->i_timescale )
207           );
208 }