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.
13954 Commits
32 Branches
283MB
Tree: 17a7fc8ceb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '17a7fc8ceb'
${ noResults }
FFmpeg/libavformat/gif.c

420 lines
16KB
Raw Blame History 

  1. /*

  2.  * Animated GIF muxer

  3.  * Copyright (c) 2000 Fabrice Bellard.

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

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

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

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. /*

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

  24.  *

  25.  * Features and limitations:

  26.  * - currently no compression is performed,

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

  28.  * - uses only a global standard palette

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

  30.  *

  31.  * Reference documents:

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

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

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

  35.  *

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

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

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

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

  40.  */

  41. 

  42. #include "avformat.h"

  43. #include "libavcodec/bitstream.h"

  44. 

  45. /* bitstream minipacket size */

  46. #define GIF_CHUNKS 100

  47. 

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

  49. /* 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 */

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

  51. 

  52. typedef struct {

  53.     unsigned char r;

  54.     unsigned char g;

  55.     unsigned char b;

  56. } rgb_triplet;

  57. 

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

  59. 

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

  61.  * 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

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

  63.  */

  64. 

  65. static const rgb_triplet gif_clut[216] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  102. };

  103. 

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

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

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

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

  108. 

  109. #ifdef ALT_BITSTREAM_WRITER

  110. # error no ALT_BITSTREAM_WRITER support for now

  111. #endif

  112. 

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

  114. {

  115.     unsigned int bit_buf;

  116.     int bit_cnt;

  117. 

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

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

  120. 

  121.     bit_buf = s->bit_buf;

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

  123. 

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

  125.     /* XXX: optimize */

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

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

  128.         bit_cnt+=n;

  129.     } else {

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

  131. 

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

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

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

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

  136. 

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

  138.         s->buf_ptr+=4;

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

  140.             abort();

  141. //            flush_buffer_rev(s);

  142.         bit_cnt=bit_cnt + n - 32;

  143.         if (bit_cnt == 0) {

  144.             bit_buf = 0;

  145.         } else {

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

  147.         }

  148.     }

  149. 

  150.     s->bit_buf = bit_buf;

  151.     s->bit_left = 32 - bit_cnt;

  152. }

  153. 

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

  155. static void gif_flush_put_bits_rev(PutBitContext *s)

  156. {

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

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

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

  160.         s->bit_buf>>=8;

  161.         s->bit_left+=8;

  162.     }

  163. //    flush_buffer_rev(s);

  164.     s->bit_left=32;

  165.     s->bit_buf=0;

  166. }

  167. 

  168. /* !RevPutBitContext */

  169. 

  170. /* GIF header */

  171. static int gif_image_write_header(ByteIOContext *pb,

  172.                                   int width, int height, int loop_count,

  173.                                   uint32_t *palette)

  174. {

  175.     int i;

  176.     unsigned int v;

  177. 

  178.     put_tag(pb, "GIF");

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

  180.     put_le16(pb, width);

  181.     put_le16(pb, height);

  182. 

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

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

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

  186. 

  187.     /* the global palette */

  188.     if (!palette) {

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

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

  191.             put_byte(pb, 0);

  192.     } else {

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

  194.             v = palette[i];

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

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

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

  198.         }

  199.     }

  200. 

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

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

  203. 

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

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

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

  207.                                          (eleven bytes of data to follow)

  208.                 bytes  4 to 11 : "NETSCAPE"

  209.                 bytes 12 to 14 : "2.0"

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

  211.                                          (three bytes of data to follow)

  212.                 byte  16       : 1 (hex 0x01)

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

  214.                                          lo-hi byte format. This indicate the

  215.                                          number of iterations the loop should

  216.                                          be executed.

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

  218.         */

  219. 

  220.     /* application extension header */

  221. #ifdef GIF_ADD_APP_HEADER

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

  223.     put_byte(pb, 0x21);

  224.     put_byte(pb, 0xff);

  225.     put_byte(pb, 0x0b);

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

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

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

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

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

  231.     }

  232. #endif

  233.     return 0;

  234. }

  235. 

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

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

  238. {

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

  240. }

  241. 

  242. 

  243. static int gif_image_write_image(ByteIOContext *pb,

  244.                                  int x1, int y1, int width, int height,

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

  246. {

  247.     PutBitContext p;

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

  249.     int i, left, w, v;

  250.     const uint8_t *ptr;

  251.     /* image block */

  252. 

  253.     put_byte(pb, 0x2c);

  254.     put_le16(pb, x1);

  255.     put_le16(pb, y1);

  256.     put_le16(pb, width);

  257.     put_le16(pb, height);

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

  259.     /* no local clut */

  260. 

  261.     put_byte(pb, 0x08);

  262. 

  263.     left= width * height;

  264. 

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

  266. 

  267. /*

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

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

  270.  */

  271.     ptr = buf;

  272.     w = width;

  273.     while(left>0) {

  274. 

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

  276. 

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

  278.             if (pix_fmt == PIX_FMT_RGB24) {

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

  280.                 ptr+=3;

  281.             } else {

  282.                 v = *ptr++;

  283.             }

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

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

  286.                 w = width;

  287.                 buf += linesize;

  288.                 ptr = buf;

  289.             }

  290.         }

  291. 

  292.         if(left<=GIF_CHUNKS) {

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

  294.             gif_flush_put_bits_rev(&p);

  295.         }

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

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

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

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

  300.         }

  301.         left-=GIF_CHUNKS;

  302.     }

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

  304. 

  305.     return 0;

  306. }

  307. 

  308. typedef struct {

  309.     int64_t time, file_time;

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

  311. } GIFContext;

  312. 

  313. static int gif_write_header(AVFormatContext *s)

  314. {

  315.     GIFContext *gif = s->priv_data;

  316.     ByteIOContext *pb = s->pb;

  317.     AVCodecContext *enc, *video_enc;

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

  319. 

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

  321.     if(s->nb_streams > 1)

  322.         return -1;

  323. */

  324.     gif->time = 0;

  325.     gif->file_time = 0;

  326. 

  327.     video_enc = NULL;

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

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

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

  331.             video_enc = enc;

  332.     }

  333. 

  334.     if (!video_enc) {

  335.         av_free(gif);

  336.         return -1;

  337.     } else {

  338.         width = video_enc->width;

  339.         height = video_enc->height;

  340.         loop_count = s->loop_output;

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

  342.     }

  343. 

  344.     if (video_enc->pix_fmt != PIX_FMT_RGB24) {

  345.         av_log(s, AV_LOG_ERROR, "ERROR: gif only handles the rgb24 pixel format. Use -pix_fmt rgb24.\n");

  346.         return AVERROR(EIO);

  347.     }

  348. 

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

  350. 

  351.     put_flush_packet(s->pb);

  352.     return 0;

  353. }

  354. 

  355. static int gif_write_video(AVFormatContext *s,

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

  357. {

  358.     ByteIOContext *pb = s->pb;

  359.     GIFContext *gif = s->priv_data;

  360.     int jiffies;

  361.     int64_t delay;

  362. 

  363.     /* graphic control extension block */

  364.     put_byte(pb, 0x21);

  365.     put_byte(pb, 0xf9);

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

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

  368. 

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

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

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

  372. 

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

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

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

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

  377. 

  378.     put_le16(pb, jiffies);

  379. 

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

  381.     put_byte(pb, 0x00);

  382. 

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

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

  385. 

  386.     put_flush_packet(s->pb);

  387.     return 0;

  388. }

  389. 

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

  391. {

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

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

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

  395.     else

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

  397. }

  398. 

  399. static int gif_write_trailer(AVFormatContext *s)

  400. {

  401.     ByteIOContext *pb = s->pb;

  402. 

  403.     put_byte(pb, 0x3b);

  404.     put_flush_packet(s->pb);

  405.     return 0;

  406. }

  407. 

  408. AVOutputFormat gif_muxer = {

  409.     "gif",

  410.     "GIF Animation",

  411.     "image/gif",

  412.     "gif",

  413.     sizeof(GIFContext),

  414.     CODEC_ID_NONE,

  415.     CODEC_ID_RAWVIDEO,

  416.     gif_write_header,

  417.     gif_write_packet,

  418.     gif_write_trailer,

  419. };