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