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
sequencelengths 1
2.8k
| label
sequencelengths 1
2.8k
| line_no
sequencelengths 1
2.8k
|
|---|---|---|---|---|---|---|---|---|---|---|
20,493 | static inline void skip_hdr_extension(GetBitContext *gb)
{
int i, len;
do {
len = get_bits(gb, 8);
for (i = 0; i < len; i++) skip_bits(gb, 8);
} while(len);
}
| false | FFmpeg | 103f9c261a68299125b99c542e20f5541051d2c9 | static inline void skip_hdr_extension(GetBitContext *gb)
{
int i, len;
do {
len = get_bits(gb, 8);
for (i = 0; i < len; i++) skip_bits(gb, 8);
} while(len);
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(GetBitContext *VAR_0)
{
int VAR_1, VAR_2;
do {
VAR_2 = get_bits(VAR_0, 8);
for (VAR_1 = 0; VAR_1 < VAR_2; VAR_1++) skip_bits(VAR_0, 8);
} while(VAR_2);
}
| [
"static inline void FUNC_0(GetBitContext *VAR_0)\n{",
"int VAR_1, VAR_2;",
"do {",
"VAR_2 = get_bits(VAR_0, 8);",
"for (VAR_1 = 0; VAR_1 < VAR_2; VAR_1++) skip_bits(VAR_0, 8);",
"} while(VAR_2);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
20,494 | static int nbd_negotiate_options(NBDClient *client)
{
uint32_t flags;
/* Client sends:
[ 0 .. 3] client flags
[ 0 .. 7] NBD_OPTS_MAGIC
[ 8 .. 11] NBD option
[12 .. 15] Data length
... Rest of request
[ 0 .. 7] NBD_OPTS_MAGIC
[ 8 .. 11] Second NBD option
[12 .. 15] Data length
... Rest of request
*/
if (nbd_negotiate_read(client->ioc, &flags, sizeof(flags)) !=
sizeof(flags)) {
LOG("read failed");
return -EIO;
}
TRACE("Checking client flags");
be32_to_cpus(&flags);
if (flags != 0 && flags != NBD_FLAG_C_FIXED_NEWSTYLE) {
LOG("Bad client flags received");
return -EIO;
}
while (1) {
int ret;
uint32_t tmp, length;
uint64_t magic;
if (nbd_negotiate_read(client->ioc, &magic, sizeof(magic)) !=
sizeof(magic)) {
LOG("read failed");
return -EINVAL;
}
TRACE("Checking opts magic");
if (magic != be64_to_cpu(NBD_OPTS_MAGIC)) {
LOG("Bad magic received");
return -EINVAL;
}
if (nbd_negotiate_read(client->ioc, &tmp, sizeof(tmp)) != sizeof(tmp)) {
LOG("read failed");
return -EINVAL;
}
if (nbd_negotiate_read(client->ioc, &length, sizeof(length)) !=
sizeof(length)) {
LOG("read failed");
return -EINVAL;
}
length = be32_to_cpu(length);
TRACE("Checking option");
switch (be32_to_cpu(tmp)) {
case NBD_OPT_LIST:
ret = nbd_negotiate_handle_list(client, length);
if (ret < 0) {
return ret;
}
break;
case NBD_OPT_ABORT:
return -EINVAL;
case NBD_OPT_EXPORT_NAME:
return nbd_negotiate_handle_export_name(client, length);
default:
tmp = be32_to_cpu(tmp);
LOG("Unsupported option 0x%x", tmp);
nbd_negotiate_send_rep(client->ioc, NBD_REP_ERR_UNSUP, tmp);
return -EINVAL;
}
}
}
| false | qemu | 26afa868dbd8641070c0a8d851b082b603c04fa1 | static int nbd_negotiate_options(NBDClient *client)
{
uint32_t flags;
if (nbd_negotiate_read(client->ioc, &flags, sizeof(flags)) !=
sizeof(flags)) {
LOG("read failed");
return -EIO;
}
TRACE("Checking client flags");
be32_to_cpus(&flags);
if (flags != 0 && flags != NBD_FLAG_C_FIXED_NEWSTYLE) {
LOG("Bad client flags received");
return -EIO;
}
while (1) {
int ret;
uint32_t tmp, length;
uint64_t magic;
if (nbd_negotiate_read(client->ioc, &magic, sizeof(magic)) !=
sizeof(magic)) {
LOG("read failed");
return -EINVAL;
}
TRACE("Checking opts magic");
if (magic != be64_to_cpu(NBD_OPTS_MAGIC)) {
LOG("Bad magic received");
return -EINVAL;
}
if (nbd_negotiate_read(client->ioc, &tmp, sizeof(tmp)) != sizeof(tmp)) {
LOG("read failed");
return -EINVAL;
}
if (nbd_negotiate_read(client->ioc, &length, sizeof(length)) !=
sizeof(length)) {
LOG("read failed");
return -EINVAL;
}
length = be32_to_cpu(length);
TRACE("Checking option");
switch (be32_to_cpu(tmp)) {
case NBD_OPT_LIST:
ret = nbd_negotiate_handle_list(client, length);
if (ret < 0) {
return ret;
}
break;
case NBD_OPT_ABORT:
return -EINVAL;
case NBD_OPT_EXPORT_NAME:
return nbd_negotiate_handle_export_name(client, length);
default:
tmp = be32_to_cpu(tmp);
LOG("Unsupported option 0x%x", tmp);
nbd_negotiate_send_rep(client->ioc, NBD_REP_ERR_UNSUP, tmp);
return -EINVAL;
}
}
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(NBDClient *VAR_0)
{
uint32_t flags;
if (nbd_negotiate_read(VAR_0->ioc, &flags, sizeof(flags)) !=
sizeof(flags)) {
LOG("read failed");
return -EIO;
}
TRACE("Checking VAR_0 flags");
be32_to_cpus(&flags);
if (flags != 0 && flags != NBD_FLAG_C_FIXED_NEWSTYLE) {
LOG("Bad VAR_0 flags received");
return -EIO;
}
while (1) {
int VAR_1;
uint32_t tmp, length;
uint64_t magic;
if (nbd_negotiate_read(VAR_0->ioc, &magic, sizeof(magic)) !=
sizeof(magic)) {
LOG("read failed");
return -EINVAL;
}
TRACE("Checking opts magic");
if (magic != be64_to_cpu(NBD_OPTS_MAGIC)) {
LOG("Bad magic received");
return -EINVAL;
}
if (nbd_negotiate_read(VAR_0->ioc, &tmp, sizeof(tmp)) != sizeof(tmp)) {
LOG("read failed");
return -EINVAL;
}
if (nbd_negotiate_read(VAR_0->ioc, &length, sizeof(length)) !=
sizeof(length)) {
LOG("read failed");
return -EINVAL;
}
length = be32_to_cpu(length);
TRACE("Checking option");
switch (be32_to_cpu(tmp)) {
case NBD_OPT_LIST:
VAR_1 = nbd_negotiate_handle_list(VAR_0, length);
if (VAR_1 < 0) {
return VAR_1;
}
break;
case NBD_OPT_ABORT:
return -EINVAL;
case NBD_OPT_EXPORT_NAME:
return nbd_negotiate_handle_export_name(VAR_0, length);
default:
tmp = be32_to_cpu(tmp);
LOG("Unsupported option 0x%x", tmp);
nbd_negotiate_send_rep(VAR_0->ioc, NBD_REP_ERR_UNSUP, tmp);
return -EINVAL;
}
}
}
| [
"static int FUNC_0(NBDClient *VAR_0)\n{",
"uint32_t flags;",
"if (nbd_negotiate_read(VAR_0->ioc, &flags, sizeof(flags)) !=\nsizeof(flags)) {",
"LOG(\"read failed\");",
"return -EIO;",
"}",
"TRACE(\"Checking VAR_0 flags\");",
"be32_to_cpus(&flags);",
"if (flags != 0 && flags != NBD_FLAG_C_FIXED_NEWSTYLE) {",
"LOG(\"Bad VAR_0 flags received\");",
"return -EIO;",
"}",
"while (1) {",
"int VAR_1;",
"uint32_t tmp, length;",
"uint64_t magic;",
"if (nbd_negotiate_read(VAR_0->ioc, &magic, sizeof(magic)) !=\nsizeof(magic)) {",
"LOG(\"read failed\");",
"return -EINVAL;",
"}",
"TRACE(\"Checking opts magic\");",
"if (magic != be64_to_cpu(NBD_OPTS_MAGIC)) {",
"LOG(\"Bad magic received\");",
"return -EINVAL;",
"}",
"if (nbd_negotiate_read(VAR_0->ioc, &tmp, sizeof(tmp)) != sizeof(tmp)) {",
"LOG(\"read failed\");",
"return -EINVAL;",
"}",
"if (nbd_negotiate_read(VAR_0->ioc, &length, sizeof(length)) !=\nsizeof(length)) {",
"LOG(\"read failed\");",
"return -EINVAL;",
"}",
"length = be32_to_cpu(length);",
"TRACE(\"Checking option\");",
"switch (be32_to_cpu(tmp)) {",
"case NBD_OPT_LIST:\nVAR_1 = nbd_negotiate_handle_list(VAR_0, length);",
"if (VAR_1 < 0) {",
"return VAR_1;",
"}",
"break;",
"case NBD_OPT_ABORT:\nreturn -EINVAL;",
"case NBD_OPT_EXPORT_NAME:\nreturn nbd_negotiate_handle_export_name(VAR_0, length);",
"default:\ntmp = be32_to_cpu(tmp);",
"LOG(\"Unsupported option 0x%x\", tmp);",
"nbd_negotiate_send_rep(VAR_0->ioc, NBD_REP_ERR_UNSUP, tmp);",
"return -EINVAL;",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
117
],
[
119
],
[
121,
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
135,
137
],
[
141,
143
],
[
147,
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
]
] |
20,496 | static void pxb_dev_realize(PCIDevice *dev, Error **errp)
{
if (pci_bus_is_express(dev->bus)) {
error_setg(errp, "pxb devices cannot reside on a PCIe bus");
return;
}
pxb_dev_realize_common(dev, false, errp);
}
| false | qemu | fd56e0612b6454a282fa6a953fdb09281a98c589 | static void pxb_dev_realize(PCIDevice *dev, Error **errp)
{
if (pci_bus_is_express(dev->bus)) {
error_setg(errp, "pxb devices cannot reside on a PCIe bus");
return;
}
pxb_dev_realize_common(dev, false, errp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)
{
if (pci_bus_is_express(VAR_0->bus)) {
error_setg(VAR_1, "pxb devices cannot reside on a PCIe bus");
return;
}
pxb_dev_realize_common(VAR_0, false, VAR_1);
}
| [
"static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)\n{",
"if (pci_bus_is_express(VAR_0->bus)) {",
"error_setg(VAR_1, \"pxb devices cannot reside on a PCIe bus\");",
"return;",
"}",
"pxb_dev_realize_common(VAR_0, false, VAR_1);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
]
] |
20,498 | static void gen_arith_imm(DisasContext *ctx, uint32_t opc,
int rt, int rs, int16_t imm)
{
target_ulong uimm = (target_long)imm; /* Sign extend to 32/64 bits */
const char *opn = "imm arith";
if (rt == 0 && opc != OPC_ADDI && opc != OPC_DADDI) {
/* If no destination, treat it as a NOP.
For addi, we must generate the overflow exception when needed. */
MIPS_DEBUG("NOP");
return;
}
switch (opc) {
case OPC_ADDI:
{
TCGv t0 = tcg_temp_local_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
int l1 = gen_new_label();
gen_load_gpr(t1, rs);
tcg_gen_addi_tl(t0, t1, uimm);
tcg_gen_ext32s_tl(t0, t0);
tcg_gen_xori_tl(t1, t1, ~uimm);
tcg_gen_xori_tl(t2, t0, uimm);
tcg_gen_and_tl(t1, t1, t2);
tcg_temp_free(t2);
tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
tcg_temp_free(t1);
/* operands of same sign, result different sign */
generate_exception(ctx, EXCP_OVERFLOW);
gen_set_label(l1);
tcg_gen_ext32s_tl(t0, t0);
gen_store_gpr(t0, rt);
tcg_temp_free(t0);
}
opn = "addi";
break;
case OPC_ADDIU:
if (rs != 0) {
tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
tcg_gen_ext32s_tl(cpu_gpr[rt], cpu_gpr[rt]);
} else {
tcg_gen_movi_tl(cpu_gpr[rt], uimm);
}
opn = "addiu";
break;
#if defined(TARGET_MIPS64)
case OPC_DADDI:
{
TCGv t0 = tcg_temp_local_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
int l1 = gen_new_label();
gen_load_gpr(t1, rs);
tcg_gen_addi_tl(t0, t1, uimm);
tcg_gen_xori_tl(t1, t1, ~uimm);
tcg_gen_xori_tl(t2, t0, uimm);
tcg_gen_and_tl(t1, t1, t2);
tcg_temp_free(t2);
tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
tcg_temp_free(t1);
/* operands of same sign, result different sign */
generate_exception(ctx, EXCP_OVERFLOW);
gen_set_label(l1);
gen_store_gpr(t0, rt);
tcg_temp_free(t0);
}
opn = "daddi";
break;
case OPC_DADDIU:
if (rs != 0) {
tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
} else {
tcg_gen_movi_tl(cpu_gpr[rt], uimm);
}
opn = "daddiu";
break;
#endif
}
(void)opn; /* avoid a compiler warning */
MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
}
| false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 | static void gen_arith_imm(DisasContext *ctx, uint32_t opc,
int rt, int rs, int16_t imm)
{
target_ulong uimm = (target_long)imm;
const char *opn = "imm arith";
if (rt == 0 && opc != OPC_ADDI && opc != OPC_DADDI) {
MIPS_DEBUG("NOP");
return;
}
switch (opc) {
case OPC_ADDI:
{
TCGv t0 = tcg_temp_local_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
int l1 = gen_new_label();
gen_load_gpr(t1, rs);
tcg_gen_addi_tl(t0, t1, uimm);
tcg_gen_ext32s_tl(t0, t0);
tcg_gen_xori_tl(t1, t1, ~uimm);
tcg_gen_xori_tl(t2, t0, uimm);
tcg_gen_and_tl(t1, t1, t2);
tcg_temp_free(t2);
tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
tcg_temp_free(t1);
generate_exception(ctx, EXCP_OVERFLOW);
gen_set_label(l1);
tcg_gen_ext32s_tl(t0, t0);
gen_store_gpr(t0, rt);
tcg_temp_free(t0);
}
opn = "addi";
break;
case OPC_ADDIU:
if (rs != 0) {
tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
tcg_gen_ext32s_tl(cpu_gpr[rt], cpu_gpr[rt]);
} else {
tcg_gen_movi_tl(cpu_gpr[rt], uimm);
}
opn = "addiu";
break;
#if defined(TARGET_MIPS64)
case OPC_DADDI:
{
TCGv t0 = tcg_temp_local_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
int l1 = gen_new_label();
gen_load_gpr(t1, rs);
tcg_gen_addi_tl(t0, t1, uimm);
tcg_gen_xori_tl(t1, t1, ~uimm);
tcg_gen_xori_tl(t2, t0, uimm);
tcg_gen_and_tl(t1, t1, t2);
tcg_temp_free(t2);
tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
tcg_temp_free(t1);
generate_exception(ctx, EXCP_OVERFLOW);
gen_set_label(l1);
gen_store_gpr(t0, rt);
tcg_temp_free(t0);
}
opn = "daddi";
break;
case OPC_DADDIU:
if (rs != 0) {
tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
} else {
tcg_gen_movi_tl(cpu_gpr[rt], uimm);
}
opn = "daddiu";
break;
#endif
}
(void)opn;
MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1,
int VAR_2, int VAR_3, int16_t VAR_4)
{
target_ulong uimm = (target_long)VAR_4;
const char *VAR_5 = "VAR_4 arith";
if (VAR_2 == 0 && VAR_1 != OPC_ADDI && VAR_1 != OPC_DADDI) {
MIPS_DEBUG("NOP");
return;
}
switch (VAR_1) {
case OPC_ADDI:
{
TCGv t0 = tcg_temp_local_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
int VAR_6 = gen_new_label();
gen_load_gpr(t1, VAR_3);
tcg_gen_addi_tl(t0, t1, uimm);
tcg_gen_ext32s_tl(t0, t0);
tcg_gen_xori_tl(t1, t1, ~uimm);
tcg_gen_xori_tl(t2, t0, uimm);
tcg_gen_and_tl(t1, t1, t2);
tcg_temp_free(t2);
tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, VAR_6);
tcg_temp_free(t1);
generate_exception(VAR_0, EXCP_OVERFLOW);
gen_set_label(VAR_6);
tcg_gen_ext32s_tl(t0, t0);
gen_store_gpr(t0, VAR_2);
tcg_temp_free(t0);
}
VAR_5 = "addi";
break;
case OPC_ADDIU:
if (VAR_3 != 0) {
tcg_gen_addi_tl(cpu_gpr[VAR_2], cpu_gpr[VAR_3], uimm);
tcg_gen_ext32s_tl(cpu_gpr[VAR_2], cpu_gpr[VAR_2]);
} else {
tcg_gen_movi_tl(cpu_gpr[VAR_2], uimm);
}
VAR_5 = "addiu";
break;
#if defined(TARGET_MIPS64)
case OPC_DADDI:
{
TCGv t0 = tcg_temp_local_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
int VAR_6 = gen_new_label();
gen_load_gpr(t1, VAR_3);
tcg_gen_addi_tl(t0, t1, uimm);
tcg_gen_xori_tl(t1, t1, ~uimm);
tcg_gen_xori_tl(t2, t0, uimm);
tcg_gen_and_tl(t1, t1, t2);
tcg_temp_free(t2);
tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, VAR_6);
tcg_temp_free(t1);
generate_exception(VAR_0, EXCP_OVERFLOW);
gen_set_label(VAR_6);
gen_store_gpr(t0, VAR_2);
tcg_temp_free(t0);
}
VAR_5 = "daddi";
break;
case OPC_DADDIU:
if (VAR_3 != 0) {
tcg_gen_addi_tl(cpu_gpr[VAR_2], cpu_gpr[VAR_3], uimm);
} else {
tcg_gen_movi_tl(cpu_gpr[VAR_2], uimm);
}
VAR_5 = "daddiu";
break;
#endif
}
(void)VAR_5;
MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, VAR_5, regnames[VAR_2], regnames[VAR_3], uimm);
}
| [
"static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1,\nint VAR_2, int VAR_3, int16_t VAR_4)\n{",
"target_ulong uimm = (target_long)VAR_4;",
"const char *VAR_5 = \"VAR_4 arith\";",
"if (VAR_2 == 0 && VAR_1 != OPC_ADDI && VAR_1 != OPC_DADDI) {",
"MIPS_DEBUG(\"NOP\");",
"return;",
"}",
"switch (VAR_1) {",
"case OPC_ADDI:\n{",
"TCGv t0 = tcg_temp_local_new();",
"TCGv t1 = tcg_temp_new();",
"TCGv t2 = tcg_temp_new();",
"int VAR_6 = gen_new_label();",
"gen_load_gpr(t1, VAR_3);",
"tcg_gen_addi_tl(t0, t1, uimm);",
"tcg_gen_ext32s_tl(t0, t0);",
"tcg_gen_xori_tl(t1, t1, ~uimm);",
"tcg_gen_xori_tl(t2, t0, uimm);",
"tcg_gen_and_tl(t1, t1, t2);",
"tcg_temp_free(t2);",
"tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, VAR_6);",
"tcg_temp_free(t1);",
"generate_exception(VAR_0, EXCP_OVERFLOW);",
"gen_set_label(VAR_6);",
"tcg_gen_ext32s_tl(t0, t0);",
"gen_store_gpr(t0, VAR_2);",
"tcg_temp_free(t0);",
"}",
"VAR_5 = \"addi\";",
"break;",
"case OPC_ADDIU:\nif (VAR_3 != 0) {",
"tcg_gen_addi_tl(cpu_gpr[VAR_2], cpu_gpr[VAR_3], uimm);",
"tcg_gen_ext32s_tl(cpu_gpr[VAR_2], cpu_gpr[VAR_2]);",
"} else {",
"tcg_gen_movi_tl(cpu_gpr[VAR_2], uimm);",
"}",
"VAR_5 = \"addiu\";",
"break;",
"#if defined(TARGET_MIPS64)\ncase OPC_DADDI:\n{",
"TCGv t0 = tcg_temp_local_new();",
"TCGv t1 = tcg_temp_new();",
"TCGv t2 = tcg_temp_new();",
"int VAR_6 = gen_new_label();",
"gen_load_gpr(t1, VAR_3);",
"tcg_gen_addi_tl(t0, t1, uimm);",
"tcg_gen_xori_tl(t1, t1, ~uimm);",
"tcg_gen_xori_tl(t2, t0, uimm);",
"tcg_gen_and_tl(t1, t1, t2);",
"tcg_temp_free(t2);",
"tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, VAR_6);",
"tcg_temp_free(t1);",
"generate_exception(VAR_0, EXCP_OVERFLOW);",
"gen_set_label(VAR_6);",
"gen_store_gpr(t0, VAR_2);",
"tcg_temp_free(t0);",
"}",
"VAR_5 = \"daddi\";",
"break;",
"case OPC_DADDIU:\nif (VAR_3 != 0) {",
"tcg_gen_addi_tl(cpu_gpr[VAR_2], cpu_gpr[VAR_3], uimm);",
"} else {",
"tcg_gen_movi_tl(cpu_gpr[VAR_2], uimm);",
"}",
"VAR_5 = \"daddiu\";",
"break;",
"#endif\n}",
"(void)VAR_5;",
"MIPS_DEBUG(\"%s %s, %s, \" TARGET_FMT_lx, VAR_5, regnames[VAR_2], regnames[VAR_3], uimm);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
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
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147,
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163,
165
],
[
167
],
[
169
],
[
171
]
] |
20,499 | CPUCRISState *cpu_cris_init (const char *cpu_model)
{
CPUCRISState *env;
static int tcg_initialized = 0;
int i;
env = qemu_mallocz(sizeof(CPUCRISState));
if (!env)
return NULL;
cpu_exec_init(env);
cpu_reset(env);
if (tcg_initialized)
return env;
tcg_initialized = 1;
cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, "env");
cc_x = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_x), "cc_x");
cc_src = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_src), "cc_src");
cc_dest = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_dest),
"cc_dest");
cc_result = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_result),
"cc_result");
cc_op = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_op), "cc_op");
cc_size = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_size),
"cc_size");
cc_mask = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_mask),
"cc_mask");
env_pc = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, pc),
"pc");
env_btarget = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, btarget),
"btarget");
env_btaken = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, btaken),
"btaken");
for (i = 0; i < 16; i++) {
cpu_R[i] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, regs[i]),
regnames[i]);
}
for (i = 0; i < 16; i++) {
cpu_PR[i] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, pregs[i]),
pregnames[i]);
}
TCG_HELPER(helper_raise_exception);
TCG_HELPER(helper_dump);
TCG_HELPER(helper_tlb_flush_pid);
TCG_HELPER(helper_movl_sreg_reg);
TCG_HELPER(helper_movl_reg_sreg);
TCG_HELPER(helper_rfe);
TCG_HELPER(helper_rfn);
TCG_HELPER(helper_evaluate_flags_muls);
TCG_HELPER(helper_evaluate_flags_mulu);
TCG_HELPER(helper_evaluate_flags_mcp);
TCG_HELPER(helper_evaluate_flags_alu_4);
TCG_HELPER(helper_evaluate_flags_move_4);
TCG_HELPER(helper_evaluate_flags_move_2);
TCG_HELPER(helper_evaluate_flags);
TCG_HELPER(helper_top_evaluate_flags);
return env;
}
| false | qemu | a7812ae412311d7d47f8aa85656faadac9d64b56 | CPUCRISState *cpu_cris_init (const char *cpu_model)
{
CPUCRISState *env;
static int tcg_initialized = 0;
int i;
env = qemu_mallocz(sizeof(CPUCRISState));
if (!env)
return NULL;
cpu_exec_init(env);
cpu_reset(env);
if (tcg_initialized)
return env;
tcg_initialized = 1;
cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, "env");
cc_x = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_x), "cc_x");
cc_src = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_src), "cc_src");
cc_dest = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_dest),
"cc_dest");
cc_result = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_result),
"cc_result");
cc_op = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_op), "cc_op");
cc_size = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_size),
"cc_size");
cc_mask = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_mask),
"cc_mask");
env_pc = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, pc),
"pc");
env_btarget = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, btarget),
"btarget");
env_btaken = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, btaken),
"btaken");
for (i = 0; i < 16; i++) {
cpu_R[i] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, regs[i]),
regnames[i]);
}
for (i = 0; i < 16; i++) {
cpu_PR[i] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, pregs[i]),
pregnames[i]);
}
TCG_HELPER(helper_raise_exception);
TCG_HELPER(helper_dump);
TCG_HELPER(helper_tlb_flush_pid);
TCG_HELPER(helper_movl_sreg_reg);
TCG_HELPER(helper_movl_reg_sreg);
TCG_HELPER(helper_rfe);
TCG_HELPER(helper_rfn);
TCG_HELPER(helper_evaluate_flags_muls);
TCG_HELPER(helper_evaluate_flags_mulu);
TCG_HELPER(helper_evaluate_flags_mcp);
TCG_HELPER(helper_evaluate_flags_alu_4);
TCG_HELPER(helper_evaluate_flags_move_4);
TCG_HELPER(helper_evaluate_flags_move_2);
TCG_HELPER(helper_evaluate_flags);
TCG_HELPER(helper_top_evaluate_flags);
return env;
}
| {
"code": [],
"line_no": []
} | CPUCRISState *FUNC_0 (const char *cpu_model)
{
CPUCRISState *env;
static int VAR_0 = 0;
int VAR_1;
env = qemu_mallocz(sizeof(CPUCRISState));
if (!env)
return NULL;
cpu_exec_init(env);
cpu_reset(env);
if (VAR_0)
return env;
VAR_0 = 1;
cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, "env");
cc_x = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_x), "cc_x");
cc_src = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_src), "cc_src");
cc_dest = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_dest),
"cc_dest");
cc_result = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_result),
"cc_result");
cc_op = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_op), "cc_op");
cc_size = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_size),
"cc_size");
cc_mask = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, cc_mask),
"cc_mask");
env_pc = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, pc),
"pc");
env_btarget = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, btarget),
"btarget");
env_btaken = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, btaken),
"btaken");
for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {
cpu_R[VAR_1] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, regs[VAR_1]),
regnames[VAR_1]);
}
for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {
cpu_PR[VAR_1] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,
offsetof(CPUState, pregs[VAR_1]),
pregnames[VAR_1]);
}
TCG_HELPER(helper_raise_exception);
TCG_HELPER(helper_dump);
TCG_HELPER(helper_tlb_flush_pid);
TCG_HELPER(helper_movl_sreg_reg);
TCG_HELPER(helper_movl_reg_sreg);
TCG_HELPER(helper_rfe);
TCG_HELPER(helper_rfn);
TCG_HELPER(helper_evaluate_flags_muls);
TCG_HELPER(helper_evaluate_flags_mulu);
TCG_HELPER(helper_evaluate_flags_mcp);
TCG_HELPER(helper_evaluate_flags_alu_4);
TCG_HELPER(helper_evaluate_flags_move_4);
TCG_HELPER(helper_evaluate_flags_move_2);
TCG_HELPER(helper_evaluate_flags);
TCG_HELPER(helper_top_evaluate_flags);
return env;
}
| [
"CPUCRISState *FUNC_0 (const char *cpu_model)\n{",
"CPUCRISState *env;",
"static int VAR_0 = 0;",
"int VAR_1;",
"env = qemu_mallocz(sizeof(CPUCRISState));",
"if (!env)\nreturn NULL;",
"cpu_exec_init(env);",
"cpu_reset(env);",
"if (VAR_0)\nreturn env;",
"VAR_0 = 1;",
"cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, \"env\");",
"cc_x = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_x), \"cc_x\");",
"cc_src = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_src), \"cc_src\");",
"cc_dest = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_dest),\n\"cc_dest\");",
"cc_result = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_result),\n\"cc_result\");",
"cc_op = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_op), \"cc_op\");",
"cc_size = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_size),\n\"cc_size\");",
"cc_mask = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, cc_mask),\n\"cc_mask\");",
"env_pc = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, pc),\n\"pc\");",
"env_btarget = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, btarget),\n\"btarget\");",
"env_btaken = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, btaken),\n\"btaken\");",
"for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {",
"cpu_R[VAR_1] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, regs[VAR_1]),\nregnames[VAR_1]);",
"}",
"for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {",
"cpu_PR[VAR_1] = tcg_global_mem_new(TCG_TYPE_TL, TCG_AREG0,\noffsetof(CPUState, pregs[VAR_1]),\npregnames[VAR_1]);",
"}",
"TCG_HELPER(helper_raise_exception);",
"TCG_HELPER(helper_dump);",
"TCG_HELPER(helper_tlb_flush_pid);",
"TCG_HELPER(helper_movl_sreg_reg);",
"TCG_HELPER(helper_movl_reg_sreg);",
"TCG_HELPER(helper_rfe);",
"TCG_HELPER(helper_rfn);",
"TCG_HELPER(helper_evaluate_flags_muls);",
"TCG_HELPER(helper_evaluate_flags_mulu);",
"TCG_HELPER(helper_evaluate_flags_mcp);",
"TCG_HELPER(helper_evaluate_flags_alu_4);",
"TCG_HELPER(helper_evaluate_flags_move_4);",
"TCG_HELPER(helper_evaluate_flags_move_2);",
"TCG_HELPER(helper_evaluate_flags);",
"TCG_HELPER(helper_top_evaluate_flags);",
"return env;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
23
],
[
27,
29
],
[
33
],
[
37
],
[
39,
41
],
[
43,
45
],
[
47,
49,
51
],
[
53,
55,
57
],
[
59,
61
],
[
63,
65,
67
],
[
69,
71,
73
],
[
77,
79,
81
],
[
83,
85,
87
],
[
89,
91,
93
],
[
95
],
[
97,
99,
101
],
[
103
],
[
105
],
[
107,
109,
111
],
[
113
],
[
117
],
[
119
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
]
] |
20,500 | static void pxa2xx_lcdc_dma0_redraw_rot180(PXA2xxLCDState *s,
hwaddr addr, int *miny, int *maxy)
{
DisplaySurface *surface = qemu_console_surface(s->con);
int src_width, dest_width;
drawfn fn = NULL;
if (s->dest_width) {
fn = s->line_fn[s->transp][s->bpp];
}
if (!fn) {
return;
}
src_width = (s->xres + 3) & ~3; /* Pad to a 4 pixels multiple */
if (s->bpp == pxa_lcdc_19pbpp || s->bpp == pxa_lcdc_18pbpp) {
src_width *= 3;
} else if (s->bpp > pxa_lcdc_16bpp) {
src_width *= 4;
} else if (s->bpp > pxa_lcdc_8bpp) {
src_width *= 2;
}
dest_width = s->xres * s->dest_width;
*miny = 0;
framebuffer_update_display(surface, s->sysmem,
addr, s->xres, s->yres,
src_width, -dest_width, -s->dest_width,
s->invalidated,
fn, s->dma_ch[0].palette, miny, maxy);
}
| false | qemu | c1076c3e13a86140cc2ba29866512df8460cc7c2 | static void pxa2xx_lcdc_dma0_redraw_rot180(PXA2xxLCDState *s,
hwaddr addr, int *miny, int *maxy)
{
DisplaySurface *surface = qemu_console_surface(s->con);
int src_width, dest_width;
drawfn fn = NULL;
if (s->dest_width) {
fn = s->line_fn[s->transp][s->bpp];
}
if (!fn) {
return;
}
src_width = (s->xres + 3) & ~3;
if (s->bpp == pxa_lcdc_19pbpp || s->bpp == pxa_lcdc_18pbpp) {
src_width *= 3;
} else if (s->bpp > pxa_lcdc_16bpp) {
src_width *= 4;
} else if (s->bpp > pxa_lcdc_8bpp) {
src_width *= 2;
}
dest_width = s->xres * s->dest_width;
*miny = 0;
framebuffer_update_display(surface, s->sysmem,
addr, s->xres, s->yres,
src_width, -dest_width, -s->dest_width,
s->invalidated,
fn, s->dma_ch[0].palette, miny, maxy);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PXA2xxLCDState *VAR_0,
hwaddr VAR_1, int *VAR_2, int *VAR_3)
{
DisplaySurface *surface = qemu_console_surface(VAR_0->con);
int VAR_4, VAR_5;
drawfn fn = NULL;
if (VAR_0->VAR_5) {
fn = VAR_0->line_fn[VAR_0->transp][VAR_0->bpp];
}
if (!fn) {
return;
}
VAR_4 = (VAR_0->xres + 3) & ~3;
if (VAR_0->bpp == pxa_lcdc_19pbpp || VAR_0->bpp == pxa_lcdc_18pbpp) {
VAR_4 *= 3;
} else if (VAR_0->bpp > pxa_lcdc_16bpp) {
VAR_4 *= 4;
} else if (VAR_0->bpp > pxa_lcdc_8bpp) {
VAR_4 *= 2;
}
VAR_5 = VAR_0->xres * VAR_0->VAR_5;
*VAR_2 = 0;
framebuffer_update_display(surface, VAR_0->sysmem,
VAR_1, VAR_0->xres, VAR_0->yres,
VAR_4, -VAR_5, -VAR_0->VAR_5,
VAR_0->invalidated,
fn, VAR_0->dma_ch[0].palette, VAR_2, VAR_3);
}
| [
"static void FUNC_0(PXA2xxLCDState *VAR_0,\nhwaddr VAR_1, int *VAR_2, int *VAR_3)\n{",
"DisplaySurface *surface = qemu_console_surface(VAR_0->con);",
"int VAR_4, VAR_5;",
"drawfn fn = NULL;",
"if (VAR_0->VAR_5) {",
"fn = VAR_0->line_fn[VAR_0->transp][VAR_0->bpp];",
"}",
"if (!fn) {",
"return;",
"}",
"VAR_4 = (VAR_0->xres + 3) & ~3;",
"if (VAR_0->bpp == pxa_lcdc_19pbpp || VAR_0->bpp == pxa_lcdc_18pbpp) {",
"VAR_4 *= 3;",
"} else if (VAR_0->bpp > pxa_lcdc_16bpp) {",
"VAR_4 *= 4;",
"} else if (VAR_0->bpp > pxa_lcdc_8bpp) {",
"VAR_4 *= 2;",
"}",
"VAR_5 = VAR_0->xres * VAR_0->VAR_5;",
"*VAR_2 = 0;",
"framebuffer_update_display(surface, VAR_0->sysmem,\nVAR_1, VAR_0->xres, VAR_0->yres,\nVAR_4, -VAR_5, -VAR_0->VAR_5,\nVAR_0->invalidated,\nfn, VAR_0->dma_ch[0].palette, VAR_2, VAR_3);",
"}"
] | [
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
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49,
51,
53,
55,
57
],
[
59
]
] |
20,501 | static void gen_compute_branch(DisasContext *ctx, uint32_t opc, int r1,
int r2 , int32_t constant , int32_t offset)
{
TCGv temp, temp2;
int n;
switch (opc) {
/* SB-format jumps */
case OPC1_16_SB_J:
case OPC1_32_B_J:
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_32_B_CALL:
case OPC1_16_SB_CALL:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_16_SB_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], 0, offset);
break;
case OPC1_16_SB_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], 0, offset);
break;
/* SBC-format jumps */
case OPC1_16_SBC_JEQ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant, offset);
break;
case OPC1_16_SBC_JNE:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], constant, offset);
break;
/* SBRN-format jumps */
case OPC1_16_SBRN_JZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
tcg_temp_free(temp);
break;
case OPC1_16_SBRN_JNZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
tcg_temp_free(temp);
break;
/* SBR-format jumps */
case OPC1_16_SBR_JEQ:
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNE:
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JNZ_A:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_JGEZ:
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JGTZ:
gen_branch_condi(ctx, TCG_COND_GT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLEZ:
gen_branch_condi(ctx, TCG_COND_LE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLTZ:
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ_A:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_LOOP:
gen_loop(ctx, r1, offset * 2 - 32);
break;
/* SR-format jumps */
case OPC1_16_SR_JI:
tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], 0xfffffffe);
tcg_gen_exit_tb(0);
break;
case OPC2_32_SYS_RET:
case OPC2_16_SR_RET:
gen_helper_ret(cpu_env);
tcg_gen_exit_tb(0);
break;
/* B-format */
case OPC1_32_B_CALLA:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JLA:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
/* fall through */
case OPC1_32_B_JA:
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JL:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
/* BOL format */
case OPCM_32_BRC_EQ_NEQ:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JEQ) {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], constant, offset);
} else {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], constant, offset);
}
break;
case OPCM_32_BRC_GE:
if (MASK_OP_BRC_OP2(ctx->opcode) == OP2_32_BRC_JGE) {
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_GEU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JLT:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JLT) {
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_LTU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JNE:
temp = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* subi is unconditional */
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* addi is unconditional */
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
}
tcg_temp_free(temp);
break;
/* BRN format */
case OPCM_32_BRN_JTT:
n = MASK_OP_BRN_N(ctx->opcode);
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[r1], (1 << n));
if (MASK_OP_BRN_OP2(ctx->opcode) == OPC2_32_BRN_JNZ_T) {
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
}
tcg_temp_free(temp);
break;
/* BRR Format */
case OPCM_32_BRR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_ADDR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ_A) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
}
break;
case OPCM_32_BRR_GE:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JGE) {
gen_branch_cond(ctx, TCG_COND_GE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_GEU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_JLT:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JLT) {
gen_branch_cond(ctx, TCG_COND_LT, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_LTU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_LOOP:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_LOOP) {
gen_loop(ctx, r1, offset * 2);
} else {
/* OPC2_32_BRR_LOOPU */
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
}
break;
case OPCM_32_BRR_JNE:
temp = tcg_temp_new();
temp2 = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRR_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* also save r2, in case of r1 == r2, so r2 is not decremented */
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
/* subi is unconditional */
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* also save r2, in case of r1 == r2, so r2 is not decremented */
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
/* addi is unconditional */
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
}
tcg_temp_free(temp);
tcg_temp_free(temp2);
break;
case OPCM_32_BRR_JNZ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JNZ_A) {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
}
break;
default:
printf("Branch Error at %x\n", ctx->pc);
}
ctx->bstate = BS_BRANCH;
}
| false | qemu | 250ef8c76861c756354ed1c67f0a4524e5339369 | static void gen_compute_branch(DisasContext *ctx, uint32_t opc, int r1,
int r2 , int32_t constant , int32_t offset)
{
TCGv temp, temp2;
int n;
switch (opc) {
case OPC1_16_SB_J:
case OPC1_32_B_J:
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_32_B_CALL:
case OPC1_16_SB_CALL:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_16_SB_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], 0, offset);
break;
case OPC1_16_SB_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], 0, offset);
break;
case OPC1_16_SBC_JEQ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant, offset);
break;
case OPC1_16_SBC_JNE:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], constant, offset);
break;
case OPC1_16_SBRN_JZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
tcg_temp_free(temp);
break;
case OPC1_16_SBRN_JNZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
tcg_temp_free(temp);
break;
case OPC1_16_SBR_JEQ:
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNE:
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JNZ_A:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_JGEZ:
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JGTZ:
gen_branch_condi(ctx, TCG_COND_GT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLEZ:
gen_branch_condi(ctx, TCG_COND_LE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLTZ:
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ_A:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_LOOP:
gen_loop(ctx, r1, offset * 2 - 32);
break;
case OPC1_16_SR_JI:
tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], 0xfffffffe);
tcg_gen_exit_tb(0);
break;
case OPC2_32_SYS_RET:
case OPC2_16_SR_RET:
gen_helper_ret(cpu_env);
tcg_gen_exit_tb(0);
break;
case OPC1_32_B_CALLA:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JLA:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
case OPC1_32_B_JA:
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JL:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPCM_32_BRC_EQ_NEQ:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JEQ) {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], constant, offset);
} else {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], constant, offset);
}
break;
case OPCM_32_BRC_GE:
if (MASK_OP_BRC_OP2(ctx->opcode) == OP2_32_BRC_JGE) {
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_GEU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JLT:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JLT) {
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_LTU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JNE:
temp = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRN_JTT:
n = MASK_OP_BRN_N(ctx->opcode);
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[r1], (1 << n));
if (MASK_OP_BRN_OP2(ctx->opcode) == OPC2_32_BRN_JNZ_T) {
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_ADDR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ_A) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
}
break;
case OPCM_32_BRR_GE:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JGE) {
gen_branch_cond(ctx, TCG_COND_GE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_GEU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_JLT:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JLT) {
gen_branch_cond(ctx, TCG_COND_LT, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_LTU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_LOOP:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_LOOP) {
gen_loop(ctx, r1, offset * 2);
} else {
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
}
break;
case OPCM_32_BRR_JNE:
temp = tcg_temp_new();
temp2 = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRR_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
}
tcg_temp_free(temp);
tcg_temp_free(temp2);
break;
case OPCM_32_BRR_JNZ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JNZ_A) {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
}
break;
default:
printf("Branch Error at %x\n", ctx->pc);
}
ctx->bstate = BS_BRANCH;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, int VAR_2,
int VAR_3 , int32_t VAR_4 , int32_t VAR_5)
{
TCGv temp, temp2;
int VAR_6;
switch (VAR_1) {
case OPC1_16_SB_J:
case OPC1_32_B_J:
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPC1_32_B_CALL:
case OPC1_16_SB_CALL:
gen_helper_1arg(call, VAR_0->next_pc);
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPC1_16_SB_JZ:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[15], 0, VAR_5);
break;
case OPC1_16_SB_JNZ:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[15], 0, VAR_5);
break;
case OPC1_16_SBC_JEQ:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[15], VAR_4, VAR_5);
break;
case OPC1_16_SBC_JNE:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[15], VAR_4, VAR_5);
break;
case OPC1_16_SBRN_JZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << VAR_4);
gen_branch_condi(VAR_0, TCG_COND_EQ, temp, 0, VAR_5);
tcg_temp_free(temp);
break;
case OPC1_16_SBRN_JNZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << VAR_4);
gen_branch_condi(VAR_0, TCG_COND_NE, temp, 0, VAR_5);
tcg_temp_free(temp);
break;
case OPC1_16_SBR_JEQ:
gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], cpu_gpr_d[15],
VAR_5);
break;
case OPC1_16_SBR_JNE:
gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], cpu_gpr_d[15],
VAR_5);
break;
case OPC1_16_SBR_JNZ:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JNZ_A:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JGEZ:
gen_branch_condi(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JGTZ:
gen_branch_condi(VAR_0, TCG_COND_GT, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JLEZ:
gen_branch_condi(VAR_0, TCG_COND_LE, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JLTZ:
gen_branch_condi(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JZ:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JZ_A:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_LOOP:
gen_loop(VAR_0, VAR_2, VAR_5 * 2 - 32);
break;
case OPC1_16_SR_JI:
tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[VAR_2], 0xfffffffe);
tcg_gen_exit_tb(0);
break;
case OPC2_32_SYS_RET:
case OPC2_16_SR_RET:
gen_helper_ret(cpu_env);
tcg_gen_exit_tb(0);
break;
case OPC1_32_B_CALLA:
gen_helper_1arg(call, VAR_0->next_pc);
gen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));
break;
case OPC1_32_B_JLA:
tcg_gen_movi_tl(cpu_gpr_a[11], VAR_0->next_pc);
case OPC1_32_B_JA:
gen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));
break;
case OPC1_32_B_JL:
tcg_gen_movi_tl(cpu_gpr_a[11], VAR_0->next_pc);
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPCM_32_BRC_EQ_NEQ:
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JEQ) {
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
} else {
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
}
break;
case OPCM_32_BRC_GE:
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OP2_32_BRC_JGE) {
gen_branch_condi(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
} else {
VAR_4 = MASK_OP_BRC_CONST4(VAR_0->opcode);
gen_branch_condi(VAR_0, TCG_COND_GEU, cpu_gpr_d[VAR_2], VAR_4,
VAR_5);
}
break;
case OPCM_32_BRC_JLT:
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JLT) {
gen_branch_condi(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
} else {
VAR_4 = MASK_OP_BRC_CONST4(VAR_0->opcode);
gen_branch_condi(VAR_0, TCG_COND_LTU, cpu_gpr_d[VAR_2], VAR_4,
VAR_5);
}
break;
case OPCM_32_BRC_JNE:
temp = tcg_temp_new();
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_subi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_condi(VAR_0, TCG_COND_NE, temp, VAR_4, VAR_5);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_addi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_condi(VAR_0, TCG_COND_NE, temp, VAR_4, VAR_5);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRN_JTT:
VAR_6 = MASK_OP_BRN_N(VAR_0->opcode);
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[VAR_2], (1 << VAR_6));
if (MASK_OP_BRN_OP2(VAR_0->opcode) == OPC2_32_BRN_JNZ_T) {
gen_branch_condi(VAR_0, TCG_COND_NE, temp, 0, VAR_5);
} else {
gen_branch_condi(VAR_0, TCG_COND_EQ, temp, 0, VAR_5);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRR_EQ_NEQ:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JEQ) {
gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_ADDR_EQ_NEQ:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JEQ_A) {
gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], cpu_gpr_a[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], cpu_gpr_a[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_GE:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JGE) {
gen_branch_cond(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_GEU, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_JLT:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JLT) {
gen_branch_cond(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_LTU, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_LOOP:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_LOOP) {
gen_loop(VAR_0, VAR_2, VAR_5 * 2);
} else {
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
}
break;
case OPCM_32_BRR_JNE:
temp = tcg_temp_new();
temp2 = tcg_temp_new();
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRR_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[VAR_3]);
tcg_gen_subi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_cond(VAR_0, TCG_COND_NE, temp, temp2, VAR_5);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[VAR_3]);
tcg_gen_addi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_cond(VAR_0, TCG_COND_NE, temp, temp2, VAR_5);
}
tcg_temp_free(temp);
tcg_temp_free(temp2);
break;
case OPCM_32_BRR_JNZ:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JNZ_A) {
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], 0, VAR_5);
} else {
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], 0, VAR_5);
}
break;
default:
printf("Branch Error at %x\VAR_6", VAR_0->pc);
}
VAR_0->bstate = BS_BRANCH;
}
| [
"static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, int VAR_2,\nint VAR_3 , int32_t VAR_4 , int32_t VAR_5)\n{",
"TCGv temp, temp2;",
"int VAR_6;",
"switch (VAR_1) {",
"case OPC1_16_SB_J:\ncase OPC1_32_B_J:\ngen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);",
"break;",
"case OPC1_32_B_CALL:\ncase OPC1_16_SB_CALL:\ngen_helper_1arg(call, VAR_0->next_pc);",
"gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);",
"break;",
"case OPC1_16_SB_JZ:\ngen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[15], 0, VAR_5);",
"break;",
"case OPC1_16_SB_JNZ:\ngen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[15], 0, VAR_5);",
"break;",
"case OPC1_16_SBC_JEQ:\ngen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[15], VAR_4, VAR_5);",
"break;",
"case OPC1_16_SBC_JNE:\ngen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[15], VAR_4, VAR_5);",
"break;",
"case OPC1_16_SBRN_JZ_T:\ntemp = tcg_temp_new();",
"tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << VAR_4);",
"gen_branch_condi(VAR_0, TCG_COND_EQ, temp, 0, VAR_5);",
"tcg_temp_free(temp);",
"break;",
"case OPC1_16_SBRN_JNZ_T:\ntemp = tcg_temp_new();",
"tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << VAR_4);",
"gen_branch_condi(VAR_0, TCG_COND_NE, temp, 0, VAR_5);",
"tcg_temp_free(temp);",
"break;",
"case OPC1_16_SBR_JEQ:\ngen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], cpu_gpr_d[15],\nVAR_5);",
"break;",
"case OPC1_16_SBR_JNE:\ngen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], cpu_gpr_d[15],\nVAR_5);",
"break;",
"case OPC1_16_SBR_JNZ:\ngen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JNZ_A:\ngen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JGEZ:\ngen_branch_condi(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JGTZ:\ngen_branch_condi(VAR_0, TCG_COND_GT, cpu_gpr_d[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JLEZ:\ngen_branch_condi(VAR_0, TCG_COND_LE, cpu_gpr_d[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JLTZ:\ngen_branch_condi(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JZ:\ngen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_JZ_A:\ngen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], 0, VAR_5);",
"break;",
"case OPC1_16_SBR_LOOP:\ngen_loop(VAR_0, VAR_2, VAR_5 * 2 - 32);",
"break;",
"case OPC1_16_SR_JI:\ntcg_gen_andi_tl(cpu_PC, cpu_gpr_a[VAR_2], 0xfffffffe);",
"tcg_gen_exit_tb(0);",
"break;",
"case OPC2_32_SYS_RET:\ncase OPC2_16_SR_RET:\ngen_helper_ret(cpu_env);",
"tcg_gen_exit_tb(0);",
"break;",
"case OPC1_32_B_CALLA:\ngen_helper_1arg(call, VAR_0->next_pc);",
"gen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));",
"break;",
"case OPC1_32_B_JLA:\ntcg_gen_movi_tl(cpu_gpr_a[11], VAR_0->next_pc);",
"case OPC1_32_B_JA:\ngen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));",
"break;",
"case OPC1_32_B_JL:\ntcg_gen_movi_tl(cpu_gpr_a[11], VAR_0->next_pc);",
"gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);",
"break;",
"case OPCM_32_BRC_EQ_NEQ:\nif (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JEQ) {",
"gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], VAR_4, VAR_5);",
"} else {",
"gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], VAR_4, VAR_5);",
"}",
"break;",
"case OPCM_32_BRC_GE:\nif (MASK_OP_BRC_OP2(VAR_0->opcode) == OP2_32_BRC_JGE) {",
"gen_branch_condi(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], VAR_4, VAR_5);",
"} else {",
"VAR_4 = MASK_OP_BRC_CONST4(VAR_0->opcode);",
"gen_branch_condi(VAR_0, TCG_COND_GEU, cpu_gpr_d[VAR_2], VAR_4,\nVAR_5);",
"}",
"break;",
"case OPCM_32_BRC_JLT:\nif (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JLT) {",
"gen_branch_condi(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], VAR_4, VAR_5);",
"} else {",
"VAR_4 = MASK_OP_BRC_CONST4(VAR_0->opcode);",
"gen_branch_condi(VAR_0, TCG_COND_LTU, cpu_gpr_d[VAR_2], VAR_4,\nVAR_5);",
"}",
"break;",
"case OPCM_32_BRC_JNE:\ntemp = tcg_temp_new();",
"if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JNED) {",
"tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);",
"tcg_gen_subi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);",
"gen_branch_condi(VAR_0, TCG_COND_NE, temp, VAR_4, VAR_5);",
"} else {",
"tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);",
"tcg_gen_addi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);",
"gen_branch_condi(VAR_0, TCG_COND_NE, temp, VAR_4, VAR_5);",
"}",
"tcg_temp_free(temp);",
"break;",
"case OPCM_32_BRN_JTT:\nVAR_6 = MASK_OP_BRN_N(VAR_0->opcode);",
"temp = tcg_temp_new();",
"tcg_gen_andi_tl(temp, cpu_gpr_d[VAR_2], (1 << VAR_6));",
"if (MASK_OP_BRN_OP2(VAR_0->opcode) == OPC2_32_BRN_JNZ_T) {",
"gen_branch_condi(VAR_0, TCG_COND_NE, temp, 0, VAR_5);",
"} else {",
"gen_branch_condi(VAR_0, TCG_COND_EQ, temp, 0, VAR_5);",
"}",
"tcg_temp_free(temp);",
"break;",
"case OPCM_32_BRR_EQ_NEQ:\nif (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JEQ) {",
"gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],\nVAR_5);",
"} else {",
"gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],\nVAR_5);",
"}",
"break;",
"case OPCM_32_BRR_ADDR_EQ_NEQ:\nif (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JEQ_A) {",
"gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], cpu_gpr_a[VAR_3],\nVAR_5);",
"} else {",
"gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], cpu_gpr_a[VAR_3],\nVAR_5);",
"}",
"break;",
"case OPCM_32_BRR_GE:\nif (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JGE) {",
"gen_branch_cond(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],\nVAR_5);",
"} else {",
"gen_branch_cond(VAR_0, TCG_COND_GEU, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],\nVAR_5);",
"}",
"break;",
"case OPCM_32_BRR_JLT:\nif (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JLT) {",
"gen_branch_cond(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],\nVAR_5);",
"} else {",
"gen_branch_cond(VAR_0, TCG_COND_LTU, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],\nVAR_5);",
"}",
"break;",
"case OPCM_32_BRR_LOOP:\nif (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_LOOP) {",
"gen_loop(VAR_0, VAR_2, VAR_5 * 2);",
"} else {",
"gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);",
"}",
"break;",
"case OPCM_32_BRR_JNE:\ntemp = tcg_temp_new();",
"temp2 = tcg_temp_new();",
"if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRR_JNED) {",
"tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);",
"tcg_gen_mov_tl(temp2, cpu_gpr_d[VAR_3]);",
"tcg_gen_subi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);",
"gen_branch_cond(VAR_0, TCG_COND_NE, temp, temp2, VAR_5);",
"} else {",
"tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);",
"tcg_gen_mov_tl(temp2, cpu_gpr_d[VAR_3]);",
"tcg_gen_addi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);",
"gen_branch_cond(VAR_0, TCG_COND_NE, temp, temp2, VAR_5);",
"}",
"tcg_temp_free(temp);",
"tcg_temp_free(temp2);",
"break;",
"case OPCM_32_BRR_JNZ:\nif (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JNZ_A) {",
"gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], 0, VAR_5);",
"} else {",
"gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], 0, VAR_5);",
"}",
"break;",
"default:\nprintf(\"Branch Error at %x\\VAR_6\", VAR_0->pc);",
"}",
"VAR_0->bstate = BS_BRANCH;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
17,
19,
21
],
[
23
],
[
25,
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
49,
51
],
[
53
],
[
55,
57
],
[
59
],
[
63,
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75,
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
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
],
[
139
],
[
141,
143
],
[
145
],
[
147,
149
],
[
151
],
[
153,
155
],
[
157
],
[
161,
163
],
[
165
],
[
167
],
[
169,
171,
173
],
[
175
],
[
177
],
[
181,
183
],
[
185
],
[
187
],
[
189,
191
],
[
195,
197
],
[
199
],
[
201,
203
],
[
205
],
[
207
],
[
211,
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225,
227
],
[
229
],
[
231
],
[
233
],
[
235,
237
],
[
239
],
[
241
],
[
243,
245
],
[
247
],
[
249
],
[
251
],
[
253,
255
],
[
257
],
[
259
],
[
261,
263
],
[
265
],
[
267
],
[
271
],
[
273
],
[
275
],
[
277
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
293,
295
],
[
299
],
[
301
],
[
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
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
],
[
403
],
[
405
],
[
407
],
[
409,
411
],
[
413
],
[
415
],
[
417
],
[
421
],
[
425
],
[
427
],
[
429
],
[
431
],
[
435
],
[
439
],
[
441
],
[
443
],
[
445
],
[
447
],
[
449
],
[
451,
453
],
[
455
],
[
457
],
[
459
],
[
461
],
[
463
],
[
465,
467
],
[
469
],
[
471
],
[
473
]
] |
20,502 | static void ide_init1(IDEBus *bus, int unit, DriveInfo *dinfo)
{
static int drive_serial = 1;
IDEState *s = &bus->ifs[unit];
s->bus = bus;
s->unit = unit;
s->drive_serial = drive_serial++;
s->io_buffer = qemu_blockalign(s->bs, IDE_DMA_BUF_SECTORS*512 + 4);
s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
s->smart_selftest_data = qemu_blockalign(s->bs, 512);
s->sector_write_timer = qemu_new_timer(vm_clock,
ide_sector_write_timer_cb, s);
ide_init_drive(s, dinfo, NULL);
}
| false | qemu | 870111c8ed95df62a101eae0acd08c84233a6341 | static void ide_init1(IDEBus *bus, int unit, DriveInfo *dinfo)
{
static int drive_serial = 1;
IDEState *s = &bus->ifs[unit];
s->bus = bus;
s->unit = unit;
s->drive_serial = drive_serial++;
s->io_buffer = qemu_blockalign(s->bs, IDE_DMA_BUF_SECTORS*512 + 4);
s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
s->smart_selftest_data = qemu_blockalign(s->bs, 512);
s->sector_write_timer = qemu_new_timer(vm_clock,
ide_sector_write_timer_cb, s);
ide_init_drive(s, dinfo, NULL);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(IDEBus *VAR_0, int VAR_1, DriveInfo *VAR_2)
{
static int VAR_3 = 1;
IDEState *s = &VAR_0->ifs[VAR_1];
s->VAR_0 = VAR_0;
s->VAR_1 = VAR_1;
s->VAR_3 = VAR_3++;
s->io_buffer = qemu_blockalign(s->bs, IDE_DMA_BUF_SECTORS*512 + 4);
s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
s->smart_selftest_data = qemu_blockalign(s->bs, 512);
s->sector_write_timer = qemu_new_timer(vm_clock,
ide_sector_write_timer_cb, s);
ide_init_drive(s, VAR_2, NULL);
}
| [
"static void FUNC_0(IDEBus *VAR_0, int VAR_1, DriveInfo *VAR_2)\n{",
"static int VAR_3 = 1;",
"IDEState *s = &VAR_0->ifs[VAR_1];",
"s->VAR_0 = VAR_0;",
"s->VAR_1 = VAR_1;",
"s->VAR_3 = VAR_3++;",
"s->io_buffer = qemu_blockalign(s->bs, IDE_DMA_BUF_SECTORS*512 + 4);",
"s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;",
"s->smart_selftest_data = qemu_blockalign(s->bs, 512);",
"s->sector_write_timer = qemu_new_timer(vm_clock,\nide_sector_write_timer_cb, s);",
"ide_init_drive(s, VAR_2, NULL);",
"}"
] | [
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
]
] |
20,503 | static void scsi_disk_apply_mode_select(SCSIDiskState *s, int page, uint8_t *p)
{
switch (page) {
case MODE_PAGE_CACHING:
bdrv_set_enable_write_cache(s->qdev.conf.bs, (p[0] & 4) != 0);
break;
default:
break;
}
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | static void scsi_disk_apply_mode_select(SCSIDiskState *s, int page, uint8_t *p)
{
switch (page) {
case MODE_PAGE_CACHING:
bdrv_set_enable_write_cache(s->qdev.conf.bs, (p[0] & 4) != 0);
break;
default:
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(SCSIDiskState *VAR_0, int VAR_1, uint8_t *VAR_2)
{
switch (VAR_1) {
case MODE_PAGE_CACHING:
bdrv_set_enable_write_cache(VAR_0->qdev.conf.bs, (VAR_2[0] & 4) != 0);
break;
default:
break;
}
}
| [
"static void FUNC_0(SCSIDiskState *VAR_0, int VAR_1, uint8_t *VAR_2)\n{",
"switch (VAR_1) {",
"case MODE_PAGE_CACHING:\nbdrv_set_enable_write_cache(VAR_0->qdev.conf.bs, (VAR_2[0] & 4) != 0);",
"break;",
"default:\nbreak;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
11
],
[
15,
17
],
[
19
],
[
21
]
] |
20,504 | int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
{
AVDictionaryEntry *t = NULL;
AVDictionary *tmp = NULL;
int ret = 0;
if (!options)
return 0;
while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
ret = av_opt_set(obj, t->key, t->value, search_flags);
if (ret == AVERROR_OPTION_NOT_FOUND)
av_dict_set(&tmp, t->key, t->value, 0);
else if (ret < 0) {
av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
break;
}
ret = 0;
}
av_dict_free(options);
*options = tmp;
return ret;
}
| false | FFmpeg | f3ace85d8869c3dddd2d28d064002d0d912e3624 | int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
{
AVDictionaryEntry *t = NULL;
AVDictionary *tmp = NULL;
int ret = 0;
if (!options)
return 0;
while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
ret = av_opt_set(obj, t->key, t->value, search_flags);
if (ret == AVERROR_OPTION_NOT_FOUND)
av_dict_set(&tmp, t->key, t->value, 0);
else if (ret < 0) {
av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
break;
}
ret = 0;
}
av_dict_free(options);
*options = tmp;
return ret;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(void *VAR_0, AVDictionary **VAR_1, int VAR_2)
{
AVDictionaryEntry *t = NULL;
AVDictionary *tmp = NULL;
int VAR_3 = 0;
if (!VAR_1)
return 0;
while ((t = av_dict_get(*VAR_1, "", t, AV_DICT_IGNORE_SUFFIX))) {
VAR_3 = av_opt_set(VAR_0, t->key, t->value, VAR_2);
if (VAR_3 == AVERROR_OPTION_NOT_FOUND)
av_dict_set(&tmp, t->key, t->value, 0);
else if (VAR_3 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
break;
}
VAR_3 = 0;
}
av_dict_free(VAR_1);
*VAR_1 = tmp;
return VAR_3;
}
| [
"int FUNC_0(void *VAR_0, AVDictionary **VAR_1, int VAR_2)\n{",
"AVDictionaryEntry *t = NULL;",
"AVDictionary *tmp = NULL;",
"int VAR_3 = 0;",
"if (!VAR_1)\nreturn 0;",
"while ((t = av_dict_get(*VAR_1, \"\", t, AV_DICT_IGNORE_SUFFIX))) {",
"VAR_3 = av_opt_set(VAR_0, t->key, t->value, VAR_2);",
"if (VAR_3 == AVERROR_OPTION_NOT_FOUND)\nav_dict_set(&tmp, t->key, t->value, 0);",
"else if (VAR_3 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Error setting option %s to value %s.\\n\", t->key, t->value);",
"break;",
"}",
"VAR_3 = 0;",
"}",
"av_dict_free(VAR_1);",
"*VAR_1 = tmp;",
"return VAR_3;",
"}"
] | [
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
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
]
] |
20,505 | START_TEST(empty_input)
{
const char *empty = "";
QObject *obj = qobject_from_json(empty);
fail_unless(obj == NULL);
}
| false | qemu | ef76dc59fa5203d146a2acf85a0ad5a5971a4824 | START_TEST(empty_input)
{
const char *empty = "";
QObject *obj = qobject_from_json(empty);
fail_unless(obj == NULL);
}
| {
"code": [],
"line_no": []
} | FUNC_0(VAR_0)
{
const char *VAR_1 = "";
QObject *obj = qobject_from_json(VAR_1);
fail_unless(obj == NULL);
}
| [
"FUNC_0(VAR_0)\n{",
"const char *VAR_1 = \"\";",
"QObject *obj = qobject_from_json(VAR_1);",
"fail_unless(obj == NULL);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
]
] |
20,506 | int net_client_init(const char *device, const char *p)
{
static const char * const fd_params[] = {
"vlan", "name", "fd", NULL
};
char buf[1024];
int vlan_id, ret;
VLANState *vlan;
char *name = NULL;
vlan_id = 0;
if (get_param_value(buf, sizeof(buf), "vlan", p)) {
vlan_id = strtol(buf, NULL, 0);
}
vlan = qemu_find_vlan(vlan_id);
if (get_param_value(buf, sizeof(buf), "name", p)) {
name = strdup(buf);
}
if (!strcmp(device, "nic")) {
static const char * const nic_params[] = {
"vlan", "name", "macaddr", "model", NULL
};
NICInfo *nd;
uint8_t *macaddr;
int idx = nic_get_free_idx();
if (check_params(nic_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (idx == -1 || nb_nics >= MAX_NICS) {
fprintf(stderr, "Too Many NICs\n");
ret = -1;
goto out;
}
nd = &nd_table[idx];
macaddr = nd->macaddr;
macaddr[0] = 0x52;
macaddr[1] = 0x54;
macaddr[2] = 0x00;
macaddr[3] = 0x12;
macaddr[4] = 0x34;
macaddr[5] = 0x56 + idx;
if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
if (parse_macaddr(macaddr, buf) < 0) {
fprintf(stderr, "invalid syntax for ethernet address\n");
ret = -1;
goto out;
}
}
if (get_param_value(buf, sizeof(buf), "model", p)) {
nd->model = strdup(buf);
}
nd->vlan = vlan;
nd->name = name;
nd->used = 1;
name = NULL;
nb_nics++;
vlan->nb_guest_devs++;
ret = idx;
} else
if (!strcmp(device, "none")) {
if (*p != '\0') {
fprintf(stderr, "qemu: 'none' takes no parameters\n");
return -1;
}
/* does nothing. It is needed to signal that no network cards
are wanted */
ret = 0;
} else
#ifdef CONFIG_SLIRP
if (!strcmp(device, "user")) {
static const char * const slirp_params[] = {
"vlan", "name", "hostname", "restrict", "ip", NULL
};
if (check_params(slirp_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (get_param_value(buf, sizeof(buf), "hostname", p)) {
pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
}
if (get_param_value(buf, sizeof(buf), "restrict", p)) {
slirp_restrict = (buf[0] == 'y') ? 1 : 0;
}
if (get_param_value(buf, sizeof(buf), "ip", p)) {
slirp_ip = strdup(buf);
}
vlan->nb_host_devs++;
ret = net_slirp_init(vlan, device, name);
} else if (!strcmp(device, "channel")) {
long port;
char name[20], *devname;
struct VMChannel *vmc;
port = strtol(p, &devname, 10);
devname++;
if (port < 1 || port > 65535) {
fprintf(stderr, "vmchannel wrong port number\n");
ret = -1;
goto out;
}
vmc = malloc(sizeof(struct VMChannel));
snprintf(name, 20, "vmchannel%ld", port);
vmc->hd = qemu_chr_open(name, devname, NULL);
if (!vmc->hd) {
fprintf(stderr, "qemu: could not open vmchannel device"
"'%s'\n", devname);
ret = -1;
goto out;
}
vmc->port = port;
slirp_add_exec(3, vmc->hd, 4, port);
qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
NULL, vmc);
ret = 0;
} else
#endif
#ifdef _WIN32
if (!strcmp(device, "tap")) {
static const char * const tap_params[] = {
"vlan", "name", "ifname", NULL
};
char ifname[64];
if (check_params(tap_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
fprintf(stderr, "tap: no interface name\n");
ret = -1;
goto out;
}
vlan->nb_host_devs++;
ret = tap_win32_init(vlan, device, name, ifname);
} else
#elif defined (_AIX)
#else
if (!strcmp(device, "tap")) {
char ifname[64];
char setup_script[1024], down_script[1024];
int fd;
vlan->nb_host_devs++;
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
if (check_params(fd_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
fd = strtol(buf, NULL, 0);
fcntl(fd, F_SETFL, O_NONBLOCK);
net_tap_fd_init(vlan, device, name, fd);
ret = 0;
} else {
static const char * const tap_params[] = {
"vlan", "name", "ifname", "script", "downscript", NULL
};
if (check_params(tap_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
ifname[0] = '\0';
}
if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
}
if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
}
ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
}
} else
#endif
if (!strcmp(device, "socket")) {
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
int fd;
if (check_params(fd_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
fd = strtol(buf, NULL, 0);
ret = -1;
if (net_socket_fd_init(vlan, device, name, fd, 1))
ret = 0;
} else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
static const char * const listen_params[] = {
"vlan", "name", "listen", NULL
};
if (check_params(listen_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
ret = net_socket_listen_init(vlan, device, name, buf);
} else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
static const char * const connect_params[] = {
"vlan", "name", "connect", NULL
};
if (check_params(connect_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
ret = net_socket_connect_init(vlan, device, name, buf);
} else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
static const char * const mcast_params[] = {
"vlan", "name", "mcast", NULL
};
if (check_params(mcast_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
ret = net_socket_mcast_init(vlan, device, name, buf);
} else {
fprintf(stderr, "Unknown socket options: %s\n", p);
ret = -1;
goto out;
}
vlan->nb_host_devs++;
} else
#ifdef CONFIG_VDE
if (!strcmp(device, "vde")) {
static const char * const vde_params[] = {
"vlan", "name", "sock", "port", "group", "mode", NULL
};
char vde_sock[1024], vde_group[512];
int vde_port, vde_mode;
if (check_params(vde_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
vlan->nb_host_devs++;
if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
vde_sock[0] = '\0';
}
if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
vde_port = strtol(buf, NULL, 10);
} else {
vde_port = 0;
}
if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
vde_group[0] = '\0';
}
if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
vde_mode = strtol(buf, NULL, 8);
} else {
vde_mode = 0700;
}
ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode);
} else
#endif
if (!strcmp(device, "dump")) {
int len = 65536;
if (get_param_value(buf, sizeof(buf), "len", p) > 0) {
len = strtol(buf, NULL, 0);
}
if (!get_param_value(buf, sizeof(buf), "file", p)) {
snprintf(buf, sizeof(buf), "qemu-vlan%d.pcap", vlan_id);
}
ret = net_dump_init(vlan, device, name, buf, len);
} else {
fprintf(stderr, "Unknown network device: %s\n", device);
ret = -1;
goto out;
}
if (ret < 0) {
fprintf(stderr, "Could not initialize device '%s'\n", device);
}
out:
if (name)
free(name);
return ret;
}
| false | qemu | 0aa7a205c899c516d906673efbe9457f7af0dd3c | int net_client_init(const char *device, const char *p)
{
static const char * const fd_params[] = {
"vlan", "name", "fd", NULL
};
char buf[1024];
int vlan_id, ret;
VLANState *vlan;
char *name = NULL;
vlan_id = 0;
if (get_param_value(buf, sizeof(buf), "vlan", p)) {
vlan_id = strtol(buf, NULL, 0);
}
vlan = qemu_find_vlan(vlan_id);
if (get_param_value(buf, sizeof(buf), "name", p)) {
name = strdup(buf);
}
if (!strcmp(device, "nic")) {
static const char * const nic_params[] = {
"vlan", "name", "macaddr", "model", NULL
};
NICInfo *nd;
uint8_t *macaddr;
int idx = nic_get_free_idx();
if (check_params(nic_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (idx == -1 || nb_nics >= MAX_NICS) {
fprintf(stderr, "Too Many NICs\n");
ret = -1;
goto out;
}
nd = &nd_table[idx];
macaddr = nd->macaddr;
macaddr[0] = 0x52;
macaddr[1] = 0x54;
macaddr[2] = 0x00;
macaddr[3] = 0x12;
macaddr[4] = 0x34;
macaddr[5] = 0x56 + idx;
if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
if (parse_macaddr(macaddr, buf) < 0) {
fprintf(stderr, "invalid syntax for ethernet address\n");
ret = -1;
goto out;
}
}
if (get_param_value(buf, sizeof(buf), "model", p)) {
nd->model = strdup(buf);
}
nd->vlan = vlan;
nd->name = name;
nd->used = 1;
name = NULL;
nb_nics++;
vlan->nb_guest_devs++;
ret = idx;
} else
if (!strcmp(device, "none")) {
if (*p != '\0') {
fprintf(stderr, "qemu: 'none' takes no parameters\n");
return -1;
}
ret = 0;
} else
#ifdef CONFIG_SLIRP
if (!strcmp(device, "user")) {
static const char * const slirp_params[] = {
"vlan", "name", "hostname", "restrict", "ip", NULL
};
if (check_params(slirp_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (get_param_value(buf, sizeof(buf), "hostname", p)) {
pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
}
if (get_param_value(buf, sizeof(buf), "restrict", p)) {
slirp_restrict = (buf[0] == 'y') ? 1 : 0;
}
if (get_param_value(buf, sizeof(buf), "ip", p)) {
slirp_ip = strdup(buf);
}
vlan->nb_host_devs++;
ret = net_slirp_init(vlan, device, name);
} else if (!strcmp(device, "channel")) {
long port;
char name[20], *devname;
struct VMChannel *vmc;
port = strtol(p, &devname, 10);
devname++;
if (port < 1 || port > 65535) {
fprintf(stderr, "vmchannel wrong port number\n");
ret = -1;
goto out;
}
vmc = malloc(sizeof(struct VMChannel));
snprintf(name, 20, "vmchannel%ld", port);
vmc->hd = qemu_chr_open(name, devname, NULL);
if (!vmc->hd) {
fprintf(stderr, "qemu: could not open vmchannel device"
"'%s'\n", devname);
ret = -1;
goto out;
}
vmc->port = port;
slirp_add_exec(3, vmc->hd, 4, port);
qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
NULL, vmc);
ret = 0;
} else
#endif
#ifdef _WIN32
if (!strcmp(device, "tap")) {
static const char * const tap_params[] = {
"vlan", "name", "ifname", NULL
};
char ifname[64];
if (check_params(tap_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
fprintf(stderr, "tap: no interface name\n");
ret = -1;
goto out;
}
vlan->nb_host_devs++;
ret = tap_win32_init(vlan, device, name, ifname);
} else
#elif defined (_AIX)
#else
if (!strcmp(device, "tap")) {
char ifname[64];
char setup_script[1024], down_script[1024];
int fd;
vlan->nb_host_devs++;
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
if (check_params(fd_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
fd = strtol(buf, NULL, 0);
fcntl(fd, F_SETFL, O_NONBLOCK);
net_tap_fd_init(vlan, device, name, fd);
ret = 0;
} else {
static const char * const tap_params[] = {
"vlan", "name", "ifname", "script", "downscript", NULL
};
if (check_params(tap_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
ifname[0] = '\0';
}
if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
}
if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
}
ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
}
} else
#endif
if (!strcmp(device, "socket")) {
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
int fd;
if (check_params(fd_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
fd = strtol(buf, NULL, 0);
ret = -1;
if (net_socket_fd_init(vlan, device, name, fd, 1))
ret = 0;
} else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
static const char * const listen_params[] = {
"vlan", "name", "listen", NULL
};
if (check_params(listen_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
ret = net_socket_listen_init(vlan, device, name, buf);
} else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
static const char * const connect_params[] = {
"vlan", "name", "connect", NULL
};
if (check_params(connect_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
ret = net_socket_connect_init(vlan, device, name, buf);
} else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
static const char * const mcast_params[] = {
"vlan", "name", "mcast", NULL
};
if (check_params(mcast_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
ret = net_socket_mcast_init(vlan, device, name, buf);
} else {
fprintf(stderr, "Unknown socket options: %s\n", p);
ret = -1;
goto out;
}
vlan->nb_host_devs++;
} else
#ifdef CONFIG_VDE
if (!strcmp(device, "vde")) {
static const char * const vde_params[] = {
"vlan", "name", "sock", "port", "group", "mode", NULL
};
char vde_sock[1024], vde_group[512];
int vde_port, vde_mode;
if (check_params(vde_params, p) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
buf, p);
return -1;
}
vlan->nb_host_devs++;
if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
vde_sock[0] = '\0';
}
if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
vde_port = strtol(buf, NULL, 10);
} else {
vde_port = 0;
}
if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
vde_group[0] = '\0';
}
if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
vde_mode = strtol(buf, NULL, 8);
} else {
vde_mode = 0700;
}
ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode);
} else
#endif
if (!strcmp(device, "dump")) {
int len = 65536;
if (get_param_value(buf, sizeof(buf), "len", p) > 0) {
len = strtol(buf, NULL, 0);
}
if (!get_param_value(buf, sizeof(buf), "file", p)) {
snprintf(buf, sizeof(buf), "qemu-vlan%d.pcap", vlan_id);
}
ret = net_dump_init(vlan, device, name, buf, len);
} else {
fprintf(stderr, "Unknown network device: %s\n", device);
ret = -1;
goto out;
}
if (ret < 0) {
fprintf(stderr, "Could not initialize device '%s'\n", device);
}
out:
if (name)
free(name);
return ret;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(const char *VAR_0, const char *VAR_1)
{
static const char * const VAR_2[] = {
"vlan", "VAR_6", "VAR_14", NULL
};
char VAR_3[1024];
int VAR_4, VAR_5;
VLANState *vlan;
char *VAR_6 = NULL;
VAR_4 = 0;
if (get_param_value(VAR_3, sizeof(VAR_3), "vlan", VAR_1)) {
VAR_4 = strtol(VAR_3, NULL, 0);
}
vlan = qemu_find_vlan(VAR_4);
if (get_param_value(VAR_3, sizeof(VAR_3), "VAR_6", VAR_1)) {
VAR_6 = strdup(VAR_3);
}
if (!strcmp(VAR_0, "nic")) {
static const char * const VAR_7[] = {
"vlan", "VAR_6", "macaddr", "model", NULL
};
NICInfo *nd;
uint8_t *macaddr;
int VAR_8 = nic_get_free_idx();
if (check_params(VAR_7, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
if (VAR_8 == -1 || nb_nics >= MAX_NICS) {
fprintf(stderr, "Too Many NICs\n");
VAR_5 = -1;
goto out;
}
nd = &nd_table[VAR_8];
macaddr = nd->macaddr;
macaddr[0] = 0x52;
macaddr[1] = 0x54;
macaddr[2] = 0x00;
macaddr[3] = 0x12;
macaddr[4] = 0x34;
macaddr[5] = 0x56 + VAR_8;
if (get_param_value(VAR_3, sizeof(VAR_3), "macaddr", VAR_1)) {
if (parse_macaddr(macaddr, VAR_3) < 0) {
fprintf(stderr, "invalid syntax for ethernet address\n");
VAR_5 = -1;
goto out;
}
}
if (get_param_value(VAR_3, sizeof(VAR_3), "model", VAR_1)) {
nd->model = strdup(VAR_3);
}
nd->vlan = vlan;
nd->VAR_6 = VAR_6;
nd->used = 1;
VAR_6 = NULL;
nb_nics++;
vlan->nb_guest_devs++;
VAR_5 = VAR_8;
} else
if (!strcmp(VAR_0, "none")) {
if (*VAR_1 != '\0') {
fprintf(stderr, "qemu: 'none' takes no parameters\n");
return -1;
}
VAR_5 = 0;
} else
#ifdef CONFIG_SLIRP
if (!strcmp(VAR_0, "user")) {
static const char * const slirp_params[] = {
"vlan", "VAR_6", "hostname", "restrict", "ip", NULL
};
if (check_params(slirp_params, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
if (get_param_value(VAR_3, sizeof(VAR_3), "hostname", VAR_1)) {
pstrcpy(slirp_hostname, sizeof(slirp_hostname), VAR_3);
}
if (get_param_value(VAR_3, sizeof(VAR_3), "restrict", VAR_1)) {
slirp_restrict = (VAR_3[0] == 'y') ? 1 : 0;
}
if (get_param_value(VAR_3, sizeof(VAR_3), "ip", VAR_1)) {
slirp_ip = strdup(VAR_3);
}
vlan->nb_host_devs++;
VAR_5 = net_slirp_init(vlan, VAR_0, VAR_6);
} else if (!strcmp(VAR_0, "channel")) {
long port;
char VAR_6[20], *devname;
struct VMChannel *vmc;
port = strtol(VAR_1, &devname, 10);
devname++;
if (port < 1 || port > 65535) {
fprintf(stderr, "vmchannel wrong port number\n");
VAR_5 = -1;
goto out;
}
vmc = malloc(sizeof(struct VMChannel));
snprintf(VAR_6, 20, "vmchannel%ld", port);
vmc->hd = qemu_chr_open(VAR_6, devname, NULL);
if (!vmc->hd) {
fprintf(stderr, "qemu: could not open vmchannel VAR_0"
"'%s'\n", devname);
VAR_5 = -1;
goto out;
}
vmc->port = port;
slirp_add_exec(3, vmc->hd, 4, port);
qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
NULL, vmc);
VAR_5 = 0;
} else
#endif
#ifdef _WIN32
if (!strcmp(VAR_0, "tap")) {
static const char * const VAR_13[] = {
"vlan", "VAR_6", "VAR_9", NULL
};
char VAR_9[64];
if (check_params(VAR_13, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
if (get_param_value(VAR_9, sizeof(VAR_9), "VAR_9", VAR_1) <= 0) {
fprintf(stderr, "tap: no interface VAR_6\n");
VAR_5 = -1;
goto out;
}
vlan->nb_host_devs++;
VAR_5 = tap_win32_init(vlan, VAR_0, VAR_6, VAR_9);
} else
#elif defined (_AIX)
#else
if (!strcmp(VAR_0, "tap")) {
char VAR_9[64];
char VAR_10[1024], VAR_11[1024];
int VAR_14;
vlan->nb_host_devs++;
if (get_param_value(VAR_3, sizeof(VAR_3), "VAR_14", VAR_1) > 0) {
if (check_params(VAR_2, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
VAR_14 = strtol(VAR_3, NULL, 0);
fcntl(VAR_14, F_SETFL, O_NONBLOCK);
net_tap_fd_init(vlan, VAR_0, VAR_6, VAR_14);
VAR_5 = 0;
} else {
static const char * const VAR_13[] = {
"vlan", "VAR_6", "VAR_9", "script", "downscript", NULL
};
if (check_params(VAR_13, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
if (get_param_value(VAR_9, sizeof(VAR_9), "VAR_9", VAR_1) <= 0) {
VAR_9[0] = '\0';
}
if (get_param_value(VAR_10, sizeof(VAR_10), "script", VAR_1) == 0) {
pstrcpy(VAR_10, sizeof(VAR_10), DEFAULT_NETWORK_SCRIPT);
}
if (get_param_value(VAR_11, sizeof(VAR_11), "downscript", VAR_1) == 0) {
pstrcpy(VAR_11, sizeof(VAR_11), DEFAULT_NETWORK_DOWN_SCRIPT);
}
VAR_5 = net_tap_init(vlan, VAR_0, VAR_6, VAR_9, VAR_10, VAR_11);
}
} else
#endif
if (!strcmp(VAR_0, "socket")) {
if (get_param_value(VAR_3, sizeof(VAR_3), "VAR_14", VAR_1) > 0) {
int VAR_14;
if (check_params(VAR_2, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
VAR_14 = strtol(VAR_3, NULL, 0);
VAR_5 = -1;
if (net_socket_fd_init(vlan, VAR_0, VAR_6, VAR_14, 1))
VAR_5 = 0;
} else if (get_param_value(VAR_3, sizeof(VAR_3), "listen", VAR_1) > 0) {
static const char * const VAR_14[] = {
"vlan", "VAR_6", "listen", NULL
};
if (check_params(VAR_14, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
VAR_5 = net_socket_listen_init(vlan, VAR_0, VAR_6, VAR_3);
} else if (get_param_value(VAR_3, sizeof(VAR_3), "connect", VAR_1) > 0) {
static const char * const VAR_15[] = {
"vlan", "VAR_6", "connect", NULL
};
if (check_params(VAR_15, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
VAR_5 = net_socket_connect_init(vlan, VAR_0, VAR_6, VAR_3);
} else if (get_param_value(VAR_3, sizeof(VAR_3), "mcast", VAR_1) > 0) {
static const char * const VAR_16[] = {
"vlan", "VAR_6", "mcast", NULL
};
if (check_params(VAR_16, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
VAR_5 = net_socket_mcast_init(vlan, VAR_0, VAR_6, VAR_3);
} else {
fprintf(stderr, "Unknown socket options: %s\n", VAR_1);
VAR_5 = -1;
goto out;
}
vlan->nb_host_devs++;
} else
#ifdef CONFIG_VDE
if (!strcmp(VAR_0, "vde")) {
static const char * const vde_params[] = {
"vlan", "VAR_6", "sock", "port", "group", "mode", NULL
};
char vde_sock[1024], vde_group[512];
int vde_port, vde_mode;
if (check_params(vde_params, VAR_1) < 0) {
fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n",
VAR_3, VAR_1);
return -1;
}
vlan->nb_host_devs++;
if (get_param_value(vde_sock, sizeof(vde_sock), "sock", VAR_1) <= 0) {
vde_sock[0] = '\0';
}
if (get_param_value(VAR_3, sizeof(VAR_3), "port", VAR_1) > 0) {
vde_port = strtol(VAR_3, NULL, 10);
} else {
vde_port = 0;
}
if (get_param_value(vde_group, sizeof(vde_group), "group", VAR_1) <= 0) {
vde_group[0] = '\0';
}
if (get_param_value(VAR_3, sizeof(VAR_3), "mode", VAR_1) > 0) {
vde_mode = strtol(VAR_3, NULL, 8);
} else {
vde_mode = 0700;
}
VAR_5 = net_vde_init(vlan, VAR_0, VAR_6, vde_sock, vde_port, vde_group, vde_mode);
} else
#endif
if (!strcmp(VAR_0, "dump")) {
int VAR_17 = 65536;
if (get_param_value(VAR_3, sizeof(VAR_3), "VAR_17", VAR_1) > 0) {
VAR_17 = strtol(VAR_3, NULL, 0);
}
if (!get_param_value(VAR_3, sizeof(VAR_3), "file", VAR_1)) {
snprintf(VAR_3, sizeof(VAR_3), "qemu-vlan%d.pcap", VAR_4);
}
VAR_5 = net_dump_init(vlan, VAR_0, VAR_6, VAR_3, VAR_17);
} else {
fprintf(stderr, "Unknown network VAR_0: %s\n", VAR_0);
VAR_5 = -1;
goto out;
}
if (VAR_5 < 0) {
fprintf(stderr, "Could not initialize VAR_0 '%s'\n", VAR_0);
}
out:
if (VAR_6)
free(VAR_6);
return VAR_5;
}
| [
"int FUNC_0(const char *VAR_0, const char *VAR_1)\n{",
"static const char * const VAR_2[] = {",
"\"vlan\", \"VAR_6\", \"VAR_14\", NULL\n};",
"char VAR_3[1024];",
"int VAR_4, VAR_5;",
"VLANState *vlan;",
"char *VAR_6 = NULL;",
"VAR_4 = 0;",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"vlan\", VAR_1)) {",
"VAR_4 = strtol(VAR_3, NULL, 0);",
"}",
"vlan = qemu_find_vlan(VAR_4);",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"VAR_6\", VAR_1)) {",
"VAR_6 = strdup(VAR_3);",
"}",
"if (!strcmp(VAR_0, \"nic\")) {",
"static const char * const VAR_7[] = {",
"\"vlan\", \"VAR_6\", \"macaddr\", \"model\", NULL\n};",
"NICInfo *nd;",
"uint8_t *macaddr;",
"int VAR_8 = nic_get_free_idx();",
"if (check_params(VAR_7, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"if (VAR_8 == -1 || nb_nics >= MAX_NICS) {",
"fprintf(stderr, \"Too Many NICs\\n\");",
"VAR_5 = -1;",
"goto out;",
"}",
"nd = &nd_table[VAR_8];",
"macaddr = nd->macaddr;",
"macaddr[0] = 0x52;",
"macaddr[1] = 0x54;",
"macaddr[2] = 0x00;",
"macaddr[3] = 0x12;",
"macaddr[4] = 0x34;",
"macaddr[5] = 0x56 + VAR_8;",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"macaddr\", VAR_1)) {",
"if (parse_macaddr(macaddr, VAR_3) < 0) {",
"fprintf(stderr, \"invalid syntax for ethernet address\\n\");",
"VAR_5 = -1;",
"goto out;",
"}",
"}",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"model\", VAR_1)) {",
"nd->model = strdup(VAR_3);",
"}",
"nd->vlan = vlan;",
"nd->VAR_6 = VAR_6;",
"nd->used = 1;",
"VAR_6 = NULL;",
"nb_nics++;",
"vlan->nb_guest_devs++;",
"VAR_5 = VAR_8;",
"} else",
"if (!strcmp(VAR_0, \"none\")) {",
"if (*VAR_1 != '\\0') {",
"fprintf(stderr, \"qemu: 'none' takes no parameters\\n\");",
"return -1;",
"}",
"VAR_5 = 0;",
"} else",
"#ifdef CONFIG_SLIRP\nif (!strcmp(VAR_0, \"user\")) {",
"static const char * const slirp_params[] = {",
"\"vlan\", \"VAR_6\", \"hostname\", \"restrict\", \"ip\", NULL\n};",
"if (check_params(slirp_params, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"hostname\", VAR_1)) {",
"pstrcpy(slirp_hostname, sizeof(slirp_hostname), VAR_3);",
"}",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"restrict\", VAR_1)) {",
"slirp_restrict = (VAR_3[0] == 'y') ? 1 : 0;",
"}",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"ip\", VAR_1)) {",
"slirp_ip = strdup(VAR_3);",
"}",
"vlan->nb_host_devs++;",
"VAR_5 = net_slirp_init(vlan, VAR_0, VAR_6);",
"} else if (!strcmp(VAR_0, \"channel\")) {",
"long port;",
"char VAR_6[20], *devname;",
"struct VMChannel *vmc;",
"port = strtol(VAR_1, &devname, 10);",
"devname++;",
"if (port < 1 || port > 65535) {",
"fprintf(stderr, \"vmchannel wrong port number\\n\");",
"VAR_5 = -1;",
"goto out;",
"}",
"vmc = malloc(sizeof(struct VMChannel));",
"snprintf(VAR_6, 20, \"vmchannel%ld\", port);",
"vmc->hd = qemu_chr_open(VAR_6, devname, NULL);",
"if (!vmc->hd) {",
"fprintf(stderr, \"qemu: could not open vmchannel VAR_0\"\n\"'%s'\\n\", devname);",
"VAR_5 = -1;",
"goto out;",
"}",
"vmc->port = port;",
"slirp_add_exec(3, vmc->hd, 4, port);",
"qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,\nNULL, vmc);",
"VAR_5 = 0;",
"} else",
"#endif\n#ifdef _WIN32\nif (!strcmp(VAR_0, \"tap\")) {",
"static const char * const VAR_13[] = {",
"\"vlan\", \"VAR_6\", \"VAR_9\", NULL\n};",
"char VAR_9[64];",
"if (check_params(VAR_13, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"if (get_param_value(VAR_9, sizeof(VAR_9), \"VAR_9\", VAR_1) <= 0) {",
"fprintf(stderr, \"tap: no interface VAR_6\\n\");",
"VAR_5 = -1;",
"goto out;",
"}",
"vlan->nb_host_devs++;",
"VAR_5 = tap_win32_init(vlan, VAR_0, VAR_6, VAR_9);",
"} else",
"#elif defined (_AIX)\n#else\nif (!strcmp(VAR_0, \"tap\")) {",
"char VAR_9[64];",
"char VAR_10[1024], VAR_11[1024];",
"int VAR_14;",
"vlan->nb_host_devs++;",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"VAR_14\", VAR_1) > 0) {",
"if (check_params(VAR_2, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"VAR_14 = strtol(VAR_3, NULL, 0);",
"fcntl(VAR_14, F_SETFL, O_NONBLOCK);",
"net_tap_fd_init(vlan, VAR_0, VAR_6, VAR_14);",
"VAR_5 = 0;",
"} else {",
"static const char * const VAR_13[] = {",
"\"vlan\", \"VAR_6\", \"VAR_9\", \"script\", \"downscript\", NULL\n};",
"if (check_params(VAR_13, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"if (get_param_value(VAR_9, sizeof(VAR_9), \"VAR_9\", VAR_1) <= 0) {",
"VAR_9[0] = '\\0';",
"}",
"if (get_param_value(VAR_10, sizeof(VAR_10), \"script\", VAR_1) == 0) {",
"pstrcpy(VAR_10, sizeof(VAR_10), DEFAULT_NETWORK_SCRIPT);",
"}",
"if (get_param_value(VAR_11, sizeof(VAR_11), \"downscript\", VAR_1) == 0) {",
"pstrcpy(VAR_11, sizeof(VAR_11), DEFAULT_NETWORK_DOWN_SCRIPT);",
"}",
"VAR_5 = net_tap_init(vlan, VAR_0, VAR_6, VAR_9, VAR_10, VAR_11);",
"}",
"} else",
"#endif\nif (!strcmp(VAR_0, \"socket\")) {",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"VAR_14\", VAR_1) > 0) {",
"int VAR_14;",
"if (check_params(VAR_2, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"VAR_14 = strtol(VAR_3, NULL, 0);",
"VAR_5 = -1;",
"if (net_socket_fd_init(vlan, VAR_0, VAR_6, VAR_14, 1))\nVAR_5 = 0;",
"} else if (get_param_value(VAR_3, sizeof(VAR_3), \"listen\", VAR_1) > 0) {",
"static const char * const VAR_14[] = {",
"\"vlan\", \"VAR_6\", \"listen\", NULL\n};",
"if (check_params(VAR_14, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"VAR_5 = net_socket_listen_init(vlan, VAR_0, VAR_6, VAR_3);",
"} else if (get_param_value(VAR_3, sizeof(VAR_3), \"connect\", VAR_1) > 0) {",
"static const char * const VAR_15[] = {",
"\"vlan\", \"VAR_6\", \"connect\", NULL\n};",
"if (check_params(VAR_15, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"VAR_5 = net_socket_connect_init(vlan, VAR_0, VAR_6, VAR_3);",
"} else if (get_param_value(VAR_3, sizeof(VAR_3), \"mcast\", VAR_1) > 0) {",
"static const char * const VAR_16[] = {",
"\"vlan\", \"VAR_6\", \"mcast\", NULL\n};",
"if (check_params(VAR_16, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"VAR_5 = net_socket_mcast_init(vlan, VAR_0, VAR_6, VAR_3);",
"} else {",
"fprintf(stderr, \"Unknown socket options: %s\\n\", VAR_1);",
"VAR_5 = -1;",
"goto out;",
"}",
"vlan->nb_host_devs++;",
"} else",
"#ifdef CONFIG_VDE\nif (!strcmp(VAR_0, \"vde\")) {",
"static const char * const vde_params[] = {",
"\"vlan\", \"VAR_6\", \"sock\", \"port\", \"group\", \"mode\", NULL\n};",
"char vde_sock[1024], vde_group[512];",
"int vde_port, vde_mode;",
"if (check_params(vde_params, VAR_1) < 0) {",
"fprintf(stderr, \"qemu: invalid parameter '%s' in '%s'\\n\",\nVAR_3, VAR_1);",
"return -1;",
"}",
"vlan->nb_host_devs++;",
"if (get_param_value(vde_sock, sizeof(vde_sock), \"sock\", VAR_1) <= 0) {",
"vde_sock[0] = '\\0';",
"}",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"port\", VAR_1) > 0) {",
"vde_port = strtol(VAR_3, NULL, 10);",
"} else {",
"vde_port = 0;",
"}",
"if (get_param_value(vde_group, sizeof(vde_group), \"group\", VAR_1) <= 0) {",
"vde_group[0] = '\\0';",
"}",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"mode\", VAR_1) > 0) {",
"vde_mode = strtol(VAR_3, NULL, 8);",
"} else {",
"vde_mode = 0700;",
"}",
"VAR_5 = net_vde_init(vlan, VAR_0, VAR_6, vde_sock, vde_port, vde_group, vde_mode);",
"} else",
"#endif\nif (!strcmp(VAR_0, \"dump\")) {",
"int VAR_17 = 65536;",
"if (get_param_value(VAR_3, sizeof(VAR_3), \"VAR_17\", VAR_1) > 0) {",
"VAR_17 = strtol(VAR_3, NULL, 0);",
"}",
"if (!get_param_value(VAR_3, sizeof(VAR_3), \"file\", VAR_1)) {",
"snprintf(VAR_3, sizeof(VAR_3), \"qemu-vlan%d.pcap\", VAR_4);",
"}",
"VAR_5 = net_dump_init(vlan, VAR_0, VAR_6, VAR_3, VAR_17);",
"} else {",
"fprintf(stderr, \"Unknown network VAR_0: %s\\n\", VAR_0);",
"VAR_5 = -1;",
"goto out;",
"}",
"if (VAR_5 < 0) {",
"fprintf(stderr, \"Could not initialize VAR_0 '%s'\\n\", VAR_0);",
"}",
"out:\nif (VAR_6)\nfree(VAR_6);",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57,
59
],
[
61
],
[
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
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
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
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221,
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
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,
287,
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303,
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
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
],
[
421
],
[
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
],
[
477
],
[
479,
481
],
[
483
],
[
485
],
[
487
],
[
489
],
[
491
],
[
493
],
[
495
],
[
497
],
[
499
],
[
501
],
[
503
],
[
505
],
[
507
],
[
509
],
[
511
],
[
513
],
[
515
],
[
517
],
[
519
],
[
521
],
[
523
],
[
525,
527
],
[
529
],
[
533
],
[
535
],
[
537
],
[
539
],
[
541
],
[
543
],
[
545
],
[
547
],
[
549
],
[
551
],
[
553
],
[
555
],
[
557
],
[
559
],
[
561
],
[
563,
565,
567
],
[
569
],
[
571
]
] |
20,508 | static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
{
unsigned int cssid = 0;
unsigned int ssid = 0;
unsigned int schid;
unsigned int devno;
bool have_devno = false;
bool found = false;
SubchDev *sch;
int ret;
int num;
DeviceState *parent = DEVICE(dev);
sch = g_malloc0(sizeof(SubchDev));
sch->driver_data = dev;
dev->sch = sch;
dev->indicators = NULL;
/* Initialize subchannel structure. */
sch->channel_prog = 0x0;
sch->last_cmd_valid = false;
sch->thinint_active = false;
/*
* Use a device number if provided. Otherwise, fall back to subchannel
* number.
*/
if (dev->bus_id) {
num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno);
if (num == 3) {
if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) {
ret = -EINVAL;
error_report("Invalid cssid or ssid: cssid %x, ssid %x",
cssid, ssid);
goto out_err;
}
/* Enforce use of virtual cssid. */
if (cssid != VIRTUAL_CSSID) {
ret = -EINVAL;
error_report("cssid %x not valid for virtio devices", cssid);
goto out_err;
}
if (css_devno_used(cssid, ssid, devno)) {
ret = -EEXIST;
error_report("Device %x.%x.%04x already exists", cssid, ssid,
devno);
goto out_err;
}
sch->cssid = cssid;
sch->ssid = ssid;
sch->devno = devno;
have_devno = true;
} else {
ret = -EINVAL;
error_report("Malformed devno parameter '%s'", dev->bus_id);
goto out_err;
}
}
/* Find the next free id. */
if (have_devno) {
for (schid = 0; schid <= MAX_SCHID; schid++) {
if (!css_find_subch(1, cssid, ssid, schid)) {
sch->schid = schid;
css_subch_assign(cssid, ssid, schid, devno, sch);
found = true;
break;
}
}
if (!found) {
ret = -ENODEV;
error_report("No free subchannel found for %x.%x.%04x", cssid, ssid,
devno);
goto out_err;
}
trace_virtio_ccw_new_device(cssid, ssid, schid, devno,
"user-configured");
} else {
cssid = VIRTUAL_CSSID;
for (ssid = 0; ssid <= MAX_SSID; ssid++) {
for (schid = 0; schid <= MAX_SCHID; schid++) {
if (!css_find_subch(1, cssid, ssid, schid)) {
sch->cssid = cssid;
sch->ssid = ssid;
sch->schid = schid;
devno = schid;
/*
* If the devno is already taken, look further in this
* subchannel set.
*/
while (css_devno_used(cssid, ssid, devno)) {
if (devno == MAX_SCHID) {
devno = 0;
} else if (devno == schid - 1) {
ret = -ENODEV;
error_report("No free devno found");
goto out_err;
} else {
devno++;
}
}
sch->devno = devno;
css_subch_assign(cssid, ssid, schid, devno, sch);
found = true;
break;
}
}
if (found) {
break;
}
}
if (!found) {
ret = -ENODEV;
error_report("Virtual channel subsystem is full!");
goto out_err;
}
trace_virtio_ccw_new_device(cssid, ssid, schid, devno,
"auto-configured");
}
/* Build initial schib. */
css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
sch->ccw_cb = virtio_ccw_cb;
/* Build senseid data. */
memset(&sch->id, 0, sizeof(SenseId));
sch->id.reserved = 0xff;
sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
sch->id.cu_model = vdev->device_id;
/* Only the first 32 feature bits are used. */
dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus,
dev->host_features[0]);
dev->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
dev->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE;
css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,
parent->hotplugged, 1);
return 0;
out_err:
dev->sch = NULL;
g_free(sch);
return ret;
}
| false | qemu | 0cd09c3a6cc2230ba38c462fc410b4acce59eb6f | static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev)
{
unsigned int cssid = 0;
unsigned int ssid = 0;
unsigned int schid;
unsigned int devno;
bool have_devno = false;
bool found = false;
SubchDev *sch;
int ret;
int num;
DeviceState *parent = DEVICE(dev);
sch = g_malloc0(sizeof(SubchDev));
sch->driver_data = dev;
dev->sch = sch;
dev->indicators = NULL;
sch->channel_prog = 0x0;
sch->last_cmd_valid = false;
sch->thinint_active = false;
if (dev->bus_id) {
num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno);
if (num == 3) {
if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) {
ret = -EINVAL;
error_report("Invalid cssid or ssid: cssid %x, ssid %x",
cssid, ssid);
goto out_err;
}
if (cssid != VIRTUAL_CSSID) {
ret = -EINVAL;
error_report("cssid %x not valid for virtio devices", cssid);
goto out_err;
}
if (css_devno_used(cssid, ssid, devno)) {
ret = -EEXIST;
error_report("Device %x.%x.%04x already exists", cssid, ssid,
devno);
goto out_err;
}
sch->cssid = cssid;
sch->ssid = ssid;
sch->devno = devno;
have_devno = true;
} else {
ret = -EINVAL;
error_report("Malformed devno parameter '%s'", dev->bus_id);
goto out_err;
}
}
if (have_devno) {
for (schid = 0; schid <= MAX_SCHID; schid++) {
if (!css_find_subch(1, cssid, ssid, schid)) {
sch->schid = schid;
css_subch_assign(cssid, ssid, schid, devno, sch);
found = true;
break;
}
}
if (!found) {
ret = -ENODEV;
error_report("No free subchannel found for %x.%x.%04x", cssid, ssid,
devno);
goto out_err;
}
trace_virtio_ccw_new_device(cssid, ssid, schid, devno,
"user-configured");
} else {
cssid = VIRTUAL_CSSID;
for (ssid = 0; ssid <= MAX_SSID; ssid++) {
for (schid = 0; schid <= MAX_SCHID; schid++) {
if (!css_find_subch(1, cssid, ssid, schid)) {
sch->cssid = cssid;
sch->ssid = ssid;
sch->schid = schid;
devno = schid;
while (css_devno_used(cssid, ssid, devno)) {
if (devno == MAX_SCHID) {
devno = 0;
} else if (devno == schid - 1) {
ret = -ENODEV;
error_report("No free devno found");
goto out_err;
} else {
devno++;
}
}
sch->devno = devno;
css_subch_assign(cssid, ssid, schid, devno, sch);
found = true;
break;
}
}
if (found) {
break;
}
}
if (!found) {
ret = -ENODEV;
error_report("Virtual channel subsystem is full!");
goto out_err;
}
trace_virtio_ccw_new_device(cssid, ssid, schid, devno,
"auto-configured");
}
css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
sch->ccw_cb = virtio_ccw_cb;
memset(&sch->id, 0, sizeof(SenseId));
sch->id.reserved = 0xff;
sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
sch->id.cu_model = vdev->device_id;
dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus,
dev->host_features[0]);
dev->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
dev->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE;
css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,
parent->hotplugged, 1);
return 0;
out_err:
dev->sch = NULL;
g_free(sch);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(VirtioCcwDevice *VAR_0, VirtIODevice *VAR_1)
{
unsigned int VAR_2 = 0;
unsigned int VAR_3 = 0;
unsigned int VAR_4;
unsigned int VAR_5;
bool have_devno = false;
bool found = false;
SubchDev *sch;
int VAR_6;
int VAR_7;
DeviceState *parent = DEVICE(VAR_0);
sch = g_malloc0(sizeof(SubchDev));
sch->driver_data = VAR_0;
VAR_0->sch = sch;
VAR_0->indicators = NULL;
sch->channel_prog = 0x0;
sch->last_cmd_valid = false;
sch->thinint_active = false;
if (VAR_0->bus_id) {
VAR_7 = sscanf(VAR_0->bus_id, "%x.%x.%04x", &VAR_2, &VAR_3, &VAR_5);
if (VAR_7 == 3) {
if ((VAR_2 > MAX_CSSID) || (VAR_3 > MAX_SSID)) {
VAR_6 = -EINVAL;
error_report("Invalid VAR_2 or VAR_3: VAR_2 %x, VAR_3 %x",
VAR_2, VAR_3);
goto out_err;
}
if (VAR_2 != VIRTUAL_CSSID) {
VAR_6 = -EINVAL;
error_report("VAR_2 %x not valid for virtio devices", VAR_2);
goto out_err;
}
if (css_devno_used(VAR_2, VAR_3, VAR_5)) {
VAR_6 = -EEXIST;
error_report("Device %x.%x.%04x already exists", VAR_2, VAR_3,
VAR_5);
goto out_err;
}
sch->VAR_2 = VAR_2;
sch->VAR_3 = VAR_3;
sch->VAR_5 = VAR_5;
have_devno = true;
} else {
VAR_6 = -EINVAL;
error_report("Malformed VAR_5 parameter '%s'", VAR_0->bus_id);
goto out_err;
}
}
if (have_devno) {
for (VAR_4 = 0; VAR_4 <= MAX_SCHID; VAR_4++) {
if (!css_find_subch(1, VAR_2, VAR_3, VAR_4)) {
sch->VAR_4 = VAR_4;
css_subch_assign(VAR_2, VAR_3, VAR_4, VAR_5, sch);
found = true;
break;
}
}
if (!found) {
VAR_6 = -ENODEV;
error_report("No free subchannel found for %x.%x.%04x", VAR_2, VAR_3,
VAR_5);
goto out_err;
}
trace_virtio_ccw_new_device(VAR_2, VAR_3, VAR_4, VAR_5,
"user-configured");
} else {
VAR_2 = VIRTUAL_CSSID;
for (VAR_3 = 0; VAR_3 <= MAX_SSID; VAR_3++) {
for (VAR_4 = 0; VAR_4 <= MAX_SCHID; VAR_4++) {
if (!css_find_subch(1, VAR_2, VAR_3, VAR_4)) {
sch->VAR_2 = VAR_2;
sch->VAR_3 = VAR_3;
sch->VAR_4 = VAR_4;
VAR_5 = VAR_4;
while (css_devno_used(VAR_2, VAR_3, VAR_5)) {
if (VAR_5 == MAX_SCHID) {
VAR_5 = 0;
} else if (VAR_5 == VAR_4 - 1) {
VAR_6 = -ENODEV;
error_report("No free VAR_5 found");
goto out_err;
} else {
VAR_5++;
}
}
sch->VAR_5 = VAR_5;
css_subch_assign(VAR_2, VAR_3, VAR_4, VAR_5, sch);
found = true;
break;
}
}
if (found) {
break;
}
}
if (!found) {
VAR_6 = -ENODEV;
error_report("Virtual channel subsystem is full!");
goto out_err;
}
trace_virtio_ccw_new_device(VAR_2, VAR_3, VAR_4, VAR_5,
"auto-configured");
}
css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
sch->ccw_cb = virtio_ccw_cb;
memset(&sch->id, 0, sizeof(SenseId));
sch->id.reserved = 0xff;
sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
sch->id.cu_model = VAR_1->device_id;
VAR_0->host_features[0] = virtio_bus_get_vdev_features(&VAR_0->bus,
VAR_0->host_features[0]);
VAR_0->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
VAR_0->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE;
css_generate_sch_crws(sch->VAR_2, sch->VAR_3, sch->VAR_4,
parent->hotplugged, 1);
return 0;
out_err:
VAR_0->sch = NULL;
g_free(sch);
return VAR_6;
}
| [
"static int FUNC_0(VirtioCcwDevice *VAR_0, VirtIODevice *VAR_1)\n{",
"unsigned int VAR_2 = 0;",
"unsigned int VAR_3 = 0;",
"unsigned int VAR_4;",
"unsigned int VAR_5;",
"bool have_devno = false;",
"bool found = false;",
"SubchDev *sch;",
"int VAR_6;",
"int VAR_7;",
"DeviceState *parent = DEVICE(VAR_0);",
"sch = g_malloc0(sizeof(SubchDev));",
"sch->driver_data = VAR_0;",
"VAR_0->sch = sch;",
"VAR_0->indicators = NULL;",
"sch->channel_prog = 0x0;",
"sch->last_cmd_valid = false;",
"sch->thinint_active = false;",
"if (VAR_0->bus_id) {",
"VAR_7 = sscanf(VAR_0->bus_id, \"%x.%x.%04x\", &VAR_2, &VAR_3, &VAR_5);",
"if (VAR_7 == 3) {",
"if ((VAR_2 > MAX_CSSID) || (VAR_3 > MAX_SSID)) {",
"VAR_6 = -EINVAL;",
"error_report(\"Invalid VAR_2 or VAR_3: VAR_2 %x, VAR_3 %x\",\nVAR_2, VAR_3);",
"goto out_err;",
"}",
"if (VAR_2 != VIRTUAL_CSSID) {",
"VAR_6 = -EINVAL;",
"error_report(\"VAR_2 %x not valid for virtio devices\", VAR_2);",
"goto out_err;",
"}",
"if (css_devno_used(VAR_2, VAR_3, VAR_5)) {",
"VAR_6 = -EEXIST;",
"error_report(\"Device %x.%x.%04x already exists\", VAR_2, VAR_3,\nVAR_5);",
"goto out_err;",
"}",
"sch->VAR_2 = VAR_2;",
"sch->VAR_3 = VAR_3;",
"sch->VAR_5 = VAR_5;",
"have_devno = true;",
"} else {",
"VAR_6 = -EINVAL;",
"error_report(\"Malformed VAR_5 parameter '%s'\", VAR_0->bus_id);",
"goto out_err;",
"}",
"}",
"if (have_devno) {",
"for (VAR_4 = 0; VAR_4 <= MAX_SCHID; VAR_4++) {",
"if (!css_find_subch(1, VAR_2, VAR_3, VAR_4)) {",
"sch->VAR_4 = VAR_4;",
"css_subch_assign(VAR_2, VAR_3, VAR_4, VAR_5, sch);",
"found = true;",
"break;",
"}",
"}",
"if (!found) {",
"VAR_6 = -ENODEV;",
"error_report(\"No free subchannel found for %x.%x.%04x\", VAR_2, VAR_3,\nVAR_5);",
"goto out_err;",
"}",
"trace_virtio_ccw_new_device(VAR_2, VAR_3, VAR_4, VAR_5,\n\"user-configured\");",
"} else {",
"VAR_2 = VIRTUAL_CSSID;",
"for (VAR_3 = 0; VAR_3 <= MAX_SSID; VAR_3++) {",
"for (VAR_4 = 0; VAR_4 <= MAX_SCHID; VAR_4++) {",
"if (!css_find_subch(1, VAR_2, VAR_3, VAR_4)) {",
"sch->VAR_2 = VAR_2;",
"sch->VAR_3 = VAR_3;",
"sch->VAR_4 = VAR_4;",
"VAR_5 = VAR_4;",
"while (css_devno_used(VAR_2, VAR_3, VAR_5)) {",
"if (VAR_5 == MAX_SCHID) {",
"VAR_5 = 0;",
"} else if (VAR_5 == VAR_4 - 1) {",
"VAR_6 = -ENODEV;",
"error_report(\"No free VAR_5 found\");",
"goto out_err;",
"} else {",
"VAR_5++;",
"}",
"}",
"sch->VAR_5 = VAR_5;",
"css_subch_assign(VAR_2, VAR_3, VAR_4, VAR_5, sch);",
"found = true;",
"break;",
"}",
"}",
"if (found) {",
"break;",
"}",
"}",
"if (!found) {",
"VAR_6 = -ENODEV;",
"error_report(\"Virtual channel subsystem is full!\");",
"goto out_err;",
"}",
"trace_virtio_ccw_new_device(VAR_2, VAR_3, VAR_4, VAR_5,\n\"auto-configured\");",
"}",
"css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);",
"sch->ccw_cb = virtio_ccw_cb;",
"memset(&sch->id, 0, sizeof(SenseId));",
"sch->id.reserved = 0xff;",
"sch->id.cu_type = VIRTIO_CCW_CU_TYPE;",
"sch->id.cu_model = VAR_1->device_id;",
"VAR_0->host_features[0] = virtio_bus_get_vdev_features(&VAR_0->bus,\nVAR_0->host_features[0]);",
"VAR_0->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;",
"VAR_0->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE;",
"css_generate_sch_crws(sch->VAR_2, sch->VAR_3, sch->VAR_4,\nparent->hotplugged, 1);",
"return 0;",
"out_err:\nVAR_0->sch = NULL;",
"g_free(sch);",
"return VAR_6;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
27
],
[
31
],
[
33
],
[
37
],
[
43
],
[
45
],
[
47
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91,
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
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
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235,
237
],
[
239
],
[
245
],
[
249
],
[
255
],
[
257
],
[
259
],
[
261
],
[
267,
269
],
[
273
],
[
275
],
[
279,
281
],
[
283
],
[
287,
289
],
[
291
],
[
293
],
[
295
]
] |
20,509 | static void pc_init_isa(MachineState *machine)
{
pci_enabled = false;
has_acpi_build = false;
smbios_defaults = false;
gigabyte_align = false;
smbios_legacy_mode = true;
has_reserved_memory = false;
option_rom_has_mr = true;
rom_file_has_mr = false;
if (!machine->cpu_model) {
machine->cpu_model = "486";
}
x86_cpu_change_kvm_default("kvm-pv-eoi", NULL);
enable_compat_apic_id_mode();
pc_init1(machine, TYPE_I440FX_PCI_HOST_BRIDGE, TYPE_I440FX_PCI_DEVICE);
}
| false | qemu | 7102fa7073b2cefb33ab4012a11f15fbf297a74b | static void pc_init_isa(MachineState *machine)
{
pci_enabled = false;
has_acpi_build = false;
smbios_defaults = false;
gigabyte_align = false;
smbios_legacy_mode = true;
has_reserved_memory = false;
option_rom_has_mr = true;
rom_file_has_mr = false;
if (!machine->cpu_model) {
machine->cpu_model = "486";
}
x86_cpu_change_kvm_default("kvm-pv-eoi", NULL);
enable_compat_apic_id_mode();
pc_init1(machine, TYPE_I440FX_PCI_HOST_BRIDGE, TYPE_I440FX_PCI_DEVICE);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(MachineState *VAR_0)
{
pci_enabled = false;
has_acpi_build = false;
smbios_defaults = false;
gigabyte_align = false;
smbios_legacy_mode = true;
has_reserved_memory = false;
option_rom_has_mr = true;
rom_file_has_mr = false;
if (!VAR_0->cpu_model) {
VAR_0->cpu_model = "486";
}
x86_cpu_change_kvm_default("kvm-pv-eoi", NULL);
enable_compat_apic_id_mode();
pc_init1(VAR_0, TYPE_I440FX_PCI_HOST_BRIDGE, TYPE_I440FX_PCI_DEVICE);
}
| [
"static void FUNC_0(MachineState *VAR_0)\n{",
"pci_enabled = false;",
"has_acpi_build = false;",
"smbios_defaults = false;",
"gigabyte_align = false;",
"smbios_legacy_mode = true;",
"has_reserved_memory = false;",
"option_rom_has_mr = true;",
"rom_file_has_mr = false;",
"if (!VAR_0->cpu_model) {",
"VAR_0->cpu_model = \"486\";",
"}",
"x86_cpu_change_kvm_default(\"kvm-pv-eoi\", NULL);",
"enable_compat_apic_id_mode();",
"pc_init1(VAR_0, TYPE_I440FX_PCI_HOST_BRIDGE, TYPE_I440FX_PCI_DEVICE);",
"}"
] | [
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
]
] |
20,510 | void qemu_aio_ref(void *p)
{
BlockAIOCB *acb = p;
acb->refcnt++;
}
| false | qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | void qemu_aio_ref(void *p)
{
BlockAIOCB *acb = p;
acb->refcnt++;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(void *VAR_0)
{
BlockAIOCB *acb = VAR_0;
acb->refcnt++;
}
| [
"void FUNC_0(void *VAR_0)\n{",
"BlockAIOCB *acb = VAR_0;",
"acb->refcnt++;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
20,511 | matroska_read_header (AVFormatContext *s,
AVFormatParameters *ap)
{
MatroskaDemuxContext *matroska = s->priv_data;
char *doctype;
int version, last_level, res = 0;
uint32_t id;
matroska->ctx = s;
/* First read the EBML header. */
doctype = NULL;
if ((res = ebml_read_header(matroska, &doctype, &version)) < 0)
return res;
if ((doctype == NULL) || strcmp(doctype, "matroska")) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Wrong EBML doctype ('%s' != 'matroska').\n",
doctype ? doctype : "(none)");
if (doctype)
av_free(doctype);
return AVERROR_NOFMT;
}
av_free(doctype);
if (version > 2) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Matroska demuxer version 2 too old for file version %d\n",
version);
return AVERROR_NOFMT;
}
/* The next thing is a segment. */
while (1) {
if (!(id = ebml_peek_id(matroska, &last_level)))
return AVERROR_IO;
if (id == MATROSKA_ID_SEGMENT)
break;
/* oi! */
av_log(matroska->ctx, AV_LOG_INFO,
"Expected a Segment ID (0x%x), but received 0x%x!\n",
MATROSKA_ID_SEGMENT, id);
if ((res = ebml_read_skip(matroska)) < 0)
return res;
}
/* We now have a Matroska segment.
* Seeks are from the beginning of the segment,
* after the segment ID/length. */
if ((res = ebml_read_master(matroska, &id)) < 0)
return res;
matroska->segment_start = url_ftell(&s->pb);
matroska->time_scale = 1000000;
/* we've found our segment, start reading the different contents in here */
while (res == 0) {
if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
res = AVERROR_IO;
break;
} else if (matroska->level_up) {
matroska->level_up--;
break;
}
switch (id) {
/* stream info */
case MATROSKA_ID_INFO: {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_info(matroska);
break;
}
/* track info headers */
case MATROSKA_ID_TRACKS: {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_tracks(matroska);
break;
}
/* stream index */
case MATROSKA_ID_CUES: {
if (!matroska->index_parsed) {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_index(matroska);
} else
res = ebml_read_skip(matroska);
break;
}
/* metadata */
case MATROSKA_ID_TAGS: {
if (!matroska->metadata_parsed) {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_metadata(matroska);
} else
res = ebml_read_skip(matroska);
break;
}
/* file index (if seekable, seek to Cues/Tags to parse it) */
case MATROSKA_ID_SEEKHEAD: {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_seekhead(matroska);
break;
}
case MATROSKA_ID_CLUSTER: {
/* Do not read the master - this will be done in the next
* call to matroska_read_packet. */
res = 1;
break;
}
default:
av_log(matroska->ctx, AV_LOG_INFO,
"Unknown matroska file header ID 0x%x\n", id);
/* fall-through */
case EBML_ID_VOID:
res = ebml_read_skip(matroska);
break;
}
if (matroska->level_up) {
matroska->level_up--;
break;
}
}
/* Have we found a cluster? */
if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {
int i, j;
MatroskaTrack *track;
AVStream *st;
for (i = 0; i < matroska->num_tracks; i++) {
enum CodecID codec_id = CODEC_ID_NONE;
uint8_t *extradata = NULL;
int extradata_size = 0;
int extradata_offset = 0;
track = matroska->tracks[i];
/* libavformat does not really support subtitles.
* Also apply some sanity checks. */
if ((track->type == MATROSKA_TRACK_TYPE_SUBTITLE) ||
(track->codec_id == NULL))
continue;
for(j=0; codec_tags[j].str; j++){
if(!strncmp(codec_tags[j].str, track->codec_id,
strlen(codec_tags[j].str))){
codec_id= codec_tags[j].id;
break;
}
}
/* Set the FourCC from the CodecID. */
/* This is the MS compatibility mode which stores a
* BITMAPINFOHEADER in the CodecPrivate. */
if (!strcmp(track->codec_id,
MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
(track->codec_priv_size >= 40) &&
(track->codec_priv != NULL)) {
unsigned char *p;
/* Offset of biCompression. Stored in LE. */
p = (unsigned char *)track->codec_priv + 16;
((MatroskaVideoTrack *)track)->fourcc = (p[3] << 24) |
(p[2] << 16) | (p[1] << 8) | p[0];
codec_id = codec_get_id(codec_bmp_tags, ((MatroskaVideoTrack *)track)->fourcc);
}
/* This is the MS compatibility mode which stores a
* WAVEFORMATEX in the CodecPrivate. */
else if (!strcmp(track->codec_id,
MATROSKA_CODEC_ID_AUDIO_ACM) &&
(track->codec_priv_size >= 18) &&
(track->codec_priv != NULL)) {
unsigned char *p;
uint16_t tag;
/* Offset of wFormatTag. Stored in LE. */
p = (unsigned char *)track->codec_priv;
tag = (p[1] << 8) | p[0];
codec_id = codec_get_id(codec_wav_tags, tag);
}
else if (codec_id == CODEC_ID_MPEG1VIDEO ||
codec_id == CODEC_ID_MPEG2VIDEO ||
codec_id == CODEC_ID_MPEG4 ||
codec_id == CODEC_ID_MSMPEG4V3 ||
codec_id == CODEC_ID_H264) {
track->flags |= MATROSKA_TRACK_REORDER;
}
else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
int profile = matroska_aac_profile(track->codec_id);
int sri = matroska_aac_sri(audiotrack->internal_samplerate);
extradata = av_malloc(5);
if (extradata == NULL)
return AVERROR_NOMEM;
extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3);
if (strstr(track->codec_id, "SBR")) {
sri = matroska_aac_sri(audiotrack->samplerate);
extradata[2] = 0x56;
extradata[3] = 0xE5;
extradata[4] = 0x80 | (sri<<3);
extradata_size = 5;
} else {
extradata_size = 2;
}
track->default_duration = 1024*1000 / audiotrack->internal_samplerate;
}
else if (codec_id == CODEC_ID_TTA) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
ByteIOContext b;
extradata_size = 30;
extradata = av_mallocz(extradata_size);
if (extradata == NULL)
return AVERROR_NOMEM;
init_put_byte(&b, extradata, extradata_size, 1,
NULL, NULL, NULL, NULL);
put_buffer(&b, (uint8_t *) "TTA1", 4);
put_le16(&b, 1);
put_le16(&b, audiotrack->channels);
put_le16(&b, audiotrack->bitdepth);
put_le32(&b, audiotrack->samplerate);
put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);
}
else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
extradata_offset = 26;
track->codec_priv_size -= extradata_offset;
track->flags |= MATROSKA_TRACK_REAL_V;
}
if (codec_id == CODEC_ID_NONE) {
av_log(matroska->ctx, AV_LOG_INFO,
"Unknown/unsupported CodecID %s.\n",
track->codec_id);
}
track->stream_index = matroska->num_streams;
matroska->num_streams++;
st = av_new_stream(s, track->stream_index);
if (st == NULL)
return AVERROR_NOMEM;
av_set_pts_info(st, 64, matroska->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
st->codec->codec_id = codec_id;
if (track->default_duration)
av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
track->default_duration, 1000, 30000);
if(extradata){
st->codec->extradata = extradata;
st->codec->extradata_size = extradata_size;
} else if(track->codec_priv && track->codec_priv_size > 0){
st->codec->extradata = av_malloc(track->codec_priv_size);
if(st->codec->extradata == NULL)
return AVERROR_NOMEM;
st->codec->extradata_size = track->codec_priv_size;
memcpy(st->codec->extradata,track->codec_priv+extradata_offset,
track->codec_priv_size);
}
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_tag = videotrack->fourcc;
st->codec->width = videotrack->pixel_width;
st->codec->height = videotrack->pixel_height;
if (videotrack->display_width == 0)
videotrack->display_width= videotrack->pixel_width;
if (videotrack->display_height == 0)
videotrack->display_height= videotrack->pixel_height;
av_reduce(&st->codec->sample_aspect_ratio.num,
&st->codec->sample_aspect_ratio.den,
st->codec->height * videotrack->display_width,
st->codec-> width * videotrack->display_height,
255);
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->sample_rate = audiotrack->samplerate;
st->codec->channels = audiotrack->channels;
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codec->codec_type = CODEC_TYPE_SUBTITLE;
}
/* What do we do with private data? E.g. for Vorbis. */
}
res = 0;
}
return res;
}
| false | FFmpeg | 262e2bee24194b88eba9e31edfc95ba3b39bc72f | matroska_read_header (AVFormatContext *s,
AVFormatParameters *ap)
{
MatroskaDemuxContext *matroska = s->priv_data;
char *doctype;
int version, last_level, res = 0;
uint32_t id;
matroska->ctx = s;
doctype = NULL;
if ((res = ebml_read_header(matroska, &doctype, &version)) < 0)
return res;
if ((doctype == NULL) || strcmp(doctype, "matroska")) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Wrong EBML doctype ('%s' != 'matroska').\n",
doctype ? doctype : "(none)");
if (doctype)
av_free(doctype);
return AVERROR_NOFMT;
}
av_free(doctype);
if (version > 2) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Matroska demuxer version 2 too old for file version %d\n",
version);
return AVERROR_NOFMT;
}
while (1) {
if (!(id = ebml_peek_id(matroska, &last_level)))
return AVERROR_IO;
if (id == MATROSKA_ID_SEGMENT)
break;
av_log(matroska->ctx, AV_LOG_INFO,
"Expected a Segment ID (0x%x), but received 0x%x!\n",
MATROSKA_ID_SEGMENT, id);
if ((res = ebml_read_skip(matroska)) < 0)
return res;
}
if ((res = ebml_read_master(matroska, &id)) < 0)
return res;
matroska->segment_start = url_ftell(&s->pb);
matroska->time_scale = 1000000;
while (res == 0) {
if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
res = AVERROR_IO;
break;
} else if (matroska->level_up) {
matroska->level_up--;
break;
}
switch (id) {
case MATROSKA_ID_INFO: {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_info(matroska);
break;
}
case MATROSKA_ID_TRACKS: {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_tracks(matroska);
break;
}
case MATROSKA_ID_CUES: {
if (!matroska->index_parsed) {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_index(matroska);
} else
res = ebml_read_skip(matroska);
break;
}
case MATROSKA_ID_TAGS: {
if (!matroska->metadata_parsed) {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_metadata(matroska);
} else
res = ebml_read_skip(matroska);
break;
}
case MATROSKA_ID_SEEKHEAD: {
if ((res = ebml_read_master(matroska, &id)) < 0)
break;
res = matroska_parse_seekhead(matroska);
break;
}
case MATROSKA_ID_CLUSTER: {
res = 1;
break;
}
default:
av_log(matroska->ctx, AV_LOG_INFO,
"Unknown matroska file header ID 0x%x\n", id);
case EBML_ID_VOID:
res = ebml_read_skip(matroska);
break;
}
if (matroska->level_up) {
matroska->level_up--;
break;
}
}
if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {
int i, j;
MatroskaTrack *track;
AVStream *st;
for (i = 0; i < matroska->num_tracks; i++) {
enum CodecID codec_id = CODEC_ID_NONE;
uint8_t *extradata = NULL;
int extradata_size = 0;
int extradata_offset = 0;
track = matroska->tracks[i];
if ((track->type == MATROSKA_TRACK_TYPE_SUBTITLE) ||
(track->codec_id == NULL))
continue;
for(j=0; codec_tags[j].str; j++){
if(!strncmp(codec_tags[j].str, track->codec_id,
strlen(codec_tags[j].str))){
codec_id= codec_tags[j].id;
break;
}
}
if (!strcmp(track->codec_id,
MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
(track->codec_priv_size >= 40) &&
(track->codec_priv != NULL)) {
unsigned char *p;
p = (unsigned char *)track->codec_priv + 16;
((MatroskaVideoTrack *)track)->fourcc = (p[3] << 24) |
(p[2] << 16) | (p[1] << 8) | p[0];
codec_id = codec_get_id(codec_bmp_tags, ((MatroskaVideoTrack *)track)->fourcc);
}
else if (!strcmp(track->codec_id,
MATROSKA_CODEC_ID_AUDIO_ACM) &&
(track->codec_priv_size >= 18) &&
(track->codec_priv != NULL)) {
unsigned char *p;
uint16_t tag;
p = (unsigned char *)track->codec_priv;
tag = (p[1] << 8) | p[0];
codec_id = codec_get_id(codec_wav_tags, tag);
}
else if (codec_id == CODEC_ID_MPEG1VIDEO ||
codec_id == CODEC_ID_MPEG2VIDEO ||
codec_id == CODEC_ID_MPEG4 ||
codec_id == CODEC_ID_MSMPEG4V3 ||
codec_id == CODEC_ID_H264) {
track->flags |= MATROSKA_TRACK_REORDER;
}
else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
int profile = matroska_aac_profile(track->codec_id);
int sri = matroska_aac_sri(audiotrack->internal_samplerate);
extradata = av_malloc(5);
if (extradata == NULL)
return AVERROR_NOMEM;
extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3);
if (strstr(track->codec_id, "SBR")) {
sri = matroska_aac_sri(audiotrack->samplerate);
extradata[2] = 0x56;
extradata[3] = 0xE5;
extradata[4] = 0x80 | (sri<<3);
extradata_size = 5;
} else {
extradata_size = 2;
}
track->default_duration = 1024*1000 / audiotrack->internal_samplerate;
}
else if (codec_id == CODEC_ID_TTA) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
ByteIOContext b;
extradata_size = 30;
extradata = av_mallocz(extradata_size);
if (extradata == NULL)
return AVERROR_NOMEM;
init_put_byte(&b, extradata, extradata_size, 1,
NULL, NULL, NULL, NULL);
put_buffer(&b, (uint8_t *) "TTA1", 4);
put_le16(&b, 1);
put_le16(&b, audiotrack->channels);
put_le16(&b, audiotrack->bitdepth);
put_le32(&b, audiotrack->samplerate);
put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);
}
else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
extradata_offset = 26;
track->codec_priv_size -= extradata_offset;
track->flags |= MATROSKA_TRACK_REAL_V;
}
if (codec_id == CODEC_ID_NONE) {
av_log(matroska->ctx, AV_LOG_INFO,
"Unknown/unsupported CodecID %s.\n",
track->codec_id);
}
track->stream_index = matroska->num_streams;
matroska->num_streams++;
st = av_new_stream(s, track->stream_index);
if (st == NULL)
return AVERROR_NOMEM;
av_set_pts_info(st, 64, matroska->time_scale, 1000*1000*1000);
st->codec->codec_id = codec_id;
if (track->default_duration)
av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
track->default_duration, 1000, 30000);
if(extradata){
st->codec->extradata = extradata;
st->codec->extradata_size = extradata_size;
} else if(track->codec_priv && track->codec_priv_size > 0){
st->codec->extradata = av_malloc(track->codec_priv_size);
if(st->codec->extradata == NULL)
return AVERROR_NOMEM;
st->codec->extradata_size = track->codec_priv_size;
memcpy(st->codec->extradata,track->codec_priv+extradata_offset,
track->codec_priv_size);
}
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_tag = videotrack->fourcc;
st->codec->width = videotrack->pixel_width;
st->codec->height = videotrack->pixel_height;
if (videotrack->display_width == 0)
videotrack->display_width= videotrack->pixel_width;
if (videotrack->display_height == 0)
videotrack->display_height= videotrack->pixel_height;
av_reduce(&st->codec->sample_aspect_ratio.num,
&st->codec->sample_aspect_ratio.den,
st->codec->height * videotrack->display_width,
st->codec-> width * videotrack->display_height,
255);
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->sample_rate = audiotrack->samplerate;
st->codec->channels = audiotrack->channels;
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codec->codec_type = CODEC_TYPE_SUBTITLE;
}
}
res = 0;
}
return res;
}
| {
"code": [],
"line_no": []
} | FUNC_0 (AVFormatContext *VAR_0,
AVFormatParameters *VAR_1)
{
MatroskaDemuxContext *matroska = VAR_0->priv_data;
char *VAR_2;
int VAR_3, VAR_4, VAR_5 = 0;
uint32_t id;
matroska->ctx = VAR_0;
VAR_2 = NULL;
if ((VAR_5 = ebml_read_header(matroska, &VAR_2, &VAR_3)) < 0)
return VAR_5;
if ((VAR_2 == NULL) || strcmp(VAR_2, "matroska")) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Wrong EBML VAR_2 ('%VAR_0' != 'matroska').\n",
VAR_2 ? VAR_2 : "(none)");
if (VAR_2)
av_free(VAR_2);
return AVERROR_NOFMT;
}
av_free(VAR_2);
if (VAR_3 > 2) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Matroska demuxer VAR_3 2 too old for file VAR_3 %d\n",
VAR_3);
return AVERROR_NOFMT;
}
while (1) {
if (!(id = ebml_peek_id(matroska, &VAR_4)))
return AVERROR_IO;
if (id == MATROSKA_ID_SEGMENT)
break;
av_log(matroska->ctx, AV_LOG_INFO,
"Expected a Segment ID (0x%x), but received 0x%x!\n",
MATROSKA_ID_SEGMENT, id);
if ((VAR_5 = ebml_read_skip(matroska)) < 0)
return VAR_5;
}
if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)
return VAR_5;
matroska->segment_start = url_ftell(&VAR_0->pb);
matroska->time_scale = 1000000;
while (VAR_5 == 0) {
if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
VAR_5 = AVERROR_IO;
break;
} else if (matroska->level_up) {
matroska->level_up--;
break;
}
switch (id) {
case MATROSKA_ID_INFO: {
if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)
break;
VAR_5 = matroska_parse_info(matroska);
break;
}
case MATROSKA_ID_TRACKS: {
if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)
break;
VAR_5 = matroska_parse_tracks(matroska);
break;
}
case MATROSKA_ID_CUES: {
if (!matroska->index_parsed) {
if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)
break;
VAR_5 = matroska_parse_index(matroska);
} else
VAR_5 = ebml_read_skip(matroska);
break;
}
case MATROSKA_ID_TAGS: {
if (!matroska->metadata_parsed) {
if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)
break;
VAR_5 = matroska_parse_metadata(matroska);
} else
VAR_5 = ebml_read_skip(matroska);
break;
}
case MATROSKA_ID_SEEKHEAD: {
if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)
break;
VAR_5 = matroska_parse_seekhead(matroska);
break;
}
case MATROSKA_ID_CLUSTER: {
VAR_5 = 1;
break;
}
default:
av_log(matroska->ctx, AV_LOG_INFO,
"Unknown matroska file header ID 0x%x\n", id);
case EBML_ID_VOID:
VAR_5 = ebml_read_skip(matroska);
break;
}
if (matroska->level_up) {
matroska->level_up--;
break;
}
}
if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {
int VAR_6, VAR_7;
MatroskaTrack *track;
AVStream *st;
for (VAR_6 = 0; VAR_6 < matroska->num_tracks; VAR_6++) {
enum CodecID codec_id = CODEC_ID_NONE;
uint8_t *extradata = NULL;
int extradata_size = 0;
int extradata_offset = 0;
track = matroska->tracks[VAR_6];
if ((track->type == MATROSKA_TRACK_TYPE_SUBTITLE) ||
(track->codec_id == NULL))
continue;
for(VAR_7=0; codec_tags[VAR_7].str; VAR_7++){
if(!strncmp(codec_tags[VAR_7].str, track->codec_id,
strlen(codec_tags[VAR_7].str))){
codec_id= codec_tags[VAR_7].id;
break;
}
}
if (!strcmp(track->codec_id,
MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
(track->codec_priv_size >= 40) &&
(track->codec_priv != NULL)) {
unsigned char *p;
p = (unsigned char *)track->codec_priv + 16;
((MatroskaVideoTrack *)track)->fourcc = (p[3] << 24) |
(p[2] << 16) | (p[1] << 8) | p[0];
codec_id = codec_get_id(codec_bmp_tags, ((MatroskaVideoTrack *)track)->fourcc);
}
else if (!strcmp(track->codec_id,
MATROSKA_CODEC_ID_AUDIO_ACM) &&
(track->codec_priv_size >= 18) &&
(track->codec_priv != NULL)) {
unsigned char *p;
uint16_t tag;
p = (unsigned char *)track->codec_priv;
tag = (p[1] << 8) | p[0];
codec_id = codec_get_id(codec_wav_tags, tag);
}
else if (codec_id == CODEC_ID_MPEG1VIDEO ||
codec_id == CODEC_ID_MPEG2VIDEO ||
codec_id == CODEC_ID_MPEG4 ||
codec_id == CODEC_ID_MSMPEG4V3 ||
codec_id == CODEC_ID_H264) {
track->flags |= MATROSKA_TRACK_REORDER;
}
else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
int profile = matroska_aac_profile(track->codec_id);
int sri = matroska_aac_sri(audiotrack->internal_samplerate);
extradata = av_malloc(5);
if (extradata == NULL)
return AVERROR_NOMEM;
extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3);
if (strstr(track->codec_id, "SBR")) {
sri = matroska_aac_sri(audiotrack->samplerate);
extradata[2] = 0x56;
extradata[3] = 0xE5;
extradata[4] = 0x80 | (sri<<3);
extradata_size = 5;
} else {
extradata_size = 2;
}
track->default_duration = 1024*1000 / audiotrack->internal_samplerate;
}
else if (codec_id == CODEC_ID_TTA) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
ByteIOContext b;
extradata_size = 30;
extradata = av_mallocz(extradata_size);
if (extradata == NULL)
return AVERROR_NOMEM;
init_put_byte(&b, extradata, extradata_size, 1,
NULL, NULL, NULL, NULL);
put_buffer(&b, (uint8_t *) "TTA1", 4);
put_le16(&b, 1);
put_le16(&b, audiotrack->channels);
put_le16(&b, audiotrack->bitdepth);
put_le32(&b, audiotrack->samplerate);
put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);
}
else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
extradata_offset = 26;
track->codec_priv_size -= extradata_offset;
track->flags |= MATROSKA_TRACK_REAL_V;
}
if (codec_id == CODEC_ID_NONE) {
av_log(matroska->ctx, AV_LOG_INFO,
"Unknown/unsupported CodecID %VAR_0.\n",
track->codec_id);
}
track->stream_index = matroska->num_streams;
matroska->num_streams++;
st = av_new_stream(VAR_0, track->stream_index);
if (st == NULL)
return AVERROR_NOMEM;
av_set_pts_info(st, 64, matroska->time_scale, 1000*1000*1000);
st->codec->codec_id = codec_id;
if (track->default_duration)
av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
track->default_duration, 1000, 30000);
if(extradata){
st->codec->extradata = extradata;
st->codec->extradata_size = extradata_size;
} else if(track->codec_priv && track->codec_priv_size > 0){
st->codec->extradata = av_malloc(track->codec_priv_size);
if(st->codec->extradata == NULL)
return AVERROR_NOMEM;
st->codec->extradata_size = track->codec_priv_size;
memcpy(st->codec->extradata,track->codec_priv+extradata_offset,
track->codec_priv_size);
}
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_tag = videotrack->fourcc;
st->codec->width = videotrack->pixel_width;
st->codec->height = videotrack->pixel_height;
if (videotrack->display_width == 0)
videotrack->display_width= videotrack->pixel_width;
if (videotrack->display_height == 0)
videotrack->display_height= videotrack->pixel_height;
av_reduce(&st->codec->sample_aspect_ratio.num,
&st->codec->sample_aspect_ratio.den,
st->codec->height * videotrack->display_width,
st->codec-> width * videotrack->display_height,
255);
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->sample_rate = audiotrack->samplerate;
st->codec->channels = audiotrack->channels;
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codec->codec_type = CODEC_TYPE_SUBTITLE;
}
}
VAR_5 = 0;
}
return VAR_5;
}
| [
"FUNC_0 (AVFormatContext *VAR_0,\nAVFormatParameters *VAR_1)\n{",
"MatroskaDemuxContext *matroska = VAR_0->priv_data;",
"char *VAR_2;",
"int VAR_3, VAR_4, VAR_5 = 0;",
"uint32_t id;",
"matroska->ctx = VAR_0;",
"VAR_2 = NULL;",
"if ((VAR_5 = ebml_read_header(matroska, &VAR_2, &VAR_3)) < 0)\nreturn VAR_5;",
"if ((VAR_2 == NULL) || strcmp(VAR_2, \"matroska\")) {",
"av_log(matroska->ctx, AV_LOG_ERROR,\n\"Wrong EBML VAR_2 ('%VAR_0' != 'matroska').\\n\",\nVAR_2 ? VAR_2 : \"(none)\");",
"if (VAR_2)\nav_free(VAR_2);",
"return AVERROR_NOFMT;",
"}",
"av_free(VAR_2);",
"if (VAR_3 > 2) {",
"av_log(matroska->ctx, AV_LOG_ERROR,\n\"Matroska demuxer VAR_3 2 too old for file VAR_3 %d\\n\",\nVAR_3);",
"return AVERROR_NOFMT;",
"}",
"while (1) {",
"if (!(id = ebml_peek_id(matroska, &VAR_4)))\nreturn AVERROR_IO;",
"if (id == MATROSKA_ID_SEGMENT)\nbreak;",
"av_log(matroska->ctx, AV_LOG_INFO,\n\"Expected a Segment ID (0x%x), but received 0x%x!\\n\",\nMATROSKA_ID_SEGMENT, id);",
"if ((VAR_5 = ebml_read_skip(matroska)) < 0)\nreturn VAR_5;",
"}",
"if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)\nreturn VAR_5;",
"matroska->segment_start = url_ftell(&VAR_0->pb);",
"matroska->time_scale = 1000000;",
"while (VAR_5 == 0) {",
"if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {",
"VAR_5 = AVERROR_IO;",
"break;",
"} else if (matroska->level_up) {",
"matroska->level_up--;",
"break;",
"}",
"switch (id) {",
"case MATROSKA_ID_INFO: {",
"if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)\nbreak;",
"VAR_5 = matroska_parse_info(matroska);",
"break;",
"}",
"case MATROSKA_ID_TRACKS: {",
"if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)\nbreak;",
"VAR_5 = matroska_parse_tracks(matroska);",
"break;",
"}",
"case MATROSKA_ID_CUES: {",
"if (!matroska->index_parsed) {",
"if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)\nbreak;",
"VAR_5 = matroska_parse_index(matroska);",
"} else",
"VAR_5 = ebml_read_skip(matroska);",
"break;",
"}",
"case MATROSKA_ID_TAGS: {",
"if (!matroska->metadata_parsed) {",
"if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)\nbreak;",
"VAR_5 = matroska_parse_metadata(matroska);",
"} else",
"VAR_5 = ebml_read_skip(matroska);",
"break;",
"}",
"case MATROSKA_ID_SEEKHEAD: {",
"if ((VAR_5 = ebml_read_master(matroska, &id)) < 0)\nbreak;",
"VAR_5 = matroska_parse_seekhead(matroska);",
"break;",
"}",
"case MATROSKA_ID_CLUSTER: {",
"VAR_5 = 1;",
"break;",
"}",
"default:\nav_log(matroska->ctx, AV_LOG_INFO,\n\"Unknown matroska file header ID 0x%x\\n\", id);",
"case EBML_ID_VOID:\nVAR_5 = ebml_read_skip(matroska);",
"break;",
"}",
"if (matroska->level_up) {",
"matroska->level_up--;",
"break;",
"}",
"}",
"if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {",
"int VAR_6, VAR_7;",
"MatroskaTrack *track;",
"AVStream *st;",
"for (VAR_6 = 0; VAR_6 < matroska->num_tracks; VAR_6++) {",
"enum CodecID codec_id = CODEC_ID_NONE;",
"uint8_t *extradata = NULL;",
"int extradata_size = 0;",
"int extradata_offset = 0;",
"track = matroska->tracks[VAR_6];",
"if ((track->type == MATROSKA_TRACK_TYPE_SUBTITLE) ||\n(track->codec_id == NULL))\ncontinue;",
"for(VAR_7=0; codec_tags[VAR_7].str; VAR_7++){",
"if(!strncmp(codec_tags[VAR_7].str, track->codec_id,\nstrlen(codec_tags[VAR_7].str))){",
"codec_id= codec_tags[VAR_7].id;",
"break;",
"}",
"}",
"if (!strcmp(track->codec_id,\nMATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&\n(track->codec_priv_size >= 40) &&\n(track->codec_priv != NULL)) {",
"unsigned char *p;",
"p = (unsigned char *)track->codec_priv + 16;",
"((MatroskaVideoTrack *)track)->fourcc = (p[3] << 24) |\n(p[2] << 16) | (p[1] << 8) | p[0];",
"codec_id = codec_get_id(codec_bmp_tags, ((MatroskaVideoTrack *)track)->fourcc);",
"}",
"else if (!strcmp(track->codec_id,\nMATROSKA_CODEC_ID_AUDIO_ACM) &&\n(track->codec_priv_size >= 18) &&\n(track->codec_priv != NULL)) {",
"unsigned char *p;",
"uint16_t tag;",
"p = (unsigned char *)track->codec_priv;",
"tag = (p[1] << 8) | p[0];",
"codec_id = codec_get_id(codec_wav_tags, tag);",
"}",
"else if (codec_id == CODEC_ID_MPEG1VIDEO ||\ncodec_id == CODEC_ID_MPEG2VIDEO ||\ncodec_id == CODEC_ID_MPEG4 ||\ncodec_id == CODEC_ID_MSMPEG4V3 ||\ncodec_id == CODEC_ID_H264) {",
"track->flags |= MATROSKA_TRACK_REORDER;",
"}",
"else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {",
"MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;",
"int profile = matroska_aac_profile(track->codec_id);",
"int sri = matroska_aac_sri(audiotrack->internal_samplerate);",
"extradata = av_malloc(5);",
"if (extradata == NULL)\nreturn AVERROR_NOMEM;",
"extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);",
"extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3);",
"if (strstr(track->codec_id, \"SBR\")) {",
"sri = matroska_aac_sri(audiotrack->samplerate);",
"extradata[2] = 0x56;",
"extradata[3] = 0xE5;",
"extradata[4] = 0x80 | (sri<<3);",
"extradata_size = 5;",
"} else {",
"extradata_size = 2;",
"}",
"track->default_duration = 1024*1000 / audiotrack->internal_samplerate;",
"}",
"else if (codec_id == CODEC_ID_TTA) {",
"MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;",
"ByteIOContext b;",
"extradata_size = 30;",
"extradata = av_mallocz(extradata_size);",
"if (extradata == NULL)\nreturn AVERROR_NOMEM;",
"init_put_byte(&b, extradata, extradata_size, 1,\nNULL, NULL, NULL, NULL);",
"put_buffer(&b, (uint8_t *) \"TTA1\", 4);",
"put_le16(&b, 1);",
"put_le16(&b, audiotrack->channels);",
"put_le16(&b, audiotrack->bitdepth);",
"put_le32(&b, audiotrack->samplerate);",
"put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);",
"}",
"else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||\ncodec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {",
"extradata_offset = 26;",
"track->codec_priv_size -= extradata_offset;",
"track->flags |= MATROSKA_TRACK_REAL_V;",
"}",
"if (codec_id == CODEC_ID_NONE) {",
"av_log(matroska->ctx, AV_LOG_INFO,\n\"Unknown/unsupported CodecID %VAR_0.\\n\",\ntrack->codec_id);",
"}",
"track->stream_index = matroska->num_streams;",
"matroska->num_streams++;",
"st = av_new_stream(VAR_0, track->stream_index);",
"if (st == NULL)\nreturn AVERROR_NOMEM;",
"av_set_pts_info(st, 64, matroska->time_scale, 1000*1000*1000);",
"st->codec->codec_id = codec_id;",
"if (track->default_duration)\nav_reduce(&st->codec->time_base.num, &st->codec->time_base.den,\ntrack->default_duration, 1000, 30000);",
"if(extradata){",
"st->codec->extradata = extradata;",
"st->codec->extradata_size = extradata_size;",
"} else if(track->codec_priv && track->codec_priv_size > 0){",
"st->codec->extradata = av_malloc(track->codec_priv_size);",
"if(st->codec->extradata == NULL)\nreturn AVERROR_NOMEM;",
"st->codec->extradata_size = track->codec_priv_size;",
"memcpy(st->codec->extradata,track->codec_priv+extradata_offset,\ntrack->codec_priv_size);",
"}",
"if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {",
"MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;",
"st->codec->codec_type = CODEC_TYPE_VIDEO;",
"st->codec->codec_tag = videotrack->fourcc;",
"st->codec->width = videotrack->pixel_width;",
"st->codec->height = videotrack->pixel_height;",
"if (videotrack->display_width == 0)\nvideotrack->display_width= videotrack->pixel_width;",
"if (videotrack->display_height == 0)\nvideotrack->display_height= videotrack->pixel_height;",
"av_reduce(&st->codec->sample_aspect_ratio.num,\n&st->codec->sample_aspect_ratio.den,\nst->codec->height * videotrack->display_width,\nst->codec-> width * videotrack->display_height,\n255);",
"} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {",
"MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;",
"st->codec->codec_type = CODEC_TYPE_AUDIO;",
"st->codec->sample_rate = audiotrack->samplerate;",
"st->codec->channels = audiotrack->channels;",
"} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {",
"st->codec->codec_type = CODEC_TYPE_SUBTITLE;",
"}",
"}",
"VAR_5 = 0;",
"}",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49,
51,
53
],
[
55
],
[
57
],
[
63
],
[
65,
67
],
[
69,
71
],
[
77,
79,
81
],
[
83,
85
],
[
87
],
[
97,
99
],
[
101
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
127
],
[
131
],
[
133,
135
],
[
137
],
[
139
],
[
141
],
[
147
],
[
149,
151
],
[
153
],
[
155
],
[
157
],
[
163
],
[
165
],
[
167,
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
185
],
[
187
],
[
189,
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
207
],
[
209,
211
],
[
213
],
[
215
],
[
217
],
[
221
],
[
227
],
[
229
],
[
231
],
[
235,
237,
239
],
[
245,
247
],
[
249
],
[
251
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
269
],
[
271
],
[
273
],
[
275
],
[
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
297,
299,
301
],
[
305
],
[
307,
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
327,
329,
331,
333
],
[
335
],
[
341
],
[
343,
345
],
[
347
],
[
351
],
[
359,
361,
363,
365
],
[
367
],
[
369
],
[
375
],
[
377
],
[
379
],
[
383
],
[
387,
389,
391,
393,
395
],
[
397
],
[
399
],
[
403
],
[
405
],
[
407
],
[
409
],
[
411
],
[
413,
415
],
[
417
],
[
419
],
[
421
],
[
423
],
[
425
],
[
427
],
[
429
],
[
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
445
],
[
447
],
[
449
],
[
451
],
[
453
],
[
455,
457
],
[
459,
461
],
[
463
],
[
465
],
[
467
],
[
469
],
[
471
],
[
473
],
[
475
],
[
479,
481
],
[
483
],
[
485
],
[
487
],
[
489
],
[
493
],
[
495,
497,
499
],
[
501
],
[
505
],
[
509
],
[
511
],
[
513,
515
],
[
517
],
[
521
],
[
525,
527,
529
],
[
533
],
[
535
],
[
537
],
[
539
],
[
541
],
[
543,
545
],
[
547
],
[
549,
551
],
[
553
],
[
557
],
[
559
],
[
563
],
[
565
],
[
567
],
[
569
],
[
571,
573
],
[
575,
577
],
[
579,
581,
583,
585,
587
],
[
589
],
[
591
],
[
595
],
[
597
],
[
599
],
[
601
],
[
603
],
[
605
],
[
611
],
[
613
],
[
615
],
[
619
],
[
621
]
] |
20,512 | void spapr_drc_detach(sPAPRDRConnector *drc)
{
trace_spapr_drc_detach(spapr_drc_index(drc));
drc->unplug_requested = true;
if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
trace_spapr_drc_awaiting_isolated(spapr_drc_index(drc));
return;
}
if (spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PCI &&
drc->allocation_state != SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {
trace_spapr_drc_awaiting_unusable(spapr_drc_index(drc));
return;
}
spapr_drc_release(drc);
}
| false | qemu | 9d4c0f4f0a71e74fd7e04d73620268484d693adf | void spapr_drc_detach(sPAPRDRConnector *drc)
{
trace_spapr_drc_detach(spapr_drc_index(drc));
drc->unplug_requested = true;
if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
trace_spapr_drc_awaiting_isolated(spapr_drc_index(drc));
return;
}
if (spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PCI &&
drc->allocation_state != SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {
trace_spapr_drc_awaiting_unusable(spapr_drc_index(drc));
return;
}
spapr_drc_release(drc);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(sPAPRDRConnector *VAR_0)
{
trace_spapr_drc_detach(spapr_drc_index(VAR_0));
VAR_0->unplug_requested = true;
if (VAR_0->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
trace_spapr_drc_awaiting_isolated(spapr_drc_index(VAR_0));
return;
}
if (spapr_drc_type(VAR_0) != SPAPR_DR_CONNECTOR_TYPE_PCI &&
VAR_0->allocation_state != SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {
trace_spapr_drc_awaiting_unusable(spapr_drc_index(VAR_0));
return;
}
spapr_drc_release(VAR_0);
}
| [
"void FUNC_0(sPAPRDRConnector *VAR_0)\n{",
"trace_spapr_drc_detach(spapr_drc_index(VAR_0));",
"VAR_0->unplug_requested = true;",
"if (VAR_0->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {",
"trace_spapr_drc_awaiting_isolated(spapr_drc_index(VAR_0));",
"return;",
"}",
"if (spapr_drc_type(VAR_0) != SPAPR_DR_CONNECTOR_TYPE_PCI &&\nVAR_0->allocation_state != SPAPR_DR_ALLOCATION_STATE_UNUSABLE) {",
"trace_spapr_drc_awaiting_unusable(spapr_drc_index(VAR_0));",
"return;",
"}",
"spapr_drc_release(VAR_0);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
]
] |
20,513 | void cpu_outb(CPUState *env, pio_addr_t addr, uint8_t val)
{
LOG_IOPORT("outb: %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
ioport_write(0, addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
}
| false | qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | void cpu_outb(CPUState *env, pio_addr_t addr, uint8_t val)
{
LOG_IOPORT("outb: %04"FMT_pioaddr" %02"PRIx8"\n", addr, val);
ioport_write(0, addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUState *VAR_0, pio_addr_t VAR_1, uint8_t VAR_2)
{
LOG_IOPORT("outb: %04"FMT_pioaddr" %02"PRIx8"\n", VAR_1, VAR_2);
ioport_write(0, VAR_1, VAR_2);
#ifdef CONFIG_KQEMU
if (VAR_0)
VAR_0->last_io_time = cpu_get_time_fast();
#endif
}
| [
"void FUNC_0(CPUState *VAR_0, pio_addr_t VAR_1, uint8_t VAR_2)\n{",
"LOG_IOPORT(\"outb: %04\"FMT_pioaddr\" %02\"PRIx8\"\\n\", VAR_1, VAR_2);",
"ioport_write(0, VAR_1, VAR_2);",
"#ifdef CONFIG_KQEMU\nif (VAR_0)\nVAR_0->last_io_time = cpu_get_time_fast();",
"#endif\n}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9,
11,
13
],
[
15,
17
]
] |
20,514 | void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata,
const char *magic, ID3v2ExtraMeta **extra_meta)
{
id3v2_read_internal(pb, metadata, NULL, magic, extra_meta);
}
| false | FFmpeg | 5331773cc33ba26b9e26ace643d926219e46a17b | void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata,
const char *magic, ID3v2ExtraMeta **extra_meta)
{
id3v2_read_internal(pb, metadata, NULL, magic, extra_meta);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(AVIOContext *VAR_0, AVDictionary **VAR_1,
const char *VAR_2, ID3v2ExtraMeta **VAR_3)
{
id3v2_read_internal(VAR_0, VAR_1, NULL, VAR_2, VAR_3);
}
| [
"void FUNC_0(AVIOContext *VAR_0, AVDictionary **VAR_1,\nconst char *VAR_2, ID3v2ExtraMeta **VAR_3)\n{",
"id3v2_read_internal(VAR_0, VAR_1, NULL, VAR_2, VAR_3);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
]
] |
20,515 | int ff_lpc_calc_coefs(DSPContext *s,
const int32_t *samples, int blocksize, int min_order,
int max_order, int precision,
int32_t coefs[][MAX_LPC_ORDER], int *shift, int use_lpc,
int omethod, int max_shift, int zero_shift)
{
double autoc[MAX_LPC_ORDER+1];
double ref[MAX_LPC_ORDER];
double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];
int i, j, pass;
int opt_order;
assert(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER);
if(use_lpc == 1){
s->flac_compute_autocorr(samples, blocksize, max_order, autoc);
compute_lpc_coefs(autoc, max_order, &lpc[0][0], MAX_LPC_ORDER, 0, 1);
for(i=0; i<max_order; i++)
ref[i] = fabs(lpc[i][i]);
}else{
LLSModel m[2];
double var[MAX_LPC_ORDER+1], weight;
for(pass=0; pass<use_lpc-1; pass++){
av_init_lls(&m[pass&1], max_order);
weight=0;
for(i=max_order; i<blocksize; i++){
for(j=0; j<=max_order; j++)
var[j]= samples[i-j];
if(pass){
double eval, inv, rinv;
eval= av_evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
eval= (512>>pass) + fabs(eval - var[0]);
inv = 1/eval;
rinv = sqrt(inv);
for(j=0; j<=max_order; j++)
var[j] *= rinv;
weight += inv;
}else
weight++;
av_update_lls(&m[pass&1], var, 1.0);
}
av_solve_lls(&m[pass&1], 0.001, 0);
}
for(i=0; i<max_order; i++){
for(j=0; j<max_order; j++)
lpc[i][j]=-m[(pass-1)&1].coeff[i][j];
ref[i]= sqrt(m[(pass-1)&1].variance[i] / weight) * (blocksize - max_order) / 4000;
}
for(i=max_order-1; i>0; i--)
ref[i] = ref[i-1] - ref[i];
}
opt_order = max_order;
if(omethod == ORDER_METHOD_EST) {
opt_order = estimate_best_order(ref, min_order, max_order);
i = opt_order-1;
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);
} else {
for(i=min_order-1; i<max_order; i++) {
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);
}
}
return opt_order;
}
| false | FFmpeg | eabe8c7033945d8042ebb75b08daed24d8852a10 | int ff_lpc_calc_coefs(DSPContext *s,
const int32_t *samples, int blocksize, int min_order,
int max_order, int precision,
int32_t coefs[][MAX_LPC_ORDER], int *shift, int use_lpc,
int omethod, int max_shift, int zero_shift)
{
double autoc[MAX_LPC_ORDER+1];
double ref[MAX_LPC_ORDER];
double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];
int i, j, pass;
int opt_order;
assert(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER);
if(use_lpc == 1){
s->flac_compute_autocorr(samples, blocksize, max_order, autoc);
compute_lpc_coefs(autoc, max_order, &lpc[0][0], MAX_LPC_ORDER, 0, 1);
for(i=0; i<max_order; i++)
ref[i] = fabs(lpc[i][i]);
}else{
LLSModel m[2];
double var[MAX_LPC_ORDER+1], weight;
for(pass=0; pass<use_lpc-1; pass++){
av_init_lls(&m[pass&1], max_order);
weight=0;
for(i=max_order; i<blocksize; i++){
for(j=0; j<=max_order; j++)
var[j]= samples[i-j];
if(pass){
double eval, inv, rinv;
eval= av_evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
eval= (512>>pass) + fabs(eval - var[0]);
inv = 1/eval;
rinv = sqrt(inv);
for(j=0; j<=max_order; j++)
var[j] *= rinv;
weight += inv;
}else
weight++;
av_update_lls(&m[pass&1], var, 1.0);
}
av_solve_lls(&m[pass&1], 0.001, 0);
}
for(i=0; i<max_order; i++){
for(j=0; j<max_order; j++)
lpc[i][j]=-m[(pass-1)&1].coeff[i][j];
ref[i]= sqrt(m[(pass-1)&1].variance[i] / weight) * (blocksize - max_order) / 4000;
}
for(i=max_order-1; i>0; i--)
ref[i] = ref[i-1] - ref[i];
}
opt_order = max_order;
if(omethod == ORDER_METHOD_EST) {
opt_order = estimate_best_order(ref, min_order, max_order);
i = opt_order-1;
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);
} else {
for(i=min_order-1; i<max_order; i++) {
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);
}
}
return opt_order;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(DSPContext *VAR_0,
const int32_t *VAR_1, int VAR_2, int VAR_3,
int VAR_4, int VAR_5,
int32_t VAR_6[][MAX_LPC_ORDER], int *VAR_7, int VAR_8,
int VAR_9, int VAR_10, int VAR_11)
{
double VAR_12[MAX_LPC_ORDER+1];
double VAR_13[MAX_LPC_ORDER];
double VAR_14[MAX_LPC_ORDER][MAX_LPC_ORDER];
int VAR_15, VAR_16, VAR_17;
int VAR_18;
assert(VAR_4 >= MIN_LPC_ORDER && VAR_4 <= MAX_LPC_ORDER);
if(VAR_8 == 1){
VAR_0->flac_compute_autocorr(VAR_1, VAR_2, VAR_4, VAR_12);
compute_lpc_coefs(VAR_12, VAR_4, &VAR_14[0][0], MAX_LPC_ORDER, 0, 1);
for(VAR_15=0; VAR_15<VAR_4; VAR_15++)
VAR_13[VAR_15] = fabs(VAR_14[VAR_15][VAR_15]);
}else{
LLSModel m[2];
double VAR_19[MAX_LPC_ORDER+1], weight;
for(VAR_17=0; VAR_17<VAR_8-1; VAR_17++){
av_init_lls(&m[VAR_17&1], VAR_4);
weight=0;
for(VAR_15=VAR_4; VAR_15<VAR_2; VAR_15++){
for(VAR_16=0; VAR_16<=VAR_4; VAR_16++)
VAR_19[VAR_16]= VAR_1[VAR_15-VAR_16];
if(VAR_17){
double VAR_20, VAR_21, VAR_22;
VAR_20= av_evaluate_lls(&m[(VAR_17-1)&1], VAR_19+1, VAR_4-1);
VAR_20= (512>>VAR_17) + fabs(VAR_20 - VAR_19[0]);
VAR_21 = 1/VAR_20;
VAR_22 = sqrt(VAR_21);
for(VAR_16=0; VAR_16<=VAR_4; VAR_16++)
VAR_19[VAR_16] *= VAR_22;
weight += VAR_21;
}else
weight++;
av_update_lls(&m[VAR_17&1], VAR_19, 1.0);
}
av_solve_lls(&m[VAR_17&1], 0.001, 0);
}
for(VAR_15=0; VAR_15<VAR_4; VAR_15++){
for(VAR_16=0; VAR_16<VAR_4; VAR_16++)
VAR_14[VAR_15][VAR_16]=-m[(VAR_17-1)&1].coeff[VAR_15][VAR_16];
VAR_13[VAR_15]= sqrt(m[(VAR_17-1)&1].variance[VAR_15] / weight) * (VAR_2 - VAR_4) / 4000;
}
for(VAR_15=VAR_4-1; VAR_15>0; VAR_15--)
VAR_13[VAR_15] = VAR_13[VAR_15-1] - VAR_13[VAR_15];
}
VAR_18 = VAR_4;
if(VAR_9 == ORDER_METHOD_EST) {
VAR_18 = estimate_best_order(VAR_13, VAR_3, VAR_4);
VAR_15 = VAR_18-1;
quantize_lpc_coefs(VAR_14[VAR_15], VAR_15+1, VAR_5, VAR_6[VAR_15], &VAR_7[VAR_15], VAR_10, VAR_11);
} else {
for(VAR_15=VAR_3-1; VAR_15<VAR_4; VAR_15++) {
quantize_lpc_coefs(VAR_14[VAR_15], VAR_15+1, VAR_5, VAR_6[VAR_15], &VAR_7[VAR_15], VAR_10, VAR_11);
}
}
return VAR_18;
}
| [
"int FUNC_0(DSPContext *VAR_0,\nconst int32_t *VAR_1, int VAR_2, int VAR_3,\nint VAR_4, int VAR_5,\nint32_t VAR_6[][MAX_LPC_ORDER], int *VAR_7, int VAR_8,\nint VAR_9, int VAR_10, int VAR_11)\n{",
"double VAR_12[MAX_LPC_ORDER+1];",
"double VAR_13[MAX_LPC_ORDER];",
"double VAR_14[MAX_LPC_ORDER][MAX_LPC_ORDER];",
"int VAR_15, VAR_16, VAR_17;",
"int VAR_18;",
"assert(VAR_4 >= MIN_LPC_ORDER && VAR_4 <= MAX_LPC_ORDER);",
"if(VAR_8 == 1){",
"VAR_0->flac_compute_autocorr(VAR_1, VAR_2, VAR_4, VAR_12);",
"compute_lpc_coefs(VAR_12, VAR_4, &VAR_14[0][0], MAX_LPC_ORDER, 0, 1);",
"for(VAR_15=0; VAR_15<VAR_4; VAR_15++)",
"VAR_13[VAR_15] = fabs(VAR_14[VAR_15][VAR_15]);",
"}else{",
"LLSModel m[2];",
"double VAR_19[MAX_LPC_ORDER+1], weight;",
"for(VAR_17=0; VAR_17<VAR_8-1; VAR_17++){",
"av_init_lls(&m[VAR_17&1], VAR_4);",
"weight=0;",
"for(VAR_15=VAR_4; VAR_15<VAR_2; VAR_15++){",
"for(VAR_16=0; VAR_16<=VAR_4; VAR_16++)",
"VAR_19[VAR_16]= VAR_1[VAR_15-VAR_16];",
"if(VAR_17){",
"double VAR_20, VAR_21, VAR_22;",
"VAR_20= av_evaluate_lls(&m[(VAR_17-1)&1], VAR_19+1, VAR_4-1);",
"VAR_20= (512>>VAR_17) + fabs(VAR_20 - VAR_19[0]);",
"VAR_21 = 1/VAR_20;",
"VAR_22 = sqrt(VAR_21);",
"for(VAR_16=0; VAR_16<=VAR_4; VAR_16++)",
"VAR_19[VAR_16] *= VAR_22;",
"weight += VAR_21;",
"}else",
"weight++;",
"av_update_lls(&m[VAR_17&1], VAR_19, 1.0);",
"}",
"av_solve_lls(&m[VAR_17&1], 0.001, 0);",
"}",
"for(VAR_15=0; VAR_15<VAR_4; VAR_15++){",
"for(VAR_16=0; VAR_16<VAR_4; VAR_16++)",
"VAR_14[VAR_15][VAR_16]=-m[(VAR_17-1)&1].coeff[VAR_15][VAR_16];",
"VAR_13[VAR_15]= sqrt(m[(VAR_17-1)&1].variance[VAR_15] / weight) * (VAR_2 - VAR_4) / 4000;",
"}",
"for(VAR_15=VAR_4-1; VAR_15>0; VAR_15--)",
"VAR_13[VAR_15] = VAR_13[VAR_15-1] - VAR_13[VAR_15];",
"}",
"VAR_18 = VAR_4;",
"if(VAR_9 == ORDER_METHOD_EST) {",
"VAR_18 = estimate_best_order(VAR_13, VAR_3, VAR_4);",
"VAR_15 = VAR_18-1;",
"quantize_lpc_coefs(VAR_14[VAR_15], VAR_15+1, VAR_5, VAR_6[VAR_15], &VAR_7[VAR_15], VAR_10, VAR_11);",
"} else {",
"for(VAR_15=VAR_3-1; VAR_15<VAR_4; VAR_15++) {",
"quantize_lpc_coefs(VAR_14[VAR_15], VAR_15+1, VAR_5, VAR_6[VAR_15], &VAR_7[VAR_15], VAR_10, VAR_11);",
"}",
"}",
"return VAR_18;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
141
],
[
143
]
] |
20,516 | void xtensa_cpu_list(FILE *f, fprintf_function cpu_fprintf)
{
cpu_fprintf(f, "Available CPUs:\n"
" Xtensa core\n");
}
| false | qemu | dedc5eae2324b3c4a6d25af2138396aa5dc3d9e0 | void xtensa_cpu_list(FILE *f, fprintf_function cpu_fprintf)
{
cpu_fprintf(f, "Available CPUs:\n"
" Xtensa core\n");
}
| {
"code": [],
"line_no": []
} | void FUNC_0(FILE *VAR_0, fprintf_function VAR_1)
{
VAR_1(VAR_0, "Available CPUs:\n"
" Xtensa core\n");
}
| [
"void FUNC_0(FILE *VAR_0, fprintf_function VAR_1)\n{",
"VAR_1(VAR_0, \"Available CPUs:\\n\"\n\" Xtensa core\\n\");",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
9
]
] |
20,517 | static inline void gen_jcc1_noeob(DisasContext *s, int b, int l1)
{
CCPrepare cc = gen_prepare_cc(s, b, cpu_T[0]);
if (cc.mask != -1) {
tcg_gen_andi_tl(cpu_T[0], cc.reg, cc.mask);
cc.reg = cpu_T[0];
}
if (cc.use_reg2) {
tcg_gen_brcond_tl(cc.cond, cc.reg, cc.reg2, l1);
} else {
tcg_gen_brcondi_tl(cc.cond, cc.reg, cc.imm, l1);
}
}
| false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 | static inline void gen_jcc1_noeob(DisasContext *s, int b, int l1)
{
CCPrepare cc = gen_prepare_cc(s, b, cpu_T[0]);
if (cc.mask != -1) {
tcg_gen_andi_tl(cpu_T[0], cc.reg, cc.mask);
cc.reg = cpu_T[0];
}
if (cc.use_reg2) {
tcg_gen_brcond_tl(cc.cond, cc.reg, cc.reg2, l1);
} else {
tcg_gen_brcondi_tl(cc.cond, cc.reg, cc.imm, l1);
}
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(DisasContext *VAR_0, int VAR_1, int VAR_2)
{
CCPrepare cc = gen_prepare_cc(VAR_0, VAR_1, cpu_T[0]);
if (cc.mask != -1) {
tcg_gen_andi_tl(cpu_T[0], cc.reg, cc.mask);
cc.reg = cpu_T[0];
}
if (cc.use_reg2) {
tcg_gen_brcond_tl(cc.cond, cc.reg, cc.reg2, VAR_2);
} else {
tcg_gen_brcondi_tl(cc.cond, cc.reg, cc.imm, VAR_2);
}
}
| [
"static inline void FUNC_0(DisasContext *VAR_0, int VAR_1, int VAR_2)\n{",
"CCPrepare cc = gen_prepare_cc(VAR_0, VAR_1, cpu_T[0]);",
"if (cc.mask != -1) {",
"tcg_gen_andi_tl(cpu_T[0], cc.reg, cc.mask);",
"cc.reg = cpu_T[0];",
"}",
"if (cc.use_reg2) {",
"tcg_gen_brcond_tl(cc.cond, cc.reg, cc.reg2, VAR_2);",
"} else {",
"tcg_gen_brcondi_tl(cc.cond, cc.reg, cc.imm, VAR_2);",
"}",
"}"
] | [
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
]
] |
20,519 | static void *rcu_q_reader(void *arg)
{
long long j, n_reads_local = 0;
struct list_element *el;
*(struct rcu_reader_data **)arg = &rcu_reader;
atomic_inc(&nthreadsrunning);
while (goflag == GOFLAG_INIT) {
g_usleep(1000);
}
while (goflag == GOFLAG_RUN) {
rcu_read_lock();
QLIST_FOREACH_RCU(el, &Q_list_head, entry) {
j = atomic_read(&el->val);
(void)j;
n_reads_local++;
if (goflag == GOFLAG_STOP) {
break;
}
}
rcu_read_unlock();
g_usleep(100);
}
atomic_add(&n_reads, n_reads_local);
return NULL;
}
| false | qemu | 8a5956ad6392f115521dad774055c737c49fb0dd | static void *rcu_q_reader(void *arg)
{
long long j, n_reads_local = 0;
struct list_element *el;
*(struct rcu_reader_data **)arg = &rcu_reader;
atomic_inc(&nthreadsrunning);
while (goflag == GOFLAG_INIT) {
g_usleep(1000);
}
while (goflag == GOFLAG_RUN) {
rcu_read_lock();
QLIST_FOREACH_RCU(el, &Q_list_head, entry) {
j = atomic_read(&el->val);
(void)j;
n_reads_local++;
if (goflag == GOFLAG_STOP) {
break;
}
}
rcu_read_unlock();
g_usleep(100);
}
atomic_add(&n_reads, n_reads_local);
return NULL;
}
| {
"code": [],
"line_no": []
} | static void *FUNC_0(void *VAR_0)
{
long long VAR_1, VAR_2 = 0;
struct list_element *VAR_3;
*(struct rcu_reader_data **)VAR_0 = &rcu_reader;
atomic_inc(&nthreadsrunning);
while (goflag == GOFLAG_INIT) {
g_usleep(1000);
}
while (goflag == GOFLAG_RUN) {
rcu_read_lock();
QLIST_FOREACH_RCU(VAR_3, &Q_list_head, entry) {
VAR_1 = atomic_read(&VAR_3->val);
(void)VAR_1;
VAR_2++;
if (goflag == GOFLAG_STOP) {
break;
}
}
rcu_read_unlock();
g_usleep(100);
}
atomic_add(&n_reads, VAR_2);
return NULL;
}
| [
"static void *FUNC_0(void *VAR_0)\n{",
"long long VAR_1, VAR_2 = 0;",
"struct list_element *VAR_3;",
"*(struct rcu_reader_data **)VAR_0 = &rcu_reader;",
"atomic_inc(&nthreadsrunning);",
"while (goflag == GOFLAG_INIT) {",
"g_usleep(1000);",
"}",
"while (goflag == GOFLAG_RUN) {",
"rcu_read_lock();",
"QLIST_FOREACH_RCU(VAR_3, &Q_list_head, entry) {",
"VAR_1 = atomic_read(&VAR_3->val);",
"(void)VAR_1;",
"VAR_2++;",
"if (goflag == GOFLAG_STOP) {",
"break;",
"}",
"}",
"rcu_read_unlock();",
"g_usleep(100);",
"}",
"atomic_add(&n_reads, VAR_2);",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
]
] |
20,521 | static ssize_t local_llistxattr(FsContext *ctx, const char *path,
void *value, size_t size)
{
ssize_t retval;
ssize_t actual_len = 0;
char *orig_value, *orig_value_start;
char *temp_value, *temp_value_start;
ssize_t xattr_len, parsed_len = 0, attr_len;
if (ctx->fs_sm != SM_MAPPED) {
return llistxattr(rpath(ctx, path), value, size);
}
/* Get the actual len */
xattr_len = llistxattr(rpath(ctx, path), value, 0);
/* Now fetch the xattr and find the actual size */
orig_value = qemu_malloc(xattr_len);
xattr_len = llistxattr(rpath(ctx, path), orig_value, xattr_len);
/*
* For mapped security model drop user.virtfs namespace
* from the list
*/
temp_value = qemu_mallocz(xattr_len);
temp_value_start = temp_value;
orig_value_start = orig_value;
while (xattr_len > parsed_len) {
attr_len = strlen(orig_value) + 1;
if (strncmp(orig_value, "user.virtfs.", 12) != 0) {
/* Copy this entry */
strcat(temp_value, orig_value);
temp_value += attr_len;
actual_len += attr_len;
}
parsed_len += attr_len;
orig_value += attr_len;
}
if (!size) {
retval = actual_len;
goto out;
} else if (size >= actual_len) {
/* now copy the parsed attribute list back */
memset(value, 0, size);
memcpy(value, temp_value_start, actual_len);
retval = actual_len;
goto out;
}
errno = ERANGE;
retval = -1;
out:
qemu_free(orig_value_start);
qemu_free(temp_value_start);
return retval;
}
| false | qemu | fc22118d9bb56ec71655b936a29513c140e6c289 | static ssize_t local_llistxattr(FsContext *ctx, const char *path,
void *value, size_t size)
{
ssize_t retval;
ssize_t actual_len = 0;
char *orig_value, *orig_value_start;
char *temp_value, *temp_value_start;
ssize_t xattr_len, parsed_len = 0, attr_len;
if (ctx->fs_sm != SM_MAPPED) {
return llistxattr(rpath(ctx, path), value, size);
}
xattr_len = llistxattr(rpath(ctx, path), value, 0);
orig_value = qemu_malloc(xattr_len);
xattr_len = llistxattr(rpath(ctx, path), orig_value, xattr_len);
temp_value = qemu_mallocz(xattr_len);
temp_value_start = temp_value;
orig_value_start = orig_value;
while (xattr_len > parsed_len) {
attr_len = strlen(orig_value) + 1;
if (strncmp(orig_value, "user.virtfs.", 12) != 0) {
strcat(temp_value, orig_value);
temp_value += attr_len;
actual_len += attr_len;
}
parsed_len += attr_len;
orig_value += attr_len;
}
if (!size) {
retval = actual_len;
goto out;
} else if (size >= actual_len) {
memset(value, 0, size);
memcpy(value, temp_value_start, actual_len);
retval = actual_len;
goto out;
}
errno = ERANGE;
retval = -1;
out:
qemu_free(orig_value_start);
qemu_free(temp_value_start);
return retval;
}
| {
"code": [],
"line_no": []
} | static ssize_t FUNC_0(FsContext *ctx, const char *path,
void *value, size_t size)
{
ssize_t retval;
ssize_t actual_len = 0;
char *VAR_0, *VAR_1;
char *VAR_2, *VAR_3;
ssize_t xattr_len, parsed_len = 0, attr_len;
if (ctx->fs_sm != SM_MAPPED) {
return llistxattr(rpath(ctx, path), value, size);
}
xattr_len = llistxattr(rpath(ctx, path), value, 0);
VAR_0 = qemu_malloc(xattr_len);
xattr_len = llistxattr(rpath(ctx, path), VAR_0, xattr_len);
VAR_2 = qemu_mallocz(xattr_len);
VAR_3 = VAR_2;
VAR_1 = VAR_0;
while (xattr_len > parsed_len) {
attr_len = strlen(VAR_0) + 1;
if (strncmp(VAR_0, "user.virtfs.", 12) != 0) {
strcat(VAR_2, VAR_0);
VAR_2 += attr_len;
actual_len += attr_len;
}
parsed_len += attr_len;
VAR_0 += attr_len;
}
if (!size) {
retval = actual_len;
goto out;
} else if (size >= actual_len) {
memset(value, 0, size);
memcpy(value, VAR_3, actual_len);
retval = actual_len;
goto out;
}
errno = ERANGE;
retval = -1;
out:
qemu_free(VAR_1);
qemu_free(VAR_3);
return retval;
}
| [
"static ssize_t FUNC_0(FsContext *ctx, const char *path,\nvoid *value, size_t size)\n{",
"ssize_t retval;",
"ssize_t actual_len = 0;",
"char *VAR_0, *VAR_1;",
"char *VAR_2, *VAR_3;",
"ssize_t xattr_len, parsed_len = 0, attr_len;",
"if (ctx->fs_sm != SM_MAPPED) {",
"return llistxattr(rpath(ctx, path), value, size);",
"}",
"xattr_len = llistxattr(rpath(ctx, path), value, 0);",
"VAR_0 = qemu_malloc(xattr_len);",
"xattr_len = llistxattr(rpath(ctx, path), VAR_0, xattr_len);",
"VAR_2 = qemu_mallocz(xattr_len);",
"VAR_3 = VAR_2;",
"VAR_1 = VAR_0;",
"while (xattr_len > parsed_len) {",
"attr_len = strlen(VAR_0) + 1;",
"if (strncmp(VAR_0, \"user.virtfs.\", 12) != 0) {",
"strcat(VAR_2, VAR_0);",
"VAR_2 += attr_len;",
"actual_len += attr_len;",
"}",
"parsed_len += attr_len;",
"VAR_0 += attr_len;",
"}",
"if (!size) {",
"retval = actual_len;",
"goto out;",
"} else if (size >= actual_len) {",
"memset(value, 0, size);",
"memcpy(value, VAR_3, actual_len);",
"retval = actual_len;",
"goto out;",
"}",
"errno = ERANGE;",
"retval = -1;",
"out:\nqemu_free(VAR_1);",
"qemu_free(VAR_3);",
"return retval;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
35
],
[
37
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101,
103
],
[
105
],
[
107
],
[
109
]
] |
20,522 | static void idct(uint8_t *dst, int dst_linesize, int src[64])
{
int i, j, k;
double tmp[64];
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
double sum = 0.0;
for (k = 0; k < 8; k++)
sum += c[k*8+j] * src[8*i+k];
tmp[8*i+j] = sum;
}
}
for (j = 0; j < 8; j++) {
for (i = 0; i < 8; i++) {
double sum = 0.0;
for (k = 0; k < 8; k++)
sum += c[k*8+i]*tmp[8*k+j];
dst[dst_linesize*i + j] = av_clip_uint8((int)floor(sum+0.5));
}
}
}
| false | FFmpeg | fa5d299496c15e992240914ae05b92d9b74eb3c4 | static void idct(uint8_t *dst, int dst_linesize, int src[64])
{
int i, j, k;
double tmp[64];
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
double sum = 0.0;
for (k = 0; k < 8; k++)
sum += c[k*8+j] * src[8*i+k];
tmp[8*i+j] = sum;
}
}
for (j = 0; j < 8; j++) {
for (i = 0; i < 8; i++) {
double sum = 0.0;
for (k = 0; k < 8; k++)
sum += c[k*8+i]*tmp[8*k+j];
dst[dst_linesize*i + j] = av_clip_uint8((int)floor(sum+0.5));
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(uint8_t *VAR_0, int VAR_1, int VAR_2[64])
{
int VAR_3, VAR_4, VAR_5;
double VAR_6[64];
for (VAR_3 = 0; VAR_3 < 8; VAR_3++) {
for (VAR_4 = 0; VAR_4 < 8; VAR_4++) {
double VAR_8 = 0.0;
for (VAR_5 = 0; VAR_5 < 8; VAR_5++)
VAR_8 += c[VAR_5*8+VAR_4] * VAR_2[8*VAR_3+VAR_5];
VAR_6[8*VAR_3+VAR_4] = VAR_8;
}
}
for (VAR_4 = 0; VAR_4 < 8; VAR_4++) {
for (VAR_3 = 0; VAR_3 < 8; VAR_3++) {
double VAR_8 = 0.0;
for (VAR_5 = 0; VAR_5 < 8; VAR_5++)
VAR_8 += c[VAR_5*8+VAR_3]*VAR_6[8*VAR_5+VAR_4];
VAR_0[VAR_1*VAR_3 + VAR_4] = av_clip_uint8((int)floor(VAR_8+0.5));
}
}
}
| [
"static void FUNC_0(uint8_t *VAR_0, int VAR_1, int VAR_2[64])\n{",
"int VAR_3, VAR_4, VAR_5;",
"double VAR_6[64];",
"for (VAR_3 = 0; VAR_3 < 8; VAR_3++) {",
"for (VAR_4 = 0; VAR_4 < 8; VAR_4++) {",
"double VAR_8 = 0.0;",
"for (VAR_5 = 0; VAR_5 < 8; VAR_5++)",
"VAR_8 += c[VAR_5*8+VAR_4] * VAR_2[8*VAR_3+VAR_5];",
"VAR_6[8*VAR_3+VAR_4] = VAR_8;",
"}",
"}",
"for (VAR_4 = 0; VAR_4 < 8; VAR_4++) {",
"for (VAR_3 = 0; VAR_3 < 8; VAR_3++) {",
"double VAR_8 = 0.0;",
"for (VAR_5 = 0; VAR_5 < 8; VAR_5++)",
"VAR_8 += c[VAR_5*8+VAR_3]*VAR_6[8*VAR_5+VAR_4];",
"VAR_0[VAR_1*VAR_3 + VAR_4] = av_clip_uint8((int)floor(VAR_8+0.5));",
"}",
"}",
"}"
] | [
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
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
]
] |
20,523 | static int usb_hid_handle_control(USBDevice *dev, int request, int value,
int index, int length, uint8_t *data)
{
USBHIDState *s = (USBHIDState *)dev;
int ret;
ret = usb_desc_handle_control(dev, request, value, index, length, data);
if (ret >= 0) {
return ret;
}
ret = 0;
switch(request) {
case DeviceRequest | USB_REQ_GET_STATUS:
data[0] = (1 << USB_DEVICE_SELF_POWERED) |
(dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
data[1] = 0x00;
ret = 2;
break;
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
dev->remote_wakeup = 0;
} else {
goto fail;
}
ret = 0;
break;
case DeviceOutRequest | USB_REQ_SET_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
dev->remote_wakeup = 1;
} else {
goto fail;
}
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
data[0] = 1;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_INTERFACE:
data[0] = 0;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_INTERFACE:
ret = 0;
break;
/* hid specific requests */
case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
switch(value >> 8) {
case 0x22:
if (s->kind == USB_MOUSE) {
memcpy(data, qemu_mouse_hid_report_descriptor,
sizeof(qemu_mouse_hid_report_descriptor));
ret = sizeof(qemu_mouse_hid_report_descriptor);
} else if (s->kind == USB_TABLET) {
memcpy(data, qemu_tablet_hid_report_descriptor,
sizeof(qemu_tablet_hid_report_descriptor));
ret = sizeof(qemu_tablet_hid_report_descriptor);
} else if (s->kind == USB_KEYBOARD) {
memcpy(data, qemu_keyboard_hid_report_descriptor,
sizeof(qemu_keyboard_hid_report_descriptor));
ret = sizeof(qemu_keyboard_hid_report_descriptor);
}
break;
default:
goto fail;
}
break;
case GET_REPORT:
if (s->kind == USB_MOUSE)
ret = usb_mouse_poll(s, data, length);
else if (s->kind == USB_TABLET)
ret = usb_tablet_poll(s, data, length);
else if (s->kind == USB_KEYBOARD)
ret = usb_keyboard_poll(&s->kbd, data, length);
break;
case SET_REPORT:
if (s->kind == USB_KEYBOARD)
ret = usb_keyboard_write(&s->kbd, data, length);
else
goto fail;
break;
case GET_PROTOCOL:
if (s->kind != USB_KEYBOARD)
goto fail;
ret = 1;
data[0] = s->protocol;
break;
case SET_PROTOCOL:
if (s->kind != USB_KEYBOARD)
goto fail;
ret = 0;
s->protocol = value;
break;
case GET_IDLE:
ret = 1;
data[0] = s->idle;
break;
case SET_IDLE:
s->idle = (uint8_t) (value >> 8);
usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
ret = 0;
break;
default:
fail:
ret = USB_RET_STALL;
break;
}
return ret;
}
| false | qemu | a980a065fb5e86d6dec337e6cb6ff432f1a143c9 | static int usb_hid_handle_control(USBDevice *dev, int request, int value,
int index, int length, uint8_t *data)
{
USBHIDState *s = (USBHIDState *)dev;
int ret;
ret = usb_desc_handle_control(dev, request, value, index, length, data);
if (ret >= 0) {
return ret;
}
ret = 0;
switch(request) {
case DeviceRequest | USB_REQ_GET_STATUS:
data[0] = (1 << USB_DEVICE_SELF_POWERED) |
(dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
data[1] = 0x00;
ret = 2;
break;
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
dev->remote_wakeup = 0;
} else {
goto fail;
}
ret = 0;
break;
case DeviceOutRequest | USB_REQ_SET_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
dev->remote_wakeup = 1;
} else {
goto fail;
}
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
data[0] = 1;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_INTERFACE:
data[0] = 0;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_INTERFACE:
ret = 0;
break;
case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
switch(value >> 8) {
case 0x22:
if (s->kind == USB_MOUSE) {
memcpy(data, qemu_mouse_hid_report_descriptor,
sizeof(qemu_mouse_hid_report_descriptor));
ret = sizeof(qemu_mouse_hid_report_descriptor);
} else if (s->kind == USB_TABLET) {
memcpy(data, qemu_tablet_hid_report_descriptor,
sizeof(qemu_tablet_hid_report_descriptor));
ret = sizeof(qemu_tablet_hid_report_descriptor);
} else if (s->kind == USB_KEYBOARD) {
memcpy(data, qemu_keyboard_hid_report_descriptor,
sizeof(qemu_keyboard_hid_report_descriptor));
ret = sizeof(qemu_keyboard_hid_report_descriptor);
}
break;
default:
goto fail;
}
break;
case GET_REPORT:
if (s->kind == USB_MOUSE)
ret = usb_mouse_poll(s, data, length);
else if (s->kind == USB_TABLET)
ret = usb_tablet_poll(s, data, length);
else if (s->kind == USB_KEYBOARD)
ret = usb_keyboard_poll(&s->kbd, data, length);
break;
case SET_REPORT:
if (s->kind == USB_KEYBOARD)
ret = usb_keyboard_write(&s->kbd, data, length);
else
goto fail;
break;
case GET_PROTOCOL:
if (s->kind != USB_KEYBOARD)
goto fail;
ret = 1;
data[0] = s->protocol;
break;
case SET_PROTOCOL:
if (s->kind != USB_KEYBOARD)
goto fail;
ret = 0;
s->protocol = value;
break;
case GET_IDLE:
ret = 1;
data[0] = s->idle;
break;
case SET_IDLE:
s->idle = (uint8_t) (value >> 8);
usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
ret = 0;
break;
default:
fail:
ret = USB_RET_STALL;
break;
}
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(USBDevice *VAR_0, int VAR_1, int VAR_2,
int VAR_3, int VAR_4, uint8_t *VAR_5)
{
USBHIDState *s = (USBHIDState *)VAR_0;
int VAR_6;
VAR_6 = usb_desc_handle_control(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5);
if (VAR_6 >= 0) {
return VAR_6;
}
VAR_6 = 0;
switch(VAR_1) {
case DeviceRequest | USB_REQ_GET_STATUS:
VAR_5[0] = (1 << USB_DEVICE_SELF_POWERED) |
(VAR_0->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
VAR_5[1] = 0x00;
VAR_6 = 2;
break;
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
if (VAR_2 == USB_DEVICE_REMOTE_WAKEUP) {
VAR_0->remote_wakeup = 0;
} else {
goto fail;
}
VAR_6 = 0;
break;
case DeviceOutRequest | USB_REQ_SET_FEATURE:
if (VAR_2 == USB_DEVICE_REMOTE_WAKEUP) {
VAR_0->remote_wakeup = 1;
} else {
goto fail;
}
VAR_6 = 0;
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
VAR_5[0] = 1;
VAR_6 = 1;
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
VAR_6 = 0;
break;
case DeviceRequest | USB_REQ_GET_INTERFACE:
VAR_5[0] = 0;
VAR_6 = 1;
break;
case DeviceOutRequest | USB_REQ_SET_INTERFACE:
VAR_6 = 0;
break;
case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
switch(VAR_2 >> 8) {
case 0x22:
if (s->kind == USB_MOUSE) {
memcpy(VAR_5, qemu_mouse_hid_report_descriptor,
sizeof(qemu_mouse_hid_report_descriptor));
VAR_6 = sizeof(qemu_mouse_hid_report_descriptor);
} else if (s->kind == USB_TABLET) {
memcpy(VAR_5, qemu_tablet_hid_report_descriptor,
sizeof(qemu_tablet_hid_report_descriptor));
VAR_6 = sizeof(qemu_tablet_hid_report_descriptor);
} else if (s->kind == USB_KEYBOARD) {
memcpy(VAR_5, qemu_keyboard_hid_report_descriptor,
sizeof(qemu_keyboard_hid_report_descriptor));
VAR_6 = sizeof(qemu_keyboard_hid_report_descriptor);
}
break;
default:
goto fail;
}
break;
case GET_REPORT:
if (s->kind == USB_MOUSE)
VAR_6 = usb_mouse_poll(s, VAR_5, VAR_4);
else if (s->kind == USB_TABLET)
VAR_6 = usb_tablet_poll(s, VAR_5, VAR_4);
else if (s->kind == USB_KEYBOARD)
VAR_6 = usb_keyboard_poll(&s->kbd, VAR_5, VAR_4);
break;
case SET_REPORT:
if (s->kind == USB_KEYBOARD)
VAR_6 = usb_keyboard_write(&s->kbd, VAR_5, VAR_4);
else
goto fail;
break;
case GET_PROTOCOL:
if (s->kind != USB_KEYBOARD)
goto fail;
VAR_6 = 1;
VAR_5[0] = s->protocol;
break;
case SET_PROTOCOL:
if (s->kind != USB_KEYBOARD)
goto fail;
VAR_6 = 0;
s->protocol = VAR_2;
break;
case GET_IDLE:
VAR_6 = 1;
VAR_5[0] = s->idle;
break;
case SET_IDLE:
s->idle = (uint8_t) (VAR_2 >> 8);
usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
VAR_6 = 0;
break;
default:
fail:
VAR_6 = USB_RET_STALL;
break;
}
return VAR_6;
}
| [
"static int FUNC_0(USBDevice *VAR_0, int VAR_1, int VAR_2,\nint VAR_3, int VAR_4, uint8_t *VAR_5)\n{",
"USBHIDState *s = (USBHIDState *)VAR_0;",
"int VAR_6;",
"VAR_6 = usb_desc_handle_control(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5);",
"if (VAR_6 >= 0) {",
"return VAR_6;",
"}",
"VAR_6 = 0;",
"switch(VAR_1) {",
"case DeviceRequest | USB_REQ_GET_STATUS:\nVAR_5[0] = (1 << USB_DEVICE_SELF_POWERED) |\n(VAR_0->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);",
"VAR_5[1] = 0x00;",
"VAR_6 = 2;",
"break;",
"case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:\nif (VAR_2 == USB_DEVICE_REMOTE_WAKEUP) {",
"VAR_0->remote_wakeup = 0;",
"} else {",
"goto fail;",
"}",
"VAR_6 = 0;",
"break;",
"case DeviceOutRequest | USB_REQ_SET_FEATURE:\nif (VAR_2 == USB_DEVICE_REMOTE_WAKEUP) {",
"VAR_0->remote_wakeup = 1;",
"} else {",
"goto fail;",
"}",
"VAR_6 = 0;",
"break;",
"case DeviceRequest | USB_REQ_GET_CONFIGURATION:\nVAR_5[0] = 1;",
"VAR_6 = 1;",
"break;",
"case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:\nVAR_6 = 0;",
"break;",
"case DeviceRequest | USB_REQ_GET_INTERFACE:\nVAR_5[0] = 0;",
"VAR_6 = 1;",
"break;",
"case DeviceOutRequest | USB_REQ_SET_INTERFACE:\nVAR_6 = 0;",
"break;",
"case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:\nswitch(VAR_2 >> 8) {",
"case 0x22:\nif (s->kind == USB_MOUSE) {",
"memcpy(VAR_5, qemu_mouse_hid_report_descriptor,\nsizeof(qemu_mouse_hid_report_descriptor));",
"VAR_6 = sizeof(qemu_mouse_hid_report_descriptor);",
"} else if (s->kind == USB_TABLET) {",
"memcpy(VAR_5, qemu_tablet_hid_report_descriptor,\nsizeof(qemu_tablet_hid_report_descriptor));",
"VAR_6 = sizeof(qemu_tablet_hid_report_descriptor);",
"} else if (s->kind == USB_KEYBOARD) {",
"memcpy(VAR_5, qemu_keyboard_hid_report_descriptor,\nsizeof(qemu_keyboard_hid_report_descriptor));",
"VAR_6 = sizeof(qemu_keyboard_hid_report_descriptor);",
"}",
"break;",
"default:\ngoto fail;",
"}",
"break;",
"case GET_REPORT:\nif (s->kind == USB_MOUSE)\nVAR_6 = usb_mouse_poll(s, VAR_5, VAR_4);",
"else if (s->kind == USB_TABLET)\nVAR_6 = usb_tablet_poll(s, VAR_5, VAR_4);",
"else if (s->kind == USB_KEYBOARD)\nVAR_6 = usb_keyboard_poll(&s->kbd, VAR_5, VAR_4);",
"break;",
"case SET_REPORT:\nif (s->kind == USB_KEYBOARD)\nVAR_6 = usb_keyboard_write(&s->kbd, VAR_5, VAR_4);",
"else\ngoto fail;",
"break;",
"case GET_PROTOCOL:\nif (s->kind != USB_KEYBOARD)\ngoto fail;",
"VAR_6 = 1;",
"VAR_5[0] = s->protocol;",
"break;",
"case SET_PROTOCOL:\nif (s->kind != USB_KEYBOARD)\ngoto fail;",
"VAR_6 = 0;",
"s->protocol = VAR_2;",
"break;",
"case GET_IDLE:\nVAR_6 = 1;",
"VAR_5[0] = s->idle;",
"break;",
"case SET_IDLE:\ns->idle = (uint8_t) (VAR_2 >> 8);",
"usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));",
"VAR_6 = 0;",
"break;",
"default:\nfail:\nVAR_6 = USB_RET_STALL;",
"break;",
"}",
"return VAR_6;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
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
],
[
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
],
[
223
],
[
225
]
] |
20,524 | static int protocol_client_auth(VncState *vs, char *data, size_t len)
{
/* We only advertise 1 auth scheme at a time, so client
* must pick the one we sent. Verify this */
if (data[0] != vs->auth) { /* Reject auth */
VNC_DEBUG("Reject auth %d\n", (int)data[0]);
vnc_write_u32(vs, 1);
if (vs->minor >= 8) {
static const char err[] = "Authentication failed";
vnc_write_u32(vs, sizeof(err));
vnc_write(vs, err, sizeof(err));
}
vnc_client_error(vs);
} else { /* Accept requested auth */
VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
switch (vs->auth) {
case VNC_AUTH_NONE:
VNC_DEBUG("Accept auth none\n");
vnc_write_u32(vs, 0); /* Accept auth completion */
vnc_read_when(vs, protocol_client_init, 1);
break;
case VNC_AUTH_VNC:
VNC_DEBUG("Start VNC auth\n");
return start_auth_vnc(vs);
#if CONFIG_VNC_TLS
case VNC_AUTH_VENCRYPT:
VNC_DEBUG("Accept VeNCrypt auth\n");;
return start_auth_vencrypt(vs);
#endif /* CONFIG_VNC_TLS */
default: /* Should not be possible, but just in case */
VNC_DEBUG("Reject auth %d\n", vs->auth);
vnc_write_u8(vs, 1);
if (vs->minor >= 8) {
static const char err[] = "Authentication failed";
vnc_write_u32(vs, sizeof(err));
vnc_write(vs, err, sizeof(err));
}
vnc_client_error(vs);
}
}
return 0;
}
| false | qemu | a26c97adce76e23ab4ad2ad152d77291ad495484 | static int protocol_client_auth(VncState *vs, char *data, size_t len)
{
if (data[0] != vs->auth) {
VNC_DEBUG("Reject auth %d\n", (int)data[0]);
vnc_write_u32(vs, 1);
if (vs->minor >= 8) {
static const char err[] = "Authentication failed";
vnc_write_u32(vs, sizeof(err));
vnc_write(vs, err, sizeof(err));
}
vnc_client_error(vs);
} else {
VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
switch (vs->auth) {
case VNC_AUTH_NONE:
VNC_DEBUG("Accept auth none\n");
vnc_write_u32(vs, 0);
vnc_read_when(vs, protocol_client_init, 1);
break;
case VNC_AUTH_VNC:
VNC_DEBUG("Start VNC auth\n");
return start_auth_vnc(vs);
#if CONFIG_VNC_TLS
case VNC_AUTH_VENCRYPT:
VNC_DEBUG("Accept VeNCrypt auth\n");;
return start_auth_vencrypt(vs);
#endif
default:
VNC_DEBUG("Reject auth %d\n", vs->auth);
vnc_write_u8(vs, 1);
if (vs->minor >= 8) {
static const char err[] = "Authentication failed";
vnc_write_u32(vs, sizeof(err));
vnc_write(vs, err, sizeof(err));
}
vnc_client_error(vs);
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(VncState *VAR_0, char *VAR_1, size_t VAR_2)
{
if (VAR_1[0] != VAR_0->auth) {
VNC_DEBUG("Reject auth %d\n", (int)VAR_1[0]);
vnc_write_u32(VAR_0, 1);
if (VAR_0->minor >= 8) {
static const char VAR_4[] = "Authentication failed";
vnc_write_u32(VAR_0, sizeof(VAR_4));
vnc_write(VAR_0, VAR_4, sizeof(VAR_4));
}
vnc_client_error(VAR_0);
} else {
VNC_DEBUG("Client requested auth %d\n", (int)VAR_1[0]);
switch (VAR_0->auth) {
case VNC_AUTH_NONE:
VNC_DEBUG("Accept auth none\n");
vnc_write_u32(VAR_0, 0);
vnc_read_when(VAR_0, protocol_client_init, 1);
break;
case VNC_AUTH_VNC:
VNC_DEBUG("Start VNC auth\n");
return start_auth_vnc(VAR_0);
#if CONFIG_VNC_TLS
case VNC_AUTH_VENCRYPT:
VNC_DEBUG("Accept VeNCrypt auth\n");;
return start_auth_vencrypt(VAR_0);
#endif
default:
VNC_DEBUG("Reject auth %d\n", VAR_0->auth);
vnc_write_u8(VAR_0, 1);
if (VAR_0->minor >= 8) {
static const char VAR_4[] = "Authentication failed";
vnc_write_u32(VAR_0, sizeof(VAR_4));
vnc_write(VAR_0, VAR_4, sizeof(VAR_4));
}
vnc_client_error(VAR_0);
}
}
return 0;
}
| [
"static int FUNC_0(VncState *VAR_0, char *VAR_1, size_t VAR_2)\n{",
"if (VAR_1[0] != VAR_0->auth) {",
"VNC_DEBUG(\"Reject auth %d\\n\", (int)VAR_1[0]);",
"vnc_write_u32(VAR_0, 1);",
"if (VAR_0->minor >= 8) {",
"static const char VAR_4[] = \"Authentication failed\";",
"vnc_write_u32(VAR_0, sizeof(VAR_4));",
"vnc_write(VAR_0, VAR_4, sizeof(VAR_4));",
"}",
"vnc_client_error(VAR_0);",
"} else {",
"VNC_DEBUG(\"Client requested auth %d\\n\", (int)VAR_1[0]);",
"switch (VAR_0->auth) {",
"case VNC_AUTH_NONE:\nVNC_DEBUG(\"Accept auth none\\n\");",
"vnc_write_u32(VAR_0, 0);",
"vnc_read_when(VAR_0, protocol_client_init, 1);",
"break;",
"case VNC_AUTH_VNC:\nVNC_DEBUG(\"Start VNC auth\\n\");",
"return start_auth_vnc(VAR_0);",
"#if CONFIG_VNC_TLS\ncase VNC_AUTH_VENCRYPT:\nVNC_DEBUG(\"Accept VeNCrypt auth\\n\");;",
"return start_auth_vencrypt(VAR_0);",
"#endif\ndefault:\nVNC_DEBUG(\"Reject auth %d\\n\", VAR_0->auth);",
"vnc_write_u8(VAR_0, 1);",
"if (VAR_0->minor >= 8) {",
"static const char VAR_4[] = \"Authentication failed\";",
"vnc_write_u32(VAR_0, sizeof(VAR_4));",
"vnc_write(VAR_0, VAR_4, sizeof(VAR_4));",
"}",
"vnc_client_error(VAR_0);",
"}",
"}",
"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
] | [
[
1,
3
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
45,
47
],
[
49
],
[
53,
55,
57
],
[
59
],
[
61,
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
]
] |
20,525 | static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
int phdr_index, target_phys_addr_t offset)
{
Elf32_Phdr phdr;
int ret;
int endian = s->dump_info.d_endian;
memset(&phdr, 0, sizeof(Elf32_Phdr));
phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian);
phdr.p_offset = cpu_convert_to_target32(offset, endian);
phdr.p_paddr = cpu_convert_to_target32(memory_mapping->phys_addr, endian);
if (offset == -1) {
/* When the memory is not stored into vmcore, offset will be -1 */
phdr.p_filesz = 0;
} else {
phdr.p_filesz = cpu_convert_to_target32(memory_mapping->length, endian);
}
phdr.p_memsz = cpu_convert_to_target32(memory_mapping->length, endian);
phdr.p_vaddr = cpu_convert_to_target32(memory_mapping->virt_addr, endian);
ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
if (ret < 0) {
dump_error(s, "dump: failed to write program header table.\n");
return -1;
}
return 0;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static int write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
int phdr_index, target_phys_addr_t offset)
{
Elf32_Phdr phdr;
int ret;
int endian = s->dump_info.d_endian;
memset(&phdr, 0, sizeof(Elf32_Phdr));
phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian);
phdr.p_offset = cpu_convert_to_target32(offset, endian);
phdr.p_paddr = cpu_convert_to_target32(memory_mapping->phys_addr, endian);
if (offset == -1) {
phdr.p_filesz = 0;
} else {
phdr.p_filesz = cpu_convert_to_target32(memory_mapping->length, endian);
}
phdr.p_memsz = cpu_convert_to_target32(memory_mapping->length, endian);
phdr.p_vaddr = cpu_convert_to_target32(memory_mapping->virt_addr, endian);
ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
if (ret < 0) {
dump_error(s, "dump: failed to write program header table.\n");
return -1;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(DumpState *VAR_0, MemoryMapping *VAR_1,
int VAR_2, target_phys_addr_t VAR_3)
{
Elf32_Phdr phdr;
int VAR_4;
int VAR_5 = VAR_0->dump_info.d_endian;
memset(&phdr, 0, sizeof(Elf32_Phdr));
phdr.p_type = cpu_convert_to_target32(PT_LOAD, VAR_5);
phdr.p_offset = cpu_convert_to_target32(VAR_3, VAR_5);
phdr.p_paddr = cpu_convert_to_target32(VAR_1->phys_addr, VAR_5);
if (VAR_3 == -1) {
phdr.p_filesz = 0;
} else {
phdr.p_filesz = cpu_convert_to_target32(VAR_1->length, VAR_5);
}
phdr.p_memsz = cpu_convert_to_target32(VAR_1->length, VAR_5);
phdr.p_vaddr = cpu_convert_to_target32(VAR_1->virt_addr, VAR_5);
VAR_4 = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), VAR_0);
if (VAR_4 < 0) {
dump_error(VAR_0, "dump: failed to write program header table.\n");
return -1;
}
return 0;
}
| [
"static int FUNC_0(DumpState *VAR_0, MemoryMapping *VAR_1,\nint VAR_2, target_phys_addr_t VAR_3)\n{",
"Elf32_Phdr phdr;",
"int VAR_4;",
"int VAR_5 = VAR_0->dump_info.d_endian;",
"memset(&phdr, 0, sizeof(Elf32_Phdr));",
"phdr.p_type = cpu_convert_to_target32(PT_LOAD, VAR_5);",
"phdr.p_offset = cpu_convert_to_target32(VAR_3, VAR_5);",
"phdr.p_paddr = cpu_convert_to_target32(VAR_1->phys_addr, VAR_5);",
"if (VAR_3 == -1) {",
"phdr.p_filesz = 0;",
"} else {",
"phdr.p_filesz = cpu_convert_to_target32(VAR_1->length, VAR_5);",
"}",
"phdr.p_memsz = cpu_convert_to_target32(VAR_1->length, VAR_5);",
"phdr.p_vaddr = cpu_convert_to_target32(VAR_1->virt_addr, VAR_5);",
"VAR_4 = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), VAR_0);",
"if (VAR_4 < 0) {",
"dump_error(VAR_0, \"dump: failed to write program header table.\\n\");",
"return -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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
]
] |
20,526 | static void rtas_nvram_fetch(PowerPCCPU *cpu, sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
sPAPRNVRAM *nvram = spapr->nvram;
hwaddr offset, buffer, len;
int alen;
void *membuf;
if ((nargs != 3) || (nret != 2)) {
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
return;
}
if (!nvram) {
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
rtas_st(rets, 1, 0);
return;
}
offset = rtas_ld(args, 0);
buffer = rtas_ld(args, 1);
len = rtas_ld(args, 2);
if (((offset + len) < offset)
|| ((offset + len) > nvram->size)) {
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
rtas_st(rets, 1, 0);
return;
}
membuf = cpu_physical_memory_map(buffer, &len, 1);
if (nvram->drive) {
alen = bdrv_pread(nvram->drive, offset, membuf, len);
} else {
assert(nvram->buf);
memcpy(membuf, nvram->buf + offset, len);
alen = len;
}
cpu_physical_memory_unmap(membuf, len, 1, len);
rtas_st(rets, 0, (alen < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
rtas_st(rets, 1, (alen < 0) ? 0 : alen);
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | static void rtas_nvram_fetch(PowerPCCPU *cpu, sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
sPAPRNVRAM *nvram = spapr->nvram;
hwaddr offset, buffer, len;
int alen;
void *membuf;
if ((nargs != 3) || (nret != 2)) {
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
return;
}
if (!nvram) {
rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
rtas_st(rets, 1, 0);
return;
}
offset = rtas_ld(args, 0);
buffer = rtas_ld(args, 1);
len = rtas_ld(args, 2);
if (((offset + len) < offset)
|| ((offset + len) > nvram->size)) {
rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
rtas_st(rets, 1, 0);
return;
}
membuf = cpu_physical_memory_map(buffer, &len, 1);
if (nvram->drive) {
alen = bdrv_pread(nvram->drive, offset, membuf, len);
} else {
assert(nvram->buf);
memcpy(membuf, nvram->buf + offset, len);
alen = len;
}
cpu_physical_memory_unmap(membuf, len, 1, len);
rtas_st(rets, 0, (alen < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
rtas_st(rets, 1, (alen < 0) ? 0 : alen);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PowerPCCPU *VAR_0, sPAPREnvironment *VAR_1,
uint32_t VAR_2, uint32_t VAR_3,
target_ulong VAR_4,
uint32_t VAR_5, target_ulong VAR_6)
{
sPAPRNVRAM *nvram = VAR_1->nvram;
hwaddr offset, buffer, len;
int VAR_7;
void *VAR_8;
if ((VAR_3 != 3) || (VAR_5 != 2)) {
rtas_st(VAR_6, 0, RTAS_OUT_PARAM_ERROR);
return;
}
if (!nvram) {
rtas_st(VAR_6, 0, RTAS_OUT_HW_ERROR);
rtas_st(VAR_6, 1, 0);
return;
}
offset = rtas_ld(VAR_4, 0);
buffer = rtas_ld(VAR_4, 1);
len = rtas_ld(VAR_4, 2);
if (((offset + len) < offset)
|| ((offset + len) > nvram->size)) {
rtas_st(VAR_6, 0, RTAS_OUT_PARAM_ERROR);
rtas_st(VAR_6, 1, 0);
return;
}
VAR_8 = cpu_physical_memory_map(buffer, &len, 1);
if (nvram->drive) {
VAR_7 = bdrv_pread(nvram->drive, offset, VAR_8, len);
} else {
assert(nvram->buf);
memcpy(VAR_8, nvram->buf + offset, len);
VAR_7 = len;
}
cpu_physical_memory_unmap(VAR_8, len, 1, len);
rtas_st(VAR_6, 0, (VAR_7 < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
rtas_st(VAR_6, 1, (VAR_7 < 0) ? 0 : VAR_7);
}
| [
"static void FUNC_0(PowerPCCPU *VAR_0, sPAPREnvironment *VAR_1,\nuint32_t VAR_2, uint32_t VAR_3,\ntarget_ulong VAR_4,\nuint32_t VAR_5, target_ulong VAR_6)\n{",
"sPAPRNVRAM *nvram = VAR_1->nvram;",
"hwaddr offset, buffer, len;",
"int VAR_7;",
"void *VAR_8;",
"if ((VAR_3 != 3) || (VAR_5 != 2)) {",
"rtas_st(VAR_6, 0, RTAS_OUT_PARAM_ERROR);",
"return;",
"}",
"if (!nvram) {",
"rtas_st(VAR_6, 0, RTAS_OUT_HW_ERROR);",
"rtas_st(VAR_6, 1, 0);",
"return;",
"}",
"offset = rtas_ld(VAR_4, 0);",
"buffer = rtas_ld(VAR_4, 1);",
"len = rtas_ld(VAR_4, 2);",
"if (((offset + len) < offset)\n|| ((offset + len) > nvram->size)) {",
"rtas_st(VAR_6, 0, RTAS_OUT_PARAM_ERROR);",
"rtas_st(VAR_6, 1, 0);",
"return;",
"}",
"VAR_8 = cpu_physical_memory_map(buffer, &len, 1);",
"if (nvram->drive) {",
"VAR_7 = bdrv_pread(nvram->drive, offset, VAR_8, len);",
"} else {",
"assert(nvram->buf);",
"memcpy(VAR_8, nvram->buf + offset, len);",
"VAR_7 = len;",
"}",
"cpu_physical_memory_unmap(VAR_8, len, 1, len);",
"rtas_st(VAR_6, 0, (VAR_7 < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);",
"rtas_st(VAR_6, 1, (VAR_7 < 0) ? 0 : VAR_7);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
51,
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
]
] |
20,527 | void address_space_init(AddressSpace *as, MemoryRegion *root)
{
memory_region_transaction_begin();
as->root = root;
as->current_map = g_new(FlatView, 1);
flatview_init(as->current_map);
as->ioeventfd_nb = 0;
as->ioeventfds = NULL;
QTAILQ_INSERT_TAIL(&address_spaces, as, address_spaces_link);
as->name = NULL;
memory_region_transaction_commit();
address_space_init_dispatch(as);
}
| false | qemu | f43793c7caab49c68b41c3b8524fc35b4c206856 | void address_space_init(AddressSpace *as, MemoryRegion *root)
{
memory_region_transaction_begin();
as->root = root;
as->current_map = g_new(FlatView, 1);
flatview_init(as->current_map);
as->ioeventfd_nb = 0;
as->ioeventfds = NULL;
QTAILQ_INSERT_TAIL(&address_spaces, as, address_spaces_link);
as->name = NULL;
memory_region_transaction_commit();
address_space_init_dispatch(as);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(AddressSpace *VAR_0, MemoryRegion *VAR_1)
{
memory_region_transaction_begin();
VAR_0->VAR_1 = VAR_1;
VAR_0->current_map = g_new(FlatView, 1);
flatview_init(VAR_0->current_map);
VAR_0->ioeventfd_nb = 0;
VAR_0->ioeventfds = NULL;
QTAILQ_INSERT_TAIL(&address_spaces, VAR_0, address_spaces_link);
VAR_0->name = NULL;
memory_region_transaction_commit();
address_space_init_dispatch(VAR_0);
}
| [
"void FUNC_0(AddressSpace *VAR_0, MemoryRegion *VAR_1)\n{",
"memory_region_transaction_begin();",
"VAR_0->VAR_1 = VAR_1;",
"VAR_0->current_map = g_new(FlatView, 1);",
"flatview_init(VAR_0->current_map);",
"VAR_0->ioeventfd_nb = 0;",
"VAR_0->ioeventfds = NULL;",
"QTAILQ_INSERT_TAIL(&address_spaces, VAR_0, address_spaces_link);",
"VAR_0->name = NULL;",
"memory_region_transaction_commit();",
"address_space_init_dispatch(VAR_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
]
] |
20,528 | static int virtio_net_init_pci(PCIDevice *pci_dev)
{
VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
VirtIODevice *vdev;
vdev = virtio_net_init(&pci_dev->qdev, &proxy->nic, &proxy->net);
vdev->nvectors = proxy->nvectors;
virtio_init_pci(proxy, vdev,
PCI_VENDOR_ID_REDHAT_QUMRANET,
PCI_DEVICE_ID_VIRTIO_NET,
PCI_CLASS_NETWORK_ETHERNET,
0x00);
/* make the actual value visible */
proxy->nvectors = vdev->nvectors;
return 0;
}
| false | qemu | e75ccf2c033fb0503d6cb7ddd0fd1dfa0aa4fc16 | static int virtio_net_init_pci(PCIDevice *pci_dev)
{
VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
VirtIODevice *vdev;
vdev = virtio_net_init(&pci_dev->qdev, &proxy->nic, &proxy->net);
vdev->nvectors = proxy->nvectors;
virtio_init_pci(proxy, vdev,
PCI_VENDOR_ID_REDHAT_QUMRANET,
PCI_DEVICE_ID_VIRTIO_NET,
PCI_CLASS_NETWORK_ETHERNET,
0x00);
proxy->nvectors = vdev->nvectors;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(PCIDevice *VAR_0)
{
VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, VAR_0, VAR_0);
VirtIODevice *vdev;
vdev = virtio_net_init(&VAR_0->qdev, &proxy->nic, &proxy->net);
vdev->nvectors = proxy->nvectors;
virtio_init_pci(proxy, vdev,
PCI_VENDOR_ID_REDHAT_QUMRANET,
PCI_DEVICE_ID_VIRTIO_NET,
PCI_CLASS_NETWORK_ETHERNET,
0x00);
proxy->nvectors = vdev->nvectors;
return 0;
}
| [
"static int FUNC_0(PCIDevice *VAR_0)\n{",
"VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, VAR_0, VAR_0);",
"VirtIODevice *vdev;",
"vdev = virtio_net_init(&VAR_0->qdev, &proxy->nic, &proxy->net);",
"vdev->nvectors = proxy->nvectors;",
"virtio_init_pci(proxy, vdev,\nPCI_VENDOR_ID_REDHAT_QUMRANET,\nPCI_DEVICE_ID_VIRTIO_NET,\nPCI_CLASS_NETWORK_ETHERNET,\n0x00);",
"proxy->nvectors = vdev->nvectors;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17,
19,
21,
23,
25
],
[
31
],
[
33
],
[
35
]
] |
20,529 | static void z2_init(MachineState *machine)
{
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->initrd_filename;
MemoryRegion *address_space_mem = get_system_memory();
uint32_t sector_len = 0x10000;
PXA2xxState *mpu;
DriveInfo *dinfo;
int be;
void *z2_lcd;
I2CBus *bus;
DeviceState *wm;
if (!cpu_model) {
cpu_model = "pxa270-c5";
}
/* Setup CPU & memory */
mpu = pxa270_init(address_space_mem, z2_binfo.ram_size, cpu_model);
#ifdef TARGET_WORDS_BIGENDIAN
be = 1;
#else
be = 0;
#endif
dinfo = drive_get(IF_PFLASH, 0, 0);
if (!dinfo && !qtest_enabled()) {
fprintf(stderr, "Flash image must be given with the "
"'pflash' parameter\n");
exit(1);
}
if (!pflash_cfi01_register(Z2_FLASH_BASE,
NULL, "z2.flash0", Z2_FLASH_SIZE,
dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL,
sector_len, Z2_FLASH_SIZE / sector_len,
4, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory.\n");
exit(1);
}
/* setup keypad */
pxa27x_register_keypad(mpu->kp, map, 0x100);
/* MMC/SD host */
pxa2xx_mmci_handlers(mpu->mmc,
NULL,
qdev_get_gpio_in(mpu->gpio, Z2_GPIO_SD_DETECT));
type_register_static(&zipit_lcd_info);
type_register_static(&aer915_info);
z2_lcd = ssi_create_slave(mpu->ssp[1], "zipit-lcd");
bus = pxa2xx_i2c_bus(mpu->i2c[0]);
i2c_create_slave(bus, TYPE_AER915, 0x55);
wm = i2c_create_slave(bus, "wm8750", 0x1b);
mpu->i2s->opaque = wm;
mpu->i2s->codec_out = wm8750_dac_dat;
mpu->i2s->codec_in = wm8750_adc_dat;
wm8750_data_req_set(wm, mpu->i2s->data_req, mpu->i2s);
qdev_connect_gpio_out(mpu->gpio, Z2_GPIO_LCD_CS,
qemu_allocate_irq(z2_lcd_cs, z2_lcd, 0));
z2_binfo.kernel_filename = kernel_filename;
z2_binfo.kernel_cmdline = kernel_cmdline;
z2_binfo.initrd_filename = initrd_filename;
z2_binfo.board_id = 0x6dd;
arm_load_kernel(mpu->cpu, &z2_binfo);
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | static void z2_init(MachineState *machine)
{
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->initrd_filename;
MemoryRegion *address_space_mem = get_system_memory();
uint32_t sector_len = 0x10000;
PXA2xxState *mpu;
DriveInfo *dinfo;
int be;
void *z2_lcd;
I2CBus *bus;
DeviceState *wm;
if (!cpu_model) {
cpu_model = "pxa270-c5";
}
mpu = pxa270_init(address_space_mem, z2_binfo.ram_size, cpu_model);
#ifdef TARGET_WORDS_BIGENDIAN
be = 1;
#else
be = 0;
#endif
dinfo = drive_get(IF_PFLASH, 0, 0);
if (!dinfo && !qtest_enabled()) {
fprintf(stderr, "Flash image must be given with the "
"'pflash' parameter\n");
exit(1);
}
if (!pflash_cfi01_register(Z2_FLASH_BASE,
NULL, "z2.flash0", Z2_FLASH_SIZE,
dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL,
sector_len, Z2_FLASH_SIZE / sector_len,
4, 0, 0, 0, 0, be)) {
fprintf(stderr, "qemu: Error registering flash memory.\n");
exit(1);
}
pxa27x_register_keypad(mpu->kp, map, 0x100);
pxa2xx_mmci_handlers(mpu->mmc,
NULL,
qdev_get_gpio_in(mpu->gpio, Z2_GPIO_SD_DETECT));
type_register_static(&zipit_lcd_info);
type_register_static(&aer915_info);
z2_lcd = ssi_create_slave(mpu->ssp[1], "zipit-lcd");
bus = pxa2xx_i2c_bus(mpu->i2c[0]);
i2c_create_slave(bus, TYPE_AER915, 0x55);
wm = i2c_create_slave(bus, "wm8750", 0x1b);
mpu->i2s->opaque = wm;
mpu->i2s->codec_out = wm8750_dac_dat;
mpu->i2s->codec_in = wm8750_adc_dat;
wm8750_data_req_set(wm, mpu->i2s->data_req, mpu->i2s);
qdev_connect_gpio_out(mpu->gpio, Z2_GPIO_LCD_CS,
qemu_allocate_irq(z2_lcd_cs, z2_lcd, 0));
z2_binfo.kernel_filename = kernel_filename;
z2_binfo.kernel_cmdline = kernel_cmdline;
z2_binfo.initrd_filename = initrd_filename;
z2_binfo.board_id = 0x6dd;
arm_load_kernel(mpu->cpu, &z2_binfo);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(MachineState *VAR_0)
{
const char *VAR_1 = VAR_0->VAR_1;
const char *VAR_2 = VAR_0->VAR_2;
const char *VAR_3 = VAR_0->VAR_3;
const char *VAR_4 = VAR_0->VAR_4;
MemoryRegion *address_space_mem = get_system_memory();
uint32_t sector_len = 0x10000;
PXA2xxState *mpu;
DriveInfo *dinfo;
int VAR_5;
void *VAR_6;
I2CBus *bus;
DeviceState *wm;
if (!VAR_1) {
VAR_1 = "pxa270-c5";
}
mpu = pxa270_init(address_space_mem, z2_binfo.ram_size, VAR_1);
#ifdef TARGET_WORDS_BIGENDIAN
VAR_5 = 1;
#else
VAR_5 = 0;
#endif
dinfo = drive_get(IF_PFLASH, 0, 0);
if (!dinfo && !qtest_enabled()) {
fprintf(stderr, "Flash image must VAR_5 given with the "
"'pflash' parameter\n");
exit(1);
}
if (!pflash_cfi01_register(Z2_FLASH_BASE,
NULL, "z2.flash0", Z2_FLASH_SIZE,
dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL,
sector_len, Z2_FLASH_SIZE / sector_len,
4, 0, 0, 0, 0, VAR_5)) {
fprintf(stderr, "qemu: Error registering flash memory.\n");
exit(1);
}
pxa27x_register_keypad(mpu->kp, map, 0x100);
pxa2xx_mmci_handlers(mpu->mmc,
NULL,
qdev_get_gpio_in(mpu->gpio, Z2_GPIO_SD_DETECT));
type_register_static(&zipit_lcd_info);
type_register_static(&aer915_info);
VAR_6 = ssi_create_slave(mpu->ssp[1], "zipit-lcd");
bus = pxa2xx_i2c_bus(mpu->i2c[0]);
i2c_create_slave(bus, TYPE_AER915, 0x55);
wm = i2c_create_slave(bus, "wm8750", 0x1b);
mpu->i2s->opaque = wm;
mpu->i2s->codec_out = wm8750_dac_dat;
mpu->i2s->codec_in = wm8750_adc_dat;
wm8750_data_req_set(wm, mpu->i2s->data_req, mpu->i2s);
qdev_connect_gpio_out(mpu->gpio, Z2_GPIO_LCD_CS,
qemu_allocate_irq(z2_lcd_cs, VAR_6, 0));
z2_binfo.VAR_2 = VAR_2;
z2_binfo.VAR_3 = VAR_3;
z2_binfo.VAR_4 = VAR_4;
z2_binfo.board_id = 0x6dd;
arm_load_kernel(mpu->cpu, &z2_binfo);
}
| [
"static void FUNC_0(MachineState *VAR_0)\n{",
"const char *VAR_1 = VAR_0->VAR_1;",
"const char *VAR_2 = VAR_0->VAR_2;",
"const char *VAR_3 = VAR_0->VAR_3;",
"const char *VAR_4 = VAR_0->VAR_4;",
"MemoryRegion *address_space_mem = get_system_memory();",
"uint32_t sector_len = 0x10000;",
"PXA2xxState *mpu;",
"DriveInfo *dinfo;",
"int VAR_5;",
"void *VAR_6;",
"I2CBus *bus;",
"DeviceState *wm;",
"if (!VAR_1) {",
"VAR_1 = \"pxa270-c5\";",
"}",
"mpu = pxa270_init(address_space_mem, z2_binfo.ram_size, VAR_1);",
"#ifdef TARGET_WORDS_BIGENDIAN\nVAR_5 = 1;",
"#else\nVAR_5 = 0;",
"#endif\ndinfo = drive_get(IF_PFLASH, 0, 0);",
"if (!dinfo && !qtest_enabled()) {",
"fprintf(stderr, \"Flash image must VAR_5 given with the \"\n\"'pflash' parameter\\n\");",
"exit(1);",
"}",
"if (!pflash_cfi01_register(Z2_FLASH_BASE,\nNULL, \"z2.flash0\", Z2_FLASH_SIZE,\ndinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL,\nsector_len, Z2_FLASH_SIZE / sector_len,\n4, 0, 0, 0, 0, VAR_5)) {",
"fprintf(stderr, \"qemu: Error registering flash memory.\\n\");",
"exit(1);",
"}",
"pxa27x_register_keypad(mpu->kp, map, 0x100);",
"pxa2xx_mmci_handlers(mpu->mmc,\nNULL,\nqdev_get_gpio_in(mpu->gpio, Z2_GPIO_SD_DETECT));",
"type_register_static(&zipit_lcd_info);",
"type_register_static(&aer915_info);",
"VAR_6 = ssi_create_slave(mpu->ssp[1], \"zipit-lcd\");",
"bus = pxa2xx_i2c_bus(mpu->i2c[0]);",
"i2c_create_slave(bus, TYPE_AER915, 0x55);",
"wm = i2c_create_slave(bus, \"wm8750\", 0x1b);",
"mpu->i2s->opaque = wm;",
"mpu->i2s->codec_out = wm8750_dac_dat;",
"mpu->i2s->codec_in = wm8750_adc_dat;",
"wm8750_data_req_set(wm, mpu->i2s->data_req, mpu->i2s);",
"qdev_connect_gpio_out(mpu->gpio, Z2_GPIO_LCD_CS,\nqemu_allocate_irq(z2_lcd_cs, VAR_6, 0));",
"z2_binfo.VAR_2 = VAR_2;",
"z2_binfo.VAR_3 = VAR_3;",
"z2_binfo.VAR_4 = VAR_4;",
"z2_binfo.board_id = 0x6dd;",
"arm_load_kernel(mpu->cpu, &z2_binfo);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
31
],
[
33
],
[
35
],
[
41
],
[
45,
47
],
[
49,
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
69,
71,
73,
75,
77
],
[
79
],
[
81
],
[
83
],
[
89
],
[
95,
97,
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125,
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
]
] |
20,533 | static int stdio_fclose(void *opaque)
{
QEMUFileStdio *s = opaque;
int ret = 0;
if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
int fd = fileno(s->stdio_file);
struct stat st;
ret = fstat(fd, &st);
if (ret == 0 && S_ISREG(st.st_mode)) {
/*
* If the file handle is a regular file make sure the
* data is flushed to disk before signaling success.
*/
ret = fsync(fd);
if (ret != 0) {
ret = -errno;
return ret;
}
}
}
if (fclose(s->stdio_file) == EOF) {
ret = -errno;
}
g_free(s);
return ret;
}
| false | qemu | 532bc727c34665370ab0ba94a9536fd3a6c2c5bc | static int stdio_fclose(void *opaque)
{
QEMUFileStdio *s = opaque;
int ret = 0;
if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
int fd = fileno(s->stdio_file);
struct stat st;
ret = fstat(fd, &st);
if (ret == 0 && S_ISREG(st.st_mode)) {
ret = fsync(fd);
if (ret != 0) {
ret = -errno;
return ret;
}
}
}
if (fclose(s->stdio_file) == EOF) {
ret = -errno;
}
g_free(s);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(void *VAR_0)
{
QEMUFileStdio *s = VAR_0;
int VAR_1 = 0;
if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
int VAR_2 = fileno(s->stdio_file);
struct stat VAR_3;
VAR_1 = fstat(VAR_2, &VAR_3);
if (VAR_1 == 0 && S_ISREG(VAR_3.st_mode)) {
VAR_1 = fsync(VAR_2);
if (VAR_1 != 0) {
VAR_1 = -errno;
return VAR_1;
}
}
}
if (fclose(s->stdio_file) == EOF) {
VAR_1 = -errno;
}
g_free(s);
return VAR_1;
}
| [
"static int FUNC_0(void *VAR_0)\n{",
"QEMUFileStdio *s = VAR_0;",
"int VAR_1 = 0;",
"if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {",
"int VAR_2 = fileno(s->stdio_file);",
"struct stat VAR_3;",
"VAR_1 = fstat(VAR_2, &VAR_3);",
"if (VAR_1 == 0 && S_ISREG(VAR_3.st_mode)) {",
"VAR_1 = fsync(VAR_2);",
"if (VAR_1 != 0) {",
"VAR_1 = -errno;",
"return VAR_1;",
"}",
"}",
"}",
"if (fclose(s->stdio_file) == EOF) {",
"VAR_1 = -errno;",
"}",
"g_free(s);",
"return VAR_1;",
"}"
] | [
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
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
]
] |
20,535 | static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) {
int num_gain = 0;
int c, g, sfb, ret, idx = 0;
int sign;
float scale;
SingleChannelElement * sce = &che->ch[0];
ChannelCoupling * coup = &che->coup;
coup->coupling_point = 2*get_bits1(gb);
coup->num_coupled = get_bits(gb, 3);
for (c = 0; c <= coup->num_coupled; c++) {
num_gain++;
coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
coup->id_select[c] = get_bits(gb, 4);
if (coup->type[c] == TYPE_CPE) {
coup->ch_select[c] = get_bits(gb, 2);
if (coup->ch_select[c] == 3)
num_gain++;
} else
coup->ch_select[c] = 1;
}
coup->coupling_point += get_bits1(gb);
if (coup->coupling_point == 2) {
av_log(ac->avccontext, AV_LOG_ERROR,
"Independently switched CCE with 'invalid' domain signalled.\n");
memset(coup, 0, sizeof(ChannelCoupling));
return -1;
}
sign = get_bits(gb, 1);
scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3));
if ((ret = decode_ics(ac, sce, gb, 0, 0)))
return ret;
for (c = 0; c < num_gain; c++) {
int cge = 1;
int gain = 0;
float gain_cache = 1.;
if (c) {
cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
gain_cache = pow(scale, gain);
}
for (g = 0; g < sce->ics.num_window_groups; g++) {
for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
if (sce->band_type[idx] != ZERO_BT) {
if (!cge) {
int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
if (t) {
int s = 1;
if (sign) {
s -= 2 * (t & 0x1);
t >>= 1;
}
gain += t;
gain_cache = pow(scale, gain) * s;
}
}
coup->gain[c][idx] = gain_cache;
}
}
}
}
return 0;
}
| false | FFmpeg | 341b28c0d274ade7902588697ec1d8bdfe449185 | static int decode_cce(AACContext * ac, GetBitContext * gb, ChannelElement * che) {
int num_gain = 0;
int c, g, sfb, ret, idx = 0;
int sign;
float scale;
SingleChannelElement * sce = &che->ch[0];
ChannelCoupling * coup = &che->coup;
coup->coupling_point = 2*get_bits1(gb);
coup->num_coupled = get_bits(gb, 3);
for (c = 0; c <= coup->num_coupled; c++) {
num_gain++;
coup->type[c] = get_bits1(gb) ? TYPE_CPE : TYPE_SCE;
coup->id_select[c] = get_bits(gb, 4);
if (coup->type[c] == TYPE_CPE) {
coup->ch_select[c] = get_bits(gb, 2);
if (coup->ch_select[c] == 3)
num_gain++;
} else
coup->ch_select[c] = 1;
}
coup->coupling_point += get_bits1(gb);
if (coup->coupling_point == 2) {
av_log(ac->avccontext, AV_LOG_ERROR,
"Independently switched CCE with 'invalid' domain signalled.\n");
memset(coup, 0, sizeof(ChannelCoupling));
return -1;
}
sign = get_bits(gb, 1);
scale = pow(2., pow(2., (int)get_bits(gb, 2) - 3));
if ((ret = decode_ics(ac, sce, gb, 0, 0)))
return ret;
for (c = 0; c < num_gain; c++) {
int cge = 1;
int gain = 0;
float gain_cache = 1.;
if (c) {
cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
gain_cache = pow(scale, gain);
}
for (g = 0; g < sce->ics.num_window_groups; g++) {
for (sfb = 0; sfb < sce->ics.max_sfb; sfb++, idx++) {
if (sce->band_type[idx] != ZERO_BT) {
if (!cge) {
int t = get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
if (t) {
int s = 1;
if (sign) {
s -= 2 * (t & 0x1);
t >>= 1;
}
gain += t;
gain_cache = pow(scale, gain) * s;
}
}
coup->gain[c][idx] = gain_cache;
}
}
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AACContext * VAR_0, GetBitContext * VAR_1, ChannelElement * VAR_2) {
int VAR_3 = 0;
int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8 = 0;
int VAR_9;
float VAR_10;
SingleChannelElement * sce = &VAR_2->ch[0];
ChannelCoupling * coup = &VAR_2->coup;
coup->coupling_point = 2*get_bits1(VAR_1);
coup->num_coupled = get_bits(VAR_1, 3);
for (VAR_4 = 0; VAR_4 <= coup->num_coupled; VAR_4++) {
VAR_3++;
coup->type[VAR_4] = get_bits1(VAR_1) ? TYPE_CPE : TYPE_SCE;
coup->id_select[VAR_4] = get_bits(VAR_1, 4);
if (coup->type[VAR_4] == TYPE_CPE) {
coup->ch_select[VAR_4] = get_bits(VAR_1, 2);
if (coup->ch_select[VAR_4] == 3)
VAR_3++;
} else
coup->ch_select[VAR_4] = 1;
}
coup->coupling_point += get_bits1(VAR_1);
if (coup->coupling_point == 2) {
av_log(VAR_0->avccontext, AV_LOG_ERROR,
"Independently switched CCE with 'invalid' domain signalled.\n");
memset(coup, 0, sizeof(ChannelCoupling));
return -1;
}
VAR_9 = get_bits(VAR_1, 1);
VAR_10 = pow(2., pow(2., (int)get_bits(VAR_1, 2) - 3));
if ((VAR_7 = decode_ics(VAR_0, sce, VAR_1, 0, 0)))
return VAR_7;
for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {
int VAR_11 = 1;
int VAR_12 = 0;
float VAR_13 = 1.;
if (VAR_4) {
VAR_11 = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(VAR_1);
VAR_12 = VAR_11 ? get_vlc2(VAR_1, vlc_scalefactors.table, 7, 3) - 60: 0;
VAR_13 = pow(VAR_10, VAR_12);
}
for (VAR_5 = 0; VAR_5 < sce->ics.num_window_groups; VAR_5++) {
for (VAR_6 = 0; VAR_6 < sce->ics.max_sfb; VAR_6++, VAR_8++) {
if (sce->band_type[VAR_8] != ZERO_BT) {
if (!VAR_11) {
int t = get_vlc2(VAR_1, vlc_scalefactors.table, 7, 3) - 60;
if (t) {
int s = 1;
if (VAR_9) {
s -= 2 * (t & 0x1);
t >>= 1;
}
VAR_12 += t;
VAR_13 = pow(VAR_10, VAR_12) * s;
}
}
coup->VAR_12[VAR_4][VAR_8] = VAR_13;
}
}
}
}
return 0;
}
| [
"static int FUNC_0(AACContext * VAR_0, GetBitContext * VAR_1, ChannelElement * VAR_2) {",
"int VAR_3 = 0;",
"int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8 = 0;",
"int VAR_9;",
"float VAR_10;",
"SingleChannelElement * sce = &VAR_2->ch[0];",
"ChannelCoupling * coup = &VAR_2->coup;",
"coup->coupling_point = 2*get_bits1(VAR_1);",
"coup->num_coupled = get_bits(VAR_1, 3);",
"for (VAR_4 = 0; VAR_4 <= coup->num_coupled; VAR_4++) {",
"VAR_3++;",
"coup->type[VAR_4] = get_bits1(VAR_1) ? TYPE_CPE : TYPE_SCE;",
"coup->id_select[VAR_4] = get_bits(VAR_1, 4);",
"if (coup->type[VAR_4] == TYPE_CPE) {",
"coup->ch_select[VAR_4] = get_bits(VAR_1, 2);",
"if (coup->ch_select[VAR_4] == 3)\nVAR_3++;",
"} else",
"coup->ch_select[VAR_4] = 1;",
"}",
"coup->coupling_point += get_bits1(VAR_1);",
"if (coup->coupling_point == 2) {",
"av_log(VAR_0->avccontext, AV_LOG_ERROR,\n\"Independently switched CCE with 'invalid' domain signalled.\\n\");",
"memset(coup, 0, sizeof(ChannelCoupling));",
"return -1;",
"}",
"VAR_9 = get_bits(VAR_1, 1);",
"VAR_10 = pow(2., pow(2., (int)get_bits(VAR_1, 2) - 3));",
"if ((VAR_7 = decode_ics(VAR_0, sce, VAR_1, 0, 0)))\nreturn VAR_7;",
"for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {",
"int VAR_11 = 1;",
"int VAR_12 = 0;",
"float VAR_13 = 1.;",
"if (VAR_4) {",
"VAR_11 = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(VAR_1);",
"VAR_12 = VAR_11 ? get_vlc2(VAR_1, vlc_scalefactors.table, 7, 3) - 60: 0;",
"VAR_13 = pow(VAR_10, VAR_12);",
"}",
"for (VAR_5 = 0; VAR_5 < sce->ics.num_window_groups; VAR_5++) {",
"for (VAR_6 = 0; VAR_6 < sce->ics.max_sfb; VAR_6++, VAR_8++) {",
"if (sce->band_type[VAR_8] != ZERO_BT) {",
"if (!VAR_11) {",
"int t = get_vlc2(VAR_1, vlc_scalefactors.table, 7, 3) - 60;",
"if (t) {",
"int s = 1;",
"if (VAR_9) {",
"s -= 2 * (t & 0x1);",
"t >>= 1;",
"}",
"VAR_12 += t;",
"VAR_13 = pow(VAR_10, VAR_12) * s;",
"}",
"}",
"coup->VAR_12[VAR_4][VAR_8] = VAR_13;",
"}",
"}",
"}",
"}",
"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
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49,
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
67,
69
],
[
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
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
]
] |
20,537 | void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
{
if (h&3) {
ff_avg_dirac_pixels32_c(dst, src, stride, h);
} else {
ff_avg_pixels16_sse2(dst , src[0] , stride, h);
ff_avg_pixels16_sse2(dst+16, src[0]+16, stride, h);
}
}
| false | FFmpeg | 6a4832caaede15e3d918b1408ff83fe30324507b | void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
{
if (h&3) {
ff_avg_dirac_pixels32_c(dst, src, stride, h);
} else {
ff_avg_pixels16_sse2(dst , src[0] , stride, h);
ff_avg_pixels16_sse2(dst+16, src[0]+16, stride, h);
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1[5], int VAR_2, int VAR_3)
{
if (VAR_3&3) {
ff_avg_dirac_pixels32_c(VAR_0, VAR_1, VAR_2, VAR_3);
} else {
ff_avg_pixels16_sse2(VAR_0 , VAR_1[0] , VAR_2, VAR_3);
ff_avg_pixels16_sse2(VAR_0+16, VAR_1[0]+16, VAR_2, VAR_3);
}
}
| [
"void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1[5], int VAR_2, int VAR_3)\n{",
"if (VAR_3&3) {",
"ff_avg_dirac_pixels32_c(VAR_0, VAR_1, VAR_2, VAR_3);",
"} else {",
"ff_avg_pixels16_sse2(VAR_0 , VAR_1[0] , VAR_2, VAR_3);",
"ff_avg_pixels16_sse2(VAR_0+16, VAR_1[0]+16, VAR_2, VAR_3);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
20,538 | static int ra288_decode_frame(AVCodecContext * avctx, void *data,
int *data_size, const uint8_t * buf,
int buf_size)
{
int16_t *out = data;
int i, j;
RA288Context *ractx = avctx->priv_data;
GetBitContext gb;
if (buf_size < avctx->block_align) {
av_log(avctx, AV_LOG_ERROR,
"Error! Input buffer is too small [%d<%d]\n",
buf_size, avctx->block_align);
return 0;
}
init_get_bits(&gb, buf, avctx->block_align * 8);
for (i=0; i < 32; i++) {
float gain = amptable[get_bits(&gb, 3)];
int cb_coef = get_bits(&gb, 6 + (i&1));
decode(ractx, gain, cb_coef);
for (j=0; j < 5; j++)
*(out++) = 8 * ractx->sp_block[4 - j];
if ((i & 7) == 3)
backward_filter(ractx);
}
*data_size = (char *)out - (char *)data;
return avctx->block_align;
}
| false | FFmpeg | e3751aa6ec8147ab7ca2649d4daadf8d4dce27d5 | static int ra288_decode_frame(AVCodecContext * avctx, void *data,
int *data_size, const uint8_t * buf,
int buf_size)
{
int16_t *out = data;
int i, j;
RA288Context *ractx = avctx->priv_data;
GetBitContext gb;
if (buf_size < avctx->block_align) {
av_log(avctx, AV_LOG_ERROR,
"Error! Input buffer is too small [%d<%d]\n",
buf_size, avctx->block_align);
return 0;
}
init_get_bits(&gb, buf, avctx->block_align * 8);
for (i=0; i < 32; i++) {
float gain = amptable[get_bits(&gb, 3)];
int cb_coef = get_bits(&gb, 6 + (i&1));
decode(ractx, gain, cb_coef);
for (j=0; j < 5; j++)
*(out++) = 8 * ractx->sp_block[4 - j];
if ((i & 7) == 3)
backward_filter(ractx);
}
*data_size = (char *)out - (char *)data;
return avctx->block_align;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1,
int *VAR_2, const uint8_t * VAR_3,
int VAR_4)
{
int16_t *out = VAR_1;
int VAR_5, VAR_6;
RA288Context *ractx = VAR_0->priv_data;
GetBitContext gb;
if (VAR_4 < VAR_0->block_align) {
av_log(VAR_0, AV_LOG_ERROR,
"Error! Input buffer is too small [%d<%d]\n",
VAR_4, VAR_0->block_align);
return 0;
}
init_get_bits(&gb, VAR_3, VAR_0->block_align * 8);
for (VAR_5=0; VAR_5 < 32; VAR_5++) {
float VAR_7 = amptable[get_bits(&gb, 3)];
int VAR_8 = get_bits(&gb, 6 + (VAR_5&1));
decode(ractx, VAR_7, VAR_8);
for (VAR_6=0; VAR_6 < 5; VAR_6++)
*(out++) = 8 * ractx->sp_block[4 - VAR_6];
if ((VAR_5 & 7) == 3)
backward_filter(ractx);
}
*VAR_2 = (char *)out - (char *)VAR_1;
return VAR_0->block_align;
}
| [
"static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1,\nint *VAR_2, const uint8_t * VAR_3,\nint VAR_4)\n{",
"int16_t *out = VAR_1;",
"int VAR_5, VAR_6;",
"RA288Context *ractx = VAR_0->priv_data;",
"GetBitContext gb;",
"if (VAR_4 < VAR_0->block_align) {",
"av_log(VAR_0, AV_LOG_ERROR,\n\"Error! Input buffer is too small [%d<%d]\\n\",\nVAR_4, VAR_0->block_align);",
"return 0;",
"}",
"init_get_bits(&gb, VAR_3, VAR_0->block_align * 8);",
"for (VAR_5=0; VAR_5 < 32; VAR_5++) {",
"float VAR_7 = amptable[get_bits(&gb, 3)];",
"int VAR_8 = get_bits(&gb, 6 + (VAR_5&1));",
"decode(ractx, VAR_7, VAR_8);",
"for (VAR_6=0; VAR_6 < 5; VAR_6++)",
"*(out++) = 8 * ractx->sp_block[4 - VAR_6];",
"if ((VAR_5 & 7) == 3)\nbackward_filter(ractx);",
"}",
"*VAR_2 = (char *)out - (char *)VAR_1;",
"return VAR_0->block_align;",
"}"
] | [
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
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
49
],
[
51
],
[
55,
57
],
[
59
],
[
63
],
[
65
],
[
67
]
] |
20,539 | void ff_avg_h264_qpel8_mc31_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_8x8_msa(src - 2,
src - (stride * 2) +
sizeof(uint8_t), stride, dst, stride);
}
| false | FFmpeg | 1181d93231e9b807965724587d363c1cfd5a1d0d | void ff_avg_h264_qpel8_mc31_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_8x8_msa(src - 2,
src - (stride * 2) +
sizeof(uint8_t), stride, dst, stride);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,
ptrdiff_t VAR_2)
{
avc_luma_hv_qrt_and_aver_dst_8x8_msa(VAR_1 - 2,
VAR_1 - (VAR_2 * 2) +
sizeof(uint8_t), VAR_2, VAR_0, VAR_2);
}
| [
"void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{",
"avc_luma_hv_qrt_and_aver_dst_8x8_msa(VAR_1 - 2,\nVAR_1 - (VAR_2 * 2) +\nsizeof(uint8_t), VAR_2, VAR_0, VAR_2);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5
],
[
7,
9,
11
],
[
13
]
] |
20,540 | static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
{
int ret = 0;
/* apply the output bitstream filters, if any */
if (ost->nb_bitstream_filters) {
int idx;
ret = av_bsf_send_packet(ost->bsf_ctx[0], pkt);
if (ret < 0)
goto finish;
idx = 1;
while (idx) {
/* get a packet from the previous filter up the chain */
ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
if (ret == AVERROR(EAGAIN)) {
ret = 0;
idx--;
continue;
} else if (ret < 0)
goto finish;
/* HACK! - aac_adtstoasc updates extradata after filtering the first frame when
* the api states this shouldn't happen after init(). Propagate it here to the
* muxer and to the next filters in the chain to workaround this.
* TODO/FIXME - Make aac_adtstoasc use new packet side data instead of changing
* par_out->extradata and adapt muxers accordingly to get rid of this. */
if (!(ost->bsf_extradata_updated[idx - 1] & 1)) {
ret = avcodec_parameters_copy(ost->st->codecpar, ost->bsf_ctx[idx - 1]->par_out);
if (ret < 0)
goto finish;
ost->bsf_extradata_updated[idx - 1] |= 1;
}
/* send it to the next filter down the chain or to the muxer */
if (idx < ost->nb_bitstream_filters) {
/* HACK/FIXME! - See above */
if (!(ost->bsf_extradata_updated[idx] & 2)) {
ret = avcodec_parameters_copy(ost->bsf_ctx[idx]->par_out, ost->bsf_ctx[idx - 1]->par_out);
if (ret < 0)
goto finish;
ost->bsf_extradata_updated[idx] |= 2;
}
ret = av_bsf_send_packet(ost->bsf_ctx[idx], pkt);
if (ret < 0)
goto finish;
idx++;
} else
write_packet(of, pkt, ost);
}
} else
write_packet(of, pkt, ost);
finish:
if (ret < 0 && ret != AVERROR_EOF) {
av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
"packet for stream #%d:%d.\n", ost->file_index, ost->index);
if(exit_on_error)
exit_program(1);
}
}
| false | FFmpeg | c4be288fdbe1993110f1abd28ea57587cb2bc221 | static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
{
int ret = 0;
if (ost->nb_bitstream_filters) {
int idx;
ret = av_bsf_send_packet(ost->bsf_ctx[0], pkt);
if (ret < 0)
goto finish;
idx = 1;
while (idx) {
ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
if (ret == AVERROR(EAGAIN)) {
ret = 0;
idx--;
continue;
} else if (ret < 0)
goto finish;
if (!(ost->bsf_extradata_updated[idx - 1] & 1)) {
ret = avcodec_parameters_copy(ost->st->codecpar, ost->bsf_ctx[idx - 1]->par_out);
if (ret < 0)
goto finish;
ost->bsf_extradata_updated[idx - 1] |= 1;
}
if (idx < ost->nb_bitstream_filters) {
if (!(ost->bsf_extradata_updated[idx] & 2)) {
ret = avcodec_parameters_copy(ost->bsf_ctx[idx]->par_out, ost->bsf_ctx[idx - 1]->par_out);
if (ret < 0)
goto finish;
ost->bsf_extradata_updated[idx] |= 2;
}
ret = av_bsf_send_packet(ost->bsf_ctx[idx], pkt);
if (ret < 0)
goto finish;
idx++;
} else
write_packet(of, pkt, ost);
}
} else
write_packet(of, pkt, ost);
finish:
if (ret < 0 && ret != AVERROR_EOF) {
av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
"packet for stream #%d:%d.\n", ost->file_index, ost->index);
if(exit_on_error)
exit_program(1);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(OutputFile *VAR_0, AVPacket *VAR_1, OutputStream *VAR_2)
{
int VAR_3 = 0;
if (VAR_2->nb_bitstream_filters) {
int VAR_4;
VAR_3 = av_bsf_send_packet(VAR_2->bsf_ctx[0], VAR_1);
if (VAR_3 < 0)
goto finish;
VAR_4 = 1;
while (VAR_4) {
VAR_3 = av_bsf_receive_packet(VAR_2->bsf_ctx[VAR_4 - 1], VAR_1);
if (VAR_3 == AVERROR(EAGAIN)) {
VAR_3 = 0;
VAR_4--;
continue;
} else if (VAR_3 < 0)
goto finish;
if (!(VAR_2->bsf_extradata_updated[VAR_4 - 1] & 1)) {
VAR_3 = avcodec_parameters_copy(VAR_2->st->codecpar, VAR_2->bsf_ctx[VAR_4 - 1]->par_out);
if (VAR_3 < 0)
goto finish;
VAR_2->bsf_extradata_updated[VAR_4 - 1] |= 1;
}
if (VAR_4 < VAR_2->nb_bitstream_filters) {
if (!(VAR_2->bsf_extradata_updated[VAR_4] & 2)) {
VAR_3 = avcodec_parameters_copy(VAR_2->bsf_ctx[VAR_4]->par_out, VAR_2->bsf_ctx[VAR_4 - 1]->par_out);
if (VAR_3 < 0)
goto finish;
VAR_2->bsf_extradata_updated[VAR_4] |= 2;
}
VAR_3 = av_bsf_send_packet(VAR_2->bsf_ctx[VAR_4], VAR_1);
if (VAR_3 < 0)
goto finish;
VAR_4++;
} else
write_packet(VAR_0, VAR_1, VAR_2);
}
} else
write_packet(VAR_0, VAR_1, VAR_2);
finish:
if (VAR_3 < 0 && VAR_3 != AVERROR_EOF) {
av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
"packet for stream #%d:%d.\n", VAR_2->file_index, VAR_2->index);
if(exit_on_error)
exit_program(1);
}
}
| [
"static void FUNC_0(OutputFile *VAR_0, AVPacket *VAR_1, OutputStream *VAR_2)\n{",
"int VAR_3 = 0;",
"if (VAR_2->nb_bitstream_filters) {",
"int VAR_4;",
"VAR_3 = av_bsf_send_packet(VAR_2->bsf_ctx[0], VAR_1);",
"if (VAR_3 < 0)\ngoto finish;",
"VAR_4 = 1;",
"while (VAR_4) {",
"VAR_3 = av_bsf_receive_packet(VAR_2->bsf_ctx[VAR_4 - 1], VAR_1);",
"if (VAR_3 == AVERROR(EAGAIN)) {",
"VAR_3 = 0;",
"VAR_4--;",
"continue;",
"} else if (VAR_3 < 0)",
"goto finish;",
"if (!(VAR_2->bsf_extradata_updated[VAR_4 - 1] & 1)) {",
"VAR_3 = avcodec_parameters_copy(VAR_2->st->codecpar, VAR_2->bsf_ctx[VAR_4 - 1]->par_out);",
"if (VAR_3 < 0)\ngoto finish;",
"VAR_2->bsf_extradata_updated[VAR_4 - 1] |= 1;",
"}",
"if (VAR_4 < VAR_2->nb_bitstream_filters) {",
"if (!(VAR_2->bsf_extradata_updated[VAR_4] & 2)) {",
"VAR_3 = avcodec_parameters_copy(VAR_2->bsf_ctx[VAR_4]->par_out, VAR_2->bsf_ctx[VAR_4 - 1]->par_out);",
"if (VAR_3 < 0)\ngoto finish;",
"VAR_2->bsf_extradata_updated[VAR_4] |= 2;",
"}",
"VAR_3 = av_bsf_send_packet(VAR_2->bsf_ctx[VAR_4], VAR_1);",
"if (VAR_3 < 0)\ngoto finish;",
"VAR_4++;",
"} else",
"write_packet(VAR_0, VAR_1, VAR_2);",
"}",
"} else",
"write_packet(VAR_0, VAR_1, VAR_2);",
"finish:\nif (VAR_3 < 0 && VAR_3 != AVERROR_EOF) {",
"av_log(NULL, AV_LOG_ERROR, \"Error applying bitstream filters to an output \"\n\"packet for stream #%d:%d.\\n\", VAR_2->file_index, VAR_2->index);",
"if(exit_on_error)\nexit_program(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
] | [
[
1,
3
],
[
5
],
[
11
],
[
13
],
[
17
],
[
19,
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
71
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
87
],
[
89,
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
107,
109
],
[
111,
113
],
[
115,
117
],
[
119
],
[
121
]
] |
20,542 | static int decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
H264Context *h = avctx->priv_data;
MpegEncContext *s = &h->s;
AVFrame *pict = data;
float new_aspect;
int buf_index;
s->flags= avctx->flags;
*data_size = 0;
/* no supplementary picture */
if (buf_size == 0) {
return 0;
}
if(s->flags&CODEC_FLAG_TRUNCATED){
int next= find_frame_end(s, buf, buf_size);
if( ff_combine_frame(s, next, &buf, &buf_size) < 0 )
return buf_size;
//printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index);
}
if(s->avctx->extradata_size && s->picture_number==0){
if(0 < decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) )
return -1;
}
buf_index=decode_nal_units(h, buf, buf_size);
if(buf_index < 0)
return -1;
//FIXME do something with unavailable reference frames
// if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_index, buf_size);
#if 0
if(s->pict_type==B_TYPE || s->low_delay){
*pict= *(AVFrame*)&s->current_picture;
} else {
*pict= *(AVFrame*)&s->last_picture;
}
#endif
*pict= *(AVFrame*)&s->current_picture; //FIXME
assert(pict->data[0]);
//printf("out %d\n", (int)pict->data[0]);
if(avctx->debug&FF_DEBUG_QP){
int8_t *qtab= pict->qscale_table;
int x,y;
for(y=0; y<s->mb_height; y++){
for(x=0; x<s->mb_width; x++){
printf("%2d ", qtab[x + y*s->mb_width]);
}
printf("\n");
}
printf("\n");
}
#if 0 //?
/* Return the Picture timestamp as the frame number */
/* we substract 1 because it is added on utils.c */
avctx->frame_number = s->picture_number - 1;
#endif
#if 0
/* dont output the last pic after seeking */
if(s->last_picture_ptr || s->low_delay)
//Note this isnt a issue as a IDR pic should flush teh buffers
#endif
*data_size = sizeof(AVFrame);
return get_consumed_bytes(s, buf_index, buf_size);
}
| false | FFmpeg | 8b92b792d18d7dc3d258f440bb0493af4e973516 | static int decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
H264Context *h = avctx->priv_data;
MpegEncContext *s = &h->s;
AVFrame *pict = data;
float new_aspect;
int buf_index;
s->flags= avctx->flags;
*data_size = 0;
if (buf_size == 0) {
return 0;
}
if(s->flags&CODEC_FLAG_TRUNCATED){
int next= find_frame_end(s, buf, buf_size);
if( ff_combine_frame(s, next, &buf, &buf_size) < 0 )
return buf_size;
}
if(s->avctx->extradata_size && s->picture_number==0){
if(0 < decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) )
return -1;
}
buf_index=decode_nal_units(h, buf, buf_size);
if(buf_index < 0)
return -1;
#if 0
if(s->pict_type==B_TYPE || s->low_delay){
*pict= *(AVFrame*)&s->current_picture;
} else {
*pict= *(AVFrame*)&s->last_picture;
}
#endif
*pict= *(AVFrame*)&s->current_picture;
assert(pict->data[0]);
if(avctx->debug&FF_DEBUG_QP){
int8_t *qtab= pict->qscale_table;
int x,y;
for(y=0; y<s->mb_height; y++){
for(x=0; x<s->mb_width; x++){
printf("%2d ", qtab[x + y*s->mb_width]);
}
printf("\n");
}
printf("\n");
}
#if 0
avctx->frame_number = s->picture_number - 1;
#endif
#if 0
if(s->last_picture_ptr || s->low_delay)
#endif
*data_size = sizeof(AVFrame);
return get_consumed_bytes(s, buf_index, buf_size);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
uint8_t *VAR_3, int VAR_4)
{
H264Context *h = VAR_0->priv_data;
MpegEncContext *s = &h->s;
AVFrame *pict = VAR_1;
float VAR_5;
int VAR_6;
s->flags= VAR_0->flags;
*VAR_2 = 0;
if (VAR_4 == 0) {
return 0;
}
if(s->flags&CODEC_FLAG_TRUNCATED){
int VAR_7= find_frame_end(s, VAR_3, VAR_4);
if( ff_combine_frame(s, VAR_7, &VAR_3, &VAR_4) < 0 )
return VAR_4;
}
if(s->VAR_0->extradata_size && s->picture_number==0){
if(0 < decode_nal_units(h, s->VAR_0->extradata, s->VAR_0->extradata_size) )
return -1;
}
VAR_6=decode_nal_units(h, VAR_3, VAR_4);
if(VAR_6 < 0)
return -1;
#if 0
if(s->pict_type==B_TYPE || s->low_delay){
*pict= *(AVFrame*)&s->current_picture;
} else {
*pict= *(AVFrame*)&s->last_picture;
}
#endif
*pict= *(AVFrame*)&s->current_picture;
assert(pict->VAR_1[0]);
if(VAR_0->debug&FF_DEBUG_QP){
int8_t *qtab= pict->qscale_table;
int VAR_8,VAR_9;
for(VAR_9=0; VAR_9<s->mb_height; VAR_9++){
for(VAR_8=0; VAR_8<s->mb_width; VAR_8++){
printf("%2d ", qtab[VAR_8 + VAR_9*s->mb_width]);
}
printf("\n");
}
printf("\n");
}
#if 0
VAR_0->frame_number = s->picture_number - 1;
#endif
#if 0
if(s->last_picture_ptr || s->low_delay)
#endif
*VAR_2 = sizeof(AVFrame);
return get_consumed_bytes(s, VAR_6, VAR_4);
}
| [
"static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{",
"H264Context *h = VAR_0->priv_data;",
"MpegEncContext *s = &h->s;",
"AVFrame *pict = VAR_1;",
"float VAR_5;",
"int VAR_6;",
"s->flags= VAR_0->flags;",
"*VAR_2 = 0;",
"if (VAR_4 == 0) {",
"return 0;",
"}",
"if(s->flags&CODEC_FLAG_TRUNCATED){",
"int VAR_7= find_frame_end(s, VAR_3, VAR_4);",
"if( ff_combine_frame(s, VAR_7, &VAR_3, &VAR_4) < 0 )\nreturn VAR_4;",
"}",
"if(s->VAR_0->extradata_size && s->picture_number==0){",
"if(0 < decode_nal_units(h, s->VAR_0->extradata, s->VAR_0->extradata_size) )\nreturn -1;",
"}",
"VAR_6=decode_nal_units(h, VAR_3, VAR_4);",
"if(VAR_6 < 0)\nreturn -1;",
"#if 0\nif(s->pict_type==B_TYPE || s->low_delay){",
"*pict= *(AVFrame*)&s->current_picture;",
"} else {",
"*pict= *(AVFrame*)&s->last_picture;",
"}",
"#endif\n*pict= *(AVFrame*)&s->current_picture;",
"assert(pict->VAR_1[0]);",
"if(VAR_0->debug&FF_DEBUG_QP){",
"int8_t *qtab= pict->qscale_table;",
"int VAR_8,VAR_9;",
"for(VAR_9=0; VAR_9<s->mb_height; VAR_9++){",
"for(VAR_8=0; VAR_8<s->mb_width; VAR_8++){",
"printf(\"%2d \", qtab[VAR_8 + VAR_9*s->mb_width]);",
"}",
"printf(\"\\n\");",
"}",
"printf(\"\\n\");",
"}",
"#if 0\nVAR_0->frame_number = s->picture_number - 1;",
"#endif\n#if 0\nif(s->last_picture_ptr || s->low_delay)\n#endif\n*VAR_2 = sizeof(AVFrame);",
"return get_consumed_bytes(s, VAR_6, 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,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
45,
47
],
[
51
],
[
55
],
[
57,
59
],
[
61
],
[
65
],
[
67,
69
],
[
79,
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91,
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123,
131
],
[
133,
135,
139,
143,
145
],
[
147
],
[
149
]
] |
20,543 | static int slice_decode_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
const uint8_t *buf= s->gb.buffer;
int mb_y= s->start_mb_y;
const int field_pic= s->picture_structure != PICT_FRAME;
s->error_count= (3*(s->end_mb_y - s->start_mb_y)*s->mb_width) >> field_pic;
for(;;){
uint32_t start_code;
int ret;
ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
emms_c();
//av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
//ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, s->start_mb_y, s->end_mb_y, s->error_count);
if(ret < 0){
if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
}else{
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
}
if(s->mb_y == s->end_mb_y)
return 0;
start_code= -1;
buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
mb_y= (start_code - SLICE_MIN_START_CODE) << field_pic;
if (s->picture_structure == PICT_BOTTOM_FIELD)
mb_y++;
if(mb_y < 0 || mb_y >= s->end_mb_y)
return -1;
}
return 0; //not reached
}
| false | FFmpeg | add41decd94b2d3581a3715ba10f27168b8cdb1b | static int slice_decode_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
const uint8_t *buf= s->gb.buffer;
int mb_y= s->start_mb_y;
const int field_pic= s->picture_structure != PICT_FRAME;
s->error_count= (3*(s->end_mb_y - s->start_mb_y)*s->mb_width) >> field_pic;
for(;;){
uint32_t start_code;
int ret;
ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
emms_c();
if(ret < 0){
if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
}else{
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
}
if(s->mb_y == s->end_mb_y)
return 0;
start_code= -1;
buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
mb_y= (start_code - SLICE_MIN_START_CODE) << field_pic;
if (s->picture_structure == PICT_BOTTOM_FIELD)
mb_y++;
if(mb_y < 0 || mb_y >= s->end_mb_y)
return -1;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1){
MpegEncContext *s= *(void**)VAR_1;
const uint8_t *VAR_2= s->gb.buffer;
int VAR_3= s->start_mb_y;
const int VAR_4= s->picture_structure != PICT_FRAME;
s->error_count= (3*(s->end_mb_y - s->start_mb_y)*s->mb_width) >> VAR_4;
for(;;){
uint32_t start_code;
int VAR_5;
VAR_5= mpeg_decode_slice((Mpeg1Context*)s, VAR_3, &VAR_2, s->gb.buffer_end - VAR_2);
emms_c();
if(VAR_5 < 0){
if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->VAR_3, AC_ERROR|DC_ERROR|MV_ERROR);
}else{
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->VAR_3, AC_END|DC_END|MV_END);
}
if(s->VAR_3 == s->end_mb_y)
return 0;
start_code= -1;
VAR_2 = ff_find_start_code(VAR_2, s->gb.buffer_end, &start_code);
VAR_3= (start_code - SLICE_MIN_START_CODE) << VAR_4;
if (s->picture_structure == PICT_BOTTOM_FIELD)
VAR_3++;
if(VAR_3 < 0 || VAR_3 >= s->end_mb_y)
return -1;
}
return 0;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1){",
"MpegEncContext *s= *(void**)VAR_1;",
"const uint8_t *VAR_2= s->gb.buffer;",
"int VAR_3= s->start_mb_y;",
"const int VAR_4= s->picture_structure != PICT_FRAME;",
"s->error_count= (3*(s->end_mb_y - s->start_mb_y)*s->mb_width) >> VAR_4;",
"for(;;){",
"uint32_t start_code;",
"int VAR_5;",
"VAR_5= mpeg_decode_slice((Mpeg1Context*)s, VAR_3, &VAR_2, s->gb.buffer_end - VAR_2);",
"emms_c();",
"if(VAR_5 < 0){",
"if(s->resync_mb_x>=0 && s->resync_mb_y>=0)\nff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->VAR_3, AC_ERROR|DC_ERROR|MV_ERROR);",
"}else{",
"ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->VAR_3, AC_END|DC_END|MV_END);",
"}",
"if(s->VAR_3 == s->end_mb_y)\nreturn 0;",
"start_code= -1;",
"VAR_2 = ff_find_start_code(VAR_2, s->gb.buffer_end, &start_code);",
"VAR_3= (start_code - SLICE_MIN_START_CODE) << VAR_4;",
"if (s->picture_structure == PICT_BOTTOM_FIELD)\nVAR_3++;",
"if(VAR_3 < 0 || VAR_3 >= s->end_mb_y)\nreturn -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
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
47,
49
],
[
53
],
[
55
],
[
57
],
[
59,
61
],
[
63,
65
],
[
67
],
[
71
],
[
73
]
] |
20,544 | void ff_put_h264_qpel16_mc12_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_midh_qrt_16w_msa(src - (2 * stride) - 2,
stride, dst, stride, 16, 0);
}
| false | FFmpeg | e549933a270dd2cfc36f2cf9bb6b29acf3dc6d08 | void ff_put_h264_qpel16_mc12_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_midh_qrt_16w_msa(src - (2 * stride) - 2,
stride, dst, stride, 16, 0);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,
ptrdiff_t VAR_2)
{
avc_luma_midh_qrt_16w_msa(VAR_1 - (2 * VAR_2) - 2,
VAR_2, VAR_0, VAR_2, 16, 0);
}
| [
"void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{",
"avc_luma_midh_qrt_16w_msa(VAR_1 - (2 * VAR_2) - 2,\nVAR_2, VAR_0, VAR_2, 16, 0);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5
],
[
7,
9
],
[
11
]
] |
20,545 | static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
int i;
const int index_a = qp + h->slice_alpha_c0_offset;
const int alpha = (alpha_table+52)[index_a];
const int beta = (beta_table+52)[qp + h->slice_beta_offset];
if( bS[0] < 4 ) {
int8_t tc[4];
for(i=0; i<4; i++)
tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
| false | FFmpeg | aac8b76983e340bc744d3542d676f72efa3b474f | static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
int i;
const int index_a = qp + h->slice_alpha_c0_offset;
const int alpha = (alpha_table+52)[index_a];
const int beta = (beta_table+52)[qp + h->slice_beta_offset];
if( bS[0] < 4 ) {
int8_t tc[4];
for(i=0; i<4; i++)
tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0( H264Context *VAR_0, uint8_t *VAR_1, int VAR_2, int16_t VAR_3[4], int VAR_4 ) {
int VAR_5;
const int VAR_6 = VAR_4 + VAR_0->slice_alpha_c0_offset;
const int VAR_7 = (alpha_table+52)[VAR_6];
const int VAR_8 = (beta_table+52)[VAR_4 + VAR_0->slice_beta_offset];
if( VAR_3[0] < 4 ) {
int8_t tc[4];
for(VAR_5=0; VAR_5<4; VAR_5++)
tc[VAR_5] = VAR_3[VAR_5] ? (tc0_table+52)[VAR_6][VAR_3[VAR_5] - 1] + 1 : 0;
VAR_0->s.dsp.h264_v_loop_filter_chroma(VAR_1, VAR_2, VAR_7, VAR_8, tc);
} else {
VAR_0->s.dsp.h264_v_loop_filter_chroma_intra(VAR_1, VAR_2, VAR_7, VAR_8);
}
}
| [
"static void FUNC_0( H264Context *VAR_0, uint8_t *VAR_1, int VAR_2, int16_t VAR_3[4], int VAR_4 ) {",
"int VAR_5;",
"const int VAR_6 = VAR_4 + VAR_0->slice_alpha_c0_offset;",
"const int VAR_7 = (alpha_table+52)[VAR_6];",
"const int VAR_8 = (beta_table+52)[VAR_4 + VAR_0->slice_beta_offset];",
"if( VAR_3[0] < 4 ) {",
"int8_t tc[4];",
"for(VAR_5=0; VAR_5<4; VAR_5++)",
"tc[VAR_5] = VAR_3[VAR_5] ? (tc0_table+52)[VAR_6][VAR_3[VAR_5] - 1] + 1 : 0;",
"VAR_0->s.dsp.h264_v_loop_filter_chroma(VAR_1, VAR_2, VAR_7, VAR_8, tc);",
"} else {",
"VAR_0->s.dsp.h264_v_loop_filter_chroma_intra(VAR_1, VAR_2, VAR_7, VAR_8);",
"}",
"}"
] | [
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
]
] |
20,546 | static int vmdk_open_vmdk4(BlockDriverState *bs,
BlockDriverState *file,
int flags, Error **errp)
{
int ret;
uint32_t magic;
uint32_t l1_size, l1_entry_sectors;
VMDK4Header header;
VmdkExtent *extent;
BDRVVmdkState *s = bs->opaque;
int64_t l1_backup_offset = 0;
ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
if (ret < 0) {
error_setg_errno(errp, -ret,
"Could not read header from file '%s'",
file->filename);
return -EINVAL;
}
if (header.capacity == 0) {
uint64_t desc_offset = le64_to_cpu(header.desc_offset);
if (desc_offset) {
char *buf = vmdk_read_desc(file, desc_offset << 9, errp);
if (!buf) {
return -EINVAL;
}
ret = vmdk_open_desc_file(bs, flags, buf, errp);
g_free(buf);
return ret;
}
}
if (!s->create_type) {
s->create_type = g_strdup("monolithicSparse");
}
if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) {
/*
* The footer takes precedence over the header, so read it in. The
* footer starts at offset -1024 from the end: One sector for the
* footer, and another one for the end-of-stream marker.
*/
struct {
struct {
uint64_t val;
uint32_t size;
uint32_t type;
uint8_t pad[512 - 16];
} QEMU_PACKED footer_marker;
uint32_t magic;
VMDK4Header header;
uint8_t pad[512 - 4 - sizeof(VMDK4Header)];
struct {
uint64_t val;
uint32_t size;
uint32_t type;
uint8_t pad[512 - 16];
} QEMU_PACKED eos_marker;
} QEMU_PACKED footer;
ret = bdrv_pread(file,
bs->file->total_sectors * 512 - 1536,
&footer, sizeof(footer));
if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to read footer");
return ret;
}
/* Some sanity checks for the footer */
if (be32_to_cpu(footer.magic) != VMDK4_MAGIC ||
le32_to_cpu(footer.footer_marker.size) != 0 ||
le32_to_cpu(footer.footer_marker.type) != MARKER_FOOTER ||
le64_to_cpu(footer.eos_marker.val) != 0 ||
le32_to_cpu(footer.eos_marker.size) != 0 ||
le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM)
{
error_setg(errp, "Invalid footer");
return -EINVAL;
}
header = footer.header;
}
if (le32_to_cpu(header.version) > 3) {
char buf[64];
snprintf(buf, sizeof(buf), "VMDK version %" PRId32,
le32_to_cpu(header.version));
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bdrv_get_device_or_node_name(bs), "vmdk", buf);
return -ENOTSUP;
} else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) {
/* VMware KB 2064959 explains that version 3 added support for
* persistent changed block tracking (CBT), and backup software can
* read it as version=1 if it doesn't care about the changed area
* information. So we are safe to enable read only. */
error_setg(errp, "VMDK version 3 must be read only");
return -EINVAL;
}
if (le32_to_cpu(header.num_gtes_per_gt) > 512) {
error_setg(errp, "L2 table size too big");
return -EINVAL;
}
l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt)
* le64_to_cpu(header.granularity);
if (l1_entry_sectors == 0) {
error_setg(errp, "L1 entry size is invalid");
return -EINVAL;
}
l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
/ l1_entry_sectors;
if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) {
l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
}
if (bdrv_nb_sectors(file) < le64_to_cpu(header.grain_offset)) {
error_setg(errp, "File truncated, expecting at least %" PRId64 " bytes",
(int64_t)(le64_to_cpu(header.grain_offset)
* BDRV_SECTOR_SIZE));
return -EINVAL;
}
ret = vmdk_add_extent(bs, file, false,
le64_to_cpu(header.capacity),
le64_to_cpu(header.gd_offset) << 9,
l1_backup_offset,
l1_size,
le32_to_cpu(header.num_gtes_per_gt),
le64_to_cpu(header.granularity),
&extent,
errp);
if (ret < 0) {
return ret;
}
extent->compressed =
le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
if (extent->compressed) {
g_free(s->create_type);
s->create_type = g_strdup("streamOptimized");
}
extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
extent->version = le32_to_cpu(header.version);
extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN;
ret = vmdk_init_tables(bs, extent, errp);
if (ret) {
/* free extent allocated by vmdk_add_extent */
vmdk_free_last_extent(bs);
}
return ret;
}
| false | qemu | a646836784a0fc50fee6f9a0d3fb968289714128 | static int vmdk_open_vmdk4(BlockDriverState *bs,
BlockDriverState *file,
int flags, Error **errp)
{
int ret;
uint32_t magic;
uint32_t l1_size, l1_entry_sectors;
VMDK4Header header;
VmdkExtent *extent;
BDRVVmdkState *s = bs->opaque;
int64_t l1_backup_offset = 0;
ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
if (ret < 0) {
error_setg_errno(errp, -ret,
"Could not read header from file '%s'",
file->filename);
return -EINVAL;
}
if (header.capacity == 0) {
uint64_t desc_offset = le64_to_cpu(header.desc_offset);
if (desc_offset) {
char *buf = vmdk_read_desc(file, desc_offset << 9, errp);
if (!buf) {
return -EINVAL;
}
ret = vmdk_open_desc_file(bs, flags, buf, errp);
g_free(buf);
return ret;
}
}
if (!s->create_type) {
s->create_type = g_strdup("monolithicSparse");
}
if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) {
struct {
struct {
uint64_t val;
uint32_t size;
uint32_t type;
uint8_t pad[512 - 16];
} QEMU_PACKED footer_marker;
uint32_t magic;
VMDK4Header header;
uint8_t pad[512 - 4 - sizeof(VMDK4Header)];
struct {
uint64_t val;
uint32_t size;
uint32_t type;
uint8_t pad[512 - 16];
} QEMU_PACKED eos_marker;
} QEMU_PACKED footer;
ret = bdrv_pread(file,
bs->file->total_sectors * 512 - 1536,
&footer, sizeof(footer));
if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to read footer");
return ret;
}
if (be32_to_cpu(footer.magic) != VMDK4_MAGIC ||
le32_to_cpu(footer.footer_marker.size) != 0 ||
le32_to_cpu(footer.footer_marker.type) != MARKER_FOOTER ||
le64_to_cpu(footer.eos_marker.val) != 0 ||
le32_to_cpu(footer.eos_marker.size) != 0 ||
le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM)
{
error_setg(errp, "Invalid footer");
return -EINVAL;
}
header = footer.header;
}
if (le32_to_cpu(header.version) > 3) {
char buf[64];
snprintf(buf, sizeof(buf), "VMDK version %" PRId32,
le32_to_cpu(header.version));
error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bdrv_get_device_or_node_name(bs), "vmdk", buf);
return -ENOTSUP;
} else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) {
error_setg(errp, "VMDK version 3 must be read only");
return -EINVAL;
}
if (le32_to_cpu(header.num_gtes_per_gt) > 512) {
error_setg(errp, "L2 table size too big");
return -EINVAL;
}
l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt)
* le64_to_cpu(header.granularity);
if (l1_entry_sectors == 0) {
error_setg(errp, "L1 entry size is invalid");
return -EINVAL;
}
l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
/ l1_entry_sectors;
if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) {
l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
}
if (bdrv_nb_sectors(file) < le64_to_cpu(header.grain_offset)) {
error_setg(errp, "File truncated, expecting at least %" PRId64 " bytes",
(int64_t)(le64_to_cpu(header.grain_offset)
* BDRV_SECTOR_SIZE));
return -EINVAL;
}
ret = vmdk_add_extent(bs, file, false,
le64_to_cpu(header.capacity),
le64_to_cpu(header.gd_offset) << 9,
l1_backup_offset,
l1_size,
le32_to_cpu(header.num_gtes_per_gt),
le64_to_cpu(header.granularity),
&extent,
errp);
if (ret < 0) {
return ret;
}
extent->compressed =
le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
if (extent->compressed) {
g_free(s->create_type);
s->create_type = g_strdup("streamOptimized");
}
extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
extent->version = le32_to_cpu(header.version);
extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN;
ret = vmdk_init_tables(bs, extent, errp);
if (ret) {
vmdk_free_last_extent(bs);
}
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(BlockDriverState *VAR_0,
BlockDriverState *VAR_1,
int VAR_2, Error **VAR_3)
{
int VAR_4;
uint32_t magic;
uint32_t l1_size, l1_entry_sectors;
VMDK4Header header;
VmdkExtent *extent;
BDRVVmdkState *s = VAR_0->opaque;
int64_t l1_backup_offset = 0;
VAR_4 = bdrv_pread(VAR_1, sizeof(magic), &header, sizeof(header));
if (VAR_4 < 0) {
error_setg_errno(VAR_3, -VAR_4,
"Could not read header from VAR_1 '%s'",
VAR_1->filename);
return -EINVAL;
}
if (header.capacity == 0) {
uint64_t desc_offset = le64_to_cpu(header.desc_offset);
if (desc_offset) {
char *VAR_7 = vmdk_read_desc(VAR_1, desc_offset << 9, VAR_3);
if (!VAR_7) {
return -EINVAL;
}
VAR_4 = vmdk_open_desc_file(VAR_0, VAR_2, VAR_7, VAR_3);
g_free(VAR_7);
return VAR_4;
}
}
if (!s->create_type) {
s->create_type = g_strdup("monolithicSparse");
}
if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) {
struct {
struct {
uint64_t val;
uint32_t size;
uint32_t type;
uint8_t pad[512 - 16];
} QEMU_PACKED footer_marker;
uint32_t magic;
VMDK4Header header;
uint8_t pad[512 - 4 - sizeof(VMDK4Header)];
struct {
uint64_t val;
uint32_t size;
uint32_t type;
uint8_t pad[512 - 16];
} QEMU_PACKED eos_marker;
} QEMU_PACKED VAR_6;
VAR_4 = bdrv_pread(VAR_1,
VAR_0->VAR_1->total_sectors * 512 - 1536,
&VAR_6, sizeof(VAR_6));
if (VAR_4 < 0) {
error_setg_errno(VAR_3, -VAR_4, "Failed to read VAR_6");
return VAR_4;
}
if (be32_to_cpu(VAR_6.magic) != VMDK4_MAGIC ||
le32_to_cpu(VAR_6.footer_marker.size) != 0 ||
le32_to_cpu(VAR_6.footer_marker.type) != MARKER_FOOTER ||
le64_to_cpu(VAR_6.eos_marker.val) != 0 ||
le32_to_cpu(VAR_6.eos_marker.size) != 0 ||
le32_to_cpu(VAR_6.eos_marker.type) != MARKER_END_OF_STREAM)
{
error_setg(VAR_3, "Invalid VAR_6");
return -EINVAL;
}
header = VAR_6.header;
}
if (le32_to_cpu(header.version) > 3) {
char VAR_7[64];
snprintf(VAR_7, sizeof(VAR_7), "VMDK version %" PRId32,
le32_to_cpu(header.version));
error_set(VAR_3, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
bdrv_get_device_or_node_name(VAR_0), "vmdk", VAR_7);
return -ENOTSUP;
} else if (le32_to_cpu(header.version) == 3 && (VAR_2 & BDRV_O_RDWR)) {
error_setg(VAR_3, "VMDK version 3 must be read only");
return -EINVAL;
}
if (le32_to_cpu(header.num_gtes_per_gt) > 512) {
error_setg(VAR_3, "L2 table size too big");
return -EINVAL;
}
l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt)
* le64_to_cpu(header.granularity);
if (l1_entry_sectors == 0) {
error_setg(VAR_3, "L1 entry size is invalid");
return -EINVAL;
}
l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
/ l1_entry_sectors;
if (le32_to_cpu(header.VAR_2) & VMDK4_FLAG_RGD) {
l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
}
if (bdrv_nb_sectors(VAR_1) < le64_to_cpu(header.grain_offset)) {
error_setg(VAR_3, "File truncated, expecting at least %" PRId64 " bytes",
(int64_t)(le64_to_cpu(header.grain_offset)
* BDRV_SECTOR_SIZE));
return -EINVAL;
}
VAR_4 = vmdk_add_extent(VAR_0, VAR_1, false,
le64_to_cpu(header.capacity),
le64_to_cpu(header.gd_offset) << 9,
l1_backup_offset,
l1_size,
le32_to_cpu(header.num_gtes_per_gt),
le64_to_cpu(header.granularity),
&extent,
VAR_3);
if (VAR_4 < 0) {
return VAR_4;
}
extent->compressed =
le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
if (extent->compressed) {
g_free(s->create_type);
s->create_type = g_strdup("streamOptimized");
}
extent->has_marker = le32_to_cpu(header.VAR_2) & VMDK4_FLAG_MARKER;
extent->version = le32_to_cpu(header.version);
extent->has_zero_grain = le32_to_cpu(header.VAR_2) & VMDK4_FLAG_ZERO_GRAIN;
VAR_4 = vmdk_init_tables(VAR_0, extent, VAR_3);
if (VAR_4) {
vmdk_free_last_extent(VAR_0);
}
return VAR_4;
}
| [
"static int FUNC_0(BlockDriverState *VAR_0,\nBlockDriverState *VAR_1,\nint VAR_2, Error **VAR_3)\n{",
"int VAR_4;",
"uint32_t magic;",
"uint32_t l1_size, l1_entry_sectors;",
"VMDK4Header header;",
"VmdkExtent *extent;",
"BDRVVmdkState *s = VAR_0->opaque;",
"int64_t l1_backup_offset = 0;",
"VAR_4 = bdrv_pread(VAR_1, sizeof(magic), &header, sizeof(header));",
"if (VAR_4 < 0) {",
"error_setg_errno(VAR_3, -VAR_4,\n\"Could not read header from VAR_1 '%s'\",\nVAR_1->filename);",
"return -EINVAL;",
"}",
"if (header.capacity == 0) {",
"uint64_t desc_offset = le64_to_cpu(header.desc_offset);",
"if (desc_offset) {",
"char *VAR_7 = vmdk_read_desc(VAR_1, desc_offset << 9, VAR_3);",
"if (!VAR_7) {",
"return -EINVAL;",
"}",
"VAR_4 = vmdk_open_desc_file(VAR_0, VAR_2, VAR_7, VAR_3);",
"g_free(VAR_7);",
"return VAR_4;",
"}",
"}",
"if (!s->create_type) {",
"s->create_type = g_strdup(\"monolithicSparse\");",
"}",
"if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) {",
"struct {",
"struct {",
"uint64_t val;",
"uint32_t size;",
"uint32_t type;",
"uint8_t pad[512 - 16];",
"} QEMU_PACKED footer_marker;",
"uint32_t magic;",
"VMDK4Header header;",
"uint8_t pad[512 - 4 - sizeof(VMDK4Header)];",
"struct {",
"uint64_t val;",
"uint32_t size;",
"uint32_t type;",
"uint8_t pad[512 - 16];",
"} QEMU_PACKED eos_marker;",
"} QEMU_PACKED VAR_6;",
"VAR_4 = bdrv_pread(VAR_1,\nVAR_0->VAR_1->total_sectors * 512 - 1536,\n&VAR_6, sizeof(VAR_6));",
"if (VAR_4 < 0) {",
"error_setg_errno(VAR_3, -VAR_4, \"Failed to read VAR_6\");",
"return VAR_4;",
"}",
"if (be32_to_cpu(VAR_6.magic) != VMDK4_MAGIC ||\nle32_to_cpu(VAR_6.footer_marker.size) != 0 ||\nle32_to_cpu(VAR_6.footer_marker.type) != MARKER_FOOTER ||\nle64_to_cpu(VAR_6.eos_marker.val) != 0 ||\nle32_to_cpu(VAR_6.eos_marker.size) != 0 ||\nle32_to_cpu(VAR_6.eos_marker.type) != MARKER_END_OF_STREAM)\n{",
"error_setg(VAR_3, \"Invalid VAR_6\");",
"return -EINVAL;",
"}",
"header = VAR_6.header;",
"}",
"if (le32_to_cpu(header.version) > 3) {",
"char VAR_7[64];",
"snprintf(VAR_7, sizeof(VAR_7), \"VMDK version %\" PRId32,\nle32_to_cpu(header.version));",
"error_set(VAR_3, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,\nbdrv_get_device_or_node_name(VAR_0), \"vmdk\", VAR_7);",
"return -ENOTSUP;",
"} else if (le32_to_cpu(header.version) == 3 && (VAR_2 & BDRV_O_RDWR)) {",
"error_setg(VAR_3, \"VMDK version 3 must be read only\");",
"return -EINVAL;",
"}",
"if (le32_to_cpu(header.num_gtes_per_gt) > 512) {",
"error_setg(VAR_3, \"L2 table size too big\");",
"return -EINVAL;",
"}",
"l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt)\n* le64_to_cpu(header.granularity);",
"if (l1_entry_sectors == 0) {",
"error_setg(VAR_3, \"L1 entry size is invalid\");",
"return -EINVAL;",
"}",
"l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)\n/ l1_entry_sectors;",
"if (le32_to_cpu(header.VAR_2) & VMDK4_FLAG_RGD) {",
"l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;",
"}",
"if (bdrv_nb_sectors(VAR_1) < le64_to_cpu(header.grain_offset)) {",
"error_setg(VAR_3, \"File truncated, expecting at least %\" PRId64 \" bytes\",\n(int64_t)(le64_to_cpu(header.grain_offset)\n* BDRV_SECTOR_SIZE));",
"return -EINVAL;",
"}",
"VAR_4 = vmdk_add_extent(VAR_0, VAR_1, false,\nle64_to_cpu(header.capacity),\nle64_to_cpu(header.gd_offset) << 9,\nl1_backup_offset,\nl1_size,\nle32_to_cpu(header.num_gtes_per_gt),\nle64_to_cpu(header.granularity),\n&extent,\nVAR_3);",
"if (VAR_4 < 0) {",
"return VAR_4;",
"}",
"extent->compressed =\nle16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;",
"if (extent->compressed) {",
"g_free(s->create_type);",
"s->create_type = g_strdup(\"streamOptimized\");",
"}",
"extent->has_marker = le32_to_cpu(header.VAR_2) & VMDK4_FLAG_MARKER;",
"extent->version = le32_to_cpu(header.version);",
"extent->has_zero_grain = le32_to_cpu(header.VAR_2) & VMDK4_FLAG_ZERO_GRAIN;",
"VAR_4 = vmdk_init_tables(VAR_0, extent, VAR_3);",
"if (VAR_4) {",
"vmdk_free_last_extent(VAR_0);",
"}",
"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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29,
31,
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
73
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125,
127,
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
143,
145,
147,
149,
151,
153,
155
],
[
157
],
[
159
],
[
161
],
[
165
],
[
167
],
[
171
],
[
173
],
[
175,
177
],
[
179,
181
],
[
183
],
[
185
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
],
[
207
],
[
209
],
[
213,
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225,
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237,
239,
241
],
[
243
],
[
245
],
[
249,
251,
253,
255,
257,
259,
261,
263,
265
],
[
267
],
[
269
],
[
271
],
[
273,
275
],
[
277
],
[
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
297
],
[
299
],
[
301
],
[
303
]
] |
20,547 | dma_write(void *opaque, target_phys_addr_t addr,
uint64_t val64, unsigned int size)
{
struct fs_dma_ctrl *ctrl = opaque;
uint32_t value = val64;
int c;
if (size != 4) {
dma_winvalid(opaque, addr, value);
}
/* Make addr relative to this channel and bounded to nr regs. */
c = fs_channel(addr);
addr &= 0xff;
addr >>= 2;
switch (addr)
{
case RW_DATA:
ctrl->channels[c].regs[addr] = value;
break;
case RW_CFG:
ctrl->channels[c].regs[addr] = value;
dma_update_state(ctrl, c);
break;
case RW_CMD:
/* continue. */
if (value & ~1)
printf("Invalid store to ch=%d RW_CMD %x\n",
c, value);
ctrl->channels[c].regs[addr] = value;
channel_continue(ctrl, c);
break;
case RW_SAVED_DATA:
case RW_SAVED_DATA_BUF:
case RW_GROUP:
case RW_GROUP_DOWN:
ctrl->channels[c].regs[addr] = value;
break;
case RW_ACK_INTR:
case RW_INTR_MASK:
ctrl->channels[c].regs[addr] = value;
channel_update_irq(ctrl, c);
if (addr == RW_ACK_INTR)
ctrl->channels[c].regs[RW_ACK_INTR] = 0;
break;
case RW_STREAM_CMD:
if (value & ~1023)
printf("Invalid store to ch=%d "
"RW_STREAMCMD %x\n",
c, value);
ctrl->channels[c].regs[addr] = value;
D(printf("stream_cmd ch=%d\n", c));
channel_stream_cmd(ctrl, c, value);
break;
default:
D(printf ("%s c=%d " TARGET_FMT_plx "\n",
__func__, c, addr));
break;
}
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | dma_write(void *opaque, target_phys_addr_t addr,
uint64_t val64, unsigned int size)
{
struct fs_dma_ctrl *ctrl = opaque;
uint32_t value = val64;
int c;
if (size != 4) {
dma_winvalid(opaque, addr, value);
}
c = fs_channel(addr);
addr &= 0xff;
addr >>= 2;
switch (addr)
{
case RW_DATA:
ctrl->channels[c].regs[addr] = value;
break;
case RW_CFG:
ctrl->channels[c].regs[addr] = value;
dma_update_state(ctrl, c);
break;
case RW_CMD:
if (value & ~1)
printf("Invalid store to ch=%d RW_CMD %x\n",
c, value);
ctrl->channels[c].regs[addr] = value;
channel_continue(ctrl, c);
break;
case RW_SAVED_DATA:
case RW_SAVED_DATA_BUF:
case RW_GROUP:
case RW_GROUP_DOWN:
ctrl->channels[c].regs[addr] = value;
break;
case RW_ACK_INTR:
case RW_INTR_MASK:
ctrl->channels[c].regs[addr] = value;
channel_update_irq(ctrl, c);
if (addr == RW_ACK_INTR)
ctrl->channels[c].regs[RW_ACK_INTR] = 0;
break;
case RW_STREAM_CMD:
if (value & ~1023)
printf("Invalid store to ch=%d "
"RW_STREAMCMD %x\n",
c, value);
ctrl->channels[c].regs[addr] = value;
D(printf("stream_cmd ch=%d\n", c));
channel_stream_cmd(ctrl, c, value);
break;
default:
D(printf ("%s c=%d " TARGET_FMT_plx "\n",
__func__, c, addr));
break;
}
}
| {
"code": [],
"line_no": []
} | FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned int VAR_3)
{
struct fs_dma_ctrl *VAR_4 = VAR_0;
uint32_t value = VAR_2;
int VAR_5;
if (VAR_3 != 4) {
dma_winvalid(VAR_0, VAR_1, value);
}
VAR_5 = fs_channel(VAR_1);
VAR_1 &= 0xff;
VAR_1 >>= 2;
switch (VAR_1)
{
case RW_DATA:
VAR_4->channels[VAR_5].regs[VAR_1] = value;
break;
case RW_CFG:
VAR_4->channels[VAR_5].regs[VAR_1] = value;
dma_update_state(VAR_4, VAR_5);
break;
case RW_CMD:
if (value & ~1)
printf("Invalid store to ch=%d RW_CMD %x\n",
VAR_5, value);
VAR_4->channels[VAR_5].regs[VAR_1] = value;
channel_continue(VAR_4, VAR_5);
break;
case RW_SAVED_DATA:
case RW_SAVED_DATA_BUF:
case RW_GROUP:
case RW_GROUP_DOWN:
VAR_4->channels[VAR_5].regs[VAR_1] = value;
break;
case RW_ACK_INTR:
case RW_INTR_MASK:
VAR_4->channels[VAR_5].regs[VAR_1] = value;
channel_update_irq(VAR_4, VAR_5);
if (VAR_1 == RW_ACK_INTR)
VAR_4->channels[VAR_5].regs[RW_ACK_INTR] = 0;
break;
case RW_STREAM_CMD:
if (value & ~1023)
printf("Invalid store to ch=%d "
"RW_STREAMCMD %x\n",
VAR_5, value);
VAR_4->channels[VAR_5].regs[VAR_1] = value;
D(printf("stream_cmd ch=%d\n", VAR_5));
channel_stream_cmd(VAR_4, VAR_5, value);
break;
default:
D(printf ("%s VAR_5=%d " TARGET_FMT_plx "\n",
__func__, VAR_5, VAR_1));
break;
}
}
| [
"FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned int VAR_3)\n{",
"struct fs_dma_ctrl *VAR_4 = VAR_0;",
"uint32_t value = VAR_2;",
"int VAR_5;",
"if (VAR_3 != 4) {",
"dma_winvalid(VAR_0, VAR_1, value);",
"}",
"VAR_5 = fs_channel(VAR_1);",
"VAR_1 &= 0xff;",
"VAR_1 >>= 2;",
"switch (VAR_1)\n{",
"case RW_DATA:\nVAR_4->channels[VAR_5].regs[VAR_1] = value;",
"break;",
"case RW_CFG:\nVAR_4->channels[VAR_5].regs[VAR_1] = value;",
"dma_update_state(VAR_4, VAR_5);",
"break;",
"case RW_CMD:\nif (value & ~1)\nprintf(\"Invalid store to ch=%d RW_CMD %x\\n\",\nVAR_5, value);",
"VAR_4->channels[VAR_5].regs[VAR_1] = value;",
"channel_continue(VAR_4, VAR_5);",
"break;",
"case RW_SAVED_DATA:\ncase RW_SAVED_DATA_BUF:\ncase RW_GROUP:\ncase RW_GROUP_DOWN:\nVAR_4->channels[VAR_5].regs[VAR_1] = value;",
"break;",
"case RW_ACK_INTR:\ncase RW_INTR_MASK:\nVAR_4->channels[VAR_5].regs[VAR_1] = value;",
"channel_update_irq(VAR_4, VAR_5);",
"if (VAR_1 == RW_ACK_INTR)\nVAR_4->channels[VAR_5].regs[RW_ACK_INTR] = 0;",
"break;",
"case RW_STREAM_CMD:\nif (value & ~1023)\nprintf(\"Invalid store to ch=%d \"\n\"RW_STREAMCMD %x\\n\",\nVAR_5, value);",
"VAR_4->channels[VAR_5].regs[VAR_1] = value;",
"D(printf(\"stream_cmd ch=%d\\n\", VAR_5));",
"channel_stream_cmd(VAR_4, VAR_5, value);",
"break;",
"default:\nD(printf (\"%s VAR_5=%d \" TARGET_FMT_plx \"\\n\",\n__func__, VAR_5, VAR_1));",
"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,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31,
33
],
[
35,
37
],
[
39
],
[
43,
45
],
[
47
],
[
49
],
[
51,
55,
57,
59
],
[
61
],
[
63
],
[
65
],
[
69,
71,
73,
75,
77
],
[
79
],
[
83,
85,
87
],
[
89
],
[
91,
93
],
[
95
],
[
99,
101,
103,
105,
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119,
121,
123
],
[
125
],
[
127
],
[
129
]
] |
20,551 | static int scsi_generic_initfn(SCSIDevice *dev)
{
SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, dev);
int sg_version;
struct sg_scsi_id scsiid;
if (!s->qdev.conf.dinfo || !s->qdev.conf.dinfo->bdrv) {
error_report("scsi-generic: drive property not set");
return -1;
}
s->bs = s->qdev.conf.dinfo->bdrv;
/* check we are really using a /dev/sg* file */
if (!bdrv_is_sg(s->bs)) {
error_report("scsi-generic: not /dev/sg*");
return -1;
}
/* check we are using a driver managing SG_IO (version 3 and after */
if (bdrv_ioctl(s->bs, SG_GET_VERSION_NUM, &sg_version) < 0 ||
sg_version < 30000) {
error_report("scsi-generic: scsi generic interface too old");
return -1;
}
/* get LUN of the /dev/sg? */
if (bdrv_ioctl(s->bs, SG_GET_SCSI_ID, &scsiid)) {
error_report("scsi-generic: SG_GET_SCSI_ID ioctl failed");
return -1;
}
/* define device state */
s->lun = scsiid.lun;
DPRINTF("LUN %d\n", s->lun);
s->qdev.type = scsiid.scsi_type;
DPRINTF("device type %d\n", s->qdev.type);
if (s->qdev.type == TYPE_TAPE) {
s->qdev.blocksize = get_stream_blocksize(s->bs);
if (s->qdev.blocksize == -1)
s->qdev.blocksize = 0;
} else {
s->qdev.blocksize = get_blocksize(s->bs);
/* removable media returns 0 if not present */
if (s->qdev.blocksize <= 0) {
if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM)
s->qdev.blocksize = 2048;
else
s->qdev.blocksize = 512;
}
}
DPRINTF("block size %d\n", s->qdev.blocksize);
s->driver_status = 0;
memset(s->sensebuf, 0, sizeof(s->sensebuf));
return 0;
}
| false | qemu | f8b6cc0070aab8b75bd082582c829be1353f395f | static int scsi_generic_initfn(SCSIDevice *dev)
{
SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, dev);
int sg_version;
struct sg_scsi_id scsiid;
if (!s->qdev.conf.dinfo || !s->qdev.conf.dinfo->bdrv) {
error_report("scsi-generic: drive property not set");
return -1;
}
s->bs = s->qdev.conf.dinfo->bdrv;
if (!bdrv_is_sg(s->bs)) {
error_report("scsi-generic: not /dev/sg*");
return -1;
}
if (bdrv_ioctl(s->bs, SG_GET_VERSION_NUM, &sg_version) < 0 ||
sg_version < 30000) {
error_report("scsi-generic: scsi generic interface too old");
return -1;
}
if (bdrv_ioctl(s->bs, SG_GET_SCSI_ID, &scsiid)) {
error_report("scsi-generic: SG_GET_SCSI_ID ioctl failed");
return -1;
}
s->lun = scsiid.lun;
DPRINTF("LUN %d\n", s->lun);
s->qdev.type = scsiid.scsi_type;
DPRINTF("device type %d\n", s->qdev.type);
if (s->qdev.type == TYPE_TAPE) {
s->qdev.blocksize = get_stream_blocksize(s->bs);
if (s->qdev.blocksize == -1)
s->qdev.blocksize = 0;
} else {
s->qdev.blocksize = get_blocksize(s->bs);
if (s->qdev.blocksize <= 0) {
if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM)
s->qdev.blocksize = 2048;
else
s->qdev.blocksize = 512;
}
}
DPRINTF("block size %d\n", s->qdev.blocksize);
s->driver_status = 0;
memset(s->sensebuf, 0, sizeof(s->sensebuf));
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(SCSIDevice *VAR_0)
{
SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, VAR_0);
int VAR_1;
struct sg_scsi_id VAR_2;
if (!s->qdev.conf.dinfo || !s->qdev.conf.dinfo->bdrv) {
error_report("scsi-generic: drive property not set");
return -1;
}
s->bs = s->qdev.conf.dinfo->bdrv;
if (!bdrv_is_sg(s->bs)) {
error_report("scsi-generic: not /VAR_0/sg*");
return -1;
}
if (bdrv_ioctl(s->bs, SG_GET_VERSION_NUM, &VAR_1) < 0 ||
VAR_1 < 30000) {
error_report("scsi-generic: scsi generic interface too old");
return -1;
}
if (bdrv_ioctl(s->bs, SG_GET_SCSI_ID, &VAR_2)) {
error_report("scsi-generic: SG_GET_SCSI_ID ioctl failed");
return -1;
}
s->lun = VAR_2.lun;
DPRINTF("LUN %d\n", s->lun);
s->qdev.type = VAR_2.scsi_type;
DPRINTF("device type %d\n", s->qdev.type);
if (s->qdev.type == TYPE_TAPE) {
s->qdev.blocksize = get_stream_blocksize(s->bs);
if (s->qdev.blocksize == -1)
s->qdev.blocksize = 0;
} else {
s->qdev.blocksize = get_blocksize(s->bs);
if (s->qdev.blocksize <= 0) {
if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM)
s->qdev.blocksize = 2048;
else
s->qdev.blocksize = 512;
}
}
DPRINTF("block size %d\n", s->qdev.blocksize);
s->driver_status = 0;
memset(s->sensebuf, 0, sizeof(s->sensebuf));
return 0;
}
| [
"static int FUNC_0(SCSIDevice *VAR_0)\n{",
"SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, VAR_0);",
"int VAR_1;",
"struct sg_scsi_id VAR_2;",
"if (!s->qdev.conf.dinfo || !s->qdev.conf.dinfo->bdrv) {",
"error_report(\"scsi-generic: drive property not set\");",
"return -1;",
"}",
"s->bs = s->qdev.conf.dinfo->bdrv;",
"if (!bdrv_is_sg(s->bs)) {",
"error_report(\"scsi-generic: not /VAR_0/sg*\");",
"return -1;",
"}",
"if (bdrv_ioctl(s->bs, SG_GET_VERSION_NUM, &VAR_1) < 0 ||\nVAR_1 < 30000) {",
"error_report(\"scsi-generic: scsi generic interface too old\");",
"return -1;",
"}",
"if (bdrv_ioctl(s->bs, SG_GET_SCSI_ID, &VAR_2)) {",
"error_report(\"scsi-generic: SG_GET_SCSI_ID ioctl failed\");",
"return -1;",
"}",
"s->lun = VAR_2.lun;",
"DPRINTF(\"LUN %d\\n\", s->lun);",
"s->qdev.type = VAR_2.scsi_type;",
"DPRINTF(\"device type %d\\n\", s->qdev.type);",
"if (s->qdev.type == TYPE_TAPE) {",
"s->qdev.blocksize = get_stream_blocksize(s->bs);",
"if (s->qdev.blocksize == -1)\ns->qdev.blocksize = 0;",
"} else {",
"s->qdev.blocksize = get_blocksize(s->bs);",
"if (s->qdev.blocksize <= 0) {",
"if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM)\ns->qdev.blocksize = 2048;",
"else\ns->qdev.blocksize = 512;",
"}",
"}",
"DPRINTF(\"block size %d\\n\", s->qdev.blocksize);",
"s->driver_status = 0;",
"memset(s->sensebuf, 0, sizeof(s->sensebuf));",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
27
],
[
29
],
[
31
],
[
33
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77,
79
],
[
81
],
[
83
],
[
87
],
[
89,
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
]
] |
20,552 | void memory_region_add_subregion_overlap(MemoryRegion *mr,
hwaddr offset,
MemoryRegion *subregion,
unsigned priority)
{
subregion->may_overlap = true;
subregion->priority = priority;
memory_region_add_subregion_common(mr, offset, subregion);
}
| false | qemu | a1ff8ae0666ffcbe78ae7e28812dd30db6bb7131 | void memory_region_add_subregion_overlap(MemoryRegion *mr,
hwaddr offset,
MemoryRegion *subregion,
unsigned priority)
{
subregion->may_overlap = true;
subregion->priority = priority;
memory_region_add_subregion_common(mr, offset, subregion);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(MemoryRegion *VAR_0,
hwaddr VAR_1,
MemoryRegion *VAR_2,
unsigned VAR_3)
{
VAR_2->may_overlap = true;
VAR_2->VAR_3 = VAR_3;
memory_region_add_subregion_common(VAR_0, VAR_1, VAR_2);
}
| [
"void FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nMemoryRegion *VAR_2,\nunsigned VAR_3)\n{",
"VAR_2->may_overlap = true;",
"VAR_2->VAR_3 = VAR_3;",
"memory_region_add_subregion_common(VAR_0, VAR_1, VAR_2);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
20,554 | static int mpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
const uint8_t *buf, int buf_size)
{
Mpeg1Context *s = avctx->priv_data;
AVFrame *picture = data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
dprintf(avctx, "fill_buffer\n");
if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
/* special case for last picture */
if (s2->low_delay==0 && s2->next_picture_ptr) {
*picture= *(AVFrame*)s2->next_picture_ptr;
s2->next_picture_ptr= NULL;
*data_size = sizeof(AVFrame);
}
return buf_size;
}
if(s2->flags&CODEC_FLAG_TRUNCATED){
int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size);
if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
return buf_size;
}
#if 0
if (s->repeat_field % 2 == 1) {
s->repeat_field++;
//fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
// s2->picture_number, s->repeat_field);
if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
*data_size = sizeof(AVPicture);
goto the_end;
}
}
#endif
if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2"))
vcr2_init_sequence(avctx);
s->slice_count= 0;
if(avctx->extradata && !avctx->frame_number)
decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
return decode_chunks(avctx, picture, data_size, buf, buf_size);
}
| false | FFmpeg | a4c7a5ea27050a28625eabf1ba98cfef9ac6620d | static int mpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
const uint8_t *buf, int buf_size)
{
Mpeg1Context *s = avctx->priv_data;
AVFrame *picture = data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
dprintf(avctx, "fill_buffer\n");
if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
if (s2->low_delay==0 && s2->next_picture_ptr) {
*picture= *(AVFrame*)s2->next_picture_ptr;
s2->next_picture_ptr= NULL;
*data_size = sizeof(AVFrame);
}
return buf_size;
}
if(s2->flags&CODEC_FLAG_TRUNCATED){
int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size);
if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
return buf_size;
}
#if 0
if (s->repeat_field % 2 == 1) {
s->repeat_field++;
if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
*data_size = sizeof(AVPicture);
goto the_end;
}
}
#endif
if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == AV_RL32("VCR2"))
vcr2_init_sequence(avctx);
s->slice_count= 0;
if(avctx->extradata && !avctx->frame_number)
decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
return decode_chunks(avctx, picture, data_size, buf, buf_size);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
const uint8_t *VAR_3, int VAR_4)
{
Mpeg1Context *s = VAR_0->priv_data;
AVFrame *picture = VAR_1;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
dprintf(VAR_0, "fill_buffer\n");
if (VAR_4 == 0 || (VAR_4 == 4 && AV_RB32(VAR_3) == SEQ_END_CODE)) {
if (s2->low_delay==0 && s2->next_picture_ptr) {
*picture= *(AVFrame*)s2->next_picture_ptr;
s2->next_picture_ptr= NULL;
*VAR_2 = sizeof(AVFrame);
}
return VAR_4;
}
if(s2->flags&CODEC_FLAG_TRUNCATED){
int VAR_5= ff_mpeg1_find_frame_end(&s2->parse_context, VAR_3, VAR_4);
if( ff_combine_frame(&s2->parse_context, VAR_5, (const uint8_t **)&VAR_3, &VAR_4) < 0 )
return VAR_4;
}
#if 0
if (s->repeat_field % 2 == 1) {
s->repeat_field++;
if (VAR_0->flags & CODEC_FLAG_REPEAT_FIELD) {
*VAR_2 = sizeof(AVPicture);
goto the_end;
}
}
#endif
if(s->mpeg_enc_ctx_allocated==0 && VAR_0->codec_tag == AV_RL32("VCR2"))
vcr2_init_sequence(VAR_0);
s->slice_count= 0;
if(VAR_0->extradata && !VAR_0->frame_number)
decode_chunks(VAR_0, picture, VAR_2, VAR_0->extradata, VAR_0->extradata_size);
return decode_chunks(VAR_0, picture, VAR_2, VAR_3, VAR_4);
}
| [
"static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nconst uint8_t *VAR_3, int VAR_4)\n{",
"Mpeg1Context *s = VAR_0->priv_data;",
"AVFrame *picture = VAR_1;",
"MpegEncContext *s2 = &s->mpeg_enc_ctx;",
"dprintf(VAR_0, \"fill_buffer\\n\");",
"if (VAR_4 == 0 || (VAR_4 == 4 && AV_RB32(VAR_3) == SEQ_END_CODE)) {",
"if (s2->low_delay==0 && s2->next_picture_ptr) {",
"*picture= *(AVFrame*)s2->next_picture_ptr;",
"s2->next_picture_ptr= NULL;",
"*VAR_2 = sizeof(AVFrame);",
"}",
"return VAR_4;",
"}",
"if(s2->flags&CODEC_FLAG_TRUNCATED){",
"int VAR_5= ff_mpeg1_find_frame_end(&s2->parse_context, VAR_3, VAR_4);",
"if( ff_combine_frame(&s2->parse_context, VAR_5, (const uint8_t **)&VAR_3, &VAR_4) < 0 )\nreturn VAR_4;",
"}",
"#if 0\nif (s->repeat_field % 2 == 1) {",
"s->repeat_field++;",
"if (VAR_0->flags & CODEC_FLAG_REPEAT_FIELD) {",
"*VAR_2 = sizeof(AVPicture);",
"goto the_end;",
"}",
"}",
"#endif\nif(s->mpeg_enc_ctx_allocated==0 && VAR_0->codec_tag == AV_RL32(\"VCR2\"))\nvcr2_init_sequence(VAR_0);",
"s->slice_count= 0;",
"if(VAR_0->extradata && !VAR_0->frame_number)\ndecode_chunks(VAR_0, picture, VAR_2, VAR_0->extradata, VAR_0->extradata_size);",
"return decode_chunks(VAR_0, picture, VAR_2, VAR_3, 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
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
47,
49
],
[
51
],
[
55,
57
],
[
59
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75,
79,
81
],
[
85
],
[
89,
91
],
[
95
],
[
97
]
] |
20,555 | void bdrv_parent_drained_begin(BlockDriverState *bs)
{
BdrvChild *c;
QLIST_FOREACH(c, &bs->parents, next_parent) {
if (c->role->drained_begin) {
c->role->drained_begin(c);
}
}
}
| false | qemu | 02d213009d571bcd7171e3ff9234722a11d30d1b | void bdrv_parent_drained_begin(BlockDriverState *bs)
{
BdrvChild *c;
QLIST_FOREACH(c, &bs->parents, next_parent) {
if (c->role->drained_begin) {
c->role->drained_begin(c);
}
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(BlockDriverState *VAR_0)
{
BdrvChild *c;
QLIST_FOREACH(c, &VAR_0->parents, next_parent) {
if (c->role->drained_begin) {
c->role->drained_begin(c);
}
}
}
| [
"void FUNC_0(BlockDriverState *VAR_0)\n{",
"BdrvChild *c;",
"QLIST_FOREACH(c, &VAR_0->parents, next_parent) {",
"if (c->role->drained_begin) {",
"c->role->drained_begin(c);",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
20,556 | static int qemu_event_init(void)
{
int err;
int fds[2];
err = qemu_eventfd(fds);
if (err == -1) {
return -errno;
}
err = fcntl_setfl(fds[0], O_NONBLOCK);
if (err < 0) {
goto fail;
}
err = fcntl_setfl(fds[1], O_NONBLOCK);
if (err < 0) {
goto fail;
}
qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
(void *)(intptr_t)fds[0]);
io_thread_fd = fds[1];
return 0;
fail:
close(fds[0]);
close(fds[1]);
return err;
}
| false | qemu | d3b12f5dec4b27ebab58fb5797cb67bacced773b | static int qemu_event_init(void)
{
int err;
int fds[2];
err = qemu_eventfd(fds);
if (err == -1) {
return -errno;
}
err = fcntl_setfl(fds[0], O_NONBLOCK);
if (err < 0) {
goto fail;
}
err = fcntl_setfl(fds[1], O_NONBLOCK);
if (err < 0) {
goto fail;
}
qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
(void *)(intptr_t)fds[0]);
io_thread_fd = fds[1];
return 0;
fail:
close(fds[0]);
close(fds[1]);
return err;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(void)
{
int VAR_0;
int VAR_1[2];
VAR_0 = qemu_eventfd(VAR_1);
if (VAR_0 == -1) {
return -errno;
}
VAR_0 = fcntl_setfl(VAR_1[0], O_NONBLOCK);
if (VAR_0 < 0) {
goto fail;
}
VAR_0 = fcntl_setfl(VAR_1[1], O_NONBLOCK);
if (VAR_0 < 0) {
goto fail;
}
qemu_set_fd_handler2(VAR_1[0], NULL, qemu_event_read, NULL,
(void *)(intptr_t)VAR_1[0]);
io_thread_fd = VAR_1[1];
return 0;
fail:
close(VAR_1[0]);
close(VAR_1[1]);
return VAR_0;
}
| [
"static int FUNC_0(void)\n{",
"int VAR_0;",
"int VAR_1[2];",
"VAR_0 = qemu_eventfd(VAR_1);",
"if (VAR_0 == -1) {",
"return -errno;",
"}",
"VAR_0 = fcntl_setfl(VAR_1[0], O_NONBLOCK);",
"if (VAR_0 < 0) {",
"goto fail;",
"}",
"VAR_0 = fcntl_setfl(VAR_1[1], O_NONBLOCK);",
"if (VAR_0 < 0) {",
"goto fail;",
"}",
"qemu_set_fd_handler2(VAR_1[0], NULL, qemu_event_read, NULL,\n(void *)(intptr_t)VAR_1[0]);",
"io_thread_fd = VAR_1[1];",
"return 0;",
"fail:\nclose(VAR_1[0]);",
"close(VAR_1[1]);",
"return VAR_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
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35,
37
],
[
41
],
[
43
],
[
47,
49
],
[
51
],
[
53
],
[
55
]
] |
20,558 | static void machine_set_kernel_irqchip(Object *obj, bool value, Error **errp)
{
MachineState *ms = MACHINE(obj);
ms->kernel_irqchip = value;
}
| false | qemu | d8870d0217216478888c2d3dd6bf62e155d978c8 | static void machine_set_kernel_irqchip(Object *obj, bool value, Error **errp)
{
MachineState *ms = MACHINE(obj);
ms->kernel_irqchip = value;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Object *VAR_0, bool VAR_1, Error **VAR_2)
{
MachineState *ms = MACHINE(VAR_0);
ms->kernel_irqchip = VAR_1;
}
| [
"static void FUNC_0(Object *VAR_0, bool VAR_1, Error **VAR_2)\n{",
"MachineState *ms = MACHINE(VAR_0);",
"ms->kernel_irqchip = VAR_1;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
]
] |
20,559 | static char *pcibus_get_dev_path(DeviceState *dev)
{
PCIDevice *d = container_of(dev, PCIDevice, qdev);
PCIDevice *t;
int slot_depth;
/* Path format: Domain:00:Slot.Function:Slot.Function....:Slot.Function.
* 00 is added here to make this format compatible with
* domain:Bus:Slot.Func for systems without nested PCI bridges.
* Slot.Function list specifies the slot and function numbers for all
* devices on the path from root to the specific device. */
int domain_len = strlen("DDDD:00");
int slot_len = strlen(":SS.F");
int path_len;
char *path, *p;
/* Calculate # of slots on path between device and root. */;
slot_depth = 0;
for (t = d; t; t = t->bus->parent_dev) {
++slot_depth;
}
path_len = domain_len + slot_len * slot_depth;
/* Allocate memory, fill in the terminating null byte. */
path = malloc(path_len + 1 /* For '\0' */);
path[path_len] = '\0';
/* First field is the domain. */
snprintf(path, domain_len, "%04x:00", pci_find_domain(d->bus));
/* Fill in slot numbers. We walk up from device to root, so need to print
* them in the reverse order, last to first. */
p = path + path_len;
for (t = d; t; t = t->bus->parent_dev) {
p -= slot_len;
snprintf(p, slot_len, ":%02x.%x", PCI_SLOT(t->devfn), PCI_FUNC(d->devfn));
}
return path;
}
| false | qemu | 2991181aaa026d8b1444bfaa9c4bcd82065ba5a3 | static char *pcibus_get_dev_path(DeviceState *dev)
{
PCIDevice *d = container_of(dev, PCIDevice, qdev);
PCIDevice *t;
int slot_depth;
int domain_len = strlen("DDDD:00");
int slot_len = strlen(":SS.F");
int path_len;
char *path, *p;
;
slot_depth = 0;
for (t = d; t; t = t->bus->parent_dev) {
++slot_depth;
}
path_len = domain_len + slot_len * slot_depth;
path = malloc(path_len + 1 );
path[path_len] = '\0';
snprintf(path, domain_len, "%04x:00", pci_find_domain(d->bus));
p = path + path_len;
for (t = d; t; t = t->bus->parent_dev) {
p -= slot_len;
snprintf(p, slot_len, ":%02x.%x", PCI_SLOT(t->devfn), PCI_FUNC(d->devfn));
}
return path;
}
| {
"code": [],
"line_no": []
} | static char *FUNC_0(DeviceState *VAR_0)
{
PCIDevice *d = container_of(VAR_0, PCIDevice, qdev);
PCIDevice *t;
int VAR_1;
int VAR_2 = strlen("DDDD:00");
int VAR_3 = strlen(":SS.F");
int VAR_4;
char *VAR_5, *VAR_6;
;
VAR_1 = 0;
for (t = d; t; t = t->bus->parent_dev) {
++VAR_1;
}
VAR_4 = VAR_2 + VAR_3 * VAR_1;
VAR_5 = malloc(VAR_4 + 1 );
VAR_5[VAR_4] = '\0';
snprintf(VAR_5, VAR_2, "%04x:00", pci_find_domain(d->bus));
VAR_6 = VAR_5 + VAR_4;
for (t = d; t; t = t->bus->parent_dev) {
VAR_6 -= VAR_3;
snprintf(VAR_6, VAR_3, ":%02x.%x", PCI_SLOT(t->devfn), PCI_FUNC(d->devfn));
}
return VAR_5;
}
| [
"static char *FUNC_0(DeviceState *VAR_0)\n{",
"PCIDevice *d = container_of(VAR_0, PCIDevice, qdev);",
"PCIDevice *t;",
"int VAR_1;",
"int VAR_2 = strlen(\"DDDD:00\");",
"int VAR_3 = strlen(\":SS.F\");",
"int VAR_4;",
"char *VAR_5, *VAR_6;",
";",
"VAR_1 = 0;",
"for (t = d; t; t = t->bus->parent_dev) {",
"++VAR_1;",
"}",
"VAR_4 = VAR_2 + VAR_3 * VAR_1;",
"VAR_5 = malloc(VAR_4 + 1 );",
"VAR_5[VAR_4] = '\\0';",
"snprintf(VAR_5, VAR_2, \"%04x:00\", pci_find_domain(d->bus));",
"VAR_6 = VAR_5 + VAR_4;",
"for (t = d; t; t = t->bus->parent_dev) {",
"VAR_6 -= VAR_3;",
"snprintf(VAR_6, VAR_3, \":%02x.%x\", PCI_SLOT(t->devfn), PCI_FUNC(d->devfn));",
"}",
"return VAR_5;",
"}"
] | [
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
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
49
],
[
51
],
[
57
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
]
] |
20,560 | int virtio_scsi_read_many(VDev *vdev,
ulong sector, void *load_addr, int sec_num)
{
int sector_count;
int f = vdev->blk_factor;
unsigned int data_size;
do {
sector_count = MIN_NON_ZERO(sec_num, vdev->config.scsi.max_sectors);
data_size = sector_count * virtio_get_block_size() * f;
if (!scsi_read_10(vdev, sector * f, sector_count * f, load_addr,
data_size)) {
virtio_scsi_verify_response(&resp, "virtio-scsi:read_many");
}
load_addr += data_size;
sector += sector_count;
sec_num -= sector_count;
} while (sec_num > 0);
return 0;
}
| false | qemu | fe921fc8b7e92020bb140079a9f47f14fb8e9075 | int virtio_scsi_read_many(VDev *vdev,
ulong sector, void *load_addr, int sec_num)
{
int sector_count;
int f = vdev->blk_factor;
unsigned int data_size;
do {
sector_count = MIN_NON_ZERO(sec_num, vdev->config.scsi.max_sectors);
data_size = sector_count * virtio_get_block_size() * f;
if (!scsi_read_10(vdev, sector * f, sector_count * f, load_addr,
data_size)) {
virtio_scsi_verify_response(&resp, "virtio-scsi:read_many");
}
load_addr += data_size;
sector += sector_count;
sec_num -= sector_count;
} while (sec_num > 0);
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(VDev *VAR_0,
ulong VAR_1, void *VAR_2, int VAR_3)
{
int VAR_4;
int VAR_5 = VAR_0->blk_factor;
unsigned int VAR_6;
do {
VAR_4 = MIN_NON_ZERO(VAR_3, VAR_0->config.scsi.max_sectors);
VAR_6 = VAR_4 * virtio_get_block_size() * VAR_5;
if (!scsi_read_10(VAR_0, VAR_1 * VAR_5, VAR_4 * VAR_5, VAR_2,
VAR_6)) {
virtio_scsi_verify_response(&resp, "virtio-scsi:read_many");
}
VAR_2 += VAR_6;
VAR_1 += VAR_4;
VAR_3 -= VAR_4;
} while (VAR_3 > 0);
return 0;
}
| [
"int FUNC_0(VDev *VAR_0,\nulong VAR_1, void *VAR_2, int VAR_3)\n{",
"int VAR_4;",
"int VAR_5 = VAR_0->blk_factor;",
"unsigned int VAR_6;",
"do {",
"VAR_4 = MIN_NON_ZERO(VAR_3, VAR_0->config.scsi.max_sectors);",
"VAR_6 = VAR_4 * virtio_get_block_size() * VAR_5;",
"if (!scsi_read_10(VAR_0, VAR_1 * VAR_5, VAR_4 * VAR_5, VAR_2,\nVAR_6)) {",
"virtio_scsi_verify_response(&resp, \"virtio-scsi:read_many\");",
"}",
"VAR_2 += VAR_6;",
"VAR_1 += VAR_4;",
"VAR_3 -= VAR_4;",
"} while (VAR_3 > 0);",
"return 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
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
]
] |
20,561 | static int nbd_negotiate_send_rep_len(QIOChannel *ioc, uint32_t type,
uint32_t opt, uint32_t len, Error **errp)
{
uint64_t magic;
trace_nbd_negotiate_send_rep_len(opt, type, len);
magic = cpu_to_be64(NBD_REP_MAGIC);
if (nbd_write(ioc, &magic, sizeof(magic), errp) < 0) {
error_prepend(errp, "write failed (rep magic): ");
return -EINVAL;
}
opt = cpu_to_be32(opt);
if (nbd_write(ioc, &opt, sizeof(opt), errp) < 0) {
error_prepend(errp, "write failed (rep opt): ");
return -EINVAL;
}
type = cpu_to_be32(type);
if (nbd_write(ioc, &type, sizeof(type), errp) < 0) {
error_prepend(errp, "write failed (rep type): ");
return -EINVAL;
}
len = cpu_to_be32(len);
if (nbd_write(ioc, &len, sizeof(len), errp) < 0) {
error_prepend(errp, "write failed (rep data length): ");
return -EINVAL;
}
return 0;
}
| false | qemu | 3736cc5be31f0399999e37d8b28ca9a3ed0b4ccb | static int nbd_negotiate_send_rep_len(QIOChannel *ioc, uint32_t type,
uint32_t opt, uint32_t len, Error **errp)
{
uint64_t magic;
trace_nbd_negotiate_send_rep_len(opt, type, len);
magic = cpu_to_be64(NBD_REP_MAGIC);
if (nbd_write(ioc, &magic, sizeof(magic), errp) < 0) {
error_prepend(errp, "write failed (rep magic): ");
return -EINVAL;
}
opt = cpu_to_be32(opt);
if (nbd_write(ioc, &opt, sizeof(opt), errp) < 0) {
error_prepend(errp, "write failed (rep opt): ");
return -EINVAL;
}
type = cpu_to_be32(type);
if (nbd_write(ioc, &type, sizeof(type), errp) < 0) {
error_prepend(errp, "write failed (rep type): ");
return -EINVAL;
}
len = cpu_to_be32(len);
if (nbd_write(ioc, &len, sizeof(len), errp) < 0) {
error_prepend(errp, "write failed (rep data length): ");
return -EINVAL;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(QIOChannel *VAR_0, uint32_t VAR_1,
uint32_t VAR_2, uint32_t VAR_3, Error **VAR_4)
{
uint64_t magic;
trace_nbd_negotiate_send_rep_len(VAR_2, VAR_1, VAR_3);
magic = cpu_to_be64(NBD_REP_MAGIC);
if (nbd_write(VAR_0, &magic, sizeof(magic), VAR_4) < 0) {
error_prepend(VAR_4, "write failed (rep magic): ");
return -EINVAL;
}
VAR_2 = cpu_to_be32(VAR_2);
if (nbd_write(VAR_0, &VAR_2, sizeof(VAR_2), VAR_4) < 0) {
error_prepend(VAR_4, "write failed (rep VAR_2): ");
return -EINVAL;
}
VAR_1 = cpu_to_be32(VAR_1);
if (nbd_write(VAR_0, &VAR_1, sizeof(VAR_1), VAR_4) < 0) {
error_prepend(VAR_4, "write failed (rep VAR_1): ");
return -EINVAL;
}
VAR_3 = cpu_to_be32(VAR_3);
if (nbd_write(VAR_0, &VAR_3, sizeof(VAR_3), VAR_4) < 0) {
error_prepend(VAR_4, "write failed (rep data length): ");
return -EINVAL;
}
return 0;
}
| [
"static int FUNC_0(QIOChannel *VAR_0, uint32_t VAR_1,\nuint32_t VAR_2, uint32_t VAR_3, Error **VAR_4)\n{",
"uint64_t magic;",
"trace_nbd_negotiate_send_rep_len(VAR_2, VAR_1, VAR_3);",
"magic = cpu_to_be64(NBD_REP_MAGIC);",
"if (nbd_write(VAR_0, &magic, sizeof(magic), VAR_4) < 0) {",
"error_prepend(VAR_4, \"write failed (rep magic): \");",
"return -EINVAL;",
"}",
"VAR_2 = cpu_to_be32(VAR_2);",
"if (nbd_write(VAR_0, &VAR_2, sizeof(VAR_2), VAR_4) < 0) {",
"error_prepend(VAR_4, \"write failed (rep VAR_2): \");",
"return -EINVAL;",
"}",
"VAR_1 = cpu_to_be32(VAR_1);",
"if (nbd_write(VAR_0, &VAR_1, sizeof(VAR_1), VAR_4) < 0) {",
"error_prepend(VAR_4, \"write failed (rep VAR_1): \");",
"return -EINVAL;",
"}",
"VAR_3 = cpu_to_be32(VAR_3);",
"if (nbd_write(VAR_0, &VAR_3, sizeof(VAR_3), VAR_4) < 0) {",
"error_prepend(VAR_4, \"write failed (rep data length): \");",
"return -EINVAL;",
"}",
"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
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
]
] |
20,563 | uint16_t cpu_inw(pio_addr_t addr)
{
uint16_t val;
val = ioport_read(1, addr);
trace_cpu_in(addr, val);
LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
return val;
}
| false | qemu | b40acf99bef69fa8ab0f9092ff162fde945eec12 | uint16_t cpu_inw(pio_addr_t addr)
{
uint16_t val;
val = ioport_read(1, addr);
trace_cpu_in(addr, val);
LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
return val;
}
| {
"code": [],
"line_no": []
} | uint16_t FUNC_0(pio_addr_t addr)
{
uint16_t val;
val = ioport_read(1, addr);
trace_cpu_in(addr, val);
LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);
return val;
}
| [
"uint16_t FUNC_0(pio_addr_t addr)\n{",
"uint16_t val;",
"val = ioport_read(1, addr);",
"trace_cpu_in(addr, val);",
"LOG_IOPORT(\"inw : %04\"FMT_pioaddr\" %04\"PRIx16\"\\n\", addr, val);",
"return val;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
20,564 | static int local_chmod(FsContext *ctx, const char *path, mode_t mode)
{
return chmod(rpath(ctx, path), mode);
}
| false | qemu | e95ead32efc48157de12e0a257ea1c52541a6ce1 | static int local_chmod(FsContext *ctx, const char *path, mode_t mode)
{
return chmod(rpath(ctx, path), mode);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(FsContext *VAR_0, const char *VAR_1, mode_t VAR_2)
{
return chmod(rpath(VAR_0, VAR_1), VAR_2);
}
| [
"static int FUNC_0(FsContext *VAR_0, const char *VAR_1, mode_t VAR_2)\n{",
"return chmod(rpath(VAR_0, VAR_1), VAR_2);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
20,565 | int ff_wmv2_decode_picture_header(MpegEncContext * s)
{
Wmv2Context * const w= (Wmv2Context*)s;
int code;
#if 0
{
int i;
for(i=0; i<s->gb.size*8; i++)
printf("%d", get_bits1(&s->gb));
// get_bits1(&s->gb);
printf("END\n");
return -1;
}
#endif
if(s->picture_number==0)
decode_ext_header(w);
s->pict_type = get_bits1(&s->gb) + 1;
if(s->pict_type == I_TYPE){
code = get_bits(&s->gb, 7);
av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
}
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
if(s->qscale < 0)
return -1;
return 0;
}
| false | FFmpeg | 9ccbc672aa341d3cb4c4159e1e746ef0693ee138 | int ff_wmv2_decode_picture_header(MpegEncContext * s)
{
Wmv2Context * const w= (Wmv2Context*)s;
int code;
#if 0
{
int i;
for(i=0; i<s->gb.size*8; i++)
printf("%d", get_bits1(&s->gb));
printf("END\n");
return -1;
}
#endif
if(s->picture_number==0)
decode_ext_header(w);
s->pict_type = get_bits1(&s->gb) + 1;
if(s->pict_type == I_TYPE){
code = get_bits(&s->gb, 7);
av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
}
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
if(s->qscale < 0)
return -1;
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(MpegEncContext * VAR_0)
{
Wmv2Context * const w= (Wmv2Context*)VAR_0;
int VAR_1;
#if 0
{
int i;
for(i=0; i<VAR_0->gb.size*8; i++)
printf("%d", get_bits1(&VAR_0->gb));
printf("END\n");
return -1;
}
#endif
if(VAR_0->picture_number==0)
decode_ext_header(w);
VAR_0->pict_type = get_bits1(&VAR_0->gb) + 1;
if(VAR_0->pict_type == I_TYPE){
VAR_1 = get_bits(&VAR_0->gb, 7);
av_log(VAR_0->avctx, AV_LOG_DEBUG, "I7:%X/\n", VAR_1);
}
VAR_0->chroma_qscale= VAR_0->qscale = get_bits(&VAR_0->gb, 5);
if(VAR_0->qscale < 0)
return -1;
return 0;
}
| [
"int FUNC_0(MpegEncContext * VAR_0)\n{",
"Wmv2Context * const w= (Wmv2Context*)VAR_0;",
"int VAR_1;",
"#if 0\n{",
"int i;",
"for(i=0; i<VAR_0->gb.size*8; i++)",
"printf(\"%d\", get_bits1(&VAR_0->gb));",
"printf(\"END\\n\");",
"return -1;",
"}",
"#endif\nif(VAR_0->picture_number==0)\ndecode_ext_header(w);",
"VAR_0->pict_type = get_bits1(&VAR_0->gb) + 1;",
"if(VAR_0->pict_type == I_TYPE){",
"VAR_1 = get_bits(&VAR_0->gb, 7);",
"av_log(VAR_0->avctx, AV_LOG_DEBUG, \"I7:%X/\\n\", VAR_1);",
"}",
"VAR_0->chroma_qscale= VAR_0->qscale = get_bits(&VAR_0->gb, 5);",
"if(VAR_0->qscale < 0)\nreturn -1;",
"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
],
[
23
],
[
25
],
[
27
],
[
29,
31,
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49,
51
],
[
55
],
[
57
]
] |
20,566 | static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s,
bool generate_data_write_guid, MSGUID *log_guid)
{
int ret = 0;
int hdr_idx = 0;
uint64_t header_offset = VHDX_HEADER1_OFFSET;
VHDXHeader *active_header;
VHDXHeader *inactive_header;
/* operate on the non-current header */
if (s->curr_header == 0) {
hdr_idx = 1;
header_offset = VHDX_HEADER2_OFFSET;
}
active_header = s->headers[s->curr_header];
inactive_header = s->headers[hdr_idx];
inactive_header->sequence_number = active_header->sequence_number + 1;
/* a new file guid must be generated before any file write, including
* headers */
inactive_header->file_write_guid = s->session_guid;
/* a new data guid only needs to be generated before any guest-visible
* writes (i.e. something observable via virtual disk read) */
if (generate_data_write_guid) {
vhdx_guid_generate(&inactive_header->data_write_guid);
}
/* update the log guid if present */
if (log_guid) {
inactive_header->log_guid = *log_guid;
}
vhdx_write_header(bs->file, inactive_header, header_offset, true);
if (ret < 0) {
goto exit;
}
s->curr_header = hdr_idx;
exit:
return ret;
}
| false | qemu | f50159fa9b5a0ad82e30c123643ec39a1df81d9a | static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s,
bool generate_data_write_guid, MSGUID *log_guid)
{
int ret = 0;
int hdr_idx = 0;
uint64_t header_offset = VHDX_HEADER1_OFFSET;
VHDXHeader *active_header;
VHDXHeader *inactive_header;
if (s->curr_header == 0) {
hdr_idx = 1;
header_offset = VHDX_HEADER2_OFFSET;
}
active_header = s->headers[s->curr_header];
inactive_header = s->headers[hdr_idx];
inactive_header->sequence_number = active_header->sequence_number + 1;
inactive_header->file_write_guid = s->session_guid;
if (generate_data_write_guid) {
vhdx_guid_generate(&inactive_header->data_write_guid);
}
if (log_guid) {
inactive_header->log_guid = *log_guid;
}
vhdx_write_header(bs->file, inactive_header, header_offset, true);
if (ret < 0) {
goto exit;
}
s->curr_header = hdr_idx;
exit:
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(BlockDriverState *VAR_0, BDRVVHDXState *VAR_1,
bool VAR_2, MSGUID *VAR_3)
{
int VAR_4 = 0;
int VAR_5 = 0;
uint64_t header_offset = VHDX_HEADER1_OFFSET;
VHDXHeader *active_header;
VHDXHeader *inactive_header;
if (VAR_1->curr_header == 0) {
VAR_5 = 1;
header_offset = VHDX_HEADER2_OFFSET;
}
active_header = VAR_1->headers[VAR_1->curr_header];
inactive_header = VAR_1->headers[VAR_5];
inactive_header->sequence_number = active_header->sequence_number + 1;
inactive_header->file_write_guid = VAR_1->session_guid;
if (VAR_2) {
vhdx_guid_generate(&inactive_header->data_write_guid);
}
if (VAR_3) {
inactive_header->VAR_3 = *VAR_3;
}
vhdx_write_header(VAR_0->file, inactive_header, header_offset, true);
if (VAR_4 < 0) {
goto exit;
}
VAR_1->curr_header = VAR_5;
exit:
return VAR_4;
}
| [
"static int FUNC_0(BlockDriverState *VAR_0, BDRVVHDXState *VAR_1,\nbool VAR_2, MSGUID *VAR_3)\n{",
"int VAR_4 = 0;",
"int VAR_5 = 0;",
"uint64_t header_offset = VHDX_HEADER1_OFFSET;",
"VHDXHeader *active_header;",
"VHDXHeader *inactive_header;",
"if (VAR_1->curr_header == 0) {",
"VAR_5 = 1;",
"header_offset = VHDX_HEADER2_OFFSET;",
"}",
"active_header = VAR_1->headers[VAR_1->curr_header];",
"inactive_header = VAR_1->headers[VAR_5];",
"inactive_header->sequence_number = active_header->sequence_number + 1;",
"inactive_header->file_write_guid = VAR_1->session_guid;",
"if (VAR_2) {",
"vhdx_guid_generate(&inactive_header->data_write_guid);",
"}",
"if (VAR_3) {",
"inactive_header->VAR_3 = *VAR_3;",
"}",
"vhdx_write_header(VAR_0->file, inactive_header, header_offset, true);",
"if (VAR_4 < 0) {",
"goto exit;",
"}",
"VAR_1->curr_header = VAR_5;",
"exit:\nreturn 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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
47
],
[
55
],
[
57
],
[
59
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85,
87
],
[
89
]
] |
20,567 | static void cirrus_invalidate_region(CirrusVGAState * s, int off_begin,
int off_pitch, int bytesperline,
int lines)
{
int y;
int off_cur;
int off_cur_end;
if (off_pitch < 0) {
off_begin -= bytesperline - 1;
}
for (y = 0; y < lines; y++) {
off_cur = off_begin;
off_cur_end = (off_cur + bytesperline) & s->cirrus_addr_mask;
assert(off_cur_end >= off_cur);
memory_region_set_dirty(&s->vga.vram, off_cur, off_cur_end - off_cur);
off_begin += off_pitch;
}
}
| false | qemu | e048dac616748273c2153490e9fdf1da242f0cad | static void cirrus_invalidate_region(CirrusVGAState * s, int off_begin,
int off_pitch, int bytesperline,
int lines)
{
int y;
int off_cur;
int off_cur_end;
if (off_pitch < 0) {
off_begin -= bytesperline - 1;
}
for (y = 0; y < lines; y++) {
off_cur = off_begin;
off_cur_end = (off_cur + bytesperline) & s->cirrus_addr_mask;
assert(off_cur_end >= off_cur);
memory_region_set_dirty(&s->vga.vram, off_cur, off_cur_end - off_cur);
off_begin += off_pitch;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(CirrusVGAState * VAR_0, int VAR_1,
int VAR_2, int VAR_3,
int VAR_4)
{
int VAR_5;
int VAR_6;
int VAR_7;
if (VAR_2 < 0) {
VAR_1 -= VAR_3 - 1;
}
for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {
VAR_6 = VAR_1;
VAR_7 = (VAR_6 + VAR_3) & VAR_0->cirrus_addr_mask;
assert(VAR_7 >= VAR_6);
memory_region_set_dirty(&VAR_0->vga.vram, VAR_6, VAR_7 - VAR_6);
VAR_1 += VAR_2;
}
}
| [
"static void FUNC_0(CirrusVGAState * VAR_0, int VAR_1,\nint VAR_2, int VAR_3,\nint VAR_4)\n{",
"int VAR_5;",
"int VAR_6;",
"int VAR_7;",
"if (VAR_2 < 0) {",
"VAR_1 -= VAR_3 - 1;",
"}",
"for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {",
"VAR_6 = VAR_1;",
"VAR_7 = (VAR_6 + VAR_3) & VAR_0->cirrus_addr_mask;",
"assert(VAR_7 >= VAR_6);",
"memory_region_set_dirty(&VAR_0->vga.vram, VAR_6, VAR_7 - VAR_6);",
"VAR_1 += VAR_2;",
"}",
"}"
] | [
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
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
]
] |
20,568 | static void msmouse_event(void *opaque,
int dx, int dy, int dz, int buttons_state)
{
CharDriverState *chr = (CharDriverState *)opaque;
unsigned char bytes[4] = { 0x40, 0x00, 0x00, 0x00 };
/* Movement deltas */
bytes[0] |= (MSMOUSE_HI2(dy) << 2) | MSMOUSE_HI2(dx);
bytes[1] |= MSMOUSE_LO6(dx);
bytes[2] |= MSMOUSE_LO6(dy);
/* Buttons */
bytes[0] |= (buttons_state & 0x01 ? 0x20 : 0x00);
bytes[0] |= (buttons_state & 0x02 ? 0x10 : 0x00);
bytes[3] |= (buttons_state & 0x04 ? 0x20 : 0x00);
/* We always send the packet of, so that we do not have to keep track
of previous state of the middle button. This can potentially confuse
some very old drivers for two button mice though. */
qemu_chr_be_write(chr, bytes, 4);
}
| false | qemu | 57a4e3b92b6e87158c1e5192fb99a5ac3b82dd5a | static void msmouse_event(void *opaque,
int dx, int dy, int dz, int buttons_state)
{
CharDriverState *chr = (CharDriverState *)opaque;
unsigned char bytes[4] = { 0x40, 0x00, 0x00, 0x00 };
bytes[0] |= (MSMOUSE_HI2(dy) << 2) | MSMOUSE_HI2(dx);
bytes[1] |= MSMOUSE_LO6(dx);
bytes[2] |= MSMOUSE_LO6(dy);
bytes[0] |= (buttons_state & 0x01 ? 0x20 : 0x00);
bytes[0] |= (buttons_state & 0x02 ? 0x10 : 0x00);
bytes[3] |= (buttons_state & 0x04 ? 0x20 : 0x00);
qemu_chr_be_write(chr, bytes, 4);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0,
int VAR_1, int VAR_2, int VAR_3, int VAR_4)
{
CharDriverState *chr = (CharDriverState *)VAR_0;
unsigned char VAR_5[4] = { 0x40, 0x00, 0x00, 0x00 };
VAR_5[0] |= (MSMOUSE_HI2(VAR_2) << 2) | MSMOUSE_HI2(VAR_1);
VAR_5[1] |= MSMOUSE_LO6(VAR_1);
VAR_5[2] |= MSMOUSE_LO6(VAR_2);
VAR_5[0] |= (VAR_4 & 0x01 ? 0x20 : 0x00);
VAR_5[0] |= (VAR_4 & 0x02 ? 0x10 : 0x00);
VAR_5[3] |= (VAR_4 & 0x04 ? 0x20 : 0x00);
qemu_chr_be_write(chr, VAR_5, 4);
}
| [
"static void FUNC_0(void *VAR_0,\nint VAR_1, int VAR_2, int VAR_3, int VAR_4)\n{",
"CharDriverState *chr = (CharDriverState *)VAR_0;",
"unsigned char VAR_5[4] = { 0x40, 0x00, 0x00, 0x00 };",
"VAR_5[0] |= (MSMOUSE_HI2(VAR_2) << 2) | MSMOUSE_HI2(VAR_1);",
"VAR_5[1] |= MSMOUSE_LO6(VAR_1);",
"VAR_5[2] |= MSMOUSE_LO6(VAR_2);",
"VAR_5[0] |= (VAR_4 & 0x01 ? 0x20 : 0x00);",
"VAR_5[0] |= (VAR_4 & 0x02 ? 0x10 : 0x00);",
"VAR_5[3] |= (VAR_4 & 0x04 ? 0x20 : 0x00);",
"qemu_chr_be_write(chr, VAR_5, 4);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
17
],
[
19
],
[
21
],
[
27
],
[
29
],
[
31
],
[
41
],
[
43
]
] |
20,569 | static void gen_load(DisasContext *dc, TCGv dst, TCGv addr,
unsigned int size, int sign)
{
int mem_index = cpu_mmu_index(dc->env);
/* If we get a fault on a delayslot we must keep the jmp state in
the cpu-state to be able to re-execute the jmp. */
if (dc->delayed_branch == 1)
cris_store_direct_jmp(dc);
if (size == 1) {
if (sign)
tcg_gen_qemu_ld8s(dst, addr, mem_index);
else
tcg_gen_qemu_ld8u(dst, addr, mem_index);
}
else if (size == 2) {
if (sign)
tcg_gen_qemu_ld16s(dst, addr, mem_index);
else
tcg_gen_qemu_ld16u(dst, addr, mem_index);
}
else if (size == 4) {
tcg_gen_qemu_ld32u(dst, addr, mem_index);
}
else if (size == 8) {
tcg_gen_qemu_ld64(dst, addr, mem_index);
}
}
| false | qemu | a7812ae412311d7d47f8aa85656faadac9d64b56 | static void gen_load(DisasContext *dc, TCGv dst, TCGv addr,
unsigned int size, int sign)
{
int mem_index = cpu_mmu_index(dc->env);
if (dc->delayed_branch == 1)
cris_store_direct_jmp(dc);
if (size == 1) {
if (sign)
tcg_gen_qemu_ld8s(dst, addr, mem_index);
else
tcg_gen_qemu_ld8u(dst, addr, mem_index);
}
else if (size == 2) {
if (sign)
tcg_gen_qemu_ld16s(dst, addr, mem_index);
else
tcg_gen_qemu_ld16u(dst, addr, mem_index);
}
else if (size == 4) {
tcg_gen_qemu_ld32u(dst, addr, mem_index);
}
else if (size == 8) {
tcg_gen_qemu_ld64(dst, addr, mem_index);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, TCGv VAR_1, TCGv VAR_2,
unsigned int VAR_3, int VAR_4)
{
int VAR_5 = cpu_mmu_index(VAR_0->env);
if (VAR_0->delayed_branch == 1)
cris_store_direct_jmp(VAR_0);
if (VAR_3 == 1) {
if (VAR_4)
tcg_gen_qemu_ld8s(VAR_1, VAR_2, VAR_5);
else
tcg_gen_qemu_ld8u(VAR_1, VAR_2, VAR_5);
}
else if (VAR_3 == 2) {
if (VAR_4)
tcg_gen_qemu_ld16s(VAR_1, VAR_2, VAR_5);
else
tcg_gen_qemu_ld16u(VAR_1, VAR_2, VAR_5);
}
else if (VAR_3 == 4) {
tcg_gen_qemu_ld32u(VAR_1, VAR_2, VAR_5);
}
else if (VAR_3 == 8) {
tcg_gen_qemu_ld64(VAR_1, VAR_2, VAR_5);
}
}
| [
"static void FUNC_0(DisasContext *VAR_0, TCGv VAR_1, TCGv VAR_2,\nunsigned int VAR_3, int VAR_4)\n{",
"int VAR_5 = cpu_mmu_index(VAR_0->env);",
"if (VAR_0->delayed_branch == 1)\ncris_store_direct_jmp(VAR_0);",
"if (VAR_3 == 1) {",
"if (VAR_4)\ntcg_gen_qemu_ld8s(VAR_1, VAR_2, VAR_5);",
"else\ntcg_gen_qemu_ld8u(VAR_1, VAR_2, VAR_5);",
"}",
"else if (VAR_3 == 2) {",
"if (VAR_4)\ntcg_gen_qemu_ld16s(VAR_1, VAR_2, VAR_5);",
"else\ntcg_gen_qemu_ld16u(VAR_1, VAR_2, VAR_5);",
"}",
"else if (VAR_3 == 4) {",
"tcg_gen_qemu_ld32u(VAR_1, VAR_2, VAR_5);",
"}",
"else if (VAR_3 == 8) {",
"tcg_gen_qemu_ld64(VAR_1, VAR_2, VAR_5);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
15,
17
],
[
21
],
[
23,
25
],
[
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
]
] |
20,570 | static void pci_apb_iowritew (void *opaque, target_phys_addr_t addr,
uint32_t val)
{
cpu_outw(addr & IOPORTS_MASK, bswap16(val));
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void pci_apb_iowritew (void *opaque, target_phys_addr_t addr,
uint32_t val)
{
cpu_outw(addr & IOPORTS_MASK, bswap16(val));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1,
uint32_t VAR_2)
{
cpu_outw(VAR_1 & IOPORTS_MASK, bswap16(VAR_2));
}
| [
"static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{",
"cpu_outw(VAR_1 & IOPORTS_MASK, bswap16(VAR_2));",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
]
] |
20,571 | static struct ioreq *ioreq_start(struct XenBlkDev *blkdev)
{
struct ioreq *ioreq = NULL;
if (LIST_EMPTY(&blkdev->freelist)) {
if (blkdev->requests_total >= max_requests)
goto out;
/* allocate new struct */
ioreq = qemu_mallocz(sizeof(*ioreq));
ioreq->blkdev = blkdev;
blkdev->requests_total++;
qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST);
} else {
/* get one from freelist */
ioreq = LIST_FIRST(&blkdev->freelist);
LIST_REMOVE(ioreq, list);
qemu_iovec_reset(&ioreq->v);
}
LIST_INSERT_HEAD(&blkdev->inflight, ioreq, list);
blkdev->requests_inflight++;
out:
return ioreq;
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static struct ioreq *ioreq_start(struct XenBlkDev *blkdev)
{
struct ioreq *ioreq = NULL;
if (LIST_EMPTY(&blkdev->freelist)) {
if (blkdev->requests_total >= max_requests)
goto out;
ioreq = qemu_mallocz(sizeof(*ioreq));
ioreq->blkdev = blkdev;
blkdev->requests_total++;
qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST);
} else {
ioreq = LIST_FIRST(&blkdev->freelist);
LIST_REMOVE(ioreq, list);
qemu_iovec_reset(&ioreq->v);
}
LIST_INSERT_HEAD(&blkdev->inflight, ioreq, list);
blkdev->requests_inflight++;
out:
return ioreq;
}
| {
"code": [],
"line_no": []
} | static struct VAR_1 *FUNC_0(struct XenBlkDev *VAR_0)
{
struct VAR_1 *VAR_1 = NULL;
if (LIST_EMPTY(&VAR_0->freelist)) {
if (VAR_0->requests_total >= max_requests)
goto out;
VAR_1 = qemu_mallocz(sizeof(*VAR_1));
VAR_1->VAR_0 = VAR_0;
VAR_0->requests_total++;
qemu_iovec_init(&VAR_1->v, BLKIF_MAX_SEGMENTS_PER_REQUEST);
} else {
VAR_1 = LIST_FIRST(&VAR_0->freelist);
LIST_REMOVE(VAR_1, list);
qemu_iovec_reset(&VAR_1->v);
}
LIST_INSERT_HEAD(&VAR_0->inflight, VAR_1, list);
VAR_0->requests_inflight++;
out:
return VAR_1;
}
| [
"static struct VAR_1 *FUNC_0(struct XenBlkDev *VAR_0)\n{",
"struct VAR_1 *VAR_1 = NULL;",
"if (LIST_EMPTY(&VAR_0->freelist)) {",
"if (VAR_0->requests_total >= max_requests)\ngoto out;",
"VAR_1 = qemu_mallocz(sizeof(*VAR_1));",
"VAR_1->VAR_0 = VAR_0;",
"VAR_0->requests_total++;",
"qemu_iovec_init(&VAR_1->v, BLKIF_MAX_SEGMENTS_PER_REQUEST);",
"} else {",
"VAR_1 = LIST_FIRST(&VAR_0->freelist);",
"LIST_REMOVE(VAR_1, list);",
"qemu_iovec_reset(&VAR_1->v);",
"}",
"LIST_INSERT_HEAD(&VAR_0->inflight, VAR_1, list);",
"VAR_0->requests_inflight++;",
"out:\nreturn VAR_1;",
"}"
] | [
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
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43,
45
],
[
47
]
] |
20,572 | static void pollfds_poll(GArray *pollfds, int nfds, fd_set *rfds,
fd_set *wfds, fd_set *xfds)
{
int i;
for (i = 0; i < pollfds->len; i++) {
GPollFD *pfd = &g_array_index(pollfds, GPollFD, i);
int fd = pfd->fd;
int revents = 0;
if (FD_ISSET(fd, rfds)) {
revents |= G_IO_IN;
}
if (FD_ISSET(fd, wfds)) {
revents |= G_IO_OUT;
}
if (FD_ISSET(fd, xfds)) {
revents |= G_IO_PRI;
}
pfd->revents = revents & pfd->events;
}
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | static void pollfds_poll(GArray *pollfds, int nfds, fd_set *rfds,
fd_set *wfds, fd_set *xfds)
{
int i;
for (i = 0; i < pollfds->len; i++) {
GPollFD *pfd = &g_array_index(pollfds, GPollFD, i);
int fd = pfd->fd;
int revents = 0;
if (FD_ISSET(fd, rfds)) {
revents |= G_IO_IN;
}
if (FD_ISSET(fd, wfds)) {
revents |= G_IO_OUT;
}
if (FD_ISSET(fd, xfds)) {
revents |= G_IO_PRI;
}
pfd->revents = revents & pfd->events;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(GArray *VAR_0, int VAR_1, fd_set *VAR_2,
fd_set *VAR_3, fd_set *VAR_4)
{
int VAR_5;
for (VAR_5 = 0; VAR_5 < VAR_0->len; VAR_5++) {
GPollFD *pfd = &g_array_index(VAR_0, GPollFD, VAR_5);
int fd = pfd->fd;
int revents = 0;
if (FD_ISSET(fd, VAR_2)) {
revents |= G_IO_IN;
}
if (FD_ISSET(fd, VAR_3)) {
revents |= G_IO_OUT;
}
if (FD_ISSET(fd, VAR_4)) {
revents |= G_IO_PRI;
}
pfd->revents = revents & pfd->events;
}
}
| [
"static void FUNC_0(GArray *VAR_0, int VAR_1, fd_set *VAR_2,\nfd_set *VAR_3, fd_set *VAR_4)\n{",
"int VAR_5;",
"for (VAR_5 = 0; VAR_5 < VAR_0->len; VAR_5++) {",
"GPollFD *pfd = &g_array_index(VAR_0, GPollFD, VAR_5);",
"int fd = pfd->fd;",
"int revents = 0;",
"if (FD_ISSET(fd, VAR_2)) {",
"revents |= G_IO_IN;",
"}",
"if (FD_ISSET(fd, VAR_3)) {",
"revents |= G_IO_OUT;",
"}",
"if (FD_ISSET(fd, VAR_4)) {",
"revents |= G_IO_PRI;",
"}",
"pfd->revents = revents & pfd->events;",
"}",
"}"
] | [
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
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
]
] |
20,573 | target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr)
{
return addr;
}
| false | qemu | b67ea0cd74417b42482499c29feb90914fbf8097 | target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr)
{
return addr;
}
| {
"code": [],
"line_no": []
} | target_phys_addr_t FUNC_0(CPUState *env, target_ulong addr)
{
return addr;
}
| [
"target_phys_addr_t FUNC_0(CPUState *env, target_ulong addr)\n{",
"return addr;",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
20,574 | static void get_seg(SegmentCache *lhs, const struct kvm_segment *rhs)
{
lhs->selector = rhs->selector;
lhs->base = rhs->base;
lhs->limit = rhs->limit;
lhs->flags =
(rhs->type << DESC_TYPE_SHIFT)
| (rhs->present * DESC_P_MASK)
| (rhs->dpl << DESC_DPL_SHIFT)
| (rhs->db << DESC_B_SHIFT)
| (rhs->s * DESC_S_MASK)
| (rhs->l << DESC_L_SHIFT)
| (rhs->g * DESC_G_MASK)
| (rhs->avl * DESC_AVL_MASK);
}
| false | qemu | b9bec74bcb16519a876ec21cd5277c526a9b512d | static void get_seg(SegmentCache *lhs, const struct kvm_segment *rhs)
{
lhs->selector = rhs->selector;
lhs->base = rhs->base;
lhs->limit = rhs->limit;
lhs->flags =
(rhs->type << DESC_TYPE_SHIFT)
| (rhs->present * DESC_P_MASK)
| (rhs->dpl << DESC_DPL_SHIFT)
| (rhs->db << DESC_B_SHIFT)
| (rhs->s * DESC_S_MASK)
| (rhs->l << DESC_L_SHIFT)
| (rhs->g * DESC_G_MASK)
| (rhs->avl * DESC_AVL_MASK);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(SegmentCache *VAR_0, const struct kvm_segment *VAR_1)
{
VAR_0->selector = VAR_1->selector;
VAR_0->base = VAR_1->base;
VAR_0->limit = VAR_1->limit;
VAR_0->flags =
(VAR_1->type << DESC_TYPE_SHIFT)
| (VAR_1->present * DESC_P_MASK)
| (VAR_1->dpl << DESC_DPL_SHIFT)
| (VAR_1->db << DESC_B_SHIFT)
| (VAR_1->s * DESC_S_MASK)
| (VAR_1->l << DESC_L_SHIFT)
| (VAR_1->g * DESC_G_MASK)
| (VAR_1->avl * DESC_AVL_MASK);
}
| [
"static void FUNC_0(SegmentCache *VAR_0, const struct kvm_segment *VAR_1)\n{",
"VAR_0->selector = VAR_1->selector;",
"VAR_0->base = VAR_1->base;",
"VAR_0->limit = VAR_1->limit;",
"VAR_0->flags =\n(VAR_1->type << DESC_TYPE_SHIFT)\n| (VAR_1->present * DESC_P_MASK)\n| (VAR_1->dpl << DESC_DPL_SHIFT)\n| (VAR_1->db << DESC_B_SHIFT)\n| (VAR_1->s * DESC_S_MASK)\n| (VAR_1->l << DESC_L_SHIFT)\n| (VAR_1->g * DESC_G_MASK)\n| (VAR_1->avl * DESC_AVL_MASK);",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11,
13,
15,
17,
19,
21,
23,
25,
27
],
[
29
]
] |
20,575 | static always_inline int get_bat (CPUState *env, mmu_ctx_t *ctx,
target_ulong virtual, int rw, int type)
{
target_ulong *BATlt, *BATut, *BATu, *BATl;
target_ulong base, BEPIl, BEPIu, bl;
int i, pp, pr;
int ret = -1;
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s: %cBAT v 0x" ADDRX "\n", __func__,
type == ACCESS_CODE ? 'I' : 'D', virtual);
}
#endif
pr = msr_pr;
switch (type) {
case ACCESS_CODE:
BATlt = env->IBAT[1];
BATut = env->IBAT[0];
break;
default:
BATlt = env->DBAT[1];
BATut = env->DBAT[0];
break;
}
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s...: %cBAT v 0x" ADDRX "\n", __func__,
type == ACCESS_CODE ? 'I' : 'D', virtual);
}
#endif
base = virtual & 0xFFFC0000;
for (i = 0; i < 4; i++) {
BATu = &BATut[i];
BATl = &BATlt[i];
BEPIu = *BATu & 0xF0000000;
BEPIl = *BATu & 0x0FFE0000;
bl = (*BATu & 0x00001FFC) << 15;
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
" BATl 0x" ADDRX "\n",
__func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
*BATu, *BATl);
}
#endif
if ((virtual & 0xF0000000) == BEPIu &&
((virtual & 0x0FFE0000) & ~bl) == BEPIl) {
/* BAT matches */
if (((pr == 0) && (*BATu & 0x00000002)) ||
((pr != 0) && (*BATu & 0x00000001))) {
/* Get physical address */
ctx->raddr = (*BATl & 0xF0000000) |
((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |
(virtual & 0x0001F000);
/* Compute access rights */
pp = *BATl & 0x00000003;
ctx->prot = 0;
if (pp != 0) {
ctx->prot = PAGE_READ | PAGE_EXEC;
if (pp == 0x2)
ctx->prot |= PAGE_WRITE;
}
ret = check_prot(ctx->prot, rw, type);
#if defined (DEBUG_BATS)
if (ret == 0 && loglevel != 0) {
fprintf(logfile, "BAT %d match: r 0x" PADDRX
" prot=%c%c\n",
i, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',
ctx->prot & PAGE_WRITE ? 'W' : '-');
}
#endif
break;
}
}
}
if (ret < 0) {
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "no BAT match for 0x" ADDRX ":\n", virtual);
for (i = 0; i < 4; i++) {
BATu = &BATut[i];
BATl = &BATlt[i];
BEPIu = *BATu & 0xF0000000;
BEPIl = *BATu & 0x0FFE0000;
bl = (*BATu & 0x00001FFC) << 15;
fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
" BATl 0x" ADDRX " \n\t"
"0x" ADDRX " 0x" ADDRX " 0x" ADDRX "\n",
__func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
*BATu, *BATl, BEPIu, BEPIl, bl);
}
}
#endif
}
/* No hit */
return ret;
}
| true | qemu | faadf50e2962dd54175647a80bd6fc4319c91973 | static always_inline int get_bat (CPUState *env, mmu_ctx_t *ctx,
target_ulong virtual, int rw, int type)
{
target_ulong *BATlt, *BATut, *BATu, *BATl;
target_ulong base, BEPIl, BEPIu, bl;
int i, pp, pr;
int ret = -1;
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s: %cBAT v 0x" ADDRX "\n", __func__,
type == ACCESS_CODE ? 'I' : 'D', virtual);
}
#endif
pr = msr_pr;
switch (type) {
case ACCESS_CODE:
BATlt = env->IBAT[1];
BATut = env->IBAT[0];
break;
default:
BATlt = env->DBAT[1];
BATut = env->DBAT[0];
break;
}
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s...: %cBAT v 0x" ADDRX "\n", __func__,
type == ACCESS_CODE ? 'I' : 'D', virtual);
}
#endif
base = virtual & 0xFFFC0000;
for (i = 0; i < 4; i++) {
BATu = &BATut[i];
BATl = &BATlt[i];
BEPIu = *BATu & 0xF0000000;
BEPIl = *BATu & 0x0FFE0000;
bl = (*BATu & 0x00001FFC) << 15;
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
" BATl 0x" ADDRX "\n",
__func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
*BATu, *BATl);
}
#endif
if ((virtual & 0xF0000000) == BEPIu &&
((virtual & 0x0FFE0000) & ~bl) == BEPIl) {
if (((pr == 0) && (*BATu & 0x00000002)) ||
((pr != 0) && (*BATu & 0x00000001))) {
ctx->raddr = (*BATl & 0xF0000000) |
((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |
(virtual & 0x0001F000);
pp = *BATl & 0x00000003;
ctx->prot = 0;
if (pp != 0) {
ctx->prot = PAGE_READ | PAGE_EXEC;
if (pp == 0x2)
ctx->prot |= PAGE_WRITE;
}
ret = check_prot(ctx->prot, rw, type);
#if defined (DEBUG_BATS)
if (ret == 0 && loglevel != 0) {
fprintf(logfile, "BAT %d match: r 0x" PADDRX
" prot=%c%c\n",
i, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',
ctx->prot & PAGE_WRITE ? 'W' : '-');
}
#endif
break;
}
}
}
if (ret < 0) {
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "no BAT match for 0x" ADDRX ":\n", virtual);
for (i = 0; i < 4; i++) {
BATu = &BATut[i];
BATl = &BATlt[i];
BEPIu = *BATu & 0xF0000000;
BEPIl = *BATu & 0x0FFE0000;
bl = (*BATu & 0x00001FFC) << 15;
fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
" BATl 0x" ADDRX " \n\t"
"0x" ADDRX " 0x" ADDRX " 0x" ADDRX "\n",
__func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
*BATu, *BATl, BEPIu, BEPIl, bl);
}
}
#endif
}
return ret;
}
| {
"code": [
" int i, pp, pr;",
" pr = msr_pr;",
" for (i = 0; i < 4; i++) {",
" bl = (*BATu & 0x00001FFC) << 15;",
" if (((pr == 0) && (*BATu & 0x00000002)) ||",
" ((pr != 0) && (*BATu & 0x00000001))) {",
" pp = *BATl & 0x00000003;",
" ctx->prot = 0;",
" if (pp != 0) {",
" ctx->prot = PAGE_READ | PAGE_EXEC;",
" if (pp == 0x2)",
" ctx->prot |= PAGE_WRITE;",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif"
],
"line_no": [
11,
29,
65,
75,
99,
101,
113,
115,
117,
119,
121,
123,
27,
27,
27,
27,
27,
27
]
} | static always_inline int FUNC_0 (CPUState *env, mmu_ctx_t *ctx,
target_ulong virtual, int rw, int type)
{
target_ulong *BATlt, *BATut, *BATu, *BATl;
target_ulong base, BEPIl, BEPIu, bl;
int VAR_0, VAR_1, VAR_2;
int VAR_3 = -1;
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s: %cBAT v 0x" ADDRX "\n", __func__,
type == ACCESS_CODE ? 'I' : 'D', virtual);
}
#endif
VAR_2 = msr_pr;
switch (type) {
case ACCESS_CODE:
BATlt = env->IBAT[1];
BATut = env->IBAT[0];
break;
default:
BATlt = env->DBAT[1];
BATut = env->DBAT[0];
break;
}
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s...: %cBAT v 0x" ADDRX "\n", __func__,
type == ACCESS_CODE ? 'I' : 'D', virtual);
}
#endif
base = virtual & 0xFFFC0000;
for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {
BATu = &BATut[VAR_0];
BATl = &BATlt[VAR_0];
BEPIu = *BATu & 0xF0000000;
BEPIl = *BATu & 0x0FFE0000;
bl = (*BATu & 0x00001FFC) << 15;
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
" BATl 0x" ADDRX "\n",
__func__, type == ACCESS_CODE ? 'I' : 'D', VAR_0, virtual,
*BATu, *BATl);
}
#endif
if ((virtual & 0xF0000000) == BEPIu &&
((virtual & 0x0FFE0000) & ~bl) == BEPIl) {
if (((VAR_2 == 0) && (*BATu & 0x00000002)) ||
((VAR_2 != 0) && (*BATu & 0x00000001))) {
ctx->raddr = (*BATl & 0xF0000000) |
((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |
(virtual & 0x0001F000);
VAR_1 = *BATl & 0x00000003;
ctx->prot = 0;
if (VAR_1 != 0) {
ctx->prot = PAGE_READ | PAGE_EXEC;
if (VAR_1 == 0x2)
ctx->prot |= PAGE_WRITE;
}
VAR_3 = check_prot(ctx->prot, rw, type);
#if defined (DEBUG_BATS)
if (VAR_3 == 0 && loglevel != 0) {
fprintf(logfile, "BAT %d match: r 0x" PADDRX
" prot=%c%c\n",
VAR_0, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',
ctx->prot & PAGE_WRITE ? 'W' : '-');
}
#endif
break;
}
}
}
if (VAR_3 < 0) {
#if defined (DEBUG_BATS)
if (loglevel != 0) {
fprintf(logfile, "no BAT match for 0x" ADDRX ":\n", virtual);
for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {
BATu = &BATut[VAR_0];
BATl = &BATlt[VAR_0];
BEPIu = *BATu & 0xF0000000;
BEPIl = *BATu & 0x0FFE0000;
bl = (*BATu & 0x00001FFC) << 15;
fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
" BATl 0x" ADDRX " \n\t"
"0x" ADDRX " 0x" ADDRX " 0x" ADDRX "\n",
__func__, type == ACCESS_CODE ? 'I' : 'D', VAR_0, virtual,
*BATu, *BATl, BEPIu, BEPIl, bl);
}
}
#endif
}
return VAR_3;
}
| [
"static always_inline int FUNC_0 (CPUState *env, mmu_ctx_t *ctx,\ntarget_ulong virtual, int rw, int type)\n{",
"target_ulong *BATlt, *BATut, *BATu, *BATl;",
"target_ulong base, BEPIl, BEPIu, bl;",
"int VAR_0, VAR_1, VAR_2;",
"int VAR_3 = -1;",
"#if defined (DEBUG_BATS)\nif (loglevel != 0) {",
"fprintf(logfile, \"%s: %cBAT v 0x\" ADDRX \"\\n\", __func__,\ntype == ACCESS_CODE ? 'I' : 'D', virtual);",
"}",
"#endif\nVAR_2 = msr_pr;",
"switch (type) {",
"case ACCESS_CODE:\nBATlt = env->IBAT[1];",
"BATut = env->IBAT[0];",
"break;",
"default:\nBATlt = env->DBAT[1];",
"BATut = env->DBAT[0];",
"break;",
"}",
"#if defined (DEBUG_BATS)\nif (loglevel != 0) {",
"fprintf(logfile, \"%s...: %cBAT v 0x\" ADDRX \"\\n\", __func__,\ntype == ACCESS_CODE ? 'I' : 'D', virtual);",
"}",
"#endif\nbase = virtual & 0xFFFC0000;",
"for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {",
"BATu = &BATut[VAR_0];",
"BATl = &BATlt[VAR_0];",
"BEPIu = *BATu & 0xF0000000;",
"BEPIl = *BATu & 0x0FFE0000;",
"bl = (*BATu & 0x00001FFC) << 15;",
"#if defined (DEBUG_BATS)\nif (loglevel != 0) {",
"fprintf(logfile, \"%s: %cBAT%d v 0x\" ADDRX \" BATu 0x\" ADDRX\n\" BATl 0x\" ADDRX \"\\n\",\n__func__, type == ACCESS_CODE ? 'I' : 'D', VAR_0, virtual,\n*BATu, *BATl);",
"}",
"#endif\nif ((virtual & 0xF0000000) == BEPIu &&\n((virtual & 0x0FFE0000) & ~bl) == BEPIl) {",
"if (((VAR_2 == 0) && (*BATu & 0x00000002)) ||\n((VAR_2 != 0) && (*BATu & 0x00000001))) {",
"ctx->raddr = (*BATl & 0xF0000000) |\n((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |\n(virtual & 0x0001F000);",
"VAR_1 = *BATl & 0x00000003;",
"ctx->prot = 0;",
"if (VAR_1 != 0) {",
"ctx->prot = PAGE_READ | PAGE_EXEC;",
"if (VAR_1 == 0x2)\nctx->prot |= PAGE_WRITE;",
"}",
"VAR_3 = check_prot(ctx->prot, rw, type);",
"#if defined (DEBUG_BATS)\nif (VAR_3 == 0 && loglevel != 0) {",
"fprintf(logfile, \"BAT %d match: r 0x\" PADDRX\n\" prot=%c%c\\n\",\nVAR_0, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',\nctx->prot & PAGE_WRITE ? 'W' : '-');",
"}",
"#endif\nbreak;",
"}",
"}",
"}",
"if (VAR_3 < 0) {",
"#if defined (DEBUG_BATS)\nif (loglevel != 0) {",
"fprintf(logfile, \"no BAT match for 0x\" ADDRX \":\\n\", virtual);",
"for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {",
"BATu = &BATut[VAR_0];",
"BATl = &BATlt[VAR_0];",
"BEPIu = *BATu & 0xF0000000;",
"BEPIl = *BATu & 0x0FFE0000;",
"bl = (*BATu & 0x00001FFC) << 15;",
"fprintf(logfile, \"%s: %cBAT%d v 0x\" ADDRX \" BATu 0x\" ADDRX\n\" BATl 0x\" ADDRX \" \\n\\t\"\n\"0x\" ADDRX \" 0x\" ADDRX \" 0x\" ADDRX \"\\n\",\n__func__, type == ACCESS_CODE ? 'I' : 'D', VAR_0, virtual,\n*BATu, *BATl, BEPIu, BEPIl, bl);",
"}",
"}",
"#endif\n}",
"return VAR_3;",
"}"
] | [
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
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
],
[
99,
101
],
[
105,
107,
109
],
[
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
],
[
195
],
[
197
]
] |
20,577 | void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c,
VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9])
{
int i, x, y, luma_start = 0, luma_ctx = 3;
int nnz_pred, nnz, nnz_total = 0;
int segment = mb->segment;
int block_dc = 0;
if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
nnz_pred = t_nnz[8] + l_nnz[8];
// decode DC values and do hadamard
nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0,
nnz_pred, s->qmat[segment].luma_dc_qmul);
l_nnz[8] = t_nnz[8] = !!nnz;
if (nnz) {
nnz_total += nnz;
block_dc = 1;
if (nnz == 1)
s->vp8dsp.vp8_luma_dc_wht_dc(td->block, td->block_dc);
else
s->vp8dsp.vp8_luma_dc_wht(td->block, td->block_dc);
}
luma_start = 1;
luma_ctx = 0;
}
// luma blocks
for (y = 0; y < 4; y++)
for (x = 0; x < 4; x++) {
nnz_pred = l_nnz[y] + t_nnz[x];
nnz = decode_block_coeffs(c, td->block[y][x],
s->prob->token[luma_ctx],
luma_start, nnz_pred,
s->qmat[segment].luma_qmul);
/* nnz+block_dc may be one more than the actual last index,
* but we don't care */
td->non_zero_count_cache[y][x] = nnz + block_dc;
t_nnz[x] = l_nnz[y] = !!nnz;
nnz_total += nnz;
}
// chroma blocks
// TODO: what to do about dimensions? 2nd dim for luma is x,
// but for chroma it's (y<<1)|x
for (i = 4; i < 6; i++)
for (y = 0; y < 2; y++)
for (x = 0; x < 2; x++) {
nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
nnz = decode_block_coeffs(c, td->block[i][(y << 1) + x],
s->prob->token[2],
0, nnz_pred,
s->qmat[segment].chroma_qmul);
td->non_zero_count_cache[i][(y << 1) + x] = nnz;
t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
nnz_total += nnz;
}
// if there were no coded coeffs despite the macroblock not being marked skip,
// we MUST not do the inner loop filter and should not do IDCT
// Since skip isn't used for bitstream prediction, just manually set it.
if (!nnz_total)
mb->skip = 1;
}
| true | FFmpeg | ac4b32df71bd932838043a4838b86d11e169707f | void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c,
VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9])
{
int i, x, y, luma_start = 0, luma_ctx = 3;
int nnz_pred, nnz, nnz_total = 0;
int segment = mb->segment;
int block_dc = 0;
if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
nnz_pred = t_nnz[8] + l_nnz[8];
nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0,
nnz_pred, s->qmat[segment].luma_dc_qmul);
l_nnz[8] = t_nnz[8] = !!nnz;
if (nnz) {
nnz_total += nnz;
block_dc = 1;
if (nnz == 1)
s->vp8dsp.vp8_luma_dc_wht_dc(td->block, td->block_dc);
else
s->vp8dsp.vp8_luma_dc_wht(td->block, td->block_dc);
}
luma_start = 1;
luma_ctx = 0;
}
for (y = 0; y < 4; y++)
for (x = 0; x < 4; x++) {
nnz_pred = l_nnz[y] + t_nnz[x];
nnz = decode_block_coeffs(c, td->block[y][x],
s->prob->token[luma_ctx],
luma_start, nnz_pred,
s->qmat[segment].luma_qmul);
td->non_zero_count_cache[y][x] = nnz + block_dc;
t_nnz[x] = l_nnz[y] = !!nnz;
nnz_total += nnz;
}
for (i = 4; i < 6; i++)
for (y = 0; y < 2; y++)
for (x = 0; x < 2; x++) {
nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
nnz = decode_block_coeffs(c, td->block[i][(y << 1) + x],
s->prob->token[2],
0, nnz_pred,
s->qmat[segment].chroma_qmul);
td->non_zero_count_cache[i][(y << 1) + x] = nnz;
t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
nnz_total += nnz;
}
if (!nnz_total)
mb->skip = 1;
}
| {
"code": [
" VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9])",
" if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {",
" nnz_pred, s->qmat[segment].luma_dc_qmul);",
" s->qmat[segment].luma_qmul);",
" nnz = decode_block_coeffs(c, td->block[i][(y << 1) + x],",
" s->prob->token[2],",
" 0, nnz_pred,",
" s->qmat[segment].chroma_qmul);",
" nnz_total += nnz;"
],
"line_no": [
3,
17,
27,
69,
99,
101,
103,
105,
111
]
} | void FUNC_0(VP8Context *VAR_0, VP8ThreadData *VAR_1, VP56RangeCoder *VAR_2,
VP8Macroblock *VAR_3, uint8_t VAR_4[9], uint8_t VAR_5[9])
{
int VAR_6, VAR_7, VAR_8, VAR_9 = 0, VAR_10 = 3;
int VAR_11, VAR_12, VAR_13 = 0;
int VAR_14 = VAR_3->VAR_14;
int VAR_15 = 0;
if (VAR_3->mode != MODE_I4x4 && VAR_3->mode != VP8_MVMODE_SPLIT) {
VAR_11 = VAR_4[8] + VAR_5[8];
VAR_12 = decode_block_coeffs(VAR_2, VAR_1->VAR_15, VAR_0->prob->token[1], 0,
VAR_11, VAR_0->qmat[VAR_14].luma_dc_qmul);
VAR_5[8] = VAR_4[8] = !!VAR_12;
if (VAR_12) {
VAR_13 += VAR_12;
VAR_15 = 1;
if (VAR_12 == 1)
VAR_0->vp8dsp.vp8_luma_dc_wht_dc(VAR_1->block, VAR_1->VAR_15);
else
VAR_0->vp8dsp.vp8_luma_dc_wht(VAR_1->block, VAR_1->VAR_15);
}
VAR_9 = 1;
VAR_10 = 0;
}
for (VAR_8 = 0; VAR_8 < 4; VAR_8++)
for (VAR_7 = 0; VAR_7 < 4; VAR_7++) {
VAR_11 = VAR_5[VAR_8] + VAR_4[VAR_7];
VAR_12 = decode_block_coeffs(VAR_2, VAR_1->block[VAR_8][VAR_7],
VAR_0->prob->token[VAR_10],
VAR_9, VAR_11,
VAR_0->qmat[VAR_14].luma_qmul);
VAR_1->non_zero_count_cache[VAR_8][VAR_7] = VAR_12 + VAR_15;
VAR_4[VAR_7] = VAR_5[VAR_8] = !!VAR_12;
VAR_13 += VAR_12;
}
for (VAR_6 = 4; VAR_6 < 6; VAR_6++)
for (VAR_8 = 0; VAR_8 < 2; VAR_8++)
for (VAR_7 = 0; VAR_7 < 2; VAR_7++) {
VAR_11 = VAR_5[VAR_6 + 2 * VAR_8] + VAR_4[VAR_6 + 2 * VAR_7];
VAR_12 = decode_block_coeffs(VAR_2, VAR_1->block[VAR_6][(VAR_8 << 1) + VAR_7],
VAR_0->prob->token[2],
0, VAR_11,
VAR_0->qmat[VAR_14].chroma_qmul);
VAR_1->non_zero_count_cache[VAR_6][(VAR_8 << 1) + VAR_7] = VAR_12;
VAR_4[VAR_6 + 2 * VAR_7] = VAR_5[VAR_6 + 2 * VAR_8] = !!VAR_12;
VAR_13 += VAR_12;
}
if (!VAR_13)
VAR_3->skip = 1;
}
| [
"void FUNC_0(VP8Context *VAR_0, VP8ThreadData *VAR_1, VP56RangeCoder *VAR_2,\nVP8Macroblock *VAR_3, uint8_t VAR_4[9], uint8_t VAR_5[9])\n{",
"int VAR_6, VAR_7, VAR_8, VAR_9 = 0, VAR_10 = 3;",
"int VAR_11, VAR_12, VAR_13 = 0;",
"int VAR_14 = VAR_3->VAR_14;",
"int VAR_15 = 0;",
"if (VAR_3->mode != MODE_I4x4 && VAR_3->mode != VP8_MVMODE_SPLIT) {",
"VAR_11 = VAR_4[8] + VAR_5[8];",
"VAR_12 = decode_block_coeffs(VAR_2, VAR_1->VAR_15, VAR_0->prob->token[1], 0,\nVAR_11, VAR_0->qmat[VAR_14].luma_dc_qmul);",
"VAR_5[8] = VAR_4[8] = !!VAR_12;",
"if (VAR_12) {",
"VAR_13 += VAR_12;",
"VAR_15 = 1;",
"if (VAR_12 == 1)\nVAR_0->vp8dsp.vp8_luma_dc_wht_dc(VAR_1->block, VAR_1->VAR_15);",
"else\nVAR_0->vp8dsp.vp8_luma_dc_wht(VAR_1->block, VAR_1->VAR_15);",
"}",
"VAR_9 = 1;",
"VAR_10 = 0;",
"}",
"for (VAR_8 = 0; VAR_8 < 4; VAR_8++)",
"for (VAR_7 = 0; VAR_7 < 4; VAR_7++) {",
"VAR_11 = VAR_5[VAR_8] + VAR_4[VAR_7];",
"VAR_12 = decode_block_coeffs(VAR_2, VAR_1->block[VAR_8][VAR_7],\nVAR_0->prob->token[VAR_10],\nVAR_9, VAR_11,\nVAR_0->qmat[VAR_14].luma_qmul);",
"VAR_1->non_zero_count_cache[VAR_8][VAR_7] = VAR_12 + VAR_15;",
"VAR_4[VAR_7] = VAR_5[VAR_8] = !!VAR_12;",
"VAR_13 += VAR_12;",
"}",
"for (VAR_6 = 4; VAR_6 < 6; VAR_6++)",
"for (VAR_8 = 0; VAR_8 < 2; VAR_8++)",
"for (VAR_7 = 0; VAR_7 < 2; VAR_7++) {",
"VAR_11 = VAR_5[VAR_6 + 2 * VAR_8] + VAR_4[VAR_6 + 2 * VAR_7];",
"VAR_12 = decode_block_coeffs(VAR_2, VAR_1->block[VAR_6][(VAR_8 << 1) + VAR_7],\nVAR_0->prob->token[2],\n0, VAR_11,\nVAR_0->qmat[VAR_14].chroma_qmul);",
"VAR_1->non_zero_count_cache[VAR_6][(VAR_8 << 1) + VAR_7] = VAR_12;",
"VAR_4[VAR_6 + 2 * VAR_7] = VAR_5[VAR_6 + 2 * VAR_8] = !!VAR_12;",
"VAR_13 += VAR_12;",
"}",
"if (!VAR_13)\nVAR_3->skip = 1;",
"}"
] | [
1,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
57
],
[
59
],
[
61
],
[
63,
65,
67,
69
],
[
75
],
[
77
],
[
79
],
[
81
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99,
101,
103,
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
123,
125
],
[
127
]
] |
20,578 | static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
{
int predictor;
predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
c->sample2 = c->sample1;
c->sample1 = av_clip_int16(predictor);
c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
if (c->idelta < 16) c->idelta = 16;
return c->sample1;
| true | FFmpeg | e59c28b16660b8f86ef05c7f0db4db89e62ed55f | static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)
{
int predictor;
predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
c->sample2 = c->sample1;
c->sample1 = av_clip_int16(predictor);
c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
if (c->idelta < 16) c->idelta = 16;
return c->sample1;
| {
"code": [],
"line_no": []
} | static inline short FUNC_0(ADPCMChannelStatus *VAR_0, int VAR_1)
{
int VAR_2;
VAR_2 = (((VAR_0->sample1) * (VAR_0->coeff1)) + ((VAR_0->sample2) * (VAR_0->coeff2))) / 64;
VAR_2 += ((VAR_1 & 0x08)?(VAR_1 - 0x10):(VAR_1)) * VAR_0->idelta;
VAR_0->sample2 = VAR_0->sample1;
VAR_0->sample1 = av_clip_int16(VAR_2);
VAR_0->idelta = (ff_adpcm_AdaptationTable[(int)VAR_1] * VAR_0->idelta) >> 8;
if (VAR_0->idelta < 16) VAR_0->idelta = 16;
return VAR_0->sample1;
| [
"static inline short FUNC_0(ADPCMChannelStatus *VAR_0, int VAR_1)\n{",
"int VAR_2;",
"VAR_2 = (((VAR_0->sample1) * (VAR_0->coeff1)) + ((VAR_0->sample2) * (VAR_0->coeff2))) / 64;",
"VAR_2 += ((VAR_1 & 0x08)?(VAR_1 - 0x10):(VAR_1)) * VAR_0->idelta;",
"VAR_0->sample2 = VAR_0->sample1;",
"VAR_0->sample1 = av_clip_int16(VAR_2);",
"VAR_0->idelta = (ff_adpcm_AdaptationTable[(int)VAR_1] * VAR_0->idelta) >> 8;",
"if (VAR_0->idelta < 16) VAR_0->idelta = 16;",
"return VAR_0->sample1;"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
29
]
] |
20,579 | static int __qemu_rdma_add_block(RDMAContext *rdma, void *host_addr,
ram_addr_t block_offset, uint64_t length)
{
RDMALocalBlocks *local = &rdma->local_ram_blocks;
RDMALocalBlock *block = g_hash_table_lookup(rdma->blockmap,
(void *) block_offset);
RDMALocalBlock *old = local->block;
assert(block == NULL);
local->block = g_malloc0(sizeof(RDMALocalBlock) * (local->nb_blocks + 1));
if (local->nb_blocks) {
int x;
for (x = 0; x < local->nb_blocks; x++) {
g_hash_table_remove(rdma->blockmap, (void *)old[x].offset);
g_hash_table_insert(rdma->blockmap, (void *)old[x].offset,
&local->block[x]);
}
memcpy(local->block, old, sizeof(RDMALocalBlock) * local->nb_blocks);
g_free(old);
}
block = &local->block[local->nb_blocks];
block->local_host_addr = host_addr;
block->offset = block_offset;
block->length = length;
block->index = local->nb_blocks;
block->nb_chunks = ram_chunk_index(host_addr, host_addr + length) + 1UL;
block->transit_bitmap = bitmap_new(block->nb_chunks);
bitmap_clear(block->transit_bitmap, 0, block->nb_chunks);
block->unregister_bitmap = bitmap_new(block->nb_chunks);
bitmap_clear(block->unregister_bitmap, 0, block->nb_chunks);
block->remote_keys = g_malloc0(block->nb_chunks * sizeof(uint32_t));
block->is_ram_block = local->init ? false : true;
g_hash_table_insert(rdma->blockmap, (void *) block_offset, block);
DDPRINTF("Added Block: %d, addr: %" PRIu64 ", offset: %" PRIu64
" length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d\n",
local->nb_blocks, (uint64_t) block->local_host_addr, block->offset,
block->length, (uint64_t) (block->local_host_addr + block->length),
BITS_TO_LONGS(block->nb_chunks) *
sizeof(unsigned long) * 8, block->nb_chunks);
local->nb_blocks++;
return 0;
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | static int __qemu_rdma_add_block(RDMAContext *rdma, void *host_addr,
ram_addr_t block_offset, uint64_t length)
{
RDMALocalBlocks *local = &rdma->local_ram_blocks;
RDMALocalBlock *block = g_hash_table_lookup(rdma->blockmap,
(void *) block_offset);
RDMALocalBlock *old = local->block;
assert(block == NULL);
local->block = g_malloc0(sizeof(RDMALocalBlock) * (local->nb_blocks + 1));
if (local->nb_blocks) {
int x;
for (x = 0; x < local->nb_blocks; x++) {
g_hash_table_remove(rdma->blockmap, (void *)old[x].offset);
g_hash_table_insert(rdma->blockmap, (void *)old[x].offset,
&local->block[x]);
}
memcpy(local->block, old, sizeof(RDMALocalBlock) * local->nb_blocks);
g_free(old);
}
block = &local->block[local->nb_blocks];
block->local_host_addr = host_addr;
block->offset = block_offset;
block->length = length;
block->index = local->nb_blocks;
block->nb_chunks = ram_chunk_index(host_addr, host_addr + length) + 1UL;
block->transit_bitmap = bitmap_new(block->nb_chunks);
bitmap_clear(block->transit_bitmap, 0, block->nb_chunks);
block->unregister_bitmap = bitmap_new(block->nb_chunks);
bitmap_clear(block->unregister_bitmap, 0, block->nb_chunks);
block->remote_keys = g_malloc0(block->nb_chunks * sizeof(uint32_t));
block->is_ram_block = local->init ? false : true;
g_hash_table_insert(rdma->blockmap, (void *) block_offset, block);
DDPRINTF("Added Block: %d, addr: %" PRIu64 ", offset: %" PRIu64
" length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d\n",
local->nb_blocks, (uint64_t) block->local_host_addr, block->offset,
block->length, (uint64_t) (block->local_host_addr + block->length),
BITS_TO_LONGS(block->nb_chunks) *
sizeof(unsigned long) * 8, block->nb_chunks);
local->nb_blocks++;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(RDMAContext *VAR_0, void *VAR_1,
ram_addr_t VAR_2, uint64_t VAR_3)
{
RDMALocalBlocks *local = &VAR_0->local_ram_blocks;
RDMALocalBlock *block = g_hash_table_lookup(VAR_0->blockmap,
(void *) VAR_2);
RDMALocalBlock *old = local->block;
assert(block == NULL);
local->block = g_malloc0(sizeof(RDMALocalBlock) * (local->nb_blocks + 1));
if (local->nb_blocks) {
int VAR_4;
for (VAR_4 = 0; VAR_4 < local->nb_blocks; VAR_4++) {
g_hash_table_remove(VAR_0->blockmap, (void *)old[VAR_4].offset);
g_hash_table_insert(VAR_0->blockmap, (void *)old[VAR_4].offset,
&local->block[VAR_4]);
}
memcpy(local->block, old, sizeof(RDMALocalBlock) * local->nb_blocks);
g_free(old);
}
block = &local->block[local->nb_blocks];
block->local_host_addr = VAR_1;
block->offset = VAR_2;
block->VAR_3 = VAR_3;
block->index = local->nb_blocks;
block->nb_chunks = ram_chunk_index(VAR_1, VAR_1 + VAR_3) + 1UL;
block->transit_bitmap = bitmap_new(block->nb_chunks);
bitmap_clear(block->transit_bitmap, 0, block->nb_chunks);
block->unregister_bitmap = bitmap_new(block->nb_chunks);
bitmap_clear(block->unregister_bitmap, 0, block->nb_chunks);
block->remote_keys = g_malloc0(block->nb_chunks * sizeof(uint32_t));
block->is_ram_block = local->init ? false : true;
g_hash_table_insert(VAR_0->blockmap, (void *) VAR_2, block);
DDPRINTF("Added Block: %d, addr: %" PRIu64 ", offset: %" PRIu64
" VAR_3: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d\n",
local->nb_blocks, (uint64_t) block->local_host_addr, block->offset,
block->VAR_3, (uint64_t) (block->local_host_addr + block->VAR_3),
BITS_TO_LONGS(block->nb_chunks) *
sizeof(unsigned long) * 8, block->nb_chunks);
local->nb_blocks++;
return 0;
}
| [
"static int FUNC_0(RDMAContext *VAR_0, void *VAR_1,\nram_addr_t VAR_2, uint64_t VAR_3)\n{",
"RDMALocalBlocks *local = &VAR_0->local_ram_blocks;",
"RDMALocalBlock *block = g_hash_table_lookup(VAR_0->blockmap,\n(void *) VAR_2);",
"RDMALocalBlock *old = local->block;",
"assert(block == NULL);",
"local->block = g_malloc0(sizeof(RDMALocalBlock) * (local->nb_blocks + 1));",
"if (local->nb_blocks) {",
"int VAR_4;",
"for (VAR_4 = 0; VAR_4 < local->nb_blocks; VAR_4++) {",
"g_hash_table_remove(VAR_0->blockmap, (void *)old[VAR_4].offset);",
"g_hash_table_insert(VAR_0->blockmap, (void *)old[VAR_4].offset,\n&local->block[VAR_4]);",
"}",
"memcpy(local->block, old, sizeof(RDMALocalBlock) * local->nb_blocks);",
"g_free(old);",
"}",
"block = &local->block[local->nb_blocks];",
"block->local_host_addr = VAR_1;",
"block->offset = VAR_2;",
"block->VAR_3 = VAR_3;",
"block->index = local->nb_blocks;",
"block->nb_chunks = ram_chunk_index(VAR_1, VAR_1 + VAR_3) + 1UL;",
"block->transit_bitmap = bitmap_new(block->nb_chunks);",
"bitmap_clear(block->transit_bitmap, 0, block->nb_chunks);",
"block->unregister_bitmap = bitmap_new(block->nb_chunks);",
"bitmap_clear(block->unregister_bitmap, 0, block->nb_chunks);",
"block->remote_keys = g_malloc0(block->nb_chunks * sizeof(uint32_t));",
"block->is_ram_block = local->init ? false : true;",
"g_hash_table_insert(VAR_0->blockmap, (void *) VAR_2, block);",
"DDPRINTF(\"Added Block: %d, addr: %\" PRIu64 \", offset: %\" PRIu64\n\" VAR_3: %\" PRIu64 \" end: %\" PRIu64 \" bits %\" PRIu64 \" chunks %d\\n\",\nlocal->nb_blocks, (uint64_t) block->local_host_addr, block->offset,\nblock->VAR_3, (uint64_t) (block->local_host_addr + block->VAR_3),\nBITS_TO_LONGS(block->nb_chunks) *\nsizeof(unsigned long) * 8, block->nb_chunks);",
"local->nb_blocks++;",
"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
] | [
[
1,
3,
5
],
[
7
],
[
9,
11
],
[
13
],
[
17
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
79
],
[
83,
85,
87,
89,
91,
93
],
[
97
],
[
101
],
[
103
]
] |
20,580 | void ff_lzw_decode_tail(LZWState *p)
{
struct LZWState *s = (struct LZWState *)p;
while(!s->eob_reached)
lzw_get_code(s);
}
| true | FFmpeg | 5f01beb54846de8764c15206aa63086238dde493 | void ff_lzw_decode_tail(LZWState *p)
{
struct LZWState *s = (struct LZWState *)p;
while(!s->eob_reached)
lzw_get_code(s);
}
| {
"code": [
" while(!s->eob_reached)",
" lzw_get_code(s);"
],
"line_no": [
7,
9
]
} | void FUNC_0(LZWState *VAR_0)
{
struct LZWState *VAR_1 = (struct LZWState *)VAR_0;
while(!VAR_1->eob_reached)
lzw_get_code(VAR_1);
}
| [
"void FUNC_0(LZWState *VAR_0)\n{",
"struct LZWState *VAR_1 = (struct LZWState *)VAR_0;",
"while(!VAR_1->eob_reached)\nlzw_get_code(VAR_1);",
"}"
] | [
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
11
]
] |
20,582 | static void x86_cpu_unrealizefn(DeviceState *dev, Error **errp)
{
X86CPU *cpu = X86_CPU(dev);
#ifndef CONFIG_USER_ONLY
cpu_remove_sync(CPU(dev));
qemu_unregister_reset(x86_cpu_machine_reset_cb, dev);
#endif
if (cpu->apic_state) {
object_unparent(OBJECT(cpu->apic_state));
cpu->apic_state = NULL;
}
xcc->parent_unrealize(dev, &local_err);
if (local_err != NULL) {
error_propagate(errp, local_err);
return;
}
} | true | qemu | 7bbc124e7e8fb544288ccd1f5185643a7d0554b8 | static void x86_cpu_unrealizefn(DeviceState *dev, Error **errp)
{
X86CPU *cpu = X86_CPU(dev);
#ifndef CONFIG_USER_ONLY
cpu_remove_sync(CPU(dev));
qemu_unregister_reset(x86_cpu_machine_reset_cb, dev);
#endif
if (cpu->apic_state) {
object_unparent(OBJECT(cpu->apic_state));
cpu->apic_state = NULL;
}
xcc->parent_unrealize(dev, &local_err);
if (local_err != NULL) {
error_propagate(errp, local_err);
return;
}
} | {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
X86CPU *cpu = X86_CPU(VAR_0);
#ifndef CONFIG_USER_ONLY
cpu_remove_sync(CPU(VAR_0));
qemu_unregister_reset(x86_cpu_machine_reset_cb, VAR_0);
#endif
if (cpu->apic_state) {
object_unparent(OBJECT(cpu->apic_state));
cpu->apic_state = NULL;
}
xcc->parent_unrealize(VAR_0, &local_err);
if (local_err != NULL) {
error_propagate(VAR_1, local_err);
return;
}
} | [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"X86CPU *cpu = X86_CPU(VAR_0);",
"#ifndef CONFIG_USER_ONLY\ncpu_remove_sync(CPU(VAR_0));",
"qemu_unregister_reset(x86_cpu_machine_reset_cb, VAR_0);",
"#endif\nif (cpu->apic_state) {",
"object_unparent(OBJECT(cpu->apic_state));",
"cpu->apic_state = NULL;",
"}",
"xcc->parent_unrealize(VAR_0, &local_err);",
"if (local_err != NULL) {",
"error_propagate(VAR_1, local_err);",
"return;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
11,
13
],
[
15
],
[
17,
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
]
] |
20,583 | static int net_tap_init(VLANState *vlan, const char *model,
const char *name, const char *ifname1,
const char *setup_script, const char *down_script)
{
TAPState *s;
int fd;
char ifname[128];
if (ifname1 != NULL)
pstrcpy(ifname, sizeof(ifname), ifname1);
else
ifname[0] = '\0';
TFR(fd = tap_open(ifname, sizeof(ifname)));
if (fd < 0)
return -1;
if (!setup_script || !strcmp(setup_script, "no"))
setup_script = "";
if (setup_script[0] != '\0') {
if (launch_script(setup_script, ifname, fd))
return -1;
}
s = net_tap_fd_init(vlan, model, name, fd);
if (!s)
return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"ifname=%s,script=%s,downscript=%s",
ifname, setup_script, down_script);
if (down_script && strcmp(down_script, "no")) {
snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
}
return 0;
}
| true | qemu | 9036de1a8ad6c565a4e5d8cd124ad8dd05e7d4d4 | static int net_tap_init(VLANState *vlan, const char *model,
const char *name, const char *ifname1,
const char *setup_script, const char *down_script)
{
TAPState *s;
int fd;
char ifname[128];
if (ifname1 != NULL)
pstrcpy(ifname, sizeof(ifname), ifname1);
else
ifname[0] = '\0';
TFR(fd = tap_open(ifname, sizeof(ifname)));
if (fd < 0)
return -1;
if (!setup_script || !strcmp(setup_script, "no"))
setup_script = "";
if (setup_script[0] != '\0') {
if (launch_script(setup_script, ifname, fd))
return -1;
}
s = net_tap_fd_init(vlan, model, name, fd);
if (!s)
return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"ifname=%s,script=%s,downscript=%s",
ifname, setup_script, down_script);
if (down_script && strcmp(down_script, "no")) {
snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
}
return 0;
}
| {
"code": [
" if (!s)",
" return -1;",
" return -1;"
],
"line_no": [
47,
29,
29
]
} | static int FUNC_0(VLANState *VAR_0, const char *VAR_1,
const char *VAR_2, const char *VAR_3,
const char *VAR_4, const char *VAR_5)
{
TAPState *s;
int VAR_6;
char VAR_7[128];
if (VAR_3 != NULL)
pstrcpy(VAR_7, sizeof(VAR_7), VAR_3);
else
VAR_7[0] = '\0';
TFR(VAR_6 = tap_open(VAR_7, sizeof(VAR_7)));
if (VAR_6 < 0)
return -1;
if (!VAR_4 || !strcmp(VAR_4, "no"))
VAR_4 = "";
if (VAR_4[0] != '\0') {
if (launch_script(VAR_4, VAR_7, VAR_6))
return -1;
}
s = net_tap_fd_init(VAR_0, VAR_1, VAR_2, VAR_6);
if (!s)
return -1;
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
"VAR_7=%s,script=%s,downscript=%s",
VAR_7, VAR_4, VAR_5);
if (VAR_5 && strcmp(VAR_5, "no")) {
snprintf(s->VAR_5, sizeof(s->VAR_5), "%s", VAR_5);
snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", VAR_7);
}
return 0;
}
| [
"static int FUNC_0(VLANState *VAR_0, const char *VAR_1,\nconst char *VAR_2, const char *VAR_3,\nconst char *VAR_4, const char *VAR_5)\n{",
"TAPState *s;",
"int VAR_6;",
"char VAR_7[128];",
"if (VAR_3 != NULL)\npstrcpy(VAR_7, sizeof(VAR_7), VAR_3);",
"else\nVAR_7[0] = '\\0';",
"TFR(VAR_6 = tap_open(VAR_7, sizeof(VAR_7)));",
"if (VAR_6 < 0)\nreturn -1;",
"if (!VAR_4 || !strcmp(VAR_4, \"no\"))\nVAR_4 = \"\";",
"if (VAR_4[0] != '\\0') {",
"if (launch_script(VAR_4, VAR_7, VAR_6))\nreturn -1;",
"}",
"s = net_tap_fd_init(VAR_0, VAR_1, VAR_2, VAR_6);",
"if (!s)\nreturn -1;",
"snprintf(s->vc->info_str, sizeof(s->vc->info_str),\n\"VAR_7=%s,script=%s,downscript=%s\",\nVAR_7, VAR_4, VAR_5);",
"if (VAR_5 && strcmp(VAR_5, \"no\")) {",
"snprintf(s->VAR_5, sizeof(s->VAR_5), \"%s\", VAR_5);",
"snprintf(s->down_script_arg, sizeof(s->down_script_arg), \"%s\", VAR_7);",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
17,
19
],
[
21,
23
],
[
25
],
[
27,
29
],
[
33,
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47,
49
],
[
51,
53,
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
]
] |
20,584 | static void ide_test_start(const char *cmdline_fmt, ...)
{
va_list ap;
char *cmdline;
va_start(ap, cmdline_fmt);
cmdline = g_strdup_vprintf(cmdline_fmt, ap);
va_end(ap);
qtest_start(cmdline);
qtest_irq_intercept_in(global_qtest, "ioapic");
guest_malloc = pc_alloc_init();
} | true | qemu | e42de189e8eaf3dc93f22e88beca4f5b62ef336c | static void ide_test_start(const char *cmdline_fmt, ...)
{
va_list ap;
char *cmdline;
va_start(ap, cmdline_fmt);
cmdline = g_strdup_vprintf(cmdline_fmt, ap);
va_end(ap);
qtest_start(cmdline);
qtest_irq_intercept_in(global_qtest, "ioapic");
guest_malloc = pc_alloc_init();
} | {
"code": [],
"line_no": []
} | static void FUNC_0(const char *VAR_0, ...)
{
va_list ap;
char *VAR_1;
va_start(ap, VAR_0);
VAR_1 = g_strdup_vprintf(VAR_0, ap);
va_end(ap);
qtest_start(VAR_1);
qtest_irq_intercept_in(global_qtest, "ioapic");
guest_malloc = pc_alloc_init();
} | [
"static void FUNC_0(const char *VAR_0, ...)\n{",
"va_list ap;",
"char *VAR_1;",
"va_start(ap, VAR_0);",
"VAR_1 = g_strdup_vprintf(VAR_0, ap);",
"va_end(ap);",
"qtest_start(VAR_1);",
"qtest_irq_intercept_in(global_qtest, \"ioapic\");",
"guest_malloc = pc_alloc_init();",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
]
] |
20,585 | static int parse_cookie(HTTPContext *s, const char *p, AVDictionary **cookies)
{
AVDictionary *new_params = NULL;
AVDictionaryEntry *e, *cookie_entry;
char *eql, *name;
// ensure the cookie is parsable
if (parse_set_cookie(p, &new_params))
return -1;
// if there is no cookie value there is nothing to parse
cookie_entry = av_dict_get(new_params, "", NULL, AV_DICT_IGNORE_SUFFIX);
if (!cookie_entry || !cookie_entry->value) {
return -1;
}
// ensure the cookie is not expired or older than an existing value
if ((e = av_dict_get(new_params, "expires", NULL, 0)) && e->value) {
struct tm new_tm = {0};
if (!parse_set_cookie_expiry_time(e->value, &new_tm)) {
AVDictionaryEntry *e2;
// if the cookie has already expired ignore it
if (av_timegm(&new_tm) < av_gettime() / 1000000) {
return -1;
}
// only replace an older cookie with the same name
e2 = av_dict_get(*cookies, cookie_entry->key, NULL, 0);
if (e2 && e2->value) {
AVDictionary *old_params = NULL;
if (!parse_set_cookie(p, &old_params)) {
e2 = av_dict_get(old_params, "expires", NULL, 0);
if (e2 && e2->value) {
struct tm old_tm = {0};
if (!parse_set_cookie_expiry_time(e->value, &old_tm)) {
if (av_timegm(&new_tm) < av_timegm(&old_tm)) {
av_dict_free(&old_params);
return -1;
}
}
}
}
av_dict_free(&old_params);
}
}
}
// duplicate the cookie name (dict will dupe the value)
if (!(eql = strchr(p, '='))) return AVERROR(EINVAL);
if (!(name = av_strndup(p, eql - p))) return AVERROR(ENOMEM);
// add the cookie to the dictionary
av_dict_set(cookies, name, eql, AV_DICT_DONT_STRDUP_KEY);
return 0;
} | true | FFmpeg | 9147c0975533c83564b1ba47f22952b291b80282 | static int parse_cookie(HTTPContext *s, const char *p, AVDictionary **cookies)
{
AVDictionary *new_params = NULL;
AVDictionaryEntry *e, *cookie_entry;
char *eql, *name;
if (parse_set_cookie(p, &new_params))
return -1;
cookie_entry = av_dict_get(new_params, "", NULL, AV_DICT_IGNORE_SUFFIX);
if (!cookie_entry || !cookie_entry->value) {
return -1;
}
if ((e = av_dict_get(new_params, "expires", NULL, 0)) && e->value) {
struct tm new_tm = {0};
if (!parse_set_cookie_expiry_time(e->value, &new_tm)) {
AVDictionaryEntry *e2;
if (av_timegm(&new_tm) < av_gettime() / 1000000) {
return -1;
}
e2 = av_dict_get(*cookies, cookie_entry->key, NULL, 0);
if (e2 && e2->value) {
AVDictionary *old_params = NULL;
if (!parse_set_cookie(p, &old_params)) {
e2 = av_dict_get(old_params, "expires", NULL, 0);
if (e2 && e2->value) {
struct tm old_tm = {0};
if (!parse_set_cookie_expiry_time(e->value, &old_tm)) {
if (av_timegm(&new_tm) < av_timegm(&old_tm)) {
av_dict_free(&old_params);
return -1;
}
}
}
}
av_dict_free(&old_params);
}
}
}
if (!(eql = strchr(p, '='))) return AVERROR(EINVAL);
if (!(name = av_strndup(p, eql - p))) return AVERROR(ENOMEM);
av_dict_set(cookies, name, eql, AV_DICT_DONT_STRDUP_KEY);
return 0;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(HTTPContext *VAR_0, const char *VAR_1, AVDictionary **VAR_2)
{
AVDictionary *new_params = NULL;
AVDictionaryEntry *e, *cookie_entry;
char *VAR_3, *VAR_4;
if (parse_set_cookie(VAR_1, &new_params))
return -1;
cookie_entry = av_dict_get(new_params, "", NULL, AV_DICT_IGNORE_SUFFIX);
if (!cookie_entry || !cookie_entry->value) {
return -1;
}
if ((e = av_dict_get(new_params, "expires", NULL, 0)) && e->value) {
struct tm VAR_5 = {0};
if (!parse_set_cookie_expiry_time(e->value, &VAR_5)) {
AVDictionaryEntry *e2;
if (av_timegm(&VAR_5) < av_gettime() / 1000000) {
return -1;
}
e2 = av_dict_get(*VAR_2, cookie_entry->key, NULL, 0);
if (e2 && e2->value) {
AVDictionary *old_params = NULL;
if (!parse_set_cookie(VAR_1, &old_params)) {
e2 = av_dict_get(old_params, "expires", NULL, 0);
if (e2 && e2->value) {
struct tm VAR_6 = {0};
if (!parse_set_cookie_expiry_time(e->value, &VAR_6)) {
if (av_timegm(&VAR_5) < av_timegm(&VAR_6)) {
av_dict_free(&old_params);
return -1;
}
}
}
}
av_dict_free(&old_params);
}
}
}
if (!(VAR_3 = strchr(VAR_1, '='))) return AVERROR(EINVAL);
if (!(VAR_4 = av_strndup(VAR_1, VAR_3 - VAR_1))) return AVERROR(ENOMEM);
av_dict_set(VAR_2, VAR_4, VAR_3, AV_DICT_DONT_STRDUP_KEY);
return 0;
} | [
"static int FUNC_0(HTTPContext *VAR_0, const char *VAR_1, AVDictionary **VAR_2)\n{",
"AVDictionary *new_params = NULL;",
"AVDictionaryEntry *e, *cookie_entry;",
"char *VAR_3, *VAR_4;",
"if (parse_set_cookie(VAR_1, &new_params))\nreturn -1;",
"cookie_entry = av_dict_get(new_params, \"\", NULL, AV_DICT_IGNORE_SUFFIX);",
"if (!cookie_entry || !cookie_entry->value) {",
"return -1;",
"}",
"if ((e = av_dict_get(new_params, \"expires\", NULL, 0)) && e->value) {",
"struct tm VAR_5 = {0};",
"if (!parse_set_cookie_expiry_time(e->value, &VAR_5)) {",
"AVDictionaryEntry *e2;",
"if (av_timegm(&VAR_5) < av_gettime() / 1000000) {",
"return -1;",
"}",
"e2 = av_dict_get(*VAR_2, cookie_entry->key, NULL, 0);",
"if (e2 && e2->value) {",
"AVDictionary *old_params = NULL;",
"if (!parse_set_cookie(VAR_1, &old_params)) {",
"e2 = av_dict_get(old_params, \"expires\", NULL, 0);",
"if (e2 && e2->value) {",
"struct tm VAR_6 = {0};",
"if (!parse_set_cookie_expiry_time(e->value, &VAR_6)) {",
"if (av_timegm(&VAR_5) < av_timegm(&VAR_6)) {",
"av_dict_free(&old_params);",
"return -1;",
"}",
"}",
"}",
"}",
"av_dict_free(&old_params);",
"}",
"}",
"}",
"if (!(VAR_3 = strchr(VAR_1, '='))) return AVERROR(EINVAL);",
"if (!(VAR_4 = av_strndup(VAR_1, VAR_3 - VAR_1))) return AVERROR(ENOMEM);",
"av_dict_set(VAR_2, VAR_4, VAR_3, AV_DICT_DONT_STRDUP_KEY);",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
15,
17
],
[
23
],
[
25
],
[
28
],
[
30
],
[
36
],
[
38
],
[
40
],
[
42
],
[
48
],
[
51
],
[
53
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
78
],
[
80
],
[
82
],
[
84
],
[
86
],
[
88
],
[
90
],
[
92
],
[
94
],
[
96
],
[
103
],
[
105
],
[
111
],
[
115
],
[
117
]
] |
20,586 | ISADevice *isa_ide_init(ISABus *bus, int iobase, int iobase2, int isairq,
DriveInfo *hd0, DriveInfo *hd1)
{
DeviceState *dev;
ISADevice *isadev;
ISAIDEState *s;
isadev = isa_create(bus, TYPE_ISA_IDE);
dev = DEVICE(isadev);
qdev_prop_set_uint32(dev, "iobase", iobase);
qdev_prop_set_uint32(dev, "iobase2", iobase2);
qdev_prop_set_uint32(dev, "irq", isairq);
if (qdev_init(dev) < 0) {
return NULL;
}
s = ISA_IDE(dev);
if (hd0) {
ide_create_drive(&s->bus, 0, hd0);
}
if (hd1) {
ide_create_drive(&s->bus, 1, hd1);
}
return isadev;
}
| true | qemu | e25b89e5208564220b9ea3a728f899b37ff6dc2d | ISADevice *isa_ide_init(ISABus *bus, int iobase, int iobase2, int isairq,
DriveInfo *hd0, DriveInfo *hd1)
{
DeviceState *dev;
ISADevice *isadev;
ISAIDEState *s;
isadev = isa_create(bus, TYPE_ISA_IDE);
dev = DEVICE(isadev);
qdev_prop_set_uint32(dev, "iobase", iobase);
qdev_prop_set_uint32(dev, "iobase2", iobase2);
qdev_prop_set_uint32(dev, "irq", isairq);
if (qdev_init(dev) < 0) {
return NULL;
}
s = ISA_IDE(dev);
if (hd0) {
ide_create_drive(&s->bus, 0, hd0);
}
if (hd1) {
ide_create_drive(&s->bus, 1, hd1);
}
return isadev;
}
| {
"code": [
" if (qdev_init(dev) < 0) {",
" return NULL;"
],
"line_no": [
25,
27
]
} | ISADevice *FUNC_0(ISABus *bus, int iobase, int iobase2, int isairq,
DriveInfo *hd0, DriveInfo *hd1)
{
DeviceState *dev;
ISADevice *isadev;
ISAIDEState *s;
isadev = isa_create(bus, TYPE_ISA_IDE);
dev = DEVICE(isadev);
qdev_prop_set_uint32(dev, "iobase", iobase);
qdev_prop_set_uint32(dev, "iobase2", iobase2);
qdev_prop_set_uint32(dev, "irq", isairq);
if (qdev_init(dev) < 0) {
return NULL;
}
s = ISA_IDE(dev);
if (hd0) {
ide_create_drive(&s->bus, 0, hd0);
}
if (hd1) {
ide_create_drive(&s->bus, 1, hd1);
}
return isadev;
}
| [
"ISADevice *FUNC_0(ISABus *bus, int iobase, int iobase2, int isairq,\nDriveInfo *hd0, DriveInfo *hd1)\n{",
"DeviceState *dev;",
"ISADevice *isadev;",
"ISAIDEState *s;",
"isadev = isa_create(bus, TYPE_ISA_IDE);",
"dev = DEVICE(isadev);",
"qdev_prop_set_uint32(dev, \"iobase\", iobase);",
"qdev_prop_set_uint32(dev, \"iobase2\", iobase2);",
"qdev_prop_set_uint32(dev, \"irq\", isairq);",
"if (qdev_init(dev) < 0) {",
"return NULL;",
"}",
"s = ISA_IDE(dev);",
"if (hd0) {",
"ide_create_drive(&s->bus, 0, hd0);",
"}",
"if (hd1) {",
"ide_create_drive(&s->bus, 1, hd1);",
"}",
"return isadev;",
"}"
] | [
0,
0,
0,
0,
0,
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
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
]
] |
20,587 | int rx_produce(World *world, uint32_t pport,
const struct iovec *iov, int iovcnt, uint8_t copy_to_cpu)
{
Rocker *r = world_rocker(world);
PCIDevice *dev = (PCIDevice *)r;
DescRing *ring = rocker_get_rx_ring_by_pport(r, pport);
DescInfo *info = desc_ring_fetch_desc(ring);
char *data;
size_t data_size = iov_size(iov, iovcnt);
char *buf;
uint16_t rx_flags = 0;
uint16_t rx_csum = 0;
size_t tlv_size;
RockerTlv *tlvs[ROCKER_TLV_RX_MAX + 1];
hwaddr frag_addr;
uint16_t frag_max_len;
int pos;
int err;
if (!info) {
return -ROCKER_ENOBUFS;
}
buf = desc_get_buf(info, false);
if (!buf) {
err = -ROCKER_ENXIO;
goto out;
}
rocker_tlv_parse(tlvs, ROCKER_TLV_RX_MAX, buf, desc_tlv_size(info));
if (!tlvs[ROCKER_TLV_RX_FRAG_ADDR] ||
!tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]) {
err = -ROCKER_EINVAL;
goto out;
}
frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_RX_FRAG_ADDR]);
frag_max_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]);
if (data_size > frag_max_len) {
err = -ROCKER_EMSGSIZE;
goto out;
}
if (copy_to_cpu) {
rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD;
}
/* XXX calc rx flags/csum */
tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) + /* flags */
rocker_tlv_total_size(sizeof(uint16_t)) + /* scum */
rocker_tlv_total_size(sizeof(uint64_t)) + /* frag addr */
rocker_tlv_total_size(sizeof(uint16_t)) + /* frag max len */
rocker_tlv_total_size(sizeof(uint16_t)); /* frag len */
if (tlv_size > desc_buf_size(info)) {
err = -ROCKER_EMSGSIZE;
goto out;
}
/* TODO:
* iov dma write can be optimized in similar way e1000 does it in
* e1000_receive_iov. But maybe if would make sense to introduce
* generic helper iov_dma_write.
*/
data = g_malloc(data_size);
if (!data) {
err = -ROCKER_ENOMEM;
goto out;
}
iov_to_buf(iov, iovcnt, 0, data, data_size);
pci_dma_write(dev, frag_addr, data, data_size);
g_free(data);
pos = 0;
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FLAGS, rx_flags);
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_CSUM, rx_csum);
rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_RX_FRAG_ADDR, frag_addr);
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_MAX_LEN, frag_max_len);
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_LEN, data_size);
err = desc_set_buf(info, tlv_size);
out:
if (desc_ring_post_desc(ring, err)) {
rocker_msix_irq(r, ROCKER_MSIX_VEC_RX(pport - 1));
}
return err;
}
| true | qemu | 107e4b352cc309f9bd7588ef1a44549200620078 | int rx_produce(World *world, uint32_t pport,
const struct iovec *iov, int iovcnt, uint8_t copy_to_cpu)
{
Rocker *r = world_rocker(world);
PCIDevice *dev = (PCIDevice *)r;
DescRing *ring = rocker_get_rx_ring_by_pport(r, pport);
DescInfo *info = desc_ring_fetch_desc(ring);
char *data;
size_t data_size = iov_size(iov, iovcnt);
char *buf;
uint16_t rx_flags = 0;
uint16_t rx_csum = 0;
size_t tlv_size;
RockerTlv *tlvs[ROCKER_TLV_RX_MAX + 1];
hwaddr frag_addr;
uint16_t frag_max_len;
int pos;
int err;
if (!info) {
return -ROCKER_ENOBUFS;
}
buf = desc_get_buf(info, false);
if (!buf) {
err = -ROCKER_ENXIO;
goto out;
}
rocker_tlv_parse(tlvs, ROCKER_TLV_RX_MAX, buf, desc_tlv_size(info));
if (!tlvs[ROCKER_TLV_RX_FRAG_ADDR] ||
!tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]) {
err = -ROCKER_EINVAL;
goto out;
}
frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_RX_FRAG_ADDR]);
frag_max_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]);
if (data_size > frag_max_len) {
err = -ROCKER_EMSGSIZE;
goto out;
}
if (copy_to_cpu) {
rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD;
}
tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) +
rocker_tlv_total_size(sizeof(uint16_t)) +
rocker_tlv_total_size(sizeof(uint64_t)) +
rocker_tlv_total_size(sizeof(uint16_t)) +
rocker_tlv_total_size(sizeof(uint16_t));
if (tlv_size > desc_buf_size(info)) {
err = -ROCKER_EMSGSIZE;
goto out;
}
data = g_malloc(data_size);
if (!data) {
err = -ROCKER_ENOMEM;
goto out;
}
iov_to_buf(iov, iovcnt, 0, data, data_size);
pci_dma_write(dev, frag_addr, data, data_size);
g_free(data);
pos = 0;
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FLAGS, rx_flags);
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_CSUM, rx_csum);
rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_RX_FRAG_ADDR, frag_addr);
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_MAX_LEN, frag_max_len);
rocker_tlv_put_le16(buf, &pos, ROCKER_TLV_RX_FRAG_LEN, data_size);
err = desc_set_buf(info, tlv_size);
out:
if (desc_ring_post_desc(ring, err)) {
rocker_msix_irq(r, ROCKER_MSIX_VEC_RX(pport - 1));
}
return err;
}
| {
"code": [
" if (!data) {",
" err = -ROCKER_ENOMEM;",
" goto out;",
" if (!buf) {",
" err = -ROCKER_ENOMEM;"
],
"line_no": [
137,
139,
53,
49,
139
]
} | int FUNC_0(World *VAR_0, uint32_t VAR_1,
const struct iovec *VAR_2, int VAR_3, uint8_t VAR_4)
{
Rocker *r = world_rocker(VAR_0);
PCIDevice *dev = (PCIDevice *)r;
DescRing *ring = rocker_get_rx_ring_by_pport(r, VAR_1);
DescInfo *info = desc_ring_fetch_desc(ring);
char *VAR_5;
size_t data_size = iov_size(VAR_2, VAR_3);
char *VAR_6;
uint16_t rx_flags = 0;
uint16_t rx_csum = 0;
size_t tlv_size;
RockerTlv *tlvs[ROCKER_TLV_RX_MAX + 1];
hwaddr frag_addr;
uint16_t frag_max_len;
int VAR_7;
int VAR_8;
if (!info) {
return -ROCKER_ENOBUFS;
}
VAR_6 = desc_get_buf(info, false);
if (!VAR_6) {
VAR_8 = -ROCKER_ENXIO;
goto out;
}
rocker_tlv_parse(tlvs, ROCKER_TLV_RX_MAX, VAR_6, desc_tlv_size(info));
if (!tlvs[ROCKER_TLV_RX_FRAG_ADDR] ||
!tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]) {
VAR_8 = -ROCKER_EINVAL;
goto out;
}
frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_RX_FRAG_ADDR]);
frag_max_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]);
if (data_size > frag_max_len) {
VAR_8 = -ROCKER_EMSGSIZE;
goto out;
}
if (VAR_4) {
rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD;
}
tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) +
rocker_tlv_total_size(sizeof(uint16_t)) +
rocker_tlv_total_size(sizeof(uint64_t)) +
rocker_tlv_total_size(sizeof(uint16_t)) +
rocker_tlv_total_size(sizeof(uint16_t));
if (tlv_size > desc_buf_size(info)) {
VAR_8 = -ROCKER_EMSGSIZE;
goto out;
}
VAR_5 = g_malloc(data_size);
if (!VAR_5) {
VAR_8 = -ROCKER_ENOMEM;
goto out;
}
iov_to_buf(VAR_2, VAR_3, 0, VAR_5, data_size);
pci_dma_write(dev, frag_addr, VAR_5, data_size);
g_free(VAR_5);
VAR_7 = 0;
rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_FLAGS, rx_flags);
rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_CSUM, rx_csum);
rocker_tlv_put_le64(VAR_6, &VAR_7, ROCKER_TLV_RX_FRAG_ADDR, frag_addr);
rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_FRAG_MAX_LEN, frag_max_len);
rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_FRAG_LEN, data_size);
VAR_8 = desc_set_buf(info, tlv_size);
out:
if (desc_ring_post_desc(ring, VAR_8)) {
rocker_msix_irq(r, ROCKER_MSIX_VEC_RX(VAR_1 - 1));
}
return VAR_8;
}
| [
"int FUNC_0(World *VAR_0, uint32_t VAR_1,\nconst struct iovec *VAR_2, int VAR_3, uint8_t VAR_4)\n{",
"Rocker *r = world_rocker(VAR_0);",
"PCIDevice *dev = (PCIDevice *)r;",
"DescRing *ring = rocker_get_rx_ring_by_pport(r, VAR_1);",
"DescInfo *info = desc_ring_fetch_desc(ring);",
"char *VAR_5;",
"size_t data_size = iov_size(VAR_2, VAR_3);",
"char *VAR_6;",
"uint16_t rx_flags = 0;",
"uint16_t rx_csum = 0;",
"size_t tlv_size;",
"RockerTlv *tlvs[ROCKER_TLV_RX_MAX + 1];",
"hwaddr frag_addr;",
"uint16_t frag_max_len;",
"int VAR_7;",
"int VAR_8;",
"if (!info) {",
"return -ROCKER_ENOBUFS;",
"}",
"VAR_6 = desc_get_buf(info, false);",
"if (!VAR_6) {",
"VAR_8 = -ROCKER_ENXIO;",
"goto out;",
"}",
"rocker_tlv_parse(tlvs, ROCKER_TLV_RX_MAX, VAR_6, desc_tlv_size(info));",
"if (!tlvs[ROCKER_TLV_RX_FRAG_ADDR] ||\n!tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]) {",
"VAR_8 = -ROCKER_EINVAL;",
"goto out;",
"}",
"frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_RX_FRAG_ADDR]);",
"frag_max_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_RX_FRAG_MAX_LEN]);",
"if (data_size > frag_max_len) {",
"VAR_8 = -ROCKER_EMSGSIZE;",
"goto out;",
"}",
"if (VAR_4) {",
"rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD;",
"}",
"tlv_size = rocker_tlv_total_size(sizeof(uint16_t)) +\nrocker_tlv_total_size(sizeof(uint16_t)) +\nrocker_tlv_total_size(sizeof(uint64_t)) +\nrocker_tlv_total_size(sizeof(uint16_t)) +\nrocker_tlv_total_size(sizeof(uint16_t));",
"if (tlv_size > desc_buf_size(info)) {",
"VAR_8 = -ROCKER_EMSGSIZE;",
"goto out;",
"}",
"VAR_5 = g_malloc(data_size);",
"if (!VAR_5) {",
"VAR_8 = -ROCKER_ENOMEM;",
"goto out;",
"}",
"iov_to_buf(VAR_2, VAR_3, 0, VAR_5, data_size);",
"pci_dma_write(dev, frag_addr, VAR_5, data_size);",
"g_free(VAR_5);",
"VAR_7 = 0;",
"rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_FLAGS, rx_flags);",
"rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_CSUM, rx_csum);",
"rocker_tlv_put_le64(VAR_6, &VAR_7, ROCKER_TLV_RX_FRAG_ADDR, frag_addr);",
"rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_FRAG_MAX_LEN, frag_max_len);",
"rocker_tlv_put_le16(VAR_6, &VAR_7, ROCKER_TLV_RX_FRAG_LEN, data_size);",
"VAR_8 = desc_set_buf(info, tlv_size);",
"out:\nif (desc_ring_post_desc(ring, VAR_8)) {",
"rocker_msix_irq(r, ROCKER_MSIX_VEC_RX(VAR_1 - 1));",
"}",
"return VAR_8;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
101,
103,
105,
107,
109
],
[
113
],
[
115
],
[
117
],
[
119
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
171,
173
],
[
175
],
[
177
],
[
181
],
[
183
]
] |
20,588 | dshow_cycle_pins(AVFormatContext *avctx, enum dshowDeviceType devtype,
IBaseFilter *device_filter, IPin **ppin)
{
struct dshow_ctx *ctx = avctx->priv_data;
IEnumPins *pins = 0;
IPin *device_pin = NULL;
IPin *pin;
int r;
const GUID *mediatype[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };
const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
int set_format = (devtype == VideoDevice && (ctx->video_size || ctx->framerate))
|| (devtype == AudioDevice && (ctx->channels || ctx->sample_rate));
int format_set = 0;
r = IBaseFilter_EnumPins(device_filter, &pins);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not enumerate pins.\n");
return AVERROR(EIO);
}
if (!ppin) {
av_log(avctx, AV_LOG_INFO, "DirectShow %s device options\n",
devtypename);
}
while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !device_pin) {
IKsPropertySet *p = NULL;
IEnumMediaTypes *types = NULL;
PIN_INFO info = {0};
AM_MEDIA_TYPE *type;
GUID category;
DWORD r2;
IPin_QueryPinInfo(pin, &info);
IBaseFilter_Release(info.pFilter);
if (info.dir != PINDIR_OUTPUT)
goto next;
if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)
goto next;
if (IKsPropertySet_Get(p, &ROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
goto next;
if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))
goto next;
if (!ppin) {
char *buf = dup_wchar_to_utf8(info.achName);
av_log(avctx, AV_LOG_INFO, " Pin \"%s\"\n", buf);
av_free(buf);
dshow_cycle_formats(avctx, devtype, pin, NULL);
goto next;
}
if (set_format) {
dshow_cycle_formats(avctx, devtype, pin, &format_set);
if (!format_set) {
goto next;
}
}
if (IPin_EnumMediaTypes(pin, &types) != S_OK)
goto next;
IEnumMediaTypes_Reset(types);
while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK && !device_pin) {
if (IsEqualGUID(&type->majortype, mediatype[devtype])) {
device_pin = pin;
goto next;
}
CoTaskMemFree(type);
}
next:
if (types)
IEnumMediaTypes_Release(types);
if (p)
IKsPropertySet_Release(p);
if (device_pin != pin)
IPin_Release(pin);
}
IEnumPins_Release(pins);
if (ppin) {
if (set_format && !format_set) {
av_log(avctx, AV_LOG_ERROR, "Could not set %s options\n", devtypename);
return AVERROR(EIO);
}
if (!device_pin) {
av_log(avctx, AV_LOG_ERROR,
"Could not find output pin from %s capture device.\n", devtypename);
return AVERROR(EIO);
}
*ppin = device_pin;
}
return 0;
}
| true | FFmpeg | 215e197942e33d5c5749d786e938bf7abe856c1d | dshow_cycle_pins(AVFormatContext *avctx, enum dshowDeviceType devtype,
IBaseFilter *device_filter, IPin **ppin)
{
struct dshow_ctx *ctx = avctx->priv_data;
IEnumPins *pins = 0;
IPin *device_pin = NULL;
IPin *pin;
int r;
const GUID *mediatype[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };
const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
int set_format = (devtype == VideoDevice && (ctx->video_size || ctx->framerate))
|| (devtype == AudioDevice && (ctx->channels || ctx->sample_rate));
int format_set = 0;
r = IBaseFilter_EnumPins(device_filter, &pins);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not enumerate pins.\n");
return AVERROR(EIO);
}
if (!ppin) {
av_log(avctx, AV_LOG_INFO, "DirectShow %s device options\n",
devtypename);
}
while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !device_pin) {
IKsPropertySet *p = NULL;
IEnumMediaTypes *types = NULL;
PIN_INFO info = {0};
AM_MEDIA_TYPE *type;
GUID category;
DWORD r2;
IPin_QueryPinInfo(pin, &info);
IBaseFilter_Release(info.pFilter);
if (info.dir != PINDIR_OUTPUT)
goto next;
if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)
goto next;
if (IKsPropertySet_Get(p, &ROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
goto next;
if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))
goto next;
if (!ppin) {
char *buf = dup_wchar_to_utf8(info.achName);
av_log(avctx, AV_LOG_INFO, " Pin \"%s\"\n", buf);
av_free(buf);
dshow_cycle_formats(avctx, devtype, pin, NULL);
goto next;
}
if (set_format) {
dshow_cycle_formats(avctx, devtype, pin, &format_set);
if (!format_set) {
goto next;
}
}
if (IPin_EnumMediaTypes(pin, &types) != S_OK)
goto next;
IEnumMediaTypes_Reset(types);
while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK && !device_pin) {
if (IsEqualGUID(&type->majortype, mediatype[devtype])) {
device_pin = pin;
goto next;
}
CoTaskMemFree(type);
}
next:
if (types)
IEnumMediaTypes_Release(types);
if (p)
IKsPropertySet_Release(p);
if (device_pin != pin)
IPin_Release(pin);
}
IEnumPins_Release(pins);
if (ppin) {
if (set_format && !format_set) {
av_log(avctx, AV_LOG_ERROR, "Could not set %s options\n", devtypename);
return AVERROR(EIO);
}
if (!device_pin) {
av_log(avctx, AV_LOG_ERROR,
"Could not find output pin from %s capture device.\n", devtypename);
return AVERROR(EIO);
}
*ppin = device_pin;
}
return 0;
}
| {
"code": [
" while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !device_pin) {",
" while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK && !device_pin) {"
],
"line_no": [
53,
131
]
} | FUNC_0(AVFormatContext *VAR_0, enum dshowDeviceType VAR_1,
IBaseFilter *VAR_2, IPin **VAR_3)
{
struct dshow_ctx *VAR_4 = VAR_0->priv_data;
IEnumPins *pins = 0;
IPin *device_pin = NULL;
IPin *pin;
int VAR_5;
const GUID *VAR_6[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };
const char *VAR_7 = (VAR_1 == VideoDevice) ? "video" : "audio";
int VAR_8 = (VAR_1 == VideoDevice && (VAR_4->video_size || VAR_4->framerate))
|| (VAR_1 == AudioDevice && (VAR_4->channels || VAR_4->sample_rate));
int VAR_9 = 0;
VAR_5 = IBaseFilter_EnumPins(VAR_2, &pins);
if (VAR_5 != S_OK) {
av_log(VAR_0, AV_LOG_ERROR, "Could not enumerate pins.\n");
return AVERROR(EIO);
}
if (!VAR_3) {
av_log(VAR_0, AV_LOG_INFO, "DirectShow %s device options\n",
VAR_7);
}
while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !device_pin) {
IKsPropertySet *p = NULL;
IEnumMediaTypes *types = NULL;
PIN_INFO info = {0};
AM_MEDIA_TYPE *type;
GUID category;
DWORD r2;
IPin_QueryPinInfo(pin, &info);
IBaseFilter_Release(info.pFilter);
if (info.dir != PINDIR_OUTPUT)
goto next;
if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)
goto next;
if (IKsPropertySet_Get(p, &ROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
goto next;
if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))
goto next;
if (!VAR_3) {
char *VAR_10 = dup_wchar_to_utf8(info.achName);
av_log(VAR_0, AV_LOG_INFO, " Pin \"%s\"\n", VAR_10);
av_free(VAR_10);
dshow_cycle_formats(VAR_0, VAR_1, pin, NULL);
goto next;
}
if (VAR_8) {
dshow_cycle_formats(VAR_0, VAR_1, pin, &VAR_9);
if (!VAR_9) {
goto next;
}
}
if (IPin_EnumMediaTypes(pin, &types) != S_OK)
goto next;
IEnumMediaTypes_Reset(types);
while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK && !device_pin) {
if (IsEqualGUID(&type->majortype, VAR_6[VAR_1])) {
device_pin = pin;
goto next;
}
CoTaskMemFree(type);
}
next:
if (types)
IEnumMediaTypes_Release(types);
if (p)
IKsPropertySet_Release(p);
if (device_pin != pin)
IPin_Release(pin);
}
IEnumPins_Release(pins);
if (VAR_3) {
if (VAR_8 && !VAR_9) {
av_log(VAR_0, AV_LOG_ERROR, "Could not set %s options\n", VAR_7);
return AVERROR(EIO);
}
if (!device_pin) {
av_log(VAR_0, AV_LOG_ERROR,
"Could not find output pin from %s capture device.\n", VAR_7);
return AVERROR(EIO);
}
*VAR_3 = device_pin;
}
return 0;
}
| [
"FUNC_0(AVFormatContext *VAR_0, enum dshowDeviceType VAR_1,\nIBaseFilter *VAR_2, IPin **VAR_3)\n{",
"struct dshow_ctx *VAR_4 = VAR_0->priv_data;",
"IEnumPins *pins = 0;",
"IPin *device_pin = NULL;",
"IPin *pin;",
"int VAR_5;",
"const GUID *VAR_6[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };",
"const char *VAR_7 = (VAR_1 == VideoDevice) ? \"video\" : \"audio\";",
"int VAR_8 = (VAR_1 == VideoDevice && (VAR_4->video_size || VAR_4->framerate))\n|| (VAR_1 == AudioDevice && (VAR_4->channels || VAR_4->sample_rate));",
"int VAR_9 = 0;",
"VAR_5 = IBaseFilter_EnumPins(VAR_2, &pins);",
"if (VAR_5 != S_OK) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Could not enumerate pins.\\n\");",
"return AVERROR(EIO);",
"}",
"if (!VAR_3) {",
"av_log(VAR_0, AV_LOG_INFO, \"DirectShow %s device options\\n\",\nVAR_7);",
"}",
"while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !device_pin) {",
"IKsPropertySet *p = NULL;",
"IEnumMediaTypes *types = NULL;",
"PIN_INFO info = {0};",
"AM_MEDIA_TYPE *type;",
"GUID category;",
"DWORD r2;",
"IPin_QueryPinInfo(pin, &info);",
"IBaseFilter_Release(info.pFilter);",
"if (info.dir != PINDIR_OUTPUT)\ngoto next;",
"if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)\ngoto next;",
"if (IKsPropertySet_Get(p, &ROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,\nNULL, 0, &category, sizeof(GUID), &r2) != S_OK)\ngoto next;",
"if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))\ngoto next;",
"if (!VAR_3) {",
"char *VAR_10 = dup_wchar_to_utf8(info.achName);",
"av_log(VAR_0, AV_LOG_INFO, \" Pin \\\"%s\\\"\\n\", VAR_10);",
"av_free(VAR_10);",
"dshow_cycle_formats(VAR_0, VAR_1, pin, NULL);",
"goto next;",
"}",
"if (VAR_8) {",
"dshow_cycle_formats(VAR_0, VAR_1, pin, &VAR_9);",
"if (!VAR_9) {",
"goto next;",
"}",
"}",
"if (IPin_EnumMediaTypes(pin, &types) != S_OK)\ngoto next;",
"IEnumMediaTypes_Reset(types);",
"while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK && !device_pin) {",
"if (IsEqualGUID(&type->majortype, VAR_6[VAR_1])) {",
"device_pin = pin;",
"goto next;",
"}",
"CoTaskMemFree(type);",
"}",
"next:\nif (types)\nIEnumMediaTypes_Release(types);",
"if (p)\nIKsPropertySet_Release(p);",
"if (device_pin != pin)\nIPin_Release(pin);",
"}",
"IEnumPins_Release(pins);",
"if (VAR_3) {",
"if (VAR_8 && !VAR_9) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Could not set %s options\\n\", VAR_7);",
"return AVERROR(EIO);",
"}",
"if (!device_pin) {",
"av_log(VAR_0, AV_LOG_ERROR,\n\"Could not find output pin from %s capture device.\\n\", VAR_7);",
"return AVERROR(EIO);",
"}",
"*VAR_3 = device_pin;",
"}",
"return 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,
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
25,
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47,
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
71
],
[
75,
77
],
[
79,
81
],
[
83,
85,
87
],
[
89,
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
123,
125
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147,
149,
151
],
[
153,
155
],
[
157,
159
],
[
161
],
[
165
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181,
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
195
],
[
197
]
] |
20,589 | static inline int yv12touyvy_unscaled_altivec(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dstParam[], int dstStride_a[]) {
uint8_t *dst=dstParam[0] + dstStride_a[0]*srcSliceY;
// yv12toyuy2( src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0] );
uint8_t *ysrc = src[0];
uint8_t *usrc = src[1];
uint8_t *vsrc = src[2];
const int width = c->srcW;
const int height = srcSliceH;
const int lumStride = srcStride[0];
const int chromStride = srcStride[1];
const int dstStride = dstStride_a[0];
const int vertLumPerChroma = 2;
const vector unsigned char yperm = vec_lvsl(0, ysrc);
register unsigned int y;
if(width&15){
yv12touyvy( ysrc, usrc, vsrc, dst,c->srcW,srcSliceH, lumStride, chromStride, dstStride);
return srcSliceH;
}
/* this code assume:
1) dst is 16 bytes-aligned
2) dstStride is a multiple of 16
3) width is a multiple of 16
4) lum&chrom stride are multiple of 8
*/
for(y=0; y<height; y++)
{
int i;
for (i = 0; i < width - 31; i+= 32) {
const unsigned int j = i >> 1;
vector unsigned char v_yA = vec_ld(i, ysrc);
vector unsigned char v_yB = vec_ld(i + 16, ysrc);
vector unsigned char v_yC = vec_ld(i + 32, ysrc);
vector unsigned char v_y1 = vec_perm(v_yA, v_yB, yperm);
vector unsigned char v_y2 = vec_perm(v_yB, v_yC, yperm);
vector unsigned char v_uA = vec_ld(j, usrc);
vector unsigned char v_uB = vec_ld(j + 16, usrc);
vector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(j, usrc));
vector unsigned char v_vA = vec_ld(j, vsrc);
vector unsigned char v_vB = vec_ld(j + 16, vsrc);
vector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(j, vsrc));
vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
vector unsigned char v_uv_b = vec_mergel(v_u, v_v);
vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
vector unsigned char v_uyvy_2 = vec_mergeh(v_uv_b, v_y2);
vector unsigned char v_uyvy_3 = vec_mergel(v_uv_b, v_y2);
vec_st(v_uyvy_0, (i << 1), dst);
vec_st(v_uyvy_1, (i << 1) + 16, dst);
vec_st(v_uyvy_2, (i << 1) + 32, dst);
vec_st(v_uyvy_3, (i << 1) + 48, dst);
}
if (i < width) {
const unsigned int j = i >> 1;
vector unsigned char v_y1 = vec_ld(i, ysrc);
vector unsigned char v_u = vec_ld(j, usrc);
vector unsigned char v_v = vec_ld(j, vsrc);
vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
vec_st(v_uyvy_0, (i << 1), dst);
vec_st(v_uyvy_1, (i << 1) + 16, dst);
}
if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
{
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
return srcSliceH;
}
| true | FFmpeg | 6e42e6c4b410dbef8b593c2d796a5dad95f89ee4 | static inline int yv12touyvy_unscaled_altivec(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dstParam[], int dstStride_a[]) {
uint8_t *dst=dstParam[0] + dstStride_a[0]*srcSliceY;
uint8_t *ysrc = src[0];
uint8_t *usrc = src[1];
uint8_t *vsrc = src[2];
const int width = c->srcW;
const int height = srcSliceH;
const int lumStride = srcStride[0];
const int chromStride = srcStride[1];
const int dstStride = dstStride_a[0];
const int vertLumPerChroma = 2;
const vector unsigned char yperm = vec_lvsl(0, ysrc);
register unsigned int y;
if(width&15){
yv12touyvy( ysrc, usrc, vsrc, dst,c->srcW,srcSliceH, lumStride, chromStride, dstStride);
return srcSliceH;
}
for(y=0; y<height; y++)
{
int i;
for (i = 0; i < width - 31; i+= 32) {
const unsigned int j = i >> 1;
vector unsigned char v_yA = vec_ld(i, ysrc);
vector unsigned char v_yB = vec_ld(i + 16, ysrc);
vector unsigned char v_yC = vec_ld(i + 32, ysrc);
vector unsigned char v_y1 = vec_perm(v_yA, v_yB, yperm);
vector unsigned char v_y2 = vec_perm(v_yB, v_yC, yperm);
vector unsigned char v_uA = vec_ld(j, usrc);
vector unsigned char v_uB = vec_ld(j + 16, usrc);
vector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(j, usrc));
vector unsigned char v_vA = vec_ld(j, vsrc);
vector unsigned char v_vB = vec_ld(j + 16, vsrc);
vector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(j, vsrc));
vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
vector unsigned char v_uv_b = vec_mergel(v_u, v_v);
vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
vector unsigned char v_uyvy_2 = vec_mergeh(v_uv_b, v_y2);
vector unsigned char v_uyvy_3 = vec_mergel(v_uv_b, v_y2);
vec_st(v_uyvy_0, (i << 1), dst);
vec_st(v_uyvy_1, (i << 1) + 16, dst);
vec_st(v_uyvy_2, (i << 1) + 32, dst);
vec_st(v_uyvy_3, (i << 1) + 48, dst);
}
if (i < width) {
const unsigned int j = i >> 1;
vector unsigned char v_y1 = vec_ld(i, ysrc);
vector unsigned char v_u = vec_ld(j, usrc);
vector unsigned char v_v = vec_ld(j, vsrc);
vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
vec_st(v_uyvy_0, (i << 1), dst);
vec_st(v_uyvy_1, (i << 1) + 16, dst);
}
if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
{
usrc += chromStride;
vsrc += chromStride;
}
ysrc += lumStride;
dst += dstStride;
}
return srcSliceH;
}
| {
"code": [
" int srcSliceH, uint8_t* dstParam[], int dstStride_a[]) {",
" uint8_t *dst=dstParam[0] + dstStride_a[0]*srcSliceY;",
" uint8_t *ysrc = src[0];",
" uint8_t *usrc = src[1];",
" uint8_t *vsrc = src[2];",
" const int width = c->srcW;",
" const int height = srcSliceH;",
" const int lumStride = srcStride[0];",
" const int chromStride = srcStride[1];",
" const int dstStride = dstStride_a[0];",
" const vector unsigned char yperm = vec_lvsl(0, ysrc);",
" const int vertLumPerChroma = 2;",
" register unsigned int y;",
" if(width&15){",
" return srcSliceH;",
" for(y=0; y<height; y++)",
" int i;",
" for (i = 0; i < width - 31; i+= 32) {",
"\tconst unsigned int j = i >> 1;",
"\tvector unsigned char v_yA = vec_ld(i, ysrc);",
"\tvector unsigned char v_yB = vec_ld(i + 16, ysrc);",
"\tvector unsigned char v_yC = vec_ld(i + 32, ysrc);",
"\tvector unsigned char v_y1 = vec_perm(v_yA, v_yB, yperm);",
"\tvector unsigned char v_y2 = vec_perm(v_yB, v_yC, yperm);",
"\tvector unsigned char v_uA = vec_ld(j, usrc);",
"\tvector unsigned char v_uB = vec_ld(j + 16, usrc);",
"\tvector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(j, usrc));",
"\tvector unsigned char v_vA = vec_ld(j, vsrc);",
"\tvector unsigned char v_vB = vec_ld(j + 16, vsrc);",
"\tvector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(j, vsrc));",
"\tvector unsigned char v_uv_a = vec_mergeh(v_u, v_v);",
"\tvector unsigned char v_uv_b = vec_mergel(v_u, v_v);",
" if (i < width) {",
"\tconst unsigned int j = i >> 1;",
"\tvector unsigned char v_y1 = vec_ld(i, ysrc);",
"\tvector unsigned char v_u = vec_ld(j, usrc);",
"\tvector unsigned char v_v = vec_ld(j, vsrc);",
"\tvector unsigned char v_uv_a = vec_mergeh(v_u, v_v);",
" if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )",
"\t usrc += chromStride;",
"\t vsrc += chromStride;",
" ysrc += lumStride;",
" dst += dstStride;",
" return srcSliceH;",
" int srcSliceH, uint8_t* dstParam[], int dstStride_a[]) {",
" uint8_t *dst=dstParam[0] + dstStride_a[0]*srcSliceY;",
" uint8_t *ysrc = src[0];",
" uint8_t *usrc = src[1];",
" uint8_t *vsrc = src[2];",
" const int width = c->srcW;",
" const int height = srcSliceH;",
" const int lumStride = srcStride[0];",
" const int chromStride = srcStride[1];",
" const int dstStride = dstStride_a[0];",
" const int vertLumPerChroma = 2;",
" const vector unsigned char yperm = vec_lvsl(0, ysrc);",
" register unsigned int y;",
" if(width&15){",
" yv12touyvy( ysrc, usrc, vsrc, dst,c->srcW,srcSliceH, lumStride, chromStride, dstStride);",
" return srcSliceH;",
" for(y=0; y<height; y++)",
" int i;",
" for (i = 0; i < width - 31; i+= 32) {",
"\tconst unsigned int j = i >> 1;",
"\tvector unsigned char v_yA = vec_ld(i, ysrc);",
"\tvector unsigned char v_yB = vec_ld(i + 16, ysrc);",
"\tvector unsigned char v_yC = vec_ld(i + 32, ysrc);",
"\tvector unsigned char v_y1 = vec_perm(v_yA, v_yB, yperm);",
"\tvector unsigned char v_y2 = vec_perm(v_yB, v_yC, yperm);",
"\tvector unsigned char v_uA = vec_ld(j, usrc);",
"\tvector unsigned char v_uB = vec_ld(j + 16, usrc);",
"\tvector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(j, usrc));",
"\tvector unsigned char v_vA = vec_ld(j, vsrc);",
"\tvector unsigned char v_vB = vec_ld(j + 16, vsrc);",
"\tvector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(j, vsrc));",
"\tvector unsigned char v_uv_a = vec_mergeh(v_u, v_v);",
"\tvector unsigned char v_uv_b = vec_mergel(v_u, v_v);",
"\tvector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);",
"\tvector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);",
"\tvector unsigned char v_uyvy_2 = vec_mergeh(v_uv_b, v_y2);",
"\tvector unsigned char v_uyvy_3 = vec_mergel(v_uv_b, v_y2);",
"\tvec_st(v_uyvy_0, (i << 1), dst);",
"\tvec_st(v_uyvy_1, (i << 1) + 16, dst);",
"\tvec_st(v_uyvy_2, (i << 1) + 32, dst);",
"\tvec_st(v_uyvy_3, (i << 1) + 48, dst);",
" if (i < width) {",
"\tconst unsigned int j = i >> 1;",
"\tvector unsigned char v_y1 = vec_ld(i, ysrc);",
"\tvector unsigned char v_u = vec_ld(j, usrc);",
"\tvector unsigned char v_v = vec_ld(j, vsrc);",
"\tvector unsigned char v_uv_a = vec_mergeh(v_u, v_v);",
"\tvector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);",
"\tvector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);",
"\tvec_st(v_uyvy_0, (i << 1), dst);",
"\tvec_st(v_uyvy_1, (i << 1) + 16, dst);",
" if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )",
"\t usrc += chromStride;",
"\t vsrc += chromStride;",
" ysrc += lumStride;",
" dst += dstStride;",
" return srcSliceH;"
],
"line_no": [
3,
5,
9,
11,
13,
15,
17,
19,
21,
23,
27,
25,
29,
33,
37,
59,
63,
65,
67,
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93,
113,
67,
117,
119,
121,
91,
135,
139,
141,
145,
147,
151,
3,
5,
9,
11,
13,
15,
17,
19,
21,
23,
25,
27,
29,
33,
35,
37,
59,
63,
65,
67,
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93,
95,
97,
99,
101,
103,
105,
107,
109,
113,
67,
117,
119,
121,
91,
95,
97,
103,
105,
135,
139,
141,
145,
147,
151
]
} | static inline int FUNC_0(SwsContext *VAR_0, uint8_t* VAR_1[], int VAR_2[], int VAR_3,
int VAR_4, uint8_t* VAR_5[], int VAR_6[]) {
uint8_t *dst=VAR_5[0] + VAR_6[0]*VAR_3;
uint8_t *ysrc = VAR_1[0];
uint8_t *usrc = VAR_1[1];
uint8_t *vsrc = VAR_1[2];
const int VAR_7 = VAR_0->srcW;
const int VAR_8 = VAR_4;
const int VAR_9 = VAR_2[0];
const int VAR_10 = VAR_2[1];
const int VAR_11 = VAR_6[0];
const int VAR_12 = 2;
const vector unsigned char VAR_13 = vec_lvsl(0, ysrc);
register unsigned int VAR_14;
if(VAR_7&15){
yv12touyvy( ysrc, usrc, vsrc, dst,VAR_0->srcW,VAR_4, VAR_9, VAR_10, VAR_11);
return VAR_4;
}
for(VAR_14=0; VAR_14<VAR_8; VAR_14++)
{
int VAR_15;
for (VAR_15 = 0; VAR_15 < VAR_7 - 31; VAR_15+= 32) {
const unsigned int VAR_17 = VAR_15 >> 1;
vector unsigned char v_yA = vec_ld(VAR_15, ysrc);
vector unsigned char v_yB = vec_ld(VAR_15 + 16, ysrc);
vector unsigned char v_yC = vec_ld(VAR_15 + 32, ysrc);
vector unsigned char v_y1 = vec_perm(v_yA, v_yB, VAR_13);
vector unsigned char v_y2 = vec_perm(v_yB, v_yC, VAR_13);
vector unsigned char v_uA = vec_ld(VAR_17, usrc);
vector unsigned char v_uB = vec_ld(VAR_17 + 16, usrc);
vector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(VAR_17, usrc));
vector unsigned char v_vA = vec_ld(VAR_17, vsrc);
vector unsigned char v_vB = vec_ld(VAR_17 + 16, vsrc);
vector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(VAR_17, vsrc));
vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
vector unsigned char v_uv_b = vec_mergel(v_u, v_v);
vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
vector unsigned char v_uyvy_2 = vec_mergeh(v_uv_b, v_y2);
vector unsigned char v_uyvy_3 = vec_mergel(v_uv_b, v_y2);
vec_st(v_uyvy_0, (VAR_15 << 1), dst);
vec_st(v_uyvy_1, (VAR_15 << 1) + 16, dst);
vec_st(v_uyvy_2, (VAR_15 << 1) + 32, dst);
vec_st(v_uyvy_3, (VAR_15 << 1) + 48, dst);
}
if (VAR_15 < VAR_7) {
const unsigned int VAR_17 = VAR_15 >> 1;
vector unsigned char v_y1 = vec_ld(VAR_15, ysrc);
vector unsigned char v_u = vec_ld(VAR_17, usrc);
vector unsigned char v_v = vec_ld(VAR_17, vsrc);
vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
vec_st(v_uyvy_0, (VAR_15 << 1), dst);
vec_st(v_uyvy_1, (VAR_15 << 1) + 16, dst);
}
if((VAR_14&(VAR_12-1))==(VAR_12-1) )
{
usrc += VAR_10;
vsrc += VAR_10;
}
ysrc += VAR_9;
dst += VAR_11;
}
return VAR_4;
}
| [
"static inline int FUNC_0(SwsContext *VAR_0, uint8_t* VAR_1[], int VAR_2[], int VAR_3,\nint VAR_4, uint8_t* VAR_5[], int VAR_6[]) {",
"uint8_t *dst=VAR_5[0] + VAR_6[0]*VAR_3;",
"uint8_t *ysrc = VAR_1[0];",
"uint8_t *usrc = VAR_1[1];",
"uint8_t *vsrc = VAR_1[2];",
"const int VAR_7 = VAR_0->srcW;",
"const int VAR_8 = VAR_4;",
"const int VAR_9 = VAR_2[0];",
"const int VAR_10 = VAR_2[1];",
"const int VAR_11 = VAR_6[0];",
"const int VAR_12 = 2;",
"const vector unsigned char VAR_13 = vec_lvsl(0, ysrc);",
"register unsigned int VAR_14;",
"if(VAR_7&15){",
"yv12touyvy( ysrc, usrc, vsrc, dst,VAR_0->srcW,VAR_4, VAR_9, VAR_10, VAR_11);",
"return VAR_4;",
"}",
"for(VAR_14=0; VAR_14<VAR_8; VAR_14++)",
"{",
"int VAR_15;",
"for (VAR_15 = 0; VAR_15 < VAR_7 - 31; VAR_15+= 32) {",
"const unsigned int VAR_17 = VAR_15 >> 1;",
"vector unsigned char v_yA = vec_ld(VAR_15, ysrc);",
"vector unsigned char v_yB = vec_ld(VAR_15 + 16, ysrc);",
"vector unsigned char v_yC = vec_ld(VAR_15 + 32, ysrc);",
"vector unsigned char v_y1 = vec_perm(v_yA, v_yB, VAR_13);",
"vector unsigned char v_y2 = vec_perm(v_yB, v_yC, VAR_13);",
"vector unsigned char v_uA = vec_ld(VAR_17, usrc);",
"vector unsigned char v_uB = vec_ld(VAR_17 + 16, usrc);",
"vector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(VAR_17, usrc));",
"vector unsigned char v_vA = vec_ld(VAR_17, vsrc);",
"vector unsigned char v_vB = vec_ld(VAR_17 + 16, vsrc);",
"vector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(VAR_17, vsrc));",
"vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);",
"vector unsigned char v_uv_b = vec_mergel(v_u, v_v);",
"vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);",
"vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);",
"vector unsigned char v_uyvy_2 = vec_mergeh(v_uv_b, v_y2);",
"vector unsigned char v_uyvy_3 = vec_mergel(v_uv_b, v_y2);",
"vec_st(v_uyvy_0, (VAR_15 << 1), dst);",
"vec_st(v_uyvy_1, (VAR_15 << 1) + 16, dst);",
"vec_st(v_uyvy_2, (VAR_15 << 1) + 32, dst);",
"vec_st(v_uyvy_3, (VAR_15 << 1) + 48, dst);",
"}",
"if (VAR_15 < VAR_7) {",
"const unsigned int VAR_17 = VAR_15 >> 1;",
"vector unsigned char v_y1 = vec_ld(VAR_15, ysrc);",
"vector unsigned char v_u = vec_ld(VAR_17, usrc);",
"vector unsigned char v_v = vec_ld(VAR_17, vsrc);",
"vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);",
"vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);",
"vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);",
"vec_st(v_uyvy_0, (VAR_15 << 1), dst);",
"vec_st(v_uyvy_1, (VAR_15 << 1) + 16, dst);",
"}",
"if((VAR_14&(VAR_12-1))==(VAR_12-1) )\n{",
"usrc += VAR_10;",
"vsrc += VAR_10;",
"}",
"ysrc += VAR_9;",
"dst += VAR_11;",
"}",
"return VAR_4;",
"}"
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
1,
1,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
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
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135,
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
]
] |
20,590 | static void serial_ioport_write(void *opaque, hwaddr addr, uint64_t val,
unsigned size)
{
SerialState *s = opaque;
addr &= 7;
DPRINTF("write addr=0x%" HWADDR_PRIx " val=0x%" PRIx64 "\n", addr, val);
switch(addr) {
default:
case 0:
if (s->lcr & UART_LCR_DLAB) {
s->divider = (s->divider & 0xff00) | val;
serial_update_parameters(s);
} else {
s->thr = (uint8_t) val;
if(s->fcr & UART_FCR_FE) {
/* xmit overruns overwrite data, so make space if needed */
if (fifo8_is_full(&s->xmit_fifo)) {
fifo8_pop(&s->xmit_fifo);
}
fifo8_push(&s->xmit_fifo, s->thr);
s->lsr &= ~UART_LSR_TEMT;
}
s->thr_ipending = 0;
s->lsr &= ~UART_LSR_THRE;
serial_update_irq(s);
serial_xmit(NULL, G_IO_OUT, s);
}
break;
case 1:
if (s->lcr & UART_LCR_DLAB) {
s->divider = (s->divider & 0x00ff) | (val << 8);
serial_update_parameters(s);
} else {
s->ier = val & 0x0f;
/* If the backend device is a real serial port, turn polling of the modem
status lines on physical port on or off depending on UART_IER_MSI state */
if (s->poll_msl >= 0) {
if (s->ier & UART_IER_MSI) {
s->poll_msl = 1;
serial_update_msl(s);
} else {
timer_del(s->modem_status_poll);
s->poll_msl = 0;
}
}
if (s->lsr & UART_LSR_THRE) {
s->thr_ipending = 1;
serial_update_irq(s);
}
}
break;
case 2:
val = val & 0xFF;
if (s->fcr == val)
break;
/* Did the enable/disable flag change? If so, make sure FIFOs get flushed */
if ((val ^ s->fcr) & UART_FCR_FE)
val |= UART_FCR_XFR | UART_FCR_RFR;
/* FIFO clear */
if (val & UART_FCR_RFR) {
timer_del(s->fifo_timeout_timer);
s->timeout_ipending=0;
fifo8_reset(&s->recv_fifo);
}
if (val & UART_FCR_XFR) {
fifo8_reset(&s->xmit_fifo);
}
if (val & UART_FCR_FE) {
s->iir |= UART_IIR_FE;
/* Set recv_fifo trigger Level */
switch (val & 0xC0) {
case UART_FCR_ITL_1:
s->recv_fifo_itl = 1;
break;
case UART_FCR_ITL_2:
s->recv_fifo_itl = 4;
break;
case UART_FCR_ITL_3:
s->recv_fifo_itl = 8;
break;
case UART_FCR_ITL_4:
s->recv_fifo_itl = 14;
break;
}
} else
s->iir &= ~UART_IIR_FE;
/* Set fcr - or at least the bits in it that are supposed to "stick" */
s->fcr = val & 0xC9;
serial_update_irq(s);
break;
case 3:
{
int break_enable;
s->lcr = val;
serial_update_parameters(s);
break_enable = (val >> 6) & 1;
if (break_enable != s->last_break_enable) {
s->last_break_enable = break_enable;
qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_BREAK,
&break_enable);
}
}
break;
case 4:
{
int flags;
int old_mcr = s->mcr;
s->mcr = val & 0x1f;
if (val & UART_MCR_LOOP)
break;
if (s->poll_msl >= 0 && old_mcr != s->mcr) {
qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &flags);
flags &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);
if (val & UART_MCR_RTS)
flags |= CHR_TIOCM_RTS;
if (val & UART_MCR_DTR)
flags |= CHR_TIOCM_DTR;
qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_SET_TIOCM, &flags);
/* Update the modem status after a one-character-send wait-time, since there may be a response
from the device/computer at the other end of the serial line */
timer_mod(s->modem_status_poll, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time);
}
}
break;
case 5:
break;
case 6:
break;
case 7:
s->scr = val;
break;
}
}
| true | qemu | f702e62a193e9ddb41cef95068717e5582b39a64 | static void serial_ioport_write(void *opaque, hwaddr addr, uint64_t val,
unsigned size)
{
SerialState *s = opaque;
addr &= 7;
DPRINTF("write addr=0x%" HWADDR_PRIx " val=0x%" PRIx64 "\n", addr, val);
switch(addr) {
default:
case 0:
if (s->lcr & UART_LCR_DLAB) {
s->divider = (s->divider & 0xff00) | val;
serial_update_parameters(s);
} else {
s->thr = (uint8_t) val;
if(s->fcr & UART_FCR_FE) {
if (fifo8_is_full(&s->xmit_fifo)) {
fifo8_pop(&s->xmit_fifo);
}
fifo8_push(&s->xmit_fifo, s->thr);
s->lsr &= ~UART_LSR_TEMT;
}
s->thr_ipending = 0;
s->lsr &= ~UART_LSR_THRE;
serial_update_irq(s);
serial_xmit(NULL, G_IO_OUT, s);
}
break;
case 1:
if (s->lcr & UART_LCR_DLAB) {
s->divider = (s->divider & 0x00ff) | (val << 8);
serial_update_parameters(s);
} else {
s->ier = val & 0x0f;
if (s->poll_msl >= 0) {
if (s->ier & UART_IER_MSI) {
s->poll_msl = 1;
serial_update_msl(s);
} else {
timer_del(s->modem_status_poll);
s->poll_msl = 0;
}
}
if (s->lsr & UART_LSR_THRE) {
s->thr_ipending = 1;
serial_update_irq(s);
}
}
break;
case 2:
val = val & 0xFF;
if (s->fcr == val)
break;
if ((val ^ s->fcr) & UART_FCR_FE)
val |= UART_FCR_XFR | UART_FCR_RFR;
if (val & UART_FCR_RFR) {
timer_del(s->fifo_timeout_timer);
s->timeout_ipending=0;
fifo8_reset(&s->recv_fifo);
}
if (val & UART_FCR_XFR) {
fifo8_reset(&s->xmit_fifo);
}
if (val & UART_FCR_FE) {
s->iir |= UART_IIR_FE;
switch (val & 0xC0) {
case UART_FCR_ITL_1:
s->recv_fifo_itl = 1;
break;
case UART_FCR_ITL_2:
s->recv_fifo_itl = 4;
break;
case UART_FCR_ITL_3:
s->recv_fifo_itl = 8;
break;
case UART_FCR_ITL_4:
s->recv_fifo_itl = 14;
break;
}
} else
s->iir &= ~UART_IIR_FE;
s->fcr = val & 0xC9;
serial_update_irq(s);
break;
case 3:
{
int break_enable;
s->lcr = val;
serial_update_parameters(s);
break_enable = (val >> 6) & 1;
if (break_enable != s->last_break_enable) {
s->last_break_enable = break_enable;
qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_BREAK,
&break_enable);
}
}
break;
case 4:
{
int flags;
int old_mcr = s->mcr;
s->mcr = val & 0x1f;
if (val & UART_MCR_LOOP)
break;
if (s->poll_msl >= 0 && old_mcr != s->mcr) {
qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &flags);
flags &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);
if (val & UART_MCR_RTS)
flags |= CHR_TIOCM_RTS;
if (val & UART_MCR_DTR)
flags |= CHR_TIOCM_DTR;
qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_SET_TIOCM, &flags);
timer_mod(s->modem_status_poll, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time);
}
}
break;
case 5:
break;
case 6:
break;
case 7:
s->scr = val;
break;
}
}
| {
"code": [
" } else {",
" serial_xmit(NULL, G_IO_OUT, s);"
],
"line_no": [
27,
53
]
} | static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,
unsigned VAR_3)
{
SerialState *s = VAR_0;
VAR_1 &= 7;
DPRINTF("write VAR_1=0x%" HWADDR_PRIx " VAR_2=0x%" PRIx64 "\n", VAR_1, VAR_2);
switch(VAR_1) {
default:
case 0:
if (s->lcr & UART_LCR_DLAB) {
s->divider = (s->divider & 0xff00) | VAR_2;
serial_update_parameters(s);
} else {
s->thr = (uint8_t) VAR_2;
if(s->fcr & UART_FCR_FE) {
if (fifo8_is_full(&s->xmit_fifo)) {
fifo8_pop(&s->xmit_fifo);
}
fifo8_push(&s->xmit_fifo, s->thr);
s->lsr &= ~UART_LSR_TEMT;
}
s->thr_ipending = 0;
s->lsr &= ~UART_LSR_THRE;
serial_update_irq(s);
serial_xmit(NULL, G_IO_OUT, s);
}
break;
case 1:
if (s->lcr & UART_LCR_DLAB) {
s->divider = (s->divider & 0x00ff) | (VAR_2 << 8);
serial_update_parameters(s);
} else {
s->ier = VAR_2 & 0x0f;
if (s->poll_msl >= 0) {
if (s->ier & UART_IER_MSI) {
s->poll_msl = 1;
serial_update_msl(s);
} else {
timer_del(s->modem_status_poll);
s->poll_msl = 0;
}
}
if (s->lsr & UART_LSR_THRE) {
s->thr_ipending = 1;
serial_update_irq(s);
}
}
break;
case 2:
VAR_2 = VAR_2 & 0xFF;
if (s->fcr == VAR_2)
break;
if ((VAR_2 ^ s->fcr) & UART_FCR_FE)
VAR_2 |= UART_FCR_XFR | UART_FCR_RFR;
if (VAR_2 & UART_FCR_RFR) {
timer_del(s->fifo_timeout_timer);
s->timeout_ipending=0;
fifo8_reset(&s->recv_fifo);
}
if (VAR_2 & UART_FCR_XFR) {
fifo8_reset(&s->xmit_fifo);
}
if (VAR_2 & UART_FCR_FE) {
s->iir |= UART_IIR_FE;
switch (VAR_2 & 0xC0) {
case UART_FCR_ITL_1:
s->recv_fifo_itl = 1;
break;
case UART_FCR_ITL_2:
s->recv_fifo_itl = 4;
break;
case UART_FCR_ITL_3:
s->recv_fifo_itl = 8;
break;
case UART_FCR_ITL_4:
s->recv_fifo_itl = 14;
break;
}
} else
s->iir &= ~UART_IIR_FE;
s->fcr = VAR_2 & 0xC9;
serial_update_irq(s);
break;
case 3:
{
int VAR_4;
s->lcr = VAR_2;
serial_update_parameters(s);
VAR_4 = (VAR_2 >> 6) & 1;
if (VAR_4 != s->last_break_enable) {
s->last_break_enable = VAR_4;
qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_BREAK,
&VAR_4);
}
}
break;
case 4:
{
int VAR_5;
int VAR_6 = s->mcr;
s->mcr = VAR_2 & 0x1f;
if (VAR_2 & UART_MCR_LOOP)
break;
if (s->poll_msl >= 0 && VAR_6 != s->mcr) {
qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &VAR_5);
VAR_5 &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);
if (VAR_2 & UART_MCR_RTS)
VAR_5 |= CHR_TIOCM_RTS;
if (VAR_2 & UART_MCR_DTR)
VAR_5 |= CHR_TIOCM_DTR;
qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_SET_TIOCM, &VAR_5);
timer_mod(s->modem_status_poll, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time);
}
}
break;
case 5:
break;
case 6:
break;
case 7:
s->scr = VAR_2;
break;
}
}
| [
"static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{",
"SerialState *s = VAR_0;",
"VAR_1 &= 7;",
"DPRINTF(\"write VAR_1=0x%\" HWADDR_PRIx \" VAR_2=0x%\" PRIx64 \"\\n\", VAR_1, VAR_2);",
"switch(VAR_1) {",
"default:\ncase 0:\nif (s->lcr & UART_LCR_DLAB) {",
"s->divider = (s->divider & 0xff00) | VAR_2;",
"serial_update_parameters(s);",
"} else {",
"s->thr = (uint8_t) VAR_2;",
"if(s->fcr & UART_FCR_FE) {",
"if (fifo8_is_full(&s->xmit_fifo)) {",
"fifo8_pop(&s->xmit_fifo);",
"}",
"fifo8_push(&s->xmit_fifo, s->thr);",
"s->lsr &= ~UART_LSR_TEMT;",
"}",
"s->thr_ipending = 0;",
"s->lsr &= ~UART_LSR_THRE;",
"serial_update_irq(s);",
"serial_xmit(NULL, G_IO_OUT, s);",
"}",
"break;",
"case 1:\nif (s->lcr & UART_LCR_DLAB) {",
"s->divider = (s->divider & 0x00ff) | (VAR_2 << 8);",
"serial_update_parameters(s);",
"} else {",
"s->ier = VAR_2 & 0x0f;",
"if (s->poll_msl >= 0) {",
"if (s->ier & UART_IER_MSI) {",
"s->poll_msl = 1;",
"serial_update_msl(s);",
"} else {",
"timer_del(s->modem_status_poll);",
"s->poll_msl = 0;",
"}",
"}",
"if (s->lsr & UART_LSR_THRE) {",
"s->thr_ipending = 1;",
"serial_update_irq(s);",
"}",
"}",
"break;",
"case 2:\nVAR_2 = VAR_2 & 0xFF;",
"if (s->fcr == VAR_2)\nbreak;",
"if ((VAR_2 ^ s->fcr) & UART_FCR_FE)\nVAR_2 |= UART_FCR_XFR | UART_FCR_RFR;",
"if (VAR_2 & UART_FCR_RFR) {",
"timer_del(s->fifo_timeout_timer);",
"s->timeout_ipending=0;",
"fifo8_reset(&s->recv_fifo);",
"}",
"if (VAR_2 & UART_FCR_XFR) {",
"fifo8_reset(&s->xmit_fifo);",
"}",
"if (VAR_2 & UART_FCR_FE) {",
"s->iir |= UART_IIR_FE;",
"switch (VAR_2 & 0xC0) {",
"case UART_FCR_ITL_1:\ns->recv_fifo_itl = 1;",
"break;",
"case UART_FCR_ITL_2:\ns->recv_fifo_itl = 4;",
"break;",
"case UART_FCR_ITL_3:\ns->recv_fifo_itl = 8;",
"break;",
"case UART_FCR_ITL_4:\ns->recv_fifo_itl = 14;",
"break;",
"}",
"} else",
"s->iir &= ~UART_IIR_FE;",
"s->fcr = VAR_2 & 0xC9;",
"serial_update_irq(s);",
"break;",
"case 3:\n{",
"int VAR_4;",
"s->lcr = VAR_2;",
"serial_update_parameters(s);",
"VAR_4 = (VAR_2 >> 6) & 1;",
"if (VAR_4 != s->last_break_enable) {",
"s->last_break_enable = VAR_4;",
"qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_BREAK,\n&VAR_4);",
"}",
"}",
"break;",
"case 4:\n{",
"int VAR_5;",
"int VAR_6 = s->mcr;",
"s->mcr = VAR_2 & 0x1f;",
"if (VAR_2 & UART_MCR_LOOP)\nbreak;",
"if (s->poll_msl >= 0 && VAR_6 != s->mcr) {",
"qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_GET_TIOCM, &VAR_5);",
"VAR_5 &= ~(CHR_TIOCM_RTS | CHR_TIOCM_DTR);",
"if (VAR_2 & UART_MCR_RTS)\nVAR_5 |= CHR_TIOCM_RTS;",
"if (VAR_2 & UART_MCR_DTR)\nVAR_5 |= CHR_TIOCM_DTR;",
"qemu_chr_fe_ioctl(s->chr,CHR_IOCTL_SERIAL_SET_TIOCM, &VAR_5);",
"timer_mod(s->modem_status_poll, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->char_transmit_time);",
"}",
"}",
"break;",
"case 5:\nbreak;",
"case 6:\nbreak;",
"case 7:\ns->scr = VAR_2;",
"break;",
"}",
"}"
] | [
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
111,
113
],
[
119,
121
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
141
],
[
143
],
[
145
],
[
149
],
[
151
],
[
155
],
[
157,
159
],
[
161
],
[
163,
165
],
[
167
],
[
169,
171
],
[
173
],
[
175,
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
191
],
[
193
],
[
195
],
[
197,
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213,
215
],
[
217
],
[
219
],
[
221
],
[
223,
225
],
[
227
],
[
229
],
[
231
],
[
233,
235
],
[
239
],
[
243
],
[
247
],
[
251,
253
],
[
255,
257
],
[
261
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275,
277
],
[
279,
281
],
[
283,
285
],
[
287
],
[
289
],
[
291
]
] |
20,591 | static void FUNC(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
int16_t *src2,
int height, int denom, int wx0, int wx1,
int ox0, int ox1, intptr_t mx, intptr_t my, int width)
{
int x, y;
pixel *src = (pixel*)_src;
ptrdiff_t srcstride = _srcstride / sizeof(pixel);
pixel *dst = (pixel *)_dst;
ptrdiff_t dststride = _dststride / sizeof(pixel);
const int8_t *filter = ff_hevc_qpel_filters[my - 1];
int shift = 14 + 1 - BIT_DEPTH;
int log2Wd = denom + shift - 1;
ox0 = ox0 * (1 << (BIT_DEPTH - 8));
ox1 = ox1 * (1 << (BIT_DEPTH - 8));
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++)
dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
src += srcstride;
dst += dststride;
src2 += MAX_PB_SIZE;
}
}
| true | FFmpeg | d135f3c514ac1723256c8e0f5cdd466fe98a2578 | static void FUNC(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
int16_t *src2,
int height, int denom, int wx0, int wx1,
int ox0, int ox1, intptr_t mx, intptr_t my, int width)
{
int x, y;
pixel *src = (pixel*)_src;
ptrdiff_t srcstride = _srcstride / sizeof(pixel);
pixel *dst = (pixel *)_dst;
ptrdiff_t dststride = _dststride / sizeof(pixel);
const int8_t *filter = ff_hevc_qpel_filters[my - 1];
int shift = 14 + 1 - BIT_DEPTH;
int log2Wd = denom + shift - 1;
ox0 = ox0 * (1 << (BIT_DEPTH - 8));
ox1 = ox1 * (1 << (BIT_DEPTH - 8));
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++)
dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
src += srcstride;
dst += dststride;
src2 += MAX_PB_SIZE;
}
}
| {
"code": [
" ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));",
" ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));"
],
"line_no": [
43,
43
]
} | static void FUNC_0(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
int16_t *src2,
int height, int denom, int wx0, int wx1,
int ox0, int ox1, intptr_t mx, intptr_t my, int width)
{
int VAR_0, VAR_1;
pixel *src = (pixel*)_src;
ptrdiff_t srcstride = _srcstride / sizeof(pixel);
pixel *dst = (pixel *)_dst;
ptrdiff_t dststride = _dststride / sizeof(pixel);
const int8_t *VAR_2 = ff_hevc_qpel_filters[my - 1];
int VAR_3 = 14 + 1 - BIT_DEPTH;
int VAR_4 = denom + VAR_3 - 1;
ox0 = ox0 * (1 << (BIT_DEPTH - 8));
ox1 = ox1 * (1 << (BIT_DEPTH - 8));
for (VAR_1 = 0; VAR_1 < height; VAR_1++) {
for (VAR_0 = 0; VAR_0 < width; VAR_0++)
dst[VAR_0] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[VAR_0] * wx0 +
((ox0 + ox1 + 1) << VAR_4)) >> (VAR_4 + 1));
src += srcstride;
dst += dststride;
src2 += MAX_PB_SIZE;
}
}
| [
"static void FUNC_0(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,\nint16_t *src2,\nint height, int denom, int wx0, int wx1,\nint ox0, int ox1, intptr_t mx, intptr_t my, int width)\n{",
"int VAR_0, VAR_1;",
"pixel *src = (pixel*)_src;",
"ptrdiff_t srcstride = _srcstride / sizeof(pixel);",
"pixel *dst = (pixel *)_dst;",
"ptrdiff_t dststride = _dststride / sizeof(pixel);",
"const int8_t *VAR_2 = ff_hevc_qpel_filters[my - 1];",
"int VAR_3 = 14 + 1 - BIT_DEPTH;",
"int VAR_4 = denom + VAR_3 - 1;",
"ox0 = ox0 * (1 << (BIT_DEPTH - 8));",
"ox1 = ox1 * (1 << (BIT_DEPTH - 8));",
"for (VAR_1 = 0; VAR_1 < height; VAR_1++) {",
"for (VAR_0 = 0; VAR_0 < width; VAR_0++)",
"dst[VAR_0] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[VAR_0] * wx0 +\n((ox0 + ox1 + 1) << VAR_4)) >> (VAR_4 + 1));",
"src += srcstride;",
"dst += dststride;",
"src2 += MAX_PB_SIZE;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
]
] |
20,592 | int spapr_ovec_populate_dt(void *fdt, int fdt_offset,
sPAPROptionVector *ov, const char *name)
{
uint8_t vec[OV_MAXBYTES + 1];
uint16_t vec_len;
unsigned long lastbit;
int i;
g_assert(ov);
lastbit = find_last_bit(ov->bitmap, OV_MAXBITS);
/* if no bits are set, include at least 1 byte of the vector so we can
* still encoded this in the device tree while abiding by the same
* encoding/sizing expected in ibm,client-architecture-support
*/
vec_len = (lastbit == OV_MAXBITS) ? 1 : lastbit / BITS_PER_BYTE + 1;
g_assert_cmpint(vec_len, <=, OV_MAXBYTES);
/* guest expects vector len encoded as vec_len - 1, since the length byte
* is assumed and not included, and the first byte of the vector
* is assumed as well
*/
vec[0] = vec_len - 1;
for (i = 1; i < vec_len + 1; i++) {
vec[i] = guest_byte_from_bitmap(ov->bitmap, (i - 1) * BITS_PER_BYTE);
if (vec[i]) {
DPRINTFN("encoding guest vector byte %3d / %3d: 0x%.2x",
i, vec_len, vec[i]);
}
}
return fdt_setprop(fdt, fdt_offset, name, vec, vec_len);
}
| true | qemu | fe93e3e6ec1b1bf4a4c9d4bf55f8776318da6847 | int spapr_ovec_populate_dt(void *fdt, int fdt_offset,
sPAPROptionVector *ov, const char *name)
{
uint8_t vec[OV_MAXBYTES + 1];
uint16_t vec_len;
unsigned long lastbit;
int i;
g_assert(ov);
lastbit = find_last_bit(ov->bitmap, OV_MAXBITS);
vec_len = (lastbit == OV_MAXBITS) ? 1 : lastbit / BITS_PER_BYTE + 1;
g_assert_cmpint(vec_len, <=, OV_MAXBYTES);
vec[0] = vec_len - 1;
for (i = 1; i < vec_len + 1; i++) {
vec[i] = guest_byte_from_bitmap(ov->bitmap, (i - 1) * BITS_PER_BYTE);
if (vec[i]) {
DPRINTFN("encoding guest vector byte %3d / %3d: 0x%.2x",
i, vec_len, vec[i]);
}
}
return fdt_setprop(fdt, fdt_offset, name, vec, vec_len);
}
| {
"code": [
" return fdt_setprop(fdt, fdt_offset, name, vec, vec_len);"
],
"line_no": [
63
]
} | int FUNC_0(void *VAR_0, int VAR_1,
sPAPROptionVector *VAR_2, const char *VAR_3)
{
uint8_t vec[OV_MAXBYTES + 1];
uint16_t vec_len;
unsigned long VAR_4;
int VAR_5;
g_assert(VAR_2);
VAR_4 = find_last_bit(VAR_2->bitmap, OV_MAXBITS);
vec_len = (VAR_4 == OV_MAXBITS) ? 1 : VAR_4 / BITS_PER_BYTE + 1;
g_assert_cmpint(vec_len, <=, OV_MAXBYTES);
vec[0] = vec_len - 1;
for (VAR_5 = 1; VAR_5 < vec_len + 1; VAR_5++) {
vec[VAR_5] = guest_byte_from_bitmap(VAR_2->bitmap, (VAR_5 - 1) * BITS_PER_BYTE);
if (vec[VAR_5]) {
DPRINTFN("encoding guest vector byte %3d / %3d: 0x%.2x",
VAR_5, vec_len, vec[VAR_5]);
}
}
return fdt_setprop(VAR_0, VAR_1, VAR_3, vec, vec_len);
}
| [
"int FUNC_0(void *VAR_0, int VAR_1,\nsPAPROptionVector *VAR_2, const char *VAR_3)\n{",
"uint8_t vec[OV_MAXBYTES + 1];",
"uint16_t vec_len;",
"unsigned long VAR_4;",
"int VAR_5;",
"g_assert(VAR_2);",
"VAR_4 = find_last_bit(VAR_2->bitmap, OV_MAXBITS);",
"vec_len = (VAR_4 == OV_MAXBITS) ? 1 : VAR_4 / BITS_PER_BYTE + 1;",
"g_assert_cmpint(vec_len, <=, OV_MAXBYTES);",
"vec[0] = vec_len - 1;",
"for (VAR_5 = 1; VAR_5 < vec_len + 1; VAR_5++) {",
"vec[VAR_5] = guest_byte_from_bitmap(VAR_2->bitmap, (VAR_5 - 1) * BITS_PER_BYTE);",
"if (vec[VAR_5]) {",
"DPRINTFN(\"encoding guest vector byte %3d / %3d: 0x%.2x\",\nVAR_5, vec_len, vec[VAR_5]);",
"}",
"}",
"return fdt_setprop(VAR_0, VAR_1, VAR_3, vec, vec_len);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
31
],
[
33
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
63
],
[
65
]
] |
20,593 | static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta)
{
int isv34, tlen, unsync;
char tag[5];
int64_t next, end = avio_tell(s->pb) + len;
int taghdrlen;
const char *reason = NULL;
AVIOContext pb;
AVIOContext *pbx;
unsigned char *buffer = NULL;
int buffer_size = 0;
void (*extra_func)(AVFormatContext*, AVIOContext*, int, char*, ID3v2ExtraMeta**) = NULL;
switch (version) {
case 2:
if (flags & 0x40) {
reason = "compression";
goto error;
}
isv34 = 0;
taghdrlen = 6;
break;
case 3:
case 4:
isv34 = 1;
taghdrlen = 10;
break;
default:
reason = "version";
goto error;
}
unsync = flags & 0x80;
if (isv34 && flags & 0x40) /* Extended header present, just skip over it */
avio_skip(s->pb, get_size(s->pb, 4));
while (len >= taghdrlen) {
unsigned int tflags = 0;
int tunsync = 0;
if (isv34) {
avio_read(s->pb, tag, 4);
tag[4] = 0;
if(version==3){
tlen = avio_rb32(s->pb);
}else
tlen = get_size(s->pb, 4);
tflags = avio_rb16(s->pb);
tunsync = tflags & ID3v2_FLAG_UNSYNCH;
} else {
avio_read(s->pb, tag, 3);
tag[3] = 0;
tlen = avio_rb24(s->pb);
}
if (tlen < 0 || tlen > len - taghdrlen) {
av_log(s, AV_LOG_WARNING, "Invalid size in frame %s, skipping the rest of tag.\n", tag);
break;
}
len -= taghdrlen + tlen;
next = avio_tell(s->pb) + tlen;
if (!tlen) {
if (tag[0])
av_log(s, AV_LOG_DEBUG, "Invalid empty frame %s, skipping.\n", tag);
continue;
}
if (tflags & ID3v2_FLAG_DATALEN) {
avio_rb32(s->pb);
tlen -= 4;
}
if (tflags & (ID3v2_FLAG_ENCRYPTION | ID3v2_FLAG_COMPRESSION)) {
av_log(s, AV_LOG_WARNING, "Skipping encrypted/compressed ID3v2 frame %s.\n", tag);
avio_skip(s->pb, tlen);
/* check for text tag or supported special meta tag */
} else if (tag[0] == 'T' || (extra_meta && (extra_func = get_extra_meta_func(tag, isv34)->read))) {
if (unsync || tunsync) {
int i, j;
av_fast_malloc(&buffer, &buffer_size, tlen);
if (!buffer) {
av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", tlen);
goto seek;
}
for (i = 0, j = 0; i < tlen; i++, j++) {
buffer[j] = avio_r8(s->pb);
if (j > 0 && !buffer[j] && buffer[j - 1] == 0xff) {
/* Unsynchronised byte, skip it */
j--;
}
}
ffio_init_context(&pb, buffer, j, 0, NULL, NULL, NULL, NULL);
tlen = j;
pbx = &pb; // read from sync buffer
} else {
pbx = s->pb; // read straight from input
}
if (tag[0] == 'T')
/* parse text tag */
read_ttag(s, pbx, tlen, tag);
else
/* parse special meta tag */
extra_func(s, pbx, tlen, tag, extra_meta);
}
else if (!tag[0]) {
if (tag[1])
av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding");
avio_skip(s->pb, tlen);
break;
}
/* Skip to end of tag */
seek:
avio_seek(s->pb, next, SEEK_SET);
}
if (version == 4 && flags & 0x10) /* Footer preset, always 10 bytes, skip over it */
end += 10;
error:
if (reason)
av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n", version, reason);
avio_seek(s->pb, end, SEEK_SET);
av_free(buffer);
return;
}
| true | FFmpeg | c780b543e72141393ae3c0b0cb2654f9a5e35f73 | static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta)
{
int isv34, tlen, unsync;
char tag[5];
int64_t next, end = avio_tell(s->pb) + len;
int taghdrlen;
const char *reason = NULL;
AVIOContext pb;
AVIOContext *pbx;
unsigned char *buffer = NULL;
int buffer_size = 0;
void (*extra_func)(AVFormatContext*, AVIOContext*, int, char*, ID3v2ExtraMeta**) = NULL;
switch (version) {
case 2:
if (flags & 0x40) {
reason = "compression";
goto error;
}
isv34 = 0;
taghdrlen = 6;
break;
case 3:
case 4:
isv34 = 1;
taghdrlen = 10;
break;
default:
reason = "version";
goto error;
}
unsync = flags & 0x80;
if (isv34 && flags & 0x40)
avio_skip(s->pb, get_size(s->pb, 4));
while (len >= taghdrlen) {
unsigned int tflags = 0;
int tunsync = 0;
if (isv34) {
avio_read(s->pb, tag, 4);
tag[4] = 0;
if(version==3){
tlen = avio_rb32(s->pb);
}else
tlen = get_size(s->pb, 4);
tflags = avio_rb16(s->pb);
tunsync = tflags & ID3v2_FLAG_UNSYNCH;
} else {
avio_read(s->pb, tag, 3);
tag[3] = 0;
tlen = avio_rb24(s->pb);
}
if (tlen < 0 || tlen > len - taghdrlen) {
av_log(s, AV_LOG_WARNING, "Invalid size in frame %s, skipping the rest of tag.\n", tag);
break;
}
len -= taghdrlen + tlen;
next = avio_tell(s->pb) + tlen;
if (!tlen) {
if (tag[0])
av_log(s, AV_LOG_DEBUG, "Invalid empty frame %s, skipping.\n", tag);
continue;
}
if (tflags & ID3v2_FLAG_DATALEN) {
avio_rb32(s->pb);
tlen -= 4;
}
if (tflags & (ID3v2_FLAG_ENCRYPTION | ID3v2_FLAG_COMPRESSION)) {
av_log(s, AV_LOG_WARNING, "Skipping encrypted/compressed ID3v2 frame %s.\n", tag);
avio_skip(s->pb, tlen);
} else if (tag[0] == 'T' || (extra_meta && (extra_func = get_extra_meta_func(tag, isv34)->read))) {
if (unsync || tunsync) {
int i, j;
av_fast_malloc(&buffer, &buffer_size, tlen);
if (!buffer) {
av_log(s, AV_LOG_ERROR, "Failed to alloc %d bytes\n", tlen);
goto seek;
}
for (i = 0, j = 0; i < tlen; i++, j++) {
buffer[j] = avio_r8(s->pb);
if (j > 0 && !buffer[j] && buffer[j - 1] == 0xff) {
j--;
}
}
ffio_init_context(&pb, buffer, j, 0, NULL, NULL, NULL, NULL);
tlen = j;
pbx = &pb;
} else {
pbx = s->pb;
}
if (tag[0] == 'T')
read_ttag(s, pbx, tlen, tag);
else
extra_func(s, pbx, tlen, tag, extra_meta);
}
else if (!tag[0]) {
if (tag[1])
av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding");
avio_skip(s->pb, tlen);
break;
}
seek:
avio_seek(s->pb, next, SEEK_SET);
}
if (version == 4 && flags & 0x10)
end += 10;
error:
if (reason)
av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n", version, reason);
avio_seek(s->pb, end, SEEK_SET);
av_free(buffer);
return;
}
| {
"code": [
" void (*extra_func)(AVFormatContext*, AVIOContext*, int, char*, ID3v2ExtraMeta**) = NULL;",
" } else if (tag[0] == 'T' || (extra_meta && (extra_func = get_extra_meta_func(tag, isv34)->read))) {",
" extra_func(s, pbx, tlen, tag, extra_meta);"
],
"line_no": [
23,
159,
211
]
} | VAR_15staticVAR_15 VAR_15voidVAR_15 VAR_15ff_id3v2_parseVAR_15(VAR_15AVFormatContextVAR_15 *VAR_15VAR_0VAR_15, VAR_15intVAR_15 VAR_15VAR_1VAR_15, VAR_15uint8_tVAR_15 VAR_15VAR_2VAR_15, VAR_15uint8_tVAR_15 VAR_15VAR_3VAR_15, VAR_15ID3v2ExtraMetaVAR_15 **VAR_15VAR_4VAR_15)
{
VAR_15intVAR_15 VAR_15VAR_5VAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_7VAR_15;
VAR_15charVAR_15 VAR_15VAR_8VAR_15[VAR_155VAR_15];
VAR_15int64_tVAR_15 VAR_15nextVAR_15, VAR_15endVAR_15 = VAR_15avio_tellVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15) + VAR_15VAR_1VAR_15;
VAR_15intVAR_15 VAR_15VAR_9VAR_15;
VAR_15constVAR_15 VAR_15charVAR_15 *VAR_15VAR_10VAR_15 = VAR_15NULLVAR_15;
VAR_15AVIOContextVAR_15 VAR_15pbVAR_15;
VAR_15AVIOContextVAR_15 *VAR_15pbxVAR_15;
VAR_15unsignedVAR_15 VAR_15charVAR_15 *VAR_15VAR_11VAR_15 = VAR_15NULLVAR_15;
VAR_15intVAR_15 VAR_15VAR_12VAR_15 = VAR_150VAR_15;
VAR_15voidVAR_15 (*VAR_15VAR_13VAR_15)(VAR_15AVFormatContextVAR_15*, VAR_15AVIOContextVAR_15*, VAR_15intVAR_15, VAR_15charVAR_15*, VAR_15ID3v2ExtraMetaVAR_15**) = VAR_15NULLVAR_15;
VAR_15switchVAR_15 (VAR_15VAR_2VAR_15) {
VAR_15caseVAR_15 VAR_152VAR_15:
VAR_15ifVAR_15 (VAR_15VAR_3VAR_15 & VAR_150x40VAR_15) {
VAR_15VAR_10VAR_15 = "VAR_15compressionVAR_15";
VAR_15gotoVAR_15 VAR_15errorVAR_15;
}
VAR_15VAR_5VAR_15 = VAR_150VAR_15;
VAR_15VAR_9VAR_15 = VAR_156VAR_15;
VAR_15breakVAR_15;
VAR_15caseVAR_15 VAR_153VAR_15:
VAR_15caseVAR_15 VAR_154VAR_15:
VAR_15VAR_5VAR_15 = VAR_151VAR_15;
VAR_15VAR_9VAR_15 = VAR_1510VAR_15;
VAR_15breakVAR_15;
VAR_15defaultVAR_15:
VAR_15VAR_10VAR_15 = "VAR_15VAR_2VAR_15";
VAR_15gotoVAR_15 VAR_15errorVAR_15;
}
VAR_15VAR_7VAR_15 = VAR_15VAR_3VAR_15 & VAR_150x80VAR_15;
VAR_15ifVAR_15 (VAR_15VAR_5VAR_15 && VAR_15VAR_3VAR_15 & VAR_150x40VAR_15)
VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15get_sizeVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_154VAR_15));
VAR_15whileVAR_15 (VAR_15VAR_1VAR_15 >= VAR_15VAR_9VAR_15) {
VAR_15unsignedVAR_15 VAR_15intVAR_15 VAR_15tflagsVAR_15 = VAR_150VAR_15;
VAR_15intVAR_15 VAR_15tunsyncVAR_15 = VAR_150VAR_15;
VAR_15ifVAR_15 (VAR_15VAR_5VAR_15) {
VAR_15avio_readVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_8VAR_15, VAR_154VAR_15);
VAR_15VAR_8VAR_15[VAR_154VAR_15] = VAR_150VAR_15;
VAR_15ifVAR_15(VAR_15VAR_2VAR_15==VAR_153VAR_15){
VAR_15VAR_6VAR_15 = VAR_15avio_rb32VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);
}VAR_15elseVAR_15
VAR_15VAR_6VAR_15 = VAR_15get_sizeVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_154VAR_15);
VAR_15tflagsVAR_15 = VAR_15avio_rb16VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);
VAR_15tunsyncVAR_15 = VAR_15tflagsVAR_15 & VAR_15ID3v2_FLAG_UNSYNCHVAR_15;
} VAR_15elseVAR_15 {
VAR_15avio_readVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_8VAR_15, VAR_153VAR_15);
VAR_15VAR_8VAR_15[VAR_153VAR_15] = VAR_150VAR_15;
VAR_15VAR_6VAR_15 = VAR_15avio_rb24VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);
}
VAR_15ifVAR_15 (VAR_15VAR_6VAR_15 < VAR_150VAR_15 || VAR_15VAR_6VAR_15 > VAR_15VAR_1VAR_15 - VAR_15VAR_9VAR_15) {
VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, "VAR_15InvalidVAR_15 VAR_15sizeVAR_15 VAR_15inVAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15, VAR_15skippingVAR_15 VAR_15theVAR_15 VAR_15restVAR_15 VAR_15ofVAR_15 VAR_15VAR_8VAR_15.\VAR_15nVAR_15", VAR_15VAR_8VAR_15);
VAR_15breakVAR_15;
}
VAR_15VAR_1VAR_15 -= VAR_15VAR_9VAR_15 + VAR_15VAR_6VAR_15;
VAR_15nextVAR_15 = VAR_15avio_tellVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15) + VAR_15VAR_6VAR_15;
VAR_15ifVAR_15 (!VAR_15VAR_6VAR_15) {
VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15])
VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_DEBUGVAR_15, "VAR_15InvalidVAR_15 VAR_15emptyVAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15, VAR_15skippingVAR_15.\VAR_15nVAR_15", VAR_15VAR_8VAR_15);
VAR_15continueVAR_15;
}
VAR_15ifVAR_15 (VAR_15tflagsVAR_15 & VAR_15ID3v2_FLAG_DATALENVAR_15) {
VAR_15avio_rb32VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);
VAR_15VAR_6VAR_15 -= VAR_154VAR_15;
}
VAR_15ifVAR_15 (VAR_15tflagsVAR_15 & (VAR_15ID3v2_FLAG_ENCRYPTIONVAR_15 | VAR_15ID3v2_FLAG_COMPRESSIONVAR_15)) {
VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, "VAR_15SkippingVAR_15 VAR_15encryptedVAR_15/VAR_15compressedVAR_15 VAR_15ID3v2VAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15.\VAR_15nVAR_15", VAR_15VAR_8VAR_15);
VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_6VAR_15);
} VAR_15elseVAR_15 VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15] == 'VAR_15TVAR_15' || (VAR_15VAR_4VAR_15 && (VAR_15VAR_13VAR_15 = VAR_15get_extra_meta_funcVAR_15(VAR_15VAR_8VAR_15, VAR_15VAR_5VAR_15)->VAR_15readVAR_15))) {
VAR_15ifVAR_15 (VAR_15VAR_7VAR_15 || VAR_15tunsyncVAR_15) {
VAR_15intVAR_15 VAR_15iVAR_15, VAR_15jVAR_15;
VAR_15av_fast_mallocVAR_15(&VAR_15VAR_11VAR_15, &VAR_15VAR_12VAR_15, VAR_15VAR_6VAR_15);
VAR_15ifVAR_15 (!VAR_15VAR_11VAR_15) {
VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_ERRORVAR_15, "VAR_15FailedVAR_15 VAR_15toVAR_15 VAR_15allocVAR_15 %VAR_15dVAR_15 VAR_15bytesVAR_15\VAR_15nVAR_15", VAR_15VAR_6VAR_15);
VAR_15gotoVAR_15 VAR_15seekVAR_15;
}
VAR_15forVAR_15 (VAR_15iVAR_15 = VAR_150VAR_15, VAR_15jVAR_15 = VAR_150VAR_15; VAR_15iVAR_15 < VAR_15VAR_6VAR_15; VAR_15iVAR_15++, VAR_15jVAR_15++) {
VAR_15VAR_11VAR_15[VAR_15jVAR_15] = VAR_15avio_r8VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);
VAR_15ifVAR_15 (VAR_15jVAR_15 > VAR_150VAR_15 && !VAR_15VAR_11VAR_15[VAR_15jVAR_15] && VAR_15VAR_11VAR_15[VAR_15jVAR_15 - VAR_151VAR_15] == VAR_150xffVAR_15) {
VAR_15jVAR_15--;
}
}
VAR_15ffio_init_contextVAR_15(&VAR_15pbVAR_15, VAR_15VAR_11VAR_15, VAR_15jVAR_15, VAR_150VAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15);
VAR_15VAR_6VAR_15 = VAR_15jVAR_15;
VAR_15pbxVAR_15 = &VAR_15pbVAR_15;
} VAR_15elseVAR_15 {
VAR_15pbxVAR_15 = VAR_15VAR_0VAR_15->VAR_15pbVAR_15;
}
VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15] == 'VAR_15TVAR_15')
VAR_15read_ttagVAR_15(VAR_15VAR_0VAR_15, VAR_15pbxVAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_8VAR_15);
VAR_15elseVAR_15
VAR_15VAR_13VAR_15(VAR_15VAR_0VAR_15, VAR_15pbxVAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_8VAR_15, VAR_15VAR_4VAR_15);
}
VAR_15elseVAR_15 VAR_15ifVAR_15 (!VAR_15VAR_8VAR_15[VAR_150VAR_15]) {
VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_151VAR_15])
VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, "VAR_15invalidVAR_15 VAR_15frameVAR_15 VAR_15idVAR_15, VAR_15assumingVAR_15 VAR_15paddingVAR_15");
VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_6VAR_15);
VAR_15breakVAR_15;
}
VAR_15seekVAR_15:
VAR_15avio_seekVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15nextVAR_15, VAR_15SEEK_SETVAR_15);
}
VAR_15ifVAR_15 (VAR_15VAR_2VAR_15 == VAR_154VAR_15 && VAR_15VAR_3VAR_15 & VAR_150x10VAR_15)
VAR_15endVAR_15 += VAR_1510VAR_15;
VAR_15errorVAR_15:
VAR_15ifVAR_15 (VAR_15VAR_10VAR_15)
VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_INFOVAR_15, "VAR_15ID3v2VAR_15.%VAR_15dVAR_15 VAR_15VAR_8VAR_15 VAR_15skippedVAR_15, VAR_15cannotVAR_15 VAR_15handleVAR_15 %VAR_15VAR_0VAR_15\VAR_15nVAR_15", VAR_15VAR_2VAR_15, VAR_15VAR_10VAR_15);
VAR_15avio_seekVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15endVAR_15, VAR_15SEEK_SETVAR_15);
VAR_15av_freeVAR_15(VAR_15VAR_11VAR_15);
VAR_15returnVAR_15;
}
| [
"VAR_15staticVAR_15 VAR_15voidVAR_15 VAR_15ff_id3v2_parseVAR_15(VAR_15AVFormatContextVAR_15 *VAR_15VAR_0VAR_15, VAR_15intVAR_15 VAR_15VAR_1VAR_15, VAR_15uint8_tVAR_15 VAR_15VAR_2VAR_15, VAR_15uint8_tVAR_15 VAR_15VAR_3VAR_15, VAR_15ID3v2ExtraMetaVAR_15 **VAR_15VAR_4VAR_15)\n{",
"VAR_15intVAR_15 VAR_15VAR_5VAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_7VAR_15;",
"VAR_15charVAR_15 VAR_15VAR_8VAR_15[VAR_155VAR_15];",
"VAR_15int64_tVAR_15 VAR_15nextVAR_15, VAR_15endVAR_15 = VAR_15avio_tellVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15) + VAR_15VAR_1VAR_15;",
"VAR_15intVAR_15 VAR_15VAR_9VAR_15;",
"VAR_15constVAR_15 VAR_15charVAR_15 *VAR_15VAR_10VAR_15 = VAR_15NULLVAR_15;",
"VAR_15AVIOContextVAR_15 VAR_15pbVAR_15;",
"VAR_15AVIOContextVAR_15 *VAR_15pbxVAR_15;",
"VAR_15unsignedVAR_15 VAR_15charVAR_15 *VAR_15VAR_11VAR_15 = VAR_15NULLVAR_15;",
"VAR_15intVAR_15 VAR_15VAR_12VAR_15 = VAR_150VAR_15;",
"VAR_15voidVAR_15 (*VAR_15VAR_13VAR_15)(VAR_15AVFormatContextVAR_15*, VAR_15AVIOContextVAR_15*, VAR_15intVAR_15, VAR_15charVAR_15*, VAR_15ID3v2ExtraMetaVAR_15**) = VAR_15NULLVAR_15;",
"VAR_15switchVAR_15 (VAR_15VAR_2VAR_15) {",
"VAR_15caseVAR_15 VAR_152VAR_15:\nVAR_15ifVAR_15 (VAR_15VAR_3VAR_15 & VAR_150x40VAR_15) {",
"VAR_15VAR_10VAR_15 = \"VAR_15compressionVAR_15\";",
"VAR_15gotoVAR_15 VAR_15errorVAR_15;",
"}",
"VAR_15VAR_5VAR_15 = VAR_150VAR_15;",
"VAR_15VAR_9VAR_15 = VAR_156VAR_15;",
"VAR_15breakVAR_15;",
"VAR_15caseVAR_15 VAR_153VAR_15:\nVAR_15caseVAR_15 VAR_154VAR_15:\nVAR_15VAR_5VAR_15 = VAR_151VAR_15;",
"VAR_15VAR_9VAR_15 = VAR_1510VAR_15;",
"VAR_15breakVAR_15;",
"VAR_15defaultVAR_15:\nVAR_15VAR_10VAR_15 = \"VAR_15VAR_2VAR_15\";",
"VAR_15gotoVAR_15 VAR_15errorVAR_15;",
"}",
"VAR_15VAR_7VAR_15 = VAR_15VAR_3VAR_15 & VAR_150x80VAR_15;",
"VAR_15ifVAR_15 (VAR_15VAR_5VAR_15 && VAR_15VAR_3VAR_15 & VAR_150x40VAR_15)\nVAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15get_sizeVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_154VAR_15));",
"VAR_15whileVAR_15 (VAR_15VAR_1VAR_15 >= VAR_15VAR_9VAR_15) {",
"VAR_15unsignedVAR_15 VAR_15intVAR_15 VAR_15tflagsVAR_15 = VAR_150VAR_15;",
"VAR_15intVAR_15 VAR_15tunsyncVAR_15 = VAR_150VAR_15;",
"VAR_15ifVAR_15 (VAR_15VAR_5VAR_15) {",
"VAR_15avio_readVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_8VAR_15, VAR_154VAR_15);",
"VAR_15VAR_8VAR_15[VAR_154VAR_15] = VAR_150VAR_15;",
"VAR_15ifVAR_15(VAR_15VAR_2VAR_15==VAR_153VAR_15){",
"VAR_15VAR_6VAR_15 = VAR_15avio_rb32VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);",
"}VAR_15elseVAR_15",
"VAR_15VAR_6VAR_15 = VAR_15get_sizeVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_154VAR_15);",
"VAR_15tflagsVAR_15 = VAR_15avio_rb16VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);",
"VAR_15tunsyncVAR_15 = VAR_15tflagsVAR_15 & VAR_15ID3v2_FLAG_UNSYNCHVAR_15;",
"} VAR_15elseVAR_15 {",
"VAR_15avio_readVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_8VAR_15, VAR_153VAR_15);",
"VAR_15VAR_8VAR_15[VAR_153VAR_15] = VAR_150VAR_15;",
"VAR_15VAR_6VAR_15 = VAR_15avio_rb24VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);",
"}",
"VAR_15ifVAR_15 (VAR_15VAR_6VAR_15 < VAR_150VAR_15 || VAR_15VAR_6VAR_15 > VAR_15VAR_1VAR_15 - VAR_15VAR_9VAR_15) {",
"VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, \"VAR_15InvalidVAR_15 VAR_15sizeVAR_15 VAR_15inVAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15, VAR_15skippingVAR_15 VAR_15theVAR_15 VAR_15restVAR_15 VAR_15ofVAR_15 VAR_15VAR_8VAR_15.\\VAR_15nVAR_15\", VAR_15VAR_8VAR_15);",
"VAR_15breakVAR_15;",
"}",
"VAR_15VAR_1VAR_15 -= VAR_15VAR_9VAR_15 + VAR_15VAR_6VAR_15;",
"VAR_15nextVAR_15 = VAR_15avio_tellVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15) + VAR_15VAR_6VAR_15;",
"VAR_15ifVAR_15 (!VAR_15VAR_6VAR_15) {",
"VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15])\nVAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_DEBUGVAR_15, \"VAR_15InvalidVAR_15 VAR_15emptyVAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15, VAR_15skippingVAR_15.\\VAR_15nVAR_15\", VAR_15VAR_8VAR_15);",
"VAR_15continueVAR_15;",
"}",
"VAR_15ifVAR_15 (VAR_15tflagsVAR_15 & VAR_15ID3v2_FLAG_DATALENVAR_15) {",
"VAR_15avio_rb32VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);",
"VAR_15VAR_6VAR_15 -= VAR_154VAR_15;",
"}",
"VAR_15ifVAR_15 (VAR_15tflagsVAR_15 & (VAR_15ID3v2_FLAG_ENCRYPTIONVAR_15 | VAR_15ID3v2_FLAG_COMPRESSIONVAR_15)) {",
"VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, \"VAR_15SkippingVAR_15 VAR_15encryptedVAR_15/VAR_15compressedVAR_15 VAR_15ID3v2VAR_15 VAR_15frameVAR_15 %VAR_15VAR_0VAR_15.\\VAR_15nVAR_15\", VAR_15VAR_8VAR_15);",
"VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_6VAR_15);",
"} VAR_15elseVAR_15 VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15] == 'VAR_15TVAR_15' || (VAR_15VAR_4VAR_15 && (VAR_15VAR_13VAR_15 = VAR_15get_extra_meta_funcVAR_15(VAR_15VAR_8VAR_15, VAR_15VAR_5VAR_15)->VAR_15readVAR_15))) {",
"VAR_15ifVAR_15 (VAR_15VAR_7VAR_15 || VAR_15tunsyncVAR_15) {",
"VAR_15intVAR_15 VAR_15iVAR_15, VAR_15jVAR_15;",
"VAR_15av_fast_mallocVAR_15(&VAR_15VAR_11VAR_15, &VAR_15VAR_12VAR_15, VAR_15VAR_6VAR_15);",
"VAR_15ifVAR_15 (!VAR_15VAR_11VAR_15) {",
"VAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_ERRORVAR_15, \"VAR_15FailedVAR_15 VAR_15toVAR_15 VAR_15allocVAR_15 %VAR_15dVAR_15 VAR_15bytesVAR_15\\VAR_15nVAR_15\", VAR_15VAR_6VAR_15);",
"VAR_15gotoVAR_15 VAR_15seekVAR_15;",
"}",
"VAR_15forVAR_15 (VAR_15iVAR_15 = VAR_150VAR_15, VAR_15jVAR_15 = VAR_150VAR_15; VAR_15iVAR_15 < VAR_15VAR_6VAR_15; VAR_15iVAR_15++, VAR_15jVAR_15++) {",
"VAR_15VAR_11VAR_15[VAR_15jVAR_15] = VAR_15avio_r8VAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15);",
"VAR_15ifVAR_15 (VAR_15jVAR_15 > VAR_150VAR_15 && !VAR_15VAR_11VAR_15[VAR_15jVAR_15] && VAR_15VAR_11VAR_15[VAR_15jVAR_15 - VAR_151VAR_15] == VAR_150xffVAR_15) {",
"VAR_15jVAR_15--;",
"}",
"}",
"VAR_15ffio_init_contextVAR_15(&VAR_15pbVAR_15, VAR_15VAR_11VAR_15, VAR_15jVAR_15, VAR_150VAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15, VAR_15NULLVAR_15);",
"VAR_15VAR_6VAR_15 = VAR_15jVAR_15;",
"VAR_15pbxVAR_15 = &VAR_15pbVAR_15;",
"} VAR_15elseVAR_15 {",
"VAR_15pbxVAR_15 = VAR_15VAR_0VAR_15->VAR_15pbVAR_15;",
"}",
"VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_150VAR_15] == 'VAR_15TVAR_15')\nVAR_15read_ttagVAR_15(VAR_15VAR_0VAR_15, VAR_15pbxVAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_8VAR_15);",
"VAR_15elseVAR_15\nVAR_15VAR_13VAR_15(VAR_15VAR_0VAR_15, VAR_15pbxVAR_15, VAR_15VAR_6VAR_15, VAR_15VAR_8VAR_15, VAR_15VAR_4VAR_15);",
"}",
"VAR_15elseVAR_15 VAR_15ifVAR_15 (!VAR_15VAR_8VAR_15[VAR_150VAR_15]) {",
"VAR_15ifVAR_15 (VAR_15VAR_8VAR_15[VAR_151VAR_15])\nVAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_WARNINGVAR_15, \"VAR_15invalidVAR_15 VAR_15frameVAR_15 VAR_15idVAR_15, VAR_15assumingVAR_15 VAR_15paddingVAR_15\");",
"VAR_15avio_skipVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15VAR_6VAR_15);",
"VAR_15breakVAR_15;",
"}",
"VAR_15seekVAR_15:\nVAR_15avio_seekVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15nextVAR_15, VAR_15SEEK_SETVAR_15);",
"}",
"VAR_15ifVAR_15 (VAR_15VAR_2VAR_15 == VAR_154VAR_15 && VAR_15VAR_3VAR_15 & VAR_150x10VAR_15)\nVAR_15endVAR_15 += VAR_1510VAR_15;",
"VAR_15errorVAR_15:\nVAR_15ifVAR_15 (VAR_15VAR_10VAR_15)\nVAR_15av_logVAR_15(VAR_15VAR_0VAR_15, VAR_15AV_LOG_INFOVAR_15, \"VAR_15ID3v2VAR_15.%VAR_15dVAR_15 VAR_15VAR_8VAR_15 VAR_15skippedVAR_15, VAR_15cannotVAR_15 VAR_15handleVAR_15 %VAR_15VAR_0VAR_15\\VAR_15nVAR_15\", VAR_15VAR_2VAR_15, VAR_15VAR_10VAR_15);",
"VAR_15avio_seekVAR_15(VAR_15VAR_0VAR_15->VAR_15pbVAR_15, VAR_15endVAR_15, VAR_15SEEK_SETVAR_15);",
"VAR_15av_freeVAR_15(VAR_15VAR_11VAR_15);",
"VAR_15returnVAR_15;",
"}"
] | [
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,
1,
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47,
49,
51
],
[
53
],
[
55
],
[
59,
61
],
[
63
],
[
65
],
[
69
],
[
73,
75
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
129
],
[
131,
133
],
[
135
],
[
137
],
[
141
],
[
143
],
[
145
],
[
147
],
[
151
],
[
153
],
[
155
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201,
205
],
[
207,
211
],
[
213
],
[
215
],
[
217,
219
],
[
221
],
[
223
],
[
225
],
[
229,
231
],
[
233
],
[
237,
239
],
[
243,
245,
247
],
[
249
],
[
251
],
[
253
],
[
255
]
] |
20,594 | static int shorten_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
ShortenContext *s = avctx->priv_data;
int i, input_buf_size = 0;
int16_t *samples = data;
if(s->max_framesize == 0){
s->max_framesize= 1024; // should hopefully be enough for the first header
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
}
if(1 && s->max_framesize){//FIXME truncated
buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
input_buf_size= buf_size;
if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
// printf("memmove\n");
memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
s->bitstream_index=0;
}
memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
buf= &s->bitstream[s->bitstream_index];
buf_size += s->bitstream_size;
s->bitstream_size= buf_size;
if(buf_size < s->max_framesize){
//dprintf("wanna more data ... %d\n", buf_size);
return input_buf_size;
}
}
init_get_bits(&s->gb, buf, buf_size*8);
get_bits(&s->gb, s->bitindex);
if (!s->blocksize)
{
int maxnlpc = 0;
/* shorten signature */
if (get_bits_long(&s->gb, 32) != bswap_32(ff_get_fourcc("ajkg"))) {
av_log(s->avctx, AV_LOG_ERROR, "missing shorten magic 'ajkg'\n");
return -1;
}
s->lpcqoffset = 0;
s->blocksize = DEFAULT_BLOCK_SIZE;
s->channels = 1;
s->nmean = -1;
s->version = get_bits(&s->gb, 8);
s->internal_ftype = get_uint(s, TYPESIZE);
s->channels = get_uint(s, CHANSIZE);
if (s->channels > MAX_CHANNELS) {
av_log(s->avctx, AV_LOG_ERROR, "too many channels: %d\n", s->channels);
return -1;
}
/* get blocksize if version > 0 */
if (s->version > 0) {
int skip_bytes;
s->blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
maxnlpc = get_uint(s, LPCQSIZE);
s->nmean = get_uint(s, 0);
skip_bytes = get_uint(s, NSKIPSIZE);
for (i=0; i<skip_bytes; i++) {
skip_bits(&s->gb, 8);
}
}
s->nwrap = FFMAX(NWRAP, maxnlpc);
allocate_buffers(s);
init_offset(s);
if (s->version > 1)
s->lpcqoffset = V2LPCQOFFSET;
if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {
av_log(s->avctx, AV_LOG_ERROR, "missing verbatim section at begining of stream\n");
return -1;
}
s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
if (s->header_size >= OUT_BUFFER_SIZE || s->header_size < CANONICAL_HEADER_SIZE) {
av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n", s->header_size);
return -1;
}
for (i=0; i<s->header_size; i++)
s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
if (decode_wave_header(avctx, s->header, s->header_size) < 0)
return -1;
s->cur_chan = 0;
s->bitshift = 0;
}
else
{
int cmd;
int len;
cmd = get_ur_golomb_shorten(&s->gb, FNSIZE);
switch (cmd) {
case FN_ZERO:
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
case FN_QLPC:
{
int residual_size = 0;
int channel = s->cur_chan;
int32_t coffset;
if (cmd != FN_ZERO) {
residual_size = get_ur_golomb_shorten(&s->gb, ENERGYSIZE);
/* this is a hack as version 0 differed in defintion of get_sr_golomb_shorten */
if (s->version == 0)
residual_size--;
}
if (s->nmean == 0)
coffset = s->offset[channel][0];
else {
int32_t sum = (s->version < 2) ? 0 : s->nmean / 2;
for (i=0; i<s->nmean; i++)
sum += s->offset[channel][i];
coffset = sum / s->nmean;
if (s->version >= 2)
coffset >>= FFMIN(1, s->bitshift);
}
switch (cmd) {
case FN_ZERO:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = 0;
break;
case FN_DIFF0:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + coffset;
break;
case FN_DIFF1:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + s->decoded[channel][i - 1];
break;
case FN_DIFF2:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + 2*s->decoded[channel][i-1]
- s->decoded[channel][i-2];
break;
case FN_DIFF3:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + 3*s->decoded[channel][i-1]
- 3*s->decoded[channel][i-2]
+ s->decoded[channel][i-3];
break;
case FN_QLPC:
{
int pred_order = get_ur_golomb_shorten(&s->gb, LPCQSIZE);
for (i=0; i<pred_order; i++)
s->decoded[channel][i - pred_order] -= coffset;
decode_subframe_lpc(s, channel, residual_size, pred_order);
if (coffset != 0)
for (i=0; i < s->blocksize; i++)
s->decoded[channel][i] += coffset;
}
}
if (s->nmean > 0) {
int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2;
for (i=0; i<s->blocksize; i++)
sum += s->decoded[channel][i];
for (i=1; i<s->nmean; i++)
s->offset[channel][i-1] = s->offset[channel][i];
if (s->version < 2)
s->offset[channel][s->nmean - 1] = sum / s->blocksize;
else
s->offset[channel][s->nmean - 1] = (sum / s->blocksize) << s->bitshift;
}
for (i=-s->nwrap; i<0; i++)
s->decoded[channel][i] = s->decoded[channel][i + s->blocksize];
fix_bitshift(s, s->decoded[channel]);
s->cur_chan++;
if (s->cur_chan == s->channels) {
samples = interleave_buffer(samples, s->channels, s->blocksize, s->decoded);
s->cur_chan = 0;
goto frame_done;
}
break;
}
break;
case FN_VERBATIM:
len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
while (len--) {
get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
}
break;
case FN_BITSHIFT:
s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
break;
case FN_BLOCKSIZE:
s->blocksize = get_uint(s, av_log2(s->blocksize));
break;
case FN_QUIT:
return buf_size;
break;
default:
av_log(avctx, AV_LOG_ERROR, "unknown shorten function %d\n", cmd);
return -1;
break;
}
}
frame_done:
*data_size = (int8_t *)samples - (int8_t *)data;
// s->last_blocksize = s->blocksize;
s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8);
i= (get_bits_count(&s->gb))/8;
if (i > buf_size) {
av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
s->bitstream_size=0;
s->bitstream_index=0;
return -1;
}
if (s->bitstream_size) {
s->bitstream_index += i;
s->bitstream_size -= i;
return input_buf_size;
} else
return i;
}
| true | FFmpeg | 1e25a7e7ebb55516d522a8ab1c4b7938b5060fe5 | static int shorten_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
ShortenContext *s = avctx->priv_data;
int i, input_buf_size = 0;
int16_t *samples = data;
if(s->max_framesize == 0){
s->max_framesize= 1024;
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
}
if(1 && s->max_framesize){
buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
input_buf_size= buf_size;
if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
s->bitstream_index=0;
}
memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
buf= &s->bitstream[s->bitstream_index];
buf_size += s->bitstream_size;
s->bitstream_size= buf_size;
if(buf_size < s->max_framesize){
return input_buf_size;
}
}
init_get_bits(&s->gb, buf, buf_size*8);
get_bits(&s->gb, s->bitindex);
if (!s->blocksize)
{
int maxnlpc = 0;
if (get_bits_long(&s->gb, 32) != bswap_32(ff_get_fourcc("ajkg"))) {
av_log(s->avctx, AV_LOG_ERROR, "missing shorten magic 'ajkg'\n");
return -1;
}
s->lpcqoffset = 0;
s->blocksize = DEFAULT_BLOCK_SIZE;
s->channels = 1;
s->nmean = -1;
s->version = get_bits(&s->gb, 8);
s->internal_ftype = get_uint(s, TYPESIZE);
s->channels = get_uint(s, CHANSIZE);
if (s->channels > MAX_CHANNELS) {
av_log(s->avctx, AV_LOG_ERROR, "too many channels: %d\n", s->channels);
return -1;
}
if (s->version > 0) {
int skip_bytes;
s->blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
maxnlpc = get_uint(s, LPCQSIZE);
s->nmean = get_uint(s, 0);
skip_bytes = get_uint(s, NSKIPSIZE);
for (i=0; i<skip_bytes; i++) {
skip_bits(&s->gb, 8);
}
}
s->nwrap = FFMAX(NWRAP, maxnlpc);
allocate_buffers(s);
init_offset(s);
if (s->version > 1)
s->lpcqoffset = V2LPCQOFFSET;
if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {
av_log(s->avctx, AV_LOG_ERROR, "missing verbatim section at begining of stream\n");
return -1;
}
s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
if (s->header_size >= OUT_BUFFER_SIZE || s->header_size < CANONICAL_HEADER_SIZE) {
av_log(s->avctx, AV_LOG_ERROR, "header is wrong size: %d\n", s->header_size);
return -1;
}
for (i=0; i<s->header_size; i++)
s->header[i] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
if (decode_wave_header(avctx, s->header, s->header_size) < 0)
return -1;
s->cur_chan = 0;
s->bitshift = 0;
}
else
{
int cmd;
int len;
cmd = get_ur_golomb_shorten(&s->gb, FNSIZE);
switch (cmd) {
case FN_ZERO:
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
case FN_QLPC:
{
int residual_size = 0;
int channel = s->cur_chan;
int32_t coffset;
if (cmd != FN_ZERO) {
residual_size = get_ur_golomb_shorten(&s->gb, ENERGYSIZE);
if (s->version == 0)
residual_size--;
}
if (s->nmean == 0)
coffset = s->offset[channel][0];
else {
int32_t sum = (s->version < 2) ? 0 : s->nmean / 2;
for (i=0; i<s->nmean; i++)
sum += s->offset[channel][i];
coffset = sum / s->nmean;
if (s->version >= 2)
coffset >>= FFMIN(1, s->bitshift);
}
switch (cmd) {
case FN_ZERO:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = 0;
break;
case FN_DIFF0:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + coffset;
break;
case FN_DIFF1:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + s->decoded[channel][i - 1];
break;
case FN_DIFF2:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + 2*s->decoded[channel][i-1]
- s->decoded[channel][i-2];
break;
case FN_DIFF3:
for (i=0; i<s->blocksize; i++)
s->decoded[channel][i] = get_sr_golomb_shorten(&s->gb, residual_size) + 3*s->decoded[channel][i-1]
- 3*s->decoded[channel][i-2]
+ s->decoded[channel][i-3];
break;
case FN_QLPC:
{
int pred_order = get_ur_golomb_shorten(&s->gb, LPCQSIZE);
for (i=0; i<pred_order; i++)
s->decoded[channel][i - pred_order] -= coffset;
decode_subframe_lpc(s, channel, residual_size, pred_order);
if (coffset != 0)
for (i=0; i < s->blocksize; i++)
s->decoded[channel][i] += coffset;
}
}
if (s->nmean > 0) {
int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2;
for (i=0; i<s->blocksize; i++)
sum += s->decoded[channel][i];
for (i=1; i<s->nmean; i++)
s->offset[channel][i-1] = s->offset[channel][i];
if (s->version < 2)
s->offset[channel][s->nmean - 1] = sum / s->blocksize;
else
s->offset[channel][s->nmean - 1] = (sum / s->blocksize) << s->bitshift;
}
for (i=-s->nwrap; i<0; i++)
s->decoded[channel][i] = s->decoded[channel][i + s->blocksize];
fix_bitshift(s, s->decoded[channel]);
s->cur_chan++;
if (s->cur_chan == s->channels) {
samples = interleave_buffer(samples, s->channels, s->blocksize, s->decoded);
s->cur_chan = 0;
goto frame_done;
}
break;
}
break;
case FN_VERBATIM:
len = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
while (len--) {
get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
}
break;
case FN_BITSHIFT:
s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
break;
case FN_BLOCKSIZE:
s->blocksize = get_uint(s, av_log2(s->blocksize));
break;
case FN_QUIT:
return buf_size;
break;
default:
av_log(avctx, AV_LOG_ERROR, "unknown shorten function %d\n", cmd);
return -1;
break;
}
}
frame_done:
*data_size = (int8_t *)samples - (int8_t *)data;
s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8);
i= (get_bits_count(&s->gb))/8;
if (i > buf_size) {
av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
s->bitstream_size=0;
s->bitstream_index=0;
return -1;
}
if (s->bitstream_size) {
s->bitstream_index += i;
s->bitstream_size -= i;
return input_buf_size;
} else
return i;
}
| {
"code": [
" allocate_buffers(s);"
],
"line_no": [
139
]
} | static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
uint8_t *VAR_3, int VAR_4)
{
ShortenContext *s = VAR_0->priv_data;
int VAR_5, VAR_6 = 0;
int16_t *samples = VAR_1;
if(s->max_framesize == 0){
s->max_framesize= 1024;
s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
}
if(1 && s->max_framesize){
VAR_4= FFMIN(VAR_4, s->max_framesize - s->bitstream_size);
VAR_6= VAR_4;
if(s->bitstream_index + s->bitstream_size + VAR_4 > s->allocated_bitstream_size){
memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
s->bitstream_index=0;
}
memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], VAR_3, VAR_4);
VAR_3= &s->bitstream[s->bitstream_index];
VAR_4 += s->bitstream_size;
s->bitstream_size= VAR_4;
if(VAR_4 < s->max_framesize){
return VAR_6;
}
}
init_get_bits(&s->gb, VAR_3, VAR_4*8);
get_bits(&s->gb, s->bitindex);
if (!s->blocksize)
{
int VAR_7 = 0;
if (get_bits_long(&s->gb, 32) != bswap_32(ff_get_fourcc("ajkg"))) {
av_log(s->VAR_0, AV_LOG_ERROR, "missing shorten magic 'ajkg'\n");
return -1;
}
s->lpcqoffset = 0;
s->blocksize = DEFAULT_BLOCK_SIZE;
s->channels = 1;
s->nmean = -1;
s->version = get_bits(&s->gb, 8);
s->internal_ftype = get_uint(s, TYPESIZE);
s->channels = get_uint(s, CHANSIZE);
if (s->channels > MAX_CHANNELS) {
av_log(s->VAR_0, AV_LOG_ERROR, "too many channels: %d\n", s->channels);
return -1;
}
if (s->version > 0) {
int VAR_8;
s->blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
VAR_7 = get_uint(s, LPCQSIZE);
s->nmean = get_uint(s, 0);
VAR_8 = get_uint(s, NSKIPSIZE);
for (VAR_5=0; VAR_5<VAR_8; VAR_5++) {
skip_bits(&s->gb, 8);
}
}
s->nwrap = FFMAX(NWRAP, VAR_7);
allocate_buffers(s);
init_offset(s);
if (s->version > 1)
s->lpcqoffset = V2LPCQOFFSET;
if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {
av_log(s->VAR_0, AV_LOG_ERROR, "missing verbatim section at begining of stream\n");
return -1;
}
s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
if (s->header_size >= OUT_BUFFER_SIZE || s->header_size < CANONICAL_HEADER_SIZE) {
av_log(s->VAR_0, AV_LOG_ERROR, "header is wrong size: %d\n", s->header_size);
return -1;
}
for (VAR_5=0; VAR_5<s->header_size; VAR_5++)
s->header[VAR_5] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
if (decode_wave_header(VAR_0, s->header, s->header_size) < 0)
return -1;
s->cur_chan = 0;
s->bitshift = 0;
}
else
{
int VAR_9;
int VAR_10;
VAR_9 = get_ur_golomb_shorten(&s->gb, FNSIZE);
switch (VAR_9) {
case FN_ZERO:
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
case FN_QLPC:
{
int VAR_11 = 0;
int VAR_12 = s->cur_chan;
int32_t coffset;
if (VAR_9 != FN_ZERO) {
VAR_11 = get_ur_golomb_shorten(&s->gb, ENERGYSIZE);
if (s->version == 0)
VAR_11--;
}
if (s->nmean == 0)
coffset = s->offset[VAR_12][0];
else {
int32_t sum = (s->version < 2) ? 0 : s->nmean / 2;
for (VAR_5=0; VAR_5<s->nmean; VAR_5++)
sum += s->offset[VAR_12][VAR_5];
coffset = sum / s->nmean;
if (s->version >= 2)
coffset >>= FFMIN(1, s->bitshift);
}
switch (VAR_9) {
case FN_ZERO:
for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)
s->decoded[VAR_12][VAR_5] = 0;
break;
case FN_DIFF0:
for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)
s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + coffset;
break;
case FN_DIFF1:
for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)
s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + s->decoded[VAR_12][VAR_5 - 1];
break;
case FN_DIFF2:
for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)
s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + 2*s->decoded[VAR_12][VAR_5-1]
- s->decoded[VAR_12][VAR_5-2];
break;
case FN_DIFF3:
for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)
s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + 3*s->decoded[VAR_12][VAR_5-1]
- 3*s->decoded[VAR_12][VAR_5-2]
+ s->decoded[VAR_12][VAR_5-3];
break;
case FN_QLPC:
{
int VAR_13 = get_ur_golomb_shorten(&s->gb, LPCQSIZE);
for (VAR_5=0; VAR_5<VAR_13; VAR_5++)
s->decoded[VAR_12][VAR_5 - VAR_13] -= coffset;
decode_subframe_lpc(s, VAR_12, VAR_11, VAR_13);
if (coffset != 0)
for (VAR_5=0; VAR_5 < s->blocksize; VAR_5++)
s->decoded[VAR_12][VAR_5] += coffset;
}
}
if (s->nmean > 0) {
int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2;
for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)
sum += s->decoded[VAR_12][VAR_5];
for (VAR_5=1; VAR_5<s->nmean; VAR_5++)
s->offset[VAR_12][VAR_5-1] = s->offset[VAR_12][VAR_5];
if (s->version < 2)
s->offset[VAR_12][s->nmean - 1] = sum / s->blocksize;
else
s->offset[VAR_12][s->nmean - 1] = (sum / s->blocksize) << s->bitshift;
}
for (VAR_5=-s->nwrap; VAR_5<0; VAR_5++)
s->decoded[VAR_12][VAR_5] = s->decoded[VAR_12][VAR_5 + s->blocksize];
fix_bitshift(s, s->decoded[VAR_12]);
s->cur_chan++;
if (s->cur_chan == s->channels) {
samples = interleave_buffer(samples, s->channels, s->blocksize, s->decoded);
s->cur_chan = 0;
goto frame_done;
}
break;
}
break;
case FN_VERBATIM:
VAR_10 = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);
while (VAR_10--) {
get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);
}
break;
case FN_BITSHIFT:
s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
break;
case FN_BLOCKSIZE:
s->blocksize = get_uint(s, av_log2(s->blocksize));
break;
case FN_QUIT:
return VAR_4;
break;
default:
av_log(VAR_0, AV_LOG_ERROR, "unknown shorten function %d\n", VAR_9);
return -1;
break;
}
}
frame_done:
*VAR_2 = (int8_t *)samples - (int8_t *)VAR_1;
s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8);
VAR_5= (get_bits_count(&s->gb))/8;
if (VAR_5 > VAR_4) {
av_log(s->VAR_0, AV_LOG_ERROR, "overread: %d\n", VAR_5 - VAR_4);
s->bitstream_size=0;
s->bitstream_index=0;
return -1;
}
if (s->bitstream_size) {
s->bitstream_index += VAR_5;
s->bitstream_size -= VAR_5;
return VAR_6;
} else
return VAR_5;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{",
"ShortenContext *s = VAR_0->priv_data;",
"int VAR_5, VAR_6 = 0;",
"int16_t *samples = VAR_1;",
"if(s->max_framesize == 0){",
"s->max_framesize= 1024;",
"s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);",
"}",
"if(1 && s->max_framesize){",
"VAR_4= FFMIN(VAR_4, s->max_framesize - s->bitstream_size);",
"VAR_6= VAR_4;",
"if(s->bitstream_index + s->bitstream_size + VAR_4 > s->allocated_bitstream_size){",
"memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);",
"s->bitstream_index=0;",
"}",
"memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], VAR_3, VAR_4);",
"VAR_3= &s->bitstream[s->bitstream_index];",
"VAR_4 += s->bitstream_size;",
"s->bitstream_size= VAR_4;",
"if(VAR_4 < s->max_framesize){",
"return VAR_6;",
"}",
"}",
"init_get_bits(&s->gb, VAR_3, VAR_4*8);",
"get_bits(&s->gb, s->bitindex);",
"if (!s->blocksize)\n{",
"int VAR_7 = 0;",
"if (get_bits_long(&s->gb, 32) != bswap_32(ff_get_fourcc(\"ajkg\"))) {",
"av_log(s->VAR_0, AV_LOG_ERROR, \"missing shorten magic 'ajkg'\\n\");",
"return -1;",
"}",
"s->lpcqoffset = 0;",
"s->blocksize = DEFAULT_BLOCK_SIZE;",
"s->channels = 1;",
"s->nmean = -1;",
"s->version = get_bits(&s->gb, 8);",
"s->internal_ftype = get_uint(s, TYPESIZE);",
"s->channels = get_uint(s, CHANSIZE);",
"if (s->channels > MAX_CHANNELS) {",
"av_log(s->VAR_0, AV_LOG_ERROR, \"too many channels: %d\\n\", s->channels);",
"return -1;",
"}",
"if (s->version > 0) {",
"int VAR_8;",
"s->blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));",
"VAR_7 = get_uint(s, LPCQSIZE);",
"s->nmean = get_uint(s, 0);",
"VAR_8 = get_uint(s, NSKIPSIZE);",
"for (VAR_5=0; VAR_5<VAR_8; VAR_5++) {",
"skip_bits(&s->gb, 8);",
"}",
"}",
"s->nwrap = FFMAX(NWRAP, VAR_7);",
"allocate_buffers(s);",
"init_offset(s);",
"if (s->version > 1)\ns->lpcqoffset = V2LPCQOFFSET;",
"if (get_ur_golomb_shorten(&s->gb, FNSIZE) != FN_VERBATIM) {",
"av_log(s->VAR_0, AV_LOG_ERROR, \"missing verbatim section at begining of stream\\n\");",
"return -1;",
"}",
"s->header_size = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);",
"if (s->header_size >= OUT_BUFFER_SIZE || s->header_size < CANONICAL_HEADER_SIZE) {",
"av_log(s->VAR_0, AV_LOG_ERROR, \"header is wrong size: %d\\n\", s->header_size);",
"return -1;",
"}",
"for (VAR_5=0; VAR_5<s->header_size; VAR_5++)",
"s->header[VAR_5] = (char)get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);",
"if (decode_wave_header(VAR_0, s->header, s->header_size) < 0)\nreturn -1;",
"s->cur_chan = 0;",
"s->bitshift = 0;",
"}",
"else\n{",
"int VAR_9;",
"int VAR_10;",
"VAR_9 = get_ur_golomb_shorten(&s->gb, FNSIZE);",
"switch (VAR_9) {",
"case FN_ZERO:\ncase FN_DIFF0:\ncase FN_DIFF1:\ncase FN_DIFF2:\ncase FN_DIFF3:\ncase FN_QLPC:\n{",
"int VAR_11 = 0;",
"int VAR_12 = s->cur_chan;",
"int32_t coffset;",
"if (VAR_9 != FN_ZERO) {",
"VAR_11 = get_ur_golomb_shorten(&s->gb, ENERGYSIZE);",
"if (s->version == 0)\nVAR_11--;",
"}",
"if (s->nmean == 0)\ncoffset = s->offset[VAR_12][0];",
"else {",
"int32_t sum = (s->version < 2) ? 0 : s->nmean / 2;",
"for (VAR_5=0; VAR_5<s->nmean; VAR_5++)",
"sum += s->offset[VAR_12][VAR_5];",
"coffset = sum / s->nmean;",
"if (s->version >= 2)\ncoffset >>= FFMIN(1, s->bitshift);",
"}",
"switch (VAR_9) {",
"case FN_ZERO:\nfor (VAR_5=0; VAR_5<s->blocksize; VAR_5++)",
"s->decoded[VAR_12][VAR_5] = 0;",
"break;",
"case FN_DIFF0:\nfor (VAR_5=0; VAR_5<s->blocksize; VAR_5++)",
"s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + coffset;",
"break;",
"case FN_DIFF1:\nfor (VAR_5=0; VAR_5<s->blocksize; VAR_5++)",
"s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + s->decoded[VAR_12][VAR_5 - 1];",
"break;",
"case FN_DIFF2:\nfor (VAR_5=0; VAR_5<s->blocksize; VAR_5++)",
"s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + 2*s->decoded[VAR_12][VAR_5-1]\n- s->decoded[VAR_12][VAR_5-2];",
"break;",
"case FN_DIFF3:\nfor (VAR_5=0; VAR_5<s->blocksize; VAR_5++)",
"s->decoded[VAR_12][VAR_5] = get_sr_golomb_shorten(&s->gb, VAR_11) + 3*s->decoded[VAR_12][VAR_5-1]\n- 3*s->decoded[VAR_12][VAR_5-2]\n+ s->decoded[VAR_12][VAR_5-3];",
"break;",
"case FN_QLPC:\n{",
"int VAR_13 = get_ur_golomb_shorten(&s->gb, LPCQSIZE);",
"for (VAR_5=0; VAR_5<VAR_13; VAR_5++)",
"s->decoded[VAR_12][VAR_5 - VAR_13] -= coffset;",
"decode_subframe_lpc(s, VAR_12, VAR_11, VAR_13);",
"if (coffset != 0)\nfor (VAR_5=0; VAR_5 < s->blocksize; VAR_5++)",
"s->decoded[VAR_12][VAR_5] += coffset;",
"}",
"}",
"if (s->nmean > 0) {",
"int32_t sum = (s->version < 2) ? 0 : s->blocksize / 2;",
"for (VAR_5=0; VAR_5<s->blocksize; VAR_5++)",
"sum += s->decoded[VAR_12][VAR_5];",
"for (VAR_5=1; VAR_5<s->nmean; VAR_5++)",
"s->offset[VAR_12][VAR_5-1] = s->offset[VAR_12][VAR_5];",
"if (s->version < 2)\ns->offset[VAR_12][s->nmean - 1] = sum / s->blocksize;",
"else\ns->offset[VAR_12][s->nmean - 1] = (sum / s->blocksize) << s->bitshift;",
"}",
"for (VAR_5=-s->nwrap; VAR_5<0; VAR_5++)",
"s->decoded[VAR_12][VAR_5] = s->decoded[VAR_12][VAR_5 + s->blocksize];",
"fix_bitshift(s, s->decoded[VAR_12]);",
"s->cur_chan++;",
"if (s->cur_chan == s->channels) {",
"samples = interleave_buffer(samples, s->channels, s->blocksize, s->decoded);",
"s->cur_chan = 0;",
"goto frame_done;",
"}",
"break;",
"}",
"break;",
"case FN_VERBATIM:\nVAR_10 = get_ur_golomb_shorten(&s->gb, VERBATIM_CKSIZE_SIZE);",
"while (VAR_10--) {",
"get_ur_golomb_shorten(&s->gb, VERBATIM_BYTE_SIZE);",
"}",
"break;",
"case FN_BITSHIFT:\ns->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);",
"break;",
"case FN_BLOCKSIZE:\ns->blocksize = get_uint(s, av_log2(s->blocksize));",
"break;",
"case FN_QUIT:\nreturn VAR_4;",
"break;",
"default:\nav_log(VAR_0, AV_LOG_ERROR, \"unknown shorten function %d\\n\", VAR_9);",
"return -1;",
"break;",
"}",
"}",
"frame_done:\n*VAR_2 = (int8_t *)samples - (int8_t *)VAR_1;",
"s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8);",
"VAR_5= (get_bits_count(&s->gb))/8;",
"if (VAR_5 > VAR_4) {",
"av_log(s->VAR_0, AV_LOG_ERROR, \"overread: %d\\n\", VAR_5 - VAR_4);",
"s->bitstream_size=0;",
"s->bitstream_index=0;",
"return -1;",
"}",
"if (s->bitstream_size) {",
"s->bitstream_index += VAR_5;",
"s->bitstream_size -= VAR_5;",
"return VAR_6;",
"} else",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
139
],
[
143
],
[
147,
149
],
[
153
],
[
155
],
[
157
],
[
159
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
175
],
[
177
],
[
181,
183
],
[
187
],
[
189
],
[
191
],
[
193,
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205,
207,
209,
211,
213,
215,
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
231,
233
],
[
235
],
[
239,
241
],
[
243
],
[
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
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319,
321
],
[
323
],
[
325
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
339
],
[
341
],
[
345,
347
],
[
349,
351
],
[
353
],
[
355
],
[
357
],
[
361
],
[
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
],
[
425,
427
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445
],
[
447
],
[
449
],
[
451
],
[
453
],
[
455
],
[
457
],
[
459
],
[
461
]
] |
20,595 | static void apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
{
int size = 0;
const uint8_t *data;
uint32_t flags;
if (!(avctx->codec->capabilities & CODEC_CAP_PARAM_CHANGE))
return;
data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
if (!data || size < 4)
return;
flags = bytestream_get_le32(&data);
size -= 4;
if (size < 4) /* Required for any of the changes */
return;
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
avctx->channels = bytestream_get_le32(&data);
size -= 4;
}
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
if (size < 8)
return;
avctx->channel_layout = bytestream_get_le64(&data);
size -= 8;
}
if (size < 4)
return;
if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
avctx->sample_rate = bytestream_get_le32(&data);
size -= 4;
}
if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
if (size < 8)
return;
avctx->width = bytestream_get_le32(&data);
avctx->height = bytestream_get_le32(&data);
avcodec_set_dimensions(avctx, avctx->width, avctx->height);
size -= 8;
}
}
| false | FFmpeg | b9589f5a770ec2357ab7920a5fabe8510b8601f9 | static void apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
{
int size = 0;
const uint8_t *data;
uint32_t flags;
if (!(avctx->codec->capabilities & CODEC_CAP_PARAM_CHANGE))
return;
data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
if (!data || size < 4)
return;
flags = bytestream_get_le32(&data);
size -= 4;
if (size < 4)
return;
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
avctx->channels = bytestream_get_le32(&data);
size -= 4;
}
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
if (size < 8)
return;
avctx->channel_layout = bytestream_get_le64(&data);
size -= 8;
}
if (size < 4)
return;
if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
avctx->sample_rate = bytestream_get_le32(&data);
size -= 4;
}
if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
if (size < 8)
return;
avctx->width = bytestream_get_le32(&data);
avctx->height = bytestream_get_le32(&data);
avcodec_set_dimensions(avctx, avctx->width, avctx->height);
size -= 8;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1)
{
int VAR_2 = 0;
const uint8_t *VAR_3;
uint32_t flags;
if (!(VAR_0->codec->capabilities & CODEC_CAP_PARAM_CHANGE))
return;
VAR_3 = av_packet_get_side_data(VAR_1, AV_PKT_DATA_PARAM_CHANGE, &VAR_2);
if (!VAR_3 || VAR_2 < 4)
return;
flags = bytestream_get_le32(&VAR_3);
VAR_2 -= 4;
if (VAR_2 < 4)
return;
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
VAR_0->channels = bytestream_get_le32(&VAR_3);
VAR_2 -= 4;
}
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
if (VAR_2 < 8)
return;
VAR_0->channel_layout = bytestream_get_le64(&VAR_3);
VAR_2 -= 8;
}
if (VAR_2 < 4)
return;
if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
VAR_0->sample_rate = bytestream_get_le32(&VAR_3);
VAR_2 -= 4;
}
if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
if (VAR_2 < 8)
return;
VAR_0->width = bytestream_get_le32(&VAR_3);
VAR_0->height = bytestream_get_le32(&VAR_3);
avcodec_set_dimensions(VAR_0, VAR_0->width, VAR_0->height);
VAR_2 -= 8;
}
}
| [
"static void FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1)\n{",
"int VAR_2 = 0;",
"const uint8_t *VAR_3;",
"uint32_t flags;",
"if (!(VAR_0->codec->capabilities & CODEC_CAP_PARAM_CHANGE))\nreturn;",
"VAR_3 = av_packet_get_side_data(VAR_1, AV_PKT_DATA_PARAM_CHANGE, &VAR_2);",
"if (!VAR_3 || VAR_2 < 4)\nreturn;",
"flags = bytestream_get_le32(&VAR_3);",
"VAR_2 -= 4;",
"if (VAR_2 < 4)\nreturn;",
"if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {",
"VAR_0->channels = bytestream_get_le32(&VAR_3);",
"VAR_2 -= 4;",
"}",
"if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {",
"if (VAR_2 < 8)\nreturn;",
"VAR_0->channel_layout = bytestream_get_le64(&VAR_3);",
"VAR_2 -= 8;",
"}",
"if (VAR_2 < 4)\nreturn;",
"if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {",
"VAR_0->sample_rate = bytestream_get_le32(&VAR_3);",
"VAR_2 -= 4;",
"}",
"if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {",
"if (VAR_2 < 8)\nreturn;",
"VAR_0->width = bytestream_get_le32(&VAR_3);",
"VAR_0->height = bytestream_get_le32(&VAR_3);",
"avcodec_set_dimensions(VAR_0, VAR_0->width, VAR_0->height);",
"VAR_2 -= 8;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
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
]
] |
20,597 | static int net_client_init1(const void *object, int is_netdev, Error **errp)
{
union {
const Netdev *netdev;
const NetLegacy *net;
} u;
const NetClientOptions *opts;
const char *name;
if (is_netdev) {
u.netdev = object;
opts = u.netdev->opts;
name = u.netdev->id;
switch (opts->kind) {
#ifdef CONFIG_SLIRP
case NET_CLIENT_OPTIONS_KIND_USER:
#endif
case NET_CLIENT_OPTIONS_KIND_TAP:
case NET_CLIENT_OPTIONS_KIND_SOCKET:
#ifdef CONFIG_VDE
case NET_CLIENT_OPTIONS_KIND_VDE:
#endif
#ifdef CONFIG_NETMAP
case NET_CLIENT_OPTIONS_KIND_NETMAP:
#endif
#ifdef CONFIG_NET_BRIDGE
case NET_CLIENT_OPTIONS_KIND_BRIDGE:
#endif
case NET_CLIENT_OPTIONS_KIND_HUBPORT:
#ifdef CONFIG_VHOST_NET_USED
case NET_CLIENT_OPTIONS_KIND_VHOST_USER:
#endif
#ifdef CONFIG_LINUX
case NET_CLIENT_OPTIONS_KIND_L2TPV3:
#endif
break;
default:
error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
"a netdev backend type");
return -1;
}
} else {
u.net = object;
opts = u.net->opts;
/* missing optional values have been initialized to "all bits zero" */
name = u.net->has_id ? u.net->id : u.net->name;
}
if (net_client_init_fun[opts->kind]) {
NetClientState *peer = NULL;
/* Do not add to a vlan if it's a -netdev or a nic with a netdev=
* parameter. */
if (!is_netdev &&
(opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
!opts->nic->has_netdev)) {
peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
}
if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
/* TODO push error reporting into init() methods */
error_set(errp, QERR_DEVICE_INIT_FAILED,
NetClientOptionsKind_lookup[opts->kind]);
return -1;
}
}
return 0;
}
| true | qemu | 015a33bd05b7fd69f400d4e0e4a9925af9292548 | static int net_client_init1(const void *object, int is_netdev, Error **errp)
{
union {
const Netdev *netdev;
const NetLegacy *net;
} u;
const NetClientOptions *opts;
const char *name;
if (is_netdev) {
u.netdev = object;
opts = u.netdev->opts;
name = u.netdev->id;
switch (opts->kind) {
#ifdef CONFIG_SLIRP
case NET_CLIENT_OPTIONS_KIND_USER:
#endif
case NET_CLIENT_OPTIONS_KIND_TAP:
case NET_CLIENT_OPTIONS_KIND_SOCKET:
#ifdef CONFIG_VDE
case NET_CLIENT_OPTIONS_KIND_VDE:
#endif
#ifdef CONFIG_NETMAP
case NET_CLIENT_OPTIONS_KIND_NETMAP:
#endif
#ifdef CONFIG_NET_BRIDGE
case NET_CLIENT_OPTIONS_KIND_BRIDGE:
#endif
case NET_CLIENT_OPTIONS_KIND_HUBPORT:
#ifdef CONFIG_VHOST_NET_USED
case NET_CLIENT_OPTIONS_KIND_VHOST_USER:
#endif
#ifdef CONFIG_LINUX
case NET_CLIENT_OPTIONS_KIND_L2TPV3:
#endif
break;
default:
error_set(errp, QERR_INVALID_PARAMETER_VALUE, "type",
"a netdev backend type");
return -1;
}
} else {
u.net = object;
opts = u.net->opts;
name = u.net->has_id ? u.net->id : u.net->name;
}
if (net_client_init_fun[opts->kind]) {
NetClientState *peer = NULL;
if (!is_netdev &&
(opts->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
!opts->nic->has_netdev)) {
peer = net_hub_add_port(u.net->has_vlan ? u.net->vlan : 0, NULL);
}
if (net_client_init_fun[opts->kind](opts, name, peer) < 0) {
error_set(errp, QERR_DEVICE_INIT_FAILED,
NetClientOptionsKind_lookup[opts->kind]);
return -1;
}
}
return 0;
}
| {
"code": [
"#ifdef CONFIG_LINUX",
"#ifdef CONFIG_LINUX"
],
"line_no": [
67,
67
]
} | static int FUNC_0(const void *VAR_0, int VAR_1, Error **VAR_2)
{
union {
const Netdev *netdev;
const NetLegacy *net;
} VAR_3;
const NetClientOptions *VAR_4;
const char *VAR_5;
if (VAR_1) {
VAR_3.netdev = VAR_0;
VAR_4 = VAR_3.netdev->VAR_4;
VAR_5 = VAR_3.netdev->id;
switch (VAR_4->kind) {
#ifdef CONFIG_SLIRP
case NET_CLIENT_OPTIONS_KIND_USER:
#endif
case NET_CLIENT_OPTIONS_KIND_TAP:
case NET_CLIENT_OPTIONS_KIND_SOCKET:
#ifdef CONFIG_VDE
case NET_CLIENT_OPTIONS_KIND_VDE:
#endif
#ifdef CONFIG_NETMAP
case NET_CLIENT_OPTIONS_KIND_NETMAP:
#endif
#ifdef CONFIG_NET_BRIDGE
case NET_CLIENT_OPTIONS_KIND_BRIDGE:
#endif
case NET_CLIENT_OPTIONS_KIND_HUBPORT:
#ifdef CONFIG_VHOST_NET_USED
case NET_CLIENT_OPTIONS_KIND_VHOST_USER:
#endif
#ifdef CONFIG_LINUX
case NET_CLIENT_OPTIONS_KIND_L2TPV3:
#endif
break;
default:
error_set(VAR_2, QERR_INVALID_PARAMETER_VALUE, "type",
"a netdev backend type");
return -1;
}
} else {
VAR_3.net = VAR_0;
VAR_4 = VAR_3.net->VAR_4;
VAR_5 = VAR_3.net->has_id ? VAR_3.net->id : VAR_3.net->VAR_5;
}
if (net_client_init_fun[VAR_4->kind]) {
NetClientState *peer = NULL;
if (!VAR_1 &&
(VAR_4->kind != NET_CLIENT_OPTIONS_KIND_NIC ||
!VAR_4->nic->has_netdev)) {
peer = net_hub_add_port(VAR_3.net->has_vlan ? VAR_3.net->vlan : 0, NULL);
}
if (net_client_init_fun[VAR_4->kind](VAR_4, VAR_5, peer) < 0) {
error_set(VAR_2, QERR_DEVICE_INIT_FAILED,
NetClientOptionsKind_lookup[VAR_4->kind]);
return -1;
}
}
return 0;
}
| [
"static int FUNC_0(const void *VAR_0, int VAR_1, Error **VAR_2)\n{",
"union {",
"const Netdev *netdev;",
"const NetLegacy *net;",
"} VAR_3;",
"const NetClientOptions *VAR_4;",
"const char *VAR_5;",
"if (VAR_1) {",
"VAR_3.netdev = VAR_0;",
"VAR_4 = VAR_3.netdev->VAR_4;",
"VAR_5 = VAR_3.netdev->id;",
"switch (VAR_4->kind) {",
"#ifdef CONFIG_SLIRP\ncase NET_CLIENT_OPTIONS_KIND_USER:\n#endif\ncase NET_CLIENT_OPTIONS_KIND_TAP:\ncase NET_CLIENT_OPTIONS_KIND_SOCKET:\n#ifdef CONFIG_VDE\ncase NET_CLIENT_OPTIONS_KIND_VDE:\n#endif\n#ifdef CONFIG_NETMAP\ncase NET_CLIENT_OPTIONS_KIND_NETMAP:\n#endif\n#ifdef CONFIG_NET_BRIDGE\ncase NET_CLIENT_OPTIONS_KIND_BRIDGE:\n#endif\ncase NET_CLIENT_OPTIONS_KIND_HUBPORT:\n#ifdef CONFIG_VHOST_NET_USED\ncase NET_CLIENT_OPTIONS_KIND_VHOST_USER:\n#endif\n#ifdef CONFIG_LINUX\ncase NET_CLIENT_OPTIONS_KIND_L2TPV3:\n#endif\nbreak;",
"default:\nerror_set(VAR_2, QERR_INVALID_PARAMETER_VALUE, \"type\",\n\"a netdev backend type\");",
"return -1;",
"}",
"} else {",
"VAR_3.net = VAR_0;",
"VAR_4 = VAR_3.net->VAR_4;",
"VAR_5 = VAR_3.net->has_id ? VAR_3.net->id : VAR_3.net->VAR_5;",
"}",
"if (net_client_init_fun[VAR_4->kind]) {",
"NetClientState *peer = NULL;",
"if (!VAR_1 &&\n(VAR_4->kind != NET_CLIENT_OPTIONS_KIND_NIC ||\n!VAR_4->nic->has_netdev)) {",
"peer = net_hub_add_port(VAR_3.net->has_vlan ? VAR_3.net->vlan : 0, NULL);",
"}",
"if (net_client_init_fun[VAR_4->kind](VAR_4, VAR_5, peer) < 0) {",
"error_set(VAR_2, QERR_DEVICE_INIT_FAILED,\nNetClientOptionsKind_lookup[VAR_4->kind]);",
"return -1;",
"}",
"}",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
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
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
101
],
[
103
],
[
111,
113,
115
],
[
117
],
[
119
],
[
123
],
[
127,
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
]
] |
20,598 | bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov)
{
BlockDriver *drv = bs->drv;
if (!drv->bdrv_co_pwritev_compressed) {
return -ENOTSUP;
return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov); | true | qemu | d470ad42acfc73c45d3e8ed5311a491160b4c100 | bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov)
{
BlockDriver *drv = bs->drv;
if (!drv->bdrv_co_pwritev_compressed) {
return -ENOTSUP;
return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov); | {
"code": [],
"line_no": []
} | FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,
uint64_t VAR_2, QEMUIOVector *VAR_3)
{
BlockDriver *drv = VAR_0->drv;
if (!drv->bdrv_co_pwritev_compressed) {
return -ENOTSUP;
return drv->bdrv_co_pwritev_compressed(VAR_0, VAR_1, VAR_2, VAR_3); | [
"FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,\nuint64_t VAR_2, QEMUIOVector *VAR_3)\n{",
"BlockDriver *drv = VAR_0->drv;",
"if (!drv->bdrv_co_pwritev_compressed) {",
"return -ENOTSUP;",
"return drv->bdrv_co_pwritev_compressed(VAR_0, VAR_1, VAR_2, VAR_3);"
] | [
0,
0,
0,
0,
0
] | [
[
1,
2,
3
],
[
4
],
[
5
],
[
6
],
[
7
]
] |
20,599 | static void cirrus_init_common(CirrusVGAState * s, int device_id, int is_pci)
{
int i;
static int inited;
if (!inited) {
inited = 1;
for(i = 0;i < 256; i++)
rop_to_index[i] = CIRRUS_ROP_NOP_INDEX; /* nop rop */
rop_to_index[CIRRUS_ROP_0] = 0;
rop_to_index[CIRRUS_ROP_SRC_AND_DST] = 1;
rop_to_index[CIRRUS_ROP_NOP] = 2;
rop_to_index[CIRRUS_ROP_SRC_AND_NOTDST] = 3;
rop_to_index[CIRRUS_ROP_NOTDST] = 4;
rop_to_index[CIRRUS_ROP_SRC] = 5;
rop_to_index[CIRRUS_ROP_1] = 6;
rop_to_index[CIRRUS_ROP_NOTSRC_AND_DST] = 7;
rop_to_index[CIRRUS_ROP_SRC_XOR_DST] = 8;
rop_to_index[CIRRUS_ROP_SRC_OR_DST] = 9;
rop_to_index[CIRRUS_ROP_NOTSRC_OR_NOTDST] = 10;
rop_to_index[CIRRUS_ROP_SRC_NOTXOR_DST] = 11;
rop_to_index[CIRRUS_ROP_SRC_OR_NOTDST] = 12;
rop_to_index[CIRRUS_ROP_NOTSRC] = 13;
rop_to_index[CIRRUS_ROP_NOTSRC_OR_DST] = 14;
rop_to_index[CIRRUS_ROP_NOTSRC_AND_NOTDST] = 15;
}
register_ioport_write(0x3c0, 16, 1, vga_ioport_write, s);
register_ioport_write(0x3b4, 2, 1, vga_ioport_write, s);
register_ioport_write(0x3d4, 2, 1, vga_ioport_write, s);
register_ioport_write(0x3ba, 1, 1, vga_ioport_write, s);
register_ioport_write(0x3da, 1, 1, vga_ioport_write, s);
register_ioport_read(0x3c0, 16, 1, vga_ioport_read, s);
register_ioport_read(0x3b4, 2, 1, vga_ioport_read, s);
register_ioport_read(0x3d4, 2, 1, vga_ioport_read, s);
register_ioport_read(0x3ba, 1, 1, vga_ioport_read, s);
register_ioport_read(0x3da, 1, 1, vga_ioport_read, s);
s->vga_io_memory = cpu_register_io_memory(0, cirrus_vga_mem_read,
cirrus_vga_mem_write, s);
cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,
s->vga_io_memory);
s->sr[0x06] = 0x0f;
if (device_id == CIRRUS_ID_CLGD5446) {
/* 4MB 64 bit memory config, always PCI */
s->sr[0x1F] = 0x2d; // MemClock
s->gr[0x18] = 0x0f; // fastest memory configuration
#if 1
s->sr[0x0f] = 0x98;
s->sr[0x17] = 0x20;
s->sr[0x15] = 0x04; /* memory size, 3=2MB, 4=4MB */
s->real_vram_size = 4096 * 1024;
#else
s->sr[0x0f] = 0x18;
s->sr[0x17] = 0x20;
s->sr[0x15] = 0x03; /* memory size, 3=2MB, 4=4MB */
s->real_vram_size = 2048 * 1024;
#endif
} else {
s->sr[0x1F] = 0x22; // MemClock
s->sr[0x0F] = CIRRUS_MEMSIZE_2M;
if (is_pci)
s->sr[0x17] = CIRRUS_BUSTYPE_PCI;
else
s->sr[0x17] = CIRRUS_BUSTYPE_ISA;
s->real_vram_size = 2048 * 1024;
s->sr[0x15] = 0x03; /* memory size, 3=2MB, 4=4MB */
}
s->cr[0x27] = device_id;
/* Win2K seems to assume that the pattern buffer is at 0xff
initially ! */
memset(s->vram_ptr, 0xff, s->real_vram_size);
s->cirrus_hidden_dac_lockindex = 5;
s->cirrus_hidden_dac_data = 0;
/* I/O handler for LFB */
s->cirrus_linear_io_addr =
cpu_register_io_memory(0, cirrus_linear_read, cirrus_linear_write,
s);
s->cirrus_linear_write = cpu_get_io_memory_write(s->cirrus_linear_io_addr);
/* I/O handler for LFB */
s->cirrus_linear_bitblt_io_addr =
cpu_register_io_memory(0, cirrus_linear_bitblt_read, cirrus_linear_bitblt_write,
s);
/* I/O handler for memory-mapped I/O */
s->cirrus_mmio_io_addr =
cpu_register_io_memory(0, cirrus_mmio_read, cirrus_mmio_write, s);
/* XXX: s->vram_size must be a power of two */
s->cirrus_addr_mask = s->real_vram_size - 1;
s->linear_mmio_mask = s->real_vram_size - 256;
s->get_bpp = cirrus_get_bpp;
s->get_offsets = cirrus_get_offsets;
s->get_resolution = cirrus_get_resolution;
s->cursor_invalidate = cirrus_cursor_invalidate;
s->cursor_draw_line = cirrus_cursor_draw_line;
register_savevm("cirrus_vga", 0, 2, cirrus_vga_save, cirrus_vga_load, s);
} | true | qemu | f65ed4c1529f29a7d62d6733eaa50bed24a4b2ed | static void cirrus_init_common(CirrusVGAState * s, int device_id, int is_pci)
{
int i;
static int inited;
if (!inited) {
inited = 1;
for(i = 0;i < 256; i++)
rop_to_index[i] = CIRRUS_ROP_NOP_INDEX;
rop_to_index[CIRRUS_ROP_0] = 0;
rop_to_index[CIRRUS_ROP_SRC_AND_DST] = 1;
rop_to_index[CIRRUS_ROP_NOP] = 2;
rop_to_index[CIRRUS_ROP_SRC_AND_NOTDST] = 3;
rop_to_index[CIRRUS_ROP_NOTDST] = 4;
rop_to_index[CIRRUS_ROP_SRC] = 5;
rop_to_index[CIRRUS_ROP_1] = 6;
rop_to_index[CIRRUS_ROP_NOTSRC_AND_DST] = 7;
rop_to_index[CIRRUS_ROP_SRC_XOR_DST] = 8;
rop_to_index[CIRRUS_ROP_SRC_OR_DST] = 9;
rop_to_index[CIRRUS_ROP_NOTSRC_OR_NOTDST] = 10;
rop_to_index[CIRRUS_ROP_SRC_NOTXOR_DST] = 11;
rop_to_index[CIRRUS_ROP_SRC_OR_NOTDST] = 12;
rop_to_index[CIRRUS_ROP_NOTSRC] = 13;
rop_to_index[CIRRUS_ROP_NOTSRC_OR_DST] = 14;
rop_to_index[CIRRUS_ROP_NOTSRC_AND_NOTDST] = 15;
}
register_ioport_write(0x3c0, 16, 1, vga_ioport_write, s);
register_ioport_write(0x3b4, 2, 1, vga_ioport_write, s);
register_ioport_write(0x3d4, 2, 1, vga_ioport_write, s);
register_ioport_write(0x3ba, 1, 1, vga_ioport_write, s);
register_ioport_write(0x3da, 1, 1, vga_ioport_write, s);
register_ioport_read(0x3c0, 16, 1, vga_ioport_read, s);
register_ioport_read(0x3b4, 2, 1, vga_ioport_read, s);
register_ioport_read(0x3d4, 2, 1, vga_ioport_read, s);
register_ioport_read(0x3ba, 1, 1, vga_ioport_read, s);
register_ioport_read(0x3da, 1, 1, vga_ioport_read, s);
s->vga_io_memory = cpu_register_io_memory(0, cirrus_vga_mem_read,
cirrus_vga_mem_write, s);
cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,
s->vga_io_memory);
s->sr[0x06] = 0x0f;
if (device_id == CIRRUS_ID_CLGD5446) {
s->sr[0x1F] = 0x2d;
s->gr[0x18] = 0x0f;
#if 1
s->sr[0x0f] = 0x98;
s->sr[0x17] = 0x20;
s->sr[0x15] = 0x04;
s->real_vram_size = 4096 * 1024;
#else
s->sr[0x0f] = 0x18;
s->sr[0x17] = 0x20;
s->sr[0x15] = 0x03;
s->real_vram_size = 2048 * 1024;
#endif
} else {
s->sr[0x1F] = 0x22;
s->sr[0x0F] = CIRRUS_MEMSIZE_2M;
if (is_pci)
s->sr[0x17] = CIRRUS_BUSTYPE_PCI;
else
s->sr[0x17] = CIRRUS_BUSTYPE_ISA;
s->real_vram_size = 2048 * 1024;
s->sr[0x15] = 0x03;
}
s->cr[0x27] = device_id;
memset(s->vram_ptr, 0xff, s->real_vram_size);
s->cirrus_hidden_dac_lockindex = 5;
s->cirrus_hidden_dac_data = 0;
s->cirrus_linear_io_addr =
cpu_register_io_memory(0, cirrus_linear_read, cirrus_linear_write,
s);
s->cirrus_linear_write = cpu_get_io_memory_write(s->cirrus_linear_io_addr);
s->cirrus_linear_bitblt_io_addr =
cpu_register_io_memory(0, cirrus_linear_bitblt_read, cirrus_linear_bitblt_write,
s);
s->cirrus_mmio_io_addr =
cpu_register_io_memory(0, cirrus_mmio_read, cirrus_mmio_write, s);
s->cirrus_addr_mask = s->real_vram_size - 1;
s->linear_mmio_mask = s->real_vram_size - 256;
s->get_bpp = cirrus_get_bpp;
s->get_offsets = cirrus_get_offsets;
s->get_resolution = cirrus_get_resolution;
s->cursor_invalidate = cirrus_cursor_invalidate;
s->cursor_draw_line = cirrus_cursor_draw_line;
register_savevm("cirrus_vga", 0, 2, cirrus_vga_save, cirrus_vga_load, s);
} | {
"code": [],
"line_no": []
} | static void FUNC_0(CirrusVGAState * VAR_0, int VAR_1, int VAR_2)
{
int VAR_3;
static int VAR_4;
if (!VAR_4) {
VAR_4 = 1;
for(VAR_3 = 0;VAR_3 < 256; VAR_3++)
rop_to_index[VAR_3] = CIRRUS_ROP_NOP_INDEX;
rop_to_index[CIRRUS_ROP_0] = 0;
rop_to_index[CIRRUS_ROP_SRC_AND_DST] = 1;
rop_to_index[CIRRUS_ROP_NOP] = 2;
rop_to_index[CIRRUS_ROP_SRC_AND_NOTDST] = 3;
rop_to_index[CIRRUS_ROP_NOTDST] = 4;
rop_to_index[CIRRUS_ROP_SRC] = 5;
rop_to_index[CIRRUS_ROP_1] = 6;
rop_to_index[CIRRUS_ROP_NOTSRC_AND_DST] = 7;
rop_to_index[CIRRUS_ROP_SRC_XOR_DST] = 8;
rop_to_index[CIRRUS_ROP_SRC_OR_DST] = 9;
rop_to_index[CIRRUS_ROP_NOTSRC_OR_NOTDST] = 10;
rop_to_index[CIRRUS_ROP_SRC_NOTXOR_DST] = 11;
rop_to_index[CIRRUS_ROP_SRC_OR_NOTDST] = 12;
rop_to_index[CIRRUS_ROP_NOTSRC] = 13;
rop_to_index[CIRRUS_ROP_NOTSRC_OR_DST] = 14;
rop_to_index[CIRRUS_ROP_NOTSRC_AND_NOTDST] = 15;
}
register_ioport_write(0x3c0, 16, 1, vga_ioport_write, VAR_0);
register_ioport_write(0x3b4, 2, 1, vga_ioport_write, VAR_0);
register_ioport_write(0x3d4, 2, 1, vga_ioport_write, VAR_0);
register_ioport_write(0x3ba, 1, 1, vga_ioport_write, VAR_0);
register_ioport_write(0x3da, 1, 1, vga_ioport_write, VAR_0);
register_ioport_read(0x3c0, 16, 1, vga_ioport_read, VAR_0);
register_ioport_read(0x3b4, 2, 1, vga_ioport_read, VAR_0);
register_ioport_read(0x3d4, 2, 1, vga_ioport_read, VAR_0);
register_ioport_read(0x3ba, 1, 1, vga_ioport_read, VAR_0);
register_ioport_read(0x3da, 1, 1, vga_ioport_read, VAR_0);
VAR_0->vga_io_memory = cpu_register_io_memory(0, cirrus_vga_mem_read,
cirrus_vga_mem_write, VAR_0);
cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,
VAR_0->vga_io_memory);
VAR_0->sr[0x06] = 0x0f;
if (VAR_1 == CIRRUS_ID_CLGD5446) {
VAR_0->sr[0x1F] = 0x2d;
VAR_0->gr[0x18] = 0x0f;
#if 1
VAR_0->sr[0x0f] = 0x98;
VAR_0->sr[0x17] = 0x20;
VAR_0->sr[0x15] = 0x04;
VAR_0->real_vram_size = 4096 * 1024;
#else
VAR_0->sr[0x0f] = 0x18;
VAR_0->sr[0x17] = 0x20;
VAR_0->sr[0x15] = 0x03;
VAR_0->real_vram_size = 2048 * 1024;
#endif
} else {
VAR_0->sr[0x1F] = 0x22;
VAR_0->sr[0x0F] = CIRRUS_MEMSIZE_2M;
if (VAR_2)
VAR_0->sr[0x17] = CIRRUS_BUSTYPE_PCI;
else
VAR_0->sr[0x17] = CIRRUS_BUSTYPE_ISA;
VAR_0->real_vram_size = 2048 * 1024;
VAR_0->sr[0x15] = 0x03;
}
VAR_0->cr[0x27] = VAR_1;
memset(VAR_0->vram_ptr, 0xff, VAR_0->real_vram_size);
VAR_0->cirrus_hidden_dac_lockindex = 5;
VAR_0->cirrus_hidden_dac_data = 0;
VAR_0->cirrus_linear_io_addr =
cpu_register_io_memory(0, cirrus_linear_read, cirrus_linear_write,
VAR_0);
VAR_0->cirrus_linear_write = cpu_get_io_memory_write(VAR_0->cirrus_linear_io_addr);
VAR_0->cirrus_linear_bitblt_io_addr =
cpu_register_io_memory(0, cirrus_linear_bitblt_read, cirrus_linear_bitblt_write,
VAR_0);
VAR_0->cirrus_mmio_io_addr =
cpu_register_io_memory(0, cirrus_mmio_read, cirrus_mmio_write, VAR_0);
VAR_0->cirrus_addr_mask = VAR_0->real_vram_size - 1;
VAR_0->linear_mmio_mask = VAR_0->real_vram_size - 256;
VAR_0->get_bpp = cirrus_get_bpp;
VAR_0->get_offsets = cirrus_get_offsets;
VAR_0->get_resolution = cirrus_get_resolution;
VAR_0->cursor_invalidate = cirrus_cursor_invalidate;
VAR_0->cursor_draw_line = cirrus_cursor_draw_line;
register_savevm("cirrus_vga", 0, 2, cirrus_vga_save, cirrus_vga_load, VAR_0);
} | [
"static void FUNC_0(CirrusVGAState * VAR_0, int VAR_1, int VAR_2)\n{",
"int VAR_3;",
"static int VAR_4;",
"if (!VAR_4) {",
"VAR_4 = 1;",
"for(VAR_3 = 0;VAR_3 < 256; VAR_3++)",
"rop_to_index[VAR_3] = CIRRUS_ROP_NOP_INDEX;",
"rop_to_index[CIRRUS_ROP_0] = 0;",
"rop_to_index[CIRRUS_ROP_SRC_AND_DST] = 1;",
"rop_to_index[CIRRUS_ROP_NOP] = 2;",
"rop_to_index[CIRRUS_ROP_SRC_AND_NOTDST] = 3;",
"rop_to_index[CIRRUS_ROP_NOTDST] = 4;",
"rop_to_index[CIRRUS_ROP_SRC] = 5;",
"rop_to_index[CIRRUS_ROP_1] = 6;",
"rop_to_index[CIRRUS_ROP_NOTSRC_AND_DST] = 7;",
"rop_to_index[CIRRUS_ROP_SRC_XOR_DST] = 8;",
"rop_to_index[CIRRUS_ROP_SRC_OR_DST] = 9;",
"rop_to_index[CIRRUS_ROP_NOTSRC_OR_NOTDST] = 10;",
"rop_to_index[CIRRUS_ROP_SRC_NOTXOR_DST] = 11;",
"rop_to_index[CIRRUS_ROP_SRC_OR_NOTDST] = 12;",
"rop_to_index[CIRRUS_ROP_NOTSRC] = 13;",
"rop_to_index[CIRRUS_ROP_NOTSRC_OR_DST] = 14;",
"rop_to_index[CIRRUS_ROP_NOTSRC_AND_NOTDST] = 15;",
"}",
"register_ioport_write(0x3c0, 16, 1, vga_ioport_write, VAR_0);",
"register_ioport_write(0x3b4, 2, 1, vga_ioport_write, VAR_0);",
"register_ioport_write(0x3d4, 2, 1, vga_ioport_write, VAR_0);",
"register_ioport_write(0x3ba, 1, 1, vga_ioport_write, VAR_0);",
"register_ioport_write(0x3da, 1, 1, vga_ioport_write, VAR_0);",
"register_ioport_read(0x3c0, 16, 1, vga_ioport_read, VAR_0);",
"register_ioport_read(0x3b4, 2, 1, vga_ioport_read, VAR_0);",
"register_ioport_read(0x3d4, 2, 1, vga_ioport_read, VAR_0);",
"register_ioport_read(0x3ba, 1, 1, vga_ioport_read, VAR_0);",
"register_ioport_read(0x3da, 1, 1, vga_ioport_read, VAR_0);",
"VAR_0->vga_io_memory = cpu_register_io_memory(0, cirrus_vga_mem_read,\ncirrus_vga_mem_write, VAR_0);",
"cpu_register_physical_memory(isa_mem_base + 0x000a0000, 0x20000,\nVAR_0->vga_io_memory);",
"VAR_0->sr[0x06] = 0x0f;",
"if (VAR_1 == CIRRUS_ID_CLGD5446) {",
"VAR_0->sr[0x1F] = 0x2d;",
"VAR_0->gr[0x18] = 0x0f;",
"#if 1\nVAR_0->sr[0x0f] = 0x98;",
"VAR_0->sr[0x17] = 0x20;",
"VAR_0->sr[0x15] = 0x04;",
"VAR_0->real_vram_size = 4096 * 1024;",
"#else\nVAR_0->sr[0x0f] = 0x18;",
"VAR_0->sr[0x17] = 0x20;",
"VAR_0->sr[0x15] = 0x03;",
"VAR_0->real_vram_size = 2048 * 1024;",
"#endif\n} else {",
"VAR_0->sr[0x1F] = 0x22;",
"VAR_0->sr[0x0F] = CIRRUS_MEMSIZE_2M;",
"if (VAR_2)\nVAR_0->sr[0x17] = CIRRUS_BUSTYPE_PCI;",
"else\nVAR_0->sr[0x17] = CIRRUS_BUSTYPE_ISA;",
"VAR_0->real_vram_size = 2048 * 1024;",
"VAR_0->sr[0x15] = 0x03;",
"}",
"VAR_0->cr[0x27] = VAR_1;",
"memset(VAR_0->vram_ptr, 0xff, VAR_0->real_vram_size);",
"VAR_0->cirrus_hidden_dac_lockindex = 5;",
"VAR_0->cirrus_hidden_dac_data = 0;",
"VAR_0->cirrus_linear_io_addr =\ncpu_register_io_memory(0, cirrus_linear_read, cirrus_linear_write,\nVAR_0);",
"VAR_0->cirrus_linear_write = cpu_get_io_memory_write(VAR_0->cirrus_linear_io_addr);",
"VAR_0->cirrus_linear_bitblt_io_addr =\ncpu_register_io_memory(0, cirrus_linear_bitblt_read, cirrus_linear_bitblt_write,\nVAR_0);",
"VAR_0->cirrus_mmio_io_addr =\ncpu_register_io_memory(0, cirrus_mmio_read, cirrus_mmio_write, VAR_0);",
"VAR_0->cirrus_addr_mask = VAR_0->real_vram_size - 1;",
"VAR_0->linear_mmio_mask = VAR_0->real_vram_size - 256;",
"VAR_0->get_bpp = cirrus_get_bpp;",
"VAR_0->get_offsets = cirrus_get_offsets;",
"VAR_0->get_resolution = cirrus_get_resolution;",
"VAR_0->cursor_invalidate = cirrus_cursor_invalidate;",
"VAR_0->cursor_draw_line = cirrus_cursor_draw_line;",
"register_savevm(\"cirrus_vga\", 0, 2, cirrus_vga_save, cirrus_vga_load, VAR_0);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83,
85
],
[
87,
89
],
[
94
],
[
96
],
[
100
],
[
102
],
[
104,
106
],
[
108
],
[
110
],
[
112
],
[
114,
116
],
[
118
],
[
120
],
[
122
],
[
124,
126
],
[
128
],
[
130
],
[
132,
134
],
[
136,
138
],
[
140
],
[
142
],
[
144
],
[
146
],
[
154
],
[
158
],
[
160
],
[
166,
168,
170
],
[
172
],
[
178,
180,
182
],
[
188,
190
],
[
196
],
[
198
],
[
202
],
[
204
],
[
206
],
[
208
],
[
210
],
[
214
],
[
216
]
] |
20,601 | static int omap2_gpio_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
struct omap2_gpif_s *s = OMAP2_GPIO(dev);
int i;
if (!s->iclk) {
hw_error("omap2-gpio: iclk not connected\n");
}
if (s->mpu_model < omap3430) {
s->modulecount = (s->mpu_model < omap2430) ? 4 : 5;
memory_region_init_io(&s->iomem, OBJECT(s), &omap2_gpif_top_ops, s,
"omap2.gpio", 0x1000);
sysbus_init_mmio(sbd, &s->iomem);
} else {
s->modulecount = 6;
}
s->modules = g_new0(struct omap2_gpio_s, s->modulecount);
s->handler = g_new0(qemu_irq, s->modulecount * 32);
qdev_init_gpio_in(dev, omap2_gpio_set, s->modulecount * 32);
qdev_init_gpio_out(dev, s->handler, s->modulecount * 32);
for (i = 0; i < s->modulecount; i++) {
struct omap2_gpio_s *m = &s->modules[i];
if (!s->fclk[i]) {
hw_error("omap2-gpio: fclk%d not connected\n", i);
}
m->revision = (s->mpu_model < omap3430) ? 0x18 : 0x25;
m->handler = &s->handler[i * 32];
sysbus_init_irq(sbd, &m->irq[0]); /* mpu irq */
sysbus_init_irq(sbd, &m->irq[1]); /* dsp irq */
sysbus_init_irq(sbd, &m->wkup);
memory_region_init_io(&m->iomem, OBJECT(s), &omap2_gpio_module_ops, m,
"omap.gpio-module", 0x1000);
sysbus_init_mmio(sbd, &m->iomem);
}
return 0;
}
| true | qemu | 84a3a53cf61ef691478bd91afa455c801696053c | static int omap2_gpio_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
struct omap2_gpif_s *s = OMAP2_GPIO(dev);
int i;
if (!s->iclk) {
hw_error("omap2-gpio: iclk not connected\n");
}
if (s->mpu_model < omap3430) {
s->modulecount = (s->mpu_model < omap2430) ? 4 : 5;
memory_region_init_io(&s->iomem, OBJECT(s), &omap2_gpif_top_ops, s,
"omap2.gpio", 0x1000);
sysbus_init_mmio(sbd, &s->iomem);
} else {
s->modulecount = 6;
}
s->modules = g_new0(struct omap2_gpio_s, s->modulecount);
s->handler = g_new0(qemu_irq, s->modulecount * 32);
qdev_init_gpio_in(dev, omap2_gpio_set, s->modulecount * 32);
qdev_init_gpio_out(dev, s->handler, s->modulecount * 32);
for (i = 0; i < s->modulecount; i++) {
struct omap2_gpio_s *m = &s->modules[i];
if (!s->fclk[i]) {
hw_error("omap2-gpio: fclk%d not connected\n", i);
}
m->revision = (s->mpu_model < omap3430) ? 0x18 : 0x25;
m->handler = &s->handler[i * 32];
sysbus_init_irq(sbd, &m->irq[0]);
sysbus_init_irq(sbd, &m->irq[1]);
sysbus_init_irq(sbd, &m->wkup);
memory_region_init_io(&m->iomem, OBJECT(s), &omap2_gpio_module_ops, m,
"omap.gpio-module", 0x1000);
sysbus_init_mmio(sbd, &m->iomem);
}
return 0;
}
| {
"code": [
" hw_error(\"omap2-gpio: iclk not connected\\n\");",
" s->modulecount = (s->mpu_model < omap2430) ? 4 : 5;",
" } else {",
" s->modulecount = 6;",
" if (!s->fclk[i]) {",
" hw_error(\"omap2-gpio: fclk%d not connected\\n\", i);"
],
"line_no": [
15,
21,
29,
31,
47,
49
]
} | static int FUNC_0(SysBusDevice *VAR_0)
{
DeviceState *dev = DEVICE(VAR_0);
struct omap2_gpif_s *VAR_1 = OMAP2_GPIO(dev);
int VAR_2;
if (!VAR_1->iclk) {
hw_error("omap2-gpio: iclk not connected\n");
}
if (VAR_1->mpu_model < omap3430) {
VAR_1->modulecount = (VAR_1->mpu_model < omap2430) ? 4 : 5;
memory_region_init_io(&VAR_1->iomem, OBJECT(VAR_1), &omap2_gpif_top_ops, VAR_1,
"omap2.gpio", 0x1000);
sysbus_init_mmio(VAR_0, &VAR_1->iomem);
} else {
VAR_1->modulecount = 6;
}
VAR_1->modules = g_new0(struct omap2_gpio_s, VAR_1->modulecount);
VAR_1->handler = g_new0(qemu_irq, VAR_1->modulecount * 32);
qdev_init_gpio_in(dev, omap2_gpio_set, VAR_1->modulecount * 32);
qdev_init_gpio_out(dev, VAR_1->handler, VAR_1->modulecount * 32);
for (VAR_2 = 0; VAR_2 < VAR_1->modulecount; VAR_2++) {
struct omap2_gpio_s *VAR_3 = &VAR_1->modules[VAR_2];
if (!VAR_1->fclk[VAR_2]) {
hw_error("omap2-gpio: fclk%d not connected\n", VAR_2);
}
VAR_3->revision = (VAR_1->mpu_model < omap3430) ? 0x18 : 0x25;
VAR_3->handler = &VAR_1->handler[VAR_2 * 32];
sysbus_init_irq(VAR_0, &VAR_3->irq[0]);
sysbus_init_irq(VAR_0, &VAR_3->irq[1]);
sysbus_init_irq(VAR_0, &VAR_3->wkup);
memory_region_init_io(&VAR_3->iomem, OBJECT(VAR_1), &omap2_gpio_module_ops, VAR_3,
"omap.gpio-module", 0x1000);
sysbus_init_mmio(VAR_0, &VAR_3->iomem);
}
return 0;
}
| [
"static int FUNC_0(SysBusDevice *VAR_0)\n{",
"DeviceState *dev = DEVICE(VAR_0);",
"struct omap2_gpif_s *VAR_1 = OMAP2_GPIO(dev);",
"int VAR_2;",
"if (!VAR_1->iclk) {",
"hw_error(\"omap2-gpio: iclk not connected\\n\");",
"}",
"if (VAR_1->mpu_model < omap3430) {",
"VAR_1->modulecount = (VAR_1->mpu_model < omap2430) ? 4 : 5;",
"memory_region_init_io(&VAR_1->iomem, OBJECT(VAR_1), &omap2_gpif_top_ops, VAR_1,\n\"omap2.gpio\", 0x1000);",
"sysbus_init_mmio(VAR_0, &VAR_1->iomem);",
"} else {",
"VAR_1->modulecount = 6;",
"}",
"VAR_1->modules = g_new0(struct omap2_gpio_s, VAR_1->modulecount);",
"VAR_1->handler = g_new0(qemu_irq, VAR_1->modulecount * 32);",
"qdev_init_gpio_in(dev, omap2_gpio_set, VAR_1->modulecount * 32);",
"qdev_init_gpio_out(dev, VAR_1->handler, VAR_1->modulecount * 32);",
"for (VAR_2 = 0; VAR_2 < VAR_1->modulecount; VAR_2++) {",
"struct omap2_gpio_s *VAR_3 = &VAR_1->modules[VAR_2];",
"if (!VAR_1->fclk[VAR_2]) {",
"hw_error(\"omap2-gpio: fclk%d not connected\\n\", VAR_2);",
"}",
"VAR_3->revision = (VAR_1->mpu_model < omap3430) ? 0x18 : 0x25;",
"VAR_3->handler = &VAR_1->handler[VAR_2 * 32];",
"sysbus_init_irq(VAR_0, &VAR_3->irq[0]);",
"sysbus_init_irq(VAR_0, &VAR_3->irq[1]);",
"sysbus_init_irq(VAR_0, &VAR_3->wkup);",
"memory_region_init_io(&VAR_3->iomem, OBJECT(VAR_1), &omap2_gpio_module_ops, VAR_3,\n\"omap.gpio-module\", 0x1000);",
"sysbus_init_mmio(VAR_0, &VAR_3->iomem);",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
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
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63,
65
],
[
67
],
[
69
],
[
71
],
[
73
]
] |
20,602 | void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
{
FrameThreadContext *fctx = avctx->internal->thread_ctx;
const AVCodec *codec = avctx->codec;
int i;
park_frame_worker_threads(fctx, thread_count);
if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
fctx->prev_thread->avctx->internal->is_copy = fctx->threads->avctx->internal->is_copy;
fctx->threads->avctx->internal->is_copy = 1;
}
fctx->die = 1;
for (i = 0; i < thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
pthread_mutex_lock(&p->mutex);
pthread_cond_signal(&p->input_cond);
pthread_mutex_unlock(&p->mutex);
if (p->thread_init)
pthread_join(p->thread, NULL);
p->thread_init=0;
if (codec->close)
codec->close(p->avctx);
release_delayed_buffers(p);
av_frame_free(&p->frame);
}
for (i = 0; i < thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
pthread_mutex_destroy(&p->mutex);
pthread_mutex_destroy(&p->progress_mutex);
pthread_cond_destroy(&p->input_cond);
pthread_cond_destroy(&p->progress_cond);
pthread_cond_destroy(&p->output_cond);
av_packet_unref(&p->avpkt);
av_freep(&p->released_buffers);
if (i) {
av_freep(&p->avctx->priv_data);
av_freep(&p->avctx->slice_offset);
}
av_freep(&p->avctx->internal);
av_freep(&p->avctx);
}
av_freep(&fctx->threads);
pthread_mutex_destroy(&fctx->buffer_mutex);
av_freep(&avctx->internal->thread_ctx);
if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
av_opt_free(avctx->priv_data);
avctx->codec = NULL;
}
| true | FFmpeg | 5d346feafa817c4fbc30f7ed0b93b2dad6cef15b | void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
{
FrameThreadContext *fctx = avctx->internal->thread_ctx;
const AVCodec *codec = avctx->codec;
int i;
park_frame_worker_threads(fctx, thread_count);
if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
fctx->prev_thread->avctx->internal->is_copy = fctx->threads->avctx->internal->is_copy;
fctx->threads->avctx->internal->is_copy = 1;
}
fctx->die = 1;
for (i = 0; i < thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
pthread_mutex_lock(&p->mutex);
pthread_cond_signal(&p->input_cond);
pthread_mutex_unlock(&p->mutex);
if (p->thread_init)
pthread_join(p->thread, NULL);
p->thread_init=0;
if (codec->close)
codec->close(p->avctx);
release_delayed_buffers(p);
av_frame_free(&p->frame);
}
for (i = 0; i < thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
pthread_mutex_destroy(&p->mutex);
pthread_mutex_destroy(&p->progress_mutex);
pthread_cond_destroy(&p->input_cond);
pthread_cond_destroy(&p->progress_cond);
pthread_cond_destroy(&p->output_cond);
av_packet_unref(&p->avpkt);
av_freep(&p->released_buffers);
if (i) {
av_freep(&p->avctx->priv_data);
av_freep(&p->avctx->slice_offset);
}
av_freep(&p->avctx->internal);
av_freep(&p->avctx);
}
av_freep(&fctx->threads);
pthread_mutex_destroy(&fctx->buffer_mutex);
av_freep(&avctx->internal->thread_ctx);
if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
av_opt_free(avctx->priv_data);
avctx->codec = NULL;
}
| {
"code": [
" if (codec->close)",
" if (i) {",
" av_freep(&p->avctx->internal);"
],
"line_no": [
57,
93,
103
]
} | void FUNC_0(AVCodecContext *VAR_0, int VAR_1)
{
FrameThreadContext *fctx = VAR_0->internal->thread_ctx;
const AVCodec *VAR_2 = VAR_0->VAR_2;
int VAR_3;
park_frame_worker_threads(fctx, VAR_1);
if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
if (update_context_from_thread(fctx->threads->VAR_0, fctx->prev_thread->VAR_0, 0) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Final thread update failed\n");
fctx->prev_thread->VAR_0->internal->is_copy = fctx->threads->VAR_0->internal->is_copy;
fctx->threads->VAR_0->internal->is_copy = 1;
}
fctx->die = 1;
for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {
PerThreadContext *p = &fctx->threads[VAR_3];
pthread_mutex_lock(&p->mutex);
pthread_cond_signal(&p->input_cond);
pthread_mutex_unlock(&p->mutex);
if (p->thread_init)
pthread_join(p->thread, NULL);
p->thread_init=0;
if (VAR_2->close)
VAR_2->close(p->VAR_0);
release_delayed_buffers(p);
av_frame_free(&p->frame);
}
for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {
PerThreadContext *p = &fctx->threads[VAR_3];
pthread_mutex_destroy(&p->mutex);
pthread_mutex_destroy(&p->progress_mutex);
pthread_cond_destroy(&p->input_cond);
pthread_cond_destroy(&p->progress_cond);
pthread_cond_destroy(&p->output_cond);
av_packet_unref(&p->avpkt);
av_freep(&p->released_buffers);
if (VAR_3) {
av_freep(&p->VAR_0->priv_data);
av_freep(&p->VAR_0->slice_offset);
}
av_freep(&p->VAR_0->internal);
av_freep(&p->VAR_0);
}
av_freep(&fctx->threads);
pthread_mutex_destroy(&fctx->buffer_mutex);
av_freep(&VAR_0->internal->thread_ctx);
if (VAR_0->priv_data && VAR_0->VAR_2 && VAR_0->VAR_2->priv_class)
av_opt_free(VAR_0->priv_data);
VAR_0->VAR_2 = NULL;
}
| [
"void FUNC_0(AVCodecContext *VAR_0, int VAR_1)\n{",
"FrameThreadContext *fctx = VAR_0->internal->thread_ctx;",
"const AVCodec *VAR_2 = VAR_0->VAR_2;",
"int VAR_3;",
"park_frame_worker_threads(fctx, VAR_1);",
"if (fctx->prev_thread && fctx->prev_thread != fctx->threads)\nif (update_context_from_thread(fctx->threads->VAR_0, fctx->prev_thread->VAR_0, 0) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Final thread update failed\\n\");",
"fctx->prev_thread->VAR_0->internal->is_copy = fctx->threads->VAR_0->internal->is_copy;",
"fctx->threads->VAR_0->internal->is_copy = 1;",
"}",
"fctx->die = 1;",
"for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {",
"PerThreadContext *p = &fctx->threads[VAR_3];",
"pthread_mutex_lock(&p->mutex);",
"pthread_cond_signal(&p->input_cond);",
"pthread_mutex_unlock(&p->mutex);",
"if (p->thread_init)\npthread_join(p->thread, NULL);",
"p->thread_init=0;",
"if (VAR_2->close)\nVAR_2->close(p->VAR_0);",
"release_delayed_buffers(p);",
"av_frame_free(&p->frame);",
"}",
"for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {",
"PerThreadContext *p = &fctx->threads[VAR_3];",
"pthread_mutex_destroy(&p->mutex);",
"pthread_mutex_destroy(&p->progress_mutex);",
"pthread_cond_destroy(&p->input_cond);",
"pthread_cond_destroy(&p->progress_cond);",
"pthread_cond_destroy(&p->output_cond);",
"av_packet_unref(&p->avpkt);",
"av_freep(&p->released_buffers);",
"if (VAR_3) {",
"av_freep(&p->VAR_0->priv_data);",
"av_freep(&p->VAR_0->slice_offset);",
"}",
"av_freep(&p->VAR_0->internal);",
"av_freep(&p->VAR_0);",
"}",
"av_freep(&fctx->threads);",
"pthread_mutex_destroy(&fctx->buffer_mutex);",
"av_freep(&VAR_0->internal->thread_ctx);",
"if (VAR_0->priv_data && VAR_0->VAR_2 && VAR_0->VAR_2->priv_class)\nav_opt_free(VAR_0->priv_data);",
"VAR_0->VAR_2 = NULL;",
"}"
] | [
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,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
49,
51
],
[
53
],
[
57,
59
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
115
],
[
119,
121
],
[
123
],
[
125
]
] |
20,604 | static bool ranges_can_merge(Range *range1, Range *range2)
{
return !(range1->end < range2->begin || range2->end < range1->begin);
}
| true | qemu | db486cc334aafd3dbdaf107388e37fc3d6d3e171 | static bool ranges_can_merge(Range *range1, Range *range2)
{
return !(range1->end < range2->begin || range2->end < range1->begin);
}
| {
"code": [
"static bool ranges_can_merge(Range *range1, Range *range2)",
" return !(range1->end < range2->begin || range2->end < range1->begin);"
],
"line_no": [
1,
5
]
} | static bool FUNC_0(Range *range1, Range *range2)
{
return !(range1->end < range2->begin || range2->end < range1->begin);
}
| [
"static bool FUNC_0(Range *range1, Range *range2)\n{",
"return !(range1->end < range2->begin || range2->end < range1->begin);",
"}"
] | [
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
20,605 | static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
BDRVNBDState *s = bs->opaque;
char *export = NULL;
int result, sock;
Error *local_err = NULL;
/* Pop the config into our state object. Exit if invalid. */
nbd_config(s, options, &export, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return -EINVAL;
}
/* establish TCP connection, return error if it fails
* TODO: Configurable retry-until-timeout behaviour.
*/
sock = nbd_establish_connection(bs, errp);
if (sock < 0) {
return sock;
}
/* NBD handshake */
result = nbd_client_init(bs, sock, export, errp);
return result;
} | true | qemu | 9d0b65e6e8f255dd86630a6873b3859fb6a5477f | static int nbd_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
BDRVNBDState *s = bs->opaque;
char *export = NULL;
int result, sock;
Error *local_err = NULL;
nbd_config(s, options, &export, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return -EINVAL;
}
sock = nbd_establish_connection(bs, errp);
if (sock < 0) {
return sock;
}
result = nbd_client_init(bs, sock, export, errp);
return result;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,
Error **VAR_3)
{
BDRVNBDState *s = VAR_0->opaque;
char *VAR_4 = NULL;
int VAR_5, VAR_6;
Error *local_err = NULL;
nbd_config(s, VAR_1, &VAR_4, &local_err);
if (local_err) {
error_propagate(VAR_3, local_err);
return -EINVAL;
}
VAR_6 = nbd_establish_connection(VAR_0, VAR_3);
if (VAR_6 < 0) {
return VAR_6;
}
VAR_5 = nbd_client_init(VAR_0, VAR_6, VAR_4, VAR_3);
return VAR_5;
} | [
"static int FUNC_0(BlockDriverState *VAR_0, QDict *VAR_1, int VAR_2,\nError **VAR_3)\n{",
"BDRVNBDState *s = VAR_0->opaque;",
"char *VAR_4 = NULL;",
"int VAR_5, VAR_6;",
"Error *local_err = NULL;",
"nbd_config(s, VAR_1, &VAR_4, &local_err);",
"if (local_err) {",
"error_propagate(VAR_3, local_err);",
"return -EINVAL;",
"}",
"VAR_6 = nbd_establish_connection(VAR_0, VAR_3);",
"if (VAR_6 < 0) {",
"return VAR_6;",
"}",
"VAR_5 = nbd_client_init(VAR_0, VAR_6, VAR_4, VAR_3);",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
37
],
[
39
],
[
42
],
[
44
],
[
50
],
[
53
],
[
55
]
] |
20,607 | static int convert_coeffs(AVFilterContext *ctx, AVFilterLink *inlink)
{
struct HeadphoneContext *s = ctx->priv;
const int ir_len = s->ir_len;
int nb_irs = s->nb_irs;
int nb_input_channels = ctx->inputs[0]->channels;
float gain_lin = expf((s->gain - 3 * nb_input_channels) / 20 * M_LN10);
FFTComplex *data_hrtf_l = NULL;
FFTComplex *data_hrtf_r = NULL;
FFTComplex *fft_in_l = NULL;
FFTComplex *fft_in_r = NULL;
float *data_ir_l = NULL;
float *data_ir_r = NULL;
int offset = 0;
int n_fft;
int i, j;
s->buffer_length = 1 << (32 - ff_clz(s->ir_len));
s->n_fft = n_fft = 1 << (32 - ff_clz(s->ir_len + inlink->sample_rate));
if (s->type == FREQUENCY_DOMAIN) {
fft_in_l = av_calloc(n_fft, sizeof(*fft_in_l));
fft_in_r = av_calloc(n_fft, sizeof(*fft_in_r));
if (!fft_in_l || !fft_in_r) {
return AVERROR(ENOMEM);
}
av_fft_end(s->fft[0]);
av_fft_end(s->fft[1]);
s->fft[0] = av_fft_init(log2(s->n_fft), 0);
s->fft[1] = av_fft_init(log2(s->n_fft), 0);
av_fft_end(s->ifft[0]);
av_fft_end(s->ifft[1]);
s->ifft[0] = av_fft_init(log2(s->n_fft), 1);
s->ifft[1] = av_fft_init(log2(s->n_fft), 1);
if (!s->fft[0] || !s->fft[1] || !s->ifft[0] || !s->ifft[1]) {
av_log(ctx, AV_LOG_ERROR, "Unable to create FFT contexts of size %d.\n", s->n_fft);
return AVERROR(ENOMEM);
}
}
s->data_ir[0] = av_calloc(FFALIGN(s->ir_len, 16), sizeof(float) * s->nb_irs);
s->data_ir[1] = av_calloc(FFALIGN(s->ir_len, 16), sizeof(float) * s->nb_irs);
s->delay[0] = av_malloc_array(s->nb_irs, sizeof(float));
s->delay[1] = av_malloc_array(s->nb_irs, sizeof(float));
if (s->type == TIME_DOMAIN) {
s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
} else {
s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float));
s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float));
s->temp_fft[0] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
s->temp_fft[1] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
if (!s->temp_fft[0] || !s->temp_fft[1])
return AVERROR(ENOMEM);
}
if (!s->data_ir[0] || !s->data_ir[1] ||
!s->ringbuffer[0] || !s->ringbuffer[1])
return AVERROR(ENOMEM);
s->in[0].frame = ff_get_audio_buffer(ctx->inputs[0], s->size);
if (!s->in[0].frame)
return AVERROR(ENOMEM);
for (i = 0; i < s->nb_irs; i++) {
s->in[i + 1].frame = ff_get_audio_buffer(ctx->inputs[i + 1], s->ir_len);
if (!s->in[i + 1].frame)
return AVERROR(ENOMEM);
}
if (s->type == TIME_DOMAIN) {
s->temp_src[0] = av_calloc(FFALIGN(ir_len, 16), sizeof(float));
s->temp_src[1] = av_calloc(FFALIGN(ir_len, 16), sizeof(float));
data_ir_l = av_calloc(nb_irs * FFALIGN(ir_len, 16), sizeof(*data_ir_l));
data_ir_r = av_calloc(nb_irs * FFALIGN(ir_len, 16), sizeof(*data_ir_r));
if (!data_ir_r || !data_ir_l || !s->temp_src[0] || !s->temp_src[1]) {
av_free(data_ir_l);
av_free(data_ir_r);
return AVERROR(ENOMEM);
}
} else {
data_hrtf_l = av_malloc_array(n_fft, sizeof(*data_hrtf_l) * nb_irs);
data_hrtf_r = av_malloc_array(n_fft, sizeof(*data_hrtf_r) * nb_irs);
if (!data_hrtf_r || !data_hrtf_l) {
av_free(data_hrtf_l);
av_free(data_hrtf_r);
return AVERROR(ENOMEM);
}
}
for (i = 0; i < s->nb_irs; i++) {
int len = s->in[i + 1].ir_len;
int delay_l = s->in[i + 1].delay_l;
int delay_r = s->in[i + 1].delay_r;
int idx = -1;
float *ptr;
for (j = 0; j < inlink->channels; j++) {
if (s->mapping[i] < 0) {
continue;
}
if ((av_channel_layout_extract_channel(inlink->channel_layout, j)) == (1LL << s->mapping[i])) {
idx = j;
break;
}
}
if (idx == -1)
continue;
av_audio_fifo_read(s->in[i + 1].fifo, (void **)s->in[i + 1].frame->extended_data, len);
ptr = (float *)s->in[i + 1].frame->extended_data[0];
if (s->type == TIME_DOMAIN) {
offset = idx * FFALIGN(len, 16);
for (j = 0; j < len; j++) {
data_ir_l[offset + j] = ptr[len * 2 - j * 2 - 2] * gain_lin;
data_ir_r[offset + j] = ptr[len * 2 - j * 2 - 1] * gain_lin;
}
} else {
memset(fft_in_l, 0, n_fft * sizeof(*fft_in_l));
memset(fft_in_r, 0, n_fft * sizeof(*fft_in_r));
offset = idx * n_fft;
for (j = 0; j < len; j++) {
fft_in_l[delay_l + j].re = ptr[j * 2 ] * gain_lin;
fft_in_r[delay_r + j].re = ptr[j * 2 + 1] * gain_lin;
}
av_fft_permute(s->fft[0], fft_in_l);
av_fft_calc(s->fft[0], fft_in_l);
memcpy(data_hrtf_l + offset, fft_in_l, n_fft * sizeof(*fft_in_l));
av_fft_permute(s->fft[0], fft_in_r);
av_fft_calc(s->fft[0], fft_in_r);
memcpy(data_hrtf_r + offset, fft_in_r, n_fft * sizeof(*fft_in_r));
}
}
if (s->type == TIME_DOMAIN) {
memcpy(s->data_ir[0], data_ir_l, sizeof(float) * nb_irs * FFALIGN(ir_len, 16));
memcpy(s->data_ir[1], data_ir_r, sizeof(float) * nb_irs * FFALIGN(ir_len, 16));
av_freep(&data_ir_l);
av_freep(&data_ir_r);
} else {
s->data_hrtf[0] = av_malloc_array(n_fft * s->nb_irs, sizeof(FFTComplex));
s->data_hrtf[1] = av_malloc_array(n_fft * s->nb_irs, sizeof(FFTComplex));
if (!s->data_hrtf[0] || !s->data_hrtf[1]) {
av_freep(&data_hrtf_l);
av_freep(&data_hrtf_r);
av_freep(&fft_in_l);
av_freep(&fft_in_r);
return AVERROR(ENOMEM);
}
memcpy(s->data_hrtf[0], data_hrtf_l,
sizeof(FFTComplex) * nb_irs * n_fft);
memcpy(s->data_hrtf[1], data_hrtf_r,
sizeof(FFTComplex) * nb_irs * n_fft);
av_freep(&data_hrtf_l);
av_freep(&data_hrtf_r);
av_freep(&fft_in_l);
av_freep(&fft_in_r);
}
s->have_hrirs = 1;
return 0;
}
| true | FFmpeg | 9b667f609c509e84ae6ef496edcfb6c8b83c4a38 | static int convert_coeffs(AVFilterContext *ctx, AVFilterLink *inlink)
{
struct HeadphoneContext *s = ctx->priv;
const int ir_len = s->ir_len;
int nb_irs = s->nb_irs;
int nb_input_channels = ctx->inputs[0]->channels;
float gain_lin = expf((s->gain - 3 * nb_input_channels) / 20 * M_LN10);
FFTComplex *data_hrtf_l = NULL;
FFTComplex *data_hrtf_r = NULL;
FFTComplex *fft_in_l = NULL;
FFTComplex *fft_in_r = NULL;
float *data_ir_l = NULL;
float *data_ir_r = NULL;
int offset = 0;
int n_fft;
int i, j;
s->buffer_length = 1 << (32 - ff_clz(s->ir_len));
s->n_fft = n_fft = 1 << (32 - ff_clz(s->ir_len + inlink->sample_rate));
if (s->type == FREQUENCY_DOMAIN) {
fft_in_l = av_calloc(n_fft, sizeof(*fft_in_l));
fft_in_r = av_calloc(n_fft, sizeof(*fft_in_r));
if (!fft_in_l || !fft_in_r) {
return AVERROR(ENOMEM);
}
av_fft_end(s->fft[0]);
av_fft_end(s->fft[1]);
s->fft[0] = av_fft_init(log2(s->n_fft), 0);
s->fft[1] = av_fft_init(log2(s->n_fft), 0);
av_fft_end(s->ifft[0]);
av_fft_end(s->ifft[1]);
s->ifft[0] = av_fft_init(log2(s->n_fft), 1);
s->ifft[1] = av_fft_init(log2(s->n_fft), 1);
if (!s->fft[0] || !s->fft[1] || !s->ifft[0] || !s->ifft[1]) {
av_log(ctx, AV_LOG_ERROR, "Unable to create FFT contexts of size %d.\n", s->n_fft);
return AVERROR(ENOMEM);
}
}
s->data_ir[0] = av_calloc(FFALIGN(s->ir_len, 16), sizeof(float) * s->nb_irs);
s->data_ir[1] = av_calloc(FFALIGN(s->ir_len, 16), sizeof(float) * s->nb_irs);
s->delay[0] = av_malloc_array(s->nb_irs, sizeof(float));
s->delay[1] = av_malloc_array(s->nb_irs, sizeof(float));
if (s->type == TIME_DOMAIN) {
s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
} else {
s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float));
s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float));
s->temp_fft[0] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
s->temp_fft[1] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
if (!s->temp_fft[0] || !s->temp_fft[1])
return AVERROR(ENOMEM);
}
if (!s->data_ir[0] || !s->data_ir[1] ||
!s->ringbuffer[0] || !s->ringbuffer[1])
return AVERROR(ENOMEM);
s->in[0].frame = ff_get_audio_buffer(ctx->inputs[0], s->size);
if (!s->in[0].frame)
return AVERROR(ENOMEM);
for (i = 0; i < s->nb_irs; i++) {
s->in[i + 1].frame = ff_get_audio_buffer(ctx->inputs[i + 1], s->ir_len);
if (!s->in[i + 1].frame)
return AVERROR(ENOMEM);
}
if (s->type == TIME_DOMAIN) {
s->temp_src[0] = av_calloc(FFALIGN(ir_len, 16), sizeof(float));
s->temp_src[1] = av_calloc(FFALIGN(ir_len, 16), sizeof(float));
data_ir_l = av_calloc(nb_irs * FFALIGN(ir_len, 16), sizeof(*data_ir_l));
data_ir_r = av_calloc(nb_irs * FFALIGN(ir_len, 16), sizeof(*data_ir_r));
if (!data_ir_r || !data_ir_l || !s->temp_src[0] || !s->temp_src[1]) {
av_free(data_ir_l);
av_free(data_ir_r);
return AVERROR(ENOMEM);
}
} else {
data_hrtf_l = av_malloc_array(n_fft, sizeof(*data_hrtf_l) * nb_irs);
data_hrtf_r = av_malloc_array(n_fft, sizeof(*data_hrtf_r) * nb_irs);
if (!data_hrtf_r || !data_hrtf_l) {
av_free(data_hrtf_l);
av_free(data_hrtf_r);
return AVERROR(ENOMEM);
}
}
for (i = 0; i < s->nb_irs; i++) {
int len = s->in[i + 1].ir_len;
int delay_l = s->in[i + 1].delay_l;
int delay_r = s->in[i + 1].delay_r;
int idx = -1;
float *ptr;
for (j = 0; j < inlink->channels; j++) {
if (s->mapping[i] < 0) {
continue;
}
if ((av_channel_layout_extract_channel(inlink->channel_layout, j)) == (1LL << s->mapping[i])) {
idx = j;
break;
}
}
if (idx == -1)
continue;
av_audio_fifo_read(s->in[i + 1].fifo, (void **)s->in[i + 1].frame->extended_data, len);
ptr = (float *)s->in[i + 1].frame->extended_data[0];
if (s->type == TIME_DOMAIN) {
offset = idx * FFALIGN(len, 16);
for (j = 0; j < len; j++) {
data_ir_l[offset + j] = ptr[len * 2 - j * 2 - 2] * gain_lin;
data_ir_r[offset + j] = ptr[len * 2 - j * 2 - 1] * gain_lin;
}
} else {
memset(fft_in_l, 0, n_fft * sizeof(*fft_in_l));
memset(fft_in_r, 0, n_fft * sizeof(*fft_in_r));
offset = idx * n_fft;
for (j = 0; j < len; j++) {
fft_in_l[delay_l + j].re = ptr[j * 2 ] * gain_lin;
fft_in_r[delay_r + j].re = ptr[j * 2 + 1] * gain_lin;
}
av_fft_permute(s->fft[0], fft_in_l);
av_fft_calc(s->fft[0], fft_in_l);
memcpy(data_hrtf_l + offset, fft_in_l, n_fft * sizeof(*fft_in_l));
av_fft_permute(s->fft[0], fft_in_r);
av_fft_calc(s->fft[0], fft_in_r);
memcpy(data_hrtf_r + offset, fft_in_r, n_fft * sizeof(*fft_in_r));
}
}
if (s->type == TIME_DOMAIN) {
memcpy(s->data_ir[0], data_ir_l, sizeof(float) * nb_irs * FFALIGN(ir_len, 16));
memcpy(s->data_ir[1], data_ir_r, sizeof(float) * nb_irs * FFALIGN(ir_len, 16));
av_freep(&data_ir_l);
av_freep(&data_ir_r);
} else {
s->data_hrtf[0] = av_malloc_array(n_fft * s->nb_irs, sizeof(FFTComplex));
s->data_hrtf[1] = av_malloc_array(n_fft * s->nb_irs, sizeof(FFTComplex));
if (!s->data_hrtf[0] || !s->data_hrtf[1]) {
av_freep(&data_hrtf_l);
av_freep(&data_hrtf_r);
av_freep(&fft_in_l);
av_freep(&fft_in_r);
return AVERROR(ENOMEM);
}
memcpy(s->data_hrtf[0], data_hrtf_l,
sizeof(FFTComplex) * nb_irs * n_fft);
memcpy(s->data_hrtf[1], data_hrtf_r,
sizeof(FFTComplex) * nb_irs * n_fft);
av_freep(&data_hrtf_l);
av_freep(&data_hrtf_r);
av_freep(&fft_in_l);
av_freep(&fft_in_r);
}
s->have_hrirs = 1;
return 0;
}
| {
"code": [
" int offset = 0;",
" return AVERROR(ENOMEM);",
" return AVERROR(ENOMEM);",
" if (!s->temp_fft[0] || !s->temp_fft[1])",
" return AVERROR(ENOMEM);",
" !s->ringbuffer[0] || !s->ringbuffer[1])",
" return AVERROR(ENOMEM);",
" if (!s->in[0].frame)",
" return AVERROR(ENOMEM);",
" if (!s->in[i + 1].frame)",
" return AVERROR(ENOMEM);",
" av_free(data_ir_l);",
" av_free(data_ir_r);",
" return AVERROR(ENOMEM);",
" av_free(data_hrtf_l);",
" av_free(data_hrtf_r);",
" return AVERROR(ENOMEM);",
" av_freep(&data_ir_l);",
" av_freep(&data_ir_r);",
" av_freep(&data_hrtf_l);",
" av_freep(&data_hrtf_r);",
" av_freep(&fft_in_l);",
" av_freep(&fft_in_r);",
" return AVERROR(ENOMEM);",
" av_freep(&data_hrtf_l);",
" av_freep(&data_hrtf_r);",
" av_freep(&fft_in_l);",
" av_freep(&fft_in_r);",
" return 0;"
],
"line_no": [
27,
49,
49,
111,
49,
121,
123,
129,
123,
137,
49,
159,
161,
49,
175,
177,
49,
291,
293,
303,
305,
307,
309,
49,
327,
329,
333,
335,
345
]
} | static int FUNC_0(AVFilterContext *VAR_0, AVFilterLink *VAR_1)
{
struct HeadphoneContext *VAR_2 = VAR_0->priv;
const int VAR_3 = VAR_2->VAR_3;
int VAR_4 = VAR_2->VAR_4;
int VAR_5 = VAR_0->inputs[0]->channels;
float VAR_6 = expf((VAR_2->gain - 3 * VAR_5) / 20 * M_LN10);
FFTComplex *data_hrtf_l = NULL;
FFTComplex *data_hrtf_r = NULL;
FFTComplex *fft_in_l = NULL;
FFTComplex *fft_in_r = NULL;
float *VAR_7 = NULL;
float *VAR_8 = NULL;
int VAR_9 = 0;
int VAR_10;
int VAR_11, VAR_12;
VAR_2->buffer_length = 1 << (32 - ff_clz(VAR_2->VAR_3));
VAR_2->VAR_10 = VAR_10 = 1 << (32 - ff_clz(VAR_2->VAR_3 + VAR_1->sample_rate));
if (VAR_2->type == FREQUENCY_DOMAIN) {
fft_in_l = av_calloc(VAR_10, sizeof(*fft_in_l));
fft_in_r = av_calloc(VAR_10, sizeof(*fft_in_r));
if (!fft_in_l || !fft_in_r) {
return AVERROR(ENOMEM);
}
av_fft_end(VAR_2->fft[0]);
av_fft_end(VAR_2->fft[1]);
VAR_2->fft[0] = av_fft_init(log2(VAR_2->VAR_10), 0);
VAR_2->fft[1] = av_fft_init(log2(VAR_2->VAR_10), 0);
av_fft_end(VAR_2->ifft[0]);
av_fft_end(VAR_2->ifft[1]);
VAR_2->ifft[0] = av_fft_init(log2(VAR_2->VAR_10), 1);
VAR_2->ifft[1] = av_fft_init(log2(VAR_2->VAR_10), 1);
if (!VAR_2->fft[0] || !VAR_2->fft[1] || !VAR_2->ifft[0] || !VAR_2->ifft[1]) {
av_log(VAR_0, AV_LOG_ERROR, "Unable to create FFT contexts of size %d.\n", VAR_2->VAR_10);
return AVERROR(ENOMEM);
}
}
VAR_2->data_ir[0] = av_calloc(FFALIGN(VAR_2->VAR_3, 16), sizeof(float) * VAR_2->VAR_4);
VAR_2->data_ir[1] = av_calloc(FFALIGN(VAR_2->VAR_3, 16), sizeof(float) * VAR_2->VAR_4);
VAR_2->delay[0] = av_malloc_array(VAR_2->VAR_4, sizeof(float));
VAR_2->delay[1] = av_malloc_array(VAR_2->VAR_4, sizeof(float));
if (VAR_2->type == TIME_DOMAIN) {
VAR_2->ringbuffer[0] = av_calloc(VAR_2->buffer_length, sizeof(float) * VAR_5);
VAR_2->ringbuffer[1] = av_calloc(VAR_2->buffer_length, sizeof(float) * VAR_5);
} else {
VAR_2->ringbuffer[0] = av_calloc(VAR_2->buffer_length, sizeof(float));
VAR_2->ringbuffer[1] = av_calloc(VAR_2->buffer_length, sizeof(float));
VAR_2->temp_fft[0] = av_malloc_array(VAR_2->VAR_10, sizeof(FFTComplex));
VAR_2->temp_fft[1] = av_malloc_array(VAR_2->VAR_10, sizeof(FFTComplex));
if (!VAR_2->temp_fft[0] || !VAR_2->temp_fft[1])
return AVERROR(ENOMEM);
}
if (!VAR_2->data_ir[0] || !VAR_2->data_ir[1] ||
!VAR_2->ringbuffer[0] || !VAR_2->ringbuffer[1])
return AVERROR(ENOMEM);
VAR_2->in[0].frame = ff_get_audio_buffer(VAR_0->inputs[0], VAR_2->size);
if (!VAR_2->in[0].frame)
return AVERROR(ENOMEM);
for (VAR_11 = 0; VAR_11 < VAR_2->VAR_4; VAR_11++) {
VAR_2->in[VAR_11 + 1].frame = ff_get_audio_buffer(VAR_0->inputs[VAR_11 + 1], VAR_2->VAR_3);
if (!VAR_2->in[VAR_11 + 1].frame)
return AVERROR(ENOMEM);
}
if (VAR_2->type == TIME_DOMAIN) {
VAR_2->temp_src[0] = av_calloc(FFALIGN(VAR_3, 16), sizeof(float));
VAR_2->temp_src[1] = av_calloc(FFALIGN(VAR_3, 16), sizeof(float));
VAR_7 = av_calloc(VAR_4 * FFALIGN(VAR_3, 16), sizeof(*VAR_7));
VAR_8 = av_calloc(VAR_4 * FFALIGN(VAR_3, 16), sizeof(*VAR_8));
if (!VAR_8 || !VAR_7 || !VAR_2->temp_src[0] || !VAR_2->temp_src[1]) {
av_free(VAR_7);
av_free(VAR_8);
return AVERROR(ENOMEM);
}
} else {
data_hrtf_l = av_malloc_array(VAR_10, sizeof(*data_hrtf_l) * VAR_4);
data_hrtf_r = av_malloc_array(VAR_10, sizeof(*data_hrtf_r) * VAR_4);
if (!data_hrtf_r || !data_hrtf_l) {
av_free(data_hrtf_l);
av_free(data_hrtf_r);
return AVERROR(ENOMEM);
}
}
for (VAR_11 = 0; VAR_11 < VAR_2->VAR_4; VAR_11++) {
int VAR_13 = VAR_2->in[VAR_11 + 1].VAR_3;
int VAR_14 = VAR_2->in[VAR_11 + 1].VAR_14;
int VAR_15 = VAR_2->in[VAR_11 + 1].VAR_15;
int VAR_16 = -1;
float *VAR_17;
for (VAR_12 = 0; VAR_12 < VAR_1->channels; VAR_12++) {
if (VAR_2->mapping[VAR_11] < 0) {
continue;
}
if ((av_channel_layout_extract_channel(VAR_1->channel_layout, VAR_12)) == (1LL << VAR_2->mapping[VAR_11])) {
VAR_16 = VAR_12;
break;
}
}
if (VAR_16 == -1)
continue;
av_audio_fifo_read(VAR_2->in[VAR_11 + 1].fifo, (void **)VAR_2->in[VAR_11 + 1].frame->extended_data, VAR_13);
VAR_17 = (float *)VAR_2->in[VAR_11 + 1].frame->extended_data[0];
if (VAR_2->type == TIME_DOMAIN) {
VAR_9 = VAR_16 * FFALIGN(VAR_13, 16);
for (VAR_12 = 0; VAR_12 < VAR_13; VAR_12++) {
VAR_7[VAR_9 + VAR_12] = VAR_17[VAR_13 * 2 - VAR_12 * 2 - 2] * VAR_6;
VAR_8[VAR_9 + VAR_12] = VAR_17[VAR_13 * 2 - VAR_12 * 2 - 1] * VAR_6;
}
} else {
memset(fft_in_l, 0, VAR_10 * sizeof(*fft_in_l));
memset(fft_in_r, 0, VAR_10 * sizeof(*fft_in_r));
VAR_9 = VAR_16 * VAR_10;
for (VAR_12 = 0; VAR_12 < VAR_13; VAR_12++) {
fft_in_l[VAR_14 + VAR_12].re = VAR_17[VAR_12 * 2 ] * VAR_6;
fft_in_r[VAR_15 + VAR_12].re = VAR_17[VAR_12 * 2 + 1] * VAR_6;
}
av_fft_permute(VAR_2->fft[0], fft_in_l);
av_fft_calc(VAR_2->fft[0], fft_in_l);
memcpy(data_hrtf_l + VAR_9, fft_in_l, VAR_10 * sizeof(*fft_in_l));
av_fft_permute(VAR_2->fft[0], fft_in_r);
av_fft_calc(VAR_2->fft[0], fft_in_r);
memcpy(data_hrtf_r + VAR_9, fft_in_r, VAR_10 * sizeof(*fft_in_r));
}
}
if (VAR_2->type == TIME_DOMAIN) {
memcpy(VAR_2->data_ir[0], VAR_7, sizeof(float) * VAR_4 * FFALIGN(VAR_3, 16));
memcpy(VAR_2->data_ir[1], VAR_8, sizeof(float) * VAR_4 * FFALIGN(VAR_3, 16));
av_freep(&VAR_7);
av_freep(&VAR_8);
} else {
VAR_2->data_hrtf[0] = av_malloc_array(VAR_10 * VAR_2->VAR_4, sizeof(FFTComplex));
VAR_2->data_hrtf[1] = av_malloc_array(VAR_10 * VAR_2->VAR_4, sizeof(FFTComplex));
if (!VAR_2->data_hrtf[0] || !VAR_2->data_hrtf[1]) {
av_freep(&data_hrtf_l);
av_freep(&data_hrtf_r);
av_freep(&fft_in_l);
av_freep(&fft_in_r);
return AVERROR(ENOMEM);
}
memcpy(VAR_2->data_hrtf[0], data_hrtf_l,
sizeof(FFTComplex) * VAR_4 * VAR_10);
memcpy(VAR_2->data_hrtf[1], data_hrtf_r,
sizeof(FFTComplex) * VAR_4 * VAR_10);
av_freep(&data_hrtf_l);
av_freep(&data_hrtf_r);
av_freep(&fft_in_l);
av_freep(&fft_in_r);
}
VAR_2->have_hrirs = 1;
return 0;
}
| [
"static int FUNC_0(AVFilterContext *VAR_0, AVFilterLink *VAR_1)\n{",
"struct HeadphoneContext *VAR_2 = VAR_0->priv;",
"const int VAR_3 = VAR_2->VAR_3;",
"int VAR_4 = VAR_2->VAR_4;",
"int VAR_5 = VAR_0->inputs[0]->channels;",
"float VAR_6 = expf((VAR_2->gain - 3 * VAR_5) / 20 * M_LN10);",
"FFTComplex *data_hrtf_l = NULL;",
"FFTComplex *data_hrtf_r = NULL;",
"FFTComplex *fft_in_l = NULL;",
"FFTComplex *fft_in_r = NULL;",
"float *VAR_7 = NULL;",
"float *VAR_8 = NULL;",
"int VAR_9 = 0;",
"int VAR_10;",
"int VAR_11, VAR_12;",
"VAR_2->buffer_length = 1 << (32 - ff_clz(VAR_2->VAR_3));",
"VAR_2->VAR_10 = VAR_10 = 1 << (32 - ff_clz(VAR_2->VAR_3 + VAR_1->sample_rate));",
"if (VAR_2->type == FREQUENCY_DOMAIN) {",
"fft_in_l = av_calloc(VAR_10, sizeof(*fft_in_l));",
"fft_in_r = av_calloc(VAR_10, sizeof(*fft_in_r));",
"if (!fft_in_l || !fft_in_r) {",
"return AVERROR(ENOMEM);",
"}",
"av_fft_end(VAR_2->fft[0]);",
"av_fft_end(VAR_2->fft[1]);",
"VAR_2->fft[0] = av_fft_init(log2(VAR_2->VAR_10), 0);",
"VAR_2->fft[1] = av_fft_init(log2(VAR_2->VAR_10), 0);",
"av_fft_end(VAR_2->ifft[0]);",
"av_fft_end(VAR_2->ifft[1]);",
"VAR_2->ifft[0] = av_fft_init(log2(VAR_2->VAR_10), 1);",
"VAR_2->ifft[1] = av_fft_init(log2(VAR_2->VAR_10), 1);",
"if (!VAR_2->fft[0] || !VAR_2->fft[1] || !VAR_2->ifft[0] || !VAR_2->ifft[1]) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Unable to create FFT contexts of size %d.\\n\", VAR_2->VAR_10);",
"return AVERROR(ENOMEM);",
"}",
"}",
"VAR_2->data_ir[0] = av_calloc(FFALIGN(VAR_2->VAR_3, 16), sizeof(float) * VAR_2->VAR_4);",
"VAR_2->data_ir[1] = av_calloc(FFALIGN(VAR_2->VAR_3, 16), sizeof(float) * VAR_2->VAR_4);",
"VAR_2->delay[0] = av_malloc_array(VAR_2->VAR_4, sizeof(float));",
"VAR_2->delay[1] = av_malloc_array(VAR_2->VAR_4, sizeof(float));",
"if (VAR_2->type == TIME_DOMAIN) {",
"VAR_2->ringbuffer[0] = av_calloc(VAR_2->buffer_length, sizeof(float) * VAR_5);",
"VAR_2->ringbuffer[1] = av_calloc(VAR_2->buffer_length, sizeof(float) * VAR_5);",
"} else {",
"VAR_2->ringbuffer[0] = av_calloc(VAR_2->buffer_length, sizeof(float));",
"VAR_2->ringbuffer[1] = av_calloc(VAR_2->buffer_length, sizeof(float));",
"VAR_2->temp_fft[0] = av_malloc_array(VAR_2->VAR_10, sizeof(FFTComplex));",
"VAR_2->temp_fft[1] = av_malloc_array(VAR_2->VAR_10, sizeof(FFTComplex));",
"if (!VAR_2->temp_fft[0] || !VAR_2->temp_fft[1])\nreturn AVERROR(ENOMEM);",
"}",
"if (!VAR_2->data_ir[0] || !VAR_2->data_ir[1] ||\n!VAR_2->ringbuffer[0] || !VAR_2->ringbuffer[1])\nreturn AVERROR(ENOMEM);",
"VAR_2->in[0].frame = ff_get_audio_buffer(VAR_0->inputs[0], VAR_2->size);",
"if (!VAR_2->in[0].frame)\nreturn AVERROR(ENOMEM);",
"for (VAR_11 = 0; VAR_11 < VAR_2->VAR_4; VAR_11++) {",
"VAR_2->in[VAR_11 + 1].frame = ff_get_audio_buffer(VAR_0->inputs[VAR_11 + 1], VAR_2->VAR_3);",
"if (!VAR_2->in[VAR_11 + 1].frame)\nreturn AVERROR(ENOMEM);",
"}",
"if (VAR_2->type == TIME_DOMAIN) {",
"VAR_2->temp_src[0] = av_calloc(FFALIGN(VAR_3, 16), sizeof(float));",
"VAR_2->temp_src[1] = av_calloc(FFALIGN(VAR_3, 16), sizeof(float));",
"VAR_7 = av_calloc(VAR_4 * FFALIGN(VAR_3, 16), sizeof(*VAR_7));",
"VAR_8 = av_calloc(VAR_4 * FFALIGN(VAR_3, 16), sizeof(*VAR_8));",
"if (!VAR_8 || !VAR_7 || !VAR_2->temp_src[0] || !VAR_2->temp_src[1]) {",
"av_free(VAR_7);",
"av_free(VAR_8);",
"return AVERROR(ENOMEM);",
"}",
"} else {",
"data_hrtf_l = av_malloc_array(VAR_10, sizeof(*data_hrtf_l) * VAR_4);",
"data_hrtf_r = av_malloc_array(VAR_10, sizeof(*data_hrtf_r) * VAR_4);",
"if (!data_hrtf_r || !data_hrtf_l) {",
"av_free(data_hrtf_l);",
"av_free(data_hrtf_r);",
"return AVERROR(ENOMEM);",
"}",
"}",
"for (VAR_11 = 0; VAR_11 < VAR_2->VAR_4; VAR_11++) {",
"int VAR_13 = VAR_2->in[VAR_11 + 1].VAR_3;",
"int VAR_14 = VAR_2->in[VAR_11 + 1].VAR_14;",
"int VAR_15 = VAR_2->in[VAR_11 + 1].VAR_15;",
"int VAR_16 = -1;",
"float *VAR_17;",
"for (VAR_12 = 0; VAR_12 < VAR_1->channels; VAR_12++) {",
"if (VAR_2->mapping[VAR_11] < 0) {",
"continue;",
"}",
"if ((av_channel_layout_extract_channel(VAR_1->channel_layout, VAR_12)) == (1LL << VAR_2->mapping[VAR_11])) {",
"VAR_16 = VAR_12;",
"break;",
"}",
"}",
"if (VAR_16 == -1)\ncontinue;",
"av_audio_fifo_read(VAR_2->in[VAR_11 + 1].fifo, (void **)VAR_2->in[VAR_11 + 1].frame->extended_data, VAR_13);",
"VAR_17 = (float *)VAR_2->in[VAR_11 + 1].frame->extended_data[0];",
"if (VAR_2->type == TIME_DOMAIN) {",
"VAR_9 = VAR_16 * FFALIGN(VAR_13, 16);",
"for (VAR_12 = 0; VAR_12 < VAR_13; VAR_12++) {",
"VAR_7[VAR_9 + VAR_12] = VAR_17[VAR_13 * 2 - VAR_12 * 2 - 2] * VAR_6;",
"VAR_8[VAR_9 + VAR_12] = VAR_17[VAR_13 * 2 - VAR_12 * 2 - 1] * VAR_6;",
"}",
"} else {",
"memset(fft_in_l, 0, VAR_10 * sizeof(*fft_in_l));",
"memset(fft_in_r, 0, VAR_10 * sizeof(*fft_in_r));",
"VAR_9 = VAR_16 * VAR_10;",
"for (VAR_12 = 0; VAR_12 < VAR_13; VAR_12++) {",
"fft_in_l[VAR_14 + VAR_12].re = VAR_17[VAR_12 * 2 ] * VAR_6;",
"fft_in_r[VAR_15 + VAR_12].re = VAR_17[VAR_12 * 2 + 1] * VAR_6;",
"}",
"av_fft_permute(VAR_2->fft[0], fft_in_l);",
"av_fft_calc(VAR_2->fft[0], fft_in_l);",
"memcpy(data_hrtf_l + VAR_9, fft_in_l, VAR_10 * sizeof(*fft_in_l));",
"av_fft_permute(VAR_2->fft[0], fft_in_r);",
"av_fft_calc(VAR_2->fft[0], fft_in_r);",
"memcpy(data_hrtf_r + VAR_9, fft_in_r, VAR_10 * sizeof(*fft_in_r));",
"}",
"}",
"if (VAR_2->type == TIME_DOMAIN) {",
"memcpy(VAR_2->data_ir[0], VAR_7, sizeof(float) * VAR_4 * FFALIGN(VAR_3, 16));",
"memcpy(VAR_2->data_ir[1], VAR_8, sizeof(float) * VAR_4 * FFALIGN(VAR_3, 16));",
"av_freep(&VAR_7);",
"av_freep(&VAR_8);",
"} else {",
"VAR_2->data_hrtf[0] = av_malloc_array(VAR_10 * VAR_2->VAR_4, sizeof(FFTComplex));",
"VAR_2->data_hrtf[1] = av_malloc_array(VAR_10 * VAR_2->VAR_4, sizeof(FFTComplex));",
"if (!VAR_2->data_hrtf[0] || !VAR_2->data_hrtf[1]) {",
"av_freep(&data_hrtf_l);",
"av_freep(&data_hrtf_r);",
"av_freep(&fft_in_l);",
"av_freep(&fft_in_r);",
"return AVERROR(ENOMEM);",
"}",
"memcpy(VAR_2->data_hrtf[0], data_hrtf_l,\nsizeof(FFTComplex) * VAR_4 * VAR_10);",
"memcpy(VAR_2->data_hrtf[1], data_hrtf_r,\nsizeof(FFTComplex) * VAR_4 * VAR_10);",
"av_freep(&data_hrtf_l);",
"av_freep(&data_hrtf_r);",
"av_freep(&fft_in_l);",
"av_freep(&fft_in_r);",
"}",
"VAR_2->have_hrirs = 1;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
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,
1,
0,
1,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
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,
0,
0,
1,
1,
0,
0,
0,
0,
1,
1,
1,
1,
0,
0,
0,
0,
1,
1,
1,
1,
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111,
113
],
[
115
],
[
119,
121,
123
],
[
127
],
[
129,
131
],
[
133
],
[
135
],
[
137,
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201
],
[
203
],
[
205
],
[
207
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221,
223
],
[
227
],
[
229
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279
],
[
283
],
[
285
],
[
287
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303
],
[
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
317,
319
],
[
321,
323
],
[
327
],
[
329
],
[
333
],
[
335
],
[
337
],
[
341
],
[
345
],
[
347
]
] |
20,608 | static void nic_cleanup(VLANClientState *nc)
{
dp8393xState *s = DO_UPCAST(NICState, nc, nc)->opaque;
cpu_unregister_io_memory(s->mmio_index);
qemu_del_timer(s->watchdog);
qemu_free_timer(s->watchdog);
g_free(s);
}
| true | qemu | 024e5bb664bda54b393e405f425f10fa9d3fbd1a | static void nic_cleanup(VLANClientState *nc)
{
dp8393xState *s = DO_UPCAST(NICState, nc, nc)->opaque;
cpu_unregister_io_memory(s->mmio_index);
qemu_del_timer(s->watchdog);
qemu_free_timer(s->watchdog);
g_free(s);
}
| {
"code": [
" cpu_unregister_io_memory(s->mmio_index);"
],
"line_no": [
9
]
} | static void FUNC_0(VLANClientState *VAR_0)
{
dp8393xState *s = DO_UPCAST(NICState, VAR_0, VAR_0)->opaque;
cpu_unregister_io_memory(s->mmio_index);
qemu_del_timer(s->watchdog);
qemu_free_timer(s->watchdog);
g_free(s);
}
| [
"static void FUNC_0(VLANClientState *VAR_0)\n{",
"dp8393xState *s = DO_UPCAST(NICState, VAR_0, VAR_0)->opaque;",
"cpu_unregister_io_memory(s->mmio_index);",
"qemu_del_timer(s->watchdog);",
"qemu_free_timer(s->watchdog);",
"g_free(s);",
"}"
] | [
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
15
],
[
19
],
[
21
]
] |
20,609 | static void ide_init1(IDEBus *bus, int unit)
{
static int drive_serial = 1;
IDEState *s = &bus->ifs[unit];
s->bus = bus;
s->unit = unit;
s->drive_serial = drive_serial++;
/* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
s->io_buffer = qemu_memalign(2048, IDE_DMA_BUF_SECTORS*512 + 4);
s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
s->smart_selftest_data = qemu_blockalign(s->bs, 512);
s->sector_write_timer = qemu_new_timer_ns(vm_clock,
ide_sector_write_timer_cb, s);
}
| true | qemu | c925400ba83bd57bf560e071f400012248f1644a | static void ide_init1(IDEBus *bus, int unit)
{
static int drive_serial = 1;
IDEState *s = &bus->ifs[unit];
s->bus = bus;
s->unit = unit;
s->drive_serial = drive_serial++;
s->io_buffer = qemu_memalign(2048, IDE_DMA_BUF_SECTORS*512 + 4);
s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
s->smart_selftest_data = qemu_blockalign(s->bs, 512);
s->sector_write_timer = qemu_new_timer_ns(vm_clock,
ide_sector_write_timer_cb, s);
}
| {
"code": [
" s->io_buffer = qemu_memalign(2048, IDE_DMA_BUF_SECTORS*512 + 4);"
],
"line_no": [
19
]
} | static void FUNC_0(IDEBus *VAR_0, int VAR_1)
{
static int VAR_2 = 1;
IDEState *s = &VAR_0->ifs[VAR_1];
s->VAR_0 = VAR_0;
s->VAR_1 = VAR_1;
s->VAR_2 = VAR_2++;
s->io_buffer = qemu_memalign(2048, IDE_DMA_BUF_SECTORS*512 + 4);
s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
s->smart_selftest_data = qemu_blockalign(s->bs, 512);
s->sector_write_timer = qemu_new_timer_ns(vm_clock,
ide_sector_write_timer_cb, s);
}
| [
"static void FUNC_0(IDEBus *VAR_0, int VAR_1)\n{",
"static int VAR_2 = 1;",
"IDEState *s = &VAR_0->ifs[VAR_1];",
"s->VAR_0 = VAR_0;",
"s->VAR_1 = VAR_1;",
"s->VAR_2 = VAR_2++;",
"s->io_buffer = qemu_memalign(2048, IDE_DMA_BUF_SECTORS*512 + 4);",
"s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;",
"s->smart_selftest_data = qemu_blockalign(s->bs, 512);",
"s->sector_write_timer = qemu_new_timer_ns(vm_clock,\nide_sector_write_timer_cb, s);",
"}"
] | [
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
]
] |
20,611 | static int iscsi_create(const char *filename, QEMUOptionParameter *options)
{
int ret = 0;
int64_t total_size = 0;
BlockDriverState bs;
IscsiLun *iscsilun = NULL;
QDict *bs_options;
memset(&bs, 0, sizeof(BlockDriverState));
/* Read out options */
while (options && options->name) {
if (!strcmp(options->name, "size")) {
total_size = options->value.n / BDRV_SECTOR_SIZE;
}
options++;
}
bs.opaque = g_malloc0(sizeof(struct IscsiLun));
iscsilun = bs.opaque;
bs_options = qdict_new();
qdict_put(bs_options, "filename", qstring_from_str(filename));
ret = iscsi_open(&bs, bs_options, 0);
QDECREF(bs_options);
if (ret != 0) {
goto out;
}
if (iscsilun->nop_timer) {
timer_del(iscsilun->nop_timer);
timer_free(iscsilun->nop_timer);
}
if (iscsilun->type != TYPE_DISK) {
ret = -ENODEV;
goto out;
}
if (bs.total_sectors < total_size) {
ret = -ENOSPC;
goto out;
}
ret = 0;
out:
if (iscsilun->iscsi != NULL) {
iscsi_destroy_context(iscsilun->iscsi);
}
g_free(bs.opaque);
return ret;
}
| true | qemu | 13c91cb7e28b47f5c4227f7e88a1378570117704 | static int iscsi_create(const char *filename, QEMUOptionParameter *options)
{
int ret = 0;
int64_t total_size = 0;
BlockDriverState bs;
IscsiLun *iscsilun = NULL;
QDict *bs_options;
memset(&bs, 0, sizeof(BlockDriverState));
while (options && options->name) {
if (!strcmp(options->name, "size")) {
total_size = options->value.n / BDRV_SECTOR_SIZE;
}
options++;
}
bs.opaque = g_malloc0(sizeof(struct IscsiLun));
iscsilun = bs.opaque;
bs_options = qdict_new();
qdict_put(bs_options, "filename", qstring_from_str(filename));
ret = iscsi_open(&bs, bs_options, 0);
QDECREF(bs_options);
if (ret != 0) {
goto out;
}
if (iscsilun->nop_timer) {
timer_del(iscsilun->nop_timer);
timer_free(iscsilun->nop_timer);
}
if (iscsilun->type != TYPE_DISK) {
ret = -ENODEV;
goto out;
}
if (bs.total_sectors < total_size) {
ret = -ENOSPC;
goto out;
}
ret = 0;
out:
if (iscsilun->iscsi != NULL) {
iscsi_destroy_context(iscsilun->iscsi);
}
g_free(bs.opaque);
return ret;
}
| {
"code": [
" BlockDriverState bs;",
" memset(&bs, 0, sizeof(BlockDriverState));",
" bs.opaque = g_malloc0(sizeof(struct IscsiLun));",
" iscsilun = bs.opaque;",
" ret = iscsi_open(&bs, bs_options, 0);",
" if (bs.total_sectors < total_size) {",
" g_free(bs.opaque);"
],
"line_no": [
9,
17,
37,
39,
47,
75,
95
]
} | static int FUNC_0(const char *VAR_0, QEMUOptionParameter *VAR_1)
{
int VAR_2 = 0;
int64_t total_size = 0;
BlockDriverState bs;
IscsiLun *iscsilun = NULL;
QDict *bs_options;
memset(&bs, 0, sizeof(BlockDriverState));
while (VAR_1 && VAR_1->name) {
if (!strcmp(VAR_1->name, "size")) {
total_size = VAR_1->value.n / BDRV_SECTOR_SIZE;
}
VAR_1++;
}
bs.opaque = g_malloc0(sizeof(struct IscsiLun));
iscsilun = bs.opaque;
bs_options = qdict_new();
qdict_put(bs_options, "VAR_0", qstring_from_str(VAR_0));
VAR_2 = iscsi_open(&bs, bs_options, 0);
QDECREF(bs_options);
if (VAR_2 != 0) {
goto out;
}
if (iscsilun->nop_timer) {
timer_del(iscsilun->nop_timer);
timer_free(iscsilun->nop_timer);
}
if (iscsilun->type != TYPE_DISK) {
VAR_2 = -ENODEV;
goto out;
}
if (bs.total_sectors < total_size) {
VAR_2 = -ENOSPC;
goto out;
}
VAR_2 = 0;
out:
if (iscsilun->iscsi != NULL) {
iscsi_destroy_context(iscsilun->iscsi);
}
g_free(bs.opaque);
return VAR_2;
}
| [
"static int FUNC_0(const char *VAR_0, QEMUOptionParameter *VAR_1)\n{",
"int VAR_2 = 0;",
"int64_t total_size = 0;",
"BlockDriverState bs;",
"IscsiLun *iscsilun = NULL;",
"QDict *bs_options;",
"memset(&bs, 0, sizeof(BlockDriverState));",
"while (VAR_1 && VAR_1->name) {",
"if (!strcmp(VAR_1->name, \"size\")) {",
"total_size = VAR_1->value.n / BDRV_SECTOR_SIZE;",
"}",
"VAR_1++;",
"}",
"bs.opaque = g_malloc0(sizeof(struct IscsiLun));",
"iscsilun = bs.opaque;",
"bs_options = qdict_new();",
"qdict_put(bs_options, \"VAR_0\", qstring_from_str(VAR_0));",
"VAR_2 = iscsi_open(&bs, bs_options, 0);",
"QDECREF(bs_options);",
"if (VAR_2 != 0) {",
"goto out;",
"}",
"if (iscsilun->nop_timer) {",
"timer_del(iscsilun->nop_timer);",
"timer_free(iscsilun->nop_timer);",
"}",
"if (iscsilun->type != TYPE_DISK) {",
"VAR_2 = -ENODEV;",
"goto out;",
"}",
"if (bs.total_sectors < total_size) {",
"VAR_2 = -ENOSPC;",
"goto out;",
"}",
"VAR_2 = 0;",
"out:\nif (iscsilun->iscsi != NULL) {",
"iscsi_destroy_context(iscsilun->iscsi);",
"}",
"g_free(bs.opaque);",
"return VAR_2;",
"}"
] | [
0,
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
]
] |
20,612 | Exynos4210State *exynos4210_init(MemoryRegion *system_mem,
unsigned long ram_size)
{
int i, n;
Exynos4210State *s = g_new(Exynos4210State, 1);
qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];
unsigned long mem_size;
DeviceState *dev;
SysBusDevice *busdev;
ObjectClass *cpu_oc;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, "cortex-a9");
assert(cpu_oc);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
Object *cpuobj = object_new(object_class_get_name(cpu_oc));
Error *err = NULL;
/* By default A9 CPUs have EL3 enabled. This board does not currently
* support EL3 so the CPU EL3 property is disabled before realization.
*/
if (object_property_find(cpuobj, "has_el3", NULL)) {
object_property_set_bool(cpuobj, false, "has_el3", &err);
if (err) {
error_report_err(err);
exit(1);
}
}
s->cpu[n] = ARM_CPU(cpuobj);
object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,
"reset-cbar", &error_abort);
object_property_set_bool(cpuobj, true, "realized", &err);
if (err) {
error_report_err(err);
exit(1);
}
}
/*** IRQs ***/
s->irq_table = exynos4210_init_irq(&s->irqs);
/* IRQ Gate */
for (i = 0; i < EXYNOS4210_NCPUS; i++) {
dev = qdev_create(NULL, "exynos4210.irq_gate");
qdev_prop_set_uint32(dev, "n_in", EXYNOS4210_IRQ_GATE_NINPUTS);
qdev_init_nofail(dev);
/* Get IRQ Gate input in gate_irq */
for (n = 0; n < EXYNOS4210_IRQ_GATE_NINPUTS; n++) {
gate_irq[i][n] = qdev_get_gpio_in(dev, n);
}
busdev = SYS_BUS_DEVICE(dev);
/* Connect IRQ Gate output to CPU's IRQ line */
sysbus_connect_irq(busdev, 0,
qdev_get_gpio_in(DEVICE(s->cpu[i]), ARM_CPU_IRQ));
}
/* Private memory region and Internal GIC */
dev = qdev_create(NULL, "a9mpcore_priv");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][0]);
}
for (n = 0; n < EXYNOS4210_INT_GIC_NIRQ; n++) {
s->irqs.int_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
/* Cache controller */
sysbus_create_simple("l2x0", EXYNOS4210_L2X0_BASE_ADDR, NULL);
/* External GIC */
dev = qdev_create(NULL, "exynos4210.gic");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
/* Map CPU interface */
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);
/* Map Distributer interface */
sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][1]);
}
for (n = 0; n < EXYNOS4210_EXT_GIC_NIRQ; n++) {
s->irqs.ext_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
/* Internal Interrupt Combiner */
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.int_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);
sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);
/* External Interrupt Combiner */
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_prop_set_uint32(dev, "external", 1);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.ext_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);
/* Initialize board IRQs. */
exynos4210_init_board_irqs(&s->irqs);
/*** Memory ***/
/* Chip-ID and OMR */
memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,
NULL, "exynos4210.chipid", sizeof(chipid_and_omr));
memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,
&s->chipid_mem);
/* Internal ROM */
memory_region_init_ram(&s->irom_mem, NULL, "exynos4210.irom",
EXYNOS4210_IROM_SIZE, &error_abort);
vmstate_register_ram_global(&s->irom_mem);
memory_region_set_readonly(&s->irom_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,
&s->irom_mem);
/* mirror of iROM */
memory_region_init_alias(&s->irom_alias_mem, NULL, "exynos4210.irom_alias",
&s->irom_mem,
0,
EXYNOS4210_IROM_SIZE);
memory_region_set_readonly(&s->irom_alias_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,
&s->irom_alias_mem);
/* Internal RAM */
memory_region_init_ram(&s->iram_mem, NULL, "exynos4210.iram",
EXYNOS4210_IRAM_SIZE, &error_abort);
vmstate_register_ram_global(&s->iram_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,
&s->iram_mem);
/* DRAM */
mem_size = ram_size;
if (mem_size > EXYNOS4210_DRAM_MAX_SIZE) {
memory_region_init_ram(&s->dram1_mem, NULL, "exynos4210.dram1",
mem_size - EXYNOS4210_DRAM_MAX_SIZE, &error_abort);
vmstate_register_ram_global(&s->dram1_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,
&s->dram1_mem);
mem_size = EXYNOS4210_DRAM_MAX_SIZE;
}
memory_region_init_ram(&s->dram0_mem, NULL, "exynos4210.dram0", mem_size,
&error_abort);
vmstate_register_ram_global(&s->dram0_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,
&s->dram0_mem);
/* PMU.
* The only reason of existence at the moment is that secondary CPU boot
* loader uses PMU INFORM5 register as a holding pen.
*/
sysbus_create_simple("exynos4210.pmu", EXYNOS4210_PMU_BASE_ADDR, NULL);
/* PWM */
sysbus_create_varargs("exynos4210.pwm", EXYNOS4210_PWM_BASE_ADDR,
s->irq_table[exynos4210_get_irq(22, 0)],
s->irq_table[exynos4210_get_irq(22, 1)],
s->irq_table[exynos4210_get_irq(22, 2)],
s->irq_table[exynos4210_get_irq(22, 3)],
s->irq_table[exynos4210_get_irq(22, 4)],
NULL);
/* RTC */
sysbus_create_varargs("exynos4210.rtc", EXYNOS4210_RTC_BASE_ADDR,
s->irq_table[exynos4210_get_irq(23, 0)],
s->irq_table[exynos4210_get_irq(23, 1)],
NULL);
/* Multi Core Timer */
dev = qdev_create(NULL, "exynos4210.mct");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < 4; n++) {
/* Connect global timer interrupts to Combiner gpio_in */
sysbus_connect_irq(busdev, n,
s->irq_table[exynos4210_get_irq(1, 4 + n)]);
}
/* Connect local timer interrupts to Combiner gpio_in */
sysbus_connect_irq(busdev, 4,
s->irq_table[exynos4210_get_irq(51, 0)]);
sysbus_connect_irq(busdev, 5,
s->irq_table[exynos4210_get_irq(35, 3)]);
sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);
/*** I2C ***/
for (n = 0; n < EXYNOS4210_I2C_NUMBER; n++) {
uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * n;
qemu_irq i2c_irq;
if (n < 8) {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, n)];
} else {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];
}
dev = qdev_create(NULL, "exynos4210.i2c");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, i2c_irq);
sysbus_mmio_map(busdev, 0, addr);
s->i2c_if[n] = (I2CBus *)qdev_get_child_bus(dev, "i2c");
}
/*** UARTs ***/
exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,
EXYNOS4210_UART0_FIFO_SIZE, 0, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);
exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,
EXYNOS4210_UART1_FIFO_SIZE, 1, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);
exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,
EXYNOS4210_UART2_FIFO_SIZE, 2, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);
exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,
EXYNOS4210_UART3_FIFO_SIZE, 3, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);
/*** Display controller (FIMD) ***/
sysbus_create_varargs("exynos4210.fimd", EXYNOS4210_FIMD0_BASE_ADDR,
s->irq_table[exynos4210_get_irq(11, 0)],
s->irq_table[exynos4210_get_irq(11, 1)],
s->irq_table[exynos4210_get_irq(11, 2)],
NULL);
sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
s->irq_table[exynos4210_get_irq(28, 3)]);
return s;
}
| true | qemu | f8ed85ac992c48814d916d5df4d44f9a971c5de4 | Exynos4210State *exynos4210_init(MemoryRegion *system_mem,
unsigned long ram_size)
{
int i, n;
Exynos4210State *s = g_new(Exynos4210State, 1);
qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];
unsigned long mem_size;
DeviceState *dev;
SysBusDevice *busdev;
ObjectClass *cpu_oc;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, "cortex-a9");
assert(cpu_oc);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
Object *cpuobj = object_new(object_class_get_name(cpu_oc));
Error *err = NULL;
if (object_property_find(cpuobj, "has_el3", NULL)) {
object_property_set_bool(cpuobj, false, "has_el3", &err);
if (err) {
error_report_err(err);
exit(1);
}
}
s->cpu[n] = ARM_CPU(cpuobj);
object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,
"reset-cbar", &error_abort);
object_property_set_bool(cpuobj, true, "realized", &err);
if (err) {
error_report_err(err);
exit(1);
}
}
s->irq_table = exynos4210_init_irq(&s->irqs);
for (i = 0; i < EXYNOS4210_NCPUS; i++) {
dev = qdev_create(NULL, "exynos4210.irq_gate");
qdev_prop_set_uint32(dev, "n_in", EXYNOS4210_IRQ_GATE_NINPUTS);
qdev_init_nofail(dev);
for (n = 0; n < EXYNOS4210_IRQ_GATE_NINPUTS; n++) {
gate_irq[i][n] = qdev_get_gpio_in(dev, n);
}
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0,
qdev_get_gpio_in(DEVICE(s->cpu[i]), ARM_CPU_IRQ));
}
dev = qdev_create(NULL, "a9mpcore_priv");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][0]);
}
for (n = 0; n < EXYNOS4210_INT_GIC_NIRQ; n++) {
s->irqs.int_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
sysbus_create_simple("l2x0", EXYNOS4210_L2X0_BASE_ADDR, NULL);
dev = qdev_create(NULL, "exynos4210.gic");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);
sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][1]);
}
for (n = 0; n < EXYNOS4210_EXT_GIC_NIRQ; n++) {
s->irqs.ext_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.int_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);
sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_prop_set_uint32(dev, "external", 1);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.ext_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);
exynos4210_init_board_irqs(&s->irqs);
memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,
NULL, "exynos4210.chipid", sizeof(chipid_and_omr));
memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,
&s->chipid_mem);
memory_region_init_ram(&s->irom_mem, NULL, "exynos4210.irom",
EXYNOS4210_IROM_SIZE, &error_abort);
vmstate_register_ram_global(&s->irom_mem);
memory_region_set_readonly(&s->irom_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,
&s->irom_mem);
memory_region_init_alias(&s->irom_alias_mem, NULL, "exynos4210.irom_alias",
&s->irom_mem,
0,
EXYNOS4210_IROM_SIZE);
memory_region_set_readonly(&s->irom_alias_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,
&s->irom_alias_mem);
memory_region_init_ram(&s->iram_mem, NULL, "exynos4210.iram",
EXYNOS4210_IRAM_SIZE, &error_abort);
vmstate_register_ram_global(&s->iram_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,
&s->iram_mem);
mem_size = ram_size;
if (mem_size > EXYNOS4210_DRAM_MAX_SIZE) {
memory_region_init_ram(&s->dram1_mem, NULL, "exynos4210.dram1",
mem_size - EXYNOS4210_DRAM_MAX_SIZE, &error_abort);
vmstate_register_ram_global(&s->dram1_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,
&s->dram1_mem);
mem_size = EXYNOS4210_DRAM_MAX_SIZE;
}
memory_region_init_ram(&s->dram0_mem, NULL, "exynos4210.dram0", mem_size,
&error_abort);
vmstate_register_ram_global(&s->dram0_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,
&s->dram0_mem);
sysbus_create_simple("exynos4210.pmu", EXYNOS4210_PMU_BASE_ADDR, NULL);
sysbus_create_varargs("exynos4210.pwm", EXYNOS4210_PWM_BASE_ADDR,
s->irq_table[exynos4210_get_irq(22, 0)],
s->irq_table[exynos4210_get_irq(22, 1)],
s->irq_table[exynos4210_get_irq(22, 2)],
s->irq_table[exynos4210_get_irq(22, 3)],
s->irq_table[exynos4210_get_irq(22, 4)],
NULL);
sysbus_create_varargs("exynos4210.rtc", EXYNOS4210_RTC_BASE_ADDR,
s->irq_table[exynos4210_get_irq(23, 0)],
s->irq_table[exynos4210_get_irq(23, 1)],
NULL);
dev = qdev_create(NULL, "exynos4210.mct");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < 4; n++) {
sysbus_connect_irq(busdev, n,
s->irq_table[exynos4210_get_irq(1, 4 + n)]);
}
sysbus_connect_irq(busdev, 4,
s->irq_table[exynos4210_get_irq(51, 0)]);
sysbus_connect_irq(busdev, 5,
s->irq_table[exynos4210_get_irq(35, 3)]);
sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);
for (n = 0; n < EXYNOS4210_I2C_NUMBER; n++) {
uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * n;
qemu_irq i2c_irq;
if (n < 8) {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, n)];
} else {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];
}
dev = qdev_create(NULL, "exynos4210.i2c");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, i2c_irq);
sysbus_mmio_map(busdev, 0, addr);
s->i2c_if[n] = (I2CBus *)qdev_get_child_bus(dev, "i2c");
}
exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,
EXYNOS4210_UART0_FIFO_SIZE, 0, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);
exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,
EXYNOS4210_UART1_FIFO_SIZE, 1, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);
exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,
EXYNOS4210_UART2_FIFO_SIZE, 2, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);
exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,
EXYNOS4210_UART3_FIFO_SIZE, 3, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);
sysbus_create_varargs("exynos4210.fimd", EXYNOS4210_FIMD0_BASE_ADDR,
s->irq_table[exynos4210_get_irq(11, 0)],
s->irq_table[exynos4210_get_irq(11, 1)],
s->irq_table[exynos4210_get_irq(11, 2)],
NULL);
sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
s->irq_table[exynos4210_get_irq(28, 3)]);
return s;
}
| {
"code": [
" EXYNOS4210_IROM_SIZE, &error_abort);",
" EXYNOS4210_IRAM_SIZE, &error_abort);",
" mem_size - EXYNOS4210_DRAM_MAX_SIZE, &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);",
" &error_abort);"
],
"line_no": [
251,
283,
301,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315,
315
]
} | Exynos4210State *FUNC_0(MemoryRegion *system_mem,
unsigned long ram_size)
{
int VAR_0, VAR_1;
Exynos4210State *s = g_new(Exynos4210State, 1);
qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];
unsigned long VAR_2;
DeviceState *dev;
SysBusDevice *busdev;
ObjectClass *cpu_oc;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, "cortex-a9");
assert(cpu_oc);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {
Object *cpuobj = object_new(object_class_get_name(cpu_oc));
Error *err = NULL;
if (object_property_find(cpuobj, "has_el3", NULL)) {
object_property_set_bool(cpuobj, false, "has_el3", &err);
if (err) {
error_report_err(err);
exit(1);
}
}
s->cpu[VAR_1] = ARM_CPU(cpuobj);
object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,
"reset-cbar", &error_abort);
object_property_set_bool(cpuobj, true, "realized", &err);
if (err) {
error_report_err(err);
exit(1);
}
}
s->irq_table = exynos4210_init_irq(&s->irqs);
for (VAR_0 = 0; VAR_0 < EXYNOS4210_NCPUS; VAR_0++) {
dev = qdev_create(NULL, "exynos4210.irq_gate");
qdev_prop_set_uint32(dev, "n_in", EXYNOS4210_IRQ_GATE_NINPUTS);
qdev_init_nofail(dev);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_IRQ_GATE_NINPUTS; VAR_1++) {
gate_irq[VAR_0][VAR_1] = qdev_get_gpio_in(dev, VAR_1);
}
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0,
qdev_get_gpio_in(DEVICE(s->cpu[VAR_0]), ARM_CPU_IRQ));
}
dev = qdev_create(NULL, "a9mpcore_priv");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][0]);
}
for (VAR_1 = 0; VAR_1 < EXYNOS4210_INT_GIC_NIRQ; VAR_1++) {
s->irqs.int_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);
}
sysbus_create_simple("l2x0", EXYNOS4210_L2X0_BASE_ADDR, NULL);
dev = qdev_create(NULL, "exynos4210.gic");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);
sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][1]);
}
for (VAR_1 = 0; VAR_1 < EXYNOS4210_EXT_GIC_NIRQ; VAR_1++) {
s->irqs.ext_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);
}
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, s->irqs.int_gic_irq[VAR_1]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);
sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_prop_set_uint32(dev, "external", 1);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, s->irqs.ext_gic_irq[VAR_1]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);
exynos4210_init_board_irqs(&s->irqs);
memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,
NULL, "exynos4210.chipid", sizeof(chipid_and_omr));
memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,
&s->chipid_mem);
memory_region_init_ram(&s->irom_mem, NULL, "exynos4210.irom",
EXYNOS4210_IROM_SIZE, &error_abort);
vmstate_register_ram_global(&s->irom_mem);
memory_region_set_readonly(&s->irom_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,
&s->irom_mem);
memory_region_init_alias(&s->irom_alias_mem, NULL, "exynos4210.irom_alias",
&s->irom_mem,
0,
EXYNOS4210_IROM_SIZE);
memory_region_set_readonly(&s->irom_alias_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,
&s->irom_alias_mem);
memory_region_init_ram(&s->iram_mem, NULL, "exynos4210.iram",
EXYNOS4210_IRAM_SIZE, &error_abort);
vmstate_register_ram_global(&s->iram_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,
&s->iram_mem);
VAR_2 = ram_size;
if (VAR_2 > EXYNOS4210_DRAM_MAX_SIZE) {
memory_region_init_ram(&s->dram1_mem, NULL, "exynos4210.dram1",
VAR_2 - EXYNOS4210_DRAM_MAX_SIZE, &error_abort);
vmstate_register_ram_global(&s->dram1_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,
&s->dram1_mem);
VAR_2 = EXYNOS4210_DRAM_MAX_SIZE;
}
memory_region_init_ram(&s->dram0_mem, NULL, "exynos4210.dram0", VAR_2,
&error_abort);
vmstate_register_ram_global(&s->dram0_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,
&s->dram0_mem);
sysbus_create_simple("exynos4210.pmu", EXYNOS4210_PMU_BASE_ADDR, NULL);
sysbus_create_varargs("exynos4210.pwm", EXYNOS4210_PWM_BASE_ADDR,
s->irq_table[exynos4210_get_irq(22, 0)],
s->irq_table[exynos4210_get_irq(22, 1)],
s->irq_table[exynos4210_get_irq(22, 2)],
s->irq_table[exynos4210_get_irq(22, 3)],
s->irq_table[exynos4210_get_irq(22, 4)],
NULL);
sysbus_create_varargs("exynos4210.rtc", EXYNOS4210_RTC_BASE_ADDR,
s->irq_table[exynos4210_get_irq(23, 0)],
s->irq_table[exynos4210_get_irq(23, 1)],
NULL);
dev = qdev_create(NULL, "exynos4210.mct");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1,
s->irq_table[exynos4210_get_irq(1, 4 + VAR_1)]);
}
sysbus_connect_irq(busdev, 4,
s->irq_table[exynos4210_get_irq(51, 0)]);
sysbus_connect_irq(busdev, 5,
s->irq_table[exynos4210_get_irq(35, 3)]);
sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_I2C_NUMBER; VAR_1++) {
uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * VAR_1;
qemu_irq i2c_irq;
if (VAR_1 < 8) {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, VAR_1)];
} else {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];
}
dev = qdev_create(NULL, "exynos4210.i2c");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, i2c_irq);
sysbus_mmio_map(busdev, 0, addr);
s->i2c_if[VAR_1] = (I2CBus *)qdev_get_child_bus(dev, "i2c");
}
exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,
EXYNOS4210_UART0_FIFO_SIZE, 0, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);
exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,
EXYNOS4210_UART1_FIFO_SIZE, 1, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);
exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,
EXYNOS4210_UART2_FIFO_SIZE, 2, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);
exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,
EXYNOS4210_UART3_FIFO_SIZE, 3, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);
sysbus_create_varargs("exynos4210.fimd", EXYNOS4210_FIMD0_BASE_ADDR,
s->irq_table[exynos4210_get_irq(11, 0)],
s->irq_table[exynos4210_get_irq(11, 1)],
s->irq_table[exynos4210_get_irq(11, 2)],
NULL);
sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
s->irq_table[exynos4210_get_irq(28, 3)]);
return s;
}
| [
"Exynos4210State *FUNC_0(MemoryRegion *system_mem,\nunsigned long ram_size)\n{",
"int VAR_0, VAR_1;",
"Exynos4210State *s = g_new(Exynos4210State, 1);",
"qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];",
"unsigned long VAR_2;",
"DeviceState *dev;",
"SysBusDevice *busdev;",
"ObjectClass *cpu_oc;",
"cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, \"cortex-a9\");",
"assert(cpu_oc);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {",
"Object *cpuobj = object_new(object_class_get_name(cpu_oc));",
"Error *err = NULL;",
"if (object_property_find(cpuobj, \"has_el3\", NULL)) {",
"object_property_set_bool(cpuobj, false, \"has_el3\", &err);",
"if (err) {",
"error_report_err(err);",
"exit(1);",
"}",
"}",
"s->cpu[VAR_1] = ARM_CPU(cpuobj);",
"object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,\n\"reset-cbar\", &error_abort);",
"object_property_set_bool(cpuobj, true, \"realized\", &err);",
"if (err) {",
"error_report_err(err);",
"exit(1);",
"}",
"}",
"s->irq_table = exynos4210_init_irq(&s->irqs);",
"for (VAR_0 = 0; VAR_0 < EXYNOS4210_NCPUS; VAR_0++) {",
"dev = qdev_create(NULL, \"exynos4210.irq_gate\");",
"qdev_prop_set_uint32(dev, \"n_in\", EXYNOS4210_IRQ_GATE_NINPUTS);",
"qdev_init_nofail(dev);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_IRQ_GATE_NINPUTS; VAR_1++) {",
"gate_irq[VAR_0][VAR_1] = qdev_get_gpio_in(dev, VAR_1);",
"}",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_connect_irq(busdev, 0,\nqdev_get_gpio_in(DEVICE(s->cpu[VAR_0]), ARM_CPU_IRQ));",
"}",
"dev = qdev_create(NULL, \"a9mpcore_priv\");",
"qdev_prop_set_uint32(dev, \"num-cpu\", EXYNOS4210_NCPUS);",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][0]);",
"}",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_INT_GIC_NIRQ; VAR_1++) {",
"s->irqs.int_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);",
"}",
"sysbus_create_simple(\"l2x0\", EXYNOS4210_L2X0_BASE_ADDR, NULL);",
"dev = qdev_create(NULL, \"exynos4210.gic\");",
"qdev_prop_set_uint32(dev, \"num-cpu\", EXYNOS4210_NCPUS);",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);",
"sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][1]);",
"}",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_EXT_GIC_NIRQ; VAR_1++) {",
"s->irqs.ext_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);",
"}",
"dev = qdev_create(NULL, \"exynos4210.combiner\");",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, s->irqs.int_gic_irq[VAR_1]);",
"}",
"exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);",
"dev = qdev_create(NULL, \"exynos4210.combiner\");",
"qdev_prop_set_uint32(dev, \"external\", 1);",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, s->irqs.ext_gic_irq[VAR_1]);",
"}",
"exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);",
"exynos4210_init_board_irqs(&s->irqs);",
"memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,\nNULL, \"exynos4210.chipid\", sizeof(chipid_and_omr));",
"memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,\n&s->chipid_mem);",
"memory_region_init_ram(&s->irom_mem, NULL, \"exynos4210.irom\",\nEXYNOS4210_IROM_SIZE, &error_abort);",
"vmstate_register_ram_global(&s->irom_mem);",
"memory_region_set_readonly(&s->irom_mem, true);",
"memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,\n&s->irom_mem);",
"memory_region_init_alias(&s->irom_alias_mem, NULL, \"exynos4210.irom_alias\",\n&s->irom_mem,\n0,\nEXYNOS4210_IROM_SIZE);",
"memory_region_set_readonly(&s->irom_alias_mem, true);",
"memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,\n&s->irom_alias_mem);",
"memory_region_init_ram(&s->iram_mem, NULL, \"exynos4210.iram\",\nEXYNOS4210_IRAM_SIZE, &error_abort);",
"vmstate_register_ram_global(&s->iram_mem);",
"memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,\n&s->iram_mem);",
"VAR_2 = ram_size;",
"if (VAR_2 > EXYNOS4210_DRAM_MAX_SIZE) {",
"memory_region_init_ram(&s->dram1_mem, NULL, \"exynos4210.dram1\",\nVAR_2 - EXYNOS4210_DRAM_MAX_SIZE, &error_abort);",
"vmstate_register_ram_global(&s->dram1_mem);",
"memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,\n&s->dram1_mem);",
"VAR_2 = EXYNOS4210_DRAM_MAX_SIZE;",
"}",
"memory_region_init_ram(&s->dram0_mem, NULL, \"exynos4210.dram0\", VAR_2,\n&error_abort);",
"vmstate_register_ram_global(&s->dram0_mem);",
"memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,\n&s->dram0_mem);",
"sysbus_create_simple(\"exynos4210.pmu\", EXYNOS4210_PMU_BASE_ADDR, NULL);",
"sysbus_create_varargs(\"exynos4210.pwm\", EXYNOS4210_PWM_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(22, 0)],\ns->irq_table[exynos4210_get_irq(22, 1)],\ns->irq_table[exynos4210_get_irq(22, 2)],\ns->irq_table[exynos4210_get_irq(22, 3)],\ns->irq_table[exynos4210_get_irq(22, 4)],\nNULL);",
"sysbus_create_varargs(\"exynos4210.rtc\", EXYNOS4210_RTC_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(23, 0)],\ns->irq_table[exynos4210_get_irq(23, 1)],\nNULL);",
"dev = qdev_create(NULL, \"exynos4210.mct\");",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1,\ns->irq_table[exynos4210_get_irq(1, 4 + VAR_1)]);",
"}",
"sysbus_connect_irq(busdev, 4,\ns->irq_table[exynos4210_get_irq(51, 0)]);",
"sysbus_connect_irq(busdev, 5,\ns->irq_table[exynos4210_get_irq(35, 3)]);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_I2C_NUMBER; VAR_1++) {",
"uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * VAR_1;",
"qemu_irq i2c_irq;",
"if (VAR_1 < 8) {",
"i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, VAR_1)];",
"} else {",
"i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];",
"}",
"dev = qdev_create(NULL, \"exynos4210.i2c\");",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_connect_irq(busdev, 0, i2c_irq);",
"sysbus_mmio_map(busdev, 0, addr);",
"s->i2c_if[VAR_1] = (I2CBus *)qdev_get_child_bus(dev, \"i2c\");",
"}",
"exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,\nEXYNOS4210_UART0_FIFO_SIZE, 0, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);",
"exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,\nEXYNOS4210_UART1_FIFO_SIZE, 1, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);",
"exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,\nEXYNOS4210_UART2_FIFO_SIZE, 2, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);",
"exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,\nEXYNOS4210_UART3_FIFO_SIZE, 3, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);",
"sysbus_create_varargs(\"exynos4210.fimd\", EXYNOS4210_FIMD0_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(11, 0)],\ns->irq_table[exynos4210_get_irq(11, 1)],\ns->irq_table[exynos4210_get_irq(11, 2)],\nNULL);",
"sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(28, 3)]);",
"return 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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
83
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105
],
[
111,
113
],
[
115
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
147
],
[
153
],
[
155
],
[
157
],
[
159
],
[
163
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
227
],
[
237,
239
],
[
241,
243
],
[
249,
251
],
[
253
],
[
255
],
[
257,
259
],
[
263,
265,
267,
269
],
[
271
],
[
273,
275
],
[
281,
283
],
[
285
],
[
287,
289
],
[
295
],
[
297
],
[
299,
301
],
[
303
],
[
305,
307
],
[
309
],
[
311
],
[
313,
315
],
[
317
],
[
319,
321
],
[
333
],
[
339,
341,
343,
345,
347,
349,
351
],
[
355,
357,
359,
361
],
[
367
],
[
369
],
[
371
],
[
373
],
[
377,
379
],
[
381
],
[
385,
387
],
[
389,
391
],
[
393
],
[
399
],
[
401
],
[
403
],
[
407
],
[
409
],
[
411
],
[
413
],
[
415
],
[
419
],
[
421
],
[
423
],
[
425
],
[
427
],
[
429
],
[
431
],
[
439,
441,
443
],
[
447,
449,
451
],
[
455,
457,
459
],
[
463,
465,
467
],
[
473,
475,
477,
479,
481
],
[
485,
487
],
[
491
],
[
493
]
] |
20,615 | void ff_put_h264_qpel8_mc22_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_mid_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8);
}
| false | FFmpeg | e549933a270dd2cfc36f2cf9bb6b29acf3dc6d08 | void ff_put_h264_qpel8_mc22_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_mid_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,
ptrdiff_t VAR_2)
{
avc_luma_mid_8w_msa(VAR_1 - (2 * VAR_2) - 2, VAR_2, VAR_0, VAR_2, 8);
}
| [
"void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{",
"avc_luma_mid_8w_msa(VAR_1 - (2 * VAR_2) - 2, VAR_2, VAR_0, VAR_2, 8);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
]
] |
20,616 | static int fbdev_write_packet(AVFormatContext *h, AVPacket *pkt)
{
FBDevContext *fbdev = h->priv_data;
uint8_t *pin, *pout;
enum AVPixelFormat fb_pix_fmt;
int disp_height;
int bytes_to_copy;
AVCodecContext *codec_ctx = h->streams[fbdev->index]->codec;
enum AVPixelFormat video_pix_fmt = codec_ctx->pix_fmt;
int video_width = codec_ctx->width;
int video_height = codec_ctx->height;
int bytes_per_pixel = ((codec_ctx->bits_per_coded_sample + 7) >> 3);
int src_line_size = video_width * bytes_per_pixel;
int i;
if (fbdev->index != pkt->stream_index)
return 0;
if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0)
av_log(h, AV_LOG_WARNING,
"Error refreshing variable info: %s\n", av_err2str(AVERROR(errno)));
fb_pix_fmt = ff_get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
if (fb_pix_fmt != video_pix_fmt) {
av_log(h, AV_LOG_ERROR, "Pixel format %s is not supported, use %s\n",
av_get_pix_fmt_name(video_pix_fmt), av_get_pix_fmt_name(fb_pix_fmt));
return AVERROR(EINVAL);
}
disp_height = FFMIN(fbdev->varinfo.yres, video_height);
bytes_to_copy = FFMIN(fbdev->varinfo.xres, video_width) * bytes_per_pixel;
pin = pkt->data;
pout = fbdev->data +
bytes_per_pixel * fbdev->varinfo.xoffset +
fbdev->varinfo.yoffset * fbdev->fixinfo.line_length;
if (fbdev->xoffset) {
if (fbdev->xoffset < 0) {
if (-fbdev->xoffset >= video_width) //nothing to display
return 0;
bytes_to_copy += fbdev->xoffset * bytes_per_pixel;
pin -= fbdev->xoffset * bytes_per_pixel;
} else {
int diff = (video_width + fbdev->xoffset) - fbdev->varinfo.xres;
if (diff > 0) {
if (diff >= video_width) //nothing to display
return 0;
bytes_to_copy -= diff * bytes_per_pixel;
}
pout += bytes_per_pixel * fbdev->xoffset;
}
}
if (fbdev->yoffset) {
if (fbdev->yoffset < 0) {
if (-fbdev->yoffset >= video_height) //nothing to display
return 0;
disp_height += fbdev->yoffset;
pin -= fbdev->yoffset * src_line_size;
} else {
int diff = (video_height + fbdev->yoffset) - fbdev->varinfo.yres;
if (diff > 0) {
if (diff >= video_height) //nothing to display
return 0;
disp_height -= diff;
}
pout += fbdev->yoffset * fbdev->fixinfo.line_length;
}
}
for (i = 0; i < disp_height; i++) {
memcpy(pout, pin, bytes_to_copy);
pout += fbdev->fixinfo.line_length;
pin += src_line_size;
}
return 0;
}
| false | FFmpeg | b04af34600d01502ac844551d157d83f7ae5db26 | static int fbdev_write_packet(AVFormatContext *h, AVPacket *pkt)
{
FBDevContext *fbdev = h->priv_data;
uint8_t *pin, *pout;
enum AVPixelFormat fb_pix_fmt;
int disp_height;
int bytes_to_copy;
AVCodecContext *codec_ctx = h->streams[fbdev->index]->codec;
enum AVPixelFormat video_pix_fmt = codec_ctx->pix_fmt;
int video_width = codec_ctx->width;
int video_height = codec_ctx->height;
int bytes_per_pixel = ((codec_ctx->bits_per_coded_sample + 7) >> 3);
int src_line_size = video_width * bytes_per_pixel;
int i;
if (fbdev->index != pkt->stream_index)
return 0;
if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0)
av_log(h, AV_LOG_WARNING,
"Error refreshing variable info: %s\n", av_err2str(AVERROR(errno)));
fb_pix_fmt = ff_get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
if (fb_pix_fmt != video_pix_fmt) {
av_log(h, AV_LOG_ERROR, "Pixel format %s is not supported, use %s\n",
av_get_pix_fmt_name(video_pix_fmt), av_get_pix_fmt_name(fb_pix_fmt));
return AVERROR(EINVAL);
}
disp_height = FFMIN(fbdev->varinfo.yres, video_height);
bytes_to_copy = FFMIN(fbdev->varinfo.xres, video_width) * bytes_per_pixel;
pin = pkt->data;
pout = fbdev->data +
bytes_per_pixel * fbdev->varinfo.xoffset +
fbdev->varinfo.yoffset * fbdev->fixinfo.line_length;
if (fbdev->xoffset) {
if (fbdev->xoffset < 0) {
if (-fbdev->xoffset >= video_width)
return 0;
bytes_to_copy += fbdev->xoffset * bytes_per_pixel;
pin -= fbdev->xoffset * bytes_per_pixel;
} else {
int diff = (video_width + fbdev->xoffset) - fbdev->varinfo.xres;
if (diff > 0) {
if (diff >= video_width)
return 0;
bytes_to_copy -= diff * bytes_per_pixel;
}
pout += bytes_per_pixel * fbdev->xoffset;
}
}
if (fbdev->yoffset) {
if (fbdev->yoffset < 0) {
if (-fbdev->yoffset >= video_height)
return 0;
disp_height += fbdev->yoffset;
pin -= fbdev->yoffset * src_line_size;
} else {
int diff = (video_height + fbdev->yoffset) - fbdev->varinfo.yres;
if (diff > 0) {
if (diff >= video_height)
return 0;
disp_height -= diff;
}
pout += fbdev->yoffset * fbdev->fixinfo.line_length;
}
}
for (i = 0; i < disp_height; i++) {
memcpy(pout, pin, bytes_to_copy);
pout += fbdev->fixinfo.line_length;
pin += src_line_size;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
FBDevContext *fbdev = VAR_0->priv_data;
uint8_t *pin, *pout;
enum AVPixelFormat VAR_2;
int VAR_3;
int VAR_4;
AVCodecContext *codec_ctx = VAR_0->streams[fbdev->index]->codec;
enum AVPixelFormat VAR_5 = codec_ctx->pix_fmt;
int VAR_6 = codec_ctx->width;
int VAR_7 = codec_ctx->height;
int VAR_8 = ((codec_ctx->bits_per_coded_sample + 7) >> 3);
int VAR_9 = VAR_6 * VAR_8;
int VAR_10;
if (fbdev->index != VAR_1->stream_index)
return 0;
if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0)
av_log(VAR_0, AV_LOG_WARNING,
"Error refreshing variable info: %s\n", av_err2str(AVERROR(errno)));
VAR_2 = ff_get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
if (VAR_2 != VAR_5) {
av_log(VAR_0, AV_LOG_ERROR, "Pixel format %s is not supported, use %s\n",
av_get_pix_fmt_name(VAR_5), av_get_pix_fmt_name(VAR_2));
return AVERROR(EINVAL);
}
VAR_3 = FFMIN(fbdev->varinfo.yres, VAR_7);
VAR_4 = FFMIN(fbdev->varinfo.xres, VAR_6) * VAR_8;
pin = VAR_1->data;
pout = fbdev->data +
VAR_8 * fbdev->varinfo.xoffset +
fbdev->varinfo.yoffset * fbdev->fixinfo.line_length;
if (fbdev->xoffset) {
if (fbdev->xoffset < 0) {
if (-fbdev->xoffset >= VAR_6)
return 0;
VAR_4 += fbdev->xoffset * VAR_8;
pin -= fbdev->xoffset * VAR_8;
} else {
int VAR_12 = (VAR_6 + fbdev->xoffset) - fbdev->varinfo.xres;
if (VAR_12 > 0) {
if (VAR_12 >= VAR_6)
return 0;
VAR_4 -= VAR_12 * VAR_8;
}
pout += VAR_8 * fbdev->xoffset;
}
}
if (fbdev->yoffset) {
if (fbdev->yoffset < 0) {
if (-fbdev->yoffset >= VAR_7)
return 0;
VAR_3 += fbdev->yoffset;
pin -= fbdev->yoffset * VAR_9;
} else {
int VAR_12 = (VAR_7 + fbdev->yoffset) - fbdev->varinfo.yres;
if (VAR_12 > 0) {
if (VAR_12 >= VAR_7)
return 0;
VAR_3 -= VAR_12;
}
pout += fbdev->yoffset * fbdev->fixinfo.line_length;
}
}
for (VAR_10 = 0; VAR_10 < VAR_3; VAR_10++) {
memcpy(pout, pin, VAR_4);
pout += fbdev->fixinfo.line_length;
pin += VAR_9;
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"FBDevContext *fbdev = VAR_0->priv_data;",
"uint8_t *pin, *pout;",
"enum AVPixelFormat VAR_2;",
"int VAR_3;",
"int VAR_4;",
"AVCodecContext *codec_ctx = VAR_0->streams[fbdev->index]->codec;",
"enum AVPixelFormat VAR_5 = codec_ctx->pix_fmt;",
"int VAR_6 = codec_ctx->width;",
"int VAR_7 = codec_ctx->height;",
"int VAR_8 = ((codec_ctx->bits_per_coded_sample + 7) >> 3);",
"int VAR_9 = VAR_6 * VAR_8;",
"int VAR_10;",
"if (fbdev->index != VAR_1->stream_index)\nreturn 0;",
"if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0)\nav_log(VAR_0, AV_LOG_WARNING,\n\"Error refreshing variable info: %s\\n\", av_err2str(AVERROR(errno)));",
"VAR_2 = ff_get_pixfmt_from_fb_varinfo(&fbdev->varinfo);",
"if (VAR_2 != VAR_5) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Pixel format %s is not supported, use %s\\n\",\nav_get_pix_fmt_name(VAR_5), av_get_pix_fmt_name(VAR_2));",
"return AVERROR(EINVAL);",
"}",
"VAR_3 = FFMIN(fbdev->varinfo.yres, VAR_7);",
"VAR_4 = FFMIN(fbdev->varinfo.xres, VAR_6) * VAR_8;",
"pin = VAR_1->data;",
"pout = fbdev->data +\nVAR_8 * fbdev->varinfo.xoffset +\nfbdev->varinfo.yoffset * fbdev->fixinfo.line_length;",
"if (fbdev->xoffset) {",
"if (fbdev->xoffset < 0) {",
"if (-fbdev->xoffset >= VAR_6)\nreturn 0;",
"VAR_4 += fbdev->xoffset * VAR_8;",
"pin -= fbdev->xoffset * VAR_8;",
"} else {",
"int VAR_12 = (VAR_6 + fbdev->xoffset) - fbdev->varinfo.xres;",
"if (VAR_12 > 0) {",
"if (VAR_12 >= VAR_6)\nreturn 0;",
"VAR_4 -= VAR_12 * VAR_8;",
"}",
"pout += VAR_8 * fbdev->xoffset;",
"}",
"}",
"if (fbdev->yoffset) {",
"if (fbdev->yoffset < 0) {",
"if (-fbdev->yoffset >= VAR_7)\nreturn 0;",
"VAR_3 += fbdev->yoffset;",
"pin -= fbdev->yoffset * VAR_9;",
"} else {",
"int VAR_12 = (VAR_7 + fbdev->yoffset) - fbdev->varinfo.yres;",
"if (VAR_12 > 0) {",
"if (VAR_12 >= VAR_7)\nreturn 0;",
"VAR_3 -= VAR_12;",
"}",
"pout += fbdev->yoffset * fbdev->fixinfo.line_length;",
"}",
"}",
"for (VAR_10 = 0; VAR_10 < VAR_3; VAR_10++) {",
"memcpy(pout, pin, VAR_4);",
"pout += fbdev->fixinfo.line_length;",
"pin += VAR_9;",
"}",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31,
33
],
[
37,
39,
41
],
[
45
],
[
49
],
[
51,
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
67
],
[
69,
71,
73
],
[
77
],
[
79
],
[
81,
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95,
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129,
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159
]
] |
20,619 | static void mxf_read_pixel_layout(ByteIOContext *pb, MXFDescriptor *descriptor)
{
int code, value, ofs = 0;
char layout[16] = {};
do {
code = get_byte(pb);
value = get_byte(pb);
dprintf(NULL, "pixel layout: code %#x\n", code);
if (ofs < 16) {
layout[ofs++] = code;
layout[ofs++] = value;
}
} while (code != 0); /* SMPTE 377M E.2.46 */
ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
}
| false | FFmpeg | 354b757300186ed7a7e36682e8faf5cdc4ad63c1 | static void mxf_read_pixel_layout(ByteIOContext *pb, MXFDescriptor *descriptor)
{
int code, value, ofs = 0;
char layout[16] = {};
do {
code = get_byte(pb);
value = get_byte(pb);
dprintf(NULL, "pixel layout: code %#x\n", code);
if (ofs < 16) {
layout[ofs++] = code;
layout[ofs++] = value;
}
} while (code != 0);
ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ByteIOContext *VAR_0, MXFDescriptor *VAR_1)
{
int VAR_2, VAR_3, VAR_4 = 0;
char VAR_5[16] = {};
do {
VAR_2 = get_byte(VAR_0);
VAR_3 = get_byte(VAR_0);
dprintf(NULL, "pixel VAR_5: VAR_2 %#x\n", VAR_2);
if (VAR_4 < 16) {
VAR_5[VAR_4++] = VAR_2;
VAR_5[VAR_4++] = VAR_3;
}
} while (VAR_2 != 0);
ff_mxf_decode_pixel_layout(VAR_5, &VAR_1->pix_fmt);
}
| [
"static void FUNC_0(ByteIOContext *VAR_0, MXFDescriptor *VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4 = 0;",
"char VAR_5[16] = {};",
"do {",
"VAR_2 = get_byte(VAR_0);",
"VAR_3 = get_byte(VAR_0);",
"dprintf(NULL, \"pixel VAR_5: VAR_2 %#x\\n\", VAR_2);",
"if (VAR_4 < 16) {",
"VAR_5[VAR_4++] = VAR_2;",
"VAR_5[VAR_4++] = VAR_3;",
"}",
"} while (VAR_2 != 0);",
"ff_mxf_decode_pixel_layout(VAR_5, &VAR_1->pix_fmt);",
"}"
] | [
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
],
[
27
],
[
29
],
[
33
],
[
35
]
] |
20,621 | static int xmv_read_header(AVFormatContext *s)
{
XMVDemuxContext *xmv = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *vst = NULL;
uint32_t file_version;
uint32_t this_packet_size;
uint16_t audio_track;
int ret;
avio_skip(pb, 4); /* Next packet size */
this_packet_size = avio_rl32(pb);
avio_skip(pb, 4); /* Max packet size */
avio_skip(pb, 4); /* "xobX" */
file_version = avio_rl32(pb);
if ((file_version != 4) && (file_version != 2))
avpriv_request_sample(s, "Uncommon version %d", file_version);
/* Video track */
vst = avformat_new_stream(s, NULL);
if (!vst)
return AVERROR(ENOMEM);
avpriv_set_pts_info(vst, 32, 1, 1000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_WMV2;
vst->codec->codec_tag = MKBETAG('W', 'M', 'V', '2');
vst->codec->width = avio_rl32(pb);
vst->codec->height = avio_rl32(pb);
vst->duration = avio_rl32(pb);
xmv->video.stream_index = vst->index;
/* Audio tracks */
xmv->audio_track_count = avio_rl16(pb);
avio_skip(pb, 2); /* Unknown (padding?) */
xmv->audio_tracks = av_malloc(xmv->audio_track_count * sizeof(XMVAudioTrack));
if (!xmv->audio_tracks)
return AVERROR(ENOMEM);
xmv->audio = av_malloc(xmv->audio_track_count * sizeof(XMVAudioPacket));
if (!xmv->audio)
return AVERROR(ENOMEM);
for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
XMVAudioTrack *track = &xmv->audio_tracks[audio_track];
XMVAudioPacket *packet = &xmv->audio [audio_track];
AVStream *ast = NULL;
track->compression = avio_rl16(pb);
track->channels = avio_rl16(pb);
track->sample_rate = avio_rl32(pb);
track->bits_per_sample = avio_rl16(pb);
track->flags = avio_rl16(pb);
track->bit_rate = track->bits_per_sample *
track->sample_rate *
track->channels;
track->block_align = 36 * track->channels;
track->block_samples = 64;
track->codec_id = ff_wav_codec_get_id(track->compression,
track->bits_per_sample);
packet->track = track;
packet->stream_index = -1;
packet->frame_size = 0;
packet->block_count = 0;
/* TODO: ADPCM'd 5.1 sound is encoded in three separate streams.
* Those need to be interleaved to a proper 5.1 stream. */
if (track->flags & XMV_AUDIO_ADPCM51)
av_log(s, AV_LOG_WARNING, "Unsupported 5.1 ADPCM audio stream "
"(0x%04X)\n", track->flags);
if (!track->channels || !track->sample_rate) {
av_log(s, AV_LOG_ERROR, "Invalid parameters for audio track %d.\n",
audio_track);
ret = AVERROR_INVALIDDATA;
goto fail;
}
ast = avformat_new_stream(s, NULL);
if (!ast)
return AVERROR(ENOMEM);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = track->codec_id;
ast->codec->codec_tag = track->compression;
ast->codec->channels = track->channels;
ast->codec->sample_rate = track->sample_rate;
ast->codec->bits_per_coded_sample = track->bits_per_sample;
ast->codec->bit_rate = track->bit_rate;
ast->codec->block_align = 36 * track->channels;
avpriv_set_pts_info(ast, 32, track->block_samples, track->sample_rate);
packet->stream_index = ast->index;
ast->duration = vst->duration;
}
/** Initialize the packet context */
xmv->next_packet_offset = avio_tell(pb);
xmv->next_packet_size = this_packet_size - xmv->next_packet_offset;
xmv->stream_count = xmv->audio_track_count + 1;
return 0;
fail:
xmv_read_close(s);
return ret;
}
| true | FFmpeg | f8080bd13b5f7fc48204b17fa59a5ce9feb15f07 | static int xmv_read_header(AVFormatContext *s)
{
XMVDemuxContext *xmv = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *vst = NULL;
uint32_t file_version;
uint32_t this_packet_size;
uint16_t audio_track;
int ret;
avio_skip(pb, 4);
this_packet_size = avio_rl32(pb);
avio_skip(pb, 4);
avio_skip(pb, 4);
file_version = avio_rl32(pb);
if ((file_version != 4) && (file_version != 2))
avpriv_request_sample(s, "Uncommon version %d", file_version);
vst = avformat_new_stream(s, NULL);
if (!vst)
return AVERROR(ENOMEM);
avpriv_set_pts_info(vst, 32, 1, 1000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_WMV2;
vst->codec->codec_tag = MKBETAG('W', 'M', 'V', '2');
vst->codec->width = avio_rl32(pb);
vst->codec->height = avio_rl32(pb);
vst->duration = avio_rl32(pb);
xmv->video.stream_index = vst->index;
xmv->audio_track_count = avio_rl16(pb);
avio_skip(pb, 2);
xmv->audio_tracks = av_malloc(xmv->audio_track_count * sizeof(XMVAudioTrack));
if (!xmv->audio_tracks)
return AVERROR(ENOMEM);
xmv->audio = av_malloc(xmv->audio_track_count * sizeof(XMVAudioPacket));
if (!xmv->audio)
return AVERROR(ENOMEM);
for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
XMVAudioTrack *track = &xmv->audio_tracks[audio_track];
XMVAudioPacket *packet = &xmv->audio [audio_track];
AVStream *ast = NULL;
track->compression = avio_rl16(pb);
track->channels = avio_rl16(pb);
track->sample_rate = avio_rl32(pb);
track->bits_per_sample = avio_rl16(pb);
track->flags = avio_rl16(pb);
track->bit_rate = track->bits_per_sample *
track->sample_rate *
track->channels;
track->block_align = 36 * track->channels;
track->block_samples = 64;
track->codec_id = ff_wav_codec_get_id(track->compression,
track->bits_per_sample);
packet->track = track;
packet->stream_index = -1;
packet->frame_size = 0;
packet->block_count = 0;
if (track->flags & XMV_AUDIO_ADPCM51)
av_log(s, AV_LOG_WARNING, "Unsupported 5.1 ADPCM audio stream "
"(0x%04X)\n", track->flags);
if (!track->channels || !track->sample_rate) {
av_log(s, AV_LOG_ERROR, "Invalid parameters for audio track %d.\n",
audio_track);
ret = AVERROR_INVALIDDATA;
goto fail;
}
ast = avformat_new_stream(s, NULL);
if (!ast)
return AVERROR(ENOMEM);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = track->codec_id;
ast->codec->codec_tag = track->compression;
ast->codec->channels = track->channels;
ast->codec->sample_rate = track->sample_rate;
ast->codec->bits_per_coded_sample = track->bits_per_sample;
ast->codec->bit_rate = track->bit_rate;
ast->codec->block_align = 36 * track->channels;
avpriv_set_pts_info(ast, 32, track->block_samples, track->sample_rate);
packet->stream_index = ast->index;
ast->duration = vst->duration;
}
xmv->next_packet_offset = avio_tell(pb);
xmv->next_packet_size = this_packet_size - xmv->next_packet_offset;
xmv->stream_count = xmv->audio_track_count + 1;
return 0;
fail:
xmv_read_close(s);
return ret;
}
| {
"code": [
" if (!xmv->audio)",
" return AVERROR(ENOMEM);",
" if (!ast)",
" return AVERROR(ENOMEM);"
],
"line_no": [
105,
55,
189,
191
]
} | static int FUNC_0(AVFormatContext *VAR_0)
{
XMVDemuxContext *xmv = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
AVStream *vst = NULL;
uint32_t file_version;
uint32_t this_packet_size;
uint16_t audio_track;
int VAR_1;
avio_skip(pb, 4);
this_packet_size = avio_rl32(pb);
avio_skip(pb, 4);
avio_skip(pb, 4);
file_version = avio_rl32(pb);
if ((file_version != 4) && (file_version != 2))
avpriv_request_sample(VAR_0, "Uncommon version %d", file_version);
vst = avformat_new_stream(VAR_0, NULL);
if (!vst)
return AVERROR(ENOMEM);
avpriv_set_pts_info(vst, 32, 1, 1000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_WMV2;
vst->codec->codec_tag = MKBETAG('W', 'M', 'V', '2');
vst->codec->width = avio_rl32(pb);
vst->codec->height = avio_rl32(pb);
vst->duration = avio_rl32(pb);
xmv->video.stream_index = vst->index;
xmv->audio_track_count = avio_rl16(pb);
avio_skip(pb, 2);
xmv->audio_tracks = av_malloc(xmv->audio_track_count * sizeof(XMVAudioTrack));
if (!xmv->audio_tracks)
return AVERROR(ENOMEM);
xmv->audio = av_malloc(xmv->audio_track_count * sizeof(XMVAudioPacket));
if (!xmv->audio)
return AVERROR(ENOMEM);
for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
XMVAudioTrack *track = &xmv->audio_tracks[audio_track];
XMVAudioPacket *packet = &xmv->audio [audio_track];
AVStream *ast = NULL;
track->compression = avio_rl16(pb);
track->channels = avio_rl16(pb);
track->sample_rate = avio_rl32(pb);
track->bits_per_sample = avio_rl16(pb);
track->flags = avio_rl16(pb);
track->bit_rate = track->bits_per_sample *
track->sample_rate *
track->channels;
track->block_align = 36 * track->channels;
track->block_samples = 64;
track->codec_id = ff_wav_codec_get_id(track->compression,
track->bits_per_sample);
packet->track = track;
packet->stream_index = -1;
packet->frame_size = 0;
packet->block_count = 0;
if (track->flags & XMV_AUDIO_ADPCM51)
av_log(VAR_0, AV_LOG_WARNING, "Unsupported 5.1 ADPCM audio stream "
"(0x%04X)\n", track->flags);
if (!track->channels || !track->sample_rate) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid parameters for audio track %d.\n",
audio_track);
VAR_1 = AVERROR_INVALIDDATA;
goto fail;
}
ast = avformat_new_stream(VAR_0, NULL);
if (!ast)
return AVERROR(ENOMEM);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = track->codec_id;
ast->codec->codec_tag = track->compression;
ast->codec->channels = track->channels;
ast->codec->sample_rate = track->sample_rate;
ast->codec->bits_per_coded_sample = track->bits_per_sample;
ast->codec->bit_rate = track->bit_rate;
ast->codec->block_align = 36 * track->channels;
avpriv_set_pts_info(ast, 32, track->block_samples, track->sample_rate);
packet->stream_index = ast->index;
ast->duration = vst->duration;
}
xmv->next_packet_offset = avio_tell(pb);
xmv->next_packet_size = this_packet_size - xmv->next_packet_offset;
xmv->stream_count = xmv->audio_track_count + 1;
return 0;
fail:
xmv_read_close(VAR_0);
return VAR_1;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"XMVDemuxContext *xmv = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"AVStream *vst = NULL;",
"uint32_t file_version;",
"uint32_t this_packet_size;",
"uint16_t audio_track;",
"int VAR_1;",
"avio_skip(pb, 4);",
"this_packet_size = avio_rl32(pb);",
"avio_skip(pb, 4);",
"avio_skip(pb, 4);",
"file_version = avio_rl32(pb);",
"if ((file_version != 4) && (file_version != 2))\navpriv_request_sample(VAR_0, \"Uncommon version %d\", file_version);",
"vst = avformat_new_stream(VAR_0, NULL);",
"if (!vst)\nreturn AVERROR(ENOMEM);",
"avpriv_set_pts_info(vst, 32, 1, 1000);",
"vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"vst->codec->codec_id = AV_CODEC_ID_WMV2;",
"vst->codec->codec_tag = MKBETAG('W', 'M', 'V', '2');",
"vst->codec->width = avio_rl32(pb);",
"vst->codec->height = avio_rl32(pb);",
"vst->duration = avio_rl32(pb);",
"xmv->video.stream_index = vst->index;",
"xmv->audio_track_count = avio_rl16(pb);",
"avio_skip(pb, 2);",
"xmv->audio_tracks = av_malloc(xmv->audio_track_count * sizeof(XMVAudioTrack));",
"if (!xmv->audio_tracks)\nreturn AVERROR(ENOMEM);",
"xmv->audio = av_malloc(xmv->audio_track_count * sizeof(XMVAudioPacket));",
"if (!xmv->audio)\nreturn AVERROR(ENOMEM);",
"for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {",
"XMVAudioTrack *track = &xmv->audio_tracks[audio_track];",
"XMVAudioPacket *packet = &xmv->audio [audio_track];",
"AVStream *ast = NULL;",
"track->compression = avio_rl16(pb);",
"track->channels = avio_rl16(pb);",
"track->sample_rate = avio_rl32(pb);",
"track->bits_per_sample = avio_rl16(pb);",
"track->flags = avio_rl16(pb);",
"track->bit_rate = track->bits_per_sample *\ntrack->sample_rate *\ntrack->channels;",
"track->block_align = 36 * track->channels;",
"track->block_samples = 64;",
"track->codec_id = ff_wav_codec_get_id(track->compression,\ntrack->bits_per_sample);",
"packet->track = track;",
"packet->stream_index = -1;",
"packet->frame_size = 0;",
"packet->block_count = 0;",
"if (track->flags & XMV_AUDIO_ADPCM51)\nav_log(VAR_0, AV_LOG_WARNING, \"Unsupported 5.1 ADPCM audio stream \"\n\"(0x%04X)\\n\", track->flags);",
"if (!track->channels || !track->sample_rate) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid parameters for audio track %d.\\n\",\naudio_track);",
"VAR_1 = AVERROR_INVALIDDATA;",
"goto fail;",
"}",
"ast = avformat_new_stream(VAR_0, NULL);",
"if (!ast)\nreturn AVERROR(ENOMEM);",
"ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;",
"ast->codec->codec_id = track->codec_id;",
"ast->codec->codec_tag = track->compression;",
"ast->codec->channels = track->channels;",
"ast->codec->sample_rate = track->sample_rate;",
"ast->codec->bits_per_coded_sample = track->bits_per_sample;",
"ast->codec->bit_rate = track->bit_rate;",
"ast->codec->block_align = 36 * track->channels;",
"avpriv_set_pts_info(ast, 32, track->block_samples, track->sample_rate);",
"packet->stream_index = ast->index;",
"ast->duration = vst->duration;",
"}",
"xmv->next_packet_offset = avio_tell(pb);",
"xmv->next_packet_size = this_packet_size - xmv->next_packet_offset;",
"xmv->stream_count = xmv->audio_track_count + 1;",
"return 0;",
"fail:\nxmv_read_close(VAR_0);",
"return VAR_1;",
"}"
] | [
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,
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,
1,
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
],
[
23
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39,
41
],
[
51
],
[
53,
55
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
79
],
[
87
],
[
91
],
[
95
],
[
97,
99
],
[
103
],
[
105,
107
],
[
111
],
[
113
],
[
115
],
[
117
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133,
135,
137
],
[
139
],
[
141
],
[
143,
145
],
[
149
],
[
151
],
[
155
],
[
157
],
[
165,
167,
169
],
[
173
],
[
175,
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
189,
191
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
213
],
[
217
],
[
221
],
[
223
],
[
233
],
[
235
],
[
237
],
[
241
],
[
245,
247
],
[
249
],
[
251
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.