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