FFmpeg
cfhd.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2016 Kieran Kunhya <kieran@kunhya.com>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Cineform HD video decoder
24  */
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/buffer.h"
28 #include "libavutil/common.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/opt.h"
32 
33 #include "avcodec.h"
34 #include "bytestream.h"
35 #include "get_bits.h"
36 #include "internal.h"
37 #include "thread.h"
38 #include "cfhd.h"
39 
40 #define ALPHA_COMPAND_DC_OFFSET 256
41 #define ALPHA_COMPAND_GAIN 9400
42 
43 enum CFHDParam {
46  ImageWidth = 20,
54  ChannelWidth = 104,
57 };
58 
59 
60 
61 static av_cold int cfhd_init(AVCodecContext *avctx)
62 {
63  CFHDContext *s = avctx->priv_data;
64 
65  avctx->bits_per_raw_sample = 10;
66  s->avctx = avctx;
67 
68  return ff_cfhd_init_vlcs(s);
69 }
70 
72 {
73  s->subband_num = 0;
74  s->level = 0;
75  s->subband_num_actual = 0;
76 }
77 
79 {
80  s->peak.level = 0;
81  s->peak.offset = 0;
82  memset(&s->peak.base, 0, sizeof(s->peak.base));
83 }
84 
86 {
87  s->coded_width = 0;
88  s->coded_height = 0;
89  s->cropped_height = 0;
90  s->bpc = 10;
91  s->channel_cnt = 4;
93  s->channel_num = 0;
94  s->lowpass_precision = 16;
95  s->quantisation = 1;
96  s->wavelet_depth = 3;
97  s->pshift = 1;
98  s->codebook = 0;
99  s->difference_coding = 0;
100  s->progressive = 0;
103 }
104 
105 /* TODO: merge with VLC tables or use LUT */
106 static inline int dequant_and_decompand(int level, int quantisation, int codebook)
107 {
108  if (codebook == 0 || codebook == 1) {
109  int64_t abslevel = abs(level);
110  if (level < 264)
111  return (abslevel + ((768 * abslevel * abslevel * abslevel) / (255 * 255 * 255))) *
112  FFSIGN(level) * quantisation;
113  else
114  return level * quantisation;
115  } else
116  return level * quantisation;
117 }
118 
119 static inline void difference_coding(int16_t *band, int width, int height)
120 {
121 
122  int i,j;
123  for (i = 0; i < height; i++) {
124  for (j = 1; j < width; j++) {
125  band[j] += band[j-1];
126  }
127  band += width;
128  }
129 }
130 
131 static inline void peak_table(int16_t *band, Peak *peak, int length)
132 {
133  int i;
134  for (i = 0; i < length; i++)
135  if (abs(band[i]) > peak->level)
136  band[i] = bytestream2_get_le16(&peak->base);
137 }
138 
139 static inline void process_alpha(int16_t *alpha, int width)
140 {
141  int i, channel;
142  for (i = 0; i < width; i++) {
143  channel = alpha[i];
144  channel -= ALPHA_COMPAND_DC_OFFSET;
145  channel <<= 3;
146  channel *= ALPHA_COMPAND_GAIN;
147  channel >>= 16;
148  channel = av_clip_uintp2(channel, 12);
149  alpha[i] = channel;
150  }
151 }
152 
153 static inline void filter(int16_t *output, ptrdiff_t out_stride,
154  int16_t *low, ptrdiff_t low_stride,
155  int16_t *high, ptrdiff_t high_stride,
156  int len, int clip)
157 {
158  int16_t tmp;
159  int i;
160 
161  for (i = 0; i < len; i++) {
162  if (i == 0) {
163  tmp = (11*low[0*low_stride] - 4*low[1*low_stride] + low[2*low_stride] + 4) >> 3;
164  output[(2*i+0)*out_stride] = (tmp + high[0*high_stride]) >> 1;
165  if (clip)
166  output[(2*i+0)*out_stride] = av_clip_uintp2_c(output[(2*i+0)*out_stride], clip);
167 
168  tmp = ( 5*low[0*low_stride] + 4*low[1*low_stride] - low[2*low_stride] + 4) >> 3;
169  output[(2*i+1)*out_stride] = (tmp - high[0*high_stride]) >> 1;
170  if (clip)
171  output[(2*i+1)*out_stride] = av_clip_uintp2_c(output[(2*i+1)*out_stride], clip);
172  } else if (i == len-1) {
173  tmp = ( 5*low[i*low_stride] + 4*low[(i-1)*low_stride] - low[(i-2)*low_stride] + 4) >> 3;
174  output[(2*i+0)*out_stride] = (tmp + high[i*high_stride]) >> 1;
175  if (clip)
176  output[(2*i+0)*out_stride] = av_clip_uintp2_c(output[(2*i+0)*out_stride], clip);
177 
178  tmp = (11*low[i*low_stride] - 4*low[(i-1)*low_stride] + low[(i-2)*low_stride] + 4) >> 3;
179  output[(2*i+1)*out_stride] = (tmp - high[i*high_stride]) >> 1;
180  if (clip)
181  output[(2*i+1)*out_stride] = av_clip_uintp2_c(output[(2*i+1)*out_stride], clip);
182  } else {
183  tmp = (low[(i-1)*low_stride] - low[(i+1)*low_stride] + 4) >> 3;
184  output[(2*i+0)*out_stride] = (tmp + low[i*low_stride] + high[i*high_stride]) >> 1;
185  if (clip)
186  output[(2*i+0)*out_stride] = av_clip_uintp2_c(output[(2*i+0)*out_stride], clip);
187 
188  tmp = (low[(i+1)*low_stride] - low[(i-1)*low_stride] + 4) >> 3;
189  output[(2*i+1)*out_stride] = (tmp + low[i*low_stride] - high[i*high_stride]) >> 1;
190  if (clip)
191  output[(2*i+1)*out_stride] = av_clip_uintp2_c(output[(2*i+1)*out_stride], clip);
192  }
193  }
194 }
195 
196 static inline void interlaced_vertical_filter(int16_t *output, int16_t *low, int16_t *high,
197  int width, int linesize, int plane)
198 {
199  int i;
200  int16_t even, odd;
201  for (i = 0; i < width; i++) {
202  even = (low[i] - high[i])/2;
203  odd = (low[i] + high[i])/2;
204  output[i] = av_clip_uintp2(even, 10);
205  output[i + linesize] = av_clip_uintp2(odd, 10);
206  }
207 }
208 static void horiz_filter(int16_t *output, int16_t *low, int16_t *high,
209  int width)
210 {
211  filter(output, 1, low, 1, high, 1, width, 0);
212 }
213 
214 static void horiz_filter_clip(int16_t *output, int16_t *low, int16_t *high,
215  int width, int clip)
216 {
217  filter(output, 1, low, 1, high, 1, width, clip);
218 }
219 
220 static void vert_filter(int16_t *output, ptrdiff_t out_stride,
221  int16_t *low, ptrdiff_t low_stride,
222  int16_t *high, ptrdiff_t high_stride, int len)
223 {
224  filter(output, out_stride, low, low_stride, high, high_stride, len, 0);
225 }
226 
228 {
229  int i, j;
230 
231  for (i = 0; i < FF_ARRAY_ELEMS(s->plane); i++) {
232  av_freep(&s->plane[i].idwt_buf);
233  av_freep(&s->plane[i].idwt_tmp);
234 
235  for (j = 0; j < 9; j++)
236  s->plane[i].subband[j] = NULL;
237 
238  for (j = 0; j < 8; j++)
239  s->plane[i].l_h[j] = NULL;
240  }
241  s->a_height = 0;
242  s->a_width = 0;
243 }
244 
245 static int alloc_buffers(AVCodecContext *avctx)
246 {
247  CFHDContext *s = avctx->priv_data;
248  int i, j, ret, planes;
249  int chroma_x_shift, chroma_y_shift;
250  unsigned k;
251 
252  if ((ret = ff_set_dimensions(avctx, s->coded_width, s->coded_height)) < 0)
253  return ret;
254  avctx->pix_fmt = s->coded_format;
255 
257  &chroma_x_shift,
258  &chroma_y_shift)) < 0)
259  return ret;
261 
262  for (i = 0; i < planes; i++) {
263  int w8, h8, w4, h4, w2, h2;
264  int width = i ? avctx->width >> chroma_x_shift : avctx->width;
265  int height = i ? avctx->height >> chroma_y_shift : avctx->height;
266  ptrdiff_t stride = FFALIGN(width / 8, 8) * 8;
267  if (chroma_y_shift)
268  height = FFALIGN(height / 8, 2) * 8;
269  s->plane[i].width = width;
270  s->plane[i].height = height;
271  s->plane[i].stride = stride;
272 
273  w8 = FFALIGN(s->plane[i].width / 8, 8);
274  h8 = height / 8;
275  w4 = w8 * 2;
276  h4 = h8 * 2;
277  w2 = w4 * 2;
278  h2 = h4 * 2;
279 
280  s->plane[i].idwt_buf =
281  av_mallocz_array(height * stride, sizeof(*s->plane[i].idwt_buf));
282  s->plane[i].idwt_tmp =
283  av_malloc_array(height * stride, sizeof(*s->plane[i].idwt_tmp));
284  if (!s->plane[i].idwt_buf || !s->plane[i].idwt_tmp)
285  return AVERROR(ENOMEM);
286 
287  s->plane[i].subband[0] = s->plane[i].idwt_buf;
288  s->plane[i].subband[1] = s->plane[i].idwt_buf + 2 * w8 * h8;
289  s->plane[i].subband[2] = s->plane[i].idwt_buf + 1 * w8 * h8;
290  s->plane[i].subband[3] = s->plane[i].idwt_buf + 3 * w8 * h8;
291  s->plane[i].subband[4] = s->plane[i].idwt_buf + 2 * w4 * h4;
292  s->plane[i].subband[5] = s->plane[i].idwt_buf + 1 * w4 * h4;
293  s->plane[i].subband[6] = s->plane[i].idwt_buf + 3 * w4 * h4;
294  s->plane[i].subband[7] = s->plane[i].idwt_buf + 2 * w2 * h2;
295  s->plane[i].subband[8] = s->plane[i].idwt_buf + 1 * w2 * h2;
296  s->plane[i].subband[9] = s->plane[i].idwt_buf + 3 * w2 * h2;
297 
298  for (j = 0; j < DWT_LEVELS; j++) {
299  for (k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
300  s->plane[i].band[j][k].a_width = w8 << j;
301  s->plane[i].band[j][k].a_height = h8 << j;
302  }
303  }
304 
305  /* ll2 and ll1 commented out because they are done in-place */
306  s->plane[i].l_h[0] = s->plane[i].idwt_tmp;
307  s->plane[i].l_h[1] = s->plane[i].idwt_tmp + 2 * w8 * h8;
308  // s->plane[i].l_h[2] = ll2;
309  s->plane[i].l_h[3] = s->plane[i].idwt_tmp;
310  s->plane[i].l_h[4] = s->plane[i].idwt_tmp + 2 * w4 * h4;
311  // s->plane[i].l_h[5] = ll1;
312  s->plane[i].l_h[6] = s->plane[i].idwt_tmp;
313  s->plane[i].l_h[7] = s->plane[i].idwt_tmp + 2 * w2 * h2;
314  }
315 
316  s->a_height = s->coded_height;
317  s->a_width = s->coded_width;
318  s->a_format = s->coded_format;
319 
320  return 0;
321 }
322 
323 static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
324  AVPacket *avpkt)
325 {
326  CFHDContext *s = avctx->priv_data;
327  GetByteContext gb;
328  ThreadFrame frame = { .f = data };
329  AVFrame *pic = data;
330  int ret = 0, i, j, planes, plane, got_buffer = 0;
331  int16_t *coeff_data;
332 
336 
337  bytestream2_init(&gb, avpkt->data, avpkt->size);
338 
339  while (bytestream2_get_bytes_left(&gb) > 4) {
340  /* Bit weird but implement the tag parsing as the spec says */
341  uint16_t tagu = bytestream2_get_be16(&gb);
342  int16_t tag = (int16_t)tagu;
343  int8_t tag8 = (int8_t)(tagu >> 8);
344  uint16_t abstag = abs(tag);
345  int8_t abs_tag8 = abs(tag8);
346  uint16_t data = bytestream2_get_be16(&gb);
347  if (abs_tag8 >= 0x60 && abs_tag8 <= 0x6f) {
348  av_log(avctx, AV_LOG_DEBUG, "large len %x\n", ((tagu & 0xff) << 16) | data);
349  } else if (tag == SampleFlags) {
350  av_log(avctx, AV_LOG_DEBUG, "Progressive?%"PRIu16"\n", data);
351  s->progressive = data & 0x0001;
352  } else if (tag == ImageWidth) {
353  av_log(avctx, AV_LOG_DEBUG, "Width %"PRIu16"\n", data);
354  s->coded_width = data;
355  } else if (tag == ImageHeight) {
356  av_log(avctx, AV_LOG_DEBUG, "Height %"PRIu16"\n", data);
357  s->coded_height = data;
358  } else if (tag == 101) {
359  av_log(avctx, AV_LOG_DEBUG, "Bits per component: %"PRIu16"\n", data);
360  if (data < 1 || data > 31) {
361  av_log(avctx, AV_LOG_ERROR, "Bits per component %d is invalid\n", data);
362  ret = AVERROR(EINVAL);
363  break;
364  }
365  s->bpc = data;
366  } else if (tag == ChannelCount) {
367  av_log(avctx, AV_LOG_DEBUG, "Channel Count: %"PRIu16"\n", data);
368  s->channel_cnt = data;
369  if (data > 4) {
370  av_log(avctx, AV_LOG_ERROR, "Channel Count of %"PRIu16" is unsupported\n", data);
371  ret = AVERROR_PATCHWELCOME;
372  break;
373  }
374  } else if (tag == SubbandCount) {
375  av_log(avctx, AV_LOG_DEBUG, "Subband Count: %"PRIu16"\n", data);
376  if (data != SUBBAND_COUNT) {
377  av_log(avctx, AV_LOG_ERROR, "Subband Count of %"PRIu16" is unsupported\n", data);
378  ret = AVERROR_PATCHWELCOME;
379  break;
380  }
381  } else if (tag == ChannelNumber) {
382  s->channel_num = data;
383  av_log(avctx, AV_LOG_DEBUG, "Channel number %"PRIu16"\n", data);
384  if (s->channel_num >= planes) {
385  av_log(avctx, AV_LOG_ERROR, "Invalid channel number\n");
386  ret = AVERROR(EINVAL);
387  break;
388  }
390  } else if (tag == SubbandNumber) {
391  if (s->subband_num != 0 && data == 1) // hack
392  s->level++;
393  av_log(avctx, AV_LOG_DEBUG, "Subband number %"PRIu16"\n", data);
394  s->subband_num = data;
395  if (s->level >= DWT_LEVELS) {
396  av_log(avctx, AV_LOG_ERROR, "Invalid level\n");
397  ret = AVERROR(EINVAL);
398  break;
399  }
400  if (s->subband_num > 3) {
401  av_log(avctx, AV_LOG_ERROR, "Invalid subband number\n");
402  ret = AVERROR(EINVAL);
403  break;
404  }
405  } else if (tag == 51) {
406  av_log(avctx, AV_LOG_DEBUG, "Subband number actual %"PRIu16"\n", data);
408  if (s->subband_num_actual >= 10) {
409  av_log(avctx, AV_LOG_ERROR, "Invalid subband number actual\n");
410  ret = AVERROR(EINVAL);
411  break;
412  }
413  } else if (tag == LowpassPrecision)
414  av_log(avctx, AV_LOG_DEBUG, "Lowpass precision bits: %"PRIu16"\n", data);
415  else if (tag == Quantization) {
416  s->quantisation = data;
417  av_log(avctx, AV_LOG_DEBUG, "Quantisation: %"PRIu16"\n", data);
418  } else if (tag == PrescaleShift) {
419  s->prescale_shift[0] = (data >> 0) & 0x7;
420  s->prescale_shift[1] = (data >> 3) & 0x7;
421  s->prescale_shift[2] = (data >> 6) & 0x7;
422  av_log(avctx, AV_LOG_DEBUG, "Prescale shift (VC-5): %x\n", data);
423  } else if (tag == 27) {
424  av_log(avctx, AV_LOG_DEBUG, "Lowpass width %"PRIu16"\n", data);
425  if (data < 3 || data > s->plane[s->channel_num].band[0][0].a_width) {
426  av_log(avctx, AV_LOG_ERROR, "Invalid lowpass width\n");
427  ret = AVERROR(EINVAL);
428  break;
429  }
430  s->plane[s->channel_num].band[0][0].width = data;
431  s->plane[s->channel_num].band[0][0].stride = data;
432  } else if (tag == 28) {
433  av_log(avctx, AV_LOG_DEBUG, "Lowpass height %"PRIu16"\n", data);
434  if (data < 3 || data > s->plane[s->channel_num].band[0][0].a_height) {
435  av_log(avctx, AV_LOG_ERROR, "Invalid lowpass height\n");
436  ret = AVERROR(EINVAL);
437  break;
438  }
439  s->plane[s->channel_num].band[0][0].height = data;
440  } else if (tag == 1)
441  av_log(avctx, AV_LOG_DEBUG, "Sample type? %"PRIu16"\n", data);
442  else if (tag == 10) {
443  if (data != 0) {
444  avpriv_report_missing_feature(avctx, "Transform type of %"PRIu16, data);
445  ret = AVERROR_PATCHWELCOME;
446  break;
447  }
448  av_log(avctx, AV_LOG_DEBUG, "Transform-type? %"PRIu16"\n", data);
449  } else if (abstag >= 0x4000 && abstag <= 0x40ff) {
450  if (abstag == 0x4001)
451  s->peak.level = 0;
452  av_log(avctx, AV_LOG_DEBUG, "Small chunk length %d %s\n", data * 4, tag < 0 ? "optional" : "required");
453  bytestream2_skipu(&gb, data * 4);
454  } else if (tag == 23) {
455  av_log(avctx, AV_LOG_DEBUG, "Skip frame\n");
456  avpriv_report_missing_feature(avctx, "Skip frame");
457  ret = AVERROR_PATCHWELCOME;
458  break;
459  } else if (tag == 2) {
460  av_log(avctx, AV_LOG_DEBUG, "tag=2 header - skipping %i tag/value pairs\n", data);
461  if (data > bytestream2_get_bytes_left(&gb) / 4) {
462  av_log(avctx, AV_LOG_ERROR, "too many tag/value pairs (%d)\n", data);
463  ret = AVERROR_INVALIDDATA;
464  break;
465  }
466  for (i = 0; i < data; i++) {
467  uint16_t tag2 = bytestream2_get_be16(&gb);
468  uint16_t val2 = bytestream2_get_be16(&gb);
469  av_log(avctx, AV_LOG_DEBUG, "Tag/Value = %x %x\n", tag2, val2);
470  }
471  } else if (tag == 41) {
472  av_log(avctx, AV_LOG_DEBUG, "Highpass width %i channel %i level %i subband %i\n", data, s->channel_num, s->level, s->subband_num);
473  if (data < 3) {
474  av_log(avctx, AV_LOG_ERROR, "Invalid highpass width\n");
475  ret = AVERROR(EINVAL);
476  break;
477  }
478  s->plane[s->channel_num].band[s->level][s->subband_num].width = data;
479  s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
480  } else if (tag == 42) {
481  av_log(avctx, AV_LOG_DEBUG, "Highpass height %i\n", data);
482  if (data < 3) {
483  av_log(avctx, AV_LOG_ERROR, "Invalid highpass height\n");
484  ret = AVERROR(EINVAL);
485  break;
486  }
487  s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
488  } else if (tag == 49) {
489  av_log(avctx, AV_LOG_DEBUG, "Highpass width2 %i\n", data);
490  if (data < 3) {
491  av_log(avctx, AV_LOG_ERROR, "Invalid highpass width2\n");
492  ret = AVERROR(EINVAL);
493  break;
494  }
495  s->plane[s->channel_num].band[s->level][s->subband_num].width = data;
496  s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
497  } else if (tag == 50) {
498  av_log(avctx, AV_LOG_DEBUG, "Highpass height2 %i\n", data);
499  if (data < 3) {
500  av_log(avctx, AV_LOG_ERROR, "Invalid highpass height2\n");
501  ret = AVERROR(EINVAL);
502  break;
503  }
504  s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
505  } else if (tag == 71) {
506  s->codebook = data;
507  av_log(avctx, AV_LOG_DEBUG, "Codebook %i\n", s->codebook);
508  } else if (tag == 72) {
509  s->codebook = data & 0xf;
510  s->difference_coding = (data >> 4) & 1;
511  av_log(avctx, AV_LOG_DEBUG, "Other codebook? %i\n", s->codebook);
512  } else if (tag == 70) {
513  av_log(avctx, AV_LOG_DEBUG, "Subsampling or bit-depth flag? %i\n", data);
514  if (!(data == 10 || data == 12)) {
515  av_log(avctx, AV_LOG_ERROR, "Invalid bits per channel\n");
516  ret = AVERROR(EINVAL);
517  break;
518  }
519  s->bpc = data;
520  } else if (tag == 84) {
521  av_log(avctx, AV_LOG_DEBUG, "Sample format? %i\n", data);
522  if (data == 1)
524  else if (data == 3)
526  else if (data == 4)
528  else {
529  avpriv_report_missing_feature(avctx, "Sample format of %"PRIu16, data);
530  ret = AVERROR_PATCHWELCOME;
531  break;
532  }
534  } else if (tag == -85) {
535  av_log(avctx, AV_LOG_DEBUG, "Cropped height %"PRIu16"\n", data);
536  s->cropped_height = data;
537  } else if (tag == -75) {
538  s->peak.offset &= ~0xffff;
539  s->peak.offset |= (data & 0xffff);
540  s->peak.base = gb;
541  s->peak.level = 0;
542  } else if (tag == -76) {
543  s->peak.offset &= 0xffff;
544  s->peak.offset |= (data & 0xffffU)<<16;
545  s->peak.base = gb;
546  s->peak.level = 0;
547  } else if (tag == -74 && s->peak.offset) {
548  s->peak.level = data;
549  bytestream2_seek(&s->peak.base, s->peak.offset - 4, SEEK_CUR);
550  } else
551  av_log(avctx, AV_LOG_DEBUG, "Unknown tag %i data %x\n", tag, data);
552 
553  /* Some kind of end of header tag */
554  if (tag == 4 && data == 0x1a4a && s->coded_width && s->coded_height &&
556  if (s->a_width != s->coded_width || s->a_height != s->coded_height ||
557  s->a_format != s->coded_format) {
558  free_buffers(s);
559  if ((ret = alloc_buffers(avctx)) < 0) {
560  free_buffers(s);
561  return ret;
562  }
563  }
564  ret = ff_set_dimensions(avctx, s->coded_width, s->coded_height);
565  if (ret < 0)
566  return ret;
567  if (s->cropped_height)
568  avctx->height = s->cropped_height;
569  frame.f->width =
570  frame.f->height = 0;
571 
572  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
573  return ret;
574 
575  s->coded_width = 0;
576  s->coded_height = 0;
578  got_buffer = 1;
579  }
580  coeff_data = s->plane[s->channel_num].subband[s->subband_num_actual];
581 
582  /* Lowpass coefficients */
583  if (tag == 4 && data == 0xf0f && s->a_width && s->a_height) {
584  int lowpass_height = s->plane[s->channel_num].band[0][0].height;
585  int lowpass_width = s->plane[s->channel_num].band[0][0].width;
586  int lowpass_a_height = s->plane[s->channel_num].band[0][0].a_height;
587  int lowpass_a_width = s->plane[s->channel_num].band[0][0].a_width;
588 
589  if (!got_buffer) {
590  av_log(avctx, AV_LOG_ERROR, "No end of header tag found\n");
591  ret = AVERROR(EINVAL);
592  goto end;
593  }
594 
595  if (lowpass_height > lowpass_a_height || lowpass_width > lowpass_a_width ||
596  lowpass_a_width * lowpass_a_height * sizeof(int16_t) > bytestream2_get_bytes_left(&gb)) {
597  av_log(avctx, AV_LOG_ERROR, "Too many lowpass coefficients\n");
598  ret = AVERROR(EINVAL);
599  goto end;
600  }
601 
602  av_log(avctx, AV_LOG_DEBUG, "Start of lowpass coeffs component %d height:%d, width:%d\n", s->channel_num, lowpass_height, lowpass_width);
603  for (i = 0; i < lowpass_height; i++) {
604  for (j = 0; j < lowpass_width; j++)
605  coeff_data[j] = bytestream2_get_be16u(&gb);
606 
607  coeff_data += lowpass_width;
608  }
609 
610  /* Align to mod-4 position to continue reading tags */
611  bytestream2_seek(&gb, bytestream2_tell(&gb) & 3, SEEK_CUR);
612 
613  /* Copy last line of coefficients if odd height */
614  if (lowpass_height & 1) {
615  memcpy(&coeff_data[lowpass_height * lowpass_width],
616  &coeff_data[(lowpass_height - 1) * lowpass_width],
617  lowpass_width * sizeof(*coeff_data));
618  }
619 
620  av_log(avctx, AV_LOG_DEBUG, "Lowpass coefficients %d\n", lowpass_width * lowpass_height);
621  }
622 
623  if (tag == 55 && s->subband_num_actual != 255 && s->a_width && s->a_height) {
624  int highpass_height = s->plane[s->channel_num].band[s->level][s->subband_num].height;
625  int highpass_width = s->plane[s->channel_num].band[s->level][s->subband_num].width;
626  int highpass_a_width = s->plane[s->channel_num].band[s->level][s->subband_num].a_width;
627  int highpass_a_height = s->plane[s->channel_num].band[s->level][s->subband_num].a_height;
628  int highpass_stride = s->plane[s->channel_num].band[s->level][s->subband_num].stride;
629  int expected;
630  int a_expected = highpass_a_height * highpass_a_width;
631  int level, run, coeff;
632  int count = 0, bytes;
633 
634  if (!got_buffer) {
635  av_log(avctx, AV_LOG_ERROR, "No end of header tag found\n");
636  ret = AVERROR(EINVAL);
637  goto end;
638  }
639 
640  if (highpass_height > highpass_a_height || highpass_width > highpass_a_width || a_expected < highpass_height * (uint64_t)highpass_stride) {
641  av_log(avctx, AV_LOG_ERROR, "Too many highpass coefficients\n");
642  ret = AVERROR(EINVAL);
643  goto end;
644  }
645  expected = highpass_height * highpass_stride;
646 
647  av_log(avctx, AV_LOG_DEBUG, "Start subband coeffs plane %i level %i codebook %i expected %i\n", s->channel_num, s->level, s->codebook, expected);
648 
650  {
651  OPEN_READER(re, &s->gb);
652  if (!s->codebook) {
653  while (1) {
654  UPDATE_CACHE(re, &s->gb);
655  GET_RL_VLC(level, run, re, &s->gb, s->table_9_rl_vlc,
656  VLC_BITS, 3, 1);
657 
658  /* escape */
659  if (level == 64)
660  break;
661 
662  count += run;
663 
664  if (count > expected)
665  break;
666 
667  coeff = dequant_and_decompand(level, s->quantisation, 0);
668  for (i = 0; i < run; i++)
669  *coeff_data++ = coeff;
670  }
671  } else {
672  while (1) {
673  UPDATE_CACHE(re, &s->gb);
674  GET_RL_VLC(level, run, re, &s->gb, s->table_18_rl_vlc,
675  VLC_BITS, 3, 1);
676 
677  /* escape */
678  if (level == 255 && run == 2)
679  break;
680 
681  count += run;
682 
683  if (count > expected)
684  break;
685 
686  coeff = dequant_and_decompand(level, s->quantisation, s->codebook);
687  for (i = 0; i < run; i++)
688  *coeff_data++ = coeff;
689  }
690  }
691  CLOSE_READER(re, &s->gb);
692  }
693 
694  if (count > expected) {
695  av_log(avctx, AV_LOG_ERROR, "Escape codeword not found, probably corrupt data\n");
696  ret = AVERROR(EINVAL);
697  goto end;
698  }
699  if (s->peak.level)
700  peak_table(coeff_data - count, &s->peak, count);
701  if (s->difference_coding)
702  difference_coding(s->plane[s->channel_num].subband[s->subband_num_actual], highpass_width, highpass_height);
703 
704  bytes = FFALIGN(AV_CEIL_RSHIFT(get_bits_count(&s->gb), 3), 4);
705  if (bytes > bytestream2_get_bytes_left(&gb)) {
706  av_log(avctx, AV_LOG_ERROR, "Bitstream overread error\n");
707  ret = AVERROR(EINVAL);
708  goto end;
709  } else
710  bytestream2_seek(&gb, bytes, SEEK_CUR);
711 
712  av_log(avctx, AV_LOG_DEBUG, "End subband coeffs %i extra %i\n", count, count - expected);
713  s->codebook = 0;
714 
715  /* Copy last line of coefficients if odd height */
716  if (highpass_height & 1) {
717  memcpy(&coeff_data[highpass_height * highpass_stride],
718  &coeff_data[(highpass_height - 1) * highpass_stride],
719  highpass_stride * sizeof(*coeff_data));
720  }
721  }
722  }
723 
724  if (!s->a_width || !s->a_height || s->a_format == AV_PIX_FMT_NONE ||
726  av_log(avctx, AV_LOG_ERROR, "Invalid dimensions\n");
727  ret = AVERROR(EINVAL);
728  goto end;
729  }
730 
731  if (!got_buffer) {
732  av_log(avctx, AV_LOG_ERROR, "No end of header tag found\n");
733  ret = AVERROR(EINVAL);
734  goto end;
735  }
736 
737  planes = av_pix_fmt_count_planes(avctx->pix_fmt);
738  for (plane = 0; plane < planes && !ret; plane++) {
739  /* level 1 */
740  int lowpass_height = s->plane[plane].band[0][0].height;
741  int lowpass_width = s->plane[plane].band[0][0].width;
742  int highpass_stride = s->plane[plane].band[0][1].stride;
743  int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
744  int16_t *low, *high, *output, *dst;
745 
746  if (lowpass_height > s->plane[plane].band[0][0].a_height || lowpass_width > s->plane[plane].band[0][0].a_width ||
747  !highpass_stride || s->plane[plane].band[0][1].width > s->plane[plane].band[0][1].a_width) {
748  av_log(avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");
749  ret = AVERROR(EINVAL);
750  goto end;
751  }
752 
753  av_log(avctx, AV_LOG_DEBUG, "Decoding level 1 plane %i %i %i %i\n", plane, lowpass_height, lowpass_width, highpass_stride);
754 
755  low = s->plane[plane].subband[0];
756  high = s->plane[plane].subband[2];
757  output = s->plane[plane].l_h[0];
758  for (i = 0; i < lowpass_width; i++) {
759  vert_filter(output, lowpass_width, low, lowpass_width, high, highpass_stride, lowpass_height);
760  low++;
761  high++;
762  output++;
763  }
764 
765  low = s->plane[plane].subband[1];
766  high = s->plane[plane].subband[3];
767  output = s->plane[plane].l_h[1];
768 
769  for (i = 0; i < lowpass_width; i++) {
770  // note the stride of "low" is highpass_stride
771  vert_filter(output, lowpass_width, low, highpass_stride, high, highpass_stride, lowpass_height);
772  low++;
773  high++;
774  output++;
775  }
776 
777  low = s->plane[plane].l_h[0];
778  high = s->plane[plane].l_h[1];
779  output = s->plane[plane].subband[0];
780  for (i = 0; i < lowpass_height * 2; i++) {
781  horiz_filter(output, low, high, lowpass_width);
782  low += lowpass_width;
783  high += lowpass_width;
784  output += lowpass_width * 2;
785  }
786  if (s->bpc == 12) {
787  output = s->plane[plane].subband[0];
788  for (i = 0; i < lowpass_height * 2; i++) {
789  for (j = 0; j < lowpass_width * 2; j++)
790  output[j] *= 4;
791 
792  output += lowpass_width * 2;
793  }
794  }
795 
796  /* level 2 */
797  lowpass_height = s->plane[plane].band[1][1].height;
798  lowpass_width = s->plane[plane].band[1][1].width;
799  highpass_stride = s->plane[plane].band[1][1].stride;
800 
801  if (lowpass_height > s->plane[plane].band[1][1].a_height || lowpass_width > s->plane[plane].band[1][1].a_width ||
802  !highpass_stride || s->plane[plane].band[1][1].width > s->plane[plane].band[1][1].a_width) {
803  av_log(avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");
804  ret = AVERROR(EINVAL);
805  goto end;
806  }
807 
808  av_log(avctx, AV_LOG_DEBUG, "Level 2 plane %i %i %i %i\n", plane, lowpass_height, lowpass_width, highpass_stride);
809 
810  low = s->plane[plane].subband[0];
811  high = s->plane[plane].subband[5];
812  output = s->plane[plane].l_h[3];
813  for (i = 0; i < lowpass_width; i++) {
814  vert_filter(output, lowpass_width, low, lowpass_width, high, highpass_stride, lowpass_height);
815  low++;
816  high++;
817  output++;
818  }
819 
820  low = s->plane[plane].subband[4];
821  high = s->plane[plane].subband[6];
822  output = s->plane[plane].l_h[4];
823  for (i = 0; i < lowpass_width; i++) {
824  vert_filter(output, lowpass_width, low, highpass_stride, high, highpass_stride, lowpass_height);
825  low++;
826  high++;
827  output++;
828  }
829 
830  low = s->plane[plane].l_h[3];
831  high = s->plane[plane].l_h[4];
832  output = s->plane[plane].subband[0];
833  for (i = 0; i < lowpass_height * 2; i++) {
834  horiz_filter(output, low, high, lowpass_width);
835  low += lowpass_width;
836  high += lowpass_width;
837  output += lowpass_width * 2;
838  }
839 
840  output = s->plane[plane].subband[0];
841  for (i = 0; i < lowpass_height * 2; i++) {
842  for (j = 0; j < lowpass_width * 2; j++)
843  output[j] *= 4;
844 
845  output += lowpass_width * 2;
846  }
847 
848  /* level 3 */
849  lowpass_height = s->plane[plane].band[2][1].height;
850  lowpass_width = s->plane[plane].band[2][1].width;
851  highpass_stride = s->plane[plane].band[2][1].stride;
852 
853  if (lowpass_height > s->plane[plane].band[2][1].a_height || lowpass_width > s->plane[plane].band[2][1].a_width ||
854  !highpass_stride || s->plane[plane].band[2][1].width > s->plane[plane].band[2][1].a_width) {
855  av_log(avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");
856  ret = AVERROR(EINVAL);
857  goto end;
858  }
859 
860  av_log(avctx, AV_LOG_DEBUG, "Level 3 plane %i %i %i %i\n", plane, lowpass_height, lowpass_width, highpass_stride);
861  if (s->progressive) {
862  low = s->plane[plane].subband[0];
863  high = s->plane[plane].subband[8];
864  output = s->plane[plane].l_h[6];
865  for (i = 0; i < lowpass_width; i++) {
866  vert_filter(output, lowpass_width, low, lowpass_width, high, highpass_stride, lowpass_height);
867  low++;
868  high++;
869  output++;
870  }
871 
872  low = s->plane[plane].subband[7];
873  high = s->plane[plane].subband[9];
874  output = s->plane[plane].l_h[7];
875  for (i = 0; i < lowpass_width; i++) {
876  vert_filter(output, lowpass_width, low, highpass_stride, high, highpass_stride, lowpass_height);
877  low++;
878  high++;
879  output++;
880  }
881 
882  dst = (int16_t *)pic->data[act_plane];
883  low = s->plane[plane].l_h[6];
884  high = s->plane[plane].l_h[7];
885  for (i = 0; i < lowpass_height * 2; i++) {
886  horiz_filter_clip(dst, low, high, lowpass_width, s->bpc);
887  low += lowpass_width;
888  high += lowpass_width;
889  dst += pic->linesize[act_plane] / 2;
890  }
891  } else {
892  av_log(avctx, AV_LOG_DEBUG, "interlaced frame ? %d", pic->interlaced_frame);
893  pic->interlaced_frame = 1;
894  low = s->plane[plane].subband[0];
895  high = s->plane[plane].subband[7];
896  output = s->plane[plane].l_h[6];
897  for (i = 0; i < lowpass_height; i++) {
898  horiz_filter(output, low, high, lowpass_width);
899  low += lowpass_width;
900  high += lowpass_width;
901  output += lowpass_width * 2;
902  }
903 
904  low = s->plane[plane].subband[8];
905  high = s->plane[plane].subband[9];
906  output = s->plane[plane].l_h[7];
907  for (i = 0; i < lowpass_height; i++) {
908  horiz_filter(output, low, high, lowpass_width);
909  low += lowpass_width;
910  high += lowpass_width;
911  output += lowpass_width * 2;
912  }
913 
914  dst = (int16_t *)pic->data[act_plane];
915  low = s->plane[plane].l_h[6];
916  high = s->plane[plane].l_h[7];
917  for (i = 0; i < lowpass_height; i++) {
918  interlaced_vertical_filter(dst, low, high, lowpass_width * 2, pic->linesize[act_plane]/2, act_plane);
919  low += lowpass_width * 2;
920  high += lowpass_width * 2;
921  dst += pic->linesize[act_plane];
922  }
923  }
924  }
925 
926 
927 end:
928  if (ret < 0)
929  return ret;
930 
931  *got_frame = 1;
932  return avpkt->size;
933 }
934 
936 {
937  CFHDContext *s = avctx->priv_data;
938 
939  free_buffers(s);
940 
941  if (!avctx->internal->is_copy) {
942  ff_free_vlc(&s->vlc_9);
943  ff_free_vlc(&s->vlc_18);
944  }
945 
946  return 0;
947 }
948 
950  .name = "cfhd",
951  .long_name = NULL_IF_CONFIG_SMALL("Cineform HD"),
952  .type = AVMEDIA_TYPE_VIDEO,
953  .id = AV_CODEC_ID_CFHD,
954  .priv_data_size = sizeof(CFHDContext),
955  .init = cfhd_init,
956  .close = cfhd_close,
957  .decode = cfhd_decode,
960 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
int plane
Definition: avisynth_c.h:384
int channel_cnt
Definition: cfhd.h:100
#define NULL
Definition: coverity.c:32
int difference_coding
Definition: cfhd.h:109
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cfhd.c:323
VLC vlc_18
Definition: cfhd.h:85
CFHDParam
Definition: cfhd.c:43
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
AVCodecContext * avctx
Definition: cfhd.h:79
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void peak_table(int16_t *band, Peak *peak, int length)
Definition: cfhd.c:131
float re
Definition: fft.c:82
misc image utilities
AVFrame * f
Definition: thread.h:35
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2562
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:104
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define ALPHA_COMPAND_GAIN
Definition: cfhd.c:41
int a_height
Definition: cfhd.h:50
int level
Definition: cfhd.h:73
int size
Definition: avcodec.h:1478
#define VLC_BITS
Definition: asvdec.c:37
int cropped_height
Definition: cfhd.h:91
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int16_t * idwt_tmp
Definition: cfhd.h:63
int a_width
Definition: cfhd.h:95
ptrdiff_t stride
Definition: cfhd.h:47
uint8_t run
Definition: svq3.c:206
int subband_num_actual
Definition: cfhd.h:112
static void horiz_filter_clip(int16_t *output, int16_t *low, int16_t *high, int width, int clip)
Definition: cfhd.c:214
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2792
AVCodec.
Definition: avcodec.h:3477
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static void interlaced_vertical_filter(int16_t *output, int16_t *low, int16_t *high, int width, int linesize, int plane)
Definition: cfhd.c:196
Macro definitions for various function/variable attributes.
int width
Definition: cfhd.h:49
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:153
static void horiz_filter(int16_t *output, int16_t *low, int16_t *high, int width)
Definition: cfhd.c:208
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
#define av_cold
Definition: attributes.h:82
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Multithreading support functions.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
int16_t * idwt_buf
Definition: cfhd.h:62
int a_format
Definition: cfhd.h:97
static int alloc_buffers(AVCodecContext *avctx)
Definition: cfhd.c:245
#define height
uint8_t * data
Definition: avcodec.h:1477
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
const uint8_t * buffer
Definition: bytestream.h:34
uint32_t tag
Definition: movenc.c:1496
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:170
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:415
#define FFALIGN(x, a)
Definition: macros.h:48
#define SUBBAND_COUNT
Definition: cfhd.h:34
#define av_log(a,...)
static int dequant_and_decompand(int level, int quantisation, int codebook)
Definition: cfhd.c:106
static const struct @309 planes[]
CFHD_RL_VLC_ELEM table_18_rl_vlc[4572]
Definition: cfhd.h:84
CFHD_RL_VLC_ELEM table_9_rl_vlc[2088]
Definition: cfhd.h:81
#define U(x)
Definition: vp56_arith.h:37
uint8_t prescale_shift[3]
Definition: cfhd.h:114
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
int width
Definition: frame.h:326
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:136
VLC vlc_9
Definition: cfhd.h:82
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2550
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int16_t * l_h[8]
Definition: cfhd.h:67
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:408
#define DWT_LEVELS
Definition: cfhd.h:42
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
GLsizei count
Definition: opengl_enc.c:108
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
#define GET_RL_VLC(level, run, name, gb, table, bits,max_depth, need_update)
Definition: get_bits.h:738
Definition: cfhd.h:72
int a_width
Definition: cfhd.h:48
static av_cold int cfhd_close(AVCodecContext *avctx)
Definition: cfhd.c:935
static void init_frame_defaults(CFHDContext *s)
Definition: cfhd.c:85
SubBand band[DWT_LEVELS][4]
Definition: cfhd.h:69
GetByteContext base
Definition: cfhd.h:75
int subband_cnt
Definition: cfhd.h:101
#define width
#define FFSIGN(a)
Definition: common.h:73
int width
picture width / height.
Definition: avcodec.h:1738
static void init_plane_defaults(CFHDContext *s)
Definition: cfhd.c:71
uint16_t quantisation
Definition: cfhd.h:104
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
static av_cold int cfhd_init(AVCodecContext *avctx)
Definition: cfhd.c:61
#define FF_ARRAY_ELEMS(a)
static void vert_filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len)
Definition: cfhd.c:220
int channel_num
Definition: cfhd.h:102
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
GetBitContext gb
Definition: cfhd.h:87
int wavelet_depth
Definition: cfhd.h:105
Libavcodec external API header.
#define ALPHA_COMPAND_DC_OFFSET
Definition: cfhd.c:40
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1565
int codebook
Definition: cfhd.h:108
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
static void difference_coding(int16_t *band, int width, int height)
Definition: cfhd.c:119
int subband_num
Definition: cfhd.h:110
int pshift
Definition: cfhd.h:106
enum AVPixelFormat coded_format
Definition: cfhd.h:92
AVCodec ff_cfhd_decoder
Definition: cfhd.c:949
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
refcounted data buffer API
Peak peak
Definition: cfhd.h:116
int level
Definition: cfhd.h:111
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
uint8_t level
Definition: svq3.c:207
int coded_width
Definition: cfhd.h:89
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
common internal api header.
common internal and external API header
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
Definition: vf_lut.c:162
static void process_alpha(int16_t *alpha, int width)
Definition: cfhd.c:139
ptrdiff_t stride
Definition: cfhd.h:60
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
int bpc
Definition: cfhd.h:99
void * priv_data
Definition: avcodec.h:1592
int len
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1600
int a_height
Definition: cfhd.h:96
static void init_peak_table_defaults(CFHDContext *s)
Definition: cfhd.c:78
int height
Definition: cfhd.h:51
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
int width
Definition: cfhd.h:58
int offset
Definition: cfhd.h:74
static void free_buffers(CFHDContext *s)
Definition: cfhd.c:227
int height
Definition: frame.h:326
int ff_cfhd_init_vlcs(CFHDContext *s)
Definition: cfhddata.c:276
int progressive
Definition: cfhd.h:93
#define av_freep(p)
#define av_malloc_array(a, b)
#define stride
Plane plane[4]
Definition: cfhd.h:115
int height
Definition: cfhd.h:59
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
uint8_t lowpass_precision
Definition: cfhd.h:103
int16_t * subband[SUBBAND_COUNT]
Definition: cfhd.h:66
This structure stores compressed data.
Definition: avcodec.h:1454
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
for(j=16;j >0;--j)
int coded_height
Definition: cfhd.h:90
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
Tag MUST be even
Definition: snow.txt:206
static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
Clip a signed integer to an unsigned power of two range.
Definition: common.h:229
static uint8_t tmp[11]
Definition: aes_ctr.c:26