FFmpeg
prosumer.c
Go to the documentation of this file.
1 /*
2  * Brooktree ProSumer Video decoder
3  * Copyright (c) 2018 Paul B Mahol
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 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 #include "libavutil/imgutils.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/mem.h"
30 
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "internal.h"
34 
35 typedef struct ProSumerContext {
38 
39  unsigned stride;
40  unsigned size;
41  uint32_t lut[0x2000];
45 
46 #define PAIR(high, low) (((uint64_t)(high) << 32) | low)
47 
48 static int decompress(GetByteContext *gb, int size, PutByteContext *pb, const uint32_t *lut)
49 {
50  int pos, idx, cnt, fill;
51  uint32_t a, b, c;
52 
53  bytestream2_skip(gb, 32);
54  cnt = 4;
55  a = bytestream2_get_le32(gb);
56  idx = a >> 20;
57  b = lut[2 * idx];
58 
59  while (1) {
61  return 0;
62  if ((b & 0xFF00u) != 0x8000u || (b & 0xFFu)) {
63  if ((b & 0xFF00u) != 0x8000u) {
64  bytestream2_put_le16(pb, b);
65  } else {
66  idx = 0;
67  for (int i = 0; i < (b & 0xFFu); i++)
68  bytestream2_put_le32(pb, 0);
69  }
70  c = b >> 16;
71  if (c & 0xFF00u) {
72  fill = lut[2 * idx + 1];
73  if ((c & 0xF000u) == 0x1000) {
74  bytestream2_put_le16(pb, fill);
75  } else {
76  bytestream2_put_le32(pb, fill);
77  }
78  c = (c >> 8) & 0x0Fu;
79  }
80  while (c) {
81  a <<= 4;
82  cnt--;
83  if (!cnt) {
84  if (bytestream2_get_bytes_left(gb) <= 0) {
85  if (!a)
86  return 0;
87  } else {
88  pos = bytestream2_tell(gb);
89  bytestream2_seek(gb, pos ^ 2, SEEK_SET);
90  AV_WN16(&a, bytestream2_peek_le16(gb));
91  bytestream2_seek(gb, pos + 2, SEEK_SET);
92  }
93  cnt = 4;
94  }
95  c--;
96  }
97  idx = a >> 20;
98  b = lut[2 * idx];
99  if (!b)
100  return AVERROR_INVALIDDATA;
101  continue;
102  }
103  idx = 2;
104  while (idx) {
105  a <<= 4;
106  cnt--;
107  if (cnt) {
108  idx--;
109  continue;
110  }
111  if (bytestream2_get_bytes_left(gb) <= 0) {
112  if (a) {
113  cnt = 4;
114  idx--;
115  continue;
116  }
117  return 0;
118  }
119  pos = bytestream2_tell(gb);
120  bytestream2_seek(gb, pos ^ 2, SEEK_SET);
121  AV_WN16(&a, bytestream2_peek_le16(gb));
122  bytestream2_seek(gb, pos + 2, SEEK_SET);
123  cnt = 4;
124  idx--;
125  }
126  b = PAIR(4, a) >> 16;
127  }
128 
129  return 0;
130 }
131 
132 static void vertical_predict(uint32_t *dst, int offset, const uint32_t *src, int stride, int height)
133 {
134  dst += offset >> 2;
135 
136  for (int i = 0; i < height; i++) {
137  for (int j = 0; j < stride >> 2; j++) {
138  dst[j] = (((src[j] >> 3) + (0x3F3F3F3F & dst[j])) << 3) & 0xFCFCFCFC;
139  }
140 
141  dst += stride >> 2;
142  src += stride >> 2;
143  }
144 }
145 
146 static int decode_frame(AVCodecContext *avctx, void *data,
147  int *got_frame, AVPacket *avpkt)
148 {
149  ProSumerContext *s = avctx->priv_data;
150  AVFrame * const frame = data;
151  int ret;
152 
153  if (avpkt->size <= 32)
154  return AVERROR_INVALIDDATA;
155 
156  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
158  ret = decompress(&s->gb, AV_RL32(avpkt->data + 28) >> 1, &s->pb, s->lut);
159  if (ret < 0)
160  return ret;
161  if (bytestream2_get_bytes_left_p(&s->pb) > s->size * (int64_t)avctx->discard_damaged_percentage / 100)
162  return AVERROR_INVALIDDATA;
163 
166 
167  vertical_predict((uint32_t *)s->decbuffer, 0, (uint32_t *)s->initial_line, s->stride, 1);
168  vertical_predict((uint32_t *)s->decbuffer, s->stride, (uint32_t *)s->decbuffer, s->stride, avctx->height - 1);
169 
170  ret = ff_get_buffer(avctx, frame, 0);
171  if (ret < 0)
172  return ret;
173 
174  for (int i = avctx->height - 1; i >= 0 ; i--) {
175  uint8_t *y = &frame->data[0][i * frame->linesize[0]];
176  uint8_t *u = &frame->data[1][i * frame->linesize[1]];
177  uint8_t *v = &frame->data[2][i * frame->linesize[2]];
178  const uint8_t *src = s->decbuffer + (avctx->height - 1 - i) * s->stride;
179 
180  for (int j = 0; j < avctx->width; j += 8) {
181  *(u++) = *src++;
182  *(y++) = *src++;
183  *(v++) = *src++;
184  *(y++) = *src++;
185 
186  *(u++) = *src++;
187  *(y++) = *src++;
188  *(v++) = *src++;
189  *(y++) = *src++;
190 
191  *(y++) = *src++;
192  *(y++) = *src++;
193  *(y++) = *src++;
194  *(y++) = *src++;
195  }
196  }
197 
198  frame->pict_type = AV_PICTURE_TYPE_I;
199  frame->key_frame = 1;
200  *got_frame = 1;
201 
202  return avpkt->size;
203 }
204 
205 #define TB(i) (1 + ((i) > 10) + ((i) > 49))
206 static const uint16_t table[] = {
207  0x0000, 0x100, 0x0101, 0x200, 0x0202, 0x300, 0xFFFF, 0x400, 0xFEFE, 0x500,
208  0x0001, 0x700, 0x0100, 0x800, 0x00FF, 0x900, 0xFF00, 0xA00, 0x8001, 0x600,
209  0x8002, 0xB00, 0xFCFC, 0x010, 0x0404, 0x030, 0x0002, 0xD30, 0xFEFC, 0x020,
210  0xFCFE, 0x040, 0xFEFF, 0xD20, 0x0808, 0x060, 0xFFFE, 0x050, 0x0402, 0xC00,
211  0x0204, 0xC10, 0xF8F8, 0xC30, 0x0201, 0xC40, 0x0102, 0xC60, 0x0804, 0xF30,
212  0x0408, 0xE00, 0xF8FC, 0xE10, 0xFCF8, 0xC70, 0x00FE, 0xD00, 0xFE00, 0xD40,
213  0xFF01, 0xD50, 0x01FF, 0xD60, 0x0200, 0xD70, 0xFCFF, 0xE20, 0x0104, 0xE30,
214  0xF0F0, 0xE50, 0x0401, 0xE70, 0x02FE, 0xF00, 0xFE02, 0xF10, 0xFE01, 0xF20,
215  0x01FE, 0xF40, 0xFF02, 0xF50, 0x02FF, 0xF60, 0x8003, 0xC20, 0x8004, 0x070,
216  0x8005, 0xD10, 0x8006, 0xC50, 0x8007, 0xE60, 0x8008, 0xE40, 0x8009, 0xF70,
217  0xFC02, 0x080, 0xFE04, 0x081, 0xFC00, 0x082, 0x02FC, 0x083, 0x1010, 0x084,
218  0x00FC, 0x085, 0x0004, 0x086, 0x0400, 0x087, 0xFFFC, 0x088, 0x1008, 0x089,
219  0x0810, 0x08A, 0x0802, 0x08B, 0x0208, 0x08C, 0xFEF8, 0x08D, 0xFC01, 0x08E,
220  0x04FF, 0x08F, 0xF8FE, 0x090, 0xFC04, 0x091, 0x04FC, 0x092, 0xFF04, 0x093,
221  0x01FC, 0x094, 0xF0F8, 0x095, 0xF8F0, 0x096, 0x04FE, 0x097, 0xF0FC, 0x098,
222  0x0008, 0x099, 0x08FE, 0x09A, 0x01F8, 0x09B, 0x0800, 0x09C, 0x08FC, 0x09D,
223  0xFE08, 0x09E, 0xFC08, 0x09F, 0xF800, 0x0A0, 0x0108, 0x0A1, 0xF802, 0x0A2,
224  0x0801, 0x0A3, 0x00F8, 0x0A4, 0xF804, 0x0A5, 0xF8FF, 0x0A6, 0xFFF8, 0x0A7,
225  0x04F8, 0x0A8, 0x02F8, 0x0A9, 0x1004, 0x0AA, 0x08F8, 0x0AB, 0xF808, 0x0AC,
226  0x0410, 0x0AD, 0xFF08, 0x0AE, 0x08FF, 0x0AF, 0xFCF0, 0x0B0, 0xF801, 0x0B1,
227  0xE0F0, 0x0B2, 0xF3F3, 0x0B3, 0xF0E0, 0x0B4, 0xFAFA, 0x0B5, 0xF7F7, 0x0B6,
228  0xFEF0, 0x0B7, 0xF0FE, 0x0B8, 0xE9E9, 0x0B9, 0xF9F9, 0x0BA, 0x2020, 0x0BB,
229  0xE0E0, 0x0BC, 0x02F0, 0x0BD, 0x04F0, 0x0BE, 0x2010, 0x0BF, 0xECEC, 0x0C0,
230  0xEFEF, 0x0C1, 0x1020, 0x0C2, 0xF5F5, 0x0C3, 0xF4F4, 0x0C4, 0xEDED, 0x0C5,
231  0xEAEA, 0x0C6, 0xFBFB, 0x0C7, 0x1002, 0x0C8, 0xF2F2, 0x0C9, 0xF6F6, 0x0CA,
232  0xF1F1, 0x0CB, 0xFDFD, 0x0CC, 0x0210, 0x0CD, 0x10FF, 0x0CE, 0xFDFE, 0x0CF,
233  0x10F8, 0x0D0, 0x1000, 0x0D1, 0xF001, 0x0D2, 0x1001, 0x0D3, 0x0010, 0x0D4,
234  0x10FE, 0x0D5, 0xEBEB, 0x0D6, 0xFE10, 0x0D7, 0x0110, 0x0D8, 0xF000, 0x0D9,
235  0x08F0, 0x0DA, 0x01F0, 0x0DB, 0x0303, 0x0DC, 0x00F0, 0x0DD, 0xF002, 0x0DE,
236  0x10FC, 0x0DF, 0xFC10, 0x0E0, 0xF0FF, 0x0E1, 0xEEEE, 0x0E2, 0xF004, 0x0E3,
237  0xFFF0, 0x0E4, 0xF7F8, 0x0E5, 0xF3F2, 0x0E6, 0xF9FA, 0x0E7, 0x0820, 0x0E8,
238  0x0302, 0x0E9, 0xE0F8, 0x0EA, 0x0505, 0x0EB, 0x2008, 0x0EC, 0xE8E8, 0x0ED,
239  0x0403, 0x0EE, 0xFBFC, 0x0EF, 0xFCFD, 0x0F0, 0xFBFA, 0x0F1, 0x0203, 0x0F2,
240  0xFCFB, 0x0F3, 0x0304, 0x0F4, 0xF810, 0x0F5, 0xFF10, 0x0F6, 0xF008, 0x0F7,
241  0xFEFD, 0x0F8, 0xF7F6, 0x0F9, 0xF2F1, 0x0FA, 0xF3F4, 0x0FB, 0xEDEC, 0x0FC,
242  0xF4F1, 0x0FD, 0xF5F6, 0x0FE, 0xF0F1, 0x0FF, 0xF9F8, 0xC80, 0x10F0, 0xC81,
243  0xF2F3, 0xC82, 0xF7F9, 0xC83, 0xF6F5, 0xC84, 0xF0EF, 0xC85, 0xF4F5, 0xC86,
244  0xF6F7, 0xC87, 0xFAF9, 0xC88, 0x0405, 0xC89, 0xF8F9, 0xC8A, 0xFAFB, 0xC8B,
245  0xF1F0, 0xC8C, 0xF4F3, 0xC8D, 0xF1F2, 0xC8E, 0xF8E0, 0xC8F, 0xF8F7, 0xC90,
246  0xFDFC, 0xC91, 0xF8FA, 0xC92, 0xFAF6, 0xC93, 0xEEEF, 0xC94, 0xF5F7, 0xC95,
247  0xFDFB, 0xC96, 0xF4F6, 0xC97, 0xFCFA, 0xC98, 0xECED, 0xC99, 0xF0F3, 0xC9A,
248  0xF3F1, 0xC9B, 0xECEB, 0xC9C, 0xEDEE, 0xC9D, 0xF9F7, 0xC9E, 0x0420, 0xC9F,
249  0xEBEA, 0xCA0, 0xF0F4, 0xCA1, 0xF3F5, 0xCA2, 0xFAF7, 0xCA3, 0x0301, 0xCA4,
250  0xF3F7, 0xCA5, 0xF7F3, 0xCA6, 0xEFF0, 0xCA7, 0xF9F6, 0xCA8, 0xEFEE, 0xCA9,
251  0xF4F7, 0xCAA, 0x0504, 0xCAB, 0xF5F4, 0xCAC, 0xF1F3, 0xCAD, 0xEBEE, 0xCAE,
252  0xF2F5, 0xCAF, 0xF3EF, 0xCB0, 0xF5F1, 0xCB1, 0xF9F3, 0xCB2, 0xEDF0, 0xCB3,
253  0xEEF1, 0xCB4, 0xF6F9, 0xCB5, 0xF8FB, 0xCB6, 0xF010, 0xCB7, 0xF2F6, 0xCB8,
254  0xF4ED, 0xCB9, 0xF7FB, 0xCBA, 0xF8F3, 0xCBB, 0xEDEB, 0xCBC, 0xF0F2, 0xCBD,
255  0xF2F9, 0xCBE, 0xF8F1, 0xCBF, 0xFAFC, 0xCC0, 0xFBF8, 0xCC1, 0xF6F0, 0xCC2,
256  0xFAF8, 0xCC3, 0x0103, 0xCC4, 0xF3F6, 0xCC5, 0xF4F9, 0xCC6, 0xF7F2, 0xCC7,
257  0x2004, 0xCC8, 0xF2F0, 0xCC9, 0xF4F2, 0xCCA, 0xEEED, 0xCCB, 0xFCE0, 0xCCC,
258  0xEAE9, 0xCCD, 0xEAEB, 0xCCE, 0xF6F4, 0xCCF, 0xFFFD, 0xCD0, 0xE9EA, 0xCD1,
259  0xF1F4, 0xCD2, 0xF6EF, 0xCD3, 0xF6F8, 0xCD4, 0xF8F6, 0xCD5, 0xEFF2, 0xCD6,
260  0xEFF1, 0xCD7, 0xF7F1, 0xCD8, 0xFBFD, 0xCD9, 0xFEF6, 0xCDA, 0xFFF7, 0xCDB,
261  0x0605, 0xCDC, 0xF0F5, 0xCDD, 0xF0FA, 0xCDE, 0xF1F9, 0xCDF, 0xF2FC, 0xCE0,
262  0xF7EE, 0xCE1, 0xF7F5, 0xCE2, 0xF9FC, 0xCE3, 0xFAF5, 0xCE4, 0xFBF1, 0xCE5,
263  0xF1EF, 0xCE6, 0xF1FA, 0xCE7, 0xF4F8, 0xCE8, 0xF7F0, 0xCE9, 0xF7F4, 0xCEA,
264  0xF7FC, 0xCEB, 0xF9FB, 0xCEC, 0xFAF1, 0xCED, 0xFBF9, 0xCEE, 0xFDFF, 0xCEF,
265  0xE0FC, 0xCF0, 0xEBEC, 0xCF1, 0xEDEF, 0xCF2, 0xEFED, 0xCF3, 0xF1F6, 0xCF4,
266  0xF2F7, 0xCF5, 0xF3EE, 0xCF6, 0xF3F8, 0xCF7, 0xF5F2, 0xCF8, 0xF8F2, 0xCF9,
267  0xF9F1, 0xCFA, 0xF9F2, 0xCFB, 0xFBEF, 0xCFC, 0x00FD, 0xCFD, 0xECEE, 0xCFE,
268  0xF2EF, 0xCFF, 0xF2F8, 0xD80, 0xF5F0, 0xD81, 0xF6F2, 0xD82, 0xFCF7, 0xD83,
269  0xFCF9, 0xD84, 0x0506, 0xD85, 0xEEEC, 0xD86, 0xF0F6, 0xD87, 0xF2F4, 0xD88,
270  0xF6F1, 0xD89, 0xF8F5, 0xD8A, 0xF9F4, 0xD8B, 0xFBF7, 0xD8C, 0x0503, 0xD8D,
271  0xEFEC, 0xD8E, 0xF3F0, 0xD8F, 0xF4F0, 0xD90, 0xF5F3, 0xD91, 0xF6F3, 0xD92,
272  0xF7FA, 0xD93, 0x800A, 0xD94, 0x800B, 0xD95, 0x800C, 0xD96, 0x800D, 0xD97,
273  0x800E, 0xD98, 0x800F, 0xD99, 0x8010, 0xD9A, 0x8011, 0xD9B, 0x8012, 0xD9C,
274  0x8013, 0xD9D, 0x8014, 0xD9E, 0x8015, 0xD9F, 0x8016, 0xDA0, 0x8017, 0xDA1,
275  0x8018, 0xDA2, 0x8019, 0xDA3, 0x801A, 0xDA4, 0x801B, 0xDA5, 0x801C, 0xDA6,
276  0x801D, 0xDA7, 0x801E, 0xDA8, 0x801F, 0xDA9, 0x8020, 0xDAA, 0x8021, 0xDAB,
277  0x8022, 0xDAC, 0x8023, 0xDAD, 0x8024, 0xDAE, 0x8025, 0xDAF, 0x8026, 0xDB0,
278  0x8027, 0xDB1, 0x8028, 0xDB2, 0x8029, 0xDB3, 0x802A, 0xDB4, 0x802B, 0xDB5,
279  0x802C, 0xDB6, 0x802D, 0xDB7, 0x802E, 0xDB8, 0x802F, 0xDB9, 0x80FF, 0xDBA,
280 };
281 
282 static void fill_elements(uint32_t idx, uint32_t shift, uint32_t *e0, uint32_t *e1)
283 {
284  uint32_t b, h = idx << (32 - shift);
285 
286  for (int j = 0; j < 2; j++) {
287  for (int i = 0; i < 43; i++) {
288  b = 4 * TB(i);
289  if (shift >= b && ((h & (0xFFF00000u << (12 - b))) >> 20) == table[2 * i + 1]) {
290  if (table[2 * i] >> 8 == 0x80u) {
291  return;
292  } else {
293  *e0 = (*e0 & 0xFFFFFFu) | (((12 + b - shift) | (0x40u<<j)) << 22);
294  if (j == 0) {
295  *e1 = table[2 * i];
296  shift -= b;
297  h <<= b;
298  } else {
299  *e1 |= (unsigned)table[2 * i] << 16;
300  }
301  break;
302  }
303  }
304  }
305  }
306 }
307 
308 static void fill_lut(uint32_t *lut)
309 {
310  for (int i = 1; i < FF_ARRAY_ELEMS(table); i += 2) {
311  uint32_t a = table[i];
312  uint32_t b = TB(i>>1);
313  uint32_t c, d;
314 
315  c = (b << 16) | table[i-1];
316  d = 4 * (3 - b);
317  if (d <= 0) {
318  lut[2 * a] = c;
319  lut[2 * a + 1] = 0;
320  } else {
321  for (int j = 0; j < 1 << d; j++) {
322  uint32_t f = 0xFFFFFFFFu;
323  c &= 0xFFFFFFu;
324  if ((c & 0xFF00u) != 0x8000u)
325  fill_elements(j, d, &c, &f);
326  lut[2 * a + 2 * j] = c;
327  lut[2 * a + 2 * j + 1] = f;
328  }
329  }
330  }
331 
332  for (int i = 0; i < 32; i += 2) {
333  lut[i ] = 0x68000;
334  lut[i+1] = 0;
335  }
336 }
337 
339 {
340  ProSumerContext *s = avctx->priv_data;
341 
342  s->stride = 3LL * FFALIGN(avctx->width, 8) >> 1;
343  s->size = avctx->height * s->stride;
344 
345  avctx->pix_fmt = AV_PIX_FMT_YUV411P;
346 
347  s->initial_line = av_malloc(s->stride);
348  s->decbuffer = av_malloc(s->size);
349  if (!s->initial_line || !s->decbuffer)
350  return AVERROR(ENOMEM);
351  memset(s->initial_line, 0x80u, s->stride);
352 
353  fill_lut(s->lut);
354 
355  return 0;
356 }
357 
359 {
360  ProSumerContext *s = avctx->priv_data;
361 
362  av_freep(&s->initial_line);
363  av_freep(&s->decbuffer);
364 
365  return 0;
366 }
367 
369  .name = "prosumer",
370  .long_name = NULL_IF_CONFIG_SMALL("Brooktree ProSumer Video"),
371  .type = AVMEDIA_TYPE_VIDEO,
372  .id = AV_CODEC_ID_PROSUMER,
373  .priv_data_size = sizeof(ProSumerContext),
374  .init = decode_init,
375  .decode = decode_frame,
376  .close = decode_close,
377  .capabilities = AV_CODEC_CAP_DR1,
378  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
380 };
#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
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
GetByteContext gb
Definition: prosumer.c:36
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
misc image utilities
Memory handling functions.
static void vertical_predict(uint32_t *dst, int offset, const uint32_t *src, int stride, int height)
Definition: prosumer.c:132
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1481
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:143
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3484
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
PutByteContext pb
Definition: prosumer.c:37
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t * decbuffer
Definition: prosumer.c:43
#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
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
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
#define f(width, name)
Definition: cbs_vp9.c:255
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
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
#define height
uint8_t * data
Definition: avcodec.h:1480
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: prosumer.c:146
ptrdiff_t size
Definition: opengl_enc.c:100
#define FFALIGN(x, a)
Definition: macros.h:48
static const uint16_t table[]
Definition: prosumer.c:206
uint32_t lut[0x2000]
Definition: prosumer.c:41
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:159
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static int decompress(GetByteContext *gb, int size, PutByteContext *pb, const uint32_t *lut)
Definition: prosumer.c:48
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3491
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:193
AVCodec ff_prosumer_decoder
Definition: prosumer.c:368
common internal API header
#define b
Definition: input.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int width
picture width / height.
Definition: avcodec.h:1741
static void fill_lut(uint32_t *lut)
Definition: prosumer.c:308
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
static av_cold int decode_init(AVCodecContext *avctx)
Definition: prosumer.c:338
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_ARRAY_ELEMS(a)
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
#define PAIR(high, low)
Definition: prosumer.c:46
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:3375
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
#define TB(i)
Definition: prosumer.c:205
main external API structure.
Definition: avcodec.h:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1963
static av_cold int decode_close(AVCodecContext *avctx)
Definition: prosumer.c:358
static void fill_elements(uint32_t idx, uint32_t shift, uint32_t *e0, uint32_t *e1)
Definition: prosumer.c:282
unsigned stride
Definition: prosumer.c:39
unsigned size
Definition: prosumer.c:40
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
common internal api header.
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
Definition: bytestream.h:328
uint8_t * initial_line
Definition: prosumer.c:42
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
void * priv_data
Definition: avcodec.h:1595
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
#define av_freep(p)
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
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
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
for(j=16;j >0;--j)