Mercurial > libavcodec.hg
annotate libdiracenc.c @ 6920:d02af7474bff libavcodec
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
fixes CID84 RUN2
CID85 RUN2
CID86 RUN2
CID87 RUN2
CID88 RUN2
CID89 RUN2
CID90 RUN2
CID91 RUN2
CID92 RUN2
CID93 RUN2
CID94 RUN2
CID95 RUN2
CID96 RUN2
CID97 RUN2
CID98 RUN2
CID99 RUN2
CID100 RUN2
CID101 RUN2
CID102 RUN2
CID103 RUN2
CID104 RUN2
CID105 RUN2
CID106 RUN2
author | michael |
---|---|
date | Wed, 28 May 2008 11:59:41 +0000 |
parents | 43bede126ef6 |
children | e943e1409077 |
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 | |
58 /** queue storing encoded frames */ | |
59 FfmpegDiracSchroQueue enc_frame_queue; | |
60 | |
61 /** end of sequence signalled by user, 0 - false, 1 - true */ | |
62 int eos_signalled; | |
63 | |
64 /** end of sequence returned by encoder, 0 - false, 1 - true */ | |
65 int eos_pulled; | |
66 } FfmpegDiracEncoderParams; | |
67 | |
68 /** | |
69 * Works out Dirac-compatible chroma format. | |
70 */ | |
71 static dirac_chroma_t GetDiracChromaFormat(enum PixelFormat ff_pix_fmt) | |
72 { | |
73 int num_formats = sizeof(ffmpeg_dirac_pixel_format_map) / | |
74 sizeof(ffmpeg_dirac_pixel_format_map[0]); | |
75 int idx; | |
76 | |
77 for (idx = 0; idx < num_formats; ++idx) { | |
78 if (ffmpeg_dirac_pixel_format_map[idx].ff_pix_fmt == ff_pix_fmt) { | |
79 return ffmpeg_dirac_pixel_format_map[idx].dirac_pix_fmt; | |
80 } | |
81 } | |
82 return formatNK; | |
83 } | |
84 | |
85 /** | |
86 * Dirac video preset table. Ensure that this tables matches up correctly | |
87 * with the ff_dirac_schro_video_format_info table in libdirac_libschro.c. | |
88 */ | |
89 static const VideoFormat ff_dirac_video_formats[]={ | |
90 VIDEO_FORMAT_CUSTOM , | |
91 VIDEO_FORMAT_QSIF525 , | |
92 VIDEO_FORMAT_QCIF , | |
93 VIDEO_FORMAT_SIF525 , | |
94 VIDEO_FORMAT_CIF , | |
95 VIDEO_FORMAT_4SIF525 , | |
96 VIDEO_FORMAT_4CIF , | |
97 VIDEO_FORMAT_SD_480I60 , | |
98 VIDEO_FORMAT_SD_576I50 , | |
99 VIDEO_FORMAT_HD_720P60 , | |
100 VIDEO_FORMAT_HD_720P50 , | |
101 VIDEO_FORMAT_HD_1080I60 , | |
102 VIDEO_FORMAT_HD_1080I50 , | |
103 VIDEO_FORMAT_HD_1080P60 , | |
104 VIDEO_FORMAT_HD_1080P50 , | |
105 VIDEO_FORMAT_DIGI_CINEMA_2K24 , | |
106 VIDEO_FORMAT_DIGI_CINEMA_4K24 , | |
107 }; | |
108 | |
109 /** | |
110 * Returns the video format preset matching the input video dimensions and | |
111 * time base. | |
112 */ | |
113 static VideoFormat GetDiracVideoFormatPreset (AVCodecContext *avccontext) | |
114 { | |
115 unsigned int num_formats = sizeof(ff_dirac_video_formats) / | |
116 sizeof(ff_dirac_video_formats[0]); | |
117 | |
118 unsigned int idx = ff_dirac_schro_get_video_format_idx (avccontext); | |
119 | |
120 return (idx < num_formats) ? | |
121 ff_dirac_video_formats[idx] : VIDEO_FORMAT_CUSTOM; | |
122 } | |
123 | |
124 static int libdirac_encode_init(AVCodecContext *avccontext) | |
125 { | |
126 | |
127 FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; | |
128 int no_local = 1; | |
129 int verbose = avccontext->debug; | |
130 VideoFormat preset; | |
131 | |
132 /* get Dirac preset */ | |
133 preset = GetDiracVideoFormatPreset(avccontext); | |
134 | |
135 /* initialize the encoder context */ | |
136 dirac_encoder_context_init (&(p_dirac_params->enc_ctx), preset); | |
137 | |
138 p_dirac_params->enc_ctx.src_params.chroma = | |
139 GetDiracChromaFormat(avccontext->pix_fmt); | |
140 | |
141 if (p_dirac_params->enc_ctx.src_params.chroma == formatNK) { | |
142 av_log (avccontext, AV_LOG_ERROR, | |
143 "Unsupported pixel format %d. This codec supports only " | |
144 "Planar YUV formats (yuv420p, yuv422p, yuv444p\n", | |
145 avccontext->pix_fmt); | |
146 return -1; | |
147 } | |
148 | |
149 p_dirac_params->enc_ctx.src_params.frame_rate.numerator = | |
150 avccontext->time_base.den; | |
151 p_dirac_params->enc_ctx.src_params.frame_rate.denominator = | |
152 avccontext->time_base.num; | |
153 | |
154 p_dirac_params->enc_ctx.src_params.width = avccontext->width; | |
155 p_dirac_params->enc_ctx.src_params.height = avccontext->height; | |
156 | |
157 p_dirac_params->frame_size = avpicture_get_size(avccontext->pix_fmt, | |
158 avccontext->width, | |
159 avccontext->height); | |
160 | |
161 avccontext->coded_frame = &p_dirac_params->picture; | |
162 | |
163 if (no_local) { | |
164 p_dirac_params->enc_ctx.decode_flag = 0; | |
165 p_dirac_params->enc_ctx.instr_flag = 0; | |
166 } else { | |
167 p_dirac_params->enc_ctx.decode_flag = 1; | |
168 p_dirac_params->enc_ctx.instr_flag = 1; | |
169 } | |
170 | |
171 /* Intra-only sequence */ | |
172 if (avccontext->gop_size == 0 ) | |
173 p_dirac_params->enc_ctx.enc_params.num_L1 = 0; | |
174 else | |
175 avccontext->has_b_frames = 1; | |
176 | |
177 if (avccontext->flags & CODEC_FLAG_QSCALE) { | |
178 if (avccontext->global_quality != 0) { | |
179 p_dirac_params->enc_ctx.enc_params.qf = | |
180 avccontext->global_quality / (FF_QP2LAMBDA*10.0); | |
181 /* if it is not default bitrate then send target rate. */ | |
182 if (avccontext->bit_rate >= 1000 && | |
183 avccontext->bit_rate != 200000) { | |
184 p_dirac_params->enc_ctx.enc_params.trate = | |
185 avccontext->bit_rate / 1000; | |
186 } | |
187 } else | |
188 p_dirac_params->enc_ctx.enc_params.lossless = 1; | |
189 } else if (avccontext->bit_rate >= 1000) | |
190 p_dirac_params->enc_ctx.enc_params.trate = avccontext->bit_rate / 1000; | |
191 | |
192 if ((preset > VIDEO_FORMAT_QCIF || preset < VIDEO_FORMAT_QSIF525) && | |
193 avccontext->bit_rate == 200000) { | |
194 p_dirac_params->enc_ctx.enc_params.trate = 0; | |
195 } | |
196 | |
197 if (avccontext->flags & CODEC_FLAG_INTERLACED_ME) { | |
198 /* all material can be coded as interlaced or progressive | |
199 * irrespective of the type of source material */ | |
200 p_dirac_params->enc_ctx.enc_params.picture_coding_mode = 1; | |
201 } | |
202 | |
203 p_dirac_params->p_encoder = dirac_encoder_init (&(p_dirac_params->enc_ctx), | |
204 verbose ); | |
205 | |
206 if (!p_dirac_params->p_encoder) { | |
207 av_log(avccontext, AV_LOG_ERROR, | |
208 "Unrecoverable Error: dirac_encoder_init failed. "); | |
209 return EXIT_FAILURE; | |
210 } | |
211 | |
212 /* allocate enough memory for the incoming data */ | |
213 p_dirac_params->p_in_frame_buf = av_malloc(p_dirac_params->frame_size); | |
214 | |
215 /* initialize the encoded frame queue */ | |
216 ff_dirac_schro_queue_init(&p_dirac_params->enc_frame_queue); | |
217 | |
218 return 0 ; | |
219 } | |
220 | |
221 static void DiracFreeFrame (void *data) | |
222 { | |
223 FfmpegDiracSchroEncodedFrame *enc_frame = data; | |
224 | |
225 av_freep (&(enc_frame->p_encbuf)); | |
226 av_free(enc_frame); | |
227 } | |
228 | |
229 static int libdirac_encode_frame(AVCodecContext *avccontext, | |
230 unsigned char *frame, | |
231 int buf_size, void *data) | |
232 { | |
233 int enc_size = 0; | |
234 dirac_encoder_state_t state; | |
235 FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; | |
236 FfmpegDiracSchroEncodedFrame* p_frame_output = NULL; | |
237 FfmpegDiracSchroEncodedFrame* p_next_output_frame = NULL; | |
238 int go = 1; | |
239 | |
240 if (data == NULL) { | |
241 /* push end of sequence if not already signalled */ | |
242 if (!p_dirac_params->eos_signalled) { | |
243 dirac_encoder_end_sequence( p_dirac_params->p_encoder ); | |
244 p_dirac_params->eos_signalled = 1; | |
245 } | |
246 } else { | |
247 | |
248 /* Allocate frame data to Dirac input buffer. | |
249 * Input line size may differ from what the codec supports, | |
250 * especially when transcoding from one format to another. | |
251 * So use avpicture_layout to copy the frame. */ | |
252 avpicture_layout ((AVPicture *)data, avccontext->pix_fmt, | |
253 avccontext->width, avccontext->height, | |
254 p_dirac_params->p_in_frame_buf, | |
255 p_dirac_params->frame_size); | |
256 | |
257 /* load next frame */ | |
258 if (dirac_encoder_load (p_dirac_params->p_encoder, | |
259 p_dirac_params->p_in_frame_buf, | |
260 p_dirac_params->frame_size ) < 0) { | |
261 av_log(avccontext, AV_LOG_ERROR, "Unrecoverable Encoder Error." | |
262 " dirac_encoder_load failed...\n"); | |
263 return -1; | |
264 } | |
265 } | |
266 | |
267 if (p_dirac_params->eos_pulled) | |
268 go = 0; | |
269 | |
270 while(go) { | |
271 p_dirac_params->p_encoder->enc_buf.buffer = frame; | |
272 p_dirac_params->p_encoder->enc_buf.size = buf_size; | |
273 /* process frame */ | |
274 state = dirac_encoder_output ( p_dirac_params->p_encoder ); | |
275 | |
276 switch (state) | |
277 { | |
278 case ENC_STATE_AVAIL: | |
279 case ENC_STATE_EOS: | |
280 assert (p_dirac_params->p_encoder->enc_buf.size > 0); | |
281 /* create output frame */ | |
282 p_frame_output = av_mallocz(sizeof(FfmpegDiracSchroEncodedFrame)); | |
283 /* set output data */ | |
284 p_frame_output->p_encbuf = | |
285 av_malloc(p_dirac_params->p_encoder->enc_buf.size); | |
286 | |
287 memcpy(p_frame_output->p_encbuf, | |
288 p_dirac_params->p_encoder->enc_buf.buffer, | |
289 p_dirac_params->p_encoder->enc_buf.size); | |
290 | |
291 p_frame_output->size = p_dirac_params->p_encoder->enc_buf.size; | |
292 | |
293 p_frame_output->frame_num = | |
294 p_dirac_params->p_encoder->enc_pparams.pnum; | |
295 | |
296 if (p_dirac_params->p_encoder->enc_pparams.ptype == INTRA_PICTURE && | |
297 p_dirac_params->p_encoder->enc_pparams.rtype == REFERENCE_PICTURE) | |
298 p_frame_output->key_frame = 1; | |
299 | |
300 ff_dirac_schro_queue_push_back (&p_dirac_params->enc_frame_queue, | |
301 p_frame_output); | |
302 | |
303 if (state == ENC_STATE_EOS) { | |
304 p_dirac_params->eos_pulled = 1; | |
305 go = 0; | |
306 } | |
307 break; | |
308 | |
309 case ENC_STATE_BUFFER: | |
310 go = 0; | |
311 break; | |
312 | |
313 case ENC_STATE_INVALID: | |
314 av_log(avccontext, AV_LOG_ERROR, | |
315 "Unrecoverable Dirac Encoder Error. Quitting...\n"); | |
316 return -1; | |
317 | |
318 default: | |
319 av_log(avccontext, AV_LOG_ERROR, "Unknown Dirac Encoder state\n"); | |
320 return -1; | |
321 } | |
322 } | |
323 | |
324 /* copy 'next' frame in queue */ | |
325 p_next_output_frame = | |
326 ff_dirac_schro_queue_pop(&p_dirac_params->enc_frame_queue); | |
327 | |
328 if (p_next_output_frame == NULL) | |
329 return 0; | |
330 | |
331 memcpy(frame, p_next_output_frame->p_encbuf, p_next_output_frame->size); | |
332 avccontext->coded_frame->key_frame = p_next_output_frame->key_frame; | |
333 /* Use the frame number of the encoded frame as the pts. It is OK to do | |
334 * so since Dirac is a constant framerate codec. It expects input to be | |
335 * of constant framerate. */ | |
336 avccontext->coded_frame->pts = p_next_output_frame->frame_num; | |
337 enc_size = p_next_output_frame->size; | |
338 | |
339 /* free frame */ | |
340 DiracFreeFrame(p_next_output_frame); | |
341 | |
342 return enc_size; | |
343 } | |
344 | |
345 static int libdirac_encode_close(AVCodecContext *avccontext) | |
346 { | |
347 FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data; | |
348 | |
349 /* close the encoder */ | |
350 dirac_encoder_close(p_dirac_params->p_encoder ); | |
351 | |
352 /* free data in the output frame queue */ | |
353 ff_dirac_schro_queue_free(&p_dirac_params->enc_frame_queue, | |
354 DiracFreeFrame); | |
355 | |
356 /* free the input frame buffer */ | |
357 av_freep(&p_dirac_params->p_in_frame_buf); | |
358 | |
359 return 0 ; | |
360 } | |
361 | |
362 | |
363 AVCodec libdirac_encoder = { | |
364 "libdirac", | |
365 CODEC_TYPE_VIDEO, | |
366 CODEC_ID_DIRAC, | |
367 sizeof(FfmpegDiracEncoderParams), | |
368 libdirac_encode_init, | |
369 libdirac_encode_frame, | |
370 libdirac_encode_close, | |
371 .capabilities= CODEC_CAP_DELAY, | |
372 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, -1}, | |
6819
43bede126ef6
missing codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6734
diff
changeset
|
373 .long_name= "libdirac Dirac 2.2", |
6734 | 374 } ; |