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 "internal.h"
70 #include "bytestream.h"
71 #include "jpeg2000.h"
72 #include "libavutil/common.h"
73 #include "libavutil/pixdesc.h"
74 #include "libavutil/opt.h"
75 #include "libavutil/intreadwrite.h"
76 #include "libavutil/avstring.h"
77 
78 #define NMSEDEC_BITS 7
79 #define NMSEDEC_FRACBITS (NMSEDEC_BITS-1)
80 #define WMSEDEC_SHIFT 13 ///< must be >= 13
81 #define LAMBDA_SCALE (100000000LL << (WMSEDEC_SHIFT - 13))
82 
83 #define CODEC_JP2 1
84 #define CODEC_J2K 0
85 
86 static int lut_nmsedec_ref [1<<NMSEDEC_BITS],
87  lut_nmsedec_ref0[1<<NMSEDEC_BITS],
88  lut_nmsedec_sig [1<<NMSEDEC_BITS],
89  lut_nmsedec_sig0[1<<NMSEDEC_BITS];
90 
91 static const int dwt_norms[2][4][10] = { // [dwt_type][band][rlevel] (multiplied by 10000)
92  {{10000, 19650, 41770, 84030, 169000, 338400, 676900, 1353000, 2706000, 5409000},
93  {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},
94  {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},
95  {20800, 38650, 83070, 171800, 347100, 695900, 1393000, 2786000, 5572000}},
96 
97  {{10000, 15000, 27500, 53750, 106800, 213400, 426700, 853300, 1707000, 3413000},
98  {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},
99  {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},
100  { 7186, 9218, 15860, 30430, 60190, 120100, 240000, 479700, 959300}}
101 };
102 
103 typedef struct {
104  Jpeg2000Component *comp;
105  double *layer_rates;
106 } Jpeg2000Tile;
107 
108 typedef struct {
109  AVClass *class;
110  AVCodecContext *avctx;
111  const AVFrame *picture;
112 
113  int width, height; ///< image width and height
114  uint8_t cbps[4]; ///< bits per sample in particular components
115  int chroma_shift[2];
116  uint8_t planar;
117  int ncomponents;
118  int tile_width, tile_height; ///< tile size
119  int numXtiles, numYtiles;
120 
121  uint8_t *buf_start;
122  uint8_t *buf;
123  uint8_t *buf_end;
124  int bit_index;
125 
126  int64_t lambda;
127 
128  Jpeg2000CodingStyle codsty;
129  Jpeg2000QuantStyle qntsty;
130 
131  Jpeg2000Tile *tile;
132  int layer_rates[100];
133  uint8_t compression_rate_enc; ///< Is compression done using compression ratio?
134 
135  int format;
136  int pred;
137  int sop;
138  int eph;
139  int prog;
140  int nlayers;
141  char *lr_str;
142 } Jpeg2000EncoderContext;
143 
144 
145 /* debug */
146 #if 0
147 #undef ifprintf
148 #undef printf
149 
150 static void nspaces(FILE *fd, int n)
151 {
152  while(n--) putc(' ', fd);
153 }
154 
155 static void printcomp(Jpeg2000Component *comp)
156 {
157  int i;
158  for (i = 0; i < comp->y1 - comp->y0; i++)
159  ff_jpeg2000_printv(comp->i_data + i * (comp->x1 - comp->x0), comp->x1 - comp->x0);
160 }
161 
162 static void dump(Jpeg2000EncoderContext *s, FILE *fd)
163 {
164  int tileno, compno, reslevelno, bandno, precno;
165  fprintf(fd, "XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"
166  "numXtiles = %d, numYtiles = %d, ncomponents = %d\n"
167  "tiles:\n",
168  s->width, s->height, s->tile_width, s->tile_height,
169  s->numXtiles, s->numYtiles, s->ncomponents);
170  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
171  Jpeg2000Tile *tile = s->tile + tileno;
172  nspaces(fd, 2);
173  fprintf(fd, "tile %d:\n", tileno);
174  for(compno = 0; compno < s->ncomponents; compno++){
175  Jpeg2000Component *comp = tile->comp + compno;
176  nspaces(fd, 4);
177  fprintf(fd, "component %d:\n", compno);
178  nspaces(fd, 4);
179  fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",
180  comp->x0, comp->x1, comp->y0, comp->y1);
181  for(reslevelno = 0; reslevelno < s->nreslevels; reslevelno++){
182  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
183  nspaces(fd, 6);
184  fprintf(fd, "reslevel %d:\n", reslevelno);
185  nspaces(fd, 6);
186  fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d, nbands = %d\n",
187  reslevel->x0, reslevel->x1, reslevel->y0,
188  reslevel->y1, reslevel->nbands);
189  for(bandno = 0; bandno < reslevel->nbands; bandno++){
190  Jpeg2000Band *band = reslevel->band + bandno;
191  nspaces(fd, 8);
192  fprintf(fd, "band %d:\n", bandno);
193  nspaces(fd, 8);
194  fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d,"
195  "codeblock_width = %d, codeblock_height = %d cblknx = %d cblkny = %d\n",
196  band->x0, band->x1,
197  band->y0, band->y1,
198  band->codeblock_width, band->codeblock_height,
199  band->cblknx, band->cblkny);
200  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
201  Jpeg2000Prec *prec = band->prec + precno;
202  nspaces(fd, 10);
203  fprintf(fd, "prec %d:\n", precno);
204  nspaces(fd, 10);
205  fprintf(fd, "xi0 = %d, xi1 = %d, yi0 = %d, yi1 = %d\n",
206  prec->xi0, prec->xi1, prec->yi0, prec->yi1);
207  }
208  }
209  }
210  }
211  }
212 }
213 #endif
214 
215 /* bitstream routines */
216 
217 /** put n times val bit */
218 static void put_bits(Jpeg2000EncoderContext *s, int val, int n) // TODO: optimize
219 {
220  while (n-- > 0){
221  if (s->bit_index == 8)
222  {
223  s->bit_index = *s->buf == 0xff;
224  *(++s->buf) = 0;
225  }
226  *s->buf |= val << (7 - s->bit_index++);
227  }
228 }
229 
230 /** put n least significant bits of a number num */
231 static void put_num(Jpeg2000EncoderContext *s, int num, int n)
232 {
233  while(--n >= 0)
234  put_bits(s, (num >> n) & 1, 1);
235 }
236 
237 /** flush the bitstream */
238 static void j2k_flush(Jpeg2000EncoderContext *s)
239 {
240  if (s->bit_index){
241  s->bit_index = 0;
242  s->buf++;
243  }
244 }
245 
246 /* tag tree routines */
247 
248 /** code the value stored in node */
249 static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)
250 {
251  Jpeg2000TgtNode *stack[30];
252  int sp = -1, curval = 0;
253 
254  while(node->parent){
255  stack[++sp] = node;
256  node = node->parent;
257  }
258 
259  while (1) {
260  if (curval > node->temp_val)
261  node->temp_val = curval;
262  else {
263  curval = node->temp_val;
264  }
265 
266  if (node->val >= threshold) {
267  put_bits(s, 0, threshold - curval);
268  curval = threshold;
269  } else {
270  put_bits(s, 0, node->val - curval);
271  curval = node->val;
272  if (!node->vis) {
273  put_bits(s, 1, 1);
274  node->vis = 1;
275  }
276  }
277 
278  node->temp_val = curval;
279  if (sp < 0)
280  break;
281  node = stack[sp--];
282  }
283 }
284 
285 /** update the value in node */
286 static void tag_tree_update(Jpeg2000TgtNode *node)
287 {
288  int lev = 0;
289  while (node->parent){
290  if (node->parent->val <= node->val)
291  break;
292  node->parent->val = node->val;
293  node = node->parent;
294  lev++;
295  }
296 }
297 
298 static int put_siz(Jpeg2000EncoderContext *s)
299 {
300  int i;
301 
302  if (s->buf_end - s->buf < 40 + 3 * s->ncomponents)
303  return -1;
304 
305  bytestream_put_be16(&s->buf, JPEG2000_SIZ);
306  bytestream_put_be16(&s->buf, 38 + 3 * s->ncomponents); // Lsiz
307  bytestream_put_be16(&s->buf, 0); // Rsiz
308  bytestream_put_be32(&s->buf, s->width); // width
309  bytestream_put_be32(&s->buf, s->height); // height
310  bytestream_put_be32(&s->buf, 0); // X0Siz
311  bytestream_put_be32(&s->buf, 0); // Y0Siz
312 
313  bytestream_put_be32(&s->buf, s->tile_width); // XTSiz
314  bytestream_put_be32(&s->buf, s->tile_height); // YTSiz
315  bytestream_put_be32(&s->buf, 0); // XT0Siz
316  bytestream_put_be32(&s->buf, 0); // YT0Siz
317  bytestream_put_be16(&s->buf, s->ncomponents); // CSiz
318 
319  for (i = 0; i < s->ncomponents; i++){ // Ssiz_i XRsiz_i, YRsiz_i
320  bytestream_put_byte(&s->buf, s->cbps[i] - 1);
321  bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[0]:1);
322  bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[1]:1);
323  }
324  return 0;
325 }
326 
327 static int put_cod(Jpeg2000EncoderContext *s)
328 {
329  Jpeg2000CodingStyle *codsty = &s->codsty;
330  uint8_t scod = 0;
331 
332  if (s->buf_end - s->buf < 14)
333  return -1;
334 
335  bytestream_put_be16(&s->buf, JPEG2000_COD);
336  bytestream_put_be16(&s->buf, 12); // Lcod
337  if (s->sop)
338  scod |= JPEG2000_CSTY_SOP;
339  if (s->eph)
340  scod |= JPEG2000_CSTY_EPH;
341  bytestream_put_byte(&s->buf, scod); // Scod
342  // SGcod
343  bytestream_put_byte(&s->buf, s->prog); // progression level
344  bytestream_put_be16(&s->buf, s->nlayers); // num of layers
345  if(s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){
346  bytestream_put_byte(&s->buf, 0); // unspecified
347  }else{
348  bytestream_put_byte(&s->buf, 0); // unspecified
349  }
350  // SPcod
351  bytestream_put_byte(&s->buf, codsty->nreslevels - 1); // num of decomp. levels
352  bytestream_put_byte(&s->buf, codsty->log2_cblk_width-2); // cblk width
353  bytestream_put_byte(&s->buf, codsty->log2_cblk_height-2); // cblk height
354  bytestream_put_byte(&s->buf, 0); // cblk style
355  bytestream_put_byte(&s->buf, codsty->transform == FF_DWT53); // transformation
356  return 0;
357 }
358 
359 static int put_qcd(Jpeg2000EncoderContext *s, int compno)
360 {
361  int i, size;
362  Jpeg2000CodingStyle *codsty = &s->codsty;
363  Jpeg2000QuantStyle *qntsty = &s->qntsty;
364 
365  if (qntsty->quantsty == JPEG2000_QSTY_NONE)
366  size = 4 + 3 * (codsty->nreslevels-1);
367  else // QSTY_SE
368  size = 5 + 6 * (codsty->nreslevels-1);
369 
370  if (s->buf_end - s->buf < size + 2)
371  return -1;
372 
373  bytestream_put_be16(&s->buf, JPEG2000_QCD);
374  bytestream_put_be16(&s->buf, size); // LQcd
375  bytestream_put_byte(&s->buf, (qntsty->nguardbits << 5) | qntsty->quantsty); // Sqcd
376  if (qntsty->quantsty == JPEG2000_QSTY_NONE)
377  for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
378  bytestream_put_byte(&s->buf, qntsty->expn[i] << 3);
379  else // QSTY_SE
380  for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
381  bytestream_put_be16(&s->buf, (qntsty->expn[i] << 11) | qntsty->mant[i]);
382  return 0;
383 }
384 
385 static int put_com(Jpeg2000EncoderContext *s, int compno)
386 {
387  int size = 4 + strlen(LIBAVCODEC_IDENT);
388 
389  if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
390  return 0;
391 
392  if (s->buf_end - s->buf < size + 2)
393  return -1;
394 
395  bytestream_put_be16(&s->buf, JPEG2000_COM);
396  bytestream_put_be16(&s->buf, size);
397  bytestream_put_be16(&s->buf, 1); // General use (ISO/IEC 8859-15 (Latin) values)
398 
399  bytestream_put_buffer(&s->buf, LIBAVCODEC_IDENT, strlen(LIBAVCODEC_IDENT));
400 
401  return 0;
402 }
403 
404 static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno)
405 {
406  uint8_t *psotptr;
407 
408  if (s->buf_end - s->buf < 12)
409  return NULL;
410 
411  bytestream_put_be16(&s->buf, JPEG2000_SOT);
412  bytestream_put_be16(&s->buf, 10); // Lsot
413  bytestream_put_be16(&s->buf, tileno); // Isot
414 
415  psotptr = s->buf;
416  bytestream_put_be32(&s->buf, 0); // Psot (filled in later)
417 
418  bytestream_put_byte(&s->buf, 0); // TPsot
419  bytestream_put_byte(&s->buf, 1); // TNsot
420  return psotptr;
421 }
422 
423 static void compute_rates(Jpeg2000EncoderContext* s)
424 {
425  int i, j;
426  int layno, compno;
427  for (i = 0; i < s->numYtiles; i++) {
428  for (j = 0; j < s->numXtiles; j++) {
429  Jpeg2000Tile *tile = &s->tile[s->numXtiles * i + j];
430  for (compno = 0; compno < s->ncomponents; compno++) {
431  int tilew = tile->comp[compno].coord[0][1] - tile->comp[compno].coord[0][0];
432  int tileh = tile->comp[compno].coord[1][1] - tile->comp[compno].coord[1][0];
433  int scale = (compno?1 << s->chroma_shift[0]:1) * (compno?1 << s->chroma_shift[1]:1);
434  for (layno = 0; layno < s->nlayers; layno++) {
435  if (s->layer_rates[layno] > 0) {
436  tile->layer_rates[layno] += (double)(tilew * tileh) * s->ncomponents * s->cbps[compno] /
437  (double)(s->layer_rates[layno] * 8 * scale);
438  } else {
439  tile->layer_rates[layno] = 0.0;
440  }
441  }
442  }
443  }
444  }
445 
446 }
447 
448 /**
449  * compute the sizes of tiles, resolution levels, bands, etc.
450  * allocate memory for them
451  * divide the input image into tile-components
452  */
453 static int init_tiles(Jpeg2000EncoderContext *s)
454 {
455  int tileno, tilex, tiley, compno;
456  Jpeg2000CodingStyle *codsty = &s->codsty;
457  Jpeg2000QuantStyle *qntsty = &s->qntsty;
458 
459  s->numXtiles = ff_jpeg2000_ceildiv(s->width, s->tile_width);
460  s->numYtiles = ff_jpeg2000_ceildiv(s->height, s->tile_height);
461 
462  s->tile = av_calloc(s->numXtiles, s->numYtiles * sizeof(Jpeg2000Tile));
463  if (!s->tile)
464  return AVERROR(ENOMEM);
465  for (tileno = 0, tiley = 0; tiley < s->numYtiles; tiley++)
466  for (tilex = 0; tilex < s->numXtiles; tilex++, tileno++){
467  Jpeg2000Tile *tile = s->tile + tileno;
468 
469  tile->comp = av_mallocz_array(s->ncomponents, sizeof(Jpeg2000Component));
470  if (!tile->comp)
471  return AVERROR(ENOMEM);
472 
473  tile->layer_rates = av_mallocz_array(s->nlayers, sizeof(*tile->layer_rates));
474  if (!tile->layer_rates)
475  return AVERROR(ENOMEM);
476 
477  for (compno = 0; compno < s->ncomponents; compno++){
478  Jpeg2000Component *comp = tile->comp + compno;
479  int ret, i, j;
480 
481  comp->coord[0][0] = comp->coord_o[0][0] = tilex * s->tile_width;
482  comp->coord[0][1] = comp->coord_o[0][1] = FFMIN((tilex+1)*s->tile_width, s->width);
483  comp->coord[1][0] = comp->coord_o[1][0] = tiley * s->tile_height;
484  comp->coord[1][1] = comp->coord_o[1][1] = FFMIN((tiley+1)*s->tile_height, s->height);
485  if (compno > 0)
486  for (i = 0; i < 2; i++)
487  for (j = 0; j < 2; j++)
488  comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]);
489 
490  if ((ret = ff_jpeg2000_init_component(comp,
491  codsty,
492  qntsty,
493  s->cbps[compno],
494  compno?1<<s->chroma_shift[0]:1,
495  compno?1<<s->chroma_shift[1]:1,
496  s->avctx
497  )) < 0)
498  return ret;
499  }
500  }
501  compute_rates(s);
502  return 0;
503 }
504 
505 #define COPY_FRAME(D, PIXEL) \
506  static void copy_frame_ ##D(Jpeg2000EncoderContext *s) \
507  { \
508  int tileno, compno, i, y, x; \
509  PIXEL *line; \
510  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){ \
511  Jpeg2000Tile *tile = s->tile + tileno; \
512  if (s->planar){ \
513  for (compno = 0; compno < s->ncomponents; compno++){ \
514  Jpeg2000Component *comp = tile->comp + compno; \
515  int *dst = comp->i_data; \
516  int cbps = s->cbps[compno]; \
517  line = (PIXEL*)s->picture->data[compno] \
518  + comp->coord[1][0] * (s->picture->linesize[compno] / sizeof(PIXEL)) \
519  + comp->coord[0][0]; \
520  for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){ \
521  PIXEL *ptr = line; \
522  for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++) \
523  *dst++ = *ptr++ - (1 << (cbps - 1)); \
524  line += s->picture->linesize[compno] / sizeof(PIXEL); \
525  } \
526  } \
527  } else{ \
528  line = (PIXEL*)s->picture->data[0] + tile->comp[0].coord[1][0] * (s->picture->linesize[0] / sizeof(PIXEL)) \
529  + tile->comp[0].coord[0][0] * s->ncomponents; \
530  \
531  i = 0; \
532  for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){ \
533  PIXEL *ptr = line; \
534  for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){ \
535  for (compno = 0; compno < s->ncomponents; compno++){ \
536  int cbps = s->cbps[compno]; \
537  tile->comp[compno].i_data[i] = *ptr++ - (1 << (cbps - 1)); \
538  } \
539  } \
540  line += s->picture->linesize[0] / sizeof(PIXEL); \
541  } \
542  } \
543  } \
544  }
545 
546 COPY_FRAME(8, uint8_t)
547 COPY_FRAME(16, uint16_t)
548 
549 static void init_quantization(Jpeg2000EncoderContext *s)
550 {
551  int compno, reslevelno, bandno;
552  Jpeg2000QuantStyle *qntsty = &s->qntsty;
553  Jpeg2000CodingStyle *codsty = &s->codsty;
554 
555  for (compno = 0; compno < s->ncomponents; compno++){
556  int gbandno = 0;
557  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
558  int nbands, lev = codsty->nreslevels - reslevelno - 1;
559  nbands = reslevelno ? 3 : 1;
560  for (bandno = 0; bandno < nbands; bandno++, gbandno++){
561  int expn, mant = 0;
562 
563  if (codsty->transform == FF_DWT97_INT){
564  int bandpos = bandno + (reslevelno>0),
565  ss = 81920000 / dwt_norms[0][bandpos][lev],
566  log = av_log2(ss);
567  mant = (11 - log < 0 ? ss >> log - 11 : ss << 11 - log) & 0x7ff;
568  expn = s->cbps[compno] - log + 13;
569  } else
570  expn = ((bandno&2)>>1) + (reslevelno>0) + s->cbps[compno];
571 
572  qntsty->expn[gbandno] = expn;
573  qntsty->mant[gbandno] = mant;
574  }
575  }
576  }
577 }
578 
579 static void init_luts(void)
580 {
581  int i, a,
582  mask = ~((1<<NMSEDEC_FRACBITS)-1);
583 
584  for (i = 0; i < (1 << NMSEDEC_BITS); i++){
585  lut_nmsedec_sig[i] = FFMAX((3 * i << (13 - NMSEDEC_FRACBITS)) - (9 << 11), 0);
586  lut_nmsedec_sig0[i] = FFMAX((i*i + (1<<NMSEDEC_FRACBITS-1) & mask) << 1, 0);
587 
588  a = (i >> (NMSEDEC_BITS-2)&2) + 1;
589  lut_nmsedec_ref[i] = FFMAX((a - 2) * (i << (13 - NMSEDEC_FRACBITS)) +
590  (1 << 13) - (a * a << 11), 0);
591  lut_nmsedec_ref0[i] = FFMAX(((i * i - (i << NMSEDEC_BITS) + (1 << 2 * NMSEDEC_FRACBITS) + (1 << (NMSEDEC_FRACBITS - 1))) & mask)
592  << 1, 0);
593  }
594 }
595 
596 /* tier-1 routines */
597 static int getnmsedec_sig(int x, int bpno)
598 {
599  if (bpno > NMSEDEC_FRACBITS)
600  return lut_nmsedec_sig[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
601  return lut_nmsedec_sig0[x & ((1 << NMSEDEC_BITS) - 1)];
602 }
603 
604 static int getnmsedec_ref(int x, int bpno)
605 {
606  if (bpno > NMSEDEC_FRACBITS)
607  return lut_nmsedec_ref[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
608  return lut_nmsedec_ref0[x & ((1 << NMSEDEC_BITS) - 1)];
609 }
610 
611 static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
612 {
613  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
614  for (y0 = 0; y0 < height; y0 += 4)
615  for (x = 0; x < width; x++)
616  for (y = y0; y < height && y < y0+4; y++){
617  if (!(t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG) && (t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB)){
618  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno),
619  bit = t1->data[(y) * t1->stride + x] & mask ? 1 : 0;
620  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, bit);
621  if (bit){
622  int xorbit;
623  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
624  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
625  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
626  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
627  }
628  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_VIS;
629  }
630  }
631 }
632 
633 static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
634 {
635  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
636  for (y0 = 0; y0 < height; y0 += 4)
637  for (x = 0; x < width; x++)
638  for (y = y0; y < height && y < y0+4; y++)
639  if ((t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG){
640  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y+1) * t1->stride + x+1]);
641  *nmsedec += getnmsedec_ref(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
642  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
643  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_REF;
644  }
645 }
646 
647 static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
648 {
649  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
650  for (y0 = 0; y0 < height; y0 += 4)
651  for (x = 0; x < width; x++){
652  if (y0 + 3 < height && !(
653  (t1->flags[(y0+1) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
654  (t1->flags[(y0+2) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
655  (t1->flags[(y0+3) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
656  (t1->flags[(y0+4) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG))))
657  {
658  // aggregation mode
659  int rlen;
660  for (rlen = 0; rlen < 4; rlen++)
661  if (t1->data[(y0+rlen) * t1->stride + x] & mask)
662  break;
663  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL, rlen != 4);
664  if (rlen == 4)
665  continue;
666  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen >> 1);
667  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen & 1);
668  for (y = y0 + rlen; y < y0 + 4; y++){
669  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
670  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
671  if (y > y0 + rlen)
672  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
673  if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
674  int xorbit;
675  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
676  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
677  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
678  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
679  }
680  }
681  t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
682  }
683  } else{
684  for (y = y0; y < y0 + 4 && y < height; y++){
685  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
686  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
687  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
688  if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
689  int xorbit;
690  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
691  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
692  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
693  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
694  }
695  }
696  t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
697  }
698  }
699  }
700 }
701 
702 static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile,
703  int width, int height, int bandpos, int lev)
704 {
705  int pass_t = 2, passno, x, y, max=0, nmsedec, bpno;
706  int64_t wmsedec = 0;
707 
708  memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
709 
710  for (y = 0; y < height; y++){
711  for (x = 0; x < width; x++){
712  if (t1->data[(y) * t1->stride + x] < 0){
713  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_SGN;
714  t1->data[(y) * t1->stride + x] = -t1->data[(y) * t1->stride + x];
715  }
716  max = FFMAX(max, t1->data[(y) * t1->stride + x]);
717  }
718  }
719 
720  if (max == 0){
721  cblk->nonzerobits = 0;
722  bpno = 0;
723  } else{
724  cblk->nonzerobits = av_log2(max) + 1 - NMSEDEC_FRACBITS;
725  bpno = cblk->nonzerobits - 1;
726  }
727 
728  cblk->data[0] = 0;
729  ff_mqc_initenc(&t1->mqc, cblk->data + 1);
730 
731  for (passno = 0; bpno >= 0; passno++){
732  nmsedec=0;
733 
734  switch(pass_t){
735  case 0: encode_sigpass(t1, width, height, bandpos, &nmsedec, bpno);
736  break;
737  case 1: encode_refpass(t1, width, height, &nmsedec, bpno);
738  break;
739  case 2: encode_clnpass(t1, width, height, bandpos, &nmsedec, bpno);
740  break;
741  }
742 
743  cblk->passes[passno].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno].flushed, &cblk->passes[passno].flushed_len);
744  cblk->passes[passno].rate -= cblk->passes[passno].flushed_len;
745 
746  wmsedec += (int64_t)nmsedec << (2*bpno);
747  cblk->passes[passno].disto = wmsedec;
748 
749  if (++pass_t == 3){
750  pass_t = 0;
751  bpno--;
752  }
753  }
754  cblk->npasses = passno;
755  cblk->ninclpasses = passno;
756 
757  if (passno) {
758  cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);
759  cblk->passes[passno-1].rate -= cblk->passes[passno-1].flushed_len;
760  }
761 }
762 
763 /* tier-2 routines: */
764 
765 static void putnumpasses(Jpeg2000EncoderContext *s, int n)
766 {
767  if (n == 1)
768  put_num(s, 0, 1);
769  else if (n == 2)
770  put_num(s, 2, 2);
771  else if (n <= 5)
772  put_num(s, 0xc | (n-3), 4);
773  else if (n <= 36)
774  put_num(s, 0x1e0 | (n-6), 9);
775  else
776  put_num(s, 0xff80 | (n-37), 16);
777 }
778 
779 
780 static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno,
781  int precno, uint8_t *expn, int numgbits, int packetno,
782  int nlayers)
783 {
784  int bandno, empty = 1;
785  int i;
786  // init bitstream
787  *s->buf = 0;
788  s->bit_index = 0;
789 
790  if (s->sop) {
791  bytestream_put_be16(&s->buf, JPEG2000_SOP);
792  bytestream_put_be16(&s->buf, 4);
793  bytestream_put_be16(&s->buf, packetno);
794  }
795  // header
796 
797  if (!layno) {
798  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
799  Jpeg2000Band *band = rlevel->band + bandno;
800  if (band->coord[0][0] < band->coord[0][1]
801  && band->coord[1][0] < band->coord[1][1]) {
802  Jpeg2000Prec *prec = band->prec + precno;
803  int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
804  int pos;
805  ff_tag_tree_zero(prec->zerobits, prec->nb_codeblocks_width, prec->nb_codeblocks_height, 99);
806  ff_tag_tree_zero(prec->cblkincl, prec->nb_codeblocks_width, prec->nb_codeblocks_height, 99);
807  for (pos = 0; pos < nb_cblks; pos++) {
808  Jpeg2000Cblk *cblk = &prec->cblk[pos];
809  prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - cblk->nonzerobits;
810  cblk->incl = 0;
811  cblk->lblock = 3;
812  tag_tree_update(prec->zerobits + pos);
813  for (i = 0; i < nlayers; i++) {
814  if (cblk->layers[i].npasses > 0) {
815  prec->cblkincl[pos].val = i;
816  break;
817  }
818  }
819  if (i == nlayers)
820  prec->cblkincl[pos].val = i;
821  tag_tree_update(prec->cblkincl + pos);
822  }
823  }
824  }
825  }
826 
827  // is the packet empty?
828  for (bandno = 0; bandno < rlevel->nbands; bandno++){
829  Jpeg2000Band *band = rlevel->band + bandno;
830  if (band->coord[0][0] < band->coord[0][1]
831  && band->coord[1][0] < band->coord[1][1]) {
832  Jpeg2000Prec *prec = band->prec + precno;
833  int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
834  int pos;
835  for (pos = 0; pos < nb_cblks; pos++) {
836  Jpeg2000Cblk *cblk = &prec->cblk[pos];
837  if (cblk->layers[layno].npasses) {
838  empty = 0;
839  break;
840  }
841  }
842  if (!empty)
843  break;
844  }
845  }
846 
847  put_bits(s, !empty, 1);
848  if (empty){
849  j2k_flush(s);
850  if (s->eph)
851  bytestream_put_be16(&s->buf, JPEG2000_EPH);
852  return 0;
853  }
854 
855  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
856  Jpeg2000Band *band = rlevel->band + bandno;
857  Jpeg2000Prec *prec = band->prec + precno;
858  int yi, xi, pos;
859  int cblknw = prec->nb_codeblocks_width;
860 
861  if (band->coord[0][0] == band->coord[0][1]
862  || band->coord[1][0] == band->coord[1][1])
863  continue;
864 
865  for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++) {
866  for (xi = 0; xi < cblknw; xi++, pos++){
867  int llen = 0, length;
868  Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
869 
870  if (s->buf_end - s->buf < 20) // approximately
871  return -1;
872 
873  // inclusion information
874  if (!cblk->incl)
875  tag_tree_code(s, prec->cblkincl + pos, layno + 1);
876  else {
877  put_bits(s, cblk->layers[layno].npasses > 0, 1);
878  }
879 
880  if (!cblk->layers[layno].npasses)
881  continue;
882 
883  // zerobits information
884  if (!cblk->incl) {
885  tag_tree_code(s, prec->zerobits + pos, 100);
886  cblk->incl = 1;
887  }
888 
889  // number of passes
890  putnumpasses(s, cblk->layers[layno].npasses);
891 
892  length = cblk->layers[layno].data_len;
893  if (layno == nlayers - 1 && cblk->layers[layno].cum_passes){
894  length += cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len;
895  }
896  if (cblk->lblock + av_log2(cblk->layers[layno].npasses) < av_log2(length) + 1) {
897  llen = av_log2(length) + 1 - cblk->lblock - av_log2(cblk->layers[layno].npasses);
898  }
899 
900  // length of code block
901  cblk->lblock += llen;
902  put_bits(s, 1, llen);
903  put_bits(s, 0, 1);
904  put_num(s, length, cblk->lblock + av_log2(cblk->layers[layno].npasses));
905  }
906  }
907  }
908  j2k_flush(s);
909  if (s->eph) {
910  bytestream_put_be16(&s->buf, JPEG2000_EPH);
911  }
912 
913  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
914  Jpeg2000Band *band = rlevel->band + bandno;
915  Jpeg2000Prec *prec = band->prec + precno;
916  int yi, cblknw = prec->nb_codeblocks_width;
917  for (yi =0; yi < prec->nb_codeblocks_height; yi++) {
918  int xi;
919  for (xi = 0; xi < cblknw; xi++){
920  Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
921  if (cblk->layers[layno].npasses) {
922  if (s->buf_end - s->buf < cblk->layers[layno].data_len + 2)
923  return -1;
924  bytestream_put_buffer(&s->buf, cblk->layers[layno].data_start + 1, cblk->layers[layno].data_len);
925  if (layno == nlayers - 1 && cblk->layers[layno].cum_passes) {
926  bytestream_put_buffer(&s->buf, cblk->passes[cblk->layers[layno].cum_passes-1].flushed,
927  cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len);
928  }
929  }
930  }
931  }
932  }
933  return 0;
934 }
935 
936 static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
937 {
938  int compno, reslevelno, layno, ret;
939  Jpeg2000CodingStyle *codsty = &s->codsty;
940  Jpeg2000QuantStyle *qntsty = &s->qntsty;
941  int packetno = 0;
942  int step_x, step_y;
943  int x, y;
944  int tile_coord[2][2];
945  int col = tileno % s->numXtiles;
946  int row = tileno / s->numXtiles;
947 
948  tile_coord[0][0] = col * s->tile_width;
949  tile_coord[0][1] = FFMIN(tile_coord[0][0] + s->tile_width, s->width);
950  tile_coord[1][0] = row * s->tile_height;
951  tile_coord[1][1] = FFMIN(tile_coord[1][0] + s->tile_height, s->height);
952 
953  av_log(s->avctx, AV_LOG_DEBUG, "tier2\n");
954  // lay-rlevel-comp-pos progression
955  switch (s->prog) {
956  case JPEG2000_PGOD_LRCP:
957  for (layno = 0; layno < nlayers; layno++) {
958  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
959  for (compno = 0; compno < s->ncomponents; compno++){
960  int precno;
961  Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
962  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
963  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
964  qntsty->nguardbits, packetno++, nlayers)) < 0)
965  return ret;
966  }
967  }
968  }
969  }
970  break;
971  case JPEG2000_PGOD_RLCP:
972  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
973  for (layno = 0; layno < nlayers; layno++) {
974  for (compno = 0; compno < s->ncomponents; compno++){
975  int precno;
976  Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
977  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
978  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
979  qntsty->nguardbits, packetno++, nlayers)) < 0)
980  return ret;
981  }
982  }
983  }
984  }
985  break;
986  case JPEG2000_PGOD_RPCL:
987  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
988  int precno;
989  step_x = 30;
990  step_y = 30;
991  for (compno = 0; compno < s->ncomponents; compno++) {
992  Jpeg2000Component *comp = tile->comp + compno;
993  if (reslevelno < codsty->nreslevels) {
994  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
995  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
996  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
997  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
998  }
999  }
1000 
1001  step_x = 1<<step_x;
1002  step_y = 1<<step_y;
1003  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1004  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1005  for (compno = 0; compno < s->ncomponents; compno++) {
1006  Jpeg2000Component *comp = tile->comp + compno;
1007  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1008  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1009  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1010  unsigned prcx, prcy;
1011  int trx0, try0;
1012 
1013  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1014  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1015 
1016  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1017  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1018  continue;
1019 
1020  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1021  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1022  continue;
1023 
1024  // check if a precinct exists
1025  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1026  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1027  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1028  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1029  precno = prcx + reslevel->num_precincts_x * prcy;
1030 
1031  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1032  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1033  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1034  continue;
1035  }
1036  for (layno = 0; layno < nlayers; layno++) {
1037  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1038  qntsty->nguardbits, packetno++, nlayers)) < 0)
1039  return ret;
1040  }
1041  }
1042  }
1043  }
1044  }
1045  break;
1046  case JPEG2000_PGOD_PCRL:
1047  step_x = 32;
1048  step_y = 32;
1049  for (compno = 0; compno < s->ncomponents; compno++) {
1050  Jpeg2000Component *comp = tile->comp + compno;
1051 
1052  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1053  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1054  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1055  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1056  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1057  }
1058  }
1059  if (step_x >= 31 || step_y >= 31){
1060  avpriv_request_sample(s->avctx, "PCRL with large step");
1061  return AVERROR_PATCHWELCOME;
1062  }
1063  step_x = 1<<step_x;
1064  step_y = 1<<step_y;
1065 
1066  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1067  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1068  for (compno = 0; compno < s->ncomponents; compno++) {
1069  Jpeg2000Component *comp = tile->comp + compno;
1070  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1071 
1072  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1073  unsigned prcx, prcy;
1074  int precno;
1075  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1076  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1077  int trx0, try0;
1078 
1079  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1080  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1081 
1082  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1083  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1084  continue;
1085 
1086  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1087  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1088  continue;
1089 
1090  // check if a precinct exists
1091  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1092  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1093  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1094  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1095 
1096  precno = prcx + reslevel->num_precincts_x * prcy;
1097 
1098  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1099  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1100  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1101  continue;
1102  }
1103  for (layno = 0; layno < nlayers; layno++) {
1104  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1105  qntsty->nguardbits, packetno++, nlayers)) < 0)
1106  return ret;
1107  }
1108  }
1109  }
1110  }
1111  }
1112  break;
1113  case JPEG2000_PGOD_CPRL:
1114  for (compno = 0; compno < s->ncomponents; compno++) {
1115  Jpeg2000Component *comp = tile->comp + compno;
1116  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1117  step_x = 32;
1118  step_y = 32;
1119 
1120  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1121  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1122  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1123  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1124  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1125  }
1126  if (step_x >= 31 || step_y >= 31){
1127  avpriv_request_sample(s->avctx, "CPRL with large step");
1128  return AVERROR_PATCHWELCOME;
1129  }
1130  step_x = 1<<step_x;
1131  step_y = 1<<step_y;
1132 
1133  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1134  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1135  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1136  unsigned prcx, prcy;
1137  int precno;
1138  int trx0, try0;
1139  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1140  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1141 
1142  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1143  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1144 
1145  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1146  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1147  continue;
1148 
1149  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1150  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1151  continue;
1152 
1153  // check if a precinct exists
1154  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1155  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1156  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1157  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1158 
1159  precno = prcx + reslevel->num_precincts_x * prcy;
1160 
1161  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1162  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1163  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1164  continue;
1165  }
1166  for (layno = 0; layno < nlayers; layno++) {
1167  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1168  qntsty->nguardbits, packetno++, nlayers)) < 0)
1169  return ret;
1170  }
1171  }
1172  }
1173  }
1174  }
1175 
1176  }
1177 
1178  av_log(s->avctx, AV_LOG_DEBUG, "after tier2\n");
1179  return 0;
1180 }
1181 
1182 static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile* tile, int final)
1183 {
1184  int compno, resno, bandno, precno, cblkno;
1185  int passno;
1186 
1187  for (compno = 0; compno < s->ncomponents; compno++) {
1188  Jpeg2000Component *comp = &tile->comp[compno];
1189 
1190  for (resno = 0; resno < s->codsty.nreslevels; resno++) {
1191  Jpeg2000ResLevel *reslevel = comp->reslevel + resno;
1192 
1193  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1194  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1195  Jpeg2000Band *band = reslevel->band + bandno;
1196  Jpeg2000Prec *prec = band->prec + precno;
1197 
1198  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1199  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1200  Jpeg2000Layer *layer = &cblk->layers[layno];
1201  int n;
1202 
1203  if (layno == 0) {
1204  cblk->ninclpasses = 0;
1205  }
1206 
1207  n = cblk->ninclpasses;
1208 
1209  if (thresh < 0) {
1210  n = cblk->npasses;
1211  } else {
1212  for (passno = cblk->ninclpasses; passno < cblk->npasses; passno++) {
1213  int32_t dr;
1214  double dd;
1215  Jpeg2000Pass *pass = &cblk->passes[passno];
1216 
1217  if (n == 0) {
1218  dr = pass->rate;
1219  dd = pass->disto;
1220  } else {
1221  dr = pass->rate - cblk->passes[n - 1].rate;
1222  dd = pass->disto - cblk->passes[n-1].disto;
1223  }
1224 
1225  if (!dr) {
1226  if (dd != 0.0) {
1227  n = passno + 1;
1228  }
1229  continue;
1230  }
1231 
1232  if (thresh - (dd / dr) < DBL_EPSILON)
1233  n = passno + 1;
1234  }
1235  }
1236  layer->npasses = n - cblk->ninclpasses;
1237  layer->cum_passes = n;
1238 
1239  if (layer->npasses == 0) {
1240  layer->disto = 0;
1241  layer->data_len = 0;
1242  continue;
1243  }
1244 
1245  if (cblk->ninclpasses == 0) {
1246  layer->data_len = cblk->passes[n - 1].rate;
1247  layer->data_start = cblk->data;
1248  layer->disto = cblk->passes[n - 1].disto;
1249  } else {
1250  layer->data_len = cblk->passes[n - 1].rate - cblk->passes[cblk->ninclpasses - 1].rate;
1251  layer->data_start = cblk->data + cblk->passes[cblk->ninclpasses - 1].rate;
1252  layer->disto = cblk->passes[n - 1].disto -
1253  cblk->passes[cblk->ninclpasses - 1].disto;
1254  }
1255  if (final) {
1256  cblk->ninclpasses = n;
1257  }
1258  }
1259  }
1260  }
1261  }
1262  }
1263 }
1264 
1265 static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
1266 {
1267  int precno, compno, reslevelno, bandno, cblkno, lev, passno, layno;
1268  int i;
1269  double min = DBL_MAX;
1270  double max = 0;
1271  double thresh;
1272  int tile_disto = 0;
1273 
1274  Jpeg2000CodingStyle *codsty = &s->codsty;
1275 
1276  for (compno = 0; compno < s->ncomponents; compno++){
1277  Jpeg2000Component *comp = tile->comp + compno;
1278 
1279  for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1280  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1281 
1282  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1283  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1284  Jpeg2000Band *band = reslevel->band + bandno;
1285  Jpeg2000Prec *prec = band->prec + precno;
1286 
1287  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1288  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1289  for (passno = 0; passno < cblk->npasses; passno++) {
1290  Jpeg2000Pass *pass = &cblk->passes[passno];
1291  int dr;
1292  double dd, drslope;
1293 
1294  tile_disto += pass->disto;
1295  if (passno == 0) {
1296  dr = (int32_t)pass->rate;
1297  dd = pass->disto;
1298  } else {
1299  dr = (int32_t)(pass->rate - cblk->passes[passno - 1].rate);
1300  dd = pass->disto - cblk->passes[passno - 1].disto;
1301  }
1302 
1303  if (dr <= 0)
1304  continue;
1305 
1306  drslope = dd / dr;
1307  if (drslope < min)
1308  min = drslope;
1309 
1310  if (drslope > max)
1311  max = drslope;
1312  }
1313  }
1314  }
1315  }
1316  }
1317  }
1318 
1319  for (layno = 0; layno < s->nlayers; layno++) {
1320  double lo = min;
1321  double hi = max;
1322  double stable_thresh = 0.0;
1323  double good_thresh = 0.0;
1324  if (!s->layer_rates[layno]) {
1325  good_thresh = -1.0;
1326  } else {
1327  for (i = 0; i < 128; i++) {
1328  uint8_t *stream_pos = s->buf;
1329  int ret;
1330  thresh = (lo + hi) / 2;
1331  makelayer(s, layno, thresh, tile, 0);
1332  ret = encode_packets(s, tile, (int)(tile - s->tile), layno + 1);
1333  memset(stream_pos, 0, s->buf - stream_pos);
1334  if ((s->buf - stream_pos > ceil(tile->layer_rates[layno])) || ret < 0) {
1335  lo = thresh;
1336  s->buf = stream_pos;
1337  continue;
1338  }
1339  hi = thresh;
1340  stable_thresh = thresh;
1341  s->buf = stream_pos;
1342  }
1343  }
1344  if (good_thresh >= 0.0)
1345  good_thresh = stable_thresh == 0.0 ? thresh : stable_thresh;
1346  makelayer(s, layno, good_thresh, tile, 1);
1347  }
1348 }
1349 
1350 static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
1351 {
1352  int passno, res = 0;
1353  for (passno = 0; passno < cblk->npasses; passno++){
1354  int dr;
1355  int64_t dd;
1356 
1357  dr = cblk->passes[passno].rate
1358  - (res ? cblk->passes[res-1].rate : 0);
1359  dd = cblk->passes[passno].disto
1360  - (res ? cblk->passes[res-1].disto : 0);
1361 
1362  if (((dd * dwt_norm) >> WMSEDEC_SHIFT) * dwt_norm >= dr * lambda)
1363  res = passno+1;
1364  }
1365  return res;
1366 }
1367 
1368 static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
1369 {
1370  int precno, compno, reslevelno, bandno, cblkno, lev;
1371  Jpeg2000CodingStyle *codsty = &s->codsty;
1372 
1373  for (compno = 0; compno < s->ncomponents; compno++){
1374  Jpeg2000Component *comp = tile->comp + compno;
1375 
1376  for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1377  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1378 
1379  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1380  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1381  int bandpos = bandno + (reslevelno > 0);
1382  Jpeg2000Band *band = reslevel->band + bandno;
1383  Jpeg2000Prec *prec = band->prec + precno;
1384 
1385  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1386  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1387 
1388  cblk->ninclpasses = getcut(cblk, s->lambda,
1389  (int64_t)dwt_norms[codsty->transform == FF_DWT53][bandpos][lev] * (int64_t)band->i_stepsize >> 15);
1390  cblk->layers[0].data_start = cblk->data;
1391  cblk->layers[0].cum_passes = cblk->ninclpasses;
1392  cblk->layers[0].npasses = cblk->ninclpasses;
1393  if (cblk->ninclpasses)
1394  cblk->layers[0].data_len = cblk->passes[cblk->ninclpasses - 1].rate;
1395  }
1396  }
1397  }
1398  }
1399  }
1400 }
1401 
1402 static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
1403 {
1404  int compno, reslevelno, bandno, ret;
1405  Jpeg2000T1Context t1;
1406  Jpeg2000CodingStyle *codsty = &s->codsty;
1407  for (compno = 0; compno < s->ncomponents; compno++){
1408  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1409 
1410  t1.stride = (1<<codsty->log2_cblk_width) + 2;
1411 
1412  av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");
1413  if ((ret = ff_dwt_encode(&comp->dwt, comp->i_data)) < 0)
1414  return ret;
1415  av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
1416 
1417  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
1418  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1419 
1420  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1421  Jpeg2000Band *band = reslevel->band + bandno;
1422  Jpeg2000Prec *prec = band->prec; // we support only 1 precinct per band ATM in the encoder
1423  int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
1424  yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
1425  y0 = yy0;
1426  yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,
1427  band->coord[1][1]) - band->coord[1][0] + yy0;
1428 
1429  if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])
1430  continue;
1431 
1432  bandpos = bandno + (reslevelno > 0);
1433 
1434  for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){
1435  if (reslevelno == 0 || bandno == 1)
1436  xx0 = 0;
1437  else
1438  xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];
1439  x0 = xx0;
1440  xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,
1441  band->coord[0][1]) - band->coord[0][0] + xx0;
1442 
1443  for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){
1444  int y, x;
1445  if (codsty->transform == FF_DWT53){
1446  for (y = yy0; y < yy1; y++){
1447  int *ptr = t1.data + (y-yy0)*t1.stride;
1448  for (x = xx0; x < xx1; x++){
1449  *ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] * (1 << NMSEDEC_FRACBITS);
1450  }
1451  }
1452  } else{
1453  for (y = yy0; y < yy1; y++){
1454  int *ptr = t1.data + (y-yy0)*t1.stride;
1455  for (x = xx0; x < xx1; x++){
1456  *ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
1457  *ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 15 - NMSEDEC_FRACBITS;
1458  ptr++;
1459  }
1460  }
1461  }
1462  if (!prec->cblk[cblkno].data)
1463  prec->cblk[cblkno].data = av_malloc(1 + 8192);
1464  if (!prec->cblk[cblkno].passes)
1465  prec->cblk[cblkno].passes = av_malloc_array(JPEG2000_MAX_PASSES, sizeof (*prec->cblk[cblkno].passes));
1466  if (!prec->cblk[cblkno].data || !prec->cblk[cblkno].passes)
1467  return AVERROR(ENOMEM);
1468  encode_cblk(s, &t1, prec->cblk + cblkno, tile, xx1 - xx0, yy1 - yy0,
1469  bandpos, codsty->nreslevels - reslevelno - 1);
1470  xx0 = xx1;
1471  xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);
1472  }
1473  yy0 = yy1;
1474  yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);
1475  }
1476  }
1477  }
1478  av_log(s->avctx, AV_LOG_DEBUG, "after tier1\n");
1479  }
1480 
1481  av_log(s->avctx, AV_LOG_DEBUG, "rate control\n");
1482  if (s->compression_rate_enc)
1483  makelayers(s, tile);
1484  else
1485  truncpasses(s, tile);
1486 
1487  if ((ret = encode_packets(s, tile, tileno, s->nlayers)) < 0)
1488  return ret;
1489  av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n");
1490  return 0;
1491 }
1492 
1493 static void cleanup(Jpeg2000EncoderContext *s)
1494 {
1495  int tileno, compno;
1496  Jpeg2000CodingStyle *codsty = &s->codsty;
1497 
1498  if (!s->tile)
1499  return;
1500  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1501  if (s->tile[tileno].comp) {
1502  for (compno = 0; compno < s->ncomponents; compno++){
1503  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1504  ff_jpeg2000_cleanup(comp, codsty);
1505  }
1506  av_freep(&s->tile[tileno].comp);
1507  }
1508  av_freep(&s->tile[tileno].layer_rates);
1509  }
1510  av_freep(&s->tile);
1511 }
1512 
1513 static void reinit(Jpeg2000EncoderContext *s)
1514 {
1515  int tileno, compno;
1516  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1517  Jpeg2000Tile *tile = s->tile + tileno;
1518  for (compno = 0; compno < s->ncomponents; compno++)
1519  ff_jpeg2000_reinit(tile->comp + compno, &s->codsty);
1520  }
1521 }
1522 
1523 static void update_size(uint8_t *size, const uint8_t *end)
1524 {
1525  AV_WB32(size, end-size);
1526 }
1527 
1528 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1529  const AVFrame *pict, int *got_packet)
1530 {
1531  int tileno, ret;
1532  Jpeg2000EncoderContext *s = avctx->priv_data;
1533  uint8_t *chunkstart, *jp2cstart, *jp2hstart;
1534 
1535  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
1536  return ret;
1537 
1538  // init:
1539  s->buf = s->buf_start = pkt->data;
1540  s->buf_end = pkt->data + pkt->size;
1541 
1542  s->picture = pict;
1543 
1544  s->lambda = s->picture->quality * LAMBDA_SCALE;
1545 
1546  if (avctx->pix_fmt == AV_PIX_FMT_BGR48 || avctx->pix_fmt == AV_PIX_FMT_GRAY16)
1547  copy_frame_16(s);
1548  else
1549  copy_frame_8(s);
1550 
1551  reinit(s);
1552 
1553  if (s->format == CODEC_JP2) {
1554  av_assert0(s->buf == pkt->data);
1555 
1556  bytestream_put_be32(&s->buf, 0x0000000C);
1557  bytestream_put_be32(&s->buf, 0x6A502020);
1558  bytestream_put_be32(&s->buf, 0x0D0A870A);
1559 
1560  chunkstart = s->buf;
1561  bytestream_put_be32(&s->buf, 0);
1562  bytestream_put_buffer(&s->buf, "ftyp", 4);
1563  bytestream_put_buffer(&s->buf, "jp2\040\040", 4);
1564  bytestream_put_be32(&s->buf, 0);
1565  bytestream_put_buffer(&s->buf, "jp2\040", 4);
1566  update_size(chunkstart, s->buf);
1567 
1568  jp2hstart = s->buf;
1569  bytestream_put_be32(&s->buf, 0);
1570  bytestream_put_buffer(&s->buf, "jp2h", 4);
1571 
1572  chunkstart = s->buf;
1573  bytestream_put_be32(&s->buf, 0);
1574  bytestream_put_buffer(&s->buf, "ihdr", 4);
1575  bytestream_put_be32(&s->buf, avctx->height);
1576  bytestream_put_be32(&s->buf, avctx->width);
1577  bytestream_put_be16(&s->buf, s->ncomponents);
1578  bytestream_put_byte(&s->buf, s->cbps[0]);
1579  bytestream_put_byte(&s->buf, 7);
1580  bytestream_put_byte(&s->buf, 0);
1581  bytestream_put_byte(&s->buf, 0);
1582  update_size(chunkstart, s->buf);
1583 
1584  chunkstart = s->buf;
1585  bytestream_put_be32(&s->buf, 0);
1586  bytestream_put_buffer(&s->buf, "colr", 4);
1587  bytestream_put_byte(&s->buf, 1);
1588  bytestream_put_byte(&s->buf, 0);
1589  bytestream_put_byte(&s->buf, 0);
1590  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1591  bytestream_put_be32(&s->buf, 16);
1592  } else if (s->ncomponents == 1) {
1593  bytestream_put_be32(&s->buf, 17);
1594  } else {
1595  bytestream_put_be32(&s->buf, 18);
1596  }
1597  update_size(chunkstart, s->buf);
1598  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1599  int i;
1600  uint8_t *palette = pict->data[1];
1601  chunkstart = s->buf;
1602  bytestream_put_be32(&s->buf, 0);
1603  bytestream_put_buffer(&s->buf, "pclr", 4);
1604  bytestream_put_be16(&s->buf, AVPALETTE_COUNT);
1605  bytestream_put_byte(&s->buf, 3); // colour channels
1606  bytestream_put_be24(&s->buf, 0x070707); //colour depths
1607  for (i = 0; i < AVPALETTE_COUNT; i++) {
1608  bytestream_put_be24(&s->buf, HAVE_BIGENDIAN ? AV_RB24(palette + 1) : AV_RL24(palette));
1609  palette += 4;
1610  }
1611  update_size(chunkstart, s->buf);
1612  chunkstart = s->buf;
1613  bytestream_put_be32(&s->buf, 0);
1614  bytestream_put_buffer(&s->buf, "cmap", 4);
1615  for (i = 0; i < 3; i++) {
1616  bytestream_put_be16(&s->buf, 0); // component
1617  bytestream_put_byte(&s->buf, 1); // palette mapping
1618  bytestream_put_byte(&s->buf, i); // index
1619  }
1620  update_size(chunkstart, s->buf);
1621  }
1622  update_size(jp2hstart, s->buf);
1623 
1624  jp2cstart = s->buf;
1625  bytestream_put_be32(&s->buf, 0);
1626  bytestream_put_buffer(&s->buf, "jp2c", 4);
1627  }
1628 
1629  if (s->buf_end - s->buf < 2)
1630  return -1;
1631  bytestream_put_be16(&s->buf, JPEG2000_SOC);
1632  if ((ret = put_siz(s)) < 0)
1633  return ret;
1634  if ((ret = put_cod(s)) < 0)
1635  return ret;
1636  if ((ret = put_qcd(s, 0)) < 0)
1637  return ret;
1638  if ((ret = put_com(s, 0)) < 0)
1639  return ret;
1640 
1641  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1642  uint8_t *psotptr;
1643  if (!(psotptr = put_sot(s, tileno)))
1644  return -1;
1645  if (s->buf_end - s->buf < 2)
1646  return -1;
1647  bytestream_put_be16(&s->buf, JPEG2000_SOD);
1648  if ((ret = encode_tile(s, s->tile + tileno, tileno)) < 0)
1649  return ret;
1650  bytestream_put_be32(&psotptr, s->buf - psotptr + 6);
1651  }
1652  if (s->buf_end - s->buf < 2)
1653  return -1;
1654  bytestream_put_be16(&s->buf, JPEG2000_EOC);
1655 
1656  if (s->format == CODEC_JP2)
1657  update_size(jp2cstart, s->buf);
1658 
1659  av_log(s->avctx, AV_LOG_DEBUG, "end\n");
1660  pkt->size = s->buf - s->buf_start;
1661  pkt->flags |= AV_PKT_FLAG_KEY;
1662  *got_packet = 1;
1663 
1664  return 0;
1665 }
1666 
1667 static int parse_layer_rates(Jpeg2000EncoderContext *s)
1668 {
1669  int i;
1670  char *token;
1671  char *saveptr = NULL;
1672  int rate;
1673  int nlayers = 0;
1674  if (!s->lr_str) {
1675  s->nlayers = 1;
1676  s->layer_rates[0] = 0;
1677  s->compression_rate_enc = 0;
1678  return 0;
1679  }
1680 
1681  token = av_strtok(s->lr_str, ",", &saveptr);
1682  if (rate = strtol(token, NULL, 10)) {
1683  s->layer_rates[0] = rate <= 1 ? 0:rate;
1684  nlayers++;
1685  } else {
1686  return AVERROR_INVALIDDATA;
1687  }
1688 
1689  while (1) {
1690  token = av_strtok(NULL, ",", &saveptr);
1691  if (!token)
1692  break;
1693  if (rate = strtol(token, NULL, 10)) {
1694  if (nlayers >= 100) {
1695  return AVERROR_INVALIDDATA;
1696  }
1697  s->layer_rates[nlayers] = rate <= 1 ? 0:rate;
1698  nlayers++;
1699  } else {
1700  return AVERROR_INVALIDDATA;
1701  }
1702  }
1703 
1704  for (i = 1; i < nlayers; i++) {
1705  if (s->layer_rates[i] >= s->layer_rates[i-1]) {
1706  return AVERROR_INVALIDDATA;
1707  }
1708  }
1709  s->nlayers = nlayers;
1710  s->compression_rate_enc = 1;
1711  return 0;
1712 }
1713 
1714 static av_cold int j2kenc_init(AVCodecContext *avctx)
1715 {
1716  int i, ret;
1717  Jpeg2000EncoderContext *s = avctx->priv_data;
1718  Jpeg2000CodingStyle *codsty = &s->codsty;
1719  Jpeg2000QuantStyle *qntsty = &s->qntsty;
1720 
1721  s->avctx = avctx;
1722  av_log(s->avctx, AV_LOG_DEBUG, "init\n");
1723  if (parse_layer_rates(s)) {
1724  av_log(s, AV_LOG_WARNING, "Layer rates invalid. Encoding with 1 layer based on quality metric.\n");
1725  s->nlayers = 1;
1726  s->layer_rates[0] = 0;
1727  s->compression_rate_enc = 0;
1728  }
1729 
1730 #if FF_API_PRIVATE_OPT
1731 FF_DISABLE_DEPRECATION_WARNINGS
1732  if (avctx->prediction_method)
1733  s->pred = avctx->prediction_method;
1734 FF_ENABLE_DEPRECATION_WARNINGS
1735 #endif
1736 
1737  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && (s->pred != FF_DWT97_INT || s->format != CODEC_JP2)) {
1738  av_log(s->avctx, AV_LOG_WARNING, "Forcing lossless jp2 for pal8\n");
1739  s->pred = FF_DWT97_INT;
1740  s->format = CODEC_JP2;
1741  }
1742 
1743  // defaults:
1744  // TODO: implement setting non-standard precinct size
1745  memset(codsty->log2_prec_widths , 15, sizeof(codsty->log2_prec_widths ));
1746  memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights));
1747  codsty->nreslevels2decode=
1748  codsty->nreslevels = 7;
1749  codsty->nlayers = s->nlayers;
1750  codsty->log2_cblk_width = 4;
1751  codsty->log2_cblk_height = 4;
1752  codsty->transform = s->pred ? FF_DWT53 : FF_DWT97_INT;
1753 
1754  qntsty->nguardbits = 1;
1755 
1756  if ((s->tile_width & (s->tile_width -1)) ||
1757  (s->tile_height & (s->tile_height-1))) {
1758  av_log(avctx, AV_LOG_WARNING, "Tile dimension not a power of 2\n");
1759  }
1760 
1761  if (codsty->transform == FF_DWT53)
1762  qntsty->quantsty = JPEG2000_QSTY_NONE;
1763  else
1764  qntsty->quantsty = JPEG2000_QSTY_SE;
1765 
1766  s->width = avctx->width;
1767  s->height = avctx->height;
1768 
1769  for (i = 0; i < 3; i++) {
1770  if (avctx->pix_fmt == AV_PIX_FMT_GRAY16 || avctx->pix_fmt == AV_PIX_FMT_RGB48)
1771  s->cbps[i] = 16;
1772  else
1773  s->cbps[i] = 8;
1774  }
1775 
1776  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_RGB48){
1777  s->ncomponents = 3;
1778  } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16){
1779  s->ncomponents = 1;
1780  } else{ // planar YUV
1781  s->planar = 1;
1782  s->ncomponents = 3;
1783  ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
1784  s->chroma_shift, s->chroma_shift + 1);
1785  if (ret)
1786  return ret;
1787  }
1788 
1789  ff_jpeg2000_init_tier1_luts();
1790  ff_mqc_init_context_tables();
1791  init_luts();
1792 
1793  init_quantization(s);
1794  if ((ret=init_tiles(s)) < 0)
1795  return ret;
1796 
1797  av_log(s->avctx, AV_LOG_DEBUG, "after init\n");
1798 
1799  return 0;
1800 }
1801 
1802 static int j2kenc_destroy(AVCodecContext *avctx)
1803 {
1804  Jpeg2000EncoderContext *s = avctx->priv_data;
1805 
1806  cleanup(s);
1807  return 0;
1808 }
1809 
1810 // taken from the libopenjpeg wraper so it matches
1811 
1812 #define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)
1813 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1814 static const AVOption options[] = {
1815  { "format", "Codec Format", OFFSET(format), AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2, VE, "format" },
1816  { "j2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K }, 0, 0, VE, "format" },
1817  { "jp2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2 }, 0, 0, VE, "format" },
1818  { "tile_width", "Tile Width", OFFSET(tile_width), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1819  { "tile_height", "Tile Height", OFFSET(tile_height), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1820  { "pred", "DWT Type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "pred" },
1821  { "dwt97int", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1822  { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1823  { "sop", "SOP marker", OFFSET(sop), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1824  { "eph", "EPH marker", OFFSET(eph), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1825  { "prog", "Progression Order", OFFSET(prog), AV_OPT_TYPE_INT, { .i64 = 0 }, JPEG2000_PGOD_LRCP, JPEG2000_PGOD_CPRL, VE, "prog" },
1826  { "lrcp", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_LRCP }, 0, 0, VE, "prog" },
1827  { "rlcp", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RLCP }, 0, 0, VE, "prog" },
1828  { "rpcl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RPCL }, 0, 0, VE, "prog" },
1829  { "pcrl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_PCRL }, 0, 0, VE, "prog" },
1830  { "cprl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_CPRL }, 0, 0, VE, "prog" },
1831  { "layer_rates", "Layer Rates", OFFSET(lr_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1832  { NULL }
1833 };
1834 
1835 static const AVClass j2k_class = {
1836  .class_name = "jpeg 2000 encoder",
1837  .item_name = av_default_item_name,
1838  .option = options,
1839  .version = LIBAVUTIL_VERSION_INT,
1840 };
1841 
1842 AVCodec ff_jpeg2000_encoder = {
1843  .name = "jpeg2000",
1844  .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1845  .type = AVMEDIA_TYPE_VIDEO,
1846  .id = AV_CODEC_ID_JPEG2000,
1847  .priv_data_size = sizeof(Jpeg2000EncoderContext),
1848  .init = j2kenc_init,
1849  .encode2 = encode_frame,
1850  .close = j2kenc_destroy,
1851  .pix_fmts = (const enum AVPixelFormat[]) {
1852  AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GRAY8,
1853  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
1854  AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
1855  AV_PIX_FMT_PAL8,
1856  AV_PIX_FMT_RGB48, AV_PIX_FMT_GRAY16,
1857  AV_PIX_FMT_NONE
1858  },
1859  .priv_class = &j2k_class,
1860  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1861 };
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: internal.h:49
getcut
static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
Definition: j2kenc.c:1350
format
fg outputs[0] format
Definition: ffmpeg_filter.c:177
Jpeg2000QuantStyle::nguardbits
uint8_t nguardbits
Definition: jpeg2000.h:155
NULL
#define NULL
Definition: coverity.c:32
Jpeg2000Layer::cum_passes
int cum_passes
Definition: jpeg2000.h:170
NMSEDEC_BITS
#define NMSEDEC_BITS
Definition: j2kenc.c:78
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_jpeg2000_init_tier1_luts
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:160
ff_jpeg2000_cleanup
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:590
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
Jpeg2000Component::dwt
DWTContext dwt
Definition: jpeg2000.h:220
AVOption
AVOption.
Definition: opt.h:248
Jpeg2000Prec::cblkincl
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:196
cleanup
static void cleanup(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1493
JPEG2000_T1_SIG_NB
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:85
ff_jpeg2000_encoder
AVCodec ff_jpeg2000_encoder
Definition: j2kenc.c:1842
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
JPEG2000_PGOD_PCRL
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:118
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AV_OPT_TYPE_INT
Definition: opt.h:225
Jpeg2000Cblk::ninclpasses
uint8_t ninclpasses
Definition: jpeg2000.h:175
JPEG2000_PGOD_RLCP
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:116
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
Jpeg2000EncoderContext::qntsty
Jpeg2000QuantStyle qntsty
Definition: j2kenc.c:129
lut_nmsedec_ref
static int lut_nmsedec_ref[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
j2kenc_init
static av_cold int j2kenc_init(AVCodecContext *avctx)
Definition: j2kenc.c:1714
AVPacket::size
int size
Definition: packet.h:370
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
Jpeg2000Prec::nb_codeblocks_width
int nb_codeblocks_width
Definition: jpeg2000.h:193
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
put_com
static int put_com(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:385
Jpeg2000EncoderContext::avctx
AVCodecContext * avctx
Definition: j2kenc.c:110
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:36
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
Jpeg2000QuantStyle::mant
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:153
ff_mqc_initenc
void ff_mqc_initenc(MqcState *mqc, uint8_t *bp)
initialize the encoder
Definition: mqcenc.c:69
tag_tree_code
static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)
code the value stored in node
Definition: j2kenc.c:249
ceil
static __device__ float ceil(float a)
Definition: cuda_runtime.h:176
pkt
AVPacket * pkt
Definition: movenc.c:59
AVCodec
AVCodec.
Definition: codec.h:197
tag_tree_update
static void tag_tree_update(Jpeg2000TgtNode *node)
update the value in node
Definition: j2kenc.c:286
update_size
static void update_size(uint8_t *size, const uint8_t *end)
Definition: j2kenc.c:1523
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
getnmsedec_ref
static int getnmsedec_ref(int x, int bpno)
Definition: j2kenc.c:604
Jpeg2000Cblk::npasses
uint8_t npasses
Definition: jpeg2000.h:174
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:72
Jpeg2000Band::log2_cblk_width
uint16_t log2_cblk_width
Definition: jpeg2000.h:204
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
AV_OPT_TYPE_CONST
Definition: opt.h:234
JPEG2000_CSTY_SOP
#define JPEG2000_CSTY_SOP
Definition: jpeg2000.h:111
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:88
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
lut_nmsedec_ref0
static int lut_nmsedec_ref0[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
opt.h
AVOptions.
Jpeg2000Layer::disto
double disto
Definition: jpeg2000.h:169
compute_rates
static void compute_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:423
j2k_class
static const AVClass j2k_class
Definition: j2kenc.c:1835
Jpeg2000Prec::zerobits
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:195
Jpeg2000Pass::disto
int64_t disto
Definition: jpeg2000.h:160
Jpeg2000ResLevel::band
Jpeg2000Band * band
Definition: jpeg2000.h:215
Jpeg2000TgtNode::val
uint8_t val
Definition: jpeg2000.h:129
Jpeg2000Component::coord
int coord[2][2]
Definition: jpeg2000.h:223
height
#define height
AV_OPT_TYPE_STRING
Definition: opt.h:229
AVPacket::data
uint8_t * data
Definition: packet.h:369
j2k_flush
static void j2k_flush(Jpeg2000EncoderContext *s)
flush the bitstream
Definition: j2kenc.c:238
sp
#define sp
Definition: regdef.h:63
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:390
init_tiles
static int init_tiles(Jpeg2000EncoderContext *s)
compute the sizes of tiles, resolution levels, bands, etc.
Definition: j2kenc.c:453
JPEG2000_T1_VIS
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:95
max
#define max(a, b)
Definition: cuda_runtime.h:33
size
ptrdiff_t size
Definition: opengl_enc.c:100
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
Jpeg2000T1Context::flags
uint16_t flags[6156]
Definition: jpeg2000.h:123
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
Jpeg2000Cblk::nonzerobits
uint8_t nonzerobits
Definition: jpeg2000.h:176
Jpeg2000CodingStyle::log2_prec_widths
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:146
JPEG2000_CSTY_EPH
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:112
U
#define U(x)
Definition: vp56_arith.h:37
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:780
mask
static const uint16_t mask[17]
Definition: lzw.c:38
Jpeg2000EncoderContext::buf_end
uint8_t * buf_end
Definition: j2kenc.c:123
OFFSET
#define OFFSET(x)
Definition: j2kenc.c:1812
ff_jpeg2000_set_significance
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:172
put_cod
static int put_cod(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:327
Jpeg2000Prec::nb_codeblocks_height
int nb_codeblocks_height
Definition: jpeg2000.h:194
CODEC_J2K
#define CODEC_J2K
Definition: j2kenc.c:84
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:2601
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
JPEG2000_PGOD_CPRL
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:119
pos
unsigned int pos
Definition: spdifenc.c:412
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
Jpeg2000CodingStyle::log2_prec_heights
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:147
t1
#define t1
Definition: regdef.h:29
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
JPEG2000_MAX_PASSES
#define JPEG2000_MAX_PASSES
Definition: jpeg2000.h:73
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:385
put_num
static void put_num(Jpeg2000EncoderContext *s, int num, int n)
put n least significant bits of a number num
Definition: j2kenc.c:231
Jpeg2000Cblk::incl
uint8_t incl
Definition: jpeg2000.h:177
length
GLsizei GLsizei * length
Definition: opengl_enc.c:114
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: j2kenc.c:1528
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:91
Jpeg2000EncoderContext::picture
const AVFrame * picture
Definition: j2kenc.c:111
Jpeg2000Pass::flushed
uint8_t flushed[4]
Definition: jpeg2000.h:161
Jpeg2000Prec::cblk
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:197
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
ff_jpeg2000_ceildiv
static int ff_jpeg2000_ceildiv(int a, int64_t b)
Definition: jpeg2000.h:234
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
pass
#define pass
Definition: fft_template.c:603
put_siz
static int put_siz(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:298
lut_nmsedec_sig0
static int lut_nmsedec_sig0[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
JPEG2000_T1_REF
#define JPEG2000_T1_REF
Definition: jpeg2000.h:97
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
Jpeg2000Cblk::lblock
uint8_t lblock
Definition: jpeg2000.h:181
Jpeg2000Pass::flushed_len
int flushed_len
Definition: jpeg2000.h:162
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
put_qcd
static int put_qcd(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:359
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
getnmsedec_sig
static int getnmsedec_sig(int x, int bpno)
Definition: j2kenc.c:597
Jpeg2000EncoderContext::tile_height
int tile_height
tile size
Definition: j2kenc.c:118
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
Jpeg2000TgtNode::parent
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:132
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:611
width
#define width
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
jpeg2000.h
JPEG 2000 structures and defines common to encoder and decoder.
Jpeg2000Band::i_stepsize
int i_stepsize
Definition: jpeg2000.h:205
int32_t
int32_t
Definition: audio_convert.c:194
j2kenc_destroy
static int j2kenc_destroy(AVCodecContext *avctx)
Definition: j2kenc.c:1802
MQC_CX_RL
#define MQC_CX_RL
Definition: mqc.h:34
CODEC_JP2
#define CODEC_JP2
Definition: j2kenc.c:83
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_jpeg2000_getsigctxno
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:253
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:441
Jpeg2000Cblk::layers
Jpeg2000Layer * layers
Definition: jpeg2000.h:188
makelayers
static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
Definition: j2kenc.c:1265
Jpeg2000EncoderContext::cbps
uint8_t cbps[4]
bits per sample in particular components
Definition: j2kenc.c:114
ff_dwt_encode
int ff_dwt_encode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:581
Jpeg2000ResLevel::coord
int coord[2][2]
Definition: jpeg2000.h:212
Jpeg2000Cblk::data
uint8_t * data
Definition: jpeg2000.h:182
encode_tile
static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
Definition: j2kenc.c:1402
JPEG2000_PGOD_RPCL
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:117
ff_jpeg2000_ceildivpow2
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:229
pred
static const float pred[4]
Definition: siprdata.h:259
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
Jpeg2000Band::coord
int coord[2][2]
Definition: jpeg2000.h:203
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
COPY_FRAME
#define COPY_FRAME(D, PIXEL)
Definition: j2kenc.c:505
Jpeg2000Component::coord_o
int coord_o[2][2]
Definition: jpeg2000.h:224
avcodec.h
Libavcodec external API header.
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:91
encode_refpass
static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
Definition: j2kenc.c:633
AVCodecContext::prediction_method
attribute_deprecated int prediction_method
Definition: avcodec.h:895
Jpeg2000EncoderContext::buf_start
uint8_t * buf_start
Definition: j2kenc.c:121
Jpeg2000EncoderContext::codsty
Jpeg2000CodingStyle codsty
Definition: j2kenc.c:128
AVCodecContext
main external API structure.
Definition: avcodec.h:536
Jpeg2000TgtNode::vis
uint8_t vis
Definition: jpeg2000.h:131
Jpeg2000ResLevel::log2_prec_height
uint8_t log2_prec_height
Definition: jpeg2000.h:214
ff_mqc_init_context_tables
void av_cold ff_mqc_init_context_tables(void)
MQ-coder Initialize context tables (QE, NLPS, NMPS)
Definition: mqc.c:97
Jpeg2000Layer::data_start
uint8_t * data_start
Definition: jpeg2000.h:166
init_luts
static void init_luts(void)
Definition: j2kenc.c:579
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:702
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
options
static const AVOption options[]
Definition: j2kenc.c:1814
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:211
JPEG2000_T1_SGN
#define JPEG2000_T1_SGN
Definition: jpeg2000.h:99
Jpeg2000EncoderContext::height
int height
image width and height
Definition: j2kenc.c:113
Jpeg2000Component::reslevel
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:219
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
Jpeg2000Tile::comp
Jpeg2000Component * comp
Definition: j2kenc.c:104
ff_jpeg2000_reinit
void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:569
encode_packets
static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
Definition: j2kenc.c:936
AV_CODEC_ID_JPEG2000
Definition: codec_id.h:137
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
Jpeg2000QuantStyle::expn
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:152
reinit
static void reinit(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1513
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:186
put_sot
static uint8_t * put_sot(Jpeg2000EncoderContext *s, int tileno)
Definition: j2kenc.c:404
Jpeg2000EncoderContext::tile
Jpeg2000Tile * tile
Definition: j2kenc.c:131
Jpeg2000TgtNode::temp_val
uint8_t temp_val
Definition: jpeg2000.h:130
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
Jpeg2000QuantStyle::quantsty
uint8_t quantsty
Definition: jpeg2000.h:154
internal.h
common internal api header.
common.h
common internal and external API header
Jpeg2000CodingStyle::log2_cblk_width
uint8_t log2_cblk_width
Definition: jpeg2000.h:138
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
LAMBDA_SCALE
#define LAMBDA_SCALE
Definition: j2kenc.c:81
Jpeg2000T1Context::data
int data[6144]
Definition: jpeg2000.h:122
AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
Jpeg2000Band::log2_cblk_height
uint16_t log2_cblk_height
Definition: jpeg2000.h:204
VE
#define VE
Definition: j2kenc.c:1813
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
ff_tag_tree_zero
void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)
Definition: jpeg2000.c:85
MQC_CX_UNI
#define MQC_CX_UNI
Definition: mqc.h:33
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
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:459
Jpeg2000Pass::rate
uint16_t rate
Definition: jpeg2000.h:159
putnumpasses
static void putnumpasses(Jpeg2000EncoderContext *s, int n)
Definition: j2kenc.c:765
JPEG2000_PGOD_LRCP
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:115
ff_mqc_flush_to
int ff_mqc_flush_to(MqcState *mqc, uint8_t *dst, int *dst_len)
Definition: mqcenc.c:117
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
lev
static LevelCodes lev[4+3+3]
Definition: clearvideo.c:85
truncpasses
static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
Definition: j2kenc.c:1368
Jpeg2000Band::prec
Jpeg2000Prec * prec
Definition: jpeg2000.h:207
Jpeg2000Tile::layer_rates
double * layer_rates
Definition: j2kenc.c:105
makelayer
static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile *tile, int final)
Definition: j2kenc.c:1182
encode_clnpass
static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
Definition: j2kenc.c:647
JPEG2000_T1_SIG
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:96
lut_nmsedec_sig
static int lut_nmsedec_sig[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:42
Jpeg2000EncoderContext::layer_rates
int layer_rates[100]
Definition: j2kenc.c:132
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
Jpeg2000T1Context::mqc
MqcState mqc
Definition: jpeg2000.h:124
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_jpeg2000_getrefctxno
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:262
Jpeg2000CodingStyle::log2_cblk_height
uint8_t log2_cblk_height
Definition: jpeg2000.h:138
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
NMSEDEC_FRACBITS
#define NMSEDEC_FRACBITS
Definition: j2kenc.c:79
init_quantization
static void init_quantization(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:549
Jpeg2000ResLevel::log2_prec_width
uint8_t log2_prec_width
Definition: jpeg2000.h:214
parse_layer_rates
static int parse_layer_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1667
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
Jpeg2000Cblk::passes
Jpeg2000Pass * passes
Definition: jpeg2000.h:187
min
float min
Definition: vorbis_enc_data.h:456
dwt_norms
static const int dwt_norms[2][4][10]
Definition: j2kenc.c:91
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVPacket
This structure stores compressed data.
Definition: packet.h:346
Jpeg2000EncoderContext::compression_rate_enc
uint8_t compression_rate_enc
Is compression done using compression ratio?
Definition: j2kenc.c:133
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
i
int i
Definition: input.c:407
MqcState::cx_states
uint8_t cx_states[19]
Definition: mqc.h:45
WMSEDEC_SHIFT
#define WMSEDEC_SHIFT
must be >= 13
Definition: j2kenc.c:80
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
ff_jpeg2000_getsgnctxno
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:271
ff_mqc_encode
void ff_mqc_encode(MqcState *mqc, uint8_t *cxstate, int d)
code bit d with context cx
Definition: mqcenc.c:79
Generated on Thu Apr 15 2021 19:21:39 for FFmpeg by   doxygen 1.8.11