2
* The simplest mpeg encoder (well, it was the simplest!)
3
* Copyright (c) 2000,2001 Fabrice Bellard.
4
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6
* This library is free software; you can redistribute it and/or
7
* modify it under the terms of the GNU Lesser General Public
8
* License as published by the Free Software Foundation; either
9
* version 2 of the License, or (at your option) any later version.
11
* This library is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14
* Lesser General Public License for more details.
16
* You should have received a copy of the GNU Lesser General Public
17
* License along with this library; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
* 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
25
* The simplest mpeg encoder (well, it was the simplest!).
30
#include "mpegvideo.h"
35
#include "fastmemcpy.h"
41
#ifdef CONFIG_ENCODERS
42
static void encode_picture(MpegEncContext *s, int picture_number);
43
#endif //CONFIG_ENCODERS
44
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45
DCTELEM *block, int n, int qscale);
46
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47
DCTELEM *block, int n, int qscale);
48
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49
DCTELEM *block, int n, int qscale);
50
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
51
DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53
DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
55
DCTELEM *block, int n, int qscale);
56
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
57
DCTELEM *block, int n, int qscale);
58
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
59
#ifdef CONFIG_ENCODERS
60
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
61
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
62
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
63
static int sse_mb(MpegEncContext *s);
64
static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
65
#endif //CONFIG_ENCODERS
68
extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
69
extern void XVMC_field_end(MpegEncContext *s);
70
extern void XVMC_decode_mb(MpegEncContext *s);
73
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
76
/* enable all paranoid tests for rounding, overflows, etc... */
82
/* for jpeg fast DCT */
85
static const uint16_t aanscales[64] = {
86
/* precomputed values scaled up by 14 bits */
87
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
88
22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
89
21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
90
19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
91
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
92
12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
93
8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
94
4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
97
static const uint8_t h263_chroma_roundtab[16] = {
98
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
99
0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
102
static const uint8_t ff_default_chroma_qscale_table[32]={
103
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
104
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
107
#ifdef CONFIG_ENCODERS
108
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
109
static uint8_t default_fcode_tab[MAX_MV*2+1];
111
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
113
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
114
const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
119
for(qscale=qmin; qscale<=qmax; qscale++){
121
if (dsp->fdct == ff_jpeg_fdct_islow
122
#ifdef FAAN_POSTSCALE
123
|| dsp->fdct == ff_faandct
127
const int j= dsp->idct_permutation[i];
128
/* 16 <= qscale * quant_matrix[i] <= 7905 */
129
/* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
130
/* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
131
/* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
133
qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
134
(qscale * quant_matrix[j]));
136
} else if (dsp->fdct == fdct_ifast
137
#ifndef FAAN_POSTSCALE
138
|| dsp->fdct == ff_faandct
142
const int j= dsp->idct_permutation[i];
143
/* 16 <= qscale * quant_matrix[i] <= 7905 */
144
/* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
145
/* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
146
/* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
148
qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
149
(aanscales[i] * qscale * quant_matrix[j]));
153
const int j= dsp->idct_permutation[i];
154
/* We can safely suppose that 16 <= quant_matrix[i] <= 255
155
So 16 <= qscale * quant_matrix[i] <= 7905
156
so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
157
so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
159
qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
160
// qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
161
qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
163
if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
164
qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
168
for(i=intra; i<64; i++){
170
if (dsp->fdct == fdct_ifast
171
#ifndef FAAN_POSTSCALE
172
|| dsp->fdct == ff_faandct
175
max= (8191LL*aanscales[i]) >> 14;
177
while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
183
av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
187
static inline void update_qscale(MpegEncContext *s){
188
s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
189
s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
191
s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
193
#endif //CONFIG_ENCODERS
195
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
199
st->scantable= src_scantable;
203
j = src_scantable[i];
204
st->permutated[i] = permutation[j];
213
j = st->permutated[i];
215
st->raster_end[i]= end;
219
#ifdef CONFIG_ENCODERS
220
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
226
put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
231
#endif //CONFIG_ENCODERS
233
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
241
uint32_t tmp= *state << 8;
242
*state= tmp + *(p++);
243
if(tmp == 0x100 || p==end)
248
if (p[-1] > 1 ) p+= 3;
249
else if(p[-2] ) p+= 2;
250
else if(p[-3]|(p[-1]-1)) p++;
258
*state= be2me_32(unaligned32(p));
263
/* init common dct for both encoder and decoder */
264
int DCT_common_init(MpegEncContext *s)
266
s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
267
s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
268
s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
269
s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
270
s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
271
if(s->flags & CODEC_FLAG_BITEXACT)
272
s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
273
s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
275
#ifdef CONFIG_ENCODERS
276
s->dct_quantize= dct_quantize_c;
277
s->denoise_dct= denoise_dct_c;
278
#endif //CONFIG_ENCODERS
281
MPV_common_init_mmx(s);
284
MPV_common_init_axp(s);
287
MPV_common_init_mlib(s);
290
MPV_common_init_mmi(s);
293
MPV_common_init_armv4l(s);
296
MPV_common_init_ppc(s);
299
#ifdef CONFIG_ENCODERS
300
s->fast_dct_quantize= s->dct_quantize;
302
if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
303
s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
306
#endif //CONFIG_ENCODERS
308
/* load & permutate scantables
309
note: only wmv uses different ones
311
if(s->alternate_scan){
312
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
313
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
315
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
316
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
318
ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
319
ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
324
static void copy_picture(Picture *dst, Picture *src){
326
dst->type= FF_BUFFER_TYPE_COPY;
329
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
332
dst->pict_type = src->pict_type;
333
dst->quality = src->quality;
334
dst->coded_picture_number = src->coded_picture_number;
335
dst->display_picture_number = src->display_picture_number;
336
// dst->reference = src->reference;
338
dst->interlaced_frame = src->interlaced_frame;
339
dst->top_field_first = src->top_field_first;
341
if(s->avctx->me_threshold){
342
if(!src->motion_val[0])
343
av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
345
av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
346
if(!src->ref_index[0])
347
av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
348
if(src->motion_subsample_log2 != dst->motion_subsample_log2)
349
av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
350
src->motion_subsample_log2, dst->motion_subsample_log2);
352
memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
355
int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
356
int height= ((16*s->mb_height)>>src->motion_subsample_log2);
358
if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
359
memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
361
if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
362
memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
369
* allocates a Picture
370
* The pixels are allocated/set by calling get_buffer() if shared=0
372
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
373
const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
374
const int mb_array_size= s->mb_stride*s->mb_height;
375
const int b8_array_size= s->b8_stride*s->mb_height*2;
376
const int b4_array_size= s->b4_stride*s->mb_height*4;
380
assert(pic->data[0]);
381
assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
382
pic->type= FF_BUFFER_TYPE_SHARED;
386
assert(!pic->data[0]);
388
r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
390
if(r<0 || !pic->age || !pic->type || !pic->data[0]){
391
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
395
if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
396
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
400
if(pic->linesize[1] != pic->linesize[2]){
401
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
405
s->linesize = pic->linesize[0];
406
s->uvlinesize= pic->linesize[1];
409
if(pic->qscale_table==NULL){
411
CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
412
CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
413
CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
416
CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
417
CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
418
CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
419
pic->mb_type= pic->mb_type_base + s->mb_stride+1;
420
if(s->out_format == FMT_H264){
422
CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
423
pic->motion_val[i]= pic->motion_val_base[i]+4;
424
CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
426
pic->motion_subsample_log2= 2;
427
}else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
429
CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
430
pic->motion_val[i]= pic->motion_val_base[i]+4;
431
CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
433
pic->motion_subsample_log2= 3;
435
if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
436
CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
438
pic->qstride= s->mb_stride;
439
CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
442
//it might be nicer if the application would keep track of these but it would require a API change
443
memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
444
s->prev_pict_types[0]= s->pict_type;
445
if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
446
pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
449
fail: //for the CHECKED_ALLOCZ macro
454
* deallocates a picture
456
static void free_picture(MpegEncContext *s, Picture *pic){
459
if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
460
s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
463
av_freep(&pic->mb_var);
464
av_freep(&pic->mc_mb_var);
465
av_freep(&pic->mb_mean);
466
av_freep(&pic->mbskip_table);
467
av_freep(&pic->qscale_table);
468
av_freep(&pic->mb_type_base);
469
av_freep(&pic->dct_coeff);
470
av_freep(&pic->pan_scan);
473
av_freep(&pic->motion_val_base[i]);
474
av_freep(&pic->ref_index[i]);
477
if(pic->type == FF_BUFFER_TYPE_SHARED){
486
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
489
// edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
490
CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
491
s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
493
//FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
494
CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
495
s->rd_scratchpad= s->me.scratchpad;
496
s->b_scratchpad= s->me.scratchpad;
497
s->obmc_scratchpad= s->me.scratchpad + 16;
499
CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
500
CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
501
if(s->avctx->noise_reduction){
502
CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
505
CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
506
s->block= s->blocks[0];
509
s->pblocks[i] = (short *)(&s->block[i]);
513
return -1; //free() through MPV_common_end()
516
static void free_duplicate_context(MpegEncContext *s){
519
av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
520
av_freep(&s->me.scratchpad);
523
s->obmc_scratchpad= NULL;
525
av_freep(&s->dct_error_sum);
526
av_freep(&s->me.map);
527
av_freep(&s->me.score_map);
528
av_freep(&s->blocks);
532
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
533
#define COPY(a) bak->a= src->a
534
COPY(allocated_edge_emu_buffer);
535
COPY(edge_emu_buffer);
539
COPY(obmc_scratchpad);
546
COPY(me.map_generation);
554
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
557
//FIXME copy only needed parts
559
backup_duplicate_context(&bak, dst);
560
memcpy(dst, src, sizeof(MpegEncContext));
561
backup_duplicate_context(dst, &bak);
563
dst->pblocks[i] = (short *)(&dst->block[i]);
565
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
568
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
569
#define COPY(a) dst->a= src->a
571
COPY(current_picture);
577
COPY(picture_in_gop_number);
578
COPY(gop_picture_number);
579
COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
580
COPY(progressive_frame); //FIXME don't set in encode_header
581
COPY(partitioned_frame); //FIXME don't set in encode_header
586
* sets the given MpegEncContext to common defaults (same for encoding and decoding).
587
* the changed fields will not depend upon the prior state of the MpegEncContext.
589
static void MPV_common_defaults(MpegEncContext *s){
591
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
592
s->chroma_qscale_table= ff_default_chroma_qscale_table;
593
s->progressive_frame= 1;
594
s->progressive_sequence= 1;
595
s->picture_structure= PICT_FRAME;
597
s->coded_picture_number = 0;
598
s->picture_number = 0;
599
s->input_picture_number = 0;
601
s->picture_in_gop_number = 0;
608
* sets the given MpegEncContext to defaults for decoding.
609
* the changed fields will not depend upon the prior state of the MpegEncContext.
611
void MPV_decode_defaults(MpegEncContext *s){
612
MPV_common_defaults(s);
616
* sets the given MpegEncContext to defaults for encoding.
617
* the changed fields will not depend upon the prior state of the MpegEncContext.
620
#ifdef CONFIG_ENCODERS
621
static void MPV_encode_defaults(MpegEncContext *s){
624
MPV_common_defaults(s);
630
default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
631
memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
633
for(i=-16; i<16; i++){
634
default_fcode_tab[i + MAX_MV]= 1;
637
s->me.mv_penalty= default_mv_penalty;
638
s->fcode_tab= default_fcode_tab;
640
#endif //CONFIG_ENCODERS
643
* init common structure for both encoder and decoder.
644
* this assumes that some variables like width/height are already set
646
int MPV_common_init(MpegEncContext *s)
648
int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
650
s->mb_height = (s->height + 15) / 16;
652
if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
653
av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
657
if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
660
dsputil_init(&s->dsp, s->avctx);
663
s->flags= s->avctx->flags;
664
s->flags2= s->avctx->flags2;
666
s->mb_width = (s->width + 15) / 16;
667
s->mb_stride = s->mb_width + 1;
668
s->b8_stride = s->mb_width*2 + 1;
669
s->b4_stride = s->mb_width*4 + 1;
670
mb_array_size= s->mb_height * s->mb_stride;
671
mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
673
/* set chroma shifts */
674
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
675
&(s->chroma_y_shift) );
677
/* set default edge pos, will be overriden in decode_header if needed */
678
s->h_edge_pos= s->mb_width*16;
679
s->v_edge_pos= s->mb_height*16;
681
s->mb_num = s->mb_width * s->mb_height;
686
s->block_wrap[3]= s->b8_stride;
688
s->block_wrap[5]= s->mb_stride;
690
y_size = s->b8_stride * (2 * s->mb_height + 1);
691
c_size = s->mb_stride * (s->mb_height + 1);
692
yc_size = y_size + 2 * c_size;
694
/* convert fourcc to upper case */
695
s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
696
+ (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
697
+ (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
698
+ (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
700
s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
701
+ (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
702
+ (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
703
+ (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
705
s->avctx->coded_frame= (AVFrame*)&s->current_picture;
707
CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
708
for(y=0; y<s->mb_height; y++){
709
for(x=0; x<s->mb_width; x++){
710
s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
713
s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
716
/* Allocate MV tables */
717
CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
718
CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
719
CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
720
CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
721
CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
722
CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
723
s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
724
s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
725
s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
726
s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
727
s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
728
s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
730
if(s->msmpeg4_version){
731
CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
733
CHECKED_ALLOCZ(s->avctx->stats_out, 256);
735
/* Allocate MB type table */
736
CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
738
CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
740
CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
741
CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
742
CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
743
CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
744
CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
745
CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
747
if(s->avctx->noise_reduction){
748
CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
751
CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
753
CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
755
if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
756
/* interlaced direct mode decoding tables */
761
CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
762
s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
764
CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
765
CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
766
s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
768
CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
771
if (s->out_format == FMT_H263) {
773
CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
774
s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
775
s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
776
s->ac_val[2] = s->ac_val[1] + c_size;
779
CHECKED_ALLOCZ(s->coded_block_base, y_size);
780
s->coded_block= s->coded_block_base + s->b8_stride + 1;
782
/* cbp, ac_pred, pred_dir */
783
CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
784
CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
787
if (s->h263_pred || s->h263_plus || !s->encoding) {
789
//MN: we need these for error resilience of intra-frames
790
CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
791
s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
792
s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
793
s->dc_val[2] = s->dc_val[1] + c_size;
794
for(i=0;i<yc_size;i++)
795
s->dc_val_base[i] = 1024;
798
/* which mb is a intra block */
799
CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
800
memset(s->mbintra_table, 1, mb_array_size);
802
/* init macroblock skip table */
803
CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
804
//Note the +1 is for a quicker mpeg4 slice_end detection
805
CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
807
s->parse_context.state= -1;
808
if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
809
s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
810
s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
811
s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
814
s->context_initialized = 1;
816
s->thread_context[0]= s;
817
for(i=1; i<s->avctx->thread_count; i++){
818
s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
819
memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
822
for(i=0; i<s->avctx->thread_count; i++){
823
if(init_duplicate_context(s->thread_context[i], s) < 0)
825
s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
826
s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
835
/* init common structure for both encoder and decoder */
836
void MPV_common_end(MpegEncContext *s)
840
for(i=0; i<s->avctx->thread_count; i++){
841
free_duplicate_context(s->thread_context[i]);
843
for(i=1; i<s->avctx->thread_count; i++){
844
av_freep(&s->thread_context[i]);
847
av_freep(&s->parse_context.buffer);
848
s->parse_context.buffer_size=0;
850
av_freep(&s->mb_type);
851
av_freep(&s->p_mv_table_base);
852
av_freep(&s->b_forw_mv_table_base);
853
av_freep(&s->b_back_mv_table_base);
854
av_freep(&s->b_bidir_forw_mv_table_base);
855
av_freep(&s->b_bidir_back_mv_table_base);
856
av_freep(&s->b_direct_mv_table_base);
858
s->b_forw_mv_table= NULL;
859
s->b_back_mv_table= NULL;
860
s->b_bidir_forw_mv_table= NULL;
861
s->b_bidir_back_mv_table= NULL;
862
s->b_direct_mv_table= NULL;
866
av_freep(&s->b_field_mv_table_base[i][j][k]);
867
s->b_field_mv_table[i][j][k]=NULL;
869
av_freep(&s->b_field_select_table[i][j]);
870
av_freep(&s->p_field_mv_table_base[i][j]);
871
s->p_field_mv_table[i][j]=NULL;
873
av_freep(&s->p_field_select_table[i]);
876
av_freep(&s->dc_val_base);
877
av_freep(&s->ac_val_base);
878
av_freep(&s->coded_block_base);
879
av_freep(&s->mbintra_table);
880
av_freep(&s->cbp_table);
881
av_freep(&s->pred_dir_table);
883
av_freep(&s->mbskip_table);
884
av_freep(&s->prev_pict_types);
885
av_freep(&s->bitstream_buffer);
886
s->allocated_bitstream_buffer_size=0;
888
av_freep(&s->avctx->stats_out);
889
av_freep(&s->ac_stats);
890
av_freep(&s->error_status_table);
891
av_freep(&s->mb_index2xy);
892
av_freep(&s->lambda_table);
893
av_freep(&s->q_intra_matrix);
894
av_freep(&s->q_inter_matrix);
895
av_freep(&s->q_intra_matrix16);
896
av_freep(&s->q_inter_matrix16);
897
av_freep(&s->input_picture);
898
av_freep(&s->reordered_input_picture);
899
av_freep(&s->dct_offset);
902
for(i=0; i<MAX_PICTURE_COUNT; i++){
903
free_picture(s, &s->picture[i]);
906
av_freep(&s->picture);
907
s->context_initialized = 0;
910
s->current_picture_ptr= NULL;
911
s->linesize= s->uvlinesize= 0;
914
av_freep(&s->visualization_buffer[i]);
916
avcodec_default_free_buffers(s->avctx);
919
#ifdef CONFIG_ENCODERS
921
/* init video encoder */
922
int MPV_encode_init(AVCodecContext *avctx)
924
MpegEncContext *s = avctx->priv_data;
926
int chroma_h_shift, chroma_v_shift;
928
MPV_encode_defaults(s);
930
switch (avctx->codec_id) {
931
case CODEC_ID_MPEG2VIDEO:
932
if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
933
av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
939
if(avctx->pix_fmt != PIX_FMT_YUVJ420P && (avctx->pix_fmt != PIX_FMT_YUV420P || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
940
av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
945
if(avctx->pix_fmt != PIX_FMT_YUV420P){
946
av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
951
switch (avctx->pix_fmt) {
952
case PIX_FMT_YUVJ422P:
953
case PIX_FMT_YUV422P:
954
s->chroma_format = CHROMA_422;
956
case PIX_FMT_YUVJ420P:
957
case PIX_FMT_YUV420P:
959
s->chroma_format = CHROMA_420;
963
s->bit_rate = avctx->bit_rate;
964
s->width = avctx->width;
965
s->height = avctx->height;
966
if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
967
av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
970
s->gop_size = avctx->gop_size;
972
s->flags= avctx->flags;
973
s->flags2= avctx->flags2;
974
s->max_b_frames= avctx->max_b_frames;
975
s->codec_id= avctx->codec->id;
976
s->luma_elim_threshold = avctx->luma_elim_threshold;
977
s->chroma_elim_threshold= avctx->chroma_elim_threshold;
978
s->strict_std_compliance= avctx->strict_std_compliance;
979
s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
980
s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
981
s->mpeg_quant= avctx->mpeg_quant;
982
s->rtp_mode= !!avctx->rtp_payload_size;
983
s->intra_dc_precision= avctx->intra_dc_precision;
984
s->user_specified_pts = AV_NOPTS_VALUE;
986
if (s->gop_size <= 1) {
993
s->me_method = avctx->me_method;
996
s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
998
s->adaptive_quant= ( s->avctx->lumi_masking
999
|| s->avctx->dark_masking
1000
|| s->avctx->temporal_cplx_masking
1001
|| s->avctx->spatial_cplx_masking
1002
|| s->avctx->p_masking
1003
|| s->avctx->border_masking
1004
|| (s->flags&CODEC_FLAG_QP_RD))
1005
&& !s->fixed_qscale;
1007
s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1008
s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1009
s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1010
s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1012
if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1013
av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1017
if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1018
av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1021
if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1022
av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1026
if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1027
av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1031
if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1032
&& (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1033
&& 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1035
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");
1038
if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1039
&& s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1040
av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1044
if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1045
av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1049
if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1050
av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1054
if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1055
av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1059
if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1060
av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1064
if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1065
av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1069
if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1070
&& s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1071
av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1075
if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1076
av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1080
if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1081
av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1085
if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1086
av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1090
if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1091
av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1095
if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1096
av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1100
if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1101
&& s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1102
&& (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1103
av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1107
if(s->avctx->thread_count > 1)
1110
if(!avctx->time_base.den || !avctx->time_base.num){
1111
av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1115
i= (INT_MAX/2+128)>>8;
1116
if(avctx->me_threshold >= i){
1117
av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1120
if(avctx->mb_threshold >= i){
1121
av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1125
if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1126
av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1127
avctx->b_frame_strategy = 0;
1130
i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1132
av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1133
avctx->time_base.den /= i;
1134
avctx->time_base.num /= i;
1138
if(s->codec_id==CODEC_ID_MJPEG){
1139
s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1140
s->inter_quant_bias= 0;
1141
}else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1142
s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1143
s->inter_quant_bias= 0;
1145
s->intra_quant_bias=0;
1146
s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1149
if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1150
s->intra_quant_bias= avctx->intra_quant_bias;
1151
if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1152
s->inter_quant_bias= avctx->inter_quant_bias;
1154
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1156
if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1157
av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1160
s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1162
switch(avctx->codec->id) {
1163
case CODEC_ID_MPEG1VIDEO:
1164
s->out_format = FMT_MPEG1;
1165
s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1166
avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1168
case CODEC_ID_MPEG2VIDEO:
1169
s->out_format = FMT_MPEG1;
1170
s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1171
avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1174
case CODEC_ID_LJPEG:
1175
case CODEC_ID_JPEGLS:
1176
case CODEC_ID_MJPEG:
1177
s->out_format = FMT_MJPEG;
1178
s->intra_only = 1; /* force intra only for jpeg */
1179
s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1180
s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1181
s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1182
s->mjpeg_vsample[1] = 1;
1183
s->mjpeg_vsample[2] = 1;
1184
s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1185
s->mjpeg_hsample[1] = 1;
1186
s->mjpeg_hsample[2] = 1;
1187
if (mjpeg_init(s) < 0)
1193
s->out_format = FMT_H261;
1198
if (h263_get_picture_format(s->width, s->height) == 7) {
1199
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);
1202
s->out_format = FMT_H263;
1203
s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1207
case CODEC_ID_H263P:
1208
s->out_format = FMT_H263;
1211
s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1212
s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1213
s->modified_quant= s->h263_aic;
1214
s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1215
s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1216
s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1217
s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1218
s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1221
/* These are just to be sure */
1226
s->out_format = FMT_H263;
1227
s->h263_flv = 2; /* format = 1; 11-bit codes */
1228
s->unrestricted_mv = 1;
1229
s->rtp_mode=0; /* don't allow GOB */
1234
s->out_format = FMT_H263;
1239
s->out_format = FMT_H263;
1242
s->modified_quant=1;
1246
s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1248
case CODEC_ID_MPEG4:
1249
s->out_format = FMT_H263;
1251
s->unrestricted_mv = 1;
1252
s->low_delay= s->max_b_frames ? 0 : 1;
1253
avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1255
case CODEC_ID_MSMPEG4V1:
1256
s->out_format = FMT_H263;
1257
s->h263_msmpeg4 = 1;
1259
s->unrestricted_mv = 1;
1260
s->msmpeg4_version= 1;
1264
case CODEC_ID_MSMPEG4V2:
1265
s->out_format = FMT_H263;
1266
s->h263_msmpeg4 = 1;
1268
s->unrestricted_mv = 1;
1269
s->msmpeg4_version= 2;
1273
case CODEC_ID_MSMPEG4V3:
1274
s->out_format = FMT_H263;
1275
s->h263_msmpeg4 = 1;
1277
s->unrestricted_mv = 1;
1278
s->msmpeg4_version= 3;
1279
s->flipflop_rounding=1;
1284
s->out_format = FMT_H263;
1285
s->h263_msmpeg4 = 1;
1287
s->unrestricted_mv = 1;
1288
s->msmpeg4_version= 4;
1289
s->flipflop_rounding=1;
1294
s->out_format = FMT_H263;
1295
s->h263_msmpeg4 = 1;
1297
s->unrestricted_mv = 1;
1298
s->msmpeg4_version= 5;
1299
s->flipflop_rounding=1;
1307
avctx->has_b_frames= !s->low_delay;
1312
if (MPV_common_init(s) < 0)
1315
if(s->modified_quant)
1316
s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1317
s->progressive_frame=
1318
s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1319
s->quant_precision=5;
1321
ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1322
ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1324
#ifdef CONFIG_H261_ENCODER
1325
if (s->out_format == FMT_H261)
1326
ff_h261_encode_init(s);
1328
if (s->out_format == FMT_H263)
1329
h263_encode_init(s);
1330
if(s->msmpeg4_version)
1331
ff_msmpeg4_encode_init(s);
1332
if (s->out_format == FMT_MPEG1)
1333
ff_mpeg1_encode_init(s);
1337
int j= s->dsp.idct_permutation[i];
1338
if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1339
s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1340
s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1341
}else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1342
s->intra_matrix[j] =
1343
s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1346
s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1347
s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1349
if(s->avctx->intra_matrix)
1350
s->intra_matrix[j] = s->avctx->intra_matrix[i];
1351
if(s->avctx->inter_matrix)
1352
s->inter_matrix[j] = s->avctx->inter_matrix[i];
1355
/* precompute matrix */
1356
/* for mjpeg, we do include qscale in the matrix */
1357
if (s->out_format != FMT_MJPEG) {
1358
convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1359
s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1360
convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1361
s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1364
if(ff_rate_control_init(s) < 0)
1370
int MPV_encode_end(AVCodecContext *avctx)
1372
MpegEncContext *s = avctx->priv_data;
1378
ff_rate_control_uninit(s);
1381
if (s->out_format == FMT_MJPEG)
1384
av_freep(&avctx->extradata);
1389
#endif //CONFIG_ENCODERS
1391
void init_rl(RLTable *rl, int use_static)
1393
int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1394
uint8_t index_run[MAX_RUN+1];
1395
int last, run, level, start, end, i;
1397
/* If table is static, we can quit if rl->max_level[0] is not NULL */
1398
if(use_static && rl->max_level[0])
1401
/* compute max_level[], max_run[] and index_run[] */
1402
for(last=0;last<2;last++) {
1411
memset(max_level, 0, MAX_RUN + 1);
1412
memset(max_run, 0, MAX_LEVEL + 1);
1413
memset(index_run, rl->n, MAX_RUN + 1);
1414
for(i=start;i<end;i++) {
1415
run = rl->table_run[i];
1416
level = rl->table_level[i];
1417
if (index_run[run] == rl->n)
1419
if (level > max_level[run])
1420
max_level[run] = level;
1421
if (run > max_run[level])
1422
max_run[level] = run;
1425
rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1427
rl->max_level[last] = av_malloc(MAX_RUN + 1);
1428
memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1430
rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1432
rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1433
memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1435
rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1437
rl->index_run[last] = av_malloc(MAX_RUN + 1);
1438
memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1442
/* draw the edges of width 'w' of an image of size width, height */
1443
//FIXME check that this is ok for mpeg4 interlaced
1444
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1446
uint8_t *ptr, *last_line;
1449
last_line = buf + (height - 1) * wrap;
1451
/* top and bottom */
1452
memcpy(buf - (i + 1) * wrap, buf, width);
1453
memcpy(last_line + (i + 1) * wrap, last_line, width);
1455
/* left and right */
1457
for(i=0;i<height;i++) {
1458
memset(ptr - w, ptr[0], w);
1459
memset(ptr + width, ptr[width-1], w);
1464
memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1465
memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1466
memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1467
memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1471
int ff_find_unused_picture(MpegEncContext *s, int shared){
1475
for(i=0; i<MAX_PICTURE_COUNT; i++){
1476
if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1479
for(i=0; i<MAX_PICTURE_COUNT; i++){
1480
if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1482
for(i=0; i<MAX_PICTURE_COUNT; i++){
1483
if(s->picture[i].data[0]==NULL) return i;
1491
static void update_noise_reduction(MpegEncContext *s){
1494
for(intra=0; intra<2; intra++){
1495
if(s->dct_count[intra] > (1<<16)){
1496
for(i=0; i<64; i++){
1497
s->dct_error_sum[intra][i] >>=1;
1499
s->dct_count[intra] >>= 1;
1502
for(i=0; i<64; i++){
1503
s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1509
* generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1511
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1517
assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1519
/* mark&release old frames */
1520
if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1521
avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1523
/* release forgotten pictures */
1524
/* if(mpeg124/h263) */
1526
for(i=0; i<MAX_PICTURE_COUNT; i++){
1527
if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1528
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1529
avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1536
/* release non reference frames */
1537
for(i=0; i<MAX_PICTURE_COUNT; i++){
1538
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1539
s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1543
if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1544
pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1546
i= ff_find_unused_picture(s, 0);
1547
pic= (AVFrame*)&s->picture[i];
1550
pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1551
&& !s->dropable ? 3 : 0;
1553
pic->coded_picture_number= s->coded_picture_number++;
1555
if( alloc_picture(s, (Picture*)pic, 0) < 0)
1558
s->current_picture_ptr= (Picture*)pic;
1559
s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1560
s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1563
s->current_picture_ptr->pict_type= s->pict_type;
1564
// if(s->flags && CODEC_FLAG_QSCALE)
1565
// s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1566
s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1568
copy_picture(&s->current_picture, s->current_picture_ptr);
1570
if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1571
if (s->pict_type != B_TYPE) {
1572
s->last_picture_ptr= s->next_picture_ptr;
1574
s->next_picture_ptr= s->current_picture_ptr;
1576
/* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1577
s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1578
s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1579
s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1580
s->pict_type, s->dropable);*/
1582
if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1583
if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1585
if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1586
av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1587
assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1591
assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1593
if(s->picture_structure!=PICT_FRAME){
1596
if(s->picture_structure == PICT_BOTTOM_FIELD){
1597
s->current_picture.data[i] += s->current_picture.linesize[i];
1599
s->current_picture.linesize[i] *= 2;
1600
s->last_picture.linesize[i] *=2;
1601
s->next_picture.linesize[i] *=2;
1606
s->hurry_up= s->avctx->hurry_up;
1607
s->error_resilience= avctx->error_resilience;
1609
/* set dequantizer, we can't do it during init as it might change for mpeg4
1610
and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1611
if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1612
s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1613
s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1614
}else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1615
s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1616
s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1618
s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1619
s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1622
if(s->dct_error_sum){
1623
assert(s->avctx->noise_reduction && s->encoding);
1625
update_noise_reduction(s);
1629
if(s->avctx->xvmc_acceleration)
1630
return XVMC_field_start(s, avctx);
1635
/* generic function for encode/decode called after a frame has been coded/decoded */
1636
void MPV_frame_end(MpegEncContext *s)
1639
/* draw edge for correct motion prediction if outside */
1641
//just to make sure that all data is rendered.
1642
if(s->avctx->xvmc_acceleration){
1646
if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1647
draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1648
draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1649
draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1653
s->last_pict_type = s->pict_type;
1654
s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1655
if(s->pict_type!=B_TYPE){
1656
s->last_non_b_pict_type= s->pict_type;
1659
/* copy back current_picture variables */
1660
for(i=0; i<MAX_PICTURE_COUNT; i++){
1661
if(s->picture[i].data[0] == s->current_picture.data[0]){
1662
s->picture[i]= s->current_picture;
1666
assert(i<MAX_PICTURE_COUNT);
1670
/* release non-reference frames */
1671
for(i=0; i<MAX_PICTURE_COUNT; i++){
1672
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1673
s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1677
// clear copies, to avoid confusion
1679
memset(&s->last_picture, 0, sizeof(Picture));
1680
memset(&s->next_picture, 0, sizeof(Picture));
1681
memset(&s->current_picture, 0, sizeof(Picture));
1683
s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1687
* draws an line from (ex, ey) -> (sx, sy).
1688
* @param w width of the image
1689
* @param h height of the image
1690
* @param stride stride/linesize of the image
1691
* @param color color of the arrow
1693
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1696
sx= clip(sx, 0, w-1);
1697
sy= clip(sy, 0, h-1);
1698
ex= clip(ex, 0, w-1);
1699
ey= clip(ey, 0, h-1);
1701
buf[sy*stride + sx]+= color;
1703
if(ABS(ex - sx) > ABS(ey - sy)){
1708
buf+= sx + sy*stride;
1710
f= ((ey-sy)<<16)/ex;
1711
for(x= 0; x <= ex; x++){
1714
buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1715
buf[(y+1)*stride + x]+= (color* fr )>>16;
1722
buf+= sx + sy*stride;
1724
if(ey) f= ((ex-sx)<<16)/ey;
1726
for(y= 0; y <= ey; y++){
1729
buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1730
buf[y*stride + x+1]+= (color* fr )>>16;;
1736
* draws an arrow from (ex, ey) -> (sx, sy).
1737
* @param w width of the image
1738
* @param h height of the image
1739
* @param stride stride/linesize of the image
1740
* @param color color of the arrow
1742
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1745
sx= clip(sx, -100, w+100);
1746
sy= clip(sy, -100, h+100);
1747
ex= clip(ex, -100, w+100);
1748
ey= clip(ey, -100, h+100);
1753
if(dx*dx + dy*dy > 3*3){
1756
int length= ff_sqrt((rx*rx + ry*ry)<<8);
1758
//FIXME subpixel accuracy
1759
rx= ROUNDED_DIV(rx*3<<4, length);
1760
ry= ROUNDED_DIV(ry*3<<4, length);
1762
draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1763
draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1765
draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1769
* prints debuging info for the given picture.
1771
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1773
if(!pict || !pict->mb_type) return;
1775
if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1778
av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1779
switch (pict->pict_type) {
1780
case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1781
case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1782
case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1783
case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1784
case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1785
case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1787
for(y=0; y<s->mb_height; y++){
1788
for(x=0; x<s->mb_width; x++){
1789
if(s->avctx->debug&FF_DEBUG_SKIP){
1790
int count= s->mbskip_table[x + y*s->mb_stride];
1791
if(count>9) count=9;
1792
av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1794
if(s->avctx->debug&FF_DEBUG_QP){
1795
av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1797
if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1798
int mb_type= pict->mb_type[x + y*s->mb_stride];
1799
//Type & MV direction
1801
av_log(s->avctx, AV_LOG_DEBUG, "P");
1802
else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1803
av_log(s->avctx, AV_LOG_DEBUG, "A");
1804
else if(IS_INTRA4x4(mb_type))
1805
av_log(s->avctx, AV_LOG_DEBUG, "i");
1806
else if(IS_INTRA16x16(mb_type))
1807
av_log(s->avctx, AV_LOG_DEBUG, "I");
1808
else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1809
av_log(s->avctx, AV_LOG_DEBUG, "d");
1810
else if(IS_DIRECT(mb_type))
1811
av_log(s->avctx, AV_LOG_DEBUG, "D");
1812
else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1813
av_log(s->avctx, AV_LOG_DEBUG, "g");
1814
else if(IS_GMC(mb_type))
1815
av_log(s->avctx, AV_LOG_DEBUG, "G");
1816
else if(IS_SKIP(mb_type))
1817
av_log(s->avctx, AV_LOG_DEBUG, "S");
1818
else if(!USES_LIST(mb_type, 1))
1819
av_log(s->avctx, AV_LOG_DEBUG, ">");
1820
else if(!USES_LIST(mb_type, 0))
1821
av_log(s->avctx, AV_LOG_DEBUG, "<");
1823
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1824
av_log(s->avctx, AV_LOG_DEBUG, "X");
1829
av_log(s->avctx, AV_LOG_DEBUG, "+");
1830
else if(IS_16X8(mb_type))
1831
av_log(s->avctx, AV_LOG_DEBUG, "-");
1832
else if(IS_8X16(mb_type))
1833
av_log(s->avctx, AV_LOG_DEBUG, "|");
1834
else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1835
av_log(s->avctx, AV_LOG_DEBUG, " ");
1837
av_log(s->avctx, AV_LOG_DEBUG, "?");
1840
if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1841
av_log(s->avctx, AV_LOG_DEBUG, "=");
1843
av_log(s->avctx, AV_LOG_DEBUG, " ");
1845
// av_log(s->avctx, AV_LOG_DEBUG, " ");
1847
av_log(s->avctx, AV_LOG_DEBUG, "\n");
1851
if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1852
const int shift= 1 + s->quarter_sample;
1856
int h_chroma_shift, v_chroma_shift;
1857
const int width = s->avctx->width;
1858
const int height= s->avctx->height;
1859
const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1860
const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1861
s->low_delay=0; //needed to see the vectors without trashing the buffers
1863
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1865
memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1866
pict->data[i]= s->visualization_buffer[i];
1868
pict->type= FF_BUFFER_TYPE_COPY;
1871
for(mb_y=0; mb_y<s->mb_height; mb_y++){
1873
for(mb_x=0; mb_x<s->mb_width; mb_x++){
1874
const int mb_index= mb_x + mb_y*s->mb_stride;
1875
if((s->avctx->debug_mv) && pict->motion_val){
1877
for(type=0; type<3; type++){
1880
case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1884
case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1888
case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1893
if(!USES_LIST(pict->mb_type[mb_index], direction))
1896
if(IS_8X8(pict->mb_type[mb_index])){
1899
int sx= mb_x*16 + 4 + 8*(i&1);
1900
int sy= mb_y*16 + 4 + 8*(i>>1);
1901
int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1902
int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1903
int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1904
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1906
}else if(IS_16X8(pict->mb_type[mb_index])){
1910
int sy=mb_y*16 + 4 + 8*i;
1911
int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1912
int mx=(pict->motion_val[direction][xy][0]>>shift);
1913
int my=(pict->motion_val[direction][xy][1]>>shift);
1915
if(IS_INTERLACED(pict->mb_type[mb_index]))
1918
draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1920
}else if(IS_8X16(pict->mb_type[mb_index])){
1923
int sx=mb_x*16 + 4 + 8*i;
1925
int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1926
int mx=(pict->motion_val[direction][xy][0]>>shift);
1927
int my=(pict->motion_val[direction][xy][1]>>shift);
1929
if(IS_INTERLACED(pict->mb_type[mb_index]))
1932
draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1935
int sx= mb_x*16 + 8;
1936
int sy= mb_y*16 + 8;
1937
int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1938
int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1939
int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1940
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1944
if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1945
uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1948
*(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1949
*(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1952
if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1953
int mb_type= pict->mb_type[mb_index];
1956
#define COLOR(theta, r)\
1957
u= (int)(128 + r*cos(theta*3.141592/180));\
1958
v= (int)(128 + r*sin(theta*3.141592/180));
1962
if(IS_PCM(mb_type)){
1964
}else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1966
}else if(IS_INTRA4x4(mb_type)){
1968
}else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1970
}else if(IS_DIRECT(mb_type)){
1972
}else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1974
}else if(IS_GMC(mb_type)){
1976
}else if(IS_SKIP(mb_type)){
1978
}else if(!USES_LIST(mb_type, 1)){
1980
}else if(!USES_LIST(mb_type, 0)){
1983
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1987
u*= 0x0101010101010101ULL;
1988
v*= 0x0101010101010101ULL;
1990
*(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1991
*(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1995
if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1996
*(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1997
*(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1999
if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2001
pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2003
if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2004
int dm= 1 << (mv_sample_log2-2);
2006
int sx= mb_x*16 + 8*(i&1);
2007
int sy= mb_y*16 + 8*(i>>1);
2008
int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2010
int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2011
if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2013
pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2014
if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2015
*(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2019
if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2023
s->mbskip_table[mb_index]=0;
2029
#ifdef CONFIG_ENCODERS
2031
static int get_sae(uint8_t *src, int ref, int stride){
2035
for(y=0; y<16; y++){
2036
for(x=0; x<16; x++){
2037
acc+= ABS(src[x+y*stride] - ref);
2044
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2051
for(y=0; y<h; y+=16){
2052
for(x=0; x<w; x+=16){
2053
int offset= x + y*stride;
2054
int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2055
int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2056
int sae = get_sae(src + offset, mean, stride);
2058
acc+= sae + 500 < sad;
2065
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2069
const int encoding_delay= s->max_b_frames;
2074
pic_arg->display_picture_number= s->input_picture_number++;
2076
if(pts != AV_NOPTS_VALUE){
2077
if(s->user_specified_pts != AV_NOPTS_VALUE){
2079
int64_t last= s->user_specified_pts;
2082
av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2086
s->user_specified_pts= pts;
2088
if(s->user_specified_pts != AV_NOPTS_VALUE){
2089
s->user_specified_pts=
2090
pts= s->user_specified_pts + 1;
2091
av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2093
pts= pic_arg->display_picture_number;
2099
if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2100
if(pic_arg->linesize[0] != s->linesize) direct=0;
2101
if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2102
if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2104
// av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2107
i= ff_find_unused_picture(s, 1);
2109
pic= (AVFrame*)&s->picture[i];
2113
pic->data[i]= pic_arg->data[i];
2114
pic->linesize[i]= pic_arg->linesize[i];
2116
alloc_picture(s, (Picture*)pic, 1);
2118
i= ff_find_unused_picture(s, 0);
2120
pic= (AVFrame*)&s->picture[i];
2123
alloc_picture(s, (Picture*)pic, 0);
2125
if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2126
&& pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2127
&& pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2130
int h_chroma_shift, v_chroma_shift;
2131
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2134
int src_stride= pic_arg->linesize[i];
2135
int dst_stride= i ? s->uvlinesize : s->linesize;
2136
int h_shift= i ? h_chroma_shift : 0;
2137
int v_shift= i ? v_chroma_shift : 0;
2138
int w= s->width >>h_shift;
2139
int h= s->height>>v_shift;
2140
uint8_t *src= pic_arg->data[i];
2141
uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2143
if(src_stride==dst_stride)
2144
memcpy(dst, src, src_stride*h);
2147
memcpy(dst, src, w);
2155
copy_picture_attributes(s, pic, pic_arg);
2156
pic->pts= pts; //we set this here to avoid modifiying pic_arg
2159
/* shift buffer entries */
2160
for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2161
s->input_picture[i-1]= s->input_picture[i];
2163
s->input_picture[encoding_delay]= (Picture*)pic;
2168
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2173
for(plane=0; plane<3; plane++){
2174
const int stride= p->linesize[plane];
2175
const int bw= plane ? 1 : 2;
2176
for(y=0; y<s->mb_height*bw; y++){
2177
for(x=0; x<s->mb_width*bw; x++){
2178
int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2179
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);
2181
switch(s->avctx->frame_skip_exp){
2182
case 0: score= FFMAX(score, v); break;
2183
case 1: score+= ABS(v);break;
2184
case 2: score+= v*v;break;
2185
case 3: score64+= ABS(v*v*(int64_t)v);break;
2186
case 4: score64+= v*v*(int64_t)(v*v);break;
2192
if(score) score64= score;
2194
if(score64 < s->avctx->frame_skip_threshold)
2196
if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2201
static int estimate_best_b_count(MpegEncContext *s){
2202
AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2203
AVCodecContext *c= avcodec_alloc_context();
2204
AVFrame input[FF_MAX_B_FRAMES+2];
2205
const int scale= s->avctx->brd_scale;
2206
int i, j, out_size, p_lambda, b_lambda, lambda2;
2207
int outbuf_size= s->width * s->height; //FIXME
2208
uint8_t *outbuf= av_malloc(outbuf_size);
2209
int64_t best_rd= INT64_MAX;
2210
int best_b_count= -1;
2212
assert(scale>=0 && scale <=3);
2215
p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2216
b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2217
if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2218
lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2220
c->width = s->width >> scale;
2221
c->height= s->height>> scale;
2222
c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2223
c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2224
c->mb_decision= s->avctx->mb_decision;
2225
c->me_cmp= s->avctx->me_cmp;
2226
c->mb_cmp= s->avctx->mb_cmp;
2227
c->me_sub_cmp= s->avctx->me_sub_cmp;
2228
c->pix_fmt = PIX_FMT_YUV420P;
2229
c->time_base= s->avctx->time_base;
2230
c->max_b_frames= s->max_b_frames;
2232
if (avcodec_open(c, codec) < 0)
2235
for(i=0; i<s->max_b_frames+2; i++){
2236
int ysize= c->width*c->height;
2237
int csize= (c->width/2)*(c->height/2);
2238
Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2241
pre_input= *pre_input_ptr;
2243
if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2244
pre_input.data[0]+=INPLACE_OFFSET;
2245
pre_input.data[1]+=INPLACE_OFFSET;
2246
pre_input.data[2]+=INPLACE_OFFSET;
2249
avcodec_get_frame_defaults(&input[i]);
2250
input[i].data[0]= av_malloc(ysize + 2*csize);
2251
input[i].data[1]= input[i].data[0] + ysize;
2252
input[i].data[2]= input[i].data[1] + csize;
2253
input[i].linesize[0]= c->width;
2254
input[i].linesize[1]=
2255
input[i].linesize[2]= c->width/2;
2257
if(!i || s->input_picture[i-1]){
2258
s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2259
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);
2260
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);
2264
for(j=0; j<s->max_b_frames+1; j++){
2267
if(!s->input_picture[j])
2270
c->error[0]= c->error[1]= c->error[2]= 0;
2272
input[0].pict_type= I_TYPE;
2273
input[0].quality= 1 * FF_QP2LAMBDA;
2274
out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2275
// rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2277
for(i=0; i<s->max_b_frames+1; i++){
2278
int is_p= i % (j+1) == j || i==s->max_b_frames;
2280
input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2281
input[i+1].quality= is_p ? p_lambda : b_lambda;
2282
out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2283
rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2286
/* get the delayed frames */
2288
out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2289
rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2292
rd += c->error[0] + c->error[1] + c->error[2];
2304
for(i=0; i<s->max_b_frames+2; i++){
2305
av_freep(&input[i].data[0]);
2308
return best_b_count;
2311
static void select_input_picture(MpegEncContext *s){
2314
for(i=1; i<MAX_PICTURE_COUNT; i++)
2315
s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2316
s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2318
/* set next picture type & ordering */
2319
if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2320
if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2321
s->reordered_input_picture[0]= s->input_picture[0];
2322
s->reordered_input_picture[0]->pict_type= I_TYPE;
2323
s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2327
if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2328
if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2329
//FIXME check that te gop check above is +-1 correct
2330
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2332
if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2334
s->input_picture[0]->data[i]= NULL;
2335
s->input_picture[0]->type= 0;
2337
assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2338
|| s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2340
s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2344
ff_vbv_update(s, 0);
2350
if(s->flags&CODEC_FLAG_PASS2){
2351
for(i=0; i<s->max_b_frames+1; i++){
2352
int pict_num= s->input_picture[0]->display_picture_number + i;
2354
if(pict_num >= s->rc_context.num_entries)
2356
if(!s->input_picture[i]){
2357
s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2361
s->input_picture[i]->pict_type=
2362
s->rc_context.entry[pict_num].new_pict_type;
2366
if(s->avctx->b_frame_strategy==0){
2367
b_frames= s->max_b_frames;
2368
while(b_frames && !s->input_picture[b_frames]) b_frames--;
2369
}else if(s->avctx->b_frame_strategy==1){
2370
for(i=1; i<s->max_b_frames+1; i++){
2371
if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2372
s->input_picture[i]->b_frame_score=
2373
get_intra_count(s, s->input_picture[i ]->data[0],
2374
s->input_picture[i-1]->data[0], s->linesize) + 1;
2377
for(i=0; i<s->max_b_frames+1; i++){
2378
if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2381
b_frames= FFMAX(0, i-1);
2384
for(i=0; i<b_frames+1; i++){
2385
s->input_picture[i]->b_frame_score=0;
2387
}else if(s->avctx->b_frame_strategy==2){
2388
b_frames= estimate_best_b_count(s);
2390
av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2395
//static int b_count=0;
2396
//b_count+= b_frames;
2397
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2399
for(i= b_frames - 1; i>=0; i--){
2400
int type= s->input_picture[i]->pict_type;
2401
if(type && type != B_TYPE)
2404
if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2405
av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2408
if(s->picture_in_gop_number + b_frames >= s->gop_size){
2409
if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2410
b_frames= s->gop_size - s->picture_in_gop_number - 1;
2412
if(s->flags & CODEC_FLAG_CLOSED_GOP)
2414
s->input_picture[b_frames]->pict_type= I_TYPE;
2418
if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2420
&& s->input_picture[b_frames]->pict_type== I_TYPE)
2423
s->reordered_input_picture[0]= s->input_picture[b_frames];
2424
if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2425
s->reordered_input_picture[0]->pict_type= P_TYPE;
2426
s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2427
for(i=0; i<b_frames; i++){
2428
s->reordered_input_picture[i+1]= s->input_picture[i];
2429
s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2430
s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2435
if(s->reordered_input_picture[0]){
2436
s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2438
copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2440
if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2441
// input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2443
int i= ff_find_unused_picture(s, 0);
2444
Picture *pic= &s->picture[i];
2446
/* mark us unused / free shared pic */
2448
s->reordered_input_picture[0]->data[i]= NULL;
2449
s->reordered_input_picture[0]->type= 0;
2451
pic->reference = s->reordered_input_picture[0]->reference;
2453
alloc_picture(s, pic, 0);
2455
copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2457
s->current_picture_ptr= pic;
2459
// input is not a shared pix -> reuse buffer for current_pix
2461
assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2462
|| s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2464
s->current_picture_ptr= s->reordered_input_picture[0];
2466
s->new_picture.data[i]+= INPLACE_OFFSET;
2469
copy_picture(&s->current_picture, s->current_picture_ptr);
2471
s->picture_number= s->new_picture.display_picture_number;
2472
//printf("dpn:%d\n", s->picture_number);
2474
memset(&s->new_picture, 0, sizeof(Picture));
2478
int MPV_encode_picture(AVCodecContext *avctx,
2479
unsigned char *buf, int buf_size, void *data)
2481
MpegEncContext *s = avctx->priv_data;
2482
AVFrame *pic_arg = data;
2483
int i, stuffing_count;
2485
for(i=0; i<avctx->thread_count; i++){
2486
int start_y= s->thread_context[i]->start_mb_y;
2487
int end_y= s->thread_context[i]-> end_mb_y;
2488
int h= s->mb_height;
2489
uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2490
uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2492
init_put_bits(&s->thread_context[i]->pb, start, end - start);
2495
s->picture_in_gop_number++;
2497
if(load_input_picture(s, pic_arg) < 0)
2500
select_input_picture(s);
2503
if(s->new_picture.data[0]){
2504
s->pict_type= s->new_picture.pict_type;
2506
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2507
MPV_frame_start(s, avctx);
2509
encode_picture(s, s->picture_number);
2511
avctx->real_pict_num = s->picture_number;
2512
avctx->header_bits = s->header_bits;
2513
avctx->mv_bits = s->mv_bits;
2514
avctx->misc_bits = s->misc_bits;
2515
avctx->i_tex_bits = s->i_tex_bits;
2516
avctx->p_tex_bits = s->p_tex_bits;
2517
avctx->i_count = s->i_count;
2518
avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2519
avctx->skip_count = s->skip_count;
2523
if (s->out_format == FMT_MJPEG)
2524
mjpeg_picture_trailer(s);
2526
if(s->flags&CODEC_FLAG_PASS1)
2527
ff_write_pass1_stats(s);
2530
s->current_picture_ptr->error[i]= s->current_picture.error[i];
2531
avctx->error[i] += s->current_picture_ptr->error[i];
2534
if(s->flags&CODEC_FLAG_PASS1)
2535
assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2536
flush_put_bits(&s->pb);
2537
s->frame_bits = put_bits_count(&s->pb);
2539
stuffing_count= ff_vbv_update(s, s->frame_bits);
2541
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2542
av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2546
switch(s->codec_id){
2547
case CODEC_ID_MPEG1VIDEO:
2548
case CODEC_ID_MPEG2VIDEO:
2549
while(stuffing_count--){
2550
put_bits(&s->pb, 8, 0);
2553
case CODEC_ID_MPEG4:
2554
put_bits(&s->pb, 16, 0);
2555
put_bits(&s->pb, 16, 0x1C3);
2556
stuffing_count -= 4;
2557
while(stuffing_count--){
2558
put_bits(&s->pb, 8, 0xFF);
2562
av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2564
flush_put_bits(&s->pb);
2565
s->frame_bits = put_bits_count(&s->pb);
2568
/* update mpeg1/2 vbv_delay for CBR */
2569
if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2570
&& 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2573
assert(s->repeat_first_field==0);
2575
vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2576
assert(vbv_delay < 0xFFFF);
2578
s->vbv_delay_ptr[0] &= 0xF8;
2579
s->vbv_delay_ptr[0] |= vbv_delay>>13;
2580
s->vbv_delay_ptr[1] = vbv_delay>>5;
2581
s->vbv_delay_ptr[2] &= 0x07;
2582
s->vbv_delay_ptr[2] |= vbv_delay<<3;
2584
s->total_bits += s->frame_bits;
2585
avctx->frame_bits = s->frame_bits;
2587
assert((pbBufPtr(&s->pb) == s->pb.buf));
2590
assert((s->frame_bits&7)==0);
2592
return s->frame_bits/8;
2595
#endif //CONFIG_ENCODERS
2597
static inline void gmc1_motion(MpegEncContext *s,
2598
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2599
uint8_t **ref_picture)
2602
int offset, src_x, src_y, linesize, uvlinesize;
2603
int motion_x, motion_y;
2606
motion_x= s->sprite_offset[0][0];
2607
motion_y= s->sprite_offset[0][1];
2608
src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2609
src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2610
motion_x<<=(3-s->sprite_warping_accuracy);
2611
motion_y<<=(3-s->sprite_warping_accuracy);
2612
src_x = clip(src_x, -16, s->width);
2613
if (src_x == s->width)
2615
src_y = clip(src_y, -16, s->height);
2616
if (src_y == s->height)
2619
linesize = s->linesize;
2620
uvlinesize = s->uvlinesize;
2622
ptr = ref_picture[0] + (src_y * linesize) + src_x;
2624
if(s->flags&CODEC_FLAG_EMU_EDGE){
2625
if( (unsigned)src_x >= s->h_edge_pos - 17
2626
|| (unsigned)src_y >= s->v_edge_pos - 17){
2627
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2628
ptr= s->edge_emu_buffer;
2632
if((motion_x|motion_y)&7){
2633
s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2634
s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2638
dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2639
if (s->no_rounding){
2640
s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2642
s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2646
if(s->flags&CODEC_FLAG_GRAY) return;
2648
motion_x= s->sprite_offset[1][0];
2649
motion_y= s->sprite_offset[1][1];
2650
src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2651
src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2652
motion_x<<=(3-s->sprite_warping_accuracy);
2653
motion_y<<=(3-s->sprite_warping_accuracy);
2654
src_x = clip(src_x, -8, s->width>>1);
2655
if (src_x == s->width>>1)
2657
src_y = clip(src_y, -8, s->height>>1);
2658
if (src_y == s->height>>1)
2661
offset = (src_y * uvlinesize) + src_x;
2662
ptr = ref_picture[1] + offset;
2663
if(s->flags&CODEC_FLAG_EMU_EDGE){
2664
if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2665
|| (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2666
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2667
ptr= s->edge_emu_buffer;
2671
s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2673
ptr = ref_picture[2] + offset;
2675
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2676
ptr= s->edge_emu_buffer;
2678
s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2683
static inline void gmc_motion(MpegEncContext *s,
2684
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2685
uint8_t **ref_picture)
2688
int linesize, uvlinesize;
2689
const int a= s->sprite_warping_accuracy;
2692
linesize = s->linesize;
2693
uvlinesize = s->uvlinesize;
2695
ptr = ref_picture[0];
2697
ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2698
oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2700
s->dsp.gmc(dest_y, ptr, linesize, 16,
2703
s->sprite_delta[0][0], s->sprite_delta[0][1],
2704
s->sprite_delta[1][0], s->sprite_delta[1][1],
2705
a+1, (1<<(2*a+1)) - s->no_rounding,
2706
s->h_edge_pos, s->v_edge_pos);
2707
s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2708
ox + s->sprite_delta[0][0]*8,
2709
oy + s->sprite_delta[1][0]*8,
2710
s->sprite_delta[0][0], s->sprite_delta[0][1],
2711
s->sprite_delta[1][0], s->sprite_delta[1][1],
2712
a+1, (1<<(2*a+1)) - s->no_rounding,
2713
s->h_edge_pos, s->v_edge_pos);
2715
if(s->flags&CODEC_FLAG_GRAY) return;
2717
ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2718
oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2720
ptr = ref_picture[1];
2721
s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2724
s->sprite_delta[0][0], s->sprite_delta[0][1],
2725
s->sprite_delta[1][0], s->sprite_delta[1][1],
2726
a+1, (1<<(2*a+1)) - s->no_rounding,
2727
s->h_edge_pos>>1, s->v_edge_pos>>1);
2729
ptr = ref_picture[2];
2730
s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2733
s->sprite_delta[0][0], s->sprite_delta[0][1],
2734
s->sprite_delta[1][0], s->sprite_delta[1][1],
2735
a+1, (1<<(2*a+1)) - s->no_rounding,
2736
s->h_edge_pos>>1, s->v_edge_pos>>1);
2740
* Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2741
* @param buf destination buffer
2742
* @param src source buffer
2743
* @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2744
* @param block_w width of block
2745
* @param block_h height of block
2746
* @param src_x x coordinate of the top left sample of the block in the source buffer
2747
* @param src_y y coordinate of the top left sample of the block in the source buffer
2748
* @param w width of the source buffer
2749
* @param h height of the source buffer
2751
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2752
int src_x, int src_y, int w, int h){
2754
int start_y, start_x, end_y, end_x;
2757
src+= (h-1-src_y)*linesize;
2759
}else if(src_y<=-block_h){
2760
src+= (1-block_h-src_y)*linesize;
2766
}else if(src_x<=-block_w){
2767
src+= (1-block_w-src_x);
2771
start_y= FFMAX(0, -src_y);
2772
start_x= FFMAX(0, -src_x);
2773
end_y= FFMIN(block_h, h-src_y);
2774
end_x= FFMIN(block_w, w-src_x);
2776
// copy existing part
2777
for(y=start_y; y<end_y; y++){
2778
for(x=start_x; x<end_x; x++){
2779
buf[x + y*linesize]= src[x + y*linesize];
2784
for(y=0; y<start_y; y++){
2785
for(x=start_x; x<end_x; x++){
2786
buf[x + y*linesize]= buf[x + start_y*linesize];
2791
for(y=end_y; y<block_h; y++){
2792
for(x=start_x; x<end_x; x++){
2793
buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2797
for(y=0; y<block_h; y++){
2799
for(x=0; x<start_x; x++){
2800
buf[x + y*linesize]= buf[start_x + y*linesize];
2804
for(x=end_x; x<block_w; x++){
2805
buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2810
static inline int hpel_motion(MpegEncContext *s,
2811
uint8_t *dest, uint8_t *src,
2812
int field_based, int field_select,
2813
int src_x, int src_y,
2814
int width, int height, int stride,
2815
int h_edge_pos, int v_edge_pos,
2816
int w, int h, op_pixels_func *pix_op,
2817
int motion_x, int motion_y)
2822
dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2823
src_x += motion_x >> 1;
2824
src_y += motion_y >> 1;
2826
/* WARNING: do no forget half pels */
2827
src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2830
src_y = clip(src_y, -16, height);
2831
if (src_y == height)
2833
src += src_y * stride + src_x;
2835
if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2836
if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2837
|| (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2838
ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2839
src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2840
src= s->edge_emu_buffer;
2846
pix_op[dxy](dest, src, stride, h);
2850
static inline int hpel_motion_lowres(MpegEncContext *s,
2851
uint8_t *dest, uint8_t *src,
2852
int field_based, int field_select,
2853
int src_x, int src_y,
2854
int width, int height, int stride,
2855
int h_edge_pos, int v_edge_pos,
2856
int w, int h, h264_chroma_mc_func *pix_op,
2857
int motion_x, int motion_y)
2859
const int lowres= s->avctx->lowres;
2860
const int s_mask= (2<<lowres)-1;
2864
if(s->quarter_sample){
2869
sx= motion_x & s_mask;
2870
sy= motion_y & s_mask;
2871
src_x += motion_x >> (lowres+1);
2872
src_y += motion_y >> (lowres+1);
2874
src += src_y * stride + src_x;
2876
if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2877
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2878
ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2879
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2880
src= s->edge_emu_buffer;
2888
pix_op[lowres](dest, src, stride, h, sx, sy);
2892
/* apply one mpeg motion vector to the three components */
2893
static always_inline void mpeg_motion(MpegEncContext *s,
2894
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2895
int field_based, int bottom_field, int field_select,
2896
uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2897
int motion_x, int motion_y, int h)
2899
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2900
int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2903
if(s->quarter_sample)
2910
v_edge_pos = s->v_edge_pos >> field_based;
2911
linesize = s->current_picture.linesize[0] << field_based;
2912
uvlinesize = s->current_picture.linesize[1] << field_based;
2914
dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2915
src_x = s->mb_x* 16 + (motion_x >> 1);
2916
src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2918
if (s->out_format == FMT_H263) {
2919
if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2920
mx = (motion_x>>1)|(motion_x&1);
2922
uvdxy = ((my & 1) << 1) | (mx & 1);
2923
uvsrc_x = s->mb_x* 8 + (mx >> 1);
2924
uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2926
uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2930
}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2934
uvsrc_x = s->mb_x*8 + mx;
2935
uvsrc_y = s->mb_y*8 + my;
2937
if(s->chroma_y_shift){
2940
uvdxy = ((my & 1) << 1) | (mx & 1);
2941
uvsrc_x = s->mb_x* 8 + (mx >> 1);
2942
uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2944
if(s->chroma_x_shift){
2947
uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2948
uvsrc_x = s->mb_x* 8 + (mx >> 1);
2959
ptr_y = ref_picture[0] + src_y * linesize + src_x;
2960
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2961
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2963
if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2964
|| (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2965
if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2966
s->codec_id == CODEC_ID_MPEG1VIDEO){
2967
av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2970
ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2971
src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2972
ptr_y = s->edge_emu_buffer;
2973
if(!(s->flags&CODEC_FLAG_GRAY)){
2974
uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2975
ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2976
uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2977
ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2978
uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2984
if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2985
dest_y += s->linesize;
2986
dest_cb+= s->uvlinesize;
2987
dest_cr+= s->uvlinesize;
2991
ptr_y += s->linesize;
2992
ptr_cb+= s->uvlinesize;
2993
ptr_cr+= s->uvlinesize;
2996
pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2998
if(!(s->flags&CODEC_FLAG_GRAY)){
2999
pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3000
pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3002
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3003
if(s->out_format == FMT_H261){
3004
ff_h261_loop_filter(s);
3009
/* apply one mpeg motion vector to the three components */
3010
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3011
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3012
int field_based, int bottom_field, int field_select,
3013
uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3014
int motion_x, int motion_y, int h)
3016
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3017
int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3018
const int lowres= s->avctx->lowres;
3019
const int block_s= 8>>lowres;
3020
const int s_mask= (2<<lowres)-1;
3021
const int h_edge_pos = s->h_edge_pos >> lowres;
3022
const int v_edge_pos = s->v_edge_pos >> lowres;
3023
linesize = s->current_picture.linesize[0] << field_based;
3024
uvlinesize = s->current_picture.linesize[1] << field_based;
3026
if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3032
motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3035
sx= motion_x & s_mask;
3036
sy= motion_y & s_mask;
3037
src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3038
src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3040
if (s->out_format == FMT_H263) {
3041
uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3042
uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3045
}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3048
uvsx = (2*mx) & s_mask;
3049
uvsy = (2*my) & s_mask;
3050
uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3051
uvsrc_y = s->mb_y*block_s + (my >> lowres);
3057
uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3058
uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3061
ptr_y = ref_picture[0] + src_y * linesize + src_x;
3062
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3063
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3065
if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3066
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3067
ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3068
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3069
ptr_y = s->edge_emu_buffer;
3070
if(!(s->flags&CODEC_FLAG_GRAY)){
3071
uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3072
ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3073
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3074
ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3075
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3081
if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3082
dest_y += s->linesize;
3083
dest_cb+= s->uvlinesize;
3084
dest_cr+= s->uvlinesize;
3088
ptr_y += s->linesize;
3089
ptr_cb+= s->uvlinesize;
3090
ptr_cr+= s->uvlinesize;
3095
pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3097
if(!(s->flags&CODEC_FLAG_GRAY)){
3098
uvsx <<= 2 - lowres;
3099
uvsy <<= 2 - lowres;
3100
pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3101
pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3103
//FIXME h261 lowres loop filter
3106
//FIXME move to dsputil, avg variant, 16x16 version
3107
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3109
uint8_t * const top = src[1];
3110
uint8_t * const left = src[2];
3111
uint8_t * const mid = src[0];
3112
uint8_t * const right = src[3];
3113
uint8_t * const bottom= src[4];
3114
#define OBMC_FILTER(x, t, l, m, r, b)\
3115
dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3116
#define OBMC_FILTER4(x, t, l, m, r, b)\
3117
OBMC_FILTER(x , t, l, m, r, b);\
3118
OBMC_FILTER(x+1 , t, l, m, r, b);\
3119
OBMC_FILTER(x +stride, t, l, m, r, b);\
3120
OBMC_FILTER(x+1+stride, t, l, m, r, b);
3123
OBMC_FILTER (x , 2, 2, 4, 0, 0);
3124
OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3125
OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3126
OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3127
OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3128
OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3130
OBMC_FILTER (x , 1, 2, 5, 0, 0);
3131
OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3132
OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3133
OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3135
OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3136
OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3137
OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3138
OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3140
OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3141
OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3142
OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3143
OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3145
OBMC_FILTER (x , 0, 2, 5, 0, 1);
3146
OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3147
OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3148
OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3149
OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3150
OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3152
OBMC_FILTER (x , 0, 2, 4, 0, 2);
3153
OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3154
OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3155
OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3158
/* obmc for 1 8x8 luma block */
3159
static inline void obmc_motion(MpegEncContext *s,
3160
uint8_t *dest, uint8_t *src,
3161
int src_x, int src_y,
3162
op_pixels_func *pix_op,
3163
int16_t mv[5][2]/* mid top left right bottom*/)
3169
assert(s->quarter_sample==0);
3172
if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3175
ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3176
hpel_motion(s, ptr[i], src, 0, 0,
3178
s->width, s->height, s->linesize,
3179
s->h_edge_pos, s->v_edge_pos,
3181
mv[i][0], mv[i][1]);
3185
put_obmc(dest, ptr, s->linesize);
3188
static inline void qpel_motion(MpegEncContext *s,
3189
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3190
int field_based, int bottom_field, int field_select,
3191
uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3192
qpel_mc_func (*qpix_op)[16],
3193
int motion_x, int motion_y, int h)
3195
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3196
int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3198
dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3199
src_x = s->mb_x * 16 + (motion_x >> 2);
3200
src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3202
v_edge_pos = s->v_edge_pos >> field_based;
3203
linesize = s->linesize << field_based;
3204
uvlinesize = s->uvlinesize << field_based;
3209
}else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3210
static const int rtab[8]= {0,0,1,1,0,0,0,1};
3211
mx= (motion_x>>1) + rtab[motion_x&7];
3212
my= (motion_y>>1) + rtab[motion_y&7];
3213
}else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3214
mx= (motion_x>>1)|(motion_x&1);
3215
my= (motion_y>>1)|(motion_y&1);
3223
uvdxy= (mx&1) | ((my&1)<<1);
3227
uvsrc_x = s->mb_x * 8 + mx;
3228
uvsrc_y = s->mb_y * (8 >> field_based) + my;
3230
ptr_y = ref_picture[0] + src_y * linesize + src_x;
3231
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3232
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3234
if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3235
|| (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3236
ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3237
src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3238
ptr_y= s->edge_emu_buffer;
3239
if(!(s->flags&CODEC_FLAG_GRAY)){
3240
uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3241
ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3242
uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3243
ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3244
uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3251
qpix_op[0][dxy](dest_y, ptr_y, linesize);
3254
dest_y += s->linesize;
3255
dest_cb+= s->uvlinesize;
3256
dest_cr+= s->uvlinesize;
3260
ptr_y += s->linesize;
3261
ptr_cb += s->uvlinesize;
3262
ptr_cr += s->uvlinesize;
3264
//damn interlaced mode
3265
//FIXME boundary mirroring is not exactly correct here
3266
qpix_op[1][dxy](dest_y , ptr_y , linesize);
3267
qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3269
if(!(s->flags&CODEC_FLAG_GRAY)){
3270
pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3271
pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3275
inline int ff_h263_round_chroma(int x){
3277
return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3280
return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3285
* h263 chorma 4mv motion compensation.
3287
static inline void chroma_4mv_motion(MpegEncContext *s,
3288
uint8_t *dest_cb, uint8_t *dest_cr,
3289
uint8_t **ref_picture,
3290
op_pixels_func *pix_op,
3292
int dxy, emu=0, src_x, src_y, offset;
3295
/* In case of 8X8, we construct a single chroma motion vector
3296
with a special rounding */
3297
mx= ff_h263_round_chroma(mx);
3298
my= ff_h263_round_chroma(my);
3300
dxy = ((my & 1) << 1) | (mx & 1);
3304
src_x = s->mb_x * 8 + mx;
3305
src_y = s->mb_y * 8 + my;
3306
src_x = clip(src_x, -8, s->width/2);
3307
if (src_x == s->width/2)
3309
src_y = clip(src_y, -8, s->height/2);
3310
if (src_y == s->height/2)
3313
offset = (src_y * (s->uvlinesize)) + src_x;
3314
ptr = ref_picture[1] + offset;
3315
if(s->flags&CODEC_FLAG_EMU_EDGE){
3316
if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3317
|| (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3318
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3319
ptr= s->edge_emu_buffer;
3323
pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3325
ptr = ref_picture[2] + offset;
3327
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3328
ptr= s->edge_emu_buffer;
3330
pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3333
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3334
uint8_t *dest_cb, uint8_t *dest_cr,
3335
uint8_t **ref_picture,
3336
h264_chroma_mc_func *pix_op,
3338
const int lowres= s->avctx->lowres;
3339
const int block_s= 8>>lowres;
3340
const int s_mask= (2<<lowres)-1;
3341
const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3342
const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3343
int emu=0, src_x, src_y, offset, sx, sy;
3346
if(s->quarter_sample){
3351
/* In case of 8X8, we construct a single chroma motion vector
3352
with a special rounding */
3353
mx= ff_h263_round_chroma(mx);
3354
my= ff_h263_round_chroma(my);
3358
src_x = s->mb_x*block_s + (mx >> (lowres+1));
3359
src_y = s->mb_y*block_s + (my >> (lowres+1));
3361
offset = src_y * s->uvlinesize + src_x;
3362
ptr = ref_picture[1] + offset;
3363
if(s->flags&CODEC_FLAG_EMU_EDGE){
3364
if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3365
|| (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3366
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3367
ptr= s->edge_emu_buffer;
3373
pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3375
ptr = ref_picture[2] + offset;
3377
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3378
ptr= s->edge_emu_buffer;
3380
pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3383
static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3384
/* fetch pixels for estimated mv 4 macroblocks ahead
3385
* optimized for 64byte cache lines */
3386
const int shift = s->quarter_sample ? 2 : 1;
3387
const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3388
const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3389
int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3390
s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3391
off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3392
s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3396
* motion compensation of a single macroblock
3398
* @param dest_y luma destination pointer
3399
* @param dest_cb chroma cb/u destination pointer
3400
* @param dest_cr chroma cr/v destination pointer
3401
* @param dir direction (0->forward, 1->backward)
3402
* @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3403
* @param pic_op halfpel motion compensation function (average or put normally)
3404
* @param pic_op qpel motion compensation function (average or put normally)
3405
* the motion vectors are taken from s->mv and the MV type from s->mv_type
3407
static inline void MPV_motion(MpegEncContext *s,
3408
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3409
int dir, uint8_t **ref_picture,
3410
op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3412
int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3414
uint8_t *ptr, *dest;
3419
prefetch_motion(s, ref_picture, dir);
3421
if(s->obmc && s->pict_type != B_TYPE){
3422
int16_t mv_cache[4][4][2];
3423
const int xy= s->mb_x + s->mb_y*s->mb_stride;
3424
const int mot_stride= s->b8_stride;
3425
const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3427
assert(!s->mb_skipped);
3429
memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3430
memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3431
memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3433
if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3434
memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3436
memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3439
if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3440
*(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3441
*(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3443
*(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3444
*(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3447
if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3448
*(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3449
*(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3451
*(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3452
*(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3458
const int x= (i&1)+1;
3459
const int y= (i>>1)+1;
3461
{mv_cache[y][x ][0], mv_cache[y][x ][1]},
3462
{mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3463
{mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3464
{mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3465
{mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3467
obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3469
mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3476
if(!(s->flags&CODEC_FLAG_GRAY))
3477
chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3482
switch(s->mv_type) {
3485
if(s->real_sprite_warping_points==1){
3486
gmc1_motion(s, dest_y, dest_cb, dest_cr,
3489
gmc_motion(s, dest_y, dest_cb, dest_cr,
3492
}else if(s->quarter_sample){
3493
qpel_motion(s, dest_y, dest_cb, dest_cr,
3495
ref_picture, pix_op, qpix_op,
3496
s->mv[dir][0][0], s->mv[dir][0][1], 16);
3498
ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3499
ref_picture, pix_op,
3500
s->mv[dir][0][0], s->mv[dir][0][1], 16);
3503
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3505
ref_picture, pix_op,
3506
s->mv[dir][0][0], s->mv[dir][0][1], 16);
3512
if(s->quarter_sample){
3514
motion_x = s->mv[dir][i][0];
3515
motion_y = s->mv[dir][i][1];
3517
dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3518
src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3519
src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3521
/* WARNING: do no forget half pels */
3522
src_x = clip(src_x, -16, s->width);
3523
if (src_x == s->width)
3525
src_y = clip(src_y, -16, s->height);
3526
if (src_y == s->height)
3529
ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3530
if(s->flags&CODEC_FLAG_EMU_EDGE){
3531
if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3532
|| (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3533
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
3534
ptr= s->edge_emu_buffer;
3537
dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3538
qpix_op[1][dxy](dest, ptr, s->linesize);
3540
mx += s->mv[dir][i][0]/2;
3541
my += s->mv[dir][i][1]/2;
3545
hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3546
ref_picture[0], 0, 0,
3547
mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3548
s->width, s->height, s->linesize,
3549
s->h_edge_pos, s->v_edge_pos,
3551
s->mv[dir][i][0], s->mv[dir][i][1]);
3553
mx += s->mv[dir][i][0];
3554
my += s->mv[dir][i][1];
3558
if(!(s->flags&CODEC_FLAG_GRAY))
3559
chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3562
if (s->picture_structure == PICT_FRAME) {
3563
if(s->quarter_sample){
3565
qpel_motion(s, dest_y, dest_cb, dest_cr,
3566
1, i, s->field_select[dir][i],
3567
ref_picture, pix_op, qpix_op,
3568
s->mv[dir][i][0], s->mv[dir][i][1], 8);
3572
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3573
1, 0, s->field_select[dir][0],
3574
ref_picture, pix_op,
3575
s->mv[dir][0][0], s->mv[dir][0][1], 8);
3577
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3578
1, 1, s->field_select[dir][1],
3579
ref_picture, pix_op,
3580
s->mv[dir][1][0], s->mv[dir][1][1], 8);
3583
if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3584
ref_picture= s->current_picture_ptr->data;
3587
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3588
0, 0, s->field_select[dir][0],
3589
ref_picture, pix_op,
3590
s->mv[dir][0][0], s->mv[dir][0][1], 16);
3595
uint8_t ** ref2picture;
3597
if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3598
ref2picture= ref_picture;
3600
ref2picture= s->current_picture_ptr->data;
3603
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3604
0, 0, s->field_select[dir][i],
3605
ref2picture, pix_op,
3606
s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3608
dest_y += 16*s->linesize;
3609
dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3610
dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3614
if(s->picture_structure == PICT_FRAME){
3618
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3620
ref_picture, pix_op,
3621
s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3623
pix_op = s->dsp.avg_pixels_tab;
3627
mpeg_motion(s, dest_y, dest_cb, dest_cr,
3628
0, 0, s->picture_structure != i+1,
3629
ref_picture, pix_op,
3630
s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3632
// after put we make avg of the same block
3633
pix_op=s->dsp.avg_pixels_tab;
3635
//opposite parity is always in the same frame if this is second field
3636
if(!s->first_field){
3637
ref_picture = s->current_picture_ptr->data;
3647
* motion compensation of a single macroblock
3649
* @param dest_y luma destination pointer
3650
* @param dest_cb chroma cb/u destination pointer
3651
* @param dest_cr chroma cr/v destination pointer
3652
* @param dir direction (0->forward, 1->backward)
3653
* @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3654
* @param pic_op halfpel motion compensation function (average or put normally)
3655
* the motion vectors are taken from s->mv and the MV type from s->mv_type
3657
static inline void MPV_motion_lowres(MpegEncContext *s,
3658
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3659
int dir, uint8_t **ref_picture,
3660
h264_chroma_mc_func *pix_op)
3664
const int lowres= s->avctx->lowres;
3665
const int block_s= 8>>lowres;
3670
switch(s->mv_type) {
3672
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3674
ref_picture, pix_op,
3675
s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3681
hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3682
ref_picture[0], 0, 0,
3683
(2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3684
s->width, s->height, s->linesize,
3685
s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3686
block_s, block_s, pix_op,
3687
s->mv[dir][i][0], s->mv[dir][i][1]);
3689
mx += s->mv[dir][i][0];
3690
my += s->mv[dir][i][1];
3693
if(!(s->flags&CODEC_FLAG_GRAY))
3694
chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3697
if (s->picture_structure == PICT_FRAME) {
3699
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3700
1, 0, s->field_select[dir][0],
3701
ref_picture, pix_op,
3702
s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3704
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3705
1, 1, s->field_select[dir][1],
3706
ref_picture, pix_op,
3707
s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3709
if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3710
ref_picture= s->current_picture_ptr->data;
3713
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3714
0, 0, s->field_select[dir][0],
3715
ref_picture, pix_op,
3716
s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3721
uint8_t ** ref2picture;
3723
if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3724
ref2picture= ref_picture;
3726
ref2picture= s->current_picture_ptr->data;
3729
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3730
0, 0, s->field_select[dir][i],
3731
ref2picture, pix_op,
3732
s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3734
dest_y += 2*block_s*s->linesize;
3735
dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3736
dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3740
if(s->picture_structure == PICT_FRAME){
3744
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3746
ref_picture, pix_op,
3747
s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3749
pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3753
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3754
0, 0, s->picture_structure != i+1,
3755
ref_picture, pix_op,
3756
s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3758
// after put we make avg of the same block
3759
pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3761
//opposite parity is always in the same frame if this is second field
3762
if(!s->first_field){
3763
ref_picture = s->current_picture_ptr->data;
3772
/* put block[] to dest[] */
3773
static inline void put_dct(MpegEncContext *s,
3774
DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3776
s->dct_unquantize_intra(s, block, i, qscale);
3777
s->dsp.idct_put (dest, line_size, block);
3780
/* add block[] to dest[] */
3781
static inline void add_dct(MpegEncContext *s,
3782
DCTELEM *block, int i, uint8_t *dest, int line_size)
3784
if (s->block_last_index[i] >= 0) {
3785
s->dsp.idct_add (dest, line_size, block);
3789
static inline void add_dequant_dct(MpegEncContext *s,
3790
DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3792
if (s->block_last_index[i] >= 0) {
3793
s->dct_unquantize_inter(s, block, i, qscale);
3795
s->dsp.idct_add (dest, line_size, block);
3800
* cleans dc, ac, coded_block for the current non intra MB
3802
void ff_clean_intra_table_entries(MpegEncContext *s)
3804
int wrap = s->b8_stride;
3805
int xy = s->block_index[0];
3808
s->dc_val[0][xy + 1 ] =
3809
s->dc_val[0][xy + wrap] =
3810
s->dc_val[0][xy + 1 + wrap] = 1024;
3812
memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3813
memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3814
if (s->msmpeg4_version>=3) {
3815
s->coded_block[xy ] =
3816
s->coded_block[xy + 1 ] =
3817
s->coded_block[xy + wrap] =
3818
s->coded_block[xy + 1 + wrap] = 0;
3821
wrap = s->mb_stride;
3822
xy = s->mb_x + s->mb_y * wrap;
3824
s->dc_val[2][xy] = 1024;
3826
memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3827
memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3829
s->mbintra_table[xy]= 0;
3832
/* generic function called after a macroblock has been parsed by the
3833
decoder or after it has been encoded by the encoder.
3835
Important variables used:
3836
s->mb_intra : true if intra macroblock
3837
s->mv_dir : motion vector direction
3838
s->mv_type : motion vector type
3839
s->mv : motion vector
3840
s->interlaced_dct : true if interlaced dct used (mpeg2)
3842
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3845
const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3847
if(s->avctx->xvmc_acceleration){
3848
XVMC_decode_mb(s);//xvmc uses pblocks
3856
if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3857
/* save DCT coefficients */
3859
DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3862
*dct++ = block[i][s->dsp.idct_permutation[j]];
3865
s->current_picture.qscale_table[mb_xy]= s->qscale;
3867
/* update DC predictors for P macroblocks */
3869
if (s->h263_pred || s->h263_aic) {
3870
if(s->mbintra_table[mb_xy])
3871
ff_clean_intra_table_entries(s);
3875
s->last_dc[2] = 128 << s->intra_dc_precision;
3878
else if (s->h263_pred || s->h263_aic)
3879
s->mbintra_table[mb_xy]=1;
3881
if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3882
uint8_t *dest_y, *dest_cb, *dest_cr;
3883
int dct_linesize, dct_offset;
3884
op_pixels_func (*op_pix)[4];
3885
qpel_mc_func (*op_qpix)[16];
3886
const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3887
const int uvlinesize= s->current_picture.linesize[1];
3888
const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3889
const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3891
/* avoid copy if macroblock skipped in last frame too */
3892
/* skip only during decoding as we might trash the buffers during encoding a bit */
3894
uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3895
const int age= s->current_picture.age;
3899
if (s->mb_skipped) {
3901
assert(s->pict_type!=I_TYPE);
3903
(*mbskip_ptr) ++; /* indicate that this time we skipped it */
3904
if(*mbskip_ptr >99) *mbskip_ptr= 99;
3906
/* if previous was skipped too, then nothing to do ! */
3907
if (*mbskip_ptr >= age && s->current_picture.reference){
3910
} else if(!s->current_picture.reference){
3911
(*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3912
if(*mbskip_ptr >99) *mbskip_ptr= 99;
3914
*mbskip_ptr = 0; /* not skipped */
3918
dct_linesize = linesize << s->interlaced_dct;
3919
dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3923
dest_cb= s->dest[1];
3924
dest_cr= s->dest[2];
3926
dest_y = s->b_scratchpad;
3927
dest_cb= s->b_scratchpad+16*linesize;
3928
dest_cr= s->b_scratchpad+32*linesize;
3932
/* motion handling */
3933
/* decoding or more than one mb_type (MC was already done otherwise) */
3936
h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3938
if (s->mv_dir & MV_DIR_FORWARD) {
3939
MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3940
op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3942
if (s->mv_dir & MV_DIR_BACKWARD) {
3943
MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3946
if ((!s->no_rounding) || s->pict_type==B_TYPE){
3947
op_pix = s->dsp.put_pixels_tab;
3948
op_qpix= s->dsp.put_qpel_pixels_tab;
3950
op_pix = s->dsp.put_no_rnd_pixels_tab;
3951
op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3953
if (s->mv_dir & MV_DIR_FORWARD) {
3954
MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3955
op_pix = s->dsp.avg_pixels_tab;
3956
op_qpix= s->dsp.avg_qpel_pixels_tab;
3958
if (s->mv_dir & MV_DIR_BACKWARD) {
3959
MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3964
/* skip dequant / idct if we are really late ;) */
3965
if(s->hurry_up>1) goto skip_idct;
3966
if(s->avctx->skip_idct){
3967
if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3968
||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3969
|| s->avctx->skip_idct >= AVDISCARD_ALL)
3973
/* add dct residue */
3974
if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3975
|| (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3976
add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3977
add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3978
add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3979
add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3981
if(!(s->flags&CODEC_FLAG_GRAY)){
3982
if (s->chroma_y_shift){
3983
add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3984
add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3988
add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3989
add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3990
add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3991
add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3994
} else if(s->codec_id != CODEC_ID_WMV2){
3995
add_dct(s, block[0], 0, dest_y , dct_linesize);
3996
add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3997
add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3998
add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
4000
if(!(s->flags&CODEC_FLAG_GRAY)){
4001
if(s->chroma_y_shift){//Chroma420
4002
add_dct(s, block[4], 4, dest_cb, uvlinesize);
4003
add_dct(s, block[5], 5, dest_cr, uvlinesize);
4006
dct_linesize = uvlinesize << s->interlaced_dct;
4007
dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4009
add_dct(s, block[4], 4, dest_cb, dct_linesize);
4010
add_dct(s, block[5], 5, dest_cr, dct_linesize);
4011
add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4012
add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4013
if(!s->chroma_x_shift){//Chroma444
4014
add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4015
add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4016
add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4017
add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4023
ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4026
/* dct only in intra block */
4027
if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4028
put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4029
put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4030
put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4031
put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4033
if(!(s->flags&CODEC_FLAG_GRAY)){
4034
if(s->chroma_y_shift){
4035
put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4036
put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4040
put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4041
put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4042
put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4043
put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4047
s->dsp.idct_put(dest_y , dct_linesize, block[0]);
4048
s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
4049
s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
4050
s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4052
if(!(s->flags&CODEC_FLAG_GRAY)){
4053
if(s->chroma_y_shift){
4054
s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4055
s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4058
dct_linesize = uvlinesize << s->interlaced_dct;
4059
dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4061
s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4062
s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4063
s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4064
s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4065
if(!s->chroma_x_shift){//Chroma444
4066
s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4067
s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4068
s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4069
s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4077
s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4078
s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4079
s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4084
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4085
if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4086
else MPV_decode_mb_internal(s, block, 0);
4089
#ifdef CONFIG_ENCODERS
4091
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4093
static const char tab[64]=
4105
DCTELEM *block= s->block[n];
4106
const int last_index= s->block_last_index[n];
4111
threshold= -threshold;
4115
/* are all which we could set to zero are allready zero? */
4116
if(last_index<=skip_dc - 1) return;
4118
for(i=0; i<=last_index; i++){
4119
const int j = s->intra_scantable.permutated[i];
4120
const int level = ABS(block[j]);
4122
if(skip_dc && i==0) continue;
4131
if(score >= threshold) return;
4132
for(i=skip_dc; i<=last_index; i++){
4133
const int j = s->intra_scantable.permutated[i];
4136
if(block[0]) s->block_last_index[n]= 0;
4137
else s->block_last_index[n]= -1;
4140
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4143
const int maxlevel= s->max_qcoeff;
4144
const int minlevel= s->min_qcoeff;
4148
i=1; //skip clipping of intra dc
4152
for(;i<=last_index; i++){
4153
const int j= s->intra_scantable.permutated[i];
4154
int level = block[j];
4156
if (level>maxlevel){
4159
}else if(level<minlevel){
4167
if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4168
av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4171
#endif //CONFIG_ENCODERS
4175
* @param h is the normal height, this will be reduced automatically if needed for the last row
4177
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4178
if (s->avctx->draw_horiz_band) {
4182
if(s->picture_structure != PICT_FRAME){
4185
if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4188
h= FFMIN(h, s->avctx->height - y);
4190
if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4191
src= (AVFrame*)s->current_picture_ptr;
4192
else if(s->last_picture_ptr)
4193
src= (AVFrame*)s->last_picture_ptr;
4197
if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4203
offset[0]= y * s->linesize;;
4205
offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4211
s->avctx->draw_horiz_band(s->avctx, src, offset,
4212
y, s->picture_structure, h);
4216
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4217
const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4218
const int uvlinesize= s->current_picture.linesize[1];
4219
const int mb_size= 4 - s->avctx->lowres;
4221
s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4222
s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4223
s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4224
s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4225
s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4226
s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4227
//block_index is not used by mpeg2, so it is not affected by chroma_format
4229
s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4230
s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4231
s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4233
if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4235
s->dest[0] += s->mb_y * linesize << mb_size;
4236
s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4237
s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4241
#ifdef CONFIG_ENCODERS
4243
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4253
for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4254
for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4255
int v= ptr[x2 + y2*stride];
4261
weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4266
static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4268
int16_t weight[8][64];
4269
DCTELEM orig[8][64];
4270
const int mb_x= s->mb_x;
4271
const int mb_y= s->mb_y;
4274
int dct_offset = s->linesize*8; //default for progressive frames
4275
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4278
for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4280
if(s->adaptive_quant){
4281
const int last_qp= s->qscale;
4282
const int mb_xy= mb_x + mb_y*s->mb_stride;
4284
s->lambda= s->lambda_table[mb_xy];
4287
if(!(s->flags&CODEC_FLAG_QP_RD)){
4288
s->dquant= s->qscale - last_qp;
4290
if(s->out_format==FMT_H263){
4291
s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4293
if(s->codec_id==CODEC_ID_MPEG4){
4295
if(s->pict_type == B_TYPE){
4297
s->dquant= (s->dquant/2)*2;
4298
if(s->mv_dir&MV_DIRECT)
4301
if(s->mv_type==MV_TYPE_8X8)
4307
ff_set_qscale(s, last_qp + s->dquant);
4308
}else if(s->flags&CODEC_FLAG_QP_RD)
4309
ff_set_qscale(s, s->qscale + s->dquant);
4311
wrap_y = s->linesize;
4312
wrap_c = s->uvlinesize;
4313
ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4314
ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4315
ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4317
if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4318
uint8_t *ebuf= s->edge_emu_buffer + 32;
4319
ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
4321
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);
4322
ptr_cb= ebuf+18*wrap_y;
4323
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);
4324
ptr_cr= ebuf+18*wrap_y+8;
4328
if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4329
int progressive_score, interlaced_score;
4331
s->interlaced_dct=0;
4332
progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4333
+s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4335
if(progressive_score > 0){
4336
interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4337
+s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4338
if(progressive_score > interlaced_score){
4339
s->interlaced_dct=1;
4343
if (s->chroma_format == CHROMA_422)
4349
s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4350
s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4351
s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4352
s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4354
if(s->flags&CODEC_FLAG_GRAY){
4358
s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4359
s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4360
if(!s->chroma_y_shift){ /* 422 */
4361
s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4362
s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4366
op_pixels_func (*op_pix)[4];
4367
qpel_mc_func (*op_qpix)[16];
4368
uint8_t *dest_y, *dest_cb, *dest_cr;
4370
dest_y = s->dest[0];
4371
dest_cb = s->dest[1];
4372
dest_cr = s->dest[2];
4374
if ((!s->no_rounding) || s->pict_type==B_TYPE){
4375
op_pix = s->dsp.put_pixels_tab;
4376
op_qpix= s->dsp.put_qpel_pixels_tab;
4378
op_pix = s->dsp.put_no_rnd_pixels_tab;
4379
op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4382
if (s->mv_dir & MV_DIR_FORWARD) {
4383
MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4384
op_pix = s->dsp.avg_pixels_tab;
4385
op_qpix= s->dsp.avg_qpel_pixels_tab;
4387
if (s->mv_dir & MV_DIR_BACKWARD) {
4388
MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4391
if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4392
int progressive_score, interlaced_score;
4394
s->interlaced_dct=0;
4395
progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4396
+s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4398
if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4400
if(progressive_score>0){
4401
interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4402
+s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4404
if(progressive_score > interlaced_score){
4405
s->interlaced_dct=1;
4409
if (s->chroma_format == CHROMA_422)
4415
s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4416
s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4417
s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4418
s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4420
if(s->flags&CODEC_FLAG_GRAY){
4424
s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4425
s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4426
if(!s->chroma_y_shift){ /* 422 */
4427
s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4428
s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4431
/* pre quantization */
4432
if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4434
if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4435
if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4436
if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4437
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;
4438
if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4439
if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4440
if(!s->chroma_y_shift){ /* 422 */
4441
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;
4442
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;
4447
if(s->avctx->quantizer_noise_shaping){
4448
if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4449
if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4450
if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4451
if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4452
if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4453
if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4454
if(!s->chroma_y_shift){ /* 422 */
4455
if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4456
if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4458
memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4461
/* DCT & quantize */
4462
assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4464
for(i=0;i<mb_block_count;i++) {
4467
s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4468
// FIXME we could decide to change to quantizer instead of clipping
4469
// JS: I don't think that would be a good idea it could lower quality instead
4470
// of improve it. Just INTRADC clipping deserves changes in quantizer
4471
if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4473
s->block_last_index[i]= -1;
4475
if(s->avctx->quantizer_noise_shaping){
4476
for(i=0;i<mb_block_count;i++) {
4478
s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4483
if(s->luma_elim_threshold && !s->mb_intra)
4485
dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4486
if(s->chroma_elim_threshold && !s->mb_intra)
4487
for(i=4; i<mb_block_count; i++)
4488
dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4490
if(s->flags & CODEC_FLAG_CBP_RD){
4491
for(i=0;i<mb_block_count;i++) {
4492
if(s->block_last_index[i] == -1)
4493
s->coded_score[i]= INT_MAX/256;
4498
if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4499
s->block_last_index[4]=
4500
s->block_last_index[5]= 0;
4502
s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4505
//non c quantize code returns incorrect block_last_index FIXME
4506
if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4507
for(i=0; i<mb_block_count; i++){
4509
if(s->block_last_index[i]>0){
4510
for(j=63; j>0; j--){
4511
if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4513
s->block_last_index[i]= j;
4518
/* huffman encode */
4519
switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4520
case CODEC_ID_MPEG1VIDEO:
4521
case CODEC_ID_MPEG2VIDEO:
4522
mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4523
case CODEC_ID_MPEG4:
4524
mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4525
case CODEC_ID_MSMPEG4V2:
4526
case CODEC_ID_MSMPEG4V3:
4528
msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4530
ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4531
#ifdef CONFIG_H261_ENCODER
4533
ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4536
case CODEC_ID_H263P:
4540
h263_encode_mb(s, s->block, motion_x, motion_y); break;
4541
case CODEC_ID_MJPEG:
4542
mjpeg_encode_mb(s, s->block); break;
4548
static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4550
if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
4551
else encode_mb_internal(s, motion_x, motion_y, 16, 8);
4554
#endif //CONFIG_ENCODERS
4556
void ff_mpeg_flush(AVCodecContext *avctx){
4558
MpegEncContext *s = avctx->priv_data;
4560
if(s==NULL || s->picture==NULL)
4563
for(i=0; i<MAX_PICTURE_COUNT; i++){
4564
if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4565
|| s->picture[i].type == FF_BUFFER_TYPE_USER))
4566
avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4568
s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4570
s->mb_x= s->mb_y= 0;
4572
s->parse_context.state= -1;
4573
s->parse_context.frame_start_found= 0;
4574
s->parse_context.overread= 0;
4575
s->parse_context.overread_index= 0;
4576
s->parse_context.index= 0;
4577
s->parse_context.last_index= 0;
4578
s->bitstream_buffer_size=0;
4581
#ifdef CONFIG_ENCODERS
4582
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4584
const uint16_t *srcw= (uint16_t*)src;
4585
int words= length>>4;
4586
int bits= length&15;
4589
if(length==0) return;
4592
for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4593
}else if(put_bits_count(pb)&7){
4594
for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4596
for(i=0; put_bits_count(pb)&31; i++)
4597
put_bits(pb, 8, src[i]);
4599
memcpy(pbBufPtr(pb), src+i, 2*words-i);
4600
skip_put_bytes(pb, 2*words-i);
4603
put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4606
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4609
memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4612
d->mb_skip_run= s->mb_skip_run;
4614
d->last_dc[i]= s->last_dc[i];
4617
d->mv_bits= s->mv_bits;
4618
d->i_tex_bits= s->i_tex_bits;
4619
d->p_tex_bits= s->p_tex_bits;
4620
d->i_count= s->i_count;
4621
d->f_count= s->f_count;
4622
d->b_count= s->b_count;
4623
d->skip_count= s->skip_count;
4624
d->misc_bits= s->misc_bits;
4628
d->qscale= s->qscale;
4629
d->dquant= s->dquant;
4632
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4635
memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4636
memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4639
d->mb_skip_run= s->mb_skip_run;
4641
d->last_dc[i]= s->last_dc[i];
4644
d->mv_bits= s->mv_bits;
4645
d->i_tex_bits= s->i_tex_bits;
4646
d->p_tex_bits= s->p_tex_bits;
4647
d->i_count= s->i_count;
4648
d->f_count= s->f_count;
4649
d->b_count= s->b_count;
4650
d->skip_count= s->skip_count;
4651
d->misc_bits= s->misc_bits;
4653
d->mb_intra= s->mb_intra;
4654
d->mb_skipped= s->mb_skipped;
4655
d->mv_type= s->mv_type;
4656
d->mv_dir= s->mv_dir;
4658
if(s->data_partitioning){
4660
d->tex_pb= s->tex_pb;
4664
d->block_last_index[i]= s->block_last_index[i];
4665
d->interlaced_dct= s->interlaced_dct;
4666
d->qscale= s->qscale;
4669
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4670
PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4671
int *dmin, int *next_block, int motion_x, int motion_y)
4674
uint8_t *dest_backup[3];
4676
copy_context_before_encode(s, backup, type);
4678
s->block= s->blocks[*next_block];
4679
s->pb= pb[*next_block];
4680
if(s->data_partitioning){
4681
s->pb2 = pb2 [*next_block];
4682
s->tex_pb= tex_pb[*next_block];
4686
memcpy(dest_backup, s->dest, sizeof(s->dest));
4687
s->dest[0] = s->rd_scratchpad;
4688
s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4689
s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4690
assert(s->linesize >= 32); //FIXME
4693
encode_mb(s, motion_x, motion_y);
4695
score= put_bits_count(&s->pb);
4696
if(s->data_partitioning){
4697
score+= put_bits_count(&s->pb2);
4698
score+= put_bits_count(&s->tex_pb);
4701
if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4702
MPV_decode_mb(s, s->block);
4704
score *= s->lambda2;
4705
score += sse_mb(s) << FF_LAMBDA_SHIFT;
4709
memcpy(s->dest, dest_backup, sizeof(s->dest));
4716
copy_context_after_encode(best, s, type);
4720
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4721
uint32_t *sq = squareTbl + 256;
4726
return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4727
else if(w==8 && h==8)
4728
return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4732
acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4741
static int sse_mb(MpegEncContext *s){
4745
if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4746
if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4749
if(s->avctx->mb_cmp == FF_CMP_NSSE){
4750
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)
4751
+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)
4752
+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);
4754
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)
4755
+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)
4756
+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);
4759
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)
4760
+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)
4761
+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);
4764
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4765
MpegEncContext *s= arg;
4769
s->me.dia_size= s->avctx->pre_dia_size;
4770
s->first_slice_line=1;
4771
for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4772
for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4773
ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4775
s->first_slice_line=0;
4783
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4784
MpegEncContext *s= arg;
4786
s->me.dia_size= s->avctx->dia_size;
4787
s->first_slice_line=1;
4788
for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4789
s->mb_x=0; //for block init below
4790
ff_init_block_index(s);
4791
for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4792
s->block_index[0]+=2;
4793
s->block_index[1]+=2;
4794
s->block_index[2]+=2;
4795
s->block_index[3]+=2;
4797
/* compute motion vector & mb_type and store in context */
4798
if(s->pict_type==B_TYPE)
4799
ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4801
ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4803
s->first_slice_line=0;
4808
static int mb_var_thread(AVCodecContext *c, void *arg){
4809
MpegEncContext *s= arg;
4812
for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4813
for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4816
uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4818
int sum = s->dsp.pix_sum(pix, s->linesize);
4820
varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4822
s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4823
s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4824
s->me.mb_var_sum_temp += varc;
4830
static void write_slice_end(MpegEncContext *s){
4831
if(s->codec_id==CODEC_ID_MPEG4){
4832
if(s->partitioned_frame){
4833
ff_mpeg4_merge_partitions(s);
4836
ff_mpeg4_stuffing(&s->pb);
4837
}else if(s->out_format == FMT_MJPEG){
4838
ff_mjpeg_stuffing(&s->pb);
4841
align_put_bits(&s->pb);
4842
flush_put_bits(&s->pb);
4844
if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4845
s->misc_bits+= get_bits_diff(s);
4848
static int encode_thread(AVCodecContext *c, void *arg){
4849
MpegEncContext *s= arg;
4850
int mb_x, mb_y, pdif = 0;
4852
MpegEncContext best_s, backup_s;
4853
uint8_t bit_buf[2][MAX_MB_BYTES];
4854
uint8_t bit_buf2[2][MAX_MB_BYTES];
4855
uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4856
PutBitContext pb[2], pb2[2], tex_pb[2];
4857
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4860
init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4861
init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4862
init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4865
s->last_bits= put_bits_count(&s->pb);
4876
/* init last dc values */
4877
/* note: quant matrix value (8) is implied here */
4878
s->last_dc[i] = 128 << s->intra_dc_precision;
4880
s->current_picture.error[i] = 0;
4883
memset(s->last_mv, 0, sizeof(s->last_mv));
4887
switch(s->codec_id){
4889
case CODEC_ID_H263P:
4891
s->gob_index = ff_h263_get_gob_height(s);
4893
case CODEC_ID_MPEG4:
4894
if(s->partitioned_frame)
4895
ff_mpeg4_init_partitions(s);
4901
s->first_slice_line = 1;
4902
s->ptr_lastgob = s->pb.buf;
4903
for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4904
// printf("row %d at %X\n", s->mb_y, (int)s);
4908
ff_set_qscale(s, s->qscale);
4909
ff_init_block_index(s);
4911
for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4912
int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4913
int mb_type= s->mb_type[xy];
4918
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4919
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4922
if(s->data_partitioning){
4923
if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4924
|| s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4925
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4931
s->mb_y = mb_y; // moved into loop, can get changed by H.261
4932
ff_update_block_index(s);
4934
#ifdef CONFIG_H261_ENCODER
4935
if(s->codec_id == CODEC_ID_H261){
4936
ff_h261_reorder_mb_index(s);
4937
xy= s->mb_y*s->mb_stride + s->mb_x;
4938
mb_type= s->mb_type[xy];
4942
/* write gob / video packet header */
4944
int current_packet_size, is_gob_start;
4946
current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4948
is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4950
if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4952
switch(s->codec_id){
4954
case CODEC_ID_H263P:
4955
if(!s->h263_slice_structured)
4956
if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4958
case CODEC_ID_MPEG2VIDEO:
4959
if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4960
case CODEC_ID_MPEG1VIDEO:
4961
if(s->mb_skip_run) is_gob_start=0;
4966
if(s->start_mb_y != mb_y || mb_x!=0){
4969
if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4970
ff_mpeg4_init_partitions(s);
4974
assert((put_bits_count(&s->pb)&7) == 0);
4975
current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4977
if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4978
int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4979
int d= 100 / s->avctx->error_rate;
4981
current_packet_size=0;
4982
#ifndef ALT_BITSTREAM_WRITER
4983
s->pb.buf_ptr= s->ptr_lastgob;
4985
assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4989
if (s->avctx->rtp_callback){
4990
int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
4991
s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
4994
switch(s->codec_id){
4995
case CODEC_ID_MPEG4:
4996
ff_mpeg4_encode_video_packet_header(s);
4997
ff_mpeg4_clean_buffers(s);
4999
case CODEC_ID_MPEG1VIDEO:
5000
case CODEC_ID_MPEG2VIDEO:
5001
ff_mpeg1_encode_slice_header(s);
5002
ff_mpeg1_clean_buffers(s);
5005
case CODEC_ID_H263P:
5006
h263_encode_gob_header(s, mb_y);
5010
if(s->flags&CODEC_FLAG_PASS1){
5011
int bits= put_bits_count(&s->pb);
5012
s->misc_bits+= bits - s->last_bits;
5016
s->ptr_lastgob += current_packet_size;
5017
s->first_slice_line=1;
5018
s->resync_mb_x=mb_x;
5019
s->resync_mb_y=mb_y;
5023
if( (s->resync_mb_x == s->mb_x)
5024
&& s->resync_mb_y+1 == s->mb_y){
5025
s->first_slice_line=0;
5029
s->dquant=0; //only for QP_RD
5031
if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5033
int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5035
copy_context_before_encode(&backup_s, s, -1);
5037
best_s.data_partitioning= s->data_partitioning;
5038
best_s.partitioned_frame= s->partitioned_frame;
5039
if(s->data_partitioning){
5040
backup_s.pb2= s->pb2;
5041
backup_s.tex_pb= s->tex_pb;
5044
if(mb_type&CANDIDATE_MB_TYPE_INTER){
5045
s->mv_dir = MV_DIR_FORWARD;
5046
s->mv_type = MV_TYPE_16X16;
5048
s->mv[0][0][0] = s->p_mv_table[xy][0];
5049
s->mv[0][0][1] = s->p_mv_table[xy][1];
5050
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5051
&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5053
if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5054
s->mv_dir = MV_DIR_FORWARD;
5055
s->mv_type = MV_TYPE_FIELD;
5058
j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5059
s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5060
s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5062
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5063
&dmin, &next_block, 0, 0);
5065
if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5066
s->mv_dir = MV_DIR_FORWARD;
5067
s->mv_type = MV_TYPE_16X16;
5071
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5072
&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5074
if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5075
s->mv_dir = MV_DIR_FORWARD;
5076
s->mv_type = MV_TYPE_8X8;
5079
s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5080
s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5082
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5083
&dmin, &next_block, 0, 0);
5085
if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5086
s->mv_dir = MV_DIR_FORWARD;
5087
s->mv_type = MV_TYPE_16X16;
5089
s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5090
s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5091
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5092
&dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5094
if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5095
s->mv_dir = MV_DIR_BACKWARD;
5096
s->mv_type = MV_TYPE_16X16;
5098
s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5099
s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5100
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5101
&dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5103
if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5104
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5105
s->mv_type = MV_TYPE_16X16;
5107
s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5108
s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5109
s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5110
s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5111
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5112
&dmin, &next_block, 0, 0);
5114
if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5115
int mx= s->b_direct_mv_table[xy][0];
5116
int my= s->b_direct_mv_table[xy][1];
5118
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5120
ff_mpeg4_set_direct_mv(s, mx, my);
5121
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5122
&dmin, &next_block, mx, my);
5124
if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5125
s->mv_dir = MV_DIR_FORWARD;
5126
s->mv_type = MV_TYPE_FIELD;
5129
j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5130
s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5131
s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5133
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5134
&dmin, &next_block, 0, 0);
5136
if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5137
s->mv_dir = MV_DIR_BACKWARD;
5138
s->mv_type = MV_TYPE_FIELD;
5141
j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5142
s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5143
s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5145
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5146
&dmin, &next_block, 0, 0);
5148
if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5149
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5150
s->mv_type = MV_TYPE_FIELD;
5152
for(dir=0; dir<2; dir++){
5154
j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5155
s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5156
s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5159
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5160
&dmin, &next_block, 0, 0);
5162
if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5164
s->mv_type = MV_TYPE_16X16;
5168
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5169
&dmin, &next_block, 0, 0);
5170
if(s->h263_pred || s->h263_aic){
5172
s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5174
ff_clean_intra_table_entries(s); //old mode?
5178
if(s->flags & CODEC_FLAG_QP_RD){
5179
if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
5180
const int last_qp= backup_s.qscale;
5181
int dquant, dir, qp, dc[6];
5183
const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5185
assert(backup_s.dquant == 0);
5188
s->mv_dir= best_s.mv_dir;
5189
s->mv_type = MV_TYPE_16X16;
5190
s->mb_intra= best_s.mb_intra;
5191
s->mv[0][0][0] = best_s.mv[0][0][0];
5192
s->mv[0][0][1] = best_s.mv[0][0][1];
5193
s->mv[1][0][0] = best_s.mv[1][0][0];
5194
s->mv[1][0][1] = best_s.mv[1][0][1];
5196
dir= s->pict_type == B_TYPE ? 2 : 1;
5197
if(last_qp + dir > s->avctx->qmax) dir= -dir;
5198
for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
5199
qp= last_qp + dquant;
5200
if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5202
backup_s.dquant= dquant;
5203
if(s->mb_intra && s->dc_val[0]){
5205
dc[i]= s->dc_val[0][ s->block_index[i] ];
5206
memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5210
encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5211
&dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5212
if(best_s.qscale != qp){
5213
if(s->mb_intra && s->dc_val[0]){
5215
s->dc_val[0][ s->block_index[i] ]= dc[i];
5216
memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5219
if(dir > 0 && dquant==dir){
5227
s->current_picture.qscale_table[xy]= qp;
5231
copy_context_after_encode(s, &best_s, -1);
5233
pb_bits_count= put_bits_count(&s->pb);
5234
flush_put_bits(&s->pb);
5235
ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5238
if(s->data_partitioning){
5239
pb2_bits_count= put_bits_count(&s->pb2);
5240
flush_put_bits(&s->pb2);
5241
ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5242
s->pb2= backup_s.pb2;
5244
tex_pb_bits_count= put_bits_count(&s->tex_pb);
5245
flush_put_bits(&s->tex_pb);
5246
ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5247
s->tex_pb= backup_s.tex_pb;
5249
s->last_bits= put_bits_count(&s->pb);
5251
if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5252
ff_h263_update_motion_val(s);
5254
if(next_block==0){ //FIXME 16 vs linesize16
5255
s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5256
s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5257
s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5260
if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5261
MPV_decode_mb(s, s->block);
5263
int motion_x, motion_y;
5264
s->mv_type=MV_TYPE_16X16;
5265
// only one MB-Type possible
5268
case CANDIDATE_MB_TYPE_INTRA:
5271
motion_x= s->mv[0][0][0] = 0;
5272
motion_y= s->mv[0][0][1] = 0;
5274
case CANDIDATE_MB_TYPE_INTER:
5275
s->mv_dir = MV_DIR_FORWARD;
5277
motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5278
motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5280
case CANDIDATE_MB_TYPE_INTER_I:
5281
s->mv_dir = MV_DIR_FORWARD;
5282
s->mv_type = MV_TYPE_FIELD;
5285
j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5286
s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5287
s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5289
motion_x = motion_y = 0;
5291
case CANDIDATE_MB_TYPE_INTER4V:
5292
s->mv_dir = MV_DIR_FORWARD;
5293
s->mv_type = MV_TYPE_8X8;
5296
s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5297
s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5299
motion_x= motion_y= 0;
5301
case CANDIDATE_MB_TYPE_DIRECT:
5302
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5304
motion_x=s->b_direct_mv_table[xy][0];
5305
motion_y=s->b_direct_mv_table[xy][1];
5306
ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5308
case CANDIDATE_MB_TYPE_BIDIR:
5309
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5313
s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5314
s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5315
s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5316
s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5318
case CANDIDATE_MB_TYPE_BACKWARD:
5319
s->mv_dir = MV_DIR_BACKWARD;
5321
motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5322
motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5324
case CANDIDATE_MB_TYPE_FORWARD:
5325
s->mv_dir = MV_DIR_FORWARD;
5327
motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5328
motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5329
// printf(" %d %d ", motion_x, motion_y);
5331
case CANDIDATE_MB_TYPE_FORWARD_I:
5332
s->mv_dir = MV_DIR_FORWARD;
5333
s->mv_type = MV_TYPE_FIELD;
5336
j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5337
s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5338
s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5340
motion_x=motion_y=0;
5342
case CANDIDATE_MB_TYPE_BACKWARD_I:
5343
s->mv_dir = MV_DIR_BACKWARD;
5344
s->mv_type = MV_TYPE_FIELD;
5347
j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5348
s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5349
s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5351
motion_x=motion_y=0;
5353
case CANDIDATE_MB_TYPE_BIDIR_I:
5354
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5355
s->mv_type = MV_TYPE_FIELD;
5357
for(dir=0; dir<2; dir++){
5359
j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5360
s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5361
s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5364
motion_x=motion_y=0;
5367
motion_x=motion_y=0; //gcc warning fix
5368
av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5371
encode_mb(s, motion_x, motion_y);
5373
// RAL: Update last macroblock type
5374
s->last_mv_dir = s->mv_dir;
5376
if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5377
ff_h263_update_motion_val(s);
5379
MPV_decode_mb(s, s->block);
5382
/* clean the MV table in IPS frames for direct mode in B frames */
5383
if(s->mb_intra /* && I,P,S_TYPE */){
5384
s->p_mv_table[xy][0]=0;
5385
s->p_mv_table[xy][1]=0;
5388
if(s->flags&CODEC_FLAG_PSNR){
5392
if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
5393
if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
5395
s->current_picture.error[0] += sse(
5396
s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
5397
s->dest[0], w, h, s->linesize);
5398
s->current_picture.error[1] += sse(
5399
s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5400
s->dest[1], w>>1, h>>1, s->uvlinesize);
5401
s->current_picture.error[2] += sse(
5402
s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5403
s->dest[2], w>>1, h>>1, s->uvlinesize);
5406
if(s->out_format == FMT_H263)
5407
ff_h263_loop_filter(s);
5409
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5413
//not beautiful here but we must write it before flushing so it has to be here
5414
if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5415
msmpeg4_encode_ext_header(s);
5419
/* Send the last GOB if RTP */
5420
if (s->avctx->rtp_callback) {
5421
int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5422
pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5423
/* Call the RTP callback to send the last GOB */
5425
s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5431
#define MERGE(field) dst->field += src->field; src->field=0
5432
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5433
MERGE(me.scene_change_score);
5434
MERGE(me.mc_mb_var_sum_temp);
5435
MERGE(me.mb_var_sum_temp);
5438
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
5441
MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5442
MERGE(dct_count[1]);
5452
MERGE(padding_bug_score);
5453
MERGE(current_picture.error[0]);
5454
MERGE(current_picture.error[1]);
5455
MERGE(current_picture.error[2]);
5457
if(dst->avctx->noise_reduction){
5458
for(i=0; i<64; i++){
5459
MERGE(dct_error_sum[0][i]);
5460
MERGE(dct_error_sum[1][i]);
5464
assert(put_bits_count(&src->pb) % 8 ==0);
5465
assert(put_bits_count(&dst->pb) % 8 ==0);
5466
ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5467
flush_put_bits(&dst->pb);
5470
static void estimate_qp(MpegEncContext *s, int dry_run){
5471
if (!s->fixed_qscale)
5472
s->current_picture_ptr->quality=
5473
s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5475
if(s->adaptive_quant){
5476
switch(s->codec_id){
5477
case CODEC_ID_MPEG4:
5478
ff_clean_mpeg4_qscales(s);
5481
case CODEC_ID_H263P:
5483
ff_clean_h263_qscales(s);
5487
s->lambda= s->lambda_table[0];
5490
s->lambda= s->current_picture.quality;
5491
//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5495
static void encode_picture(MpegEncContext *s, int picture_number)
5500
s->picture_number = picture_number;
5502
/* Reset the average MB variance */
5503
s->me.mb_var_sum_temp =
5504
s->me.mc_mb_var_sum_temp = 0;
5506
/* we need to initialize some time vars before we can encode b-frames */
5507
// RAL: Condition added for MPEG1VIDEO
5508
if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5509
ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5511
s->me.scene_change_score=0;
5513
// s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5515
if(s->pict_type==I_TYPE){
5516
if(s->msmpeg4_version >= 3) s->no_rounding=1;
5517
else s->no_rounding=0;
5518
}else if(s->pict_type!=B_TYPE){
5519
if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5520
s->no_rounding ^= 1;
5523
if(s->flags & CODEC_FLAG_PASS2){
5525
ff_get_2pass_fcode(s);
5526
}else if(!(s->flags & CODEC_FLAG_QSCALE)){
5527
if(s->pict_type==B_TYPE)
5528
s->lambda= s->last_lambda_for[s->pict_type];
5530
s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5534
s->mb_intra=0; //for the rate distortion & bit compare functions
5535
for(i=1; i<s->avctx->thread_count; i++){
5536
ff_update_duplicate_context(s->thread_context[i], s);
5541
/* Estimate motion for every MB */
5542
if(s->pict_type != I_TYPE){
5543
s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5544
s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5545
if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5546
if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
5547
s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5551
s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5552
}else /* if(s->pict_type == I_TYPE) */{
5554
for(i=0; i<s->mb_stride*s->mb_height; i++)
5555
s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5557
if(!s->fixed_qscale){
5558
/* finding spatial complexity for I-frame rate control */
5559
s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5562
for(i=1; i<s->avctx->thread_count; i++){
5563
merge_context_after_me(s, s->thread_context[i]);
5565
s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5566
s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5569
if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5570
s->pict_type= I_TYPE;
5571
for(i=0; i<s->mb_stride*s->mb_height; i++)
5572
s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5573
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5577
if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5578
s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5580
if(s->flags & CODEC_FLAG_INTERLACED_ME){
5582
a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5583
b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5584
s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5587
ff_fix_long_p_mvs(s);
5588
ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5589
if(s->flags & CODEC_FLAG_INTERLACED_ME){
5593
ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5594
s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5599
if(s->pict_type==B_TYPE){
5602
a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5603
b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5604
s->f_code = FFMAX(a, b);
5606
a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5607
b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5608
s->b_code = FFMAX(a, b);
5610
ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5611
ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5612
ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5613
ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5614
if(s->flags & CODEC_FLAG_INTERLACED_ME){
5616
for(dir=0; dir<2; dir++){
5619
int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5620
: (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5621
ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5622
s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5632
if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5633
s->qscale= 3; //reduce clipping problems
5635
if (s->out_format == FMT_MJPEG) {
5636
/* for mjpeg, we do include qscale in the matrix */
5637
s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5639
int j= s->dsp.idct_permutation[i];
5641
s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5643
convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5644
s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5648
//FIXME var duplication
5649
s->current_picture_ptr->key_frame=
5650
s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5651
s->current_picture_ptr->pict_type=
5652
s->current_picture.pict_type= s->pict_type;
5654
if(s->current_picture.key_frame)
5655
s->picture_in_gop_number=0;
5657
s->last_bits= put_bits_count(&s->pb);
5658
switch(s->out_format) {
5660
mjpeg_picture_header(s);
5662
#ifdef CONFIG_H261_ENCODER
5664
ff_h261_encode_picture_header(s, picture_number);
5668
if (s->codec_id == CODEC_ID_WMV2)
5669
ff_wmv2_encode_picture_header(s, picture_number);
5670
else if (s->h263_msmpeg4)
5671
msmpeg4_encode_picture_header(s, picture_number);
5672
else if (s->h263_pred)
5673
mpeg4_encode_picture_header(s, picture_number);
5674
#ifdef CONFIG_RV10_ENCODER
5675
else if (s->codec_id == CODEC_ID_RV10)
5676
rv10_encode_picture_header(s, picture_number);
5678
#ifdef CONFIG_RV20_ENCODER
5679
else if (s->codec_id == CODEC_ID_RV20)
5680
rv20_encode_picture_header(s, picture_number);
5682
else if (s->codec_id == CODEC_ID_FLV1)
5683
ff_flv_encode_picture_header(s, picture_number);
5685
h263_encode_picture_header(s, picture_number);
5688
mpeg1_encode_picture_header(s, picture_number);
5695
bits= put_bits_count(&s->pb);
5696
s->header_bits= bits - s->last_bits;
5698
for(i=1; i<s->avctx->thread_count; i++){
5699
update_duplicate_context_after_me(s->thread_context[i], s);
5701
s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5702
for(i=1; i<s->avctx->thread_count; i++){
5703
merge_context_after_encode(s, s->thread_context[i]);
5708
#endif //CONFIG_ENCODERS
5710
static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5711
const int intra= s->mb_intra;
5714
s->dct_count[intra]++;
5716
for(i=0; i<64; i++){
5717
int level= block[i];
5721
s->dct_error_sum[intra][i] += level;
5722
level -= s->dct_offset[intra][i];
5723
if(level<0) level=0;
5725
s->dct_error_sum[intra][i] -= level;
5726
level += s->dct_offset[intra][i];
5727
if(level>0) level=0;
5734
#ifdef CONFIG_ENCODERS
5736
static int dct_quantize_trellis_c(MpegEncContext *s,
5737
DCTELEM *block, int n,
5738
int qscale, int *overflow){
5740
const uint8_t *scantable= s->intra_scantable.scantable;
5741
const uint8_t *perm_scantable= s->intra_scantable.permutated;
5743
unsigned int threshold1, threshold2;
5755
int coeff_count[64];
5756
int qmul, qadd, start_i, last_non_zero, i, dc;
5757
const int esc_length= s->ac_esc_length;
5759
uint8_t * last_length;
5760
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5762
s->dsp.fdct (block);
5764
if(s->dct_error_sum)
5765
s->denoise_dct(s, block);
5767
qadd= ((qscale-1)|1)*8;
5778
/* For AIC we skip quant/dequant of INTRADC */
5783
/* note: block[0] is assumed to be positive */
5784
block[0] = (block[0] + (q >> 1)) / q;
5787
qmat = s->q_intra_matrix[qscale];
5788
if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5789
bias= 1<<(QMAT_SHIFT-1);
5790
length = s->intra_ac_vlc_length;
5791
last_length= s->intra_ac_vlc_last_length;
5795
qmat = s->q_inter_matrix[qscale];
5796
length = s->inter_ac_vlc_length;
5797
last_length= s->inter_ac_vlc_last_length;
5801
threshold1= (1<<QMAT_SHIFT) - bias - 1;
5802
threshold2= (threshold1<<1);
5804
for(i=63; i>=start_i; i--) {
5805
const int j = scantable[i];
5806
int level = block[j] * qmat[j];
5808
if(((unsigned)(level+threshold1))>threshold2){
5814
for(i=start_i; i<=last_non_zero; i++) {
5815
const int j = scantable[i];
5816
int level = block[j] * qmat[j];
5818
// if( bias+level >= (1<<(QMAT_SHIFT - 3))
5819
// || bias-level >= (1<<(QMAT_SHIFT - 3))){
5820
if(((unsigned)(level+threshold1))>threshold2){
5822
level= (bias + level)>>QMAT_SHIFT;
5824
coeff[1][i]= level-1;
5825
// coeff[2][k]= level-2;
5827
level= (bias - level)>>QMAT_SHIFT;
5828
coeff[0][i]= -level;
5829
coeff[1][i]= -level+1;
5830
// coeff[2][k]= -level+2;
5832
coeff_count[i]= FFMIN(level, 2);
5833
assert(coeff_count[i]);
5836
coeff[0][i]= (level>>31)|1;
5841
*overflow= s->max_qcoeff < max; //overflow might have happened
5843
if(last_non_zero < start_i){
5844
memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5845
return last_non_zero;
5848
score_tab[start_i]= 0;
5849
survivor[0]= start_i;
5852
for(i=start_i; i<=last_non_zero; i++){
5854
const int dct_coeff= ABS(block[ scantable[i] ]);
5855
const int zero_distoration= dct_coeff*dct_coeff;
5856
int best_score=256*256*256*120;
5857
for(level_index=0; level_index < coeff_count[i]; level_index++){
5859
int level= coeff[level_index][i];
5860
const int alevel= ABS(level);
5865
if(s->out_format == FMT_H263){
5866
unquant_coeff= alevel*qmul + qadd;
5868
j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5870
unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5871
unquant_coeff = (unquant_coeff - 1) | 1;
5873
unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5874
unquant_coeff = (unquant_coeff - 1) | 1;
5879
distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5881
if((level&(~127)) == 0){
5882
for(j=survivor_count-1; j>=0; j--){
5883
int run= i - survivor[j];
5884
int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5885
score += score_tab[i-run];
5887
if(score < best_score){
5890
level_tab[i+1]= level-64;
5894
if(s->out_format == FMT_H263){
5895
for(j=survivor_count-1; j>=0; j--){
5896
int run= i - survivor[j];
5897
int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5898
score += score_tab[i-run];
5899
if(score < last_score){
5902
last_level= level-64;
5908
distoration += esc_length*lambda;
5909
for(j=survivor_count-1; j>=0; j--){
5910
int run= i - survivor[j];
5911
int score= distoration + score_tab[i-run];
5913
if(score < best_score){
5916
level_tab[i+1]= level-64;
5920
if(s->out_format == FMT_H263){
5921
for(j=survivor_count-1; j>=0; j--){
5922
int run= i - survivor[j];
5923
int score= distoration + score_tab[i-run];
5924
if(score < last_score){
5927
last_level= level-64;
5935
score_tab[i+1]= best_score;
5937
//Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5938
if(last_non_zero <= 27){
5939
for(; survivor_count; survivor_count--){
5940
if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5944
for(; survivor_count; survivor_count--){
5945
if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5950
survivor[ survivor_count++ ]= i+1;
5953
if(s->out_format != FMT_H263){
5954
last_score= 256*256*256*120;
5955
for(i= survivor[0]; i<=last_non_zero + 1; i++){
5956
int score= score_tab[i];
5957
if(i) score += lambda*2; //FIXME exacter?
5959
if(score < last_score){
5962
last_level= level_tab[i];
5963
last_run= run_tab[i];
5968
s->coded_score[n] = last_score;
5971
last_non_zero= last_i - 1;
5972
memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5974
if(last_non_zero < start_i)
5975
return last_non_zero;
5977
if(last_non_zero == 0 && start_i == 0){
5979
int best_score= dc * dc;
5981
for(i=0; i<coeff_count[0]; i++){
5982
int level= coeff[i][0];
5983
int alevel= ABS(level);
5984
int unquant_coeff, score, distortion;
5986
if(s->out_format == FMT_H263){
5987
unquant_coeff= (alevel*qmul + qadd)>>3;
5989
unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5990
unquant_coeff = (unquant_coeff - 1) | 1;
5992
unquant_coeff = (unquant_coeff + 4) >> 3;
5993
unquant_coeff<<= 3 + 3;
5995
distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5997
if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
5998
else score= distortion + esc_length*lambda;
6000
if(score < best_score){
6002
best_level= level - 64;
6005
block[0]= best_level;
6006
s->coded_score[n] = best_score - dc*dc;
6007
if(best_level == 0) return -1;
6008
else return last_non_zero;
6014
block[ perm_scantable[last_non_zero] ]= last_level;
6017
for(; i>start_i; i -= run_tab[i] + 1){
6018
block[ perm_scantable[i-1] ]= level_tab[i];
6021
return last_non_zero;
6024
//#define REFINE_STATS 1
6025
static int16_t basis[64][64];
6027
static void build_basis(uint8_t *perm){
6034
double s= 0.25*(1<<BASIS_SHIFT);
6036
int perm_index= perm[index];
6037
if(i==0) s*= sqrt(0.5);
6038
if(j==0) s*= sqrt(0.5);
6039
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)));
6046
static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
6047
DCTELEM *block, int16_t *weight, DCTELEM *orig,
6050
DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6052
const uint8_t *scantable= s->intra_scantable.scantable;
6053
const uint8_t *perm_scantable= s->intra_scantable.permutated;
6054
// unsigned int threshold1, threshold2;
6059
int qmul, qadd, start_i, last_non_zero, i, dc;
6061
uint8_t * last_length;
6063
int rle_index, run, q, sum;
6066
static int after_last=0;
6067
static int to_zero=0;
6068
static int from_zero=0;
6071
static int messed_sign=0;
6074
if(basis[0][0] == 0)
6075
build_basis(s->dsp.idct_permutation);
6086
/* For AIC we skip quant/dequant of INTRADC */
6090
q <<= RECON_SHIFT-3;
6091
/* note: block[0] is assumed to be positive */
6093
// block[0] = (block[0] + (q >> 1)) / q;
6095
qmat = s->q_intra_matrix[qscale];
6096
// if(s->mpeg_quant || s->out_format == FMT_MPEG1)
6097
// bias= 1<<(QMAT_SHIFT-1);
6098
length = s->intra_ac_vlc_length;
6099
last_length= s->intra_ac_vlc_last_length;
6103
qmat = s->q_inter_matrix[qscale];
6104
length = s->inter_ac_vlc_length;
6105
last_length= s->inter_ac_vlc_last_length;
6107
last_non_zero = s->block_last_index[n];
6112
dc += (1<<(RECON_SHIFT-1));
6113
for(i=0; i<64; i++){
6114
rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6117
STOP_TIMER("memset rem[]")}
6120
for(i=0; i<64; i++){
6125
w= ABS(weight[i]) + qns*one;
6126
w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
6129
// w=weight[i] = (63*qns + (w/2)) / w;
6135
lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6141
for(i=start_i; i<=last_non_zero; i++){
6142
int j= perm_scantable[i];
6143
const int level= block[j];
6147
if(level<0) coeff= qmul*level - qadd;
6148
else coeff= qmul*level + qadd;
6149
run_tab[rle_index++]=run;
6152
s->dsp.add_8x8basis(rem, basis[j], coeff);
6158
if(last_non_zero>0){
6159
STOP_TIMER("init rem[]")
6166
int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6169
int run2, best_unquant_change=0, analyze_gradient;
6173
analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
6175
if(analyze_gradient){
6179
for(i=0; i<64; i++){
6182
d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6185
STOP_TIMER("rem*w*w")}
6195
const int level= block[0];
6196
int change, old_coeff;
6198
assert(s->mb_intra);
6202
for(change=-1; change<=1; change+=2){
6203
int new_level= level + change;
6204
int score, new_coeff;
6206
new_coeff= q*new_level;
6207
if(new_coeff >= 2048 || new_coeff < 0)
6210
score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6211
if(score<best_score){
6214
best_change= change;
6215
best_unquant_change= new_coeff - old_coeff;
6222
run2= run_tab[rle_index++];
6226
for(i=start_i; i<64; i++){
6227
int j= perm_scantable[i];
6228
const int level= block[j];
6229
int change, old_coeff;
6231
if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6235
if(level<0) old_coeff= qmul*level - qadd;
6236
else old_coeff= qmul*level + qadd;
6237
run2= run_tab[rle_index++]; //FIXME ! maybe after last
6241
assert(run2>=0 || i >= last_non_zero );
6244
for(change=-1; change<=1; change+=2){
6245
int new_level= level + change;
6246
int score, new_coeff, unquant_change;
6249
if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
6253
if(new_level<0) new_coeff= qmul*new_level - qadd;
6254
else new_coeff= qmul*new_level + qadd;
6255
if(new_coeff >= 2048 || new_coeff <= -2048)
6257
//FIXME check for overflow
6260
if(level < 63 && level > -63){
6261
if(i < last_non_zero)
6262
score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6263
- length[UNI_AC_ENC_INDEX(run, level+64)];
6265
score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6266
- last_length[UNI_AC_ENC_INDEX(run, level+64)];
6269
assert(ABS(new_level)==1);
6271
if(analyze_gradient){
6272
int g= d1[ scantable[i] ];
6273
if(g && (g^new_level) >= 0)
6277
if(i < last_non_zero){
6278
int next_i= i + run2 + 1;
6279
int next_level= block[ perm_scantable[next_i] ] + 64;
6281
if(next_level&(~127))
6284
if(next_i < last_non_zero)
6285
score += length[UNI_AC_ENC_INDEX(run, 65)]
6286
+ length[UNI_AC_ENC_INDEX(run2, next_level)]
6287
- length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6289
score += length[UNI_AC_ENC_INDEX(run, 65)]
6290
+ last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6291
- last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6293
score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6295
score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6296
- last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6302
assert(ABS(level)==1);
6304
if(i < last_non_zero){
6305
int next_i= i + run2 + 1;
6306
int next_level= block[ perm_scantable[next_i] ] + 64;
6308
if(next_level&(~127))
6311
if(next_i < last_non_zero)
6312
score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6313
- length[UNI_AC_ENC_INDEX(run2, next_level)]
6314
- length[UNI_AC_ENC_INDEX(run, 65)];
6316
score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6317
- last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6318
- length[UNI_AC_ENC_INDEX(run, 65)];
6320
score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6322
score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6323
- length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6330
unquant_change= new_coeff - old_coeff;
6331
assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6333
score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6334
if(score<best_score){
6337
best_change= change;
6338
best_unquant_change= unquant_change;
6342
prev_level= level + 64;
6343
if(prev_level&(~127))
6352
STOP_TIMER("iterative step")}
6356
int j= perm_scantable[ best_coeff ];
6358
block[j] += best_change;
6360
if(best_coeff > last_non_zero){
6361
last_non_zero= best_coeff;
6369
if(block[j] - best_change){
6370
if(ABS(block[j]) > ABS(block[j] - best_change)){
6382
for(; last_non_zero>=start_i; last_non_zero--){
6383
if(block[perm_scantable[last_non_zero]])
6389
if(256*256*256*64 % count == 0){
6390
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);
6395
for(i=start_i; i<=last_non_zero; i++){
6396
int j= perm_scantable[i];
6397
const int level= block[j];
6400
run_tab[rle_index++]=run;
6407
s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6413
if(last_non_zero>0){
6414
STOP_TIMER("iterative search")
6419
return last_non_zero;
6422
static int dct_quantize_c(MpegEncContext *s,
6423
DCTELEM *block, int n,
6424
int qscale, int *overflow)
6426
int i, j, level, last_non_zero, q, start_i;
6428
const uint8_t *scantable= s->intra_scantable.scantable;
6431
unsigned int threshold1, threshold2;
6433
s->dsp.fdct (block);
6435
if(s->dct_error_sum)
6436
s->denoise_dct(s, block);
6446
/* For AIC we skip quant/dequant of INTRADC */
6449
/* note: block[0] is assumed to be positive */
6450
block[0] = (block[0] + (q >> 1)) / q;
6453
qmat = s->q_intra_matrix[qscale];
6454
bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6458
qmat = s->q_inter_matrix[qscale];
6459
bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6461
threshold1= (1<<QMAT_SHIFT) - bias - 1;
6462
threshold2= (threshold1<<1);
6463
for(i=63;i>=start_i;i--) {
6465
level = block[j] * qmat[j];
6467
if(((unsigned)(level+threshold1))>threshold2){
6474
for(i=start_i; i<=last_non_zero; i++) {
6476
level = block[j] * qmat[j];
6478
// if( bias+level >= (1<<QMAT_SHIFT)
6479
// || bias-level >= (1<<QMAT_SHIFT)){
6480
if(((unsigned)(level+threshold1))>threshold2){
6482
level= (bias + level)>>QMAT_SHIFT;
6485
level= (bias - level)>>QMAT_SHIFT;
6493
*overflow= s->max_qcoeff < max; //overflow might have happened
6495
/* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6496
if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6497
ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6499
return last_non_zero;
6502
#endif //CONFIG_ENCODERS
6504
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6505
DCTELEM *block, int n, int qscale)
6507
int i, level, nCoeffs;
6508
const uint16_t *quant_matrix;
6510
nCoeffs= s->block_last_index[n];
6513
block[0] = block[0] * s->y_dc_scale;
6515
block[0] = block[0] * s->c_dc_scale;
6516
/* XXX: only mpeg1 */
6517
quant_matrix = s->intra_matrix;
6518
for(i=1;i<=nCoeffs;i++) {
6519
int j= s->intra_scantable.permutated[i];
6524
level = (int)(level * qscale * quant_matrix[j]) >> 3;
6525
level = (level - 1) | 1;
6528
level = (int)(level * qscale * quant_matrix[j]) >> 3;
6529
level = (level - 1) | 1;
6536
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6537
DCTELEM *block, int n, int qscale)
6539
int i, level, nCoeffs;
6540
const uint16_t *quant_matrix;
6542
nCoeffs= s->block_last_index[n];
6544
quant_matrix = s->inter_matrix;
6545
for(i=0; i<=nCoeffs; i++) {
6546
int j= s->intra_scantable.permutated[i];
6551
level = (((level << 1) + 1) * qscale *
6552
((int) (quant_matrix[j]))) >> 4;
6553
level = (level - 1) | 1;
6556
level = (((level << 1) + 1) * qscale *
6557
((int) (quant_matrix[j]))) >> 4;
6558
level = (level - 1) | 1;
6565
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6566
DCTELEM *block, int n, int qscale)
6568
int i, level, nCoeffs;
6569
const uint16_t *quant_matrix;
6571
if(s->alternate_scan) nCoeffs= 63;
6572
else nCoeffs= s->block_last_index[n];
6575
block[0] = block[0] * s->y_dc_scale;
6577
block[0] = block[0] * s->c_dc_scale;
6578
quant_matrix = s->intra_matrix;
6579
for(i=1;i<=nCoeffs;i++) {
6580
int j= s->intra_scantable.permutated[i];
6585
level = (int)(level * qscale * quant_matrix[j]) >> 3;
6588
level = (int)(level * qscale * quant_matrix[j]) >> 3;
6595
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
6596
DCTELEM *block, int n, int qscale)
6598
int i, level, nCoeffs;
6599
const uint16_t *quant_matrix;
6602
if(s->alternate_scan) nCoeffs= 63;
6603
else nCoeffs= s->block_last_index[n];
6606
block[0] = block[0] * s->y_dc_scale;
6608
block[0] = block[0] * s->c_dc_scale;
6609
quant_matrix = s->intra_matrix;
6610
for(i=1;i<=nCoeffs;i++) {
6611
int j= s->intra_scantable.permutated[i];
6616
level = (int)(level * qscale * quant_matrix[j]) >> 3;
6619
level = (int)(level * qscale * quant_matrix[j]) >> 3;
6628
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6629
DCTELEM *block, int n, int qscale)
6631
int i, level, nCoeffs;
6632
const uint16_t *quant_matrix;
6635
if(s->alternate_scan) nCoeffs= 63;
6636
else nCoeffs= s->block_last_index[n];
6638
quant_matrix = s->inter_matrix;
6639
for(i=0; i<=nCoeffs; i++) {
6640
int j= s->intra_scantable.permutated[i];
6645
level = (((level << 1) + 1) * qscale *
6646
((int) (quant_matrix[j]))) >> 4;
6649
level = (((level << 1) + 1) * qscale *
6650
((int) (quant_matrix[j]))) >> 4;
6659
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6660
DCTELEM *block, int n, int qscale)
6662
int i, level, qmul, qadd;
6665
assert(s->block_last_index[n]>=0);
6671
block[0] = block[0] * s->y_dc_scale;
6673
block[0] = block[0] * s->c_dc_scale;
6674
qadd = (qscale - 1) | 1;
6681
nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6683
for(i=1; i<=nCoeffs; i++) {
6687
level = level * qmul - qadd;
6689
level = level * qmul + qadd;
6696
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6697
DCTELEM *block, int n, int qscale)
6699
int i, level, qmul, qadd;
6702
assert(s->block_last_index[n]>=0);
6704
qadd = (qscale - 1) | 1;
6707
nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6709
for(i=0; i<=nCoeffs; i++) {
6713
level = level * qmul - qadd;
6715
level = level * qmul + qadd;
6722
#ifdef CONFIG_ENCODERS
6723
AVCodec h263_encoder = {
6727
sizeof(MpegEncContext),
6731
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6734
AVCodec h263p_encoder = {
6738
sizeof(MpegEncContext),
6742
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6745
AVCodec flv_encoder = {
6749
sizeof(MpegEncContext),
6753
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6756
AVCodec rv10_encoder = {
6760
sizeof(MpegEncContext),
6764
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6767
AVCodec rv20_encoder = {
6771
sizeof(MpegEncContext),
6775
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6778
AVCodec mpeg4_encoder = {
6782
sizeof(MpegEncContext),
6786
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6787
.capabilities= CODEC_CAP_DELAY,
6790
AVCodec msmpeg4v1_encoder = {
6794
sizeof(MpegEncContext),
6798
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6801
AVCodec msmpeg4v2_encoder = {
6805
sizeof(MpegEncContext),
6809
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6812
AVCodec msmpeg4v3_encoder = {
6816
sizeof(MpegEncContext),
6820
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6823
AVCodec wmv1_encoder = {
6827
sizeof(MpegEncContext),
6831
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6834
AVCodec mjpeg_encoder = {
6838
sizeof(MpegEncContext),
6842
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, -1},
6845
#endif //CONFIG_ENCODERS
added
removed
extern/ffmpeg/libavcodec/mpegvideo.c
