Mercurial > mplayer.hg
annotate DOCS/tech/mpcf.txt @ 12117:e1e5e2124dae
minor changes
rename b -> vb, so 'v' is the vlc, 'b' is simply a series of bytes and 'vb' is the length as vlc + the bytes
encode the fourcc & language code as v instead of vb, this is much simpler in practice, at least in lavf as the fourcc is an int there
author | michael |
---|---|
date | Sun, 04 Apr 2004 22:40:48 +0000 |
parents | a34dc5a369ca |
children | b8fea9441d02 |
rev | line source |
---|---|
12082 | 1 NUT Open Container Format DRAFT 20040330 |
10817 | 2 ---------------------------------------- |
9294 | 3 |
4 | |
5 | |
6 Intro: | |
7 | |
8 Features / goals: | |
9 (supported by the format, not necessary by a specific implementation) | |
10 | |
11 Simple | |
12 use the same encoding for nearly all fields | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
13 simple decoding, so slow cpus (and embedded systems) can handle it |
9294 | 14 Extendible |
15 no limit for the possible values for all fields (using universal vlc) | |
16 allow adding of new headers in the future | |
17 allow adding more fields at the end of headers | |
18 Compact | |
19 ~0.2% overhead, for normal bitrates | |
20 index is <10kb per hour (1 keyframe every 3sec) | |
10831 | 21 a usual header for a file is about 100bytes (audio + video headers together) |
12082 | 22 a packet header is about ~1-8 bytes |
9294 | 23 Error resistant |
24 seeking / playback without an index | |
25 headers & index can be repeated | |
26 checksums to allow quick redownloading of damaged parts | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
27 damaged files can be played back with minimal data lost and fast |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
28 resyncing times |
9294 | 29 |
30 | |
31 | |
32 Definitions: | |
33 | |
34 MUST the specific part must be done to conform to this standard | |
35 SHOULD its recommanded to be done that way but its not strictly required | |
36 | |
37 | |
38 | |
39 Syntax: | |
40 | |
9295 | 41 Type definitions: |
42 v | |
43 value=0 | |
44 do{ | |
45 more_data u(1) | |
46 data u(7) | |
47 value= 128*value + data | |
48 }while(more_data) | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
49 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
50 s |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
51 temp v |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
52 temp++ |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
53 if(temp&1) value= -(temp>>1) |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
54 else value= (temp>>1) |
9323 | 55 |
56 b (binary data or string) | |
57 for(i=0; i<length; i++){ | |
58 data[i] u(8) | |
9295 | 59 } |
9335
de287fe94511
lang & country codes from ISO & utf8 requirement (ideas from Tobias Diedrich <td at sim dot uni-hannover dot de>
michael
parents:
9325
diff
changeset
|
60 Note: strings MUST be encoded in utf8 |
9295 | 61 |
12117 | 62 vb |
63 length v | |
64 value b | |
65 | |
10824 | 66 f(x) n fixed bits in big endian order |
9295 | 67 u(x) unsigned number encoded in x bits in MSB first order |
68 | |
69 | |
70 Bitstream syntax: | |
9294 | 71 packet header |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
72 forward ptr v |
12082 | 73 backward ptr v |
9294 | 74 |
75 align_byte | |
76 while(not byte aligned) | |
77 one f(1) | |
78 | |
79 reserved_bytes | |
80 for(i=0; i<forward_ptr - length_of_non_reserved; i++) | |
81 reserved u(8) | |
10824 | 82 a decoder MUST ignore any reserved bytes |
83 a encoder MUST NOT write any reserved bytes, as this would make it | |
84 inpossible to add new fields at the end of packets in the future in | |
85 a compatible way | |
86 | |
9294 | 87 main header: |
10831 | 88 main_startcode f(64) |
9294 | 89 packet header |
90 version v | |
91 stream_count v | |
12082 | 92 checksum_threshold v |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
93 for(i=0; i<256; ){ |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
94 tmp_flag v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
95 tmp_stream v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
96 tmp_mul v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
97 tmp_size v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
98 count v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
99 for(j=0; j<count; j++, i++){ |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
100 flags[i]= tmp_flag; |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
101 stream_id_plus1[i]= tmp_stream; |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
102 data_size_mul[i]= tmp_mul; |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
103 data_size_lsb[i]= tmp_size; |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
104 if(++tmp_size >= tmp_mul){ |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
105 tmp_size=0; |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
106 tmp_stream++; |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
107 } |
12082 | 108 } |
109 } | |
9294 | 110 reserved_bytes |
111 checksum u(32) | |
112 | |
113 stream_header: | |
10831 | 114 stream_startcode f(64) |
9294 | 115 packet_header |
116 stream_id v | |
117 stream_class v | |
12117 | 118 fourcc v |
9294 | 119 average_bitrate v |
12117 | 120 language_code v |
9297 | 121 time_base_nom v |
122 time_base_denom v | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
123 msb_timestamp_shift v |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
124 initial_timestamp_predictor v(3) |
12082 | 125 initial_data_size_predictor v(2) |
9294 | 126 fixed_fps u(1) |
9347
97888c25ae60
changing name to "nut" for now, we can change it again if we agree on something else
michael
parents:
9335
diff
changeset
|
127 index_flag u(1) |
9356 | 128 reserved u(6) |
9357
21347f49e8d8
supprting various codec specific/private headers for different APIs (ideas by arpi/alex/fabian)
michael
parents:
9356
diff
changeset
|
129 for(;;){ |
9361 | 130 codec_specific_data_type v |
131 if(codec_specific_data_type==0) break; | |
12117 | 132 codec_specific_data vb |
9357
21347f49e8d8
supprting various codec specific/private headers for different APIs (ideas by arpi/alex/fabian)
michael
parents:
9356
diff
changeset
|
133 } |
9294 | 134 |
135 video_stream_header: | |
136 stream_header | |
137 width v | |
138 height v | |
139 sample_width v | |
140 sample_height v | |
141 colorspace_type v | |
142 reserved_bytes | |
143 checksum u(32) | |
144 | |
145 audio_stream_header: | |
146 stream_header | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
147 samplerate_mul v |
9294 | 148 channel_count v |
149 reserved_bytes | |
150 checksum u(32) | |
9420 | 151 |
12082 | 152 |
9294 | 153 frame |
12082 | 154 if(frame_type == 2){ |
155 frame_type2_startcode f(64) | |
9294 | 156 } |
12082 | 157 frame_code f(8) |
158 if(flags[frame_code]&1){ | |
159 packet header | |
160 } | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
161 if(stream_id_plus1[frame_code]==0){ |
12082 | 162 stream_id v |
163 } | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
164 if(flags[frame_code]&16){ |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
165 if(flags[frame_code]&4){ |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
166 timestamp v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
167 }else{ |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
168 lsb_timestamp v |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
169 } |
9420 | 170 } |
12082 | 171 if(flags[frame_code]&2){ |
172 data_size_msb v | |
173 } | |
174 data | |
175 if(checksum_threshold < frame_type) | |
9312 | 176 frame_checksum u(32) |
12082 | 177 |
9294 | 178 Index: |
10831 | 179 index_startcode f(64) |
9294 | 180 packet header |
181 stream_id v | |
182 index_length v | |
183 for(i=0; i<index_length; i++){ | |
184 index_timestamp v | |
185 index_position v | |
186 } | |
9310 | 187 reserved_bytes |
9294 | 188 checksum u(32) |
189 | |
9310 | 190 info_packet: (optional) |
10831 | 191 info_startcode f(64) |
9294 | 192 packet header |
9323 | 193 for(;;){ |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
194 id v |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
195 if(id==0) break |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
196 name= info_table[id][0] |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
197 type= info_table[id][1] |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
198 if(type==NULL) |
12117 | 199 type vb |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
200 if(name==NULL) |
12117 | 201 name vb |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
202 if(type=="v") |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
203 value v |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
204 else |
12117 | 205 value vb |
9323 | 206 } |
9310 | 207 reserved_bytes |
9294 | 208 checksum u(32) |
9323 | 209 |
210 | |
9294 | 211 forward_ptr |
212 backward_ptr | |
213 pointer to the next / previous packet | |
9323 | 214 pointers are relative and backward pointer is implicitelly negative |
9294 | 215 Note: a frame with 0 bytes means that its skiped |
9323 | 216 Note: the forward pointer is equal to the size of this packet including |
217 the header | |
218 the backward pointer is equal to the size of the previous packet | |
219 Example: | |
220 0 | |
221 size1 (size of frame1 including header) | |
222 frame1 | |
223 | |
224 size1 | |
225 size2 | |
226 frame2 | |
227 | |
228 size2 | |
229 size3 | |
230 frame3 | |
231 | |
232 | |
233 *_startcode | |
234 the first bit is allways set | |
9294 | 235 |
236 version | |
237 0 for now | |
12082 | 238 |
9294 | 239 stream_id |
240 Note: streams with a lower relative class MUST have a lower relative id | |
241 so a stream with class 0 MUST allways have a id which is lower then any | |
242 stream with class > 0 | |
9295 | 243 streams should use low ids |
9294 | 244 |
245 stream_class | |
246 0 video | |
247 32 audio | |
248 64 subtiles | |
249 Note the remaining values are reserved and MUST NOT be used | |
9312 | 250 a decoder MUST ignore streams with reserved classes |
9294 | 251 |
252 fourcc | |
253 identification for the codec | |
9323 | 254 example: "H264" |
10817 | 255 MUST contain 2 or 4 bytes, note, this might be increased in the future |
256 if needed | |
257 | |
9294 | 258 language_code |
9335
de287fe94511
lang & country codes from ISO & utf8 requirement (ideas from Tobias Diedrich <td at sim dot uni-hannover dot de>
michael
parents:
9325
diff
changeset
|
259 ISO 639 and ISO 3166 for language/country code |
9325 | 260 something like "usen" (US english), can be 0 |
9294 | 261 if unknown |
9335
de287fe94511
lang & country codes from ISO & utf8 requirement (ideas from Tobias Diedrich <td at sim dot uni-hannover dot de>
michael
parents:
9325
diff
changeset
|
262 see http://www.loc.gov/standards/iso639-2/englangn.html |
de287fe94511
lang & country codes from ISO & utf8 requirement (ideas from Tobias Diedrich <td at sim dot uni-hannover dot de>
michael
parents:
9325
diff
changeset
|
263 and http://www.din.de/gremien/nas/nabd/iso3166ma/codlstp1/en_listp1.html |
9294 | 264 |
9297 | 265 time_base_nom / time_base_denom = time_base |
9294 | 266 the number of timer ticks per second, this MUST be equal to the fps |
267 if the fixed_fps is 1 | |
9297 | 268 time_base_denom MUST not be 0 |
269 time_base_nom and time_base_denom MUST be relative prime | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
270 time_base_nom MUST be < 2^16 |
9297 | 271 examples: |
272 fps time_base_nom time_base_denom | |
273 30 30 1 | |
274 29.97 30000 1001 | |
275 23.976 24000 1001 | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
276 sample_rate sample_rate_mul time_base_nom time_base_denom |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
277 44100 1 44100 1 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
278 44100 64 11025 16 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
279 48000 1024 375 8 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
280 Note: the advantage to using a large sample_rate_mul is that the |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
281 timestamps need fewer bits |
9294 | 282 |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
283 msb_timestamp_shift |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
284 amount of bits msb_timestamp is shifted left before adding lsb_timestamp |
9294 | 285 MUST be <16 |
286 | |
287 fixed_fps | |
288 1 indicates that the fps is fixed | |
289 | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
290 index_flag |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
291 1 indicates that this file has an index |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
292 Note, all files SHOULD have an index at the end except, (realtime) streams |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
293 Note, all streams SHOULD have an index |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
294 |
9357
21347f49e8d8
supprting various codec specific/private headers for different APIs (ideas by arpi/alex/fabian)
michael
parents:
9356
diff
changeset
|
295 codec_specific_data_type |
10817 | 296 0 none/end |
9361 | 297 1 native |
298 2 bitmapinfoheader | |
299 3 waveformatex | |
300 4 imagedesc | |
301 5 sounddesc | |
9357
21347f49e8d8
supprting various codec specific/private headers for different APIs (ideas by arpi/alex/fabian)
michael
parents:
9356
diff
changeset
|
302 "native", means a simple api & container independanet storage form, |
21347f49e8d8
supprting various codec specific/private headers for different APIs (ideas by arpi/alex/fabian)
michael
parents:
9356
diff
changeset
|
303 for example some mpeg4-es headers |
21347f49e8d8
supprting various codec specific/private headers for different APIs (ideas by arpi/alex/fabian)
michael
parents:
9356
diff
changeset
|
304 |
9356 | 305 codec_specific_data |
306 private global data for a codec (could be huffman tables or ...) | |
12082 | 307 |
308 frame_code | |
309 the meaning of this byte is stored in the main header | |
310 the value 78 ('N') is forbidden to ensure that the byte is always | |
311 different from the first byte of any startcode | |
9420 | 312 |
12082 | 313 flags[frame_code] |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
314 the bits of the flags from MSB to LSB are KKTTTDP |
12082 | 315 P is 1 for type 1 and 2 packets, 0 for type 0 packets |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
316 TTT is the timestamp_code, 000,001,010 use the last timestamp + the |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
317 first, second and third last unique timestamp difference, so if |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
318 the timestamp differences, are +3,+1,+2,+2,+1 then last diff is |
12082 | 319 +1, second is +2 and third is +3 |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
320 100,101 mean that the lsb or full timestamp is coded |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
321 if TTT is 100, then the timestamp is calculated by |
12082 | 322 mask = (1<<msb_timestamp_shift)-1; |
323 delta= last_timestamp - mask/2 | |
324 timestamp= ((timestamp_lsb-delta)&mask) + delta | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
325 TTT must be 100 or 101 if the packet_type is not 0 |
12082 | 326 the last timestamp differences are reset to the default values |
327 from the stream header if a packet of type not 0 in encountered | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
328 if D is 1 then data_size_msb is coded, otherwise its 0 |
12082 | 329 KK is the keyframe_type |
330 00-> no keyframe, | |
331 01-> keyframe, | |
332 10-> equal to last of the same stream, | |
333 11-> opposite from last of the same stream | |
334 KK must be 00 or 01 if the packet_type is not 0 | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
335 flags=1 can be used to mark illegal frame_code bytes |
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
336 frame_code=78 must have flags=1 |
9420 | 337 |
12082 | 338 frame_type |
339 0 is indicated by (flags[frame_code]&1)==0 | |
340 1 is indicated by (flags[frame_code]&1)==1 && !startcode | |
341 2 is indicated by (flags[frame_code]&1)==1 && startcode | |
342 there SHOULD not be more then 0.5 seconds or 16kbyte of type 0 frames | |
343 wihout a intervening frame of different frame_type | |
12110
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
344 * type 2 frames MUST be decodeable independantly of any other frames |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
345 this means they MUST be keyframes and they MUST use a full timestamp |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
346 * type 1 frames MUST not depend(1) upon any other frames, this means, |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
347 they MUST use a full timestamp |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
348 * type 0 frames MUST not depend(1) upon frames prior to the last type |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
349 1/2 frames |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
350 depend(1) means dependancy on the container level (NUT) not dependancy |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
351 on the codec level |
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
352 |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
353 stream_id_plus1[frame_code] |
12082 | 354 must be <250 |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
355 if its 0 then the stream_id is coded in the frame |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
356 |
12082 | 357 data_size_mul[frame_code] |
358 must be <250 | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
359 |
12082 | 360 data_size_lsb[frame_code] |
361 must be <250 | |
362 | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
363 data_size |
12082 | 364 if(data_size_lsb == data_size_mul) |
365 data_size= last; | |
366 else if(data_size_lsb == data_size_mul+1) | |
367 data_size= next last; | |
368 else if(data_size_lsb < data_size_mul) | |
369 data_size= data_size_lsb + data_size_msb*data_size_mul; | |
370 else reserved | |
371 last and next last are reset to the values stored in the stream header | |
372 if an frame with type > 0 is encountered | |
373 | |
9294 | 374 lsb_timestamp |
12082 | 375 least significant bits of the timestamp in time_base precission |
9294 | 376 Example: IBBP display order |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
377 keyframe timestamp=0 -> timestamp=0 |
9294 | 378 frame lsb_timestamp=3 -> timestamp=3 |
379 frame lsb_timestamp=1 -> timestamp=1 | |
380 frame lsb_timestamp=2 -> timestamp=2 | |
381 ... | |
12084
68baf8877c07
reversing the change to the forw/backw pointers, its somewhat simpler to update it if the forward pointer is first
michael
parents:
12082
diff
changeset
|
382 keyframe msb_timestamp=257 -> timestamp=257 |
12082 | 383 frame lsb_timestamp=255->timestamp=255 |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
384 frame lsb_timestamp=0 -> timestamp=256 |
9294 | 385 frame lsb_timestamp=4 -> timestamp=260 |
386 frame lsb_timestamp=2 -> timestamp=258 | |
387 frame lsb_timestamp=3 -> timestamp=259 | |
12110
a34dc5a369ca
restrictions to ensure that O(log n) seeking and error recovery is possible
michael
parents:
12084
diff
changeset
|
388 all timestamps of keyframes of a single stream MUST be monotone |
9294 | 389 |
390 width/height | |
391 MUST be set to the coded width/height | |
392 | |
393 sample_width/sample_height (aspect ratio) | |
394 sample_width is the horizontal distance between samples | |
395 sample_width and sample_height MUST be relative prime if not zero | |
396 MUST be 0 if unknown | |
397 | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
398 colorspace_type |
10166 | 399 0 unknown |
400 1 ITU Rec 624 / ITU Rec 601 Y range: 16..235 Cb/Cr range: 16..240 | |
401 2 ITU Rec 709 Y range: 16..235 Cb/Cr range: 16..240 | |
402 17 ITU Rec 624 / ITU Rec 601 Y range: 0..255 Cb/Cr range: 0..255 | |
403 18 ITU Rec 709 Y range: 0..255 Cb/Cr range: 0..255 | |
404 | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
405 samplerate_mul |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
406 the number of samples per second in one time_base unit |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
407 samplerate = time_base*samplerate_mul |
9294 | 408 |
9311
4b04416ada91
zero_bit for normal frames, so we can distinguish them from other packets
michael
parents:
9310
diff
changeset
|
409 zero_bit |
4b04416ada91
zero_bit for normal frames, so we can distinguish them from other packets
michael
parents:
9310
diff
changeset
|
410 MUST be 0, its there to distinguish non keyframes from other packets, |
4b04416ada91
zero_bit for normal frames, so we can distinguish them from other packets
michael
parents:
9310
diff
changeset
|
411 Note: all packets have a 64-bit startcode except non-keyframes to reduce |
4b04416ada91
zero_bit for normal frames, so we can distinguish them from other packets
michael
parents:
9310
diff
changeset
|
412 their size, and all startcodes start with a 1 bit |
9294 | 413 |
414 checksum | |
9307
ec18ad315bbe
10l (copy & pasting the generator poly for crc32 from ogg was a bad idea...)
michael
parents:
9299
diff
changeset
|
415 crc32 checksum using the generator polynomial 0x104c11db7 (same as ogg) |
9294 | 416 |
417 frame_checksum | |
418 identical to checksum, but instead of covering just the current | |
12082 | 419 packet, it covers all frames since the last frame_checksum |
9294 | 420 |
421 index_timestamp | |
422 value in time_base precission, relative to the last index_timestamp | |
423 | |
424 index_position | |
425 position in bytes of the first byte of the keyframe header, relative | |
426 to the last index_position | |
427 | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
428 id |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
429 the id of the type/name pair, so its more compact |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
430 0 means end |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
431 |
9323 | 432 type |
9347
97888c25ae60
changing name to "nut" for now, we can change it again if we agree on something else
michael
parents:
9335
diff
changeset
|
433 for example: "UTF8" -> String or "JPEG" -> jpeg image |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
434 Note: nonstandard fields should be prefixed by "X-" |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
435 Note: MUST be less than 6 byte long (might be increased to 64 later) |
9323 | 436 |
9295 | 437 name |
438 the name of the info entry, valid names are | |
10873 | 439 "TotalTime" total length of the stream in msecs |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
440 "StreamId" the stream(s) to which the info packet applies |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
441 "StartTimestamp" |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
442 "EndTimestamp" the time range in msecs to which the info applies |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
443 "SegmentId" a unique id for the streams + time specified |
9347
97888c25ae60
changing name to "nut" for now, we can change it again if we agree on something else
michael
parents:
9335
diff
changeset
|
444 "Author" |
97888c25ae60
changing name to "nut" for now, we can change it again if we agree on something else
michael
parents:
9335
diff
changeset
|
445 "Description" |
97888c25ae60
changing name to "nut" for now, we can change it again if we agree on something else
michael
parents:
9335
diff
changeset
|
446 "Copyright" |
9369 | 447 "Encoder" the name & version of the software used for encoding |
9347
97888c25ae60
changing name to "nut" for now, we can change it again if we agree on something else
michael
parents:
9335
diff
changeset
|
448 "Title" |
9373 | 449 "Cover" an image of the (cd,dvd,vhs,..) cover (preferable PNG or JPEG) |
9350 | 450 "Source" "DVD", "VCD", "CD", "MD", "FM radio", "VHS", "TV", |
451 "LD" | |
9373 | 452 Optional: appended PAL,NTSC,SECAM, ... in parentheses |
9350 | 453 "CaptureDevice" "BT878", "BT848", "webcam", ... (more exact names are fine too) |
454 "CreationTime" "2003-01-20 20:13:15Z", ... | |
455 (ISO 8601 format, see http://www.cl.cam.ac.uk/~mgk25/iso-time.html) | |
456 Note: dont forget the timezone | |
11975 | 457 "ReplayGain" |
9360
add934b25d6d
"X-" prefix for nonstd fields & "keywords" idea by (Andreas Hess <jaska at gmx dot net>)
michael
parents:
9357
diff
changeset
|
458 "Keywords" |
9295 | 459 Note: if someone needs some others, please tell us about them, so we can |
460 add them to the official standard (if they are sane) | |
9360
add934b25d6d
"X-" prefix for nonstd fields & "keywords" idea by (Andreas Hess <jaska at gmx dot net>)
michael
parents:
9357
diff
changeset
|
461 Note: nonstandard fields should be prefixed by "X-" |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
462 Note: MUST be less than 64 bytes long |
9295 | 463 |
464 value | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
465 value of this name/type pair |
9295 | 466 |
9310 | 467 stuffing |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
468 0x80 can be placed infront of any type v entry for stuffing |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
469 purposes |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
470 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
471 info_table[][2]={ |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
472 {NULL , NULL }, // end |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
473 {NULL , NULL }, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
474 {NULL , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
475 {NULL , "v"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
476 {NULL , "s"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
477 {"StreamId" , "v"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
478 {"SegmentId" , "v"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
479 {"StartTimestamp" , "v"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
480 {"EndTimestamp" , "v"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
481 {"Author" , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
482 {"Titel" , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
483 {"Description" , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
484 {"Copyright" , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
485 {"Encoder" , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
486 {"Keyword" , "UTF8"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
487 {"Cover" , "JPEG"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
488 {"Cover" , "PNG"}, |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
489 }; |
9294 | 490 |
491 Structure: | |
492 | |
493 the headers MUST be in exactly the following order (to simplify demuxer design) | |
494 main header | |
495 stream_header (id=0) | |
496 stream_header (id=1) | |
497 ... | |
498 stream_header (id=n) | |
499 | |
500 headers may be repated, but if they are then they MUST all be repeated together | |
501 and repeated headers MUST be identical | |
502 | |
503 headers MUST be repeated every 10sec at least ? FIXME | |
10817 | 504 headers MUST be repeated BEFORE keyframes |
9310 | 505 headers MUST be repeated at least twice (so they exist 3 times in a file) |
9295 | 506 |
9310 | 507 Index |
9580 | 508 the index can be repeated but there SHOULD be at least one for each stream at |
509 the end | |
9311
4b04416ada91
zero_bit for normal frames, so we can distinguish them from other packets
michael
parents:
9310
diff
changeset
|
510 Note: in case of realtime streaming there is no end, so no index there either |
9310 | 511 |
512 Info packets | |
513 the info_packet can be repeated, it can also contain different names & values | |
514 each time but only if allso the time is different | |
515 Info packets can be used to describe the file or some part of it (chapters) | |
516 | |
517 info packets, SHOULD be placed at the begin of the file at least | |
518 for realtime streaming info packets will normally be transmitted when they apply | |
519 for example, the current song title & artist of the currently shown music video | |
520 | |
521 Stuffing packets | |
522 can be used as a filler, for example to leave some empty space at the begin for | |
523 a copy of the index | |
524 | |
525 Unknown packets | |
526 MUST be ignored by the decoder | |
527 | |
9294 | 528 Sample code (GPL, & untested) |
529 | |
530 typedef BufferContext{ | |
531 uint8_t *buf; | |
532 uint8_t *buf_ptr; | |
533 }BufferContext; | |
534 | |
535 static inline uint64_t get_bytes(BufferContext *bc, int count){ | |
536 uint64_t val=0; | |
537 | |
538 assert(count>0 && count<9) | |
539 | |
540 for(i=0; i<count; i++){ | |
541 val <<=8; | |
542 val += *(bc->buf_ptr++); | |
543 } | |
544 | |
545 return val; | |
546 } | |
547 | |
548 static inline void put_bytes(BufferContext *bc, int count, uint64_t val){ | |
549 uint64_t val=0; | |
550 | |
551 assert(count>0 && count<9) | |
552 | |
553 for(i=count-1; i>=0; i--){ | |
554 *(bc->buf_ptr++)= val >> (8*i); | |
555 } | |
556 | |
557 return val; | |
558 } | |
559 | |
10061 | 560 static inline uint64_t get_v(BufferContext *bc){ |
9294 | 561 uint64_t val= 0; |
562 | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
563 for(; space_left(bc) > 0; ){ |
9294 | 564 int tmp= *(bc->buf_ptr++); |
565 if(tmp&0x80) | |
566 val= (val<<7) + tmp - 0x80; | |
567 else | |
9299 | 568 return (val<<7) + tmp; |
9294 | 569 } |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
570 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
571 return -1; |
9294 | 572 } |
573 | |
10061 | 574 static inline int put_v(BufferContext *bc, uint64_t val){ |
9294 | 575 int i; |
576 | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
577 if(space_left(bc) < 9) return -1; |
9294 | 578 |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
579 val &= 0x7FFFFFFFFFFFFFFFULL; // FIXME can only encode upto 63 bits currently |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
580 for(i=7; ; i+=7){ |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
581 if(val>>i == 0) break; |
9294 | 582 } |
583 | |
10827 | 584 for(i-=7; i>0; i-=7){ |
9294 | 585 *(bc->buf_ptr++)= 0x80 | (val>>i); |
586 } | |
587 *(bc->buf_ptr++)= val&0x7F; | |
9579
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
588 |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
589 return 0; |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
590 } |
89d27a306886
*signed int vlc (needs only 5 lines of code so its no increase of complexity)
michael
parents:
9422
diff
changeset
|
591 |
9294 | 592 |
593 Example stream | |
594 | |
595 main header | |
596 video_stream_header (stream 0, video jpjp, timebase 30, lsb_timestamp_length=8) | |
597 video_stream_header (stream 1 subtitle usen, timebase 30, lsb_timestamp_length=8) | |
598 video_stream_header (stream 2 subtitle atde, timebase 30, lsb_timestamp_length=8) | |
599 audio_stream_header (stream 3, audio jpjp, timebase 1 , lsb_timestamp_length=8) | |
600 audio_stream_header (stream 4, audio usen, timebase 1 , lsb_timestamp_length=8) | |
601 index (stream 0) | |
602 keyframe (stream 0, msb_timestamp=0, lsb_timestamp=0) | |
603 keyframe (stream 1, msb_timestamp=0, lsb_timestamp=0) | |
604 keyframe (stream 2, msb_timestamp=0, lsb_timestamp=0) | |
605 keyframe (stream 3, msb_timestamp=0, lsb_timestamp=0) | |
606 keyframe (stream 4, msb_timestamp=0, lsb_timestamp=0) | |
607 frame (stream 0, lsb_timestamp=1) | |
608 frame (stream 0, lsb_timestamp=2) | |
609 ... | |
610 frame (stream 0, lsb_timestamp=30) | |
611 keyframe (stream 3, msb_timestamp=0, lsb_timestamp=1) | |
612 keyframe (stream 4, msb_timestamp=0, lsb_timestamp=1) | |
613 frame (stream 0, lsb_timestamp=31) | |
614 frame (stream 0, lsb_timestamp=32) | |
615 ... | |
616 frame (stream 0, lsb_timestamp=60) | |
617 frame (stream 1, lsb_timestamp=60) | |
618 frame (stream 2, lsb_timestamp=60) | |
619 keyframe (stream 3, msb_timestamp=0, lsb_timestamp=2) | |
620 keyframe (stream 4, msb_timestamp=0, lsb_timestamp=2) | |
621 frame (stream 0, lsb_timestamp=61) | |
622 frame (stream 0, lsb_timestamp=62) | |
623 ... | |
624 main header | |
625 video_stream_header (stream 0, video jpjp, timebase 30, lsb_timestamp_length=8) | |
626 video_stream_header (stream 1 subtitle usen, timebase 30, lsb_timestamp_length=8) | |
627 video_stream_header (stream 2 subtitle atde, timebase 30, lsb_timestamp_length=8) | |
628 audio_stream_header (stream 3, audio jpjp, timebase 1 , lsb_timestamp_length=8) | |
629 audio_stream_header (stream 4, audio usen, timebase 1 , lsb_timestamp_length=8) | |
630 frame (stream 0, lsb_timestamp=255) | |
631 frame (stream 0, msb_timestamp=1 lsb_timestamp=0) | |
632 frame (stream 0, lsb_timestamp=1) | |
633 frame (stream 0, lsb_timestamp=2) | |
634 frame (stream 1, msb_timestamp=1 lsb_timestamp=2) | |
635 frame (stream 2, msb_timestamp=1 lsb_timestamp=2) | |
636 frame (stream 0, lsb_timestamp=3) | |
637 frame (stream 0, lsb_timestamp=4) | |
638 ... | |
639 keyframe (stream 3, msb_timestamp=0, lsb_timestamp=9) | |
640 keyframe (stream 4, msb_timestamp=0, lsb_timestamp=9) | |
641 main header | |
642 video_stream_header (stream 0, video jpjp, timebase 30, lsb_timestamp_length=8) | |
643 video_stream_header (stream 1 subtitle usen, timebase 30, lsb_timestamp_length=8) | |
644 video_stream_header (stream 2 subtitle atde, timebase 30, lsb_timestamp_length=8) | |
645 audio_stream_header (stream 3, audio jpjp, timebase 1 , lsb_timestamp_length=8) | |
646 audio_stream_header (stream 4, audio usen, timebase 1 , lsb_timestamp_length=8) | |
647 index (stream 0) | |
10158
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
648 |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
649 Authors |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
650 |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
651 Folks from MPlayer Developers Mailinglist (http://www.mplayehrq.hu/). |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
652 Authors in ABC-order: (FIXME! Tell us if we left you out) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
653 Beregszaszi, Alex (alex@fsn.hu) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
654 Bunkus, Moritz (moritz@bunkus.org) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
655 Diedrich, Tobias (td@sim.uni-hannover.de) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
656 Franz, Fabian (FabianFranz@gmx.de) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
657 Gereoffy, Arpad (arpi@thot.banki.hu) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
658 Hess, Andreas (jaska@gmx.net) |
93e5428d0b3e
some changes (michael: is the colorspace_type field needed?)
alex
parents:
10061
diff
changeset
|
659 Niedermayer, Michael (michaelni@gmx.at) |