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.
4744 Commits
32 Branches
1.0GB
Tree: 1b51e051c0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1b51e051c0'
${ noResults }
FFmpeg/libavformat/gif.c

441 lines
16KB
Raw Blame History 

  1. /*

  2.  * Animated GIF encoder

  3.  * Copyright (c) 2000 Fabrice Bellard.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  */

  19. 

  20. /*

  21.  * First version by Francois Revol revol@free.fr

  22.  *

  23.  * Features and limitations:

  24.  * - currently no compression is performed,

  25.  *   in fact the size of the data is 9/8 the size of the image in 8bpp

  26.  * - uses only a global standard palette

  27.  * - tested with IE 5.0, Opera for BeOS, NetPositive (BeOS), and Mozilla (BeOS).

  28.  *

  29.  * Reference documents:

  30.  * http://www.goice.co.jp/member/mo/formats/gif.html

  31.  * http://astronomy.swin.edu.au/pbourke/dataformats/gif/

  32.  * http://www.dcs.ed.ac.uk/home/mxr/gfx/2d/GIF89a.txt

  33.  *

  34.  * this url claims to have an LZW algorithm not covered by Unisys patent:

  35.  * http://www.msg.net/utility/whirlgif/gifencod.html

  36.  * could help reduce the size of the files _a lot_...

  37.  * some sites mentions an RLE type compression also.

  38.  */

  39. 

  40. #include "avformat.h"

  41. #include "bitstream.h"

  42. 

  43. /* bitstream minipacket size */

  44. #define GIF_CHUNKS 100

  45. 

  46. /* slows down the decoding (and some browsers don't like it) */

  47. /* update on the 'some browsers don't like it issue from above: this was probably due to missing 'Data Sub-block Terminator' (byte 19) in the app_header */

  48. #define GIF_ADD_APP_HEADER // required to enable looping of animated gif

  49. 

  50. typedef struct {

  51.     unsigned char r;

  52.     unsigned char g;

  53.     unsigned char b;

  54. } rgb_triplet;

  55. 

  56. /* we use the standard 216 color palette */

  57. 

  58. /* this script was used to create the palette:

  59.  * for r in 00 33 66 99 cc ff; do for g in 00 33 66 99 cc ff; do echo -n "    "; for b in 00 33 66 99 cc ff; do 

  60.  *   echo -n "{ 0x$r, 0x$g, 0x$b }, "; done; echo ""; done; done

  61.  */

  62. 

  63. static const rgb_triplet gif_clut[216] = {

  64.     { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x33 }, { 0x00, 0x00, 0x66 }, { 0x00, 0x00, 0x99 }, { 0x00, 0x00, 0xcc }, { 0x00, 0x00, 0xff },

  65.     { 0x00, 0x33, 0x00 }, { 0x00, 0x33, 0x33 }, { 0x00, 0x33, 0x66 }, { 0x00, 0x33, 0x99 }, { 0x00, 0x33, 0xcc }, { 0x00, 0x33, 0xff },

  66.     { 0x00, 0x66, 0x00 }, { 0x00, 0x66, 0x33 }, { 0x00, 0x66, 0x66 }, { 0x00, 0x66, 0x99 }, { 0x00, 0x66, 0xcc }, { 0x00, 0x66, 0xff },

  67.     { 0x00, 0x99, 0x00 }, { 0x00, 0x99, 0x33 }, { 0x00, 0x99, 0x66 }, { 0x00, 0x99, 0x99 }, { 0x00, 0x99, 0xcc }, { 0x00, 0x99, 0xff },

  68.     { 0x00, 0xcc, 0x00 }, { 0x00, 0xcc, 0x33 }, { 0x00, 0xcc, 0x66 }, { 0x00, 0xcc, 0x99 }, { 0x00, 0xcc, 0xcc }, { 0x00, 0xcc, 0xff },

  69.     { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0x33 }, { 0x00, 0xff, 0x66 }, { 0x00, 0xff, 0x99 }, { 0x00, 0xff, 0xcc }, { 0x00, 0xff, 0xff },

  70.     { 0x33, 0x00, 0x00 }, { 0x33, 0x00, 0x33 }, { 0x33, 0x00, 0x66 }, { 0x33, 0x00, 0x99 }, { 0x33, 0x00, 0xcc }, { 0x33, 0x00, 0xff },

  71.     { 0x33, 0x33, 0x00 }, { 0x33, 0x33, 0x33 }, { 0x33, 0x33, 0x66 }, { 0x33, 0x33, 0x99 }, { 0x33, 0x33, 0xcc }, { 0x33, 0x33, 0xff },

  72.     { 0x33, 0x66, 0x00 }, { 0x33, 0x66, 0x33 }, { 0x33, 0x66, 0x66 }, { 0x33, 0x66, 0x99 }, { 0x33, 0x66, 0xcc }, { 0x33, 0x66, 0xff },

  73.     { 0x33, 0x99, 0x00 }, { 0x33, 0x99, 0x33 }, { 0x33, 0x99, 0x66 }, { 0x33, 0x99, 0x99 }, { 0x33, 0x99, 0xcc }, { 0x33, 0x99, 0xff },

  74.     { 0x33, 0xcc, 0x00 }, { 0x33, 0xcc, 0x33 }, { 0x33, 0xcc, 0x66 }, { 0x33, 0xcc, 0x99 }, { 0x33, 0xcc, 0xcc }, { 0x33, 0xcc, 0xff },

  75.     { 0x33, 0xff, 0x00 }, { 0x33, 0xff, 0x33 }, { 0x33, 0xff, 0x66 }, { 0x33, 0xff, 0x99 }, { 0x33, 0xff, 0xcc }, { 0x33, 0xff, 0xff },

  76.     { 0x66, 0x00, 0x00 }, { 0x66, 0x00, 0x33 }, { 0x66, 0x00, 0x66 }, { 0x66, 0x00, 0x99 }, { 0x66, 0x00, 0xcc }, { 0x66, 0x00, 0xff },

  77.     { 0x66, 0x33, 0x00 }, { 0x66, 0x33, 0x33 }, { 0x66, 0x33, 0x66 }, { 0x66, 0x33, 0x99 }, { 0x66, 0x33, 0xcc }, { 0x66, 0x33, 0xff },

  78.     { 0x66, 0x66, 0x00 }, { 0x66, 0x66, 0x33 }, { 0x66, 0x66, 0x66 }, { 0x66, 0x66, 0x99 }, { 0x66, 0x66, 0xcc }, { 0x66, 0x66, 0xff },

  79.     { 0x66, 0x99, 0x00 }, { 0x66, 0x99, 0x33 }, { 0x66, 0x99, 0x66 }, { 0x66, 0x99, 0x99 }, { 0x66, 0x99, 0xcc }, { 0x66, 0x99, 0xff },

  80.     { 0x66, 0xcc, 0x00 }, { 0x66, 0xcc, 0x33 }, { 0x66, 0xcc, 0x66 }, { 0x66, 0xcc, 0x99 }, { 0x66, 0xcc, 0xcc }, { 0x66, 0xcc, 0xff },

  81.     { 0x66, 0xff, 0x00 }, { 0x66, 0xff, 0x33 }, { 0x66, 0xff, 0x66 }, { 0x66, 0xff, 0x99 }, { 0x66, 0xff, 0xcc }, { 0x66, 0xff, 0xff },

  82.     { 0x99, 0x00, 0x00 }, { 0x99, 0x00, 0x33 }, { 0x99, 0x00, 0x66 }, { 0x99, 0x00, 0x99 }, { 0x99, 0x00, 0xcc }, { 0x99, 0x00, 0xff },

  83.     { 0x99, 0x33, 0x00 }, { 0x99, 0x33, 0x33 }, { 0x99, 0x33, 0x66 }, { 0x99, 0x33, 0x99 }, { 0x99, 0x33, 0xcc }, { 0x99, 0x33, 0xff },

  84.     { 0x99, 0x66, 0x00 }, { 0x99, 0x66, 0x33 }, { 0x99, 0x66, 0x66 }, { 0x99, 0x66, 0x99 }, { 0x99, 0x66, 0xcc }, { 0x99, 0x66, 0xff },

  85.     { 0x99, 0x99, 0x00 }, { 0x99, 0x99, 0x33 }, { 0x99, 0x99, 0x66 }, { 0x99, 0x99, 0x99 }, { 0x99, 0x99, 0xcc }, { 0x99, 0x99, 0xff },

  86.     { 0x99, 0xcc, 0x00 }, { 0x99, 0xcc, 0x33 }, { 0x99, 0xcc, 0x66 }, { 0x99, 0xcc, 0x99 }, { 0x99, 0xcc, 0xcc }, { 0x99, 0xcc, 0xff },

  87.     { 0x99, 0xff, 0x00 }, { 0x99, 0xff, 0x33 }, { 0x99, 0xff, 0x66 }, { 0x99, 0xff, 0x99 }, { 0x99, 0xff, 0xcc }, { 0x99, 0xff, 0xff },

  88.     { 0xcc, 0x00, 0x00 }, { 0xcc, 0x00, 0x33 }, { 0xcc, 0x00, 0x66 }, { 0xcc, 0x00, 0x99 }, { 0xcc, 0x00, 0xcc }, { 0xcc, 0x00, 0xff },

  89.     { 0xcc, 0x33, 0x00 }, { 0xcc, 0x33, 0x33 }, { 0xcc, 0x33, 0x66 }, { 0xcc, 0x33, 0x99 }, { 0xcc, 0x33, 0xcc }, { 0xcc, 0x33, 0xff },

  90.     { 0xcc, 0x66, 0x00 }, { 0xcc, 0x66, 0x33 }, { 0xcc, 0x66, 0x66 }, { 0xcc, 0x66, 0x99 }, { 0xcc, 0x66, 0xcc }, { 0xcc, 0x66, 0xff },

  91.     { 0xcc, 0x99, 0x00 }, { 0xcc, 0x99, 0x33 }, { 0xcc, 0x99, 0x66 }, { 0xcc, 0x99, 0x99 }, { 0xcc, 0x99, 0xcc }, { 0xcc, 0x99, 0xff },

  92.     { 0xcc, 0xcc, 0x00 }, { 0xcc, 0xcc, 0x33 }, { 0xcc, 0xcc, 0x66 }, { 0xcc, 0xcc, 0x99 }, { 0xcc, 0xcc, 0xcc }, { 0xcc, 0xcc, 0xff },

  93.     { 0xcc, 0xff, 0x00 }, { 0xcc, 0xff, 0x33 }, { 0xcc, 0xff, 0x66 }, { 0xcc, 0xff, 0x99 }, { 0xcc, 0xff, 0xcc }, { 0xcc, 0xff, 0xff },

  94.     { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0x33 }, { 0xff, 0x00, 0x66 }, { 0xff, 0x00, 0x99 }, { 0xff, 0x00, 0xcc }, { 0xff, 0x00, 0xff },

  95.     { 0xff, 0x33, 0x00 }, { 0xff, 0x33, 0x33 }, { 0xff, 0x33, 0x66 }, { 0xff, 0x33, 0x99 }, { 0xff, 0x33, 0xcc }, { 0xff, 0x33, 0xff },

  96.     { 0xff, 0x66, 0x00 }, { 0xff, 0x66, 0x33 }, { 0xff, 0x66, 0x66 }, { 0xff, 0x66, 0x99 }, { 0xff, 0x66, 0xcc }, { 0xff, 0x66, 0xff },

  97.     { 0xff, 0x99, 0x00 }, { 0xff, 0x99, 0x33 }, { 0xff, 0x99, 0x66 }, { 0xff, 0x99, 0x99 }, { 0xff, 0x99, 0xcc }, { 0xff, 0x99, 0xff },

  98.     { 0xff, 0xcc, 0x00 }, { 0xff, 0xcc, 0x33 }, { 0xff, 0xcc, 0x66 }, { 0xff, 0xcc, 0x99 }, { 0xff, 0xcc, 0xcc }, { 0xff, 0xcc, 0xff },

  99.     { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0x33 }, { 0xff, 0xff, 0x66 }, { 0xff, 0xff, 0x99 }, { 0xff, 0xff, 0xcc }, { 0xff, 0xff, 0xff },

  100. };

  101. 

  102. /* The GIF format uses reversed order for bitstreams... */

  103. /* at least they don't use PDP_ENDIAN :) */

  104. /* so we 'extend' PutBitContext. hmmm, OOP :) */

  105. /* seems this thing changed slightly since I wrote it... */

  106. 

  107. #ifdef ALT_BITSTREAM_WRITER

  108. # error no ALT_BITSTREAM_WRITER support for now

  109. #endif

  110. 

  111. static void gif_put_bits_rev(PutBitContext *s, int n, unsigned int value)

  112. {

  113.     unsigned int bit_buf;

  114.     int bit_cnt;

  115. 

  116. #ifdef STATS

  117.     st_out_bit_counts[st_current_index] += n;

  118. #endif

  119.     //    printf("put_bits=%d %x\n", n, value);

  120.     assert(n == 32 || value < (1U << n));

  121. 

  122.     bit_buf = s->bit_buf;

  123.     bit_cnt = 32 - s->bit_left; /* XXX:lazyness... was = s->bit_cnt; */

  124. 

  125.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

  126.     /* XXX: optimize */

  127.     if (n < (32-bit_cnt)) {

  128.         bit_buf |= value << (bit_cnt);

  129.         bit_cnt+=n;

  130.     } else {

  131.         bit_buf |= value << (bit_cnt);

  132.         

  133.         *s->buf_ptr = bit_buf & 0xff;

  134.         s->buf_ptr[1] = (bit_buf >> 8) & 0xff;

  135.         s->buf_ptr[2] = (bit_buf >> 16) & 0xff;

  136.         s->buf_ptr[3] = (bit_buf >> 24) & 0xff;

  137.         

  138.         //printf("bitbuf = %08x\n", bit_buf);

  139.         s->buf_ptr+=4;

  140.         if (s->buf_ptr >= s->buf_end)

  141.             puts("bit buffer overflow !!"); // should never happen ! who got rid of the callback ???

  142. //            flush_buffer_rev(s);

  143.         bit_cnt=bit_cnt + n - 32;

  144.         if (bit_cnt == 0) {

  145.             bit_buf = 0;

  146.         } else {

  147.             bit_buf = value >> (n - bit_cnt);

  148.         }

  149.     }

  150. 

  151.     s->bit_buf = bit_buf;

  152.     s->bit_left = 32 - bit_cnt;

  153. }

  154. 

  155. /* pad the end of the output stream with zeros */

  156. static void gif_flush_put_bits_rev(PutBitContext *s)

  157. {

  158.     while (s->bit_left < 32) {

  159.         /* XXX: should test end of buffer */

  160.         *s->buf_ptr++=s->bit_buf & 0xff;

  161.         s->bit_buf>>=8;

  162.         s->bit_left+=8;

  163.     }

  164. //    flush_buffer_rev(s);

  165.     s->bit_left=32;

  166.     s->bit_buf=0;

  167. }

  168. 

  169. /* !RevPutBitContext */

  170. 

  171. /* GIF header */

  172. static int gif_image_write_header(ByteIOContext *pb, 

  173.                                   int width, int height, int loop_count,

  174.                                   uint32_t *palette)

  175. {

  176.     int i;

  177.     unsigned int v;

  178. 

  179.     put_tag(pb, "GIF");

  180.     put_tag(pb, "89a");

  181.     put_le16(pb, width);

  182.     put_le16(pb, height);

  183. 

  184.     put_byte(pb, 0xf7); /* flags: global clut, 256 entries */

  185.     put_byte(pb, 0x1f); /* background color index */

  186.     put_byte(pb, 0); /* aspect ratio */

  187. 

  188.     /* the global palette */

  189.     if (!palette) {

  190.         put_buffer(pb, (unsigned char *)gif_clut, 216*3);

  191.         for(i=0;i<((256-216)*3);i++)

  192.             put_byte(pb, 0);

  193.     } else {

  194.         for(i=0;i<256;i++) {

  195.             v = palette[i];

  196.             put_byte(pb, (v >> 16) & 0xff);

  197.             put_byte(pb, (v >> 8) & 0xff);

  198.             put_byte(pb, (v) & 0xff);

  199.         }

  200.     }

  201. 

  202. 	/*	update: this is the 'NETSCAPE EXTENSION' that allows for looped animated gif

  203. 		see http://members.aol.com/royalef/gifabout.htm#net-extension

  204. 

  205. 		byte   1       : 33 (hex 0x21) GIF Extension code

  206. 		byte   2       : 255 (hex 0xFF) Application Extension Label

  207. 		byte   3       : 11 (hex (0x0B) Length of Application Block 

  208. 					 (eleven bytes of data to follow)

  209. 		bytes  4 to 11 : "NETSCAPE"

  210. 		bytes 12 to 14 : "2.0"

  211. 		byte  15       : 3 (hex 0x03) Length of Data Sub-Block 

  212. 					 (three bytes of data to follow)

  213. 		byte  16       : 1 (hex 0x01)

  214. 		bytes 17 to 18 : 0 to 65535, an unsigned integer in 

  215. 					 lo-hi byte format. This indicate the 

  216. 					 number of iterations the loop should 

  217. 					 be executed.

  218. 		bytes 19       : 0 (hex 0x00) a Data Sub-block Terminator

  219. 	*/

  220. 

  221.     /* application extension header */

  222. #ifdef GIF_ADD_APP_HEADER

  223.     if (loop_count >= 0 && loop_count <= 65535) {

  224.     put_byte(pb, 0x21);

  225.     put_byte(pb, 0xff);

  226.     put_byte(pb, 0x0b);

  227.         put_tag(pb, "NETSCAPE2.0");  // bytes 4 to 14

  228.         put_byte(pb, 0x03); // byte 15

  229.         put_byte(pb, 0x01); // byte 16

  230.         put_le16(pb, (uint16_t)loop_count);

  231.         put_byte(pb, 0x00); // byte 19

  232.     }

  233. #endif

  234.     return 0;

  235. }

  236. 

  237. /* this is maybe slow, but allows for extensions */

  238. static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)

  239. {

  240.     return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));

  241. }

  242. 

  243. 

  244. static int gif_image_write_image(ByteIOContext *pb, 

  245.                                  int x1, int y1, int width, int height,

  246.                                  const uint8_t *buf, int linesize, int pix_fmt)

  247. {

  248.     PutBitContext p;

  249.     uint8_t buffer[200]; /* 100 * 9 / 8 = 113 */

  250.     int i, left, w, v;

  251.     const uint8_t *ptr;

  252.     /* image block */

  253. 

  254.     put_byte(pb, 0x2c);

  255.     put_le16(pb, x1);

  256.     put_le16(pb, y1);

  257.     put_le16(pb, width);

  258.     put_le16(pb, height);

  259.     put_byte(pb, 0x00); /* flags */

  260.     /* no local clut */

  261. 

  262.     put_byte(pb, 0x08);

  263. 

  264.     left= width * height;

  265. 

  266.     init_put_bits(&p, buffer, 130);

  267. 

  268. /*

  269.  * the thing here is the bitstream is written as little packets, with a size byte before

  270.  * but it's still the same bitstream between packets (no flush !)

  271.  */

  272.     ptr = buf;

  273.     w = width;

  274.     while(left>0) {

  275. 

  276.         gif_put_bits_rev(&p, 9, 0x0100); /* clear code */

  277. 

  278.         for(i=(left<GIF_CHUNKS)?left:GIF_CHUNKS;i;i--) {

  279.             if (pix_fmt == PIX_FMT_RGB24) {

  280.                 v = gif_clut_index(ptr[0], ptr[1], ptr[2]);

  281.                 ptr+=3;

  282.             } else {

  283.                 v = *ptr++;

  284.             }

  285.             gif_put_bits_rev(&p, 9, v);

  286.             if (--w == 0) {

  287.                 w = width;

  288.                 buf += linesize;

  289.                 ptr = buf;

  290.             }

  291.         }

  292. 

  293.         if(left<=GIF_CHUNKS) {

  294.             gif_put_bits_rev(&p, 9, 0x101); /* end of stream */

  295.             gif_flush_put_bits_rev(&p);

  296.         }

  297.         if(pbBufPtr(&p) - p.buf > 0) {

  298.             put_byte(pb, pbBufPtr(&p) - p.buf); /* byte count of the packet */

  299.             put_buffer(pb, p.buf, pbBufPtr(&p) - p.buf); /* the actual buffer */

  300.             p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */

  301.         }

  302.         left-=GIF_CHUNKS;

  303.     }

  304.     put_byte(pb, 0x00); /* end of image block */

  305.     

  306.     return 0;

  307. }

  308. 

  309. typedef struct {

  310.     int64_t time, file_time;

  311.     uint8_t buffer[100]; /* data chunks */

  312. } GIFContext;

  313. 

  314. static int gif_write_header(AVFormatContext *s)

  315. {

  316.     GIFContext *gif = s->priv_data;

  317.     ByteIOContext *pb = &s->pb;

  318.     AVCodecContext *enc, *video_enc;

  319.     int i, width, height, loop_count /*, rate*/;

  320. 

  321. /* XXX: do we reject audio streams or just ignore them ?

  322.     if(s->nb_streams > 1)

  323.         return -1;

  324. */

  325.     gif->time = 0;

  326.     gif->file_time = 0;

  327. 

  328.     video_enc = NULL;

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

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

  331.         if (enc->codec_type != CODEC_TYPE_AUDIO)

  332.             video_enc = enc;

  333.     }

  334. 

  335.     if (!video_enc) {

  336.         av_free(gif);

  337.         return -1;

  338.     } else {

  339.         width = video_enc->width;

  340.         height = video_enc->height;

  341.         loop_count = s->loop_output;

  342. //        rate = video_enc->time_base.den;

  343.     }

  344. 

  345.     /* XXX: is it allowed ? seems to work so far... */

  346.     video_enc->pix_fmt = PIX_FMT_RGB24;

  347. 

  348.     gif_image_write_header(pb, width, height, loop_count, NULL);

  349. 

  350.     put_flush_packet(&s->pb);

  351.     return 0;

  352. }

  353. 

  354. static int gif_write_video(AVFormatContext *s, 

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

  356. {

  357.     ByteIOContext *pb = &s->pb;

  358.     GIFContext *gif = s->priv_data;

  359.     int jiffies;

  360.     int64_t delay;

  361. 

  362.     /* graphic control extension block */

  363.     put_byte(pb, 0x21);

  364.     put_byte(pb, 0xf9);

  365.     put_byte(pb, 0x04); /* block size */

  366.     put_byte(pb, 0x04); /* flags */

  367.     

  368.     /* 1 jiffy is 1/70 s */

  369.     /* the delay_time field indicates the number of jiffies - 1 */

  370.     delay = gif->file_time - gif->time;

  371. 

  372.     /* XXX: should use delay, in order to be more accurate */

  373.     /* instead of using the same rounded value each time */

  374.     /* XXX: don't even remember if I really use it for now */

  375.     jiffies = (70*enc->time_base.num/enc->time_base.den) - 1;

  376. 

  377.     put_le16(pb, jiffies);

  378. 

  379.     put_byte(pb, 0x1f); /* transparent color index */

  380.     put_byte(pb, 0x00);

  381. 

  382.     gif_image_write_image(pb, 0, 0, enc->width, enc->height,

  383.                           buf, enc->width * 3, PIX_FMT_RGB24);

  384. 

  385.     put_flush_packet(&s->pb);

  386.     return 0;

  387. }

  388. 

  389. static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)

  390. {

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

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

  393.         return 0; /* just ignore audio */

  394.     else

  395.         return gif_write_video(s, codec, pkt->data, pkt->size);

  396. }

  397. 

  398. static int gif_write_trailer(AVFormatContext *s)

  399. {

  400.     ByteIOContext *pb = &s->pb;

  401. 

  402.     put_byte(pb, 0x3b);

  403.     put_flush_packet(&s->pb);

  404.     return 0;

  405. }

  406. 

  407. /* better than nothing gif image writer */

  408. int gif_write(ByteIOContext *pb, AVImageInfo *info)

  409. {

  410.     gif_image_write_header(pb, info->width, info->height, AVFMT_NOOUTPUTLOOP, 

  411.                            (uint32_t *)info->pict.data[1]);

  412.     gif_image_write_image(pb, 0, 0, info->width, info->height, 

  413.                           info->pict.data[0], info->pict.linesize[0], 

  414.                           PIX_FMT_PAL8);

  415.     put_byte(pb, 0x3b);

  416.     put_flush_packet(pb);

  417.     return 0;

  418. }

  419. 

  420. static AVOutputFormat gif_oformat = {

  421.     "gif",

  422.     "GIF Animation",

  423.     "image/gif",

  424.     "gif",

  425.     sizeof(GIFContext),

  426.     CODEC_ID_NONE,

  427.     CODEC_ID_RAWVIDEO,

  428.     gif_write_header,

  429.     gif_write_packet,

  430.     gif_write_trailer,

  431. };

  432. 

  433. extern AVInputFormat gif_iformat;

  434. 

  435. int gif_init(void)

  436. {

  437.     av_register_output_format(&gif_oformat);

  438.     av_register_input_format(&gif_iformat);

  439.     return 0;

  440. }