2 * Dirac encoder support via Schroedinger libraries
3 * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
5 * This file is part of FFmpeg.
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.
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.
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
24 * Dirac encoder support via libschroedinger-1.0 libraries. More details about
25 * the Schroedinger project can be found at http://www.diracvideo.org/.
26 * The library implements Dirac Specification Version 2.2
27 * (http://dirac.sourceforge.net/specification.html).
30 #include <schroedinger/schro.h>
31 #include <schroedinger/schrodebug.h>
32 #include <schroedinger/schrovideoformat.h>
34 #include "libavutil/attributes.h"
35 #include "libavutil/avassert.h"
38 #include "libschroedinger.h"
39 #include "bytestream.h"
42 /** libschroedinger encoder private data */
43 typedef struct SchroEncoderParams
{
44 /** Schroedinger video format */
45 SchroVideoFormat
*format
;
47 /** Schroedinger frame format */
48 SchroFrameFormat frame_format
;
53 /** Schroedinger encoder handle*/
54 SchroEncoder
* encoder
;
56 /** buffer to store encoder output before writing it to the frame queue*/
57 unsigned char *enc_buf
;
59 /** Size of encoder buffer*/
62 /** queue storing encoded frames */
63 FFSchroQueue enc_frame_queue
;
65 /** end of sequence signalled */
68 /** end of sequence pulled */
71 /* counter for frames submitted to encoder, used as dts */
76 * Works out Schro-compatible chroma format.
78 static int set_chroma_format(AVCodecContext
*avctx
)
80 int num_formats
= sizeof(schro_pixel_format_map
) /
81 sizeof(schro_pixel_format_map
[0]);
84 SchroEncoderParams
*p_schro_params
= avctx
->priv_data
;
86 for (idx
= 0; idx
< num_formats
; ++idx
) {
87 if (schro_pixel_format_map
[idx
].ff_pix_fmt
== avctx
->pix_fmt
) {
88 p_schro_params
->format
->chroma_format
=
89 schro_pixel_format_map
[idx
].schro_pix_fmt
;
94 av_log(avctx
, AV_LOG_ERROR
,
95 "This codec currently only supports planar YUV 4:2:0, 4:2:2"
96 " and 4:4:4 formats.\n");
101 static av_cold
int libschroedinger_encode_init(AVCodecContext
*avctx
)
103 SchroEncoderParams
*p_schro_params
= avctx
->priv_data
;
104 SchroVideoFormatEnum preset
;
106 /* Initialize the libraries that libschroedinger depends on. */
109 /* Create an encoder object. */
110 p_schro_params
->encoder
= schro_encoder_new();
112 if (!p_schro_params
->encoder
) {
113 av_log(avctx
, AV_LOG_ERROR
,
114 "Unrecoverable Error: schro_encoder_new failed. ");
118 /* Initialize the format. */
119 preset
= ff_get_schro_video_format_preset(avctx
);
120 p_schro_params
->format
=
121 schro_encoder_get_video_format(p_schro_params
->encoder
);
122 schro_video_format_set_std_video_format(p_schro_params
->format
, preset
);
123 p_schro_params
->format
->width
= avctx
->width
;
124 p_schro_params
->format
->height
= avctx
->height
;
126 if (set_chroma_format(avctx
) == -1)
129 if (avctx
->color_primaries
== AVCOL_PRI_BT709
) {
130 p_schro_params
->format
->colour_primaries
= SCHRO_COLOUR_PRIMARY_HDTV
;
131 } else if (avctx
->color_primaries
== AVCOL_PRI_BT470BG
) {
132 p_schro_params
->format
->colour_primaries
= SCHRO_COLOUR_PRIMARY_SDTV_625
;
133 } else if (avctx
->color_primaries
== AVCOL_PRI_SMPTE170M
) {
134 p_schro_params
->format
->colour_primaries
= SCHRO_COLOUR_PRIMARY_SDTV_525
;
137 if (avctx
->colorspace
== AVCOL_SPC_BT709
) {
138 p_schro_params
->format
->colour_matrix
= SCHRO_COLOUR_MATRIX_HDTV
;
139 } else if (avctx
->colorspace
== AVCOL_SPC_BT470BG
) {
140 p_schro_params
->format
->colour_matrix
= SCHRO_COLOUR_MATRIX_SDTV
;
143 if (avctx
->color_trc
== AVCOL_TRC_BT709
) {
144 p_schro_params
->format
->transfer_function
= SCHRO_TRANSFER_CHAR_TV_GAMMA
;
147 if (ff_get_schro_frame_format(p_schro_params
->format
->chroma_format
,
148 &p_schro_params
->frame_format
) == -1) {
149 av_log(avctx
, AV_LOG_ERROR
,
150 "This codec currently supports only planar YUV 4:2:0, 4:2:2"
151 " and 4:4:4 formats.\n");
155 p_schro_params
->format
->frame_rate_numerator
= avctx
->time_base
.den
;
156 p_schro_params
->format
->frame_rate_denominator
= avctx
->time_base
.num
;
158 p_schro_params
->frame_size
= avpicture_get_size(avctx
->pix_fmt
,
162 avctx
->coded_frame
= av_frame_alloc();
163 if (!avctx
->coded_frame
)
164 return AVERROR(ENOMEM
);
166 if (!avctx
->gop_size
) {
167 schro_encoder_setting_set_double(p_schro_params
->encoder
,
169 SCHRO_ENCODER_GOP_INTRA_ONLY
);
171 if (avctx
->coder_type
== FF_CODER_TYPE_VLC
)
172 schro_encoder_setting_set_double(p_schro_params
->encoder
,
173 "enable_noarith", 1);
175 schro_encoder_setting_set_double(p_schro_params
->encoder
,
176 "au_distance", avctx
->gop_size
);
177 avctx
->has_b_frames
= 1;
178 p_schro_params
->dts
= -1;
181 /* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */
182 if (avctx
->flags
& CODEC_FLAG_QSCALE
) {
183 if (!avctx
->global_quality
) {
184 /* lossless coding */
185 schro_encoder_setting_set_double(p_schro_params
->encoder
,
187 SCHRO_ENCODER_RATE_CONTROL_LOSSLESS
);
190 schro_encoder_setting_set_double(p_schro_params
->encoder
,
192 SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY
);
194 quality
= avctx
->global_quality
/ FF_QP2LAMBDA
;
197 schro_encoder_setting_set_double(p_schro_params
->encoder
,
201 schro_encoder_setting_set_double(p_schro_params
->encoder
,
203 SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE
);
205 schro_encoder_setting_set_double(p_schro_params
->encoder
,
206 "bitrate", avctx
->bit_rate
);
209 if (avctx
->flags
& CODEC_FLAG_INTERLACED_ME
)
210 /* All material can be coded as interlaced or progressive
211 irrespective of the type of source material. */
212 schro_encoder_setting_set_double(p_schro_params
->encoder
,
213 "interlaced_coding", 1);
215 schro_encoder_setting_set_double(p_schro_params
->encoder
, "open_gop",
216 !(avctx
->flags
& CODEC_FLAG_CLOSED_GOP
));
218 /* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger
219 * and libdirac support other bit-depth data. */
220 schro_video_format_set_std_signal_range(p_schro_params
->format
,
221 SCHRO_SIGNAL_RANGE_8BIT_VIDEO
);
223 /* Set the encoder format. */
224 schro_encoder_set_video_format(p_schro_params
->encoder
,
225 p_schro_params
->format
);
227 /* Set the debug level. */
228 schro_debug_set_level(avctx
->debug
);
230 schro_encoder_start(p_schro_params
->encoder
);
232 /* Initialize the encoded frame queue. */
233 ff_schro_queue_init(&p_schro_params
->enc_frame_queue
);
237 static SchroFrame
*libschroedinger_frame_from_data(AVCodecContext
*avctx
,
238 const AVFrame
*frame
)
240 SchroEncoderParams
*p_schro_params
= avctx
->priv_data
;
241 SchroFrame
*in_frame
;
242 /* Input line size may differ from what the codec supports. Especially
243 * when transcoding from one format to another. So use avpicture_layout
244 * to copy the frame. */
245 in_frame
= ff_create_schro_frame(avctx
, p_schro_params
->frame_format
);
248 avpicture_layout((const AVPicture
*)frame
, avctx
->pix_fmt
,
249 avctx
->width
, avctx
->height
,
250 in_frame
->components
[0].data
,
251 p_schro_params
->frame_size
);
256 static void libschroedinger_free_frame(void *data
)
258 FFSchroEncodedFrame
*enc_frame
= data
;
260 av_freep(&enc_frame
->p_encbuf
);
264 static int libschroedinger_encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
265 const AVFrame
*frame
, int *got_packet
)
268 SchroEncoderParams
*p_schro_params
= avctx
->priv_data
;
269 SchroEncoder
*encoder
= p_schro_params
->encoder
;
270 struct FFSchroEncodedFrame
*p_frame_output
= NULL
;
272 SchroBuffer
*enc_buf
;
273 int presentation_frame
;
275 int last_frame_in_sequence
= 0;
279 /* Push end of sequence if not already signalled. */
280 if (!p_schro_params
->eos_signalled
) {
281 schro_encoder_end_of_stream(encoder
);
282 p_schro_params
->eos_signalled
= 1;
285 /* Allocate frame data to schro input buffer. */
286 SchroFrame
*in_frame
= libschroedinger_frame_from_data(avctx
, frame
);
287 /* Load next frame. */
288 schro_encoder_push_frame(encoder
, in_frame
);
291 if (p_schro_params
->eos_pulled
)
294 /* Now check to see if we have any output from the encoder. */
297 SchroStateEnum state
;
298 state
= schro_encoder_wait(encoder
);
300 case SCHRO_STATE_HAVE_BUFFER
:
301 case SCHRO_STATE_END_OF_STREAM
:
302 enc_buf
= schro_encoder_pull(encoder
, &presentation_frame
);
303 if (enc_buf
->length
<= 0)
305 parse_code
= enc_buf
->data
[4];
307 /* All non-frame data is prepended to actual frame data to
308 * be able to set the pts correctly. So we don't write data
309 * to the frame output queue until we actually have a frame
311 if ((err
= av_reallocp(&p_schro_params
->enc_buf
,
312 p_schro_params
->enc_buf_size
+
313 enc_buf
->length
)) < 0) {
314 p_schro_params
->enc_buf_size
= 0;
318 memcpy(p_schro_params
->enc_buf
+ p_schro_params
->enc_buf_size
,
319 enc_buf
->data
, enc_buf
->length
);
320 p_schro_params
->enc_buf_size
+= enc_buf
->length
;
323 if (state
== SCHRO_STATE_END_OF_STREAM
) {
324 p_schro_params
->eos_pulled
= 1;
328 if (!SCHRO_PARSE_CODE_IS_PICTURE(parse_code
)) {
329 schro_buffer_unref(enc_buf
);
333 /* Create output frame. */
334 p_frame_output
= av_mallocz(sizeof(FFSchroEncodedFrame
));
335 /* Set output data. */
336 p_frame_output
->size
= p_schro_params
->enc_buf_size
;
337 p_frame_output
->p_encbuf
= p_schro_params
->enc_buf
;
338 if (SCHRO_PARSE_CODE_IS_INTRA(parse_code
) &&
339 SCHRO_PARSE_CODE_IS_REFERENCE(parse_code
))
340 p_frame_output
->key_frame
= 1;
342 /* Parse the coded frame number from the bitstream. Bytes 14
343 * through 17 represesent the frame number. */
344 p_frame_output
->frame_num
= AV_RB32(enc_buf
->data
+ 13);
346 ff_schro_queue_push_back(&p_schro_params
->enc_frame_queue
,
348 p_schro_params
->enc_buf_size
= 0;
349 p_schro_params
->enc_buf
= NULL
;
351 schro_buffer_unref(enc_buf
);
355 case SCHRO_STATE_NEED_FRAME
:
359 case SCHRO_STATE_AGAIN
:
363 av_log(avctx
, AV_LOG_ERROR
, "Unknown Schro Encoder state\n");
368 /* Copy 'next' frame in queue. */
370 if (p_schro_params
->enc_frame_queue
.size
== 1 &&
371 p_schro_params
->eos_pulled
)
372 last_frame_in_sequence
= 1;
374 p_frame_output
= ff_schro_queue_pop(&p_schro_params
->enc_frame_queue
);
379 pkt_size
= p_frame_output
->size
;
380 if (last_frame_in_sequence
&& p_schro_params
->enc_buf_size
> 0)
381 pkt_size
+= p_schro_params
->enc_buf_size
;
382 if ((ret
= ff_alloc_packet2(avctx
, pkt
, pkt_size
)) < 0)
385 memcpy(pkt
->data
, p_frame_output
->p_encbuf
, p_frame_output
->size
);
386 avctx
->coded_frame
->key_frame
= p_frame_output
->key_frame
;
387 /* Use the frame number of the encoded frame as the pts. It is OK to
388 * do so since Dirac is a constant frame rate codec. It expects input
389 * to be of constant frame rate. */
391 avctx
->coded_frame
->pts
= p_frame_output
->frame_num
;
392 pkt
->dts
= p_schro_params
->dts
++;
393 enc_size
= p_frame_output
->size
;
395 /* Append the end of sequence information to the last frame in the
397 if (last_frame_in_sequence
&& p_schro_params
->enc_buf_size
> 0) {
398 memcpy(pkt
->data
+ enc_size
, p_schro_params
->enc_buf
,
399 p_schro_params
->enc_buf_size
);
400 enc_size
+= p_schro_params
->enc_buf_size
;
401 av_freep(&p_schro_params
->enc_buf
);
402 p_schro_params
->enc_buf_size
= 0;
405 if (p_frame_output
->key_frame
)
406 pkt
->flags
|= AV_PKT_FLAG_KEY
;
411 libschroedinger_free_frame(p_frame_output
);
416 static int libschroedinger_encode_close(AVCodecContext
*avctx
)
418 SchroEncoderParams
*p_schro_params
= avctx
->priv_data
;
420 /* Close the encoder. */
421 schro_encoder_free(p_schro_params
->encoder
);
423 /* Free data in the output frame queue. */
424 ff_schro_queue_free(&p_schro_params
->enc_frame_queue
,
425 libschroedinger_free_frame
);
428 /* Free the encoder buffer. */
429 if (p_schro_params
->enc_buf_size
)
430 av_freep(&p_schro_params
->enc_buf
);
432 /* Free the video format structure. */
433 av_freep(&p_schro_params
->format
);
435 av_frame_free(&avctx
->coded_frame
);
441 AVCodec ff_libschroedinger_encoder
= {
442 .name
= "libschroedinger",
443 .long_name
= NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
444 .type
= AVMEDIA_TYPE_VIDEO
,
445 .id
= AV_CODEC_ID_DIRAC
,
446 .priv_data_size
= sizeof(SchroEncoderParams
),
447 .init
= libschroedinger_encode_init
,
448 .encode2
= libschroedinger_encode_frame
,
449 .close
= libschroedinger_encode_close
,
450 .capabilities
= CODEC_CAP_DELAY
,
451 .pix_fmts
= (const enum AVPixelFormat
[]){
452 AV_PIX_FMT_YUV420P
, AV_PIX_FMT_YUV422P
, AV_PIX_FMT_YUV444P
, AV_PIX_FMT_NONE