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