Mercurial > libavcodec.hg
annotate libdiracenc.c @ 7354:456957d86106 libavcodec
My commit at r14340 was not the right solution. For a monochromatic
frame, there will be only one centroid and it will be impossible to
find three distinct ones. It is better to just avoid shifting if
there are not three different centroids.
author | vitor |
---|---|
date | Wed, 23 Jul 2008 05:54:34 +0000 |
parents | e674db16f1c6 |
children | e6348a5656e0 |
rev | line source |
---|---|
6734 | 1 /* |
2 * Dirac encoding support via libdirac library | |
3 * Copyright (c) 2005 BBC, Andrew Kennedy <dirac at rd dot bbc dot co dot uk> | |
4 * Copyright (c) 2006-2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com > | |
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 libdiracenc.c | |
25 * Dirac encoding support via libdirac library; more details about the | |
26 * Dirac project can be found at http://dirac.sourceforge.net/. | |
27 * The libdirac_encoder library implements Dirac specification version 2.2 | |
28 * (http://dirac.sourceforge.net/specification.html). | |
29 */ | |
30 | |
31 #include "libdirac_libschro.h" | |
32 #include "libdirac.h" | |
33 | |
34 #undef NDEBUG | |
35 #include <assert.h> | |
36 | |
37 | |
38 #include <libdirac_encoder/dirac_encoder.h> | |
39 | |
40 /** Dirac encoder private data */ | |
41 typedef struct FfmpegDiracEncoderParams | |
42 { | |
43 /** Dirac encoder context */ | |
44 dirac_encoder_context_t enc_ctx; | |
45 | |
46 /** frame being encoded */ | |
47 AVFrame picture; | |
48 | |
49 /** frame size */ | |
50 int frame_size; | |
51 | |
52 /** Dirac encoder handle */ | |
53 dirac_encoder_t* p_encoder; | |
54 | |
55 /** input frame buffer */ | |
56 unsigned char *p_in_frame_buf; | |
57 | |
7252 | 58 /** buffer to store encoder output before writing it to the frame queue */ |
59 unsigned char *enc_buf; | |
60 | |
61 /** size of encoder buffer */ | |
62 int enc_buf_size; | |
63 | |
6734 | 64 /** queue storing encoded frames */ |
65 FfmpegDiracSchroQueue enc_frame_queue; | |
66 | |
67 /** end of sequence signalled by user, 0 - false, 1 - true */ | |
68 int eos_signalled; | |
69 | |
70 /** end of sequence returned by encoder, 0 - false, 1 - true */ | |
71 int eos_pulled; | |
72 } FfmpegDiracEncoderParams; | |
73 | |
74 /** | |
75 * Works out Dirac-compatible chroma format. | |
76 */ | |
77 static dirac_chroma_t GetDiracChromaFormat(enum PixelFormat ff_pix_fmt) | |
78 { | |
79 int num_formats = sizeof(ffmpeg_dirac_pixel_format_map) / | |
80 sizeof(ffmpeg_dirac_pixel_format_map[0]); | |
81 int idx; | |
82 | |
83 for (idx = 0; idx < num_formats; ++idx) { | |
84 if (ffmpeg_dirac_pixel_format_map[idx].ff_pix_fmt == ff_pix_fmt) { | |
85 return ffmpeg_dirac_pixel_format_map[idx].dirac_pix_fmt; | |
86 } | |
87 } | |
88 return formatNK; | |
89 } | |
90 | |
91 /** | |
92 * Dirac video preset table. Ensure that this tables matches up correctly | |
93 * with the ff_dirac_schro_video_format_info table in libdirac_libschro.c. | |
94 */ | |
95 static const VideoFormat ff_dirac_video_formats[]={ | |
96 VIDEO_FORMAT_CUSTOM , | |
97 VIDEO_FORMAT_QSIF525 , | |
98 VIDEO_FORMAT_QCIF , | |
99 VIDEO_FORMAT_SIF525 , | |
100 VIDEO_FORMAT_CIF , | |
101 VIDEO_FORMAT_4SIF525 , | |
102 VIDEO_FORMAT_4CIF , | |
103 VIDEO_FORMAT_SD_480I60 , | |
104 VIDEO_FORMAT_SD_576I50 , | |
105 VIDEO_FORMAT_HD_720P60 , | |
106 VIDEO_FORMAT_HD_720P50 , | |
107 VIDEO_FORMAT_HD_1080I60 , | |
108 VIDEO_FORMAT_HD_1080I50 , | |
109 VIDEO_FORMAT_HD_1080P60 , | |
110 VIDEO_FORMAT_HD_1080P50 , | |
111 VIDEO_FORMAT_DIGI_CINEMA_2K24 , | |
112 VIDEO_FORMAT_DIGI_CINEMA_4K24 , | |
113 }; | |
114 | |
115 /** | |
116 * Returns the video format preset matching the input video dimensions and | |
117 * time base. | |
118 */ | |
119 static VideoFormat GetDiracVideoFormatPreset (AVCodecContext *avccontext) | |
120 { | |
121 unsigned int num_formats = sizeof(ff_dirac_video_formats) / | |
122 sizeof(ff_dirac_video_formats[0]); | |
123 | |
124 unsigned int idx = ff_dirac_schro_get_video_format_idx (avccontext); | |
125 | |
126 return (idx < num_formats) ? | |
127 ff_dirac_video_formats[idx] : VIDEO_FORMAT_CUSTOM; | |
128 } | |
129 | |
130 static int libdirac_encode_init(AVCodecContext *avccontext) | |
131 { | |
132 | |
133 FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; | |
134 int no_local = 1; | |
135 int verbose = avccontext->debug; | |
136 VideoFormat preset; | |
137 | |
138 /* get Dirac preset */ | |
139 preset = GetDiracVideoFormatPreset(avccontext); | |
140 | |
141 /* initialize the encoder context */ | |
142 dirac_encoder_context_init (&(p_dirac_params->enc_ctx), preset); | |
143 | |
144 p_dirac_params->enc_ctx.src_params.chroma = | |
145 GetDiracChromaFormat(avccontext->pix_fmt); | |
146 | |
147 if (p_dirac_params->enc_ctx.src_params.chroma == formatNK) { | |
148 av_log (avccontext, AV_LOG_ERROR, | |
149 "Unsupported pixel format %d. This codec supports only " | |
150 "Planar YUV formats (yuv420p, yuv422p, yuv444p\n", | |
151 avccontext->pix_fmt); | |
152 return -1; | |
153 } | |
154 | |
155 p_dirac_params->enc_ctx.src_params.frame_rate.numerator = | |
156 avccontext->time_base.den; | |
157 p_dirac_params->enc_ctx.src_params.frame_rate.denominator = | |
158 avccontext->time_base.num; | |
159 | |
160 p_dirac_params->enc_ctx.src_params.width = avccontext->width; | |
161 p_dirac_params->enc_ctx.src_params.height = avccontext->height; | |
162 | |
163 p_dirac_params->frame_size = avpicture_get_size(avccontext->pix_fmt, | |
164 avccontext->width, | |
165 avccontext->height); | |
166 | |
167 avccontext->coded_frame = &p_dirac_params->picture; | |
168 | |
169 if (no_local) { | |
170 p_dirac_params->enc_ctx.decode_flag = 0; | |
171 p_dirac_params->enc_ctx.instr_flag = 0; | |
172 } else { | |
173 p_dirac_params->enc_ctx.decode_flag = 1; | |
174 p_dirac_params->enc_ctx.instr_flag = 1; | |
175 } | |
176 | |
177 /* Intra-only sequence */ | |
178 if (avccontext->gop_size == 0 ) | |
179 p_dirac_params->enc_ctx.enc_params.num_L1 = 0; | |
180 else | |
181 avccontext->has_b_frames = 1; | |
182 | |
183 if (avccontext->flags & CODEC_FLAG_QSCALE) { | |
184 if (avccontext->global_quality != 0) { | |
185 p_dirac_params->enc_ctx.enc_params.qf = | |
186 avccontext->global_quality / (FF_QP2LAMBDA*10.0); | |
187 /* if it is not default bitrate then send target rate. */ | |
188 if (avccontext->bit_rate >= 1000 && | |
189 avccontext->bit_rate != 200000) { | |
190 p_dirac_params->enc_ctx.enc_params.trate = | |
191 avccontext->bit_rate / 1000; | |
192 } | |
193 } else | |
194 p_dirac_params->enc_ctx.enc_params.lossless = 1; | |
195 } else if (avccontext->bit_rate >= 1000) | |
196 p_dirac_params->enc_ctx.enc_params.trate = avccontext->bit_rate / 1000; | |
197 | |
198 if ((preset > VIDEO_FORMAT_QCIF || preset < VIDEO_FORMAT_QSIF525) && | |
199 avccontext->bit_rate == 200000) { | |
200 p_dirac_params->enc_ctx.enc_params.trate = 0; | |
201 } | |
202 | |
203 if (avccontext->flags & CODEC_FLAG_INTERLACED_ME) { | |
204 /* all material can be coded as interlaced or progressive | |
205 * irrespective of the type of source material */ | |
206 p_dirac_params->enc_ctx.enc_params.picture_coding_mode = 1; | |
207 } | |
208 | |
209 p_dirac_params->p_encoder = dirac_encoder_init (&(p_dirac_params->enc_ctx), | |
210 verbose ); | |
211 | |
212 if (!p_dirac_params->p_encoder) { | |
213 av_log(avccontext, AV_LOG_ERROR, | |
214 "Unrecoverable Error: dirac_encoder_init failed. "); | |
215 return EXIT_FAILURE; | |
216 } | |
217 | |
218 /* allocate enough memory for the incoming data */ | |
219 p_dirac_params->p_in_frame_buf = av_malloc(p_dirac_params->frame_size); | |
220 | |
221 /* initialize the encoded frame queue */ | |
222 ff_dirac_schro_queue_init(&p_dirac_params->enc_frame_queue); | |
223 | |
224 return 0 ; | |
225 } | |
226 | |
227 static void DiracFreeFrame (void *data) | |
228 { | |
229 FfmpegDiracSchroEncodedFrame *enc_frame = data; | |
230 | |
231 av_freep (&(enc_frame->p_encbuf)); | |
232 av_free(enc_frame); | |
233 } | |
234 | |
235 static int libdirac_encode_frame(AVCodecContext *avccontext, | |
236 unsigned char *frame, | |
237 int buf_size, void *data) | |
238 { | |
239 int enc_size = 0; | |
240 dirac_encoder_state_t state; | |
241 FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; | |
242 FfmpegDiracSchroEncodedFrame* p_frame_output = NULL; | |
243 FfmpegDiracSchroEncodedFrame* p_next_output_frame = NULL; | |
244 int go = 1; | |
7252 | 245 int last_frame_in_sequence = 0; |
6734 | 246 |
247 if (data == NULL) { | |
248 /* push end of sequence if not already signalled */ | |
249 if (!p_dirac_params->eos_signalled) { | |
250 dirac_encoder_end_sequence( p_dirac_params->p_encoder ); | |
251 p_dirac_params->eos_signalled = 1; | |
252 } | |
253 } else { | |
254 | |
255 /* Allocate frame data to Dirac input buffer. | |
256 * Input line size may differ from what the codec supports, | |
257 * especially when transcoding from one format to another. | |
258 * So use avpicture_layout to copy the frame. */ | |
259 avpicture_layout ((AVPicture *)data, avccontext->pix_fmt, | |
260 avccontext->width, avccontext->height, | |
261 p_dirac_params->p_in_frame_buf, | |
262 p_dirac_params->frame_size); | |
263 | |
264 /* load next frame */ | |
265 if (dirac_encoder_load (p_dirac_params->p_encoder, | |
266 p_dirac_params->p_in_frame_buf, | |
267 p_dirac_params->frame_size ) < 0) { | |
268 av_log(avccontext, AV_LOG_ERROR, "Unrecoverable Encoder Error." | |
269 " dirac_encoder_load failed...\n"); | |
270 return -1; | |
271 } | |
272 } | |
273 | |
274 if (p_dirac_params->eos_pulled) | |
275 go = 0; | |
276 | |
277 while(go) { | |
278 p_dirac_params->p_encoder->enc_buf.buffer = frame; | |
279 p_dirac_params->p_encoder->enc_buf.size = buf_size; | |
280 /* process frame */ | |
281 state = dirac_encoder_output ( p_dirac_params->p_encoder ); | |
282 | |
283 switch (state) | |
284 { | |
285 case ENC_STATE_AVAIL: | |
286 case ENC_STATE_EOS: | |
287 assert (p_dirac_params->p_encoder->enc_buf.size > 0); | |
7252 | 288 |
289 /* All non-frame data is prepended to actual frame data to | |
290 * be able to set the pts correctly. So we don't write data | |
291 * to the frame output queue until we actually have a frame | |
292 */ | |
293 | |
294 p_dirac_params->enc_buf = av_realloc ( | |
295 p_dirac_params->enc_buf, | |
296 p_dirac_params->enc_buf_size + | |
297 p_dirac_params->p_encoder->enc_buf.size | |
298 ); | |
299 memcpy(p_dirac_params->enc_buf + p_dirac_params->enc_buf_size, | |
300 p_dirac_params->p_encoder->enc_buf.buffer, | |
301 p_dirac_params->p_encoder->enc_buf.size); | |
302 | |
303 p_dirac_params->enc_buf_size += | |
304 p_dirac_params->p_encoder->enc_buf.size; | |
305 | |
306 if (state == ENC_STATE_EOS) { | |
307 p_dirac_params->eos_pulled = 1; | |
308 go = 0; | |
309 } | |
310 | |
311 /* If non-frame data, don't output it until it we get an | |
312 * encoded frame back from the encoder. */ | |
313 if (p_dirac_params->p_encoder->enc_pparams.pnum == -1) | |
314 break; | |
315 | |
6734 | 316 /* create output frame */ |
317 p_frame_output = av_mallocz(sizeof(FfmpegDiracSchroEncodedFrame)); | |
318 /* set output data */ | |
7252 | 319 p_frame_output->size = p_dirac_params->enc_buf_size; |
320 p_frame_output->p_encbuf = p_dirac_params->enc_buf; | |
6734 | 321 p_frame_output->frame_num = |
322 p_dirac_params->p_encoder->enc_pparams.pnum; | |
323 | |
324 if (p_dirac_params->p_encoder->enc_pparams.ptype == INTRA_PICTURE && | |
325 p_dirac_params->p_encoder->enc_pparams.rtype == REFERENCE_PICTURE) | |
326 p_frame_output->key_frame = 1; | |
327 | |
328 ff_dirac_schro_queue_push_back (&p_dirac_params->enc_frame_queue, | |
329 p_frame_output); | |
330 | |
7252 | 331 p_dirac_params->enc_buf_size = 0; |
332 p_dirac_params->enc_buf = NULL; | |
6734 | 333 break; |
334 | |
335 case ENC_STATE_BUFFER: | |
336 go = 0; | |
337 break; | |
338 | |
339 case ENC_STATE_INVALID: | |
340 av_log(avccontext, AV_LOG_ERROR, | |
341 "Unrecoverable Dirac Encoder Error. Quitting...\n"); | |
342 return -1; | |
343 | |
344 default: | |
345 av_log(avccontext, AV_LOG_ERROR, "Unknown Dirac Encoder state\n"); | |
346 return -1; | |
347 } | |
348 } | |
349 | |
350 /* copy 'next' frame in queue */ | |
7252 | 351 |
352 if (p_dirac_params->enc_frame_queue.size == 1 && | |
353 p_dirac_params->eos_pulled) | |
354 last_frame_in_sequence = 1; | |
355 | |
6734 | 356 p_next_output_frame = |
357 ff_dirac_schro_queue_pop(&p_dirac_params->enc_frame_queue); | |
358 | |
359 if (p_next_output_frame == NULL) | |
360 return 0; | |
361 | |
362 memcpy(frame, p_next_output_frame->p_encbuf, p_next_output_frame->size); | |
363 avccontext->coded_frame->key_frame = p_next_output_frame->key_frame; | |
364 /* Use the frame number of the encoded frame as the pts. It is OK to do | |
365 * so since Dirac is a constant framerate codec. It expects input to be | |
366 * of constant framerate. */ | |
367 avccontext->coded_frame->pts = p_next_output_frame->frame_num; | |
368 enc_size = p_next_output_frame->size; | |
369 | |
7252 | 370 /* Append the end of sequence information to the last frame in the |
371 * sequence. */ | |
372 if (last_frame_in_sequence && p_dirac_params->enc_buf_size > 0) | |
373 { | |
374 memcpy (frame + enc_size, p_dirac_params->enc_buf, | |
375 p_dirac_params->enc_buf_size); | |
376 enc_size += p_dirac_params->enc_buf_size; | |
377 av_freep (&p_dirac_params->enc_buf); | |
378 p_dirac_params->enc_buf_size = 0; | |
379 } | |
380 | |
6734 | 381 /* free frame */ |
382 DiracFreeFrame(p_next_output_frame); | |
383 | |
384 return enc_size; | |
385 } | |
386 | |
387 static int libdirac_encode_close(AVCodecContext *avccontext) | |
388 { | |
389 FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; | |
390 | |
391 /* close the encoder */ | |
392 dirac_encoder_close(p_dirac_params->p_encoder ); | |
393 | |
394 /* free data in the output frame queue */ | |
395 ff_dirac_schro_queue_free(&p_dirac_params->enc_frame_queue, | |
396 DiracFreeFrame); | |
397 | |
7252 | 398 /* free the encoder buffer */ |
399 if (p_dirac_params->enc_buf_size) | |
400 av_freep(&p_dirac_params->enc_buf); | |
401 | |
6734 | 402 /* free the input frame buffer */ |
403 av_freep(&p_dirac_params->p_in_frame_buf); | |
404 | |
405 return 0 ; | |
406 } | |
407 | |
408 | |
409 AVCodec libdirac_encoder = { | |
410 "libdirac", | |
411 CODEC_TYPE_VIDEO, | |
412 CODEC_ID_DIRAC, | |
413 sizeof(FfmpegDiracEncoderParams), | |
414 libdirac_encode_init, | |
415 libdirac_encode_frame, | |
416 libdirac_encode_close, | |
417 .capabilities= CODEC_CAP_DELAY, | |
418 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, -1}, | |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6819
diff
changeset
|
419 .long_name= NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"), |
6734 | 420 } ; |