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