FFmpeg: libavcodec/j2kenc.c Source File

FFmpeg

[フレーム]

libavcodec

j2kenc.c

Go to the documentation of this file.

1 /*

2 * JPEG2000 image encoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 *

21 * **********************************************************************************************************************

22 *

23 *

24 *

25 * This source code incorporates work covered by the following copyright and

26 * permission notice:

27 *

37 *

38 * Redistribution and use in source and binary forms, with or without

39 * modification, are permitted provided that the following conditions

40 * are met:

41 * 1. Redistributions of source code must retain the above copyright

42 * notice, this list of conditions and the following disclaimer.

43 * 2. Redistributions in binary form must reproduce the above copyright

44 * notice, this list of conditions and the following disclaimer in the

45 * documentation and/or other materials provided with the distribution.

46 *

47 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'

48 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

50 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

51 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

52 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

53 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

54 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

55 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

56 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

57 * POSSIBILITY OF SUCH DAMAGE.

58 */

61 /**

62 * JPEG2000 image encoder

63 * @file

64 * @author Kamil Nowosad

65 */

67 #include <float.h>

68 #include "avcodec.h"

69 #include "codec_internal.h"

70 #include "encode.h"

71 #include "bytestream.h"

72 #include "jpeg2000.h"

73 #include "version.h"

74 #include "libavutil/common.h"

75 #include "libavutil/pixdesc.h"

76 #include "libavutil/opt.h"

77 #include "libavutil/intreadwrite.h"

78 #include "libavutil/avstring.h"

79 #include "libavutil/thread.h"

81 #define NMSEDEC_BITS 7

82 #define NMSEDEC_FRACBITS (NMSEDEC_BITS-1)

83 #define WMSEDEC_SHIFT 13 ///< must be >= 13

84 #define LAMBDA_SCALE (100000000LL << (WMSEDEC_SHIFT - 13))

86 #define CODEC_JP2 1

87 #define CODEC_J2K 0

89 static int lut_nmsedec_ref [1<<NMSEDEC_BITS],

90 lut_nmsedec_ref0[1<<NMSEDEC_BITS],

91 lut_nmsedec_sig [1<<NMSEDEC_BITS],

92 lut_nmsedec_sig0[1<<NMSEDEC_BITS];

94 static const int dwt_norms[2][4][10] = { // [dwt_type][band][rlevel] (multiplied by 10000)

95 {{10000, 19650, 41770, 84030, 169000, 338400, 676900, 1353000, 2706000, 5409000},

96 {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},

97 {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},

98 {20800, 38650, 83070, 171800, 347100, 695900, 1393000, 2786000, 5572000}},

100 {{10000, 15000, 27500, 53750, 106800, 213400, 426700, 853300, 1707000, 3413000},

101 {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},

102 {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},

103 { 7186, 9218, 15860, 30430, 60190, 120100, 240000, 479700, 959300}}

104 };

105

106 typedef struct {

107 Jpeg2000Component *comp;

108 double *layer_rates;

109 } Jpeg2000Tile;

110

111 typedef struct {

112 AVClass *class;

113 AVCodecContext *avctx;

114 const AVFrame *picture;

115

116 int width, height; ///< image width and height

117 uint8_t cbps[4]; ///< bits per sample in particular components

118 int chroma_shift[2];

119 uint8_t planar;

120 int ncomponents;

121 int tile_width, tile_height; ///< tile size

122 int numXtiles, numYtiles;

123

124 uint8_t *buf_start;

125 uint8_t *buf;

126 uint8_t *buf_end;

127 int bit_index;

128

129 int64_t lambda;

130

131 Jpeg2000CodingStyle codsty;

132 Jpeg2000QuantStyle qntsty;

133

134 Jpeg2000Tile *tile;

135 int layer_rates[100];

136 uint8_t compression_rate_enc; ///< Is compression done using compression ratio?

137

138 int format;

139 int pred;

140 int sop;

141 int eph;

142 int prog;

143 int nlayers;

144 char *lr_str;

145 } Jpeg2000EncoderContext;

146

147

148 /* debug */

149 #if 0

150 #undef ifprintf

151 #undef printf

152

153 static void nspaces(FILE *fd, int n)

154 {

155 while(n--) putc(' ', fd);

156 }

157

158 static void printcomp(Jpeg2000Component *comp)

159 {

160 int i;

161 for (i = 0; i < comp->y1 - comp->y0; i++)

162 ff_jpeg2000_printv(comp->i_data + i * (comp->x1 - comp->x0), comp->x1 - comp->x0);

163 }

164

165 static void dump(Jpeg2000EncoderContext *s, FILE *fd)

166 {

167 int tileno, compno, reslevelno, bandno, precno;

168 fprintf(fd, "XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"

169 "numXtiles = %d, numYtiles = %d, ncomponents = %d\n"

170 "tiles:\n",

171 s->width, s->height, s->tile_width, s->tile_height,

172 s->numXtiles, s->numYtiles, s->ncomponents);

173 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){

174 Jpeg2000Tile *tile = s->tile + tileno;

175 nspaces(fd, 2);

176 fprintf(fd, "tile %d:\n", tileno);

177 for(compno = 0; compno < s->ncomponents; compno++){

178 Jpeg2000Component *comp = tile->comp + compno;

179 nspaces(fd, 4);

180 fprintf(fd, "component %d:\n", compno);

181 nspaces(fd, 4);

182 fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",

183 comp->x0, comp->x1, comp->y0, comp->y1);

184 for(reslevelno = 0; reslevelno < s->nreslevels; reslevelno++){

185 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

186 nspaces(fd, 6);

187 fprintf(fd, "reslevel %d:\n", reslevelno);

188 nspaces(fd, 6);

189 fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d, nbands = %d\n",

190 reslevel->x0, reslevel->x1, reslevel->y0,

191 reslevel->y1, reslevel->nbands);

192 for(bandno = 0; bandno < reslevel->nbands; bandno++){

193 Jpeg2000Band *band = reslevel->band + bandno;

194 nspaces(fd, 8);

195 fprintf(fd, "band %d:\n", bandno);

196 nspaces(fd, 8);

197 fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d,"

198 "codeblock_width = %d, codeblock_height = %d cblknx = %d cblkny = %d\n",

199 band->x0, band->x1,

200 band->y0, band->y1,

201 band->codeblock_width, band->codeblock_height,

202 band->cblknx, band->cblkny);

203 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){

204 Jpeg2000Prec *prec = band->prec + precno;

205 nspaces(fd, 10);

206 fprintf(fd, "prec %d:\n", precno);

207 nspaces(fd, 10);

208 fprintf(fd, "xi0 = %d, xi1 = %d, yi0 = %d, yi1 = %d\n",

209 prec->xi0, prec->xi1, prec->yi0, prec->yi1);

210 }

211 }

212 }

213 }

214 }

215 }

216 #endif

217

218 /* bitstream routines */

219

220 /** put n times val bit */

221 static void put_bits(Jpeg2000EncoderContext *s, int val, int n) // TODO: optimize

222 {

223 while (n-- > 0){

224 if (s->bit_index == 8)

225 {

226 s->bit_index = *s->buf == 0xff;

227 *(++s->buf) = 0;

228 }

229 *s->buf |= val << (7 - s->bit_index++);

230 }

231 }

232

233 /** put n least significant bits of a number num */

234 static void put_num(Jpeg2000EncoderContext *s, int num, int n)

235 {

236 while(--n >= 0)

237 put_bits(s, (num >> n) & 1, 1);

238 }

239

240 /** flush the bitstream */

241 static void j2k_flush(Jpeg2000EncoderContext *s)

242 {

243 if (s->bit_index){

244 s->bit_index = 0;

245 s->buf++;

246 }

247 }

248

249 /* tag tree routines */

250

251 /** code the value stored in node */

252 static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)

253 {

254 Jpeg2000TgtNode *stack[30];

255 int sp = -1, curval = 0;

256

257 while(node->parent){

258 stack[++sp] = node;

259 node = node->parent;

260 }

261

262 while (1) {

263 if (curval > node->temp_val)

264 node->temp_val = curval;

265 else {

266 curval = node->temp_val;

267 }

268

269 if (node->val >= threshold) {

270 put_bits(s, 0, threshold - curval);

271 curval = threshold;

272 } else {

273 put_bits(s, 0, node->val - curval);

274 curval = node->val;

275 if (!node->vis) {

276 put_bits(s, 1, 1);

277 node->vis = 1;

278 }

279 }

280

281 node->temp_val = curval;

282 if (sp < 0)

283 break;

284 node = stack[sp--];

285 }

286 }

287

288 /** update the value in node */

289 static void tag_tree_update(Jpeg2000TgtNode *node)

290 {

291 while (node->parent){

292 if (node->parent->val <= node->val)

293 break;

294 node->parent->val = node->val;

295 node = node->parent;

296 }

297 }

298

299 static int put_siz(Jpeg2000EncoderContext *s)

300 {

301 int i;

302

303 if (s->buf_end - s->buf < 40 + 3 * s->ncomponents)

304 return -1;

305

306 bytestream_put_be16(&s->buf, JPEG2000_SIZ);

307 bytestream_put_be16(&s->buf, 38 + 3 * s->ncomponents); // Lsiz

308 bytestream_put_be16(&s->buf, 0); // Rsiz

309 bytestream_put_be32(&s->buf, s->width); // width

310 bytestream_put_be32(&s->buf, s->height); // height

311 bytestream_put_be32(&s->buf, 0); // X0Siz

312 bytestream_put_be32(&s->buf, 0); // Y0Siz

313

314 bytestream_put_be32(&s->buf, s->tile_width); // XTSiz

315 bytestream_put_be32(&s->buf, s->tile_height); // YTSiz

316 bytestream_put_be32(&s->buf, 0); // XT0Siz

317 bytestream_put_be32(&s->buf, 0); // YT0Siz

318 bytestream_put_be16(&s->buf, s->ncomponents); // CSiz

319

320 for (i = 0; i < s->ncomponents; i++){ // Ssiz_i XRsiz_i, YRsiz_i

321 bytestream_put_byte(&s->buf, s->cbps[i] - 1);

322 bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[0]:1);

323 bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[1]:1);

324 }

325 return 0;

326 }

327

328 static int put_cod(Jpeg2000EncoderContext *s)

329 {

330 Jpeg2000CodingStyle *codsty = &s->codsty;

331 uint8_t scod = 0;

332

333 if (s->buf_end - s->buf < 14)

334 return -1;

335

336 bytestream_put_be16(&s->buf, JPEG2000_COD);

337 bytestream_put_be16(&s->buf, 12); // Lcod

338 if (s->sop)

339 scod |= JPEG2000_CSTY_SOP;

340 if (s->eph)

341 scod |= JPEG2000_CSTY_EPH;

342 bytestream_put_byte(&s->buf, scod); // Scod

343 // SGcod

344 bytestream_put_byte(&s->buf, s->prog); // progression level

345 bytestream_put_be16(&s->buf, s->nlayers); // num of layers

346 if(s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){

347 bytestream_put_byte(&s->buf, 0); // unspecified

348 }else{

349 bytestream_put_byte(&s->buf, 0); // unspecified

350 }

351 // SPcod

352 bytestream_put_byte(&s->buf, codsty->nreslevels - 1); // num of decomp. levels

353 bytestream_put_byte(&s->buf, codsty->log2_cblk_width-2); // cblk width

354 bytestream_put_byte(&s->buf, codsty->log2_cblk_height-2); // cblk height

355 bytestream_put_byte(&s->buf, 0); // cblk style

356 bytestream_put_byte(&s->buf, codsty->transform == FF_DWT53); // transformation

357 return 0;

358 }

359

360 static int put_qcd(Jpeg2000EncoderContext *s, int compno)

361 {

362 int i, size;

363 Jpeg2000CodingStyle *codsty = &s->codsty;

364 Jpeg2000QuantStyle *qntsty = &s->qntsty;

365

366 if (qntsty->quantsty == JPEG2000_QSTY_NONE)

367 size = 4 + 3 * (codsty->nreslevels-1);

368 else // QSTY_SE

369 size = 5 + 6 * (codsty->nreslevels-1);

370

371 if (s->buf_end - s->buf < size + 2)

372 return -1;

373

374 bytestream_put_be16(&s->buf, JPEG2000_QCD);

375 bytestream_put_be16(&s->buf, size); // LQcd

376 bytestream_put_byte(&s->buf, (qntsty->nguardbits << 5) | qntsty->quantsty); // Sqcd

377 if (qntsty->quantsty == JPEG2000_QSTY_NONE)

378 for (i = 0; i < codsty->nreslevels * 3 - 2; i++)

379 bytestream_put_byte(&s->buf, qntsty->expn[i] << 3);

380 else // QSTY_SE

381 for (i = 0; i < codsty->nreslevels * 3 - 2; i++)

382 bytestream_put_be16(&s->buf, (qntsty->expn[i] << 11) | qntsty->mant[i]);

383 return 0;

384 }

385

386 static int put_com(Jpeg2000EncoderContext *s, int compno)

387 {

388 int size = 4 + strlen(LIBAVCODEC_IDENT);

389

390 if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)

391 return 0;

392

393 if (s->buf_end - s->buf < size + 2)

394 return -1;

395

396 bytestream_put_be16(&s->buf, JPEG2000_COM);

397 bytestream_put_be16(&s->buf, size);

398 bytestream_put_be16(&s->buf, 1); // General use (ISO/IEC 8859-15 (Latin) values)

399

400 bytestream_put_buffer(&s->buf, LIBAVCODEC_IDENT, strlen(LIBAVCODEC_IDENT));

401

402 return 0;

403 }

404

405 static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno)

406 {

407 uint8_t *psotptr;

408

409 if (s->buf_end - s->buf < 12)

410 return NULL;

411

412 bytestream_put_be16(&s->buf, JPEG2000_SOT);

413 bytestream_put_be16(&s->buf, 10); // Lsot

414 bytestream_put_be16(&s->buf, tileno); // Isot

415

416 psotptr = s->buf;

417 bytestream_put_be32(&s->buf, 0); // Psot (filled in later)

418

419 bytestream_put_byte(&s->buf, 0); // TPsot

420 bytestream_put_byte(&s->buf, 1); // TNsot

421 return psotptr;

422 }

423

424 static void compute_rates(Jpeg2000EncoderContext* s)

425 {

426 int i, j;

427 int layno, compno;

428 for (i = 0; i < s->numYtiles; i++) {

429 for (j = 0; j < s->numXtiles; j++) {

430 Jpeg2000Tile *tile = &s->tile[s->numXtiles * i + j];

431 for (compno = 0; compno < s->ncomponents; compno++) {

432 int tilew = tile->comp[compno].coord[0][1] - tile->comp[compno].coord[0][0];

433 int tileh = tile->comp[compno].coord[1][1] - tile->comp[compno].coord[1][0];

434 int scale = (compno?1 << s->chroma_shift[0]:1) * (compno?1 << s->chroma_shift[1]:1);

435 for (layno = 0; layno < s->nlayers; layno++) {

436 if (s->layer_rates[layno] > 0) {

437 tile->layer_rates[layno] += (double)(tilew * tileh) * s->ncomponents * s->cbps[compno] /

438 (double)(s->layer_rates[layno] * 8 * scale);

439 } else {

440 tile->layer_rates[layno] = 0.0;

441 }

442 }

443 }

444 }

445 }

446

447 }

448

449 /**

450 * compute the sizes of tiles, resolution levels, bands, etc.

451 * allocate memory for them

452 * divide the input image into tile-components

453 */

454 static int init_tiles(Jpeg2000EncoderContext *s)

455 {

456 int tileno, tilex, tiley, compno;

457 Jpeg2000CodingStyle *codsty = &s->codsty;

458 Jpeg2000QuantStyle *qntsty = &s->qntsty;

459

460 s->numXtiles = ff_jpeg2000_ceildiv(s->width, s->tile_width);

461 s->numYtiles = ff_jpeg2000_ceildiv(s->height, s->tile_height);

462

463 s->tile = av_calloc(s->numXtiles, s->numYtiles * sizeof(Jpeg2000Tile));

464 if (!s->tile)

465 return AVERROR(ENOMEM);

466 for (tileno = 0, tiley = 0; tiley < s->numYtiles; tiley++)

467 for (tilex = 0; tilex < s->numXtiles; tilex++, tileno++){

468 Jpeg2000Tile *tile = s->tile + tileno;

469

470 tile->comp = av_calloc(s->ncomponents, sizeof(*tile->comp));

471 if (!tile->comp)

472 return AVERROR(ENOMEM);

473

474 tile->layer_rates = av_calloc(s->nlayers, sizeof(*tile->layer_rates));

475 if (!tile->layer_rates)

476 return AVERROR(ENOMEM);

477

478 for (compno = 0; compno < s->ncomponents; compno++){

479 Jpeg2000Component *comp = tile->comp + compno;

480 int ret, i, j;

481

482 comp->coord[0][0] = comp->coord_o[0][0] = tilex * s->tile_width;

483 comp->coord[0][1] = comp->coord_o[0][1] = FFMIN((tilex+1)*s->tile_width, s->width);

484 comp->coord[1][0] = comp->coord_o[1][0] = tiley * s->tile_height;

485 comp->coord[1][1] = comp->coord_o[1][1] = FFMIN((tiley+1)*s->tile_height, s->height);

486 if (compno > 0)

487 for (i = 0; i < 2; i++)

488 for (j = 0; j < 2; j++)

489 comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]);

490

491 if ((ret = ff_jpeg2000_init_component(comp,

492 codsty,

493 qntsty,

494 s->cbps[compno],

495 compno?1<<s->chroma_shift[0]:1,

496 compno?1<<s->chroma_shift[1]:1,

497 s->avctx

498 )) < 0)

499 return ret;

500 }

501 }

502 compute_rates(s);

503 return 0;

504 }

505

506 #define COPY_FRAME(D, PIXEL) \

507 static void copy_frame_ ##D(Jpeg2000EncoderContext *s) \

508 { \

509 int tileno, compno, i, y, x; \

510 PIXEL *line; \

511 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){ \

512 Jpeg2000Tile *tile = s->tile + tileno; \

513 if (s->planar){ \

514 for (compno = 0; compno < s->ncomponents; compno++){ \

515 Jpeg2000Component *comp = tile->comp + compno; \

516 int *dst = comp->i_data; \

517 int cbps = s->cbps[compno]; \

518 line = (PIXEL*)s->picture->data[compno] \

519 + comp->coord[1][0] * (s->picture->linesize[compno] / sizeof(PIXEL)) \

520 + comp->coord[0][0]; \

521 for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){ \

522 PIXEL *ptr = line; \

523 for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++) \

524 *dst++ = *ptr++ - (1 << (cbps - 1)); \

525 line += s->picture->linesize[compno] / sizeof(PIXEL); \

526 } \

527 } \

528 } else{ \

529 line = (PIXEL*)s->picture->data[0] + tile->comp[0].coord[1][0] * (s->picture->linesize[0] / sizeof(PIXEL)) \

530 + tile->comp[0].coord[0][0] * s->ncomponents; \

531 \

532 i = 0; \

533 for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){ \

534 PIXEL *ptr = line; \

535 for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){ \

536 for (compno = 0; compno < s->ncomponents; compno++){ \

537 int cbps = s->cbps[compno]; \

538 tile->comp[compno].i_data[i] = *ptr++ - (1 << (cbps - 1)); \

539 } \

540 } \

541 line += s->picture->linesize[0] / sizeof(PIXEL); \

542 } \

543 } \

544 } \

545 }

546

547 COPY_FRAME(8, uint8_t)

548 COPY_FRAME(16, uint16_t)

549

550 static void init_quantization(Jpeg2000EncoderContext *s)

551 {

552 int compno, reslevelno, bandno;

553 Jpeg2000QuantStyle *qntsty = &s->qntsty;

554 Jpeg2000CodingStyle *codsty = &s->codsty;

555

556 for (compno = 0; compno < s->ncomponents; compno++){

557 int gbandno = 0;

558 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){

559 int nbands, lev = codsty->nreslevels - reslevelno - 1;

560 nbands = reslevelno ? 3 : 1;

561 for (bandno = 0; bandno < nbands; bandno++, gbandno++){

562 int expn, mant = 0;

563

564 if (codsty->transform == FF_DWT97_INT){

565 int bandpos = bandno + (reslevelno>0),

566 ss = 81920000 / dwt_norms[0][bandpos][lev],

567 log = av_log2(ss);

568 mant = (11 - log < 0 ? ss >> log - 11 : ss << 11 - log) & 0x7ff;

569 expn = s->cbps[compno] - log + 13;

570 } else

571 expn = ((bandno&2)>>1) + (reslevelno>0) + s->cbps[compno];

572

573 qntsty->expn[gbandno] = expn;

574 qntsty->mant[gbandno] = mant;

575 }

576 }

577 }

578 }

579

580 static void init_luts(void)

581 {

582 int i, a,

583 mask = ~((1<<NMSEDEC_FRACBITS)-1);

584

585 for (i = 0; i < (1 << NMSEDEC_BITS); i++){

586 lut_nmsedec_sig[i] = FFMAX((3 * i << (13 - NMSEDEC_FRACBITS)) - (9 << 11), 0);

587 lut_nmsedec_sig0[i] = FFMAX((i*i + (1<<NMSEDEC_FRACBITS-1) & mask) << 1, 0);

588

589 a = (i >> (NMSEDEC_BITS-2)&2) + 1;

590 lut_nmsedec_ref[i] = FFMAX((a - 2) * (i << (13 - NMSEDEC_FRACBITS)) +

591 (1 << 13) - (a * a << 11), 0);

592 lut_nmsedec_ref0[i] = FFMAX(((i * i - (i << NMSEDEC_BITS) + (1 << 2 * NMSEDEC_FRACBITS) + (1 << (NMSEDEC_FRACBITS - 1))) & mask)

593 << 1, 0);

594 }

595 ff_jpeg2000_init_tier1_luts();

596 }

597

598 /* tier-1 routines */

599 static int getnmsedec_sig(int x, int bpno)

600 {

601 if (bpno > NMSEDEC_FRACBITS)

602 return lut_nmsedec_sig[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];

603 return lut_nmsedec_sig0[x & ((1 << NMSEDEC_BITS) - 1)];

604 }

605

606 static int getnmsedec_ref(int x, int bpno)

607 {

608 if (bpno > NMSEDEC_FRACBITS)

609 return lut_nmsedec_ref[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];

610 return lut_nmsedec_ref0[x & ((1 << NMSEDEC_BITS) - 1)];

611 }

612

613 static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)

614 {

615 int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);

616 for (y0 = 0; y0 < height; y0 += 4)

617 for (x = 0; x < width; x++)

618 for (y = y0; y < height && y < y0+4; y++){

619 if (!(t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG) && (t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB)){

620 int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno),

621 bit = t1->data[(y) * t1->stride + x] & mask ? 1 : 0;

622 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, bit);

623 if (bit){

624 int xorbit;

625 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);

626 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);

627 *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);

628 ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);

629 }

630 t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_VIS;

631 }

632 }

633 }

634

635 static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)

636 {

637 int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);

638 for (y0 = 0; y0 < height; y0 += 4)

639 for (x = 0; x < width; x++)

640 for (y = y0; y < height && y < y0+4; y++)

641 if ((t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG){

642 int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y+1) * t1->stride + x+1]);

643 *nmsedec += getnmsedec_ref(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);

644 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);

645 t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_REF;

646 }

647 }

648

649 static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)

650 {

651 int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);

652 for (y0 = 0; y0 < height; y0 += 4)

653 for (x = 0; x < width; x++){

654 if (y0 + 3 < height && !(

655 (t1->flags[(y0+1) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||

656 (t1->flags[(y0+2) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||

657 (t1->flags[(y0+3) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||

658 (t1->flags[(y0+4) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG))))

659 {

660 // aggregation mode

661 int rlen;

662 for (rlen = 0; rlen < 4; rlen++)

663 if (t1->data[(y0+rlen) * t1->stride + x] & mask)

664 break;

665 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL, rlen != 4);

666 if (rlen == 4)

667 continue;

668 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen >> 1);

669 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen & 1);

670 for (y = y0 + rlen; y < y0 + 4; y++){

671 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){

672 int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);

673 if (y > y0 + rlen)

674 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);

675 if (t1->data[(y) * t1->stride + x] & mask){ // newly significant

676 int xorbit;

677 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);

678 *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);

679 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);

680 ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);

681 }

682 }

683 t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;

684 }

685 } else{

686 for (y = y0; y < y0 + 4 && y < height; y++){

687 if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){

688 int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);

689 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);

690 if (t1->data[(y) * t1->stride + x] & mask){ // newly significant

691 int xorbit;

692 int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);

693 *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);

694 ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);

695 ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);

696 }

697 }

698 t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;

699 }

700 }

701 }

702 }

703

704 static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile,

705 int width, int height, int bandpos, int lev)

706 {

707 int pass_t = 2, passno, x, y, max=0, nmsedec, bpno;

708 int64_t wmsedec = 0;

709

710 memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));

711

712 for (y = 0; y < height; y++){

713 for (x = 0; x < width; x++){

714 if (t1->data[(y) * t1->stride + x] < 0){

715 t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_SGN;

716 t1->data[(y) * t1->stride + x] = -t1->data[(y) * t1->stride + x];

717 }

718 max = FFMAX(max, t1->data[(y) * t1->stride + x]);

719 }

720 }

721

722 if (max == 0){

723 cblk->nonzerobits = 0;

724 bpno = 0;

725 } else{

726 cblk->nonzerobits = av_log2(max) + 1 - NMSEDEC_FRACBITS;

727 bpno = cblk->nonzerobits - 1;

728 }

729

730 cblk->data[0] = 0;

731 ff_mqc_initenc(&t1->mqc, cblk->data + 1);

732

733 for (passno = 0; bpno >= 0; passno++){

734 nmsedec=0;

735

736 switch(pass_t){

737 case 0: encode_sigpass(t1, width, height, bandpos, &nmsedec, bpno);

738 break;

739 case 1: encode_refpass(t1, width, height, &nmsedec, bpno);

740 break;

741 case 2: encode_clnpass(t1, width, height, bandpos, &nmsedec, bpno);

742 break;

743 }

744

745 cblk->passes[passno].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno].flushed, &cblk->passes[passno].flushed_len);

746 cblk->passes[passno].rate -= cblk->passes[passno].flushed_len;

747

748 wmsedec += (int64_t)nmsedec << (2*bpno);

749 cblk->passes[passno].disto = wmsedec;

750

751 if (++pass_t == 3){

752 pass_t = 0;

753 bpno--;

754 }

755 }

756 cblk->npasses = passno;

757 cblk->ninclpasses = passno;

758

759 if (passno) {

760 cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);

761 cblk->passes[passno-1].rate -= cblk->passes[passno-1].flushed_len;

762 }

763 }

764

765 /* tier-2 routines: */

766

767 static void putnumpasses(Jpeg2000EncoderContext *s, int n)

768 {

769 if (n == 1)

770 put_num(s, 0, 1);

771 else if (n == 2)

772 put_num(s, 2, 2);

773 else if (n <= 5)

774 put_num(s, 0xc | (n-3), 4);

775 else if (n <= 36)

776 put_num(s, 0x1e0 | (n-6), 9);

777 else

778 put_num(s, 0xff80 | (n-37), 16);

779 }

780

781

782 static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno,

783 int precno, uint8_t *expn, int numgbits, int packetno,

784 int nlayers)

785 {

786 int bandno, empty = 1;

787 int i;

788 // init bitstream

789 *s->buf = 0;

790 s->bit_index = 0;

791

792 if (s->sop) {

793 bytestream_put_be16(&s->buf, JPEG2000_SOP);

794 bytestream_put_be16(&s->buf, 4);

795 bytestream_put_be16(&s->buf, packetno);

796 }

797 // header

798

799 if (!layno) {

800 for (bandno = 0; bandno < rlevel->nbands; bandno++) {

801 Jpeg2000Band *band = rlevel->band + bandno;

802 if (band->coord[0][0] < band->coord[0][1]

803 && band->coord[1][0] < band->coord[1][1]) {

804 Jpeg2000Prec *prec = band->prec + precno;

805 int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;

806 int pos;

807 ff_tag_tree_zero(prec->zerobits, prec->nb_codeblocks_width, prec->nb_codeblocks_height, 99);

808 ff_tag_tree_zero(prec->cblkincl, prec->nb_codeblocks_width, prec->nb_codeblocks_height, 99);

809 for (pos = 0; pos < nb_cblks; pos++) {

810 Jpeg2000Cblk *cblk = &prec->cblk[pos];

811 prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - cblk->nonzerobits;

812 cblk->incl = 0;

813 cblk->lblock = 3;

814 tag_tree_update(prec->zerobits + pos);

815 for (i = 0; i < nlayers; i++) {

816 if (cblk->layers[i].npasses > 0) {

817 prec->cblkincl[pos].val = i;

818 break;

819 }

820 }

821 if (i == nlayers)

822 prec->cblkincl[pos].val = i;

823 tag_tree_update(prec->cblkincl + pos);

824 }

825 }

826 }

827 }

828

829 // is the packet empty?

830 for (bandno = 0; bandno < rlevel->nbands; bandno++){

831 Jpeg2000Band *band = rlevel->band + bandno;

832 if (band->coord[0][0] < band->coord[0][1]

833 && band->coord[1][0] < band->coord[1][1]) {

834 Jpeg2000Prec *prec = band->prec + precno;

835 int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;

836 int pos;

837 for (pos = 0; pos < nb_cblks; pos++) {

838 Jpeg2000Cblk *cblk = &prec->cblk[pos];

839 if (cblk->layers[layno].npasses) {

840 empty = 0;

841 break;

842 }

843 }

844 if (!empty)

845 break;

846 }

847 }

848

849 put_bits(s, !empty, 1);

850 if (empty){

851 j2k_flush(s);

852 if (s->eph)

853 bytestream_put_be16(&s->buf, JPEG2000_EPH);

854 return 0;

855 }

856

857 for (bandno = 0; bandno < rlevel->nbands; bandno++) {

858 Jpeg2000Band *band = rlevel->band + bandno;

859 Jpeg2000Prec *prec = band->prec + precno;

860 int yi, xi, pos;

861 int cblknw = prec->nb_codeblocks_width;

862

863 if (band->coord[0][0] == band->coord[0][1]

864 || band->coord[1][0] == band->coord[1][1])

865 continue;

866

867 for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++) {

868 for (xi = 0; xi < cblknw; xi++, pos++){

869 int llen = 0, length;

870 Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;

871

872 if (s->buf_end - s->buf < 20) // approximately

873 return -1;

874

875 // inclusion information

876 if (!cblk->incl)

877 tag_tree_code(s, prec->cblkincl + pos, layno + 1);

878 else {

879 put_bits(s, cblk->layers[layno].npasses > 0, 1);

880 }

881

882 if (!cblk->layers[layno].npasses)

883 continue;

884

885 // zerobits information

886 if (!cblk->incl) {

887 tag_tree_code(s, prec->zerobits + pos, 100);

888 cblk->incl = 1;

889 }

890

891 // number of passes

892 putnumpasses(s, cblk->layers[layno].npasses);

893

894 length = cblk->layers[layno].data_len;

895 if (layno == nlayers - 1 && cblk->layers[layno].cum_passes){

896 length += cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len;

897 }

898 if (cblk->lblock + av_log2(cblk->layers[layno].npasses) < av_log2(length) + 1) {

899 llen = av_log2(length) + 1 - cblk->lblock - av_log2(cblk->layers[layno].npasses);

900 }

901

902 // length of code block

903 cblk->lblock += llen;

904 put_bits(s, 1, llen);

905 put_bits(s, 0, 1);

906 put_num(s, length, cblk->lblock + av_log2(cblk->layers[layno].npasses));

907 }

908 }

909 }

910 j2k_flush(s);

911 if (s->eph) {

912 bytestream_put_be16(&s->buf, JPEG2000_EPH);

913 }

914

915 for (bandno = 0; bandno < rlevel->nbands; bandno++) {

916 Jpeg2000Band *band = rlevel->band + bandno;

917 Jpeg2000Prec *prec = band->prec + precno;

918 int yi, cblknw = prec->nb_codeblocks_width;

919 for (yi =0; yi < prec->nb_codeblocks_height; yi++) {

920 int xi;

921 for (xi = 0; xi < cblknw; xi++){

922 Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;

923 if (cblk->layers[layno].npasses) {

924 if (s->buf_end - s->buf < cblk->layers[layno].data_len + 2)

925 return -1;

926 bytestream_put_buffer(&s->buf, cblk->layers[layno].data_start + 1, cblk->layers[layno].data_len);

927 if (layno == nlayers - 1 && cblk->layers[layno].cum_passes) {

928 bytestream_put_buffer(&s->buf, cblk->passes[cblk->layers[layno].cum_passes-1].flushed,

929 cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len);

930 }

931 }

932 }

933 }

934 }

935 return 0;

936 }

937

938 static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)

939 {

940 int compno, reslevelno, layno, ret;

941 Jpeg2000CodingStyle *codsty = &s->codsty;

942 Jpeg2000QuantStyle *qntsty = &s->qntsty;

943 int packetno = 0;

944 int step_x, step_y;

945 int x, y;

946 int tile_coord[2][2];

947 int col = tileno % s->numXtiles;

948 int row = tileno / s->numXtiles;

949

950 tile_coord[0][0] = col * s->tile_width;

951 tile_coord[0][1] = FFMIN(tile_coord[0][0] + s->tile_width, s->width);

952 tile_coord[1][0] = row * s->tile_height;

953 tile_coord[1][1] = FFMIN(tile_coord[1][0] + s->tile_height, s->height);

954

955 av_log(s->avctx, AV_LOG_DEBUG, "tier2\n");

956 // lay-rlevel-comp-pos progression

957 switch (s->prog) {

958 case JPEG2000_PGOD_LRCP:

959 for (layno = 0; layno < nlayers; layno++) {

960 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){

961 for (compno = 0; compno < s->ncomponents; compno++){

962 int precno;

963 Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;

964 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){

965 if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),

966 qntsty->nguardbits, packetno++, nlayers)) < 0)

967 return ret;

968 }

969 }

970 }

971 }

972 break;

973 case JPEG2000_PGOD_RLCP:

974 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){

975 for (layno = 0; layno < nlayers; layno++) {

976 for (compno = 0; compno < s->ncomponents; compno++){

977 int precno;

978 Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;

979 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){

980 if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),

981 qntsty->nguardbits, packetno++, nlayers)) < 0)

982 return ret;

983 }

984 }

985 }

986 }

987 break;

988 case JPEG2000_PGOD_RPCL:

989 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

990 int precno;

991 step_x = 30;

992 step_y = 30;

993 for (compno = 0; compno < s->ncomponents; compno++) {

994 Jpeg2000Component *comp = tile->comp + compno;

995 if (reslevelno < codsty->nreslevels) {

996 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r

997 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

998 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);

999 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);

1000 }

1001 }

1002

1003 step_x = 1<<step_x;

1004 step_y = 1<<step_y;

1005 for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {

1006 for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {

1007 for (compno = 0; compno < s->ncomponents; compno++) {

1008 Jpeg2000Component *comp = tile->comp + compno;

1009 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r

1010 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

1011 int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};

1012 unsigned prcx, prcy;

1013 int trx0, try0;

1014

1015 trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);

1016 try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);

1017

1018 if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||

1019 (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))

1020 continue;

1021

1022 if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||

1023 (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))

1024 continue;

1025

1026 // check if a precinct exists

1027 prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;

1028 prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;

1029 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;

1030 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;

1031 precno = prcx + reslevel->num_precincts_x * prcy;

1032

1033 if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {

1034 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",

1035 prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);

1036 continue;

1037 }

1038 for (layno = 0; layno < nlayers; layno++) {

1039 if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),

1040 qntsty->nguardbits, packetno++, nlayers)) < 0)

1041 return ret;

1042 }

1043 }

1044 }

1045 }

1046 }

1047 break;

1048 case JPEG2000_PGOD_PCRL:

1049 step_x = 32;

1050 step_y = 32;

1051 for (compno = 0; compno < s->ncomponents; compno++) {

1052 Jpeg2000Component *comp = tile->comp + compno;

1053

1054 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

1055 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r

1056 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

1057 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);

1058 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);

1059 }

1060 }

1061 if (step_x >= 31 || step_y >= 31){

1062 avpriv_request_sample(s->avctx, "PCRL with large step");

1063 return AVERROR_PATCHWELCOME;

1064 }

1065 step_x = 1<<step_x;

1066 step_y = 1<<step_y;

1067

1068 for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {

1069 for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {

1070 for (compno = 0; compno < s->ncomponents; compno++) {

1071 Jpeg2000Component *comp = tile->comp + compno;

1072 int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};

1073

1074 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

1075 unsigned prcx, prcy;

1076 int precno;

1077 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r

1078 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

1079 int trx0, try0;

1080

1081 trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);

1082 try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);

1083

1084 if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||

1085 (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))

1086 continue;

1087

1088 if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||

1089 (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))

1090 continue;

1091

1092 // check if a precinct exists

1093 prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;

1094 prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;

1095 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;

1096 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;

1097

1098 precno = prcx + reslevel->num_precincts_x * prcy;

1099

1100 if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {

1101 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",

1102 prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);

1103 continue;

1104 }

1105 for (layno = 0; layno < nlayers; layno++) {

1106 if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),

1107 qntsty->nguardbits, packetno++, nlayers)) < 0)

1108 return ret;

1109 }

1110 }

1111 }

1112 }

1113 }

1114 break;

1115 case JPEG2000_PGOD_CPRL:

1116 for (compno = 0; compno < s->ncomponents; compno++) {

1117 Jpeg2000Component *comp = tile->comp + compno;

1118 int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};

1119 step_x = 32;

1120 step_y = 32;

1121

1122 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

1123 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r

1124 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;

1125 step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);

1126 step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);

1127 }

1128 if (step_x >= 31 || step_y >= 31){

1129 avpriv_request_sample(s->avctx, "CPRL with large step");

1130 return AVERROR_PATCHWELCOME;

1131 }

1132 step_x = 1<<step_x;

1133 step_y = 1<<step_y;

1134

1135 for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {

1136 for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {

1137 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {

1138 unsigned prcx, prcy;

1139 int precno;

1140 int trx0, try0;

1141 uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r

1142 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

1143

1144 trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);

1145 try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);

1146

1147 if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||

1148 (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))

1149 continue;

1150

1151 if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||

1152 (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))

1153 continue;

1154

1155 // check if a precinct exists

1156 prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;

1157 prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;

1158 prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;

1159 prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;

1160

1161 precno = prcx + reslevel->num_precincts_x * prcy;

1162

1163 if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {

1164 av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",

1165 prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);

1166 continue;

1167 }

1168 for (layno = 0; layno < nlayers; layno++) {

1169 if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),

1170 qntsty->nguardbits, packetno++, nlayers)) < 0)

1171 return ret;

1172 }

1173 }

1174 }

1175 }

1176 }

1177

1178 }

1179

1180 av_log(s->avctx, AV_LOG_DEBUG, "after tier2\n");

1181 return 0;

1182 }

1183

1184 static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile* tile, int final)

1185 {

1186 int compno, resno, bandno, precno, cblkno;

1187 int passno;

1188

1189 for (compno = 0; compno < s->ncomponents; compno++) {

1190 Jpeg2000Component *comp = &tile->comp[compno];

1191

1192 for (resno = 0; resno < s->codsty.nreslevels; resno++) {

1193 Jpeg2000ResLevel *reslevel = comp->reslevel + resno;

1194

1195 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){

1196 for (bandno = 0; bandno < reslevel->nbands ; bandno++){

1197 Jpeg2000Band *band = reslevel->band + bandno;

1198 Jpeg2000Prec *prec = band->prec + precno;

1199

1200 for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){

1201 Jpeg2000Cblk *cblk = prec->cblk + cblkno;

1202 Jpeg2000Layer *layer = &cblk->layers[layno];

1203 int n;

1204

1205 if (layno == 0) {

1206 cblk->ninclpasses = 0;

1207 }

1208

1209 n = cblk->ninclpasses;

1210

1211 if (thresh < 0) {

1212 n = cblk->npasses;

1213 } else {

1214 for (passno = cblk->ninclpasses; passno < cblk->npasses; passno++) {

1215 int32_t dr;

1216 double dd;

1217 Jpeg2000Pass *pass = &cblk->passes[passno];

1218

1219 if (n == 0) {

1220 dr = pass->rate;

1221 dd = pass->disto;

1222 } else {

1223 dr = pass->rate - cblk->passes[n - 1].rate;

1224 dd = pass->disto - cblk->passes[n-1].disto;

1225 }

1226

1227 if (!dr) {

1228 if (dd != 0.0) {

1229 n = passno + 1;

1230 }

1231 continue;

1232 }

1233

1234 if (thresh - (dd / dr) < DBL_EPSILON)

1235 n = passno + 1;

1236 }

1237 }

1238 layer->npasses = n - cblk->ninclpasses;

1239 layer->cum_passes = n;

1240

1241 if (layer->npasses == 0) {

1242 layer->disto = 0;

1243 layer->data_len = 0;

1244 continue;

1245 }

1246

1247 if (cblk->ninclpasses == 0) {

1248 layer->data_len = cblk->passes[n - 1].rate;

1249 layer->data_start = cblk->data;

1250 layer->disto = cblk->passes[n - 1].disto;

1251 } else {

1252 layer->data_len = cblk->passes[n - 1].rate - cblk->passes[cblk->ninclpasses - 1].rate;

1253 layer->data_start = cblk->data + cblk->passes[cblk->ninclpasses - 1].rate;

1254 layer->disto = cblk->passes[n - 1].disto -

1255 cblk->passes[cblk->ninclpasses - 1].disto;

1256 }

1257 if (final) {

1258 cblk->ninclpasses = n;

1259 }

1260 }

1261 }

1262 }

1263 }

1264 }

1265 }

1266

1267 static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)

1268 {

1269 int precno, compno, reslevelno, bandno, cblkno, lev, passno, layno;

1270 int i;

1271 double min = DBL_MAX;

1272 double max = 0;

1273 double thresh;

1274

1275 Jpeg2000CodingStyle *codsty = &s->codsty;

1276

1277 for (compno = 0; compno < s->ncomponents; compno++){

1278 Jpeg2000Component *comp = tile->comp + compno;

1279

1280 for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){

1281 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

1282

1283 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){

1284 for (bandno = 0; bandno < reslevel->nbands ; bandno++){

1285 Jpeg2000Band *band = reslevel->band + bandno;

1286 Jpeg2000Prec *prec = band->prec + precno;

1287

1288 for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){

1289 Jpeg2000Cblk *cblk = prec->cblk + cblkno;

1290 for (passno = 0; passno < cblk->npasses; passno++) {

1291 Jpeg2000Pass *pass = &cblk->passes[passno];

1292 int dr;

1293 double dd, drslope;

1294

1295 if (passno == 0) {

1296 dr = (int32_t)pass->rate;

1297 dd = pass->disto;

1298 } else {

1299 dr = (int32_t)(pass->rate - cblk->passes[passno - 1].rate);

1300 dd = pass->disto - cblk->passes[passno - 1].disto;

1301 }

1302

1303 if (dr <= 0)

1304 continue;

1305

1306 drslope = dd / dr;

1307 if (drslope < min)

1308 min = drslope;

1309

1310 if (drslope > max)

1311 max = drslope;

1312 }

1313 }

1314 }

1315 }

1316 }

1317 }

1318

1319 for (layno = 0; layno < s->nlayers; layno++) {

1320 double lo = min;

1321 double hi = max;

1322 double stable_thresh = 0.0;

1323 double good_thresh = 0.0;

1324 if (!s->layer_rates[layno]) {

1325 good_thresh = -1.0;

1326 } else {

1327 for (i = 0; i < 128; i++) {

1328 uint8_t *stream_pos = s->buf;

1329 int ret;

1330 thresh = (lo + hi) / 2;

1331 makelayer(s, layno, thresh, tile, 0);

1332 ret = encode_packets(s, tile, (int)(tile - s->tile), layno + 1);

1333 memset(stream_pos, 0, s->buf - stream_pos);

1334 if ((s->buf - stream_pos > ceil(tile->layer_rates[layno])) || ret < 0) {

1335 lo = thresh;

1336 s->buf = stream_pos;

1337 continue;

1338 }

1339 hi = thresh;

1340 stable_thresh = thresh;

1341 s->buf = stream_pos;

1342 }

1343 }

1344 if (good_thresh >= 0.0)

1345 good_thresh = stable_thresh == 0.0 ? thresh : stable_thresh;

1346 makelayer(s, layno, good_thresh, tile, 1);

1347 }

1348 }

1349

1350 static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)

1351 {

1352 int passno, res = 0;

1353 for (passno = 0; passno < cblk->npasses; passno++){

1354 int dr;

1355 int64_t dd;

1356

1357 dr = cblk->passes[passno].rate

1358 - (res ? cblk->passes[res-1].rate : 0);

1359 dd = cblk->passes[passno].disto

1360 - (res ? cblk->passes[res-1].disto : 0);

1361

1362 if (((dd * dwt_norm) >> WMSEDEC_SHIFT) * dwt_norm >= dr * lambda)

1363 res = passno+1;

1364 }

1365 return res;

1366 }

1367

1368 static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)

1369 {

1370 int precno, compno, reslevelno, bandno, cblkno, lev;

1371 Jpeg2000CodingStyle *codsty = &s->codsty;

1372

1373 for (compno = 0; compno < s->ncomponents; compno++){

1374 Jpeg2000Component *comp = tile->comp + compno;

1375

1376 for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){

1377 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

1378

1379 for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){

1380 for (bandno = 0; bandno < reslevel->nbands ; bandno++){

1381 int bandpos = bandno + (reslevelno > 0);

1382 Jpeg2000Band *band = reslevel->band + bandno;

1383 Jpeg2000Prec *prec = band->prec + precno;

1384

1385 for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){

1386 Jpeg2000Cblk *cblk = prec->cblk + cblkno;

1387

1388 cblk->ninclpasses = getcut(cblk, s->lambda,

1389 (int64_t)dwt_norms[codsty->transform == FF_DWT53][bandpos][lev] * (int64_t)band->i_stepsize >> 15);

1390 cblk->layers[0].data_start = cblk->data;

1391 cblk->layers[0].cum_passes = cblk->ninclpasses;

1392 cblk->layers[0].npasses = cblk->ninclpasses;

1393 if (cblk->ninclpasses)

1394 cblk->layers[0].data_len = cblk->passes[cblk->ninclpasses - 1].rate;

1395 }

1396 }

1397 }

1398 }

1399 }

1400 }

1401

1402 static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)

1403 {

1404 int compno, reslevelno, bandno, ret;

1405 Jpeg2000T1Context t1;

1406 Jpeg2000CodingStyle *codsty = &s->codsty;

1407 for (compno = 0; compno < s->ncomponents; compno++){

1408 Jpeg2000Component *comp = s->tile[tileno].comp + compno;

1409

1410 t1.stride = (1<<codsty->log2_cblk_width) + 2;

1411

1412 av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");

1413 if ((ret = ff_dwt_encode(&comp->dwt, comp->i_data)) < 0)

1414 return ret;

1415 av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");

1416

1417 for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){

1418 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;

1419

1420 for (bandno = 0; bandno < reslevel->nbands ; bandno++){

1421 Jpeg2000Band *band = reslevel->band + bandno;

1422 Jpeg2000Prec *prec = band->prec; // we support only 1 precinct per band ATM in the encoder

1423 int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;

1424 yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];

1425 y0 = yy0;

1426 yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,

1427 band->coord[1][1]) - band->coord[1][0] + yy0;

1428

1429 if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])

1430 continue;

1431

1432 bandpos = bandno + (reslevelno > 0);

1433

1434 for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){

1435 if (reslevelno == 0 || bandno == 1)

1436 xx0 = 0;

1437 else

1438 xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];

1439 x0 = xx0;

1440 xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,

1441 band->coord[0][1]) - band->coord[0][0] + xx0;

1442

1443 for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){

1444 int y, x;

1445 if (codsty->transform == FF_DWT53){

1446 for (y = yy0; y < yy1; y++){

1447 int *ptr = t1.data + (y-yy0)*t1.stride;

1448 for (x = xx0; x < xx1; x++){

1449 *ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] * (1 << NMSEDEC_FRACBITS);

1450 }

1451 }

1452 } else{

1453 for (y = yy0; y < yy1; y++){

1454 int *ptr = t1.data + (y-yy0)*t1.stride;

1455 for (x = xx0; x < xx1; x++){

1456 *ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);

1457 *ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 15 - NMSEDEC_FRACBITS;

1458 ptr++;

1459 }

1460 }

1461 }

1462 if (!prec->cblk[cblkno].data)

1463 prec->cblk[cblkno].data = av_malloc(1 + 8192);

1464 if (!prec->cblk[cblkno].passes)

1465 prec->cblk[cblkno].passes = av_malloc_array(JPEG2000_MAX_PASSES, sizeof (*prec->cblk[cblkno].passes));

1466 if (!prec->cblk[cblkno].data || !prec->cblk[cblkno].passes)

1467 return AVERROR(ENOMEM);

1468 encode_cblk(s, &t1, prec->cblk + cblkno, tile, xx1 - xx0, yy1 - yy0,

1469 bandpos, codsty->nreslevels - reslevelno - 1);

1470 xx0 = xx1;

1471 xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);

1472 }

1473 yy0 = yy1;

1474 yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);

1475 }

1476 }

1477 }

1478 av_log(s->avctx, AV_LOG_DEBUG, "after tier1\n");

1479 }

1480

1481 av_log(s->avctx, AV_LOG_DEBUG, "rate control\n");

1482 if (s->compression_rate_enc)

1483 makelayers(s, tile);

1484 else

1485 truncpasses(s, tile);

1486

1487 if ((ret = encode_packets(s, tile, tileno, s->nlayers)) < 0)

1488 return ret;

1489 av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n");

1490 return 0;

1491 }

1492

1493 static void cleanup(Jpeg2000EncoderContext *s)

1494 {

1495 int tileno, compno;

1496 Jpeg2000CodingStyle *codsty = &s->codsty;

1497

1498 if (!s->tile)

1499 return;

1500 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){

1501 if (s->tile[tileno].comp) {

1502 for (compno = 0; compno < s->ncomponents; compno++){

1503 Jpeg2000Component *comp = s->tile[tileno].comp + compno;

1504 ff_jpeg2000_cleanup(comp, codsty);

1505 }

1506 av_freep(&s->tile[tileno].comp);

1507 }

1508 av_freep(&s->tile[tileno].layer_rates);

1509 }

1510 av_freep(&s->tile);

1511 }

1512

1513 static void reinit(Jpeg2000EncoderContext *s)

1514 {

1515 int tileno, compno;

1516 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){

1517 Jpeg2000Tile *tile = s->tile + tileno;

1518 for (compno = 0; compno < s->ncomponents; compno++)

1519 ff_jpeg2000_reinit(tile->comp + compno, &s->codsty);

1520 }

1521 }

1522

1523 static void update_size(uint8_t *size, const uint8_t *end)

1524 {

1525 AV_WB32(size, end-size);

1526 }

1527

1528 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

1529 const AVFrame *pict, int *got_packet)

1530 {

1531 int tileno, ret;

1532 Jpeg2000EncoderContext *s = avctx->priv_data;

1533 uint8_t *chunkstart, *jp2cstart, *jp2hstart;

1534

1535 if ((ret = ff_alloc_packet(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE)) < 0)

1536 return ret;

1537

1538 // init:

1539 s->buf = s->buf_start = pkt->data;

1540 s->buf_end = pkt->data + pkt->size;

1541

1542 s->picture = pict;

1543

1544 s->lambda = s->picture->quality * LAMBDA_SCALE;

1545

1546 if (avctx->pix_fmt == AV_PIX_FMT_BGR48 || avctx->pix_fmt == AV_PIX_FMT_GRAY16)

1547 copy_frame_16(s);

1548 else

1549 copy_frame_8(s);

1550

1551 reinit(s);

1552

1553 if (s->format == CODEC_JP2) {

1554 av_assert0(s->buf == pkt->data);

1555

1556 bytestream_put_be32(&s->buf, 0x0000000C);

1557 bytestream_put_be32(&s->buf, 0x6A502020);

1558 bytestream_put_be32(&s->buf, 0x0D0A870A);

1559

1560 chunkstart = s->buf;

1561 bytestream_put_be32(&s->buf, 0);

1562 bytestream_put_buffer(&s->buf, "ftyp", 4);

1563 bytestream_put_buffer(&s->buf, "jp2040円040円", 4);

1564 bytestream_put_be32(&s->buf, 0);

1565 bytestream_put_buffer(&s->buf, "jp2040円", 4);

1566 update_size(chunkstart, s->buf);

1567

1568 jp2hstart = s->buf;

1569 bytestream_put_be32(&s->buf, 0);

1570 bytestream_put_buffer(&s->buf, "jp2h", 4);

1571

1572 chunkstart = s->buf;

1573 bytestream_put_be32(&s->buf, 0);

1574 bytestream_put_buffer(&s->buf, "ihdr", 4);

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);

1582 update_size(chunkstart, s->buf);

1583

1584 chunkstart = s->buf;

1585 bytestream_put_be32(&s->buf, 0);

1586 bytestream_put_buffer(&s->buf, "colr", 4);

1587 bytestream_put_byte(&s->buf, 1);

1588 bytestream_put_byte(&s->buf, 0);

1589 bytestream_put_byte(&s->buf, 0);

1590 if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_PAL8) {

1591 bytestream_put_be32(&s->buf, 16);

1592 } else if (s->ncomponents == 1) {

1593 bytestream_put_be32(&s->buf, 17);

1594 } else {

1595 bytestream_put_be32(&s->buf, 18);

1596 }

1597 update_size(chunkstart, s->buf);

1598 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

1599 int i;

1600 uint8_t *palette = pict->data[1];

1601 chunkstart = s->buf;

1602 bytestream_put_be32(&s->buf, 0);

1603 bytestream_put_buffer(&s->buf, "pclr", 4);

1604 bytestream_put_be16(&s->buf, AVPALETTE_COUNT);

1605 bytestream_put_byte(&s->buf, 3); // colour channels

1606 bytestream_put_be24(&s->buf, 0x070707); //colour depths

1607 for (i = 0; i < AVPALETTE_COUNT; i++) {

1608 bytestream_put_be24(&s->buf, HAVE_BIGENDIAN ? AV_RB24(palette + 1) : AV_RL24(palette));

1609 palette += 4;

1610 }

1611 update_size(chunkstart, s->buf);

1612 chunkstart = s->buf;

1613 bytestream_put_be32(&s->buf, 0);

1614 bytestream_put_buffer(&s->buf, "cmap", 4);

1615 for (i = 0; i < 3; i++) {

1616 bytestream_put_be16(&s->buf, 0); // component

1617 bytestream_put_byte(&s->buf, 1); // palette mapping

1618 bytestream_put_byte(&s->buf, i); // index

1619 }

1620 update_size(chunkstart, s->buf);

1621 }

1622 update_size(jp2hstart, s->buf);

1623

1624 jp2cstart = s->buf;

1625 bytestream_put_be32(&s->buf, 0);

1626 bytestream_put_buffer(&s->buf, "jp2c", 4);

1627 }

1628

1629 if (s->buf_end - s->buf < 2)

1630 return -1;

1631 bytestream_put_be16(&s->buf, JPEG2000_SOC);

1632 if ((ret = put_siz(s)) < 0)

1633 return ret;

1634 if ((ret = put_cod(s)) < 0)

1635 return ret;

1636 if ((ret = put_qcd(s, 0)) < 0)

1637 return ret;

1638 if ((ret = put_com(s, 0)) < 0)

1639 return ret;

1640

1641 for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){

1642 uint8_t *psotptr;

1643 if (!(psotptr = put_sot(s, tileno)))

1644 return -1;

1645 if (s->buf_end - s->buf < 2)

1646 return -1;

1647 bytestream_put_be16(&s->buf, JPEG2000_SOD);

1648 if ((ret = encode_tile(s, s->tile + tileno, tileno)) < 0)

1649 return ret;

1650 bytestream_put_be32(&psotptr, s->buf - psotptr + 6);

1651 }

1652 if (s->buf_end - s->buf < 2)

1653 return -1;

1654 bytestream_put_be16(&s->buf, JPEG2000_EOC);

1655

1656 if (s->format == CODEC_JP2)

1657 update_size(jp2cstart, s->buf);

1658

1659 av_log(s->avctx, AV_LOG_DEBUG, "end\n");

1660 pkt->size = s->buf - s->buf_start;

1661 *got_packet = 1;

1662

1663 return 0;

1664 }

1665

1666 static int parse_layer_rates(Jpeg2000EncoderContext *s)

1667 {

1668 int i;

1669 char *token;

1670 char *saveptr = NULL;

1671 int rate;

1672 int nlayers = 0;

1673 if (!s->lr_str) {

1674 s->nlayers = 1;

1675 s->layer_rates[0] = 0;

1676 s->compression_rate_enc = 0;

1677 return 0;

1678 }

1679

1680 token = av_strtok(s->lr_str, ",", &saveptr);

1681 if (token && (rate = strtol(token, NULL, 10))) {

1682 s->layer_rates[0] = rate <= 1 ? 0:rate;

1683 nlayers++;

1684 } else {

1685 return AVERROR_INVALIDDATA;

1686 }

1687

1688 while (1) {

1689 token = av_strtok(NULL, ",", &saveptr);

1690 if (!token)

1691 break;

1692 if (rate = strtol(token, NULL, 10)) {

1693 if (nlayers >= 100) {

1694 return AVERROR_INVALIDDATA;

1695 }

1696 s->layer_rates[nlayers] = rate <= 1 ? 0:rate;

1697 nlayers++;

1698 } else {

1699 return AVERROR_INVALIDDATA;

1700 }

1701 }

1702

1703 for (i = 1; i < nlayers; i++) {

1704 if (s->layer_rates[i] >= s->layer_rates[i-1]) {

1705 return AVERROR_INVALIDDATA;

1706 }

1707 }

1708 s->nlayers = nlayers;

1709 s->compression_rate_enc = 1;

1710 return 0;

1711 }

1712

1713 static av_cold int j2kenc_init(AVCodecContext *avctx)

1714 {

1715 static AVOnce init_static_once = AV_ONCE_INIT;

1716 int i, ret;

1717 Jpeg2000EncoderContext *s = avctx->priv_data;

1718 Jpeg2000CodingStyle *codsty = &s->codsty;

1719 Jpeg2000QuantStyle *qntsty = &s->qntsty;

1720

1721 s->avctx = avctx;

1722 av_log(s->avctx, AV_LOG_DEBUG, "init\n");

1723 if (parse_layer_rates(s)) {

1724 av_log(s, AV_LOG_WARNING, "Layer rates invalid. Encoding with 1 layer based on quality metric.\n");

1725 s->nlayers = 1;

1726 s->layer_rates[0] = 0;

1727 s->compression_rate_enc = 0;

1728 }

1729

1730 if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && (s->pred != FF_DWT97_INT || s->format != CODEC_JP2)) {

1731 av_log(s->avctx, AV_LOG_WARNING, "Forcing lossless jp2 for pal8\n");

1732 s->pred = FF_DWT97_INT;

1733 s->format = CODEC_JP2;

1734 }

1735

1736 // defaults:

1737 // TODO: implement setting non-standard precinct size

1738 memset(codsty->log2_prec_widths , 15, sizeof(codsty->log2_prec_widths ));

1739 memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights));

1740 codsty->nreslevels2decode=

1741 codsty->nreslevels = 7;

1742 codsty->nlayers = s->nlayers;

1743 codsty->log2_cblk_width = 4;

1744 codsty->log2_cblk_height = 4;

1745 codsty->transform = s->pred ? FF_DWT53 : FF_DWT97_INT;

1746

1747 qntsty->nguardbits = 1;

1748

1749 if ((s->tile_width & (s->tile_width -1)) ||

1750 (s->tile_height & (s->tile_height-1))) {

1751 av_log(avctx, AV_LOG_WARNING, "Tile dimension not a power of 2\n");

1752 }

1753

1754 if (codsty->transform == FF_DWT53)

1755 qntsty->quantsty = JPEG2000_QSTY_NONE;

1756 else

1757 qntsty->quantsty = JPEG2000_QSTY_SE;

1758

1759 s->width = avctx->width;

1760 s->height = avctx->height;

1761

1762 for (i = 0; i < 3; i++) {

1763 if (avctx->pix_fmt == AV_PIX_FMT_GRAY16 || avctx->pix_fmt == AV_PIX_FMT_RGB48)

1764 s->cbps[i] = 16;

1765 else

1766 s->cbps[i] = 8;

1767 }

1768

1769 if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_RGB48){

1770 s->ncomponents = 3;

1771 } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16){

1772 s->ncomponents = 1;

1773 } else{ // planar YUV

1774 s->planar = 1;

1775 s->ncomponents = 3;

1776 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,

1777 s->chroma_shift, s->chroma_shift + 1);

1778 if (ret)

1779 return ret;

1780 }

1781

1782 ff_thread_once(&init_static_once, init_luts);

1783

1784 init_quantization(s);

1785 if ((ret=init_tiles(s)) < 0)

1786 return ret;

1787

1788 av_log(s->avctx, AV_LOG_DEBUG, "after init\n");

1789

1790 return 0;

1791 }

1792

1793 static int j2kenc_destroy(AVCodecContext *avctx)

1794 {

1795 Jpeg2000EncoderContext *s = avctx->priv_data;

1796

1797 cleanup(s);

1798 return 0;

1799 }

1800

1801 // taken from the libopenjpeg wraper so it matches

1802

1803 #define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)

1804 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

1805 static const AVOption options[] = {

1806 { "format", "Codec Format", OFFSET(format), AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2, VE, "format" },

1807 { "j2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K }, 0, 0, VE, "format" },

1808 { "jp2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2 }, 0, 0, VE, "format" },

1809 { "tile_width", "Tile Width", OFFSET(tile_width), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },

1810 { "tile_height", "Tile Height", OFFSET(tile_height), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },

1811 { "pred", "DWT Type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "pred" },

1812 { "dwt97int", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },

1813 { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },

1814 { "sop", "SOP marker", OFFSET(sop), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },

1815 { "eph", "EPH marker", OFFSET(eph), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },

1816 { "prog", "Progression Order", OFFSET(prog), AV_OPT_TYPE_INT, { .i64 = 0 }, JPEG2000_PGOD_LRCP, JPEG2000_PGOD_CPRL, VE, "prog" },

1817 { "lrcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_LRCP }, 0, 0, VE, "prog" },

1818 { "rlcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RLCP }, 0, 0, VE, "prog" },

1819 { "rpcl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RPCL }, 0, 0, VE, "prog" },

1820 { "pcrl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_PCRL }, 0, 0, VE, "prog" },

1821 { "cprl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_CPRL }, 0, 0, VE, "prog" },

1822 { "layer_rates", "Layer Rates", OFFSET(lr_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },

1823 { NULL }

1824 };

1825

1826 static const AVClass j2k_class = {

1827 .class_name = "jpeg 2000 encoder",

1828 .item_name = av_default_item_name,

1829 .option = options,

1830 .version = LIBAVUTIL_VERSION_INT,

1831 };

1832

1833 const FFCodec ff_jpeg2000_encoder = {

1834 .p.name = "jpeg2000",

1835 .p.long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),

1836 .p.type = AVMEDIA_TYPE_VIDEO,

1837 .p.id = AV_CODEC_ID_JPEG2000,

1838 .priv_data_size = sizeof(Jpeg2000EncoderContext),

1839 .init = j2kenc_init,

1840 FF_CODEC_ENCODE_CB(encode_frame),

1841 .close = j2kenc_destroy,

1842 .p.pix_fmts = (const enum AVPixelFormat[]) {

1843 AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GRAY8,

1844 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,

1845 AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,

1846 AV_PIX_FMT_PAL8,

1847 AV_PIX_FMT_RGB48, AV_PIX_FMT_GRAY16,

1848 AV_PIX_FMT_NONE

1849 },

1850 .p.priv_class = &j2k_class,

1851 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

1852 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

Jpeg2000Tile::layer_rates

double * layer_rates

Definition: j2kenc.c:108

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

tag_tree_code

static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)

code the value stored in node

Definition: j2kenc.c:252

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:39

makelayer

static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile *tile, int final)

Definition: j2kenc.c:1184

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

Jpeg2000QuantStyle::quantsty

uint8_t quantsty

Definition: jpeg2000.h:154

LIBAVCODEC_IDENT

#define LIBAVCODEC_IDENT

Definition: version.h:43

JPEG2000_EOC

@ JPEG2000_EOC

Definition: jpeg2000.h:58

options

static const AVOption options[]

Definition: j2kenc.c:1805

comp

static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)

Definition: eamad.c:86

Jpeg2000EncoderContext::buf

uint8_t * buf

Definition: j2kenc.c:125

ff_jpeg2000_init_component

int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)

Definition: jpeg2000.c:466

thread.h

JPEG2000_QSTY_NONE

@ JPEG2000_QSTY_NONE

Definition: jpeg2000.h:65

Jpeg2000Layer::disto

double disto

Definition: jpeg2000.h:169

Jpeg2000EncoderContext::bit_index

int bit_index

Definition: j2kenc.c:127

j2kenc_init

static av_cold int j2kenc_init(AVCodecContext *avctx)

Definition: j2kenc.c:1713

JPEG2000_QCD

@ JPEG2000_QCD

Definition: jpeg2000.h:46

Jpeg2000Prec::nb_codeblocks_height

int nb_codeblocks_height

Definition: jpeg2000.h:194

Jpeg2000Band::i_stepsize

int i_stepsize

Definition: jpeg2000.h:205

JPEG2000_SOP

@ JPEG2000_SOP

Definition: jpeg2000.h:55

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:325

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:221

pixdesc.h

Jpeg2000Layer::cum_passes

int cum_passes

Definition: jpeg2000.h:170

compute_rates

static void compute_rates(Jpeg2000EncoderContext *s)

Definition: j2kenc.c:424

AVPacket::data

uint8_t * data

Definition: packet.h:374

Jpeg2000Layer::data_len

int data_len

Definition: jpeg2000.h:167

j2k_class

static const AVClass j2k_class

Definition: j2kenc.c:1826

Jpeg2000Prec::zerobits

Jpeg2000TgtNode * zerobits

Definition: jpeg2000.h:195

CODEC_J2K

#define CODEC_J2K

Definition: j2kenc.c:87

AVOption

AVOption.

Definition: opt.h:251

encode.h

JPEG2000_SOD

@ JPEG2000_SOD

Definition: jpeg2000.h:57

JPEG2000_SOC

@ JPEG2000_SOC

Definition: jpeg2000.h:39

ff_dwt_encode

int ff_dwt_encode(DWTContext *s, void *t)

Definition: jpeg2000dwt.c:580

ff_jpeg2000_ceildiv

static int ff_jpeg2000_ceildiv(int a, int64_t b)

Definition: jpeg2000.h:234

FFCodec

Definition: codec_internal.h:112

version.h

Jpeg2000Prec

Definition: jpeg2000.h:192

float.h

JPEG2000_SOT

@ JPEG2000_SOT

Definition: jpeg2000.h:54

Jpeg2000TgtNode::parent

struct Jpeg2000TgtNode * parent

Definition: jpeg2000.h:132

Jpeg2000Band

Definition: jpeg2000.h:202

#define t1

Definition: regdef.h:29

Jpeg2000EncoderContext::lambda

int64_t lambda

Definition: j2kenc.c:129

encode_frame

static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)

Definition: j2kenc.c:1528

max

#define max(a, b)

Definition: cuda_runtime.h:33

Jpeg2000Pass::rate

uint16_t rate

Definition: jpeg2000.h:159

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

JPEG2000_CSTY_SOP

#define JPEG2000_CSTY_SOP

Definition: jpeg2000.h:111

LAMBDA_SCALE

#define LAMBDA_SCALE

Definition: j2kenc.c:84

Jpeg2000Tile

Definition: j2kenc.c:106

ff_jpeg2000_getrefctxno

static int ff_jpeg2000_getrefctxno(int flag)

Definition: jpeg2000.h:262

Jpeg2000Pass::flushed_len

int flushed_len

Definition: jpeg2000.h:162

j2kenc_destroy

static int j2kenc_destroy(AVCodecContext *avctx)

Definition: j2kenc.c:1793

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:346

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

Jpeg2000Cblk::incl

uint8_t incl

Definition: jpeg2000.h:177

init

static int init

Definition: av_tx.c:47

bit

#define bit(string, value)

Definition: cbs_mpeg2.c:58

tag_tree_update

static void tag_tree_update(Jpeg2000TgtNode *node)

update the value in node

Definition: j2kenc.c:289

Jpeg2000EncoderContext::lr_str

char * lr_str

Definition: j2kenc.c:144

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

Jpeg2000CodingStyle::log2_cblk_width

uint8_t log2_cblk_width

Definition: jpeg2000.h:138

#define U(x)

Definition: vp56_arith.h:37

Jpeg2000EncoderContext::buf_end

uint8_t * buf_end

Definition: j2kenc.c:126

Jpeg2000Cblk::passes

Jpeg2000Pass * passes

Definition: jpeg2000.h:187

Jpeg2000CodingStyle::log2_prec_heights

uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]

Definition: jpeg2000.h:147

val

static double val(void *priv, double ch)

Definition: aeval.c:77

av_pix_fmt_get_chroma_sub_sample

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.

Definition: pixdesc.c:2690

scale

static av_always_inline float scale(float x, float s)

Definition: vf_v360.c:1389

MQC_CX_UNI

#define MQC_CX_UNI

Definition: mqc.h:33

AV_PIX_FMT_GRAY16

#define AV_PIX_FMT_GRAY16

Definition: pixfmt.h:390

j2k_flush

static void j2k_flush(Jpeg2000EncoderContext *s)

flush the bitstream

Definition: j2kenc.c:241

Jpeg2000EncoderContext::numYtiles

int numYtiles

Definition: j2kenc.c:122

#define ss(width, name, subs,...)

Definition: cbs_vp9.c:260

put_cod

static int put_cod(Jpeg2000EncoderContext *s)

Definition: j2kenc.c:328

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:263

Jpeg2000T1Context

Definition: jpeg2000.h:121

ceil

static __device__ float ceil(float a)

Definition: cuda_runtime.h:176

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:179

pkt

AVPacket * pkt

Definition: movenc.c:59

Jpeg2000ResLevel

Definition: jpeg2000.h:210

av_cold

#define av_cold

Definition: attributes.h:90

mask

static const uint16_t mask[17]

Definition: lzw.c:38

Jpeg2000Pass::disto

int64_t disto

Definition: jpeg2000.h:160

Jpeg2000QuantStyle::nguardbits

uint8_t nguardbits

Definition: jpeg2000.h:155

init_luts

static void init_luts(void)

Definition: j2kenc.c:580

Jpeg2000Tile::comp

Jpeg2000Component * comp

Definition: j2kenc.c:107

width

#define width

intreadwrite.h

Jpeg2000CodingStyle::transform

uint8_t transform

Definition: jpeg2000.h:140

#define s(width, name)

Definition: cbs_vp9.c:256

Jpeg2000Cblk::layers

Jpeg2000Layer * layers

Definition: jpeg2000.h:188

lut_nmsedec_sig0

static int lut_nmsedec_sig0[1<< NMSEDEC_BITS]

Definition: j2kenc.c:92

Jpeg2000ResLevel::band

Jpeg2000Band * band

Definition: jpeg2000.h:215

format

getcut

static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)

Definition: j2kenc.c:1350

jpeg2000.h

Jpeg2000EncoderContext::eph

int eph

Definition: j2kenc.c:141

Jpeg2000EncoderContext::nlayers

int nlayers

Definition: j2kenc.c:143

av_strtok

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().

Definition: avstring.c:189

JPEG2000_PGOD_RPCL

#define JPEG2000_PGOD_RPCL

Definition: jpeg2000.h:117

Jpeg2000Cblk::data

uint8_t * data

Definition: jpeg2000.h:182

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

Jpeg2000Band::coord

int coord[2][2]

Definition: jpeg2000.h:203

Jpeg2000EncoderContext::planar

uint8_t planar

Definition: j2kenc.c:119

#define xi(width, name, var, range_min, range_max, subs,...)

Definition: cbs_h2645.c:402

encode_sigpass

static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)

Definition: j2kenc.c:613

AV_INPUT_BUFFER_MIN_SIZE

#define AV_INPUT_BUFFER_MIN_SIZE

Definition: avcodec.h:191

encode_packet

static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno, int precno, uint8_t *expn, int numgbits, int packetno, int nlayers)

Definition: j2kenc.c:782

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

JPEG2000_PGOD_CPRL

#define JPEG2000_PGOD_CPRL

Definition: jpeg2000.h:119

JPEG2000_COM

@ JPEG2000_COM

Definition: jpeg2000.h:53

pass

#define pass

Definition: fft_template.c:608

Jpeg2000Cblk::lblock

uint8_t lblock

Definition: jpeg2000.h:181

Jpeg2000CodingStyle::log2_prec_widths

uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]

Definition: jpeg2000.h:146

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:177

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

makelayers

static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)

Definition: j2kenc.c:1267

AV_PIX_FMT_BGR48

#define AV_PIX_FMT_BGR48

Definition: pixfmt.h:397

NULL

#define NULL

Definition: coverity.c:32

put_num

static void put_num(Jpeg2000EncoderContext *s, int num, int n)

put n least significant bits of a number num

Definition: j2kenc.c:234

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

Jpeg2000EncoderContext::sop

int sop

Definition: j2kenc.c:140

Jpeg2000EncoderContext::codsty

Jpeg2000CodingStyle codsty

Definition: j2kenc.c:131

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

Jpeg2000Band::prec

Jpeg2000Prec * prec

Definition: jpeg2000.h:207

JPEG2000_T1_VIS

#define JPEG2000_T1_VIS

Definition: jpeg2000.h:95

Jpeg2000Layer::npasses

int npasses

Definition: jpeg2000.h:168

double

Definition: af_crystalizer.c:132

Jpeg2000ResLevel::num_precincts_y

int num_precincts_y

Definition: jpeg2000.h:213

JPEG2000_EPH

@ JPEG2000_EPH

Definition: jpeg2000.h:56

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:74

Jpeg2000Band::log2_cblk_height

uint16_t log2_cblk_height

Definition: jpeg2000.h:204

AVOnce

#define AVOnce

Definition: thread.h:176

AVPALETTE_COUNT

#define AVPALETTE_COUNT

Definition: pixfmt.h:33

truncpasses

static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)

Definition: j2kenc.c:1368

Jpeg2000EncoderContext::format

int format

Definition: j2kenc.c:138

getnmsedec_sig

static int getnmsedec_sig(int x, int bpno)

Definition: j2kenc.c:599

JPEG2000_T1_SIG_NB

#define JPEG2000_T1_SIG_NB

Definition: jpeg2000.h:85

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:419

Jpeg2000Prec::nb_codeblocks_width

int nb_codeblocks_width

Definition: jpeg2000.h:193

JPEG2000_T1_SGN

#define JPEG2000_T1_SGN

Definition: jpeg2000.h:99

Jpeg2000ResLevel::log2_prec_height

uint8_t log2_prec_height

Definition: jpeg2000.h:214

ff_jpeg2000_cleanup

void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)

Definition: jpeg2000.c:597

getnmsedec_ref

static int getnmsedec_ref(int x, int bpno)

Definition: j2kenc.c:606

Jpeg2000Component

Definition: jpeg2000.h:218

AV_PIX_FMT_RGB24

@ AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:68

Jpeg2000Prec::cblkincl

Jpeg2000TgtNode * cblkincl

Definition: jpeg2000.h:196

encode_clnpass

static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)

Definition: j2kenc.c:649

Jpeg2000EncoderContext::picture

const AVFrame * picture

Definition: j2kenc.c:114

AVPacket::size

int size

Definition: packet.h:375

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

codec_internal.h

encode_tile

static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)

Definition: j2kenc.c:1402

Jpeg2000ResLevel::nbands

uint8_t nbands

Definition: jpeg2000.h:211

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

#define sp

Definition: regdef.h:63

AV_PIX_FMT_RGB48

#define AV_PIX_FMT_RGB48

Definition: pixfmt.h:392

size

int size

Definition: twinvq_data.h:10344

Jpeg2000Cblk

Definition: jpeg2000.h:173

COPY_FRAME

#define COPY_FRAME(D, PIXEL)

Definition: j2kenc.c:506

Jpeg2000Cblk::ninclpasses

uint8_t ninclpasses

Definition: jpeg2000.h:175

NMSEDEC_FRACBITS

#define NMSEDEC_FRACBITS

Definition: j2kenc.c:82

AV_RL24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24

Definition: bytestream.h:93

height

#define height

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

JPEG2000_COD

@ JPEG2000_COD

Definition: jpeg2000.h:41

ff_jpeg2000_getsgnctxno

static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)

Definition: jpeg2000.h:271

JPEG2000_PGOD_LRCP

#define JPEG2000_PGOD_LRCP

Definition: jpeg2000.h:115

Jpeg2000TgtNode

Definition: jpeg2000.h:128

OFFSET

#define OFFSET(x)

Definition: j2kenc.c:1803

Jpeg2000CodingStyle::nlayers

uint8_t nlayers

Definition: jpeg2000.h:142

reinit

static void reinit(Jpeg2000EncoderContext *s)

Definition: j2kenc.c:1513

Jpeg2000CodingStyle::nreslevels

int nreslevels

Definition: jpeg2000.h:136

ff_jpeg2000_reinit

void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)

Definition: jpeg2000.c:576

Jpeg2000TgtNode::temp_val

uint8_t temp_val

Definition: jpeg2000.h:130

Jpeg2000Pass

Definition: jpeg2000.h:158

bytestream_put_buffer

static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)

Definition: bytestream.h:372

Jpeg2000CodingStyle::log2_cblk_height

uint8_t log2_cblk_height

Definition: jpeg2000.h:139

put_sot

static uint8_t * put_sot(Jpeg2000EncoderContext *s, int tileno)

Definition: j2kenc.c:405

JPEG2000_PGOD_RLCP

#define JPEG2000_PGOD_RLCP

Definition: jpeg2000.h:116

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

parse_layer_rates

static int parse_layer_rates(Jpeg2000EncoderContext *s)

Definition: j2kenc.c:1666

Jpeg2000ResLevel::num_precincts_x

int num_precincts_x

Definition: jpeg2000.h:213

JPEG2000_T1_REF

#define JPEG2000_T1_REF

Definition: jpeg2000.h:97

cleanup

static void cleanup(Jpeg2000EncoderContext *s)

Definition: j2kenc.c:1493

Jpeg2000QuantStyle::expn

uint8_t expn[JPEG2000_MAX_DECLEVELS *3]

Definition: jpeg2000.h:152

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

dwt_norms

static const int dwt_norms[2][4][10]

Definition: j2kenc.c:94

common.h

Jpeg2000Layer

Definition: jpeg2000.h:165

encode_cblk

static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile, int width, int height, int bandpos, int lev)

Definition: j2kenc.c:704

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: codec_internal.h:31

ff_mqc_initenc

void ff_mqc_initenc(MqcState *mqc, uint8_t *bp)

initialize the encoder

Definition: mqcenc.c:71

JPEG2000_SIZ

@ JPEG2000_SIZ

Definition: jpeg2000.h:40

Jpeg2000Band::log2_cblk_width

uint16_t log2_cblk_width

Definition: jpeg2000.h:204

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

ff_jpeg2000_getsigctxno

static int ff_jpeg2000_getsigctxno(int flag, int bandno)

Definition: jpeg2000.h:253

encode_packets

static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)

Definition: j2kenc.c:938

WMSEDEC_SHIFT

#define WMSEDEC_SHIFT

must be >= 13

Definition: j2kenc.c:83

lev

static LevelCodes lev[4+3+3]

Definition: clearvideo.c:86

AV_CODEC_ID_JPEG2000

@ AV_CODEC_ID_JPEG2000

Definition: codec_id.h:138

AVCodecContext::height

int height

Definition: avcodec.h:562

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:599

JPEG2000_MAX_PASSES

#define JPEG2000_MAX_PASSES

Definition: jpeg2000.h:73

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:272

Jpeg2000EncoderContext::compression_rate_enc

uint8_t compression_rate_enc

Is compression done using compression ratio?

Definition: j2kenc.c:136

Jpeg2000EncoderContext::tile_width

int tile_width

Definition: j2kenc.c:121

lut_nmsedec_ref

static int lut_nmsedec_ref[1<< NMSEDEC_BITS]

Definition: j2kenc.c:89

Jpeg2000EncoderContext::width

int width

Definition: j2kenc.c:116

Jpeg2000QuantStyle::mant

uint16_t mant[JPEG2000_MAX_DECLEVELS *3]

Definition: jpeg2000.h:153

avcodec.h

JPEG2000_T1_SIG

#define JPEG2000_T1_SIG

Definition: jpeg2000.h:96

AV_PIX_FMT_PAL8

@ AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:77

ff_jpeg2000_encoder

const FFCodec ff_jpeg2000_encoder

Definition: j2kenc.c:1833

ret

Definition: filter_design.txt:187

put_qcd

static int put_qcd(Jpeg2000EncoderContext *s, int compno)

Definition: j2kenc.c:360

pred

static const float pred[4]

Definition: siprdata.h:259

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

JPEG2000_QSTY_SE

@ JPEG2000_QSTY_SE

Definition: jpeg2000.h:67

NMSEDEC_BITS

#define NMSEDEC_BITS

Definition: j2kenc.c:81

Jpeg2000EncoderContext::buf_start

uint8_t * buf_start

Definition: j2kenc.c:124

encode_refpass

static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)

Definition: j2kenc.c:635

Jpeg2000Layer::data_start

uint8_t * data_start

Definition: jpeg2000.h:166

Jpeg2000Pass::flushed

uint8_t flushed[4]

Definition: jpeg2000.h:161

pos

unsigned int pos

Definition: spdifenc.c:412

Jpeg2000EncoderContext::prog

int prog

Definition: j2kenc.c:142

lut_nmsedec_sig

static int lut_nmsedec_sig[1<< NMSEDEC_BITS]

Definition: j2kenc.c:91

MQC_CX_RL

#define MQC_CX_RL

Definition: mqc.h:34

Jpeg2000Component::coord

int coord[2][2]

Definition: jpeg2000.h:223

AVCodecContext

main external API structure.

Definition: avcodec.h:389

FF_DWT53

@ FF_DWT53

Definition: jpeg2000dwt.h:38

ff_jpeg2000_ceildivpow2

static int ff_jpeg2000_ceildivpow2(int a, int b)

Definition: jpeg2000.h:229

put_siz

static int put_siz(Jpeg2000EncoderContext *s)

Definition: j2kenc.c:299

CODEC_JP2

#define CODEC_JP2

Definition: j2kenc.c:86

Jpeg2000ResLevel::log2_prec_width

uint8_t log2_prec_width

Definition: jpeg2000.h:214

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:225

ff_jpeg2000_init_tier1_luts

void av_cold ff_jpeg2000_init_tier1_luts(void)

Definition: jpeg2000.c:173

JPEG2000_CSTY_EPH

#define JPEG2000_CSTY_EPH

Definition: jpeg2000.h:112

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:71

Jpeg2000EncoderContext::pred

int pred

Definition: j2kenc.c:139

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

Jpeg2000EncoderContext::qntsty

Jpeg2000QuantStyle qntsty

Definition: j2kenc.c:132

AV_PIX_FMT_YUV422P

@ AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:70

#define VE

Definition: j2kenc.c:1804

put_com

static int put_com(Jpeg2000EncoderContext *s, int compno)

Definition: j2kenc.c:386

JPEG2000_PGOD_PCRL

#define JPEG2000_PGOD_PCRL

Definition: jpeg2000.h:118

AV_CODEC_FLAG_BITEXACT

#define AV_CODEC_FLAG_BITEXACT

Use only bitexact stuff (except (I)DCT).

Definition: avcodec.h:278

ff_mqc_flush_to

int ff_mqc_flush_to(MqcState *mqc, uint8_t *dst, int *dst_len)

flush the encoder [returns number of bytes encoded]

Definition: mqcenc.c:119

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:36

putnumpasses

static void putnumpasses(Jpeg2000EncoderContext *s, int n)

Definition: j2kenc.c:767

Jpeg2000Cblk::npasses

uint8_t npasses

Definition: jpeg2000.h:174

Jpeg2000CodingStyle::nreslevels2decode

int nreslevels2decode

Definition: jpeg2000.h:137

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:416

AVPacket

This structure stores compressed data.

Definition: packet.h:351

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

ff_jpeg2000_set_significance

void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)

Definition: jpeg2000.c:179

AV_PIX_FMT_YUV411P

@ AV_PIX_FMT_YUV411P

planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)

Definition: pixfmt.h:73

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:562

int32_t

Definition: audioconvert.c:56

bytestream.h

Jpeg2000TgtNode::val

uint8_t val

Definition: jpeg2000.h:129

AV_PIX_FMT_YUV410P

@ AV_PIX_FMT_YUV410P

planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)

Definition: pixfmt.h:72

update_size

static void update_size(uint8_t *size, const uint8_t *end)

Definition: j2kenc.c:1523

Jpeg2000TgtNode::vis

uint8_t vis

Definition: jpeg2000.h:131

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

Jpeg2000CodingStyle

Definition: jpeg2000.h:135

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

Jpeg2000QuantStyle

Definition: jpeg2000.h:151

avstring.h

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Definition: opt.h:229

Jpeg2000Cblk::nonzerobits

uint8_t nonzerobits

Definition: jpeg2000.h:176

Jpeg2000Prec::cblk

Jpeg2000Cblk * cblk

Definition: jpeg2000.h:197

AV_RB24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:97

Jpeg2000EncoderContext::avctx

AVCodecContext * avctx

Definition: j2kenc.c:113

ff_mqc_encode

void ff_mqc_encode(MqcState *mqc, uint8_t *cxstate, int d)

code bit d with context cx

Definition: mqcenc.c:81

ff_tag_tree_zero

void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)

Definition: jpeg2000.c:86

AV_OPT_TYPE_CONST