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