libavformat/rmenc.c

   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 + (size >= 0x4000)*4, 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     if(size >= 0x4000){
 363         put_be32(pb, size); /* total frame size */
 364         put_be32(pb, size); /* offset from the start or the end */
 365     }else{
 366         put_be16(pb, 0x4000 | size); /* total frame size */
 367         put_be16(pb, 0x4000 | size); /* offset from the start or the end */
 368     }
 369 #else
 370     /* full frame */
 371     write_packet_header(s, size + 6);
 372     put_byte(pb, 0xc0);
 373     put_be16(pb, 0x4000 + size); /* total frame size */
 374     put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */
 375 #endif
 376     put_byte(pb, stream->nb_frames & 0xff);
 377
 378     put_buffer(pb, buf, size);
 379     put_flush_packet(pb);
 380
 381     stream->nb_frames++;
 382     return 0;
 383 }
 384
 385 static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
 386 {
 387     if (s->streams[pkt->stream_index]->codec->codec_type ==
 388         CODEC_TYPE_AUDIO)
 389         return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);
 390     else
 391         return rm_write_video(s, pkt->data, pkt->size, pkt->flags);
 392 }
 393
 394 static int rm_write_trailer(AVFormatContext *s)
 395 {
 396     RMContext *rm = s->priv_data;
 397     int data_size, index_pos, i;
 398     ByteIOContext *pb = s->pb;
 399
 400     if (!url_is_streamed(s->pb)) {
 401         /* end of file: finish to write header */
 402         index_pos = url_fseek(pb, 0, SEEK_CUR);
 403         data_size = index_pos - rm->data_pos;
 404
 405         /* index */
 406         put_tag(pb, "INDX");
 407         put_be32(pb, 10 + 10 * s->nb_streams);
 408         put_be16(pb, 0);
 409
 410         for(i=0;i<s->nb_streams;i++) {
 411             put_be32(pb, 0); /* zero indexes */
 412             put_be16(pb, i); /* stream number */
 413             put_be32(pb, 0); /* next index */
 414         }
 415         /* undocumented end header */
 416         put_be32(pb, 0);
 417         put_be32(pb, 0);
 418
 419         url_fseek(pb, 0, SEEK_SET);
 420         for(i=0;i<s->nb_streams;i++)
 421             rm->streams[i].total_frames = rm->streams[i].nb_frames;
 422         rv10_write_header(s, data_size, index_pos);
 423     } else {
 424         /* undocumented end header */
 425         put_be32(pb, 0);
 426         put_be32(pb, 0);
 427     }
 428     put_flush_packet(pb);
 429     return 0;
 430 }
 431
 432
 433 AVOutputFormat rm_muxer = {
 434     "rm",
 435     NULL_IF_CONFIG_SMALL("RM format"),
 436     "application/vnd.rn-realmedia",
 437     "rm,ra",
 438     sizeof(RMContext),
 439     CODEC_ID_AC3,
 440     CODEC_ID_RV10,
 441     rm_write_header,
 442     rm_write_packet,
 443     rm_write_trailer,
 444 };