proresenc_anatoliy.c
Go to the documentation of this file.
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2011 Anatoliy Wasserman
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Apple ProRes encoder (Anatoliy Wasserman version)
26  * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy)
27  */
28 
29 #include "avcodec.h"
30 #include "dct.h"
31 #include "internal.h"
32 #include "put_bits.h"
33 #include "bytestream.h"
34 #include "dsputil.h"
35 
36 #define DEFAULT_SLICE_MB_WIDTH 8
37 
38 #define FF_PROFILE_PRORES_PROXY 0
39 #define FF_PROFILE_PRORES_LT 1
40 #define FF_PROFILE_PRORES_STANDARD 2
41 #define FF_PROFILE_PRORES_HQ 3
42 
43 static const AVProfile profiles[] = {
44  { FF_PROFILE_PRORES_PROXY, "apco"},
45  { FF_PROFILE_PRORES_LT, "apcs"},
46  { FF_PROFILE_PRORES_STANDARD, "apcn"},
47  { FF_PROFILE_PRORES_HQ, "apch"},
49 };
50 
51 static const int qp_start_table[4] = { 4, 1, 1, 1 };
52 static const int qp_end_table[4] = { 8, 9, 6, 6 };
53 static const int bitrate_table[5] = { 1000, 2100, 3500, 5400 };
54 
55 static const uint8_t progressive_scan[64] = {
56  0, 1, 8, 9, 2, 3, 10, 11,
57  16, 17, 24, 25, 18, 19, 26, 27,
58  4, 5, 12, 20, 13, 6, 7, 14,
59  21, 28, 29, 22, 15, 23, 30, 31,
60  32, 33, 40, 48, 41, 34, 35, 42,
61  49, 56, 57, 50, 43, 36, 37, 44,
62  51, 58, 59, 52, 45, 38, 39, 46,
63  53, 60, 61, 54, 47, 55, 62, 63
64 };
65 
66 static const uint8_t QMAT_LUMA[4][64] = {
67  {
68  4, 7, 9, 11, 13, 14, 15, 63,
69  7, 7, 11, 12, 14, 15, 63, 63,
70  9, 11, 13, 14, 15, 63, 63, 63,
71  11, 11, 13, 14, 63, 63, 63, 63,
72  11, 13, 14, 63, 63, 63, 63, 63,
73  13, 14, 63, 63, 63, 63, 63, 63,
74  13, 63, 63, 63, 63, 63, 63, 63,
75  63, 63, 63, 63, 63, 63, 63, 63
76  }, {
77  4, 5, 6, 7, 9, 11, 13, 15,
78  5, 5, 7, 8, 11, 13, 15, 17,
79  6, 7, 9, 11, 13, 15, 15, 17,
80  7, 7, 9, 11, 13, 15, 17, 19,
81  7, 9, 11, 13, 14, 16, 19, 23,
82  9, 11, 13, 14, 16, 19, 23, 29,
83  9, 11, 13, 15, 17, 21, 28, 35,
84  11, 13, 16, 17, 21, 28, 35, 41
85  }, {
86  4, 4, 5, 5, 6, 7, 7, 9,
87  4, 4, 5, 6, 7, 7, 9, 9,
88  5, 5, 6, 7, 7, 9, 9, 10,
89  5, 5, 6, 7, 7, 9, 9, 10,
90  5, 6, 7, 7, 8, 9, 10, 12,
91  6, 7, 7, 8, 9, 10, 12, 15,
92  6, 7, 7, 9, 10, 11, 14, 17,
93  7, 7, 9, 10, 11, 14, 17, 21
94  }, {
95  4, 4, 4, 4, 4, 4, 4, 4,
96  4, 4, 4, 4, 4, 4, 4, 4,
97  4, 4, 4, 4, 4, 4, 4, 4,
98  4, 4, 4, 4, 4, 4, 4, 5,
99  4, 4, 4, 4, 4, 4, 5, 5,
100  4, 4, 4, 4, 4, 5, 5, 6,
101  4, 4, 4, 4, 5, 5, 6, 7,
102  4, 4, 4, 4, 5, 6, 7, 7
103  }
104 };
105 
106 static const uint8_t QMAT_CHROMA[4][64] = {
107  {
108  4, 7, 9, 11, 13, 14, 63, 63,
109  7, 7, 11, 12, 14, 63, 63, 63,
110  9, 11, 13, 14, 63, 63, 63, 63,
111  11, 11, 13, 14, 63, 63, 63, 63,
112  11, 13, 14, 63, 63, 63, 63, 63,
113  13, 14, 63, 63, 63, 63, 63, 63,
114  13, 63, 63, 63, 63, 63, 63, 63,
115  63, 63, 63, 63, 63, 63, 63, 63
116  }, {
117  4, 5, 6, 7, 9, 11, 13, 15,
118  5, 5, 7, 8, 11, 13, 15, 17,
119  6, 7, 9, 11, 13, 15, 15, 17,
120  7, 7, 9, 11, 13, 15, 17, 19,
121  7, 9, 11, 13, 14, 16, 19, 23,
122  9, 11, 13, 14, 16, 19, 23, 29,
123  9, 11, 13, 15, 17, 21, 28, 35,
124  11, 13, 16, 17, 21, 28, 35, 41
125  }, {
126  4, 4, 5, 5, 6, 7, 7, 9,
127  4, 4, 5, 6, 7, 7, 9, 9,
128  5, 5, 6, 7, 7, 9, 9, 10,
129  5, 5, 6, 7, 7, 9, 9, 10,
130  5, 6, 7, 7, 8, 9, 10, 12,
131  6, 7, 7, 8, 9, 10, 12, 15,
132  6, 7, 7, 9, 10, 11, 14, 17,
133  7, 7, 9, 10, 11, 14, 17, 21
134  }, {
135  4, 4, 4, 4, 4, 4, 4, 4,
136  4, 4, 4, 4, 4, 4, 4, 4,
137  4, 4, 4, 4, 4, 4, 4, 4,
138  4, 4, 4, 4, 4, 4, 4, 5,
139  4, 4, 4, 4, 4, 4, 5, 5,
140  4, 4, 4, 4, 4, 5, 5, 6,
141  4, 4, 4, 4, 5, 5, 6, 7,
142  4, 4, 4, 4, 5, 6, 7, 7
143  }
144 };
145 
146 
147 typedef struct {
151 
152  int qmat_luma[16][64];
153  int qmat_chroma[16][64];
154 } ProresContext;
155 
156 static void encode_codeword(PutBitContext *pb, int val, int codebook)
157 {
158  unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros,
159  mask;
160 
161  /* number of bits to switch between rice and exp golomb */
162  switch_bits = codebook & 3;
163  rice_order = codebook >> 5;
164  exp_order = (codebook >> 2) & 7;
165 
166  first_exp = ((switch_bits + 1) << rice_order);
167 
168  if (val >= first_exp) { /* exp golomb */
169  val -= first_exp;
170  val += (1 << exp_order);
171  exp = av_log2(val);
172  zeros = exp - exp_order + switch_bits + 1;
173  put_bits(pb, zeros, 0);
174  put_bits(pb, exp + 1, val);
175  } else if (rice_order) {
176  mask = (1 << rice_order) - 1;
177  put_bits(pb, (val >> rice_order), 0);
178  put_bits(pb, 1, 1);
179  put_bits(pb, rice_order, val & mask);
180  } else {
181  put_bits(pb, val, 0);
182  put_bits(pb, 1, 1);
183  }
184 }
185 
186 #define QSCALE(qmat,ind,val) ((val) / (qmat[ind]))
187 #define TO_GOLOMB(val) ((val << 1) ^ (val >> 31))
188 #define DIFF_SIGN(val, sign) ((val >> 31) ^ sign)
189 #define IS_NEGATIVE(val) (((val >> 31) ^ -1) + 1)
190 #define TO_GOLOMB2(val,sign) (val==0 ? 0 : (val << 1) + sign)
191 
193 {
194  int sign = (val >> 31);
195  return (val ^ sign) - sign;
196 }
197 
198 #define FIRST_DC_CB 0xB8
199 
200 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
201 
202 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
203  int blocks_per_slice, int *qmat)
204 {
205  int prev_dc, code;
206  int i, sign, idx;
207  int new_dc, delta, diff_sign, new_code;
208 
209  prev_dc = QSCALE(qmat, 0, in[0] - 16384);
210  code = TO_GOLOMB(prev_dc);
211  encode_codeword(pb, code, FIRST_DC_CB);
212 
213  code = 5; sign = 0; idx = 64;
214  for (i = 1; i < blocks_per_slice; i++, idx += 64) {
215  new_dc = QSCALE(qmat, 0, in[idx] - 16384);
216  delta = new_dc - prev_dc;
217  diff_sign = DIFF_SIGN(delta, sign);
218  new_code = TO_GOLOMB2(get_level(delta), diff_sign);
219 
220  encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
221 
222  code = new_code;
223  sign = delta >> 31;
224  prev_dc = new_dc;
225  }
226 }
227 
228 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
229  0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
230 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
231  0x28, 0x28, 0x28, 0x4C };
232 
234  int16_t *in, int blocks_per_slice, int *qmat)
235 {
236  int prev_run = 4;
237  int prev_level = 2;
238 
239  int run = 0, level, code, i, j;
240  for (i = 1; i < 64; i++) {
241  int indp = progressive_scan[i];
242  for (j = 0; j < blocks_per_slice; j++) {
243  int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
244  if (val) {
245  encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
246 
247  prev_run = run;
248  run = 0;
249  level = get_level(val);
250  code = level - 1;
251 
252  encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
253 
254  prev_level = level;
255 
256  put_bits(pb, 1, IS_NEGATIVE(val));
257  } else {
258  ++run;
259  }
260  }
261  }
262 }
263 
264 static void get(uint8_t *pixels, int stride, int16_t* block)
265 {
266  int16_t *p = (int16_t*)pixels;
267  int i, j;
268 
269  stride >>= 1;
270  for (i = 0; i < 8; i++) {
271  for (j = 0; j < 8; j++) {
272  block[j] = p[j];
273  }
274  p += stride;
275  block += 8;
276  }
277 }
278 
279 static void fdct_get(uint8_t *pixels, int stride, int16_t* block)
280 {
281  get(pixels, stride, block);
282  ff_jpeg_fdct_islow_10(block);
283 }
284 
285 static int encode_slice_plane(AVCodecContext *avctx, int mb_count,
286  uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size,
287  int *qmat, int chroma)
288 {
289  DECLARE_ALIGNED(16, int16_t, blocks)[DEFAULT_SLICE_MB_WIDTH << 8], *block;
290  int i, blocks_per_slice;
291  PutBitContext pb;
292 
293  block = blocks;
294  for (i = 0; i < mb_count; i++) {
295  fdct_get(src, src_stride, block + (0 << 6));
296  fdct_get(src + 8 * src_stride, src_stride, block + ((2 - chroma) << 6));
297  if (!chroma) {
298  fdct_get(src + 16, src_stride, block + (1 << 6));
299  fdct_get(src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
300  }
301 
302  block += (256 >> chroma);
303  src += (32 >> chroma);
304  }
305 
306  blocks_per_slice = mb_count << (2 - chroma);
307  init_put_bits(&pb, buf, buf_size << 3);
308 
309  encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
310  encode_ac_coeffs(avctx, &pb, blocks, blocks_per_slice, qmat);
311 
312  flush_put_bits(&pb);
313  return put_bits_ptr(&pb) - pb.buf;
314 }
315 
317  uint8_t *dest_y, uint8_t *dest_u, uint8_t *dest_v, int luma_stride,
318  int chroma_stride, unsigned mb_count, uint8_t *buf, unsigned data_size,
319  unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
320  int qp)
321 {
322  ProresContext* ctx = avctx->priv_data;
323 
324  *y_data_size = encode_slice_plane(avctx, mb_count, dest_y, luma_stride,
325  buf, data_size, ctx->qmat_luma[qp - 1], 0);
326 
327  if (!(avctx->flags & CODEC_FLAG_GRAY)) {
328  *u_data_size = encode_slice_plane(avctx, mb_count, dest_u,
329  chroma_stride, buf + *y_data_size, data_size - *y_data_size,
330  ctx->qmat_chroma[qp - 1], 1);
331 
332  *v_data_size = encode_slice_plane(avctx, mb_count, dest_v,
333  chroma_stride, buf + *y_data_size + *u_data_size,
334  data_size - *y_data_size - *u_data_size,
335  ctx->qmat_chroma[qp - 1], 1);
336  }
337 
338  return *y_data_size + *u_data_size + *v_data_size;
339 }
340 
341 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
342  unsigned stride, unsigned width, unsigned height, uint16_t *dst,
343  unsigned dst_width, unsigned dst_height)
344 {
345 
346  int box_width = FFMIN(width - x, dst_width);
347  int box_height = FFMIN(height - y, dst_height);
348  int i, j, src_stride = stride >> 1;
349  uint16_t last_pix, *last_line;
350 
351  src += y * src_stride + x;
352  for (i = 0; i < box_height; ++i) {
353  for (j = 0; j < box_width; ++j) {
354  dst[j] = src[j];
355  }
356  last_pix = dst[j - 1];
357  for (; j < dst_width; j++)
358  dst[j] = last_pix;
359  src += src_stride;
360  dst += dst_width;
361  }
362  last_line = dst - dst_width;
363  for (; i < dst_height; i++) {
364  for (j = 0; j < dst_width; ++j) {
365  dst[j] = last_line[j];
366  }
367  dst += dst_width;
368  }
369 }
370 
371 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
372  int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
373  int unsafe, int *qp)
374 {
375  int luma_stride, chroma_stride;
376  int hdr_size = 6, slice_size;
377  uint8_t *dest_y, *dest_u, *dest_v;
378  unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0;
379  ProresContext* ctx = avctx->priv_data;
380  int tgt_bits = (mb_count * bitrate_table[avctx->profile]) >> 2;
381  int low_bytes = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
382  int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
383 
384  luma_stride = pic->linesize[0];
385  chroma_stride = pic->linesize[1];
386 
387  dest_y = pic->data[0] + (mb_y << 4) * luma_stride + (mb_x << 5);
388  dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << 4);
389  dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << 4);
390 
391  if (unsafe) {
392 
393  subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
394  luma_stride, avctx->width, avctx->height,
395  (uint16_t *) ctx->fill_y, mb_count << 4, 16);
396  subimage_with_fill((uint16_t *) pic->data[1], mb_x << 3, mb_y << 4,
397  chroma_stride, avctx->width >> 1, avctx->height,
398  (uint16_t *) ctx->fill_u, mb_count << 3, 16);
399  subimage_with_fill((uint16_t *) pic->data[2], mb_x << 3, mb_y << 4,
400  chroma_stride, avctx->width >> 1, avctx->height,
401  (uint16_t *) ctx->fill_v, mb_count << 3, 16);
402 
403  encode_slice_data(avctx, ctx->fill_y, ctx->fill_u, ctx->fill_v,
404  mb_count << 5, mb_count << 4, mb_count, buf + hdr_size,
405  data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
406  *qp);
407  } else {
408  slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
409  luma_stride, chroma_stride, mb_count, buf + hdr_size,
410  data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
411  *qp);
412 
413  if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
414  do {
415  *qp += 1;
416  slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
417  luma_stride, chroma_stride, mb_count, buf + hdr_size,
418  data_size - hdr_size, &y_data_size, &u_data_size,
419  &v_data_size, *qp);
420  } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
421  } else if (slice_size < low_bytes && *qp
422  > qp_start_table[avctx->profile]) {
423  do {
424  *qp -= 1;
425  slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
426  luma_stride, chroma_stride, mb_count, buf + hdr_size,
427  data_size - hdr_size, &y_data_size, &u_data_size,
428  &v_data_size, *qp);
429  } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
430  }
431  }
432 
433  buf[0] = hdr_size << 3;
434  buf[1] = *qp;
435  AV_WB16(buf + 2, y_data_size);
436  AV_WB16(buf + 4, u_data_size);
437 
438  return hdr_size + y_data_size + u_data_size + v_data_size;
439 }
440 
441 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
442  uint8_t *buf, const int buf_size)
443 {
444  int mb_width = (avctx->width + 15) >> 4;
445  int mb_height = (avctx->height + 15) >> 4;
446  int hdr_size, sl_size, i;
447  int mb_y, sl_data_size, qp;
448  int unsafe_bot, unsafe_right;
449  uint8_t *sl_data, *sl_data_sizes;
450  int slice_per_line = 0, rem = mb_width;
451 
452  for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
453  slice_per_line += rem >> i;
454  rem &= (1 << i) - 1;
455  }
456 
457  qp = qp_start_table[avctx->profile];
458  hdr_size = 8; sl_data_size = buf_size - hdr_size;
459  sl_data_sizes = buf + hdr_size;
460  sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
461  for (mb_y = 0; mb_y < mb_height; mb_y++) {
462  int mb_x = 0;
463  int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
464  while (mb_x < mb_width) {
465  while (mb_width - mb_x < slice_mb_count)
466  slice_mb_count >>= 1;
467 
468  unsafe_bot = (avctx->height & 0xf) && (mb_y == mb_height - 1);
469  unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
470 
471  sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
472  sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp);
473 
474  bytestream_put_be16(&sl_data_sizes, sl_size);
475  sl_data += sl_size;
476  sl_data_size -= sl_size;
477  mb_x += slice_mb_count;
478  }
479  }
480 
481  buf[0] = hdr_size << 3;
482  AV_WB32(buf + 1, sl_data - buf);
483  AV_WB16(buf + 5, slice_per_line * mb_height);
484  buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4;
485 
486  return sl_data - buf;
487 }
488 
490  const AVFrame *pict, int *got_packet)
491 {
492  int header_size = 148;
493  uint8_t *buf;
494  int pic_size, ret;
495  int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + FF_MIN_BUFFER_SIZE; //FIXME choose tighter limit
496 
497 
498  if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + FF_MIN_BUFFER_SIZE)) < 0)
499  return ret;
500 
501  buf = pkt->data;
502  pic_size = prores_encode_picture(avctx, pict, buf + header_size + 8,
503  pkt->size - header_size - 8);
504 
505  bytestream_put_be32(&buf, pic_size + 8 + header_size);
506  bytestream_put_buffer(&buf, "icpf", 4);
507 
508  bytestream_put_be16(&buf, header_size);
509  bytestream_put_be16(&buf, 0);
510  bytestream_put_buffer(&buf, "fmpg", 4);
511  bytestream_put_be16(&buf, avctx->width);
512  bytestream_put_be16(&buf, avctx->height);
513  *buf++ = 0x83; // {10}(422){00}{00}(frame){11}
514  *buf++ = 0;
515  *buf++ = 2;
516  *buf++ = 2;
517  *buf++ = 6;
518  *buf++ = 32;
519  *buf++ = 0;
520  *buf++ = 3;
521 
522  bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile], 64);
523  bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
524 
525  pkt->flags |= AV_PKT_FLAG_KEY;
526  pkt->size = pic_size + 8 + header_size;
527  *got_packet = 1;
528 
529  return 0;
530 }
531 
532 static void scale_mat(const uint8_t* src, int* dst, int scale)
533 {
534  int i;
535  for (i = 0; i < 64; i++)
536  dst[i] = src[i] * scale;
537 }
538 
540 {
541  int i;
542  ProresContext* ctx = avctx->priv_data;
543 
544  if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
545  av_log(avctx, AV_LOG_ERROR, "need YUV422P10\n");
546  return -1;
547  }
548  if (avctx->width & 0x1) {
549  av_log(avctx, AV_LOG_ERROR,
550  "frame width needs to be multiple of 2\n");
551  return -1;
552  }
553 
554  if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
555  ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
556  if (!ctx->fill_y)
557  return AVERROR(ENOMEM);
558  ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
559  ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
560  }
561 
562  if (avctx->profile == FF_PROFILE_UNKNOWN) {
564  av_log(avctx, AV_LOG_INFO,
565  "encoding with ProRes standard (apcn) profile\n");
566 
567  } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
568  || avctx->profile > FF_PROFILE_PRORES_HQ) {
569  av_log(
570  avctx,
571  AV_LOG_ERROR,
572  "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
573  avctx->profile);
574  return -1;
575  }
576 
577  avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
578 
579  for (i = 1; i <= 16; i++) {
580  scale_mat(QMAT_LUMA[avctx->profile] , ctx->qmat_luma[i - 1] , i);
581  scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
582  }
583 
584  avctx->coded_frame = avcodec_alloc_frame();
585  avctx->coded_frame->key_frame = 1;
587 
588  return 0;
589 }
590 
592 {
593  ProresContext* ctx = avctx->priv_data;
594  av_freep(&avctx->coded_frame);
595  av_freep(&ctx->fill_y);
596 
597  return 0;
598 }
599 
601  .name = "prores_aw",
602  .type = AVMEDIA_TYPE_VIDEO,
603  .id = AV_CODEC_ID_PRORES,
604  .priv_data_size = sizeof(ProresContext),
607  .encode2 = prores_encode_frame,
608  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
609  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
611  .profiles = profiles
612 };
613 
615  .name = "prores",
616  .type = AVMEDIA_TYPE_VIDEO,
617  .id = AV_CODEC_ID_PRORES,
618  .priv_data_size = sizeof(ProresContext),
621  .encode2 = prores_encode_frame,
622  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
623  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
625  .profiles = profiles
626 };
void ff_jpeg_fdct_islow_10(int16_t *data)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
static const uint8_t QMAT_LUMA[4][64]
static const int bitrate_table[5]
#define TO_GOLOMB2(val, sign)
AVFrame * coded_frame
the picture in the bitstream
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx, uint8_t *dest_y, uint8_t *dest_u, uint8_t *dest_v, int luma_stride, int chroma_stride, unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned *y_data_size, unsigned *u_data_size, unsigned *v_data_size, int qp)
uint8_t qmat_chroma[64]
dequantization matrix for chroma
Definition: proresdec.h:43
static av_cold int prores_encode_init(AVCodecContext *avctx)
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:59
About Git write you should know how to use GIT properly Luckily Git comes with excellent documentation git help man git shows you the available git< command > help man git< command > shows information about the subcommand< command > The most comprehensive manual is the website Git Reference visit they are quite exhaustive You do not need a special username or password All you need is to provide a ssh public key to the Git server admin What follows now is a basic introduction to Git and some FFmpeg specific guidelines Read it at least if you are granted commit privileges to the FFmpeg project you are expected to be familiar with these rules I if not You can get git from etc no matter how small Every one of them has been saved from looking like a fool by this many times It s very easy for stray debug output or cosmetic modifications to slip in
Definition: git-howto.txt:5
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
N, 1 zeros()
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x, int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size, int unsafe, int *qp)
#define FF_PROFILE_PRORES_PROXY
x1
Definition: genspecsines3.m:7
uint8_t run
Definition: svq3.c:136
#define FIRST_DC_CB
int stride
Definition: mace.c:144
#define FFALIGN(x, a)
Definition: common.h:63
static int encode_slice_plane(AVCodecContext *avctx, int mb_count, uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size, int *qmat, int chroma)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
#define AV_WB32(p, darg)
Definition: intreadwrite.h:265
static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic, uint8_t *buf, const int buf_size)
uint8_t
#define av_cold
Definition: attributes.h:78
float delta
#define CODEC_CAP_INTRA_ONLY
Codec is intra only.
static void encode_dc_coeffs(PutBitContext *pb, int16_t *in, int blocks_per_slice, int *qmat)
static AVPacket pkt
Definition: demuxing.c:56
static const uint8_t QMAT_CHROMA[4][64]
static const uint8_t progressive_scan[64]
#define FF_PROFILE_UNKNOWN
uint8_t * data
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static const uint8_t frame_size[4]
Definition: g723_1_data.h:58
Discrete Time axis x
static const uint8_t lev_to_cb[10]
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:199
static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static const uint16_t mask[17]
Definition: lzw.c:37
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_cold int prores_encode_close(AVCodecContext *avctx)
int flags
CODEC_FLAG_*.
uint8_t * buf
Definition: put_bits.h:44
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
const char * name
Name of the codec implementation.
#define IS_NEGATIVE(val)
static void put_bits(J2kEncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
external API header
int flags
A combination of AV_PKT_FLAG values.
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
static av_always_inline int get_level(int val)
#define TO_GOLOMB(val)
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
#define FFMIN(a, b)
Definition: common.h:58
static void scale_mat(const uint8_t *src, int *dst, int scale)
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
static const AVProfile profiles[]
ret
Definition: avfilter.c:821
int width
picture width / height.
#define FF_PROFILE_PRORES_STANDARD
#define DEFAULT_SLICE_MB_WIDTH
#define AV_RL32
FIXME Range Coding of cr are level
Definition: snow.txt:367
AVCodec ff_prores_encoder
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
1i.*Xphase exp()
or the Software in violation of any applicable export control laws in any jurisdiction Except as provided by mandatorily applicable UPF has no obligation to provide you with source code to the Software In the event Software contains any source code
static int width
Definition: tests/utils.c:158
AVS_Value src
Definition: avisynth_c.h:523
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
main external API structure.
static const uint8_t dc_codebook[7]
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
void * buf
Definition: avisynth_c.h:594
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
synthesis window for stochastic i
#define AV_WB16(p, darg)
Definition: intreadwrite.h:237
const char * name
short name for the profile
#define QSCALE(qmat, ind, val)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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.Buffer references ownership and permissions
static void encode_codeword(PutBitContext *pb, int val, int codebook)
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:280
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y, unsigned stride, unsigned width, unsigned height, uint16_t *dst, unsigned dst_width, unsigned dst_height)
AVCodec ff_prores_aw_encoder
static const int qp_start_table[4]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:81
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
AVProfile.
Same thing on a dB scale
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:54
function y
Definition: D.m:1
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:337
DSP utils.
#define av_log2
Definition: intmath.h:89
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
#define AV_LOG_INFO
Definition: log.h:156
#define av_always_inline
Definition: attributes.h:41
struct ProresContext ProresContext
uint8_t qmat_luma[64]
dequantization matrix for luma
Definition: proresdec.h:42
#define FF_PROFILE_PRORES_HQ
#define DIFF_SIGN(val, sign)
static const uint8_t run_to_cb[16]
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
#define FF_PROFILE_PRORES_LT
This structure stores compressed data.
static void encode_ac_coeffs(AVCodecContext *avctx, PutBitContext *pb, int16_t *in, int blocks_per_slice, int *qmat)
static const int qp_end_table[4]
static void fdct_get(uint8_t *pixels, int stride, int16_t *block)
bitstream writer API