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