4 * Copyright (c) 2011 Anatoliy Wasserman
6 * This file is part of FFmpeg.
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.
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.
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
25 * Apple ProRes encoder (Anatoliy Wasserman version)
26 * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy)
33 #include "bytestream.h"
36 #define DEFAULT_SLICE_MB_WIDTH 8
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
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
}
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 };
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
66 static const uint8_t QMAT_LUMA
[4][64] = {
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
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
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
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
106 static const uint8_t QMAT_CHROMA
[4][64] = {
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
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
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
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
153 int qmat_luma
[16][64];
154 int qmat_chroma
[16][64];
157 static void encode_codeword(PutBitContext
*pb
, int val
, int codebook
)
159 unsigned int rice_order
, exp_order
, switch_bits
, first_exp
, exp
, zeros
,
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;
167 first_exp
= ((switch_bits
+ 1) << rice_order
);
169 if (val
>= first_exp
) { /* exp golomb */
171 val
+= (1 << exp_order
);
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);
180 put_bits(pb
, rice_order
, val
& mask
);
182 put_bits(pb
, val
, 0);
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))
193 static av_always_inline
int get_level(int val
)
195 int sign
= (val
>> 31);
196 return (val
^ sign
) - sign
;
199 #define FIRST_DC_CB 0xB8
201 static const uint8_t dc_codebook
[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
203 static void encode_dc_coeffs(PutBitContext
*pb
, int16_t *in
,
204 int blocks_per_slice
, int *qmat
)
208 int new_dc
, delta
, diff_sign
, new_code
;
210 prev_dc
= QSCALE(qmat
, 0, in
[0] - 16384);
211 code
= TO_GOLOMB(prev_dc
);
212 encode_codeword(pb
, code
, FIRST_DC_CB
);
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
);
221 encode_codeword(pb
, new_code
, dc_codebook
[FFMIN(code
, 6)]);
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 };
234 static void encode_ac_coeffs(AVCodecContext
*avctx
, PutBitContext
*pb
,
235 int16_t *in
, int blocks_per_slice
, int *qmat
)
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
]);
246 encode_codeword(pb
, run
, run_to_cb
[FFMIN(prev_run
, 15)]);
250 level
= get_level(val
);
253 encode_codeword(pb
, code
, lev_to_cb
[FFMIN(prev_level
, 9)]);
257 put_bits(pb
, 1, IS_NEGATIVE(val
));
265 static void get(uint8_t *pixels
, int stride
, int16_t* block
)
269 for (i
= 0; i
< 8; i
++) {
270 AV_WN64(block
, AV_RN64(pixels
));
271 AV_WN64(block
+4, AV_RN64(pixels
+8));
277 static void fdct_get(FDCTDSPContext
*fdsp
, uint8_t *pixels
, int stride
, int16_t* block
)
279 get(pixels
, stride
, block
);
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
)
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
;
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));
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));
302 block
+= (256 >> chroma
);
303 src
+= (32 >> chroma
);
306 blocks_per_slice
= mb_count
<< (2 - chroma
);
307 init_put_bits(&pb
, buf
, buf_size
<< 3);
309 encode_dc_coeffs(&pb
, blocks
, blocks_per_slice
, qmat
);
310 encode_ac_coeffs(avctx
, &pb
, blocks
, blocks_per_slice
, qmat
);
313 return put_bits_ptr(&pb
) - pb
.buf
;
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
,
322 ProresContext
* ctx
= avctx
->priv_data
;
324 *y_data_size
= encode_slice_plane(avctx
, mb_count
, dest_y
, luma_stride
,
325 buf
, data_size
, ctx
->qmat_luma
[qp
- 1], 0);
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);
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);
338 return *y_data_size
+ *u_data_size
+ *v_data_size
;
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
)
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
;
351 src
+= y
* src_stride
+ x
;
352 for (i
= 0; i
< box_height
; ++i
) {
353 for (j
= 0; j
< box_width
; ++j
) {
356 last_pix
= dst
[j
- 1];
357 for (; j
< dst_width
; j
++)
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
];
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
,
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;
384 luma_stride
= pic
->linesize
[0];
385 chroma_stride
= pic
->linesize
[1];
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);
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);
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
,
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
,
413 if (slice_size
> high_bytes
&& *qp
< qp_end_table
[avctx
->profile
]) {
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
,
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
]) {
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
,
429 } while (slice_size
< low_bytes
&& *qp
> qp_start_table
[avctx
->profile
]);
433 buf
[0] = hdr_size
<< 3;
435 AV_WB16(buf
+ 2, y_data_size
);
436 AV_WB16(buf
+ 4, u_data_size
);
438 return hdr_size
+ y_data_size
+ u_data_size
+ v_data_size
;
441 static int prores_encode_picture(AVCodecContext
*avctx
, const AVFrame
*pic
,
442 uint8_t *buf
, const int buf_size
)
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
;
452 for (i
= av_log2(DEFAULT_SLICE_MB_WIDTH
); i
>= 0; --i
) {
453 slice_per_line
+= rem
>> i
;
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
++) {
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;
468 unsafe_bot
= (avctx
->height
& 0xf) && (mb_y
== mb_height
- 1);
469 unsafe_right
= (avctx
->width
& 0xf) && (mb_x
+ slice_mb_count
== mb_width
);
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
);
474 bytestream_put_be16(&sl_data_sizes
, sl_size
);
476 sl_data_size
-= sl_size
;
477 mb_x
+= slice_mb_count
;
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;
486 return sl_data
- buf
;
489 static int prores_encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
490 const AVFrame
*pict
, int *got_packet
)
492 int header_size
= 148;
495 int frame_size
= FFALIGN(avctx
->width
, 16) * FFALIGN(avctx
->height
, 16)*16 + 500 + FF_MIN_BUFFER_SIZE
; //FIXME choose tighter limit
498 if ((ret
= ff_alloc_packet2(avctx
, pkt
, frame_size
+ FF_MIN_BUFFER_SIZE
)) < 0)
502 pic_size
= prores_encode_picture(avctx
, pict
, buf
+ header_size
+ 8,
503 pkt
->size
- header_size
- 8);
505 bytestream_put_be32(&buf
, pic_size
+ 8 + header_size
);
506 bytestream_put_buffer(&buf
, "icpf", 4);
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}
522 bytestream_put_buffer(&buf
, QMAT_LUMA
[avctx
->profile
], 64);
523 bytestream_put_buffer(&buf
, QMAT_CHROMA
[avctx
->profile
], 64);
525 pkt
->flags
|= AV_PKT_FLAG_KEY
;
526 pkt
->size
= pic_size
+ 8 + header_size
;
532 static void scale_mat(const uint8_t* src
, int* dst
, int scale
)
535 for (i
= 0; i
< 64; i
++)
536 dst
[i
] = src
[i
] * scale
;
539 static av_cold
int prores_encode_init(AVCodecContext
*avctx
)
542 ProresContext
* ctx
= avctx
->priv_data
;
544 if (avctx
->pix_fmt
!= AV_PIX_FMT_YUV422P10
) {
545 av_log(avctx
, AV_LOG_ERROR
, "need YUV422P10\n");
548 avctx
->bits_per_raw_sample
= 10;
550 if (avctx
->width
& 0x1) {
551 av_log(avctx
, AV_LOG_ERROR
,
552 "frame width needs to be multiple of 2\n");
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
);
562 if ((avctx
->height
& 0xf) || (avctx
->width
& 0xf)) {
563 ctx
->fill_y
= av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH
<< 8));
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);
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");
575 } else if (avctx
->profile
< FF_PROFILE_PRORES_PROXY
576 || avctx
->profile
> FF_PROFILE_PRORES_HQ
) {
580 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
585 ff_fdctdsp_init(&ctx
->fdsp
, avctx
);
587 avctx
->codec_tag
= AV_RL32((const uint8_t*)profiles
[avctx
->profile
].name
);
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
);
594 avctx
->coded_frame
= av_frame_alloc();
595 avctx
->coded_frame
->key_frame
= 1;
596 avctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
601 static av_cold
int prores_encode_close(AVCodecContext
*avctx
)
603 ProresContext
* ctx
= avctx
->priv_data
;
604 av_freep(&avctx
->coded_frame
);
605 av_freep(&ctx
->fill_y
);
610 AVCodec ff_prores_aw_encoder
= {
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
,
624 AVCodec ff_prores_encoder
= {
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
,