78 #define NMSEDEC_BITS 7
79 #define NMSEDEC_FRACBITS (NMSEDEC_BITS-1)
80 #define WMSEDEC_SHIFT 13
81 #define LAMBDA_SCALE (100000000LL << (WMSEDEC_SHIFT - 13))
92 {{10000, 19650, 41770, 84030, 169000, 338400, 676900, 1353000, 2706000, 5409000},
93 {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},
94 {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},
95 {20800, 38650, 83070, 171800, 347100, 695900, 1393000, 2786000, 5572000}},
97 {{10000, 15000, 27500, 53750, 106800, 213400, 426700, 853300, 1707000, 3413000},
98 {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},
99 {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},
100 { 7186, 9218, 15860, 30430, 60190, 120100, 240000, 479700, 959300}}
132 int layer_rates[100];
150 static void nspaces(FILE *fd,
int n)
152 while(n--) putc(
' ', fd);
164 int tileno, compno, reslevelno, bandno, precno;
165 fprintf(fd,
"XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"
166 "numXtiles = %d, numYtiles = %d, ncomponents = %d\n"
168 s->width,
s->height,
s->tile_width,
s->tile_height,
169 s->numXtiles,
s->numYtiles,
s->ncomponents);
170 for (tileno = 0; tileno <
s->numXtiles *
s->numYtiles; tileno++){
173 fprintf(fd,
"tile %d:\n", tileno);
174 for(compno = 0; compno <
s->ncomponents; compno++){
177 fprintf(fd,
"component %d:\n", compno);
179 fprintf(fd,
"x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",
181 for(reslevelno = 0; reslevelno <
s->nreslevels; reslevelno++){
184 fprintf(fd,
"reslevel %d:\n", reslevelno);
186 fprintf(fd,
"x0 = %d, x1 = %d, y0 = %d, y1 = %d, nbands = %d\n",
187 reslevel->x0, reslevel->x1, reslevel->y0,
188 reslevel->y1, reslevel->
nbands);
189 for(bandno = 0; bandno < reslevel->
nbands; bandno++){
192 fprintf(fd,
"band %d:\n", bandno);
194 fprintf(fd,
"x0 = %d, x1 = %d, y0 = %d, y1 = %d,"
195 "codeblock_width = %d, codeblock_height = %d cblknx = %d cblkny = %d\n",
198 band->codeblock_width, band->codeblock_height,
199 band->cblknx, band->cblkny);
203 fprintf(fd,
"prec %d:\n", precno);
205 fprintf(fd,
"xi0 = %d, xi1 = %d, yi0 = %d, yi1 = %d\n",
206 prec->xi0, prec->xi1, prec->yi0, prec->yi1);
221 if (
s->bit_index == 8)
223 s->bit_index = *
s->buf == 0xff;
226 *
s->buf |=
val << (7 -
s->bit_index++);
252 int sp = -1, curval = 0;
266 if (node->
val >= threshold) {
302 if (
s->buf_end -
s->buf < 40 + 3 *
s->ncomponents)
306 bytestream_put_be16(&
s->buf, 38 + 3 *
s->ncomponents);
307 bytestream_put_be16(&
s->buf, 0);
308 bytestream_put_be32(&
s->buf,
s->width);
309 bytestream_put_be32(&
s->buf,
s->height);
310 bytestream_put_be32(&
s->buf, 0);
311 bytestream_put_be32(&
s->buf, 0);
313 bytestream_put_be32(&
s->buf,
s->tile_width);
314 bytestream_put_be32(&
s->buf,
s->tile_height);
315 bytestream_put_be32(&
s->buf, 0);
316 bytestream_put_be32(&
s->buf, 0);
317 bytestream_put_be16(&
s->buf,
s->ncomponents);
319 for (
i = 0;
i <
s->ncomponents;
i++){
320 bytestream_put_byte(&
s->buf,
s->cbps[
i] - 1);
321 bytestream_put_byte(&
s->buf,
i?1<<
s->chroma_shift[0]:1);
322 bytestream_put_byte(&
s->buf,
i?1<<
s->chroma_shift[1]:1);
332 if (
s->buf_end -
s->buf < 14)
336 bytestream_put_be16(&
s->buf, 12);
341 bytestream_put_byte(&
s->buf, scod);
343 bytestream_put_byte(&
s->buf,
s->prog);
344 bytestream_put_be16(&
s->buf,
s->nlayers);
346 bytestream_put_byte(&
s->buf, 0);
348 bytestream_put_byte(&
s->buf, 0);
351 bytestream_put_byte(&
s->buf, codsty->
nreslevels - 1);
354 bytestream_put_byte(&
s->buf, 0);
370 if (
s->buf_end -
s->buf <
size + 2)
374 bytestream_put_be16(&
s->buf,
size);
378 bytestream_put_byte(&
s->buf, qntsty->
expn[
i] << 3);
381 bytestream_put_be16(&
s->buf, (qntsty->
expn[
i] << 11) | qntsty->
mant[
i]);
392 if (
s->buf_end -
s->buf <
size + 2)
396 bytestream_put_be16(&
s->buf,
size);
397 bytestream_put_be16(&
s->buf, 1);
408 if (
s->buf_end -
s->buf < 12)
412 bytestream_put_be16(&
s->buf, 10);
413 bytestream_put_be16(&
s->buf, tileno);
416 bytestream_put_be32(&
s->buf, 0);
418 bytestream_put_byte(&
s->buf, 0);
419 bytestream_put_byte(&
s->buf, 1);
427 for (
i = 0;
i <
s->numYtiles;
i++) {
428 for (j = 0; j <
s->numXtiles; j++) {
430 for (compno = 0; compno <
s->ncomponents; compno++) {
433 int scale = (compno?1 <<
s->chroma_shift[0]:1) * (compno?1 <<
s->chroma_shift[1]:1);
434 for (layno = 0; layno <
s->nlayers; layno++) {
435 if (
s->layer_rates[layno] > 0) {
436 tile->
layer_rates[layno] += (double)(tilew * tileh) *
s->ncomponents *
s->cbps[compno] /
437 (double)(
s->layer_rates[layno] * 8 * scale);
455 int tileno, tilex, tiley, compno;
465 for (tileno = 0, tiley = 0; tiley <
s->numYtiles; tiley++)
466 for (tilex = 0; tilex <
s->numXtiles; tilex++, tileno++){
477 for (compno = 0; compno <
s->ncomponents; compno++){
481 comp->coord[0][0] =
comp->coord_o[0][0] = tilex *
s->tile_width;
482 comp->coord[0][1] =
comp->coord_o[0][1] =
FFMIN((tilex+1)*
s->tile_width,
s->width);
483 comp->coord[1][0] =
comp->coord_o[1][0] = tiley *
s->tile_height;
484 comp->coord[1][1] =
comp->coord_o[1][1] =
FFMIN((tiley+1)*
s->tile_height,
s->height);
486 for (
i = 0;
i < 2;
i++)
487 for (j = 0; j < 2; j++)
494 compno?1<<
s->chroma_shift[0]:1,
495 compno?1<<
s->chroma_shift[1]:1,
505 #define COPY_FRAME(D, PIXEL) \
506 static void copy_frame_ ##D(Jpeg2000EncoderContext *s) \
508 int tileno, compno, i, y, x; \
510 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){ \
511 Jpeg2000Tile *tile = s->tile + tileno; \
513 for (compno = 0; compno < s->ncomponents; compno++){ \
514 Jpeg2000Component *comp = tile->comp + compno; \
515 int *dst = comp->i_data; \
516 int cbps = s->cbps[compno]; \
517 line = (PIXEL*)s->picture->data[compno] \
518 + comp->coord[1][0] * (s->picture->linesize[compno] / sizeof(PIXEL)) \
519 + comp->coord[0][0]; \
520 for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){ \
522 for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++) \
523 *dst++ = *ptr++ - (1 << (cbps - 1)); \
524 line += s->picture->linesize[compno] / sizeof(PIXEL); \
528 line = (PIXEL*)s->picture->data[0] + tile->comp[0].coord[1][0] * (s->picture->linesize[0] / sizeof(PIXEL)) \
529 + tile->comp[0].coord[0][0] * s->ncomponents; \
532 for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){ \
534 for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){ \
535 for (compno = 0; compno < s->ncomponents; compno++){ \
536 int cbps = s->cbps[compno]; \
537 tile->comp[compno].i_data[i] = *ptr++ - (1 << (cbps - 1)); \
540 line += s->picture->linesize[0] / sizeof(PIXEL); \
551 int compno, reslevelno, bandno;
555 for (compno = 0; compno <
s->ncomponents; compno++){
557 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++){
559 nbands = reslevelno ? 3 : 1;
560 for (bandno = 0; bandno < nbands; bandno++, gbandno++){
564 int bandpos = bandno + (reslevelno>0),
567 mant = (11 - log < 0 ? ss >> log - 11 :
ss << 11 - log) & 0x7ff;
568 expn =
s->cbps[compno] - log + 13;
570 expn = ((bandno&2)>>1) + (reslevelno>0) +
s->cbps[compno];
572 qntsty->
expn[gbandno] = expn;
573 qntsty->
mant[gbandno] = mant;
590 (1 << 13) - (
a *
a << 11), 0);
614 for (y0 = 0; y0 <
height; y0 += 4)
615 for (x = 0; x <
width; x++)
616 for (y = y0; y <
height && y < y0+4; y++){
619 bit =
t1->data[(y) *
t1->stride + x] &
mask ? 1 : 0;
624 ff_mqc_encode(&
t1->mqc,
t1->mqc.cx_states + ctxno, (
t1->flags[(y+1) *
t1->stride + x+1] >> 15) ^ xorbit);
636 for (y0 = 0; y0 <
height; y0 += 4)
637 for (x = 0; x <
width; x++)
638 for (y = y0; y <
height && y < y0+4; y++)
650 for (y0 = 0; y0 <
height; y0 += 4)
651 for (x = 0; x <
width; x++){
660 for (rlen = 0; rlen < 4; rlen++)
661 if (
t1->data[(y0+rlen) *
t1->stride + x] &
mask)
668 for (y = y0 + rlen; y < y0 + 4; y++){
673 if (
t1->data[(y) *
t1->stride + x] &
mask){
677 ff_mqc_encode(&
t1->mqc,
t1->mqc.cx_states + ctxno, (
t1->flags[(y+1) *
t1->stride + x+1] >> 15) ^ xorbit);
684 for (y = y0; y < y0 + 4 && y <
height; y++){
688 if (
t1->data[(y) *
t1->stride + x] &
mask){
692 ff_mqc_encode(&
t1->mqc,
t1->mqc.cx_states + ctxno, (
t1->flags[(y+1) *
t1->stride + x+1] >> 15) ^ xorbit);
705 int pass_t = 2, passno, x, y,
max=0, nmsedec, bpno;
708 memset(
t1->flags, 0,
t1->stride * (
height + 2) *
sizeof(*
t1->flags));
710 for (y = 0; y <
height; y++){
711 for (x = 0; x <
width; x++){
712 if (
t1->data[(y) *
t1->stride + x] < 0){
714 t1->data[(y) *
t1->stride + x] = -
t1->data[(y) *
t1->stride + x];
730 for (passno = 0; bpno >= 0; passno++){
745 wmsedec += (
int64_t)nmsedec << (2*bpno);
780 int precno,
uint8_t *expn,
int numgbits,
int packetno,
783 int bandno, empty = 1;
791 bytestream_put_be16(&
s->buf, 4);
792 bytestream_put_be16(&
s->buf, packetno);
797 for (bandno = 0; bandno < rlevel->
nbands; bandno++) {
812 for (
i = 0;
i < nlayers;
i++) {
827 for (bandno = 0; bandno < rlevel->
nbands; bandno++){
854 for (bandno = 0; bandno < rlevel->
nbands; bandno++) {
866 int llen = 0, length;
869 if (
s->buf_end -
s->buf < 20)
912 for (bandno = 0; bandno < rlevel->
nbands; bandno++) {
918 for (
xi = 0;
xi < cblknw;
xi++){
937 int compno, reslevelno, layno, ret;
943 int tile_coord[2][2];
944 int col = tileno %
s->numXtiles;
945 int row = tileno /
s->numXtiles;
947 tile_coord[0][0] = col *
s->tile_width;
948 tile_coord[0][1] =
FFMIN(tile_coord[0][0] +
s->tile_width,
s->width);
949 tile_coord[1][0] = row *
s->tile_height;
950 tile_coord[1][1] =
FFMIN(tile_coord[1][0] +
s->tile_height,
s->height);
956 for (layno = 0; layno < nlayers; layno++) {
957 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++){
958 for (compno = 0; compno <
s->ncomponents; compno++){
962 if ((ret =
encode_packet(
s, reslevel, layno, precno, qntsty->
expn + (reslevelno ? 3*reslevelno-2 : 0),
963 qntsty->
nguardbits, packetno++, nlayers)) < 0)
971 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++){
972 for (layno = 0; layno < nlayers; layno++) {
973 for (compno = 0; compno <
s->ncomponents; compno++){
977 if ((ret =
encode_packet(
s, reslevel, layno, precno, qntsty->
expn + (reslevelno ? 3*reslevelno-2 : 0),
978 qntsty->
nguardbits, packetno++, nlayers)) < 0)
986 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++) {
990 for (compno = 0; compno <
s->ncomponents; compno++) {
992 if (reslevelno < codsty->nreslevels) {
1002 for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1003 for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1004 for (compno = 0; compno <
s->ncomponents; compno++) {
1008 int log_subsampling[2] = { compno?
s->chroma_shift[0]:0, compno?
s->chroma_shift[1]:0};
1009 unsigned prcx, prcy;
1015 if (!(y % ((uint64_t)1 << (reslevel->
log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1016 (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->
log2_prec_height)))))
1019 if (!(x % ((uint64_t)1 << (reslevel->
log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1020 (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->
log2_prec_width)))))
1035 for (layno = 0; layno < nlayers; layno++) {
1036 if ((ret =
encode_packet(
s, reslevel, layno, precno, qntsty->
expn + (reslevelno ? 3*reslevelno-2 : 0),
1037 qntsty->
nguardbits, packetno++, nlayers)) < 0)
1048 for (compno = 0; compno <
s->ncomponents; compno++) {
1051 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++) {
1058 if (step_x >= 31 || step_y >= 31){
1065 for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1066 for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1067 for (compno = 0; compno <
s->ncomponents; compno++) {
1069 int log_subsampling[2] = { compno?
s->chroma_shift[0]:0, compno?
s->chroma_shift[1]:0};
1071 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++) {
1072 unsigned prcx, prcy;
1081 if (!(y % ((uint64_t)1 << (reslevel->
log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1082 (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->
log2_prec_height)))))
1085 if (!(x % ((uint64_t)1 << (reslevel->
log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1086 (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->
log2_prec_width)))))
1102 for (layno = 0; layno < nlayers; layno++) {
1103 if ((ret =
encode_packet(
s, reslevel, layno, precno, qntsty->
expn + (reslevelno ? 3*reslevelno-2 : 0),
1104 qntsty->
nguardbits, packetno++, nlayers)) < 0)
1113 for (compno = 0; compno <
s->ncomponents; compno++) {
1115 int log_subsampling[2] = { compno?
s->chroma_shift[0]:0, compno?
s->chroma_shift[1]:0};
1119 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++) {
1125 if (step_x >= 31 || step_y >= 31){
1132 for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1133 for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1134 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++) {
1135 unsigned prcx, prcy;
1144 if (!(y % ((uint64_t)1 << (reslevel->
log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1145 (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->
log2_prec_height)))))
1148 if (!(x % ((uint64_t)1 << (reslevel->
log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1149 (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->
log2_prec_width)))))
1165 for (layno = 0; layno < nlayers; layno++) {
1166 if ((ret =
encode_packet(
s, reslevel, layno, precno, qntsty->
expn + (reslevelno ? 3*reslevelno-2 : 0),
1167 qntsty->
nguardbits, packetno++, nlayers)) < 0)
1183 int compno, resno, bandno, precno, cblkno;
1186 for (compno = 0; compno <
s->ncomponents; compno++) {
1189 for (resno = 0; resno <
s->codsty.nreslevels; resno++) {
1193 for (bandno = 0; bandno < reslevel->
nbands ; bandno++){
1211 for (passno = cblk->
ninclpasses; passno < cblk->npasses; passno++) {
1231 if (thresh - (dd / dr) < DBL_EPSILON)
1266 int precno, compno, reslevelno, bandno, cblkno,
lev, passno, layno;
1268 double min = DBL_MAX;
1275 for (compno = 0; compno <
s->ncomponents; compno++){
1278 for (reslevelno = 0,
lev = codsty->
nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++,
lev--){
1282 for (bandno = 0; bandno < reslevel->
nbands ; bandno++){
1288 for (passno = 0; passno < cblk->
npasses; passno++) {
1293 tile_disto +=
pass->disto;
1318 for (layno = 0; layno <
s->nlayers; layno++) {
1321 double stable_thresh = 0.0;
1322 double good_thresh = 0.0;
1323 if (!
s->layer_rates[layno]) {
1326 for (
i = 0;
i < 128;
i++) {
1329 thresh = (lo + hi) / 2;
1332 memset(stream_pos, 0,
s->buf - stream_pos);
1335 s->buf = stream_pos;
1339 stable_thresh = thresh;
1340 s->buf = stream_pos;
1343 if (good_thresh >= 0.0)
1344 good_thresh = stable_thresh == 0.0 ? thresh : stable_thresh;
1351 int passno, res = 0;
1352 for (passno = 0; passno < cblk->
npasses; passno++){
1361 if (((dd * dwt_norm) >>
WMSEDEC_SHIFT) * dwt_norm >= dr * lambda)
1369 int precno, compno, reslevelno, bandno, cblkno,
lev;
1372 for (compno = 0; compno <
s->ncomponents; compno++){
1375 for (reslevelno = 0,
lev = codsty->
nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++,
lev--){
1379 for (bandno = 0; bandno < reslevel->
nbands ; bandno++){
1380 int bandpos = bandno + (reslevelno > 0);
1403 int compno, reslevelno, bandno, ret;
1406 for (compno = 0; compno <
s->ncomponents; compno++){
1416 for (reslevelno = 0; reslevelno < codsty->
nreslevels; reslevelno++){
1419 for (bandno = 0; bandno < reslevel->
nbands ; bandno++){
1422 int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
1423 yy0 = bandno == 0 ? 0 :
comp->reslevel[reslevelno-1].coord[1][1] -
comp->reslevel[reslevelno-1].coord[1][0];
1426 band->
coord[1][1]) - band->
coord[1][0] + yy0;
1431 bandpos = bandno + (reslevelno > 0);
1434 if (reslevelno == 0 || bandno == 1)
1437 xx0 =
comp->reslevel[reslevelno-1].coord[0][1] -
comp->reslevel[reslevelno-1].coord[0][0];
1440 band->
coord[0][1]) - band->
coord[0][0] + xx0;
1445 for (y = yy0; y < yy1; y++){
1446 int *ptr =
t1.data + (y-yy0)*
t1.stride;
1447 for (x = xx0; x < xx1; x++){
1452 for (y = yy0; y < yy1; y++){
1453 int *ptr =
t1.data + (y-yy0)*
t1.stride;
1454 for (x = xx0; x < xx1; x++){
1455 *ptr = (
comp->i_data[(
comp->coord[0][1] -
comp->coord[0][0]) * y + x]);
1468 bandpos, codsty->
nreslevels - reslevelno - 1);
1481 if (
s->compression_rate_enc)
1499 for (tileno = 0; tileno <
s->numXtiles *
s->numYtiles; tileno++){
1500 if (
s->tile[tileno].comp) {
1501 for (compno = 0; compno <
s->ncomponents; compno++){
1515 for (tileno = 0; tileno <
s->numXtiles *
s->numYtiles; tileno++){
1517 for (compno = 0; compno <
s->ncomponents; compno++)
1528 const AVFrame *pict,
int *got_packet)
1532 uint8_t *chunkstart, *jp2cstart, *jp2hstart;
1556 bytestream_put_be32(&
s->buf, 0x0000000C);
1557 bytestream_put_be32(&
s->buf, 0x6A502020);
1558 bytestream_put_be32(&
s->buf, 0x0D0A870A);
1560 chunkstart =
s->buf;
1561 bytestream_put_be32(&
s->buf, 0);
1564 bytestream_put_be32(&
s->buf, 0);
1569 bytestream_put_be32(&
s->buf, 0);
1572 chunkstart =
s->buf;
1573 bytestream_put_be32(&
s->buf, 0);
1575 bytestream_put_be32(&
s->buf, avctx->
height);
1576 bytestream_put_be32(&
s->buf, avctx->
width);
1577 bytestream_put_be16(&
s->buf,
s->ncomponents);
1578 bytestream_put_byte(&
s->buf,
s->cbps[0]);
1579 bytestream_put_byte(&
s->buf, 7);
1580 bytestream_put_byte(&
s->buf, 0);
1581 bytestream_put_byte(&
s->buf, 0);
1584 chunkstart =
s->buf;
1585 bytestream_put_be32(&
s->buf, 0);
1587 bytestream_put_byte(&
s->buf, 1);
1588 bytestream_put_byte(&
s->buf, 0);
1589 bytestream_put_byte(&
s->buf, 0);
1591 bytestream_put_be32(&
s->buf, 16);
1592 }
else if (
s->ncomponents == 1) {
1593 bytestream_put_be32(&
s->buf, 17);
1595 bytestream_put_be32(&
s->buf, 18);
1601 chunkstart =
s->buf;
1602 bytestream_put_be32(&
s->buf, 0);
1605 bytestream_put_byte(&
s->buf, 3);
1606 bytestream_put_be24(&
s->buf, 0x070707);
1612 chunkstart =
s->buf;
1613 bytestream_put_be32(&
s->buf, 0);
1615 for (
i = 0;
i < 3;
i++) {
1616 bytestream_put_be16(&
s->buf, 0);
1617 bytestream_put_byte(&
s->buf, 1);
1618 bytestream_put_byte(&
s->buf,
i);
1625 bytestream_put_be32(&
s->buf, 0);
1629 if (
s->buf_end -
s->buf < 2)
1641 for (tileno = 0; tileno <
s->numXtiles *
s->numYtiles; tileno++){
1643 if (!(psotptr =
put_sot(
s, tileno)))
1645 if (
s->buf_end -
s->buf < 2)
1650 bytestream_put_be32(&psotptr,
s->buf - psotptr + 6);
1652 if (
s->buf_end -
s->buf < 2)
1671 char *saveptr =
NULL;
1676 s->layer_rates[0] = 0;
1677 s->compression_rate_enc = 0;
1682 if (token && (rate = strtol(token,
NULL, 10))) {
1683 s->layer_rates[0] = rate <= 1 ? 0:rate;
1693 if (rate = strtol(token,
NULL, 10)) {
1694 if (nlayers >= 100) {
1697 s->layer_rates[nlayers] = rate <= 1 ? 0:rate;
1704 for (
i = 1;
i < nlayers;
i++) {
1705 if (
s->layer_rates[
i] >=
s->layer_rates[
i-1]) {
1709 s->nlayers = nlayers;
1710 s->compression_rate_enc = 1;
1727 s->layer_rates[0] = 0;
1728 s->compression_rate_enc = 0;
1731 #if FF_API_PRIVATE_OPT
1757 if ((
s->tile_width & (
s->tile_width -1)) ||
1758 (
s->tile_height & (
s->tile_height-1))) {
1770 s->ncomponents =
desc->nb_components;
1771 for (
i = 0;
i < 3;
i++) {
1772 s->cbps[
i] =
desc->comp[
i].depth;
1778 s->chroma_shift,
s->chroma_shift + 1);
1806 #define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)
1807 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static double val(void *priv, double ch)
static const char *const format[]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
#define xi(width, name, var, range_min, range_max, subs,...)
#define bit(string, value)
#define ss(width, name, subs,...)
static LevelCodes lev[4+3+3]
common internal and external API header
static __device__ float ceil(float a)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
const char * av_default_item_name(void *ptr)
Return the context name.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
#define LIBAVUTIL_VERSION_INT
static int init_tiles(Jpeg2000EncoderContext *s)
compute the sizes of tiles, resolution levels, bands, etc.
static int put_com(Jpeg2000EncoderContext *s, int compno)
static int parse_layer_rates(Jpeg2000EncoderContext *s)
static uint8_t * put_sot(Jpeg2000EncoderContext *s, int tileno)
#define WMSEDEC_SHIFT
must be >= 13
static void update_size(uint8_t *size, const uint8_t *end)
static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
AVCodec ff_jpeg2000_encoder
static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile *tile, int final)
static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
static void init_luts(void)
static const AVOption options[]
static void putnumpasses(Jpeg2000EncoderContext *s, int n)
static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno, int precno, uint8_t *expn, int numgbits, int packetno, int nlayers)
static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
static void reinit(Jpeg2000EncoderContext *s)
static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
static av_cold int j2kenc_init(AVCodecContext *avctx)
static int j2kenc_destroy(AVCodecContext *avctx)
static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
static void init_quantization(Jpeg2000EncoderContext *s)
static int lut_nmsedec_sig0[1<< NMSEDEC_BITS]
static void compute_rates(Jpeg2000EncoderContext *s)
static void tag_tree_update(Jpeg2000TgtNode *node)
update the value in node
static void cleanup(Jpeg2000EncoderContext *s)
static void put_num(Jpeg2000EncoderContext *s, int num, int n)
put n least significant bits of a number num
static void j2k_flush(Jpeg2000EncoderContext *s)
flush the bitstream
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static int lut_nmsedec_sig[1<< NMSEDEC_BITS]
static int lut_nmsedec_ref0[1<< NMSEDEC_BITS]
static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile, int width, int height, int bandpos, int lev)
static int lut_nmsedec_ref[1<< NMSEDEC_BITS]
static int put_qcd(Jpeg2000EncoderContext *s, int compno)
static int getnmsedec_sig(int x, int bpno)
static int getnmsedec_ref(int x, int bpno)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)
code the value stored in node
static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
static const int dwt_norms[2][4][10]
static const AVClass j2k_class
static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
static int put_siz(Jpeg2000EncoderContext *s)
#define COPY_FRAME(D, PIXEL)
static int put_cod(Jpeg2000EncoderContext *s)
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)
void av_cold ff_jpeg2000_init_tier1_luts(void)
void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
JPEG 2000 structures and defines common to encoder and decoder.
#define JPEG2000_T1_SIG_NB
#define JPEG2000_CSTY_SOP
static int ff_jpeg2000_ceildivpow2(int a, int b)
#define JPEG2000_PGOD_PCRL
static int ff_jpeg2000_ceildiv(int a, int64_t b)
#define JPEG2000_CSTY_EPH
#define JPEG2000_PGOD_CPRL
#define JPEG2000_PGOD_RPCL
#define JPEG2000_MAX_PASSES
#define JPEG2000_PGOD_RLCP
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
static int ff_jpeg2000_getrefctxno(int flag)
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
#define JPEG2000_PGOD_LRCP
int ff_dwt_encode(DWTContext *s, void *t)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
static enum AVPixelFormat pix_fmts[]
static const uint16_t mask[17]
void av_cold ff_mqc_init_context_tables(void)
MQ-coder Initialize context tables (QE, NLPS, NMPS)
void ff_mqc_encode(MqcState *mqc, uint8_t *cxstate, int d)
code bit d with context cx
int ff_mqc_flush_to(MqcState *mqc, uint8_t *dst, int *dst_len)
void ff_mqc_initenc(MqcState *mqc, uint8_t *bp)
initialize the encoder
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
#define AV_PIX_FMT_GRAY16
static const float pred[4]
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
attribute_deprecated int prediction_method
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
uint16_t log2_cblk_height
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Jpeg2000CodingStyle codsty
Jpeg2000QuantStyle qntsty
int height
image width and height
uint8_t compression_rate_enc
Is compression done using compression ratio?
Jpeg2000TgtNode * zerobits
Jpeg2000TgtNode * cblkincl
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
struct Jpeg2000TgtNode * parent
#define av_malloc_array(a, b)
#define avpriv_request_sample(...)