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