Chiebot-Mirror
/
FFmpeg
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cinepakenc: Stop using AVPicture

Browse Source
pull/272/head
Timothy Gu 8 years ago committed by Diego Biurrun
parent b40236d954
commit 1e12730e5d
1 changed files with 162 additions and 106 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 268
      libavcodec/cinepakenc.c

268
libavcodec/cinepakenc.c
Unescape 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];
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[1][0] =
data[1][1] =
data[1][ linesize[1]] =
data[1][1+ linesize[1]] = info->v1_codebook[v1_vector*entry_size+4];
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);
s->mb[i].skip_error = compute_mb_distortion(s, &sub_last, &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_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);
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)
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_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;

Write Preview
Loading…
Cancel
Save