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,
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++) {
1006 for (
int i = 0;
i <
s->plane_count;
i++) {
1015 s->slices[j].remap =
s->remap_mode;
1021 #define STATS_OUT_SIZE 1024 * 1024 * 6
1026 for (
int i = 0;
i <
s->quant_table_count;
i++)
1027 for (
int j = 0; j <
s->max_slice_count; j++) {
1051 for (j=0; j<
f->plane_count; j++) {
1061 if (
f->version > 3) {
1075 const uint8_t *
src[3],
const int stride[3],
int w,
int h)
1077 #define NB_Y_COEFF 15
1078 static const int rct_y_coeff[15][2] = {
1098 int x, y,
i, p, best;
1100 int lbd =
f->bits_per_raw_sample <= 8;
1101 int packed = !
src[1];
1102 int transparency =
f->transparency;
1103 int packed_size = (3 + transparency)*2;
1105 for (y = 0; y <
h; y++) {
1106 int lastr=0, lastg=0, lastb=0;
1107 for (p = 0; p < 3; p++)
1110 for (x = 0; x <
w; x++) {
1114 unsigned v = *((
const uint32_t*)(
src[0] + x*4 +
stride[0]*y));
1116 g = (v >> 8) & 0xFF;
1117 r = (v >> 16) & 0xFF;
1118 }
else if (packed) {
1119 const uint16_t *p = ((
const uint16_t*)(
src[0] + x*packed_size +
stride[0]*y));
1123 }
else if (
f->use32bit || transparency) {
1124 g = *((
const uint16_t *)(
src[0] + x*2 +
stride[0]*y));
1125 b = *((
const uint16_t *)(
src[1] + x*2 +
stride[1]*y));
1126 r = *((
const uint16_t *)(
src[2] + x*2 +
stride[2]*y));
1128 b = *((
const uint16_t*)(
src[0] + x*2 +
stride[0]*y));
1129 g = *((
const uint16_t*)(
src[1] + x*2 +
stride[1]*y));
1130 r = *((
const uint16_t*)(
src[2] + x*2 +
stride[2]*y));
1137 int bg = ag -
sample[0][x];
1138 int bb = ab -
sample[1][x];
1139 int br = ar -
sample[2][x];
1145 stat[
i] +=
FFABS(bg + ((br*rct_y_coeff[
i][0] + bb*rct_y_coeff[
i][1])>>2));
1161 if (stat[
i] < stat[best])
1171 int len = 1 <<
f->bits_per_raw_sample;
1174 for (
int p= 0; p < 1 + 2*
f->chroma_planes +
f->transparency; p++) {
1177 uint8_t
state[2][32];
1183 for (
int i= 0;
i<
len;
i++) {
1184 int ri =
i ^ ((
i&0x8000) ? 0 :
flip);
1204 const uint8_t *
src[4],
1208 int transparency =
f->transparency;
1211 for (y = 0; y <
h; y++) {
1212 for (x = 0; x <
w; x++) {
1215 g = *((
const uint32_t *)(
src[0] + x*4 +
stride[0]*y));
1216 b = *((
const uint32_t *)(
src[1] + x*4 +
stride[1]*y));
1217 r = *((
const uint32_t *)(
src[2] + x*4 +
stride[2]*y));
1219 a = *((
const uint32_t *)(
src[3] + x*4 +
stride[3]*y));
1221 if (sc->
remap == 2) {
1222 #define FLIP(f) (((f)&0x80000000) ? (f) : (f)^0x7FFFFFFF);
1247 #define CMP(A,B) ((A)->val - (int64_t)(B)->val)
1277 memcpy(
dst->mul,
src->mul, (
src->mul_count + 1) *
sizeof(
src->mul[0]));
1278 memcpy(
dst->state,
src->state,
sizeof(
dst->state));
1281 dst->last_val =
src->last_val;
1282 dst->compact_index =
src->compact_index;
1283 dst->mul_count =
src->mul_count;
1285 dst->pixel_num =
src->pixel_num;
1287 dst->current_mul_index =
src->current_mul_index;
1288 dst->run1final =
src->run1final;
1289 dst->run1start_i =
src->run1start_i;
1290 dst->run1start_last_val =
src->run1start_last_val;
1291 dst->run1start_mul_index =
src->run1start_mul_index;
1302 memset(
s.state, 128,
sizeof(
s.state));
1304 memset(
s.state, 128,
sizeof(
s.state));
1306 s.compact_index = -1;
1309 s.current_mul_index = -1;
1313 for (;
s.i <
s.pixel_num+1;
s.i++) {
1314 int current_mul =
s.current_mul_index < 0 ? 1 :
FFABS(
s.mul[
s.current_mul_index]);
1316 if (
s.i ==
s.pixel_num) {
1317 if (
s.last_val == 0xFFFFFFFF) {
1320 val =
s.last_val + ((1LL<<32) -
s.last_val + current_mul - 1) / current_mul * current_mul;
1322 val +=
s.lu * current_mul;
1327 if (
s.last_val !=
val) {
1340 s.run1start_i =
s.i - 1;
1341 s.run1start_last_val =
s.last_val;
1342 s.run1start_mul_index=
s.current_mul_index;
1356 s.last_val += current_mul;
1359 s.i =
s.run1start_i;
1360 s.last_val =
s.run1start_last_val;
1361 s.current_mul_index =
s.run1start_mul_index;
1373 if (current_mul > 1)
1381 s.current_mul_index = ((
s.last_val + 1) *
s.mul_count) >> 32;
1382 if (!
s.run ||
s.run1final) {
1384 if (
s.mul[
s.current_mul_index ] < 0) {
1386 s.mul[
s.current_mul_index ] *= -1;
1392 if (!
s.run ||
s.run1final)
1393 if (
final &&
s.i <
s.pixel_num)
1404 const uint8_t *
src[4])
1411 for (
int p= 0; p < 1 + 2*
f->chroma_planes +
f->transparency; p++) {
1412 float score_tab[16] = {0};
1419 for(
int v = 0; v< 512; v++) {
1420 if (v >= 0x378/8 && v <= 23 + 0x378/8) {
1421 s.mul[v] = -(0x800080 >> (v - 0x378/8));
1425 for (
int i= 0;
i<
s.pixel_num;
i++) {
1427 if (
val != last_val) {
1437 mul = -
s.mul[ (last_val + 1) >> (32-9) ];
1448 if (score_tab[si] < score_tab[ best_index ])
1452 s.mul[0] = -1 << best_index;
1457 s.mul[
s.mul_count] = 1;
1466 const uint8_t *
src[4],
1467 int w,
int h,
const int stride[4],
int ac)
1470 const int ring_size =
f->context_model ? 3 : 2;
1475 int transparency =
f->transparency;
1482 for (y = 0; y <
h; y++) {
1487 for (x = 0; x <
w; x++) {
1508 for (p = 0; p < 3 + transparency; p++) {
1512 ret = encode_line32(
f, sc,
f->avctx,
w,
sample[p], (p + 1) / 2,
1530 const AVFrame *
const p =
f->cur_enc_frame;
1543 if (
f->version > 3 &&
f->colorspace == 1) {
1553 if (
f->version > 2) {
1561 if (
f->bits_per_raw_sample != 32) {
1563 const int cx = x >>
f->chroma_h_shift;
1564 const int cy = y >>
f->chroma_v_shift;
1571 if (
f->chroma_planes) {
1575 if (
f->transparency)
1580 }
else if (
f->use32bit) {
1600 const int cx = x >>
f->chroma_h_shift;
1601 const int cy = y >>
f->chroma_v_shift;
1605 if (
f->chroma_planes) {
1609 if (
f->transparency)
1614 }
else if (
f->bits_per_raw_sample == 32) {
1616 }
else if (
f->use32bit) {
1631 if (
f->version < 4) {
1649 size_t maxsize = avctx->
width*avctx->
height * (1 +
f->transparency);
1650 if (
f->chroma_planes)
1652 maxsize +=
f->slice_count * 800;
1653 if (
f->version > 3) {
1654 maxsize *=
f->bits_per_raw_sample + 1;
1656 maxsize +=
f->slice_count * 70000 * (1 + 2*
f->chroma_planes +
f->transparency);
1658 maxsize +=
f->slice_count * 2 * (avctx->
width + avctx->
height);
1659 maxsize *= 8*(2*
f->bits_per_raw_sample + 5);
1668 const AVFrame *pict,
int *got_packet)
1672 uint8_t keystate = 128;
1683 memset(
f->rc_stat, 0,
sizeof(
f->rc_stat));
1684 for (
i = 0;
i <
f->quant_table_count;
i++)
1685 memset(
f->rc_stat2[
i], 0,
f->context_count[
i] *
sizeof(*
f->rc_stat2[
i]));
1688 for (j = 0; j <
f->slice_count; j++) {
1690 for (
i = 0;
i < 256;
i++) {
1694 for (
i = 0;
i <
f->quant_table_count;
i++) {
1695 for (k = 0; k <
f->context_count[
i]; k++)
1696 for (m = 0; m < 32; m++) {
1697 f->rc_stat2[
i][k][m][0] += sc->
rc_stat2[
i][k][m][0];
1698 f->rc_stat2[
i][k][m][1] += sc->
rc_stat2[
i][k][m][1];
1703 for (j = 0; j < 256; j++) {
1704 snprintf(p, end - p,
"%" PRIu64
" %" PRIu64
" ",
1705 f->rc_stat[j][0],
f->rc_stat[j][1]);
1710 for (
i = 0;
i <
f->quant_table_count;
i++) {
1711 for (j = 0; j <
f->context_count[
i]; j++)
1712 for (m = 0; m < 32; m++) {
1713 snprintf(p, end - p,
"%" PRIu64
" %" PRIu64
" ",
1714 f->rc_stat2[
i][j][m][0],
f->rc_stat2[
i][j][m][1]);
1718 snprintf(p, end - p,
"%d\n",
f->gob_count);
1727 av_log(avctx,
AV_LOG_WARNING,
"Cannot allocate worst case packet size, the encoding could fail\n");
1737 f->cur_enc_frame = pict;
1751 for (
i = 1;
i < 256;
i++) {
1752 c->one_state[
i] =
f->state_transition[
i];
1753 c->zero_state[256 -
i] = 256 -
c->one_state[
i];
1757 for (
i = 0;
i <
f->slice_count;
i++) {
1770 f->slice_count,
sizeof(*
f->slices));
1773 for (
i = 0;
i <
f->slice_count;
i++) {
1776 if (
i > 0 ||
f->version > 2) {
1780 AV_WB24(buf_p + bytes, bytes);
1796 f->picture_number++;
1814 #define OFFSET(x) offsetof(FFV1Context, x)
1815 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1819 { .i64 = 0 }, -2, 2,
VE, .unit =
"coder" },
1826 {
"ac",
"Range with custom table (the ac option exists for compatibility and is deprecated)", 0,
AV_OPT_TYPE_CONST,
1827 { .i64 = 1 }, INT_MIN, INT_MAX,
VE, .unit =
"coder" },
1829 { .i64 = 0 }, 0, 1,
VE },
1831 { .i64 = -1 }, -1, 2,
VE , .unit =
"qtable"},
1835 { .i64 =
QTABLE_8BIT }, INT_MIN, INT_MAX,
VE, .unit =
"qtable" },
1838 {
"remap_mode",
"Remap Mode",
OFFSET(remap_mode),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2,
VE, .unit =
"remap_mode" },
1840 { .i64 = -1 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1842 { .i64 = 0 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1844 { .i64 = 1 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },
1846 { .i64 = 2 }, INT_MIN, INT_MAX,
VE, .unit =
"remap_mode" },