FFmpeg
clearvideo.c
Go to the documentation of this file.
1 /*
2  * ClearVideo decoder
3  * Copyright (c) 2012-2018 Konstantin Shishkov
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * ClearVideo decoder
25  */
26 
27 #include "libavutil/mem.h"
28 #include "libavutil/mem_internal.h"
29 #include "libavutil/thread.h"
30 
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "codec_internal.h"
34 #include "decode.h"
35 #include "get_bits.h"
36 #include "idctdsp.h"
37 #include "mathops.h"
38 #include "clearvideodata.h"
39 
40 #define CLV_VLC_BITS 9
41 
42 typedef struct LevelCodes {
43  const VLCElem *flags_cb;
44  const VLCElem *mv_cb;
45  const VLCElem *bias_cb;
46 } LevelCodes;
47 
48 typedef struct MV {
49  int16_t x, y;
50 } MV;
51 
52 static const MV zero_mv = { 0 };
53 
54 typedef struct MVInfo {
55  int mb_w;
56  int mb_h;
57  int mb_size;
58  int mb_stride;
59  int top;
60  MV *mv;
61 } MVInfo;
62 
63 typedef struct CLVContext {
72  int tile_size;
75  DECLARE_ALIGNED(16, int16_t, block)[64];
76  int top_dc[3], left_dc[4];
77 } CLVContext;
78 
79 static VLCElem dc_vlc[1104], ac_vlc[554];
80 static LevelCodes lev[4 + 3 + 3]; // 0..3: Y, 4..6: U, 7..9: V
81 
82 static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
83  int ac_quant)
84 {
85  GetBitContext *gb = &ctx->gb;
86  int idx = 1, last = 0, val, skip;
87 
88  memset(blk, 0, sizeof(*blk) * 64);
89  blk[0] = get_vlc2(gb, dc_vlc, CLV_VLC_BITS, 3);
90 
91  if (!has_ac)
92  return 0;
93 
94  while (idx < 64 && !last) {
95  val = get_vlc2(gb, ac_vlc, CLV_VLC_BITS, 2);
96  if (val < 0)
97  return AVERROR_INVALIDDATA;
98  if (val != 0x1BFF) {
99  last = val >> 12;
100  skip = (val >> 4) & 0xFF;
101  val &= 0xF;
102  if (get_bits1(gb))
103  val = -val;
104  } else {
105  last = get_bits1(gb);
106  skip = get_bits(gb, 6);
107  val = get_sbits(gb, 8);
108  }
109  if (val) {
110  int aval = FFABS(val), sign = val < 0;
111  val = ac_quant * (2 * aval + 1);
112  if (!(ac_quant & 1))
113  val--;
114  if (sign)
115  val = -val;
116  }
117  idx += skip;
118  if (idx >= 64)
119  return AVERROR_INVALIDDATA;
120  blk[ff_zigzag_direct[idx++]] = val;
121  }
122 
123  return (idx <= 64 && last) ? 0 : -1;
124 }
125 
126 #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP) \
127  const int t0 = OP(2841 * blk[1 * step] + 565 * blk[7 * step]); \
128  const int t1 = OP( 565 * blk[1 * step] - 2841 * blk[7 * step]); \
129  const int t2 = OP(1609 * blk[5 * step] + 2408 * blk[3 * step]); \
130  const int t3 = OP(2408 * blk[5 * step] - 1609 * blk[3 * step]); \
131  const int t4 = OP(1108 * blk[2 * step] - 2676 * blk[6 * step]); \
132  const int t5 = OP(2676 * blk[2 * step] + 1108 * blk[6 * step]); \
133  const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias; \
134  const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias; \
135  const int t8 = t0 + t2; \
136  const int t9 = t0 - t2; \
137  const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8; \
138  const int tB = (int)(181U * (t9 - (t1 - t3)) + 0x80) >> 8; \
139  const int tC = t1 + t3; \
140  \
141  blk[0 * step] = (t6 + t5 + t8) >> shift; \
142  blk[1 * step] = (t7 + t4 + tA) >> shift; \
143  blk[2 * step] = (t7 - t4 + tB) >> shift; \
144  blk[3 * step] = (t6 - t5 + tC) >> shift; \
145  blk[4 * step] = (t6 - t5 - tC) >> shift; \
146  blk[5 * step] = (t7 - t4 - tB) >> shift; \
147  blk[6 * step] = (t7 + t4 - tA) >> shift; \
148  blk[7 * step] = (t6 + t5 - t8) >> shift; \
149 
150 #define ROP(x) x
151 #define COP(x) (((x) + 4) >> 3)
152 
153 static void clv_dct(int16_t *block)
154 {
155  int i;
156  int16_t *ptr;
157 
158  ptr = block;
159  for (i = 0; i < 8; i++) {
160  DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
161  ptr += 8;
162  }
163 
164  ptr = block;
165  for (i = 0; i < 8; i++) {
166  DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
167  ptr++;
168  }
169 }
170 
171 static int decode_mb(CLVContext *c, int x, int y)
172 {
173  int i, has_ac[6], off;
174 
175  for (i = 0; i < 6; i++)
176  has_ac[i] = get_bits1(&c->gb);
177 
178  off = x * 16 + y * 16 * c->pic->linesize[0];
179  for (i = 0; i < 4; i++) {
180  if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
181  return AVERROR_INVALIDDATA;
182  if (!x && !(i & 1)) {
183  c->block[0] += c->top_dc[0];
184  c->top_dc[0] = c->block[0];
185  } else {
186  c->block[0] += c->left_dc[(i & 2) >> 1];
187  }
188  c->left_dc[(i & 2) >> 1] = c->block[0];
189  c->block[0] *= c->luma_dc_quant;
190  clv_dct(c->block);
191  if (i == 2)
192  off += c->pic->linesize[0] * 8;
193  c->idsp.put_pixels_clamped(c->block,
194  c->pic->data[0] + off + (i & 1) * 8,
195  c->pic->linesize[0]);
196  }
197 
198  off = x * 8 + y * 8 * c->pic->linesize[1];
199  for (i = 1; i < 3; i++) {
200  if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)
201  return AVERROR_INVALIDDATA;
202  if (!x) {
203  c->block[0] += c->top_dc[i];
204  c->top_dc[i] = c->block[0];
205  } else {
206  c->block[0] += c->left_dc[i + 1];
207  }
208  c->left_dc[i + 1] = c->block[0];
209  c->block[0] *= c->chroma_dc_quant;
210  clv_dct(c->block);
211  c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,
212  c->pic->linesize[i]);
213  }
214 
215  return 0;
216 }
217 
218 static int copy_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src,
219  int plane, int x, int y, int dx, int dy, int size)
220 {
221  int shift = plane > 0;
222  int sx = x + dx;
223  int sy = y + dy;
224  int sstride, dstride, soff, doff;
225  uint8_t *dbuf;
226  const uint8_t *sbuf;
227  int i;
228 
229  if (x < 0 || sx < 0 || y < 0 || sy < 0 ||
230  x + size > avctx->coded_width >> shift ||
231  y + size > avctx->coded_height >> shift ||
232  sx + size > avctx->coded_width >> shift ||
233  sy + size > avctx->coded_height >> shift)
234  return AVERROR_INVALIDDATA;
235 
236  sstride = src->linesize[plane];
237  dstride = dst->linesize[plane];
238  soff = sx + sy * sstride;
239  sbuf = src->data[plane];
240  doff = x + y * dstride;
241  dbuf = dst->data[plane];
242 
243  for (i = 0; i < size; i++) {
244  uint8_t *dptr = &dbuf[doff];
245  const uint8_t *sptr = &sbuf[soff];
246 
247  memcpy(dptr, sptr, size);
248  doff += dstride;
249  soff += sstride;
250  }
251 
252  return 0;
253 }
254 
255 static int copyadd_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src,
256  int plane, int x, int y, int dx, int dy, int size, int bias)
257 {
258  int shift = plane > 0;
259  int sx = x + dx;
260  int sy = y + dy;
261  int sstride = src->linesize[plane];
262  int dstride = dst->linesize[plane];
263  int soff = sx + sy * sstride;
264  const uint8_t *sbuf = src->data[plane];
265  int doff = x + y * dstride;
266  uint8_t *dbuf = dst->data[plane];
267  int i, j;
268 
269  if (x < 0 || sx < 0 || y < 0 || sy < 0 ||
270  x + size > avctx->coded_width >> shift ||
271  y + size > avctx->coded_height >> shift ||
272  sx + size > avctx->coded_width >> shift ||
273  sy + size > avctx->coded_height >> shift)
274  return AVERROR_INVALIDDATA;
275 
276  for (j = 0; j < size; j++) {
277  uint8_t *dptr = &dbuf[doff];
278  const uint8_t *sptr = &sbuf[soff];
279 
280  for (i = 0; i < size; i++) {
281  int val = sptr[i] + bias;
282 
283  dptr[i] = av_clip_uint8(val);
284  }
285 
286  doff += dstride;
287  soff += sstride;
288  }
289 
290  return 0;
291 }
292 
293 static MV *mvi_predict(MVInfo *mvi, int mb_x, int mb_y)
294 {
295  MV res, pred_mv;
296  int left_mv, right_mv, top_mv, bot_mv;
297 
298  if (mvi->top) {
299  if (mb_x > 0) {
300  pred_mv = mvi->mv[mvi->mb_stride + mb_x - 1];
301  } else {
302  pred_mv = zero_mv;
303  }
304  } else if ((mb_x == 0) || (mb_x == mvi->mb_w - 1)) {
305  pred_mv = mvi->mv[mb_x];
306  } else {
307  MV A = mvi->mv[mvi->mb_stride + mb_x - 1];
308  MV B = mvi->mv[ mb_x ];
309  MV C = mvi->mv[ mb_x + 1];
310  pred_mv.x = mid_pred(A.x, B.x, C.x);
311  pred_mv.y = mid_pred(A.y, B.y, C.y);
312  }
313 
314  res = pred_mv;
315 
316  left_mv = -((mb_x * mvi->mb_size));
317  right_mv = ((mvi->mb_w - mb_x - 1) * mvi->mb_size);
318  if (res.x < left_mv) {
319  res.x = left_mv;
320  }
321  if (res.x > right_mv) {
322  res.x = right_mv;
323  }
324  top_mv = -((mb_y * mvi->mb_size));
325  bot_mv = ((mvi->mb_h - mb_y - 1) * mvi->mb_size);
326  if (res.y < top_mv) {
327  res.y = top_mv;
328  }
329  if (res.y > bot_mv) {
330  res.y = bot_mv;
331  }
332 
333  mvi->mv[mvi->mb_stride + mb_x].x = res.x;
334  mvi->mv[mvi->mb_stride + mb_x].y = res.y;
335 
336  return &mvi->mv[mvi->mb_stride + mb_x];
337 }
338 
340 {
341  mv->x += diff.x;
342  mv->y += diff.y;
343 }
344 
345 static void mvi_reset(MVInfo *mvi, int mb_w, int mb_h, int mb_size)
346 {
347  mvi->top = 1;
348  mvi->mb_w = mb_w;
349  mvi->mb_h = mb_h;
350  mvi->mb_size = mb_size;
351  mvi->mb_stride = mb_w;
352  memset(mvi->mv, 0, sizeof(MV) * mvi->mb_stride * 2);
353 }
354 
355 static void mvi_update_row(MVInfo *mvi)
356 {
357  int i;
358 
359  mvi->top = 0;
360  for (i = 0 ; i < mvi->mb_stride; i++) {
361  mvi->mv[i] = mvi->mv[mvi->mb_stride + i];
362  }
363 }
364 
365 static int tile_do_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src,
366  int plane, int x, int y, int dx, int dy, int size, int bias)
367 {
368  int ret;
369 
370  if (!bias) {
371  ret = copy_block(avctx, dst, src, plane, x, y, dx, dy, size);
372  } else {
373  ret = copyadd_block(avctx, dst, src, plane, x, y, dx, dy, size, bias);
374  }
375 
376  return ret;
377 }
378 
379 static int decode_tile(AVCodecContext *avctx, GetBitContext *gb,
380  const LevelCodes *lc,
381  AVFrame *dst, const AVFrame *src,
382  int plane, int x, int y, int size,
383  MV root_mv, MV *pred)
384 {
385  int i, flags = 0;
386  int16_t bias = 0;
387  MV mv = { 0 };
388  int err;
389 
390  if (lc->flags_cb)
391  flags = get_vlc2(gb, lc->flags_cb, CLV_VLC_BITS, 2);
392 
393  if (lc->mv_cb) {
394  uint16_t mv_code = get_vlc2(gb, lc->mv_cb, CLV_VLC_BITS, 2);
395 
396  if (mv_code != MV_ESC) {
397  mv.x = (int8_t)(mv_code & 0xff);
398  mv.y = (int8_t)(mv_code >> 8);
399  } else {
400  mv.x = get_sbits(gb, 8);
401  mv.y = get_sbits(gb, 8);
402  }
403  if (pred)
405  }
406  mv.x += root_mv.x;
407  mv.y += root_mv.y;
408 
409  if (lc->bias_cb) {
410  uint16_t bias_val = get_vlc2(gb, lc->bias_cb, CLV_VLC_BITS, 2);
411 
412  if (bias_val != BIAS_ESC) {
413  bias = (int16_t)(bias_val);
414  } else {
415  bias = get_sbits(gb, 16);
416  }
417  }
418 
419  if (flags) {
420  int hsize = size >> 1;
421  for (i = 0; i < 4; i++) {
422  int xoff = (i & 2) == 0 ? 0 : hsize;
423  int yoff = (i & 1) == 0 ? 0 : hsize;
424 
425  if (flags & (1 << i)) {
426  err = decode_tile(avctx, gb, lc + 1, dst, src, plane,
427  x + xoff, y + yoff, hsize, root_mv, NULL);
428  } else {
429  err = tile_do_block(avctx, dst, src, plane, x + xoff, y + yoff,
430  mv.x, mv.y, hsize, bias);
431  }
432  if (err < 0)
433  return err;
434  }
435  } else {
436  err = tile_do_block(avctx, dst, src, plane, x, y, mv.x, mv.y, size, bias);
437  if (err < 0)
438  return err;
439  }
440 
441  return 0;
442 }
443 
444 static void extend_edges(AVFrame *buf, int tile_size)
445 {
446  int comp, i, j;
447 
448  for (comp = 0; comp < 3; comp++) {
449  int shift = comp > 0;
450  int w = buf->width >> shift;
451  int h = buf->height >> shift;
452  int size = comp == 0 ? tile_size : tile_size >> 1;
453  int stride = buf->linesize[comp];
454  uint8_t *framebuf = buf->data[comp];
455 
456  int right = size - (w & (size - 1));
457  int bottom = size - (h & (size - 1));
458 
459  if ((right == size) && (bottom == size)) {
460  return;
461  }
462  if (right != size) {
463  int off = w;
464  for (j = 0; j < h; j++) {
465  for (i = 0; i < right; i++) {
466  framebuf[off + i] = 0x80;
467  }
468  off += stride;
469  }
470  }
471  if (bottom != size) {
472  int off = h * stride;
473  for (j = 0; j < bottom; j++) {
474  for (i = 0; i < stride; i++) {
475  framebuf[off + i] = 0x80;
476  }
477  off += stride;
478  }
479  }
480  }
481 }
482 
483 static int clv_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
484  int *got_frame, AVPacket *avpkt)
485 {
486  const uint8_t *buf = avpkt->data;
487  int buf_size = avpkt->size;
488  CLVContext *c = avctx->priv_data;
489  GetByteContext gb;
490  uint32_t frame_type;
491  int i, j, ret;
492  int mb_ret = 0;
493 
494  bytestream2_init(&gb, buf, buf_size);
495  if (avctx->codec_tag == MKTAG('C', 'L', 'V', '1')) {
496  int skip = bytestream2_get_byte(&gb);
497  bytestream2_skip(&gb, (skip + 1) * 8);
498  }
499 
500  frame_type = bytestream2_get_byte(&gb);
501 
502  if ((frame_type & 0x7f) == 0x30) {
503  *got_frame = 0;
504  return buf_size;
505  } else if (frame_type & 0x2) {
506  if (buf_size < c->mb_width * c->mb_height) {
507  av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
508  return AVERROR_INVALIDDATA;
509  }
510 
511  if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
512  return ret;
513 
514  c->pic->flags |= AV_FRAME_FLAG_KEY;
515  c->pic->pict_type = AV_PICTURE_TYPE_I;
516 
517  bytestream2_get_be32(&gb); // frame size;
518  c->ac_quant = bytestream2_get_byte(&gb);
519  c->luma_dc_quant = 32;
520  c->chroma_dc_quant = 32;
521 
522  if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
523  buf_size - bytestream2_tell(&gb))) < 0)
524  return ret;
525 
526  for (i = 0; i < 3; i++)
527  c->top_dc[i] = 32;
528  for (i = 0; i < 4; i++)
529  c->left_dc[i] = 32;
530 
531  for (j = 0; j < c->mb_height; j++) {
532  for (i = 0; i < c->mb_width; i++) {
533  ret = decode_mb(c, i, j);
534  if (ret < 0)
535  mb_ret = ret;
536  }
537  }
538  extend_edges(c->pic, c->tile_size);
539  } else {
540  int plane;
541 
542  if (c->pmb_width * c->pmb_height > 8LL*(buf_size - bytestream2_tell(&gb)))
543  return AVERROR_INVALIDDATA;
544 
545  if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
546  return ret;
547 
548  ret = av_frame_copy(c->pic, c->prev);
549  if (ret < 0)
550  return ret;
551 
552  if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
553  buf_size - bytestream2_tell(&gb))) < 0)
554  return ret;
555 
556  mvi_reset(&c->mvi, c->pmb_width, c->pmb_height, 1 << c->tile_shift);
557 
558  for (j = 0; j < c->pmb_height; j++) {
559  for (i = 0; i < c->pmb_width; i++) {
560  MV *mvp, mv;
561  if (get_bits_left(&c->gb) <= 0)
562  return AVERROR_INVALIDDATA;
563 
564  mvp = mvi_predict(&c->mvi, i, j);
565  mv = *mvp;
566  if (get_bits1(&c->gb)) {
567  for (plane = 0; plane < 3; plane++) {
568  int16_t x = plane == 0 ? i << c->tile_shift : i << (c->tile_shift - 1);
569  int16_t y = plane == 0 ? j << c->tile_shift : j << (c->tile_shift - 1);
570  int16_t size = plane == 0 ? 1 << c->tile_shift : 1 << (c->tile_shift - 1);
571  int16_t mx = plane == 0 ? mv.x : mv.x / 2;
572  int16_t my = plane == 0 ? mv.y : mv.y / 2;
573 
574  ret = copy_block(avctx, c->pic, c->prev, plane, x, y, mx, my, size);
575  if (ret < 0)
576  mb_ret = ret;
577  }
578  } else {
579  int x = i << c->tile_shift;
580  int y = j << c->tile_shift;
581  int size = 1 << c->tile_shift;
582  MV cmv;
583 
584  ret = decode_tile(avctx, &c->gb, &lev[0], c->pic, c->prev, // Y
585  0, x, y, size, mv, mvp);
586  if (ret < 0)
587  mb_ret = ret;
588  x = i << (c->tile_shift - 1);
589  y = j << (c->tile_shift - 1);
590  size = 1 << (c->tile_shift - 1);
591  cmv = *mvp;
592  cmv.x /= 2;
593  cmv.y /= 2;
594  ret = decode_tile(avctx, &c->gb, &lev[4], c->pic, c->prev, // U
595  1, x, y, size, cmv, NULL);
596  if (ret < 0)
597  mb_ret = ret;
598  ret = decode_tile(avctx, &c->gb, &lev[7], c->pic, c->prev, // U
599  2, x, y, size, cmv, NULL);
600  if (ret < 0)
601  mb_ret = ret;
602  }
603  }
604  mvi_update_row(&c->mvi);
605  }
606  extend_edges(c->pic, c->tile_size);
607 
608  c->pic->flags &= ~AV_FRAME_FLAG_KEY;
609  c->pic->pict_type = AV_PICTURE_TYPE_P;
610  }
611 
612  if ((ret = av_frame_ref(rframe, c->pic)) < 0)
613  return ret;
614 
615  FFSWAP(AVFrame *, c->pic, c->prev);
616 
617  *got_frame = 1;
618 
619  if (get_bits_left(&c->gb) < 0)
620  av_log(c->avctx, AV_LOG_WARNING, "overread %d\n", -get_bits_left(&c->gb));
621 
622  return mb_ret < 0 ? mb_ret : buf_size;
623 }
624 
626  const uint8_t counts[16],
627  const uint16_t **syms)
628 {
629  uint8_t lens[MAX_VLC_ENTRIES];
630  const uint16_t *symbols = *syms;
631  unsigned num = 0;
632 
633  for (int i = 0; i < 16; i++) {
634  unsigned count = counts[i];
635  if (count == 255) /* Special case for Y_3 table */
636  count = 303;
637  for (count += num; num < count; num++)
638  lens[num] = i + 1;
639  }
640  *syms += num;
641  return ff_vlc_init_tables_from_lengths(state, CLV_VLC_BITS, num, lens, 1,
642  symbols, 2, 2, 0, 0);
643 }
644 
645 static av_cold void clv_init_static(void)
646 {
647  static VLCElem vlc_buf[16716];
648  VLCInitState state = VLC_INIT_STATE(vlc_buf);
649  const uint16_t *mv_syms = clv_mv_syms, *bias_syms = clv_bias_syms;
650 
652  clv_dc_lens, 1,
653  clv_dc_syms, 1, 1, -63, 0);
655  clv_ac_bits, 1,
656  clv_ac_syms, 2, 2, 0, 0);
657  for (unsigned i = 0, j = 0, k = 0;; i++) {
658  if (0x36F & (1 << i)) {
660  k++;
661  }
662  if (i == FF_ARRAY_ELEMS(lev) - 1)
663  break;
664  if (0x1B7 & (1 << i)) {
665  lev[i].flags_cb =
667  clv_flags_bits[j], 1,
668  clv_flags_syms[j], 1, 1,
669  0, 0);
670 
672  &bias_syms);
673  j++;
674  }
675  }
676 }
677 
679 {
680  static AVOnce init_static_once = AV_ONCE_INIT;
681  CLVContext *const c = avctx->priv_data;
682  int ret, w, h;
683 
684  if (avctx->extradata_size == 110) {
685  c->tile_size = AV_RL32(&avctx->extradata[94]);
686  } else if (avctx->extradata_size == 150) {
687  c->tile_size = AV_RB32(&avctx->extradata[134]);
688  } else if (!avctx->extradata_size) {
689  c->tile_size = 16;
690  } else {
691  av_log(avctx, AV_LOG_ERROR, "Unsupported extradata size: %d\n", avctx->extradata_size);
692  return AVERROR_INVALIDDATA;
693  }
694 
695  c->tile_shift = av_log2(c->tile_size);
696  if (1U << c->tile_shift != c->tile_size || c->tile_shift < 1 || c->tile_shift > 30) {
697  av_log(avctx, AV_LOG_ERROR, "Tile size: %d, is not power of 2 > 1 and < 2^31\n", c->tile_size);
698  return AVERROR_INVALIDDATA;
699  }
700 
701  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
702  w = avctx->width;
703  h = avctx->height;
704  ret = ff_set_dimensions(avctx, FFALIGN(w, 1 << c->tile_shift), FFALIGN(h, 1 << c->tile_shift));
705  if (ret < 0)
706  return ret;
707  avctx->width = w;
708  avctx->height = h;
709 
710  c->avctx = avctx;
711  c->mb_width = FFALIGN(avctx->width, 16) >> 4;
712  c->mb_height = FFALIGN(avctx->height, 16) >> 4;
713  c->pmb_width = (w + c->tile_size - 1) >> c->tile_shift;
714  c->pmb_height = (h + c->tile_size - 1) >> c->tile_shift;
715  c->pic = av_frame_alloc();
716  c->prev = av_frame_alloc();
717  c->mvi.mv = av_calloc(c->pmb_width * 2, sizeof(*c->mvi.mv));
718  if (!c->pic || !c->prev || !c->mvi.mv)
719  return AVERROR(ENOMEM);
720 
721  ff_idctdsp_init(&c->idsp, avctx);
722 
723  ff_thread_once(&init_static_once, clv_init_static);
724 
725  return 0;
726 }
727 
729 {
730  CLVContext *const c = avctx->priv_data;
731 
732  av_frame_free(&c->prev);
733  av_frame_free(&c->pic);
734 
735  av_freep(&c->mvi.mv);
736 
737  return 0;
738 }
739 
741  .p.name = "clearvideo",
742  CODEC_LONG_NAME("Iterated Systems ClearVideo"),
743  .p.type = AVMEDIA_TYPE_VIDEO,
744  .p.id = AV_CODEC_ID_CLEARVIDEO,
745  .priv_data_size = sizeof(CLVContext),
747  .close = clv_decode_end,
749  .p.capabilities = AV_CODEC_CAP_DR1,
750  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
751 };
A
#define A(x)
Definition: vpx_arith.h:28
MAX_VLC_ENTRIES
#define MAX_VLC_ENTRIES
Definition: clearvideodata.h:27
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
mem_internal.h
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
GetByteContext
Definition: bytestream.h:33
clv_dc_syms
static const uint8_t clv_dc_syms[NUM_DC_CODES]
Definition: clearvideodata.h:41
LevelCodes::mv_cb
const VLCElem * mv_cb
Definition: clearvideo.c:44
thread.h
CLVContext::pmb_width
int pmb_width
Definition: clearvideo.c:70
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
MVInfo::mv
MV * mv
Definition: clearvideo.c:60
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
clv_mv_syms
static const uint16_t clv_mv_syms[]
Definition: clearvideodata.h:112
MV::y
int16_t y
Definition: clearvideo.c:49
AVFrame::width
int width
Definition: frame.h:446
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:524
MVInfo::mb_w
int mb_w
Definition: clearvideo.c:55
clv_decode_frame
static int clv_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: clearvideo.c:483
mvi_update_prediction
static void mvi_update_prediction(MV *mv, MV diff)
Definition: clearvideo.c:339
FFCodec
Definition: codec_internal.h:126
clearvideodata.h
CLVContext::top_dc
int top_dc[3]
Definition: clearvideo.c:76
CLVContext::mvi
MVInfo mvi
Definition: clearvideo.c:71
clv_flags_syms
static const uint8_t clv_flags_syms[][16]
Definition: clearvideodata.h:90
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
CLVContext::pic
AVFrame * pic
Definition: clearvideo.c:66
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
clv_decode_init
static av_cold int clv_decode_init(AVCodecContext *avctx)
Definition: clearvideo.c:678
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
MVInfo::top
int top
Definition: clearvideo.c:59
ROP
#define ROP(x)
Definition: clearvideo.c:150
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
extend_edges
static void extend_edges(AVFrame *buf, int tile_size)
Definition: clearvideo.c:444
BIAS_ESC
#define BIAS_ESC
Definition: clearvideodata.h:619
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
decode_mb
static int decode_mb(CLVContext *c, int x, int y)
Definition: clearvideo.c:171
GetBitContext
Definition: get_bits.h:108
clv_dc_lens
static const uint8_t clv_dc_lens[NUM_DC_CODES]
Definition: clearvideodata.h:31
CLVContext::mb_width
int mb_width
Definition: clearvideo.c:69
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
clv_init_static
static av_cold void clv_init_static(void)
Definition: clearvideo.c:645
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
clv_bias_syms
static const uint16_t clv_bias_syms[]
Definition: clearvideodata.h:620
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:212
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
CLVContext::avctx
AVCodecContext * avctx
Definition: clearvideo.c:64
clv_dct
static void clv_dct(int16_t *block)
Definition: clearvideo.c:153
CLVContext::gb
GetBitContext gb
Definition: clearvideo.c:68
B
#define B
Definition: huffyuv.h:42
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:320
ctx
AVFormatContext * ctx
Definition: movenc.c:49
decode.h
get_bits.h
MV::x
int16_t x
Definition: clearvideo.c:49
CLVContext::left_dc
int left_dc[4]
Definition: clearvideo.c:76
LevelCodes
Definition: clearvideo.c:42
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
blk
#define blk(i)
Definition: sha.c:186
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
mvi_predict
static MV * mvi_predict(MVInfo *mvi, int mb_x, int mb_y)
Definition: clearvideo.c:293
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
dc_vlc
static VLCElem dc_vlc[1104]
Definition: clearvideo.c:79
CLVContext::tile_shift
int tile_shift
Definition: clearvideo.c:73
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
bias
static int bias(int x, int c)
Definition: vqcdec.c:115
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
mathops.h
clv_decode_end
static av_cold int clv_decode_end(AVCodecContext *avctx)
Definition: clearvideo.c:728
copyadd_block
static int copyadd_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int dx, int dy, int size, int bias)
Definition: clearvideo.c:255
MVInfo
Definition: clearvideo.c:54
MVInfo::mb_stride
int mb_stride
Definition: clearvideo.c:58
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
mvi_update_row
static void mvi_update_row(MVInfo *mvi)
Definition: clearvideo.c:355
AVOnce
#define AVOnce
Definition: thread.h:202
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:525
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:384
MVInfo::mb_h
int mb_h
Definition: clearvideo.c:56
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
shift
static int shift(int a, int b)
Definition: bonk.c:261
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:999
build_vlc
static const av_cold VLCElem * build_vlc(VLCInitState *state, const uint8_t counts[16], const uint16_t **syms)
Definition: clearvideo.c:625
MV
Definition: clearvideo.c:48
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
size
int size
Definition: twinvq_data.h:10344
VLCElem
Definition: vlc.h:32
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
ff_clearvideo_decoder
const FFCodec ff_clearvideo_decoder
Definition: clearvideo.c:740
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
CLVContext::pmb_height
int pmb_height
Definition: clearvideo.c:70
LevelCodes::bias_cb
const VLCElem * bias_cb
Definition: clearvideo.c:45
NUM_AC_CODES
#define NUM_AC_CODES
Definition: clearvideodata.h:29
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
frame_type
frame_type
Definition: jpeg2000_parser.c:31
pred_mv
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: diracdec.c:1393
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
clv_ac_bits
static const uint8_t clv_ac_bits[NUM_AC_CODES]
Definition: clearvideodata.h:71
state
static struct @416 state
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
LevelCodes::flags_cb
const VLCElem * flags_cb
Definition: clearvideo.c:43
lev
static LevelCodes lev[4+3+3]
Definition: clearvideo.c:80
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
CLVContext::tile_size
int tile_size
Definition: clearvideo.c:72
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
clv_flags_bits
static const uint8_t clv_flags_bits[][16]
Definition: clearvideodata.h:80
idctdsp.h
avcodec.h
CLV_VLC_BITS
#define CLV_VLC_BITS
Definition: clearvideo.c:40
stride
#define stride
Definition: h264pred_template.c:537
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
mid_pred
#define mid_pred
Definition: mathops.h:98
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1684
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
copy_block
static int copy_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int dx, int dy, int size)
Definition: clearvideo.c:218
IDCTDSPContext
Definition: idctdsp.h:43
COP
#define COP(x)
Definition: clearvideo.c:151
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
CLVContext::luma_dc_quant
int luma_dc_quant
Definition: clearvideo.c:74
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:446
decode_block
static int decode_block(CLVContext *ctx, int16_t *blk, int has_ac, int ac_quant)
Definition: clearvideo.c:82
CLVContext::mb_height
int mb_height
Definition: clearvideo.c:69
MV_ESC
#define MV_ESC
Definition: clearvideodata.h:111
DCT_TEMPLATE
#define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)
Definition: clearvideo.c:126
ac_vlc
static VLCElem ac_vlc[554]
Definition: clearvideo.c:79
av_clip_uint8
#define av_clip_uint8
Definition: common.h:105
ff_vlc_init_tables_from_lengths
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
Definition: vlc.c:366
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
CLVContext::prev
AVFrame * prev
Definition: clearvideo.c:67
mem.h
mvi_reset
static void mvi_reset(MVInfo *mvi, int mb_w, int mb_h, int mb_size)
Definition: clearvideo.c:345
VLC_INIT_STATIC_TABLE_FROM_LENGTHS
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
Definition: vlc.h:280
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
mvp
static void mvp(const VVCLocalContext *lc, const int mvp_lx_flag, const int lx, const int8_t *ref_idx, const int amvr_shift, Mv *mv)
Definition: mvs.c:1577
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:217
CLVContext::idsp
IDCTDSPContext idsp
Definition: clearvideo.c:65
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
clv_mv_len_counts
static const uint8_t clv_mv_len_counts[][16]
Definition: clearvideodata.h:100
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
CLVContext::chroma_dc_quant
int chroma_dc_quant
Definition: clearvideo.c:74
NUM_DC_CODES
#define NUM_DC_CODES
Definition: clearvideodata.h:28
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
CLVContext
Definition: clearvideo.c:63
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
CLVContext::block
int16_t block[64]
Definition: clearvideo.c:75
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
AV_CODEC_ID_CLEARVIDEO
@ AV_CODEC_ID_CLEARVIDEO
Definition: codec_id.h:278
zero_mv
static const MV zero_mv
Definition: clearvideo.c:52
tile_do_block
static int tile_do_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int dx, int dy, int size, int bias)
Definition: clearvideo.c:365
CLVContext::ac_quant
int ac_quant
Definition: clearvideo.c:74
decode_tile
static int decode_tile(AVCodecContext *avctx, GetBitContext *gb, const LevelCodes *lc, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int size, MV root_mv, MV *pred)
Definition: clearvideo.c:379
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
MVInfo::mb_size
int mb_size
Definition: clearvideo.c:57
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
clv_ac_syms
static const uint16_t clv_ac_syms[NUM_AC_CODES]
Definition: clearvideodata.h:55
clv_bias_len_counts
static const uint8_t clv_bias_len_counts[][16]
Definition: clearvideodata.h:609
mv_syms
static const uint8_t mv_syms[2][16][10]
Definition: mobiclip.c:204