libavformat/swf.c

   1 /*
   2  * Flash Compatible Streaming Format
   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 #include "avformat.h"
  23 #include "bitstream.h"
  24 #include "riff.h"    /* for CodecTag */
  25
  26 /* should have a generic way to indicate probable size */
  27 #define DUMMY_FILE_SIZE   (100 * 1024 * 1024)
  28 #define DUMMY_DURATION    600 /* in seconds */
  29
  30 #define TAG_END           0
  31 #define TAG_SHOWFRAME     1
  32 #define TAG_DEFINESHAPE   2
  33 #define TAG_FREECHARACTER 3
  34 #define TAG_PLACEOBJECT   4
  35 #define TAG_REMOVEOBJECT  5
  36 #define TAG_STREAMHEAD    18
  37 #define TAG_STREAMBLOCK   19
  38 #define TAG_JPEG2         21
  39 #define TAG_PLACEOBJECT2  26
  40 #define TAG_STREAMHEAD2   45
  41 #define TAG_VIDEOSTREAM   60
  42 #define TAG_VIDEOFRAME    61
  43 #define TAG_FILEATTRIBUTES 69
  44
  45 #define TAG_LONG         0x100
  46
  47 /* flags for shape definition */
  48 #define FLAG_MOVETO      0x01
  49 #define FLAG_SETFILL0    0x02
  50 #define FLAG_SETFILL1    0x04
  51
  52 #define AUDIO_FIFO_SIZE 65536
  53
  54 /* character id used */
  55 #define BITMAP_ID 0
  56 #define VIDEO_ID 0
  57 #define SHAPE_ID  1
  58
  59 #undef NDEBUG
  60 #include <assert.h>
  61
  62 typedef struct {
  63     int audio_stream_index;
  64     offset_t duration_pos;
  65     offset_t tag_pos;
  66
  67     int samples_per_frame;
  68     int sound_samples;
  69     int swf_frame_number;
  70     int video_frame_number;
  71     int frame_rate;
  72     int tag;
  73
  74     uint8_t audio_fifo[AUDIO_FIFO_SIZE];
  75     int audio_in_pos;
  76
  77     int video_type;
  78     int audio_type;
  79 } SWFContext;
  80
  81 static const AVCodecTag swf_codec_tags[] = {
  82     {CODEC_ID_FLV1, 0x02},
  83     {CODEC_ID_VP6F, 0x04},
  84     {0, 0},
  85 };
  86
  87 static const AVCodecTag swf_audio_codec_tags[] = {
  88     {CODEC_ID_PCM_S16LE,  0x00},
  89     {CODEC_ID_ADPCM_SWF,  0x01},
  90     {CODEC_ID_MP3,        0x02},
  91     {CODEC_ID_PCM_S16LE,  0x03},
  92   //{CODEC_ID_NELLYMOSER, 0x06},
  93     {0, 0},
  94 };
  95
  96 #ifdef CONFIG_MUXERS
  97 static void put_swf_tag(AVFormatContext *s, int tag)
  98 {
  99     SWFContext *swf = s->priv_data;
 100     ByteIOContext *pb = s->pb;
 101
 102     swf->tag_pos = url_ftell(pb);
 103     swf->tag = tag;
 104     /* reserve some room for the tag */
 105     if (tag & TAG_LONG) {
 106         put_le16(pb, 0);
 107         put_le32(pb, 0);
 108     } else {
 109         put_le16(pb, 0);
 110     }
 111 }
 112
 113 static void put_swf_end_tag(AVFormatContext *s)
 114 {
 115     SWFContext *swf = s->priv_data;
 116     ByteIOContext *pb = s->pb;
 117     offset_t pos;
 118     int tag_len, tag;
 119
 120     pos = url_ftell(pb);
 121     tag_len = pos - swf->tag_pos - 2;
 122     tag = swf->tag;
 123     url_fseek(pb, swf->tag_pos, SEEK_SET);
 124     if (tag & TAG_LONG) {
 125         tag &= ~TAG_LONG;
 126         put_le16(pb, (tag << 6) | 0x3f);
 127         put_le32(pb, tag_len - 4);
 128     } else {
 129         assert(tag_len < 0x3f);
 130         put_le16(pb, (tag << 6) | tag_len);
 131     }
 132     url_fseek(pb, pos, SEEK_SET);
 133 }
 134
 135 static inline void max_nbits(int *nbits_ptr, int val)
 136 {
 137     int n;
 138
 139     if (val == 0)
 140         return;
 141     val = abs(val);
 142     n = 1;
 143     while (val != 0) {
 144         n++;
 145         val >>= 1;
 146     }
 147     if (n > *nbits_ptr)
 148         *nbits_ptr = n;
 149 }
 150
 151 static void put_swf_rect(ByteIOContext *pb,
 152                          int xmin, int xmax, int ymin, int ymax)
 153 {
 154     PutBitContext p;
 155     uint8_t buf[256];
 156     int nbits, mask;
 157
 158     init_put_bits(&p, buf, sizeof(buf));
 159
 160     nbits = 0;
 161     max_nbits(&nbits, xmin);
 162     max_nbits(&nbits, xmax);
 163     max_nbits(&nbits, ymin);
 164     max_nbits(&nbits, ymax);
 165     mask = (1 << nbits) - 1;
 166
 167     /* rectangle info */
 168     put_bits(&p, 5, nbits);
 169     put_bits(&p, nbits, xmin & mask);
 170     put_bits(&p, nbits, xmax & mask);
 171     put_bits(&p, nbits, ymin & mask);
 172     put_bits(&p, nbits, ymax & mask);
 173
 174     flush_put_bits(&p);
 175     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);
 176 }
 177
 178 static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
 179 {
 180     int nbits, mask;
 181
 182     put_bits(pb, 1, 1); /* edge */
 183     put_bits(pb, 1, 1); /* line select */
 184     nbits = 2;
 185     max_nbits(&nbits, dx);
 186     max_nbits(&nbits, dy);
 187
 188     mask = (1 << nbits) - 1;
 189     put_bits(pb, 4, nbits - 2); /* 16 bits precision */
 190     if (dx == 0) {
 191         put_bits(pb, 1, 0);
 192         put_bits(pb, 1, 1);
 193         put_bits(pb, nbits, dy & mask);
 194     } else if (dy == 0) {
 195         put_bits(pb, 1, 0);
 196         put_bits(pb, 1, 0);
 197         put_bits(pb, nbits, dx & mask);
 198     } else {
 199         put_bits(pb, 1, 1);
 200         put_bits(pb, nbits, dx & mask);
 201         put_bits(pb, nbits, dy & mask);
 202     }
 203 }
 204
 205 #define FRAC_BITS 16
 206
 207 /* put matrix */
 208 static void put_swf_matrix(ByteIOContext *pb,
 209                            int a, int b, int c, int d, int tx, int ty)
 210 {
 211     PutBitContext p;
 212     uint8_t buf[256];
 213     int nbits;
 214
 215     init_put_bits(&p, buf, sizeof(buf));
 216
 217     put_bits(&p, 1, 1); /* a, d present */
 218     nbits = 1;
 219     max_nbits(&nbits, a);
 220     max_nbits(&nbits, d);
 221     put_bits(&p, 5, nbits); /* nb bits */
 222     put_bits(&p, nbits, a);
 223     put_bits(&p, nbits, d);
 224
 225     put_bits(&p, 1, 1); /* b, c present */
 226     nbits = 1;
 227     max_nbits(&nbits, c);
 228     max_nbits(&nbits, b);
 229     put_bits(&p, 5, nbits); /* nb bits */
 230     put_bits(&p, nbits, c);
 231     put_bits(&p, nbits, b);
 232
 233     nbits = 1;
 234     max_nbits(&nbits, tx);
 235     max_nbits(&nbits, ty);
 236     put_bits(&p, 5, nbits); /* nb bits */
 237     put_bits(&p, nbits, tx);
 238     put_bits(&p, nbits, ty);
 239
 240     flush_put_bits(&p);
 241     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);
 242 }
 243
 244 /* */
 245 static int swf_write_header(AVFormatContext *s)
 246 {
 247     SWFContext *swf = s->priv_data;
 248     ByteIOContext *pb = s->pb;
 249     AVCodecContext *enc, *audio_enc, *video_enc;
 250     PutBitContext p;
 251     uint8_t buf1[256];
 252     int i, width, height, rate, rate_base;
 253     int is_avm2;
 254
 255     swf->audio_in_pos = 0;
 256     swf->sound_samples = 0;
 257     swf->swf_frame_number = 0;
 258     swf->video_frame_number = 0;
 259
 260     video_enc = NULL;
 261     audio_enc = NULL;
 262     for(i=0;i<s->nb_streams;i++) {
 263         enc = s->streams[i]->codec;
 264         if (enc->codec_type == CODEC_TYPE_AUDIO) {
 265             if (enc->codec_id == CODEC_ID_MP3) {
 266                 if (!enc->frame_size) {
 267                     av_log(s, AV_LOG_ERROR, "audio frame size not set\n");
 268                     return -1;
 269                 }
 270                 audio_enc = enc;
 271             } else {
 272                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports MP3\n");
 273                 return -1;
 274             }
 275         } else {
 276             if (enc->codec_id == CODEC_ID_VP6F ||
 277                 enc->codec_id == CODEC_ID_FLV1 ||
 278                 enc->codec_id == CODEC_ID_MJPEG) {
 279                 video_enc = enc;
 280             } else {
 281                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV1 and MJPEG\n");
 282                 return -1;
 283             }
 284         }
 285     }
 286
 287     if (!video_enc) {
 288         /* currently, cannot work correctly if audio only */
 289         swf->video_type = 0;
 290         width = 320;
 291         height = 200;
 292         rate = 10;
 293         rate_base= 1;
 294     } else {
 295         swf->video_type = video_enc->codec_id;
 296         width = video_enc->width;
 297         height = video_enc->height;
 298         rate = video_enc->time_base.den;
 299         rate_base = video_enc->time_base.num;
 300     }
 301
 302     if (!audio_enc) {
 303         swf->audio_type = 0;
 304         swf->samples_per_frame = (44100. * rate_base) / rate;
 305     } else {
 306         swf->audio_type = audio_enc->codec_id;
 307         swf->samples_per_frame = (audio_enc->sample_rate * rate_base) / rate;
 308     }
 309
 310     is_avm2 = !strcmp("avm2", s->oformat->name);
 311
 312     put_tag(pb, "FWS");
 313     if (is_avm2) {
 314         put_byte(pb, 9);
 315     } else if (video_enc && video_enc->codec_id == CODEC_ID_VP6F) {
 316         put_byte(pb, 8); /* version (version 8 and above support VP6 codec) */
 317     } else if (video_enc && video_enc->codec_id == CODEC_ID_FLV1) {
 318         put_byte(pb, 6); /* version (version 6 and above support FLV1 codec) */
 319     } else {
 320         put_byte(pb, 4); /* version (should use 4 for mpeg audio support) */
 321     }
 322     put_le32(pb, DUMMY_FILE_SIZE); /* dummy size
 323                                       (will be patched if not streamed) */
 324
 325     put_swf_rect(pb, 0, width * 20, 0, height * 20);
 326     put_le16(pb, (rate * 256) / rate_base); /* frame rate */
 327     swf->duration_pos = url_ftell(pb);
 328     put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
 329
 330     /* avm2/swf v9 (also v8?) files require a file attribute tag */
 331     if (is_avm2) {
 332         put_swf_tag(s, TAG_FILEATTRIBUTES);
 333         put_le32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
 334         put_swf_end_tag(s);
 335     }
 336
 337     /* define a shape with the jpeg inside */
 338     if (video_enc && (video_enc->codec_id == CODEC_ID_VP6F ||
 339                        video_enc->codec_id == CODEC_ID_FLV1)) {
 340     } else if (video_enc && video_enc->codec_id == CODEC_ID_MJPEG) {
 341         put_swf_tag(s, TAG_DEFINESHAPE);
 342
 343         put_le16(pb, SHAPE_ID); /* ID of shape */
 344         /* bounding rectangle */
 345         put_swf_rect(pb, 0, width, 0, height);
 346         /* style info */
 347         put_byte(pb, 1); /* one fill style */
 348         put_byte(pb, 0x41); /* clipped bitmap fill */
 349         put_le16(pb, BITMAP_ID); /* bitmap ID */
 350         /* position of the bitmap */
 351         put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,
 352                        0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);
 353         put_byte(pb, 0); /* no line style */
 354
 355         /* shape drawing */
 356         init_put_bits(&p, buf1, sizeof(buf1));
 357         put_bits(&p, 4, 1); /* one fill bit */
 358         put_bits(&p, 4, 0); /* zero line bit */
 359
 360         put_bits(&p, 1, 0); /* not an edge */
 361         put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);
 362         put_bits(&p, 5, 1); /* nbits */
 363         put_bits(&p, 1, 0); /* X */
 364         put_bits(&p, 1, 0); /* Y */
 365         put_bits(&p, 1, 1); /* set fill style 1 */
 366
 367         /* draw the rectangle ! */
 368         put_swf_line_edge(&p, width, 0);
 369         put_swf_line_edge(&p, 0, height);
 370         put_swf_line_edge(&p, -width, 0);
 371         put_swf_line_edge(&p, 0, -height);
 372
 373         /* end of shape */
 374         put_bits(&p, 1, 0); /* not an edge */
 375         put_bits(&p, 5, 0);
 376
 377         flush_put_bits(&p);
 378         put_buffer(pb, buf1, pbBufPtr(&p) - p.buf);
 379
 380         put_swf_end_tag(s);
 381     }
 382
 383     if (audio_enc && audio_enc->codec_id == CODEC_ID_MP3) {
 384         int v;
 385
 386         /* start sound */
 387         put_swf_tag(s, TAG_STREAMHEAD2);
 388
 389         v = 0;
 390         switch(audio_enc->sample_rate) {
 391         case 11025:
 392             v |= 1 << 2;
 393             break;
 394         case 22050:
 395             v |= 2 << 2;
 396             break;
 397         case 44100:
 398             v |= 3 << 2;
 399             break;
 400         default:
 401             /* not supported */
 402             av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
 403             return -1;
 404         }
 405         v |= 0x02; /* 16 bit playback */
 406         if (audio_enc->channels == 2)
 407             v |= 0x01; /* stereo playback */
 408         put_byte(s->pb, v);
 409         v |= 0x20; /* mp3 compressed */
 410         put_byte(s->pb, v);
 411         put_le16(s->pb, swf->samples_per_frame);  /* avg samples per frame */
 412         put_le16(s->pb, 0);
 413
 414         put_swf_end_tag(s);
 415     }
 416
 417     put_flush_packet(s->pb);
 418     return 0;
 419 }
 420
 421 static int swf_write_video(AVFormatContext *s,
 422                            AVCodecContext *enc, const uint8_t *buf, int size)
 423 {
 424     SWFContext *swf = s->priv_data;
 425     ByteIOContext *pb = s->pb;
 426
 427     /* Flash Player limit */
 428     if (swf->swf_frame_number == 16000) {
 429         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
 430     }
 431
 432     if (swf->video_type == CODEC_ID_VP6F ||
 433         swf->video_type == CODEC_ID_FLV1) {
 434         if (swf->video_frame_number == 0) {
 435             /* create a new video object */
 436             put_swf_tag(s, TAG_VIDEOSTREAM);
 437             put_le16(pb, VIDEO_ID);
 438             put_le16(pb, 15000); /* hard flash player limit */
 439             put_le16(pb, enc->width);
 440             put_le16(pb, enc->height);
 441             put_byte(pb, 0);
 442             put_byte(pb,codec_get_tag(swf_codec_tags,swf->video_type));
 443             put_swf_end_tag(s);
 444
 445             /* place the video object for the first time */
 446             put_swf_tag(s, TAG_PLACEOBJECT2);
 447             put_byte(pb, 0x36);
 448             put_le16(pb, 1);
 449             put_le16(pb, VIDEO_ID);
 450             put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
 451             put_le16(pb, swf->video_frame_number);
 452             put_byte(pb, 'v');
 453             put_byte(pb, 'i');
 454             put_byte(pb, 'd');
 455             put_byte(pb, 'e');
 456             put_byte(pb, 'o');
 457             put_byte(pb, 0x00);
 458             put_swf_end_tag(s);
 459         } else {
 460             /* mark the character for update */
 461             put_swf_tag(s, TAG_PLACEOBJECT2);
 462             put_byte(pb, 0x11);
 463             put_le16(pb, 1);
 464             put_le16(pb, swf->video_frame_number);
 465             put_swf_end_tag(s);
 466         }
 467
 468         /* set video frame data */
 469         put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
 470         put_le16(pb, VIDEO_ID);
 471         put_le16(pb, swf->video_frame_number++);
 472         put_buffer(pb, buf, size);
 473         put_swf_end_tag(s);
 474     } else if (swf->video_type == CODEC_ID_MJPEG) {
 475         if (swf->swf_frame_number > 0) {
 476             /* remove the shape */
 477             put_swf_tag(s, TAG_REMOVEOBJECT);
 478             put_le16(pb, SHAPE_ID); /* shape ID */
 479             put_le16(pb, 1); /* depth */
 480             put_swf_end_tag(s);
 481
 482             /* free the bitmap */
 483             put_swf_tag(s, TAG_FREECHARACTER);
 484             put_le16(pb, BITMAP_ID);
 485             put_swf_end_tag(s);
 486         }
 487
 488         put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
 489
 490         put_le16(pb, BITMAP_ID); /* ID of the image */
 491
 492         /* a dummy jpeg header seems to be required */
 493         put_byte(pb, 0xff);
 494         put_byte(pb, 0xd8);
 495         put_byte(pb, 0xff);
 496         put_byte(pb, 0xd9);
 497         /* write the jpeg image */
 498         put_buffer(pb, buf, size);
 499
 500         put_swf_end_tag(s);
 501
 502         /* draw the shape */
 503
 504         put_swf_tag(s, TAG_PLACEOBJECT);
 505         put_le16(pb, SHAPE_ID); /* shape ID */
 506         put_le16(pb, 1); /* depth */
 507         put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
 508         put_swf_end_tag(s);
 509     } else {
 510         /* invalid codec */
 511     }
 512
 513     swf->swf_frame_number ++;
 514
 515     /* streaming sound always should be placed just before showframe tags */
 516     if (swf->audio_type && swf->audio_in_pos) {
 517         put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
 518         put_le16(pb, swf->sound_samples);
 519         put_le16(pb, 0); // seek samples
 520         put_buffer(pb, swf->audio_fifo, swf->audio_in_pos);
 521         put_swf_end_tag(s);
 522
 523         /* update FIFO */
 524         swf->sound_samples = 0;
 525         swf->audio_in_pos = 0;
 526     }
 527
 528     /* output the frame */
 529     put_swf_tag(s, TAG_SHOWFRAME);
 530     put_swf_end_tag(s);
 531
 532     put_flush_packet(s->pb);
 533
 534     return 0;
 535 }
 536
 537 static int swf_write_audio(AVFormatContext *s,
 538                            AVCodecContext *enc, const uint8_t *buf, int size)
 539 {
 540     SWFContext *swf = s->priv_data;
 541
 542     /* Flash Player limit */
 543     if (swf->swf_frame_number == 16000) {
 544         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
 545     }
 546
 547     if (swf->audio_in_pos + size >= AUDIO_FIFO_SIZE) {
 548         av_log(s, AV_LOG_ERROR, "audio fifo too small to mux audio essence\n");
 549         return -1;
 550     }
 551
 552     memcpy(swf->audio_fifo +  swf->audio_in_pos, buf, size);
 553     swf->audio_in_pos += size;
 554     swf->sound_samples += enc->frame_size;
 555
 556     /* if audio only stream make sure we add swf frames */
 557     if (swf->video_type == 0) {
 558         swf_write_video(s, enc, 0, 0);
 559     }
 560
 561     return 0;
 562 }
 563
 564 static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
 565 {
 566     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
 567     if (codec->codec_type == CODEC_TYPE_AUDIO)
 568         return swf_write_audio(s, codec, pkt->data, pkt->size);
 569     else
 570         return swf_write_video(s, codec, pkt->data, pkt->size);
 571 }
 572
 573 static int swf_write_trailer(AVFormatContext *s)
 574 {
 575     SWFContext *swf = s->priv_data;
 576     ByteIOContext *pb = s->pb;
 577     AVCodecContext *enc, *video_enc;
 578     int file_size, i;
 579
 580     video_enc = NULL;
 581     for(i=0;i<s->nb_streams;i++) {
 582         enc = s->streams[i]->codec;
 583         if (enc->codec_type == CODEC_TYPE_VIDEO)
 584             video_enc = enc;
 585     }
 586
 587     put_swf_tag(s, TAG_END);
 588     put_swf_end_tag(s);
 589
 590     put_flush_packet(s->pb);
 591
 592     /* patch file size and number of frames if not streamed */
 593     if (!url_is_streamed(s->pb) && video_enc) {
 594         file_size = url_ftell(pb);
 595         url_fseek(pb, 4, SEEK_SET);
 596         put_le32(pb, file_size);
 597         url_fseek(pb, swf->duration_pos, SEEK_SET);
 598         put_le16(pb, video_enc->frame_number);
 599         url_fseek(pb, file_size, SEEK_SET);
 600     }
 601     return 0;
 602 }
 603 #endif //CONFIG_MUXERS
 604
 605 /*********************************************/
 606 /* Extract FLV encoded frame and MP3 from swf
 607    Note that the detection of the real frame
 608    is inaccurate at this point as it can be
 609    quite tricky to determine, you almost certainly
 610    will get a bad audio/video sync */
 611
 612 static int get_swf_tag(ByteIOContext *pb, int *len_ptr)
 613 {
 614     int tag, len;
 615
 616     if (url_feof(pb))
 617         return -1;
 618
 619     tag = get_le16(pb);
 620     len = tag & 0x3f;
 621     tag = tag >> 6;
 622     if (len == 0x3f) {
 623         len = get_le32(pb);
 624     }
 625 //    av_log(NULL, AV_LOG_DEBUG, "Tag: %d - Len: %d\n", tag, len);
 626     *len_ptr = len;
 627     return tag;
 628 }
 629
 630
 631 static int swf_probe(AVProbeData *p)
 632 {
 633     /* check file header */
 634     if ((p->buf[0] == 'F' || p->buf[0] == 'C') && p->buf[1] == 'W' &&
 635         p->buf[2] == 'S')
 636         return AVPROBE_SCORE_MAX;
 637     else
 638         return 0;
 639 }
 640
 641 static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 642 {
 643     SWFContext *swf = s->priv_data;
 644     ByteIOContext *pb = s->pb;
 645     int nbits, len, tag;
 646
 647     tag = get_be32(pb) & 0xffffff00;
 648
 649     if (tag == MKBETAG('C', 'W', 'S', 0)) {
 650         av_log(s, AV_LOG_ERROR, "Compressed SWF format not supported\n");
 651         return AVERROR(EIO);
 652     }
 653     if (tag != MKBETAG('F', 'W', 'S', 0))
 654         return AVERROR(EIO);
 655     get_le32(pb);
 656     /* skip rectangle size */
 657     nbits = get_byte(pb) >> 3;
 658     len = (4 * nbits - 3 + 7) / 8;
 659     url_fskip(pb, len);
 660     swf->frame_rate = get_le16(pb); /* 8.8 fixed */
 661     get_le16(pb); /* frame count */
 662
 663     swf->samples_per_frame = 0;
 664     s->ctx_flags |= AVFMTCTX_NOHEADER;
 665     return 0;
 666 }
 667
 668 static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
 669 {
 670     SWFContext *swf = s->priv_data;
 671     ByteIOContext *pb = s->pb;
 672     AVStream *vst = NULL, *ast = NULL, *st = 0;
 673     int tag, len, i, frame, v;
 674
 675     for(;;) {
 676         tag = get_swf_tag(pb, &len);
 677         if (tag < 0)
 678             return AVERROR(EIO);
 679         if (tag == TAG_VIDEOSTREAM && !vst) {
 680             int ch_id = get_le16(pb);
 681             get_le16(pb);
 682             get_le16(pb);
 683             get_le16(pb);
 684             get_byte(pb);
 685             /* Check for FLV1 */
 686             vst = av_new_stream(s, ch_id);
 687             if (!vst)
 688                 return -1;
 689             vst->codec->codec_type = CODEC_TYPE_VIDEO;
 690             vst->codec->codec_id = codec_get_id(swf_codec_tags, get_byte(pb));
 691             av_set_pts_info(vst, 64, 256, swf->frame_rate);
 692             vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
 693             len -= 10;
 694         } else if ((tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) && !ast) {
 695             /* streaming found */
 696             int sample_rate_code;
 697             get_byte(pb);
 698             v = get_byte(pb);
 699             swf->samples_per_frame = get_le16(pb);
 700             ast = av_new_stream(s, -1); /* -1 to avoid clash with video stream ch_id */
 701             if (!ast)
 702                 return -1;
 703             swf->audio_stream_index = ast->index;
 704             ast->codec->channels = 1 + (v&1);
 705             ast->codec->codec_type = CODEC_TYPE_AUDIO;
 706             ast->codec->codec_id = codec_get_id(swf_audio_codec_tags, (v>>4) & 15);
 707             ast->need_parsing = AVSTREAM_PARSE_FULL;
 708             sample_rate_code= (v>>2) & 3;
 709             if (!sample_rate_code)
 710                 return AVERROR(EIO);
 711             ast->codec->sample_rate = 11025 << (sample_rate_code-1);
 712             av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
 713             len -= 4;
 714         } else if (tag == TAG_VIDEOFRAME) {
 715             int ch_id = get_le16(pb);
 716             len -= 2;
 717             for(i=0; i<s->nb_streams; i++) {
 718                 st = s->streams[i];
 719                 if (st->codec->codec_type == CODEC_TYPE_VIDEO && st->id == ch_id) {
 720                     frame = get_le16(pb);
 721                     av_get_packet(pb, pkt, len-2);
 722                     pkt->pts = frame;
 723                     pkt->stream_index = st->index;
 724                     return pkt->size;
 725                 }
 726             }
 727         } else if (tag == TAG_STREAMBLOCK) {
 728             st = s->streams[swf->audio_stream_index];
 729             if (st->codec->codec_id == CODEC_ID_MP3) {
 730                 url_fskip(pb, 4);
 731                 av_get_packet(pb, pkt, len-4);
 732             } else { // ADPCM, PCM
 733                 av_get_packet(pb, pkt, len);
 734             }
 735             pkt->stream_index = st->index;
 736             return pkt->size;
 737         } else if (tag == TAG_JPEG2) {
 738             for (i=0; i<s->nb_streams; i++) {
 739                 st = s->streams[i];
 740                 if (st->id == -2)
 741                     break;
 742             }
 743             if (i == s->nb_streams) {
 744                 vst = av_new_stream(s, -2); /* -2 to avoid clash with video stream and audio stream */
 745                 if (!vst)
 746                     return -1;
 747                 vst->codec->codec_type = CODEC_TYPE_VIDEO;
 748                 vst->codec->codec_id = CODEC_ID_MJPEG;
 749                 av_set_pts_info(vst, 64, 256, swf->frame_rate);
 750                 vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
 751                 st = vst;
 752             }
 753             get_le16(pb); /* BITMAP_ID */
 754             av_new_packet(pkt, len-2);
 755             get_buffer(pb, pkt->data, 4);
 756             if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
 757                 AV_RB32(pkt->data) == 0xffd9ffd8) {
 758                 /* old SWF files containing SOI/EOI as data start */
 759                 /* files created by swink have reversed tag */
 760                 pkt->size -= 4;
 761                 get_buffer(pb, pkt->data, pkt->size);
 762             } else {
 763                 get_buffer(pb, pkt->data + 4, pkt->size - 4);
 764             }
 765             pkt->stream_index = st->index;
 766             return pkt->size;
 767         }
 768         url_fskip(pb, len);
 769     }
 770     return 0;
 771 }
 772
 773 static int swf_read_close(AVFormatContext *s)
 774 {
 775     return 0;
 776 }
 777
 778 #ifdef CONFIG_SWF_DEMUXER
 779 AVInputFormat swf_demuxer = {
 780     "swf",
 781     "Flash format",
 782     sizeof(SWFContext),
 783     swf_probe,
 784     swf_read_header,
 785     swf_read_packet,
 786     swf_read_close,
 787 };
 788 #endif
 789 #ifdef CONFIG_SWF_MUXER
 790 AVOutputFormat swf_muxer = {
 791     "swf",
 792     "Flash format",
 793     "application/x-shockwave-flash",
 794     "swf",
 795     sizeof(SWFContext),
 796     CODEC_ID_MP3,
 797     CODEC_ID_FLV1,
 798     swf_write_header,
 799     swf_write_packet,
 800     swf_write_trailer,
 801 };
 802 #endif
 803 #ifdef CONFIG_AVM2_MUXER
 804 AVOutputFormat avm2_muxer = {
 805     "avm2",
 806     "Flash 9 (AVM2) format",
 807     "application/x-shockwave-flash",
 808     NULL,
 809     sizeof(SWFContext),
 810     CODEC_ID_MP3,
 811     CODEC_ID_FLV1,
 812     swf_write_header,
 813     swf_write_packet,
 814     swf_write_trailer,
 815 };
 816 #endif