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>

5 files changed, 154 insertions, 150 deletions

diff --git a/cmdutils.c b/cmdutils.c
index ffc22bfd4e..5ad45e107d 100644
--- a/cmdutils.c
+++ b/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;
diff --git a/libavcodec/ac3enc_fixed.c b/libavcodec/ac3enc_fixed.c
index 462e658a8c..58590ac958 100644
--- a/libavcodec/ac3enc_fixed.c
+++ b/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);
 }
 
 
diff --git a/libavcodec/flashsv.c b/libavcodec/flashsv.c
index f5ffca08ac..12aabe6004 100644
--- a/libavcodec/flashsv.c
+++ b/libavcodec/flashsv.c
@@ -49,32 +49,30 @@
 
 #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;
-    int image_width, image_height;
-    int block_width, block_height;
-    uint8_t* tmpblock;
-    int block_size;
-    z_stream zstream;
+    AVFrame         frame;
+    int             image_width, image_height;
+    int             block_width, block_height;
+    uint8_t        *tmpblock;
+    int             block_size;
+    z_stream        zstream;
 } FlashSVContext;
 
 
 static void copy_region(uint8_t *sptr, uint8_t *dptr,
-        int dx, int dy, int h, int w, int stride)
+                        int dx, int dy, int h, int w, int stride)
 {
     int i;
 
-    for (i = dx+h; i > dx; i--)
-    {
-        memcpy(dptr+(i*stride)+dy*3, sptr, w*3);
-        sptr += w*3;
+    for (i = dx + h; i > dx; i--) {
+        memcpy(dptr + (i * stride) + dy * 3, sptr, w * 3);
+        sptr += w * 3;
     }
 }
 
@@ -84,9 +82,9 @@ static av_cold int flashsv_decode_init(AVCodecContext *avctx)
     FlashSVContext *s = avctx->priv_data;
     int zret; // Zlib return code
 
-    s->avctx = avctx;
+    s->avctx          = avctx;
     s->zstream.zalloc = Z_NULL;
-    s->zstream.zfree = Z_NULL;
+    s->zstream.zfree  = Z_NULL;
     s->zstream.opaque = Z_NULL;
     zret = inflateInit(&(s->zstream));
     if (zret != Z_OK) {
@@ -100,13 +98,12 @@ 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;
-    FlashSVContext *s = avctx->priv_data;
+    int buf_size       = avpkt->size;
+    FlashSVContext *s  = avctx->priv_data;
     int h_blocks, v_blocks, h_part, v_part, i, j;
     GetBitContext gb;
 
@@ -119,66 +116,64 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
     init_get_bits(&gb, buf, buf_size * 8);
 
     /* start to parse the bitstream */
-    s->block_width = 16* (get_bits(&gb, 4)+1);
-    s->image_width =     get_bits(&gb,12);
-    s->block_height= 16* (get_bits(&gb, 4)+1);
-    s->image_height=     get_bits(&gb,12);
+    s->block_width  = 16 * (get_bits(&gb,  4) + 1);
+    s->image_width  =       get_bits(&gb, 12);
+    s->block_height = 16 * (get_bits(&gb,  4) + 1);
+    s->image_height =       get_bits(&gb, 12);
 
     /* calculate amount of blocks and the size of the border blocks */
-    h_blocks = s->image_width / s->block_width;
-    h_part = s->image_width % s->block_width;
+    h_blocks = s->image_width  / s->block_width;
+    h_part   = s->image_width  % s->block_width;
     v_blocks = s->image_height / s->block_height;
-    v_part = s->image_height % s->block_height;
+    v_part   = s->image_height % s->block_height;
 
     /* the block size could change between frames, make sure the buffer
      * is large enough, if not, get a larger one */
-    if(s->block_size < s->block_width*s->block_height) {
+    if (s->block_size < s->block_width * s->block_height) {
         av_free(s->tmpblock);
-        if ((s->tmpblock = av_malloc(3*s->block_width*s->block_height)) == NULL) {
+        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;
+    s->block_size = s->block_width * s->block_height;
 
     /* init the image size once */
-    if((avctx->width==0) && (avctx->height==0)){
-        avctx->width = s->image_width;
+    if ((avctx->width == 0) && (avctx->height == 0)) {
+        avctx->width  = s->image_width;
         avctx->height = s->image_height;
     }
 
     /* check for changes of image width and image height */
     if ((avctx->width != s->image_width) || (avctx->height != s->image_height)) {
         av_log(avctx, AV_LOG_ERROR, "Frame width or height differs from first frames!\n");
-        av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",avctx->height,
-        avctx->width,s->image_height,s->image_width);
+        av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n", avctx->height,
+        avctx->width,s->image_height, s->image_width);
         return -1;
     }
 
     av_log(avctx, AV_LOG_DEBUG, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
-        s->image_width, s->image_height, s->block_width, s->block_height,
-        h_blocks, v_blocks, h_part, v_part);
+           s->image_width, s->image_height, s->block_width, s->block_height,
+           h_blocks, v_blocks, h_part, v_part);
 
-    s->frame.reference = 1;
+    s->frame.reference    = 1;
     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
-    if(avctx->reget_buffer(avctx, &s->frame) < 0){
-      av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
-      return -1;
+    if (avctx->reget_buffer(avctx, &s->frame) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
+        return -1;
     }
 
     /* 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
+        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++)
-        {
-            int wp = i*s->block_width; // vert position in frame
-            int ws = (i<h_blocks)?s->block_width:h_part; // size of block
+        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
 
             /* get the size of the compressed zlib chunk */
             int size = get_bits(&gb, 16);
@@ -193,30 +188,28 @@ 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; */
                 }
-                s->zstream.next_in = buf+(get_bits_count(&gb)/8);
-                s->zstream.avail_in = size;
-                s->zstream.next_out = s->tmpblock;
+                s->zstream.next_in   = buf + (get_bits_count(&gb) / 8);
+                s->zstream.avail_in  = size;
+                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]);
-                skip_bits_long(&gb, 8*size);   /* skip the consumed bits */
+                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 */
             }
         }
     }
@@ -224,9 +217,9 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
     *data_size = sizeof(AVFrame);
     *(AVFrame*)data = s->frame;
 
-    if ((get_bits_count(&gb)/8) != buf_size)
+    if ((get_bits_count(&gb) / 8) != buf_size)
         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
-            buf_size, (get_bits_count(&gb)/8));
+               buf_size, (get_bits_count(&gb) / 8));
 
     /* report that the buffer was completely consumed */
     return buf_size;
@@ -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,
-    .pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
-    .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
+    .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"),
 };
diff --git a/libavcodec/flashsvenc.c b/libavcodec/flashsvenc.c
index 9093969cfe..042efb5fed 100644
--- a/libavcodec/flashsvenc.c
+++ b/libavcodec/flashsvenc.c
@@ -65,32 +65,33 @@
 
 typedef struct FlashSVContext {
     AVCodecContext *avctx;
-    uint8_t *previous_frame;
-    AVFrame frame;
-    int image_width, image_height;
-    int block_width, block_height;
-    uint8_t* tmpblock;
-    uint8_t* encbuffer;
-    int block_size;
-    z_stream zstream;
-    int last_key_frame;
+    uint8_t        *previous_frame;
+    AVFrame         frame;
+    int             image_width, image_height;
+    int             block_width, block_height;
+    uint8_t        *tmpblock;
+    uint8_t        *encbuffer;
+    int             block_size;
+    z_stream        zstream;
+    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) {
-    int i,j;
+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;
     int diff = 0;
 
-    for (i = dx+h; i > dx; i--) {
-        nsptr = sptr+(i*stride)+dy*3;
-        npfptr = pfptr+(i*stride)+dy*3;
-        for (j=0 ; j<w*3 ; j++) {
-            diff |=npfptr[j]^nsptr[j];
-            dptr[j] = nsptr[j];
+    for (i = dx + h; i > dx; i--) {
+        nsptr  = sptr  + (i * stride) + dy * 3;
+        npfptr = pfptr + (i * stride) + dy * 3;
+        for (j = 0; j < w * 3; j++) {
+            diff    |= npfptr[j] ^ nsptr[j];
+            dptr[j]  = nsptr[j];
         }
-        dptr += w*3;
+        dptr += w * 3;
     }
     if (diff)
         return 1;
@@ -105,87 +106,90 @@ 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
     memset(&(s->zstream), 0, sizeof(z_stream));
 
-    s->last_key_frame=0;
+    s->last_key_frame = 0;
 
-    s->image_width = avctx->width;
+    s->image_width  = avctx->width;
     s->image_height = avctx->height;
 
-    s->tmpblock = av_mallocz(3*256*256);
-    s->encbuffer = av_mallocz(s->image_width*s->image_height*3);
+    s->tmpblock  = av_mallocz(3 * 256 * 256);
+    s->encbuffer = av_mallocz(s->image_width * s->image_height * 3);
 
     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;
     int buf_pos, res;
     int pred_blocks = 0;
 
-    init_put_bits(&pb, buf, buf_size*8);
+    init_put_bits(&pb, buf, buf_size * 8);
 
-    put_bits(&pb, 4, (block_width/16)-1);
+    put_bits(&pb,  4, (block_width / 16) - 1);
     put_bits(&pb, 12, s->image_width);
-    put_bits(&pb, 4, (block_height/16)-1);
+    put_bits(&pb,  4, (block_height / 16) - 1);
     put_bits(&pb, 12, s->image_height);
     flush_put_bits(&pb);
-    buf_pos=4;
+    buf_pos = 4;
 
-    h_blocks = s->image_width / block_width;
-    h_part = s->image_width % block_width;
+    h_blocks = s->image_width  / block_width;
+    h_part   = s->image_width  % block_width;
     v_blocks = s->image_height / block_height;
-    v_part = s->image_height % block_height;
+    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
+        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++)
-        {
-            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;
+        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;
             uint8_t *ptr;
 
-            ptr = buf+buf_pos;
+            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;
-                zsize = 3*block_width*block_height;
-                ret = compress2(ptr+2, &zsize, s->tmpblock, 3*ws*hs, 9);
+                zsize = 3 * block_width * block_height;
+                ret   = compress2(ptr + 2, &zsize, s->tmpblock, 3 * ws * hs, 9);
 
 
                 //ret = deflateReset(&(s->zstream));
                 if (ret != Z_OK)
                     av_log(s->avctx, AV_LOG_ERROR, "error while compressing block %dx%d\n", i, j);
 
-                bytestream_put_be16(&ptr,(unsigned int)zsize);
-                buf_pos += zsize+2;
+                bytestream_put_be16(&ptr, (unsigned int) zsize);
+                buf_pos += zsize + 2;
                 //av_log(avctx, AV_LOG_ERROR, "buf_pos = %d\n", buf_pos);
             } else {
                 pred_blocks++;
-                bytestream_put_be16(&ptr,0);
+                bytestream_put_be16(&ptr, 0);
                 buf_pos += 2;
             }
         }
@@ -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;
@@ -214,16 +219,16 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
 
     /* First frame needs to be a keyframe */
     if (avctx->frame_number == 0) {
-        s->previous_frame = av_mallocz(FFABS(p->linesize[0])*s->image_height);
+        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;
     }
 
     if (p->linesize[0] < 0)
-        pfptr = s->previous_frame - ((s->image_height-1) * p->linesize[0]);
+        pfptr = s->previous_frame - ((s->image_height - 1) * p->linesize[0]);
     else
         pfptr = s->previous_frame;
 
@@ -234,29 +239,31 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
         }
     }
 
-    opt_w=4;
-    opt_h=4;
+    opt_w = 4;
+    opt_h = 4;
 
     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;
     }
 
-    res = encode_bitstream(s, p, buf, buf_size, opt_w*16, opt_h*16, pfptr, &I_frame);
+    res = encode_bitstream(s, p, buf, buf_size, opt_w * 16, opt_h * 16, pfptr, &I_frame);
 
     //save the current frame
-    if(p->linesize[0] > 0)
-        memcpy(s->previous_frame, p->data[0], s->image_height*p->linesize[0]);
+    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) {
         p->pict_type = FF_I_TYPE;
         p->key_frame = 1;
         s->last_key_frame = avctx->frame_number;
-        av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n",avctx->frame_number);
+        av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
     } else {
         p->pict_type = FF_P_TYPE;
         p->key_frame = 0;
@@ -281,14 +288,14 @@ 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,
-    .pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
-    .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
+    .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"),
 };
 
diff --git a/libavformat/avidec.c b/libavformat/avidec.c
index d8df55b591..97b392aef4 100644
--- a/libavformat/avidec.c
+++ b/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;
                     }