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