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  while (node->parent){
292  if (node->parent->val <= node->val)
293  break;
294  node->parent->val = node->val;
295  node = node->parent;
296  }
297 }
298 
300 {
301  int i;
302 
303  if (s->buf_end - s->buf < 40 + 3 * s->ncomponents)
304  return -1;
305 
306  bytestream_put_be16(&s->buf, JPEG2000_SIZ);
307  bytestream_put_be16(&s->buf, 38 + 3 * s->ncomponents); // Lsiz
308  bytestream_put_be16(&s->buf, 0); // Rsiz
309  bytestream_put_be32(&s->buf, s->width); // width
310  bytestream_put_be32(&s->buf, s->height); // height
311  bytestream_put_be32(&s->buf, 0); // X0Siz
312  bytestream_put_be32(&s->buf, 0); // Y0Siz
313 
314  bytestream_put_be32(&s->buf, s->tile_width); // XTSiz
315  bytestream_put_be32(&s->buf, s->tile_height); // YTSiz
316  bytestream_put_be32(&s->buf, 0); // XT0Siz
317  bytestream_put_be32(&s->buf, 0); // YT0Siz
318  bytestream_put_be16(&s->buf, s->ncomponents); // CSiz
319 
320  for (i = 0; i < s->ncomponents; i++){ // Ssiz_i XRsiz_i, YRsiz_i
321  bytestream_put_byte(&s->buf, s->cbps[i] - 1);
322  bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[0]:1);
323  bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[1]:1);
324  }
325  return 0;
326 }
327 
329 {
330  Jpeg2000CodingStyle *codsty = &s->codsty;
331  uint8_t scod = 0;
332 
333  if (s->buf_end - s->buf < 14)
334  return -1;
335 
336  bytestream_put_be16(&s->buf, JPEG2000_COD);
337  bytestream_put_be16(&s->buf, 12); // Lcod
338  if (s->sop)
339  scod |= JPEG2000_CSTY_SOP;
340  if (s->eph)
341  scod |= JPEG2000_CSTY_EPH;
342  bytestream_put_byte(&s->buf, scod); // Scod
343  // SGcod
344  bytestream_put_byte(&s->buf, s->prog); // progression level
345  bytestream_put_be16(&s->buf, s->nlayers); // num of layers
346  if(s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){
347  bytestream_put_byte(&s->buf, 0); // unspecified
348  }else{
349  bytestream_put_byte(&s->buf, 0); // unspecified
350  }
351  // SPcod
352  bytestream_put_byte(&s->buf, codsty->nreslevels - 1); // num of decomp. levels
353  bytestream_put_byte(&s->buf, codsty->log2_cblk_width-2); // cblk width
354  bytestream_put_byte(&s->buf, codsty->log2_cblk_height-2); // cblk height
355  bytestream_put_byte(&s->buf, 0); // cblk style
356  bytestream_put_byte(&s->buf, codsty->transform == FF_DWT53); // transformation
357  return 0;
358 }
359 
360 static int put_qcd(Jpeg2000EncoderContext *s, int compno)
361 {
362  int i, size;
363  Jpeg2000CodingStyle *codsty = &s->codsty;
364  Jpeg2000QuantStyle *qntsty = &s->qntsty;
365 
366  if (qntsty->quantsty == JPEG2000_QSTY_NONE)
367  size = 4 + 3 * (codsty->nreslevels-1);
368  else // QSTY_SE
369  size = 5 + 6 * (codsty->nreslevels-1);
370 
371  if (s->buf_end - s->buf < size + 2)
372  return -1;
373 
374  bytestream_put_be16(&s->buf, JPEG2000_QCD);
375  bytestream_put_be16(&s->buf, size); // LQcd
376  bytestream_put_byte(&s->buf, (qntsty->nguardbits << 5) | qntsty->quantsty); // Sqcd
377  if (qntsty->quantsty == JPEG2000_QSTY_NONE)
378  for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
379  bytestream_put_byte(&s->buf, qntsty->expn[i] << 3);
380  else // QSTY_SE
381  for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
382  bytestream_put_be16(&s->buf, (qntsty->expn[i] << 11) | qntsty->mant[i]);
383  return 0;
384 }
385 
386 static int put_com(Jpeg2000EncoderContext *s, int compno)
387 {
388  int size = 4 + strlen(LIBAVCODEC_IDENT);
389 
390  if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
391  return 0;
392 
393  if (s->buf_end - s->buf < size + 2)
394  return -1;
395 
396  bytestream_put_be16(&s->buf, JPEG2000_COM);
397  bytestream_put_be16(&s->buf, size);
398  bytestream_put_be16(&s->buf, 1); // General use (ISO/IEC 8859-15 (Latin) values)
399 
401 
402  return 0;
403 }
404 
405 static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno)
406 {
407  uint8_t *psotptr;
408 
409  if (s->buf_end - s->buf < 12)
410  return NULL;
411 
412  bytestream_put_be16(&s->buf, JPEG2000_SOT);
413  bytestream_put_be16(&s->buf, 10); // Lsot
414  bytestream_put_be16(&s->buf, tileno); // Isot
415 
416  psotptr = s->buf;
417  bytestream_put_be32(&s->buf, 0); // Psot (filled in later)
418 
419  bytestream_put_byte(&s->buf, 0); // TPsot
420  bytestream_put_byte(&s->buf, 1); // TNsot
421  return psotptr;
422 }
423 
425 {
426  int i, j;
427  int layno, compno;
428  for (i = 0; i < s->numYtiles; i++) {
429  for (j = 0; j < s->numXtiles; j++) {
430  Jpeg2000Tile *tile = &s->tile[s->numXtiles * i + j];
431  for (compno = 0; compno < s->ncomponents; compno++) {
432  int tilew = tile->comp[compno].coord[0][1] - tile->comp[compno].coord[0][0];
433  int tileh = tile->comp[compno].coord[1][1] - tile->comp[compno].coord[1][0];
434  int scale = (compno?1 << s->chroma_shift[0]:1) * (compno?1 << s->chroma_shift[1]:1);
435  for (layno = 0; layno < s->nlayers; layno++) {
436  if (s->layer_rates[layno] > 0) {
437  tile->layer_rates[layno] += (double)(tilew * tileh) * s->ncomponents * s->cbps[compno] /
438  (double)(s->layer_rates[layno] * 8 * scale);
439  } else {
440  tile->layer_rates[layno] = 0.0;
441  }
442  }
443  }
444  }
445  }
446 
447 }
448 
449 /**
450  * compute the sizes of tiles, resolution levels, bands, etc.
451  * allocate memory for them
452  * divide the input image into tile-components
453  */
455 {
456  int tileno, tilex, tiley, compno;
457  Jpeg2000CodingStyle *codsty = &s->codsty;
458  Jpeg2000QuantStyle *qntsty = &s->qntsty;
459 
460  s->numXtiles = ff_jpeg2000_ceildiv(s->width, s->tile_width);
461  s->numYtiles = ff_jpeg2000_ceildiv(s->height, s->tile_height);
462 
463  s->tile = av_calloc(s->numXtiles, s->numYtiles * sizeof(Jpeg2000Tile));
464  if (!s->tile)
465  return AVERROR(ENOMEM);
466  for (tileno = 0, tiley = 0; tiley < s->numYtiles; tiley++)
467  for (tilex = 0; tilex < s->numXtiles; tilex++, tileno++){
468  Jpeg2000Tile *tile = s->tile + tileno;
469 
470  tile->comp = av_calloc(s->ncomponents, sizeof(*tile->comp));
471  if (!tile->comp)
472  return AVERROR(ENOMEM);
473 
474  tile->layer_rates = av_calloc(s->nlayers, sizeof(*tile->layer_rates));
475  if (!tile->layer_rates)
476  return AVERROR(ENOMEM);
477 
478  for (compno = 0; compno < s->ncomponents; compno++){
479  Jpeg2000Component *comp = tile->comp + compno;
480  int ret, i, j;
481 
482  comp->coord[0][0] = comp->coord_o[0][0] = tilex * s->tile_width;
483  comp->coord[0][1] = comp->coord_o[0][1] = FFMIN((tilex+1)*s->tile_width, s->width);
484  comp->coord[1][0] = comp->coord_o[1][0] = tiley * s->tile_height;
485  comp->coord[1][1] = comp->coord_o[1][1] = FFMIN((tiley+1)*s->tile_height, s->height);
486  if (compno > 0)
487  for (i = 0; i < 2; i++)
488  for (j = 0; j < 2; j++)
489  comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]);
490 
492  codsty,
493  qntsty,
494  s->cbps[compno],
495  compno?1<<s->chroma_shift[0]:1,
496  compno?1<<s->chroma_shift[1]:1,
497  s->avctx
498  )) < 0)
499  return ret;
500  }
501  }
502  compute_rates(s);
503  return 0;
504 }
505 
506 #define COPY_FRAME(D, PIXEL) \
507  static void copy_frame_ ##D(Jpeg2000EncoderContext *s) \
508  { \
509  int tileno, compno, i, y, x; \
510  const PIXEL *line; \
511  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){ \
512  Jpeg2000Tile *tile = s->tile + tileno; \
513  if (s->planar){ \
514  for (compno = 0; compno < s->ncomponents; compno++){ \
515  Jpeg2000Component *comp = tile->comp + compno; \
516  int *dst = comp->i_data; \
517  int cbps = s->cbps[compno]; \
518  line = (const PIXEL*)s->picture->data[compno] \
519  + comp->coord[1][0] * (s->picture->linesize[compno] / sizeof(PIXEL)) \
520  + comp->coord[0][0]; \
521  for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){ \
522  const PIXEL *ptr = line; \
523  for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++) \
524  *dst++ = *ptr++ - (1 << (cbps - 1)); \
525  line += s->picture->linesize[compno] / sizeof(PIXEL); \
526  } \
527  } \
528  } else{ \
529  line = (const PIXEL*)(s->picture->data[0] + tile->comp[0].coord[1][0] * s->picture->linesize[0]) \
530  + tile->comp[0].coord[0][0] * s->ncomponents; \
531  \
532  i = 0; \
533  for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){ \
534  const PIXEL *ptr = line; \
535  for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){ \
536  for (compno = 0; compno < s->ncomponents; compno++){ \
537  int cbps = s->cbps[compno]; \
538  tile->comp[compno].i_data[i] = *ptr++ - (1 << (cbps - 1)); \
539  } \
540  } \
541  line += s->picture->linesize[0] / sizeof(PIXEL); \
542  } \
543  } \
544  } \
545  }
546 
547 COPY_FRAME(8, uint8_t)
548 COPY_FRAME(16, uint16_t)
549 
551 {
552  int compno, reslevelno, bandno;
553  Jpeg2000QuantStyle *qntsty = &s->qntsty;
554  Jpeg2000CodingStyle *codsty = &s->codsty;
555 
556  for (compno = 0; compno < s->ncomponents; compno++){
557  int gbandno = 0;
558  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
559  int nbands, lev = codsty->nreslevels - reslevelno - 1;
560  nbands = reslevelno ? 3 : 1;
561  for (bandno = 0; bandno < nbands; bandno++, gbandno++){
562  int expn, mant = 0;
563 
564  if (codsty->transform == FF_DWT97_INT){
565  int bandpos = bandno + (reslevelno>0),
566  ss = 81920000 / dwt_norms[0][bandpos][lev],
567  log = av_log2(ss);
568  mant = (11 - log < 0 ? ss >> log - 11 : ss << 11 - log) & 0x7ff;
569  expn = s->cbps[compno] - log + 13;
570  } else
571  expn = ((bandno&2)>>1) + (reslevelno>0) + s->cbps[compno];
572 
573  qntsty->expn[gbandno] = expn;
574  qntsty->mant[gbandno] = mant;
575  }
576  }
577  }
578 }
579 
580 static void init_luts(void)
581 {
582  int i, a,
583  mask = ~((1<<NMSEDEC_FRACBITS)-1);
584 
585  for (i = 0; i < (1 << NMSEDEC_BITS); i++){
586  lut_nmsedec_sig[i] = FFMAX((3 * i << (13 - NMSEDEC_FRACBITS)) - (9 << 11), 0);
587  lut_nmsedec_sig0[i] = FFMAX((i*i + (1<<NMSEDEC_FRACBITS-1) & mask) << 1, 0);
588 
589  a = (i >> (NMSEDEC_BITS-2)&2) + 1;
590  lut_nmsedec_ref[i] = FFMAX((a - 2) * (i << (13 - NMSEDEC_FRACBITS)) +
591  (1 << 13) - (a * a << 11), 0);
592  lut_nmsedec_ref0[i] = FFMAX(((i * i - (i << NMSEDEC_BITS) + (1 << 2 * NMSEDEC_FRACBITS) + (1 << (NMSEDEC_FRACBITS - 1))) & mask)
593  << 1, 0);
594  }
596 }
597 
598 /* tier-1 routines */
599 static int getnmsedec_sig(int x, int bpno)
600 {
601  if (bpno > NMSEDEC_FRACBITS)
602  return lut_nmsedec_sig[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
603  return lut_nmsedec_sig0[x & ((1 << NMSEDEC_BITS) - 1)];
604 }
605 
606 static int getnmsedec_ref(int x, int bpno)
607 {
608  if (bpno > NMSEDEC_FRACBITS)
609  return lut_nmsedec_ref[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
610  return lut_nmsedec_ref0[x & ((1 << NMSEDEC_BITS) - 1)];
611 }
612 
613 static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
614 {
615  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
616  for (y0 = 0; y0 < height; y0 += 4)
617  for (x = 0; x < width; x++)
618  for (y = y0; y < height && y < y0+4; y++){
619  if (!(t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG) && (t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB)){
620  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno),
621  bit = t1->data[(y) * t1->stride + x] & mask ? 1 : 0;
622  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, bit);
623  if (bit){
624  int xorbit;
625  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
626  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
627  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
628  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
629  }
630  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_VIS;
631  }
632  }
633 }
634 
635 static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
636 {
637  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
638  for (y0 = 0; y0 < height; y0 += 4)
639  for (x = 0; x < width; x++)
640  for (y = y0; y < height && y < y0+4; y++)
641  if ((t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG){
642  int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y+1) * t1->stride + x+1]);
643  *nmsedec += getnmsedec_ref(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
644  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
645  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_REF;
646  }
647 }
648 
649 static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
650 {
651  int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
652  for (y0 = 0; y0 < height; y0 += 4)
653  for (x = 0; x < width; x++){
654  if (y0 + 3 < height && !(
655  (t1->flags[(y0+1) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
656  (t1->flags[(y0+2) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
657  (t1->flags[(y0+3) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
658  (t1->flags[(y0+4) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG))))
659  {
660  // aggregation mode
661  int rlen;
662  for (rlen = 0; rlen < 4; rlen++)
663  if (t1->data[(y0+rlen) * t1->stride + x] & mask)
664  break;
665  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL, rlen != 4);
666  if (rlen == 4)
667  continue;
668  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen >> 1);
669  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen & 1);
670  for (y = y0 + rlen; y < y0 + 4; y++){
671  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
672  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
673  if (y > y0 + rlen)
674  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
675  if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
676  int xorbit;
677  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
678  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
679  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
680  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
681  }
682  }
683  t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
684  }
685  } else{
686  for (y = y0; y < y0 + 4 && y < height; y++){
687  if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
688  int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
689  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
690  if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
691  int xorbit;
692  int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
693  *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
694  ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
695  ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
696  }
697  }
698  t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
699  }
700  }
701  }
702 }
703 
705  int width, int height, int bandpos, int lev)
706 {
707  int pass_t = 2, passno, x, y, max=0, nmsedec, bpno;
708  int64_t wmsedec = 0;
709 
710  memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
711 
712  for (y = 0; y < height; y++){
713  for (x = 0; x < width; x++){
714  if (t1->data[(y) * t1->stride + x] < 0){
715  t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_SGN;
716  t1->data[(y) * t1->stride + x] = -t1->data[(y) * t1->stride + x];
717  }
718  max = FFMAX(max, t1->data[(y) * t1->stride + x]);
719  }
720  }
721 
722  if (max == 0){
723  cblk->nonzerobits = 0;
724  bpno = 0;
725  } else{
726  cblk->nonzerobits = av_log2(max) + 1 - NMSEDEC_FRACBITS;
727  bpno = cblk->nonzerobits - 1;
728  }
729 
730  cblk->data[0] = 0;
731  ff_mqc_initenc(&t1->mqc, cblk->data + 1);
732 
733  for (passno = 0; bpno >= 0; passno++){
734  nmsedec=0;
735 
736  switch(pass_t){
737  case 0: encode_sigpass(t1, width, height, bandpos, &nmsedec, bpno);
738  break;
739  case 1: encode_refpass(t1, width, height, &nmsedec, bpno);
740  break;
741  case 2: encode_clnpass(t1, width, height, bandpos, &nmsedec, bpno);
742  break;
743  }
744 
745  cblk->passes[passno].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno].flushed, &cblk->passes[passno].flushed_len);
746  cblk->passes[passno].rate -= cblk->passes[passno].flushed_len;
747 
748  wmsedec += (int64_t)nmsedec << (2*bpno);
749  cblk->passes[passno].disto = wmsedec;
750 
751  if (++pass_t == 3){
752  pass_t = 0;
753  bpno--;
754  }
755  }
756  cblk->npasses = passno;
757  cblk->ninclpasses = passno;
758 
759  if (passno) {
760  cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);
761  cblk->passes[passno-1].rate -= cblk->passes[passno-1].flushed_len;
762  }
763 }
764 
765 /* tier-2 routines: */
766 
768 {
769  if (n == 1)
770  put_num(s, 0, 1);
771  else if (n == 2)
772  put_num(s, 2, 2);
773  else if (n <= 5)
774  put_num(s, 0xc | (n-3), 4);
775  else if (n <= 36)
776  put_num(s, 0x1e0 | (n-6), 9);
777  else
778  put_num(s, 0xff80 | (n-37), 16);
779 }
780 
781 
782 static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno,
783  int precno, uint8_t *expn, int numgbits, int packetno,
784  int nlayers)
785 {
786  int bandno, empty = 1;
787  int i;
788  // init bitstream
789  *s->buf = 0;
790  s->bit_index = 0;
791 
792  if (s->sop) {
793  bytestream_put_be16(&s->buf, JPEG2000_SOP);
794  bytestream_put_be16(&s->buf, 4);
795  bytestream_put_be16(&s->buf, packetno);
796  }
797  // header
798 
799  if (!layno) {
800  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
801  Jpeg2000Band *band = rlevel->band + bandno;
802  if (band->coord[0][0] < band->coord[0][1]
803  && band->coord[1][0] < band->coord[1][1]) {
804  Jpeg2000Prec *prec = band->prec + precno;
805  int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
806  int pos;
809  for (pos = 0; pos < nb_cblks; pos++) {
810  Jpeg2000Cblk *cblk = &prec->cblk[pos];
811  prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - cblk->nonzerobits;
812  cblk->incl = 0;
813  cblk->lblock = 3;
814  tag_tree_update(prec->zerobits + pos);
815  for (i = 0; i < nlayers; i++) {
816  if (cblk->layers[i].npasses > 0) {
817  prec->cblkincl[pos].val = i;
818  break;
819  }
820  }
821  if (i == nlayers)
822  prec->cblkincl[pos].val = i;
823  tag_tree_update(prec->cblkincl + pos);
824  }
825  }
826  }
827  }
828 
829  // is the packet empty?
830  for (bandno = 0; bandno < rlevel->nbands; bandno++){
831  Jpeg2000Band *band = rlevel->band + bandno;
832  if (band->coord[0][0] < band->coord[0][1]
833  && band->coord[1][0] < band->coord[1][1]) {
834  Jpeg2000Prec *prec = band->prec + precno;
835  int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
836  int pos;
837  for (pos = 0; pos < nb_cblks; pos++) {
838  Jpeg2000Cblk *cblk = &prec->cblk[pos];
839  if (cblk->layers[layno].npasses) {
840  empty = 0;
841  break;
842  }
843  }
844  if (!empty)
845  break;
846  }
847  }
848 
849  put_bits(s, !empty, 1);
850  if (empty){
851  j2k_flush(s);
852  if (s->eph)
853  bytestream_put_be16(&s->buf, JPEG2000_EPH);
854  return 0;
855  }
856 
857  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
858  Jpeg2000Band *band = rlevel->band + bandno;
859  Jpeg2000Prec *prec = band->prec + precno;
860  int yi, xi, pos;
861  int cblknw = prec->nb_codeblocks_width;
862 
863  if (band->coord[0][0] == band->coord[0][1]
864  || band->coord[1][0] == band->coord[1][1])
865  continue;
866 
867  for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++) {
868  for (xi = 0; xi < cblknw; xi++, pos++){
869  int llen = 0, length;
870  Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
871 
872  if (s->buf_end - s->buf < 20) // approximately
873  return -1;
874 
875  // inclusion information
876  if (!cblk->incl)
877  tag_tree_code(s, prec->cblkincl + pos, layno + 1);
878  else {
879  put_bits(s, cblk->layers[layno].npasses > 0, 1);
880  }
881 
882  if (!cblk->layers[layno].npasses)
883  continue;
884 
885  // zerobits information
886  if (!cblk->incl) {
887  tag_tree_code(s, prec->zerobits + pos, 100);
888  cblk->incl = 1;
889  }
890 
891  // number of passes
892  putnumpasses(s, cblk->layers[layno].npasses);
893 
894  length = cblk->layers[layno].data_len;
895  if (layno == nlayers - 1 && cblk->layers[layno].cum_passes){
896  length += cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len;
897  }
898  if (cblk->lblock + av_log2(cblk->layers[layno].npasses) < av_log2(length) + 1) {
899  llen = av_log2(length) + 1 - cblk->lblock - av_log2(cblk->layers[layno].npasses);
900  }
901 
902  // length of code block
903  cblk->lblock += llen;
904  put_bits(s, 1, llen);
905  put_bits(s, 0, 1);
906  put_num(s, length, cblk->lblock + av_log2(cblk->layers[layno].npasses));
907  }
908  }
909  }
910  j2k_flush(s);
911  if (s->eph) {
912  bytestream_put_be16(&s->buf, JPEG2000_EPH);
913  }
914 
915  for (bandno = 0; bandno < rlevel->nbands; bandno++) {
916  Jpeg2000Band *band = rlevel->band + bandno;
917  Jpeg2000Prec *prec = band->prec + precno;
918  int yi, cblknw = prec->nb_codeblocks_width;
919  for (yi =0; yi < prec->nb_codeblocks_height; yi++) {
920  int xi;
921  for (xi = 0; xi < cblknw; xi++){
922  Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
923  if (cblk->layers[layno].npasses) {
924  if (s->buf_end - s->buf < cblk->layers[layno].data_len + 2)
925  return -1;
926  bytestream_put_buffer(&s->buf, cblk->layers[layno].data_start + 1, cblk->layers[layno].data_len);
927  if (layno == nlayers - 1 && cblk->layers[layno].cum_passes) {
928  bytestream_put_buffer(&s->buf, cblk->passes[cblk->layers[layno].cum_passes-1].flushed,
929  cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len);
930  }
931  }
932  }
933  }
934  }
935  return 0;
936 }
937 
938 static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
939 {
940  int compno, reslevelno, layno, ret;
941  Jpeg2000CodingStyle *codsty = &s->codsty;
942  Jpeg2000QuantStyle *qntsty = &s->qntsty;
943  int packetno = 0;
944  int step_x, step_y;
945  int x, y;
946  int tile_coord[2][2];
947  int col = tileno % s->numXtiles;
948  int row = tileno / s->numXtiles;
949 
950  tile_coord[0][0] = col * s->tile_width;
951  tile_coord[0][1] = FFMIN(tile_coord[0][0] + s->tile_width, s->width);
952  tile_coord[1][0] = row * s->tile_height;
953  tile_coord[1][1] = FFMIN(tile_coord[1][0] + s->tile_height, s->height);
954 
955  av_log(s->avctx, AV_LOG_DEBUG, "tier2\n");
956  // lay-rlevel-comp-pos progression
957  switch (s->prog) {
958  case JPEG2000_PGOD_LRCP:
959  for (layno = 0; layno < nlayers; layno++) {
960  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
961  for (compno = 0; compno < s->ncomponents; compno++){
962  int precno;
963  Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
964  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
965  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
966  qntsty->nguardbits, packetno++, nlayers)) < 0)
967  return ret;
968  }
969  }
970  }
971  }
972  break;
973  case JPEG2000_PGOD_RLCP:
974  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
975  for (layno = 0; layno < nlayers; layno++) {
976  for (compno = 0; compno < s->ncomponents; compno++){
977  int precno;
978  Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
979  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
980  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
981  qntsty->nguardbits, packetno++, nlayers)) < 0)
982  return ret;
983  }
984  }
985  }
986  }
987  break;
988  case JPEG2000_PGOD_RPCL:
989  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
990  int precno;
991  step_x = 30;
992  step_y = 30;
993  for (compno = 0; compno < s->ncomponents; compno++) {
994  Jpeg2000Component *comp = tile->comp + compno;
995  if (reslevelno < codsty->nreslevels) {
996  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
997  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
998  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
999  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1000  }
1001  }
1002 
1003  step_x = 1<<step_x;
1004  step_y = 1<<step_y;
1005  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1006  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1007  for (compno = 0; compno < s->ncomponents; compno++) {
1008  Jpeg2000Component *comp = tile->comp + compno;
1009  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1010  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1011  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1012  unsigned prcx, prcy;
1013  int trx0, try0;
1014 
1015  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1016  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1017 
1018  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1019  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1020  continue;
1021 
1022  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1023  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1024  continue;
1025 
1026  // check if a precinct exists
1027  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1028  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1029  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1030  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1031  precno = prcx + reslevel->num_precincts_x * prcy;
1032 
1033  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1034  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1035  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1036  continue;
1037  }
1038  for (layno = 0; layno < nlayers; layno++) {
1039  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1040  qntsty->nguardbits, packetno++, nlayers)) < 0)
1041  return ret;
1042  }
1043  }
1044  }
1045  }
1046  }
1047  break;
1048  case JPEG2000_PGOD_PCRL:
1049  step_x = 32;
1050  step_y = 32;
1051  for (compno = 0; compno < s->ncomponents; compno++) {
1052  Jpeg2000Component *comp = tile->comp + compno;
1053 
1054  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1055  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1056  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1057  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1058  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1059  }
1060  }
1061  if (step_x >= 31 || step_y >= 31){
1062  avpriv_request_sample(s->avctx, "PCRL with large step");
1063  return AVERROR_PATCHWELCOME;
1064  }
1065  step_x = 1<<step_x;
1066  step_y = 1<<step_y;
1067 
1068  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1069  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1070  for (compno = 0; compno < s->ncomponents; compno++) {
1071  Jpeg2000Component *comp = tile->comp + compno;
1072  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1073 
1074  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1075  unsigned prcx, prcy;
1076  int precno;
1077  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1078  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1079  int trx0, try0;
1080 
1081  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1082  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1083 
1084  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1085  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1086  continue;
1087 
1088  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1089  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1090  continue;
1091 
1092  // check if a precinct exists
1093  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1094  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1095  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1096  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1097 
1098  precno = prcx + reslevel->num_precincts_x * prcy;
1099 
1100  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1101  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1102  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1103  continue;
1104  }
1105  for (layno = 0; layno < nlayers; layno++) {
1106  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1107  qntsty->nguardbits, packetno++, nlayers)) < 0)
1108  return ret;
1109  }
1110  }
1111  }
1112  }
1113  }
1114  break;
1115  case JPEG2000_PGOD_CPRL:
1116  for (compno = 0; compno < s->ncomponents; compno++) {
1117  Jpeg2000Component *comp = tile->comp + compno;
1118  int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1119  step_x = 32;
1120  step_y = 32;
1121 
1122  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1123  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1124  Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1125  step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1126  step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1127  }
1128  if (step_x >= 31 || step_y >= 31){
1129  avpriv_request_sample(s->avctx, "CPRL with large step");
1130  return AVERROR_PATCHWELCOME;
1131  }
1132  step_x = 1<<step_x;
1133  step_y = 1<<step_y;
1134 
1135  for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1136  for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1137  for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1138  unsigned prcx, prcy;
1139  int precno;
1140  int trx0, try0;
1141  uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1142  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1143 
1144  trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1145  try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1146 
1147  if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1148  (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1149  continue;
1150 
1151  if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1152  (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1153  continue;
1154 
1155  // check if a precinct exists
1156  prcx = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1157  prcy = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1158  prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1159  prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1160 
1161  precno = prcx + reslevel->num_precincts_x * prcy;
1162 
1163  if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1164  av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1165  prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1166  continue;
1167  }
1168  for (layno = 0; layno < nlayers; layno++) {
1169  if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1170  qntsty->nguardbits, packetno++, nlayers)) < 0)
1171  return ret;
1172  }
1173  }
1174  }
1175  }
1176  }
1177 
1178  }
1179 
1180  av_log(s->avctx, AV_LOG_DEBUG, "after tier2\n");
1181  return 0;
1182 }
1183 
1184 static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile* tile, int final)
1185 {
1186  int compno, resno, bandno, precno, cblkno;
1187  int passno;
1188 
1189  for (compno = 0; compno < s->ncomponents; compno++) {
1190  Jpeg2000Component *comp = &tile->comp[compno];
1191 
1192  for (resno = 0; resno < s->codsty.nreslevels; resno++) {
1193  Jpeg2000ResLevel *reslevel = comp->reslevel + resno;
1194 
1195  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1196  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1197  Jpeg2000Band *band = reslevel->band + bandno;
1198  Jpeg2000Prec *prec = band->prec + precno;
1199 
1200  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1201  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1202  Jpeg2000Layer *layer = &cblk->layers[layno];
1203  int n;
1204 
1205  if (layno == 0) {
1206  cblk->ninclpasses = 0;
1207  }
1208 
1209  n = cblk->ninclpasses;
1210 
1211  if (thresh < 0) {
1212  n = cblk->npasses;
1213  } else {
1214  for (passno = cblk->ninclpasses; passno < cblk->npasses; passno++) {
1215  int32_t dr;
1216  double dd;
1217  Jpeg2000Pass *pass = &cblk->passes[passno];
1218 
1219  if (n == 0) {
1220  dr = pass->rate;
1221  dd = pass->disto;
1222  } else {
1223  dr = pass->rate - cblk->passes[n - 1].rate;
1224  dd = pass->disto - cblk->passes[n-1].disto;
1225  }
1226 
1227  if (!dr) {
1228  if (dd != 0.0) {
1229  n = passno + 1;
1230  }
1231  continue;
1232  }
1233 
1234  if (thresh - (dd / dr) < DBL_EPSILON)
1235  n = passno + 1;
1236  }
1237  }
1238  layer->npasses = n - cblk->ninclpasses;
1239  layer->cum_passes = n;
1240 
1241  if (layer->npasses == 0) {
1242  layer->disto = 0;
1243  layer->data_len = 0;
1244  continue;
1245  }
1246 
1247  if (cblk->ninclpasses == 0) {
1248  layer->data_len = cblk->passes[n - 1].rate;
1249  layer->data_start = cblk->data;
1250  layer->disto = cblk->passes[n - 1].disto;
1251  } else {
1252  layer->data_len = cblk->passes[n - 1].rate - cblk->passes[cblk->ninclpasses - 1].rate;
1253  layer->data_start = cblk->data + cblk->passes[cblk->ninclpasses - 1].rate;
1254  layer->disto = cblk->passes[n - 1].disto -
1255  cblk->passes[cblk->ninclpasses - 1].disto;
1256  }
1257  if (final) {
1258  cblk->ninclpasses = n;
1259  }
1260  }
1261  }
1262  }
1263  }
1264  }
1265 }
1266 
1268 {
1269  int precno, compno, reslevelno, bandno, cblkno, lev, passno, layno;
1270  int i;
1271  double min = DBL_MAX;
1272  double max = 0;
1273  double thresh;
1274 
1275  Jpeg2000CodingStyle *codsty = &s->codsty;
1276 
1277  for (compno = 0; compno < s->ncomponents; compno++){
1278  Jpeg2000Component *comp = tile->comp + compno;
1279 
1280  for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1281  Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1282 
1283  for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1284  for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1285  Jpeg2000Band *band = reslevel->band + bandno;
1286  Jpeg2000Prec *prec = band->prec + precno;
1287 
1288  for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1289  Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1290  for (passno = 0; passno < cblk->npasses; passno++) {
1291  Jpeg2000Pass *pass = &cblk->passes[passno];
1292  int dr;
1293  double dd, drslope;
1294 
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 
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;
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 
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 
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 
1529  const AVFrame *pict, int *got_packet)
1530 {
1531  int tileno, ret;
1533  uint8_t *chunkstart, *jp2cstart, *jp2hstart;
1534 
1535  if ((ret = ff_alloc_packet(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE)) < 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  const 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  *got_packet = 1;
1662 
1663  return 0;
1664 }
1665 
1667 {
1668  int i;
1669  char *token;
1670  char *saveptr = NULL;
1671  int rate;
1672  int nlayers = 0;
1673  if (!s->lr_str) {
1674  s->nlayers = 1;
1675  s->layer_rates[0] = 0;
1676  s->compression_rate_enc = 0;
1677  return 0;
1678  }
1679 
1680  token = av_strtok(s->lr_str, ",", &saveptr);
1681  if (token && (rate = strtol(token, NULL, 10))) {
1682  s->layer_rates[0] = rate <= 1 ? 0:rate;
1683  nlayers++;
1684  } else {
1685  return AVERROR_INVALIDDATA;
1686  }
1687 
1688  while (1) {
1689  token = av_strtok(NULL, ",", &saveptr);
1690  if (!token)
1691  break;
1692  if (rate = strtol(token, NULL, 10)) {
1693  if (nlayers >= 100) {
1694  return AVERROR_INVALIDDATA;
1695  }
1696  s->layer_rates[nlayers] = rate <= 1 ? 0:rate;
1697  nlayers++;
1698  } else {
1699  return AVERROR_INVALIDDATA;
1700  }
1701  }
1702 
1703  for (i = 1; i < nlayers; i++) {
1704  if (s->layer_rates[i] >= s->layer_rates[i-1]) {
1705  return AVERROR_INVALIDDATA;
1706  }
1707  }
1708  s->nlayers = nlayers;
1709  s->compression_rate_enc = 1;
1710  return 0;
1711 }
1712 
1714 {
1715  static AVOnce init_static_once = AV_ONCE_INIT;
1716  int i, ret;
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 (avctx->pix_fmt == AV_PIX_FMT_PAL8 && (s->pred != FF_DWT97_INT || s->format != CODEC_JP2)) {
1731  av_log(s->avctx, AV_LOG_WARNING, "Forcing lossless jp2 for pal8\n");
1732  s->pred = FF_DWT97_INT;
1733  s->format = CODEC_JP2;
1734  }
1735 
1736  // defaults:
1737  // TODO: implement setting non-standard precinct size
1738  memset(codsty->log2_prec_widths , 15, sizeof(codsty->log2_prec_widths ));
1739  memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights));
1740  codsty->nreslevels2decode=
1741  codsty->nreslevels = 7;
1742  codsty->nlayers = s->nlayers;
1743  codsty->log2_cblk_width = 4;
1744  codsty->log2_cblk_height = 4;
1745  codsty->transform = s->pred ? FF_DWT53 : FF_DWT97_INT;
1746 
1747  qntsty->nguardbits = 1;
1748 
1749  if ((s->tile_width & (s->tile_width -1)) ||
1750  (s->tile_height & (s->tile_height-1))) {
1751  av_log(avctx, AV_LOG_WARNING, "Tile dimension not a power of 2\n");
1752  }
1753 
1754  if (codsty->transform == FF_DWT53)
1755  qntsty->quantsty = JPEG2000_QSTY_NONE;
1756  else
1757  qntsty->quantsty = JPEG2000_QSTY_SE;
1758 
1759  s->width = avctx->width;
1760  s->height = avctx->height;
1761 
1762  for (i = 0; i < 3; i++) {
1763  if (avctx->pix_fmt == AV_PIX_FMT_GRAY16 || avctx->pix_fmt == AV_PIX_FMT_RGB48)
1764  s->cbps[i] = 16;
1765  else
1766  s->cbps[i] = 8;
1767  }
1768 
1769  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_RGB48){
1770  s->ncomponents = 3;
1771  } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16){
1772  s->ncomponents = 1;
1773  } else{ // planar YUV
1774  s->planar = 1;
1775  s->ncomponents = 3;
1777  s->chroma_shift, s->chroma_shift + 1);
1778  if (ret)
1779  return ret;
1780  }
1781 
1782  ff_thread_once(&init_static_once, init_luts);
1783 
1785  if ((ret=init_tiles(s)) < 0)
1786  return ret;
1787 
1788  av_log(s->avctx, AV_LOG_DEBUG, "after init\n");
1789 
1790  return 0;
1791 }
1792 
1793 static int j2kenc_destroy(AVCodecContext *avctx)
1794 {
1796 
1797  cleanup(s);
1798  return 0;
1799 }
1800 
1801 // taken from the libopenjpeg wraper so it matches
1802 
1803 #define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)
1804 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1805 static const AVOption options[] = {
1806  { "format", "Codec Format", OFFSET(format), AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2, VE, "format" },
1807  { "j2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K }, 0, 0, VE, "format" },
1808  { "jp2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2 }, 0, 0, VE, "format" },
1809  { "tile_width", "Tile Width", OFFSET(tile_width), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1810  { "tile_height", "Tile Height", OFFSET(tile_height), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1811  { "pred", "DWT Type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "pred" },
1812  { "dwt97int", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1813  { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1814  { "sop", "SOP marker", OFFSET(sop), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1815  { "eph", "EPH marker", OFFSET(eph), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1816  { "prog", "Progression Order", OFFSET(prog), AV_OPT_TYPE_INT, { .i64 = 0 }, JPEG2000_PGOD_LRCP, JPEG2000_PGOD_CPRL, VE, "prog" },
1817  { "lrcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_LRCP }, 0, 0, VE, "prog" },
1818  { "rlcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RLCP }, 0, 0, VE, "prog" },
1819  { "rpcl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RPCL }, 0, 0, VE, "prog" },
1820  { "pcrl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_PCRL }, 0, 0, VE, "prog" },
1821  { "cprl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_CPRL }, 0, 0, VE, "prog" },
1822  { "layer_rates", "Layer Rates", OFFSET(lr_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1823  { NULL }
1824 };
1825 
1826 static const AVClass j2k_class = {
1827  .class_name = "jpeg 2000 encoder",
1828  .item_name = av_default_item_name,
1829  .option = options,
1830  .version = LIBAVUTIL_VERSION_INT,
1831 };
1832 
1834  .p.name = "jpeg2000",
1835  CODEC_LONG_NAME("JPEG 2000"),
1836  .p.type = AVMEDIA_TYPE_VIDEO,
1837  .p.id = AV_CODEC_ID_JPEG2000,
1838  .p.capabilities = AV_CODEC_CAP_DR1,
1839  .priv_data_size = sizeof(Jpeg2000EncoderContext),
1840  .init = j2kenc_init,
1842  .close = j2kenc_destroy,
1843  .p.pix_fmts = (const enum AVPixelFormat[]) {
1850  },
1851  .p.priv_class = &j2k_class,
1852  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1853 };
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:42
makelayer
static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile *tile, int final)
Definition: j2kenc.c:1184
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:156
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:1805
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:80
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:171
Jpeg2000EncoderContext::bit_index
int bit_index
Definition: j2kenc.c:127
j2kenc_init
static av_cold int j2kenc_init(AVCodecContext *avctx)
Definition: j2kenc.c:1713
JPEG2000_QCD
@ JPEG2000_QCD
Definition: jpeg2000.h:46
Jpeg2000Prec::nb_codeblocks_height
int nb_codeblocks_height
Definition: jpeg2000.h:196
Jpeg2000Band::i_stepsize
int i_stepsize
Definition: jpeg2000.h:207
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:172
compute_rates
static void compute_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:424
AVPacket::data
uint8_t * data
Definition: packet.h:374
Jpeg2000Layer::data_len
int data_len
Definition: jpeg2000.h:169
j2k_class
static const AVClass j2k_class
Definition: j2kenc.c:1826
Jpeg2000Prec::zerobits
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:197
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:236
FFCodec
Definition: codec_internal.h:119
version.h
Jpeg2000Prec
Definition: jpeg2000.h:194
float.h
JPEG2000_SOT
@ JPEG2000_SOT
Definition: jpeg2000.h:54
Jpeg2000TgtNode::parent
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:134
Jpeg2000Band
Definition: jpeg2000.h:204
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:1528
max
#define max(a, b)
Definition: cuda_runtime.h:33
Jpeg2000Pass::rate
uint16_t rate
Definition: jpeg2000.h:161
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:264
Jpeg2000Pass::flushed_len
int flushed_len
Definition: jpeg2000.h:164
j2kenc_destroy
static int j2kenc_destroy(AVCodecContext *avctx)
Definition: j2kenc.c:1793
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:179
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:123
Jpeg2000CodingStyle::log2_cblk_width
uint8_t log2_cblk_width
Definition: jpeg2000.h:140
Jpeg2000EncoderContext::buf_end
uint8_t * buf_end
Definition: j2kenc.c:126
Jpeg2000Cblk::passes
Jpeg2000Pass * passes
Definition: jpeg2000.h:189
Jpeg2000CodingStyle::log2_prec_heights
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:149
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:2886
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
MQC_CX_UNI
#define MQC_CX_UNI
Definition: mqc.h:33
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:443
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:328
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:307
Jpeg2000T1Context
Definition: jpeg2000.h:123
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:184
pkt
AVPacket * pkt
Definition: movenc.c:59
Jpeg2000ResLevel
Definition: jpeg2000.h:212
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:162
Jpeg2000QuantStyle::nguardbits
uint8_t nguardbits
Definition: jpeg2000.h:157
init_luts
static void init_luts(void)
Definition: j2kenc.c:580
Jpeg2000Tile::comp
Jpeg2000Component * comp
Definition: j2kenc.c:107
width
#define width
intreadwrite.h
Jpeg2000CodingStyle::transform
uint8_t transform
Definition: jpeg2000.h:142
s
#define s(width, name)
Definition: cbs_vp9.c:256
Jpeg2000Cblk::layers
Jpeg2000Layer * layers
Definition: jpeg2000.h:190
lut_nmsedec_sig0
static int lut_nmsedec_sig0[1<< NMSEDEC_BITS]
Definition: j2kenc.c:92
Jpeg2000ResLevel::band
Jpeg2000Band * band
Definition: jpeg2000.h:217
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:1350
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
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
JPEG2000_PGOD_RPCL
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:119
Jpeg2000Cblk::data
uint8_t * data
Definition: jpeg2000.h:184
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:205
Jpeg2000EncoderContext::planar
uint8_t planar
Definition: j2kenc.c:119
xi
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:402
encode_sigpass
static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
Definition: j2kenc.c:613
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:782
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:121
JPEG2000_COM
@ JPEG2000_COM
Definition: jpeg2000.h:53
pass
#define pass
Definition: fft_template.c:608
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
Jpeg2000Cblk::lblock
uint8_t lblock
Definition: jpeg2000.h:183
Jpeg2000CodingStyle::log2_prec_widths
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:148
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
makelayers
static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
Definition: j2kenc.c:1267
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:450
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:209
JPEG2000_T1_VIS
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:95
Jpeg2000Layer::npasses
int npasses
Definition: jpeg2000.h:170
double
double
Definition: af_crystalizer.c:132
Jpeg2000ResLevel::num_precincts_y
int num_precincts_y
Definition: jpeg2000.h:215
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:206
AVOnce
#define AVOnce
Definition: thread.h:181
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
truncpasses
static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
Definition: j2kenc.c:1368
Jpeg2000EncoderContext::format
int format
Definition: j2kenc.c:138
getnmsedec_sig
static int getnmsedec_sig(int x, int bpno)
Definition: j2kenc.c:599
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:195
JPEG2000_T1_SGN
#define JPEG2000_T1_SGN
Definition: jpeg2000.h:99
Jpeg2000ResLevel::log2_prec_height
uint8_t log2_prec_height
Definition: jpeg2000.h:216
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:606
Jpeg2000Component
Definition: jpeg2000.h:220
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:198
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
encode_clnpass
static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
Definition: j2kenc.c:649
Jpeg2000EncoderContext::picture
const AVFrame * picture
Definition: j2kenc.c:114
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
encode_tile
static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
Definition: j2kenc.c:1402
Jpeg2000ResLevel::nbands
uint8_t nbands
Definition: jpeg2000.h:213
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:445
size
int size
Definition: twinvq_data.h:10344
Jpeg2000Cblk
Definition: jpeg2000.h:175
COPY_FRAME
#define COPY_FRAME(D, PIXEL)
Definition: j2kenc.c:506
Jpeg2000Cblk::ninclpasses
uint8_t ninclpasses
Definition: jpeg2000.h:177
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:273
JPEG2000_PGOD_LRCP
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:117
Jpeg2000TgtNode
Definition: jpeg2000.h:130
OFFSET
#define OFFSET(x)
Definition: j2kenc.c:1803
Jpeg2000CodingStyle::nlayers
uint8_t nlayers
Definition: jpeg2000.h:144
reinit
static void reinit(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1513
Jpeg2000CodingStyle::nreslevels
int nreslevels
Definition: jpeg2000.h:138
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:132
Jpeg2000Pass
Definition: jpeg2000.h:160
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:141
put_sot
static uint8_t * put_sot(Jpeg2000EncoderContext *s, int tileno)
Definition: j2kenc.c:405
JPEG2000_PGOD_RLCP
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:118
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
parse_layer_rates
static int parse_layer_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1666
Jpeg2000ResLevel::num_precincts_x
int num_precincts_x
Definition: jpeg2000.h:215
JPEG2000_T1_REF
#define JPEG2000_T1_REF
Definition: jpeg2000.h:97
cleanup
static void cleanup(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1493
Jpeg2000QuantStyle::expn
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:154
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:167
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:704
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:206
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_jpeg2000_getsigctxno
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:255
encode_packets
static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
Definition: j2kenc.c:938
WMSEDEC_SHIFT
#define WMSEDEC_SHIFT
must be >= 13
Definition: j2kenc.c:83
lev
static LevelCodes lev[4+3+3]
Definition: clearvideo.c:79
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
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:155
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:1833
ret
ret
Definition: filter_design.txt:187
put_qcd
static int put_qcd(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:360
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:635
Jpeg2000Layer::data_start
uint8_t * data_start
Definition: jpeg2000.h:168
Jpeg2000Pass::flushed
uint8_t flushed[4]
Definition: jpeg2000.h:163
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
U
#define U(x)
Definition: vpx_arith.h:37
MQC_CX_RL
#define MQC_CX_RL
Definition: mqc.h:34
Jpeg2000Component::coord
int coord[2][2]
Definition: jpeg2000.h:225
AVCodecContext
main external API structure.
Definition: avcodec.h:398
FF_DWT53
@ FF_DWT53
Definition: jpeg2000dwt.h:38
ff_jpeg2000_ceildivpow2
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:231
put_siz
static int put_siz(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:299
CODEC_JP2
#define CODEC_JP2
Definition: j2kenc.c:86
Jpeg2000ResLevel::log2_prec_width
uint8_t log2_prec_width
Definition: jpeg2000.h:216
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:1804
put_com
static int put_com(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:386
JPEG2000_PGOD_PCRL
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:120
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:288
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:767
Jpeg2000Cblk::npasses
uint8_t npasses
Definition: jpeg2000.h:176
Jpeg2000CodingStyle::nreslevels2decode
int nreslevels2decode
Definition: jpeg2000.h:139
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:571
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
Jpeg2000TgtNode::val
uint8_t val
Definition: jpeg2000.h:131
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:1523
Jpeg2000TgtNode::vis
uint8_t vis
Definition: jpeg2000.h:133
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
Jpeg2000CodingStyle
Definition: jpeg2000.h:137
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
Jpeg2000QuantStyle
Definition: jpeg2000.h:153
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
Jpeg2000Cblk::nonzerobits
uint8_t nonzerobits
Definition: jpeg2000.h:178
Jpeg2000Prec::cblk
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:199
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:454
init_quantization
static void init_quantization(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:550
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