/libavcodec/jpeglsenc.c

http://github.com/FFmpeg/FFmpeg · C · 483 lines · 374 code · 60 blank · 49 comment · 81 complexity · 5645e64c5d85e06a360c04de9ffa896e MD5 · raw file

  1. /*
  2. * JPEG-LS encoder
  3. * Copyright (c) 2003 Michael Niedermayer
  4. * Copyright (c) 2006 Konstantin Shishkov
  5. *
  6. * This file is part of FFmpeg.
  7. *
  8. * FFmpeg is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public
  10. * License as published by the Free Software Foundation; either
  11. * version 2.1 of the License, or (at your option) any later version.
  12. *
  13. * FFmpeg is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * Lesser General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public
  19. * License along with FFmpeg; if not, write to the Free Software
  20. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21. */
  22. /**
  23. * @file
  24. * JPEG-LS encoder.
  25. */
  26. #include "avcodec.h"
  27. #include "get_bits.h"
  28. #include "put_bits.h"
  29. #include "golomb.h"
  30. #include "internal.h"
  31. #include "mathops.h"
  32. #include "mjpeg.h"
  33. #include "mjpegenc.h"
  34. #include "jpegls.h"
  35. typedef struct JPEGLSContext {
  36. AVClass *class;
  37. int pred;
  38. } JPEGLSContext;
  39. /**
  40. * Encode error from regular symbol
  41. */
  42. static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q,
  43. int err)
  44. {
  45. int k;
  46. int val;
  47. int map;
  48. for (k = 0; (state->N[Q] << k) < state->A[Q]; k++)
  49. ;
  50. map = !state->near && !k && (2 * state->B[Q] <= -state->N[Q]);
  51. if (err < 0)
  52. err += state->range;
  53. if (err >= (state->range + 1 >> 1)) {
  54. err -= state->range;
  55. val = 2 * FFABS(err) - 1 - map;
  56. } else
  57. val = 2 * err + map;
  58. set_ur_golomb_jpegls(pb, val, k, state->limit, state->qbpp);
  59. ff_jpegls_update_state_regular(state, Q, err);
  60. }
  61. /**
  62. * Encode error from run termination
  63. */
  64. static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb,
  65. int RItype, int err, int limit_add)
  66. {
  67. int k;
  68. int val, map;
  69. int Q = 365 + RItype;
  70. int temp;
  71. temp = state->A[Q];
  72. if (RItype)
  73. temp += state->N[Q] >> 1;
  74. for (k = 0; (state->N[Q] << k) < temp; k++)
  75. ;
  76. map = 0;
  77. if (!k && err && (2 * state->B[Q] < state->N[Q]))
  78. map = 1;
  79. if (err < 0)
  80. val = -(2 * err) - 1 - RItype + map;
  81. else
  82. val = 2 * err - RItype - map;
  83. set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp);
  84. if (err < 0)
  85. state->B[Q]++;
  86. state->A[Q] += (val + 1 - RItype) >> 1;
  87. ff_jpegls_downscale_state(state, Q);
  88. }
  89. /**
  90. * Encode run value as specified by JPEG-LS standard
  91. */
  92. static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run,
  93. int comp, int trail)
  94. {
  95. while (run >= (1 << ff_log2_run[state->run_index[comp]])) {
  96. put_bits(pb, 1, 1);
  97. run -= 1 << ff_log2_run[state->run_index[comp]];
  98. if (state->run_index[comp] < 31)
  99. state->run_index[comp]++;
  100. }
  101. /* if hit EOL, encode another full run, else encode aborted run */
  102. if (!trail && run) {
  103. put_bits(pb, 1, 1);
  104. } else if (trail) {
  105. put_bits(pb, 1, 0);
  106. if (ff_log2_run[state->run_index[comp]])
  107. put_bits(pb, ff_log2_run[state->run_index[comp]], run);
  108. }
  109. }
  110. /**
  111. * Encode one line of image
  112. */
  113. static inline void ls_encode_line(JLSState *state, PutBitContext *pb,
  114. void *last, void *cur, int last2, int w,
  115. int stride, int comp, int bits)
  116. {
  117. int x = 0;
  118. int Ra, Rb, Rc, Rd;
  119. int D0, D1, D2;
  120. while (x < w) {
  121. int err, pred, sign;
  122. /* compute gradients */
  123. Ra = x ? R(cur, x - stride) : R(last, x);
  124. Rb = R(last, x);
  125. Rc = x ? R(last, x - stride) : last2;
  126. Rd = (x >= w - stride) ? R(last, x) : R(last, x + stride);
  127. D0 = Rd - Rb;
  128. D1 = Rb - Rc;
  129. D2 = Rc - Ra;
  130. /* run mode */
  131. if ((FFABS(D0) <= state->near) &&
  132. (FFABS(D1) <= state->near) &&
  133. (FFABS(D2) <= state->near)) {
  134. int RUNval, RItype, run;
  135. run = 0;
  136. RUNval = Ra;
  137. while (x < w && (FFABS(R(cur, x) - RUNval) <= state->near)) {
  138. run++;
  139. W(cur, x, Ra);
  140. x += stride;
  141. }
  142. ls_encode_run(state, pb, run, comp, x < w);
  143. if (x >= w)
  144. return;
  145. Rb = R(last, x);
  146. RItype = FFABS(Ra - Rb) <= state->near;
  147. pred = RItype ? Ra : Rb;
  148. err = R(cur, x) - pred;
  149. if (!RItype && Ra > Rb)
  150. err = -err;
  151. if (state->near) {
  152. if (err > 0)
  153. err = (state->near + err) / state->twonear;
  154. else
  155. err = -(state->near - err) / state->twonear;
  156. if (RItype || (Rb >= Ra))
  157. Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
  158. else
  159. Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
  160. W(cur, x, Ra);
  161. }
  162. if (err < 0)
  163. err += state->range;
  164. if (err >= state->range + 1 >> 1)
  165. err -= state->range;
  166. ls_encode_runterm(state, pb, RItype, err,
  167. ff_log2_run[state->run_index[comp]]);
  168. if (state->run_index[comp] > 0)
  169. state->run_index[comp]--;
  170. } else { /* regular mode */
  171. int context;
  172. context = ff_jpegls_quantize(state, D0) * 81 +
  173. ff_jpegls_quantize(state, D1) * 9 +
  174. ff_jpegls_quantize(state, D2);
  175. pred = mid_pred(Ra, Ra + Rb - Rc, Rb);
  176. if (context < 0) {
  177. context = -context;
  178. sign = 1;
  179. pred = av_clip(pred - state->C[context], 0, state->maxval);
  180. err = pred - R(cur, x);
  181. } else {
  182. sign = 0;
  183. pred = av_clip(pred + state->C[context], 0, state->maxval);
  184. err = R(cur, x) - pred;
  185. }
  186. if (state->near) {
  187. if (err > 0)
  188. err = (state->near + err) / state->twonear;
  189. else
  190. err = -(state->near - err) / state->twonear;
  191. if (!sign)
  192. Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
  193. else
  194. Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
  195. W(cur, x, Ra);
  196. }
  197. ls_encode_regular(state, pb, context, err);
  198. }
  199. x += stride;
  200. }
  201. }
  202. static void ls_store_lse(JLSState *state, PutBitContext *pb)
  203. {
  204. /* Test if we have default params and don't need to store LSE */
  205. JLSState state2 = { 0 };
  206. state2.bpp = state->bpp;
  207. state2.near = state->near;
  208. ff_jpegls_reset_coding_parameters(&state2, 1);
  209. if (state->T1 == state2.T1 &&
  210. state->T2 == state2.T2 &&
  211. state->T3 == state2.T3 &&
  212. state->reset == state2.reset)
  213. return;
  214. /* store LSE type 1 */
  215. put_marker(pb, LSE);
  216. put_bits(pb, 16, 13);
  217. put_bits(pb, 8, 1);
  218. put_bits(pb, 16, state->maxval);
  219. put_bits(pb, 16, state->T1);
  220. put_bits(pb, 16, state->T2);
  221. put_bits(pb, 16, state->T3);
  222. put_bits(pb, 16, state->reset);
  223. }
  224. static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
  225. const AVFrame *pict, int *got_packet)
  226. {
  227. JPEGLSContext *ctx = avctx->priv_data;
  228. const AVFrame *const p = pict;
  229. PutBitContext pb, pb2;
  230. GetBitContext gb;
  231. uint8_t *buf2 = NULL;
  232. uint8_t *zero = NULL;
  233. uint8_t *cur = NULL;
  234. uint8_t *last = NULL;
  235. JLSState *state = NULL;
  236. int i, size, ret;
  237. int comps;
  238. #if FF_API_PRIVATE_OPT
  239. FF_DISABLE_DEPRECATION_WARNINGS
  240. if (avctx->prediction_method)
  241. ctx->pred = avctx->prediction_method;
  242. FF_ENABLE_DEPRECATION_WARNINGS
  243. #endif
  244. if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
  245. avctx->pix_fmt == AV_PIX_FMT_GRAY16)
  246. comps = 1;
  247. else
  248. comps = 3;
  249. if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width *avctx->height * comps * 4 +
  250. AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
  251. return ret;
  252. buf2 = av_malloc(pkt->size);
  253. if (!buf2)
  254. goto memfail;
  255. init_put_bits(&pb, pkt->data, pkt->size);
  256. init_put_bits(&pb2, buf2, pkt->size);
  257. /* write our own JPEG header, can't use mjpeg_picture_header */
  258. put_marker(&pb, SOI);
  259. put_marker(&pb, SOF48);
  260. put_bits(&pb, 16, 8 + comps * 3); // header size depends on components
  261. put_bits(&pb, 8, (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8); // bpp
  262. put_bits(&pb, 16, avctx->height);
  263. put_bits(&pb, 16, avctx->width);
  264. put_bits(&pb, 8, comps); // components
  265. for (i = 1; i <= comps; i++) {
  266. put_bits(&pb, 8, i); // component ID
  267. put_bits(&pb, 8, 0x11); // subsampling: none
  268. put_bits(&pb, 8, 0); // Tiq, used by JPEG-LS ext
  269. }
  270. put_marker(&pb, SOS);
  271. put_bits(&pb, 16, 6 + comps * 2);
  272. put_bits(&pb, 8, comps);
  273. for (i = 1; i <= comps; i++) {
  274. put_bits(&pb, 8, i); // component ID
  275. put_bits(&pb, 8, 0); // mapping index: none
  276. }
  277. put_bits(&pb, 8, ctx->pred);
  278. put_bits(&pb, 8, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line
  279. put_bits(&pb, 8, 0); // point transform: none
  280. state = av_mallocz(sizeof(JLSState));
  281. if (!state)
  282. goto memfail;
  283. /* initialize JPEG-LS state from JPEG parameters */
  284. state->near = ctx->pred;
  285. state->bpp = (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8;
  286. ff_jpegls_reset_coding_parameters(state, 0);
  287. ff_jpegls_init_state(state);
  288. ls_store_lse(state, &pb);
  289. zero = last = av_mallocz(FFABS(p->linesize[0]));
  290. if (!zero)
  291. goto memfail;
  292. cur = p->data[0];
  293. if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
  294. int t = 0;
  295. for (i = 0; i < avctx->height; i++) {
  296. ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 8);
  297. t = last[0];
  298. last = cur;
  299. cur += p->linesize[0];
  300. }
  301. } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY16) {
  302. int t = 0;
  303. for (i = 0; i < avctx->height; i++) {
  304. ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 16);
  305. t = *((uint16_t *)last);
  306. last = cur;
  307. cur += p->linesize[0];
  308. }
  309. } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
  310. int j, width;
  311. int Rc[3] = { 0, 0, 0 };
  312. width = avctx->width * 3;
  313. for (i = 0; i < avctx->height; i++) {
  314. for (j = 0; j < 3; j++) {
  315. ls_encode_line(state, &pb2, last + j, cur + j, Rc[j],
  316. width, 3, j, 8);
  317. Rc[j] = last[j];
  318. }
  319. last = cur;
  320. cur += p->linesize[0];
  321. }
  322. } else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) {
  323. int j, width;
  324. int Rc[3] = { 0, 0, 0 };
  325. width = avctx->width * 3;
  326. for (i = 0; i < avctx->height; i++) {
  327. for (j = 2; j >= 0; j--) {
  328. ls_encode_line(state, &pb2, last + j, cur + j, Rc[j],
  329. width, 3, j, 8);
  330. Rc[j] = last[j];
  331. }
  332. last = cur;
  333. cur += p->linesize[0];
  334. }
  335. }
  336. av_freep(&zero);
  337. av_freep(&state);
  338. /* the specification says that after doing 0xff escaping unused bits in
  339. * the last byte must be set to 0, so just append 7 "optional" zero bits
  340. * to avoid special-casing. */
  341. put_bits(&pb2, 7, 0);
  342. size = put_bits_count(&pb2);
  343. flush_put_bits(&pb2);
  344. /* do escape coding */
  345. init_get_bits(&gb, buf2, size);
  346. size -= 7;
  347. while (get_bits_count(&gb) < size) {
  348. int v;
  349. v = get_bits(&gb, 8);
  350. put_bits(&pb, 8, v);
  351. if (v == 0xFF) {
  352. v = get_bits(&gb, 7);
  353. put_bits(&pb, 8, v);
  354. }
  355. }
  356. avpriv_align_put_bits(&pb);
  357. av_freep(&buf2);
  358. /* End of image */
  359. put_marker(&pb, EOI);
  360. flush_put_bits(&pb);
  361. emms_c();
  362. pkt->size = put_bits_count(&pb) >> 3;
  363. pkt->flags |= AV_PKT_FLAG_KEY;
  364. *got_packet = 1;
  365. return 0;
  366. memfail:
  367. av_packet_unref(pkt);
  368. av_freep(&buf2);
  369. av_freep(&state);
  370. av_freep(&zero);
  371. return AVERROR(ENOMEM);
  372. }
  373. static av_cold int encode_init_ls(AVCodecContext *ctx)
  374. {
  375. #if FF_API_CODED_FRAME
  376. FF_DISABLE_DEPRECATION_WARNINGS
  377. ctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
  378. ctx->coded_frame->key_frame = 1;
  379. FF_ENABLE_DEPRECATION_WARNINGS
  380. #endif
  381. if (ctx->pix_fmt != AV_PIX_FMT_GRAY8 &&
  382. ctx->pix_fmt != AV_PIX_FMT_GRAY16 &&
  383. ctx->pix_fmt != AV_PIX_FMT_RGB24 &&
  384. ctx->pix_fmt != AV_PIX_FMT_BGR24) {
  385. av_log(ctx, AV_LOG_ERROR,
  386. "Only grayscale and RGB24/BGR24 images are supported\n");
  387. return -1;
  388. }
  389. return 0;
  390. }
  391. #define OFFSET(x) offsetof(JPEGLSContext, x)
  392. #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  393. static const AVOption options[] = {
  394. { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE, "pred" },
  395. { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
  396. { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
  397. { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
  398. { NULL},
  399. };
  400. static const AVClass jpegls_class = {
  401. .class_name = "jpegls",
  402. .item_name = av_default_item_name,
  403. .option = options,
  404. .version = LIBAVUTIL_VERSION_INT,
  405. };
  406. AVCodec ff_jpegls_encoder = {
  407. .name = "jpegls",
  408. .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
  409. .type = AVMEDIA_TYPE_VIDEO,
  410. .id = AV_CODEC_ID_JPEGLS,
  411. .priv_data_size = sizeof(JPEGLSContext),
  412. .priv_class = &jpegls_class,
  413. .init = encode_init_ls,
  414. .capabilities = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
  415. .encode2 = encode_picture_ls,
  416. .pix_fmts = (const enum AVPixelFormat[]) {
  417. AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
  418. AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
  419. AV_PIX_FMT_NONE
  420. },
  421. .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
  422. FF_CODEC_CAP_INIT_CLEANUP,
  423. };