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