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);
157  bytestream2_init_writer(&s->pb, s->decbuffer, s->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 
164  av_assert0(s->size >= bytestream2_get_bytes_left_p(&s->pb));
165  memset(s->decbuffer + bytestream2_tell_p(&s->pb), 0, bytestream2_get_bytes_left_p(&s->pb));
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 };
ProSumerContext::gb
GetByteContext gb
Definition: prosumer.c:36
ProSumerContext::lut
uint32_t lut[0x2000]
Definition: prosumer.c:41
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#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:41
bytestream2_get_eof
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
Definition: bytestream.h:332
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
GetByteContext
Definition: bytestream.h:33
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
ProSumerContext::size
unsigned size
Definition: prosumer.c:40
fill_elements
static void fill_elements(uint32_t idx, uint32_t shift, uint32_t *e0, uint32_t *e1)
Definition: prosumer.c:282
fill_lut
static void fill_lut(uint32_t *lut)
Definition: prosumer.c:308
ProSumerContext::initial_line
uint8_t * initial_line
Definition: prosumer.c:42
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
b
#define b
Definition: input.c:41
table
static const uint16_t table[]
Definition: prosumer.c:206
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
data
const char data[16]
Definition: mxf.c:142
PAIR
#define PAIR(high, low)
Definition: prosumer.c:46
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
decompress
static int decompress(GetByteContext *gb, int size, PutByteContext *pb, const uint32_t *lut)
Definition: prosumer.c:48
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
ProSumerContext
Definition: prosumer.c:35
bytestream2_get_bytes_left_p
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:163
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
ProSumerContext::decbuffer
uint8_t * decbuffer
Definition: prosumer.c:43
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
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_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
PutByteContext
Definition: bytestream.h:37
vertical_predict
static void vertical_predict(uint32_t *dst, int offset, const uint32_t *src, int stride, int height)
Definition: prosumer.c:132
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
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:370
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: prosumer.c:358
size
int size
Definition: twinvq_data.h:10344
height
#define height
a
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:41
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
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: prosumer.c:338
TB
#define TB(i)
Definition: prosumer.c:205
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: prosumer.c:146
i
int i
Definition: input.c:407
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: internal.h:49
internal.h
ProSumerContext::stride
unsigned stride
Definition: prosumer.c:39
ff_prosumer_decoder
AVCodec ff_prosumer_decoder
Definition: prosumer.c:368
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
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
Definition: filter_design.txt:264
pos
unsigned int pos
Definition: spdifenc.c:412
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AV_CODEC_ID_PROSUMER
@ AV_CODEC_ID_PROSUMER
Definition: codec_id.h:287
AVCodecContext
main external API structure.
Definition: avcodec.h:536
ProSumerContext::pb
PutByteContext pb
Definition: prosumer.c:37
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:2328
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
d
d
Definition: ffmpeg_filter.c:158
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372