Mercurial > libavcodec.hg
annotate mpegvideo_enc.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | b6cf19580e47 |
children | 04e68eb1aab7 |
rev | line source |
---|---|
5204 | 1 /* |
2 * The simplest mpeg encoder (well, it was the simplest!) | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8611
diff
changeset
|
3 * Copyright (c) 2000,2001 Fabrice Bellard |
5204 | 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
5 * | |
5214 | 6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> |
7 * | |
5204 | 8 * This file is part of FFmpeg. |
9 * | |
10 * FFmpeg is free software; you can redistribute it and/or | |
11 * modify it under the terms of the GNU Lesser General Public | |
12 * License as published by the Free Software Foundation; either | |
13 * version 2.1 of the License, or (at your option) any later version. | |
14 * | |
15 * FFmpeg is distributed in the hope that it will be useful, | |
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
18 * Lesser General Public License for more details. | |
19 * | |
20 * You should have received a copy of the GNU Lesser General Public | |
21 * License along with FFmpeg; if not, write to the Free Software | |
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
23 */ | |
24 | |
25 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
26 * @file |
5204 | 27 * The simplest mpeg encoder (well, it was the simplest!). |
28 */ | |
29 | |
11417 | 30 #include "libavutil/intmath.h" |
5204 | 31 #include "avcodec.h" |
32 #include "dsputil.h" | |
33 #include "mpegvideo.h" | |
34 #include "mpegvideo_common.h" | |
10832
f20726a6d538
Add a function to match a 2 element vector of uint16_t and use it in h263 and svq1
michael
parents:
10803
diff
changeset
|
35 #include "h263.h" |
5204 | 36 #include "mjpegenc.h" |
37 #include "msmpeg4.h" | |
38 #include "faandct.h" | |
8218
03054192daac
Move aanscales tables to their own file; fixes compilation without encoders.
diego
parents:
8217
diff
changeset
|
39 #include "aandcttab.h" |
10787 | 40 #include "flv.h" |
10803 | 41 #include "mpeg4video.h" |
10843
f6afc7837f83
Add missing internal.h to files calling ff_match_2uint16().
astrange
parents:
10832
diff
changeset
|
42 #include "internal.h" |
5204 | 43 #include <limits.h> |
44 | |
45 //#undef NDEBUG | |
46 //#include <assert.h> | |
47 | |
48 static int encode_picture(MpegEncContext *s, int picture_number); | |
49 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); | |
50 static int sse_mb(MpegEncContext *s); | |
51 | |
52 /* enable all paranoid tests for rounding, overflows, etc... */ | |
53 //#define PARANOID | |
54 | |
55 //#define DEBUG | |
56 | |
57 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; | |
58 static uint8_t default_fcode_tab[MAX_MV*2+1]; | |
59 | |
5789 | 60 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], |
5204 | 61 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) |
62 { | |
63 int qscale; | |
64 int shift=0; | |
65 | |
66 for(qscale=qmin; qscale<=qmax; qscale++){ | |
67 int i; | |
68 if (dsp->fdct == ff_jpeg_fdct_islow | |
69 #ifdef FAAN_POSTSCALE | |
70 || dsp->fdct == ff_faandct | |
71 #endif | |
72 ) { | |
73 for(i=0;i<64;i++) { | |
74 const int j= dsp->idct_permutation[i]; | |
75 /* 16 <= qscale * quant_matrix[i] <= 7905 */ | |
8217
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
76 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
77 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1 << 36) / 249205026 */ |
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
78 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
5204 | 79 |
80 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / | |
81 (qscale * quant_matrix[j])); | |
82 } | |
83 } else if (dsp->fdct == fdct_ifast | |
84 #ifndef FAAN_POSTSCALE | |
85 || dsp->fdct == ff_faandct | |
86 #endif | |
87 ) { | |
88 for(i=0;i<64;i++) { | |
89 const int j= dsp->idct_permutation[i]; | |
90 /* 16 <= qscale * quant_matrix[i] <= 7905 */ | |
8217
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
91 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ |
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
92 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ |
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
93 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */ |
5204 | 94 |
95 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / | |
8217
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
96 (ff_aanscales[i] * qscale * quant_matrix[j])); |
5204 | 97 } |
98 } else { | |
99 for(i=0;i<64;i++) { | |
100 const int j= dsp->idct_permutation[i]; | |
101 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 | |
102 So 16 <= qscale * quant_matrix[i] <= 7905 | |
103 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 | |
104 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 | |
105 */ | |
106 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); | |
107 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); | |
108 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]); | |
109 | |
110 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1; | |
111 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); | |
112 } | |
113 } | |
114 | |
115 for(i=intra; i<64; i++){ | |
116 int64_t max= 8191; | |
117 if (dsp->fdct == fdct_ifast | |
118 #ifndef FAAN_POSTSCALE | |
119 || dsp->fdct == ff_faandct | |
120 #endif | |
121 ) { | |
8217
f88ab1c3e333
cosmetics: Rename aanscales to ff_aanscales, it will soon be externally visible.
diego
parents:
8129
diff
changeset
|
122 max = (8191LL*ff_aanscales[i]) >> 14; |
5204 | 123 } |
124 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ | |
125 shift++; | |
126 } | |
127 } | |
128 } | |
129 if(shift){ | |
130 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift); | |
131 } | |
132 } | |
133 | |
134 static inline void update_qscale(MpegEncContext *s){ | |
135 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); | |
136 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax); | |
137 | |
138 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; | |
139 } | |
140 | |
141 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ | |
142 int i; | |
143 | |
144 if(matrix){ | |
145 put_bits(pb, 1, 1); | |
146 for(i=0;i<64;i++) { | |
147 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); | |
148 } | |
149 }else | |
150 put_bits(pb, 1, 0); | |
151 } | |
152 | |
10636
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
153 /** |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
154 * init s->current_picture.qscale_table from s->lambda_table |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
155 */ |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
156 void ff_init_qscale_tab(MpegEncContext *s){ |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
157 int8_t * const qscale_table= s->current_picture.qscale_table; |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
158 int i; |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
159 |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
160 for(i=0; i<s->mb_num; i++){ |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
161 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ]; |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
162 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
163 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax); |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
164 } |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
165 } |
703cfed31320
Move ff_init_qscale_tab() from h263.c to mpegvideo, the function is not h263 specific.
michael
parents:
10443
diff
changeset
|
166 |
5204 | 167 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){ |
168 int i; | |
169 | |
170 dst->pict_type = src->pict_type; | |
171 dst->quality = src->quality; | |
172 dst->coded_picture_number = src->coded_picture_number; | |
173 dst->display_picture_number = src->display_picture_number; | |
174 // dst->reference = src->reference; | |
175 dst->pts = src->pts; | |
176 dst->interlaced_frame = src->interlaced_frame; | |
177 dst->top_field_first = src->top_field_first; | |
178 | |
179 if(s->avctx->me_threshold){ | |
180 if(!src->motion_val[0]) | |
181 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n"); | |
182 if(!src->mb_type) | |
183 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n"); | |
184 if(!src->ref_index[0]) | |
185 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n"); | |
186 if(src->motion_subsample_log2 != dst->motion_subsample_log2) | |
187 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n", | |
188 src->motion_subsample_log2, dst->motion_subsample_log2); | |
189 | |
190 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); | |
191 | |
192 for(i=0; i<2; i++){ | |
193 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1; | |
194 int height= ((16*s->mb_height)>>src->motion_subsample_log2); | |
195 | |
196 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){ | |
197 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t)); | |
198 } | |
199 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ | |
11531
31033caa5344
Change ref_index structure so it matches how its organized in h264.
michael
parents:
11495
diff
changeset
|
200 memcpy(dst->ref_index[i], src->ref_index[i], s->mb_stride*4*s->mb_height*sizeof(int8_t)); |
5204 | 201 } |
202 } | |
203 } | |
204 } | |
205 | |
206 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ | |
207 #define COPY(a) dst->a= src->a | |
208 COPY(pict_type); | |
209 COPY(current_picture); | |
210 COPY(f_code); | |
211 COPY(b_code); | |
212 COPY(qscale); | |
213 COPY(lambda); | |
214 COPY(lambda2); | |
215 COPY(picture_in_gop_number); | |
216 COPY(gop_picture_number); | |
217 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header | |
218 COPY(progressive_frame); //FIXME don't set in encode_header | |
219 COPY(partitioned_frame); //FIXME don't set in encode_header | |
220 #undef COPY | |
221 } | |
222 | |
223 /** | |
224 * sets the given MpegEncContext to defaults for encoding. | |
225 * the changed fields will not depend upon the prior state of the MpegEncContext. | |
226 */ | |
227 static void MPV_encode_defaults(MpegEncContext *s){ | |
228 int i; | |
229 MPV_common_defaults(s); | |
230 | |
231 for(i=-16; i<16; i++){ | |
232 default_fcode_tab[i + MAX_MV]= 1; | |
233 } | |
234 s->me.mv_penalty= default_mv_penalty; | |
235 s->fcode_tab= default_fcode_tab; | |
236 } | |
237 | |
238 /* init video encoder */ | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6497
diff
changeset
|
239 av_cold int MPV_encode_init(AVCodecContext *avctx) |
5204 | 240 { |
241 MpegEncContext *s = avctx->priv_data; | |
242 int i; | |
243 int chroma_h_shift, chroma_v_shift; | |
244 | |
245 MPV_encode_defaults(s); | |
246 | |
247 switch (avctx->codec_id) { | |
248 case CODEC_ID_MPEG2VIDEO: | |
249 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ | |
250 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); | |
251 return -1; | |
252 } | |
253 break; | |
254 case CODEC_ID_LJPEG: | |
255 case CODEC_ID_MJPEG: | |
8807 | 256 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && avctx->pix_fmt != PIX_FMT_RGB32 && |
12084
b6cf19580e47
Change all occurences of "inofficial" to "unofficial" in code, comments
cehoyos
parents:
11644
diff
changeset
|
257 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_UNOFFICIAL)){ |
5204 | 258 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); |
259 return -1; | |
260 } | |
261 break; | |
262 default: | |
263 if(avctx->pix_fmt != PIX_FMT_YUV420P){ | |
264 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); | |
265 return -1; | |
266 } | |
267 } | |
268 | |
269 switch (avctx->pix_fmt) { | |
270 case PIX_FMT_YUVJ422P: | |
271 case PIX_FMT_YUV422P: | |
272 s->chroma_format = CHROMA_422; | |
273 break; | |
274 case PIX_FMT_YUVJ420P: | |
275 case PIX_FMT_YUV420P: | |
276 default: | |
277 s->chroma_format = CHROMA_420; | |
278 break; | |
279 } | |
280 | |
281 s->bit_rate = avctx->bit_rate; | |
282 s->width = avctx->width; | |
283 s->height = avctx->height; | |
284 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ | |
285 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); | |
286 avctx->gop_size=600; | |
287 } | |
288 s->gop_size = avctx->gop_size; | |
289 s->avctx = avctx; | |
290 s->flags= avctx->flags; | |
291 s->flags2= avctx->flags2; | |
292 s->max_b_frames= avctx->max_b_frames; | |
293 s->codec_id= avctx->codec->id; | |
294 s->luma_elim_threshold = avctx->luma_elim_threshold; | |
295 s->chroma_elim_threshold= avctx->chroma_elim_threshold; | |
296 s->strict_std_compliance= avctx->strict_std_compliance; | |
297 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; | |
298 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; | |
299 s->mpeg_quant= avctx->mpeg_quant; | |
300 s->rtp_mode= !!avctx->rtp_payload_size; | |
301 s->intra_dc_precision= avctx->intra_dc_precision; | |
302 s->user_specified_pts = AV_NOPTS_VALUE; | |
303 | |
304 if (s->gop_size <= 1) { | |
305 s->intra_only = 1; | |
306 s->gop_size = 12; | |
307 } else { | |
308 s->intra_only = 0; | |
309 } | |
310 | |
311 s->me_method = avctx->me_method; | |
312 | |
313 /* Fixed QSCALE */ | |
314 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); | |
315 | |
316 s->adaptive_quant= ( s->avctx->lumi_masking | |
317 || s->avctx->dark_masking | |
318 || s->avctx->temporal_cplx_masking | |
319 || s->avctx->spatial_cplx_masking | |
320 || s->avctx->p_masking | |
321 || s->avctx->border_masking | |
322 || (s->flags&CODEC_FLAG_QP_RD)) | |
323 && !s->fixed_qscale; | |
324 | |
325 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); | |
326 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); | |
327 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); | |
328 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); | |
329 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT); | |
330 | |
331 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ | |
332 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); | |
333 return -1; | |
334 } | |
335 | |
336 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){ | |
337 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); | |
338 } | |
339 | |
340 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ | |
341 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n"); | |
342 return -1; | |
343 } | |
344 | |
345 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ | |
346 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); | |
347 return -1; | |
348 } | |
349 | |
5420 | 350 if(avctx->rc_max_rate && avctx->rc_max_rate == avctx->bit_rate && avctx->rc_max_rate != avctx->rc_min_rate){ |
351 av_log(avctx, AV_LOG_INFO, "impossible bitrate constraints, this will fail\n"); | |
352 } | |
353 | |
5204 | 354 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){ |
355 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n"); | |
356 return -1; | |
357 } | |
358 | |
359 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){ | |
360 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n"); | |
361 return -1; | |
362 } | |
363 | |
364 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate | |
365 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) | |
366 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ | |
367 | |
368 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n"); | |
369 } | |
370 | |
371 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 | |
372 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){ | |
373 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); | |
374 return -1; | |
375 } | |
376 | |
377 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){ | |
378 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); | |
379 return -1; | |
380 } | |
381 | |
382 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ | |
383 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); | |
384 return -1; | |
385 } | |
386 | |
387 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){ | |
388 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); | |
389 return -1; | |
390 } | |
391 | |
392 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){ | |
393 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); | |
394 return -1; | |
395 } | |
396 | |
397 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
398 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); | |
399 return -1; | |
400 } | |
401 | |
10683
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
402 if ((s->codec_id == CODEC_ID_MPEG4 || s->codec_id == CODEC_ID_H263 || |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
403 s->codec_id == CODEC_ID_H263P) && |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
404 (avctx->sample_aspect_ratio.num > 255 || avctx->sample_aspect_ratio.den > 255)) { |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
405 av_log(avctx, AV_LOG_ERROR, "Invalid pixel aspect ratio %i/%i, limit is 255/255\n", |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
406 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den); |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
407 return -1; |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
408 } |
e5fac8ac71f6
Check sample_aspect_ratio validity for mpeg4/h263/h263p encoding.
michael
parents:
10670
diff
changeset
|
409 |
5204 | 410 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) |
411 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
412 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); | |
413 return -1; | |
414 } | |
415 | |
416 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too | |
417 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); | |
418 return -1; | |
419 } | |
420 | |
7034 | 421 if((s->flags & CODEC_FLAG_CBP_RD) && !avctx->trellis){ |
5204 | 422 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n"); |
423 return -1; | |
424 } | |
425 | |
426 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ | |
427 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); | |
428 return -1; | |
429 } | |
430 | |
431 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){ | |
6486 | 432 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection are not supported yet, set threshold to 1000000000\n"); |
5204 | 433 return -1; |
434 } | |
435 | |
436 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
437 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); | |
438 return -1; | |
439 } | |
440 | |
441 if(s->flags & CODEC_FLAG_LOW_DELAY){ | |
7502 | 442 if (s->codec_id != CODEC_ID_MPEG2VIDEO){ |
443 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg2\n"); | |
5204 | 444 return -1; |
445 } | |
446 if (s->max_b_frames != 0){ | |
447 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n"); | |
448 return -1; | |
449 } | |
450 } | |
451 | |
452 if(s->q_scale_type == 1){ | |
453 if(s->codec_id != CODEC_ID_MPEG2VIDEO){ | |
454 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n"); | |
455 return -1; | |
456 } | |
457 if(avctx->qmax > 12){ | |
458 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n"); | |
459 return -1; | |
460 } | |
461 } | |
462 | |
463 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 | |
464 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO | |
465 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ | |
466 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); | |
467 return -1; | |
468 } | |
469 | |
10155 | 470 if(s->avctx->thread_count < 1){ |
471 av_log(avctx, AV_LOG_ERROR, "automatic thread number detection not supported by codec, patch welcome\n"); | |
472 return -1; | |
473 } | |
474 | |
5204 | 475 if(s->avctx->thread_count > 1) |
476 s->rtp_mode= 1; | |
477 | |
478 if(!avctx->time_base.den || !avctx->time_base.num){ | |
479 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); | |
480 return -1; | |
481 } | |
482 | |
483 i= (INT_MAX/2+128)>>8; | |
484 if(avctx->me_threshold >= i){ | |
485 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1); | |
486 return -1; | |
487 } | |
488 if(avctx->mb_threshold >= i){ | |
489 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1); | |
490 return -1; | |
491 } | |
492 | |
493 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){ | |
494 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); | |
495 avctx->b_frame_strategy = 0; | |
496 } | |
497 | |
8611 | 498 i= av_gcd(avctx->time_base.den, avctx->time_base.num); |
5204 | 499 if(i > 1){ |
500 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); | |
501 avctx->time_base.den /= i; | |
502 avctx->time_base.num /= i; | |
503 // return -1; | |
504 } | |
505 | |
11493 | 506 if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO || s->codec_id==CODEC_ID_MJPEG){ |
5204 | 507 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x |
508 s->inter_quant_bias= 0; | |
509 }else{ | |
510 s->intra_quant_bias=0; | |
511 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x | |
512 } | |
513 | |
514 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
515 s->intra_quant_bias= avctx->intra_quant_bias; | |
516 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) | |
517 s->inter_quant_bias= avctx->inter_quant_bias; | |
518 | |
519 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift); | |
520 | |
521 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ | |
522 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); | |
523 return -1; | |
524 } | |
525 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; | |
526 | |
527 switch(avctx->codec->id) { | |
528 case CODEC_ID_MPEG1VIDEO: | |
529 s->out_format = FMT_MPEG1; | |
530 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); | |
531 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); | |
532 break; | |
533 case CODEC_ID_MPEG2VIDEO: | |
534 s->out_format = FMT_MPEG1; | |
535 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); | |
536 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); | |
537 s->rtp_mode= 1; | |
538 break; | |
539 case CODEC_ID_LJPEG: | |
540 case CODEC_ID_MJPEG: | |
541 s->out_format = FMT_MJPEG; | |
542 s->intra_only = 1; /* force intra only for jpeg */ | |
10670
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
543 if(avctx->codec->id == CODEC_ID_LJPEG && avctx->pix_fmt == PIX_FMT_BGRA){ |
10665 | 544 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] = |
545 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] = | |
546 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1; | |
10670
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
547 }else{ |
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
548 s->mjpeg_vsample[0] = 2; |
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
549 s->mjpeg_vsample[1] = 2>>chroma_v_shift; |
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
550 s->mjpeg_vsample[2] = 2>>chroma_v_shift; |
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
551 s->mjpeg_hsample[0] = 2; |
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
552 s->mjpeg_hsample[1] = 2>>chroma_h_shift; |
7986ecc952e1
Cosmetic (restructure RGB ljpeg check to be more readable)
michael
parents:
10669
diff
changeset
|
553 s->mjpeg_hsample[2] = 2>>chroma_h_shift; |
10665 | 554 } |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
555 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) |
5204 | 556 || ff_mjpeg_encode_init(s) < 0) |
557 return -1; | |
558 avctx->delay=0; | |
559 s->low_delay=1; | |
560 break; | |
561 case CODEC_ID_H261: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
562 if (!CONFIG_H261_ENCODER) return -1; |
5204 | 563 if (ff_h261_get_picture_format(s->width, s->height) < 0) { |
564 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height); | |
565 return -1; | |
566 } | |
567 s->out_format = FMT_H261; | |
568 avctx->delay=0; | |
569 s->low_delay=1; | |
570 break; | |
571 case CODEC_ID_H263: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
572 if (!CONFIG_H263_ENCODER) return -1; |
10832
f20726a6d538
Add a function to match a 2 element vector of uint16_t and use it in h263 and svq1
michael
parents:
10803
diff
changeset
|
573 if (ff_match_2uint16(h263_format, FF_ARRAY_ELEMS(h263_format), s->width, s->height) == 7) { |
5204 | 574 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height); |
575 return -1; | |
576 } | |
577 s->out_format = FMT_H263; | |
578 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; | |
579 avctx->delay=0; | |
580 s->low_delay=1; | |
581 break; | |
582 case CODEC_ID_H263P: | |
583 s->out_format = FMT_H263; | |
584 s->h263_plus = 1; | |
585 /* Fx */ | |
586 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0; | |
587 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0; | |
588 s->modified_quant= s->h263_aic; | |
589 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; | |
590 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; | |
591 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; | |
592 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
593 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; | |
594 | |
595 /* /Fx */ | |
596 /* These are just to be sure */ | |
597 avctx->delay=0; | |
598 s->low_delay=1; | |
599 break; | |
600 case CODEC_ID_FLV1: | |
601 s->out_format = FMT_H263; | |
602 s->h263_flv = 2; /* format = 1; 11-bit codes */ | |
603 s->unrestricted_mv = 1; | |
604 s->rtp_mode=0; /* don't allow GOB */ | |
605 avctx->delay=0; | |
606 s->low_delay=1; | |
607 break; | |
608 case CODEC_ID_RV10: | |
609 s->out_format = FMT_H263; | |
610 avctx->delay=0; | |
611 s->low_delay=1; | |
612 break; | |
613 case CODEC_ID_RV20: | |
614 s->out_format = FMT_H263; | |
615 avctx->delay=0; | |
616 s->low_delay=1; | |
617 s->modified_quant=1; | |
618 s->h263_aic=1; | |
619 s->h263_plus=1; | |
620 s->loop_filter=1; | |
621 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; | |
622 break; | |
623 case CODEC_ID_MPEG4: | |
624 s->out_format = FMT_H263; | |
625 s->h263_pred = 1; | |
626 s->unrestricted_mv = 1; | |
627 s->low_delay= s->max_b_frames ? 0 : 1; | |
628 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); | |
629 break; | |
630 case CODEC_ID_MSMPEG4V1: | |
631 s->out_format = FMT_H263; | |
632 s->h263_msmpeg4 = 1; | |
633 s->h263_pred = 1; | |
634 s->unrestricted_mv = 1; | |
635 s->msmpeg4_version= 1; | |
636 avctx->delay=0; | |
637 s->low_delay=1; | |
638 break; | |
639 case CODEC_ID_MSMPEG4V2: | |
640 s->out_format = FMT_H263; | |
641 s->h263_msmpeg4 = 1; | |
642 s->h263_pred = 1; | |
643 s->unrestricted_mv = 1; | |
644 s->msmpeg4_version= 2; | |
645 avctx->delay=0; | |
646 s->low_delay=1; | |
647 break; | |
648 case CODEC_ID_MSMPEG4V3: | |
649 s->out_format = FMT_H263; | |
650 s->h263_msmpeg4 = 1; | |
651 s->h263_pred = 1; | |
652 s->unrestricted_mv = 1; | |
653 s->msmpeg4_version= 3; | |
654 s->flipflop_rounding=1; | |
655 avctx->delay=0; | |
656 s->low_delay=1; | |
657 break; | |
658 case CODEC_ID_WMV1: | |
659 s->out_format = FMT_H263; | |
660 s->h263_msmpeg4 = 1; | |
661 s->h263_pred = 1; | |
662 s->unrestricted_mv = 1; | |
663 s->msmpeg4_version= 4; | |
664 s->flipflop_rounding=1; | |
665 avctx->delay=0; | |
666 s->low_delay=1; | |
667 break; | |
668 case CODEC_ID_WMV2: | |
669 s->out_format = FMT_H263; | |
670 s->h263_msmpeg4 = 1; | |
671 s->h263_pred = 1; | |
672 s->unrestricted_mv = 1; | |
673 s->msmpeg4_version= 5; | |
674 s->flipflop_rounding=1; | |
675 avctx->delay=0; | |
676 s->low_delay=1; | |
677 break; | |
678 default: | |
679 return -1; | |
680 } | |
681 | |
682 avctx->has_b_frames= !s->low_delay; | |
683 | |
684 s->encoding = 1; | |
685 | |
9690
cc0380d2bbc3
Set progressive_sequence before MPV_common_init which cares about it when
bcoudurier
parents:
9638
diff
changeset
|
686 s->progressive_frame= |
cc0380d2bbc3
Set progressive_sequence before MPV_common_init which cares about it when
bcoudurier
parents:
9638
diff
changeset
|
687 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)); |
cc0380d2bbc3
Set progressive_sequence before MPV_common_init which cares about it when
bcoudurier
parents:
9638
diff
changeset
|
688 |
5204 | 689 /* init */ |
690 if (MPV_common_init(s) < 0) | |
691 return -1; | |
692 | |
5211
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
693 if(!s->dct_quantize) |
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
694 s->dct_quantize = dct_quantize_c; |
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
695 if(!s->denoise_dct) |
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
696 s->denoise_dct = denoise_dct_c; |
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
697 s->fast_dct_quantize = s->dct_quantize; |
7034 | 698 if(avctx->trellis) |
5211
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
699 s->dct_quantize = dct_quantize_trellis_c; |
413c5e2eff68
move mpeg encoder specific initialization in the encoder specific file
aurel
parents:
5209
diff
changeset
|
700 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
701 if((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant) |
5204 | 702 s->chroma_qscale_table= ff_h263_chroma_qscale_table; |
9690
cc0380d2bbc3
Set progressive_sequence before MPV_common_init which cares about it when
bcoudurier
parents:
9638
diff
changeset
|
703 |
5204 | 704 s->quant_precision=5; |
705 | |
706 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); | |
707 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); | |
708 | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
709 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261) |
5204 | 710 ff_h261_encode_init(s); |
10727
47e1e474e1f1
Replace CONFIG_ANY_H263_ENCODER definition by CONFIG_H263_ENCODER.
diego
parents:
10683
diff
changeset
|
711 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263) |
5204 | 712 h263_encode_init(s); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
713 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version) |
5204 | 714 ff_msmpeg4_encode_init(s); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
715 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) |
5208 | 716 && s->out_format == FMT_MPEG1) |
5204 | 717 ff_mpeg1_encode_init(s); |
718 | |
719 /* init q matrix */ | |
720 for(i=0;i<64;i++) { | |
721 int j= s->dsp.idct_permutation[i]; | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
722 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){ |
5204 | 723 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i]; |
724 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i]; | |
725 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ | |
726 s->intra_matrix[j] = | |
727 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; | |
728 }else | |
729 { /* mpeg1/2 */ | |
730 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i]; | |
731 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; | |
732 } | |
733 if(s->avctx->intra_matrix) | |
734 s->intra_matrix[j] = s->avctx->intra_matrix[i]; | |
735 if(s->avctx->inter_matrix) | |
736 s->inter_matrix[j] = s->avctx->inter_matrix[i]; | |
737 } | |
738 | |
739 /* precompute matrix */ | |
740 /* for mjpeg, we do include qscale in the matrix */ | |
741 if (s->out_format != FMT_MJPEG) { | |
5789 | 742 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, |
5204 | 743 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); |
5789 | 744 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, |
5204 | 745 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); |
746 } | |
747 | |
748 if(ff_rate_control_init(s) < 0) | |
749 return -1; | |
750 | |
751 return 0; | |
752 } | |
753 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6497
diff
changeset
|
754 av_cold int MPV_encode_end(AVCodecContext *avctx) |
5204 | 755 { |
756 MpegEncContext *s = avctx->priv_data; | |
757 | |
758 ff_rate_control_uninit(s); | |
759 | |
760 MPV_common_end(s); | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
761 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) && s->out_format == FMT_MJPEG) |
5204 | 762 ff_mjpeg_encode_close(s); |
763 | |
764 av_freep(&avctx->extradata); | |
765 | |
766 return 0; | |
767 } | |
768 | |
769 static int get_sae(uint8_t *src, int ref, int stride){ | |
770 int x,y; | |
771 int acc=0; | |
772 | |
773 for(y=0; y<16; y++){ | |
774 for(x=0; x<16; x++){ | |
775 acc+= FFABS(src[x+y*stride] - ref); | |
776 } | |
777 } | |
778 | |
779 return acc; | |
780 } | |
781 | |
782 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ | |
783 int x, y, w, h; | |
784 int acc=0; | |
785 | |
786 w= s->width &~15; | |
787 h= s->height&~15; | |
788 | |
789 for(y=0; y<h; y+=16){ | |
790 for(x=0; x<w; x+=16){ | |
791 int offset= x + y*stride; | |
792 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); | |
793 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; | |
794 int sae = get_sae(src + offset, mean, stride); | |
795 | |
796 acc+= sae + 500 < sad; | |
797 } | |
798 } | |
799 return acc; | |
800 } | |
801 | |
802 | |
803 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ | |
804 AVFrame *pic=NULL; | |
805 int64_t pts; | |
806 int i; | |
807 const int encoding_delay= s->max_b_frames; | |
808 int direct=1; | |
809 | |
810 if(pic_arg){ | |
811 pts= pic_arg->pts; | |
812 pic_arg->display_picture_number= s->input_picture_number++; | |
813 | |
814 if(pts != AV_NOPTS_VALUE){ | |
815 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
816 int64_t time= pts; | |
817 int64_t last= s->user_specified_pts; | |
818 | |
819 if(time <= last){ | |
820 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); | |
821 return -1; | |
822 } | |
823 } | |
824 s->user_specified_pts= pts; | |
825 }else{ | |
826 if(s->user_specified_pts != AV_NOPTS_VALUE){ | |
827 s->user_specified_pts= | |
828 pts= s->user_specified_pts + 1; | |
829 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); | |
830 }else{ | |
831 pts= pic_arg->display_picture_number; | |
832 } | |
833 } | |
834 } | |
835 | |
836 if(pic_arg){ | |
837 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; | |
838 if(pic_arg->linesize[0] != s->linesize) direct=0; | |
839 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; | |
840 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; | |
841 | |
842 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); | |
843 | |
844 if(direct){ | |
845 i= ff_find_unused_picture(s, 1); | |
846 | |
847 pic= (AVFrame*)&s->picture[i]; | |
848 pic->reference= 3; | |
849 | |
850 for(i=0; i<4; i++){ | |
851 pic->data[i]= pic_arg->data[i]; | |
852 pic->linesize[i]= pic_arg->linesize[i]; | |
853 } | |
11534 | 854 if(ff_alloc_picture(s, (Picture*)pic, 1) < 0){ |
855 return -1; | |
856 } | |
5204 | 857 }else{ |
858 i= ff_find_unused_picture(s, 0); | |
859 | |
860 pic= (AVFrame*)&s->picture[i]; | |
861 pic->reference= 3; | |
862 | |
11534 | 863 if(ff_alloc_picture(s, (Picture*)pic, 0) < 0){ |
864 return -1; | |
865 } | |
5204 | 866 |
867 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] | |
868 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] | |
869 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ | |
870 // empty | |
871 }else{ | |
872 int h_chroma_shift, v_chroma_shift; | |
873 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
874 | |
875 for(i=0; i<3; i++){ | |
876 int src_stride= pic_arg->linesize[i]; | |
877 int dst_stride= i ? s->uvlinesize : s->linesize; | |
878 int h_shift= i ? h_chroma_shift : 0; | |
879 int v_shift= i ? v_chroma_shift : 0; | |
880 int w= s->width >>h_shift; | |
881 int h= s->height>>v_shift; | |
882 uint8_t *src= pic_arg->data[i]; | |
883 uint8_t *dst= pic->data[i]; | |
884 | |
885 if(!s->avctx->rc_buffer_size) | |
886 dst +=INPLACE_OFFSET; | |
887 | |
888 if(src_stride==dst_stride) | |
889 memcpy(dst, src, src_stride*h); | |
890 else{ | |
891 while(h--){ | |
892 memcpy(dst, src, w); | |
893 dst += dst_stride; | |
894 src += src_stride; | |
895 } | |
896 } | |
897 } | |
898 } | |
899 } | |
900 copy_picture_attributes(s, pic, pic_arg); | |
901 pic->pts= pts; //we set this here to avoid modifiying pic_arg | |
902 } | |
903 | |
904 /* shift buffer entries */ | |
905 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) | |
906 s->input_picture[i-1]= s->input_picture[i]; | |
907 | |
908 s->input_picture[encoding_delay]= (Picture*)pic; | |
909 | |
910 return 0; | |
911 } | |
912 | |
913 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ | |
914 int x, y, plane; | |
915 int score=0; | |
916 int64_t score64=0; | |
917 | |
918 for(plane=0; plane<3; plane++){ | |
919 const int stride= p->linesize[plane]; | |
920 const int bw= plane ? 1 : 2; | |
921 for(y=0; y<s->mb_height*bw; y++){ | |
922 for(x=0; x<s->mb_width*bw; x++){ | |
923 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; | |
924 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8); | |
925 | |
926 switch(s->avctx->frame_skip_exp){ | |
927 case 0: score= FFMAX(score, v); break; | |
928 case 1: score+= FFABS(v);break; | |
929 case 2: score+= v*v;break; | |
930 case 3: score64+= FFABS(v*v*(int64_t)v);break; | |
931 case 4: score64+= v*v*(int64_t)(v*v);break; | |
932 } | |
933 } | |
934 } | |
935 } | |
936 | |
937 if(score) score64= score; | |
938 | |
939 if(score64 < s->avctx->frame_skip_threshold) | |
940 return 1; | |
941 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) | |
942 return 1; | |
943 return 0; | |
944 } | |
945 | |
946 static int estimate_best_b_count(MpegEncContext *s){ | |
947 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); | |
948 AVCodecContext *c= avcodec_alloc_context(); | |
949 AVFrame input[FF_MAX_B_FRAMES+2]; | |
950 const int scale= s->avctx->brd_scale; | |
951 int i, j, out_size, p_lambda, b_lambda, lambda2; | |
952 int outbuf_size= s->width * s->height; //FIXME | |
953 uint8_t *outbuf= av_malloc(outbuf_size); | |
954 int64_t best_rd= INT64_MAX; | |
955 int best_b_count= -1; | |
956 | |
957 assert(scale>=0 && scale <=3); | |
958 | |
959 // emms_c(); | |
6481 | 960 p_lambda= s->last_lambda_for[FF_P_TYPE]; //s->next_picture_ptr->quality; |
961 b_lambda= s->last_lambda_for[FF_B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; | |
5204 | 962 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else |
963 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; | |
964 | |
965 c->width = s->width >> scale; | |
966 c->height= s->height>> scale; | |
967 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; | |
968 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; | |
969 c->mb_decision= s->avctx->mb_decision; | |
970 c->me_cmp= s->avctx->me_cmp; | |
971 c->mb_cmp= s->avctx->mb_cmp; | |
972 c->me_sub_cmp= s->avctx->me_sub_cmp; | |
973 c->pix_fmt = PIX_FMT_YUV420P; | |
974 c->time_base= s->avctx->time_base; | |
975 c->max_b_frames= s->max_b_frames; | |
976 | |
977 if (avcodec_open(c, codec) < 0) | |
978 return -1; | |
979 | |
980 for(i=0; i<s->max_b_frames+2; i++){ | |
981 int ysize= c->width*c->height; | |
982 int csize= (c->width/2)*(c->height/2); | |
983 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; | |
984 | |
985 avcodec_get_frame_defaults(&input[i]); | |
986 input[i].data[0]= av_malloc(ysize + 2*csize); | |
987 input[i].data[1]= input[i].data[0] + ysize; | |
988 input[i].data[2]= input[i].data[1] + csize; | |
989 input[i].linesize[0]= c->width; | |
990 input[i].linesize[1]= | |
991 input[i].linesize[2]= c->width/2; | |
992 | |
993 if(pre_input_ptr && (!i || s->input_picture[i-1])) { | |
994 pre_input= *pre_input_ptr; | |
995 | |
996 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) { | |
997 pre_input.data[0]+=INPLACE_OFFSET; | |
998 pre_input.data[1]+=INPLACE_OFFSET; | |
999 pre_input.data[2]+=INPLACE_OFFSET; | |
1000 } | |
1001 | |
1002 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); | |
1003 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1); | |
1004 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1); | |
1005 } | |
1006 } | |
1007 | |
1008 for(j=0; j<s->max_b_frames+1; j++){ | |
1009 int64_t rd=0; | |
1010 | |
1011 if(!s->input_picture[j]) | |
1012 break; | |
1013 | |
1014 c->error[0]= c->error[1]= c->error[2]= 0; | |
1015 | |
6481 | 1016 input[0].pict_type= FF_I_TYPE; |
5204 | 1017 input[0].quality= 1 * FF_QP2LAMBDA; |
1018 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); | |
1019 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; | |
1020 | |
1021 for(i=0; i<s->max_b_frames+1; i++){ | |
1022 int is_p= i % (j+1) == j || i==s->max_b_frames; | |
1023 | |
6481 | 1024 input[i+1].pict_type= is_p ? FF_P_TYPE : FF_B_TYPE; |
5204 | 1025 input[i+1].quality= is_p ? p_lambda : b_lambda; |
1026 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); | |
1027 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); | |
1028 } | |
1029 | |
1030 /* get the delayed frames */ | |
1031 while(out_size){ | |
1032 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); | |
1033 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); | |
1034 } | |
1035 | |
1036 rd += c->error[0] + c->error[1] + c->error[2]; | |
1037 | |
1038 if(rd < best_rd){ | |
1039 best_rd= rd; | |
1040 best_b_count= j; | |
1041 } | |
1042 } | |
1043 | |
1044 av_freep(&outbuf); | |
1045 avcodec_close(c); | |
1046 av_freep(&c); | |
1047 | |
1048 for(i=0; i<s->max_b_frames+2; i++){ | |
1049 av_freep(&input[i].data[0]); | |
1050 } | |
1051 | |
1052 return best_b_count; | |
1053 } | |
1054 | |
11534 | 1055 static int select_input_picture(MpegEncContext *s){ |
5204 | 1056 int i; |
1057 | |
1058 for(i=1; i<MAX_PICTURE_COUNT; i++) | |
1059 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; | |
1060 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; | |
1061 | |
1062 /* set next picture type & ordering */ | |
1063 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ | |
1064 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ | |
1065 s->reordered_input_picture[0]= s->input_picture[0]; | |
6481 | 1066 s->reordered_input_picture[0]->pict_type= FF_I_TYPE; |
5204 | 1067 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
1068 }else{ | |
1069 int b_frames; | |
1070 | |
1071 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ | |
1072 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ | |
1073 //FIXME check that te gop check above is +-1 correct | |
1074 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); | |
1075 | |
1076 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ | |
1077 for(i=0; i<4; i++) | |
1078 s->input_picture[0]->data[i]= NULL; | |
1079 s->input_picture[0]->type= 0; | |
1080 }else{ | |
1081 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER | |
1082 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); | |
1083 | |
1084 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); | |
1085 } | |
1086 | |
1087 emms_c(); | |
1088 ff_vbv_update(s, 0); | |
1089 | |
1090 goto no_output_pic; | |
1091 } | |
1092 } | |
1093 | |
1094 if(s->flags&CODEC_FLAG_PASS2){ | |
1095 for(i=0; i<s->max_b_frames+1; i++){ | |
1096 int pict_num= s->input_picture[0]->display_picture_number + i; | |
1097 | |
1098 if(pict_num >= s->rc_context.num_entries) | |
1099 break; | |
1100 if(!s->input_picture[i]){ | |
6481 | 1101 s->rc_context.entry[pict_num-1].new_pict_type = FF_P_TYPE; |
5204 | 1102 break; |
1103 } | |
1104 | |
1105 s->input_picture[i]->pict_type= | |
1106 s->rc_context.entry[pict_num].new_pict_type; | |
1107 } | |
1108 } | |
1109 | |
1110 if(s->avctx->b_frame_strategy==0){ | |
1111 b_frames= s->max_b_frames; | |
1112 while(b_frames && !s->input_picture[b_frames]) b_frames--; | |
1113 }else if(s->avctx->b_frame_strategy==1){ | |
1114 for(i=1; i<s->max_b_frames+1; i++){ | |
1115 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ | |
1116 s->input_picture[i]->b_frame_score= | |
1117 get_intra_count(s, s->input_picture[i ]->data[0], | |
1118 s->input_picture[i-1]->data[0], s->linesize) + 1; | |
1119 } | |
1120 } | |
1121 for(i=0; i<s->max_b_frames+1; i++){ | |
1122 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; | |
1123 } | |
1124 | |
1125 b_frames= FFMAX(0, i-1); | |
1126 | |
1127 /* reset scores */ | |
1128 for(i=0; i<b_frames+1; i++){ | |
1129 s->input_picture[i]->b_frame_score=0; | |
1130 } | |
1131 }else if(s->avctx->b_frame_strategy==2){ | |
1132 b_frames= estimate_best_b_count(s); | |
1133 }else{ | |
1134 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); | |
1135 b_frames=0; | |
1136 } | |
1137 | |
1138 emms_c(); | |
1139 //static int b_count=0; | |
1140 //b_count+= b_frames; | |
1141 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); | |
1142 | |
1143 for(i= b_frames - 1; i>=0; i--){ | |
1144 int type= s->input_picture[i]->pict_type; | |
6481 | 1145 if(type && type != FF_B_TYPE) |
5204 | 1146 b_frames= i; |
1147 } | |
6481 | 1148 if(s->input_picture[b_frames]->pict_type == FF_B_TYPE && b_frames == s->max_b_frames){ |
5204 | 1149 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); |
1150 } | |
1151 | |
1152 if(s->picture_in_gop_number + b_frames >= s->gop_size){ | |
1153 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ | |
1154 b_frames= s->gop_size - s->picture_in_gop_number - 1; | |
1155 }else{ | |
1156 if(s->flags & CODEC_FLAG_CLOSED_GOP) | |
1157 b_frames=0; | |
6481 | 1158 s->input_picture[b_frames]->pict_type= FF_I_TYPE; |
5204 | 1159 } |
1160 } | |
1161 | |
1162 if( (s->flags & CODEC_FLAG_CLOSED_GOP) | |
1163 && b_frames | |
6481 | 1164 && s->input_picture[b_frames]->pict_type== FF_I_TYPE) |
5204 | 1165 b_frames--; |
1166 | |
1167 s->reordered_input_picture[0]= s->input_picture[b_frames]; | |
6481 | 1168 if(s->reordered_input_picture[0]->pict_type != FF_I_TYPE) |
1169 s->reordered_input_picture[0]->pict_type= FF_P_TYPE; | |
5204 | 1170 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; |
1171 for(i=0; i<b_frames; i++){ | |
1172 s->reordered_input_picture[i+1]= s->input_picture[i]; | |
6481 | 1173 s->reordered_input_picture[i+1]->pict_type= FF_B_TYPE; |
5204 | 1174 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; |
1175 } | |
1176 } | |
1177 } | |
1178 no_output_pic: | |
1179 if(s->reordered_input_picture[0]){ | |
6481 | 1180 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=FF_B_TYPE ? 3 : 0; |
5204 | 1181 |
7974 | 1182 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]); |
5204 | 1183 |
1184 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ | |
1185 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable | |
1186 | |
1187 int i= ff_find_unused_picture(s, 0); | |
1188 Picture *pic= &s->picture[i]; | |
1189 | |
1190 pic->reference = s->reordered_input_picture[0]->reference; | |
11534 | 1191 if(ff_alloc_picture(s, pic, 0) < 0){ |
1192 return -1; | |
1193 } | |
5204 | 1194 |
1195 /* mark us unused / free shared pic */ | |
1196 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL) | |
1197 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); | |
1198 for(i=0; i<4; i++) | |
1199 s->reordered_input_picture[0]->data[i]= NULL; | |
1200 s->reordered_input_picture[0]->type= 0; | |
1201 | |
1202 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]); | |
1203 | |
1204 s->current_picture_ptr= pic; | |
1205 }else{ | |
1206 // input is not a shared pix -> reuse buffer for current_pix | |
1207 | |
1208 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER | |
1209 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); | |
1210 | |
1211 s->current_picture_ptr= s->reordered_input_picture[0]; | |
1212 for(i=0; i<4; i++){ | |
1213 s->new_picture.data[i]+= INPLACE_OFFSET; | |
1214 } | |
1215 } | |
7974 | 1216 ff_copy_picture(&s->current_picture, s->current_picture_ptr); |
5204 | 1217 |
1218 s->picture_number= s->new_picture.display_picture_number; | |
1219 //printf("dpn:%d\n", s->picture_number); | |
1220 }else{ | |
1221 memset(&s->new_picture, 0, sizeof(Picture)); | |
1222 } | |
11534 | 1223 return 0; |
5204 | 1224 } |
1225 | |
1226 int MPV_encode_picture(AVCodecContext *avctx, | |
1227 unsigned char *buf, int buf_size, void *data) | |
1228 { | |
1229 MpegEncContext *s = avctx->priv_data; | |
1230 AVFrame *pic_arg = data; | |
1231 int i, stuffing_count; | |
1232 | |
1233 for(i=0; i<avctx->thread_count; i++){ | |
1234 int start_y= s->thread_context[i]->start_mb_y; | |
1235 int end_y= s->thread_context[i]-> end_mb_y; | |
1236 int h= s->mb_height; | |
1237 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h); | |
1238 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); | |
1239 | |
1240 init_put_bits(&s->thread_context[i]->pb, start, end - start); | |
1241 } | |
1242 | |
1243 s->picture_in_gop_number++; | |
1244 | |
1245 if(load_input_picture(s, pic_arg) < 0) | |
1246 return -1; | |
1247 | |
11534 | 1248 if(select_input_picture(s) < 0){ |
1249 return -1; | |
1250 } | |
5204 | 1251 |
1252 /* output? */ | |
1253 if(s->new_picture.data[0]){ | |
1254 s->pict_type= s->new_picture.pict_type; | |
1255 //emms_c(); | |
1256 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); | |
1257 MPV_frame_start(s, avctx); | |
1258 vbv_retry: | |
1259 if (encode_picture(s, s->picture_number) < 0) | |
1260 return -1; | |
1261 | |
1262 avctx->header_bits = s->header_bits; | |
1263 avctx->mv_bits = s->mv_bits; | |
1264 avctx->misc_bits = s->misc_bits; | |
1265 avctx->i_tex_bits = s->i_tex_bits; | |
1266 avctx->p_tex_bits = s->p_tex_bits; | |
1267 avctx->i_count = s->i_count; | |
1268 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx | |
1269 avctx->skip_count = s->skip_count; | |
1270 | |
1271 MPV_frame_end(s); | |
1272 | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1273 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) |
5204 | 1274 ff_mjpeg_encode_picture_trailer(s); |
1275 | |
1276 if(avctx->rc_buffer_size){ | |
1277 RateControlContext *rcc= &s->rc_context; | |
8227 | 1278 int max_size= rcc->buffer_index * avctx->rc_max_available_vbv_use; |
5204 | 1279 |
1280 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ | |
1281 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); | |
1282 if(s->adaptive_quant){ | |
1283 int i; | |
1284 for(i=0; i<s->mb_height*s->mb_stride; i++) | |
1285 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); | |
1286 } | |
1287 s->mb_skipped = 0; //done in MPV_frame_start() | |
6481 | 1288 if(s->pict_type==FF_P_TYPE){ //done in encode_picture() so we must undo it |
5204 | 1289 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) |
1290 s->no_rounding ^= 1; | |
1291 } | |
6481 | 1292 if(s->pict_type!=FF_B_TYPE){ |
5204 | 1293 s->time_base= s->last_time_base; |
1294 s->last_non_b_time= s->time - s->pp_time; | |
1295 } | |
1296 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda); | |
1297 for(i=0; i<avctx->thread_count; i++){ | |
1298 PutBitContext *pb= &s->thread_context[i]->pb; | |
1299 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf); | |
1300 } | |
1301 goto vbv_retry; | |
1302 } | |
1303 | |
1304 assert(s->avctx->rc_max_rate); | |
1305 } | |
1306 | |
1307 if(s->flags&CODEC_FLAG_PASS1) | |
1308 ff_write_pass1_stats(s); | |
1309 | |
1310 for(i=0; i<4; i++){ | |
1311 s->current_picture_ptr->error[i]= s->current_picture.error[i]; | |
1312 avctx->error[i] += s->current_picture_ptr->error[i]; | |
1313 } | |
1314 | |
1315 if(s->flags&CODEC_FLAG_PASS1) | |
1316 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); | |
1317 flush_put_bits(&s->pb); | |
1318 s->frame_bits = put_bits_count(&s->pb); | |
1319 | |
1320 stuffing_count= ff_vbv_update(s, s->frame_bits); | |
1321 if(stuffing_count){ | |
1322 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ | |
1323 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); | |
1324 return -1; | |
1325 } | |
1326 | |
1327 switch(s->codec_id){ | |
1328 case CODEC_ID_MPEG1VIDEO: | |
1329 case CODEC_ID_MPEG2VIDEO: | |
1330 while(stuffing_count--){ | |
1331 put_bits(&s->pb, 8, 0); | |
1332 } | |
1333 break; | |
1334 case CODEC_ID_MPEG4: | |
1335 put_bits(&s->pb, 16, 0); | |
1336 put_bits(&s->pb, 16, 0x1C3); | |
1337 stuffing_count -= 4; | |
1338 while(stuffing_count--){ | |
1339 put_bits(&s->pb, 8, 0xFF); | |
1340 } | |
1341 break; | |
1342 default: | |
1343 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); | |
1344 } | |
1345 flush_put_bits(&s->pb); | |
1346 s->frame_bits = put_bits_count(&s->pb); | |
1347 } | |
1348 | |
1349 /* update mpeg1/2 vbv_delay for CBR */ | |
1350 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 | |
1351 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ | |
9638 | 1352 int vbv_delay, min_delay; |
1353 double inbits = s->avctx->rc_max_rate*av_q2d(s->avctx->time_base); | |
1354 int minbits= s->frame_bits - 8*(s->vbv_delay_ptr - s->pb.buf - 1); | |
1355 double bits = s->rc_context.buffer_index + minbits - inbits; | |
1356 | |
1357 if(bits<0) | |
1358 av_log(s->avctx, AV_LOG_ERROR, "Internal error, negative bits\n"); | |
5204 | 1359 |
1360 assert(s->repeat_first_field==0); | |
1361 | |
9638 | 1362 vbv_delay= bits * 90000 / s->avctx->rc_max_rate; |
1363 min_delay= (minbits * 90000LL + s->avctx->rc_max_rate - 1)/ s->avctx->rc_max_rate; | |
1364 | |
1365 vbv_delay= FFMAX(vbv_delay, min_delay); | |
1366 | |
5204 | 1367 assert(vbv_delay < 0xFFFF); |
1368 | |
1369 s->vbv_delay_ptr[0] &= 0xF8; | |
1370 s->vbv_delay_ptr[0] |= vbv_delay>>13; | |
1371 s->vbv_delay_ptr[1] = vbv_delay>>5; | |
1372 s->vbv_delay_ptr[2] &= 0x07; | |
1373 s->vbv_delay_ptr[2] |= vbv_delay<<3; | |
1374 } | |
1375 s->total_bits += s->frame_bits; | |
1376 avctx->frame_bits = s->frame_bits; | |
1377 }else{ | |
9431 | 1378 assert((put_bits_ptr(&s->pb) == s->pb.buf)); |
5204 | 1379 s->frame_bits=0; |
1380 } | |
1381 assert((s->frame_bits&7)==0); | |
1382 | |
1383 return s->frame_bits/8; | |
1384 } | |
1385 | |
1386 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) | |
1387 { | |
1388 static const char tab[64]= | |
1389 {3,2,2,1,1,1,1,1, | |
1390 1,1,1,1,1,1,1,1, | |
1391 1,1,1,1,1,1,1,1, | |
1392 0,0,0,0,0,0,0,0, | |
1393 0,0,0,0,0,0,0,0, | |
1394 0,0,0,0,0,0,0,0, | |
1395 0,0,0,0,0,0,0,0, | |
1396 0,0,0,0,0,0,0,0}; | |
1397 int score=0; | |
1398 int run=0; | |
1399 int i; | |
1400 DCTELEM *block= s->block[n]; | |
1401 const int last_index= s->block_last_index[n]; | |
1402 int skip_dc; | |
1403 | |
1404 if(threshold<0){ | |
1405 skip_dc=0; | |
1406 threshold= -threshold; | |
1407 }else | |
1408 skip_dc=1; | |
1409 | |
6497 | 1410 /* Are all we could set to zero already zero? */ |
5204 | 1411 if(last_index<=skip_dc - 1) return; |
1412 | |
1413 for(i=0; i<=last_index; i++){ | |
1414 const int j = s->intra_scantable.permutated[i]; | |
1415 const int level = FFABS(block[j]); | |
1416 if(level==1){ | |
1417 if(skip_dc && i==0) continue; | |
1418 score+= tab[run]; | |
1419 run=0; | |
1420 }else if(level>1){ | |
1421 return; | |
1422 }else{ | |
1423 run++; | |
1424 } | |
1425 } | |
1426 if(score >= threshold) return; | |
1427 for(i=skip_dc; i<=last_index; i++){ | |
1428 const int j = s->intra_scantable.permutated[i]; | |
1429 block[j]=0; | |
1430 } | |
1431 if(block[0]) s->block_last_index[n]= 0; | |
1432 else s->block_last_index[n]= -1; | |
1433 } | |
1434 | |
1435 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) | |
1436 { | |
1437 int i; | |
1438 const int maxlevel= s->max_qcoeff; | |
1439 const int minlevel= s->min_qcoeff; | |
1440 int overflow=0; | |
1441 | |
1442 if(s->mb_intra){ | |
1443 i=1; //skip clipping of intra dc | |
1444 }else | |
1445 i=0; | |
1446 | |
1447 for(;i<=last_index; i++){ | |
1448 const int j= s->intra_scantable.permutated[i]; | |
1449 int level = block[j]; | |
1450 | |
1451 if (level>maxlevel){ | |
1452 level=maxlevel; | |
1453 overflow++; | |
1454 }else if(level<minlevel){ | |
1455 level=minlevel; | |
1456 overflow++; | |
1457 } | |
1458 | |
1459 block[j]= level; | |
1460 } | |
1461 | |
1462 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE) | |
1463 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); | |
1464 } | |
1465 | |
5909 | 1466 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride){ |
5204 | 1467 int x, y; |
1468 //FIXME optimize | |
1469 for(y=0; y<8; y++){ | |
1470 for(x=0; x<8; x++){ | |
1471 int x2, y2; | |
1472 int sum=0; | |
1473 int sqr=0; | |
1474 int count=0; | |
1475 | |
1476 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ | |
1477 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ | |
1478 int v= ptr[x2 + y2*stride]; | |
1479 sum += v; | |
1480 sqr += v*v; | |
1481 count++; | |
1482 } | |
1483 } | |
1484 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; | |
1485 } | |
1486 } | |
1487 } | |
1488 | |
1489 static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count) | |
1490 { | |
1491 int16_t weight[8][64]; | |
1492 DCTELEM orig[8][64]; | |
1493 const int mb_x= s->mb_x; | |
1494 const int mb_y= s->mb_y; | |
1495 int i; | |
1496 int skip_dct[8]; | |
1497 int dct_offset = s->linesize*8; //default for progressive frames | |
1498 uint8_t *ptr_y, *ptr_cb, *ptr_cr; | |
1499 int wrap_y, wrap_c; | |
1500 | |
1501 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct; | |
1502 | |
1503 if(s->adaptive_quant){ | |
1504 const int last_qp= s->qscale; | |
1505 const int mb_xy= mb_x + mb_y*s->mb_stride; | |
1506 | |
1507 s->lambda= s->lambda_table[mb_xy]; | |
1508 update_qscale(s); | |
1509 | |
1510 if(!(s->flags&CODEC_FLAG_QP_RD)){ | |
1511 s->qscale= s->current_picture_ptr->qscale_table[mb_xy]; | |
1512 s->dquant= s->qscale - last_qp; | |
1513 | |
1514 if(s->out_format==FMT_H263){ | |
1515 s->dquant= av_clip(s->dquant, -2, 2); | |
1516 | |
1517 if(s->codec_id==CODEC_ID_MPEG4){ | |
1518 if(!s->mb_intra){ | |
6481 | 1519 if(s->pict_type == FF_B_TYPE){ |
5204 | 1520 if(s->dquant&1 || s->mv_dir&MV_DIRECT) |
1521 s->dquant= 0; | |
1522 } | |
1523 if(s->mv_type==MV_TYPE_8X8) | |
1524 s->dquant=0; | |
1525 } | |
1526 } | |
1527 } | |
1528 } | |
1529 ff_set_qscale(s, last_qp + s->dquant); | |
1530 }else if(s->flags&CODEC_FLAG_QP_RD) | |
1531 ff_set_qscale(s, s->qscale + s->dquant); | |
1532 | |
1533 wrap_y = s->linesize; | |
1534 wrap_c = s->uvlinesize; | |
1535 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; | |
1536 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1537 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; | |
1538 | |
1539 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){ | |
1540 uint8_t *ebuf= s->edge_emu_buffer + 32; | |
1541 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height); | |
1542 ptr_y= ebuf; | |
1543 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); | |
1544 ptr_cb= ebuf+18*wrap_y; | |
1545 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); | |
1546 ptr_cr= ebuf+18*wrap_y+8; | |
1547 } | |
1548 | |
1549 if (s->mb_intra) { | |
1550 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ | |
1551 int progressive_score, interlaced_score; | |
1552 | |
1553 s->interlaced_dct=0; | |
1554 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) | |
1555 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; | |
1556 | |
1557 if(progressive_score > 0){ | |
1558 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) | |
1559 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); | |
1560 if(progressive_score > interlaced_score){ | |
1561 s->interlaced_dct=1; | |
1562 | |
1563 dct_offset= wrap_y; | |
1564 wrap_y<<=1; | |
1565 if (s->chroma_format == CHROMA_422) | |
1566 wrap_c<<=1; | |
1567 } | |
1568 } | |
1569 } | |
1570 | |
1571 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); | |
1572 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); | |
1573 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); | |
1574 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); | |
1575 | |
1576 if(s->flags&CODEC_FLAG_GRAY){ | |
1577 skip_dct[4]= 1; | |
1578 skip_dct[5]= 1; | |
1579 }else{ | |
1580 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); | |
1581 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); | |
1582 if(!s->chroma_y_shift){ /* 422 */ | |
1583 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); | |
1584 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); | |
1585 } | |
1586 } | |
1587 }else{ | |
1588 op_pixels_func (*op_pix)[4]; | |
1589 qpel_mc_func (*op_qpix)[16]; | |
1590 uint8_t *dest_y, *dest_cb, *dest_cr; | |
1591 | |
1592 dest_y = s->dest[0]; | |
1593 dest_cb = s->dest[1]; | |
1594 dest_cr = s->dest[2]; | |
1595 | |
6481 | 1596 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){ |
5204 | 1597 op_pix = s->dsp.put_pixels_tab; |
1598 op_qpix= s->dsp.put_qpel_pixels_tab; | |
1599 }else{ | |
1600 op_pix = s->dsp.put_no_rnd_pixels_tab; | |
1601 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; | |
1602 } | |
1603 | |
1604 if (s->mv_dir & MV_DIR_FORWARD) { | |
1605 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); | |
1606 op_pix = s->dsp.avg_pixels_tab; | |
1607 op_qpix= s->dsp.avg_qpel_pixels_tab; | |
1608 } | |
1609 if (s->mv_dir & MV_DIR_BACKWARD) { | |
1610 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); | |
1611 } | |
1612 | |
1613 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ | |
1614 int progressive_score, interlaced_score; | |
1615 | |
1616 s->interlaced_dct=0; | |
1617 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) | |
1618 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; | |
1619 | |
1620 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; | |
1621 | |
1622 if(progressive_score>0){ | |
1623 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) | |
1624 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); | |
1625 | |
1626 if(progressive_score > interlaced_score){ | |
1627 s->interlaced_dct=1; | |
1628 | |
1629 dct_offset= wrap_y; | |
1630 wrap_y<<=1; | |
1631 if (s->chroma_format == CHROMA_422) | |
1632 wrap_c<<=1; | |
1633 } | |
1634 } | |
1635 } | |
1636 | |
1637 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y); | |
1638 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y); | |
1639 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y); | |
1640 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); | |
1641 | |
1642 if(s->flags&CODEC_FLAG_GRAY){ | |
1643 skip_dct[4]= 1; | |
1644 skip_dct[5]= 1; | |
1645 }else{ | |
1646 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); | |
1647 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); | |
1648 if(!s->chroma_y_shift){ /* 422 */ | |
1649 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); | |
1650 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); | |
1651 } | |
1652 } | |
1653 /* pre quantization */ | |
1654 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ | |
1655 //FIXME optimize | |
1656 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; | |
1657 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; | |
1658 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; | |
1659 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1; | |
1660 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; | |
1661 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; | |
1662 if(!s->chroma_y_shift){ /* 422 */ | |
1663 if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1; | |
1664 if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1; | |
1665 } | |
1666 } | |
1667 } | |
1668 | |
1669 if(s->avctx->quantizer_noise_shaping){ | |
5909 | 1670 if(!skip_dct[0]) get_visual_weight(weight[0], ptr_y , wrap_y); |
1671 if(!skip_dct[1]) get_visual_weight(weight[1], ptr_y + 8, wrap_y); | |
1672 if(!skip_dct[2]) get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y); | |
1673 if(!skip_dct[3]) get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); | |
1674 if(!skip_dct[4]) get_visual_weight(weight[4], ptr_cb , wrap_c); | |
1675 if(!skip_dct[5]) get_visual_weight(weight[5], ptr_cr , wrap_c); | |
5204 | 1676 if(!s->chroma_y_shift){ /* 422 */ |
5909 | 1677 if(!skip_dct[6]) get_visual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); |
1678 if(!skip_dct[7]) get_visual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); | |
5204 | 1679 } |
1680 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); | |
1681 } | |
1682 | |
1683 /* DCT & quantize */ | |
1684 assert(s->out_format!=FMT_MJPEG || s->qscale==8); | |
1685 { | |
1686 for(i=0;i<mb_block_count;i++) { | |
1687 if(!skip_dct[i]){ | |
1688 int overflow; | |
1689 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); | |
1690 // FIXME we could decide to change to quantizer instead of clipping | |
1691 // JS: I don't think that would be a good idea it could lower quality instead | |
1692 // of improve it. Just INTRADC clipping deserves changes in quantizer | |
1693 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); | |
1694 }else | |
1695 s->block_last_index[i]= -1; | |
1696 } | |
1697 if(s->avctx->quantizer_noise_shaping){ | |
1698 for(i=0;i<mb_block_count;i++) { | |
1699 if(!skip_dct[i]){ | |
1700 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); | |
1701 } | |
1702 } | |
1703 } | |
1704 | |
1705 if(s->luma_elim_threshold && !s->mb_intra) | |
1706 for(i=0; i<4; i++) | |
1707 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); | |
1708 if(s->chroma_elim_threshold && !s->mb_intra) | |
1709 for(i=4; i<mb_block_count; i++) | |
1710 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); | |
1711 | |
1712 if(s->flags & CODEC_FLAG_CBP_RD){ | |
1713 for(i=0;i<mb_block_count;i++) { | |
1714 if(s->block_last_index[i] == -1) | |
1715 s->coded_score[i]= INT_MAX/256; | |
1716 } | |
1717 } | |
1718 } | |
1719 | |
1720 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ | |
1721 s->block_last_index[4]= | |
1722 s->block_last_index[5]= 0; | |
1723 s->block[4][0]= | |
1724 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; | |
1725 } | |
1726 | |
1727 //non c quantize code returns incorrect block_last_index FIXME | |
1728 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ | |
1729 for(i=0; i<mb_block_count; i++){ | |
1730 int j; | |
1731 if(s->block_last_index[i]>0){ | |
1732 for(j=63; j>0; j--){ | |
1733 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; | |
1734 } | |
1735 s->block_last_index[i]= j; | |
1736 } | |
1737 } | |
1738 } | |
1739 | |
1740 /* huffman encode */ | |
1741 switch(s->codec_id){ //FIXME funct ptr could be slightly faster | |
1742 case CODEC_ID_MPEG1VIDEO: | |
1743 case CODEC_ID_MPEG2VIDEO: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1744 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) |
5209 | 1745 mpeg1_encode_mb(s, s->block, motion_x, motion_y); |
1746 break; | |
5204 | 1747 case CODEC_ID_MPEG4: |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1748 if (CONFIG_MPEG4_ENCODER) |
5278 | 1749 mpeg4_encode_mb(s, s->block, motion_x, motion_y); |
1750 break; | |
5204 | 1751 case CODEC_ID_MSMPEG4V2: |
1752 case CODEC_ID_MSMPEG4V3: | |
1753 case CODEC_ID_WMV1: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1754 if (CONFIG_MSMPEG4_ENCODER) |
5204 | 1755 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); |
1756 break; | |
1757 case CODEC_ID_WMV2: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1758 if (CONFIG_WMV2_ENCODER) |
5204 | 1759 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); |
1760 break; | |
1761 case CODEC_ID_H261: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1762 if (CONFIG_H261_ENCODER) |
5204 | 1763 ff_h261_encode_mb(s, s->block, motion_x, motion_y); |
1764 break; | |
1765 case CODEC_ID_H263: | |
1766 case CODEC_ID_H263P: | |
1767 case CODEC_ID_FLV1: | |
1768 case CODEC_ID_RV10: | |
1769 case CODEC_ID_RV20: | |
10034
ea2422aa4635
Do not check for both CONFIG_H263_ENCODER and CONFIG_FLV_ENCODER.
diego
parents:
10032
diff
changeset
|
1770 if (CONFIG_H263_ENCODER) |
5278 | 1771 h263_encode_mb(s, s->block, motion_x, motion_y); |
1772 break; | |
5204 | 1773 case CODEC_ID_MJPEG: |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
1774 if (CONFIG_MJPEG_ENCODER) |
5204 | 1775 ff_mjpeg_encode_mb(s, s->block); |
1776 break; | |
1777 default: | |
1778 assert(0); | |
1779 } | |
1780 } | |
1781 | |
1782 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) | |
1783 { | |
1784 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); | |
1785 else encode_mb_internal(s, motion_x, motion_y, 16, 8); | |
1786 } | |
1787 | |
1788 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ | |
1789 int i; | |
1790 | |
1791 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
1792 | |
1793 /* mpeg1 */ | |
1794 d->mb_skip_run= s->mb_skip_run; | |
1795 for(i=0; i<3; i++) | |
1796 d->last_dc[i]= s->last_dc[i]; | |
1797 | |
1798 /* statistics */ | |
1799 d->mv_bits= s->mv_bits; | |
1800 d->i_tex_bits= s->i_tex_bits; | |
1801 d->p_tex_bits= s->p_tex_bits; | |
1802 d->i_count= s->i_count; | |
1803 d->f_count= s->f_count; | |
1804 d->b_count= s->b_count; | |
1805 d->skip_count= s->skip_count; | |
1806 d->misc_bits= s->misc_bits; | |
1807 d->last_bits= 0; | |
1808 | |
1809 d->mb_skipped= 0; | |
1810 d->qscale= s->qscale; | |
1811 d->dquant= s->dquant; | |
6074 | 1812 |
1813 d->esc3_level_length= s->esc3_level_length; | |
5204 | 1814 } |
1815 | |
1816 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ | |
1817 int i; | |
1818 | |
1819 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); | |
1820 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? | |
1821 | |
1822 /* mpeg1 */ | |
1823 d->mb_skip_run= s->mb_skip_run; | |
1824 for(i=0; i<3; i++) | |
1825 d->last_dc[i]= s->last_dc[i]; | |
1826 | |
1827 /* statistics */ | |
1828 d->mv_bits= s->mv_bits; | |
1829 d->i_tex_bits= s->i_tex_bits; | |
1830 d->p_tex_bits= s->p_tex_bits; | |
1831 d->i_count= s->i_count; | |
1832 d->f_count= s->f_count; | |
1833 d->b_count= s->b_count; | |
1834 d->skip_count= s->skip_count; | |
1835 d->misc_bits= s->misc_bits; | |
1836 | |
1837 d->mb_intra= s->mb_intra; | |
1838 d->mb_skipped= s->mb_skipped; | |
1839 d->mv_type= s->mv_type; | |
1840 d->mv_dir= s->mv_dir; | |
1841 d->pb= s->pb; | |
1842 if(s->data_partitioning){ | |
1843 d->pb2= s->pb2; | |
1844 d->tex_pb= s->tex_pb; | |
1845 } | |
1846 d->block= s->block; | |
1847 for(i=0; i<8; i++) | |
1848 d->block_last_index[i]= s->block_last_index[i]; | |
1849 d->interlaced_dct= s->interlaced_dct; | |
1850 d->qscale= s->qscale; | |
6074 | 1851 |
1852 d->esc3_level_length= s->esc3_level_length; | |
5204 | 1853 } |
1854 | |
1855 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, | |
1856 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], | |
1857 int *dmin, int *next_block, int motion_x, int motion_y) | |
1858 { | |
1859 int score; | |
1860 uint8_t *dest_backup[3]; | |
1861 | |
1862 copy_context_before_encode(s, backup, type); | |
1863 | |
1864 s->block= s->blocks[*next_block]; | |
1865 s->pb= pb[*next_block]; | |
1866 if(s->data_partitioning){ | |
1867 s->pb2 = pb2 [*next_block]; | |
1868 s->tex_pb= tex_pb[*next_block]; | |
1869 } | |
1870 | |
1871 if(*next_block){ | |
1872 memcpy(dest_backup, s->dest, sizeof(s->dest)); | |
1873 s->dest[0] = s->rd_scratchpad; | |
1874 s->dest[1] = s->rd_scratchpad + 16*s->linesize; | |
1875 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; | |
1876 assert(s->linesize >= 32); //FIXME | |
1877 } | |
1878 | |
1879 encode_mb(s, motion_x, motion_y); | |
1880 | |
1881 score= put_bits_count(&s->pb); | |
1882 if(s->data_partitioning){ | |
1883 score+= put_bits_count(&s->pb2); | |
1884 score+= put_bits_count(&s->tex_pb); | |
1885 } | |
1886 | |
1887 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ | |
1888 MPV_decode_mb(s, s->block); | |
1889 | |
1890 score *= s->lambda2; | |
1891 score += sse_mb(s) << FF_LAMBDA_SHIFT; | |
1892 } | |
1893 | |
1894 if(*next_block){ | |
1895 memcpy(s->dest, dest_backup, sizeof(s->dest)); | |
1896 } | |
1897 | |
1898 if(score<*dmin){ | |
1899 *dmin= score; | |
1900 *next_block^=1; | |
1901 | |
1902 copy_context_after_encode(best, s, type); | |
1903 } | |
1904 } | |
1905 | |
1906 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ | |
1907 uint32_t *sq = ff_squareTbl + 256; | |
1908 int acc=0; | |
1909 int x,y; | |
1910 | |
1911 if(w==16 && h==16) | |
1912 return s->dsp.sse[0](NULL, src1, src2, stride, 16); | |
1913 else if(w==8 && h==8) | |
1914 return s->dsp.sse[1](NULL, src1, src2, stride, 8); | |
1915 | |
1916 for(y=0; y<h; y++){ | |
1917 for(x=0; x<w; x++){ | |
1918 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; | |
1919 } | |
1920 } | |
1921 | |
1922 assert(acc>=0); | |
1923 | |
1924 return acc; | |
1925 } | |
1926 | |
1927 static int sse_mb(MpegEncContext *s){ | |
1928 int w= 16; | |
1929 int h= 16; | |
1930 | |
1931 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
1932 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
1933 | |
1934 if(w==16 && h==16) | |
1935 if(s->avctx->mb_cmp == FF_CMP_NSSE){ | |
1936 return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) | |
1937 +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) | |
1938 +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); | |
1939 }else{ | |
1940 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) | |
1941 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) | |
1942 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); | |
1943 } | |
1944 else | |
1945 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize) | |
1946 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize) | |
1947 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize); | |
1948 } | |
1949 | |
1950 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ | |
8129
a9734fe0811e
Making it easier to send arbitrary structures as work orders to MT workers
romansh
parents:
8117
diff
changeset
|
1951 MpegEncContext *s= *(void**)arg; |
5204 | 1952 |
1953 | |
1954 s->me.pre_pass=1; | |
1955 s->me.dia_size= s->avctx->pre_dia_size; | |
1956 s->first_slice_line=1; | |
1957 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { | |
1958 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { | |
1959 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
1960 } | |
1961 s->first_slice_line=0; | |
1962 } | |
1963 | |
1964 s->me.pre_pass=0; | |
1965 | |
1966 return 0; | |
1967 } | |
1968 | |
1969 static int estimate_motion_thread(AVCodecContext *c, void *arg){ | |
8129
a9734fe0811e
Making it easier to send arbitrary structures as work orders to MT workers
romansh
parents:
8117
diff
changeset
|
1970 MpegEncContext *s= *(void**)arg; |
5204 | 1971 |
1972 ff_check_alignment(); | |
1973 | |
1974 s->me.dia_size= s->avctx->dia_size; | |
1975 s->first_slice_line=1; | |
1976 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { | |
1977 s->mb_x=0; //for block init below | |
1978 ff_init_block_index(s); | |
1979 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | |
1980 s->block_index[0]+=2; | |
1981 s->block_index[1]+=2; | |
1982 s->block_index[2]+=2; | |
1983 s->block_index[3]+=2; | |
1984 | |
1985 /* compute motion vector & mb_type and store in context */ | |
6481 | 1986 if(s->pict_type==FF_B_TYPE) |
5204 | 1987 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); |
1988 else | |
1989 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); | |
1990 } | |
1991 s->first_slice_line=0; | |
1992 } | |
1993 return 0; | |
1994 } | |
1995 | |
1996 static int mb_var_thread(AVCodecContext *c, void *arg){ | |
8129
a9734fe0811e
Making it easier to send arbitrary structures as work orders to MT workers
romansh
parents:
8117
diff
changeset
|
1997 MpegEncContext *s= *(void**)arg; |
5204 | 1998 int mb_x, mb_y; |
1999 | |
2000 ff_check_alignment(); | |
2001 | |
2002 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { | |
2003 for(mb_x=0; mb_x < s->mb_width; mb_x++) { | |
2004 int xx = mb_x * 16; | |
2005 int yy = mb_y * 16; | |
2006 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx; | |
2007 int varc; | |
2008 int sum = s->dsp.pix_sum(pix, s->linesize); | |
2009 | |
2010 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; | |
2011 | |
2012 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc; | |
2013 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8; | |
2014 s->me.mb_var_sum_temp += varc; | |
2015 } | |
2016 } | |
2017 return 0; | |
2018 } | |
2019 | |
2020 static void write_slice_end(MpegEncContext *s){ | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2021 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){ |
5204 | 2022 if(s->partitioned_frame){ |
2023 ff_mpeg4_merge_partitions(s); | |
2024 } | |
2025 | |
2026 ff_mpeg4_stuffing(&s->pb); | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2027 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){ |
5204 | 2028 ff_mjpeg_encode_stuffing(&s->pb); |
2029 } | |
2030 | |
2031 align_put_bits(&s->pb); | |
2032 flush_put_bits(&s->pb); | |
2033 | |
2034 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) | |
2035 s->misc_bits+= get_bits_diff(s); | |
2036 } | |
2037 | |
2038 static int encode_thread(AVCodecContext *c, void *arg){ | |
8129
a9734fe0811e
Making it easier to send arbitrary structures as work orders to MT workers
romansh
parents:
8117
diff
changeset
|
2039 MpegEncContext *s= *(void**)arg; |
5204 | 2040 int mb_x, mb_y, pdif = 0; |
7520 | 2041 int chr_h= 16>>s->chroma_y_shift; |
5204 | 2042 int i, j; |
2043 MpegEncContext best_s, backup_s; | |
2044 uint8_t bit_buf[2][MAX_MB_BYTES]; | |
2045 uint8_t bit_buf2[2][MAX_MB_BYTES]; | |
2046 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; | |
2047 PutBitContext pb[2], pb2[2], tex_pb[2]; | |
2048 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); | |
2049 | |
2050 ff_check_alignment(); | |
2051 | |
2052 for(i=0; i<2; i++){ | |
2053 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); | |
2054 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); | |
2055 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); | |
2056 } | |
2057 | |
2058 s->last_bits= put_bits_count(&s->pb); | |
2059 s->mv_bits=0; | |
2060 s->misc_bits=0; | |
2061 s->i_tex_bits=0; | |
2062 s->p_tex_bits=0; | |
2063 s->i_count=0; | |
2064 s->f_count=0; | |
2065 s->b_count=0; | |
2066 s->skip_count=0; | |
2067 | |
2068 for(i=0; i<3; i++){ | |
2069 /* init last dc values */ | |
2070 /* note: quant matrix value (8) is implied here */ | |
2071 s->last_dc[i] = 128 << s->intra_dc_precision; | |
2072 | |
2073 s->current_picture.error[i] = 0; | |
2074 } | |
2075 s->mb_skip_run = 0; | |
2076 memset(s->last_mv, 0, sizeof(s->last_mv)); | |
2077 | |
2078 s->last_mv_dir = 0; | |
2079 | |
2080 switch(s->codec_id){ | |
2081 case CODEC_ID_H263: | |
2082 case CODEC_ID_H263P: | |
2083 case CODEC_ID_FLV1: | |
10034
ea2422aa4635
Do not check for both CONFIG_H263_ENCODER and CONFIG_FLV_ENCODER.
diego
parents:
10032
diff
changeset
|
2084 if (CONFIG_H263_ENCODER) |
5278 | 2085 s->gob_index = ff_h263_get_gob_height(s); |
5204 | 2086 break; |
2087 case CODEC_ID_MPEG4: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2088 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame) |
5204 | 2089 ff_mpeg4_init_partitions(s); |
2090 break; | |
2091 } | |
2092 | |
2093 s->resync_mb_x=0; | |
2094 s->resync_mb_y=0; | |
2095 s->first_slice_line = 1; | |
2096 s->ptr_lastgob = s->pb.buf; | |
2097 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { | |
2098 // printf("row %d at %X\n", s->mb_y, (int)s); | |
2099 s->mb_x=0; | |
2100 s->mb_y= mb_y; | |
2101 | |
2102 ff_set_qscale(s, s->qscale); | |
2103 ff_init_block_index(s); | |
2104 | |
2105 for(mb_x=0; mb_x < s->mb_width; mb_x++) { | |
2106 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this | |
2107 int mb_type= s->mb_type[xy]; | |
2108 // int d; | |
2109 int dmin= INT_MAX; | |
2110 int dir; | |
2111 | |
2112 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ | |
2113 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
2114 return -1; | |
2115 } | |
2116 if(s->data_partitioning){ | |
2117 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES | |
2118 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ | |
2119 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
2120 return -1; | |
2121 } | |
2122 } | |
2123 | |
2124 s->mb_x = mb_x; | |
2125 s->mb_y = mb_y; // moved into loop, can get changed by H.261 | |
2126 ff_update_block_index(s); | |
2127 | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2128 if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){ |
5204 | 2129 ff_h261_reorder_mb_index(s); |
2130 xy= s->mb_y*s->mb_stride + s->mb_x; | |
2131 mb_type= s->mb_type[xy]; | |
2132 } | |
2133 | |
2134 /* write gob / video packet header */ | |
2135 if(s->rtp_mode){ | |
2136 int current_packet_size, is_gob_start; | |
2137 | |
2138 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf); | |
2139 | |
2140 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; | |
2141 | |
2142 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1; | |
2143 | |
2144 switch(s->codec_id){ | |
2145 case CODEC_ID_H263: | |
2146 case CODEC_ID_H263P: | |
2147 if(!s->h263_slice_structured) | |
2148 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0; | |
2149 break; | |
2150 case CODEC_ID_MPEG2VIDEO: | |
2151 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1; | |
2152 case CODEC_ID_MPEG1VIDEO: | |
2153 if(s->mb_skip_run) is_gob_start=0; | |
2154 break; | |
2155 } | |
2156 | |
2157 if(is_gob_start){ | |
2158 if(s->start_mb_y != mb_y || mb_x!=0){ | |
2159 write_slice_end(s); | |
2160 | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2161 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){ |
5204 | 2162 ff_mpeg4_init_partitions(s); |
2163 } | |
2164 } | |
2165 | |
2166 assert((put_bits_count(&s->pb)&7) == 0); | |
9431 | 2167 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob; |
5204 | 2168 |
2169 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ | |
2170 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y; | |
2171 int d= 100 / s->avctx->error_rate; | |
2172 if(r % d == 0){ | |
2173 current_packet_size=0; | |
2174 #ifndef ALT_BITSTREAM_WRITER | |
2175 s->pb.buf_ptr= s->ptr_lastgob; | |
2176 #endif | |
9431 | 2177 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob); |
5204 | 2178 } |
2179 } | |
2180 | |
2181 if (s->avctx->rtp_callback){ | |
2182 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x; | |
2183 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb); | |
2184 } | |
2185 | |
2186 switch(s->codec_id){ | |
2187 case CODEC_ID_MPEG4: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2188 if (CONFIG_MPEG4_ENCODER) { |
5278 | 2189 ff_mpeg4_encode_video_packet_header(s); |
2190 ff_mpeg4_clean_buffers(s); | |
5277
7b3fcb7c61ce
Avoid linking with h263.c functions when the relevant codecs
aurel
parents:
5273
diff
changeset
|
2191 } |
5204 | 2192 break; |
2193 case CODEC_ID_MPEG1VIDEO: | |
2194 case CODEC_ID_MPEG2VIDEO: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2195 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) { |
5209 | 2196 ff_mpeg1_encode_slice_header(s); |
2197 ff_mpeg1_clean_buffers(s); | |
5208 | 2198 } |
5204 | 2199 break; |
2200 case CODEC_ID_H263: | |
2201 case CODEC_ID_H263P: | |
10032
29c9829a9684
Do not check for both CONFIG_H263_ENCODER and CONFIG_H263P_ENCODER.
diego
parents:
10029
diff
changeset
|
2202 if (CONFIG_H263_ENCODER) |
5278 | 2203 h263_encode_gob_header(s, mb_y); |
5204 | 2204 break; |
2205 } | |
2206 | |
2207 if(s->flags&CODEC_FLAG_PASS1){ | |
2208 int bits= put_bits_count(&s->pb); | |
2209 s->misc_bits+= bits - s->last_bits; | |
2210 s->last_bits= bits; | |
2211 } | |
2212 | |
2213 s->ptr_lastgob += current_packet_size; | |
2214 s->first_slice_line=1; | |
2215 s->resync_mb_x=mb_x; | |
2216 s->resync_mb_y=mb_y; | |
2217 } | |
2218 } | |
2219 | |
2220 if( (s->resync_mb_x == s->mb_x) | |
2221 && s->resync_mb_y+1 == s->mb_y){ | |
2222 s->first_slice_line=0; | |
2223 } | |
2224 | |
2225 s->mb_skipped=0; | |
2226 s->dquant=0; //only for QP_RD | |
2227 | |
2228 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD | |
2229 int next_block=0; | |
2230 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; | |
2231 | |
2232 copy_context_before_encode(&backup_s, s, -1); | |
2233 backup_s.pb= s->pb; | |
2234 best_s.data_partitioning= s->data_partitioning; | |
2235 best_s.partitioned_frame= s->partitioned_frame; | |
2236 if(s->data_partitioning){ | |
2237 backup_s.pb2= s->pb2; | |
2238 backup_s.tex_pb= s->tex_pb; | |
2239 } | |
2240 | |
2241 if(mb_type&CANDIDATE_MB_TYPE_INTER){ | |
2242 s->mv_dir = MV_DIR_FORWARD; | |
2243 s->mv_type = MV_TYPE_16X16; | |
2244 s->mb_intra= 0; | |
2245 s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
2246 s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
2247 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, | |
2248 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); | |
2249 } | |
2250 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ | |
2251 s->mv_dir = MV_DIR_FORWARD; | |
2252 s->mv_type = MV_TYPE_FIELD; | |
2253 s->mb_intra= 0; | |
2254 for(i=0; i<2; i++){ | |
2255 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
2256 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
2257 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
2258 } | |
2259 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, | |
2260 &dmin, &next_block, 0, 0); | |
2261 } | |
2262 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){ | |
2263 s->mv_dir = MV_DIR_FORWARD; | |
2264 s->mv_type = MV_TYPE_16X16; | |
2265 s->mb_intra= 0; | |
2266 s->mv[0][0][0] = 0; | |
2267 s->mv[0][0][1] = 0; | |
2268 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb, | |
2269 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); | |
2270 } | |
2271 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){ | |
2272 s->mv_dir = MV_DIR_FORWARD; | |
2273 s->mv_type = MV_TYPE_8X8; | |
2274 s->mb_intra= 0; | |
2275 for(i=0; i<4; i++){ | |
2276 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; | |
2277 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; | |
2278 } | |
2279 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, | |
2280 &dmin, &next_block, 0, 0); | |
2281 } | |
2282 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){ | |
2283 s->mv_dir = MV_DIR_FORWARD; | |
2284 s->mv_type = MV_TYPE_16X16; | |
2285 s->mb_intra= 0; | |
2286 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
2287 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
2288 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, | |
2289 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); | |
2290 } | |
2291 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){ | |
2292 s->mv_dir = MV_DIR_BACKWARD; | |
2293 s->mv_type = MV_TYPE_16X16; | |
2294 s->mb_intra= 0; | |
2295 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
2296 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
2297 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, | |
2298 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); | |
2299 } | |
2300 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){ | |
2301 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
2302 s->mv_type = MV_TYPE_16X16; | |
2303 s->mb_intra= 0; | |
2304 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
2305 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
2306 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
2307 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
2308 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, | |
2309 &dmin, &next_block, 0, 0); | |
2310 } | |
2311 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ | |
2312 s->mv_dir = MV_DIR_FORWARD; | |
2313 s->mv_type = MV_TYPE_FIELD; | |
2314 s->mb_intra= 0; | |
2315 for(i=0; i<2; i++){ | |
2316 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
2317 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
2318 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
2319 } | |
2320 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, | |
2321 &dmin, &next_block, 0, 0); | |
2322 } | |
2323 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ | |
2324 s->mv_dir = MV_DIR_BACKWARD; | |
2325 s->mv_type = MV_TYPE_FIELD; | |
2326 s->mb_intra= 0; | |
2327 for(i=0; i<2; i++){ | |
2328 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
2329 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
2330 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
2331 } | |
2332 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, | |
2333 &dmin, &next_block, 0, 0); | |
2334 } | |
2335 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ | |
2336 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
2337 s->mv_type = MV_TYPE_FIELD; | |
2338 s->mb_intra= 0; | |
2339 for(dir=0; dir<2; dir++){ | |
2340 for(i=0; i<2; i++){ | |
2341 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
2342 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
2343 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
2344 } | |
2345 } | |
2346 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, | |
2347 &dmin, &next_block, 0, 0); | |
2348 } | |
2349 if(mb_type&CANDIDATE_MB_TYPE_INTRA){ | |
2350 s->mv_dir = 0; | |
2351 s->mv_type = MV_TYPE_16X16; | |
2352 s->mb_intra= 1; | |
2353 s->mv[0][0][0] = 0; | |
2354 s->mv[0][0][1] = 0; | |
2355 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, | |
2356 &dmin, &next_block, 0, 0); | |
2357 if(s->h263_pred || s->h263_aic){ | |
2358 if(best_s.mb_intra) | |
2359 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; | |
2360 else | |
2361 ff_clean_intra_table_entries(s); //old mode? | |
2362 } | |
2363 } | |
2364 | |
2365 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){ | |
2366 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD | |
2367 const int last_qp= backup_s.qscale; | |
2368 int qpi, qp, dc[6]; | |
2369 DCTELEM ac[6][16]; | |
2370 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0; | |
2371 static const int dquant_tab[4]={-1,1,-2,2}; | |
2372 | |
2373 assert(backup_s.dquant == 0); | |
2374 | |
2375 //FIXME intra | |
2376 s->mv_dir= best_s.mv_dir; | |
2377 s->mv_type = MV_TYPE_16X16; | |
2378 s->mb_intra= best_s.mb_intra; | |
2379 s->mv[0][0][0] = best_s.mv[0][0][0]; | |
2380 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
2381 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
2382 s->mv[1][0][1] = best_s.mv[1][0][1]; | |
2383 | |
6481 | 2384 qpi = s->pict_type == FF_B_TYPE ? 2 : 0; |
5204 | 2385 for(; qpi<4; qpi++){ |
2386 int dquant= dquant_tab[qpi]; | |
2387 qp= last_qp + dquant; | |
2388 if(qp < s->avctx->qmin || qp > s->avctx->qmax) | |
2389 continue; | |
2390 backup_s.dquant= dquant; | |
2391 if(s->mb_intra && s->dc_val[0]){ | |
2392 for(i=0; i<6; i++){ | |
2393 dc[i]= s->dc_val[0][ s->block_index[i] ]; | |
2394 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); | |
2395 } | |
2396 } | |
2397 | |
2398 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, | |
2399 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); | |
2400 if(best_s.qscale != qp){ | |
2401 if(s->mb_intra && s->dc_val[0]){ | |
2402 for(i=0; i<6; i++){ | |
2403 s->dc_val[0][ s->block_index[i] ]= dc[i]; | |
2404 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16); | |
2405 } | |
2406 } | |
2407 } | |
2408 } | |
2409 } | |
2410 } | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2411 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){ |
5204 | 2412 int mx= s->b_direct_mv_table[xy][0]; |
2413 int my= s->b_direct_mv_table[xy][1]; | |
2414 | |
2415 backup_s.dquant = 0; | |
2416 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
2417 s->mb_intra= 0; | |
2418 ff_mpeg4_set_direct_mv(s, mx, my); | |
2419 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, | |
2420 &dmin, &next_block, mx, my); | |
2421 } | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2422 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){ |
5204 | 2423 backup_s.dquant = 0; |
2424 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
2425 s->mb_intra= 0; | |
2426 ff_mpeg4_set_direct_mv(s, 0, 0); | |
2427 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, | |
2428 &dmin, &next_block, 0, 0); | |
2429 } | |
2430 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){ | |
2431 int coded=0; | |
2432 for(i=0; i<6; i++) | |
2433 coded |= s->block_last_index[i]; | |
2434 if(coded){ | |
2435 int mx,my; | |
2436 memcpy(s->mv, best_s.mv, sizeof(s->mv)); | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2437 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){ |
5204 | 2438 mx=my=0; //FIXME find the one we actually used |
2439 ff_mpeg4_set_direct_mv(s, mx, my); | |
2440 }else if(best_s.mv_dir&MV_DIR_BACKWARD){ | |
2441 mx= s->mv[1][0][0]; | |
2442 my= s->mv[1][0][1]; | |
2443 }else{ | |
2444 mx= s->mv[0][0][0]; | |
2445 my= s->mv[0][0][1]; | |
2446 } | |
2447 | |
2448 s->mv_dir= best_s.mv_dir; | |
2449 s->mv_type = best_s.mv_type; | |
2450 s->mb_intra= 0; | |
2451 /* s->mv[0][0][0] = best_s.mv[0][0][0]; | |
2452 s->mv[0][0][1] = best_s.mv[0][0][1]; | |
2453 s->mv[1][0][0] = best_s.mv[1][0][0]; | |
2454 s->mv[1][0][1] = best_s.mv[1][0][1];*/ | |
2455 backup_s.dquant= 0; | |
2456 s->skipdct=1; | |
2457 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, | |
2458 &dmin, &next_block, mx, my); | |
2459 s->skipdct=0; | |
2460 } | |
2461 } | |
2462 | |
2463 s->current_picture.qscale_table[xy]= best_s.qscale; | |
2464 | |
2465 copy_context_after_encode(s, &best_s, -1); | |
2466 | |
2467 pb_bits_count= put_bits_count(&s->pb); | |
2468 flush_put_bits(&s->pb); | |
2469 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); | |
2470 s->pb= backup_s.pb; | |
2471 | |
2472 if(s->data_partitioning){ | |
2473 pb2_bits_count= put_bits_count(&s->pb2); | |
2474 flush_put_bits(&s->pb2); | |
2475 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); | |
2476 s->pb2= backup_s.pb2; | |
2477 | |
2478 tex_pb_bits_count= put_bits_count(&s->tex_pb); | |
2479 flush_put_bits(&s->tex_pb); | |
2480 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); | |
2481 s->tex_pb= backup_s.tex_pb; | |
2482 } | |
2483 s->last_bits= put_bits_count(&s->pb); | |
2484 | |
10727
47e1e474e1f1
Replace CONFIG_ANY_H263_ENCODER definition by CONFIG_H263_ENCODER.
diego
parents:
10683
diff
changeset
|
2485 if (CONFIG_H263_ENCODER && |
6481 | 2486 s->out_format == FMT_H263 && s->pict_type!=FF_B_TYPE) |
5204 | 2487 ff_h263_update_motion_val(s); |
2488 | |
2489 if(next_block==0){ //FIXME 16 vs linesize16 | |
2490 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); | |
2491 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); | |
2492 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); | |
2493 } | |
2494 | |
2495 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) | |
2496 MPV_decode_mb(s, s->block); | |
2497 } else { | |
2498 int motion_x = 0, motion_y = 0; | |
2499 s->mv_type=MV_TYPE_16X16; | |
2500 // only one MB-Type possible | |
2501 | |
2502 switch(mb_type){ | |
2503 case CANDIDATE_MB_TYPE_INTRA: | |
2504 s->mv_dir = 0; | |
2505 s->mb_intra= 1; | |
2506 motion_x= s->mv[0][0][0] = 0; | |
2507 motion_y= s->mv[0][0][1] = 0; | |
2508 break; | |
2509 case CANDIDATE_MB_TYPE_INTER: | |
2510 s->mv_dir = MV_DIR_FORWARD; | |
2511 s->mb_intra= 0; | |
2512 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; | |
2513 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; | |
2514 break; | |
2515 case CANDIDATE_MB_TYPE_INTER_I: | |
2516 s->mv_dir = MV_DIR_FORWARD; | |
2517 s->mv_type = MV_TYPE_FIELD; | |
2518 s->mb_intra= 0; | |
2519 for(i=0; i<2; i++){ | |
2520 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; | |
2521 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; | |
2522 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; | |
2523 } | |
2524 break; | |
2525 case CANDIDATE_MB_TYPE_INTER4V: | |
2526 s->mv_dir = MV_DIR_FORWARD; | |
2527 s->mv_type = MV_TYPE_8X8; | |
2528 s->mb_intra= 0; | |
2529 for(i=0; i<4; i++){ | |
2530 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; | |
2531 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; | |
2532 } | |
2533 break; | |
2534 case CANDIDATE_MB_TYPE_DIRECT: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2535 if (CONFIG_MPEG4_ENCODER) { |
5278 | 2536 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT; |
2537 s->mb_intra= 0; | |
2538 motion_x=s->b_direct_mv_table[xy][0]; | |
2539 motion_y=s->b_direct_mv_table[xy][1]; | |
2540 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); | |
5277
7b3fcb7c61ce
Avoid linking with h263.c functions when the relevant codecs
aurel
parents:
5273
diff
changeset
|
2541 } |
5204 | 2542 break; |
2543 case CANDIDATE_MB_TYPE_DIRECT0: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2544 if (CONFIG_MPEG4_ENCODER) { |
5278 | 2545 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT; |
2546 s->mb_intra= 0; | |
2547 ff_mpeg4_set_direct_mv(s, 0, 0); | |
5277
7b3fcb7c61ce
Avoid linking with h263.c functions when the relevant codecs
aurel
parents:
5273
diff
changeset
|
2548 } |
5204 | 2549 break; |
2550 case CANDIDATE_MB_TYPE_BIDIR: | |
2551 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
2552 s->mb_intra= 0; | |
2553 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; | |
2554 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; | |
2555 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; | |
2556 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; | |
2557 break; | |
2558 case CANDIDATE_MB_TYPE_BACKWARD: | |
2559 s->mv_dir = MV_DIR_BACKWARD; | |
2560 s->mb_intra= 0; | |
2561 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; | |
2562 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; | |
2563 break; | |
2564 case CANDIDATE_MB_TYPE_FORWARD: | |
2565 s->mv_dir = MV_DIR_FORWARD; | |
2566 s->mb_intra= 0; | |
2567 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; | |
2568 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; | |
2569 // printf(" %d %d ", motion_x, motion_y); | |
2570 break; | |
2571 case CANDIDATE_MB_TYPE_FORWARD_I: | |
2572 s->mv_dir = MV_DIR_FORWARD; | |
2573 s->mv_type = MV_TYPE_FIELD; | |
2574 s->mb_intra= 0; | |
2575 for(i=0; i<2; i++){ | |
2576 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; | |
2577 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; | |
2578 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; | |
2579 } | |
2580 break; | |
2581 case CANDIDATE_MB_TYPE_BACKWARD_I: | |
2582 s->mv_dir = MV_DIR_BACKWARD; | |
2583 s->mv_type = MV_TYPE_FIELD; | |
2584 s->mb_intra= 0; | |
2585 for(i=0; i<2; i++){ | |
2586 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; | |
2587 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; | |
2588 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; | |
2589 } | |
2590 break; | |
2591 case CANDIDATE_MB_TYPE_BIDIR_I: | |
2592 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; | |
2593 s->mv_type = MV_TYPE_FIELD; | |
2594 s->mb_intra= 0; | |
2595 for(dir=0; dir<2; dir++){ | |
2596 for(i=0; i<2; i++){ | |
2597 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; | |
2598 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; | |
2599 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; | |
2600 } | |
2601 } | |
2602 break; | |
2603 default: | |
2604 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); | |
2605 } | |
2606 | |
2607 encode_mb(s, motion_x, motion_y); | |
2608 | |
2609 // RAL: Update last macroblock type | |
2610 s->last_mv_dir = s->mv_dir; | |
2611 | |
10727
47e1e474e1f1
Replace CONFIG_ANY_H263_ENCODER definition by CONFIG_H263_ENCODER.
diego
parents:
10683
diff
changeset
|
2612 if (CONFIG_H263_ENCODER && |
6481 | 2613 s->out_format == FMT_H263 && s->pict_type!=FF_B_TYPE) |
5204 | 2614 ff_h263_update_motion_val(s); |
2615 | |
2616 MPV_decode_mb(s, s->block); | |
2617 } | |
2618 | |
2619 /* clean the MV table in IPS frames for direct mode in B frames */ | |
2620 if(s->mb_intra /* && I,P,S_TYPE */){ | |
2621 s->p_mv_table[xy][0]=0; | |
2622 s->p_mv_table[xy][1]=0; | |
2623 } | |
2624 | |
2625 if(s->flags&CODEC_FLAG_PSNR){ | |
2626 int w= 16; | |
2627 int h= 16; | |
2628 | |
2629 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; | |
2630 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; | |
2631 | |
2632 s->current_picture.error[0] += sse( | |
2633 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, | |
2634 s->dest[0], w, h, s->linesize); | |
2635 s->current_picture.error[1] += sse( | |
7520 | 2636 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h, |
2637 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize); | |
5204 | 2638 s->current_picture.error[2] += sse( |
7520 | 2639 s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h, |
2640 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize); | |
5204 | 2641 } |
2642 if(s->loop_filter){ | |
10727
47e1e474e1f1
Replace CONFIG_ANY_H263_ENCODER definition by CONFIG_H263_ENCODER.
diego
parents:
10683
diff
changeset
|
2643 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263) |
5204 | 2644 ff_h263_loop_filter(s); |
2645 } | |
2646 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb)); | |
2647 } | |
2648 } | |
2649 | |
2650 //not beautiful here but we must write it before flushing so it has to be here | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2651 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == FF_I_TYPE) |
5204 | 2652 msmpeg4_encode_ext_header(s); |
2653 | |
2654 write_slice_end(s); | |
2655 | |
2656 /* Send the last GOB if RTP */ | |
2657 if (s->avctx->rtp_callback) { | |
2658 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x; | |
9431 | 2659 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob; |
5204 | 2660 /* Call the RTP callback to send the last GOB */ |
2661 emms_c(); | |
2662 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); | |
2663 } | |
2664 | |
2665 return 0; | |
2666 } | |
2667 | |
2668 #define MERGE(field) dst->field += src->field; src->field=0 | |
2669 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){ | |
2670 MERGE(me.scene_change_score); | |
2671 MERGE(me.mc_mb_var_sum_temp); | |
2672 MERGE(me.mb_var_sum_temp); | |
2673 } | |
2674 | |
2675 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){ | |
2676 int i; | |
2677 | |
2678 MERGE(dct_count[0]); //note, the other dct vars are not part of the context | |
2679 MERGE(dct_count[1]); | |
2680 MERGE(mv_bits); | |
2681 MERGE(i_tex_bits); | |
2682 MERGE(p_tex_bits); | |
2683 MERGE(i_count); | |
2684 MERGE(f_count); | |
2685 MERGE(b_count); | |
2686 MERGE(skip_count); | |
2687 MERGE(misc_bits); | |
2688 MERGE(error_count); | |
2689 MERGE(padding_bug_score); | |
2690 MERGE(current_picture.error[0]); | |
2691 MERGE(current_picture.error[1]); | |
2692 MERGE(current_picture.error[2]); | |
2693 | |
2694 if(dst->avctx->noise_reduction){ | |
2695 for(i=0; i<64; i++){ | |
2696 MERGE(dct_error_sum[0][i]); | |
2697 MERGE(dct_error_sum[1][i]); | |
2698 } | |
2699 } | |
2700 | |
2701 assert(put_bits_count(&src->pb) % 8 ==0); | |
2702 assert(put_bits_count(&dst->pb) % 8 ==0); | |
2703 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb)); | |
2704 flush_put_bits(&dst->pb); | |
2705 } | |
2706 | |
2707 static int estimate_qp(MpegEncContext *s, int dry_run){ | |
2708 if (s->next_lambda){ | |
2709 s->current_picture_ptr->quality= | |
2710 s->current_picture.quality = s->next_lambda; | |
2711 if(!dry_run) s->next_lambda= 0; | |
2712 } else if (!s->fixed_qscale) { | |
2713 s->current_picture_ptr->quality= | |
2714 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run); | |
2715 if (s->current_picture.quality < 0) | |
2716 return -1; | |
2717 } | |
2718 | |
2719 if(s->adaptive_quant){ | |
2720 switch(s->codec_id){ | |
2721 case CODEC_ID_MPEG4: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2722 if (CONFIG_MPEG4_ENCODER) |
5278 | 2723 ff_clean_mpeg4_qscales(s); |
5204 | 2724 break; |
2725 case CODEC_ID_H263: | |
2726 case CODEC_ID_H263P: | |
2727 case CODEC_ID_FLV1: | |
10034
ea2422aa4635
Do not check for both CONFIG_H263_ENCODER and CONFIG_FLV_ENCODER.
diego
parents:
10032
diff
changeset
|
2728 if (CONFIG_H263_ENCODER) |
5278 | 2729 ff_clean_h263_qscales(s); |
5204 | 2730 break; |
10637
afd44c3040f5
Make sure ff_init_qscale_tab() is called one way or another when
michael
parents:
10636
diff
changeset
|
2731 default: |
afd44c3040f5
Make sure ff_init_qscale_tab() is called one way or another when
michael
parents:
10636
diff
changeset
|
2732 ff_init_qscale_tab(s); |
5204 | 2733 } |
2734 | |
2735 s->lambda= s->lambda_table[0]; | |
2736 //FIXME broken | |
2737 }else | |
2738 s->lambda= s->current_picture.quality; | |
2739 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); | |
2740 update_qscale(s); | |
2741 return 0; | |
2742 } | |
2743 | |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2744 /* must be called before writing the header */ |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2745 static void set_frame_distances(MpegEncContext * s){ |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2746 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE); |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2747 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num; |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2748 |
6481 | 2749 if(s->pict_type==FF_B_TYPE){ |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2750 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2751 assert(s->pb_time > 0 && s->pb_time < s->pp_time); |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2752 }else{ |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2753 s->pp_time= s->time - s->last_non_b_time; |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2754 s->last_non_b_time= s->time; |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2755 assert(s->picture_number==0 || s->pp_time > 0); |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2756 } |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2757 } |
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2758 |
5204 | 2759 static int encode_picture(MpegEncContext *s, int picture_number) |
2760 { | |
2761 int i; | |
2762 int bits; | |
2763 | |
2764 s->picture_number = picture_number; | |
2765 | |
2766 /* Reset the average MB variance */ | |
2767 s->me.mb_var_sum_temp = | |
2768 s->me.mc_mb_var_sum_temp = 0; | |
2769 | |
2770 /* we need to initialize some time vars before we can encode b-frames */ | |
2771 // RAL: Condition added for MPEG1VIDEO | |
2772 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) | |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2773 set_frame_distances(s); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2774 if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4) |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5229
diff
changeset
|
2775 ff_set_mpeg4_time(s); |
5204 | 2776 |
2777 s->me.scene_change_score=0; | |
2778 | |
6719 | 2779 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion |
5204 | 2780 |
6481 | 2781 if(s->pict_type==FF_I_TYPE){ |
5204 | 2782 if(s->msmpeg4_version >= 3) s->no_rounding=1; |
2783 else s->no_rounding=0; | |
6481 | 2784 }else if(s->pict_type!=FF_B_TYPE){ |
5204 | 2785 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) |
2786 s->no_rounding ^= 1; | |
2787 } | |
2788 | |
2789 if(s->flags & CODEC_FLAG_PASS2){ | |
2790 if (estimate_qp(s,1) < 0) | |
2791 return -1; | |
2792 ff_get_2pass_fcode(s); | |
2793 }else if(!(s->flags & CODEC_FLAG_QSCALE)){ | |
6481 | 2794 if(s->pict_type==FF_B_TYPE) |
5204 | 2795 s->lambda= s->last_lambda_for[s->pict_type]; |
2796 else | |
2797 s->lambda= s->last_lambda_for[s->last_non_b_pict_type]; | |
2798 update_qscale(s); | |
2799 } | |
2800 | |
2801 s->mb_intra=0; //for the rate distortion & bit compare functions | |
2802 for(i=1; i<s->avctx->thread_count; i++){ | |
2803 ff_update_duplicate_context(s->thread_context[i], s); | |
2804 } | |
2805 | |
7767 | 2806 if(ff_init_me(s)<0) |
2807 return -1; | |
5204 | 2808 |
2809 /* Estimate motion for every MB */ | |
6481 | 2810 if(s->pict_type != FF_I_TYPE){ |
5204 | 2811 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8; |
2812 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8; | |
6481 | 2813 if(s->pict_type != FF_B_TYPE && s->avctx->me_threshold==0){ |
2814 if((s->avctx->pre_me && s->last_non_b_pict_type==FF_I_TYPE) || s->avctx->pre_me==2){ | |
10368
59ec306245a4
Remove casts that are useless since the argument is void *.
reimar
parents:
10155
diff
changeset
|
2815 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*)); |
5204 | 2816 } |
2817 } | |
2818 | |
10368
59ec306245a4
Remove casts that are useless since the argument is void *.
reimar
parents:
10155
diff
changeset
|
2819 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*)); |
6481 | 2820 }else /* if(s->pict_type == FF_I_TYPE) */{ |
5204 | 2821 /* I-Frame */ |
2822 for(i=0; i<s->mb_stride*s->mb_height; i++) | |
2823 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
2824 | |
2825 if(!s->fixed_qscale){ | |
2826 /* finding spatial complexity for I-frame rate control */ | |
10368
59ec306245a4
Remove casts that are useless since the argument is void *.
reimar
parents:
10155
diff
changeset
|
2827 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*)); |
5204 | 2828 } |
2829 } | |
2830 for(i=1; i<s->avctx->thread_count; i++){ | |
2831 merge_context_after_me(s, s->thread_context[i]); | |
2832 } | |
2833 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp; | |
2834 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; | |
2835 emms_c(); | |
2836 | |
6481 | 2837 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == FF_P_TYPE){ |
2838 s->pict_type= FF_I_TYPE; | |
5204 | 2839 for(i=0; i<s->mb_stride*s->mb_height; i++) |
2840 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
2841 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); | |
2842 } | |
2843 | |
2844 if(!s->umvplus){ | |
6481 | 2845 if(s->pict_type==FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
5204 | 2846 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); |
2847 | |
2848 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
2849 int a,b; | |
2850 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select | |
2851 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); | |
6655
22cca5d3173a
Implement FFMAX3(a,b,c) - maximum over three arguments.
voroshil
parents:
6517
diff
changeset
|
2852 s->f_code= FFMAX3(s->f_code, a, b); |
5204 | 2853 } |
2854 | |
2855 ff_fix_long_p_mvs(s); | |
2856 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
2857 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
2858 int j; | |
2859 for(i=0; i<2; i++){ | |
2860 for(j=0; j<2; j++) | |
2861 ff_fix_long_mvs(s, s->p_field_select_table[i], j, | |
2862 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); | |
2863 } | |
2864 } | |
2865 } | |
2866 | |
6481 | 2867 if(s->pict_type==FF_B_TYPE){ |
5204 | 2868 int a, b; |
2869 | |
2870 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); | |
2871 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
2872 s->f_code = FFMAX(a, b); | |
2873 | |
2874 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); | |
2875 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); | |
2876 s->b_code = FFMAX(a, b); | |
2877 | |
2878 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); | |
2879 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); | |
2880 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
2881 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); | |
2882 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
2883 int dir, j; | |
2884 for(dir=0; dir<2; dir++){ | |
2885 for(i=0; i<2; i++){ | |
2886 for(j=0; j<2; j++){ | |
2887 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) | |
2888 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); | |
2889 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, | |
2890 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); | |
2891 } | |
2892 } | |
2893 } | |
2894 } | |
2895 } | |
2896 } | |
2897 | |
2898 if (estimate_qp(s, 0) < 0) | |
2899 return -1; | |
2900 | |
6481 | 2901 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==FF_I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) |
5204 | 2902 s->qscale= 3; //reduce clipping problems |
2903 | |
2904 if (s->out_format == FMT_MJPEG) { | |
2905 /* for mjpeg, we do include qscale in the matrix */ | |
2906 for(i=1;i<64;i++){ | |
2907 int j= s->dsp.idct_permutation[i]; | |
2908 | |
2909 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); | |
2910 } | |
11494 | 2911 s->y_dc_scale_table= |
11495 | 2912 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision]; |
2913 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8]; | |
5789 | 2914 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, |
5204 | 2915 s->intra_matrix, s->intra_quant_bias, 8, 8, 1); |
2916 s->qscale= 8; | |
2917 } | |
2918 | |
2919 //FIXME var duplication | |
2920 s->current_picture_ptr->key_frame= | |
6481 | 2921 s->current_picture.key_frame= s->pict_type == FF_I_TYPE; //FIXME pic_ptr |
5204 | 2922 s->current_picture_ptr->pict_type= |
2923 s->current_picture.pict_type= s->pict_type; | |
2924 | |
2925 if(s->current_picture.key_frame) | |
2926 s->picture_in_gop_number=0; | |
2927 | |
2928 s->last_bits= put_bits_count(&s->pb); | |
2929 switch(s->out_format) { | |
2930 case FMT_MJPEG: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2931 if (CONFIG_MJPEG_ENCODER) |
5204 | 2932 ff_mjpeg_encode_picture_header(s); |
2933 break; | |
2934 case FMT_H261: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2935 if (CONFIG_H261_ENCODER) |
5204 | 2936 ff_h261_encode_picture_header(s, picture_number); |
2937 break; | |
2938 case FMT_H263: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2939 if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2) |
5204 | 2940 ff_wmv2_encode_picture_header(s, picture_number); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2941 else if (CONFIG_MSMPEG4_ENCODER && s->h263_msmpeg4) |
5204 | 2942 msmpeg4_encode_picture_header(s, picture_number); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2943 else if (CONFIG_MPEG4_ENCODER && s->h263_pred) |
5204 | 2944 mpeg4_encode_picture_header(s, picture_number); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2945 else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10) |
5204 | 2946 rv10_encode_picture_header(s, picture_number); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2947 else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20) |
5204 | 2948 rv20_encode_picture_header(s, picture_number); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2949 else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1) |
5204 | 2950 ff_flv_encode_picture_header(s, picture_number); |
10727
47e1e474e1f1
Replace CONFIG_ANY_H263_ENCODER definition by CONFIG_H263_ENCODER.
diego
parents:
10683
diff
changeset
|
2951 else if (CONFIG_H263_ENCODER) |
5204 | 2952 h263_encode_picture_header(s, picture_number); |
2953 break; | |
2954 case FMT_MPEG1: | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8227
diff
changeset
|
2955 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) |
5209 | 2956 mpeg1_encode_picture_header(s, picture_number); |
5204 | 2957 break; |
2958 case FMT_H264: | |
2959 break; | |
2960 default: | |
2961 assert(0); | |
2962 } | |
2963 bits= put_bits_count(&s->pb); | |
2964 s->header_bits= bits - s->last_bits; | |
2965 | |
2966 for(i=1; i<s->avctx->thread_count; i++){ | |
2967 update_duplicate_context_after_me(s->thread_context[i], s); | |
2968 } | |
10368
59ec306245a4
Remove casts that are useless since the argument is void *.
reimar
parents:
10155
diff
changeset
|
2969 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, s->avctx->thread_count, sizeof(void*)); |
5204 | 2970 for(i=1; i<s->avctx->thread_count; i++){ |
2971 merge_context_after_encode(s, s->thread_context[i]); | |
2972 } | |
2973 emms_c(); | |
2974 return 0; | |
2975 } | |
2976 | |
2977 void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ | |
2978 const int intra= s->mb_intra; | |
2979 int i; | |
2980 | |
2981 s->dct_count[intra]++; | |
2982 | |
2983 for(i=0; i<64; i++){ | |
2984 int level= block[i]; | |
2985 | |
2986 if(level){ | |
2987 if(level>0){ | |
2988 s->dct_error_sum[intra][i] += level; | |
2989 level -= s->dct_offset[intra][i]; | |
2990 if(level<0) level=0; | |
2991 }else{ | |
2992 s->dct_error_sum[intra][i] -= level; | |
2993 level += s->dct_offset[intra][i]; | |
2994 if(level>0) level=0; | |
2995 } | |
2996 block[i]= level; | |
2997 } | |
2998 } | |
2999 } | |
3000 | |
3001 int dct_quantize_trellis_c(MpegEncContext *s, | |
3002 DCTELEM *block, int n, | |
3003 int qscale, int *overflow){ | |
3004 const int *qmat; | |
3005 const uint8_t *scantable= s->intra_scantable.scantable; | |
3006 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
3007 int max=0; | |
3008 unsigned int threshold1, threshold2; | |
3009 int bias=0; | |
3010 int run_tab[65]; | |
3011 int level_tab[65]; | |
3012 int score_tab[65]; | |
3013 int survivor[65]; | |
3014 int survivor_count; | |
3015 int last_run=0; | |
3016 int last_level=0; | |
3017 int last_score= 0; | |
3018 int last_i; | |
3019 int coeff[2][64]; | |
3020 int coeff_count[64]; | |
3021 int qmul, qadd, start_i, last_non_zero, i, dc; | |
3022 const int esc_length= s->ac_esc_length; | |
3023 uint8_t * length; | |
3024 uint8_t * last_length; | |
3025 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); | |
3026 | |
3027 s->dsp.fdct (block); | |
3028 | |
3029 if(s->dct_error_sum) | |
3030 s->denoise_dct(s, block); | |
3031 qmul= qscale*16; | |
3032 qadd= ((qscale-1)|1)*8; | |
3033 | |
3034 if (s->mb_intra) { | |
3035 int q; | |
3036 if (!s->h263_aic) { | |
3037 if (n < 4) | |
3038 q = s->y_dc_scale; | |
3039 else | |
3040 q = s->c_dc_scale; | |
3041 q = q << 3; | |
3042 } else{ | |
3043 /* For AIC we skip quant/dequant of INTRADC */ | |
3044 q = 1 << 3; | |
3045 qadd=0; | |
3046 } | |
3047 | |
3048 /* note: block[0] is assumed to be positive */ | |
3049 block[0] = (block[0] + (q >> 1)) / q; | |
3050 start_i = 1; | |
3051 last_non_zero = 0; | |
3052 qmat = s->q_intra_matrix[qscale]; | |
3053 if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
3054 bias= 1<<(QMAT_SHIFT-1); | |
3055 length = s->intra_ac_vlc_length; | |
3056 last_length= s->intra_ac_vlc_last_length; | |
3057 } else { | |
3058 start_i = 0; | |
3059 last_non_zero = -1; | |
3060 qmat = s->q_inter_matrix[qscale]; | |
3061 length = s->inter_ac_vlc_length; | |
3062 last_length= s->inter_ac_vlc_last_length; | |
3063 } | |
3064 last_i= start_i; | |
3065 | |
3066 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
3067 threshold2= (threshold1<<1); | |
3068 | |
3069 for(i=63; i>=start_i; i--) { | |
3070 const int j = scantable[i]; | |
3071 int level = block[j] * qmat[j]; | |
3072 | |
3073 if(((unsigned)(level+threshold1))>threshold2){ | |
3074 last_non_zero = i; | |
3075 break; | |
3076 } | |
3077 } | |
3078 | |
3079 for(i=start_i; i<=last_non_zero; i++) { | |
3080 const int j = scantable[i]; | |
3081 int level = block[j] * qmat[j]; | |
3082 | |
3083 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
3084 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
3085 if(((unsigned)(level+threshold1))>threshold2){ | |
3086 if(level>0){ | |
3087 level= (bias + level)>>QMAT_SHIFT; | |
3088 coeff[0][i]= level; | |
3089 coeff[1][i]= level-1; | |
3090 // coeff[2][k]= level-2; | |
3091 }else{ | |
3092 level= (bias - level)>>QMAT_SHIFT; | |
3093 coeff[0][i]= -level; | |
3094 coeff[1][i]= -level+1; | |
3095 // coeff[2][k]= -level+2; | |
3096 } | |
3097 coeff_count[i]= FFMIN(level, 2); | |
3098 assert(coeff_count[i]); | |
3099 max |=level; | |
3100 }else{ | |
3101 coeff[0][i]= (level>>31)|1; | |
3102 coeff_count[i]= 1; | |
3103 } | |
3104 } | |
3105 | |
3106 *overflow= s->max_qcoeff < max; //overflow might have happened | |
3107 | |
3108 if(last_non_zero < start_i){ | |
3109 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
3110 return last_non_zero; | |
3111 } | |
3112 | |
3113 score_tab[start_i]= 0; | |
3114 survivor[0]= start_i; | |
3115 survivor_count= 1; | |
3116 | |
3117 for(i=start_i; i<=last_non_zero; i++){ | |
6719 | 3118 int level_index, j, zero_distortion; |
6401 | 3119 int dct_coeff= FFABS(block[ scantable[i] ]); |
5204 | 3120 int best_score=256*256*256*120; |
6401 | 3121 |
3122 if ( s->dsp.fdct == fdct_ifast | |
3123 #ifndef FAAN_POSTSCALE | |
3124 || s->dsp.fdct == ff_faandct | |
3125 #endif | |
3126 ) | |
8117
a0f9045e0a82
Promote inv_aanscales array to global scope (ff_inv_aanscales)
pross
parents:
7974
diff
changeset
|
3127 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12; |
6719 | 3128 zero_distortion= dct_coeff*dct_coeff; |
6401 | 3129 |
5204 | 3130 for(level_index=0; level_index < coeff_count[i]; level_index++){ |
6719 | 3131 int distortion; |
5204 | 3132 int level= coeff[level_index][i]; |
3133 const int alevel= FFABS(level); | |
3134 int unquant_coeff; | |
3135 | |
3136 assert(level); | |
3137 | |
3138 if(s->out_format == FMT_H263){ | |
3139 unquant_coeff= alevel*qmul + qadd; | |
3140 }else{ //MPEG1 | |
3141 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize | |
3142 if(s->mb_intra){ | |
3143 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; | |
3144 unquant_coeff = (unquant_coeff - 1) | 1; | |
3145 }else{ | |
3146 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; | |
3147 unquant_coeff = (unquant_coeff - 1) | 1; | |
3148 } | |
3149 unquant_coeff<<= 3; | |
3150 } | |
3151 | |
6719 | 3152 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion; |
5204 | 3153 level+=64; |
3154 if((level&(~127)) == 0){ | |
3155 for(j=survivor_count-1; j>=0; j--){ | |
3156 int run= i - survivor[j]; | |
6719 | 3157 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
5204 | 3158 score += score_tab[i-run]; |
3159 | |
3160 if(score < best_score){ | |
3161 best_score= score; | |
3162 run_tab[i+1]= run; | |
3163 level_tab[i+1]= level-64; | |
3164 } | |
3165 } | |
3166 | |
3167 if(s->out_format == FMT_H263){ | |
3168 for(j=survivor_count-1; j>=0; j--){ | |
3169 int run= i - survivor[j]; | |
6719 | 3170 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; |
5204 | 3171 score += score_tab[i-run]; |
3172 if(score < last_score){ | |
3173 last_score= score; | |
3174 last_run= run; | |
3175 last_level= level-64; | |
3176 last_i= i+1; | |
3177 } | |
3178 } | |
3179 } | |
3180 }else{ | |
6719 | 3181 distortion += esc_length*lambda; |
5204 | 3182 for(j=survivor_count-1; j>=0; j--){ |
3183 int run= i - survivor[j]; | |
6719 | 3184 int score= distortion + score_tab[i-run]; |
5204 | 3185 |
3186 if(score < best_score){ | |
3187 best_score= score; | |
3188 run_tab[i+1]= run; | |
3189 level_tab[i+1]= level-64; | |
3190 } | |
3191 } | |
3192 | |
3193 if(s->out_format == FMT_H263){ | |
3194 for(j=survivor_count-1; j>=0; j--){ | |
3195 int run= i - survivor[j]; | |
6719 | 3196 int score= distortion + score_tab[i-run]; |
5204 | 3197 if(score < last_score){ |
3198 last_score= score; | |
3199 last_run= run; | |
3200 last_level= level-64; | |
3201 last_i= i+1; | |
3202 } | |
3203 } | |
3204 } | |
3205 } | |
3206 } | |
3207 | |
3208 score_tab[i+1]= best_score; | |
3209 | |
3210 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level | |
3211 if(last_non_zero <= 27){ | |
3212 for(; survivor_count; survivor_count--){ | |
3213 if(score_tab[ survivor[survivor_count-1] ] <= best_score) | |
3214 break; | |
3215 } | |
3216 }else{ | |
3217 for(; survivor_count; survivor_count--){ | |
3218 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) | |
3219 break; | |
3220 } | |
3221 } | |
3222 | |
3223 survivor[ survivor_count++ ]= i+1; | |
3224 } | |
3225 | |
3226 if(s->out_format != FMT_H263){ | |
3227 last_score= 256*256*256*120; | |
3228 for(i= survivor[0]; i<=last_non_zero + 1; i++){ | |
3229 int score= score_tab[i]; | |
3230 if(i) score += lambda*2; //FIXME exacter? | |
3231 | |
3232 if(score < last_score){ | |
3233 last_score= score; | |
3234 last_i= i; | |
3235 last_level= level_tab[i]; | |
3236 last_run= run_tab[i]; | |
3237 } | |
3238 } | |
3239 } | |
3240 | |
3241 s->coded_score[n] = last_score; | |
3242 | |
3243 dc= FFABS(block[0]); | |
3244 last_non_zero= last_i - 1; | |
3245 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); | |
3246 | |
3247 if(last_non_zero < start_i) | |
3248 return last_non_zero; | |
3249 | |
3250 if(last_non_zero == 0 && start_i == 0){ | |
3251 int best_level= 0; | |
3252 int best_score= dc * dc; | |
3253 | |
3254 for(i=0; i<coeff_count[0]; i++){ | |
3255 int level= coeff[i][0]; | |
3256 int alevel= FFABS(level); | |
3257 int unquant_coeff, score, distortion; | |
3258 | |
3259 if(s->out_format == FMT_H263){ | |
3260 unquant_coeff= (alevel*qmul + qadd)>>3; | |
3261 }else{ //MPEG1 | |
3262 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; | |
3263 unquant_coeff = (unquant_coeff - 1) | 1; | |
3264 } | |
3265 unquant_coeff = (unquant_coeff + 4) >> 3; | |
3266 unquant_coeff<<= 3 + 3; | |
3267 | |
3268 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); | |
3269 level+=64; | |
3270 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; | |
3271 else score= distortion + esc_length*lambda; | |
3272 | |
3273 if(score < best_score){ | |
3274 best_score= score; | |
3275 best_level= level - 64; | |
3276 } | |
3277 } | |
3278 block[0]= best_level; | |
3279 s->coded_score[n] = best_score - dc*dc; | |
3280 if(best_level == 0) return -1; | |
3281 else return last_non_zero; | |
3282 } | |
3283 | |
3284 i= last_i; | |
3285 assert(last_level); | |
3286 | |
3287 block[ perm_scantable[last_non_zero] ]= last_level; | |
3288 i -= last_run + 1; | |
3289 | |
3290 for(; i>start_i; i -= run_tab[i] + 1){ | |
3291 block[ perm_scantable[i-1] ]= level_tab[i]; | |
3292 } | |
3293 | |
3294 return last_non_zero; | |
3295 } | |
3296 | |
3297 //#define REFINE_STATS 1 | |
3298 static int16_t basis[64][64]; | |
3299 | |
3300 static void build_basis(uint8_t *perm){ | |
3301 int i, j, x, y; | |
3302 emms_c(); | |
3303 for(i=0; i<8; i++){ | |
3304 for(j=0; j<8; j++){ | |
3305 for(y=0; y<8; y++){ | |
3306 for(x=0; x<8; x++){ | |
3307 double s= 0.25*(1<<BASIS_SHIFT); | |
3308 int index= 8*i + j; | |
3309 int perm_index= perm[index]; | |
3310 if(i==0) s*= sqrt(0.5); | |
3311 if(j==0) s*= sqrt(0.5); | |
3312 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5))); | |
3313 } | |
3314 } | |
3315 } | |
3316 } | |
3317 } | |
3318 | |
3319 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? | |
3320 DCTELEM *block, int16_t *weight, DCTELEM *orig, | |
3321 int n, int qscale){ | |
3322 int16_t rem[64]; | |
11195 | 3323 LOCAL_ALIGNED_16(DCTELEM, d1, [64]); |
5204 | 3324 const uint8_t *scantable= s->intra_scantable.scantable; |
3325 const uint8_t *perm_scantable= s->intra_scantable.permutated; | |
3326 // unsigned int threshold1, threshold2; | |
3327 // int bias=0; | |
3328 int run_tab[65]; | |
3329 int prev_run=0; | |
3330 int prev_level=0; | |
3331 int qmul, qadd, start_i, last_non_zero, i, dc; | |
3332 uint8_t * length; | |
3333 uint8_t * last_length; | |
3334 int lambda; | |
3335 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true | |
3336 #ifdef REFINE_STATS | |
3337 static int count=0; | |
3338 static int after_last=0; | |
3339 static int to_zero=0; | |
3340 static int from_zero=0; | |
3341 static int raise=0; | |
3342 static int lower=0; | |
3343 static int messed_sign=0; | |
3344 #endif | |
3345 | |
3346 if(basis[0][0] == 0) | |
3347 build_basis(s->dsp.idct_permutation); | |
3348 | |
3349 qmul= qscale*2; | |
3350 qadd= (qscale-1)|1; | |
3351 if (s->mb_intra) { | |
3352 if (!s->h263_aic) { | |
3353 if (n < 4) | |
3354 q = s->y_dc_scale; | |
3355 else | |
3356 q = s->c_dc_scale; | |
3357 } else{ | |
3358 /* For AIC we skip quant/dequant of INTRADC */ | |
3359 q = 1; | |
3360 qadd=0; | |
3361 } | |
3362 q <<= RECON_SHIFT-3; | |
3363 /* note: block[0] is assumed to be positive */ | |
3364 dc= block[0]*q; | |
3365 // block[0] = (block[0] + (q >> 1)) / q; | |
3366 start_i = 1; | |
3367 // if(s->mpeg_quant || s->out_format == FMT_MPEG1) | |
3368 // bias= 1<<(QMAT_SHIFT-1); | |
3369 length = s->intra_ac_vlc_length; | |
3370 last_length= s->intra_ac_vlc_last_length; | |
3371 } else { | |
3372 dc= 0; | |
3373 start_i = 0; | |
3374 length = s->inter_ac_vlc_length; | |
3375 last_length= s->inter_ac_vlc_last_length; | |
3376 } | |
3377 last_non_zero = s->block_last_index[n]; | |
3378 | |
3379 #ifdef REFINE_STATS | |
3380 {START_TIMER | |
3381 #endif | |
3382 dc += (1<<(RECON_SHIFT-1)); | |
3383 for(i=0; i<64; i++){ | |
3384 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] | |
3385 } | |
3386 #ifdef REFINE_STATS | |
3387 STOP_TIMER("memset rem[]")} | |
3388 #endif | |
3389 sum=0; | |
3390 for(i=0; i<64; i++){ | |
3391 int one= 36; | |
3392 int qns=4; | |
3393 int w; | |
3394 | |
3395 w= FFABS(weight[i]) + qns*one; | |
3396 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 | |
3397 | |
3398 weight[i] = w; | |
3399 // w=weight[i] = (63*qns + (w/2)) / w; | |
3400 | |
3401 assert(w>0); | |
3402 assert(w<(1<<6)); | |
3403 sum += w*w; | |
3404 } | |
3405 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); | |
3406 #ifdef REFINE_STATS | |
3407 {START_TIMER | |
3408 #endif | |
3409 run=0; | |
3410 rle_index=0; | |
3411 for(i=start_i; i<=last_non_zero; i++){ | |
3412 int j= perm_scantable[i]; | |
3413 const int level= block[j]; | |
3414 int coeff; | |
3415 | |
3416 if(level){ | |
3417 if(level<0) coeff= qmul*level - qadd; | |
3418 else coeff= qmul*level + qadd; | |
3419 run_tab[rle_index++]=run; | |
3420 run=0; | |
3421 | |
3422 s->dsp.add_8x8basis(rem, basis[j], coeff); | |
3423 }else{ | |
3424 run++; | |
3425 } | |
3426 } | |
3427 #ifdef REFINE_STATS | |
3428 if(last_non_zero>0){ | |
3429 STOP_TIMER("init rem[]") | |
3430 } | |
3431 } | |
3432 | |
3433 {START_TIMER | |
3434 #endif | |
3435 for(;;){ | |
3436 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); | |
3437 int best_coeff=0; | |
3438 int best_change=0; | |
3439 int run2, best_unquant_change=0, analyze_gradient; | |
3440 #ifdef REFINE_STATS | |
3441 {START_TIMER | |
3442 #endif | |
3443 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3; | |
3444 | |
3445 if(analyze_gradient){ | |
3446 #ifdef REFINE_STATS | |
3447 {START_TIMER | |
3448 #endif | |
3449 for(i=0; i<64; i++){ | |
3450 int w= weight[i]; | |
3451 | |
3452 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12); | |
3453 } | |
3454 #ifdef REFINE_STATS | |
3455 STOP_TIMER("rem*w*w")} | |
3456 {START_TIMER | |
3457 #endif | |
3458 s->dsp.fdct(d1); | |
3459 #ifdef REFINE_STATS | |
3460 STOP_TIMER("dct")} | |
3461 #endif | |
3462 } | |
3463 | |
3464 if(start_i){ | |
3465 const int level= block[0]; | |
3466 int change, old_coeff; | |
3467 | |
3468 assert(s->mb_intra); | |
3469 | |
3470 old_coeff= q*level; | |
3471 | |
3472 for(change=-1; change<=1; change+=2){ | |
3473 int new_level= level + change; | |
3474 int score, new_coeff; | |
3475 | |
3476 new_coeff= q*new_level; | |
3477 if(new_coeff >= 2048 || new_coeff < 0) | |
3478 continue; | |
3479 | |
3480 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); | |
3481 if(score<best_score){ | |
3482 best_score= score; | |
3483 best_coeff= 0; | |
3484 best_change= change; | |
3485 best_unquant_change= new_coeff - old_coeff; | |
3486 } | |
3487 } | |
3488 } | |
3489 | |
3490 run=0; | |
3491 rle_index=0; | |
3492 run2= run_tab[rle_index++]; | |
3493 prev_level=0; | |
3494 prev_run=0; | |
3495 | |
3496 for(i=start_i; i<64; i++){ | |
3497 int j= perm_scantable[i]; | |
3498 const int level= block[j]; | |
3499 int change, old_coeff; | |
3500 | |
3501 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) | |
3502 break; | |
3503 | |
3504 if(level){ | |
3505 if(level<0) old_coeff= qmul*level - qadd; | |
3506 else old_coeff= qmul*level + qadd; | |
3507 run2= run_tab[rle_index++]; //FIXME ! maybe after last | |
3508 }else{ | |
3509 old_coeff=0; | |
3510 run2--; | |
3511 assert(run2>=0 || i >= last_non_zero ); | |
3512 } | |
3513 | |
3514 for(change=-1; change<=1; change+=2){ | |
3515 int new_level= level + change; | |
3516 int score, new_coeff, unquant_change; | |
3517 | |
3518 score=0; | |
3519 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) | |
3520 continue; | |
3521 | |
3522 if(new_level){ | |
3523 if(new_level<0) new_coeff= qmul*new_level - qadd; | |
3524 else new_coeff= qmul*new_level + qadd; | |
3525 if(new_coeff >= 2048 || new_coeff <= -2048) | |
3526 continue; | |
3527 //FIXME check for overflow | |
3528 | |
3529 if(level){ | |
3530 if(level < 63 && level > -63){ | |
3531 if(i < last_non_zero) | |
3532 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
3533 - length[UNI_AC_ENC_INDEX(run, level+64)]; | |
3534 else | |
3535 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] | |
3536 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; | |
3537 } | |
3538 }else{ | |
3539 assert(FFABS(new_level)==1); | |
3540 | |
3541 if(analyze_gradient){ | |
3542 int g= d1[ scantable[i] ]; | |
3543 if(g && (g^new_level) >= 0) | |
3544 continue; | |
3545 } | |
3546 | |
3547 if(i < last_non_zero){ | |
3548 int next_i= i + run2 + 1; | |
3549 int next_level= block[ perm_scantable[next_i] ] + 64; | |
3550 | |
3551 if(next_level&(~127)) | |
3552 next_level= 0; | |
3553 | |
3554 if(next_i < last_non_zero) | |
3555 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
3556 + length[UNI_AC_ENC_INDEX(run2, next_level)] | |
3557 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
3558 else | |
3559 score += length[UNI_AC_ENC_INDEX(run, 65)] | |
3560 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
3561 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; | |
3562 }else{ | |
3563 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
3564 if(prev_level){ | |
3565 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
3566 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
3567 } | |
3568 } | |
3569 } | |
3570 }else{ | |
3571 new_coeff=0; | |
3572 assert(FFABS(level)==1); | |
3573 | |
3574 if(i < last_non_zero){ | |
3575 int next_i= i + run2 + 1; | |
3576 int next_level= block[ perm_scantable[next_i] ] + 64; | |
3577 | |
3578 if(next_level&(~127)) | |
3579 next_level= 0; | |
3580 | |
3581 if(next_i < last_non_zero) | |
3582 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
3583 - length[UNI_AC_ENC_INDEX(run2, next_level)] | |
3584 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
3585 else | |
3586 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] | |
3587 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] | |
3588 - length[UNI_AC_ENC_INDEX(run, 65)]; | |
3589 }else{ | |
3590 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; | |
3591 if(prev_level){ | |
3592 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] | |
3593 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; | |
3594 } | |
3595 } | |
3596 } | |
3597 | |
3598 score *= lambda; | |
3599 | |
3600 unquant_change= new_coeff - old_coeff; | |
3601 assert((score < 100*lambda && score > -100*lambda) || lambda==0); | |
3602 | |
3603 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); | |
3604 if(score<best_score){ | |
3605 best_score= score; | |
3606 best_coeff= i; | |
3607 best_change= change; | |
3608 best_unquant_change= unquant_change; | |
3609 } | |
3610 } | |
3611 if(level){ | |
3612 prev_level= level + 64; | |
3613 if(prev_level&(~127)) | |
3614 prev_level= 0; | |
3615 prev_run= run; | |
3616 run=0; | |
3617 }else{ | |
3618 run++; | |
3619 } | |
3620 } | |
3621 #ifdef REFINE_STATS | |
3622 STOP_TIMER("iterative step")} | |
3623 #endif | |
3624 | |
3625 if(best_change){ | |
3626 int j= perm_scantable[ best_coeff ]; | |
3627 | |
3628 block[j] += best_change; | |
3629 | |
3630 if(best_coeff > last_non_zero){ | |
3631 last_non_zero= best_coeff; | |
3632 assert(block[j]); | |
3633 #ifdef REFINE_STATS | |
3634 after_last++; | |
3635 #endif | |
3636 }else{ | |
3637 #ifdef REFINE_STATS | |
3638 if(block[j]){ | |
3639 if(block[j] - best_change){ | |
3640 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ | |
3641 raise++; | |
3642 }else{ | |
3643 lower++; | |
3644 } | |
3645 }else{ | |
3646 from_zero++; | |
3647 } | |
3648 }else{ | |
3649 to_zero++; | |
3650 } | |
3651 #endif | |
3652 for(; last_non_zero>=start_i; last_non_zero--){ | |
3653 if(block[perm_scantable[last_non_zero]]) | |
3654 break; | |
3655 } | |
3656 } | |
3657 #ifdef REFINE_STATS | |
3658 count++; | |
3659 if(256*256*256*64 % count == 0){ | |
3660 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number); | |
3661 } | |
3662 #endif | |
3663 run=0; | |
3664 rle_index=0; | |
3665 for(i=start_i; i<=last_non_zero; i++){ | |
3666 int j= perm_scantable[i]; | |
3667 const int level= block[j]; | |
3668 | |
3669 if(level){ | |
3670 run_tab[rle_index++]=run; | |
3671 run=0; | |
3672 }else{ | |
3673 run++; | |
3674 } | |
3675 } | |
3676 | |
3677 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); | |
3678 }else{ | |
3679 break; | |
3680 } | |
3681 } | |
3682 #ifdef REFINE_STATS | |
3683 if(last_non_zero>0){ | |
3684 STOP_TIMER("iterative search") | |
3685 } | |
3686 } | |
3687 #endif | |
3688 | |
3689 return last_non_zero; | |
3690 } | |
3691 | |
3692 int dct_quantize_c(MpegEncContext *s, | |
3693 DCTELEM *block, int n, | |
3694 int qscale, int *overflow) | |
3695 { | |
3696 int i, j, level, last_non_zero, q, start_i; | |
3697 const int *qmat; | |
3698 const uint8_t *scantable= s->intra_scantable.scantable; | |
3699 int bias; | |
3700 int max=0; | |
3701 unsigned int threshold1, threshold2; | |
3702 | |
3703 s->dsp.fdct (block); | |
3704 | |
3705 if(s->dct_error_sum) | |
3706 s->denoise_dct(s, block); | |
3707 | |
3708 if (s->mb_intra) { | |
3709 if (!s->h263_aic) { | |
3710 if (n < 4) | |
3711 q = s->y_dc_scale; | |
3712 else | |
3713 q = s->c_dc_scale; | |
3714 q = q << 3; | |
3715 } else | |
3716 /* For AIC we skip quant/dequant of INTRADC */ | |
3717 q = 1 << 3; | |
3718 | |
3719 /* note: block[0] is assumed to be positive */ | |
3720 block[0] = (block[0] + (q >> 1)) / q; | |
3721 start_i = 1; | |
3722 last_non_zero = 0; | |
3723 qmat = s->q_intra_matrix[qscale]; | |
3724 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); | |
3725 } else { | |
3726 start_i = 0; | |
3727 last_non_zero = -1; | |
3728 qmat = s->q_inter_matrix[qscale]; | |
3729 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); | |
3730 } | |
3731 threshold1= (1<<QMAT_SHIFT) - bias - 1; | |
3732 threshold2= (threshold1<<1); | |
3733 for(i=63;i>=start_i;i--) { | |
3734 j = scantable[i]; | |
3735 level = block[j] * qmat[j]; | |
3736 | |
3737 if(((unsigned)(level+threshold1))>threshold2){ | |
3738 last_non_zero = i; | |
3739 break; | |
3740 }else{ | |
3741 block[j]=0; | |
3742 } | |
3743 } | |
3744 for(i=start_i; i<=last_non_zero; i++) { | |
3745 j = scantable[i]; | |
3746 level = block[j] * qmat[j]; | |
3747 | |
3748 // if( bias+level >= (1<<QMAT_SHIFT) | |
3749 // || bias-level >= (1<<QMAT_SHIFT)){ | |
3750 if(((unsigned)(level+threshold1))>threshold2){ | |
3751 if(level>0){ | |
3752 level= (bias + level)>>QMAT_SHIFT; | |
3753 block[j]= level; | |
3754 }else{ | |
3755 level= (bias - level)>>QMAT_SHIFT; | |
3756 block[j]= -level; | |
3757 } | |
3758 max |=level; | |
3759 }else{ | |
3760 block[j]=0; | |
3761 } | |
3762 } | |
3763 *overflow= s->max_qcoeff < max; //overflow might have happened | |
3764 | |
3765 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ | |
3766 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) | |
3767 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); | |
3768 | |
3769 return last_non_zero; | |
3770 } | |
3771 | |
3772 AVCodec h263_encoder = { | |
3773 "h263", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11534
diff
changeset
|
3774 AVMEDIA_TYPE_VIDEO, |
5204 | 3775 CODEC_ID_H263, |
3776 sizeof(MpegEncContext), | |
3777 MPV_encode_init, | |
3778 MPV_encode_picture, | |
3779 MPV_encode_end, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10034
diff
changeset
|
3780 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
8665
5094ddbe4476
Make more descriptive the long names for the various variants of H.263.
stefano
parents:
8629
diff
changeset
|
3781 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"), |
5204 | 3782 }; |
3783 | |
3784 AVCodec h263p_encoder = { | |
3785 "h263p", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11534
diff
changeset
|
3786 AVMEDIA_TYPE_VIDEO, |
5204 | 3787 CODEC_ID_H263P, |
3788 sizeof(MpegEncContext), | |
3789 MPV_encode_init, | |
3790 MPV_encode_picture, | |
3791 MPV_encode_end, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10034
diff
changeset
|
3792 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
8665
5094ddbe4476
Make more descriptive the long names for the various variants of H.263.
stefano
parents:
8629
diff
changeset
|
3793 .long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"), |
5204 | 3794 }; |
3795 | |
3796 AVCodec msmpeg4v1_encoder = { | |
3797 "msmpeg4v1", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11534
diff
changeset
|
3798 AVMEDIA_TYPE_VIDEO, |
5204 | 3799 CODEC_ID_MSMPEG4V1, |
3800 sizeof(MpegEncContext), | |
3801 MPV_encode_init, | |
3802 MPV_encode_picture, | |
3803 MPV_encode_end, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10034
diff
changeset
|
3804 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7034
diff
changeset
|
3805 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), |
5204 | 3806 }; |
3807 | |
3808 AVCodec msmpeg4v2_encoder = { | |
3809 "msmpeg4v2", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11534
diff
changeset
|
3810 AVMEDIA_TYPE_VIDEO, |
5204 | 3811 CODEC_ID_MSMPEG4V2, |
3812 sizeof(MpegEncContext), | |
3813 MPV_encode_init, | |
3814 MPV_encode_picture, | |
3815 MPV_encode_end, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10034
diff
changeset
|
3816 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7034
diff
changeset
|
3817 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), |
5204 | 3818 }; |
3819 | |
3820 AVCodec msmpeg4v3_encoder = { | |
3821 "msmpeg4", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11534
diff
changeset
|
3822 AVMEDIA_TYPE_VIDEO, |
5204 | 3823 CODEC_ID_MSMPEG4V3, |
3824 sizeof(MpegEncContext), | |
3825 MPV_encode_init, | |
3826 MPV_encode_picture, | |
3827 MPV_encode_end, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10034
diff
changeset
|
3828 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7034
diff
changeset
|
3829 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), |
5204 | 3830 }; |
3831 | |
3832 AVCodec wmv1_encoder = { | |
3833 "wmv1", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11534
diff
changeset
|
3834 AVMEDIA_TYPE_VIDEO, |
5204 | 3835 CODEC_ID_WMV1, |
3836 sizeof(MpegEncContext), | |
3837 MPV_encode_init, | |
3838 MPV_encode_picture, | |
3839 MPV_encode_end, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10034
diff
changeset
|
3840 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7034
diff
changeset
|
3841 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"), |
5204 | 3842 }; |