FFmpeg
j2kenc.c
Go to the documentation of this file.
1 /*
2  * JPEG2000 image encoder
3  * Copyright (c) 2007 Kamil Nowosad
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  *
28  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
29  * Copyright (c) 2002-2007, Professor Benoit Macq
30  * Copyright (c) 2001-2003, David Janssens
31  * Copyright (c) 2002-2003, Yannick Verschueren
32  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
33  * Copyright (c) 2005, Herve Drolon, FreeImage Team
34  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
35  * Copyright (c) 2020, Gautam Ramakrishnan <gautamramk@gmail.com>
36  * All rights reserved.
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  */
59 
60 
61 /**
62  * JPEG2000 image encoder
63  * @file
64  * @author Kamil Nowosad
65  */
66 
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"
80 
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))
85 
86 #define CODEC_JP2 1
87 #define CODEC_J2K 0
88 
89 static int lut_nmsedec_ref [1<<NMSEDEC_BITS],
93 
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}},
99 
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 {
108  double *layer_rates;
109 } Jpeg2000Tile;
110 
111 typedef struct {
112  AVClass *class;
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;
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;
128 
129  int64_t lambda;
130 
133 
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;
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 */
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 */
290 {
291  int lev = 0;
292  while (node->parent){
293  if (node->parent->val <= node->val)
294  break;
295  node->parent->val = node->val;
296  node = node->parent;
297  lev++;
298  }
299 }
300 
302 {
303  int i;
304 
305  if (s->buf_end - s->buf < 40 + 3 * s->ncomponents)
306  return -1;
307 
308  bytestream_put_be16(&s->buf, JPEG2000_SIZ);
309  bytestream_put_be16(&s->buf, 38 + 3 * s->ncomponents); // Lsiz
310  bytestream_put_be16(&s->buf, 0); // Rsiz
311  bytestream_put_be32(&s->buf, s->width); // width
312  bytestream_put_be32(&s->buf, s->height); // height
313  bytestream_put_be32(&s->buf, 0); // X0Siz
314  bytestream_put_be32(&s->buf, 0); // Y0Siz
315 
316  bytestream_put_be32(&s->buf, s->tile_width); // XTSiz
317  bytestream_put_be32(&s->buf, s->tile_height); // YTSiz
318  bytestream_put_be32(&s->buf, 0); // XT0Siz
319  bytestream_put_be32(&s->buf, 0); // YT0Siz
320  bytestream_put_be16(&s->buf, s->ncomponents); // CSiz
321 
322  for (i = 0; i < s->ncomponents; i++){ // Ssiz_i XRsiz_i, YRsiz_i
323  bytestream_put_byte(&s->buf, s->cbps[i] - 1);
324  bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[0]:1);
325  bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[1]:1);
326  }
327  return 0;
328 }
329 
331 {
332  Jpeg2000CodingStyle *codsty = &s->codsty;
333  uint8_t scod = 0;
334 
335  if (s->buf_end - s->buf < 14)
336  return -1;
337 
338  bytestream_put_be16(&s->buf, JPEG2000_COD);
339  bytestream_put_be16(&s->buf, 12); // Lcod
340  if (s->sop)
341  scod |= JPEG2000_CSTY_SOP;
342  if (s->eph)
343  scod |= JPEG2000_CSTY_EPH;
344  bytestream_put_byte(&s->buf, scod); // Scod
345  // SGcod
346  bytestream_put_byte(&s->buf, s->prog); // progression level
347  bytestream_put_be16(&s->buf, s->nlayers); // num of layers
348  if(s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){
349  bytestream_put_byte(&s->buf, 0); // unspecified
350  }else{
351  bytestream_put_byte(&s->buf, 0); // unspecified
352  }
353  // SPcod
354  bytestream_put_byte(&s->buf, codsty->nreslevels - 1); // num of decomp. levels
355  bytestream_put_byte(&s->buf, codsty->log2_cblk_width-2); // cblk width
356  bytestream_put_byte(&s->buf, codsty->log2_cblk_height-2); // cblk height
357  bytestream_put_byte(&s->buf, 0); // cblk style
358  bytestream_put_byte(&s->buf, codsty->transform == FF_DWT53); // transformation
359  return 0;
360 }
361 
362 static int put_qcd(Jpeg2000EncoderContext *s, int compno)
363 {
364  int i, size;
365  Jpeg2000CodingStyle *codsty = &s->codsty;
366  Jpeg2000QuantStyle *qntsty = &s->qntsty;
367 
368  if (qntsty->quantsty == JPEG2000_QSTY_NONE)
369  size = 4 + 3 * (codsty->nreslevels-1);
370  else // QSTY_SE
371  size = 5 + 6 * (codsty->nreslevels-1);
372 
373  if (s->buf_end - s->buf < size + 2)
374  return -1;
375 
376  bytestream_put_be16(&s->buf, JPEG2000_QCD);
377  bytestream_put_be16(&s->buf, size); // LQcd
378  bytestream_put_byte(&s->buf, (qntsty->nguardbits << 5) | qntsty->quantsty); // Sqcd
379  if (qntsty->quantsty == JPEG2000_QSTY_NONE)
380  for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
381  bytestream_put_byte(&s->buf, qntsty->expn[i] << 3);
382  else // QSTY_SE
383  for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
384  bytestream_put_be16(&s->buf, (qntsty->expn[i] << 11) | qntsty->mant[i]);
385  return 0;
386 }
387 
388 static int put_com(Jpeg2000EncoderContext *s, int compno)
389 {
390  int size = 4 + strlen(LIBAVCODEC_IDENT);
391 
392  if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
393  return 0;
394 
395  if (s->buf_end - s->buf < size + 2)
396  return -1;
397 
398  bytestream_put_be16(&s->buf, JPEG2000_COM);
399  bytestream_put_be16(&s->buf, size);
400  bytestream_put_be16(&s->buf, 1); // General use (ISO/IEC 8859-15 (Latin) values)
401 
403 
404  return 0;
405 }
406 
407 static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno)
408 {
409  uint8_t *psotptr;
410 
411  if (s->buf_end - s->buf < 12)
412  return NULL;
413 
414  bytestream_put_be16(&s->buf, JPEG2000_SOT);
415  bytestream_put_be16(&s->buf, 10); // Lsot
416  bytestream_put_be16(&s->buf, tileno); // Isot
417 
418  psotptr = s->buf;
419  bytestream_put_be32(&s->buf, 0); // Psot (filled in later)
420 
421  bytestream_put_byte(&s->buf, 0); // TPsot
422  bytestream_put_byte(&s->buf, 1); // TNsot
423  return psotptr;
424 }
425 
427 {
428  int i, j;
429  int layno, compno;
430  for (i = 0; i < s->numYtiles; i++) {
431  for (j = 0; j < s->numXtiles; j++) {
432  Jpeg2000Tile *tile = &s->tile[s->numXtiles * i + j];
433  for (compno = 0; compno < s->ncomponents; compno++) {
434  int tilew = tile->comp[compno].coord[0][1] - tile->comp[compno].coord[0][0];
435  int tileh = tile->comp[compno].coord[1][1] - tile->comp[compno].coord[1][0];
436  int scale = (compno?1 << s->chroma_shift[0]:1) * (compno?1 << s->chroma_shift[1]:1);
437  for (layno = 0; layno < s->nlayers; layno++) {
438  if (s->layer_rates[layno] > 0) {
439  tile->layer_rates[layno] += (double)(tilew * tileh) * s->ncomponents * s->cbps[compno] /
440  (double)(s->layer_rates[layno] * 8 * scale);
441  } else {
442  tile->layer_rates[layno] = 0.0;
443  }
444  }
445  }
446  }
447  }
448 
449 }
450 
451 /**
452  * compute the sizes of tiles, resolution levels, bands, etc.
453  * allocate memory for them
454  * divide the input image into tile-components
455  */
457 {
458  int tileno, tilex, tiley, compno;
459  Jpeg2000CodingStyle *codsty = &s->codsty;
460  Jpeg2000QuantStyle *qntsty = &s->qntsty;
461 
462  s->numXtiles = ff_jpeg2000_ceildiv(s->width, s->tile_width);
463  s->numYtiles = ff_jpeg2000_ceildiv(s->height, s->tile_height);
464 
465  s->tile = av_calloc(s->numXtiles, s->numYtiles * sizeof(Jpeg2000Tile));
466  if (!s->tile)
467  return AVERROR(ENOMEM);
468  for (tileno = 0, tiley = 0; tiley < s->numYtiles; tiley++)
469  for (tilex = 0; tilex < s->numXtiles; tilex++, tileno++){
470  Jpeg2000Tile *tile = s->tile + tileno;
471 
472  tile->comp = av_calloc(s->ncomponents, sizeof(*tile->comp));
473  if (!tile->comp)
474  return AVERROR(ENOMEM);
475 
476  tile->layer_rates = av_calloc(s->nlayers, sizeof(*tile->layer_rates));
477  if (!tile->layer_rates)
478  return AVERROR(ENOMEM);
479 
480  for (compno = 0; compno < s->ncomponents; compno++){
481  Jpeg2000Component *comp = tile->comp + compno;
482  int ret, i, j;
483 
484  comp->coord[0][0] = comp->coord_o[0][0] = tilex * s->tile_width;
485  comp->coord[0][1] = comp->coord_o[0][1] = FFMIN((tilex+1)*s->tile_width, s->width);
486  comp->coord[1][0] = comp->coord_o[1][0] = tiley * s->tile_height;
487  comp->coord[1][1] = comp->coord_o[1][1] = FFMIN((tiley+1)*s->tile_height, s->height);
488  if (compno > 0)
489  for (i = 0; i < 2; i++)
490  for (j = 0; j < 2; j++)
491  comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]);
492 
494  codsty,
495  qntsty,
496  s->cbps[compno],
497  compno?1<<s->chroma_shift[0]:1,
498  compno?1<<s->chroma_shift[1]:1,
499  s->avctx
500  )) < 0)
501  return ret;
502  }
503  }
504  compute_rates(s);
505  return 0;
506 }
507 
508 #define COPY_FRAME(D, PIXEL) \
509  static void copy_frame_ ##D(Jpeg2000EncoderContext *s) \
510  { \
511  int tileno, compno, i, y, x; \
512  PIXEL *line; \
513  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){ \
514  Jpeg2000Tile *tile = s->tile + tileno; \
515  if (s->planar){ \
516  for (compno = 0; compno < s->ncomponents; compno++){ \
517  Jpeg2000Component *comp = tile->comp + compno; \
518  int *dst = comp->i_data; \
519  int cbps = s->cbps[compno]; \
520  line = (PIXEL*)s->picture->data[compno] \
521  + comp->coord[1][0] * (s->picture->linesize[compno] / sizeof(PIXEL)) \
522  + comp->coord[0][0]; \
523  for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){ \
524  PIXEL *ptr = line; \
525  for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++) \
526  *dst++ = *ptr++ - (1 << (cbps - 1)); \
527  line += s->picture->linesize[compno] / sizeof(PIXEL); \
528  } \
529  } \
530  } else{ \
531  line = (PIXEL*)s->picture->data[0] + tile->comp[0].coord[1][0] * (s->picture->linesize[0] / sizeof(PIXEL)) \
532  + tile->comp[0].coord[0][0] * s->ncomponents; \
533  \
534  i = 0; \
535  for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){ \
536  PIXEL *ptr = line; \
537  for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){ \
538  for (compno = 0; compno < s->ncomponents; compno++){ \
539  int cbps = s->cbps[compno]; \
540  tile->comp[compno].i_data[i] = *ptr++ - (1 << (cbps - 1)); \
541  } \
542  } \
543  line += s->picture->linesize[0] / sizeof(PIXEL); \
544  } \
545  } \
546  } \
547  }
548 
549 COPY_FRAME(8, uint8_t)
550 COPY_FRAME(16, uint16_t)
551 
553 {
554  int compno, reslevelno, bandno;
555  Jpeg2000QuantStyle *qntsty = &s->qntsty;
556  Jpeg2000CodingStyle *codsty = &s->codsty;
557 
558  for (compno = 0; compno < s->ncomponents; compno++){
559  int gbandno = 0;
560  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
561  int nbands, lev = codsty->nreslevels - reslevelno - 1;
562  nbands = reslevelno ? 3 : 1;
563  for (bandno = 0; bandno < nbands; bandno++, gbandno++){
564  int expn, mant = 0;
565 
566  if (codsty->transform == FF_DWT97_INT){
567  int bandpos = bandno + (reslevelno>0),
568  ss = 81920000 / dwt_norms[0][bandpos][lev],
569  log = av_log2(ss);
570  mant = (11 - log < 0 ? ss >> log - 11 : ss << 11 - log) & 0x7ff;
571  expn = s->cbps[compno] - log + 13;
572  } else
573  expn = ((bandno&2)>>1) + (reslevelno>0) + s->cbps[compno];
574 
575  qntsty->expn[gbandno] = expn;
576  qntsty->mant[gbandno] = mant;
577  }
578  }
579  }
580 }
581 
582 static void init_luts(void)
583 {
584  int i, a,
585  mask = ~((1<<NMSEDEC_FRACBITS)-1);
586 
587  for (i = 0; i < (1 << NMSEDEC_BITS); i++){
588  lut_nmsedec_sig[i] = FFMAX((3 * i << (13 - NMSEDEC_FRACBITS)) - (9 << 11), 0);
589  lut_nmsedec_sig0[i] = FFMAX((i*i + (1<<NMSEDEC_FRACBITS-1) & mask) << 1, 0);
590 
591  a = (i >> (NMSEDEC_BITS-2)&2) + 1;
592  lut_nmsedec_ref[i] = FFMAX((a - 2) * (i << (13 - NMSEDEC_FRACBITS)) +
593  (1 << 13) - (a * a << 11), 0);
594  lut_nmsedec_ref0[i] = FFMAX(((i * i - (i << NMSEDEC_BITS) + (1 << 2 * NMSEDEC_FRACBITS) + (1 << (NMSEDEC_FRACBITS - 1))) & mask)
595  << 1, 0);
596  }
598 }
599 
600 /* tier-1 routines */
601 static int getnmsedec_sig(int x, int bpno)
602 {
603  if (bpno > NMSEDEC_FRACBITS)
604  return lut_nmsedec_sig[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
605  return lut_nmsedec_sig0[x & ((1 << NMSEDEC_BITS) - 1)];
606 }
607 
608 static int getnmsedec_ref(int x, int bpno)
609 {
610  if (bpno > NMSEDEC_FRACBITS)
611  return lut_nmsedec_ref[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
612  return lut_nmsedec_ref0[x & ((1 << NMSEDEC_BITS) - 1)];
613 }
614 
615 static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
616 {
617  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
618  for (y0 = 0; y0 < height; y0 += 4)
619  for (x = 0; x < width; x++)
620  for (y = y0; y < height && y < y0+4; y++){
621  if (!(t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG) && (t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB)){
622  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno),
623  bit = t1->data[(y) * t1->stride + x] & mask ? 1 : 0;
624  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, bit);
625  if (bit){
626  int xorbit;
627  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
628  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
629  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
630  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
631  }
632  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_VIS;
633  }
634  }
635 }
636 
637 static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
638 {
639  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
640  for (y0 = 0; y0 < height; y0 += 4)
641  for (x = 0; x < width; x++)
642  for (y = y0; y < height && y < y0+4; y++)
643  if ((t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG){
644  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y+1) * t1->stride + x+1]);
645  *nmsedec += getnmsedec_ref(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
646  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
647  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_REF;
648  }
649 }
650 
651 static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
652 {
653  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
654  for (y0 = 0; y0 < height; y0 += 4)
655  for (x = 0; x < width; x++){
656  if (y0 + 3 < height && !(
657  (t1->flags[(y0+1) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
658  (t1->flags[(y0+2) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
659  (t1->flags[(y0+3) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
660  (t1->flags[(y0+4) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG))))
661  {
662  // aggregation mode
663  int rlen;
664  for (rlen = 0; rlen < 4; rlen++)
665  if (t1->data[(y0+rlen) * t1->stride + x] & mask)
666  break;
667  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL, rlen != 4);
668  if (rlen == 4)
669  continue;
670  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen >> 1);
671  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen & 1);
672  for (y = y0 + rlen; y < y0 + 4; y++){
673  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
674  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
675  if (y > y0 + rlen)
676  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
677  if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
678  int xorbit;
679  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
680  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
681  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
682  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
683  }
684  }
685  t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
686  }
687  } else{
688  for (y = y0; y < y0 + 4 && y < height; y++){
689  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
690  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
691  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
692  if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
693  int xorbit;
694  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
695  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
696  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
697  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
698  }
699  }
700  t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
701  }
702  }
703  }
704 }
705 
707  int width, int height, int bandpos, int lev)
708 {
709  int pass_t = 2, passno, x, y, max=0, nmsedec, bpno;
710  int64_t wmsedec = 0;
711 
712  memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
713 
714  for (y = 0; y < height; y++){
715  for (x = 0; x < width; x++){
716  if (t1->data[(y) * t1->stride + x] < 0){
717  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_SGN;
718  t1->data[(y) * t1->stride + x] = -t1->data[(y) * t1->stride + x];
719  }
720  max = FFMAX(max, t1->data[(y) * t1->stride + x]);
721  }
722  }
723 
724  if (max == 0){
725  cblk->nonzerobits = 0;
726  bpno = 0;
727  } else{
728  cblk->nonzerobits = av_log2(max) + 1 - NMSEDEC_FRACBITS;
729  bpno = cblk->nonzerobits - 1;
730  }
731 
732  cblk->data[0] = 0;
733  ff_mqc_initenc(&t1->mqc, cblk->data + 1);
734 
735  for (passno = 0; bpno >= 0; passno++){
736  nmsedec=0;
737 
738  switch(pass_t){
739  case 0: encode_sigpass(t1, width, height, bandpos, &nmsedec, bpno);
740  break;
741  case 1: encode_refpass(t1, width, height, &nmsedec, bpno);
742  break;
743  case 2: encode_clnpass(t1, width, height, bandpos, &nmsedec, bpno);
744  break;
745  }
746 
747  cblk->passes[passno].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno].flushed, &cblk->passes[passno].flushed_len);
748  cblk->passes[passno].rate -= cblk->passes[passno].flushed_len;
749 
750  wmsedec += (int64_t)nmsedec << (2*bpno);
751  cblk->passes[passno].disto = wmsedec;
752 
753  if (++pass_t == 3){
754  pass_t = 0;
755  bpno--;
756  }
757  }
758  cblk->npasses = passno;
759  cblk->ninclpasses = passno;
760 
761  if (passno) {
762  cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);
763  cblk->passes[passno-1].rate -= cblk->passes[passno-1].flushed_len;
764  }
765 }
766 
767 /* tier-2 routines: */
768 
770 {
771  if (n == 1)
772  put_num(s, 0, 1);
773  else if (n == 2)
774  put_num(s, 2, 2);
775  else if (n <= 5)
776  put_num(s, 0xc | (n-3), 4);
777  else if (n <= 36)
778  put_num(s, 0x1e0 | (n-6), 9);
779  else
780  put_num(s, 0xff80 | (n-37), 16);
781 }
782 
783 
784 static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno,
785  int precno, uint8_t *expn, int numgbits, int packetno,
786  int nlayers)
787 {
788  int bandno, empty = 1;
789  int i;
790  // init bitstream
791  *s->buf = 0;
792  s->bit_index = 0;
793 
794  if (s->sop) {
795  bytestream_put_be16(&s->buf, JPEG2000_SOP);
796  bytestream_put_be16(&s->buf, 4);
797  bytestream_put_be16(&s->buf, packetno);
798  }
799  // header
800 
801  if (!layno) {
802  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
803  Jpeg2000Band *band = rlevel->band + bandno;
804  if (band->coord[0][0] < band->coord[0][1]
805  && band->coord[1][0] < band->coord[1][1]) {
806  Jpeg2000Prec *prec = band->prec + precno;
807  int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
808  int pos;
811  for (pos = 0; pos < nb_cblks; pos++) {
812  Jpeg2000Cblk *cblk = &prec->cblk[pos];
813  prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - cblk->nonzerobits;
814  cblk->incl = 0;
815  cblk->lblock = 3;
816  tag_tree_update(prec->zerobits + pos);
817  for (i = 0; i < nlayers; i++) {
818  if (cblk->layers[i].npasses > 0) {
819  prec->cblkincl[pos].val = i;
820  break;
821  }
822  }
823  if (i == nlayers)
824  prec->cblkincl[pos].val = i;
825  tag_tree_update(prec->cblkincl + pos);
826  }
827  }
828  }
829  }
830 
831  // is the packet empty?
832  for (bandno = 0; bandno < rlevel->nbands; bandno++){
833  Jpeg2000Band *band = rlevel->band + bandno;
834  if (band->coord[0][0] < band->coord[0][1]
835  && band->coord[1][0] < band->coord[1][1]) {
836  Jpeg2000Prec *prec = band->prec + precno;
837  int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
838  int pos;
839  for (pos = 0; pos < nb_cblks; pos++) {
840  Jpeg2000Cblk *cblk = &prec->cblk[pos];
841  if (cblk->layers[layno].npasses) {
842  empty = 0;
843  break;
844  }
845  }
846  if (!empty)
847  break;
848  }
849  }
850 
851  put_bits(s, !empty, 1);
852  if (empty){
853  j2k_flush(s);
854  if (s->eph)
855  bytestream_put_be16(&s->buf, JPEG2000_EPH);
856  return 0;
857  }
858 
859  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
860  Jpeg2000Band *band = rlevel->band + bandno;
861  Jpeg2000Prec *prec = band->prec + precno;
862  int yi, xi, pos;
863  int cblknw = prec->nb_codeblocks_width;
864 
865  if (band->coord[0][0] == band->coord[0][1]
866  || band->coord[1][0] == band->coord[1][1])
867  continue;
868 
869  for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++) {
870  for (xi = 0; xi < cblknw; xi++, pos++){
871  int llen = 0, length;
872  Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
873 
874  if (s->buf_end - s->buf < 20) // approximately
875  return -1;
876 
877  // inclusion information
878  if (!cblk->incl)
879  tag_tree_code(s, prec->cblkincl + pos, layno + 1);
880  else {
881  put_bits(s, cblk->layers[layno].npasses > 0, 1);
882  }
883 
884  if (!cblk->layers[layno].npasses)
885  continue;
886 
887  // zerobits information
888  if (!cblk->incl) {
889  tag_tree_code(s, prec->zerobits + pos, 100);
890  cblk->incl = 1;
891  }
892 
893  // number of passes
894  putnumpasses(s, cblk->layers[layno].npasses);
895 
896  length = cblk->layers[layno].data_len;
897  if (layno == nlayers - 1 && cblk->layers[layno].cum_passes){
898  length += cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len;
899  }
900  if (cblk->lblock + av_log2(cblk->layers[layno].npasses) < av_log2(length) + 1) {
901  llen = av_log2(length) + 1 - cblk->lblock - av_log2(cblk->layers[layno].npasses);
902  }
903 
904  // length of code block
905  cblk->lblock += llen;
906  put_bits(s, 1, llen);
907  put_bits(s, 0, 1);
908  put_num(s, length, cblk->lblock + av_log2(cblk->layers[layno].npasses));
909  }
910  }
911  }
912  j2k_flush(s);
913  if (s->eph) {
914  bytestream_put_be16(&s->buf, JPEG2000_EPH);
915  }
916 
917  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
918  Jpeg2000Band *band = rlevel->band + bandno;
919  Jpeg2000Prec *prec = band->prec + precno;
920  int yi, cblknw = prec->nb_codeblocks_width;
921  for (yi =0; yi < prec->nb_codeblocks_height; yi++) {
922  int xi;
923  for (xi = 0; xi < cblknw; xi++){
924  Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
925  if (cblk->layers[layno].npasses) {
926  if (s->buf_end - s->buf < cblk->layers[layno].data_len + 2)
927  return -1;
928  bytestream_put_buffer(&s->buf, cblk->layers[layno].data_start + 1, cblk->layers[layno].data_len);
929  if (layno == nlayers - 1 && cblk->layers[layno].cum_passes) {
930  bytestream_put_buffer(&s->buf, cblk->passes[cblk->layers[layno].cum_passes-1].flushed,
931  cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len);
932  }
933  }
934  }
935  }
936  }
937  return 0;
938 }
939 
940 static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
941 {
942  int compno, reslevelno, layno, ret;
943  Jpeg2000CodingStyle *codsty = &s->codsty;
944  Jpeg2000QuantStyle *qntsty = &s->qntsty;
945  int packetno = 0;
946  int step_x, step_y;
947  int x, y;
948  int tile_coord[2][2];
949  int col = tileno % s->numXtiles;
950  int row = tileno / s->numXtiles;
951 
952  tile_coord[0][0] = col * s->tile_width;
953  tile_coord[0][1] = FFMIN(tile_coord[0][0] + s->tile_width, s->width);
954  tile_coord[1][0] = row * s->tile_height;
955  tile_coord[1][1] = FFMIN(tile_coord[1][0] + s->tile_height, s->height);
956 
957  av_log(s->avctx, AV_LOG_DEBUG, "tier2\n");
958  // lay-rlevel-comp-pos progression
959  switch (s->prog) {
960  case JPEG2000_PGOD_LRCP:
961  for (layno = 0; layno < nlayers; layno++) {
962  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
963  for (compno = 0; compno < s->ncomponents; compno++){
964  int precno;
965  Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
966  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
967  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
968  qntsty->nguardbits, packetno++, nlayers)) < 0)
969  return ret;
970  }
971  }
972  }
973  }
974  break;
975  case JPEG2000_PGOD_RLCP:
976  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
977  for (layno = 0; layno < nlayers; layno++) {
978  for (compno = 0; compno < s->ncomponents; compno++){
979  int precno;
980  Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
981  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
982  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
983  qntsty->nguardbits, packetno++, nlayers)) < 0)
984  return ret;
985  }
986  }
987  }
988  }
989  break;
990  case JPEG2000_PGOD_RPCL:
991  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
992  int precno;
993  step_x = 30;
994  step_y = 30;
995  for (compno = 0; compno < s->ncomponents; compno++) {
996  Jpeg2000Component *comp = tile->comp + compno;
997  if (reslevelno < codsty->nreslevels) {
998  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
999  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1000  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1001  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1002  }
1003  }
1004 
1005  step_x = 1<<step_x;
1006  step_y = 1<<step_y;
1007  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1008  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1009  for (compno = 0; compno < s->ncomponents; compno++) {
1010  Jpeg2000Component *comp = tile->comp + compno;
1011  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1012  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1013  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1014  unsigned prcx, prcy;
1015  int trx0, try0;
1016 
1017  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1018  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1019 
1020  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1021  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1022  continue;
1023 
1024  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1025  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1026  continue;
1027 
1028  // check if a precinct exists
1029  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1030  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1031  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1032  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1033  precno = prcx + reslevel->num_precincts_x * prcy;
1034 
1035  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1036  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1037  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1038  continue;
1039  }
1040  for (layno = 0; layno < nlayers; layno++) {
1041  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1042  qntsty->nguardbits, packetno++, nlayers)) < 0)
1043  return ret;
1044  }
1045  }
1046  }
1047  }
1048  }
1049  break;
1050  case JPEG2000_PGOD_PCRL:
1051  step_x = 32;
1052  step_y = 32;
1053  for (compno = 0; compno < s->ncomponents; compno++) {
1054  Jpeg2000Component *comp = tile->comp + compno;
1055 
1056  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1057  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1058  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1059  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1060  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1061  }
1062  }
1063  if (step_x >= 31 || step_y >= 31){
1064  avpriv_request_sample(s->avctx, "PCRL with large step");
1065  return AVERROR_PATCHWELCOME;
1066  }
1067  step_x = 1<<step_x;
1068  step_y = 1<<step_y;
1069 
1070  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1071  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1072  for (compno = 0; compno < s->ncomponents; compno++) {
1073  Jpeg2000Component *comp = tile->comp + compno;
1074  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1075 
1076  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1077  unsigned prcx, prcy;
1078  int precno;
1079  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1080  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1081  int trx0, try0;
1082 
1083  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1084  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1085 
1086  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1087  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1088  continue;
1089 
1090  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1091  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1092  continue;
1093 
1094  // check if a precinct exists
1095  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1096  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1097  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1098  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1099 
1100  precno = prcx + reslevel->num_precincts_x * prcy;
1101 
1102  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1103  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1104  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1105  continue;
1106  }
1107  for (layno = 0; layno < nlayers; layno++) {
1108  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1109  qntsty->nguardbits, packetno++, nlayers)) < 0)
1110  return ret;
1111  }
1112  }
1113  }
1114  }
1115  }
1116  break;
1117  case JPEG2000_PGOD_CPRL:
1118  for (compno = 0; compno < s->ncomponents; compno++) {
1119  Jpeg2000Component *comp = tile->comp + compno;
1120  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1121  step_x = 32;
1122  step_y = 32;
1123 
1124  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1125  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1126  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1127  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1128  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1129  }
1130  if (step_x >= 31 || step_y >= 31){
1131  avpriv_request_sample(s->avctx, "CPRL with large step");
1132  return AVERROR_PATCHWELCOME;
1133  }
1134  step_x = 1<<step_x;
1135  step_y = 1<<step_y;
1136 
1137  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1138  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1139  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1140  unsigned prcx, prcy;
1141  int precno;
1142  int trx0, try0;
1143  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1144  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1145 
1146  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1147  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1148 
1149  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1150  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1151  continue;
1152 
1153  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1154  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1155  continue;
1156 
1157  // check if a precinct exists
1158  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1159  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1160  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1161  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1162 
1163  precno = prcx + reslevel->num_precincts_x * prcy;
1164 
1165  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1166  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1167  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1168  continue;
1169  }
1170  for (layno = 0; layno < nlayers; layno++) {
1171  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1172  qntsty->nguardbits, packetno++, nlayers)) < 0)
1173  return ret;
1174  }
1175  }
1176  }
1177  }
1178  }
1179 
1180  }
1181 
1182  av_log(s->avctx, AV_LOG_DEBUG, "after tier2\n");
1183  return 0;
1184 }
1185 
1186 static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile* tile, int final)
1187 {
1188  int compno, resno, bandno, precno, cblkno;
1189  int passno;
1190 
1191  for (compno = 0; compno < s->ncomponents; compno++) {
1192  Jpeg2000Component *comp = &tile->comp[compno];
1193 
1194  for (resno = 0; resno < s->codsty.nreslevels; resno++) {
1195  Jpeg2000ResLevel *reslevel = comp->reslevel + resno;
1196 
1197  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1198  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1199  Jpeg2000Band *band = reslevel->band + bandno;
1200  Jpeg2000Prec *prec = band->prec + precno;
1201 
1202  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1203  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1204  Jpeg2000Layer *layer = &cblk->layers[layno];
1205  int n;
1206 
1207  if (layno == 0) {
1208  cblk->ninclpasses = 0;
1209  }
1210 
1211  n = cblk->ninclpasses;
1212 
1213  if (thresh < 0) {
1214  n = cblk->npasses;
1215  } else {
1216  for (passno = cblk->ninclpasses; passno < cblk->npasses; passno++) {
1217  int32_t dr;
1218  double dd;
1219  Jpeg2000Pass *pass = &cblk->passes[passno];
1220 
1221  if (n == 0) {
1222  dr = pass->rate;
1223  dd = pass->disto;
1224  } else {
1225  dr = pass->rate - cblk->passes[n - 1].rate;
1226  dd = pass->disto - cblk->passes[n-1].disto;
1227  }
1228 
1229  if (!dr) {
1230  if (dd != 0.0) {
1231  n = passno + 1;
1232  }
1233  continue;
1234  }
1235 
1236  if (thresh - (dd / dr) < DBL_EPSILON)
1237  n = passno + 1;
1238  }
1239  }
1240  layer->npasses = n - cblk->ninclpasses;
1241  layer->cum_passes = n;
1242 
1243  if (layer->npasses == 0) {
1244  layer->disto = 0;
1245  layer->data_len = 0;
1246  continue;
1247  }
1248 
1249  if (cblk->ninclpasses == 0) {
1250  layer->data_len = cblk->passes[n - 1].rate;
1251  layer->data_start = cblk->data;
1252  layer->disto = cblk->passes[n - 1].disto;
1253  } else {
1254  layer->data_len = cblk->passes[n - 1].rate - cblk->passes[cblk->ninclpasses - 1].rate;
1255  layer->data_start = cblk->data + cblk->passes[cblk->ninclpasses - 1].rate;
1256  layer->disto = cblk->passes[n - 1].disto -
1257  cblk->passes[cblk->ninclpasses - 1].disto;
1258  }
1259  if (final) {
1260  cblk->ninclpasses = n;
1261  }
1262  }
1263  }
1264  }
1265  }
1266  }
1267 }
1268 
1270 {
1271  int precno, compno, reslevelno, bandno, cblkno, lev, passno, layno;
1272  int i;
1273  double min = DBL_MAX;
1274  double max = 0;
1275  double thresh;
1276 
1277  Jpeg2000CodingStyle *codsty = &s->codsty;
1278 
1279  for (compno = 0; compno < s->ncomponents; compno++){
1280  Jpeg2000Component *comp = tile->comp + compno;
1281 
1282  for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1283  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1284 
1285  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1286  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1287  Jpeg2000Band *band = reslevel->band + bandno;
1288  Jpeg2000Prec *prec = band->prec + precno;
1289 
1290  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1291  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1292  for (passno = 0; passno < cblk->npasses; passno++) {
1293  Jpeg2000Pass *pass = &cblk->passes[passno];
1294  int dr;
1295  double dd, drslope;
1296 
1297  if (passno == 0) {
1298  dr = (int32_t)pass->rate;
1299  dd = pass->disto;
1300  } else {
1301  dr = (int32_t)(pass->rate - cblk->passes[passno - 1].rate);
1302  dd = pass->disto - cblk->passes[passno - 1].disto;
1303  }
1304 
1305  if (dr <= 0)
1306  continue;
1307 
1308  drslope = dd / dr;
1309  if (drslope < min)
1310  min = drslope;
1311 
1312  if (drslope > max)
1313  max = drslope;
1314  }
1315  }
1316  }
1317  }
1318  }
1319  }
1320 
1321  for (layno = 0; layno < s->nlayers; layno++) {
1322  double lo = min;
1323  double hi = max;
1324  double stable_thresh = 0.0;
1325  double good_thresh = 0.0;
1326  if (!s->layer_rates[layno]) {
1327  good_thresh = -1.0;
1328  } else {
1329  for (i = 0; i < 128; i++) {
1330  uint8_t *stream_pos = s->buf;
1331  int ret;
1332  thresh = (lo + hi) / 2;
1333  makelayer(s, layno, thresh, tile, 0);
1334  ret = encode_packets(s, tile, (int)(tile - s->tile), layno + 1);
1335  memset(stream_pos, 0, s->buf - stream_pos);
1336  if ((s->buf - stream_pos > ceil(tile->layer_rates[layno])) || ret < 0) {
1337  lo = thresh;
1338  s->buf = stream_pos;
1339  continue;
1340  }
1341  hi = thresh;
1342  stable_thresh = thresh;
1343  s->buf = stream_pos;
1344  }
1345  }
1346  if (good_thresh >= 0.0)
1347  good_thresh = stable_thresh == 0.0 ? thresh : stable_thresh;
1348  makelayer(s, layno, good_thresh, tile, 1);
1349  }
1350 }
1351 
1352 static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
1353 {
1354  int passno, res = 0;
1355  for (passno = 0; passno < cblk->npasses; passno++){
1356  int dr;
1357  int64_t dd;
1358 
1359  dr = cblk->passes[passno].rate
1360  - (res ? cblk->passes[res-1].rate : 0);
1361  dd = cblk->passes[passno].disto
1362  - (res ? cblk->passes[res-1].disto : 0);
1363 
1364  if (((dd * dwt_norm) >> WMSEDEC_SHIFT) * dwt_norm >= dr * lambda)
1365  res = passno+1;
1366  }
1367  return res;
1368 }
1369 
1371 {
1372  int precno, compno, reslevelno, bandno, cblkno, lev;
1373  Jpeg2000CodingStyle *codsty = &s->codsty;
1374 
1375  for (compno = 0; compno < s->ncomponents; compno++){
1376  Jpeg2000Component *comp = tile->comp + compno;
1377 
1378  for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1379  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1380 
1381  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1382  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1383  int bandpos = bandno + (reslevelno > 0);
1384  Jpeg2000Band *band = reslevel->band + bandno;
1385  Jpeg2000Prec *prec = band->prec + precno;
1386 
1387  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1388  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1389 
1390  cblk->ninclpasses = getcut(cblk, s->lambda,
1391  (int64_t)dwt_norms[codsty->transform == FF_DWT53][bandpos][lev] * (int64_t)band->i_stepsize >> 15);
1392  cblk->layers[0].data_start = cblk->data;
1393  cblk->layers[0].cum_passes = cblk->ninclpasses;
1394  cblk->layers[0].npasses = cblk->ninclpasses;
1395  if (cblk->ninclpasses)
1396  cblk->layers[0].data_len = cblk->passes[cblk->ninclpasses - 1].rate;
1397  }
1398  }
1399  }
1400  }
1401  }
1402 }
1403 
1404 static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
1405 {
1406  int compno, reslevelno, bandno, ret;
1408  Jpeg2000CodingStyle *codsty = &s->codsty;
1409  for (compno = 0; compno < s->ncomponents; compno++){
1410  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1411 
1412  t1.stride = (1<<codsty->log2_cblk_width) + 2;
1413 
1414  av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");
1415  if ((ret = ff_dwt_encode(&comp->dwt, comp->i_data)) < 0)
1416  return ret;
1417  av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
1418 
1419  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
1420  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1421 
1422  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1423  Jpeg2000Band *band = reslevel->band + bandno;
1424  Jpeg2000Prec *prec = band->prec; // we support only 1 precinct per band ATM in the encoder
1425  int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
1426  yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
1427  y0 = yy0;
1428  yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,
1429  band->coord[1][1]) - band->coord[1][0] + yy0;
1430 
1431  if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])
1432  continue;
1433 
1434  bandpos = bandno + (reslevelno > 0);
1435 
1436  for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){
1437  if (reslevelno == 0 || bandno == 1)
1438  xx0 = 0;
1439  else
1440  xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];
1441  x0 = xx0;
1442  xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,
1443  band->coord[0][1]) - band->coord[0][0] + xx0;
1444 
1445  for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){
1446  int y, x;
1447  if (codsty->transform == FF_DWT53){
1448  for (y = yy0; y < yy1; y++){
1449  int *ptr = t1.data + (y-yy0)*t1.stride;
1450  for (x = xx0; x < xx1; x++){
1451  *ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] * (1 << NMSEDEC_FRACBITS);
1452  }
1453  }
1454  } else{
1455  for (y = yy0; y < yy1; y++){
1456  int *ptr = t1.data + (y-yy0)*t1.stride;
1457  for (x = xx0; x < xx1; x++){
1458  *ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
1459  *ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 15 - NMSEDEC_FRACBITS;
1460  ptr++;
1461  }
1462  }
1463  }
1464  if (!prec->cblk[cblkno].data)
1465  prec->cblk[cblkno].data = av_malloc(1 + 8192);
1466  if (!prec->cblk[cblkno].passes)
1467  prec->cblk[cblkno].passes = av_malloc_array(JPEG2000_MAX_PASSES, sizeof (*prec->cblk[cblkno].passes));
1468  if (!prec->cblk[cblkno].data || !prec->cblk[cblkno].passes)
1469  return AVERROR(ENOMEM);
1470  encode_cblk(s, &t1, prec->cblk + cblkno, tile, xx1 - xx0, yy1 - yy0,
1471  bandpos, codsty->nreslevels - reslevelno - 1);
1472  xx0 = xx1;
1473  xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);
1474  }
1475  yy0 = yy1;
1476  yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);
1477  }
1478  }
1479  }
1480  av_log(s->avctx, AV_LOG_DEBUG, "after tier1\n");
1481  }
1482 
1483  av_log(s->avctx, AV_LOG_DEBUG, "rate control\n");
1484  if (s->compression_rate_enc)
1485  makelayers(s, tile);
1486  else
1487  truncpasses(s, tile);
1488 
1489  if ((ret = encode_packets(s, tile, tileno, s->nlayers)) < 0)
1490  return ret;
1491  av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n");
1492  return 0;
1493 }
1494 
1496 {
1497  int tileno, compno;
1498  Jpeg2000CodingStyle *codsty = &s->codsty;
1499 
1500  if (!s->tile)
1501  return;
1502  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1503  if (s->tile[tileno].comp) {
1504  for (compno = 0; compno < s->ncomponents; compno++){
1505  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1506  ff_jpeg2000_cleanup(comp, codsty);
1507  }
1508  av_freep(&s->tile[tileno].comp);
1509  }
1510  av_freep(&s->tile[tileno].layer_rates);
1511  }
1512  av_freep(&s->tile);
1513 }
1514 
1516 {
1517  int tileno, compno;
1518  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1519  Jpeg2000Tile *tile = s->tile + tileno;
1520  for (compno = 0; compno < s->ncomponents; compno++)
1521  ff_jpeg2000_reinit(tile->comp + compno, &s->codsty);
1522  }
1523 }
1524 
1525 static void update_size(uint8_t *size, const uint8_t *end)
1526 {
1527  AV_WB32(size, end-size);
1528 }
1529 
1531  const AVFrame *pict, int *got_packet)
1532 {
1533  int tileno, ret;
1535  uint8_t *chunkstart, *jp2cstart, *jp2hstart;
1536 
1537  if ((ret = ff_alloc_packet(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
1538  return ret;
1539 
1540  // init:
1541  s->buf = s->buf_start = pkt->data;
1542  s->buf_end = pkt->data + pkt->size;
1543 
1544  s->picture = pict;
1545 
1546  s->lambda = s->picture->quality * LAMBDA_SCALE;
1547 
1548  if (avctx->pix_fmt == AV_PIX_FMT_BGR48 || avctx->pix_fmt == AV_PIX_FMT_GRAY16)
1549  copy_frame_16(s);
1550  else
1551  copy_frame_8(s);
1552 
1553  reinit(s);
1554 
1555  if (s->format == CODEC_JP2) {
1556  av_assert0(s->buf == pkt->data);
1557 
1558  bytestream_put_be32(&s->buf, 0x0000000C);
1559  bytestream_put_be32(&s->buf, 0x6A502020);
1560  bytestream_put_be32(&s->buf, 0x0D0A870A);
1561 
1562  chunkstart = s->buf;
1563  bytestream_put_be32(&s->buf, 0);
1564  bytestream_put_buffer(&s->buf, "ftyp", 4);
1565  bytestream_put_buffer(&s->buf, "jp2\040\040", 4);
1566  bytestream_put_be32(&s->buf, 0);
1567  bytestream_put_buffer(&s->buf, "jp2\040", 4);
1568  update_size(chunkstart, s->buf);
1569 
1570  jp2hstart = s->buf;
1571  bytestream_put_be32(&s->buf, 0);
1572  bytestream_put_buffer(&s->buf, "jp2h", 4);
1573 
1574  chunkstart = s->buf;
1575  bytestream_put_be32(&s->buf, 0);
1576  bytestream_put_buffer(&s->buf, "ihdr", 4);
1577  bytestream_put_be32(&s->buf, avctx->height);
1578  bytestream_put_be32(&s->buf, avctx->width);
1579  bytestream_put_be16(&s->buf, s->ncomponents);
1580  bytestream_put_byte(&s->buf, s->cbps[0]);
1581  bytestream_put_byte(&s->buf, 7);
1582  bytestream_put_byte(&s->buf, 0);
1583  bytestream_put_byte(&s->buf, 0);
1584  update_size(chunkstart, s->buf);
1585 
1586  chunkstart = s->buf;
1587  bytestream_put_be32(&s->buf, 0);
1588  bytestream_put_buffer(&s->buf, "colr", 4);
1589  bytestream_put_byte(&s->buf, 1);
1590  bytestream_put_byte(&s->buf, 0);
1591  bytestream_put_byte(&s->buf, 0);
1592  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1593  bytestream_put_be32(&s->buf, 16);
1594  } else if (s->ncomponents == 1) {
1595  bytestream_put_be32(&s->buf, 17);
1596  } else {
1597  bytestream_put_be32(&s->buf, 18);
1598  }
1599  update_size(chunkstart, s->buf);
1600  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1601  int i;
1602  uint8_t *palette = pict->data[1];
1603  chunkstart = s->buf;
1604  bytestream_put_be32(&s->buf, 0);
1605  bytestream_put_buffer(&s->buf, "pclr", 4);
1606  bytestream_put_be16(&s->buf, AVPALETTE_COUNT);
1607  bytestream_put_byte(&s->buf, 3); // colour channels
1608  bytestream_put_be24(&s->buf, 0x070707); //colour depths
1609  for (i = 0; i < AVPALETTE_COUNT; i++) {
1610  bytestream_put_be24(&s->buf, HAVE_BIGENDIAN ? AV_RB24(palette + 1) : AV_RL24(palette));
1611  palette += 4;
1612  }
1613  update_size(chunkstart, s->buf);
1614  chunkstart = s->buf;
1615  bytestream_put_be32(&s->buf, 0);
1616  bytestream_put_buffer(&s->buf, "cmap", 4);
1617  for (i = 0; i < 3; i++) {
1618  bytestream_put_be16(&s->buf, 0); // component
1619  bytestream_put_byte(&s->buf, 1); // palette mapping
1620  bytestream_put_byte(&s->buf, i); // index
1621  }
1622  update_size(chunkstart, s->buf);
1623  }
1624  update_size(jp2hstart, s->buf);
1625 
1626  jp2cstart = s->buf;
1627  bytestream_put_be32(&s->buf, 0);
1628  bytestream_put_buffer(&s->buf, "jp2c", 4);
1629  }
1630 
1631  if (s->buf_end - s->buf < 2)
1632  return -1;
1633  bytestream_put_be16(&s->buf, JPEG2000_SOC);
1634  if ((ret = put_siz(s)) < 0)
1635  return ret;
1636  if ((ret = put_cod(s)) < 0)
1637  return ret;
1638  if ((ret = put_qcd(s, 0)) < 0)
1639  return ret;
1640  if ((ret = put_com(s, 0)) < 0)
1641  return ret;
1642 
1643  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1644  uint8_t *psotptr;
1645  if (!(psotptr = put_sot(s, tileno)))
1646  return -1;
1647  if (s->buf_end - s->buf < 2)
1648  return -1;
1649  bytestream_put_be16(&s->buf, JPEG2000_SOD);
1650  if ((ret = encode_tile(s, s->tile + tileno, tileno)) < 0)
1651  return ret;
1652  bytestream_put_be32(&psotptr, s->buf - psotptr + 6);
1653  }
1654  if (s->buf_end - s->buf < 2)
1655  return -1;
1656  bytestream_put_be16(&s->buf, JPEG2000_EOC);
1657 
1658  if (s->format == CODEC_JP2)
1659  update_size(jp2cstart, s->buf);
1660 
1661  av_log(s->avctx, AV_LOG_DEBUG, "end\n");
1662  pkt->size = s->buf - s->buf_start;
1663  *got_packet = 1;
1664 
1665  return 0;
1666 }
1667 
1669 {
1670  int i;
1671  char *token;
1672  char *saveptr = NULL;
1673  int rate;
1674  int nlayers = 0;
1675  if (!s->lr_str) {
1676  s->nlayers = 1;
1677  s->layer_rates[0] = 0;
1678  s->compression_rate_enc = 0;
1679  return 0;
1680  }
1681 
1682  token = av_strtok(s->lr_str, ",", &saveptr);
1683  if (token && (rate = strtol(token, NULL, 10))) {
1684  s->layer_rates[0] = rate <= 1 ? 0:rate;
1685  nlayers++;
1686  } else {
1687  return AVERROR_INVALIDDATA;
1688  }
1689 
1690  while (1) {
1691  token = av_strtok(NULL, ",", &saveptr);
1692  if (!token)
1693  break;
1694  if (rate = strtol(token, NULL, 10)) {
1695  if (nlayers >= 100) {
1696  return AVERROR_INVALIDDATA;
1697  }
1698  s->layer_rates[nlayers] = rate <= 1 ? 0:rate;
1699  nlayers++;
1700  } else {
1701  return AVERROR_INVALIDDATA;
1702  }
1703  }
1704 
1705  for (i = 1; i < nlayers; i++) {
1706  if (s->layer_rates[i] >= s->layer_rates[i-1]) {
1707  return AVERROR_INVALIDDATA;
1708  }
1709  }
1710  s->nlayers = nlayers;
1711  s->compression_rate_enc = 1;
1712  return 0;
1713 }
1714 
1716 {
1717  static AVOnce init_static_once = AV_ONCE_INIT;
1718  int i, ret;
1720  Jpeg2000CodingStyle *codsty = &s->codsty;
1721  Jpeg2000QuantStyle *qntsty = &s->qntsty;
1722 
1723  s->avctx = avctx;
1724  av_log(s->avctx, AV_LOG_DEBUG, "init\n");
1725  if (parse_layer_rates(s)) {
1726  av_log(s, AV_LOG_WARNING, "Layer rates invalid. Encoding with 1 layer based on quality metric.\n");
1727  s->nlayers = 1;
1728  s->layer_rates[0] = 0;
1729  s->compression_rate_enc = 0;
1730  }
1731 
1732  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && (s->pred != FF_DWT97_INT || s->format != CODEC_JP2)) {
1733  av_log(s->avctx, AV_LOG_WARNING, "Forcing lossless jp2 for pal8\n");
1734  s->pred = FF_DWT97_INT;
1735  s->format = CODEC_JP2;
1736  }
1737 
1738  // defaults:
1739  // TODO: implement setting non-standard precinct size
1740  memset(codsty->log2_prec_widths , 15, sizeof(codsty->log2_prec_widths ));
1741  memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights));
1742  codsty->nreslevels2decode=
1743  codsty->nreslevels = 7;
1744  codsty->nlayers = s->nlayers;
1745  codsty->log2_cblk_width = 4;
1746  codsty->log2_cblk_height = 4;
1747  codsty->transform = s->pred ? FF_DWT53 : FF_DWT97_INT;
1748 
1749  qntsty->nguardbits = 1;
1750 
1751  if ((s->tile_width & (s->tile_width -1)) ||
1752  (s->tile_height & (s->tile_height-1))) {
1753  av_log(avctx, AV_LOG_WARNING, "Tile dimension not a power of 2\n");
1754  }
1755 
1756  if (codsty->transform == FF_DWT53)
1757  qntsty->quantsty = JPEG2000_QSTY_NONE;
1758  else
1759  qntsty->quantsty = JPEG2000_QSTY_SE;
1760 
1761  s->width = avctx->width;
1762  s->height = avctx->height;
1763 
1764  for (i = 0; i < 3; i++) {
1765  if (avctx->pix_fmt == AV_PIX_FMT_GRAY16 || avctx->pix_fmt == AV_PIX_FMT_RGB48)
1766  s->cbps[i] = 16;
1767  else
1768  s->cbps[i] = 8;
1769  }
1770 
1771  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_RGB48){
1772  s->ncomponents = 3;
1773  } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16){
1774  s->ncomponents = 1;
1775  } else{ // planar YUV
1776  s->planar = 1;
1777  s->ncomponents = 3;
1779  s->chroma_shift, s->chroma_shift + 1);
1780  if (ret)
1781  return ret;
1782  }
1783 
1784  ff_thread_once(&init_static_once, init_luts);
1785 
1787  if ((ret=init_tiles(s)) < 0)
1788  return ret;
1789 
1790  av_log(s->avctx, AV_LOG_DEBUG, "after init\n");
1791 
1792  return 0;
1793 }
1794 
1795 static int j2kenc_destroy(AVCodecContext *avctx)
1796 {
1798 
1799  cleanup(s);
1800  return 0;
1801 }
1802 
1803 // taken from the libopenjpeg wraper so it matches
1804 
1805 #define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)
1806 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1807 static const AVOption options[] = {
1808  { "format", "Codec Format", OFFSET(format), AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2, VE, "format" },
1809  { "j2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K }, 0, 0, VE, "format" },
1810  { "jp2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2 }, 0, 0, VE, "format" },
1811  { "tile_width", "Tile Width", OFFSET(tile_width), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1812  { "tile_height", "Tile Height", OFFSET(tile_height), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1813  { "pred", "DWT Type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "pred" },
1814  { "dwt97int", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1815  { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1816  { "sop", "SOP marker", OFFSET(sop), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1817  { "eph", "EPH marker", OFFSET(eph), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1818  { "prog", "Progression Order", OFFSET(prog), AV_OPT_TYPE_INT, { .i64 = 0 }, JPEG2000_PGOD_LRCP, JPEG2000_PGOD_CPRL, VE, "prog" },
1819  { "lrcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_LRCP }, 0, 0, VE, "prog" },
1820  { "rlcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RLCP }, 0, 0, VE, "prog" },
1821  { "rpcl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RPCL }, 0, 0, VE, "prog" },
1822  { "pcrl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_PCRL }, 0, 0, VE, "prog" },
1823  { "cprl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_CPRL }, 0, 0, VE, "prog" },
1824  { "layer_rates", "Layer Rates", OFFSET(lr_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1825  { NULL }
1826 };
1827 
1828 static const AVClass j2k_class = {
1829  .class_name = "jpeg 2000 encoder",
1830  .item_name = av_default_item_name,
1831  .option = options,
1832  .version = LIBAVUTIL_VERSION_INT,
1833 };
1834 
1836  .p.name = "jpeg2000",
1837  .p.long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1838  .p.type = AVMEDIA_TYPE_VIDEO,
1839  .p.id = AV_CODEC_ID_JPEG2000,
1840  .priv_data_size = sizeof(Jpeg2000EncoderContext),
1841  .init = j2kenc_init,
1843  .close = j2kenc_destroy,
1844  .p.pix_fmts = (const enum AVPixelFormat[]) {
1851  },
1852  .p.priv_class = &j2k_class,
1854 };
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
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:1186
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:1807
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:1715
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:426
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:1828
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
t1
#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:1530
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:1795
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
U
#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:1388
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
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:260
put_cod
static int put_cod(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:330
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:582
Jpeg2000Tile::comp
Jpeg2000Component * comp
Definition: j2kenc.c:107
width
#define width
intreadwrite.h
Jpeg2000CodingStyle::transform
uint8_t transform
Definition: jpeg2000.h:140
s
#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
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
getcut
static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
Definition: j2kenc.c:1352
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
xi
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:404
encode_sigpass
static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
Definition: j2kenc.c:615
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:784
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:601
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:1269
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
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:1370
Jpeg2000EncoderContext::format
int format
Definition: j2kenc.c:138
getnmsedec_sig
static int getnmsedec_sig(int x, int bpno)
Definition: j2kenc.c:601
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:608
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:651
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:1404
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:211
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
sp
#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:508
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
a
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:1805
Jpeg2000CodingStyle::nlayers
uint8_t nlayers
Definition: jpeg2000.h:142
reinit
static void reinit(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1515
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:407
JPEG2000_PGOD_RLCP
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:116
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
parse_layer_rates
static int parse_layer_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1668
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:1495
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:706
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:940
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:1835
ret
ret
Definition: filter_design.txt:187
put_qcd
static int put_qcd(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:362
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:637
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:301
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
VE
#define VE
Definition: j2kenc.c:1806
put_com
static int put_com(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:388
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:769
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
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:1525
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
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:35
Jpeg2000EncoderContext::ncomponents
int ncomponents
Definition: j2kenc.c:120
init_tiles
static int init_tiles(Jpeg2000EncoderContext *s)
compute the sizes of tiles, resolution levels, bands, etc.
Definition: j2kenc.c:456
init_quantization
static void init_quantization(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:552
lut_nmsedec_ref0
static int lut_nmsedec_ref0[1<< NMSEDEC_BITS]
Definition: j2kenc.c:90
FF_DWT97_INT
@ FF_DWT97_INT
Definition: jpeg2000dwt.h:39
Jpeg2000EncoderContext::tile
Jpeg2000Tile * tile
Definition: j2kenc.c:134
Jpeg2000EncoderContext
Definition: j2kenc.c:111
min
float min
Definition: vorbis_enc_data.h:429