libavformat/swfenc.c

   1 /*
   2  * Flash Compatible Streaming Format muxer
   3  * Copyright (c) 2000 Fabrice Bellard
   4  * Copyright (c) 2003 Tinic Uro
   5  *
   6  * This file is part of Libav.
   7  *
   8  * Libav is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * Libav is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with Libav; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "libavcodec/put_bits.h"
  24 #include "avformat.h"
  25 #include "swf.h"
  26
  27 static void put_swf_tag(AVFormatContext *s, int tag)
  28 {
  29     SWFContext *swf = s->priv_data;
  30     AVIOContext *pb = s->pb;
  31
  32     swf->tag_pos = avio_tell(pb);
  33     swf->tag = tag;
  34     /* reserve some room for the tag */
  35     if (tag & TAG_LONG) {
  36         avio_wl16(pb, 0);
  37         avio_wl32(pb, 0);
  38     } else {
  39         avio_wl16(pb, 0);
  40     }
  41 }
  42
  43 static void put_swf_end_tag(AVFormatContext *s)
  44 {
  45     SWFContext *swf = s->priv_data;
  46     AVIOContext *pb = s->pb;
  47     int64_t pos;
  48     int tag_len, tag;
  49
  50     pos = avio_tell(pb);
  51     tag_len = pos - swf->tag_pos - 2;
  52     tag = swf->tag;
  53     avio_seek(pb, swf->tag_pos, SEEK_SET);
  54     if (tag & TAG_LONG) {
  55         tag &= ~TAG_LONG;
  56         avio_wl16(pb, (tag << 6) | 0x3f);
  57         avio_wl32(pb, tag_len - 4);
  58     } else {
  59         assert(tag_len < 0x3f);
  60         avio_wl16(pb, (tag << 6) | tag_len);
  61     }
  62     avio_seek(pb, pos, SEEK_SET);
  63 }
  64
  65 static inline void max_nbits(int *nbits_ptr, int val)
  66 {
  67     int n;
  68
  69     if (val == 0)
  70         return;
  71     val = abs(val);
  72     n = 1;
  73     while (val != 0) {
  74         n++;
  75         val >>= 1;
  76     }
  77     if (n > *nbits_ptr)
  78         *nbits_ptr = n;
  79 }
  80
  81 static void put_swf_rect(AVIOContext *pb,
  82                          int xmin, int xmax, int ymin, int ymax)
  83 {
  84     PutBitContext p;
  85     uint8_t buf[256];
  86     int nbits, mask;
  87
  88     init_put_bits(&p, buf, sizeof(buf));
  89
  90     nbits = 0;
  91     max_nbits(&nbits, xmin);
  92     max_nbits(&nbits, xmax);
  93     max_nbits(&nbits, ymin);
  94     max_nbits(&nbits, ymax);
  95     mask = (1 << nbits) - 1;
  96
  97     /* rectangle info */
  98     put_bits(&p, 5, nbits);
  99     put_bits(&p, nbits, xmin & mask);
 100     put_bits(&p, nbits, xmax & mask);
 101     put_bits(&p, nbits, ymin & mask);
 102     put_bits(&p, nbits, ymax & mask);
 103
 104     flush_put_bits(&p);
 105     avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
 106 }
 107
 108 static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
 109 {
 110     int nbits, mask;
 111
 112     put_bits(pb, 1, 1); /* edge */
 113     put_bits(pb, 1, 1); /* line select */
 114     nbits = 2;
 115     max_nbits(&nbits, dx);
 116     max_nbits(&nbits, dy);
 117
 118     mask = (1 << nbits) - 1;
 119     put_bits(pb, 4, nbits - 2); /* 16 bits precision */
 120     if (dx == 0) {
 121         put_bits(pb, 1, 0);
 122         put_bits(pb, 1, 1);
 123         put_bits(pb, nbits, dy & mask);
 124     } else if (dy == 0) {
 125         put_bits(pb, 1, 0);
 126         put_bits(pb, 1, 0);
 127         put_bits(pb, nbits, dx & mask);
 128     } else {
 129         put_bits(pb, 1, 1);
 130         put_bits(pb, nbits, dx & mask);
 131         put_bits(pb, nbits, dy & mask);
 132     }
 133 }
 134
 135 #define FRAC_BITS 16
 136
 137 static void put_swf_matrix(AVIOContext *pb,
 138                            int a, int b, int c, int d, int tx, int ty)
 139 {
 140     PutBitContext p;
 141     uint8_t buf[256];
 142     int nbits;
 143
 144     init_put_bits(&p, buf, sizeof(buf));
 145
 146     put_bits(&p, 1, 1); /* a, d present */
 147     nbits = 1;
 148     max_nbits(&nbits, a);
 149     max_nbits(&nbits, d);
 150     put_bits(&p, 5, nbits); /* nb bits */
 151     put_bits(&p, nbits, a);
 152     put_bits(&p, nbits, d);
 153
 154     put_bits(&p, 1, 1); /* b, c present */
 155     nbits = 1;
 156     max_nbits(&nbits, c);
 157     max_nbits(&nbits, b);
 158     put_bits(&p, 5, nbits); /* nb bits */
 159     put_bits(&p, nbits, c);
 160     put_bits(&p, nbits, b);
 161
 162     nbits = 1;
 163     max_nbits(&nbits, tx);
 164     max_nbits(&nbits, ty);
 165     put_bits(&p, 5, nbits); /* nb bits */
 166     put_bits(&p, nbits, tx);
 167     put_bits(&p, nbits, ty);
 168
 169     flush_put_bits(&p);
 170     avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
 171 }
 172
 173 static int swf_write_header(AVFormatContext *s)
 174 {
 175     SWFContext *swf = s->priv_data;
 176     AVIOContext *pb = s->pb;
 177     PutBitContext p;
 178     uint8_t buf1[256];
 179     int i, width, height, rate, rate_base;
 180     int version;
 181
 182     swf->sound_samples = 0;
 183     swf->swf_frame_number = 0;
 184     swf->video_frame_number = 0;
 185
 186     for(i=0;i<s->nb_streams;i++) {
 187         AVCodecContext *enc = s->streams[i]->codec;
 188         if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
 189             if (swf->audio_enc) {
 190                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports 1 audio stream\n");
 191                 return AVERROR_INVALIDDATA;
 192             }
 193             if (enc->codec_id == AV_CODEC_ID_MP3) {
 194                 swf->audio_enc = enc;
 195                 swf->audio_fifo= av_fifo_alloc(AUDIO_FIFO_SIZE);
 196                 if (!swf->audio_fifo)
 197                     return AVERROR(ENOMEM);
 198             } else {
 199                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports MP3\n");
 200                 return -1;
 201             }
 202         } else {
 203             if (swf->video_enc) {
 204                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports 1 video stream\n");
 205                 return AVERROR_INVALIDDATA;
 206             }
 207             if (enc->codec_id == AV_CODEC_ID_VP6F ||
 208                 enc->codec_id == AV_CODEC_ID_FLV1 ||
 209                 enc->codec_id == AV_CODEC_ID_MJPEG) {
 210                 swf->video_st  = s->streams[i];
 211                 swf->video_enc = enc;
 212             } else {
 213                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV1 and MJPEG\n");
 214                 return -1;
 215             }
 216         }
 217     }
 218
 219     if (!swf->video_enc) {
 220         /* currently, cannot work correctly if audio only */
 221         width = 320;
 222         height = 200;
 223         rate = 10;
 224         rate_base= 1;
 225     } else {
 226         width = swf->video_enc->width;
 227         height = swf->video_enc->height;
 228         // TODO: should be avg_frame_rate
 229         rate = swf->video_st->time_base.den;
 230         rate_base = swf->video_st->time_base.num;
 231     }
 232
 233     if (!swf->audio_enc)
 234         swf->samples_per_frame = (44100.0 * rate_base) / rate;
 235     else
 236         swf->samples_per_frame = (swf->audio_enc->sample_rate * rate_base) / rate;
 237
 238     avio_write(pb, "FWS", 3);
 239
 240     if (!strcmp("avm2", s->oformat->name))
 241         version = 9;
 242     else if (swf->video_enc && swf->video_enc->codec_id == AV_CODEC_ID_VP6F)
 243         version = 8; /* version 8 and above support VP6 codec */
 244     else if (swf->video_enc && swf->video_enc->codec_id == AV_CODEC_ID_FLV1)
 245         version = 6; /* version 6 and above support FLV1 codec */
 246     else
 247         version = 4; /* version 4 for mpeg audio support */
 248     avio_w8(pb, version);
 249
 250     avio_wl32(pb, DUMMY_FILE_SIZE); /* dummy size
 251                                       (will be patched if not streamed) */
 252
 253     put_swf_rect(pb, 0, width * 20, 0, height * 20);
 254     avio_wl16(pb, (rate * 256) / rate_base); /* frame rate */
 255     swf->duration_pos = avio_tell(pb);
 256     avio_wl16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
 257
 258     /* avm2/swf v9 (also v8?) files require a file attribute tag */
 259     if (version == 9) {
 260         put_swf_tag(s, TAG_FILEATTRIBUTES);
 261         avio_wl32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
 262         put_swf_end_tag(s);
 263     }
 264
 265     /* define a shape with the jpeg inside */
 266     if (swf->video_enc && swf->video_enc->codec_id == AV_CODEC_ID_MJPEG) {
 267         put_swf_tag(s, TAG_DEFINESHAPE);
 268
 269         avio_wl16(pb, SHAPE_ID); /* ID of shape */
 270         /* bounding rectangle */
 271         put_swf_rect(pb, 0, width, 0, height);
 272         /* style info */
 273         avio_w8(pb, 1); /* one fill style */
 274         avio_w8(pb, 0x41); /* clipped bitmap fill */
 275         avio_wl16(pb, BITMAP_ID); /* bitmap ID */
 276         /* position of the bitmap */
 277         put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
 278                        0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
 279         avio_w8(pb, 0); /* no line style */
 280
 281         /* shape drawing */
 282         init_put_bits(&p, buf1, sizeof(buf1));
 283         put_bits(&p, 4, 1); /* one fill bit */
 284         put_bits(&p, 4, 0); /* zero line bit */
 285
 286         put_bits(&p, 1, 0); /* not an edge */
 287         put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);
 288         put_bits(&p, 5, 1); /* nbits */
 289         put_bits(&p, 1, 0); /* X */
 290         put_bits(&p, 1, 0); /* Y */
 291         put_bits(&p, 1, 1); /* set fill style 1 */
 292
 293         /* draw the rectangle ! */
 294         put_swf_line_edge(&p, width, 0);
 295         put_swf_line_edge(&p, 0, height);
 296         put_swf_line_edge(&p, -width, 0);
 297         put_swf_line_edge(&p, 0, -height);
 298
 299         /* end of shape */
 300         put_bits(&p, 1, 0); /* not an edge */
 301         put_bits(&p, 5, 0);
 302
 303         flush_put_bits(&p);
 304         avio_write(pb, buf1, put_bits_ptr(&p) - p.buf);
 305
 306         put_swf_end_tag(s);
 307     }
 308
 309     if (swf->audio_enc && swf->audio_enc->codec_id == AV_CODEC_ID_MP3) {
 310         int v = 0;
 311
 312         /* start sound */
 313         put_swf_tag(s, TAG_STREAMHEAD2);
 314         switch(swf->audio_enc->sample_rate) {
 315         case 11025: v |= 1 << 2; break;
 316         case 22050: v |= 2 << 2; break;
 317         case 44100: v |= 3 << 2; break;
 318         default:
 319             /* not supported */
 320             av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
 321             return -1;
 322         }
 323         v |= 0x02; /* 16 bit playback */
 324         if (swf->audio_enc->channels == 2)
 325             v |= 0x01; /* stereo playback */
 326         avio_w8(s->pb, v);
 327         v |= 0x20; /* mp3 compressed */
 328         avio_w8(s->pb, v);
 329         avio_wl16(s->pb, swf->samples_per_frame);  /* avg samples per frame */
 330         avio_wl16(s->pb, 0);
 331
 332         put_swf_end_tag(s);
 333     }
 334
 335     avio_flush(s->pb);
 336     return 0;
 337 }
 338
 339 static int swf_write_video(AVFormatContext *s,
 340                            AVCodecContext *enc, const uint8_t *buf, int size)
 341 {
 342     SWFContext *swf = s->priv_data;
 343     AVIOContext *pb = s->pb;
 344
 345     /* Flash Player limit */
 346     if (swf->swf_frame_number == 16000)
 347         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
 348
 349     if (enc->codec_id == AV_CODEC_ID_VP6F ||
 350         enc->codec_id == AV_CODEC_ID_FLV1) {
 351         if (swf->video_frame_number == 0) {
 352             /* create a new video object */
 353             put_swf_tag(s, TAG_VIDEOSTREAM);
 354             avio_wl16(pb, VIDEO_ID);
 355             swf->vframes_pos = avio_tell(pb);
 356             avio_wl16(pb, 15000); /* hard flash player limit */
 357             avio_wl16(pb, enc->width);
 358             avio_wl16(pb, enc->height);
 359             avio_w8(pb, 0);
 360             avio_w8(pb,ff_codec_get_tag(ff_swf_codec_tags, enc->codec_id));
 361             put_swf_end_tag(s);
 362
 363             /* place the video object for the first time */
 364             put_swf_tag(s, TAG_PLACEOBJECT2);
 365             avio_w8(pb, 0x36);
 366             avio_wl16(pb, 1);
 367             avio_wl16(pb, VIDEO_ID);
 368             put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
 369             avio_wl16(pb, swf->video_frame_number);
 370             avio_write(pb, "video", 5);
 371             avio_w8(pb, 0x00);
 372             put_swf_end_tag(s);
 373         } else {
 374             /* mark the character for update */
 375             put_swf_tag(s, TAG_PLACEOBJECT2);
 376             avio_w8(pb, 0x11);
 377             avio_wl16(pb, 1);
 378             avio_wl16(pb, swf->video_frame_number);
 379             put_swf_end_tag(s);
 380         }
 381
 382         /* set video frame data */
 383         put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
 384         avio_wl16(pb, VIDEO_ID);
 385         avio_wl16(pb, swf->video_frame_number++);
 386         avio_write(pb, buf, size);
 387         put_swf_end_tag(s);
 388     } else if (enc->codec_id == AV_CODEC_ID_MJPEG) {
 389         if (swf->swf_frame_number > 0) {
 390             /* remove the shape */
 391             put_swf_tag(s, TAG_REMOVEOBJECT);
 392             avio_wl16(pb, SHAPE_ID); /* shape ID */
 393             avio_wl16(pb, 1); /* depth */
 394             put_swf_end_tag(s);
 395
 396             /* free the bitmap */
 397             put_swf_tag(s, TAG_FREECHARACTER);
 398             avio_wl16(pb, BITMAP_ID);
 399             put_swf_end_tag(s);
 400         }
 401
 402         put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
 403
 404         avio_wl16(pb, BITMAP_ID); /* ID of the image */
 405
 406         /* a dummy jpeg header seems to be required */
 407         avio_wb32(pb, 0xffd8ffd9);
 408         /* write the jpeg image */
 409         avio_write(pb, buf, size);
 410
 411         put_swf_end_tag(s);
 412
 413         /* draw the shape */
 414
 415         put_swf_tag(s, TAG_PLACEOBJECT);
 416         avio_wl16(pb, SHAPE_ID); /* shape ID */
 417         avio_wl16(pb, 1); /* depth */
 418         put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
 419         put_swf_end_tag(s);
 420     }
 421
 422     swf->swf_frame_number++;
 423
 424     /* streaming sound always should be placed just before showframe tags */
 425     if (swf->audio_enc && av_fifo_size(swf->audio_fifo)) {
 426         int frame_size = av_fifo_size(swf->audio_fifo);
 427         put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
 428         avio_wl16(pb, swf->sound_samples);
 429         avio_wl16(pb, 0); // seek samples
 430         av_fifo_generic_read(swf->audio_fifo, pb, frame_size, &avio_write);
 431         put_swf_end_tag(s);
 432
 433         /* update FIFO */
 434         swf->sound_samples = 0;
 435     }
 436
 437     /* output the frame */
 438     put_swf_tag(s, TAG_SHOWFRAME);
 439     put_swf_end_tag(s);
 440
 441     return 0;
 442 }
 443
 444 static int swf_write_audio(AVFormatContext *s,
 445                            AVCodecContext *enc, uint8_t *buf, int size)
 446 {
 447     SWFContext *swf = s->priv_data;
 448
 449     /* Flash Player limit */
 450     if (swf->swf_frame_number == 16000)
 451         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
 452
 453     if (av_fifo_size(swf->audio_fifo) + size > AUDIO_FIFO_SIZE) {
 454         av_log(s, AV_LOG_ERROR, "audio fifo too small to mux audio essence\n");
 455         return -1;
 456     }
 457
 458     av_fifo_generic_write(swf->audio_fifo, buf, size, NULL);
 459     swf->sound_samples += av_get_audio_frame_duration(enc, size);
 460
 461     /* if audio only stream make sure we add swf frames */
 462     if (!swf->video_enc)
 463         swf_write_video(s, enc, 0, 0);
 464
 465     return 0;
 466 }
 467
 468 static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
 469 {
 470     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
 471     if (codec->codec_type == AVMEDIA_TYPE_AUDIO)
 472         return swf_write_audio(s, codec, pkt->data, pkt->size);
 473     else
 474         return swf_write_video(s, codec, pkt->data, pkt->size);
 475 }
 476
 477 static int swf_write_trailer(AVFormatContext *s)
 478 {
 479     SWFContext *swf = s->priv_data;
 480     AVIOContext *pb = s->pb;
 481     AVCodecContext *enc, *video_enc;
 482     int file_size, i;
 483
 484     video_enc = NULL;
 485     for(i=0;i<s->nb_streams;i++) {
 486         enc = s->streams[i]->codec;
 487         if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
 488             video_enc = enc;
 489         else
 490             av_fifo_free(swf->audio_fifo);
 491     }
 492
 493     put_swf_tag(s, TAG_END);
 494     put_swf_end_tag(s);
 495
 496     /* patch file size and number of frames if not streamed */
 497     if (s->pb->seekable && video_enc) {
 498         file_size = avio_tell(pb);
 499         avio_seek(pb, 4, SEEK_SET);
 500         avio_wl32(pb, file_size);
 501         avio_seek(pb, swf->duration_pos, SEEK_SET);
 502         avio_wl16(pb, swf->video_frame_number);
 503         avio_seek(pb, swf->vframes_pos, SEEK_SET);
 504         avio_wl16(pb, swf->video_frame_number);
 505         avio_seek(pb, file_size, SEEK_SET);
 506     }
 507     return 0;
 508 }
 509
 510 #if CONFIG_SWF_MUXER
 511 AVOutputFormat ff_swf_muxer = {
 512     .name              = "swf",
 513     .long_name         = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
 514     .mime_type         = "application/x-shockwave-flash",
 515     .extensions        = "swf",
 516     .priv_data_size    = sizeof(SWFContext),
 517     .audio_codec       = AV_CODEC_ID_MP3,
 518     .video_codec       = AV_CODEC_ID_FLV1,
 519     .write_header      = swf_write_header,
 520     .write_packet      = swf_write_packet,
 521     .write_trailer     = swf_write_trailer,
 522     .flags             = AVFMT_TS_NONSTRICT,
 523 };
 524 #endif
 525 #if CONFIG_AVM2_MUXER
 526 AVOutputFormat ff_avm2_muxer = {
 527     .name              = "avm2",
 528     .long_name         = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash) (AVM2)"),
 529     .mime_type         = "application/x-shockwave-flash",
 530     .priv_data_size    = sizeof(SWFContext),
 531     .audio_codec       = AV_CODEC_ID_MP3,
 532     .video_codec       = AV_CODEC_ID_FLV1,
 533     .write_header      = swf_write_header,
 534     .write_packet      = swf_write_packet,
 535     .write_trailer     = swf_write_trailer,
 536     .flags             = AVFMT_TS_NONSTRICT,
 537 };
 538 #endif