FFmpeg: libavcodec/libopenjpegenc.c Source File

FFmpeg

[フレーム]

libavcodec

libopenjpegenc.c

Go to the documentation of this file.

1 /*

2 * JPEG 2000 encoding support via OpenJPEG

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 */

22 /**

23 * @file

24 * JPEG 2000 encoder using libopenjpeg

25 */

27 #define OPJ_STATIC

29 #include "libavutil/avassert.h"

30 #include "libavutil/common.h"

31 #include "libavutil/imgutils.h"

32 #include "libavutil/intreadwrite.h"

33 #include "libavutil/opt.h"

34 #include "avcodec.h"

35 #include "internal.h"

37 #if HAVE_OPENJPEG_1_5_OPENJPEG_H

38 # include <openjpeg-1.5/openjpeg.h>

39 #else

40 # include <openjpeg.h>

41 #endif

43 typedef struct LibOpenJPEGContext {

44 AVClass *avclass;

45 opj_image_t *image;

46 opj_cparameters_t enc_params;

47 opj_event_mgr_t event_mgr;

48 int format;

49 int profile;

50 int prog_order;

51 int cinema_mode;

52 int numresolution;

53 int numlayers;

54 int disto_alloc;

55 int fixed_alloc;

56 int fixed_quality;

57 } LibOpenJPEGContext;

59 static void error_callback(const char *msg, void *data)

60 {

61 av_log(data, AV_LOG_ERROR, "%s\n", msg);

62 }

64 static void warning_callback(const char *msg, void *data)

65 {

66 av_log(data, AV_LOG_WARNING, "%s\n", msg);

67 }

69 static void info_callback(const char *msg, void *data)

70 {

71 av_log(data, AV_LOG_DEBUG, "%s\n", msg);

72 }

74 static void cinema_parameters(opj_cparameters_t *p)

75 {

76 p->tile_size_on = 0;

77 p->cp_tdx = 1;

78 p->cp_tdy = 1;

80 /* Tile part */

81 p->tp_flag = 'C';

82 p->tp_on = 1;

84 /* Tile and Image shall be at (0, 0) */

85 p->cp_tx0 = 0;

86 p->cp_ty0 = 0;

87 p->image_offset_x0 = 0;

88 p->image_offset_y0 = 0;

90 /* Codeblock size= 32 * 32 */

91 p->cblockw_init = 32;

92 p->cblockh_init = 32;

93 p->csty |= 0x01;

95 /* The progression order shall be CPRL */

96 p->prog_order = CPRL;

98 /* No ROI */

99 p->roi_compno = -1;

100

101 /* No subsampling */

102 p->subsampling_dx = 1;

103 p->subsampling_dy = 1;

104

105 /* 9-7 transform */

106 p->irreversible = 1;

107

108 p->tcp_mct = 1;

109 }

110

111 static opj_image_t *mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *parameters)

112 {

113 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

114 opj_image_cmptparm_t cmptparm[4] = {{0}};

115 opj_image_t *img;

116 int i;

117 int sub_dx[4];

118 int sub_dy[4];

119 int numcomps;

120 OPJ_COLOR_SPACE color_space = CLRSPC_UNKNOWN;

121

122 sub_dx[0] = sub_dx[3] = 1;

123 sub_dy[0] = sub_dy[3] = 1;

124 sub_dx[1] = sub_dx[2] = 1 << desc->log2_chroma_w;

125 sub_dy[1] = sub_dy[2] = 1 << desc->log2_chroma_h;

126

127 numcomps = desc->nb_components;

128

129 switch (avctx->pix_fmt) {

130 case AV_PIX_FMT_GRAY8:

131 case AV_PIX_FMT_YA8:

132 case AV_PIX_FMT_GRAY16:

133 case AV_PIX_FMT_YA16:

134 color_space = CLRSPC_GRAY;

135 break;

136 case AV_PIX_FMT_RGB24:

137 case AV_PIX_FMT_RGBA:

138 case AV_PIX_FMT_RGB48:

139 case AV_PIX_FMT_RGBA64:

140 case AV_PIX_FMT_GBR24P:

141 case AV_PIX_FMT_GBRP9:

142 case AV_PIX_FMT_GBRP10:

143 case AV_PIX_FMT_GBRP12:

144 case AV_PIX_FMT_GBRP14:

145 case AV_PIX_FMT_GBRP16:

146 case AV_PIX_FMT_XYZ12:

147 color_space = CLRSPC_SRGB;

148 break;

149 case AV_PIX_FMT_YUV410P:

150 case AV_PIX_FMT_YUV411P:

151 case AV_PIX_FMT_YUV420P:

152 case AV_PIX_FMT_YUV422P:

153 case AV_PIX_FMT_YUV440P:

154 case AV_PIX_FMT_YUV444P:

155 case AV_PIX_FMT_YUVA420P:

156 case AV_PIX_FMT_YUVA422P:

157 case AV_PIX_FMT_YUVA444P:

158 case AV_PIX_FMT_YUV420P9:

159 case AV_PIX_FMT_YUV422P9:

160 case AV_PIX_FMT_YUV444P9:

161 case AV_PIX_FMT_YUVA420P9:

162 case AV_PIX_FMT_YUVA422P9:

163 case AV_PIX_FMT_YUVA444P9:

164 case AV_PIX_FMT_YUV420P10:

165 case AV_PIX_FMT_YUV422P10:

166 case AV_PIX_FMT_YUV444P10:

167 case AV_PIX_FMT_YUVA420P10:

168 case AV_PIX_FMT_YUVA422P10:

169 case AV_PIX_FMT_YUVA444P10:

170 case AV_PIX_FMT_YUV420P12:

171 case AV_PIX_FMT_YUV422P12:

172 case AV_PIX_FMT_YUV444P12:

173 case AV_PIX_FMT_YUV420P14:

174 case AV_PIX_FMT_YUV422P14:

175 case AV_PIX_FMT_YUV444P14:

176 case AV_PIX_FMT_YUV420P16:

177 case AV_PIX_FMT_YUV422P16:

178 case AV_PIX_FMT_YUV444P16:

179 case AV_PIX_FMT_YUVA420P16:

180 case AV_PIX_FMT_YUVA422P16:

181 case AV_PIX_FMT_YUVA444P16:

182 color_space = CLRSPC_SYCC;

183 break;

184 default:

185 av_log(avctx, AV_LOG_ERROR,

186 "The requested pixel format '%s' is not supported\n",

187 av_get_pix_fmt_name(avctx->pix_fmt));

188 return NULL;

189 }

190

191 for (i = 0; i < numcomps; i++) {

192 cmptparm[i].prec = desc->comp[i].depth_minus1 + 1;

193 cmptparm[i].bpp = desc->comp[i].depth_minus1 + 1;

194 cmptparm[i].sgnd = 0;

195 cmptparm[i].dx = sub_dx[i];

196 cmptparm[i].dy = sub_dy[i];

197 cmptparm[i].w = (avctx->width + sub_dx[i] - 1) / sub_dx[i];

198 cmptparm[i].h = (avctx->height + sub_dy[i] - 1) / sub_dy[i];

199 }

200

201 img = opj_image_create(numcomps, cmptparm, color_space);

202

203 // x0, y0 is the top left corner of the image

204 // x1, y1 is the width, height of the reference grid

205 img->x0 = 0;

206 img->y0 = 0;

207 img->x1 = (avctx->width - 1) * parameters->subsampling_dx + 1;

208 img->y1 = (avctx->height - 1) * parameters->subsampling_dy + 1;

209

210 return img;

211 }

212

213 static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)

214 {

215 LibOpenJPEGContext *ctx = avctx->priv_data;

216 int err = AVERROR(ENOMEM);

217

218 opj_set_default_encoder_parameters(&ctx->enc_params);

219

220 ctx->enc_params.cp_rsiz = ctx->profile;

221 ctx->enc_params.mode = !!avctx->global_quality;

222 ctx->enc_params.cp_cinema = ctx->cinema_mode;

223 ctx->enc_params.prog_order = ctx->prog_order;

224 ctx->enc_params.numresolution = ctx->numresolution;

225 ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;

226 ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;

227 ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;

228 ctx->enc_params.tcp_numlayers = ctx->numlayers;

229 ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;

230

231 if (ctx->cinema_mode > 0) {

232 cinema_parameters(&ctx->enc_params);

233 }

234

235 ctx->image = mj2_create_image(avctx, &ctx->enc_params);

236 if (!ctx->image) {

237 av_log(avctx, AV_LOG_ERROR, "Error creating the mj2 image\n");

238 err = AVERROR(EINVAL);

239 goto fail;

240 }

241

242 avctx->coded_frame = av_frame_alloc();

243 if (!avctx->coded_frame) {

244 av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");

245 goto fail;

246 }

247

248 return 0;

249

250 fail:

251 opj_image_destroy(ctx->image);

252 ctx->image = NULL;

253 av_frame_free(&avctx->coded_frame);

254 return err;

255 }

256

257 static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

258 {

259 int compno;

260 int x;

261 int y;

262 int *image_line;

263 int frame_index;

264 const int numcomps = image->numcomps;

265

266 for (compno = 0; compno < numcomps; ++compno) {

267 if (image->comps[compno].w > frame->linesize[0] / numcomps) {

268 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

269 return 0;

270 }

271 }

272

273 for (compno = 0; compno < numcomps; ++compno) {

274 for (y = 0; y < avctx->height; ++y) {

275 image_line = image->comps[compno].data + y * image->comps[compno].w;

276 frame_index = y * frame->linesize[0] + compno;

277 for (x = 0; x < avctx->width; ++x) {

278 image_line[x] = frame->data[0][frame_index];

279 frame_index += numcomps;

280 }

281 for (; x < image->comps[compno].w; ++x) {

282 image_line[x] = image_line[x - 1];

283 }

284 }

285 for (; y < image->comps[compno].h; ++y) {

286 image_line = image->comps[compno].data + y * image->comps[compno].w;

287 for (x = 0; x < image->comps[compno].w; ++x) {

288 image_line[x] = image_line[x - image->comps[compno].w];

289 }

290 }

291 }

292

293 return 1;

294 }

295

296 // for XYZ 12 bit

297 static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

298 {

299 int compno;

300 int x, y;

301 int *image_line;

302 int frame_index;

303 const int numcomps = image->numcomps;

304 uint16_t *frame_ptr = (uint16_t *)frame->data[0];

305

306 for (compno = 0; compno < numcomps; ++compno) {

307 if (image->comps[compno].w > frame->linesize[0] / numcomps) {

308 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

309 return 0;

310 }

311 }

312

313 for (compno = 0; compno < numcomps; ++compno) {

314 for (y = 0; y < avctx->height; ++y) {

315 image_line = image->comps[compno].data + y * image->comps[compno].w;

316 frame_index = y * (frame->linesize[0] / 2) + compno;

317 for (x = 0; x < avctx->width; ++x) {

318 image_line[x] = frame_ptr[frame_index] >> 4;

319 frame_index += numcomps;

320 }

321 for (; x < image->comps[compno].w; ++x) {

322 image_line[x] = image_line[x - 1];

323 }

324 }

325 for (; y < image->comps[compno].h; ++y) {

326 image_line = image->comps[compno].data + y * image->comps[compno].w;

327 for (x = 0; x < image->comps[compno].w; ++x) {

328 image_line[x] = image_line[x - image->comps[compno].w];

329 }

330 }

331 }

332

333 return 1;

334 }

335

336 static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

337 {

338 int compno;

339 int x;

340 int y;

341 int *image_line;

342 int frame_index;

343 const int numcomps = image->numcomps;

344 uint16_t *frame_ptr = (uint16_t*)frame->data[0];

345

346 for (compno = 0; compno < numcomps; ++compno) {

347 if (image->comps[compno].w > frame->linesize[0] / numcomps) {

348 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

349 return 0;

350 }

351 }

352

353 for (compno = 0; compno < numcomps; ++compno) {

354 for (y = 0; y < avctx->height; ++y) {

355 image_line = image->comps[compno].data + y * image->comps[compno].w;

356 frame_index = y * (frame->linesize[0] / 2) + compno;

357 for (x = 0; x < avctx->width; ++x) {

358 image_line[x] = frame_ptr[frame_index];

359 frame_index += numcomps;

360 }

361 for (; x < image->comps[compno].w; ++x) {

362 image_line[x] = image_line[x - 1];

363 }

364 }

365 for (; y < image->comps[compno].h; ++y) {

366 image_line = image->comps[compno].data + y * image->comps[compno].w;

367 for (x = 0; x < image->comps[compno].w; ++x) {

368 image_line[x] = image_line[x - image->comps[compno].w];

369 }

370 }

371 }

372

373 return 1;

374 }

375

376 static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

377 {

378 int compno;

379 int x;

380 int y;

381 int width;

382 int height;

383 int *image_line;

384 int frame_index;

385 const int numcomps = image->numcomps;

386

387 for (compno = 0; compno < numcomps; ++compno) {

388 if (image->comps[compno].w > frame->linesize[compno]) {

389 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

390 return 0;

391 }

392 }

393

394 for (compno = 0; compno < numcomps; ++compno) {

395 width = avctx->width / image->comps[compno].dx;

396 height = avctx->height / image->comps[compno].dy;

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

398 image_line = image->comps[compno].data + y * image->comps[compno].w;

399 frame_index = y * frame->linesize[compno];

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

401 image_line[x] = frame->data[compno][frame_index++];

402 for (; x < image->comps[compno].w; ++x) {

403 image_line[x] = image_line[x - 1];

404 }

405 }

406 for (; y < image->comps[compno].h; ++y) {

407 image_line = image->comps[compno].data + y * image->comps[compno].w;

408 for (x = 0; x < image->comps[compno].w; ++x) {

409 image_line[x] = image_line[x - image->comps[compno].w];

410 }

411 }

412 }

413

414 return 1;

415 }

416

417 static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

418 {

419 int compno;

420 int x;

421 int y;

422 int width;

423 int height;

424 int *image_line;

425 int frame_index;

426 const int numcomps = image->numcomps;

427 uint16_t *frame_ptr;

428

429 for (compno = 0; compno < numcomps; ++compno) {

430 if (image->comps[compno].w > frame->linesize[compno]) {

431 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

432 return 0;

433 }

434 }

435

436 for (compno = 0; compno < numcomps; ++compno) {

437 width = avctx->width / image->comps[compno].dx;

438 height = avctx->height / image->comps[compno].dy;

439 frame_ptr = (uint16_t *)frame->data[compno];

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

441 image_line = image->comps[compno].data + y * image->comps[compno].w;

442 frame_index = y * (frame->linesize[compno] / 2);

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

444 image_line[x] = frame_ptr[frame_index++];

445 for (; x < image->comps[compno].w; ++x) {

446 image_line[x] = image_line[x - 1];

447 }

448 }

449 for (; y < image->comps[compno].h; ++y) {

450 image_line = image->comps[compno].data + y * image->comps[compno].w;

451 for (x = 0; x < image->comps[compno].w; ++x) {

452 image_line[x] = image_line[x - image->comps[compno].w];

453 }

454 }

455 }

456

457 return 1;

458 }

459

460 static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

461 const AVFrame *frame, int *got_packet)

462 {

463 LibOpenJPEGContext *ctx = avctx->priv_data;

464 opj_image_t *image = ctx->image;

465 opj_cinfo_t *compress = NULL;

466 opj_cio_t *stream = NULL;

467 int cpyresult = 0;

468 int ret, len;

469 AVFrame *gbrframe;

470

471 switch (avctx->pix_fmt) {

472 case AV_PIX_FMT_RGB24:

473 case AV_PIX_FMT_RGBA:

474 case AV_PIX_FMT_YA8:

475 cpyresult = libopenjpeg_copy_packed8(avctx, frame, image);

476 break;

477 case AV_PIX_FMT_XYZ12:

478 cpyresult = libopenjpeg_copy_packed12(avctx, frame, image);

479 break;

480 case AV_PIX_FMT_RGB48:

481 case AV_PIX_FMT_RGBA64:

482 case AV_PIX_FMT_YA16:

483 cpyresult = libopenjpeg_copy_packed16(avctx, frame, image);

484 break;

485 case AV_PIX_FMT_GBR24P:

486 case AV_PIX_FMT_GBRP9:

487 case AV_PIX_FMT_GBRP10:

488 case AV_PIX_FMT_GBRP12:

489 case AV_PIX_FMT_GBRP14:

490 case AV_PIX_FMT_GBRP16:

491 gbrframe = av_frame_clone(frame);

492 if (!gbrframe)

493 return AVERROR(ENOMEM);

494 gbrframe->data[0] = frame->data[2]; // swap to be rgb

495 gbrframe->data[1] = frame->data[0];

496 gbrframe->data[2] = frame->data[1];

497 gbrframe->linesize[0] = frame->linesize[2];

498 gbrframe->linesize[1] = frame->linesize[0];

499 gbrframe->linesize[2] = frame->linesize[1];

500 if (avctx->pix_fmt == AV_PIX_FMT_GBR24P) {

501 cpyresult = libopenjpeg_copy_unpacked8(avctx, gbrframe, image);

502 } else {

503 cpyresult = libopenjpeg_copy_unpacked16(avctx, gbrframe, image);

504 }

505 av_frame_free(&gbrframe);

506 break;

507 case AV_PIX_FMT_GRAY8:

508 case AV_PIX_FMT_YUV410P:

509 case AV_PIX_FMT_YUV411P:

510 case AV_PIX_FMT_YUV420P:

511 case AV_PIX_FMT_YUV422P:

512 case AV_PIX_FMT_YUV440P:

513 case AV_PIX_FMT_YUV444P:

514 case AV_PIX_FMT_YUVA420P:

515 case AV_PIX_FMT_YUVA422P:

516 case AV_PIX_FMT_YUVA444P:

517 cpyresult = libopenjpeg_copy_unpacked8(avctx, frame, image);

518 break;

519 case AV_PIX_FMT_GRAY16:

520 case AV_PIX_FMT_YUV420P9:

521 case AV_PIX_FMT_YUV422P9:

522 case AV_PIX_FMT_YUV444P9:

523 case AV_PIX_FMT_YUVA420P9:

524 case AV_PIX_FMT_YUVA422P9:

525 case AV_PIX_FMT_YUVA444P9:

526 case AV_PIX_FMT_YUV444P10:

527 case AV_PIX_FMT_YUV422P10:

528 case AV_PIX_FMT_YUV420P10:

529 case AV_PIX_FMT_YUVA444P10:

530 case AV_PIX_FMT_YUVA422P10:

531 case AV_PIX_FMT_YUVA420P10:

532 case AV_PIX_FMT_YUV420P12:

533 case AV_PIX_FMT_YUV422P12:

534 case AV_PIX_FMT_YUV444P12:

535 case AV_PIX_FMT_YUV420P14:

536 case AV_PIX_FMT_YUV422P14:

537 case AV_PIX_FMT_YUV444P14:

538 case AV_PIX_FMT_YUV444P16:

539 case AV_PIX_FMT_YUV422P16:

540 case AV_PIX_FMT_YUV420P16:

541 case AV_PIX_FMT_YUVA444P16:

542 case AV_PIX_FMT_YUVA422P16:

543 case AV_PIX_FMT_YUVA420P16:

544 cpyresult = libopenjpeg_copy_unpacked16(avctx, frame, image);

545 break;

546 default:

547 av_log(avctx, AV_LOG_ERROR,

548 "The frame's pixel format '%s' is not supported\n",

549 av_get_pix_fmt_name(avctx->pix_fmt));

550 return AVERROR(EINVAL);

551 break;

552 }

553

554 if (!cpyresult) {

555 av_log(avctx, AV_LOG_ERROR,

556 "Could not copy the frame data to the internal image buffer\n");

557 return -1;

558 }

559

560 compress = opj_create_compress(ctx->format);

561 if (!compress) {

562 av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");

563 return AVERROR(ENOMEM);

564 }

565

566 opj_setup_encoder(compress, &ctx->enc_params, image);

567

568 stream = opj_cio_open((opj_common_ptr) compress, NULL, 0);

569 if (!stream) {

570 av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");

571 return AVERROR(ENOMEM);

572 }

573

574 memset(&ctx->event_mgr, 0, sizeof(opj_event_mgr_t));

575 ctx->event_mgr.info_handler = info_callback;

576 ctx->event_mgr.error_handler = error_callback;

577 ctx->event_mgr.warning_handler = warning_callback;

578 opj_set_event_mgr((opj_common_ptr) compress, &ctx->event_mgr, avctx);

579

580 if (!opj_encode(compress, stream, image, NULL)) {

581 av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");

582 return -1;

583 }

584

585 len = cio_tell(stream);

586 if ((ret = ff_alloc_packet2(avctx, pkt, len)) < 0) {

587 return ret;

588 }

589

590 memcpy(pkt->data, stream->buffer, len);

591 pkt->flags |= AV_PKT_FLAG_KEY;

592 *got_packet = 1;

593

594 opj_cio_close(stream);

595 stream = NULL;

596 opj_destroy_compress(compress);

597 compress = NULL;

598

599 return 0;

600 }

601

602 static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)

603 {

604 LibOpenJPEGContext *ctx = avctx->priv_data;

605

606 opj_image_destroy(ctx->image);

607 ctx->image = NULL;

608 av_frame_free(&avctx->coded_frame);

609 return 0;

610 }

611

612 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)

613 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

614 static const AVOption options[] = {

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

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

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

618 { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = STD_RSIZ }, STD_RSIZ, CINEMA4K, VE, "profile" },

619 { "jpeg2000", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = STD_RSIZ }, 0, 0, VE, "profile" },

620 { "cinema2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA2K }, 0, 0, VE, "profile" },

621 { "cinema4k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA4K }, 0, 0, VE, "profile" },

622 { "cinema_mode", "Digital Cinema", OFFSET(cinema_mode), AV_OPT_TYPE_INT, { .i64 = OFF }, OFF, CINEMA4K_24, VE, "cinema_mode" },

623 { "off", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = OFF }, 0, 0, VE, "cinema_mode" },

624 { "2k_24", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_24 }, 0, 0, VE, "cinema_mode" },

625 { "2k_48", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_48 }, 0, 0, VE, "cinema_mode" },

626 { "4k_24", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA4K_24 }, 0, 0, VE, "cinema_mode" },

627 { "prog_order", "Progression Order", OFFSET(prog_order), AV_OPT_TYPE_INT, { .i64 = LRCP }, LRCP, CPRL, VE, "prog_order" },

628 { "lrcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LRCP }, 0, 0, VE, "prog_order" },

629 { "rlcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = RLCP }, 0, 0, VE, "prog_order" },

630 { "rpcl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = RPCL }, 0, 0, VE, "prog_order" },

631 { "pcrl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PCRL }, 0, 0, VE, "prog_order" },

632 { "cprl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPRL }, 0, 0, VE, "prog_order" },

633 { "numresolution", NULL, OFFSET(numresolution), AV_OPT_TYPE_INT, { .i64 = 6 }, 1, INT_MAX, VE },

634 { "numlayers", NULL, OFFSET(numlayers), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 10, VE },

635 { "disto_alloc", NULL, OFFSET(disto_alloc), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },

636 { "fixed_alloc", NULL, OFFSET(fixed_alloc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },

637 { "fixed_quality", NULL, OFFSET(fixed_quality), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },

638 { NULL },

639 };

640

641 static const AVClass openjpeg_class = {

642 .class_name = "libopenjpeg",

643 .item_name = av_default_item_name,

644 .option = options,

645 .version = LIBAVUTIL_VERSION_INT,

646 };

647

648 AVCodec ff_libopenjpeg_encoder = {

649 .name = "libopenjpeg",

650 .long_name = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),

651 .type = AVMEDIA_TYPE_VIDEO,

652 .id = AV_CODEC_ID_JPEG2000,

653 .priv_data_size = sizeof(LibOpenJPEGContext),

654 .init = libopenjpeg_encode_init,

655 .encode2 = libopenjpeg_encode_frame,

656 .close = libopenjpeg_encode_close,

657 .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,

658 .pix_fmts = (const enum AVPixelFormat[]) {

659 AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48,

660 AV_PIX_FMT_RGBA64, AV_PIX_FMT_GBR24P,

661 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,

662 AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16,

663 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P,

664 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA422P,

665 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVA444P,

666 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,

667 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,

668 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,

669 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,

670 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,

671 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,

672 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,

673 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,

674 AV_PIX_FMT_XYZ12,

675 AV_PIX_FMT_NONE

676 },

677 .priv_class = &openjpeg_class,

678 };

Generated on Sun Mar 8 2015 02:34:54 for FFmpeg by doxygen 1.8.2