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_internal.h"
28 #include "libavutil/thread.h"
29 
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "codec_internal.h"
33 #include "decode.h"
34 #include "get_bits.h"
35 #include "idctdsp.h"
36 #include "mathops.h"
37 #include "clearvideodata.h"
38 
39 #define CLV_VLC_BITS 9
40 
41 typedef struct LevelCodes {
45 } LevelCodes;
46 
47 typedef struct MV {
48  int16_t x, y;
49 } MV;
50 
51 static const MV zero_mv = { 0 };
52 
53 typedef struct MVInfo {
54  int mb_w;
55  int mb_h;
56  int mb_size;
57  int mb_stride;
58  int top;
59  MV *mv;
60 } MVInfo;
61 
62 typedef struct CLVContext {
71  int tile_size;
74  DECLARE_ALIGNED(16, int16_t, block)[64];
75  int top_dc[3], left_dc[4];
76 } CLVContext;
77 
78 static VLC dc_vlc, ac_vlc;
79 static LevelCodes lev[4 + 3 + 3]; // 0..3: Y, 4..6: U, 7..9: V
80 static VLCElem vlc_buf[16716];
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.table, CLV_VLC_BITS, 3);
90 
91  if (!has_ac)
92  return 0;
93 
94  while (idx < 64 && !last) {
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.table)
391  flags = get_vlc2(gb, lc->flags_cb.table, CLV_VLC_BITS, 2);
392 
393  if (lc->mv_cb.table) {
394  uint16_t mv_code = get_vlc2(gb, lc->mv_cb.table, 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.table) {
410  uint16_t bias_val = get_vlc2(gb, lc->bias_cb.table, 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->key_frame = 1;
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->key_frame = 0;
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 
625 static av_cold void build_vlc(VLC *vlc, const uint8_t counts[16],
626  const uint16_t **syms, unsigned *offset)
627 {
628  uint8_t lens[MAX_VLC_ENTRIES];
629  unsigned num = 0;
630 
631  for (int i = 0; i < 16; i++) {
632  unsigned count = counts[i];
633  if (count == 255) /* Special case for Y_3 table */
634  count = 303;
635  for (count += num; num < count; num++)
636  lens[num] = i + 1;
637  }
638  vlc->table = &vlc_buf[*offset];
640  ff_init_vlc_from_lengths(vlc, CLV_VLC_BITS, num, lens, 1,
641  *syms, 2, 2, 0, INIT_VLC_STATIC_OVERLONG, NULL);
642  *syms += num;
643  *offset += vlc->table_size;
644 }
645 
646 static av_cold void clv_init_static(void)
647 {
648  const uint16_t *mv_syms = clv_mv_syms, *bias_syms = clv_bias_syms;
649 
651  clv_dc_lens, 1,
652  clv_dc_syms, 1, 1, -63, 0, 1104);
654  clv_ac_bits, 1,
655  clv_ac_syms, 2, 2, 0, 0, 554);
656  for (unsigned i = 0, j = 0, k = 0, offset = 0;; i++) {
657  if (0x36F & (1 << i)) {
658  build_vlc(&lev[i].mv_cb, clv_mv_len_counts[k], &mv_syms, &offset);
659  k++;
660  }
661  if (i == FF_ARRAY_ELEMS(lev) - 1)
662  break;
663  if (0x1B7 & (1 << i)) {
666  ff_init_vlc_from_lengths(&lev[i].flags_cb, CLV_VLC_BITS, 16,
667  clv_flags_bits[j], 1,
668  clv_flags_syms[j], 1, 1,
671 
672  build_vlc(&lev[i + 1].bias_cb, clv_bias_len_counts[j],
673  &bias_syms, &offset);
674  j++;
675  }
676  }
677 }
678 
680 {
681  static AVOnce init_static_once = AV_ONCE_INIT;
682  CLVContext *const c = avctx->priv_data;
683  int ret, w, h;
684 
685  if (avctx->extradata_size == 110) {
686  c->tile_size = AV_RL32(&avctx->extradata[94]);
687  } else if (avctx->extradata_size == 150) {
688  c->tile_size = AV_RB32(&avctx->extradata[134]);
689  } else if (!avctx->extradata_size) {
690  c->tile_size = 16;
691  } else {
692  av_log(avctx, AV_LOG_ERROR, "Unsupported extradata size: %d\n", avctx->extradata_size);
693  return AVERROR_INVALIDDATA;
694  }
695 
696  c->tile_shift = av_log2(c->tile_size);
697  if (1U << c->tile_shift != c->tile_size || c->tile_shift < 1 || c->tile_shift > 30) {
698  av_log(avctx, AV_LOG_ERROR, "Tile size: %d, is not power of 2 > 1 and < 2^31\n", c->tile_size);
699  return AVERROR_INVALIDDATA;
700  }
701 
702  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
703  w = avctx->width;
704  h = avctx->height;
705  ret = ff_set_dimensions(avctx, FFALIGN(w, 1 << c->tile_shift), FFALIGN(h, 1 << c->tile_shift));
706  if (ret < 0)
707  return ret;
708  avctx->width = w;
709  avctx->height = h;
710 
711  c->avctx = avctx;
712  c->mb_width = FFALIGN(avctx->width, 16) >> 4;
713  c->mb_height = FFALIGN(avctx->height, 16) >> 4;
714  c->pmb_width = (w + c->tile_size - 1) >> c->tile_shift;
715  c->pmb_height = (h + c->tile_size - 1) >> c->tile_shift;
716  c->pic = av_frame_alloc();
717  c->prev = av_frame_alloc();
718  c->mvi.mv = av_calloc(c->pmb_width * 2, sizeof(*c->mvi.mv));
719  if (!c->pic || !c->prev || !c->mvi.mv)
720  return AVERROR(ENOMEM);
721 
722  ff_idctdsp_init(&c->idsp, avctx);
723 
724  ff_thread_once(&init_static_once, clv_init_static);
725 
726  return 0;
727 }
728 
730 {
731  CLVContext *const c = avctx->priv_data;
732 
733  av_frame_free(&c->prev);
734  av_frame_free(&c->pic);
735 
736  av_freep(&c->mvi.mv);
737 
738  return 0;
739 }
740 
742  .p.name = "clearvideo",
743  CODEC_LONG_NAME("Iterated Systems ClearVideo"),
744  .p.type = AVMEDIA_TYPE_VIDEO,
745  .p.id = AV_CODEC_ID_CLEARVIDEO,
746  .priv_data_size = sizeof(CLVContext),
748  .close = clv_decode_end,
750  .p.capabilities = AV_CODEC_CAP_DR1,
751  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
752 };
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:839
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:80
GetByteContext
Definition: bytestream.h:33
clv_dc_syms
static const uint8_t clv_dc_syms[NUM_DC_CODES]
Definition: clearvideodata.h:41
thread.h
CLVContext::pmb_width
int pmb_width
Definition: clearvideo.c:69
LevelCodes::mv_cb
VLC mv_cb
Definition: clearvideo.c:43
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
MVInfo::mv
MV * mv
Definition: clearvideo.c:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
clv_mv_syms
static const uint16_t clv_mv_syms[]
Definition: clearvideodata.h:112
MV::y
int16_t y
Definition: clearvideo.c:48
AVFrame::width
int width
Definition: frame.h:397
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:374
MVInfo::mb_w
int mb_w
Definition: clearvideo.c:54
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:119
clearvideodata.h
CLVContext::top_dc
int top_dc[3]
Definition: clearvideo.c:75
CLVContext::mvi
MVInfo mvi
Definition: clearvideo.c:70
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:91
CLVContext::pic
AVFrame * pic
Definition: clearvideo.c:65
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:679
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
MVInfo::top
int top
Definition: clearvideo.c:58
LevelCodes::flags_cb
VLC flags_cb
Definition: clearvideo.c:42
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:379
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:123
decode_mb
static int decode_mb(CLVContext *c, int x, int y)
Definition: clearvideo.c:171
GetBitContext
Definition: get_bits.h:61
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:68
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:586
dc_vlc
static VLC dc_vlc
Definition: clearvideo.c:78
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
clv_init_static
static av_cold void clv_init_static(void)
Definition: clearvideo.c:646
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:184
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:667
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
CLVContext::avctx
AVCodecContext * avctx
Definition: clearvideo.c:63
clv_dct
static void clv_dct(int16_t *block)
Definition: clearvideo.c:153
CLVContext::gb
GetBitContext gb
Definition: clearvideo.c:67
vlc_buf
static VLCElem vlc_buf[16716]
Definition: clearvideo.c:80
B
#define B
Definition: huffyuv.h:42
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
get_bits.h
MV::x
int16_t x
Definition: clearvideo.c:48
CLVContext::left_dc
int left_dc[4]
Definition: clearvideo.c:75
LevelCodes
Definition: clearvideo.c:41
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:66
blk
#define blk(i)
Definition: sha.c:186
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
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:64
CLVContext::tile_shift
int tile_shift
Definition: clearvideo.c:72
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
NULL
#define NULL
Definition: coverity.c:32
bias
static int bias(int x, int c)
Definition: vqcdec.c:110
INIT_VLC_STATIC_FROM_LENGTHS
#define INIT_VLC_STATIC_FROM_LENGTHS(vlc, bits, nb_codes, lens, len_wrap, symbols, symbols_wrap, symbols_size, offset, flags, static_size)
Definition: vlc.h:131
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc, 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, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: vlc.c:328
mathops.h
clv_decode_end
static av_cold int clv_decode_end(AVCodecContext *avctx)
Definition: clearvideo.c:729
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:53
MVInfo::mb_stride
int mb_stride
Definition: clearvideo.c:57
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:787
mvi_update_row
static void mvi_update_row(MVInfo *mvi)
Definition: clearvideo.c:355
AVOnce
#define AVOnce
Definition: thread.h:181
ac_vlc
static VLC ac_vlc
Definition: clearvideo.c:78
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
VLC::table_allocated
int table_allocated
Definition: vlc.h:34
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:375
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:353
MVInfo::mb_h
int mb_h
Definition: clearvideo.c:55
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:253
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:771
MV
Definition: clearvideo.c:47
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
size
int size
Definition: twinvq_data.h:10344
VLCElem
Definition: vlc.h:27
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:741
CLVContext::pmb_height
int pmb_height
Definition: clearvideo.c:69
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
NUM_AC_CODES
#define NUM_AC_CODES
Definition: clearvideodata.h:29
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:1390
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
clv_ac_bits
static const uint8_t clv_ac_bits[NUM_AC_CODES]
Definition: clearvideodata.h:71
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
lev
static LevelCodes lev[4+3+3]
Definition: clearvideo.c:79
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
CLVContext::tile_size
int tile_size
Definition: clearvideo.c:71
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
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:39
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:1568
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:101
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:44
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:73
LevelCodes::bias_cb
VLC bias_cb
Definition: clearvideo.c:44
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVFrame::height
int height
Definition: frame.h:397
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:68
VLC
Definition: vlc.h:31
MV_ESC
#define MV_ESC
Definition: clearvideodata.h:111
DCT_TEMPLATE
#define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)
Definition: clearvideo.c:126
VLC::table
VLCElem * table
Definition: vlc.h:33
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
VLC::table_size
int table_size
Definition: vlc.h:34
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:586
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
CLVContext::prev
AVFrame * prev
Definition: clearvideo.c:66
mvi_reset
static void mvi_reset(MVInfo *mvi, int mb_w, int mb_h, int mb_size)
Definition: clearvideo.c:345
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:423
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
CLVContext::idsp
IDCTDSPContext idsp
Definition: clearvideo.c:64
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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:73
NUM_DC_CODES
#define NUM_DC_CODES
Definition: clearvideodata.h:28
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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:561
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:370
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:62
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
CLVContext::block
int16_t block[64]
Definition: clearvideo.c:74
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:281
zero_mv
static const MV zero_mv
Definition: clearvideo.c:51
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:73
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:56
clv_ac_syms
static const uint16_t clv_ac_syms[NUM_AC_CODES]
Definition: clearvideodata.h:55
build_vlc
static av_cold void build_vlc(VLC *vlc, const uint8_t counts[16], const uint16_t **syms, unsigned *offset)
Definition: clearvideo.c:625
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:203