/libavformat/swfenc.c

http://github.com/FFmpeg/FFmpeg · C · 545 lines · 420 code · 73 blank · 52 comment · 81 complexity · 2fe432c46ada06f665be272d7ed8c1e4 MD5 · raw file

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