Ticket #1976: Offending_Palette_change.diff

File Offending_Palette_change.diff, 31.6 KB (added by o.flebbe@…, 15 years ago)

Patch to ffmpeg which broke paletted MSRLE video

  • libavcodec/8bps.c 

    commit 2d8591c27e2dc582a7020e2580e16278dbfbddff
Author: Kostya Shishkov <kostya.shishkov@gmail.com>
Date:   Sat Apr 9 15:49:51 2011 +0200

    make containers pass palette change in AVPacket
    
    Signed-off-by: Luca Barbato <lu_zero@gentoo.org>

diff --git a/libavcodec/8bps.c b/libavcodec/8bps.c
index 1c6d406..055715f 100644
    a b typedef struct EightBpsContext {  
    5050
    5151        unsigned char planes;
    5252        unsigned char planemap[4];
     53
     54        uint32_t pal[256];
    5355} EightBpsContext;
    5456
    5557
    … … static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac  
    129131                }
    130132        }
    131133
    132         if (avctx->palctrl) {
    133                 memcpy (c->pic.data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
    134                 if (avctx->palctrl->palette_changed) {
     134        if (avctx->bits_per_coded_sample <= 8) {
     135                const uint8_t *pal = av_packet_get_side_data(avpkt,
     136                                                             AV_PKT_DATA_PALETTE,
     137                                                             NULL);
     138                if (pal) {
    135139                        c->pic.palette_has_changed = 1;
    136                         avctx->palctrl->palette_changed = 0;
    137                 } else
    138                         c->pic.palette_has_changed = 0;
     140                        memcpy(c->pal, pal, AVPALETTE_SIZE);
     141                }
     142
     143                memcpy (c->pic.data[1], c->pal, AVPALETTE_SIZE);
    139144        }
    140145
    141146        *data_size = sizeof(AVFrame);
    … … static av_cold int decode_init(AVCodecContext *avctx)  
    164169                        avctx->pix_fmt = PIX_FMT_PAL8;
    165170                        c->planes = 1;
    166171                        c->planemap[0] = 0; // 1st plane is palette indexes
    167                         if (avctx->palctrl == NULL) {
    168                                 av_log(avctx, AV_LOG_ERROR, "Error: PAL8 format but no palette from demuxer.\n");
    169                                 return -1;
    170                         }
    171172                        break;
    172173                case 24:
    173174                        avctx->pix_fmt = avctx->get_format(avctx, pixfmt_rgb24);

  • libavcodec/cinepak.c 

    diff --git a/libavcodec/cinepak.c b/libavcodec/cinepak.c
index f325bdb..4bda2a7 100644
    a b typedef struct CinepakContext {  
    6767
    6868    int sega_film_skip_bytes;
    6969
     70    uint32_t pal[256];
    7071} CinepakContext;
    7172
    7273static void cinepak_decode_codebook (cvid_codebook *codebook,
    … … static av_cold int cinepak_decode_init(AVCodecContext *avctx)  
    395396    s->sega_film_skip_bytes = -1;  /* uninitialized state */
    396397
    397398    // check for paletted data
    398     if ((avctx->palctrl == NULL) || (avctx->bits_per_coded_sample == 40)) {
     399    if (avctx->bits_per_coded_sample != 8) {
    399400        s->palette_video = 0;
    400401        avctx->pix_fmt = PIX_FMT_YUV420P;
    401402    } else {
    … … static int cinepak_decode_frame(AVCodecContext *avctx,  
    427428        return -1;
    428429    }
    429430
    430     cinepak_decode(s);
    431 
    432431    if (s->palette_video) {
    433         memcpy (s->frame.data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
    434         if (avctx->palctrl->palette_changed) {
     432        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     433        if (pal) {
    435434            s->frame.palette_has_changed = 1;
    436             avctx->palctrl->palette_changed = 0;
    437         } else
    438             s->frame.palette_has_changed = 0;
     435            memcpy(s->pal, pal, AVPALETTE_SIZE);
     436        }
    439437    }
    440438
     439    cinepak_decode(s);
     440
     441    if (s->palette_video)
     442        memcpy (s->frame.data[1], s->pal, AVPALETTE_SIZE);
     443
    441444    *data_size = sizeof(AVFrame);
    442445    *(AVFrame*)data = s->frame;
    443446

  • libavcodec/idcinvideo.c 

    diff --git a/libavcodec/idcinvideo.c b/libavcodec/idcinvideo.c
index b8d47ad..ac56e19 100644
    a b typedef struct IdcinContext {  
    7272    hnode huff_nodes[256][HUF_TOKENS*2];
    7373    int num_huff_nodes[256];
    7474
     75    uint32_t pal[256];
    7576} IdcinContext;
    7677
    7778/*
    … … static int idcin_decode_frame(AVCodecContext *avctx,  
    213214    const uint8_t *buf = avpkt->data;
    214215    int buf_size = avpkt->size;
    215216    IdcinContext *s = avctx->priv_data;
    216     AVPaletteControl *palette_control = avctx->palctrl;
     217    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
    217218
    218219    s->buf = buf;
    219220    s->size = buf_size;
    … … static int idcin_decode_frame(AVCodecContext *avctx,  
    228229
    229230    idcin_decode_vlcs(s);
    230231
    231     /* make the palette available on the way out */
    232     memcpy(s->frame.data[1], palette_control->palette, PALETTE_COUNT * 4);
    233     /* If palette changed inform application*/
    234     if (palette_control->palette_changed) {
    235         palette_control->palette_changed = 0;
     232    if (pal) {
    236233        s->frame.palette_has_changed = 1;
     234        memcpy(s->pal, pal, AVPALETTE_SIZE);
    237235    }
     236    /* make the palette available on the way out */
     237    memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);
    238238
    239239    *data_size = sizeof(AVFrame);
    240240    *(AVFrame*)data = s->frame;

  • libavcodec/interplayvideo.c 

    diff --git a/libavcodec/interplayvideo.c b/libavcodec/interplayvideo.c
index 8dbe6f6..c12b241 100644
    a b typedef struct IpvideoContext {  
    7777    int stride;
    7878    int upper_motion_limit_offset;
    7979
     80    uint32_t pal[256];
    8081} IpvideoContext;
    8182
    8283#define CHECK_STREAM_PTR(stream_ptr, stream_end, n) \
    … … static void ipvideo_decode_opcodes(IpvideoContext *s)  
    969970
    970971    if (!s->is_16bpp) {
    971972        /* this is PAL8, so make the palette available */
    972         memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
     973        memcpy(s->current_frame.data[1], s->pal, AVPALETTE_SIZE);
    973974
    974975        s->stride = s->current_frame.linesize[0];
    975976        s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
    … … static av_cold int ipvideo_decode_init(AVCodecContext *avctx)  
    10231024
    10241025    s->is_16bpp = avctx->bits_per_coded_sample == 16;
    10251026    avctx->pix_fmt = s->is_16bpp ? PIX_FMT_RGB555 : PIX_FMT_PAL8;
    1026     if (!s->is_16bpp && s->avctx->palctrl == NULL) {
    1027         av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
    1028         return -1;
    1029     }
    10301027
    10311028    dsputil_init(&s->dsp, avctx);
    10321029
    … … static int ipvideo_decode_frame(AVCodecContext *avctx,  
    10461043    const uint8_t *buf = avpkt->data;
    10471044    int buf_size = avpkt->size;
    10481045    IpvideoContext *s = avctx->priv_data;
    1049     AVPaletteControl *palette_control = avctx->palctrl;
    10501046
    10511047    /* compressed buffer needs to be large enough to at least hold an entire
    10521048     * decoding map */
    … … static int ipvideo_decode_frame(AVCodecContext *avctx,  
    10631059        return -1;
    10641060    }
    10651061
    1066     ipvideo_decode_opcodes(s);
    1067 
    1068     if (!s->is_16bpp && palette_control->palette_changed) {
    1069         palette_control->palette_changed = 0;
    1070         s->current_frame.palette_has_changed = 1;
     1062    if (!s->is_16bpp) {
     1063        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     1064        if (pal) {
     1065            s->current_frame.palette_has_changed = 1;
     1066            memcpy(s->pal, pal, AVPALETTE_SIZE);
     1067        }
    10711068    }
    10721069
     1070    ipvideo_decode_opcodes(s);
     1071
    10731072    *data_size = sizeof(AVFrame);
    10741073    *(AVFrame*)data = s->current_frame;
    10751074

  • libavcodec/kmvc.c 

    diff --git a/libavcodec/kmvc.c b/libavcodec/kmvc.c
index 2671cc6..c41c882 100644
    a b static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPa  
    233233    int i;
    234234    int header;
    235235    int blocksize;
     236    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
    236237
    237238    if (ctx->pic.data[0])
    238239        avctx->release_buffer(avctx, &ctx->pic);
    … … static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPa  
    264265        ctx->pic.pict_type = FF_P_TYPE;
    265266    }
    266267
    267     /* if palette has been changed, copy it from palctrl */
    268     if (ctx->avctx->palctrl && ctx->avctx->palctrl->palette_changed) {
    269         memcpy(ctx->pal, ctx->avctx->palctrl->palette, AVPALETTE_SIZE);
    270         ctx->setpal = 1;
    271         ctx->avctx->palctrl->palette_changed = 0;
    272     }
    273 
    274268    if (header & KMVC_PALETTE) {
    275269        ctx->pic.palette_has_changed = 1;
    276270        // palette starts from index 1 and has 127 entries
    … … static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPa  
    279273        }
    280274    }
    281275
     276    if (pal) {
     277        ctx->pic.palette_has_changed = 1;
     278        memcpy(ctx->pal, pal, AVPALETTE_SIZE);
     279    }
     280
    282281    if (ctx->setpal) {
    283282        ctx->setpal = 0;
    284283        ctx->pic.palette_has_changed = 1;
    … … static av_cold int decode_init(AVCodecContext * avctx)  
    374373            src += 4;
    375374        }
    376375        c->setpal = 1;
    377         if (c->avctx->palctrl) {
    378             c->avctx->palctrl->palette_changed = 0;
    379         }
    380376    }
    381377
    382378    avctx->pix_fmt = PIX_FMT_PAL8;

  • libavcodec/msrle.c 

    diff --git a/libavcodec/msrle.c b/libavcodec/msrle.c
index a400589..f426b05 100644
    a b  
    2626 *   http://www.pcisys.net/~melanson/codecs/
    2727 *
    2828 * The MS RLE decoder outputs PAL8 colorspace data.
    29  *
    30  * Note that this decoder expects the palette colors from the end of the
    31  * BITMAPINFO header passed through palctrl.
    3229 */
    3330
    3431#include <stdio.h>
    … … typedef struct MsrleContext {  
    4643    const unsigned char *buf;
    4744    int size;
    4845
     46    uint32_t pal[256];
    4947} MsrleContext;
    5048
    5149static av_cold int msrle_decode_init(AVCodecContext *avctx)
    … … static int msrle_decode_frame(AVCodecContext *avctx,  
    9189        return -1;
    9290    }
    9391
    94     if (s->avctx->palctrl) {
    95         /* make the palette available */
    96         memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE);
    97         if (s->avctx->palctrl->palette_changed) {
     92    if (avctx->bits_per_coded_sample <= 8) {
     93        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     94
     95        if (pal) {
    9896            s->frame.palette_has_changed = 1;
    99             s->avctx->palctrl->palette_changed = 0;
     97            memcpy(s->pal, pal, AVPALETTE_SIZE);
    10098        }
     99
     100        /* make the palette available */
     101        memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);
    101102    }
    102103
    103104    /* FIXME how to correctly detect RLE ??? */

  • libavcodec/msvideo1.c 

    diff --git a/libavcodec/msvideo1.c b/libavcodec/msvideo1.c
index e01ddf5..a89ec6a 100644
    a b  
    2525 * For more information about the MS Video-1 format, visit:
    2626 *   http://www.pcisys.net/~melanson/codecs/
    2727 *
    28  * This decoder outputs either PAL8 or RGB555 data, depending on the
    29  * whether a RGB palette was passed through palctrl;
    30  * if it's present, then the data is PAL8; RGB555 otherwise.
    3128 */
    3229
    3330#include <stdio.h>
    … … typedef struct Msvideo1Context {  
    5552
    5653    int mode_8bit;  /* if it's not 8-bit, it's 16-bit */
    5754
     55    uint32_t pal[256];
    5856} Msvideo1Context;
    5957
    6058static av_cold int msvideo1_decode_init(AVCodecContext *avctx)
    … … static av_cold int msvideo1_decode_init(AVCodecContext *avctx)  
    6462    s->avctx = avctx;
    6563
    6664    /* figure out the colorspace based on the presence of a palette */
    67     if (s->avctx->palctrl) {
     65    if (s->avctx->bits_per_coded_sample == 8) {
    6866        s->mode_8bit = 1;
    6967        avctx->pix_fmt = PIX_FMT_PAL8;
    7068    } else {
    … … static void msvideo1_decode_8bit(Msvideo1Context *s)  
    173171    }
    174172
    175173    /* make the palette available on the way out */
    176     if (s->avctx->pix_fmt == PIX_FMT_PAL8) {
    177         memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE);
    178         if (s->avctx->palctrl->palette_changed) {
    179             s->frame.palette_has_changed = 1;
    180             s->avctx->palctrl->palette_changed = 0;
    181         }
    182     }
     174    if (s->avctx->pix_fmt == PIX_FMT_PAL8)
     175        memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);
    183176}
    184177
    185178static void msvideo1_decode_16bit(Msvideo1Context *s)
    … … static int msvideo1_decode_frame(AVCodecContext *avctx,  
    309302        return -1;
    310303    }
    311304
     305    if (s->mode_8bit) {
     306        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     307
     308        if (pal) {
     309            memcpy(s->pal, pal, AVPALETTE_SIZE);
     310            s->frame.palette_has_changed = 1;
     311        }
     312    }
     313
    312314    if (s->mode_8bit)
    313315        msvideo1_decode_8bit(s);
    314316    else

  • libavcodec/qpeg.c 

    diff --git a/libavcodec/qpeg.c b/libavcodec/qpeg.c
index ccd634a..c96184f 100644
    a b typedef struct QpegContext{  
    3030    AVCodecContext *avctx;
    3131    AVFrame pic;
    3232    uint8_t *refdata;
     33    uint32_t pal[256];
    3334} QpegContext;
    3435
    3536static void qpeg_decode_intra(const uint8_t *src, uint8_t *dst, int size,
    … … static int decode_frame(AVCodecContext *avctx,  
    256257    AVFrame * const p= (AVFrame*)&a->pic;
    257258    uint8_t* outdata;
    258259    int delta;
     260    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
    259261
    260262    if(p->data[0])
    261263        avctx->release_buffer(avctx, p);
    … … static int decode_frame(AVCodecContext *avctx,  
    274276    }
    275277
    276278    /* make the palette available on the way out */
    277     memcpy(a->pic.data[1], a->avctx->palctrl->palette, AVPALETTE_SIZE);
    278     if (a->avctx->palctrl->palette_changed) {
     279    if (pal) {
    279280        a->pic.palette_has_changed = 1;
    280         a->avctx->palctrl->palette_changed = 0;
     281        memcpy(a->pal, pal, AVPALETTE_SIZE);
    281282    }
     283    memcpy(a->pic.data[1], a->pal, AVPALETTE_SIZE);
    282284
    283285    *data_size = sizeof(AVFrame);
    284286    *(AVFrame*)data = a->pic;
    … … static int decode_frame(AVCodecContext *avctx,  
    289291static av_cold int decode_init(AVCodecContext *avctx){
    290292    QpegContext * const a = avctx->priv_data;
    291293
    292     if (!avctx->palctrl) {
    293         av_log(avctx, AV_LOG_FATAL, "Missing required palette via palctrl\n");
    294         return -1;
    295     }
    296294    a->avctx = avctx;
    297295    avctx->pix_fmt= PIX_FMT_PAL8;
    298296    a->refdata = av_malloc(avctx->width * avctx->height);

  • libavcodec/qtrle.c 

    diff --git a/libavcodec/qtrle.c b/libavcodec/qtrle.c
index a8cc903..e14c306 100644
    a b typedef struct QtrleContext {  
    4646    const unsigned char *buf;
    4747    int size;
    4848
     49    uint32_t pal[256];
    4950} QtrleContext;
    5051
    5152#define CHECK_STREAM_PTR(n) \
    … … static int qtrle_decode_frame(AVCodecContext *avctx,  
    511512    }
    512513
    513514    if(has_palette) {
    514         /* make the palette available on the way out */
    515         memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE);
    516         if (s->avctx->palctrl->palette_changed) {
     515        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     516
     517        if (pal) {
    517518            s->frame.palette_has_changed = 1;
    518             s->avctx->palctrl->palette_changed = 0;
     519            memcpy(s->pal, pal, AVPALETTE_SIZE);
    519520        }
     521
     522        /* make the palette available on the way out */
     523        memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);
    520524    }
    521525
    522526done:

  • libavcodec/rawdec.c 

    diff --git a/libavcodec/rawdec.c b/libavcodec/rawdec.c
index 3c38829..3dbfdfe 100644
    a b static int raw_decode(AVCodecContext *avctx,  
    158158        (av_pix_fmt_descriptors[avctx->pix_fmt].flags & PIX_FMT_PAL))){
    159159        frame->data[1]= context->palette;
    160160    }
    161     if (avctx->palctrl && avctx->palctrl->palette_changed) {
    162         memcpy(frame->data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
    163         avctx->palctrl->palette_changed = 0;
     161    if (avctx->pix_fmt == PIX_FMT_PAL8) {
     162        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     163
     164        if (pal) {
     165            memcpy(frame->data[1], pal, AVPALETTE_SIZE);
     166            frame->palette_has_changed = 1;
     167        }
    164168    }
    165169    if(avctx->pix_fmt==PIX_FMT_BGR24 && ((frame->linesize[0]+3)&~3)*avctx->height <= buf_size)
    166170        frame->linesize[0] = (frame->linesize[0]+3)&~3;

  • libavcodec/smc.c 

    diff --git a/libavcodec/smc.c b/libavcodec/smc.c
index fe92b43..e75203d 100644
    a b typedef struct SmcContext {  
    5454    unsigned char color_quads[COLORS_PER_TABLE * CQUAD];
    5555    unsigned char color_octets[COLORS_PER_TABLE * COCTET];
    5656
     57    uint32_t pal[256];
    5758} SmcContext;
    5859
    5960#define GET_BLOCK_COUNT() \
    … … static void smc_decode_stream(SmcContext *s)  
    110111    int color_octet_index = 0;
    111112
    112113    /* make the palette available */
    113     memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE);
    114     if (s->avctx->palctrl->palette_changed) {
    115         s->frame.palette_has_changed = 1;
    116         s->avctx->palctrl->palette_changed = 0;
    117     }
     114    memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);
    118115
    119116    chunk_size = AV_RB32(&s->buf[stream_ptr]) & 0x00FFFFFF;
    120117    stream_ptr += 4;
    … … static int smc_decode_frame(AVCodecContext *avctx,  
    440437    const uint8_t *buf = avpkt->data;
    441438    int buf_size = avpkt->size;
    442439    SmcContext *s = avctx->priv_data;
     440    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
    443441
    444442    s->buf = buf;
    445443    s->size = buf_size;
    … … static int smc_decode_frame(AVCodecContext *avctx,  
    452450        return -1;
    453451    }
    454452
     453    if (pal) {
     454        s->frame.palette_has_changed = 1;
     455        memcpy(s->pal, pal, AVPALETTE_SIZE);
     456    }
     457
    455458    smc_decode_stream(s);
    456459
    457460    *data_size = sizeof(AVFrame);

  • libavcodec/targa.c 

    diff --git a/libavcodec/targa.c b/libavcodec/targa.c
index 06f87e4..910cc1b 100644
    a b static int decode_frame(AVCodecContext *avctx,  
    171171        stride = -p->linesize[0];
    172172    }
    173173
    174     if(avctx->pix_fmt == PIX_FMT_PAL8 && avctx->palctrl){
    175         memcpy(p->data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
    176         if(avctx->palctrl->palette_changed){
    177             p->palette_has_changed = 1;
    178             avctx->palctrl->palette_changed = 0;
    179         }
    180     }
    181174    if(colors){
    182175        size_t pal_size;
    183176        if((colors + first_clr) > 256){

  • libavcodec/tscc.c 

    diff --git a/libavcodec/tscc.c b/libavcodec/tscc.c
index f695973..bd05f02 100644
    a b typedef struct TsccContext {  
    6060    unsigned char* decomp_buf;
    6161    int height;
    6262    z_stream zstream;
     63
     64    uint32_t pal[256];
    6365} CamtasiaContext;
    6466
    6567/*
    … … static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac  
    111113
    112114    /* make the palette available on the way out */
    113115    if (c->avctx->pix_fmt == PIX_FMT_PAL8) {
    114         memcpy(c->pic.data[1], c->avctx->palctrl->palette, AVPALETTE_SIZE);
    115         if (c->avctx->palctrl->palette_changed) {
     116        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
     117
     118        if (pal) {
    116119            c->pic.palette_has_changed = 1;
    117             c->avctx->palctrl->palette_changed = 0;
     120            memcpy(c->pal, pal, AVPALETTE_SIZE);
    118121        }
     122        memcpy(c->pic.data[1], c->pal, AVPALETTE_SIZE);
    119123    }
    120124
    121125    *data_size = sizeof(AVFrame);

  • libavformat/asf.h 

    diff --git a/libavformat/asf.h b/libavformat/asf.h
index b563459..b72445d 100644
    a b typedef struct {  
    4444
    4545    uint16_t stream_language_index;
    4646
     47    int      palette_changed;
     48    uint32_t palette[256];
    4749} ASFStream;
    4850
    4951typedef uint8_t ff_asf_guid[16];

  • libavformat/asfdec.c 

    diff --git a/libavformat/asfdec.c b/libavformat/asfdec.c
index 30828ad..36e9efa 100644
    a b static int asf_read_stream_properties(AVFormatContext *s, int64_t size)  
    365365        /* This is true for all paletted codecs implemented in ffmpeg */
    366366        if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
    367367            int av_unused i;
    368             st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
    369368#if HAVE_BIGENDIAN
    370369            for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
    371                 st->codec->palctrl->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
     370                asf_st->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
    372371#else
    373             memcpy(st->codec->palctrl->palette, st->codec->extradata,
    374                     FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
     372            memcpy(asf_st->palette, st->codec->extradata,
     373                   FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
    375374#endif
    376             st->codec->palctrl->palette_changed = 1;
     375            asf_st->palette_changed = 1;
    377376        }
    378377
    379378        st->codec->codec_tag = tag1;
    … … static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pk  
    966965            asf_st->pkt.stream_index = asf->stream_index;
    967966            asf_st->pkt.pos =
    968967            asf_st->packet_pos= asf->packet_pos;
     968            if (asf_st->pkt.data && asf_st->palette_changed) {
     969                uint8_t *pal;
     970                pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
     971                                              AVPALETTE_SIZE);
     972                if (!pal) {
     973                    av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
     974                } else {
     975                    memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
     976                    asf_st->palette_changed = 0;
     977                }
     978            }
    969979//printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
    970980//asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & AV_PKT_FLAG_KEY,
    971981//s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO, asf->packet_obj_size);
    … … static int asf_read_close(AVFormatContext *s)  
    11271137    asf_reset_header(s);
    11281138    for(i=0;i<s->nb_streams;i++) {
    11291139        AVStream *st = s->streams[i];
    1130         av_free(st->codec->palctrl);
    11311140    }
    11321141    return 0;
    11331142}

  • libavformat/avidec.c 

    diff --git a/libavformat/avidec.c b/libavformat/avidec.c
index ec3aa93..c7bbf42 100644
    a b static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)  
    590590                    /* This code assumes that extradata contains only palette. */
    591591                    /* This is true for all paletted codecs implemented in FFmpeg. */
    592592                    if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
    593                         st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
    594593#if HAVE_BIGENDIAN
    595594                        for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
    596                             st->codec->palctrl->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
     595                            ast->pal[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
    597596#else
    598                         memcpy(st->codec->palctrl->palette, st->codec->extradata,
     597                        memcpy(ast->pal, st->codec->extradata,
    599598                               FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
    600599#endif
    601                         st->codec->palctrl->palette_changed = 1;
     600                        ast->has_pal = 1;
    602601                    }
    603602
    604603                    print_tag("video", tag1, 0);
    … … resync:  
    932931            return err;
    933932
    934933        if(ast->has_pal && pkt->data && pkt->size<(unsigned)INT_MAX/2){
    935             void *ptr= av_realloc(pkt->data, pkt->size + 4*256 + FF_INPUT_BUFFER_PADDING_SIZE);
    936             if(ptr){
    937             ast->has_pal=0;
    938             pkt->size += 4*256;
    939             pkt->data= ptr;
    940                 memcpy(pkt->data + pkt->size - 4*256, ast->pal, 4*256);
    941             }else
    942                 av_log(s, AV_LOG_ERROR, "Failed to append palette\n");
     934            uint8_t *pal;
     935            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
     936            if(!pal){
     937                av_log(s, AV_LOG_ERROR, "Failed to allocate data for palette\n");
     938            }else{
     939                memcpy(pal, ast->pal, AVPALETTE_SIZE);
     940                ast->has_pal = 0;
     941            }
    943942        }
    944943
    945944        if (CONFIG_DV_DEMUXER && avi->dv_demux) {
    … … static int avi_read_close(AVFormatContext *s)  
    13401339    for(i=0;i<s->nb_streams;i++) {
    13411340        AVStream *st = s->streams[i];
    13421341        AVIStream *ast = st->priv_data;
    1343         av_free(st->codec->palctrl);
    13441342        if (ast) {
    13451343            if (ast->sub_ctx) {
    13461344                av_freep(&ast->sub_ctx->pb);

  • libavformat/idcin.c 

    diff --git a/libavformat/idcin.c b/libavformat/idcin.c
index e6883c7..04ae687 100644
    a b typedef struct IdcinDemuxContext {  
    8686    int audio_present;
    8787
    8888    int64_t pts;
    89 
    90     AVPaletteControl palctrl;
    9189} IdcinDemuxContext;
    9290
    9391static int idcin_probe(AVProbeData *p)
    … … static int idcin_read_header(AVFormatContext *s,  
    172170    if (avio_read(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) !=
    173171        HUFFMAN_TABLE_SIZE)
    174172        return AVERROR(EIO);
    175     /* save a reference in order to transport the palette */
    176     st->codec->palctrl = &idcin->palctrl;
    177173
    178174    /* if sample rate is 0, assume no audio */
    179175    if (sample_rate) {
    … … static int idcin_read_packet(AVFormatContext *s,  
    226222    int palette_scale;
    227223    unsigned char r, g, b;
    228224    unsigned char palette_buffer[768];
     225    uint32_t palette[256];
    229226
    230227    if (s->pb->eof_reached)
    231228        return AVERROR(EIO);
    … … static int idcin_read_packet(AVFormatContext *s,  
    236233            return AVERROR(EIO);
    237234        } else if (command == 1) {
    238235            /* trigger a palette change */
    239             idcin->palctrl.palette_changed = 1;
    240236            if (avio_read(pb, palette_buffer, 768) != 768)
    241237                return AVERROR(EIO);
    242238            /* scale the palette as necessary */
    … … static int idcin_read_packet(AVFormatContext *s,  
    251247                r = palette_buffer[i * 3    ] << palette_scale;
    252248                g = palette_buffer[i * 3 + 1] << palette_scale;
    253249                b = palette_buffer[i * 3 + 2] << palette_scale;
    254                 idcin->palctrl.palette[i] = (r << 16) | (g << 8) | (b);
     250                palette[i] = (r << 16) | (g << 8) | (b);
    255251            }
    256252        }
    257253
    … … static int idcin_read_packet(AVFormatContext *s,  
    262258        ret= av_get_packet(pb, pkt, chunk_size);
    263259        if (ret < 0)
    264260            return ret;
     261        if (command == 1) {
     262            uint8_t *pal;
     263
     264            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
     265                                          AVPALETTE_SIZE);
     266            if (ret < 0)
     267                return ret;
     268            memcpy(pal, palette, AVPALETTE_SIZE);
     269        }
    265270        pkt->stream_index = idcin->video_stream_index;
    266271        pkt->pts = idcin->pts;
    267272    } else {

  • libavformat/ipmovie.c 

    diff --git a/libavformat/ipmovie.c b/libavformat/ipmovie.c
index e1d08df..e3215d3 100644
    a b typedef struct IPMVEContext {  
    9797    unsigned int video_width;
    9898    unsigned int video_height;
    9999    int64_t video_pts;
     100    uint32_t     palette[256];
     101    int          has_palette;
    100102
    101103    unsigned int audio_bits;
    102104    unsigned int audio_channels;
    … … typedef struct IPMVEContext {  
    116118
    117119    int64_t next_chunk_offset;
    118120
    119     AVPaletteControl palette_control;
    120 
    121121} IPMVEContext;
    122122
    123123static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
    … … static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,  
    162162        if (av_new_packet(pkt, s->decode_map_chunk_size + s->video_chunk_size))
    163163            return CHUNK_NOMEM;
    164164
     165        if (s->has_palette) {
     166            uint8_t *pal;
     167
     168            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
     169                                          AVPALETTE_SIZE);
     170            if (pal) {
     171                memcpy(pal, s->palette, AVPALETTE_SIZE);
     172                s->has_palette = 0;
     173            }
     174        }
     175
    165176        pkt->pos= s->decode_map_chunk_offset;
    166177        avio_seek(pb, s->decode_map_chunk_offset, SEEK_SET);
    167178        s->decode_map_chunk_offset = 0;
    … … static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,  
    456467                r = scratch[j++] * 4;
    457468                g = scratch[j++] * 4;
    458469                b = scratch[j++] * 4;
    459                 s->palette_control.palette[i] = (r << 16) | (g << 8) | (b);
     470                s->palette[i] = (r << 16) | (g << 8) | (b);
    460471            }
    461             /* indicate a palette change */
    462             s->palette_control.palette_changed = 1;
     472            s->has_palette = 1;
    463473            break;
    464474
    465475        case OPCODE_SET_PALETTE_COMPRESSED:
    … … static int ipmovie_read_header(AVFormatContext *s,  
    573583    st->codec->height = ipmovie->video_height;
    574584    st->codec->bits_per_coded_sample = ipmovie->video_bpp;
    575585
    576     /* palette considerations */
    577     st->codec->palctrl = &ipmovie->palette_control;
    578 
    579586    if (ipmovie->audio_type) {
    580587        st = av_new_stream(s, 0);
    581588        if (!st)

  • libavformat/isom.h 

    diff --git a/libavformat/isom.h b/libavformat/isom.h
index fba4963..48e0bcf 100644
    a b typedef struct MOVStreamContext {  
    123123    int width;            ///< tkhd width
    124124    int height;           ///< tkhd height
    125125    int dts_shift;        ///< dts shift when ctts is negative
     126    uint32_t palette[256];
     127    int has_palette;
    126128} MOVStreamContext;
    127129
    128130typedef struct MOVContext {

  • libavformat/mov.c 

    diff --git a/libavformat/mov.c b/libavformat/mov.c
index 61ceaac..bd8cf03 100644
    a b int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)  
    10271027                unsigned int color_start, color_count, color_end;
    10281028                unsigned char r, g, b;
    10291029
    1030                 st->codec->palctrl = av_malloc(sizeof(*st->codec->palctrl));
    10311030                if (color_greyscale) {
    10321031                    int color_index, color_dec;
    10331032                    /* compute the greyscale palette */
    … … int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)  
    10371036                    color_dec = 256 / (color_count - 1);
    10381037                    for (j = 0; j < color_count; j++) {
    10391038                        r = g = b = color_index;
    1040                         st->codec->palctrl->palette[j] =
     1039                        sc->palette[j] =
    10411040                            (r << 16) | (g << 8) | (b);
    10421041                        color_index -= color_dec;
    10431042                        if (color_index < 0)
    … … int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)  
    10581057                        r = color_table[j * 3 + 0];
    10591058                        g = color_table[j * 3 + 1];
    10601059                        b = color_table[j * 3 + 2];
    1061                         st->codec->palctrl->palette[j] =
     1060                        sc->palette[j] =
    10621061                            (r << 16) | (g << 8) | (b);
    10631062                    }
    10641063                } else {
    … … int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)  
    10801079                            avio_r8(pb);
    10811080                            b = avio_r8(pb);
    10821081                            avio_r8(pb);
    1083                             st->codec->palctrl->palette[j] =
     1082                            sc->palette[j] =
    10841083                                (r << 16) | (g << 8) | (b);
    10851084                        }
    10861085                    }
    10871086                }
    1088                 st->codec->palctrl->palette_changed = 1;
     1087                sc->has_palette = 1;
    10891088            }
    10901089        } else if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
    10911090            int bits_per_sample, flags;
    … … static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)  
    24332432        ret = av_get_packet(sc->pb, pkt, sample->size);
    24342433        if (ret < 0)
    24352434            return ret;
     2435        if (sc->has_palette) {
     2436            uint8_t *pal;
     2437
     2438            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
     2439            if (!pal) {
     2440                av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
     2441            } else {
     2442                memcpy(pal, sc->palette, AVPALETTE_SIZE);
     2443                sc->has_palette = 0;
     2444            }
     2445        }
    24362446#if CONFIG_DV_DEMUXER
    24372447        if (mov->dv_demux && sc->dv_audio_container) {
    24382448            dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size);