FFmpeg: libavcodec/proresenc_anatoliy.c Source File

FFmpeg
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 "fdctdsp.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"},
48  { FF_PROFILE_UNKNOWN }
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 {
148   FDCTDSPContext fdsp;
149   uint8_t* fill_y;
150   uint8_t* fill_u;
151   uint8_t* fill_v;
152 
153   int qmat_luma[16][64];
154   int qmat_chroma[16][64];
155 } ProresContext;
156 
157  static void encode_codeword(PutBitContext *pb, int val, int codebook)
158 {
159  unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros,
160  mask;
161 
162  /* number of bits to switch between rice and exp golomb */
163  switch_bits = codebook & 3;
164  rice_order = codebook >> 5;
165  exp_order = (codebook >> 2) & 7;
166 
167  first_exp = ((switch_bits + 1) << rice_order);
168 
169  if (val >= first_exp) { /* exp golomb */
170  val -= first_exp;
171  val += (1 << exp_order);
172  exp = av_log2(val);
173  zeros = exp - exp_order + switch_bits + 1;
174  put_bits(pb, zeros, 0);
175  put_bits(pb, exp + 1, val);
176  } else if (rice_order) {
177  mask = (1 << rice_order) - 1;
178  put_bits(pb, (val >> rice_order), 0);
179  put_bits(pb, 1, 1);
180  put_bits(pb, rice_order, val & mask);
181  } else {
182  put_bits(pb, val, 0);
183  put_bits(pb, 1, 1);
184  }
185 }
186 
187  #define QSCALE(qmat,ind,val) ((val) / ((qmat)[ind]))
188  #define TO_GOLOMB(val) (((val) << 1) ^ ((val) >> 31))
189  #define DIFF_SIGN(val, sign) (((val) >> 31) ^ (sign))
190  #define IS_NEGATIVE(val) ((((val) >> 31) ^ -1) + 1)
191  #define TO_GOLOMB2(val,sign) ((val)==0 ? 0 : ((val) << 1) + (sign))
192 
193  static av_always_inline int get_level(int val)
194 {
195  int sign = (val >> 31);
196  return (val ^ sign) - sign;
197 }
198 
199  #define FIRST_DC_CB 0xB8
200 
201  static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
202 
203  static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
204  int blocks_per_slice, int *qmat)
205 {
206  int prev_dc, code;
207  int i, sign, idx;
208  int new_dc, delta, diff_sign, new_code;
209 
210  prev_dc = QSCALE(qmat, 0, in[0] - 16384);
211  code = TO_GOLOMB(prev_dc);
212  encode_codeword(pb, code, FIRST_DC_CB);
213 
214  code = 5; sign = 0; idx = 64;
215  for (i = 1; i < blocks_per_slice; i++, idx += 64) {
216  new_dc = QSCALE(qmat, 0, in[idx] - 16384);
217  delta = new_dc - prev_dc;
218  diff_sign = DIFF_SIGN(delta, sign);
219  new_code = TO_GOLOMB2(get_level(delta), diff_sign);
220 
221  encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
222 
223  code = new_code;
224  sign = delta >> 31;
225  prev_dc = new_dc;
226  }
227 }
228 
229  static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
230  0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
231  static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
232  0x28, 0x28, 0x28, 0x4C };
233 
234  static void encode_ac_coeffs(AVCodecContext *avctx, PutBitContext *pb,
235  int16_t *in, int blocks_per_slice, int *qmat)
236 {
237  int prev_run = 4;
238  int prev_level = 2;
239 
240  int run = 0, level, code, i, j;
241  for (i = 1; i < 64; i++) {
242  int indp = progressive_scan[i];
243  for (j = 0; j < blocks_per_slice; j++) {
244  int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
245  if (val) {
246  encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
247 
248  prev_run = run;
249  run = 0;
250  level = get_level(val);
251  code = level - 1;
252 
253  encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
254 
255  prev_level = level;
256 
257  put_bits(pb, 1, IS_NEGATIVE(val));
258  } else {
259  ++run;
260  }
261  }
262  }
263 }
264 
265  static void get(uint8_t *pixels, int stride, int16_t* block)
266 {
267  int i;
268 
269  for (i = 0; i < 8; i++) {
270  AV_WN64(block, AV_RN64(pixels));
271  AV_WN64(block+4, AV_RN64(pixels+8));
272  pixels += stride;
273  block += 8;
274  }
275 }
276 
277  static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t* block)
278 {
279  get(pixels, stride, block);
280  fdsp->fdct(block);
281 }
282 
283  static int encode_slice_plane(AVCodecContext *avctx, int mb_count,
284  uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size,
285  int *qmat, int chroma)
286 {
287  ProresContext* ctx = avctx->priv_data;
288  FDCTDSPContext *fdsp = &ctx->fdsp;
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(fdsp, src, src_stride, block + (0 << 6));
296  fdct_get(fdsp, src + 8 * src_stride, src_stride, block + ((2 - chroma) << 6));
297  if (!chroma) {
298  fdct_get(fdsp, src + 16, src_stride, block + (1 << 6));
299  fdct_get(fdsp, 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);
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 
316  static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx,
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 
489  static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
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 
539  static av_cold int prores_encode_init(AVCodecContext *avctx)
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  avctx->bits_per_raw_sample = 10;
549 
550  if (avctx->width & 0x1) {
551  av_log(avctx, AV_LOG_ERROR,
552  "frame width needs to be multiple of 2\n");
553  return -1;
554  }
555 
556  if (avctx->width > 65534 || avctx->height > 65535) {
557  av_log(avctx, AV_LOG_ERROR,
558  "The maximum dimensions are 65534x65535\n");
559  return AVERROR(EINVAL);
560  }
561 
562  if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
563  ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
564  if (!ctx->fill_y)
565  return AVERROR(ENOMEM);
566  ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
567  ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
568  }
569 
570  if (avctx->profile == FF_PROFILE_UNKNOWN) {
571  avctx->profile = FF_PROFILE_PRORES_STANDARD;
572  av_log(avctx, AV_LOG_INFO,
573  "encoding with ProRes standard (apcn) profile\n");
574 
575  } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
576  || avctx->profile > FF_PROFILE_PRORES_HQ) {
577  av_log(
578  avctx,
579  AV_LOG_ERROR,
580  "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
581  avctx->profile);
582  return -1;
583  }
584 
585  ff_fdctdsp_init(&ctx->fdsp, avctx);
586 
587  avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
588 
589  for (i = 1; i <= 16; i++) {
590  scale_mat(QMAT_LUMA[avctx->profile] , ctx->qmat_luma[i - 1] , i);
591  scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
592  }
593 
594  avctx->coded_frame = av_frame_alloc();
595  avctx->coded_frame->key_frame = 1;
596  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
597 
598  return 0;
599 }
600 
601  static av_cold int prores_encode_close(AVCodecContext *avctx)
602 {
603  ProresContext* ctx = avctx->priv_data;
604  av_frame_free(&avctx->coded_frame);
605  av_freep(&ctx->fill_y);
606 
607  return 0;
608 }
609 
610  AVCodec ff_prores_aw_encoder = {
611  .name = "prores_aw",
612  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
613  .type = AVMEDIA_TYPE_VIDEO,
614  .id = AV_CODEC_ID_PRORES,
615  .priv_data_size = sizeof(ProresContext),
616  .init = prores_encode_init,
617  .close = prores_encode_close,
618  .encode2 = prores_encode_frame,
619  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
620  .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
621  .profiles = profiles
622 };
623 
624  AVCodec ff_prores_encoder = {
625  .name = "prores",
626  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
627  .type = AVMEDIA_TYPE_VIDEO,
628  .id = AV_CODEC_ID_PRORES,
629  .priv_data_size = sizeof(ProresContext),
630  .init = prores_encode_init,
631  .close = prores_encode_close,
632  .encode2 = prores_encode_frame,
633  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
634  .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
635  .profiles = profiles
636 };
Generated on Sun Mar 8 2015 02:34:58 for FFmpeg by   doxygen 1.8.2

AltStyle によって変換されたページ (->オリジナル) /