FFmpeg  2.1.1
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 "avcodec.h"
30 #include "dsputil.h"
31 #include "get_bits.h"
32 #include "bytestream.h"
33 #include "internal.h"
34 #include "golomb.h"
35 #include "dirac_arith.h"
36 #include "mpeg12data.h"
37 #include "dirac_dwt.h"
38 #include "dirac.h"
39 #include "diracdsp.h"
40 #include "videodsp.h" // for ff_emulated_edge_mc_8
41 
42 /**
43  * The spec limits the number of wavelet decompositions to 4 for both
44  * level 1 (VC-2) and 128 (long-gop default).
45  * 5 decompositions is the maximum before >16-bit buffers are needed.
46  * Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting
47  * the others to 4 decompositions (or 3 for the fidelity filter).
48  *
49  * We use this instead of MAX_DECOMPOSITIONS to save some memory.
50  */
51 #define MAX_DWT_LEVELS 5
52 
53 /**
54  * The spec limits this to 3 for frame coding, but in practice can be as high as 6
55  */
56 #define MAX_REFERENCE_FRAMES 8
57 #define MAX_DELAY 5 /* limit for main profile for frame coding (TODO: field coding) */
58 #define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
59 #define MAX_QUANT 68 /* max quant for VC-2 */
60 #define MAX_BLOCKSIZE 32 /* maximum xblen/yblen we support */
61 
62 /**
63  * DiracBlock->ref flags, if set then the block does MC from the given ref
64  */
65 #define DIRAC_REF_MASK_REF1 1
66 #define DIRAC_REF_MASK_REF2 2
67 #define DIRAC_REF_MASK_GLOBAL 4
68 
69 /**
70  * Value of Picture.reference when Picture is not a reference picture, but
71  * is held for delayed output.
72  */
73 #define DELAYED_PIC_REF 4
74 
75 #define ff_emulated_edge_mc ff_emulated_edge_mc_8 /* Fix: change the calls to this function regarding bit depth */
76 
77 #define CALC_PADDING(size, depth) \
78  (((size + (1 << depth) - 1) >> depth) << depth)
79 
80 #define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
81 
82 typedef struct {
84  int interpolated[3]; /* 1 if hpel[] is valid */
85  uint8_t *hpel[3][4];
86  uint8_t *hpel_base[3][4];
87 } DiracFrame;
88 
89 typedef struct {
90  union {
91  int16_t mv[2][2];
92  int16_t dc[3];
93  } u; /* anonymous unions aren't in C99 :( */
95 } DiracBlock;
96 
97 typedef struct SubBand {
98  int level;
100  int stride;
101  int width;
102  int height;
103  int quant;
105  struct SubBand *parent;
106 
107  /* for low delay */
108  unsigned length;
110 } SubBand;
111 
112 typedef struct Plane {
113  int width;
114  int height;
115  ptrdiff_t stride;
116 
123 
124  /* block length */
127  /* block separation (block n+1 starts after this many pixels in block n) */
130  /* amount of overspill on each edge (half of the overlap between blocks) */
133 
135 } Plane;
136 
137 typedef struct DiracContext {
144  int frame_number; /* number of the next frame to display */
148 
149  int zero_res; /* zero residue flag */
150  int is_arith; /* whether coeffs use arith or golomb coding */
151  int low_delay; /* use the low delay syntax */
152  int globalmc_flag; /* use global motion compensation */
153  int num_refs; /* number of reference pictures */
154 
155  /* wavelet decoding */
156  unsigned wavelet_depth; /* depth of the IDWT */
157  unsigned wavelet_idx;
158 
159  /**
160  * schroedinger older than 1.0.8 doesn't store
161  * quant delta if only one codebook exists in a band
162  */
163  unsigned old_delta_quant;
164  unsigned codeblock_mode;
165 
166  struct {
167  unsigned width;
168  unsigned height;
170 
171  struct {
172  unsigned num_x; /* number of horizontal slices */
173  unsigned num_y; /* number of vertical slices */
174  AVRational bytes; /* average bytes per slice */
175  uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
176  } lowdelay;
177 
178  struct {
179  int pan_tilt[2]; /* pan/tilt vector */
180  int zrs[2][2]; /* zoom/rotate/shear matrix */
181  int perspective[2]; /* perspective vector */
182  unsigned zrs_exp;
183  unsigned perspective_exp;
184  } globalmc[2];
185 
186  /* motion compensation */
187  uint8_t mv_precision; /* [DIRAC_STD] REFS_WT_PRECISION */
188  int16_t weight[2]; /* [DIRAC_STD] REF1_WT and REF2_WT */
189  unsigned weight_log2denom; /* [DIRAC_STD] REFS_WT_PRECISION */
190 
191  int blwidth; /* number of blocks (horizontally) */
192  int blheight; /* number of blocks (vertically) */
193  int sbwidth; /* number of superblocks (horizontally) */
194  int sbheight; /* number of superblocks (vertically) */
195 
198 
201 
202  uint16_t *mctmp; /* buffer holding the MC data multipled by OBMC weights */
204 
206 
207  void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
208  void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
209  void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
212 
215 
219 } DiracContext;
220 
221 /**
222  * Dirac Specification ->
223  * Parse code values. 9.6.1 Table 9.1
224  */
227  pc_eos = 0x10,
228  pc_aux_data = 0x20,
229  pc_padding = 0x30,
230 };
231 
237 };
238 
239 static const uint8_t default_qmat[][4][4] = {
240  { { 5, 3, 3, 0}, { 0, 4, 4, 1}, { 0, 5, 5, 2}, { 0, 6, 6, 3} },
241  { { 4, 2, 2, 0}, { 0, 4, 4, 2}, { 0, 5, 5, 3}, { 0, 7, 7, 5} },
242  { { 5, 3, 3, 0}, { 0, 4, 4, 1}, { 0, 5, 5, 2}, { 0, 6, 6, 3} },
243  { { 8, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0} },
244  { { 8, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0} },
245  { { 0, 4, 4, 8}, { 0, 8, 8, 12}, { 0, 13, 13, 17}, { 0, 17, 17, 21} },
246  { { 3, 1, 1, 0}, { 0, 4, 4, 2}, { 0, 6, 6, 5}, { 0, 9, 9, 7} },
247 };
248 
249 static const int qscale_tab[MAX_QUANT+1] = {
250  4, 5, 6, 7, 8, 10, 11, 13,
251  16, 19, 23, 27, 32, 38, 45, 54,
252  64, 76, 91, 108, 128, 152, 181, 215,
253  256, 304, 362, 431, 512, 609, 724, 861,
254  1024, 1218, 1448, 1722, 2048, 2435, 2896, 3444,
255  4096, 4871, 5793, 6889, 8192, 9742, 11585, 13777,
256  16384, 19484, 23170, 27554, 32768, 38968, 46341, 55109,
257  65536, 77936
258 };
259 
260 static const int qoffset_intra_tab[MAX_QUANT+1] = {
261  1, 2, 3, 4, 4, 5, 6, 7,
262  8, 10, 12, 14, 16, 19, 23, 27,
263  32, 38, 46, 54, 64, 76, 91, 108,
264  128, 152, 181, 216, 256, 305, 362, 431,
265  512, 609, 724, 861, 1024, 1218, 1448, 1722,
266  2048, 2436, 2897, 3445, 4096, 4871, 5793, 6889,
267  8192, 9742, 11585, 13777, 16384, 19484, 23171, 27555,
268  32768, 38968
269 };
270 
271 static const int qoffset_inter_tab[MAX_QUANT+1] = {
272  1, 2, 2, 3, 3, 4, 4, 5,
273  6, 7, 9, 10, 12, 14, 17, 20,
274  24, 29, 34, 41, 48, 57, 68, 81,
275  96, 114, 136, 162, 192, 228, 272, 323,
276  384, 457, 543, 646, 768, 913, 1086, 1292,
277  1536, 1827, 2172, 2583, 3072, 3653, 4344, 5166,
278  6144, 7307, 8689, 10333, 12288, 14613, 17378, 20666,
279  24576, 29226
280 };
281 
282 /* magic number division by 3 from schroedinger */
283 static inline int divide3(int x)
284 {
285  return ((x+1)*21845 + 10922) >> 16;
286 }
287 
288 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
289 {
290  DiracFrame *remove_pic = NULL;
291  int i, remove_idx = -1;
292 
293  for (i = 0; framelist[i]; i++)
294  if (framelist[i]->avframe.display_picture_number == picnum) {
295  remove_pic = framelist[i];
296  remove_idx = i;
297  }
298 
299  if (remove_pic)
300  for (i = remove_idx; framelist[i]; i++)
301  framelist[i] = framelist[i+1];
302 
303  return remove_pic;
304 }
305 
306 static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
307 {
308  int i;
309  for (i = 0; i < maxframes; i++)
310  if (!framelist[i]) {
311  framelist[i] = frame;
312  return 0;
313  }
314  return -1;
315 }
316 
318 {
319  int sbwidth = DIVRNDUP(s->source.width, 4);
320  int sbheight = DIVRNDUP(s->source.height, 4);
321  int i, w, h, top_padding;
322 
323  /* todo: think more about this / use or set Plane here */
324  for (i = 0; i < 3; i++) {
325  int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
326  int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
327  w = s->source.width >> (i ? s->chroma_x_shift : 0);
328  h = s->source.height >> (i ? s->chroma_y_shift : 0);
329 
330  /* we allocate the max we support here since num decompositions can
331  * change from frame to frame. Stride is aligned to 16 for SIMD, and
332  * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
333  * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
334  * on each side */
335  top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
336  w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
337  h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
338 
339  s->plane[i].idwt_buf_base = av_mallocz((w+max_xblen)*h * sizeof(IDWTELEM));
340  s->plane[i].idwt_tmp = av_malloc((w+16) * sizeof(IDWTELEM));
341  s->plane[i].idwt_buf = s->plane[i].idwt_buf_base + top_padding*w;
342  if (!s->plane[i].idwt_buf_base || !s->plane[i].idwt_tmp)
343  return AVERROR(ENOMEM);
344  }
345 
346  w = s->source.width;
347  h = s->source.height;
348 
349  /* fixme: allocate using real stride here */
350  s->sbsplit = av_malloc(sbwidth * sbheight);
351  s->blmotion = av_malloc(sbwidth * sbheight * 16 * sizeof(*s->blmotion));
353 
354  s->mctmp = av_malloc((w+64+MAX_BLOCKSIZE) * (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));
355  s->mcscratch = av_malloc((w+64)*MAX_BLOCKSIZE);
356 
357  if (!s->sbsplit || !s->blmotion || !s->mctmp || !s->mcscratch)
358  return AVERROR(ENOMEM);
359  return 0;
360 }
361 
363 {
364  int i, j, k;
365 
366  for (i = 0; i < MAX_FRAMES; i++) {
367  if (s->all_frames[i].avframe.data[0]) {
369  memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
370  }
371 
372  for (j = 0; j < 3; j++)
373  for (k = 1; k < 4; k++)
374  av_freep(&s->all_frames[i].hpel_base[j][k]);
375  }
376 
377  memset(s->ref_frames, 0, sizeof(s->ref_frames));
378  memset(s->delay_frames, 0, sizeof(s->delay_frames));
379 
380  for (i = 0; i < 3; i++) {
381  av_freep(&s->plane[i].idwt_buf_base);
382  av_freep(&s->plane[i].idwt_tmp);
383  }
384 
385  av_freep(&s->sbsplit);
386  av_freep(&s->blmotion);
388 
389  av_freep(&s->mctmp);
390  av_freep(&s->mcscratch);
391 }
392 
394 {
395  DiracContext *s = avctx->priv_data;
396  s->avctx = avctx;
397  s->frame_number = -1;
398 
399  if (avctx->flags&CODEC_FLAG_EMU_EDGE) {
400  av_log(avctx, AV_LOG_ERROR, "Edge emulation not supported!\n");
401  return AVERROR_PATCHWELCOME;
402  }
403 
404  ff_dsputil_init(&s->dsp, avctx);
406 
407  return 0;
408 }
409 
411 {
412  DiracContext *s = avctx->priv_data;
414  s->seen_sequence_header = 0;
415  s->frame_number = -1;
416 }
417 
419 {
420  dirac_decode_flush(avctx);
421  return 0;
422 }
423 
424 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
425 
426 static inline void coeff_unpack_arith(DiracArith *c, int qfactor, int qoffset,
427  SubBand *b, IDWTELEM *buf, int x, int y)
428 {
429  int coeff, sign;
430  int sign_pred = 0;
431  int pred_ctx = CTX_ZPZN_F1;
432 
433  /* Check if the parent subband has a 0 in the corresponding position */
434  if (b->parent)
435  pred_ctx += !!b->parent->ibuf[b->parent->stride * (y>>1) + (x>>1)] << 1;
436 
437  if (b->orientation == subband_hl)
438  sign_pred = buf[-b->stride];
439 
440  /* Determine if the pixel has only zeros in its neighbourhood */
441  if (x) {
442  pred_ctx += !(buf[-1] | buf[-b->stride] | buf[-1-b->stride]);
443  if (b->orientation == subband_lh)
444  sign_pred = buf[-1];
445  } else {
446  pred_ctx += !buf[-b->stride];
447  }
448 
449  coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA);
450  if (coeff) {
451  coeff = (coeff * qfactor + qoffset + 2) >> 2;
452  sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred));
453  coeff = (coeff ^ -sign) + sign;
454  }
455  *buf = coeff;
456 }
457 
458 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
459 {
460  int sign, coeff;
461 
462  coeff = svq3_get_ue_golomb(gb);
463  if (coeff) {
464  coeff = (coeff * qfactor + qoffset + 2) >> 2;
465  sign = get_bits1(gb);
466  coeff = (coeff ^ -sign) + sign;
467  }
468  return coeff;
469 }
470 
471 /**
472  * Decode the coeffs in the rectangle defined by left, right, top, bottom
473  * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
474  */
475 static inline void codeblock(DiracContext *s, SubBand *b,
476  GetBitContext *gb, DiracArith *c,
477  int left, int right, int top, int bottom,
478  int blockcnt_one, int is_arith)
479 {
480  int x, y, zero_block;
481  int qoffset, qfactor;
482  IDWTELEM *buf;
483 
484  /* check for any coded coefficients in this codeblock */
485  if (!blockcnt_one) {
486  if (is_arith)
487  zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
488  else
489  zero_block = get_bits1(gb);
490 
491  if (zero_block)
492  return;
493  }
494 
495  if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
496  int quant = b->quant;
497  if (is_arith)
499  else
500  quant += dirac_get_se_golomb(gb);
501  if (quant < 0) {
502  av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
503  return;
504  }
505  b->quant = quant;
506  }
507 
508  b->quant = FFMIN(b->quant, MAX_QUANT);
509 
510  qfactor = qscale_tab[b->quant];
511  /* TODO: context pointer? */
512  if (!s->num_refs)
513  qoffset = qoffset_intra_tab[b->quant];
514  else
515  qoffset = qoffset_inter_tab[b->quant];
516 
517  buf = b->ibuf + top * b->stride;
518  for (y = top; y < bottom; y++) {
519  for (x = left; x < right; x++) {
520  /* [DIRAC_STD] 13.4.4 Subband coefficients. coeff_unpack() */
521  if (is_arith)
522  coeff_unpack_arith(c, qfactor, qoffset, b, buf+x, x, y);
523  else
524  buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
525  }
526  buf += b->stride;
527  }
528 }
529 
530 /**
531  * Dirac Specification ->
532  * 13.3 intra_dc_prediction(band)
533  */
534 static inline void intra_dc_prediction(SubBand *b)
535 {
536  IDWTELEM *buf = b->ibuf;
537  int x, y;
538 
539  for (x = 1; x < b->width; x++)
540  buf[x] += buf[x-1];
541  buf += b->stride;
542 
543  for (y = 1; y < b->height; y++) {
544  buf[0] += buf[-b->stride];
545 
546  for (x = 1; x < b->width; x++) {
547  int pred = buf[x - 1] + buf[x - b->stride] + buf[x - b->stride-1];
548  buf[x] += divide3(pred);
549  }
550  buf += b->stride;
551  }
552 }
553 
554 /**
555  * Dirac Specification ->
556  * 13.4.2 Non-skipped subbands. subband_coeffs()
557  */
559 {
560  int cb_x, cb_y, left, right, top, bottom;
561  DiracArith c;
562  GetBitContext gb;
563  int cb_width = s->codeblock[b->level + (b->orientation != subband_ll)].width;
564  int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
565  int blockcnt_one = (cb_width + cb_height) == 2;
566 
567  if (!b->length)
568  return;
569 
570  init_get_bits8(&gb, b->coeff_data, b->length);
571 
572  if (is_arith)
573  ff_dirac_init_arith_decoder(&c, &gb, b->length);
574 
575  top = 0;
576  for (cb_y = 0; cb_y < cb_height; cb_y++) {
577  bottom = (b->height * (cb_y+1)) / cb_height;
578  left = 0;
579  for (cb_x = 0; cb_x < cb_width; cb_x++) {
580  right = (b->width * (cb_x+1)) / cb_width;
581  codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
582  left = right;
583  }
584  top = bottom;
585  }
586 
587  if (b->orientation == subband_ll && s->num_refs == 0)
589 }
590 
591 static int decode_subband_arith(AVCodecContext *avctx, void *b)
592 {
593  DiracContext *s = avctx->priv_data;
594  decode_subband_internal(s, b, 1);
595  return 0;
596 }
597 
598 static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
599 {
600  DiracContext *s = avctx->priv_data;
601  SubBand **b = arg;
602  decode_subband_internal(s, *b, 0);
603  return 0;
604 }
605 
606 /**
607  * Dirac Specification ->
608  * [DIRAC_STD] 13.4.1 core_transform_data()
609  */
611 {
612  AVCodecContext *avctx = s->avctx;
613  SubBand *bands[3*MAX_DWT_LEVELS+1];
614  enum dirac_subband orientation;
615  int level, num_bands = 0;
616 
617  /* Unpack all subbands at all levels. */
618  for (level = 0; level < s->wavelet_depth; level++) {
619  for (orientation = !!level; orientation < 4; orientation++) {
620  SubBand *b = &s->plane[comp].band[level][orientation];
621  bands[num_bands++] = b;
622 
623  align_get_bits(&s->gb);
624  /* [DIRAC_STD] 13.4.2 subband() */
625  b->length = svq3_get_ue_golomb(&s->gb);
626  if (b->length) {
627  b->quant = svq3_get_ue_golomb(&s->gb);
628  align_get_bits(&s->gb);
629  b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
630  b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
631  skip_bits_long(&s->gb, b->length*8);
632  }
633  }
634  /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
635  if (s->is_arith)
636  avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
637  NULL, 4-!!level, sizeof(SubBand));
638  }
639  /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
640  if (!s->is_arith)
641  avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
642 }
643 
644 /* [DIRAC_STD] 13.5.5.2 Luma slice subband data. luma_slice_band(level,orient,sx,sy) --> if b2 == NULL */
645 /* [DIRAC_STD] 13.5.5.3 Chroma slice subband data. chroma_slice_band(level,orient,sx,sy) --> if b2 != NULL */
647  int slice_x, int slice_y, int bits_end,
648  SubBand *b1, SubBand *b2)
649 {
650  int left = b1->width * slice_x / s->lowdelay.num_x;
651  int right = b1->width *(slice_x+1) / s->lowdelay.num_x;
652  int top = b1->height * slice_y / s->lowdelay.num_y;
653  int bottom = b1->height *(slice_y+1) / s->lowdelay.num_y;
654 
655  int qfactor = qscale_tab[FFMIN(quant, MAX_QUANT)];
656  int qoffset = qoffset_intra_tab[FFMIN(quant, MAX_QUANT)];
657 
658  IDWTELEM *buf1 = b1->ibuf + top * b1->stride;
659  IDWTELEM *buf2 = b2 ? b2->ibuf + top * b2->stride : NULL;
660  int x, y;
661  /* we have to constantly check for overread since the spec explictly
662  requires this, with the meaning that all remaining coeffs are set to 0 */
663  if (get_bits_count(gb) >= bits_end)
664  return;
665 
666  for (y = top; y < bottom; y++) {
667  for (x = left; x < right; x++) {
668  buf1[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
669  if (get_bits_count(gb) >= bits_end)
670  return;
671  if (buf2) {
672  buf2[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
673  if (get_bits_count(gb) >= bits_end)
674  return;
675  }
676  }
677  buf1 += b1->stride;
678  if (buf2)
679  buf2 += b2->stride;
680  }
681 }
682 
685  int slice_x;
686  int slice_y;
687  int bytes;
688 };
689 
690 
691 /**
692  * Dirac Specification ->
693  * 13.5.2 Slices. slice(sx,sy)
694  */
695 static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
696 {
697  DiracContext *s = avctx->priv_data;
698  struct lowdelay_slice *slice = arg;
699  GetBitContext *gb = &slice->gb;
700  enum dirac_subband orientation;
701  int level, quant, chroma_bits, chroma_end;
702 
703  int quant_base = get_bits(gb, 7); /*[DIRAC_STD] qindex */
704  int length_bits = av_log2(8 * slice->bytes)+1;
705  int luma_bits = get_bits_long(gb, length_bits);
706  int luma_end = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
707 
708  /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
709  for (level = 0; level < s->wavelet_depth; level++)
710  for (orientation = !!level; orientation < 4; orientation++) {
711  quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
712  lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
713  &s->plane[0].band[level][orientation], NULL);
714  }
715 
716  /* consume any unused bits from luma */
717  skip_bits_long(gb, get_bits_count(gb) - luma_end);
718 
719  chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
720  chroma_end = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
721  /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
722  for (level = 0; level < s->wavelet_depth; level++)
723  for (orientation = !!level; orientation < 4; orientation++) {
724  quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
725  lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
726  &s->plane[1].band[level][orientation],
727  &s->plane[2].band[level][orientation]);
728  }
729 
730  return 0;
731 }
732 
733 /**
734  * Dirac Specification ->
735  * 13.5.1 low_delay_transform_data()
736  */
738 {
739  AVCodecContext *avctx = s->avctx;
740  int slice_x, slice_y, bytes, bufsize;
741  const uint8_t *buf;
742  struct lowdelay_slice *slices;
743  int slice_num = 0;
744 
745  slices = av_mallocz(s->lowdelay.num_x * s->lowdelay.num_y * sizeof(struct lowdelay_slice));
746 
747  align_get_bits(&s->gb);
748  /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
749  buf = s->gb.buffer + get_bits_count(&s->gb)/8;
750  bufsize = get_bits_left(&s->gb);
751 
752  for (slice_y = 0; bufsize > 0 && slice_y < s->lowdelay.num_y; slice_y++)
753  for (slice_x = 0; bufsize > 0 && slice_x < s->lowdelay.num_x; slice_x++) {
754  bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
755  - slice_num * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
756 
757  slices[slice_num].bytes = bytes;
758  slices[slice_num].slice_x = slice_x;
759  slices[slice_num].slice_y = slice_y;
760  init_get_bits(&slices[slice_num].gb, buf, bufsize);
761  slice_num++;
762 
763  buf += bytes;
764  bufsize -= bytes*8;
765  }
766 
767  avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
768  sizeof(struct lowdelay_slice)); /* [DIRAC_STD] 13.5.2 Slices */
769  intra_dc_prediction(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
770  intra_dc_prediction(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
771  intra_dc_prediction(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
772  av_free(slices);
773 }
774 
776 {
777  int i, w, h, level, orientation;
778 
779  for (i = 0; i < 3; i++) {
780  Plane *p = &s->plane[i];
781 
782  p->width = s->source.width >> (i ? s->chroma_x_shift : 0);
783  p->height = s->source.height >> (i ? s->chroma_y_shift : 0);
784  p->idwt_width = w = CALC_PADDING(p->width , s->wavelet_depth);
785  p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
786  p->idwt_stride = FFALIGN(p->idwt_width, 8);
787 
788  for (level = s->wavelet_depth-1; level >= 0; level--) {
789  w = w>>1;
790  h = h>>1;
791  for (orientation = !!level; orientation < 4; orientation++) {
792  SubBand *b = &p->band[level][orientation];
793 
794  b->ibuf = p->idwt_buf;
795  b->level = level;
796  b->stride = p->idwt_stride << (s->wavelet_depth - level);
797  b->width = w;
798  b->height = h;
799  b->orientation = orientation;
800 
801  if (orientation & 1)
802  b->ibuf += w;
803  if (orientation > 1)
804  b->ibuf += b->stride>>1;
805 
806  if (level)
807  b->parent = &p->band[level-1][orientation];
808  }
809  }
810 
811  if (i > 0) {
812  p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
813  p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
814  p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
815  p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
816  }
817 
818  p->xoffset = (p->xblen - p->xbsep)/2;
819  p->yoffset = (p->yblen - p->ybsep)/2;
820  }
821 }
822 
823 /**
824  * Unpack the motion compensation parameters
825  * Dirac Specification ->
826  * 11.2 Picture prediction data. picture_prediction()
827  */
829 {
830  static const uint8_t default_blen[] = { 4, 12, 16, 24 };
831  static const uint8_t default_bsep[] = { 4, 8, 12, 16 };
832 
833  GetBitContext *gb = &s->gb;
834  unsigned idx, ref;
835 
836  align_get_bits(gb);
837  /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
838  /* Luma and Chroma are equal. 11.2.3 */
839  idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
840 
841  if (idx > 4) {
842  av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
843  return -1;
844  }
845 
846  if (idx == 0) {
847  s->plane[0].xblen = svq3_get_ue_golomb(gb);
848  s->plane[0].yblen = svq3_get_ue_golomb(gb);
849  s->plane[0].xbsep = svq3_get_ue_golomb(gb);
850  s->plane[0].ybsep = svq3_get_ue_golomb(gb);
851  } else {
852  /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
853  s->plane[0].xblen = default_blen[idx-1];
854  s->plane[0].yblen = default_blen[idx-1];
855  s->plane[0].xbsep = default_bsep[idx-1];
856  s->plane[0].ybsep = default_bsep[idx-1];
857  }
858  /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
859  Calculated in function dirac_unpack_block_motion_data */
860 
861  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) {
862  av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
863  return -1;
864  }
865  if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
866  av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
867  return -1;
868  }
869  if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
870  av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
871  return -1;
872  }
873 
874  /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
875  Read motion vector precision */
877  if (s->mv_precision > 3) {
878  av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
879  return -1;
880  }
881 
882  /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
883  Read the global motion compensation parameters */
884  s->globalmc_flag = get_bits1(gb);
885  if (s->globalmc_flag) {
886  memset(s->globalmc, 0, sizeof(s->globalmc));
887  /* [DIRAC_STD] pan_tilt(gparams) */
888  for (ref = 0; ref < s->num_refs; ref++) {
889  if (get_bits1(gb)) {
890  s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
891  s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
892  }
893  /* [DIRAC_STD] zoom_rotate_shear(gparams)
894  zoom/rotation/shear parameters */
895  if (get_bits1(gb)) {
896  s->globalmc[ref].zrs_exp = svq3_get_ue_golomb(gb);
897  s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
898  s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
899  s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
900  s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
901  } else {
902  s->globalmc[ref].zrs[0][0] = 1;
903  s->globalmc[ref].zrs[1][1] = 1;
904  }
905  /* [DIRAC_STD] perspective(gparams) */
906  if (get_bits1(gb)) {
908  s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb);
909  s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb);
910  }
911  }
912  }
913 
914  /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
915  Picture prediction mode, not currently used. */
916  if (svq3_get_ue_golomb(gb)) {
917  av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
918  return -1;
919  }
920 
921  /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
922  just data read, weight calculation will be done later on. */
923  s->weight_log2denom = 1;
924  s->weight[0] = 1;
925  s->weight[1] = 1;
926 
927  if (get_bits1(gb)) {
929  s->weight[0] = dirac_get_se_golomb(gb);
930  if (s->num_refs == 2)
931  s->weight[1] = dirac_get_se_golomb(gb);
932  }
933  return 0;
934 }
935 
936 /**
937  * Dirac Specification ->
938  * 11.3 Wavelet transform data. wavelet_transform()
939  */
941 {
942  GetBitContext *gb = &s->gb;
943  int i, level;
944  unsigned tmp;
945 
946 #define CHECKEDREAD(dst, cond, errmsg) \
947  tmp = svq3_get_ue_golomb(gb); \
948  if (cond) { \
949  av_log(s->avctx, AV_LOG_ERROR, errmsg); \
950  return -1; \
951  }\
952  dst = tmp;
953 
954  align_get_bits(gb);
955 
956  s->zero_res = s->num_refs ? get_bits1(gb) : 0;
957  if (s->zero_res)
958  return 0;
959 
960  /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
961  CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
962 
963  CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
964 
965  if (!s->low_delay) {
966  /* Codeblock parameters (core syntax only) */
967  if (get_bits1(gb)) {
968  for (i = 0; i <= s->wavelet_depth; i++) {
969  CHECKEDREAD(s->codeblock[i].width , tmp < 1, "codeblock width invalid\n")
970  CHECKEDREAD(s->codeblock[i].height, tmp < 1, "codeblock height invalid\n")
971  }
972 
973  CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
974  } else
975  for (i = 0; i <= s->wavelet_depth; i++)
976  s->codeblock[i].width = s->codeblock[i].height = 1;
977  } else {
978  /* Slice parameters + quantization matrix*/
979  /*[DIRAC_STD] 11.3.4 Slice coding Parameters (low delay syntax only). slice_parameters() */
984 
985  if (s->lowdelay.bytes.den <= 0) {
986  av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
987  return AVERROR_INVALIDDATA;
988  }
989 
990  /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
991  if (get_bits1(gb)) {
992  av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
993  /* custom quantization matrix */
994  s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
995  for (level = 0; level < s->wavelet_depth; level++) {
996  s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
997  s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
998  s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
999  }
1000  } else {
1001  if (s->wavelet_depth > 4) {
1002  av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1003  return AVERROR_INVALIDDATA;
1004  }
1005  /* default quantization matrix */
1006  for (level = 0; level < s->wavelet_depth; level++)
1007  for (i = 0; i < 4; i++) {
1008  s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
1009  /* haar with no shift differs for different depths */
1010  if (s->wavelet_idx == 3)
1011  s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1012  }
1013  }
1014  }
1015  return 0;
1016 }
1017 
1018 static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1019 {
1020  static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1021 
1022  if (!(x|y))
1023  return 0;
1024  else if (!y)
1025  return sbsplit[-1];
1026  else if (!x)
1027  return sbsplit[-stride];
1028 
1029  return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1030 }
1031 
1032 static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1033 {
1034  int pred;
1035 
1036  if (!(x|y))
1037  return 0;
1038  else if (!y)
1039  return block[-1].ref & refmask;
1040  else if (!x)
1041  return block[-stride].ref & refmask;
1042 
1043  /* return the majority */
1044  pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1045  return (pred >> 1) & refmask;
1046 }
1047 
1048 static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1049 {
1050  int i, n = 0;
1051 
1052  memset(block->u.dc, 0, sizeof(block->u.dc));
1053 
1054  if (x && !(block[-1].ref & 3)) {
1055  for (i = 0; i < 3; i++)
1056  block->u.dc[i] += block[-1].u.dc[i];
1057  n++;
1058  }
1059 
1060  if (y && !(block[-stride].ref & 3)) {
1061  for (i = 0; i < 3; i++)
1062  block->u.dc[i] += block[-stride].u.dc[i];
1063  n++;
1064  }
1065 
1066  if (x && y && !(block[-1-stride].ref & 3)) {
1067  for (i = 0; i < 3; i++)
1068  block->u.dc[i] += block[-1-stride].u.dc[i];
1069  n++;
1070  }
1071 
1072  if (n == 2) {
1073  for (i = 0; i < 3; i++)
1074  block->u.dc[i] = (block->u.dc[i]+1)>>1;
1075  } else if (n == 3) {
1076  for (i = 0; i < 3; i++)
1077  block->u.dc[i] = divide3(block->u.dc[i]);
1078  }
1079 }
1080 
1081 static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1082 {
1083  int16_t *pred[3];
1084  int refmask = ref+1;
1085  int mask = refmask | DIRAC_REF_MASK_GLOBAL; /* exclude gmc blocks */
1086  int n = 0;
1087 
1088  if (x && (block[-1].ref & mask) == refmask)
1089  pred[n++] = block[-1].u.mv[ref];
1090 
1091  if (y && (block[-stride].ref & mask) == refmask)
1092  pred[n++] = block[-stride].u.mv[ref];
1093 
1094  if (x && y && (block[-stride-1].ref & mask) == refmask)
1095  pred[n++] = block[-stride-1].u.mv[ref];
1096 
1097  switch (n) {
1098  case 0:
1099  block->u.mv[ref][0] = 0;
1100  block->u.mv[ref][1] = 0;
1101  break;
1102  case 1:
1103  block->u.mv[ref][0] = pred[0][0];
1104  block->u.mv[ref][1] = pred[0][1];
1105  break;
1106  case 2:
1107  block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1108  block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1109  break;
1110  case 3:
1111  block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1112  block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1113  break;
1114  }
1115 }
1116 
1117 static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1118 {
1119  int ez = s->globalmc[ref].zrs_exp;
1120  int ep = s->globalmc[ref].perspective_exp;
1121  int (*A)[2] = s->globalmc[ref].zrs;
1122  int *b = s->globalmc[ref].pan_tilt;
1123  int *c = s->globalmc[ref].perspective;
1124 
1125  int m = (1<<ep) - (c[0]*x + c[1]*y);
1126  int mx = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
1127  int my = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
1128 
1129  block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1130  block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1131 }
1132 
1134  int stride, int x, int y)
1135 {
1136  int i;
1137 
1138  block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1139  block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1140 
1141  if (s->num_refs == 2) {
1142  block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1143  block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1144  }
1145 
1146  if (!block->ref) {
1147  pred_block_dc(block, stride, x, y);
1148  for (i = 0; i < 3; i++)
1149  block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1150  return;
1151  }
1152 
1153  if (s->globalmc_flag) {
1154  block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1155  block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1156  }
1157 
1158  for (i = 0; i < s->num_refs; i++)
1159  if (block->ref & (i+1)) {
1160  if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1161  global_mv(s, block, x, y, i);
1162  } else {
1163  pred_mv(block, stride, x, y, i);
1164  block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1165  block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1166  }
1167  }
1168 }
1169 
1170 /**
1171  * Copies the current block to the other blocks covered by the current superblock split mode
1172  */
1174 {
1175  int x, y;
1176  DiracBlock *dst = block;
1177 
1178  for (x = 1; x < size; x++)
1179  dst[x] = *block;
1180 
1181  for (y = 1; y < size; y++) {
1182  dst += stride;
1183  for (x = 0; x < size; x++)
1184  dst[x] = *block;
1185  }
1186 }
1187 
1188 /**
1189  * Dirac Specification ->
1190  * 12. Block motion data syntax
1191  */
1193 {
1194  GetBitContext *gb = &s->gb;
1195  uint8_t *sbsplit = s->sbsplit;
1196  int i, x, y, q, p;
1197  DiracArith arith[8];
1198 
1199  align_get_bits(gb);
1200 
1201  /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1202  s->sbwidth = DIVRNDUP(s->source.width, 4*s->plane[0].xbsep);
1203  s->sbheight = DIVRNDUP(s->source.height, 4*s->plane[0].ybsep);
1204  s->blwidth = 4 * s->sbwidth;
1205  s->blheight = 4 * s->sbheight;
1206 
1207  /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1208  decode superblock split modes */
1209  ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb)); /* svq3_get_ue_golomb(gb) is the length */
1210  for (y = 0; y < s->sbheight; y++) {
1211  for (x = 0; x < s->sbwidth; x++) {
1212  unsigned int split = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1213  if (split > 2)
1214  return -1;
1215  sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1216  }
1217  sbsplit += s->sbwidth;
1218  }
1219 
1220  /* setup arith decoding */
1222  for (i = 0; i < s->num_refs; i++) {
1223  ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
1224  ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
1225  }
1226  for (i = 0; i < 3; i++)
1227  ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
1228 
1229  for (y = 0; y < s->sbheight; y++)
1230  for (x = 0; x < s->sbwidth; x++) {
1231  int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1232  int step = 4 >> s->sbsplit[y * s->sbwidth + x];
1233 
1234  for (q = 0; q < blkcnt; q++)
1235  for (p = 0; p < blkcnt; p++) {
1236  int bx = 4 * x + p*step;
1237  int by = 4 * y + q*step;
1238  DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1239  decode_block_params(s, arith, block, s->blwidth, bx, by);
1240  propagate_block_data(block, s->blwidth, step);
1241  }
1242  }
1243 
1244  return 0;
1245 }
1246 
1247 static int weight(int i, int blen, int offset)
1248 {
1249 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \
1250  (1 + (6*(i) + offset - 1) / (2*offset - 1))
1251 
1252  if (i < 2*offset)
1253  return ROLLOFF(i);
1254  else if (i > blen-1 - 2*offset)
1255  return ROLLOFF(blen-1 - i);
1256  return 8;
1257 }
1258 
1259 static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1260  int left, int right, int wy)
1261 {
1262  int x;
1263  for (x = 0; left && x < p->xblen >> 1; x++)
1264  obmc_weight[x] = wy*8;
1265  for (; x < p->xblen >> right; x++)
1266  obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1267  for (; x < p->xblen; x++)
1268  obmc_weight[x] = wy*8;
1269  for (; x < stride; x++)
1270  obmc_weight[x] = 0;
1271 }
1272 
1273 static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1274  int left, int right, int top, int bottom)
1275 {
1276  int y;
1277  for (y = 0; top && y < p->yblen >> 1; y++) {
1278  init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1279  obmc_weight += stride;
1280  }
1281  for (; y < p->yblen >> bottom; y++) {
1282  int wy = weight(y, p->yblen, p->yoffset);
1283  init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1284  obmc_weight += stride;
1285  }
1286  for (; y < p->yblen; y++) {
1287  init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1288  obmc_weight += stride;
1289  }
1290 }
1291 
1292 static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1293 {
1294  int top = !by;
1295  int bottom = by == s->blheight-1;
1296 
1297  /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1298  if (top || bottom || by == 1) {
1299  init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1300  init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1301  init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1302  }
1303 }
1304 
1305 static const uint8_t epel_weights[4][4][4] = {
1306  {{ 16, 0, 0, 0 },
1307  { 12, 4, 0, 0 },
1308  { 8, 8, 0, 0 },
1309  { 4, 12, 0, 0 }},
1310  {{ 12, 0, 4, 0 },
1311  { 9, 3, 3, 1 },
1312  { 6, 6, 2, 2 },
1313  { 3, 9, 1, 3 }},
1314  {{ 8, 0, 8, 0 },
1315  { 6, 2, 6, 2 },
1316  { 4, 4, 4, 4 },
1317  { 2, 6, 2, 6 }},
1318  {{ 4, 0, 12, 0 },
1319  { 3, 1, 9, 3 },
1320  { 2, 2, 6, 6 },
1321  { 1, 3, 3, 9 }}
1322 };
1323 
1324 /**
1325  * For block x,y, determine which of the hpel planes to do bilinear
1326  * interpolation from and set src[] to the location in each hpel plane
1327  * to MC from.
1328  *
1329  * @return the index of the put_dirac_pixels_tab function to use
1330  * 0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1331  */
1333  int x, int y, int ref, int plane)
1334 {
1335  Plane *p = &s->plane[plane];
1336  uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1337  int motion_x = block->u.mv[ref][0];
1338  int motion_y = block->u.mv[ref][1];
1339  int mx, my, i, epel, nplanes = 0;
1340 
1341  if (plane) {
1342  motion_x >>= s->chroma_x_shift;
1343  motion_y >>= s->chroma_y_shift;
1344  }
1345 
1346  mx = motion_x & ~(-1 << s->mv_precision);
1347  my = motion_y & ~(-1 << s->mv_precision);
1348  motion_x >>= s->mv_precision;
1349  motion_y >>= s->mv_precision;
1350  /* normalize subpel coordinates to epel */
1351  /* TODO: template this function? */
1352  mx <<= 3 - s->mv_precision;
1353  my <<= 3 - s->mv_precision;
1354 
1355  x += motion_x;
1356  y += motion_y;
1357  epel = (mx|my)&1;
1358 
1359  /* hpel position */
1360  if (!((mx|my)&3)) {
1361  nplanes = 1;
1362  src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1363  } else {
1364  /* qpel or epel */
1365  nplanes = 4;
1366  for (i = 0; i < 4; i++)
1367  src[i] = ref_hpel[i] + y*p->stride + x;
1368 
1369  /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1370  we increment x/y because the edge changes for half of the pixels */
1371  if (mx > 4) {
1372  src[0] += 1;
1373  src[2] += 1;
1374  x++;
1375  }
1376  if (my > 4) {
1377  src[0] += p->stride;
1378  src[1] += p->stride;
1379  y++;
1380  }
1381 
1382  /* hpel planes are:
1383  [0]: F [1]: H
1384  [2]: V [3]: C */
1385  if (!epel) {
1386  /* check if we really only need 2 planes since either mx or my is
1387  a hpel position. (epel weights of 0 handle this there) */
1388  if (!(mx&3)) {
1389  /* mx == 0: average [0] and [2]
1390  mx == 4: average [1] and [3] */
1391  src[!mx] = src[2 + !!mx];
1392  nplanes = 2;
1393  } else if (!(my&3)) {
1394  src[0] = src[(my>>1) ];
1395  src[1] = src[(my>>1)+1];
1396  nplanes = 2;
1397  }
1398  } else {
1399  /* adjust the ordering if needed so the weights work */
1400  if (mx > 4) {
1401  FFSWAP(const uint8_t *, src[0], src[1]);
1402  FFSWAP(const uint8_t *, src[2], src[3]);
1403  }
1404  if (my > 4) {
1405  FFSWAP(const uint8_t *, src[0], src[2]);
1406  FFSWAP(const uint8_t *, src[1], src[3]);
1407  }
1408  src[4] = epel_weights[my&3][mx&3];
1409  }
1410  }
1411 
1412  /* fixme: v/h _edge_pos */
1413  if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1414  y + p->yblen > p->height+EDGE_WIDTH/2 ||
1415  x < 0 || y < 0) {
1416  for (i = 0; i < nplanes; i++) {
1418  src[i], p->stride,
1419  p->xblen, p->yblen, x, y,
1420  p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1421  src[i] = s->edge_emu_buffer[i];
1422  }
1423  }
1424  return (nplanes>>1) + epel;
1425 }
1426 
1427 static void add_dc(uint16_t *dst, int dc, int stride,
1428  uint8_t *obmc_weight, int xblen, int yblen)
1429 {
1430  int x, y;
1431  dc += 128;
1432 
1433  for (y = 0; y < yblen; y++) {
1434  for (x = 0; x < xblen; x += 2) {
1435  dst[x ] += dc * obmc_weight[x ];
1436  dst[x+1] += dc * obmc_weight[x+1];
1437  }
1438  dst += stride;
1439  obmc_weight += MAX_BLOCKSIZE;
1440  }
1441 }
1442 
1444  uint16_t *mctmp, uint8_t *obmc_weight,
1445  int plane, int dstx, int dsty)
1446 {
1447  Plane *p = &s->plane[plane];
1448  const uint8_t *src[5];
1449  int idx;
1450 
1451  switch (block->ref&3) {
1452  case 0: /* DC */
1453  add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1454  return;
1455  case 1:
1456  case 2:
1457  idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1458  s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1459  if (s->weight_func)
1461  s->weight[0] + s->weight[1], p->yblen);
1462  break;
1463  case 3:
1464  idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1465  s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1466  idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1467  if (s->biweight_func) {
1468  /* fixme: +32 is a quick hack */
1469  s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1471  s->weight[0], s->weight[1], p->yblen);
1472  } else
1473  s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1474  break;
1475  }
1476  s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1477 }
1478 
1479 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1480 {
1481  Plane *p = &s->plane[plane];
1482  int x, dstx = p->xbsep - p->xoffset;
1483 
1484  block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1485  mctmp += p->xbsep;
1486 
1487  for (x = 1; x < s->blwidth-1; x++) {
1488  block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1489  dstx += p->xbsep;
1490  mctmp += p->xbsep;
1491  }
1492  block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1493 }
1494 
1495 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1496 {
1497  int idx = 0;
1498  if (xblen > 8)
1499  idx = 1;
1500  if (xblen > 16)
1501  idx = 2;
1502 
1503  memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1504  memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1505  s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1506  if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1509  } else {
1510  s->weight_func = NULL;
1511  s->biweight_func = NULL;
1512  }
1513 }
1514 
1515 static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1516 {
1517  /* chroma allocates an edge of 8 when subsampled
1518  which for 4:2:2 means an h edge of 16 and v edge of 8
1519  just use 8 for everything for the moment */
1520  int i, edge = EDGE_WIDTH/2;
1521 
1522  ref->hpel[plane][0] = ref->avframe.data[plane];
1523  s->dsp.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 */
1524 
1525  /* no need for hpel if we only have fpel vectors */
1526  if (!s->mv_precision)
1527  return;
1528 
1529  for (i = 1; i < 4; i++) {
1530  if (!ref->hpel_base[plane][i])
1531  ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe.linesize[plane] + 32);
1532  /* we need to be 16-byte aligned even for chroma */
1533  ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe.linesize[plane] + 16;
1534  }
1535 
1536  if (!ref->interpolated[plane]) {
1537  s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1538  ref->hpel[plane][3], ref->hpel[plane][0],
1539  ref->avframe.linesize[plane], width, height);
1540  s->dsp.draw_edges(ref->hpel[plane][1], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1541  s->dsp.draw_edges(ref->hpel[plane][2], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1542  s->dsp.draw_edges(ref->hpel[plane][3], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1543  }
1544  ref->interpolated[plane] = 1;
1545 }
1546 
1547 /**
1548  * Dirac Specification ->
1549  * 13.0 Transform data syntax. transform_data()
1550  */
1552 {
1553  DWTContext d;
1554  int y, i, comp, dsty;
1555 
1556  if (s->low_delay) {
1557  /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1558  for (comp = 0; comp < 3; comp++) {
1559  Plane *p = &s->plane[comp];
1560  memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1561  }
1562  if (!s->zero_res)
1563  decode_lowdelay(s);
1564  }
1565 
1566  for (comp = 0; comp < 3; comp++) {
1567  Plane *p = &s->plane[comp];
1569 
1570  /* FIXME: small resolutions */
1571  for (i = 0; i < 4; i++)
1572  s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1573 
1574  if (!s->zero_res && !s->low_delay)
1575  {
1576  memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1577  decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1578  }
1580  s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp))
1581  return -1;
1582 
1583  if (!s->num_refs) { /* intra */
1584  for (y = 0; y < p->height; y += 16) {
1585  ff_spatial_idwt_slice2(&d, y+16); /* decode */
1586  s->diracdsp.put_signed_rect_clamped(frame + y*p->stride, p->stride,
1587  p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
1588  }
1589  } else { /* inter */
1590  int rowheight = p->ybsep*p->stride;
1591 
1592  select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1593 
1594  for (i = 0; i < s->num_refs; i++)
1595  interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1596 
1597  memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1598 
1599  dsty = -p->yoffset;
1600  for (y = 0; y < s->blheight; y++) {
1601  int h = 0,
1602  start = FFMAX(dsty, 0);
1603  uint16_t *mctmp = s->mctmp + y*rowheight;
1604  DiracBlock *blocks = s->blmotion + y*s->blwidth;
1605 
1606  init_obmc_weights(s, p, y);
1607 
1608  if (y == s->blheight-1 || start+p->ybsep > p->height)
1609  h = p->height - start;
1610  else
1611  h = p->ybsep - (start - dsty);
1612  if (h < 0)
1613  break;
1614 
1615  memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1616  mc_row(s, blocks, mctmp, comp, dsty);
1617 
1618  mctmp += (start - dsty)*p->stride + p->xoffset;
1619  ff_spatial_idwt_slice2(&d, start + h); /* decode */
1620  s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1621  p->idwt_buf + start*p->idwt_stride, p->idwt_stride, p->width, h);
1622 
1623  dsty += p->ybsep;
1624  }
1625  }
1626  }
1627 
1628 
1629  return 0;
1630 }
1631 
1632 /**
1633  * Dirac Specification ->
1634  * 11.1.1 Picture Header. picture_header()
1635  */
1637 {
1638  int retire, picnum;
1639  int i, j, refnum, refdist;
1640  GetBitContext *gb = &s->gb;
1641 
1642  /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1644 
1645 
1646  av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1647 
1648  /* if this is the first keyframe after a sequence header, start our
1649  reordering from here */
1650  if (s->frame_number < 0)
1651  s->frame_number = picnum;
1652 
1653  s->ref_pics[0] = s->ref_pics[1] = NULL;
1654  for (i = 0; i < s->num_refs; i++) {
1655  refnum = picnum + dirac_get_se_golomb(gb);
1656  refdist = INT_MAX;
1657 
1658  /* find the closest reference to the one we want */
1659  /* Jordi: this is needed if the referenced picture hasn't yet arrived */
1660  for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1661  if (s->ref_frames[j]
1662  && FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum) < refdist) {
1663  s->ref_pics[i] = s->ref_frames[j];
1664  refdist = FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum);
1665  }
1666 
1667  if (!s->ref_pics[i] || refdist)
1668  av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1669 
1670  /* if there were no references at all, allocate one */
1671  if (!s->ref_pics[i])
1672  for (j = 0; j < MAX_FRAMES; j++)
1673  if (!s->all_frames[j].avframe.data[0]) {
1674  s->ref_pics[i] = &s->all_frames[j];
1676  break;
1677  }
1678  }
1679 
1680  /* retire the reference frames that are not used anymore */
1681  if (s->current_picture->avframe.reference) {
1682  retire = picnum + dirac_get_se_golomb(gb);
1683  if (retire != picnum) {
1684  DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1685 
1686  if (retire_pic)
1687  retire_pic->avframe.reference &= DELAYED_PIC_REF;
1688  else
1689  av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1690  }
1691 
1692  /* if reference array is full, remove the oldest as per the spec */
1694  av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1696  }
1697  }
1698 
1699  if (s->num_refs) {
1700  if (dirac_unpack_prediction_parameters(s)) /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1701  return -1;
1702  if (dirac_unpack_block_motion_data(s)) /* [DIRAC_STD] 12. Block motion data syntax */
1703  return -1;
1704  }
1705  if (dirac_unpack_idwt_params(s)) /* [DIRAC_STD] 11.3 Wavelet transform data */
1706  return -1;
1707 
1708  init_planes(s);
1709  return 0;
1710 }
1711 
1712 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
1713 {
1714  DiracFrame *out = s->delay_frames[0];
1715  int i, out_idx = 0;
1716  int ret;
1717 
1718  /* find frame with lowest picture number */
1719  for (i = 1; s->delay_frames[i]; i++)
1721  out = s->delay_frames[i];
1722  out_idx = i;
1723  }
1724 
1725  for (i = out_idx; s->delay_frames[i]; i++)
1726  s->delay_frames[i] = s->delay_frames[i+1];
1727 
1728  if (out) {
1730  *got_frame = 1;
1731  if((ret = av_frame_ref(picture, &out->avframe)) < 0)
1732  return ret;
1733  }
1734 
1735  return 0;
1736 }
1737 
1738 /**
1739  * Dirac Specification ->
1740  * 9.6 Parse Info Header Syntax. parse_info()
1741  * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
1742  */
1743 #define DATA_UNIT_HEADER_SIZE 13
1744 
1745 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
1746  inside the function parse_sequence() */
1747 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
1748 {
1749  DiracContext *s = avctx->priv_data;
1750  DiracFrame *pic = NULL;
1751  int ret, i, parse_code = buf[4];
1752  unsigned tmp;
1753 
1754  if (size < DATA_UNIT_HEADER_SIZE)
1755  return -1;
1756 
1757  init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
1758 
1759  if (parse_code == pc_seq_header) {
1760  if (s->seen_sequence_header)
1761  return 0;
1762 
1763  /* [DIRAC_STD] 10. Sequence header */
1764  if (avpriv_dirac_parse_sequence_header(avctx, &s->gb, &s->source))
1765  return -1;
1766 
1768 
1769  if (alloc_sequence_buffers(s))
1770  return -1;
1771 
1772  s->seen_sequence_header = 1;
1773  } else if (parse_code == pc_eos) { /* [DIRAC_STD] End of Sequence */
1775  s->seen_sequence_header = 0;
1776  } else if (parse_code == pc_aux_data) {
1777  if (buf[13] == 1) { /* encoder implementation/version */
1778  int ver[3];
1779  /* versions older than 1.0.8 don't store quant delta for
1780  subbands with only one codeblock */
1781  if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
1782  if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
1783  s->old_delta_quant = 1;
1784  }
1785  } else if (parse_code & 0x8) { /* picture data unit */
1786  if (!s->seen_sequence_header) {
1787  av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
1788  return -1;
1789  }
1790 
1791  /* find an unused frame */
1792  for (i = 0; i < MAX_FRAMES; i++)
1793  if (s->all_frames[i].avframe.data[0] == NULL)
1794  pic = &s->all_frames[i];
1795  if (!pic) {
1796  av_log(avctx, AV_LOG_ERROR, "framelist full\n");
1797  return -1;
1798  }
1799 
1801 
1802  /* [DIRAC_STD] Defined in 9.6.1 ... */
1803  tmp = parse_code & 0x03; /* [DIRAC_STD] num_refs() */
1804  if (tmp > 2) {
1805  av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
1806  return -1;
1807  }
1808  s->num_refs = tmp;
1809  s->is_arith = (parse_code & 0x48) == 0x08; /* [DIRAC_STD] using_ac() */
1810  s->low_delay = (parse_code & 0x88) == 0x88; /* [DIRAC_STD] is_low_delay() */
1811  pic->avframe.reference = (parse_code & 0x0C) == 0x0C; /* [DIRAC_STD] is_reference() */
1812  pic->avframe.key_frame = s->num_refs == 0; /* [DIRAC_STD] is_intra() */
1813  pic->avframe.pict_type = s->num_refs + 1; /* Definition of AVPictureType in avutil.h */
1814 
1815  if ((ret = ff_get_buffer(avctx, &pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
1816  return ret;
1817  s->current_picture = pic;
1818  s->plane[0].stride = pic->avframe.linesize[0];
1819  s->plane[1].stride = pic->avframe.linesize[1];
1820  s->plane[2].stride = pic->avframe.linesize[2];
1821 
1822  /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
1824  return -1;
1825 
1826  /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
1828  return -1;
1829  }
1830  return 0;
1831 }
1832 
1833 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
1834 {
1835  DiracContext *s = avctx->priv_data;
1836  DiracFrame *picture = data;
1837  uint8_t *buf = pkt->data;
1838  int buf_size = pkt->size;
1839  int i, data_unit_size, buf_idx = 0;
1840  int ret;
1841 
1842  /* release unused frames */
1843  for (i = 0; i < MAX_FRAMES; i++)
1844  if (s->all_frames[i].avframe.data[0] && !s->all_frames[i].avframe.reference) {
1846  memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
1847  }
1848 
1849  s->current_picture = NULL;
1850  *got_frame = 0;
1851 
1852  /* end of stream, so flush delayed pics */
1853  if (buf_size == 0)
1854  return get_delayed_pic(s, (AVFrame *)data, got_frame);
1855 
1856  for (;;) {
1857  /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
1858  [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
1859  BBCD start code search */
1860  for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
1861  if (buf[buf_idx ] == 'B' && buf[buf_idx+1] == 'B' &&
1862  buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
1863  break;
1864  }
1865  /* BBCD found or end of data */
1866  if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
1867  break;
1868 
1869  data_unit_size = AV_RB32(buf+buf_idx+5);
1870  if (buf_idx + data_unit_size > buf_size || !data_unit_size) {
1871  if(buf_idx + data_unit_size > buf_size)
1873  "Data unit with size %d is larger than input buffer, discarding\n",
1874  data_unit_size);
1875  buf_idx += 4;
1876  continue;
1877  }
1878  /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
1879  if (dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size))
1880  {
1881  av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
1882  return -1;
1883  }
1884  buf_idx += data_unit_size;
1885  }
1886 
1887  if (!s->current_picture)
1888  return buf_size;
1889 
1891  DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
1892 
1894 
1896  int min_num = s->delay_frames[0]->avframe.display_picture_number;
1897  /* Too many delayed frames, so we display the frame with the lowest pts */
1898  av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
1899  delayed_frame = s->delay_frames[0];
1900 
1901  for (i = 1; s->delay_frames[i]; i++)
1902  if (s->delay_frames[i]->avframe.display_picture_number < min_num)
1903  min_num = s->delay_frames[i]->avframe.display_picture_number;
1904 
1905  delayed_frame = remove_frame(s->delay_frames, min_num);
1907  }
1908 
1909  if (delayed_frame) {
1910  delayed_frame->avframe.reference ^= DELAYED_PIC_REF;
1911  if((ret=av_frame_ref(data, &delayed_frame->avframe)) < 0)
1912  return ret;
1913  *got_frame = 1;
1914  }
1916  /* The right frame at the right time :-) */
1917  if((ret=av_frame_ref(data, &s->current_picture->avframe)) < 0)
1918  return ret;
1919  *got_frame = 1;
1920  }
1921 
1922  if (*got_frame)
1923  s->frame_number = picture->avframe.display_picture_number + 1;
1924 
1925  return buf_idx;
1926 }
1927 
1929  .name = "dirac",
1930  .long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
1931  .type = AVMEDIA_TYPE_VIDEO,
1932  .id = AV_CODEC_ID_DIRAC,
1933  .priv_data_size = sizeof(DiracContext),
1937  .capabilities = CODEC_CAP_DELAY,
1939 };
#define CHECKEDREAD(dst, cond, errmsg)
int quant
Definition: diracdec.c:103
void(* add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen)
Definition: diracdec.c:209
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2678
unsigned height
Definition: dirac.h:39
const char * s
Definition: avisynth_c.h:668
int blheight
Definition: diracdec.c:192
static av_cold int dirac_decode_end(AVCodecContext *avctx)
Definition: diracdec.c:418
static void 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:475
#define AVERROR_PATCHWELCOME
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
dirac_weight_func weight_func
Definition: diracdec.c:210
#define av_always_inline
Definition: attributes.h:41
uint8_t * sbsplit
Definition: diracdec.c:196
#define CTX_SB_DATA
Definition: dirac_arith.h:65
#define CTX_PMODE_REF2
Definition: dirac_arith.h:67
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:255
DiracFrame * ref_frames[MAX_REFERENCE_FRAMES+1]
Definition: diracdec.c:216
static int divide3(int x)
Definition: diracdec.c:283
static int dirac_decode_frame_internal(DiracContext *s)
Dirac Specification -&gt; 13.0 Transform data syntax.
Definition: diracdec.c:1551
#define SIGN_CTX(x)
Definition: diracdec.c:424
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:212
#define EDGE_TOP
Definition: dsputil.h:262
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:1173
dirac_weight_func weight_dirac_pixels_tab[3]
Definition: diracdsp.h:49
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
Definition: dsputil.h:260
int num
numerator
Definition: rational.h:44
int idwt_width
Definition: diracdec.c:117
int size
Definition: avcodec.h:1064
const char * b
Definition: vf_curves.c:105
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output...
Definition: diracdec.c:73
void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length)
Definition: dirac_arith.c:86
unsigned width
Definition: diracdec.c:167
#define DATA_UNIT_HEADER_SIZE
Dirac Specification -&gt; 9.6 Parse Info Header Syntax.
Definition: diracdec.c:1743
const uint8_t * buffer
Definition: get_bits.h:55
#define DECLARE_ALIGNED(n, t, v)
Definition: avcodec.h:5102
static unsigned svq3_get_ue_golomb(GetBitContext *gb)
Definition: golomb.h:115
uint8_t yoffset
Definition: diracdec.c:132
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
Definition: diracdec.c:1117
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
static const int qoffset_inter_tab[MAX_QUANT+1]
Definition: diracdec.c:271
static int dirac_get_arith_uint(DiracArith *c, int follow_ctx, int data_ctx)
Definition: dirac_arith.h:169
dirac_source_params source
Definition: diracdec.c:142
static void coeff_unpack_arith(DiracArith *c, int qfactor, int qoffset, SubBand *b, IDWTELEM *buf, int x, int y)
Definition: diracdec.c:426
unsigned height
Definition: diracdec.c:168
static void lowdelay_subband(DiracContext *s, GetBitContext *gb, int quant, int slice_x, int slice_y, int bits_end, SubBand *b1, SubBand *b2)
Definition: diracdec.c:646
static void dirac_decode_flush(AVCodecContext *avctx)
Definition: diracdec.c:410
const uint8_t * coeff_data
Definition: diracdec.c:109
static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
Definition: diracdec.c:1712
static int dirac_unpack_idwt_params(DiracContext *s)
Dirac Specification -&gt; 11.3 Wavelet transform data.
Definition: diracdec.c:940
#define DIRAC_REF_MASK_REF2
Definition: diracdec.c:66
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
int zrs[2][2]
Definition: diracdec.c:180
unsigned codeblock_mode
Definition: diracdec.c:164
short IDWTELEM
Definition: dirac_dwt.h:27
int num_refs
Definition: diracdec.c:153
uint8_t xoffset
Definition: diracdec.c:131
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:234
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
Definition: avfilter.c:965
unsigned weight_log2denom
Definition: diracdec.c:189
#define CTX_GLOBAL_BLOCK
Definition: dirac_arith.h:68
int width
Definition: diracdec.c:101
GetBitContext gb
Definition: diracdec.c:684
void(* put_signed_rect_clamped)(uint8_t *dst, int dst_stride, const int16_t *src, int src_stride, int width, int height)
Definition: diracdsp.h:44
DiracFrame * delay_frames[MAX_DELAY+1]
Definition: diracdec.c:217
uint8_t * mcscratch
Definition: diracdec.c:203
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:46
uint8_t
unsigned wavelet_idx
Definition: diracdec.c:157
Interface to Dirac Decoder/Encoder.
#define CTX_PMODE_REF1
Definition: dirac_arith.h:66
static int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
Definition: diracdec.c:458
#define DIVRNDUP(a, b)
Definition: diracdec.c:80
static const uint8_t offset[511][2]
Definition: vf_uspp.c:58
static av_cold int dirac_decode_init(AVCodecContext *avctx)
Definition: diracdec.c:393
uint8_t quant[MAX_DWT_LEVELS][4]
Definition: diracdec.c:175
unsigned num_x
Definition: diracdec.c:172
int low_delay
Definition: diracdec.c:151
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
Plane plane[3]
Definition: diracdec.c:145
static int dirac_get_se_golomb(GetBitContext *gb)
Definition: golomb.h:250
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by a given frame.
Definition: frame.c:247
const char data[16]
Definition: mxf.c:68
static void free_sequence_buffers(DiracContext *s)
Definition: diracdec.c:362
IDWTELEM * idwt_buf_base
Definition: diracdec.c:121
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:207
bitstream reader API header.
#define ff_emulated_edge_mc
Definition: diracdec.c:75
static const uint8_t epel_weights[4][4][4]
Definition: diracdec.c:1305
uint8_t xblen
Definition: diracdec.c:125
static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
Dirac Specification -&gt; 13.5.2 Slices.
Definition: diracdec.c:695
#define FFSWAP(type, a, b)
Definition: avcodec.h:928
#define CTX_DC_DATA
Definition: dirac_arith.h:72
#define A(x)
Definition: vp56_arith.h:28
static const int qoffset_intra_tab[MAX_QUANT+1]
Definition: diracdec.c:260
void(* avg_dirac_pixels_tab[3][4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
Definition: diracdsp.h:42
AVFrame avframe
Definition: diracdec.c:83
static AVFrame * frame
Definition: demuxing.c:51
static void pred_block_dc(DiracBlock *block, int stride, int x, int y)
Definition: diracdec.c:1048
int pan_tilt[2]
Definition: diracdec.c:179
int interpolated[3]
Definition: diracdec.c:84
#define ROLLOFF(i)
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:583
dirac_subband
Definition: diracdec.c:232
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:219
unsigned length
Definition: diracdec.c:108
static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
Definition: diracdec.c:1833
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:30
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);ff_audio_convert_init_arm(ac);ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
uint8_t * hpel[3][4]
Definition: diracdec.c:85
static const uint16_t mask[17]
Definition: lzw.c:37
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:769
void ff_diracdsp_init(DiracDSPContext *c)
Definition: diracdsp.c:176
uint16_t * mctmp
Definition: diracdec.c:202
unsigned m
Definition: audioconvert.c:186
#define DIRAC_REF_MASK_GLOBAL
Definition: diracdec.c:67
static int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
Definition: diracdec.c:1018
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
Definition: diracdec.c:306
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: diracdec.c:1081
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: avcodec.h:4168
const char * arg
Definition: jacosubdec.c:69
unsigned num_y
Definition: diracdec.c:173
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1234
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:1332
unsigned wavelet_depth
Definition: diracdec.c:156
#define CTX_MV_DATA
Definition: dirac_arith.h:70
int stride
Definition: diracdec.c:100
DiracFrame * current_picture
Definition: diracdec.c:213
#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: diracdec.c:51
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:163
Libavcodec external API header.
int avpriv_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb, dirac_source_params *source)
Definition: dirac.c:288
static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
Definition: diracdec.c:1747
DiracDSPContext diracdsp
Definition: diracdec.c:140
int orientation
Definition: diracdec.c:99
#define MAX_BLOCKSIZE
Definition: diracdec.c:60
static char * split(char *message, char delim)
Definition: af_channelmap.c:82
static void init_planes(DiracContext *s)
Definition: diracdec.c:775
int globalmc_flag
Definition: diracdec.c:152
AVCodec ff_dirac_decoder
Definition: diracdec.c:1928
static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block, int stride, int x, int y)
Definition: diracdec.c:1133
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:167
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:351
int display_picture_number
picture number in display order
Definition: frame.h:203
#define CALC_PADDING(size, depth)
Definition: diracdec.c:77
DiracFrame * ref_pics[2]
Definition: diracdec.c:214
void(* avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
Definition: diracdec.c:208
static void block_mc(DiracContext *s, DiracBlock *block, uint16_t *mctmp, uint8_t *obmc_weight, int plane, int dstx, int dsty)
Definition: diracdec.c:1443
float y
static DiracFrame * remove_frame(DiracFrame *framelist[], int picnum)
Definition: diracdec.c:288
void ff_spatial_idwt_slice2(DWTContext *d, int y)
Definition: dirac_dwt.c:558
ret
Definition: avfilter.c:961
attribute_deprecated int reference
Definition: frame.h:212
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
int perspective[2]
Definition: diracdec.c:181
static int dirac_unpack_prediction_parameters(DiracContext *s)
Unpack the motion compensation parameters Dirac Specification -&gt; 11.2 Picture prediction data...
Definition: diracdec.c:828
#define FFMIN(a, b)
Definition: avcodec.h:925
struct DiracContext::@57 globalmc[2]
static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
Definition: diracdec.c:1479
static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
Definition: diracdec.c:1515
unsigned perspective_exp
Definition: diracdec.c:183
int chroma_y_shift
Definition: diracdec.c:147
static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
Definition: diracdec.c:1495
float u
int n
Definition: avisynth_c.h:588
#define EDGE_BOTTOM
Definition: dsputil.h:263
int16_t dc[3]
Definition: diracdec.c:92
void avcodec_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: imgconvert.c:65
uint8_t * edge_emu_buffer_base
Definition: diracdec.c:200
static void intra_dc_prediction(SubBand *b)
Dirac Specification -&gt; 13.3 intra_dc_prediction(band)
Definition: diracdec.c:534
static void decode_component(DiracContext *s, int comp)
Dirac Specification -&gt; [DIRAC_STD] 13.4.1 core_transform_data()
Definition: diracdec.c:610
static void flush(AVCodecContext *avctx)
Definition: aacdec.c:498
static void init_obmc_weights(DiracContext *s, Plane *p, int by)
Definition: diracdec.c:1292
static const float pred[4]
Definition: siprdata.h:259
void(* add_dirac_obmc[3])(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen)
Definition: diracdsp.h:47
SubBand band[MAX_DWT_LEVELS][4]
Definition: diracdec.c:134
static const int8_t mv[256][2]
Definition: 4xm.c:73
static int width
Definition: utils.c:158
uint8_t ybsep
Definition: diracdec.c:129
static av_always_inline void decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
Dirac Specification -&gt; 13.4.2 Non-skipped subbands.
Definition: diracdec.c:558
AVS_Value src
Definition: avisynth_c.h:523
uint8_t * edge_emu_buffer[4]
Definition: diracdec.c:199
static void decode_lowdelay(DiracContext *s)
Dirac Specification -&gt; 13.5.1 low_delay_transform_data()
Definition: diracdec.c:737
#define FFMAX(a, b)
Definition: avcodec.h:923
typedef void(RENAME(mix_any_func_type))
int seen_sequence_header
Definition: diracdec.c:143
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:436
static const uint8_t default_qmat[][4][4]
Definition: diracdec.c:239
void(* dirac_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int h)
Definition: diracdsp.h:26
main external API structure.
Definition: avcodec.h:1146
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:538
MPEG1/2 tables.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:941
DiracFrame all_frames[MAX_FRAMES]
Definition: diracdec.c:218
DSPContext dsp
Definition: diracdec.c:139
Arithmetic decoder for Dirac.
struct SubBand * parent
Definition: diracdec.c:105
void * buf
Definition: avisynth_c.h:594
dirac_biweight_func biweight_dirac_pixels_tab[3]
Definition: diracdsp.h:50
IDWTELEM * idwt_buf
Definition: diracdec.c:120
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:1046
int frame_number
Definition: diracdec.c:144
static int dirac_get_arith_bit(DiracArith *c, int ctx)
Definition: dirac_arith.h:128
AVCodecContext * avctx
Definition: diracdec.c:138
rational number numerator/denominator
Definition: rational.h:43
uint8_t * data
Definition: avcodec.h:1063
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:405
GetBitContext gb
Definition: diracdec.c:141
#define mid_pred
Definition: mathops.h:94
dirac_biweight_func biweight_func
Definition: diracdec.c:211
int ff_spatial_idwt_init2(DWTContext *d, IDWTELEM *buffer, int width, int height, int stride, enum dwt_type type, int decomposition_count, IDWTELEM *temp)
Definition: dirac_dwt.c:461
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
uint8_t xbsep
Definition: diracdec.c:128
int chroma_x_shift
Definition: diracdec.c:146
AVRational bytes
Definition: diracdec.c:174
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:332
static int decode_subband_arith(AVCodecContext *avctx, void *b)
Definition: diracdec.c:591
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1247
static const int qscale_tab[MAX_QUANT+1]
Definition: diracdec.c:249
#define MAX_DELAY
Definition: diracdec.c:57
int zero_res
Definition: diracdec.c:149
const uint8_t * quant
#define FFABS(a)
Definition: avcodec.h:920
void * priv_data
Definition: avcodec.h:1182
#define MAX_FRAMES
Definition: diracdec.c:58
union DiracBlock::@54 u
uint8_t level
Definition: svq3.c:146
static int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
Definition: diracdec.c:1032
#define MAX_QUANT
Definition: diracdec.c:59
DiracBlock * blmotion
Definition: diracdec.c:197
#define CODEC_FLAG_EMU_EDGE
Don&#39;t draw edges.
Definition: avcodec.h:706
#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:56
int idwt_stride
Definition: diracdec.c:119
static int dirac_decode_picture_header(DiracContext *s)
Dirac Specification -&gt; 11.1.1 Picture Header.
Definition: diracdec.c:1636
common internal api header.
struct DiracContext::@56 lowdelay
ptrdiff_t stride
Definition: diracdec.c:115
static double c[64]
static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
Definition: diracdec.c:598
int16_t weight[2]
Definition: diracdec.c:188
#define FFALIGN(x, a)
Definition: avcodec.h:930
int16_t mv[2][2]
Definition: diracdec.c:91
static int dirac_get_arith_int(DiracArith *c, int follow_ctx, int data_ctx)
Definition: dirac_arith.h:180
#define CTX_MV_F1
Definition: dirac_arith.h:69
int sbheight
Definition: diracdec.c:194
int den
denominator
Definition: rational.h:45
struct DiracContext::@55 codeblock[MAX_DWT_LEVELS+1]
static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride, int left, int right, int wy)
Definition: diracdec.c:1259
Core video DSP helper functions.
void(* put_dirac_pixels_tab[3][4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
dirac_pixels_tab[width][subpel] width is 2 for 32, 1 for 16, 0 for 8 subpel is 0 for fpel and hpel (o...
Definition: diracdsp.h:41
DSP utils.
#define CTX_DC_F1
Definition: dirac_arith.h:71
int idwt_height
Definition: diracdec.c:118
#define AV_RB32(x)
Definition: intreadwrite.h:258
dirac_parse_code
Dirac Specification -&gt; Parse code values.
Definition: diracdec.c:225
static int alloc_sequence_buffers(DiracContext *s)
Definition: diracdec.c:317
void(* put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h)
Definition: diracdec.c:207
static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride, int left, int right, int top, int bottom)
Definition: diracdec.c:1273
#define AVERROR_INVALIDDATA
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:2636
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);ff_audio_convert_init_arm(ac);ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
#define CTX_SB_F1
Definition: dirac_arith.h:64
#define av_log2
Definition: intmath.h:89
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:27
#define EDGE_WIDTH
Definition: dsputil.h:261
int key_frame
1 -&gt; keyframe, 0-&gt; not
Definition: frame.h:162
int height
Definition: diracdec.c:102
IDWTELEM * ibuf
Definition: diracdec.c:104
static const double coeff[2][5]
Definition: vf_owdenoise.c:71
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:444
#define AVERROR(e)
int width
Definition: diracdec.c:113
uint8_t ref
Definition: diracdec.c:94
int is_arith
Definition: diracdec.c:150
static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)
Definition: eamad.c:71
static void add_dc(uint16_t *dst, int dc, int stride, uint8_t *obmc_weight, int xblen, int yblen)
Definition: diracdec.c:1427
void INT64 start
Definition: avisynth_c.h:594
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
uint8_t * hpel_base[3][4]
Definition: diracdec.c:86
static AVPacket pkt
Definition: demuxing.c:52
int height
Definition: diracdec.c:114
IDWTELEM * idwt_tmp
Definition: diracdec.c:122
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1040
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:910
unsigned width
Definition: dirac.h:38
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
#define DIRAC_REF_MASK_REF1
DiracBlock-&gt;ref flags, if set then the block does MC from the given ref.
Definition: diracdec.c:65
unsigned zrs_exp
Definition: diracdec.c:182
uint8_t mv_precision
Definition: diracdec.c:187
static int dirac_unpack_block_motion_data(DiracContext *s)
Dirac Specification -&gt;
Definition: diracdec.c:1192
uint8_t obmc_weight[3][MAX_BLOCKSIZE *MAX_BLOCKSIZE]
Definition: diracdec.c:205
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:241
DSPContext.
Definition: dsputil.h:124
int level
Definition: diracdec.c:98
uint8_t yblen
Definition: diracdec.c:126
static int16_t block[64]
Definition: dct-test.c:198