FFmpeg
diracdec.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
3  * Copyright (C) 2009 David Conrad
4  * Copyright (C) 2011 Jordi Ortiz
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Dirac Decoder
26  * @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com>
27  */
28 
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/thread.h"
31 #include "avcodec.h"
32 #include "get_bits.h"
33 #include "bytestream.h"
34 #include "internal.h"
35 #include "golomb.h"
36 #include "dirac_arith.h"
37 #include "dirac_vlc.h"
38 #include "mpeg12data.h"
39 #include "libavcodec/mpegvideo.h"
40 #include "mpegvideoencdsp.h"
41 #include "dirac_dwt.h"
42 #include "dirac.h"
43 #include "diractab.h"
44 #include "diracdsp.h"
45 #include "videodsp.h"
46 
47 /**
48  * The spec limits this to 3 for frame coding, but in practice can be as high as 6
49  */
50 #define MAX_REFERENCE_FRAMES 8
51 #define MAX_DELAY 5 /* limit for main profile for frame coding (TODO: field coding) */
52 #define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
53 #define MAX_QUANT 255 /* max quant for VC-2 */
54 #define MAX_BLOCKSIZE 32 /* maximum xblen/yblen we support */
55 
56 /**
57  * DiracBlock->ref flags, if set then the block does MC from the given ref
58  */
59 #define DIRAC_REF_MASK_REF1 1
60 #define DIRAC_REF_MASK_REF2 2
61 #define DIRAC_REF_MASK_GLOBAL 4
62 
63 /**
64  * Value of Picture.reference when Picture is not a reference picture, but
65  * is held for delayed output.
66  */
67 #define DELAYED_PIC_REF 4
68 
69 #define CALC_PADDING(size, depth) \
70  (((size + (1 << depth) - 1) >> depth) << depth)
71 
72 #define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
73 
74 typedef struct {
76  int interpolated[3]; /* 1 if hpel[] is valid */
77  uint8_t *hpel[3][4];
78  uint8_t *hpel_base[3][4];
79  int reference;
80 } DiracFrame;
81 
82 typedef struct {
83  union {
84  int16_t mv[2][2];
85  int16_t dc[3];
86  } u; /* anonymous unions aren't in C99 :( */
88 } DiracBlock;
89 
90 typedef struct SubBand {
91  int level;
92  int orientation;
93  int stride; /* in bytes */
94  int width;
95  int height;
96  int pshift;
97  int quant;
98  uint8_t *ibuf;
99  struct SubBand *parent;
100 
101  /* for low delay */
102  unsigned length;
104 } SubBand;
105 
106 typedef struct Plane {
108 
109  int width;
110  int height;
111  ptrdiff_t stride;
112 
113  /* block length */
116  /* block separation (block n+1 starts after this many pixels in block n) */
119  /* amount of overspill on each edge (half of the overlap between blocks) */
122 
123  SubBand band[MAX_DWT_LEVELS][4];
124 } Plane;
125 
126 /* Used by Low Delay and High Quality profiles */
127 typedef struct DiracSlice {
129  int slice_x;
130  int slice_y;
131  int bytes;
132 } DiracSlice;
133 
134 typedef struct DiracContext {
144  int64_t frame_number; /* number of the next frame to display */
148 
149  int bit_depth; /* bit depth */
150  int pshift; /* pixel shift = bit_depth > 8 */
151 
152  int zero_res; /* zero residue flag */
153  int is_arith; /* whether coeffs use arith or golomb coding */
154  int core_syntax; /* use core syntax only */
155  int low_delay; /* use the low delay syntax */
156  int hq_picture; /* high quality picture, enables low_delay */
157  int ld_picture; /* use low delay picture, turns on low_delay */
158  int dc_prediction; /* has dc prediction */
159  int globalmc_flag; /* use global motion compensation */
160  int num_refs; /* number of reference pictures */
161 
162  /* wavelet decoding */
163  unsigned wavelet_depth; /* depth of the IDWT */
164  unsigned wavelet_idx;
165 
166  /**
167  * schroedinger older than 1.0.8 doesn't store
168  * quant delta if only one codebook exists in a band
169  */
170  unsigned old_delta_quant;
171  unsigned codeblock_mode;
172 
173  unsigned num_x; /* number of horizontal slices */
174  unsigned num_y; /* number of vertical slices */
175 
176  uint8_t *thread_buf; /* Per-thread buffer for coefficient storage */
177  int threads_num_buf; /* Current # of buffers allocated */
178  int thread_buf_size; /* Each thread has a buffer this size */
179 
182 
183  struct {
184  unsigned width;
185  unsigned height;
187 
188  struct {
189  AVRational bytes; /* average bytes per slice */
190  uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
191  } lowdelay;
192 
193  struct {
194  unsigned prefix_bytes;
195  uint64_t size_scaler;
196  } highquality;
197 
198  struct {
199  int pan_tilt[2]; /* pan/tilt vector */
200  int zrs[2][2]; /* zoom/rotate/shear matrix */
201  int perspective[2]; /* perspective vector */
202  unsigned zrs_exp;
203  unsigned perspective_exp;
204  } globalmc[2];
205 
206  /* motion compensation */
207  uint8_t mv_precision; /* [DIRAC_STD] REFS_WT_PRECISION */
208  int16_t weight[2]; /* [DIRAC_STD] REF1_WT and REF2_WT */
209  unsigned weight_log2denom; /* [DIRAC_STD] REFS_WT_PRECISION */
210 
211  int blwidth; /* number of blocks (horizontally) */
212  int blheight; /* number of blocks (vertically) */
213  int sbwidth; /* number of superblocks (horizontally) */
214  int sbheight; /* number of superblocks (vertically) */
215 
218 
219  uint8_t *edge_emu_buffer[4];
221 
222  uint16_t *mctmp; /* buffer holding the MC data multiplied by OBMC weights */
225 
227 
228  void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
229  void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
230  void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
233 
235  DiracFrame *ref_pics[2];
236 
238  DiracFrame *delay_frames[MAX_DELAY+1];
239  DiracFrame all_frames[MAX_FRAMES];
240 } DiracContext;
241 
248 };
249 
250 /* magic number division by 3 from schroedinger */
251 static inline int divide3(int x)
252 {
253  return (int)((x+1U)*21845 + 10922) >> 16;
254 }
255 
256 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
257 {
258  DiracFrame *remove_pic = NULL;
259  int i, remove_idx = -1;
260 
261  for (i = 0; framelist[i]; i++)
262  if (framelist[i]->avframe->display_picture_number == picnum) {
263  remove_pic = framelist[i];
264  remove_idx = i;
265  }
266 
267  if (remove_pic)
268  for (i = remove_idx; framelist[i]; i++)
269  framelist[i] = framelist[i+1];
270 
271  return remove_pic;
272 }
273 
274 static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
275 {
276  int i;
277  for (i = 0; i < maxframes; i++)
278  if (!framelist[i]) {
279  framelist[i] = frame;
280  return 0;
281  }
282  return -1;
283 }
284 
286 {
287  int sbwidth = DIVRNDUP(s->seq.width, 4);
288  int sbheight = DIVRNDUP(s->seq.height, 4);
289  int i, w, h, top_padding;
290 
291  /* todo: think more about this / use or set Plane here */
292  for (i = 0; i < 3; i++) {
293  int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
294  int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
295  w = s->seq.width >> (i ? s->chroma_x_shift : 0);
296  h = s->seq.height >> (i ? s->chroma_y_shift : 0);
297 
298  /* we allocate the max we support here since num decompositions can
299  * change from frame to frame. Stride is aligned to 16 for SIMD, and
300  * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
301  * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
302  * on each side */
303  top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
304  w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
305  h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
306 
307  s->plane[i].idwt.buf_base = av_mallocz_array((w+max_xblen), h * (2 << s->pshift));
308  s->plane[i].idwt.tmp = av_malloc_array((w+16), 2 << s->pshift);
309  s->plane[i].idwt.buf = s->plane[i].idwt.buf_base + (top_padding*w)*(2 << s->pshift);
310  if (!s->plane[i].idwt.buf_base || !s->plane[i].idwt.tmp)
311  return AVERROR(ENOMEM);
312  }
313 
314  /* fixme: allocate using real stride here */
315  s->sbsplit = av_malloc_array(sbwidth, sbheight);
316  s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion));
317 
318  if (!s->sbsplit || !s->blmotion)
319  return AVERROR(ENOMEM);
320  return 0;
321 }
322 
324 {
325  int w = s->seq.width;
326  int h = s->seq.height;
327 
328  av_assert0(stride >= w);
329  stride += 64;
330 
331  if (s->buffer_stride >= stride)
332  return 0;
333  s->buffer_stride = 0;
334 
336  memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer));
337  av_freep(&s->mctmp);
338  av_freep(&s->mcscratch);
339 
341 
342  s->mctmp = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));
344 
345  if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch)
346  return AVERROR(ENOMEM);
347 
348  s->buffer_stride = stride;
349  return 0;
350 }
351 
353 {
354  int i, j, k;
355 
356  for (i = 0; i < MAX_FRAMES; i++) {
357  if (s->all_frames[i].avframe->data[0]) {
359  memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
360  }
361 
362  for (j = 0; j < 3; j++)
363  for (k = 1; k < 4; k++)
364  av_freep(&s->all_frames[i].hpel_base[j][k]);
365  }
366 
367  memset(s->ref_frames, 0, sizeof(s->ref_frames));
368  memset(s->delay_frames, 0, sizeof(s->delay_frames));
369 
370  for (i = 0; i < 3; i++) {
371  av_freep(&s->plane[i].idwt.buf_base);
372  av_freep(&s->plane[i].idwt.tmp);
373  }
374 
375  s->buffer_stride = 0;
376  av_freep(&s->sbsplit);
377  av_freep(&s->blmotion);
379 
380  av_freep(&s->mctmp);
381  av_freep(&s->mcscratch);
382 }
383 
385 
387 {
388  DiracContext *s = avctx->priv_data;
389  int i, ret;
390 
391  s->avctx = avctx;
392  s->frame_number = -1;
393 
394  s->thread_buf = NULL;
395  s->threads_num_buf = -1;
396  s->thread_buf_size = -1;
397 
401  ff_videodsp_init(&s->vdsp, 8);
402 
403  for (i = 0; i < MAX_FRAMES; i++) {
405  if (!s->all_frames[i].avframe) {
406  while (i > 0)
407  av_frame_free(&s->all_frames[--i].avframe);
408  return AVERROR(ENOMEM);
409  }
410  }
412  if (ret != 0)
413  return AVERROR_UNKNOWN;
414 
415  return 0;
416 }
417 
419 {
420  DiracContext *s = avctx->priv_data;
422  s->seen_sequence_header = 0;
423  s->frame_number = -1;
424 }
425 
427 {
428  DiracContext *s = avctx->priv_data;
429  int i;
430 
432 
433  dirac_decode_flush(avctx);
434  for (i = 0; i < MAX_FRAMES; i++)
436 
437  av_freep(&s->thread_buf);
439 
440  return 0;
441 }
442 
443 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
444 {
445  int coeff = dirac_get_se_golomb(gb);
446  const unsigned sign = FFSIGN(coeff);
447  if (coeff)
448  coeff = sign*((sign * coeff * qfactor + qoffset) >> 2);
449  return coeff;
450 }
451 
452 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
453 
454 #define UNPACK_ARITH(n, type) \
455  static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
456  SubBand *b, type *buf, int x, int y) \
457  { \
458  int sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
459  unsigned coeff; \
460  const int mstride = -(b->stride >> (1+b->pshift)); \
461  if (b->parent) { \
462  const type *pbuf = (type *)b->parent->ibuf; \
463  const int stride = b->parent->stride >> (1+b->parent->pshift); \
464  pred_ctx += !!pbuf[stride * (y>>1) + (x>>1)] << 1; \
465  } \
466  if (b->orientation == subband_hl) \
467  sign_pred = buf[mstride]; \
468  if (x) { \
469  pred_ctx += !(buf[-1] | buf[mstride] | buf[-1 + mstride]); \
470  if (b->orientation == subband_lh) \
471  sign_pred = buf[-1]; \
472  } else { \
473  pred_ctx += !buf[mstride]; \
474  } \
475  coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA); \
476  if (coeff) { \
477  coeff = (coeff * qfactor + qoffset) >> 2; \
478  sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred)); \
479  coeff = (coeff ^ -sign) + sign; \
480  } \
481  *buf = coeff; \
482  } \
483 
484 UNPACK_ARITH(8, int16_t)
486 
487 /**
488  * Decode the coeffs in the rectangle defined by left, right, top, bottom
489  * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
490  */
491 static inline int codeblock(DiracContext *s, SubBand *b,
492  GetBitContext *gb, DiracArith *c,
493  int left, int right, int top, int bottom,
494  int blockcnt_one, int is_arith)
495 {
496  int x, y, zero_block;
497  int qoffset, qfactor;
498  uint8_t *buf;
499 
500  /* check for any coded coefficients in this codeblock */
501  if (!blockcnt_one) {
502  if (is_arith)
503  zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
504  else
505  zero_block = get_bits1(gb);
506 
507  if (zero_block)
508  return 0;
509  }
510 
511  if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
512  int quant;
513  if (is_arith)
515  else
516  quant = dirac_get_se_golomb(gb);
517  if (quant > INT_MAX - b->quant || b->quant + quant < 0) {
518  av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
519  return AVERROR_INVALIDDATA;
520  }
521  b->quant += quant;
522  }
523 
524  if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
525  av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant);
526  b->quant = 0;
527  return AVERROR_INVALIDDATA;
528  }
529 
530  qfactor = ff_dirac_qscale_tab[b->quant];
531  /* TODO: context pointer? */
532  if (!s->num_refs)
533  qoffset = ff_dirac_qoffset_intra_tab[b->quant] + 2;
534  else
535  qoffset = ff_dirac_qoffset_inter_tab[b->quant] + 2;
536 
537  buf = b->ibuf + top * b->stride;
538  if (is_arith) {
539  for (y = top; y < bottom; y++) {
540  if (c->error)
541  return c->error;
542  for (x = left; x < right; x++) {
543  if (b->pshift) {
544  coeff_unpack_arith_10(c, qfactor, qoffset, b, (int32_t*)(buf)+x, x, y);
545  } else {
546  coeff_unpack_arith_8(c, qfactor, qoffset, b, (int16_t*)(buf)+x, x, y);
547  }
548  }
549  buf += b->stride;
550  }
551  } else {
552  for (y = top; y < bottom; y++) {
553  if (get_bits_left(gb) < 1)
554  return AVERROR_INVALIDDATA;
555  for (x = left; x < right; x++) {
556  int val = coeff_unpack_golomb(gb, qfactor, qoffset);
557  if (b->pshift) {
558  AV_WN32(&buf[4*x], val);
559  } else {
560  AV_WN16(&buf[2*x], val);
561  }
562  }
563  buf += b->stride;
564  }
565  }
566  return 0;
567 }
568 
569 /**
570  * Dirac Specification ->
571  * 13.3 intra_dc_prediction(band)
572  */
573 #define INTRA_DC_PRED(n, type) \
574  static inline void intra_dc_prediction_##n(SubBand *b) \
575  { \
576  type *buf = (type*)b->ibuf; \
577  int x, y; \
578  \
579  for (x = 1; x < b->width; x++) \
580  buf[x] += buf[x-1]; \
581  buf += (b->stride >> (1+b->pshift)); \
582  \
583  for (y = 1; y < b->height; y++) { \
584  buf[0] += buf[-(b->stride >> (1+b->pshift))]; \
585  \
586  for (x = 1; x < b->width; x++) { \
587  int pred = buf[x - 1] + buf[x - (b->stride >> (1+b->pshift))] + buf[x - (b->stride >> (1+b->pshift))-1]; \
588  buf[x] += divide3(pred); \
589  } \
590  buf += (b->stride >> (1+b->pshift)); \
591  } \
592  } \
593 
594 INTRA_DC_PRED(8, int16_t)
595 INTRA_DC_PRED(10, uint32_t)
596 
597 /**
598  * Dirac Specification ->
599  * 13.4.2 Non-skipped subbands. subband_coeffs()
600  */
602 {
603  int cb_x, cb_y, left, right, top, bottom;
604  DiracArith c;
605  GetBitContext gb;
606  int cb_width = s->codeblock[b->level + (b->orientation != subband_ll)].width;
607  int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
608  int blockcnt_one = (cb_width + cb_height) == 2;
609  int ret;
610 
611  if (!b->length)
612  return 0;
613 
614  init_get_bits8(&gb, b->coeff_data, b->length);
615 
616  if (is_arith)
617  ff_dirac_init_arith_decoder(&c, &gb, b->length);
618 
619  top = 0;
620  for (cb_y = 0; cb_y < cb_height; cb_y++) {
621  bottom = (b->height * (cb_y+1LL)) / cb_height;
622  left = 0;
623  for (cb_x = 0; cb_x < cb_width; cb_x++) {
624  right = (b->width * (cb_x+1LL)) / cb_width;
625  ret = codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
626  if (ret < 0)
627  return ret;
628  left = right;
629  }
630  top = bottom;
631  }
632 
633  if (b->orientation == subband_ll && s->num_refs == 0) {
634  if (s->pshift) {
635  intra_dc_prediction_10(b);
636  } else {
637  intra_dc_prediction_8(b);
638  }
639  }
640  return 0;
641 }
642 
643 static int decode_subband_arith(AVCodecContext *avctx, void *b)
644 {
645  DiracContext *s = avctx->priv_data;
646  return decode_subband_internal(s, b, 1);
647 }
648 
649 static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
650 {
651  DiracContext *s = avctx->priv_data;
652  SubBand **b = arg;
653  return decode_subband_internal(s, *b, 0);
654 }
655 
656 /**
657  * Dirac Specification ->
658  * [DIRAC_STD] 13.4.1 core_transform_data()
659  */
661 {
662  AVCodecContext *avctx = s->avctx;
665  int level, num_bands = 0;
666  int ret[3*MAX_DWT_LEVELS+1];
667  int i;
668  int damaged_count = 0;
669 
670  /* Unpack all subbands at all levels. */
671  for (level = 0; level < s->wavelet_depth; level++) {
672  for (orientation = !!level; orientation < 4; orientation++) {
674  bands[num_bands++] = b;
675 
676  align_get_bits(&s->gb);
677  /* [DIRAC_STD] 13.4.2 subband() */
679  if (b->length) {
681  if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
682  av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant);
683  b->quant = 0;
684  return AVERROR_INVALIDDATA;
685  }
686  align_get_bits(&s->gb);
687  b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
688  if (b->length > FFMAX(get_bits_left(&s->gb)/8, 0)) {
689  b->length = FFMAX(get_bits_left(&s->gb)/8, 0);
690  damaged_count ++;
691  }
692  skip_bits_long(&s->gb, b->length*8);
693  }
694  }
695  /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
696  if (s->is_arith)
697  avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
698  ret + 3*level + !!level, 4-!!level, sizeof(SubBand));
699  }
700  /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
701  if (!s->is_arith)
702  avctx->execute(avctx, decode_subband_golomb, bands, ret, num_bands, sizeof(SubBand*));
703 
704  for (i = 0; i < s->wavelet_depth * 3 + 1; i++) {
705  if (ret[i] < 0)
706  damaged_count++;
707  }
708  if (damaged_count > (s->wavelet_depth * 3 + 1) /2)
709  return AVERROR_INVALIDDATA;
710 
711  return 0;
712 }
713 
714 #define PARSE_VALUES(type, x, gb, ebits, buf1, buf2) \
715  type *buf = (type *)buf1; \
716  buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
717  if (get_bits_count(gb) >= ebits) \
718  return; \
719  if (buf2) { \
720  buf = (type *)buf2; \
721  buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
722  if (get_bits_count(gb) >= ebits) \
723  return; \
724  } \
725 
727  int slice_x, int slice_y, int bits_end,
728  SubBand *b1, SubBand *b2)
729 {
730  int left = b1->width * slice_x / s->num_x;
731  int right = b1->width *(slice_x+1) / s->num_x;
732  int top = b1->height * slice_y / s->num_y;
733  int bottom = b1->height *(slice_y+1) / s->num_y;
734 
735  int qfactor, qoffset;
736 
737  uint8_t *buf1 = b1->ibuf + top * b1->stride;
738  uint8_t *buf2 = b2 ? b2->ibuf + top * b2->stride: NULL;
739  int x, y;
740 
741  if (quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
742  av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", quant);
743  return;
744  }
745  qfactor = ff_dirac_qscale_tab[quant];
746  qoffset = ff_dirac_qoffset_intra_tab[quant] + 2;
747  /* we have to constantly check for overread since the spec explicitly
748  requires this, with the meaning that all remaining coeffs are set to 0 */
749  if (get_bits_count(gb) >= bits_end)
750  return;
751 
752  if (s->pshift) {
753  for (y = top; y < bottom; y++) {
754  for (x = left; x < right; x++) {
755  PARSE_VALUES(int32_t, x, gb, bits_end, buf1, buf2);
756  }
757  buf1 += b1->stride;
758  if (buf2)
759  buf2 += b2->stride;
760  }
761  }
762  else {
763  for (y = top; y < bottom; y++) {
764  for (x = left; x < right; x++) {
765  PARSE_VALUES(int16_t, x, gb, bits_end, buf1, buf2);
766  }
767  buf1 += b1->stride;
768  if (buf2)
769  buf2 += b2->stride;
770  }
771  }
772 }
773 
774 /**
775  * Dirac Specification ->
776  * 13.5.2 Slices. slice(sx,sy)
777  */
778 static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
779 {
780  DiracContext *s = avctx->priv_data;
781  DiracSlice *slice = arg;
782  GetBitContext *gb = &slice->gb;
784  int level, quant, chroma_bits, chroma_end;
785 
786  int quant_base = get_bits(gb, 7); /*[DIRAC_STD] qindex */
787  int length_bits = av_log2(8 * slice->bytes)+1;
788  int luma_bits = get_bits_long(gb, length_bits);
789  int luma_end = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
790 
791  /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
792  for (level = 0; level < s->wavelet_depth; level++)
793  for (orientation = !!level; orientation < 4; orientation++) {
794  quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
795  decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
796  &s->plane[0].band[level][orientation], NULL);
797  }
798 
799  /* consume any unused bits from luma */
800  skip_bits_long(gb, get_bits_count(gb) - luma_end);
801 
802  chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
803  chroma_end = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
804  /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
805  for (level = 0; level < s->wavelet_depth; level++)
806  for (orientation = !!level; orientation < 4; orientation++) {
807  quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
808  decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
809  &s->plane[1].band[level][orientation],
810  &s->plane[2].band[level][orientation]);
811  }
812 
813  return 0;
814 }
815 
816 typedef struct SliceCoeffs {
817  int left;
818  int top;
819  int tot_h;
820  int tot_v;
821  int tot;
822 } SliceCoeffs;
823 
824 static int subband_coeffs(DiracContext *s, int x, int y, int p,
826 {
827  int level, coef = 0;
828  for (level = 0; level < s->wavelet_depth; level++) {
829  SliceCoeffs *o = &c[level];
830  SubBand *b = &s->plane[p].band[level][3]; /* orientation doens't matter */
831  o->top = b->height * y / s->num_y;
832  o->left = b->width * x / s->num_x;
833  o->tot_h = ((b->width * (x + 1)) / s->num_x) - o->left;
834  o->tot_v = ((b->height * (y + 1)) / s->num_y) - o->top;
835  o->tot = o->tot_h*o->tot_v;
836  coef += o->tot * (4 - !!level);
837  }
838  return coef;
839 }
840 
841 /**
842  * VC-2 Specification ->
843  * 13.5.3 hq_slice(sx,sy)
844  */
845 static int decode_hq_slice(DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf)
846 {
847  int i, level, orientation, quant_idx;
848  int qfactor[MAX_DWT_LEVELS][4], qoffset[MAX_DWT_LEVELS][4];
849  GetBitContext *gb = &slice->gb;
850  SliceCoeffs coeffs_num[MAX_DWT_LEVELS];
851 
853  quant_idx = get_bits(gb, 8);
854 
855  if (quant_idx > DIRAC_MAX_QUANT_INDEX - 1) {
856  av_log(s->avctx, AV_LOG_ERROR, "Invalid quantization index - %i\n", quant_idx);
857  return AVERROR_INVALIDDATA;
858  }
859 
860  /* Slice quantization (slice_quantizers() in the specs) */
861  for (level = 0; level < s->wavelet_depth; level++) {
862  for (orientation = !!level; orientation < 4; orientation++) {
863  const int quant = FFMAX(quant_idx - s->lowdelay.quant[level][orientation], 0);
866  }
867  }
868 
869  /* Luma + 2 Chroma planes */
870  for (i = 0; i < 3; i++) {
871  int coef_num, coef_par, off = 0;
872  int64_t length = s->highquality.size_scaler*get_bits(gb, 8);
873  int64_t bits_end = get_bits_count(gb) + 8*length;
874  const uint8_t *addr = align_get_bits(gb);
875 
876  if (length*8 > get_bits_left(gb)) {
877  av_log(s->avctx, AV_LOG_ERROR, "end too far away\n");
878  return AVERROR_INVALIDDATA;
879  }
880 
881  coef_num = subband_coeffs(s, slice->slice_x, slice->slice_y, i, coeffs_num);
882 
883  if (s->pshift)
884  coef_par = ff_dirac_golomb_read_32bit(s->reader_ctx, addr,
885  length, tmp_buf, coef_num);
886  else
887  coef_par = ff_dirac_golomb_read_16bit(s->reader_ctx, addr,
888  length, tmp_buf, coef_num);
889 
890  if (coef_num > coef_par) {
891  const int start_b = coef_par * (1 << (s->pshift + 1));
892  const int end_b = coef_num * (1 << (s->pshift + 1));
893  memset(&tmp_buf[start_b], 0, end_b - start_b);
894  }
895 
896  for (level = 0; level < s->wavelet_depth; level++) {
897  const SliceCoeffs *c = &coeffs_num[level];
898  for (orientation = !!level; orientation < 4; orientation++) {
899  const SubBand *b1 = &s->plane[i].band[level][orientation];
900  uint8_t *buf = b1->ibuf + c->top * b1->stride + (c->left << (s->pshift + 1));
901 
902  /* Change to c->tot_h <= 4 for AVX2 dequantization */
903  const int qfunc = s->pshift + 2*(c->tot_h <= 2);
904  s->diracdsp.dequant_subband[qfunc](&tmp_buf[off], buf, b1->stride,
905  qfactor[level][orientation],
906  qoffset[level][orientation],
907  c->tot_v, c->tot_h);
908 
909  off += c->tot << (s->pshift + 1);
910  }
911  }
912 
913  skip_bits_long(gb, bits_end - get_bits_count(gb));
914  }
915 
916  return 0;
917 }
918 
919 static int decode_hq_slice_row(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
920 {
921  int i;
922  DiracContext *s = avctx->priv_data;
923  DiracSlice *slices = ((DiracSlice *)arg) + s->num_x*jobnr;
924  uint8_t *thread_buf = &s->thread_buf[s->thread_buf_size*threadnr];
925  for (i = 0; i < s->num_x; i++)
926  decode_hq_slice(s, &slices[i], thread_buf);
927  return 0;
928 }
929 
930 /**
931  * Dirac Specification ->
932  * 13.5.1 low_delay_transform_data()
933  */
935 {
936  AVCodecContext *avctx = s->avctx;
937  int slice_x, slice_y, bufsize;
938  int64_t coef_buf_size, bytes = 0;
939  const uint8_t *buf;
940  DiracSlice *slices;
942  int slice_num = 0;
943 
944  if (s->slice_params_num_buf != (s->num_x * s->num_y)) {
946  if (!s->slice_params_buf) {
947  av_log(s->avctx, AV_LOG_ERROR, "slice params buffer allocation failure\n");
948  s->slice_params_num_buf = 0;
949  return AVERROR(ENOMEM);
950  }
951  s->slice_params_num_buf = s->num_x * s->num_y;
952  }
953  slices = s->slice_params_buf;
954 
955  /* 8 becacuse that's how much the golomb reader could overread junk data
956  * from another plane/slice at most, and 512 because SIMD */
957  coef_buf_size = subband_coeffs(s, s->num_x - 1, s->num_y - 1, 0, tmp) + 8;
958  coef_buf_size = (coef_buf_size << (1 + s->pshift)) + 512;
959 
960  if (s->threads_num_buf != avctx->thread_count ||
961  s->thread_buf_size != coef_buf_size) {
962  s->threads_num_buf = avctx->thread_count;
963  s->thread_buf_size = coef_buf_size;
965  if (!s->thread_buf) {
966  av_log(s->avctx, AV_LOG_ERROR, "thread buffer allocation failure\n");
967  return AVERROR(ENOMEM);
968  }
969  }
970 
971  align_get_bits(&s->gb);
972  /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
973  buf = s->gb.buffer + get_bits_count(&s->gb)/8;
974  bufsize = get_bits_left(&s->gb);
975 
976  if (s->hq_picture) {
977  int i;
978 
979  for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
980  for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
981  bytes = s->highquality.prefix_bytes + 1;
982  for (i = 0; i < 3; i++) {
983  if (bytes <= bufsize/8)
984  bytes += buf[bytes] * s->highquality.size_scaler + 1;
985  }
986  if (bytes >= INT_MAX || bytes*8 > bufsize) {
987  av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n");
988  return AVERROR_INVALIDDATA;
989  }
990 
991  slices[slice_num].bytes = bytes;
992  slices[slice_num].slice_x = slice_x;
993  slices[slice_num].slice_y = slice_y;
994  init_get_bits(&slices[slice_num].gb, buf, bufsize);
995  slice_num++;
996 
997  buf += bytes;
998  if (bufsize/8 >= bytes)
999  bufsize -= bytes*8;
1000  else
1001  bufsize = 0;
1002  }
1003  }
1004 
1005  if (s->num_x*s->num_y != slice_num) {
1006  av_log(s->avctx, AV_LOG_ERROR, "too few slices\n");
1007  return AVERROR_INVALIDDATA;
1008  }
1009 
1010  avctx->execute2(avctx, decode_hq_slice_row, slices, NULL, s->num_y);
1011  } else {
1012  for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
1013  for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
1014  bytes = (slice_num+1) * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den
1015  - slice_num * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den;
1016  if (bytes >= INT_MAX || bytes*8 > bufsize) {
1017  av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n");
1018  return AVERROR_INVALIDDATA;
1019  }
1020  slices[slice_num].bytes = bytes;
1021  slices[slice_num].slice_x = slice_x;
1022  slices[slice_num].slice_y = slice_y;
1023  init_get_bits(&slices[slice_num].gb, buf, bufsize);
1024  slice_num++;
1025 
1026  buf += bytes;
1027  if (bufsize/8 >= bytes)
1028  bufsize -= bytes*8;
1029  else
1030  bufsize = 0;
1031  }
1032  }
1033  avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
1034  sizeof(DiracSlice)); /* [DIRAC_STD] 13.5.2 Slices */
1035  }
1036 
1037  if (s->dc_prediction) {
1038  if (s->pshift) {
1039  intra_dc_prediction_10(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1040  intra_dc_prediction_10(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1041  intra_dc_prediction_10(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1042  } else {
1043  intra_dc_prediction_8(&s->plane[0].band[0][0]);
1044  intra_dc_prediction_8(&s->plane[1].band[0][0]);
1045  intra_dc_prediction_8(&s->plane[2].band[0][0]);
1046  }
1047  }
1048 
1049  return 0;
1050 }
1051 
1053 {
1054  int i, w, h, level, orientation;
1055 
1056  for (i = 0; i < 3; i++) {
1057  Plane *p = &s->plane[i];
1058 
1059  p->width = s->seq.width >> (i ? s->chroma_x_shift : 0);
1060  p->height = s->seq.height >> (i ? s->chroma_y_shift : 0);
1061  p->idwt.width = w = CALC_PADDING(p->width , s->wavelet_depth);
1062  p->idwt.height = h = CALC_PADDING(p->height, s->wavelet_depth);
1063  p->idwt.stride = FFALIGN(p->idwt.width, 8) << (1 + s->pshift);
1064 
1065  for (level = s->wavelet_depth-1; level >= 0; level--) {
1066  w = w>>1;
1067  h = h>>1;
1068  for (orientation = !!level; orientation < 4; orientation++) {
1069  SubBand *b = &p->band[level][orientation];
1070 
1071  b->pshift = s->pshift;
1072  b->ibuf = p->idwt.buf;
1073  b->level = level;
1074  b->stride = p->idwt.stride << (s->wavelet_depth - level);
1075  b->width = w;
1076  b->height = h;
1077  b->orientation = orientation;
1078 
1079  if (orientation & 1)
1080  b->ibuf += w << (1+b->pshift);
1081  if (orientation > 1)
1082  b->ibuf += (b->stride>>1);
1083 
1084  if (level)
1085  b->parent = &p->band[level-1][orientation];
1086  }
1087  }
1088 
1089  if (i > 0) {
1090  p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
1091  p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
1092  p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
1093  p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
1094  }
1095 
1096  p->xoffset = (p->xblen - p->xbsep)/2;
1097  p->yoffset = (p->yblen - p->ybsep)/2;
1098  }
1099 }
1100 
1101 /**
1102  * Unpack the motion compensation parameters
1103  * Dirac Specification ->
1104  * 11.2 Picture prediction data. picture_prediction()
1105  */
1107 {
1108  static const uint8_t default_blen[] = { 4, 12, 16, 24 };
1109 
1110  GetBitContext *gb = &s->gb;
1111  unsigned idx, ref;
1112 
1113  align_get_bits(gb);
1114  /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
1115  /* Luma and Chroma are equal. 11.2.3 */
1116  idx = get_interleaved_ue_golomb(gb); /* [DIRAC_STD] index */
1117 
1118  if (idx > 4) {
1119  av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
1120  return AVERROR_INVALIDDATA;
1121  }
1122 
1123  if (idx == 0) {
1128  } else {
1129  /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
1130  s->plane[0].xblen = default_blen[idx-1];
1131  s->plane[0].yblen = default_blen[idx-1];
1132  s->plane[0].xbsep = 4 * idx;
1133  s->plane[0].ybsep = 4 * idx;
1134  }
1135  /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
1136  Calculated in function dirac_unpack_block_motion_data */
1137 
1138  if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 ||
1139  s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 ||
1140  !s->plane[0].xblen || !s->plane[0].yblen) {
1142  "invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
1143  s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift);
1144  return AVERROR_INVALIDDATA;
1145  }
1146  if (!s->plane[0].xbsep || !s->plane[0].ybsep || s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) {
1147  av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
1148  return AVERROR_INVALIDDATA;
1149  }
1150  if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
1151  av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
1152  return AVERROR_INVALIDDATA;
1153  }
1154  if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
1155  av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
1156  return AVERROR_PATCHWELCOME;
1157  }
1158 
1159  /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
1160  Read motion vector precision */
1162  if (s->mv_precision > 3) {
1163  av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
1164  return AVERROR_INVALIDDATA;
1165  }
1166 
1167  /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
1168  Read the global motion compensation parameters */
1169  s->globalmc_flag = get_bits1(gb);
1170  if (s->globalmc_flag) {
1171  memset(s->globalmc, 0, sizeof(s->globalmc));
1172  /* [DIRAC_STD] pan_tilt(gparams) */
1173  for (ref = 0; ref < s->num_refs; ref++) {
1174  if (get_bits1(gb)) {
1177  }
1178  /* [DIRAC_STD] zoom_rotate_shear(gparams)
1179  zoom/rotation/shear parameters */
1180  if (get_bits1(gb)) {
1182  s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
1183  s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
1184  s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
1185  s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
1186  } else {
1187  s->globalmc[ref].zrs[0][0] = 1;
1188  s->globalmc[ref].zrs[1][1] = 1;
1189  }
1190  /* [DIRAC_STD] perspective(gparams) */
1191  if (get_bits1(gb)) {
1195  }
1196  if (s->globalmc[ref].perspective_exp + (uint64_t)s->globalmc[ref].zrs_exp > 30) {
1197  return AVERROR_INVALIDDATA;
1198  }
1199 
1200  }
1201  }
1202 
1203  /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
1204  Picture prediction mode, not currently used. */
1205  if (get_interleaved_ue_golomb(gb)) {
1206  av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
1207  return AVERROR_INVALIDDATA;
1208  }
1209 
1210  /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
1211  just data read, weight calculation will be done later on. */
1212  s->weight_log2denom = 1;
1213  s->weight[0] = 1;
1214  s->weight[1] = 1;
1215 
1216  if (get_bits1(gb)) {
1218  if (s->weight_log2denom < 1 || s->weight_log2denom > 8) {
1219  av_log(s->avctx, AV_LOG_ERROR, "weight_log2denom unsupported or invalid\n");
1220  s->weight_log2denom = 1;
1221  return AVERROR_INVALIDDATA;
1222  }
1223  s->weight[0] = dirac_get_se_golomb(gb);
1224  if (s->num_refs == 2)
1225  s->weight[1] = dirac_get_se_golomb(gb);
1226  }
1227  return 0;
1228 }
1229 
1230 /**
1231  * Dirac Specification ->
1232  * 11.3 Wavelet transform data. wavelet_transform()
1233  */
1235 {
1236  GetBitContext *gb = &s->gb;
1237  int i, level;
1238  unsigned tmp;
1239 
1240 #define CHECKEDREAD(dst, cond, errmsg) \
1241  tmp = get_interleaved_ue_golomb(gb); \
1242  if (cond) { \
1243  av_log(s->avctx, AV_LOG_ERROR, errmsg); \
1244  return AVERROR_INVALIDDATA; \
1245  }\
1246  dst = tmp;
1247 
1248  align_get_bits(gb);
1249 
1250  s->zero_res = s->num_refs ? get_bits1(gb) : 0;
1251  if (s->zero_res)
1252  return 0;
1253 
1254  /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
1255  CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
1256 
1257  CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
1258 
1259  if (!s->low_delay) {
1260  /* Codeblock parameters (core syntax only) */
1261  if (get_bits1(gb)) {
1262  for (i = 0; i <= s->wavelet_depth; i++) {
1263  CHECKEDREAD(s->codeblock[i].width , tmp < 1 || tmp > (s->avctx->width >>s->wavelet_depth-i), "codeblock width invalid\n")
1264  CHECKEDREAD(s->codeblock[i].height, tmp < 1 || tmp > (s->avctx->height>>s->wavelet_depth-i), "codeblock height invalid\n")
1265  }
1266 
1267  CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
1268  }
1269  else {
1270  for (i = 0; i <= s->wavelet_depth; i++)
1271  s->codeblock[i].width = s->codeblock[i].height = 1;
1272  }
1273  }
1274  else {
1277  if (s->num_x * s->num_y == 0 || s->num_x * (uint64_t)s->num_y > INT_MAX ||
1278  s->num_x * (uint64_t)s->avctx->width > INT_MAX ||
1279  s->num_y * (uint64_t)s->avctx->height > INT_MAX
1280  ) {
1281  av_log(s->avctx,AV_LOG_ERROR,"Invalid numx/y\n");
1282  s->num_x = s->num_y = 0;
1283  return AVERROR_INVALIDDATA;
1284  }
1285  if (s->ld_picture) {
1288  if (s->lowdelay.bytes.den <= 0) {
1289  av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
1290  return AVERROR_INVALIDDATA;
1291  }
1292  } else if (s->hq_picture) {
1295  if (s->highquality.prefix_bytes >= INT_MAX / 8) {
1296  av_log(s->avctx,AV_LOG_ERROR,"too many prefix bytes\n");
1297  return AVERROR_INVALIDDATA;
1298  }
1299  }
1300 
1301  /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
1302  if (get_bits1(gb)) {
1303  av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
1304  /* custom quantization matrix */
1305  for (level = 0; level < s->wavelet_depth; level++) {
1306  for (i = !!level; i < 4; i++) {
1308  }
1309  }
1310  } else {
1311  if (s->wavelet_depth > 4) {
1312  av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1313  return AVERROR_INVALIDDATA;
1314  }
1315  /* default quantization matrix */
1316  for (level = 0; level < s->wavelet_depth; level++)
1317  for (i = 0; i < 4; i++) {
1319  /* haar with no shift differs for different depths */
1320  if (s->wavelet_idx == 3)
1321  s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1322  }
1323  }
1324  }
1325  return 0;
1326 }
1327 
1328 static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1329 {
1330  static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1331 
1332  if (!(x|y))
1333  return 0;
1334  else if (!y)
1335  return sbsplit[-1];
1336  else if (!x)
1337  return sbsplit[-stride];
1338 
1339  return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1340 }
1341 
1342 static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1343 {
1344  int pred;
1345 
1346  if (!(x|y))
1347  return 0;
1348  else if (!y)
1349  return block[-1].ref & refmask;
1350  else if (!x)
1351  return block[-stride].ref & refmask;
1352 
1353  /* return the majority */
1354  pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1355  return (pred >> 1) & refmask;
1356 }
1357 
1358 static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1359 {
1360  int i, n = 0;
1361 
1362  memset(block->u.dc, 0, sizeof(block->u.dc));
1363 
1364  if (x && !(block[-1].ref & 3)) {
1365  for (i = 0; i < 3; i++)
1366  block->u.dc[i] += block[-1].u.dc[i];
1367  n++;
1368  }
1369 
1370  if (y && !(block[-stride].ref & 3)) {
1371  for (i = 0; i < 3; i++)
1372  block->u.dc[i] += block[-stride].u.dc[i];
1373  n++;
1374  }
1375 
1376  if (x && y && !(block[-1-stride].ref & 3)) {
1377  for (i = 0; i < 3; i++)
1378  block->u.dc[i] += block[-1-stride].u.dc[i];
1379  n++;
1380  }
1381 
1382  if (n == 2) {
1383  for (i = 0; i < 3; i++)
1384  block->u.dc[i] = (block->u.dc[i]+1)>>1;
1385  } else if (n == 3) {
1386  for (i = 0; i < 3; i++)
1387  block->u.dc[i] = divide3(block->u.dc[i]);
1388  }
1389 }
1390 
1391 static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1392 {
1393  int16_t *pred[3];
1394  int refmask = ref+1;
1395  int mask = refmask | DIRAC_REF_MASK_GLOBAL; /* exclude gmc blocks */
1396  int n = 0;
1397 
1398  if (x && (block[-1].ref & mask) == refmask)
1399  pred[n++] = block[-1].u.mv[ref];
1400 
1401  if (y && (block[-stride].ref & mask) == refmask)
1402  pred[n++] = block[-stride].u.mv[ref];
1403 
1404  if (x && y && (block[-stride-1].ref & mask) == refmask)
1405  pred[n++] = block[-stride-1].u.mv[ref];
1406 
1407  switch (n) {
1408  case 0:
1409  block->u.mv[ref][0] = 0;
1410  block->u.mv[ref][1] = 0;
1411  break;
1412  case 1:
1413  block->u.mv[ref][0] = pred[0][0];
1414  block->u.mv[ref][1] = pred[0][1];
1415  break;
1416  case 2:
1417  block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1418  block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1419  break;
1420  case 3:
1421  block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1422  block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1423  break;
1424  }
1425 }
1426 
1427 static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1428 {
1429  int ez = s->globalmc[ref].zrs_exp;
1430  int ep = s->globalmc[ref].perspective_exp;
1431  int (*A)[2] = s->globalmc[ref].zrs;
1432  int *b = s->globalmc[ref].pan_tilt;
1433  int *c = s->globalmc[ref].perspective;
1434 
1435  int64_t m = (1<<ep) - (c[0]*(int64_t)x + c[1]*(int64_t)y);
1436  int64_t mx = m * (int64_t)((A[0][0] * (int64_t)x + A[0][1]*(int64_t)y) + (1LL<<ez) * b[0]);
1437  int64_t my = m * (int64_t)((A[1][0] * (int64_t)x + A[1][1]*(int64_t)y) + (1LL<<ez) * b[1]);
1438 
1439  block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1440  block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1441 }
1442 
1444  int stride, int x, int y)
1445 {
1446  int i;
1447 
1448  block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1449  block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1450 
1451  if (s->num_refs == 2) {
1452  block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1453  block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1454  }
1455 
1456  if (!block->ref) {
1457  pred_block_dc(block, stride, x, y);
1458  for (i = 0; i < 3; i++)
1459  block->u.dc[i] += (unsigned)dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1460  return;
1461  }
1462 
1463  if (s->globalmc_flag) {
1464  block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1465  block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1466  }
1467 
1468  for (i = 0; i < s->num_refs; i++)
1469  if (block->ref & (i+1)) {
1470  if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1471  global_mv(s, block, x, y, i);
1472  } else {
1473  pred_mv(block, stride, x, y, i);
1474  block->u.mv[i][0] += (unsigned)dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1475  block->u.mv[i][1] += (unsigned)dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1476  }
1477  }
1478 }
1479 
1480 /**
1481  * Copies the current block to the other blocks covered by the current superblock split mode
1482  */
1484 {
1485  int x, y;
1486  DiracBlock *dst = block;
1487 
1488  for (x = 1; x < size; x++)
1489  dst[x] = *block;
1490 
1491  for (y = 1; y < size; y++) {
1492  dst += stride;
1493  for (x = 0; x < size; x++)
1494  dst[x] = *block;
1495  }
1496 }
1497 
1498 /**
1499  * Dirac Specification ->
1500  * 12. Block motion data syntax
1501  */
1503 {
1504  GetBitContext *gb = &s->gb;
1505  uint8_t *sbsplit = s->sbsplit;
1506  int i, x, y, q, p;
1507  DiracArith arith[8];
1508 
1509  align_get_bits(gb);
1510 
1511  /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1512  s->sbwidth = DIVRNDUP(s->seq.width, 4*s->plane[0].xbsep);
1513  s->sbheight = DIVRNDUP(s->seq.height, 4*s->plane[0].ybsep);
1514  s->blwidth = 4 * s->sbwidth;
1515  s->blheight = 4 * s->sbheight;
1516 
1517  /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1518  decode superblock split modes */
1519  ff_dirac_init_arith_decoder(arith, gb, get_interleaved_ue_golomb(gb)); /* get_interleaved_ue_golomb(gb) is the length */
1520  for (y = 0; y < s->sbheight; y++) {
1521  for (x = 0; x < s->sbwidth; x++) {
1522  unsigned int split = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1523  if (split > 2)
1524  return AVERROR_INVALIDDATA;
1525  sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1526  }
1527  sbsplit += s->sbwidth;
1528  }
1529 
1530  /* setup arith decoding */
1532  for (i = 0; i < s->num_refs; i++) {
1533  ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, get_interleaved_ue_golomb(gb));
1534  ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, get_interleaved_ue_golomb(gb));
1535  }
1536  for (i = 0; i < 3; i++)
1538 
1539  for (y = 0; y < s->sbheight; y++)
1540  for (x = 0; x < s->sbwidth; x++) {
1541  int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1542  int step = 4 >> s->sbsplit[y * s->sbwidth + x];
1543 
1544  for (q = 0; q < blkcnt; q++)
1545  for (p = 0; p < blkcnt; p++) {
1546  int bx = 4 * x + p*step;
1547  int by = 4 * y + q*step;
1548  DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1549  decode_block_params(s, arith, block, s->blwidth, bx, by);
1550  propagate_block_data(block, s->blwidth, step);
1551  }
1552  }
1553 
1554  for (i = 0; i < 4 + 2*s->num_refs; i++) {
1555  if (arith[i].error)
1556  return arith[i].error;
1557  }
1558 
1559  return 0;
1560 }
1561 
1562 static int weight(int i, int blen, int offset)
1563 {
1564 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \
1565  (1 + (6*(i) + offset - 1) / (2*offset - 1))
1566 
1567  if (i < 2*offset)
1568  return ROLLOFF(i);
1569  else if (i > blen-1 - 2*offset)
1570  return ROLLOFF(blen-1 - i);
1571  return 8;
1572 }
1573 
1574 static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1575  int left, int right, int wy)
1576 {
1577  int x;
1578  for (x = 0; left && x < p->xblen >> 1; x++)
1579  obmc_weight[x] = wy*8;
1580  for (; x < p->xblen >> right; x++)
1581  obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1582  for (; x < p->xblen; x++)
1583  obmc_weight[x] = wy*8;
1584  for (; x < stride; x++)
1585  obmc_weight[x] = 0;
1586 }
1587 
1588 static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1589  int left, int right, int top, int bottom)
1590 {
1591  int y;
1592  for (y = 0; top && y < p->yblen >> 1; y++) {
1593  init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1594  obmc_weight += stride;
1595  }
1596  for (; y < p->yblen >> bottom; y++) {
1597  int wy = weight(y, p->yblen, p->yoffset);
1598  init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1599  obmc_weight += stride;
1600  }
1601  for (; y < p->yblen; y++) {
1602  init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1603  obmc_weight += stride;
1604  }
1605 }
1606 
1607 static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1608 {
1609  int top = !by;
1610  int bottom = by == s->blheight-1;
1611 
1612  /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1613  if (top || bottom || by == 1) {
1614  init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1615  init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1616  init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1617  }
1618 }
1619 
1620 static const uint8_t epel_weights[4][4][4] = {
1621  {{ 16, 0, 0, 0 },
1622  { 12, 4, 0, 0 },
1623  { 8, 8, 0, 0 },
1624  { 4, 12, 0, 0 }},
1625  {{ 12, 0, 4, 0 },
1626  { 9, 3, 3, 1 },
1627  { 6, 6, 2, 2 },
1628  { 3, 9, 1, 3 }},
1629  {{ 8, 0, 8, 0 },
1630  { 6, 2, 6, 2 },
1631  { 4, 4, 4, 4 },
1632  { 2, 6, 2, 6 }},
1633  {{ 4, 0, 12, 0 },
1634  { 3, 1, 9, 3 },
1635  { 2, 2, 6, 6 },
1636  { 1, 3, 3, 9 }}
1637 };
1638 
1639 /**
1640  * For block x,y, determine which of the hpel planes to do bilinear
1641  * interpolation from and set src[] to the location in each hpel plane
1642  * to MC from.
1643  *
1644  * @return the index of the put_dirac_pixels_tab function to use
1645  * 0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1646  */
1648  int x, int y, int ref, int plane)
1649 {
1650  Plane *p = &s->plane[plane];
1651  uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1652  int motion_x = block->u.mv[ref][0];
1653  int motion_y = block->u.mv[ref][1];
1654  int mx, my, i, epel, nplanes = 0;
1655 
1656  if (plane) {
1657  motion_x >>= s->chroma_x_shift;
1658  motion_y >>= s->chroma_y_shift;
1659  }
1660 
1661  mx = motion_x & ~(-1U << s->mv_precision);
1662  my = motion_y & ~(-1U << s->mv_precision);
1663  motion_x >>= s->mv_precision;
1664  motion_y >>= s->mv_precision;
1665  /* normalize subpel coordinates to epel */
1666  /* TODO: template this function? */
1667  mx <<= 3 - s->mv_precision;
1668  my <<= 3 - s->mv_precision;
1669 
1670  x += motion_x;
1671  y += motion_y;
1672  epel = (mx|my)&1;
1673 
1674  /* hpel position */
1675  if (!((mx|my)&3)) {
1676  nplanes = 1;
1677  src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1678  } else {
1679  /* qpel or epel */
1680  nplanes = 4;
1681  for (i = 0; i < 4; i++)
1682  src[i] = ref_hpel[i] + y*p->stride + x;
1683 
1684  /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1685  we increment x/y because the edge changes for half of the pixels */
1686  if (mx > 4) {
1687  src[0] += 1;
1688  src[2] += 1;
1689  x++;
1690  }
1691  if (my > 4) {
1692  src[0] += p->stride;
1693  src[1] += p->stride;
1694  y++;
1695  }
1696 
1697  /* hpel planes are:
1698  [0]: F [1]: H
1699  [2]: V [3]: C */
1700  if (!epel) {
1701  /* check if we really only need 2 planes since either mx or my is
1702  a hpel position. (epel weights of 0 handle this there) */
1703  if (!(mx&3)) {
1704  /* mx == 0: average [0] and [2]
1705  mx == 4: average [1] and [3] */
1706  src[!mx] = src[2 + !!mx];
1707  nplanes = 2;
1708  } else if (!(my&3)) {
1709  src[0] = src[(my>>1) ];
1710  src[1] = src[(my>>1)+1];
1711  nplanes = 2;
1712  }
1713  } else {
1714  /* adjust the ordering if needed so the weights work */
1715  if (mx > 4) {
1716  FFSWAP(const uint8_t *, src[0], src[1]);
1717  FFSWAP(const uint8_t *, src[2], src[3]);
1718  }
1719  if (my > 4) {
1720  FFSWAP(const uint8_t *, src[0], src[2]);
1721  FFSWAP(const uint8_t *, src[1], src[3]);
1722  }
1723  src[4] = epel_weights[my&3][mx&3];
1724  }
1725  }
1726 
1727  /* fixme: v/h _edge_pos */
1728  if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1729  y + p->yblen > p->height+EDGE_WIDTH/2 ||
1730  x < 0 || y < 0) {
1731  for (i = 0; i < nplanes; i++) {
1732  s->vdsp.emulated_edge_mc(s->edge_emu_buffer[i], src[i],
1733  p->stride, p->stride,
1734  p->xblen, p->yblen, x, y,
1735  p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1736  src[i] = s->edge_emu_buffer[i];
1737  }
1738  }
1739  return (nplanes>>1) + epel;
1740 }
1741 
1742 static void add_dc(uint16_t *dst, int dc, int stride,
1743  uint8_t *obmc_weight, int xblen, int yblen)
1744 {
1745  int x, y;
1746  dc += 128;
1747 
1748  for (y = 0; y < yblen; y++) {
1749  for (x = 0; x < xblen; x += 2) {
1750  dst[x ] += dc * obmc_weight[x ];
1751  dst[x+1] += dc * obmc_weight[x+1];
1752  }
1753  dst += stride;
1754  obmc_weight += MAX_BLOCKSIZE;
1755  }
1756 }
1757 
1759  uint16_t *mctmp, uint8_t *obmc_weight,
1760  int plane, int dstx, int dsty)
1761 {
1762  Plane *p = &s->plane[plane];
1763  const uint8_t *src[5];
1764  int idx;
1765 
1766  switch (block->ref&3) {
1767  case 0: /* DC */
1768  add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1769  return;
1770  case 1:
1771  case 2:
1772  idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1773  s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1774  if (s->weight_func)
1776  s->weight[0] + s->weight[1], p->yblen);
1777  break;
1778  case 3:
1779  idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1780  s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1781  idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1782  if (s->biweight_func) {
1783  /* fixme: +32 is a quick hack */
1784  s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1786  s->weight[0], s->weight[1], p->yblen);
1787  } else
1788  s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1789  break;
1790  }
1791  s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1792 }
1793 
1794 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1795 {
1796  Plane *p = &s->plane[plane];
1797  int x, dstx = p->xbsep - p->xoffset;
1798 
1799  block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1800  mctmp += p->xbsep;
1801 
1802  for (x = 1; x < s->blwidth-1; x++) {
1803  block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1804  dstx += p->xbsep;
1805  mctmp += p->xbsep;
1806  }
1807  block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1808 }
1809 
1810 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1811 {
1812  int idx = 0;
1813  if (xblen > 8)
1814  idx = 1;
1815  if (xblen > 16)
1816  idx = 2;
1817 
1818  memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1819  memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1820  s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1821  if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1824  } else {
1825  s->weight_func = NULL;
1826  s->biweight_func = NULL;
1827  }
1828 }
1829 
1831 {
1832  /* chroma allocates an edge of 8 when subsampled
1833  which for 4:2:2 means an h edge of 16 and v edge of 8
1834  just use 8 for everything for the moment */
1835  int i, edge = EDGE_WIDTH/2;
1836 
1837  ref->hpel[plane][0] = ref->avframe->data[plane];
1838  s->mpvencdsp.draw_edges(ref->hpel[plane][0], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM); /* EDGE_TOP | EDGE_BOTTOM values just copied to make it build, this needs to be ensured */
1839 
1840  /* no need for hpel if we only have fpel vectors */
1841  if (!s->mv_precision)
1842  return 0;
1843 
1844  for (i = 1; i < 4; i++) {
1845  if (!ref->hpel_base[plane][i])
1846  ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
1847  if (!ref->hpel_base[plane][i]) {
1848  return AVERROR(ENOMEM);
1849  }
1850  /* we need to be 16-byte aligned even for chroma */
1851  ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
1852  }
1853 
1854  if (!ref->interpolated[plane]) {
1855  s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1856  ref->hpel[plane][3], ref->hpel[plane][0],
1857  ref->avframe->linesize[plane], width, height);
1858  s->mpvencdsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1859  s->mpvencdsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1860  s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1861  }
1862  ref->interpolated[plane] = 1;
1863 
1864  return 0;
1865 }
1866 
1867 /**
1868  * Dirac Specification ->
1869  * 13.0 Transform data syntax. transform_data()
1870  */
1872 {
1873  DWTContext d;
1874  int y, i, comp, dsty;
1875  int ret;
1876 
1877  if (s->low_delay) {
1878  /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1879  if (!s->hq_picture) {
1880  for (comp = 0; comp < 3; comp++) {
1881  Plane *p = &s->plane[comp];
1882  memset(p->idwt.buf, 0, p->idwt.stride * p->idwt.height);
1883  }
1884  }
1885  if (!s->zero_res) {
1886  if ((ret = decode_lowdelay(s)) < 0)
1887  return ret;
1888  }
1889  }
1890 
1891  for (comp = 0; comp < 3; comp++) {
1892  Plane *p = &s->plane[comp];
1894 
1895  /* FIXME: small resolutions */
1896  for (i = 0; i < 4; i++)
1897  s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1898 
1899  if (!s->zero_res && !s->low_delay)
1900  {
1901  memset(p->idwt.buf, 0, p->idwt.stride * p->idwt.height);
1902  ret = decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1903  if (ret < 0)
1904  return ret;
1905  }
1906  ret = ff_spatial_idwt_init(&d, &p->idwt, s->wavelet_idx+2,
1907  s->wavelet_depth, s->bit_depth);
1908  if (ret < 0)
1909  return ret;
1910 
1911  if (!s->num_refs) { /* intra */
1912  for (y = 0; y < p->height; y += 16) {
1913  int idx = (s->bit_depth - 8) >> 1;
1914  ff_spatial_idwt_slice2(&d, y+16); /* decode */
1915  s->diracdsp.put_signed_rect_clamped[idx](frame + y*p->stride,
1916  p->stride,
1917  p->idwt.buf + y*p->idwt.stride,
1918  p->idwt.stride, p->width, 16);
1919  }
1920  } else { /* inter */
1921  int rowheight = p->ybsep*p->stride;
1922 
1923  select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1924 
1925  for (i = 0; i < s->num_refs; i++) {
1926  int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1927  if (ret < 0)
1928  return ret;
1929  }
1930 
1931  memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1932 
1933  dsty = -p->yoffset;
1934  for (y = 0; y < s->blheight; y++) {
1935  int h = 0,
1936  start = FFMAX(dsty, 0);
1937  uint16_t *mctmp = s->mctmp + y*rowheight;
1938  DiracBlock *blocks = s->blmotion + y*s->blwidth;
1939 
1940  init_obmc_weights(s, p, y);
1941 
1942  if (y == s->blheight-1 || start+p->ybsep > p->height)
1943  h = p->height - start;
1944  else
1945  h = p->ybsep - (start - dsty);
1946  if (h < 0)
1947  break;
1948 
1949  memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1950  mc_row(s, blocks, mctmp, comp, dsty);
1951 
1952  mctmp += (start - dsty)*p->stride + p->xoffset;
1953  ff_spatial_idwt_slice2(&d, start + h); /* decode */
1954  /* NOTE: add_rect_clamped hasn't been templated hence the shifts.
1955  * idwt.stride is passed as pixels, not in bytes as in the rest of the decoder */
1956  s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1957  (int16_t*)(p->idwt.buf) + start*(p->idwt.stride >> 1), (p->idwt.stride >> 1), p->width, h);
1958 
1959  dsty += p->ybsep;
1960  }
1961  }
1962  }
1963 
1964 
1965  return 0;
1966 }
1967 
1969 {
1970  int ret, i;
1971  int chroma_x_shift, chroma_y_shift;
1972  ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift,
1973  &chroma_y_shift);
1974  if (ret < 0)
1975  return ret;
1976 
1977  f->width = avctx->width + 2 * EDGE_WIDTH;
1978  f->height = avctx->height + 2 * EDGE_WIDTH + 2;
1979  ret = ff_get_buffer(avctx, f, flags);
1980  if (ret < 0)
1981  return ret;
1982 
1983  for (i = 0; f->data[i]; i++) {
1984  int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) *
1985  f->linesize[i] + 32;
1986  f->data[i] += offset;
1987  }
1988  f->width = avctx->width;
1989  f->height = avctx->height;
1990 
1991  return 0;
1992 }
1993 
1994 /**
1995  * Dirac Specification ->
1996  * 11.1.1 Picture Header. picture_header()
1997  */
1999 {
2000  unsigned retire, picnum;
2001  int i, j, ret;
2002  int64_t refdist, refnum;
2003  GetBitContext *gb = &s->gb;
2004 
2005  /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
2007 
2008 
2009  av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
2010 
2011  /* if this is the first keyframe after a sequence header, start our
2012  reordering from here */
2013  if (s->frame_number < 0)
2014  s->frame_number = picnum;
2015 
2016  s->ref_pics[0] = s->ref_pics[1] = NULL;
2017  for (i = 0; i < s->num_refs; i++) {
2018  refnum = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
2019  refdist = INT64_MAX;
2020 
2021  /* find the closest reference to the one we want */
2022  /* Jordi: this is needed if the referenced picture hasn't yet arrived */
2023  for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
2024  if (s->ref_frames[j]
2025  && FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) {
2026  s->ref_pics[i] = s->ref_frames[j];
2027  refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum);
2028  }
2029 
2030  if (!s->ref_pics[i] || refdist)
2031  av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
2032 
2033  /* if there were no references at all, allocate one */
2034  if (!s->ref_pics[i])
2035  for (j = 0; j < MAX_FRAMES; j++)
2036  if (!s->all_frames[j].avframe->data[0]) {
2037  s->ref_pics[i] = &s->all_frames[j];
2039  if (ret < 0)
2040  return ret;
2041  break;
2042  }
2043 
2044  if (!s->ref_pics[i]) {
2045  av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n");
2046  return AVERROR_INVALIDDATA;
2047  }
2048 
2049  }
2050 
2051  /* retire the reference frames that are not used anymore */
2052  if (s->current_picture->reference) {
2053  retire = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
2054  if (retire != picnum) {
2055  DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
2056 
2057  if (retire_pic)
2058  retire_pic->reference &= DELAYED_PIC_REF;
2059  else
2060  av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
2061  }
2062 
2063  /* if reference array is full, remove the oldest as per the spec */
2065  av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
2067  }
2068  }
2069 
2070  if (s->num_refs) {
2071  ret = dirac_unpack_prediction_parameters(s); /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
2072  if (ret < 0)
2073  return ret;
2074  ret = dirac_unpack_block_motion_data(s); /* [DIRAC_STD] 12. Block motion data syntax */
2075  if (ret < 0)
2076  return ret;
2077  }
2078  ret = dirac_unpack_idwt_params(s); /* [DIRAC_STD] 11.3 Wavelet transform data */
2079  if (ret < 0)
2080  return ret;
2081 
2082  init_planes(s);
2083  return 0;
2084 }
2085 
2086 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
2087 {
2088  DiracFrame *out = s->delay_frames[0];
2089  int i, out_idx = 0;
2090  int ret;
2091 
2092  /* find frame with lowest picture number */
2093  for (i = 1; s->delay_frames[i]; i++)
2095  out = s->delay_frames[i];
2096  out_idx = i;
2097  }
2098 
2099  for (i = out_idx; s->delay_frames[i]; i++)
2100  s->delay_frames[i] = s->delay_frames[i+1];
2101 
2102  if (out) {
2103  out->reference ^= DELAYED_PIC_REF;
2104  if((ret = av_frame_ref(picture, out->avframe)) < 0)
2105  return ret;
2106  *got_frame = 1;
2107  }
2108 
2109  return 0;
2110 }
2111 
2112 /**
2113  * Dirac Specification ->
2114  * 9.6 Parse Info Header Syntax. parse_info()
2115  * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
2116  */
2117 #define DATA_UNIT_HEADER_SIZE 13
2118 
2119 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
2120  inside the function parse_sequence() */
2121 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
2122 {
2123  DiracContext *s = avctx->priv_data;
2124  DiracFrame *pic = NULL;
2125  AVDiracSeqHeader *dsh;
2126  int ret, i;
2127  uint8_t parse_code;
2128  unsigned tmp;
2129 
2130  if (size < DATA_UNIT_HEADER_SIZE)
2131  return AVERROR_INVALIDDATA;
2132 
2133  parse_code = buf[4];
2134 
2135  init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
2136 
2137  if (parse_code == DIRAC_PCODE_SEQ_HEADER) {
2138  if (s->seen_sequence_header)
2139  return 0;
2140 
2141  /* [DIRAC_STD] 10. Sequence header */
2143  if (ret < 0) {
2144  av_log(avctx, AV_LOG_ERROR, "error parsing sequence header");
2145  return ret;
2146  }
2147 
2148  if (CALC_PADDING((int64_t)dsh->width, MAX_DWT_LEVELS) * CALC_PADDING((int64_t)dsh->height, MAX_DWT_LEVELS) * 5LL > avctx->max_pixels)
2149  ret = AVERROR(ERANGE);
2150  if (ret >= 0)
2151  ret = ff_set_dimensions(avctx, dsh->width, dsh->height);
2152  if (ret < 0) {
2153  av_freep(&dsh);
2154  return ret;
2155  }
2156 
2157  ff_set_sar(avctx, dsh->sample_aspect_ratio);
2158  avctx->pix_fmt = dsh->pix_fmt;
2159  avctx->color_range = dsh->color_range;
2160  avctx->color_trc = dsh->color_trc;
2161  avctx->color_primaries = dsh->color_primaries;
2162  avctx->colorspace = dsh->colorspace;
2163  avctx->profile = dsh->profile;
2164  avctx->level = dsh->level;
2165  avctx->framerate = dsh->framerate;
2166  s->bit_depth = dsh->bit_depth;
2167  s->version.major = dsh->version.major;
2168  s->version.minor = dsh->version.minor;
2169  s->seq = *dsh;
2170  av_freep(&dsh);
2171 
2172  s->pshift = s->bit_depth > 8;
2173 
2175  &s->chroma_x_shift,
2176  &s->chroma_y_shift);
2177  if (ret < 0)
2178  return ret;
2179 
2180  ret = alloc_sequence_buffers(s);
2181  if (ret < 0)
2182  return ret;
2183 
2184  s->seen_sequence_header = 1;
2185  } else if (parse_code == DIRAC_PCODE_END_SEQ) { /* [DIRAC_STD] End of Sequence */
2187  s->seen_sequence_header = 0;
2188  } else if (parse_code == DIRAC_PCODE_AUX) {
2189  if (buf[13] == 1) { /* encoder implementation/version */
2190  int ver[3];
2191  /* versions older than 1.0.8 don't store quant delta for
2192  subbands with only one codeblock */
2193  if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
2194  if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
2195  s->old_delta_quant = 1;
2196  }
2197  } else if (parse_code & 0x8) { /* picture data unit */
2198  if (!s->seen_sequence_header) {
2199  av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
2200  return AVERROR_INVALIDDATA;
2201  }
2202 
2203  /* find an unused frame */
2204  for (i = 0; i < MAX_FRAMES; i++)
2205  if (s->all_frames[i].avframe->data[0] == NULL)
2206  pic = &s->all_frames[i];
2207  if (!pic) {
2208  av_log(avctx, AV_LOG_ERROR, "framelist full\n");
2209  return AVERROR_INVALIDDATA;
2210  }
2211 
2212  av_frame_unref(pic->avframe);
2213 
2214  /* [DIRAC_STD] Defined in 9.6.1 ... */
2215  tmp = parse_code & 0x03; /* [DIRAC_STD] num_refs() */
2216  if (tmp > 2) {
2217  av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
2218  return AVERROR_INVALIDDATA;
2219  }
2220  s->num_refs = tmp;
2221  s->is_arith = (parse_code & 0x48) == 0x08; /* [DIRAC_STD] using_ac() */
2222  s->low_delay = (parse_code & 0x88) == 0x88; /* [DIRAC_STD] is_low_delay() */
2223  s->core_syntax = (parse_code & 0x88) == 0x08; /* [DIRAC_STD] is_core_syntax() */
2224  s->ld_picture = (parse_code & 0xF8) == 0xC8; /* [DIRAC_STD] is_ld_picture() */
2225  s->hq_picture = (parse_code & 0xF8) == 0xE8; /* [DIRAC_STD] is_hq_picture() */
2226  s->dc_prediction = (parse_code & 0x28) == 0x08; /* [DIRAC_STD] using_dc_prediction() */
2227  pic->reference = (parse_code & 0x0C) == 0x0C; /* [DIRAC_STD] is_reference() */
2228  pic->avframe->key_frame = s->num_refs == 0; /* [DIRAC_STD] is_intra() */
2229  pic->avframe->pict_type = s->num_refs + 1; /* Definition of AVPictureType in avutil.h */
2230 
2231  /* VC-2 Low Delay has a different parse code than the Dirac Low Delay */
2232  if (s->version.minor == 2 && parse_code == 0x88)
2233  s->ld_picture = 1;
2234 
2235  if (s->low_delay && !(s->ld_picture || s->hq_picture) ) {
2236  av_log(avctx, AV_LOG_ERROR, "Invalid low delay flag\n");
2237  return AVERROR_INVALIDDATA;
2238  }
2239 
2240  if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
2241  return ret;
2242  s->current_picture = pic;
2243  s->plane[0].stride = pic->avframe->linesize[0];
2244  s->plane[1].stride = pic->avframe->linesize[1];
2245  s->plane[2].stride = pic->avframe->linesize[2];
2246 
2247  if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0)
2248  return AVERROR(ENOMEM);
2249 
2250  /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
2251  ret = dirac_decode_picture_header(s);
2252  if (ret < 0)
2253  return ret;
2254 
2255  /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
2256  ret = dirac_decode_frame_internal(s);
2257  if (ret < 0)
2258  return ret;
2259  }
2260  return 0;
2261 }
2262 
2263 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
2264 {
2265  DiracContext *s = avctx->priv_data;
2266  AVFrame *picture = data;
2267  uint8_t *buf = pkt->data;
2268  int buf_size = pkt->size;
2269  int i, buf_idx = 0;
2270  int ret;
2271  unsigned data_unit_size;
2272 
2273  /* release unused frames */
2274  for (i = 0; i < MAX_FRAMES; i++)
2275  if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].reference) {
2277  memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
2278  }
2279 
2280  s->current_picture = NULL;
2281  *got_frame = 0;
2282 
2283  /* end of stream, so flush delayed pics */
2284  if (buf_size == 0)
2285  return get_delayed_pic(s, (AVFrame *)data, got_frame);
2286 
2287  for (;;) {
2288  /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
2289  [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
2290  BBCD start code search */
2291  for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
2292  if (buf[buf_idx ] == 'B' && buf[buf_idx+1] == 'B' &&
2293  buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
2294  break;
2295  }
2296  /* BBCD found or end of data */
2297  if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
2298  break;
2299 
2300  data_unit_size = AV_RB32(buf+buf_idx+5);
2301  if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
2302  if(data_unit_size > buf_size - buf_idx)
2304  "Data unit with size %d is larger than input buffer, discarding\n",
2305  data_unit_size);
2306  buf_idx += 4;
2307  continue;
2308  }
2309  /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
2310  ret = dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size);
2311  if (ret < 0)
2312  {
2313  av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
2314  return ret;
2315  }
2316  buf_idx += data_unit_size;
2317  }
2318 
2319  if (!s->current_picture)
2320  return buf_size;
2321 
2323  DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
2324 
2326 
2328  int min_num = s->delay_frames[0]->avframe->display_picture_number;
2329  /* Too many delayed frames, so we display the frame with the lowest pts */
2330  av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
2331 
2332  for (i = 1; s->delay_frames[i]; i++)
2333  if (s->delay_frames[i]->avframe->display_picture_number < min_num)
2334  min_num = s->delay_frames[i]->avframe->display_picture_number;
2335 
2336  delayed_frame = remove_frame(s->delay_frames, min_num);
2338  }
2339 
2340  if (delayed_frame) {
2341  delayed_frame->reference ^= DELAYED_PIC_REF;
2342  if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0)
2343  return ret;
2344  *got_frame = 1;
2345  }
2347  /* The right frame at the right time :-) */
2348  if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0)
2349  return ret;
2350  *got_frame = 1;
2351  }
2352 
2353  if (*got_frame)
2354  s->frame_number = picture->display_picture_number + 1LL;
2355 
2356  return buf_idx;
2357 }
2358 
2360  .name = "dirac",
2361  .long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
2362  .type = AVMEDIA_TYPE_VIDEO,
2363  .id = AV_CODEC_ID_DIRAC,
2364  .priv_data_size = sizeof(DiracContext),
2366  .close = dirac_decode_end,
2369  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
2371 };
#define CHECKEDREAD(dst, cond, errmsg)
int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf, int bytes, uint8_t *_dst, int coeffs)
Definition: dirac_vlc.c:42
int quant
Definition: cfhd.h:53
int plane
Definition: avisynth_c.h:384
uint8_t * thread_buf
Definition: diracdec.c:176
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
#define NULL
Definition: coverity.c:32
#define UNPACK_ARITH(n, type)
Definition: diracdec.c:454
AVRational framerate
Definition: avcodec.h:3101
const char const char void * val
Definition: avisynth_c.h:863
const int32_t ff_dirac_qscale_tab[116]
Definition: diractab.c:34
#define PARSE_VALUES(type, x, gb, ebits, buf1, buf2)
Definition: diracdec.c:714
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int blheight
Definition: diracdec.c:212
static av_cold int dirac_decode_end(AVCodecContext *avctx)
Definition: diracdec.c:426
struct DiracContext::@76 lowdelay
enum AVColorRange color_range
Definition: dirac.h:107
#define av_realloc_f(p, o, n)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
dirac_weight_func weight_func
Definition: diracdec.c:231
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
uint8_t * sbsplit
Definition: diracdec.c:216
#define CTX_SB_DATA
Definition: dirac_arith.h:66
#define CTX_PMODE_REF2
Definition: dirac_arith.h:68
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
enum AVColorTransferCharacteristic color_trc
Definition: dirac.h:109
DiracFrame * ref_frames[MAX_REFERENCE_FRAMES+1]
Definition: diracdec.c:237
static int divide3(int x)
Definition: diracdec.c:251
struct DiracContext::@78 globalmc[2]
static int dirac_decode_frame_internal(DiracContext *s)
Dirac Specification -> 13.0 Transform data syntax.
Definition: diracdec.c:1871
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
DiracVersionInfo version
Definition: dirac.h:112
int ld_picture
Definition: diracdec.c:157
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int bit_depth
Definition: diracdec.c:149
static void propagate_block_data(DiracBlock *block, int stride, int size)
Copies the current block to the other blocks covered by the current superblock split mode...
Definition: diracdec.c:1483
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2196
dirac_weight_func weight_dirac_pixels_tab[3]
Definition: diracdsp.h:53
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output...
Definition: diracdec.c:67
void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length)
Definition: dirac_arith.c:96
static int subband_coeffs(DiracContext *s, int x, int y, int p, SliceCoeffs c[MAX_DWT_LEVELS])
Definition: diracdec.c:824
unsigned width
Definition: diracdec.c:184
#define DATA_UNIT_HEADER_SIZE
Dirac Specification -> 9.6 Parse Info Header Syntax.
Definition: diracdec.c:2117
const uint8_t * buffer
Definition: get_bits.h:62
int av_log2(unsigned v)
Definition: intmath.c:26
uint8_t * buf
Definition: dirac_dwt.h:41
uint8_t yoffset
Definition: diracdec.c:121
void(* add_rect_clamped)(uint8_t *dst, const uint16_t *src, int stride, const int16_t *idwt, int idwt_stride, int width, int height)
Definition: diracdsp.h:47
static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
Definition: diracdec.c:1427
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
GetBitContext gb
Definition: diracdec.c:128
static int dirac_get_arith_uint(DiracArith *c, int follow_ctx, int data_ctx)
Definition: dirac_arith.h:175
static int alloc_buffers(DiracContext *s, int stride)
Definition: diracdec.c:323
int ff_dirac_golomb_read_16bit(DiracGolombLUT *lut_ctx, const uint8_t *buf, int bytes, uint8_t *_dst, int coeffs)
Definition: dirac_vlc.c:82
mpegvideo header.
DiracVersionInfo version
Definition: diracdec.c:140
ptrdiff_t stride
Definition: cfhd.h:47
unsigned height
Definition: diracdec.c:185
static AVPacket pkt
#define EDGE_TOP
static void dirac_decode_flush(AVCodecContext *avctx)
Definition: diracdec.c:418
const uint8_t * coeff_data
Definition: diracdec.c:103
#define src
Definition: vp8dsp.c:254
static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
Definition: diracdec.c:2086
static int dirac_unpack_idwt_params(DiracContext *s)
Dirac Specification -> 11.3 Wavelet transform data.
Definition: diracdec.c:1234
int profile
profile
Definition: avcodec.h:2894
#define DIRAC_REF_MASK_REF2
Definition: diracdec.c:60
AVCodec.
Definition: avcodec.h:3477
int zrs[2][2]
Definition: diracdec.c:200
static int decode_hq_slice(DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf)
VC-2 Specification -> 13.5.3 hq_slice(sx,sy)
Definition: diracdec.c:845
unsigned codeblock_mode
Definition: diracdec.c:171
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int num_refs
Definition: diracdec.c:160
int av_dirac_parse_sequence_header(AVDiracSeqHeader **pdsh, const uint8_t *buf, size_t buf_size, void *log_ctx)
Parse a Dirac sequence header.
Definition: dirac.c:402
uint8_t xoffset
Definition: diracdec.c:120
uint8_t * tmp
Definition: dirac_dwt.h:43
unsigned weight_log2denom
Definition: diracdec.c:209
#define CTX_GLOBAL_BLOCK
Definition: dirac_arith.h:69
int width
Definition: cfhd.h:49
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1006
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
DiracFrame * delay_frames[MAX_DELAY+1]
Definition: diracdec.c:238
uint8_t * mcscratch
Definition: diracdec.c:223
int dc_prediction
Definition: diracdec.c:158
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
unsigned wavelet_idx
Definition: diracdec.c:164
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
Interface to Dirac Decoder/Encoder.
#define CTX_PMODE_REF1
Definition: dirac_arith.h:67
static int decode_component(DiracContext *s, int comp)
Dirac Specification -> [DIRAC_STD] 13.4.1 core_transform_data()
Definition: diracdec.c:660
static int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
Definition: diracdec.c:443
#define DIVRNDUP(a, b)
Definition: diracdec.c:72
int hq_picture
Definition: diracdec.c:156
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int dirac_decode_init(AVCodecContext *avctx)
Definition: diracdec.c:386
uint8_t quant[MAX_DWT_LEVELS][4]
Definition: diracdec.c:190
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
unsigned prefix_bytes
Definition: diracdec.c:194
AVRational sample_aspect_ratio
Definition: dirac.h:104
unsigned num_x
Definition: diracdec.c:173
int low_delay
Definition: diracdec.c:155
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
Plane plane[3]
Definition: diracdec.c:145
static int dirac_get_se_golomb(GetBitContext *gb)
Definition: golomb.h:359
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
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_RB32
Definition: bytestream.h:87
DiracSlice * slice_params_buf
Definition: diracdec.c:180
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
static AVOnce dirac_arith_init
Definition: diracdec.c:384
uint8_t * data
Definition: avcodec.h:1477
static void free_sequence_buffers(DiracContext *s)
Definition: diracdec.c:352
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:119
int height
Definition: dirac_dwt.h:39
bitstream reader API header.
static const uint8_t epel_weights[4][4][4]
Definition: diracdec.c:1620
ptrdiff_t size
Definition: opengl_enc.c:100
uint8_t xblen
Definition: diracdec.c:114
static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
Dirac Specification -> 13.5.2 Slices.
Definition: diracdec.c:778
#define CTX_DC_DATA
Definition: dirac_arith.h:73
#define AVOnce
Definition: thread.h:159
#define A(x)
Definition: vp56_arith.h:28
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
unsigned x
Definition: pixlet.c:45
Definition: cfhd.h:44
void(* avg_dirac_pixels_tab[3][4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
Definition: diracdsp.h:43
static void pred_block_dc(DiracBlock *block, int stride, int x, int y)
Definition: diracdec.c:1358
AVRational framerate
Definition: dirac.h:103
int pan_tilt[2]
Definition: diracdec.c:199
int interpolated[3]
Definition: diracdec.c:76
#define EDGE_WIDTH
Definition: mpegpicture.h:33
#define ROLLOFF(i)
#define U(x)
Definition: vp56_arith.h:37
av_cold int ff_dirac_golomb_reader_init(DiracGolombLUT **lut_ctx)
Definition: dirac_vlc.c:232
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
dirac_subband
Definition: diracdec.c:242
const int32_t ff_dirac_qoffset_intra_tab[120]
Definition: diractab.c:53
av_cold void ff_diracdsp_init(DiracDSPContext *c)
Definition: diracdsp.c:219
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
unsigned length
Definition: diracdec.c:102
static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
Definition: diracdec.c:2263
uint8_t * hpel[3][4]
Definition: diracdec.c:77
int slice_x
Definition: diracdec.c:129
static const uint16_t mask[17]
Definition: lzw.c:38
uint16_t * mctmp
Definition: diracdec.c:222
static av_always_inline int decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
Dirac Specification -> 13.4.2 Non-skipped subbands.
Definition: diracdec.c:601
void(* add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen)
Definition: diracdec.c:230
#define DIRAC_REF_MASK_GLOBAL
Definition: diracdec.c:61
int width
Definition: dirac_dwt.h:38
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
static int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
Definition: diracdec.c:1328
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:2550
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
Definition: diracdec.c:274
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: diracdec.c:1391
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * arg
Definition: jacosubdec.c:66
const uint8_t ff_dirac_default_qmat[7][4][4]
Definition: diractab.c:24
unsigned num_y
Definition: diracdec.c:174
static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
Definition: diracdec.c:1830
static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5], int x, int y, int ref, int plane)
For block x,y, determine which of the hpel planes to do bilinear interpolation from and set src[] to ...
Definition: diracdec.c:1647
unsigned wavelet_depth
Definition: diracdec.c:163
#define CTX_MV_DATA
Definition: dirac_arith.h:71
int stride
Definition: diracdec.c:93
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
DiracFrame * current_picture
Definition: diracdec.c:234
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3288
#define DIRAC_MAX_QUANT_INDEX
Definition: diractab.h:41
int slice_y
Definition: diracdec.c:130
unsigned old_delta_quant
schroedinger older than 1.0.8 doesn&#39;t store quant delta if only one codebook exists in a band ...
Definition: diracdec.c:170
#define FFMAX(a, b)
Definition: common.h:94
static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
Definition: diracdec.c:2121
DiracDSPContext diracdsp
Definition: diracdec.c:138
int orientation
Definition: cfhd.h:46
#define MAX_BLOCKSIZE
Definition: diracdec.c:54
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
int bytes
Definition: diracdec.c:131
int slice_params_num_buf
Definition: diracdec.c:181
#define INTRA_DC_PRED(n, type)
Dirac Specification -> 13.3 intra_dc_prediction(band)
Definition: diracdec.c:573
static int codeblock(DiracContext *s, SubBand *b, GetBitContext *gb, DiracArith *c, int left, int right, int top, int bottom, int blockcnt_one, int is_arith)
Decode the coeffs in the rectangle defined by left, right, top, bottom [DIRAC_STD] 13...
Definition: diracdec.c:491
static void init_planes(DiracContext *s)
Definition: diracdec.c:1052
int globalmc_flag
Definition: diracdec.c:159
AVCodec ff_dirac_decoder
Definition: diracdec.c:2359
static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block, int stride, int x, int y)
Definition: diracdec.c:1443
SubBand band[DWT_LEVELS][4]
Definition: cfhd.h:69
#define b
Definition: input.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
uint8_t * ibuf
Definition: cfhd.h:54
#define FFMIN(a, b)
Definition: common.h:96
int display_picture_number
picture number in display order
Definition: frame.h:413
#define CALC_PADDING(size, depth)
Definition: diracdec.c:69
DiracFrame * ref_pics[2]
Definition: diracdec.c:235
static int decode_hq_slice_row(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: diracdec.c:919
void(* avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
Definition: diracdec.c:229
static void block_mc(DiracContext *s, DiracBlock *block, uint16_t *mctmp, uint8_t *obmc_weight, int plane, int dstx, int dsty)
Definition: diracdec.c:1758
enum AVColorSpace colorspace
Definition: dirac.h:110
static DiracFrame * remove_frame(DiracFrame *framelist[], int picnum)
Definition: diracdec.c:256
void ff_spatial_idwt_slice2(DWTContext *d, int y)
Definition: dirac_dwt.c:67
#define FFSIGN(a)
Definition: common.h:73
struct DiracContext::@77 highquality
int width
picture width / height.
Definition: avcodec.h:1738
uint8_t w
Definition: llviddspenc.c:38
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
int perspective[2]
Definition: diracdec.c:201
static int dirac_unpack_prediction_parameters(DiracContext *s)
Unpack the motion compensation parameters Dirac Specification -> 11.2 Picture prediction data...
Definition: diracdec.c:1106
int32_t
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2175
av_cold void ff_dirac_golomb_reader_end(DiracGolombLUT **lut_ctx)
Definition: dirac_vlc.c:249
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
MpegvideoEncDSPContext mpvencdsp
Definition: diracdec.c:136
static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
Definition: diracdec.c:1794
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:3014
unsigned perspective_exp
Definition: diracdec.c:203
int64_t frame_number
Definition: diracdec.c:144
int chroma_y_shift
Definition: diracdec.c:147
static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
Definition: diracdec.c:1810
int n
Definition: avisynth_c.h:760
int16_t dc[3]
Definition: diracdec.c:85
uint8_t * edge_emu_buffer_base
Definition: diracdec.c:220
static void error(const char *err)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2820
static void init_obmc_weights(DiracContext *s, Plane *p, int by)
Definition: diracdec.c:1607
if(ret)
static const float pred[4]
Definition: siprdata.h:259
void(* add_dirac_obmc[3])(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen)
Definition: diracdsp.h:48
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
uint8_t * buf_base
Definition: dirac_dwt.h:42
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1041
static const int8_t mv[256][2]
Definition: 4xm.c:77
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:2880
static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags)
Definition: diracdec.c:1968
VideoDSPContext vdsp
Definition: diracdec.c:137
uint8_t ybsep
Definition: diracdec.c:118
#define AV_ONCE_INIT
Definition: thread.h:160
Libavcodec external API header.
void(* dirac_biweight_func)(uint8_t *dst, const uint8_t *src, int stride, int log2_denom, int weightd, int weights, int h)
Definition: diracdsp.h:28
uint8_t * edge_emu_buffer[4]
Definition: diracdec.c:219
int seen_sequence_header
Definition: diracdec.c:143
enum AVPixelFormat pix_fmt
Definition: dirac.h:106
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
union DiracBlock::@74 u
const int ff_dirac_qoffset_inter_tab[122]
Definition: diractab.c:72
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1565
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
int buffer_stride
Definition: diracdec.c:224
MPEG-1/2 tables.
DiracFrame all_frames[MAX_FRAMES]
Definition: diracdec.c:239
static const float bands[]
int reference
Definition: diracdec.c:79
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
Arithmetic decoder for Dirac.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
struct SubBand * parent
Definition: diracdec.c:99
dirac_biweight_func biweight_dirac_pixels_tab[3]
Definition: diracdsp.h:54
#define MAX_DWT_LEVELS
The spec limits the number of wavelet decompositions to 4 for both level 1 (VC-2) and 128 (long-gop d...
Definition: dirac.h:45
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static int decode_lowdelay(DiracContext *s)
Dirac Specification -> 13.5.1 low_delay_transform_data()
Definition: diracdec.c:934
struct DiracContext::@75 codeblock[MAX_DWT_LEVELS+1]
int core_syntax
Definition: diracdec.c:154
static int dirac_get_arith_bit(DiracArith *c, int ctx)
Definition: dirac_arith.h:134
AVCodecContext * avctx
Definition: diracdec.c:135
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2189
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2182
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
GetBitContext gb
Definition: diracdec.c:141
#define mid_pred
Definition: mathops.h:97
dirac_biweight_func biweight_func
Definition: diracdec.c:232
uint8_t xbsep
Definition: diracdec.c:117
int thread_buf_size
Definition: diracdec.c:178
int chroma_x_shift
Definition: diracdec.c:146
AVRational bytes
Definition: diracdec.c:189
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static int decode_subband_arith(AVCodecContext *avctx, void *b)
Definition: diracdec.c:643
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1562
#define MAX_DELAY
Definition: diracdec.c:51
unsigned height
Definition: dirac.h:83
int zero_res
Definition: diracdec.c:152
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
#define MAX_FRAMES
Definition: diracdec.c:52
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int pshift
Definition: cfhd.h:52
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
unsigned y
Definition: pixlet.c:45
static int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
Definition: diracdec.c:1342
AVFrame * avframe
Definition: diracdec.c:75
DiracBlock * blmotion
Definition: diracdec.c:217
void(* dirac_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int h)
Definition: diracdsp.h:27
DiracGolombLUT * reader_ctx
Definition: diracdec.c:139
#define MAX_REFERENCE_FRAMES
The spec limits this to 3 for frame coding, but in practice can be as high as 6.
Definition: diracdec.c:50
int
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
static int dirac_decode_picture_header(DiracContext *s)
Dirac Specification -> 11.1.1 Picture Header.
Definition: diracdec.c:1998
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVDiracSeqHeader seq
Definition: diracdec.c:142
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
ptrdiff_t stride
Definition: cfhd.h:60
static void decode_subband(DiracContext *s, GetBitContext *gb, int quant, int slice_x, int slice_y, int bits_end, SubBand *b1, SubBand *b2)
Definition: diracdec.c:726
unsigned size
Definition: pixlet.c:44
static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
Definition: diracdec.c:649
int16_t weight[2]
Definition: diracdec.c:208
int16_t mv[2][2]
Definition: diracdec.c:84
static int dirac_get_arith_int(DiracArith *c, int follow_ctx, int data_ctx)
Definition: dirac_arith.h:191
#define CTX_MV_F1
Definition: dirac_arith.h:70
int sbheight
Definition: diracdec.c:214
int den
Denominator.
Definition: rational.h:60
static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride, int left, int right, int wy)
Definition: diracdec.c:1574
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
Core video DSP helper functions.
void(* put_dirac_pixels_tab[3][4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
dirac_pixels_tab[width][subpel] width is 2 for 32, 1 for 16, 0 for 8 subpel is 0 for fpel and hpel (o...
Definition: diracdsp.h:42
#define CTX_DC_F1
Definition: dirac_arith.h:72
void * priv_data
Definition: avcodec.h:1592
DWTPlane idwt
Definition: diracdec.c:107
static int alloc_sequence_buffers(DiracContext *s)
Definition: diracdec.c:285
void(* put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
Definition: diracdec.c:228
static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride, int left, int right, int top, int bottom)
Definition: diracdec.c:1588
void(* dequant_subband[4])(uint8_t *src, uint8_t *dst, ptrdiff_t stride, const int qf, const int qs, int tot_v, int tot_h)
Definition: diracdsp.h:51
int threads_num_buf
Definition: diracdec.c:177
#define CTX_SB_F1
Definition: dirac_arith.h:65
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:162
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
int height
Definition: cfhd.h:51
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
#define EDGE_BOTTOM
int width
Definition: cfhd.h:58
DWTELEM * buf
Definition: snow.h:89
int height
Definition: frame.h:353
FILE * out
Definition: movenc.c:54
uint8_t ref
Definition: diracdec.c:87
int is_arith
Definition: diracdec.c:153
#define av_freep(p)
static void add_dc(uint16_t *dst, int dc, int stride, uint8_t *obmc_weight, int xblen, int yblen)
Definition: diracdec.c:1742
enum AVColorPrimaries color_primaries
Definition: dirac.h:108
void INT64 start
Definition: avisynth_c.h:766
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
#define av_always_inline
Definition: attributes.h:39
#define av_malloc_array(a, b)
uint8_t * hpel_base[3][4]
Definition: diracdec.c:78
unsigned width
Definition: dirac.h:82
#define FFSWAP(type, a, b)
Definition: common.h:99
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:143
int stride
Definition: dirac_dwt.h:40
int height
Definition: cfhd.h:59
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
void(* dirac_hpel_filter)(uint8_t *dsth, uint8_t *dstv, uint8_t *dstc, const uint8_t *src, int stride, int width, int height)
Definition: diracdsp.h:31
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2860
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1454
void(* put_signed_rect_clamped[3])(uint8_t *dst, int dst_stride, const uint8_t *src, int src_stride, int width, int height)
Definition: diracdsp.h:45
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1176
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
#define DIRAC_REF_MASK_REF1
DiracBlock->ref flags, if set then the block does MC from the given ref.
Definition: diracdec.c:59
uint64_t size_scaler
Definition: diracdec.c:195
unsigned zrs_exp
Definition: diracdec.c:202
#define FFMAX3(a, b, c)
Definition: common.h:95
uint8_t mv_precision
Definition: diracdec.c:207
static int dirac_unpack_block_motion_data(DiracContext *s)
Dirac Specification ->
Definition: diracdec.c:1502
Definition: cfhd.h:57
uint8_t obmc_weight[3][MAX_BLOCKSIZE *MAX_BLOCKSIZE]
Definition: diracdec.c:226
int ff_spatial_idwt_init(DWTContext *d, DWTPlane *p, enum dwt_type type, int decomposition_count, int bit_depth)
Definition: dirac_dwt.c:36
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
av_cold void ff_dirac_init_arith_tables(void)
Definition: dirac_arith.c:86
int level
Definition: cfhd.h:45
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
uint8_t yblen
Definition: diracdec.c:115
static uint8_t tmp[11]
Definition: aes_ctr.c:26