46 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
47 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
54 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
55 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
56 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
57 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
58 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,
59 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
60 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
61 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
65 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
70 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
71 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
72 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
73 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
74 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
75 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
76 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
77 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
78 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
79 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
80 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,
84 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
86 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
87 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
93 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
94 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
95 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
96 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
97 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
98 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
99 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
103 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
104 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
105 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
110 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
111 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
112 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
113 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
114 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
115 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
116 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
117 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
118 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
122 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
123 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
124 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
125 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
126 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
127 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
128 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
141 const uint8_t one_state[256])
146 for (
i = 1;
i < 256;
i++)
147 l2tab[
i] = -
log2(
i / 256.0) * ((1
U << 31) / 8);
149 for (
i = 0;
i < 256;
i++) {
150 uint64_t best_len[256];
152 for (j = 0; j < 256; j++)
153 best_len[j] = UINT64_MAX;
155 for (j =
FFMAX(
i - 10, 1); j <
FFMIN(
i + 11, 256); j++) {
156 uint32_t occ[256] = { 0 };
163 for (k = 0; k < 256; k++) {
164 uint32_t newocc[256] = { 0 };
165 for (m = 1; m < 256; m++)
167 len += (occ[m]*((
i *(uint64_t)l2tab[ m]
168 + (256-
i)*(uint64_t)l2tab[256-m])>>8)) >> 8;
170 if (
len < best_len[k]) {
172 best_state[
i][k] = j;
174 for (m = 1; m < 256; m++)
176 newocc[ one_state[ m]] += occ[m] * (uint64_t)
i >> 8;
177 newocc[256 - one_state[256 - m]] += occ[m] * (uint64_t)(256 -
i) >> 8;
179 memcpy(occ, newocc,
sizeof(occ));
186 uint8_t *
state,
int v,
188 uint64_t rc_stat[256][2],
189 uint64_t rc_stat2[32][2])
193 #define put_rac(C, S, B) \
196 rc_stat[*(S)][B]++; \
197 rc_stat2[(S) - state][B]++; \
203 const unsigned a = is_signed ?
FFABS(v) : v;
207 for (
i = 0;
i < e;
i++)
211 for (
i = e - 1;
i >= 0;
i--)
217 for (
i = 0;
i < e;
i++)
221 for (
i = e - 1;
i >= 0;
i--)
234 int v,
int is_signed)
248 while (i < state->error_sum) {
257 ff_dlog(
NULL,
"v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v,
code,
265 #define RENAME(name) name
271 #define RENAME(name) name ## 32
275 const uint8_t *
src,
int w,
int h,
276 int stride,
int plane_index,
int remap_index,
int pixel_stride,
int ac)
280 const int ring_size =
f->context_model ? 3 : 2;
286 for (y = 0; y <
h; y++) {
293 if (
f->bits_per_raw_sample <= 8) {
294 for (x = 0; x <
w; x++)
297 for (x = 0; x <
w; x++)
303 if (
f->packed_at_lsb) {
304 for (x = 0; x <
w; x++) {
308 for (x = 0; x <
w; x++) {
309 sample[0][x] = ((uint16_t*)(
src +
stride*y))[x * pixel_stride] >> (16 -
f->bits_per_raw_sample);
313 for (x = 0; x <
w; x++)
324 const uint8_t *
src,
int w,
int h,
325 int stride,
int remap_index,
int pixel_stride)
329 memset(sc->
fltmap[remap_index], 0, 65536 *
sizeof(*sc->
fltmap[remap_index]));
331 for (y = 0; y <
h; y++) {
332 if (
f->bits_per_raw_sample <= 8) {
333 for (x = 0; x <
w; x++)
336 if (
f->packed_at_lsb) {
337 for (x = 0; x <
w; x++)
338 sc->
fltmap[remap_index][ ((uint16_t*)(
src +
stride*y))[x * pixel_stride] ] = 1;
340 for (x = 0; x <
w; x++)
341 sc->
fltmap[remap_index][ ((uint16_t*)(
src +
stride*y))[x * pixel_stride] >> (16 -
f->bits_per_raw_sample) ] = 1;
366 for (
i = 0;
i < 5;
i++)
375 for (
int i = 0;
i < nb_contexts;
i++)
377 if (initial_state[
i][j] != 128)
390 if (
f->version < 2) {
394 for (
i = 1;
i < 256;
i++)
396 f->state_transition[
i] -
c->one_state[
i], 1);
407 }
else if (
f->version < 3) {
409 for (
i = 0;
i <
f->slice_count;
i++) {
412 (
fs->slice_x + 1) *
f->num_h_slices /
f->width, 0);
414 (
fs->slice_y + 1) *
f->num_v_slices /
f->height, 0);
416 (
fs->slice_width + 1) *
f->num_h_slices /
f->width - 1,
419 (
fs->slice_height + 1) *
f->num_v_slices /
f->height - 1,
421 for (j = 0; j <
f->plane_count; j++) {
423 av_assert0(
fs->plane[j].quant_table_index ==
f->context_model);
431 f->combined_version =
f->version << 16;
432 if (
f->version > 2) {
433 if (
f->version == 3) {
434 f->micro_version = 4;
435 }
else if (
f->version == 4) {
436 f->micro_version = 7;
440 f->combined_version +=
f->micro_version;
455 memset(state2, 128,
sizeof(state2));
458 f->avctx->extradata_size = 10000 + 4 +
459 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;
461 if (!
f->avctx->extradata)
472 for (
i = 1;
i < 256;
i++)
485 for (
i = 0;
i <
f->quant_table_count;
i++)
488 for (
i = 0;
i <
f->quant_table_count;
i++) {
491 for (j = 0; j <
f->context_count[
i]; j++)
493 int pred = j ?
f->initial_states[
i][j - 1][k] : 128;
495 (int8_t)(
f->initial_states[
i][j][k] -
pred), 1);
502 if (
f->version > 2) {
509 AV_WL32(
f->avctx->extradata +
f->avctx->extradata_size, v);
510 f->avctx->extradata_size += 4;
517 int i, i2, changed,
print = 0;
521 for (
i = 12;
i < 244;
i++) {
522 for (i2 =
i + 1; i2 < 245 && i2 <
i + 4; i2++) {
524 #define COST(old, new) \
525 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \
526 s->rc_stat[old][1] * -log2((new) / 256.0)
528 #define COST2(old, new) \
529 COST(old, new) + COST(256 - (old), 256 - (new))
533 if (size0 - sizeX > size0*(1e-14) &&
i != 128 && i2 != 128) {
536 FFSWAP(
int,
s->rc_stat[
i][0],
s->rc_stat[i2][0]);
537 FFSWAP(
int,
s->rc_stat[
i][1],
s->rc_stat[i2][1]);
539 FFSWAP(
int, stt[256 -
i], stt[256 - i2]);
540 FFSWAP(
int,
s->rc_stat[256 -
i][0],
s->rc_stat[256 - i2][0]);
541 FFSWAP(
int,
s->rc_stat[256 -
i][1],
s->rc_stat[256 - i2][1]);
543 for (j = 1; j < 256; j++) {
546 else if (stt[j] == i2)
549 if (stt[256 - j] == 256 -
i)
550 stt[256 - j] = 256 - i2;
551 else if (stt[256 - j] == 256 - i2)
552 stt[256 - j] = 256 -
i;
567 int plane_count = 1 + 2*
s->chroma_planes +
s->transparency;
570 s->num_v_slices = (avctx->
width > 352 || avctx->
height > 288 || !avctx->
slices) ? 2 : 1;
571 s->num_v_slices =
FFMIN(
s->num_v_slices, max_v_slices);
572 for (;
s->num_v_slices < 32;
s->num_v_slices++) {
573 for (
s->num_h_slices =
s->num_v_slices;
s->num_h_slices <= 2*
s->num_v_slices;
s->num_h_slices++) {
574 int maxw = (avctx->
width +
s->num_h_slices - 1) /
s->num_h_slices;
575 int maxh = (avctx->
height +
s->num_v_slices - 1) /
s->num_v_slices;
576 if (
s->num_h_slices > max_h_slices ||
s->num_v_slices > max_v_slices)
578 if (maxw * maxh * (
int64_t)(
s->bits_per_raw_sample+1) * plane_count > 8<<24)
580 if (
s->bits_per_raw_sample == 32)
581 if (maxw * maxh > 65536)
592 "Unsupported number %d of slices requested, please specify a "
593 "supported number with -slices (ex:4,6,9,12,16, ...)\n",
605 s->version =
FFMAX(
s->version, 2);
614 s->version =
FFMAX(
s->version, 2);
616 if (avctx->
level <= 0 &&
s->version == 2) {
620 if (avctx->
level <
s->version) {
621 av_log(avctx,
AV_LOG_ERROR,
"Version %d needed for requested features but %d requested\n",
s->version, avctx->
level);
624 s->version = avctx->
level;
628 if (
s->version >= 4) {
630 s->crcref = 0x7a8c4079;
631 }
else if (
s->version >= 3) {
639 s->version =
FFMAX(
s->version, 3);
641 s->version =
FFMAX(
s->version, 4);
644 av_log(avctx,
AV_LOG_ERROR,
"Version 2 or 4 needed for requested features but version 2 or 4 is experimental and not enabled\n");
649 for (
i = 1;
i < 256;
i++)
654 for (
i = 1;
i < 256;
i++)
655 s->state_transition[
i] =
c.one_state[
i];
658 for (
i = 0;
i < 256;
i++) {
659 s->quant_table_count = 2;
660 if ((
s->qtable == -1 &&
s->bits_per_raw_sample <= 8) ||
s->qtable == 1) {
666 s->quant_tables[1][2][
i]= 11*11*
quant5 [
i];
667 s->quant_tables[1][3][
i]= 5*11*11*
quant5 [
i];
668 s->quant_tables[1][4][
i]= 5*5*11*11*
quant5 [
i];
669 s->context_count[0] = (11 * 11 * 11 + 1) / 2;
670 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;
680 s->context_count[0] = (9 * 9 * 9 + 1) / 2;
681 s->context_count[1] = (9 * 9 * 5 * 5 * 5 + 1) / 2;
688 if (!
s->transparency)
690 if (!
s->chroma_planes &&
s->version > 3)
693 s->picture_number = 0;
696 for (
i = 0;
i <
s->quant_table_count;
i++) {
698 sizeof(*
s->rc_stat2[
i]));
714 for (j = 0; j < 256; j++)
715 for (
i = 0;
i < 2;
i++) {
716 s->rc_stat[j][
i] = strtol(p, &next, 0);
719 "2Pass file invalid at %d %d [%s]\n", j,
i, p);
725 for (
i = 0;
i <
s->quant_table_count;
i++)
726 for (j = 0; j <
s->context_count[
i]; j++) {
727 for (k = 0; k < 32; k++)
728 for (m = 0; m < 2; m++) {
729 s->rc_stat2[
i][j][k][m] = strtol(p, &next, 0);
732 "2Pass file invalid at %d %d %d %d [%s]\n",
740 gob_count = strtol(p, &next, 0);
741 if (next == p || gob_count <= 0) {
747 while (*p ==
'\n' || *p ==
' ')
757 for (
i = 0;
i <
s->quant_table_count;
i++) {
758 for (k = 0; k < 32; k++) {
761 for (j = 0; j <
s->context_count[
i]; j++) {
763 if (
s->rc_stat2[
i][j][k][0] +
s->rc_stat2[
i][j][k][1] > 200 && j ||
a+
b > 200) {
765 p = 256.0 *
b / (
a +
b);
766 s->initial_states[
i][jp][k] =
768 for(jp++; jp<j; jp++)
769 s->initial_states[
i][jp][k] =
s->initial_states[
i][jp-1][k];
772 a +=
s->rc_stat2[
i][j][k][0];
773 b +=
s->rc_stat2[
i][j][k][1];
775 p = 256.0 *
b / (
a +
b);
777 s->initial_states[
i][j][k] =
785 if (
s->version <= 1) {
812 s->bits_per_raw_sample = 9;
822 s->bits_per_raw_sample = 10;
831 s->bits_per_raw_sample = 12;
837 s->bits_per_raw_sample = 14;
838 s->packed_at_lsb = 1;
849 s->bits_per_raw_sample = 16;
850 }
else if (!
s->bits_per_raw_sample) {
853 if (
s->bits_per_raw_sample <= 8) {
857 s->version =
FFMAX(
s->version, 1);
869 s->chroma_planes =
desc->nb_components < 3 ? 0 : 1;
873 s->bits_per_raw_sample = 8;
874 else if (!
s->bits_per_raw_sample)
875 s->bits_per_raw_sample = 8;
880 s->chroma_planes = 1;
881 s->bits_per_raw_sample = 8;
886 s->chroma_planes = 1;
887 s->bits_per_raw_sample = 16;
889 s->version =
FFMAX(
s->version, 1);
893 s->chroma_planes = 1;
894 s->bits_per_raw_sample = 16;
896 s->version =
FFMAX(
s->version, 1);
900 s->chroma_planes = 1;
901 s->bits_per_raw_sample = 8;
905 s->bits_per_raw_sample = 9;
909 s->bits_per_raw_sample = 10;
913 s->bits_per_raw_sample = 12;
917 s->bits_per_raw_sample = 14;
923 s->bits_per_raw_sample = 16;
927 s->bits_per_raw_sample = 32;
928 else if (!
s->bits_per_raw_sample)
932 s->chroma_planes = 1;
933 if (
s->bits_per_raw_sample >= 16) {
936 s->version =
FFMAX(
s->version, 1);
945 s->version =
FFMAX(
s->version, 4);
948 if (
s->remap_mode < 0)
949 s->remap_mode =
s->flt ? 2 : 0;
950 if (
s->remap_mode == 0 &&
s->bits_per_raw_sample == 32) {
954 if (
s->remap_mode == 2 &&
955 !((
s->bits_per_raw_sample == 16 ||
s->bits_per_raw_sample == 32 ||
s->bits_per_raw_sample == 64) &&
s->flt)) {
980 if (
s->bits_per_raw_sample > (
s->version > 3 ? 16 : 8) && !
s->remap_mode) {
983 "high bits_per_raw_sample, forcing range coder\n");
993 if (
s->version > 1) {
1003 s->slice_count =
s->max_slice_count;
1005 for (
int j = 0; j <
s->slice_count; j++) {
1008 for (
int i = 0;
i <
s->plane_count;
i++) {
1015 if (
s->remap_mode) {
1016 for (
int p = 0; p < 1 + 2*
s->chroma_planes +
s->transparency ; p++) {
1017 if (
s->bits_per_raw_sample == 32) {
1034 s->slices[j].remap =
s->remap_mode;
1040 #define STATS_OUT_SIZE 1024 * 1024 * 6
1045 for (
int i = 0;
i <
s->quant_table_count;
i++)
1046 for (
int j = 0; j <
s->max_slice_count; j++) {
1070 for (j=0; j<
f->plane_count; j++) {
1080 if (
f->version > 3) {
1094 const uint8_t *
src[3],
const int stride[3],
int w,
int h)
1096 #define NB_Y_COEFF 15
1097 static const int rct_y_coeff[15][2] = {
1117 int x, y,
i, p, best;
1119 int lbd =
f->bits_per_raw_sample <= 8;
1120 int packed = !
src[1];
1121 int transparency =
f->transparency;
1122 int packed_size = (3 + transparency)*2;
1124 for (y = 0; y <
h; y++) {
1125 int lastr=0, lastg=0, lastb=0;
1126 for (p = 0; p < 3; p++)
1129 for (x = 0; x <
w; x++) {
1133 unsigned v = *((
const uint32_t*)(
src[0] + x*4 +
stride[0]*y));
1135 g = (v >> 8) & 0xFF;
1136 r = (v >> 16) & 0xFF;
1137 }
else if (packed) {
1138 const uint16_t *p = ((
const uint16_t*)(
src[0] + x*packed_size +
stride[0]*y));
1142 }
else if (
f->use32bit || transparency) {
1143 g = *((
const uint16_t *)(
src[0] + x*2 +
stride[0]*y));
1144 b = *((
const uint16_t *)(
src[1] + x*2 +
stride[1]*y));
1145 r = *((
const uint16_t *)(
src[2] + x*2 +
stride[2]*y));
1147 b = *((
const uint16_t*)(
src[0] + x*2 +
stride[0]*y));
1148 g = *((
const uint16_t*)(
src[1] + x*2 +
stride[1]*y));
1149 r = *((
const uint16_t*)(
src[2] + x*2 +
stride[2]*y));
1156 int bg = ag -
sample[0][x];
1157 int bb = ab -
sample[1][x];
1158 int br = ar -
sample[2][x];
1164 stat[
i] +=
FFABS(bg + ((br*rct_y_coeff[
i][0] + bb*rct_y_coeff[
i][1])>>2));
1180 if (stat[
i] < stat[best])
1190 int len = 1 <<
f->bits_per_raw_sample;
1193 for (
int p= 0; p < 1 + 2*
f->chroma_planes +
f->transparency; p++) {
1196 uint8_t
state[2][32];
1202 for (
int i= 0;
i<
len;
i++) {
1203 int ri =
i ^ ((
i&0x8000) ? 0 :
flip);
1223 const uint8_t *
src[4],
1227 int transparency =
f->transparency;
1230 for (y = 0; y <
h; y++) {
1231 for (x = 0; x <
w; x++) {
1234 g = *((
const uint32_t *)(
src[0] + x*4 +
stride[0]*y));
1235 b = *((
const uint32_t *)(
src[1] + x*4 +
stride[1]*y));
1236 r = *((
const uint32_t *)(
src[2] + x*4 +
stride[2]*y));
1238 a = *((
const uint32_t *)(
src[3] + x*4 +
stride[3]*y));
1240 if (sc->
remap == 2) {
1241 #define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1266 #define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1275 int p,
int mul_count,
int *mul_tab,
int update,
int final)
1278 uint8_t
state[2][3][32];
1284 int compact_index = -1;
1286 int current_mul_index = -1;
1289 int run1start_last_val;
1290 int run1start_mul_index;
1292 memcpy(mul, mul_tab,
sizeof(*mul_tab)*(mul_count+1));
1297 for (;
i < pixel_num+1;
i++) {
1298 int current_mul = current_mul_index < 0 ? 1 :
FFABS(mul[current_mul_index]);
1300 if (
i == pixel_num) {
1301 if (last_val == 0xFFFFFFFF) {
1304 val = last_val + ((1LL<<32) - last_val + current_mul - 1) / current_mul * current_mul;
1306 val += lu * current_mul;
1311 if (last_val !=
val) {
1324 run1start_i =
i - 1;
1325 run1start_last_val = last_val;
1326 run1start_mul_index= current_mul_index;
1340 last_val += current_mul;
1344 last_val = run1start_last_val;
1345 current_mul_index = run1start_mul_index;
1357 if (current_mul > 1)
1365 current_mul_index = ((last_val + 1) * mul_count) >> 32;
1366 if (!
run || run1final) {
1368 if (mul[ current_mul_index ] < 0) {
1370 mul[ current_mul_index ] *= -1;
1376 if (!
run || run1final)
1377 if (
final &&
i < pixel_num)
1388 const uint8_t *
src[4])
1391 const int max_log2_mul_count = ((
int[]){ 1, 1, 1, 9, 9, 10})[
f->remap_optimizer];
1392 const int log2_mul_count_step = ((
int[]){ 1, 1, 1, 9, 9, 1})[
f->remap_optimizer];
1393 const int max_log2_mul = ((
int[]){ 1, 8, 8, 9, 22, 22})[
f->remap_optimizer];
1394 const int log2_mul_step = ((
int[]){ 1, 8, 1, 1, 1, 1})[
f->remap_optimizer];
1395 const int bruteforce_count = ((
int[]){ 0, 0, 0, 1, 1, 1})[
f->remap_optimizer];
1396 const int stair_mode = ((
int[]){ 0, 0, 0, 1, 0, 0})[
f->remap_optimizer];
1397 const int magic_log2 = ((
int[]){ 1, 1, 1, 1, 0, 0})[
f->remap_optimizer];
1401 for (
int p= 0; p < 1 + 2*
f->chroma_planes +
f->transparency; p++) {
1402 int best_log2_mul_count = 0;
1403 float score_sum[11] = {0};
1404 int mul_all[11][1025];
1406 for (
int log2_mul_count= 0; log2_mul_count <= max_log2_mul_count; log2_mul_count += log2_mul_count_step) {
1407 float score_tab_all[1025][23] = {0};
1409 int *mul_tab = mul_all[log2_mul_count];
1410 int last_mul_index = -1;
1411 int mul_count = 1 << log2_mul_count;
1413 score_sum[log2_mul_count] = 2 * log2_mul_count;
1415 score_sum[log2_mul_count] =
av_float2int((
float)mul_count * mul_count);
1416 for (
int i= 0;
i<pixel_num;
i++) {
1418 int mul_index = (
val + 1LL)*mul_count >> 32;
1419 if (
val != last_val) {
1420 float *score_tab = score_tab_all[(last_val + 1LL)*mul_count >> 32];
1422 for(
int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1429 }
else if (stair_mode && mul_count == 512 && si == max_log2_mul ) {
1430 if (mul_index >= 0x378/8 && mul_index <= 23 + 0x378/8) {
1431 mul = (0x800080 >> (mul_index - 0x378/8));
1435 mul = (0x10001LL)<<si >> 16;
1447 if (mul_index != last_mul_index)
1452 score_tab[si] +=
log2f(score);
1456 last_mul_index = mul_index;
1458 for(
int i= 0;
i<mul_count;
i++) {
1460 float *score_tab = score_tab_all[
i];
1461 for(
int si= 0; si <= max_log2_mul; si += log2_mul_step) {
1462 if (score_tab[si] < score_tab[ best_index ])
1465 if (stair_mode && mul_count == 512 && best_index == max_log2_mul ) {
1466 if (
i >= 0x378/8 &&
i <= 23 + 0x378/8) {
1467 mul_tab[
i] = -(0x800080 >> (
i - 0x378/8));
1471 mul_tab[
i] = -((0x10001LL)<<best_index >> 16);
1472 score_sum[log2_mul_count] += score_tab[ best_index ];
1474 mul_tab[mul_count] = 1;
1476 if (bruteforce_count)
1479 if (score_sum[log2_mul_count] < score_sum[best_log2_mul_count])
1480 best_log2_mul_count = log2_mul_count;
1488 const uint8_t *
src[4],
1489 int w,
int h,
const int stride[4],
int ac)
1492 const int ring_size =
f->context_model ? 3 : 2;
1497 int transparency =
f->transparency;
1504 for (y = 0; y <
h; y++) {
1509 for (x = 0; x <
w; x++) {
1530 for (p = 0; p < 3 + transparency; p++) {
1534 ret = encode_line32(
f, sc,
f->avctx,
w,
sample[p], (p + 1) / 2,
1552 const AVFrame *
const p =
f->cur_enc_frame;
1565 if (
f->version > 3 &&
f->colorspace == 1) {
1575 if (
f->version > 2) {
1583 if (
f->bits_per_raw_sample != 32) {
1585 const int cx = x >>
f->chroma_h_shift;
1586 const int cy = y >>
f->chroma_v_shift;
1593 if (
f->chroma_planes) {
1597 if (
f->transparency)
1602 }
else if (
f->use32bit) {
1622 const int cx = x >>
f->chroma_h_shift;
1623 const int cy = y >>
f->chroma_v_shift;
1627 if (
f->chroma_planes) {
1631 if (
f->transparency)
1636 }
else if (
f->bits_per_raw_sample == 32) {
1638 }
else if (
f->use32bit) {
1653 if (
f->version < 4) {
1671 size_t maxsize = avctx->
width*avctx->
height * (1 +
f->transparency);
1672 if (
f->chroma_planes)
1674 maxsize +=
f->slice_count * 800;
1675 if (
f->version > 3) {
1676 maxsize *=
f->bits_per_raw_sample + 1;
1678 maxsize +=
f->slice_count * 70000 * (1 + 2*
f->chroma_planes +
f->transparency);
1680 maxsize +=
f->slice_count * 2 * (avctx->
width + avctx->
height);
1681 maxsize *= 8*(2*
f->bits_per_raw_sample + 5);
1690 const AVFrame *pict,
int *got_packet)
1694 uint8_t keystate = 128;
1705 memset(
f->rc_stat, 0,
sizeof(
f->rc_stat));
1706 for (
i = 0;
i <
f->quant_table_count;
i++)
1707 memset(
f->rc_stat2[
i], 0,
f->context_count[
i] *
sizeof(*
f->rc_stat2[
i]));
1710 for (j = 0; j <
f->slice_count; j++) {
1712 for (
i = 0;
i < 256;
i++) {
1716 for (
i = 0;
i <
f->quant_table_count;
i++) {
1717 for (k = 0; k <
f->context_count[
i]; k++)
1718 for (m = 0; m < 32; m++) {
1719 f->rc_stat2[
i][k][m][0] += sc->
rc_stat2[
i][k][m][0];
1720 f->rc_stat2[
i][k][m][1] += sc->
rc_stat2[
i][k][m][1];
1725 for (j = 0; j < 256; j++) {
1726 snprintf(p, end - p,
"%" PRIu64
" %" PRIu64
" ",
1727 f->rc_stat[j][0],
f->rc_stat[j][1]);
1732 for (
i = 0;
i <
f->quant_table_count;
i++) {
1733 for (j = 0; j <
f->context_count[
i]; j++)
1734 for (m = 0; m < 32; m++) {
1735 snprintf(p, end - p,
"%" PRIu64
" %" PRIu64
" ",
1736 f->rc_stat2[
i][j][m][0],
f->rc_stat2[
i][j][m][1]);
1740 snprintf(p, end - p,
"%d\n",
f->gob_count);
1749 av_log(avctx,
AV_LOG_WARNING,
"Cannot allocate worst case packet size, the encoding could fail\n");
1759 f->cur_enc_frame = pict;
1773 for (
i = 1;
i < 256;
i++) {
1774 c->one_state[
i] =
f->state_transition[
i];
1775 c->zero_state[256 -
i] = 256 -
c->one_state[
i];
1779 for (
i = 0;
i <
f->slice_count;
i++) {
1792 f->slice_count,
sizeof(*
f->slices));
1795 for (
i = 0;
i <
f->slice_count;
i++) {
1798 if (
i > 0 ||
f->version > 2) {
1802 AV_WB24(buf_p + bytes, bytes);
1818 f->picture_number++;
1830 for (
int j = 0; j <
s->max_slice_count; j++) {
1833 for(
int p = 0; p<4; p++) {
1845 #define OFFSET(x) offsetof(FFV1Context, x)
1846 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1850 { .i64 = 0 }, -2, 2,
VE, .unit =
"coder" },
1857 {
"ac",
"Range with custom table (the ac option exists for compatibility and is deprecated)", 0,
AV_OPT_TYPE_CONST,
1858 { .i64 = 1 }, INT_MIN, INT_MAX,
VE, .unit =
"coder" },
1860 { .i64 = 0 }, 0, 1,
VE },
1862 { .i64 = -1 }, -1, 2,
VE , .unit =
"qtable"},
1866 { .i64 =
QTABLE_8BIT }, INT_MIN, INT_MAX,
VE, .unit =
"qtable" },
1869 {
"remap_mode",
"Remap Mode",
OFFSET(remap_mode),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2,
VE, .unit =
"remap_mode" },
1871 { .i64 = -1 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1873 { .i64 = 0 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1875 { .i64 = 1 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1877 { .i64 = 2 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1878 {
"remap_optimizer",
"Remap Optimizer",
OFFSET(remap_optimizer),
AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 5,
VE, .unit =
"remap_optimizer" },