Merge remote branch 'qatar/master'

* qatar/master:
  graphparser: add a NULL check on the argument passed to strstr
  setdar: prefer "sar" over "par" in log info message
  fade: fix draw_slice() check on fade->factor value
  fade: make draw_slice() chroma check against planes 1 and 2
  win32: include the correct header in cmdutils.c
  ac3: fix memleak in fixed-point encoder
  flashsv: Return more meaningful error values.
  flashsv: Employ explicit AVCodec struct initializers.
  read AVI palette from the end of extradata
  cosmetics: K&R coding style and more whitespace for Flash Screen Video

Merged-by: Michael Niedermayer <michaelni@gmx.at>

cmdutils.c

@@ -154,6 +154,7 @@ static const OptionDef* find_option(const OptionDef *po, const char *name){
 }
 
 #if defined(_WIN32) && !defined(__MINGW32CE__)
+#include <windows.h>
 /* Will be leaked on exit */
 static char** win32_argv_utf8 = NULL;
 static int win32_argc = 0;

libavcodec/ac3enc_fixed.c

@@ -36,7 +36,7 @@
  */
 static av_cold void mdct_end(AC3MDCTContext *mdct)
 {
-    ff_fft_end(&mdct->fft);
+    ff_mdct_end(&mdct->fft);
 }
 
 

libavcodec/flashsv.c

@@ -49,12 +49,11 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <zlib.h>
 
 #include "avcodec.h"
 #include "get_bits.h"
 
-#include <zlib.h>
-
 typedef struct FlashSVContext {
     AVCodecContext *avctx;
     AVFrame         frame;
@@ -71,8 +70,7 @@ static void copy_region(uint8_t *sptr, uint8_t *dptr,
 {
     int i;
 
-    for (i = dx+h; i > dx; i--)
-    {
+    for (i = dx + h; i > dx; i--) {
         memcpy(dptr + (i * stride) + dy * 3, sptr, w * 3);
         sptr += w * 3;
     }
@@ -100,9 +98,8 @@ static av_cold int flashsv_decode_init(AVCodecContext *avctx)
 }
 
 
-static int flashsv_decode_frame(AVCodecContext *avctx,
-                                    void *data, int *data_size,
-                                    AVPacket *avpkt)
+static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
+                                int *data_size, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
@@ -136,7 +133,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
         av_free(s->tmpblock);
         if ((s->tmpblock = av_malloc(3 * s->block_width * s->block_height)) == NULL) {
             av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
-            return -1;
+            return AVERROR(ENOMEM);
         }
     }
     s->block_size = s->block_width * s->block_height;
@@ -167,16 +164,14 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
     }
 
     /* loop over all block columns */
-    for (j = 0; j < v_blocks + (v_part?1:0); j++)
-    {
+    for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 
         int hp = j * s->block_height; // horiz position in frame
         int hs = (j < v_blocks) ? s->block_height : v_part; // size of block
 
 
         /* loop over all block rows */
-        for (i = 0; i < h_blocks + (h_part?1:0); i++)
-        {
+        for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
             int wp = i * s->block_width; // vert position in frame
             int ws = (i < h_blocks) ? s->block_width : h_part; // size of block
 
@@ -193,8 +188,7 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
             } else {
                 /* decompress block */
                 int ret = inflateReset(&(s->zstream));
-                if (ret != Z_OK)
-                {
+                if (ret != Z_OK) {
                     av_log(avctx, AV_LOG_ERROR, "error in decompression (reset) of block %dx%d\n", i, j);
                     /* return -1; */
                 }
@@ -203,19 +197,18 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
                 s->zstream.next_out  = s->tmpblock;
                 s->zstream.avail_out = s->block_size*3;
                 ret = inflate(&(s->zstream), Z_FINISH);
-                if (ret == Z_DATA_ERROR)
-                {
+                if (ret == Z_DATA_ERROR) {
                     av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
                     inflateSync(&(s->zstream));
                     ret = inflate(&(s->zstream), Z_FINISH);
                 }
 
-                if ((ret != Z_OK) && (ret != Z_STREAM_END))
-                {
+                if ((ret != Z_OK) && (ret != Z_STREAM_END)) {
                     av_log(avctx, AV_LOG_ERROR, "error in decompression of block %dx%d: %d\n", i, j, ret);
                     /* return -1; */
                 }
-                copy_region(s->tmpblock, s->frame.data[0], s->image_height-(hp+hs+1), wp, hs, ws, s->frame.linesize[0]);
+                copy_region(s->tmpblock, s->frame.data[0], s->image_height - (hp + hs + 1),
+                            wp, hs, ws, s->frame.linesize[0]);
                 skip_bits_long(&gb, 8 * size);   /* skip the consumed bits */
             }
         }
@@ -249,15 +242,14 @@ static av_cold int flashsv_decode_end(AVCodecContext *avctx)
 
 
 AVCodec ff_flashsv_decoder = {
-    "flashsv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FLASHSV,
-    sizeof(FlashSVContext),
-    flashsv_decode_init,
-    NULL,
-    flashsv_decode_end,
-    flashsv_decode_frame,
-    CODEC_CAP_DR1,
+    .name           = "flashsv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FLASHSV,
+    .priv_data_size = sizeof(FlashSVContext),
+    .init           = flashsv_decode_init,
+    .close          = flashsv_decode_end,
+    .decode         = flashsv_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
 };

libavcodec/flashsvenc.c

@@ -76,8 +76,9 @@ typedef struct FlashSVContext {
     int             last_key_frame;
 } FlashSVContext;
 
-static int copy_region_enc(uint8_t *sptr, uint8_t *dptr,
-        int dx, int dy, int h, int w, int stride, uint8_t *pfptr) {
+static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, int dx, int dy,
+                           int h, int w, int stride, uint8_t *pfptr)
+{
     int i, j;
     uint8_t *nsptr;
     uint8_t *npfptr;
@@ -105,7 +106,7 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
 
     if ((avctx->width > 4095) || (avctx->height > 4095)) {
         av_log(avctx, AV_LOG_ERROR, "Input dimensions too large, input must be max 4096x4096 !\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     // Needed if zlib unused or init aborted before deflateInit
@@ -121,15 +122,17 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
 
     if (!s->tmpblock || !s->encbuffer) {
         av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
-        return -1;
+        return AVERROR(ENOMEM);
     }
 
     return 0;
 }
 
 
-static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf_size,
-     int block_width, int block_height, uint8_t *previous_frame, int* I_frame) {
+static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf,
+                            int buf_size, int block_width, int block_height,
+                            uint8_t *previous_frame, int *I_frame)
+{
 
     PutBitContext pb;
     int h_blocks, v_blocks, h_part, v_part, i, j;
@@ -151,15 +154,13 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf
     v_part   = s->image_height % block_height;
 
     /* loop over all block columns */
-    for (j = 0; j < v_blocks + (v_part?1:0); j++)
-    {
+    for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 
         int hp = j * block_height; // horiz position in frame
         int hs = (j < v_blocks) ? block_height : v_part; // size of block
 
         /* loop over all block rows */
-        for (i = 0; i < h_blocks + (h_part?1:0); i++)
-        {
+        for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
             int wp  = i * block_width; // vert position in frame
             int ws  = (i < h_blocks) ? block_width : h_part; // size of block
             int ret = Z_OK;
@@ -167,8 +168,11 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf
 
             ptr = buf + buf_pos;
 
-            //copy the block to the temp buffer before compression (if it differs from the previous frame's block)
-            res = copy_region_enc(p->data[0], s->tmpblock, s->image_height-(hp+hs+1), wp, hs, ws, p->linesize[0], previous_frame);
+            /* copy the block to the temp buffer before compression
+             * (if it differs from the previous frame's block) */
+            res = copy_region_enc(p->data[0], s->tmpblock,
+                                  s->image_height - (hp + hs + 1),
+                                  wp, hs, ws, p->linesize[0], previous_frame);
 
             if (res || *I_frame) {
                 unsigned long zsize;
@@ -200,7 +204,8 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf
 }
 
 
-static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data)
+static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,
+                                int buf_size, void *data)
 {
     FlashSVContext * const s = avctx->priv_data;
     AVFrame *pict = data;
@@ -217,7 +222,7 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
         s->previous_frame = av_mallocz(FFABS(p->linesize[0]) * s->image_height);
         if (!s->previous_frame) {
             av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
-            return -1;
+            return AVERROR(ENOMEM);
         }
         I_frame = 1;
     }
@@ -239,7 +244,8 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
 
     if (buf_size < s->image_width*s->image_height*3) {
         //Conservative upper bound check for compressed data
-        av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n", buf_size, s->image_width*s->image_height*3);
+        av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n",
+               buf_size, s->image_width * s->image_height * 3);
         return -1;
     }
 
@@ -249,7 +255,8 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
     if (p->linesize[0] > 0)
         memcpy(s->previous_frame, p->data[0], s->image_height * p->linesize[0]);
     else
-        memcpy(s->previous_frame, p->data[0] + p->linesize[0] * (s->image_height-1), s->image_height*FFABS(p->linesize[0]));
+        memcpy(s->previous_frame, p->data[0] + p->linesize[0] * (s->image_height - 1),
+               s->image_height * FFABS(p->linesize[0]));
 
     //mark the frame type so the muxer can mux it correctly
     if (I_frame) {
@@ -281,13 +288,13 @@ static av_cold int flashsv_encode_end(AVCodecContext *avctx)
 }
 
 AVCodec ff_flashsv_encoder = {
-    "flashsv",
-    AVMEDIA_TYPE_VIDEO,
-    CODEC_ID_FLASHSV,
-    sizeof(FlashSVContext),
-    flashsv_encode_init,
-    flashsv_encode_frame,
-    flashsv_encode_end,
+    .name           = "flashsv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = CODEC_ID_FLASHSV,
+    .priv_data_size = sizeof(FlashSVContext),
+    .init           = flashsv_encode_init,
+    .encode         = flashsv_encode_frame,
+    .close          = flashsv_encode_end,
     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
 };

libavformat/avidec.c

@@ -592,12 +592,16 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     /* This code assumes that extradata contains only palette. */
                     /* This is true for all paletted codecs implemented in FFmpeg. */
                     if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
+                        int pal_size = (1 << st->codec->bits_per_coded_sample) << 2;
+                        const uint8_t *pal_src;
+
+                        pal_size = FFMIN(pal_size, st->codec->extradata_size);
+                        pal_src = st->codec->extradata + st->codec->extradata_size - pal_size;
 #if HAVE_BIGENDIAN
-                        for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
-                            ast->pal[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
+                        for (i = 0; i < pal_size/4; i++)
+                            ast->pal[i] = AV_RL32(pal_src+4*i);
 #else
-                        memcpy(ast->pal, st->codec->extradata,
-                               FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
+                        memcpy(ast->pal, pal_src, pal_size);
 #endif
                         ast->has_pal = 1;
                     }