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

429 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.     //    printf("put_bits=%d %x\n", n, value);

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

  118. 

  119.     bit_buf = s->bit_buf;

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

  121. 

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

  123.     /* XXX: optimize */

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

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

  126.         bit_cnt+=n;

  127.     } else {

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

  129. 

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

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

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

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

  134. 

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

  136.         s->buf_ptr+=4;

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

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

  139. //            flush_buffer_rev(s);

  140.         bit_cnt=bit_cnt + n - 32;

  141.         if (bit_cnt == 0) {

  142.             bit_buf = 0;

  143.         } else {

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

  145.         }

  146.     }

  147. 

  148.     s->bit_buf = bit_buf;

  149.     s->bit_left = 32 - bit_cnt;

  150. }

  151. 

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

  153. static void gif_flush_put_bits_rev(PutBitContext *s)

  154. {

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

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

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

  158.         s->bit_buf>>=8;

  159.         s->bit_left+=8;

  160.     }

  161. //    flush_buffer_rev(s);

  162.     s->bit_left=32;

  163.     s->bit_buf=0;

  164. }

  165. 

  166. /* !RevPutBitContext */

  167. 

  168. /* GIF header */

  169. static int gif_image_write_header(ByteIOContext *pb,

  170.                                   int width, int height, int loop_count,

  171.                                   uint32_t *palette)

  172. {

  173.     int i;

  174.     unsigned int v;

  175. 

  176.     put_tag(pb, "GIF");

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

  178.     put_le16(pb, width);

  179.     put_le16(pb, height);

  180. 

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

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

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

  184. 

  185.     /* the global palette */

  186.     if (!palette) {

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

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

  189.             put_byte(pb, 0);

  190.     } else {

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

  192.             v = palette[i];

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

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

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

  196.         }

  197.     }

  198. 

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

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

  201. 

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

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

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

  205.                                          (eleven bytes of data to follow)

  206.                 bytes  4 to 11 : "NETSCAPE"

  207.                 bytes 12 to 14 : "2.0"

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

  209.                                          (three bytes of data to follow)

  210.                 byte  16       : 1 (hex 0x01)

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

  212.                                          lo-hi byte format. This indicate the

  213.                                          number of iterations the loop should

  214.                                          be executed.

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

  216.         */

  217. 

  218.     /* application extension header */

  219. #ifdef GIF_ADD_APP_HEADER

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

  221.     put_byte(pb, 0x21);

  222.     put_byte(pb, 0xff);

  223.     put_byte(pb, 0x0b);

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

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

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

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

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

  229.     }

  230. #endif

  231.     return 0;

  232. }

  233. 

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

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

  236. {

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

  238. }

  239. 

  240. 

  241. static int gif_image_write_image(ByteIOContext *pb,

  242.                                  int x1, int y1, int width, int height,

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

  244. {

  245.     PutBitContext p;

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

  247.     int i, left, w, v;

  248.     const uint8_t *ptr;

  249.     /* image block */

  250. 

  251.     put_byte(pb, 0x2c);

  252.     put_le16(pb, x1);

  253.     put_le16(pb, y1);

  254.     put_le16(pb, width);

  255.     put_le16(pb, height);

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

  257.     /* no local clut */

  258. 

  259.     put_byte(pb, 0x08);

  260. 

  261.     left= width * height;

  262. 

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

  264. 

  265. /*

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

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

  268.  */

  269.     ptr = buf;

  270.     w = width;

  271.     while(left>0) {

  272. 

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

  274. 

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

  276.             if (pix_fmt == PIX_FMT_RGB24) {

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

  278.                 ptr+=3;

  279.             } else {

  280.                 v = *ptr++;

  281.             }

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

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

  284.                 w = width;

  285.                 buf += linesize;

  286.                 ptr = buf;

  287.             }

  288.         }

  289. 

  290.         if(left<=GIF_CHUNKS) {

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

  292.             gif_flush_put_bits_rev(&p);

  293.         }

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

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

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

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

  298.         }

  299.         left-=GIF_CHUNKS;

  300.     }

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

  302. 

  303.     return 0;

  304. }

  305. 

  306. typedef struct {

  307.     int64_t time, file_time;

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

  309. } GIFContext;

  310. 

  311. static int gif_write_header(AVFormatContext *s)

  312. {

  313.     GIFContext *gif = s->priv_data;

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

  315.     AVCodecContext *enc, *video_enc;

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

  317. 

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

  319.     if(s->nb_streams > 1)

  320.         return -1;

  321. */

  322.     gif->time = 0;

  323.     gif->file_time = 0;

  324. 

  325.     video_enc = NULL;

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

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

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

  329.             video_enc = enc;

  330.     }

  331. 

  332.     if (!video_enc) {

  333.         av_free(gif);

  334.         return -1;

  335.     } else {

  336.         width = video_enc->width;

  337.         height = video_enc->height;

  338.         loop_count = s->loop_output;

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

  340.     }

  341. 

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

  343.     video_enc->pix_fmt = PIX_FMT_RGB24;

  344. 

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

  346. 

  347.     put_flush_packet(&s->pb);

  348.     return 0;

  349. }

  350. 

  351. static int gif_write_video(AVFormatContext *s,

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

  353. {

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

  355.     GIFContext *gif = s->priv_data;

  356.     int jiffies;

  357.     int64_t delay;

  358. 

  359.     /* graphic control extension block */

  360.     put_byte(pb, 0x21);

  361.     put_byte(pb, 0xf9);

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

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

  364. 

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

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

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

  368. 

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

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

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

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

  373. 

  374.     put_le16(pb, jiffies);

  375. 

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

  377.     put_byte(pb, 0x00);

  378. 

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

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

  381. 

  382.     put_flush_packet(&s->pb);

  383.     return 0;

  384. }

  385. 

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

  387. {

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

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

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

  391.     else

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

  393. }

  394. 

  395. static int gif_write_trailer(AVFormatContext *s)

  396. {

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

  398. 

  399.     put_byte(pb, 0x3b);

  400.     put_flush_packet(&s->pb);

  401.     return 0;

  402. }

  403. 

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

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

  406. {

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

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

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

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

  411.                           PIX_FMT_PAL8);

  412.     put_byte(pb, 0x3b);

  413.     put_flush_packet(pb);

  414.     return 0;

  415. }

  416. 

  417. AVOutputFormat gif_muxer = {

  418.     "gif",

  419.     "GIF Animation",

  420.     "image/gif",

  421.     "gif",

  422.     sizeof(GIFContext),

  423.     CODEC_ID_NONE,

  424.     CODEC_ID_RAWVIDEO,

  425.     gif_write_header,

  426.     gif_write_packet,

  427.     gif_write_trailer,

  428. };