00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "avformat.h"
00022 #include "rm.h"
00023
00024
00025 #define BUFFER_DURATION 0
00026
00027
00028 static void put_str(ByteIOContext *s, const char *tag)
00029 {
00030 put_be16(s,strlen(tag));
00031 while (*tag) {
00032 put_byte(s, *tag++);
00033 }
00034 }
00035
00036 static void put_str8(ByteIOContext *s, const char *tag)
00037 {
00038 put_byte(s, strlen(tag));
00039 while (*tag) {
00040 put_byte(s, *tag++);
00041 }
00042 }
00043
00044 static void rv10_write_header(AVFormatContext *ctx,
00045 int data_size, int index_pos)
00046 {
00047 RMContext *rm = ctx->priv_data;
00048 ByteIOContext *s = ctx->pb;
00049 StreamInfo *stream;
00050 unsigned char *data_offset_ptr, *start_ptr;
00051 const char *desc, *mimetype;
00052 int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;
00053 int bit_rate, v, duration, flags, data_pos;
00054
00055 start_ptr = s->buf_ptr;
00056
00057 put_tag(s, ".RMF");
00058 put_be32(s,18);
00059 put_be16(s,0);
00060 put_be32(s,0);
00061 put_be32(s,4 + ctx->nb_streams);
00062
00063 put_tag(s,"PROP");
00064 put_be32(s, 50);
00065 put_be16(s, 0);
00066 packet_max_size = 0;
00067 packet_total_size = 0;
00068 nb_packets = 0;
00069 bit_rate = 0;
00070 duration = 0;
00071 for(i=0;i<ctx->nb_streams;i++) {
00072 StreamInfo *stream = &rm->streams[i];
00073 bit_rate += stream->bit_rate;
00074 if (stream->packet_max_size > packet_max_size)
00075 packet_max_size = stream->packet_max_size;
00076 nb_packets += stream->nb_packets;
00077 packet_total_size += stream->packet_total_size;
00078
00079 v = (int) (1000.0 * (float)stream->total_frames / stream->frame_rate);
00080 if (v > duration)
00081 duration = v;
00082 }
00083 put_be32(s, bit_rate);
00084 put_be32(s, bit_rate);
00085 put_be32(s, packet_max_size);
00086 if (nb_packets > 0)
00087 packet_avg_size = packet_total_size / nb_packets;
00088 else
00089 packet_avg_size = 0;
00090 put_be32(s, packet_avg_size);
00091 put_be32(s, nb_packets);
00092 put_be32(s, duration);
00093 put_be32(s, BUFFER_DURATION);
00094 put_be32(s, index_pos);
00095
00096 data_offset_ptr = s->buf_ptr;
00097 put_be32(s, 0);
00098 put_be16(s, ctx->nb_streams);
00099 flags = 1 | 2;
00100 if (url_is_streamed(s))
00101 flags |= 4;
00102 put_be16(s, flags);
00103
00104
00105
00106 put_tag(s,"CONT");
00107 size = strlen(ctx->title) + strlen(ctx->author) + strlen(ctx->copyright) +
00108 strlen(ctx->comment) + 4 * 2 + 10;
00109 put_be32(s,size);
00110 put_be16(s,0);
00111 put_str(s, ctx->title);
00112 put_str(s, ctx->author);
00113 put_str(s, ctx->copyright);
00114 put_str(s, ctx->comment);
00115
00116 for(i=0;i<ctx->nb_streams;i++) {
00117 int codec_data_size;
00118
00119 stream = &rm->streams[i];
00120
00121 if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
00122 desc = "The Audio Stream";
00123 mimetype = "audio/x-pn-realaudio";
00124 codec_data_size = 73;
00125 } else {
00126 desc = "The Video Stream";
00127 mimetype = "video/x-pn-realvideo";
00128 codec_data_size = 34;
00129 }
00130
00131 put_tag(s,"MDPR");
00132 size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;
00133 put_be32(s, size);
00134 put_be16(s, 0);
00135
00136 put_be16(s, i);
00137 put_be32(s, stream->bit_rate);
00138 put_be32(s, stream->bit_rate);
00139 put_be32(s, stream->packet_max_size);
00140 if (stream->nb_packets > 0)
00141 packet_avg_size = stream->packet_total_size /
00142 stream->nb_packets;
00143 else
00144 packet_avg_size = 0;
00145 put_be32(s, packet_avg_size);
00146 put_be32(s, 0);
00147 put_be32(s, BUFFER_DURATION);
00148
00149 if (url_is_streamed(s) || !stream->total_frames)
00150 put_be32(s, (int)(3600 * 1000));
00151 else
00152 put_be32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
00153 put_str8(s, desc);
00154 put_str8(s, mimetype);
00155 put_be32(s, codec_data_size);
00156
00157 if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
00158 int coded_frame_size, fscode, sample_rate;
00159 sample_rate = stream->enc->sample_rate;
00160 coded_frame_size = (stream->enc->bit_rate *
00161 stream->enc->frame_size) / (8 * sample_rate);
00162
00163 put_tag(s, ".ra");
00164 put_byte(s, 0xfd);
00165 put_be32(s, 0x00040000);
00166 put_tag(s, ".ra4");
00167 put_be32(s, 0x01b53530);
00168 put_be16(s, 4);
00169 put_be32(s, 0x39);
00170
00171 switch(sample_rate) {
00172 case 48000:
00173 case 24000:
00174 case 12000:
00175 fscode = 1;
00176 break;
00177 default:
00178 case 44100:
00179 case 22050:
00180 case 11025:
00181 fscode = 2;
00182 break;
00183 case 32000:
00184 case 16000:
00185 case 8000:
00186 fscode = 3;
00187 }
00188 put_be16(s, fscode);
00189
00190
00191 if (coded_frame_size == 557)
00192 coded_frame_size--;
00193 put_be32(s, coded_frame_size);
00194 put_be32(s, 0x51540);
00195 put_be32(s, 0x249f0);
00196 put_be32(s, 0x249f0);
00197 put_be16(s, 0x01);
00198
00199 put_be16(s, coded_frame_size);
00200 put_be32(s, 0);
00201 put_be16(s, stream->enc->sample_rate);
00202 put_be32(s, 0x10);
00203 put_be16(s, stream->enc->channels);
00204 put_str8(s, "Int0");
00205 put_str8(s, "dnet");
00206 put_be16(s, 0);
00207 put_be16(s, 0);
00208 put_be16(s, 0);
00209 put_byte(s, 0);
00210 } else {
00211
00212 put_be32(s,34);
00213 if(stream->enc->codec_id == CODEC_ID_RV10)
00214 put_tag(s,"VIDORV10");
00215 else
00216 put_tag(s,"VIDORV20");
00217 put_be16(s, stream->enc->width);
00218 put_be16(s, stream->enc->height);
00219 put_be16(s, (int) stream->frame_rate);
00220 put_be32(s,0);
00221 put_be16(s, (int) stream->frame_rate);
00222 put_be32(s,0);
00223 put_be16(s, 8);
00224
00225
00226
00227 if(stream->enc->codec_id == CODEC_ID_RV10)
00228 put_be32(s,0x10000000);
00229 else
00230 put_be32(s,0x20103001);
00231
00232 }
00233 }
00234
00235
00236 data_pos = s->buf_ptr - start_ptr;
00237 rm->data_pos = data_pos;
00238 data_offset_ptr[0] = data_pos >> 24;
00239 data_offset_ptr[1] = data_pos >> 16;
00240 data_offset_ptr[2] = data_pos >> 8;
00241 data_offset_ptr[3] = data_pos;
00242
00243
00244 put_tag(s,"DATA");
00245 put_be32(s,data_size + 10 + 8);
00246 put_be16(s,0);
00247
00248 put_be32(s, nb_packets);
00249 put_be32(s,0);
00250 }
00251
00252 static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
00253 int length, int key_frame)
00254 {
00255 int timestamp;
00256 ByteIOContext *s = ctx->pb;
00257
00258 stream->nb_packets++;
00259 stream->packet_total_size += length;
00260 if (length > stream->packet_max_size)
00261 stream->packet_max_size = length;
00262
00263 put_be16(s,0);
00264 put_be16(s,length + 12);
00265 put_be16(s, stream->num);
00266 timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate;
00267 put_be32(s, timestamp);
00268 put_byte(s, 0);
00269 put_byte(s, key_frame ? 2 : 0);
00270 }
00271
00272 static int rm_write_header(AVFormatContext *s)
00273 {
00274 RMContext *rm = s->priv_data;
00275 StreamInfo *stream;
00276 int n;
00277 AVCodecContext *codec;
00278
00279 for(n=0;n<s->nb_streams;n++) {
00280 s->streams[n]->id = n;
00281 codec = s->streams[n]->codec;
00282 stream = &rm->streams[n];
00283 memset(stream, 0, sizeof(StreamInfo));
00284 stream->num = n;
00285 stream->bit_rate = codec->bit_rate;
00286 stream->enc = codec;
00287
00288 switch(codec->codec_type) {
00289 case CODEC_TYPE_AUDIO:
00290 rm->audio_stream = stream;
00291 stream->frame_rate = (float)codec->sample_rate / (float)codec->frame_size;
00292
00293 stream->packet_max_size = 1024;
00294 stream->nb_packets = 0;
00295 stream->total_frames = stream->nb_packets;
00296 break;
00297 case CODEC_TYPE_VIDEO:
00298 rm->video_stream = stream;
00299 stream->frame_rate = (float)codec->time_base.den / (float)codec->time_base.num;
00300
00301 stream->packet_max_size = 4096;
00302 stream->nb_packets = 0;
00303 stream->total_frames = stream->nb_packets;
00304 break;
00305 default:
00306 return -1;
00307 }
00308 }
00309
00310 rv10_write_header(s, 0, 0);
00311 put_flush_packet(s->pb);
00312 return 0;
00313 }
00314
00315 static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int flags)
00316 {
00317 uint8_t *buf1;
00318 RMContext *rm = s->priv_data;
00319 ByteIOContext *pb = s->pb;
00320 StreamInfo *stream = rm->audio_stream;
00321 int i;
00322
00323
00324 buf1= (uint8_t*) av_malloc( size * sizeof(uint8_t) );
00325
00326 write_packet_header(s, stream, size, !!(flags & PKT_FLAG_KEY));
00327
00328
00329 for(i=0;i<size;i+=2) {
00330 buf1[i] = buf[i+1];
00331 buf1[i+1] = buf[i];
00332 }
00333 put_buffer(pb, buf1, size);
00334 put_flush_packet(pb);
00335 stream->nb_frames++;
00336 av_free(buf1);
00337 return 0;
00338 }
00339
00340 static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags)
00341 {
00342 RMContext *rm = s->priv_data;
00343 ByteIOContext *pb = s->pb;
00344 StreamInfo *stream = rm->video_stream;
00345 int key_frame = !!(flags & PKT_FLAG_KEY);
00346
00347
00348
00349
00350
00351 #if 1
00352 write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame);
00353
00354 put_byte(pb, 0x81);
00355
00356
00357 if (key_frame) {
00358 put_byte(pb, 0x81);
00359 } else {
00360 put_byte(pb, 0x01);
00361 }
00362 if(size >= 0x4000){
00363 put_be32(pb, size);
00364 put_be32(pb, size);
00365 }else{
00366 put_be16(pb, 0x4000 | size);
00367 put_be16(pb, 0x4000 | size);
00368 }
00369 #else
00370
00371 write_packet_header(s, size + 6);
00372 put_byte(pb, 0xc0);
00373 put_be16(pb, 0x4000 + size);
00374 put_be16(pb, 0x4000 + packet_number * 126);
00375 #endif
00376 put_byte(pb, stream->nb_frames & 0xff);
00377
00378 put_buffer(pb, buf, size);
00379 put_flush_packet(pb);
00380
00381 stream->nb_frames++;
00382 return 0;
00383 }
00384
00385 static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
00386 {
00387 if (s->streams[pkt->stream_index]->codec->codec_type ==
00388 CODEC_TYPE_AUDIO)
00389 return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);
00390 else
00391 return rm_write_video(s, pkt->data, pkt->size, pkt->flags);
00392 }
00393
00394 static int rm_write_trailer(AVFormatContext *s)
00395 {
00396 RMContext *rm = s->priv_data;
00397 int data_size, index_pos, i;
00398 ByteIOContext *pb = s->pb;
00399
00400 if (!url_is_streamed(s->pb)) {
00401
00402 index_pos = url_fseek(pb, 0, SEEK_CUR);
00403 data_size = index_pos - rm->data_pos;
00404
00405
00406 put_tag(pb, "INDX");
00407 put_be32(pb, 10 + 10 * s->nb_streams);
00408 put_be16(pb, 0);
00409
00410 for(i=0;i<s->nb_streams;i++) {
00411 put_be32(pb, 0);
00412 put_be16(pb, i);
00413 put_be32(pb, 0);
00414 }
00415
00416 put_be32(pb, 0);
00417 put_be32(pb, 0);
00418
00419 url_fseek(pb, 0, SEEK_SET);
00420 for(i=0;i<s->nb_streams;i++)
00421 rm->streams[i].total_frames = rm->streams[i].nb_frames;
00422 rv10_write_header(s, data_size, index_pos);
00423 } else {
00424
00425 put_be32(pb, 0);
00426 put_be32(pb, 0);
00427 }
00428 put_flush_packet(pb);
00429 return 0;
00430 }
00431
00432
00433 AVOutputFormat rm_muxer = {
00434 "rm",
00435 "rm format",
00436 "application/vnd.rn-realmedia",
00437 "rm,ra",
00438 sizeof(RMContext),
00439 CODEC_ID_AC3,
00440 CODEC_ID_RV10,
00441 rm_write_header,
00442 rm_write_packet,
00443 rm_write_trailer,
00444 };