synfig-core/tags/synfig_0_61_03/synfig-core/src/modules/mod_libavcodec/libavformat/swf.c

   1 /*
   2  * Flash Compatible Streaming Format
   3  * Copyright (c) 2000 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include "avformat.h"
  20
  21 /* should have a generic way to indicate probable size */
  22 #define DUMMY_FILE_SIZE   (100 * 1024 * 1024)
  23 #define DUMMY_DURATION    600 /* in seconds */
  24
  25 #define TAG_END           0
  26 #define TAG_SHOWFRAME     1
  27 #define TAG_DEFINESHAPE   2
  28 #define TAG_FREECHARACTER 3
  29 #define TAG_PLACEOBJECT   4
  30 #define TAG_REMOVEOBJECT  5
  31 #define TAG_STREAMHEAD    18
  32 #define TAG_STREAMBLOCK   19
  33 #define TAG_JPEG2         21
  34
  35 #define TAG_LONG         0x100
  36
  37 /* flags for shape definition */
  38 #define FLAG_MOVETO      0x01
  39 #define FLAG_SETFILL0    0x02
  40 #define FLAG_SETFILL1    0x04
  41
  42 /* character id used */
  43 #define BITMAP_ID 0
  44 #define SHAPE_ID  1
  45
  46 typedef struct {
  47     offset_t duration_pos;
  48     offset_t tag_pos;
  49     int tag;
  50 } SWFContext;
  51
  52 static void put_swf_tag(AVFormatContext *s, int tag)
  53 {
  54     SWFContext *swf = s->priv_data;
  55     ByteIOContext *pb = &s->pb;
  56
  57     swf->tag_pos = url_ftell(pb);
  58     swf->tag = tag;
  59     /* reserve some room for the tag */
  60     if (tag & TAG_LONG) {
  61         put_le16(pb, 0);
  62         put_le32(pb, 0);
  63     } else {
  64         put_le16(pb, 0);
  65     }
  66 }
  67
  68 static void put_swf_end_tag(AVFormatContext *s)
  69 {
  70     SWFContext *swf = s->priv_data;
  71     ByteIOContext *pb = &s->pb;
  72     offset_t pos;
  73     int tag_len, tag;
  74
  75     pos = url_ftell(pb);
  76     tag_len = pos - swf->tag_pos - 2;
  77     tag = swf->tag;
  78     url_fseek(pb, swf->tag_pos, SEEK_SET);
  79     if (tag & TAG_LONG) {
  80         tag &= ~TAG_LONG;
  81         put_le16(pb, (tag << 6) | 0x3f);
  82         put_le32(pb, tag_len - 4);
  83     } else {
  84         assert(tag_len < 0x3f);
  85         put_le16(pb, (tag << 6) | tag_len);
  86     }
  87     url_fseek(pb, pos, SEEK_SET);
  88 }
  89
  90 static inline void max_nbits(int *nbits_ptr, int val)
  91 {
  92     int n;
  93
  94     if (val == 0)
  95         return;
  96     val = abs(val);
  97     n = 1;
  98     while (val != 0) {
  99         n++;
 100         val >>= 1;
 101     }
 102     if (n > *nbits_ptr)
 103         *nbits_ptr = n;
 104 }
 105
 106 static void put_swf_rect(ByteIOContext *pb,
 107                          int xmin, int xmax, int ymin, int ymax)
 108 {
 109     PutBitContext p;
 110     uint8_t buf[256];
 111     int nbits, mask;
 112
 113     init_put_bits(&p, buf, sizeof(buf), NULL, NULL);
 114
 115     nbits = 0;
 116     max_nbits(&nbits, xmin);
 117     max_nbits(&nbits, xmax);
 118     max_nbits(&nbits, ymin);
 119     max_nbits(&nbits, ymax);
 120     mask = (1 << nbits) - 1;
 121
 122     /* rectangle info */
 123     put_bits(&p, 5, nbits);
 124     put_bits(&p, nbits, xmin & mask);
 125     put_bits(&p, nbits, xmax & mask);
 126     put_bits(&p, nbits, ymin & mask);
 127     put_bits(&p, nbits, ymax & mask);
 128
 129     flush_put_bits(&p);
 130     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);
 131 }
 132
 133 static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
 134 {
 135     int nbits, mask;
 136
 137     put_bits(pb, 1, 1); /* edge */
 138     put_bits(pb, 1, 1); /* line select */
 139     nbits = 2;
 140     max_nbits(&nbits, dx);
 141     max_nbits(&nbits, dy);
 142
 143     mask = (1 << nbits) - 1;
 144     put_bits(pb, 4, nbits - 2); /* 16 bits precision */
 145     if (dx == 0) {
 146       put_bits(pb, 1, 0);
 147       put_bits(pb, 1, 1);
 148       put_bits(pb, nbits, dy & mask);
 149     } else if (dy == 0) {
 150       put_bits(pb, 1, 0);
 151       put_bits(pb, 1, 0);
 152       put_bits(pb, nbits, dx & mask);
 153     } else {
 154       put_bits(pb, 1, 1);
 155       put_bits(pb, nbits, dx & mask);
 156       put_bits(pb, nbits, dy & mask);
 157     }
 158 }
 159
 160 #define FRAC_BITS 16
 161
 162 /* put matrix (not size optimized */
 163 static void put_swf_matrix(ByteIOContext *pb,
 164                            int a, int b, int c, int d, int tx, int ty)
 165 {
 166     PutBitContext p;
 167     uint8_t buf[256];
 168
 169     init_put_bits(&p, buf, sizeof(buf), NULL, NULL);
 170
 171     put_bits(&p, 1, 1); /* a, d present */
 172     put_bits(&p, 5, 20); /* nb bits */
 173     put_bits(&p, 20, a);
 174     put_bits(&p, 20, d);
 175
 176     put_bits(&p, 1, 1); /* b, c present */
 177     put_bits(&p, 5, 20); /* nb bits */
 178     put_bits(&p, 20, c);
 179     put_bits(&p, 20, b);
 180
 181     put_bits(&p, 5, 20); /* nb bits */
 182     put_bits(&p, 20, tx);
 183     put_bits(&p, 20, ty);
 184
 185     flush_put_bits(&p);
 186     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);
 187 }
 188
 189 /* XXX: handle audio only */
 190 static int swf_write_header(AVFormatContext *s)
 191 {
 192     SWFContext *swf;
 193     ByteIOContext *pb = &s->pb;
 194     AVCodecContext *enc, *audio_enc, *video_enc;
 195     PutBitContext p;
 196     uint8_t buf1[256];
 197     int i, width, height, rate, rate_base;
 198
 199     swf = av_malloc(sizeof(SWFContext));
 200     if (!swf)
 201         return -1;
 202     s->priv_data = swf;
 203
 204     video_enc = NULL;
 205     audio_enc = NULL;
 206     for(i=0;i<s->nb_streams;i++) {
 207         enc = &s->streams[i]->codec;
 208         if (enc->codec_type == CODEC_TYPE_AUDIO)
 209             audio_enc = enc;
 210         else
 211             video_enc = enc;
 212     }
 213
 214     if (!video_enc) {
 215         /* currenty, cannot work correctly if audio only */
 216         width = 320;
 217         height = 200;
 218         rate = 10;
 219         rate_base= 1;
 220     } else {
 221         width = video_enc->width;
 222         height = video_enc->height;
 223         rate = video_enc->frame_rate;
 224         rate_base = video_enc->frame_rate_base;
 225     }
 226
 227     put_tag(pb, "FWS");
 228     put_byte(pb, 4); /* version (should use 4 for mpeg audio support) */
 229     put_le32(pb, DUMMY_FILE_SIZE); /* dummy size
 230                                       (will be patched if not streamed) */
 231
 232     put_swf_rect(pb, 0, width, 0, height);
 233     put_le16(pb, (rate * 256) / rate_base); /* frame rate */
 234     swf->duration_pos = url_ftell(pb);
 235     put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
 236
 237     /* define a shape with the jpeg inside */
 238
 239     put_swf_tag(s, TAG_DEFINESHAPE);
 240
 241     put_le16(pb, SHAPE_ID); /* ID of shape */
 242     /* bounding rectangle */
 243     put_swf_rect(pb, 0, width, 0, height);
 244     /* style info */
 245     put_byte(pb, 1); /* one fill style */
 246     put_byte(pb, 0x41); /* clipped bitmap fill */
 247     put_le16(pb, BITMAP_ID); /* bitmap ID */
 248     /* position of the bitmap */
 249     put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
 250                    0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
 251     put_byte(pb, 0); /* no line style */
 252
 253     /* shape drawing */
 254     init_put_bits(&p, buf1, sizeof(buf1), NULL, NULL);
 255     put_bits(&p, 4, 1); /* one fill bit */
 256     put_bits(&p, 4, 0); /* zero line bit */
 257
 258     put_bits(&p, 1, 0); /* not an edge */
 259     put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);
 260     put_bits(&p, 5, 1); /* nbits */
 261     put_bits(&p, 1, 0); /* X */
 262     put_bits(&p, 1, 0); /* Y */
 263     put_bits(&p, 1, 1); /* set fill style 1 */
 264
 265     /* draw the rectangle ! */
 266     put_swf_line_edge(&p, width, 0);
 267     put_swf_line_edge(&p, 0, height);
 268     put_swf_line_edge(&p, -width, 0);
 269     put_swf_line_edge(&p, 0, -height);
 270
 271     /* end of shape */
 272     put_bits(&p, 1, 0); /* not an edge */
 273     put_bits(&p, 5, 0);
 274
 275     flush_put_bits(&p);
 276     put_buffer(pb, buf1, pbBufPtr(&p) - p.buf);
 277
 278     put_swf_end_tag(s);
 279
 280
 281     if (audio_enc) {
 282         int v;
 283
 284         /* start sound */
 285
 286         v = 0;
 287         switch(audio_enc->sample_rate) {
 288         case 11025:
 289             v |= 1 << 2;
 290             break;
 291         case 22050:
 292             v |= 2 << 2;
 293             break;
 294         case 44100:
 295             v |= 3 << 2;
 296             break;
 297         default:
 298             /* not supported */
 299             av_free(swf);
 300             return -1;
 301         }
 302         if (audio_enc->channels == 2)
 303             v |= 1;
 304         v |= 0x20; /* mp3 compressed */
 305         v |= 0x02; /* 16 bits */
 306
 307         put_swf_tag(s, TAG_STREAMHEAD);
 308         put_byte(&s->pb, 0);
 309         put_byte(&s->pb, v);
 310         put_le16(&s->pb, (audio_enc->sample_rate * rate_base) / rate);  /* avg samples per frame */
 311
 312
 313         put_swf_end_tag(s);
 314     }
 315
 316     put_flush_packet(&s->pb);
 317     return 0;
 318 }
 319
 320 static int swf_write_video(AVFormatContext *s,
 321                            AVCodecContext *enc, const uint8_t *buf, int size)
 322 {
 323     ByteIOContext *pb = &s->pb;
 324     static int tag_id = 0;
 325
 326     if (enc->frame_number > 1) {
 327         /* remove the shape */
 328         put_swf_tag(s, TAG_REMOVEOBJECT);
 329         put_le16(pb, SHAPE_ID); /* shape ID */
 330         put_le16(pb, 1); /* depth */
 331         put_swf_end_tag(s);
 332
 333         /* free the bitmap */
 334         put_swf_tag(s, TAG_FREECHARACTER);
 335         put_le16(pb, BITMAP_ID);
 336         put_swf_end_tag(s);
 337     }
 338
 339     put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
 340
 341     put_le16(pb, tag_id); /* ID of the image */
 342
 343     /* a dummy jpeg header seems to be required */
 344     put_byte(pb, 0xff);
 345     put_byte(pb, 0xd8);
 346     put_byte(pb, 0xff);
 347     put_byte(pb, 0xd9);
 348     /* write the jpeg image */
 349     put_buffer(pb, buf, size);
 350
 351     put_swf_end_tag(s);
 352
 353     /* draw the shape */
 354
 355     put_swf_tag(s, TAG_PLACEOBJECT);
 356     put_le16(pb, SHAPE_ID); /* shape ID */
 357     put_le16(pb, 1); /* depth */
 358     put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
 359     put_swf_end_tag(s);
 360
 361     /* output the frame */
 362     put_swf_tag(s, TAG_SHOWFRAME);
 363     put_swf_end_tag(s);
 364
 365     put_flush_packet(&s->pb);
 366     return 0;
 367 }
 368
 369 static int swf_write_audio(AVFormatContext *s, const uint8_t *buf, int size)
 370 {
 371     ByteIOContext *pb = &s->pb;
 372
 373     put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
 374
 375     put_buffer(pb, buf, size);
 376
 377     put_swf_end_tag(s);
 378     put_flush_packet(&s->pb);
 379     return 0;
 380 }
 381
 382 static int swf_write_packet(AVFormatContext *s, int stream_index,
 383                            const uint8_t *buf, int size, int64_t pts)
 384 {
 385     AVCodecContext *codec = &s->streams[stream_index]->codec;
 386     if (codec->codec_type == CODEC_TYPE_AUDIO)
 387         return swf_write_audio(s, buf, size);
 388     else
 389         return swf_write_video(s, codec, buf, size);
 390 }
 391
 392 static int swf_write_trailer(AVFormatContext *s)
 393 {
 394     SWFContext *swf = s->priv_data;
 395     ByteIOContext *pb = &s->pb;
 396     AVCodecContext *enc, *video_enc;
 397     int file_size, i;
 398
 399     video_enc = NULL;
 400     for(i=0;i<s->nb_streams;i++) {
 401         enc = &s->streams[i]->codec;
 402         if (enc->codec_type == CODEC_TYPE_VIDEO)
 403             video_enc = enc;
 404     }
 405
 406     put_swf_tag(s, TAG_END);
 407     put_swf_end_tag(s);
 408
 409     put_flush_packet(&s->pb);
 410
 411     /* patch file size and number of frames if not streamed */
 412     if (!url_is_streamed(&s->pb) && video_enc) {
 413         file_size = url_ftell(pb);
 414         url_fseek(pb, 4, SEEK_SET);
 415         put_le32(pb, file_size);
 416         url_fseek(pb, swf->duration_pos, SEEK_SET);
 417         put_le16(pb, video_enc->frame_number);
 418     }
 419     return 0;
 420 }
 421
 422 /***********************************/
 423 /* just to extract MP3 from swf */
 424
 425 static int get_swf_tag(ByteIOContext *pb, int *len_ptr)
 426 {
 427     int tag, len;
 428
 429     if (url_feof(pb))
 430         return -1;
 431
 432     tag = get_le16(pb);
 433     len = tag & 0x3f;
 434     tag = tag >> 6;
 435     if (len == 0x3f) {
 436         len = get_le32(pb);
 437     }
 438     *len_ptr = len;
 439     return tag;
 440 }
 441
 442
 443 static int swf_probe(AVProbeData *p)
 444 {
 445     /* check file header */
 446     if (p->buf_size <= 16)
 447         return 0;
 448     if (p->buf[0] == 'F' && p->buf[1] == 'W' &&
 449         p->buf[2] == 'S')
 450         return AVPROBE_SCORE_MAX;
 451     else
 452         return 0;
 453 }
 454
 455 static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 456 {
 457     ByteIOContext *pb = &s->pb;
 458     int nbits, len, frame_rate, tag, v;
 459     AVStream *st;
 460
 461     if ((get_be32(pb) & 0xffffff00) != MKBETAG('F', 'W', 'S', 0))
 462         return -EIO;
 463     get_le32(pb);
 464     /* skip rectangle size */
 465     nbits = get_byte(pb) >> 3;
 466     len = (4 * nbits - 3 + 7) / 8;
 467     url_fskip(pb, len);
 468     frame_rate = get_le16(pb);
 469     get_le16(pb); /* frame count */
 470
 471     for(;;) {
 472         tag = get_swf_tag(pb, &len);
 473         if (tag < 0) {
 474             fprintf(stderr, "No streaming found in SWF\n");
 475             return -EIO;
 476         }
 477         if (tag == TAG_STREAMHEAD) {
 478             /* streaming found */
 479             get_byte(pb);
 480             v = get_byte(pb);
 481             get_le16(pb);
 482             /* if mp3 streaming found, OK */
 483             if ((v & 0x20) != 0) {
 484                 st = av_new_stream(s, 0);
 485                 if (!st)
 486                     return -ENOMEM;
 487
 488                 if (v & 0x01)
 489                     st->codec.channels = 2;
 490                 else
 491                     st->codec.channels = 1;
 492
 493                 switch((v>> 2) & 0x03) {
 494                 case 1:
 495                     st->codec.sample_rate = 11025;
 496                     break;
 497                 case 2:
 498                     st->codec.sample_rate = 22050;
 499                     break;
 500                 case 3:
 501                     st->codec.sample_rate = 44100;
 502                     break;
 503                 default:
 504                     av_free(st);
 505                     return -EIO;
 506                 }
 507                 st->codec.codec_type = CODEC_TYPE_AUDIO;
 508                 st->codec.codec_id = CODEC_ID_MP2;
 509                 break;
 510             }
 511         } else {
 512             url_fskip(pb, len);
 513         }
 514     }
 515
 516     return 0;
 517 }
 518
 519 static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
 520 {
 521     ByteIOContext *pb = &s->pb;
 522     int tag, len;
 523
 524     for(;;) {
 525         tag = get_swf_tag(pb, &len);
 526         if (tag < 0)
 527             return -EIO;
 528         if (tag == TAG_STREAMBLOCK) {
 529             av_new_packet(pkt, len);
 530             get_buffer(pb, pkt->data, pkt->size);
 531             break;
 532         } else {
 533             url_fskip(pb, len);
 534         }
 535     }
 536     return 0;
 537 }
 538
 539 static int swf_read_close(AVFormatContext *s)
 540 {
 541      return 0;
 542 }
 543
 544 static AVInputFormat swf_iformat = {
 545     "swf",
 546     "Flash format",
 547     0,
 548     swf_probe,
 549     swf_read_header,
 550     swf_read_packet,
 551     swf_read_close,
 552 };
 553
 554 static AVOutputFormat swf_oformat = {
 555     "swf",
 556     "Flash format",
 557     "application/x-shockwave-flash",
 558     "swf",
 559     sizeof(SWFContext),
 560     CODEC_ID_MP2,
 561     CODEC_ID_MJPEG,
 562     swf_write_header,
 563     swf_write_packet,
 564     swf_write_trailer,
 565 };
 566
 567 int swf_init(void)
 568 {
 569     av_register_input_format(&swf_iformat);
 570     av_register_output_format(&swf_oformat);
 571     return 0;
 572 }