#include "libavutil/attributes.h"
#include "libavutil/crc.h"
+#include "libavutil/mem_internal.h"
#include "internal.h"
#include "avcodec.h"
typedef struct SVQ3Frame {
AVFrame *f;
- AVBufferRef *motion_val_buf[2];
+ int16_t (*motion_val_buf[2])[2];
int16_t (*motion_val[2])[2];
- AVBufferRef *mb_type_buf;
- uint32_t *mb_type;
-
-
- AVBufferRef *ref_index_buf[2];
- int8_t *ref_index[2];
+ uint32_t *mb_type_buf, *mb_type;
} SVQ3Frame;
typedef struct SVQ3Context {
GetBitContext gb;
GetBitContext gb_slice;
uint8_t *slice_buf;
- int slice_size;
+ unsigned slice_buf_size;
int halfpel_flag;
int thirdpel_flag;
int has_watermark;
uint32_t watermark_key;
- uint8_t *buf;
- int buf_size;
int adaptive_quant;
int next_p_frame_damaged;
int h_edge_pos;
61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
};
-static int svq3_decode_end(AVCodecContext *avctx);
-
static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
{
const unsigned qmul = svq3_dequant_coeff[qp];
skip_bits(&s->gb, 8);
- av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
+ av_fast_padded_malloc(&s->slice_buf, &s->slice_buf_size, slice_bytes);
if (!s->slice_buf)
return AVERROR(ENOMEM);
int w,h;
size = AV_RB32(&extradata[4]);
- if (size > extradata_end - extradata - 8) {
- ret = AVERROR_INVALIDDATA;
- goto fail;
- }
+ if (size > extradata_end - extradata - 8)
+ return AVERROR_INVALIDDATA;
init_get_bits(&gb, extradata + 8, size * 8);
/* 'frame size code' and optional 'width, height' */
}
ret = ff_set_dimensions(avctx, w, h);
if (ret < 0)
- goto fail;
+ return ret;
s->halfpel_flag = get_bits1(&gb);
s->thirdpel_flag = get_bits1(&gb);
av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
unk0, unk1, unk2, unk3, unk4);
- if (skip_1stop_8data_bits(&gb) < 0) {
- ret = AVERROR_INVALIDDATA;
- goto fail;
- }
+ if (skip_1stop_8data_bits(&gb) < 0)
+ return AVERROR_INVALIDDATA;
s->has_watermark = get_bits1(&gb);
avctx->has_b_frames = !s->low_delay;
uint8_t *buf;
if (watermark_height <= 0 ||
- (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
- ret = -1;
- goto fail;
- }
+ (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
+ return AVERROR_INVALIDDATA;
buf = av_malloc(buf_len);
- if (!buf) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
+ if (!buf)
+ return AVERROR(ENOMEM);
+
av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
watermark_width, watermark_height);
av_log(avctx, AV_LOG_DEBUG,
av_log(avctx, AV_LOG_ERROR,
"could not uncompress watermark logo\n");
av_free(buf);
- ret = -1;
- goto fail;
+ return -1;
}
s->watermark_key = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), 0, buf, buf_len));
#else
av_log(avctx, AV_LOG_ERROR,
"this svq3 file contains watermark which need zlib support compiled in\n");
- ret = -1;
- goto fail;
+ return AVERROR(ENOSYS);
#endif
}
}
init_dequant4_coeff_table(s);
return 0;
-fail:
- svq3_decode_end(avctx);
- return ret;
}
-static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
+static void free_picture(SVQ3Frame *pic)
{
int i;
for (i = 0; i < 2; i++) {
- av_buffer_unref(&pic->motion_val_buf[i]);
- av_buffer_unref(&pic->ref_index_buf[i]);
+ av_freep(&pic->motion_val_buf[i]);
}
- av_buffer_unref(&pic->mb_type_buf);
+ av_freep(&pic->mb_type_buf);
av_frame_unref(pic->f);
}
{
SVQ3Context *s = avctx->priv_data;
const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
- const int mb_array_size = s->mb_stride * s->mb_height;
const int b4_stride = s->mb_width * 4 + 1;
const int b4_array_size = b4_stride * s->mb_height * 4;
int ret;
if (!pic->motion_val_buf[0]) {
int i;
- pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
+ pic->mb_type_buf = av_calloc(big_mb_num + s->mb_stride, sizeof(uint32_t));
if (!pic->mb_type_buf)
return AVERROR(ENOMEM);
- pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
+ pic->mb_type = pic->mb_type_buf + 2 * s->mb_stride + 1;
for (i = 0; i < 2; i++) {
- pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
- pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
- if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
+ pic->motion_val_buf[i] = av_calloc(b4_array_size + 4, 2 * sizeof(int16_t));
+ if (!pic->motion_val_buf[i]) {
ret = AVERROR(ENOMEM);
goto fail;
}
- pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
- pic->ref_index[i] = pic->ref_index_buf[i]->data;
+ pic->motion_val[i] = pic->motion_val_buf[i] + 4;
}
}
return 0;
fail:
- free_picture(avctx, pic);
+ free_picture(pic);
return ret;
}
SVQ3Context *s = avctx->priv_data;
int buf_size = avpkt->size;
int left;
- uint8_t *buf;
int ret, m, i;
/* special case for last picture */
s->mb_x = s->mb_y = s->mb_xy = 0;
- if (s->watermark_key) {
- av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
- if (!s->buf)
- return AVERROR(ENOMEM);
- memcpy(s->buf, avpkt->data, buf_size);
- buf = s->buf;
- } else {
- buf = avpkt->data;
- }
-
- ret = init_get_bits(&s->gb, buf, 8 * buf_size);
+ ret = init_get_bits8(&s->gb, avpkt->data, avpkt->size);
if (ret < 0)
return ret;
{
SVQ3Context *s = avctx->priv_data;
- free_picture(avctx, s->cur_pic);
- free_picture(avctx, s->next_pic);
- free_picture(avctx, s->last_pic);
- av_frame_free(&s->cur_pic->f);
- av_frame_free(&s->next_pic->f);
- av_frame_free(&s->last_pic->f);
+ for (int i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
+ free_picture(&s->frames[i]);
+ av_frame_free(&s->frames[i].f);
+ }
av_freep(&s->slice_buf);
av_freep(&s->intra4x4_pred_mode);
av_freep(&s->edge_emu_buffer);
av_freep(&s->mb2br_xy);
-
- av_freep(&s->buf);
- s->buf_size = 0;
-
return 0;
}
-AVCodec ff_svq3_decoder = {
+const AVCodec ff_svq3_decoder = {
.name = "svq3",
.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
.type = AVMEDIA_TYPE_VIDEO,
AV_CODEC_CAP_DELAY,
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
AV_PIX_FMT_NONE},
+ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
};
projects / ffmpeg / blobdiff