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],
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 {
105  double *layer_rates;
106 } Jpeg2000Tile;
107 
108 typedef struct {
109  AVClass *class;
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];
118  int tile_width, tile_height; ///< tile size
119  int numXtiles, numYtiles;
120 
125 
126  int64_t lambda;
127 
130 
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;
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 */
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 */
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 
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 
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 
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 
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 
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  */
454 {
455  int tileno, tilex, tiley, compno;
456  Jpeg2000CodingStyle *codsty = &s->codsty;
457  Jpeg2000QuantStyle *qntsty = &s->qntsty;
458 
461 
462  s->tile = av_malloc_array(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 
547 COPY_FRAME(16, uint16_t)
548 
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 
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;
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 
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 
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  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1499  for (compno = 0; compno < s->ncomponents; compno++){
1500  Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1501  ff_jpeg2000_cleanup(comp, codsty);
1502  }
1503  av_freep(&s->tile[tileno].comp);
1504  av_freep(&s->tile[tileno].layer_rates);
1505  }
1506  av_freep(&s->tile);
1507 }
1508 
1510 {
1511  int tileno, compno;
1512  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1513  Jpeg2000Tile *tile = s->tile + tileno;
1514  for (compno = 0; compno < s->ncomponents; compno++)
1515  ff_jpeg2000_reinit(tile->comp + compno, &s->codsty);
1516  }
1517 }
1518 
1519 static void update_size(uint8_t *size, const uint8_t *end)
1520 {
1521  AV_WB32(size, end-size);
1522 }
1523 
1525  const AVFrame *pict, int *got_packet)
1526 {
1527  int tileno, ret;
1528  Jpeg2000EncoderContext *s = avctx->priv_data;
1529  uint8_t *chunkstart, *jp2cstart, *jp2hstart;
1530 
1531  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
1532  return ret;
1533 
1534  // init:
1535  s->buf = s->buf_start = pkt->data;
1536  s->buf_end = pkt->data + pkt->size;
1537 
1538  s->picture = pict;
1539 
1540  s->lambda = s->picture->quality * LAMBDA_SCALE;
1541 
1542  if (avctx->pix_fmt == AV_PIX_FMT_BGR48 || avctx->pix_fmt == AV_PIX_FMT_GRAY16)
1543  copy_frame_16(s);
1544  else
1545  copy_frame_8(s);
1546 
1547  reinit(s);
1548 
1549  if (s->format == CODEC_JP2) {
1550  av_assert0(s->buf == pkt->data);
1551 
1552  bytestream_put_be32(&s->buf, 0x0000000C);
1553  bytestream_put_be32(&s->buf, 0x6A502020);
1554  bytestream_put_be32(&s->buf, 0x0D0A870A);
1555 
1556  chunkstart = s->buf;
1557  bytestream_put_be32(&s->buf, 0);
1558  bytestream_put_buffer(&s->buf, "ftyp", 4);
1559  bytestream_put_buffer(&s->buf, "jp2\040\040", 4);
1560  bytestream_put_be32(&s->buf, 0);
1561  bytestream_put_buffer(&s->buf, "jp2\040", 4);
1562  update_size(chunkstart, s->buf);
1563 
1564  jp2hstart = s->buf;
1565  bytestream_put_be32(&s->buf, 0);
1566  bytestream_put_buffer(&s->buf, "jp2h", 4);
1567 
1568  chunkstart = s->buf;
1569  bytestream_put_be32(&s->buf, 0);
1570  bytestream_put_buffer(&s->buf, "ihdr", 4);
1571  bytestream_put_be32(&s->buf, avctx->height);
1572  bytestream_put_be32(&s->buf, avctx->width);
1573  bytestream_put_be16(&s->buf, s->ncomponents);
1574  bytestream_put_byte(&s->buf, s->cbps[0]);
1575  bytestream_put_byte(&s->buf, 7);
1576  bytestream_put_byte(&s->buf, 0);
1577  bytestream_put_byte(&s->buf, 0);
1578  update_size(chunkstart, s->buf);
1579 
1580  chunkstart = s->buf;
1581  bytestream_put_be32(&s->buf, 0);
1582  bytestream_put_buffer(&s->buf, "colr", 4);
1583  bytestream_put_byte(&s->buf, 1);
1584  bytestream_put_byte(&s->buf, 0);
1585  bytestream_put_byte(&s->buf, 0);
1586  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1587  bytestream_put_be32(&s->buf, 16);
1588  } else if (s->ncomponents == 1) {
1589  bytestream_put_be32(&s->buf, 17);
1590  } else {
1591  bytestream_put_be32(&s->buf, 18);
1592  }
1593  update_size(chunkstart, s->buf);
1594  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1595  int i;
1596  uint8_t *palette = pict->data[1];
1597  chunkstart = s->buf;
1598  bytestream_put_be32(&s->buf, 0);
1599  bytestream_put_buffer(&s->buf, "pclr", 4);
1600  bytestream_put_be16(&s->buf, AVPALETTE_COUNT);
1601  bytestream_put_byte(&s->buf, 3); // colour channels
1602  bytestream_put_be24(&s->buf, 0x070707); //colour depths
1603  for (i = 0; i < AVPALETTE_COUNT; i++) {
1604  bytestream_put_be24(&s->buf, HAVE_BIGENDIAN ? AV_RB24(palette + 1) : AV_RL24(palette));
1605  palette += 4;
1606  }
1607  update_size(chunkstart, s->buf);
1608  chunkstart = s->buf;
1609  bytestream_put_be32(&s->buf, 0);
1610  bytestream_put_buffer(&s->buf, "cmap", 4);
1611  for (i = 0; i < 3; i++) {
1612  bytestream_put_be16(&s->buf, 0); // component
1613  bytestream_put_byte(&s->buf, 1); // palette mapping
1614  bytestream_put_byte(&s->buf, i); // index
1615  }
1616  update_size(chunkstart, s->buf);
1617  }
1618  update_size(jp2hstart, s->buf);
1619 
1620  jp2cstart = s->buf;
1621  bytestream_put_be32(&s->buf, 0);
1622  bytestream_put_buffer(&s->buf, "jp2c", 4);
1623  }
1624 
1625  if (s->buf_end - s->buf < 2)
1626  return -1;
1627  bytestream_put_be16(&s->buf, JPEG2000_SOC);
1628  if ((ret = put_siz(s)) < 0)
1629  return ret;
1630  if ((ret = put_cod(s)) < 0)
1631  return ret;
1632  if ((ret = put_qcd(s, 0)) < 0)
1633  return ret;
1634  if ((ret = put_com(s, 0)) < 0)
1635  return ret;
1636 
1637  for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1638  uint8_t *psotptr;
1639  if (!(psotptr = put_sot(s, tileno)))
1640  return -1;
1641  if (s->buf_end - s->buf < 2)
1642  return -1;
1643  bytestream_put_be16(&s->buf, JPEG2000_SOD);
1644  if ((ret = encode_tile(s, s->tile + tileno, tileno)) < 0)
1645  return ret;
1646  bytestream_put_be32(&psotptr, s->buf - psotptr + 6);
1647  }
1648  if (s->buf_end - s->buf < 2)
1649  return -1;
1650  bytestream_put_be16(&s->buf, JPEG2000_EOC);
1651 
1652  if (s->format == CODEC_JP2)
1653  update_size(jp2cstart, s->buf);
1654 
1655  av_log(s->avctx, AV_LOG_DEBUG, "end\n");
1656  pkt->size = s->buf - s->buf_start;
1657  pkt->flags |= AV_PKT_FLAG_KEY;
1658  *got_packet = 1;
1659 
1660  return 0;
1661 }
1662 
1664 {
1665  int i;
1666  char *token;
1667  char *saveptr = NULL;
1668  int rate;
1669  int nlayers = 0;
1670  if (!s->lr_str) {
1671  s->nlayers = 1;
1672  s->layer_rates[0] = 0;
1673  s->compression_rate_enc = 0;
1674  return 0;
1675  }
1676 
1677  token = av_strtok(s->lr_str, ",", &saveptr);
1678  if (rate = strtol(token, NULL, 10)) {
1679  s->layer_rates[0] = rate <= 1 ? 0:rate;
1680  nlayers++;
1681  } else {
1682  return AVERROR_INVALIDDATA;
1683  }
1684 
1685  while (1) {
1686  token = av_strtok(NULL, ",", &saveptr);
1687  if (!token)
1688  break;
1689  if (rate = strtol(token, NULL, 10)) {
1690  if (nlayers >= 100) {
1691  return AVERROR_INVALIDDATA;
1692  }
1693  s->layer_rates[nlayers] = rate <= 1 ? 0:rate;
1694  nlayers++;
1695  } else {
1696  return AVERROR_INVALIDDATA;
1697  }
1698  }
1699 
1700  for (i = 1; i < nlayers; i++) {
1701  if (s->layer_rates[i] >= s->layer_rates[i-1]) {
1702  return AVERROR_INVALIDDATA;
1703  }
1704  }
1705  s->nlayers = nlayers;
1706  s->compression_rate_enc = 1;
1707  return 0;
1708 }
1709 
1711 {
1712  int i, ret;
1713  Jpeg2000EncoderContext *s = avctx->priv_data;
1714  Jpeg2000CodingStyle *codsty = &s->codsty;
1715  Jpeg2000QuantStyle *qntsty = &s->qntsty;
1716 
1717  s->avctx = avctx;
1718  av_log(s->avctx, AV_LOG_DEBUG, "init\n");
1719  if (parse_layer_rates(s)) {
1720  av_log(s, AV_LOG_WARNING, "Layer rates invalid. Encoding with 1 layer based on quality metric.\n");
1721  s->nlayers = 1;
1722  s->layer_rates[0] = 0;
1723  s->compression_rate_enc = 0;
1724  }
1725 
1726 #if FF_API_PRIVATE_OPT
1728  if (avctx->prediction_method)
1729  s->pred = avctx->prediction_method;
1731 #endif
1732 
1733  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && (s->pred != FF_DWT97_INT || s->format != CODEC_JP2)) {
1734  av_log(s->avctx, AV_LOG_WARNING, "Forcing lossless jp2 for pal8\n");
1735  s->pred = FF_DWT97_INT;
1736  s->format = CODEC_JP2;
1737  }
1738 
1739  // defaults:
1740  // TODO: implement setting non-standard precinct size
1741  memset(codsty->log2_prec_widths , 15, sizeof(codsty->log2_prec_widths ));
1742  memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights));
1743  codsty->nreslevels2decode=
1744  codsty->nreslevels = 7;
1745  codsty->nlayers = s->nlayers;
1746  codsty->log2_cblk_width = 4;
1747  codsty->log2_cblk_height = 4;
1748  codsty->transform = s->pred ? FF_DWT53 : FF_DWT97_INT;
1749 
1750  qntsty->nguardbits = 1;
1751 
1752  if ((s->tile_width & (s->tile_width -1)) ||
1753  (s->tile_height & (s->tile_height-1))) {
1754  av_log(avctx, AV_LOG_WARNING, "Tile dimension not a power of 2\n");
1755  }
1756 
1757  if (codsty->transform == FF_DWT53)
1758  qntsty->quantsty = JPEG2000_QSTY_NONE;
1759  else
1760  qntsty->quantsty = JPEG2000_QSTY_SE;
1761 
1762  s->width = avctx->width;
1763  s->height = avctx->height;
1764 
1765  for (i = 0; i < 3; i++) {
1766  if (avctx->pix_fmt == AV_PIX_FMT_GRAY16 || avctx->pix_fmt == AV_PIX_FMT_RGB48)
1767  s->cbps[i] = 16;
1768  else
1769  s->cbps[i] = 8;
1770  }
1771 
1772  if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_RGB48){
1773  s->ncomponents = 3;
1774  } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16){
1775  s->ncomponents = 1;
1776  } else{ // planar YUV
1777  s->planar = 1;
1778  s->ncomponents = 3;
1780  s->chroma_shift, s->chroma_shift + 1);
1781  if (ret)
1782  return ret;
1783  }
1784 
1787  init_luts();
1788 
1789  init_quantization(s);
1790  if ((ret=init_tiles(s)) < 0)
1791  return ret;
1792 
1793  av_log(s->avctx, AV_LOG_DEBUG, "after init\n");
1794 
1795  return 0;
1796 }
1797 
1798 static int j2kenc_destroy(AVCodecContext *avctx)
1799 {
1800  Jpeg2000EncoderContext *s = avctx->priv_data;
1801 
1802  cleanup(s);
1803  return 0;
1804 }
1805 
1806 // taken from the libopenjpeg wraper so it matches
1807 
1808 #define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)
1809 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1810 static const AVOption options[] = {
1811  { "format", "Codec Format", OFFSET(format), AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2, VE, "format" },
1812  { "j2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K }, 0, 0, VE, "format" },
1813  { "jp2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2 }, 0, 0, VE, "format" },
1814  { "tile_width", "Tile Width", OFFSET(tile_width), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1815  { "tile_height", "Tile Height", OFFSET(tile_height), AV_OPT_TYPE_INT, { .i64 = 256 }, 1, 1<<30, VE, },
1816  { "pred", "DWT Type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "pred" },
1817  { "dwt97int", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1818  { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1819  { "sop", "SOP marker", OFFSET(sop), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1820  { "eph", "EPH marker", OFFSET(eph), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, },
1821  { "prog", "Progression Order", OFFSET(prog), AV_OPT_TYPE_INT, { .i64 = 0 }, JPEG2000_PGOD_LRCP, JPEG2000_PGOD_CPRL, VE, "prog" },
1822  { "lrcp", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_LRCP }, 0, 0, VE, "prog" },
1823  { "rlcp", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RLCP }, 0, 0, VE, "prog" },
1824  { "rpcl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RPCL }, 0, 0, VE, "prog" },
1825  { "pcrl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_PCRL }, 0, 0, VE, "prog" },
1826  { "cprl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_CPRL }, 0, 0, VE, "prog" },
1827  { "layer_rates", "Layer Rates", OFFSET(lr_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1828  { NULL }
1829 };
1830 
1831 static const AVClass j2k_class = {
1832  .class_name = "jpeg 2000 encoder",
1833  .item_name = av_default_item_name,
1834  .option = options,
1835  .version = LIBAVUTIL_VERSION_INT,
1836 };
1837 
1839  .name = "jpeg2000",
1840  .long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1841  .type = AVMEDIA_TYPE_VIDEO,
1842  .id = AV_CODEC_ID_JPEG2000,
1843  .priv_data_size = sizeof(Jpeg2000EncoderContext),
1844  .init = j2kenc_init,
1845  .encode2 = encode_frame,
1846  .close = j2kenc_destroy,
1847  .pix_fmts = (const enum AVPixelFormat[]) {
1854  },
1855  .priv_class = &j2k_class,
1856 };
static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
Definition: j2kenc.c:1350
uint8_t nguardbits
Definition: jpeg2000.h:155
#define NULL
Definition: coverity.c:32
int cum_passes
Definition: jpeg2000.h:170
#define NMSEDEC_BITS
Definition: j2kenc.c:78
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_cold ff_jpeg2000_init_tier1_luts(void)
Definition: jpeg2000.c:160
void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:590
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
DWTContext dwt
Definition: jpeg2000.h:220
AVOption.
Definition: opt.h:248
Jpeg2000TgtNode * cblkincl
Definition: jpeg2000.h:196
static void cleanup(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1493
#define JPEG2000_T1_SIG_NB
Definition: jpeg2000.h:85
AVCodec ff_jpeg2000_encoder
Definition: j2kenc.c:1838
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
#define JPEG2000_PGOD_PCRL
Definition: jpeg2000.h:118
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t ninclpasses
Definition: jpeg2000.h:175
#define JPEG2000_PGOD_RLCP
Definition: jpeg2000.h:116
#define avpriv_request_sample(...)
Jpeg2000QuantStyle qntsty
Definition: j2kenc.c:129
static int lut_nmsedec_ref[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
static av_cold int j2kenc_init(AVCodecContext *avctx)
Definition: j2kenc.c:1710
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int nb_codeblocks_width
Definition: jpeg2000.h:193
int av_log2(unsigned v)
Definition: intmath.c:26
static int put_com(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:385
AVCodecContext * avctx
Definition: j2kenc.c:110
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
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
uint16_t mant[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:153
void ff_mqc_initenc(MqcState *mqc, uint8_t *bp)
initialize the encoder
Definition: mqcenc.c:69
static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)
code the value stored in node
Definition: j2kenc.c:249
static AVPacket pkt
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
AVCodec.
Definition: codec.h:190
static void tag_tree_update(Jpeg2000TgtNode *node)
update the value in node
Definition: j2kenc.c:286
static void update_size(uint8_t *size, const uint8_t *end)
Definition: j2kenc.c:1519
static int getnmsedec_ref(int x, int bpno)
Definition: j2kenc.c:604
uint8_t npasses
Definition: jpeg2000.h:174
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
uint16_t log2_cblk_width
Definition: jpeg2000.h:204
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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
#define JPEG2000_CSTY_SOP
Definition: jpeg2000.h:111
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
static int lut_nmsedec_ref0[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
double disto
Definition: jpeg2000.h:169
static void compute_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:423
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
static const AVClass j2k_class
Definition: j2kenc.c:1831
Jpeg2000TgtNode * zerobits
Definition: jpeg2000.h:195
int64_t disto
Definition: jpeg2000.h:160
Jpeg2000Band * band
Definition: jpeg2000.h:215
uint8_t val
Definition: jpeg2000.h:129
int coord[2][2]
Definition: jpeg2000.h:223
#define height
uint8_t * data
Definition: packet.h:363
static void j2k_flush(Jpeg2000EncoderContext *s)
flush the bitstream
Definition: j2kenc.c:238
#define sp
Definition: regdef.h:63
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:390
static int init_tiles(Jpeg2000EncoderContext *s)
compute the sizes of tiles, resolution levels, bands, etc.
Definition: j2kenc.c:453
#define JPEG2000_T1_VIS
Definition: jpeg2000.h:95
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
uint16_t flags[6156]
Definition: jpeg2000.h:123
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
uint8_t nonzerobits
Definition: jpeg2000.h:176
uint8_t log2_prec_widths[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:146
#define JPEG2000_CSTY_EPH
Definition: jpeg2000.h:112
#define U(x)
Definition: vp56_arith.h:37
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
static const uint16_t mask[17]
Definition: lzw.c:38
uint8_t * buf_end
Definition: j2kenc.c:123
#define OFFSET(x)
Definition: j2kenc.c:1808
void ff_jpeg2000_set_significance(Jpeg2000T1Context *t1, int x, int y, int negative)
Definition: jpeg2000.c:172
static int put_cod(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:327
int nb_codeblocks_height
Definition: jpeg2000.h:194
#define CODEC_J2K
Definition: j2kenc.c:84
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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define JPEG2000_PGOD_CPRL
Definition: jpeg2000.h:119
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
uint8_t log2_prec_heights[JPEG2000_MAX_RESLEVELS]
Definition: jpeg2000.h:147
#define t1
Definition: regdef.h:29
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
#define JPEG2000_MAX_PASSES
Definition: jpeg2000.h:73
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:385
static void put_num(Jpeg2000EncoderContext *s, int num, int n)
put n least significant bits of a number num
Definition: j2kenc.c:231
uint8_t incl
Definition: jpeg2000.h:177
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: codec.h:197
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: j2kenc.c:1524
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
const AVFrame * picture
Definition: j2kenc.c:111
uint8_t flushed[4]
Definition: jpeg2000.h:161
Jpeg2000Cblk * cblk
Definition: jpeg2000.h:197
#define FFMAX(a, b)
Definition: common.h:94
static int ff_jpeg2000_ceildiv(int a, int64_t b)
Definition: jpeg2000.h:234
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define pass
Definition: fft_template.c:619
static int put_siz(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:298
static int lut_nmsedec_sig0[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
#define JPEG2000_T1_REF
Definition: jpeg2000.h:97
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
uint8_t lblock
Definition: jpeg2000.h:181
int flushed_len
Definition: jpeg2000.h:162
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
static int put_qcd(Jpeg2000EncoderContext *s, int compno)
Definition: j2kenc.c:359
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
static int getnmsedec_sig(int x, int bpno)
Definition: j2kenc.c:597
int tile_height
tile size
Definition: j2kenc.c:118
#define FFMIN(a, b)
Definition: common.h:96
struct Jpeg2000TgtNode * parent
Definition: jpeg2000.h:132
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:396
static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
Definition: j2kenc.c:611
#define width
int width
picture width / height.
Definition: avcodec.h:699
JPEG 2000 structures and defines common to encoder and decoder.
int i_stepsize
Definition: jpeg2000.h:205
int32_t
static int j2kenc_destroy(AVCodecContext *avctx)
Definition: j2kenc.c:1798
#define MQC_CX_RL
Definition: mqc.h:34
#define CODEC_JP2
Definition: j2kenc.c:83
#define s(width, name)
Definition: cbs_vp9.c:257
static int ff_jpeg2000_getsigctxno(int flag, int bandno)
Definition: jpeg2000.h:253
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
Jpeg2000Layer * layers
Definition: jpeg2000.h:188
static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
Definition: j2kenc.c:1265
uint8_t cbps[4]
bits per sample in particular components
Definition: j2kenc.c:114
int ff_dwt_encode(DWTContext *s, void *t)
Definition: jpeg2000dwt.c:581
int coord[2][2]
Definition: jpeg2000.h:212
uint8_t * data
Definition: jpeg2000.h:182
static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
Definition: j2kenc.c:1402
#define JPEG2000_PGOD_RPCL
Definition: jpeg2000.h:117
static int ff_jpeg2000_ceildivpow2(int a, int b)
Definition: jpeg2000.h:229
static const float pred[4]
Definition: siprdata.h:259
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
int coord[2][2]
Definition: jpeg2000.h:203
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define COPY_FRAME(D, PIXEL)
Definition: j2kenc.c:505
int coord_o[2][2]
Definition: jpeg2000.h:224
Libavcodec external API header.
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:87
static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
Definition: j2kenc.c:633
attribute_deprecated int prediction_method
Definition: avcodec.h:885
uint8_t * buf_start
Definition: j2kenc.c:121
Jpeg2000CodingStyle codsty
Definition: j2kenc.c:128
main external API structure.
Definition: avcodec.h:526
uint8_t vis
Definition: jpeg2000.h:131
uint8_t log2_prec_height
Definition: jpeg2000.h:214
void av_cold ff_mqc_init_context_tables(void)
MQ-coder Initialize context tables (QE, NLPS, NMPS)
Definition: mqc.c:97
uint8_t * data_start
Definition: jpeg2000.h:166
static void init_luts(void)
Definition: j2kenc.c:579
static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile, int width, int height, int bandpos, int lev)
Definition: j2kenc.c:702
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
static const AVOption options[]
Definition: j2kenc.c:1810
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
uint8_t nbands
Definition: jpeg2000.h:211
#define JPEG2000_T1_SGN
Definition: jpeg2000.h:99
int height
image width and height
Definition: j2kenc.c:113
Jpeg2000ResLevel * reslevel
Definition: jpeg2000.h:219
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
Jpeg2000Component * comp
Definition: j2kenc.c:104
void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
Definition: jpeg2000.c:569
static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
Definition: j2kenc.c:936
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
uint8_t expn[JPEG2000_MAX_DECLEVELS *3]
Definition: jpeg2000.h:152
static void reinit(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1509
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
static uint8_t * put_sot(Jpeg2000EncoderContext *s, int tileno)
Definition: j2kenc.c:404
Jpeg2000Tile * tile
Definition: j2kenc.c:131
uint8_t temp_val
Definition: jpeg2000.h:130
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
uint8_t quantsty
Definition: jpeg2000.h:154
common internal api header.
common internal and external API header
uint8_t log2_cblk_width
Definition: jpeg2000.h:138
#define bit(string, value)
Definition: cbs_mpeg2.c:58
#define LAMBDA_SCALE
Definition: j2kenc.c:81
int data[6144]
Definition: jpeg2000.h:122
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
uint16_t log2_cblk_height
Definition: jpeg2000.h:204
#define VE
Definition: j2kenc.c:1809
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h, int val)
Definition: jpeg2000.c:85
#define MQC_CX_UNI
Definition: mqc.h:33
void * priv_data
Definition: avcodec.h:553
int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx)
Definition: jpeg2000.c:459
uint16_t rate
Definition: jpeg2000.h:159
static void putnumpasses(Jpeg2000EncoderContext *s, int n)
Definition: j2kenc.c:765
#define JPEG2000_PGOD_LRCP
Definition: jpeg2000.h:115
int ff_mqc_flush_to(MqcState *mqc, uint8_t *dst, int *dst_len)
Definition: mqcenc.c:122
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
Definition: j2kenc.c:1368
Jpeg2000Prec * prec
Definition: jpeg2000.h:207
double * layer_rates
Definition: j2kenc.c:105
static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile *tile, int final)
Definition: j2kenc.c:1182
static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
Definition: j2kenc.c:647
#define JPEG2000_T1_SIG
Definition: jpeg2000.h:96
static int lut_nmsedec_sig[1<< NMSEDEC_BITS]
Definition: j2kenc.c:86
#define LIBAVCODEC_IDENT
Definition: version.h:42
int layer_rates[100]
Definition: j2kenc.c:132
#define av_freep(p)
MqcState mqc
Definition: jpeg2000.h:124
static int ff_jpeg2000_getrefctxno(int flag)
Definition: jpeg2000.h:262
uint8_t log2_cblk_height
Definition: jpeg2000.h:138
#define av_malloc_array(a, b)
#define NMSEDEC_FRACBITS
Definition: j2kenc.c:79
static void init_quantization(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:549
uint8_t log2_prec_width
Definition: jpeg2000.h:214
static int parse_layer_rates(Jpeg2000EncoderContext *s)
Definition: j2kenc.c:1663
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
Jpeg2000Pass * passes
Definition: jpeg2000.h:187
float min
static const int dwt_norms[2][4][10]
Definition: j2kenc.c:91
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
uint8_t compression_rate_enc
Is compression done using compression ratio?
Definition: j2kenc.c:133
for(j=16;j >0;--j)
int i
Definition: input.c:407
uint8_t cx_states[19]
Definition: mqc.h:45
#define WMSEDEC_SHIFT
must be >= 13
Definition: j2kenc.c:80
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
static int ff_jpeg2000_getsgnctxno(int flag, int *xorbit)
Definition: jpeg2000.h:271
void ff_mqc_encode(MqcState *mqc, uint8_t *cxstate, int d)
code bit d with context cx
Definition: mqcenc.c:79