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 "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  int i;
397 
398  s->avctx = avctx;
399  s->frame_number = -1;
400 
401  ff_dsputil_init(&s->dsp, avctx);
403 
404  for (i = 0; i < MAX_FRAMES; i++) {
406  if (!s->all_frames[i].avframe) {
407  while (i > 0)
408  av_frame_free(&s->all_frames[--i].avframe);
409  return AVERROR(ENOMEM);
410  }
411  }
412 
413  return 0;
414 }
415 
417 {
418  DiracContext *s = avctx->priv_data;
420  s->seen_sequence_header = 0;
421  s->frame_number = -1;
422 }
423 
425 {
426  DiracContext *s = avctx->priv_data;
427  int i;
428 
429  dirac_decode_flush(avctx);
430  for (i = 0; i < MAX_FRAMES; i++)
432 
433  return 0;
434 }
435 
436 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
437 
438 static inline void coeff_unpack_arith(DiracArith *c, int qfactor, int qoffset,
439  SubBand *b, IDWTELEM *buf, int x, int y)
440 {
441  int coeff, sign;
442  int sign_pred = 0;
443  int pred_ctx = CTX_ZPZN_F1;
444 
445  /* Check if the parent subband has a 0 in the corresponding position */
446  if (b->parent)
447  pred_ctx += !!b->parent->ibuf[b->parent->stride * (y>>1) + (x>>1)] << 1;
448 
449  if (b->orientation == subband_hl)
450  sign_pred = buf[-b->stride];
451 
452  /* Determine if the pixel has only zeros in its neighbourhood */
453  if (x) {
454  pred_ctx += !(buf[-1] | buf[-b->stride] | buf[-1-b->stride]);
455  if (b->orientation == subband_lh)
456  sign_pred = buf[-1];
457  } else {
458  pred_ctx += !buf[-b->stride];
459  }
460 
461  coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA);
462  if (coeff) {
463  coeff = (coeff * qfactor + qoffset + 2) >> 2;
464  sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred));
465  coeff = (coeff ^ -sign) + sign;
466  }
467  *buf = coeff;
468 }
469 
470 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
471 {
472  int sign, coeff;
473 
474  coeff = svq3_get_ue_golomb(gb);
475  if (coeff) {
476  coeff = (coeff * qfactor + qoffset + 2) >> 2;
477  sign = get_bits1(gb);
478  coeff = (coeff ^ -sign) + sign;
479  }
480  return coeff;
481 }
482 
483 /**
484  * Decode the coeffs in the rectangle defined by left, right, top, bottom
485  * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
486  */
487 static inline void codeblock(DiracContext *s, SubBand *b,
488  GetBitContext *gb, DiracArith *c,
489  int left, int right, int top, int bottom,
490  int blockcnt_one, int is_arith)
491 {
492  int x, y, zero_block;
493  int qoffset, qfactor;
494  IDWTELEM *buf;
495 
496  /* check for any coded coefficients in this codeblock */
497  if (!blockcnt_one) {
498  if (is_arith)
499  zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
500  else
501  zero_block = get_bits1(gb);
502 
503  if (zero_block)
504  return;
505  }
506 
507  if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
508  int quant = b->quant;
509  if (is_arith)
511  else
512  quant += dirac_get_se_golomb(gb);
513  if (quant < 0) {
514  av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
515  return;
516  }
517  b->quant = quant;
518  }
519 
520  b->quant = FFMIN(b->quant, MAX_QUANT);
521 
522  qfactor = qscale_tab[b->quant];
523  /* TODO: context pointer? */
524  if (!s->num_refs)
525  qoffset = qoffset_intra_tab[b->quant];
526  else
527  qoffset = qoffset_inter_tab[b->quant];
528 
529  buf = b->ibuf + top * b->stride;
530  for (y = top; y < bottom; y++) {
531  for (x = left; x < right; x++) {
532  /* [DIRAC_STD] 13.4.4 Subband coefficients. coeff_unpack() */
533  if (is_arith)
534  coeff_unpack_arith(c, qfactor, qoffset, b, buf+x, x, y);
535  else
536  buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
537  }
538  buf += b->stride;
539  }
540 }
541 
542 /**
543  * Dirac Specification ->
544  * 13.3 intra_dc_prediction(band)
545  */
546 static inline void intra_dc_prediction(SubBand *b)
547 {
548  IDWTELEM *buf = b->ibuf;
549  int x, y;
550 
551  for (x = 1; x < b->width; x++)
552  buf[x] += buf[x-1];
553  buf += b->stride;
554 
555  for (y = 1; y < b->height; y++) {
556  buf[0] += buf[-b->stride];
557 
558  for (x = 1; x < b->width; x++) {
559  int pred = buf[x - 1] + buf[x - b->stride] + buf[x - b->stride-1];
560  buf[x] += divide3(pred);
561  }
562  buf += b->stride;
563  }
564 }
565 
566 /**
567  * Dirac Specification ->
568  * 13.4.2 Non-skipped subbands. subband_coeffs()
569  */
571 {
572  int cb_x, cb_y, left, right, top, bottom;
573  DiracArith c;
574  GetBitContext gb;
575  int cb_width = s->codeblock[b->level + (b->orientation != subband_ll)].width;
576  int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
577  int blockcnt_one = (cb_width + cb_height) == 2;
578 
579  if (!b->length)
580  return;
581 
582  init_get_bits8(&gb, b->coeff_data, b->length);
583 
584  if (is_arith)
585  ff_dirac_init_arith_decoder(&c, &gb, b->length);
586 
587  top = 0;
588  for (cb_y = 0; cb_y < cb_height; cb_y++) {
589  bottom = (b->height * (cb_y+1)) / cb_height;
590  left = 0;
591  for (cb_x = 0; cb_x < cb_width; cb_x++) {
592  right = (b->width * (cb_x+1)) / cb_width;
593  codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
594  left = right;
595  }
596  top = bottom;
597  }
598 
599  if (b->orientation == subband_ll && s->num_refs == 0)
601 }
602 
603 static int decode_subband_arith(AVCodecContext *avctx, void *b)
604 {
605  DiracContext *s = avctx->priv_data;
606  decode_subband_internal(s, b, 1);
607  return 0;
608 }
609 
610 static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
611 {
612  DiracContext *s = avctx->priv_data;
613  SubBand **b = arg;
614  decode_subband_internal(s, *b, 0);
615  return 0;
616 }
617 
618 /**
619  * Dirac Specification ->
620  * [DIRAC_STD] 13.4.1 core_transform_data()
621  */
623 {
624  AVCodecContext *avctx = s->avctx;
625  SubBand *bands[3*MAX_DWT_LEVELS+1];
626  enum dirac_subband orientation;
627  int level, num_bands = 0;
628 
629  /* Unpack all subbands at all levels. */
630  for (level = 0; level < s->wavelet_depth; level++) {
631  for (orientation = !!level; orientation < 4; orientation++) {
632  SubBand *b = &s->plane[comp].band[level][orientation];
633  bands[num_bands++] = b;
634 
635  align_get_bits(&s->gb);
636  /* [DIRAC_STD] 13.4.2 subband() */
637  b->length = svq3_get_ue_golomb(&s->gb);
638  if (b->length) {
639  b->quant = svq3_get_ue_golomb(&s->gb);
640  align_get_bits(&s->gb);
641  b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
642  b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
643  skip_bits_long(&s->gb, b->length*8);
644  }
645  }
646  /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
647  if (s->is_arith)
648  avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
649  NULL, 4-!!level, sizeof(SubBand));
650  }
651  /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
652  if (!s->is_arith)
653  avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
654 }
655 
656 /* [DIRAC_STD] 13.5.5.2 Luma slice subband data. luma_slice_band(level,orient,sx,sy) --> if b2 == NULL */
657 /* [DIRAC_STD] 13.5.5.3 Chroma slice subband data. chroma_slice_band(level,orient,sx,sy) --> if b2 != NULL */
659  int slice_x, int slice_y, int bits_end,
660  SubBand *b1, SubBand *b2)
661 {
662  int left = b1->width * slice_x / s->lowdelay.num_x;
663  int right = b1->width *(slice_x+1) / s->lowdelay.num_x;
664  int top = b1->height * slice_y / s->lowdelay.num_y;
665  int bottom = b1->height *(slice_y+1) / s->lowdelay.num_y;
666 
667  int qfactor = qscale_tab[FFMIN(quant, MAX_QUANT)];
668  int qoffset = qoffset_intra_tab[FFMIN(quant, MAX_QUANT)];
669 
670  IDWTELEM *buf1 = b1->ibuf + top * b1->stride;
671  IDWTELEM *buf2 = b2 ? b2->ibuf + top * b2->stride : NULL;
672  int x, y;
673  /* we have to constantly check for overread since the spec explictly
674  requires this, with the meaning that all remaining coeffs are set to 0 */
675  if (get_bits_count(gb) >= bits_end)
676  return;
677 
678  for (y = top; y < bottom; y++) {
679  for (x = left; x < right; x++) {
680  buf1[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
681  if (get_bits_count(gb) >= bits_end)
682  return;
683  if (buf2) {
684  buf2[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
685  if (get_bits_count(gb) >= bits_end)
686  return;
687  }
688  }
689  buf1 += b1->stride;
690  if (buf2)
691  buf2 += b2->stride;
692  }
693 }
694 
697  int slice_x;
698  int slice_y;
699  int bytes;
700 };
701 
702 
703 /**
704  * Dirac Specification ->
705  * 13.5.2 Slices. slice(sx,sy)
706  */
707 static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
708 {
709  DiracContext *s = avctx->priv_data;
710  struct lowdelay_slice *slice = arg;
711  GetBitContext *gb = &slice->gb;
712  enum dirac_subband orientation;
713  int level, quant, chroma_bits, chroma_end;
714 
715  int quant_base = get_bits(gb, 7); /*[DIRAC_STD] qindex */
716  int length_bits = av_log2(8 * slice->bytes)+1;
717  int luma_bits = get_bits_long(gb, length_bits);
718  int luma_end = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
719 
720  /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
721  for (level = 0; level < s->wavelet_depth; level++)
722  for (orientation = !!level; orientation < 4; orientation++) {
723  quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
724  lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
725  &s->plane[0].band[level][orientation], NULL);
726  }
727 
728  /* consume any unused bits from luma */
729  skip_bits_long(gb, get_bits_count(gb) - luma_end);
730 
731  chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
732  chroma_end = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
733  /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
734  for (level = 0; level < s->wavelet_depth; level++)
735  for (orientation = !!level; orientation < 4; orientation++) {
736  quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
737  lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
738  &s->plane[1].band[level][orientation],
739  &s->plane[2].band[level][orientation]);
740  }
741 
742  return 0;
743 }
744 
745 /**
746  * Dirac Specification ->
747  * 13.5.1 low_delay_transform_data()
748  */
750 {
751  AVCodecContext *avctx = s->avctx;
752  int slice_x, slice_y, bytes, bufsize;
753  const uint8_t *buf;
754  struct lowdelay_slice *slices;
755  int slice_num = 0;
756 
757  slices = av_mallocz(s->lowdelay.num_x * s->lowdelay.num_y * sizeof(struct lowdelay_slice));
758 
759  align_get_bits(&s->gb);
760  /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
761  buf = s->gb.buffer + get_bits_count(&s->gb)/8;
762  bufsize = get_bits_left(&s->gb);
763 
764  for (slice_y = 0; bufsize > 0 && slice_y < s->lowdelay.num_y; slice_y++)
765  for (slice_x = 0; bufsize > 0 && slice_x < s->lowdelay.num_x; slice_x++) {
766  bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
767  - slice_num * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
768 
769  slices[slice_num].bytes = bytes;
770  slices[slice_num].slice_x = slice_x;
771  slices[slice_num].slice_y = slice_y;
772  init_get_bits(&slices[slice_num].gb, buf, bufsize);
773  slice_num++;
774 
775  buf += bytes;
776  bufsize -= bytes*8;
777  }
778 
779  avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
780  sizeof(struct lowdelay_slice)); /* [DIRAC_STD] 13.5.2 Slices */
781  intra_dc_prediction(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
782  intra_dc_prediction(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
783  intra_dc_prediction(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
784  av_free(slices);
785 }
786 
788 {
789  int i, w, h, level, orientation;
790 
791  for (i = 0; i < 3; i++) {
792  Plane *p = &s->plane[i];
793 
794  p->width = s->source.width >> (i ? s->chroma_x_shift : 0);
795  p->height = s->source.height >> (i ? s->chroma_y_shift : 0);
796  p->idwt_width = w = CALC_PADDING(p->width , s->wavelet_depth);
797  p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
798  p->idwt_stride = FFALIGN(p->idwt_width, 8);
799 
800  for (level = s->wavelet_depth-1; level >= 0; level--) {
801  w = w>>1;
802  h = h>>1;
803  for (orientation = !!level; orientation < 4; orientation++) {
804  SubBand *b = &p->band[level][orientation];
805 
806  b->ibuf = p->idwt_buf;
807  b->level = level;
808  b->stride = p->idwt_stride << (s->wavelet_depth - level);
809  b->width = w;
810  b->height = h;
811  b->orientation = orientation;
812 
813  if (orientation & 1)
814  b->ibuf += w;
815  if (orientation > 1)
816  b->ibuf += b->stride>>1;
817 
818  if (level)
819  b->parent = &p->band[level-1][orientation];
820  }
821  }
822 
823  if (i > 0) {
824  p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
825  p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
826  p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
827  p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
828  }
829 
830  p->xoffset = (p->xblen - p->xbsep)/2;
831  p->yoffset = (p->yblen - p->ybsep)/2;
832  }
833 }
834 
835 /**
836  * Unpack the motion compensation parameters
837  * Dirac Specification ->
838  * 11.2 Picture prediction data. picture_prediction()
839  */
841 {
842  static const uint8_t default_blen[] = { 4, 12, 16, 24 };
843  static const uint8_t default_bsep[] = { 4, 8, 12, 16 };
844 
845  GetBitContext *gb = &s->gb;
846  unsigned idx, ref;
847 
848  align_get_bits(gb);
849  /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
850  /* Luma and Chroma are equal. 11.2.3 */
851  idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
852 
853  if (idx > 4) {
854  av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
855  return -1;
856  }
857 
858  if (idx == 0) {
859  s->plane[0].xblen = svq3_get_ue_golomb(gb);
860  s->plane[0].yblen = svq3_get_ue_golomb(gb);
861  s->plane[0].xbsep = svq3_get_ue_golomb(gb);
862  s->plane[0].ybsep = svq3_get_ue_golomb(gb);
863  } else {
864  /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
865  s->plane[0].xblen = default_blen[idx-1];
866  s->plane[0].yblen = default_blen[idx-1];
867  s->plane[0].xbsep = default_bsep[idx-1];
868  s->plane[0].ybsep = default_bsep[idx-1];
869  }
870  /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
871  Calculated in function dirac_unpack_block_motion_data */
872 
873  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) {
874  av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
875  return -1;
876  }
877  if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
878  av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
879  return -1;
880  }
881  if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
882  av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
883  return -1;
884  }
885 
886  /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
887  Read motion vector precision */
889  if (s->mv_precision > 3) {
890  av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
891  return -1;
892  }
893 
894  /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
895  Read the global motion compensation parameters */
896  s->globalmc_flag = get_bits1(gb);
897  if (s->globalmc_flag) {
898  memset(s->globalmc, 0, sizeof(s->globalmc));
899  /* [DIRAC_STD] pan_tilt(gparams) */
900  for (ref = 0; ref < s->num_refs; ref++) {
901  if (get_bits1(gb)) {
902  s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
903  s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
904  }
905  /* [DIRAC_STD] zoom_rotate_shear(gparams)
906  zoom/rotation/shear parameters */
907  if (get_bits1(gb)) {
908  s->globalmc[ref].zrs_exp = svq3_get_ue_golomb(gb);
909  s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
910  s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
911  s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
912  s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
913  } else {
914  s->globalmc[ref].zrs[0][0] = 1;
915  s->globalmc[ref].zrs[1][1] = 1;
916  }
917  /* [DIRAC_STD] perspective(gparams) */
918  if (get_bits1(gb)) {
920  s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb);
921  s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb);
922  }
923  }
924  }
925 
926  /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
927  Picture prediction mode, not currently used. */
928  if (svq3_get_ue_golomb(gb)) {
929  av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
930  return -1;
931  }
932 
933  /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
934  just data read, weight calculation will be done later on. */
935  s->weight_log2denom = 1;
936  s->weight[0] = 1;
937  s->weight[1] = 1;
938 
939  if (get_bits1(gb)) {
941  s->weight[0] = dirac_get_se_golomb(gb);
942  if (s->num_refs == 2)
943  s->weight[1] = dirac_get_se_golomb(gb);
944  }
945  return 0;
946 }
947 
948 /**
949  * Dirac Specification ->
950  * 11.3 Wavelet transform data. wavelet_transform()
951  */
953 {
954  GetBitContext *gb = &s->gb;
955  int i, level;
956  unsigned tmp;
957 
958 #define CHECKEDREAD(dst, cond, errmsg) \
959  tmp = svq3_get_ue_golomb(gb); \
960  if (cond) { \
961  av_log(s->avctx, AV_LOG_ERROR, errmsg); \
962  return -1; \
963  }\
964  dst = tmp;
965 
966  align_get_bits(gb);
967 
968  s->zero_res = s->num_refs ? get_bits1(gb) : 0;
969  if (s->zero_res)
970  return 0;
971 
972  /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
973  CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
974 
975  CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
976 
977  if (!s->low_delay) {
978  /* Codeblock parameters (core syntax only) */
979  if (get_bits1(gb)) {
980  for (i = 0; i <= s->wavelet_depth; i++) {
981  CHECKEDREAD(s->codeblock[i].width , tmp < 1, "codeblock width invalid\n")
982  CHECKEDREAD(s->codeblock[i].height, tmp < 1, "codeblock height invalid\n")
983  }
984 
985  CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
986  } else
987  for (i = 0; i <= s->wavelet_depth; i++)
988  s->codeblock[i].width = s->codeblock[i].height = 1;
989  } else {
990  /* Slice parameters + quantization matrix*/
991  /*[DIRAC_STD] 11.3.4 Slice coding Parameters (low delay syntax only). slice_parameters() */
996 
997  if (s->lowdelay.bytes.den <= 0) {
998  av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
999  return AVERROR_INVALIDDATA;
1000  }
1001 
1002  /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
1003  if (get_bits1(gb)) {
1004  av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
1005  /* custom quantization matrix */
1006  s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
1007  for (level = 0; level < s->wavelet_depth; level++) {
1008  s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
1009  s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
1010  s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
1011  }
1012  } else {
1013  if (s->wavelet_depth > 4) {
1014  av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1015  return AVERROR_INVALIDDATA;
1016  }
1017  /* default quantization matrix */
1018  for (level = 0; level < s->wavelet_depth; level++)
1019  for (i = 0; i < 4; i++) {
1020  s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
1021  /* haar with no shift differs for different depths */
1022  if (s->wavelet_idx == 3)
1023  s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1024  }
1025  }
1026  }
1027  return 0;
1028 }
1029 
1030 static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1031 {
1032  static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1033 
1034  if (!(x|y))
1035  return 0;
1036  else if (!y)
1037  return sbsplit[-1];
1038  else if (!x)
1039  return sbsplit[-stride];
1040 
1041  return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1042 }
1043 
1044 static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1045 {
1046  int pred;
1047 
1048  if (!(x|y))
1049  return 0;
1050  else if (!y)
1051  return block[-1].ref & refmask;
1052  else if (!x)
1053  return block[-stride].ref & refmask;
1054 
1055  /* return the majority */
1056  pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1057  return (pred >> 1) & refmask;
1058 }
1059 
1060 static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1061 {
1062  int i, n = 0;
1063 
1064  memset(block->u.dc, 0, sizeof(block->u.dc));
1065 
1066  if (x && !(block[-1].ref & 3)) {
1067  for (i = 0; i < 3; i++)
1068  block->u.dc[i] += block[-1].u.dc[i];
1069  n++;
1070  }
1071 
1072  if (y && !(block[-stride].ref & 3)) {
1073  for (i = 0; i < 3; i++)
1074  block->u.dc[i] += block[-stride].u.dc[i];
1075  n++;
1076  }
1077 
1078  if (x && y && !(block[-1-stride].ref & 3)) {
1079  for (i = 0; i < 3; i++)
1080  block->u.dc[i] += block[-1-stride].u.dc[i];
1081  n++;
1082  }
1083 
1084  if (n == 2) {
1085  for (i = 0; i < 3; i++)
1086  block->u.dc[i] = (block->u.dc[i]+1)>>1;
1087  } else if (n == 3) {
1088  for (i = 0; i < 3; i++)
1089  block->u.dc[i] = divide3(block->u.dc[i]);
1090  }
1091 }
1092 
1093 static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1094 {
1095  int16_t *pred[3];
1096  int refmask = ref+1;
1097  int mask = refmask | DIRAC_REF_MASK_GLOBAL; /* exclude gmc blocks */
1098  int n = 0;
1099 
1100  if (x && (block[-1].ref & mask) == refmask)
1101  pred[n++] = block[-1].u.mv[ref];
1102 
1103  if (y && (block[-stride].ref & mask) == refmask)
1104  pred[n++] = block[-stride].u.mv[ref];
1105 
1106  if (x && y && (block[-stride-1].ref & mask) == refmask)
1107  pred[n++] = block[-stride-1].u.mv[ref];
1108 
1109  switch (n) {
1110  case 0:
1111  block->u.mv[ref][0] = 0;
1112  block->u.mv[ref][1] = 0;
1113  break;
1114  case 1:
1115  block->u.mv[ref][0] = pred[0][0];
1116  block->u.mv[ref][1] = pred[0][1];
1117  break;
1118  case 2:
1119  block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1120  block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1121  break;
1122  case 3:
1123  block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1124  block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1125  break;
1126  }
1127 }
1128 
1129 static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1130 {
1131  int ez = s->globalmc[ref].zrs_exp;
1132  int ep = s->globalmc[ref].perspective_exp;
1133  int (*A)[2] = s->globalmc[ref].zrs;
1134  int *b = s->globalmc[ref].pan_tilt;
1135  int *c = s->globalmc[ref].perspective;
1136 
1137  int m = (1<<ep) - (c[0]*x + c[1]*y);
1138  int mx = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
1139  int my = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
1140 
1141  block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1142  block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1143 }
1144 
1146  int stride, int x, int y)
1147 {
1148  int i;
1149 
1150  block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1151  block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1152 
1153  if (s->num_refs == 2) {
1154  block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1155  block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1156  }
1157 
1158  if (!block->ref) {
1159  pred_block_dc(block, stride, x, y);
1160  for (i = 0; i < 3; i++)
1161  block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1162  return;
1163  }
1164 
1165  if (s->globalmc_flag) {
1166  block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1167  block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1168  }
1169 
1170  for (i = 0; i < s->num_refs; i++)
1171  if (block->ref & (i+1)) {
1172  if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1173  global_mv(s, block, x, y, i);
1174  } else {
1175  pred_mv(block, stride, x, y, i);
1176  block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1177  block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1178  }
1179  }
1180 }
1181 
1182 /**
1183  * Copies the current block to the other blocks covered by the current superblock split mode
1184  */
1186 {
1187  int x, y;
1188  DiracBlock *dst = block;
1189 
1190  for (x = 1; x < size; x++)
1191  dst[x] = *block;
1192 
1193  for (y = 1; y < size; y++) {
1194  dst += stride;
1195  for (x = 0; x < size; x++)
1196  dst[x] = *block;
1197  }
1198 }
1199 
1200 /**
1201  * Dirac Specification ->
1202  * 12. Block motion data syntax
1203  */
1205 {
1206  GetBitContext *gb = &s->gb;
1207  uint8_t *sbsplit = s->sbsplit;
1208  int i, x, y, q, p;
1209  DiracArith arith[8];
1210 
1211  align_get_bits(gb);
1212 
1213  /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1214  s->sbwidth = DIVRNDUP(s->source.width, 4*s->plane[0].xbsep);
1215  s->sbheight = DIVRNDUP(s->source.height, 4*s->plane[0].ybsep);
1216  s->blwidth = 4 * s->sbwidth;
1217  s->blheight = 4 * s->sbheight;
1218 
1219  /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1220  decode superblock split modes */
1221  ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb)); /* svq3_get_ue_golomb(gb) is the length */
1222  for (y = 0; y < s->sbheight; y++) {
1223  for (x = 0; x < s->sbwidth; x++) {
1224  unsigned int split = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1225  if (split > 2)
1226  return -1;
1227  sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1228  }
1229  sbsplit += s->sbwidth;
1230  }
1231 
1232  /* setup arith decoding */
1234  for (i = 0; i < s->num_refs; i++) {
1235  ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
1236  ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
1237  }
1238  for (i = 0; i < 3; i++)
1239  ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
1240 
1241  for (y = 0; y < s->sbheight; y++)
1242  for (x = 0; x < s->sbwidth; x++) {
1243  int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1244  int step = 4 >> s->sbsplit[y * s->sbwidth + x];
1245 
1246  for (q = 0; q < blkcnt; q++)
1247  for (p = 0; p < blkcnt; p++) {
1248  int bx = 4 * x + p*step;
1249  int by = 4 * y + q*step;
1250  DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1251  decode_block_params(s, arith, block, s->blwidth, bx, by);
1252  propagate_block_data(block, s->blwidth, step);
1253  }
1254  }
1255 
1256  return 0;
1257 }
1258 
1259 static int weight(int i, int blen, int offset)
1260 {
1261 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \
1262  (1 + (6*(i) + offset - 1) / (2*offset - 1))
1263 
1264  if (i < 2*offset)
1265  return ROLLOFF(i);
1266  else if (i > blen-1 - 2*offset)
1267  return ROLLOFF(blen-1 - i);
1268  return 8;
1269 }
1270 
1271 static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1272  int left, int right, int wy)
1273 {
1274  int x;
1275  for (x = 0; left && x < p->xblen >> 1; x++)
1276  obmc_weight[x] = wy*8;
1277  for (; x < p->xblen >> right; x++)
1278  obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1279  for (; x < p->xblen; x++)
1280  obmc_weight[x] = wy*8;
1281  for (; x < stride; x++)
1282  obmc_weight[x] = 0;
1283 }
1284 
1285 static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1286  int left, int right, int top, int bottom)
1287 {
1288  int y;
1289  for (y = 0; top && y < p->yblen >> 1; y++) {
1290  init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1291  obmc_weight += stride;
1292  }
1293  for (; y < p->yblen >> bottom; y++) {
1294  int wy = weight(y, p->yblen, p->yoffset);
1295  init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1296  obmc_weight += stride;
1297  }
1298  for (; y < p->yblen; y++) {
1299  init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1300  obmc_weight += stride;
1301  }
1302 }
1303 
1304 static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1305 {
1306  int top = !by;
1307  int bottom = by == s->blheight-1;
1308 
1309  /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1310  if (top || bottom || by == 1) {
1311  init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1312  init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1313  init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1314  }
1315 }
1316 
1317 static const uint8_t epel_weights[4][4][4] = {
1318  {{ 16, 0, 0, 0 },
1319  { 12, 4, 0, 0 },
1320  { 8, 8, 0, 0 },
1321  { 4, 12, 0, 0 }},
1322  {{ 12, 0, 4, 0 },
1323  { 9, 3, 3, 1 },
1324  { 6, 6, 2, 2 },
1325  { 3, 9, 1, 3 }},
1326  {{ 8, 0, 8, 0 },
1327  { 6, 2, 6, 2 },
1328  { 4, 4, 4, 4 },
1329  { 2, 6, 2, 6 }},
1330  {{ 4, 0, 12, 0 },
1331  { 3, 1, 9, 3 },
1332  { 2, 2, 6, 6 },
1333  { 1, 3, 3, 9 }}
1334 };
1335 
1336 /**
1337  * For block x,y, determine which of the hpel planes to do bilinear
1338  * interpolation from and set src[] to the location in each hpel plane
1339  * to MC from.
1340  *
1341  * @return the index of the put_dirac_pixels_tab function to use
1342  * 0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1343  */
1345  int x, int y, int ref, int plane)
1346 {
1347  Plane *p = &s->plane[plane];
1348  uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1349  int motion_x = block->u.mv[ref][0];
1350  int motion_y = block->u.mv[ref][1];
1351  int mx, my, i, epel, nplanes = 0;
1352 
1353  if (plane) {
1354  motion_x >>= s->chroma_x_shift;
1355  motion_y >>= s->chroma_y_shift;
1356  }
1357 
1358  mx = motion_x & ~(-1 << s->mv_precision);
1359  my = motion_y & ~(-1 << s->mv_precision);
1360  motion_x >>= s->mv_precision;
1361  motion_y >>= s->mv_precision;
1362  /* normalize subpel coordinates to epel */
1363  /* TODO: template this function? */
1364  mx <<= 3 - s->mv_precision;
1365  my <<= 3 - s->mv_precision;
1366 
1367  x += motion_x;
1368  y += motion_y;
1369  epel = (mx|my)&1;
1370 
1371  /* hpel position */
1372  if (!((mx|my)&3)) {
1373  nplanes = 1;
1374  src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1375  } else {
1376  /* qpel or epel */
1377  nplanes = 4;
1378  for (i = 0; i < 4; i++)
1379  src[i] = ref_hpel[i] + y*p->stride + x;
1380 
1381  /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1382  we increment x/y because the edge changes for half of the pixels */
1383  if (mx > 4) {
1384  src[0] += 1;
1385  src[2] += 1;
1386  x++;
1387  }
1388  if (my > 4) {
1389  src[0] += p->stride;
1390  src[1] += p->stride;
1391  y++;
1392  }
1393 
1394  /* hpel planes are:
1395  [0]: F [1]: H
1396  [2]: V [3]: C */
1397  if (!epel) {
1398  /* check if we really only need 2 planes since either mx or my is
1399  a hpel position. (epel weights of 0 handle this there) */
1400  if (!(mx&3)) {
1401  /* mx == 0: average [0] and [2]
1402  mx == 4: average [1] and [3] */
1403  src[!mx] = src[2 + !!mx];
1404  nplanes = 2;
1405  } else if (!(my&3)) {
1406  src[0] = src[(my>>1) ];
1407  src[1] = src[(my>>1)+1];
1408  nplanes = 2;
1409  }
1410  } else {
1411  /* adjust the ordering if needed so the weights work */
1412  if (mx > 4) {
1413  FFSWAP(const uint8_t *, src[0], src[1]);
1414  FFSWAP(const uint8_t *, src[2], src[3]);
1415  }
1416  if (my > 4) {
1417  FFSWAP(const uint8_t *, src[0], src[2]);
1418  FFSWAP(const uint8_t *, src[1], src[3]);
1419  }
1420  src[4] = epel_weights[my&3][mx&3];
1421  }
1422  }
1423 
1424  /* fixme: v/h _edge_pos */
1425  if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1426  y + p->yblen > p->height+EDGE_WIDTH/2 ||
1427  x < 0 || y < 0) {
1428  for (i = 0; i < nplanes; i++) {
1429  ff_emulated_edge_mc(s->edge_emu_buffer[i], src[i],
1430  p->stride, p->stride,
1431  p->xblen, p->yblen, x, y,
1432  p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1433  src[i] = s->edge_emu_buffer[i];
1434  }
1435  }
1436  return (nplanes>>1) + epel;
1437 }
1438 
1439 static void add_dc(uint16_t *dst, int dc, int stride,
1440  uint8_t *obmc_weight, int xblen, int yblen)
1441 {
1442  int x, y;
1443  dc += 128;
1444 
1445  for (y = 0; y < yblen; y++) {
1446  for (x = 0; x < xblen; x += 2) {
1447  dst[x ] += dc * obmc_weight[x ];
1448  dst[x+1] += dc * obmc_weight[x+1];
1449  }
1450  dst += stride;
1451  obmc_weight += MAX_BLOCKSIZE;
1452  }
1453 }
1454 
1456  uint16_t *mctmp, uint8_t *obmc_weight,
1457  int plane, int dstx, int dsty)
1458 {
1459  Plane *p = &s->plane[plane];
1460  const uint8_t *src[5];
1461  int idx;
1462 
1463  switch (block->ref&3) {
1464  case 0: /* DC */
1465  add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1466  return;
1467  case 1:
1468  case 2:
1469  idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1470  s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1471  if (s->weight_func)
1473  s->weight[0] + s->weight[1], p->yblen);
1474  break;
1475  case 3:
1476  idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1477  s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1478  idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1479  if (s->biweight_func) {
1480  /* fixme: +32 is a quick hack */
1481  s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1483  s->weight[0], s->weight[1], p->yblen);
1484  } else
1485  s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1486  break;
1487  }
1488  s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1489 }
1490 
1491 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1492 {
1493  Plane *p = &s->plane[plane];
1494  int x, dstx = p->xbsep - p->xoffset;
1495 
1496  block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1497  mctmp += p->xbsep;
1498 
1499  for (x = 1; x < s->blwidth-1; x++) {
1500  block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1501  dstx += p->xbsep;
1502  mctmp += p->xbsep;
1503  }
1504  block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1505 }
1506 
1507 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1508 {
1509  int idx = 0;
1510  if (xblen > 8)
1511  idx = 1;
1512  if (xblen > 16)
1513  idx = 2;
1514 
1515  memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1516  memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1517  s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1518  if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1521  } else {
1522  s->weight_func = NULL;
1523  s->biweight_func = NULL;
1524  }
1525 }
1526 
1527 static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1528 {
1529  /* chroma allocates an edge of 8 when subsampled
1530  which for 4:2:2 means an h edge of 16 and v edge of 8
1531  just use 8 for everything for the moment */
1532  int i, edge = EDGE_WIDTH/2;
1533 
1534  ref->hpel[plane][0] = ref->avframe->data[plane];
1535  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 */
1536 
1537  /* no need for hpel if we only have fpel vectors */
1538  if (!s->mv_precision)
1539  return;
1540 
1541  for (i = 1; i < 4; i++) {
1542  if (!ref->hpel_base[plane][i])
1543  ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
1544  /* we need to be 16-byte aligned even for chroma */
1545  ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
1546  }
1547 
1548  if (!ref->interpolated[plane]) {
1549  s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1550  ref->hpel[plane][3], ref->hpel[plane][0],
1551  ref->avframe->linesize[plane], width, height);
1552  s->dsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1553  s->dsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1554  s->dsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1555  }
1556  ref->interpolated[plane] = 1;
1557 }
1558 
1559 /**
1560  * Dirac Specification ->
1561  * 13.0 Transform data syntax. transform_data()
1562  */
1564 {
1565  DWTContext d;
1566  int y, i, comp, dsty;
1567 
1568  if (s->low_delay) {
1569  /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1570  for (comp = 0; comp < 3; comp++) {
1571  Plane *p = &s->plane[comp];
1572  memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1573  }
1574  if (!s->zero_res)
1575  decode_lowdelay(s);
1576  }
1577 
1578  for (comp = 0; comp < 3; comp++) {
1579  Plane *p = &s->plane[comp];
1581 
1582  /* FIXME: small resolutions */
1583  for (i = 0; i < 4; i++)
1584  s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1585 
1586  if (!s->zero_res && !s->low_delay)
1587  {
1588  memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1589  decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1590  }
1592  s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp))
1593  return -1;
1594 
1595  if (!s->num_refs) { /* intra */
1596  for (y = 0; y < p->height; y += 16) {
1597  ff_spatial_idwt_slice2(&d, y+16); /* decode */
1598  s->diracdsp.put_signed_rect_clamped(frame + y*p->stride, p->stride,
1599  p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
1600  }
1601  } else { /* inter */
1602  int rowheight = p->ybsep*p->stride;
1603 
1604  select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1605 
1606  for (i = 0; i < s->num_refs; i++)
1607  interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1608 
1609  memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1610 
1611  dsty = -p->yoffset;
1612  for (y = 0; y < s->blheight; y++) {
1613  int h = 0,
1614  start = FFMAX(dsty, 0);
1615  uint16_t *mctmp = s->mctmp + y*rowheight;
1616  DiracBlock *blocks = s->blmotion + y*s->blwidth;
1617 
1618  init_obmc_weights(s, p, y);
1619 
1620  if (y == s->blheight-1 || start+p->ybsep > p->height)
1621  h = p->height - start;
1622  else
1623  h = p->ybsep - (start - dsty);
1624  if (h < 0)
1625  break;
1626 
1627  memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1628  mc_row(s, blocks, mctmp, comp, dsty);
1629 
1630  mctmp += (start - dsty)*p->stride + p->xoffset;
1631  ff_spatial_idwt_slice2(&d, start + h); /* decode */
1632  s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1633  p->idwt_buf + start*p->idwt_stride, p->idwt_stride, p->width, h);
1634 
1635  dsty += p->ybsep;
1636  }
1637  }
1638  }
1639 
1640 
1641  return 0;
1642 }
1643 
1645 {
1646  int ret, i;
1647  int chroma_x_shift, chroma_y_shift;
1648  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift, &chroma_y_shift);
1649 
1650  f->width = avctx->width + 2 * EDGE_WIDTH;
1651  f->height = avctx->height + 2 * EDGE_WIDTH + 2;
1652  ret = ff_get_buffer(avctx, f, flags);
1653  if (ret < 0)
1654  return ret;
1655 
1656  for (i = 0; f->data[i]; i++) {
1657  int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) *
1658  f->linesize[i] + 32;
1659  f->data[i] += offset;
1660  }
1661  f->width = avctx->width;
1662  f->height = avctx->height;
1663 
1664  return 0;
1665 }
1666 
1667 /**
1668  * Dirac Specification ->
1669  * 11.1.1 Picture Header. picture_header()
1670  */
1672 {
1673  int retire, picnum;
1674  int i, j, refnum, refdist;
1675  GetBitContext *gb = &s->gb;
1676 
1677  /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1679 
1680 
1681  av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1682 
1683  /* if this is the first keyframe after a sequence header, start our
1684  reordering from here */
1685  if (s->frame_number < 0)
1686  s->frame_number = picnum;
1687 
1688  s->ref_pics[0] = s->ref_pics[1] = NULL;
1689  for (i = 0; i < s->num_refs; i++) {
1690  refnum = picnum + dirac_get_se_golomb(gb);
1691  refdist = INT_MAX;
1692 
1693  /* find the closest reference to the one we want */
1694  /* Jordi: this is needed if the referenced picture hasn't yet arrived */
1695  for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1696  if (s->ref_frames[j]
1697  && FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) {
1698  s->ref_pics[i] = s->ref_frames[j];
1699  refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum);
1700  }
1701 
1702  if (!s->ref_pics[i] || refdist)
1703  av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1704 
1705  /* if there were no references at all, allocate one */
1706  if (!s->ref_pics[i])
1707  for (j = 0; j < MAX_FRAMES; j++)
1708  if (!s->all_frames[j].avframe->data[0]) {
1709  s->ref_pics[i] = &s->all_frames[j];
1711  break;
1712  }
1713  }
1714 
1715  /* retire the reference frames that are not used anymore */
1716  if (s->current_picture->avframe->reference) {
1717  retire = picnum + dirac_get_se_golomb(gb);
1718  if (retire != picnum) {
1719  DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1720 
1721  if (retire_pic)
1722  retire_pic->avframe->reference &= DELAYED_PIC_REF;
1723  else
1724  av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1725  }
1726 
1727  /* if reference array is full, remove the oldest as per the spec */
1729  av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1731  }
1732  }
1733 
1734  if (s->num_refs) {
1735  if (dirac_unpack_prediction_parameters(s)) /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1736  return -1;
1737  if (dirac_unpack_block_motion_data(s)) /* [DIRAC_STD] 12. Block motion data syntax */
1738  return -1;
1739  }
1740  if (dirac_unpack_idwt_params(s)) /* [DIRAC_STD] 11.3 Wavelet transform data */
1741  return -1;
1742 
1743  init_planes(s);
1744  return 0;
1745 }
1746 
1747 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
1748 {
1749  DiracFrame *out = s->delay_frames[0];
1750  int i, out_idx = 0;
1751  int ret;
1752 
1753  /* find frame with lowest picture number */
1754  for (i = 1; s->delay_frames[i]; i++)
1756  out = s->delay_frames[i];
1757  out_idx = i;
1758  }
1759 
1760  for (i = out_idx; s->delay_frames[i]; i++)
1761  s->delay_frames[i] = s->delay_frames[i+1];
1762 
1763  if (out) {
1765  *got_frame = 1;
1766  if((ret = av_frame_ref(picture, out->avframe)) < 0)
1767  return ret;
1768  }
1769 
1770  return 0;
1771 }
1772 
1773 /**
1774  * Dirac Specification ->
1775  * 9.6 Parse Info Header Syntax. parse_info()
1776  * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
1777  */
1778 #define DATA_UNIT_HEADER_SIZE 13
1779 
1780 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
1781  inside the function parse_sequence() */
1782 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
1783 {
1784  DiracContext *s = avctx->priv_data;
1785  DiracFrame *pic = NULL;
1786  int ret, i, parse_code = buf[4];
1787  unsigned tmp;
1788 
1789  if (size < DATA_UNIT_HEADER_SIZE)
1790  return -1;
1791 
1792  init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
1793 
1794  if (parse_code == pc_seq_header) {
1795  if (s->seen_sequence_header)
1796  return 0;
1797 
1798  /* [DIRAC_STD] 10. Sequence header */
1799  if (avpriv_dirac_parse_sequence_header(avctx, &s->gb, &s->source))
1800  return -1;
1801 
1803 
1804  if (alloc_sequence_buffers(s))
1805  return -1;
1806 
1807  s->seen_sequence_header = 1;
1808  } else if (parse_code == pc_eos) { /* [DIRAC_STD] End of Sequence */
1810  s->seen_sequence_header = 0;
1811  } else if (parse_code == pc_aux_data) {
1812  if (buf[13] == 1) { /* encoder implementation/version */
1813  int ver[3];
1814  /* versions older than 1.0.8 don't store quant delta for
1815  subbands with only one codeblock */
1816  if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
1817  if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
1818  s->old_delta_quant = 1;
1819  }
1820  } else if (parse_code & 0x8) { /* picture data unit */
1821  if (!s->seen_sequence_header) {
1822  av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
1823  return -1;
1824  }
1825 
1826  /* find an unused frame */
1827  for (i = 0; i < MAX_FRAMES; i++)
1828  if (s->all_frames[i].avframe->data[0] == NULL)
1829  pic = &s->all_frames[i];
1830  if (!pic) {
1831  av_log(avctx, AV_LOG_ERROR, "framelist full\n");
1832  return -1;
1833  }
1834 
1835  av_frame_unref(pic->avframe);
1836 
1837  /* [DIRAC_STD] Defined in 9.6.1 ... */
1838  tmp = parse_code & 0x03; /* [DIRAC_STD] num_refs() */
1839  if (tmp > 2) {
1840  av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
1841  return -1;
1842  }
1843  s->num_refs = tmp;
1844  s->is_arith = (parse_code & 0x48) == 0x08; /* [DIRAC_STD] using_ac() */
1845  s->low_delay = (parse_code & 0x88) == 0x88; /* [DIRAC_STD] is_low_delay() */
1846  pic->avframe->reference = (parse_code & 0x0C) == 0x0C; /* [DIRAC_STD] is_reference() */
1847  pic->avframe->key_frame = s->num_refs == 0; /* [DIRAC_STD] is_intra() */
1848  pic->avframe->pict_type = s->num_refs + 1; /* Definition of AVPictureType in avutil.h */
1849 
1850  if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
1851  return ret;
1852  s->current_picture = pic;
1853  s->plane[0].stride = pic->avframe->linesize[0];
1854  s->plane[1].stride = pic->avframe->linesize[1];
1855  s->plane[2].stride = pic->avframe->linesize[2];
1856 
1857  /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
1859  return -1;
1860 
1861  /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
1863  return -1;
1864  }
1865  return 0;
1866 }
1867 
1868 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
1869 {
1870  DiracContext *s = avctx->priv_data;
1871  AVFrame *picture = data;
1872  uint8_t *buf = pkt->data;
1873  int buf_size = pkt->size;
1874  int i, data_unit_size, buf_idx = 0;
1875  int ret;
1876 
1877  /* release unused frames */
1878  for (i = 0; i < MAX_FRAMES; i++)
1879  if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].avframe->reference) {
1881  memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
1882  }
1883 
1884  s->current_picture = NULL;
1885  *got_frame = 0;
1886 
1887  /* end of stream, so flush delayed pics */
1888  if (buf_size == 0)
1889  return get_delayed_pic(s, (AVFrame *)data, got_frame);
1890 
1891  for (;;) {
1892  /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
1893  [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
1894  BBCD start code search */
1895  for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
1896  if (buf[buf_idx ] == 'B' && buf[buf_idx+1] == 'B' &&
1897  buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
1898  break;
1899  }
1900  /* BBCD found or end of data */
1901  if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
1902  break;
1903 
1904  data_unit_size = AV_RB32(buf+buf_idx+5);
1905  if (buf_idx + data_unit_size > buf_size || !data_unit_size) {
1906  if(buf_idx + data_unit_size > buf_size)
1908  "Data unit with size %d is larger than input buffer, discarding\n",
1909  data_unit_size);
1910  buf_idx += 4;
1911  continue;
1912  }
1913  /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
1914  if (dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size))
1915  {
1916  av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
1917  return -1;
1918  }
1919  buf_idx += data_unit_size;
1920  }
1921 
1922  if (!s->current_picture)
1923  return buf_size;
1924 
1926  DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
1927 
1929 
1931  int min_num = s->delay_frames[0]->avframe->display_picture_number;
1932  /* Too many delayed frames, so we display the frame with the lowest pts */
1933  av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
1934  delayed_frame = s->delay_frames[0];
1935 
1936  for (i = 1; s->delay_frames[i]; i++)
1937  if (s->delay_frames[i]->avframe->display_picture_number < min_num)
1938  min_num = s->delay_frames[i]->avframe->display_picture_number;
1939 
1940  delayed_frame = remove_frame(s->delay_frames, min_num);
1942  }
1943 
1944  if (delayed_frame) {
1945  delayed_frame->avframe->reference ^= DELAYED_PIC_REF;
1946  if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0)
1947  return ret;
1948  *got_frame = 1;
1949  }
1951  /* The right frame at the right time :-) */
1952  if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0)
1953  return ret;
1954  *got_frame = 1;
1955  }
1956 
1957  if (*got_frame)
1958  s->frame_number = picture->display_picture_number + 1;
1959 
1960  return buf_idx;
1961 }
1962 
1964  .name = "dirac",
1965  .long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
1966  .type = AVMEDIA_TYPE_VIDEO,
1967  .id = AV_CODEC_ID_DIRAC,
1968  .priv_data_size = sizeof(DiracContext),
1972  .capabilities = CODEC_CAP_DELAY,
1974 };