Mercurial > libavformat.hg
comparison rmenc.c @ 2103:95139f2053a9 libavformat
split rm muxer and demuxer in their own files
author | aurel |
---|---|
date | Wed, 30 May 2007 09:44:16 +0000 |
parents | rm.c@8b400be65542 |
children | d52c718e83f9 |
comparison
equal
deleted
inserted
replaced
2102:ea6094e10af8 | 2103:95139f2053a9 |
---|---|
1 /* | |
2 * "Real" compatible muxer. | |
3 * Copyright (c) 2000, 2001 Fabrice Bellard. | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 #include "avformat.h" | |
22 #include "rm.h" | |
23 | |
24 /* in ms */ | |
25 #define BUFFER_DURATION 0 | |
26 | |
27 | |
28 static void put_str(ByteIOContext *s, const char *tag) | |
29 { | |
30 put_be16(s,strlen(tag)); | |
31 while (*tag) { | |
32 put_byte(s, *tag++); | |
33 } | |
34 } | |
35 | |
36 static void put_str8(ByteIOContext *s, const char *tag) | |
37 { | |
38 put_byte(s, strlen(tag)); | |
39 while (*tag) { | |
40 put_byte(s, *tag++); | |
41 } | |
42 } | |
43 | |
44 static void rv10_write_header(AVFormatContext *ctx, | |
45 int data_size, int index_pos) | |
46 { | |
47 RMContext *rm = ctx->priv_data; | |
48 ByteIOContext *s = &ctx->pb; | |
49 StreamInfo *stream; | |
50 unsigned char *data_offset_ptr, *start_ptr; | |
51 const char *desc, *mimetype; | |
52 int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i; | |
53 int bit_rate, v, duration, flags, data_pos; | |
54 | |
55 start_ptr = s->buf_ptr; | |
56 | |
57 put_tag(s, ".RMF"); | |
58 put_be32(s,18); /* header size */ | |
59 put_be16(s,0); | |
60 put_be32(s,0); | |
61 put_be32(s,4 + ctx->nb_streams); /* num headers */ | |
62 | |
63 put_tag(s,"PROP"); | |
64 put_be32(s, 50); | |
65 put_be16(s, 0); | |
66 packet_max_size = 0; | |
67 packet_total_size = 0; | |
68 nb_packets = 0; | |
69 bit_rate = 0; | |
70 duration = 0; | |
71 for(i=0;i<ctx->nb_streams;i++) { | |
72 StreamInfo *stream = &rm->streams[i]; | |
73 bit_rate += stream->bit_rate; | |
74 if (stream->packet_max_size > packet_max_size) | |
75 packet_max_size = stream->packet_max_size; | |
76 nb_packets += stream->nb_packets; | |
77 packet_total_size += stream->packet_total_size; | |
78 /* select maximum duration */ | |
79 v = (int) (1000.0 * (float)stream->total_frames / stream->frame_rate); | |
80 if (v > duration) | |
81 duration = v; | |
82 } | |
83 put_be32(s, bit_rate); /* max bit rate */ | |
84 put_be32(s, bit_rate); /* avg bit rate */ | |
85 put_be32(s, packet_max_size); /* max packet size */ | |
86 if (nb_packets > 0) | |
87 packet_avg_size = packet_total_size / nb_packets; | |
88 else | |
89 packet_avg_size = 0; | |
90 put_be32(s, packet_avg_size); /* avg packet size */ | |
91 put_be32(s, nb_packets); /* num packets */ | |
92 put_be32(s, duration); /* duration */ | |
93 put_be32(s, BUFFER_DURATION); /* preroll */ | |
94 put_be32(s, index_pos); /* index offset */ | |
95 /* computation of data the data offset */ | |
96 data_offset_ptr = s->buf_ptr; | |
97 put_be32(s, 0); /* data offset : will be patched after */ | |
98 put_be16(s, ctx->nb_streams); /* num streams */ | |
99 flags = 1 | 2; /* save allowed & perfect play */ | |
100 if (url_is_streamed(s)) | |
101 flags |= 4; /* live broadcast */ | |
102 put_be16(s, flags); | |
103 | |
104 /* comments */ | |
105 | |
106 put_tag(s,"CONT"); | |
107 size = strlen(ctx->title) + strlen(ctx->author) + strlen(ctx->copyright) + | |
108 strlen(ctx->comment) + 4 * 2 + 10; | |
109 put_be32(s,size); | |
110 put_be16(s,0); | |
111 put_str(s, ctx->title); | |
112 put_str(s, ctx->author); | |
113 put_str(s, ctx->copyright); | |
114 put_str(s, ctx->comment); | |
115 | |
116 for(i=0;i<ctx->nb_streams;i++) { | |
117 int codec_data_size; | |
118 | |
119 stream = &rm->streams[i]; | |
120 | |
121 if (stream->enc->codec_type == CODEC_TYPE_AUDIO) { | |
122 desc = "The Audio Stream"; | |
123 mimetype = "audio/x-pn-realaudio"; | |
124 codec_data_size = 73; | |
125 } else { | |
126 desc = "The Video Stream"; | |
127 mimetype = "video/x-pn-realvideo"; | |
128 codec_data_size = 34; | |
129 } | |
130 | |
131 put_tag(s,"MDPR"); | |
132 size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size; | |
133 put_be32(s, size); | |
134 put_be16(s, 0); | |
135 | |
136 put_be16(s, i); /* stream number */ | |
137 put_be32(s, stream->bit_rate); /* max bit rate */ | |
138 put_be32(s, stream->bit_rate); /* avg bit rate */ | |
139 put_be32(s, stream->packet_max_size); /* max packet size */ | |
140 if (stream->nb_packets > 0) | |
141 packet_avg_size = stream->packet_total_size / | |
142 stream->nb_packets; | |
143 else | |
144 packet_avg_size = 0; | |
145 put_be32(s, packet_avg_size); /* avg packet size */ | |
146 put_be32(s, 0); /* start time */ | |
147 put_be32(s, BUFFER_DURATION); /* preroll */ | |
148 /* duration */ | |
149 if (url_is_streamed(s) || !stream->total_frames) | |
150 put_be32(s, (int)(3600 * 1000)); | |
151 else | |
152 put_be32(s, (int)(stream->total_frames * 1000 / stream->frame_rate)); | |
153 put_str8(s, desc); | |
154 put_str8(s, mimetype); | |
155 put_be32(s, codec_data_size); | |
156 | |
157 if (stream->enc->codec_type == CODEC_TYPE_AUDIO) { | |
158 int coded_frame_size, fscode, sample_rate; | |
159 sample_rate = stream->enc->sample_rate; | |
160 coded_frame_size = (stream->enc->bit_rate * | |
161 stream->enc->frame_size) / (8 * sample_rate); | |
162 /* audio codec info */ | |
163 put_tag(s, ".ra"); | |
164 put_byte(s, 0xfd); | |
165 put_be32(s, 0x00040000); /* version */ | |
166 put_tag(s, ".ra4"); | |
167 put_be32(s, 0x01b53530); /* stream length */ | |
168 put_be16(s, 4); /* unknown */ | |
169 put_be32(s, 0x39); /* header size */ | |
170 | |
171 switch(sample_rate) { | |
172 case 48000: | |
173 case 24000: | |
174 case 12000: | |
175 fscode = 1; | |
176 break; | |
177 default: | |
178 case 44100: | |
179 case 22050: | |
180 case 11025: | |
181 fscode = 2; | |
182 break; | |
183 case 32000: | |
184 case 16000: | |
185 case 8000: | |
186 fscode = 3; | |
187 } | |
188 put_be16(s, fscode); /* codec additional info, for AC3, seems | |
189 to be a frequency code */ | |
190 /* special hack to compensate rounding errors... */ | |
191 if (coded_frame_size == 557) | |
192 coded_frame_size--; | |
193 put_be32(s, coded_frame_size); /* frame length */ | |
194 put_be32(s, 0x51540); /* unknown */ | |
195 put_be32(s, 0x249f0); /* unknown */ | |
196 put_be32(s, 0x249f0); /* unknown */ | |
197 put_be16(s, 0x01); | |
198 /* frame length : seems to be very important */ | |
199 put_be16(s, coded_frame_size); | |
200 put_be32(s, 0); /* unknown */ | |
201 put_be16(s, stream->enc->sample_rate); /* sample rate */ | |
202 put_be32(s, 0x10); /* unknown */ | |
203 put_be16(s, stream->enc->channels); | |
204 put_str8(s, "Int0"); /* codec name */ | |
205 put_str8(s, "dnet"); /* codec name */ | |
206 put_be16(s, 0); /* title length */ | |
207 put_be16(s, 0); /* author length */ | |
208 put_be16(s, 0); /* copyright length */ | |
209 put_byte(s, 0); /* end of header */ | |
210 } else { | |
211 /* video codec info */ | |
212 put_be32(s,34); /* size */ | |
213 if(stream->enc->codec_id == CODEC_ID_RV10) | |
214 put_tag(s,"VIDORV10"); | |
215 else | |
216 put_tag(s,"VIDORV20"); | |
217 put_be16(s, stream->enc->width); | |
218 put_be16(s, stream->enc->height); | |
219 put_be16(s, (int) stream->frame_rate); /* frames per seconds ? */ | |
220 put_be32(s,0); /* unknown meaning */ | |
221 put_be16(s, (int) stream->frame_rate); /* unknown meaning */ | |
222 put_be32(s,0); /* unknown meaning */ | |
223 put_be16(s, 8); /* unknown meaning */ | |
224 /* Seems to be the codec version: only use basic H263. The next | |
225 versions seems to add a diffential DC coding as in | |
226 MPEG... nothing new under the sun */ | |
227 if(stream->enc->codec_id == CODEC_ID_RV10) | |
228 put_be32(s,0x10000000); | |
229 else | |
230 put_be32(s,0x20103001); | |
231 //put_be32(s,0x10003000); | |
232 } | |
233 } | |
234 | |
235 /* patch data offset field */ | |
236 data_pos = s->buf_ptr - start_ptr; | |
237 rm->data_pos = data_pos; | |
238 data_offset_ptr[0] = data_pos >> 24; | |
239 data_offset_ptr[1] = data_pos >> 16; | |
240 data_offset_ptr[2] = data_pos >> 8; | |
241 data_offset_ptr[3] = data_pos; | |
242 | |
243 /* data stream */ | |
244 put_tag(s,"DATA"); | |
245 put_be32(s,data_size + 10 + 8); | |
246 put_be16(s,0); | |
247 | |
248 put_be32(s, nb_packets); /* number of packets */ | |
249 put_be32(s,0); /* next data header */ | |
250 } | |
251 | |
252 static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream, | |
253 int length, int key_frame) | |
254 { | |
255 int timestamp; | |
256 ByteIOContext *s = &ctx->pb; | |
257 | |
258 stream->nb_packets++; | |
259 stream->packet_total_size += length; | |
260 if (length > stream->packet_max_size) | |
261 stream->packet_max_size = length; | |
262 | |
263 put_be16(s,0); /* version */ | |
264 put_be16(s,length + 12); | |
265 put_be16(s, stream->num); /* stream number */ | |
266 timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate; | |
267 put_be32(s, timestamp); /* timestamp */ | |
268 put_byte(s, 0); /* reserved */ | |
269 put_byte(s, key_frame ? 2 : 0); /* flags */ | |
270 } | |
271 | |
272 static int rm_write_header(AVFormatContext *s) | |
273 { | |
274 RMContext *rm = s->priv_data; | |
275 StreamInfo *stream; | |
276 int n; | |
277 AVCodecContext *codec; | |
278 | |
279 for(n=0;n<s->nb_streams;n++) { | |
280 s->streams[n]->id = n; | |
281 codec = s->streams[n]->codec; | |
282 stream = &rm->streams[n]; | |
283 memset(stream, 0, sizeof(StreamInfo)); | |
284 stream->num = n; | |
285 stream->bit_rate = codec->bit_rate; | |
286 stream->enc = codec; | |
287 | |
288 switch(codec->codec_type) { | |
289 case CODEC_TYPE_AUDIO: | |
290 rm->audio_stream = stream; | |
291 stream->frame_rate = (float)codec->sample_rate / (float)codec->frame_size; | |
292 /* XXX: dummy values */ | |
293 stream->packet_max_size = 1024; | |
294 stream->nb_packets = 0; | |
295 stream->total_frames = stream->nb_packets; | |
296 break; | |
297 case CODEC_TYPE_VIDEO: | |
298 rm->video_stream = stream; | |
299 stream->frame_rate = (float)codec->time_base.den / (float)codec->time_base.num; | |
300 /* XXX: dummy values */ | |
301 stream->packet_max_size = 4096; | |
302 stream->nb_packets = 0; | |
303 stream->total_frames = stream->nb_packets; | |
304 break; | |
305 default: | |
306 return -1; | |
307 } | |
308 } | |
309 | |
310 rv10_write_header(s, 0, 0); | |
311 put_flush_packet(&s->pb); | |
312 return 0; | |
313 } | |
314 | |
315 static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int flags) | |
316 { | |
317 uint8_t *buf1; | |
318 RMContext *rm = s->priv_data; | |
319 ByteIOContext *pb = &s->pb; | |
320 StreamInfo *stream = rm->audio_stream; | |
321 int i; | |
322 | |
323 /* XXX: suppress this malloc */ | |
324 buf1= (uint8_t*) av_malloc( size * sizeof(uint8_t) ); | |
325 | |
326 write_packet_header(s, stream, size, !!(flags & PKT_FLAG_KEY)); | |
327 | |
328 /* for AC3, the words seems to be reversed */ | |
329 for(i=0;i<size;i+=2) { | |
330 buf1[i] = buf[i+1]; | |
331 buf1[i+1] = buf[i]; | |
332 } | |
333 put_buffer(pb, buf1, size); | |
334 put_flush_packet(pb); | |
335 stream->nb_frames++; | |
336 av_free(buf1); | |
337 return 0; | |
338 } | |
339 | |
340 static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags) | |
341 { | |
342 RMContext *rm = s->priv_data; | |
343 ByteIOContext *pb = &s->pb; | |
344 StreamInfo *stream = rm->video_stream; | |
345 int key_frame = !!(flags & PKT_FLAG_KEY); | |
346 | |
347 /* XXX: this is incorrect: should be a parameter */ | |
348 | |
349 /* Well, I spent some time finding the meaning of these bits. I am | |
350 not sure I understood everything, but it works !! */ | |
351 #if 1 | |
352 write_packet_header(s, stream, size + 7, key_frame); | |
353 /* bit 7: '1' if final packet of a frame converted in several packets */ | |
354 put_byte(pb, 0x81); | |
355 /* bit 7: '1' if I frame. bits 6..0 : sequence number in current | |
356 frame starting from 1 */ | |
357 if (key_frame) { | |
358 put_byte(pb, 0x81); | |
359 } else { | |
360 put_byte(pb, 0x01); | |
361 } | |
362 put_be16(pb, 0x4000 + (size)); /* total frame size */ | |
363 put_be16(pb, 0x4000 + (size)); /* offset from the start or the end */ | |
364 #else | |
365 /* full frame */ | |
366 write_packet_header(s, size + 6); | |
367 put_byte(pb, 0xc0); | |
368 put_be16(pb, 0x4000 + size); /* total frame size */ | |
369 put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */ | |
370 #endif | |
371 put_byte(pb, stream->nb_frames & 0xff); | |
372 | |
373 put_buffer(pb, buf, size); | |
374 put_flush_packet(pb); | |
375 | |
376 stream->nb_frames++; | |
377 return 0; | |
378 } | |
379 | |
380 static int rm_write_packet(AVFormatContext *s, AVPacket *pkt) | |
381 { | |
382 if (s->streams[pkt->stream_index]->codec->codec_type == | |
383 CODEC_TYPE_AUDIO) | |
384 return rm_write_audio(s, pkt->data, pkt->size, pkt->flags); | |
385 else | |
386 return rm_write_video(s, pkt->data, pkt->size, pkt->flags); | |
387 } | |
388 | |
389 static int rm_write_trailer(AVFormatContext *s) | |
390 { | |
391 RMContext *rm = s->priv_data; | |
392 int data_size, index_pos, i; | |
393 ByteIOContext *pb = &s->pb; | |
394 | |
395 if (!url_is_streamed(&s->pb)) { | |
396 /* end of file: finish to write header */ | |
397 index_pos = url_fseek(pb, 0, SEEK_CUR); | |
398 data_size = index_pos - rm->data_pos; | |
399 | |
400 /* index */ | |
401 put_tag(pb, "INDX"); | |
402 put_be32(pb, 10 + 10 * s->nb_streams); | |
403 put_be16(pb, 0); | |
404 | |
405 for(i=0;i<s->nb_streams;i++) { | |
406 put_be32(pb, 0); /* zero indices */ | |
407 put_be16(pb, i); /* stream number */ | |
408 put_be32(pb, 0); /* next index */ | |
409 } | |
410 /* undocumented end header */ | |
411 put_be32(pb, 0); | |
412 put_be32(pb, 0); | |
413 | |
414 url_fseek(pb, 0, SEEK_SET); | |
415 for(i=0;i<s->nb_streams;i++) | |
416 rm->streams[i].total_frames = rm->streams[i].nb_frames; | |
417 rv10_write_header(s, data_size, index_pos); | |
418 } else { | |
419 /* undocumented end header */ | |
420 put_be32(pb, 0); | |
421 put_be32(pb, 0); | |
422 } | |
423 put_flush_packet(pb); | |
424 return 0; | |
425 } | |
426 | |
427 | |
428 AVOutputFormat rm_muxer = { | |
429 "rm", | |
430 "rm format", | |
431 "application/vnd.rn-realmedia", | |
432 "rm,ra", | |
433 sizeof(RMContext), | |
434 CODEC_ID_AC3, | |
435 CODEC_ID_RV10, | |
436 rm_write_header, | |
437 rm_write_packet, | |
438 rm_write_trailer, | |
439 }; |