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