Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge remote branch 'qatar/master'

Browse Source 
* 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>
pull/2/head
Michael Niedermayer 14 years ago
parent 05815b3545 f80b381bfd
commit 3788a3c0c0
5 changed files with 154 additions and 150 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      cmdutils.c
  2. 2
      libavcodec/ac3enc_fixed.c
  3. 92
      libavcodec/flashsv.c
  4. 123
      libavcodec/flashsvenc.c
  5. 12
      libavformat/avidec.c

1
cmdutils.c
Unescape View File

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

2
libavcodec/ac3enc_fixed.c
Unescape View File

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

92
libavcodec/flashsv.c
Unescape View File

@ -49,18 +49,17 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <zlib.h>
#include "avcodec.h" #include "avcodec.h"
#include "get_bits.h" #include "get_bits.h"
#include <zlib.h>
typedef struct FlashSVContext { typedef struct FlashSVContext {
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame frame; AVFrame frame;
int image_width, image_height; int image_width, image_height;
int block_width, block_height; int block_width, block_height;
uint8_t* tmpblock; uint8_t *tmpblock;
int block_size; int block_size;
z_stream zstream; z_stream zstream;
} FlashSVContext; } FlashSVContext;
@ -71,10 +70,9 @@ static void copy_region(uint8_t *sptr, uint8_t *dptr,
{ {
int i; 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);
memcpy(dptr+(i*stride)+dy*3, sptr, w*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, static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
void *data, int *data_size, int *data_size, AVPacket *avpkt)
AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
@ -119,10 +116,10 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
init_get_bits(&gb, buf, buf_size * 8); init_get_bits(&gb, buf, buf_size * 8);
/* start to parse the bitstream */ /* start to parse the bitstream */
s->block_width = 16* (get_bits(&gb, 4)+1); s->block_width = 16 * (get_bits(&gb, 4) + 1);
s->image_width = get_bits(&gb,12); s->image_width = get_bits(&gb, 12);
s->block_height= 16* (get_bits(&gb, 4)+1); s->block_height = 16 * (get_bits(&gb, 4) + 1);
s->image_height= get_bits(&gb,12); s->image_height = get_bits(&gb, 12);
/* calculate amount of blocks and the size of the border blocks */ /* calculate amount of blocks and the size of the border blocks */
h_blocks = s->image_width / s->block_width; h_blocks = s->image_width / s->block_width;
@ -132,17 +129,17 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
/* the block size could change between frames, make sure the buffer /* the block size could change between frames, make sure the buffer
* is large enough, if not, get a larger one */ * 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); 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"); 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 */ /* init the image size once */
if((avctx->width==0) && (avctx->height==0)){ if ((avctx->width == 0) && (avctx->height == 0)) {
avctx->width = s->image_width; avctx->width = s->image_width;
avctx->height = s->image_height; avctx->height = s->image_height;
} }
@ -150,8 +147,8 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
/* check for changes of image width and image height */ /* check for changes of image width and image height */
if ((avctx->width != s->image_width) || (avctx->height != s->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, "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, 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); avctx->width,s->image_height, s->image_width);
return -1; return -1;
} }
@ -161,24 +158,22 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
s->frame.reference = 1; s->frame.reference = 1;
s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
if(avctx->reget_buffer(avctx, &s->frame) < 0){ if (avctx->reget_buffer(avctx, &s->frame) < 0) {
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
return -1; return -1;
} }
/* loop over all block columns */ /* 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 hp = j * s->block_height; // horiz position in frame
int hs = (j<v_blocks)?s->block_height:v_part; // size of block int hs = (j < v_blocks) ? s->block_height : v_part; // size of block
/* loop over all block rows */ /* 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 wp = i*s->block_width; // vert position in frame int ws = (i < h_blocks) ? s->block_width : h_part; // size of block
int ws = (i<h_blocks)?s->block_width:h_part; // size of block
/* get the size of the compressed zlib chunk */ /* get the size of the compressed zlib chunk */
int size = get_bits(&gb, 16); int size = get_bits(&gb, 16);
@ -193,30 +188,28 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
} else { } else {
/* decompress block */ /* decompress block */
int ret = inflateReset(&(s->zstream)); 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); av_log(avctx, AV_LOG_ERROR, "error in decompression (reset) of block %dx%d\n", i, j);
/* return -1; */ /* return -1; */
} }
s->zstream.next_in = buf+(get_bits_count(&gb)/8); s->zstream.next_in = buf + (get_bits_count(&gb) / 8);
s->zstream.avail_in = size; s->zstream.avail_in = size;
s->zstream.next_out = s->tmpblock; s->zstream.next_out = s->tmpblock;
s->zstream.avail_out = s->block_size*3; s->zstream.avail_out = s->block_size*3;
ret = inflate(&(s->zstream), Z_FINISH); 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"); av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
inflateSync(&(s->zstream)); inflateSync(&(s->zstream));
ret = inflate(&(s->zstream), Z_FINISH); 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); av_log(avctx, AV_LOG_ERROR, "error in decompression of block %dx%d: %d\n", i, j, ret);
/* return -1; */ /* 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),
skip_bits_long(&gb, 8*size); /* skip the consumed bits */ 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); *data_size = sizeof(AVFrame);
*(AVFrame*)data = s->frame; *(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", 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 */ /* report that the buffer was completely consumed */
return buf_size; return buf_size;
@ -249,15 +242,14 @@ static av_cold int flashsv_decode_end(AVCodecContext *avctx)
AVCodec ff_flashsv_decoder = { AVCodec ff_flashsv_decoder = {
"flashsv", .name = "flashsv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLASHSV, .id = CODEC_ID_FLASHSV,
sizeof(FlashSVContext), .priv_data_size = sizeof(FlashSVContext),
flashsv_decode_init, .init = flashsv_decode_init,
NULL, .close = flashsv_decode_end,
flashsv_decode_end, .decode = flashsv_decode_frame,
flashsv_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"), .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
}; };

123
libavcodec/flashsvenc.c
Unescape View File

@ -69,28 +69,29 @@ typedef struct FlashSVContext {
AVFrame frame; AVFrame frame;
int image_width, image_height; int image_width, image_height;
int block_width, block_height; int block_width, block_height;
uint8_t* tmpblock; uint8_t *tmpblock;
uint8_t* encbuffer; uint8_t *encbuffer;
int block_size; int block_size;
z_stream zstream; z_stream zstream;
int last_key_frame; int last_key_frame;
} FlashSVContext; } FlashSVContext;
static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, int dx, int dy,
int dx, int dy, int h, int w, int stride, uint8_t *pfptr) { int h, int w, int stride, uint8_t *pfptr)
int i,j; {
int i, j;
uint8_t *nsptr; uint8_t *nsptr;
uint8_t *npfptr; uint8_t *npfptr;
int diff = 0; int diff = 0;
for (i = dx+h; i > dx; i--) { for (i = dx + h; i > dx; i--) {
nsptr = sptr+(i*stride)+dy*3; nsptr = sptr + (i * stride) + dy * 3;
npfptr = pfptr+(i*stride)+dy*3; npfptr = pfptr + (i * stride) + dy * 3;
for (j=0 ; j<w*3 ; j++) { for (j = 0; j < w * 3; j++) {
diff |=npfptr[j]^nsptr[j]; diff |= npfptr[j] ^ nsptr[j];
dptr[j] = nsptr[j]; dptr[j] = nsptr[j];
} }
dptr += w*3; dptr += w * 3;
} }
if (diff) if (diff)
return 1; return 1;
@ -105,45 +106,47 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
if ((avctx->width > 4095) || (avctx->height > 4095)) { if ((avctx->width > 4095) || (avctx->height > 4095)) {
av_log(avctx, AV_LOG_ERROR, "Input dimensions too large, input must be max 4096x4096 !\n"); 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 // Needed if zlib unused or init aborted before deflateInit
memset(&(s->zstream), 0, sizeof(z_stream)); 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->image_height = avctx->height;
s->tmpblock = av_mallocz(3*256*256); s->tmpblock = av_mallocz(3 * 256 * 256);
s->encbuffer = av_mallocz(s->image_width*s->image_height*3); s->encbuffer = av_mallocz(s->image_width * s->image_height * 3);
if (!s->tmpblock || !s->encbuffer) { if (!s->tmpblock || !s->encbuffer) {
av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n"); av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
return -1; return AVERROR(ENOMEM);
} }
return 0; return 0;
} }
static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf_size, static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf,
int block_width, int block_height, uint8_t *previous_frame, int* I_frame) { int buf_size, int block_width, int block_height,
uint8_t *previous_frame, int *I_frame)
{
PutBitContext pb; PutBitContext pb;
int h_blocks, v_blocks, h_part, v_part, i, j; int h_blocks, v_blocks, h_part, v_part, i, j;
int buf_pos, res; int buf_pos, res;
int pred_blocks = 0; 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, 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); put_bits(&pb, 12, s->image_height);
flush_put_bits(&pb); flush_put_bits(&pb);
buf_pos=4; buf_pos = 4;
h_blocks = s->image_width / block_width; h_blocks = s->image_width / block_width;
h_part = s->image_width % block_width; h_part = s->image_width % block_width;
@ -151,41 +154,42 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf
v_part = s->image_height % block_height; v_part = s->image_height % block_height;
/* loop over all block columns */ /* 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 hp = j * block_height; // horiz position in frame
int hs = (j<v_blocks)?block_height:v_part; // size of block int hs = (j < v_blocks) ? block_height : v_part; // size of block
/* loop over all block rows */ /* 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 wp = i*block_width; // vert position in frame int ws = (i < h_blocks) ? block_width : h_part; // size of block
int ws = (i<h_blocks)?block_width:h_part; // size of block int ret = Z_OK;
int ret=Z_OK;
uint8_t *ptr; 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) /* copy the block to the temp buffer before compression
res = copy_region_enc(p->data[0], s->tmpblock, s->image_height-(hp+hs+1), wp, hs, ws, p->linesize[0], previous_frame); * (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) { if (res || *I_frame) {
unsigned long zsize; unsigned long zsize;
zsize = 3*block_width*block_height; zsize = 3 * block_width * block_height;
ret = compress2(ptr+2, &zsize, s->tmpblock, 3*ws*hs, 9); ret = compress2(ptr + 2, &zsize, s->tmpblock, 3 * ws * hs, 9);
//ret = deflateReset(&(s->zstream)); //ret = deflateReset(&(s->zstream));
if (ret != Z_OK) if (ret != Z_OK)
av_log(s->avctx, AV_LOG_ERROR, "error while compressing block %dx%d\n", i, j); av_log(s->avctx, AV_LOG_ERROR, "error while compressing block %dx%d\n", i, j);
bytestream_put_be16(&ptr,(unsigned int)zsize); bytestream_put_be16(&ptr, (unsigned int) zsize);
buf_pos += zsize+2; buf_pos += zsize + 2;
//av_log(avctx, AV_LOG_ERROR, "buf_pos = %d\n", buf_pos); //av_log(avctx, AV_LOG_ERROR, "buf_pos = %d\n", buf_pos);
} else { } else {
pred_blocks++; pred_blocks++;
bytestream_put_be16(&ptr,0); bytestream_put_be16(&ptr, 0);
buf_pos += 2; 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; FlashSVContext * const s = avctx->priv_data;
AVFrame *pict = 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 */ /* First frame needs to be a keyframe */
if (avctx->frame_number == 0) { 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) { if (!s->previous_frame) {
av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n"); av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
return -1; return AVERROR(ENOMEM);
} }
I_frame = 1; I_frame = 1;
} }
if (p->linesize[0] < 0) 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 else
pfptr = s->previous_frame; 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_w = 4;
opt_h=4; opt_h = 4;
if (buf_size < s->image_width*s->image_height*3) { if (buf_size < s->image_width*s->image_height*3) {
//Conservative upper bound check for compressed data //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; 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 //save the current frame
if(p->linesize[0] > 0) if (p->linesize[0] > 0)
memcpy(s->previous_frame, p->data[0], s->image_height*p->linesize[0]); memcpy(s->previous_frame, p->data[0], s->image_height * p->linesize[0]);
else 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 //mark the frame type so the muxer can mux it correctly
if (I_frame) { if (I_frame) {
p->pict_type = FF_I_TYPE; p->pict_type = FF_I_TYPE;
p->key_frame = 1; p->key_frame = 1;
s->last_key_frame = avctx->frame_number; 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 { } else {
p->pict_type = FF_P_TYPE; p->pict_type = FF_P_TYPE;
p->key_frame = 0; p->key_frame = 0;
@ -281,13 +288,13 @@ static av_cold int flashsv_encode_end(AVCodecContext *avctx)
} }
AVCodec ff_flashsv_encoder = { AVCodec ff_flashsv_encoder = {
"flashsv", .name = "flashsv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLASHSV, .id = CODEC_ID_FLASHSV,
sizeof(FlashSVContext), .priv_data_size = sizeof(FlashSVContext),
flashsv_encode_init, .init = flashsv_encode_init,
flashsv_encode_frame, .encode = flashsv_encode_frame,
flashsv_encode_end, .close = flashsv_encode_end,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video"), .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
}; };

12
libavformat/avidec.c
Unescape View File

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

Write Preview
Loading…
Cancel
Save