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