@@ -20,8 +20,12 @@ Specifically, the GPL parts of FFmpeg are

 There are a handful of files under other licensing terms, namely:

-* The files libavcodec/jfdctfst.c, libavcodec/jfdctint.c, libavcodec/jrevdct.c

-  are taken from libjpeg, see the top of the files for licensing details.

+* The files libavcodec/jfdctfst.c, libavcodec/jfdctint_template.c and

+  libavcodec/jrevdct.c are taken from libjpeg, see the top of the files for

+  licensing details. Specifically note that you must credit the IJG in the

+  documentation accompanying your program if you only distribute executables.

+  You must also indicate any changes including additions and deletions to

+  those three files in the documentation.

 Should you, for whatever reason, prefer to use version 3 of the (L)GPL, then

 the configure parameter --enable-version3 will activate this licensing option

@@ -68,13 +68,13 @@ static const OptionDef options[];

 static const char *input_filename;

 static AVInputFormat *iformat = NULL;

-static const char *binary_unit_prefixes [] = { "", "Ki", "Mi", "Gi", "Ti", "Pi" };

-static const char *decimal_unit_prefixes[] = { "", "K" , "M" , "G" , "T" , "P"  };

+static const char *const binary_unit_prefixes [] = { "", "Ki", "Mi", "Gi", "Ti", "Pi" };

+static const char *const decimal_unit_prefixes[] = { "", "K" , "M" , "G" , "T" , "P"  };

-static const char *unit_second_str          = "s"    ;

-static const char *unit_hertz_str           = "Hz"   ;

-static const char *unit_byte_str            = "byte" ;

-static const char *unit_bit_per_second_str  = "bit/s";

+static const char unit_second_str[]         = "s"    ;

+static const char unit_hertz_str[]          = "Hz"   ;

+static const char unit_byte_str[]           = "byte" ;

+static const char unit_bit_per_second_str[] = "bit/s";

 static uint64_t *nb_streams_packets;

 static uint64_t *nb_streams_frames;

@@ -1872,7 +1872,7 @@ static int http_parse_request(HTTPContext *c)

 static void fmt_bytecount(AVIOContext *pb, int64_t count)

 {

-    static const char *suffix = " kMGTP";

+    static const char suffix[] = " kMGTP";

     const char *s;

     for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);

@@ -1036,7 +1036,7 @@ static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,

     int offset[3] = { global_gain, global_gain - 90, 0 };

     int clipped_offset;

     int noise_flag = 1;

-    static const char *sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };

+    static const char *const sf_str[3] = { "Global gain", "Noise gain", "Intensity stereo position" };

     for (g = 0; g < ics->num_window_groups; g++) {

         for (i = 0; i < ics->max_sfb;) {

             int run_end = band_type_run_end[idx];

@@ -27,8 +27,8 @@ void ff_rv34_inv_transform_noround_neon(DCTELEM *block);

 void ff_rv34_inv_transform_noround_dc_neon(DCTELEM *block);

-void ff_rv34_idct_add_neon(uint8_t *dst, int stride, DCTELEM *block);

-void ff_rv34_idct_dc_add_neon(uint8_t *dst, int stride, int dc);

+void ff_rv34_idct_add_neon(uint8_t *dst, ptrdiff_t stride, DCTELEM *block);

+void ff_rv34_idct_dc_add_neon(uint8_t *dst, ptrdiff_t stride, int dc);

 void ff_rv34dsp_init_neon(RV34DSPContext *c, DSPContext* dsp)

 {

@@ -51,20 +51,20 @@ void ff_put_rv40_chroma_mc4_neon(uint8_t *, uint8_t *, int, int, int, int);

 void ff_avg_rv40_chroma_mc8_neon(uint8_t *, uint8_t *, int, int, int, int);

 void ff_avg_rv40_chroma_mc4_neon(uint8_t *, uint8_t *, int, int, int, int);

-void ff_rv40_weight_func_16_neon(uint8_t *, uint8_t *, uint8_t *, int, int, int);

-void ff_rv40_weight_func_8_neon(uint8_t *, uint8_t *, uint8_t *, int, int, int);

+void ff_rv40_weight_func_16_neon(uint8_t *, uint8_t *, uint8_t *, int, int, ptrdiff_t);

+void ff_rv40_weight_func_8_neon(uint8_t *, uint8_t *, uint8_t *, int, int, ptrdiff_t);

-int ff_rv40_h_loop_filter_strength_neon(uint8_t *src, int stride,

+int ff_rv40_h_loop_filter_strength_neon(uint8_t *src, ptrdiff_t stride,

                                         int beta, int beta2, int edge,

                                         int *p1, int *q1);

-int ff_rv40_v_loop_filter_strength_neon(uint8_t *src, int stride,

+int ff_rv40_v_loop_filter_strength_neon(uint8_t *src, ptrdiff_t stride,

                                         int beta, int beta2, int edge,

                                         int *p1, int *q1);

-void ff_rv40_h_weak_loop_filter_neon(uint8_t *src, int stride, int filter_p1,

+void ff_rv40_h_weak_loop_filter_neon(uint8_t *src, ptrdiff_t stride, int filter_p1,

                                      int filter_q1, int alpha, int beta,

                                      int lim_p0q0, int lim_q1, int lim_p1);

-void ff_rv40_v_weak_loop_filter_neon(uint8_t *src, int stride, int filter_p1,

+void ff_rv40_v_weak_loop_filter_neon(uint8_t *src, ptrdiff_t stride, int filter_p1,

                                      int filter_q1, int alpha, int beta,

                                      int lim_p0q0, int lim_q1, int lim_p1);

@@ -150,7 +150,7 @@ static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)

 }

 #endif

-#define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))

+#define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))

 typedef struct DVBSubCLUT {

     int id;

@@ -77,7 +77,7 @@ typedef struct VP8EncoderContext {

 } VP8Context;

 /** String mappings for enum vp8e_enc_control_id */

-static const char *ctlidstr[] = {

+static const char *const ctlidstr[] = {

     [VP8E_UPD_ENTROPY]           = "VP8E_UPD_ENTROPY",

     [VP8E_UPD_REFERENCE]         = "VP8E_UPD_REFERENCE",

     [VP8E_USE_REFERENCE]         = "VP8E_USE_REFERENCE",

@@ -48,7 +48,7 @@ int ff_xvid_rate_control_init(MpegEncContext *s){

     }

     for(i=0; i<s->rc_context.num_entries; i++){

-        static const char *frame_types = " ipbs";

+        static const char frame_types[] = " ipbs";

         char tmp[256];

         RateControlEntry *rce;

@@ -38,12 +38,6 @@

 /** number of bits used for VLC lookup - longest Huffman code is 9 */

 #define VLC_BITS            9

-

-static const char* sample_message =

-    "Please file a bug report following the instructions at "

-    "http://ffmpeg.org/bugreports.html and include "

-    "a sample of this file.";

-

 typedef struct SubStream {

     /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.

     uint8_t     restart_seen;

@@ -308,10 +302,10 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)

         return AVERROR_INVALIDDATA;

     }

     if (mh.num_substreams > MAX_SUBSTREAMS) {

-        av_log(m->avctx, AV_LOG_ERROR,

+        av_log_ask_for_sample(m->avctx,

                "Number of substreams %d is larger than the maximum supported "

-               "by the decoder. %s\n", mh.num_substreams, sample_message);

-        return AVERROR_INVALIDDATA;

+               "by the decoder.\n", mh.num_substreams);

+        return AVERROR_PATCHWELCOME;

     }

     m->access_unit_size      = mh.access_unit_size;

@@ -410,10 +404,10 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,

     /* This should happen for TrueHD streams with >6 channels and MLP's noise

      * type. It is not yet known if this is allowed. */

     if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {

-        av_log(m->avctx, AV_LOG_ERROR,

+        av_log_ask_for_sample(m->avctx,

                "Number of channels %d is larger than the maximum supported "

-               "by the decoder. %s\n", s->max_channel+2, sample_message);

-        return AVERROR_INVALIDDATA;

+               "by the decoder.\n", s->max_channel + 2);

+        return AVERROR_PATCHWELCOME;

     }

     if (s->min_channel > s->max_channel) {

@@ -455,10 +449,10 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,

     for (ch = 0; ch <= s->max_matrix_channel; ch++) {

         int ch_assign = get_bits(gbp, 6);

         if (ch_assign > s->max_matrix_channel) {

-            av_log(m->avctx, AV_LOG_ERROR,

-                   "Assignment of matrix channel %d to invalid output channel %d. %s\n",

-                   ch, ch_assign, sample_message);

-            return AVERROR_INVALIDDATA;

+            av_log_ask_for_sample(m->avctx,

+                   "Assignment of matrix channel %d to invalid output channel %d.\n",

+                   ch, ch_assign);

+            return AVERROR_PATCHWELCOME;

         }

         s->ch_assign[ch_assign] = ch;

     }

@@ -813,8 +807,8 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,

     if (s->data_check_present) {

         expected_stream_pos  = get_bits_count(gbp);

         expected_stream_pos += get_bits(gbp, 16);

-        av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "

-               "we have not tested yet. %s\n", sample_message);

+        av_log_ask_for_sample(m->avctx, "This file contains some features "

+                              "we have not tested yet.\n");

     }

     if (s->blockpos + s->blocksize > m->access_unit_size) {

@@ -1395,20 +1395,6 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,

     int i, stuffing_count, ret;

     int context_count = s->slice_context_count;

-    if (!pkt->data &&

-        (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)

-        return ret;

-

-    for (i = 0; i < context_count; i++) {

-        int start_y = s->thread_context[i]->start_mb_y;

-        int   end_y = s->thread_context[i]->  end_mb_y;

-        int h       = s->mb_height;

-        uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);

-        uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);

-

-        init_put_bits(&s->thread_context[i]->pb, start, end - start);

-    }

-

     s->picture_in_gop_number++;

     if (load_input_picture(s, pic_arg) < 0)

@@ -1420,6 +1406,20 @@ int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,

     /* output? */

     if (s->new_picture.f.data[0]) {

+        if (!pkt->data &&

+            (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)

+            return ret;

+

+        for (i = 0; i < context_count; i++) {

+            int start_y = s->thread_context[i]->start_mb_y;

+            int   end_y = s->thread_context[i]->  end_mb_y;

+            int h       = s->mb_height;

+            uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);

+            uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);

+

+            init_put_bits(&s->thread_context[i]->pb, start, end - start);

+        }

+

         s->pict_type = s->new_picture.f.pict_type;

         //emms_c();

         //printf("qs:%f %f %d\n", s->new_picture.quality,

@@ -732,5 +732,5 @@ AVCodec ff_png_decoder = {

     .close          = png_dec_end,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,

-    .long_name = NULL_IF_CONFIG_SMALL("PNG image"),

+    .long_name = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),

 };

@@ -445,5 +445,5 @@ AVCodec ff_png_encoder = {

                                           PIX_FMT_GRAY8, PIX_FMT_GRAY8A,

                                           PIX_FMT_GRAY16BE,

                                           PIX_FMT_MONOBLACK, PIX_FMT_NONE},

-    .long_name= NULL_IF_CONFIG_SMALL("PNG image"),

+    .long_name= NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),

 };

@@ -53,7 +53,7 @@ static av_always_inline void rv34_row_transform(int temp[16], DCTELEM *block)

  * Real Video 3.0/4.0 inverse transform + sample reconstruction

  * Code is almost the same as in SVQ3, only scaling is different.

  */

-static void rv34_idct_add_c(uint8_t *dst, int stride, DCTELEM *block){

+static void rv34_idct_add_c(uint8_t *dst, ptrdiff_t stride, DCTELEM *block){

     int      temp[16];

     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

     int      i;

@@ -101,7 +101,7 @@ static void rv34_inv_transform_noround_c(DCTELEM *block){

     }

 }

-static void rv34_idct_dc_add_c(uint8_t *dst, int stride, int dc)

+static void rv34_idct_dc_add_c(uint8_t *dst, ptrdiff_t stride, int dc)

 {

     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

     int i, j;

@@ -32,24 +32,24 @@

 typedef void (*rv40_weight_func)(uint8_t *dst/*align width (8 or 16)*/,

                                  uint8_t *src1/*align width (8 or 16)*/,

                                  uint8_t *src2/*align width (8 or 16)*/,

-                                 int w1, int w2, int stride);

+                                 int w1, int w2, ptrdiff_t stride);

 typedef void (*rv34_inv_transform_func)(DCTELEM *block);

-typedef void (*rv34_idct_add_func)(uint8_t *dst, int stride, DCTELEM *block);

-typedef void (*rv34_idct_dc_add_func)(uint8_t *dst, int stride,

+typedef void (*rv34_idct_add_func)(uint8_t *dst, ptrdiff_t stride, DCTELEM *block);

+typedef void (*rv34_idct_dc_add_func)(uint8_t *dst, ptrdiff_t stride,

                                       int   dc);

-typedef void (*rv40_weak_loop_filter_func)(uint8_t *src, int stride,

+typedef void (*rv40_weak_loop_filter_func)(uint8_t *src, ptrdiff_t stride,

                                            int filter_p1, int filter_q1,

                                            int alpha, int beta,

                                            int lims, int lim_q1, int lim_p1);

-typedef void (*rv40_strong_loop_filter_func)(uint8_t *src, int stride,

+typedef void (*rv40_strong_loop_filter_func)(uint8_t *src, ptrdiff_t stride,

                                              int alpha, int lims,

                                              int dmode, int chroma);

-typedef int (*rv40_loop_filter_strength_func)(uint8_t *src, int stride,

+typedef int (*rv40_loop_filter_strength_func)(uint8_t *src, ptrdiff_t stride,

                                               int beta, int beta2, int edge,

                                               int *p1, int *q1);

@@ -278,7 +278,7 @@ RV40_CHROMA_MC(put_, op_put)

 RV40_CHROMA_MC(avg_, op_avg)

 #define RV40_WEIGHT_FUNC(size) \

-static void rv40_weight_func_ ## size (uint8_t *dst, uint8_t *src1, uint8_t *src2, int w1, int w2, int stride)\

+static void rv40_weight_func_ ## size (uint8_t *dst, uint8_t *src1, uint8_t *src2, int w1, int w2, ptrdiff_t stride)\

 {\

     int i, j;\

 \

@@ -316,7 +316,7 @@ static const uint8_t rv40_dither_r[16] = {

  */

 static av_always_inline void rv40_weak_loop_filter(uint8_t *src,

                                                    const int step,

-                                                   const int stride,

+                                                   const ptrdiff_t stride,

                                                    const int filter_p1,

                                                    const int filter_q1,

                                                    const int alpha,

@@ -362,7 +362,7 @@ static av_always_inline void rv40_weak_loop_filter(uint8_t *src,

     }

 }

-static void rv40_h_weak_loop_filter(uint8_t *src, const int stride,

+static void rv40_h_weak_loop_filter(uint8_t *src, const ptrdiff_t stride,

                                     const int filter_p1, const int filter_q1,

                                     const int alpha, const int beta,

                                     const int lim_p0q0, const int lim_q1,

@@ -372,7 +372,7 @@ static void rv40_h_weak_loop_filter(uint8_t *src, const int stride,

                           alpha, beta, lim_p0q0, lim_q1, lim_p1);

 }

-static void rv40_v_weak_loop_filter(uint8_t *src, const int stride,

+static void rv40_v_weak_loop_filter(uint8_t *src, const ptrdiff_t stride,

                                     const int filter_p1, const int filter_q1,

                                     const int alpha, const int beta,

                                     const int lim_p0q0, const int lim_q1,

@@ -384,7 +384,7 @@ static void rv40_v_weak_loop_filter(uint8_t *src, const int stride,

 static av_always_inline void rv40_strong_loop_filter(uint8_t *src,

                                                      const int step,

-                                                     const int stride,

+                                                     const ptrdiff_t stride,

                                                      const int alpha,

                                                      const int lims,

                                                      const int dmode,

@@ -440,14 +440,14 @@ static av_always_inline void rv40_strong_loop_filter(uint8_t *src,

     }

 }

-static void rv40_h_strong_loop_filter(uint8_t *src, const int stride,

+static void rv40_h_strong_loop_filter(uint8_t *src, const ptrdiff_t stride,

                                       const int alpha, const int lims,

                                       const int dmode, const int chroma)

 {

     rv40_strong_loop_filter(src, stride, 1, alpha, lims, dmode, chroma);

 }

-static void rv40_v_strong_loop_filter(uint8_t *src, const int stride,

+static void rv40_v_strong_loop_filter(uint8_t *src, const ptrdiff_t stride,

                                       const int alpha, const int lims,

                                       const int dmode, const int chroma)

 {

@@ -455,7 +455,7 @@ static void rv40_v_strong_loop_filter(uint8_t *src, const int stride,

 }

 static av_always_inline int rv40_loop_filter_strength(uint8_t *src,

-                                                      int step, int stride,

+                                                      int step, ptrdiff_t stride,

                                                       int beta, int beta2,

                                                       int edge,

                                                       int *p1, int *q1)

@@ -490,14 +490,14 @@ static av_always_inline int rv40_loop_filter_strength(uint8_t *src,

     return strong0 && strong1;

 }

-static int rv40_h_loop_filter_strength(uint8_t *src, int stride,

+static int rv40_h_loop_filter_strength(uint8_t *src, ptrdiff_t stride,

                                        int beta, int beta2, int edge,

                                        int *p1, int *q1)

 {

     return rv40_loop_filter_strength(src, stride, 1, beta, beta2, edge, p1, q1);

 }

-static int rv40_v_loop_filter_strength(uint8_t *src, int stride,

+static int rv40_v_loop_filter_strength(uint8_t *src, ptrdiff_t stride,

                                        int beta, int beta2, int edge,

                                        int *p1, int *q1)

 {

@@ -77,7 +77,11 @@ static int sunrast_decode_frame(AVCodecContext *avctx, void *data,

         av_log(avctx, AV_LOG_ERROR, "invalid image size\n");

         return AVERROR_INVALIDDATA;

     }

-    if (maptype & ~1) {

+    if (maptype == RMT_RAW) {

+        av_log_ask_for_sample(avctx, "unsupported colormap type\n");

+        return AVERROR_PATCHWELCOME;

+    }

+    if (maptype > RMT_RAW) {

         av_log(avctx, AV_LOG_ERROR, "invalid colormap type\n");

         return AVERROR_INVALIDDATA;

     }

@@ -992,9 +992,11 @@ int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,

         ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);

         if (!ret && *got_packet_ptr) {

             if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {

-                avpkt->pts = frame->pts;

-                avpkt->duration = ff_samples_to_time_base(avctx,

-                                                          frame->nb_samples);

+                if (avpkt->pts == AV_NOPTS_VALUE)

+                    avpkt->pts = frame->pts;

+                if (!avpkt->duration)

+                    avpkt->duration = ff_samples_to_time_base(avctx,

+                                                              frame->nb_samples);

             }

             avpkt->dts = avpkt->pts;

         } else {

@@ -26,8 +26,8 @@

 void ff_rv34_idct_dc_mmx2(DCTELEM *block);

 void ff_rv34_idct_dc_noround_mmx2(DCTELEM *block);

-void ff_rv34_idct_dc_add_mmx(uint8_t *dst, int stride, int dc);

-void ff_rv34_idct_dc_add_sse4(uint8_t *dst, int stride, int dc);

+void ff_rv34_idct_dc_add_mmx(uint8_t *dst, ptrdiff_t stride, int dc);

+void ff_rv34_idct_dc_add_sse4(uint8_t *dst, ptrdiff_t stride, int dc);

 av_cold void ff_rv34dsp_init_x86(RV34DSPContext* c, DSPContext *dsp)

 {

@@ -42,9 +42,9 @@ void ff_avg_rv40_chroma_mc4_3dnow(uint8_t *dst, uint8_t *src,

 #define DECLARE_WEIGHT(opt) \

 void ff_rv40_weight_func_16_##opt(uint8_t *dst, uint8_t *src1, uint8_t *src2, \

-                                  int w1, int w2, int stride); \

+                                  int w1, int w2, ptrdiff_t stride); \

 void ff_rv40_weight_func_8_##opt (uint8_t *dst, uint8_t *src1, uint8_t *src2, \

-                                  int w1, int w2, int stride);

+                                  int w1, int w2, ptrdiff_t stride);

 DECLARE_WEIGHT(mmx)

 DECLARE_WEIGHT(sse2)

 DECLARE_WEIGHT(ssse3)

@@ -1,18 +1,18 @@

 /*

- * This file is part of Libav.

+ * This file is part of FFmpeg.

  *

- * Libav is free software; you can redistribute it and/or

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

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

  * License as published by the Free Software Foundation; either

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

  *

- * Libav is distributed in the hope that it will be useful,

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

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

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

  * Lesser General Public License for more details.

  *

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

- * License along with Libav; if not, write to the Free Software

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

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

  */

@@ -30,7 +30,7 @@

 #include "libavutil/pixdesc.h"

 #include "avfilter.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "w",

     "h",

     "cw",

@@ -32,7 +32,7 @@

 #include "libavutil/imgutils.h"

 #include "libavutil/mathematics.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "in_w", "iw",   ///< width  of the input video

     "in_h", "ih",   ///< height of the input video

     "out_w", "ow",  ///< width  of the cropped video

@@ -51,7 +51,7 @@

 #include FT_FREETYPE_H

 #include FT_GLYPH_H

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "main_w", "w", "W",       ///< width  of the input video

     "main_h", "h", "H",       ///< height of the input video

     "tw", "text_w",           ///< width  of the rendered text

@@ -72,8 +72,8 @@ static const char * const var_names[] = {

     NULL

 };

-static const char *fun2_names[] = {

-    "rand",

+static const char *const fun2_names[] = {

+    "rand"

 };

 static double drand(void *opaque, double min, double max)

@@ -30,7 +30,7 @@

 #include "avfilter.h"

 #include "internal.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "w",        ///< width of the input video

     "h",        ///< height of the input video

     "val",      ///< input value for the pixel

@@ -38,7 +38,7 @@

 #include "internal.h"

 #include "drawutils.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "main_w",    "W", ///< width  of the main    video

     "main_h",    "H", ///< height of the main    video

     "overlay_w", "w", ///< width  of the overlay video

@@ -35,7 +35,7 @@

 #include "libavutil/mathematics.h"

 #include "drawutils.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "in_w",   "iw",

     "in_h",   "ih",

     "out_w",  "ow",

@@ -31,7 +31,7 @@

 #include "libavutil/avassert.h"

 #include "libswscale/swscale.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "in_w",   "iw",

     "in_h",   "ih",

     "out_w",  "ow",

@@ -27,7 +27,7 @@

 #include "libavutil/fifo.h"

 #include "avfilter.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "TB",                ///< timebase

     "pts",               ///< original pts in the file of the frame

@@ -30,7 +30,7 @@

 #include "libavutil/mathematics.h"

 #include "avfilter.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "INTERLACED",  ///< tell if the current frame is interlaced

     "N",           ///< frame number (starting at zero)

     "POS",         ///< original position in the file of the frame

@@ -30,7 +30,7 @@

 #include "avfilter.h"

 #include "internal.h"

-static const char * const var_names[] = {

+static const char *const var_names[] = {

     "AVTB",   /* default timebase 1/AV_TIME_BASE */

     "intb",   /* input timebase */

     NULL

@@ -53,7 +53,9 @@

 #define GIF_CHUNKS 100

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

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

+/* 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 */

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

 typedef struct {

@@ -65,8 +67,15 @@ typedef struct {

 /* we use the standard 216 color palette */

 /* this script was used to create the palette:

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

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

+ * 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

+ *             echo -n "{ 0x$r, 0x$g, 0x$b }, "

+ *         done

+ *         echo ""

+ *     done

+ * done

  */

 static const rgb_triplet gif_clut[216] = {

@@ -109,9 +118,8 @@ static const rgb_triplet gif_clut[216] = {

 };

 /* GIF header */

-static int gif_image_write_header(AVIOContext *pb,

-                                  int width, int height, int loop_count,

-                                  uint32_t *palette)

+static int gif_image_write_header(AVIOContext *pb, int width, int height,

+                                  int loop_count, uint32_t *palette)

 {

     int i;

     unsigned int v;

@@ -127,44 +135,45 @@ static int gif_image_write_header(AVIOContext *pb,

     /* the global palette */

     if (!palette) {

-        avio_write(pb, (const unsigned char *)gif_clut, 216*3);

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

+        avio_write(pb, (const unsigned char *)gif_clut, 216 * 3);

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

             avio_w8(pb, 0);

     } else {

-        for(i=0;i<256;i++) {

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

             v = palette[i];

             avio_w8(pb, (v >> 16) & 0xff);

-            avio_w8(pb, (v >> 8) & 0xff);

-            avio_w8(pb, (v) & 0xff);

+            avio_w8(pb, (v >>  8) & 0xff);

+            avio_w8(pb, (v)       & 0xff);

         }

     }

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

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

-

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

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

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

-                                         (eleven bytes of data to follow)

-                bytes  4 to 11 : "NETSCAPE"

-                bytes 12 to 14 : "2.0"

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

-                                         (three bytes of data to follow)

-                byte  16       : 1 (hex 0x01)

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

-                                         lo-hi byte format. This indicate the

-                                         number of iterations the loop should

-                                         be executed.

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

-        */

+    /* update: this is the 'NETSCAPE EXTENSION' that allows for looped animated

+     * GIF, see http://members.aol.com/royalef/gifabout.htm#net-extension

+     *

+     * byte   1       : 33 (hex 0x21) GIF Extension code

+     * byte   2       : 255 (hex 0xFF) Application Extension Label

+     * byte   3       : 11 (hex (0x0B) Length of Application Block

+     *                          (eleven bytes of data to follow)

+     * bytes  4 to 11 : "NETSCAPE"

+     * bytes 12 to 14 : "2.0"

+     * byte  15       : 3 (hex 0x03) Length of Data Sub-Block

+     *                          (three bytes of data to follow)

+     * byte  16       : 1 (hex 0x01)

+     * bytes 17 to 18 : 0 to 65535, an unsigned integer in

+     *                          lo-hi byte format. This indicate the

+     *                          number of iterations the loop should

+     *                          be executed.

+     * bytes 19       : 0 (hex 0x00) a Data Sub-block Terminator

+     */

     /* application extension header */

 #ifdef GIF_ADD_APP_HEADER

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

-    avio_w8(pb, 0x21);

-    avio_w8(pb, 0xff);

-    avio_w8(pb, 0x0b);

-        avio_write(pb, "NETSCAPE2.0", sizeof("NETSCAPE2.0") - 1);  // bytes 4 to 14

+        avio_w8(pb, 0x21);

+        avio_w8(pb, 0xff);

+        avio_w8(pb, 0x0b);

+        // bytes 4 to 14

+        avio_write(pb, "NETSCAPE2.0", sizeof("NETSCAPE2.0") - 1);

         avio_w8(pb, 0x03); // byte 15

         avio_w8(pb, 0x01); // byte 16

         avio_wl16(pb, (uint16_t)loop_count);

@@ -180,7 +189,6 @@ static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)

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

 }

-

 static int gif_image_write_image(AVIOContext *pb,

                                  int x1, int y1, int width, int height,

                                  const uint8_t *buf, int linesize, int pix_fmt)

@@ -201,45 +209,44 @@ static int gif_image_write_image(AVIOContext *pb,

     avio_w8(pb, 0x08);

-    left= width * height;

+    left = width * height;

     init_put_bits(&p, buffer, 130);

 /*

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

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

+ * the thing here is the bitstream is written as little packets, with a size

+ * byte before but it's still the same bitstream between packets (no flush !)

  */

     ptr = buf;

-    w = width;

-    while(left>0) {

-

+    w   = width;

+    while (left > 0) {

         put_bits(&p, 9, 0x0100); /* clear code */

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

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

             if (pix_fmt == PIX_FMT_RGB24) {

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

-                ptr+=3;

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

+                ptr += 3;

             } else {

                 v = *ptr++;

             }

             put_bits(&p, 9, v);

             if (--w == 0) {

-                w = width;

+                w    = width;

                 buf += linesize;

-                ptr = buf;

+                ptr  = buf;

             }

         }

-        if(left<=GIF_CHUNKS) {

+        if (left <= GIF_CHUNKS) {

             put_bits(&p, 9, 0x101); /* end of stream */

             flush_put_bits(&p);

         }

-        if(put_bits_ptr(&p) - p.buf > 0) {

+        if (put_bits_ptr(&p) - p.buf > 0) {

             avio_w8(pb, put_bits_ptr(&p) - p.buf); /* byte count of the packet */

             avio_write(pb, p.buf, put_bits_ptr(&p) - p.buf); /* the actual buffer */

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

         }

-        left-=GIF_CHUNKS;

+        left -= GIF_CHUNKS;

     }

     avio_w8(pb, 0x00); /* end of image block */

@@ -261,14 +268,14 @@ static int gif_write_header(AVFormatContext *s)

     int i, width, height /*, rate*/;

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

-    if(s->nb_streams > 1)

-        return -1;

-*/

-    gif->time = 0;

+ *  if (s->nb_streams > 1)

+ *      return -1;

+ */

+    gif->time      = 0;

     gif->file_time = 0;

     video_enc = NULL;

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

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

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

         if (enc->codec_type != AVMEDIA_TYPE_AUDIO)

             video_enc = enc;

@@ -278,13 +285,14 @@ static int gif_write_header(AVFormatContext *s)

         av_free(gif);

         return -1;

     } else {

-        width = video_enc->width;

+        width  = video_enc->width;

         height = video_enc->height;

 //        rate = video_enc->time_base.den;

     }

     if (video_enc->pix_fmt != PIX_FMT_RGB24) {

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

+        av_log(s, AV_LOG_ERROR,

+               "ERROR: gif only handles the rgb24 pixel format. Use -pix_fmt rgb24.\n");

         return AVERROR(EIO);

     }

@@ -294,8 +302,8 @@ static int gif_write_header(AVFormatContext *s)

     return 0;

 }

-static int gif_write_video(AVFormatContext *s,

-                           AVCodecContext *enc, const uint8_t *buf, int size)

+static int gif_write_video(AVFormatContext *s, AVCodecContext *enc,

+                           const uint8_t *buf, int size)

 {

     AVIOContext *pb = s->pb;

     int jiffies;

@@ -311,7 +319,7 @@ static int gif_write_video(AVFormatContext *s,

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

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

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

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

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

     avio_wl16(pb, jiffies);

@@ -346,7 +354,8 @@ static int gif_write_trailer(AVFormatContext *s)

 #define OFFSET(x) offsetof(GIFContext, x)

 #define ENC AV_OPT_FLAG_ENCODING_PARAM

 static const AVOption options[] = {

-    { "loop", "Number of times to loop the output.", OFFSET(loop), AV_OPT_TYPE_INT, {0}, 0, 65535, ENC },

+    { "loop", "Number of times to loop the output.", OFFSET(loop),

+      AV_OPT_TYPE_INT, { 0 }, 0, 65535, ENC },

     { NULL },

 };

@@ -358,15 +367,15 @@ static const AVClass gif_muxer_class = {

 };

 AVOutputFormat ff_gif_muxer = {

-    .name              = "gif",

-    .long_name         = NULL_IF_CONFIG_SMALL("GIF Animation"),

-    .mime_type         = "image/gif",

-    .extensions        = "gif",

-    .priv_data_size    = sizeof(GIFContext),

-    .audio_codec       = CODEC_ID_NONE,

-    .video_codec       = CODEC_ID_RAWVIDEO,

-    .write_header      = gif_write_header,

-    .write_packet      = gif_write_packet,

-    .write_trailer     = gif_write_trailer,

-    .priv_class = &gif_muxer_class,

+    .name           = "gif",

+    .long_name      = NULL_IF_CONFIG_SMALL("GIF Animation"),

+    .mime_type      = "image/gif",

+    .extensions     = "gif",

+    .priv_data_size = sizeof(GIFContext),

+    .audio_codec    = CODEC_ID_NONE,

+    .video_codec    = CODEC_ID_RAWVIDEO,

+    .write_header   = gif_write_header,

+    .write_packet   = gif_write_packet,

+    .write_trailer  = gif_write_trailer,

+    .priv_class     = &gif_muxer_class,

 };

@@ -138,6 +138,11 @@ static enum CodecID av_str2id(const IdStrMap *tags, const char *str)

     return CODEC_ID_NONE;

 }

+enum CodecID ff_guess_image2_codec(const char *filename)

+{

+    return av_str2id(img_tags, filename);

+}