MrBesen/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

cinepakenc: Stop using AVPicture

Browse Source
This commit is contained in:
Timothy Gu 2017-06-28 00:27:15 +02:00 committed by Diego Biurrun
parent b40236d954
commit 1e12730e5d
1 changed files with 159 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

262
libavcodec/cinepakenc.c
View File

@ -429,105 +429,115 @@ static int encode_codebook(CinepakEncContext *s, int *codebook, int size, int ch
}
//sets out to the sub picture starting at (x,y) in in
static void get_sub_picture(CinepakEncContext *s, int x, int y, AVPicture *in, AVPicture *out)
static void get_sub_picture(CinepakEncContext *s, int x, int y,
uint8_t * in_data[4], int in_linesize[4],
uint8_t *out_data[4], int out_linesize[4])
{
out->data[0] = in->data[0] + x + y * in->linesize[0];
out->linesize[0] = in->linesize[0];
out_data[0] = in_data[0] + x + y * in_linesize[0];
out_linesize[0] = in_linesize[0];
if(s->pix_fmt == AV_PIX_FMT_RGB24) {
out->data[1] = in->data[1] + (x >> 1) + (y >> 1) * in->linesize[1];
out->linesize[1] = in->linesize[1];
out_data[1] = in_data[1] + (x >> 1) + (y >> 1) * in_linesize[1];
out_linesize[1] = in_linesize[1];
out->data[2] = in->data[2] + (x >> 1) + (y >> 1) * in->linesize[2];
out->linesize[2] = in->linesize[2];
out_data[2] = in_data[2] + (x >> 1) + (y >> 1) * in_linesize[2];
out_linesize[2] = in_linesize[2];
}
}
//decodes the V1 vector in mb into the 4x4 MB pointed to by sub_pict
static void decode_v1_vector(CinepakEncContext *s, AVPicture *sub_pict, int v1_vector, strip_info *info)
//decodes the V1 vector in mb into the 4x4 MB pointed to by data
static void decode_v1_vector(CinepakEncContext *s, uint8_t *data[4],
int linesize[4], int v1_vector, strip_info *info)
{
int entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
sub_pict->data[0][0] =
sub_pict->data[0][1] =
sub_pict->data[0][ sub_pict->linesize[0]] =
sub_pict->data[0][1+ sub_pict->linesize[0]] = info->v1_codebook[v1_vector*entry_size];
data[0][0] =
data[0][1] =
data[0][ linesize[0]] =
data[0][1+ linesize[0]] = info->v1_codebook[v1_vector*entry_size];
sub_pict->data[0][2] =
sub_pict->data[0][3] =
sub_pict->data[0][2+ sub_pict->linesize[0]] =
sub_pict->data[0][3+ sub_pict->linesize[0]] = info->v1_codebook[v1_vector*entry_size+1];
data[0][2] =
data[0][3] =
data[0][2+ linesize[0]] =
data[0][3+ linesize[0]] = info->v1_codebook[v1_vector*entry_size+1];
sub_pict->data[0][2*sub_pict->linesize[0]] =
sub_pict->data[0][1+2*sub_pict->linesize[0]] =
sub_pict->data[0][ 3*sub_pict->linesize[0]] =
sub_pict->data[0][1+3*sub_pict->linesize[0]] = info->v1_codebook[v1_vector*entry_size+2];
data[0][2*linesize[0]] =
data[0][1+2*linesize[0]] =
data[0][ 3*linesize[0]] =
data[0][1+3*linesize[0]] = info->v1_codebook[v1_vector*entry_size+2];
sub_pict->data[0][2+2*sub_pict->linesize[0]] =
sub_pict->data[0][3+2*sub_pict->linesize[0]] =
sub_pict->data[0][2+3*sub_pict->linesize[0]] =
sub_pict->data[0][3+3*sub_pict->linesize[0]] = info->v1_codebook[v1_vector*entry_size+3];
data[0][2+2*linesize[0]] =
data[0][3+2*linesize[0]] =
data[0][2+3*linesize[0]] =
data[0][3+3*linesize[0]] = info->v1_codebook[v1_vector*entry_size+3];
if(s->pix_fmt == AV_PIX_FMT_RGB24) {
sub_pict->data[1][0] =
sub_pict->data[1][1] =
sub_pict->data[1][ sub_pict->linesize[1]] =
sub_pict->data[1][1+ sub_pict->linesize[1]] = info->v1_codebook[v1_vector*entry_size+4];
data[1][0] =
data[1][1] =
data[1][ linesize[1]] =
data[1][1+ linesize[1]] = info->v1_codebook[v1_vector*entry_size+4];
sub_pict->data[2][0] =
sub_pict->data[2][1] =
sub_pict->data[2][ sub_pict->linesize[2]] =
sub_pict->data[2][1+ sub_pict->linesize[2]] = info->v1_codebook[v1_vector*entry_size+5];
data[2][0] =
data[2][1] =
data[2][ linesize[2]] =
data[2][1+ linesize[2]] = info->v1_codebook[v1_vector*entry_size+5];
}
}
//decodes the V4 vectors in mb into the 4x4 MB pointed to by sub_pict
static void decode_v4_vector(CinepakEncContext *s, AVPicture *sub_pict, int *v4_vector, strip_info *info)
//decodes the V4 vectors in mb into the 4x4 MB pointed to by data
static void decode_v4_vector(CinepakEncContext *s, uint8_t *data[4],
int linesize[4], int *v4_vector, strip_info *info)
{
int i, x, y, entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
for(i = y = 0; y < 4; y += 2) {
for(x = 0; x < 4; x += 2, i++) {
sub_pict->data[0][x + y*sub_pict->linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size];
sub_pict->data[0][x+1 + y*sub_pict->linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size+1];
sub_pict->data[0][x + (y+1)*sub_pict->linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size+2];
sub_pict->data[0][x+1 + (y+1)*sub_pict->linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size+3];
data[0][x + y*linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size];
data[0][x+1 + y*linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size+1];
data[0][x + (y+1)*linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size+2];
data[0][x+1 + (y+1)*linesize[0]] = info->v4_codebook[v4_vector[i]*entry_size+3];
if(s->pix_fmt == AV_PIX_FMT_RGB24) {
sub_pict->data[1][(x>>1) + (y>>1)*sub_pict->linesize[1]] = info->v4_codebook[v4_vector[i]*entry_size+4];
sub_pict->data[2][(x>>1) + (y>>1)*sub_pict->linesize[2]] = info->v4_codebook[v4_vector[i]*entry_size+5];
data[1][(x>>1) + (y>>1)*linesize[1]] = info->v4_codebook[v4_vector[i]*entry_size+4];
data[2][(x>>1) + (y>>1)*linesize[2]] = info->v4_codebook[v4_vector[i]*entry_size+5];
}
}
}
}
static void copy_mb(CinepakEncContext *s, AVPicture *a, AVPicture *b)
static void copy_mb(CinepakEncContext *s,
uint8_t *a_data[4], int a_linesize[4],
uint8_t *b_data[4], int b_linesize[4])
{
int y, p;
for(y = 0; y < MB_SIZE; y++) {
memcpy(a->data[0]+y*a->linesize[0], b->data[0]+y*b->linesize[0],
memcpy(a_data[0]+y*a_linesize[0], b_data[0]+y*b_linesize[0],
MB_SIZE);
}
if(s->pix_fmt == AV_PIX_FMT_RGB24) {
for(p = 1; p <= 2; p++) {
for(y = 0; y < MB_SIZE/2; y++) {
memcpy(a->data[p] + y*a->linesize[p],
b->data[p] + y*b->linesize[p],
memcpy(a_data[p] + y*a_linesize[p],
b_data[p] + y*b_linesize[p],
MB_SIZE/2);
}
}
}
}
static int encode_mode(CinepakEncContext *s, int h, AVPicture *scratch_pict, AVPicture *last_pict, strip_info *info, unsigned char *buf)
static int encode_mode(CinepakEncContext *s, int h,
uint8_t *scratch_data[4], int scratch_linesize[4],
uint8_t *last_data[4], int last_linesize[4],
strip_info *info, unsigned char *buf)
{
int x, y, z, flags, bits, temp_size, header_ofs, ret = 0, mb_count = s->w * h / MB_AREA;
int needs_extra_bit, should_write_temp;
unsigned char temp[64]; //32/2 = 16 V4 blocks at 4 B each -> 64 B
mb_info *mb;
AVPicture sub_scratch, sub_last;
uint8_t *sub_scratch_data[4] = {0}, *sub_last_data[4] = {0};
int sub_scratch_linesize[4] = {0}, sub_last_linesize[4] = {0};
//encode codebooks
////// MacOS vintage decoder compatibility dictates the presence of
@ -544,15 +554,21 @@ static int encode_mode(CinepakEncContext *s, int h, AVPicture *scratch_pict, AVP
for(x = 0; x < s->w; x += MB_SIZE, z++) {
mb = &s->mb[z];
get_sub_picture(s, x, y, scratch_pict, &sub_scratch);
get_sub_picture(s, x, y, scratch_data, scratch_linesize,
sub_scratch_data, sub_scratch_linesize);
if(info->mode == MODE_MC && mb->best_encoding == ENC_SKIP) {
get_sub_picture(s, x, y, last_pict, &sub_last);
copy_mb(s, &sub_scratch, &sub_last);
get_sub_picture(s, x, y,
last_data, last_linesize,
sub_last_data, sub_last_linesize);
copy_mb(s, sub_scratch_data, sub_scratch_linesize,
sub_last_data, sub_last_linesize);
} else if(info->mode == MODE_V1_ONLY || mb->best_encoding == ENC_V1)
decode_v1_vector(s, &sub_scratch, mb->v1_vector, info);
decode_v1_vector(s, sub_scratch_data, sub_scratch_linesize,
mb->v1_vector, info);
else
decode_v4_vector(s, &sub_scratch, mb->v4_vector, info);
decode_v4_vector(s, sub_scratch_data, sub_scratch_linesize,
mb->v4_vector, info);
}
}
@ -659,13 +675,15 @@ static int encode_mode(CinepakEncContext *s, int h, AVPicture *scratch_pict, AVP
}
//computes distortion of 4x4 MB in b compared to a
static int compute_mb_distortion(CinepakEncContext *s, AVPicture *a, AVPicture *b)
static int compute_mb_distortion(CinepakEncContext *s,
uint8_t *a_data[4], int a_linesize[4],
uint8_t *b_data[4], int b_linesize[4])
{
int x, y, p, d, ret = 0;
for(y = 0; y < MB_SIZE; y++) {
for(x = 0; x < MB_SIZE; x++) {
d = a->data[0][x + y*a->linesize[0]] - b->data[0][x + y*b->linesize[0]];
d = a_data[0][x + y*a_linesize[0]] - b_data[0][x + y*b_linesize[0]];
ret += d*d;
}
}
@ -674,7 +692,7 @@ static int compute_mb_distortion(CinepakEncContext *s, AVPicture *a, AVPicture *
for(p = 1; p <= 2; p++) {
for(y = 0; y < MB_SIZE/2; y++) {
for(x = 0; x < MB_SIZE/2; x++) {
d = a->data[p][x + y*a->linesize[p]] - b->data[p][x + y*b->linesize[p]];
d = a_data[p][x + y*a_linesize[p]] - b_data[p][x + y*b_linesize[p]];
ret += d*d;
}
}
@ -686,7 +704,8 @@ static int compute_mb_distortion(CinepakEncContext *s, AVPicture *a, AVPicture *
// return the possibly adjusted size of the codebook
#define CERTAIN(x) ((x)!=ENC_UNCERTAIN)
static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
static int quantize(CinepakEncContext *s, int h,
uint8_t *data[4], int linesize[4],
int v1mode, strip_info *info,
mb_encoding encoding)
{
@ -696,7 +715,8 @@ static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
int size = v1mode ? info->v1_size : info->v4_size;
int64_t total_error = 0;
uint8_t vq_pict_buf[(MB_AREA*3)/2];
AVPicture sub_pict, vq_pict;
uint8_t *sub_data [4], *vq_data [4];
int sub_linesize[4], vq_linesize[4];
for(mbn = i = y = 0; y < h; y += MB_SIZE) {
for(x = 0; x < s->w; x += MB_SIZE, ++mbn) {
@ -716,10 +736,10 @@ static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
shift = y2 < 4 ? 0 : 1;
x3 = shift ? 0 : x2;
y3 = shift ? 0 : y2;
base[j] = (pict->data[plane][((x+x3) >> shift) + ((y+y3) >> shift) * pict->linesize[plane]] +
pict->data[plane][((x+x3) >> shift) + 1 + ((y+y3) >> shift) * pict->linesize[plane]] +
pict->data[plane][((x+x3) >> shift) + (((y+y3) >> shift) + 1) * pict->linesize[plane]] +
pict->data[plane][((x+x3) >> shift) + 1 + (((y+y3) >> shift) + 1) * pict->linesize[plane]]) >> 2;
base[j] = (data[plane][((x+x3) >> shift) + ((y+y3) >> shift) * linesize[plane]] +
data[plane][((x+x3) >> shift) + 1 + ((y+y3) >> shift) * linesize[plane]] +
data[plane][((x+x3) >> shift) + (((y+y3) >> shift) + 1) * linesize[plane]] +
data[plane][((x+x3) >> shift) + 1 + (((y+y3) >> shift) + 1) * linesize[plane]]) >> 2;
}
}
} else {
@ -737,7 +757,7 @@ static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
y3 = y + y2 + (k >> 1);
}
base[j] = pict->data[plane][x3 + y3*pict->linesize[plane]];
base[j] = data[plane][x3 + y3*linesize[plane]];
}
}
}
@ -754,12 +774,12 @@ static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
ff_init_elbg(s->codebook_input, entry_size, i, codebook, size, 1, s->codebook_closest, &s->randctx);
ff_do_elbg(s->codebook_input, entry_size, i, codebook, size, 1, s->codebook_closest, &s->randctx);
//setup vq_pict, which contains a single MB
vq_pict.data[0] = vq_pict_buf;
vq_pict.linesize[0] = MB_SIZE;
vq_pict.data[1] = &vq_pict_buf[MB_AREA];
vq_pict.data[2] = vq_pict.data[1] + (MB_AREA >> 2);
vq_pict.linesize[1] = vq_pict.linesize[2] = MB_SIZE >> 1;
//setup vq_data, which contains a single MB
vq_data[0] = vq_pict_buf;
vq_linesize[0] = MB_SIZE;
vq_data[1] = &vq_pict_buf[MB_AREA];
vq_data[2] = vq_data[1] + (MB_AREA >> 2);
vq_linesize[1] = vq_linesize[2] = MB_SIZE >> 1;
//copy indices
for(i = j = y = 0; y < h; y += MB_SIZE) {
@ -769,25 +789,27 @@ static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
if(CERTAIN(encoding) && mb->best_encoding != encoding)
continue;
//point sub_pict to current MB
get_sub_picture(s, x, y, pict, &sub_pict);
//point sub_data to current MB
get_sub_picture(s, x, y, data, linesize, sub_data, sub_linesize);
if(v1mode) {
mb->v1_vector = s->codebook_closest[i];
//fill in vq_pict with V1 data
decode_v1_vector(s, &vq_pict, mb->v1_vector, info);
//fill in vq_data with V1 data
decode_v1_vector(s, vq_data, vq_linesize, mb->v1_vector, info);
mb->v1_error = compute_mb_distortion(s, &sub_pict, &vq_pict);
mb->v1_error = compute_mb_distortion(s, sub_data, sub_linesize,
vq_data, vq_linesize);
total_error += mb->v1_error;
} else {
for(k = 0; k < 4; k++)
mb->v4_vector[k] = s->codebook_closest[i+k];
//fill in vq_pict with V4 data
decode_v4_vector(s, &vq_pict, mb->v4_vector, info);
//fill in vq_data with V4 data
decode_v4_vector(s, vq_data, vq_linesize, mb->v4_vector, info);
mb->v4_error = compute_mb_distortion(s, &sub_pict, &vq_pict);
mb->v4_error = compute_mb_distortion(s, sub_data, sub_linesize,
vq_data, vq_linesize);
total_error += mb->v4_error;
}
i += v1mode ? 1 : 4;
@ -799,17 +821,25 @@ static int quantize(CinepakEncContext *s, int h, AVPicture *pict,
return size;
}
static void calculate_skip_errors(CinepakEncContext *s, int h, AVPicture *last_pict, AVPicture *pict, strip_info *info)
static void calculate_skip_errors(CinepakEncContext *s, int h,
uint8_t *last_data[4], int last_linesize[4],
uint8_t *data[4], int linesize[4],
strip_info *info)
{
int x, y, i;
AVPicture sub_last, sub_pict;
uint8_t *sub_last_data [4], *sub_pict_data [4];
int sub_last_linesize[4], sub_pict_linesize[4];
for(i = y = 0; y < h; y += MB_SIZE) {
for(x = 0; x < s->w; x += MB_SIZE, i++) {
get_sub_picture(s, x, y, last_pict, &sub_last);
get_sub_picture(s, x, y, pict, &sub_pict);
get_sub_picture(s, x, y, last_data, last_linesize,
sub_last_data, sub_last_linesize);
get_sub_picture(s, x, y, data, linesize,
sub_pict_data, sub_pict_linesize);
s->mb[i].skip_error = compute_mb_distortion(s, &sub_last, &sub_pict);
s->mb[i].skip_error = compute_mb_distortion(s,
sub_last_data, sub_last_linesize,
sub_pict_data, sub_pict_linesize);
}
}
}
@ -831,7 +861,11 @@ static void write_strip_header(CinepakEncContext *s, int y, int h, int keyframe,
AV_WB16(&buf[10], s->w);
}
static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture *last_pict, AVPicture *pict, AVPicture *scratch_pict, unsigned char *buf, int64_t *best_score)
static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe,
uint8_t *last_data[4], int last_linesize[4],
uint8_t *data[4], int linesize[4],
uint8_t *scratch_data[4], int scratch_linesize[4],
unsigned char *buf, int64_t *best_score)
{
int64_t score = 0;
int best_size = 0;
@ -842,7 +876,8 @@ static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture
int v1shrunk, v4shrunk;
if(!keyframe)
calculate_skip_errors(s, h, last_pict, pict, &info);
calculate_skip_errors(s, h, last_data, last_linesize, data, linesize,
&info);
//try some powers of 4 for the size of the codebooks
//constraint the v4 codebook to be no bigger than v1 one,
@ -860,7 +895,8 @@ static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture
if(mode == MODE_V1_ONLY) {
info.v1_size = v1_size;
// the size may shrink even before optimizations if the input is short:
info.v1_size = quantize(s, h, pict, 1, &info, ENC_UNCERTAIN);
info.v1_size = quantize(s, h, data, linesize, 1,
&info, ENC_UNCERTAIN);
if(info.v1_size < v1_size)
// too few eligible blocks, no sense in trying bigger sizes
v1enough = 1;
@ -873,7 +909,8 @@ static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture
if(mode == MODE_V1_V4) {
info.v4_size = v4_size;
info.v4_size = quantize(s, h, pict, 0, &info, ENC_UNCERTAIN);
info.v4_size = quantize(s, h, data, linesize, 0,
&info, ENC_UNCERTAIN);
if(info.v4_size < v4_size)
// too few eligible blocks, no sense in trying bigger sizes
v4enough = 1;
@ -890,12 +927,12 @@ static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture
// recompute the codebooks, omitting the extra blocks
// we assume we _may_ come here with more blocks to encode than before
info.v1_size = v1_size;
new_v1_size = quantize(s, h, pict, 1, &info, ENC_V1);
new_v1_size = quantize(s, h, data, linesize, 1, &info, ENC_V1);
if (new_v1_size < info.v1_size)
info.v1_size = new_v1_size;
// we assume we _may_ come here with more blocks to encode than before
info.v4_size = v4_size;
new_v4_size = quantize(s, h, pict, 0, &info, ENC_V4);
new_v4_size = quantize(s, h, data, linesize, 0, &info, ENC_V4);
if (new_v4_size < info.v4_size)
info.v4_size = new_v4_size;
// calculate the resulting score
@ -910,13 +947,13 @@ static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture
// recompute the codebooks, omitting the extra blocks
if(v1shrunk) {
info.v1_size = v1_size;
new_v1_size = quantize(s, h, pict, 1, &info, ENC_V1);
new_v1_size = quantize(s, h, data, linesize, 1, &info, ENC_V1);
if (new_v1_size < info.v1_size)
info.v1_size = new_v1_size;
}
if(v4shrunk) {
info.v4_size = v4_size;
new_v4_size = quantize(s, h, pict, 0, &info, ENC_V4);
new_v4_size = quantize(s, h, data, linesize, 0, &info, ENC_V4);
if (new_v4_size < info.v4_size)
info.v4_size = new_v4_size;
}
@ -926,7 +963,11 @@ static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, AVPicture
if(best_size == 0 || score < *best_score) {
*best_score = score;
best_size = encode_mode(s, h, scratch_pict, last_pict, &info, s->strip_buf + STRIP_HEADER_SIZE);
best_size = encode_mode(s, h,
scratch_data, scratch_linesize,
last_data, last_linesize, &info,
s->strip_buf + STRIP_HEADER_SIZE);
write_strip_header(s, y, h, keyframe, s->strip_buf, best_size);
}
@ -951,10 +992,12 @@ static int write_cvid_header(CinepakEncContext *s, unsigned char *buf, int num_s
return CVID_HEADER_SIZE;
}
static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe, unsigned char *buf, int buf_size)
static int rd_frame(CinepakEncContext *s, const AVFrame *frame,
int isakeyframe, unsigned char *buf, int buf_size)
{
int num_strips, strip, i, y, nexty, size, temp_size, best_size;
AVPicture last_pict, pict, scratch_pict;
uint8_t *last_data [4], *data [4], *scratch_data [4];
int last_linesize[4], linesize[4], scratch_linesize[4];
int64_t best_score = 0, score, score_temp;
int best_nstrips;
@ -964,9 +1007,11 @@ static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe,
for(y = 0; y < s->h; y += 2) {
for(x = 0; x < s->w; x += 2) {
uint8_t *ir[2]; int32_t r, g, b, rr, gg, bb;
ir[0] = ((AVPicture*)frame)->data[0] + x*3 + y*((AVPicture*)frame)->linesize[0];
ir[1] = ir[0] + ((AVPicture*)frame)->linesize[0];
get_sub_picture(s, x, y, (AVPicture*)s->input_frame, &scratch_pict);
ir[0] = frame->data[0] + x*3 + y*frame->linesize[0];
ir[1] = ir[0] + frame->linesize[0];
get_sub_picture(s, x, y,
s->input_frame->data, s->input_frame->linesize,
scratch_data, scratch_linesize);
r = g = b = 0;
for(i=0; i<4; ++i) {
int i1, i2;
@ -981,7 +1026,7 @@ static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe,
rr = (2396625*rr + 4793251*gg + 1198732*bb) >> 23;
if( rr < 0) rr = 0;
else if (rr > 255) rr = 255;
scratch_pict.data[0][i1 + i2*scratch_pict.linesize[0]] = rr;
scratch_data[0][i1 + i2*scratch_linesize[0]] = rr;
}
// let us scale down as late as possible
// r /= 4; g /= 4; b /= 4;
@ -990,13 +1035,13 @@ static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe,
rr = (-299683*r - 599156*g + 898839*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[1][0] = rr + 128; // quantize needs unsigned
scratch_data[1][0] = rr + 128; // quantize needs unsigned
// "V"
// rr = 0.3571*r - 0.2857*g - 0.0714*b;
rr = (748893*r - 599156*g - 149737*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[2][0] = rr + 128; // quantize needs unsigned
scratch_data[2][0] = rr + 128; // quantize needs unsigned
}
}
}
@ -1022,13 +1067,24 @@ static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe,
}
if(s->pix_fmt == AV_PIX_FMT_RGB24)
get_sub_picture(s, 0, y, (AVPicture*)s->input_frame, &pict);
get_sub_picture(s, 0, y,
s->input_frame->data, s->input_frame->linesize,
data, linesize);
else
get_sub_picture(s, 0, y, (AVPicture*)frame, &pict);
get_sub_picture(s, 0, y, (AVPicture*)s->last_frame, &last_pict);
get_sub_picture(s, 0, y, (AVPicture*)s->scratch_frame, &scratch_pict);
get_sub_picture(s, 0, y,
(uint8_t **)frame->data, (int*)frame->linesize,
data, linesize);
get_sub_picture(s, 0, y,
s->last_frame->data, s->last_frame->linesize,
last_data, last_linesize);
get_sub_picture(s, 0, y,
s->scratch_frame->data, s->scratch_frame->linesize,
scratch_data, scratch_linesize);
if((temp_size = rd_strip(s, y, strip_height, isakeyframe, &last_pict, &pict, &scratch_pict, s->frame_buf + size + CVID_HEADER_SIZE, &score_temp)) < 0)
if((temp_size = rd_strip(s, y, strip_height, isakeyframe,
last_data, last_linesize, data, linesize,
scratch_data, scratch_linesize,
s->frame_buf + size + CVID_HEADER_SIZE, &score_temp)) < 0)
return temp_size;
score += score_temp;