falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13950 Commits
32 Branches
1.0GB
Tree: 0147b92ea5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0147b92ea5'
${ noResults }
FFmpeg/libavformat/swfenc.c

560 lines
16KB
Raw Blame History 

  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/bitstream.h"

  24. #include "avformat.h"

  25. #include "swf.h"

  26. 

  27. static void put_swf_tag(AVFormatContext *s, int tag)

  28. {

  29.     SWFContext *swf = s->priv_data;

  30.     ByteIOContext *pb = s->pb;

  31. 

  32.     swf->tag_pos = url_ftell(pb);

  33.     swf->tag = tag;

  34.     /* reserve some room for the tag */

  35.     if (tag & TAG_LONG) {

  36.         put_le16(pb, 0);

  37.         put_le32(pb, 0);

  38.     } else {

  39.         put_le16(pb, 0);

  40.     }

  41. }

  42. 

  43. static void put_swf_end_tag(AVFormatContext *s)

  44. {

  45.     SWFContext *swf = s->priv_data;

  46.     ByteIOContext *pb = s->pb;

  47.     offset_t pos;

  48.     int tag_len, tag;

  49. 

  50.     pos = url_ftell(pb);

  51.     tag_len = pos - swf->tag_pos - 2;

  52.     tag = swf->tag;

  53.     url_fseek(pb, swf->tag_pos, SEEK_SET);

  54.     if (tag & TAG_LONG) {

  55.         tag &= ~TAG_LONG;

  56.         put_le16(pb, (tag << 6) | 0x3f);

  57.         put_le32(pb, tag_len - 4);

  58.     } else {

  59.         assert(tag_len < 0x3f);

  60.         put_le16(pb, (tag << 6) | tag_len);

  61.     }

  62.     url_fseek(pb, pos, SEEK_SET);

  63. }

  64. 

  65. static inline void max_nbits(int *nbits_ptr, int val)

  66. {

  67.     int n;

  68. 

  69.     if (val == 0)

  70.         return;

  71.     val = abs(val);

  72.     n = 1;

  73.     while (val != 0) {

  74.         n++;

  75.         val >>= 1;

  76.     }

  77.     if (n > *nbits_ptr)

  78.         *nbits_ptr = n;

  79. }

  80. 

  81. static void put_swf_rect(ByteIOContext *pb,

  82.                          int xmin, int xmax, int ymin, int ymax)

  83. {

  84.     PutBitContext p;

  85.     uint8_t buf[256];

  86.     int nbits, mask;

  87. 

  88.     init_put_bits(&p, buf, sizeof(buf));

  89. 

  90.     nbits = 0;

  91.     max_nbits(&nbits, xmin);

  92.     max_nbits(&nbits, xmax);

  93.     max_nbits(&nbits, ymin);

  94.     max_nbits(&nbits, ymax);

  95.     mask = (1 << nbits) - 1;

  96. 

  97.     /* rectangle info */

  98.     put_bits(&p, 5, nbits);

  99.     put_bits(&p, nbits, xmin & mask);

  100.     put_bits(&p, nbits, xmax & mask);

  101.     put_bits(&p, nbits, ymin & mask);

  102.     put_bits(&p, nbits, ymax & mask);

  103. 

  104.     flush_put_bits(&p);

  105.     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);

  106. }

  107. 

  108. static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)

  109. {

  110.     int nbits, mask;

  111. 

  112.     put_bits(pb, 1, 1); /* edge */

  113.     put_bits(pb, 1, 1); /* line select */

  114.     nbits = 2;

  115.     max_nbits(&nbits, dx);

  116.     max_nbits(&nbits, dy);

  117. 

  118.     mask = (1 << nbits) - 1;

  119.     put_bits(pb, 4, nbits - 2); /* 16 bits precision */

  120.     if (dx == 0) {

  121.         put_bits(pb, 1, 0);

  122.         put_bits(pb, 1, 1);

  123.         put_bits(pb, nbits, dy & mask);

  124.     } else if (dy == 0) {

  125.         put_bits(pb, 1, 0);

  126.         put_bits(pb, 1, 0);

  127.         put_bits(pb, nbits, dx & mask);

  128.     } else {

  129.         put_bits(pb, 1, 1);

  130.         put_bits(pb, nbits, dx & mask);

  131.         put_bits(pb, nbits, dy & mask);

  132.     }

  133. }

  134. 

  135. #define FRAC_BITS 16

  136. 

  137. static void put_swf_matrix(ByteIOContext *pb,

  138.                            int a, int b, int c, int d, int tx, int ty)

  139. {

  140.     PutBitContext p;

  141.     uint8_t buf[256];

  142.     int nbits;

  143. 

  144.     init_put_bits(&p, buf, sizeof(buf));

  145. 

  146.     put_bits(&p, 1, 1); /* a, d present */

  147.     nbits = 1;

  148.     max_nbits(&nbits, a);

  149.     max_nbits(&nbits, d);

  150.     put_bits(&p, 5, nbits); /* nb bits */

  151.     put_bits(&p, nbits, a);

  152.     put_bits(&p, nbits, d);

  153. 

  154.     put_bits(&p, 1, 1); /* b, c present */

  155.     nbits = 1;

  156.     max_nbits(&nbits, c);

  157.     max_nbits(&nbits, b);

  158.     put_bits(&p, 5, nbits); /* nb bits */

  159.     put_bits(&p, nbits, c);

  160.     put_bits(&p, nbits, b);

  161. 

  162.     nbits = 1;

  163.     max_nbits(&nbits, tx);

  164.     max_nbits(&nbits, ty);

  165.     put_bits(&p, 5, nbits); /* nb bits */

  166.     put_bits(&p, nbits, tx);

  167.     put_bits(&p, nbits, ty);

  168. 

  169.     flush_put_bits(&p);

  170.     put_buffer(pb, buf, pbBufPtr(&p) - p.buf);

  171. }

  172. 

  173. static int swf_write_header(AVFormatContext *s)

  174. {

  175.     SWFContext *swf = s->priv_data;

  176.     ByteIOContext *pb = s->pb;

  177.     AVCodecContext *enc, *audio_enc, *video_enc;

  178.     PutBitContext p;

  179.     uint8_t buf1[256];

  180.     int i, width, height, rate, rate_base;

  181.     int is_avm2;

  182. 

  183.     swf->audio_in_pos = 0;

  184.     swf->sound_samples = 0;

  185.     swf->swf_frame_number = 0;

  186.     swf->video_frame_number = 0;

  187. 

  188.     video_enc = NULL;

  189.     audio_enc = NULL;

  190.     for(i=0;i<s->nb_streams;i++) {

  191.         enc = s->streams[i]->codec;

  192.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  193.             if (enc->codec_id == CODEC_ID_MP3) {

  194.                 if (!enc->frame_size) {

  195.                     av_log(s, AV_LOG_ERROR, "audio frame size not set\n");

  196.                     return -1;

  197.                 }

  198.                 audio_enc = enc;

  199.             } else {

  200.                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports MP3\n");

  201.                 return -1;

  202.             }

  203.         } else {

  204.             if (enc->codec_id == CODEC_ID_VP6F ||

  205.                 enc->codec_id == CODEC_ID_FLV1 ||

  206.                 enc->codec_id == CODEC_ID_MJPEG) {

  207.                 video_enc = enc;

  208.             } else {

  209.                 av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV1 and MJPEG\n");

  210.                 return -1;

  211.             }

  212.         }

  213.     }

  214. 

  215.     if (!video_enc) {

  216.         /* currently, cannot work correctly if audio only */

  217.         swf->video_type = 0;

  218.         width = 320;

  219.         height = 200;

  220.         rate = 10;

  221.         rate_base= 1;

  222.     } else {

  223.         swf->video_type = video_enc->codec_id;

  224.         width = video_enc->width;

  225.         height = video_enc->height;

  226.         rate = video_enc->time_base.den;

  227.         rate_base = video_enc->time_base.num;

  228.     }

  229. 

  230.     if (!audio_enc) {

  231.         swf->audio_type = 0;

  232.         swf->samples_per_frame = (44100. * rate_base) / rate;

  233.     } else {

  234.         swf->audio_type = audio_enc->codec_id;

  235.         swf->samples_per_frame = (audio_enc->sample_rate * rate_base) / rate;

  236.     }

  237. 

  238.     is_avm2 = !strcmp("avm2", s->oformat->name);

  239. 

  240.     put_tag(pb, "FWS");

  241.     if (is_avm2) {

  242.         put_byte(pb, 9);

  243.     } else if (video_enc && video_enc->codec_id == CODEC_ID_VP6F) {

  244.         put_byte(pb, 8); /* version (version 8 and above support VP6 codec) */

  245.     } else if (video_enc && video_enc->codec_id == CODEC_ID_FLV1) {

  246.         put_byte(pb, 6); /* version (version 6 and above support FLV1 codec) */

  247.     } else {

  248.         put_byte(pb, 4); /* version (should use 4 for mpeg audio support) */

  249.     }

  250.     put_le32(pb, DUMMY_FILE_SIZE); /* dummy size

  251.                                       (will be patched if not streamed) */

  252. 

  253.     put_swf_rect(pb, 0, width * 20, 0, height * 20);

  254.     put_le16(pb, (rate * 256) / rate_base); /* frame rate */

  255.     swf->duration_pos = url_ftell(pb);

  256.     put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */

  257. 

  258.     /* avm2/swf v9 (also v8?) files require a file attribute tag */

  259.     if (is_avm2) {

  260.         put_swf_tag(s, TAG_FILEATTRIBUTES);

  261.         put_le32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */

  262.         put_swf_end_tag(s);

  263.     }

  264. 

  265.     /* define a shape with the jpeg inside */

  266.     if (video_enc && (video_enc->codec_id == CODEC_ID_VP6F ||

  267.                        video_enc->codec_id == CODEC_ID_FLV1)) {

  268.     } else if (video_enc && video_enc->codec_id == CODEC_ID_MJPEG) {

  269.         put_swf_tag(s, TAG_DEFINESHAPE);

  270. 

  271.         put_le16(pb, SHAPE_ID); /* ID of shape */

  272.         /* bounding rectangle */

  273.         put_swf_rect(pb, 0, width, 0, height);

  274.         /* style info */

  275.         put_byte(pb, 1); /* one fill style */

  276.         put_byte(pb, 0x41); /* clipped bitmap fill */

  277.         put_le16(pb, BITMAP_ID); /* bitmap ID */

  278.         /* position of the bitmap */

  279.         put_swf_matrix(pb, (int)(1.0 * (1 << FRAC_BITS)), 0,

  280.                        0, (int)(1.0 * (1 << FRAC_BITS)), 0, 0);

  281.         put_byte(pb, 0); /* no line style */

  282. 

  283.         /* shape drawing */

  284.         init_put_bits(&p, buf1, sizeof(buf1));

  285.         put_bits(&p, 4, 1); /* one fill bit */

  286.         put_bits(&p, 4, 0); /* zero line bit */

  287. 

  288.         put_bits(&p, 1, 0); /* not an edge */

  289.         put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);

  290.         put_bits(&p, 5, 1); /* nbits */

  291.         put_bits(&p, 1, 0); /* X */

  292.         put_bits(&p, 1, 0); /* Y */

  293.         put_bits(&p, 1, 1); /* set fill style 1 */

  294. 

  295.         /* draw the rectangle ! */

  296.         put_swf_line_edge(&p, width, 0);

  297.         put_swf_line_edge(&p, 0, height);

  298.         put_swf_line_edge(&p, -width, 0);

  299.         put_swf_line_edge(&p, 0, -height);

  300. 

  301.         /* end of shape */

  302.         put_bits(&p, 1, 0); /* not an edge */

  303.         put_bits(&p, 5, 0);

  304. 

  305.         flush_put_bits(&p);

  306.         put_buffer(pb, buf1, pbBufPtr(&p) - p.buf);

  307. 

  308.         put_swf_end_tag(s);

  309.     }

  310. 

  311.     if (audio_enc && audio_enc->codec_id == CODEC_ID_MP3) {

  312.         int v;

  313. 

  314.         /* start sound */

  315.         put_swf_tag(s, TAG_STREAMHEAD2);

  316. 

  317.         v = 0;

  318.         switch(audio_enc->sample_rate) {

  319.         case 11025:

  320.             v |= 1 << 2;

  321.             break;

  322.         case 22050:

  323.             v |= 2 << 2;

  324.             break;

  325.         case 44100:

  326.             v |= 3 << 2;

  327.             break;

  328.         default:

  329.             /* not supported */

  330.             av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");

  331.             return -1;

  332.         }

  333.         v |= 0x02; /* 16 bit playback */

  334.         if (audio_enc->channels == 2)

  335.             v |= 0x01; /* stereo playback */

  336.         put_byte(s->pb, v);

  337.         v |= 0x20; /* mp3 compressed */

  338.         put_byte(s->pb, v);

  339.         put_le16(s->pb, swf->samples_per_frame);  /* avg samples per frame */

  340.         put_le16(s->pb, 0);

  341. 

  342.         put_swf_end_tag(s);

  343.     }

  344. 

  345.     put_flush_packet(s->pb);

  346.     return 0;

  347. }

  348. 

  349. static int swf_write_video(AVFormatContext *s,

  350.                            AVCodecContext *enc, const uint8_t *buf, int size)

  351. {

  352.     SWFContext *swf = s->priv_data;

  353.     ByteIOContext *pb = s->pb;

  354. 

  355.     /* Flash Player limit */

  356.     if (swf->swf_frame_number == 16000) {

  357.         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");

  358.     }

  359. 

  360.     if (swf->video_type == CODEC_ID_VP6F ||

  361.         swf->video_type == CODEC_ID_FLV1) {

  362.         if (swf->video_frame_number == 0) {

  363.             /* create a new video object */

  364.             put_swf_tag(s, TAG_VIDEOSTREAM);

  365.             put_le16(pb, VIDEO_ID);

  366.             put_le16(pb, 15000); /* hard flash player limit */

  367.             put_le16(pb, enc->width);

  368.             put_le16(pb, enc->height);

  369.             put_byte(pb, 0);

  370.             put_byte(pb,codec_get_tag(swf_codec_tags,swf->video_type));

  371.             put_swf_end_tag(s);

  372. 

  373.             /* place the video object for the first time */

  374.             put_swf_tag(s, TAG_PLACEOBJECT2);

  375.             put_byte(pb, 0x36);

  376.             put_le16(pb, 1);

  377.             put_le16(pb, VIDEO_ID);

  378.             put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);

  379.             put_le16(pb, swf->video_frame_number);

  380.             put_byte(pb, 'v');

  381.             put_byte(pb, 'i');

  382.             put_byte(pb, 'd');

  383.             put_byte(pb, 'e');

  384.             put_byte(pb, 'o');

  385.             put_byte(pb, 0x00);

  386.             put_swf_end_tag(s);

  387.         } else {

  388.             /* mark the character for update */

  389.             put_swf_tag(s, TAG_PLACEOBJECT2);

  390.             put_byte(pb, 0x11);

  391.             put_le16(pb, 1);

  392.             put_le16(pb, swf->video_frame_number);

  393.             put_swf_end_tag(s);

  394.         }

  395. 

  396.         /* set video frame data */

  397.         put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);

  398.         put_le16(pb, VIDEO_ID);

  399.         put_le16(pb, swf->video_frame_number++);

  400.         put_buffer(pb, buf, size);

  401.         put_swf_end_tag(s);

  402.     } else if (swf->video_type == CODEC_ID_MJPEG) {

  403.         if (swf->swf_frame_number > 0) {

  404.             /* remove the shape */

  405.             put_swf_tag(s, TAG_REMOVEOBJECT);

  406.             put_le16(pb, SHAPE_ID); /* shape ID */

  407.             put_le16(pb, 1); /* depth */

  408.             put_swf_end_tag(s);

  409. 

  410.             /* free the bitmap */

  411.             put_swf_tag(s, TAG_FREECHARACTER);

  412.             put_le16(pb, BITMAP_ID);

  413.             put_swf_end_tag(s);

  414.         }

  415. 

  416.         put_swf_tag(s, TAG_JPEG2 | TAG_LONG);

  417. 

  418.         put_le16(pb, BITMAP_ID); /* ID of the image */

  419. 

  420.         /* a dummy jpeg header seems to be required */

  421.         put_byte(pb, 0xff);

  422.         put_byte(pb, 0xd8);

  423.         put_byte(pb, 0xff);

  424.         put_byte(pb, 0xd9);

  425.         /* write the jpeg image */

  426.         put_buffer(pb, buf, size);

  427. 

  428.         put_swf_end_tag(s);

  429. 

  430.         /* draw the shape */

  431. 

  432.         put_swf_tag(s, TAG_PLACEOBJECT);

  433.         put_le16(pb, SHAPE_ID); /* shape ID */

  434.         put_le16(pb, 1); /* depth */

  435.         put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);

  436.         put_swf_end_tag(s);

  437.     } else {

  438.         /* invalid codec */

  439.     }

  440. 

  441.     swf->swf_frame_number ++;

  442. 

  443.     /* streaming sound always should be placed just before showframe tags */

  444.     if (swf->audio_type && swf->audio_in_pos) {

  445.         put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);

  446.         put_le16(pb, swf->sound_samples);

  447.         put_le16(pb, 0); // seek samples

  448.         put_buffer(pb, swf->audio_fifo, swf->audio_in_pos);

  449.         put_swf_end_tag(s);

  450. 

  451.         /* update FIFO */

  452.         swf->sound_samples = 0;

  453.         swf->audio_in_pos = 0;

  454.     }

  455. 

  456.     /* output the frame */

  457.     put_swf_tag(s, TAG_SHOWFRAME);

  458.     put_swf_end_tag(s);

  459. 

  460.     put_flush_packet(s->pb);

  461. 

  462.     return 0;

  463. }

  464. 

  465. static int swf_write_audio(AVFormatContext *s,

  466.                            AVCodecContext *enc, const uint8_t *buf, int size)

  467. {

  468.     SWFContext *swf = s->priv_data;

  469. 

  470.     /* Flash Player limit */

  471.     if (swf->swf_frame_number == 16000) {

  472.         av_log(enc, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");

  473.     }

  474. 

  475.     if (swf->audio_in_pos + size >= AUDIO_FIFO_SIZE) {

  476.         av_log(s, AV_LOG_ERROR, "audio fifo too small to mux audio essence\n");

  477.         return -1;

  478.     }

  479. 

  480.     memcpy(swf->audio_fifo +  swf->audio_in_pos, buf, size);

  481.     swf->audio_in_pos += size;

  482.     swf->sound_samples += enc->frame_size;

  483. 

  484.     /* if audio only stream make sure we add swf frames */

  485.     if (swf->video_type == 0) {

  486.         swf_write_video(s, enc, 0, 0);

  487.     }

  488. 

  489.     return 0;

  490. }

  491. 

  492. static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)

  493. {

  494.     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;

  495.     if (codec->codec_type == CODEC_TYPE_AUDIO)

  496.         return swf_write_audio(s, codec, pkt->data, pkt->size);

  497.     else

  498.         return swf_write_video(s, codec, pkt->data, pkt->size);

  499. }

  500. 

  501. static int swf_write_trailer(AVFormatContext *s)

  502. {

  503.     SWFContext *swf = s->priv_data;

  504.     ByteIOContext *pb = s->pb;

  505.     AVCodecContext *enc, *video_enc;

  506.     int file_size, i;

  507. 

  508.     video_enc = NULL;

  509.     for(i=0;i<s->nb_streams;i++) {

  510.         enc = s->streams[i]->codec;

  511.         if (enc->codec_type == CODEC_TYPE_VIDEO)

  512.             video_enc = enc;

  513.     }

  514. 

  515.     put_swf_tag(s, TAG_END);

  516.     put_swf_end_tag(s);

  517. 

  518.     put_flush_packet(s->pb);

  519. 

  520.     /* patch file size and number of frames if not streamed */

  521.     if (!url_is_streamed(s->pb) && video_enc) {

  522.         file_size = url_ftell(pb);

  523.         url_fseek(pb, 4, SEEK_SET);

  524.         put_le32(pb, file_size);

  525.         url_fseek(pb, swf->duration_pos, SEEK_SET);

  526.         put_le16(pb, video_enc->frame_number);

  527.         url_fseek(pb, file_size, SEEK_SET);

  528.     }

  529.     return 0;

  530. }

  531. 

  532. #ifdef CONFIG_SWF_MUXER

  533. AVOutputFormat swf_muxer = {

  534.     "swf",

  535.     "Flash format",

  536.     "application/x-shockwave-flash",

  537.     "swf",

  538.     sizeof(SWFContext),

  539.     CODEC_ID_MP3,

  540.     CODEC_ID_FLV1,

  541.     swf_write_header,

  542.     swf_write_packet,

  543.     swf_write_trailer,

  544. };

  545. #endif

  546. #ifdef CONFIG_AVM2_MUXER

  547. AVOutputFormat avm2_muxer = {

  548.     "avm2",

  549.     "Flash 9 (AVM2) format",

  550.     "application/x-shockwave-flash",

  551.     NULL,

  552.     sizeof(SWFContext),

  553.     CODEC_ID_MP3,

  554.     CODEC_ID_FLV1,

  555.     swf_write_header,

  556.     swf_write_packet,

  557.     swf_write_trailer,

  558. };

  559. #endif