FFmpeg: libavcodec/libopenjpegdec.c Source File

FFmpeg

[フレーム]

libavcodec

libopenjpegdec.c

Go to the documentation of this file.

1 /*

2 * JPEG 2000 decoding 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 decoder using libopenjpeg

25 */

27 #include "libavutil/common.h"

28 #include "libavutil/imgutils.h"

29 #include "libavutil/intreadwrite.h"

30 #include "libavutil/opt.h"

31 #include "libavutil/pixfmt.h"

33 #include "avcodec.h"

34 #include "internal.h"

35 #include "thread.h"

37 #include <openjpeg.h>

39 #define JP2_SIG_TYPE 0x6A502020

40 #define JP2_SIG_VALUE 0x0D0A870A

42 // pix_fmts with lower bpp have to be listed before

43 // similar pix_fmts with higher bpp.

44 #define RGB_PIXEL_FORMATS AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, \

45 AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64

47 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, \

48 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, \

49 AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16

51 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVA420P, \

52 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \

53 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \

54 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \

55 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, \

56 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \

57 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, \

58 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, \

59 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \

60 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \

61 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16

63 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12

65 static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[] = {

66 RGB_PIXEL_FORMATS

67 };

68 static const enum AVPixelFormat libopenjpeg_gray_pix_fmts[] = {

69 GRAY_PIXEL_FORMATS

70 };

71 static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[] = {

72 YUV_PIXEL_FORMATS

73 };

74 static const enum AVPixelFormat libopenjpeg_all_pix_fmts[] = {

75 RGB_PIXEL_FORMATS, GRAY_PIXEL_FORMATS, YUV_PIXEL_FORMATS, XYZ_PIXEL_FORMATS

76 };

78 typedef struct LibOpenJPEGContext {

79 AVClass *class;

80 opj_dparameters_t dec_params;

81 int lowqual;

82 } LibOpenJPEGContext;

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

85 {

86 av_log(data, AV_LOG_ERROR, "%s", msg);

87 }

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

90 {

91 av_log(data, AV_LOG_WARNING, "%s", msg);

92 }

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

95 {

96 av_log(data, AV_LOG_DEBUG, "%s", msg);

97 }

99 typedef struct BufferReader {

100 int pos;

101 int size;

102 const uint8_t *buffer;

103 } BufferReader;

104

105 static OPJ_SIZE_T stream_read(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)

106 {

107 BufferReader *reader = user_data;

108 int remaining;

109

110 if (reader->pos == reader->size) {

111 return (OPJ_SIZE_T)-1;

112 }

113 remaining = reader->size - reader->pos;

114 if (nb_bytes > remaining) {

115 nb_bytes = remaining;

116 }

117 memcpy(out_buffer, reader->buffer + reader->pos, nb_bytes);

118 reader->pos += (int)nb_bytes;

119 return nb_bytes;

120 }

121

122 static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)

123 {

124 BufferReader *reader = user_data;

125 if (nb_bytes < 0) {

126 if (reader->pos == 0) {

127 return (OPJ_SIZE_T)-1;

128 }

129 if (nb_bytes + reader->pos < 0) {

130 nb_bytes = -reader->pos;

131 }

132 } else {

133 int remaining;

134

135 if (reader->pos == reader->size) {

136 return (OPJ_SIZE_T)-1;

137 }

138 remaining = reader->size - reader->pos;

139 if (nb_bytes > remaining) {

140 nb_bytes = remaining;

141 }

142 }

143 reader->pos += (int)nb_bytes;

144 return nb_bytes;

145 }

146

147 static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data)

148 {

149 BufferReader *reader = user_data;

150 if (nb_bytes < 0 || nb_bytes > reader->size) {

151 return OPJ_FALSE;

152 }

153 reader->pos = (int)nb_bytes;

154 return OPJ_TRUE;

155 }

156

157 static inline int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)

158 {

159 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

160 int match = 1;

161

162 if (desc->nb_components != image->numcomps) {

163 return 0;

164 }

165

166 switch (desc->nb_components) {

167 case 4:

168 match = match &&

169 desc->comp[3].depth >= image->comps[3].prec &&

170 1 == image->comps[3].dx &&

171 1 == image->comps[3].dy;

172 case 3:

173 match = match &&

174 desc->comp[2].depth >= image->comps[2].prec &&

175 1 << desc->log2_chroma_w == image->comps[2].dx &&

176 1 << desc->log2_chroma_h == image->comps[2].dy;

177 case 2:

178 match = match &&

179 desc->comp[1].depth >= image->comps[1].prec &&

180 1 << desc->log2_chroma_w == image->comps[1].dx &&

181 1 << desc->log2_chroma_h == image->comps[1].dy;

182 case 1:

183 match = match &&

184 desc->comp[0].depth >= image->comps[0].prec &&

185 1 == image->comps[0].dx &&

186 1 == image->comps[0].dy;

187 default:

188 break;

189 }

190

191 return match;

192 }

193

194 static inline enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image) {

195 int index;

196 const enum AVPixelFormat *possible_fmts = NULL;

197 int possible_fmts_nb = 0;

198

199 switch (image->color_space) {

200 case OPJ_CLRSPC_SRGB:

201 possible_fmts = libopenjpeg_rgb_pix_fmts;

202 possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_rgb_pix_fmts);

203 break;

204 case OPJ_CLRSPC_GRAY:

205 possible_fmts = libopenjpeg_gray_pix_fmts;

206 possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_gray_pix_fmts);

207 break;

208 case OPJ_CLRSPC_SYCC:

209 possible_fmts = libopenjpeg_yuv_pix_fmts;

210 possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_yuv_pix_fmts);

211 break;

212 default:

213 possible_fmts = libopenjpeg_all_pix_fmts;

214 possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_all_pix_fmts);

215 break;

216 }

217

218 for (index = 0; index < possible_fmts_nb; ++index)

219 if (libopenjpeg_matches_pix_fmt(image, possible_fmts[index])) {

220 return possible_fmts[index];

221 }

222

223 return AV_PIX_FMT_NONE;

224 }

225

226 static inline int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)

227 {

228 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

229 int i, component_plane;

230

231 if (pix_fmt == AV_PIX_FMT_GRAY16)

232 return 0;

233

234 component_plane = desc->comp[0].plane;

235 for (i = 1; i < desc->nb_components; i++)

236 if (component_plane != desc->comp[i].plane)

237 return 0;

238 return 1;

239 }

240

241 static inline void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image) {

242 uint8_t *img_ptr;

243 int index, x, y, c;

244 for (y = 0; y < picture->height; y++) {

245 index = y * picture->width;

246 img_ptr = picture->data[0] + y * picture->linesize[0];

247 for (x = 0; x < picture->width; x++, index++)

248 for (c = 0; c < image->numcomps; c++)

249 *img_ptr++ = 0x80 * image->comps[c].sgnd + image->comps[c].data[index];

250 }

251 }

252

253 static inline void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image) {

254 uint16_t *img_ptr;

255 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(picture->format);

256 int index, x, y, c;

257 int adjust[4];

258 for (x = 0; x < image->numcomps; x++)

259 adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;

260

261 for (y = 0; y < picture->height; y++) {

262 index = y * picture->width;

263 img_ptr = (uint16_t *) (picture->data[0] + y * picture->linesize[0]);

264 for (x = 0; x < picture->width; x++, index++)

265 for (c = 0; c < image->numcomps; c++)

266 *img_ptr++ = (1 << image->comps[c].prec - 1) * image->comps[c].sgnd +

267 (unsigned)image->comps[c].data[index] << adjust[c];

268 }

269 }

270

271 static inline void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image) {

272 int *comp_data;

273 uint8_t *img_ptr;

274 int index, x, y;

275

276 for (index = 0; index < image->numcomps; index++) {

277 comp_data = image->comps[index].data;

278 for (y = 0; y < image->comps[index].h; y++) {

279 img_ptr = picture->data[index] + y * picture->linesize[index];

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

281 *img_ptr = 0x80 * image->comps[index].sgnd + *comp_data;

282 img_ptr++;

283 comp_data++;

284 }

285 }

286 }

287 }

288

289 static inline void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image) {

290 int *comp_data;

291 uint16_t *img_ptr;

292 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(picture->format);

293 int index, x, y;

294 int adjust[4];

295 for (x = 0; x < image->numcomps; x++)

296 adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;

297

298 for (index = 0; index < image->numcomps; index++) {

299 comp_data = image->comps[index].data;

300 for (y = 0; y < image->comps[index].h; y++) {

301 img_ptr = (uint16_t *)(picture->data[index] + y * picture->linesize[index]);

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

303 *img_ptr = (1 << image->comps[index].prec - 1) * image->comps[index].sgnd +

304 (unsigned)*comp_data << adjust[index];

305 img_ptr++;

306 comp_data++;

307 }

308 }

309 }

310 }

311

312 static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx)

313 {

314 LibOpenJPEGContext *ctx = avctx->priv_data;

315

316 opj_set_default_decoder_parameters(&ctx->dec_params);

317 return 0;

318 }

319

320 static int libopenjpeg_decode_frame(AVCodecContext *avctx,

321 void *data, int *got_frame,

322 AVPacket *avpkt)

323 {

324 uint8_t *buf = avpkt->data;

325 int buf_size = avpkt->size;

326 LibOpenJPEGContext *ctx = avctx->priv_data;

327 ThreadFrame frame = { .f = data };

328 AVFrame *picture = data;

329 const AVPixFmtDescriptor *desc;

330 int width, height, ret;

331 int pixel_size = 0;

332 int ispacked = 0;

333 int i;

334 opj_image_t *image = NULL;

335 BufferReader reader = {0, avpkt->size, avpkt->data};

336 opj_codec_t *dec = NULL;

337 opj_stream_t *stream = NULL;

338

339 *got_frame = 0;

340

341 // Check if input is a raw jpeg2k codestream or in jp2 wrapping

342 if ((AV_RB32(buf) == 12) &&

343 (AV_RB32(buf + 4) == JP2_SIG_TYPE) &&

344 (AV_RB32(buf + 8) == JP2_SIG_VALUE)) {

345 dec = opj_create_decompress(OPJ_CODEC_JP2);

346 } else {

347 /* If the AVPacket contains a jp2c box, then skip to

348 * the starting byte of the codestream. */

349 if (AV_RB32(buf + 4) == AV_RB32("jp2c"))

350 buf += 8;

351 dec = opj_create_decompress(OPJ_CODEC_J2K);

352 }

353

354 if (!dec) {

355 av_log(avctx, AV_LOG_ERROR, "Error initializing decoder.\n");

356 ret = AVERROR_EXTERNAL;

357 goto done;

358 }

359

360 if (!opj_set_error_handler(dec, error_callback, avctx) ||

361 !opj_set_warning_handler(dec, warning_callback, avctx) ||

362 !opj_set_info_handler(dec, info_callback, avctx)) {

363 av_log(avctx, AV_LOG_ERROR, "Error setting decoder handlers.\n");

364 ret = AVERROR_EXTERNAL;

365 goto done;

366 }

367

368 ctx->dec_params.cp_layer = ctx->lowqual;

369 ctx->dec_params.cp_reduce = avctx->lowres;

370

371 // Tie decoder with decoding parameters

372 opj_setup_decoder(dec, &ctx->dec_params);

373

374 stream = opj_stream_default_create(OPJ_STREAM_READ);

375

376 if (!stream) {

377 av_log(avctx, AV_LOG_ERROR,

378 "Codestream could not be opened for reading.\n");

379 ret = AVERROR_EXTERNAL;

380 goto done;

381 }

382

383 opj_stream_set_read_function(stream, stream_read);

384 opj_stream_set_skip_function(stream, stream_skip);

385 opj_stream_set_seek_function(stream, stream_seek);

386 opj_stream_set_user_data(stream, &reader, NULL);

387 opj_stream_set_user_data_length(stream, avpkt->size);

388 // Decode the header only.

389 ret = !opj_read_header(stream, dec, &image);

390

391 if (ret) {

392 av_log(avctx, AV_LOG_ERROR, "Error decoding codestream header.\n");

393 ret = AVERROR_EXTERNAL;

394 goto done;

395 }

396

397 width = image->x1 - image->x0;

398 height = image->y1 - image->y0;

399

400 ret = ff_set_dimensions(avctx, width, height);

401 if (ret < 0)

402 goto done;

403

404 if (avctx->pix_fmt != AV_PIX_FMT_NONE)

405 if (!libopenjpeg_matches_pix_fmt(image, avctx->pix_fmt))

406 avctx->pix_fmt = AV_PIX_FMT_NONE;

407

408 if (avctx->pix_fmt == AV_PIX_FMT_NONE)

409 avctx->pix_fmt = libopenjpeg_guess_pix_fmt(image);

410

411 if (avctx->pix_fmt == AV_PIX_FMT_NONE) {

412 av_log(avctx, AV_LOG_ERROR, "Unable to determine pixel format.\n");

413 ret = AVERROR_UNKNOWN;

414 goto done;

415 }

416 for (i = 0; i < image->numcomps; i++)

417 if (image->comps[i].prec > avctx->bits_per_raw_sample)

418 avctx->bits_per_raw_sample = image->comps[i].prec;

419

420 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

421 goto done;

422

423 ret = !opj_decode(dec, stream, image);

424

425 if (ret) {

426 av_log(avctx, AV_LOG_ERROR, "Error decoding codestream.\n");

427 ret = AVERROR_EXTERNAL;

428 goto done;

429 }

430

431 for (i = 0; i < image->numcomps; i++) {

432 if (!image->comps[i].data) {

433 av_log(avctx, AV_LOG_ERROR,

434 "Image component %d contains no data.\n", i);

435 ret = AVERROR_INVALIDDATA;

436 goto done;

437 }

438 }

439

440 desc = av_pix_fmt_desc_get(avctx->pix_fmt);

441 pixel_size = desc->comp[0].step;

442 ispacked = libopenjpeg_ispacked(avctx->pix_fmt);

443

444 switch (pixel_size) {

445 case 1:

446 if (ispacked) {

447 libopenjpeg_copy_to_packed8(picture, image);

448 } else {

449 libopenjpeg_copyto8(picture, image);

450 }

451 break;

452 case 2:

453 if (ispacked) {

454 libopenjpeg_copy_to_packed8(picture, image);

455 } else {

456 libopenjpeg_copyto16(picture, image);

457 }

458 break;

459 case 3:

460 case 4:

461 if (ispacked) {

462 libopenjpeg_copy_to_packed8(picture, image);

463 }

464 break;

465 case 6:

466 case 8:

467 if (ispacked) {

468 libopenjpeg_copy_to_packed16(picture, image);

469 }

470 break;

471 default:

472 avpriv_report_missing_feature(avctx, "Pixel size %d", pixel_size);

473 ret = AVERROR_PATCHWELCOME;

474 goto done;

475 }

476

477 *got_frame = 1;

478 picture->pict_type = AV_PICTURE_TYPE_I;

479 picture->key_frame = 1;

480 ret = buf_size;

481

482 done:

483 opj_image_destroy(image);

484 opj_stream_destroy(stream);

485 opj_destroy_codec(dec);

486 return ret;

487 }

488

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

490 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

491

492 static const AVOption options[] = {

493 { "lowqual", "Limit the number of layers used for decoding",

494 OFFSET(lowqual), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },

495 { NULL },

496 };

497

498 static const AVClass openjpeg_class = {

499 .class_name = "libopenjpeg",

500 .item_name = av_default_item_name,

501 .option = options,

502 .version = LIBAVUTIL_VERSION_INT,

503 };

504

505 const AVCodec ff_libopenjpeg_decoder = {

506 .name = "libopenjpeg",

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

508 .type = AVMEDIA_TYPE_VIDEO,

509 .id = AV_CODEC_ID_JPEG2000,

510 .priv_data_size = sizeof(LibOpenJPEGContext),

511 .init = libopenjpeg_decode_init,

512 .decode = libopenjpeg_decode_frame,

513 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

514 .max_lowres = 31,

515 .priv_class = &openjpeg_class,

516 .wrapper_name = "libopenjpeg",

517 };

AVCodec

AVCodec.

Definition: codec.h:202

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

opt.h

libopenjpeg_copy_to_packed8

static void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image)

Definition: libopenjpegdec.c:241

ff_libopenjpeg_decoder

const AVCodec ff_libopenjpeg_decoder

Definition: libopenjpegdec.c:505

BufferReader::size

int size

Definition: libopenjpegdec.c:101

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2660

AVFrame

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

Definition: frame.h:317

index

fg index

Definition: ffmpeg_filter.c:167

AVFrame::width

int width

Definition: frame.h:389

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

AVOption

AVOption.

Definition: opt.h:247

libopenjpeg_yuv_pix_fmts

static enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]

Definition: libopenjpegdec.c:71

BufferReader::buffer

const uint8_t * buffer

Definition: libopenjpegdec.c:102

data

const char data[16]

Definition: mxf.c:143

libopenjpeg_gray_pix_fmts

static enum AVPixelFormat libopenjpeg_gray_pix_fmts[]

Definition: libopenjpegdec.c:68

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

thread.h

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:338

XYZ_PIXEL_FORMATS

#define XYZ_PIXEL_FORMATS

Definition: libopenjpegdec.c:63

init

static int init

Definition: av_tx.c:47

libopenjpeg_decode_init

static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx)

Definition: libopenjpegdec.c:312

options

static const AVOption options[]

Definition: libopenjpegdec.c:492

ff_thread_get_buffer

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:409

warning_callback

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

Definition: libopenjpegdec.c:89

AV_PIX_FMT_GRAY16

#define AV_PIX_FMT_GRAY16

Definition: pixfmt.h:388

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:71

width

#define width

stream_skip

static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)

Definition: libopenjpegdec.c:122

intreadwrite.h

libopenjpeg_rgb_pix_fmts

static enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]

Definition: libopenjpegdec.c:65

#define VD

Definition: libopenjpegdec.c:490

adjust

static int adjust(int x, int size)

Definition: mobiclip.c:514

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1425

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:48

libopenjpeg_ispacked

static int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)

Definition: libopenjpegdec.c:226

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demuxing_decoding.c:41

GRAY_PIXEL_FORMATS

#define GRAY_PIXEL_FORMATS

Definition: libopenjpegdec.c:47

info_callback

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

Definition: libopenjpegdec.c:94

RGB_PIXEL_FORMATS

#define RGB_PIXEL_FORMATS

Definition: libopenjpegdec.c:44

libopenjpeg_all_pix_fmts

static enum AVPixelFormat libopenjpeg_all_pix_fmts[]

Definition: libopenjpegdec.c:74

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:113

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:235

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

LibOpenJPEGContext::lowqual

int lowqual

Definition: libopenjpegdec.c:81

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

LibOpenJPEGContext

Definition: libopenjpegdec.c:78

AVCodecContext::lowres

int lowres

low resolution decoding, 1-> 1/2 size, 2->1/4 size

Definition: avcodec.h:1432

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:414

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:374

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

openjpeg_class

static const AVClass openjpeg_class

Definition: libopenjpegdec.c:498

stream_read

static OPJ_SIZE_T stream_read(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)

Definition: libopenjpegdec.c:105

AV_RB32

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_RB32

Definition: bytestream.h:96

avpriv_report_missing_feature

void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

libopenjpeg_copy_to_packed16

static void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image)

Definition: libopenjpegdec.c:253

user_data

static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)

Definition: cbs_mpeg2_syntax_template.c:59

libopenjpeg_decode_frame

static int libopenjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: libopenjpegdec.c:320

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...

Definition: frame.h:404

height

#define height

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

libopenjpeg_copyto8

static void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image)

Definition: libopenjpegdec.c:271

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

Definition: cbs_h2645.c:271

LibOpenJPEGContext::dec_params

opj_dparameters_t dec_params

Definition: libopenjpegdec.c:80

libopenjpeg_guess_pix_fmt

static enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image)

Definition: libopenjpegdec.c:194

common.h

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

AV_CODEC_ID_JPEG2000

@ AV_CODEC_ID_JPEG2000

Definition: codec_id.h:138

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:593

avcodec.h

ret

Definition: filter_design.txt:187

pixfmt.h

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

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

BufferReader::pos

int pos

Definition: libopenjpegdec.c:100

AVCodecContext

main external API structure.

Definition: avcodec.h:383

AVFrame::height

int height

Definition: frame.h:389

JP2_SIG_TYPE

#define JP2_SIG_TYPE