id
int32 0
27.3k
| func
stringlengths 26
142k
| target
bool 2
classes | project
stringclasses 2
values | commit_id
stringlengths 40
40
| func_clean
stringlengths 26
131k
| vul_lines
dict | normalized_func
stringlengths 24
132k
| lines
listlengths 1
2.8k
| label
listlengths 1
2.8k
| line_no
listlengths 1
2.8k
|
|---|---|---|---|---|---|---|---|---|---|---|
6,958 |
static void dec_modu(DisasContext *dc)
{
int l1;
LOG_DIS("modu r%d, r%d, %d\n", dc->r2, dc->r0, dc->r1);
if (!(dc->env->features & LM32_FEATURE_DIVIDE)) {
cpu_abort(dc->env, "hardware divider is not available\n");
}
l1 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_R[dc->r1], 0, l1);
tcg_gen_movi_tl(cpu_pc, dc->pc);
t_gen_raise_exception(dc, EXCP_DIVIDE_BY_ZERO);
gen_set_label(l1);
tcg_gen_remu_tl(cpu_R[dc->r2], cpu_R[dc->r0], cpu_R[dc->r1]);
}
| true |
qemu
|
3604a76fea6ff37738d4a8f596be38407be74a83
|
static void dec_modu(DisasContext *dc)
{
int l1;
LOG_DIS("modu r%d, r%d, %d\n", dc->r2, dc->r0, dc->r1);
if (!(dc->env->features & LM32_FEATURE_DIVIDE)) {
cpu_abort(dc->env, "hardware divider is not available\n");
}
l1 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_R[dc->r1], 0, l1);
tcg_gen_movi_tl(cpu_pc, dc->pc);
t_gen_raise_exception(dc, EXCP_DIVIDE_BY_ZERO);
gen_set_label(l1);
tcg_gen_remu_tl(cpu_R[dc->r2], cpu_R[dc->r0], cpu_R[dc->r1]);
}
|
{
"code": [
" cpu_abort(dc->env, \"hardware divider is not available\\n\");",
" cpu_abort(dc->env, \"hardware divider is not available\\n\");"
],
"line_no": [
15,
15
]
}
|
static void FUNC_0(DisasContext *VAR_0)
{
int VAR_1;
LOG_DIS("modu r%d, r%d, %d\n", VAR_0->r2, VAR_0->r0, VAR_0->r1);
if (!(VAR_0->env->features & LM32_FEATURE_DIVIDE)) {
cpu_abort(VAR_0->env, "hardware divider is not available\n");
}
VAR_1 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_R[VAR_0->r1], 0, VAR_1);
tcg_gen_movi_tl(cpu_pc, VAR_0->pc);
t_gen_raise_exception(VAR_0, EXCP_DIVIDE_BY_ZERO);
gen_set_label(VAR_1);
tcg_gen_remu_tl(cpu_R[VAR_0->r2], cpu_R[VAR_0->r0], cpu_R[VAR_0->r1]);
}
|
[
"static void FUNC_0(DisasContext *VAR_0)\n{",
"int VAR_1;",
"LOG_DIS(\"modu r%d, r%d, %d\\n\", VAR_0->r2, VAR_0->r0, VAR_0->r1);",
"if (!(VAR_0->env->features & LM32_FEATURE_DIVIDE)) {",
"cpu_abort(VAR_0->env, \"hardware divider is not available\\n\");",
"}",
"VAR_1 = gen_new_label();",
"tcg_gen_brcondi_tl(TCG_COND_NE, cpu_R[VAR_0->r1], 0, VAR_1);",
"tcg_gen_movi_tl(cpu_pc, VAR_0->pc);",
"t_gen_raise_exception(VAR_0, EXCP_DIVIDE_BY_ZERO);",
"gen_set_label(VAR_1);",
"tcg_gen_remu_tl(cpu_R[VAR_0->r2], cpu_R[VAR_0->r0], cpu_R[VAR_0->r1]);",
"}"
] |
[
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
6,959 |
static void rv40_loop_filter(RV34DecContext *r, int row)
{
MpegEncContext *s = &r->s;
int mb_pos, mb_x;
int i, j, k;
uint8_t *Y, *C;
int alpha, beta, betaY, betaC;
int q;
int mbtype[4]; ///< current macroblock and its neighbours types
/**
* flags indicating that macroblock can be filtered with strong filter
* it is set only for intra coded MB and MB with DCs coded separately
*/
int mb_strong[4];
int clip[4]; ///< MB filter clipping value calculated from filtering strength
/**
* coded block patterns for luma part of current macroblock and its neighbours
* Format:
* LSB corresponds to the top left block,
* each nibble represents one row of subblocks.
*/
int cbp[4];
/**
* coded block patterns for chroma part of current macroblock and its neighbours
* Format is the same as for luma with two subblocks in a row.
*/
int uvcbp[4][2];
/**
* This mask represents the pattern of luma subblocks that should be filtered
* in addition to the coded ones because because they lie at the edge of
* 8x8 block with different enough motion vectors
*/
unsigned mvmasks[4];
mb_pos = row * s->mb_stride;
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
int mbtype = s->current_picture_ptr->mb_type[mb_pos];
if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))
r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;
if(IS_INTRA(mbtype))
r->cbp_chroma[mb_pos] = 0xFF;
}
mb_pos = row * s->mb_stride;
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
int y_h_deblock, y_v_deblock;
int c_v_deblock[2], c_h_deblock[2];
int clip_left;
int avail[4];
unsigned y_to_deblock;
int c_to_deblock[2];
q = s->current_picture_ptr->qscale_table[mb_pos];
alpha = rv40_alpha_tab[q];
beta = rv40_beta_tab [q];
betaY = betaC = beta * 3;
if(s->width * s->height <= 176*144)
betaY += beta;
avail[0] = 1;
avail[1] = row;
avail[2] = mb_x;
avail[3] = row < s->mb_height - 1;
for(i = 0; i < 4; i++){
if(avail[i]){
int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;
mvmasks[i] = r->deblock_coefs[pos];
mbtype [i] = s->current_picture_ptr->mb_type[pos];
cbp [i] = r->cbp_luma[pos];
uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;
uvcbp[i][1] = r->cbp_chroma[pos] >> 4;
}else{
mvmasks[i] = 0;
mbtype [i] = mbtype[0];
cbp [i] = 0;
uvcbp[i][0] = uvcbp[i][1] = 0;
}
mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]);
clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q];
}
y_to_deblock = mvmasks[POS_CUR]
| (mvmasks[POS_BOTTOM] << 16);
/* This pattern contains bits signalling that horizontal edges of
* the current block can be filtered.
* That happens when either of adjacent subblocks is coded or lies on
* the edge of 8x8 blocks with motion vectors differing by more than
* 3/4 pel in any component (any edge orientation for some reason).
*/
y_h_deblock = y_to_deblock
| ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)
| ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12);
/* This pattern contains bits signalling that vertical edges of
* the current block can be filtered.
* That happens when either of adjacent subblocks is coded or lies on
* the edge of 8x8 blocks with motion vectors differing by more than
* 3/4 pel in any component (any edge orientation for some reason).
*/
y_v_deblock = y_to_deblock
| ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)
| ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);
if(!mb_x)
y_v_deblock &= ~MASK_Y_LEFT_COL;
if(!row)
y_h_deblock &= ~MASK_Y_TOP_ROW;
if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
/* Calculating chroma patterns is similar and easier since there is
* no motion vector pattern for them.
*/
for(i = 0; i < 2; i++){
c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i];
c_v_deblock[i] = c_to_deblock[i]
| ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL)
| ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1);
c_h_deblock[i] = c_to_deblock[i]
| ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2)
| (uvcbp[POS_CUR][i] << 2);
if(!mb_x)
c_v_deblock[i] &= ~MASK_C_LEFT_COL;
if(!row)
c_h_deblock[i] &= ~MASK_C_TOP_ROW;
if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);
}
for(j = 0; j < 16; j += 4){
Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize;
for(i = 0; i < 4; i++, Y += 4){
int ij = i + j;
int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
int dither = j ? ij : i*4;
// if bottom block is coded then we can filter its top edge
// (or bottom edge of this block, which is the same)
if(y_h_deblock & (MASK_BOTTOM << ij)){
rv40_adaptive_loop_filter(&r->rdsp, Y+4*s->linesize,
s->linesize, dither,
y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0,
clip_cur, alpha, beta, betaY,
0, 0, 0);
}
// filter left block edge in ordinary mode (with low filtering strength)
if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
if(!i)
clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
else
clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur,
clip_left,
alpha, beta, betaY, 0, 0, 1);
}
// filter top edge of the current macroblock when filtering strength is high
if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur,
mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,
alpha, beta, betaY, 0, 1, 0);
}
// filter left block edge in edge mode (with high filtering strength)
if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur,
clip_left,
alpha, beta, betaY, 0, 1, 1);
}
}
}
for(k = 0; k < 2; k++){
for(j = 0; j < 2; j++){
C = s->current_picture_ptr->f.data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;
for(i = 0; i < 2; i++, C += 4){
int ij = i + j*2;
int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
if(c_h_deblock[k] & (MASK_CUR << (ij+2))){
int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C+4*s->uvlinesize, s->uvlinesize, i*8,
clip_bot,
clip_cur,
alpha, beta, betaC, 1, 0, 0);
}
if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
if(!i)
clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
else
clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
clip_cur,
clip_left,
alpha, beta, betaC, 1, 0, 1);
}
if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,
clip_cur,
clip_top,
alpha, beta, betaC, 1, 1, 0);
}
if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
clip_cur,
clip_left,
alpha, beta, betaC, 1, 1, 1);
}
}
}
}
}
}
| true |
FFmpeg
|
f6774f905fb3cfdc319523ac640be30b14c1bc55
|
static void rv40_loop_filter(RV34DecContext *r, int row)
{
MpegEncContext *s = &r->s;
int mb_pos, mb_x;
int i, j, k;
uint8_t *Y, *C;
int alpha, beta, betaY, betaC;
int q;
int mbtype[4];
int mb_strong[4];
int clip[4];
int cbp[4];
int uvcbp[4][2];
unsigned mvmasks[4];
mb_pos = row * s->mb_stride;
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
int mbtype = s->current_picture_ptr->mb_type[mb_pos];
if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype))
r->cbp_luma [mb_pos] = r->deblock_coefs[mb_pos] = 0xFFFF;
if(IS_INTRA(mbtype))
r->cbp_chroma[mb_pos] = 0xFF;
}
mb_pos = row * s->mb_stride;
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){
int y_h_deblock, y_v_deblock;
int c_v_deblock[2], c_h_deblock[2];
int clip_left;
int avail[4];
unsigned y_to_deblock;
int c_to_deblock[2];
q = s->current_picture_ptr->qscale_table[mb_pos];
alpha = rv40_alpha_tab[q];
beta = rv40_beta_tab [q];
betaY = betaC = beta * 3;
if(s->width * s->height <= 176*144)
betaY += beta;
avail[0] = 1;
avail[1] = row;
avail[2] = mb_x;
avail[3] = row < s->mb_height - 1;
for(i = 0; i < 4; i++){
if(avail[i]){
int pos = mb_pos + neighbour_offs_x[i] + neighbour_offs_y[i]*s->mb_stride;
mvmasks[i] = r->deblock_coefs[pos];
mbtype [i] = s->current_picture_ptr->mb_type[pos];
cbp [i] = r->cbp_luma[pos];
uvcbp[i][0] = r->cbp_chroma[pos] & 0xF;
uvcbp[i][1] = r->cbp_chroma[pos] >> 4;
}else{
mvmasks[i] = 0;
mbtype [i] = mbtype[0];
cbp [i] = 0;
uvcbp[i][0] = uvcbp[i][1] = 0;
}
mb_strong[i] = IS_INTRA(mbtype[i]) || IS_SEPARATE_DC(mbtype[i]);
clip[i] = rv40_filter_clip_tbl[mb_strong[i] + 1][q];
}
y_to_deblock = mvmasks[POS_CUR]
| (mvmasks[POS_BOTTOM] << 16);
y_h_deblock = y_to_deblock
| ((cbp[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)
| ((cbp[POS_TOP] & MASK_Y_LAST_ROW) >> 12);
y_v_deblock = y_to_deblock
| ((cbp[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)
| ((cbp[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);
if(!mb_x)
y_v_deblock &= ~MASK_Y_LEFT_COL;
if(!row)
y_h_deblock &= ~MASK_Y_TOP_ROW;
if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
for(i = 0; i < 2; i++){
c_to_deblock[i] = (uvcbp[POS_BOTTOM][i] << 4) | uvcbp[POS_CUR][i];
c_v_deblock[i] = c_to_deblock[i]
| ((uvcbp[POS_CUR] [i] << 1) & ~MASK_C_LEFT_COL)
| ((uvcbp[POS_LEFT][i] & MASK_C_RIGHT_COL) >> 1);
c_h_deblock[i] = c_to_deblock[i]
| ((uvcbp[POS_TOP][i] & MASK_C_LAST_ROW) >> 2)
| (uvcbp[POS_CUR][i] << 2);
if(!mb_x)
c_v_deblock[i] &= ~MASK_C_LEFT_COL;
if(!row)
c_h_deblock[i] &= ~MASK_C_TOP_ROW;
if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);
}
for(j = 0; j < 16; j += 4){
Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize;
for(i = 0; i < 4; i++, Y += 4){
int ij = i + j;
int clip_cur = y_to_deblock & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
int dither = j ? ij : i*4;
if(y_h_deblock & (MASK_BOTTOM << ij)){
rv40_adaptive_loop_filter(&r->rdsp, Y+4*s->linesize,
s->linesize, dither,
y_to_deblock & (MASK_BOTTOM << ij) ? clip[POS_CUR] : 0,
clip_cur, alpha, beta, betaY,
0, 0, 0);
}
if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
if(!i)
clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
else
clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur,
clip_left,
alpha, beta, betaY, 0, 0, 1);
}
if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur,
mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,
alpha, beta, betaY, 0, 1, 0);
}
if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur,
clip_left,
alpha, beta, betaY, 0, 1, 1);
}
}
}
for(k = 0; k < 2; k++){
for(j = 0; j < 2; j++){
C = s->current_picture_ptr->f.data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;
for(i = 0; i < 2; i++, C += 4){
int ij = i + j*2;
int clip_cur = c_to_deblock[k] & (MASK_CUR << ij) ? clip[POS_CUR] : 0;
if(c_h_deblock[k] & (MASK_CUR << (ij+2))){
int clip_bot = c_to_deblock[k] & (MASK_CUR << (ij+2)) ? clip[POS_CUR] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C+4*s->uvlinesize, s->uvlinesize, i*8,
clip_bot,
clip_cur,
alpha, beta, betaC, 1, 0, 0);
}
if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
if(!i)
clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
else
clip_left = c_to_deblock[k] & (MASK_CUR << (ij-1)) ? clip[POS_CUR] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
clip_cur,
clip_left,
alpha, beta, betaC, 1, 0, 1);
}
if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,
clip_cur,
clip_top,
alpha, beta, betaC, 1, 1, 0);
}
if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
clip_cur,
clip_left,
alpha, beta, betaC, 1, 1, 1);
}
}
}
}
}
}
|
{
"code": [
" Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize;",
" Y = s->current_picture_ptr->f.data[0] + mb_x*16 + (row*16 + j) * s->linesize;",
" C = s->current_picture_ptr->f.data[k + 1] + mb_x*8 + (row*8 + j*4) * s->uvlinesize;"
],
"line_no": [
251,
251,
341
]
}
|
static void FUNC_0(RV34DecContext *VAR_0, int VAR_1)
{
MpegEncContext *s = &VAR_0->s;
int VAR_2, VAR_3;
int VAR_4, VAR_5, VAR_6;
uint8_t *Y, *C;
int VAR_7, VAR_8, VAR_9, VAR_10;
int VAR_11;
int VAR_12[4];
int VAR_13[4];
int VAR_14[4];
int VAR_15[4];
int VAR_16[4][2];
unsigned VAR_17[4];
VAR_2 = VAR_1 * s->mb_stride;
for(VAR_3 = 0; VAR_3 < s->mb_width; VAR_3++, VAR_2++){
int VAR_12 = s->current_picture_ptr->mb_type[VAR_2];
if(IS_INTRA(VAR_12) || IS_SEPARATE_DC(VAR_12))
VAR_0->cbp_luma [VAR_2] = VAR_0->deblock_coefs[VAR_2] = 0xFFFF;
if(IS_INTRA(VAR_12))
VAR_0->cbp_chroma[VAR_2] = 0xFF;
}
VAR_2 = VAR_1 * s->mb_stride;
for(VAR_3 = 0; VAR_3 < s->mb_width; VAR_3++, VAR_2++){
int y_h_deblock, y_v_deblock;
int c_v_deblock[2], c_h_deblock[2];
int clip_left;
int avail[4];
unsigned y_to_deblock;
int c_to_deblock[2];
VAR_11 = s->current_picture_ptr->qscale_table[VAR_2];
VAR_7 = rv40_alpha_tab[VAR_11];
VAR_8 = rv40_beta_tab [VAR_11];
VAR_9 = VAR_10 = VAR_8 * 3;
if(s->width * s->height <= 176*144)
VAR_9 += VAR_8;
avail[0] = 1;
avail[1] = VAR_1;
avail[2] = VAR_3;
avail[3] = VAR_1 < s->mb_height - 1;
for(VAR_4 = 0; VAR_4 < 4; VAR_4++){
if(avail[VAR_4]){
int pos = VAR_2 + neighbour_offs_x[VAR_4] + neighbour_offs_y[VAR_4]*s->mb_stride;
VAR_17[VAR_4] = VAR_0->deblock_coefs[pos];
VAR_12 [VAR_4] = s->current_picture_ptr->mb_type[pos];
VAR_15 [VAR_4] = VAR_0->cbp_luma[pos];
VAR_16[VAR_4][0] = VAR_0->cbp_chroma[pos] & 0xF;
VAR_16[VAR_4][1] = VAR_0->cbp_chroma[pos] >> 4;
}else{
VAR_17[VAR_4] = 0;
VAR_12 [VAR_4] = VAR_12[0];
VAR_15 [VAR_4] = 0;
VAR_16[VAR_4][0] = VAR_16[VAR_4][1] = 0;
}
VAR_13[VAR_4] = IS_INTRA(VAR_12[VAR_4]) || IS_SEPARATE_DC(VAR_12[VAR_4]);
VAR_14[VAR_4] = rv40_filter_clip_tbl[VAR_13[VAR_4] + 1][VAR_11];
}
y_to_deblock = VAR_17[POS_CUR]
| (VAR_17[POS_BOTTOM] << 16);
y_h_deblock = y_to_deblock
| ((VAR_15[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)
| ((VAR_15[POS_TOP] & MASK_Y_LAST_ROW) >> 12);
y_v_deblock = y_to_deblock
| ((VAR_15[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)
| ((VAR_15[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);
if(!VAR_3)
y_v_deblock &= ~MASK_Y_LEFT_COL;
if(!VAR_1)
y_h_deblock &= ~MASK_Y_TOP_ROW;
if(VAR_1 == s->mb_height - 1 || (VAR_13[POS_CUR] | VAR_13[POS_BOTTOM]))
y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
for(VAR_4 = 0; VAR_4 < 2; VAR_4++){
c_to_deblock[VAR_4] = (VAR_16[POS_BOTTOM][VAR_4] << 4) | VAR_16[POS_CUR][VAR_4];
c_v_deblock[VAR_4] = c_to_deblock[VAR_4]
| ((VAR_16[POS_CUR] [VAR_4] << 1) & ~MASK_C_LEFT_COL)
| ((VAR_16[POS_LEFT][VAR_4] & MASK_C_RIGHT_COL) >> 1);
c_h_deblock[VAR_4] = c_to_deblock[VAR_4]
| ((VAR_16[POS_TOP][VAR_4] & MASK_C_LAST_ROW) >> 2)
| (VAR_16[POS_CUR][VAR_4] << 2);
if(!VAR_3)
c_v_deblock[VAR_4] &= ~MASK_C_LEFT_COL;
if(!VAR_1)
c_h_deblock[VAR_4] &= ~MASK_C_TOP_ROW;
if(VAR_1 == s->mb_height - 1 || (VAR_13[POS_CUR] | VAR_13[POS_BOTTOM]))
c_h_deblock[VAR_4] &= ~(MASK_C_TOP_ROW << 4);
}
for(VAR_5 = 0; VAR_5 < 16; VAR_5 += 4){
Y = s->current_picture_ptr->f.data[0] + VAR_3*16 + (VAR_1*16 + VAR_5) * s->linesize;
for(VAR_4 = 0; VAR_4 < 4; VAR_4++, Y += 4){
int ij = VAR_4 + VAR_5;
int clip_cur = y_to_deblock & (MASK_CUR << ij) ? VAR_14[POS_CUR] : 0;
int dither = VAR_5 ? ij : VAR_4*4;
if(y_h_deblock & (MASK_BOTTOM << ij)){
rv40_adaptive_loop_filter(&VAR_0->rdsp, Y+4*s->linesize,
s->linesize, dither,
y_to_deblock & (MASK_BOTTOM << ij) ? VAR_14[POS_CUR] : 0,
clip_cur, VAR_7, VAR_8, VAR_9,
0, 0, 0);
}
if(y_v_deblock & (MASK_CUR << ij) && (VAR_4 || !(VAR_13[POS_CUR] | VAR_13[POS_LEFT]))){
if(!VAR_4)
clip_left = VAR_17[POS_LEFT] & (MASK_RIGHT << VAR_5) ? VAR_14[POS_LEFT] : 0;
else
clip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? VAR_14[POS_CUR] : 0;
rv40_adaptive_loop_filter(&VAR_0->rdsp, Y, s->linesize, dither,
clip_cur,
clip_left,
VAR_7, VAR_8, VAR_9, 0, 0, 1);
}
if(!VAR_5 && y_h_deblock & (MASK_CUR << VAR_4) && (VAR_13[POS_CUR] | VAR_13[POS_TOP])){
rv40_adaptive_loop_filter(&VAR_0->rdsp, Y, s->linesize, dither,
clip_cur,
VAR_17[POS_TOP] & (MASK_TOP << VAR_4) ? VAR_14[POS_TOP] : 0,
VAR_7, VAR_8, VAR_9, 0, 1, 0);
}
if(y_v_deblock & (MASK_CUR << ij) && !VAR_4 && (VAR_13[POS_CUR] | VAR_13[POS_LEFT])){
clip_left = VAR_17[POS_LEFT] & (MASK_RIGHT << VAR_5) ? VAR_14[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&VAR_0->rdsp, Y, s->linesize, dither,
clip_cur,
clip_left,
VAR_7, VAR_8, VAR_9, 0, 1, 1);
}
}
}
for(VAR_6 = 0; VAR_6 < 2; VAR_6++){
for(VAR_5 = 0; VAR_5 < 2; VAR_5++){
C = s->current_picture_ptr->f.data[VAR_6 + 1] + VAR_3*8 + (VAR_1*8 + VAR_5*4) * s->uvlinesize;
for(VAR_4 = 0; VAR_4 < 2; VAR_4++, C += 4){
int ij = VAR_4 + VAR_5*2;
int clip_cur = c_to_deblock[VAR_6] & (MASK_CUR << ij) ? VAR_14[POS_CUR] : 0;
if(c_h_deblock[VAR_6] & (MASK_CUR << (ij+2))){
int clip_bot = c_to_deblock[VAR_6] & (MASK_CUR << (ij+2)) ? VAR_14[POS_CUR] : 0;
rv40_adaptive_loop_filter(&VAR_0->rdsp, C+4*s->uvlinesize, s->uvlinesize, VAR_4*8,
clip_bot,
clip_cur,
VAR_7, VAR_8, VAR_10, 1, 0, 0);
}
if((c_v_deblock[VAR_6] & (MASK_CUR << ij)) && (VAR_4 || !(VAR_13[POS_CUR] | VAR_13[POS_LEFT]))){
if(!VAR_4)
clip_left = VAR_16[POS_LEFT][VAR_6] & (MASK_CUR << (2*VAR_5+1)) ? VAR_14[POS_LEFT] : 0;
else
clip_left = c_to_deblock[VAR_6] & (MASK_CUR << (ij-1)) ? VAR_14[POS_CUR] : 0;
rv40_adaptive_loop_filter(&VAR_0->rdsp, C, s->uvlinesize, VAR_5*8,
clip_cur,
clip_left,
VAR_7, VAR_8, VAR_10, 1, 0, 1);
}
if(!VAR_5 && c_h_deblock[VAR_6] & (MASK_CUR << ij) && (VAR_13[POS_CUR] | VAR_13[POS_TOP])){
int clip_top = VAR_16[POS_TOP][VAR_6] & (MASK_CUR << (ij+2)) ? VAR_14[POS_TOP] : 0;
rv40_adaptive_loop_filter(&VAR_0->rdsp, C, s->uvlinesize, VAR_4*8,
clip_cur,
clip_top,
VAR_7, VAR_8, VAR_10, 1, 1, 0);
}
if(c_v_deblock[VAR_6] & (MASK_CUR << ij) && !VAR_4 && (VAR_13[POS_CUR] | VAR_13[POS_LEFT])){
clip_left = VAR_16[POS_LEFT][VAR_6] & (MASK_CUR << (2*VAR_5+1)) ? VAR_14[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&VAR_0->rdsp, C, s->uvlinesize, VAR_5*8,
clip_cur,
clip_left,
VAR_7, VAR_8, VAR_10, 1, 1, 1);
}
}
}
}
}
}
|
[
"static void FUNC_0(RV34DecContext *VAR_0, int VAR_1)\n{",
"MpegEncContext *s = &VAR_0->s;",
"int VAR_2, VAR_3;",
"int VAR_4, VAR_5, VAR_6;",
"uint8_t *Y, *C;",
"int VAR_7, VAR_8, VAR_9, VAR_10;",
"int VAR_11;",
"int VAR_12[4];",
"int VAR_13[4];",
"int VAR_14[4];",
"int VAR_15[4];",
"int VAR_16[4][2];",
"unsigned VAR_17[4];",
"VAR_2 = VAR_1 * s->mb_stride;",
"for(VAR_3 = 0; VAR_3 < s->mb_width; VAR_3++, VAR_2++){",
"int VAR_12 = s->current_picture_ptr->mb_type[VAR_2];",
"if(IS_INTRA(VAR_12) || IS_SEPARATE_DC(VAR_12))\nVAR_0->cbp_luma [VAR_2] = VAR_0->deblock_coefs[VAR_2] = 0xFFFF;",
"if(IS_INTRA(VAR_12))\nVAR_0->cbp_chroma[VAR_2] = 0xFF;",
"}",
"VAR_2 = VAR_1 * s->mb_stride;",
"for(VAR_3 = 0; VAR_3 < s->mb_width; VAR_3++, VAR_2++){",
"int y_h_deblock, y_v_deblock;",
"int c_v_deblock[2], c_h_deblock[2];",
"int clip_left;",
"int avail[4];",
"unsigned y_to_deblock;",
"int c_to_deblock[2];",
"VAR_11 = s->current_picture_ptr->qscale_table[VAR_2];",
"VAR_7 = rv40_alpha_tab[VAR_11];",
"VAR_8 = rv40_beta_tab [VAR_11];",
"VAR_9 = VAR_10 = VAR_8 * 3;",
"if(s->width * s->height <= 176*144)\nVAR_9 += VAR_8;",
"avail[0] = 1;",
"avail[1] = VAR_1;",
"avail[2] = VAR_3;",
"avail[3] = VAR_1 < s->mb_height - 1;",
"for(VAR_4 = 0; VAR_4 < 4; VAR_4++){",
"if(avail[VAR_4]){",
"int pos = VAR_2 + neighbour_offs_x[VAR_4] + neighbour_offs_y[VAR_4]*s->mb_stride;",
"VAR_17[VAR_4] = VAR_0->deblock_coefs[pos];",
"VAR_12 [VAR_4] = s->current_picture_ptr->mb_type[pos];",
"VAR_15 [VAR_4] = VAR_0->cbp_luma[pos];",
"VAR_16[VAR_4][0] = VAR_0->cbp_chroma[pos] & 0xF;",
"VAR_16[VAR_4][1] = VAR_0->cbp_chroma[pos] >> 4;",
"}else{",
"VAR_17[VAR_4] = 0;",
"VAR_12 [VAR_4] = VAR_12[0];",
"VAR_15 [VAR_4] = 0;",
"VAR_16[VAR_4][0] = VAR_16[VAR_4][1] = 0;",
"}",
"VAR_13[VAR_4] = IS_INTRA(VAR_12[VAR_4]) || IS_SEPARATE_DC(VAR_12[VAR_4]);",
"VAR_14[VAR_4] = rv40_filter_clip_tbl[VAR_13[VAR_4] + 1][VAR_11];",
"}",
"y_to_deblock = VAR_17[POS_CUR]\n| (VAR_17[POS_BOTTOM] << 16);",
"y_h_deblock = y_to_deblock\n| ((VAR_15[POS_CUR] << 4) & ~MASK_Y_TOP_ROW)\n| ((VAR_15[POS_TOP] & MASK_Y_LAST_ROW) >> 12);",
"y_v_deblock = y_to_deblock\n| ((VAR_15[POS_CUR] << 1) & ~MASK_Y_LEFT_COL)\n| ((VAR_15[POS_LEFT] & MASK_Y_RIGHT_COL) >> 3);",
"if(!VAR_3)\ny_v_deblock &= ~MASK_Y_LEFT_COL;",
"if(!VAR_1)\ny_h_deblock &= ~MASK_Y_TOP_ROW;",
"if(VAR_1 == s->mb_height - 1 || (VAR_13[POS_CUR] | VAR_13[POS_BOTTOM]))\ny_h_deblock &= ~(MASK_Y_TOP_ROW << 16);",
"for(VAR_4 = 0; VAR_4 < 2; VAR_4++){",
"c_to_deblock[VAR_4] = (VAR_16[POS_BOTTOM][VAR_4] << 4) | VAR_16[POS_CUR][VAR_4];",
"c_v_deblock[VAR_4] = c_to_deblock[VAR_4]\n| ((VAR_16[POS_CUR] [VAR_4] << 1) & ~MASK_C_LEFT_COL)\n| ((VAR_16[POS_LEFT][VAR_4] & MASK_C_RIGHT_COL) >> 1);",
"c_h_deblock[VAR_4] = c_to_deblock[VAR_4]\n| ((VAR_16[POS_TOP][VAR_4] & MASK_C_LAST_ROW) >> 2)\n| (VAR_16[POS_CUR][VAR_4] << 2);",
"if(!VAR_3)\nc_v_deblock[VAR_4] &= ~MASK_C_LEFT_COL;",
"if(!VAR_1)\nc_h_deblock[VAR_4] &= ~MASK_C_TOP_ROW;",
"if(VAR_1 == s->mb_height - 1 || (VAR_13[POS_CUR] | VAR_13[POS_BOTTOM]))\nc_h_deblock[VAR_4] &= ~(MASK_C_TOP_ROW << 4);",
"}",
"for(VAR_5 = 0; VAR_5 < 16; VAR_5 += 4){",
"Y = s->current_picture_ptr->f.data[0] + VAR_3*16 + (VAR_1*16 + VAR_5) * s->linesize;",
"for(VAR_4 = 0; VAR_4 < 4; VAR_4++, Y += 4){",
"int ij = VAR_4 + VAR_5;",
"int clip_cur = y_to_deblock & (MASK_CUR << ij) ? VAR_14[POS_CUR] : 0;",
"int dither = VAR_5 ? ij : VAR_4*4;",
"if(y_h_deblock & (MASK_BOTTOM << ij)){",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, Y+4*s->linesize,\ns->linesize, dither,\ny_to_deblock & (MASK_BOTTOM << ij) ? VAR_14[POS_CUR] : 0,\nclip_cur, VAR_7, VAR_8, VAR_9,\n0, 0, 0);",
"}",
"if(y_v_deblock & (MASK_CUR << ij) && (VAR_4 || !(VAR_13[POS_CUR] | VAR_13[POS_LEFT]))){",
"if(!VAR_4)\nclip_left = VAR_17[POS_LEFT] & (MASK_RIGHT << VAR_5) ? VAR_14[POS_LEFT] : 0;",
"else\nclip_left = y_to_deblock & (MASK_CUR << (ij-1)) ? VAR_14[POS_CUR] : 0;",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, Y, s->linesize, dither,\nclip_cur,\nclip_left,\nVAR_7, VAR_8, VAR_9, 0, 0, 1);",
"}",
"if(!VAR_5 && y_h_deblock & (MASK_CUR << VAR_4) && (VAR_13[POS_CUR] | VAR_13[POS_TOP])){",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, Y, s->linesize, dither,\nclip_cur,\nVAR_17[POS_TOP] & (MASK_TOP << VAR_4) ? VAR_14[POS_TOP] : 0,\nVAR_7, VAR_8, VAR_9, 0, 1, 0);",
"}",
"if(y_v_deblock & (MASK_CUR << ij) && !VAR_4 && (VAR_13[POS_CUR] | VAR_13[POS_LEFT])){",
"clip_left = VAR_17[POS_LEFT] & (MASK_RIGHT << VAR_5) ? VAR_14[POS_LEFT] : 0;",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, Y, s->linesize, dither,\nclip_cur,\nclip_left,\nVAR_7, VAR_8, VAR_9, 0, 1, 1);",
"}",
"}",
"}",
"for(VAR_6 = 0; VAR_6 < 2; VAR_6++){",
"for(VAR_5 = 0; VAR_5 < 2; VAR_5++){",
"C = s->current_picture_ptr->f.data[VAR_6 + 1] + VAR_3*8 + (VAR_1*8 + VAR_5*4) * s->uvlinesize;",
"for(VAR_4 = 0; VAR_4 < 2; VAR_4++, C += 4){",
"int ij = VAR_4 + VAR_5*2;",
"int clip_cur = c_to_deblock[VAR_6] & (MASK_CUR << ij) ? VAR_14[POS_CUR] : 0;",
"if(c_h_deblock[VAR_6] & (MASK_CUR << (ij+2))){",
"int clip_bot = c_to_deblock[VAR_6] & (MASK_CUR << (ij+2)) ? VAR_14[POS_CUR] : 0;",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, C+4*s->uvlinesize, s->uvlinesize, VAR_4*8,\nclip_bot,\nclip_cur,\nVAR_7, VAR_8, VAR_10, 1, 0, 0);",
"}",
"if((c_v_deblock[VAR_6] & (MASK_CUR << ij)) && (VAR_4 || !(VAR_13[POS_CUR] | VAR_13[POS_LEFT]))){",
"if(!VAR_4)\nclip_left = VAR_16[POS_LEFT][VAR_6] & (MASK_CUR << (2*VAR_5+1)) ? VAR_14[POS_LEFT] : 0;",
"else\nclip_left = c_to_deblock[VAR_6] & (MASK_CUR << (ij-1)) ? VAR_14[POS_CUR] : 0;",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, C, s->uvlinesize, VAR_5*8,\nclip_cur,\nclip_left,\nVAR_7, VAR_8, VAR_10, 1, 0, 1);",
"}",
"if(!VAR_5 && c_h_deblock[VAR_6] & (MASK_CUR << ij) && (VAR_13[POS_CUR] | VAR_13[POS_TOP])){",
"int clip_top = VAR_16[POS_TOP][VAR_6] & (MASK_CUR << (ij+2)) ? VAR_14[POS_TOP] : 0;",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, C, s->uvlinesize, VAR_4*8,\nclip_cur,\nclip_top,\nVAR_7, VAR_8, VAR_10, 1, 1, 0);",
"}",
"if(c_v_deblock[VAR_6] & (MASK_CUR << ij) && !VAR_4 && (VAR_13[POS_CUR] | VAR_13[POS_LEFT])){",
"clip_left = VAR_16[POS_LEFT][VAR_6] & (MASK_CUR << (2*VAR_5+1)) ? VAR_14[POS_LEFT] : 0;",
"rv40_adaptive_loop_filter(&VAR_0->rdsp, C, s->uvlinesize, VAR_5*8,\nclip_cur,\nclip_left,\nVAR_7, VAR_8, VAR_10, 1, 1, 1);",
"}",
"}",
"}",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
27
],
[
29
],
[
43
],
[
53
],
[
65
],
[
69
],
[
71
],
[
73
],
[
75,
77
],
[
79,
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111,
113
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159,
161
],
[
175,
177,
179
],
[
193,
195,
197
],
[
199,
201
],
[
203,
205
],
[
207,
209
],
[
217
],
[
219
],
[
221,
223,
225
],
[
227,
229,
231
],
[
233,
235
],
[
237,
239
],
[
241,
243
],
[
245
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
267
],
[
269,
271,
273,
275,
277
],
[
279
],
[
283
],
[
285,
287
],
[
289,
291
],
[
293,
295,
297,
299
],
[
301
],
[
305
],
[
307,
309,
311,
313
],
[
315
],
[
319
],
[
321
],
[
323,
325,
327,
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353,
355,
357,
359
],
[
361
],
[
363
],
[
365,
367
],
[
369,
371
],
[
373,
375,
377,
379
],
[
381
],
[
383
],
[
385
],
[
387,
389,
391,
393
],
[
395
],
[
397
],
[
399
],
[
401,
403,
405,
407
],
[
409
],
[
411
],
[
413
],
[
415
],
[
417
],
[
419
]
] |
6,961 |
static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
{
struct video_data *s = ctx->priv_data;
struct v4l2_buffer buf = {
.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
.memory = V4L2_MEMORY_MMAP
};
int res;
pkt->size = 0;
/* FIXME: Some special treatment might be needed in case of loss of signal... */
while ((res = v4l2_ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
if (res < 0) {
if (errno == EAGAIN)
return AVERROR(EAGAIN);
res = AVERROR(errno);
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",
av_err2str(res));
return res;
}
if (buf.index >= s->buffers) {
av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");
return AVERROR(EINVAL);
}
atomic_fetch_add(&s->buffers_queued, -1);
// always keep at least one buffer queued
av_assert0(atomic_load(&s->buffers_queued) >= 1);
#ifdef V4L2_BUF_FLAG_ERROR
if (buf.flags & V4L2_BUF_FLAG_ERROR) {
av_log(ctx, AV_LOG_WARNING,
"Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
buf.bytesused);
buf.bytesused = 0;
} else
#endif
{
/* CPIA is a compressed format and we don't know the exact number of bytes
* used by a frame, so set it here as the driver announces it. */
if (ctx->video_codec_id == AV_CODEC_ID_CPIA)
s->frame_size = buf.bytesused;
if (s->frame_size > 0 && buf.bytesused != s->frame_size) {
av_log(ctx, AV_LOG_ERROR,
"Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
buf.bytesused, s->frame_size, buf.flags);
enqueue_buffer(s, &buf);
return AVERROR_INVALIDDATA;
}
}
/* Image is at s->buff_start[buf.index] */
if (atomic_load(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
/* when we start getting low on queued buffers, fall back on copying data */
res = av_new_packet(pkt, buf.bytesused);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n");
enqueue_buffer(s, &buf);
return res;
}
memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused);
res = enqueue_buffer(s, &buf);
if (res) {
av_packet_unref(pkt);
return res;
}
} else {
struct buff_data *buf_descriptor;
pkt->data = s->buf_start[buf.index];
pkt->size = buf.bytesused;
buf_descriptor = av_malloc(sizeof(struct buff_data));
if (!buf_descriptor) {
/* Something went wrong... Since av_malloc() failed, we cannot even
* allocate a buffer for memcpying into it
*/
av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
enqueue_buffer(s, &buf);
return AVERROR(ENOMEM);
}
buf_descriptor->index = buf.index;
buf_descriptor->s = s;
pkt->buf = av_buffer_create(pkt->data, pkt->size, mmap_release_buffer,
buf_descriptor, 0);
if (!pkt->buf) {
av_log(ctx, AV_LOG_ERROR, "Failed to create a buffer\n");
enqueue_buffer(s, &buf);
av_freep(&buf_descriptor);
return AVERROR(ENOMEM);
}
}
pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
convert_timestamp(ctx, &pkt->pts);
return pkt->size;
}
| true |
FFmpeg
|
00a1e1337f22376909338a5319a378b2e2afdde8
|
static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
{
struct video_data *s = ctx->priv_data;
struct v4l2_buffer buf = {
.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
.memory = V4L2_MEMORY_MMAP
};
int res;
pkt->size = 0;
while ((res = v4l2_ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
if (res < 0) {
if (errno == EAGAIN)
return AVERROR(EAGAIN);
res = AVERROR(errno);
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",
av_err2str(res));
return res;
}
if (buf.index >= s->buffers) {
av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");
return AVERROR(EINVAL);
}
atomic_fetch_add(&s->buffers_queued, -1);
av_assert0(atomic_load(&s->buffers_queued) >= 1);
#ifdef V4L2_BUF_FLAG_ERROR
if (buf.flags & V4L2_BUF_FLAG_ERROR) {
av_log(ctx, AV_LOG_WARNING,
"Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
buf.bytesused);
buf.bytesused = 0;
} else
#endif
{
if (ctx->video_codec_id == AV_CODEC_ID_CPIA)
s->frame_size = buf.bytesused;
if (s->frame_size > 0 && buf.bytesused != s->frame_size) {
av_log(ctx, AV_LOG_ERROR,
"Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
buf.bytesused, s->frame_size, buf.flags);
enqueue_buffer(s, &buf);
return AVERROR_INVALIDDATA;
}
}
if (atomic_load(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
res = av_new_packet(pkt, buf.bytesused);
if (res < 0) {
av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n");
enqueue_buffer(s, &buf);
return res;
}
memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused);
res = enqueue_buffer(s, &buf);
if (res) {
av_packet_unref(pkt);
return res;
}
} else {
struct buff_data *buf_descriptor;
pkt->data = s->buf_start[buf.index];
pkt->size = buf.bytesused;
buf_descriptor = av_malloc(sizeof(struct buff_data));
if (!buf_descriptor) {
av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
enqueue_buffer(s, &buf);
return AVERROR(ENOMEM);
}
buf_descriptor->index = buf.index;
buf_descriptor->s = s;
pkt->buf = av_buffer_create(pkt->data, pkt->size, mmap_release_buffer,
buf_descriptor, 0);
if (!pkt->buf) {
av_log(ctx, AV_LOG_ERROR, "Failed to create a buffer\n");
enqueue_buffer(s, &buf);
av_freep(&buf_descriptor);
return AVERROR(ENOMEM);
}
}
pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
convert_timestamp(ctx, &pkt->pts);
return pkt->size;
}
|
{
"code": [
" pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;"
],
"line_no": [
197
]
}
|
static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
struct video_data *VAR_2 = VAR_0->priv_data;
struct v4l2_buffer VAR_3 = {
.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
.memory = V4L2_MEMORY_MMAP
};
int VAR_4;
VAR_1->size = 0;
while ((VAR_4 = v4l2_ioctl(VAR_2->fd, VIDIOC_DQBUF, &VAR_3)) < 0 && (errno == EINTR));
if (VAR_4 < 0) {
if (errno == EAGAIN)
return AVERROR(EAGAIN);
VAR_4 = AVERROR(errno);
av_log(VAR_0, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %VAR_2\n",
av_err2str(VAR_4));
return VAR_4;
}
if (VAR_3.index >= VAR_2->buffers) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid buffer index received.\n");
return AVERROR(EINVAL);
}
atomic_fetch_add(&VAR_2->buffers_queued, -1);
av_assert0(atomic_load(&VAR_2->buffers_queued) >= 1);
#ifdef V4L2_BUF_FLAG_ERROR
if (VAR_3.flags & V4L2_BUF_FLAG_ERROR) {
av_log(VAR_0, AV_LOG_WARNING,
"Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
VAR_3.bytesused);
VAR_3.bytesused = 0;
} else
#endif
{
if (VAR_0->video_codec_id == AV_CODEC_ID_CPIA)
VAR_2->frame_size = VAR_3.bytesused;
if (VAR_2->frame_size > 0 && VAR_3.bytesused != VAR_2->frame_size) {
av_log(VAR_0, AV_LOG_ERROR,
"Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
VAR_3.bytesused, VAR_2->frame_size, VAR_3.flags);
enqueue_buffer(VAR_2, &VAR_3);
return AVERROR_INVALIDDATA;
}
}
if (atomic_load(&VAR_2->buffers_queued) == FFMAX(VAR_2->buffers / 8, 1)) {
VAR_4 = av_new_packet(VAR_1, VAR_3.bytesused);
if (VAR_4 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Error allocating a packet.\n");
enqueue_buffer(VAR_2, &VAR_3);
return VAR_4;
}
memcpy(VAR_1->data, VAR_2->buf_start[VAR_3.index], VAR_3.bytesused);
VAR_4 = enqueue_buffer(VAR_2, &VAR_3);
if (VAR_4) {
av_packet_unref(VAR_1);
return VAR_4;
}
} else {
struct buff_data *VAR_5;
VAR_1->data = VAR_2->buf_start[VAR_3.index];
VAR_1->size = VAR_3.bytesused;
VAR_5 = av_malloc(sizeof(struct buff_data));
if (!VAR_5) {
av_log(VAR_0, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
enqueue_buffer(VAR_2, &VAR_3);
return AVERROR(ENOMEM);
}
VAR_5->index = VAR_3.index;
VAR_5->VAR_2 = VAR_2;
VAR_1->VAR_3 = av_buffer_create(VAR_1->data, VAR_1->size, mmap_release_buffer,
VAR_5, 0);
if (!VAR_1->VAR_3) {
av_log(VAR_0, AV_LOG_ERROR, "Failed to create a buffer\n");
enqueue_buffer(VAR_2, &VAR_3);
av_freep(&VAR_5);
return AVERROR(ENOMEM);
}
}
VAR_1->pts = VAR_3.timestamp.tv_sec * INT64_C(1000000) + VAR_3.timestamp.tv_usec;
convert_timestamp(VAR_0, &VAR_1->pts);
return VAR_1->size;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"struct video_data *VAR_2 = VAR_0->priv_data;",
"struct v4l2_buffer VAR_3 = {",
".type = V4L2_BUF_TYPE_VIDEO_CAPTURE,\n.memory = V4L2_MEMORY_MMAP\n};",
"int VAR_4;",
"VAR_1->size = 0;",
"while ((VAR_4 = v4l2_ioctl(VAR_2->fd, VIDIOC_DQBUF, &VAR_3)) < 0 && (errno == EINTR));",
"if (VAR_4 < 0) {",
"if (errno == EAGAIN)\nreturn AVERROR(EAGAIN);",
"VAR_4 = AVERROR(errno);",
"av_log(VAR_0, AV_LOG_ERROR, \"ioctl(VIDIOC_DQBUF): %VAR_2\\n\",\nav_err2str(VAR_4));",
"return VAR_4;",
"}",
"if (VAR_3.index >= VAR_2->buffers) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid buffer index received.\\n\");",
"return AVERROR(EINVAL);",
"}",
"atomic_fetch_add(&VAR_2->buffers_queued, -1);",
"av_assert0(atomic_load(&VAR_2->buffers_queued) >= 1);",
"#ifdef V4L2_BUF_FLAG_ERROR\nif (VAR_3.flags & V4L2_BUF_FLAG_ERROR) {",
"av_log(VAR_0, AV_LOG_WARNING,\n\"Dequeued v4l2 buffer contains corrupted data (%d bytes).\\n\",\nVAR_3.bytesused);",
"VAR_3.bytesused = 0;",
"} else",
"#endif\n{",
"if (VAR_0->video_codec_id == AV_CODEC_ID_CPIA)\nVAR_2->frame_size = VAR_3.bytesused;",
"if (VAR_2->frame_size > 0 && VAR_3.bytesused != VAR_2->frame_size) {",
"av_log(VAR_0, AV_LOG_ERROR,\n\"Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\\n\",\nVAR_3.bytesused, VAR_2->frame_size, VAR_3.flags);",
"enqueue_buffer(VAR_2, &VAR_3);",
"return AVERROR_INVALIDDATA;",
"}",
"}",
"if (atomic_load(&VAR_2->buffers_queued) == FFMAX(VAR_2->buffers / 8, 1)) {",
"VAR_4 = av_new_packet(VAR_1, VAR_3.bytesused);",
"if (VAR_4 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Error allocating a packet.\\n\");",
"enqueue_buffer(VAR_2, &VAR_3);",
"return VAR_4;",
"}",
"memcpy(VAR_1->data, VAR_2->buf_start[VAR_3.index], VAR_3.bytesused);",
"VAR_4 = enqueue_buffer(VAR_2, &VAR_3);",
"if (VAR_4) {",
"av_packet_unref(VAR_1);",
"return VAR_4;",
"}",
"} else {",
"struct buff_data *VAR_5;",
"VAR_1->data = VAR_2->buf_start[VAR_3.index];",
"VAR_1->size = VAR_3.bytesused;",
"VAR_5 = av_malloc(sizeof(struct buff_data));",
"if (!VAR_5) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Failed to allocate a buffer descriptor\\n\");",
"enqueue_buffer(VAR_2, &VAR_3);",
"return AVERROR(ENOMEM);",
"}",
"VAR_5->index = VAR_3.index;",
"VAR_5->VAR_2 = VAR_2;",
"VAR_1->VAR_3 = av_buffer_create(VAR_1->data, VAR_1->size, mmap_release_buffer,\nVAR_5, 0);",
"if (!VAR_1->VAR_3) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Failed to create a buffer\\n\");",
"enqueue_buffer(VAR_2, &VAR_3);",
"av_freep(&VAR_5);",
"return AVERROR(ENOMEM);",
"}",
"}",
"VAR_1->pts = VAR_3.timestamp.tv_sec * INT64_C(1000000) + VAR_3.timestamp.tv_usec;",
"convert_timestamp(VAR_0, &VAR_1->pts);",
"return VAR_1->size;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9,
11,
13
],
[
15
],
[
19
],
[
25
],
[
27
],
[
29,
31
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
63,
65
],
[
67,
69,
71
],
[
73
],
[
75
],
[
77,
79
],
[
85,
87
],
[
91
],
[
93,
95,
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
111
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149
],
[
153
],
[
155
],
[
163
],
[
165
],
[
169
],
[
171
],
[
173
],
[
175
],
[
179,
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
]
] |
6,962 |
static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
{
SegmentContext *seg = s->priv_data;
AVStream *st = s->streams[pkt->stream_index];
int64_t end_pts = INT64_MAX, offset;
int start_frame = INT_MAX;
int ret;
struct tm ti;
int64_t usecs;
int64_t wrapped_val;
if (!seg->avf)
return AVERROR(EINVAL);
calc_times:
if (seg->times) {
end_pts = seg->segment_count < seg->nb_times ?
seg->times[seg->segment_count] : INT64_MAX;
} else if (seg->frames) {
start_frame = seg->segment_count < seg->nb_frames ?
seg->frames[seg->segment_count] : INT_MAX;
} else {
if (seg->use_clocktime) {
int64_t avgt = av_gettime();
time_t sec = avgt / 1000000;
localtime_r(&sec, &ti);
usecs = (int64_t)(ti.tm_hour * 3600 + ti.tm_min * 60 + ti.tm_sec) * 1000000 + (avgt % 1000000);
wrapped_val = (usecs + seg->clocktime_offset) % seg->time;
if (seg->last_cut != usecs && wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration) {
seg->cut_pending = 1;
seg->last_cut = usecs;
}
seg->last_val = wrapped_val;
} else {
end_pts = seg->time * (seg->segment_count + 1);
}
}
ff_dlog(s, "packet stream:%d pts:%s pts_time:%s duration_time:%s is_key:%d frame:%d\n",
pkt->stream_index, av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
av_ts2timestr(pkt->duration, &st->time_base),
pkt->flags & AV_PKT_FLAG_KEY,
pkt->stream_index == seg->reference_stream_index ? seg->frame_count : -1);
if (pkt->stream_index == seg->reference_stream_index &&
(pkt->flags & AV_PKT_FLAG_KEY || seg->break_non_keyframes) &&
(seg->segment_frame_count > 0 || seg->write_empty) &&
(seg->cut_pending || seg->frame_count >= start_frame ||
(pkt->pts != AV_NOPTS_VALUE &&
av_compare_ts(pkt->pts, st->time_base,
end_pts - seg->time_delta, AV_TIME_BASE_Q) >= 0))) {
/* sanitize end time in case last packet didn't have a defined duration */
if (seg->cur_entry.last_duration == 0)
seg->cur_entry.end_time = (double)pkt->pts * av_q2d(st->time_base);
if ((ret = segment_end(s, seg->individual_header_trailer, 0)) < 0)
goto fail;
if ((ret = segment_start(s, seg->individual_header_trailer)) < 0)
goto fail;
seg->cut_pending = 0;
seg->cur_entry.index = seg->segment_idx + seg->segment_idx_wrap * seg->segment_idx_wrap_nb;
seg->cur_entry.start_time = (double)pkt->pts * av_q2d(st->time_base);
seg->cur_entry.start_pts = av_rescale_q(pkt->pts, st->time_base, AV_TIME_BASE_Q);
seg->cur_entry.end_time = seg->cur_entry.start_time;
if (seg->times || (!seg->frames && !seg->use_clocktime) && seg->write_empty)
goto calc_times;
}
if (pkt->stream_index == seg->reference_stream_index) {
if (pkt->pts != AV_NOPTS_VALUE)
seg->cur_entry.end_time =
FFMAX(seg->cur_entry.end_time, (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));
seg->cur_entry.last_duration = pkt->duration;
}
if (seg->segment_frame_count == 0) {
av_log(s, AV_LOG_VERBOSE, "segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d\n",
seg->avf->filename, pkt->stream_index,
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base), seg->frame_count);
}
av_log(s, AV_LOG_DEBUG, "stream:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s",
pkt->stream_index,
av_ts2timestr(seg->cur_entry.start_pts, &AV_TIME_BASE_Q),
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
/* compute new timestamps */
offset = av_rescale_q(seg->initial_offset - (seg->reset_timestamps ? seg->cur_entry.start_pts : 0),
AV_TIME_BASE_Q, st->time_base);
if (pkt->pts != AV_NOPTS_VALUE)
pkt->pts += offset;
if (pkt->dts != AV_NOPTS_VALUE)
pkt->dts += offset;
av_log(s, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
ret = ff_write_chained(seg->avf, pkt->stream_index, pkt, s, seg->initial_offset || seg->reset_timestamps);
fail:
if (pkt->stream_index == seg->reference_stream_index) {
seg->frame_count++;
seg->segment_frame_count++;
}
return ret;
}
| true |
FFmpeg
|
2b202900618d82030384d46c8d9c3dbf3fe1d7ed
|
static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
{
SegmentContext *seg = s->priv_data;
AVStream *st = s->streams[pkt->stream_index];
int64_t end_pts = INT64_MAX, offset;
int start_frame = INT_MAX;
int ret;
struct tm ti;
int64_t usecs;
int64_t wrapped_val;
if (!seg->avf)
return AVERROR(EINVAL);
calc_times:
if (seg->times) {
end_pts = seg->segment_count < seg->nb_times ?
seg->times[seg->segment_count] : INT64_MAX;
} else if (seg->frames) {
start_frame = seg->segment_count < seg->nb_frames ?
seg->frames[seg->segment_count] : INT_MAX;
} else {
if (seg->use_clocktime) {
int64_t avgt = av_gettime();
time_t sec = avgt / 1000000;
localtime_r(&sec, &ti);
usecs = (int64_t)(ti.tm_hour * 3600 + ti.tm_min * 60 + ti.tm_sec) * 1000000 + (avgt % 1000000);
wrapped_val = (usecs + seg->clocktime_offset) % seg->time;
if (seg->last_cut != usecs && wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration) {
seg->cut_pending = 1;
seg->last_cut = usecs;
}
seg->last_val = wrapped_val;
} else {
end_pts = seg->time * (seg->segment_count + 1);
}
}
ff_dlog(s, "packet stream:%d pts:%s pts_time:%s duration_time:%s is_key:%d frame:%d\n",
pkt->stream_index, av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
av_ts2timestr(pkt->duration, &st->time_base),
pkt->flags & AV_PKT_FLAG_KEY,
pkt->stream_index == seg->reference_stream_index ? seg->frame_count : -1);
if (pkt->stream_index == seg->reference_stream_index &&
(pkt->flags & AV_PKT_FLAG_KEY || seg->break_non_keyframes) &&
(seg->segment_frame_count > 0 || seg->write_empty) &&
(seg->cut_pending || seg->frame_count >= start_frame ||
(pkt->pts != AV_NOPTS_VALUE &&
av_compare_ts(pkt->pts, st->time_base,
end_pts - seg->time_delta, AV_TIME_BASE_Q) >= 0))) {
if (seg->cur_entry.last_duration == 0)
seg->cur_entry.end_time = (double)pkt->pts * av_q2d(st->time_base);
if ((ret = segment_end(s, seg->individual_header_trailer, 0)) < 0)
goto fail;
if ((ret = segment_start(s, seg->individual_header_trailer)) < 0)
goto fail;
seg->cut_pending = 0;
seg->cur_entry.index = seg->segment_idx + seg->segment_idx_wrap * seg->segment_idx_wrap_nb;
seg->cur_entry.start_time = (double)pkt->pts * av_q2d(st->time_base);
seg->cur_entry.start_pts = av_rescale_q(pkt->pts, st->time_base, AV_TIME_BASE_Q);
seg->cur_entry.end_time = seg->cur_entry.start_time;
if (seg->times || (!seg->frames && !seg->use_clocktime) && seg->write_empty)
goto calc_times;
}
if (pkt->stream_index == seg->reference_stream_index) {
if (pkt->pts != AV_NOPTS_VALUE)
seg->cur_entry.end_time =
FFMAX(seg->cur_entry.end_time, (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));
seg->cur_entry.last_duration = pkt->duration;
}
if (seg->segment_frame_count == 0) {
av_log(s, AV_LOG_VERBOSE, "segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d\n",
seg->avf->filename, pkt->stream_index,
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base), seg->frame_count);
}
av_log(s, AV_LOG_DEBUG, "stream:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s",
pkt->stream_index,
av_ts2timestr(seg->cur_entry.start_pts, &AV_TIME_BASE_Q),
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
offset = av_rescale_q(seg->initial_offset - (seg->reset_timestamps ? seg->cur_entry.start_pts : 0),
AV_TIME_BASE_Q, st->time_base);
if (pkt->pts != AV_NOPTS_VALUE)
pkt->pts += offset;
if (pkt->dts != AV_NOPTS_VALUE)
pkt->dts += offset;
av_log(s, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
ret = ff_write_chained(seg->avf, pkt->stream_index, pkt, s, seg->initial_offset || seg->reset_timestamps);
fail:
if (pkt->stream_index == seg->reference_stream_index) {
seg->frame_count++;
seg->segment_frame_count++;
}
return ret;
}
|
{
"code": [
" if (!seg->avf)"
],
"line_no": [
23
]
}
|
static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
SegmentContext *seg = VAR_0->priv_data;
AVStream *st = VAR_0->streams[VAR_1->stream_index];
int64_t end_pts = INT64_MAX, offset;
int VAR_2 = INT_MAX;
int VAR_3;
struct tm VAR_4;
int64_t usecs;
int64_t wrapped_val;
if (!seg->avf)
return AVERROR(EINVAL);
calc_times:
if (seg->times) {
end_pts = seg->segment_count < seg->nb_times ?
seg->times[seg->segment_count] : INT64_MAX;
} else if (seg->frames) {
VAR_2 = seg->segment_count < seg->nb_frames ?
seg->frames[seg->segment_count] : INT_MAX;
} else {
if (seg->use_clocktime) {
int64_t avgt = av_gettime();
time_t sec = avgt / 1000000;
localtime_r(&sec, &VAR_4);
usecs = (int64_t)(VAR_4.tm_hour * 3600 + VAR_4.tm_min * 60 + VAR_4.tm_sec) * 1000000 + (avgt % 1000000);
wrapped_val = (usecs + seg->clocktime_offset) % seg->time;
if (seg->last_cut != usecs && wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration) {
seg->cut_pending = 1;
seg->last_cut = usecs;
}
seg->last_val = wrapped_val;
} else {
end_pts = seg->time * (seg->segment_count + 1);
}
}
ff_dlog(VAR_0, "packet stream:%d pts:%VAR_0 pts_time:%VAR_0 duration_time:%VAR_0 is_key:%d frame:%d\n",
VAR_1->stream_index, av_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base),
av_ts2timestr(VAR_1->duration, &st->time_base),
VAR_1->flags & AV_PKT_FLAG_KEY,
VAR_1->stream_index == seg->reference_stream_index ? seg->frame_count : -1);
if (VAR_1->stream_index == seg->reference_stream_index &&
(VAR_1->flags & AV_PKT_FLAG_KEY || seg->break_non_keyframes) &&
(seg->segment_frame_count > 0 || seg->write_empty) &&
(seg->cut_pending || seg->frame_count >= VAR_2 ||
(VAR_1->pts != AV_NOPTS_VALUE &&
av_compare_ts(VAR_1->pts, st->time_base,
end_pts - seg->time_delta, AV_TIME_BASE_Q) >= 0))) {
if (seg->cur_entry.last_duration == 0)
seg->cur_entry.end_time = (double)VAR_1->pts * av_q2d(st->time_base);
if ((VAR_3 = segment_end(VAR_0, seg->individual_header_trailer, 0)) < 0)
goto fail;
if ((VAR_3 = segment_start(VAR_0, seg->individual_header_trailer)) < 0)
goto fail;
seg->cut_pending = 0;
seg->cur_entry.index = seg->segment_idx + seg->segment_idx_wrap * seg->segment_idx_wrap_nb;
seg->cur_entry.start_time = (double)VAR_1->pts * av_q2d(st->time_base);
seg->cur_entry.start_pts = av_rescale_q(VAR_1->pts, st->time_base, AV_TIME_BASE_Q);
seg->cur_entry.end_time = seg->cur_entry.start_time;
if (seg->times || (!seg->frames && !seg->use_clocktime) && seg->write_empty)
goto calc_times;
}
if (VAR_1->stream_index == seg->reference_stream_index) {
if (VAR_1->pts != AV_NOPTS_VALUE)
seg->cur_entry.end_time =
FFMAX(seg->cur_entry.end_time, (double)(VAR_1->pts + VAR_1->duration) * av_q2d(st->time_base));
seg->cur_entry.last_duration = VAR_1->duration;
}
if (seg->segment_frame_count == 0) {
av_log(VAR_0, AV_LOG_VERBOSE, "segment:'%VAR_0' starts with packet stream:%d pts:%VAR_0 pts_time:%VAR_0 frame:%d\n",
seg->avf->filename, VAR_1->stream_index,
av_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base), seg->frame_count);
}
av_log(VAR_0, AV_LOG_DEBUG, "stream:%d start_pts_time:%VAR_0 pts:%VAR_0 pts_time:%VAR_0 dts:%VAR_0 dts_time:%VAR_0",
VAR_1->stream_index,
av_ts2timestr(seg->cur_entry.start_pts, &AV_TIME_BASE_Q),
av_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base),
av_ts2str(VAR_1->dts), av_ts2timestr(VAR_1->dts, &st->time_base));
offset = av_rescale_q(seg->initial_offset - (seg->reset_timestamps ? seg->cur_entry.start_pts : 0),
AV_TIME_BASE_Q, st->time_base);
if (VAR_1->pts != AV_NOPTS_VALUE)
VAR_1->pts += offset;
if (VAR_1->dts != AV_NOPTS_VALUE)
VAR_1->dts += offset;
av_log(VAR_0, AV_LOG_DEBUG, " -> pts:%VAR_0 pts_time:%VAR_0 dts:%VAR_0 dts_time:%VAR_0\n",
av_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base),
av_ts2str(VAR_1->dts), av_ts2timestr(VAR_1->dts, &st->time_base));
VAR_3 = ff_write_chained(seg->avf, VAR_1->stream_index, VAR_1, VAR_0, seg->initial_offset || seg->reset_timestamps);
fail:
if (VAR_1->stream_index == seg->reference_stream_index) {
seg->frame_count++;
seg->segment_frame_count++;
}
return VAR_3;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"SegmentContext *seg = VAR_0->priv_data;",
"AVStream *st = VAR_0->streams[VAR_1->stream_index];",
"int64_t end_pts = INT64_MAX, offset;",
"int VAR_2 = INT_MAX;",
"int VAR_3;",
"struct tm VAR_4;",
"int64_t usecs;",
"int64_t wrapped_val;",
"if (!seg->avf)\nreturn AVERROR(EINVAL);",
"calc_times:\nif (seg->times) {",
"end_pts = seg->segment_count < seg->nb_times ?\nseg->times[seg->segment_count] : INT64_MAX;",
"} else if (seg->frames) {",
"VAR_2 = seg->segment_count < seg->nb_frames ?\nseg->frames[seg->segment_count] : INT_MAX;",
"} else {",
"if (seg->use_clocktime) {",
"int64_t avgt = av_gettime();",
"time_t sec = avgt / 1000000;",
"localtime_r(&sec, &VAR_4);",
"usecs = (int64_t)(VAR_4.tm_hour * 3600 + VAR_4.tm_min * 60 + VAR_4.tm_sec) * 1000000 + (avgt % 1000000);",
"wrapped_val = (usecs + seg->clocktime_offset) % seg->time;",
"if (seg->last_cut != usecs && wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration) {",
"seg->cut_pending = 1;",
"seg->last_cut = usecs;",
"}",
"seg->last_val = wrapped_val;",
"} else {",
"end_pts = seg->time * (seg->segment_count + 1);",
"}",
"}",
"ff_dlog(VAR_0, \"packet stream:%d pts:%VAR_0 pts_time:%VAR_0 duration_time:%VAR_0 is_key:%d frame:%d\\n\",\nVAR_1->stream_index, av_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base),\nav_ts2timestr(VAR_1->duration, &st->time_base),\nVAR_1->flags & AV_PKT_FLAG_KEY,\nVAR_1->stream_index == seg->reference_stream_index ? seg->frame_count : -1);",
"if (VAR_1->stream_index == seg->reference_stream_index &&\n(VAR_1->flags & AV_PKT_FLAG_KEY || seg->break_non_keyframes) &&\n(seg->segment_frame_count > 0 || seg->write_empty) &&\n(seg->cut_pending || seg->frame_count >= VAR_2 ||\n(VAR_1->pts != AV_NOPTS_VALUE &&\nav_compare_ts(VAR_1->pts, st->time_base,\nend_pts - seg->time_delta, AV_TIME_BASE_Q) >= 0))) {",
"if (seg->cur_entry.last_duration == 0)\nseg->cur_entry.end_time = (double)VAR_1->pts * av_q2d(st->time_base);",
"if ((VAR_3 = segment_end(VAR_0, seg->individual_header_trailer, 0)) < 0)\ngoto fail;",
"if ((VAR_3 = segment_start(VAR_0, seg->individual_header_trailer)) < 0)\ngoto fail;",
"seg->cut_pending = 0;",
"seg->cur_entry.index = seg->segment_idx + seg->segment_idx_wrap * seg->segment_idx_wrap_nb;",
"seg->cur_entry.start_time = (double)VAR_1->pts * av_q2d(st->time_base);",
"seg->cur_entry.start_pts = av_rescale_q(VAR_1->pts, st->time_base, AV_TIME_BASE_Q);",
"seg->cur_entry.end_time = seg->cur_entry.start_time;",
"if (seg->times || (!seg->frames && !seg->use_clocktime) && seg->write_empty)\ngoto calc_times;",
"}",
"if (VAR_1->stream_index == seg->reference_stream_index) {",
"if (VAR_1->pts != AV_NOPTS_VALUE)\nseg->cur_entry.end_time =\nFFMAX(seg->cur_entry.end_time, (double)(VAR_1->pts + VAR_1->duration) * av_q2d(st->time_base));",
"seg->cur_entry.last_duration = VAR_1->duration;",
"}",
"if (seg->segment_frame_count == 0) {",
"av_log(VAR_0, AV_LOG_VERBOSE, \"segment:'%VAR_0' starts with packet stream:%d pts:%VAR_0 pts_time:%VAR_0 frame:%d\\n\",\nseg->avf->filename, VAR_1->stream_index,\nav_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base), seg->frame_count);",
"}",
"av_log(VAR_0, AV_LOG_DEBUG, \"stream:%d start_pts_time:%VAR_0 pts:%VAR_0 pts_time:%VAR_0 dts:%VAR_0 dts_time:%VAR_0\",\nVAR_1->stream_index,\nav_ts2timestr(seg->cur_entry.start_pts, &AV_TIME_BASE_Q),\nav_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base),\nav_ts2str(VAR_1->dts), av_ts2timestr(VAR_1->dts, &st->time_base));",
"offset = av_rescale_q(seg->initial_offset - (seg->reset_timestamps ? seg->cur_entry.start_pts : 0),\nAV_TIME_BASE_Q, st->time_base);",
"if (VAR_1->pts != AV_NOPTS_VALUE)\nVAR_1->pts += offset;",
"if (VAR_1->dts != AV_NOPTS_VALUE)\nVAR_1->dts += offset;",
"av_log(VAR_0, AV_LOG_DEBUG, \" -> pts:%VAR_0 pts_time:%VAR_0 dts:%VAR_0 dts_time:%VAR_0\\n\",\nav_ts2str(VAR_1->pts), av_ts2timestr(VAR_1->pts, &st->time_base),\nav_ts2str(VAR_1->dts), av_ts2timestr(VAR_1->dts, &st->time_base));",
"VAR_3 = ff_write_chained(seg->avf, VAR_1->stream_index, VAR_1, VAR_0, seg->initial_offset || seg->reset_timestamps);",
"fail:\nif (VAR_1->stream_index == seg->reference_stream_index) {",
"seg->frame_count++;",
"seg->segment_frame_count++;",
"}",
"return VAR_3;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25
],
[
29,
31
],
[
33,
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77,
79,
81,
83,
85
],
[
89,
91,
93,
95,
97,
99,
101
],
[
105,
107
],
[
111,
113
],
[
117,
119
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
135,
137
],
[
139
],
[
143
],
[
145,
147,
149
],
[
151
],
[
153
],
[
157
],
[
159,
161,
163
],
[
165
],
[
169,
171,
173,
175,
177
],
[
183,
185
],
[
187,
189
],
[
191,
193
],
[
197,
199,
201
],
[
205
],
[
209,
211
],
[
213
],
[
215
],
[
217
],
[
221
],
[
223
]
] |
6,963 |
static int reap_filters(int flush)
{
AVFrame *filtered_frame = NULL;
int i;
/* Reap all buffers present in the buffer sinks */
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = output_streams[i];
OutputFile *of = output_files[ost->file_index];
AVFilterContext *filter;
AVCodecContext *enc = ost->enc_ctx;
int ret = 0;
if (!ost->filter || !ost->filter->graph->graph)
continue;
filter = ost->filter->filter;
if (!ost->initialized) {
char error[1024];
ret = init_output_stream(ost, error, sizeof(error));
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
ost->file_index, ost->index, error);
exit_program(1);
}
}
if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
return AVERROR(ENOMEM);
}
filtered_frame = ost->filtered_frame;
while (1) {
double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
ret = av_buffersink_get_frame_flags(filter, filtered_frame,
AV_BUFFERSINK_FLAG_NO_REQUEST);
if (ret < 0) {
if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
av_log(NULL, AV_LOG_WARNING,
"Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
} else if (flush && ret == AVERROR_EOF) {
if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
}
break;
}
if (ost->finished) {
av_frame_unref(filtered_frame);
continue;
}
if (filtered_frame->pts != AV_NOPTS_VALUE) {
int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
AVRational filter_tb = av_buffersink_get_time_base(filter);
AVRational tb = enc->time_base;
int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
tb.den <<= extra_bits;
float_pts =
av_rescale_q(filtered_frame->pts, filter_tb, tb) -
av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
float_pts /= 1 << extra_bits;
// avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
filtered_frame->pts =
av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
}
//if (ost->source_index >= 0)
// *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
switch (av_buffersink_get_type(filter)) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio.num)
enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
if (debug_ts) {
av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
float_pts,
enc->time_base.num, enc->time_base.den);
}
do_video_out(of, ost, filtered_frame, float_pts);
break;
case AVMEDIA_TYPE_AUDIO:
if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
enc->channels != av_frame_get_channels(filtered_frame)) {
av_log(NULL, AV_LOG_ERROR,
"Audio filter graph output is not normalized and encoder does not support parameter changes\n");
break;
}
do_audio_out(of, ost, filtered_frame);
break;
default:
// TODO support subtitle filters
av_assert0(0);
}
av_frame_unref(filtered_frame);
}
}
return 0;
}
| true |
FFmpeg
|
4b192ffdbe226461d8a07fd36d655ec13b2c7582
|
static int reap_filters(int flush)
{
AVFrame *filtered_frame = NULL;
int i;
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = output_streams[i];
OutputFile *of = output_files[ost->file_index];
AVFilterContext *filter;
AVCodecContext *enc = ost->enc_ctx;
int ret = 0;
if (!ost->filter || !ost->filter->graph->graph)
continue;
filter = ost->filter->filter;
if (!ost->initialized) {
char error[1024];
ret = init_output_stream(ost, error, sizeof(error));
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
ost->file_index, ost->index, error);
exit_program(1);
}
}
if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
return AVERROR(ENOMEM);
}
filtered_frame = ost->filtered_frame;
while (1) {
double float_pts = AV_NOPTS_VALUE;
ret = av_buffersink_get_frame_flags(filter, filtered_frame,
AV_BUFFERSINK_FLAG_NO_REQUEST);
if (ret < 0) {
if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
av_log(NULL, AV_LOG_WARNING,
"Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
} else if (flush && ret == AVERROR_EOF) {
if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
}
break;
}
if (ost->finished) {
av_frame_unref(filtered_frame);
continue;
}
if (filtered_frame->pts != AV_NOPTS_VALUE) {
int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
AVRational filter_tb = av_buffersink_get_time_base(filter);
AVRational tb = enc->time_base;
int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
tb.den <<= extra_bits;
float_pts =
av_rescale_q(filtered_frame->pts, filter_tb, tb) -
av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
float_pts /= 1 << extra_bits;
float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
filtered_frame->pts =
av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
}
switch (av_buffersink_get_type(filter)) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio.num)
enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
if (debug_ts) {
av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
float_pts,
enc->time_base.num, enc->time_base.den);
}
do_video_out(of, ost, filtered_frame, float_pts);
break;
case AVMEDIA_TYPE_AUDIO:
if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
enc->channels != av_frame_get_channels(filtered_frame)) {
av_log(NULL, AV_LOG_ERROR,
"Audio filter graph output is not normalized and encoder does not support parameter changes\n");
break;
}
do_audio_out(of, ost, filtered_frame);
break;
default:
av_assert0(0);
}
av_frame_unref(filtered_frame);
}
}
return 0;
}
|
{
"code": [
" char error[1024];",
" char error[1024];"
],
"line_no": [
37,
37
]
}
|
static int FUNC_0(int VAR_0)
{
AVFrame *filtered_frame = NULL;
int VAR_1;
for (VAR_1 = 0; VAR_1 < nb_output_streams; VAR_1++) {
OutputStream *ost = output_streams[VAR_1];
OutputFile *of = output_files[ost->file_index];
AVFilterContext *filter;
AVCodecContext *enc = ost->enc_ctx;
int ret = 0;
if (!ost->filter || !ost->filter->graph->graph)
continue;
filter = ost->filter->filter;
if (!ost->initialized) {
char error[1024];
ret = init_output_stream(ost, error, sizeof(error));
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
ost->file_index, ost->index, error);
exit_program(1);
}
}
if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
return AVERROR(ENOMEM);
}
filtered_frame = ost->filtered_frame;
while (1) {
double float_pts = AV_NOPTS_VALUE;
ret = av_buffersink_get_frame_flags(filter, filtered_frame,
AV_BUFFERSINK_FLAG_NO_REQUEST);
if (ret < 0) {
if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
av_log(NULL, AV_LOG_WARNING,
"Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
} else if (VAR_0 && ret == AVERROR_EOF) {
if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
}
break;
}
if (ost->finished) {
av_frame_unref(filtered_frame);
continue;
}
if (filtered_frame->pts != AV_NOPTS_VALUE) {
int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
AVRational filter_tb = av_buffersink_get_time_base(filter);
AVRational tb = enc->time_base;
int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
tb.den <<= extra_bits;
float_pts =
av_rescale_q(filtered_frame->pts, filter_tb, tb) -
av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
float_pts /= 1 << extra_bits;
float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
filtered_frame->pts =
av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
}
switch (av_buffersink_get_type(filter)) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio.num)
enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
if (debug_ts) {
av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
float_pts,
enc->time_base.num, enc->time_base.den);
}
do_video_out(of, ost, filtered_frame, float_pts);
break;
case AVMEDIA_TYPE_AUDIO:
if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
enc->channels != av_frame_get_channels(filtered_frame)) {
av_log(NULL, AV_LOG_ERROR,
"Audio filter graph output is not normalized and encoder does not support parameter changes\n");
break;
}
do_audio_out(of, ost, filtered_frame);
break;
default:
av_assert0(0);
}
av_frame_unref(filtered_frame);
}
}
return 0;
}
|
[
"static int FUNC_0(int VAR_0)\n{",
"AVFrame *filtered_frame = NULL;",
"int VAR_1;",
"for (VAR_1 = 0; VAR_1 < nb_output_streams; VAR_1++) {",
"OutputStream *ost = output_streams[VAR_1];",
"OutputFile *of = output_files[ost->file_index];",
"AVFilterContext *filter;",
"AVCodecContext *enc = ost->enc_ctx;",
"int ret = 0;",
"if (!ost->filter || !ost->filter->graph->graph)\ncontinue;",
"filter = ost->filter->filter;",
"if (!ost->initialized) {",
"char error[1024];",
"ret = init_output_stream(ost, error, sizeof(error));",
"if (ret < 0) {",
"av_log(NULL, AV_LOG_ERROR, \"Error initializing output stream %d:%d -- %s\\n\",\nost->file_index, ost->index, error);",
"exit_program(1);",
"}",
"}",
"if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {",
"return AVERROR(ENOMEM);",
"}",
"filtered_frame = ost->filtered_frame;",
"while (1) {",
"double float_pts = AV_NOPTS_VALUE;",
"ret = av_buffersink_get_frame_flags(filter, filtered_frame,\nAV_BUFFERSINK_FLAG_NO_REQUEST);",
"if (ret < 0) {",
"if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {",
"av_log(NULL, AV_LOG_WARNING,\n\"Error in av_buffersink_get_frame_flags(): %s\\n\", av_err2str(ret));",
"} else if (VAR_0 && ret == AVERROR_EOF) {",
"if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)\ndo_video_out(of, ost, NULL, AV_NOPTS_VALUE);",
"}",
"break;",
"}",
"if (ost->finished) {",
"av_frame_unref(filtered_frame);",
"continue;",
"}",
"if (filtered_frame->pts != AV_NOPTS_VALUE) {",
"int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;",
"AVRational filter_tb = av_buffersink_get_time_base(filter);",
"AVRational tb = enc->time_base;",
"int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);",
"tb.den <<= extra_bits;",
"float_pts =\nav_rescale_q(filtered_frame->pts, filter_tb, tb) -\nav_rescale_q(start_time, AV_TIME_BASE_Q, tb);",
"float_pts /= 1 << extra_bits;",
"float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);",
"filtered_frame->pts =\nav_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -\nav_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);",
"}",
"switch (av_buffersink_get_type(filter)) {",
"case AVMEDIA_TYPE_VIDEO:\nif (!ost->frame_aspect_ratio.num)\nenc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;",
"if (debug_ts) {",
"av_log(NULL, AV_LOG_INFO, \"filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\\n\",\nav_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),\nfloat_pts,\nenc->time_base.num, enc->time_base.den);",
"}",
"do_video_out(of, ost, filtered_frame, float_pts);",
"break;",
"case AVMEDIA_TYPE_AUDIO:\nif (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&\nenc->channels != av_frame_get_channels(filtered_frame)) {",
"av_log(NULL, AV_LOG_ERROR,\n\"Audio filter graph output is not normalized and encoder does not support parameter changes\\n\");",
"break;",
"}",
"do_audio_out(of, ost, filtered_frame);",
"break;",
"default:\nav_assert0(0);",
"}",
"av_frame_unref(filtered_frame);",
"}",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27,
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
77,
79
],
[
81
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
113
],
[
115,
117,
119
],
[
121
],
[
125
],
[
129,
131,
133
],
[
135
],
[
143
],
[
145,
147,
149
],
[
153
],
[
155,
157,
159,
161
],
[
163
],
[
167
],
[
169
],
[
171,
173,
175
],
[
177,
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189,
193
],
[
195
],
[
199
],
[
201
],
[
203
],
[
207
],
[
209
]
] |
6,964 |
static int decode_p_picture_primary_header(VC9Context *v)
{
/* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
GetBitContext *gb = &v->s.gb;
int lowquant, pqindex, status = 0;
pqindex = get_bits(gb, 5);
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
v->pq = pquant_table[0][pqindex];
else
{
v->pq = pquant_table[v->quantizer_mode-1][pqindex];
}
if (pqindex < 9) v->halfpq = get_bits(gb, 1);
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
v->pquantizer = get_bits(gb, 1);
av_log(v->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
v->pq, v->halfpq);
if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
#if HAS_ADVANCED_PROFILE
if (v->profile > PROFILE_MAIN)
{
if (v->postprocflag) v->postproc = get_bits(gb, 1);
}
else
#endif
if (v->multires) v->respic = get_bits(gb, 2);
lowquant = (v->pquantizer>12) ? 0 : 1;
v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
{
v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
v->lumscale = get_bits(gb, 6);
v->lumshift = get_bits(gb, 6);
}
return 0;
}
| true |
FFmpeg
|
bf2bc926f04dcdde0a22c137d08a0bb546e0179e
|
static int decode_p_picture_primary_header(VC9Context *v)
{
GetBitContext *gb = &v->s.gb;
int lowquant, pqindex, status = 0;
pqindex = get_bits(gb, 5);
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
v->pq = pquant_table[0][pqindex];
else
{
v->pq = pquant_table[v->quantizer_mode-1][pqindex];
}
if (pqindex < 9) v->halfpq = get_bits(gb, 1);
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
v->pquantizer = get_bits(gb, 1);
av_log(v->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
v->pq, v->halfpq);
if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
#if HAS_ADVANCED_PROFILE
if (v->profile > PROFILE_MAIN)
{
if (v->postprocflag) v->postproc = get_bits(gb, 1);
}
else
#endif
if (v->multires) v->respic = get_bits(gb, 2);
lowquant = (v->pquantizer>12) ? 0 : 1;
v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
{
v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
v->lumscale = get_bits(gb, 6);
v->lumshift = get_bits(gb, 6);
}
return 0;
}
|
{
"code": [
"#endif",
" if (v->multires) v->respic = get_bits(gb, 2);",
"#if HAS_ADVANCED_PROFILE",
" if (v->postprocflag) v->postproc = get_bits(gb, 1);",
"#endif",
" int lowquant, pqindex, status = 0;",
" return 0;"
],
"line_no": [
51,
53,
39,
45,
51,
9,
71
]
}
|
static int FUNC_0(VC9Context *VAR_0)
{
GetBitContext *gb = &VAR_0->s.gb;
int VAR_1, VAR_2, VAR_3 = 0;
VAR_2 = get_bits(gb, 5);
if (VAR_0->quantizer_mode == QUANT_FRAME_IMPLICIT)
VAR_0->pq = pquant_table[0][VAR_2];
else
{
VAR_0->pq = pquant_table[VAR_0->quantizer_mode-1][VAR_2];
}
if (VAR_2 < 9) VAR_0->halfpq = get_bits(gb, 1);
if (VAR_0->quantizer_mode == QUANT_FRAME_EXPLICIT)
VAR_0->pquantizer = get_bits(gb, 1);
av_log(VAR_0->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
VAR_0->pq, VAR_0->halfpq);
if (VAR_0->extended_mv == 1) VAR_0->mvrange = get_prefix(gb, 0, 3);
#if HAS_ADVANCED_PROFILE
if (VAR_0->profile > PROFILE_MAIN)
{
if (VAR_0->postprocflag) VAR_0->postproc = get_bits(gb, 1);
}
else
#endif
if (VAR_0->multires) VAR_0->respic = get_bits(gb, 2);
VAR_1 = (VAR_0->pquantizer>12) ? 0 : 1;
VAR_0->mv_mode = mv_pmode_table[VAR_1][get_prefix(gb, 1, 4)];
if (VAR_0->mv_mode == MV_PMODE_INTENSITY_COMP)
{
VAR_0->mv_mode2 = mv_pmode_table[VAR_1][get_prefix(gb, 1, 3)];
VAR_0->lumscale = get_bits(gb, 6);
VAR_0->lumshift = get_bits(gb, 6);
}
return 0;
}
|
[
"static int FUNC_0(VC9Context *VAR_0)\n{",
"GetBitContext *gb = &VAR_0->s.gb;",
"int VAR_1, VAR_2, VAR_3 = 0;",
"VAR_2 = get_bits(gb, 5);",
"if (VAR_0->quantizer_mode == QUANT_FRAME_IMPLICIT)\nVAR_0->pq = pquant_table[0][VAR_2];",
"else\n{",
"VAR_0->pq = pquant_table[VAR_0->quantizer_mode-1][VAR_2];",
"}",
"if (VAR_2 < 9) VAR_0->halfpq = get_bits(gb, 1);",
"if (VAR_0->quantizer_mode == QUANT_FRAME_EXPLICIT)\nVAR_0->pquantizer = get_bits(gb, 1);",
"av_log(VAR_0->s.avctx, AV_LOG_DEBUG, \"P Frame: QP=%i (+%i/2)\\n\",\nVAR_0->pq, VAR_0->halfpq);",
"if (VAR_0->extended_mv == 1) VAR_0->mvrange = get_prefix(gb, 0, 3);",
"#if HAS_ADVANCED_PROFILE\nif (VAR_0->profile > PROFILE_MAIN)\n{",
"if (VAR_0->postprocflag) VAR_0->postproc = get_bits(gb, 1);",
"}",
"else\n#endif\nif (VAR_0->multires) VAR_0->respic = get_bits(gb, 2);",
"VAR_1 = (VAR_0->pquantizer>12) ? 0 : 1;",
"VAR_0->mv_mode = mv_pmode_table[VAR_1][get_prefix(gb, 1, 4)];",
"if (VAR_0->mv_mode == MV_PMODE_INTENSITY_COMP)\n{",
"VAR_0->mv_mode2 = mv_pmode_table[VAR_1][get_prefix(gb, 1, 3)];",
"VAR_0->lumscale = get_bits(gb, 6);",
"VAR_0->lumshift = get_bits(gb, 6);",
"}",
"return 0;",
"}"
] |
[
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0
] |
[
[
1,
3
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29,
31
],
[
33,
35
],
[
37
],
[
39,
41,
43
],
[
45
],
[
47
],
[
49,
51,
53
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
]
] |
6,965 |
static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){
RMDemuxContext *rm = s->priv_data;
ByteIOContext *pb = s->pb;
int len, num, res, i;
AVStream *st;
uint32_t state=0xFFFFFFFF;
while(!url_feof(pb)){
*pos= url_ftell(pb) - 3;
if(rm->remaining_len > 0){
num= rm->current_stream;
len= rm->remaining_len;
*timestamp = AV_NOPTS_VALUE;
*flags= 0;
}else{
state= (state<<8) + get_byte(pb);
if(state == MKBETAG('I', 'N', 'D', 'X')){
len = get_be16(pb) - 6;
if(len<0)
continue;
goto skip;
}
if(state > (unsigned)0xFFFF || state < 12)
continue;
len=state;
state= 0xFFFFFFFF;
num = get_be16(pb);
*timestamp = get_be32(pb);
res= get_byte(pb); /* reserved */
*flags = get_byte(pb); /* flags */
len -= 12;
}
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
if (num == st->id)
break;
}
if (i == s->nb_streams) {
skip:
/* skip packet if unknown number */
url_fskip(pb, len);
rm->remaining_len -= len;
continue;
}
*stream_index= i;
return len;
}
return -1;
}
| true |
FFmpeg
|
b8cc5a9fdfbc514a0d6e02b7c5380853a50ae1ac
|
static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){
RMDemuxContext *rm = s->priv_data;
ByteIOContext *pb = s->pb;
int len, num, res, i;
AVStream *st;
uint32_t state=0xFFFFFFFF;
while(!url_feof(pb)){
*pos= url_ftell(pb) - 3;
if(rm->remaining_len > 0){
num= rm->current_stream;
len= rm->remaining_len;
*timestamp = AV_NOPTS_VALUE;
*flags= 0;
}else{
state= (state<<8) + get_byte(pb);
if(state == MKBETAG('I', 'N', 'D', 'X')){
len = get_be16(pb) - 6;
if(len<0)
continue;
goto skip;
}
if(state > (unsigned)0xFFFF || state < 12)
continue;
len=state;
state= 0xFFFFFFFF;
num = get_be16(pb);
*timestamp = get_be32(pb);
res= get_byte(pb);
*flags = get_byte(pb);
len -= 12;
}
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
if (num == st->id)
break;
}
if (i == s->nb_streams) {
skip:
url_fskip(pb, len);
rm->remaining_len -= len;
continue;
}
*stream_index= i;
return len;
}
return -1;
}
|
{
"code": [
" rm->remaining_len -= len;"
],
"line_no": [
93
]
}
|
static int FUNC_0(AVFormatContext *VAR_0, int64_t *VAR_1, int *VAR_2, int *VAR_3, int64_t *VAR_4){
RMDemuxContext *rm = VAR_0->priv_data;
ByteIOContext *pb = VAR_0->pb;
int VAR_5, VAR_6, VAR_7, VAR_8;
AVStream *st;
uint32_t state=0xFFFFFFFF;
while(!url_feof(pb)){
*VAR_4= url_ftell(pb) - 3;
if(rm->remaining_len > 0){
VAR_6= rm->current_stream;
VAR_5= rm->remaining_len;
*VAR_1 = AV_NOPTS_VALUE;
*VAR_2= 0;
}else{
state= (state<<8) + get_byte(pb);
if(state == MKBETAG('I', 'N', 'D', 'X')){
VAR_5 = get_be16(pb) - 6;
if(VAR_5<0)
continue;
goto skip;
}
if(state > (unsigned)0xFFFF || state < 12)
continue;
VAR_5=state;
state= 0xFFFFFFFF;
VAR_6 = get_be16(pb);
*VAR_1 = get_be32(pb);
VAR_7= get_byte(pb);
*VAR_2 = get_byte(pb);
VAR_5 -= 12;
}
for(VAR_8=0;VAR_8<VAR_0->nb_streams;VAR_8++) {
st = VAR_0->streams[VAR_8];
if (VAR_6 == st->id)
break;
}
if (VAR_8 == VAR_0->nb_streams) {
skip:
url_fskip(pb, VAR_5);
rm->remaining_len -= VAR_5;
continue;
}
*VAR_3= VAR_8;
return VAR_5;
}
return -1;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, int64_t *VAR_1, int *VAR_2, int *VAR_3, int64_t *VAR_4){",
"RMDemuxContext *rm = VAR_0->priv_data;",
"ByteIOContext *pb = VAR_0->pb;",
"int VAR_5, VAR_6, VAR_7, VAR_8;",
"AVStream *st;",
"uint32_t state=0xFFFFFFFF;",
"while(!url_feof(pb)){",
"*VAR_4= url_ftell(pb) - 3;",
"if(rm->remaining_len > 0){",
"VAR_6= rm->current_stream;",
"VAR_5= rm->remaining_len;",
"*VAR_1 = AV_NOPTS_VALUE;",
"*VAR_2= 0;",
"}else{",
"state= (state<<8) + get_byte(pb);",
"if(state == MKBETAG('I', 'N', 'D', 'X')){",
"VAR_5 = get_be16(pb) - 6;",
"if(VAR_5<0)\ncontinue;",
"goto skip;",
"}",
"if(state > (unsigned)0xFFFF || state < 12)\ncontinue;",
"VAR_5=state;",
"state= 0xFFFFFFFF;",
"VAR_6 = get_be16(pb);",
"*VAR_1 = get_be32(pb);",
"VAR_7= get_byte(pb);",
"*VAR_2 = get_byte(pb);",
"VAR_5 -= 12;",
"}",
"for(VAR_8=0;VAR_8<VAR_0->nb_streams;VAR_8++) {",
"st = VAR_0->streams[VAR_8];",
"if (VAR_6 == st->id)\nbreak;",
"}",
"if (VAR_8 == VAR_0->nb_streams) {",
"skip:\nurl_fskip(pb, VAR_5);",
"rm->remaining_len -= VAR_5;",
"continue;",
"}",
"*VAR_3= VAR_8;",
"return VAR_5;",
"}",
"return -1;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
49,
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
87,
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
]
] |
6,966 |
int mpeg4_decode_picture_header(MpegEncContext * s)
{
int time_incr, startcode, state, v;
redo:
/* search next start code */
align_get_bits(&s->gb);
state = 0xff;
for(;;) {
v = get_bits(&s->gb, 8);
if (state == 0x000001) {
state = ((state << 8) | v) & 0xffffff;
startcode = state;
break;
}
state = ((state << 8) | v) & 0xffffff;
if( get_bits_count(&s->gb) > s->gb.size*8-32){
printf("no VOP startcode found\n");
return -1;
}
}
//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
if (startcode == 0x120) { // Video Object Layer
int width, height, vo_ver_id;
/* vol header */
skip_bits(&s->gb, 1); /* random access */
skip_bits(&s->gb, 8); /* vo_type */
if (get_bits1(&s->gb) != 0) { /* is_ol_id */
vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
skip_bits(&s->gb, 3); /* vo_priority */
} else {
vo_ver_id = 1;
}
s->aspect_ratio_info= get_bits(&s->gb, 4);
if(s->aspect_ratio_info == EXTENDET_PAR){
skip_bits(&s->gb, 8); //par_width
skip_bits(&s->gb, 8); // par_height
}
if(get_bits1(&s->gb)){ /* vol control parameter */
printf("vol control parameter not supported\n");
return -1;
}
s->shape = get_bits(&s->gb, 2); /* vol shape */
if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
printf("Gray shape not supported\n");
skip_bits(&s->gb, 4); //video_object_layer_shape_extension
}
skip_bits1(&s->gb); /* marker */
s->time_increment_resolution = get_bits(&s->gb, 16);
s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
if (s->time_increment_bits < 1)
s->time_increment_bits = 1;
skip_bits1(&s->gb); /* marker */
if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
skip_bits(&s->gb, s->time_increment_bits);
}
if (s->shape != BIN_ONLY_SHAPE) {
if (s->shape == RECT_SHAPE) {
skip_bits1(&s->gb); /* marker */
width = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
height = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
if(width && height){ /* they should be non zero but who knows ... */
s->width = width;
s->height = height;
// printf("%d %d\n", width, height);
}
}
if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */
if(!get_bits1(&s->gb)) printf("OBMC not supported\n"); /* OBMC Disable */
if (vo_ver_id == 1) {
s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
} else {
s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
}
if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
if(s->vol_sprite_usage==STATIC_SPRITE){
s->sprite_width = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
s->sprite_height= get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
s->sprite_left = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
s->sprite_top = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
}
s->num_sprite_warping_points= get_bits(&s->gb, 6);
s->sprite_warping_accuracy = get_bits(&s->gb, 2);
s->sprite_brightness_change= get_bits1(&s->gb);
if(s->vol_sprite_usage==STATIC_SPRITE)
s->low_latency_sprite= get_bits1(&s->gb);
}
// FIXME sadct disable bit if verid!=1 && shape not rect
if (get_bits1(&s->gb) == 1) { /* not_8_bit */
s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
} else {
s->quant_precision = 5;
}
// FIXME a bunch of grayscale shape things
if(get_bits1(&s->gb)) printf("Quant-Type not supported\n"); /* vol_quant_type */ //FIXME
if(vo_ver_id != 1)
s->quarter_sample= get_bits1(&s->gb);
else s->quarter_sample=0;
if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
#if 0
if(get_bits1(&s->gb)) printf("resync disable\n");
#else
skip_bits1(&s->gb); /* resync_marker_disabled */
#endif
s->data_partioning= get_bits1(&s->gb);
if(s->data_partioning){
printf("data partitioning not supported\n");
skip_bits1(&s->gb); // reversible vlc
}
if(vo_ver_id != 1) {
s->new_pred= get_bits1(&s->gb);
if(s->new_pred){
printf("new pred not supported\n");
skip_bits(&s->gb, 2); /* requested upstream message type */
skip_bits1(&s->gb); /* newpred segment type */
}
s->reduced_res_vop= get_bits1(&s->gb);
if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
}
else{
s->new_pred=0;
s->reduced_res_vop= 0;
}
s->scalability= get_bits1(&s->gb);
if (s->scalability) {
printf("bad scalability!!!\n");
return -1;
}
}
//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
goto redo;
} else if (startcode == 0x1b2) { //userdata
char buf[256];
int i;
int e;
int ver, build;
//printf("user Data %X\n", show_bits(&s->gb, 32));
buf[0]= show_bits(&s->gb, 8);
for(i=1; i<256; i++){
buf[i]= show_bits(&s->gb, 16)&0xFF;
if(buf[i]==0) break;
skip_bits(&s->gb, 8);
}
buf[255]=0;
e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
if(e==2){
s->divx_version= ver;
s->divx_build= build;
if(s->picture_number==0){
printf("This file was encoded with DivX%d Build%d\n", ver, build);
if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
}else{
printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
"using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
}
}
}
//printf("User Data: %s\n", buf);
goto redo;
} else if (startcode != 0x1b6) { //VOP
goto redo;
}
s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */
//printf("pic: %d\n", s->pict_type);
time_incr=0;
while (get_bits1(&s->gb) != 0)
time_incr++;
check_marker(&s->gb, "before time_increment");
s->time_increment= get_bits(&s->gb, s->time_increment_bits);
if(s->pict_type!=B_TYPE){
s->time_base+= time_incr;
s->last_non_b_time[1]= s->last_non_b_time[0];
s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
}else{
s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
s->time+= s->time_increment;
}
if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
if(get_bits1(&s->gb)) break;
}
printf("my guess is %d bits ;)\n",s->time_increment_bits);
}
/* vop coded */
if (get_bits1(&s->gb) != 1)
goto redo;
//printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
//s->time, s->last_non_b_time[0], s->last_non_b_time[1]);
if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
/* rounding type for motion estimation */
s->no_rounding = get_bits1(&s->gb);
} else {
s->no_rounding = 0;
}
//FIXME reduced res stuff
if (s->shape != RECT_SHAPE) {
if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
int width, height, hor_spat_ref, ver_spat_ref;
width = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
height = get_bits(&s->gb, 13);
skip_bits1(&s->gb); /* marker */
hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
skip_bits1(&s->gb); /* marker */
ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
}
skip_bits1(&s->gb); /* change_CR_disable */
if (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8); /* constant_alpha_value */
}
}
//FIXME complexity estimation stuff
if (s->shape != BIN_ONLY_SHAPE) {
skip_bits(&s->gb, 3); /* intra dc VLC threshold */
//FIXME interlaced specific bits
}
if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
if(s->num_sprite_warping_points){
mpeg4_decode_sprite_trajectory(s);
}
if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
}
if (s->shape != BIN_ONLY_SHAPE) {
/* note: we do not use quant_precision to avoid problem if no
MPEG4 vol header as it is found on some old opendivx
movies */
s->qscale = get_bits(&s->gb, 5);
if(s->qscale==0){
printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
return -1; // makes no sense to continue, as there is nothing left from the image then
}
if (s->pict_type != I_TYPE) {
s->f_code = get_bits(&s->gb, 3); /* fcode_for */
if(s->f_code==0){
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
return -1; // makes no sense to continue, as the MV decoding will break very quickly
}
}
if (s->pict_type == B_TYPE) {
s->b_code = get_bits(&s->gb, 3);
//printf("b-code %d\n", s->b_code);
}
//printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
if(!s->scalability){
if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
skip_bits1(&s->gb); // vop shape coding type
}
}
}
s->picture_number++; // better than pic number==0 allways ;)
return 0;
}
| true |
FFmpeg
|
11ce88346b1ae4da21b581baf1b4eb784d842547
|
int mpeg4_decode_picture_header(MpegEncContext * s)
{
int time_incr, startcode, state, v;
redo:
align_get_bits(&s->gb);
state = 0xff;
for(;;) {
v = get_bits(&s->gb, 8);
if (state == 0x000001) {
state = ((state << 8) | v) & 0xffffff;
startcode = state;
break;
}
state = ((state << 8) | v) & 0xffffff;
if( get_bits_count(&s->gb) > s->gb.size*8-32){
printf("no VOP startcode found\n");
return -1;
}
}
if (startcode == 0x120) {
int width, height, vo_ver_id;
skip_bits(&s->gb, 1);
skip_bits(&s->gb, 8);
if (get_bits1(&s->gb) != 0) {
vo_ver_id = get_bits(&s->gb, 4);
skip_bits(&s->gb, 3);
} else {
vo_ver_id = 1;
}
s->aspect_ratio_info= get_bits(&s->gb, 4);
if(s->aspect_ratio_info == EXTENDET_PAR){
skip_bits(&s->gb, 8);
skip_bits(&s->gb, 8);
}
if(get_bits1(&s->gb)){
printf("vol control parameter not supported\n");
return -1;
}
s->shape = get_bits(&s->gb, 2);
if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
printf("Gray shape not supported\n");
skip_bits(&s->gb, 4);
}
skip_bits1(&s->gb);
s->time_increment_resolution = get_bits(&s->gb, 16);
s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
if (s->time_increment_bits < 1)
s->time_increment_bits = 1;
skip_bits1(&s->gb);
if (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, s->time_increment_bits);
}
if (s->shape != BIN_ONLY_SHAPE) {
if (s->shape == RECT_SHAPE) {
skip_bits1(&s->gb);
width = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
height = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
if(width && height){
s->width = width;
s->height = height;
}
}
if(get_bits1(&s->gb)) printf("interlaced not supported\n");
if(!get_bits1(&s->gb)) printf("OBMC not supported\n");
if (vo_ver_id == 1) {
s->vol_sprite_usage = get_bits1(&s->gb);
} else {
s->vol_sprite_usage = get_bits(&s->gb, 2);
}
if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
if(s->vol_sprite_usage==STATIC_SPRITE){
s->sprite_width = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
s->sprite_height= get_bits(&s->gb, 13);
skip_bits1(&s->gb);
s->sprite_left = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
s->sprite_top = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
}
s->num_sprite_warping_points= get_bits(&s->gb, 6);
s->sprite_warping_accuracy = get_bits(&s->gb, 2);
s->sprite_brightness_change= get_bits1(&s->gb);
if(s->vol_sprite_usage==STATIC_SPRITE)
s->low_latency_sprite= get_bits1(&s->gb);
}
if (get_bits1(&s->gb) == 1) {
s->quant_precision = get_bits(&s->gb, 4);
if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n");
} else {
s->quant_precision = 5;
}
if(get_bits1(&s->gb)) printf("Quant-Type not supported\n");
if(vo_ver_id != 1)
s->quarter_sample= get_bits1(&s->gb);
else s->quarter_sample=0;
if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
#if 0
if(get_bits1(&s->gb)) printf("resync disable\n");
#else
skip_bits1(&s->gb);
#endif
s->data_partioning= get_bits1(&s->gb);
if(s->data_partioning){
printf("data partitioning not supported\n");
skip_bits1(&s->gb);
}
if(vo_ver_id != 1) {
s->new_pred= get_bits1(&s->gb);
if(s->new_pred){
printf("new pred not supported\n");
skip_bits(&s->gb, 2);
skip_bits1(&s->gb);
}
s->reduced_res_vop= get_bits1(&s->gb);
if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
}
else{
s->new_pred=0;
s->reduced_res_vop= 0;
}
s->scalability= get_bits1(&s->gb);
if (s->scalability) {
printf("bad scalability!!!\n");
return -1;
}
}
goto redo;
} else if (startcode == 0x1b2) {
char buf[256];
int i;
int e;
int ver, build;
buf[0]= show_bits(&s->gb, 8);
for(i=1; i<256; i++){
buf[i]= show_bits(&s->gb, 16)&0xFF;
if(buf[i]==0) break;
skip_bits(&s->gb, 8);
}
buf[255]=0;
e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
if(e==2){
s->divx_version= ver;
s->divx_build= build;
if(s->picture_number==0){
printf("This file was encoded with DivX%d Build%d\n", ver, build);
if(ver==500 && build==413){
printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
}else{
printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
"using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
}
}
}
goto redo;
} else if (startcode != 0x1b6) {
goto redo;
}
s->pict_type = get_bits(&s->gb, 2) + 1;
time_incr=0;
while (get_bits1(&s->gb) != 0)
time_incr++;
check_marker(&s->gb, "before time_increment");
s->time_increment= get_bits(&s->gb, s->time_increment_bits);
if(s->pict_type!=B_TYPE){
s->time_base+= time_incr;
s->last_non_b_time[1]= s->last_non_b_time[0];
s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
}else{
s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
s->time+= s->time_increment;
}
if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
if(get_bits1(&s->gb)) break;
}
printf("my guess is %d bits ;)\n",s->time_increment_bits);
}
if (get_bits1(&s->gb) != 1)
goto redo;
if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
s->no_rounding = get_bits1(&s->gb);
} else {
s->no_rounding = 0;
}
reduced res stuff
if (s->shape != RECT_SHAPE) {
if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
int width, height, hor_spat_ref, ver_spat_ref;
width = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
height = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
hor_spat_ref = get_bits(&s->gb, 13);
skip_bits1(&s->gb);
ver_spat_ref = get_bits(&s->gb, 13);
}
skip_bits1(&s->gb);
if (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
}
}
complexity estimation stuff
if (s->shape != BIN_ONLY_SHAPE) {
skip_bits(&s->gb, 3);
interlaced specific bits
}
if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
if(s->num_sprite_warping_points){
mpeg4_decode_sprite_trajectory(s);
}
if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
}
if (s->shape != BIN_ONLY_SHAPE) {
s->qscale = get_bits(&s->gb, 5);
if(s->qscale==0){
printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
return -1;
}
if (s->pict_type != I_TYPE) {
s->f_code = get_bits(&s->gb, 3);
if(s->f_code==0){
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
return -1;
}
}
if (s->pict_type == B_TYPE) {
s->b_code = get_bits(&s->gb, 3);
}
if(!s->scalability){
if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
skip_bits1(&s->gb);
}
}
}
s->picture_number++;
return 0;
}
|
{
"code": [],
"line_no": []
}
|
int FUNC_0(MpegEncContext * VAR_0)
{
int VAR_1, VAR_2, VAR_3, VAR_4;
redo:
align_get_bits(&VAR_0->gb);
VAR_3 = 0xff;
for(;;) {
VAR_4 = get_bits(&VAR_0->gb, 8);
if (VAR_3 == 0x000001) {
VAR_3 = ((VAR_3 << 8) | VAR_4) & 0xffffff;
VAR_2 = VAR_3;
break;
}
VAR_3 = ((VAR_3 << 8) | VAR_4) & 0xffffff;
if( get_bits_count(&VAR_0->gb) > VAR_0->gb.size*8-32){
printf("no VOP VAR_2 found\n");
return -1;
}
}
if (VAR_2 == 0x120) {
int VAR_5, VAR_6, VAR_7;
skip_bits(&VAR_0->gb, 1);
skip_bits(&VAR_0->gb, 8);
if (get_bits1(&VAR_0->gb) != 0) {
VAR_7 = get_bits(&VAR_0->gb, 4);
skip_bits(&VAR_0->gb, 3);
} else {
VAR_7 = 1;
}
VAR_0->aspect_ratio_info= get_bits(&VAR_0->gb, 4);
if(VAR_0->aspect_ratio_info == EXTENDET_PAR){
skip_bits(&VAR_0->gb, 8);
skip_bits(&VAR_0->gb, 8);
}
if(get_bits1(&VAR_0->gb)){
printf("vol control parameter not supported\n");
return -1;
}
VAR_0->shape = get_bits(&VAR_0->gb, 2);
if(VAR_0->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
if(VAR_0->shape == GRAY_SHAPE && VAR_7 != 1){
printf("Gray shape not supported\n");
skip_bits(&VAR_0->gb, 4);
}
skip_bits1(&VAR_0->gb);
VAR_0->time_increment_resolution = get_bits(&VAR_0->gb, 16);
VAR_0->time_increment_bits = av_log2(VAR_0->time_increment_resolution - 1) + 1;
if (VAR_0->time_increment_bits < 1)
VAR_0->time_increment_bits = 1;
skip_bits1(&VAR_0->gb);
if (get_bits1(&VAR_0->gb) != 0) {
skip_bits(&VAR_0->gb, VAR_0->time_increment_bits);
}
if (VAR_0->shape != BIN_ONLY_SHAPE) {
if (VAR_0->shape == RECT_SHAPE) {
skip_bits1(&VAR_0->gb);
VAR_5 = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
VAR_6 = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
if(VAR_5 && VAR_6){
VAR_0->VAR_5 = VAR_5;
VAR_0->VAR_6 = VAR_6;
}
}
if(get_bits1(&VAR_0->gb)) printf("interlaced not supported\n");
if(!get_bits1(&VAR_0->gb)) printf("OBMC not supported\n");
if (VAR_7 == 1) {
VAR_0->vol_sprite_usage = get_bits1(&VAR_0->gb);
} else {
VAR_0->vol_sprite_usage = get_bits(&VAR_0->gb, 2);
}
if(VAR_0->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
if(VAR_0->vol_sprite_usage==STATIC_SPRITE || VAR_0->vol_sprite_usage==GMC_SPRITE){
if(VAR_0->vol_sprite_usage==STATIC_SPRITE){
VAR_0->sprite_width = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
VAR_0->sprite_height= get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
VAR_0->sprite_left = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
VAR_0->sprite_top = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
}
VAR_0->num_sprite_warping_points= get_bits(&VAR_0->gb, 6);
VAR_0->sprite_warping_accuracy = get_bits(&VAR_0->gb, 2);
VAR_0->sprite_brightness_change= get_bits1(&VAR_0->gb);
if(VAR_0->vol_sprite_usage==STATIC_SPRITE)
VAR_0->low_latency_sprite= get_bits1(&VAR_0->gb);
}
if (get_bits1(&VAR_0->gb) == 1) {
VAR_0->quant_precision = get_bits(&VAR_0->gb, 4);
if(get_bits(&VAR_0->gb, 4)!=8) printf("N-bit not supported\n");
} else {
VAR_0->quant_precision = 5;
}
if(get_bits1(&VAR_0->gb)) printf("Quant-Type not supported\n");
if(VAR_7 != 1)
VAR_0->quarter_sample= get_bits1(&VAR_0->gb);
else VAR_0->quarter_sample=0;
if(!get_bits1(&VAR_0->gb)) printf("Complexity estimation not supported\n");
#if 0
if(get_bits1(&VAR_0->gb)) printf("resync disable\n");
#else
skip_bits1(&VAR_0->gb);
#endif
VAR_0->data_partioning= get_bits1(&VAR_0->gb);
if(VAR_0->data_partioning){
printf("data partitioning not supported\n");
skip_bits1(&VAR_0->gb);
}
if(VAR_7 != 1) {
VAR_0->new_pred= get_bits1(&VAR_0->gb);
if(VAR_0->new_pred){
printf("new pred not supported\n");
skip_bits(&VAR_0->gb, 2);
skip_bits1(&VAR_0->gb);
}
VAR_0->reduced_res_vop= get_bits1(&VAR_0->gb);
if(VAR_0->reduced_res_vop) printf("reduced resolution VOP not supported\n");
}
else{
VAR_0->new_pred=0;
VAR_0->reduced_res_vop= 0;
}
VAR_0->scalability= get_bits1(&VAR_0->gb);
if (VAR_0->scalability) {
printf("bad scalability!!!\n");
return -1;
}
}
goto redo;
} else if (VAR_2 == 0x1b2) {
char VAR_8[256];
int VAR_9;
int VAR_10;
int VAR_11, VAR_12;
VAR_8[0]= show_bits(&VAR_0->gb, 8);
for(VAR_9=1; VAR_9<256; VAR_9++){
VAR_8[VAR_9]= show_bits(&VAR_0->gb, 16)&0xFF;
if(VAR_8[VAR_9]==0) break;
skip_bits(&VAR_0->gb, 8);
}
VAR_8[255]=0;
VAR_10=sscanf(VAR_8, "DivX%dBuild%d", &VAR_11, &VAR_12);
if(VAR_10==2){
VAR_0->divx_version= VAR_11;
VAR_0->divx_build= VAR_12;
if(VAR_0->picture_number==0){
printf("This file was encoded with DivX%d Build%d\n", VAR_11, VAR_12);
if(VAR_11==500 && VAR_12==413){
printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
}else{
printf("hmm, VAR_9 havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
"using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
}
}
}
goto redo;
} else if (VAR_2 != 0x1b6) {
goto redo;
}
VAR_0->pict_type = get_bits(&VAR_0->gb, 2) + 1;
VAR_1=0;
while (get_bits1(&VAR_0->gb) != 0)
VAR_1++;
check_marker(&VAR_0->gb, "before time_increment");
VAR_0->time_increment= get_bits(&VAR_0->gb, VAR_0->time_increment_bits);
if(VAR_0->pict_type!=B_TYPE){
VAR_0->time_base+= VAR_1;
VAR_0->last_non_b_time[1]= VAR_0->last_non_b_time[0];
VAR_0->last_non_b_time[0]= VAR_0->time_base*VAR_0->time_increment_resolution + VAR_0->time_increment;
}else{
VAR_0->time= (VAR_0->last_non_b_time[1]/VAR_0->time_increment_resolution + VAR_1)*VAR_0->time_increment_resolution;
VAR_0->time+= VAR_0->time_increment;
}
if(check_marker(&VAR_0->gb, "before vop_coded")==0 && VAR_0->picture_number==0){
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
for(VAR_0->time_increment_bits++ ;VAR_0->time_increment_bits<16; VAR_0->time_increment_bits++){
if(get_bits1(&VAR_0->gb)) break;
}
printf("my guess is %d bits ;)\n",VAR_0->time_increment_bits);
}
if (get_bits1(&VAR_0->gb) != 1)
goto redo;
if (VAR_0->shape != BIN_ONLY_SHAPE && ( VAR_0->pict_type == P_TYPE
|| (VAR_0->pict_type == S_TYPE && VAR_0->vol_sprite_usage==GMC_SPRITE))) {
VAR_0->no_rounding = get_bits1(&VAR_0->gb);
} else {
VAR_0->no_rounding = 0;
}
reduced res stuff
if (VAR_0->shape != RECT_SHAPE) {
if (VAR_0->vol_sprite_usage != 1 || VAR_0->pict_type != I_TYPE) {
int VAR_5, VAR_6, hor_spat_ref, ver_spat_ref;
VAR_5 = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
VAR_6 = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
hor_spat_ref = get_bits(&VAR_0->gb, 13);
skip_bits1(&VAR_0->gb);
ver_spat_ref = get_bits(&VAR_0->gb, 13);
}
skip_bits1(&VAR_0->gb);
if (get_bits1(&VAR_0->gb) != 0) {
skip_bits(&VAR_0->gb, 8);
}
}
complexity estimation stuff
if (VAR_0->shape != BIN_ONLY_SHAPE) {
skip_bits(&VAR_0->gb, 3);
interlaced specific bits
}
if(VAR_0->pict_type == S_TYPE && (VAR_0->vol_sprite_usage==STATIC_SPRITE || VAR_0->vol_sprite_usage==GMC_SPRITE)){
if(VAR_0->num_sprite_warping_points){
mpeg4_decode_sprite_trajectory(VAR_0);
}
if(VAR_0->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
if(VAR_0->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
}
if (VAR_0->shape != BIN_ONLY_SHAPE) {
VAR_0->qscale = get_bits(&VAR_0->gb, 5);
if(VAR_0->qscale==0){
printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
return -1;
}
if (VAR_0->pict_type != I_TYPE) {
VAR_0->f_code = get_bits(&VAR_0->gb, 3);
if(VAR_0->f_code==0){
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
return -1;
}
}
if (VAR_0->pict_type == B_TYPE) {
VAR_0->b_code = get_bits(&VAR_0->gb, 3);
}
if(!VAR_0->scalability){
if (VAR_0->shape!=RECT_SHAPE && VAR_0->pict_type!=I_TYPE) {
skip_bits1(&VAR_0->gb);
}
}
}
VAR_0->picture_number++;
return 0;
}
|
[
"int FUNC_0(MpegEncContext * VAR_0)\n{",
"int VAR_1, VAR_2, VAR_3, VAR_4;",
"redo:\nalign_get_bits(&VAR_0->gb);",
"VAR_3 = 0xff;",
"for(;;) {",
"VAR_4 = get_bits(&VAR_0->gb, 8);",
"if (VAR_3 == 0x000001) {",
"VAR_3 = ((VAR_3 << 8) | VAR_4) & 0xffffff;",
"VAR_2 = VAR_3;",
"break;",
"}",
"VAR_3 = ((VAR_3 << 8) | VAR_4) & 0xffffff;",
"if( get_bits_count(&VAR_0->gb) > VAR_0->gb.size*8-32){",
"printf(\"no VOP VAR_2 found\\n\");",
"return -1;",
"}",
"}",
"if (VAR_2 == 0x120) {",
"int VAR_5, VAR_6, VAR_7;",
"skip_bits(&VAR_0->gb, 1);",
"skip_bits(&VAR_0->gb, 8);",
"if (get_bits1(&VAR_0->gb) != 0) {",
"VAR_7 = get_bits(&VAR_0->gb, 4);",
"skip_bits(&VAR_0->gb, 3);",
"} else {",
"VAR_7 = 1;",
"}",
"VAR_0->aspect_ratio_info= get_bits(&VAR_0->gb, 4);",
"if(VAR_0->aspect_ratio_info == EXTENDET_PAR){",
"skip_bits(&VAR_0->gb, 8);",
"skip_bits(&VAR_0->gb, 8);",
"}",
"if(get_bits1(&VAR_0->gb)){",
"printf(\"vol control parameter not supported\\n\");",
"return -1;",
"}",
"VAR_0->shape = get_bits(&VAR_0->gb, 2);",
"if(VAR_0->shape != RECT_SHAPE) printf(\"only rectangular vol supported\\n\");",
"if(VAR_0->shape == GRAY_SHAPE && VAR_7 != 1){",
"printf(\"Gray shape not supported\\n\");",
"skip_bits(&VAR_0->gb, 4);",
"}",
"skip_bits1(&VAR_0->gb);",
"VAR_0->time_increment_resolution = get_bits(&VAR_0->gb, 16);",
"VAR_0->time_increment_bits = av_log2(VAR_0->time_increment_resolution - 1) + 1;",
"if (VAR_0->time_increment_bits < 1)\nVAR_0->time_increment_bits = 1;",
"skip_bits1(&VAR_0->gb);",
"if (get_bits1(&VAR_0->gb) != 0) {",
"skip_bits(&VAR_0->gb, VAR_0->time_increment_bits);",
"}",
"if (VAR_0->shape != BIN_ONLY_SHAPE) {",
"if (VAR_0->shape == RECT_SHAPE) {",
"skip_bits1(&VAR_0->gb);",
"VAR_5 = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"VAR_6 = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"if(VAR_5 && VAR_6){",
"VAR_0->VAR_5 = VAR_5;",
"VAR_0->VAR_6 = VAR_6;",
"}",
"}",
"if(get_bits1(&VAR_0->gb)) printf(\"interlaced not supported\\n\");",
"if(!get_bits1(&VAR_0->gb)) printf(\"OBMC not supported\\n\");",
"if (VAR_7 == 1) {",
"VAR_0->vol_sprite_usage = get_bits1(&VAR_0->gb);",
"} else {",
"VAR_0->vol_sprite_usage = get_bits(&VAR_0->gb, 2);",
"}",
"if(VAR_0->vol_sprite_usage==STATIC_SPRITE) printf(\"Static Sprites not supported\\n\");",
"if(VAR_0->vol_sprite_usage==STATIC_SPRITE || VAR_0->vol_sprite_usage==GMC_SPRITE){",
"if(VAR_0->vol_sprite_usage==STATIC_SPRITE){",
"VAR_0->sprite_width = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"VAR_0->sprite_height= get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"VAR_0->sprite_left = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"VAR_0->sprite_top = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"}",
"VAR_0->num_sprite_warping_points= get_bits(&VAR_0->gb, 6);",
"VAR_0->sprite_warping_accuracy = get_bits(&VAR_0->gb, 2);",
"VAR_0->sprite_brightness_change= get_bits1(&VAR_0->gb);",
"if(VAR_0->vol_sprite_usage==STATIC_SPRITE)\nVAR_0->low_latency_sprite= get_bits1(&VAR_0->gb);",
"}",
"if (get_bits1(&VAR_0->gb) == 1) {",
"VAR_0->quant_precision = get_bits(&VAR_0->gb, 4);",
"if(get_bits(&VAR_0->gb, 4)!=8) printf(\"N-bit not supported\\n\");",
"} else {",
"VAR_0->quant_precision = 5;",
"}",
"if(get_bits1(&VAR_0->gb)) printf(\"Quant-Type not supported\\n\");",
"if(VAR_7 != 1)\nVAR_0->quarter_sample= get_bits1(&VAR_0->gb);",
"else VAR_0->quarter_sample=0;",
"if(!get_bits1(&VAR_0->gb)) printf(\"Complexity estimation not supported\\n\");",
"#if 0\nif(get_bits1(&VAR_0->gb)) printf(\"resync disable\\n\");",
"#else\nskip_bits1(&VAR_0->gb);",
"#endif\nVAR_0->data_partioning= get_bits1(&VAR_0->gb);",
"if(VAR_0->data_partioning){",
"printf(\"data partitioning not supported\\n\");",
"skip_bits1(&VAR_0->gb);",
"}",
"if(VAR_7 != 1) {",
"VAR_0->new_pred= get_bits1(&VAR_0->gb);",
"if(VAR_0->new_pred){",
"printf(\"new pred not supported\\n\");",
"skip_bits(&VAR_0->gb, 2);",
"skip_bits1(&VAR_0->gb);",
"}",
"VAR_0->reduced_res_vop= get_bits1(&VAR_0->gb);",
"if(VAR_0->reduced_res_vop) printf(\"reduced resolution VOP not supported\\n\");",
"}",
"else{",
"VAR_0->new_pred=0;",
"VAR_0->reduced_res_vop= 0;",
"}",
"VAR_0->scalability= get_bits1(&VAR_0->gb);",
"if (VAR_0->scalability) {",
"printf(\"bad scalability!!!\\n\");",
"return -1;",
"}",
"}",
"goto redo;",
"} else if (VAR_2 == 0x1b2) {",
"char VAR_8[256];",
"int VAR_9;",
"int VAR_10;",
"int VAR_11, VAR_12;",
"VAR_8[0]= show_bits(&VAR_0->gb, 8);",
"for(VAR_9=1; VAR_9<256; VAR_9++){",
"VAR_8[VAR_9]= show_bits(&VAR_0->gb, 16)&0xFF;",
"if(VAR_8[VAR_9]==0) break;",
"skip_bits(&VAR_0->gb, 8);",
"}",
"VAR_8[255]=0;",
"VAR_10=sscanf(VAR_8, \"DivX%dBuild%d\", &VAR_11, &VAR_12);",
"if(VAR_10==2){",
"VAR_0->divx_version= VAR_11;",
"VAR_0->divx_build= VAR_12;",
"if(VAR_0->picture_number==0){",
"printf(\"This file was encoded with DivX%d Build%d\\n\", VAR_11, VAR_12);",
"if(VAR_11==500 && VAR_12==413){",
"printf(\"WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\\n\");",
"}else{",
"printf(\"hmm, VAR_9 havnt seen that version of divx yet, lets assume they fixed these bugs ...\\n\"\n\"using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\\n\");",
"}",
"}",
"}",
"goto redo;",
"} else if (VAR_2 != 0x1b6) {",
"goto redo;",
"}",
"VAR_0->pict_type = get_bits(&VAR_0->gb, 2) + 1;",
"VAR_1=0;",
"while (get_bits1(&VAR_0->gb) != 0)\nVAR_1++;",
"check_marker(&VAR_0->gb, \"before time_increment\");",
"VAR_0->time_increment= get_bits(&VAR_0->gb, VAR_0->time_increment_bits);",
"if(VAR_0->pict_type!=B_TYPE){",
"VAR_0->time_base+= VAR_1;",
"VAR_0->last_non_b_time[1]= VAR_0->last_non_b_time[0];",
"VAR_0->last_non_b_time[0]= VAR_0->time_base*VAR_0->time_increment_resolution + VAR_0->time_increment;",
"}else{",
"VAR_0->time= (VAR_0->last_non_b_time[1]/VAR_0->time_increment_resolution + VAR_1)*VAR_0->time_increment_resolution;",
"VAR_0->time+= VAR_0->time_increment;",
"}",
"if(check_marker(&VAR_0->gb, \"before vop_coded\")==0 && VAR_0->picture_number==0){",
"printf(\"hmm, seems the headers arnt complete, trying to guess time_increment_bits\\n\");",
"for(VAR_0->time_increment_bits++ ;VAR_0->time_increment_bits<16; VAR_0->time_increment_bits++){",
"if(get_bits1(&VAR_0->gb)) break;",
"}",
"printf(\"my guess is %d bits ;)\\n\",VAR_0->time_increment_bits);",
"}",
"if (get_bits1(&VAR_0->gb) != 1)\ngoto redo;",
"if (VAR_0->shape != BIN_ONLY_SHAPE && ( VAR_0->pict_type == P_TYPE\n|| (VAR_0->pict_type == S_TYPE && VAR_0->vol_sprite_usage==GMC_SPRITE))) {",
"VAR_0->no_rounding = get_bits1(&VAR_0->gb);",
"} else {",
"VAR_0->no_rounding = 0;",
"}",
"reduced res stuff\nif (VAR_0->shape != RECT_SHAPE) {",
"if (VAR_0->vol_sprite_usage != 1 || VAR_0->pict_type != I_TYPE) {",
"int VAR_5, VAR_6, hor_spat_ref, ver_spat_ref;",
"VAR_5 = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"VAR_6 = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"hor_spat_ref = get_bits(&VAR_0->gb, 13);",
"skip_bits1(&VAR_0->gb);",
"ver_spat_ref = get_bits(&VAR_0->gb, 13);",
"}",
"skip_bits1(&VAR_0->gb);",
"if (get_bits1(&VAR_0->gb) != 0) {",
"skip_bits(&VAR_0->gb, 8);",
"}",
"}",
"complexity estimation stuff\nif (VAR_0->shape != BIN_ONLY_SHAPE) {",
"skip_bits(&VAR_0->gb, 3);",
"interlaced specific bits\n}",
"if(VAR_0->pict_type == S_TYPE && (VAR_0->vol_sprite_usage==STATIC_SPRITE || VAR_0->vol_sprite_usage==GMC_SPRITE)){",
"if(VAR_0->num_sprite_warping_points){",
"mpeg4_decode_sprite_trajectory(VAR_0);",
"}",
"if(VAR_0->sprite_brightness_change) printf(\"sprite_brightness_change not supported\\n\");",
"if(VAR_0->vol_sprite_usage==STATIC_SPRITE) printf(\"static sprite not supported\\n\");",
"}",
"if (VAR_0->shape != BIN_ONLY_SHAPE) {",
"VAR_0->qscale = get_bits(&VAR_0->gb, 5);",
"if(VAR_0->qscale==0){",
"printf(\"Error, header damaged or not MPEG4 header (qscale=0)\\n\");",
"return -1;",
"}",
"if (VAR_0->pict_type != I_TYPE) {",
"VAR_0->f_code = get_bits(&VAR_0->gb, 3);",
"if(VAR_0->f_code==0){",
"printf(\"Error, header damaged or not MPEG4 header (f_code=0)\\n\");",
"return -1;",
"}",
"}",
"if (VAR_0->pict_type == B_TYPE) {",
"VAR_0->b_code = get_bits(&VAR_0->gb, 3);",
"}",
"if(!VAR_0->scalability){",
"if (VAR_0->shape!=RECT_SHAPE && VAR_0->pict_type!=I_TYPE) {",
"skip_bits1(&VAR_0->gb);",
"}",
"}",
"}",
"VAR_0->picture_number++;",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
107
],
[
109
],
[
111,
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199,
201
],
[
203
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
225
],
[
227,
229
],
[
231
],
[
235
],
[
237,
239
],
[
241,
243
],
[
245,
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283
],
[
285
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
303
],
[
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351,
353
],
[
355
],
[
357
],
[
359
],
[
363
],
[
365
],
[
367
],
[
369
],
[
373
],
[
377
],
[
379,
381
],
[
385
],
[
387
],
[
389
],
[
391
],
[
393
],
[
395
],
[
397
],
[
399
],
[
401
],
[
403
],
[
407
],
[
409
],
[
411
],
[
413
],
[
415
],
[
417
],
[
419
],
[
423,
425
],
[
431,
433
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445,
449
],
[
451
],
[
453
],
[
457
],
[
459
],
[
461
],
[
463
],
[
465
],
[
467
],
[
469
],
[
471
],
[
473
],
[
477
],
[
479
],
[
481
],
[
483
],
[
485,
489
],
[
491
],
[
493,
495
],
[
499
],
[
501
],
[
503
],
[
505
],
[
507
],
[
509
],
[
511
],
[
515
],
[
523
],
[
525
],
[
527
],
[
529
],
[
531
],
[
535
],
[
537
],
[
539
],
[
541
],
[
543
],
[
545
],
[
547
],
[
549
],
[
551
],
[
555
],
[
561
],
[
563
],
[
565
],
[
567
],
[
569
],
[
571
],
[
573
],
[
575
],
[
577
]
] |
6,968 |
static int encode_init(AVCodecContext * avctx){
WMACodecContext *s = avctx->priv_data;
int i, flags1, flags2;
uint8_t *extradata;
s->avctx = avctx;
if(avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
avctx->channels, MAX_CHANNELS);
return AVERROR(EINVAL);
}
if(avctx->bit_rate < 24*1000) {
av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n",
avctx->bit_rate);
return AVERROR(EINVAL);
}
/* extract flag infos */
flags1 = 0;
flags2 = 1;
if (avctx->codec->id == CODEC_ID_WMAV1) {
extradata= av_malloc(4);
avctx->extradata_size= 4;
AV_WL16(extradata, flags1);
AV_WL16(extradata+2, flags2);
} else if (avctx->codec->id == CODEC_ID_WMAV2) {
extradata= av_mallocz(10);
avctx->extradata_size= 10;
AV_WL32(extradata, flags1);
AV_WL16(extradata+4, flags2);
}else
assert(0);
avctx->extradata= extradata;
s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004;
ff_wma_init(avctx, flags2);
/* init MDCT */
for(i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
avctx->block_align=
s->block_align= avctx->bit_rate*(int64_t)s->frame_len / (avctx->sample_rate*8);
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", s->block_align, avctx->bit_rate, s->frame_len, avctx->sample_rate);
avctx->frame_size= s->frame_len;
return 0;
}
| true |
FFmpeg
|
c2b8dea1828f35c808adcf12615893d5c740bc0a
|
static int encode_init(AVCodecContext * avctx){
WMACodecContext *s = avctx->priv_data;
int i, flags1, flags2;
uint8_t *extradata;
s->avctx = avctx;
if(avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
avctx->channels, MAX_CHANNELS);
return AVERROR(EINVAL);
}
if(avctx->bit_rate < 24*1000) {
av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n",
avctx->bit_rate);
return AVERROR(EINVAL);
}
flags1 = 0;
flags2 = 1;
if (avctx->codec->id == CODEC_ID_WMAV1) {
extradata= av_malloc(4);
avctx->extradata_size= 4;
AV_WL16(extradata, flags1);
AV_WL16(extradata+2, flags2);
} else if (avctx->codec->id == CODEC_ID_WMAV2) {
extradata= av_mallocz(10);
avctx->extradata_size= 10;
AV_WL32(extradata, flags1);
AV_WL16(extradata+4, flags2);
}else
assert(0);
avctx->extradata= extradata;
s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004;
ff_wma_init(avctx, flags2);
for(i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
avctx->block_align=
s->block_align= avctx->bit_rate*(int64_t)s->frame_len / (avctx->sample_rate*8);
avctx->frame_size= s->frame_len;
return 0;
}
|
{
"code": [
" avctx->block_align=",
" s->block_align= avctx->bit_rate*(int64_t)s->frame_len / (avctx->sample_rate*8);"
],
"line_no": [
91,
93
]
}
|
static int FUNC_0(AVCodecContext * VAR_0){
WMACodecContext *s = VAR_0->priv_data;
int VAR_1, VAR_2, VAR_3;
uint8_t *extradata;
s->VAR_0 = VAR_0;
if(VAR_0->channels > MAX_CHANNELS) {
av_log(VAR_0, AV_LOG_ERROR, "too many channels: got %VAR_1, need %VAR_1 or fewer",
VAR_0->channels, MAX_CHANNELS);
return AVERROR(EINVAL);
}
if(VAR_0->bit_rate < 24*1000) {
av_log(VAR_0, AV_LOG_ERROR, "bitrate too low: got %VAR_1, need 24000 or higher\n",
VAR_0->bit_rate);
return AVERROR(EINVAL);
}
VAR_2 = 0;
VAR_3 = 1;
if (VAR_0->codec->id == CODEC_ID_WMAV1) {
extradata= av_malloc(4);
VAR_0->extradata_size= 4;
AV_WL16(extradata, VAR_2);
AV_WL16(extradata+2, VAR_3);
} else if (VAR_0->codec->id == CODEC_ID_WMAV2) {
extradata= av_mallocz(10);
VAR_0->extradata_size= 10;
AV_WL32(extradata, VAR_2);
AV_WL16(extradata+4, VAR_3);
}else
assert(0);
VAR_0->extradata= extradata;
s->use_exp_vlc = VAR_3 & 0x0001;
s->use_bit_reservoir = VAR_3 & 0x0002;
s->use_variable_block_len = VAR_3 & 0x0004;
ff_wma_init(VAR_0, VAR_3);
for(VAR_1 = 0; VAR_1 < s->nb_block_sizes; VAR_1++)
ff_mdct_init(&s->mdct_ctx[VAR_1], s->frame_len_bits - VAR_1 + 1, 0, 1.0);
VAR_0->block_align=
s->block_align= VAR_0->bit_rate*(int64_t)s->frame_len / (VAR_0->sample_rate*8);
VAR_0->frame_size= s->frame_len;
return 0;
}
|
[
"static int FUNC_0(AVCodecContext * VAR_0){",
"WMACodecContext *s = VAR_0->priv_data;",
"int VAR_1, VAR_2, VAR_3;",
"uint8_t *extradata;",
"s->VAR_0 = VAR_0;",
"if(VAR_0->channels > MAX_CHANNELS) {",
"av_log(VAR_0, AV_LOG_ERROR, \"too many channels: got %VAR_1, need %VAR_1 or fewer\",\nVAR_0->channels, MAX_CHANNELS);",
"return AVERROR(EINVAL);",
"}",
"if(VAR_0->bit_rate < 24*1000) {",
"av_log(VAR_0, AV_LOG_ERROR, \"bitrate too low: got %VAR_1, need 24000 or higher\\n\",\nVAR_0->bit_rate);",
"return AVERROR(EINVAL);",
"}",
"VAR_2 = 0;",
"VAR_3 = 1;",
"if (VAR_0->codec->id == CODEC_ID_WMAV1) {",
"extradata= av_malloc(4);",
"VAR_0->extradata_size= 4;",
"AV_WL16(extradata, VAR_2);",
"AV_WL16(extradata+2, VAR_3);",
"} else if (VAR_0->codec->id == CODEC_ID_WMAV2) {",
"extradata= av_mallocz(10);",
"VAR_0->extradata_size= 10;",
"AV_WL32(extradata, VAR_2);",
"AV_WL16(extradata+4, VAR_3);",
"}else",
"assert(0);",
"VAR_0->extradata= extradata;",
"s->use_exp_vlc = VAR_3 & 0x0001;",
"s->use_bit_reservoir = VAR_3 & 0x0002;",
"s->use_variable_block_len = VAR_3 & 0x0004;",
"ff_wma_init(VAR_0, VAR_3);",
"for(VAR_1 = 0; VAR_1 < s->nb_block_sizes; VAR_1++)",
"ff_mdct_init(&s->mdct_ctx[VAR_1], s->frame_len_bits - VAR_1 + 1, 0, 1.0);",
"VAR_0->block_align=\ns->block_align= VAR_0->bit_rate*(int64_t)s->frame_len / (VAR_0->sample_rate*8);",
"VAR_0->frame_size= s->frame_len;",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0
] |
[
[
1
],
[
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
85
],
[
87
],
[
91,
93
],
[
97
],
[
101
],
[
103
]
] |
6,969 |
static int txd_read_header(AVFormatContext *s, AVFormatParameters *ap) {
AVStream *st;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_TXD;
st->codec->time_base.den = 5;
st->codec->time_base.num = 1;
/* the parameters will be extracted from the compressed bitstream */
return 0;
}
| true |
FFmpeg
|
f72601d06378494b5026b919fcd3eb5eb22799a1
|
static int txd_read_header(AVFormatContext *s, AVFormatParameters *ap) {
AVStream *st;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_TXD;
st->codec->time_base.den = 5;
st->codec->time_base.num = 1;
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVFormatContext *VAR_0, AVFormatParameters *VAR_1) {
AVStream *st;
st = avformat_new_stream(VAR_0, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_TXD;
st->codec->time_base.den = 5;
st->codec->time_base.num = 1;
return 0;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, AVFormatParameters *VAR_1) {",
"AVStream *st;",
"st = avformat_new_stream(VAR_0, NULL);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"st->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"st->codec->codec_id = CODEC_ID_TXD;",
"st->codec->time_base.den = 5;",
"st->codec->time_base.num = 1;",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1
],
[
2
],
[
3
],
[
4,
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
11
],
[
12
]
] |
6,970 |
static int output_frame(AVFilterLink *outlink, int nb_samples)
{
AVFilterContext *ctx = outlink->src;
MixContext *s = ctx->priv;
AVFilterBufferRef *out_buf, *in_buf;
int i;
calculate_scales(s, nb_samples);
out_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
if (!out_buf)
return AVERROR(ENOMEM);
in_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
if (!in_buf)
return AVERROR(ENOMEM);
for (i = 0; i < s->nb_inputs; i++) {
if (s->input_state[i] == INPUT_ON) {
int planes, plane_size, p;
av_audio_fifo_read(s->fifos[i], (void **)in_buf->extended_data,
nb_samples);
planes = s->planar ? s->nb_channels : 1;
plane_size = nb_samples * (s->planar ? 1 : s->nb_channels);
plane_size = FFALIGN(plane_size, 16);
for (p = 0; p < planes; p++) {
s->fdsp.vector_fmac_scalar((float *)out_buf->extended_data[p],
(float *) in_buf->extended_data[p],
s->input_scale[i], plane_size);
}
}
}
avfilter_unref_buffer(in_buf);
out_buf->pts = s->next_pts;
if (s->next_pts != AV_NOPTS_VALUE)
s->next_pts += nb_samples;
return ff_filter_samples(outlink, out_buf);
}
| true |
FFmpeg
|
8501c098687bbf551a2f1cdef80ee653fdfff6ac
|
static int output_frame(AVFilterLink *outlink, int nb_samples)
{
AVFilterContext *ctx = outlink->src;
MixContext *s = ctx->priv;
AVFilterBufferRef *out_buf, *in_buf;
int i;
calculate_scales(s, nb_samples);
out_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
if (!out_buf)
return AVERROR(ENOMEM);
in_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
if (!in_buf)
return AVERROR(ENOMEM);
for (i = 0; i < s->nb_inputs; i++) {
if (s->input_state[i] == INPUT_ON) {
int planes, plane_size, p;
av_audio_fifo_read(s->fifos[i], (void **)in_buf->extended_data,
nb_samples);
planes = s->planar ? s->nb_channels : 1;
plane_size = nb_samples * (s->planar ? 1 : s->nb_channels);
plane_size = FFALIGN(plane_size, 16);
for (p = 0; p < planes; p++) {
s->fdsp.vector_fmac_scalar((float *)out_buf->extended_data[p],
(float *) in_buf->extended_data[p],
s->input_scale[i], plane_size);
}
}
}
avfilter_unref_buffer(in_buf);
out_buf->pts = s->next_pts;
if (s->next_pts != AV_NOPTS_VALUE)
s->next_pts += nb_samples;
return ff_filter_samples(outlink, out_buf);
}
|
{
"code": [
" if (!in_buf)"
],
"line_no": [
29
]
}
|
static int FUNC_0(AVFilterLink *VAR_0, int VAR_1)
{
AVFilterContext *ctx = VAR_0->src;
MixContext *s = ctx->priv;
AVFilterBufferRef *out_buf, *in_buf;
int VAR_2;
calculate_scales(s, VAR_1);
out_buf = ff_get_audio_buffer(VAR_0, AV_PERM_WRITE, VAR_1);
if (!out_buf)
return AVERROR(ENOMEM);
in_buf = ff_get_audio_buffer(VAR_0, AV_PERM_WRITE, VAR_1);
if (!in_buf)
return AVERROR(ENOMEM);
for (VAR_2 = 0; VAR_2 < s->nb_inputs; VAR_2++) {
if (s->input_state[VAR_2] == INPUT_ON) {
int planes, plane_size, p;
av_audio_fifo_read(s->fifos[VAR_2], (void **)in_buf->extended_data,
VAR_1);
planes = s->planar ? s->nb_channels : 1;
plane_size = VAR_1 * (s->planar ? 1 : s->nb_channels);
plane_size = FFALIGN(plane_size, 16);
for (p = 0; p < planes; p++) {
s->fdsp.vector_fmac_scalar((float *)out_buf->extended_data[p],
(float *) in_buf->extended_data[p],
s->input_scale[VAR_2], plane_size);
}
}
}
avfilter_unref_buffer(in_buf);
out_buf->pts = s->next_pts;
if (s->next_pts != AV_NOPTS_VALUE)
s->next_pts += VAR_1;
return ff_filter_samples(VAR_0, out_buf);
}
|
[
"static int FUNC_0(AVFilterLink *VAR_0, int VAR_1)\n{",
"AVFilterContext *ctx = VAR_0->src;",
"MixContext *s = ctx->priv;",
"AVFilterBufferRef *out_buf, *in_buf;",
"int VAR_2;",
"calculate_scales(s, VAR_1);",
"out_buf = ff_get_audio_buffer(VAR_0, AV_PERM_WRITE, VAR_1);",
"if (!out_buf)\nreturn AVERROR(ENOMEM);",
"in_buf = ff_get_audio_buffer(VAR_0, AV_PERM_WRITE, VAR_1);",
"if (!in_buf)\nreturn AVERROR(ENOMEM);",
"for (VAR_2 = 0; VAR_2 < s->nb_inputs; VAR_2++) {",
"if (s->input_state[VAR_2] == INPUT_ON) {",
"int planes, plane_size, p;",
"av_audio_fifo_read(s->fifos[VAR_2], (void **)in_buf->extended_data,\nVAR_1);",
"planes = s->planar ? s->nb_channels : 1;",
"plane_size = VAR_1 * (s->planar ? 1 : s->nb_channels);",
"plane_size = FFALIGN(plane_size, 16);",
"for (p = 0; p < planes; p++) {",
"s->fdsp.vector_fmac_scalar((float *)out_buf->extended_data[p],\n(float *) in_buf->extended_data[p],\ns->input_scale[VAR_2], plane_size);",
"}",
"}",
"}",
"avfilter_unref_buffer(in_buf);",
"out_buf->pts = s->next_pts;",
"if (s->next_pts != AV_NOPTS_VALUE)\ns->next_pts += VAR_1;",
"return ff_filter_samples(VAR_0, out_buf);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21,
23
],
[
27
],
[
29,
31
],
[
35
],
[
37
],
[
39
],
[
43,
45
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59,
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77,
79
],
[
83
],
[
85
]
] |
6,971 |
MAKE_ACCESSORS(AVVDPAUContext, vdpau_hwaccel, AVVDPAU_Render2, render2)
int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,
int level)
{
VDPAUHWContext *hwctx = avctx->hwaccel_context;
VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
VdpDecoderCreate *create;
void *func;
VdpStatus status;
/* See vdpau/vdpau.h for alignment constraints. */
uint32_t width = (avctx->coded_width + 1) & ~1;
uint32_t height = (avctx->coded_height + 3) & ~3;
if (hwctx->context.decoder != VDP_INVALID_HANDLE) {
vdctx->decoder = hwctx->context.decoder;
vdctx->render = hwctx->context.render;
return 0; /* Decoder created by user */
vdctx->device = hwctx->device;
vdctx->get_proc_address = hwctx->get_proc_address;
status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,
&func);
if (status != VDP_STATUS_OK)
return vdpau_error(status);
else
create = func;
status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,
&func);
if (status != VDP_STATUS_OK)
return vdpau_error(status);
else
vdctx->render = func;
status = create(vdctx->device, profile, width, height, avctx->refs,
&vdctx->decoder);
return vdpau_error(status);
| true |
FFmpeg
|
ec6a855b3a6b87f3415cc4ecfc685bd2eefc6a80
|
MAKE_ACCESSORS(AVVDPAUContext, vdpau_hwaccel, AVVDPAU_Render2, render2)
int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,
int level)
{
VDPAUHWContext *hwctx = avctx->hwaccel_context;
VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
VdpDecoderCreate *create;
void *func;
VdpStatus status;
uint32_t width = (avctx->coded_width + 1) & ~1;
uint32_t height = (avctx->coded_height + 3) & ~3;
if (hwctx->context.decoder != VDP_INVALID_HANDLE) {
vdctx->decoder = hwctx->context.decoder;
vdctx->render = hwctx->context.render;
return 0;
vdctx->device = hwctx->device;
vdctx->get_proc_address = hwctx->get_proc_address;
status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,
&func);
if (status != VDP_STATUS_OK)
return vdpau_error(status);
else
create = func;
status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,
&func);
if (status != VDP_STATUS_OK)
return vdpau_error(status);
else
vdctx->render = func;
status = create(vdctx->device, profile, width, height, avctx->refs,
&vdctx->decoder);
return vdpau_error(status);
|
{
"code": [],
"line_no": []
}
|
FUNC_0(VAR_0, VAR_1, VAR_2, VAR_3)
int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,
int level)
{
VDPAUHWContext *hwctx = avctx->hwaccel_context;
VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;
VdpDecoderCreate *create;
void *VAR_4;
VdpStatus status;
uint32_t width = (avctx->coded_width + 1) & ~1;
uint32_t height = (avctx->coded_height + 3) & ~3;
if (hwctx->context.decoder != VDP_INVALID_HANDLE) {
vdctx->decoder = hwctx->context.decoder;
vdctx->render = hwctx->context.render;
return 0;
vdctx->device = hwctx->device;
vdctx->get_proc_address = hwctx->get_proc_address;
status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,
&VAR_4);
if (status != VDP_STATUS_OK)
return vdpau_error(status);
else
create = VAR_4;
status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,
&VAR_4);
if (status != VDP_STATUS_OK)
return vdpau_error(status);
else
vdctx->render = VAR_4;
status = create(vdctx->device, profile, width, height, avctx->refs,
&vdctx->decoder);
return vdpau_error(status);
|
[
"FUNC_0(VAR_0, VAR_1, VAR_2, VAR_3)\nint ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,\nint level)\n{",
"VDPAUHWContext *hwctx = avctx->hwaccel_context;",
"VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data;",
"VdpDecoderCreate *create;",
"void *VAR_4;",
"VdpStatus status;",
"uint32_t width = (avctx->coded_width + 1) & ~1;",
"uint32_t height = (avctx->coded_height + 3) & ~3;",
"if (hwctx->context.decoder != VDP_INVALID_HANDLE) {",
"vdctx->decoder = hwctx->context.decoder;",
"vdctx->render = hwctx->context.render;",
"return 0;",
"vdctx->device = hwctx->device;",
"vdctx->get_proc_address = hwctx->get_proc_address;",
"status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_CREATE,\n&VAR_4);",
"if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);",
"else\ncreate = VAR_4;",
"status = vdctx->get_proc_address(vdctx->device, VDP_FUNC_ID_DECODER_RENDER,\n&VAR_4);",
"if (status != VDP_STATUS_OK)\nreturn vdpau_error(status);",
"else\nvdctx->render = VAR_4;",
"status = create(vdctx->device, profile, width, height, avctx->refs,\n&vdctx->decoder);",
"return vdpau_error(status);"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
2,
3,
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19,
20
],
[
21,
22
],
[
23,
24
],
[
25,
26
],
[
27,
28
],
[
29,
30
],
[
31,
32
],
[
33
]
] |
6,973 |
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
int n, int coded, int intra, int rvlc)
{
int level, i, last, run;
int dc_pred_dir;
RLTable * rl;
RL_VLC_ELEM * rl_vlc;
const uint8_t * scan_table;
int qmul, qadd;
//Note intra & rvlc should be optimized away if this is inlined
if(intra) {
if(s->use_intra_dc_vlc){
/* DC coef */
if(s->partitioned_frame){
level = s->dc_val[0][ s->block_index[n] ];
if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
}else{
level = mpeg4_decode_dc(s, n, &dc_pred_dir);
if (level < 0)
return -1;
}
block[0] = level;
i = 0;
}else{
i = -1;
ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
}
if (!coded)
goto not_coded;
if(rvlc){
rl = &rvlc_rl_intra;
rl_vlc = rvlc_rl_intra.rl_vlc[0];
}else{
rl = &rl_intra;
rl_vlc = rl_intra.rl_vlc[0];
}
if (s->ac_pred) {
if (dc_pred_dir == 0)
scan_table = s->intra_v_scantable.permutated; /* left */
else
scan_table = s->intra_h_scantable.permutated; /* top */
} else {
scan_table = s->intra_scantable.permutated;
}
qmul=1;
qadd=0;
} else {
i = -1;
if (!coded) {
s->block_last_index[n] = i;
return 0;
}
if(rvlc) rl = &rvlc_rl_inter;
else rl = &rl_inter;
scan_table = s->intra_scantable.permutated;
if(s->mpeg_quant){
qmul=1;
qadd=0;
if(rvlc){
rl_vlc = rvlc_rl_inter.rl_vlc[0];
}else{
rl_vlc = rl_inter.rl_vlc[0];
}
}else{
qmul = s->qscale << 1;
qadd = (s->qscale - 1) | 1;
if(rvlc){
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
}else{
rl_vlc = rl_inter.rl_vlc[s->qscale];
}
}
}
{
OPEN_READER(re, &s->gb);
for(;;) {
UPDATE_CACHE(re, &s->gb);
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (level==0) {
/* escape */
if(rvlc){
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 1);
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
SKIP_COUNTER(re, &s->gb, 1+1+6);
UPDATE_CACHE(re, &s->gb);
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 1);
level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 5);
level= level * qmul + qadd;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
SKIP_COUNTER(re, &s->gb, 1+11+5+1);
i+= run + 1;
if(last) i+=192;
}else{
int cache;
cache= GET_CACHE(re, &s->gb);
if(IS_3IV1)
cache ^= 0xC0000000;
if (cache&0x80000000) {
if (cache&0x40000000) {
/* third escape */
SKIP_CACHE(re, &s->gb, 2);
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
SKIP_COUNTER(re, &s->gb, 2+1+6);
UPDATE_CACHE(re, &s->gb);
if(IS_3IV1){
level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
}else{
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 1);
level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
return -1;
}; LAST_SKIP_CACHE(re, &s->gb, 1);
SKIP_COUNTER(re, &s->gb, 1+12+1);
}
#if 0
if(s->error_resilience >= FF_ER_COMPLIANT){
const int abs_level= FFABS(level);
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
const int run1= run - rl->max_run[last][abs_level] - 1;
if(abs_level <= rl->max_level[last][run]){
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
return -1;
}
if(s->error_resilience > FF_ER_COMPLIANT){
if(abs_level <= rl->max_level[last][run]*2){
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
return -1;
}
if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
return -1;
}
}
}
}
#endif
if (level>0) level= level * qmul + qadd;
else level= level * qmul - qadd;
if((unsigned)(level + 2048) > 4095){
if(s->error_resilience > FF_ER_COMPLIANT){
if(level > 2560 || level<-2560){
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
return -1;
}
}
level= level<0 ? -2048 : 2047;
}
i+= run + 1;
if(last) i+=192;
} else {
/* second escape */
#if MIN_CACHE_BITS < 20
LAST_SKIP_BITS(re, &s->gb, 2);
UPDATE_CACHE(re, &s->gb);
#else
SKIP_BITS(re, &s->gb, 2);
#endif
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
}
} else {
/* first escape */
#if MIN_CACHE_BITS < 19
LAST_SKIP_BITS(re, &s->gb, 1);
UPDATE_CACHE(re, &s->gb);
#else
SKIP_BITS(re, &s->gb, 1);
#endif
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i+= run;
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
}
}
} else {
i+= run;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
}
if (i > 62){
i-= 192;
if(i&(~63)){
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
return -1;
}
block[scan_table[i]] = level;
break;
}
block[scan_table[i]] = level;
}
CLOSE_READER(re, &s->gb);
}
not_coded:
if (intra) {
if(!s->use_intra_dc_vlc){
block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
i -= i>>31; //if(i == -1) i=0;
}
mpeg4_pred_ac(s, block, n, dc_pred_dir);
if (s->ac_pred) {
i = 63; /* XXX: not optimal */
}
}
s->block_last_index[n] = i;
return 0;
}
| true |
FFmpeg
|
3fbe36d4d0eaad5ed855b0418a841c70d0cdbcb3
|
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
int n, int coded, int intra, int rvlc)
{
int level, i, last, run;
int dc_pred_dir;
RLTable * rl;
RL_VLC_ELEM * rl_vlc;
const uint8_t * scan_table;
int qmul, qadd;
if(intra) {
if(s->use_intra_dc_vlc){
if(s->partitioned_frame){
level = s->dc_val[0][ s->block_index[n] ];
if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
}else{
level = mpeg4_decode_dc(s, n, &dc_pred_dir);
if (level < 0)
return -1;
}
block[0] = level;
i = 0;
}else{
i = -1;
ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
}
if (!coded)
goto not_coded;
if(rvlc){
rl = &rvlc_rl_intra;
rl_vlc = rvlc_rl_intra.rl_vlc[0];
}else{
rl = &rl_intra;
rl_vlc = rl_intra.rl_vlc[0];
}
if (s->ac_pred) {
if (dc_pred_dir == 0)
scan_table = s->intra_v_scantable.permutated;
else
scan_table = s->intra_h_scantable.permutated;
} else {
scan_table = s->intra_scantable.permutated;
}
qmul=1;
qadd=0;
} else {
i = -1;
if (!coded) {
s->block_last_index[n] = i;
return 0;
}
if(rvlc) rl = &rvlc_rl_inter;
else rl = &rl_inter;
scan_table = s->intra_scantable.permutated;
if(s->mpeg_quant){
qmul=1;
qadd=0;
if(rvlc){
rl_vlc = rvlc_rl_inter.rl_vlc[0];
}else{
rl_vlc = rl_inter.rl_vlc[0];
}
}else{
qmul = s->qscale << 1;
qadd = (s->qscale - 1) | 1;
if(rvlc){
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
}else{
rl_vlc = rl_inter.rl_vlc[s->qscale];
}
}
}
{
OPEN_READER(re, &s->gb);
for(;;) {
UPDATE_CACHE(re, &s->gb);
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (level==0) {
if(rvlc){
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 1);
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
SKIP_COUNTER(re, &s->gb, 1+1+6);
UPDATE_CACHE(re, &s->gb);
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 1);
level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 5);
level= level * qmul + qadd;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
SKIP_COUNTER(re, &s->gb, 1+11+5+1);
i+= run + 1;
if(last) i+=192;
}else{
int cache;
cache= GET_CACHE(re, &s->gb);
if(IS_3IV1)
cache ^= 0xC0000000;
if (cache&0x80000000) {
if (cache&0x40000000) {
SKIP_CACHE(re, &s->gb, 2);
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
SKIP_COUNTER(re, &s->gb, 2+1+6);
UPDATE_CACHE(re, &s->gb);
if(IS_3IV1){
level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
}else{
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
return -1;
}; SKIP_CACHE(re, &s->gb, 1);
level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
if(SHOW_UBITS(re, &s->gb, 1)==0){
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
return -1;
}; LAST_SKIP_CACHE(re, &s->gb, 1);
SKIP_COUNTER(re, &s->gb, 1+12+1);
}
#if 0
if(s->error_resilience >= FF_ER_COMPLIANT){
const int abs_level= FFABS(level);
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
const int run1= run - rl->max_run[last][abs_level] - 1;
if(abs_level <= rl->max_level[last][run]){
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
return -1;
}
if(s->error_resilience > FF_ER_COMPLIANT){
if(abs_level <= rl->max_level[last][run]*2){
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
return -1;
}
if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
return -1;
}
}
}
}
#endif
if (level>0) level= level * qmul + qadd;
else level= level * qmul - qadd;
if((unsigned)(level + 2048) > 4095){
if(s->error_resilience > FF_ER_COMPLIANT){
if(level > 2560 || level<-2560){
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
return -1;
}
}
level= level<0 ? -2048 : 2047;
}
i+= run + 1;
if(last) i+=192;
} else {
#if MIN_CACHE_BITS < 20
LAST_SKIP_BITS(re, &s->gb, 2);
UPDATE_CACHE(re, &s->gb);
#else
SKIP_BITS(re, &s->gb, 2);
#endif
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i+= run + rl->max_run[run>>7][level/qmul] +1;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
}
} else {
#if MIN_CACHE_BITS < 19
LAST_SKIP_BITS(re, &s->gb, 1);
UPDATE_CACHE(re, &s->gb);
#else
SKIP_BITS(re, &s->gb, 1);
#endif
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
i+= run;
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
}
}
} else {
i+= run;
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
}
if (i > 62){
i-= 192;
if(i&(~63)){
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
return -1;
}
block[scan_table[i]] = level;
break;
}
block[scan_table[i]] = level;
}
CLOSE_READER(re, &s->gb);
}
not_coded:
if (intra) {
if(!s->use_intra_dc_vlc){
block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
i -= i>>31;
}
mpeg4_pred_ac(s, block, n, dc_pred_dir);
if (s->ac_pred) {
i = 63;
}
}
s->block_last_index[n] = i;
return 0;
}
|
{
"code": [
" int dc_pred_dir;"
],
"line_no": [
9
]
}
|
static inline int FUNC_0(MpegEncContext * VAR_0, DCTELEM * VAR_1,
int VAR_2, int VAR_3, int VAR_4, int VAR_5)
{
int VAR_6, VAR_7, VAR_8, VAR_9;
int VAR_10;
RLTable * rl;
RL_VLC_ELEM * rl_vlc;
const uint8_t * VAR_11;
int VAR_12, VAR_13;
if(VAR_4) {
if(VAR_0->use_intra_dc_vlc){
if(VAR_0->partitioned_frame){
VAR_6 = VAR_0->dc_val[0][ VAR_0->block_index[VAR_2] ];
if(VAR_2<4) VAR_6= FASTDIV((VAR_6 + (VAR_0->y_dc_scale>>1)), VAR_0->y_dc_scale);
else VAR_6= FASTDIV((VAR_6 + (VAR_0->c_dc_scale>>1)), VAR_0->c_dc_scale);
VAR_10= (VAR_0->pred_dir_table[VAR_0->mb_x + VAR_0->mb_y*VAR_0->mb_stride]<<VAR_2)&32;
}else{
VAR_6 = mpeg4_decode_dc(VAR_0, VAR_2, &VAR_10);
if (VAR_6 < 0)
return -1;
}
VAR_1[0] = VAR_6;
VAR_7 = 0;
}else{
VAR_7 = -1;
ff_mpeg4_pred_dc(VAR_0, VAR_2, 0, &VAR_10, 0);
}
if (!VAR_3)
goto not_coded;
if(VAR_5){
rl = &rvlc_rl_intra;
rl_vlc = rvlc_rl_intra.rl_vlc[0];
}else{
rl = &rl_intra;
rl_vlc = rl_intra.rl_vlc[0];
}
if (VAR_0->ac_pred) {
if (VAR_10 == 0)
VAR_11 = VAR_0->intra_v_scantable.permutated;
else
VAR_11 = VAR_0->intra_h_scantable.permutated;
} else {
VAR_11 = VAR_0->intra_scantable.permutated;
}
VAR_12=1;
VAR_13=0;
} else {
VAR_7 = -1;
if (!VAR_3) {
VAR_0->block_last_index[VAR_2] = VAR_7;
return 0;
}
if(VAR_5) rl = &rvlc_rl_inter;
else rl = &rl_inter;
VAR_11 = VAR_0->intra_scantable.permutated;
if(VAR_0->mpeg_quant){
VAR_12=1;
VAR_13=0;
if(VAR_5){
rl_vlc = rvlc_rl_inter.rl_vlc[0];
}else{
rl_vlc = rl_inter.rl_vlc[0];
}
}else{
VAR_12 = VAR_0->qscale << 1;
VAR_13 = (VAR_0->qscale - 1) | 1;
if(VAR_5){
rl_vlc = rvlc_rl_inter.rl_vlc[VAR_0->qscale];
}else{
rl_vlc = rl_inter.rl_vlc[VAR_0->qscale];
}
}
}
{
OPEN_READER(re, &VAR_0->gb);
for(;;) {
UPDATE_CACHE(re, &VAR_0->gb);
GET_RL_VLC(VAR_6, VAR_9, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
if (VAR_6==0) {
if(VAR_5){
if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){
av_log(VAR_0->avctx, AV_LOG_ERROR, "1. marker bit missing in VAR_5 esc\VAR_2");
return -1;
}; SKIP_CACHE(re, &VAR_0->gb, 1);
VAR_8= SHOW_UBITS(re, &VAR_0->gb, 1); SKIP_CACHE(re, &VAR_0->gb, 1);
VAR_9= SHOW_UBITS(re, &VAR_0->gb, 6); LAST_SKIP_CACHE(re, &VAR_0->gb, 6);
SKIP_COUNTER(re, &VAR_0->gb, 1+1+6);
UPDATE_CACHE(re, &VAR_0->gb);
if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){
av_log(VAR_0->avctx, AV_LOG_ERROR, "2. marker bit missing in VAR_5 esc\VAR_2");
return -1;
}; SKIP_CACHE(re, &VAR_0->gb, 1);
VAR_6= SHOW_UBITS(re, &VAR_0->gb, 11); SKIP_CACHE(re, &VAR_0->gb, 11);
if(SHOW_UBITS(re, &VAR_0->gb, 5)!=0x10){
av_log(VAR_0->avctx, AV_LOG_ERROR, "reverse esc missing\VAR_2");
return -1;
}; SKIP_CACHE(re, &VAR_0->gb, 5);
VAR_6= VAR_6 * VAR_12 + VAR_13;
VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1); LAST_SKIP_CACHE(re, &VAR_0->gb, 1);
SKIP_COUNTER(re, &VAR_0->gb, 1+11+5+1);
VAR_7+= VAR_9 + 1;
if(VAR_8) VAR_7+=192;
}else{
int VAR_14;
VAR_14= GET_CACHE(re, &VAR_0->gb);
if(IS_3IV1)
VAR_14 ^= 0xC0000000;
if (VAR_14&0x80000000) {
if (VAR_14&0x40000000) {
SKIP_CACHE(re, &VAR_0->gb, 2);
VAR_8= SHOW_UBITS(re, &VAR_0->gb, 1); SKIP_CACHE(re, &VAR_0->gb, 1);
VAR_9= SHOW_UBITS(re, &VAR_0->gb, 6); LAST_SKIP_CACHE(re, &VAR_0->gb, 6);
SKIP_COUNTER(re, &VAR_0->gb, 2+1+6);
UPDATE_CACHE(re, &VAR_0->gb);
if(IS_3IV1){
VAR_6= SHOW_SBITS(re, &VAR_0->gb, 12); LAST_SKIP_BITS(re, &VAR_0->gb, 12);
}else{
if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){
av_log(VAR_0->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\VAR_2");
return -1;
}; SKIP_CACHE(re, &VAR_0->gb, 1);
VAR_6= SHOW_SBITS(re, &VAR_0->gb, 12); SKIP_CACHE(re, &VAR_0->gb, 12);
if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){
av_log(VAR_0->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\VAR_2");
return -1;
}; LAST_SKIP_CACHE(re, &VAR_0->gb, 1);
SKIP_COUNTER(re, &VAR_0->gb, 1+12+1);
}
#if 0
if(VAR_0->error_resilience >= FF_ER_COMPLIANT){
const int abs_level= FFABS(VAR_6);
if(abs_level<=MAX_LEVEL && VAR_9<=MAX_RUN){
const int run1= VAR_9 - rl->max_run[VAR_8][abs_level] - 1;
if(abs_level <= rl->max_level[VAR_8][VAR_9]){
av_log(VAR_0->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\VAR_2");
return -1;
}
if(VAR_0->error_resilience > FF_ER_COMPLIANT){
if(abs_level <= rl->max_level[VAR_8][VAR_9]*2){
av_log(VAR_0->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\VAR_2");
return -1;
}
if(run1 >= 0 && abs_level <= rl->max_level[VAR_8][run1]){
av_log(VAR_0->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\VAR_2");
return -1;
}
}
}
}
#endif
if (VAR_6>0) VAR_6= VAR_6 * VAR_12 + VAR_13;
else VAR_6= VAR_6 * VAR_12 - VAR_13;
if((unsigned)(VAR_6 + 2048) > 4095){
if(VAR_0->error_resilience > FF_ER_COMPLIANT){
if(VAR_6 > 2560 || VAR_6<-2560){
av_log(VAR_0->avctx, AV_LOG_ERROR, "|VAR_6| overflow in 3. esc, qp=%d\VAR_2", VAR_0->qscale);
return -1;
}
}
VAR_6= VAR_6<0 ? -2048 : 2047;
}
VAR_7+= VAR_9 + 1;
if(VAR_8) VAR_7+=192;
} else {
#if MIN_CACHE_BITS < 20
LAST_SKIP_BITS(re, &VAR_0->gb, 2);
UPDATE_CACHE(re, &VAR_0->gb);
#else
SKIP_BITS(re, &VAR_0->gb, 2);
#endif
GET_RL_VLC(VAR_6, VAR_9, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
VAR_7+= VAR_9 + rl->max_run[VAR_9>>7][VAR_6/VAR_12] +1;
VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);
LAST_SKIP_BITS(re, &VAR_0->gb, 1);
}
} else {
#if MIN_CACHE_BITS < 19
LAST_SKIP_BITS(re, &VAR_0->gb, 1);
UPDATE_CACHE(re, &VAR_0->gb);
#else
SKIP_BITS(re, &VAR_0->gb, 1);
#endif
GET_RL_VLC(VAR_6, VAR_9, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
VAR_7+= VAR_9;
VAR_6 = VAR_6 + rl->max_level[VAR_9>>7][(VAR_9-1)&63] * VAR_12;
VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);
LAST_SKIP_BITS(re, &VAR_0->gb, 1);
}
}
} else {
VAR_7+= VAR_9;
VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);
LAST_SKIP_BITS(re, &VAR_0->gb, 1);
}
if (VAR_7 > 62){
VAR_7-= 192;
if(VAR_7&(~63)){
av_log(VAR_0->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\VAR_2", VAR_0->mb_x, VAR_0->mb_y);
return -1;
}
VAR_1[VAR_11[VAR_7]] = VAR_6;
break;
}
VAR_1[VAR_11[VAR_7]] = VAR_6;
}
CLOSE_READER(re, &VAR_0->gb);
}
not_coded:
if (VAR_4) {
if(!VAR_0->use_intra_dc_vlc){
VAR_1[0] = ff_mpeg4_pred_dc(VAR_0, VAR_2, VAR_1[0], &VAR_10, 0);
VAR_7 -= VAR_7>>31;
}
mpeg4_pred_ac(VAR_0, VAR_1, VAR_2, VAR_10);
if (VAR_0->ac_pred) {
VAR_7 = 63;
}
}
VAR_0->block_last_index[VAR_2] = VAR_7;
return 0;
}
|
[
"static inline int FUNC_0(MpegEncContext * VAR_0, DCTELEM * VAR_1,\nint VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{",
"int VAR_6, VAR_7, VAR_8, VAR_9;",
"int VAR_10;",
"RLTable * rl;",
"RL_VLC_ELEM * rl_vlc;",
"const uint8_t * VAR_11;",
"int VAR_12, VAR_13;",
"if(VAR_4) {",
"if(VAR_0->use_intra_dc_vlc){",
"if(VAR_0->partitioned_frame){",
"VAR_6 = VAR_0->dc_val[0][ VAR_0->block_index[VAR_2] ];",
"if(VAR_2<4) VAR_6= FASTDIV((VAR_6 + (VAR_0->y_dc_scale>>1)), VAR_0->y_dc_scale);",
"else VAR_6= FASTDIV((VAR_6 + (VAR_0->c_dc_scale>>1)), VAR_0->c_dc_scale);",
"VAR_10= (VAR_0->pred_dir_table[VAR_0->mb_x + VAR_0->mb_y*VAR_0->mb_stride]<<VAR_2)&32;",
"}else{",
"VAR_6 = mpeg4_decode_dc(VAR_0, VAR_2, &VAR_10);",
"if (VAR_6 < 0)\nreturn -1;",
"}",
"VAR_1[0] = VAR_6;",
"VAR_7 = 0;",
"}else{",
"VAR_7 = -1;",
"ff_mpeg4_pred_dc(VAR_0, VAR_2, 0, &VAR_10, 0);",
"}",
"if (!VAR_3)\ngoto not_coded;",
"if(VAR_5){",
"rl = &rvlc_rl_intra;",
"rl_vlc = rvlc_rl_intra.rl_vlc[0];",
"}else{",
"rl = &rl_intra;",
"rl_vlc = rl_intra.rl_vlc[0];",
"}",
"if (VAR_0->ac_pred) {",
"if (VAR_10 == 0)\nVAR_11 = VAR_0->intra_v_scantable.permutated;",
"else\nVAR_11 = VAR_0->intra_h_scantable.permutated;",
"} else {",
"VAR_11 = VAR_0->intra_scantable.permutated;",
"}",
"VAR_12=1;",
"VAR_13=0;",
"} else {",
"VAR_7 = -1;",
"if (!VAR_3) {",
"VAR_0->block_last_index[VAR_2] = VAR_7;",
"return 0;",
"}",
"if(VAR_5) rl = &rvlc_rl_inter;",
"else rl = &rl_inter;",
"VAR_11 = VAR_0->intra_scantable.permutated;",
"if(VAR_0->mpeg_quant){",
"VAR_12=1;",
"VAR_13=0;",
"if(VAR_5){",
"rl_vlc = rvlc_rl_inter.rl_vlc[0];",
"}else{",
"rl_vlc = rl_inter.rl_vlc[0];",
"}",
"}else{",
"VAR_12 = VAR_0->qscale << 1;",
"VAR_13 = (VAR_0->qscale - 1) | 1;",
"if(VAR_5){",
"rl_vlc = rvlc_rl_inter.rl_vlc[VAR_0->qscale];",
"}else{",
"rl_vlc = rl_inter.rl_vlc[VAR_0->qscale];",
"}",
"}",
"}",
"{",
"OPEN_READER(re, &VAR_0->gb);",
"for(;;) {",
"UPDATE_CACHE(re, &VAR_0->gb);",
"GET_RL_VLC(VAR_6, VAR_9, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2, 0);",
"if (VAR_6==0) {",
"if(VAR_5){",
"if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"1. marker bit missing in VAR_5 esc\\VAR_2\");",
"return -1;",
"}; SKIP_CACHE(re, &VAR_0->gb, 1);",
"VAR_8= SHOW_UBITS(re, &VAR_0->gb, 1); SKIP_CACHE(re, &VAR_0->gb, 1);",
"VAR_9= SHOW_UBITS(re, &VAR_0->gb, 6); LAST_SKIP_CACHE(re, &VAR_0->gb, 6);",
"SKIP_COUNTER(re, &VAR_0->gb, 1+1+6);",
"UPDATE_CACHE(re, &VAR_0->gb);",
"if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"2. marker bit missing in VAR_5 esc\\VAR_2\");",
"return -1;",
"}; SKIP_CACHE(re, &VAR_0->gb, 1);",
"VAR_6= SHOW_UBITS(re, &VAR_0->gb, 11); SKIP_CACHE(re, &VAR_0->gb, 11);",
"if(SHOW_UBITS(re, &VAR_0->gb, 5)!=0x10){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"reverse esc missing\\VAR_2\");",
"return -1;",
"}; SKIP_CACHE(re, &VAR_0->gb, 5);",
"VAR_6= VAR_6 * VAR_12 + VAR_13;",
"VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1); LAST_SKIP_CACHE(re, &VAR_0->gb, 1);",
"SKIP_COUNTER(re, &VAR_0->gb, 1+11+5+1);",
"VAR_7+= VAR_9 + 1;",
"if(VAR_8) VAR_7+=192;",
"}else{",
"int VAR_14;",
"VAR_14= GET_CACHE(re, &VAR_0->gb);",
"if(IS_3IV1)\nVAR_14 ^= 0xC0000000;",
"if (VAR_14&0x80000000) {",
"if (VAR_14&0x40000000) {",
"SKIP_CACHE(re, &VAR_0->gb, 2);",
"VAR_8= SHOW_UBITS(re, &VAR_0->gb, 1); SKIP_CACHE(re, &VAR_0->gb, 1);",
"VAR_9= SHOW_UBITS(re, &VAR_0->gb, 6); LAST_SKIP_CACHE(re, &VAR_0->gb, 6);",
"SKIP_COUNTER(re, &VAR_0->gb, 2+1+6);",
"UPDATE_CACHE(re, &VAR_0->gb);",
"if(IS_3IV1){",
"VAR_6= SHOW_SBITS(re, &VAR_0->gb, 12); LAST_SKIP_BITS(re, &VAR_0->gb, 12);",
"}else{",
"if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"1. marker bit missing in 3. esc\\VAR_2\");",
"return -1;",
"}; SKIP_CACHE(re, &VAR_0->gb, 1);",
"VAR_6= SHOW_SBITS(re, &VAR_0->gb, 12); SKIP_CACHE(re, &VAR_0->gb, 12);",
"if(SHOW_UBITS(re, &VAR_0->gb, 1)==0){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"2. marker bit missing in 3. esc\\VAR_2\");",
"return -1;",
"}; LAST_SKIP_CACHE(re, &VAR_0->gb, 1);",
"SKIP_COUNTER(re, &VAR_0->gb, 1+12+1);",
"}",
"#if 0\nif(VAR_0->error_resilience >= FF_ER_COMPLIANT){",
"const int abs_level= FFABS(VAR_6);",
"if(abs_level<=MAX_LEVEL && VAR_9<=MAX_RUN){",
"const int run1= VAR_9 - rl->max_run[VAR_8][abs_level] - 1;",
"if(abs_level <= rl->max_level[VAR_8][VAR_9]){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal 3. esc, vlc encoding possible\\VAR_2\");",
"return -1;",
"}",
"if(VAR_0->error_resilience > FF_ER_COMPLIANT){",
"if(abs_level <= rl->max_level[VAR_8][VAR_9]*2){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal 3. esc, esc 1 encoding possible\\VAR_2\");",
"return -1;",
"}",
"if(run1 >= 0 && abs_level <= rl->max_level[VAR_8][run1]){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal 3. esc, esc 2 encoding possible\\VAR_2\");",
"return -1;",
"}",
"}",
"}",
"}",
"#endif\nif (VAR_6>0) VAR_6= VAR_6 * VAR_12 + VAR_13;",
"else VAR_6= VAR_6 * VAR_12 - VAR_13;",
"if((unsigned)(VAR_6 + 2048) > 4095){",
"if(VAR_0->error_resilience > FF_ER_COMPLIANT){",
"if(VAR_6 > 2560 || VAR_6<-2560){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"|VAR_6| overflow in 3. esc, qp=%d\\VAR_2\", VAR_0->qscale);",
"return -1;",
"}",
"}",
"VAR_6= VAR_6<0 ? -2048 : 2047;",
"}",
"VAR_7+= VAR_9 + 1;",
"if(VAR_8) VAR_7+=192;",
"} else {",
"#if MIN_CACHE_BITS < 20\nLAST_SKIP_BITS(re, &VAR_0->gb, 2);",
"UPDATE_CACHE(re, &VAR_0->gb);",
"#else\nSKIP_BITS(re, &VAR_0->gb, 2);",
"#endif\nGET_RL_VLC(VAR_6, VAR_9, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2, 1);",
"VAR_7+= VAR_9 + rl->max_run[VAR_9>>7][VAR_6/VAR_12] +1;",
"VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);",
"LAST_SKIP_BITS(re, &VAR_0->gb, 1);",
"}",
"} else {",
"#if MIN_CACHE_BITS < 19\nLAST_SKIP_BITS(re, &VAR_0->gb, 1);",
"UPDATE_CACHE(re, &VAR_0->gb);",
"#else\nSKIP_BITS(re, &VAR_0->gb, 1);",
"#endif\nGET_RL_VLC(VAR_6, VAR_9, re, &VAR_0->gb, rl_vlc, TEX_VLC_BITS, 2, 1);",
"VAR_7+= VAR_9;",
"VAR_6 = VAR_6 + rl->max_level[VAR_9>>7][(VAR_9-1)&63] * VAR_12;",
"VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);",
"LAST_SKIP_BITS(re, &VAR_0->gb, 1);",
"}",
"}",
"} else {",
"VAR_7+= VAR_9;",
"VAR_6 = (VAR_6 ^ SHOW_SBITS(re, &VAR_0->gb, 1)) - SHOW_SBITS(re, &VAR_0->gb, 1);",
"LAST_SKIP_BITS(re, &VAR_0->gb, 1);",
"}",
"if (VAR_7 > 62){",
"VAR_7-= 192;",
"if(VAR_7&(~63)){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"ac-tex damaged at %d %d\\VAR_2\", VAR_0->mb_x, VAR_0->mb_y);",
"return -1;",
"}",
"VAR_1[VAR_11[VAR_7]] = VAR_6;",
"break;",
"}",
"VAR_1[VAR_11[VAR_7]] = VAR_6;",
"}",
"CLOSE_READER(re, &VAR_0->gb);",
"}",
"not_coded:\nif (VAR_4) {",
"if(!VAR_0->use_intra_dc_vlc){",
"VAR_1[0] = ff_mpeg4_pred_dc(VAR_0, VAR_2, VAR_1[0], &VAR_10, 0);",
"VAR_7 -= VAR_7>>31;",
"}",
"mpeg4_pred_ac(VAR_0, VAR_1, VAR_2, VAR_10);",
"if (VAR_0->ac_pred) {",
"VAR_7 = 63;",
"}",
"}",
"VAR_0->block_last_index[VAR_2] = VAR_7;",
"return 0;",
"}"
] |
[
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63,
65
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85,
87
],
[
89,
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
121
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
197
],
[
199
],
[
201
],
[
203
],
[
207
],
[
211
],
[
213
],
[
215
],
[
217
],
[
221
],
[
223
],
[
225
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
241,
243
],
[
247
],
[
249
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
281
],
[
285
],
[
287
],
[
289
],
[
291
],
[
295
],
[
297
],
[
301,
303
],
[
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343,
345
],
[
347
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
371
],
[
373
],
[
375
],
[
379,
381
],
[
383
],
[
385,
387
],
[
389,
391
],
[
393
],
[
395
],
[
397
],
[
399
],
[
401
],
[
405,
407
],
[
409
],
[
411,
413
],
[
415,
417
],
[
419
],
[
421
],
[
423
],
[
425
],
[
427
],
[
429
],
[
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445
],
[
447
],
[
449
],
[
451
],
[
455
],
[
457
],
[
459
],
[
463
],
[
465
],
[
467
],
[
469
],
[
471,
473
],
[
475
],
[
477
],
[
481
],
[
483
],
[
487
],
[
489
],
[
491
],
[
493
],
[
495
],
[
497
],
[
499
],
[
501
]
] |
6,974 |
static void check_watchpoint(int offset, int len, int flags)
{
CPUState *cpu = current_cpu;
CPUArchState *env = cpu->env_ptr;
target_ulong pc, cs_base;
target_ulong vaddr;
CPUWatchpoint *wp;
int cpu_flags;
if (cpu->watchpoint_hit) {
/* We re-entered the check after replacing the TB. Now raise
* the debug interrupt so that is will trigger after the
* current instruction. */
cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);
return;
}
vaddr = (cpu->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
if (cpu_watchpoint_address_matches(wp, vaddr, len)
&& (wp->flags & flags)) {
if (flags == BP_MEM_READ) {
wp->flags |= BP_WATCHPOINT_HIT_READ;
} else {
wp->flags |= BP_WATCHPOINT_HIT_WRITE;
}
wp->hitaddr = vaddr;
if (!cpu->watchpoint_hit) {
cpu->watchpoint_hit = wp;
tb_check_watchpoint(cpu);
if (wp->flags & BP_STOP_BEFORE_ACCESS) {
cpu->exception_index = EXCP_DEBUG;
cpu_loop_exit(cpu);
} else {
cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
tb_gen_code(cpu, pc, cs_base, cpu_flags, 1);
cpu_resume_from_signal(cpu, NULL);
}
}
} else {
wp->flags &= ~BP_WATCHPOINT_HIT;
}
}
}
| true |
qemu
|
66b9b43c42049bcae37668e890fedde9a72c8167
|
static void check_watchpoint(int offset, int len, int flags)
{
CPUState *cpu = current_cpu;
CPUArchState *env = cpu->env_ptr;
target_ulong pc, cs_base;
target_ulong vaddr;
CPUWatchpoint *wp;
int cpu_flags;
if (cpu->watchpoint_hit) {
cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);
return;
}
vaddr = (cpu->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
if (cpu_watchpoint_address_matches(wp, vaddr, len)
&& (wp->flags & flags)) {
if (flags == BP_MEM_READ) {
wp->flags |= BP_WATCHPOINT_HIT_READ;
} else {
wp->flags |= BP_WATCHPOINT_HIT_WRITE;
}
wp->hitaddr = vaddr;
if (!cpu->watchpoint_hit) {
cpu->watchpoint_hit = wp;
tb_check_watchpoint(cpu);
if (wp->flags & BP_STOP_BEFORE_ACCESS) {
cpu->exception_index = EXCP_DEBUG;
cpu_loop_exit(cpu);
} else {
cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
tb_gen_code(cpu, pc, cs_base, cpu_flags, 1);
cpu_resume_from_signal(cpu, NULL);
}
}
} else {
wp->flags &= ~BP_WATCHPOINT_HIT;
}
}
}
|
{
"code": [
"static void check_watchpoint(int offset, int len, int flags)"
],
"line_no": [
1
]
}
|
static void FUNC_0(int VAR_0, int VAR_1, int VAR_2)
{
CPUState *cpu = current_cpu;
CPUArchState *env = cpu->env_ptr;
target_ulong pc, cs_base;
target_ulong vaddr;
CPUWatchpoint *wp;
int VAR_3;
if (cpu->watchpoint_hit) {
cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);
return;
}
vaddr = (cpu->mem_io_vaddr & TARGET_PAGE_MASK) + VAR_0;
QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
if (cpu_watchpoint_address_matches(wp, vaddr, VAR_1)
&& (wp->VAR_2 & VAR_2)) {
if (VAR_2 == BP_MEM_READ) {
wp->VAR_2 |= BP_WATCHPOINT_HIT_READ;
} else {
wp->VAR_2 |= BP_WATCHPOINT_HIT_WRITE;
}
wp->hitaddr = vaddr;
if (!cpu->watchpoint_hit) {
cpu->watchpoint_hit = wp;
tb_check_watchpoint(cpu);
if (wp->VAR_2 & BP_STOP_BEFORE_ACCESS) {
cpu->exception_index = EXCP_DEBUG;
cpu_loop_exit(cpu);
} else {
cpu_get_tb_cpu_state(env, &pc, &cs_base, &VAR_3);
tb_gen_code(cpu, pc, cs_base, VAR_3, 1);
cpu_resume_from_signal(cpu, NULL);
}
}
} else {
wp->VAR_2 &= ~BP_WATCHPOINT_HIT;
}
}
}
|
[
"static void FUNC_0(int VAR_0, int VAR_1, int VAR_2)\n{",
"CPUState *cpu = current_cpu;",
"CPUArchState *env = cpu->env_ptr;",
"target_ulong pc, cs_base;",
"target_ulong vaddr;",
"CPUWatchpoint *wp;",
"int VAR_3;",
"if (cpu->watchpoint_hit) {",
"cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);",
"return;",
"}",
"vaddr = (cpu->mem_io_vaddr & TARGET_PAGE_MASK) + VAR_0;",
"QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {",
"if (cpu_watchpoint_address_matches(wp, vaddr, VAR_1)\n&& (wp->VAR_2 & VAR_2)) {",
"if (VAR_2 == BP_MEM_READ) {",
"wp->VAR_2 |= BP_WATCHPOINT_HIT_READ;",
"} else {",
"wp->VAR_2 |= BP_WATCHPOINT_HIT_WRITE;",
"}",
"wp->hitaddr = vaddr;",
"if (!cpu->watchpoint_hit) {",
"cpu->watchpoint_hit = wp;",
"tb_check_watchpoint(cpu);",
"if (wp->VAR_2 & BP_STOP_BEFORE_ACCESS) {",
"cpu->exception_index = EXCP_DEBUG;",
"cpu_loop_exit(cpu);",
"} else {",
"cpu_get_tb_cpu_state(env, &pc, &cs_base, &VAR_3);",
"tb_gen_code(cpu, pc, cs_base, VAR_3, 1);",
"cpu_resume_from_signal(cpu, NULL);",
"}",
"}",
"} else {",
"wp->VAR_2 &= ~BP_WATCHPOINT_HIT;",
"}",
"}",
"}"
] |
[
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
]
] |
6,975 |
int ff_mov_read_esds(AVFormatContext *fc, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st;
int tag, len;
if (fc->nb_streams < 1)
return 0;
st = fc->streams[fc->nb_streams-1];
get_be32(pb); /* version + flags */
len = mp4_read_descr(fc, pb, &tag);
if (tag == MP4ESDescrTag) {
get_be16(pb); /* ID */
get_byte(pb); /* priority */
} else
get_be16(pb); /* ID */
len = mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecConfigDescrTag) {
int object_type_id = get_byte(pb);
get_byte(pb); /* stream type */
get_be24(pb); /* buffer size db */
get_be32(pb); /* max bitrate */
get_be32(pb); /* avg bitrate */
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
dprintf(fc, "esds object type id 0x%02x\n", object_type_id);
len = mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecSpecificDescrTag) {
dprintf(fc, "Specific MPEG4 header len=%d\n", len);
if((uint64_t)len > (1<<30))
return -1;
st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, len);
st->codec->extradata_size = len;
if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg;
ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size);
st->codec->channels = cfg.channels;
if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
else if (cfg.ext_sample_rate)
st->codec->sample_rate = cfg.ext_sample_rate;
else
st->codec->sample_rate = cfg.sample_rate;
dprintf(fc, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type)))
st->codec->codec_id = CODEC_ID_AAC;
}
}
}
return 0;
}
| true |
FFmpeg
|
2f412421e8bb1927fcd866777dfedf223c9dfdfb
|
int ff_mov_read_esds(AVFormatContext *fc, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st;
int tag, len;
if (fc->nb_streams < 1)
return 0;
st = fc->streams[fc->nb_streams-1];
get_be32(pb);
len = mp4_read_descr(fc, pb, &tag);
if (tag == MP4ESDescrTag) {
get_be16(pb);
get_byte(pb);
} else
get_be16(pb);
len = mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecConfigDescrTag) {
int object_type_id = get_byte(pb);
get_byte(pb);
get_be24(pb);
get_be32(pb);
get_be32(pb);
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
dprintf(fc, "esds object type id 0x%02x\n", object_type_id);
len = mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecSpecificDescrTag) {
dprintf(fc, "Specific MPEG4 header len=%d\n", len);
if((uint64_t)len > (1<<30))
return -1;
st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, len);
st->codec->extradata_size = len;
if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg;
ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size);
st->codec->channels = cfg.channels;
if (cfg.object_type == 29 && cfg.sampling_index < 3)
st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
else if (cfg.ext_sample_rate)
st->codec->sample_rate = cfg.ext_sample_rate;
else
st->codec->sample_rate = cfg.sample_rate;
dprintf(fc, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type)))
st->codec->codec_id = CODEC_ID_AAC;
}
}
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
int FUNC_0(AVFormatContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)
{
AVStream *st;
int VAR_3, VAR_4;
if (VAR_0->nb_streams < 1)
return 0;
st = VAR_0->streams[VAR_0->nb_streams-1];
get_be32(VAR_1);
VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);
if (VAR_3 == MP4ESDescrTag) {
get_be16(VAR_1);
get_byte(VAR_1);
} else
get_be16(VAR_1);
VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);
if (VAR_3 == MP4DecConfigDescrTag) {
int VAR_5 = get_byte(VAR_1);
get_byte(VAR_1);
get_be24(VAR_1);
get_be32(VAR_1);
get_be32(VAR_1);
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, VAR_5);
dprintf(VAR_0, "esds object type id 0x%02x\n", VAR_5);
VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);
if (VAR_3 == MP4DecSpecificDescrTag) {
dprintf(VAR_0, "Specific MPEG4 header VAR_4=%d\n", VAR_4);
if((uint64_t)VAR_4 > (1<<30))
return -1;
st->codec->extradata = av_mallocz(VAR_4 + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
get_buffer(VAR_1, st->codec->extradata, VAR_4);
st->codec->extradata_size = VAR_4;
if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg;
ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size);
st->codec->channels = cfg.channels;
if (cfg.object_type == 29 && cfg.sampling_index < 3)
st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
else if (cfg.ext_sample_rate)
st->codec->sample_rate = cfg.ext_sample_rate;
else
st->codec->sample_rate = cfg.sample_rate;
dprintf(VAR_0, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type)))
st->codec->codec_id = CODEC_ID_AAC;
}
}
}
return 0;
}
|
[
"int FUNC_0(AVFormatContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)\n{",
"AVStream *st;",
"int VAR_3, VAR_4;",
"if (VAR_0->nb_streams < 1)\nreturn 0;",
"st = VAR_0->streams[VAR_0->nb_streams-1];",
"get_be32(VAR_1);",
"VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);",
"if (VAR_3 == MP4ESDescrTag) {",
"get_be16(VAR_1);",
"get_byte(VAR_1);",
"} else",
"get_be16(VAR_1);",
"VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);",
"if (VAR_3 == MP4DecConfigDescrTag) {",
"int VAR_5 = get_byte(VAR_1);",
"get_byte(VAR_1);",
"get_be24(VAR_1);",
"get_be32(VAR_1);",
"get_be32(VAR_1);",
"st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, VAR_5);",
"dprintf(VAR_0, \"esds object type id 0x%02x\\n\", VAR_5);",
"VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);",
"if (VAR_3 == MP4DecSpecificDescrTag) {",
"dprintf(VAR_0, \"Specific MPEG4 header VAR_4=%d\\n\", VAR_4);",
"if((uint64_t)VAR_4 > (1<<30))\nreturn -1;",
"st->codec->extradata = av_mallocz(VAR_4 + FF_INPUT_BUFFER_PADDING_SIZE);",
"if (!st->codec->extradata)\nreturn AVERROR(ENOMEM);",
"get_buffer(VAR_1, st->codec->extradata, VAR_4);",
"st->codec->extradata_size = VAR_4;",
"if (st->codec->codec_id == CODEC_ID_AAC) {",
"MPEG4AudioConfig cfg;",
"ff_mpeg4audio_get_config(&cfg, st->codec->extradata,\nst->codec->extradata_size);",
"st->codec->channels = cfg.channels;",
"if (cfg.object_type == 29 && cfg.sampling_index < 3)\nst->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];",
"else if (cfg.ext_sample_rate)\nst->codec->sample_rate = cfg.ext_sample_rate;",
"else\nst->codec->sample_rate = cfg.sample_rate;",
"dprintf(VAR_0, \"mp4a config channels %d obj %d ext obj %d \"\n\"sample rate %d ext sample rate %d\\n\", st->codec->channels,\ncfg.object_type, cfg.ext_object_type,\ncfg.sample_rate, cfg.ext_sample_rate);",
"if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,\ncfg.object_type)))\nst->codec->codec_id = CODEC_ID_AAC;",
"}",
"}",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61,
63
],
[
66
],
[
68,
70
],
[
72
],
[
74
],
[
76
],
[
78
],
[
80,
82
],
[
84
],
[
86,
88
],
[
90,
92
],
[
94,
96
],
[
98,
100,
102,
104
],
[
106,
108,
110
],
[
112
],
[
114
],
[
116
],
[
118
],
[
120
]
] |
6,976 |
PPC_OP(neg)
{
if (T0 != 0x80000000) {
T0 = -Ts0;
}
RETURN();
}
| true |
qemu
|
d9bce9d99f4656ae0b0127f7472db9067b8f84ab
|
PPC_OP(neg)
{
if (T0 != 0x80000000) {
T0 = -Ts0;
}
RETURN();
}
|
{
"code": [
" RETURN();",
"PPC_OP(neg)",
" if (T0 != 0x80000000) {",
" T0 = -Ts0;",
" T0 = -Ts0;",
" RETURN();"
],
"line_no": [
11,
1,
5,
7,
7,
11
]
}
|
FUNC_0(VAR_0)
{
if (T0 != 0x80000000) {
T0 = -Ts0;
}
RETURN();
}
|
[
"FUNC_0(VAR_0)\n{",
"if (T0 != 0x80000000) {",
"T0 = -Ts0;",
"}",
"RETURN();",
"}"
] |
[
1,
1,
1,
0,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
6,977 |
static inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1,
TCGv arg2, bool add_ca, bool compute_ca,
bool compute_ov, bool compute_rc0)
{
TCGv t0 = ret;
if (compute_ca || compute_ov) {
t0 = tcg_temp_new();
}
if (compute_ca) {
/* dest = ~arg1 + arg2 [+ ca]. */
if (NARROW_MODE(ctx)) {
/* Caution: a non-obvious corner case of the spec is that we
must produce the *entire* 64-bit addition, but produce the
carry into bit 32. */
TCGv inv1 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
tcg_gen_not_tl(inv1, arg1);
if (add_ca) {
tcg_gen_add_tl(t0, arg2, cpu_ca);
} else {
tcg_gen_addi_tl(t0, arg2, 1);
}
tcg_gen_xor_tl(t1, arg2, inv1); /* add without carry */
tcg_gen_add_tl(t0, t0, inv1);
tcg_gen_xor_tl(cpu_ca, t0, t1); /* bits changes w/ carry */
tcg_temp_free(t1);
tcg_gen_shri_tl(cpu_ca, cpu_ca, 32); /* extract bit 32 */
tcg_gen_andi_tl(cpu_ca, cpu_ca, 1);
} else if (add_ca) {
TCGv zero, inv1 = tcg_temp_new();
tcg_gen_not_tl(inv1, arg1);
zero = tcg_const_tl(0);
tcg_gen_add2_tl(t0, cpu_ca, arg2, zero, cpu_ca, zero);
tcg_gen_add2_tl(t0, cpu_ca, t0, cpu_ca, inv1, zero);
tcg_temp_free(zero);
} else {
tcg_gen_setcond_tl(TCG_COND_GEU, cpu_ca, arg2, arg1);
tcg_gen_sub_tl(t0, arg2, arg1);
}
} else if (add_ca) {
/* Since we're ignoring carry-out, we can simplify the
standard ~arg1 + arg2 + ca to arg2 - arg1 + ca - 1. */
tcg_gen_sub_tl(t0, arg2, arg1);
tcg_gen_add_tl(t0, t0, cpu_ca);
tcg_gen_subi_tl(t0, t0, 1);
} else {
tcg_gen_sub_tl(t0, arg2, arg1);
}
if (compute_ov) {
gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 1);
}
if (unlikely(compute_rc0)) {
gen_set_Rc0(ctx, t0);
}
if (!TCGV_EQUAL(t0, ret)) {
tcg_gen_mov_tl(ret, t0);
tcg_temp_free(t0);
}
}
| true |
qemu
|
c80d1df5083846396ab5120731a76a9d62900fda
|
static inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1,
TCGv arg2, bool add_ca, bool compute_ca,
bool compute_ov, bool compute_rc0)
{
TCGv t0 = ret;
if (compute_ca || compute_ov) {
t0 = tcg_temp_new();
}
if (compute_ca) {
if (NARROW_MODE(ctx)) {
TCGv inv1 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
tcg_gen_not_tl(inv1, arg1);
if (add_ca) {
tcg_gen_add_tl(t0, arg2, cpu_ca);
} else {
tcg_gen_addi_tl(t0, arg2, 1);
}
tcg_gen_xor_tl(t1, arg2, inv1);
tcg_gen_add_tl(t0, t0, inv1);
tcg_gen_xor_tl(cpu_ca, t0, t1);
tcg_temp_free(t1);
tcg_gen_shri_tl(cpu_ca, cpu_ca, 32);
tcg_gen_andi_tl(cpu_ca, cpu_ca, 1);
} else if (add_ca) {
TCGv zero, inv1 = tcg_temp_new();
tcg_gen_not_tl(inv1, arg1);
zero = tcg_const_tl(0);
tcg_gen_add2_tl(t0, cpu_ca, arg2, zero, cpu_ca, zero);
tcg_gen_add2_tl(t0, cpu_ca, t0, cpu_ca, inv1, zero);
tcg_temp_free(zero);
} else {
tcg_gen_setcond_tl(TCG_COND_GEU, cpu_ca, arg2, arg1);
tcg_gen_sub_tl(t0, arg2, arg1);
}
} else if (add_ca) {
tcg_gen_sub_tl(t0, arg2, arg1);
tcg_gen_add_tl(t0, t0, cpu_ca);
tcg_gen_subi_tl(t0, t0, 1);
} else {
tcg_gen_sub_tl(t0, arg2, arg1);
}
if (compute_ov) {
gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 1);
}
if (unlikely(compute_rc0)) {
gen_set_Rc0(ctx, t0);
}
if (!TCGV_EQUAL(t0, ret)) {
tcg_gen_mov_tl(ret, t0);
tcg_temp_free(t0);
}
}
|
{
"code": [],
"line_no": []
}
|
static inline void FUNC_0(DisasContext *VAR_0, TCGv VAR_1, TCGv VAR_2,
TCGv VAR_3, bool VAR_4, bool VAR_5,
bool VAR_6, bool VAR_7)
{
TCGv t0 = VAR_1;
if (VAR_5 || VAR_6) {
t0 = tcg_temp_new();
}
if (VAR_5) {
if (NARROW_MODE(VAR_0)) {
TCGv inv1 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
tcg_gen_not_tl(inv1, VAR_2);
if (VAR_4) {
tcg_gen_add_tl(t0, VAR_3, cpu_ca);
} else {
tcg_gen_addi_tl(t0, VAR_3, 1);
}
tcg_gen_xor_tl(t1, VAR_3, inv1);
tcg_gen_add_tl(t0, t0, inv1);
tcg_gen_xor_tl(cpu_ca, t0, t1);
tcg_temp_free(t1);
tcg_gen_shri_tl(cpu_ca, cpu_ca, 32);
tcg_gen_andi_tl(cpu_ca, cpu_ca, 1);
} else if (VAR_4) {
TCGv zero, inv1 = tcg_temp_new();
tcg_gen_not_tl(inv1, VAR_2);
zero = tcg_const_tl(0);
tcg_gen_add2_tl(t0, cpu_ca, VAR_3, zero, cpu_ca, zero);
tcg_gen_add2_tl(t0, cpu_ca, t0, cpu_ca, inv1, zero);
tcg_temp_free(zero);
} else {
tcg_gen_setcond_tl(TCG_COND_GEU, cpu_ca, VAR_3, VAR_2);
tcg_gen_sub_tl(t0, VAR_3, VAR_2);
}
} else if (VAR_4) {
tcg_gen_sub_tl(t0, VAR_3, VAR_2);
tcg_gen_add_tl(t0, t0, cpu_ca);
tcg_gen_subi_tl(t0, t0, 1);
} else {
tcg_gen_sub_tl(t0, VAR_3, VAR_2);
}
if (VAR_6) {
gen_op_arith_compute_ov(VAR_0, t0, VAR_2, VAR_3, 1);
}
if (unlikely(VAR_7)) {
gen_set_Rc0(VAR_0, t0);
}
if (!TCGV_EQUAL(t0, VAR_1)) {
tcg_gen_mov_tl(VAR_1, t0);
tcg_temp_free(t0);
}
}
|
[
"static inline void FUNC_0(DisasContext *VAR_0, TCGv VAR_1, TCGv VAR_2,\nTCGv VAR_3, bool VAR_4, bool VAR_5,\nbool VAR_6, bool VAR_7)\n{",
"TCGv t0 = VAR_1;",
"if (VAR_5 || VAR_6) {",
"t0 = tcg_temp_new();",
"}",
"if (VAR_5) {",
"if (NARROW_MODE(VAR_0)) {",
"TCGv inv1 = tcg_temp_new();",
"TCGv t1 = tcg_temp_new();",
"tcg_gen_not_tl(inv1, VAR_2);",
"if (VAR_4) {",
"tcg_gen_add_tl(t0, VAR_3, cpu_ca);",
"} else {",
"tcg_gen_addi_tl(t0, VAR_3, 1);",
"}",
"tcg_gen_xor_tl(t1, VAR_3, inv1);",
"tcg_gen_add_tl(t0, t0, inv1);",
"tcg_gen_xor_tl(cpu_ca, t0, t1);",
"tcg_temp_free(t1);",
"tcg_gen_shri_tl(cpu_ca, cpu_ca, 32);",
"tcg_gen_andi_tl(cpu_ca, cpu_ca, 1);",
"} else if (VAR_4) {",
"TCGv zero, inv1 = tcg_temp_new();",
"tcg_gen_not_tl(inv1, VAR_2);",
"zero = tcg_const_tl(0);",
"tcg_gen_add2_tl(t0, cpu_ca, VAR_3, zero, cpu_ca, zero);",
"tcg_gen_add2_tl(t0, cpu_ca, t0, cpu_ca, inv1, zero);",
"tcg_temp_free(zero);",
"} else {",
"tcg_gen_setcond_tl(TCG_COND_GEU, cpu_ca, VAR_3, VAR_2);",
"tcg_gen_sub_tl(t0, VAR_3, VAR_2);",
"}",
"} else if (VAR_4) {",
"tcg_gen_sub_tl(t0, VAR_3, VAR_2);",
"tcg_gen_add_tl(t0, t0, cpu_ca);",
"tcg_gen_subi_tl(t0, t0, 1);",
"} else {",
"tcg_gen_sub_tl(t0, VAR_3, VAR_2);",
"}",
"if (VAR_6) {",
"gen_op_arith_compute_ov(VAR_0, t0, VAR_2, VAR_3, 1);",
"}",
"if (unlikely(VAR_7)) {",
"gen_set_Rc0(VAR_0, t0);",
"}",
"if (!TCGV_EQUAL(t0, VAR_1)) {",
"tcg_gen_mov_tl(VAR_1, t0);",
"tcg_temp_free(t0);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
54
],
[
56
],
[
58
],
[
60
],
[
62
],
[
64
],
[
66
],
[
68
],
[
70
],
[
72
],
[
74
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
]
] |
6,978 |
static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
{
BDRVVPCState *s = bs->opaque;
VHDFooter *footer = (VHDFooter*) s->footer_buf;
int64_t start, offset;
bool allocated;
int64_t ret;
int n;
if (be32_to_cpu(footer->type) == VHD_FIXED) {
*pnum = nb_sectors;
*file = bs->file->bs;
return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |
(sector_num << BDRV_SECTOR_BITS);
}
qemu_co_mutex_lock(&s->lock);
offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);
start = offset;
allocated = (offset != -1);
*pnum = 0;
ret = 0;
do {
/* All sectors in a block are contiguous (without using the bitmap) */
n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)
- sector_num;
n = MIN(n, nb_sectors);
*pnum += n;
sector_num += n;
nb_sectors -= n;
/* *pnum can't be greater than one block for allocated
* sectors since there is always a bitmap in between. */
if (allocated) {
*file = bs->file->bs;
ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
break;
}
if (nb_sectors == 0) {
break;
}
offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);
} while (offset == -1);
qemu_co_mutex_unlock(&s->lock);
return ret;
}
| true |
qemu
|
cfc87e00c22ab4ea0262c9771c803ed03d754001
|
static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
{
BDRVVPCState *s = bs->opaque;
VHDFooter *footer = (VHDFooter*) s->footer_buf;
int64_t start, offset;
bool allocated;
int64_t ret;
int n;
if (be32_to_cpu(footer->type) == VHD_FIXED) {
*pnum = nb_sectors;
*file = bs->file->bs;
return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |
(sector_num << BDRV_SECTOR_BITS);
}
qemu_co_mutex_lock(&s->lock);
offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);
start = offset;
allocated = (offset != -1);
*pnum = 0;
ret = 0;
do {
n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)
- sector_num;
n = MIN(n, nb_sectors);
*pnum += n;
sector_num += n;
nb_sectors -= n;
if (allocated) {
*file = bs->file->bs;
ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
break;
}
if (nb_sectors == 0) {
break;
}
offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);
} while (offset == -1);
qemu_co_mutex_unlock(&s->lock);
return ret;
}
|
{
"code": [
" offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);",
" offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);"
],
"line_no": [
39,
89
]
}
|
static int64_t VAR_0 vpc_co_get_block_status(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)
{
BDRVVPCState *s = bs->opaque;
VHDFooter *footer = (VHDFooter*) s->footer_buf;
int64_t start, offset;
bool allocated;
int64_t ret;
int n;
if (be32_to_cpu(footer->type) == VHD_FIXED) {
*pnum = nb_sectors;
*file = bs->file->bs;
return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |
(sector_num << BDRV_SECTOR_BITS);
}
qemu_co_mutex_lock(&s->lock);
offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);
start = offset;
allocated = (offset != -1);
*pnum = 0;
ret = 0;
do {
n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)
- sector_num;
n = MIN(n, nb_sectors);
*pnum += n;
sector_num += n;
nb_sectors -= n;
if (allocated) {
*file = bs->file->bs;
ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
break;
}
if (nb_sectors == 0) {
break;
}
offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);
} while (offset == -1);
qemu_co_mutex_unlock(&s->lock);
return ret;
}
|
[
"static int64_t VAR_0 vpc_co_get_block_status(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file)\n{",
"BDRVVPCState *s = bs->opaque;",
"VHDFooter *footer = (VHDFooter*) s->footer_buf;",
"int64_t start, offset;",
"bool allocated;",
"int64_t ret;",
"int n;",
"if (be32_to_cpu(footer->type) == VHD_FIXED) {",
"*pnum = nb_sectors;",
"*file = bs->file->bs;",
"return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID |\n(sector_num << BDRV_SECTOR_BITS);",
"}",
"qemu_co_mutex_lock(&s->lock);",
"offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);",
"start = offset;",
"allocated = (offset != -1);",
"*pnum = 0;",
"ret = 0;",
"do {",
"n = ROUND_UP(sector_num + 1, s->block_size / BDRV_SECTOR_SIZE)\n- sector_num;",
"n = MIN(n, nb_sectors);",
"*pnum += n;",
"sector_num += n;",
"nb_sectors -= n;",
"if (allocated) {",
"*file = bs->file->bs;",
"ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;",
"break;",
"}",
"if (nb_sectors == 0) {",
"break;",
"}",
"offset = get_image_offset(bs, sector_num << BDRV_SECTOR_BITS, false);",
"} while (offset == -1);",
"qemu_co_mutex_unlock(&s->lock);",
"return ret;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
55,
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
]
] |
6,979 |
struct pxa2xx_mmci_s *pxa2xx_mmci_init(target_phys_addr_t base,
qemu_irq irq, void *dma)
{
int iomemtype;
struct pxa2xx_mmci_s *s;
s = (struct pxa2xx_mmci_s *) qemu_mallocz(sizeof(struct pxa2xx_mmci_s));
s->base = base;
s->irq = irq;
s->dma = dma;
iomemtype = cpu_register_io_memory(0, pxa2xx_mmci_readfn,
pxa2xx_mmci_writefn, s);
cpu_register_physical_memory(base, 0x000fffff, iomemtype);
/* Instantiate the actual storage */
s->card = sd_init(sd_bdrv);
register_savevm("pxa2xx_mmci", 0, 0,
pxa2xx_mmci_save, pxa2xx_mmci_load, s);
return s;
}
| true |
qemu
|
187337f8b0ec0813dd3876d1efe37d415fb81c2e
|
struct pxa2xx_mmci_s *pxa2xx_mmci_init(target_phys_addr_t base,
qemu_irq irq, void *dma)
{
int iomemtype;
struct pxa2xx_mmci_s *s;
s = (struct pxa2xx_mmci_s *) qemu_mallocz(sizeof(struct pxa2xx_mmci_s));
s->base = base;
s->irq = irq;
s->dma = dma;
iomemtype = cpu_register_io_memory(0, pxa2xx_mmci_readfn,
pxa2xx_mmci_writefn, s);
cpu_register_physical_memory(base, 0x000fffff, iomemtype);
s->card = sd_init(sd_bdrv);
register_savevm("pxa2xx_mmci", 0, 0,
pxa2xx_mmci_save, pxa2xx_mmci_load, s);
return s;
}
|
{
"code": [
" cpu_register_physical_memory(base, 0x000fffff, iomemtype);",
" cpu_register_physical_memory(base, 0x000fffff, iomemtype);",
" cpu_register_physical_memory(base, 0x000fffff, iomemtype);"
],
"line_no": [
27,
27,
27
]
}
|
struct pxa2xx_mmci_s *FUNC_0(target_phys_addr_t VAR_0,
qemu_irq VAR_1, void *VAR_2)
{
int VAR_3;
struct pxa2xx_mmci_s *VAR_4;
VAR_4 = (struct pxa2xx_mmci_s *) qemu_mallocz(sizeof(struct pxa2xx_mmci_s));
VAR_4->VAR_0 = VAR_0;
VAR_4->VAR_1 = VAR_1;
VAR_4->VAR_2 = VAR_2;
VAR_3 = cpu_register_io_memory(0, pxa2xx_mmci_readfn,
pxa2xx_mmci_writefn, VAR_4);
cpu_register_physical_memory(VAR_0, 0x000fffff, VAR_3);
VAR_4->card = sd_init(sd_bdrv);
register_savevm("pxa2xx_mmci", 0, 0,
pxa2xx_mmci_save, pxa2xx_mmci_load, VAR_4);
return VAR_4;
}
|
[
"struct pxa2xx_mmci_s *FUNC_0(target_phys_addr_t VAR_0,\nqemu_irq VAR_1, void *VAR_2)\n{",
"int VAR_3;",
"struct pxa2xx_mmci_s *VAR_4;",
"VAR_4 = (struct pxa2xx_mmci_s *) qemu_mallocz(sizeof(struct pxa2xx_mmci_s));",
"VAR_4->VAR_0 = VAR_0;",
"VAR_4->VAR_1 = VAR_1;",
"VAR_4->VAR_2 = VAR_2;",
"VAR_3 = cpu_register_io_memory(0, pxa2xx_mmci_readfn,\npxa2xx_mmci_writefn, VAR_4);",
"cpu_register_physical_memory(VAR_0, 0x000fffff, VAR_3);",
"VAR_4->card = sd_init(sd_bdrv);",
"register_savevm(\"pxa2xx_mmci\", 0, 0,\npxa2xx_mmci_save, pxa2xx_mmci_load, VAR_4);",
"return VAR_4;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25
],
[
27
],
[
33
],
[
37,
39
],
[
43
],
[
45
]
] |
6,980 |
void kvmppc_set_papr(CPUPPCState *env)
{
struct kvm_enable_cap cap = {};
struct kvm_one_reg reg = {};
struct kvm_sregs sregs = {};
int ret;
uint64_t hior = env->spr[SPR_HIOR];
cap.cap = KVM_CAP_PPC_PAPR;
ret = kvm_vcpu_ioctl(env, KVM_ENABLE_CAP, &cap);
if (ret) {
goto fail;
}
/*
* XXX We set HIOR here. It really should be a qdev property of
* the CPU node, but we don't have CPUs converted to qdev yet.
*
* Once we have qdev CPUs, move HIOR to a qdev property and
* remove this chunk.
*/
reg.id = KVM_REG_PPC_HIOR;
reg.addr = (uintptr_t)&hior;
ret = kvm_vcpu_ioctl(env, KVM_SET_ONE_REG, ®);
if (ret) {
fprintf(stderr, "Couldn't set HIOR. Maybe you're running an old \n"
"kernel with support for HV KVM but no PAPR PR \n"
"KVM in which case things will work. If they don't \n"
"please update your host kernel!\n");
}
/* Set SDR1 so kernel space finds the HTAB */
ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
if (ret) {
goto fail;
}
sregs.u.s.sdr1 = env->spr[SPR_SDR1];
ret = kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs);
if (ret) {
goto fail;
}
return;
fail:
cpu_abort(env, "This KVM version does not support PAPR\n");
}
| true |
qemu
|
f1af19d767073a0926ce12c19b1f06c4933bca35
|
void kvmppc_set_papr(CPUPPCState *env)
{
struct kvm_enable_cap cap = {};
struct kvm_one_reg reg = {};
struct kvm_sregs sregs = {};
int ret;
uint64_t hior = env->spr[SPR_HIOR];
cap.cap = KVM_CAP_PPC_PAPR;
ret = kvm_vcpu_ioctl(env, KVM_ENABLE_CAP, &cap);
if (ret) {
goto fail;
}
reg.id = KVM_REG_PPC_HIOR;
reg.addr = (uintptr_t)&hior;
ret = kvm_vcpu_ioctl(env, KVM_SET_ONE_REG, ®);
if (ret) {
fprintf(stderr, "Couldn't set HIOR. Maybe you're running an old \n"
"kernel with support for HV KVM but no PAPR PR \n"
"KVM in which case things will work. If they don't \n"
"please update your host kernel!\n");
}
ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
if (ret) {
goto fail;
}
sregs.u.s.sdr1 = env->spr[SPR_SDR1];
ret = kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs);
if (ret) {
goto fail;
}
return;
fail:
cpu_abort(env, "This KVM version does not support PAPR\n");
}
|
{
"code": [
" struct kvm_one_reg reg = {};",
" struct kvm_sregs sregs = {};",
" uint64_t hior = env->spr[SPR_HIOR];",
" goto fail;",
" reg.id = KVM_REG_PPC_HIOR;",
" reg.addr = (uintptr_t)&hior;",
" ret = kvm_vcpu_ioctl(env, KVM_SET_ONE_REG, ®);",
" if (ret) {",
" fprintf(stderr, \"Couldn't set HIOR. Maybe you're running an old \\n\"",
" \"kernel with support for HV KVM but no PAPR PR \\n\"",
" \"KVM in which case things will work. If they don't \\n\"",
" \"please update your host kernel!\\n\");",
" ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);",
" if (ret) {",
" goto fail;",
" sregs.u.s.sdr1 = env->spr[SPR_SDR1];",
" ret = kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs);",
" if (ret) {",
" goto fail;",
"fail:",
" cpu_abort(env, \"This KVM version does not support PAPR\\n\");"
],
"line_no": [
7,
9,
13,
25,
45,
47,
49,
23,
53,
55,
57,
59,
67,
23,
25,
77,
81,
23,
25,
95,
97
]
}
|
void FUNC_0(CPUPPCState *VAR_0)
{
struct kvm_enable_cap VAR_1 = {};
struct kvm_one_reg VAR_2 = {};
struct kvm_sregs VAR_3 = {};
int VAR_4;
uint64_t hior = VAR_0->spr[SPR_HIOR];
VAR_1.VAR_1 = KVM_CAP_PPC_PAPR;
VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_ENABLE_CAP, &VAR_1);
if (VAR_4) {
goto fail;
}
VAR_2.id = KVM_REG_PPC_HIOR;
VAR_2.addr = (uintptr_t)&hior;
VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);
if (VAR_4) {
fprintf(stderr, "Couldn't set HIOR. Maybe you're running an old \n"
"kernel with support for HV KVM but no PAPR PR \n"
"KVM in which case things will work. If they don't \n"
"please update your host kernel!\n");
}
VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_GET_SREGS, &VAR_3);
if (VAR_4) {
goto fail;
}
VAR_3.u.s.sdr1 = VAR_0->spr[SPR_SDR1];
VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_SREGS, &VAR_3);
if (VAR_4) {
goto fail;
}
return;
fail:
cpu_abort(VAR_0, "This KVM version does not support PAPR\n");
}
|
[
"void FUNC_0(CPUPPCState *VAR_0)\n{",
"struct kvm_enable_cap VAR_1 = {};",
"struct kvm_one_reg VAR_2 = {};",
"struct kvm_sregs VAR_3 = {};",
"int VAR_4;",
"uint64_t hior = VAR_0->spr[SPR_HIOR];",
"VAR_1.VAR_1 = KVM_CAP_PPC_PAPR;",
"VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_ENABLE_CAP, &VAR_1);",
"if (VAR_4) {",
"goto fail;",
"}",
"VAR_2.id = KVM_REG_PPC_HIOR;",
"VAR_2.addr = (uintptr_t)&hior;",
"VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_ONE_REG, &VAR_2);",
"if (VAR_4) {",
"fprintf(stderr, \"Couldn't set HIOR. Maybe you're running an old \\n\"\n\"kernel with support for HV KVM but no PAPR PR \\n\"\n\"KVM in which case things will work. If they don't \\n\"\n\"please update your host kernel!\\n\");",
"}",
"VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_GET_SREGS, &VAR_3);",
"if (VAR_4) {",
"goto fail;",
"}",
"VAR_3.u.s.sdr1 = VAR_0->spr[SPR_SDR1];",
"VAR_4 = kvm_vcpu_ioctl(VAR_0, KVM_SET_SREGS, &VAR_3);",
"if (VAR_4) {",
"goto fail;",
"}",
"return;",
"fail:\ncpu_abort(VAR_0, \"This KVM version does not support PAPR\\n\");",
"}"
] |
[
0,
0,
1,
1,
0,
1,
0,
0,
1,
1,
0,
1,
1,
1,
0,
1,
0,
1,
0,
0,
0,
1,
1,
0,
0,
0,
0,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53,
55,
57,
59
],
[
61
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
95,
97
],
[
99
]
] |
6,982 |
static void send_ext_key_event_ack(VncState *vs)
{
vnc_lock_output(vs);
vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
vnc_write_u8(vs, 0);
vnc_write_u16(vs, 1);
vnc_framebuffer_update(vs, 0, 0,
surface_width(vs->vd->ds),
surface_height(vs->vd->ds),
VNC_ENCODING_EXT_KEY_EVENT);
vnc_unlock_output(vs);
vnc_flush(vs);
}
| true |
qemu
|
bea60dd7679364493a0d7f5b54316c767cf894ef
|
static void send_ext_key_event_ack(VncState *vs)
{
vnc_lock_output(vs);
vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
vnc_write_u8(vs, 0);
vnc_write_u16(vs, 1);
vnc_framebuffer_update(vs, 0, 0,
surface_width(vs->vd->ds),
surface_height(vs->vd->ds),
VNC_ENCODING_EXT_KEY_EVENT);
vnc_unlock_output(vs);
vnc_flush(vs);
}
|
{
"code": [
" surface_width(vs->vd->ds),",
" surface_height(vs->vd->ds),",
" surface_width(vs->vd->ds),",
" surface_height(vs->vd->ds),"
],
"line_no": [
15,
17,
15,
17
]
}
|
static void FUNC_0(VncState *VAR_0)
{
vnc_lock_output(VAR_0);
vnc_write_u8(VAR_0, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
vnc_write_u8(VAR_0, 0);
vnc_write_u16(VAR_0, 1);
vnc_framebuffer_update(VAR_0, 0, 0,
surface_width(VAR_0->vd->ds),
surface_height(VAR_0->vd->ds),
VNC_ENCODING_EXT_KEY_EVENT);
vnc_unlock_output(VAR_0);
vnc_flush(VAR_0);
}
|
[
"static void FUNC_0(VncState *VAR_0)\n{",
"vnc_lock_output(VAR_0);",
"vnc_write_u8(VAR_0, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);",
"vnc_write_u8(VAR_0, 0);",
"vnc_write_u16(VAR_0, 1);",
"vnc_framebuffer_update(VAR_0, 0, 0,\nsurface_width(VAR_0->vd->ds),\nsurface_height(VAR_0->vd->ds),\nVNC_ENCODING_EXT_KEY_EVENT);",
"vnc_unlock_output(VAR_0);",
"vnc_flush(VAR_0);",
"}"
] |
[
0,
0,
0,
0,
0,
1,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15,
17,
19
],
[
21
],
[
23
],
[
25
]
] |
6,983 |
static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, long src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm __volatile(
"movq %0, %%mm7\n\t"
"movq %1, %%mm6\n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 11;
while(s < mm_end)
{
__asm __volatile(
PREFETCH" 32%1\n\t"
"movd %1, %%mm0\n\t"
"movd 3%1, %%mm3\n\t"
"punpckldq 6%1, %%mm0\n\t"
"punpckldq 9%1, %%mm3\n\t"
"movq %%mm0, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm3, %%mm4\n\t"
"movq %%mm3, %%mm5\n\t"
"psrlq $3, %%mm0\n\t"
"psrlq $3, %%mm3\n\t"
"pand %2, %%mm0\n\t"
"pand %2, %%mm3\n\t"
"psrlq $6, %%mm1\n\t"
"psrlq $6, %%mm4\n\t"
"pand %%mm6, %%mm1\n\t"
"pand %%mm6, %%mm4\n\t"
"psrlq $9, %%mm2\n\t"
"psrlq $9, %%mm5\n\t"
"pand %%mm7, %%mm2\n\t"
"pand %%mm7, %%mm5\n\t"
"por %%mm1, %%mm0\n\t"
"por %%mm4, %%mm3\n\t"
"por %%mm2, %%mm0\n\t"
"por %%mm5, %%mm3\n\t"
"psllq $16, %%mm3\n\t"
"por %%mm3, %%mm0\n\t"
MOVNTQ" %%mm0, %0\n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 12;
}
__asm __volatile(SFENCE:::"memory");
__asm __volatile(EMMS:::"memory");
#endif
while(s < end)
{
const int b= *s++;
const int g= *s++;
const int r= *s++;
*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
}
}
| true |
FFmpeg
|
6e42e6c4b410dbef8b593c2d796a5dad95f89ee4
|
static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, long src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm __volatile(
"movq %0, %%mm7\n\t"
"movq %1, %%mm6\n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 11;
while(s < mm_end)
{
__asm __volatile(
PREFETCH" 32%1\n\t"
"movd %1, %%mm0\n\t"
"movd 3%1, %%mm3\n\t"
"punpckldq 6%1, %%mm0\n\t"
"punpckldq 9%1, %%mm3\n\t"
"movq %%mm0, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm3, %%mm4\n\t"
"movq %%mm3, %%mm5\n\t"
"psrlq $3, %%mm0\n\t"
"psrlq $3, %%mm3\n\t"
"pand %2, %%mm0\n\t"
"pand %2, %%mm3\n\t"
"psrlq $6, %%mm1\n\t"
"psrlq $6, %%mm4\n\t"
"pand %%mm6, %%mm1\n\t"
"pand %%mm6, %%mm4\n\t"
"psrlq $9, %%mm2\n\t"
"psrlq $9, %%mm5\n\t"
"pand %%mm7, %%mm2\n\t"
"pand %%mm7, %%mm5\n\t"
"por %%mm1, %%mm0\n\t"
"por %%mm4, %%mm3\n\t"
"por %%mm2, %%mm0\n\t"
"por %%mm5, %%mm3\n\t"
"psllq $16, %%mm3\n\t"
"por %%mm3, %%mm0\n\t"
MOVNTQ" %%mm0, %0\n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 12;
}
__asm __volatile(SFENCE:::"memory");
__asm __volatile(EMMS:::"memory");
#endif
while(s < end)
{
const int b= *s++;
const int g= *s++;
const int r= *s++;
*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
}
}
|
{
"code": [
"\twhile(s < end)",
"\twhile(s < end)",
"\twhile(s < end)",
"\twhile(s < end)",
"#ifdef HAVE_MMX",
"#endif",
"#ifdef HAVE_MMX",
"#endif",
"#endif",
"#endif",
"\t__asm __volatile(",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t__asm __volatile(",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm2\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm0\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm3\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"pand\t%2, %%mm3\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm2\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm5\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\td += 4;",
"#endif",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\td += 4;",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\t ::\"m\"(red_15mask),\"m\"(green_15mask));",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm0\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm3\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"pand\t%2, %%mm3\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm1\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm4\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"psrlq\t$9, %%mm2\\n\\t\"",
"\t\t\"psrlq\t$9, %%mm5\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm2\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm5\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\t:\"=m\"(*d):\"m\"(*s),\"m\"(blue_15mask):\"memory\");",
"\t\td += 4;",
"#endif",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\t ::\"m\"(red_15mask),\"m\"(green_15mask));",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm1\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm4\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\t:\"=m\"(*d):\"m\"(*s),\"m\"(blue_15mask):\"memory\");",
"\t\td += 4;",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\tmm_end = end - 11;",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movd\t3%1, %%mm3\\n\\t\"",
"\t\t\"punpckldq 6%1, %%mm0\\n\\t\"",
"\t\t\"punpckldq 9%1, %%mm3\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm0\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm3\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"pand\t%2, %%mm3\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm2\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm5\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\td += 4;",
"\t\ts += 12;",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\t\tconst int b= *s++;",
"\t\tconst int g= *s++;",
"\t\tconst int r= *s++;",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movd\t3%1, %%mm3\\n\\t\"",
"\t\t\"punpckldq 6%1, %%mm0\\n\\t\"",
"\t\t\"punpckldq 9%1, %%mm3\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\td += 4;",
"\t\ts += 12;",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\t\tconst int r= *s++;",
"\t\tconst int g= *s++;",
"\t\tconst int b= *s++;",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\t ::\"m\"(red_15mask),\"m\"(green_15mask));",
"\tmm_end = end - 11;",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movd\t3%1, %%mm3\\n\\t\"",
"\t\t\"punpckldq 6%1, %%mm0\\n\\t\"",
"\t\t\"punpckldq 9%1, %%mm3\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm0\\n\\t\"",
"\t\t\"psrlq\t$3, %%mm3\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"pand\t%2, %%mm3\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm1\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm4\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"psrlq\t$9, %%mm2\\n\\t\"",
"\t\t\"psrlq\t$9, %%mm5\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm2\\n\\t\"",
"\t\t\"pand\t%%mm7, %%mm5\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\t:\"=m\"(*d):\"m\"(*s),\"m\"(blue_15mask):\"memory\");",
"\t\td += 4;",
"\t\ts += 12;",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\t\tconst int b= *s++;",
"\t\tconst int g= *s++;",
"\t\tconst int r= *s++;",
"\t\t*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);",
"\tconst uint8_t *s = src;",
"\tconst uint8_t *end;",
"\tconst uint8_t *mm_end;",
"\tuint16_t *d = (uint16_t *)dst;",
"\tend = s + src_size;",
"\t__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"\t__asm __volatile(",
"\t \"movq\t%0, %%mm7\\n\\t\"",
"\t \"movq\t%1, %%mm6\\n\\t\"",
"\t ::\"m\"(red_15mask),\"m\"(green_15mask));",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"movd\t%1, %%mm0\\n\\t\"",
"\t\t\"movd\t3%1, %%mm3\\n\\t\"",
"\t\t\"punpckldq 6%1, %%mm0\\n\\t\"",
"\t\t\"punpckldq 9%1, %%mm3\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm1\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm4\\n\\t\"",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm1\\n\\t\"",
"\t\t\"psrlq\t$6, %%mm4\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm1\\n\\t\"",
"\t\t\"pand\t%%mm6, %%mm4\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"psllq\t$16, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm3, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t\t:\"=m\"(*d):\"m\"(*s),\"m\"(blue_15mask):\"memory\");",
"\t\td += 4;",
"\t\ts += 12;",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\t\tconst int r= *s++;",
"\t\tconst int g= *s++;",
"\t\tconst int b= *s++;",
"\t\t*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t __asm __volatile(",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t __asm __volatile(",
"\t\t\"movq\t%%mm3, %%mm5\\n\\t\"",
"\t\t\"movq\t%%mm0, %%mm2\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\twhile(s < mm_end)",
"\t __asm __volatile(",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\t\"pand\t%2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm1, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm2, %%mm0\\n\\t\"",
"\t\t\"por\t%%mm4, %%mm3\\n\\t\"",
"\t\t\"por\t%%mm5, %%mm3\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"\twhile(s < end)",
"\t__asm __volatile(",
"#endif",
"\t__asm __volatile(SFENCE:::\"memory\");",
"\t__asm __volatile(EMMS:::\"memory\");",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"#endif",
"\t\tPREFETCH\" 32%1\\n\\t\"",
"\t\tMOVNTQ\"\t%%mm0, %0\\n\\t\"",
"#endif",
"#endif"
],
"line_no": [
109,
109,
109,
109,
9,
13,
9,
13,
13,
13,
23,
49,
93,
23,
49,
77,
69,
81,
93,
5,
7,
11,
15,
17,
21,
23,
25,
27,
33,
37,
39,
41,
49,
51,
53,
55,
57,
59,
61,
63,
69,
71,
77,
79,
81,
83,
85,
87,
89,
91,
93,
97,
13,
103,
105,
13,
109,
5,
7,
11,
15,
17,
21,
23,
25,
27,
33,
37,
39,
41,
49,
51,
53,
55,
69,
71,
81,
83,
85,
87,
89,
91,
93,
97,
103,
105,
13,
109,
5,
7,
11,
15,
17,
21,
23,
25,
27,
29,
33,
37,
39,
41,
49,
51,
53,
55,
57,
59,
61,
63,
65,
67,
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93,
95,
97,
13,
103,
105,
13,
109,
5,
7,
11,
15,
17,
21,
23,
25,
27,
29,
33,
37,
39,
41,
49,
51,
53,
55,
65,
67,
69,
71,
81,
83,
85,
87,
89,
91,
93,
95,
97,
103,
105,
13,
109,
5,
7,
11,
15,
17,
21,
23,
25,
27,
31,
33,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
57,
59,
61,
63,
69,
71,
77,
79,
81,
83,
85,
87,
89,
91,
93,
97,
99,
103,
105,
13,
109,
113,
115,
117,
5,
7,
11,
15,
17,
21,
23,
25,
27,
33,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
69,
71,
81,
83,
85,
87,
89,
91,
93,
97,
99,
103,
105,
13,
109,
117,
115,
113,
5,
7,
11,
15,
17,
21,
23,
25,
27,
29,
31,
33,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
57,
59,
61,
63,
65,
67,
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93,
95,
97,
99,
103,
105,
13,
109,
113,
115,
117,
119,
5,
7,
11,
15,
17,
21,
23,
25,
27,
29,
33,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
65,
67,
69,
71,
81,
83,
85,
87,
89,
91,
93,
95,
97,
99,
103,
105,
13,
109,
117,
115,
113,
119,
33,
37,
39,
61,
81,
85,
83,
87,
61,
81,
85,
83,
87,
37,
55,
51,
61,
85,
85,
93,
103,
105,
13,
109,
33,
37,
39,
61,
81,
85,
83,
87,
61,
81,
85,
83,
87,
37,
55,
51,
61,
85,
85,
93,
103,
105,
13,
109,
33,
37,
39,
61,
81,
85,
83,
87,
93,
103,
105,
13,
109,
33,
37,
39,
61,
81,
85,
83,
87,
93,
103,
105,
13,
109,
23,
13,
103,
105,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
39,
93,
13,
39,
93,
13,
13
]
}
|
static inline void FUNC_0(rgb24to15)(const uint8_t *src, uint8_t *dst, long src_size)
{
const uint8_t *VAR_0 = src;
const uint8_t *VAR_1;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
VAR_1 = VAR_0 + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm __volatile(
"movq %0, %%mm7\n\t"
"movq %1, %%mm6\n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = VAR_1 - 11;
while(VAR_0 < mm_end)
{
__asm __volatile(
PREFETCH" 32%1\n\t"
"movd %1, %%mm0\n\t"
"movd 3%1, %%mm3\n\t"
"punpckldq 6%1, %%mm0\n\t"
"punpckldq 9%1, %%mm3\n\t"
"movq %%mm0, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm3, %%mm4\n\t"
"movq %%mm3, %%mm5\n\t"
"psrlq $3, %%mm0\n\t"
"psrlq $3, %%mm3\n\t"
"pand %2, %%mm0\n\t"
"pand %2, %%mm3\n\t"
"psrlq $6, %%mm1\n\t"
"psrlq $6, %%mm4\n\t"
"pand %%mm6, %%mm1\n\t"
"pand %%mm6, %%mm4\n\t"
"psrlq $9, %%mm2\n\t"
"psrlq $9, %%mm5\n\t"
"pand %%mm7, %%mm2\n\t"
"pand %%mm7, %%mm5\n\t"
"por %%mm1, %%mm0\n\t"
"por %%mm4, %%mm3\n\t"
"por %%mm2, %%mm0\n\t"
"por %%mm5, %%mm3\n\t"
"psllq $16, %%mm3\n\t"
"por %%mm3, %%mm0\n\t"
MOVNTQ" %%mm0, %0\n\t"
:"=m"(*d):"m"(*VAR_0),"m"(blue_15mask):"memory");
d += 4;
VAR_0 += 12;
}
__asm __volatile(SFENCE:::"memory");
__asm __volatile(EMMS:::"memory");
#endif
while(VAR_0 < VAR_1)
{
const int VAR_2= *VAR_0++;
const int VAR_3= *VAR_0++;
const int VAR_4= *VAR_0++;
*d++ = (VAR_2>>3) | ((VAR_3&0xF8)<<2) | ((VAR_4&0xF8)<<7);
}
}
|
[
"static inline void FUNC_0(rgb24to15)(const uint8_t *src, uint8_t *dst, long src_size)\n{",
"const uint8_t *VAR_0 = src;",
"const uint8_t *VAR_1;",
"#ifdef HAVE_MMX\nconst uint8_t *mm_end;",
"#endif\nuint16_t *d = (uint16_t *)dst;",
"VAR_1 = VAR_0 + src_size;",
"#ifdef HAVE_MMX\n__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*src):\"memory\");",
"__asm __volatile(\n\"movq\t%0, %%mm7\\n\\t\"\n\"movq\t%1, %%mm6\\n\\t\"\n::\"m\"(red_15mask),\"m\"(green_15mask));",
"mm_end = VAR_1 - 11;",
"while(VAR_0 < mm_end)\n{",
"__asm __volatile(\nPREFETCH\" 32%1\\n\\t\"\n\"movd\t%1, %%mm0\\n\\t\"\n\"movd\t3%1, %%mm3\\n\\t\"\n\"punpckldq 6%1, %%mm0\\n\\t\"\n\"punpckldq 9%1, %%mm3\\n\\t\"\n\"movq\t%%mm0, %%mm1\\n\\t\"\n\"movq\t%%mm0, %%mm2\\n\\t\"\n\"movq\t%%mm3, %%mm4\\n\\t\"\n\"movq\t%%mm3, %%mm5\\n\\t\"\n\"psrlq\t$3, %%mm0\\n\\t\"\n\"psrlq\t$3, %%mm3\\n\\t\"\n\"pand\t%2, %%mm0\\n\\t\"\n\"pand\t%2, %%mm3\\n\\t\"\n\"psrlq\t$6, %%mm1\\n\\t\"\n\"psrlq\t$6, %%mm4\\n\\t\"\n\"pand\t%%mm6, %%mm1\\n\\t\"\n\"pand\t%%mm6, %%mm4\\n\\t\"\n\"psrlq\t$9, %%mm2\\n\\t\"\n\"psrlq\t$9, %%mm5\\n\\t\"\n\"pand\t%%mm7, %%mm2\\n\\t\"\n\"pand\t%%mm7, %%mm5\\n\\t\"\n\"por\t%%mm1, %%mm0\\n\\t\"\n\"por\t%%mm4, %%mm3\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"por\t%%mm5, %%mm3\\n\\t\"\n\"psllq\t$16, %%mm3\\n\\t\"\n\"por\t%%mm3, %%mm0\\n\\t\"\nMOVNTQ\"\t%%mm0, %0\\n\\t\"\n:\"=m\"(*d):\"m\"(*VAR_0),\"m\"(blue_15mask):\"memory\");",
"d += 4;",
"VAR_0 += 12;",
"}",
"__asm __volatile(SFENCE:::\"memory\");",
"__asm __volatile(EMMS:::\"memory\");",
"#endif\nwhile(VAR_0 < VAR_1)\n{",
"const int VAR_2= *VAR_0++;",
"const int VAR_3= *VAR_0++;",
"const int VAR_4= *VAR_0++;",
"*d++ = (VAR_2>>3) | ((VAR_3&0xF8)<<2) | ((VAR_4&0xF8)<<7);",
"}",
"}"
] |
[
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9,
11
],
[
13,
15
],
[
17
],
[
19,
21
],
[
23,
25,
27,
29
],
[
31
],
[
33,
35
],
[
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
57,
59,
61,
63,
65,
67,
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93,
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107,
109,
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
]
] |
6,984 |
void *HELPER(lookup_tb_ptr)(CPUArchState *env)
{
CPUState *cpu = ENV_GET_CPU(env);
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags, hash;
cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
hash = tb_jmp_cache_hash_func(pc);
tb = atomic_rcu_read(&cpu->tb_jmp_cache[hash]);
if (unlikely(!(tb
&& tb->pc == pc
&& tb->cs_base == cs_base
&& tb->flags == flags
&& tb->trace_vcpu_dstate == *cpu->trace_dstate))) {
tb = tb_htable_lookup(cpu, pc, cs_base, flags);
if (!tb) {
return tcg_ctx.code_gen_epilogue;
}
atomic_set(&cpu->tb_jmp_cache[hash], tb);
}
qemu_log_mask_and_addr(CPU_LOG_EXEC, pc,
"Chain %p [%d: " TARGET_FMT_lx "] %s\n",
tb->tc_ptr, cpu->cpu_index, pc,
lookup_symbol(pc));
return tb->tc_ptr;
}
| true |
qemu
|
f6bb84d53110398f4899c19dab4e0fe9908ec060
|
void *HELPER(lookup_tb_ptr)(CPUArchState *env)
{
CPUState *cpu = ENV_GET_CPU(env);
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags, hash;
cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
hash = tb_jmp_cache_hash_func(pc);
tb = atomic_rcu_read(&cpu->tb_jmp_cache[hash]);
if (unlikely(!(tb
&& tb->pc == pc
&& tb->cs_base == cs_base
&& tb->flags == flags
&& tb->trace_vcpu_dstate == *cpu->trace_dstate))) {
tb = tb_htable_lookup(cpu, pc, cs_base, flags);
if (!tb) {
return tcg_ctx.code_gen_epilogue;
}
atomic_set(&cpu->tb_jmp_cache[hash], tb);
}
qemu_log_mask_and_addr(CPU_LOG_EXEC, pc,
"Chain %p [%d: " TARGET_FMT_lx "] %s\n",
tb->tc_ptr, cpu->cpu_index, pc,
lookup_symbol(pc));
return tb->tc_ptr;
}
|
{
"code": [
" cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);",
" tb = tb_htable_lookup(cpu, pc, cs_base, flags);",
" if (!tb) {",
" uint32_t flags, hash;",
" cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);",
" hash = tb_jmp_cache_hash_func(pc);",
" tb = atomic_rcu_read(&cpu->tb_jmp_cache[hash]);",
" if (unlikely(!(tb",
" && tb->pc == pc",
" && tb->cs_base == cs_base",
" && tb->flags == flags",
" && tb->trace_vcpu_dstate == *cpu->trace_dstate))) {",
" tb = tb_htable_lookup(cpu, pc, cs_base, flags);",
" if (!tb) {",
" return tcg_ctx.code_gen_epilogue;",
" atomic_set(&cpu->tb_jmp_cache[hash], tb);"
],
"line_no": [
15,
33,
35,
11,
15,
17,
19,
23,
25,
27,
29,
31,
33,
35,
37,
41
]
}
|
void *FUNC_0(lookup_tb_ptr)(CPUArchState *env)
{
CPUState *cpu = ENV_GET_CPU(env);
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags, hash;
cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
hash = tb_jmp_cache_hash_func(pc);
tb = atomic_rcu_read(&cpu->tb_jmp_cache[hash]);
if (unlikely(!(tb
&& tb->pc == pc
&& tb->cs_base == cs_base
&& tb->flags == flags
&& tb->trace_vcpu_dstate == *cpu->trace_dstate))) {
tb = tb_htable_lookup(cpu, pc, cs_base, flags);
if (!tb) {
return tcg_ctx.code_gen_epilogue;
}
atomic_set(&cpu->tb_jmp_cache[hash], tb);
}
qemu_log_mask_and_addr(CPU_LOG_EXEC, pc,
"Chain %p [%d: " TARGET_FMT_lx "] %s\n",
tb->tc_ptr, cpu->cpu_index, pc,
lookup_symbol(pc));
return tb->tc_ptr;
}
|
[
"void *FUNC_0(lookup_tb_ptr)(CPUArchState *env)\n{",
"CPUState *cpu = ENV_GET_CPU(env);",
"TranslationBlock *tb;",
"target_ulong cs_base, pc;",
"uint32_t flags, hash;",
"cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);",
"hash = tb_jmp_cache_hash_func(pc);",
"tb = atomic_rcu_read(&cpu->tb_jmp_cache[hash]);",
"if (unlikely(!(tb\n&& tb->pc == pc\n&& tb->cs_base == cs_base\n&& tb->flags == flags\n&& tb->trace_vcpu_dstate == *cpu->trace_dstate))) {",
"tb = tb_htable_lookup(cpu, pc, cs_base, flags);",
"if (!tb) {",
"return tcg_ctx.code_gen_epilogue;",
"}",
"atomic_set(&cpu->tb_jmp_cache[hash], tb);",
"}",
"qemu_log_mask_and_addr(CPU_LOG_EXEC, pc,\n\"Chain %p [%d: \" TARGET_FMT_lx \"] %s\\n\",\ntb->tc_ptr, cpu->cpu_index, pc,\nlookup_symbol(pc));",
"return tb->tc_ptr;",
"}"
] |
[
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
23,
25,
27,
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47,
49,
51,
53
],
[
55
],
[
57
]
] |
6,985 |
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
{
ff_draw_horiz_band(s->avctx, &s->current_picture.f,
&s->last_picture.f, y, h, s->picture_structure,
s->first_field, s->low_delay);
}
| true |
FFmpeg
|
f6774f905fb3cfdc319523ac640be30b14c1bc55
|
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
{
ff_draw_horiz_band(s->avctx, &s->current_picture.f,
&s->last_picture.f, y, h, s->picture_structure,
s->first_field, s->low_delay);
}
|
{
"code": [
" ff_draw_horiz_band(s->avctx, &s->current_picture.f,",
" &s->last_picture.f, y, h, s->picture_structure,"
],
"line_no": [
5,
7
]
}
|
void FUNC_0(MpegEncContext *VAR_0, int VAR_1, int VAR_2)
{
ff_draw_horiz_band(VAR_0->avctx, &VAR_0->current_picture.f,
&VAR_0->last_picture.f, VAR_1, VAR_2, VAR_0->picture_structure,
VAR_0->first_field, VAR_0->low_delay);
}
|
[
"void FUNC_0(MpegEncContext *VAR_0, int VAR_1, int VAR_2)\n{",
"ff_draw_horiz_band(VAR_0->avctx, &VAR_0->current_picture.f,\n&VAR_0->last_picture.f, VAR_1, VAR_2, VAR_0->picture_structure,\nVAR_0->first_field, VAR_0->low_delay);",
"}"
] |
[
0,
1,
0
] |
[
[
1,
3
],
[
5,
7,
9
],
[
11
]
] |
6,986 |
int load_image_targphys(const char *filename,
target_phys_addr_t addr, int max_sz)
{
int size;
size = get_image_size(filename);
if (size > 0)
rom_add_file_fixed(filename, addr, -1);
return size;
}
| true |
qemu
|
17df768c1e4580f03301d18ea938d3557d441911
|
int load_image_targphys(const char *filename,
target_phys_addr_t addr, int max_sz)
{
int size;
size = get_image_size(filename);
if (size > 0)
rom_add_file_fixed(filename, addr, -1);
return size;
}
|
{
"code": [
" if (size > 0)"
],
"line_no": [
13
]
}
|
int FUNC_0(const char *VAR_0,
target_phys_addr_t VAR_1, int VAR_2)
{
int VAR_3;
VAR_3 = get_image_size(VAR_0);
if (VAR_3 > 0)
rom_add_file_fixed(VAR_0, VAR_1, -1);
return VAR_3;
}
|
[
"int FUNC_0(const char *VAR_0,\ntarget_phys_addr_t VAR_1, int VAR_2)\n{",
"int VAR_3;",
"VAR_3 = get_image_size(VAR_0);",
"if (VAR_3 > 0)\nrom_add_file_fixed(VAR_0, VAR_1, -1);",
"return VAR_3;",
"}"
] |
[
0,
0,
0,
1,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
11
],
[
13,
15
],
[
17
],
[
19
]
] |
6,987 |
static void ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
{
CCID_Header *ccid_header;
if (p->iov.size + s->bulk_out_pos > BULK_OUT_DATA_SIZE) {
goto err;
}
usb_packet_copy(p, s->bulk_out_data + s->bulk_out_pos, p->iov.size);
s->bulk_out_pos += p->iov.size;
if (s->bulk_out_pos < 10) {
DPRINTF(s, 1, "%s: header incomplete\n", __func__);
goto err;
}
ccid_header = (CCID_Header *)s->bulk_out_data;
if (p->iov.size == CCID_MAX_PACKET_SIZE) {
DPRINTF(s, D_VERBOSE,
"usb-ccid: bulk_in: expecting more packets (%zd/%d)\n",
p->iov.size, ccid_header->dwLength);
return;
}
DPRINTF(s, D_MORE_INFO, "%s %x %s\n", __func__,
ccid_header->bMessageType,
ccid_message_type_to_str(ccid_header->bMessageType));
switch (ccid_header->bMessageType) {
case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
ccid_write_slot_status(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
DPRINTF(s, 1, "%s: PowerOn: %d\n", __func__,
((CCID_IccPowerOn *)(ccid_header))->bPowerSelect);
s->powered = true;
if (!ccid_card_inserted(s)) {
ccid_report_error_failed(s, ERROR_ICC_MUTE);
}
/* atr is written regardless of error. */
ccid_write_data_block_atr(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
ccid_reset_error_status(s);
s->powered = false;
ccid_write_slot_status(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
ccid_on_apdu_from_guest(s, (CCID_XferBlock *)s->bulk_out_data);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
ccid_reset_error_status(s);
ccid_set_parameters(s, ccid_header);
ccid_write_parameters(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
ccid_reset_error_status(s);
ccid_reset_parameters(s);
ccid_write_parameters(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
ccid_reset_error_status(s);
ccid_write_parameters(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical:
ccid_report_error_failed(s, 0);
ccid_write_slot_status(s, ccid_header);
break;
default:
DPRINTF(s, 1,
"handle_data: ERROR: unhandled message type %Xh\n",
ccid_header->bMessageType);
/*
* The caller is expecting the device to respond, tell it we
* don't support the operation.
*/
ccid_report_error_failed(s, ERROR_CMD_NOT_SUPPORTED);
ccid_write_slot_status(s, ccid_header);
break;
}
s->bulk_out_pos = 0;
return;
err:
p->status = USB_RET_STALL;
s->bulk_out_pos = 0;
return;
}
| true |
qemu
|
31fb4444a485a348f8e2699d7c3dd15e1819ad2c
|
static void ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
{
CCID_Header *ccid_header;
if (p->iov.size + s->bulk_out_pos > BULK_OUT_DATA_SIZE) {
goto err;
}
usb_packet_copy(p, s->bulk_out_data + s->bulk_out_pos, p->iov.size);
s->bulk_out_pos += p->iov.size;
if (s->bulk_out_pos < 10) {
DPRINTF(s, 1, "%s: header incomplete\n", __func__);
goto err;
}
ccid_header = (CCID_Header *)s->bulk_out_data;
if (p->iov.size == CCID_MAX_PACKET_SIZE) {
DPRINTF(s, D_VERBOSE,
"usb-ccid: bulk_in: expecting more packets (%zd/%d)\n",
p->iov.size, ccid_header->dwLength);
return;
}
DPRINTF(s, D_MORE_INFO, "%s %x %s\n", __func__,
ccid_header->bMessageType,
ccid_message_type_to_str(ccid_header->bMessageType));
switch (ccid_header->bMessageType) {
case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
ccid_write_slot_status(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
DPRINTF(s, 1, "%s: PowerOn: %d\n", __func__,
((CCID_IccPowerOn *)(ccid_header))->bPowerSelect);
s->powered = true;
if (!ccid_card_inserted(s)) {
ccid_report_error_failed(s, ERROR_ICC_MUTE);
}
ccid_write_data_block_atr(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
ccid_reset_error_status(s);
s->powered = false;
ccid_write_slot_status(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
ccid_on_apdu_from_guest(s, (CCID_XferBlock *)s->bulk_out_data);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
ccid_reset_error_status(s);
ccid_set_parameters(s, ccid_header);
ccid_write_parameters(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
ccid_reset_error_status(s);
ccid_reset_parameters(s);
ccid_write_parameters(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
ccid_reset_error_status(s);
ccid_write_parameters(s, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical:
ccid_report_error_failed(s, 0);
ccid_write_slot_status(s, ccid_header);
break;
default:
DPRINTF(s, 1,
"handle_data: ERROR: unhandled message type %Xh\n",
ccid_header->bMessageType);
ccid_report_error_failed(s, ERROR_CMD_NOT_SUPPORTED);
ccid_write_slot_status(s, ccid_header);
break;
}
s->bulk_out_pos = 0;
return;
err:
p->status = USB_RET_STALL;
s->bulk_out_pos = 0;
return;
}
|
{
"code": [
" if (p->iov.size == CCID_MAX_PACKET_SIZE) {",
" \"usb-ccid: bulk_in: expecting more packets (%zd/%d)\\n\",",
" p->iov.size, ccid_header->dwLength);"
],
"line_no": [
31,
35,
37
]
}
|
static void FUNC_0(USBCCIDState *VAR_0, USBPacket *VAR_1)
{
CCID_Header *ccid_header;
if (VAR_1->iov.size + VAR_0->bulk_out_pos > BULK_OUT_DATA_SIZE) {
goto err;
}
usb_packet_copy(VAR_1, VAR_0->bulk_out_data + VAR_0->bulk_out_pos, VAR_1->iov.size);
VAR_0->bulk_out_pos += VAR_1->iov.size;
if (VAR_0->bulk_out_pos < 10) {
DPRINTF(VAR_0, 1, "%VAR_0: header incomplete\n", __func__);
goto err;
}
ccid_header = (CCID_Header *)VAR_0->bulk_out_data;
if (VAR_1->iov.size == CCID_MAX_PACKET_SIZE) {
DPRINTF(VAR_0, D_VERBOSE,
"usb-ccid: bulk_in: expecting more packets (%zd/%d)\n",
VAR_1->iov.size, ccid_header->dwLength);
return;
}
DPRINTF(VAR_0, D_MORE_INFO, "%VAR_0 %x %VAR_0\n", __func__,
ccid_header->bMessageType,
ccid_message_type_to_str(ccid_header->bMessageType));
switch (ccid_header->bMessageType) {
case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
ccid_write_slot_status(VAR_0, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
DPRINTF(VAR_0, 1, "%VAR_0: PowerOn: %d\n", __func__,
((CCID_IccPowerOn *)(ccid_header))->bPowerSelect);
VAR_0->powered = true;
if (!ccid_card_inserted(VAR_0)) {
ccid_report_error_failed(VAR_0, ERROR_ICC_MUTE);
}
ccid_write_data_block_atr(VAR_0, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
ccid_reset_error_status(VAR_0);
VAR_0->powered = false;
ccid_write_slot_status(VAR_0, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
ccid_on_apdu_from_guest(VAR_0, (CCID_XferBlock *)VAR_0->bulk_out_data);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
ccid_reset_error_status(VAR_0);
ccid_set_parameters(VAR_0, ccid_header);
ccid_write_parameters(VAR_0, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
ccid_reset_error_status(VAR_0);
ccid_reset_parameters(VAR_0);
ccid_write_parameters(VAR_0, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
ccid_reset_error_status(VAR_0);
ccid_write_parameters(VAR_0, ccid_header);
break;
case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical:
ccid_report_error_failed(VAR_0, 0);
ccid_write_slot_status(VAR_0, ccid_header);
break;
default:
DPRINTF(VAR_0, 1,
"handle_data: ERROR: unhandled message type %Xh\n",
ccid_header->bMessageType);
ccid_report_error_failed(VAR_0, ERROR_CMD_NOT_SUPPORTED);
ccid_write_slot_status(VAR_0, ccid_header);
break;
}
VAR_0->bulk_out_pos = 0;
return;
err:
VAR_1->status = USB_RET_STALL;
VAR_0->bulk_out_pos = 0;
return;
}
|
[
"static void FUNC_0(USBCCIDState *VAR_0, USBPacket *VAR_1)\n{",
"CCID_Header *ccid_header;",
"if (VAR_1->iov.size + VAR_0->bulk_out_pos > BULK_OUT_DATA_SIZE) {",
"goto err;",
"}",
"usb_packet_copy(VAR_1, VAR_0->bulk_out_data + VAR_0->bulk_out_pos, VAR_1->iov.size);",
"VAR_0->bulk_out_pos += VAR_1->iov.size;",
"if (VAR_0->bulk_out_pos < 10) {",
"DPRINTF(VAR_0, 1, \"%VAR_0: header incomplete\\n\", __func__);",
"goto err;",
"}",
"ccid_header = (CCID_Header *)VAR_0->bulk_out_data;",
"if (VAR_1->iov.size == CCID_MAX_PACKET_SIZE) {",
"DPRINTF(VAR_0, D_VERBOSE,\n\"usb-ccid: bulk_in: expecting more packets (%zd/%d)\\n\",\nVAR_1->iov.size, ccid_header->dwLength);",
"return;",
"}",
"DPRINTF(VAR_0, D_MORE_INFO, \"%VAR_0 %x %VAR_0\\n\", __func__,\nccid_header->bMessageType,\nccid_message_type_to_str(ccid_header->bMessageType));",
"switch (ccid_header->bMessageType) {",
"case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:\nccid_write_slot_status(VAR_0, ccid_header);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:\nDPRINTF(VAR_0, 1, \"%VAR_0: PowerOn: %d\\n\", __func__,\n((CCID_IccPowerOn *)(ccid_header))->bPowerSelect);",
"VAR_0->powered = true;",
"if (!ccid_card_inserted(VAR_0)) {",
"ccid_report_error_failed(VAR_0, ERROR_ICC_MUTE);",
"}",
"ccid_write_data_block_atr(VAR_0, ccid_header);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:\nccid_reset_error_status(VAR_0);",
"VAR_0->powered = false;",
"ccid_write_slot_status(VAR_0, ccid_header);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:\nccid_on_apdu_from_guest(VAR_0, (CCID_XferBlock *)VAR_0->bulk_out_data);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:\nccid_reset_error_status(VAR_0);",
"ccid_set_parameters(VAR_0, ccid_header);",
"ccid_write_parameters(VAR_0, ccid_header);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:\nccid_reset_error_status(VAR_0);",
"ccid_reset_parameters(VAR_0);",
"ccid_write_parameters(VAR_0, ccid_header);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:\nccid_reset_error_status(VAR_0);",
"ccid_write_parameters(VAR_0, ccid_header);",
"break;",
"case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical:\nccid_report_error_failed(VAR_0, 0);",
"ccid_write_slot_status(VAR_0, ccid_header);",
"break;",
"default:\nDPRINTF(VAR_0, 1,\n\"handle_data: ERROR: unhandled message type %Xh\\n\",\nccid_header->bMessageType);",
"ccid_report_error_failed(VAR_0, ERROR_CMD_NOT_SUPPORTED);",
"ccid_write_slot_status(VAR_0, ccid_header);",
"break;",
"}",
"VAR_0->bulk_out_pos = 0;",
"return;",
"err:\nVAR_1->status = USB_RET_STALL;",
"VAR_0->bulk_out_pos = 0;",
"return;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33,
35,
37
],
[
39
],
[
41
],
[
45,
47,
49
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
87
],
[
89,
91
],
[
93
],
[
95,
97
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
113
],
[
115,
117
],
[
119
],
[
121
],
[
123,
125
],
[
127
],
[
129
],
[
131,
133,
135,
137
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161,
163
],
[
165
],
[
167
],
[
169
]
] |
6,988 |
static av_cold int vcr1_decode_init(AVCodecContext *avctx)
{
avctx->pix_fmt = AV_PIX_FMT_YUV410P;
return 0;
| true |
FFmpeg
|
8aba7968dd604aae91ee42cbce0be3dad7dceb30
|
static av_cold int vcr1_decode_init(AVCodecContext *avctx)
{
avctx->pix_fmt = AV_PIX_FMT_YUV410P;
return 0;
|
{
"code": [],
"line_no": []
}
|
static av_cold int FUNC_0(AVCodecContext *avctx)
{
avctx->pix_fmt = AV_PIX_FMT_YUV410P;
return 0;
|
[
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"avctx->pix_fmt = AV_PIX_FMT_YUV410P;",
"return 0;"
] |
[
0,
0,
0
] |
[
[
1,
2
],
[
3
],
[
4
]
] |
6,989 |
static void *sparc32_dma_init(target_phys_addr_t daddr, qemu_irq parent_irq,
void *iommu, qemu_irq *dev_irq)
{
DeviceState *dev;
SysBusDevice *s;
dev = qdev_create(NULL, "sparc32_dma");
qdev_prop_set_ptr(dev, "iommu_opaque", iommu);
qdev_init(dev);
s = sysbus_from_qdev(dev);
sysbus_connect_irq(s, 0, parent_irq);
*dev_irq = qdev_get_gpio_in(dev, 0);
sysbus_mmio_map(s, 0, daddr);
return s;
}
| true |
qemu
|
e23a1b33b53d25510320b26d9f154e19c6c99725
|
static void *sparc32_dma_init(target_phys_addr_t daddr, qemu_irq parent_irq,
void *iommu, qemu_irq *dev_irq)
{
DeviceState *dev;
SysBusDevice *s;
dev = qdev_create(NULL, "sparc32_dma");
qdev_prop_set_ptr(dev, "iommu_opaque", iommu);
qdev_init(dev);
s = sysbus_from_qdev(dev);
sysbus_connect_irq(s, 0, parent_irq);
*dev_irq = qdev_get_gpio_in(dev, 0);
sysbus_mmio_map(s, 0, daddr);
return s;
}
|
{
"code": [
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);",
" qdev_init(dev);"
],
"line_no": [
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17,
17
]
}
|
static void *FUNC_0(target_phys_addr_t VAR_0, qemu_irq VAR_1,
void *VAR_2, qemu_irq *VAR_3)
{
DeviceState *dev;
SysBusDevice *s;
dev = qdev_create(NULL, "sparc32_dma");
qdev_prop_set_ptr(dev, "iommu_opaque", VAR_2);
qdev_init(dev);
s = sysbus_from_qdev(dev);
sysbus_connect_irq(s, 0, VAR_1);
*VAR_3 = qdev_get_gpio_in(dev, 0);
sysbus_mmio_map(s, 0, VAR_0);
return s;
}
|
[
"static void *FUNC_0(target_phys_addr_t VAR_0, qemu_irq VAR_1,\nvoid *VAR_2, qemu_irq *VAR_3)\n{",
"DeviceState *dev;",
"SysBusDevice *s;",
"dev = qdev_create(NULL, \"sparc32_dma\");",
"qdev_prop_set_ptr(dev, \"iommu_opaque\", VAR_2);",
"qdev_init(dev);",
"s = sysbus_from_qdev(dev);",
"sysbus_connect_irq(s, 0, VAR_1);",
"*VAR_3 = qdev_get_gpio_in(dev, 0);",
"sysbus_mmio_map(s, 0, VAR_0);",
"return s;",
"}"
] |
[
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
]
] |
6,990 |
int monitor_read_block_device_key(Monitor *mon, const char *device,
BlockCompletionFunc *completion_cb,
void *opaque)
{
Error *err = NULL;
BlockBackend *blk;
blk = blk_by_name(device);
if (!blk) {
monitor_printf(mon, "Device not found %s\n", device);
return -1;
}
if (!blk_bs(blk)) {
monitor_printf(mon, "Device '%s' has no medium\n", device);
return -1;
}
bdrv_add_key(blk_bs(blk), NULL, &err);
if (err) {
error_free(err);
return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
}
if (completion_cb) {
completion_cb(opaque, 0);
}
return 0;
}
| true |
qemu
|
788cf9f8c8cbda53843e060540f3e91a060eb744
|
int monitor_read_block_device_key(Monitor *mon, const char *device,
BlockCompletionFunc *completion_cb,
void *opaque)
{
Error *err = NULL;
BlockBackend *blk;
blk = blk_by_name(device);
if (!blk) {
monitor_printf(mon, "Device not found %s\n", device);
return -1;
}
if (!blk_bs(blk)) {
monitor_printf(mon, "Device '%s' has no medium\n", device);
return -1;
}
bdrv_add_key(blk_bs(blk), NULL, &err);
if (err) {
error_free(err);
return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
}
if (completion_cb) {
completion_cb(opaque, 0);
}
return 0;
}
|
{
"code": [
"int monitor_read_block_device_key(Monitor *mon, const char *device,",
" BlockCompletionFunc *completion_cb,",
"int monitor_read_block_device_key(Monitor *mon, const char *device,",
" BlockCompletionFunc *completion_cb,",
" void *opaque)",
" Error *err = NULL;",
" BlockBackend *blk;",
" blk = blk_by_name(device);",
" if (!blk) {",
" monitor_printf(mon, \"Device not found %s\\n\", device);",
" return -1;",
" if (!blk_bs(blk)) {",
" monitor_printf(mon, \"Device '%s' has no medium\\n\", device);",
" return -1;",
" bdrv_add_key(blk_bs(blk), NULL, &err);",
" if (err) {",
" error_free(err);",
" return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);",
" if (completion_cb) {",
" completion_cb(opaque, 0);",
" return 0;",
" return 0;",
" return 0;"
],
"line_no": [
1,
3,
1,
3,
5,
9,
11,
15,
17,
19,
21,
25,
27,
21,
35,
37,
39,
41,
47,
49,
53,
53,
53
]
}
|
int FUNC_0(Monitor *VAR_0, const char *VAR_1,
BlockCompletionFunc *VAR_2,
void *VAR_3)
{
Error *err = NULL;
BlockBackend *blk;
blk = blk_by_name(VAR_1);
if (!blk) {
monitor_printf(VAR_0, "Device not found %s\n", VAR_1);
return -1;
}
if (!blk_bs(blk)) {
monitor_printf(VAR_0, "Device '%s' has no medium\n", VAR_1);
return -1;
}
bdrv_add_key(blk_bs(blk), NULL, &err);
if (err) {
error_free(err);
return monitor_read_bdrv_key_start(VAR_0, blk_bs(blk), VAR_2, VAR_3);
}
if (VAR_2) {
VAR_2(VAR_3, 0);
}
return 0;
}
|
[
"int FUNC_0(Monitor *VAR_0, const char *VAR_1,\nBlockCompletionFunc *VAR_2,\nvoid *VAR_3)\n{",
"Error *err = NULL;",
"BlockBackend *blk;",
"blk = blk_by_name(VAR_1);",
"if (!blk) {",
"monitor_printf(VAR_0, \"Device not found %s\\n\", VAR_1);",
"return -1;",
"}",
"if (!blk_bs(blk)) {",
"monitor_printf(VAR_0, \"Device '%s' has no medium\\n\", VAR_1);",
"return -1;",
"}",
"bdrv_add_key(blk_bs(blk), NULL, &err);",
"if (err) {",
"error_free(err);",
"return monitor_read_bdrv_key_start(VAR_0, blk_bs(blk), VAR_2, VAR_3);",
"}",
"if (VAR_2) {",
"VAR_2(VAR_3, 0);",
"}",
"return 0;",
"}"
] |
[
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
0,
0,
1,
1,
1,
1,
0,
1,
1,
0,
1,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
]
] |
6,991 |
static void migrate_set_state(MigrationState *s, int old_state, int new_state)
{
if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) {
trace_migrate_set_state(new_state);
}
}
| true |
qemu
|
60fe637bf0e4d7989e21e50f52526444765c63b4
|
static void migrate_set_state(MigrationState *s, int old_state, int new_state)
{
if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) {
trace_migrate_set_state(new_state);
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(MigrationState *VAR_0, int VAR_1, int VAR_2)
{
if (atomic_cmpxchg(&VAR_0->state, VAR_1, VAR_2) == VAR_2) {
trace_migrate_set_state(VAR_2);
}
}
|
[
"static void FUNC_0(MigrationState *VAR_0, int VAR_1, int VAR_2)\n{",
"if (atomic_cmpxchg(&VAR_0->state, VAR_1, VAR_2) == VAR_2) {",
"trace_migrate_set_state(VAR_2);",
"}",
"}"
] |
[
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
] |
6,992 |
static void disas_arm_insn(CPUState * env, DisasContext *s)
{
unsigned int cond, insn, val, op1, i, shift, rm, rs, rn, rd, sh;
insn = ldl_code(s->pc);
s->pc += 4;
cond = insn >> 28;
if (cond == 0xf){
/* Unconditional instructions. */
if ((insn & 0x0d70f000) == 0x0550f000)
return; /* PLD */
else if ((insn & 0x0e000000) == 0x0a000000) {
/* branch link and change to thumb (blx <offset>) */
int32_t offset;
val = (uint32_t)s->pc;
gen_op_movl_T0_im(val);
gen_movl_reg_T0(s, 14);
/* Sign-extend the 24-bit offset */
offset = (((int32_t)insn) << 8) >> 8;
/* offset * 4 + bit24 * 2 + (thumb bit) */
val += (offset << 2) | ((insn >> 23) & 2) | 1;
/* pipeline offset */
val += 4;
gen_op_movl_T0_im(val);
gen_bx(s);
return;
} else if ((insn & 0x0fe00000) == 0x0c400000) {
/* Coprocessor double register transfer. */
} else if ((insn & 0x0f000010) == 0x0e000010) {
/* Additional coprocessor register transfer. */
} else if ((insn & 0x0ff10010) == 0x01000000) {
/* cps (privileged) */
} else if ((insn & 0x0ffffdff) == 0x01010000) {
/* setend */
if (insn & (1 << 9)) {
/* BE8 mode not implemented. */
goto illegal_op;
}
return;
}
goto illegal_op;
}
if (cond != 0xe) {
/* if not always execute, we generate a conditional jump to
next instruction */
s->condlabel = gen_new_label();
gen_test_cc[cond ^ 1](s->condlabel);
s->condjmp = 1;
//gen_test_cc[cond ^ 1]((long)s->tb, (long)s->pc);
//s->is_jmp = DISAS_JUMP_NEXT;
}
if ((insn & 0x0f900000) == 0x03000000) {
if ((insn & 0x0fb0f000) != 0x0320f000)
goto illegal_op;
/* CPSR = immediate */
val = insn & 0xff;
shift = ((insn >> 8) & 0xf) * 2;
if (shift)
val = (val >> shift) | (val << (32 - shift));
gen_op_movl_T0_im(val);
i = ((insn & (1 << 22)) != 0);
if (gen_set_psr_T0(s, msr_mask(s, (insn >> 16) & 0xf, i), i))
goto illegal_op;
} else if ((insn & 0x0f900000) == 0x01000000
&& (insn & 0x00000090) != 0x00000090) {
/* miscellaneous instructions */
op1 = (insn >> 21) & 3;
sh = (insn >> 4) & 0xf;
rm = insn & 0xf;
switch (sh) {
case 0x0: /* move program status register */
if (op1 & 1) {
/* PSR = reg */
gen_movl_T0_reg(s, rm);
i = ((op1 & 2) != 0);
if (gen_set_psr_T0(s, msr_mask(s, (insn >> 16) & 0xf, i), i))
goto illegal_op;
} else {
/* reg = PSR */
rd = (insn >> 12) & 0xf;
if (op1 & 2) {
if (IS_USER(s))
goto illegal_op;
gen_op_movl_T0_spsr();
} else {
gen_op_movl_T0_cpsr();
}
gen_movl_reg_T0(s, rd);
}
break;
case 0x1:
if (op1 == 1) {
/* branch/exchange thumb (bx). */
gen_movl_T0_reg(s, rm);
gen_bx(s);
} else if (op1 == 3) {
/* clz */
rd = (insn >> 12) & 0xf;
gen_movl_T0_reg(s, rm);
gen_op_clz_T0();
gen_movl_reg_T0(s, rd);
} else {
goto illegal_op;
}
break;
case 0x2:
if (op1 == 1) {
ARCH(5J); /* bxj */
/* Trivial implementation equivalent to bx. */
gen_movl_T0_reg(s, rm);
gen_bx(s);
} else {
goto illegal_op;
}
break;
case 0x3:
if (op1 != 1)
goto illegal_op;
/* branch link/exchange thumb (blx) */
val = (uint32_t)s->pc;
gen_op_movl_T0_im(val);
gen_movl_reg_T0(s, 14);
gen_movl_T0_reg(s, rm);
gen_bx(s);
break;
case 0x5: /* saturating add/subtract */
rd = (insn >> 12) & 0xf;
rn = (insn >> 16) & 0xf;
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rn);
if (op1 & 2)
gen_op_double_T1_saturate();
if (op1 & 1)
gen_op_subl_T0_T1_saturate();
else
gen_op_addl_T0_T1_saturate();
gen_movl_reg_T0(s, rd);
break;
case 7: /* bkpt */
gen_op_movl_T0_im((long)s->pc - 4);
gen_op_movl_reg_TN[0][15]();
gen_op_bkpt();
s->is_jmp = DISAS_JUMP;
break;
case 0x8: /* signed multiply */
case 0xa:
case 0xc:
case 0xe:
rs = (insn >> 8) & 0xf;
rn = (insn >> 12) & 0xf;
rd = (insn >> 16) & 0xf;
if (op1 == 1) {
/* (32 * 16) >> 16 */
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rs);
if (sh & 4)
gen_op_sarl_T1_im(16);
else
gen_op_sxth_T1();
gen_op_imulw_T0_T1();
if ((sh & 2) == 0) {
gen_movl_T1_reg(s, rn);
gen_op_addl_T0_T1_setq();
}
gen_movl_reg_T0(s, rd);
} else {
/* 16 * 16 */
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rs);
gen_mulxy(sh & 2, sh & 4);
if (op1 == 2) {
gen_op_signbit_T1_T0();
gen_op_addq_T0_T1(rn, rd);
gen_movl_reg_T0(s, rn);
gen_movl_reg_T1(s, rd);
} else {
if (op1 == 0) {
gen_movl_T1_reg(s, rn);
gen_op_addl_T0_T1_setq();
}
gen_movl_reg_T0(s, rd);
}
}
break;
default:
goto illegal_op;
}
} else if (((insn & 0x0e000000) == 0 &&
(insn & 0x00000090) != 0x90) ||
((insn & 0x0e000000) == (1 << 25))) {
int set_cc, logic_cc, shiftop;
op1 = (insn >> 21) & 0xf;
set_cc = (insn >> 20) & 1;
logic_cc = table_logic_cc[op1] & set_cc;
/* data processing instruction */
if (insn & (1 << 25)) {
/* immediate operand */
val = insn & 0xff;
shift = ((insn >> 8) & 0xf) * 2;
if (shift)
val = (val >> shift) | (val << (32 - shift));
gen_op_movl_T1_im(val);
if (logic_cc && shift)
gen_op_mov_CF_T1();
} else {
/* register */
rm = (insn) & 0xf;
gen_movl_T1_reg(s, rm);
shiftop = (insn >> 5) & 3;
if (!(insn & (1 << 4))) {
shift = (insn >> 7) & 0x1f;
if (shift != 0) {
if (logic_cc) {
gen_shift_T1_im_cc[shiftop](shift);
} else {
gen_shift_T1_im[shiftop](shift);
}
} else if (shiftop != 0) {
if (logic_cc) {
gen_shift_T1_0_cc[shiftop]();
} else {
gen_shift_T1_0[shiftop]();
}
}
} else {
rs = (insn >> 8) & 0xf;
gen_movl_T0_reg(s, rs);
if (logic_cc) {
gen_shift_T1_T0_cc[shiftop]();
} else {
gen_shift_T1_T0[shiftop]();
}
}
}
if (op1 != 0x0f && op1 != 0x0d) {
rn = (insn >> 16) & 0xf;
gen_movl_T0_reg(s, rn);
}
rd = (insn >> 12) & 0xf;
switch(op1) {
case 0x00:
gen_op_andl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
case 0x01:
gen_op_xorl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
case 0x02:
if (set_cc && rd == 15) {
/* SUBS r15, ... is used for exception return. */
if (IS_USER(s))
goto illegal_op;
gen_op_subl_T0_T1_cc();
gen_exception_return(s);
} else {
if (set_cc)
gen_op_subl_T0_T1_cc();
else
gen_op_subl_T0_T1();
gen_movl_reg_T0(s, rd);
}
break;
case 0x03:
if (set_cc)
gen_op_rsbl_T0_T1_cc();
else
gen_op_rsbl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x04:
if (set_cc)
gen_op_addl_T0_T1_cc();
else
gen_op_addl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x05:
if (set_cc)
gen_op_adcl_T0_T1_cc();
else
gen_op_adcl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x06:
if (set_cc)
gen_op_sbcl_T0_T1_cc();
else
gen_op_sbcl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x07:
if (set_cc)
gen_op_rscl_T0_T1_cc();
else
gen_op_rscl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x08:
if (set_cc) {
gen_op_andl_T0_T1();
gen_op_logic_T0_cc();
}
break;
case 0x09:
if (set_cc) {
gen_op_xorl_T0_T1();
gen_op_logic_T0_cc();
}
break;
case 0x0a:
if (set_cc) {
gen_op_subl_T0_T1_cc();
}
break;
case 0x0b:
if (set_cc) {
gen_op_addl_T0_T1_cc();
}
break;
case 0x0c:
gen_op_orl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
case 0x0d:
if (logic_cc && rd == 15) {
/* MOVS r15, ... is used for exception return. */
if (IS_USER(s))
goto illegal_op;
gen_op_movl_T0_T1();
gen_exception_return(s);
} else {
gen_movl_reg_T1(s, rd);
if (logic_cc)
gen_op_logic_T1_cc();
}
break;
case 0x0e:
gen_op_bicl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
default:
case 0x0f:
gen_op_notl_T1();
gen_movl_reg_T1(s, rd);
if (logic_cc)
gen_op_logic_T1_cc();
break;
}
} else {
/* other instructions */
op1 = (insn >> 24) & 0xf;
switch(op1) {
case 0x0:
case 0x1:
/* multiplies, extra load/stores */
sh = (insn >> 5) & 3;
if (sh == 0) {
if (op1 == 0x0) {
rd = (insn >> 16) & 0xf;
rn = (insn >> 12) & 0xf;
rs = (insn >> 8) & 0xf;
rm = (insn) & 0xf;
if (((insn >> 22) & 3) == 0) {
/* 32 bit mul */
gen_movl_T0_reg(s, rs);
gen_movl_T1_reg(s, rm);
gen_op_mul_T0_T1();
if (insn & (1 << 21)) {
gen_movl_T1_reg(s, rn);
gen_op_addl_T0_T1();
}
if (insn & (1 << 20))
gen_op_logic_T0_cc();
gen_movl_reg_T0(s, rd);
} else {
/* 64 bit mul */
gen_movl_T0_reg(s, rs);
gen_movl_T1_reg(s, rm);
if (insn & (1 << 22))
gen_op_imull_T0_T1();
else
gen_op_mull_T0_T1();
if (insn & (1 << 21)) /* mult accumulate */
gen_op_addq_T0_T1(rn, rd);
if (!(insn & (1 << 23))) { /* double accumulate */
ARCH(6);
gen_op_addq_lo_T0_T1(rn);
gen_op_addq_lo_T0_T1(rd);
}
if (insn & (1 << 20))
gen_op_logicq_cc();
gen_movl_reg_T0(s, rn);
gen_movl_reg_T1(s, rd);
}
} else {
rn = (insn >> 16) & 0xf;
rd = (insn >> 12) & 0xf;
if (insn & (1 << 23)) {
/* load/store exclusive */
goto illegal_op;
} else {
/* SWP instruction */
rm = (insn) & 0xf;
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rn);
if (insn & (1 << 22)) {
gen_ldst(swpb, s);
} else {
gen_ldst(swpl, s);
}
gen_movl_reg_T0(s, rd);
}
}
} else {
int address_offset;
/* Misc load/store */
rn = (insn >> 16) & 0xf;
rd = (insn >> 12) & 0xf;
gen_movl_T1_reg(s, rn);
if (insn & (1 << 24))
gen_add_datah_offset(s, insn, 0);
address_offset = 0;
if (insn & (1 << 20)) {
/* load */
switch(sh) {
case 1:
gen_ldst(lduw, s);
break;
case 2:
gen_ldst(ldsb, s);
break;
default:
case 3:
gen_ldst(ldsw, s);
break;
}
gen_movl_reg_T0(s, rd);
} else if (sh & 2) {
/* doubleword */
if (sh & 1) {
/* store */
gen_movl_T0_reg(s, rd);
gen_ldst(stl, s);
gen_op_addl_T1_im(4);
gen_movl_T0_reg(s, rd + 1);
gen_ldst(stl, s);
} else {
/* load */
gen_ldst(ldl, s);
gen_movl_reg_T0(s, rd);
gen_op_addl_T1_im(4);
gen_ldst(ldl, s);
gen_movl_reg_T0(s, rd + 1);
}
address_offset = -4;
} else {
/* store */
gen_movl_T0_reg(s, rd);
gen_ldst(stw, s);
}
if (!(insn & (1 << 24))) {
gen_add_datah_offset(s, insn, address_offset);
gen_movl_reg_T1(s, rn);
} else if (insn & (1 << 21)) {
if (address_offset)
gen_op_addl_T1_im(address_offset);
gen_movl_reg_T1(s, rn);
}
}
break;
case 0x4:
case 0x5:
case 0x6:
case 0x7:
/* Check for undefined extension instructions
* per the ARM Bible IE:
* xxxx 0111 1111 xxxx xxxx xxxx 1111 xxxx
*/
sh = (0xf << 20) | (0xf << 4);
if (op1 == 0x7 && ((insn & sh) == sh))
{
goto illegal_op;
}
/* load/store byte/word */
rn = (insn >> 16) & 0xf;
rd = (insn >> 12) & 0xf;
gen_movl_T1_reg(s, rn);
i = (IS_USER(s) || (insn & 0x01200000) == 0x00200000);
if (insn & (1 << 24))
gen_add_data_offset(s, insn);
if (insn & (1 << 20)) {
/* load */
#if defined(CONFIG_USER_ONLY)
if (insn & (1 << 22))
gen_op_ldub_raw();
else
gen_op_ldl_raw();
#else
if (insn & (1 << 22)) {
if (i)
gen_op_ldub_user();
else
gen_op_ldub_kernel();
} else {
if (i)
gen_op_ldl_user();
else
gen_op_ldl_kernel();
}
#endif
if (rd == 15)
gen_bx(s);
else
gen_movl_reg_T0(s, rd);
} else {
/* store */
gen_movl_T0_reg(s, rd);
#if defined(CONFIG_USER_ONLY)
if (insn & (1 << 22))
gen_op_stb_raw();
else
gen_op_stl_raw();
#else
if (insn & (1 << 22)) {
if (i)
gen_op_stb_user();
else
gen_op_stb_kernel();
} else {
if (i)
gen_op_stl_user();
else
gen_op_stl_kernel();
}
#endif
}
if (!(insn & (1 << 24))) {
gen_add_data_offset(s, insn);
gen_movl_reg_T1(s, rn);
} else if (insn & (1 << 21))
gen_movl_reg_T1(s, rn); {
}
break;
case 0x08:
case 0x09:
{
int j, n, user, loaded_base;
/* load/store multiple words */
/* XXX: store correct base if write back */
user = 0;
if (insn & (1 << 22)) {
if (IS_USER(s))
goto illegal_op; /* only usable in supervisor mode */
if ((insn & (1 << 15)) == 0)
user = 1;
}
rn = (insn >> 16) & 0xf;
gen_movl_T1_reg(s, rn);
/* compute total size */
loaded_base = 0;
n = 0;
for(i=0;i<16;i++) {
if (insn & (1 << i))
n++;
}
/* XXX: test invalid n == 0 case ? */
if (insn & (1 << 23)) {
if (insn & (1 << 24)) {
/* pre increment */
gen_op_addl_T1_im(4);
} else {
/* post increment */
}
} else {
if (insn & (1 << 24)) {
/* pre decrement */
gen_op_addl_T1_im(-(n * 4));
} else {
/* post decrement */
if (n != 1)
gen_op_addl_T1_im(-((n - 1) * 4));
}
}
j = 0;
for(i=0;i<16;i++) {
if (insn & (1 << i)) {
if (insn & (1 << 20)) {
/* load */
gen_ldst(ldl, s);
if (i == 15) {
gen_bx(s);
} else if (user) {
gen_op_movl_user_T0(i);
} else if (i == rn) {
gen_op_movl_T2_T0();
loaded_base = 1;
} else {
gen_movl_reg_T0(s, i);
}
} else {
/* store */
if (i == 15) {
/* special case: r15 = PC + 12 */
val = (long)s->pc + 8;
gen_op_movl_TN_im[0](val);
} else if (user) {
gen_op_movl_T0_user(i);
} else {
gen_movl_T0_reg(s, i);
}
gen_ldst(stl, s);
}
j++;
/* no need to add after the last transfer */
if (j != n)
gen_op_addl_T1_im(4);
}
}
if (insn & (1 << 21)) {
/* write back */
if (insn & (1 << 23)) {
if (insn & (1 << 24)) {
/* pre increment */
} else {
/* post increment */
gen_op_addl_T1_im(4);
}
} else {
if (insn & (1 << 24)) {
/* pre decrement */
if (n != 1)
gen_op_addl_T1_im(-((n - 1) * 4));
} else {
/* post decrement */
gen_op_addl_T1_im(-(n * 4));
}
}
gen_movl_reg_T1(s, rn);
}
if (loaded_base) {
gen_op_movl_T0_T2();
gen_movl_reg_T0(s, rn);
}
if ((insn & (1 << 22)) && !user) {
/* Restore CPSR from SPSR. */
gen_op_movl_T0_spsr();
gen_op_movl_cpsr_T0(0xffffffff);
s->is_jmp = DISAS_UPDATE;
}
}
break;
case 0xa:
case 0xb:
{
int32_t offset;
/* branch (and link) */
val = (int32_t)s->pc;
if (insn & (1 << 24)) {
gen_op_movl_T0_im(val);
gen_op_movl_reg_TN[0][14]();
}
offset = (((int32_t)insn << 8) >> 8);
val += (offset << 2) + 4;
gen_jmp(s, val);
}
break;
case 0xc:
case 0xd:
case 0xe:
/* Coprocessor. */
op1 = (insn >> 8) & 0xf;
switch (op1) {
case 10:
case 11:
if (disas_vfp_insn (env, s, insn))
goto illegal_op;
break;
case 15:
if (disas_cp15_insn (s, insn))
goto illegal_op;
break;
default:
/* unknown coprocessor. */
goto illegal_op;
}
break;
case 0xf:
/* swi */
gen_op_movl_T0_im((long)s->pc);
gen_op_movl_reg_TN[0][15]();
gen_op_swi();
s->is_jmp = DISAS_JUMP;
break;
default:
illegal_op:
gen_op_movl_T0_im((long)s->pc - 4);
gen_op_movl_reg_TN[0][15]();
gen_op_undef_insn();
s->is_jmp = DISAS_JUMP;
break;
}
}
}
| true |
qemu
|
6658ffb81ee56a510d7d77025872a508a9adce3a
|
static void disas_arm_insn(CPUState * env, DisasContext *s)
{
unsigned int cond, insn, val, op1, i, shift, rm, rs, rn, rd, sh;
insn = ldl_code(s->pc);
s->pc += 4;
cond = insn >> 28;
if (cond == 0xf){
if ((insn & 0x0d70f000) == 0x0550f000)
return;
else if ((insn & 0x0e000000) == 0x0a000000) {
int32_t offset;
val = (uint32_t)s->pc;
gen_op_movl_T0_im(val);
gen_movl_reg_T0(s, 14);
offset = (((int32_t)insn) << 8) >> 8;
val += (offset << 2) | ((insn >> 23) & 2) | 1;
val += 4;
gen_op_movl_T0_im(val);
gen_bx(s);
return;
} else if ((insn & 0x0fe00000) == 0x0c400000) {
} else if ((insn & 0x0f000010) == 0x0e000010) {
} else if ((insn & 0x0ff10010) == 0x01000000) {
} else if ((insn & 0x0ffffdff) == 0x01010000) {
if (insn & (1 << 9)) {
goto illegal_op;
}
return;
}
goto illegal_op;
}
if (cond != 0xe) {
s->condlabel = gen_new_label();
gen_test_cc[cond ^ 1](s->condlabel);
s->condjmp = 1;
}
if ((insn & 0x0f900000) == 0x03000000) {
if ((insn & 0x0fb0f000) != 0x0320f000)
goto illegal_op;
val = insn & 0xff;
shift = ((insn >> 8) & 0xf) * 2;
if (shift)
val = (val >> shift) | (val << (32 - shift));
gen_op_movl_T0_im(val);
i = ((insn & (1 << 22)) != 0);
if (gen_set_psr_T0(s, msr_mask(s, (insn >> 16) & 0xf, i), i))
goto illegal_op;
} else if ((insn & 0x0f900000) == 0x01000000
&& (insn & 0x00000090) != 0x00000090) {
op1 = (insn >> 21) & 3;
sh = (insn >> 4) & 0xf;
rm = insn & 0xf;
switch (sh) {
case 0x0:
if (op1 & 1) {
gen_movl_T0_reg(s, rm);
i = ((op1 & 2) != 0);
if (gen_set_psr_T0(s, msr_mask(s, (insn >> 16) & 0xf, i), i))
goto illegal_op;
} else {
rd = (insn >> 12) & 0xf;
if (op1 & 2) {
if (IS_USER(s))
goto illegal_op;
gen_op_movl_T0_spsr();
} else {
gen_op_movl_T0_cpsr();
}
gen_movl_reg_T0(s, rd);
}
break;
case 0x1:
if (op1 == 1) {
gen_movl_T0_reg(s, rm);
gen_bx(s);
} else if (op1 == 3) {
rd = (insn >> 12) & 0xf;
gen_movl_T0_reg(s, rm);
gen_op_clz_T0();
gen_movl_reg_T0(s, rd);
} else {
goto illegal_op;
}
break;
case 0x2:
if (op1 == 1) {
ARCH(5J);
gen_movl_T0_reg(s, rm);
gen_bx(s);
} else {
goto illegal_op;
}
break;
case 0x3:
if (op1 != 1)
goto illegal_op;
val = (uint32_t)s->pc;
gen_op_movl_T0_im(val);
gen_movl_reg_T0(s, 14);
gen_movl_T0_reg(s, rm);
gen_bx(s);
break;
case 0x5:
rd = (insn >> 12) & 0xf;
rn = (insn >> 16) & 0xf;
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rn);
if (op1 & 2)
gen_op_double_T1_saturate();
if (op1 & 1)
gen_op_subl_T0_T1_saturate();
else
gen_op_addl_T0_T1_saturate();
gen_movl_reg_T0(s, rd);
break;
case 7:
gen_op_movl_T0_im((long)s->pc - 4);
gen_op_movl_reg_TN[0][15]();
gen_op_bkpt();
s->is_jmp = DISAS_JUMP;
break;
case 0x8:
case 0xa:
case 0xc:
case 0xe:
rs = (insn >> 8) & 0xf;
rn = (insn >> 12) & 0xf;
rd = (insn >> 16) & 0xf;
if (op1 == 1) {
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rs);
if (sh & 4)
gen_op_sarl_T1_im(16);
else
gen_op_sxth_T1();
gen_op_imulw_T0_T1();
if ((sh & 2) == 0) {
gen_movl_T1_reg(s, rn);
gen_op_addl_T0_T1_setq();
}
gen_movl_reg_T0(s, rd);
} else {
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rs);
gen_mulxy(sh & 2, sh & 4);
if (op1 == 2) {
gen_op_signbit_T1_T0();
gen_op_addq_T0_T1(rn, rd);
gen_movl_reg_T0(s, rn);
gen_movl_reg_T1(s, rd);
} else {
if (op1 == 0) {
gen_movl_T1_reg(s, rn);
gen_op_addl_T0_T1_setq();
}
gen_movl_reg_T0(s, rd);
}
}
break;
default:
goto illegal_op;
}
} else if (((insn & 0x0e000000) == 0 &&
(insn & 0x00000090) != 0x90) ||
((insn & 0x0e000000) == (1 << 25))) {
int set_cc, logic_cc, shiftop;
op1 = (insn >> 21) & 0xf;
set_cc = (insn >> 20) & 1;
logic_cc = table_logic_cc[op1] & set_cc;
if (insn & (1 << 25)) {
val = insn & 0xff;
shift = ((insn >> 8) & 0xf) * 2;
if (shift)
val = (val >> shift) | (val << (32 - shift));
gen_op_movl_T1_im(val);
if (logic_cc && shift)
gen_op_mov_CF_T1();
} else {
rm = (insn) & 0xf;
gen_movl_T1_reg(s, rm);
shiftop = (insn >> 5) & 3;
if (!(insn & (1 << 4))) {
shift = (insn >> 7) & 0x1f;
if (shift != 0) {
if (logic_cc) {
gen_shift_T1_im_cc[shiftop](shift);
} else {
gen_shift_T1_im[shiftop](shift);
}
} else if (shiftop != 0) {
if (logic_cc) {
gen_shift_T1_0_cc[shiftop]();
} else {
gen_shift_T1_0[shiftop]();
}
}
} else {
rs = (insn >> 8) & 0xf;
gen_movl_T0_reg(s, rs);
if (logic_cc) {
gen_shift_T1_T0_cc[shiftop]();
} else {
gen_shift_T1_T0[shiftop]();
}
}
}
if (op1 != 0x0f && op1 != 0x0d) {
rn = (insn >> 16) & 0xf;
gen_movl_T0_reg(s, rn);
}
rd = (insn >> 12) & 0xf;
switch(op1) {
case 0x00:
gen_op_andl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
case 0x01:
gen_op_xorl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
case 0x02:
if (set_cc && rd == 15) {
if (IS_USER(s))
goto illegal_op;
gen_op_subl_T0_T1_cc();
gen_exception_return(s);
} else {
if (set_cc)
gen_op_subl_T0_T1_cc();
else
gen_op_subl_T0_T1();
gen_movl_reg_T0(s, rd);
}
break;
case 0x03:
if (set_cc)
gen_op_rsbl_T0_T1_cc();
else
gen_op_rsbl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x04:
if (set_cc)
gen_op_addl_T0_T1_cc();
else
gen_op_addl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x05:
if (set_cc)
gen_op_adcl_T0_T1_cc();
else
gen_op_adcl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x06:
if (set_cc)
gen_op_sbcl_T0_T1_cc();
else
gen_op_sbcl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x07:
if (set_cc)
gen_op_rscl_T0_T1_cc();
else
gen_op_rscl_T0_T1();
gen_movl_reg_T0(s, rd);
break;
case 0x08:
if (set_cc) {
gen_op_andl_T0_T1();
gen_op_logic_T0_cc();
}
break;
case 0x09:
if (set_cc) {
gen_op_xorl_T0_T1();
gen_op_logic_T0_cc();
}
break;
case 0x0a:
if (set_cc) {
gen_op_subl_T0_T1_cc();
}
break;
case 0x0b:
if (set_cc) {
gen_op_addl_T0_T1_cc();
}
break;
case 0x0c:
gen_op_orl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
case 0x0d:
if (logic_cc && rd == 15) {
if (IS_USER(s))
goto illegal_op;
gen_op_movl_T0_T1();
gen_exception_return(s);
} else {
gen_movl_reg_T1(s, rd);
if (logic_cc)
gen_op_logic_T1_cc();
}
break;
case 0x0e:
gen_op_bicl_T0_T1();
gen_movl_reg_T0(s, rd);
if (logic_cc)
gen_op_logic_T0_cc();
break;
default:
case 0x0f:
gen_op_notl_T1();
gen_movl_reg_T1(s, rd);
if (logic_cc)
gen_op_logic_T1_cc();
break;
}
} else {
op1 = (insn >> 24) & 0xf;
switch(op1) {
case 0x0:
case 0x1:
sh = (insn >> 5) & 3;
if (sh == 0) {
if (op1 == 0x0) {
rd = (insn >> 16) & 0xf;
rn = (insn >> 12) & 0xf;
rs = (insn >> 8) & 0xf;
rm = (insn) & 0xf;
if (((insn >> 22) & 3) == 0) {
gen_movl_T0_reg(s, rs);
gen_movl_T1_reg(s, rm);
gen_op_mul_T0_T1();
if (insn & (1 << 21)) {
gen_movl_T1_reg(s, rn);
gen_op_addl_T0_T1();
}
if (insn & (1 << 20))
gen_op_logic_T0_cc();
gen_movl_reg_T0(s, rd);
} else {
gen_movl_T0_reg(s, rs);
gen_movl_T1_reg(s, rm);
if (insn & (1 << 22))
gen_op_imull_T0_T1();
else
gen_op_mull_T0_T1();
if (insn & (1 << 21))
gen_op_addq_T0_T1(rn, rd);
if (!(insn & (1 << 23))) {
ARCH(6);
gen_op_addq_lo_T0_T1(rn);
gen_op_addq_lo_T0_T1(rd);
}
if (insn & (1 << 20))
gen_op_logicq_cc();
gen_movl_reg_T0(s, rn);
gen_movl_reg_T1(s, rd);
}
} else {
rn = (insn >> 16) & 0xf;
rd = (insn >> 12) & 0xf;
if (insn & (1 << 23)) {
goto illegal_op;
} else {
rm = (insn) & 0xf;
gen_movl_T0_reg(s, rm);
gen_movl_T1_reg(s, rn);
if (insn & (1 << 22)) {
gen_ldst(swpb, s);
} else {
gen_ldst(swpl, s);
}
gen_movl_reg_T0(s, rd);
}
}
} else {
int address_offset;
rn = (insn >> 16) & 0xf;
rd = (insn >> 12) & 0xf;
gen_movl_T1_reg(s, rn);
if (insn & (1 << 24))
gen_add_datah_offset(s, insn, 0);
address_offset = 0;
if (insn & (1 << 20)) {
switch(sh) {
case 1:
gen_ldst(lduw, s);
break;
case 2:
gen_ldst(ldsb, s);
break;
default:
case 3:
gen_ldst(ldsw, s);
break;
}
gen_movl_reg_T0(s, rd);
} else if (sh & 2) {
if (sh & 1) {
gen_movl_T0_reg(s, rd);
gen_ldst(stl, s);
gen_op_addl_T1_im(4);
gen_movl_T0_reg(s, rd + 1);
gen_ldst(stl, s);
} else {
gen_ldst(ldl, s);
gen_movl_reg_T0(s, rd);
gen_op_addl_T1_im(4);
gen_ldst(ldl, s);
gen_movl_reg_T0(s, rd + 1);
}
address_offset = -4;
} else {
gen_movl_T0_reg(s, rd);
gen_ldst(stw, s);
}
if (!(insn & (1 << 24))) {
gen_add_datah_offset(s, insn, address_offset);
gen_movl_reg_T1(s, rn);
} else if (insn & (1 << 21)) {
if (address_offset)
gen_op_addl_T1_im(address_offset);
gen_movl_reg_T1(s, rn);
}
}
break;
case 0x4:
case 0x5:
case 0x6:
case 0x7:
sh = (0xf << 20) | (0xf << 4);
if (op1 == 0x7 && ((insn & sh) == sh))
{
goto illegal_op;
}
rn = (insn >> 16) & 0xf;
rd = (insn >> 12) & 0xf;
gen_movl_T1_reg(s, rn);
i = (IS_USER(s) || (insn & 0x01200000) == 0x00200000);
if (insn & (1 << 24))
gen_add_data_offset(s, insn);
if (insn & (1 << 20)) {
#if defined(CONFIG_USER_ONLY)
if (insn & (1 << 22))
gen_op_ldub_raw();
else
gen_op_ldl_raw();
#else
if (insn & (1 << 22)) {
if (i)
gen_op_ldub_user();
else
gen_op_ldub_kernel();
} else {
if (i)
gen_op_ldl_user();
else
gen_op_ldl_kernel();
}
#endif
if (rd == 15)
gen_bx(s);
else
gen_movl_reg_T0(s, rd);
} else {
gen_movl_T0_reg(s, rd);
#if defined(CONFIG_USER_ONLY)
if (insn & (1 << 22))
gen_op_stb_raw();
else
gen_op_stl_raw();
#else
if (insn & (1 << 22)) {
if (i)
gen_op_stb_user();
else
gen_op_stb_kernel();
} else {
if (i)
gen_op_stl_user();
else
gen_op_stl_kernel();
}
#endif
}
if (!(insn & (1 << 24))) {
gen_add_data_offset(s, insn);
gen_movl_reg_T1(s, rn);
} else if (insn & (1 << 21))
gen_movl_reg_T1(s, rn); {
}
break;
case 0x08:
case 0x09:
{
int j, n, user, loaded_base;
user = 0;
if (insn & (1 << 22)) {
if (IS_USER(s))
goto illegal_op;
if ((insn & (1 << 15)) == 0)
user = 1;
}
rn = (insn >> 16) & 0xf;
gen_movl_T1_reg(s, rn);
loaded_base = 0;
n = 0;
for(i=0;i<16;i++) {
if (insn & (1 << i))
n++;
}
if (insn & (1 << 23)) {
if (insn & (1 << 24)) {
gen_op_addl_T1_im(4);
} else {
}
} else {
if (insn & (1 << 24)) {
gen_op_addl_T1_im(-(n * 4));
} else {
if (n != 1)
gen_op_addl_T1_im(-((n - 1) * 4));
}
}
j = 0;
for(i=0;i<16;i++) {
if (insn & (1 << i)) {
if (insn & (1 << 20)) {
gen_ldst(ldl, s);
if (i == 15) {
gen_bx(s);
} else if (user) {
gen_op_movl_user_T0(i);
} else if (i == rn) {
gen_op_movl_T2_T0();
loaded_base = 1;
} else {
gen_movl_reg_T0(s, i);
}
} else {
if (i == 15) {
val = (long)s->pc + 8;
gen_op_movl_TN_im[0](val);
} else if (user) {
gen_op_movl_T0_user(i);
} else {
gen_movl_T0_reg(s, i);
}
gen_ldst(stl, s);
}
j++;
if (j != n)
gen_op_addl_T1_im(4);
}
}
if (insn & (1 << 21)) {
if (insn & (1 << 23)) {
if (insn & (1 << 24)) {
} else {
gen_op_addl_T1_im(4);
}
} else {
if (insn & (1 << 24)) {
if (n != 1)
gen_op_addl_T1_im(-((n - 1) * 4));
} else {
gen_op_addl_T1_im(-(n * 4));
}
}
gen_movl_reg_T1(s, rn);
}
if (loaded_base) {
gen_op_movl_T0_T2();
gen_movl_reg_T0(s, rn);
}
if ((insn & (1 << 22)) && !user) {
gen_op_movl_T0_spsr();
gen_op_movl_cpsr_T0(0xffffffff);
s->is_jmp = DISAS_UPDATE;
}
}
break;
case 0xa:
case 0xb:
{
int32_t offset;
val = (int32_t)s->pc;
if (insn & (1 << 24)) {
gen_op_movl_T0_im(val);
gen_op_movl_reg_TN[0][14]();
}
offset = (((int32_t)insn << 8) >> 8);
val += (offset << 2) + 4;
gen_jmp(s, val);
}
break;
case 0xc:
case 0xd:
case 0xe:
op1 = (insn >> 8) & 0xf;
switch (op1) {
case 10:
case 11:
if (disas_vfp_insn (env, s, insn))
goto illegal_op;
break;
case 15:
if (disas_cp15_insn (s, insn))
goto illegal_op;
break;
default:
goto illegal_op;
}
break;
case 0xf:
gen_op_movl_T0_im((long)s->pc);
gen_op_movl_reg_TN[0][15]();
gen_op_swi();
s->is_jmp = DISAS_JUMP;
break;
default:
illegal_op:
gen_op_movl_T0_im((long)s->pc - 4);
gen_op_movl_reg_TN[0][15]();
gen_op_undef_insn();
s->is_jmp = DISAS_JUMP;
break;
}
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(CPUState * VAR_0, DisasContext *VAR_1)
{
unsigned int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;
VAR_3 = ldl_code(VAR_1->pc);
VAR_1->pc += 4;
VAR_2 = VAR_3 >> 28;
if (VAR_2 == 0xf){
if ((VAR_3 & 0x0d70f000) == 0x0550f000)
return;
else if ((VAR_3 & 0x0e000000) == 0x0a000000) {
int32_t offset;
VAR_4 = (uint32_t)VAR_1->pc;
gen_op_movl_T0_im(VAR_4);
gen_movl_reg_T0(VAR_1, 14);
offset = (((int32_t)VAR_3) << 8) >> 8;
VAR_4 += (offset << 2) | ((VAR_3 >> 23) & 2) | 1;
VAR_4 += 4;
gen_op_movl_T0_im(VAR_4);
gen_bx(VAR_1);
return;
} else if ((VAR_3 & 0x0fe00000) == 0x0c400000) {
} else if ((VAR_3 & 0x0f000010) == 0x0e000010) {
} else if ((VAR_3 & 0x0ff10010) == 0x01000000) {
} else if ((VAR_3 & 0x0ffffdff) == 0x01010000) {
if (VAR_3 & (1 << 9)) {
goto illegal_op;
}
return;
}
goto illegal_op;
}
if (VAR_2 != 0xe) {
VAR_1->condlabel = gen_new_label();
gen_test_cc[VAR_2 ^ 1](VAR_1->condlabel);
VAR_1->condjmp = 1;
}
if ((VAR_3 & 0x0f900000) == 0x03000000) {
if ((VAR_3 & 0x0fb0f000) != 0x0320f000)
goto illegal_op;
VAR_4 = VAR_3 & 0xff;
VAR_7 = ((VAR_3 >> 8) & 0xf) * 2;
if (VAR_7)
VAR_4 = (VAR_4 >> VAR_7) | (VAR_4 << (32 - VAR_7));
gen_op_movl_T0_im(VAR_4);
VAR_6 = ((VAR_3 & (1 << 22)) != 0);
if (gen_set_psr_T0(VAR_1, msr_mask(VAR_1, (VAR_3 >> 16) & 0xf, VAR_6), VAR_6))
goto illegal_op;
} else if ((VAR_3 & 0x0f900000) == 0x01000000
&& (VAR_3 & 0x00000090) != 0x00000090) {
VAR_5 = (VAR_3 >> 21) & 3;
VAR_12 = (VAR_3 >> 4) & 0xf;
VAR_8 = VAR_3 & 0xf;
switch (VAR_12) {
case 0x0:
if (VAR_5 & 1) {
gen_movl_T0_reg(VAR_1, VAR_8);
VAR_6 = ((VAR_5 & 2) != 0);
if (gen_set_psr_T0(VAR_1, msr_mask(VAR_1, (VAR_3 >> 16) & 0xf, VAR_6), VAR_6))
goto illegal_op;
} else {
VAR_11 = (VAR_3 >> 12) & 0xf;
if (VAR_5 & 2) {
if (IS_USER(VAR_1))
goto illegal_op;
gen_op_movl_T0_spsr();
} else {
gen_op_movl_T0_cpsr();
}
gen_movl_reg_T0(VAR_1, VAR_11);
}
break;
case 0x1:
if (VAR_5 == 1) {
gen_movl_T0_reg(VAR_1, VAR_8);
gen_bx(VAR_1);
} else if (VAR_5 == 3) {
VAR_11 = (VAR_3 >> 12) & 0xf;
gen_movl_T0_reg(VAR_1, VAR_8);
gen_op_clz_T0();
gen_movl_reg_T0(VAR_1, VAR_11);
} else {
goto illegal_op;
}
break;
case 0x2:
if (VAR_5 == 1) {
ARCH(5J);
gen_movl_T0_reg(VAR_1, VAR_8);
gen_bx(VAR_1);
} else {
goto illegal_op;
}
break;
case 0x3:
if (VAR_5 != 1)
goto illegal_op;
VAR_4 = (uint32_t)VAR_1->pc;
gen_op_movl_T0_im(VAR_4);
gen_movl_reg_T0(VAR_1, 14);
gen_movl_T0_reg(VAR_1, VAR_8);
gen_bx(VAR_1);
break;
case 0x5:
VAR_11 = (VAR_3 >> 12) & 0xf;
VAR_10 = (VAR_3 >> 16) & 0xf;
gen_movl_T0_reg(VAR_1, VAR_8);
gen_movl_T1_reg(VAR_1, VAR_10);
if (VAR_5 & 2)
gen_op_double_T1_saturate();
if (VAR_5 & 1)
gen_op_subl_T0_T1_saturate();
else
gen_op_addl_T0_T1_saturate();
gen_movl_reg_T0(VAR_1, VAR_11);
break;
case 7:
gen_op_movl_T0_im((long)VAR_1->pc - 4);
gen_op_movl_reg_TN[0][15]();
gen_op_bkpt();
VAR_1->is_jmp = DISAS_JUMP;
break;
case 0x8:
case 0xa:
case 0xc:
case 0xe:
VAR_9 = (VAR_3 >> 8) & 0xf;
VAR_10 = (VAR_3 >> 12) & 0xf;
VAR_11 = (VAR_3 >> 16) & 0xf;
if (VAR_5 == 1) {
gen_movl_T0_reg(VAR_1, VAR_8);
gen_movl_T1_reg(VAR_1, VAR_9);
if (VAR_12 & 4)
gen_op_sarl_T1_im(16);
else
gen_op_sxth_T1();
gen_op_imulw_T0_T1();
if ((VAR_12 & 2) == 0) {
gen_movl_T1_reg(VAR_1, VAR_10);
gen_op_addl_T0_T1_setq();
}
gen_movl_reg_T0(VAR_1, VAR_11);
} else {
gen_movl_T0_reg(VAR_1, VAR_8);
gen_movl_T1_reg(VAR_1, VAR_9);
gen_mulxy(VAR_12 & 2, VAR_12 & 4);
if (VAR_5 == 2) {
gen_op_signbit_T1_T0();
gen_op_addq_T0_T1(VAR_10, VAR_11);
gen_movl_reg_T0(VAR_1, VAR_10);
gen_movl_reg_T1(VAR_1, VAR_11);
} else {
if (VAR_5 == 0) {
gen_movl_T1_reg(VAR_1, VAR_10);
gen_op_addl_T0_T1_setq();
}
gen_movl_reg_T0(VAR_1, VAR_11);
}
}
break;
default:
goto illegal_op;
}
} else if (((VAR_3 & 0x0e000000) == 0 &&
(VAR_3 & 0x00000090) != 0x90) ||
((VAR_3 & 0x0e000000) == (1 << 25))) {
int VAR_13, VAR_14, VAR_15;
VAR_5 = (VAR_3 >> 21) & 0xf;
VAR_13 = (VAR_3 >> 20) & 1;
VAR_14 = table_logic_cc[VAR_5] & VAR_13;
if (VAR_3 & (1 << 25)) {
VAR_4 = VAR_3 & 0xff;
VAR_7 = ((VAR_3 >> 8) & 0xf) * 2;
if (VAR_7)
VAR_4 = (VAR_4 >> VAR_7) | (VAR_4 << (32 - VAR_7));
gen_op_movl_T1_im(VAR_4);
if (VAR_14 && VAR_7)
gen_op_mov_CF_T1();
} else {
VAR_8 = (VAR_3) & 0xf;
gen_movl_T1_reg(VAR_1, VAR_8);
VAR_15 = (VAR_3 >> 5) & 3;
if (!(VAR_3 & (1 << 4))) {
VAR_7 = (VAR_3 >> 7) & 0x1f;
if (VAR_7 != 0) {
if (VAR_14) {
gen_shift_T1_im_cc[VAR_15](VAR_7);
} else {
gen_shift_T1_im[VAR_15](VAR_7);
}
} else if (VAR_15 != 0) {
if (VAR_14) {
gen_shift_T1_0_cc[VAR_15]();
} else {
gen_shift_T1_0[VAR_15]();
}
}
} else {
VAR_9 = (VAR_3 >> 8) & 0xf;
gen_movl_T0_reg(VAR_1, VAR_9);
if (VAR_14) {
gen_shift_T1_T0_cc[VAR_15]();
} else {
gen_shift_T1_T0[VAR_15]();
}
}
}
if (VAR_5 != 0x0f && VAR_5 != 0x0d) {
VAR_10 = (VAR_3 >> 16) & 0xf;
gen_movl_T0_reg(VAR_1, VAR_10);
}
VAR_11 = (VAR_3 >> 12) & 0xf;
switch(VAR_5) {
case 0x00:
gen_op_andl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
if (VAR_14)
gen_op_logic_T0_cc();
break;
case 0x01:
gen_op_xorl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
if (VAR_14)
gen_op_logic_T0_cc();
break;
case 0x02:
if (VAR_13 && VAR_11 == 15) {
if (IS_USER(VAR_1))
goto illegal_op;
gen_op_subl_T0_T1_cc();
gen_exception_return(VAR_1);
} else {
if (VAR_13)
gen_op_subl_T0_T1_cc();
else
gen_op_subl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
}
break;
case 0x03:
if (VAR_13)
gen_op_rsbl_T0_T1_cc();
else
gen_op_rsbl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
break;
case 0x04:
if (VAR_13)
gen_op_addl_T0_T1_cc();
else
gen_op_addl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
break;
case 0x05:
if (VAR_13)
gen_op_adcl_T0_T1_cc();
else
gen_op_adcl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
break;
case 0x06:
if (VAR_13)
gen_op_sbcl_T0_T1_cc();
else
gen_op_sbcl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
break;
case 0x07:
if (VAR_13)
gen_op_rscl_T0_T1_cc();
else
gen_op_rscl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
break;
case 0x08:
if (VAR_13) {
gen_op_andl_T0_T1();
gen_op_logic_T0_cc();
}
break;
case 0x09:
if (VAR_13) {
gen_op_xorl_T0_T1();
gen_op_logic_T0_cc();
}
break;
case 0x0a:
if (VAR_13) {
gen_op_subl_T0_T1_cc();
}
break;
case 0x0b:
if (VAR_13) {
gen_op_addl_T0_T1_cc();
}
break;
case 0x0c:
gen_op_orl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
if (VAR_14)
gen_op_logic_T0_cc();
break;
case 0x0d:
if (VAR_14 && VAR_11 == 15) {
if (IS_USER(VAR_1))
goto illegal_op;
gen_op_movl_T0_T1();
gen_exception_return(VAR_1);
} else {
gen_movl_reg_T1(VAR_1, VAR_11);
if (VAR_14)
gen_op_logic_T1_cc();
}
break;
case 0x0e:
gen_op_bicl_T0_T1();
gen_movl_reg_T0(VAR_1, VAR_11);
if (VAR_14)
gen_op_logic_T0_cc();
break;
default:
case 0x0f:
gen_op_notl_T1();
gen_movl_reg_T1(VAR_1, VAR_11);
if (VAR_14)
gen_op_logic_T1_cc();
break;
}
} else {
VAR_5 = (VAR_3 >> 24) & 0xf;
switch(VAR_5) {
case 0x0:
case 0x1:
VAR_12 = (VAR_3 >> 5) & 3;
if (VAR_12 == 0) {
if (VAR_5 == 0x0) {
VAR_11 = (VAR_3 >> 16) & 0xf;
VAR_10 = (VAR_3 >> 12) & 0xf;
VAR_9 = (VAR_3 >> 8) & 0xf;
VAR_8 = (VAR_3) & 0xf;
if (((VAR_3 >> 22) & 3) == 0) {
gen_movl_T0_reg(VAR_1, VAR_9);
gen_movl_T1_reg(VAR_1, VAR_8);
gen_op_mul_T0_T1();
if (VAR_3 & (1 << 21)) {
gen_movl_T1_reg(VAR_1, VAR_10);
gen_op_addl_T0_T1();
}
if (VAR_3 & (1 << 20))
gen_op_logic_T0_cc();
gen_movl_reg_T0(VAR_1, VAR_11);
} else {
gen_movl_T0_reg(VAR_1, VAR_9);
gen_movl_T1_reg(VAR_1, VAR_8);
if (VAR_3 & (1 << 22))
gen_op_imull_T0_T1();
else
gen_op_mull_T0_T1();
if (VAR_3 & (1 << 21))
gen_op_addq_T0_T1(VAR_10, VAR_11);
if (!(VAR_3 & (1 << 23))) {
ARCH(6);
gen_op_addq_lo_T0_T1(VAR_10);
gen_op_addq_lo_T0_T1(VAR_11);
}
if (VAR_3 & (1 << 20))
gen_op_logicq_cc();
gen_movl_reg_T0(VAR_1, VAR_10);
gen_movl_reg_T1(VAR_1, VAR_11);
}
} else {
VAR_10 = (VAR_3 >> 16) & 0xf;
VAR_11 = (VAR_3 >> 12) & 0xf;
if (VAR_3 & (1 << 23)) {
goto illegal_op;
} else {
VAR_8 = (VAR_3) & 0xf;
gen_movl_T0_reg(VAR_1, VAR_8);
gen_movl_T1_reg(VAR_1, VAR_10);
if (VAR_3 & (1 << 22)) {
gen_ldst(swpb, VAR_1);
} else {
gen_ldst(swpl, VAR_1);
}
gen_movl_reg_T0(VAR_1, VAR_11);
}
}
} else {
int VAR_16;
VAR_10 = (VAR_3 >> 16) & 0xf;
VAR_11 = (VAR_3 >> 12) & 0xf;
gen_movl_T1_reg(VAR_1, VAR_10);
if (VAR_3 & (1 << 24))
gen_add_datah_offset(VAR_1, VAR_3, 0);
VAR_16 = 0;
if (VAR_3 & (1 << 20)) {
switch(VAR_12) {
case 1:
gen_ldst(lduw, VAR_1);
break;
case 2:
gen_ldst(ldsb, VAR_1);
break;
default:
case 3:
gen_ldst(ldsw, VAR_1);
break;
}
gen_movl_reg_T0(VAR_1, VAR_11);
} else if (VAR_12 & 2) {
if (VAR_12 & 1) {
gen_movl_T0_reg(VAR_1, VAR_11);
gen_ldst(stl, VAR_1);
gen_op_addl_T1_im(4);
gen_movl_T0_reg(VAR_1, VAR_11 + 1);
gen_ldst(stl, VAR_1);
} else {
gen_ldst(ldl, VAR_1);
gen_movl_reg_T0(VAR_1, VAR_11);
gen_op_addl_T1_im(4);
gen_ldst(ldl, VAR_1);
gen_movl_reg_T0(VAR_1, VAR_11 + 1);
}
VAR_16 = -4;
} else {
gen_movl_T0_reg(VAR_1, VAR_11);
gen_ldst(stw, VAR_1);
}
if (!(VAR_3 & (1 << 24))) {
gen_add_datah_offset(VAR_1, VAR_3, VAR_16);
gen_movl_reg_T1(VAR_1, VAR_10);
} else if (VAR_3 & (1 << 21)) {
if (VAR_16)
gen_op_addl_T1_im(VAR_16);
gen_movl_reg_T1(VAR_1, VAR_10);
}
}
break;
case 0x4:
case 0x5:
case 0x6:
case 0x7:
VAR_12 = (0xf << 20) | (0xf << 4);
if (VAR_5 == 0x7 && ((VAR_3 & VAR_12) == VAR_12))
{
goto illegal_op;
}
VAR_10 = (VAR_3 >> 16) & 0xf;
VAR_11 = (VAR_3 >> 12) & 0xf;
gen_movl_T1_reg(VAR_1, VAR_10);
VAR_6 = (IS_USER(VAR_1) || (VAR_3 & 0x01200000) == 0x00200000);
if (VAR_3 & (1 << 24))
gen_add_data_offset(VAR_1, VAR_3);
if (VAR_3 & (1 << 20)) {
#if defined(CONFIG_USER_ONLY)
if (VAR_3 & (1 << 22))
gen_op_ldub_raw();
else
gen_op_ldl_raw();
#else
if (VAR_3 & (1 << 22)) {
if (VAR_6)
gen_op_ldub_user();
else
gen_op_ldub_kernel();
} else {
if (VAR_6)
gen_op_ldl_user();
else
gen_op_ldl_kernel();
}
#endif
if (VAR_11 == 15)
gen_bx(VAR_1);
else
gen_movl_reg_T0(VAR_1, VAR_11);
} else {
gen_movl_T0_reg(VAR_1, VAR_11);
#if defined(CONFIG_USER_ONLY)
if (VAR_3 & (1 << 22))
gen_op_stb_raw();
else
gen_op_stl_raw();
#else
if (VAR_3 & (1 << 22)) {
if (VAR_6)
gen_op_stb_user();
else
gen_op_stb_kernel();
} else {
if (VAR_6)
gen_op_stl_user();
else
gen_op_stl_kernel();
}
#endif
}
if (!(VAR_3 & (1 << 24))) {
gen_add_data_offset(VAR_1, VAR_3);
gen_movl_reg_T1(VAR_1, VAR_10);
} else if (VAR_3 & (1 << 21))
gen_movl_reg_T1(VAR_1, VAR_10); {
}
break;
case 0x08:
case 0x09:
{
int VAR_17, VAR_18, VAR_19, VAR_20;
VAR_19 = 0;
if (VAR_3 & (1 << 22)) {
if (IS_USER(VAR_1))
goto illegal_op;
if ((VAR_3 & (1 << 15)) == 0)
VAR_19 = 1;
}
VAR_10 = (VAR_3 >> 16) & 0xf;
gen_movl_T1_reg(VAR_1, VAR_10);
VAR_20 = 0;
VAR_18 = 0;
for(VAR_6=0;VAR_6<16;VAR_6++) {
if (VAR_3 & (1 << VAR_6))
VAR_18++;
}
if (VAR_3 & (1 << 23)) {
if (VAR_3 & (1 << 24)) {
gen_op_addl_T1_im(4);
} else {
}
} else {
if (VAR_3 & (1 << 24)) {
gen_op_addl_T1_im(-(VAR_18 * 4));
} else {
if (VAR_18 != 1)
gen_op_addl_T1_im(-((VAR_18 - 1) * 4));
}
}
VAR_17 = 0;
for(VAR_6=0;VAR_6<16;VAR_6++) {
if (VAR_3 & (1 << VAR_6)) {
if (VAR_3 & (1 << 20)) {
gen_ldst(ldl, VAR_1);
if (VAR_6 == 15) {
gen_bx(VAR_1);
} else if (VAR_19) {
gen_op_movl_user_T0(VAR_6);
} else if (VAR_6 == VAR_10) {
gen_op_movl_T2_T0();
VAR_20 = 1;
} else {
gen_movl_reg_T0(VAR_1, VAR_6);
}
} else {
if (VAR_6 == 15) {
VAR_4 = (long)VAR_1->pc + 8;
gen_op_movl_TN_im[0](VAR_4);
} else if (VAR_19) {
gen_op_movl_T0_user(VAR_6);
} else {
gen_movl_T0_reg(VAR_1, VAR_6);
}
gen_ldst(stl, VAR_1);
}
VAR_17++;
if (VAR_17 != VAR_18)
gen_op_addl_T1_im(4);
}
}
if (VAR_3 & (1 << 21)) {
if (VAR_3 & (1 << 23)) {
if (VAR_3 & (1 << 24)) {
} else {
gen_op_addl_T1_im(4);
}
} else {
if (VAR_3 & (1 << 24)) {
if (VAR_18 != 1)
gen_op_addl_T1_im(-((VAR_18 - 1) * 4));
} else {
gen_op_addl_T1_im(-(VAR_18 * 4));
}
}
gen_movl_reg_T1(VAR_1, VAR_10);
}
if (VAR_20) {
gen_op_movl_T0_T2();
gen_movl_reg_T0(VAR_1, VAR_10);
}
if ((VAR_3 & (1 << 22)) && !VAR_19) {
gen_op_movl_T0_spsr();
gen_op_movl_cpsr_T0(0xffffffff);
VAR_1->is_jmp = DISAS_UPDATE;
}
}
break;
case 0xa:
case 0xb:
{
int32_t offset;
VAR_4 = (int32_t)VAR_1->pc;
if (VAR_3 & (1 << 24)) {
gen_op_movl_T0_im(VAR_4);
gen_op_movl_reg_TN[0][14]();
}
offset = (((int32_t)VAR_3 << 8) >> 8);
VAR_4 += (offset << 2) + 4;
gen_jmp(VAR_1, VAR_4);
}
break;
case 0xc:
case 0xd:
case 0xe:
VAR_5 = (VAR_3 >> 8) & 0xf;
switch (VAR_5) {
case 10:
case 11:
if (disas_vfp_insn (VAR_0, VAR_1, VAR_3))
goto illegal_op;
break;
case 15:
if (disas_cp15_insn (VAR_1, VAR_3))
goto illegal_op;
break;
default:
goto illegal_op;
}
break;
case 0xf:
gen_op_movl_T0_im((long)VAR_1->pc);
gen_op_movl_reg_TN[0][15]();
gen_op_swi();
VAR_1->is_jmp = DISAS_JUMP;
break;
default:
illegal_op:
gen_op_movl_T0_im((long)VAR_1->pc - 4);
gen_op_movl_reg_TN[0][15]();
gen_op_undef_insn();
VAR_1->is_jmp = DISAS_JUMP;
break;
}
}
}
|
[
"static void FUNC_0(CPUState * VAR_0, DisasContext *VAR_1)\n{",
"unsigned int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;",
"VAR_3 = ldl_code(VAR_1->pc);",
"VAR_1->pc += 4;",
"VAR_2 = VAR_3 >> 28;",
"if (VAR_2 == 0xf){",
"if ((VAR_3 & 0x0d70f000) == 0x0550f000)\nreturn;",
"else if ((VAR_3 & 0x0e000000) == 0x0a000000) {",
"int32_t offset;",
"VAR_4 = (uint32_t)VAR_1->pc;",
"gen_op_movl_T0_im(VAR_4);",
"gen_movl_reg_T0(VAR_1, 14);",
"offset = (((int32_t)VAR_3) << 8) >> 8;",
"VAR_4 += (offset << 2) | ((VAR_3 >> 23) & 2) | 1;",
"VAR_4 += 4;",
"gen_op_movl_T0_im(VAR_4);",
"gen_bx(VAR_1);",
"return;",
"} else if ((VAR_3 & 0x0fe00000) == 0x0c400000) {",
"} else if ((VAR_3 & 0x0f000010) == 0x0e000010) {",
"} else if ((VAR_3 & 0x0ff10010) == 0x01000000) {",
"} else if ((VAR_3 & 0x0ffffdff) == 0x01010000) {",
"if (VAR_3 & (1 << 9)) {",
"goto illegal_op;",
"}",
"return;",
"}",
"goto illegal_op;",
"}",
"if (VAR_2 != 0xe) {",
"VAR_1->condlabel = gen_new_label();",
"gen_test_cc[VAR_2 ^ 1](VAR_1->condlabel);",
"VAR_1->condjmp = 1;",
"}",
"if ((VAR_3 & 0x0f900000) == 0x03000000) {",
"if ((VAR_3 & 0x0fb0f000) != 0x0320f000)\ngoto illegal_op;",
"VAR_4 = VAR_3 & 0xff;",
"VAR_7 = ((VAR_3 >> 8) & 0xf) * 2;",
"if (VAR_7)\nVAR_4 = (VAR_4 >> VAR_7) | (VAR_4 << (32 - VAR_7));",
"gen_op_movl_T0_im(VAR_4);",
"VAR_6 = ((VAR_3 & (1 << 22)) != 0);",
"if (gen_set_psr_T0(VAR_1, msr_mask(VAR_1, (VAR_3 >> 16) & 0xf, VAR_6), VAR_6))\ngoto illegal_op;",
"} else if ((VAR_3 & 0x0f900000) == 0x01000000",
"&& (VAR_3 & 0x00000090) != 0x00000090) {",
"VAR_5 = (VAR_3 >> 21) & 3;",
"VAR_12 = (VAR_3 >> 4) & 0xf;",
"VAR_8 = VAR_3 & 0xf;",
"switch (VAR_12) {",
"case 0x0:\nif (VAR_5 & 1) {",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"VAR_6 = ((VAR_5 & 2) != 0);",
"if (gen_set_psr_T0(VAR_1, msr_mask(VAR_1, (VAR_3 >> 16) & 0xf, VAR_6), VAR_6))\ngoto illegal_op;",
"} else {",
"VAR_11 = (VAR_3 >> 12) & 0xf;",
"if (VAR_5 & 2) {",
"if (IS_USER(VAR_1))\ngoto illegal_op;",
"gen_op_movl_T0_spsr();",
"} else {",
"gen_op_movl_T0_cpsr();",
"}",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"}",
"break;",
"case 0x1:\nif (VAR_5 == 1) {",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_bx(VAR_1);",
"} else if (VAR_5 == 3) {",
"VAR_11 = (VAR_3 >> 12) & 0xf;",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_op_clz_T0();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"} else {",
"goto illegal_op;",
"}",
"break;",
"case 0x2:\nif (VAR_5 == 1) {",
"ARCH(5J);",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_bx(VAR_1);",
"} else {",
"goto illegal_op;",
"}",
"break;",
"case 0x3:\nif (VAR_5 != 1)\ngoto illegal_op;",
"VAR_4 = (uint32_t)VAR_1->pc;",
"gen_op_movl_T0_im(VAR_4);",
"gen_movl_reg_T0(VAR_1, 14);",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_bx(VAR_1);",
"break;",
"case 0x5:\nVAR_11 = (VAR_3 >> 12) & 0xf;",
"VAR_10 = (VAR_3 >> 16) & 0xf;",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"if (VAR_5 & 2)\ngen_op_double_T1_saturate();",
"if (VAR_5 & 1)\ngen_op_subl_T0_T1_saturate();",
"else\ngen_op_addl_T0_T1_saturate();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"break;",
"case 7:\ngen_op_movl_T0_im((long)VAR_1->pc - 4);",
"gen_op_movl_reg_TN[0][15]();",
"gen_op_bkpt();",
"VAR_1->is_jmp = DISAS_JUMP;",
"break;",
"case 0x8:\ncase 0xa:\ncase 0xc:\ncase 0xe:\nVAR_9 = (VAR_3 >> 8) & 0xf;",
"VAR_10 = (VAR_3 >> 12) & 0xf;",
"VAR_11 = (VAR_3 >> 16) & 0xf;",
"if (VAR_5 == 1) {",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_movl_T1_reg(VAR_1, VAR_9);",
"if (VAR_12 & 4)\ngen_op_sarl_T1_im(16);",
"else\ngen_op_sxth_T1();",
"gen_op_imulw_T0_T1();",
"if ((VAR_12 & 2) == 0) {",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"gen_op_addl_T0_T1_setq();",
"}",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"} else {",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_movl_T1_reg(VAR_1, VAR_9);",
"gen_mulxy(VAR_12 & 2, VAR_12 & 4);",
"if (VAR_5 == 2) {",
"gen_op_signbit_T1_T0();",
"gen_op_addq_T0_T1(VAR_10, VAR_11);",
"gen_movl_reg_T0(VAR_1, VAR_10);",
"gen_movl_reg_T1(VAR_1, VAR_11);",
"} else {",
"if (VAR_5 == 0) {",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"gen_op_addl_T0_T1_setq();",
"}",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"}",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"} else if (((VAR_3 & 0x0e000000) == 0 &&",
"(VAR_3 & 0x00000090) != 0x90) ||\n((VAR_3 & 0x0e000000) == (1 << 25))) {",
"int VAR_13, VAR_14, VAR_15;",
"VAR_5 = (VAR_3 >> 21) & 0xf;",
"VAR_13 = (VAR_3 >> 20) & 1;",
"VAR_14 = table_logic_cc[VAR_5] & VAR_13;",
"if (VAR_3 & (1 << 25)) {",
"VAR_4 = VAR_3 & 0xff;",
"VAR_7 = ((VAR_3 >> 8) & 0xf) * 2;",
"if (VAR_7)\nVAR_4 = (VAR_4 >> VAR_7) | (VAR_4 << (32 - VAR_7));",
"gen_op_movl_T1_im(VAR_4);",
"if (VAR_14 && VAR_7)\ngen_op_mov_CF_T1();",
"} else {",
"VAR_8 = (VAR_3) & 0xf;",
"gen_movl_T1_reg(VAR_1, VAR_8);",
"VAR_15 = (VAR_3 >> 5) & 3;",
"if (!(VAR_3 & (1 << 4))) {",
"VAR_7 = (VAR_3 >> 7) & 0x1f;",
"if (VAR_7 != 0) {",
"if (VAR_14) {",
"gen_shift_T1_im_cc[VAR_15](VAR_7);",
"} else {",
"gen_shift_T1_im[VAR_15](VAR_7);",
"}",
"} else if (VAR_15 != 0) {",
"if (VAR_14) {",
"gen_shift_T1_0_cc[VAR_15]();",
"} else {",
"gen_shift_T1_0[VAR_15]();",
"}",
"}",
"} else {",
"VAR_9 = (VAR_3 >> 8) & 0xf;",
"gen_movl_T0_reg(VAR_1, VAR_9);",
"if (VAR_14) {",
"gen_shift_T1_T0_cc[VAR_15]();",
"} else {",
"gen_shift_T1_T0[VAR_15]();",
"}",
"}",
"}",
"if (VAR_5 != 0x0f && VAR_5 != 0x0d) {",
"VAR_10 = (VAR_3 >> 16) & 0xf;",
"gen_movl_T0_reg(VAR_1, VAR_10);",
"}",
"VAR_11 = (VAR_3 >> 12) & 0xf;",
"switch(VAR_5) {",
"case 0x00:\ngen_op_andl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"if (VAR_14)\ngen_op_logic_T0_cc();",
"break;",
"case 0x01:\ngen_op_xorl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"if (VAR_14)\ngen_op_logic_T0_cc();",
"break;",
"case 0x02:\nif (VAR_13 && VAR_11 == 15) {",
"if (IS_USER(VAR_1))\ngoto illegal_op;",
"gen_op_subl_T0_T1_cc();",
"gen_exception_return(VAR_1);",
"} else {",
"if (VAR_13)\ngen_op_subl_T0_T1_cc();",
"else\ngen_op_subl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"}",
"break;",
"case 0x03:\nif (VAR_13)\ngen_op_rsbl_T0_T1_cc();",
"else\ngen_op_rsbl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"break;",
"case 0x04:\nif (VAR_13)\ngen_op_addl_T0_T1_cc();",
"else\ngen_op_addl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"break;",
"case 0x05:\nif (VAR_13)\ngen_op_adcl_T0_T1_cc();",
"else\ngen_op_adcl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"break;",
"case 0x06:\nif (VAR_13)\ngen_op_sbcl_T0_T1_cc();",
"else\ngen_op_sbcl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"break;",
"case 0x07:\nif (VAR_13)\ngen_op_rscl_T0_T1_cc();",
"else\ngen_op_rscl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"break;",
"case 0x08:\nif (VAR_13) {",
"gen_op_andl_T0_T1();",
"gen_op_logic_T0_cc();",
"}",
"break;",
"case 0x09:\nif (VAR_13) {",
"gen_op_xorl_T0_T1();",
"gen_op_logic_T0_cc();",
"}",
"break;",
"case 0x0a:\nif (VAR_13) {",
"gen_op_subl_T0_T1_cc();",
"}",
"break;",
"case 0x0b:\nif (VAR_13) {",
"gen_op_addl_T0_T1_cc();",
"}",
"break;",
"case 0x0c:\ngen_op_orl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"if (VAR_14)\ngen_op_logic_T0_cc();",
"break;",
"case 0x0d:\nif (VAR_14 && VAR_11 == 15) {",
"if (IS_USER(VAR_1))\ngoto illegal_op;",
"gen_op_movl_T0_T1();",
"gen_exception_return(VAR_1);",
"} else {",
"gen_movl_reg_T1(VAR_1, VAR_11);",
"if (VAR_14)\ngen_op_logic_T1_cc();",
"}",
"break;",
"case 0x0e:\ngen_op_bicl_T0_T1();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"if (VAR_14)\ngen_op_logic_T0_cc();",
"break;",
"default:\ncase 0x0f:\ngen_op_notl_T1();",
"gen_movl_reg_T1(VAR_1, VAR_11);",
"if (VAR_14)\ngen_op_logic_T1_cc();",
"break;",
"}",
"} else {",
"VAR_5 = (VAR_3 >> 24) & 0xf;",
"switch(VAR_5) {",
"case 0x0:\ncase 0x1:\nVAR_12 = (VAR_3 >> 5) & 3;",
"if (VAR_12 == 0) {",
"if (VAR_5 == 0x0) {",
"VAR_11 = (VAR_3 >> 16) & 0xf;",
"VAR_10 = (VAR_3 >> 12) & 0xf;",
"VAR_9 = (VAR_3 >> 8) & 0xf;",
"VAR_8 = (VAR_3) & 0xf;",
"if (((VAR_3 >> 22) & 3) == 0) {",
"gen_movl_T0_reg(VAR_1, VAR_9);",
"gen_movl_T1_reg(VAR_1, VAR_8);",
"gen_op_mul_T0_T1();",
"if (VAR_3 & (1 << 21)) {",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"gen_op_addl_T0_T1();",
"}",
"if (VAR_3 & (1 << 20))\ngen_op_logic_T0_cc();",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"} else {",
"gen_movl_T0_reg(VAR_1, VAR_9);",
"gen_movl_T1_reg(VAR_1, VAR_8);",
"if (VAR_3 & (1 << 22))\ngen_op_imull_T0_T1();",
"else\ngen_op_mull_T0_T1();",
"if (VAR_3 & (1 << 21))\ngen_op_addq_T0_T1(VAR_10, VAR_11);",
"if (!(VAR_3 & (1 << 23))) {",
"ARCH(6);",
"gen_op_addq_lo_T0_T1(VAR_10);",
"gen_op_addq_lo_T0_T1(VAR_11);",
"}",
"if (VAR_3 & (1 << 20))\ngen_op_logicq_cc();",
"gen_movl_reg_T0(VAR_1, VAR_10);",
"gen_movl_reg_T1(VAR_1, VAR_11);",
"}",
"} else {",
"VAR_10 = (VAR_3 >> 16) & 0xf;",
"VAR_11 = (VAR_3 >> 12) & 0xf;",
"if (VAR_3 & (1 << 23)) {",
"goto illegal_op;",
"} else {",
"VAR_8 = (VAR_3) & 0xf;",
"gen_movl_T0_reg(VAR_1, VAR_8);",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"if (VAR_3 & (1 << 22)) {",
"gen_ldst(swpb, VAR_1);",
"} else {",
"gen_ldst(swpl, VAR_1);",
"}",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"}",
"}",
"} else {",
"int VAR_16;",
"VAR_10 = (VAR_3 >> 16) & 0xf;",
"VAR_11 = (VAR_3 >> 12) & 0xf;",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"if (VAR_3 & (1 << 24))\ngen_add_datah_offset(VAR_1, VAR_3, 0);",
"VAR_16 = 0;",
"if (VAR_3 & (1 << 20)) {",
"switch(VAR_12) {",
"case 1:\ngen_ldst(lduw, VAR_1);",
"break;",
"case 2:\ngen_ldst(ldsb, VAR_1);",
"break;",
"default:\ncase 3:\ngen_ldst(ldsw, VAR_1);",
"break;",
"}",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"} else if (VAR_12 & 2) {",
"if (VAR_12 & 1) {",
"gen_movl_T0_reg(VAR_1, VAR_11);",
"gen_ldst(stl, VAR_1);",
"gen_op_addl_T1_im(4);",
"gen_movl_T0_reg(VAR_1, VAR_11 + 1);",
"gen_ldst(stl, VAR_1);",
"} else {",
"gen_ldst(ldl, VAR_1);",
"gen_movl_reg_T0(VAR_1, VAR_11);",
"gen_op_addl_T1_im(4);",
"gen_ldst(ldl, VAR_1);",
"gen_movl_reg_T0(VAR_1, VAR_11 + 1);",
"}",
"VAR_16 = -4;",
"} else {",
"gen_movl_T0_reg(VAR_1, VAR_11);",
"gen_ldst(stw, VAR_1);",
"}",
"if (!(VAR_3 & (1 << 24))) {",
"gen_add_datah_offset(VAR_1, VAR_3, VAR_16);",
"gen_movl_reg_T1(VAR_1, VAR_10);",
"} else if (VAR_3 & (1 << 21)) {",
"if (VAR_16)\ngen_op_addl_T1_im(VAR_16);",
"gen_movl_reg_T1(VAR_1, VAR_10);",
"}",
"}",
"break;",
"case 0x4:\ncase 0x5:\ncase 0x6:\ncase 0x7:\nVAR_12 = (0xf << 20) | (0xf << 4);",
"if (VAR_5 == 0x7 && ((VAR_3 & VAR_12) == VAR_12))\n{",
"goto illegal_op;",
"}",
"VAR_10 = (VAR_3 >> 16) & 0xf;",
"VAR_11 = (VAR_3 >> 12) & 0xf;",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"VAR_6 = (IS_USER(VAR_1) || (VAR_3 & 0x01200000) == 0x00200000);",
"if (VAR_3 & (1 << 24))\ngen_add_data_offset(VAR_1, VAR_3);",
"if (VAR_3 & (1 << 20)) {",
"#if defined(CONFIG_USER_ONLY)\nif (VAR_3 & (1 << 22))\ngen_op_ldub_raw();",
"else\ngen_op_ldl_raw();",
"#else\nif (VAR_3 & (1 << 22)) {",
"if (VAR_6)\ngen_op_ldub_user();",
"else\ngen_op_ldub_kernel();",
"} else {",
"if (VAR_6)\ngen_op_ldl_user();",
"else\ngen_op_ldl_kernel();",
"}",
"#endif\nif (VAR_11 == 15)\ngen_bx(VAR_1);",
"else\ngen_movl_reg_T0(VAR_1, VAR_11);",
"} else {",
"gen_movl_T0_reg(VAR_1, VAR_11);",
"#if defined(CONFIG_USER_ONLY)\nif (VAR_3 & (1 << 22))\ngen_op_stb_raw();",
"else\ngen_op_stl_raw();",
"#else\nif (VAR_3 & (1 << 22)) {",
"if (VAR_6)\ngen_op_stb_user();",
"else\ngen_op_stb_kernel();",
"} else {",
"if (VAR_6)\ngen_op_stl_user();",
"else\ngen_op_stl_kernel();",
"}",
"#endif\n}",
"if (!(VAR_3 & (1 << 24))) {",
"gen_add_data_offset(VAR_1, VAR_3);",
"gen_movl_reg_T1(VAR_1, VAR_10);",
"} else if (VAR_3 & (1 << 21))",
"gen_movl_reg_T1(VAR_1, VAR_10); {",
"}",
"break;",
"case 0x08:\ncase 0x09:\n{",
"int VAR_17, VAR_18, VAR_19, VAR_20;",
"VAR_19 = 0;",
"if (VAR_3 & (1 << 22)) {",
"if (IS_USER(VAR_1))\ngoto illegal_op;",
"if ((VAR_3 & (1 << 15)) == 0)\nVAR_19 = 1;",
"}",
"VAR_10 = (VAR_3 >> 16) & 0xf;",
"gen_movl_T1_reg(VAR_1, VAR_10);",
"VAR_20 = 0;",
"VAR_18 = 0;",
"for(VAR_6=0;VAR_6<16;VAR_6++) {",
"if (VAR_3 & (1 << VAR_6))\nVAR_18++;",
"}",
"if (VAR_3 & (1 << 23)) {",
"if (VAR_3 & (1 << 24)) {",
"gen_op_addl_T1_im(4);",
"} else {",
"}",
"} else {",
"if (VAR_3 & (1 << 24)) {",
"gen_op_addl_T1_im(-(VAR_18 * 4));",
"} else {",
"if (VAR_18 != 1)\ngen_op_addl_T1_im(-((VAR_18 - 1) * 4));",
"}",
"}",
"VAR_17 = 0;",
"for(VAR_6=0;VAR_6<16;VAR_6++) {",
"if (VAR_3 & (1 << VAR_6)) {",
"if (VAR_3 & (1 << 20)) {",
"gen_ldst(ldl, VAR_1);",
"if (VAR_6 == 15) {",
"gen_bx(VAR_1);",
"} else if (VAR_19) {",
"gen_op_movl_user_T0(VAR_6);",
"} else if (VAR_6 == VAR_10) {",
"gen_op_movl_T2_T0();",
"VAR_20 = 1;",
"} else {",
"gen_movl_reg_T0(VAR_1, VAR_6);",
"}",
"} else {",
"if (VAR_6 == 15) {",
"VAR_4 = (long)VAR_1->pc + 8;",
"gen_op_movl_TN_im[0](VAR_4);",
"} else if (VAR_19) {",
"gen_op_movl_T0_user(VAR_6);",
"} else {",
"gen_movl_T0_reg(VAR_1, VAR_6);",
"}",
"gen_ldst(stl, VAR_1);",
"}",
"VAR_17++;",
"if (VAR_17 != VAR_18)\ngen_op_addl_T1_im(4);",
"}",
"}",
"if (VAR_3 & (1 << 21)) {",
"if (VAR_3 & (1 << 23)) {",
"if (VAR_3 & (1 << 24)) {",
"} else {",
"gen_op_addl_T1_im(4);",
"}",
"} else {",
"if (VAR_3 & (1 << 24)) {",
"if (VAR_18 != 1)\ngen_op_addl_T1_im(-((VAR_18 - 1) * 4));",
"} else {",
"gen_op_addl_T1_im(-(VAR_18 * 4));",
"}",
"}",
"gen_movl_reg_T1(VAR_1, VAR_10);",
"}",
"if (VAR_20) {",
"gen_op_movl_T0_T2();",
"gen_movl_reg_T0(VAR_1, VAR_10);",
"}",
"if ((VAR_3 & (1 << 22)) && !VAR_19) {",
"gen_op_movl_T0_spsr();",
"gen_op_movl_cpsr_T0(0xffffffff);",
"VAR_1->is_jmp = DISAS_UPDATE;",
"}",
"}",
"break;",
"case 0xa:\ncase 0xb:\n{",
"int32_t offset;",
"VAR_4 = (int32_t)VAR_1->pc;",
"if (VAR_3 & (1 << 24)) {",
"gen_op_movl_T0_im(VAR_4);",
"gen_op_movl_reg_TN[0][14]();",
"}",
"offset = (((int32_t)VAR_3 << 8) >> 8);",
"VAR_4 += (offset << 2) + 4;",
"gen_jmp(VAR_1, VAR_4);",
"}",
"break;",
"case 0xc:\ncase 0xd:\ncase 0xe:\nVAR_5 = (VAR_3 >> 8) & 0xf;",
"switch (VAR_5) {",
"case 10:\ncase 11:\nif (disas_vfp_insn (VAR_0, VAR_1, VAR_3))\ngoto illegal_op;",
"break;",
"case 15:\nif (disas_cp15_insn (VAR_1, VAR_3))\ngoto illegal_op;",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0xf:\ngen_op_movl_T0_im((long)VAR_1->pc);",
"gen_op_movl_reg_TN[0][15]();",
"gen_op_swi();",
"VAR_1->is_jmp = DISAS_JUMP;",
"break;",
"default:\nillegal_op:\ngen_op_movl_T0_im((long)VAR_1->pc - 4);",
"gen_op_movl_reg_TN[0][15]();",
"gen_op_undef_insn();",
"VAR_1->is_jmp = DISAS_JUMP;",
"break;",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21,
23
],
[
25
],
[
29
],
[
33
],
[
35
],
[
37
],
[
41
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
65
],
[
69
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
95
],
[
97
],
[
99
],
[
105
],
[
107
],
[
109,
111
],
[
115
],
[
117
],
[
119,
121
],
[
123
],
[
125
],
[
127,
129
],
[
131
],
[
133
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145,
147
],
[
151
],
[
153
],
[
155,
157
],
[
159
],
[
163
],
[
165
],
[
167,
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185,
187
],
[
191
],
[
193
],
[
195
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215,
217
],
[
219
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235,
237,
239
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257,
259
],
[
261
],
[
263
],
[
265
],
[
267,
269
],
[
271,
273
],
[
275,
277
],
[
279
],
[
281
],
[
283,
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295,
297,
299,
301,
303
],
[
305
],
[
307
],
[
309
],
[
313
],
[
315
],
[
317,
319
],
[
321,
323
],
[
325
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
371
],
[
373
],
[
375,
377
],
[
379
],
[
381
],
[
383,
385
],
[
387
],
[
391
],
[
393
],
[
395
],
[
401
],
[
405
],
[
407
],
[
409,
411
],
[
413
],
[
415,
417
],
[
419
],
[
423
],
[
425
],
[
427
],
[
429
],
[
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445
],
[
447
],
[
449
],
[
451
],
[
453
],
[
455
],
[
457
],
[
459
],
[
461
],
[
463
],
[
465
],
[
467
],
[
469
],
[
471
],
[
473
],
[
475
],
[
477
],
[
479
],
[
481
],
[
483
],
[
485
],
[
487
],
[
489
],
[
491,
493
],
[
495
],
[
497,
499
],
[
501
],
[
503,
505
],
[
507
],
[
509,
511
],
[
513
],
[
515,
517
],
[
521,
523
],
[
525
],
[
527
],
[
529
],
[
531,
533
],
[
535,
537
],
[
539
],
[
541
],
[
543
],
[
545,
547,
549
],
[
551,
553
],
[
555
],
[
557
],
[
559,
561,
563
],
[
565,
567
],
[
569
],
[
571
],
[
573,
575,
577
],
[
579,
581
],
[
583
],
[
585
],
[
587,
589,
591
],
[
593,
595
],
[
597
],
[
599
],
[
601,
603,
605
],
[
607,
609
],
[
611
],
[
613
],
[
615,
617
],
[
619
],
[
621
],
[
623
],
[
625
],
[
627,
629
],
[
631
],
[
633
],
[
635
],
[
637
],
[
639,
641
],
[
643
],
[
645
],
[
647
],
[
649,
651
],
[
653
],
[
655
],
[
657
],
[
659,
661
],
[
663
],
[
665,
667
],
[
669
],
[
671,
673
],
[
677,
679
],
[
681
],
[
683
],
[
685
],
[
687
],
[
689,
691
],
[
693
],
[
695
],
[
697,
699
],
[
701
],
[
703,
705
],
[
707
],
[
709,
711,
713
],
[
715
],
[
717,
719
],
[
721
],
[
723
],
[
725
],
[
729
],
[
731
],
[
733,
735,
739
],
[
741
],
[
743
],
[
745
],
[
747
],
[
749
],
[
751
],
[
753
],
[
757
],
[
759
],
[
761
],
[
763
],
[
765
],
[
767
],
[
769
],
[
771,
773
],
[
775
],
[
777
],
[
781
],
[
783
],
[
785,
787
],
[
789,
791
],
[
793,
795
],
[
797
],
[
799
],
[
801
],
[
803
],
[
805
],
[
807,
809
],
[
811
],
[
813
],
[
815
],
[
817
],
[
819
],
[
821
],
[
823
],
[
827
],
[
829
],
[
833
],
[
837
],
[
839
],
[
841
],
[
843
],
[
845
],
[
847
],
[
849
],
[
851
],
[
853
],
[
855
],
[
857
],
[
859
],
[
863
],
[
865
],
[
867
],
[
869,
871
],
[
873
],
[
875
],
[
879
],
[
881,
883
],
[
885
],
[
887,
889
],
[
891
],
[
893,
895,
897
],
[
899
],
[
901
],
[
903
],
[
905
],
[
909
],
[
913
],
[
915
],
[
917
],
[
919
],
[
921
],
[
923
],
[
927
],
[
929
],
[
931
],
[
933
],
[
935
],
[
937
],
[
939
],
[
941
],
[
945
],
[
947
],
[
949
],
[
951
],
[
953
],
[
955
],
[
957
],
[
959,
961
],
[
963
],
[
965
],
[
967
],
[
969
],
[
971,
973,
975,
977,
987
],
[
989,
991
],
[
993
],
[
995
],
[
999
],
[
1001
],
[
1003
],
[
1005
],
[
1007,
1009
],
[
1011
],
[
1016,
1018,
1020
],
[
1022,
1024
],
[
1026,
1028
],
[
1030,
1032
],
[
1034,
1036
],
[
1038
],
[
1040,
1042
],
[
1044,
1046
],
[
1048
],
[
1050,
1052,
1054
],
[
1056,
1058
],
[
1060
],
[
1064
],
[
1066,
1068,
1070
],
[
1072,
1074
],
[
1076,
1078
],
[
1080,
1082
],
[
1084,
1086
],
[
1088
],
[
1090,
1092
],
[
1094,
1096
],
[
1098
],
[
1100,
1102
],
[
1104
],
[
1106
],
[
1108
],
[
1110
],
[
1112
],
[
1114
],
[
1116
],
[
1118,
1120,
1122
],
[
1124
],
[
1130
],
[
1132
],
[
1134,
1136
],
[
1140,
1142
],
[
1144
],
[
1146
],
[
1148
],
[
1154
],
[
1156
],
[
1158
],
[
1160,
1162
],
[
1164
],
[
1168
],
[
1170
],
[
1174
],
[
1176
],
[
1180
],
[
1182
],
[
1184
],
[
1188
],
[
1190
],
[
1194,
1196
],
[
1198
],
[
1200
],
[
1202
],
[
1204
],
[
1206
],
[
1208
],
[
1212
],
[
1214
],
[
1216
],
[
1218
],
[
1220
],
[
1222
],
[
1224
],
[
1226
],
[
1228
],
[
1230
],
[
1232
],
[
1234
],
[
1238
],
[
1242
],
[
1244
],
[
1246
],
[
1248
],
[
1250
],
[
1252
],
[
1254
],
[
1256
],
[
1258
],
[
1260
],
[
1264,
1266
],
[
1268
],
[
1270
],
[
1272
],
[
1276
],
[
1278
],
[
1282
],
[
1286
],
[
1288
],
[
1290
],
[
1292
],
[
1296,
1298
],
[
1300
],
[
1304
],
[
1306
],
[
1308
],
[
1310
],
[
1312
],
[
1314
],
[
1316
],
[
1318
],
[
1320
],
[
1322
],
[
1326
],
[
1328
],
[
1330
],
[
1332
],
[
1334
],
[
1336
],
[
1338,
1340,
1342
],
[
1344
],
[
1350
],
[
1352
],
[
1354
],
[
1356
],
[
1358
],
[
1360
],
[
1362
],
[
1364
],
[
1366
],
[
1368
],
[
1370,
1372,
1374,
1378
],
[
1380
],
[
1382,
1384,
1386,
1388
],
[
1390
],
[
1392,
1394,
1396
],
[
1398
],
[
1400,
1404
],
[
1406
],
[
1408
],
[
1410,
1414
],
[
1416
],
[
1418
],
[
1420
],
[
1422
],
[
1424,
1426,
1428
],
[
1430
],
[
1432
],
[
1434
],
[
1436
],
[
1438
],
[
1440
],
[
1442
]
] |
6,993 |
static void print_block_info(Monitor *mon, BlockInfo *info,
BlockDeviceInfo *inserted, bool verbose)
{
ImageInfo *image_info;
assert(!info || !info->has_inserted || info->inserted == inserted);
if (info) {
monitor_printf(mon, "%s", info->device);
if (inserted && inserted->has_node_name) {
monitor_printf(mon, " (%s)", inserted->node_name);
}
} else {
assert(inserted);
monitor_printf(mon, "%s",
inserted->has_node_name
? inserted->node_name
: "<anonymous>");
}
if (inserted) {
monitor_printf(mon, ": %s (%s%s%s)\n",
inserted->file,
inserted->drv,
inserted->ro ? ", read-only" : "",
inserted->encrypted ? ", encrypted" : "");
} else {
monitor_printf(mon, ": [not inserted]\n");
}
if (info) {
if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
monitor_printf(mon, " I/O status: %s\n",
BlockDeviceIoStatus_lookup[info->io_status]);
}
if (info->removable) {
monitor_printf(mon, " Removable device: %slocked, tray %s\n",
info->locked ? "" : "not ",
info->tray_open ? "open" : "closed");
}
}
if (!inserted) {
return;
}
monitor_printf(mon, " Cache mode: %s%s%s\n",
inserted->cache->writeback ? "writeback" : "writethrough",
inserted->cache->direct ? ", direct" : "",
inserted->cache->no_flush ? ", ignore flushes" : "");
if (inserted->has_backing_file) {
monitor_printf(mon,
" Backing file: %s "
"(chain depth: %" PRId64 ")\n",
inserted->backing_file,
inserted->backing_file_depth);
}
if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
monitor_printf(mon, " Detect zeroes: %s\n",
BlockdevDetectZeroesOptions_lookup[inserted->detect_zeroes]);
}
if (inserted->bps || inserted->bps_rd || inserted->bps_wr ||
inserted->iops || inserted->iops_rd || inserted->iops_wr)
{
monitor_printf(mon, " I/O throttling: bps=%" PRId64
" bps_rd=%" PRId64 " bps_wr=%" PRId64
" bps_max=%" PRId64
" bps_rd_max=%" PRId64
" bps_wr_max=%" PRId64
" iops=%" PRId64 " iops_rd=%" PRId64
" iops_wr=%" PRId64
" iops_max=%" PRId64
" iops_rd_max=%" PRId64
" iops_wr_max=%" PRId64
" iops_size=%" PRId64 "\n",
inserted->bps,
inserted->bps_rd,
inserted->bps_wr,
inserted->bps_max,
inserted->bps_rd_max,
inserted->bps_wr_max,
inserted->iops,
inserted->iops_rd,
inserted->iops_wr,
inserted->iops_max,
inserted->iops_rd_max,
inserted->iops_wr_max,
inserted->iops_size);
}
/* TODO: inserted->image should never be null */
if (verbose && inserted->image) {
monitor_printf(mon, "\nImages:\n");
image_info = inserted->image;
while (1) {
bdrv_image_info_dump((fprintf_function)monitor_printf,
mon, image_info);
if (image_info->has_backing_image) {
image_info = image_info->backing_image;
} else {
break;
}
}
}
}
| true |
qemu
|
9419874f709469de16c1bced7731bfecb07fe1cf
|
static void print_block_info(Monitor *mon, BlockInfo *info,
BlockDeviceInfo *inserted, bool verbose)
{
ImageInfo *image_info;
assert(!info || !info->has_inserted || info->inserted == inserted);
if (info) {
monitor_printf(mon, "%s", info->device);
if (inserted && inserted->has_node_name) {
monitor_printf(mon, " (%s)", inserted->node_name);
}
} else {
assert(inserted);
monitor_printf(mon, "%s",
inserted->has_node_name
? inserted->node_name
: "<anonymous>");
}
if (inserted) {
monitor_printf(mon, ": %s (%s%s%s)\n",
inserted->file,
inserted->drv,
inserted->ro ? ", read-only" : "",
inserted->encrypted ? ", encrypted" : "");
} else {
monitor_printf(mon, ": [not inserted]\n");
}
if (info) {
if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
monitor_printf(mon, " I/O status: %s\n",
BlockDeviceIoStatus_lookup[info->io_status]);
}
if (info->removable) {
monitor_printf(mon, " Removable device: %slocked, tray %s\n",
info->locked ? "" : "not ",
info->tray_open ? "open" : "closed");
}
}
if (!inserted) {
return;
}
monitor_printf(mon, " Cache mode: %s%s%s\n",
inserted->cache->writeback ? "writeback" : "writethrough",
inserted->cache->direct ? ", direct" : "",
inserted->cache->no_flush ? ", ignore flushes" : "");
if (inserted->has_backing_file) {
monitor_printf(mon,
" Backing file: %s "
"(chain depth: %" PRId64 ")\n",
inserted->backing_file,
inserted->backing_file_depth);
}
if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
monitor_printf(mon, " Detect zeroes: %s\n",
BlockdevDetectZeroesOptions_lookup[inserted->detect_zeroes]);
}
if (inserted->bps || inserted->bps_rd || inserted->bps_wr ||
inserted->iops || inserted->iops_rd || inserted->iops_wr)
{
monitor_printf(mon, " I/O throttling: bps=%" PRId64
" bps_rd=%" PRId64 " bps_wr=%" PRId64
" bps_max=%" PRId64
" bps_rd_max=%" PRId64
" bps_wr_max=%" PRId64
" iops=%" PRId64 " iops_rd=%" PRId64
" iops_wr=%" PRId64
" iops_max=%" PRId64
" iops_rd_max=%" PRId64
" iops_wr_max=%" PRId64
" iops_size=%" PRId64 "\n",
inserted->bps,
inserted->bps_rd,
inserted->bps_wr,
inserted->bps_max,
inserted->bps_rd_max,
inserted->bps_wr_max,
inserted->iops,
inserted->iops_rd,
inserted->iops_wr,
inserted->iops_max,
inserted->iops_rd_max,
inserted->iops_wr_max,
inserted->iops_size);
}
if (verbose && inserted->image) {
monitor_printf(mon, "\nImages:\n");
image_info = inserted->image;
while (1) {
bdrv_image_info_dump((fprintf_function)monitor_printf,
mon, image_info);
if (image_info->has_backing_image) {
image_info = image_info->backing_image;
} else {
break;
}
}
}
}
|
{
"code": [
" if (verbose && inserted->image) {"
],
"line_no": [
193
]
}
|
static void FUNC_0(Monitor *VAR_0, BlockInfo *VAR_1,
BlockDeviceInfo *VAR_2, bool VAR_3)
{
ImageInfo *image_info;
assert(!VAR_1 || !VAR_1->has_inserted || VAR_1->VAR_2 == VAR_2);
if (VAR_1) {
monitor_printf(VAR_0, "%s", VAR_1->device);
if (VAR_2 && VAR_2->has_node_name) {
monitor_printf(VAR_0, " (%s)", VAR_2->node_name);
}
} else {
assert(VAR_2);
monitor_printf(VAR_0, "%s",
VAR_2->has_node_name
? VAR_2->node_name
: "<anonymous>");
}
if (VAR_2) {
monitor_printf(VAR_0, ": %s (%s%s%s)\n",
VAR_2->file,
VAR_2->drv,
VAR_2->ro ? ", read-only" : "",
VAR_2->encrypted ? ", encrypted" : "");
} else {
monitor_printf(VAR_0, ": [not VAR_2]\n");
}
if (VAR_1) {
if (VAR_1->has_io_status && VAR_1->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
monitor_printf(VAR_0, " I/O status: %s\n",
BlockDeviceIoStatus_lookup[VAR_1->io_status]);
}
if (VAR_1->removable) {
monitor_printf(VAR_0, " Removable device: %slocked, tray %s\n",
VAR_1->locked ? "" : "not ",
VAR_1->tray_open ? "open" : "closed");
}
}
if (!VAR_2) {
return;
}
monitor_printf(VAR_0, " Cache mode: %s%s%s\n",
VAR_2->cache->writeback ? "writeback" : "writethrough",
VAR_2->cache->direct ? ", direct" : "",
VAR_2->cache->no_flush ? ", ignore flushes" : "");
if (VAR_2->has_backing_file) {
monitor_printf(VAR_0,
" Backing file: %s "
"(chain depth: %" PRId64 ")\n",
VAR_2->backing_file,
VAR_2->backing_file_depth);
}
if (VAR_2->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
monitor_printf(VAR_0, " Detect zeroes: %s\n",
BlockdevDetectZeroesOptions_lookup[VAR_2->detect_zeroes]);
}
if (VAR_2->bps || VAR_2->bps_rd || VAR_2->bps_wr ||
VAR_2->iops || VAR_2->iops_rd || VAR_2->iops_wr)
{
monitor_printf(VAR_0, " I/O throttling: bps=%" PRId64
" bps_rd=%" PRId64 " bps_wr=%" PRId64
" bps_max=%" PRId64
" bps_rd_max=%" PRId64
" bps_wr_max=%" PRId64
" iops=%" PRId64 " iops_rd=%" PRId64
" iops_wr=%" PRId64
" iops_max=%" PRId64
" iops_rd_max=%" PRId64
" iops_wr_max=%" PRId64
" iops_size=%" PRId64 "\n",
VAR_2->bps,
VAR_2->bps_rd,
VAR_2->bps_wr,
VAR_2->bps_max,
VAR_2->bps_rd_max,
VAR_2->bps_wr_max,
VAR_2->iops,
VAR_2->iops_rd,
VAR_2->iops_wr,
VAR_2->iops_max,
VAR_2->iops_rd_max,
VAR_2->iops_wr_max,
VAR_2->iops_size);
}
if (VAR_3 && VAR_2->image) {
monitor_printf(VAR_0, "\nImages:\n");
image_info = VAR_2->image;
while (1) {
bdrv_image_info_dump((fprintf_function)monitor_printf,
VAR_0, image_info);
if (image_info->has_backing_image) {
image_info = image_info->backing_image;
} else {
break;
}
}
}
}
|
[
"static void FUNC_0(Monitor *VAR_0, BlockInfo *VAR_1,\nBlockDeviceInfo *VAR_2, bool VAR_3)\n{",
"ImageInfo *image_info;",
"assert(!VAR_1 || !VAR_1->has_inserted || VAR_1->VAR_2 == VAR_2);",
"if (VAR_1) {",
"monitor_printf(VAR_0, \"%s\", VAR_1->device);",
"if (VAR_2 && VAR_2->has_node_name) {",
"monitor_printf(VAR_0, \" (%s)\", VAR_2->node_name);",
"}",
"} else {",
"assert(VAR_2);",
"monitor_printf(VAR_0, \"%s\",\nVAR_2->has_node_name\n? VAR_2->node_name\n: \"<anonymous>\");",
"}",
"if (VAR_2) {",
"monitor_printf(VAR_0, \": %s (%s%s%s)\\n\",\nVAR_2->file,\nVAR_2->drv,\nVAR_2->ro ? \", read-only\" : \"\",\nVAR_2->encrypted ? \", encrypted\" : \"\");",
"} else {",
"monitor_printf(VAR_0, \": [not VAR_2]\\n\");",
"}",
"if (VAR_1) {",
"if (VAR_1->has_io_status && VAR_1->io_status != BLOCK_DEVICE_IO_STATUS_OK) {",
"monitor_printf(VAR_0, \" I/O status: %s\\n\",\nBlockDeviceIoStatus_lookup[VAR_1->io_status]);",
"}",
"if (VAR_1->removable) {",
"monitor_printf(VAR_0, \" Removable device: %slocked, tray %s\\n\",\nVAR_1->locked ? \"\" : \"not \",\nVAR_1->tray_open ? \"open\" : \"closed\");",
"}",
"}",
"if (!VAR_2) {",
"return;",
"}",
"monitor_printf(VAR_0, \" Cache mode: %s%s%s\\n\",\nVAR_2->cache->writeback ? \"writeback\" : \"writethrough\",\nVAR_2->cache->direct ? \", direct\" : \"\",\nVAR_2->cache->no_flush ? \", ignore flushes\" : \"\");",
"if (VAR_2->has_backing_file) {",
"monitor_printf(VAR_0,\n\" Backing file: %s \"\n\"(chain depth: %\" PRId64 \")\\n\",\nVAR_2->backing_file,\nVAR_2->backing_file_depth);",
"}",
"if (VAR_2->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {",
"monitor_printf(VAR_0, \" Detect zeroes: %s\\n\",\nBlockdevDetectZeroesOptions_lookup[VAR_2->detect_zeroes]);",
"}",
"if (VAR_2->bps || VAR_2->bps_rd || VAR_2->bps_wr ||\nVAR_2->iops || VAR_2->iops_rd || VAR_2->iops_wr)\n{",
"monitor_printf(VAR_0, \" I/O throttling: bps=%\" PRId64\n\" bps_rd=%\" PRId64 \" bps_wr=%\" PRId64\n\" bps_max=%\" PRId64\n\" bps_rd_max=%\" PRId64\n\" bps_wr_max=%\" PRId64\n\" iops=%\" PRId64 \" iops_rd=%\" PRId64\n\" iops_wr=%\" PRId64\n\" iops_max=%\" PRId64\n\" iops_rd_max=%\" PRId64\n\" iops_wr_max=%\" PRId64\n\" iops_size=%\" PRId64 \"\\n\",\nVAR_2->bps,\nVAR_2->bps_rd,\nVAR_2->bps_wr,\nVAR_2->bps_max,\nVAR_2->bps_rd_max,\nVAR_2->bps_wr_max,\nVAR_2->iops,\nVAR_2->iops_rd,\nVAR_2->iops_wr,\nVAR_2->iops_max,\nVAR_2->iops_rd_max,\nVAR_2->iops_wr_max,\nVAR_2->iops_size);",
"}",
"if (VAR_3 && VAR_2->image) {",
"monitor_printf(VAR_0, \"\\nImages:\\n\");",
"image_info = VAR_2->image;",
"while (1) {",
"bdrv_image_info_dump((fprintf_function)monitor_printf,\nVAR_0, image_info);",
"if (image_info->has_backing_image) {",
"image_info = image_info->backing_image;",
"} else {",
"break;",
"}",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29,
31,
33,
35
],
[
37
],
[
41
],
[
43,
45,
47,
49,
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65,
67
],
[
69
],
[
73
],
[
75,
77,
79
],
[
81
],
[
83
],
[
89
],
[
91
],
[
93
],
[
97,
99,
101,
103
],
[
107
],
[
109,
111,
113,
115,
117
],
[
119
],
[
123
],
[
125,
127
],
[
129
],
[
133,
135,
137
],
[
139,
141,
143,
145,
147,
149,
151,
153,
155,
157,
159,
161,
163,
165,
167,
169,
171,
173,
175,
177,
179,
181,
183,
185
],
[
187
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201,
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
]
] |
6,994 |
int qemu_bh_poll(void)
{
QEMUBH *bh, **pbh;
int ret;
ret = 0;
for(;;) {
pbh = &first_bh;
bh = *pbh;
if (!bh)
break;
ret = 1;
*pbh = bh->next;
bh->scheduled = 0;
bh->cb(bh->opaque);
}
return ret;
}
| true |
qemu
|
1b435b10324fe9937f254bb00718f78d5e50837a
|
int qemu_bh_poll(void)
{
QEMUBH *bh, **pbh;
int ret;
ret = 0;
for(;;) {
pbh = &first_bh;
bh = *pbh;
if (!bh)
break;
ret = 1;
*pbh = bh->next;
bh->scheduled = 0;
bh->cb(bh->opaque);
}
return ret;
}
|
{
"code": [
" QEMUBH *bh, **pbh;",
" for(;;) {",
" pbh = &first_bh;",
" bh = *pbh;",
" if (!bh)",
" break;",
" ret = 1;",
" *pbh = bh->next;",
" bh->scheduled = 0;",
" bh->cb(bh->opaque);",
" pbh = &first_bh;",
" *pbh = bh->next;",
" bh->scheduled = 0;"
],
"line_no": [
5,
13,
15,
17,
19,
21,
23,
25,
27,
29,
15,
25,
27
]
}
|
int FUNC_0(void)
{
QEMUBH *bh, **pbh;
int VAR_0;
VAR_0 = 0;
for(;;) {
pbh = &first_bh;
bh = *pbh;
if (!bh)
break;
VAR_0 = 1;
*pbh = bh->next;
bh->scheduled = 0;
bh->cb(bh->opaque);
}
return VAR_0;
}
|
[
"int FUNC_0(void)\n{",
"QEMUBH *bh, **pbh;",
"int VAR_0;",
"VAR_0 = 0;",
"for(;;) {",
"pbh = &first_bh;",
"bh = *pbh;",
"if (!bh)\nbreak;",
"VAR_0 = 1;",
"*pbh = bh->next;",
"bh->scheduled = 0;",
"bh->cb(bh->opaque);",
"}",
"return VAR_0;",
"}"
] |
[
0,
1,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
6,995 |
static int qemu_rdma_write(QEMUFile *f, RDMAContext *rdma,
uint64_t block_offset, uint64_t offset,
uint64_t len)
{
uint64_t current_addr = block_offset + offset;
uint64_t index = rdma->current_index;
uint64_t chunk = rdma->current_chunk;
int ret;
/* If we cannot merge it, we flush the current buffer first. */
if (!qemu_rdma_buffer_mergable(rdma, current_addr, len)) {
ret = qemu_rdma_write_flush(f, rdma);
if (ret) {
return ret;
}
rdma->current_length = 0;
rdma->current_addr = current_addr;
ret = qemu_rdma_search_ram_block(rdma, block_offset,
offset, len, &index, &chunk);
if (ret) {
fprintf(stderr, "ram block search failed\n");
return ret;
}
rdma->current_index = index;
rdma->current_chunk = chunk;
}
/* merge it */
rdma->current_length += len;
/* flush it if buffer is too large */
if (rdma->current_length >= RDMA_MERGE_MAX) {
return qemu_rdma_write_flush(f, rdma);
}
return 0;
}
| true |
qemu
|
60fe637bf0e4d7989e21e50f52526444765c63b4
|
static int qemu_rdma_write(QEMUFile *f, RDMAContext *rdma,
uint64_t block_offset, uint64_t offset,
uint64_t len)
{
uint64_t current_addr = block_offset + offset;
uint64_t index = rdma->current_index;
uint64_t chunk = rdma->current_chunk;
int ret;
if (!qemu_rdma_buffer_mergable(rdma, current_addr, len)) {
ret = qemu_rdma_write_flush(f, rdma);
if (ret) {
return ret;
}
rdma->current_length = 0;
rdma->current_addr = current_addr;
ret = qemu_rdma_search_ram_block(rdma, block_offset,
offset, len, &index, &chunk);
if (ret) {
fprintf(stderr, "ram block search failed\n");
return ret;
}
rdma->current_index = index;
rdma->current_chunk = chunk;
}
rdma->current_length += len;
if (rdma->current_length >= RDMA_MERGE_MAX) {
return qemu_rdma_write_flush(f, rdma);
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(QEMUFile *VAR_0, RDMAContext *VAR_1,
uint64_t VAR_2, uint64_t VAR_3,
uint64_t VAR_4)
{
uint64_t current_addr = VAR_2 + VAR_3;
uint64_t index = VAR_1->current_index;
uint64_t chunk = VAR_1->current_chunk;
int VAR_5;
if (!qemu_rdma_buffer_mergable(VAR_1, current_addr, VAR_4)) {
VAR_5 = qemu_rdma_write_flush(VAR_0, VAR_1);
if (VAR_5) {
return VAR_5;
}
VAR_1->current_length = 0;
VAR_1->current_addr = current_addr;
VAR_5 = qemu_rdma_search_ram_block(VAR_1, VAR_2,
VAR_3, VAR_4, &index, &chunk);
if (VAR_5) {
fprintf(stderr, "ram block search failed\n");
return VAR_5;
}
VAR_1->current_index = index;
VAR_1->current_chunk = chunk;
}
VAR_1->current_length += VAR_4;
if (VAR_1->current_length >= RDMA_MERGE_MAX) {
return qemu_rdma_write_flush(VAR_0, VAR_1);
}
return 0;
}
|
[
"static int FUNC_0(QEMUFile *VAR_0, RDMAContext *VAR_1,\nuint64_t VAR_2, uint64_t VAR_3,\nuint64_t VAR_4)\n{",
"uint64_t current_addr = VAR_2 + VAR_3;",
"uint64_t index = VAR_1->current_index;",
"uint64_t chunk = VAR_1->current_chunk;",
"int VAR_5;",
"if (!qemu_rdma_buffer_mergable(VAR_1, current_addr, VAR_4)) {",
"VAR_5 = qemu_rdma_write_flush(VAR_0, VAR_1);",
"if (VAR_5) {",
"return VAR_5;",
"}",
"VAR_1->current_length = 0;",
"VAR_1->current_addr = current_addr;",
"VAR_5 = qemu_rdma_search_ram_block(VAR_1, VAR_2,\nVAR_3, VAR_4, &index, &chunk);",
"if (VAR_5) {",
"fprintf(stderr, \"ram block search failed\\n\");",
"return VAR_5;",
"}",
"VAR_1->current_index = index;",
"VAR_1->current_chunk = chunk;",
"}",
"VAR_1->current_length += VAR_4;",
"if (VAR_1->current_length >= RDMA_MERGE_MAX) {",
"return qemu_rdma_write_flush(VAR_0, VAR_1);",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
59
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
]
] |
6,996 |
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
int pitch)
{
uint32_t bit_cache;
uint8_t *list[63];
uint32_t *dst;
const uint32_t *codebook;
int entries[6];
int i, j, m, n;
int mean, stages;
int x, y, width, height, level;
uint32_t n1, n2, n3, n4;
/* initialize list for breadth first processing of vectors */
list[0] = pixels;
/* recursively process vector */
for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
SVQ1_PROCESS_VECTOR();
/* destination address and vector size */
dst = (uint32_t *)list[i];
width = 1 << ((4 + level) / 2);
height = 1 << ((3 + level) / 2);
/* get number of stages (-1 skips vector, 0 for mean only) */
stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
if (stages == -1)
continue; /* skip vector */
if ((stages > 0) && (level >= 4)) {
av_dlog(NULL,
"Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
stages, level);
return AVERROR_INVALIDDATA; /* invalid vector */
}
mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
for (y = 0; y < height; y++) {
for (x = 0; x < width / 4; x++, codebook++) {
n3 = dst[x];
/* add mean value to vector */
n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
n2 = n4 + (n3 & 0x00FF00FF);
SVQ1_ADD_CODEBOOK()
/* store result */
dst[x] = n1 << 8 | n2;
}
dst += pitch / 4;
}
}
return 0;
}
| false |
FFmpeg
|
9b8c8a9395c849639aea0f6b5300e991e93c3a73
|
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
int pitch)
{
uint32_t bit_cache;
uint8_t *list[63];
uint32_t *dst;
const uint32_t *codebook;
int entries[6];
int i, j, m, n;
int mean, stages;
int x, y, width, height, level;
uint32_t n1, n2, n3, n4;
list[0] = pixels;
for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
SVQ1_PROCESS_VECTOR();
dst = (uint32_t *)list[i];
width = 1 << ((4 + level) / 2);
height = 1 << ((3 + level) / 2);
stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
if (stages == -1)
continue;
if ((stages > 0) && (level >= 4)) {
av_dlog(NULL,
"Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
stages, level);
return AVERROR_INVALIDDATA;
}
mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
for (y = 0; y < height; y++) {
for (x = 0; x < width / 4; x++, codebook++) {
n3 = dst[x];
n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
n2 = n4 + (n3 & 0x00FF00FF);
SVQ1_ADD_CODEBOOK()
dst[x] = n1 << 8 | n2;
}
dst += pitch / 4;
}
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(GetBitContext *VAR_0, uint8_t *VAR_1,
int VAR_2)
{
uint32_t bit_cache;
uint8_t *list[63];
uint32_t *dst;
const uint32_t *VAR_3;
int VAR_4[6];
int VAR_5, VAR_6, VAR_7, VAR_8;
int VAR_9, VAR_10;
int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15;
uint32_t n1, n2, n3, n4;
list[0] = VAR_1;
for (VAR_5 = 0, VAR_7 = 1, VAR_8 = 1, VAR_15 = 5; VAR_5 < VAR_8; VAR_5++) {
SVQ1_PROCESS_VECTOR();
dst = (uint32_t *)list[VAR_5];
VAR_13 = 1 << ((4 + VAR_15) / 2);
VAR_14 = 1 << ((3 + VAR_15) / 2);
VAR_10 = get_vlc2(VAR_0, svq1_inter_multistage[VAR_15].table, 3, 2) - 1;
if (VAR_10 == -1)
continue;
if ((VAR_10 > 0) && (VAR_15 >= 4)) {
av_dlog(NULL,
"Error (FUNC_0): invalid vector: VAR_10=%VAR_5 VAR_15=%VAR_5\VAR_8",
VAR_10, VAR_15);
return AVERROR_INVALIDDATA;
}
VAR_9 = get_vlc2(VAR_0, svq1_inter_mean.table, 9, 3) - 256;
SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
for (VAR_12 = 0; VAR_12 < VAR_14; VAR_12++) {
for (VAR_11 = 0; VAR_11 < VAR_13 / 4; VAR_11++, VAR_3++) {
n3 = dst[VAR_11];
n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
n2 = n4 + (n3 & 0x00FF00FF);
SVQ1_ADD_CODEBOOK()
dst[VAR_11] = n1 << 8 | n2;
}
dst += VAR_2 / 4;
}
}
return 0;
}
|
[
"static int FUNC_0(GetBitContext *VAR_0, uint8_t *VAR_1,\nint VAR_2)\n{",
"uint32_t bit_cache;",
"uint8_t *list[63];",
"uint32_t *dst;",
"const uint32_t *VAR_3;",
"int VAR_4[6];",
"int VAR_5, VAR_6, VAR_7, VAR_8;",
"int VAR_9, VAR_10;",
"int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15;",
"uint32_t n1, n2, n3, n4;",
"list[0] = VAR_1;",
"for (VAR_5 = 0, VAR_7 = 1, VAR_8 = 1, VAR_15 = 5; VAR_5 < VAR_8; VAR_5++) {",
"SVQ1_PROCESS_VECTOR();",
"dst = (uint32_t *)list[VAR_5];",
"VAR_13 = 1 << ((4 + VAR_15) / 2);",
"VAR_14 = 1 << ((3 + VAR_15) / 2);",
"VAR_10 = get_vlc2(VAR_0, svq1_inter_multistage[VAR_15].table, 3, 2) - 1;",
"if (VAR_10 == -1)\ncontinue;",
"if ((VAR_10 > 0) && (VAR_15 >= 4)) {",
"av_dlog(NULL,\n\"Error (FUNC_0): invalid vector: VAR_10=%VAR_5 VAR_15=%VAR_5\\VAR_8\",\nVAR_10, VAR_15);",
"return AVERROR_INVALIDDATA;",
"}",
"VAR_9 = get_vlc2(VAR_0, svq1_inter_mean.table, 9, 3) - 256;",
"SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);",
"for (VAR_12 = 0; VAR_12 < VAR_14; VAR_12++) {",
"for (VAR_11 = 0; VAR_11 < VAR_13 / 4; VAR_11++, VAR_3++) {",
"n3 = dst[VAR_11];",
"n1 = n4 + ((n3 & 0xFF00FF00) >> 8);",
"n2 = n4 + (n3 & 0x00FF00FF);",
"SVQ1_ADD_CODEBOOK()\ndst[VAR_11] = n1 << 8 | n2;",
"}",
"dst += VAR_2 / 4;",
"}",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
29
],
[
35
],
[
37
],
[
43
],
[
45
],
[
47
],
[
53
],
[
57,
59
],
[
63
],
[
65,
67,
69
],
[
71
],
[
73
],
[
77
],
[
81
],
[
85
],
[
87
],
[
89
],
[
93
],
[
95
],
[
97,
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
]
] |
6,998 |
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
AC3DecodeContext *s = avctx->priv_data;
int blk, ch, err, ret;
const uint8_t *channel_map;
const float *output[AC3_MAX_CHANNELS];
/* copy input buffer to decoder context to avoid reading past the end
of the buffer, which can be caused by a damaged input stream. */
if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
// seems to be byte-swapped AC-3
int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
} else
memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
buf = s->input_buffer;
/* initialize the GetBitContext with the start of valid AC-3 Frame */
init_get_bits(&s->gbc, buf, buf_size * 8);
/* parse the syncinfo */
err = parse_frame_header(s);
if (err) {
switch (err) {
case AAC_AC3_PARSE_ERROR_SYNC:
av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
return -1;
case AAC_AC3_PARSE_ERROR_BSID:
av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
break;
case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
break;
case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
break;
case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
/* skip frame if CRC is ok. otherwise use error concealment. */
/* TODO: add support for substreams and dependent frames */
if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
"skipping frame\n");
*got_frame_ptr = 0;
return s->frame_size;
} else {
av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
}
break;
default:
av_log(avctx, AV_LOG_ERROR, "invalid header\n");
break;
}
} else {
/* check that reported frame size fits in input buffer */
if (s->frame_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
} else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
/* check for crc mismatch */
if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
s->frame_size - 2)) {
av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
err = AAC_AC3_PARSE_ERROR_CRC;
}
}
}
/* if frame is ok, set audio parameters */
if (!err) {
avctx->sample_rate = s->sample_rate;
avctx->bit_rate = s->bit_rate;
/* channel config */
s->out_channels = s->channels;
s->output_mode = s->channel_mode;
if (s->lfe_on)
s->output_mode |= AC3_OUTPUT_LFEON;
if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
avctx->request_channels < s->channels) {
s->out_channels = avctx->request_channels;
s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
}
avctx->channels = s->out_channels;
avctx->channel_layout = s->channel_layout;
s->loro_center_mix_level = gain_levels[s-> center_mix_level];
s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
/* set downmixing coefficients if needed */
if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
s->fbw_channels == s->out_channels)) {
set_downmix_coeffs(s);
}
} else if (!s->out_channels) {
s->out_channels = avctx->channels;
if (s->out_channels < s->channels)
s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
}
if (avctx->channels != s->out_channels) {
av_log(avctx, AV_LOG_ERROR, "channel number mismatching on damaged frame\n");
return AVERROR_INVALIDDATA;
}
/* set audio service type based on bitstream mode for AC-3 */
avctx->audio_service_type = s->bitstream_mode;
if (s->bitstream_mode == 0x7 && s->channels > 1)
avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
/* get output buffer */
avctx->channels = s->out_channels;
s->frame.nb_samples = s->num_blocks * 256;
if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
/* decode the audio blocks */
channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
output[ch] = s->output[ch];
s->outptr[ch] = s->output[ch];
}
for (ch = 0; ch < s->channels; ch++) {
if (ch < s->out_channels)
s->outptr[channel_map[ch]] = (float *)s->frame.data[ch];
}
for (blk = 0; blk < s->num_blocks; blk++) {
if (!err && decode_audio_block(s, blk)) {
av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
err = 1;
}
if (err)
for (ch = 0; ch < s->out_channels; ch++)
memcpy(((float*)s->frame.data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], 1024);
for (ch = 0; ch < s->out_channels; ch++) {
output[ch] = s->outptr[channel_map[ch]];
if (!ch || channel_map[ch])
s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
}
}
s->frame.decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
/* keep last block for error concealment in next frame */
for (ch = 0; ch < s->out_channels; ch++)
memcpy(s->output[ch], output[ch], 1024);
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
return FFMIN(buf_size, s->frame_size);
}
| false |
FFmpeg
|
b888cea9cb2a01276ce026a5abe90ad57e042444
|
static int ac3_decode_frame(AVCodecContext * avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
AC3DecodeContext *s = avctx->priv_data;
int blk, ch, err, ret;
const uint8_t *channel_map;
const float *output[AC3_MAX_CHANNELS];
if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
} else
memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
buf = s->input_buffer;
init_get_bits(&s->gbc, buf, buf_size * 8);
err = parse_frame_header(s);
if (err) {
switch (err) {
case AAC_AC3_PARSE_ERROR_SYNC:
av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
return -1;
case AAC_AC3_PARSE_ERROR_BSID:
av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
break;
case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
break;
case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
break;
case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
"skipping frame\n");
*got_frame_ptr = 0;
return s->frame_size;
} else {
av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
}
break;
default:
av_log(avctx, AV_LOG_ERROR, "invalid header\n");
break;
}
} else {
if (s->frame_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
} else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
s->frame_size - 2)) {
av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
err = AAC_AC3_PARSE_ERROR_CRC;
}
}
}
if (!err) {
avctx->sample_rate = s->sample_rate;
avctx->bit_rate = s->bit_rate;
s->out_channels = s->channels;
s->output_mode = s->channel_mode;
if (s->lfe_on)
s->output_mode |= AC3_OUTPUT_LFEON;
if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
avctx->request_channels < s->channels) {
s->out_channels = avctx->request_channels;
s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
}
avctx->channels = s->out_channels;
avctx->channel_layout = s->channel_layout;
s->loro_center_mix_level = gain_levels[s-> center_mix_level];
s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
s->fbw_channels == s->out_channels)) {
set_downmix_coeffs(s);
}
} else if (!s->out_channels) {
s->out_channels = avctx->channels;
if (s->out_channels < s->channels)
s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
}
if (avctx->channels != s->out_channels) {
av_log(avctx, AV_LOG_ERROR, "channel number mismatching on damaged frame\n");
return AVERROR_INVALIDDATA;
}
avctx->audio_service_type = s->bitstream_mode;
if (s->bitstream_mode == 0x7 && s->channels > 1)
avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
avctx->channels = s->out_channels;
s->frame.nb_samples = s->num_blocks * 256;
if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
output[ch] = s->output[ch];
s->outptr[ch] = s->output[ch];
}
for (ch = 0; ch < s->channels; ch++) {
if (ch < s->out_channels)
s->outptr[channel_map[ch]] = (float *)s->frame.data[ch];
}
for (blk = 0; blk < s->num_blocks; blk++) {
if (!err && decode_audio_block(s, blk)) {
av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
err = 1;
}
if (err)
for (ch = 0; ch < s->out_channels; ch++)
memcpy(((float*)s->frame.data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], 1024);
for (ch = 0; ch < s->out_channels; ch++) {
output[ch] = s->outptr[channel_map[ch]];
if (!ch || channel_map[ch])
s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
}
}
s->frame.decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
for (ch = 0; ch < s->out_channels; ch++)
memcpy(s->output[ch], output[ch], 1024);
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
return FFMIN(buf_size, s->frame_size);
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1,
int *VAR_2, AVPacket *VAR_3)
{
const uint8_t *VAR_4 = VAR_3->VAR_1;
int VAR_5 = VAR_3->size;
AC3DecodeContext *s = VAR_0->priv_data;
int VAR_6, VAR_7, VAR_8, VAR_9;
const uint8_t *VAR_10;
const float *VAR_11[AC3_MAX_CHANNELS];
if (VAR_5 >= 2 && AV_RB16(VAR_4) == 0x770B) {
int VAR_12 = FFMIN(VAR_5, AC3_FRAME_BUFFER_SIZE) >> 1;
s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)VAR_4, VAR_12);
} else
memcpy(s->input_buffer, VAR_4, FFMIN(VAR_5, AC3_FRAME_BUFFER_SIZE));
VAR_4 = s->input_buffer;
init_get_bits(&s->gbc, VAR_4, VAR_5 * 8);
VAR_8 = parse_frame_header(s);
if (VAR_8) {
switch (VAR_8) {
case AAC_AC3_PARSE_ERROR_SYNC:
av_log(VAR_0, AV_LOG_ERROR, "frame sync error\n");
return -1;
case AAC_AC3_PARSE_ERROR_BSID:
av_log(VAR_0, AV_LOG_ERROR, "invalid bitstream id\n");
break;
case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
av_log(VAR_0, AV_LOG_ERROR, "invalid sample rate\n");
break;
case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
av_log(VAR_0, AV_LOG_ERROR, "invalid frame size\n");
break;
case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
av_log(VAR_0, AV_LOG_ERROR, "unsupported frame type : "
"skipping frame\n");
*VAR_2 = 0;
return s->frame_size;
} else {
av_log(VAR_0, AV_LOG_ERROR, "invalid frame type\n");
}
break;
default:
av_log(VAR_0, AV_LOG_ERROR, "invalid header\n");
break;
}
} else {
if (s->frame_size > VAR_5) {
av_log(VAR_0, AV_LOG_ERROR, "incomplete frame\n");
VAR_8 = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
} else if (VAR_0->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &VAR_4[2],
s->frame_size - 2)) {
av_log(VAR_0, AV_LOG_ERROR, "frame CRC mismatch\n");
VAR_8 = AAC_AC3_PARSE_ERROR_CRC;
}
}
}
if (!VAR_8) {
VAR_0->sample_rate = s->sample_rate;
VAR_0->bit_rate = s->bit_rate;
s->out_channels = s->channels;
s->output_mode = s->channel_mode;
if (s->lfe_on)
s->output_mode |= AC3_OUTPUT_LFEON;
if (VAR_0->request_channels > 0 && VAR_0->request_channels <= 2 &&
VAR_0->request_channels < s->channels) {
s->out_channels = VAR_0->request_channels;
s->output_mode = VAR_0->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
}
VAR_0->channels = s->out_channels;
VAR_0->channel_layout = s->channel_layout;
s->loro_center_mix_level = gain_levels[s-> center_mix_level];
s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
s->ltrt_center_mix_level = LEVEL_MINUS_3DB;
s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
s->fbw_channels == s->out_channels)) {
set_downmix_coeffs(s);
}
} else if (!s->out_channels) {
s->out_channels = VAR_0->channels;
if (s->out_channels < s->channels)
s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
}
if (VAR_0->channels != s->out_channels) {
av_log(VAR_0, AV_LOG_ERROR, "channel number mismatching on damaged frame\n");
return AVERROR_INVALIDDATA;
}
VAR_0->audio_service_type = s->bitstream_mode;
if (s->bitstream_mode == 0x7 && s->channels > 1)
VAR_0->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
VAR_0->channels = s->out_channels;
s->frame.nb_samples = s->num_blocks * 256;
if ((VAR_9 = ff_get_buffer(VAR_0, &s->frame)) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");
return VAR_9;
}
VAR_10 = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
for (VAR_7 = 0; VAR_7 < AC3_MAX_CHANNELS; VAR_7++) {
VAR_11[VAR_7] = s->VAR_11[VAR_7];
s->outptr[VAR_7] = s->VAR_11[VAR_7];
}
for (VAR_7 = 0; VAR_7 < s->channels; VAR_7++) {
if (VAR_7 < s->out_channels)
s->outptr[VAR_10[VAR_7]] = (float *)s->frame.VAR_1[VAR_7];
}
for (VAR_6 = 0; VAR_6 < s->num_blocks; VAR_6++) {
if (!VAR_8 && decode_audio_block(s, VAR_6)) {
av_log(VAR_0, AV_LOG_ERROR, "error decoding the audio block\n");
VAR_8 = 1;
}
if (VAR_8)
for (VAR_7 = 0; VAR_7 < s->out_channels; VAR_7++)
memcpy(((float*)s->frame.VAR_1[VAR_7]) + AC3_BLOCK_SIZE*VAR_6, VAR_11[VAR_7], 1024);
for (VAR_7 = 0; VAR_7 < s->out_channels; VAR_7++) {
VAR_11[VAR_7] = s->outptr[VAR_10[VAR_7]];
if (!VAR_7 || VAR_10[VAR_7])
s->outptr[VAR_10[VAR_7]] += AC3_BLOCK_SIZE;
}
}
s->frame.decode_error_flags = VAR_8 ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
for (VAR_7 = 0; VAR_7 < s->out_channels; VAR_7++)
memcpy(s->VAR_11[VAR_7], VAR_11[VAR_7], 1024);
*VAR_2 = 1;
*(AVFrame *)VAR_1 = s->frame;
return FFMIN(VAR_5, s->frame_size);
}
|
[
"static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"AC3DecodeContext *s = VAR_0->priv_data;",
"int VAR_6, VAR_7, VAR_8, VAR_9;",
"const uint8_t *VAR_10;",
"const float *VAR_11[AC3_MAX_CHANNELS];",
"if (VAR_5 >= 2 && AV_RB16(VAR_4) == 0x770B) {",
"int VAR_12 = FFMIN(VAR_5, AC3_FRAME_BUFFER_SIZE) >> 1;",
"s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)VAR_4, VAR_12);",
"} else",
"memcpy(s->input_buffer, VAR_4, FFMIN(VAR_5, AC3_FRAME_BUFFER_SIZE));",
"VAR_4 = s->input_buffer;",
"init_get_bits(&s->gbc, VAR_4, VAR_5 * 8);",
"VAR_8 = parse_frame_header(s);",
"if (VAR_8) {",
"switch (VAR_8) {",
"case AAC_AC3_PARSE_ERROR_SYNC:\nav_log(VAR_0, AV_LOG_ERROR, \"frame sync error\\n\");",
"return -1;",
"case AAC_AC3_PARSE_ERROR_BSID:\nav_log(VAR_0, AV_LOG_ERROR, \"invalid bitstream id\\n\");",
"break;",
"case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:\nav_log(VAR_0, AV_LOG_ERROR, \"invalid sample rate\\n\");",
"break;",
"case AAC_AC3_PARSE_ERROR_FRAME_SIZE:\nav_log(VAR_0, AV_LOG_ERROR, \"invalid frame size\\n\");",
"break;",
"case AAC_AC3_PARSE_ERROR_FRAME_TYPE:\nif (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {",
"av_log(VAR_0, AV_LOG_ERROR, \"unsupported frame type : \"\n\"skipping frame\\n\");",
"*VAR_2 = 0;",
"return s->frame_size;",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"invalid frame type\\n\");",
"}",
"break;",
"default:\nav_log(VAR_0, AV_LOG_ERROR, \"invalid header\\n\");",
"break;",
"}",
"} else {",
"if (s->frame_size > VAR_5) {",
"av_log(VAR_0, AV_LOG_ERROR, \"incomplete frame\\n\");",
"VAR_8 = AAC_AC3_PARSE_ERROR_FRAME_SIZE;",
"} else if (VAR_0->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {",
"if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &VAR_4[2],\ns->frame_size - 2)) {",
"av_log(VAR_0, AV_LOG_ERROR, \"frame CRC mismatch\\n\");",
"VAR_8 = AAC_AC3_PARSE_ERROR_CRC;",
"}",
"}",
"}",
"if (!VAR_8) {",
"VAR_0->sample_rate = s->sample_rate;",
"VAR_0->bit_rate = s->bit_rate;",
"s->out_channels = s->channels;",
"s->output_mode = s->channel_mode;",
"if (s->lfe_on)\ns->output_mode |= AC3_OUTPUT_LFEON;",
"if (VAR_0->request_channels > 0 && VAR_0->request_channels <= 2 &&\nVAR_0->request_channels < s->channels) {",
"s->out_channels = VAR_0->request_channels;",
"s->output_mode = VAR_0->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;",
"s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];",
"}",
"VAR_0->channels = s->out_channels;",
"VAR_0->channel_layout = s->channel_layout;",
"s->loro_center_mix_level = gain_levels[s-> center_mix_level];",
"s->loro_surround_mix_level = gain_levels[s->surround_mix_level];",
"s->ltrt_center_mix_level = LEVEL_MINUS_3DB;",
"s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;",
"if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&\ns->fbw_channels == s->out_channels)) {",
"set_downmix_coeffs(s);",
"}",
"} else if (!s->out_channels) {",
"s->out_channels = VAR_0->channels;",
"if (s->out_channels < s->channels)\ns->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;",
"}",
"if (VAR_0->channels != s->out_channels) {",
"av_log(VAR_0, AV_LOG_ERROR, \"channel number mismatching on damaged frame\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"VAR_0->audio_service_type = s->bitstream_mode;",
"if (s->bitstream_mode == 0x7 && s->channels > 1)\nVAR_0->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;",
"VAR_0->channels = s->out_channels;",
"s->frame.nb_samples = s->num_blocks * 256;",
"if ((VAR_9 = ff_get_buffer(VAR_0, &s->frame)) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");",
"return VAR_9;",
"}",
"VAR_10 = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];",
"for (VAR_7 = 0; VAR_7 < AC3_MAX_CHANNELS; VAR_7++) {",
"VAR_11[VAR_7] = s->VAR_11[VAR_7];",
"s->outptr[VAR_7] = s->VAR_11[VAR_7];",
"}",
"for (VAR_7 = 0; VAR_7 < s->channels; VAR_7++) {",
"if (VAR_7 < s->out_channels)\ns->outptr[VAR_10[VAR_7]] = (float *)s->frame.VAR_1[VAR_7];",
"}",
"for (VAR_6 = 0; VAR_6 < s->num_blocks; VAR_6++) {",
"if (!VAR_8 && decode_audio_block(s, VAR_6)) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error decoding the audio block\\n\");",
"VAR_8 = 1;",
"}",
"if (VAR_8)\nfor (VAR_7 = 0; VAR_7 < s->out_channels; VAR_7++)",
"memcpy(((float*)s->frame.VAR_1[VAR_7]) + AC3_BLOCK_SIZE*VAR_6, VAR_11[VAR_7], 1024);",
"for (VAR_7 = 0; VAR_7 < s->out_channels; VAR_7++) {",
"VAR_11[VAR_7] = s->outptr[VAR_10[VAR_7]];",
"if (!VAR_7 || VAR_10[VAR_7])\ns->outptr[VAR_10[VAR_7]] += AC3_BLOCK_SIZE;",
"}",
"}",
"s->frame.decode_error_flags = VAR_8 ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;",
"for (VAR_7 = 0; VAR_7 < s->out_channels; VAR_7++)",
"memcpy(s->VAR_11[VAR_7], VAR_11[VAR_7], 1024);",
"*VAR_2 = 1;",
"*(AVFrame *)VAR_1 = s->frame;",
"return FFMIN(VAR_5, s->frame_size);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
47
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61,
63
],
[
65
],
[
67,
69
],
[
71
],
[
73,
75
],
[
77
],
[
79,
85
],
[
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125,
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
143
],
[
145
],
[
147
],
[
153
],
[
155
],
[
157,
159
],
[
161,
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
179
],
[
181
],
[
183
],
[
185
],
[
189,
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201,
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
217
],
[
219,
221
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255,
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271,
273
],
[
275
],
[
277
],
[
279
],
[
281,
283
],
[
285
],
[
287
],
[
291
],
[
297
],
[
299
],
[
303
],
[
305
],
[
309
],
[
311
]
] |
7,000 |
static void decode_postinit(H264Context *h, int setup_finished)
{
H264Picture *out = h->cur_pic_ptr;
H264Picture *cur = h->cur_pic_ptr;
int i, pics, out_of_order, out_idx;
int invalid = 0, cnt = 0;
h->cur_pic_ptr->f->pict_type = h->pict_type;
if (h->next_output_pic)
return;
if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {
/* FIXME: if we have two PAFF fields in one packet, we can't start
* the next thread here. If we have one field per packet, we can.
* The check in decode_nal_units() is not good enough to find this
* yet, so we assume the worst for now. */
// if (setup_finished)
// ff_thread_finish_setup(h->avctx);
return;
}
cur->f->interlaced_frame = 0;
cur->f->repeat_pict = 0;
/* Signal interlacing information externally. */
/* Prioritize picture timing SEI information over used
* decoding process if it exists. */
if (h->sps.pic_struct_present_flag) {
switch (h->sei_pic_struct) {
case SEI_PIC_STRUCT_FRAME:
break;
case SEI_PIC_STRUCT_TOP_FIELD:
case SEI_PIC_STRUCT_BOTTOM_FIELD:
cur->f->interlaced_frame = 1;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM:
case SEI_PIC_STRUCT_BOTTOM_TOP:
if (FIELD_OR_MBAFF_PICTURE(h))
cur->f->interlaced_frame = 1;
else
// try to flag soft telecine progressive
cur->f->interlaced_frame = h->prev_interlaced_frame;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
/* Signal the possibility of telecined film externally
* (pic_struct 5,6). From these hints, let the applications
* decide if they apply deinterlacing. */
cur->f->repeat_pict = 1;
break;
case SEI_PIC_STRUCT_FRAME_DOUBLING:
cur->f->repeat_pict = 2;
break;
case SEI_PIC_STRUCT_FRAME_TRIPLING:
cur->f->repeat_pict = 4;
break;
}
if ((h->sei_ct_type & 3) &&
h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
cur->f->interlaced_frame = (h->sei_ct_type & (1 << 1)) != 0;
} else {
/* Derive interlacing flag from used decoding process. */
cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);
}
h->prev_interlaced_frame = cur->f->interlaced_frame;
if (cur->field_poc[0] != cur->field_poc[1]) {
/* Derive top_field_first from field pocs. */
cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
} else {
if (cur->f->interlaced_frame || h->sps.pic_struct_present_flag) {
/* Use picture timing SEI information. Even if it is a
* information of a past frame, better than nothing. */
if (h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
cur->f->top_field_first = 1;
else
cur->f->top_field_first = 0;
} else {
/* Most likely progressive */
cur->f->top_field_first = 0;
}
}
if (h->sei_frame_packing_present &&
h->frame_packing_arrangement_type >= 0 &&
h->frame_packing_arrangement_type <= 6 &&
h->content_interpretation_type > 0 &&
h->content_interpretation_type < 3) {
AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
if (!stereo)
return;
switch (h->frame_packing_arrangement_type) {
case 0:
stereo->type = AV_STEREO3D_CHECKERBOARD;
break;
case 1:
stereo->type = AV_STEREO3D_COLUMNS;
break;
case 2:
stereo->type = AV_STEREO3D_LINES;
break;
case 3:
if (h->quincunx_subsampling)
stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
else
stereo->type = AV_STEREO3D_SIDEBYSIDE;
break;
case 4:
stereo->type = AV_STEREO3D_TOPBOTTOM;
break;
case 5:
stereo->type = AV_STEREO3D_FRAMESEQUENCE;
break;
case 6:
stereo->type = AV_STEREO3D_2D;
break;
}
if (h->content_interpretation_type == 2)
stereo->flags = AV_STEREO3D_FLAG_INVERT;
}
if (h->sei_display_orientation_present &&
(h->sei_anticlockwise_rotation || h->sei_hflip || h->sei_vflip)) {
double angle = h->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
AV_FRAME_DATA_DISPLAYMATRIX,
sizeof(int32_t) * 9);
if (!rotation)
return;
av_display_rotation_set((int32_t *)rotation->data, angle);
av_display_matrix_flip((int32_t *)rotation->data,
h->sei_hflip, h->sei_vflip);
}
// FIXME do something with unavailable reference frames
/* Sort B-frames into display order */
if (h->sps.bitstream_restriction_flag &&
h->avctx->has_b_frames < h->sps.num_reorder_frames) {
h->avctx->has_b_frames = h->sps.num_reorder_frames;
h->low_delay = 0;
}
if (h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT &&
!h->sps.bitstream_restriction_flag) {
h->avctx->has_b_frames = MAX_DELAYED_PIC_COUNT - 1;
h->low_delay = 0;
}
pics = 0;
while (h->delayed_pic[pics])
pics++;
assert(pics <= MAX_DELAYED_PIC_COUNT);
h->delayed_pic[pics++] = cur;
if (cur->reference == 0)
cur->reference = DELAYED_PIC_REF;
/* Frame reordering. This code takes pictures from coding order and sorts
* them by their incremental POC value into display order. It supports POC
* gaps, MMCO reset codes and random resets.
* A "display group" can start either with a IDR frame (f.key_frame = 1),
* and/or can be closed down with a MMCO reset code. In sequences where
* there is no delay, we can't detect that (since the frame was already
* output to the user), so we also set h->mmco_reset to detect the MMCO
* reset code.
* FIXME: if we detect insufficient delays (as per h->avctx->has_b_frames),
* we increase the delay between input and output. All frames affected by
* the lag (e.g. those that should have been output before another frame
* that we already returned to the user) will be dropped. This is a bug
* that we will fix later. */
for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
cnt += out->poc < h->last_pocs[i];
invalid += out->poc == INT_MIN;
}
if (!h->mmco_reset && !cur->f->key_frame &&
cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
h->mmco_reset = 2;
if (pics > 1)
h->delayed_pic[pics - 2]->mmco_reset = 2;
}
if (h->mmco_reset || cur->f->key_frame) {
for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
h->last_pocs[i] = INT_MIN;
cnt = 0;
invalid = MAX_DELAYED_PIC_COUNT;
}
out = h->delayed_pic[0];
out_idx = 0;
for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
h->delayed_pic[i] &&
!h->delayed_pic[i - 1]->mmco_reset &&
!h->delayed_pic[i]->f->key_frame;
i++)
if (h->delayed_pic[i]->poc < out->poc) {
out = h->delayed_pic[i];
out_idx = i;
}
if (h->avctx->has_b_frames == 0 &&
(h->delayed_pic[0]->f->key_frame || h->mmco_reset))
h->next_outputed_poc = INT_MIN;
out_of_order = !out->f->key_frame && !h->mmco_reset &&
(out->poc < h->next_outputed_poc);
if (h->sps.bitstream_restriction_flag &&
h->avctx->has_b_frames >= h->sps.num_reorder_frames) {
} else if (out_of_order && pics - 1 == h->avctx->has_b_frames &&
h->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, cnt);
}
h->low_delay = 0;
} else if (h->low_delay &&
((h->next_outputed_poc != INT_MIN &&
out->poc > h->next_outputed_poc + 2) ||
cur->f->pict_type == AV_PICTURE_TYPE_B)) {
h->low_delay = 0;
h->avctx->has_b_frames++;
}
if (pics > h->avctx->has_b_frames) {
out->reference &= ~DELAYED_PIC_REF;
// for frame threading, the owner must be the second field's thread or
// else the first thread can release the picture and reuse it unsafely
for (i = out_idx; h->delayed_pic[i]; i++)
h->delayed_pic[i] = h->delayed_pic[i + 1];
}
memmove(h->last_pocs, &h->last_pocs[1],
sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
if (!out_of_order && pics > h->avctx->has_b_frames) {
h->next_output_pic = out;
if (out->mmco_reset) {
if (out_idx > 0) {
h->next_outputed_poc = out->poc;
h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
} else {
h->next_outputed_poc = INT_MIN;
}
} else {
if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f->key_frame) {
h->next_outputed_poc = INT_MIN;
} else {
h->next_outputed_poc = out->poc;
}
}
h->mmco_reset = 0;
} else {
av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
}
if (h->next_output_pic) {
if (h->next_output_pic->recovered) {
// We have reached an recovery point and all frames after it in
// display order are "recovered".
h->frame_recovered |= FRAME_RECOVERED_SEI;
}
h->next_output_pic->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
}
if (setup_finished && !h->avctx->hwaccel)
ff_thread_finish_setup(h->avctx);
}
| true |
FFmpeg
|
5ec0bdf2c524224f30ba4786f47324970aed4aaa
|
static void decode_postinit(H264Context *h, int setup_finished)
{
H264Picture *out = h->cur_pic_ptr;
H264Picture *cur = h->cur_pic_ptr;
int i, pics, out_of_order, out_idx;
int invalid = 0, cnt = 0;
h->cur_pic_ptr->f->pict_type = h->pict_type;
if (h->next_output_pic)
return;
if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {
return;
}
cur->f->interlaced_frame = 0;
cur->f->repeat_pict = 0;
if (h->sps.pic_struct_present_flag) {
switch (h->sei_pic_struct) {
case SEI_PIC_STRUCT_FRAME:
break;
case SEI_PIC_STRUCT_TOP_FIELD:
case SEI_PIC_STRUCT_BOTTOM_FIELD:
cur->f->interlaced_frame = 1;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM:
case SEI_PIC_STRUCT_BOTTOM_TOP:
if (FIELD_OR_MBAFF_PICTURE(h))
cur->f->interlaced_frame = 1;
else
cur->f->interlaced_frame = h->prev_interlaced_frame;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
cur->f->repeat_pict = 1;
break;
case SEI_PIC_STRUCT_FRAME_DOUBLING:
cur->f->repeat_pict = 2;
break;
case SEI_PIC_STRUCT_FRAME_TRIPLING:
cur->f->repeat_pict = 4;
break;
}
if ((h->sei_ct_type & 3) &&
h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
cur->f->interlaced_frame = (h->sei_ct_type & (1 << 1)) != 0;
} else {
cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);
}
h->prev_interlaced_frame = cur->f->interlaced_frame;
if (cur->field_poc[0] != cur->field_poc[1]) {
cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
} else {
if (cur->f->interlaced_frame || h->sps.pic_struct_present_flag) {
if (h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
cur->f->top_field_first = 1;
else
cur->f->top_field_first = 0;
} else {
cur->f->top_field_first = 0;
}
}
if (h->sei_frame_packing_present &&
h->frame_packing_arrangement_type >= 0 &&
h->frame_packing_arrangement_type <= 6 &&
h->content_interpretation_type > 0 &&
h->content_interpretation_type < 3) {
AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
if (!stereo)
return;
switch (h->frame_packing_arrangement_type) {
case 0:
stereo->type = AV_STEREO3D_CHECKERBOARD;
break;
case 1:
stereo->type = AV_STEREO3D_COLUMNS;
break;
case 2:
stereo->type = AV_STEREO3D_LINES;
break;
case 3:
if (h->quincunx_subsampling)
stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
else
stereo->type = AV_STEREO3D_SIDEBYSIDE;
break;
case 4:
stereo->type = AV_STEREO3D_TOPBOTTOM;
break;
case 5:
stereo->type = AV_STEREO3D_FRAMESEQUENCE;
break;
case 6:
stereo->type = AV_STEREO3D_2D;
break;
}
if (h->content_interpretation_type == 2)
stereo->flags = AV_STEREO3D_FLAG_INVERT;
}
if (h->sei_display_orientation_present &&
(h->sei_anticlockwise_rotation || h->sei_hflip || h->sei_vflip)) {
double angle = h->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
AV_FRAME_DATA_DISPLAYMATRIX,
sizeof(int32_t) * 9);
if (!rotation)
return;
av_display_rotation_set((int32_t *)rotation->data, angle);
av_display_matrix_flip((int32_t *)rotation->data,
h->sei_hflip, h->sei_vflip);
}
if (h->sps.bitstream_restriction_flag &&
h->avctx->has_b_frames < h->sps.num_reorder_frames) {
h->avctx->has_b_frames = h->sps.num_reorder_frames;
h->low_delay = 0;
}
if (h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT &&
!h->sps.bitstream_restriction_flag) {
h->avctx->has_b_frames = MAX_DELAYED_PIC_COUNT - 1;
h->low_delay = 0;
}
pics = 0;
while (h->delayed_pic[pics])
pics++;
assert(pics <= MAX_DELAYED_PIC_COUNT);
h->delayed_pic[pics++] = cur;
if (cur->reference == 0)
cur->reference = DELAYED_PIC_REF;
for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
cnt += out->poc < h->last_pocs[i];
invalid += out->poc == INT_MIN;
}
if (!h->mmco_reset && !cur->f->key_frame &&
cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
h->mmco_reset = 2;
if (pics > 1)
h->delayed_pic[pics - 2]->mmco_reset = 2;
}
if (h->mmco_reset || cur->f->key_frame) {
for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
h->last_pocs[i] = INT_MIN;
cnt = 0;
invalid = MAX_DELAYED_PIC_COUNT;
}
out = h->delayed_pic[0];
out_idx = 0;
for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
h->delayed_pic[i] &&
!h->delayed_pic[i - 1]->mmco_reset &&
!h->delayed_pic[i]->f->key_frame;
i++)
if (h->delayed_pic[i]->poc < out->poc) {
out = h->delayed_pic[i];
out_idx = i;
}
if (h->avctx->has_b_frames == 0 &&
(h->delayed_pic[0]->f->key_frame || h->mmco_reset))
h->next_outputed_poc = INT_MIN;
out_of_order = !out->f->key_frame && !h->mmco_reset &&
(out->poc < h->next_outputed_poc);
if (h->sps.bitstream_restriction_flag &&
h->avctx->has_b_frames >= h->sps.num_reorder_frames) {
} else if (out_of_order && pics - 1 == h->avctx->has_b_frames &&
h->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, cnt);
}
h->low_delay = 0;
} else if (h->low_delay &&
((h->next_outputed_poc != INT_MIN &&
out->poc > h->next_outputed_poc + 2) ||
cur->f->pict_type == AV_PICTURE_TYPE_B)) {
h->low_delay = 0;
h->avctx->has_b_frames++;
}
if (pics > h->avctx->has_b_frames) {
out->reference &= ~DELAYED_PIC_REF;
for (i = out_idx; h->delayed_pic[i]; i++)
h->delayed_pic[i] = h->delayed_pic[i + 1];
}
memmove(h->last_pocs, &h->last_pocs[1],
sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
if (!out_of_order && pics > h->avctx->has_b_frames) {
h->next_output_pic = out;
if (out->mmco_reset) {
if (out_idx > 0) {
h->next_outputed_poc = out->poc;
h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
} else {
h->next_outputed_poc = INT_MIN;
}
} else {
if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f->key_frame) {
h->next_outputed_poc = INT_MIN;
} else {
h->next_outputed_poc = out->poc;
}
}
h->mmco_reset = 0;
} else {
av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
}
if (h->next_output_pic) {
if (h->next_output_pic->recovered) {
h->frame_recovered |= FRAME_RECOVERED_SEI;
}
h->next_output_pic->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
}
if (setup_finished && !h->avctx->hwaccel)
ff_thread_finish_setup(h->avctx);
}
|
{
"code": [
" if (setup_finished && !h->avctx->hwaccel)"
],
"line_no": [
539
]
}
|
static void FUNC_0(H264Context *VAR_0, int VAR_1)
{
H264Picture *out = VAR_0->cur_pic_ptr;
H264Picture *cur = VAR_0->cur_pic_ptr;
int VAR_2, VAR_3, VAR_4, VAR_5;
int VAR_6 = 0, VAR_7 = 0;
VAR_0->cur_pic_ptr->f->pict_type = VAR_0->pict_type;
if (VAR_0->next_output_pic)
return;
if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {
return;
}
cur->f->interlaced_frame = 0;
cur->f->repeat_pict = 0;
if (VAR_0->sps.pic_struct_present_flag) {
switch (VAR_0->sei_pic_struct) {
case SEI_PIC_STRUCT_FRAME:
break;
case SEI_PIC_STRUCT_TOP_FIELD:
case SEI_PIC_STRUCT_BOTTOM_FIELD:
cur->f->interlaced_frame = 1;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM:
case SEI_PIC_STRUCT_BOTTOM_TOP:
if (FIELD_OR_MBAFF_PICTURE(VAR_0))
cur->f->interlaced_frame = 1;
else
cur->f->interlaced_frame = VAR_0->prev_interlaced_frame;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
cur->f->repeat_pict = 1;
break;
case SEI_PIC_STRUCT_FRAME_DOUBLING:
cur->f->repeat_pict = 2;
break;
case SEI_PIC_STRUCT_FRAME_TRIPLING:
cur->f->repeat_pict = 4;
break;
}
if ((VAR_0->sei_ct_type & 3) &&
VAR_0->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
cur->f->interlaced_frame = (VAR_0->sei_ct_type & (1 << 1)) != 0;
} else {
cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(VAR_0);
}
VAR_0->prev_interlaced_frame = cur->f->interlaced_frame;
if (cur->field_poc[0] != cur->field_poc[1]) {
cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
} else {
if (cur->f->interlaced_frame || VAR_0->sps.pic_struct_present_flag) {
if (VAR_0->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
VAR_0->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
cur->f->top_field_first = 1;
else
cur->f->top_field_first = 0;
} else {
cur->f->top_field_first = 0;
}
}
if (VAR_0->sei_frame_packing_present &&
VAR_0->frame_packing_arrangement_type >= 0 &&
VAR_0->frame_packing_arrangement_type <= 6 &&
VAR_0->content_interpretation_type > 0 &&
VAR_0->content_interpretation_type < 3) {
AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
if (!stereo)
return;
switch (VAR_0->frame_packing_arrangement_type) {
case 0:
stereo->type = AV_STEREO3D_CHECKERBOARD;
break;
case 1:
stereo->type = AV_STEREO3D_COLUMNS;
break;
case 2:
stereo->type = AV_STEREO3D_LINES;
break;
case 3:
if (VAR_0->quincunx_subsampling)
stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
else
stereo->type = AV_STEREO3D_SIDEBYSIDE;
break;
case 4:
stereo->type = AV_STEREO3D_TOPBOTTOM;
break;
case 5:
stereo->type = AV_STEREO3D_FRAMESEQUENCE;
break;
case 6:
stereo->type = AV_STEREO3D_2D;
break;
}
if (VAR_0->content_interpretation_type == 2)
stereo->flags = AV_STEREO3D_FLAG_INVERT;
}
if (VAR_0->sei_display_orientation_present &&
(VAR_0->sei_anticlockwise_rotation || VAR_0->sei_hflip || VAR_0->sei_vflip)) {
double VAR_8 = VAR_0->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
AV_FRAME_DATA_DISPLAYMATRIX,
sizeof(int32_t) * 9);
if (!rotation)
return;
av_display_rotation_set((int32_t *)rotation->data, VAR_8);
av_display_matrix_flip((int32_t *)rotation->data,
VAR_0->sei_hflip, VAR_0->sei_vflip);
}
if (VAR_0->sps.bitstream_restriction_flag &&
VAR_0->avctx->has_b_frames < VAR_0->sps.num_reorder_frames) {
VAR_0->avctx->has_b_frames = VAR_0->sps.num_reorder_frames;
VAR_0->low_delay = 0;
}
if (VAR_0->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT &&
!VAR_0->sps.bitstream_restriction_flag) {
VAR_0->avctx->has_b_frames = MAX_DELAYED_PIC_COUNT - 1;
VAR_0->low_delay = 0;
}
VAR_3 = 0;
while (VAR_0->delayed_pic[VAR_3])
VAR_3++;
assert(VAR_3 <= MAX_DELAYED_PIC_COUNT);
VAR_0->delayed_pic[VAR_3++] = cur;
if (cur->reference == 0)
cur->reference = DELAYED_PIC_REF;
for (VAR_2 = 0; VAR_2 < MAX_DELAYED_PIC_COUNT; VAR_2++) {
VAR_7 += out->poc < VAR_0->last_pocs[VAR_2];
VAR_6 += out->poc == INT_MIN;
}
if (!VAR_0->mmco_reset && !cur->f->key_frame &&
VAR_7 + VAR_6 == MAX_DELAYED_PIC_COUNT && VAR_7 > 0) {
VAR_0->mmco_reset = 2;
if (VAR_3 > 1)
VAR_0->delayed_pic[VAR_3 - 2]->mmco_reset = 2;
}
if (VAR_0->mmco_reset || cur->f->key_frame) {
for (VAR_2 = 0; VAR_2 < MAX_DELAYED_PIC_COUNT; VAR_2++)
VAR_0->last_pocs[VAR_2] = INT_MIN;
VAR_7 = 0;
VAR_6 = MAX_DELAYED_PIC_COUNT;
}
out = VAR_0->delayed_pic[0];
VAR_5 = 0;
for (VAR_2 = 1; VAR_2 < MAX_DELAYED_PIC_COUNT &&
VAR_0->delayed_pic[VAR_2] &&
!VAR_0->delayed_pic[VAR_2 - 1]->mmco_reset &&
!VAR_0->delayed_pic[VAR_2]->f->key_frame;
VAR_2++)
if (VAR_0->delayed_pic[VAR_2]->poc < out->poc) {
out = VAR_0->delayed_pic[VAR_2];
VAR_5 = VAR_2;
}
if (VAR_0->avctx->has_b_frames == 0 &&
(VAR_0->delayed_pic[0]->f->key_frame || VAR_0->mmco_reset))
VAR_0->next_outputed_poc = INT_MIN;
VAR_4 = !out->f->key_frame && !VAR_0->mmco_reset &&
(out->poc < VAR_0->next_outputed_poc);
if (VAR_0->sps.bitstream_restriction_flag &&
VAR_0->avctx->has_b_frames >= VAR_0->sps.num_reorder_frames) {
} else if (VAR_4 && VAR_3 - 1 == VAR_0->avctx->has_b_frames &&
VAR_0->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
if (VAR_6 + VAR_7 < MAX_DELAYED_PIC_COUNT) {
VAR_0->avctx->has_b_frames = FFMAX(VAR_0->avctx->has_b_frames, VAR_7);
}
VAR_0->low_delay = 0;
} else if (VAR_0->low_delay &&
((VAR_0->next_outputed_poc != INT_MIN &&
out->poc > VAR_0->next_outputed_poc + 2) ||
cur->f->pict_type == AV_PICTURE_TYPE_B)) {
VAR_0->low_delay = 0;
VAR_0->avctx->has_b_frames++;
}
if (VAR_3 > VAR_0->avctx->has_b_frames) {
out->reference &= ~DELAYED_PIC_REF;
for (VAR_2 = VAR_5; VAR_0->delayed_pic[VAR_2]; VAR_2++)
VAR_0->delayed_pic[VAR_2] = VAR_0->delayed_pic[VAR_2 + 1];
}
memmove(VAR_0->last_pocs, &VAR_0->last_pocs[1],
sizeof(*VAR_0->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
VAR_0->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
if (!VAR_4 && VAR_3 > VAR_0->avctx->has_b_frames) {
VAR_0->next_output_pic = out;
if (out->mmco_reset) {
if (VAR_5 > 0) {
VAR_0->next_outputed_poc = out->poc;
VAR_0->delayed_pic[VAR_5 - 1]->mmco_reset = out->mmco_reset;
} else {
VAR_0->next_outputed_poc = INT_MIN;
}
} else {
if (VAR_5 == 0 && VAR_3 > 1 && VAR_0->delayed_pic[0]->f->key_frame) {
VAR_0->next_outputed_poc = INT_MIN;
} else {
VAR_0->next_outputed_poc = out->poc;
}
}
VAR_0->mmco_reset = 0;
} else {
av_log(VAR_0->avctx, AV_LOG_DEBUG, "no picture\n");
}
if (VAR_0->next_output_pic) {
if (VAR_0->next_output_pic->recovered) {
VAR_0->frame_recovered |= FRAME_RECOVERED_SEI;
}
VAR_0->next_output_pic->recovered |= !!(VAR_0->frame_recovered & FRAME_RECOVERED_SEI);
}
if (VAR_1 && !VAR_0->avctx->hwaccel)
ff_thread_finish_setup(VAR_0->avctx);
}
|
[
"static void FUNC_0(H264Context *VAR_0, int VAR_1)\n{",
"H264Picture *out = VAR_0->cur_pic_ptr;",
"H264Picture *cur = VAR_0->cur_pic_ptr;",
"int VAR_2, VAR_3, VAR_4, VAR_5;",
"int VAR_6 = 0, VAR_7 = 0;",
"VAR_0->cur_pic_ptr->f->pict_type = VAR_0->pict_type;",
"if (VAR_0->next_output_pic)\nreturn;",
"if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {",
"return;",
"}",
"cur->f->interlaced_frame = 0;",
"cur->f->repeat_pict = 0;",
"if (VAR_0->sps.pic_struct_present_flag) {",
"switch (VAR_0->sei_pic_struct) {",
"case SEI_PIC_STRUCT_FRAME:\nbreak;",
"case SEI_PIC_STRUCT_TOP_FIELD:\ncase SEI_PIC_STRUCT_BOTTOM_FIELD:\ncur->f->interlaced_frame = 1;",
"break;",
"case SEI_PIC_STRUCT_TOP_BOTTOM:\ncase SEI_PIC_STRUCT_BOTTOM_TOP:\nif (FIELD_OR_MBAFF_PICTURE(VAR_0))\ncur->f->interlaced_frame = 1;",
"else\ncur->f->interlaced_frame = VAR_0->prev_interlaced_frame;",
"break;",
"case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:\ncase SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:\ncur->f->repeat_pict = 1;",
"break;",
"case SEI_PIC_STRUCT_FRAME_DOUBLING:\ncur->f->repeat_pict = 2;",
"break;",
"case SEI_PIC_STRUCT_FRAME_TRIPLING:\ncur->f->repeat_pict = 4;",
"break;",
"}",
"if ((VAR_0->sei_ct_type & 3) &&\nVAR_0->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)\ncur->f->interlaced_frame = (VAR_0->sei_ct_type & (1 << 1)) != 0;",
"} else {",
"cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(VAR_0);",
"}",
"VAR_0->prev_interlaced_frame = cur->f->interlaced_frame;",
"if (cur->field_poc[0] != cur->field_poc[1]) {",
"cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];",
"} else {",
"if (cur->f->interlaced_frame || VAR_0->sps.pic_struct_present_flag) {",
"if (VAR_0->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||\nVAR_0->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)\ncur->f->top_field_first = 1;",
"else\ncur->f->top_field_first = 0;",
"} else {",
"cur->f->top_field_first = 0;",
"}",
"}",
"if (VAR_0->sei_frame_packing_present &&\nVAR_0->frame_packing_arrangement_type >= 0 &&\nVAR_0->frame_packing_arrangement_type <= 6 &&\nVAR_0->content_interpretation_type > 0 &&\nVAR_0->content_interpretation_type < 3) {",
"AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);",
"if (!stereo)\nreturn;",
"switch (VAR_0->frame_packing_arrangement_type) {",
"case 0:\nstereo->type = AV_STEREO3D_CHECKERBOARD;",
"break;",
"case 1:\nstereo->type = AV_STEREO3D_COLUMNS;",
"break;",
"case 2:\nstereo->type = AV_STEREO3D_LINES;",
"break;",
"case 3:\nif (VAR_0->quincunx_subsampling)\nstereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;",
"else\nstereo->type = AV_STEREO3D_SIDEBYSIDE;",
"break;",
"case 4:\nstereo->type = AV_STEREO3D_TOPBOTTOM;",
"break;",
"case 5:\nstereo->type = AV_STEREO3D_FRAMESEQUENCE;",
"break;",
"case 6:\nstereo->type = AV_STEREO3D_2D;",
"break;",
"}",
"if (VAR_0->content_interpretation_type == 2)\nstereo->flags = AV_STEREO3D_FLAG_INVERT;",
"}",
"if (VAR_0->sei_display_orientation_present &&\n(VAR_0->sei_anticlockwise_rotation || VAR_0->sei_hflip || VAR_0->sei_vflip)) {",
"double VAR_8 = VAR_0->sei_anticlockwise_rotation * 360 / (double) (1 << 16);",
"AVFrameSideData *rotation = av_frame_new_side_data(cur->f,\nAV_FRAME_DATA_DISPLAYMATRIX,\nsizeof(int32_t) * 9);",
"if (!rotation)\nreturn;",
"av_display_rotation_set((int32_t *)rotation->data, VAR_8);",
"av_display_matrix_flip((int32_t *)rotation->data,\nVAR_0->sei_hflip, VAR_0->sei_vflip);",
"}",
"if (VAR_0->sps.bitstream_restriction_flag &&\nVAR_0->avctx->has_b_frames < VAR_0->sps.num_reorder_frames) {",
"VAR_0->avctx->has_b_frames = VAR_0->sps.num_reorder_frames;",
"VAR_0->low_delay = 0;",
"}",
"if (VAR_0->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT &&\n!VAR_0->sps.bitstream_restriction_flag) {",
"VAR_0->avctx->has_b_frames = MAX_DELAYED_PIC_COUNT - 1;",
"VAR_0->low_delay = 0;",
"}",
"VAR_3 = 0;",
"while (VAR_0->delayed_pic[VAR_3])\nVAR_3++;",
"assert(VAR_3 <= MAX_DELAYED_PIC_COUNT);",
"VAR_0->delayed_pic[VAR_3++] = cur;",
"if (cur->reference == 0)\ncur->reference = DELAYED_PIC_REF;",
"for (VAR_2 = 0; VAR_2 < MAX_DELAYED_PIC_COUNT; VAR_2++) {",
"VAR_7 += out->poc < VAR_0->last_pocs[VAR_2];",
"VAR_6 += out->poc == INT_MIN;",
"}",
"if (!VAR_0->mmco_reset && !cur->f->key_frame &&\nVAR_7 + VAR_6 == MAX_DELAYED_PIC_COUNT && VAR_7 > 0) {",
"VAR_0->mmco_reset = 2;",
"if (VAR_3 > 1)\nVAR_0->delayed_pic[VAR_3 - 2]->mmco_reset = 2;",
"}",
"if (VAR_0->mmco_reset || cur->f->key_frame) {",
"for (VAR_2 = 0; VAR_2 < MAX_DELAYED_PIC_COUNT; VAR_2++)",
"VAR_0->last_pocs[VAR_2] = INT_MIN;",
"VAR_7 = 0;",
"VAR_6 = MAX_DELAYED_PIC_COUNT;",
"}",
"out = VAR_0->delayed_pic[0];",
"VAR_5 = 0;",
"for (VAR_2 = 1; VAR_2 < MAX_DELAYED_PIC_COUNT &&",
"VAR_0->delayed_pic[VAR_2] &&\n!VAR_0->delayed_pic[VAR_2 - 1]->mmco_reset &&\n!VAR_0->delayed_pic[VAR_2]->f->key_frame;",
"VAR_2++)\nif (VAR_0->delayed_pic[VAR_2]->poc < out->poc) {",
"out = VAR_0->delayed_pic[VAR_2];",
"VAR_5 = VAR_2;",
"}",
"if (VAR_0->avctx->has_b_frames == 0 &&\n(VAR_0->delayed_pic[0]->f->key_frame || VAR_0->mmco_reset))\nVAR_0->next_outputed_poc = INT_MIN;",
"VAR_4 = !out->f->key_frame && !VAR_0->mmco_reset &&\n(out->poc < VAR_0->next_outputed_poc);",
"if (VAR_0->sps.bitstream_restriction_flag &&\nVAR_0->avctx->has_b_frames >= VAR_0->sps.num_reorder_frames) {",
"} else if (VAR_4 && VAR_3 - 1 == VAR_0->avctx->has_b_frames &&",
"VAR_0->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {",
"if (VAR_6 + VAR_7 < MAX_DELAYED_PIC_COUNT) {",
"VAR_0->avctx->has_b_frames = FFMAX(VAR_0->avctx->has_b_frames, VAR_7);",
"}",
"VAR_0->low_delay = 0;",
"} else if (VAR_0->low_delay &&",
"((VAR_0->next_outputed_poc != INT_MIN &&\nout->poc > VAR_0->next_outputed_poc + 2) ||\ncur->f->pict_type == AV_PICTURE_TYPE_B)) {",
"VAR_0->low_delay = 0;",
"VAR_0->avctx->has_b_frames++;",
"}",
"if (VAR_3 > VAR_0->avctx->has_b_frames) {",
"out->reference &= ~DELAYED_PIC_REF;",
"for (VAR_2 = VAR_5; VAR_0->delayed_pic[VAR_2]; VAR_2++)",
"VAR_0->delayed_pic[VAR_2] = VAR_0->delayed_pic[VAR_2 + 1];",
"}",
"memmove(VAR_0->last_pocs, &VAR_0->last_pocs[1],\nsizeof(*VAR_0->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));",
"VAR_0->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;",
"if (!VAR_4 && VAR_3 > VAR_0->avctx->has_b_frames) {",
"VAR_0->next_output_pic = out;",
"if (out->mmco_reset) {",
"if (VAR_5 > 0) {",
"VAR_0->next_outputed_poc = out->poc;",
"VAR_0->delayed_pic[VAR_5 - 1]->mmco_reset = out->mmco_reset;",
"} else {",
"VAR_0->next_outputed_poc = INT_MIN;",
"}",
"} else {",
"if (VAR_5 == 0 && VAR_3 > 1 && VAR_0->delayed_pic[0]->f->key_frame) {",
"VAR_0->next_outputed_poc = INT_MIN;",
"} else {",
"VAR_0->next_outputed_poc = out->poc;",
"}",
"}",
"VAR_0->mmco_reset = 0;",
"} else {",
"av_log(VAR_0->avctx, AV_LOG_DEBUG, \"no picture\\n\");",
"}",
"if (VAR_0->next_output_pic) {",
"if (VAR_0->next_output_pic->recovered) {",
"VAR_0->frame_recovered |= FRAME_RECOVERED_SEI;",
"}",
"VAR_0->next_output_pic->recovered |= !!(VAR_0->frame_recovered & FRAME_RECOVERED_SEI);",
"}",
"if (VAR_1 && !VAR_0->avctx->hwaccel)\nff_thread_finish_setup(VAR_0->avctx);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19,
21
],
[
25
],
[
39
],
[
41
],
[
45
],
[
47
],
[
59
],
[
61
],
[
63,
65
],
[
67,
69,
71
],
[
73
],
[
75,
77,
79,
81
],
[
83,
87
],
[
89
],
[
91,
93,
101
],
[
103
],
[
105,
107
],
[
109
],
[
111,
113
],
[
115
],
[
117
],
[
121,
123,
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
139
],
[
143
],
[
145
],
[
147
],
[
153,
155,
157
],
[
159,
161
],
[
163
],
[
167
],
[
169
],
[
171
],
[
175,
177,
179,
181,
183
],
[
185
],
[
187,
189
],
[
193
],
[
195,
197
],
[
199
],
[
201,
203
],
[
205
],
[
207,
209
],
[
211
],
[
213,
215,
217
],
[
219,
221
],
[
223
],
[
225,
227
],
[
229
],
[
231,
233
],
[
235
],
[
237,
239
],
[
241
],
[
243
],
[
247,
249
],
[
251
],
[
255,
257
],
[
259
],
[
261,
263,
265
],
[
267,
269
],
[
273
],
[
275,
277
],
[
279
],
[
291,
293
],
[
295
],
[
297
],
[
299
],
[
303,
305
],
[
307
],
[
309
],
[
311
],
[
315
],
[
317,
319
],
[
323
],
[
327
],
[
329,
331
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369,
371
],
[
373
],
[
375,
377
],
[
379
],
[
381
],
[
383
],
[
385
],
[
387
],
[
389
],
[
391
],
[
393
],
[
395
],
[
397
],
[
399,
401,
403
],
[
405,
407
],
[
409
],
[
411
],
[
413
],
[
415,
417,
419
],
[
421,
423
],
[
427,
429
],
[
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445,
447,
449
],
[
451
],
[
453
],
[
455
],
[
459
],
[
461
],
[
467
],
[
469
],
[
471
],
[
473,
475
],
[
477
],
[
479
],
[
481
],
[
483
],
[
485
],
[
487
],
[
489
],
[
491
],
[
493
],
[
495
],
[
497
],
[
499
],
[
501
],
[
503
],
[
505
],
[
507
],
[
509
],
[
511
],
[
513
],
[
515
],
[
517
],
[
521
],
[
523
],
[
529
],
[
531
],
[
533
],
[
535
],
[
539,
541
],
[
543
]
] |
7,001 |
static int str_read_packet(AVFormatContext *s,
AVPacket *ret_pkt)
{
AVIOContext *pb = s->pb;
StrDemuxContext *str = s->priv_data;
unsigned char sector[RAW_CD_SECTOR_SIZE];
int channel;
AVPacket *pkt;
AVStream *st;
while (1) {
if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
return AVERROR(EIO);
channel = sector[0x11];
if (channel >= 32)
return AVERROR_INVALIDDATA;
switch (sector[0x12] & CDXA_TYPE_MASK) {
case CDXA_TYPE_DATA:
case CDXA_TYPE_VIDEO:
{
int current_sector = AV_RL16(§or[0x1C]);
int sector_count = AV_RL16(§or[0x1E]);
int frame_size = AV_RL32(§or[0x24]);
if(!( frame_size>=0
&& current_sector < sector_count
&& sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
av_log(s, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", current_sector, sector_count, frame_size);
break;
}
if(str->channels[channel].video_stream_index < 0){
/* allocate a new AVStream */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 15);
str->channels[channel].video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MDEC;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = AV_RL16(§or[0x28]);
st->codec->height = AV_RL16(§or[0x2A]);
}
/* if this is the first sector of the frame, allocate a pkt */
pkt = &str->channels[channel].tmp_pkt;
if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
if(pkt->data)
av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
av_free_packet(pkt);
if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
return AVERROR(EIO);
pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;
pkt->stream_index =
str->channels[channel].video_stream_index;
}
memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
sector + VIDEO_DATA_HEADER_SIZE,
VIDEO_DATA_CHUNK_SIZE);
if (current_sector == sector_count-1) {
pkt->size= frame_size;
*ret_pkt = *pkt;
pkt->data= NULL;
pkt->size= -1;
pkt->buf = NULL;
#if FF_API_DESTRUCT_PACKET
FF_DISABLE_DEPRECATION_WARNINGS
pkt->destruct = NULL;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
return 0;
}
}
break;
case CDXA_TYPE_AUDIO:
if(str->channels[channel].audio_stream_index < 0){
int fmt = sector[0x13];
/* allocate a new AVStream */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
str->channels[channel].audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ADPCM_XA;
st->codec->codec_tag = 0; /* no fourcc */
if (fmt & 1) {
st->codec->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
} else {
st->codec->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO;
}
st->codec->sample_rate = (fmt&4)?18900:37800;
// st->codec->bit_rate = 0; //FIXME;
st->codec->block_align = 128;
avpriv_set_pts_info(st, 64, 18 * 224 / st->codec->channels,
st->codec->sample_rate);
st->start_time = 0;
}
pkt = ret_pkt;
if (av_new_packet(pkt, 2304))
return AVERROR(EIO);
memcpy(pkt->data,sector+24,2304);
pkt->stream_index =
str->channels[channel].audio_stream_index;
pkt->duration = 1;
return 0;
default:
av_log(s, AV_LOG_WARNING, "Unknown sector type %02X\n", sector[0x12]);
/* drop the sector and move on */
break;
}
if (url_feof(pb))
return AVERROR(EIO);
}
}
| true |
FFmpeg
|
4ecac816780dbb3d3297885856bde6e53a5f7708
|
static int str_read_packet(AVFormatContext *s,
AVPacket *ret_pkt)
{
AVIOContext *pb = s->pb;
StrDemuxContext *str = s->priv_data;
unsigned char sector[RAW_CD_SECTOR_SIZE];
int channel;
AVPacket *pkt;
AVStream *st;
while (1) {
if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
return AVERROR(EIO);
channel = sector[0x11];
if (channel >= 32)
return AVERROR_INVALIDDATA;
switch (sector[0x12] & CDXA_TYPE_MASK) {
case CDXA_TYPE_DATA:
case CDXA_TYPE_VIDEO:
{
int current_sector = AV_RL16(§or[0x1C]);
int sector_count = AV_RL16(§or[0x1E]);
int frame_size = AV_RL32(§or[0x24]);
if(!( frame_size>=0
&& current_sector < sector_count
&& sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
av_log(s, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", current_sector, sector_count, frame_size);
break;
}
if(str->channels[channel].video_stream_index < 0){
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 15);
str->channels[channel].video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MDEC;
st->codec->codec_tag = 0;
st->codec->width = AV_RL16(§or[0x28]);
st->codec->height = AV_RL16(§or[0x2A]);
}
pkt = &str->channels[channel].tmp_pkt;
if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
if(pkt->data)
av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
av_free_packet(pkt);
if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
return AVERROR(EIO);
pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;
pkt->stream_index =
str->channels[channel].video_stream_index;
}
memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
sector + VIDEO_DATA_HEADER_SIZE,
VIDEO_DATA_CHUNK_SIZE);
if (current_sector == sector_count-1) {
pkt->size= frame_size;
*ret_pkt = *pkt;
pkt->data= NULL;
pkt->size= -1;
pkt->buf = NULL;
#if FF_API_DESTRUCT_PACKET
FF_DISABLE_DEPRECATION_WARNINGS
pkt->destruct = NULL;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
return 0;
}
}
break;
case CDXA_TYPE_AUDIO:
if(str->channels[channel].audio_stream_index < 0){
int fmt = sector[0x13];
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
str->channels[channel].audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ADPCM_XA;
st->codec->codec_tag = 0;
if (fmt & 1) {
st->codec->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
} else {
st->codec->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO;
}
st->codec->sample_rate = (fmt&4)?18900:37800;
st->codec->block_align = 128;
avpriv_set_pts_info(st, 64, 18 * 224 / st->codec->channels,
st->codec->sample_rate);
st->start_time = 0;
}
pkt = ret_pkt;
if (av_new_packet(pkt, 2304))
return AVERROR(EIO);
memcpy(pkt->data,sector+24,2304);
pkt->stream_index =
str->channels[channel].audio_stream_index;
pkt->duration = 1;
return 0;
default:
av_log(s, AV_LOG_WARNING, "Unknown sector type %02X\n", sector[0x12]);
break;
}
if (url_feof(pb))
return AVERROR(EIO);
}
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVFormatContext *VAR_0,
AVPacket *VAR_1)
{
AVIOContext *pb = VAR_0->pb;
StrDemuxContext *str = VAR_0->priv_data;
unsigned char VAR_2[RAW_CD_SECTOR_SIZE];
int VAR_3;
AVPacket *pkt;
AVStream *st;
while (1) {
if (avio_read(pb, VAR_2, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
return AVERROR(EIO);
VAR_3 = VAR_2[0x11];
if (VAR_3 >= 32)
return AVERROR_INVALIDDATA;
switch (VAR_2[0x12] & CDXA_TYPE_MASK) {
case CDXA_TYPE_DATA:
case CDXA_TYPE_VIDEO:
{
int VAR_4 = AV_RL16(&VAR_2[0x1C]);
int VAR_5 = AV_RL16(&VAR_2[0x1E]);
int VAR_6 = AV_RL32(&VAR_2[0x24]);
if(!( VAR_6>=0
&& VAR_4 < VAR_5
&& VAR_5*VIDEO_DATA_CHUNK_SIZE >=VAR_6)){
av_log(VAR_0, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", VAR_4, VAR_5, VAR_6);
break;
}
if(str->channels[VAR_3].video_stream_index < 0){
st = avformat_new_stream(VAR_0, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 15);
str->channels[VAR_3].video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MDEC;
st->codec->codec_tag = 0;
st->codec->width = AV_RL16(&VAR_2[0x28]);
st->codec->height = AV_RL16(&VAR_2[0x2A]);
}
pkt = &str->channels[VAR_3].tmp_pkt;
if(pkt->size != VAR_5*VIDEO_DATA_CHUNK_SIZE){
if(pkt->data)
av_log(VAR_0, AV_LOG_ERROR, "missmatching VAR_5\n");
av_free_packet(pkt);
if (av_new_packet(pkt, VAR_5*VIDEO_DATA_CHUNK_SIZE))
return AVERROR(EIO);
pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;
pkt->stream_index =
str->channels[VAR_3].video_stream_index;
}
memcpy(pkt->data + VAR_4*VIDEO_DATA_CHUNK_SIZE,
VAR_2 + VIDEO_DATA_HEADER_SIZE,
VIDEO_DATA_CHUNK_SIZE);
if (VAR_4 == VAR_5-1) {
pkt->size= VAR_6;
*VAR_1 = *pkt;
pkt->data= NULL;
pkt->size= -1;
pkt->buf = NULL;
#if FF_API_DESTRUCT_PACKET
FF_DISABLE_DEPRECATION_WARNINGS
pkt->destruct = NULL;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
return 0;
}
}
break;
case CDXA_TYPE_AUDIO:
if(str->channels[VAR_3].audio_stream_index < 0){
int VAR_7 = VAR_2[0x13];
st = avformat_new_stream(VAR_0, NULL);
if (!st)
return AVERROR(ENOMEM);
str->channels[VAR_3].audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ADPCM_XA;
st->codec->codec_tag = 0;
if (VAR_7 & 1) {
st->codec->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
} else {
st->codec->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO;
}
st->codec->sample_rate = (VAR_7&4)?18900:37800;
st->codec->block_align = 128;
avpriv_set_pts_info(st, 64, 18 * 224 / st->codec->channels,
st->codec->sample_rate);
st->start_time = 0;
}
pkt = VAR_1;
if (av_new_packet(pkt, 2304))
return AVERROR(EIO);
memcpy(pkt->data,VAR_2+24,2304);
pkt->stream_index =
str->channels[VAR_3].audio_stream_index;
pkt->duration = 1;
return 0;
default:
av_log(VAR_0, AV_LOG_WARNING, "Unknown VAR_2 type %02X\n", VAR_2[0x12]);
break;
}
if (url_feof(pb))
return AVERROR(EIO);
}
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0,\nAVPacket *VAR_1)\n{",
"AVIOContext *pb = VAR_0->pb;",
"StrDemuxContext *str = VAR_0->priv_data;",
"unsigned char VAR_2[RAW_CD_SECTOR_SIZE];",
"int VAR_3;",
"AVPacket *pkt;",
"AVStream *st;",
"while (1) {",
"if (avio_read(pb, VAR_2, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)\nreturn AVERROR(EIO);",
"VAR_3 = VAR_2[0x11];",
"if (VAR_3 >= 32)\nreturn AVERROR_INVALIDDATA;",
"switch (VAR_2[0x12] & CDXA_TYPE_MASK) {",
"case CDXA_TYPE_DATA:\ncase CDXA_TYPE_VIDEO:\n{",
"int VAR_4 = AV_RL16(&VAR_2[0x1C]);",
"int VAR_5 = AV_RL16(&VAR_2[0x1E]);",
"int VAR_6 = AV_RL32(&VAR_2[0x24]);",
"if(!( VAR_6>=0\n&& VAR_4 < VAR_5\n&& VAR_5*VIDEO_DATA_CHUNK_SIZE >=VAR_6)){",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid parameters %d %d %d\\n\", VAR_4, VAR_5, VAR_6);",
"break;",
"}",
"if(str->channels[VAR_3].video_stream_index < 0){",
"st = avformat_new_stream(VAR_0, NULL);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"avpriv_set_pts_info(st, 64, 1, 15);",
"str->channels[VAR_3].video_stream_index = st->index;",
"st->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"st->codec->codec_id = AV_CODEC_ID_MDEC;",
"st->codec->codec_tag = 0;",
"st->codec->width = AV_RL16(&VAR_2[0x28]);",
"st->codec->height = AV_RL16(&VAR_2[0x2A]);",
"}",
"pkt = &str->channels[VAR_3].tmp_pkt;",
"if(pkt->size != VAR_5*VIDEO_DATA_CHUNK_SIZE){",
"if(pkt->data)\nav_log(VAR_0, AV_LOG_ERROR, \"missmatching VAR_5\\n\");",
"av_free_packet(pkt);",
"if (av_new_packet(pkt, VAR_5*VIDEO_DATA_CHUNK_SIZE))\nreturn AVERROR(EIO);",
"pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;",
"pkt->stream_index =\nstr->channels[VAR_3].video_stream_index;",
"}",
"memcpy(pkt->data + VAR_4*VIDEO_DATA_CHUNK_SIZE,\nVAR_2 + VIDEO_DATA_HEADER_SIZE,\nVIDEO_DATA_CHUNK_SIZE);",
"if (VAR_4 == VAR_5-1) {",
"pkt->size= VAR_6;",
"*VAR_1 = *pkt;",
"pkt->data= NULL;",
"pkt->size= -1;",
"pkt->buf = NULL;",
"#if FF_API_DESTRUCT_PACKET\nFF_DISABLE_DEPRECATION_WARNINGS\npkt->destruct = NULL;",
"FF_ENABLE_DEPRECATION_WARNINGS\n#endif\nreturn 0;",
"}",
"}",
"break;",
"case CDXA_TYPE_AUDIO:\nif(str->channels[VAR_3].audio_stream_index < 0){",
"int VAR_7 = VAR_2[0x13];",
"st = avformat_new_stream(VAR_0, NULL);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"str->channels[VAR_3].audio_stream_index = st->index;",
"st->codec->codec_type = AVMEDIA_TYPE_AUDIO;",
"st->codec->codec_id = AV_CODEC_ID_ADPCM_XA;",
"st->codec->codec_tag = 0;",
"if (VAR_7 & 1) {",
"st->codec->channels = 2;",
"st->codec->channel_layout = AV_CH_LAYOUT_STEREO;",
"} else {",
"st->codec->channels = 1;",
"st->codec->channel_layout = AV_CH_LAYOUT_MONO;",
"}",
"st->codec->sample_rate = (VAR_7&4)?18900:37800;",
"st->codec->block_align = 128;",
"avpriv_set_pts_info(st, 64, 18 * 224 / st->codec->channels,\nst->codec->sample_rate);",
"st->start_time = 0;",
"}",
"pkt = VAR_1;",
"if (av_new_packet(pkt, 2304))\nreturn AVERROR(EIO);",
"memcpy(pkt->data,VAR_2+24,2304);",
"pkt->stream_index =\nstr->channels[VAR_3].audio_stream_index;",
"pkt->duration = 1;",
"return 0;",
"default:\nav_log(VAR_0, AV_LOG_WARNING, \"Unknown VAR_2 type %02X\\n\", VAR_2[0x12]);",
"break;",
"}",
"if (url_feof(pb))\nreturn AVERROR(EIO);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25,
27
],
[
31
],
[
33,
35
],
[
39
],
[
43,
45,
47
],
[
51
],
[
53
],
[
55
],
[
59,
61,
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
77
],
[
79,
81
],
[
83
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
107
],
[
111
],
[
113,
115
],
[
117
],
[
119,
121
],
[
126
],
[
128,
130
],
[
132
],
[
136,
138,
140
],
[
144
],
[
146
],
[
148
],
[
150
],
[
152
],
[
154
],
[
156,
158,
160
],
[
162,
164,
166
],
[
168
],
[
172
],
[
174
],
[
178,
180
],
[
182
],
[
186
],
[
188,
190
],
[
194
],
[
198
],
[
200
],
[
202
],
[
204
],
[
206
],
[
208
],
[
210
],
[
212
],
[
214
],
[
216
],
[
218
],
[
222
],
[
226,
228
],
[
230
],
[
232
],
[
234
],
[
236,
238
],
[
240
],
[
244,
246
],
[
248
],
[
250
],
[
252,
254
],
[
258
],
[
260
],
[
264,
266
],
[
268
],
[
270
]
] |
7,002 |
char *object_property_print(Object *obj, const char *name, bool human,
Error **errp)
{
StringOutputVisitor *mo;
char *string;
mo = string_output_visitor_new(human);
object_property_get(obj, string_output_get_visitor(mo), name, errp);
string = string_output_get_string(mo);
string_output_visitor_cleanup(mo);
return string;
}
| true |
qemu
|
3a53009fa044a554dbdeacf30a6b8ea3eb02fe63
|
char *object_property_print(Object *obj, const char *name, bool human,
Error **errp)
{
StringOutputVisitor *mo;
char *string;
mo = string_output_visitor_new(human);
object_property_get(obj, string_output_get_visitor(mo), name, errp);
string = string_output_get_string(mo);
string_output_visitor_cleanup(mo);
return string;
}
|
{
"code": [
" char *string;",
" object_property_get(obj, string_output_get_visitor(mo), name, errp);"
],
"line_no": [
9,
15
]
}
|
char *FUNC_0(Object *VAR_0, const char *VAR_1, bool VAR_2,
Error **VAR_3)
{
StringOutputVisitor *mo;
char *VAR_4;
mo = string_output_visitor_new(VAR_2);
object_property_get(VAR_0, string_output_get_visitor(mo), VAR_1, VAR_3);
VAR_4 = string_output_get_string(mo);
string_output_visitor_cleanup(mo);
return VAR_4;
}
|
[
"char *FUNC_0(Object *VAR_0, const char *VAR_1, bool VAR_2,\nError **VAR_3)\n{",
"StringOutputVisitor *mo;",
"char *VAR_4;",
"mo = string_output_visitor_new(VAR_2);",
"object_property_get(VAR_0, string_output_get_visitor(mo), VAR_1, VAR_3);",
"VAR_4 = string_output_get_string(mo);",
"string_output_visitor_cleanup(mo);",
"return VAR_4;",
"}"
] |
[
0,
0,
1,
0,
1,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
7,003 |
static void virtio_gpu_resource_create_2d(VirtIOGPU *g,
struct virtio_gpu_ctrl_command *cmd)
{
pixman_format_code_t pformat;
struct virtio_gpu_simple_resource *res;
struct virtio_gpu_resource_create_2d c2d;
VIRTIO_GPU_FILL_CMD(c2d);
trace_virtio_gpu_cmd_res_create_2d(c2d.resource_id, c2d.format,
c2d.width, c2d.height);
if (c2d.resource_id == 0) {
qemu_log_mask(LOG_GUEST_ERROR, "%s: resource id 0 is not allowed\n",
__func__);
cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;
return;
}
res = virtio_gpu_find_resource(g, c2d.resource_id);
if (res) {
qemu_log_mask(LOG_GUEST_ERROR, "%s: resource already exists %d\n",
__func__, c2d.resource_id);
cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;
return;
}
res = g_new0(struct virtio_gpu_simple_resource, 1);
res->width = c2d.width;
res->height = c2d.height;
res->format = c2d.format;
res->resource_id = c2d.resource_id;
pformat = get_pixman_format(c2d.format);
if (!pformat) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: host couldn't handle guest format %d\n",
__func__, c2d.format);
g_free(res);
cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;
return;
}
res->image = pixman_image_create_bits(pformat,
c2d.width,
c2d.height,
NULL, 0);
if (!res->image) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: resource creation failed %d %d %d\n",
__func__, c2d.resource_id, c2d.width, c2d.height);
g_free(res);
cmd->error = VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY;
return;
}
QTAILQ_INSERT_HEAD(&g->reslist, res, next);
}
| true |
qemu
|
9b7621bca2f70dc1a9815d50f05261296a8ae932
|
static void virtio_gpu_resource_create_2d(VirtIOGPU *g,
struct virtio_gpu_ctrl_command *cmd)
{
pixman_format_code_t pformat;
struct virtio_gpu_simple_resource *res;
struct virtio_gpu_resource_create_2d c2d;
VIRTIO_GPU_FILL_CMD(c2d);
trace_virtio_gpu_cmd_res_create_2d(c2d.resource_id, c2d.format,
c2d.width, c2d.height);
if (c2d.resource_id == 0) {
qemu_log_mask(LOG_GUEST_ERROR, "%s: resource id 0 is not allowed\n",
__func__);
cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;
return;
}
res = virtio_gpu_find_resource(g, c2d.resource_id);
if (res) {
qemu_log_mask(LOG_GUEST_ERROR, "%s: resource already exists %d\n",
__func__, c2d.resource_id);
cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;
return;
}
res = g_new0(struct virtio_gpu_simple_resource, 1);
res->width = c2d.width;
res->height = c2d.height;
res->format = c2d.format;
res->resource_id = c2d.resource_id;
pformat = get_pixman_format(c2d.format);
if (!pformat) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: host couldn't handle guest format %d\n",
__func__, c2d.format);
g_free(res);
cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;
return;
}
res->image = pixman_image_create_bits(pformat,
c2d.width,
c2d.height,
NULL, 0);
if (!res->image) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: resource creation failed %d %d %d\n",
__func__, c2d.resource_id, c2d.width, c2d.height);
g_free(res);
cmd->error = VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY;
return;
}
QTAILQ_INSERT_HEAD(&g->reslist, res, next);
}
|
{
"code": [
" res->image = pixman_image_create_bits(pformat,",
" c2d.width,",
" c2d.height,",
" NULL, 0);"
],
"line_no": [
85,
87,
89,
91
]
}
|
static void FUNC_0(VirtIOGPU *VAR_0,
struct virtio_gpu_ctrl_command *VAR_1)
{
pixman_format_code_t pformat;
struct virtio_gpu_simple_resource *VAR_2;
struct FUNC_0 VAR_3;
VIRTIO_GPU_FILL_CMD(VAR_3);
trace_virtio_gpu_cmd_res_create_2d(VAR_3.resource_id, VAR_3.format,
VAR_3.width, VAR_3.height);
if (VAR_3.resource_id == 0) {
qemu_log_mask(LOG_GUEST_ERROR, "%s: resource id 0 is not allowed\n",
__func__);
VAR_1->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;
return;
}
VAR_2 = virtio_gpu_find_resource(VAR_0, VAR_3.resource_id);
if (VAR_2) {
qemu_log_mask(LOG_GUEST_ERROR, "%s: resource already exists %d\n",
__func__, VAR_3.resource_id);
VAR_1->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;
return;
}
VAR_2 = g_new0(struct virtio_gpu_simple_resource, 1);
VAR_2->width = VAR_3.width;
VAR_2->height = VAR_3.height;
VAR_2->format = VAR_3.format;
VAR_2->resource_id = VAR_3.resource_id;
pformat = get_pixman_format(VAR_3.format);
if (!pformat) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: host couldn't handle guest format %d\n",
__func__, VAR_3.format);
g_free(VAR_2);
VAR_1->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;
return;
}
VAR_2->image = pixman_image_create_bits(pformat,
VAR_3.width,
VAR_3.height,
NULL, 0);
if (!VAR_2->image) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: resource creation failed %d %d %d\n",
__func__, VAR_3.resource_id, VAR_3.width, VAR_3.height);
g_free(VAR_2);
VAR_1->error = VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY;
return;
}
QTAILQ_INSERT_HEAD(&VAR_0->reslist, VAR_2, next);
}
|
[
"static void FUNC_0(VirtIOGPU *VAR_0,\nstruct virtio_gpu_ctrl_command *VAR_1)\n{",
"pixman_format_code_t pformat;",
"struct virtio_gpu_simple_resource *VAR_2;",
"struct FUNC_0 VAR_3;",
"VIRTIO_GPU_FILL_CMD(VAR_3);",
"trace_virtio_gpu_cmd_res_create_2d(VAR_3.resource_id, VAR_3.format,\nVAR_3.width, VAR_3.height);",
"if (VAR_3.resource_id == 0) {",
"qemu_log_mask(LOG_GUEST_ERROR, \"%s: resource id 0 is not allowed\\n\",\n__func__);",
"VAR_1->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;",
"return;",
"}",
"VAR_2 = virtio_gpu_find_resource(VAR_0, VAR_3.resource_id);",
"if (VAR_2) {",
"qemu_log_mask(LOG_GUEST_ERROR, \"%s: resource already exists %d\\n\",\n__func__, VAR_3.resource_id);",
"VAR_1->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID;",
"return;",
"}",
"VAR_2 = g_new0(struct virtio_gpu_simple_resource, 1);",
"VAR_2->width = VAR_3.width;",
"VAR_2->height = VAR_3.height;",
"VAR_2->format = VAR_3.format;",
"VAR_2->resource_id = VAR_3.resource_id;",
"pformat = get_pixman_format(VAR_3.format);",
"if (!pformat) {",
"qemu_log_mask(LOG_GUEST_ERROR,\n\"%s: host couldn't handle guest format %d\\n\",\n__func__, VAR_3.format);",
"g_free(VAR_2);",
"VAR_1->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER;",
"return;",
"}",
"VAR_2->image = pixman_image_create_bits(pformat,\nVAR_3.width,\nVAR_3.height,\nNULL, 0);",
"if (!VAR_2->image) {",
"qemu_log_mask(LOG_GUEST_ERROR,\n\"%s: resource creation failed %d %d %d\\n\",\n__func__, VAR_3.resource_id, VAR_3.width, VAR_3.height);",
"g_free(VAR_2);",
"VAR_1->error = VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY;",
"return;",
"}",
"QTAILQ_INSERT_HEAD(&VAR_0->reslist, VAR_2, next);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17,
19
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71,
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85,
87,
89,
91
],
[
95
],
[
97,
99,
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
113
],
[
115
]
] |
7,005 |
int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
int nb_clusters)
{
BDRVQcowState *s = bs->opaque;
uint64_t cluster_index;
uint64_t old_free_cluster_index;
uint64_t i;
int refcount, ret;
assert(nb_clusters >= 0);
if (nb_clusters == 0) {
return 0;
}
/* Check how many clusters there are free */
cluster_index = offset >> s->cluster_bits;
for(i = 0; i < nb_clusters; i++) {
refcount = get_refcount(bs, cluster_index++);
if (refcount < 0) {
return refcount;
} else if (refcount != 0) {
break;
}
}
/* And then allocate them */
old_free_cluster_index = s->free_cluster_index;
s->free_cluster_index = cluster_index + i;
ret = update_refcount(bs, offset, i << s->cluster_bits, 1,
QCOW2_DISCARD_NEVER);
if (ret < 0) {
return ret;
}
s->free_cluster_index = old_free_cluster_index;
return i;
}
| true |
qemu
|
b106ad9185f35fc4ad669555ad0e79e276083bd7
|
int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
int nb_clusters)
{
BDRVQcowState *s = bs->opaque;
uint64_t cluster_index;
uint64_t old_free_cluster_index;
uint64_t i;
int refcount, ret;
assert(nb_clusters >= 0);
if (nb_clusters == 0) {
return 0;
}
cluster_index = offset >> s->cluster_bits;
for(i = 0; i < nb_clusters; i++) {
refcount = get_refcount(bs, cluster_index++);
if (refcount < 0) {
return refcount;
} else if (refcount != 0) {
break;
}
}
old_free_cluster_index = s->free_cluster_index;
s->free_cluster_index = cluster_index + i;
ret = update_refcount(bs, offset, i << s->cluster_bits, 1,
QCOW2_DISCARD_NEVER);
if (ret < 0) {
return ret;
}
s->free_cluster_index = old_free_cluster_index;
return i;
}
|
{
"code": [
" return 0;",
" s->free_cluster_index = old_free_cluster_index;",
" uint64_t old_free_cluster_index;",
" cluster_index = offset >> s->cluster_bits;",
" for(i = 0; i < nb_clusters; i++) {",
" refcount = get_refcount(bs, cluster_index++);",
" if (refcount < 0) {",
" return refcount;",
" } else if (refcount != 0) {",
" break;",
" old_free_cluster_index = s->free_cluster_index;",
" s->free_cluster_index = cluster_index + i;",
" ret = update_refcount(bs, offset, i << s->cluster_bits, 1,",
" QCOW2_DISCARD_NEVER);",
" s->free_cluster_index = old_free_cluster_index;"
],
"line_no": [
23,
73,
11,
31,
33,
35,
39,
41,
43,
45,
55,
57,
61,
63,
73
]
}
|
int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,
int VAR_2)
{
BDRVQcowState *s = VAR_0->opaque;
uint64_t cluster_index;
uint64_t old_free_cluster_index;
uint64_t i;
int VAR_3, VAR_4;
assert(VAR_2 >= 0);
if (VAR_2 == 0) {
return 0;
}
cluster_index = VAR_1 >> s->cluster_bits;
for(i = 0; i < VAR_2; i++) {
VAR_3 = get_refcount(VAR_0, cluster_index++);
if (VAR_3 < 0) {
return VAR_3;
} else if (VAR_3 != 0) {
break;
}
}
old_free_cluster_index = s->free_cluster_index;
s->free_cluster_index = cluster_index + i;
VAR_4 = update_refcount(VAR_0, VAR_1, i << s->cluster_bits, 1,
QCOW2_DISCARD_NEVER);
if (VAR_4 < 0) {
return VAR_4;
}
s->free_cluster_index = old_free_cluster_index;
return i;
}
|
[
"int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,\nint VAR_2)\n{",
"BDRVQcowState *s = VAR_0->opaque;",
"uint64_t cluster_index;",
"uint64_t old_free_cluster_index;",
"uint64_t i;",
"int VAR_3, VAR_4;",
"assert(VAR_2 >= 0);",
"if (VAR_2 == 0) {",
"return 0;",
"}",
"cluster_index = VAR_1 >> s->cluster_bits;",
"for(i = 0; i < VAR_2; i++) {",
"VAR_3 = get_refcount(VAR_0, cluster_index++);",
"if (VAR_3 < 0) {",
"return VAR_3;",
"} else if (VAR_3 != 0) {",
"break;",
"}",
"}",
"old_free_cluster_index = s->free_cluster_index;",
"s->free_cluster_index = cluster_index + i;",
"VAR_4 = update_refcount(VAR_0, VAR_1, i << s->cluster_bits, 1,\nQCOW2_DISCARD_NEVER);",
"if (VAR_4 < 0) {",
"return VAR_4;",
"}",
"s->free_cluster_index = old_free_cluster_index;",
"return i;",
"}"
] |
[
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0,
1,
1,
1,
0,
0,
0,
1,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
55
],
[
57
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
77
],
[
79
]
] |
7,006 |
static int decode_chunks(AVCodecContext *avctx,
AVFrame *picture, int *got_output,
const uint8_t *buf, int buf_size)
{
Mpeg1Context *s = avctx->priv_data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
const uint8_t *buf_ptr = buf;
const uint8_t *buf_end = buf + buf_size;
int ret, input_size;
int last_code = 0, skip_frame = 0;
int picture_start_code_seen = 0;
for (;;) {
/* find next start code */
uint32_t start_code = -1;
buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
if (start_code > 0x1ff) {
if (!skip_frame) {
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
!avctx->hwaccel) {
int i;
av_assert0(avctx->thread_count > 1);
avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
for (i = 0; i < s->slice_count; i++)
s2->er.error_count += s2->thread_context[i]->er.error_count;
ret = slice_end(avctx, picture);
if (ret < 0)
return ret;
else if (ret) {
if (s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
*got_output = 1;
s2->pict_type = 0;
return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
input_size = buf_end - buf_ptr;
if (avctx->debug & FF_DEBUG_STARTCODE) {
av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
/* prepare data for next start code */
switch (start_code) {
case SEQ_START_CODE:
if (last_code == 0) {
mpeg1_decode_sequence(avctx, buf_ptr, input_size);
if(buf != avctx->extradata)
s->sync=1;
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
case PICTURE_START_CODE:
if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
/* If it's a frame picture, there can't be more than one picture header.
Yet, it does happen and we need to handle it. */
av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
break;
picture_start_code_seen = 1;
if (s2->width <= 0 || s2->height <= 0) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
s2->width, s2->height);
if(s->tmpgexs){
s2->intra_dc_precision= 3;
s2->intra_matrix[0]= 1;
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
!avctx->hwaccel && s->slice_count) {
int i;
avctx->execute(avctx, slice_decode_thread,
s2->thread_context, NULL,
s->slice_count, sizeof(void*));
for (i = 0; i < s->slice_count; i++)
s2->er.error_count += s2->thread_context[i]->er.error_count;
s->slice_count = 0;
if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
ret = mpeg_decode_postinit(avctx);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
return ret;
/* we have a complete image: we try to decompress it */
if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
s2->pict_type = 0;
s2->first_slice = 1;
last_code = PICTURE_START_CODE;
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring pic after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
case EXT_START_CODE:
init_get_bits(&s2->gb, buf_ptr, input_size*8);
switch (get_bits(&s2->gb, 4)) {
case 0x1:
if (last_code == 0) {
mpeg_decode_sequence_extension(s);
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring seq ext after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
case 0x2:
mpeg_decode_sequence_display_extension(s);
break;
case 0x3:
mpeg_decode_quant_matrix_extension(s2);
break;
case 0x7:
mpeg_decode_picture_display_extension(s);
break;
case 0x8:
if (last_code == PICTURE_START_CODE) {
mpeg_decode_picture_coding_extension(s);
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
break;
case USER_START_CODE:
mpeg_decode_user_data(avctx, buf_ptr, input_size);
break;
case GOP_START_CODE:
if (last_code == 0) {
s2->first_field=0;
mpeg_decode_gop(avctx, buf_ptr, input_size);
s->sync=1;
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
default:
if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
if (s2->progressive_sequence && !s2->progressive_frame) {
s2->progressive_frame = 1;
av_log(s2->avctx, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n");
if (s2->picture_structure == 0 || (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
av_log(s2->avctx, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s2->picture_structure);
s2->picture_structure = PICT_FRAME;
if (s2->progressive_sequence && !s2->frame_pred_frame_dct) {
av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
if (s2->picture_structure == PICT_FRAME) {
s2->first_field = 0;
s2->v_edge_pos = 16 * s2->mb_height;
} else {
s2->first_field ^= 1;
s2->v_edge_pos = 8 * s2->mb_height;
memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE && last_code != 0) {
const int field_pic = s2->picture_structure != PICT_FRAME;
int mb_y = start_code - SLICE_MIN_START_CODE;
last_code = SLICE_MIN_START_CODE;
if(s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
mb_y += (*buf_ptr&0xE0)<<2;
mb_y <<= field_pic;
if (s2->picture_structure == PICT_BOTTOM_FIELD)
mb_y++;
if (mb_y >= s2->mb_height) {
av_log(s2->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
return -1;
if (s2->last_picture_ptr == NULL) {
/* Skip B-frames if we do not have reference frames and gop is not closed */
if (s2->pict_type == AV_PICTURE_TYPE_B) {
if (!s2->closed_gop) {
skip_frame = 1;
break;
if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->flags2 & CODEC_FLAG2_SHOW_ALL))
s->sync=1;
if (s2->next_picture_ptr == NULL) {
/* Skip P-frames if we do not have a reference frame or we have an invalid header. */
if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
skip_frame = 1;
break;
if ((avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type == AV_PICTURE_TYPE_B) ||
(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type != AV_PICTURE_TYPE_I) ||
avctx->skip_frame >= AVDISCARD_ALL) {
skip_frame = 1;
break;
if (!s->mpeg_enc_ctx_allocated)
break;
if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
if (mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
break;
if (!s2->pict_type) {
av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
if (s2->first_slice) {
skip_frame = 0;
s2->first_slice = 0;
if (mpeg_field_start(s2, buf, buf_size) < 0)
return -1;
if (!s2->current_picture_ptr) {
av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
!avctx->hwaccel) {
int threshold = (s2->mb_height * s->slice_count +
s2->slice_context_count / 2) /
s2->slice_context_count;
av_assert0(avctx->thread_count > 1);
if (threshold <= mb_y) {
MpegEncContext *thread_context = s2->thread_context[s->slice_count];
thread_context->start_mb_y = mb_y;
thread_context->end_mb_y = s2->mb_height;
if (s->slice_count) {
s2->thread_context[s->slice_count-1]->end_mb_y = mb_y;
ret = ff_update_duplicate_context(thread_context,
s2);
if (ret < 0)
return ret;
init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
s->slice_count++;
buf_ptr += 2; // FIXME add minimum number of bytes per slice
} else {
ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
emms_c();
if (ret < 0) {
if (avctx->err_recognition & AV_EF_EXPLODE)
return ret;
if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
} else {
ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, ER_AC_END | ER_DC_END | ER_MV_END);
break;
| true |
FFmpeg
|
97064019279d227669ea3db583a8a8aa47e970ba
|
static int decode_chunks(AVCodecContext *avctx,
AVFrame *picture, int *got_output,
const uint8_t *buf, int buf_size)
{
Mpeg1Context *s = avctx->priv_data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
const uint8_t *buf_ptr = buf;
const uint8_t *buf_end = buf + buf_size;
int ret, input_size;
int last_code = 0, skip_frame = 0;
int picture_start_code_seen = 0;
for (;;) {
uint32_t start_code = -1;
buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
if (start_code > 0x1ff) {
if (!skip_frame) {
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
!avctx->hwaccel) {
int i;
av_assert0(avctx->thread_count > 1);
avctx->execute(avctx, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
for (i = 0; i < s->slice_count; i++)
s2->er.error_count += s2->thread_context[i]->er.error_count;
ret = slice_end(avctx, picture);
if (ret < 0)
return ret;
else if (ret) {
if (s2->last_picture_ptr || s2->low_delay)
*got_output = 1;
s2->pict_type = 0;
return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
input_size = buf_end - buf_ptr;
if (avctx->debug & FF_DEBUG_STARTCODE) {
av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
switch (start_code) {
case SEQ_START_CODE:
if (last_code == 0) {
mpeg1_decode_sequence(avctx, buf_ptr, input_size);
if(buf != avctx->extradata)
s->sync=1;
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
case PICTURE_START_CODE:
if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
break;
picture_start_code_seen = 1;
if (s2->width <= 0 || s2->height <= 0) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
s2->width, s2->height);
if(s->tmpgexs){
s2->intra_dc_precision= 3;
s2->intra_matrix[0]= 1;
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
!avctx->hwaccel && s->slice_count) {
int i;
avctx->execute(avctx, slice_decode_thread,
s2->thread_context, NULL,
s->slice_count, sizeof(void*));
for (i = 0; i < s->slice_count; i++)
s2->er.error_count += s2->thread_context[i]->er.error_count;
s->slice_count = 0;
if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
ret = mpeg_decode_postinit(avctx);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
return ret;
if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
s2->pict_type = 0;
s2->first_slice = 1;
last_code = PICTURE_START_CODE;
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring pic after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
case EXT_START_CODE:
init_get_bits(&s2->gb, buf_ptr, input_size*8);
switch (get_bits(&s2->gb, 4)) {
case 0x1:
if (last_code == 0) {
mpeg_decode_sequence_extension(s);
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring seq ext after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
case 0x2:
mpeg_decode_sequence_display_extension(s);
break;
case 0x3:
mpeg_decode_quant_matrix_extension(s2);
break;
case 0x7:
mpeg_decode_picture_display_extension(s);
break;
case 0x8:
if (last_code == PICTURE_START_CODE) {
mpeg_decode_picture_coding_extension(s);
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
break;
case USER_START_CODE:
mpeg_decode_user_data(avctx, buf_ptr, input_size);
break;
case GOP_START_CODE:
if (last_code == 0) {
s2->first_field=0;
mpeg_decode_gop(avctx, buf_ptr, input_size);
s->sync=1;
} else {
av_log(avctx, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", last_code);
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
default:
if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
if (s2->progressive_sequence && !s2->progressive_frame) {
s2->progressive_frame = 1;
av_log(s2->avctx, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n");
if (s2->picture_structure == 0 || (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
av_log(s2->avctx, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s2->picture_structure);
s2->picture_structure = PICT_FRAME;
if (s2->progressive_sequence && !s2->frame_pred_frame_dct) {
av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
if (s2->picture_structure == PICT_FRAME) {
s2->first_field = 0;
s2->v_edge_pos = 16 * s2->mb_height;
} else {
s2->first_field ^= 1;
s2->v_edge_pos = 8 * s2->mb_height;
memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE && last_code != 0) {
const int field_pic = s2->picture_structure != PICT_FRAME;
int mb_y = start_code - SLICE_MIN_START_CODE;
last_code = SLICE_MIN_START_CODE;
if(s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
mb_y += (*buf_ptr&0xE0)<<2;
mb_y <<= field_pic;
if (s2->picture_structure == PICT_BOTTOM_FIELD)
mb_y++;
if (mb_y >= s2->mb_height) {
av_log(s2->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
return -1;
if (s2->last_picture_ptr == NULL) {
if (s2->pict_type == AV_PICTURE_TYPE_B) {
if (!s2->closed_gop) {
skip_frame = 1;
break;
if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->flags2 & CODEC_FLAG2_SHOW_ALL))
s->sync=1;
if (s2->next_picture_ptr == NULL) {
if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
skip_frame = 1;
break;
if ((avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type == AV_PICTURE_TYPE_B) ||
(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type != AV_PICTURE_TYPE_I) ||
avctx->skip_frame >= AVDISCARD_ALL) {
skip_frame = 1;
break;
if (!s->mpeg_enc_ctx_allocated)
break;
if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
if (mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
break;
if (!s2->pict_type) {
av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
if (avctx->err_recognition & AV_EF_EXPLODE)
break;
if (s2->first_slice) {
skip_frame = 0;
s2->first_slice = 0;
if (mpeg_field_start(s2, buf, buf_size) < 0)
return -1;
if (!s2->current_picture_ptr) {
av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
!avctx->hwaccel) {
int threshold = (s2->mb_height * s->slice_count +
s2->slice_context_count / 2) /
s2->slice_context_count;
av_assert0(avctx->thread_count > 1);
if (threshold <= mb_y) {
MpegEncContext *thread_context = s2->thread_context[s->slice_count];
thread_context->start_mb_y = mb_y;
thread_context->end_mb_y = s2->mb_height;
if (s->slice_count) {
s2->thread_context[s->slice_count-1]->end_mb_y = mb_y;
ret = ff_update_duplicate_context(thread_context,
s2);
if (ret < 0)
return ret;
init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
s->slice_count++;
buf_ptr += 2;
} else {
ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
emms_c();
if (ret < 0) {
if (avctx->err_recognition & AV_EF_EXPLODE)
return ret;
if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
} else {
ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, ER_AC_END | ER_DC_END | ER_MV_END);
break;
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVCodecContext *VAR_0,
AVFrame *VAR_1, int *VAR_2,
const uint8_t *VAR_3, int VAR_4)
{
Mpeg1Context *s = VAR_0->priv_data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
const uint8_t *VAR_5 = VAR_3;
const uint8_t *VAR_6 = VAR_3 + VAR_4;
int VAR_7, VAR_8;
int VAR_9 = 0, VAR_10 = 0;
int VAR_11 = 0;
for (;;) {
uint32_t start_code = -1;
VAR_5 = avpriv_find_start_code(VAR_5, VAR_6, &start_code);
if (start_code > 0x1ff) {
if (!VAR_10) {
if (HAVE_THREADS && (VAR_0->active_thread_type & FF_THREAD_SLICE) &&
!VAR_0->hwaccel) {
int VAR_13;
av_assert0(VAR_0->thread_count > 1);
VAR_0->execute(VAR_0, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));
for (VAR_13 = 0; VAR_13 < s->slice_count; VAR_13++)
s2->er.error_count += s2->thread_context[VAR_13]->er.error_count;
VAR_7 = slice_end(VAR_0, VAR_1);
if (VAR_7 < 0)
return VAR_7;
else if (VAR_7) {
if (s2->last_picture_ptr || s2->low_delay)
*VAR_2 = 1;
s2->pict_type = 0;
return FFMAX(0, VAR_5 - VAR_3 - s2->parse_context.last_index);
VAR_8 = VAR_6 - VAR_5;
if (VAR_0->debug & FF_DEBUG_STARTCODE) {
av_log(VAR_0, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, VAR_5-VAR_3, VAR_8);
switch (start_code) {
case SEQ_START_CODE:
if (VAR_9 == 0) {
mpeg1_decode_sequence(VAR_0, VAR_5, VAR_8);
if(VAR_3 != VAR_0->extradata)
s->sync=1;
} else {
av_log(VAR_0, AV_LOG_ERROR, "ignoring SEQ_START_CODE after %X\n", VAR_9);
if (VAR_0->err_recognition & AV_EF_EXPLODE)
break;
case PICTURE_START_CODE:
if (VAR_11 && s2->picture_structure == PICT_FRAME) {
av_log(VAR_0, AV_LOG_WARNING, "ignoring extra VAR_1 following a frame-VAR_1\n");
break;
VAR_11 = 1;
if (s2->width <= 0 || s2->height <= 0) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
s2->width, s2->height);
if(s->tmpgexs){
s2->intra_dc_precision= 3;
s2->intra_matrix[0]= 1;
if (HAVE_THREADS && (VAR_0->active_thread_type & FF_THREAD_SLICE) &&
!VAR_0->hwaccel && s->slice_count) {
int VAR_13;
VAR_0->execute(VAR_0, slice_decode_thread,
s2->thread_context, NULL,
s->slice_count, sizeof(void*));
for (VAR_13 = 0; VAR_13 < s->slice_count; VAR_13++)
s2->er.error_count += s2->thread_context[VAR_13]->er.error_count;
s->slice_count = 0;
if (VAR_9 == 0 || VAR_9 == SLICE_MIN_START_CODE) {
VAR_7 = mpeg_decode_postinit(VAR_0);
if (VAR_7 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "mpeg_decode_postinit() failure\n");
return VAR_7;
if (mpeg1_decode_picture(VAR_0, VAR_5, VAR_8) < 0)
s2->pict_type = 0;
s2->first_slice = 1;
VAR_9 = PICTURE_START_CODE;
} else {
av_log(VAR_0, AV_LOG_ERROR, "ignoring pic after %X\n", VAR_9);
if (VAR_0->err_recognition & AV_EF_EXPLODE)
break;
case EXT_START_CODE:
init_get_bits(&s2->gb, VAR_5, VAR_8*8);
switch (get_bits(&s2->gb, 4)) {
case 0x1:
if (VAR_9 == 0) {
mpeg_decode_sequence_extension(s);
} else {
av_log(VAR_0, AV_LOG_ERROR, "ignoring seq ext after %X\n", VAR_9);
if (VAR_0->err_recognition & AV_EF_EXPLODE)
break;
case 0x2:
mpeg_decode_sequence_display_extension(s);
break;
case 0x3:
mpeg_decode_quant_matrix_extension(s2);
break;
case 0x7:
mpeg_decode_picture_display_extension(s);
break;
case 0x8:
if (VAR_9 == PICTURE_START_CODE) {
mpeg_decode_picture_coding_extension(s);
} else {
av_log(VAR_0, AV_LOG_ERROR, "ignoring pic cod ext after %X\n", VAR_9);
if (VAR_0->err_recognition & AV_EF_EXPLODE)
break;
break;
case USER_START_CODE:
mpeg_decode_user_data(VAR_0, VAR_5, VAR_8);
break;
case GOP_START_CODE:
if (VAR_9 == 0) {
s2->first_field=0;
mpeg_decode_gop(VAR_0, VAR_5, VAR_8);
s->sync=1;
} else {
av_log(VAR_0, AV_LOG_ERROR, "ignoring GOP_START_CODE after %X\n", VAR_9);
if (VAR_0->err_recognition & AV_EF_EXPLODE)
break;
default:
if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE && VAR_9 == PICTURE_START_CODE) {
if (s2->progressive_sequence && !s2->progressive_frame) {
s2->progressive_frame = 1;
av_log(s2->VAR_0, AV_LOG_ERROR, "interlaced frame in progressive sequence, ignoring\n");
if (s2->picture_structure == 0 || (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
av_log(s2->VAR_0, AV_LOG_ERROR, "picture_structure %d invalid, ignoring\n", s2->picture_structure);
s2->picture_structure = PICT_FRAME;
if (s2->progressive_sequence && !s2->frame_pred_frame_dct) {
av_log(s2->VAR_0, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
if (s2->picture_structure == PICT_FRAME) {
s2->first_field = 0;
s2->v_edge_pos = 16 * s2->mb_height;
} else {
s2->first_field ^= 1;
s2->v_edge_pos = 8 * s2->mb_height;
memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE && VAR_9 != 0) {
const int VAR_13 = s2->picture_structure != PICT_FRAME;
int VAR_14 = start_code - SLICE_MIN_START_CODE;
VAR_9 = SLICE_MIN_START_CODE;
if(s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
VAR_14 += (*VAR_5&0xE0)<<2;
VAR_14 <<= VAR_13;
if (s2->picture_structure == PICT_BOTTOM_FIELD)
VAR_14++;
if (VAR_14 >= s2->mb_height) {
av_log(s2->VAR_0, AV_LOG_ERROR, "slice below image (%d >= %d)\n", VAR_14, s2->mb_height);
return -1;
if (s2->last_picture_ptr == NULL) {
if (s2->pict_type == AV_PICTURE_TYPE_B) {
if (!s2->closed_gop) {
VAR_10 = 1;
break;
if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->flags2 & CODEC_FLAG2_SHOW_ALL))
s->sync=1;
if (s2->next_picture_ptr == NULL) {
if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
VAR_10 = 1;
break;
if ((VAR_0->VAR_10 >= AVDISCARD_NONREF && s2->pict_type == AV_PICTURE_TYPE_B) ||
(VAR_0->VAR_10 >= AVDISCARD_NONKEY && s2->pict_type != AV_PICTURE_TYPE_I) ||
VAR_0->VAR_10 >= AVDISCARD_ALL) {
VAR_10 = 1;
break;
if (!s->mpeg_enc_ctx_allocated)
break;
if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
if (VAR_14 < VAR_0->skip_top || VAR_14 >= s2->mb_height - VAR_0->skip_bottom)
break;
if (!s2->pict_type) {
av_log(VAR_0, AV_LOG_ERROR, "Missing VAR_1 start code\n");
if (VAR_0->err_recognition & AV_EF_EXPLODE)
break;
if (s2->first_slice) {
VAR_10 = 0;
s2->first_slice = 0;
if (mpeg_field_start(s2, VAR_3, VAR_4) < 0)
return -1;
if (!s2->current_picture_ptr) {
av_log(VAR_0, AV_LOG_ERROR, "current_picture not initialized\n");
if (HAVE_THREADS && (VAR_0->active_thread_type & FF_THREAD_SLICE) &&
!VAR_0->hwaccel) {
int VAR_15 = (s2->mb_height * s->slice_count +
s2->slice_context_count / 2) /
s2->slice_context_count;
av_assert0(VAR_0->thread_count > 1);
if (VAR_15 <= VAR_14) {
MpegEncContext *thread_context = s2->thread_context[s->slice_count];
thread_context->start_mb_y = VAR_14;
thread_context->end_mb_y = s2->mb_height;
if (s->slice_count) {
s2->thread_context[s->slice_count-1]->end_mb_y = VAR_14;
VAR_7 = ff_update_duplicate_context(thread_context,
s2);
if (VAR_7 < 0)
return VAR_7;
init_get_bits(&thread_context->gb, VAR_5, VAR_8*8);
s->slice_count++;
VAR_5 += 2;
} else {
VAR_7 = mpeg_decode_slice(s2, VAR_14, &VAR_5, VAR_8);
emms_c();
if (VAR_7 < 0) {
if (VAR_0->err_recognition & AV_EF_EXPLODE)
return VAR_7;
if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->VAR_14, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
} else {
ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->VAR_14, ER_AC_END | ER_DC_END | ER_MV_END);
break;
|
[
"static int FUNC_0(AVCodecContext *VAR_0,\nAVFrame *VAR_1, int *VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{",
"Mpeg1Context *s = VAR_0->priv_data;",
"MpegEncContext *s2 = &s->mpeg_enc_ctx;",
"const uint8_t *VAR_5 = VAR_3;",
"const uint8_t *VAR_6 = VAR_3 + VAR_4;",
"int VAR_7, VAR_8;",
"int VAR_9 = 0, VAR_10 = 0;",
"int VAR_11 = 0;",
"for (;;) {",
"uint32_t start_code = -1;",
"VAR_5 = avpriv_find_start_code(VAR_5, VAR_6, &start_code);",
"if (start_code > 0x1ff) {",
"if (!VAR_10) {",
"if (HAVE_THREADS && (VAR_0->active_thread_type & FF_THREAD_SLICE) &&\n!VAR_0->hwaccel) {",
"int VAR_13;",
"av_assert0(VAR_0->thread_count > 1);",
"VAR_0->execute(VAR_0, slice_decode_thread, &s2->thread_context[0], NULL, s->slice_count, sizeof(void*));",
"for (VAR_13 = 0; VAR_13 < s->slice_count; VAR_13++)",
"s2->er.error_count += s2->thread_context[VAR_13]->er.error_count;",
"VAR_7 = slice_end(VAR_0, VAR_1);",
"if (VAR_7 < 0)\nreturn VAR_7;",
"else if (VAR_7) {",
"if (s2->last_picture_ptr || s2->low_delay)\n*VAR_2 = 1;",
"s2->pict_type = 0;",
"return FFMAX(0, VAR_5 - VAR_3 - s2->parse_context.last_index);",
"VAR_8 = VAR_6 - VAR_5;",
"if (VAR_0->debug & FF_DEBUG_STARTCODE) {",
"av_log(VAR_0, AV_LOG_DEBUG, \"%3X at %td left %d\\n\", start_code, VAR_5-VAR_3, VAR_8);",
"switch (start_code) {",
"case SEQ_START_CODE:\nif (VAR_9 == 0) {",
"mpeg1_decode_sequence(VAR_0, VAR_5, VAR_8);",
"if(VAR_3 != VAR_0->extradata)\ns->sync=1;",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"ignoring SEQ_START_CODE after %X\\n\", VAR_9);",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nbreak;",
"case PICTURE_START_CODE:\nif (VAR_11 && s2->picture_structure == PICT_FRAME) {",
"av_log(VAR_0, AV_LOG_WARNING, \"ignoring extra VAR_1 following a frame-VAR_1\\n\");",
"break;",
"VAR_11 = 1;",
"if (s2->width <= 0 || s2->height <= 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid frame dimensions %dx%d.\\n\",\ns2->width, s2->height);",
"if(s->tmpgexs){",
"s2->intra_dc_precision= 3;",
"s2->intra_matrix[0]= 1;",
"if (HAVE_THREADS && (VAR_0->active_thread_type & FF_THREAD_SLICE) &&\n!VAR_0->hwaccel && s->slice_count) {",
"int VAR_13;",
"VAR_0->execute(VAR_0, slice_decode_thread,\ns2->thread_context, NULL,\ns->slice_count, sizeof(void*));",
"for (VAR_13 = 0; VAR_13 < s->slice_count; VAR_13++)",
"s2->er.error_count += s2->thread_context[VAR_13]->er.error_count;",
"s->slice_count = 0;",
"if (VAR_9 == 0 || VAR_9 == SLICE_MIN_START_CODE) {",
"VAR_7 = mpeg_decode_postinit(VAR_0);",
"if (VAR_7 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"mpeg_decode_postinit() failure\\n\");",
"return VAR_7;",
"if (mpeg1_decode_picture(VAR_0, VAR_5, VAR_8) < 0)\ns2->pict_type = 0;",
"s2->first_slice = 1;",
"VAR_9 = PICTURE_START_CODE;",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"ignoring pic after %X\\n\", VAR_9);",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nbreak;",
"case EXT_START_CODE:\ninit_get_bits(&s2->gb, VAR_5, VAR_8*8);",
"switch (get_bits(&s2->gb, 4)) {",
"case 0x1:\nif (VAR_9 == 0) {",
"mpeg_decode_sequence_extension(s);",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"ignoring seq ext after %X\\n\", VAR_9);",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nbreak;",
"case 0x2:\nmpeg_decode_sequence_display_extension(s);",
"break;",
"case 0x3:\nmpeg_decode_quant_matrix_extension(s2);",
"break;",
"case 0x7:\nmpeg_decode_picture_display_extension(s);",
"break;",
"case 0x8:\nif (VAR_9 == PICTURE_START_CODE) {",
"mpeg_decode_picture_coding_extension(s);",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"ignoring pic cod ext after %X\\n\", VAR_9);",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nbreak;",
"break;",
"case USER_START_CODE:\nmpeg_decode_user_data(VAR_0, VAR_5, VAR_8);",
"break;",
"case GOP_START_CODE:\nif (VAR_9 == 0) {",
"s2->first_field=0;",
"mpeg_decode_gop(VAR_0, VAR_5, VAR_8);",
"s->sync=1;",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"ignoring GOP_START_CODE after %X\\n\", VAR_9);",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nbreak;",
"default:\nif (start_code >= SLICE_MIN_START_CODE &&\nstart_code <= SLICE_MAX_START_CODE && VAR_9 == PICTURE_START_CODE) {",
"if (s2->progressive_sequence && !s2->progressive_frame) {",
"s2->progressive_frame = 1;",
"av_log(s2->VAR_0, AV_LOG_ERROR, \"interlaced frame in progressive sequence, ignoring\\n\");",
"if (s2->picture_structure == 0 || (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {",
"av_log(s2->VAR_0, AV_LOG_ERROR, \"picture_structure %d invalid, ignoring\\n\", s2->picture_structure);",
"s2->picture_structure = PICT_FRAME;",
"if (s2->progressive_sequence && !s2->frame_pred_frame_dct) {",
"av_log(s2->VAR_0, AV_LOG_WARNING, \"invalid frame_pred_frame_dct\\n\");",
"if (s2->picture_structure == PICT_FRAME) {",
"s2->first_field = 0;",
"s2->v_edge_pos = 16 * s2->mb_height;",
"} else {",
"s2->first_field ^= 1;",
"s2->v_edge_pos = 8 * s2->mb_height;",
"memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);",
"if (start_code >= SLICE_MIN_START_CODE &&\nstart_code <= SLICE_MAX_START_CODE && VAR_9 != 0) {",
"const int VAR_13 = s2->picture_structure != PICT_FRAME;",
"int VAR_14 = start_code - SLICE_MIN_START_CODE;",
"VAR_9 = SLICE_MIN_START_CODE;",
"if(s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)\nVAR_14 += (*VAR_5&0xE0)<<2;",
"VAR_14 <<= VAR_13;",
"if (s2->picture_structure == PICT_BOTTOM_FIELD)\nVAR_14++;",
"if (VAR_14 >= s2->mb_height) {",
"av_log(s2->VAR_0, AV_LOG_ERROR, \"slice below image (%d >= %d)\\n\", VAR_14, s2->mb_height);",
"return -1;",
"if (s2->last_picture_ptr == NULL) {",
"if (s2->pict_type == AV_PICTURE_TYPE_B) {",
"if (!s2->closed_gop) {",
"VAR_10 = 1;",
"break;",
"if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->flags2 & CODEC_FLAG2_SHOW_ALL))\ns->sync=1;",
"if (s2->next_picture_ptr == NULL) {",
"if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {",
"VAR_10 = 1;",
"break;",
"if ((VAR_0->VAR_10 >= AVDISCARD_NONREF && s2->pict_type == AV_PICTURE_TYPE_B) ||\n(VAR_0->VAR_10 >= AVDISCARD_NONKEY && s2->pict_type != AV_PICTURE_TYPE_I) ||\nVAR_0->VAR_10 >= AVDISCARD_ALL) {",
"VAR_10 = 1;",
"break;",
"if (!s->mpeg_enc_ctx_allocated)\nbreak;",
"if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {",
"if (VAR_14 < VAR_0->skip_top || VAR_14 >= s2->mb_height - VAR_0->skip_bottom)\nbreak;",
"if (!s2->pict_type) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Missing VAR_1 start code\\n\");",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nbreak;",
"if (s2->first_slice) {",
"VAR_10 = 0;",
"s2->first_slice = 0;",
"if (mpeg_field_start(s2, VAR_3, VAR_4) < 0)\nreturn -1;",
"if (!s2->current_picture_ptr) {",
"av_log(VAR_0, AV_LOG_ERROR, \"current_picture not initialized\\n\");",
"if (HAVE_THREADS && (VAR_0->active_thread_type & FF_THREAD_SLICE) &&\n!VAR_0->hwaccel) {",
"int VAR_15 = (s2->mb_height * s->slice_count +\ns2->slice_context_count / 2) /\ns2->slice_context_count;",
"av_assert0(VAR_0->thread_count > 1);",
"if (VAR_15 <= VAR_14) {",
"MpegEncContext *thread_context = s2->thread_context[s->slice_count];",
"thread_context->start_mb_y = VAR_14;",
"thread_context->end_mb_y = s2->mb_height;",
"if (s->slice_count) {",
"s2->thread_context[s->slice_count-1]->end_mb_y = VAR_14;",
"VAR_7 = ff_update_duplicate_context(thread_context,\ns2);",
"if (VAR_7 < 0)\nreturn VAR_7;",
"init_get_bits(&thread_context->gb, VAR_5, VAR_8*8);",
"s->slice_count++;",
"VAR_5 += 2;",
"} else {",
"VAR_7 = mpeg_decode_slice(s2, VAR_14, &VAR_5, VAR_8);",
"emms_c();",
"if (VAR_7 < 0) {",
"if (VAR_0->err_recognition & AV_EF_EXPLODE)\nreturn VAR_7;",
"if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)\nff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->VAR_14, ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);",
"} else {",
"ff_er_add_slice(&s2->er, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->VAR_14, ER_AC_END | ER_DC_END | ER_MV_END);",
"break;"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
2,
3,
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18,
19
],
[
20
],
[
21
],
[
22
],
[
23
],
[
24
],
[
25
],
[
26,
27
],
[
28
],
[
29,
30
],
[
31
],
[
32
],
[
33
],
[
34
],
[
35
],
[
37
],
[
38,
39
],
[
40
],
[
41,
42
],
[
43
],
[
44
],
[
45,
46
],
[
47,
48
],
[
51
],
[
52
],
[
53
],
[
54
],
[
55,
56
],
[
57
],
[
58
],
[
59
],
[
60,
61
],
[
62
],
[
63,
64,
65
],
[
66
],
[
67
],
[
68
],
[
69
],
[
70
],
[
71
],
[
72
],
[
73
],
[
75,
76
],
[
77
],
[
78
],
[
79
],
[
80
],
[
81,
82
],
[
83,
84
],
[
85
],
[
86,
87
],
[
88
],
[
89
],
[
90
],
[
91,
92
],
[
93,
94
],
[
95
],
[
96,
97
],
[
98
],
[
99,
100
],
[
101
],
[
102,
103
],
[
104
],
[
105
],
[
106
],
[
107,
108
],
[
109
],
[
110,
111
],
[
112
],
[
113,
114
],
[
115
],
[
116
],
[
117
],
[
118
],
[
119
],
[
120,
121
],
[
122,
123,
124
],
[
125
],
[
126
],
[
127
],
[
128
],
[
129
],
[
130
],
[
131
],
[
132
],
[
133
],
[
134
],
[
135
],
[
136
],
[
137
],
[
138
],
[
139
],
[
140,
141
],
[
142
],
[
143
],
[
144
],
[
145,
146
],
[
147
],
[
148,
149
],
[
150
],
[
151
],
[
152
],
[
153
],
[
155
],
[
156
],
[
157
],
[
158
],
[
159,
160
],
[
161
],
[
163
],
[
164
],
[
165
],
[
166,
167,
168
],
[
169
],
[
170
],
[
171,
172
],
[
173
],
[
174,
175
],
[
176
],
[
177
],
[
178,
179
],
[
180
],
[
181
],
[
182
],
[
183,
184
],
[
185
],
[
186
],
[
187,
188
],
[
189,
190,
191
],
[
192
],
[
193
],
[
194
],
[
195
],
[
196
],
[
197
],
[
198
],
[
199,
200
],
[
201,
202
],
[
203
],
[
204
],
[
205
],
[
206
],
[
207
],
[
208
],
[
209
],
[
210,
211
],
[
212,
213
],
[
214
],
[
215
],
[
216
]
] |
7,007 |
static int get_video_frame(VideoState *is, AVFrame *frame)
{
int got_picture;
if ((got_picture = decoder_decode_frame(&is->viddec, frame)) < 0)
return -1;
if (got_picture) {
double dpts = NAN;
if (frame->pts != AV_NOPTS_VALUE)
dpts = av_q2d(is->video_st->time_base) * frame->pts;
frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
if (frame->pts != AV_NOPTS_VALUE) {
double diff = dpts - get_master_clock(is);
if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
diff - is->frame_last_filter_delay < 0 &&
is->viddec.pkt_serial == is->vidclk.serial &&
is->videoq.nb_packets) {
is->frame_drops_early++;
av_frame_unref(frame);
got_picture = 0;
}
}
}
}
return got_picture;
}
| true |
FFmpeg
|
2ec4a84dca603a24a8131297036dfe30eed33dd7
|
static int get_video_frame(VideoState *is, AVFrame *frame)
{
int got_picture;
if ((got_picture = decoder_decode_frame(&is->viddec, frame)) < 0)
return -1;
if (got_picture) {
double dpts = NAN;
if (frame->pts != AV_NOPTS_VALUE)
dpts = av_q2d(is->video_st->time_base) * frame->pts;
frame->sample_aspect_ratio = av_guess_sample_aspect_ratio(is->ic, is->video_st, frame);
if (framedrop>0 || (framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) {
if (frame->pts != AV_NOPTS_VALUE) {
double diff = dpts - get_master_clock(is);
if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD &&
diff - is->frame_last_filter_delay < 0 &&
is->viddec.pkt_serial == is->vidclk.serial &&
is->videoq.nb_packets) {
is->frame_drops_early++;
av_frame_unref(frame);
got_picture = 0;
}
}
}
}
return got_picture;
}
|
{
"code": [
" if ((got_picture = decoder_decode_frame(&is->viddec, frame)) < 0)"
],
"line_no": [
9
]
}
|
static int FUNC_0(VideoState *VAR_0, AVFrame *VAR_1)
{
int VAR_2;
if ((VAR_2 = decoder_decode_frame(&VAR_0->viddec, VAR_1)) < 0)
return -1;
if (VAR_2) {
double VAR_3 = NAN;
if (VAR_1->pts != AV_NOPTS_VALUE)
VAR_3 = av_q2d(VAR_0->video_st->time_base) * VAR_1->pts;
VAR_1->sample_aspect_ratio = av_guess_sample_aspect_ratio(VAR_0->ic, VAR_0->video_st, VAR_1);
if (framedrop>0 || (framedrop && get_master_sync_type(VAR_0) != AV_SYNC_VIDEO_MASTER)) {
if (VAR_1->pts != AV_NOPTS_VALUE) {
double VAR_4 = VAR_3 - get_master_clock(VAR_0);
if (!isnan(VAR_4) && fabs(VAR_4) < AV_NOSYNC_THRESHOLD &&
VAR_4 - VAR_0->frame_last_filter_delay < 0 &&
VAR_0->viddec.pkt_serial == VAR_0->vidclk.serial &&
VAR_0->videoq.nb_packets) {
VAR_0->frame_drops_early++;
av_frame_unref(VAR_1);
VAR_2 = 0;
}
}
}
}
return VAR_2;
}
|
[
"static int FUNC_0(VideoState *VAR_0, AVFrame *VAR_1)\n{",
"int VAR_2;",
"if ((VAR_2 = decoder_decode_frame(&VAR_0->viddec, VAR_1)) < 0)\nreturn -1;",
"if (VAR_2) {",
"double VAR_3 = NAN;",
"if (VAR_1->pts != AV_NOPTS_VALUE)\nVAR_3 = av_q2d(VAR_0->video_st->time_base) * VAR_1->pts;",
"VAR_1->sample_aspect_ratio = av_guess_sample_aspect_ratio(VAR_0->ic, VAR_0->video_st, VAR_1);",
"if (framedrop>0 || (framedrop && get_master_sync_type(VAR_0) != AV_SYNC_VIDEO_MASTER)) {",
"if (VAR_1->pts != AV_NOPTS_VALUE) {",
"double VAR_4 = VAR_3 - get_master_clock(VAR_0);",
"if (!isnan(VAR_4) && fabs(VAR_4) < AV_NOSYNC_THRESHOLD &&\nVAR_4 - VAR_0->frame_last_filter_delay < 0 &&\nVAR_0->viddec.pkt_serial == VAR_0->vidclk.serial &&\nVAR_0->videoq.nb_packets) {",
"VAR_0->frame_drops_early++;",
"av_frame_unref(VAR_1);",
"VAR_2 = 0;",
"}",
"}",
"}",
"}",
"return VAR_2;",
"}"
] |
[
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
11
],
[
15
],
[
17
],
[
21,
23
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37,
39,
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
]
] |
7,008 |
START_TEST(escaped_string)
{
int i;
struct {
const char *encoded;
const char *decoded;
int skip;
} test_cases[] = {
{ "\"\\\"\"", "\"" },
{ "\"hello world \\\"embedded string\\\"\"",
"hello world \"embedded string\"" },
{ "\"hello world\\nwith new line\"", "hello world\nwith new line" },
{ "\"single byte utf-8 \\u0020\"", "single byte utf-8 ", .skip = 1 },
{ "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
{ "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
{}
};
for (i = 0; test_cases[i].encoded; i++) {
QObject *obj;
QString *str;
obj = qobject_from_json(test_cases[i].encoded);
fail_unless(obj != NULL);
fail_unless(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
if (test_cases[i].skip == 0) {
str = qobject_to_json(obj);
fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
qobject_decref(obj);
}
QDECREF(str);
}
}
| true |
qemu
|
d22b0bd7fc85f991275ffc60a550ed42f4c1b04c
|
START_TEST(escaped_string)
{
int i;
struct {
const char *encoded;
const char *decoded;
int skip;
} test_cases[] = {
{ "\"\\\"\"", "\"" },
{ "\"hello world \\\"embedded string\\\"\"",
"hello world \"embedded string\"" },
{ "\"hello world\\nwith new line\"", "hello world\nwith new line" },
{ "\"single byte utf-8 \\u0020\"", "single byte utf-8 ", .skip = 1 },
{ "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
{ "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
{}
};
for (i = 0; test_cases[i].encoded; i++) {
QObject *obj;
QString *str;
obj = qobject_from_json(test_cases[i].encoded);
fail_unless(obj != NULL);
fail_unless(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
if (test_cases[i].skip == 0) {
str = qobject_to_json(obj);
fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
qobject_decref(obj);
}
QDECREF(str);
}
}
|
{
"code": [
" fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);",
" fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);"
],
"line_no": [
57,
65
]
}
|
FUNC_0(VAR_0)
{
int VAR_1;
struct {
const char *encoded;
const char *decoded;
int skip;
} VAR_2[] = {
{ "\"\\\"\"", "\"" },
{ "\"hello world \\\"embedded string\\\"\"",
"hello world \"embedded string\"" },
{ "\"hello world\\nwith new line\"", "hello world\nwith new line" },
{ "\"single byte utf-8 \\u0020\"", "single byte utf-8 ", .skip = 1 },
{ "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
{ "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
{}
};
for (VAR_1 = 0; VAR_2[VAR_1].encoded; VAR_1++) {
QObject *obj;
QString *str;
obj = qobject_from_json(VAR_2[VAR_1].encoded);
fail_unless(obj != NULL);
fail_unless(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
fail_unless(strcmp(qstring_get_str(str), VAR_2[VAR_1].decoded) == 0);
if (VAR_2[VAR_1].skip == 0) {
str = qobject_to_json(obj);
fail_unless(strcmp(qstring_get_str(str), VAR_2[VAR_1].encoded) == 0);
qobject_decref(obj);
}
QDECREF(str);
}
}
|
[
"FUNC_0(VAR_0)\n{",
"int VAR_1;",
"struct {",
"const char *encoded;",
"const char *decoded;",
"int skip;",
"} VAR_2[] = {",
"{ \"\\\"\\\\\\\"\\\"\", \"\\\"\" },",
"{ \"\\\"hello world \\\\\\\"embedded string\\\\\\\"\\\"\",",
"\"hello world \\\"embedded string\\\"\" },",
"{ \"\\\"hello world\\\\nwith new line\\\"\", \"hello world\\nwith new line\" },",
"{ \"\\\"single byte utf-8 \\\\u0020\\\"\", \"single byte utf-8 \", .skip = 1 },",
"{ \"\\\"double byte utf-8 \\\\u00A2\\\"\", \"double byte utf-8 \\xc2\\xa2\" },",
"{ \"\\\"triple byte utf-8 \\\\u20AC\\\"\", \"triple byte utf-8 \\xe2\\x82\\xac\" },",
"{}",
"};",
"for (VAR_1 = 0; VAR_2[VAR_1].encoded; VAR_1++) {",
"QObject *obj;",
"QString *str;",
"obj = qobject_from_json(VAR_2[VAR_1].encoded);",
"fail_unless(obj != NULL);",
"fail_unless(qobject_type(obj) == QTYPE_QSTRING);",
"str = qobject_to_qstring(obj);",
"fail_unless(strcmp(qstring_get_str(str), VAR_2[VAR_1].decoded) == 0);",
"if (VAR_2[VAR_1].skip == 0) {",
"str = qobject_to_json(obj);",
"fail_unless(strcmp(qstring_get_str(str), VAR_2[VAR_1].encoded) == 0);",
"qobject_decref(obj);",
"}",
"QDECREF(str);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
49
],
[
51
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
]
] |
7,009 |
static void pc_dimm_unplug_request(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
HotplugHandlerClass *hhc;
Error *local_err = NULL;
PCMachineState *pcms = PC_MACHINE(hotplug_dev);
if (!pcms->acpi_dev) {
error_setg(&local_err,
"memory hotplug is not enabled: missing acpi device");
goto out;
}
if (object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)) {
error_setg(&local_err,
"nvdimm device hot unplug is not supported yet.");
goto out;
}
hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
hhc->unplug_request(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
out:
error_propagate(errp, local_err);
}
| true |
qemu
|
8cd91acec8dfea6065272ca828405333f564a612
|
static void pc_dimm_unplug_request(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
HotplugHandlerClass *hhc;
Error *local_err = NULL;
PCMachineState *pcms = PC_MACHINE(hotplug_dev);
if (!pcms->acpi_dev) {
error_setg(&local_err,
"memory hotplug is not enabled: missing acpi device");
goto out;
}
if (object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)) {
error_setg(&local_err,
"nvdimm device hot unplug is not supported yet.");
goto out;
}
hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
hhc->unplug_request(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
out:
error_propagate(errp, local_err);
}
|
{
"code": [
" if (!pcms->acpi_dev) {",
" \"memory hotplug is not enabled: missing acpi device\");",
" if (!pcms->acpi_dev) {",
" \"memory hotplug is not enabled: missing acpi device\");"
],
"line_no": [
15,
19,
15,
19
]
}
|
static void FUNC_0(HotplugHandler *VAR_0,
DeviceState *VAR_1, Error **VAR_2)
{
HotplugHandlerClass *hhc;
Error *local_err = NULL;
PCMachineState *pcms = PC_MACHINE(VAR_0);
if (!pcms->acpi_dev) {
error_setg(&local_err,
"memory hotplug is not enabled: missing acpi device");
goto out;
}
if (object_dynamic_cast(OBJECT(VAR_1), TYPE_NVDIMM)) {
error_setg(&local_err,
"nvdimm device hot unplug is not supported yet.");
goto out;
}
hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);
hhc->unplug_request(HOTPLUG_HANDLER(pcms->acpi_dev), VAR_1, &local_err);
out:
error_propagate(VAR_2, local_err);
}
|
[
"static void FUNC_0(HotplugHandler *VAR_0,\nDeviceState *VAR_1, Error **VAR_2)\n{",
"HotplugHandlerClass *hhc;",
"Error *local_err = NULL;",
"PCMachineState *pcms = PC_MACHINE(VAR_0);",
"if (!pcms->acpi_dev) {",
"error_setg(&local_err,\n\"memory hotplug is not enabled: missing acpi device\");",
"goto out;",
"}",
"if (object_dynamic_cast(OBJECT(VAR_1), TYPE_NVDIMM)) {",
"error_setg(&local_err,\n\"nvdimm device hot unplug is not supported yet.\");",
"goto out;",
"}",
"hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);",
"hhc->unplug_request(HOTPLUG_HANDLER(pcms->acpi_dev), VAR_1, &local_err);",
"out:\nerror_propagate(VAR_2, local_err);",
"}"
] |
[
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
45,
47
],
[
49
]
] |
7,010 |
SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, int unit)
{
const char *driver;
DeviceState *dev;
driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk";
dev = qdev_create(&bus->qbus, driver);
qdev_prop_set_uint32(dev, "scsi-id", unit);
if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {
qdev_free(dev);
return NULL;
}
if (qdev_init(dev) < 0)
return NULL;
return DO_UPCAST(SCSIDevice, qdev, dev);
}
| false |
qemu
|
2d1fd2613769d99e5fad1f57ab8466434e2079fd
|
SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, int unit)
{
const char *driver;
DeviceState *dev;
driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk";
dev = qdev_create(&bus->qbus, driver);
qdev_prop_set_uint32(dev, "scsi-id", unit);
if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {
qdev_free(dev);
return NULL;
}
if (qdev_init(dev) < 0)
return NULL;
return DO_UPCAST(SCSIDevice, qdev, dev);
}
|
{
"code": [],
"line_no": []
}
|
SCSIDevice *FUNC_0(SCSIBus *bus, BlockDriverState *bdrv, int unit)
{
const char *VAR_0;
DeviceState *dev;
VAR_0 = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk";
dev = qdev_create(&bus->qbus, VAR_0);
qdev_prop_set_uint32(dev, "scsi-id", unit);
if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {
qdev_free(dev);
return NULL;
}
if (qdev_init(dev) < 0)
return NULL;
return DO_UPCAST(SCSIDevice, qdev, dev);
}
|
[
"SCSIDevice *FUNC_0(SCSIBus *bus, BlockDriverState *bdrv, int unit)\n{",
"const char *VAR_0;",
"DeviceState *dev;",
"VAR_0 = bdrv_is_sg(bdrv) ? \"scsi-generic\" : \"scsi-disk\";",
"dev = qdev_create(&bus->qbus, VAR_0);",
"qdev_prop_set_uint32(dev, \"scsi-id\", unit);",
"if (qdev_prop_set_drive(dev, \"drive\", bdrv) < 0) {",
"qdev_free(dev);",
"return NULL;",
"}",
"if (qdev_init(dev) < 0)\nreturn NULL;",
"return DO_UPCAST(SCSIDevice, qdev, dev);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31
]
] |
7,011 |
NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,
uint32_t nbdflags, void (*close)(NBDExport *),
Error **errp)
{
NBDExport *exp = g_malloc0(sizeof(NBDExport));
exp->refcount = 1;
QTAILQ_INIT(&exp->clients);
exp->blk = blk;
exp->dev_offset = dev_offset;
exp->nbdflags = nbdflags;
exp->size = size < 0 ? blk_getlength(blk) : size;
if (exp->size < 0) {
error_setg_errno(errp, -exp->size,
"Failed to determine the NBD export's length");
goto fail;
}
exp->size -= exp->size % BDRV_SECTOR_SIZE;
exp->close = close;
exp->ctx = blk_get_aio_context(blk);
blk_ref(blk);
blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
exp->eject_notifier.notify = nbd_eject_notifier;
blk_add_remove_bs_notifier(blk, &exp->eject_notifier);
/*
* NBD exports are used for non-shared storage migration. Make sure
* that BDRV_O_INACTIVE is cleared and the image is ready for write
* access since the export could be available before migration handover.
*/
aio_context_acquire(exp->ctx);
blk_invalidate_cache(blk, NULL);
aio_context_release(exp->ctx);
return exp;
fail:
g_free(exp);
return NULL;
}
| false |
qemu
|
7423f417827146f956df820f172d0bf80a489495
|
NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size,
uint32_t nbdflags, void (*close)(NBDExport *),
Error **errp)
{
NBDExport *exp = g_malloc0(sizeof(NBDExport));
exp->refcount = 1;
QTAILQ_INIT(&exp->clients);
exp->blk = blk;
exp->dev_offset = dev_offset;
exp->nbdflags = nbdflags;
exp->size = size < 0 ? blk_getlength(blk) : size;
if (exp->size < 0) {
error_setg_errno(errp, -exp->size,
"Failed to determine the NBD export's length");
goto fail;
}
exp->size -= exp->size % BDRV_SECTOR_SIZE;
exp->close = close;
exp->ctx = blk_get_aio_context(blk);
blk_ref(blk);
blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
exp->eject_notifier.notify = nbd_eject_notifier;
blk_add_remove_bs_notifier(blk, &exp->eject_notifier);
aio_context_acquire(exp->ctx);
blk_invalidate_cache(blk, NULL);
aio_context_release(exp->ctx);
return exp;
fail:
g_free(exp);
return NULL;
}
|
{
"code": [],
"line_no": []
}
|
NBDExport *FUNC_0(BlockBackend *blk, off_t dev_offset, off_t size,
uint32_t nbdflags, void (*close)(NBDExport *),
Error **errp)
{
NBDExport *exp = g_malloc0(sizeof(NBDExport));
exp->refcount = 1;
QTAILQ_INIT(&exp->clients);
exp->blk = blk;
exp->dev_offset = dev_offset;
exp->nbdflags = nbdflags;
exp->size = size < 0 ? blk_getlength(blk) : size;
if (exp->size < 0) {
error_setg_errno(errp, -exp->size,
"Failed to determine the NBD export's length");
goto fail;
}
exp->size -= exp->size % BDRV_SECTOR_SIZE;
exp->close = close;
exp->ctx = blk_get_aio_context(blk);
blk_ref(blk);
blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
exp->eject_notifier.notify = nbd_eject_notifier;
blk_add_remove_bs_notifier(blk, &exp->eject_notifier);
aio_context_acquire(exp->ctx);
blk_invalidate_cache(blk, NULL);
aio_context_release(exp->ctx);
return exp;
fail:
g_free(exp);
return NULL;
}
|
[
"NBDExport *FUNC_0(BlockBackend *blk, off_t dev_offset, off_t size,\nuint32_t nbdflags, void (*close)(NBDExport *),\nError **errp)\n{",
"NBDExport *exp = g_malloc0(sizeof(NBDExport));",
"exp->refcount = 1;",
"QTAILQ_INIT(&exp->clients);",
"exp->blk = blk;",
"exp->dev_offset = dev_offset;",
"exp->nbdflags = nbdflags;",
"exp->size = size < 0 ? blk_getlength(blk) : size;",
"if (exp->size < 0) {",
"error_setg_errno(errp, -exp->size,\n\"Failed to determine the NBD export's length\");",
"goto fail;",
"}",
"exp->size -= exp->size % BDRV_SECTOR_SIZE;",
"exp->close = close;",
"exp->ctx = blk_get_aio_context(blk);",
"blk_ref(blk);",
"blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);",
"exp->eject_notifier.notify = nbd_eject_notifier;",
"blk_add_remove_bs_notifier(blk, &exp->eject_notifier);",
"aio_context_acquire(exp->ctx);",
"blk_invalidate_cache(blk, NULL);",
"aio_context_release(exp->ctx);",
"return exp;",
"fail:\ng_free(exp);",
"return NULL;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73,
75
],
[
77
],
[
79
]
] |
7,012 |
static int bdrv_qed_open(BlockDriverState *bs, int flags)
{
BDRVQEDState *s = bs->opaque;
QEDHeader le_header;
int64_t file_size;
int ret;
s->bs = bs;
QSIMPLEQ_INIT(&s->allocating_write_reqs);
ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header));
if (ret < 0) {
return ret;
}
qed_header_le_to_cpu(&le_header, &s->header);
if (s->header.magic != QED_MAGIC) {
return -EINVAL;
}
if (s->header.features & ~QED_FEATURE_MASK) {
/* image uses unsupported feature bits */
char buf[64];
snprintf(buf, sizeof(buf), "%" PRIx64,
s->header.features & ~QED_FEATURE_MASK);
qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bs->device_name, "QED", buf);
return -ENOTSUP;
}
if (!qed_is_cluster_size_valid(s->header.cluster_size)) {
return -EINVAL;
}
/* Round down file size to the last cluster */
file_size = bdrv_getlength(bs->file);
if (file_size < 0) {
return file_size;
}
s->file_size = qed_start_of_cluster(s, file_size);
if (!qed_is_table_size_valid(s->header.table_size)) {
return -EINVAL;
}
if (!qed_is_image_size_valid(s->header.image_size,
s->header.cluster_size,
s->header.table_size)) {
return -EINVAL;
}
if (!qed_check_table_offset(s, s->header.l1_table_offset)) {
return -EINVAL;
}
s->table_nelems = (s->header.cluster_size * s->header.table_size) /
sizeof(uint64_t);
s->l2_shift = ffs(s->header.cluster_size) - 1;
s->l2_mask = s->table_nelems - 1;
s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1;
if ((s->header.features & QED_F_BACKING_FILE)) {
if ((uint64_t)s->header.backing_filename_offset +
s->header.backing_filename_size >
s->header.cluster_size * s->header.header_size) {
return -EINVAL;
}
ret = qed_read_string(bs->file, s->header.backing_filename_offset,
s->header.backing_filename_size, bs->backing_file,
sizeof(bs->backing_file));
if (ret < 0) {
return ret;
}
if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) {
pstrcpy(bs->backing_format, sizeof(bs->backing_format), "raw");
}
}
/* Reset unknown autoclear feature bits. This is a backwards
* compatibility mechanism that allows images to be opened by older
* programs, which "knock out" unknown feature bits. When an image is
* opened by a newer program again it can detect that the autoclear
* feature is no longer valid.
*/
if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 &&
!bdrv_is_read_only(bs->file) && !(flags & BDRV_O_INCOMING)) {
s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK;
ret = qed_write_header_sync(s);
if (ret) {
return ret;
}
/* From here on only known autoclear feature bits are valid */
bdrv_flush(bs->file);
}
s->l1_table = qed_alloc_table(s);
qed_init_l2_cache(&s->l2_cache);
ret = qed_read_l1_table_sync(s);
if (ret) {
goto out;
}
/* If image was not closed cleanly, check consistency */
if (s->header.features & QED_F_NEED_CHECK) {
/* Read-only images cannot be fixed. There is no risk of corruption
* since write operations are not possible. Therefore, allow
* potentially inconsistent images to be opened read-only. This can
* aid data recovery from an otherwise inconsistent image.
*/
if (!bdrv_is_read_only(bs->file) &&
!(flags & BDRV_O_INCOMING)) {
BdrvCheckResult result = {0};
ret = qed_check(s, &result, true);
if (ret) {
goto out;
}
}
}
s->need_check_timer = qemu_new_timer_ns(vm_clock,
qed_need_check_timer_cb, s);
out:
if (ret) {
qed_free_l2_cache(&s->l2_cache);
qemu_vfree(s->l1_table);
}
return ret;
}
| false |
qemu
|
058f8f16db0c1c528b665a6283457f019c8b0926
|
static int bdrv_qed_open(BlockDriverState *bs, int flags)
{
BDRVQEDState *s = bs->opaque;
QEDHeader le_header;
int64_t file_size;
int ret;
s->bs = bs;
QSIMPLEQ_INIT(&s->allocating_write_reqs);
ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header));
if (ret < 0) {
return ret;
}
qed_header_le_to_cpu(&le_header, &s->header);
if (s->header.magic != QED_MAGIC) {
return -EINVAL;
}
if (s->header.features & ~QED_FEATURE_MASK) {
char buf[64];
snprintf(buf, sizeof(buf), "%" PRIx64,
s->header.features & ~QED_FEATURE_MASK);
qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bs->device_name, "QED", buf);
return -ENOTSUP;
}
if (!qed_is_cluster_size_valid(s->header.cluster_size)) {
return -EINVAL;
}
file_size = bdrv_getlength(bs->file);
if (file_size < 0) {
return file_size;
}
s->file_size = qed_start_of_cluster(s, file_size);
if (!qed_is_table_size_valid(s->header.table_size)) {
return -EINVAL;
}
if (!qed_is_image_size_valid(s->header.image_size,
s->header.cluster_size,
s->header.table_size)) {
return -EINVAL;
}
if (!qed_check_table_offset(s, s->header.l1_table_offset)) {
return -EINVAL;
}
s->table_nelems = (s->header.cluster_size * s->header.table_size) /
sizeof(uint64_t);
s->l2_shift = ffs(s->header.cluster_size) - 1;
s->l2_mask = s->table_nelems - 1;
s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1;
if ((s->header.features & QED_F_BACKING_FILE)) {
if ((uint64_t)s->header.backing_filename_offset +
s->header.backing_filename_size >
s->header.cluster_size * s->header.header_size) {
return -EINVAL;
}
ret = qed_read_string(bs->file, s->header.backing_filename_offset,
s->header.backing_filename_size, bs->backing_file,
sizeof(bs->backing_file));
if (ret < 0) {
return ret;
}
if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) {
pstrcpy(bs->backing_format, sizeof(bs->backing_format), "raw");
}
}
if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 &&
!bdrv_is_read_only(bs->file) && !(flags & BDRV_O_INCOMING)) {
s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK;
ret = qed_write_header_sync(s);
if (ret) {
return ret;
}
bdrv_flush(bs->file);
}
s->l1_table = qed_alloc_table(s);
qed_init_l2_cache(&s->l2_cache);
ret = qed_read_l1_table_sync(s);
if (ret) {
goto out;
}
if (s->header.features & QED_F_NEED_CHECK) {
if (!bdrv_is_read_only(bs->file) &&
!(flags & BDRV_O_INCOMING)) {
BdrvCheckResult result = {0};
ret = qed_check(s, &result, true);
if (ret) {
goto out;
}
}
}
s->need_check_timer = qemu_new_timer_ns(vm_clock,
qed_need_check_timer_cb, s);
out:
if (ret) {
qed_free_l2_cache(&s->l2_cache);
qemu_vfree(s->l1_table);
}
return ret;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(BlockDriverState *VAR_0, int VAR_1)
{
BDRVQEDState *s = VAR_0->opaque;
QEDHeader le_header;
int64_t file_size;
int VAR_2;
s->VAR_0 = VAR_0;
QSIMPLEQ_INIT(&s->allocating_write_reqs);
VAR_2 = bdrv_pread(VAR_0->file, 0, &le_header, sizeof(le_header));
if (VAR_2 < 0) {
return VAR_2;
}
qed_header_le_to_cpu(&le_header, &s->header);
if (s->header.magic != QED_MAGIC) {
return -EINVAL;
}
if (s->header.features & ~QED_FEATURE_MASK) {
char VAR_3[64];
snprintf(VAR_3, sizeof(VAR_3), "%" PRIx64,
s->header.features & ~QED_FEATURE_MASK);
qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
VAR_0->device_name, "QED", VAR_3);
return -ENOTSUP;
}
if (!qed_is_cluster_size_valid(s->header.cluster_size)) {
return -EINVAL;
}
file_size = bdrv_getlength(VAR_0->file);
if (file_size < 0) {
return file_size;
}
s->file_size = qed_start_of_cluster(s, file_size);
if (!qed_is_table_size_valid(s->header.table_size)) {
return -EINVAL;
}
if (!qed_is_image_size_valid(s->header.image_size,
s->header.cluster_size,
s->header.table_size)) {
return -EINVAL;
}
if (!qed_check_table_offset(s, s->header.l1_table_offset)) {
return -EINVAL;
}
s->table_nelems = (s->header.cluster_size * s->header.table_size) /
sizeof(uint64_t);
s->l2_shift = ffs(s->header.cluster_size) - 1;
s->l2_mask = s->table_nelems - 1;
s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1;
if ((s->header.features & QED_F_BACKING_FILE)) {
if ((uint64_t)s->header.backing_filename_offset +
s->header.backing_filename_size >
s->header.cluster_size * s->header.header_size) {
return -EINVAL;
}
VAR_2 = qed_read_string(VAR_0->file, s->header.backing_filename_offset,
s->header.backing_filename_size, VAR_0->backing_file,
sizeof(VAR_0->backing_file));
if (VAR_2 < 0) {
return VAR_2;
}
if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) {
pstrcpy(VAR_0->backing_format, sizeof(VAR_0->backing_format), "raw");
}
}
if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 &&
!bdrv_is_read_only(VAR_0->file) && !(VAR_1 & BDRV_O_INCOMING)) {
s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK;
VAR_2 = qed_write_header_sync(s);
if (VAR_2) {
return VAR_2;
}
bdrv_flush(VAR_0->file);
}
s->l1_table = qed_alloc_table(s);
qed_init_l2_cache(&s->l2_cache);
VAR_2 = qed_read_l1_table_sync(s);
if (VAR_2) {
goto out;
}
if (s->header.features & QED_F_NEED_CHECK) {
if (!bdrv_is_read_only(VAR_0->file) &&
!(VAR_1 & BDRV_O_INCOMING)) {
BdrvCheckResult result = {0};
VAR_2 = qed_check(s, &result, true);
if (VAR_2) {
goto out;
}
}
}
s->need_check_timer = qemu_new_timer_ns(vm_clock,
qed_need_check_timer_cb, s);
out:
if (VAR_2) {
qed_free_l2_cache(&s->l2_cache);
qemu_vfree(s->l1_table);
}
return VAR_2;
}
|
[
"static int FUNC_0(BlockDriverState *VAR_0, int VAR_1)\n{",
"BDRVQEDState *s = VAR_0->opaque;",
"QEDHeader le_header;",
"int64_t file_size;",
"int VAR_2;",
"s->VAR_0 = VAR_0;",
"QSIMPLEQ_INIT(&s->allocating_write_reqs);",
"VAR_2 = bdrv_pread(VAR_0->file, 0, &le_header, sizeof(le_header));",
"if (VAR_2 < 0) {",
"return VAR_2;",
"}",
"qed_header_le_to_cpu(&le_header, &s->header);",
"if (s->header.magic != QED_MAGIC) {",
"return -EINVAL;",
"}",
"if (s->header.features & ~QED_FEATURE_MASK) {",
"char VAR_3[64];",
"snprintf(VAR_3, sizeof(VAR_3), \"%\" PRIx64,\ns->header.features & ~QED_FEATURE_MASK);",
"qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,\nVAR_0->device_name, \"QED\", VAR_3);",
"return -ENOTSUP;",
"}",
"if (!qed_is_cluster_size_valid(s->header.cluster_size)) {",
"return -EINVAL;",
"}",
"file_size = bdrv_getlength(VAR_0->file);",
"if (file_size < 0) {",
"return file_size;",
"}",
"s->file_size = qed_start_of_cluster(s, file_size);",
"if (!qed_is_table_size_valid(s->header.table_size)) {",
"return -EINVAL;",
"}",
"if (!qed_is_image_size_valid(s->header.image_size,\ns->header.cluster_size,\ns->header.table_size)) {",
"return -EINVAL;",
"}",
"if (!qed_check_table_offset(s, s->header.l1_table_offset)) {",
"return -EINVAL;",
"}",
"s->table_nelems = (s->header.cluster_size * s->header.table_size) /\nsizeof(uint64_t);",
"s->l2_shift = ffs(s->header.cluster_size) - 1;",
"s->l2_mask = s->table_nelems - 1;",
"s->l1_shift = s->l2_shift + ffs(s->table_nelems) - 1;",
"if ((s->header.features & QED_F_BACKING_FILE)) {",
"if ((uint64_t)s->header.backing_filename_offset +\ns->header.backing_filename_size >\ns->header.cluster_size * s->header.header_size) {",
"return -EINVAL;",
"}",
"VAR_2 = qed_read_string(VAR_0->file, s->header.backing_filename_offset,\ns->header.backing_filename_size, VAR_0->backing_file,\nsizeof(VAR_0->backing_file));",
"if (VAR_2 < 0) {",
"return VAR_2;",
"}",
"if (s->header.features & QED_F_BACKING_FORMAT_NO_PROBE) {",
"pstrcpy(VAR_0->backing_format, sizeof(VAR_0->backing_format), \"raw\");",
"}",
"}",
"if ((s->header.autoclear_features & ~QED_AUTOCLEAR_FEATURE_MASK) != 0 &&\n!bdrv_is_read_only(VAR_0->file) && !(VAR_1 & BDRV_O_INCOMING)) {",
"s->header.autoclear_features &= QED_AUTOCLEAR_FEATURE_MASK;",
"VAR_2 = qed_write_header_sync(s);",
"if (VAR_2) {",
"return VAR_2;",
"}",
"bdrv_flush(VAR_0->file);",
"}",
"s->l1_table = qed_alloc_table(s);",
"qed_init_l2_cache(&s->l2_cache);",
"VAR_2 = qed_read_l1_table_sync(s);",
"if (VAR_2) {",
"goto out;",
"}",
"if (s->header.features & QED_F_NEED_CHECK) {",
"if (!bdrv_is_read_only(VAR_0->file) &&\n!(VAR_1 & BDRV_O_INCOMING)) {",
"BdrvCheckResult result = {0};",
"VAR_2 = qed_check(s, &result, true);",
"if (VAR_2) {",
"goto out;",
"}",
"}",
"}",
"s->need_check_timer = qemu_new_timer_ns(vm_clock,\nqed_need_check_timer_cb, s);",
"out:\nif (VAR_2) {",
"qed_free_l2_cache(&s->l2_cache);",
"qemu_vfree(s->l1_table);",
"}",
"return VAR_2;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45,
47
],
[
49,
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85,
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117,
119,
121
],
[
123
],
[
125
],
[
129,
131,
133
],
[
135
],
[
137
],
[
139
],
[
143
],
[
145
],
[
147
],
[
149
],
[
165,
167
],
[
169
],
[
173
],
[
175
],
[
177
],
[
179
],
[
185
],
[
187
],
[
191
],
[
193
],
[
197
],
[
199
],
[
201
],
[
203
],
[
209
],
[
221,
223
],
[
225
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
243,
245
],
[
249,
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
]
] |
7,013 |
static void test_io_channel_unix(bool async)
{
SocketAddress *listen_addr = g_new0(SocketAddress, 1);
SocketAddress *connect_addr = g_new0(SocketAddress, 1);
#define TEST_SOCKET "test-io-channel-socket.sock"
listen_addr->type = SOCKET_ADDRESS_KIND_UNIX;
listen_addr->u.q_unix = g_new0(UnixSocketAddress, 1);
listen_addr->u.q_unix->path = g_strdup(TEST_SOCKET);
connect_addr->type = SOCKET_ADDRESS_KIND_UNIX;
connect_addr->u.q_unix = g_new0(UnixSocketAddress, 1);
connect_addr->u.q_unix->path = g_strdup(TEST_SOCKET);
test_io_channel(async, listen_addr, connect_addr, true);
qapi_free_SocketAddress(listen_addr);
qapi_free_SocketAddress(connect_addr);
unlink(TEST_SOCKET);
}
| false |
qemu
|
32bafa8fdd098d52fbf1102d5a5e48d29398c0aa
|
static void test_io_channel_unix(bool async)
{
SocketAddress *listen_addr = g_new0(SocketAddress, 1);
SocketAddress *connect_addr = g_new0(SocketAddress, 1);
#define TEST_SOCKET "test-io-channel-socket.sock"
listen_addr->type = SOCKET_ADDRESS_KIND_UNIX;
listen_addr->u.q_unix = g_new0(UnixSocketAddress, 1);
listen_addr->u.q_unix->path = g_strdup(TEST_SOCKET);
connect_addr->type = SOCKET_ADDRESS_KIND_UNIX;
connect_addr->u.q_unix = g_new0(UnixSocketAddress, 1);
connect_addr->u.q_unix->path = g_strdup(TEST_SOCKET);
test_io_channel(async, listen_addr, connect_addr, true);
qapi_free_SocketAddress(listen_addr);
qapi_free_SocketAddress(connect_addr);
unlink(TEST_SOCKET);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(bool VAR_0)
{
SocketAddress *listen_addr = g_new0(SocketAddress, 1);
SocketAddress *connect_addr = g_new0(SocketAddress, 1);
#define TEST_SOCKET "test-io-channel-socket.sock"
listen_addr->type = SOCKET_ADDRESS_KIND_UNIX;
listen_addr->u.q_unix = g_new0(UnixSocketAddress, 1);
listen_addr->u.q_unix->path = g_strdup(TEST_SOCKET);
connect_addr->type = SOCKET_ADDRESS_KIND_UNIX;
connect_addr->u.q_unix = g_new0(UnixSocketAddress, 1);
connect_addr->u.q_unix->path = g_strdup(TEST_SOCKET);
test_io_channel(VAR_0, listen_addr, connect_addr, true);
qapi_free_SocketAddress(listen_addr);
qapi_free_SocketAddress(connect_addr);
unlink(TEST_SOCKET);
}
|
[
"static void FUNC_0(bool VAR_0)\n{",
"SocketAddress *listen_addr = g_new0(SocketAddress, 1);",
"SocketAddress *connect_addr = g_new0(SocketAddress, 1);",
"#define TEST_SOCKET \"test-io-channel-socket.sock\"\nlisten_addr->type = SOCKET_ADDRESS_KIND_UNIX;",
"listen_addr->u.q_unix = g_new0(UnixSocketAddress, 1);",
"listen_addr->u.q_unix->path = g_strdup(TEST_SOCKET);",
"connect_addr->type = SOCKET_ADDRESS_KIND_UNIX;",
"connect_addr->u.q_unix = g_new0(UnixSocketAddress, 1);",
"connect_addr->u.q_unix->path = g_strdup(TEST_SOCKET);",
"test_io_channel(VAR_0, listen_addr, connect_addr, true);",
"qapi_free_SocketAddress(listen_addr);",
"qapi_free_SocketAddress(connect_addr);",
"unlink(TEST_SOCKET);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
]
] |
7,014 |
static void test_visitor_in_native_list_bool(TestInputVisitorData *data,
const void *unused)
{
UserDefNativeListUnion *cvalue = NULL;
boolList *elem = NULL;
Visitor *v;
GString *gstr_list = g_string_new("");
GString *gstr_union = g_string_new("");
int i;
for (i = 0; i < 32; i++) {
g_string_append_printf(gstr_list, "%s",
(i % 3 == 0) ? "true" : "false");
if (i != 31) {
g_string_append(gstr_list, ", ");
}
}
g_string_append_printf(gstr_union, "{ 'type': 'boolean', 'data': [ %s ] }",
gstr_list->str);
v = visitor_input_test_init_raw(data, gstr_union->str);
visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort);
g_assert(cvalue != NULL);
g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);
for (i = 0, elem = cvalue->u.boolean.data; elem; elem = elem->next, i++) {
g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0);
}
g_string_free(gstr_union, true);
g_string_free(gstr_list, true);
qapi_free_UserDefNativeListUnion(cvalue);
}
| false |
qemu
|
b3db211f3c80bb996a704d665fe275619f728bd4
|
static void test_visitor_in_native_list_bool(TestInputVisitorData *data,
const void *unused)
{
UserDefNativeListUnion *cvalue = NULL;
boolList *elem = NULL;
Visitor *v;
GString *gstr_list = g_string_new("");
GString *gstr_union = g_string_new("");
int i;
for (i = 0; i < 32; i++) {
g_string_append_printf(gstr_list, "%s",
(i % 3 == 0) ? "true" : "false");
if (i != 31) {
g_string_append(gstr_list, ", ");
}
}
g_string_append_printf(gstr_union, "{ 'type': 'boolean', 'data': [ %s ] }",
gstr_list->str);
v = visitor_input_test_init_raw(data, gstr_union->str);
visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort);
g_assert(cvalue != NULL);
g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);
for (i = 0, elem = cvalue->u.boolean.data; elem; elem = elem->next, i++) {
g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0);
}
g_string_free(gstr_union, true);
g_string_free(gstr_list, true);
qapi_free_UserDefNativeListUnion(cvalue);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(TestInputVisitorData *VAR_0,
const void *VAR_1)
{
UserDefNativeListUnion *cvalue = NULL;
boolList *elem = NULL;
Visitor *v;
GString *gstr_list = g_string_new("");
GString *gstr_union = g_string_new("");
int VAR_2;
for (VAR_2 = 0; VAR_2 < 32; VAR_2++) {
g_string_append_printf(gstr_list, "%s",
(VAR_2 % 3 == 0) ? "true" : "false");
if (VAR_2 != 31) {
g_string_append(gstr_list, ", ");
}
}
g_string_append_printf(gstr_union, "{ 'type': 'boolean', 'VAR_0': [ %s ] }",
gstr_list->str);
v = visitor_input_test_init_raw(VAR_0, gstr_union->str);
visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort);
g_assert(cvalue != NULL);
g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);
for (VAR_2 = 0, elem = cvalue->u.boolean.VAR_0; elem; elem = elem->next, VAR_2++) {
g_assert_cmpint(elem->value, ==, (VAR_2 % 3 == 0) ? 1 : 0);
}
g_string_free(gstr_union, true);
g_string_free(gstr_list, true);
qapi_free_UserDefNativeListUnion(cvalue);
}
|
[
"static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"UserDefNativeListUnion *cvalue = NULL;",
"boolList *elem = NULL;",
"Visitor *v;",
"GString *gstr_list = g_string_new(\"\");",
"GString *gstr_union = g_string_new(\"\");",
"int VAR_2;",
"for (VAR_2 = 0; VAR_2 < 32; VAR_2++) {",
"g_string_append_printf(gstr_list, \"%s\",\n(VAR_2 % 3 == 0) ? \"true\" : \"false\");",
"if (VAR_2 != 31) {",
"g_string_append(gstr_list, \", \");",
"}",
"}",
"g_string_append_printf(gstr_union, \"{ 'type': 'boolean', 'VAR_0': [ %s ] }\",",
"gstr_list->str);",
"v = visitor_input_test_init_raw(VAR_0, gstr_union->str);",
"visit_type_UserDefNativeListUnion(v, NULL, &cvalue, &error_abort);",
"g_assert(cvalue != NULL);",
"g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);",
"for (VAR_2 = 0, elem = cvalue->u.boolean.VAR_0; elem; elem = elem->next, VAR_2++) {",
"g_assert_cmpint(elem->value, ==, (VAR_2 % 3 == 0) ? 1 : 0);",
"}",
"g_string_free(gstr_union, true);",
"g_string_free(gstr_list, true);",
"qapi_free_UserDefNativeListUnion(cvalue);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
]
] |
7,015 |
static void init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext *gb, int length)
{
int i, k, run, level, diff;
if (BITS_LEFT(length,gb) < 16)
return;
level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2);
quantized_coeffs[0] = level;
for (i = 0; i < 7; ) {
if (BITS_LEFT(length,gb) < 16)
break;
run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1;
if (BITS_LEFT(length,gb) < 16)
break;
diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2);
for (k = 1; k <= run; k++)
quantized_coeffs[i + k] = (level + ((k * diff) / run));
level += diff;
i += run;
}
}
| false |
FFmpeg
|
cece491daa9f4c7c908e016f4e285a49d37cb17c
|
static void init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext *gb, int length)
{
int i, k, run, level, diff;
if (BITS_LEFT(length,gb) < 16)
return;
level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2);
quantized_coeffs[0] = level;
for (i = 0; i < 7; ) {
if (BITS_LEFT(length,gb) < 16)
break;
run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1;
if (BITS_LEFT(length,gb) < 16)
break;
diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2);
for (k = 1; k <= run; k++)
quantized_coeffs[i + k] = (level + ((k * diff) / run));
level += diff;
i += run;
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0 (int8_t *VAR_0, GetBitContext *VAR_1, int VAR_2)
{
int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;
if (BITS_LEFT(VAR_2,VAR_1) < 16)
return;
VAR_6 = qdm2_get_vlc(VAR_1, &vlc_tab_level, 0, 2);
VAR_0[0] = VAR_6;
for (VAR_3 = 0; VAR_3 < 7; ) {
if (BITS_LEFT(VAR_2,VAR_1) < 16)
break;
VAR_5 = qdm2_get_vlc(VAR_1, &vlc_tab_run, 0, 1) + 1;
if (BITS_LEFT(VAR_2,VAR_1) < 16)
break;
VAR_7 = qdm2_get_se_vlc(&vlc_tab_diff, VAR_1, 2);
for (VAR_4 = 1; VAR_4 <= VAR_5; VAR_4++)
VAR_0[VAR_3 + VAR_4] = (VAR_6 + ((VAR_4 * VAR_7) / VAR_5));
VAR_6 += VAR_7;
VAR_3 += VAR_5;
}
}
|
[
"static void FUNC_0 (int8_t *VAR_0, GetBitContext *VAR_1, int VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;",
"if (BITS_LEFT(VAR_2,VAR_1) < 16)\nreturn;",
"VAR_6 = qdm2_get_vlc(VAR_1, &vlc_tab_level, 0, 2);",
"VAR_0[0] = VAR_6;",
"for (VAR_3 = 0; VAR_3 < 7; ) {",
"if (BITS_LEFT(VAR_2,VAR_1) < 16)\nbreak;",
"VAR_5 = qdm2_get_vlc(VAR_1, &vlc_tab_run, 0, 1) + 1;",
"if (BITS_LEFT(VAR_2,VAR_1) < 16)\nbreak;",
"VAR_7 = qdm2_get_se_vlc(&vlc_tab_diff, VAR_1, 2);",
"for (VAR_4 = 1; VAR_4 <= VAR_5; VAR_4++)",
"VAR_0[VAR_3 + VAR_4] = (VAR_6 + ((VAR_4 * VAR_7) / VAR_5));",
"VAR_6 += VAR_7;",
"VAR_3 += VAR_5;",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
11
],
[
13
],
[
17
],
[
21
],
[
23,
25
],
[
27
],
[
31,
33
],
[
35
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
]
] |
7,016 |
QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
QEMUTimerCB *cb, void *opaque)
{
return g_malloc(1);
}
| false |
qemu
|
cbcfa0418f0c196afa765f5c9837b9344d1adcf3
|
QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
QEMUTimerCB *cb, void *opaque)
{
return g_malloc(1);
}
|
{
"code": [],
"line_no": []
}
|
QEMUTimer *FUNC_0(QEMUClock *clock, int scale,
QEMUTimerCB *cb, void *opaque)
{
return g_malloc(1);
}
|
[
"QEMUTimer *FUNC_0(QEMUClock *clock, int scale,\nQEMUTimerCB *cb, void *opaque)\n{",
"return g_malloc(1);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
]
] |
7,018 |
static void handle_fmov(DisasContext *s, int rd, int rn, int type, bool itof)
{
/* FMOV: gpr to or from float, double, or top half of quad fp reg,
* without conversion.
*/
if (itof) {
TCGv_i64 tcg_rn = cpu_reg(s, rn);
switch (type) {
case 0:
{
/* 32 bit */
TCGv_i64 tmp = tcg_temp_new_i64();
tcg_gen_ext32u_i64(tmp, tcg_rn);
tcg_gen_st_i64(tmp, cpu_env, fp_reg_offset(rd, MO_64));
tcg_gen_movi_i64(tmp, 0);
tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(rd));
tcg_temp_free_i64(tmp);
break;
}
case 1:
{
/* 64 bit */
TCGv_i64 tmp = tcg_const_i64(0);
tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_offset(rd, MO_64));
tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(rd));
tcg_temp_free_i64(tmp);
break;
}
case 2:
/* 64 bit to top half. */
tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_hi_offset(rd));
break;
}
} else {
TCGv_i64 tcg_rd = cpu_reg(s, rd);
switch (type) {
case 0:
/* 32 bit */
tcg_gen_ld32u_i64(tcg_rd, cpu_env, fp_reg_offset(rn, MO_32));
break;
case 1:
/* 64 bit */
tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_offset(rn, MO_64));
break;
case 2:
/* 64 bits from top half */
tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_hi_offset(rn));
break;
}
}
}
| false |
qemu
|
90e496386fe7fd32c189561f846b7913f95b8cf4
|
static void handle_fmov(DisasContext *s, int rd, int rn, int type, bool itof)
{
if (itof) {
TCGv_i64 tcg_rn = cpu_reg(s, rn);
switch (type) {
case 0:
{
TCGv_i64 tmp = tcg_temp_new_i64();
tcg_gen_ext32u_i64(tmp, tcg_rn);
tcg_gen_st_i64(tmp, cpu_env, fp_reg_offset(rd, MO_64));
tcg_gen_movi_i64(tmp, 0);
tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(rd));
tcg_temp_free_i64(tmp);
break;
}
case 1:
{
TCGv_i64 tmp = tcg_const_i64(0);
tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_offset(rd, MO_64));
tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(rd));
tcg_temp_free_i64(tmp);
break;
}
case 2:
tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_hi_offset(rd));
break;
}
} else {
TCGv_i64 tcg_rd = cpu_reg(s, rd);
switch (type) {
case 0:
tcg_gen_ld32u_i64(tcg_rd, cpu_env, fp_reg_offset(rn, MO_32));
break;
case 1:
tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_offset(rn, MO_64));
break;
case 2:
tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_hi_offset(rn));
break;
}
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(DisasContext *VAR_0, int VAR_1, int VAR_2, int VAR_3, bool VAR_4)
{
if (VAR_4) {
TCGv_i64 tcg_rn = cpu_reg(VAR_0, VAR_2);
switch (VAR_3) {
case 0:
{
TCGv_i64 tmp = tcg_temp_new_i64();
tcg_gen_ext32u_i64(tmp, tcg_rn);
tcg_gen_st_i64(tmp, cpu_env, fp_reg_offset(VAR_1, MO_64));
tcg_gen_movi_i64(tmp, 0);
tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(VAR_1));
tcg_temp_free_i64(tmp);
break;
}
case 1:
{
TCGv_i64 tmp = tcg_const_i64(0);
tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_offset(VAR_1, MO_64));
tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(VAR_1));
tcg_temp_free_i64(tmp);
break;
}
case 2:
tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_hi_offset(VAR_1));
break;
}
} else {
TCGv_i64 tcg_rd = cpu_reg(VAR_0, VAR_1);
switch (VAR_3) {
case 0:
tcg_gen_ld32u_i64(tcg_rd, cpu_env, fp_reg_offset(VAR_2, MO_32));
break;
case 1:
tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_offset(VAR_2, MO_64));
break;
case 2:
tcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_hi_offset(VAR_2));
break;
}
}
}
|
[
"static void FUNC_0(DisasContext *VAR_0, int VAR_1, int VAR_2, int VAR_3, bool VAR_4)\n{",
"if (VAR_4) {",
"TCGv_i64 tcg_rn = cpu_reg(VAR_0, VAR_2);",
"switch (VAR_3) {",
"case 0:\n{",
"TCGv_i64 tmp = tcg_temp_new_i64();",
"tcg_gen_ext32u_i64(tmp, tcg_rn);",
"tcg_gen_st_i64(tmp, cpu_env, fp_reg_offset(VAR_1, MO_64));",
"tcg_gen_movi_i64(tmp, 0);",
"tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(VAR_1));",
"tcg_temp_free_i64(tmp);",
"break;",
"}",
"case 1:\n{",
"TCGv_i64 tmp = tcg_const_i64(0);",
"tcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_offset(VAR_1, MO_64));",
"tcg_gen_st_i64(tmp, cpu_env, fp_reg_hi_offset(VAR_1));",
"tcg_temp_free_i64(tmp);",
"break;",
"}",
"case 2:\ntcg_gen_st_i64(tcg_rn, cpu_env, fp_reg_hi_offset(VAR_1));",
"break;",
"}",
"} else {",
"TCGv_i64 tcg_rd = cpu_reg(VAR_0, VAR_1);",
"switch (VAR_3) {",
"case 0:\ntcg_gen_ld32u_i64(tcg_rd, cpu_env, fp_reg_offset(VAR_2, MO_32));",
"break;",
"case 1:\ntcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_offset(VAR_2, MO_64));",
"break;",
"case 2:\ntcg_gen_ld_i64(tcg_rd, cpu_env, fp_reg_hi_offset(VAR_2));",
"break;",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61,
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79,
83
],
[
85
],
[
87,
91
],
[
93
],
[
95,
99
],
[
101
],
[
103
],
[
105
],
[
107
]
] |
7,020 |
static void coroutine_fn bdrv_discard_co_entry(void *opaque)
{
DiscardCo *rwco = opaque;
rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
}
| false |
qemu
|
61007b316cd71ee7333ff7a0a749a8949527575f
|
static void coroutine_fn bdrv_discard_co_entry(void *opaque)
{
DiscardCo *rwco = opaque;
rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
}
|
{
"code": [],
"line_no": []
}
|
static void VAR_0 bdrv_discard_co_entry(void *opaque)
{
DiscardCo *rwco = opaque;
rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
}
|
[
"static void VAR_0 bdrv_discard_co_entry(void *opaque)\n{",
"DiscardCo *rwco = opaque;",
"rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);",
"}"
] |
[
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
]
] |
7,022 |
static uint64_t escc_mem_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
SerialState *serial = opaque;
ChannelState *s;
uint32_t saddr;
uint32_t ret;
int channel;
saddr = (addr >> serial->it_shift) & 1;
channel = (addr >> (serial->it_shift + 1)) & 1;
s = &serial->chn[channel];
switch (saddr) {
case SERIAL_CTRL:
trace_escc_mem_readb_ctrl(CHN_C(s), s->reg, s->rregs[s->reg]);
ret = s->rregs[s->reg];
s->reg = 0;
return ret;
case SERIAL_DATA:
s->rregs[R_STATUS] &= ~STATUS_RXAV;
clr_rxint(s);
if (s->type == kbd || s->type == mouse)
ret = get_queue(s);
else
ret = s->rx;
trace_escc_mem_readb_data(CHN_C(s), ret);
if (s->chr)
qemu_chr_accept_input(s->chr);
return ret;
default:
break;
}
return 0;
}
| false |
qemu
|
a8170e5e97ad17ca169c64ba87ae2f53850dab4c
|
static uint64_t escc_mem_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
SerialState *serial = opaque;
ChannelState *s;
uint32_t saddr;
uint32_t ret;
int channel;
saddr = (addr >> serial->it_shift) & 1;
channel = (addr >> (serial->it_shift + 1)) & 1;
s = &serial->chn[channel];
switch (saddr) {
case SERIAL_CTRL:
trace_escc_mem_readb_ctrl(CHN_C(s), s->reg, s->rregs[s->reg]);
ret = s->rregs[s->reg];
s->reg = 0;
return ret;
case SERIAL_DATA:
s->rregs[R_STATUS] &= ~STATUS_RXAV;
clr_rxint(s);
if (s->type == kbd || s->type == mouse)
ret = get_queue(s);
else
ret = s->rx;
trace_escc_mem_readb_data(CHN_C(s), ret);
if (s->chr)
qemu_chr_accept_input(s->chr);
return ret;
default:
break;
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,
unsigned size)
{
SerialState *serial = opaque;
ChannelState *s;
uint32_t saddr;
uint32_t ret;
int VAR_0;
saddr = (addr >> serial->it_shift) & 1;
VAR_0 = (addr >> (serial->it_shift + 1)) & 1;
s = &serial->chn[VAR_0];
switch (saddr) {
case SERIAL_CTRL:
trace_escc_mem_readb_ctrl(CHN_C(s), s->reg, s->rregs[s->reg]);
ret = s->rregs[s->reg];
s->reg = 0;
return ret;
case SERIAL_DATA:
s->rregs[R_STATUS] &= ~STATUS_RXAV;
clr_rxint(s);
if (s->type == kbd || s->type == mouse)
ret = get_queue(s);
else
ret = s->rx;
trace_escc_mem_readb_data(CHN_C(s), ret);
if (s->chr)
qemu_chr_accept_input(s->chr);
return ret;
default:
break;
}
return 0;
}
|
[
"static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{",
"SerialState *serial = opaque;",
"ChannelState *s;",
"uint32_t saddr;",
"uint32_t ret;",
"int VAR_0;",
"saddr = (addr >> serial->it_shift) & 1;",
"VAR_0 = (addr >> (serial->it_shift + 1)) & 1;",
"s = &serial->chn[VAR_0];",
"switch (saddr) {",
"case SERIAL_CTRL:\ntrace_escc_mem_readb_ctrl(CHN_C(s), s->reg, s->rregs[s->reg]);",
"ret = s->rregs[s->reg];",
"s->reg = 0;",
"return ret;",
"case SERIAL_DATA:\ns->rregs[R_STATUS] &= ~STATUS_RXAV;",
"clr_rxint(s);",
"if (s->type == kbd || s->type == mouse)\nret = get_queue(s);",
"else\nret = s->rx;",
"trace_escc_mem_readb_data(CHN_C(s), ret);",
"if (s->chr)\nqemu_chr_accept_input(s->chr);",
"return ret;",
"default:\nbreak;",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43,
45
],
[
47,
49
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
]
] |
7,023 |
static int proxy_parse_opts(QemuOpts *opts, struct FsDriverEntry *fs)
{
const char *socket = qemu_opt_get(opts, "socket");
const char *sock_fd = qemu_opt_get(opts, "sock_fd");
if (!socket && !sock_fd) {
fprintf(stderr, "socket and sock_fd none of the option specified\n");
return -1;
}
if (socket && sock_fd) {
fprintf(stderr, "Both socket and sock_fd options specified\n");
return -1;
}
if (socket) {
fs->path = g_strdup(socket);
fs->export_flags = V9FS_PROXY_SOCK_NAME;
} else {
fs->path = g_strdup(sock_fd);
fs->export_flags = V9FS_PROXY_SOCK_FD;
}
return 0;
}
| false |
qemu
|
494a8ebe713055d3946183f4b395f85a18b43e9e
|
static int proxy_parse_opts(QemuOpts *opts, struct FsDriverEntry *fs)
{
const char *socket = qemu_opt_get(opts, "socket");
const char *sock_fd = qemu_opt_get(opts, "sock_fd");
if (!socket && !sock_fd) {
fprintf(stderr, "socket and sock_fd none of the option specified\n");
return -1;
}
if (socket && sock_fd) {
fprintf(stderr, "Both socket and sock_fd options specified\n");
return -1;
}
if (socket) {
fs->path = g_strdup(socket);
fs->export_flags = V9FS_PROXY_SOCK_NAME;
} else {
fs->path = g_strdup(sock_fd);
fs->export_flags = V9FS_PROXY_SOCK_FD;
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(QemuOpts *VAR_0, struct FsDriverEntry *VAR_1)
{
const char *VAR_2 = qemu_opt_get(VAR_0, "VAR_2");
const char *VAR_3 = qemu_opt_get(VAR_0, "VAR_3");
if (!VAR_2 && !VAR_3) {
fprintf(stderr, "VAR_2 and VAR_3 none of the option specified\n");
return -1;
}
if (VAR_2 && VAR_3) {
fprintf(stderr, "Both VAR_2 and VAR_3 options specified\n");
return -1;
}
if (VAR_2) {
VAR_1->path = g_strdup(VAR_2);
VAR_1->export_flags = V9FS_PROXY_SOCK_NAME;
} else {
VAR_1->path = g_strdup(VAR_3);
VAR_1->export_flags = V9FS_PROXY_SOCK_FD;
}
return 0;
}
|
[
"static int FUNC_0(QemuOpts *VAR_0, struct FsDriverEntry *VAR_1)\n{",
"const char *VAR_2 = qemu_opt_get(VAR_0, \"VAR_2\");",
"const char *VAR_3 = qemu_opt_get(VAR_0, \"VAR_3\");",
"if (!VAR_2 && !VAR_3) {",
"fprintf(stderr, \"VAR_2 and VAR_3 none of the option specified\\n\");",
"return -1;",
"}",
"if (VAR_2 && VAR_3) {",
"fprintf(stderr, \"Both VAR_2 and VAR_3 options specified\\n\");",
"return -1;",
"}",
"if (VAR_2) {",
"VAR_1->path = g_strdup(VAR_2);",
"VAR_1->export_flags = V9FS_PROXY_SOCK_NAME;",
"} else {",
"VAR_1->path = g_strdup(VAR_3);",
"VAR_1->export_flags = V9FS_PROXY_SOCK_FD;",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
]
] |
7,024 |
static void bdrv_co_io_em_complete(void *opaque, int ret)
{
CoroutineIOCompletion *co = opaque;
co->ret = ret;
qemu_coroutine_enter(co->coroutine, NULL);
}
| false |
qemu
|
08844473820c93541fc47bdfeae0f2cc88cfab59
|
static void bdrv_co_io_em_complete(void *opaque, int ret)
{
CoroutineIOCompletion *co = opaque;
co->ret = ret;
qemu_coroutine_enter(co->coroutine, NULL);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(void *VAR_0, int VAR_1)
{
CoroutineIOCompletion *co = VAR_0;
co->VAR_1 = VAR_1;
qemu_coroutine_enter(co->coroutine, NULL);
}
|
[
"static void FUNC_0(void *VAR_0, int VAR_1)\n{",
"CoroutineIOCompletion *co = VAR_0;",
"co->VAR_1 = VAR_1;",
"qemu_coroutine_enter(co->coroutine, NULL);",
"}"
] |
[
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
]
] |
7,025 |
START_TEST(qobject_to_qdict_test)
{
fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
}
| false |
qemu
|
ac531cb6e542b1e61d668604adf9dc5306a948c0
|
START_TEST(qobject_to_qdict_test)
{
fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
}
|
{
"code": [],
"line_no": []
}
|
FUNC_0(VAR_0)
{
fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
}
|
[
"FUNC_0(VAR_0)\n{",
"fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
]
] |
7,028 |
static int mmu_translate_pte(CPUS390XState *env, target_ulong vaddr,
uint64_t asc, uint64_t asce,
target_ulong *raddr, int *flags, int rw)
{
if (asce & _PAGE_INVALID) {
DPRINTF("%s: PTE=0x%" PRIx64 " invalid\n", __func__, asce);
trigger_page_fault(env, vaddr, PGM_PAGE_TRANS, asc, rw);
return -1;
}
if (asce & _PAGE_RO) {
*flags &= ~PAGE_WRITE;
}
*raddr = asce & _ASCE_ORIGIN;
PTE_DPRINTF("%s: PTE=0x%" PRIx64 "\n", __func__, asce);
return 0;
}
| false |
qemu
|
e3e09d87c6e69c2da684d5aacabe3124ebcb6f8e
|
static int mmu_translate_pte(CPUS390XState *env, target_ulong vaddr,
uint64_t asc, uint64_t asce,
target_ulong *raddr, int *flags, int rw)
{
if (asce & _PAGE_INVALID) {
DPRINTF("%s: PTE=0x%" PRIx64 " invalid\n", __func__, asce);
trigger_page_fault(env, vaddr, PGM_PAGE_TRANS, asc, rw);
return -1;
}
if (asce & _PAGE_RO) {
*flags &= ~PAGE_WRITE;
}
*raddr = asce & _ASCE_ORIGIN;
PTE_DPRINTF("%s: PTE=0x%" PRIx64 "\n", __func__, asce);
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(CPUS390XState *VAR_0, target_ulong VAR_1,
uint64_t VAR_2, uint64_t VAR_3,
target_ulong *VAR_4, int *VAR_5, int VAR_6)
{
if (VAR_3 & _PAGE_INVALID) {
DPRINTF("%s: PTE=0x%" PRIx64 " invalid\n", __func__, VAR_3);
trigger_page_fault(VAR_0, VAR_1, PGM_PAGE_TRANS, VAR_2, VAR_6);
return -1;
}
if (VAR_3 & _PAGE_RO) {
*VAR_5 &= ~PAGE_WRITE;
}
*VAR_4 = VAR_3 & _ASCE_ORIGIN;
PTE_DPRINTF("%s: PTE=0x%" PRIx64 "\n", __func__, VAR_3);
return 0;
}
|
[
"static int FUNC_0(CPUS390XState *VAR_0, target_ulong VAR_1,\nuint64_t VAR_2, uint64_t VAR_3,\ntarget_ulong *VAR_4, int *VAR_5, int VAR_6)\n{",
"if (VAR_3 & _PAGE_INVALID) {",
"DPRINTF(\"%s: PTE=0x%\" PRIx64 \" invalid\\n\", __func__, VAR_3);",
"trigger_page_fault(VAR_0, VAR_1, PGM_PAGE_TRANS, VAR_2, VAR_6);",
"return -1;",
"}",
"if (VAR_3 & _PAGE_RO) {",
"*VAR_5 &= ~PAGE_WRITE;",
"}",
"*VAR_4 = VAR_3 & _ASCE_ORIGIN;",
"PTE_DPRINTF(\"%s: PTE=0x%\" PRIx64 \"\\n\", __func__, VAR_3);",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29
],
[
33
],
[
37
],
[
39
]
] |
7,029 |
static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size,
const void *data)
{
uint64_t addr;
addr = guest_alloc(vs->alloc, alloc_size);
if (data) {
memwrite(addr, data, alloc_size);
}
return addr;
}
| false |
qemu
|
a980f7f2c2f4d7e9a1eba4f804cd66dbd458b6d4
|
static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size,
const void *data)
{
uint64_t addr;
addr = guest_alloc(vs->alloc, alloc_size);
if (data) {
memwrite(addr, data, alloc_size);
}
return addr;
}
|
{
"code": [],
"line_no": []
}
|
static uint64_t FUNC_0(QVirtIOSCSI *vs, size_t alloc_size,
const void *data)
{
uint64_t addr;
addr = guest_alloc(vs->alloc, alloc_size);
if (data) {
memwrite(addr, data, alloc_size);
}
return addr;
}
|
[
"static uint64_t FUNC_0(QVirtIOSCSI *vs, size_t alloc_size,\nconst void *data)\n{",
"uint64_t addr;",
"addr = guest_alloc(vs->alloc, alloc_size);",
"if (data) {",
"memwrite(addr, data, alloc_size);",
"}",
"return addr;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
]
] |
7,030 |
guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
GIOFunc func, void *user_data)
{
GSource *src;
guint tag;
if (s->chr_add_watch == NULL) {
return -ENOSYS;
}
src = s->chr_add_watch(s, cond);
g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
tag = g_source_attach(src, NULL);
g_source_unref(src);
return tag;
}
| false |
qemu
|
2c8a59422c06fe1e37c85502d92ccdfb5e2ac987
|
guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
GIOFunc func, void *user_data)
{
GSource *src;
guint tag;
if (s->chr_add_watch == NULL) {
return -ENOSYS;
}
src = s->chr_add_watch(s, cond);
g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
tag = g_source_attach(src, NULL);
g_source_unref(src);
return tag;
}
|
{
"code": [],
"line_no": []
}
|
guint FUNC_0(CharDriverState *s, GIOCondition cond,
GIOFunc func, void *user_data)
{
GSource *src;
guint tag;
if (s->chr_add_watch == NULL) {
return -ENOSYS;
}
src = s->chr_add_watch(s, cond);
g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
tag = g_source_attach(src, NULL);
g_source_unref(src);
return tag;
}
|
[
"guint FUNC_0(CharDriverState *s, GIOCondition cond,\nGIOFunc func, void *user_data)\n{",
"GSource *src;",
"guint tag;",
"if (s->chr_add_watch == NULL) {",
"return -ENOSYS;",
"}",
"src = s->chr_add_watch(s, cond);",
"g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);",
"tag = g_source_attach(src, NULL);",
"g_source_unref(src);",
"return tag;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
]
] |
7,031 |
static void notdirty_mem_write(void *opaque, target_phys_addr_t ram_addr,
uint64_t val, unsigned size)
{
int dirty_flags;
dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
if (!(dirty_flags & CODE_DIRTY_FLAG)) {
#if !defined(CONFIG_USER_ONLY)
tb_invalidate_phys_page_fast(ram_addr, size);
dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
#endif
}
switch (size) {
case 1:
stb_p(qemu_get_ram_ptr(ram_addr), val);
break;
case 2:
stw_p(qemu_get_ram_ptr(ram_addr), val);
break;
case 4:
stl_p(qemu_get_ram_ptr(ram_addr), val);
break;
default:
abort();
}
dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
/* we remove the notdirty callback only if the code has been
flushed */
if (dirty_flags == 0xff)
tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
}
| false |
qemu
|
a8170e5e97ad17ca169c64ba87ae2f53850dab4c
|
static void notdirty_mem_write(void *opaque, target_phys_addr_t ram_addr,
uint64_t val, unsigned size)
{
int dirty_flags;
dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
if (!(dirty_flags & CODE_DIRTY_FLAG)) {
#if !defined(CONFIG_USER_ONLY)
tb_invalidate_phys_page_fast(ram_addr, size);
dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
#endif
}
switch (size) {
case 1:
stb_p(qemu_get_ram_ptr(ram_addr), val);
break;
case 2:
stw_p(qemu_get_ram_ptr(ram_addr), val);
break;
case 4:
stl_p(qemu_get_ram_ptr(ram_addr), val);
break;
default:
abort();
}
dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
if (dirty_flags == 0xff)
tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned VAR_3)
{
int VAR_4;
VAR_4 = cpu_physical_memory_get_dirty_flags(VAR_1);
if (!(VAR_4 & CODE_DIRTY_FLAG)) {
#if !defined(CONFIG_USER_ONLY)
tb_invalidate_phys_page_fast(VAR_1, VAR_3);
VAR_4 = cpu_physical_memory_get_dirty_flags(VAR_1);
#endif
}
switch (VAR_3) {
case 1:
stb_p(qemu_get_ram_ptr(VAR_1), VAR_2);
break;
case 2:
stw_p(qemu_get_ram_ptr(VAR_1), VAR_2);
break;
case 4:
stl_p(qemu_get_ram_ptr(VAR_1), VAR_2);
break;
default:
abort();
}
VAR_4 |= (0xff & ~CODE_DIRTY_FLAG);
cpu_physical_memory_set_dirty_flags(VAR_1, VAR_4);
if (VAR_4 == 0xff)
tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
}
|
[
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{",
"int VAR_4;",
"VAR_4 = cpu_physical_memory_get_dirty_flags(VAR_1);",
"if (!(VAR_4 & CODE_DIRTY_FLAG)) {",
"#if !defined(CONFIG_USER_ONLY)\ntb_invalidate_phys_page_fast(VAR_1, VAR_3);",
"VAR_4 = cpu_physical_memory_get_dirty_flags(VAR_1);",
"#endif\n}",
"switch (VAR_3) {",
"case 1:\nstb_p(qemu_get_ram_ptr(VAR_1), VAR_2);",
"break;",
"case 2:\nstw_p(qemu_get_ram_ptr(VAR_1), VAR_2);",
"break;",
"case 4:\nstl_p(qemu_get_ram_ptr(VAR_1), VAR_2);",
"break;",
"default:\nabort();",
"}",
"VAR_4 |= (0xff & ~CODE_DIRTY_FLAG);",
"cpu_physical_memory_set_dirty_flags(VAR_1, VAR_4);",
"if (VAR_4 == 0xff)\ntlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17
],
[
19,
21
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
35
],
[
37,
39
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
51
],
[
57,
59
],
[
61
]
] |
7,032 |
static void v9fs_xattrwalk(void *opaque)
{
int64_t size;
V9fsString name;
ssize_t err = 0;
size_t offset = 7;
int32_t fid, newfid;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp = NULL;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);
file_fidp = get_fid(pdu, fid);
if (file_fidp == NULL) {
err = -ENOENT;
goto out_nofid;
}
xattr_fidp = alloc_fid(s, newfid);
if (xattr_fidp == NULL) {
err = -EINVAL;
goto out;
}
v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);
if (name.data[0] == 0) {
/*
* listxattr request. Get the size first
*/
size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);
if (size < 0) {
err = size;
clunk_fid(s, xattr_fidp->fid);
goto out;
}
/*
* Read the xattr value
*/
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = -1;
if (size) {
xattr_fidp->fs.xattr.value = g_malloc(size);
err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,
xattr_fidp->fs.xattr.value,
xattr_fidp->fs.xattr.len);
if (err < 0) {
clunk_fid(s, xattr_fidp->fid);
goto out;
}
}
offset += pdu_marshal(pdu, offset, "q", size);
err = offset;
} else {
/*
* specific xattr fid. We check for xattr
* presence also collect the xattr size
*/
size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
&name, NULL, 0);
if (size < 0) {
err = size;
clunk_fid(s, xattr_fidp->fid);
goto out;
}
/*
* Read the xattr value
*/
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = -1;
if (size) {
xattr_fidp->fs.xattr.value = g_malloc(size);
err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
&name, xattr_fidp->fs.xattr.value,
xattr_fidp->fs.xattr.len);
if (err < 0) {
clunk_fid(s, xattr_fidp->fid);
goto out;
}
}
offset += pdu_marshal(pdu, offset, "q", size);
err = offset;
}
trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);
out:
put_fid(pdu, file_fidp);
if (xattr_fidp) {
put_fid(pdu, xattr_fidp);
}
out_nofid:
complete_pdu(s, pdu, err);
v9fs_string_free(&name);
}
| false |
qemu
|
ddca7f86ac022289840e0200fd4050b2b58e9176
|
static void v9fs_xattrwalk(void *opaque)
{
int64_t size;
V9fsString name;
ssize_t err = 0;
size_t offset = 7;
int32_t fid, newfid;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp = NULL;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);
file_fidp = get_fid(pdu, fid);
if (file_fidp == NULL) {
err = -ENOENT;
goto out_nofid;
}
xattr_fidp = alloc_fid(s, newfid);
if (xattr_fidp == NULL) {
err = -EINVAL;
goto out;
}
v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);
if (name.data[0] == 0) {
size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);
if (size < 0) {
err = size;
clunk_fid(s, xattr_fidp->fid);
goto out;
}
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = -1;
if (size) {
xattr_fidp->fs.xattr.value = g_malloc(size);
err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,
xattr_fidp->fs.xattr.value,
xattr_fidp->fs.xattr.len);
if (err < 0) {
clunk_fid(s, xattr_fidp->fid);
goto out;
}
}
offset += pdu_marshal(pdu, offset, "q", size);
err = offset;
} else {
size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
&name, NULL, 0);
if (size < 0) {
err = size;
clunk_fid(s, xattr_fidp->fid);
goto out;
}
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = -1;
if (size) {
xattr_fidp->fs.xattr.value = g_malloc(size);
err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
&name, xattr_fidp->fs.xattr.value,
xattr_fidp->fs.xattr.len);
if (err < 0) {
clunk_fid(s, xattr_fidp->fid);
goto out;
}
}
offset += pdu_marshal(pdu, offset, "q", size);
err = offset;
}
trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);
out:
put_fid(pdu, file_fidp);
if (xattr_fidp) {
put_fid(pdu, xattr_fidp);
}
out_nofid:
complete_pdu(s, pdu, err);
v9fs_string_free(&name);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(void *VAR_0)
{
int64_t size;
V9fsString name;
ssize_t err = 0;
size_t offset = 7;
int32_t fid, newfid;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp = NULL;
V9fsPDU *pdu = VAR_0;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name);
trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);
file_fidp = get_fid(pdu, fid);
if (file_fidp == NULL) {
err = -ENOENT;
goto out_nofid;
}
xattr_fidp = alloc_fid(s, newfid);
if (xattr_fidp == NULL) {
err = -EINVAL;
goto out;
}
v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);
if (name.data[0] == 0) {
size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);
if (size < 0) {
err = size;
clunk_fid(s, xattr_fidp->fid);
goto out;
}
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = -1;
if (size) {
xattr_fidp->fs.xattr.value = g_malloc(size);
err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,
xattr_fidp->fs.xattr.value,
xattr_fidp->fs.xattr.len);
if (err < 0) {
clunk_fid(s, xattr_fidp->fid);
goto out;
}
}
offset += pdu_marshal(pdu, offset, "q", size);
err = offset;
} else {
size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
&name, NULL, 0);
if (size < 0) {
err = size;
clunk_fid(s, xattr_fidp->fid);
goto out;
}
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = -1;
if (size) {
xattr_fidp->fs.xattr.value = g_malloc(size);
err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,
&name, xattr_fidp->fs.xattr.value,
xattr_fidp->fs.xattr.len);
if (err < 0) {
clunk_fid(s, xattr_fidp->fid);
goto out;
}
}
offset += pdu_marshal(pdu, offset, "q", size);
err = offset;
}
trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);
out:
put_fid(pdu, file_fidp);
if (xattr_fidp) {
put_fid(pdu, xattr_fidp);
}
out_nofid:
complete_pdu(s, pdu, err);
v9fs_string_free(&name);
}
|
[
"static void FUNC_0(void *VAR_0)\n{",
"int64_t size;",
"V9fsString name;",
"ssize_t err = 0;",
"size_t offset = 7;",
"int32_t fid, newfid;",
"V9fsFidState *file_fidp;",
"V9fsFidState *xattr_fidp = NULL;",
"V9fsPDU *pdu = VAR_0;",
"V9fsState *s = pdu->s;",
"pdu_unmarshal(pdu, offset, \"dds\", &fid, &newfid, &name);",
"trace_v9fs_xattrwalk(pdu->tag, pdu->id, fid, newfid, name.data);",
"file_fidp = get_fid(pdu, fid);",
"if (file_fidp == NULL) {",
"err = -ENOENT;",
"goto out_nofid;",
"}",
"xattr_fidp = alloc_fid(s, newfid);",
"if (xattr_fidp == NULL) {",
"err = -EINVAL;",
"goto out;",
"}",
"v9fs_path_copy(&xattr_fidp->path, &file_fidp->path);",
"if (name.data[0] == 0) {",
"size = v9fs_co_llistxattr(pdu, &xattr_fidp->path, NULL, 0);",
"if (size < 0) {",
"err = size;",
"clunk_fid(s, xattr_fidp->fid);",
"goto out;",
"}",
"xattr_fidp->fs.xattr.len = size;",
"xattr_fidp->fid_type = P9_FID_XATTR;",
"xattr_fidp->fs.xattr.copied_len = -1;",
"if (size) {",
"xattr_fidp->fs.xattr.value = g_malloc(size);",
"err = v9fs_co_llistxattr(pdu, &xattr_fidp->path,\nxattr_fidp->fs.xattr.value,\nxattr_fidp->fs.xattr.len);",
"if (err < 0) {",
"clunk_fid(s, xattr_fidp->fid);",
"goto out;",
"}",
"}",
"offset += pdu_marshal(pdu, offset, \"q\", size);",
"err = offset;",
"} else {",
"size = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,\n&name, NULL, 0);",
"if (size < 0) {",
"err = size;",
"clunk_fid(s, xattr_fidp->fid);",
"goto out;",
"}",
"xattr_fidp->fs.xattr.len = size;",
"xattr_fidp->fid_type = P9_FID_XATTR;",
"xattr_fidp->fs.xattr.copied_len = -1;",
"if (size) {",
"xattr_fidp->fs.xattr.value = g_malloc(size);",
"err = v9fs_co_lgetxattr(pdu, &xattr_fidp->path,\n&name, xattr_fidp->fs.xattr.value,\nxattr_fidp->fs.xattr.len);",
"if (err < 0) {",
"clunk_fid(s, xattr_fidp->fid);",
"goto out;",
"}",
"}",
"offset += pdu_marshal(pdu, offset, \"q\", size);",
"err = offset;",
"}",
"trace_v9fs_xattrwalk_return(pdu->tag, pdu->id, size);",
"out:\nput_fid(pdu, file_fidp);",
"if (xattr_fidp) {",
"put_fid(pdu, xattr_fidp);",
"}",
"out_nofid:\ncomplete_pdu(s, pdu, err);",
"v9fs_string_free(&name);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89,
91,
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
119,
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149,
151,
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173,
175
],
[
177
],
[
179
],
[
181
],
[
183,
185
],
[
187
],
[
189
]
] |
7,034 |
void kvm_cpu_synchronize_state(CPUState *env)
{
if (!env->kvm_vcpu_dirty)
run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
}
| false |
qemu
|
a426e122173f36f05ea2cb72dcff77b7408546ce
|
void kvm_cpu_synchronize_state(CPUState *env)
{
if (!env->kvm_vcpu_dirty)
run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(CPUState *VAR_0)
{
if (!VAR_0->kvm_vcpu_dirty)
run_on_cpu(VAR_0, do_kvm_cpu_synchronize_state, VAR_0);
}
|
[
"void FUNC_0(CPUState *VAR_0)\n{",
"if (!VAR_0->kvm_vcpu_dirty)\nrun_on_cpu(VAR_0, do_kvm_cpu_synchronize_state, VAR_0);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5,
7
],
[
9
]
] |
7,035 |
static void virtio_blk_rw_complete(void *opaque, int ret)
{
VirtIOBlockReq *req = opaque;
trace_virtio_blk_rw_complete(req, ret);
if (ret) {
int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
bool is_read = !(p & VIRTIO_BLK_T_OUT);
if (virtio_blk_handle_rw_error(req, -ret, is_read))
return;
}
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct);
virtio_blk_free_request(req);
}
| false |
qemu
|
4be746345f13e99e468c60acbd3a355e8183e3ce
|
static void virtio_blk_rw_complete(void *opaque, int ret)
{
VirtIOBlockReq *req = opaque;
trace_virtio_blk_rw_complete(req, ret);
if (ret) {
int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
bool is_read = !(p & VIRTIO_BLK_T_OUT);
if (virtio_blk_handle_rw_error(req, -ret, is_read))
return;
}
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct);
virtio_blk_free_request(req);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(void *VAR_0, int VAR_1)
{
VirtIOBlockReq *req = VAR_0;
trace_virtio_blk_rw_complete(req, VAR_1);
if (VAR_1) {
int VAR_2 = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);
bool is_read = !(VAR_2 & VIRTIO_BLK_T_OUT);
if (virtio_blk_handle_rw_error(req, -VAR_1, is_read))
return;
}
virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct);
virtio_blk_free_request(req);
}
|
[
"static void FUNC_0(void *VAR_0, int VAR_1)\n{",
"VirtIOBlockReq *req = VAR_0;",
"trace_virtio_blk_rw_complete(req, VAR_1);",
"if (VAR_1) {",
"int VAR_2 = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);",
"bool is_read = !(VAR_2 & VIRTIO_BLK_T_OUT);",
"if (virtio_blk_handle_rw_error(req, -VAR_1, is_read))\nreturn;",
"}",
"virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);",
"block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct);",
"virtio_blk_free_request(req);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
7,036 |
void qmp_migrate_set_parameters(MigrationParameters *params, Error **errp)
{
MigrationState *s = migrate_get_current();
if (params->has_compress_level &&
(params->compress_level < 0 || params->compress_level > 9)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
"is invalid, it should be in the range of 0 to 9");
return;
}
if (params->has_compress_threads &&
(params->compress_threads < 1 || params->compress_threads > 255)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"compress_threads",
"is invalid, it should be in the range of 1 to 255");
return;
}
if (params->has_decompress_threads &&
(params->decompress_threads < 1 || params->decompress_threads > 255)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"decompress_threads",
"is invalid, it should be in the range of 1 to 255");
return;
}
if (params->has_cpu_throttle_initial &&
(params->cpu_throttle_initial < 1 ||
params->cpu_throttle_initial > 99)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"cpu_throttle_initial",
"an integer in the range of 1 to 99");
return;
}
if (params->has_cpu_throttle_increment &&
(params->cpu_throttle_increment < 1 ||
params->cpu_throttle_increment > 99)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"cpu_throttle_increment",
"an integer in the range of 1 to 99");
return;
}
if (params->has_max_bandwidth &&
(params->max_bandwidth < 0 || params->max_bandwidth > SIZE_MAX)) {
error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the"
" range of 0 to %zu bytes/second", SIZE_MAX);
return;
}
if (params->has_downtime_limit &&
(params->downtime_limit < 0 || params->downtime_limit > 2000000)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"downtime_limit",
"an integer in the range of 0 to 2000000 milliseconds");
return;
}
if (params->has_x_checkpoint_delay && (params->x_checkpoint_delay < 0)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"x_checkpoint_delay",
"is invalid, it should be positive");
}
if (params->has_compress_level) {
s->parameters.compress_level = params->compress_level;
}
if (params->has_compress_threads) {
s->parameters.compress_threads = params->compress_threads;
}
if (params->has_decompress_threads) {
s->parameters.decompress_threads = params->decompress_threads;
}
if (params->has_cpu_throttle_initial) {
s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
}
if (params->has_cpu_throttle_increment) {
s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
}
if (params->has_tls_creds) {
g_free(s->parameters.tls_creds);
s->parameters.tls_creds = g_strdup(params->tls_creds);
}
if (params->has_tls_hostname) {
g_free(s->parameters.tls_hostname);
s->parameters.tls_hostname = g_strdup(params->tls_hostname);
}
if (params->has_max_bandwidth) {
s->parameters.max_bandwidth = params->max_bandwidth;
if (s->to_dst_file) {
qemu_file_set_rate_limit(s->to_dst_file,
s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
}
}
if (params->has_downtime_limit) {
s->parameters.downtime_limit = params->downtime_limit;
}
if (params->has_x_checkpoint_delay) {
s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
if (migration_in_colo_state()) {
colo_checkpoint_notify(s);
}
}
}
| false |
qemu
|
87c9cc1c30d2981e9686aaf245b3e2420062f7d4
|
void qmp_migrate_set_parameters(MigrationParameters *params, Error **errp)
{
MigrationState *s = migrate_get_current();
if (params->has_compress_level &&
(params->compress_level < 0 || params->compress_level > 9)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
"is invalid, it should be in the range of 0 to 9");
return;
}
if (params->has_compress_threads &&
(params->compress_threads < 1 || params->compress_threads > 255)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"compress_threads",
"is invalid, it should be in the range of 1 to 255");
return;
}
if (params->has_decompress_threads &&
(params->decompress_threads < 1 || params->decompress_threads > 255)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"decompress_threads",
"is invalid, it should be in the range of 1 to 255");
return;
}
if (params->has_cpu_throttle_initial &&
(params->cpu_throttle_initial < 1 ||
params->cpu_throttle_initial > 99)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"cpu_throttle_initial",
"an integer in the range of 1 to 99");
return;
}
if (params->has_cpu_throttle_increment &&
(params->cpu_throttle_increment < 1 ||
params->cpu_throttle_increment > 99)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"cpu_throttle_increment",
"an integer in the range of 1 to 99");
return;
}
if (params->has_max_bandwidth &&
(params->max_bandwidth < 0 || params->max_bandwidth > SIZE_MAX)) {
error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the"
" range of 0 to %zu bytes/second", SIZE_MAX);
return;
}
if (params->has_downtime_limit &&
(params->downtime_limit < 0 || params->downtime_limit > 2000000)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"downtime_limit",
"an integer in the range of 0 to 2000000 milliseconds");
return;
}
if (params->has_x_checkpoint_delay && (params->x_checkpoint_delay < 0)) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"x_checkpoint_delay",
"is invalid, it should be positive");
}
if (params->has_compress_level) {
s->parameters.compress_level = params->compress_level;
}
if (params->has_compress_threads) {
s->parameters.compress_threads = params->compress_threads;
}
if (params->has_decompress_threads) {
s->parameters.decompress_threads = params->decompress_threads;
}
if (params->has_cpu_throttle_initial) {
s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
}
if (params->has_cpu_throttle_increment) {
s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
}
if (params->has_tls_creds) {
g_free(s->parameters.tls_creds);
s->parameters.tls_creds = g_strdup(params->tls_creds);
}
if (params->has_tls_hostname) {
g_free(s->parameters.tls_hostname);
s->parameters.tls_hostname = g_strdup(params->tls_hostname);
}
if (params->has_max_bandwidth) {
s->parameters.max_bandwidth = params->max_bandwidth;
if (s->to_dst_file) {
qemu_file_set_rate_limit(s->to_dst_file,
s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
}
}
if (params->has_downtime_limit) {
s->parameters.downtime_limit = params->downtime_limit;
}
if (params->has_x_checkpoint_delay) {
s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
if (migration_in_colo_state()) {
colo_checkpoint_notify(s);
}
}
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(MigrationParameters *VAR_0, Error **VAR_1)
{
MigrationState *s = migrate_get_current();
if (VAR_0->has_compress_level &&
(VAR_0->compress_level < 0 || VAR_0->compress_level > 9)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE, "compress_level",
"is invalid, it should be in the range of 0 to 9");
return;
}
if (VAR_0->has_compress_threads &&
(VAR_0->compress_threads < 1 || VAR_0->compress_threads > 255)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,
"compress_threads",
"is invalid, it should be in the range of 1 to 255");
return;
}
if (VAR_0->has_decompress_threads &&
(VAR_0->decompress_threads < 1 || VAR_0->decompress_threads > 255)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,
"decompress_threads",
"is invalid, it should be in the range of 1 to 255");
return;
}
if (VAR_0->has_cpu_throttle_initial &&
(VAR_0->cpu_throttle_initial < 1 ||
VAR_0->cpu_throttle_initial > 99)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,
"cpu_throttle_initial",
"an integer in the range of 1 to 99");
return;
}
if (VAR_0->has_cpu_throttle_increment &&
(VAR_0->cpu_throttle_increment < 1 ||
VAR_0->cpu_throttle_increment > 99)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,
"cpu_throttle_increment",
"an integer in the range of 1 to 99");
return;
}
if (VAR_0->has_max_bandwidth &&
(VAR_0->max_bandwidth < 0 || VAR_0->max_bandwidth > SIZE_MAX)) {
error_setg(VAR_1, "Parameter 'max_bandwidth' expects an integer in the"
" range of 0 to %zu bytes/second", SIZE_MAX);
return;
}
if (VAR_0->has_downtime_limit &&
(VAR_0->downtime_limit < 0 || VAR_0->downtime_limit > 2000000)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,
"downtime_limit",
"an integer in the range of 0 to 2000000 milliseconds");
return;
}
if (VAR_0->has_x_checkpoint_delay && (VAR_0->x_checkpoint_delay < 0)) {
error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,
"x_checkpoint_delay",
"is invalid, it should be positive");
}
if (VAR_0->has_compress_level) {
s->parameters.compress_level = VAR_0->compress_level;
}
if (VAR_0->has_compress_threads) {
s->parameters.compress_threads = VAR_0->compress_threads;
}
if (VAR_0->has_decompress_threads) {
s->parameters.decompress_threads = VAR_0->decompress_threads;
}
if (VAR_0->has_cpu_throttle_initial) {
s->parameters.cpu_throttle_initial = VAR_0->cpu_throttle_initial;
}
if (VAR_0->has_cpu_throttle_increment) {
s->parameters.cpu_throttle_increment = VAR_0->cpu_throttle_increment;
}
if (VAR_0->has_tls_creds) {
g_free(s->parameters.tls_creds);
s->parameters.tls_creds = g_strdup(VAR_0->tls_creds);
}
if (VAR_0->has_tls_hostname) {
g_free(s->parameters.tls_hostname);
s->parameters.tls_hostname = g_strdup(VAR_0->tls_hostname);
}
if (VAR_0->has_max_bandwidth) {
s->parameters.max_bandwidth = VAR_0->max_bandwidth;
if (s->to_dst_file) {
qemu_file_set_rate_limit(s->to_dst_file,
s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
}
}
if (VAR_0->has_downtime_limit) {
s->parameters.downtime_limit = VAR_0->downtime_limit;
}
if (VAR_0->has_x_checkpoint_delay) {
s->parameters.x_checkpoint_delay = VAR_0->x_checkpoint_delay;
if (migration_in_colo_state()) {
colo_checkpoint_notify(s);
}
}
}
|
[
"void FUNC_0(MigrationParameters *VAR_0, Error **VAR_1)\n{",
"MigrationState *s = migrate_get_current();",
"if (VAR_0->has_compress_level &&\n(VAR_0->compress_level < 0 || VAR_0->compress_level > 9)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE, \"compress_level\",\n\"is invalid, it should be in the range of 0 to 9\");",
"return;",
"}",
"if (VAR_0->has_compress_threads &&\n(VAR_0->compress_threads < 1 || VAR_0->compress_threads > 255)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,\n\"compress_threads\",\n\"is invalid, it should be in the range of 1 to 255\");",
"return;",
"}",
"if (VAR_0->has_decompress_threads &&\n(VAR_0->decompress_threads < 1 || VAR_0->decompress_threads > 255)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,\n\"decompress_threads\",\n\"is invalid, it should be in the range of 1 to 255\");",
"return;",
"}",
"if (VAR_0->has_cpu_throttle_initial &&\n(VAR_0->cpu_throttle_initial < 1 ||\nVAR_0->cpu_throttle_initial > 99)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,\n\"cpu_throttle_initial\",\n\"an integer in the range of 1 to 99\");",
"return;",
"}",
"if (VAR_0->has_cpu_throttle_increment &&\n(VAR_0->cpu_throttle_increment < 1 ||\nVAR_0->cpu_throttle_increment > 99)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,\n\"cpu_throttle_increment\",\n\"an integer in the range of 1 to 99\");",
"return;",
"}",
"if (VAR_0->has_max_bandwidth &&\n(VAR_0->max_bandwidth < 0 || VAR_0->max_bandwidth > SIZE_MAX)) {",
"error_setg(VAR_1, \"Parameter 'max_bandwidth' expects an integer in the\"\n\" range of 0 to %zu bytes/second\", SIZE_MAX);",
"return;",
"}",
"if (VAR_0->has_downtime_limit &&\n(VAR_0->downtime_limit < 0 || VAR_0->downtime_limit > 2000000)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,\n\"downtime_limit\",\n\"an integer in the range of 0 to 2000000 milliseconds\");",
"return;",
"}",
"if (VAR_0->has_x_checkpoint_delay && (VAR_0->x_checkpoint_delay < 0)) {",
"error_setg(VAR_1, QERR_INVALID_PARAMETER_VALUE,\n\"x_checkpoint_delay\",\n\"is invalid, it should be positive\");",
"}",
"if (VAR_0->has_compress_level) {",
"s->parameters.compress_level = VAR_0->compress_level;",
"}",
"if (VAR_0->has_compress_threads) {",
"s->parameters.compress_threads = VAR_0->compress_threads;",
"}",
"if (VAR_0->has_decompress_threads) {",
"s->parameters.decompress_threads = VAR_0->decompress_threads;",
"}",
"if (VAR_0->has_cpu_throttle_initial) {",
"s->parameters.cpu_throttle_initial = VAR_0->cpu_throttle_initial;",
"}",
"if (VAR_0->has_cpu_throttle_increment) {",
"s->parameters.cpu_throttle_increment = VAR_0->cpu_throttle_increment;",
"}",
"if (VAR_0->has_tls_creds) {",
"g_free(s->parameters.tls_creds);",
"s->parameters.tls_creds = g_strdup(VAR_0->tls_creds);",
"}",
"if (VAR_0->has_tls_hostname) {",
"g_free(s->parameters.tls_hostname);",
"s->parameters.tls_hostname = g_strdup(VAR_0->tls_hostname);",
"}",
"if (VAR_0->has_max_bandwidth) {",
"s->parameters.max_bandwidth = VAR_0->max_bandwidth;",
"if (s->to_dst_file) {",
"qemu_file_set_rate_limit(s->to_dst_file,\ns->parameters.max_bandwidth / XFER_LIMIT_RATIO);",
"}",
"}",
"if (VAR_0->has_downtime_limit) {",
"s->parameters.downtime_limit = VAR_0->downtime_limit;",
"}",
"if (VAR_0->has_x_checkpoint_delay) {",
"s->parameters.x_checkpoint_delay = VAR_0->x_checkpoint_delay;",
"if (migration_in_colo_state()) {",
"colo_checkpoint_notify(s);",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
11
],
[
13,
15
],
[
17
],
[
19
],
[
21,
23
],
[
25,
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
39,
41,
43
],
[
45
],
[
47
],
[
49,
51,
53
],
[
55,
57,
59
],
[
61
],
[
63
],
[
65,
67,
69
],
[
71,
73,
75
],
[
77
],
[
79
],
[
81,
83
],
[
85,
87
],
[
89
],
[
91
],
[
93,
95
],
[
97,
99,
101
],
[
103
],
[
105
],
[
107
],
[
109,
111,
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171,
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
]
] |
7,038 |
uint64_t HELPER(lpq)(CPUS390XState *env, uint64_t addr)
{
uintptr_t ra = GETPC();
uint64_t hi, lo;
if (parallel_cpus) {
#ifndef CONFIG_ATOMIC128
cpu_loop_exit_atomic(ENV_GET_CPU(env), ra);
#else
int mem_idx = cpu_mmu_index(env, false);
TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
Int128 v = helper_atomic_ldo_be_mmu(env, addr, oi, ra);
hi = int128_gethi(v);
lo = int128_getlo(v);
#endif
} else {
check_alignment(env, addr, 16, ra);
hi = cpu_ldq_data_ra(env, addr + 0, ra);
lo = cpu_ldq_data_ra(env, addr + 8, ra);
}
env->retxl = lo;
return hi;
}
| false |
qemu
|
6476615d385eb249105b25873ef30ba4b9c808dc
|
uint64_t HELPER(lpq)(CPUS390XState *env, uint64_t addr)
{
uintptr_t ra = GETPC();
uint64_t hi, lo;
if (parallel_cpus) {
#ifndef CONFIG_ATOMIC128
cpu_loop_exit_atomic(ENV_GET_CPU(env), ra);
#else
int mem_idx = cpu_mmu_index(env, false);
TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
Int128 v = helper_atomic_ldo_be_mmu(env, addr, oi, ra);
hi = int128_gethi(v);
lo = int128_getlo(v);
#endif
} else {
check_alignment(env, addr, 16, ra);
hi = cpu_ldq_data_ra(env, addr + 0, ra);
lo = cpu_ldq_data_ra(env, addr + 8, ra);
}
env->retxl = lo;
return hi;
}
|
{
"code": [],
"line_no": []
}
|
uint64_t FUNC_0(lpq)(CPUS390XState *env, uint64_t addr)
{
uintptr_t ra = GETPC();
uint64_t hi, lo;
if (parallel_cpus) {
#ifndef CONFIG_ATOMIC128
cpu_loop_exit_atomic(ENV_GET_CPU(env), ra);
#else
int mem_idx = cpu_mmu_index(env, false);
TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
Int128 v = helper_atomic_ldo_be_mmu(env, addr, oi, ra);
hi = int128_gethi(v);
lo = int128_getlo(v);
#endif
} else {
check_alignment(env, addr, 16, ra);
hi = cpu_ldq_data_ra(env, addr + 0, ra);
lo = cpu_ldq_data_ra(env, addr + 8, ra);
}
env->retxl = lo;
return hi;
}
|
[
"uint64_t FUNC_0(lpq)(CPUS390XState *env, uint64_t addr)\n{",
"uintptr_t ra = GETPC();",
"uint64_t hi, lo;",
"if (parallel_cpus) {",
"#ifndef CONFIG_ATOMIC128\ncpu_loop_exit_atomic(ENV_GET_CPU(env), ra);",
"#else\nint mem_idx = cpu_mmu_index(env, false);",
"TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);",
"Int128 v = helper_atomic_ldo_be_mmu(env, addr, oi, ra);",
"hi = int128_gethi(v);",
"lo = int128_getlo(v);",
"#endif\n} else {",
"check_alignment(env, addr, 16, ra);",
"hi = cpu_ldq_data_ra(env, addr + 0, ra);",
"lo = cpu_ldq_data_ra(env, addr + 8, ra);",
"}",
"env->retxl = lo;",
"return hi;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
]
] |
7,039 |
void breakpoint_handler(CPUState *cs)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
CPUBreakpoint *bp;
if (cs->watchpoint_hit) {
if (cs->watchpoint_hit->flags & BP_CPU) {
cs->watchpoint_hit = NULL;
if (check_hw_breakpoints(env, false)) {
raise_exception(env, EXCP01_DB);
} else {
cpu_resume_from_signal(cs, NULL);
}
}
} else {
QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {
if (bp->pc == env->eip) {
if (bp->flags & BP_CPU) {
check_hw_breakpoints(env, true);
raise_exception(env, EXCP01_DB);
}
break;
}
}
}
}
| false |
qemu
|
6886b98036a8f8f5bce8b10756ce080084cef11b
|
void breakpoint_handler(CPUState *cs)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
CPUBreakpoint *bp;
if (cs->watchpoint_hit) {
if (cs->watchpoint_hit->flags & BP_CPU) {
cs->watchpoint_hit = NULL;
if (check_hw_breakpoints(env, false)) {
raise_exception(env, EXCP01_DB);
} else {
cpu_resume_from_signal(cs, NULL);
}
}
} else {
QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {
if (bp->pc == env->eip) {
if (bp->flags & BP_CPU) {
check_hw_breakpoints(env, true);
raise_exception(env, EXCP01_DB);
}
break;
}
}
}
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(CPUState *VAR_0)
{
X86CPU *cpu = X86_CPU(VAR_0);
CPUX86State *env = &cpu->env;
CPUBreakpoint *bp;
if (VAR_0->watchpoint_hit) {
if (VAR_0->watchpoint_hit->flags & BP_CPU) {
VAR_0->watchpoint_hit = NULL;
if (check_hw_breakpoints(env, false)) {
raise_exception(env, EXCP01_DB);
} else {
cpu_resume_from_signal(VAR_0, NULL);
}
}
} else {
QTAILQ_FOREACH(bp, &VAR_0->breakpoints, entry) {
if (bp->pc == env->eip) {
if (bp->flags & BP_CPU) {
check_hw_breakpoints(env, true);
raise_exception(env, EXCP01_DB);
}
break;
}
}
}
}
|
[
"void FUNC_0(CPUState *VAR_0)\n{",
"X86CPU *cpu = X86_CPU(VAR_0);",
"CPUX86State *env = &cpu->env;",
"CPUBreakpoint *bp;",
"if (VAR_0->watchpoint_hit) {",
"if (VAR_0->watchpoint_hit->flags & BP_CPU) {",
"VAR_0->watchpoint_hit = NULL;",
"if (check_hw_breakpoints(env, false)) {",
"raise_exception(env, EXCP01_DB);",
"} else {",
"cpu_resume_from_signal(VAR_0, NULL);",
"}",
"}",
"} else {",
"QTAILQ_FOREACH(bp, &VAR_0->breakpoints, entry) {",
"if (bp->pc == env->eip) {",
"if (bp->flags & BP_CPU) {",
"check_hw_breakpoints(env, true);",
"raise_exception(env, EXCP01_DB);",
"}",
"break;",
"}",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
]
] |
7,040 |
static void start_output(DBDMA_channel *ch, int key, uint32_t addr,
uint16_t req_count, int is_last)
{
DBDMA_DPRINTF("start_output\n");
/* KEY_REGS, KEY_DEVICE and KEY_STREAM
* are not implemented in the mac-io chip
*/
DBDMA_DPRINTF("addr 0x%x key 0x%x\n", addr, key);
if (!addr || key > KEY_STREAM3) {
kill_channel(ch);
return;
}
ch->io.addr = addr;
ch->io.len = req_count;
ch->io.is_last = is_last;
ch->io.dma_end = dbdma_end;
ch->io.is_dma_out = 1;
ch->processing = 1;
ch->rw(&ch->io);
}
| false |
qemu
|
a9ceb76d55abfed9426a819024aa3a4b87266c9f
|
static void start_output(DBDMA_channel *ch, int key, uint32_t addr,
uint16_t req_count, int is_last)
{
DBDMA_DPRINTF("start_output\n");
DBDMA_DPRINTF("addr 0x%x key 0x%x\n", addr, key);
if (!addr || key > KEY_STREAM3) {
kill_channel(ch);
return;
}
ch->io.addr = addr;
ch->io.len = req_count;
ch->io.is_last = is_last;
ch->io.dma_end = dbdma_end;
ch->io.is_dma_out = 1;
ch->processing = 1;
ch->rw(&ch->io);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(DBDMA_channel *VAR_0, int VAR_1, uint32_t VAR_2,
uint16_t VAR_3, int VAR_4)
{
DBDMA_DPRINTF("FUNC_0\n");
DBDMA_DPRINTF("VAR_2 0x%x VAR_1 0x%x\n", VAR_2, VAR_1);
if (!VAR_2 || VAR_1 > KEY_STREAM3) {
kill_channel(VAR_0);
return;
}
VAR_0->io.VAR_2 = VAR_2;
VAR_0->io.len = VAR_3;
VAR_0->io.VAR_4 = VAR_4;
VAR_0->io.dma_end = dbdma_end;
VAR_0->io.is_dma_out = 1;
VAR_0->processing = 1;
VAR_0->rw(&VAR_0->io);
}
|
[
"static void FUNC_0(DBDMA_channel *VAR_0, int VAR_1, uint32_t VAR_2,\nuint16_t VAR_3, int VAR_4)\n{",
"DBDMA_DPRINTF(\"FUNC_0\\n\");",
"DBDMA_DPRINTF(\"VAR_2 0x%x VAR_1 0x%x\\n\", VAR_2, VAR_1);",
"if (!VAR_2 || VAR_1 > KEY_STREAM3) {",
"kill_channel(VAR_0);",
"return;",
"}",
"VAR_0->io.VAR_2 = VAR_2;",
"VAR_0->io.len = VAR_3;",
"VAR_0->io.VAR_4 = VAR_4;",
"VAR_0->io.dma_end = dbdma_end;",
"VAR_0->io.is_dma_out = 1;",
"VAR_0->processing = 1;",
"VAR_0->rw(&VAR_0->io);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
]
] |
7,041 |
static void FUNCC(pred8x8_dc)(uint8_t *_src, int stride){
int i;
int dc0, dc1, dc2;
pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
pixel *src = (pixel*)_src;
stride /= sizeof(pixel);
dc0=dc1=dc2=0;
for(i=0;i<4; i++){
dc0+= src[-1+i*stride] + src[i-stride];
dc1+= src[4+i-stride];
dc2+= src[-1+(i+4)*stride];
}
dc0splat = PIXEL_SPLAT_X4((dc0 + 4)>>3);
dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
dc3splat = PIXEL_SPLAT_X4((dc1 + dc2 + 4)>>3);
for(i=0; i<4; i++){
((pixel4*)(src+i*stride))[0]= dc0splat;
((pixel4*)(src+i*stride))[1]= dc1splat;
}
for(i=4; i<8; i++){
((pixel4*)(src+i*stride))[0]= dc2splat;
((pixel4*)(src+i*stride))[1]= dc3splat;
}
}
| true |
FFmpeg
|
2caf19e90f270abe1e80a3e85acaf0eb5c9d0aac
|
static void FUNCC(pred8x8_dc)(uint8_t *_src, int stride){
int i;
int dc0, dc1, dc2;
pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
pixel *src = (pixel*)_src;
stride /= sizeof(pixel);
dc0=dc1=dc2=0;
for(i=0;i<4; i++){
dc0+= src[-1+i*stride] + src[i-stride];
dc1+= src[4+i-stride];
dc2+= src[-1+(i+4)*stride];
}
dc0splat = PIXEL_SPLAT_X4((dc0 + 4)>>3);
dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
dc3splat = PIXEL_SPLAT_X4((dc1 + dc2 + 4)>>3);
for(i=0; i<4; i++){
((pixel4*)(src+i*stride))[0]= dc0splat;
((pixel4*)(src+i*stride))[1]= dc1splat;
}
for(i=4; i<8; i++){
((pixel4*)(src+i*stride))[0]= dc2splat;
((pixel4*)(src+i*stride))[1]= dc3splat;
}
}
|
{
"code": [
" ((pixel4*)(src+i*stride))[0]= dc0splat;",
" ((pixel4*)(src+i*stride))[1]= dc1splat;",
" ((pixel4*)(src+i*stride))[0]= dc0splat;",
" ((pixel4*)(src+i*stride))[1]= dc1splat;",
" ((pixel4*)(src+i*stride))[0]= dc0splat;",
" ((pixel4*)(src+i*stride))[1]= dc1splat;",
" ((pixel4*)(src+i*stride))[0]= dc2splat;",
" ((pixel4*)(src+i*stride))[1]= dc3splat;"
],
"line_no": [
39,
41,
39,
41,
39,
41,
47,
49
]
}
|
static void FUNC_0(pred8x8_dc)(uint8_t *_src, int stride){
int VAR_0;
int VAR_1, VAR_2, VAR_3;
pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
pixel *src = (pixel*)_src;
stride /= sizeof(pixel);
VAR_1=VAR_2=VAR_3=0;
for(VAR_0=0;VAR_0<4; VAR_0++){
VAR_1+= src[-1+VAR_0*stride] + src[VAR_0-stride];
VAR_2+= src[4+VAR_0-stride];
VAR_3+= src[-1+(VAR_0+4)*stride];
}
dc0splat = PIXEL_SPLAT_X4((VAR_1 + 4)>>3);
dc1splat = PIXEL_SPLAT_X4((VAR_2 + 2)>>2);
dc2splat = PIXEL_SPLAT_X4((VAR_3 + 2)>>2);
dc3splat = PIXEL_SPLAT_X4((VAR_2 + VAR_3 + 4)>>3);
for(VAR_0=0; VAR_0<4; VAR_0++){
((pixel4*)(src+VAR_0*stride))[0]= dc0splat;
((pixel4*)(src+VAR_0*stride))[1]= dc1splat;
}
for(VAR_0=4; VAR_0<8; VAR_0++){
((pixel4*)(src+VAR_0*stride))[0]= dc2splat;
((pixel4*)(src+VAR_0*stride))[1]= dc3splat;
}
}
|
[
"static void FUNC_0(pred8x8_dc)(uint8_t *_src, int stride){",
"int VAR_0;",
"int VAR_1, VAR_2, VAR_3;",
"pixel4 dc0splat, dc1splat, dc2splat, dc3splat;",
"pixel *src = (pixel*)_src;",
"stride /= sizeof(pixel);",
"VAR_1=VAR_2=VAR_3=0;",
"for(VAR_0=0;VAR_0<4; VAR_0++){",
"VAR_1+= src[-1+VAR_0*stride] + src[VAR_0-stride];",
"VAR_2+= src[4+VAR_0-stride];",
"VAR_3+= src[-1+(VAR_0+4)*stride];",
"}",
"dc0splat = PIXEL_SPLAT_X4((VAR_1 + 4)>>3);",
"dc1splat = PIXEL_SPLAT_X4((VAR_2 + 2)>>2);",
"dc2splat = PIXEL_SPLAT_X4((VAR_3 + 2)>>2);",
"dc3splat = PIXEL_SPLAT_X4((VAR_2 + VAR_3 + 4)>>3);",
"for(VAR_0=0; VAR_0<4; VAR_0++){",
"((pixel4*)(src+VAR_0*stride))[0]= dc0splat;",
"((pixel4*)(src+VAR_0*stride))[1]= dc1splat;",
"}",
"for(VAR_0=4; VAR_0<8; VAR_0++){",
"((pixel4*)(src+VAR_0*stride))[0]= dc2splat;",
"((pixel4*)(src+VAR_0*stride))[1]= dc3splat;",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0
] |
[
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
]
] |
7,042 |
static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len)
{
int32_t *ptr = qdev_get_prop_ptr(dev, prop);
return snprintf(dest, len, "%" PRId32, *ptr);
}
| true |
qemu
|
5cb9b56acfc0b50acf7ccd2d044ab4991c47fdde
|
static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len)
{
int32_t *ptr = qdev_get_prop_ptr(dev, prop);
return snprintf(dest, len, "%" PRId32, *ptr);
}
|
{
"code": [
" int32_t *ptr = qdev_get_prop_ptr(dev, prop);",
"static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len)",
" int32_t *ptr = qdev_get_prop_ptr(dev, prop);",
" return snprintf(dest, len, \"%\" PRId32, *ptr);"
],
"line_no": [
5,
1,
5,
7
]
}
|
static int FUNC_0(DeviceState *VAR_0, Property *VAR_1, char *VAR_2, size_t VAR_3)
{
int32_t *ptr = qdev_get_prop_ptr(VAR_0, VAR_1);
return snprintf(VAR_2, VAR_3, "%" PRId32, *ptr);
}
|
[
"static int FUNC_0(DeviceState *VAR_0, Property *VAR_1, char *VAR_2, size_t VAR_3)\n{",
"int32_t *ptr = qdev_get_prop_ptr(VAR_0, VAR_1);",
"return snprintf(VAR_2, VAR_3, \"%\" PRId32, *ptr);",
"}"
] |
[
1,
1,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
7,043 |
int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
const uint8_t *buf, int buf_size)
{
VP56Context *s = avctx->priv_data;
AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
int remaining_buf_size = buf_size;
int is_alpha, alpha_offset;
if (s->has_alpha) {
alpha_offset = bytestream_get_be24(&buf);
remaining_buf_size -= 3;
}
for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
s->modelp = &s->models[is_alpha];
res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
if (!res)
return -1;
if (!is_alpha) {
p->reference = 1;
if (avctx->get_buffer(avctx, p) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(avctx)) {
avctx->release_buffer(avctx, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = FF_I_TYPE;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = FF_P_TYPE;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
/* main macroblocks loop */
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_FRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, is_alpha);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (p->key_frame || golden_frame) {
if (s->framep[VP56_FRAME_GOLDEN]->data[0] &&
s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]);
s->framep[VP56_FRAME_GOLDEN] = p;
}
if (s->has_alpha) {
FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
s->framep[VP56_FRAME_GOLDEN2]);
buf += alpha_offset;
remaining_buf_size -= alpha_offset;
}
}
if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED]);
else
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED2]);
} else if (s->framep[VP56_FRAME_PREVIOUS]->data[0])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]);
FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
s->framep[VP56_FRAME_PREVIOUS]);
*(AVFrame*)data = *p;
*data_size = sizeof(AVFrame);
return buf_size;
}
| true |
FFmpeg
|
ed761067550ec784c62b32dd749bbbca62462d89
|
int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
const uint8_t *buf, int buf_size)
{
VP56Context *s = avctx->priv_data;
AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
int remaining_buf_size = buf_size;
int is_alpha, alpha_offset;
if (s->has_alpha) {
alpha_offset = bytestream_get_be24(&buf);
remaining_buf_size -= 3;
}
for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
s->modelp = &s->models[is_alpha];
res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
if (!res)
return -1;
if (!is_alpha) {
p->reference = 1;
if (avctx->get_buffer(avctx, p) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(avctx)) {
avctx->release_buffer(avctx, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = FF_I_TYPE;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = FF_P_TYPE;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_FRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, is_alpha);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (p->key_frame || golden_frame) {
if (s->framep[VP56_FRAME_GOLDEN]->data[0] &&
s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]);
s->framep[VP56_FRAME_GOLDEN] = p;
}
if (s->has_alpha) {
FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
s->framep[VP56_FRAME_GOLDEN2]);
buf += alpha_offset;
remaining_buf_size -= alpha_offset;
}
}
if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED]);
else
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED2]);
} else if (s->framep[VP56_FRAME_PREVIOUS]->data[0])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]);
FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
s->framep[VP56_FRAME_PREVIOUS]);
*(AVFrame*)data = *p;
*data_size = sizeof(AVFrame);
return buf_size;
}
|
{
"code": [
" int is_alpha, alpha_offset;"
],
"line_no": [
13
]
}
|
int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,
const uint8_t *VAR_3, int VAR_4)
{
VP56Context *s = VAR_0->priv_data;
AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
int VAR_5 = VAR_4;
int VAR_6, VAR_7;
if (s->has_alpha) {
VAR_7 = bytestream_get_be24(&VAR_3);
VAR_5 -= 3;
}
for (VAR_6=0; VAR_6 < 1+s->has_alpha; VAR_6++) {
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
s->modelp = &s->models[VAR_6];
res = s->parse_header(s, VAR_3, VAR_5, &golden_frame);
if (!res)
return -1;
if (!VAR_6) {
p->reference = 1;
if (VAR_0->get_buffer(VAR_0, p) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(VAR_0)) {
VAR_0->release_buffer(VAR_0, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = FF_I_TYPE;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = FF_P_TYPE;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_FRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, VAR_6);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (p->key_frame || golden_frame) {
if (s->framep[VP56_FRAME_GOLDEN]->VAR_1[0] &&
s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
VAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_GOLDEN]);
s->framep[VP56_FRAME_GOLDEN] = p;
}
if (s->has_alpha) {
FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
s->framep[VP56_FRAME_GOLDEN2]);
VAR_3 += VAR_7;
VAR_5 -= VAR_7;
}
}
if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED]);
else
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED2]);
} else if (s->framep[VP56_FRAME_PREVIOUS]->VAR_1[0])
VAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_PREVIOUS]);
FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
s->framep[VP56_FRAME_PREVIOUS]);
*(AVFrame*)VAR_1 = *p;
*VAR_2 = sizeof(AVFrame);
return VAR_4;
}
|
[
"int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{",
"VP56Context *s = VAR_0->priv_data;",
"AVFrame *const p = s->framep[VP56_FRAME_CURRENT];",
"int VAR_5 = VAR_4;",
"int VAR_6, VAR_7;",
"if (s->has_alpha) {",
"VAR_7 = bytestream_get_be24(&VAR_3);",
"VAR_5 -= 3;",
"}",
"for (VAR_6=0; VAR_6 < 1+s->has_alpha; VAR_6++) {",
"int mb_row, mb_col, mb_row_flip, mb_offset = 0;",
"int block, y, uv, stride_y, stride_uv;",
"int golden_frame = 0;",
"int res;",
"s->modelp = &s->models[VAR_6];",
"res = s->parse_header(s, VAR_3, VAR_5, &golden_frame);",
"if (!res)\nreturn -1;",
"if (!VAR_6) {",
"p->reference = 1;",
"if (VAR_0->get_buffer(VAR_0, p) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");",
"return -1;",
"}",
"if (res == 2)\nif (vp56_size_changed(VAR_0)) {",
"VAR_0->release_buffer(VAR_0, p);",
"return -1;",
"}",
"}",
"if (p->key_frame) {",
"p->pict_type = FF_I_TYPE;",
"s->default_models_init(s);",
"for (block=0; block<s->mb_height*s->mb_width; block++)",
"s->macroblocks[block].type = VP56_MB_INTRA;",
"} else {",
"p->pict_type = FF_P_TYPE;",
"vp56_parse_mb_type_models(s);",
"s->parse_vector_models(s);",
"s->mb_type = VP56_MB_INTER_NOVEC_PF;",
"}",
"s->parse_coeff_models(s);",
"memset(s->prev_dc, 0, sizeof(s->prev_dc));",
"s->prev_dc[1][VP56_FRAME_CURRENT] = 128;",
"s->prev_dc[2][VP56_FRAME_CURRENT] = 128;",
"for (block=0; block < 4*s->mb_width+6; block++) {",
"s->above_blocks[block].ref_frame = VP56_FRAME_NONE;",
"s->above_blocks[block].dc_coeff = 0;",
"s->above_blocks[block].not_null_dc = 0;",
"}",
"s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;",
"s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;",
"stride_y = p->linesize[0];",
"stride_uv = p->linesize[1];",
"if (s->flip < 0)\nmb_offset = 7;",
"for (mb_row=0; mb_row<s->mb_height; mb_row++) {",
"if (s->flip < 0)\nmb_row_flip = s->mb_height - mb_row - 1;",
"else\nmb_row_flip = mb_row;",
"for (block=0; block<4; block++) {",
"s->left_block[block].ref_frame = VP56_FRAME_NONE;",
"s->left_block[block].dc_coeff = 0;",
"s->left_block[block].not_null_dc = 0;",
"}",
"memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));",
"memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));",
"s->above_block_idx[0] = 1;",
"s->above_block_idx[1] = 2;",
"s->above_block_idx[2] = 1;",
"s->above_block_idx[3] = 2;",
"s->above_block_idx[4] = 2*s->mb_width + 2 + 1;",
"s->above_block_idx[5] = 3*s->mb_width + 4 + 1;",
"s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;",
"s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;",
"s->block_offset[1] = s->block_offset[0] + 8;",
"s->block_offset[3] = s->block_offset[2] + 8;",
"s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;",
"s->block_offset[5] = s->block_offset[4];",
"for (mb_col=0; mb_col<s->mb_width; mb_col++) {",
"vp56_decode_mb(s, mb_row, mb_col, VAR_6);",
"for (y=0; y<4; y++) {",
"s->above_block_idx[y] += 2;",
"s->block_offset[y] += 16;",
"}",
"for (uv=4; uv<6; uv++) {",
"s->above_block_idx[uv] += 1;",
"s->block_offset[uv] += 8;",
"}",
"}",
"}",
"if (p->key_frame || golden_frame) {",
"if (s->framep[VP56_FRAME_GOLDEN]->VAR_1[0] &&\ns->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])\nVAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_GOLDEN]);",
"s->framep[VP56_FRAME_GOLDEN] = p;",
"}",
"if (s->has_alpha) {",
"FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],\ns->framep[VP56_FRAME_GOLDEN2]);",
"VAR_3 += VAR_7;",
"VAR_5 -= VAR_7;",
"}",
"}",
"if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||\ns->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {",
"if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&\ns->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])\nFFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],\ns->framep[VP56_FRAME_UNUSED]);",
"else\nFFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],\ns->framep[VP56_FRAME_UNUSED2]);",
"} else if (s->framep[VP56_FRAME_PREVIOUS]->VAR_1[0])",
"VAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_PREVIOUS]);",
"FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],\ns->framep[VP56_FRAME_PREVIOUS]);",
"*(AVFrame*)VAR_1 = *p;",
"*VAR_2 = sizeof(AVFrame);",
"return VAR_4;",
"}"
] |
[
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
43
],
[
45,
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
137,
139
],
[
145
],
[
147,
149
],
[
151,
153
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201
],
[
203
],
[
207
],
[
209
],
[
211
],
[
213
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
231
],
[
233,
235,
237
],
[
239
],
[
241
],
[
245
],
[
247,
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
261,
263
],
[
265,
267,
269,
271
],
[
273,
275,
277
],
[
279
],
[
281
],
[
283,
285
],
[
289
],
[
291
],
[
295
],
[
297
]
] |
7,044 |
static inline void RENAME(uyvyToY)(uint8_t *dst, uint8_t *src, int width)
{
#ifdef HAVE_MMX
asm volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((long)-width), "r" (src+width*2), "r" (dst+width)
: "%"REG_a
);
#else
int i;
for(i=0; i<width; i++)
dst[i]= src[2*i+1];
#endif
}
| true |
FFmpeg
|
7f526efd17973ec6d2204f7a47b6923e2be31363
|
static inline void RENAME(uyvyToY)(uint8_t *dst, uint8_t *src, int width)
{
#ifdef HAVE_MMX
asm volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((long)-width), "r" (src+width*2), "r" (dst+width)
: "%"REG_a
);
#else
int i;
for(i=0; i<width; i++)
dst[i]= src[2*i+1];
#endif
}
|
{
"code": [
"\t\t: : \"g\" ((long)-width), \"r\" (src+width*2), \"r\" (dst+width)",
"static inline void RENAME(uyvyToY)(uint8_t *dst, uint8_t *src, int width)",
"\t\t: : \"g\" ((long)-width), \"r\" (src+width*2), \"r\" (dst+width)"
],
"line_no": [
29,
1,
29
]
}
|
static inline void FUNC_0(uyvyToY)(uint8_t *dst, uint8_t *src, int width)
{
#ifdef HAVE_MMX
asm volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"movq %%mm0, (%2, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((long)-width), "r" (src+width*2), "r" (dst+width)
: "%"REG_a
);
#else
int VAR_0;
for(VAR_0=0; VAR_0<width; VAR_0++)
dst[VAR_0]= src[2*VAR_0+1];
#endif
}
|
[
"static inline void FUNC_0(uyvyToY)(uint8_t *dst, uint8_t *src, int width)\n{",
"#ifdef HAVE_MMX\nasm volatile(\n\"mov %0, %%\"REG_a\"\t\t\\n\\t\"\n\"1:\t\t\t\t\\n\\t\"\n\"movq (%1, %%\"REG_a\",2), %%mm0\t\\n\\t\"\n\"movq 8(%1, %%\"REG_a\",2), %%mm1\t\\n\\t\"\n\"psrlw $8, %%mm0\t\t\\n\\t\"\n\"psrlw $8, %%mm1\t\t\\n\\t\"\n\"packuswb %%mm1, %%mm0\t\t\\n\\t\"\n\"movq %%mm0, (%2, %%\"REG_a\")\t\\n\\t\"\n\"add $8, %%\"REG_a\"\t\t\\n\\t\"\n\" js 1b\t\t\t\t\\n\\t\"\n: : \"g\" ((long)-width), \"r\" (src+width*2), \"r\" (dst+width)\n: \"%\"REG_a\n);",
"#else\nint VAR_0;",
"for(VAR_0=0; VAR_0<width; VAR_0++)",
"dst[VAR_0]= src[2*VAR_0+1];",
"#endif\n}"
] |
[
1,
1,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5,
7,
9,
11,
13,
15,
17,
19,
21,
23,
25,
27,
29,
31,
33
],
[
35,
37
],
[
39
],
[
41
],
[
43,
45
]
] |
7,045 |
static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
{
int n, flags, pitch_range, lsp16_flag;
WMAVoiceContext *s = ctx->priv_data;
/**
* Extradata layout:
* - byte 0-18: WMAPro-in-WMAVoice extradata (see wmaprodec.c),
* - byte 19-22: flags field (annoyingly in LE; see below for known
* values),
* - byte 23-46: variable bitmode tree (really just 17 * 3 bits,
* rest is 0).
*/
if (ctx->extradata_size != 46) {
av_log(ctx, AV_LOG_ERROR,
"Invalid extradata size %d (should be 46)\n",
ctx->extradata_size);
flags = AV_RL32(ctx->extradata + 18);
s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);
s->do_apf = flags & 0x1;
if (s->do_apf) {
ff_rdft_init(&s->rdft, 7, DFT_R2C);
ff_rdft_init(&s->irdft, 7, IDFT_C2R);
ff_dct_init(&s->dct, 6, DCT_I);
ff_dct_init(&s->dst, 6, DST_I);
ff_sine_window_init(s->cos, 256);
memcpy(&s->sin[255], s->cos, 256 * sizeof(s->cos[0]));
for (n = 0; n < 255; n++) {
s->sin[n] = -s->sin[510 - n];
s->cos[510 - n] = s->cos[n];
s->denoise_strength = (flags >> 2) & 0xF;
if (s->denoise_strength >= 12) {
av_log(ctx, AV_LOG_ERROR,
"Invalid denoise filter strength %d (max=11)\n",
s->denoise_strength);
s->denoise_tilt_corr = !!(flags & 0x40);
s->dc_level = (flags >> 7) & 0xF;
s->lsp_q_mode = !!(flags & 0x2000);
s->lsp_def_mode = !!(flags & 0x4000);
lsp16_flag = flags & 0x1000;
if (lsp16_flag) {
s->lsps = 16;
s->frame_lsp_bitsize = 34;
s->sframe_lsp_bitsize = 60;
} else {
s->lsps = 10;
s->frame_lsp_bitsize = 24;
s->sframe_lsp_bitsize = 48;
for (n = 0; n < s->lsps; n++)
s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
init_get_bits(&s->gb, ctx->extradata + 22, (ctx->extradata_size - 22) << 3);
if (decode_vbmtree(&s->gb, s->vbm_tree) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid VBM tree; broken extradata?\n");
s->min_pitch_val = ((ctx->sample_rate << 8) / 400 + 50) >> 8;
s->max_pitch_val = ((ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
pitch_range = s->max_pitch_val - s->min_pitch_val;
if (pitch_range <= 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid pitch range; broken extradata?\n");
s->pitch_nbits = av_ceil_log2(pitch_range);
s->last_pitch_val = 40;
s->last_acb_type = ACB_TYPE_NONE;
s->history_nsamples = s->max_pitch_val + 8;
if (s->min_pitch_val < 1 || s->history_nsamples > MAX_SIGNAL_HISTORY) {
int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
max_sr = ((((MAX_SIGNAL_HISTORY - 8) << 8) + 205) * 2000 / 37) >> 8;
av_log(ctx, AV_LOG_ERROR,
"Unsupported samplerate %d (min=%d, max=%d)\n",
ctx->sample_rate, min_sr, max_sr); // 322-22097 Hz
s->block_conv_table[0] = s->min_pitch_val;
s->block_conv_table[1] = (pitch_range * 25) >> 6;
s->block_conv_table[2] = (pitch_range * 44) >> 6;
s->block_conv_table[3] = s->max_pitch_val - 1;
s->block_delta_pitch_hrange = (pitch_range >> 3) & ~0xF;
s->block_delta_pitch_nbits = 1 + av_ceil_log2(s->block_delta_pitch_hrange);
s->block_pitch_range = s->block_conv_table[2] +
s->block_conv_table[3] + 1 +
2 * (s->block_conv_table[1] - 2 * s->min_pitch_val);
s->block_pitch_nbits = av_ceil_log2(s->block_pitch_range);
ctx->sample_fmt = AV_SAMPLE_FMT_FLT;
return 0;
| true |
FFmpeg
|
d99427cb8ba099375d8cce6df808d4acf045ab43
|
static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
{
int n, flags, pitch_range, lsp16_flag;
WMAVoiceContext *s = ctx->priv_data;
if (ctx->extradata_size != 46) {
av_log(ctx, AV_LOG_ERROR,
"Invalid extradata size %d (should be 46)\n",
ctx->extradata_size);
flags = AV_RL32(ctx->extradata + 18);
s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);
s->do_apf = flags & 0x1;
if (s->do_apf) {
ff_rdft_init(&s->rdft, 7, DFT_R2C);
ff_rdft_init(&s->irdft, 7, IDFT_C2R);
ff_dct_init(&s->dct, 6, DCT_I);
ff_dct_init(&s->dst, 6, DST_I);
ff_sine_window_init(s->cos, 256);
memcpy(&s->sin[255], s->cos, 256 * sizeof(s->cos[0]));
for (n = 0; n < 255; n++) {
s->sin[n] = -s->sin[510 - n];
s->cos[510 - n] = s->cos[n];
s->denoise_strength = (flags >> 2) & 0xF;
if (s->denoise_strength >= 12) {
av_log(ctx, AV_LOG_ERROR,
"Invalid denoise filter strength %d (max=11)\n",
s->denoise_strength);
s->denoise_tilt_corr = !!(flags & 0x40);
s->dc_level = (flags >> 7) & 0xF;
s->lsp_q_mode = !!(flags & 0x2000);
s->lsp_def_mode = !!(flags & 0x4000);
lsp16_flag = flags & 0x1000;
if (lsp16_flag) {
s->lsps = 16;
s->frame_lsp_bitsize = 34;
s->sframe_lsp_bitsize = 60;
} else {
s->lsps = 10;
s->frame_lsp_bitsize = 24;
s->sframe_lsp_bitsize = 48;
for (n = 0; n < s->lsps; n++)
s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
init_get_bits(&s->gb, ctx->extradata + 22, (ctx->extradata_size - 22) << 3);
if (decode_vbmtree(&s->gb, s->vbm_tree) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid VBM tree; broken extradata?\n");
s->min_pitch_val = ((ctx->sample_rate << 8) / 400 + 50) >> 8;
s->max_pitch_val = ((ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
pitch_range = s->max_pitch_val - s->min_pitch_val;
if (pitch_range <= 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid pitch range; broken extradata?\n");
s->pitch_nbits = av_ceil_log2(pitch_range);
s->last_pitch_val = 40;
s->last_acb_type = ACB_TYPE_NONE;
s->history_nsamples = s->max_pitch_val + 8;
if (s->min_pitch_val < 1 || s->history_nsamples > MAX_SIGNAL_HISTORY) {
int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
max_sr = ((((MAX_SIGNAL_HISTORY - 8) << 8) + 205) * 2000 / 37) >> 8;
av_log(ctx, AV_LOG_ERROR,
"Unsupported samplerate %d (min=%d, max=%d)\n",
ctx->sample_rate, min_sr, max_sr);
s->block_conv_table[0] = s->min_pitch_val;
s->block_conv_table[1] = (pitch_range * 25) >> 6;
s->block_conv_table[2] = (pitch_range * 44) >> 6;
s->block_conv_table[3] = s->max_pitch_val - 1;
s->block_delta_pitch_hrange = (pitch_range >> 3) & ~0xF;
s->block_delta_pitch_nbits = 1 + av_ceil_log2(s->block_delta_pitch_hrange);
s->block_pitch_range = s->block_conv_table[2] +
s->block_conv_table[3] + 1 +
2 * (s->block_conv_table[1] - 2 * s->min_pitch_val);
s->block_pitch_nbits = av_ceil_log2(s->block_pitch_range);
ctx->sample_fmt = AV_SAMPLE_FMT_FLT;
return 0;
|
{
"code": [],
"line_no": []
}
|
static av_cold int FUNC_0(AVCodecContext *ctx)
{
int VAR_0, VAR_1, VAR_2, VAR_3;
WMAVoiceContext *s = ctx->priv_data;
if (ctx->extradata_size != 46) {
av_log(ctx, AV_LOG_ERROR,
"Invalid extradata size %d (should be 46)\VAR_0",
ctx->extradata_size);
VAR_1 = AV_RL32(ctx->extradata + 18);
s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);
s->do_apf = VAR_1 & 0x1;
if (s->do_apf) {
ff_rdft_init(&s->rdft, 7, DFT_R2C);
ff_rdft_init(&s->irdft, 7, IDFT_C2R);
ff_dct_init(&s->dct, 6, DCT_I);
ff_dct_init(&s->dst, 6, DST_I);
ff_sine_window_init(s->cos, 256);
memcpy(&s->sin[255], s->cos, 256 * sizeof(s->cos[0]));
for (VAR_0 = 0; VAR_0 < 255; VAR_0++) {
s->sin[VAR_0] = -s->sin[510 - VAR_0];
s->cos[510 - VAR_0] = s->cos[VAR_0];
s->denoise_strength = (VAR_1 >> 2) & 0xF;
if (s->denoise_strength >= 12) {
av_log(ctx, AV_LOG_ERROR,
"Invalid denoise filter strength %d (max=11)\VAR_0",
s->denoise_strength);
s->denoise_tilt_corr = !!(VAR_1 & 0x40);
s->dc_level = (VAR_1 >> 7) & 0xF;
s->lsp_q_mode = !!(VAR_1 & 0x2000);
s->lsp_def_mode = !!(VAR_1 & 0x4000);
VAR_3 = VAR_1 & 0x1000;
if (VAR_3) {
s->lsps = 16;
s->frame_lsp_bitsize = 34;
s->sframe_lsp_bitsize = 60;
} else {
s->lsps = 10;
s->frame_lsp_bitsize = 24;
s->sframe_lsp_bitsize = 48;
for (VAR_0 = 0; VAR_0 < s->lsps; VAR_0++)
s->prev_lsps[VAR_0] = M_PI * (VAR_0 + 1.0) / (s->lsps + 1.0);
init_get_bits(&s->gb, ctx->extradata + 22, (ctx->extradata_size - 22) << 3);
if (decode_vbmtree(&s->gb, s->vbm_tree) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid VBM tree; broken extradata?\VAR_0");
s->min_pitch_val = ((ctx->sample_rate << 8) / 400 + 50) >> 8;
s->max_pitch_val = ((ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
VAR_2 = s->max_pitch_val - s->min_pitch_val;
if (VAR_2 <= 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid pitch range; broken extradata?\VAR_0");
s->pitch_nbits = av_ceil_log2(VAR_2);
s->last_pitch_val = 40;
s->last_acb_type = ACB_TYPE_NONE;
s->history_nsamples = s->max_pitch_val + 8;
if (s->min_pitch_val < 1 || s->history_nsamples > MAX_SIGNAL_HISTORY) {
int VAR_4 = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
VAR_5 = ((((MAX_SIGNAL_HISTORY - 8) << 8) + 205) * 2000 / 37) >> 8;
av_log(ctx, AV_LOG_ERROR,
"Unsupported samplerate %d (min=%d, max=%d)\VAR_0",
ctx->sample_rate, VAR_4, VAR_5);
s->block_conv_table[0] = s->min_pitch_val;
s->block_conv_table[1] = (VAR_2 * 25) >> 6;
s->block_conv_table[2] = (VAR_2 * 44) >> 6;
s->block_conv_table[3] = s->max_pitch_val - 1;
s->block_delta_pitch_hrange = (VAR_2 >> 3) & ~0xF;
s->block_delta_pitch_nbits = 1 + av_ceil_log2(s->block_delta_pitch_hrange);
s->block_pitch_range = s->block_conv_table[2] +
s->block_conv_table[3] + 1 +
2 * (s->block_conv_table[1] - 2 * s->min_pitch_val);
s->block_pitch_nbits = av_ceil_log2(s->block_pitch_range);
ctx->sample_fmt = AV_SAMPLE_FMT_FLT;
return 0;
|
[
"static av_cold int FUNC_0(AVCodecContext *ctx)\n{",
"int VAR_0, VAR_1, VAR_2, VAR_3;",
"WMAVoiceContext *s = ctx->priv_data;",
"if (ctx->extradata_size != 46) {",
"av_log(ctx, AV_LOG_ERROR,\n\"Invalid extradata size %d (should be 46)\\VAR_0\",\nctx->extradata_size);",
"VAR_1 = AV_RL32(ctx->extradata + 18);",
"s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);",
"s->do_apf = VAR_1 & 0x1;",
"if (s->do_apf) {",
"ff_rdft_init(&s->rdft, 7, DFT_R2C);",
"ff_rdft_init(&s->irdft, 7, IDFT_C2R);",
"ff_dct_init(&s->dct, 6, DCT_I);",
"ff_dct_init(&s->dst, 6, DST_I);",
"ff_sine_window_init(s->cos, 256);",
"memcpy(&s->sin[255], s->cos, 256 * sizeof(s->cos[0]));",
"for (VAR_0 = 0; VAR_0 < 255; VAR_0++) {",
"s->sin[VAR_0] = -s->sin[510 - VAR_0];",
"s->cos[510 - VAR_0] = s->cos[VAR_0];",
"s->denoise_strength = (VAR_1 >> 2) & 0xF;",
"if (s->denoise_strength >= 12) {",
"av_log(ctx, AV_LOG_ERROR,\n\"Invalid denoise filter strength %d (max=11)\\VAR_0\",\ns->denoise_strength);",
"s->denoise_tilt_corr = !!(VAR_1 & 0x40);",
"s->dc_level = (VAR_1 >> 7) & 0xF;",
"s->lsp_q_mode = !!(VAR_1 & 0x2000);",
"s->lsp_def_mode = !!(VAR_1 & 0x4000);",
"VAR_3 = VAR_1 & 0x1000;",
"if (VAR_3) {",
"s->lsps = 16;",
"s->frame_lsp_bitsize = 34;",
"s->sframe_lsp_bitsize = 60;",
"} else {",
"s->lsps = 10;",
"s->frame_lsp_bitsize = 24;",
"s->sframe_lsp_bitsize = 48;",
"for (VAR_0 = 0; VAR_0 < s->lsps; VAR_0++)",
"s->prev_lsps[VAR_0] = M_PI * (VAR_0 + 1.0) / (s->lsps + 1.0);",
"init_get_bits(&s->gb, ctx->extradata + 22, (ctx->extradata_size - 22) << 3);",
"if (decode_vbmtree(&s->gb, s->vbm_tree) < 0) {",
"av_log(ctx, AV_LOG_ERROR, \"Invalid VBM tree; broken extradata?\\VAR_0\");",
"s->min_pitch_val = ((ctx->sample_rate << 8) / 400 + 50) >> 8;",
"s->max_pitch_val = ((ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;",
"VAR_2 = s->max_pitch_val - s->min_pitch_val;",
"if (VAR_2 <= 0) {",
"av_log(ctx, AV_LOG_ERROR, \"Invalid pitch range; broken extradata?\\VAR_0\");",
"s->pitch_nbits = av_ceil_log2(VAR_2);",
"s->last_pitch_val = 40;",
"s->last_acb_type = ACB_TYPE_NONE;",
"s->history_nsamples = s->max_pitch_val + 8;",
"if (s->min_pitch_val < 1 || s->history_nsamples > MAX_SIGNAL_HISTORY) {",
"int VAR_4 = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,\nVAR_5 = ((((MAX_SIGNAL_HISTORY - 8) << 8) + 205) * 2000 / 37) >> 8;",
"av_log(ctx, AV_LOG_ERROR,\n\"Unsupported samplerate %d (min=%d, max=%d)\\VAR_0\",\nctx->sample_rate, VAR_4, VAR_5);",
"s->block_conv_table[0] = s->min_pitch_val;",
"s->block_conv_table[1] = (VAR_2 * 25) >> 6;",
"s->block_conv_table[2] = (VAR_2 * 44) >> 6;",
"s->block_conv_table[3] = s->max_pitch_val - 1;",
"s->block_delta_pitch_hrange = (VAR_2 >> 3) & ~0xF;",
"s->block_delta_pitch_nbits = 1 + av_ceil_log2(s->block_delta_pitch_hrange);",
"s->block_pitch_range = s->block_conv_table[2] +\ns->block_conv_table[3] + 1 +\n2 * (s->block_conv_table[1] - 2 * s->min_pitch_val);",
"s->block_pitch_nbits = av_ceil_log2(s->block_pitch_range);",
"ctx->sample_fmt = AV_SAMPLE_FMT_FLT;",
"return 0;"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
27
],
[
29,
31,
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71,
73,
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
106
],
[
108
],
[
112
],
[
114
],
[
116
],
[
122
],
[
124
],
[
126
],
[
128
],
[
130
],
[
134
],
[
136
],
[
138
],
[
140
],
[
144
],
[
146,
148
],
[
152,
154,
156
],
[
164
],
[
166
],
[
168
],
[
170
],
[
172
],
[
178
],
[
180,
182,
184
],
[
186
],
[
190
],
[
194
]
] |
7,046 |
static void ehci_queues_rip_unused(EHCIState *ehci, int async)
{
EHCIQueueHead *head = async ? &ehci->aqueues : &ehci->pqueues;
EHCIQueue *q, *tmp;
QTAILQ_FOREACH_SAFE(q, head, next, tmp) {
if (q->seen) {
q->seen = 0;
q->ts = ehci->last_run_ns;
continue;
}
if (ehci->last_run_ns < q->ts + 250000000) {
/* allow 0.25 sec idle */
continue;
}
ehci_free_queue(q, async);
}
}
| true |
qemu
|
4be23939ab0d7019c7e59a37485b416fbbf0f073
|
static void ehci_queues_rip_unused(EHCIState *ehci, int async)
{
EHCIQueueHead *head = async ? &ehci->aqueues : &ehci->pqueues;
EHCIQueue *q, *tmp;
QTAILQ_FOREACH_SAFE(q, head, next, tmp) {
if (q->seen) {
q->seen = 0;
q->ts = ehci->last_run_ns;
continue;
}
if (ehci->last_run_ns < q->ts + 250000000) {
continue;
}
ehci_free_queue(q, async);
}
}
|
{
"code": [
"static void ehci_queues_rip_unused(EHCIState *ehci, int async)",
" if (ehci->last_run_ns < q->ts + 250000000) {"
],
"line_no": [
1,
23
]
}
|
static void FUNC_0(EHCIState *VAR_0, int VAR_1)
{
EHCIQueueHead *head = VAR_1 ? &VAR_0->aqueues : &VAR_0->pqueues;
EHCIQueue *q, *tmp;
QTAILQ_FOREACH_SAFE(q, head, next, tmp) {
if (q->seen) {
q->seen = 0;
q->ts = VAR_0->last_run_ns;
continue;
}
if (VAR_0->last_run_ns < q->ts + 250000000) {
continue;
}
ehci_free_queue(q, VAR_1);
}
}
|
[
"static void FUNC_0(EHCIState *VAR_0, int VAR_1)\n{",
"EHCIQueueHead *head = VAR_1 ? &VAR_0->aqueues : &VAR_0->pqueues;",
"EHCIQueue *q, *tmp;",
"QTAILQ_FOREACH_SAFE(q, head, next, tmp) {",
"if (q->seen) {",
"q->seen = 0;",
"q->ts = VAR_0->last_run_ns;",
"continue;",
"}",
"if (VAR_0->last_run_ns < q->ts + 250000000) {",
"continue;",
"}",
"ehci_free_queue(q, VAR_1);",
"}",
"}"
] |
[
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
7,047 |
void kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
{
/* Inject NMI */
if (env->interrupt_request & CPU_INTERRUPT_NMI) {
env->interrupt_request &= ~CPU_INTERRUPT_NMI;
DPRINTF("injected NMI\n");
kvm_vcpu_ioctl(env, KVM_NMI);
}
if (!kvm_irqchip_in_kernel()) {
/* Force the VCPU out of its inner loop to process the INIT request */
if (env->interrupt_request & CPU_INTERRUPT_INIT) {
env->exit_request = 1;
}
/* Try to inject an interrupt if the guest can accept it */
if (run->ready_for_interrupt_injection &&
(env->interrupt_request & CPU_INTERRUPT_HARD) &&
(env->eflags & IF_MASK)) {
int irq;
env->interrupt_request &= ~CPU_INTERRUPT_HARD;
irq = cpu_get_pic_interrupt(env);
if (irq >= 0) {
struct kvm_interrupt intr;
intr.irq = irq;
/* FIXME: errors */
DPRINTF("injected interrupt %d\n", irq);
kvm_vcpu_ioctl(env, KVM_INTERRUPT, &intr);
}
}
/* If we have an interrupt but the guest is not ready to receive an
* interrupt, request an interrupt window exit. This will
* cause a return to userspace as soon as the guest is ready to
* receive interrupts. */
if ((env->interrupt_request & CPU_INTERRUPT_HARD)) {
run->request_interrupt_window = 1;
} else {
run->request_interrupt_window = 0;
}
DPRINTF("setting tpr\n");
run->cr8 = cpu_get_apic_tpr(env->apic_state);
}
}
| true |
qemu
|
ce377af399563195d066d5fee0c7b717967932ee
|
void kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
{
if (env->interrupt_request & CPU_INTERRUPT_NMI) {
env->interrupt_request &= ~CPU_INTERRUPT_NMI;
DPRINTF("injected NMI\n");
kvm_vcpu_ioctl(env, KVM_NMI);
}
if (!kvm_irqchip_in_kernel()) {
if (env->interrupt_request & CPU_INTERRUPT_INIT) {
env->exit_request = 1;
}
if (run->ready_for_interrupt_injection &&
(env->interrupt_request & CPU_INTERRUPT_HARD) &&
(env->eflags & IF_MASK)) {
int irq;
env->interrupt_request &= ~CPU_INTERRUPT_HARD;
irq = cpu_get_pic_interrupt(env);
if (irq >= 0) {
struct kvm_interrupt intr;
intr.irq = irq;
DPRINTF("injected interrupt %d\n", irq);
kvm_vcpu_ioctl(env, KVM_INTERRUPT, &intr);
}
}
if ((env->interrupt_request & CPU_INTERRUPT_HARD)) {
run->request_interrupt_window = 1;
} else {
run->request_interrupt_window = 0;
}
DPRINTF("setting tpr\n");
run->cr8 = cpu_get_apic_tpr(env->apic_state);
}
}
|
{
"code": [
" kvm_vcpu_ioctl(env, KVM_NMI);",
" kvm_vcpu_ioctl(env, KVM_INTERRUPT, &intr);"
],
"line_no": [
13,
59
]
}
|
void FUNC_0(CPUState *VAR_0, struct kvm_run *VAR_1)
{
if (VAR_0->interrupt_request & CPU_INTERRUPT_NMI) {
VAR_0->interrupt_request &= ~CPU_INTERRUPT_NMI;
DPRINTF("injected NMI\n");
kvm_vcpu_ioctl(VAR_0, KVM_NMI);
}
if (!kvm_irqchip_in_kernel()) {
if (VAR_0->interrupt_request & CPU_INTERRUPT_INIT) {
VAR_0->exit_request = 1;
}
if (VAR_1->ready_for_interrupt_injection &&
(VAR_0->interrupt_request & CPU_INTERRUPT_HARD) &&
(VAR_0->eflags & IF_MASK)) {
int VAR_2;
VAR_0->interrupt_request &= ~CPU_INTERRUPT_HARD;
VAR_2 = cpu_get_pic_interrupt(VAR_0);
if (VAR_2 >= 0) {
struct kvm_interrupt VAR_3;
VAR_3.VAR_2 = VAR_2;
DPRINTF("injected interrupt %d\n", VAR_2);
kvm_vcpu_ioctl(VAR_0, KVM_INTERRUPT, &VAR_3);
}
}
if ((VAR_0->interrupt_request & CPU_INTERRUPT_HARD)) {
VAR_1->request_interrupt_window = 1;
} else {
VAR_1->request_interrupt_window = 0;
}
DPRINTF("setting tpr\n");
VAR_1->cr8 = cpu_get_apic_tpr(VAR_0->apic_state);
}
}
|
[
"void FUNC_0(CPUState *VAR_0, struct kvm_run *VAR_1)\n{",
"if (VAR_0->interrupt_request & CPU_INTERRUPT_NMI) {",
"VAR_0->interrupt_request &= ~CPU_INTERRUPT_NMI;",
"DPRINTF(\"injected NMI\\n\");",
"kvm_vcpu_ioctl(VAR_0, KVM_NMI);",
"}",
"if (!kvm_irqchip_in_kernel()) {",
"if (VAR_0->interrupt_request & CPU_INTERRUPT_INIT) {",
"VAR_0->exit_request = 1;",
"}",
"if (VAR_1->ready_for_interrupt_injection &&\n(VAR_0->interrupt_request & CPU_INTERRUPT_HARD) &&\n(VAR_0->eflags & IF_MASK)) {",
"int VAR_2;",
"VAR_0->interrupt_request &= ~CPU_INTERRUPT_HARD;",
"VAR_2 = cpu_get_pic_interrupt(VAR_0);",
"if (VAR_2 >= 0) {",
"struct kvm_interrupt VAR_3;",
"VAR_3.VAR_2 = VAR_2;",
"DPRINTF(\"injected interrupt %d\\n\", VAR_2);",
"kvm_vcpu_ioctl(VAR_0, KVM_INTERRUPT, &VAR_3);",
"}",
"}",
"if ((VAR_0->interrupt_request & CPU_INTERRUPT_HARD)) {",
"VAR_1->request_interrupt_window = 1;",
"} else {",
"VAR_1->request_interrupt_window = 0;",
"}",
"DPRINTF(\"setting tpr\\n\");",
"VAR_1->cr8 = cpu_get_apic_tpr(VAR_0->apic_state);",
"}",
"}"
] |
[
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
27
],
[
33,
35,
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
],
[
93
]
] |
7,049 |
static void test_acpi_one(const char *params, test_data *data)
{
char *args;
uint8_t signature_low;
uint8_t signature_high;
uint16_t signature;
int i;
const char *device = "";
if (!g_strcmp0(data->machine, MACHINE_Q35)) {
device = ",id=hd -device ide-hd,drive=hd";
}
args = g_strdup_printf("-net none -display none %s -drive file=%s%s,",
params ? params : "", disk, device);
qtest_start(args);
/* Wait at most 1 minute */
#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)
#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)
/* Poll until code has run and modified memory. Once it has we know BIOS
* initialization is done. TODO: check that IP reached the halt
* instruction.
*/
for (i = 0; i < TEST_CYCLES; ++i) {
signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);
signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);
signature = (signature_high << 8) | signature_low;
if (signature == SIGNATURE) {
break;
}
g_usleep(TEST_DELAY);
}
g_assert_cmphex(signature, ==, SIGNATURE);
test_acpi_rsdp_address(data);
test_acpi_rsdp_table(data);
test_acpi_rsdt_table(data);
test_acpi_fadt_table(data);
test_acpi_facs_table(data);
test_acpi_dsdt_table(data);
test_acpi_tables(data);
if (iasl) {
if (getenv(ACPI_REBUILD_EXPECTED_AML)) {
dump_aml_files(data, true);
} else {
test_acpi_asl(data);
}
}
test_smbios_ep_address(data);
test_smbios_ep_table(data);
test_smbios_structs(data);
qtest_quit(global_qtest);
g_free(args);
}
| true |
qemu
|
6b9e03a4e7598765a6cebb7618f2eeb22e928f6e
|
static void test_acpi_one(const char *params, test_data *data)
{
char *args;
uint8_t signature_low;
uint8_t signature_high;
uint16_t signature;
int i;
const char *device = "";
if (!g_strcmp0(data->machine, MACHINE_Q35)) {
device = ",id=hd -device ide-hd,drive=hd";
}
args = g_strdup_printf("-net none -display none %s -drive file=%s%s,",
params ? params : "", disk, device);
qtest_start(args);
#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)
#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)
for (i = 0; i < TEST_CYCLES; ++i) {
signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);
signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);
signature = (signature_high << 8) | signature_low;
if (signature == SIGNATURE) {
break;
}
g_usleep(TEST_DELAY);
}
g_assert_cmphex(signature, ==, SIGNATURE);
test_acpi_rsdp_address(data);
test_acpi_rsdp_table(data);
test_acpi_rsdt_table(data);
test_acpi_fadt_table(data);
test_acpi_facs_table(data);
test_acpi_dsdt_table(data);
test_acpi_tables(data);
if (iasl) {
if (getenv(ACPI_REBUILD_EXPECTED_AML)) {
dump_aml_files(data, true);
} else {
test_acpi_asl(data);
}
}
test_smbios_ep_address(data);
test_smbios_ep_table(data);
test_smbios_structs(data);
qtest_quit(global_qtest);
g_free(args);
}
|
{
"code": [
" const char *device = \"\";",
" if (!g_strcmp0(data->machine, MACHINE_Q35)) {",
" device = \",id=hd -device ide-hd,drive=hd\";",
" args = g_strdup_printf(\"-net none -display none %s -drive file=%s%s,\",",
" params ? params : \"\", disk, device);"
],
"line_no": [
15,
19,
21,
27,
29
]
}
|
static void FUNC_0(const char *VAR_0, test_data *VAR_1)
{
char *VAR_2;
uint8_t signature_low;
uint8_t signature_high;
uint16_t signature;
int VAR_3;
const char *VAR_4 = "";
if (!g_strcmp0(VAR_1->machine, MACHINE_Q35)) {
VAR_4 = ",id=hd -VAR_4 ide-hd,drive=hd";
}
VAR_2 = g_strdup_printf("-net none -display none %s -drive file=%s%s,",
VAR_0 ? VAR_0 : "", disk, VAR_4);
qtest_start(VAR_2);
#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)
#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)
for (VAR_3 = 0; VAR_3 < TEST_CYCLES; ++VAR_3) {
signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);
signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);
signature = (signature_high << 8) | signature_low;
if (signature == SIGNATURE) {
break;
}
g_usleep(TEST_DELAY);
}
g_assert_cmphex(signature, ==, SIGNATURE);
test_acpi_rsdp_address(VAR_1);
test_acpi_rsdp_table(VAR_1);
test_acpi_rsdt_table(VAR_1);
test_acpi_fadt_table(VAR_1);
test_acpi_facs_table(VAR_1);
test_acpi_dsdt_table(VAR_1);
test_acpi_tables(VAR_1);
if (iasl) {
if (getenv(ACPI_REBUILD_EXPECTED_AML)) {
dump_aml_files(VAR_1, true);
} else {
test_acpi_asl(VAR_1);
}
}
test_smbios_ep_address(VAR_1);
test_smbios_ep_table(VAR_1);
test_smbios_structs(VAR_1);
qtest_quit(global_qtest);
g_free(VAR_2);
}
|
[
"static void FUNC_0(const char *VAR_0, test_data *VAR_1)\n{",
"char *VAR_2;",
"uint8_t signature_low;",
"uint8_t signature_high;",
"uint16_t signature;",
"int VAR_3;",
"const char *VAR_4 = \"\";",
"if (!g_strcmp0(VAR_1->machine, MACHINE_Q35)) {",
"VAR_4 = \",id=hd -VAR_4 ide-hd,drive=hd\";",
"}",
"VAR_2 = g_strdup_printf(\"-net none -display none %s -drive file=%s%s,\",\nVAR_0 ? VAR_0 : \"\", disk, VAR_4);",
"qtest_start(VAR_2);",
"#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)\n#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)\nfor (VAR_3 = 0; VAR_3 < TEST_CYCLES; ++VAR_3) {",
"signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);",
"signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);",
"signature = (signature_high << 8) | signature_low;",
"if (signature == SIGNATURE) {",
"break;",
"}",
"g_usleep(TEST_DELAY);",
"}",
"g_assert_cmphex(signature, ==, SIGNATURE);",
"test_acpi_rsdp_address(VAR_1);",
"test_acpi_rsdp_table(VAR_1);",
"test_acpi_rsdt_table(VAR_1);",
"test_acpi_fadt_table(VAR_1);",
"test_acpi_facs_table(VAR_1);",
"test_acpi_dsdt_table(VAR_1);",
"test_acpi_tables(VAR_1);",
"if (iasl) {",
"if (getenv(ACPI_REBUILD_EXPECTED_AML)) {",
"dump_aml_files(VAR_1, true);",
"} else {",
"test_acpi_asl(VAR_1);",
"}",
"}",
"test_smbios_ep_address(VAR_1);",
"test_smbios_ep_table(VAR_1);",
"test_smbios_structs(VAR_1);",
"qtest_quit(global_qtest);",
"g_free(VAR_2);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
27,
29
],
[
31
],
[
37,
39,
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109
],
[
113
],
[
115
],
[
117
]
] |
7,050 |
static int ea_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
EaDemuxContext *ea = s->priv_data;
AVStream *st;
if (!process_ea_header(s))
return AVERROR(EIO);
if (ea->video_codec) {
/* initialize the video decoder stream */
st = av_new_stream(s, 0);
if (!st)
return AVERROR(ENOMEM);
ea->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = ea->video_codec;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->time_base = ea->time_base;
st->codec->width = ea->width;
st->codec->height = ea->height;
if (ea->num_channels <= 0) {
av_log(s, AV_LOG_WARNING, "Unsupported number of channels: %d\n", ea->num_channels);
if (ea->audio_codec) {
/* initialize the audio decoder stream */
st = av_new_stream(s, 0);
if (!st)
return AVERROR(ENOMEM);
av_set_pts_info(st, 33, 1, ea->sample_rate);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ea->audio_codec;
st->codec->codec_tag = 0; /* no tag */
st->codec->channels = ea->num_channels;
st->codec->sample_rate = ea->sample_rate;
st->codec->bits_per_coded_sample = ea->bytes * 8;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_coded_sample / 4;
st->codec->block_align = st->codec->channels*st->codec->bits_per_coded_sample;
ea->audio_stream_index = st->index;
ea->audio_frame_counter = 0;
return 1;
| true |
FFmpeg
|
cb77dad72414940837bdb01dad5e747175d6a01f
|
static int ea_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
EaDemuxContext *ea = s->priv_data;
AVStream *st;
if (!process_ea_header(s))
return AVERROR(EIO);
if (ea->video_codec) {
st = av_new_stream(s, 0);
if (!st)
return AVERROR(ENOMEM);
ea->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = ea->video_codec;
st->codec->codec_tag = 0;
st->codec->time_base = ea->time_base;
st->codec->width = ea->width;
st->codec->height = ea->height;
if (ea->num_channels <= 0) {
av_log(s, AV_LOG_WARNING, "Unsupported number of channels: %d\n", ea->num_channels);
if (ea->audio_codec) {
st = av_new_stream(s, 0);
if (!st)
return AVERROR(ENOMEM);
av_set_pts_info(st, 33, 1, ea->sample_rate);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ea->audio_codec;
st->codec->codec_tag = 0;
st->codec->channels = ea->num_channels;
st->codec->sample_rate = ea->sample_rate;
st->codec->bits_per_coded_sample = ea->bytes * 8;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_coded_sample / 4;
st->codec->block_align = st->codec->channels*st->codec->bits_per_coded_sample;
ea->audio_stream_index = st->index;
ea->audio_frame_counter = 0;
return 1;
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVFormatContext *VAR_0,
AVFormatParameters *VAR_1)
{
EaDemuxContext *ea = VAR_0->priv_data;
AVStream *st;
if (!process_ea_header(VAR_0))
return AVERROR(EIO);
if (ea->video_codec) {
st = av_new_stream(VAR_0, 0);
if (!st)
return AVERROR(ENOMEM);
ea->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = ea->video_codec;
st->codec->codec_tag = 0;
st->codec->time_base = ea->time_base;
st->codec->width = ea->width;
st->codec->height = ea->height;
if (ea->num_channels <= 0) {
av_log(VAR_0, AV_LOG_WARNING, "Unsupported number of channels: %d\n", ea->num_channels);
if (ea->audio_codec) {
st = av_new_stream(VAR_0, 0);
if (!st)
return AVERROR(ENOMEM);
av_set_pts_info(st, 33, 1, ea->sample_rate);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ea->audio_codec;
st->codec->codec_tag = 0;
st->codec->channels = ea->num_channels;
st->codec->sample_rate = ea->sample_rate;
st->codec->bits_per_coded_sample = ea->bytes * 8;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_coded_sample / 4;
st->codec->block_align = st->codec->channels*st->codec->bits_per_coded_sample;
ea->audio_stream_index = st->index;
ea->audio_frame_counter = 0;
return 1;
|
[
"static int FUNC_0(AVFormatContext *VAR_0,\nAVFormatParameters *VAR_1)\n{",
"EaDemuxContext *ea = VAR_0->priv_data;",
"AVStream *st;",
"if (!process_ea_header(VAR_0))\nreturn AVERROR(EIO);",
"if (ea->video_codec) {",
"st = av_new_stream(VAR_0, 0);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"ea->video_stream_index = st->index;",
"st->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"st->codec->codec_id = ea->video_codec;",
"st->codec->codec_tag = 0;",
"st->codec->time_base = ea->time_base;",
"st->codec->width = ea->width;",
"st->codec->height = ea->height;",
"if (ea->num_channels <= 0) {",
"av_log(VAR_0, AV_LOG_WARNING, \"Unsupported number of channels: %d\\n\", ea->num_channels);",
"if (ea->audio_codec) {",
"st = av_new_stream(VAR_0, 0);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"av_set_pts_info(st, 33, 1, ea->sample_rate);",
"st->codec->codec_type = AVMEDIA_TYPE_AUDIO;",
"st->codec->codec_id = ea->audio_codec;",
"st->codec->codec_tag = 0;",
"st->codec->channels = ea->num_channels;",
"st->codec->sample_rate = ea->sample_rate;",
"st->codec->bits_per_coded_sample = ea->bytes * 8;",
"st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *\nst->codec->bits_per_coded_sample / 4;",
"st->codec->block_align = st->codec->channels*st->codec->bits_per_coded_sample;",
"ea->audio_stream_index = st->index;",
"ea->audio_frame_counter = 0;",
"return 1;"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
2,
3
],
[
4
],
[
5
],
[
6,
7
],
[
8
],
[
10
],
[
11,
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22
],
[
24
],
[
25,
26
],
[
27
],
[
28
],
[
29
],
[
30
],
[
31
],
[
32
],
[
33
],
[
34,
35
],
[
36
],
[
37
],
[
38
],
[
39
]
] |
7,051 |
PCIBus *pci_get_bus_devfn(int *devfnp, PCIBus *root, const char *devaddr)
{
int dom, bus;
unsigned slot;
assert(!root->parent_dev);
if (!root) {
fprintf(stderr, "No primary PCI bus\n");
return NULL;
}
if (!devaddr) {
*devfnp = -1;
return pci_find_bus_nr(root, 0);
}
if (pci_parse_devaddr(devaddr, &dom, &bus, &slot, NULL) < 0) {
return NULL;
}
if (dom != 0) {
fprintf(stderr, "No support for non-zero PCI domains\n");
return NULL;
}
*devfnp = PCI_DEVFN(slot, 0);
return pci_find_bus_nr(root, bus);
}
| true |
qemu
|
b645000e1ac430601eddb0b435936837aea94bb4
|
PCIBus *pci_get_bus_devfn(int *devfnp, PCIBus *root, const char *devaddr)
{
int dom, bus;
unsigned slot;
assert(!root->parent_dev);
if (!root) {
fprintf(stderr, "No primary PCI bus\n");
return NULL;
}
if (!devaddr) {
*devfnp = -1;
return pci_find_bus_nr(root, 0);
}
if (pci_parse_devaddr(devaddr, &dom, &bus, &slot, NULL) < 0) {
return NULL;
}
if (dom != 0) {
fprintf(stderr, "No support for non-zero PCI domains\n");
return NULL;
}
*devfnp = PCI_DEVFN(slot, 0);
return pci_find_bus_nr(root, bus);
}
|
{
"code": [
" assert(!root->parent_dev);"
],
"line_no": [
11
]
}
|
PCIBus *FUNC_0(int *devfnp, PCIBus *root, const char *devaddr)
{
int VAR_0, VAR_1;
unsigned VAR_2;
assert(!root->parent_dev);
if (!root) {
fprintf(stderr, "No primary PCI VAR_1\n");
return NULL;
}
if (!devaddr) {
*devfnp = -1;
return pci_find_bus_nr(root, 0);
}
if (pci_parse_devaddr(devaddr, &VAR_0, &VAR_1, &VAR_2, NULL) < 0) {
return NULL;
}
if (VAR_0 != 0) {
fprintf(stderr, "No support for non-zero PCI domains\n");
return NULL;
}
*devfnp = PCI_DEVFN(VAR_2, 0);
return pci_find_bus_nr(root, VAR_1);
}
|
[
"PCIBus *FUNC_0(int *devfnp, PCIBus *root, const char *devaddr)\n{",
"int VAR_0, VAR_1;",
"unsigned VAR_2;",
"assert(!root->parent_dev);",
"if (!root) {",
"fprintf(stderr, \"No primary PCI VAR_1\\n\");",
"return NULL;",
"}",
"if (!devaddr) {",
"*devfnp = -1;",
"return pci_find_bus_nr(root, 0);",
"}",
"if (pci_parse_devaddr(devaddr, &VAR_0, &VAR_1, &VAR_2, NULL) < 0) {",
"return NULL;",
"}",
"if (VAR_0 != 0) {",
"fprintf(stderr, \"No support for non-zero PCI domains\\n\");",
"return NULL;",
"}",
"*devfnp = PCI_DEVFN(VAR_2, 0);",
"return pci_find_bus_nr(root, VAR_1);",
"}"
] |
[
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
]
] |
7,052 |
static void destroy_page_desc(uint16_t section_index)
{
MemoryRegionSection *section = &phys_sections[section_index];
MemoryRegion *mr = section->mr;
if (mr->subpage) {
subpage_t *subpage = container_of(mr, subpage_t, iomem);
memory_region_destroy(&subpage->iomem);
g_free(subpage);
}
}
| true |
qemu
|
058bc4b57f9d6b39d9a6748b4049e1be3fde3dac
|
static void destroy_page_desc(uint16_t section_index)
{
MemoryRegionSection *section = &phys_sections[section_index];
MemoryRegion *mr = section->mr;
if (mr->subpage) {
subpage_t *subpage = container_of(mr, subpage_t, iomem);
memory_region_destroy(&subpage->iomem);
g_free(subpage);
}
}
|
{
"code": [
"static void destroy_page_desc(uint16_t section_index)",
" MemoryRegionSection *section = &phys_sections[section_index];",
" MemoryRegion *mr = section->mr;",
" if (mr->subpage) {",
" subpage_t *subpage = container_of(mr, subpage_t, iomem);",
" memory_region_destroy(&subpage->iomem);",
" g_free(subpage);"
],
"line_no": [
1,
5,
7,
11,
13,
15,
17
]
}
|
static void FUNC_0(uint16_t VAR_0)
{
MemoryRegionSection *section = &phys_sections[VAR_0];
MemoryRegion *mr = section->mr;
if (mr->subpage) {
subpage_t *subpage = container_of(mr, subpage_t, iomem);
memory_region_destroy(&subpage->iomem);
g_free(subpage);
}
}
|
[
"static void FUNC_0(uint16_t VAR_0)\n{",
"MemoryRegionSection *section = &phys_sections[VAR_0];",
"MemoryRegion *mr = section->mr;",
"if (mr->subpage) {",
"subpage_t *subpage = container_of(mr, subpage_t, iomem);",
"memory_region_destroy(&subpage->iomem);",
"g_free(subpage);",
"}",
"}"
] |
[
1,
1,
1,
1,
1,
1,
1,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
7,053 |
static void opt_output_file(const char *filename)
{
AVFormatContext *oc;
int err, use_video, use_audio, use_subtitle;
int input_has_video, input_has_audio, input_has_subtitle;
AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
if (!strcmp(filename, "-"))
filename = "pipe:";
oc = avformat_alloc_context();
if (!oc) {
print_error(filename, AVERROR(ENOMEM));
ffmpeg_exit(1);
}
if (last_asked_format) {
file_oformat = av_guess_format(last_asked_format, NULL, NULL);
if (!file_oformat) {
fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
ffmpeg_exit(1);
}
last_asked_format = NULL;
} else {
file_oformat = av_guess_format(NULL, filename, NULL);
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
ffmpeg_exit(1);
}
}
oc->oformat = file_oformat;
av_strlcpy(oc->filename, filename, sizeof(oc->filename));
if (!strcmp(file_oformat->name, "ffm") &&
av_strstart(filename, "http:", NULL)) {
/* special case for files sent to ffserver: we get the stream
parameters from ffserver */
int err = read_ffserver_streams(oc, filename);
if (err < 0) {
print_error(filename, err);
ffmpeg_exit(1);
}
} else {
use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
/* disable if no corresponding type found and at least one
input file */
if (nb_input_files > 0) {
check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
&input_has_subtitle);
if (!input_has_video)
use_video = 0;
if (!input_has_audio)
use_audio = 0;
if (!input_has_subtitle)
use_subtitle = 0;
}
/* manual disable */
if (audio_disable) {
use_audio = 0;
}
if (video_disable) {
use_video = 0;
}
if (subtitle_disable) {
use_subtitle = 0;
}
if (use_video) {
new_video_stream(oc);
}
if (use_audio) {
new_audio_stream(oc);
}
if (use_subtitle) {
new_subtitle_stream(oc);
}
oc->timestamp = recording_timestamp;
for(; metadata_count>0; metadata_count--){
av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
metadata[metadata_count-1].value, 0);
}
av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
}
output_files[nb_output_files++] = oc;
/* check filename in case of an image number is expected */
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
if (!av_filename_number_test(oc->filename)) {
print_error(oc->filename, AVERROR_NUMEXPECTED);
ffmpeg_exit(1);
}
}
if (!(oc->oformat->flags & AVFMT_NOFILE)) {
/* test if it already exists to avoid loosing precious files */
if (!file_overwrite &&
(strchr(filename, ':') == NULL ||
filename[1] == ':' ||
av_strstart(filename, "file:", NULL))) {
if (url_exist(filename)) {
if (!using_stdin) {
fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
fflush(stderr);
if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
ffmpeg_exit(1);
}
}
else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
ffmpeg_exit(1);
}
}
}
/* open the file */
if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
print_error(filename, err);
ffmpeg_exit(1);
}
}
memset(ap, 0, sizeof(*ap));
if (av_set_parameters(oc, ap) < 0) {
fprintf(stderr, "%s: Invalid encoding parameters\n",
oc->filename);
ffmpeg_exit(1);
}
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
oc->loop_output = loop_output;
oc->flags |= AVFMT_FLAG_NONBLOCK;
set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
nb_streamid_map = 0;
}
| true |
FFmpeg
|
ca8064d2d1b293d7a8011bf0a08005c11ae8ba67
|
static void opt_output_file(const char *filename)
{
AVFormatContext *oc;
int err, use_video, use_audio, use_subtitle;
int input_has_video, input_has_audio, input_has_subtitle;
AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
if (!strcmp(filename, "-"))
filename = "pipe:";
oc = avformat_alloc_context();
if (!oc) {
print_error(filename, AVERROR(ENOMEM));
ffmpeg_exit(1);
}
if (last_asked_format) {
file_oformat = av_guess_format(last_asked_format, NULL, NULL);
if (!file_oformat) {
fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
ffmpeg_exit(1);
}
last_asked_format = NULL;
} else {
file_oformat = av_guess_format(NULL, filename, NULL);
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
filename);
ffmpeg_exit(1);
}
}
oc->oformat = file_oformat;
av_strlcpy(oc->filename, filename, sizeof(oc->filename));
if (!strcmp(file_oformat->name, "ffm") &&
av_strstart(filename, "http:", NULL)) {
int err = read_ffserver_streams(oc, filename);
if (err < 0) {
print_error(filename, err);
ffmpeg_exit(1);
}
} else {
use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
if (nb_input_files > 0) {
check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
&input_has_subtitle);
if (!input_has_video)
use_video = 0;
if (!input_has_audio)
use_audio = 0;
if (!input_has_subtitle)
use_subtitle = 0;
}
if (audio_disable) {
use_audio = 0;
}
if (video_disable) {
use_video = 0;
}
if (subtitle_disable) {
use_subtitle = 0;
}
if (use_video) {
new_video_stream(oc);
}
if (use_audio) {
new_audio_stream(oc);
}
if (use_subtitle) {
new_subtitle_stream(oc);
}
oc->timestamp = recording_timestamp;
for(; metadata_count>0; metadata_count--){
av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
metadata[metadata_count-1].value, 0);
}
av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
}
output_files[nb_output_files++] = oc;
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
if (!av_filename_number_test(oc->filename)) {
print_error(oc->filename, AVERROR_NUMEXPECTED);
ffmpeg_exit(1);
}
}
if (!(oc->oformat->flags & AVFMT_NOFILE)) {
if (!file_overwrite &&
(strchr(filename, ':') == NULL ||
filename[1] == ':' ||
av_strstart(filename, "file:", NULL))) {
if (url_exist(filename)) {
if (!using_stdin) {
fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
fflush(stderr);
if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
ffmpeg_exit(1);
}
}
else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
ffmpeg_exit(1);
}
}
}
if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
print_error(filename, err);
ffmpeg_exit(1);
}
}
memset(ap, 0, sizeof(*ap));
if (av_set_parameters(oc, ap) < 0) {
fprintf(stderr, "%s: Invalid encoding parameters\n",
oc->filename);
ffmpeg_exit(1);
}
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
oc->loop_output = loop_output;
oc->flags |= AVFMT_FLAG_NONBLOCK;
set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
nb_streamid_map = 0;
}
|
{
"code": [
" new_video_stream(oc);",
" new_audio_stream(oc);",
" new_subtitle_stream(oc);"
],
"line_no": [
151,
159,
167
]
}
|
static void FUNC_0(const char *VAR_0)
{
AVFormatContext *oc;
int VAR_8, VAR_2, VAR_3, VAR_4;
int VAR_5, VAR_6, VAR_7;
AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
if (!strcmp(VAR_0, "-"))
VAR_0 = "pipe:";
oc = avformat_alloc_context();
if (!oc) {
print_error(VAR_0, AVERROR(ENOMEM));
ffmpeg_exit(1);
}
if (last_asked_format) {
file_oformat = av_guess_format(last_asked_format, NULL, NULL);
if (!file_oformat) {
fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
ffmpeg_exit(1);
}
last_asked_format = NULL;
} else {
file_oformat = av_guess_format(NULL, VAR_0, NULL);
if (!file_oformat) {
fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
VAR_0);
ffmpeg_exit(1);
}
}
oc->oformat = file_oformat;
av_strlcpy(oc->VAR_0, VAR_0, sizeof(oc->VAR_0));
if (!strcmp(file_oformat->name, "ffm") &&
av_strstart(VAR_0, "http:", NULL)) {
int VAR_8 = read_ffserver_streams(oc, VAR_0);
if (VAR_8 < 0) {
print_error(VAR_0, VAR_8);
ffmpeg_exit(1);
}
} else {
VAR_2 = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
VAR_3 = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
VAR_4 = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
if (nb_input_files > 0) {
check_audio_video_sub_inputs(&VAR_5, &VAR_6,
&VAR_7);
if (!VAR_5)
VAR_2 = 0;
if (!VAR_6)
VAR_3 = 0;
if (!VAR_7)
VAR_4 = 0;
}
if (audio_disable) {
VAR_3 = 0;
}
if (video_disable) {
VAR_2 = 0;
}
if (subtitle_disable) {
VAR_4 = 0;
}
if (VAR_2) {
new_video_stream(oc);
}
if (VAR_3) {
new_audio_stream(oc);
}
if (VAR_4) {
new_subtitle_stream(oc);
}
oc->timestamp = recording_timestamp;
for(; metadata_count>0; metadata_count--){
av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,
metadata[metadata_count-1].value, 0);
}
av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
}
output_files[nb_output_files++] = oc;
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
if (!av_filename_number_test(oc->VAR_0)) {
print_error(oc->VAR_0, AVERROR_NUMEXPECTED);
ffmpeg_exit(1);
}
}
if (!(oc->oformat->flags & AVFMT_NOFILE)) {
if (!file_overwrite &&
(strchr(VAR_0, ':') == NULL ||
VAR_0[1] == ':' ||
av_strstart(VAR_0, "file:", NULL))) {
if (url_exist(VAR_0)) {
if (!using_stdin) {
fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", VAR_0);
fflush(stderr);
if (!read_yesno()) {
fprintf(stderr, "Not overwriting - exiting\n");
ffmpeg_exit(1);
}
}
else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", VAR_0);
ffmpeg_exit(1);
}
}
}
if ((VAR_8 = url_fopen(&oc->pb, VAR_0, URL_WRONLY)) < 0) {
print_error(VAR_0, VAR_8);
ffmpeg_exit(1);
}
}
memset(ap, 0, sizeof(*ap));
if (av_set_parameters(oc, ap) < 0) {
fprintf(stderr, "%s: Invalid encoding parameters\n",
oc->VAR_0);
ffmpeg_exit(1);
}
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
oc->loop_output = loop_output;
oc->flags |= AVFMT_FLAG_NONBLOCK;
set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
nb_streamid_map = 0;
}
|
[
"static void FUNC_0(const char *VAR_0)\n{",
"AVFormatContext *oc;",
"int VAR_8, VAR_2, VAR_3, VAR_4;",
"int VAR_5, VAR_6, VAR_7;",
"AVFormatParameters params, *ap = ¶ms;",
"AVOutputFormat *file_oformat;",
"if (!strcmp(VAR_0, \"-\"))\nVAR_0 = \"pipe:\";",
"oc = avformat_alloc_context();",
"if (!oc) {",
"print_error(VAR_0, AVERROR(ENOMEM));",
"ffmpeg_exit(1);",
"}",
"if (last_asked_format) {",
"file_oformat = av_guess_format(last_asked_format, NULL, NULL);",
"if (!file_oformat) {",
"fprintf(stderr, \"Requested output format '%s' is not a suitable output format\\n\", last_asked_format);",
"ffmpeg_exit(1);",
"}",
"last_asked_format = NULL;",
"} else {",
"file_oformat = av_guess_format(NULL, VAR_0, NULL);",
"if (!file_oformat) {",
"fprintf(stderr, \"Unable to find a suitable output format for '%s'\\n\",\nVAR_0);",
"ffmpeg_exit(1);",
"}",
"}",
"oc->oformat = file_oformat;",
"av_strlcpy(oc->VAR_0, VAR_0, sizeof(oc->VAR_0));",
"if (!strcmp(file_oformat->name, \"ffm\") &&\nav_strstart(VAR_0, \"http:\", NULL)) {",
"int VAR_8 = read_ffserver_streams(oc, VAR_0);",
"if (VAR_8 < 0) {",
"print_error(VAR_0, VAR_8);",
"ffmpeg_exit(1);",
"}",
"} else {",
"VAR_2 = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;",
"VAR_3 = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;",
"VAR_4 = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;",
"if (nb_input_files > 0) {",
"check_audio_video_sub_inputs(&VAR_5, &VAR_6,\n&VAR_7);",
"if (!VAR_5)\nVAR_2 = 0;",
"if (!VAR_6)\nVAR_3 = 0;",
"if (!VAR_7)\nVAR_4 = 0;",
"}",
"if (audio_disable) {",
"VAR_3 = 0;",
"}",
"if (video_disable) {",
"VAR_2 = 0;",
"}",
"if (subtitle_disable) {",
"VAR_4 = 0;",
"}",
"if (VAR_2) {",
"new_video_stream(oc);",
"}",
"if (VAR_3) {",
"new_audio_stream(oc);",
"}",
"if (VAR_4) {",
"new_subtitle_stream(oc);",
"}",
"oc->timestamp = recording_timestamp;",
"for(; metadata_count>0; metadata_count--){",
"av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key,\nmetadata[metadata_count-1].value, 0);",
"}",
"av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);",
"}",
"output_files[nb_output_files++] = oc;",
"if (oc->oformat->flags & AVFMT_NEEDNUMBER) {",
"if (!av_filename_number_test(oc->VAR_0)) {",
"print_error(oc->VAR_0, AVERROR_NUMEXPECTED);",
"ffmpeg_exit(1);",
"}",
"}",
"if (!(oc->oformat->flags & AVFMT_NOFILE)) {",
"if (!file_overwrite &&\n(strchr(VAR_0, ':') == NULL ||\nVAR_0[1] == ':' ||\nav_strstart(VAR_0, \"file:\", NULL))) {",
"if (url_exist(VAR_0)) {",
"if (!using_stdin) {",
"fprintf(stderr,\"File '%s' already exists. Overwrite ? [y/N] \", VAR_0);",
"fflush(stderr);",
"if (!read_yesno()) {",
"fprintf(stderr, \"Not overwriting - exiting\\n\");",
"ffmpeg_exit(1);",
"}",
"}",
"else {",
"fprintf(stderr,\"File '%s' already exists. Exiting.\\n\", VAR_0);",
"ffmpeg_exit(1);",
"}",
"}",
"}",
"if ((VAR_8 = url_fopen(&oc->pb, VAR_0, URL_WRONLY)) < 0) {",
"print_error(VAR_0, VAR_8);",
"ffmpeg_exit(1);",
"}",
"}",
"memset(ap, 0, sizeof(*ap));",
"if (av_set_parameters(oc, ap) < 0) {",
"fprintf(stderr, \"%s: Invalid encoding parameters\\n\",\noc->VAR_0);",
"ffmpeg_exit(1);",
"}",
"oc->preload= (int)(mux_preload*AV_TIME_BASE);",
"oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);",
"oc->loop_output = loop_output;",
"oc->flags |= AVFMT_FLAG_NONBLOCK;",
"set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);",
"nb_streamid_map = 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17,
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
73,
75
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
105
],
[
107,
109
],
[
111,
113
],
[
115,
117
],
[
119,
121
],
[
123
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159
],
[
161
],
[
165
],
[
167
],
[
169
],
[
173
],
[
177
],
[
179,
181
],
[
183
],
[
185
],
[
187
],
[
191
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
211
],
[
215,
217,
219,
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
269
],
[
271
],
[
273,
275
],
[
277
],
[
279
],
[
283
],
[
285
],
[
287
],
[
289
],
[
293
],
[
297
],
[
299
]
] |
7,054 |
void vnc_display_add_client(DisplayState *ds, int csock, int skipauth)
{
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
vnc_connect(vs, csock, skipauth, 0);
}
| true |
qemu
|
21ef45d71221b4577330fe3aacfb06afad91ad46
|
void vnc_display_add_client(DisplayState *ds, int csock, int skipauth)
{
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
vnc_connect(vs, csock, skipauth, 0);
}
|
{
"code": [
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;",
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;",
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;",
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;",
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;",
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;",
" VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;"
],
"line_no": [
5,
5,
5,
5,
5,
5,
5
]
}
|
void FUNC_0(DisplayState *VAR_0, int VAR_1, int VAR_2)
{
VncDisplay *vs = VAR_0 ? (VncDisplay *)VAR_0->opaque : vnc_display;
vnc_connect(vs, VAR_1, VAR_2, 0);
}
|
[
"void FUNC_0(DisplayState *VAR_0, int VAR_1, int VAR_2)\n{",
"VncDisplay *vs = VAR_0 ? (VncDisplay *)VAR_0->opaque : vnc_display;",
"vnc_connect(vs, VAR_1, VAR_2, 0);",
"}"
] |
[
0,
1,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
]
] |
7,057 |
av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp)
{
#if HAVE_YASM
int cpu_flags = av_get_cpu_flags();
#define init_fpel(idx1, idx2, sz, type, opt) \
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][0][0] = \
dsp->mc[idx1][FILTER_BILINEAR ][idx2][0][0] = ff_vp9_##type##sz##_##opt
#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type, opt) \
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][idxh][idxv] = type##_8tap_smooth_##sz##dir##_##opt; \
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type##_8tap_regular_##sz##dir##_##opt; \
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][idxh][idxv] = type##_8tap_sharp_##sz##dir##_##opt
#define init_subpel2_32_64(idx, idxh, idxv, dir, type, opt) \
init_subpel1(0, idx, idxh, idxv, 64, dir, type, opt); \
init_subpel1(1, idx, idxh, idxv, 32, dir, type, opt)
#define init_subpel2(idx, idxh, idxv, dir, type, opt) \
init_subpel2_32_64(idx, idxh, idxv, dir, type, opt); \
init_subpel1(2, idx, idxh, idxv, 16, dir, type, opt); \
init_subpel1(3, idx, idxh, idxv, 8, dir, type, opt); \
init_subpel1(4, idx, idxh, idxv, 4, dir, type, opt)
#define init_subpel3(idx, type, opt) \
init_subpel2(idx, 1, 1, hv, type, opt); \
init_subpel2(idx, 0, 1, v, type, opt); \
init_subpel2(idx, 1, 0, h, type, opt)
#define init_lpf(opt) do { \
if (ARCH_X86_64) { \
dsp->loop_filter_16[0] = ff_vp9_loop_filter_h_16_16_##opt; \
dsp->loop_filter_16[1] = ff_vp9_loop_filter_v_16_16_##opt; \
dsp->loop_filter_mix2[0][0][0] = ff_vp9_loop_filter_h_44_16_##opt; \
dsp->loop_filter_mix2[0][0][1] = ff_vp9_loop_filter_v_44_16_##opt; \
dsp->loop_filter_mix2[0][1][0] = ff_vp9_loop_filter_h_48_16_##opt; \
dsp->loop_filter_mix2[0][1][1] = ff_vp9_loop_filter_v_48_16_##opt; \
dsp->loop_filter_mix2[1][0][0] = ff_vp9_loop_filter_h_84_16_##opt; \
dsp->loop_filter_mix2[1][0][1] = ff_vp9_loop_filter_v_84_16_##opt; \
dsp->loop_filter_mix2[1][1][0] = ff_vp9_loop_filter_h_88_16_##opt; \
dsp->loop_filter_mix2[1][1][1] = ff_vp9_loop_filter_v_88_16_##opt; \
} \
} while (0)
#define init_ipred(tx, sz, opt) do { \
dsp->intra_pred[tx][HOR_PRED] = ff_vp9_ipred_h_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][DIAG_DOWN_LEFT_PRED] = ff_vp9_ipred_dl_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][DIAG_DOWN_RIGHT_PRED] = ff_vp9_ipred_dr_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][HOR_DOWN_PRED] = ff_vp9_ipred_hd_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][VERT_LEFT_PRED] = ff_vp9_ipred_vl_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][HOR_UP_PRED] = ff_vp9_ipred_hu_##sz##x##sz##_##opt; \
if (ARCH_X86_64 || tx != TX_32X32) { \
dsp->intra_pred[tx][VERT_RIGHT_PRED] = ff_vp9_ipred_vr_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][TM_VP8_PRED] = ff_vp9_ipred_tm_##sz##x##sz##_##opt; \
} \
} while (0)
#define init_dc_ipred(tx, sz, opt) do { \
init_ipred(tx, sz, opt); \
dsp->intra_pred[tx][DC_PRED] = ff_vp9_ipred_dc_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][TOP_DC_PRED] = ff_vp9_ipred_dc_top_##sz##x##sz##_##opt; \
} while (0)
if (EXTERNAL_MMX(cpu_flags)) {
init_fpel(4, 0, 4, put, mmx);
init_fpel(3, 0, 8, put, mmx);
dsp->itxfm_add[4 /* lossless */][DCT_DCT] =
dsp->itxfm_add[4 /* lossless */][ADST_DCT] =
dsp->itxfm_add[4 /* lossless */][DCT_ADST] =
dsp->itxfm_add[4 /* lossless */][ADST_ADST] = ff_vp9_iwht_iwht_4x4_add_mmx;
dsp->intra_pred[TX_8X8][VERT_PRED] = ff_vp9_ipred_v_8x8_mmx;
}
if (EXTERNAL_MMXEXT(cpu_flags)) {
init_fpel(4, 1, 4, avg, mmxext);
init_fpel(3, 1, 8, avg, mmxext);
dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_mmxext;
}
if (EXTERNAL_SSE(cpu_flags)) {
init_fpel(2, 0, 16, put, sse);
init_fpel(1, 0, 32, put, sse);
init_fpel(0, 0, 64, put, sse);
}
if (EXTERNAL_SSE2(cpu_flags)) {
init_fpel(2, 1, 16, avg, sse2);
init_fpel(1, 1, 32, avg, sse2);
init_fpel(0, 1, 64, avg, sse2);
init_lpf(sse2);
dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_sse2;
dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_sse2;
dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_sse2;
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_sse2;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_sse2;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_sse2;
dsp->intra_pred[TX_16X16][VERT_PRED] = ff_vp9_ipred_v_16x16_sse2;
dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_sse2;
}
if (EXTERNAL_SSSE3(cpu_flags)) {
init_subpel3(0, put, ssse3);
init_subpel3(1, avg, ssse3);
dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_ssse3;
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_ssse3;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_ssse3;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_ssse3;
init_lpf(ssse3);
init_dc_ipred(TX_4X4, 4, ssse3);
init_dc_ipred(TX_8X8, 8, ssse3);
init_dc_ipred(TX_16X16, 16, ssse3);
init_dc_ipred(TX_32X32, 32, ssse3);
}
if (EXTERNAL_AVX(cpu_flags)) {
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_avx;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_avx;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_avx;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_avx;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_avx;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_avx;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_avx;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_avx;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_avx;
init_fpel(1, 0, 32, put, avx);
init_fpel(0, 0, 64, put, avx);
init_lpf(avx);
init_ipred(TX_8X8, 8, avx);
init_ipred(TX_16X16, 16, avx);
init_ipred(TX_32X32, 32, avx);
}
if (EXTERNAL_AVX2(cpu_flags)) {
init_fpel(1, 1, 32, avg, avx2);
init_fpel(0, 1, 64, avg, avx2);
if (ARCH_X86_64) {
#if ARCH_X86_64 && HAVE_AVX2_EXTERNAL
init_subpel2_32_64(0, 1, 1, hv, put, avx2);
init_subpel2_32_64(0, 0, 1, v, put, avx2);
init_subpel2_32_64(0, 1, 0, h, put, avx2);
init_subpel2_32_64(1, 1, 1, hv, avg, avx2);
init_subpel2_32_64(1, 0, 1, v, avg, avx2);
init_subpel2_32_64(1, 1, 0, h, avg, avx2);
#endif
}
dsp->intra_pred[TX_32X32][DC_PRED] = ff_vp9_ipred_dc_32x32_avx2;
dsp->intra_pred[TX_32X32][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_32x32_avx2;
dsp->intra_pred[TX_32X32][TOP_DC_PRED] = ff_vp9_ipred_dc_top_32x32_avx2;
dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_avx2;
dsp->intra_pred[TX_32X32][HOR_PRED] = ff_vp9_ipred_h_32x32_avx2;
dsp->intra_pred[TX_32X32][TM_VP8_PRED] = ff_vp9_ipred_tm_32x32_avx2;
}
#undef init_fpel
#undef init_subpel1
#undef init_subpel2
#undef init_subpel3
#endif /* HAVE_YASM */
}
| true |
FFmpeg
|
cae893f692bf848872b2e37be5ddb9d8a24644eb
|
av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp)
{
#if HAVE_YASM
int cpu_flags = av_get_cpu_flags();
#define init_fpel(idx1, idx2, sz, type, opt) \
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][0][0] = \
dsp->mc[idx1][FILTER_BILINEAR ][idx2][0][0] = ff_vp9_##type##sz##_##opt
#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type, opt) \
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][idxh][idxv] = type##_8tap_smooth_##sz##dir##_##opt; \
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type##_8tap_regular_##sz##dir##_##opt; \
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][idxh][idxv] = type##_8tap_sharp_##sz##dir##_##opt
#define init_subpel2_32_64(idx, idxh, idxv, dir, type, opt) \
init_subpel1(0, idx, idxh, idxv, 64, dir, type, opt); \
init_subpel1(1, idx, idxh, idxv, 32, dir, type, opt)
#define init_subpel2(idx, idxh, idxv, dir, type, opt) \
init_subpel2_32_64(idx, idxh, idxv, dir, type, opt); \
init_subpel1(2, idx, idxh, idxv, 16, dir, type, opt); \
init_subpel1(3, idx, idxh, idxv, 8, dir, type, opt); \
init_subpel1(4, idx, idxh, idxv, 4, dir, type, opt)
#define init_subpel3(idx, type, opt) \
init_subpel2(idx, 1, 1, hv, type, opt); \
init_subpel2(idx, 0, 1, v, type, opt); \
init_subpel2(idx, 1, 0, h, type, opt)
#define init_lpf(opt) do { \
if (ARCH_X86_64) { \
dsp->loop_filter_16[0] = ff_vp9_loop_filter_h_16_16_##opt; \
dsp->loop_filter_16[1] = ff_vp9_loop_filter_v_16_16_##opt; \
dsp->loop_filter_mix2[0][0][0] = ff_vp9_loop_filter_h_44_16_##opt; \
dsp->loop_filter_mix2[0][0][1] = ff_vp9_loop_filter_v_44_16_##opt; \
dsp->loop_filter_mix2[0][1][0] = ff_vp9_loop_filter_h_48_16_##opt; \
dsp->loop_filter_mix2[0][1][1] = ff_vp9_loop_filter_v_48_16_##opt; \
dsp->loop_filter_mix2[1][0][0] = ff_vp9_loop_filter_h_84_16_##opt; \
dsp->loop_filter_mix2[1][0][1] = ff_vp9_loop_filter_v_84_16_##opt; \
dsp->loop_filter_mix2[1][1][0] = ff_vp9_loop_filter_h_88_16_##opt; \
dsp->loop_filter_mix2[1][1][1] = ff_vp9_loop_filter_v_88_16_##opt; \
} \
} while (0)
#define init_ipred(tx, sz, opt) do { \
dsp->intra_pred[tx][HOR_PRED] = ff_vp9_ipred_h_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][DIAG_DOWN_LEFT_PRED] = ff_vp9_ipred_dl_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][DIAG_DOWN_RIGHT_PRED] = ff_vp9_ipred_dr_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][HOR_DOWN_PRED] = ff_vp9_ipred_hd_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][VERT_LEFT_PRED] = ff_vp9_ipred_vl_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][HOR_UP_PRED] = ff_vp9_ipred_hu_##sz##x##sz##_##opt; \
if (ARCH_X86_64 || tx != TX_32X32) { \
dsp->intra_pred[tx][VERT_RIGHT_PRED] = ff_vp9_ipred_vr_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][TM_VP8_PRED] = ff_vp9_ipred_tm_##sz##x##sz##_##opt; \
} \
} while (0)
#define init_dc_ipred(tx, sz, opt) do { \
init_ipred(tx, sz, opt); \
dsp->intra_pred[tx][DC_PRED] = ff_vp9_ipred_dc_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][TOP_DC_PRED] = ff_vp9_ipred_dc_top_##sz##x##sz##_##opt; \
} while (0)
if (EXTERNAL_MMX(cpu_flags)) {
init_fpel(4, 0, 4, put, mmx);
init_fpel(3, 0, 8, put, mmx);
dsp->itxfm_add[4 ][DCT_DCT] =
dsp->itxfm_add[4 ][ADST_DCT] =
dsp->itxfm_add[4 ][DCT_ADST] =
dsp->itxfm_add[4 ][ADST_ADST] = ff_vp9_iwht_iwht_4x4_add_mmx;
dsp->intra_pred[TX_8X8][VERT_PRED] = ff_vp9_ipred_v_8x8_mmx;
}
if (EXTERNAL_MMXEXT(cpu_flags)) {
init_fpel(4, 1, 4, avg, mmxext);
init_fpel(3, 1, 8, avg, mmxext);
dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_mmxext;
}
if (EXTERNAL_SSE(cpu_flags)) {
init_fpel(2, 0, 16, put, sse);
init_fpel(1, 0, 32, put, sse);
init_fpel(0, 0, 64, put, sse);
}
if (EXTERNAL_SSE2(cpu_flags)) {
init_fpel(2, 1, 16, avg, sse2);
init_fpel(1, 1, 32, avg, sse2);
init_fpel(0, 1, 64, avg, sse2);
init_lpf(sse2);
dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_sse2;
dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_sse2;
dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_sse2;
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_sse2;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_sse2;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_sse2;
dsp->intra_pred[TX_16X16][VERT_PRED] = ff_vp9_ipred_v_16x16_sse2;
dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_sse2;
}
if (EXTERNAL_SSSE3(cpu_flags)) {
init_subpel3(0, put, ssse3);
init_subpel3(1, avg, ssse3);
dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_ssse3;
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_ssse3;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_ssse3;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_ssse3;
init_lpf(ssse3);
init_dc_ipred(TX_4X4, 4, ssse3);
init_dc_ipred(TX_8X8, 8, ssse3);
init_dc_ipred(TX_16X16, 16, ssse3);
init_dc_ipred(TX_32X32, 32, ssse3);
}
if (EXTERNAL_AVX(cpu_flags)) {
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_avx;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_avx;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_avx;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_avx;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_avx;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_avx;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_avx;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_avx;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_avx;
init_fpel(1, 0, 32, put, avx);
init_fpel(0, 0, 64, put, avx);
init_lpf(avx);
init_ipred(TX_8X8, 8, avx);
init_ipred(TX_16X16, 16, avx);
init_ipred(TX_32X32, 32, avx);
}
if (EXTERNAL_AVX2(cpu_flags)) {
init_fpel(1, 1, 32, avg, avx2);
init_fpel(0, 1, 64, avg, avx2);
if (ARCH_X86_64) {
#if ARCH_X86_64 && HAVE_AVX2_EXTERNAL
init_subpel2_32_64(0, 1, 1, hv, put, avx2);
init_subpel2_32_64(0, 0, 1, v, put, avx2);
init_subpel2_32_64(0, 1, 0, h, put, avx2);
init_subpel2_32_64(1, 1, 1, hv, avg, avx2);
init_subpel2_32_64(1, 0, 1, v, avg, avx2);
init_subpel2_32_64(1, 1, 0, h, avg, avx2);
#endif
}
dsp->intra_pred[TX_32X32][DC_PRED] = ff_vp9_ipred_dc_32x32_avx2;
dsp->intra_pred[TX_32X32][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_32x32_avx2;
dsp->intra_pred[TX_32X32][TOP_DC_PRED] = ff_vp9_ipred_dc_top_32x32_avx2;
dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_avx2;
dsp->intra_pred[TX_32X32][HOR_PRED] = ff_vp9_ipred_h_32x32_avx2;
dsp->intra_pred[TX_32X32][TM_VP8_PRED] = ff_vp9_ipred_tm_32x32_avx2;
}
#undef init_fpel
#undef init_subpel1
#undef init_subpel2
#undef init_subpel3
#endif
}
|
{
"code": [
"#define init_subpel2_32_64(idx, idxh, idxv, dir, type, opt) \\",
" init_subpel1(0, idx, idxh, idxv, 64, dir, type, opt); \\",
" init_subpel1(1, idx, idxh, idxv, 32, dir, type, opt)",
"#define init_subpel2(idx, idxh, idxv, dir, type, opt) \\",
" init_subpel2_32_64(idx, idxh, idxv, dir, type, opt); \\",
" init_subpel1(2, idx, idxh, idxv, 16, dir, type, opt); \\",
" init_subpel1(3, idx, idxh, idxv, 8, dir, type, opt); \\",
" init_subpel1(4, idx, idxh, idxv, 4, dir, type, opt)",
" init_subpel2(idx, 1, 1, hv, type, opt); \\",
" init_subpel2(idx, 0, 1, v, type, opt); \\",
" init_subpel2(idx, 1, 0, h, type, opt)",
" init_subpel2_32_64(0, 1, 1, hv, put, avx2);",
" init_subpel2_32_64(0, 0, 1, v, put, avx2);",
" init_subpel2_32_64(0, 1, 0, h, put, avx2);",
" init_subpel2_32_64(1, 1, 1, hv, avg, avx2);",
" init_subpel2_32_64(1, 0, 1, v, avg, avx2);",
" init_subpel2_32_64(1, 1, 0, h, avg, avx2);"
],
"line_no": [
33,
35,
37,
41,
43,
45,
47,
49,
55,
57,
59,
327,
329,
331,
333,
335,
337
]
}
|
av_cold void FUNC_0(VP9DSPContext *dsp)
{
#if HAVE_YASM
int cpu_flags = av_get_cpu_flags();
#define init_fpel(idx1, idx2, sz, type, opt) \
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][0][0] = \
dsp->mc[idx1][FILTER_BILINEAR ][idx2][0][0] = ff_vp9_##type##sz##_##opt
#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type, opt) \
dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][idxh][idxv] = type##_8tap_smooth_##sz##dir##_##opt; \
dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type##_8tap_regular_##sz##dir##_##opt; \
dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][idxh][idxv] = type##_8tap_sharp_##sz##dir##_##opt
#define init_subpel2_32_64(idx, idxh, idxv, dir, type, opt) \
init_subpel1(0, idx, idxh, idxv, 64, dir, type, opt); \
init_subpel1(1, idx, idxh, idxv, 32, dir, type, opt)
#define init_subpel2(idx, idxh, idxv, dir, type, opt) \
init_subpel2_32_64(idx, idxh, idxv, dir, type, opt); \
init_subpel1(2, idx, idxh, idxv, 16, dir, type, opt); \
init_subpel1(3, idx, idxh, idxv, 8, dir, type, opt); \
init_subpel1(4, idx, idxh, idxv, 4, dir, type, opt)
#define init_subpel3(idx, type, opt) \
init_subpel2(idx, 1, 1, hv, type, opt); \
init_subpel2(idx, 0, 1, v, type, opt); \
init_subpel2(idx, 1, 0, h, type, opt)
#define init_lpf(opt) do { \
if (ARCH_X86_64) { \
dsp->loop_filter_16[0] = ff_vp9_loop_filter_h_16_16_##opt; \
dsp->loop_filter_16[1] = ff_vp9_loop_filter_v_16_16_##opt; \
dsp->loop_filter_mix2[0][0][0] = ff_vp9_loop_filter_h_44_16_##opt; \
dsp->loop_filter_mix2[0][0][1] = ff_vp9_loop_filter_v_44_16_##opt; \
dsp->loop_filter_mix2[0][1][0] = ff_vp9_loop_filter_h_48_16_##opt; \
dsp->loop_filter_mix2[0][1][1] = ff_vp9_loop_filter_v_48_16_##opt; \
dsp->loop_filter_mix2[1][0][0] = ff_vp9_loop_filter_h_84_16_##opt; \
dsp->loop_filter_mix2[1][0][1] = ff_vp9_loop_filter_v_84_16_##opt; \
dsp->loop_filter_mix2[1][1][0] = ff_vp9_loop_filter_h_88_16_##opt; \
dsp->loop_filter_mix2[1][1][1] = ff_vp9_loop_filter_v_88_16_##opt; \
} \
} while (0)
#define init_ipred(tx, sz, opt) do { \
dsp->intra_pred[tx][HOR_PRED] = ff_vp9_ipred_h_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][DIAG_DOWN_LEFT_PRED] = ff_vp9_ipred_dl_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][DIAG_DOWN_RIGHT_PRED] = ff_vp9_ipred_dr_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][HOR_DOWN_PRED] = ff_vp9_ipred_hd_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][VERT_LEFT_PRED] = ff_vp9_ipred_vl_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][HOR_UP_PRED] = ff_vp9_ipred_hu_##sz##x##sz##_##opt; \
if (ARCH_X86_64 || tx != TX_32X32) { \
dsp->intra_pred[tx][VERT_RIGHT_PRED] = ff_vp9_ipred_vr_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][TM_VP8_PRED] = ff_vp9_ipred_tm_##sz##x##sz##_##opt; \
} \
} while (0)
#define init_dc_ipred(tx, sz, opt) do { \
init_ipred(tx, sz, opt); \
dsp->intra_pred[tx][DC_PRED] = ff_vp9_ipred_dc_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_##sz##x##sz##_##opt; \
dsp->intra_pred[tx][TOP_DC_PRED] = ff_vp9_ipred_dc_top_##sz##x##sz##_##opt; \
} while (0)
if (EXTERNAL_MMX(cpu_flags)) {
init_fpel(4, 0, 4, put, mmx);
init_fpel(3, 0, 8, put, mmx);
dsp->itxfm_add[4 ][DCT_DCT] =
dsp->itxfm_add[4 ][ADST_DCT] =
dsp->itxfm_add[4 ][DCT_ADST] =
dsp->itxfm_add[4 ][ADST_ADST] = ff_vp9_iwht_iwht_4x4_add_mmx;
dsp->intra_pred[TX_8X8][VERT_PRED] = ff_vp9_ipred_v_8x8_mmx;
}
if (EXTERNAL_MMXEXT(cpu_flags)) {
init_fpel(4, 1, 4, avg, mmxext);
init_fpel(3, 1, 8, avg, mmxext);
dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_mmxext;
}
if (EXTERNAL_SSE(cpu_flags)) {
init_fpel(2, 0, 16, put, sse);
init_fpel(1, 0, 32, put, sse);
init_fpel(0, 0, 64, put, sse);
}
if (EXTERNAL_SSE2(cpu_flags)) {
init_fpel(2, 1, 16, avg, sse2);
init_fpel(1, 1, 32, avg, sse2);
init_fpel(0, 1, 64, avg, sse2);
init_lpf(sse2);
dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_sse2;
dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_sse2;
dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_sse2;
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_sse2;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_sse2;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_sse2;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_sse2;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_sse2;
dsp->intra_pred[TX_16X16][VERT_PRED] = ff_vp9_ipred_v_16x16_sse2;
dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_sse2;
}
if (EXTERNAL_SSSE3(cpu_flags)) {
init_subpel3(0, put, ssse3);
init_subpel3(1, avg, ssse3);
dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_ssse3;
dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_ssse3;
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_ssse3;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_ssse3;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_ssse3;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_ssse3;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_ssse3;
init_lpf(ssse3);
init_dc_ipred(TX_4X4, 4, ssse3);
init_dc_ipred(TX_8X8, 8, ssse3);
init_dc_ipred(TX_16X16, 16, ssse3);
init_dc_ipred(TX_32X32, 32, ssse3);
}
if (EXTERNAL_AVX(cpu_flags)) {
dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_avx;
dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_avx;
dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_avx;
dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_avx;
dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_avx;
dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_avx;
dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_avx;
dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_avx;
dsp->itxfm_add[TX_32X32][ADST_ADST] =
dsp->itxfm_add[TX_32X32][ADST_DCT] =
dsp->itxfm_add[TX_32X32][DCT_ADST] =
dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_avx;
init_fpel(1, 0, 32, put, avx);
init_fpel(0, 0, 64, put, avx);
init_lpf(avx);
init_ipred(TX_8X8, 8, avx);
init_ipred(TX_16X16, 16, avx);
init_ipred(TX_32X32, 32, avx);
}
if (EXTERNAL_AVX2(cpu_flags)) {
init_fpel(1, 1, 32, avg, avx2);
init_fpel(0, 1, 64, avg, avx2);
if (ARCH_X86_64) {
#if ARCH_X86_64 && HAVE_AVX2_EXTERNAL
init_subpel2_32_64(0, 1, 1, hv, put, avx2);
init_subpel2_32_64(0, 0, 1, v, put, avx2);
init_subpel2_32_64(0, 1, 0, h, put, avx2);
init_subpel2_32_64(1, 1, 1, hv, avg, avx2);
init_subpel2_32_64(1, 0, 1, v, avg, avx2);
init_subpel2_32_64(1, 1, 0, h, avg, avx2);
#endif
}
dsp->intra_pred[TX_32X32][DC_PRED] = ff_vp9_ipred_dc_32x32_avx2;
dsp->intra_pred[TX_32X32][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_32x32_avx2;
dsp->intra_pred[TX_32X32][TOP_DC_PRED] = ff_vp9_ipred_dc_top_32x32_avx2;
dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_avx2;
dsp->intra_pred[TX_32X32][HOR_PRED] = ff_vp9_ipred_h_32x32_avx2;
dsp->intra_pred[TX_32X32][TM_VP8_PRED] = ff_vp9_ipred_tm_32x32_avx2;
}
#undef init_fpel
#undef init_subpel1
#undef init_subpel2
#undef init_subpel3
#endif
}
|
[
"av_cold void FUNC_0(VP9DSPContext *dsp)\n{",
"#if HAVE_YASM\nint cpu_flags = av_get_cpu_flags();",
"#define init_fpel(idx1, idx2, sz, type, opt) \\\ndsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \\\ndsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \\\ndsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][0][0] = \\\ndsp->mc[idx1][FILTER_BILINEAR ][idx2][0][0] = ff_vp9_##type##sz##_##opt\n#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type, opt) \\\ndsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][idxh][idxv] = type##_8tap_smooth_##sz##dir##_##opt; \\",
"dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type##_8tap_regular_##sz##dir##_##opt; \\",
"dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][idxh][idxv] = type##_8tap_sharp_##sz##dir##_##opt\n#define init_subpel2_32_64(idx, idxh, idxv, dir, type, opt) \\\ninit_subpel1(0, idx, idxh, idxv, 64, dir, type, opt); \\",
"init_subpel1(1, idx, idxh, idxv, 32, dir, type, opt)\n#define init_subpel2(idx, idxh, idxv, dir, type, opt) \\\ninit_subpel2_32_64(idx, idxh, idxv, dir, type, opt); \\",
"init_subpel1(2, idx, idxh, idxv, 16, dir, type, opt); \\",
"init_subpel1(3, idx, idxh, idxv, 8, dir, type, opt); \\",
"init_subpel1(4, idx, idxh, idxv, 4, dir, type, opt)\n#define init_subpel3(idx, type, opt) \\\ninit_subpel2(idx, 1, 1, hv, type, opt); \\",
"init_subpel2(idx, 0, 1, v, type, opt); \\",
"init_subpel2(idx, 1, 0, h, type, opt)\n#define init_lpf(opt) do { \\",
"if (ARCH_X86_64) { \\",
"dsp->loop_filter_16[0] = ff_vp9_loop_filter_h_16_16_##opt; \\",
"dsp->loop_filter_16[1] = ff_vp9_loop_filter_v_16_16_##opt; \\",
"dsp->loop_filter_mix2[0][0][0] = ff_vp9_loop_filter_h_44_16_##opt; \\",
"dsp->loop_filter_mix2[0][0][1] = ff_vp9_loop_filter_v_44_16_##opt; \\",
"dsp->loop_filter_mix2[0][1][0] = ff_vp9_loop_filter_h_48_16_##opt; \\",
"dsp->loop_filter_mix2[0][1][1] = ff_vp9_loop_filter_v_48_16_##opt; \\",
"dsp->loop_filter_mix2[1][0][0] = ff_vp9_loop_filter_h_84_16_##opt; \\",
"dsp->loop_filter_mix2[1][0][1] = ff_vp9_loop_filter_v_84_16_##opt; \\",
"dsp->loop_filter_mix2[1][1][0] = ff_vp9_loop_filter_h_88_16_##opt; \\",
"dsp->loop_filter_mix2[1][1][1] = ff_vp9_loop_filter_v_88_16_##opt; \\",
"} \\",
"} while (0)",
"#define init_ipred(tx, sz, opt) do { \\",
"dsp->intra_pred[tx][HOR_PRED] = ff_vp9_ipred_h_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][DIAG_DOWN_LEFT_PRED] = ff_vp9_ipred_dl_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][DIAG_DOWN_RIGHT_PRED] = ff_vp9_ipred_dr_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][HOR_DOWN_PRED] = ff_vp9_ipred_hd_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][VERT_LEFT_PRED] = ff_vp9_ipred_vl_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][HOR_UP_PRED] = ff_vp9_ipred_hu_##sz##x##sz##_##opt; \\",
"if (ARCH_X86_64 || tx != TX_32X32) { \\",
"dsp->intra_pred[tx][VERT_RIGHT_PRED] = ff_vp9_ipred_vr_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][TM_VP8_PRED] = ff_vp9_ipred_tm_##sz##x##sz##_##opt; \\",
"} \\",
"} while (0)",
"#define init_dc_ipred(tx, sz, opt) do { \\",
"init_ipred(tx, sz, opt); \\",
"dsp->intra_pred[tx][DC_PRED] = ff_vp9_ipred_dc_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_##sz##x##sz##_##opt; \\",
"dsp->intra_pred[tx][TOP_DC_PRED] = ff_vp9_ipred_dc_top_##sz##x##sz##_##opt; \\",
"} while (0)",
"if (EXTERNAL_MMX(cpu_flags)) {",
"init_fpel(4, 0, 4, put, mmx);",
"init_fpel(3, 0, 8, put, mmx);",
"dsp->itxfm_add[4 ][DCT_DCT] =\ndsp->itxfm_add[4 ][ADST_DCT] =\ndsp->itxfm_add[4 ][DCT_ADST] =\ndsp->itxfm_add[4 ][ADST_ADST] = ff_vp9_iwht_iwht_4x4_add_mmx;",
"dsp->intra_pred[TX_8X8][VERT_PRED] = ff_vp9_ipred_v_8x8_mmx;",
"}",
"if (EXTERNAL_MMXEXT(cpu_flags)) {",
"init_fpel(4, 1, 4, avg, mmxext);",
"init_fpel(3, 1, 8, avg, mmxext);",
"dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_mmxext;",
"}",
"if (EXTERNAL_SSE(cpu_flags)) {",
"init_fpel(2, 0, 16, put, sse);",
"init_fpel(1, 0, 32, put, sse);",
"init_fpel(0, 0, 64, put, sse);",
"}",
"if (EXTERNAL_SSE2(cpu_flags)) {",
"init_fpel(2, 1, 16, avg, sse2);",
"init_fpel(1, 1, 32, avg, sse2);",
"init_fpel(0, 1, 64, avg, sse2);",
"init_lpf(sse2);",
"dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_sse2;",
"dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_sse2;",
"dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_sse2;",
"dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_sse2;",
"dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_sse2;",
"dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_sse2;",
"dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_sse2;",
"dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_sse2;",
"dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_sse2;",
"dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_sse2;",
"dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_sse2;",
"dsp->itxfm_add[TX_32X32][ADST_ADST] =\ndsp->itxfm_add[TX_32X32][ADST_DCT] =\ndsp->itxfm_add[TX_32X32][DCT_ADST] =\ndsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_sse2;",
"dsp->intra_pred[TX_16X16][VERT_PRED] = ff_vp9_ipred_v_16x16_sse2;",
"dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_sse2;",
"}",
"if (EXTERNAL_SSSE3(cpu_flags)) {",
"init_subpel3(0, put, ssse3);",
"init_subpel3(1, avg, ssse3);",
"dsp->itxfm_add[TX_4X4][DCT_DCT] = ff_vp9_idct_idct_4x4_add_ssse3;",
"dsp->itxfm_add[TX_4X4][ADST_DCT] = ff_vp9_idct_iadst_4x4_add_ssse3;",
"dsp->itxfm_add[TX_4X4][DCT_ADST] = ff_vp9_iadst_idct_4x4_add_ssse3;",
"dsp->itxfm_add[TX_4X4][ADST_ADST] = ff_vp9_iadst_iadst_4x4_add_ssse3;",
"dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_ssse3;",
"dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_ssse3;",
"dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_ssse3;",
"dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_ssse3;",
"dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_ssse3;",
"dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_ssse3;",
"dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_ssse3;",
"dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_ssse3;",
"dsp->itxfm_add[TX_32X32][ADST_ADST] =\ndsp->itxfm_add[TX_32X32][ADST_DCT] =\ndsp->itxfm_add[TX_32X32][DCT_ADST] =\ndsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_ssse3;",
"init_lpf(ssse3);",
"init_dc_ipred(TX_4X4, 4, ssse3);",
"init_dc_ipred(TX_8X8, 8, ssse3);",
"init_dc_ipred(TX_16X16, 16, ssse3);",
"init_dc_ipred(TX_32X32, 32, ssse3);",
"}",
"if (EXTERNAL_AVX(cpu_flags)) {",
"dsp->itxfm_add[TX_8X8][DCT_DCT] = ff_vp9_idct_idct_8x8_add_avx;",
"dsp->itxfm_add[TX_8X8][ADST_DCT] = ff_vp9_idct_iadst_8x8_add_avx;",
"dsp->itxfm_add[TX_8X8][DCT_ADST] = ff_vp9_iadst_idct_8x8_add_avx;",
"dsp->itxfm_add[TX_8X8][ADST_ADST] = ff_vp9_iadst_iadst_8x8_add_avx;",
"dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_avx;",
"dsp->itxfm_add[TX_16X16][ADST_DCT] = ff_vp9_idct_iadst_16x16_add_avx;",
"dsp->itxfm_add[TX_16X16][DCT_ADST] = ff_vp9_iadst_idct_16x16_add_avx;",
"dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_avx;",
"dsp->itxfm_add[TX_32X32][ADST_ADST] =\ndsp->itxfm_add[TX_32X32][ADST_DCT] =\ndsp->itxfm_add[TX_32X32][DCT_ADST] =\ndsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_avx;",
"init_fpel(1, 0, 32, put, avx);",
"init_fpel(0, 0, 64, put, avx);",
"init_lpf(avx);",
"init_ipred(TX_8X8, 8, avx);",
"init_ipred(TX_16X16, 16, avx);",
"init_ipred(TX_32X32, 32, avx);",
"}",
"if (EXTERNAL_AVX2(cpu_flags)) {",
"init_fpel(1, 1, 32, avg, avx2);",
"init_fpel(0, 1, 64, avg, avx2);",
"if (ARCH_X86_64) {",
"#if ARCH_X86_64 && HAVE_AVX2_EXTERNAL\ninit_subpel2_32_64(0, 1, 1, hv, put, avx2);",
"init_subpel2_32_64(0, 0, 1, v, put, avx2);",
"init_subpel2_32_64(0, 1, 0, h, put, avx2);",
"init_subpel2_32_64(1, 1, 1, hv, avg, avx2);",
"init_subpel2_32_64(1, 0, 1, v, avg, avx2);",
"init_subpel2_32_64(1, 1, 0, h, avg, avx2);",
"#endif\n}",
"dsp->intra_pred[TX_32X32][DC_PRED] = ff_vp9_ipred_dc_32x32_avx2;",
"dsp->intra_pred[TX_32X32][LEFT_DC_PRED] = ff_vp9_ipred_dc_left_32x32_avx2;",
"dsp->intra_pred[TX_32X32][TOP_DC_PRED] = ff_vp9_ipred_dc_top_32x32_avx2;",
"dsp->intra_pred[TX_32X32][VERT_PRED] = ff_vp9_ipred_v_32x32_avx2;",
"dsp->intra_pred[TX_32X32][HOR_PRED] = ff_vp9_ipred_h_32x32_avx2;",
"dsp->intra_pred[TX_32X32][TM_VP8_PRED] = ff_vp9_ipred_tm_32x32_avx2;",
"}",
"#undef init_fpel\n#undef init_subpel1\n#undef init_subpel2\n#undef init_subpel3\n#endif\n}"
] |
[
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5,
7
],
[
11,
13,
15,
17,
19,
23,
25
],
[
27
],
[
29,
33,
35
],
[
37,
41,
43
],
[
45
],
[
47
],
[
49,
53,
55
],
[
57
],
[
59,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137,
139,
141,
143
],
[
145
],
[
147
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207,
209,
211,
213
],
[
215
],
[
217
],
[
219
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253,
255,
257,
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293,
295,
297,
299
],
[
301
],
[
303
],
[
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
317
],
[
319
],
[
321
],
[
323
],
[
325,
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339,
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
359,
361,
363,
365,
369,
371
]
] |
7,058 |
static void tracked_request_end(BdrvTrackedRequest *req)
{
QLIST_REMOVE(req, list);
}
| true |
qemu
|
f4658285f99473367dbbc34ce6970ec4637c2388
|
static void tracked_request_end(BdrvTrackedRequest *req)
{
QLIST_REMOVE(req, list);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(BdrvTrackedRequest *VAR_0)
{
QLIST_REMOVE(VAR_0, list);
}
|
[
"static void FUNC_0(BdrvTrackedRequest *VAR_0)\n{",
"QLIST_REMOVE(VAR_0, list);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
8
]
] |
7,060 |
static TranslationBlock *tb_alloc(target_ulong pc)
{
TranslationBlock *tb;
if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
tcg_ctx.code_gen_buffer_max_size) {
return NULL;
}
tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
tb->pc = pc;
tb->cflags = 0;
return tb;
}
| true |
qemu
|
b125f9dc7bd68cd4c57189db4da83b0620b28a72
|
static TranslationBlock *tb_alloc(target_ulong pc)
{
TranslationBlock *tb;
if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
tcg_ctx.code_gen_buffer_max_size) {
return NULL;
}
tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
tb->pc = pc;
tb->cflags = 0;
return tb;
}
|
{
"code": [
" if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||",
" (tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=",
" tcg_ctx.code_gen_buffer_max_size) {"
],
"line_no": [
9,
11,
13
]
}
|
static TranslationBlock *FUNC_0(target_ulong pc)
{
TranslationBlock *tb;
if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
tcg_ctx.code_gen_buffer_max_size) {
return NULL;
}
tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
tb->pc = pc;
tb->cflags = 0;
return tb;
}
|
[
"static TranslationBlock *FUNC_0(target_ulong pc)\n{",
"TranslationBlock *tb;",
"if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||\n(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=\ntcg_ctx.code_gen_buffer_max_size) {",
"return NULL;",
"}",
"tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];",
"tb->pc = pc;",
"tb->cflags = 0;",
"return tb;",
"}"
] |
[
0,
0,
1,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
]
] |
7,061 |
static void mxf_write_partition(AVFormatContext *s, int bodysid,
int indexsid,
const uint8_t *key, int write_metadata)
{
MXFContext *mxf = s->priv_data;
AVIOContext *pb = s->pb;
int64_t header_byte_count_offset;
unsigned index_byte_count = 0;
uint64_t partition_offset = avio_tell(pb);
if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
12+mxf->edit_units_count*(11+mxf->slice_count*4);
else if (mxf->edit_unit_byte_count && indexsid)
index_byte_count = 80;
if (index_byte_count) {
// add encoded ber length
index_byte_count += 16 + klv_ber_length(index_byte_count);
index_byte_count += klv_fill_size(index_byte_count);
}
if (!memcmp(key, body_partition_key, 16)) {
mxf->body_partition_offset =
av_realloc(mxf->body_partition_offset,
(mxf->body_partitions_count+1)*
sizeof(*mxf->body_partition_offset));
mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
}
// write klv
avio_write(pb, key, 16);
klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
// write partition value
avio_wb16(pb, 1); // majorVersion
avio_wb16(pb, 2); // minorVersion
avio_wb32(pb, KAG_SIZE); // KAGSize
avio_wb64(pb, partition_offset); // ThisPartition
if (!memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
else if (!memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
else
avio_wb64(pb, 0);
avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
// set offset
header_byte_count_offset = avio_tell(pb);
avio_wb64(pb, 0); // headerByteCount, update later
// indexTable
avio_wb64(pb, index_byte_count); // indexByteCount
avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
// BodyOffset
if (bodysid && mxf->edit_units_count && mxf->body_partitions_count) {
avio_wb64(pb, mxf->body_offset);
} else
avio_wb64(pb, 0);
avio_wb32(pb, bodysid); // bodySID
// operational pattern
avio_write(pb, op1a_ul, 16);
// essence container
mxf_write_essence_container_refs(s);
if (write_metadata) {
// mark the start of the headermetadata and calculate metadata size
int64_t pos, start;
unsigned header_byte_count;
mxf_write_klv_fill(s);
start = avio_tell(s->pb);
mxf_write_primer_pack(s);
mxf_write_header_metadata_sets(s);
pos = avio_tell(s->pb);
header_byte_count = pos - start + klv_fill_size(pos);
// update header_byte_count
avio_seek(pb, header_byte_count_offset, SEEK_SET);
avio_wb64(pb, header_byte_count);
avio_seek(pb, pos, SEEK_SET);
}
avio_flush(pb);
}
| true |
FFmpeg
|
e3ba817b95bbdc7c8aaf83b4a6804d1b49eb4de4
|
static void mxf_write_partition(AVFormatContext *s, int bodysid,
int indexsid,
const uint8_t *key, int write_metadata)
{
MXFContext *mxf = s->priv_data;
AVIOContext *pb = s->pb;
int64_t header_byte_count_offset;
unsigned index_byte_count = 0;
uint64_t partition_offset = avio_tell(pb);
if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
12+mxf->edit_units_count*(11+mxf->slice_count*4);
else if (mxf->edit_unit_byte_count && indexsid)
index_byte_count = 80;
if (index_byte_count) {
index_byte_count += 16 + klv_ber_length(index_byte_count);
index_byte_count += klv_fill_size(index_byte_count);
}
if (!memcmp(key, body_partition_key, 16)) {
mxf->body_partition_offset =
av_realloc(mxf->body_partition_offset,
(mxf->body_partitions_count+1)*
sizeof(*mxf->body_partition_offset));
mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
}
avio_write(pb, key, 16);
klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
avio_wb16(pb, 1);
avio_wb16(pb, 2);
avio_wb32(pb, KAG_SIZE);
avio_wb64(pb, partition_offset);
if (!memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]);
else if (!memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]);
else
avio_wb64(pb, 0);
avio_wb64(pb, mxf->footer_partition_offset);
header_byte_count_offset = avio_tell(pb);
avio_wb64(pb, 0);
avio_wb64(pb, index_byte_count);
avio_wb32(pb, index_byte_count ? indexsid : 0);
if (bodysid && mxf->edit_units_count && mxf->body_partitions_count) {
avio_wb64(pb, mxf->body_offset);
} else
avio_wb64(pb, 0);
avio_wb32(pb, bodysid);
avio_write(pb, op1a_ul, 16);
mxf_write_essence_container_refs(s);
if (write_metadata) {
int64_t pos, start;
unsigned header_byte_count;
mxf_write_klv_fill(s);
start = avio_tell(s->pb);
mxf_write_primer_pack(s);
mxf_write_header_metadata_sets(s);
pos = avio_tell(s->pb);
header_byte_count = pos - start + klv_fill_size(pos);
avio_seek(pb, header_byte_count_offset, SEEK_SET);
avio_wb64(pb, header_byte_count);
avio_seek(pb, pos, SEEK_SET);
}
avio_flush(pb);
}
|
{
"code": [
" klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);"
],
"line_no": [
65
]
}
|
static void FUNC_0(AVFormatContext *VAR_0, int VAR_1,
int VAR_2,
const uint8_t *VAR_3, int VAR_4)
{
MXFContext *mxf = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
int64_t header_byte_count_offset;
unsigned VAR_5 = 0;
uint64_t partition_offset = avio_tell(pb);
if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
VAR_5 = 85 + 12+(VAR_0->nb_streams+1)*6 +
12+mxf->edit_units_count*(11+mxf->slice_count*4);
else if (mxf->edit_unit_byte_count && VAR_2)
VAR_5 = 80;
if (VAR_5) {
VAR_5 += 16 + klv_ber_length(VAR_5);
VAR_5 += klv_fill_size(VAR_5);
}
if (!memcmp(VAR_3, body_partition_key, 16)) {
mxf->body_partition_offset =
av_realloc(mxf->body_partition_offset,
(mxf->body_partitions_count+1)*
sizeof(*mxf->body_partition_offset));
mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
}
avio_write(pb, VAR_3, 16);
klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
avio_wb16(pb, 1);
avio_wb16(pb, 2);
avio_wb32(pb, KAG_SIZE);
avio_wb64(pb, partition_offset);
if (!memcmp(VAR_3, body_partition_key, 16) && mxf->body_partitions_count > 1)
avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]);
else if (!memcmp(VAR_3, footer_partition_key, 16) && mxf->body_partitions_count)
avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]);
else
avio_wb64(pb, 0);
avio_wb64(pb, mxf->footer_partition_offset);
header_byte_count_offset = avio_tell(pb);
avio_wb64(pb, 0);
avio_wb64(pb, VAR_5);
avio_wb32(pb, VAR_5 ? VAR_2 : 0);
if (VAR_1 && mxf->edit_units_count && mxf->body_partitions_count) {
avio_wb64(pb, mxf->body_offset);
} else
avio_wb64(pb, 0);
avio_wb32(pb, VAR_1);
avio_write(pb, op1a_ul, 16);
mxf_write_essence_container_refs(VAR_0);
if (VAR_4) {
int64_t pos, start;
unsigned VAR_6;
mxf_write_klv_fill(VAR_0);
start = avio_tell(VAR_0->pb);
mxf_write_primer_pack(VAR_0);
mxf_write_header_metadata_sets(VAR_0);
pos = avio_tell(VAR_0->pb);
VAR_6 = pos - start + klv_fill_size(pos);
avio_seek(pb, header_byte_count_offset, SEEK_SET);
avio_wb64(pb, VAR_6);
avio_seek(pb, pos, SEEK_SET);
}
avio_flush(pb);
}
|
[
"static void FUNC_0(AVFormatContext *VAR_0, int VAR_1,\nint VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{",
"MXFContext *mxf = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"int64_t header_byte_count_offset;",
"unsigned VAR_5 = 0;",
"uint64_t partition_offset = avio_tell(pb);",
"if (!mxf->edit_unit_byte_count && mxf->edit_units_count)\nVAR_5 = 85 + 12+(VAR_0->nb_streams+1)*6 +\n12+mxf->edit_units_count*(11+mxf->slice_count*4);",
"else if (mxf->edit_unit_byte_count && VAR_2)\nVAR_5 = 80;",
"if (VAR_5) {",
"VAR_5 += 16 + klv_ber_length(VAR_5);",
"VAR_5 += klv_fill_size(VAR_5);",
"}",
"if (!memcmp(VAR_3, body_partition_key, 16)) {",
"mxf->body_partition_offset =\nav_realloc(mxf->body_partition_offset,\n(mxf->body_partitions_count+1)*\nsizeof(*mxf->body_partition_offset));",
"mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;",
"}",
"avio_write(pb, VAR_3, 16);",
"klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);",
"avio_wb16(pb, 1);",
"avio_wb16(pb, 2);",
"avio_wb32(pb, KAG_SIZE);",
"avio_wb64(pb, partition_offset);",
"if (!memcmp(VAR_3, body_partition_key, 16) && mxf->body_partitions_count > 1)\navio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]);",
"else if (!memcmp(VAR_3, footer_partition_key, 16) && mxf->body_partitions_count)\navio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]);",
"else\navio_wb64(pb, 0);",
"avio_wb64(pb, mxf->footer_partition_offset);",
"header_byte_count_offset = avio_tell(pb);",
"avio_wb64(pb, 0);",
"avio_wb64(pb, VAR_5);",
"avio_wb32(pb, VAR_5 ? VAR_2 : 0);",
"if (VAR_1 && mxf->edit_units_count && mxf->body_partitions_count) {",
"avio_wb64(pb, mxf->body_offset);",
"} else",
"avio_wb64(pb, 0);",
"avio_wb32(pb, VAR_1);",
"avio_write(pb, op1a_ul, 16);",
"mxf_write_essence_container_refs(VAR_0);",
"if (VAR_4) {",
"int64_t pos, start;",
"unsigned VAR_6;",
"mxf_write_klv_fill(VAR_0);",
"start = avio_tell(VAR_0->pb);",
"mxf_write_primer_pack(VAR_0);",
"mxf_write_header_metadata_sets(VAR_0);",
"pos = avio_tell(VAR_0->pb);",
"VAR_6 = pos - start + klv_fill_size(pos);",
"avio_seek(pb, header_byte_count_offset, SEEK_SET);",
"avio_wb64(pb, VAR_6);",
"avio_seek(pb, pos, SEEK_SET);",
"}",
"avio_flush(pb);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21,
23,
25
],
[
27,
29
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47,
49,
51,
53
],
[
55
],
[
57
],
[
63
],
[
65
],
[
71
],
[
73
],
[
75
],
[
79
],
[
83,
85
],
[
87,
89
],
[
91,
93
],
[
97
],
[
103
],
[
105
],
[
111
],
[
113
],
[
119
],
[
121
],
[
123
],
[
125
],
[
129
],
[
135
],
[
141
],
[
145
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
171
],
[
173
],
[
175
],
[
177
],
[
181
],
[
183
]
] |
7,062 |
static inline void RENAME(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
long width, long height,
long lumStride, long chromStride, long dstStride, long vertLumPerChroma)
{
long y;
const long chromWidth= width>>1;
for(y=0; y<height; y++)
{
#ifdef HAVE_MMX
//FIXME handle 2 lines a once (fewer prefetch, reuse some chrom, but very likely limited by mem anyway)
asm volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
ASMALIGN16
"1: \n\t"
PREFETCH" 32(%1, %%"REG_a", 2) \n\t"
PREFETCH" 32(%2, %%"REG_a") \n\t"
PREFETCH" 32(%3, %%"REG_a") \n\t"
"movq (%2, %%"REG_a"), %%mm0 \n\t" // U(0)
"movq %%mm0, %%mm2 \n\t" // U(0)
"movq (%3, %%"REG_a"), %%mm1 \n\t" // V(0)
"punpcklbw %%mm1, %%mm0 \n\t" // UVUV UVUV(0)
"punpckhbw %%mm1, %%mm2 \n\t" // UVUV UVUV(8)
"movq (%1, %%"REG_a",2), %%mm3 \n\t" // Y(0)
"movq 8(%1, %%"REG_a",2), %%mm5 \n\t" // Y(8)
"movq %%mm0, %%mm4 \n\t" // Y(0)
"movq %%mm2, %%mm6 \n\t" // Y(8)
"punpcklbw %%mm3, %%mm0 \n\t" // YUYV YUYV(0)
"punpckhbw %%mm3, %%mm4 \n\t" // YUYV YUYV(4)
"punpcklbw %%mm5, %%mm2 \n\t" // YUYV YUYV(8)
"punpckhbw %%mm5, %%mm6 \n\t" // YUYV YUYV(12)
MOVNTQ" %%mm0, (%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm4, 8(%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm2, 16(%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm6, 24(%0, %%"REG_a", 4)\n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)
: "%"REG_a
);
#else
//FIXME adapt the alpha asm code from yv12->yuy2
#if __WORDSIZE >= 64
int i;
uint64_t *ldst = (uint64_t *) dst;
const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
for(i = 0; i < chromWidth; i += 2){
uint64_t k, l;
k = uc[0] + (yc[0] << 8) +
(vc[0] << 16) + (yc[1] << 24);
l = uc[1] + (yc[2] << 8) +
(vc[1] << 16) + (yc[3] << 24);
*ldst++ = k + (l << 32);
yc += 4;
uc += 2;
vc += 2;
}
#else
int i, *idst = (int32_t *) dst;
const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
for(i = 0; i < chromWidth; i++){
#ifdef WORDS_BIGENDIAN
*idst++ = (uc[0] << 24)+ (yc[0] << 16) +
(vc[0] << 8) + (yc[1] << 0);
#else
*idst++ = uc[0] + (yc[0] << 8) +
(vc[0] << 16) + (yc[1] << 24);
#endif
yc += 2;
uc++;
vc++;
}
#endif
#endif
if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
{
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
#ifdef HAVE_MMX
asm( EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
#endif
}
| false |
FFmpeg
|
4bff9ef9d0781c4de228bf1f85634d2706fc589b
|
static inline void RENAME(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
long width, long height,
long lumStride, long chromStride, long dstStride, long vertLumPerChroma)
{
long y;
const long chromWidth= width>>1;
for(y=0; y<height; y++)
{
#ifdef HAVE_MMX
asm volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
ASMALIGN16
"1: \n\t"
PREFETCH" 32(%1, %%"REG_a", 2) \n\t"
PREFETCH" 32(%2, %%"REG_a") \n\t"
PREFETCH" 32(%3, %%"REG_a") \n\t"
"movq (%2, %%"REG_a"), %%mm0 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq (%3, %%"REG_a"), %%mm1 \n\t"
"punpcklbw %%mm1, %%mm0 \n\t"
"punpckhbw %%mm1, %%mm2 \n\t"
"movq (%1, %%"REG_a",2), %%mm3 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm5 \n\t"
"movq %%mm0, %%mm4 \n\t"
"movq %%mm2, %%mm6 \n\t"
"punpcklbw %%mm3, %%mm0 \n\t"
"punpckhbw %%mm3, %%mm4 \n\t"
"punpcklbw %%mm5, %%mm2 \n\t"
"punpckhbw %%mm5, %%mm6 \n\t"
MOVNTQ" %%mm0, (%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm4, 8(%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm2, 16(%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm6, 24(%0, %%"REG_a", 4)\n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)
: "%"REG_a
);
#else
#if __WORDSIZE >= 64
int i;
uint64_t *ldst = (uint64_t *) dst;
const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
for(i = 0; i < chromWidth; i += 2){
uint64_t k, l;
k = uc[0] + (yc[0] << 8) +
(vc[0] << 16) + (yc[1] << 24);
l = uc[1] + (yc[2] << 8) +
(vc[1] << 16) + (yc[3] << 24);
*ldst++ = k + (l << 32);
yc += 4;
uc += 2;
vc += 2;
}
#else
int i, *idst = (int32_t *) dst;
const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
for(i = 0; i < chromWidth; i++){
#ifdef WORDS_BIGENDIAN
*idst++ = (uc[0] << 24)+ (yc[0] << 16) +
(vc[0] << 8) + (yc[1] << 0);
#else
*idst++ = uc[0] + (yc[0] << 8) +
(vc[0] << 16) + (yc[1] << 24);
#endif
yc += 2;
uc++;
vc++;
}
#endif
#endif
if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
{
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
#ifdef HAVE_MMX
asm( EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
#endif
}
|
{
"code": [],
"line_no": []
}
|
static inline void FUNC_0(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
long width, long height,
long lumStride, long chromStride, long dstStride, long vertLumPerChroma)
{
long VAR_0;
const long VAR_1= width>>1;
for(VAR_0=0; VAR_0<height; VAR_0++)
{
#ifdef HAVE_MMX
asm volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
ASMALIGN16
"1: \n\t"
PREFETCH" 32(%1, %%"REG_a", 2) \n\t"
PREFETCH" 32(%2, %%"REG_a") \n\t"
PREFETCH" 32(%3, %%"REG_a") \n\t"
"movq (%2, %%"REG_a"), %%mm0 \n\t"
"movq %%mm0, %%mm2 \n\t"
"movq (%3, %%"REG_a"), %%mm1 \n\t"
"punpcklbw %%mm1, %%mm0 \n\t"
"punpckhbw %%mm1, %%mm2 \n\t"
"movq (%1, %%"REG_a",2), %%mm3 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm5 \n\t"
"movq %%mm0, %%mm4 \n\t"
"movq %%mm2, %%mm6 \n\t"
"punpcklbw %%mm3, %%mm0 \n\t"
"punpckhbw %%mm3, %%mm4 \n\t"
"punpcklbw %%mm5, %%mm2 \n\t"
"punpckhbw %%mm5, %%mm6 \n\t"
MOVNTQ" %%mm0, (%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm4, 8(%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm2, 16(%0, %%"REG_a", 4)\n\t"
MOVNTQ" %%mm6, 24(%0, %%"REG_a", 4)\n\t"
"add $8, %%"REG_a" \n\t"
"cmp %4, %%"REG_a" \n\t"
" jb 1b \n\t"
::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (VAR_1)
: "%"REG_a
);
#else
#if __WORDSIZE >= 64
int i;
uint64_t *ldst = (uint64_t *) dst;
const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
for(i = 0; i < VAR_1; i += 2){
uint64_t k, l;
k = uc[0] + (yc[0] << 8) +
(vc[0] << 16) + (yc[1] << 24);
l = uc[1] + (yc[2] << 8) +
(vc[1] << 16) + (yc[3] << 24);
*ldst++ = k + (l << 32);
yc += 4;
uc += 2;
vc += 2;
}
#else
int i, *idst = (int32_t *) dst;
const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
for(i = 0; i < VAR_1; i++){
#ifdef WORDS_BIGENDIAN
*idst++ = (uc[0] << 24)+ (yc[0] << 16) +
(vc[0] << 8) + (yc[1] << 0);
#else
*idst++ = uc[0] + (yc[0] << 8) +
(vc[0] << 16) + (yc[1] << 24);
#endif
yc += 2;
uc++;
vc++;
}
#endif
#endif
if((VAR_0&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
{
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
#ifdef HAVE_MMX
asm( EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
#endif
}
|
[
"static inline void FUNC_0(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,\nlong width, long height,\nlong lumStride, long chromStride, long dstStride, long vertLumPerChroma)\n{",
"long VAR_0;",
"const long VAR_1= width>>1;",
"for(VAR_0=0; VAR_0<height; VAR_0++)",
"{",
"#ifdef HAVE_MMX\nasm volatile(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\nASMALIGN16\n\"1:\t\t\t\t\\n\\t\"\nPREFETCH\" 32(%1, %%\"REG_a\", 2)\t\\n\\t\"\nPREFETCH\" 32(%2, %%\"REG_a\")\t\\n\\t\"\nPREFETCH\" 32(%3, %%\"REG_a\")\t\\n\\t\"\n\"movq (%2, %%\"REG_a\"), %%mm0\t\\n\\t\"\n\"movq %%mm0, %%mm2\t\t\\n\\t\"\n\"movq (%3, %%\"REG_a\"), %%mm1\t\\n\\t\"\n\"punpcklbw %%mm1, %%mm0\t\t\\n\\t\"\n\"punpckhbw %%mm1, %%mm2\t\t\\n\\t\"\n\"movq (%1, %%\"REG_a\",2), %%mm3\t\\n\\t\"\n\"movq 8(%1, %%\"REG_a\",2), %%mm5\t\\n\\t\"\n\"movq %%mm0, %%mm4\t\t\\n\\t\"\n\"movq %%mm2, %%mm6\t\t\\n\\t\"\n\"punpcklbw %%mm3, %%mm0\t\t\\n\\t\"\n\"punpckhbw %%mm3, %%mm4\t\t\\n\\t\"\n\"punpcklbw %%mm5, %%mm2\t\t\\n\\t\"\n\"punpckhbw %%mm5, %%mm6\t\t\\n\\t\"\nMOVNTQ\" %%mm0, (%0, %%\"REG_a\", 4)\\n\\t\"\nMOVNTQ\" %%mm4, 8(%0, %%\"REG_a\", 4)\\n\\t\"\nMOVNTQ\" %%mm2, 16(%0, %%\"REG_a\", 4)\\n\\t\"\nMOVNTQ\" %%mm6, 24(%0, %%\"REG_a\", 4)\\n\\t\"\n\"add $8, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %4, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n::\"r\"(dst), \"r\"(ysrc), \"r\"(usrc), \"r\"(vsrc), \"g\" (VAR_1)\n: \"%\"REG_a\n);",
"#else\n#if __WORDSIZE >= 64\nint i;",
"uint64_t *ldst = (uint64_t *) dst;",
"const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;",
"for(i = 0; i < VAR_1; i += 2){",
"uint64_t k, l;",
"k = uc[0] + (yc[0] << 8) +\n(vc[0] << 16) + (yc[1] << 24);",
"l = uc[1] + (yc[2] << 8) +\n(vc[1] << 16) + (yc[3] << 24);",
"*ldst++ = k + (l << 32);",
"yc += 4;",
"uc += 2;",
"vc += 2;",
"}",
"#else\nint i, *idst = (int32_t *) dst;",
"const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;",
"for(i = 0; i < VAR_1; i++){",
"#ifdef WORDS_BIGENDIAN\n*idst++ = (uc[0] << 24)+ (yc[0] << 16) +\n(vc[0] << 8) + (yc[1] << 0);",
"#else\n*idst++ = uc[0] + (yc[0] << 8) +\n(vc[0] << 16) + (yc[1] << 24);",
"#endif\nyc += 2;",
"uc++;",
"vc++;",
"}",
"#endif\n#endif\nif((VAR_0&(vertLumPerChroma-1))==(vertLumPerChroma-1) )\n{",
"usrc += chromStride;",
"vsrc += chromStride;",
"}",
"ysrc += lumStride;",
"dst += dstStride;",
"}",
"#ifdef HAVE_MMX\nasm( EMMS\" \\n\\t\"\nSFENCE\" \\n\\t\"\n:::\"memory\");",
"#endif\n}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17,
21,
23,
25,
27,
29,
31,
33,
35,
37,
39,
41,
43,
47,
49,
51,
53,
55,
57,
59,
61,
65,
67,
69,
71,
75,
77,
79,
81,
83,
85
],
[
87,
93,
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
109,
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125,
127
],
[
129
],
[
131
],
[
133,
135,
137
],
[
139,
141,
143
],
[
145,
147
],
[
149
],
[
151
],
[
153
],
[
155,
157,
159,
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175,
177,
179,
181
],
[
183,
185
]
] |
7,063 |
static void decodeplane32(uint32_t *dst, const uint8_t *const buf, int buf_size, int bps, int plane)
{
GetBitContext gb;
int i, b;
init_get_bits(&gb, buf, buf_size * 8);
for(i = 0; i < (buf_size * 8 + bps - 1) / bps; i++) {
for (b = 0; b < bps; b++) {
dst[ i*bps + b ] |= get_bits1(&gb) << plane;
}
}
}
| false |
FFmpeg
|
473147bed01c0c6c82d85fd79d3e1c1d65542663
|
static void decodeplane32(uint32_t *dst, const uint8_t *const buf, int buf_size, int bps, int plane)
{
GetBitContext gb;
int i, b;
init_get_bits(&gb, buf, buf_size * 8);
for(i = 0; i < (buf_size * 8 + bps - 1) / bps; i++) {
for (b = 0; b < bps; b++) {
dst[ i*bps + b ] |= get_bits1(&gb) << plane;
}
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(uint32_t *VAR_0, const uint8_t *const VAR_1, int VAR_2, int VAR_3, int VAR_4)
{
GetBitContext gb;
int VAR_5, VAR_6;
init_get_bits(&gb, VAR_1, VAR_2 * 8);
for(VAR_5 = 0; VAR_5 < (VAR_2 * 8 + VAR_3 - 1) / VAR_3; VAR_5++) {
for (VAR_6 = 0; VAR_6 < VAR_3; VAR_6++) {
VAR_0[ VAR_5*VAR_3 + VAR_6 ] |= get_bits1(&gb) << VAR_4;
}
}
}
|
[
"static void FUNC_0(uint32_t *VAR_0, const uint8_t *const VAR_1, int VAR_2, int VAR_3, int VAR_4)\n{",
"GetBitContext gb;",
"int VAR_5, VAR_6;",
"init_get_bits(&gb, VAR_1, VAR_2 * 8);",
"for(VAR_5 = 0; VAR_5 < (VAR_2 * 8 + VAR_3 - 1) / VAR_3; VAR_5++) {",
"for (VAR_6 = 0; VAR_6 < VAR_3; VAR_6++) {",
"VAR_0[ VAR_5*VAR_3 + VAR_6 ] |= get_bits1(&gb) << VAR_4;",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
7,064 |
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
{
SWFContext *swf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *vst = NULL, *ast = NULL, *st = 0;
int tag, len, i, frame, v;
for(;;) {
uint64_t pos = avio_tell(pb);
tag = get_swf_tag(pb, &len);
if (tag < 0)
return AVERROR(EIO);
if (tag == TAG_VIDEOSTREAM) {
int ch_id = avio_rl16(pb);
len -= 2;
for (i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
goto skip;
}
avio_rl16(pb);
avio_rl16(pb);
avio_rl16(pb);
avio_r8(pb);
/* Check for FLV1 */
vst = av_new_stream(s, ch_id);
if (!vst)
return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
av_set_pts_info(vst, 16, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
len -= 8;
} else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
/* streaming found */
int sample_rate_code;
for (i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
goto skip;
}
avio_r8(pb);
v = avio_r8(pb);
swf->samples_per_frame = avio_rl16(pb);
ast = av_new_stream(s, -1); /* -1 to avoid clash with video stream ch_id */
if (!ast)
return -1;
ast->codec->channels = 1 + (v&1);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = ff_codec_get_id(swf_audio_codec_tags, (v>>4) & 15);
ast->need_parsing = AVSTREAM_PARSE_FULL;
sample_rate_code= (v>>2) & 3;
if (!sample_rate_code)
return AVERROR(EIO);
ast->codec->sample_rate = 11025 << (sample_rate_code-1);
av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
len -= 4;
} else if (tag == TAG_VIDEOFRAME) {
int ch_id = avio_rl16(pb);
len -= 2;
for(i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
frame = avio_rl16(pb);
av_get_packet(pb, pkt, len-2);
pkt->pos = pos;
pkt->pts = frame;
pkt->stream_index = st->index;
return pkt->size;
}
}
} else if (tag == TAG_STREAMBLOCK) {
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
if (st->codec->codec_id == CODEC_ID_MP3) {
avio_skip(pb, 4);
av_get_packet(pb, pkt, len-4);
} else { // ADPCM, PCM
av_get_packet(pb, pkt, len);
}
pkt->pos = pos;
pkt->stream_index = st->index;
return pkt->size;
}
}
} else if (tag == TAG_JPEG2) {
for (i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_id == CODEC_ID_MJPEG && st->id == -2)
break;
}
if (i == s->nb_streams) {
vst = av_new_stream(s, -2); /* -2 to avoid clash with video stream and audio stream */
if (!vst)
return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_MJPEG;
av_set_pts_info(vst, 64, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
st = vst;
}
avio_rl16(pb); /* BITMAP_ID */
av_new_packet(pkt, len-2);
avio_read(pb, pkt->data, 4);
if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
AV_RB32(pkt->data) == 0xffd9ffd8) {
/* old SWF files containing SOI/EOI as data start */
/* files created by swink have reversed tag */
pkt->size -= 4;
avio_read(pb, pkt->data, pkt->size);
} else {
avio_read(pb, pkt->data + 4, pkt->size - 4);
}
pkt->pos = pos;
pkt->stream_index = st->index;
return pkt->size;
}
skip:
avio_skip(pb, len);
}
return 0;
}
| false |
FFmpeg
|
add41decd94b2d3581a3715ba10f27168b8cdb1b
|
static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
{
SWFContext *swf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *vst = NULL, *ast = NULL, *st = 0;
int tag, len, i, frame, v;
for(;;) {
uint64_t pos = avio_tell(pb);
tag = get_swf_tag(pb, &len);
if (tag < 0)
return AVERROR(EIO);
if (tag == TAG_VIDEOSTREAM) {
int ch_id = avio_rl16(pb);
len -= 2;
for (i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id)
goto skip;
}
avio_rl16(pb);
avio_rl16(pb);
avio_rl16(pb);
avio_r8(pb);
vst = av_new_stream(s, ch_id);
if (!vst)
return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
av_set_pts_info(vst, 16, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
len -= 8;
} else if (tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2) {
int sample_rate_code;
for (i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
goto skip;
}
avio_r8(pb);
v = avio_r8(pb);
swf->samples_per_frame = avio_rl16(pb);
ast = av_new_stream(s, -1);
if (!ast)
return -1;
ast->codec->channels = 1 + (v&1);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = ff_codec_get_id(swf_audio_codec_tags, (v>>4) & 15);
ast->need_parsing = AVSTREAM_PARSE_FULL;
sample_rate_code= (v>>2) & 3;
if (!sample_rate_code)
return AVERROR(EIO);
ast->codec->sample_rate = 11025 << (sample_rate_code-1);
av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
len -= 4;
} else if (tag == TAG_VIDEOFRAME) {
int ch_id = avio_rl16(pb);
len -= 2;
for(i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == ch_id) {
frame = avio_rl16(pb);
av_get_packet(pb, pkt, len-2);
pkt->pos = pos;
pkt->pts = frame;
pkt->stream_index = st->index;
return pkt->size;
}
}
} else if (tag == TAG_STREAMBLOCK) {
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
if (st->codec->codec_id == CODEC_ID_MP3) {
avio_skip(pb, 4);
av_get_packet(pb, pkt, len-4);
} else {
av_get_packet(pb, pkt, len);
}
pkt->pos = pos;
pkt->stream_index = st->index;
return pkt->size;
}
}
} else if (tag == TAG_JPEG2) {
for (i=0; i<s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_id == CODEC_ID_MJPEG && st->id == -2)
break;
}
if (i == s->nb_streams) {
vst = av_new_stream(s, -2);
if (!vst)
return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_MJPEG;
av_set_pts_info(vst, 64, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
st = vst;
}
avio_rl16(pb);
av_new_packet(pkt, len-2);
avio_read(pb, pkt->data, 4);
if (AV_RB32(pkt->data) == 0xffd8ffd9 ||
AV_RB32(pkt->data) == 0xffd9ffd8) {
pkt->size -= 4;
avio_read(pb, pkt->data, pkt->size);
} else {
avio_read(pb, pkt->data + 4, pkt->size - 4);
}
pkt->pos = pos;
pkt->stream_index = st->index;
return pkt->size;
}
skip:
avio_skip(pb, len);
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
SWFContext *swf = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
AVStream *vst = NULL, *ast = NULL, *st = 0;
int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6;
for(;;) {
uint64_t pos = avio_tell(pb);
VAR_2 = get_swf_tag(pb, &VAR_3);
if (VAR_2 < 0)
return AVERROR(EIO);
if (VAR_2 == TAG_VIDEOSTREAM) {
int VAR_9 = avio_rl16(pb);
VAR_3 -= 2;
for (VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {
st = VAR_0->streams[VAR_4];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == VAR_9)
goto skip;
}
avio_rl16(pb);
avio_rl16(pb);
avio_rl16(pb);
avio_r8(pb);
vst = av_new_stream(VAR_0, VAR_9);
if (!vst)
return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));
av_set_pts_info(vst, 16, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
VAR_3 -= 8;
} else if (VAR_2 == TAG_STREAMHEAD || VAR_2 == TAG_STREAMHEAD2) {
int VAR_8;
for (VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {
st = VAR_0->streams[VAR_4];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)
goto skip;
}
avio_r8(pb);
VAR_6 = avio_r8(pb);
swf->samples_per_frame = avio_rl16(pb);
ast = av_new_stream(VAR_0, -1);
if (!ast)
return -1;
ast->codec->channels = 1 + (VAR_6&1);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = ff_codec_get_id(swf_audio_codec_tags, (VAR_6>>4) & 15);
ast->need_parsing = AVSTREAM_PARSE_FULL;
VAR_8= (VAR_6>>2) & 3;
if (!VAR_8)
return AVERROR(EIO);
ast->codec->sample_rate = 11025 << (VAR_8-1);
av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);
VAR_3 -= 4;
} else if (VAR_2 == TAG_VIDEOFRAME) {
int VAR_9 = avio_rl16(pb);
VAR_3 -= 2;
for(VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {
st = VAR_0->streams[VAR_4];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == VAR_9) {
VAR_5 = avio_rl16(pb);
av_get_packet(pb, VAR_1, VAR_3-2);
VAR_1->pos = pos;
VAR_1->pts = VAR_5;
VAR_1->stream_index = st->index;
return VAR_1->size;
}
}
} else if (VAR_2 == TAG_STREAMBLOCK) {
for (VAR_4 = 0; VAR_4 < VAR_0->nb_streams; VAR_4++) {
st = VAR_0->streams[VAR_4];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {
if (st->codec->codec_id == CODEC_ID_MP3) {
avio_skip(pb, 4);
av_get_packet(pb, VAR_1, VAR_3-4);
} else {
av_get_packet(pb, VAR_1, VAR_3);
}
VAR_1->pos = pos;
VAR_1->stream_index = st->index;
return VAR_1->size;
}
}
} else if (VAR_2 == TAG_JPEG2) {
for (VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {
st = VAR_0->streams[VAR_4];
if (st->codec->codec_id == CODEC_ID_MJPEG && st->id == -2)
break;
}
if (VAR_4 == VAR_0->nb_streams) {
vst = av_new_stream(VAR_0, -2);
if (!vst)
return -1;
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_MJPEG;
av_set_pts_info(vst, 64, 256, swf->frame_rate);
vst->codec->time_base = (AVRational){ 256, swf->frame_rate };
st = vst;
}
avio_rl16(pb);
av_new_packet(VAR_1, VAR_3-2);
avio_read(pb, VAR_1->data, 4);
if (AV_RB32(VAR_1->data) == 0xffd8ffd9 ||
AV_RB32(VAR_1->data) == 0xffd9ffd8) {
VAR_1->size -= 4;
avio_read(pb, VAR_1->data, VAR_1->size);
} else {
avio_read(pb, VAR_1->data + 4, VAR_1->size - 4);
}
VAR_1->pos = pos;
VAR_1->stream_index = st->index;
return VAR_1->size;
}
skip:
avio_skip(pb, VAR_3);
}
return 0;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"SWFContext *swf = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"AVStream *vst = NULL, *ast = NULL, *st = 0;",
"int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6;",
"for(;;) {",
"uint64_t pos = avio_tell(pb);",
"VAR_2 = get_swf_tag(pb, &VAR_3);",
"if (VAR_2 < 0)\nreturn AVERROR(EIO);",
"if (VAR_2 == TAG_VIDEOSTREAM) {",
"int VAR_9 = avio_rl16(pb);",
"VAR_3 -= 2;",
"for (VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {",
"st = VAR_0->streams[VAR_4];",
"if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == VAR_9)\ngoto skip;",
"}",
"avio_rl16(pb);",
"avio_rl16(pb);",
"avio_rl16(pb);",
"avio_r8(pb);",
"vst = av_new_stream(VAR_0, VAR_9);",
"if (!vst)\nreturn -1;",
"vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"vst->codec->codec_id = ff_codec_get_id(swf_codec_tags, avio_r8(pb));",
"av_set_pts_info(vst, 16, 256, swf->frame_rate);",
"vst->codec->time_base = (AVRational){ 256, swf->frame_rate };",
"VAR_3 -= 8;",
"} else if (VAR_2 == TAG_STREAMHEAD || VAR_2 == TAG_STREAMHEAD2) {",
"int VAR_8;",
"for (VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {",
"st = VAR_0->streams[VAR_4];",
"if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1)\ngoto skip;",
"}",
"avio_r8(pb);",
"VAR_6 = avio_r8(pb);",
"swf->samples_per_frame = avio_rl16(pb);",
"ast = av_new_stream(VAR_0, -1);",
"if (!ast)\nreturn -1;",
"ast->codec->channels = 1 + (VAR_6&1);",
"ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;",
"ast->codec->codec_id = ff_codec_get_id(swf_audio_codec_tags, (VAR_6>>4) & 15);",
"ast->need_parsing = AVSTREAM_PARSE_FULL;",
"VAR_8= (VAR_6>>2) & 3;",
"if (!VAR_8)\nreturn AVERROR(EIO);",
"ast->codec->sample_rate = 11025 << (VAR_8-1);",
"av_set_pts_info(ast, 64, 1, ast->codec->sample_rate);",
"VAR_3 -= 4;",
"} else if (VAR_2 == TAG_VIDEOFRAME) {",
"int VAR_9 = avio_rl16(pb);",
"VAR_3 -= 2;",
"for(VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {",
"st = VAR_0->streams[VAR_4];",
"if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->id == VAR_9) {",
"VAR_5 = avio_rl16(pb);",
"av_get_packet(pb, VAR_1, VAR_3-2);",
"VAR_1->pos = pos;",
"VAR_1->pts = VAR_5;",
"VAR_1->stream_index = st->index;",
"return VAR_1->size;",
"}",
"}",
"} else if (VAR_2 == TAG_STREAMBLOCK) {",
"for (VAR_4 = 0; VAR_4 < VAR_0->nb_streams; VAR_4++) {",
"st = VAR_0->streams[VAR_4];",
"if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) {",
"if (st->codec->codec_id == CODEC_ID_MP3) {",
"avio_skip(pb, 4);",
"av_get_packet(pb, VAR_1, VAR_3-4);",
"} else {",
"av_get_packet(pb, VAR_1, VAR_3);",
"}",
"VAR_1->pos = pos;",
"VAR_1->stream_index = st->index;",
"return VAR_1->size;",
"}",
"}",
"} else if (VAR_2 == TAG_JPEG2) {",
"for (VAR_4=0; VAR_4<VAR_0->nb_streams; VAR_4++) {",
"st = VAR_0->streams[VAR_4];",
"if (st->codec->codec_id == CODEC_ID_MJPEG && st->id == -2)\nbreak;",
"}",
"if (VAR_4 == VAR_0->nb_streams) {",
"vst = av_new_stream(VAR_0, -2);",
"if (!vst)\nreturn -1;",
"vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"vst->codec->codec_id = CODEC_ID_MJPEG;",
"av_set_pts_info(vst, 64, 256, swf->frame_rate);",
"vst->codec->time_base = (AVRational){ 256, swf->frame_rate };",
"st = vst;",
"}",
"avio_rl16(pb);",
"av_new_packet(VAR_1, VAR_3-2);",
"avio_read(pb, VAR_1->data, 4);",
"if (AV_RB32(VAR_1->data) == 0xffd8ffd9 ||\nAV_RB32(VAR_1->data) == 0xffd9ffd8) {",
"VAR_1->size -= 4;",
"avio_read(pb, VAR_1->data, VAR_1->size);",
"} else {",
"avio_read(pb, VAR_1->data + 4, VAR_1->size - 4);",
"}",
"VAR_1->pos = pos;",
"VAR_1->stream_index = st->index;",
"return VAR_1->size;",
"}",
"skip:\navio_skip(pb, VAR_3);",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99,
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187,
189
],
[
191
],
[
193
],
[
195
],
[
197,
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219,
221
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245,
247
],
[
249
],
[
251
],
[
253
]
] |
7,065 |
void qxl_render_update(PCIQXLDevice *qxl)
{
VGACommonState *vga = &qxl->vga;
QXLRect dirty[32], update;
void *ptr;
int i;
if (qxl->guest_primary.resized) {
qxl->guest_primary.resized = 0;
if (qxl->guest_primary.flipped) {
g_free(qxl->guest_primary.flipped);
qxl->guest_primary.flipped = NULL;
}
qemu_free_displaysurface(vga->ds);
qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
if (qxl->guest_primary.stride < 0) {
/* spice surface is upside down -> need extra buffer to flip */
qxl->guest_primary.stride = -qxl->guest_primary.stride;
qxl->guest_primary.flipped = g_malloc(qxl->guest_primary.surface.width *
qxl->guest_primary.stride);
ptr = qxl->guest_primary.flipped;
} else {
ptr = qxl->guest_primary.data;
}
dprint(qxl, 1, "%s: %dx%d, stride %d, bpp %d, depth %d, flip %s\n",
__FUNCTION__,
qxl->guest_primary.surface.width,
qxl->guest_primary.surface.height,
qxl->guest_primary.stride,
qxl->guest_primary.bytes_pp,
qxl->guest_primary.bits_pp,
qxl->guest_primary.flipped ? "yes" : "no");
vga->ds->surface =
qemu_create_displaysurface_from(qxl->guest_primary.surface.width,
qxl->guest_primary.surface.height,
qxl->guest_primary.bits_pp,
qxl->guest_primary.stride,
ptr);
dpy_resize(vga->ds);
}
if (!qxl->guest_primary.commands) {
return;
}
qxl->guest_primary.commands = 0;
update.left = 0;
update.right = qxl->guest_primary.surface.width;
update.top = 0;
update.bottom = qxl->guest_primary.surface.height;
memset(dirty, 0, sizeof(dirty));
qxl_spice_update_area(qxl, 0, &update,
dirty, ARRAY_SIZE(dirty), 1, QXL_SYNC);
for (i = 0; i < ARRAY_SIZE(dirty); i++) {
if (qemu_spice_rect_is_empty(dirty+i)) {
break;
}
if (qxl->guest_primary.flipped) {
qxl_flip(qxl, dirty+i);
}
dpy_update(vga->ds,
dirty[i].left, dirty[i].top,
dirty[i].right - dirty[i].left,
dirty[i].bottom - dirty[i].top);
}
}
| false |
qemu
|
0e2487bd6f56445b43307536a465ee2ba810aed9
|
void qxl_render_update(PCIQXLDevice *qxl)
{
VGACommonState *vga = &qxl->vga;
QXLRect dirty[32], update;
void *ptr;
int i;
if (qxl->guest_primary.resized) {
qxl->guest_primary.resized = 0;
if (qxl->guest_primary.flipped) {
g_free(qxl->guest_primary.flipped);
qxl->guest_primary.flipped = NULL;
}
qemu_free_displaysurface(vga->ds);
qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
if (qxl->guest_primary.stride < 0) {
qxl->guest_primary.stride = -qxl->guest_primary.stride;
qxl->guest_primary.flipped = g_malloc(qxl->guest_primary.surface.width *
qxl->guest_primary.stride);
ptr = qxl->guest_primary.flipped;
} else {
ptr = qxl->guest_primary.data;
}
dprint(qxl, 1, "%s: %dx%d, stride %d, bpp %d, depth %d, flip %s\n",
__FUNCTION__,
qxl->guest_primary.surface.width,
qxl->guest_primary.surface.height,
qxl->guest_primary.stride,
qxl->guest_primary.bytes_pp,
qxl->guest_primary.bits_pp,
qxl->guest_primary.flipped ? "yes" : "no");
vga->ds->surface =
qemu_create_displaysurface_from(qxl->guest_primary.surface.width,
qxl->guest_primary.surface.height,
qxl->guest_primary.bits_pp,
qxl->guest_primary.stride,
ptr);
dpy_resize(vga->ds);
}
if (!qxl->guest_primary.commands) {
return;
}
qxl->guest_primary.commands = 0;
update.left = 0;
update.right = qxl->guest_primary.surface.width;
update.top = 0;
update.bottom = qxl->guest_primary.surface.height;
memset(dirty, 0, sizeof(dirty));
qxl_spice_update_area(qxl, 0, &update,
dirty, ARRAY_SIZE(dirty), 1, QXL_SYNC);
for (i = 0; i < ARRAY_SIZE(dirty); i++) {
if (qemu_spice_rect_is_empty(dirty+i)) {
break;
}
if (qxl->guest_primary.flipped) {
qxl_flip(qxl, dirty+i);
}
dpy_update(vga->ds,
dirty[i].left, dirty[i].top,
dirty[i].right - dirty[i].left,
dirty[i].bottom - dirty[i].top);
}
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(PCIQXLDevice *VAR_0)
{
VGACommonState *vga = &VAR_0->vga;
QXLRect dirty[32], update;
void *VAR_1;
int VAR_2;
if (VAR_0->guest_primary.resized) {
VAR_0->guest_primary.resized = 0;
if (VAR_0->guest_primary.flipped) {
g_free(VAR_0->guest_primary.flipped);
VAR_0->guest_primary.flipped = NULL;
}
qemu_free_displaysurface(vga->ds);
VAR_0->guest_primary.data = memory_region_get_ram_ptr(&VAR_0->vga.vram);
if (VAR_0->guest_primary.stride < 0) {
VAR_0->guest_primary.stride = -VAR_0->guest_primary.stride;
VAR_0->guest_primary.flipped = g_malloc(VAR_0->guest_primary.surface.width *
VAR_0->guest_primary.stride);
VAR_1 = VAR_0->guest_primary.flipped;
} else {
VAR_1 = VAR_0->guest_primary.data;
}
dprint(VAR_0, 1, "%s: %dx%d, stride %d, bpp %d, depth %d, flip %s\n",
__FUNCTION__,
VAR_0->guest_primary.surface.width,
VAR_0->guest_primary.surface.height,
VAR_0->guest_primary.stride,
VAR_0->guest_primary.bytes_pp,
VAR_0->guest_primary.bits_pp,
VAR_0->guest_primary.flipped ? "yes" : "no");
vga->ds->surface =
qemu_create_displaysurface_from(VAR_0->guest_primary.surface.width,
VAR_0->guest_primary.surface.height,
VAR_0->guest_primary.bits_pp,
VAR_0->guest_primary.stride,
VAR_1);
dpy_resize(vga->ds);
}
if (!VAR_0->guest_primary.commands) {
return;
}
VAR_0->guest_primary.commands = 0;
update.left = 0;
update.right = VAR_0->guest_primary.surface.width;
update.top = 0;
update.bottom = VAR_0->guest_primary.surface.height;
memset(dirty, 0, sizeof(dirty));
qxl_spice_update_area(VAR_0, 0, &update,
dirty, ARRAY_SIZE(dirty), 1, QXL_SYNC);
for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(dirty); VAR_2++) {
if (qemu_spice_rect_is_empty(dirty+VAR_2)) {
break;
}
if (VAR_0->guest_primary.flipped) {
qxl_flip(VAR_0, dirty+VAR_2);
}
dpy_update(vga->ds,
dirty[VAR_2].left, dirty[VAR_2].top,
dirty[VAR_2].right - dirty[VAR_2].left,
dirty[VAR_2].bottom - dirty[VAR_2].top);
}
}
|
[
"void FUNC_0(PCIQXLDevice *VAR_0)\n{",
"VGACommonState *vga = &VAR_0->vga;",
"QXLRect dirty[32], update;",
"void *VAR_1;",
"int VAR_2;",
"if (VAR_0->guest_primary.resized) {",
"VAR_0->guest_primary.resized = 0;",
"if (VAR_0->guest_primary.flipped) {",
"g_free(VAR_0->guest_primary.flipped);",
"VAR_0->guest_primary.flipped = NULL;",
"}",
"qemu_free_displaysurface(vga->ds);",
"VAR_0->guest_primary.data = memory_region_get_ram_ptr(&VAR_0->vga.vram);",
"if (VAR_0->guest_primary.stride < 0) {",
"VAR_0->guest_primary.stride = -VAR_0->guest_primary.stride;",
"VAR_0->guest_primary.flipped = g_malloc(VAR_0->guest_primary.surface.width *\nVAR_0->guest_primary.stride);",
"VAR_1 = VAR_0->guest_primary.flipped;",
"} else {",
"VAR_1 = VAR_0->guest_primary.data;",
"}",
"dprint(VAR_0, 1, \"%s: %dx%d, stride %d, bpp %d, depth %d, flip %s\\n\",\n__FUNCTION__,\nVAR_0->guest_primary.surface.width,\nVAR_0->guest_primary.surface.height,\nVAR_0->guest_primary.stride,\nVAR_0->guest_primary.bytes_pp,\nVAR_0->guest_primary.bits_pp,\nVAR_0->guest_primary.flipped ? \"yes\" : \"no\");",
"vga->ds->surface =\nqemu_create_displaysurface_from(VAR_0->guest_primary.surface.width,\nVAR_0->guest_primary.surface.height,\nVAR_0->guest_primary.bits_pp,\nVAR_0->guest_primary.stride,\nVAR_1);",
"dpy_resize(vga->ds);",
"}",
"if (!VAR_0->guest_primary.commands) {",
"return;",
"}",
"VAR_0->guest_primary.commands = 0;",
"update.left = 0;",
"update.right = VAR_0->guest_primary.surface.width;",
"update.top = 0;",
"update.bottom = VAR_0->guest_primary.surface.height;",
"memset(dirty, 0, sizeof(dirty));",
"qxl_spice_update_area(VAR_0, 0, &update,\ndirty, ARRAY_SIZE(dirty), 1, QXL_SYNC);",
"for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(dirty); VAR_2++) {",
"if (qemu_spice_rect_is_empty(dirty+VAR_2)) {",
"break;",
"}",
"if (VAR_0->guest_primary.flipped) {",
"qxl_flip(VAR_0, dirty+VAR_2);",
"}",
"dpy_update(vga->ds,\ndirty[VAR_2].left, dirty[VAR_2].top,\ndirty[VAR_2].right - dirty[VAR_2].left,\ndirty[VAR_2].bottom - dirty[VAR_2].top);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53,
55,
57,
59,
61,
63,
65,
67
],
[
69,
71,
73,
75,
77,
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
],
[
93
],
[
97
],
[
99
],
[
101
],
[
103
],
[
107
],
[
109,
111
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129,
131,
133,
135
],
[
137
],
[
139
]
] |
7,067 |
static int local_fstat(FsContext *fs_ctx, int fid_type,
V9fsFidOpenState *fs, struct stat *stbuf)
{
int err, fd;
if (fid_type == P9_FID_DIR) {
fd = dirfd(fs->dir);
} else {
fd = fs->fd;
}
err = fstat(fd, stbuf);
if (err) {
return err;
}
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
/* Actual credentials are part of extended attrs */
uid_t tmp_uid;
gid_t tmp_gid;
mode_t tmp_mode;
dev_t tmp_dev;
if (fgetxattr(fd, "user.virtfs.uid",
&tmp_uid, sizeof(uid_t)) > 0) {
stbuf->st_uid = tmp_uid;
}
if (fgetxattr(fd, "user.virtfs.gid",
&tmp_gid, sizeof(gid_t)) > 0) {
stbuf->st_gid = tmp_gid;
}
if (fgetxattr(fd, "user.virtfs.mode",
&tmp_mode, sizeof(mode_t)) > 0) {
stbuf->st_mode = tmp_mode;
}
if (fgetxattr(fd, "user.virtfs.rdev",
&tmp_dev, sizeof(dev_t)) > 0) {
stbuf->st_rdev = tmp_dev;
}
} else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
errno = EOPNOTSUPP;
return -1;
}
return err;
}
| false |
qemu
|
f8ad4a89e99848a554b0049d7a612f5a585b7231
|
static int local_fstat(FsContext *fs_ctx, int fid_type,
V9fsFidOpenState *fs, struct stat *stbuf)
{
int err, fd;
if (fid_type == P9_FID_DIR) {
fd = dirfd(fs->dir);
} else {
fd = fs->fd;
}
err = fstat(fd, stbuf);
if (err) {
return err;
}
if (fs_ctx->export_flags & V9FS_SM_MAPPED) {
uid_t tmp_uid;
gid_t tmp_gid;
mode_t tmp_mode;
dev_t tmp_dev;
if (fgetxattr(fd, "user.virtfs.uid",
&tmp_uid, sizeof(uid_t)) > 0) {
stbuf->st_uid = tmp_uid;
}
if (fgetxattr(fd, "user.virtfs.gid",
&tmp_gid, sizeof(gid_t)) > 0) {
stbuf->st_gid = tmp_gid;
}
if (fgetxattr(fd, "user.virtfs.mode",
&tmp_mode, sizeof(mode_t)) > 0) {
stbuf->st_mode = tmp_mode;
}
if (fgetxattr(fd, "user.virtfs.rdev",
&tmp_dev, sizeof(dev_t)) > 0) {
stbuf->st_rdev = tmp_dev;
}
} else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) {
errno = EOPNOTSUPP;
return -1;
}
return err;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(FsContext *VAR_0, int VAR_1,
V9fsFidOpenState *VAR_2, struct stat *VAR_3)
{
int VAR_4, VAR_5;
if (VAR_1 == P9_FID_DIR) {
VAR_5 = dirfd(VAR_2->dir);
} else {
VAR_5 = VAR_2->VAR_5;
}
VAR_4 = fstat(VAR_5, VAR_3);
if (VAR_4) {
return VAR_4;
}
if (VAR_0->export_flags & V9FS_SM_MAPPED) {
uid_t tmp_uid;
gid_t tmp_gid;
mode_t tmp_mode;
dev_t tmp_dev;
if (fgetxattr(VAR_5, "user.virtfs.uid",
&tmp_uid, sizeof(uid_t)) > 0) {
VAR_3->st_uid = tmp_uid;
}
if (fgetxattr(VAR_5, "user.virtfs.gid",
&tmp_gid, sizeof(gid_t)) > 0) {
VAR_3->st_gid = tmp_gid;
}
if (fgetxattr(VAR_5, "user.virtfs.mode",
&tmp_mode, sizeof(mode_t)) > 0) {
VAR_3->st_mode = tmp_mode;
}
if (fgetxattr(VAR_5, "user.virtfs.rdev",
&tmp_dev, sizeof(dev_t)) > 0) {
VAR_3->st_rdev = tmp_dev;
}
} else if (VAR_0->export_flags & V9FS_SM_MAPPED_FILE) {
errno = EOPNOTSUPP;
return -1;
}
return VAR_4;
}
|
[
"static int FUNC_0(FsContext *VAR_0, int VAR_1,\nV9fsFidOpenState *VAR_2, struct stat *VAR_3)\n{",
"int VAR_4, VAR_5;",
"if (VAR_1 == P9_FID_DIR) {",
"VAR_5 = dirfd(VAR_2->dir);",
"} else {",
"VAR_5 = VAR_2->VAR_5;",
"}",
"VAR_4 = fstat(VAR_5, VAR_3);",
"if (VAR_4) {",
"return VAR_4;",
"}",
"if (VAR_0->export_flags & V9FS_SM_MAPPED) {",
"uid_t tmp_uid;",
"gid_t tmp_gid;",
"mode_t tmp_mode;",
"dev_t tmp_dev;",
"if (fgetxattr(VAR_5, \"user.virtfs.uid\",\n&tmp_uid, sizeof(uid_t)) > 0) {",
"VAR_3->st_uid = tmp_uid;",
"}",
"if (fgetxattr(VAR_5, \"user.virtfs.gid\",\n&tmp_gid, sizeof(gid_t)) > 0) {",
"VAR_3->st_gid = tmp_gid;",
"}",
"if (fgetxattr(VAR_5, \"user.virtfs.mode\",\n&tmp_mode, sizeof(mode_t)) > 0) {",
"VAR_3->st_mode = tmp_mode;",
"}",
"if (fgetxattr(VAR_5, \"user.virtfs.rdev\",\n&tmp_dev, sizeof(dev_t)) > 0) {",
"VAR_3->st_rdev = tmp_dev;",
"}",
"} else if (VAR_0->export_flags & V9FS_SM_MAPPED_FILE) {",
"errno = EOPNOTSUPP;",
"return -1;",
"}",
"return VAR_4;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45,
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
]
] |
7,068 |
static uint64_t malta_fpga_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
MaltaFPGAState *s = opaque;
uint32_t val = 0;
uint32_t saddr;
saddr = (addr & 0xfffff);
switch (saddr) {
/* SWITCH Register */
case 0x00200:
val = 0x00000000; /* All switches closed */
break;
/* STATUS Register */
case 0x00208:
#ifdef TARGET_WORDS_BIGENDIAN
val = 0x00000012;
#else
val = 0x00000010;
#endif
break;
/* JMPRS Register */
case 0x00210:
val = 0x00;
break;
/* LEDBAR Register */
case 0x00408:
val = s->leds;
break;
/* BRKRES Register */
case 0x00508:
val = s->brk;
break;
/* UART Registers are handled directly by the serial device */
/* GPOUT Register */
case 0x00a00:
val = s->gpout;
break;
/* XXX: implement a real I2C controller */
/* GPINP Register */
case 0x00a08:
/* IN = OUT until a real I2C control is implemented */
if (s->i2csel)
val = s->i2cout;
else
val = 0x00;
break;
/* I2CINP Register */
case 0x00b00:
val = ((s->i2cin & ~1) | eeprom24c0x_read());
break;
/* I2COE Register */
case 0x00b08:
val = s->i2coe;
break;
/* I2COUT Register */
case 0x00b10:
val = s->i2cout;
break;
/* I2CSEL Register */
case 0x00b18:
val = s->i2csel;
break;
default:
#if 0
printf ("malta_fpga_read: Bad register offset 0x" TARGET_FMT_lx "\n",
addr);
#endif
break;
}
return val;
}
| false |
qemu
|
a8170e5e97ad17ca169c64ba87ae2f53850dab4c
|
static uint64_t malta_fpga_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
MaltaFPGAState *s = opaque;
uint32_t val = 0;
uint32_t saddr;
saddr = (addr & 0xfffff);
switch (saddr) {
case 0x00200:
val = 0x00000000;
break;
case 0x00208:
#ifdef TARGET_WORDS_BIGENDIAN
val = 0x00000012;
#else
val = 0x00000010;
#endif
break;
case 0x00210:
val = 0x00;
break;
case 0x00408:
val = s->leds;
break;
case 0x00508:
val = s->brk;
break;
case 0x00a00:
val = s->gpout;
break;
case 0x00a08:
if (s->i2csel)
val = s->i2cout;
else
val = 0x00;
break;
case 0x00b00:
val = ((s->i2cin & ~1) | eeprom24c0x_read());
break;
case 0x00b08:
val = s->i2coe;
break;
case 0x00b10:
val = s->i2cout;
break;
case 0x00b18:
val = s->i2csel;
break;
default:
#if 0
printf ("malta_fpga_read: Bad register offset 0x" TARGET_FMT_lx "\n",
addr);
#endif
break;
}
return val;
}
|
{
"code": [],
"line_no": []
}
|
static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,
unsigned size)
{
MaltaFPGAState *s = opaque;
uint32_t val = 0;
uint32_t saddr;
saddr = (addr & 0xfffff);
switch (saddr) {
case 0x00200:
val = 0x00000000;
break;
case 0x00208:
#ifdef TARGET_WORDS_BIGENDIAN
val = 0x00000012;
#else
val = 0x00000010;
#endif
break;
case 0x00210:
val = 0x00;
break;
case 0x00408:
val = s->leds;
break;
case 0x00508:
val = s->brk;
break;
case 0x00a00:
val = s->gpout;
break;
case 0x00a08:
if (s->i2csel)
val = s->i2cout;
else
val = 0x00;
break;
case 0x00b00:
val = ((s->i2cin & ~1) | eeprom24c0x_read());
break;
case 0x00b08:
val = s->i2coe;
break;
case 0x00b10:
val = s->i2cout;
break;
case 0x00b18:
val = s->i2csel;
break;
default:
#if 0
printf ("FUNC_0: Bad register offset 0x" TARGET_FMT_lx "\n",
addr);
#endif
break;
}
return val;
}
|
[
"static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{",
"MaltaFPGAState *s = opaque;",
"uint32_t val = 0;",
"uint32_t saddr;",
"saddr = (addr & 0xfffff);",
"switch (saddr) {",
"case 0x00200:\nval = 0x00000000;",
"break;",
"case 0x00208:\n#ifdef TARGET_WORDS_BIGENDIAN\nval = 0x00000012;",
"#else\nval = 0x00000010;",
"#endif\nbreak;",
"case 0x00210:\nval = 0x00;",
"break;",
"case 0x00408:\nval = s->leds;",
"break;",
"case 0x00508:\nval = s->brk;",
"break;",
"case 0x00a00:\nval = s->gpout;",
"break;",
"case 0x00a08:\nif (s->i2csel)\nval = s->i2cout;",
"else\nval = 0x00;",
"break;",
"case 0x00b00:\nval = ((s->i2cin & ~1) | eeprom24c0x_read());",
"break;",
"case 0x00b08:\nval = s->i2coe;",
"break;",
"case 0x00b10:\nval = s->i2cout;",
"break;",
"case 0x00b18:\nval = s->i2csel;",
"break;",
"default:\n#if 0\nprintf (\"FUNC_0: Bad register offset 0x\" TARGET_FMT_lx \"\\n\",\naddr);",
"#endif\nbreak;",
"}",
"return val;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
25,
27
],
[
29
],
[
35,
37,
39
],
[
41,
43
],
[
45,
47
],
[
53,
55
],
[
57
],
[
63,
65
],
[
67
],
[
73,
75
],
[
77
],
[
87,
89
],
[
91
],
[
101,
105,
107
],
[
109,
111
],
[
113
],
[
119,
121
],
[
123
],
[
129,
131
],
[
133
],
[
139,
141
],
[
143
],
[
149,
151
],
[
153
],
[
157,
159,
161,
163
],
[
165,
167
],
[
169
],
[
171
],
[
173
]
] |
7,071 |
static void replay_save_event(Event *event, int checkpoint)
{
if (replay_mode != REPLAY_MODE_PLAY) {
/* put the event into the file */
replay_put_event(EVENT_ASYNC);
replay_put_byte(checkpoint);
replay_put_byte(event->event_kind);
/* save event-specific data */
switch (event->event_kind) {
default:
error_report("Unknown ID %d of replay event", read_event_kind);
exit(1);
break;
}
}
}
| false |
qemu
|
8a354bd935a800dd2d98ac8f30707e2912c80ae6
|
static void replay_save_event(Event *event, int checkpoint)
{
if (replay_mode != REPLAY_MODE_PLAY) {
replay_put_event(EVENT_ASYNC);
replay_put_byte(checkpoint);
replay_put_byte(event->event_kind);
switch (event->event_kind) {
default:
error_report("Unknown ID %d of replay event", read_event_kind);
exit(1);
break;
}
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(Event *VAR_0, int VAR_1)
{
if (replay_mode != REPLAY_MODE_PLAY) {
replay_put_event(EVENT_ASYNC);
replay_put_byte(VAR_1);
replay_put_byte(VAR_0->event_kind);
switch (VAR_0->event_kind) {
default:
error_report("Unknown ID %d of replay VAR_0", read_event_kind);
exit(1);
break;
}
}
}
|
[
"static void FUNC_0(Event *VAR_0, int VAR_1)\n{",
"if (replay_mode != REPLAY_MODE_PLAY) {",
"replay_put_event(EVENT_ASYNC);",
"replay_put_byte(VAR_1);",
"replay_put_byte(VAR_0->event_kind);",
"switch (VAR_0->event_kind) {",
"default:\nerror_report(\"Unknown ID %d of replay VAR_0\", read_event_kind);",
"exit(1);",
"break;",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
7,072 |
static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
{
static int nr=0;
char id[8];
QemuOpts *opts;
DriveInfo *dinfo;
USBDevice *dev;
const char *p1;
char fmt[32];
/* parse -usbdevice disk: syntax into drive opts */
do {
snprintf(id, sizeof(id), "usb%d", nr++);
opts = qemu_opts_create(qemu_find_opts("drive"), id, 1, NULL);
} while (!opts);
p1 = strchr(filename, ':');
if (p1++) {
const char *p2;
if (strstart(filename, "format=", &p2)) {
int len = MIN(p1 - p2, sizeof(fmt));
pstrcpy(fmt, len, p2);
qemu_opt_set(opts, "format", fmt);
} else if (*filename != ':') {
error_report("unrecognized USB mass-storage option %s", filename);
return NULL;
}
filename = p1;
}
if (!*filename) {
error_report("block device specification needed");
return NULL;
}
qemu_opt_set(opts, "file", filename);
qemu_opt_set(opts, "if", "none");
/* create host drive */
dinfo = drive_new(opts, 0);
if (!dinfo) {
qemu_opts_del(opts);
return NULL;
}
/* create guest device */
dev = usb_create(bus, "usb-storage");
if (!dev) {
return NULL;
}
if (qdev_prop_set_drive(&dev->qdev, "drive",
blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) {
object_unparent(OBJECT(dev));
return NULL;
}
if (qdev_init(&dev->qdev) < 0)
return NULL;
return dev;
}
| false |
qemu
|
4be746345f13e99e468c60acbd3a355e8183e3ce
|
static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
{
static int nr=0;
char id[8];
QemuOpts *opts;
DriveInfo *dinfo;
USBDevice *dev;
const char *p1;
char fmt[32];
do {
snprintf(id, sizeof(id), "usb%d", nr++);
opts = qemu_opts_create(qemu_find_opts("drive"), id, 1, NULL);
} while (!opts);
p1 = strchr(filename, ':');
if (p1++) {
const char *p2;
if (strstart(filename, "format=", &p2)) {
int len = MIN(p1 - p2, sizeof(fmt));
pstrcpy(fmt, len, p2);
qemu_opt_set(opts, "format", fmt);
} else if (*filename != ':') {
error_report("unrecognized USB mass-storage option %s", filename);
return NULL;
}
filename = p1;
}
if (!*filename) {
error_report("block device specification needed");
return NULL;
}
qemu_opt_set(opts, "file", filename);
qemu_opt_set(opts, "if", "none");
dinfo = drive_new(opts, 0);
if (!dinfo) {
qemu_opts_del(opts);
return NULL;
}
dev = usb_create(bus, "usb-storage");
if (!dev) {
return NULL;
}
if (qdev_prop_set_drive(&dev->qdev, "drive",
blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) {
object_unparent(OBJECT(dev));
return NULL;
}
if (qdev_init(&dev->qdev) < 0)
return NULL;
return dev;
}
|
{
"code": [],
"line_no": []
}
|
static USBDevice *FUNC_0(USBBus *bus, const char *filename)
{
static int VAR_0=0;
char VAR_1[8];
QemuOpts *opts;
DriveInfo *dinfo;
USBDevice *dev;
const char *VAR_2;
char VAR_3[32];
do {
snprintf(VAR_1, sizeof(VAR_1), "usb%d", VAR_0++);
opts = qemu_opts_create(qemu_find_opts("drive"), VAR_1, 1, NULL);
} while (!opts);
VAR_2 = strchr(filename, ':');
if (VAR_2++) {
const char *VAR_4;
if (strstart(filename, "format=", &VAR_4)) {
int VAR_5 = MIN(VAR_2 - VAR_4, sizeof(VAR_3));
pstrcpy(VAR_3, VAR_5, VAR_4);
qemu_opt_set(opts, "format", VAR_3);
} else if (*filename != ':') {
error_report("unrecognized USB mass-storage option %s", filename);
return NULL;
}
filename = VAR_2;
}
if (!*filename) {
error_report("block device specification needed");
return NULL;
}
qemu_opt_set(opts, "file", filename);
qemu_opt_set(opts, "if", "none");
dinfo = drive_new(opts, 0);
if (!dinfo) {
qemu_opts_del(opts);
return NULL;
}
dev = usb_create(bus, "usb-storage");
if (!dev) {
return NULL;
}
if (qdev_prop_set_drive(&dev->qdev, "drive",
blk_bs(blk_by_legacy_dinfo(dinfo))) < 0) {
object_unparent(OBJECT(dev));
return NULL;
}
if (qdev_init(&dev->qdev) < 0)
return NULL;
return dev;
}
|
[
"static USBDevice *FUNC_0(USBBus *bus, const char *filename)\n{",
"static int VAR_0=0;",
"char VAR_1[8];",
"QemuOpts *opts;",
"DriveInfo *dinfo;",
"USBDevice *dev;",
"const char *VAR_2;",
"char VAR_3[32];",
"do {",
"snprintf(VAR_1, sizeof(VAR_1), \"usb%d\", VAR_0++);",
"opts = qemu_opts_create(qemu_find_opts(\"drive\"), VAR_1, 1, NULL);",
"} while (!opts);",
"VAR_2 = strchr(filename, ':');",
"if (VAR_2++) {",
"const char *VAR_4;",
"if (strstart(filename, \"format=\", &VAR_4)) {",
"int VAR_5 = MIN(VAR_2 - VAR_4, sizeof(VAR_3));",
"pstrcpy(VAR_3, VAR_5, VAR_4);",
"qemu_opt_set(opts, \"format\", VAR_3);",
"} else if (*filename != ':') {",
"error_report(\"unrecognized USB mass-storage option %s\", filename);",
"return NULL;",
"}",
"filename = VAR_2;",
"}",
"if (!*filename) {",
"error_report(\"block device specification needed\");",
"return NULL;",
"}",
"qemu_opt_set(opts, \"file\", filename);",
"qemu_opt_set(opts, \"if\", \"none\");",
"dinfo = drive_new(opts, 0);",
"if (!dinfo) {",
"qemu_opts_del(opts);",
"return NULL;",
"}",
"dev = usb_create(bus, \"usb-storage\");",
"if (!dev) {",
"return NULL;",
"}",
"if (qdev_prop_set_drive(&dev->qdev, \"drive\",\nblk_bs(blk_by_legacy_dinfo(dinfo))) < 0) {",
"object_unparent(OBJECT(dev));",
"return NULL;",
"}",
"if (qdev_init(&dev->qdev) < 0)\nreturn NULL;",
"return dev;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99,
101
],
[
103
],
[
105
],
[
107
],
[
109,
111
],
[
115
],
[
117
]
] |
7,074 |
static size_t handle_aiocb_flush(struct qemu_paiocb *aiocb)
{
int ret;
ret = qemu_fdatasync(aiocb->aio_fildes);
if (ret == -1)
return -errno;
return 0;
}
| false |
qemu
|
6769da29c7a3caa9de4020db87f495de692cf8e2
|
static size_t handle_aiocb_flush(struct qemu_paiocb *aiocb)
{
int ret;
ret = qemu_fdatasync(aiocb->aio_fildes);
if (ret == -1)
return -errno;
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static size_t FUNC_0(struct qemu_paiocb *aiocb)
{
int VAR_0;
VAR_0 = qemu_fdatasync(aiocb->aio_fildes);
if (VAR_0 == -1)
return -errno;
return 0;
}
|
[
"static size_t FUNC_0(struct qemu_paiocb *aiocb)\n{",
"int VAR_0;",
"VAR_0 = qemu_fdatasync(aiocb->aio_fildes);",
"if (VAR_0 == -1)\nreturn -errno;",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15
],
[
17
]
] |
7,075 |
static int unin_internal_pci_host_init(PCIDevice *d)
{
pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_APPLE);
pci_config_set_device_id(d->config, PCI_DEVICE_ID_APPLE_UNI_N_I_PCI);
d->config[0x08] = 0x00; // revision
pci_config_set_class(d->config, PCI_CLASS_BRIDGE_HOST);
d->config[0x0C] = 0x08; // cache_line_size
d->config[0x0D] = 0x10; // latency_timer
d->config[0x34] = 0x00; // capabilities_pointer
return 0;
}
| false |
qemu
|
d7b61ecc61f84d23f98f1ee270fb48b41834ca00
|
static int unin_internal_pci_host_init(PCIDevice *d)
{
pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_APPLE);
pci_config_set_device_id(d->config, PCI_DEVICE_ID_APPLE_UNI_N_I_PCI);
d->config[0x08] = 0x00;
pci_config_set_class(d->config, PCI_CLASS_BRIDGE_HOST);
d->config[0x0C] = 0x08;
d->config[0x0D] = 0x10;
d->config[0x34] = 0x00;
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(PCIDevice *VAR_0)
{
pci_config_set_vendor_id(VAR_0->config, PCI_VENDOR_ID_APPLE);
pci_config_set_device_id(VAR_0->config, PCI_DEVICE_ID_APPLE_UNI_N_I_PCI);
VAR_0->config[0x08] = 0x00;
pci_config_set_class(VAR_0->config, PCI_CLASS_BRIDGE_HOST);
VAR_0->config[0x0C] = 0x08;
VAR_0->config[0x0D] = 0x10;
VAR_0->config[0x34] = 0x00;
return 0;
}
|
[
"static int FUNC_0(PCIDevice *VAR_0)\n{",
"pci_config_set_vendor_id(VAR_0->config, PCI_VENDOR_ID_APPLE);",
"pci_config_set_device_id(VAR_0->config, PCI_DEVICE_ID_APPLE_UNI_N_I_PCI);",
"VAR_0->config[0x08] = 0x00;",
"pci_config_set_class(VAR_0->config, PCI_CLASS_BRIDGE_HOST);",
"VAR_0->config[0x0C] = 0x08;",
"VAR_0->config[0x0D] = 0x10;",
"VAR_0->config[0x34] = 0x00;",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
7,077 |
static int upload_texture(SDL_Texture *tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
int ret = 0;
switch (frame->format) {
case AV_PIX_FMT_YUV420P:
if (frame->linesize[0] < 0 || frame->linesize[1] < 0 || frame->linesize[2] < 0) {
av_log(NULL, AV_LOG_ERROR, "Negative linesize is not supported for YUV.\n");
return -1;
}
ret = SDL_UpdateYUVTexture(tex, NULL, frame->data[0], frame->linesize[0],
frame->data[1], frame->linesize[1],
frame->data[2], frame->linesize[2]);
break;
case AV_PIX_FMT_BGRA:
if (frame->linesize[0] < 0) {
ret = SDL_UpdateTexture(tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
} else {
ret = SDL_UpdateTexture(tex, NULL, frame->data[0], frame->linesize[0]);
}
break;
default:
/* This should only happen if we are not using avfilter... */
*img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
frame->width, frame->height, frame->format, frame->width, frame->height,
AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
if (*img_convert_ctx != NULL) {
uint8_t *pixels[4];
int pitch[4];
if (!SDL_LockTexture(tex, NULL, (void **)pixels, pitch)) {
sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
0, frame->height, pixels, pitch);
SDL_UnlockTexture(tex);
}
} else {
av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
ret = -1;
}
break;
}
return ret;
}
| false |
FFmpeg
|
493f637d1e933ebdd9f63528a7782d3617c442cb
|
static int upload_texture(SDL_Texture *tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
int ret = 0;
switch (frame->format) {
case AV_PIX_FMT_YUV420P:
if (frame->linesize[0] < 0 || frame->linesize[1] < 0 || frame->linesize[2] < 0) {
av_log(NULL, AV_LOG_ERROR, "Negative linesize is not supported for YUV.\n");
return -1;
}
ret = SDL_UpdateYUVTexture(tex, NULL, frame->data[0], frame->linesize[0],
frame->data[1], frame->linesize[1],
frame->data[2], frame->linesize[2]);
break;
case AV_PIX_FMT_BGRA:
if (frame->linesize[0] < 0) {
ret = SDL_UpdateTexture(tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
} else {
ret = SDL_UpdateTexture(tex, NULL, frame->data[0], frame->linesize[0]);
}
break;
default:
*img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
frame->width, frame->height, frame->format, frame->width, frame->height,
AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
if (*img_convert_ctx != NULL) {
uint8_t *pixels[4];
int pitch[4];
if (!SDL_LockTexture(tex, NULL, (void **)pixels, pitch)) {
sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
0, frame->height, pixels, pitch);
SDL_UnlockTexture(tex);
}
} else {
av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
ret = -1;
}
break;
}
return ret;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(SDL_Texture *VAR_0, AVFrame *VAR_1, struct SwsContext **VAR_2) {
int VAR_3 = 0;
switch (VAR_1->format) {
case AV_PIX_FMT_YUV420P:
if (VAR_1->linesize[0] < 0 || VAR_1->linesize[1] < 0 || VAR_1->linesize[2] < 0) {
av_log(NULL, AV_LOG_ERROR, "Negative linesize is not supported for YUV.\n");
return -1;
}
VAR_3 = SDL_UpdateYUVTexture(VAR_0, NULL, VAR_1->data[0], VAR_1->linesize[0],
VAR_1->data[1], VAR_1->linesize[1],
VAR_1->data[2], VAR_1->linesize[2]);
break;
case AV_PIX_FMT_BGRA:
if (VAR_1->linesize[0] < 0) {
VAR_3 = SDL_UpdateTexture(VAR_0, NULL, VAR_1->data[0] + VAR_1->linesize[0] * (VAR_1->height - 1), -VAR_1->linesize[0]);
} else {
VAR_3 = SDL_UpdateTexture(VAR_0, NULL, VAR_1->data[0], VAR_1->linesize[0]);
}
break;
default:
*VAR_2 = sws_getCachedContext(*VAR_2,
VAR_1->width, VAR_1->height, VAR_1->format, VAR_1->width, VAR_1->height,
AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
if (*VAR_2 != NULL) {
uint8_t *pixels[4];
int VAR_4[4];
if (!SDL_LockTexture(VAR_0, NULL, (void **)pixels, VAR_4)) {
sws_scale(*VAR_2, (const uint8_t * const *)VAR_1->data, VAR_1->linesize,
0, VAR_1->height, pixels, VAR_4);
SDL_UnlockTexture(VAR_0);
}
} else {
av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
VAR_3 = -1;
}
break;
}
return VAR_3;
}
|
[
"static int FUNC_0(SDL_Texture *VAR_0, AVFrame *VAR_1, struct SwsContext **VAR_2) {",
"int VAR_3 = 0;",
"switch (VAR_1->format) {",
"case AV_PIX_FMT_YUV420P:\nif (VAR_1->linesize[0] < 0 || VAR_1->linesize[1] < 0 || VAR_1->linesize[2] < 0) {",
"av_log(NULL, AV_LOG_ERROR, \"Negative linesize is not supported for YUV.\\n\");",
"return -1;",
"}",
"VAR_3 = SDL_UpdateYUVTexture(VAR_0, NULL, VAR_1->data[0], VAR_1->linesize[0],\nVAR_1->data[1], VAR_1->linesize[1],\nVAR_1->data[2], VAR_1->linesize[2]);",
"break;",
"case AV_PIX_FMT_BGRA:\nif (VAR_1->linesize[0] < 0) {",
"VAR_3 = SDL_UpdateTexture(VAR_0, NULL, VAR_1->data[0] + VAR_1->linesize[0] * (VAR_1->height - 1), -VAR_1->linesize[0]);",
"} else {",
"VAR_3 = SDL_UpdateTexture(VAR_0, NULL, VAR_1->data[0], VAR_1->linesize[0]);",
"}",
"break;",
"default:\n*VAR_2 = sws_getCachedContext(*VAR_2,\nVAR_1->width, VAR_1->height, VAR_1->format, VAR_1->width, VAR_1->height,\nAV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);",
"if (*VAR_2 != NULL) {",
"uint8_t *pixels[4];",
"int VAR_4[4];",
"if (!SDL_LockTexture(VAR_0, NULL, (void **)pixels, VAR_4)) {",
"sws_scale(*VAR_2, (const uint8_t * const *)VAR_1->data, VAR_1->linesize,\n0, VAR_1->height, pixels, VAR_4);",
"SDL_UnlockTexture(VAR_0);",
"}",
"} else {",
"av_log(NULL, AV_LOG_FATAL, \"Cannot initialize the conversion context\\n\");",
"VAR_3 = -1;",
"}",
"break;",
"}",
"return VAR_3;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1
],
[
3
],
[
5
],
[
7,
9
],
[
11
],
[
13
],
[
15
],
[
17,
19,
21
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
43,
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
]
] |
7,079 |
static void load_linux(const char *kernel_filename,
const char *initrd_filename,
const char *kernel_cmdline)
{
uint16_t protocol;
uint32_t gpr[8];
uint16_t seg[6];
uint16_t real_seg;
int setup_size, kernel_size, initrd_size, cmdline_size;
uint32_t initrd_max;
uint8_t header[1024];
target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr;
FILE *f, *fi;
/* Align to 16 bytes as a paranoia measure */
cmdline_size = (strlen(kernel_cmdline)+16) & ~15;
/* load the kernel header */
f = fopen(kernel_filename, "rb");
if (!f || !(kernel_size = get_file_size(f)) ||
fread(header, 1, 1024, f) != 1024) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
/* kernel protocol version */
#if 0
fprintf(stderr, "header magic: %#x\n", ldl_p(header+0x202));
#endif
if (ldl_p(header+0x202) == 0x53726448)
protocol = lduw_p(header+0x206);
else
protocol = 0;
if (protocol < 0x200 || !(header[0x211] & 0x01)) {
/* Low kernel */
real_addr = 0x90000;
cmdline_addr = 0x9a000 - cmdline_size;
prot_addr = 0x10000;
} else if (protocol < 0x202) {
/* High but ancient kernel */
real_addr = 0x90000;
cmdline_addr = 0x9a000 - cmdline_size;
prot_addr = 0x100000;
} else {
/* High and recent kernel */
real_addr = 0x10000;
cmdline_addr = 0x20000;
prot_addr = 0x100000;
}
#if 0
fprintf(stderr,
"qemu: real_addr = 0x" TARGET_FMT_plx "\n"
"qemu: cmdline_addr = 0x" TARGET_FMT_plx "\n"
"qemu: prot_addr = 0x" TARGET_FMT_plx "\n",
real_addr,
cmdline_addr,
prot_addr);
#endif
/* highest address for loading the initrd */
if (protocol >= 0x203)
initrd_max = ldl_p(header+0x22c);
else
initrd_max = 0x37ffffff;
if (initrd_max >= ram_size-ACPI_DATA_SIZE)
initrd_max = ram_size-ACPI_DATA_SIZE-1;
/* kernel command line */
pstrcpy_targphys(cmdline_addr, 4096, kernel_cmdline);
if (protocol >= 0x202) {
stl_p(header+0x228, cmdline_addr);
} else {
stw_p(header+0x20, 0xA33F);
stw_p(header+0x22, cmdline_addr-real_addr);
}
/* loader type */
/* High nybble = B reserved for Qemu; low nybble is revision number.
If this code is substantially changed, you may want to consider
incrementing the revision. */
if (protocol >= 0x200)
header[0x210] = 0xB0;
/* heap */
if (protocol >= 0x201) {
header[0x211] |= 0x80; /* CAN_USE_HEAP */
stw_p(header+0x224, cmdline_addr-real_addr-0x200);
}
/* load initrd */
if (initrd_filename) {
if (protocol < 0x200) {
fprintf(stderr, "qemu: linux kernel too old to load a ram disk\n");
exit(1);
}
fi = fopen(initrd_filename, "rb");
if (!fi) {
fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
initrd_size = get_file_size(fi);
initrd_addr = (initrd_max-initrd_size) & ~4095;
fprintf(stderr, "qemu: loading initrd (%#x bytes) at 0x" TARGET_FMT_plx
"\n", initrd_size, initrd_addr);
if (!fread_targphys_ok(initrd_addr, initrd_size, fi)) {
fprintf(stderr, "qemu: read error on initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
fclose(fi);
stl_p(header+0x218, initrd_addr);
stl_p(header+0x21c, initrd_size);
}
/* store the finalized header and load the rest of the kernel */
cpu_physical_memory_write(real_addr, header, 1024);
setup_size = header[0x1f1];
if (setup_size == 0)
setup_size = 4;
setup_size = (setup_size+1)*512;
kernel_size -= setup_size; /* Size of protected-mode code */
if (!fread_targphys_ok(real_addr+1024, setup_size-1024, f) ||
!fread_targphys_ok(prot_addr, kernel_size, f)) {
fprintf(stderr, "qemu: read error on kernel '%s'\n",
kernel_filename);
exit(1);
}
fclose(f);
/* generate bootsector to set up the initial register state */
real_seg = real_addr >> 4;
seg[0] = seg[2] = seg[3] = seg[4] = seg[4] = real_seg;
seg[1] = real_seg+0x20; /* CS */
memset(gpr, 0, sizeof gpr);
gpr[4] = cmdline_addr-real_addr-16; /* SP (-16 is paranoia) */
generate_bootsect(gpr, seg, 0);
}
| false |
qemu
|
4fc9af53d88c0a2a810704a06cb39a7182982e4e
|
static void load_linux(const char *kernel_filename,
const char *initrd_filename,
const char *kernel_cmdline)
{
uint16_t protocol;
uint32_t gpr[8];
uint16_t seg[6];
uint16_t real_seg;
int setup_size, kernel_size, initrd_size, cmdline_size;
uint32_t initrd_max;
uint8_t header[1024];
target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr;
FILE *f, *fi;
cmdline_size = (strlen(kernel_cmdline)+16) & ~15;
f = fopen(kernel_filename, "rb");
if (!f || !(kernel_size = get_file_size(f)) ||
fread(header, 1, 1024, f) != 1024) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
#if 0
fprintf(stderr, "header magic: %#x\n", ldl_p(header+0x202));
#endif
if (ldl_p(header+0x202) == 0x53726448)
protocol = lduw_p(header+0x206);
else
protocol = 0;
if (protocol < 0x200 || !(header[0x211] & 0x01)) {
real_addr = 0x90000;
cmdline_addr = 0x9a000 - cmdline_size;
prot_addr = 0x10000;
} else if (protocol < 0x202) {
real_addr = 0x90000;
cmdline_addr = 0x9a000 - cmdline_size;
prot_addr = 0x100000;
} else {
real_addr = 0x10000;
cmdline_addr = 0x20000;
prot_addr = 0x100000;
}
#if 0
fprintf(stderr,
"qemu: real_addr = 0x" TARGET_FMT_plx "\n"
"qemu: cmdline_addr = 0x" TARGET_FMT_plx "\n"
"qemu: prot_addr = 0x" TARGET_FMT_plx "\n",
real_addr,
cmdline_addr,
prot_addr);
#endif
if (protocol >= 0x203)
initrd_max = ldl_p(header+0x22c);
else
initrd_max = 0x37ffffff;
if (initrd_max >= ram_size-ACPI_DATA_SIZE)
initrd_max = ram_size-ACPI_DATA_SIZE-1;
pstrcpy_targphys(cmdline_addr, 4096, kernel_cmdline);
if (protocol >= 0x202) {
stl_p(header+0x228, cmdline_addr);
} else {
stw_p(header+0x20, 0xA33F);
stw_p(header+0x22, cmdline_addr-real_addr);
}
if (protocol >= 0x200)
header[0x210] = 0xB0;
if (protocol >= 0x201) {
header[0x211] |= 0x80;
stw_p(header+0x224, cmdline_addr-real_addr-0x200);
}
if (initrd_filename) {
if (protocol < 0x200) {
fprintf(stderr, "qemu: linux kernel too old to load a ram disk\n");
exit(1);
}
fi = fopen(initrd_filename, "rb");
if (!fi) {
fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
initrd_size = get_file_size(fi);
initrd_addr = (initrd_max-initrd_size) & ~4095;
fprintf(stderr, "qemu: loading initrd (%#x bytes) at 0x" TARGET_FMT_plx
"\n", initrd_size, initrd_addr);
if (!fread_targphys_ok(initrd_addr, initrd_size, fi)) {
fprintf(stderr, "qemu: read error on initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
fclose(fi);
stl_p(header+0x218, initrd_addr);
stl_p(header+0x21c, initrd_size);
}
cpu_physical_memory_write(real_addr, header, 1024);
setup_size = header[0x1f1];
if (setup_size == 0)
setup_size = 4;
setup_size = (setup_size+1)*512;
kernel_size -= setup_size;
if (!fread_targphys_ok(real_addr+1024, setup_size-1024, f) ||
!fread_targphys_ok(prot_addr, kernel_size, f)) {
fprintf(stderr, "qemu: read error on kernel '%s'\n",
kernel_filename);
exit(1);
}
fclose(f);
real_seg = real_addr >> 4;
seg[0] = seg[2] = seg[3] = seg[4] = seg[4] = real_seg;
seg[1] = real_seg+0x20;
memset(gpr, 0, sizeof gpr);
gpr[4] = cmdline_addr-real_addr-16;
generate_bootsect(gpr, seg, 0);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(const char *VAR_0,
const char *VAR_1,
const char *VAR_2)
{
uint16_t protocol;
uint32_t gpr[8];
uint16_t seg[6];
uint16_t real_seg;
int VAR_3, VAR_4, VAR_5, VAR_6;
uint32_t initrd_max;
uint8_t header[1024];
target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr;
FILE *f, *fi;
VAR_6 = (strlen(VAR_2)+16) & ~15;
f = fopen(VAR_0, "rb");
if (!f || !(VAR_4 = get_file_size(f)) ||
fread(header, 1, 1024, f) != 1024) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
VAR_0);
exit(1);
}
#if 0
fprintf(stderr, "header magic: %#x\n", ldl_p(header+0x202));
#endif
if (ldl_p(header+0x202) == 0x53726448)
protocol = lduw_p(header+0x206);
else
protocol = 0;
if (protocol < 0x200 || !(header[0x211] & 0x01)) {
real_addr = 0x90000;
cmdline_addr = 0x9a000 - VAR_6;
prot_addr = 0x10000;
} else if (protocol < 0x202) {
real_addr = 0x90000;
cmdline_addr = 0x9a000 - VAR_6;
prot_addr = 0x100000;
} else {
real_addr = 0x10000;
cmdline_addr = 0x20000;
prot_addr = 0x100000;
}
#if 0
fprintf(stderr,
"qemu: real_addr = 0x" TARGET_FMT_plx "\n"
"qemu: cmdline_addr = 0x" TARGET_FMT_plx "\n"
"qemu: prot_addr = 0x" TARGET_FMT_plx "\n",
real_addr,
cmdline_addr,
prot_addr);
#endif
if (protocol >= 0x203)
initrd_max = ldl_p(header+0x22c);
else
initrd_max = 0x37ffffff;
if (initrd_max >= ram_size-ACPI_DATA_SIZE)
initrd_max = ram_size-ACPI_DATA_SIZE-1;
pstrcpy_targphys(cmdline_addr, 4096, VAR_2);
if (protocol >= 0x202) {
stl_p(header+0x228, cmdline_addr);
} else {
stw_p(header+0x20, 0xA33F);
stw_p(header+0x22, cmdline_addr-real_addr);
}
if (protocol >= 0x200)
header[0x210] = 0xB0;
if (protocol >= 0x201) {
header[0x211] |= 0x80;
stw_p(header+0x224, cmdline_addr-real_addr-0x200);
}
if (VAR_1) {
if (protocol < 0x200) {
fprintf(stderr, "qemu: linux kernel too old to load a ram disk\n");
exit(1);
}
fi = fopen(VAR_1, "rb");
if (!fi) {
fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
VAR_1);
exit(1);
}
VAR_5 = get_file_size(fi);
initrd_addr = (initrd_max-VAR_5) & ~4095;
fprintf(stderr, "qemu: loading initrd (%#x bytes) at 0x" TARGET_FMT_plx
"\n", VAR_5, initrd_addr);
if (!fread_targphys_ok(initrd_addr, VAR_5, fi)) {
fprintf(stderr, "qemu: read error on initial ram disk '%s'\n",
VAR_1);
exit(1);
}
fclose(fi);
stl_p(header+0x218, initrd_addr);
stl_p(header+0x21c, VAR_5);
}
cpu_physical_memory_write(real_addr, header, 1024);
VAR_3 = header[0x1f1];
if (VAR_3 == 0)
VAR_3 = 4;
VAR_3 = (VAR_3+1)*512;
VAR_4 -= VAR_3;
if (!fread_targphys_ok(real_addr+1024, VAR_3-1024, f) ||
!fread_targphys_ok(prot_addr, VAR_4, f)) {
fprintf(stderr, "qemu: read error on kernel '%s'\n",
VAR_0);
exit(1);
}
fclose(f);
real_seg = real_addr >> 4;
seg[0] = seg[2] = seg[3] = seg[4] = seg[4] = real_seg;
seg[1] = real_seg+0x20;
memset(gpr, 0, sizeof gpr);
gpr[4] = cmdline_addr-real_addr-16;
generate_bootsect(gpr, seg, 0);
}
|
[
"static void FUNC_0(const char *VAR_0,\nconst char *VAR_1,\nconst char *VAR_2)\n{",
"uint16_t protocol;",
"uint32_t gpr[8];",
"uint16_t seg[6];",
"uint16_t real_seg;",
"int VAR_3, VAR_4, VAR_5, VAR_6;",
"uint32_t initrd_max;",
"uint8_t header[1024];",
"target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr;",
"FILE *f, *fi;",
"VAR_6 = (strlen(VAR_2)+16) & ~15;",
"f = fopen(VAR_0, \"rb\");",
"if (!f || !(VAR_4 = get_file_size(f)) ||\nfread(header, 1, 1024, f) != 1024) {",
"fprintf(stderr, \"qemu: could not load kernel '%s'\\n\",\nVAR_0);",
"exit(1);",
"}",
"#if 0\nfprintf(stderr, \"header magic: %#x\\n\", ldl_p(header+0x202));",
"#endif\nif (ldl_p(header+0x202) == 0x53726448)\nprotocol = lduw_p(header+0x206);",
"else\nprotocol = 0;",
"if (protocol < 0x200 || !(header[0x211] & 0x01)) {",
"real_addr = 0x90000;",
"cmdline_addr = 0x9a000 - VAR_6;",
"prot_addr = 0x10000;",
"} else if (protocol < 0x202) {",
"real_addr = 0x90000;",
"cmdline_addr = 0x9a000 - VAR_6;",
"prot_addr = 0x100000;",
"} else {",
"real_addr = 0x10000;",
"cmdline_addr = 0x20000;",
"prot_addr = 0x100000;",
"}",
"#if 0\nfprintf(stderr,\n\"qemu: real_addr = 0x\" TARGET_FMT_plx \"\\n\"\n\"qemu: cmdline_addr = 0x\" TARGET_FMT_plx \"\\n\"\n\"qemu: prot_addr = 0x\" TARGET_FMT_plx \"\\n\",\nreal_addr,\ncmdline_addr,\nprot_addr);",
"#endif\nif (protocol >= 0x203)\ninitrd_max = ldl_p(header+0x22c);",
"else\ninitrd_max = 0x37ffffff;",
"if (initrd_max >= ram_size-ACPI_DATA_SIZE)\ninitrd_max = ram_size-ACPI_DATA_SIZE-1;",
"pstrcpy_targphys(cmdline_addr, 4096, VAR_2);",
"if (protocol >= 0x202) {",
"stl_p(header+0x228, cmdline_addr);",
"} else {",
"stw_p(header+0x20, 0xA33F);",
"stw_p(header+0x22, cmdline_addr-real_addr);",
"}",
"if (protocol >= 0x200)\nheader[0x210] = 0xB0;",
"if (protocol >= 0x201) {",
"header[0x211] |= 0x80;",
"stw_p(header+0x224, cmdline_addr-real_addr-0x200);",
"}",
"if (VAR_1) {",
"if (protocol < 0x200) {",
"fprintf(stderr, \"qemu: linux kernel too old to load a ram disk\\n\");",
"exit(1);",
"}",
"fi = fopen(VAR_1, \"rb\");",
"if (!fi) {",
"fprintf(stderr, \"qemu: could not load initial ram disk '%s'\\n\",\nVAR_1);",
"exit(1);",
"}",
"VAR_5 = get_file_size(fi);",
"initrd_addr = (initrd_max-VAR_5) & ~4095;",
"fprintf(stderr, \"qemu: loading initrd (%#x bytes) at 0x\" TARGET_FMT_plx\n\"\\n\", VAR_5, initrd_addr);",
"if (!fread_targphys_ok(initrd_addr, VAR_5, fi)) {",
"fprintf(stderr, \"qemu: read error on initial ram disk '%s'\\n\",\nVAR_1);",
"exit(1);",
"}",
"fclose(fi);",
"stl_p(header+0x218, initrd_addr);",
"stl_p(header+0x21c, VAR_5);",
"}",
"cpu_physical_memory_write(real_addr, header, 1024);",
"VAR_3 = header[0x1f1];",
"if (VAR_3 == 0)\nVAR_3 = 4;",
"VAR_3 = (VAR_3+1)*512;",
"VAR_4 -= VAR_3;",
"if (!fread_targphys_ok(real_addr+1024, VAR_3-1024, f) ||\n!fread_targphys_ok(prot_addr, VAR_4, f)) {",
"fprintf(stderr, \"qemu: read error on kernel '%s'\\n\",\nVAR_0);",
"exit(1);",
"}",
"fclose(f);",
"real_seg = real_addr >> 4;",
"seg[0] = seg[2] = seg[3] = seg[4] = seg[4] = real_seg;",
"seg[1] = real_seg+0x20;",
"memset(gpr, 0, sizeof gpr);",
"gpr[4] = cmdline_addr-real_addr-16;",
"generate_bootsect(gpr, seg, 0);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
31
],
[
37
],
[
39,
41
],
[
43,
45
],
[
47
],
[
49
],
[
55,
57
],
[
59,
61,
63
],
[
65,
67
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105,
107,
109,
111,
113,
115,
117,
119
],
[
121,
127,
129
],
[
131,
133
],
[
137,
139
],
[
145
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
171,
173
],
[
179
],
[
181
],
[
183
],
[
185
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
],
[
207,
209
],
[
211
],
[
213
],
[
217
],
[
219
],
[
223,
225
],
[
229
],
[
231,
233
],
[
235
],
[
237
],
[
239
],
[
243
],
[
245
],
[
247
],
[
253
],
[
257
],
[
259,
261
],
[
265
],
[
267
],
[
271,
273
],
[
275,
277
],
[
279
],
[
281
],
[
283
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
301
],
[
303
]
] |
7,080 |
static void gen_neon_zip_u8(TCGv t0, TCGv t1)
{
TCGv rd, rm, tmp;
rd = new_tmp();
rm = new_tmp();
tmp = new_tmp();
tcg_gen_andi_i32(rd, t0, 0xff);
tcg_gen_shli_i32(tmp, t1, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff00);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_shli_i32(tmp, t0, 16);
tcg_gen_andi_i32(tmp, tmp, 0xff0000);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_shli_i32(tmp, t1, 24);
tcg_gen_andi_i32(tmp, tmp, 0xff000000);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_andi_i32(rm, t1, 0xff000000);
tcg_gen_shri_i32(tmp, t0, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff0000);
tcg_gen_or_i32(rm, rm, tmp);
tcg_gen_shri_i32(tmp, t1, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff00);
tcg_gen_or_i32(rm, rm, tmp);
tcg_gen_shri_i32(tmp, t0, 16);
tcg_gen_andi_i32(tmp, tmp, 0xff);
tcg_gen_or_i32(t1, rm, tmp);
tcg_gen_mov_i32(t0, rd);
dead_tmp(tmp);
dead_tmp(rm);
dead_tmp(rd);
}
| false |
qemu
|
d68a6f3a6deb2f5eee198b6fa46877a20227d86e
|
static void gen_neon_zip_u8(TCGv t0, TCGv t1)
{
TCGv rd, rm, tmp;
rd = new_tmp();
rm = new_tmp();
tmp = new_tmp();
tcg_gen_andi_i32(rd, t0, 0xff);
tcg_gen_shli_i32(tmp, t1, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff00);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_shli_i32(tmp, t0, 16);
tcg_gen_andi_i32(tmp, tmp, 0xff0000);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_shli_i32(tmp, t1, 24);
tcg_gen_andi_i32(tmp, tmp, 0xff000000);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_andi_i32(rm, t1, 0xff000000);
tcg_gen_shri_i32(tmp, t0, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff0000);
tcg_gen_or_i32(rm, rm, tmp);
tcg_gen_shri_i32(tmp, t1, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff00);
tcg_gen_or_i32(rm, rm, tmp);
tcg_gen_shri_i32(tmp, t0, 16);
tcg_gen_andi_i32(tmp, tmp, 0xff);
tcg_gen_or_i32(t1, rm, tmp);
tcg_gen_mov_i32(t0, rd);
dead_tmp(tmp);
dead_tmp(rm);
dead_tmp(rd);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(TCGv VAR_0, TCGv VAR_1)
{
TCGv rd, rm, tmp;
rd = new_tmp();
rm = new_tmp();
tmp = new_tmp();
tcg_gen_andi_i32(rd, VAR_0, 0xff);
tcg_gen_shli_i32(tmp, VAR_1, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff00);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_shli_i32(tmp, VAR_0, 16);
tcg_gen_andi_i32(tmp, tmp, 0xff0000);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_shli_i32(tmp, VAR_1, 24);
tcg_gen_andi_i32(tmp, tmp, 0xff000000);
tcg_gen_or_i32(rd, rd, tmp);
tcg_gen_andi_i32(rm, VAR_1, 0xff000000);
tcg_gen_shri_i32(tmp, VAR_0, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff0000);
tcg_gen_or_i32(rm, rm, tmp);
tcg_gen_shri_i32(tmp, VAR_1, 8);
tcg_gen_andi_i32(tmp, tmp, 0xff00);
tcg_gen_or_i32(rm, rm, tmp);
tcg_gen_shri_i32(tmp, VAR_0, 16);
tcg_gen_andi_i32(tmp, tmp, 0xff);
tcg_gen_or_i32(VAR_1, rm, tmp);
tcg_gen_mov_i32(VAR_0, rd);
dead_tmp(tmp);
dead_tmp(rm);
dead_tmp(rd);
}
|
[
"static void FUNC_0(TCGv VAR_0, TCGv VAR_1)\n{",
"TCGv rd, rm, tmp;",
"rd = new_tmp();",
"rm = new_tmp();",
"tmp = new_tmp();",
"tcg_gen_andi_i32(rd, VAR_0, 0xff);",
"tcg_gen_shli_i32(tmp, VAR_1, 8);",
"tcg_gen_andi_i32(tmp, tmp, 0xff00);",
"tcg_gen_or_i32(rd, rd, tmp);",
"tcg_gen_shli_i32(tmp, VAR_0, 16);",
"tcg_gen_andi_i32(tmp, tmp, 0xff0000);",
"tcg_gen_or_i32(rd, rd, tmp);",
"tcg_gen_shli_i32(tmp, VAR_1, 24);",
"tcg_gen_andi_i32(tmp, tmp, 0xff000000);",
"tcg_gen_or_i32(rd, rd, tmp);",
"tcg_gen_andi_i32(rm, VAR_1, 0xff000000);",
"tcg_gen_shri_i32(tmp, VAR_0, 8);",
"tcg_gen_andi_i32(tmp, tmp, 0xff0000);",
"tcg_gen_or_i32(rm, rm, tmp);",
"tcg_gen_shri_i32(tmp, VAR_1, 8);",
"tcg_gen_andi_i32(tmp, tmp, 0xff00);",
"tcg_gen_or_i32(rm, rm, tmp);",
"tcg_gen_shri_i32(tmp, VAR_0, 16);",
"tcg_gen_andi_i32(tmp, tmp, 0xff);",
"tcg_gen_or_i32(VAR_1, rm, tmp);",
"tcg_gen_mov_i32(VAR_0, rd);",
"dead_tmp(tmp);",
"dead_tmp(rm);",
"dead_tmp(rd);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
]
] |
7,081 |
static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo)
{
VncState *vs = cinfo->client_data;
Buffer *buffer = &vs->tight_jpeg;
buffer->offset = buffer->capacity;
buffer_reserve(buffer, 2048);
jpeg_init_destination(cinfo);
return TRUE;
}
| false |
qemu
|
245f7b51c0ea04fb2224b1127430a096c91aee70
|
static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo)
{
VncState *vs = cinfo->client_data;
Buffer *buffer = &vs->tight_jpeg;
buffer->offset = buffer->capacity;
buffer_reserve(buffer, 2048);
jpeg_init_destination(cinfo);
return TRUE;
}
|
{
"code": [],
"line_no": []
}
|
static boolean FUNC_0(j_compress_ptr cinfo)
{
VncState *vs = cinfo->client_data;
Buffer *buffer = &vs->tight_jpeg;
buffer->offset = buffer->capacity;
buffer_reserve(buffer, 2048);
jpeg_init_destination(cinfo);
return TRUE;
}
|
[
"static boolean FUNC_0(j_compress_ptr cinfo)\n{",
"VncState *vs = cinfo->client_data;",
"Buffer *buffer = &vs->tight_jpeg;",
"buffer->offset = buffer->capacity;",
"buffer_reserve(buffer, 2048);",
"jpeg_init_destination(cinfo);",
"return TRUE;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.