id
int32 0
27.3k
| func
stringlengths 26
142k
| target
bool 2
classes | project
stringclasses 2
values | commit_id
stringlengths 40
40
| func_clean
stringlengths 26
131k
| vul_lines
dict | normalized_func
stringlengths 24
132k
| lines
listlengths 1
2.8k
| label
listlengths 1
2.8k
| line_no
listlengths 1
2.8k
|
---|---|---|---|---|---|---|---|---|---|---|
7,970 |
void ppc_hash64_unmap_hptes(PowerPCCPU *cpu, const ppc_hash_pte64_t *hptes,
hwaddr ptex, int n)
{
if (cpu->env.external_htab == MMU_HASH64_KVM_MANAGED_HPT) {
g_free((void *)hptes);
} else if (!cpu->env.external_htab) {
address_space_unmap(CPU(cpu)->as, (void *)hptes, n * HASH_PTE_SIZE_64,
false, n * HASH_PTE_SIZE_64);
}
}
| false |
qemu
|
e57ca75ce3b2bd33102573a8c0555d62e1bcfceb
|
void ppc_hash64_unmap_hptes(PowerPCCPU *cpu, const ppc_hash_pte64_t *hptes,
hwaddr ptex, int n)
{
if (cpu->env.external_htab == MMU_HASH64_KVM_MANAGED_HPT) {
g_free((void *)hptes);
} else if (!cpu->env.external_htab) {
address_space_unmap(CPU(cpu)->as, (void *)hptes, n * HASH_PTE_SIZE_64,
false, n * HASH_PTE_SIZE_64);
}
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(PowerPCCPU *VAR_0, const ppc_hash_pte64_t *VAR_1,
hwaddr VAR_2, int VAR_3)
{
if (VAR_0->env.external_htab == MMU_HASH64_KVM_MANAGED_HPT) {
g_free((void *)VAR_1);
} else if (!VAR_0->env.external_htab) {
address_space_unmap(CPU(VAR_0)->as, (void *)VAR_1, VAR_3 * HASH_PTE_SIZE_64,
false, VAR_3 * HASH_PTE_SIZE_64);
}
}
|
[
"void FUNC_0(PowerPCCPU *VAR_0, const ppc_hash_pte64_t *VAR_1,\nhwaddr VAR_2, int VAR_3)\n{",
"if (VAR_0->env.external_htab == MMU_HASH64_KVM_MANAGED_HPT) {",
"g_free((void *)VAR_1);",
"} else if (!VAR_0->env.external_htab) {",
"address_space_unmap(CPU(VAR_0)->as, (void *)VAR_1, VAR_3 * HASH_PTE_SIZE_64,\nfalse, VAR_3 * HASH_PTE_SIZE_64);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17
],
[
19
]
] |
7,971 |
static void tcg_reg_sync(TCGContext *s, TCGReg reg, TCGRegSet allocated_regs)
{
TCGTemp *ts = s->reg_to_temp[reg];
assert(ts->val_type == TEMP_VAL_REG);
if (!ts->mem_coherent && !ts->fixed_reg) {
if (!ts->mem_allocated) {
temp_allocate_frame(s, temp_idx(s, ts));
} else if (ts->indirect_reg) {
tcg_regset_set_reg(allocated_regs, ts->reg);
temp_load(s, ts->mem_base,
tcg_target_available_regs[TCG_TYPE_PTR],
allocated_regs);
}
tcg_out_st(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset);
}
ts->mem_coherent = 1;
}
| false |
qemu
|
eabb7b91b36b202b4dac2df2d59d698e3aff197a
|
static void tcg_reg_sync(TCGContext *s, TCGReg reg, TCGRegSet allocated_regs)
{
TCGTemp *ts = s->reg_to_temp[reg];
assert(ts->val_type == TEMP_VAL_REG);
if (!ts->mem_coherent && !ts->fixed_reg) {
if (!ts->mem_allocated) {
temp_allocate_frame(s, temp_idx(s, ts));
} else if (ts->indirect_reg) {
tcg_regset_set_reg(allocated_regs, ts->reg);
temp_load(s, ts->mem_base,
tcg_target_available_regs[TCG_TYPE_PTR],
allocated_regs);
}
tcg_out_st(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset);
}
ts->mem_coherent = 1;
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(TCGContext *VAR_0, TCGReg VAR_1, TCGRegSet VAR_2)
{
TCGTemp *ts = VAR_0->reg_to_temp[VAR_1];
assert(ts->val_type == TEMP_VAL_REG);
if (!ts->mem_coherent && !ts->fixed_reg) {
if (!ts->mem_allocated) {
temp_allocate_frame(VAR_0, temp_idx(VAR_0, ts));
} else if (ts->indirect_reg) {
tcg_regset_set_reg(VAR_2, ts->VAR_1);
temp_load(VAR_0, ts->mem_base,
tcg_target_available_regs[TCG_TYPE_PTR],
VAR_2);
}
tcg_out_st(VAR_0, ts->type, VAR_1, ts->mem_base->VAR_1, ts->mem_offset);
}
ts->mem_coherent = 1;
}
|
[
"static void FUNC_0(TCGContext *VAR_0, TCGReg VAR_1, TCGRegSet VAR_2)\n{",
"TCGTemp *ts = VAR_0->reg_to_temp[VAR_1];",
"assert(ts->val_type == TEMP_VAL_REG);",
"if (!ts->mem_coherent && !ts->fixed_reg) {",
"if (!ts->mem_allocated) {",
"temp_allocate_frame(VAR_0, temp_idx(VAR_0, ts));",
"} else if (ts->indirect_reg) {",
"tcg_regset_set_reg(VAR_2, ts->VAR_1);",
"temp_load(VAR_0, ts->mem_base,\ntcg_target_available_regs[TCG_TYPE_PTR],\nVAR_2);",
"}",
"tcg_out_st(VAR_0, ts->type, VAR_1, ts->mem_base->VAR_1, ts->mem_offset);",
"}",
"ts->mem_coherent = 1;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21,
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
7,973 |
static QOSState *pci_test_start(int socket)
{
const char *cmd = "-netdev socket,fd=%d,id=hs0 -device "
"virtio-net-pci,netdev=hs0";
return qtest_pc_boot(cmd, socket);
}
| false |
qemu
|
30ca440eec9fe1d7eec5a48addac656438778278
|
static QOSState *pci_test_start(int socket)
{
const char *cmd = "-netdev socket,fd=%d,id=hs0 -device "
"virtio-net-pci,netdev=hs0";
return qtest_pc_boot(cmd, socket);
}
|
{
"code": [],
"line_no": []
}
|
static QOSState *FUNC_0(int socket)
{
const char *VAR_0 = "-netdev socket,fd=%d,id=hs0 -device "
"virtio-net-pci,netdev=hs0";
return qtest_pc_boot(VAR_0, socket);
}
|
[
"static QOSState *FUNC_0(int socket)\n{",
"const char *VAR_0 = \"-netdev socket,fd=%d,id=hs0 -device \"\n\"virtio-net-pci,netdev=hs0\";",
"return qtest_pc_boot(VAR_0, socket);",
"}"
] |
[
0,
0,
0,
0
] |
[
[
1,
3
],
[
5,
7
],
[
11
],
[
13
]
] |
7,974 |
static int spapr_populate_pci_child_dt(PCIDevice *dev, void *fdt, int offset,
sPAPRPHBState *sphb)
{
ResourceProps rp;
bool is_bridge = false;
int pci_status, err;
char *buf = NULL;
uint32_t drc_index = spapr_phb_get_pci_drc_index(sphb, dev);
uint32_t ccode = pci_default_read_config(dev, PCI_CLASS_PROG, 3);
uint32_t max_msi, max_msix;
if (pci_default_read_config(dev, PCI_HEADER_TYPE, 1) ==
PCI_HEADER_TYPE_BRIDGE) {
is_bridge = true;
}
/* in accordance with PAPR+ v2.7 13.6.3, Table 181 */
_FDT(fdt_setprop_cell(fdt, offset, "vendor-id",
pci_default_read_config(dev, PCI_VENDOR_ID, 2)));
_FDT(fdt_setprop_cell(fdt, offset, "device-id",
pci_default_read_config(dev, PCI_DEVICE_ID, 2)));
_FDT(fdt_setprop_cell(fdt, offset, "revision-id",
pci_default_read_config(dev, PCI_REVISION_ID, 1)));
_FDT(fdt_setprop_cell(fdt, offset, "class-code", ccode));
if (pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)) {
_FDT(fdt_setprop_cell(fdt, offset, "interrupts",
pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)));
}
if (!is_bridge) {
_FDT(fdt_setprop_cell(fdt, offset, "min-grant",
pci_default_read_config(dev, PCI_MIN_GNT, 1)));
_FDT(fdt_setprop_cell(fdt, offset, "max-latency",
pci_default_read_config(dev, PCI_MAX_LAT, 1)));
}
if (pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)) {
_FDT(fdt_setprop_cell(fdt, offset, "subsystem-id",
pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)));
}
if (pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)) {
_FDT(fdt_setprop_cell(fdt, offset, "subsystem-vendor-id",
pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)));
}
_FDT(fdt_setprop_cell(fdt, offset, "cache-line-size",
pci_default_read_config(dev, PCI_CACHE_LINE_SIZE, 1)));
/* the following fdt cells are masked off the pci status register */
pci_status = pci_default_read_config(dev, PCI_STATUS, 2);
_FDT(fdt_setprop_cell(fdt, offset, "devsel-speed",
PCI_STATUS_DEVSEL_MASK & pci_status));
if (pci_status & PCI_STATUS_FAST_BACK) {
_FDT(fdt_setprop(fdt, offset, "fast-back-to-back", NULL, 0));
}
if (pci_status & PCI_STATUS_66MHZ) {
_FDT(fdt_setprop(fdt, offset, "66mhz-capable", NULL, 0));
}
if (pci_status & PCI_STATUS_UDF) {
_FDT(fdt_setprop(fdt, offset, "udf-supported", NULL, 0));
}
_FDT(fdt_setprop_string(fdt, offset, "name",
pci_find_device_name((ccode >> 16) & 0xff,
(ccode >> 8) & 0xff,
ccode & 0xff)));
buf = spapr_phb_get_loc_code(sphb, dev);
if (!buf) {
error_report("Failed setting the ibm,loc-code");
return -1;
}
err = fdt_setprop_string(fdt, offset, "ibm,loc-code", buf);
g_free(buf);
if (err < 0) {
return err;
}
if (drc_index) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index));
}
_FDT(fdt_setprop_cell(fdt, offset, "#address-cells",
RESOURCE_CELLS_ADDRESS));
_FDT(fdt_setprop_cell(fdt, offset, "#size-cells",
RESOURCE_CELLS_SIZE));
max_msi = msi_nr_vectors_allocated(dev);
if (max_msi) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi", max_msi));
}
max_msix = dev->msix_entries_nr;
if (max_msix) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi-x", max_msix));
}
populate_resource_props(dev, &rp);
_FDT(fdt_setprop(fdt, offset, "reg", (uint8_t *)rp.reg, rp.reg_len));
_FDT(fdt_setprop(fdt, offset, "assigned-addresses",
(uint8_t *)rp.assigned, rp.assigned_len));
if (pci_is_express(dev)) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,pci-config-space-type", 0x1));
}
return 0;
}
| false |
qemu
|
82516263cead40ac240ae5fb2a6f5fc0fda9614c
|
static int spapr_populate_pci_child_dt(PCIDevice *dev, void *fdt, int offset,
sPAPRPHBState *sphb)
{
ResourceProps rp;
bool is_bridge = false;
int pci_status, err;
char *buf = NULL;
uint32_t drc_index = spapr_phb_get_pci_drc_index(sphb, dev);
uint32_t ccode = pci_default_read_config(dev, PCI_CLASS_PROG, 3);
uint32_t max_msi, max_msix;
if (pci_default_read_config(dev, PCI_HEADER_TYPE, 1) ==
PCI_HEADER_TYPE_BRIDGE) {
is_bridge = true;
}
_FDT(fdt_setprop_cell(fdt, offset, "vendor-id",
pci_default_read_config(dev, PCI_VENDOR_ID, 2)));
_FDT(fdt_setprop_cell(fdt, offset, "device-id",
pci_default_read_config(dev, PCI_DEVICE_ID, 2)));
_FDT(fdt_setprop_cell(fdt, offset, "revision-id",
pci_default_read_config(dev, PCI_REVISION_ID, 1)));
_FDT(fdt_setprop_cell(fdt, offset, "class-code", ccode));
if (pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)) {
_FDT(fdt_setprop_cell(fdt, offset, "interrupts",
pci_default_read_config(dev, PCI_INTERRUPT_PIN, 1)));
}
if (!is_bridge) {
_FDT(fdt_setprop_cell(fdt, offset, "min-grant",
pci_default_read_config(dev, PCI_MIN_GNT, 1)));
_FDT(fdt_setprop_cell(fdt, offset, "max-latency",
pci_default_read_config(dev, PCI_MAX_LAT, 1)));
}
if (pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)) {
_FDT(fdt_setprop_cell(fdt, offset, "subsystem-id",
pci_default_read_config(dev, PCI_SUBSYSTEM_ID, 2)));
}
if (pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)) {
_FDT(fdt_setprop_cell(fdt, offset, "subsystem-vendor-id",
pci_default_read_config(dev, PCI_SUBSYSTEM_VENDOR_ID, 2)));
}
_FDT(fdt_setprop_cell(fdt, offset, "cache-line-size",
pci_default_read_config(dev, PCI_CACHE_LINE_SIZE, 1)));
pci_status = pci_default_read_config(dev, PCI_STATUS, 2);
_FDT(fdt_setprop_cell(fdt, offset, "devsel-speed",
PCI_STATUS_DEVSEL_MASK & pci_status));
if (pci_status & PCI_STATUS_FAST_BACK) {
_FDT(fdt_setprop(fdt, offset, "fast-back-to-back", NULL, 0));
}
if (pci_status & PCI_STATUS_66MHZ) {
_FDT(fdt_setprop(fdt, offset, "66mhz-capable", NULL, 0));
}
if (pci_status & PCI_STATUS_UDF) {
_FDT(fdt_setprop(fdt, offset, "udf-supported", NULL, 0));
}
_FDT(fdt_setprop_string(fdt, offset, "name",
pci_find_device_name((ccode >> 16) & 0xff,
(ccode >> 8) & 0xff,
ccode & 0xff)));
buf = spapr_phb_get_loc_code(sphb, dev);
if (!buf) {
error_report("Failed setting the ibm,loc-code");
return -1;
}
err = fdt_setprop_string(fdt, offset, "ibm,loc-code", buf);
g_free(buf);
if (err < 0) {
return err;
}
if (drc_index) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index));
}
_FDT(fdt_setprop_cell(fdt, offset, "#address-cells",
RESOURCE_CELLS_ADDRESS));
_FDT(fdt_setprop_cell(fdt, offset, "#size-cells",
RESOURCE_CELLS_SIZE));
max_msi = msi_nr_vectors_allocated(dev);
if (max_msi) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi", max_msi));
}
max_msix = dev->msix_entries_nr;
if (max_msix) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,req#msi-x", max_msix));
}
populate_resource_props(dev, &rp);
_FDT(fdt_setprop(fdt, offset, "reg", (uint8_t *)rp.reg, rp.reg_len));
_FDT(fdt_setprop(fdt, offset, "assigned-addresses",
(uint8_t *)rp.assigned, rp.assigned_len));
if (pci_is_express(dev)) {
_FDT(fdt_setprop_cell(fdt, offset, "ibm,pci-config-space-type", 0x1));
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(PCIDevice *VAR_0, void *VAR_1, int VAR_2,
sPAPRPHBState *VAR_3)
{
ResourceProps rp;
bool is_bridge = false;
int VAR_4, VAR_5;
char *VAR_6 = NULL;
uint32_t drc_index = spapr_phb_get_pci_drc_index(VAR_3, VAR_0);
uint32_t ccode = pci_default_read_config(VAR_0, PCI_CLASS_PROG, 3);
uint32_t max_msi, max_msix;
if (pci_default_read_config(VAR_0, PCI_HEADER_TYPE, 1) ==
PCI_HEADER_TYPE_BRIDGE) {
is_bridge = true;
}
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "vendor-id",
pci_default_read_config(VAR_0, PCI_VENDOR_ID, 2)));
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "device-id",
pci_default_read_config(VAR_0, PCI_DEVICE_ID, 2)));
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "revision-id",
pci_default_read_config(VAR_0, PCI_REVISION_ID, 1)));
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "class-code", ccode));
if (pci_default_read_config(VAR_0, PCI_INTERRUPT_PIN, 1)) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "interrupts",
pci_default_read_config(VAR_0, PCI_INTERRUPT_PIN, 1)));
}
if (!is_bridge) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "min-grant",
pci_default_read_config(VAR_0, PCI_MIN_GNT, 1)));
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "max-latency",
pci_default_read_config(VAR_0, PCI_MAX_LAT, 1)));
}
if (pci_default_read_config(VAR_0, PCI_SUBSYSTEM_ID, 2)) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "subsystem-id",
pci_default_read_config(VAR_0, PCI_SUBSYSTEM_ID, 2)));
}
if (pci_default_read_config(VAR_0, PCI_SUBSYSTEM_VENDOR_ID, 2)) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "subsystem-vendor-id",
pci_default_read_config(VAR_0, PCI_SUBSYSTEM_VENDOR_ID, 2)));
}
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "cache-line-size",
pci_default_read_config(VAR_0, PCI_CACHE_LINE_SIZE, 1)));
VAR_4 = pci_default_read_config(VAR_0, PCI_STATUS, 2);
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "devsel-speed",
PCI_STATUS_DEVSEL_MASK & VAR_4));
if (VAR_4 & PCI_STATUS_FAST_BACK) {
_FDT(fdt_setprop(VAR_1, VAR_2, "fast-back-to-back", NULL, 0));
}
if (VAR_4 & PCI_STATUS_66MHZ) {
_FDT(fdt_setprop(VAR_1, VAR_2, "66mhz-capable", NULL, 0));
}
if (VAR_4 & PCI_STATUS_UDF) {
_FDT(fdt_setprop(VAR_1, VAR_2, "udf-supported", NULL, 0));
}
_FDT(fdt_setprop_string(VAR_1, VAR_2, "name",
pci_find_device_name((ccode >> 16) & 0xff,
(ccode >> 8) & 0xff,
ccode & 0xff)));
VAR_6 = spapr_phb_get_loc_code(VAR_3, VAR_0);
if (!VAR_6) {
error_report("Failed setting the ibm,loc-code");
return -1;
}
VAR_5 = fdt_setprop_string(VAR_1, VAR_2, "ibm,loc-code", VAR_6);
g_free(VAR_6);
if (VAR_5 < 0) {
return VAR_5;
}
if (drc_index) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "ibm,my-drc-index", drc_index));
}
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "#address-cells",
RESOURCE_CELLS_ADDRESS));
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "#size-cells",
RESOURCE_CELLS_SIZE));
max_msi = msi_nr_vectors_allocated(VAR_0);
if (max_msi) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "ibm,req#msi", max_msi));
}
max_msix = VAR_0->msix_entries_nr;
if (max_msix) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "ibm,req#msi-x", max_msix));
}
populate_resource_props(VAR_0, &rp);
_FDT(fdt_setprop(VAR_1, VAR_2, "reg", (uint8_t *)rp.reg, rp.reg_len));
_FDT(fdt_setprop(VAR_1, VAR_2, "assigned-addresses",
(uint8_t *)rp.assigned, rp.assigned_len));
if (pci_is_express(VAR_0)) {
_FDT(fdt_setprop_cell(VAR_1, VAR_2, "ibm,pci-config-space-type", 0x1));
}
return 0;
}
|
[
"static int FUNC_0(PCIDevice *VAR_0, void *VAR_1, int VAR_2,\nsPAPRPHBState *VAR_3)\n{",
"ResourceProps rp;",
"bool is_bridge = false;",
"int VAR_4, VAR_5;",
"char *VAR_6 = NULL;",
"uint32_t drc_index = spapr_phb_get_pci_drc_index(VAR_3, VAR_0);",
"uint32_t ccode = pci_default_read_config(VAR_0, PCI_CLASS_PROG, 3);",
"uint32_t max_msi, max_msix;",
"if (pci_default_read_config(VAR_0, PCI_HEADER_TYPE, 1) ==\nPCI_HEADER_TYPE_BRIDGE) {",
"is_bridge = true;",
"}",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"vendor-id\",\npci_default_read_config(VAR_0, PCI_VENDOR_ID, 2)));",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"device-id\",\npci_default_read_config(VAR_0, PCI_DEVICE_ID, 2)));",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"revision-id\",\npci_default_read_config(VAR_0, PCI_REVISION_ID, 1)));",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"class-code\", ccode));",
"if (pci_default_read_config(VAR_0, PCI_INTERRUPT_PIN, 1)) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"interrupts\",\npci_default_read_config(VAR_0, PCI_INTERRUPT_PIN, 1)));",
"}",
"if (!is_bridge) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"min-grant\",\npci_default_read_config(VAR_0, PCI_MIN_GNT, 1)));",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"max-latency\",\npci_default_read_config(VAR_0, PCI_MAX_LAT, 1)));",
"}",
"if (pci_default_read_config(VAR_0, PCI_SUBSYSTEM_ID, 2)) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"subsystem-id\",\npci_default_read_config(VAR_0, PCI_SUBSYSTEM_ID, 2)));",
"}",
"if (pci_default_read_config(VAR_0, PCI_SUBSYSTEM_VENDOR_ID, 2)) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"subsystem-vendor-id\",\npci_default_read_config(VAR_0, PCI_SUBSYSTEM_VENDOR_ID, 2)));",
"}",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"cache-line-size\",\npci_default_read_config(VAR_0, PCI_CACHE_LINE_SIZE, 1)));",
"VAR_4 = pci_default_read_config(VAR_0, PCI_STATUS, 2);",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"devsel-speed\",\nPCI_STATUS_DEVSEL_MASK & VAR_4));",
"if (VAR_4 & PCI_STATUS_FAST_BACK) {",
"_FDT(fdt_setprop(VAR_1, VAR_2, \"fast-back-to-back\", NULL, 0));",
"}",
"if (VAR_4 & PCI_STATUS_66MHZ) {",
"_FDT(fdt_setprop(VAR_1, VAR_2, \"66mhz-capable\", NULL, 0));",
"}",
"if (VAR_4 & PCI_STATUS_UDF) {",
"_FDT(fdt_setprop(VAR_1, VAR_2, \"udf-supported\", NULL, 0));",
"}",
"_FDT(fdt_setprop_string(VAR_1, VAR_2, \"name\",\npci_find_device_name((ccode >> 16) & 0xff,\n(ccode >> 8) & 0xff,\nccode & 0xff)));",
"VAR_6 = spapr_phb_get_loc_code(VAR_3, VAR_0);",
"if (!VAR_6) {",
"error_report(\"Failed setting the ibm,loc-code\");",
"return -1;",
"}",
"VAR_5 = fdt_setprop_string(VAR_1, VAR_2, \"ibm,loc-code\", VAR_6);",
"g_free(VAR_6);",
"if (VAR_5 < 0) {",
"return VAR_5;",
"}",
"if (drc_index) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"ibm,my-drc-index\", drc_index));",
"}",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"#address-cells\",\nRESOURCE_CELLS_ADDRESS));",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"#size-cells\",\nRESOURCE_CELLS_SIZE));",
"max_msi = msi_nr_vectors_allocated(VAR_0);",
"if (max_msi) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"ibm,req#msi\", max_msi));",
"}",
"max_msix = VAR_0->msix_entries_nr;",
"if (max_msix) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"ibm,req#msi-x\", max_msix));",
"}",
"populate_resource_props(VAR_0, &rp);",
"_FDT(fdt_setprop(VAR_1, VAR_2, \"reg\", (uint8_t *)rp.reg, rp.reg_len));",
"_FDT(fdt_setprop(VAR_1, VAR_2, \"assigned-addresses\",\n(uint8_t *)rp.assigned, rp.assigned_len));",
"if (pci_is_express(VAR_0)) {",
"_FDT(fdt_setprop_cell(VAR_1, VAR_2, \"ibm,pci-config-space-type\", 0x1));",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25
],
[
27
],
[
29
],
[
35,
37
],
[
39,
41
],
[
43,
45
],
[
47
],
[
49
],
[
51,
53
],
[
55
],
[
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
73
],
[
75,
77
],
[
79
],
[
83
],
[
85,
87
],
[
89
],
[
93,
95
],
[
101
],
[
103,
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
129,
131,
133,
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
163
],
[
165
],
[
169,
171
],
[
173,
175
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
197
],
[
199
],
[
201,
203
],
[
207
],
[
209
],
[
211
],
[
215
],
[
217
]
] |
7,975 |
static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
uint64_t off, uint32_t count,
struct iovec *sg, int cnt)
{
int i, to_copy;
ssize_t err = 0;
int write_count;
int64_t xattr_len;
size_t offset = 7;
xattr_len = fidp->fs.xattr.len;
write_count = xattr_len - off;
if (write_count > count) {
write_count = count;
} else if (write_count < 0) {
/*
* write beyond XATTR value len specified in
* xattrcreate
*/
err = -ENOSPC;
goto out;
}
offset += pdu_marshal(pdu, offset, "d", write_count);
err = offset;
fidp->fs.xattr.copied_len += write_count;
/*
* Now copy the content from sg list
*/
for (i = 0; i < cnt; i++) {
if (write_count > sg[i].iov_len) {
to_copy = sg[i].iov_len;
} else {
to_copy = write_count;
}
memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
/* updating vs->off since we are not using below */
off += to_copy;
write_count -= to_copy;
}
out:
return err;
}
| false |
qemu
|
ddca7f86ac022289840e0200fd4050b2b58e9176
|
static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
uint64_t off, uint32_t count,
struct iovec *sg, int cnt)
{
int i, to_copy;
ssize_t err = 0;
int write_count;
int64_t xattr_len;
size_t offset = 7;
xattr_len = fidp->fs.xattr.len;
write_count = xattr_len - off;
if (write_count > count) {
write_count = count;
} else if (write_count < 0) {
err = -ENOSPC;
goto out;
}
offset += pdu_marshal(pdu, offset, "d", write_count);
err = offset;
fidp->fs.xattr.copied_len += write_count;
for (i = 0; i < cnt; i++) {
if (write_count > sg[i].iov_len) {
to_copy = sg[i].iov_len;
} else {
to_copy = write_count;
}
memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
off += to_copy;
write_count -= to_copy;
}
out:
return err;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(V9fsState *VAR_0, V9fsPDU *VAR_1, V9fsFidState *VAR_2,
uint64_t VAR_3, uint32_t VAR_4,
struct iovec *VAR_5, int VAR_6)
{
int VAR_7, VAR_8;
ssize_t err = 0;
int VAR_9;
int64_t xattr_len;
size_t offset = 7;
xattr_len = VAR_2->fs.xattr.len;
VAR_9 = xattr_len - VAR_3;
if (VAR_9 > VAR_4) {
VAR_9 = VAR_4;
} else if (VAR_9 < 0) {
err = -ENOSPC;
goto out;
}
offset += pdu_marshal(VAR_1, offset, "d", VAR_9);
err = offset;
VAR_2->fs.xattr.copied_len += VAR_9;
for (VAR_7 = 0; VAR_7 < VAR_6; VAR_7++) {
if (VAR_9 > VAR_5[VAR_7].iov_len) {
VAR_8 = VAR_5[VAR_7].iov_len;
} else {
VAR_8 = VAR_9;
}
memcpy((char *)VAR_2->fs.xattr.value + VAR_3, VAR_5[VAR_7].iov_base, VAR_8);
VAR_3 += VAR_8;
VAR_9 -= VAR_8;
}
out:
return err;
}
|
[
"static int FUNC_0(V9fsState *VAR_0, V9fsPDU *VAR_1, V9fsFidState *VAR_2,\nuint64_t VAR_3, uint32_t VAR_4,\nstruct iovec *VAR_5, int VAR_6)\n{",
"int VAR_7, VAR_8;",
"ssize_t err = 0;",
"int VAR_9;",
"int64_t xattr_len;",
"size_t offset = 7;",
"xattr_len = VAR_2->fs.xattr.len;",
"VAR_9 = xattr_len - VAR_3;",
"if (VAR_9 > VAR_4) {",
"VAR_9 = VAR_4;",
"} else if (VAR_9 < 0) {",
"err = -ENOSPC;",
"goto out;",
"}",
"offset += pdu_marshal(VAR_1, offset, \"d\", VAR_9);",
"err = offset;",
"VAR_2->fs.xattr.copied_len += VAR_9;",
"for (VAR_7 = 0; VAR_7 < VAR_6; VAR_7++) {",
"if (VAR_9 > VAR_5[VAR_7].iov_len) {",
"VAR_8 = VAR_5[VAR_7].iov_len;",
"} else {",
"VAR_8 = VAR_9;",
"}",
"memcpy((char *)VAR_2->fs.xattr.value + VAR_3, VAR_5[VAR_7].iov_base, VAR_8);",
"VAR_3 += VAR_8;",
"VAR_9 -= VAR_8;",
"}",
"out:\nreturn err;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81,
83
],
[
85
]
] |
7,976 |
static int x86_cpu_filter_features(X86CPU *cpu)
{
CPUX86State *env = &cpu->env;
FeatureWord w;
int rv = 0;
for (w = 0; w < FEATURE_WORDS; w++) {
uint32_t host_feat =
x86_cpu_get_supported_feature_word(w, false);
uint32_t requested_features = env->features[w];
env->features[w] &= host_feat;
cpu->filtered_features[w] = requested_features & ~env->features[w];
if (cpu->filtered_features[w]) {
rv = 1;
}
}
return rv;
}
| false |
qemu
|
b8d834a00fa3ed4dad7d371e1a00938a126a54a0
|
static int x86_cpu_filter_features(X86CPU *cpu)
{
CPUX86State *env = &cpu->env;
FeatureWord w;
int rv = 0;
for (w = 0; w < FEATURE_WORDS; w++) {
uint32_t host_feat =
x86_cpu_get_supported_feature_word(w, false);
uint32_t requested_features = env->features[w];
env->features[w] &= host_feat;
cpu->filtered_features[w] = requested_features & ~env->features[w];
if (cpu->filtered_features[w]) {
rv = 1;
}
}
return rv;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(X86CPU *VAR_0)
{
CPUX86State *env = &VAR_0->env;
FeatureWord w;
int VAR_1 = 0;
for (w = 0; w < FEATURE_WORDS; w++) {
uint32_t host_feat =
x86_cpu_get_supported_feature_word(w, false);
uint32_t requested_features = env->features[w];
env->features[w] &= host_feat;
VAR_0->filtered_features[w] = requested_features & ~env->features[w];
if (VAR_0->filtered_features[w]) {
VAR_1 = 1;
}
}
return VAR_1;
}
|
[
"static int FUNC_0(X86CPU *VAR_0)\n{",
"CPUX86State *env = &VAR_0->env;",
"FeatureWord w;",
"int VAR_1 = 0;",
"for (w = 0; w < FEATURE_WORDS; w++) {",
"uint32_t host_feat =\nx86_cpu_get_supported_feature_word(w, false);",
"uint32_t requested_features = env->features[w];",
"env->features[w] &= host_feat;",
"VAR_0->filtered_features[w] = requested_features & ~env->features[w];",
"if (VAR_0->filtered_features[w]) {",
"VAR_1 = 1;",
"}",
"}",
"return VAR_1;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
]
] |
7,978 |
static int decode_mb(H264Context *h){
MpegEncContext * const s = &h->s;
const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
int mb_type, partition_count, cbp;
s->dsp.clear_blocks(h->mb); //FIXME avoid if allready clear (move after skip handlong?
tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
cbp = 0; /* avoid warning. FIXME: find a solution without slowing
down the code */
if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
if(s->mb_skip_run==-1)
s->mb_skip_run= get_ue_golomb(&s->gb);
if (s->mb_skip_run--) {
int mx, my;
/* skip mb */
//FIXME b frame
mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0;
memset(h->non_zero_count[mb_xy], 0, 16+4+4);
memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
if(h->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){
h->mb_field_decoding_flag= get_bits1(&s->gb);
}
if(h->mb_field_decoding_flag)
mb_type|= MB_TYPE_INTERLACED;
fill_caches(h, mb_type); //FIXME check what is needed and what not ...
pred_pskip_motion(h, &mx, &my);
fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
write_back_motion(h, mb_type);
s->current_picture.mb_type[mb_xy]= mb_type; //FIXME SKIP type
s->current_picture.qscale_table[mb_xy]= s->qscale;
h->slice_table[ mb_xy ]= h->slice_num;
h->prev_mb_skiped= 1;
return 0;
}
}
if(h->sps.mb_aff /* && !field pic FIXME needed? */){
if((s->mb_y&1)==0)
h->mb_field_decoding_flag = get_bits1(&s->gb);
}else
h->mb_field_decoding_flag=0; //FIXME som ed note ?!
h->prev_mb_skiped= 0;
mb_type= get_ue_golomb(&s->gb);
if(h->slice_type == B_TYPE){
if(mb_type < 23){
partition_count= b_mb_type_info[mb_type].partition_count;
mb_type= b_mb_type_info[mb_type].type;
}else{
mb_type -= 23;
goto decode_intra_mb;
}
}else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){
if(mb_type < 5){
partition_count= p_mb_type_info[mb_type].partition_count;
mb_type= p_mb_type_info[mb_type].type;
}else{
mb_type -= 5;
goto decode_intra_mb;
}
}else{
assert(h->slice_type == I_TYPE);
decode_intra_mb:
if(mb_type > 25){
av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
return -1;
}
partition_count=0;
cbp= i_mb_type_info[mb_type].cbp;
h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
mb_type= i_mb_type_info[mb_type].type;
}
if(h->mb_field_decoding_flag)
mb_type |= MB_TYPE_INTERLACED;
s->current_picture.mb_type[mb_xy]= mb_type;
h->slice_table[ mb_xy ]= h->slice_num;
if(IS_INTRA_PCM(mb_type)){
const uint8_t *ptr;
int x, y;
// we assume these blocks are very rare so we dont optimize it
align_get_bits(&s->gb);
ptr= s->gb.buffer + get_bits_count(&s->gb);
for(y=0; y<16; y++){
const int index= 4*(y&3) + 64*(y>>2);
for(x=0; x<16; x++){
h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
}
}
for(y=0; y<8; y++){
const int index= 256 + 4*(y&3) + 32*(y>>2);
for(x=0; x<8; x++){
h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
}
}
for(y=0; y<8; y++){
const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
for(x=0; x<8; x++){
h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
}
}
skip_bits(&s->gb, 384); //FIXME check /fix the bitstream readers
memset(h->non_zero_count[mb_xy], 16, 16+4+4);
s->current_picture.qscale_table[mb_xy]= s->qscale;
return 0;
}
fill_caches(h, mb_type);
//mb_pred
if(IS_INTRA(mb_type)){
// init_top_left_availability(h);
if(IS_INTRA4x4(mb_type)){
int i;
// fill_intra4x4_pred_table(h);
for(i=0; i<16; i++){
const int mode_coded= !get_bits1(&s->gb);
const int predicted_mode= pred_intra_mode(h, i);
int mode;
if(mode_coded){
const int rem_mode= get_bits(&s->gb, 3);
if(rem_mode<predicted_mode)
mode= rem_mode;
else
mode= rem_mode + 1;
}else{
mode= predicted_mode;
}
h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
}
write_back_intra_pred_mode(h);
if( check_intra4x4_pred_mode(h) < 0)
return -1;
}else{
h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
if(h->intra16x16_pred_mode < 0)
return -1;
}
h->chroma_pred_mode= get_ue_golomb(&s->gb);
h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
if(h->chroma_pred_mode < 0)
return -1;
}else if(partition_count==4){
int i, j, sub_partition_count[4], list, ref[2][4];
if(h->slice_type == B_TYPE){
for(i=0; i<4; i++){
h->sub_mb_type[i]= get_ue_golomb(&s->gb);
if(h->sub_mb_type[i] >=13){
av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
return -1;
}
sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
}
}else{
assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
for(i=0; i<4; i++){
h->sub_mb_type[i]= get_ue_golomb(&s->gb);
if(h->sub_mb_type[i] >=4){
av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
return -1;
}
sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
}
}
for(list=0; list<2; list++){
const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
if(ref_count == 0) continue;
for(i=0; i<4; i++){
if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
}else{
//FIXME
ref[list][i] = -1;
}
}
}
for(list=0; list<2; list++){
const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
if(ref_count == 0) continue;
for(i=0; i<4; i++){
h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
const int sub_mb_type= h->sub_mb_type[i];
const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
for(j=0; j<sub_partition_count[i]; j++){
int mx, my;
const int index= 4*i + block_width*j;
int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
if(IS_SUB_8X8(sub_mb_type)){
mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
}else if(IS_SUB_8X4(sub_mb_type)){
mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
}else if(IS_SUB_4X8(sub_mb_type)){
mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
}else{
assert(IS_SUB_4X4(sub_mb_type));
mv_cache[ 0 ][0]= mx;
mv_cache[ 0 ][1]= my;
}
}
}else{
uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
p[0] = p[1]=
p[8] = p[9]= 0;
}
}
}
}else if(!IS_DIRECT(mb_type)){
int list, mx, my, i;
//FIXME we should set ref_idx_l? to 0 if we use that later ...
if(IS_16X16(mb_type)){
for(list=0; list<2; list++){
if(h->ref_count[0]>0){
if(IS_DIR(mb_type, 0, list)){
const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
}
}
}
for(list=0; list<2; list++){
if(IS_DIR(mb_type, 0, list)){
pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
}
}
}
else if(IS_16X8(mb_type)){
for(list=0; list<2; list++){
if(h->ref_count[list]>0){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){
const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
}
}
}
}
for(list=0; list<2; list++){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){
pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
}
}
}
}else{
assert(IS_8X16(mb_type));
for(list=0; list<2; list++){
if(h->ref_count[list]>0){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){ //FIXME optimize
const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
}
}
}
}
for(list=0; list<2; list++){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){
pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
}
}
}
}
}
if(IS_INTER(mb_type))
write_back_motion(h, mb_type);
if(!IS_INTRA16x16(mb_type)){
cbp= get_ue_golomb(&s->gb);
if(cbp > 47){
av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
return -1;
}
if(IS_INTRA4x4(mb_type))
cbp= golomb_to_intra4x4_cbp[cbp];
else
cbp= golomb_to_inter_cbp[cbp];
}
if(cbp || IS_INTRA16x16(mb_type)){
int i8x8, i4x4, chroma_idx;
int chroma_qp, dquant;
GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
const uint8_t *scan, *dc_scan;
// fill_non_zero_count_cache(h);
if(IS_INTERLACED(mb_type)){
scan= field_scan;
dc_scan= luma_dc_field_scan;
}else{
scan= zigzag_scan;
dc_scan= luma_dc_zigzag_scan;
}
dquant= get_se_golomb(&s->gb);
if( dquant > 25 || dquant < -26 ){
av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
return -1;
}
s->qscale += dquant;
if(((unsigned)s->qscale) > 51){
if(s->qscale<0) s->qscale+= 52;
else s->qscale-= 52;
}
h->chroma_qp= chroma_qp= get_chroma_qp(h, s->qscale);
if(IS_INTRA16x16(mb_type)){
if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, s->qscale, 16) < 0){
return -1; //FIXME continue if partotioned and other retirn -1 too
}
assert((cbp&15) == 0 || (cbp&15) == 15);
if(cbp&15){
for(i8x8=0; i8x8<4; i8x8++){
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8;
if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, s->qscale, 15) < 0 ){
return -1;
}
}
}
}else{
fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
}
}else{
for(i8x8=0; i8x8<4; i8x8++){
if(cbp & (1<<i8x8)){
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8;
if( decode_residual(h, gb, h->mb + 16*index, index, scan, s->qscale, 16) <0 ){
return -1;
}
}
}else{
uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
}
}
}
if(cbp&0x30){
for(chroma_idx=0; chroma_idx<2; chroma_idx++)
if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, chroma_qp, 4) < 0){
return -1;
}
}
if(cbp&0x20){
for(chroma_idx=0; chroma_idx<2; chroma_idx++){
for(i4x4=0; i4x4<4; i4x4++){
const int index= 16 + 4*chroma_idx + i4x4;
if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, chroma_qp, 15) < 0){
return -1;
}
}
}
}else{
uint8_t * const nnz= &h->non_zero_count_cache[0];
nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
}
}else{
memset(&h->non_zero_count_cache[8], 0, 8*5);
}
s->current_picture.qscale_table[mb_xy]= s->qscale;
write_back_non_zero_count(h);
return 0;
}
| false |
FFmpeg
|
53c05b1eacd5f7dbfa3651b45e797adaea0a5ff8
|
static int decode_mb(H264Context *h){
MpegEncContext * const s = &h->s;
const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
int mb_type, partition_count, cbp;
s->dsp.clear_blocks(h->mb);
tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
cbp = 0;
if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
if(s->mb_skip_run==-1)
s->mb_skip_run= get_ue_golomb(&s->gb);
if (s->mb_skip_run--) {
int mx, my;
mb_type= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0;
memset(h->non_zero_count[mb_xy], 0, 16+4+4);
memset(h->non_zero_count_cache + 8, 0, 8*5);
if(h->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){
h->mb_field_decoding_flag= get_bits1(&s->gb);
}
if(h->mb_field_decoding_flag)
mb_type|= MB_TYPE_INTERLACED;
fill_caches(h, mb_type);
pred_pskip_motion(h, &mx, &my);
fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
write_back_motion(h, mb_type);
s->current_picture.mb_type[mb_xy]= mb_type;
s->current_picture.qscale_table[mb_xy]= s->qscale;
h->slice_table[ mb_xy ]= h->slice_num;
h->prev_mb_skiped= 1;
return 0;
}
}
if(h->sps.mb_aff ){
if((s->mb_y&1)==0)
h->mb_field_decoding_flag = get_bits1(&s->gb);
}else
h->mb_field_decoding_flag=0;
h->prev_mb_skiped= 0;
mb_type= get_ue_golomb(&s->gb);
if(h->slice_type == B_TYPE){
if(mb_type < 23){
partition_count= b_mb_type_info[mb_type].partition_count;
mb_type= b_mb_type_info[mb_type].type;
}else{
mb_type -= 23;
goto decode_intra_mb;
}
}else if(h->slice_type == P_TYPE ){
if(mb_type < 5){
partition_count= p_mb_type_info[mb_type].partition_count;
mb_type= p_mb_type_info[mb_type].type;
}else{
mb_type -= 5;
goto decode_intra_mb;
}
}else{
assert(h->slice_type == I_TYPE);
decode_intra_mb:
if(mb_type > 25){
av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
return -1;
}
partition_count=0;
cbp= i_mb_type_info[mb_type].cbp;
h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
mb_type= i_mb_type_info[mb_type].type;
}
if(h->mb_field_decoding_flag)
mb_type |= MB_TYPE_INTERLACED;
s->current_picture.mb_type[mb_xy]= mb_type;
h->slice_table[ mb_xy ]= h->slice_num;
if(IS_INTRA_PCM(mb_type)){
const uint8_t *ptr;
int x, y;
align_get_bits(&s->gb);
ptr= s->gb.buffer + get_bits_count(&s->gb);
for(y=0; y<16; y++){
const int index= 4*(y&3) + 64*(y>>2);
for(x=0; x<16; x++){
h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
}
}
for(y=0; y<8; y++){
const int index= 256 + 4*(y&3) + 32*(y>>2);
for(x=0; x<8; x++){
h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
}
}
for(y=0; y<8; y++){
const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
for(x=0; x<8; x++){
h->mb[index + (x&3) + 16*(x>>2)]= *(ptr++);
}
}
skip_bits(&s->gb, 384);
memset(h->non_zero_count[mb_xy], 16, 16+4+4);
s->current_picture.qscale_table[mb_xy]= s->qscale;
return 0;
}
fill_caches(h, mb_type);
if(IS_INTRA(mb_type)){
if(IS_INTRA4x4(mb_type)){
int i;
for(i=0; i<16; i++){
const int mode_coded= !get_bits1(&s->gb);
const int predicted_mode= pred_intra_mode(h, i);
int mode;
if(mode_coded){
const int rem_mode= get_bits(&s->gb, 3);
if(rem_mode<predicted_mode)
mode= rem_mode;
else
mode= rem_mode + 1;
}else{
mode= predicted_mode;
}
h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
}
write_back_intra_pred_mode(h);
if( check_intra4x4_pred_mode(h) < 0)
return -1;
}else{
h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
if(h->intra16x16_pred_mode < 0)
return -1;
}
h->chroma_pred_mode= get_ue_golomb(&s->gb);
h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
if(h->chroma_pred_mode < 0)
return -1;
}else if(partition_count==4){
int i, j, sub_partition_count[4], list, ref[2][4];
if(h->slice_type == B_TYPE){
for(i=0; i<4; i++){
h->sub_mb_type[i]= get_ue_golomb(&s->gb);
if(h->sub_mb_type[i] >=13){
av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
return -1;
}
sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
}
}else{
assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE);
for(i=0; i<4; i++){
h->sub_mb_type[i]= get_ue_golomb(&s->gb);
if(h->sub_mb_type[i] >=4){
av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
return -1;
}
sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
}
}
for(list=0; list<2; list++){
const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
if(ref_count == 0) continue;
for(i=0; i<4; i++){
if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
ref[list][i] = get_te0_golomb(&s->gb, ref_count);
}else{
ref[list][i] = -1;
}
}
}
for(list=0; list<2; list++){
const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
if(ref_count == 0) continue;
for(i=0; i<4; i++){
h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
const int sub_mb_type= h->sub_mb_type[i];
const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
for(j=0; j<sub_partition_count[i]; j++){
int mx, my;
const int index= 4*i + block_width*j;
int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
if(IS_SUB_8X8(sub_mb_type)){
mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
}else if(IS_SUB_8X4(sub_mb_type)){
mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
}else if(IS_SUB_4X8(sub_mb_type)){
mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
}else{
assert(IS_SUB_4X4(sub_mb_type));
mv_cache[ 0 ][0]= mx;
mv_cache[ 0 ][1]= my;
}
}
}else{
uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
p[0] = p[1]=
p[8] = p[9]= 0;
}
}
}
}else if(!IS_DIRECT(mb_type)){
int list, mx, my, i;
we should set ref_idx_l? to 0 if we use that later ...
if(IS_16X16(mb_type)){
for(list=0; list<2; list++){
if(h->ref_count[0]>0){
if(IS_DIR(mb_type, 0, list)){
const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
}
}
}
for(list=0; list<2; list++){
if(IS_DIR(mb_type, 0, list)){
pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
}
}
}
else if(IS_16X8(mb_type)){
for(list=0; list<2; list++){
if(h->ref_count[list]>0){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){
const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
}
}
}
}
for(list=0; list<2; list++){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){
pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
}
}
}
}else{
assert(IS_8X16(mb_type));
for(list=0; list<2; list++){
if(h->ref_count[list]>0){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){ optimize
const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
}
}
}
}
for(list=0; list<2; list++){
for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){
pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
mx += get_se_golomb(&s->gb);
my += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", mx, my);
fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
}
}
}
}
}
if(IS_INTER(mb_type))
write_back_motion(h, mb_type);
if(!IS_INTRA16x16(mb_type)){
cbp= get_ue_golomb(&s->gb);
if(cbp > 47){
av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
return -1;
}
if(IS_INTRA4x4(mb_type))
cbp= golomb_to_intra4x4_cbp[cbp];
else
cbp= golomb_to_inter_cbp[cbp];
}
if(cbp || IS_INTRA16x16(mb_type)){
int i8x8, i4x4, chroma_idx;
int chroma_qp, dquant;
GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
const uint8_t *scan, *dc_scan;
if(IS_INTERLACED(mb_type)){
scan= field_scan;
dc_scan= luma_dc_field_scan;
}else{
scan= zigzag_scan;
dc_scan= luma_dc_zigzag_scan;
}
dquant= get_se_golomb(&s->gb);
if( dquant > 25 || dquant < -26 ){
av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
return -1;
}
s->qscale += dquant;
if(((unsigned)s->qscale) > 51){
if(s->qscale<0) s->qscale+= 52;
else s->qscale-= 52;
}
h->chroma_qp= chroma_qp= get_chroma_qp(h, s->qscale);
if(IS_INTRA16x16(mb_type)){
if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, s->qscale, 16) < 0){
return -1; continue if partotioned and other retirn -1 too
}
assert((cbp&15) == 0 || (cbp&15) == 15);
if(cbp&15){
for(i8x8=0; i8x8<4; i8x8++){
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8;
if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, s->qscale, 15) < 0 ){
return -1;
}
}
}
}else{
fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
}
}else{
for(i8x8=0; i8x8<4; i8x8++){
if(cbp & (1<<i8x8)){
for(i4x4=0; i4x4<4; i4x4++){
const int index= i4x4 + 4*i8x8;
if( decode_residual(h, gb, h->mb + 16*index, index, scan, s->qscale, 16) <0 ){
return -1;
}
}
}else{
uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
}
}
}
if(cbp&0x30){
for(chroma_idx=0; chroma_idx<2; chroma_idx++)
if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, chroma_qp, 4) < 0){
return -1;
}
}
if(cbp&0x20){
for(chroma_idx=0; chroma_idx<2; chroma_idx++){
for(i4x4=0; i4x4<4; i4x4++){
const int index= 16 + 4*chroma_idx + i4x4;
if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, chroma_qp, 15) < 0){
return -1;
}
}
}
}else{
uint8_t * const nnz= &h->non_zero_count_cache[0];
nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
}
}else{
memset(&h->non_zero_count_cache[8], 0, 8*5);
}
s->current_picture.qscale_table[mb_xy]= s->qscale;
write_back_non_zero_count(h);
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(H264Context *VAR_0){
MpegEncContext * const s = &VAR_0->s;
const int VAR_1= s->mb_x + s->mb_y*s->mb_stride;
int VAR_2, VAR_3, VAR_4;
s->dsp.clear_blocks(VAR_0->mb);
tprintf("pic:%d mb:%d/%d\n", VAR_0->frame_num, s->mb_x, s->mb_y);
VAR_4 = 0;
if(VAR_0->slice_type != I_TYPE && VAR_0->slice_type != SI_TYPE){
if(s->mb_skip_run==-1)
s->mb_skip_run= get_ue_golomb(&s->gb);
if (s->mb_skip_run--) {
int VAR_23, VAR_23;
VAR_2= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0;
memset(VAR_0->non_zero_count[VAR_1], 0, 16+4+4);
memset(VAR_0->non_zero_count_cache + 8, 0, 8*5);
if(VAR_0->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){
VAR_0->mb_field_decoding_flag= get_bits1(&s->gb);
}
if(VAR_0->mb_field_decoding_flag)
VAR_2|= MB_TYPE_INTERLACED;
fill_caches(VAR_0, VAR_2);
pred_pskip_motion(VAR_0, &VAR_23, &VAR_23);
fill_rectangle(&VAR_0->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
fill_rectangle( VAR_0->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(VAR_23,VAR_23), 4);
write_back_motion(VAR_0, VAR_2);
s->current_picture.VAR_2[VAR_1]= VAR_2;
s->current_picture.qscale_table[VAR_1]= s->qscale;
VAR_0->slice_table[ VAR_1 ]= VAR_0->slice_num;
VAR_0->prev_mb_skiped= 1;
return 0;
}
}
if(VAR_0->sps.mb_aff ){
if((s->mb_y&1)==0)
VAR_0->mb_field_decoding_flag = get_bits1(&s->gb);
}else
VAR_0->mb_field_decoding_flag=0;
VAR_0->prev_mb_skiped= 0;
VAR_2= get_ue_golomb(&s->gb);
if(VAR_0->slice_type == B_TYPE){
if(VAR_2 < 23){
VAR_3= b_mb_type_info[VAR_2].VAR_3;
VAR_2= b_mb_type_info[VAR_2].type;
}else{
VAR_2 -= 23;
goto decode_intra_mb;
}
}else if(VAR_0->slice_type == P_TYPE ){
if(VAR_2 < 5){
VAR_3= p_mb_type_info[VAR_2].VAR_3;
VAR_2= p_mb_type_info[VAR_2].type;
}else{
VAR_2 -= 5;
goto decode_intra_mb;
}
}else{
assert(VAR_0->slice_type == I_TYPE);
decode_intra_mb:
if(VAR_2 > 25){
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "VAR_2 %d in %c slice to large at %d %d\n", VAR_2, av_get_pict_type_char(VAR_0->slice_type), s->mb_x, s->mb_y);
return -1;
}
VAR_3=0;
VAR_4= i_mb_type_info[VAR_2].VAR_4;
VAR_0->intra16x16_pred_mode= i_mb_type_info[VAR_2].pred_mode;
VAR_2= i_mb_type_info[VAR_2].type;
}
if(VAR_0->mb_field_decoding_flag)
VAR_2 |= MB_TYPE_INTERLACED;
s->current_picture.VAR_2[VAR_1]= VAR_2;
VAR_0->slice_table[ VAR_1 ]= VAR_0->slice_num;
if(IS_INTRA_PCM(VAR_2)){
const uint8_t *VAR_7;
int VAR_8, VAR_9;
align_get_bits(&s->gb);
VAR_7= s->gb.buffer + get_bits_count(&s->gb);
for(VAR_9=0; VAR_9<16; VAR_9++){
const int VAR_29= 4*(VAR_9&3) + 64*(VAR_9>>2);
for(VAR_8=0; VAR_8<16; VAR_8++){
VAR_0->mb[VAR_29 + (VAR_8&3) + 16*(VAR_8>>2)]= *(VAR_7++);
}
}
for(VAR_9=0; VAR_9<8; VAR_9++){
const int VAR_29= 256 + 4*(VAR_9&3) + 32*(VAR_9>>2);
for(VAR_8=0; VAR_8<8; VAR_8++){
VAR_0->mb[VAR_29 + (VAR_8&3) + 16*(VAR_8>>2)]= *(VAR_7++);
}
}
for(VAR_9=0; VAR_9<8; VAR_9++){
const int VAR_29= 256 + 64 + 4*(VAR_9&3) + 32*(VAR_9>>2);
for(VAR_8=0; VAR_8<8; VAR_8++){
VAR_0->mb[VAR_29 + (VAR_8&3) + 16*(VAR_8>>2)]= *(VAR_7++);
}
}
skip_bits(&s->gb, 384);
memset(VAR_0->non_zero_count[VAR_1], 16, 16+4+4);
s->current_picture.qscale_table[VAR_1]= s->qscale;
return 0;
}
fill_caches(VAR_0, VAR_2);
if(IS_INTRA(VAR_2)){
if(IS_INTRA4x4(VAR_2)){
int VAR_23;
for(VAR_23=0; VAR_23<16; VAR_23++){
const int VAR_12= !get_bits1(&s->gb);
const int VAR_13= pred_intra_mode(VAR_0, VAR_23);
int VAR_14;
if(VAR_12){
const int VAR_15= get_bits(&s->gb, 3);
if(VAR_15<VAR_13)
VAR_14= VAR_15;
else
VAR_14= VAR_15 + 1;
}else{
VAR_14= VAR_13;
}
VAR_0->intra4x4_pred_mode_cache[ scan8[VAR_23] ] = VAR_14;
}
write_back_intra_pred_mode(VAR_0);
if( check_intra4x4_pred_mode(VAR_0) < 0)
return -1;
}else{
VAR_0->intra16x16_pred_mode= check_intra_pred_mode(VAR_0, VAR_0->intra16x16_pred_mode);
if(VAR_0->intra16x16_pred_mode < 0)
return -1;
}
VAR_0->chroma_pred_mode= get_ue_golomb(&s->gb);
VAR_0->chroma_pred_mode= check_intra_pred_mode(VAR_0, VAR_0->chroma_pred_mode);
if(VAR_0->chroma_pred_mode < 0)
return -1;
}else if(VAR_3==4){
int VAR_23, VAR_16, VAR_17[4], VAR_23, VAR_19[2][4];
if(VAR_0->slice_type == B_TYPE){
for(VAR_23=0; VAR_23<4; VAR_23++){
VAR_0->VAR_21[VAR_23]= get_ue_golomb(&s->gb);
if(VAR_0->VAR_21[VAR_23] >=13){
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "B VAR_21 %d out of range at %d %d\n", VAR_0->VAR_21[VAR_23], s->mb_x, s->mb_y);
return -1;
}
VAR_17[VAR_23]= b_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].VAR_3;
VAR_0->VAR_21[VAR_23]= b_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].type;
}
}else{
assert(VAR_0->slice_type == P_TYPE || VAR_0->slice_type == SP_TYPE);
for(VAR_23=0; VAR_23<4; VAR_23++){
VAR_0->VAR_21[VAR_23]= get_ue_golomb(&s->gb);
if(VAR_0->VAR_21[VAR_23] >=4){
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "P VAR_21 %d out of range at %d %d\n", VAR_0->VAR_21[VAR_23], s->mb_x, s->mb_y);
return -1;
}
VAR_17[VAR_23]= p_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].VAR_3;
VAR_0->VAR_21[VAR_23]= p_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].type;
}
}
for(VAR_23=0; VAR_23<2; VAR_23++){
const int VAR_21= IS_REF0(VAR_2) ? 1 : VAR_0->VAR_21[VAR_23];
if(VAR_21 == 0) continue;
for(VAR_23=0; VAR_23<4; VAR_23++){
if(IS_DIR(VAR_0->VAR_21[VAR_23], 0, VAR_23) && !IS_DIRECT(VAR_0->VAR_21[VAR_23])){
VAR_19[VAR_23][VAR_23] = get_te0_golomb(&s->gb, VAR_21);
}else{
VAR_19[VAR_23][VAR_23] = -1;
}
}
}
for(VAR_23=0; VAR_23<2; VAR_23++){
const int VAR_21= IS_REF0(VAR_2) ? 1 : VAR_0->VAR_21[VAR_23];
if(VAR_21 == 0) continue;
for(VAR_23=0; VAR_23<4; VAR_23++){
VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23] ]=VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23]+1 ]=
VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23]+8 ]=VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23]+9 ]= VAR_19[VAR_23][VAR_23];
if(IS_DIR(VAR_0->VAR_21[VAR_23], 0, VAR_23) && !IS_DIRECT(VAR_0->VAR_21[VAR_23])){
const int VAR_21= VAR_0->VAR_21[VAR_23];
const int VAR_22= (VAR_21 & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
for(VAR_16=0; VAR_16<VAR_17[VAR_23]; VAR_16++){
int VAR_23, VAR_23;
const int VAR_29= 4*VAR_23 + VAR_22*VAR_16;
int16_t (* mv_cache)[2]= &VAR_0->mv_cache[VAR_23][ scan8[VAR_29] ];
pred_motion(VAR_0, VAR_29, VAR_22, VAR_23, VAR_0->ref_cache[VAR_23][ scan8[VAR_29] ], &VAR_23, &VAR_23);
VAR_23 += get_se_golomb(&s->gb);
VAR_23 += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", VAR_23, VAR_23);
if(IS_SUB_8X8(VAR_21)){
mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= VAR_23;
mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= VAR_23;
}else if(IS_SUB_8X4(VAR_21)){
mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= VAR_23;
mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= VAR_23;
}else if(IS_SUB_4X8(VAR_21)){
mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= VAR_23;
mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= VAR_23;
}else{
assert(IS_SUB_4X4(VAR_21));
mv_cache[ 0 ][0]= VAR_23;
mv_cache[ 0 ][1]= VAR_23;
}
}
}else{
uint32_t *p= (uint32_t *)&VAR_0->mv_cache[VAR_23][ scan8[4*VAR_23] ][0];
p[0] = p[1]=
p[8] = p[9]= 0;
}
}
}
}else if(!IS_DIRECT(VAR_2)){
int VAR_23, VAR_23, VAR_23, VAR_23;
we should set ref_idx_l? to 0 if we use that later ...
if(IS_16X16(VAR_2)){
for(VAR_23=0; VAR_23<2; VAR_23++){
if(VAR_0->VAR_21[0]>0){
if(IS_DIR(VAR_2, 0, VAR_23)){
const int val= get_te0_golomb(&s->gb, VAR_0->VAR_21[VAR_23]);
fill_rectangle(&VAR_0->ref_cache[VAR_23][ scan8[0] ], 4, 4, 8, val, 1);
}
}
}
for(VAR_23=0; VAR_23<2; VAR_23++){
if(IS_DIR(VAR_2, 0, VAR_23)){
pred_motion(VAR_0, 0, 4, VAR_23, VAR_0->ref_cache[VAR_23][ scan8[0] ], &VAR_23, &VAR_23);
VAR_23 += get_se_golomb(&s->gb);
VAR_23 += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", VAR_23, VAR_23);
fill_rectangle(VAR_0->mv_cache[VAR_23][ scan8[0] ], 4, 4, 8, pack16to32(VAR_23,VAR_23), 4);
}
}
}
else if(IS_16X8(VAR_2)){
for(VAR_23=0; VAR_23<2; VAR_23++){
if(VAR_0->VAR_21[VAR_23]>0){
for(VAR_23=0; VAR_23<2; VAR_23++){
if(IS_DIR(VAR_2, VAR_23, VAR_23)){
const int val= get_te0_golomb(&s->gb, VAR_0->VAR_21[VAR_23]);
fill_rectangle(&VAR_0->ref_cache[VAR_23][ scan8[0] + 16*VAR_23 ], 4, 2, 8, val, 1);
}
}
}
}
for(VAR_23=0; VAR_23<2; VAR_23++){
for(VAR_23=0; VAR_23<2; VAR_23++){
if(IS_DIR(VAR_2, VAR_23, VAR_23)){
pred_16x8_motion(VAR_0, 8*VAR_23, VAR_23, VAR_0->ref_cache[VAR_23][scan8[0] + 16*VAR_23], &VAR_23, &VAR_23);
VAR_23 += get_se_golomb(&s->gb);
VAR_23 += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", VAR_23, VAR_23);
fill_rectangle(VAR_0->mv_cache[VAR_23][ scan8[0] + 16*VAR_23 ], 4, 2, 8, pack16to32(VAR_23,VAR_23), 4);
}
}
}
}else{
assert(IS_8X16(VAR_2));
for(VAR_23=0; VAR_23<2; VAR_23++){
if(VAR_0->VAR_21[VAR_23]>0){
for(VAR_23=0; VAR_23<2; VAR_23++){
if(IS_DIR(VAR_2, VAR_23, VAR_23)){ optimize
const int val= get_te0_golomb(&s->gb, VAR_0->VAR_21[VAR_23]);
fill_rectangle(&VAR_0->ref_cache[VAR_23][ scan8[0] + 2*VAR_23 ], 2, 4, 8, val, 1);
}
}
}
}
for(VAR_23=0; VAR_23<2; VAR_23++){
for(VAR_23=0; VAR_23<2; VAR_23++){
if(IS_DIR(VAR_2, VAR_23, VAR_23)){
pred_8x16_motion(VAR_0, VAR_23*4, VAR_23, VAR_0->ref_cache[VAR_23][ scan8[0] + 2*VAR_23 ], &VAR_23, &VAR_23);
VAR_23 += get_se_golomb(&s->gb);
VAR_23 += get_se_golomb(&s->gb);
tprintf("final mv:%d %d\n", VAR_23, VAR_23);
fill_rectangle(VAR_0->mv_cache[VAR_23][ scan8[0] + 2*VAR_23 ], 2, 4, 8, pack16to32(VAR_23,VAR_23), 4);
}
}
}
}
}
if(IS_INTER(VAR_2))
write_back_motion(VAR_0, VAR_2);
if(!IS_INTRA16x16(VAR_2)){
VAR_4= get_ue_golomb(&s->gb);
if(VAR_4 > 47){
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "VAR_4 too large (%d) at %d %d\n", VAR_4, s->mb_x, s->mb_y);
return -1;
}
if(IS_INTRA4x4(VAR_2))
VAR_4= golomb_to_intra4x4_cbp[VAR_4];
else
VAR_4= golomb_to_inter_cbp[VAR_4];
}
if(VAR_4 || IS_INTRA16x16(VAR_2)){
int VAR_23, VAR_24, VAR_25;
int VAR_26, VAR_27;
GetBitContext *gb= IS_INTRA(VAR_2) ? VAR_0->intra_gb_ptr : VAR_0->inter_gb_ptr;
const uint8_t *VAR_28, *dc_scan;
if(IS_INTERLACED(VAR_2)){
VAR_28= field_scan;
dc_scan= luma_dc_field_scan;
}else{
VAR_28= zigzag_scan;
dc_scan= luma_dc_zigzag_scan;
}
VAR_27= get_se_golomb(&s->gb);
if( VAR_27 > 25 || VAR_27 < -26 ){
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "VAR_27 out of range (%d) at %d %d\n", VAR_27, s->mb_x, s->mb_y);
return -1;
}
s->qscale += VAR_27;
if(((unsigned)s->qscale) > 51){
if(s->qscale<0) s->qscale+= 52;
else s->qscale-= 52;
}
VAR_0->VAR_26= VAR_26= get_chroma_qp(VAR_0, s->qscale);
if(IS_INTRA16x16(VAR_2)){
if( decode_residual(VAR_0, VAR_0->intra_gb_ptr, VAR_0->mb, LUMA_DC_BLOCK_INDEX, dc_scan, s->qscale, 16) < 0){
return -1; continue if partotioned and other retirn -1 too
}
assert((VAR_4&15) == 0 || (VAR_4&15) == 15);
if(VAR_4&15){
for(VAR_23=0; VAR_23<4; VAR_23++){
for(VAR_24=0; VAR_24<4; VAR_24++){
const int VAR_29= VAR_24 + 4*VAR_23;
if( decode_residual(VAR_0, VAR_0->intra_gb_ptr, VAR_0->mb + 16*VAR_29, VAR_29, VAR_28 + 1, s->qscale, 15) < 0 ){
return -1;
}
}
}
}else{
fill_rectangle(&VAR_0->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
}
}else{
for(VAR_23=0; VAR_23<4; VAR_23++){
if(VAR_4 & (1<<VAR_23)){
for(VAR_24=0; VAR_24<4; VAR_24++){
const int VAR_29= VAR_24 + 4*VAR_23;
if( decode_residual(VAR_0, gb, VAR_0->mb + 16*VAR_29, VAR_29, VAR_28, s->qscale, 16) <0 ){
return -1;
}
}
}else{
uint8_t * const nnz= &VAR_0->non_zero_count_cache[ scan8[4*VAR_23] ];
nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
}
}
}
if(VAR_4&0x30){
for(VAR_25=0; VAR_25<2; VAR_25++)
if( decode_residual(VAR_0, gb, VAR_0->mb + 256 + 16*4*VAR_25, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, VAR_26, 4) < 0){
return -1;
}
}
if(VAR_4&0x20){
for(VAR_25=0; VAR_25<2; VAR_25++){
for(VAR_24=0; VAR_24<4; VAR_24++){
const int VAR_29= 16 + 4*VAR_25 + VAR_24;
if( decode_residual(VAR_0, gb, VAR_0->mb + 16*VAR_29, VAR_29, VAR_28 + 1, VAR_26, 15) < 0){
return -1;
}
}
}
}else{
uint8_t * const nnz= &VAR_0->non_zero_count_cache[0];
nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
}
}else{
memset(&VAR_0->non_zero_count_cache[8], 0, 8*5);
}
s->current_picture.qscale_table[VAR_1]= s->qscale;
write_back_non_zero_count(VAR_0);
return 0;
}
|
[
"static int FUNC_0(H264Context *VAR_0){",
"MpegEncContext * const s = &VAR_0->s;",
"const int VAR_1= s->mb_x + s->mb_y*s->mb_stride;",
"int VAR_2, VAR_3, VAR_4;",
"s->dsp.clear_blocks(VAR_0->mb);",
"tprintf(\"pic:%d mb:%d/%d\\n\", VAR_0->frame_num, s->mb_x, s->mb_y);",
"VAR_4 = 0;",
"if(VAR_0->slice_type != I_TYPE && VAR_0->slice_type != SI_TYPE){",
"if(s->mb_skip_run==-1)\ns->mb_skip_run= get_ue_golomb(&s->gb);",
"if (s->mb_skip_run--) {",
"int VAR_23, VAR_23;",
"VAR_2= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0;",
"memset(VAR_0->non_zero_count[VAR_1], 0, 16+4+4);",
"memset(VAR_0->non_zero_count_cache + 8, 0, 8*5);",
"if(VAR_0->sps.mb_aff && s->mb_skip_run==0 && (s->mb_y&1)==0){",
"VAR_0->mb_field_decoding_flag= get_bits1(&s->gb);",
"}",
"if(VAR_0->mb_field_decoding_flag)\nVAR_2|= MB_TYPE_INTERLACED;",
"fill_caches(VAR_0, VAR_2);",
"pred_pskip_motion(VAR_0, &VAR_23, &VAR_23);",
"fill_rectangle(&VAR_0->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);",
"fill_rectangle( VAR_0->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(VAR_23,VAR_23), 4);",
"write_back_motion(VAR_0, VAR_2);",
"s->current_picture.VAR_2[VAR_1]= VAR_2;",
"s->current_picture.qscale_table[VAR_1]= s->qscale;",
"VAR_0->slice_table[ VAR_1 ]= VAR_0->slice_num;",
"VAR_0->prev_mb_skiped= 1;",
"return 0;",
"}",
"}",
"if(VAR_0->sps.mb_aff ){",
"if((s->mb_y&1)==0)\nVAR_0->mb_field_decoding_flag = get_bits1(&s->gb);",
"}else",
"VAR_0->mb_field_decoding_flag=0;",
"VAR_0->prev_mb_skiped= 0;",
"VAR_2= get_ue_golomb(&s->gb);",
"if(VAR_0->slice_type == B_TYPE){",
"if(VAR_2 < 23){",
"VAR_3= b_mb_type_info[VAR_2].VAR_3;",
"VAR_2= b_mb_type_info[VAR_2].type;",
"}else{",
"VAR_2 -= 23;",
"goto decode_intra_mb;",
"}",
"}else if(VAR_0->slice_type == P_TYPE ){",
"if(VAR_2 < 5){",
"VAR_3= p_mb_type_info[VAR_2].VAR_3;",
"VAR_2= p_mb_type_info[VAR_2].type;",
"}else{",
"VAR_2 -= 5;",
"goto decode_intra_mb;",
"}",
"}else{",
"assert(VAR_0->slice_type == I_TYPE);",
"decode_intra_mb:\nif(VAR_2 > 25){",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"VAR_2 %d in %c slice to large at %d %d\\n\", VAR_2, av_get_pict_type_char(VAR_0->slice_type), s->mb_x, s->mb_y);",
"return -1;",
"}",
"VAR_3=0;",
"VAR_4= i_mb_type_info[VAR_2].VAR_4;",
"VAR_0->intra16x16_pred_mode= i_mb_type_info[VAR_2].pred_mode;",
"VAR_2= i_mb_type_info[VAR_2].type;",
"}",
"if(VAR_0->mb_field_decoding_flag)\nVAR_2 |= MB_TYPE_INTERLACED;",
"s->current_picture.VAR_2[VAR_1]= VAR_2;",
"VAR_0->slice_table[ VAR_1 ]= VAR_0->slice_num;",
"if(IS_INTRA_PCM(VAR_2)){",
"const uint8_t *VAR_7;",
"int VAR_8, VAR_9;",
"align_get_bits(&s->gb);",
"VAR_7= s->gb.buffer + get_bits_count(&s->gb);",
"for(VAR_9=0; VAR_9<16; VAR_9++){",
"const int VAR_29= 4*(VAR_9&3) + 64*(VAR_9>>2);",
"for(VAR_8=0; VAR_8<16; VAR_8++){",
"VAR_0->mb[VAR_29 + (VAR_8&3) + 16*(VAR_8>>2)]= *(VAR_7++);",
"}",
"}",
"for(VAR_9=0; VAR_9<8; VAR_9++){",
"const int VAR_29= 256 + 4*(VAR_9&3) + 32*(VAR_9>>2);",
"for(VAR_8=0; VAR_8<8; VAR_8++){",
"VAR_0->mb[VAR_29 + (VAR_8&3) + 16*(VAR_8>>2)]= *(VAR_7++);",
"}",
"}",
"for(VAR_9=0; VAR_9<8; VAR_9++){",
"const int VAR_29= 256 + 64 + 4*(VAR_9&3) + 32*(VAR_9>>2);",
"for(VAR_8=0; VAR_8<8; VAR_8++){",
"VAR_0->mb[VAR_29 + (VAR_8&3) + 16*(VAR_8>>2)]= *(VAR_7++);",
"}",
"}",
"skip_bits(&s->gb, 384);",
"memset(VAR_0->non_zero_count[VAR_1], 16, 16+4+4);",
"s->current_picture.qscale_table[VAR_1]= s->qscale;",
"return 0;",
"}",
"fill_caches(VAR_0, VAR_2);",
"if(IS_INTRA(VAR_2)){",
"if(IS_INTRA4x4(VAR_2)){",
"int VAR_23;",
"for(VAR_23=0; VAR_23<16; VAR_23++){",
"const int VAR_12= !get_bits1(&s->gb);",
"const int VAR_13= pred_intra_mode(VAR_0, VAR_23);",
"int VAR_14;",
"if(VAR_12){",
"const int VAR_15= get_bits(&s->gb, 3);",
"if(VAR_15<VAR_13)\nVAR_14= VAR_15;",
"else\nVAR_14= VAR_15 + 1;",
"}else{",
"VAR_14= VAR_13;",
"}",
"VAR_0->intra4x4_pred_mode_cache[ scan8[VAR_23] ] = VAR_14;",
"}",
"write_back_intra_pred_mode(VAR_0);",
"if( check_intra4x4_pred_mode(VAR_0) < 0)\nreturn -1;",
"}else{",
"VAR_0->intra16x16_pred_mode= check_intra_pred_mode(VAR_0, VAR_0->intra16x16_pred_mode);",
"if(VAR_0->intra16x16_pred_mode < 0)\nreturn -1;",
"}",
"VAR_0->chroma_pred_mode= get_ue_golomb(&s->gb);",
"VAR_0->chroma_pred_mode= check_intra_pred_mode(VAR_0, VAR_0->chroma_pred_mode);",
"if(VAR_0->chroma_pred_mode < 0)\nreturn -1;",
"}else if(VAR_3==4){",
"int VAR_23, VAR_16, VAR_17[4], VAR_23, VAR_19[2][4];",
"if(VAR_0->slice_type == B_TYPE){",
"for(VAR_23=0; VAR_23<4; VAR_23++){",
"VAR_0->VAR_21[VAR_23]= get_ue_golomb(&s->gb);",
"if(VAR_0->VAR_21[VAR_23] >=13){",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"B VAR_21 %d out of range at %d %d\\n\", VAR_0->VAR_21[VAR_23], s->mb_x, s->mb_y);",
"return -1;",
"}",
"VAR_17[VAR_23]= b_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].VAR_3;",
"VAR_0->VAR_21[VAR_23]= b_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].type;",
"}",
"}else{",
"assert(VAR_0->slice_type == P_TYPE || VAR_0->slice_type == SP_TYPE);",
"for(VAR_23=0; VAR_23<4; VAR_23++){",
"VAR_0->VAR_21[VAR_23]= get_ue_golomb(&s->gb);",
"if(VAR_0->VAR_21[VAR_23] >=4){",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"P VAR_21 %d out of range at %d %d\\n\", VAR_0->VAR_21[VAR_23], s->mb_x, s->mb_y);",
"return -1;",
"}",
"VAR_17[VAR_23]= p_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].VAR_3;",
"VAR_0->VAR_21[VAR_23]= p_sub_mb_type_info[ VAR_0->VAR_21[VAR_23] ].type;",
"}",
"}",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"const int VAR_21= IS_REF0(VAR_2) ? 1 : VAR_0->VAR_21[VAR_23];",
"if(VAR_21 == 0) continue;",
"for(VAR_23=0; VAR_23<4; VAR_23++){",
"if(IS_DIR(VAR_0->VAR_21[VAR_23], 0, VAR_23) && !IS_DIRECT(VAR_0->VAR_21[VAR_23])){",
"VAR_19[VAR_23][VAR_23] = get_te0_golomb(&s->gb, VAR_21);",
"}else{",
"VAR_19[VAR_23][VAR_23] = -1;",
"}",
"}",
"}",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"const int VAR_21= IS_REF0(VAR_2) ? 1 : VAR_0->VAR_21[VAR_23];",
"if(VAR_21 == 0) continue;",
"for(VAR_23=0; VAR_23<4; VAR_23++){",
"VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23] ]=VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23]+1 ]=\nVAR_0->ref_cache[VAR_23][ scan8[4*VAR_23]+8 ]=VAR_0->ref_cache[VAR_23][ scan8[4*VAR_23]+9 ]= VAR_19[VAR_23][VAR_23];",
"if(IS_DIR(VAR_0->VAR_21[VAR_23], 0, VAR_23) && !IS_DIRECT(VAR_0->VAR_21[VAR_23])){",
"const int VAR_21= VAR_0->VAR_21[VAR_23];",
"const int VAR_22= (VAR_21 & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;",
"for(VAR_16=0; VAR_16<VAR_17[VAR_23]; VAR_16++){",
"int VAR_23, VAR_23;",
"const int VAR_29= 4*VAR_23 + VAR_22*VAR_16;",
"int16_t (* mv_cache)[2]= &VAR_0->mv_cache[VAR_23][ scan8[VAR_29] ];",
"pred_motion(VAR_0, VAR_29, VAR_22, VAR_23, VAR_0->ref_cache[VAR_23][ scan8[VAR_29] ], &VAR_23, &VAR_23);",
"VAR_23 += get_se_golomb(&s->gb);",
"VAR_23 += get_se_golomb(&s->gb);",
"tprintf(\"final mv:%d %d\\n\", VAR_23, VAR_23);",
"if(IS_SUB_8X8(VAR_21)){",
"mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=\nmv_cache[ 8 ][0]= mv_cache[ 9 ][0]= VAR_23;",
"mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=\nmv_cache[ 8 ][1]= mv_cache[ 9 ][1]= VAR_23;",
"}else if(IS_SUB_8X4(VAR_21)){",
"mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= VAR_23;",
"mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= VAR_23;",
"}else if(IS_SUB_4X8(VAR_21)){",
"mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= VAR_23;",
"mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= VAR_23;",
"}else{",
"assert(IS_SUB_4X4(VAR_21));",
"mv_cache[ 0 ][0]= VAR_23;",
"mv_cache[ 0 ][1]= VAR_23;",
"}",
"}",
"}else{",
"uint32_t *p= (uint32_t *)&VAR_0->mv_cache[VAR_23][ scan8[4*VAR_23] ][0];",
"p[0] = p[1]=\np[8] = p[9]= 0;",
"}",
"}",
"}",
"}else if(!IS_DIRECT(VAR_2)){",
"int VAR_23, VAR_23, VAR_23, VAR_23;",
"we should set ref_idx_l? to 0 if we use that later ...\nif(IS_16X16(VAR_2)){",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(VAR_0->VAR_21[0]>0){",
"if(IS_DIR(VAR_2, 0, VAR_23)){",
"const int val= get_te0_golomb(&s->gb, VAR_0->VAR_21[VAR_23]);",
"fill_rectangle(&VAR_0->ref_cache[VAR_23][ scan8[0] ], 4, 4, 8, val, 1);",
"}",
"}",
"}",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(IS_DIR(VAR_2, 0, VAR_23)){",
"pred_motion(VAR_0, 0, 4, VAR_23, VAR_0->ref_cache[VAR_23][ scan8[0] ], &VAR_23, &VAR_23);",
"VAR_23 += get_se_golomb(&s->gb);",
"VAR_23 += get_se_golomb(&s->gb);",
"tprintf(\"final mv:%d %d\\n\", VAR_23, VAR_23);",
"fill_rectangle(VAR_0->mv_cache[VAR_23][ scan8[0] ], 4, 4, 8, pack16to32(VAR_23,VAR_23), 4);",
"}",
"}",
"}",
"else if(IS_16X8(VAR_2)){",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(VAR_0->VAR_21[VAR_23]>0){",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(IS_DIR(VAR_2, VAR_23, VAR_23)){",
"const int val= get_te0_golomb(&s->gb, VAR_0->VAR_21[VAR_23]);",
"fill_rectangle(&VAR_0->ref_cache[VAR_23][ scan8[0] + 16*VAR_23 ], 4, 2, 8, val, 1);",
"}",
"}",
"}",
"}",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(IS_DIR(VAR_2, VAR_23, VAR_23)){",
"pred_16x8_motion(VAR_0, 8*VAR_23, VAR_23, VAR_0->ref_cache[VAR_23][scan8[0] + 16*VAR_23], &VAR_23, &VAR_23);",
"VAR_23 += get_se_golomb(&s->gb);",
"VAR_23 += get_se_golomb(&s->gb);",
"tprintf(\"final mv:%d %d\\n\", VAR_23, VAR_23);",
"fill_rectangle(VAR_0->mv_cache[VAR_23][ scan8[0] + 16*VAR_23 ], 4, 2, 8, pack16to32(VAR_23,VAR_23), 4);",
"}",
"}",
"}",
"}else{",
"assert(IS_8X16(VAR_2));",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(VAR_0->VAR_21[VAR_23]>0){",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(IS_DIR(VAR_2, VAR_23, VAR_23)){ optimize",
"const int val= get_te0_golomb(&s->gb, VAR_0->VAR_21[VAR_23]);",
"fill_rectangle(&VAR_0->ref_cache[VAR_23][ scan8[0] + 2*VAR_23 ], 2, 4, 8, val, 1);",
"}",
"}",
"}",
"}",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"for(VAR_23=0; VAR_23<2; VAR_23++){",
"if(IS_DIR(VAR_2, VAR_23, VAR_23)){",
"pred_8x16_motion(VAR_0, VAR_23*4, VAR_23, VAR_0->ref_cache[VAR_23][ scan8[0] + 2*VAR_23 ], &VAR_23, &VAR_23);",
"VAR_23 += get_se_golomb(&s->gb);",
"VAR_23 += get_se_golomb(&s->gb);",
"tprintf(\"final mv:%d %d\\n\", VAR_23, VAR_23);",
"fill_rectangle(VAR_0->mv_cache[VAR_23][ scan8[0] + 2*VAR_23 ], 2, 4, 8, pack16to32(VAR_23,VAR_23), 4);",
"}",
"}",
"}",
"}",
"}",
"if(IS_INTER(VAR_2))\nwrite_back_motion(VAR_0, VAR_2);",
"if(!IS_INTRA16x16(VAR_2)){",
"VAR_4= get_ue_golomb(&s->gb);",
"if(VAR_4 > 47){",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"VAR_4 too large (%d) at %d %d\\n\", VAR_4, s->mb_x, s->mb_y);",
"return -1;",
"}",
"if(IS_INTRA4x4(VAR_2))\nVAR_4= golomb_to_intra4x4_cbp[VAR_4];",
"else\nVAR_4= golomb_to_inter_cbp[VAR_4];",
"}",
"if(VAR_4 || IS_INTRA16x16(VAR_2)){",
"int VAR_23, VAR_24, VAR_25;",
"int VAR_26, VAR_27;",
"GetBitContext *gb= IS_INTRA(VAR_2) ? VAR_0->intra_gb_ptr : VAR_0->inter_gb_ptr;",
"const uint8_t *VAR_28, *dc_scan;",
"if(IS_INTERLACED(VAR_2)){",
"VAR_28= field_scan;",
"dc_scan= luma_dc_field_scan;",
"}else{",
"VAR_28= zigzag_scan;",
"dc_scan= luma_dc_zigzag_scan;",
"}",
"VAR_27= get_se_golomb(&s->gb);",
"if( VAR_27 > 25 || VAR_27 < -26 ){",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"VAR_27 out of range (%d) at %d %d\\n\", VAR_27, s->mb_x, s->mb_y);",
"return -1;",
"}",
"s->qscale += VAR_27;",
"if(((unsigned)s->qscale) > 51){",
"if(s->qscale<0) s->qscale+= 52;",
"else s->qscale-= 52;",
"}",
"VAR_0->VAR_26= VAR_26= get_chroma_qp(VAR_0, s->qscale);",
"if(IS_INTRA16x16(VAR_2)){",
"if( decode_residual(VAR_0, VAR_0->intra_gb_ptr, VAR_0->mb, LUMA_DC_BLOCK_INDEX, dc_scan, s->qscale, 16) < 0){",
"return -1; continue if partotioned and other retirn -1 too",
"}",
"assert((VAR_4&15) == 0 || (VAR_4&15) == 15);",
"if(VAR_4&15){",
"for(VAR_23=0; VAR_23<4; VAR_23++){",
"for(VAR_24=0; VAR_24<4; VAR_24++){",
"const int VAR_29= VAR_24 + 4*VAR_23;",
"if( decode_residual(VAR_0, VAR_0->intra_gb_ptr, VAR_0->mb + 16*VAR_29, VAR_29, VAR_28 + 1, s->qscale, 15) < 0 ){",
"return -1;",
"}",
"}",
"}",
"}else{",
"fill_rectangle(&VAR_0->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);",
"}",
"}else{",
"for(VAR_23=0; VAR_23<4; VAR_23++){",
"if(VAR_4 & (1<<VAR_23)){",
"for(VAR_24=0; VAR_24<4; VAR_24++){",
"const int VAR_29= VAR_24 + 4*VAR_23;",
"if( decode_residual(VAR_0, gb, VAR_0->mb + 16*VAR_29, VAR_29, VAR_28, s->qscale, 16) <0 ){",
"return -1;",
"}",
"}",
"}else{",
"uint8_t * const nnz= &VAR_0->non_zero_count_cache[ scan8[4*VAR_23] ];",
"nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;",
"}",
"}",
"}",
"if(VAR_4&0x30){",
"for(VAR_25=0; VAR_25<2; VAR_25++)",
"if( decode_residual(VAR_0, gb, VAR_0->mb + 256 + 16*4*VAR_25, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, VAR_26, 4) < 0){",
"return -1;",
"}",
"}",
"if(VAR_4&0x20){",
"for(VAR_25=0; VAR_25<2; VAR_25++){",
"for(VAR_24=0; VAR_24<4; VAR_24++){",
"const int VAR_29= 16 + 4*VAR_25 + VAR_24;",
"if( decode_residual(VAR_0, gb, VAR_0->mb + 16*VAR_29, VAR_29, VAR_28 + 1, VAR_26, 15) < 0){",
"return -1;",
"}",
"}",
"}",
"}else{",
"uint8_t * const nnz= &VAR_0->non_zero_count_cache[0];",
"nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =\nnnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;",
"}",
"}else{",
"memset(&VAR_0->non_zero_count_cache[8], 0, 8*5);",
"}",
"s->current_picture.qscale_table[VAR_1]= s->qscale;",
"write_back_non_zero_count(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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
21
],
[
23,
25
],
[
29
],
[
31
],
[
37
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91,
93
],
[
95
],
[
97
],
[
101
],
[
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
],
[
165,
167
],
[
171
],
[
173
],
[
177
],
[
179
],
[
181
],
[
187
],
[
191
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
233
],
[
237
],
[
239
],
[
243
],
[
245
],
[
249
],
[
255
],
[
259
],
[
261
],
[
267
],
[
269
],
[
271
],
[
273
],
[
277
],
[
279
],
[
281,
283
],
[
285,
287
],
[
289
],
[
291
],
[
293
],
[
297
],
[
299
],
[
301
],
[
303,
305
],
[
307
],
[
309
],
[
311,
313
],
[
315
],
[
317
],
[
321
],
[
323,
325
],
[
327
],
[
329
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
371
],
[
373
],
[
375
],
[
379
],
[
381
],
[
383
],
[
385
],
[
387
],
[
389
],
[
391
],
[
395
],
[
397
],
[
399
],
[
401
],
[
405
],
[
407
],
[
409
],
[
413
],
[
415,
417
],
[
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
],
[
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
],
[
531
],
[
533
],
[
535
],
[
537
],
[
539
],
[
541
],
[
543
],
[
545
],
[
547
],
[
549
],
[
551
],
[
553
],
[
555
],
[
557
],
[
559
],
[
561
],
[
563
],
[
565
],
[
567
],
[
569
],
[
571
],
[
573
],
[
577
],
[
579
],
[
581
],
[
583
],
[
585
],
[
587
],
[
589
],
[
591
],
[
593
],
[
595
],
[
597
],
[
599
],
[
601
],
[
603
],
[
605
],
[
607
],
[
609
],
[
611
],
[
613
],
[
615
],
[
617
],
[
619
],
[
621
],
[
625
],
[
627
],
[
629
],
[
631
],
[
633
],
[
635
],
[
639,
641
],
[
645
],
[
647
],
[
649
],
[
651
],
[
653
],
[
655
],
[
659,
661
],
[
663,
665
],
[
667
],
[
671
],
[
673
],
[
675
],
[
677
],
[
679
],
[
687
],
[
689
],
[
691
],
[
693
],
[
695
],
[
697
],
[
699
],
[
703
],
[
707
],
[
709
],
[
711
],
[
713
],
[
717
],
[
719
],
[
721
],
[
723
],
[
725
],
[
729
],
[
731
],
[
733
],
[
735
],
[
737
],
[
741
],
[
745
],
[
747
],
[
749
],
[
751
],
[
753
],
[
755
],
[
757
],
[
759
],
[
761
],
[
763
],
[
765
],
[
767
],
[
769
],
[
771
],
[
773
],
[
775
],
[
777
],
[
781
],
[
783
],
[
785
],
[
787
],
[
789
],
[
791
],
[
793
],
[
795
],
[
797
],
[
799
],
[
803
],
[
805
],
[
807
],
[
809
],
[
811
],
[
813
],
[
817
],
[
819
],
[
821
],
[
823
],
[
825
],
[
827
],
[
829
],
[
831
],
[
833
],
[
835
],
[
837
],
[
839,
841
],
[
843
],
[
845
],
[
847
],
[
849
],
[
851
],
[
853
],
[
857
],
[
859
]
] |
7,979 |
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
int apply_defdispwin, HEVCSPS *sps)
{
VUI *vui = &sps->vui;
int sar_present;
av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
sar_present = get_bits1(gb);
if (sar_present) {
uint8_t sar_idx = get_bits(gb, 8);
if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
vui->sar = vui_sar[sar_idx];
else if (sar_idx == 255) {
vui->sar.num = get_bits(gb, 16);
vui->sar.den = get_bits(gb, 16);
} else
av_log(avctx, AV_LOG_WARNING,
"Unknown SAR index: %u.\n", sar_idx);
}
vui->overscan_info_present_flag = get_bits1(gb);
if (vui->overscan_info_present_flag)
vui->overscan_appropriate_flag = get_bits1(gb);
vui->video_signal_type_present_flag = get_bits1(gb);
if (vui->video_signal_type_present_flag) {
vui->video_format = get_bits(gb, 3);
vui->video_full_range_flag = get_bits1(gb);
vui->colour_description_present_flag = get_bits1(gb);
if (vui->video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
if (vui->colour_description_present_flag) {
vui->colour_primaries = get_bits(gb, 8);
vui->transfer_characteristic = get_bits(gb, 8);
vui->matrix_coeffs = get_bits(gb, 8);
// Set invalid values to "unspecified"
if (vui->colour_primaries >= AVCOL_PRI_NB)
vui->colour_primaries = AVCOL_PRI_UNSPECIFIED;
if (vui->transfer_characteristic >= AVCOL_TRC_NB)
vui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;
if (vui->matrix_coeffs >= AVCOL_SPC_NB)
vui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
}
}
vui->chroma_loc_info_present_flag = get_bits1(gb);
if (vui->chroma_loc_info_present_flag) {
vui->chroma_sample_loc_type_top_field = get_ue_golomb_long(gb);
vui->chroma_sample_loc_type_bottom_field = get_ue_golomb_long(gb);
}
vui->neutra_chroma_indication_flag = get_bits1(gb);
vui->field_seq_flag = get_bits1(gb);
vui->frame_field_info_present_flag = get_bits1(gb);
vui->default_display_window_flag = get_bits1(gb);
if (vui->default_display_window_flag) {
//TODO: * 2 is only valid for 420
vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * 2;
vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * 2;
vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * 2;
vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * 2;
if (apply_defdispwin &&
avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
av_log(avctx, AV_LOG_DEBUG,
"discarding vui default display window, "
"original values are l:%u r:%u t:%u b:%u\n",
vui->def_disp_win.left_offset,
vui->def_disp_win.right_offset,
vui->def_disp_win.top_offset,
vui->def_disp_win.bottom_offset);
vui->def_disp_win.left_offset =
vui->def_disp_win.right_offset =
vui->def_disp_win.top_offset =
vui->def_disp_win.bottom_offset = 0;
}
}
vui->vui_timing_info_present_flag = get_bits1(gb);
if (vui->vui_timing_info_present_flag) {
vui->vui_num_units_in_tick = get_bits_long(gb, 32);
vui->vui_time_scale = get_bits_long(gb, 32);
vui->vui_poc_proportional_to_timing_flag = get_bits1(gb);
if (vui->vui_poc_proportional_to_timing_flag)
vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(gb);
vui->vui_hrd_parameters_present_flag = get_bits1(gb);
if (vui->vui_hrd_parameters_present_flag)
decode_hrd(gb, 1, sps->max_sub_layers);
}
vui->bitstream_restriction_flag = get_bits1(gb);
if (vui->bitstream_restriction_flag) {
vui->tiles_fixed_structure_flag = get_bits1(gb);
vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb);
vui->restricted_ref_pic_lists_flag = get_bits1(gb);
vui->min_spatial_segmentation_idc = get_ue_golomb_long(gb);
vui->max_bytes_per_pic_denom = get_ue_golomb_long(gb);
vui->max_bits_per_min_cu_denom = get_ue_golomb_long(gb);
vui->log2_max_mv_length_horizontal = get_ue_golomb_long(gb);
vui->log2_max_mv_length_vertical = get_ue_golomb_long(gb);
}
}
| false |
FFmpeg
|
ff9db5cfd14558df9cfcc54d6c062bc34bf1f341
|
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
int apply_defdispwin, HEVCSPS *sps)
{
VUI *vui = &sps->vui;
int sar_present;
av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
sar_present = get_bits1(gb);
if (sar_present) {
uint8_t sar_idx = get_bits(gb, 8);
if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
vui->sar = vui_sar[sar_idx];
else if (sar_idx == 255) {
vui->sar.num = get_bits(gb, 16);
vui->sar.den = get_bits(gb, 16);
} else
av_log(avctx, AV_LOG_WARNING,
"Unknown SAR index: %u.\n", sar_idx);
}
vui->overscan_info_present_flag = get_bits1(gb);
if (vui->overscan_info_present_flag)
vui->overscan_appropriate_flag = get_bits1(gb);
vui->video_signal_type_present_flag = get_bits1(gb);
if (vui->video_signal_type_present_flag) {
vui->video_format = get_bits(gb, 3);
vui->video_full_range_flag = get_bits1(gb);
vui->colour_description_present_flag = get_bits1(gb);
if (vui->video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
if (vui->colour_description_present_flag) {
vui->colour_primaries = get_bits(gb, 8);
vui->transfer_characteristic = get_bits(gb, 8);
vui->matrix_coeffs = get_bits(gb, 8);
if (vui->colour_primaries >= AVCOL_PRI_NB)
vui->colour_primaries = AVCOL_PRI_UNSPECIFIED;
if (vui->transfer_characteristic >= AVCOL_TRC_NB)
vui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;
if (vui->matrix_coeffs >= AVCOL_SPC_NB)
vui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
}
}
vui->chroma_loc_info_present_flag = get_bits1(gb);
if (vui->chroma_loc_info_present_flag) {
vui->chroma_sample_loc_type_top_field = get_ue_golomb_long(gb);
vui->chroma_sample_loc_type_bottom_field = get_ue_golomb_long(gb);
}
vui->neutra_chroma_indication_flag = get_bits1(gb);
vui->field_seq_flag = get_bits1(gb);
vui->frame_field_info_present_flag = get_bits1(gb);
vui->default_display_window_flag = get_bits1(gb);
if (vui->default_display_window_flag) {
vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * 2;
vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * 2;
vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * 2;
vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * 2;
if (apply_defdispwin &&
avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
av_log(avctx, AV_LOG_DEBUG,
"discarding vui default display window, "
"original values are l:%u r:%u t:%u b:%u\n",
vui->def_disp_win.left_offset,
vui->def_disp_win.right_offset,
vui->def_disp_win.top_offset,
vui->def_disp_win.bottom_offset);
vui->def_disp_win.left_offset =
vui->def_disp_win.right_offset =
vui->def_disp_win.top_offset =
vui->def_disp_win.bottom_offset = 0;
}
}
vui->vui_timing_info_present_flag = get_bits1(gb);
if (vui->vui_timing_info_present_flag) {
vui->vui_num_units_in_tick = get_bits_long(gb, 32);
vui->vui_time_scale = get_bits_long(gb, 32);
vui->vui_poc_proportional_to_timing_flag = get_bits1(gb);
if (vui->vui_poc_proportional_to_timing_flag)
vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(gb);
vui->vui_hrd_parameters_present_flag = get_bits1(gb);
if (vui->vui_hrd_parameters_present_flag)
decode_hrd(gb, 1, sps->max_sub_layers);
}
vui->bitstream_restriction_flag = get_bits1(gb);
if (vui->bitstream_restriction_flag) {
vui->tiles_fixed_structure_flag = get_bits1(gb);
vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb);
vui->restricted_ref_pic_lists_flag = get_bits1(gb);
vui->min_spatial_segmentation_idc = get_ue_golomb_long(gb);
vui->max_bytes_per_pic_denom = get_ue_golomb_long(gb);
vui->max_bits_per_min_cu_denom = get_ue_golomb_long(gb);
vui->log2_max_mv_length_horizontal = get_ue_golomb_long(gb);
vui->log2_max_mv_length_vertical = get_ue_golomb_long(gb);
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(GetBitContext *VAR_0, AVCodecContext *VAR_1,
int VAR_2, HEVCSPS *VAR_3)
{
VUI *vui = &VAR_3->vui;
int VAR_4;
av_log(VAR_1, AV_LOG_DEBUG, "Decoding VUI\n");
VAR_4 = get_bits1(VAR_0);
if (VAR_4) {
uint8_t sar_idx = get_bits(VAR_0, 8);
if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
vui->sar = vui_sar[sar_idx];
else if (sar_idx == 255) {
vui->sar.num = get_bits(VAR_0, 16);
vui->sar.den = get_bits(VAR_0, 16);
} else
av_log(VAR_1, AV_LOG_WARNING,
"Unknown SAR index: %u.\n", sar_idx);
}
vui->overscan_info_present_flag = get_bits1(VAR_0);
if (vui->overscan_info_present_flag)
vui->overscan_appropriate_flag = get_bits1(VAR_0);
vui->video_signal_type_present_flag = get_bits1(VAR_0);
if (vui->video_signal_type_present_flag) {
vui->video_format = get_bits(VAR_0, 3);
vui->video_full_range_flag = get_bits1(VAR_0);
vui->colour_description_present_flag = get_bits1(VAR_0);
if (vui->video_full_range_flag && VAR_3->pix_fmt == AV_PIX_FMT_YUV420P)
VAR_3->pix_fmt = AV_PIX_FMT_YUVJ420P;
if (vui->colour_description_present_flag) {
vui->colour_primaries = get_bits(VAR_0, 8);
vui->transfer_characteristic = get_bits(VAR_0, 8);
vui->matrix_coeffs = get_bits(VAR_0, 8);
if (vui->colour_primaries >= AVCOL_PRI_NB)
vui->colour_primaries = AVCOL_PRI_UNSPECIFIED;
if (vui->transfer_characteristic >= AVCOL_TRC_NB)
vui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;
if (vui->matrix_coeffs >= AVCOL_SPC_NB)
vui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
}
}
vui->chroma_loc_info_present_flag = get_bits1(VAR_0);
if (vui->chroma_loc_info_present_flag) {
vui->chroma_sample_loc_type_top_field = get_ue_golomb_long(VAR_0);
vui->chroma_sample_loc_type_bottom_field = get_ue_golomb_long(VAR_0);
}
vui->neutra_chroma_indication_flag = get_bits1(VAR_0);
vui->field_seq_flag = get_bits1(VAR_0);
vui->frame_field_info_present_flag = get_bits1(VAR_0);
vui->default_display_window_flag = get_bits1(VAR_0);
if (vui->default_display_window_flag) {
vui->def_disp_win.left_offset = get_ue_golomb_long(VAR_0) * 2;
vui->def_disp_win.right_offset = get_ue_golomb_long(VAR_0) * 2;
vui->def_disp_win.top_offset = get_ue_golomb_long(VAR_0) * 2;
vui->def_disp_win.bottom_offset = get_ue_golomb_long(VAR_0) * 2;
if (VAR_2 &&
VAR_1->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
av_log(VAR_1, AV_LOG_DEBUG,
"discarding vui default display window, "
"original values are l:%u r:%u t:%u b:%u\n",
vui->def_disp_win.left_offset,
vui->def_disp_win.right_offset,
vui->def_disp_win.top_offset,
vui->def_disp_win.bottom_offset);
vui->def_disp_win.left_offset =
vui->def_disp_win.right_offset =
vui->def_disp_win.top_offset =
vui->def_disp_win.bottom_offset = 0;
}
}
vui->vui_timing_info_present_flag = get_bits1(VAR_0);
if (vui->vui_timing_info_present_flag) {
vui->vui_num_units_in_tick = get_bits_long(VAR_0, 32);
vui->vui_time_scale = get_bits_long(VAR_0, 32);
vui->vui_poc_proportional_to_timing_flag = get_bits1(VAR_0);
if (vui->vui_poc_proportional_to_timing_flag)
vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(VAR_0);
vui->vui_hrd_parameters_present_flag = get_bits1(VAR_0);
if (vui->vui_hrd_parameters_present_flag)
decode_hrd(VAR_0, 1, VAR_3->max_sub_layers);
}
vui->bitstream_restriction_flag = get_bits1(VAR_0);
if (vui->bitstream_restriction_flag) {
vui->tiles_fixed_structure_flag = get_bits1(VAR_0);
vui->motion_vectors_over_pic_boundaries_flag = get_bits1(VAR_0);
vui->restricted_ref_pic_lists_flag = get_bits1(VAR_0);
vui->min_spatial_segmentation_idc = get_ue_golomb_long(VAR_0);
vui->max_bytes_per_pic_denom = get_ue_golomb_long(VAR_0);
vui->max_bits_per_min_cu_denom = get_ue_golomb_long(VAR_0);
vui->log2_max_mv_length_horizontal = get_ue_golomb_long(VAR_0);
vui->log2_max_mv_length_vertical = get_ue_golomb_long(VAR_0);
}
}
|
[
"static void FUNC_0(GetBitContext *VAR_0, AVCodecContext *VAR_1,\nint VAR_2, HEVCSPS *VAR_3)\n{",
"VUI *vui = &VAR_3->vui;",
"int VAR_4;",
"av_log(VAR_1, AV_LOG_DEBUG, \"Decoding VUI\\n\");",
"VAR_4 = get_bits1(VAR_0);",
"if (VAR_4) {",
"uint8_t sar_idx = get_bits(VAR_0, 8);",
"if (sar_idx < FF_ARRAY_ELEMS(vui_sar))\nvui->sar = vui_sar[sar_idx];",
"else if (sar_idx == 255) {",
"vui->sar.num = get_bits(VAR_0, 16);",
"vui->sar.den = get_bits(VAR_0, 16);",
"} else",
"av_log(VAR_1, AV_LOG_WARNING,\n\"Unknown SAR index: %u.\\n\", sar_idx);",
"}",
"vui->overscan_info_present_flag = get_bits1(VAR_0);",
"if (vui->overscan_info_present_flag)\nvui->overscan_appropriate_flag = get_bits1(VAR_0);",
"vui->video_signal_type_present_flag = get_bits1(VAR_0);",
"if (vui->video_signal_type_present_flag) {",
"vui->video_format = get_bits(VAR_0, 3);",
"vui->video_full_range_flag = get_bits1(VAR_0);",
"vui->colour_description_present_flag = get_bits1(VAR_0);",
"if (vui->video_full_range_flag && VAR_3->pix_fmt == AV_PIX_FMT_YUV420P)\nVAR_3->pix_fmt = AV_PIX_FMT_YUVJ420P;",
"if (vui->colour_description_present_flag) {",
"vui->colour_primaries = get_bits(VAR_0, 8);",
"vui->transfer_characteristic = get_bits(VAR_0, 8);",
"vui->matrix_coeffs = get_bits(VAR_0, 8);",
"if (vui->colour_primaries >= AVCOL_PRI_NB)\nvui->colour_primaries = AVCOL_PRI_UNSPECIFIED;",
"if (vui->transfer_characteristic >= AVCOL_TRC_NB)\nvui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;",
"if (vui->matrix_coeffs >= AVCOL_SPC_NB)\nvui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;",
"}",
"}",
"vui->chroma_loc_info_present_flag = get_bits1(VAR_0);",
"if (vui->chroma_loc_info_present_flag) {",
"vui->chroma_sample_loc_type_top_field = get_ue_golomb_long(VAR_0);",
"vui->chroma_sample_loc_type_bottom_field = get_ue_golomb_long(VAR_0);",
"}",
"vui->neutra_chroma_indication_flag = get_bits1(VAR_0);",
"vui->field_seq_flag = get_bits1(VAR_0);",
"vui->frame_field_info_present_flag = get_bits1(VAR_0);",
"vui->default_display_window_flag = get_bits1(VAR_0);",
"if (vui->default_display_window_flag) {",
"vui->def_disp_win.left_offset = get_ue_golomb_long(VAR_0) * 2;",
"vui->def_disp_win.right_offset = get_ue_golomb_long(VAR_0) * 2;",
"vui->def_disp_win.top_offset = get_ue_golomb_long(VAR_0) * 2;",
"vui->def_disp_win.bottom_offset = get_ue_golomb_long(VAR_0) * 2;",
"if (VAR_2 &&\nVAR_1->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {",
"av_log(VAR_1, AV_LOG_DEBUG,\n\"discarding vui default display window, \"\n\"original values are l:%u r:%u t:%u b:%u\\n\",\nvui->def_disp_win.left_offset,\nvui->def_disp_win.right_offset,\nvui->def_disp_win.top_offset,\nvui->def_disp_win.bottom_offset);",
"vui->def_disp_win.left_offset =\nvui->def_disp_win.right_offset =\nvui->def_disp_win.top_offset =\nvui->def_disp_win.bottom_offset = 0;",
"}",
"}",
"vui->vui_timing_info_present_flag = get_bits1(VAR_0);",
"if (vui->vui_timing_info_present_flag) {",
"vui->vui_num_units_in_tick = get_bits_long(VAR_0, 32);",
"vui->vui_time_scale = get_bits_long(VAR_0, 32);",
"vui->vui_poc_proportional_to_timing_flag = get_bits1(VAR_0);",
"if (vui->vui_poc_proportional_to_timing_flag)\nvui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(VAR_0);",
"vui->vui_hrd_parameters_present_flag = get_bits1(VAR_0);",
"if (vui->vui_hrd_parameters_present_flag)\ndecode_hrd(VAR_0, 1, VAR_3->max_sub_layers);",
"}",
"vui->bitstream_restriction_flag = get_bits1(VAR_0);",
"if (vui->bitstream_restriction_flag) {",
"vui->tiles_fixed_structure_flag = get_bits1(VAR_0);",
"vui->motion_vectors_over_pic_boundaries_flag = get_bits1(VAR_0);",
"vui->restricted_ref_pic_lists_flag = get_bits1(VAR_0);",
"vui->min_spatial_segmentation_idc = get_ue_golomb_long(VAR_0);",
"vui->max_bytes_per_pic_denom = get_ue_golomb_long(VAR_0);",
"vui->max_bits_per_min_cu_denom = get_ue_golomb_long(VAR_0);",
"vui->log2_max_mv_length_horizontal = get_ue_golomb_long(VAR_0);",
"vui->log2_max_mv_length_vertical = get_ue_golomb_long(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
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
43
],
[
45,
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
77,
79
],
[
81,
83
],
[
85,
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131,
133
],
[
135,
137,
139,
141,
143,
145,
147
],
[
151,
153,
155,
157
],
[
159
],
[
161
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175,
177
],
[
179
],
[
181,
183
],
[
185
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
]
] |
7,981 |
static int ivf_write_trailer(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
if (pb->seekable) {
IVFEncContext *ctx = s->priv_data;
size_t end = avio_tell(pb);
avio_seek(pb, 24, SEEK_SET);
avio_wl64(pb, ctx->frame_cnt * ctx->sum_delta_pts / (ctx->frame_cnt - 1));
avio_seek(pb, end, SEEK_SET);
}
return 0;
}
| true |
FFmpeg
|
5c8467a07c654f6acd9e8e3a436cd5b746bb2f44
|
static int ivf_write_trailer(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
if (pb->seekable) {
IVFEncContext *ctx = s->priv_data;
size_t end = avio_tell(pb);
avio_seek(pb, 24, SEEK_SET);
avio_wl64(pb, ctx->frame_cnt * ctx->sum_delta_pts / (ctx->frame_cnt - 1));
avio_seek(pb, end, SEEK_SET);
}
return 0;
}
|
{
"code": [
" if (pb->seekable) {",
" IVFEncContext *ctx = s->priv_data;"
],
"line_no": [
7,
9
]
}
|
static int FUNC_0(AVFormatContext *VAR_0)
{
AVIOContext *pb = VAR_0->pb;
if (pb->seekable) {
IVFEncContext *ctx = VAR_0->priv_data;
size_t end = avio_tell(pb);
avio_seek(pb, 24, SEEK_SET);
avio_wl64(pb, ctx->frame_cnt * ctx->sum_delta_pts / (ctx->frame_cnt - 1));
avio_seek(pb, end, SEEK_SET);
}
return 0;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"AVIOContext *pb = VAR_0->pb;",
"if (pb->seekable) {",
"IVFEncContext *ctx = VAR_0->priv_data;",
"size_t end = avio_tell(pb);",
"avio_seek(pb, 24, SEEK_SET);",
"avio_wl64(pb, ctx->frame_cnt * ctx->sum_delta_pts / (ctx->frame_cnt - 1));",
"avio_seek(pb, end, SEEK_SET);",
"}",
"return 0;",
"}"
] |
[
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
]
] |
7,983 |
static int main_loop(void)
{
int ret, timeout;
#ifdef CONFIG_PROFILER
int64_t ti;
#endif
CPUState *env;
cur_cpu = first_cpu;
next_cpu = cur_cpu->next_cpu ?: first_cpu;
for(;;) {
if (vm_running) {
for(;;) {
/* get next cpu */
env = next_cpu;
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
if (use_icount) {
int64_t count;
int decr;
qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
env->icount_decr.u16.low = 0;
env->icount_extra = 0;
count = qemu_next_deadline();
count = (count + (1 << icount_time_shift) - 1)
>> icount_time_shift;
qemu_icount += count;
decr = (count > 0xffff) ? 0xffff : count;
count -= decr;
env->icount_decr.u16.low = decr;
env->icount_extra = count;
}
ret = cpu_exec(env);
#ifdef CONFIG_PROFILER
qemu_time += profile_getclock() - ti;
#endif
if (use_icount) {
/* Fold pending instructions back into the
instruction counter, and clear the interrupt flag. */
qemu_icount -= (env->icount_decr.u16.low
+ env->icount_extra);
env->icount_decr.u32 = 0;
env->icount_extra = 0;
}
next_cpu = env->next_cpu ?: first_cpu;
if (event_pending && likely(ret != EXCP_DEBUG)) {
ret = EXCP_INTERRUPT;
event_pending = 0;
break;
}
if (ret == EXCP_HLT) {
/* Give the next CPU a chance to run. */
cur_cpu = env;
continue;
}
if (ret != EXCP_HALTED)
break;
/* all CPUs are halted ? */
if (env == cur_cpu)
break;
}
cur_cpu = env;
if (shutdown_requested) {
ret = EXCP_INTERRUPT;
if (no_shutdown) {
vm_stop(0);
no_shutdown = 0;
}
else
break;
}
if (reset_requested) {
reset_requested = 0;
qemu_system_reset();
ret = EXCP_INTERRUPT;
}
if (powerdown_requested) {
powerdown_requested = 0;
qemu_system_powerdown();
ret = EXCP_INTERRUPT;
}
if (unlikely(ret == EXCP_DEBUG)) {
vm_stop(EXCP_DEBUG);
}
/* If all cpus are halted then wait until the next IRQ */
/* XXX: use timeout computed from timers */
if (ret == EXCP_HALTED) {
if (use_icount) {
int64_t add;
int64_t delta;
/* Advance virtual time to the next event. */
if (use_icount == 1) {
/* When not using an adaptive execution frequency
we tend to get badly out of sync with real time,
so just delay for a reasonable amount of time. */
delta = 0;
} else {
delta = cpu_get_icount() - cpu_get_clock();
}
if (delta > 0) {
/* If virtual time is ahead of real time then just
wait for IO. */
timeout = (delta / 1000000) + 1;
} else {
/* Wait for either IO to occur or the next
timer event. */
add = qemu_next_deadline();
/* We advance the timer before checking for IO.
Limit the amount we advance so that early IO
activity won't get the guest too far ahead. */
if (add > 10000000)
add = 10000000;
delta += add;
add = (add + (1 << icount_time_shift) - 1)
>> icount_time_shift;
qemu_icount += add;
timeout = delta / 1000000;
if (timeout < 0)
timeout = 0;
}
} else {
timeout = 10;
}
} else {
timeout = 0;
}
} else {
if (shutdown_requested)
break;
timeout = 10;
}
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
main_loop_wait(timeout);
#ifdef CONFIG_PROFILER
dev_time += profile_getclock() - ti;
#endif
}
cpu_disable_ticks();
return ret;
}
| true |
qemu
|
98448f58c10033a0f7fcd0673cce4626506403fa
|
static int main_loop(void)
{
int ret, timeout;
#ifdef CONFIG_PROFILER
int64_t ti;
#endif
CPUState *env;
cur_cpu = first_cpu;
next_cpu = cur_cpu->next_cpu ?: first_cpu;
for(;;) {
if (vm_running) {
for(;;) {
env = next_cpu;
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
if (use_icount) {
int64_t count;
int decr;
qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
env->icount_decr.u16.low = 0;
env->icount_extra = 0;
count = qemu_next_deadline();
count = (count + (1 << icount_time_shift) - 1)
>> icount_time_shift;
qemu_icount += count;
decr = (count > 0xffff) ? 0xffff : count;
count -= decr;
env->icount_decr.u16.low = decr;
env->icount_extra = count;
}
ret = cpu_exec(env);
#ifdef CONFIG_PROFILER
qemu_time += profile_getclock() - ti;
#endif
if (use_icount) {
qemu_icount -= (env->icount_decr.u16.low
+ env->icount_extra);
env->icount_decr.u32 = 0;
env->icount_extra = 0;
}
next_cpu = env->next_cpu ?: first_cpu;
if (event_pending && likely(ret != EXCP_DEBUG)) {
ret = EXCP_INTERRUPT;
event_pending = 0;
break;
}
if (ret == EXCP_HLT) {
cur_cpu = env;
continue;
}
if (ret != EXCP_HALTED)
break;
if (env == cur_cpu)
break;
}
cur_cpu = env;
if (shutdown_requested) {
ret = EXCP_INTERRUPT;
if (no_shutdown) {
vm_stop(0);
no_shutdown = 0;
}
else
break;
}
if (reset_requested) {
reset_requested = 0;
qemu_system_reset();
ret = EXCP_INTERRUPT;
}
if (powerdown_requested) {
powerdown_requested = 0;
qemu_system_powerdown();
ret = EXCP_INTERRUPT;
}
if (unlikely(ret == EXCP_DEBUG)) {
vm_stop(EXCP_DEBUG);
}
if (ret == EXCP_HALTED) {
if (use_icount) {
int64_t add;
int64_t delta;
if (use_icount == 1) {
delta = 0;
} else {
delta = cpu_get_icount() - cpu_get_clock();
}
if (delta > 0) {
timeout = (delta / 1000000) + 1;
} else {
add = qemu_next_deadline();
if (add > 10000000)
add = 10000000;
delta += add;
add = (add + (1 << icount_time_shift) - 1)
>> icount_time_shift;
qemu_icount += add;
timeout = delta / 1000000;
if (timeout < 0)
timeout = 0;
}
} else {
timeout = 10;
}
} else {
timeout = 0;
}
} else {
if (shutdown_requested)
break;
timeout = 10;
}
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
main_loop_wait(timeout);
#ifdef CONFIG_PROFILER
dev_time += profile_getclock() - ti;
#endif
}
cpu_disable_ticks();
return ret;
}
|
{
"code": [
" if (shutdown_requested)"
],
"line_no": [
261
]
}
|
static int FUNC_0(void)
{
int VAR_0, VAR_1;
#ifdef CONFIG_PROFILER
int64_t ti;
#endif
CPUState *env;
cur_cpu = first_cpu;
next_cpu = cur_cpu->next_cpu ?: first_cpu;
for(;;) {
if (vm_running) {
for(;;) {
env = next_cpu;
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
if (use_icount) {
int64_t count;
int VAR_2;
qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
env->icount_decr.u16.low = 0;
env->icount_extra = 0;
count = qemu_next_deadline();
count = (count + (1 << icount_time_shift) - 1)
>> icount_time_shift;
qemu_icount += count;
VAR_2 = (count > 0xffff) ? 0xffff : count;
count -= VAR_2;
env->icount_decr.u16.low = VAR_2;
env->icount_extra = count;
}
VAR_0 = cpu_exec(env);
#ifdef CONFIG_PROFILER
qemu_time += profile_getclock() - ti;
#endif
if (use_icount) {
qemu_icount -= (env->icount_decr.u16.low
+ env->icount_extra);
env->icount_decr.u32 = 0;
env->icount_extra = 0;
}
next_cpu = env->next_cpu ?: first_cpu;
if (event_pending && likely(VAR_0 != EXCP_DEBUG)) {
VAR_0 = EXCP_INTERRUPT;
event_pending = 0;
break;
}
if (VAR_0 == EXCP_HLT) {
cur_cpu = env;
continue;
}
if (VAR_0 != EXCP_HALTED)
break;
if (env == cur_cpu)
break;
}
cur_cpu = env;
if (shutdown_requested) {
VAR_0 = EXCP_INTERRUPT;
if (no_shutdown) {
vm_stop(0);
no_shutdown = 0;
}
else
break;
}
if (reset_requested) {
reset_requested = 0;
qemu_system_reset();
VAR_0 = EXCP_INTERRUPT;
}
if (powerdown_requested) {
powerdown_requested = 0;
qemu_system_powerdown();
VAR_0 = EXCP_INTERRUPT;
}
if (unlikely(VAR_0 == EXCP_DEBUG)) {
vm_stop(EXCP_DEBUG);
}
if (VAR_0 == EXCP_HALTED) {
if (use_icount) {
int64_t add;
int64_t delta;
if (use_icount == 1) {
delta = 0;
} else {
delta = cpu_get_icount() - cpu_get_clock();
}
if (delta > 0) {
VAR_1 = (delta / 1000000) + 1;
} else {
add = qemu_next_deadline();
if (add > 10000000)
add = 10000000;
delta += add;
add = (add + (1 << icount_time_shift) - 1)
>> icount_time_shift;
qemu_icount += add;
VAR_1 = delta / 1000000;
if (VAR_1 < 0)
VAR_1 = 0;
}
} else {
VAR_1 = 10;
}
} else {
VAR_1 = 0;
}
} else {
if (shutdown_requested)
break;
VAR_1 = 10;
}
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
main_loop_wait(VAR_1);
#ifdef CONFIG_PROFILER
dev_time += profile_getclock() - ti;
#endif
}
cpu_disable_ticks();
return VAR_0;
}
|
[
"static int FUNC_0(void)\n{",
"int VAR_0, VAR_1;",
"#ifdef CONFIG_PROFILER\nint64_t ti;",
"#endif\nCPUState *env;",
"cur_cpu = first_cpu;",
"next_cpu = cur_cpu->next_cpu ?: first_cpu;",
"for(;;) {",
"if (vm_running) {",
"for(;;) {",
"env = next_cpu;",
"#ifdef CONFIG_PROFILER\nti = profile_getclock();",
"#endif\nif (use_icount) {",
"int64_t count;",
"int VAR_2;",
"qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);",
"env->icount_decr.u16.low = 0;",
"env->icount_extra = 0;",
"count = qemu_next_deadline();",
"count = (count + (1 << icount_time_shift) - 1)\n>> icount_time_shift;",
"qemu_icount += count;",
"VAR_2 = (count > 0xffff) ? 0xffff : count;",
"count -= VAR_2;",
"env->icount_decr.u16.low = VAR_2;",
"env->icount_extra = count;",
"}",
"VAR_0 = cpu_exec(env);",
"#ifdef CONFIG_PROFILER\nqemu_time += profile_getclock() - ti;",
"#endif\nif (use_icount) {",
"qemu_icount -= (env->icount_decr.u16.low\n+ env->icount_extra);",
"env->icount_decr.u32 = 0;",
"env->icount_extra = 0;",
"}",
"next_cpu = env->next_cpu ?: first_cpu;",
"if (event_pending && likely(VAR_0 != EXCP_DEBUG)) {",
"VAR_0 = EXCP_INTERRUPT;",
"event_pending = 0;",
"break;",
"}",
"if (VAR_0 == EXCP_HLT) {",
"cur_cpu = env;",
"continue;",
"}",
"if (VAR_0 != EXCP_HALTED)\nbreak;",
"if (env == cur_cpu)\nbreak;",
"}",
"cur_cpu = env;",
"if (shutdown_requested) {",
"VAR_0 = EXCP_INTERRUPT;",
"if (no_shutdown) {",
"vm_stop(0);",
"no_shutdown = 0;",
"}",
"else\nbreak;",
"}",
"if (reset_requested) {",
"reset_requested = 0;",
"qemu_system_reset();",
"VAR_0 = EXCP_INTERRUPT;",
"}",
"if (powerdown_requested) {",
"powerdown_requested = 0;",
"qemu_system_powerdown();",
"VAR_0 = EXCP_INTERRUPT;",
"}",
"if (unlikely(VAR_0 == EXCP_DEBUG)) {",
"vm_stop(EXCP_DEBUG);",
"}",
"if (VAR_0 == EXCP_HALTED) {",
"if (use_icount) {",
"int64_t add;",
"int64_t delta;",
"if (use_icount == 1) {",
"delta = 0;",
"} else {",
"delta = cpu_get_icount() - cpu_get_clock();",
"}",
"if (delta > 0) {",
"VAR_1 = (delta / 1000000) + 1;",
"} else {",
"add = qemu_next_deadline();",
"if (add > 10000000)\nadd = 10000000;",
"delta += add;",
"add = (add + (1 << icount_time_shift) - 1)\n>> icount_time_shift;",
"qemu_icount += add;",
"VAR_1 = delta / 1000000;",
"if (VAR_1 < 0)\nVAR_1 = 0;",
"}",
"} else {",
"VAR_1 = 10;",
"}",
"} else {",
"VAR_1 = 0;",
"}",
"} else {",
"if (shutdown_requested)\nbreak;",
"VAR_1 = 10;",
"}",
"#ifdef CONFIG_PROFILER\nti = profile_getclock();",
"#endif\nmain_loop_wait(VAR_1);",
"#ifdef CONFIG_PROFILER\ndev_time += profile_getclock() - ti;",
"#endif\n}",
"cpu_disable_ticks();",
"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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
] |
[
[
1,
3
],
[
5
],
[
7,
9
],
[
11,
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
31
],
[
33,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71,
73
],
[
75,
77
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115,
117
],
[
121,
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143,
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
179
],
[
181
],
[
183
],
[
185
],
[
189
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
211
],
[
213
],
[
219
],
[
227,
229
],
[
231
],
[
233,
235
],
[
237
],
[
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
]
] |
7,984 |
int acpi_table_add(const QemuOpts *opts)
{
AcpiTableOptions *hdrs = NULL;
Error *err = NULL;
char **pathnames = NULL;
char **cur;
size_t len, start, allen;
bool has_header;
int changed;
int r;
struct acpi_table_header hdr;
char unsigned *table_start;
{
OptsVisitor *ov;
ov = opts_visitor_new(opts);
visit_type_AcpiTableOptions(opts_get_visitor(ov), &hdrs, NULL, &err);
opts_visitor_cleanup(ov);
}
if (err) {
goto out;
}
if (hdrs->has_file == hdrs->has_data) {
error_setg(&err, "'-acpitable' requires one of 'data' or 'file'");
goto out;
}
has_header = hdrs->has_file;
pathnames = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->data, ":", 0);
if (pathnames == NULL || pathnames[0] == NULL) {
error_setg(&err, "'-acpitable' requires at least one pathname");
goto out;
}
if (!acpi_tables) {
allen = sizeof(uint16_t);
acpi_tables = g_malloc0(allen);
} else {
allen = acpi_tables_len;
}
start = allen;
acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;
/* now read in the data files, reallocating buffer as needed */
for (cur = pathnames; *cur; ++cur) {
int fd = open(*cur, O_RDONLY | O_BINARY);
if (fd < 0) {
error_setg(&err, "can't open file %s: %s", *cur, strerror(errno));
goto out;
}
for (;;) {
char unsigned data[8192];
r = read(fd, data, sizeof(data));
if (r == 0) {
break;
} else if (r > 0) {
acpi_tables = g_realloc(acpi_tables, allen + r);
memcpy(acpi_tables + allen, data, r);
allen += r;
} else if (errno != EINTR) {
error_setg(&err, "can't read file %s: %s",
*cur, strerror(errno));
close(fd);
goto out;
}
}
close(fd);
}
/* now fill in the header fields */
table_start = acpi_tables + start; /* start of the table */
changed = 0;
/* copy the header to temp place to align the fields */
memcpy(&hdr, has_header ? table_start : dfl_hdr, ACPI_TABLE_HDR_SIZE);
/* length of the table minus our prefix */
len = allen - start - ACPI_TABLE_PFX_SIZE;
hdr._length = cpu_to_le16(len);
if (hdrs->has_sig) {
/* strncpy is justified: the field need not be NUL-terminated. */
strncpy(hdr.sig, hdrs->sig, sizeof(hdr.sig));
++changed;
}
/* length of the table including header, in bytes */
if (has_header) {
unsigned long val;
/* check if actual length is correct */
val = le32_to_cpu(hdr.length);
if (val != len) {
fprintf(stderr,
"warning: acpitable has wrong length,"
" header says %lu, actual size %zu bytes\n",
val, len);
++changed;
}
}
/* we may avoid putting length here if has_header is true */
hdr.length = cpu_to_le32(len);
if (hdrs->has_rev) {
hdr.revision = hdrs->rev;
++changed;
}
if (hdrs->has_oem_id) {
/* strncpy is justified: the field need not be NUL-terminated. */
strncpy(hdr.oem_id, hdrs->oem_id, sizeof(hdr.oem_id));
++changed;
}
if (hdrs->has_oem_table_id) {
/* strncpy is justified: the field need not be NUL-terminated. */
strncpy(hdr.oem_table_id, hdrs->oem_table_id,
sizeof(hdr.oem_table_id));
++changed;
}
if (hdrs->has_oem_rev) {
hdr.oem_revision = cpu_to_le32(hdrs->oem_rev);
++changed;
}
if (hdrs->has_asl_compiler_id) {
/* strncpy is justified: the field need not be NUL-terminated. */
strncpy(hdr.asl_compiler_id, hdrs->asl_compiler_id,
sizeof(hdr.asl_compiler_id));
++changed;
}
if (hdrs->has_asl_compiler_rev) {
hdr.asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);
++changed;
}
if (!has_header && !changed) {
fprintf(stderr, "warning: acpitable: no table headers are specified\n");
}
/* now calculate checksum of the table, complete with the header */
/* we may as well leave checksum intact if has_header is true */
/* alternatively there may be a way to set cksum to a given value */
hdr.checksum = 0; /* for checksum calculation */
/* put header back */
memcpy(table_start, &hdr, sizeof(hdr));
if (changed || !has_header || 1) {
((struct acpi_table_header *)table_start)->checksum =
acpi_checksum((uint8_t *)table_start + ACPI_TABLE_PFX_SIZE, len);
}
/* increase number of tables */
(*(uint16_t *)acpi_tables) =
cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);
acpi_tables_len = allen;
out:
g_strfreev(pathnames);
if (hdrs != NULL) {
QapiDeallocVisitor *dv;
dv = qapi_dealloc_visitor_new();
visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv), &hdrs, NULL,
NULL);
qapi_dealloc_visitor_cleanup(dv);
}
if (err) {
fprintf(stderr, "%s\n", error_get_pretty(err));
error_free(err);
return -1;
}
return 0;
}
| true |
qemu
|
e980f2bf0a39cb524259bb70084e0f75b92c8f39
|
int acpi_table_add(const QemuOpts *opts)
{
AcpiTableOptions *hdrs = NULL;
Error *err = NULL;
char **pathnames = NULL;
char **cur;
size_t len, start, allen;
bool has_header;
int changed;
int r;
struct acpi_table_header hdr;
char unsigned *table_start;
{
OptsVisitor *ov;
ov = opts_visitor_new(opts);
visit_type_AcpiTableOptions(opts_get_visitor(ov), &hdrs, NULL, &err);
opts_visitor_cleanup(ov);
}
if (err) {
goto out;
}
if (hdrs->has_file == hdrs->has_data) {
error_setg(&err, "'-acpitable' requires one of 'data' or 'file'");
goto out;
}
has_header = hdrs->has_file;
pathnames = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->data, ":", 0);
if (pathnames == NULL || pathnames[0] == NULL) {
error_setg(&err, "'-acpitable' requires at least one pathname");
goto out;
}
if (!acpi_tables) {
allen = sizeof(uint16_t);
acpi_tables = g_malloc0(allen);
} else {
allen = acpi_tables_len;
}
start = allen;
acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;
for (cur = pathnames; *cur; ++cur) {
int fd = open(*cur, O_RDONLY | O_BINARY);
if (fd < 0) {
error_setg(&err, "can't open file %s: %s", *cur, strerror(errno));
goto out;
}
for (;;) {
char unsigned data[8192];
r = read(fd, data, sizeof(data));
if (r == 0) {
break;
} else if (r > 0) {
acpi_tables = g_realloc(acpi_tables, allen + r);
memcpy(acpi_tables + allen, data, r);
allen += r;
} else if (errno != EINTR) {
error_setg(&err, "can't read file %s: %s",
*cur, strerror(errno));
close(fd);
goto out;
}
}
close(fd);
}
table_start = acpi_tables + start;
changed = 0;
memcpy(&hdr, has_header ? table_start : dfl_hdr, ACPI_TABLE_HDR_SIZE);
len = allen - start - ACPI_TABLE_PFX_SIZE;
hdr._length = cpu_to_le16(len);
if (hdrs->has_sig) {
strncpy(hdr.sig, hdrs->sig, sizeof(hdr.sig));
++changed;
}
if (has_header) {
unsigned long val;
val = le32_to_cpu(hdr.length);
if (val != len) {
fprintf(stderr,
"warning: acpitable has wrong length,"
" header says %lu, actual size %zu bytes\n",
val, len);
++changed;
}
}
hdr.length = cpu_to_le32(len);
if (hdrs->has_rev) {
hdr.revision = hdrs->rev;
++changed;
}
if (hdrs->has_oem_id) {
strncpy(hdr.oem_id, hdrs->oem_id, sizeof(hdr.oem_id));
++changed;
}
if (hdrs->has_oem_table_id) {
strncpy(hdr.oem_table_id, hdrs->oem_table_id,
sizeof(hdr.oem_table_id));
++changed;
}
if (hdrs->has_oem_rev) {
hdr.oem_revision = cpu_to_le32(hdrs->oem_rev);
++changed;
}
if (hdrs->has_asl_compiler_id) {
strncpy(hdr.asl_compiler_id, hdrs->asl_compiler_id,
sizeof(hdr.asl_compiler_id));
++changed;
}
if (hdrs->has_asl_compiler_rev) {
hdr.asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);
++changed;
}
if (!has_header && !changed) {
fprintf(stderr, "warning: acpitable: no table headers are specified\n");
}
hdr.checksum = 0;
memcpy(table_start, &hdr, sizeof(hdr));
if (changed || !has_header || 1) {
((struct acpi_table_header *)table_start)->checksum =
acpi_checksum((uint8_t *)table_start + ACPI_TABLE_PFX_SIZE, len);
}
(*(uint16_t *)acpi_tables) =
cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);
acpi_tables_len = allen;
out:
g_strfreev(pathnames);
if (hdrs != NULL) {
QapiDeallocVisitor *dv;
dv = qapi_dealloc_visitor_new();
visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv), &hdrs, NULL,
NULL);
qapi_dealloc_visitor_cleanup(dv);
}
if (err) {
fprintf(stderr, "%s\n", error_get_pretty(err));
error_free(err);
return -1;
}
return 0;
}
|
{
"code": [
" size_t len, start, allen;",
" bool has_header;",
" int changed;",
" int r;",
" struct acpi_table_header hdr;",
" char unsigned *table_start;",
" has_header = hdrs->has_file;",
" if (!acpi_tables) {",
" allen = sizeof(uint16_t);",
" acpi_tables = g_malloc0(allen);",
" } else {",
" allen = acpi_tables_len;",
" start = allen;",
" acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);",
" allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;",
" r = read(fd, data, sizeof(data));",
" acpi_tables = g_realloc(acpi_tables, allen + r);",
" memcpy(acpi_tables + allen, data, r);",
" allen += r;",
" changed = 0;",
" memcpy(&hdr, has_header ? table_start : dfl_hdr, ACPI_TABLE_HDR_SIZE);",
" len = allen - start - ACPI_TABLE_PFX_SIZE;",
" hdr._length = cpu_to_le16(len);",
" if (hdrs->has_sig) {",
" strncpy(hdr.sig, hdrs->sig, sizeof(hdr.sig));",
" ++changed;",
" if (has_header) {",
" unsigned long val;",
" val = le32_to_cpu(hdr.length);",
" if (val != len) {",
" fprintf(stderr,",
" \"warning: acpitable has wrong length,\"",
" \" header says %lu, actual size %zu bytes\\n\",",
" val, len);",
" ++changed;",
" hdr.length = cpu_to_le32(len);",
" if (hdrs->has_rev) {",
" hdr.revision = hdrs->rev;",
" ++changed;",
" if (hdrs->has_oem_id) {",
" strncpy(hdr.oem_id, hdrs->oem_id, sizeof(hdr.oem_id));",
" ++changed;",
" if (hdrs->has_oem_table_id) {",
" strncpy(hdr.oem_table_id, hdrs->oem_table_id,",
" sizeof(hdr.oem_table_id));",
" ++changed;",
" if (hdrs->has_oem_rev) {",
" hdr.oem_revision = cpu_to_le32(hdrs->oem_rev);",
" ++changed;",
" if (hdrs->has_asl_compiler_id) {",
" strncpy(hdr.asl_compiler_id, hdrs->asl_compiler_id,",
" sizeof(hdr.asl_compiler_id));",
" ++changed;",
" if (hdrs->has_asl_compiler_rev) {",
" hdr.asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);",
" ++changed;",
" if (!has_header && !changed) {",
" fprintf(stderr, \"warning: acpitable: no table headers are specified\\n\");",
" memcpy(table_start, &hdr, sizeof(hdr));",
" if (changed || !has_header || 1) {",
" ((struct acpi_table_header *)table_start)->checksum =",
" acpi_checksum((uint8_t *)table_start + ACPI_TABLE_PFX_SIZE, len);",
" (*(uint16_t *)acpi_tables) =",
" cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);",
" acpi_tables_len = allen;"
],
"line_no": [
15,
17,
19,
21,
23,
25,
59,
75,
77,
79,
81,
83,
89,
91,
93,
121,
129,
131,
133,
163,
169,
175,
179,
183,
187,
189,
197,
199,
205,
207,
209,
211,
213,
215,
217,
225,
229,
231,
189,
239,
243,
189,
251,
255,
257,
189,
265,
267,
189,
275,
279,
281,
189,
289,
291,
189,
299,
301,
321,
325,
327,
329,
337,
339,
343
]
}
|
int FUNC_0(const QemuOpts *VAR_0)
{
AcpiTableOptions *hdrs = NULL;
Error *err = NULL;
char **VAR_1 = NULL;
char **VAR_2;
size_t len, start, allen;
bool has_header;
int VAR_3;
int VAR_4;
struct acpi_table_header VAR_5;
char unsigned *VAR_6;
{
OptsVisitor *ov;
ov = opts_visitor_new(VAR_0);
visit_type_AcpiTableOptions(opts_get_visitor(ov), &hdrs, NULL, &err);
opts_visitor_cleanup(ov);
}
if (err) {
goto out;
}
if (hdrs->has_file == hdrs->has_data) {
error_setg(&err, "'-acpitable' requires one of 'VAR_8' or 'file'");
goto out;
}
has_header = hdrs->has_file;
VAR_1 = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->VAR_8, ":", 0);
if (VAR_1 == NULL || VAR_1[0] == NULL) {
error_setg(&err, "'-acpitable' requires at least one pathname");
goto out;
}
if (!acpi_tables) {
allen = sizeof(uint16_t);
acpi_tables = g_malloc0(allen);
} else {
allen = acpi_tables_len;
}
start = allen;
acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;
for (VAR_2 = VAR_1; *VAR_2; ++VAR_2) {
int VAR_7 = open(*VAR_2, O_RDONLY | O_BINARY);
if (VAR_7 < 0) {
error_setg(&err, "can't open file %s: %s", *VAR_2, strerror(errno));
goto out;
}
for (;;) {
char unsigned VAR_8[8192];
VAR_4 = read(VAR_7, VAR_8, sizeof(VAR_8));
if (VAR_4 == 0) {
break;
} else if (VAR_4 > 0) {
acpi_tables = g_realloc(acpi_tables, allen + VAR_4);
memcpy(acpi_tables + allen, VAR_8, VAR_4);
allen += VAR_4;
} else if (errno != EINTR) {
error_setg(&err, "can't read file %s: %s",
*VAR_2, strerror(errno));
close(VAR_7);
goto out;
}
}
close(VAR_7);
}
VAR_6 = acpi_tables + start;
VAR_3 = 0;
memcpy(&VAR_5, has_header ? VAR_6 : dfl_hdr, ACPI_TABLE_HDR_SIZE);
len = allen - start - ACPI_TABLE_PFX_SIZE;
VAR_5._length = cpu_to_le16(len);
if (hdrs->has_sig) {
strncpy(VAR_5.sig, hdrs->sig, sizeof(VAR_5.sig));
++VAR_3;
}
if (has_header) {
unsigned long VAR_9;
VAR_9 = le32_to_cpu(VAR_5.length);
if (VAR_9 != len) {
fprintf(stderr,
"warning: acpitable has wrong length,"
" header says %lu, actual size %zu bytes\n",
VAR_9, len);
++VAR_3;
}
}
VAR_5.length = cpu_to_le32(len);
if (hdrs->has_rev) {
VAR_5.revision = hdrs->rev;
++VAR_3;
}
if (hdrs->has_oem_id) {
strncpy(VAR_5.oem_id, hdrs->oem_id, sizeof(VAR_5.oem_id));
++VAR_3;
}
if (hdrs->has_oem_table_id) {
strncpy(VAR_5.oem_table_id, hdrs->oem_table_id,
sizeof(VAR_5.oem_table_id));
++VAR_3;
}
if (hdrs->has_oem_rev) {
VAR_5.oem_revision = cpu_to_le32(hdrs->oem_rev);
++VAR_3;
}
if (hdrs->has_asl_compiler_id) {
strncpy(VAR_5.asl_compiler_id, hdrs->asl_compiler_id,
sizeof(VAR_5.asl_compiler_id));
++VAR_3;
}
if (hdrs->has_asl_compiler_rev) {
VAR_5.asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);
++VAR_3;
}
if (!has_header && !VAR_3) {
fprintf(stderr, "warning: acpitable: no table headers are specified\n");
}
VAR_5.checksum = 0;
memcpy(VAR_6, &VAR_5, sizeof(VAR_5));
if (VAR_3 || !has_header || 1) {
((struct acpi_table_header *)VAR_6)->checksum =
acpi_checksum((uint8_t *)VAR_6 + ACPI_TABLE_PFX_SIZE, len);
}
(*(uint16_t *)acpi_tables) =
cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);
acpi_tables_len = allen;
out:
g_strfreev(VAR_1);
if (hdrs != NULL) {
QapiDeallocVisitor *dv;
dv = qapi_dealloc_visitor_new();
visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv), &hdrs, NULL,
NULL);
qapi_dealloc_visitor_cleanup(dv);
}
if (err) {
fprintf(stderr, "%s\n", error_get_pretty(err));
error_free(err);
return -1;
}
return 0;
}
|
[
"int FUNC_0(const QemuOpts *VAR_0)\n{",
"AcpiTableOptions *hdrs = NULL;",
"Error *err = NULL;",
"char **VAR_1 = NULL;",
"char **VAR_2;",
"size_t len, start, allen;",
"bool has_header;",
"int VAR_3;",
"int VAR_4;",
"struct acpi_table_header VAR_5;",
"char unsigned *VAR_6;",
"{",
"OptsVisitor *ov;",
"ov = opts_visitor_new(VAR_0);",
"visit_type_AcpiTableOptions(opts_get_visitor(ov), &hdrs, NULL, &err);",
"opts_visitor_cleanup(ov);",
"}",
"if (err) {",
"goto out;",
"}",
"if (hdrs->has_file == hdrs->has_data) {",
"error_setg(&err, \"'-acpitable' requires one of 'VAR_8' or 'file'\");",
"goto out;",
"}",
"has_header = hdrs->has_file;",
"VAR_1 = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->VAR_8, \":\", 0);",
"if (VAR_1 == NULL || VAR_1[0] == NULL) {",
"error_setg(&err, \"'-acpitable' requires at least one pathname\");",
"goto out;",
"}",
"if (!acpi_tables) {",
"allen = sizeof(uint16_t);",
"acpi_tables = g_malloc0(allen);",
"} else {",
"allen = acpi_tables_len;",
"}",
"start = allen;",
"acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);",
"allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;",
"for (VAR_2 = VAR_1; *VAR_2; ++VAR_2) {",
"int VAR_7 = open(*VAR_2, O_RDONLY | O_BINARY);",
"if (VAR_7 < 0) {",
"error_setg(&err, \"can't open file %s: %s\", *VAR_2, strerror(errno));",
"goto out;",
"}",
"for (;;) {",
"char unsigned VAR_8[8192];",
"VAR_4 = read(VAR_7, VAR_8, sizeof(VAR_8));",
"if (VAR_4 == 0) {",
"break;",
"} else if (VAR_4 > 0) {",
"acpi_tables = g_realloc(acpi_tables, allen + VAR_4);",
"memcpy(acpi_tables + allen, VAR_8, VAR_4);",
"allen += VAR_4;",
"} else if (errno != EINTR) {",
"error_setg(&err, \"can't read file %s: %s\",\n*VAR_2, strerror(errno));",
"close(VAR_7);",
"goto out;",
"}",
"}",
"close(VAR_7);",
"}",
"VAR_6 = acpi_tables + start;",
"VAR_3 = 0;",
"memcpy(&VAR_5, has_header ? VAR_6 : dfl_hdr, ACPI_TABLE_HDR_SIZE);",
"len = allen - start - ACPI_TABLE_PFX_SIZE;",
"VAR_5._length = cpu_to_le16(len);",
"if (hdrs->has_sig) {",
"strncpy(VAR_5.sig, hdrs->sig, sizeof(VAR_5.sig));",
"++VAR_3;",
"}",
"if (has_header) {",
"unsigned long VAR_9;",
"VAR_9 = le32_to_cpu(VAR_5.length);",
"if (VAR_9 != len) {",
"fprintf(stderr,\n\"warning: acpitable has wrong length,\"\n\" header says %lu, actual size %zu bytes\\n\",\nVAR_9, len);",
"++VAR_3;",
"}",
"}",
"VAR_5.length = cpu_to_le32(len);",
"if (hdrs->has_rev) {",
"VAR_5.revision = hdrs->rev;",
"++VAR_3;",
"}",
"if (hdrs->has_oem_id) {",
"strncpy(VAR_5.oem_id, hdrs->oem_id, sizeof(VAR_5.oem_id));",
"++VAR_3;",
"}",
"if (hdrs->has_oem_table_id) {",
"strncpy(VAR_5.oem_table_id, hdrs->oem_table_id,\nsizeof(VAR_5.oem_table_id));",
"++VAR_3;",
"}",
"if (hdrs->has_oem_rev) {",
"VAR_5.oem_revision = cpu_to_le32(hdrs->oem_rev);",
"++VAR_3;",
"}",
"if (hdrs->has_asl_compiler_id) {",
"strncpy(VAR_5.asl_compiler_id, hdrs->asl_compiler_id,\nsizeof(VAR_5.asl_compiler_id));",
"++VAR_3;",
"}",
"if (hdrs->has_asl_compiler_rev) {",
"VAR_5.asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);",
"++VAR_3;",
"}",
"if (!has_header && !VAR_3) {",
"fprintf(stderr, \"warning: acpitable: no table headers are specified\\n\");",
"}",
"VAR_5.checksum = 0;",
"memcpy(VAR_6, &VAR_5, sizeof(VAR_5));",
"if (VAR_3 || !has_header || 1) {",
"((struct acpi_table_header *)VAR_6)->checksum =\nacpi_checksum((uint8_t *)VAR_6 + ACPI_TABLE_PFX_SIZE, len);",
"}",
"(*(uint16_t *)acpi_tables) =\ncpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);",
"acpi_tables_len = allen;",
"out:\ng_strfreev(VAR_1);",
"if (hdrs != NULL) {",
"QapiDeallocVisitor *dv;",
"dv = qapi_dealloc_visitor_new();",
"visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv), &hdrs, NULL,\nNULL);",
"qapi_dealloc_visitor_cleanup(dv);",
"}",
"if (err) {",
"fprintf(stderr, \"%s\\n\", error_get_pretty(err));",
"error_free(err);",
"return -1;",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
1,
1,
0,
1,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
0,
0,
1,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
1,
0,
1,
1,
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
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
101
],
[
103
],
[
107
],
[
109
],
[
111
],
[
113
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137,
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
151
],
[
153
],
[
161
],
[
163
],
[
169
],
[
175
],
[
179
],
[
183
],
[
187
],
[
189
],
[
191
],
[
197
],
[
199
],
[
205
],
[
207
],
[
209,
211,
213,
215
],
[
217
],
[
219
],
[
221
],
[
225
],
[
229
],
[
231
],
[
233
],
[
235
],
[
239
],
[
243
],
[
245
],
[
247
],
[
251
],
[
255,
257
],
[
259
],
[
261
],
[
265
],
[
267
],
[
269
],
[
271
],
[
275
],
[
279,
281
],
[
283
],
[
285
],
[
289
],
[
291
],
[
293
],
[
295
],
[
299
],
[
301
],
[
303
],
[
315
],
[
321
],
[
325
],
[
327,
329
],
[
331
],
[
337,
339
],
[
343
],
[
347,
349
],
[
353
],
[
355
],
[
359
],
[
361,
363
],
[
365
],
[
367
],
[
371
],
[
373
],
[
375
],
[
377
],
[
379
],
[
381
],
[
383
]
] |
7,985 |
static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
int entries, i;
print_atom("stsz", atom);
get_byte(pb); /* version */
get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
sc->sample_size = get_be32(pb);
entries = get_be32(pb);
sc->sample_count = entries;
#ifdef DEBUG
av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count);
#endif
if(sc->sample_size)
return 0; /* there isn't any table following */
sc->sample_sizes = (long*) av_malloc(entries * sizeof(long));
if (!sc->sample_sizes)
return -1;
for(i=0; i<entries; i++) {
sc->sample_sizes[i] = get_be32(pb);
#ifdef DEBUG
/* av_log(NULL, AV_LOG_DEBUG, "sample_sizes[]=%ld\n", sc->sample_sizes[i]); */
#endif
}
return 0;
}
| true |
FFmpeg
|
568e18b15e2ddf494fd8926707d34ca08c8edce5
|
static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
int entries, i;
print_atom("stsz", atom);
get_byte(pb);
get_byte(pb); get_byte(pb); get_byte(pb);
sc->sample_size = get_be32(pb);
entries = get_be32(pb);
sc->sample_count = entries;
#ifdef DEBUG
av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count);
#endif
if(sc->sample_size)
return 0;
sc->sample_sizes = (long*) av_malloc(entries * sizeof(long));
if (!sc->sample_sizes)
return -1;
for(i=0; i<entries; i++) {
sc->sample_sizes[i] = get_be32(pb);
#ifdef DEBUG
#endif
}
return 0;
}
|
{
"code": [
" int entries, i;",
" int entries, i;",
" int entries, i;",
" int entries, i;",
" int entries, i;"
],
"line_no": [
9,
9,
9,
9,
9
]
}
|
static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOV_atom_t VAR_2)
{
AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];
MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
int VAR_3, VAR_4;
print_atom("stsz", VAR_2);
get_byte(VAR_1);
get_byte(VAR_1); get_byte(VAR_1); get_byte(VAR_1);
sc->sample_size = get_be32(VAR_1);
VAR_3 = get_be32(VAR_1);
sc->sample_count = VAR_3;
#ifdef DEBUG
av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count);
#endif
if(sc->sample_size)
return 0;
sc->sample_sizes = (long*) av_malloc(VAR_3 * sizeof(long));
if (!sc->sample_sizes)
return -1;
for(VAR_4=0; VAR_4<VAR_3; VAR_4++) {
sc->sample_sizes[VAR_4] = get_be32(VAR_1);
#ifdef DEBUG
#endif
}
return 0;
}
|
[
"static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOV_atom_t VAR_2)\n{",
"AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];",
"MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;",
"int VAR_3, VAR_4;",
"print_atom(\"stsz\", VAR_2);",
"get_byte(VAR_1);",
"get_byte(VAR_1); get_byte(VAR_1); get_byte(VAR_1);",
"sc->sample_size = get_be32(VAR_1);",
"VAR_3 = get_be32(VAR_1);",
"sc->sample_count = VAR_3;",
"#ifdef DEBUG\nav_log(NULL, AV_LOG_DEBUG, \"sample_size = %ld sample_count = %ld\\n\", sc->sample_size, sc->sample_count);",
"#endif\nif(sc->sample_size)\nreturn 0;",
"sc->sample_sizes = (long*) av_malloc(VAR_3 * sizeof(long));",
"if (!sc->sample_sizes)\nreturn -1;",
"for(VAR_4=0; VAR_4<VAR_3; VAR_4++) {",
"sc->sample_sizes[VAR_4] = get_be32(VAR_1);",
"#ifdef DEBUG\n#endif\n}",
"return 0;",
"}"
] |
[
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29,
31
],
[
33,
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49,
53,
55
],
[
57
],
[
59
]
] |
7,986 |
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
void (*init)(struct CharDriverState *s))
{
CharDriverState *chr;
int i;
int ret;
if (qemu_opts_id(opts) == NULL) {
fprintf(stderr, "chardev: no id specified\n");
return NULL;
}
if (qemu_opt_get(opts, "backend") == NULL) {
fprintf(stderr, "chardev: \"%s\" missing backend\n",
qemu_opts_id(opts));
return NULL;
}
for (i = 0; i < ARRAY_SIZE(backend_table); i++) {
if (strcmp(backend_table[i].name, qemu_opt_get(opts, "backend")) == 0)
break;
}
if (i == ARRAY_SIZE(backend_table)) {
fprintf(stderr, "chardev: backend \"%s\" not found\n",
qemu_opt_get(opts, "backend"));
return NULL;
}
ret = backend_table[i].open(opts, &chr);
if (ret < 0) {
fprintf(stderr, "chardev: opening backend \"%s\" failed: %s\n",
qemu_opt_get(opts, "backend"), strerror(-ret));
return NULL;
}
if (!chr->filename)
chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
chr->init = init;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
if (qemu_opt_get_bool(opts, "mux", 0)) {
CharDriverState *base = chr;
int len = strlen(qemu_opts_id(opts)) + 6;
base->label = g_malloc(len);
snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
chr = qemu_chr_open_mux(base);
chr->filename = base->filename;
chr->avail_connections = MAX_MUX;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
} else {
chr->avail_connections = 1;
}
chr->label = g_strdup(qemu_opts_id(opts));
return chr;
}
| true |
qemu
|
1f51470d044852592922f91000e741c381582cdc
|
CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
void (*init)(struct CharDriverState *s))
{
CharDriverState *chr;
int i;
int ret;
if (qemu_opts_id(opts) == NULL) {
fprintf(stderr, "chardev: no id specified\n");
return NULL;
}
if (qemu_opt_get(opts, "backend") == NULL) {
fprintf(stderr, "chardev: \"%s\" missing backend\n",
qemu_opts_id(opts));
return NULL;
}
for (i = 0; i < ARRAY_SIZE(backend_table); i++) {
if (strcmp(backend_table[i].name, qemu_opt_get(opts, "backend")) == 0)
break;
}
if (i == ARRAY_SIZE(backend_table)) {
fprintf(stderr, "chardev: backend \"%s\" not found\n",
qemu_opt_get(opts, "backend"));
return NULL;
}
ret = backend_table[i].open(opts, &chr);
if (ret < 0) {
fprintf(stderr, "chardev: opening backend \"%s\" failed: %s\n",
qemu_opt_get(opts, "backend"), strerror(-ret));
return NULL;
}
if (!chr->filename)
chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
chr->init = init;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
if (qemu_opt_get_bool(opts, "mux", 0)) {
CharDriverState *base = chr;
int len = strlen(qemu_opts_id(opts)) + 6;
base->label = g_malloc(len);
snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
chr = qemu_chr_open_mux(base);
chr->filename = base->filename;
chr->avail_connections = MAX_MUX;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
} else {
chr->avail_connections = 1;
}
chr->label = g_strdup(qemu_opts_id(opts));
return chr;
}
|
{
"code": [
" int ret;",
" int ret;",
" int ret;",
" ret = backend_table[i].open(opts, &chr);",
" if (ret < 0) {",
" fprintf(stderr, \"chardev: opening backend \\\"%s\\\" failed: %s\\n\",",
" qemu_opt_get(opts, \"backend\"), strerror(-ret));"
],
"line_no": [
11,
11,
11,
55,
57,
59,
61
]
}
|
CharDriverState *FUNC_0(QemuOpts *opts,
void (*init)(struct CharDriverState *s))
{
CharDriverState *chr;
int VAR_0;
int VAR_1;
if (qemu_opts_id(opts) == NULL) {
fprintf(stderr, "chardev: no id specified\n");
return NULL;
}
if (qemu_opt_get(opts, "backend") == NULL) {
fprintf(stderr, "chardev: \"%s\" missing backend\n",
qemu_opts_id(opts));
return NULL;
}
for (VAR_0 = 0; VAR_0 < ARRAY_SIZE(backend_table); VAR_0++) {
if (strcmp(backend_table[VAR_0].name, qemu_opt_get(opts, "backend")) == 0)
break;
}
if (VAR_0 == ARRAY_SIZE(backend_table)) {
fprintf(stderr, "chardev: backend \"%s\" not found\n",
qemu_opt_get(opts, "backend"));
return NULL;
}
VAR_1 = backend_table[VAR_0].open(opts, &chr);
if (VAR_1 < 0) {
fprintf(stderr, "chardev: opening backend \"%s\" failed: %s\n",
qemu_opt_get(opts, "backend"), strerror(-VAR_1));
return NULL;
}
if (!chr->filename)
chr->filename = g_strdup(qemu_opt_get(opts, "backend"));
chr->init = init;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
if (qemu_opt_get_bool(opts, "mux", 0)) {
CharDriverState *base = chr;
int VAR_2 = strlen(qemu_opts_id(opts)) + 6;
base->label = g_malloc(VAR_2);
snprintf(base->label, VAR_2, "%s-base", qemu_opts_id(opts));
chr = qemu_chr_open_mux(base);
chr->filename = base->filename;
chr->avail_connections = MAX_MUX;
QTAILQ_INSERT_TAIL(&chardevs, chr, next);
} else {
chr->avail_connections = 1;
}
chr->label = g_strdup(qemu_opts_id(opts));
return chr;
}
|
[
"CharDriverState *FUNC_0(QemuOpts *opts,\nvoid (*init)(struct CharDriverState *s))\n{",
"CharDriverState *chr;",
"int VAR_0;",
"int VAR_1;",
"if (qemu_opts_id(opts) == NULL) {",
"fprintf(stderr, \"chardev: no id specified\\n\");",
"return NULL;",
"}",
"if (qemu_opt_get(opts, \"backend\") == NULL) {",
"fprintf(stderr, \"chardev: \\\"%s\\\" missing backend\\n\",\nqemu_opts_id(opts));",
"return NULL;",
"}",
"for (VAR_0 = 0; VAR_0 < ARRAY_SIZE(backend_table); VAR_0++) {",
"if (strcmp(backend_table[VAR_0].name, qemu_opt_get(opts, \"backend\")) == 0)\nbreak;",
"}",
"if (VAR_0 == ARRAY_SIZE(backend_table)) {",
"fprintf(stderr, \"chardev: backend \\\"%s\\\" not found\\n\",\nqemu_opt_get(opts, \"backend\"));",
"return NULL;",
"}",
"VAR_1 = backend_table[VAR_0].open(opts, &chr);",
"if (VAR_1 < 0) {",
"fprintf(stderr, \"chardev: opening backend \\\"%s\\\" failed: %s\\n\",\nqemu_opt_get(opts, \"backend\"), strerror(-VAR_1));",
"return NULL;",
"}",
"if (!chr->filename)\nchr->filename = g_strdup(qemu_opt_get(opts, \"backend\"));",
"chr->init = init;",
"QTAILQ_INSERT_TAIL(&chardevs, chr, next);",
"if (qemu_opt_get_bool(opts, \"mux\", 0)) {",
"CharDriverState *base = chr;",
"int VAR_2 = strlen(qemu_opts_id(opts)) + 6;",
"base->label = g_malloc(VAR_2);",
"snprintf(base->label, VAR_2, \"%s-base\", qemu_opts_id(opts));",
"chr = qemu_chr_open_mux(base);",
"chr->filename = base->filename;",
"chr->avail_connections = MAX_MUX;",
"QTAILQ_INSERT_TAIL(&chardevs, chr, next);",
"} else {",
"chr->avail_connections = 1;",
"}",
"chr->label = g_strdup(qemu_opts_id(opts));",
"return chr;",
"}"
] |
[
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
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
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
69,
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
]
] |
7,987 |
static void bastardized_rice_decompress(ALACContext *alac,
int32_t *output_buffer,
int output_size,
int readsamplesize, /* arg_10 */
int rice_initialhistory, /* arg424->b */
int rice_kmodifier, /* arg424->d */
int rice_historymult, /* arg424->c */
int rice_kmodifier_mask /* arg424->e */
)
{
int output_count;
unsigned int history = rice_initialhistory;
int sign_modifier = 0;
for (output_count = 0; output_count < output_size; output_count++) {
int32_t x;
int32_t x_modified;
int32_t final_val;
/* standard rice encoding */
int k; /* size of extra bits */
/* read k, that is bits as is */
k = av_log2((history >> 9) + 3);
x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize);
x_modified = sign_modifier + x;
final_val = (x_modified + 1) / 2;
if (x_modified & 1) final_val *= -1;
output_buffer[output_count] = final_val;
sign_modifier = 0;
/* now update the history */
history += x_modified * rice_historymult
- ((history * rice_historymult) >> 9);
if (x_modified > 0xffff)
history = 0xffff;
/* special case: there may be compressed blocks of 0 */
if ((history < 128) && (output_count+1 < output_size)) {
int k;
unsigned int block_size;
sign_modifier = 1;
k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */);
block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16);
if (block_size > 0) {
if(block_size >= output_size - output_count){
av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
block_size= output_size - output_count - 1;
}
memset(&output_buffer[output_count+1], 0, block_size * 4);
output_count += block_size;
}
if (block_size > 0xffff)
sign_modifier = 0;
history = 0;
}
}
}
| true |
FFmpeg
|
a8469223f6bb756a44f6579439fcae24ccc739b1
|
static void bastardized_rice_decompress(ALACContext *alac,
int32_t *output_buffer,
int output_size,
int readsamplesize,
int rice_initialhistory,
int rice_kmodifier,
int rice_historymult,
int rice_kmodifier_mask
)
{
int output_count;
unsigned int history = rice_initialhistory;
int sign_modifier = 0;
for (output_count = 0; output_count < output_size; output_count++) {
int32_t x;
int32_t x_modified;
int32_t final_val;
int k;
k = av_log2((history >> 9) + 3);
x= decode_scalar(&alac->gb, k, rice_kmodifier, readsamplesize);
x_modified = sign_modifier + x;
final_val = (x_modified + 1) / 2;
if (x_modified & 1) final_val *= -1;
output_buffer[output_count] = final_val;
sign_modifier = 0;
history += x_modified * rice_historymult
- ((history * rice_historymult) >> 9);
if (x_modified > 0xffff)
history = 0xffff;
if ((history < 128) && (output_count+1 < output_size)) {
int k;
unsigned int block_size;
sign_modifier = 1;
k = 7 - av_log2(history) + ((history + 16) >> 6 );
block_size= decode_scalar(&alac->gb, k, rice_kmodifier, 16);
if (block_size > 0) {
if(block_size >= output_size - output_count){
av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
block_size= output_size - output_count - 1;
}
memset(&output_buffer[output_count+1], 0, block_size * 4);
output_count += block_size;
}
if (block_size > 0xffff)
sign_modifier = 0;
history = 0;
}
}
}
|
{
"code": [
"static void bastardized_rice_decompress(ALACContext *alac,"
],
"line_no": [
1
]
}
|
static void FUNC_0(ALACContext *VAR_0,
int32_t *VAR_1,
int VAR_2,
int VAR_3,
int VAR_4,
int VAR_5,
int VAR_6,
int VAR_7
)
{
int VAR_8;
unsigned int VAR_9 = VAR_4;
int VAR_10 = 0;
for (VAR_8 = 0; VAR_8 < VAR_2; VAR_8++) {
int32_t x;
int32_t x_modified;
int32_t final_val;
int VAR_12;
VAR_12 = av_log2((VAR_9 >> 9) + 3);
x= decode_scalar(&VAR_0->gb, VAR_12, VAR_5, VAR_3);
x_modified = VAR_10 + x;
final_val = (x_modified + 1) / 2;
if (x_modified & 1) final_val *= -1;
VAR_1[VAR_8] = final_val;
VAR_10 = 0;
VAR_9 += x_modified * VAR_6
- ((VAR_9 * VAR_6) >> 9);
if (x_modified > 0xffff)
VAR_9 = 0xffff;
if ((VAR_9 < 128) && (VAR_8+1 < VAR_2)) {
int VAR_12;
unsigned int VAR_12;
VAR_10 = 1;
VAR_12 = 7 - av_log2(VAR_9) + ((VAR_9 + 16) >> 6 );
VAR_12= decode_scalar(&VAR_0->gb, VAR_12, VAR_5, 16);
if (VAR_12 > 0) {
if(VAR_12 >= VAR_2 - VAR_8){
av_log(VAR_0->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", VAR_12, VAR_2, VAR_8);
VAR_12= VAR_2 - VAR_8 - 1;
}
memset(&VAR_1[VAR_8+1], 0, VAR_12 * 4);
VAR_8 += VAR_12;
}
if (VAR_12 > 0xffff)
VAR_10 = 0;
VAR_9 = 0;
}
}
}
|
[
"static void FUNC_0(ALACContext *VAR_0,\nint32_t *VAR_1,\nint VAR_2,\nint VAR_3,\nint VAR_4,\nint VAR_5,\nint VAR_6,\nint VAR_7\n)\n{",
"int VAR_8;",
"unsigned int VAR_9 = VAR_4;",
"int VAR_10 = 0;",
"for (VAR_8 = 0; VAR_8 < VAR_2; VAR_8++) {",
"int32_t x;",
"int32_t x_modified;",
"int32_t final_val;",
"int VAR_12;",
"VAR_12 = av_log2((VAR_9 >> 9) + 3);",
"x= decode_scalar(&VAR_0->gb, VAR_12, VAR_5, VAR_3);",
"x_modified = VAR_10 + x;",
"final_val = (x_modified + 1) / 2;",
"if (x_modified & 1) final_val *= -1;",
"VAR_1[VAR_8] = final_val;",
"VAR_10 = 0;",
"VAR_9 += x_modified * VAR_6\n- ((VAR_9 * VAR_6) >> 9);",
"if (x_modified > 0xffff)\nVAR_9 = 0xffff;",
"if ((VAR_9 < 128) && (VAR_8+1 < VAR_2)) {",
"int VAR_12;",
"unsigned int VAR_12;",
"VAR_10 = 1;",
"VAR_12 = 7 - av_log2(VAR_9) + ((VAR_9 + 16) >> 6 );",
"VAR_12= decode_scalar(&VAR_0->gb, VAR_12, VAR_5, 16);",
"if (VAR_12 > 0) {",
"if(VAR_12 >= VAR_2 - VAR_8){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"invalid zero block size of %d %d %d\\n\", VAR_12, VAR_2, VAR_8);",
"VAR_12= VAR_2 - VAR_8 - 1;",
"}",
"memset(&VAR_1[VAR_8+1], 0, VAR_12 * 4);",
"VAR_8 += VAR_12;",
"}",
"if (VAR_12 > 0xffff)\nVAR_10 = 0;",
"VAR_9 = 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
] |
[
[
1,
3,
5,
7,
9,
11,
13,
15,
17,
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
41
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
61
],
[
65
],
[
71,
73
],
[
77,
79
],
[
85
],
[
87
],
[
89
],
[
93
],
[
97
],
[
101
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
123,
125
],
[
129
],
[
131
],
[
133
],
[
135
]
] |
7,988 |
static int vdadec_decode(AVCodecContext *avctx,
void *data, int *got_frame, AVPacket *avpkt)
{
VDADecoderContext *ctx = avctx->priv_data;
AVFrame *pic = data;
int ret;
ret = ff_h264_decoder.decode(avctx, data, got_frame, avpkt);
if (*got_frame) {
AVBufferRef *buffer = pic->buf[0];
VDABufferContext *context = av_buffer_get_opaque(buffer);
CVPixelBufferRef cv_buffer = (CVPixelBufferRef)pic->data[3];
CVPixelBufferLockBaseAddress(cv_buffer, 0);
context->cv_buffer = cv_buffer;
pic->format = ctx->pix_fmt;
if (CVPixelBufferIsPlanar(cv_buffer)) {
int i, count = CVPixelBufferGetPlaneCount(cv_buffer);
av_assert0(count < 4);
for (i = 0; i < count; i++) {
pic->data[i] = CVPixelBufferGetBaseAddressOfPlane(cv_buffer, i);
pic->linesize[i] = CVPixelBufferGetBytesPerRowOfPlane(cv_buffer, i);
}
} else {
pic->data[0] = CVPixelBufferGetBaseAddress(cv_buffer);
pic->linesize[0] = CVPixelBufferGetBytesPerRow(cv_buffer);
}
}
avctx->pix_fmt = ctx->pix_fmt;
return ret;
}
| true |
FFmpeg
|
499b82f604616a6ce7de4bd8e15f4698702c1e6a
|
static int vdadec_decode(AVCodecContext *avctx,
void *data, int *got_frame, AVPacket *avpkt)
{
VDADecoderContext *ctx = avctx->priv_data;
AVFrame *pic = data;
int ret;
ret = ff_h264_decoder.decode(avctx, data, got_frame, avpkt);
if (*got_frame) {
AVBufferRef *buffer = pic->buf[0];
VDABufferContext *context = av_buffer_get_opaque(buffer);
CVPixelBufferRef cv_buffer = (CVPixelBufferRef)pic->data[3];
CVPixelBufferLockBaseAddress(cv_buffer, 0);
context->cv_buffer = cv_buffer;
pic->format = ctx->pix_fmt;
if (CVPixelBufferIsPlanar(cv_buffer)) {
int i, count = CVPixelBufferGetPlaneCount(cv_buffer);
av_assert0(count < 4);
for (i = 0; i < count; i++) {
pic->data[i] = CVPixelBufferGetBaseAddressOfPlane(cv_buffer, i);
pic->linesize[i] = CVPixelBufferGetBytesPerRowOfPlane(cv_buffer, i);
}
} else {
pic->data[0] = CVPixelBufferGetBaseAddress(cv_buffer);
pic->linesize[0] = CVPixelBufferGetBytesPerRow(cv_buffer);
}
}
avctx->pix_fmt = ctx->pix_fmt;
return ret;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2, AVPacket *VAR_3)
{
VDADecoderContext *ctx = VAR_0->priv_data;
AVFrame *pic = VAR_1;
int VAR_4;
VAR_4 = ff_h264_decoder.decode(VAR_0, VAR_1, VAR_2, VAR_3);
if (*VAR_2) {
AVBufferRef *buffer = pic->buf[0];
VDABufferContext *context = av_buffer_get_opaque(buffer);
CVPixelBufferRef cv_buffer = (CVPixelBufferRef)pic->VAR_1[3];
CVPixelBufferLockBaseAddress(cv_buffer, 0);
context->cv_buffer = cv_buffer;
pic->format = ctx->pix_fmt;
if (CVPixelBufferIsPlanar(cv_buffer)) {
int VAR_5, VAR_6 = CVPixelBufferGetPlaneCount(cv_buffer);
av_assert0(VAR_6 < 4);
for (VAR_5 = 0; VAR_5 < VAR_6; VAR_5++) {
pic->VAR_1[VAR_5] = CVPixelBufferGetBaseAddressOfPlane(cv_buffer, VAR_5);
pic->linesize[VAR_5] = CVPixelBufferGetBytesPerRowOfPlane(cv_buffer, VAR_5);
}
} else {
pic->VAR_1[0] = CVPixelBufferGetBaseAddress(cv_buffer);
pic->linesize[0] = CVPixelBufferGetBytesPerRow(cv_buffer);
}
}
VAR_0->pix_fmt = ctx->pix_fmt;
return VAR_4;
}
|
[
"static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2, AVPacket *VAR_3)\n{",
"VDADecoderContext *ctx = VAR_0->priv_data;",
"AVFrame *pic = VAR_1;",
"int VAR_4;",
"VAR_4 = ff_h264_decoder.decode(VAR_0, VAR_1, VAR_2, VAR_3);",
"if (*VAR_2) {",
"AVBufferRef *buffer = pic->buf[0];",
"VDABufferContext *context = av_buffer_get_opaque(buffer);",
"CVPixelBufferRef cv_buffer = (CVPixelBufferRef)pic->VAR_1[3];",
"CVPixelBufferLockBaseAddress(cv_buffer, 0);",
"context->cv_buffer = cv_buffer;",
"pic->format = ctx->pix_fmt;",
"if (CVPixelBufferIsPlanar(cv_buffer)) {",
"int VAR_5, VAR_6 = CVPixelBufferGetPlaneCount(cv_buffer);",
"av_assert0(VAR_6 < 4);",
"for (VAR_5 = 0; VAR_5 < VAR_6; VAR_5++) {",
"pic->VAR_1[VAR_5] = CVPixelBufferGetBaseAddressOfPlane(cv_buffer, VAR_5);",
"pic->linesize[VAR_5] = CVPixelBufferGetBytesPerRowOfPlane(cv_buffer, VAR_5);",
"}",
"} else {",
"pic->VAR_1[0] = CVPixelBufferGetBaseAddress(cv_buffer);",
"pic->linesize[0] = CVPixelBufferGetBytesPerRow(cv_buffer);",
"}",
"}",
"VAR_0->pix_fmt = ctx->pix_fmt;",
"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
] |
[
[
1,
2,
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22
],
[
23
],
[
24
],
[
25
],
[
26
],
[
27
],
[
28
],
[
29
]
] |
7,990 |
static int target_pread(int fd, abi_ulong ptr, abi_ulong len,
abi_ulong offset)
{
void *buf;
int ret;
buf = lock_user(VERIFY_WRITE, ptr, len, 0);
ret = pread(fd, buf, len, offset);
unlock_user(buf, ptr, len);
return ret;
| true |
qemu
|
e5a869ed569a97fa676e9827952629086ec41f4e
|
static int target_pread(int fd, abi_ulong ptr, abi_ulong len,
abi_ulong offset)
{
void *buf;
int ret;
buf = lock_user(VERIFY_WRITE, ptr, len, 0);
ret = pread(fd, buf, len, offset);
unlock_user(buf, ptr, len);
return ret;
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(int VAR_0, abi_ulong VAR_1, abi_ulong VAR_2,
abi_ulong VAR_3)
{
void *VAR_4;
int VAR_5;
VAR_4 = lock_user(VERIFY_WRITE, VAR_1, VAR_2, 0);
VAR_5 = pread(VAR_0, VAR_4, VAR_2, VAR_3);
unlock_user(VAR_4, VAR_1, VAR_2);
return VAR_5;
|
[
"static int FUNC_0(int VAR_0, abi_ulong VAR_1, abi_ulong VAR_2,\nabi_ulong VAR_3)\n{",
"void *VAR_4;",
"int VAR_5;",
"VAR_4 = lock_user(VERIFY_WRITE, VAR_1, VAR_2, 0);",
"VAR_5 = pread(VAR_0, VAR_4, VAR_2, VAR_3);",
"unlock_user(VAR_4, VAR_1, VAR_2);",
"return VAR_5;"
] |
[
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
18
],
[
23
],
[
25
]
] |
7,991 |
void helper_lret_protected(int shift, int addend)
{
helper_ret_protected(shift, 0, addend);
#ifdef CONFIG_KQEMU
if (kqemu_is_ok(env)) {
env->exception_index = -1;
cpu_loop_exit();
}
#endif
}
| false |
qemu
|
4a1418e07bdcfaa3177739e04707ecaec75d89e1
|
void helper_lret_protected(int shift, int addend)
{
helper_ret_protected(shift, 0, addend);
#ifdef CONFIG_KQEMU
if (kqemu_is_ok(env)) {
env->exception_index = -1;
cpu_loop_exit();
}
#endif
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(int VAR_0, int VAR_1)
{
helper_ret_protected(VAR_0, 0, VAR_1);
#ifdef CONFIG_KQEMU
if (kqemu_is_ok(env)) {
env->exception_index = -1;
cpu_loop_exit();
}
#endif
}
|
[
"void FUNC_0(int VAR_0, int VAR_1)\n{",
"helper_ret_protected(VAR_0, 0, VAR_1);",
"#ifdef CONFIG_KQEMU\nif (kqemu_is_ok(env)) {",
"env->exception_index = -1;",
"cpu_loop_exit();",
"}",
"#endif\n}"
] |
[
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7,
9
],
[
11
],
[
13
],
[
15
],
[
17,
19
]
] |
7,993 |
uint32_t gic_acknowledge_irq(GICState *s, int cpu)
{
int ret, irq, src;
int cm = 1 << cpu;
irq = s->current_pending[cpu];
if (irq == 1023
|| GIC_GET_PRIORITY(irq, cpu) >= s->running_priority[cpu]) {
DPRINTF("ACK no pending IRQ\n");
return 1023;
}
s->last_active[irq][cpu] = s->running_irq[cpu];
if (s->revision == REV_11MPCORE || s->revision == REV_NVIC) {
/* Clear pending flags for both level and edge triggered interrupts.
* Level triggered IRQs will be reasserted once they become inactive.
*/
GIC_CLEAR_PENDING(irq, GIC_TEST_MODEL(irq) ? ALL_CPU_MASK : cm);
ret = irq;
} else {
if (irq < GIC_NR_SGIS) {
/* Lookup the source CPU for the SGI and clear this in the
* sgi_pending map. Return the src and clear the overall pending
* state on this CPU if the SGI is not pending from any CPUs.
*/
assert(s->sgi_pending[irq][cpu] != 0);
src = ctz32(s->sgi_pending[irq][cpu]);
s->sgi_pending[irq][cpu] &= ~(1 << src);
if (s->sgi_pending[irq][cpu] == 0) {
GIC_CLEAR_PENDING(irq, GIC_TEST_MODEL(irq) ? ALL_CPU_MASK : cm);
}
ret = irq | ((src & 0x7) << 10);
} else {
/* Clear pending state for both level and edge triggered
* interrupts. (level triggered interrupts with an active line
* remain pending, see gic_test_pending)
*/
GIC_CLEAR_PENDING(irq, GIC_TEST_MODEL(irq) ? ALL_CPU_MASK : cm);
ret = irq;
}
}
gic_set_running_irq(s, cpu, irq);
DPRINTF("ACK %d\n", irq);
return ret;
}
| false |
qemu
|
c5619bf9e8935aeb972c0bd935549e9ee0a739f2
|
uint32_t gic_acknowledge_irq(GICState *s, int cpu)
{
int ret, irq, src;
int cm = 1 << cpu;
irq = s->current_pending[cpu];
if (irq == 1023
|| GIC_GET_PRIORITY(irq, cpu) >= s->running_priority[cpu]) {
DPRINTF("ACK no pending IRQ\n");
return 1023;
}
s->last_active[irq][cpu] = s->running_irq[cpu];
if (s->revision == REV_11MPCORE || s->revision == REV_NVIC) {
GIC_CLEAR_PENDING(irq, GIC_TEST_MODEL(irq) ? ALL_CPU_MASK : cm);
ret = irq;
} else {
if (irq < GIC_NR_SGIS) {
assert(s->sgi_pending[irq][cpu] != 0);
src = ctz32(s->sgi_pending[irq][cpu]);
s->sgi_pending[irq][cpu] &= ~(1 << src);
if (s->sgi_pending[irq][cpu] == 0) {
GIC_CLEAR_PENDING(irq, GIC_TEST_MODEL(irq) ? ALL_CPU_MASK : cm);
}
ret = irq | ((src & 0x7) << 10);
} else {
GIC_CLEAR_PENDING(irq, GIC_TEST_MODEL(irq) ? ALL_CPU_MASK : cm);
ret = irq;
}
}
gic_set_running_irq(s, cpu, irq);
DPRINTF("ACK %d\n", irq);
return ret;
}
|
{
"code": [],
"line_no": []
}
|
uint32_t FUNC_0(GICState *s, int cpu)
{
int VAR_0, VAR_1, VAR_2;
int VAR_3 = 1 << cpu;
VAR_1 = s->current_pending[cpu];
if (VAR_1 == 1023
|| GIC_GET_PRIORITY(VAR_1, cpu) >= s->running_priority[cpu]) {
DPRINTF("ACK no pending IRQ\n");
return 1023;
}
s->last_active[VAR_1][cpu] = s->running_irq[cpu];
if (s->revision == REV_11MPCORE || s->revision == REV_NVIC) {
GIC_CLEAR_PENDING(VAR_1, GIC_TEST_MODEL(VAR_1) ? ALL_CPU_MASK : VAR_3);
VAR_0 = VAR_1;
} else {
if (VAR_1 < GIC_NR_SGIS) {
assert(s->sgi_pending[VAR_1][cpu] != 0);
VAR_2 = ctz32(s->sgi_pending[VAR_1][cpu]);
s->sgi_pending[VAR_1][cpu] &= ~(1 << VAR_2);
if (s->sgi_pending[VAR_1][cpu] == 0) {
GIC_CLEAR_PENDING(VAR_1, GIC_TEST_MODEL(VAR_1) ? ALL_CPU_MASK : VAR_3);
}
VAR_0 = VAR_1 | ((VAR_2 & 0x7) << 10);
} else {
GIC_CLEAR_PENDING(VAR_1, GIC_TEST_MODEL(VAR_1) ? ALL_CPU_MASK : VAR_3);
VAR_0 = VAR_1;
}
}
gic_set_running_irq(s, cpu, VAR_1);
DPRINTF("ACK %d\n", VAR_1);
return VAR_0;
}
|
[
"uint32_t FUNC_0(GICState *s, int cpu)\n{",
"int VAR_0, VAR_1, VAR_2;",
"int VAR_3 = 1 << cpu;",
"VAR_1 = s->current_pending[cpu];",
"if (VAR_1 == 1023\n|| GIC_GET_PRIORITY(VAR_1, cpu) >= s->running_priority[cpu]) {",
"DPRINTF(\"ACK no pending IRQ\\n\");",
"return 1023;",
"}",
"s->last_active[VAR_1][cpu] = s->running_irq[cpu];",
"if (s->revision == REV_11MPCORE || s->revision == REV_NVIC) {",
"GIC_CLEAR_PENDING(VAR_1, GIC_TEST_MODEL(VAR_1) ? ALL_CPU_MASK : VAR_3);",
"VAR_0 = VAR_1;",
"} else {",
"if (VAR_1 < GIC_NR_SGIS) {",
"assert(s->sgi_pending[VAR_1][cpu] != 0);",
"VAR_2 = ctz32(s->sgi_pending[VAR_1][cpu]);",
"s->sgi_pending[VAR_1][cpu] &= ~(1 << VAR_2);",
"if (s->sgi_pending[VAR_1][cpu] == 0) {",
"GIC_CLEAR_PENDING(VAR_1, GIC_TEST_MODEL(VAR_1) ? ALL_CPU_MASK : VAR_3);",
"}",
"VAR_0 = VAR_1 | ((VAR_2 & 0x7) << 10);",
"} else {",
"GIC_CLEAR_PENDING(VAR_1, GIC_TEST_MODEL(VAR_1) ? ALL_CPU_MASK : VAR_3);",
"VAR_0 = VAR_1;",
"}",
"}",
"gic_set_running_irq(s, cpu, VAR_1);",
"DPRINTF(\"ACK %d\\n\", VAR_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,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
33
],
[
35
],
[
37
],
[
39
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
89
]
] |
7,994 |
av_cold void ff_dsputil_init_ppc(DSPContext *c, AVCodecContext *avctx)
{
const int high_bit_depth = avctx->bits_per_raw_sample > 8;
// Common optimizations whether AltiVec is available or not
if (!high_bit_depth) {
switch (check_dcbzl_effect()) {
case 32:
c->clear_blocks = clear_blocks_dcbz32_ppc;
break;
case 128:
c->clear_blocks = clear_blocks_dcbz128_ppc;
break;
default:
break;
}
}
#if HAVE_ALTIVEC
if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {
ff_dsputil_init_altivec(c, avctx);
ff_int_init_altivec(c, avctx);
c->gmc1 = ff_gmc1_altivec;
#if CONFIG_ENCODERS
if (avctx->bits_per_raw_sample <= 8 &&
(avctx->dct_algo == FF_DCT_AUTO ||
avctx->dct_algo == FF_DCT_ALTIVEC)) {
c->fdct = ff_fdct_altivec;
}
#endif //CONFIG_ENCODERS
if (avctx->bits_per_raw_sample <= 8) {
if ((avctx->idct_algo == FF_IDCT_AUTO) ||
(avctx->idct_algo == FF_IDCT_ALTIVEC)) {
c->idct_put = ff_idct_put_altivec;
c->idct_add = ff_idct_add_altivec;
c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
}
}
}
#endif /* HAVE_ALTIVEC */
}
| false |
FFmpeg
|
f61bece684d9685b07895508e6c1c733b5564ccf
|
av_cold void ff_dsputil_init_ppc(DSPContext *c, AVCodecContext *avctx)
{
const int high_bit_depth = avctx->bits_per_raw_sample > 8;
if (!high_bit_depth) {
switch (check_dcbzl_effect()) {
case 32:
c->clear_blocks = clear_blocks_dcbz32_ppc;
break;
case 128:
c->clear_blocks = clear_blocks_dcbz128_ppc;
break;
default:
break;
}
}
#if HAVE_ALTIVEC
if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {
ff_dsputil_init_altivec(c, avctx);
ff_int_init_altivec(c, avctx);
c->gmc1 = ff_gmc1_altivec;
#if CONFIG_ENCODERS
if (avctx->bits_per_raw_sample <= 8 &&
(avctx->dct_algo == FF_DCT_AUTO ||
avctx->dct_algo == FF_DCT_ALTIVEC)) {
c->fdct = ff_fdct_altivec;
}
#endif
if (avctx->bits_per_raw_sample <= 8) {
if ((avctx->idct_algo == FF_IDCT_AUTO) ||
(avctx->idct_algo == FF_IDCT_ALTIVEC)) {
c->idct_put = ff_idct_put_altivec;
c->idct_add = ff_idct_add_altivec;
c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
}
}
}
#endif
}
|
{
"code": [],
"line_no": []
}
|
av_cold void FUNC_0(DSPContext *c, AVCodecContext *avctx)
{
const int VAR_0 = avctx->bits_per_raw_sample > 8;
if (!VAR_0) {
switch (check_dcbzl_effect()) {
case 32:
c->clear_blocks = clear_blocks_dcbz32_ppc;
break;
case 128:
c->clear_blocks = clear_blocks_dcbz128_ppc;
break;
default:
break;
}
}
#if HAVE_ALTIVEC
if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {
ff_dsputil_init_altivec(c, avctx);
ff_int_init_altivec(c, avctx);
c->gmc1 = ff_gmc1_altivec;
#if CONFIG_ENCODERS
if (avctx->bits_per_raw_sample <= 8 &&
(avctx->dct_algo == FF_DCT_AUTO ||
avctx->dct_algo == FF_DCT_ALTIVEC)) {
c->fdct = ff_fdct_altivec;
}
#endif
if (avctx->bits_per_raw_sample <= 8) {
if ((avctx->idct_algo == FF_IDCT_AUTO) ||
(avctx->idct_algo == FF_IDCT_ALTIVEC)) {
c->idct_put = ff_idct_put_altivec;
c->idct_add = ff_idct_add_altivec;
c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
}
}
}
#endif
}
|
[
"av_cold void FUNC_0(DSPContext *c, AVCodecContext *avctx)\n{",
"const int VAR_0 = avctx->bits_per_raw_sample > 8;",
"if (!VAR_0) {",
"switch (check_dcbzl_effect()) {",
"case 32:\nc->clear_blocks = clear_blocks_dcbz32_ppc;",
"break;",
"case 128:\nc->clear_blocks = clear_blocks_dcbz128_ppc;",
"break;",
"default:\nbreak;",
"}",
"}",
"#if HAVE_ALTIVEC\nif (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {",
"ff_dsputil_init_altivec(c, avctx);",
"ff_int_init_altivec(c, avctx);",
"c->gmc1 = ff_gmc1_altivec;",
"#if CONFIG_ENCODERS\nif (avctx->bits_per_raw_sample <= 8 &&\n(avctx->dct_algo == FF_DCT_AUTO ||\navctx->dct_algo == FF_DCT_ALTIVEC)) {",
"c->fdct = ff_fdct_altivec;",
"}",
"#endif\nif (avctx->bits_per_raw_sample <= 8) {",
"if ((avctx->idct_algo == FF_IDCT_AUTO) ||\n(avctx->idct_algo == FF_IDCT_ALTIVEC)) {",
"c->idct_put = ff_idct_put_altivec;",
"c->idct_add = ff_idct_add_altivec;",
"c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;",
"}",
"}",
"}",
"#endif\n}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
11
],
[
13
],
[
15,
17
],
[
19
],
[
21,
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
49,
51,
53,
55
],
[
57
],
[
59
],
[
61,
65
],
[
67,
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85,
87
]
] |
7,996 |
static IOMMUTLBEntry pbm_translate_iommu(MemoryRegion *iommu, hwaddr addr,
bool is_write)
{
IOMMUState *is = container_of(iommu, IOMMUState, iommu);
hwaddr baseaddr, offset;
uint64_t tte;
uint32_t tsbsize;
IOMMUTLBEntry ret = {
.target_as = &address_space_memory,
.iova = 0,
.translated_addr = 0,
.addr_mask = ~(hwaddr)0,
.perm = IOMMU_NONE,
};
if (!(is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_MMU_EN)) {
/* IOMMU disabled, passthrough using standard 8K page */
ret.iova = addr & IOMMU_PAGE_MASK_8K;
ret.translated_addr = addr;
ret.addr_mask = IOMMU_PAGE_MASK_8K;
ret.perm = IOMMU_RW;
return ret;
}
baseaddr = is->regs[IOMMU_BASE >> 3];
tsbsize = (is->regs[IOMMU_CTRL >> 3] >> IOMMU_CTRL_TSB_SHIFT) & 0x7;
if (is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_TBW_SIZE) {
/* 64K */
switch (tsbsize) {
case 0:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_64M) >> 13;
break;
case 1:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_128M) >> 13;
break;
case 2:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_256M) >> 13;
break;
case 3:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_512M) >> 13;
break;
case 4:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_1G) >> 13;
break;
case 5:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_2G) >> 13;
break;
default:
/* Not implemented, error */
return ret;
}
} else {
/* 8K */
switch (tsbsize) {
case 0:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_8M) >> 10;
break;
case 1:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_16M) >> 10;
break;
case 2:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_32M) >> 10;
break;
case 3:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_64M) >> 10;
break;
case 4:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_128M) >> 10;
break;
case 5:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_256M) >> 10;
break;
case 6:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_512M) >> 10;
break;
case 7:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_1G) >> 10;
break;
}
}
tte = address_space_ldq_be(&address_space_memory, baseaddr + offset,
MEMTXATTRS_UNSPECIFIED, NULL);
if (!(tte & IOMMU_TTE_DATA_V)) {
/* Invalid mapping */
return ret;
}
if (tte & IOMMU_TTE_DATA_W) {
/* Writeable */
ret.perm = IOMMU_RW;
} else {
ret.perm = IOMMU_RO;
}
/* Extract phys */
if (tte & IOMMU_TTE_DATA_SIZE) {
/* 64K */
ret.iova = addr & IOMMU_PAGE_MASK_64K;
ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_64K;
ret.addr_mask = (IOMMU_PAGE_SIZE_64K - 1);
} else {
/* 8K */
ret.iova = addr & IOMMU_PAGE_MASK_8K;
ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_8K;
ret.addr_mask = (IOMMU_PAGE_SIZE_8K - 1);
}
return ret;
}
| false |
qemu
|
bf55b7afce53718ef96f4e6616da62c0ccac37dd
|
static IOMMUTLBEntry pbm_translate_iommu(MemoryRegion *iommu, hwaddr addr,
bool is_write)
{
IOMMUState *is = container_of(iommu, IOMMUState, iommu);
hwaddr baseaddr, offset;
uint64_t tte;
uint32_t tsbsize;
IOMMUTLBEntry ret = {
.target_as = &address_space_memory,
.iova = 0,
.translated_addr = 0,
.addr_mask = ~(hwaddr)0,
.perm = IOMMU_NONE,
};
if (!(is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_MMU_EN)) {
ret.iova = addr & IOMMU_PAGE_MASK_8K;
ret.translated_addr = addr;
ret.addr_mask = IOMMU_PAGE_MASK_8K;
ret.perm = IOMMU_RW;
return ret;
}
baseaddr = is->regs[IOMMU_BASE >> 3];
tsbsize = (is->regs[IOMMU_CTRL >> 3] >> IOMMU_CTRL_TSB_SHIFT) & 0x7;
if (is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_TBW_SIZE) {
switch (tsbsize) {
case 0:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_64M) >> 13;
break;
case 1:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_128M) >> 13;
break;
case 2:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_256M) >> 13;
break;
case 3:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_512M) >> 13;
break;
case 4:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_1G) >> 13;
break;
case 5:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_2G) >> 13;
break;
default:
return ret;
}
} else {
switch (tsbsize) {
case 0:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_8M) >> 10;
break;
case 1:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_16M) >> 10;
break;
case 2:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_32M) >> 10;
break;
case 3:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_64M) >> 10;
break;
case 4:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_128M) >> 10;
break;
case 5:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_256M) >> 10;
break;
case 6:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_512M) >> 10;
break;
case 7:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_1G) >> 10;
break;
}
}
tte = address_space_ldq_be(&address_space_memory, baseaddr + offset,
MEMTXATTRS_UNSPECIFIED, NULL);
if (!(tte & IOMMU_TTE_DATA_V)) {
return ret;
}
if (tte & IOMMU_TTE_DATA_W) {
ret.perm = IOMMU_RW;
} else {
ret.perm = IOMMU_RO;
}
if (tte & IOMMU_TTE_DATA_SIZE) {
ret.iova = addr & IOMMU_PAGE_MASK_64K;
ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_64K;
ret.addr_mask = (IOMMU_PAGE_SIZE_64K - 1);
} else {
ret.iova = addr & IOMMU_PAGE_MASK_8K;
ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_8K;
ret.addr_mask = (IOMMU_PAGE_SIZE_8K - 1);
}
return ret;
}
|
{
"code": [],
"line_no": []
}
|
static IOMMUTLBEntry FUNC_0(MemoryRegion *iommu, hwaddr addr,
bool is_write)
{
IOMMUState *is = container_of(iommu, IOMMUState, iommu);
hwaddr baseaddr, offset;
uint64_t tte;
uint32_t tsbsize;
IOMMUTLBEntry ret = {
.target_as = &address_space_memory,
.iova = 0,
.translated_addr = 0,
.addr_mask = ~(hwaddr)0,
.perm = IOMMU_NONE,
};
if (!(is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_MMU_EN)) {
ret.iova = addr & IOMMU_PAGE_MASK_8K;
ret.translated_addr = addr;
ret.addr_mask = IOMMU_PAGE_MASK_8K;
ret.perm = IOMMU_RW;
return ret;
}
baseaddr = is->regs[IOMMU_BASE >> 3];
tsbsize = (is->regs[IOMMU_CTRL >> 3] >> IOMMU_CTRL_TSB_SHIFT) & 0x7;
if (is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_TBW_SIZE) {
switch (tsbsize) {
case 0:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_64M) >> 13;
break;
case 1:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_128M) >> 13;
break;
case 2:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_256M) >> 13;
break;
case 3:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_512M) >> 13;
break;
case 4:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_1G) >> 13;
break;
case 5:
offset = (addr & IOMMU_TSB_64K_OFFSET_MASK_2G) >> 13;
break;
default:
return ret;
}
} else {
switch (tsbsize) {
case 0:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_8M) >> 10;
break;
case 1:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_16M) >> 10;
break;
case 2:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_32M) >> 10;
break;
case 3:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_64M) >> 10;
break;
case 4:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_128M) >> 10;
break;
case 5:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_256M) >> 10;
break;
case 6:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_512M) >> 10;
break;
case 7:
offset = (addr & IOMMU_TSB_8K_OFFSET_MASK_1G) >> 10;
break;
}
}
tte = address_space_ldq_be(&address_space_memory, baseaddr + offset,
MEMTXATTRS_UNSPECIFIED, NULL);
if (!(tte & IOMMU_TTE_DATA_V)) {
return ret;
}
if (tte & IOMMU_TTE_DATA_W) {
ret.perm = IOMMU_RW;
} else {
ret.perm = IOMMU_RO;
}
if (tte & IOMMU_TTE_DATA_SIZE) {
ret.iova = addr & IOMMU_PAGE_MASK_64K;
ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_64K;
ret.addr_mask = (IOMMU_PAGE_SIZE_64K - 1);
} else {
ret.iova = addr & IOMMU_PAGE_MASK_8K;
ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_8K;
ret.addr_mask = (IOMMU_PAGE_SIZE_8K - 1);
}
return ret;
}
|
[
"static IOMMUTLBEntry FUNC_0(MemoryRegion *iommu, hwaddr addr,\nbool is_write)\n{",
"IOMMUState *is = container_of(iommu, IOMMUState, iommu);",
"hwaddr baseaddr, offset;",
"uint64_t tte;",
"uint32_t tsbsize;",
"IOMMUTLBEntry ret = {",
".target_as = &address_space_memory,\n.iova = 0,\n.translated_addr = 0,\n.addr_mask = ~(hwaddr)0,\n.perm = IOMMU_NONE,\n};",
"if (!(is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_MMU_EN)) {",
"ret.iova = addr & IOMMU_PAGE_MASK_8K;",
"ret.translated_addr = addr;",
"ret.addr_mask = IOMMU_PAGE_MASK_8K;",
"ret.perm = IOMMU_RW;",
"return ret;",
"}",
"baseaddr = is->regs[IOMMU_BASE >> 3];",
"tsbsize = (is->regs[IOMMU_CTRL >> 3] >> IOMMU_CTRL_TSB_SHIFT) & 0x7;",
"if (is->regs[IOMMU_CTRL >> 3] & IOMMU_CTRL_TBW_SIZE) {",
"switch (tsbsize) {",
"case 0:\noffset = (addr & IOMMU_TSB_64K_OFFSET_MASK_64M) >> 13;",
"break;",
"case 1:\noffset = (addr & IOMMU_TSB_64K_OFFSET_MASK_128M) >> 13;",
"break;",
"case 2:\noffset = (addr & IOMMU_TSB_64K_OFFSET_MASK_256M) >> 13;",
"break;",
"case 3:\noffset = (addr & IOMMU_TSB_64K_OFFSET_MASK_512M) >> 13;",
"break;",
"case 4:\noffset = (addr & IOMMU_TSB_64K_OFFSET_MASK_1G) >> 13;",
"break;",
"case 5:\noffset = (addr & IOMMU_TSB_64K_OFFSET_MASK_2G) >> 13;",
"break;",
"default:\nreturn ret;",
"}",
"} else {",
"switch (tsbsize) {",
"case 0:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_8M) >> 10;",
"break;",
"case 1:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_16M) >> 10;",
"break;",
"case 2:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_32M) >> 10;",
"break;",
"case 3:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_64M) >> 10;",
"break;",
"case 4:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_128M) >> 10;",
"break;",
"case 5:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_256M) >> 10;",
"break;",
"case 6:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_512M) >> 10;",
"break;",
"case 7:\noffset = (addr & IOMMU_TSB_8K_OFFSET_MASK_1G) >> 10;",
"break;",
"}",
"}",
"tte = address_space_ldq_be(&address_space_memory, baseaddr + offset,\nMEMTXATTRS_UNSPECIFIED, NULL);",
"if (!(tte & IOMMU_TTE_DATA_V)) {",
"return ret;",
"}",
"if (tte & IOMMU_TTE_DATA_W) {",
"ret.perm = IOMMU_RW;",
"} else {",
"ret.perm = IOMMU_RO;",
"}",
"if (tte & IOMMU_TTE_DATA_SIZE) {",
"ret.iova = addr & IOMMU_PAGE_MASK_64K;",
"ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_64K;",
"ret.addr_mask = (IOMMU_PAGE_SIZE_64K - 1);",
"} else {",
"ret.iova = addr & IOMMU_PAGE_MASK_8K;",
"ret.translated_addr = tte & IOMMU_TTE_PHYS_MASK_8K;",
"ret.addr_mask = (IOMMU_PAGE_SIZE_8K - 1);",
"}",
"return ret;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
51
],
[
53
],
[
57
],
[
61
],
[
63,
65
],
[
67
],
[
69,
71
],
[
73
],
[
75,
77
],
[
79
],
[
81,
83
],
[
85
],
[
87,
89
],
[
91
],
[
93,
95
],
[
97
],
[
99,
103
],
[
105
],
[
107
],
[
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
],
[
167,
169
],
[
173
],
[
177
],
[
179
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
199
],
[
203
],
[
205
],
[
207
],
[
209
],
[
213
],
[
215
],
[
217
],
[
219
],
[
223
],
[
225
]
] |
7,997 |
static void coroutine_fn mirror_iteration(MirrorBlockJob *s)
{
BlockDriverState *source = s->common.bs;
int nb_sectors, sectors_per_chunk, nb_chunks;
int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector;
MirrorOp *op;
s->sector_num = hbitmap_iter_next(&s->hbi);
if (s->sector_num < 0) {
bdrv_dirty_iter_init(source, s->dirty_bitmap, &s->hbi);
s->sector_num = hbitmap_iter_next(&s->hbi);
trace_mirror_restart_iter(s,
bdrv_get_dirty_count(source, s->dirty_bitmap));
assert(s->sector_num >= 0);
}
hbitmap_next_sector = s->sector_num;
sector_num = s->sector_num;
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
end = s->common.len >> BDRV_SECTOR_BITS;
/* Extend the QEMUIOVector to include all adjacent blocks that will
* be copied in this operation.
*
* We have to do this if we have no backing file yet in the destination,
* and the cluster size is very large. Then we need to do COW ourselves.
* The first time a cluster is copied, copy it entirely. Note that,
* because both the granularity and the cluster size are powers of two,
* the number of sectors to copy cannot exceed one cluster.
*
* We also want to extend the QEMUIOVector to include more adjacent
* dirty blocks if possible, to limit the number of I/O operations and
* run efficiently even with a small granularity.
*/
nb_chunks = 0;
nb_sectors = 0;
next_sector = sector_num;
next_chunk = sector_num / sectors_per_chunk;
/* Wait for I/O to this cluster (from a previous iteration) to be done. */
while (test_bit(next_chunk, s->in_flight_bitmap)) {
trace_mirror_yield_in_flight(s, sector_num, s->in_flight);
qemu_coroutine_yield();
}
do {
int added_sectors, added_chunks;
if (!bdrv_get_dirty(source, s->dirty_bitmap, next_sector) ||
test_bit(next_chunk, s->in_flight_bitmap)) {
assert(nb_sectors > 0);
break;
}
added_sectors = sectors_per_chunk;
if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) {
bdrv_round_to_clusters(s->target,
next_sector, added_sectors,
&next_sector, &added_sectors);
/* On the first iteration, the rounding may make us copy
* sectors before the first dirty one.
*/
if (next_sector < sector_num) {
assert(nb_sectors == 0);
sector_num = next_sector;
next_chunk = next_sector / sectors_per_chunk;
}
}
added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors));
added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk;
/* When doing COW, it may happen that there is not enough space for
* a full cluster. Wait if that is the case.
*/
while (nb_chunks == 0 && s->buf_free_count < added_chunks) {
trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight);
qemu_coroutine_yield();
}
if (s->buf_free_count < nb_chunks + added_chunks) {
trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight);
break;
}
/* We have enough free space to copy these sectors. */
bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks);
nb_sectors += added_sectors;
nb_chunks += added_chunks;
next_sector += added_sectors;
next_chunk += added_chunks;
} while (next_sector < end);
/* Allocate a MirrorOp that is used as an AIO callback. */
op = g_slice_new(MirrorOp);
op->s = s;
op->sector_num = sector_num;
op->nb_sectors = nb_sectors;
/* Now make a QEMUIOVector taking enough granularity-sized chunks
* from s->buf_free.
*/
qemu_iovec_init(&op->qiov, nb_chunks);
next_sector = sector_num;
while (nb_chunks-- > 0) {
MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free);
QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next);
s->buf_free_count--;
qemu_iovec_add(&op->qiov, buf, s->granularity);
/* Advance the HBitmapIter in parallel, so that we do not examine
* the same sector twice.
*/
if (next_sector > hbitmap_next_sector
&& bdrv_get_dirty(source, s->dirty_bitmap, next_sector)) {
hbitmap_next_sector = hbitmap_iter_next(&s->hbi);
}
next_sector += sectors_per_chunk;
}
bdrv_reset_dirty(source, sector_num, nb_sectors);
/* Copy the dirty cluster. */
s->in_flight++;
trace_mirror_one_iteration(s, sector_num, nb_sectors);
bdrv_aio_readv(source, sector_num, &op->qiov, nb_sectors,
mirror_read_complete, op);
}
| false |
qemu
|
cc8c9d6c6f28e4e376a6561a2a31524fd069bc2d
|
static void coroutine_fn mirror_iteration(MirrorBlockJob *s)
{
BlockDriverState *source = s->common.bs;
int nb_sectors, sectors_per_chunk, nb_chunks;
int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector;
MirrorOp *op;
s->sector_num = hbitmap_iter_next(&s->hbi);
if (s->sector_num < 0) {
bdrv_dirty_iter_init(source, s->dirty_bitmap, &s->hbi);
s->sector_num = hbitmap_iter_next(&s->hbi);
trace_mirror_restart_iter(s,
bdrv_get_dirty_count(source, s->dirty_bitmap));
assert(s->sector_num >= 0);
}
hbitmap_next_sector = s->sector_num;
sector_num = s->sector_num;
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
end = s->common.len >> BDRV_SECTOR_BITS;
nb_chunks = 0;
nb_sectors = 0;
next_sector = sector_num;
next_chunk = sector_num / sectors_per_chunk;
while (test_bit(next_chunk, s->in_flight_bitmap)) {
trace_mirror_yield_in_flight(s, sector_num, s->in_flight);
qemu_coroutine_yield();
}
do {
int added_sectors, added_chunks;
if (!bdrv_get_dirty(source, s->dirty_bitmap, next_sector) ||
test_bit(next_chunk, s->in_flight_bitmap)) {
assert(nb_sectors > 0);
break;
}
added_sectors = sectors_per_chunk;
if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) {
bdrv_round_to_clusters(s->target,
next_sector, added_sectors,
&next_sector, &added_sectors);
if (next_sector < sector_num) {
assert(nb_sectors == 0);
sector_num = next_sector;
next_chunk = next_sector / sectors_per_chunk;
}
}
added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors));
added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk;
while (nb_chunks == 0 && s->buf_free_count < added_chunks) {
trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight);
qemu_coroutine_yield();
}
if (s->buf_free_count < nb_chunks + added_chunks) {
trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight);
break;
}
bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks);
nb_sectors += added_sectors;
nb_chunks += added_chunks;
next_sector += added_sectors;
next_chunk += added_chunks;
} while (next_sector < end);
op = g_slice_new(MirrorOp);
op->s = s;
op->sector_num = sector_num;
op->nb_sectors = nb_sectors;
qemu_iovec_init(&op->qiov, nb_chunks);
next_sector = sector_num;
while (nb_chunks-- > 0) {
MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free);
QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next);
s->buf_free_count--;
qemu_iovec_add(&op->qiov, buf, s->granularity);
if (next_sector > hbitmap_next_sector
&& bdrv_get_dirty(source, s->dirty_bitmap, next_sector)) {
hbitmap_next_sector = hbitmap_iter_next(&s->hbi);
}
next_sector += sectors_per_chunk;
}
bdrv_reset_dirty(source, sector_num, nb_sectors);
s->in_flight++;
trace_mirror_one_iteration(s, sector_num, nb_sectors);
bdrv_aio_readv(source, sector_num, &op->qiov, nb_sectors,
mirror_read_complete, op);
}
|
{
"code": [],
"line_no": []
}
|
static void VAR_0 mirror_iteration(MirrorBlockJob *s)
{
BlockDriverState *source = s->common.bs;
int nb_sectors, sectors_per_chunk, nb_chunks;
int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector;
MirrorOp *op;
s->sector_num = hbitmap_iter_next(&s->hbi);
if (s->sector_num < 0) {
bdrv_dirty_iter_init(source, s->dirty_bitmap, &s->hbi);
s->sector_num = hbitmap_iter_next(&s->hbi);
trace_mirror_restart_iter(s,
bdrv_get_dirty_count(source, s->dirty_bitmap));
assert(s->sector_num >= 0);
}
hbitmap_next_sector = s->sector_num;
sector_num = s->sector_num;
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
end = s->common.len >> BDRV_SECTOR_BITS;
nb_chunks = 0;
nb_sectors = 0;
next_sector = sector_num;
next_chunk = sector_num / sectors_per_chunk;
while (test_bit(next_chunk, s->in_flight_bitmap)) {
trace_mirror_yield_in_flight(s, sector_num, s->in_flight);
qemu_coroutine_yield();
}
do {
int added_sectors, added_chunks;
if (!bdrv_get_dirty(source, s->dirty_bitmap, next_sector) ||
test_bit(next_chunk, s->in_flight_bitmap)) {
assert(nb_sectors > 0);
break;
}
added_sectors = sectors_per_chunk;
if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) {
bdrv_round_to_clusters(s->target,
next_sector, added_sectors,
&next_sector, &added_sectors);
if (next_sector < sector_num) {
assert(nb_sectors == 0);
sector_num = next_sector;
next_chunk = next_sector / sectors_per_chunk;
}
}
added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors));
added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk;
while (nb_chunks == 0 && s->buf_free_count < added_chunks) {
trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight);
qemu_coroutine_yield();
}
if (s->buf_free_count < nb_chunks + added_chunks) {
trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight);
break;
}
bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks);
nb_sectors += added_sectors;
nb_chunks += added_chunks;
next_sector += added_sectors;
next_chunk += added_chunks;
} while (next_sector < end);
op = g_slice_new(MirrorOp);
op->s = s;
op->sector_num = sector_num;
op->nb_sectors = nb_sectors;
qemu_iovec_init(&op->qiov, nb_chunks);
next_sector = sector_num;
while (nb_chunks-- > 0) {
MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free);
QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next);
s->buf_free_count--;
qemu_iovec_add(&op->qiov, buf, s->granularity);
if (next_sector > hbitmap_next_sector
&& bdrv_get_dirty(source, s->dirty_bitmap, next_sector)) {
hbitmap_next_sector = hbitmap_iter_next(&s->hbi);
}
next_sector += sectors_per_chunk;
}
bdrv_reset_dirty(source, sector_num, nb_sectors);
s->in_flight++;
trace_mirror_one_iteration(s, sector_num, nb_sectors);
bdrv_aio_readv(source, sector_num, &op->qiov, nb_sectors,
mirror_read_complete, op);
}
|
[
"static void VAR_0 mirror_iteration(MirrorBlockJob *s)\n{",
"BlockDriverState *source = s->common.bs;",
"int nb_sectors, sectors_per_chunk, nb_chunks;",
"int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector;",
"MirrorOp *op;",
"s->sector_num = hbitmap_iter_next(&s->hbi);",
"if (s->sector_num < 0) {",
"bdrv_dirty_iter_init(source, s->dirty_bitmap, &s->hbi);",
"s->sector_num = hbitmap_iter_next(&s->hbi);",
"trace_mirror_restart_iter(s,\nbdrv_get_dirty_count(source, s->dirty_bitmap));",
"assert(s->sector_num >= 0);",
"}",
"hbitmap_next_sector = s->sector_num;",
"sector_num = s->sector_num;",
"sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;",
"end = s->common.len >> BDRV_SECTOR_BITS;",
"nb_chunks = 0;",
"nb_sectors = 0;",
"next_sector = sector_num;",
"next_chunk = sector_num / sectors_per_chunk;",
"while (test_bit(next_chunk, s->in_flight_bitmap)) {",
"trace_mirror_yield_in_flight(s, sector_num, s->in_flight);",
"qemu_coroutine_yield();",
"}",
"do {",
"int added_sectors, added_chunks;",
"if (!bdrv_get_dirty(source, s->dirty_bitmap, next_sector) ||\ntest_bit(next_chunk, s->in_flight_bitmap)) {",
"assert(nb_sectors > 0);",
"break;",
"}",
"added_sectors = sectors_per_chunk;",
"if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) {",
"bdrv_round_to_clusters(s->target,\nnext_sector, added_sectors,\n&next_sector, &added_sectors);",
"if (next_sector < sector_num) {",
"assert(nb_sectors == 0);",
"sector_num = next_sector;",
"next_chunk = next_sector / sectors_per_chunk;",
"}",
"}",
"added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors));",
"added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk;",
"while (nb_chunks == 0 && s->buf_free_count < added_chunks) {",
"trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight);",
"qemu_coroutine_yield();",
"}",
"if (s->buf_free_count < nb_chunks + added_chunks) {",
"trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight);",
"break;",
"}",
"bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks);",
"nb_sectors += added_sectors;",
"nb_chunks += added_chunks;",
"next_sector += added_sectors;",
"next_chunk += added_chunks;",
"} while (next_sector < end);",
"op = g_slice_new(MirrorOp);",
"op->s = s;",
"op->sector_num = sector_num;",
"op->nb_sectors = nb_sectors;",
"qemu_iovec_init(&op->qiov, nb_chunks);",
"next_sector = sector_num;",
"while (nb_chunks-- > 0) {",
"MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free);",
"QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next);",
"s->buf_free_count--;",
"qemu_iovec_add(&op->qiov, buf, s->granularity);",
"if (next_sector > hbitmap_next_sector\n&& bdrv_get_dirty(source, s->dirty_bitmap, next_sector)) {",
"hbitmap_next_sector = hbitmap_iter_next(&s->hbi);",
"}",
"next_sector += sectors_per_chunk;",
"}",
"bdrv_reset_dirty(source, sector_num, nb_sectors);",
"s->in_flight++;",
"trace_mirror_one_iteration(s, sector_num, nb_sectors);",
"bdrv_aio_readv(source, sector_num, &op->qiov, nb_sectors,\nmirror_read_complete, op);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
69
],
[
71
],
[
73
],
[
75
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
97,
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113,
115,
117
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
141
],
[
143
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
173
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
191
],
[
193
],
[
195
],
[
197
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
229,
231
],
[
233
],
[
235
],
[
239
],
[
241
],
[
245
],
[
251
],
[
253
],
[
255,
257
],
[
259
]
] |
7,999 |
static int s390_cpu_initial_reset(S390CPU *cpu)
{
CPUState *cs = CPU(cpu);
CPUS390XState *env = &cpu->env;
int i;
s390_del_running_cpu(cpu);
if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) {
perror("cannot init reset vcpu");
}
/* Manually zero out all registers */
cpu_synchronize_state(cs);
for (i = 0; i < 16; i++) {
env->regs[i] = 0;
}
DPRINTF("DONE: SIGP initial reset: %p\n", env);
return 0;
}
| false |
qemu
|
f7d3e466764e0258d0883d90edb7e98ad0b56e18
|
static int s390_cpu_initial_reset(S390CPU *cpu)
{
CPUState *cs = CPU(cpu);
CPUS390XState *env = &cpu->env;
int i;
s390_del_running_cpu(cpu);
if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) {
perror("cannot init reset vcpu");
}
cpu_synchronize_state(cs);
for (i = 0; i < 16; i++) {
env->regs[i] = 0;
}
DPRINTF("DONE: SIGP initial reset: %p\n", env);
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(S390CPU *VAR_0)
{
CPUState *cs = CPU(VAR_0);
CPUS390XState *env = &VAR_0->env;
int VAR_1;
s390_del_running_cpu(VAR_0);
if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) {
perror("cannot init reset vcpu");
}
cpu_synchronize_state(cs);
for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {
env->regs[VAR_1] = 0;
}
DPRINTF("DONE: SIGP initial reset: %p\n", env);
return 0;
}
|
[
"static int FUNC_0(S390CPU *VAR_0)\n{",
"CPUState *cs = CPU(VAR_0);",
"CPUS390XState *env = &VAR_0->env;",
"int VAR_1;",
"s390_del_running_cpu(VAR_0);",
"if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) {",
"perror(\"cannot init reset vcpu\");",
"}",
"cpu_synchronize_state(cs);",
"for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {",
"env->regs[VAR_1] = 0;",
"}",
"DPRINTF(\"DONE: SIGP initial reset: %p\\n\", env);",
"return 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
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
]
] |
8,000 |
void virtio_setup_block(struct subchannel_id schid)
{
struct vq_info_block info;
struct vq_config_block config = {};
virtio_reset(schid);
config.index = 0;
if (run_ccw(schid, CCW_CMD_READ_VQ_CONF, &config, sizeof(config))) {
virtio_panic("Could not get block device configuration\n");
}
vring_init(&block, config.num, (void*)(100 * 1024 * 1024),
KVM_S390_VIRTIO_RING_ALIGN);
info.queue = (100ULL * 1024ULL* 1024ULL);
info.align = KVM_S390_VIRTIO_RING_ALIGN;
info.index = 0;
info.num = config.num;
block.schid = schid;
if (!run_ccw(schid, CCW_CMD_SET_VQ, &info, sizeof(info))) {
virtio_set_status(schid, VIRTIO_CONFIG_S_DRIVER_OK);
}
}
| false |
qemu
|
abd696e4f74a9d30801c6ae2693efe4e5979c2f2
|
void virtio_setup_block(struct subchannel_id schid)
{
struct vq_info_block info;
struct vq_config_block config = {};
virtio_reset(schid);
config.index = 0;
if (run_ccw(schid, CCW_CMD_READ_VQ_CONF, &config, sizeof(config))) {
virtio_panic("Could not get block device configuration\n");
}
vring_init(&block, config.num, (void*)(100 * 1024 * 1024),
KVM_S390_VIRTIO_RING_ALIGN);
info.queue = (100ULL * 1024ULL* 1024ULL);
info.align = KVM_S390_VIRTIO_RING_ALIGN;
info.index = 0;
info.num = config.num;
block.schid = schid;
if (!run_ccw(schid, CCW_CMD_SET_VQ, &info, sizeof(info))) {
virtio_set_status(schid, VIRTIO_CONFIG_S_DRIVER_OK);
}
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(struct subchannel_id VAR_0)
{
struct vq_info_block VAR_1;
struct vq_config_block VAR_2 = {};
virtio_reset(VAR_0);
VAR_2.index = 0;
if (run_ccw(VAR_0, CCW_CMD_READ_VQ_CONF, &VAR_2, sizeof(VAR_2))) {
virtio_panic("Could not get block device configuration\n");
}
vring_init(&block, VAR_2.num, (void*)(100 * 1024 * 1024),
KVM_S390_VIRTIO_RING_ALIGN);
VAR_1.queue = (100ULL * 1024ULL* 1024ULL);
VAR_1.align = KVM_S390_VIRTIO_RING_ALIGN;
VAR_1.index = 0;
VAR_1.num = VAR_2.num;
block.VAR_0 = VAR_0;
if (!run_ccw(VAR_0, CCW_CMD_SET_VQ, &VAR_1, sizeof(VAR_1))) {
virtio_set_status(VAR_0, VIRTIO_CONFIG_S_DRIVER_OK);
}
}
|
[
"void FUNC_0(struct subchannel_id VAR_0)\n{",
"struct vq_info_block VAR_1;",
"struct vq_config_block VAR_2 = {};",
"virtio_reset(VAR_0);",
"VAR_2.index = 0;",
"if (run_ccw(VAR_0, CCW_CMD_READ_VQ_CONF, &VAR_2, sizeof(VAR_2))) {",
"virtio_panic(\"Could not get block device configuration\\n\");",
"}",
"vring_init(&block, VAR_2.num, (void*)(100 * 1024 * 1024),\nKVM_S390_VIRTIO_RING_ALIGN);",
"VAR_1.queue = (100ULL * 1024ULL* 1024ULL);",
"VAR_1.align = KVM_S390_VIRTIO_RING_ALIGN;",
"VAR_1.index = 0;",
"VAR_1.num = VAR_2.num;",
"block.VAR_0 = VAR_0;",
"if (!run_ccw(VAR_0, CCW_CMD_SET_VQ, &VAR_1, sizeof(VAR_1))) {",
"virtio_set_status(VAR_0, VIRTIO_CONFIG_S_DRIVER_OK);",
"}",
"}"
] |
[
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,
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
]
] |
8,001 |
static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode)
{
return s->ops->open2(&s->ctx, path->data, flags, mode);
}
| false |
qemu
|
4750a96f6baf8949cc04a0c5b7167606544a4401
|
static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode)
{
return s->ops->open2(&s->ctx, path->data, flags, mode);
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(V9fsState *VAR_0, V9fsString *VAR_1, int VAR_2, mode_t VAR_3)
{
return VAR_0->ops->open2(&VAR_0->ctx, VAR_1->data, VAR_2, VAR_3);
}
|
[
"static int FUNC_0(V9fsState *VAR_0, V9fsString *VAR_1, int VAR_2, mode_t VAR_3)\n{",
"return VAR_0->ops->open2(&VAR_0->ctx, VAR_1->data, VAR_2, VAR_3);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
]
] |
8,002 |
udp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,
u_int lport, int flags)
{
struct sockaddr_in addr;
struct socket *so;
socklen_t addrlen = sizeof(struct sockaddr_in);
so = socreate(slirp);
if (!so) {
return NULL;
}
so->s = qemu_socket(AF_INET,SOCK_DGRAM,0);
so->so_expire = curtime + SO_EXPIRE;
insque(so, &slirp->udb);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = haddr;
addr.sin_port = hport;
if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
udp_detach(so);
return NULL;
}
socket_set_fast_reuse(so->s);
getsockname(so->s,(struct sockaddr *)&addr,&addrlen);
so->so_ffamily = AF_INET;
so->so_fport = addr.sin_port;
if (addr.sin_addr.s_addr == 0 ||
addr.sin_addr.s_addr == loopback_addr.s_addr) {
so->so_faddr = slirp->vhost_addr;
} else {
so->so_faddr = addr.sin_addr;
}
so->so_lfamily = AF_INET;
so->so_lport = lport;
so->so_laddr.s_addr = laddr;
if (flags != SS_FACCEPTONCE)
so->so_expire = 0;
so->so_state &= SS_PERSISTENT_MASK;
so->so_state |= SS_ISFCONNECTED | flags;
return so;
}
| false |
qemu
|
5379229a2708df3a1506113315214c3ce5325859
|
udp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,
u_int lport, int flags)
{
struct sockaddr_in addr;
struct socket *so;
socklen_t addrlen = sizeof(struct sockaddr_in);
so = socreate(slirp);
if (!so) {
return NULL;
}
so->s = qemu_socket(AF_INET,SOCK_DGRAM,0);
so->so_expire = curtime + SO_EXPIRE;
insque(so, &slirp->udb);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = haddr;
addr.sin_port = hport;
if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
udp_detach(so);
return NULL;
}
socket_set_fast_reuse(so->s);
getsockname(so->s,(struct sockaddr *)&addr,&addrlen);
so->so_ffamily = AF_INET;
so->so_fport = addr.sin_port;
if (addr.sin_addr.s_addr == 0 ||
addr.sin_addr.s_addr == loopback_addr.s_addr) {
so->so_faddr = slirp->vhost_addr;
} else {
so->so_faddr = addr.sin_addr;
}
so->so_lfamily = AF_INET;
so->so_lport = lport;
so->so_laddr.s_addr = laddr;
if (flags != SS_FACCEPTONCE)
so->so_expire = 0;
so->so_state &= SS_PERSISTENT_MASK;
so->so_state |= SS_ISFCONNECTED | flags;
return so;
}
|
{
"code": [],
"line_no": []
}
|
FUNC_0(Slirp *VAR_0, uint32_t VAR_1, u_int VAR_2, uint32_t VAR_3,
u_int VAR_4, int VAR_5)
{
struct sockaddr_in VAR_6;
struct socket *VAR_7;
socklen_t addrlen = sizeof(struct sockaddr_in);
VAR_7 = socreate(VAR_0);
if (!VAR_7) {
return NULL;
}
VAR_7->s = qemu_socket(AF_INET,SOCK_DGRAM,0);
VAR_7->so_expire = curtime + SO_EXPIRE;
insque(VAR_7, &VAR_0->udb);
VAR_6.sin_family = AF_INET;
VAR_6.sin_addr.s_addr = VAR_1;
VAR_6.sin_port = VAR_2;
if (bind(VAR_7->s,(struct sockaddr *)&VAR_6, addrlen) < 0) {
udp_detach(VAR_7);
return NULL;
}
socket_set_fast_reuse(VAR_7->s);
getsockname(VAR_7->s,(struct sockaddr *)&VAR_6,&addrlen);
VAR_7->so_ffamily = AF_INET;
VAR_7->so_fport = VAR_6.sin_port;
if (VAR_6.sin_addr.s_addr == 0 ||
VAR_6.sin_addr.s_addr == loopback_addr.s_addr) {
VAR_7->so_faddr = VAR_0->vhost_addr;
} else {
VAR_7->so_faddr = VAR_6.sin_addr;
}
VAR_7->so_lfamily = AF_INET;
VAR_7->so_lport = VAR_4;
VAR_7->so_laddr.s_addr = VAR_3;
if (VAR_5 != SS_FACCEPTONCE)
VAR_7->so_expire = 0;
VAR_7->so_state &= SS_PERSISTENT_MASK;
VAR_7->so_state |= SS_ISFCONNECTED | VAR_5;
return VAR_7;
}
|
[
"FUNC_0(Slirp *VAR_0, uint32_t VAR_1, u_int VAR_2, uint32_t VAR_3,\nu_int VAR_4, int VAR_5)\n{",
"struct sockaddr_in VAR_6;",
"struct socket *VAR_7;",
"socklen_t addrlen = sizeof(struct sockaddr_in);",
"VAR_7 = socreate(VAR_0);",
"if (!VAR_7) {",
"return NULL;",
"}",
"VAR_7->s = qemu_socket(AF_INET,SOCK_DGRAM,0);",
"VAR_7->so_expire = curtime + SO_EXPIRE;",
"insque(VAR_7, &VAR_0->udb);",
"VAR_6.sin_family = AF_INET;",
"VAR_6.sin_addr.s_addr = VAR_1;",
"VAR_6.sin_port = VAR_2;",
"if (bind(VAR_7->s,(struct sockaddr *)&VAR_6, addrlen) < 0) {",
"udp_detach(VAR_7);",
"return NULL;",
"}",
"socket_set_fast_reuse(VAR_7->s);",
"getsockname(VAR_7->s,(struct sockaddr *)&VAR_6,&addrlen);",
"VAR_7->so_ffamily = AF_INET;",
"VAR_7->so_fport = VAR_6.sin_port;",
"if (VAR_6.sin_addr.s_addr == 0 ||\nVAR_6.sin_addr.s_addr == loopback_addr.s_addr) {",
"VAR_7->so_faddr = VAR_0->vhost_addr;",
"} else {",
"VAR_7->so_faddr = VAR_6.sin_addr;",
"}",
"VAR_7->so_lfamily = AF_INET;",
"VAR_7->so_lport = VAR_4;",
"VAR_7->so_laddr.s_addr = VAR_3;",
"if (VAR_5 != SS_FACCEPTONCE)\nVAR_7->so_expire = 0;",
"VAR_7->so_state &= SS_PERSISTENT_MASK;",
"VAR_7->so_state |= SS_ISFCONNECTED | VAR_5;",
"return 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,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75,
77
],
[
81
],
[
83
],
[
87
],
[
89
]
] |
8,003 |
blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
QEMUIOVector *qiov, int flags)
{
BDRVBlkdebugState *s = bs->opaque;
BlkdebugRule *rule = NULL;
/* Sanity check block layer guarantees */
assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
if (bs->bl.max_transfer) {
assert(bytes <= bs->bl.max_transfer);
}
QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
uint64_t inject_offset = rule->options.inject.offset;
if (inject_offset == -1 ||
(inject_offset >= offset && inject_offset < offset + bytes))
{
break;
}
}
if (rule && rule->options.inject.error) {
return inject_error(bs, rule);
}
return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
}
| false |
qemu
|
d157ed5f7235f3d2d5596a514ad7507b18e24b88
|
blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
QEMUIOVector *qiov, int flags)
{
BDRVBlkdebugState *s = bs->opaque;
BlkdebugRule *rule = NULL;
assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
if (bs->bl.max_transfer) {
assert(bytes <= bs->bl.max_transfer);
}
QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
uint64_t inject_offset = rule->options.inject.offset;
if (inject_offset == -1 ||
(inject_offset >= offset && inject_offset < offset + bytes))
{
break;
}
}
if (rule && rule->options.inject.error) {
return inject_error(bs, rule);
}
return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
}
|
{
"code": [],
"line_no": []
}
|
FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1, uint64_t VAR_2,
QEMUIOVector *VAR_3, int VAR_4)
{
BDRVBlkdebugState *s = VAR_0->opaque;
BlkdebugRule *rule = NULL;
assert(QEMU_IS_ALIGNED(VAR_1, VAR_0->bl.request_alignment));
assert(QEMU_IS_ALIGNED(VAR_2, VAR_0->bl.request_alignment));
if (VAR_0->bl.max_transfer) {
assert(VAR_2 <= VAR_0->bl.max_transfer);
}
QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
uint64_t inject_offset = rule->options.inject.VAR_1;
if (inject_offset == -1 ||
(inject_offset >= VAR_1 && inject_offset < VAR_1 + VAR_2))
{
break;
}
}
if (rule && rule->options.inject.error) {
return inject_error(VAR_0, rule);
}
return bdrv_co_pwritev(VAR_0->file, VAR_1, VAR_2, VAR_3, VAR_4);
}
|
[
"FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1, uint64_t VAR_2,\nQEMUIOVector *VAR_3, int VAR_4)\n{",
"BDRVBlkdebugState *s = VAR_0->opaque;",
"BlkdebugRule *rule = NULL;",
"assert(QEMU_IS_ALIGNED(VAR_1, VAR_0->bl.request_alignment));",
"assert(QEMU_IS_ALIGNED(VAR_2, VAR_0->bl.request_alignment));",
"if (VAR_0->bl.max_transfer) {",
"assert(VAR_2 <= VAR_0->bl.max_transfer);",
"}",
"QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {",
"uint64_t inject_offset = rule->options.inject.VAR_1;",
"if (inject_offset == -1 ||\n(inject_offset >= VAR_1 && inject_offset < VAR_1 + VAR_2))\n{",
"break;",
"}",
"}",
"if (rule && rule->options.inject.error) {",
"return inject_error(VAR_0, rule);",
"}",
"return bdrv_co_pwritev(VAR_0->file, VAR_1, 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
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
33,
35,
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
]
] |
8,004 |
static void test_visitor_out_struct_errors(TestOutputVisitorData *data,
const void *unused)
{
EnumOne bad_values[] = { ENUM_ONE_MAX, -1 };
UserDefZero b;
UserDefOne u = { .base = &b }, *pu = &u;
Error *err;
int i;
for (i = 0; i < ARRAY_SIZE(bad_values) ; i++) {
err = NULL;
u.has_enum1 = true;
u.enum1 = bad_values[i];
visit_type_UserDefOne(data->ov, &pu, "unused", &err);
g_assert(err);
error_free(err);
}
}
| false |
qemu
|
ddf21908961073199f3d186204da4810f2ea150b
|
static void test_visitor_out_struct_errors(TestOutputVisitorData *data,
const void *unused)
{
EnumOne bad_values[] = { ENUM_ONE_MAX, -1 };
UserDefZero b;
UserDefOne u = { .base = &b }, *pu = &u;
Error *err;
int i;
for (i = 0; i < ARRAY_SIZE(bad_values) ; i++) {
err = NULL;
u.has_enum1 = true;
u.enum1 = bad_values[i];
visit_type_UserDefOne(data->ov, &pu, "unused", &err);
g_assert(err);
error_free(err);
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(TestOutputVisitorData *VAR_0,
const void *VAR_1)
{
EnumOne bad_values[] = { ENUM_ONE_MAX, -1 };
UserDefZero b;
UserDefOne u = { .base = &b }, *pu = &u;
Error *err;
int VAR_2;
for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(bad_values) ; VAR_2++) {
err = NULL;
u.has_enum1 = true;
u.enum1 = bad_values[VAR_2];
visit_type_UserDefOne(VAR_0->ov, &pu, "VAR_1", &err);
g_assert(err);
error_free(err);
}
}
|
[
"static void FUNC_0(TestOutputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"EnumOne bad_values[] = { ENUM_ONE_MAX, -1 };",
"UserDefZero b;",
"UserDefOne u = { .base = &b }, *pu = &u;",
"Error *err;",
"int VAR_2;",
"for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(bad_values) ; VAR_2++) {",
"err = NULL;",
"u.has_enum1 = true;",
"u.enum1 = bad_values[VAR_2];",
"visit_type_UserDefOne(VAR_0->ov, &pu, \"VAR_1\", &err);",
"g_assert(err);",
"error_free(err);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
8,005 |
static HEVCFrame *find_ref_idx(HEVCContext *s, int poc)
{
int i;
int LtMask = (1 << s->sps->log2_max_poc_lsb) - 1;
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *ref = &s->DPB[i];
if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) {
if ((ref->poc & LtMask) == poc)
return ref;
}
}
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *ref = &s->DPB[i];
if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
if (ref->poc == poc || (ref->poc & LtMask) == poc)
return ref;
}
}
av_log(s->avctx, AV_LOG_ERROR,
"Could not find ref with POC %d\n", poc);
return NULL;
}
| false |
FFmpeg
|
294bb6cbd7bdc52233ddfa8f88f99aaf0d64d183
|
static HEVCFrame *find_ref_idx(HEVCContext *s, int poc)
{
int i;
int LtMask = (1 << s->sps->log2_max_poc_lsb) - 1;
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *ref = &s->DPB[i];
if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) {
if ((ref->poc & LtMask) == poc)
return ref;
}
}
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *ref = &s->DPB[i];
if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
if (ref->poc == poc || (ref->poc & LtMask) == poc)
return ref;
}
}
av_log(s->avctx, AV_LOG_ERROR,
"Could not find ref with POC %d\n", poc);
return NULL;
}
|
{
"code": [],
"line_no": []
}
|
static HEVCFrame *FUNC_0(HEVCContext *s, int poc)
{
int VAR_0;
int VAR_1 = (1 << s->sps->log2_max_poc_lsb) - 1;
for (VAR_0 = 0; VAR_0 < FF_ARRAY_ELEMS(s->DPB); VAR_0++) {
HEVCFrame *ref = &s->DPB[VAR_0];
if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) {
if ((ref->poc & VAR_1) == poc)
return ref;
}
}
for (VAR_0 = 0; VAR_0 < FF_ARRAY_ELEMS(s->DPB); VAR_0++) {
HEVCFrame *ref = &s->DPB[VAR_0];
if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {
if (ref->poc == poc || (ref->poc & VAR_1) == poc)
return ref;
}
}
av_log(s->avctx, AV_LOG_ERROR,
"Could not find ref with POC %d\n", poc);
return NULL;
}
|
[
"static HEVCFrame *FUNC_0(HEVCContext *s, int poc)\n{",
"int VAR_0;",
"int VAR_1 = (1 << s->sps->log2_max_poc_lsb) - 1;",
"for (VAR_0 = 0; VAR_0 < FF_ARRAY_ELEMS(s->DPB); VAR_0++) {",
"HEVCFrame *ref = &s->DPB[VAR_0];",
"if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) {",
"if ((ref->poc & VAR_1) == poc)\nreturn ref;",
"}",
"}",
"for (VAR_0 = 0; VAR_0 < FF_ARRAY_ELEMS(s->DPB); VAR_0++) {",
"HEVCFrame *ref = &s->DPB[VAR_0];",
"if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {",
"if (ref->poc == poc || (ref->poc & VAR_1) == poc)\nreturn ref;",
"}",
"}",
"av_log(s->avctx, AV_LOG_ERROR,\n\"Could not find ref with POC %d\\n\", poc);",
"return NULL;",
"}"
] |
[
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
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
43,
45
],
[
47
],
[
49
]
] |
8,007 |
void timer_free(QEMUTimer *ts)
{
g_free(ts);
}
| false |
qemu
|
c2b38b277a7882a592f4f2ec955084b2b756daaa
|
void timer_free(QEMUTimer *ts)
{
g_free(ts);
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(QEMUTimer *VAR_0)
{
g_free(VAR_0);
}
|
[
"void FUNC_0(QEMUTimer *VAR_0)\n{",
"g_free(VAR_0);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
]
] |
8,008 |
int do_snapshot_blkdev(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
const char *device = qdict_get_str(qdict, "device");
const char *filename = qdict_get_try_str(qdict, "snapshot-file");
const char *format = qdict_get_try_str(qdict, "format");
BlockDriverState *bs;
BlockDriver *drv, *old_drv, *proto_drv;
int ret = 0;
int flags;
char old_filename[1024];
if (!filename) {
qerror_report(QERR_MISSING_PARAMETER, "snapshot-file");
ret = -1;
goto out;
}
bs = bdrv_find(device);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, device);
ret = -1;
goto out;
}
pstrcpy(old_filename, sizeof(old_filename), bs->filename);
old_drv = bs->drv;
flags = bs->open_flags;
if (!format) {
format = "qcow2";
}
drv = bdrv_find_format(format);
if (!drv) {
qerror_report(QERR_INVALID_BLOCK_FORMAT, format);
ret = -1;
goto out;
}
proto_drv = bdrv_find_protocol(filename);
if (!proto_drv) {
qerror_report(QERR_INVALID_BLOCK_FORMAT, format);
ret = -1;
goto out;
}
ret = bdrv_img_create(filename, format, bs->filename,
bs->drv->format_name, NULL, -1, flags);
if (ret) {
goto out;
}
qemu_aio_flush();
bdrv_flush(bs);
bdrv_close(bs);
ret = bdrv_open(bs, filename, flags, drv);
/*
* If reopening the image file we just created fails, fall back
* and try to re-open the original image. If that fails too, we
* are in serious trouble.
*/
if (ret != 0) {
ret = bdrv_open(bs, old_filename, flags, old_drv);
if (ret != 0) {
qerror_report(QERR_OPEN_FILE_FAILED, old_filename);
} else {
qerror_report(QERR_OPEN_FILE_FAILED, filename);
}
}
out:
if (ret) {
ret = -1;
}
return ret;
}
| false |
qemu
|
922453bca6a927bb527068ae8679d587cfa45dbc
|
int do_snapshot_blkdev(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
const char *device = qdict_get_str(qdict, "device");
const char *filename = qdict_get_try_str(qdict, "snapshot-file");
const char *format = qdict_get_try_str(qdict, "format");
BlockDriverState *bs;
BlockDriver *drv, *old_drv, *proto_drv;
int ret = 0;
int flags;
char old_filename[1024];
if (!filename) {
qerror_report(QERR_MISSING_PARAMETER, "snapshot-file");
ret = -1;
goto out;
}
bs = bdrv_find(device);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, device);
ret = -1;
goto out;
}
pstrcpy(old_filename, sizeof(old_filename), bs->filename);
old_drv = bs->drv;
flags = bs->open_flags;
if (!format) {
format = "qcow2";
}
drv = bdrv_find_format(format);
if (!drv) {
qerror_report(QERR_INVALID_BLOCK_FORMAT, format);
ret = -1;
goto out;
}
proto_drv = bdrv_find_protocol(filename);
if (!proto_drv) {
qerror_report(QERR_INVALID_BLOCK_FORMAT, format);
ret = -1;
goto out;
}
ret = bdrv_img_create(filename, format, bs->filename,
bs->drv->format_name, NULL, -1, flags);
if (ret) {
goto out;
}
qemu_aio_flush();
bdrv_flush(bs);
bdrv_close(bs);
ret = bdrv_open(bs, filename, flags, drv);
if (ret != 0) {
ret = bdrv_open(bs, old_filename, flags, old_drv);
if (ret != 0) {
qerror_report(QERR_OPEN_FILE_FAILED, old_filename);
} else {
qerror_report(QERR_OPEN_FILE_FAILED, filename);
}
}
out:
if (ret) {
ret = -1;
}
return ret;
}
|
{
"code": [],
"line_no": []
}
|
int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)
{
const char *VAR_3 = qdict_get_str(VAR_1, "VAR_3");
const char *VAR_4 = qdict_get_try_str(VAR_1, "snapshot-file");
const char *VAR_5 = qdict_get_try_str(VAR_1, "VAR_5");
BlockDriverState *bs;
BlockDriver *drv, *old_drv, *proto_drv;
int VAR_6 = 0;
int VAR_7;
char VAR_8[1024];
if (!VAR_4) {
qerror_report(QERR_MISSING_PARAMETER, "snapshot-file");
VAR_6 = -1;
goto out;
}
bs = bdrv_find(VAR_3);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, VAR_3);
VAR_6 = -1;
goto out;
}
pstrcpy(VAR_8, sizeof(VAR_8), bs->VAR_4);
old_drv = bs->drv;
VAR_7 = bs->open_flags;
if (!VAR_5) {
VAR_5 = "qcow2";
}
drv = bdrv_find_format(VAR_5);
if (!drv) {
qerror_report(QERR_INVALID_BLOCK_FORMAT, VAR_5);
VAR_6 = -1;
goto out;
}
proto_drv = bdrv_find_protocol(VAR_4);
if (!proto_drv) {
qerror_report(QERR_INVALID_BLOCK_FORMAT, VAR_5);
VAR_6 = -1;
goto out;
}
VAR_6 = bdrv_img_create(VAR_4, VAR_5, bs->VAR_4,
bs->drv->format_name, NULL, -1, VAR_7);
if (VAR_6) {
goto out;
}
qemu_aio_flush();
bdrv_flush(bs);
bdrv_close(bs);
VAR_6 = bdrv_open(bs, VAR_4, VAR_7, drv);
if (VAR_6 != 0) {
VAR_6 = bdrv_open(bs, VAR_8, VAR_7, old_drv);
if (VAR_6 != 0) {
qerror_report(QERR_OPEN_FILE_FAILED, VAR_8);
} else {
qerror_report(QERR_OPEN_FILE_FAILED, VAR_4);
}
}
out:
if (VAR_6) {
VAR_6 = -1;
}
return VAR_6;
}
|
[
"int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)\n{",
"const char *VAR_3 = qdict_get_str(VAR_1, \"VAR_3\");",
"const char *VAR_4 = qdict_get_try_str(VAR_1, \"snapshot-file\");",
"const char *VAR_5 = qdict_get_try_str(VAR_1, \"VAR_5\");",
"BlockDriverState *bs;",
"BlockDriver *drv, *old_drv, *proto_drv;",
"int VAR_6 = 0;",
"int VAR_7;",
"char VAR_8[1024];",
"if (!VAR_4) {",
"qerror_report(QERR_MISSING_PARAMETER, \"snapshot-file\");",
"VAR_6 = -1;",
"goto out;",
"}",
"bs = bdrv_find(VAR_3);",
"if (!bs) {",
"qerror_report(QERR_DEVICE_NOT_FOUND, VAR_3);",
"VAR_6 = -1;",
"goto out;",
"}",
"pstrcpy(VAR_8, sizeof(VAR_8), bs->VAR_4);",
"old_drv = bs->drv;",
"VAR_7 = bs->open_flags;",
"if (!VAR_5) {",
"VAR_5 = \"qcow2\";",
"}",
"drv = bdrv_find_format(VAR_5);",
"if (!drv) {",
"qerror_report(QERR_INVALID_BLOCK_FORMAT, VAR_5);",
"VAR_6 = -1;",
"goto out;",
"}",
"proto_drv = bdrv_find_protocol(VAR_4);",
"if (!proto_drv) {",
"qerror_report(QERR_INVALID_BLOCK_FORMAT, VAR_5);",
"VAR_6 = -1;",
"goto out;",
"}",
"VAR_6 = bdrv_img_create(VAR_4, VAR_5, bs->VAR_4,\nbs->drv->format_name, NULL, -1, VAR_7);",
"if (VAR_6) {",
"goto out;",
"}",
"qemu_aio_flush();",
"bdrv_flush(bs);",
"bdrv_close(bs);",
"VAR_6 = bdrv_open(bs, VAR_4, VAR_7, drv);",
"if (VAR_6 != 0) {",
"VAR_6 = bdrv_open(bs, VAR_8, VAR_7, old_drv);",
"if (VAR_6 != 0) {",
"qerror_report(QERR_OPEN_FILE_FAILED, VAR_8);",
"} else {",
"qerror_report(QERR_OPEN_FILE_FAILED, VAR_4);",
"}",
"}",
"out:\nif (VAR_6) {",
"VAR_6 = -1;",
"}",
"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
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95,
97
],
[
99
],
[
101
],
[
103
],
[
107
],
[
109
],
[
113
],
[
115
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143,
145
],
[
147
],
[
149
],
[
153
],
[
155
]
] |
8,009 |
static void breakpoint_invalidate(CPUState *env, target_ulong pc)
{
target_ulong phys_addr;
phys_addr = cpu_get_phys_page_debug(env, pc);
tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);
}
| false |
qemu
|
c2f07f81a2d52d9d5243ead61d93e875487acf70
|
static void breakpoint_invalidate(CPUState *env, target_ulong pc)
{
target_ulong phys_addr;
phys_addr = cpu_get_phys_page_debug(env, pc);
tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(CPUState *VAR_0, target_ulong VAR_1)
{
target_ulong phys_addr;
phys_addr = cpu_get_phys_page_debug(VAR_0, VAR_1);
tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);
}
|
[
"static void FUNC_0(CPUState *VAR_0, target_ulong VAR_1)\n{",
"target_ulong phys_addr;",
"phys_addr = cpu_get_phys_page_debug(VAR_0, VAR_1);",
"tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);",
"}"
] |
[
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
]
] |
8,011 |
static void omap_ppm_save(const char *filename, uint8_t *data,
int w, int h, int linesize, Error **errp)
{
FILE *f;
uint8_t *d, *d1;
unsigned int v;
int ret, y, x, bpp;
f = fopen(filename, "wb");
if (!f) {
error_setg(errp, "failed to open file '%s': %s", filename,
strerror(errno));
return;
}
ret = fprintf(f, "P6\n%d %d\n%d\n", w, h, 255);
if (ret < 0) {
goto write_err;
}
d1 = data;
bpp = linesize / w;
for (y = 0; y < h; y ++) {
d = d1;
for (x = 0; x < w; x ++) {
v = *(uint32_t *) d;
switch (bpp) {
case 2:
ret = fputc((v >> 8) & 0xf8, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v >> 3) & 0xfc, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v << 3) & 0xf8, f);
if (ret == EOF) {
goto write_err;
}
break;
case 3:
case 4:
default:
ret = fputc((v >> 16) & 0xff, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v >> 8) & 0xff, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v) & 0xff, f);
if (ret == EOF) {
goto write_err;
}
break;
}
d += bpp;
}
d1 += linesize;
}
out:
fclose(f);
return;
write_err:
error_setg(errp, "failed to write to file '%s': %s", filename,
strerror(errno));
unlink(filename);
goto out;
}
| false |
qemu
|
2c62f08ddbf3fa80dc7202eb9a2ea60ae44e2cc5
|
static void omap_ppm_save(const char *filename, uint8_t *data,
int w, int h, int linesize, Error **errp)
{
FILE *f;
uint8_t *d, *d1;
unsigned int v;
int ret, y, x, bpp;
f = fopen(filename, "wb");
if (!f) {
error_setg(errp, "failed to open file '%s': %s", filename,
strerror(errno));
return;
}
ret = fprintf(f, "P6\n%d %d\n%d\n", w, h, 255);
if (ret < 0) {
goto write_err;
}
d1 = data;
bpp = linesize / w;
for (y = 0; y < h; y ++) {
d = d1;
for (x = 0; x < w; x ++) {
v = *(uint32_t *) d;
switch (bpp) {
case 2:
ret = fputc((v >> 8) & 0xf8, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v >> 3) & 0xfc, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v << 3) & 0xf8, f);
if (ret == EOF) {
goto write_err;
}
break;
case 3:
case 4:
default:
ret = fputc((v >> 16) & 0xff, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v >> 8) & 0xff, f);
if (ret == EOF) {
goto write_err;
}
ret = fputc((v) & 0xff, f);
if (ret == EOF) {
goto write_err;
}
break;
}
d += bpp;
}
d1 += linesize;
}
out:
fclose(f);
return;
write_err:
error_setg(errp, "failed to write to file '%s': %s", filename,
strerror(errno));
unlink(filename);
goto out;
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(const char *VAR_0, uint8_t *VAR_1,
int VAR_2, int VAR_3, int VAR_4, Error **VAR_5)
{
FILE *f;
uint8_t *d, *d1;
unsigned int VAR_6;
int VAR_7, VAR_8, VAR_9, VAR_10;
f = fopen(VAR_0, "wb");
if (!f) {
error_setg(VAR_5, "failed to open file '%s': %s", VAR_0,
strerror(errno));
return;
}
VAR_7 = fprintf(f, "P6\n%d %d\n%d\n", VAR_2, VAR_3, 255);
if (VAR_7 < 0) {
goto write_err;
}
d1 = VAR_1;
VAR_10 = VAR_4 / VAR_2;
for (VAR_8 = 0; VAR_8 < VAR_3; VAR_8 ++) {
d = d1;
for (VAR_9 = 0; VAR_9 < VAR_2; VAR_9 ++) {
VAR_6 = *(uint32_t *) d;
switch (VAR_10) {
case 2:
VAR_7 = fputc((VAR_6 >> 8) & 0xf8, f);
if (VAR_7 == EOF) {
goto write_err;
}
VAR_7 = fputc((VAR_6 >> 3) & 0xfc, f);
if (VAR_7 == EOF) {
goto write_err;
}
VAR_7 = fputc((VAR_6 << 3) & 0xf8, f);
if (VAR_7 == EOF) {
goto write_err;
}
break;
case 3:
case 4:
default:
VAR_7 = fputc((VAR_6 >> 16) & 0xff, f);
if (VAR_7 == EOF) {
goto write_err;
}
VAR_7 = fputc((VAR_6 >> 8) & 0xff, f);
if (VAR_7 == EOF) {
goto write_err;
}
VAR_7 = fputc((VAR_6) & 0xff, f);
if (VAR_7 == EOF) {
goto write_err;
}
break;
}
d += VAR_10;
}
d1 += VAR_4;
}
out:
fclose(f);
return;
write_err:
error_setg(VAR_5, "failed to write to file '%s': %s", VAR_0,
strerror(errno));
unlink(VAR_0);
goto out;
}
|
[
"static void FUNC_0(const char *VAR_0, uint8_t *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, Error **VAR_5)\n{",
"FILE *f;",
"uint8_t *d, *d1;",
"unsigned int VAR_6;",
"int VAR_7, VAR_8, VAR_9, VAR_10;",
"f = fopen(VAR_0, \"wb\");",
"if (!f) {",
"error_setg(VAR_5, \"failed to open file '%s': %s\", VAR_0,\nstrerror(errno));",
"return;",
"}",
"VAR_7 = fprintf(f, \"P6\\n%d %d\\n%d\\n\", VAR_2, VAR_3, 255);",
"if (VAR_7 < 0) {",
"goto write_err;",
"}",
"d1 = VAR_1;",
"VAR_10 = VAR_4 / VAR_2;",
"for (VAR_8 = 0; VAR_8 < VAR_3; VAR_8 ++) {",
"d = d1;",
"for (VAR_9 = 0; VAR_9 < VAR_2; VAR_9 ++) {",
"VAR_6 = *(uint32_t *) d;",
"switch (VAR_10) {",
"case 2:\nVAR_7 = fputc((VAR_6 >> 8) & 0xf8, f);",
"if (VAR_7 == EOF) {",
"goto write_err;",
"}",
"VAR_7 = fputc((VAR_6 >> 3) & 0xfc, f);",
"if (VAR_7 == EOF) {",
"goto write_err;",
"}",
"VAR_7 = fputc((VAR_6 << 3) & 0xf8, f);",
"if (VAR_7 == EOF) {",
"goto write_err;",
"}",
"break;",
"case 3:\ncase 4:\ndefault:\nVAR_7 = fputc((VAR_6 >> 16) & 0xff, f);",
"if (VAR_7 == EOF) {",
"goto write_err;",
"}",
"VAR_7 = fputc((VAR_6 >> 8) & 0xff, f);",
"if (VAR_7 == EOF) {",
"goto write_err;",
"}",
"VAR_7 = fputc((VAR_6) & 0xff, f);",
"if (VAR_7 == EOF) {",
"goto write_err;",
"}",
"break;",
"}",
"d += VAR_10;",
"}",
"d1 += VAR_4;",
"}",
"out:\nfclose(f);",
"return;",
"write_err:\nerror_setg(VAR_5, \"failed to write to file '%s': %s\", VAR_0,\nstrerror(errno));",
"unlink(VAR_0);",
"goto out;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121,
123
],
[
125
],
[
129,
131,
133
],
[
135
],
[
137
],
[
139
]
] |
8,012 |
static uint64_t unassigned_mem_read(void *opaque, hwaddr addr,
unsigned size)
{
#ifdef DEBUG_UNASSIGNED
printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
#endif
if (current_cpu != NULL) {
cpu_unassigned_access(current_cpu, addr, false, false, 0, size);
}
return -1ULL;
}
| false |
qemu
|
68a7439a150d6b4da99082ab454b9328b151bc25
|
static uint64_t unassigned_mem_read(void *opaque, hwaddr addr,
unsigned size)
{
#ifdef DEBUG_UNASSIGNED
printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
#endif
if (current_cpu != NULL) {
cpu_unassigned_access(current_cpu, addr, false, false, 0, size);
}
return -1ULL;
}
|
{
"code": [],
"line_no": []
}
|
static uint64_t FUNC_0(void *opaque, hwaddr addr,
unsigned size)
{
#ifdef DEBUG_UNASSIGNED
printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
#endif
if (current_cpu != NULL) {
cpu_unassigned_access(current_cpu, addr, false, false, 0, size);
}
return -1ULL;
}
|
[
"static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{",
"#ifdef DEBUG_UNASSIGNED\nprintf(\"Unassigned mem read \" TARGET_FMT_plx \"\\n\", addr);",
"#endif\nif (current_cpu != NULL) {",
"cpu_unassigned_access(current_cpu, addr, false, false, 0, size);",
"}",
"return -1ULL;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7,
9
],
[
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
8,013 |
void qemu_set_cloexec(int fd)
{
int f;
f = fcntl(fd, F_GETFD);
fcntl(fd, F_SETFD, f | FD_CLOEXEC);
}
| false |
qemu
|
7e6478e7d4f2c4b607069bf488d57089a9d3244b
|
void qemu_set_cloexec(int fd)
{
int f;
f = fcntl(fd, F_GETFD);
fcntl(fd, F_SETFD, f | FD_CLOEXEC);
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(int VAR_0)
{
int VAR_1;
VAR_1 = fcntl(VAR_0, F_GETFD);
fcntl(VAR_0, F_SETFD, VAR_1 | FD_CLOEXEC);
}
|
[
"void FUNC_0(int VAR_0)\n{",
"int VAR_1;",
"VAR_1 = fcntl(VAR_0, F_GETFD);",
"fcntl(VAR_0, F_SETFD, VAR_1 | FD_CLOEXEC);",
"}"
] |
[
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
] |
8,014 |
static int netmap_can_send(void *opaque)
{
NetmapState *s = opaque;
return qemu_can_send_packet(&s->nc);
}
| false |
qemu
|
e8dd1d9c396104f0fac4b39a701143df49df2a74
|
static int netmap_can_send(void *opaque)
{
NetmapState *s = opaque;
return qemu_can_send_packet(&s->nc);
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(void *VAR_0)
{
NetmapState *s = VAR_0;
return qemu_can_send_packet(&s->nc);
}
|
[
"static int FUNC_0(void *VAR_0)\n{",
"NetmapState *s = VAR_0;",
"return qemu_can_send_packet(&s->nc);",
"}"
] |
[
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11
]
] |
8,015 |
static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section,
unsigned long *bitmap)
{
unsigned int i, j;
unsigned long page_number, c;
hwaddr addr, addr1;
unsigned int len = ((section->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE;
/*
* bitmap-traveling is faster than memory-traveling (for addr...)
* especially when most of the memory is not dirty.
*/
for (i = 0; i < len; i++) {
if (bitmap[i] != 0) {
c = leul_to_cpu(bitmap[i]);
do {
j = ffsl(c) - 1;
c &= ~(1ul << j);
page_number = (i * HOST_LONG_BITS + j) * hpratio;
addr1 = page_number * TARGET_PAGE_SIZE;
addr = section->offset_within_region + addr1;
memory_region_set_dirty(section->mr, addr,
TARGET_PAGE_SIZE * hpratio);
} while (c != 0);
}
}
return 0;
}
| false |
qemu
|
752ced0488806830f18f96b60ae6f3d1fadfd089
|
static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section,
unsigned long *bitmap)
{
unsigned int i, j;
unsigned long page_number, c;
hwaddr addr, addr1;
unsigned int len = ((section->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE;
for (i = 0; i < len; i++) {
if (bitmap[i] != 0) {
c = leul_to_cpu(bitmap[i]);
do {
j = ffsl(c) - 1;
c &= ~(1ul << j);
page_number = (i * HOST_LONG_BITS + j) * hpratio;
addr1 = page_number * TARGET_PAGE_SIZE;
addr = section->offset_within_region + addr1;
memory_region_set_dirty(section->mr, addr,
TARGET_PAGE_SIZE * hpratio);
} while (c != 0);
}
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(MemoryRegionSection *VAR_0,
unsigned long *VAR_1)
{
unsigned int VAR_2, VAR_3;
unsigned long VAR_4, VAR_5;
hwaddr addr, addr1;
unsigned int VAR_6 = ((VAR_0->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
unsigned long VAR_7 = getpagesize() / TARGET_PAGE_SIZE;
for (VAR_2 = 0; VAR_2 < VAR_6; VAR_2++) {
if (VAR_1[VAR_2] != 0) {
VAR_5 = leul_to_cpu(VAR_1[VAR_2]);
do {
VAR_3 = ffsl(VAR_5) - 1;
VAR_5 &= ~(1ul << VAR_3);
VAR_4 = (VAR_2 * HOST_LONG_BITS + VAR_3) * VAR_7;
addr1 = VAR_4 * TARGET_PAGE_SIZE;
addr = VAR_0->offset_within_region + addr1;
memory_region_set_dirty(VAR_0->mr, addr,
TARGET_PAGE_SIZE * VAR_7);
} while (VAR_5 != 0);
}
}
return 0;
}
|
[
"static int FUNC_0(MemoryRegionSection *VAR_0,\nunsigned long *VAR_1)\n{",
"unsigned int VAR_2, VAR_3;",
"unsigned long VAR_4, VAR_5;",
"hwaddr addr, addr1;",
"unsigned int VAR_6 = ((VAR_0->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS;",
"unsigned long VAR_7 = getpagesize() / TARGET_PAGE_SIZE;",
"for (VAR_2 = 0; VAR_2 < VAR_6; VAR_2++) {",
"if (VAR_1[VAR_2] != 0) {",
"VAR_5 = leul_to_cpu(VAR_1[VAR_2]);",
"do {",
"VAR_3 = ffsl(VAR_5) - 1;",
"VAR_5 &= ~(1ul << VAR_3);",
"VAR_4 = (VAR_2 * HOST_LONG_BITS + VAR_3) * VAR_7;",
"addr1 = VAR_4 * TARGET_PAGE_SIZE;",
"addr = VAR_0->offset_within_region + addr1;",
"memory_region_set_dirty(VAR_0->mr, addr,\nTARGET_PAGE_SIZE * VAR_7);",
"} while (VAR_5 != 0);",
"}",
"}",
"return 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
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
]
] |
8,016 |
static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
MpegEncContext * const s = &h->s;
static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
int level[16];
int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
//FIXME put trailing_onex into the context
if(n == CHROMA_DC_BLOCK_INDEX){
coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
total_coeff= coeff_token>>2;
}else{
if(n == LUMA_DC_BLOCK_INDEX){
total_coeff= pred_non_zero_count(h, 0);
coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
total_coeff= coeff_token>>2;
}else{
total_coeff= pred_non_zero_count(h, n);
coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
total_coeff= coeff_token>>2;
h->non_zero_count_cache[ scan8[n] ]= total_coeff;
}
}
//FIXME set last_non_zero?
if(total_coeff==0)
return 0;
if(total_coeff > (unsigned)max_coeff) {
av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
return -1;
}
trailing_ones= coeff_token&3;
tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
assert(total_coeff<=16);
i = show_bits(gb, 3);
skip_bits(gb, trailing_ones);
level[0] = 1-((i&4)>>1);
level[1] = 1-((i&2) );
level[2] = 1-((i&1)<<1);
if(trailing_ones<total_coeff) {
int mask, prefix;
int suffix_length = total_coeff > 10 & trailing_ones < 3;
int bitsi= show_bits(gb, LEVEL_TAB_BITS);
int level_code= cavlc_level_tab[suffix_length][bitsi][0];
skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
if(level_code >= 100){
prefix= level_code - 100;
if(prefix == LEVEL_TAB_BITS)
prefix += get_level_prefix(gb);
//first coefficient has suffix_length equal to 0 or 1
if(prefix<14){ //FIXME try to build a large unified VLC table for all this
if(suffix_length)
level_code= (prefix<<1) + get_bits1(gb); //part
else
level_code= prefix; //part
}else if(prefix==14){
if(suffix_length)
level_code= (prefix<<1) + get_bits1(gb); //part
else
level_code= prefix + get_bits(gb, 4); //part
}else{
level_code= 30 + get_bits(gb, prefix-3); //part
if(prefix>=16)
level_code += (1<<(prefix-3))-4096;
}
if(trailing_ones < 3) level_code += 2;
suffix_length = 2;
mask= -(level_code&1);
level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
}else{
level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
suffix_length = 1 + (level_code + 3U > 6U);
level[trailing_ones]= level_code;
}
//remaining coefficients have suffix_length > 0
for(i=trailing_ones+1;i<total_coeff;i++) {
static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
int bitsi= show_bits(gb, LEVEL_TAB_BITS);
level_code= cavlc_level_tab[suffix_length][bitsi][0];
skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
if(level_code >= 100){
prefix= level_code - 100;
if(prefix == LEVEL_TAB_BITS){
prefix += get_level_prefix(gb);
}
if(prefix<15){
level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
}else{
level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
if(prefix>=16)
level_code += (1<<(prefix-3))-4096;
}
mask= -(level_code&1);
level_code= (((2+level_code)>>1) ^ mask) - mask;
}
level[i]= level_code;
suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
}
}
if(total_coeff == max_coeff)
zeros_left=0;
else{
if(n == CHROMA_DC_BLOCK_INDEX)
zeros_left= get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[ total_coeff ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
else
zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
}
coeff_num = zeros_left + total_coeff - 1;
j = scantable[coeff_num];
if(n > 24){
block[j] = level[0];
for(i=1;i<total_coeff;i++) {
if(zeros_left <= 0)
run_before = 0;
else if(zeros_left < 7){
run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
}else{
run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
}
zeros_left -= run_before;
coeff_num -= 1 + run_before;
j= scantable[ coeff_num ];
block[j]= level[i];
}
}else{
block[j] = (level[0] * qmul[j] + 32)>>6;
for(i=1;i<total_coeff;i++) {
if(zeros_left <= 0)
run_before = 0;
else if(zeros_left < 7){
run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
}else{
run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
}
zeros_left -= run_before;
coeff_num -= 1 + run_before;
j= scantable[ coeff_num ];
block[j]= (level[i] * qmul[j] + 32)>>6;
}
}
if(zeros_left<0){
av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
return -1;
}
return 0;
}
| false |
FFmpeg
|
9885284c2259847b0d2b34b5574e3276607e37e4
|
static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
MpegEncContext * const s = &h->s;
static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
int level[16];
int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
if(n == CHROMA_DC_BLOCK_INDEX){
coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
total_coeff= coeff_token>>2;
}else{
if(n == LUMA_DC_BLOCK_INDEX){
total_coeff= pred_non_zero_count(h, 0);
coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
total_coeff= coeff_token>>2;
}else{
total_coeff= pred_non_zero_count(h, n);
coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
total_coeff= coeff_token>>2;
h->non_zero_count_cache[ scan8[n] ]= total_coeff;
}
}
if(total_coeff==0)
return 0;
if(total_coeff > (unsigned)max_coeff) {
av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
return -1;
}
trailing_ones= coeff_token&3;
tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
assert(total_coeff<=16);
i = show_bits(gb, 3);
skip_bits(gb, trailing_ones);
level[0] = 1-((i&4)>>1);
level[1] = 1-((i&2) );
level[2] = 1-((i&1)<<1);
if(trailing_ones<total_coeff) {
int mask, prefix;
int suffix_length = total_coeff > 10 & trailing_ones < 3;
int bitsi= show_bits(gb, LEVEL_TAB_BITS);
int level_code= cavlc_level_tab[suffix_length][bitsi][0];
skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
if(level_code >= 100){
prefix= level_code - 100;
if(prefix == LEVEL_TAB_BITS)
prefix += get_level_prefix(gb);
if(prefix<14){
if(suffix_length)
level_code= (prefix<<1) + get_bits1(gb);
else
level_code= prefix;
}else if(prefix==14){
if(suffix_length)
level_code= (prefix<<1) + get_bits1(gb);
else
level_code= prefix + get_bits(gb, 4);
}else{
level_code= 30 + get_bits(gb, prefix-3);
if(prefix>=16)
level_code += (1<<(prefix-3))-4096;
}
if(trailing_ones < 3) level_code += 2;
suffix_length = 2;
mask= -(level_code&1);
level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
}else{
level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
suffix_length = 1 + (level_code + 3U > 6U);
level[trailing_ones]= level_code;
}
for(i=trailing_ones+1;i<total_coeff;i++) {
static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
int bitsi= show_bits(gb, LEVEL_TAB_BITS);
level_code= cavlc_level_tab[suffix_length][bitsi][0];
skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
if(level_code >= 100){
prefix= level_code - 100;
if(prefix == LEVEL_TAB_BITS){
prefix += get_level_prefix(gb);
}
if(prefix<15){
level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
}else{
level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
if(prefix>=16)
level_code += (1<<(prefix-3))-4096;
}
mask= -(level_code&1);
level_code= (((2+level_code)>>1) ^ mask) - mask;
}
level[i]= level_code;
suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
}
}
if(total_coeff == max_coeff)
zeros_left=0;
else{
if(n == CHROMA_DC_BLOCK_INDEX)
zeros_left= get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[ total_coeff ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
else
zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
}
coeff_num = zeros_left + total_coeff - 1;
j = scantable[coeff_num];
if(n > 24){
block[j] = level[0];
for(i=1;i<total_coeff;i++) {
if(zeros_left <= 0)
run_before = 0;
else if(zeros_left < 7){
run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
}else{
run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
}
zeros_left -= run_before;
coeff_num -= 1 + run_before;
j= scantable[ coeff_num ];
block[j]= level[i];
}
}else{
block[j] = (level[0] * qmul[j] + 32)>>6;
for(i=1;i<total_coeff;i++) {
if(zeros_left <= 0)
run_before = 0;
else if(zeros_left < 7){
run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
}else{
run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
}
zeros_left -= run_before;
coeff_num -= 1 + run_before;
j= scantable[ coeff_num ];
block[j]= (level[i] * qmul[j] + 32)>>6;
}
}
if(zeros_left<0){
av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
return -1;
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(H264Context *VAR_0, GetBitContext *VAR_1, DCTELEM *VAR_2, int VAR_3, const uint8_t *VAR_4, const uint32_t *VAR_5, int VAR_6){
MpegEncContext * const s = &VAR_0->s;
static const int VAR_7[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
int VAR_8[16];
int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16;
if(VAR_3 == CHROMA_DC_BLOCK_INDEX){
VAR_11= get_vlc2(VAR_1, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
VAR_12= VAR_11>>2;
}else{
if(VAR_3 == LUMA_DC_BLOCK_INDEX){
VAR_12= pred_non_zero_count(VAR_0, 0);
VAR_11= get_vlc2(VAR_1, coeff_token_vlc[ VAR_7[VAR_12] ].table, COEFF_TOKEN_VLC_BITS, 2);
VAR_12= VAR_11>>2;
}else{
VAR_12= pred_non_zero_count(VAR_0, VAR_3);
VAR_11= get_vlc2(VAR_1, coeff_token_vlc[ VAR_7[VAR_12] ].table, COEFF_TOKEN_VLC_BITS, 2);
VAR_12= VAR_11>>2;
VAR_0->non_zero_count_cache[ scan8[VAR_3] ]= VAR_12;
}
}
if(VAR_12==0)
return 0;
if(VAR_12 > (unsigned)VAR_6) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (VAR_12=%d)\VAR_3", s->mb_x, s->mb_y, VAR_12);
return -1;
}
VAR_15= VAR_11&3;
tprintf(VAR_0->s.avctx, "trailing:%d, total:%d\VAR_3", VAR_15, VAR_12);
assert(VAR_12<=16);
VAR_13 = show_bits(VAR_1, 3);
skip_bits(VAR_1, VAR_15);
VAR_8[0] = 1-((VAR_13&4)>>1);
VAR_8[1] = 1-((VAR_13&2) );
VAR_8[2] = 1-((VAR_13&1)<<1);
if(VAR_15<VAR_12) {
int VAR_17, VAR_18;
int VAR_19 = VAR_12 > 10 & VAR_15 < 3;
int VAR_23= show_bits(VAR_1, LEVEL_TAB_BITS);
int VAR_21= cavlc_level_tab[VAR_19][VAR_23][0];
skip_bits(VAR_1, cavlc_level_tab[VAR_19][VAR_23][1]);
if(VAR_21 >= 100){
VAR_18= VAR_21 - 100;
if(VAR_18 == LEVEL_TAB_BITS)
VAR_18 += get_level_prefix(VAR_1);
if(VAR_18<14){
if(VAR_19)
VAR_21= (VAR_18<<1) + get_bits1(VAR_1);
else
VAR_21= VAR_18;
}else if(VAR_18==14){
if(VAR_19)
VAR_21= (VAR_18<<1) + get_bits1(VAR_1);
else
VAR_21= VAR_18 + get_bits(VAR_1, 4);
}else{
VAR_21= 30 + get_bits(VAR_1, VAR_18-3);
if(VAR_18>=16)
VAR_21 += (1<<(VAR_18-3))-4096;
}
if(VAR_15 < 3) VAR_21 += 2;
VAR_19 = 2;
VAR_17= -(VAR_21&1);
VAR_8[VAR_15]= (((2+VAR_21)>>1) ^ VAR_17) - VAR_17;
}else{
VAR_21 += ((VAR_21>>31)|1) & -(VAR_15 < 3);
VAR_19 = 1 + (VAR_21 + 3U > 6U);
VAR_8[VAR_15]= VAR_21;
}
for(VAR_13=VAR_15+1;VAR_13<VAR_12;VAR_13++) {
static const unsigned int VAR_22[7] = {0,3,6,12,24,48,INT_MAX };
int VAR_23= show_bits(VAR_1, LEVEL_TAB_BITS);
VAR_21= cavlc_level_tab[VAR_19][VAR_23][0];
skip_bits(VAR_1, cavlc_level_tab[VAR_19][VAR_23][1]);
if(VAR_21 >= 100){
VAR_18= VAR_21 - 100;
if(VAR_18 == LEVEL_TAB_BITS){
VAR_18 += get_level_prefix(VAR_1);
}
if(VAR_18<15){
VAR_21 = (VAR_18<<VAR_19) + get_bits(VAR_1, VAR_19);
}else{
VAR_21 = (15<<VAR_19) + get_bits(VAR_1, VAR_18-3);
if(VAR_18>=16)
VAR_21 += (1<<(VAR_18-3))-4096;
}
VAR_17= -(VAR_21&1);
VAR_21= (((2+VAR_21)>>1) ^ VAR_17) - VAR_17;
}
VAR_8[VAR_13]= VAR_21;
VAR_19+= VAR_22[VAR_19] + VAR_21 > 2U*VAR_22[VAR_19];
}
}
if(VAR_12 == VAR_6)
VAR_9=0;
else{
if(VAR_3 == CHROMA_DC_BLOCK_INDEX)
VAR_9= get_vlc2(VAR_1, (chroma_dc_total_zeros_vlc-1)[ VAR_12 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
else
VAR_9= get_vlc2(VAR_1, (total_zeros_vlc-1)[ VAR_12 ].table, TOTAL_ZEROS_VLC_BITS, 1);
}
VAR_10 = VAR_9 + VAR_12 - 1;
VAR_14 = VAR_4[VAR_10];
if(VAR_3 > 24){
VAR_2[VAR_14] = VAR_8[0];
for(VAR_13=1;VAR_13<VAR_12;VAR_13++) {
if(VAR_9 <= 0)
VAR_16 = 0;
else if(VAR_9 < 7){
VAR_16= get_vlc2(VAR_1, (run_vlc-1)[VAR_9].table, RUN_VLC_BITS, 1);
}else{
VAR_16= get_vlc2(VAR_1, run7_vlc.table, RUN7_VLC_BITS, 2);
}
VAR_9 -= VAR_16;
VAR_10 -= 1 + VAR_16;
VAR_14= VAR_4[ VAR_10 ];
VAR_2[VAR_14]= VAR_8[VAR_13];
}
}else{
VAR_2[VAR_14] = (VAR_8[0] * VAR_5[VAR_14] + 32)>>6;
for(VAR_13=1;VAR_13<VAR_12;VAR_13++) {
if(VAR_9 <= 0)
VAR_16 = 0;
else if(VAR_9 < 7){
VAR_16= get_vlc2(VAR_1, (run_vlc-1)[VAR_9].table, RUN_VLC_BITS, 1);
}else{
VAR_16= get_vlc2(VAR_1, run7_vlc.table, RUN7_VLC_BITS, 2);
}
VAR_9 -= VAR_16;
VAR_10 -= 1 + VAR_16;
VAR_14= VAR_4[ VAR_10 ];
VAR_2[VAR_14]= (VAR_8[VAR_13] * VAR_5[VAR_14] + 32)>>6;
}
}
if(VAR_9<0){
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\VAR_3", s->mb_x, s->mb_y);
return -1;
}
return 0;
}
|
[
"static int FUNC_0(H264Context *VAR_0, GetBitContext *VAR_1, DCTELEM *VAR_2, int VAR_3, const uint8_t *VAR_4, const uint32_t *VAR_5, int VAR_6){",
"MpegEncContext * const s = &VAR_0->s;",
"static const int VAR_7[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};",
"int VAR_8[16];",
"int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16;",
"if(VAR_3 == CHROMA_DC_BLOCK_INDEX){",
"VAR_11= get_vlc2(VAR_1, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);",
"VAR_12= VAR_11>>2;",
"}else{",
"if(VAR_3 == LUMA_DC_BLOCK_INDEX){",
"VAR_12= pred_non_zero_count(VAR_0, 0);",
"VAR_11= get_vlc2(VAR_1, coeff_token_vlc[ VAR_7[VAR_12] ].table, COEFF_TOKEN_VLC_BITS, 2);",
"VAR_12= VAR_11>>2;",
"}else{",
"VAR_12= pred_non_zero_count(VAR_0, VAR_3);",
"VAR_11= get_vlc2(VAR_1, coeff_token_vlc[ VAR_7[VAR_12] ].table, COEFF_TOKEN_VLC_BITS, 2);",
"VAR_12= VAR_11>>2;",
"VAR_0->non_zero_count_cache[ scan8[VAR_3] ]= VAR_12;",
"}",
"}",
"if(VAR_12==0)\nreturn 0;",
"if(VAR_12 > (unsigned)VAR_6) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"corrupted macroblock %d %d (VAR_12=%d)\\VAR_3\", s->mb_x, s->mb_y, VAR_12);",
"return -1;",
"}",
"VAR_15= VAR_11&3;",
"tprintf(VAR_0->s.avctx, \"trailing:%d, total:%d\\VAR_3\", VAR_15, VAR_12);",
"assert(VAR_12<=16);",
"VAR_13 = show_bits(VAR_1, 3);",
"skip_bits(VAR_1, VAR_15);",
"VAR_8[0] = 1-((VAR_13&4)>>1);",
"VAR_8[1] = 1-((VAR_13&2) );",
"VAR_8[2] = 1-((VAR_13&1)<<1);",
"if(VAR_15<VAR_12) {",
"int VAR_17, VAR_18;",
"int VAR_19 = VAR_12 > 10 & VAR_15 < 3;",
"int VAR_23= show_bits(VAR_1, LEVEL_TAB_BITS);",
"int VAR_21= cavlc_level_tab[VAR_19][VAR_23][0];",
"skip_bits(VAR_1, cavlc_level_tab[VAR_19][VAR_23][1]);",
"if(VAR_21 >= 100){",
"VAR_18= VAR_21 - 100;",
"if(VAR_18 == LEVEL_TAB_BITS)\nVAR_18 += get_level_prefix(VAR_1);",
"if(VAR_18<14){",
"if(VAR_19)\nVAR_21= (VAR_18<<1) + get_bits1(VAR_1);",
"else\nVAR_21= VAR_18;",
"}else if(VAR_18==14){",
"if(VAR_19)\nVAR_21= (VAR_18<<1) + get_bits1(VAR_1);",
"else\nVAR_21= VAR_18 + get_bits(VAR_1, 4);",
"}else{",
"VAR_21= 30 + get_bits(VAR_1, VAR_18-3);",
"if(VAR_18>=16)\nVAR_21 += (1<<(VAR_18-3))-4096;",
"}",
"if(VAR_15 < 3) VAR_21 += 2;",
"VAR_19 = 2;",
"VAR_17= -(VAR_21&1);",
"VAR_8[VAR_15]= (((2+VAR_21)>>1) ^ VAR_17) - VAR_17;",
"}else{",
"VAR_21 += ((VAR_21>>31)|1) & -(VAR_15 < 3);",
"VAR_19 = 1 + (VAR_21 + 3U > 6U);",
"VAR_8[VAR_15]= VAR_21;",
"}",
"for(VAR_13=VAR_15+1;VAR_13<VAR_12;VAR_13++) {",
"static const unsigned int VAR_22[7] = {0,3,6,12,24,48,INT_MAX };",
"int VAR_23= show_bits(VAR_1, LEVEL_TAB_BITS);",
"VAR_21= cavlc_level_tab[VAR_19][VAR_23][0];",
"skip_bits(VAR_1, cavlc_level_tab[VAR_19][VAR_23][1]);",
"if(VAR_21 >= 100){",
"VAR_18= VAR_21 - 100;",
"if(VAR_18 == LEVEL_TAB_BITS){",
"VAR_18 += get_level_prefix(VAR_1);",
"}",
"if(VAR_18<15){",
"VAR_21 = (VAR_18<<VAR_19) + get_bits(VAR_1, VAR_19);",
"}else{",
"VAR_21 = (15<<VAR_19) + get_bits(VAR_1, VAR_18-3);",
"if(VAR_18>=16)\nVAR_21 += (1<<(VAR_18-3))-4096;",
"}",
"VAR_17= -(VAR_21&1);",
"VAR_21= (((2+VAR_21)>>1) ^ VAR_17) - VAR_17;",
"}",
"VAR_8[VAR_13]= VAR_21;",
"VAR_19+= VAR_22[VAR_19] + VAR_21 > 2U*VAR_22[VAR_19];",
"}",
"}",
"if(VAR_12 == VAR_6)\nVAR_9=0;",
"else{",
"if(VAR_3 == CHROMA_DC_BLOCK_INDEX)\nVAR_9= get_vlc2(VAR_1, (chroma_dc_total_zeros_vlc-1)[ VAR_12 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);",
"else\nVAR_9= get_vlc2(VAR_1, (total_zeros_vlc-1)[ VAR_12 ].table, TOTAL_ZEROS_VLC_BITS, 1);",
"}",
"VAR_10 = VAR_9 + VAR_12 - 1;",
"VAR_14 = VAR_4[VAR_10];",
"if(VAR_3 > 24){",
"VAR_2[VAR_14] = VAR_8[0];",
"for(VAR_13=1;VAR_13<VAR_12;VAR_13++) {",
"if(VAR_9 <= 0)\nVAR_16 = 0;",
"else if(VAR_9 < 7){",
"VAR_16= get_vlc2(VAR_1, (run_vlc-1)[VAR_9].table, RUN_VLC_BITS, 1);",
"}else{",
"VAR_16= get_vlc2(VAR_1, run7_vlc.table, RUN7_VLC_BITS, 2);",
"}",
"VAR_9 -= VAR_16;",
"VAR_10 -= 1 + VAR_16;",
"VAR_14= VAR_4[ VAR_10 ];",
"VAR_2[VAR_14]= VAR_8[VAR_13];",
"}",
"}else{",
"VAR_2[VAR_14] = (VAR_8[0] * VAR_5[VAR_14] + 32)>>6;",
"for(VAR_13=1;VAR_13<VAR_12;VAR_13++) {",
"if(VAR_9 <= 0)\nVAR_16 = 0;",
"else if(VAR_9 < 7){",
"VAR_16= get_vlc2(VAR_1, (run_vlc-1)[VAR_9].table, RUN_VLC_BITS, 1);",
"}else{",
"VAR_16= get_vlc2(VAR_1, run7_vlc.table, RUN7_VLC_BITS, 2);",
"}",
"VAR_9 -= VAR_16;",
"VAR_10 -= 1 + VAR_16;",
"VAR_14= VAR_4[ VAR_10 ];",
"VAR_2[VAR_14]= (VAR_8[VAR_13] * VAR_5[VAR_14] + 32)>>6;",
"}",
"}",
"if(VAR_9<0){",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"negative number of zero coeffs at %d %d\\VAR_3\", s->mb_x, s->mb_y);",
"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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
113
],
[
115,
117
],
[
119,
121
],
[
123
],
[
125,
127
],
[
129,
131
],
[
133
],
[
135
],
[
137,
139
],
[
141
],
[
145
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
163
],
[
165
],
[
171
],
[
173
],
[
175
],
[
177
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201,
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
223,
225
],
[
227
],
[
229,
231
],
[
233,
235
],
[
237
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251,
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283,
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
305
],
[
307
],
[
309
],
[
313
],
[
315
],
[
317
],
[
319
],
[
323
],
[
325
]
] |
8,017 |
static void ccw_machine_class_init(ObjectClass *oc, void *data)
{
MachineClass *mc = MACHINE_CLASS(oc);
NMIClass *nc = NMI_CLASS(oc);
mc->name = "s390-ccw-virtio";
mc->alias = "s390-ccw";
mc->desc = "VirtIO-ccw based S390 machine";
mc->init = ccw_init;
mc->block_default_type = IF_VIRTIO;
mc->no_cdrom = 1;
mc->no_floppy = 1;
mc->no_serial = 1;
mc->no_parallel = 1;
mc->no_sdcard = 1;
mc->use_sclp = 1;
mc->max_cpus = 255;
mc->is_default = 1;
nc->nmi_monitor_handler = s390_nmi;
}
| false |
qemu
|
c4d3c0a2696c09a884b680d15b03325e46656a6c
|
static void ccw_machine_class_init(ObjectClass *oc, void *data)
{
MachineClass *mc = MACHINE_CLASS(oc);
NMIClass *nc = NMI_CLASS(oc);
mc->name = "s390-ccw-virtio";
mc->alias = "s390-ccw";
mc->desc = "VirtIO-ccw based S390 machine";
mc->init = ccw_init;
mc->block_default_type = IF_VIRTIO;
mc->no_cdrom = 1;
mc->no_floppy = 1;
mc->no_serial = 1;
mc->no_parallel = 1;
mc->no_sdcard = 1;
mc->use_sclp = 1;
mc->max_cpus = 255;
mc->is_default = 1;
nc->nmi_monitor_handler = s390_nmi;
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
MachineClass *mc = MACHINE_CLASS(VAR_0);
NMIClass *nc = NMI_CLASS(VAR_0);
mc->name = "s390-ccw-virtio";
mc->alias = "s390-ccw";
mc->desc = "VirtIO-ccw based S390 machine";
mc->init = ccw_init;
mc->block_default_type = IF_VIRTIO;
mc->no_cdrom = 1;
mc->no_floppy = 1;
mc->no_serial = 1;
mc->no_parallel = 1;
mc->no_sdcard = 1;
mc->use_sclp = 1;
mc->max_cpus = 255;
mc->is_default = 1;
nc->nmi_monitor_handler = s390_nmi;
}
|
[
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"MachineClass *mc = MACHINE_CLASS(VAR_0);",
"NMIClass *nc = NMI_CLASS(VAR_0);",
"mc->name = \"s390-ccw-virtio\";",
"mc->alias = \"s390-ccw\";",
"mc->desc = \"VirtIO-ccw based S390 machine\";",
"mc->init = ccw_init;",
"mc->block_default_type = IF_VIRTIO;",
"mc->no_cdrom = 1;",
"mc->no_floppy = 1;",
"mc->no_serial = 1;",
"mc->no_parallel = 1;",
"mc->no_sdcard = 1;",
"mc->use_sclp = 1;",
"mc->max_cpus = 255;",
"mc->is_default = 1;",
"nc->nmi_monitor_handler = s390_nmi;",
"}"
] |
[
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
]
] |
8,019 |
static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len)
{
uint32_t *p = qdev_get_prop_ptr(dev, prop);
return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off");
}
| false |
qemu
|
949fc82314cc84162e64a5323764527a542421ce
|
static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len)
{
uint32_t *p = qdev_get_prop_ptr(dev, prop);
return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off");
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(DeviceState *VAR_0, Property *VAR_1, char *VAR_2, size_t VAR_3)
{
uint32_t *p = qdev_get_prop_ptr(VAR_0, VAR_1);
return snprintf(VAR_2, VAR_3, (*p & qdev_get_prop_mask(VAR_1)) ? "on" : "off");
}
|
[
"static int FUNC_0(DeviceState *VAR_0, Property *VAR_1, char *VAR_2, size_t VAR_3)\n{",
"uint32_t *p = qdev_get_prop_ptr(VAR_0, VAR_1);",
"return snprintf(VAR_2, VAR_3, (*p & qdev_get_prop_mask(VAR_1)) ? \"on\" : \"off\");",
"}"
] |
[
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
8,020 |
static char *pxb_host_ofw_unit_address(const SysBusDevice *dev)
{
const PCIHostState *pxb_host;
const PCIBus *pxb_bus;
const PXBDev *pxb_dev;
int position;
const DeviceState *pxb_dev_base;
const PCIHostState *main_host;
const SysBusDevice *main_host_sbd;
pxb_host = PCI_HOST_BRIDGE(dev);
pxb_bus = pxb_host->bus;
pxb_dev = PXB_DEV(pxb_bus->parent_dev);
position = g_list_index(pxb_dev_list, pxb_dev);
assert(position >= 0);
pxb_dev_base = DEVICE(pxb_dev);
main_host = PCI_HOST_BRIDGE(pxb_dev_base->parent_bus->parent);
main_host_sbd = SYS_BUS_DEVICE(main_host);
if (main_host_sbd->num_mmio > 0) {
return g_strdup_printf(TARGET_FMT_plx ",%x",
main_host_sbd->mmio[0].addr, position + 1);
}
if (main_host_sbd->num_pio > 0) {
return g_strdup_printf("i%04x,%x",
main_host_sbd->pio[0], position + 1);
}
return NULL;
}
| false |
qemu
|
02b07434bed8360715198b4cbfdfebd17f7cac32
|
static char *pxb_host_ofw_unit_address(const SysBusDevice *dev)
{
const PCIHostState *pxb_host;
const PCIBus *pxb_bus;
const PXBDev *pxb_dev;
int position;
const DeviceState *pxb_dev_base;
const PCIHostState *main_host;
const SysBusDevice *main_host_sbd;
pxb_host = PCI_HOST_BRIDGE(dev);
pxb_bus = pxb_host->bus;
pxb_dev = PXB_DEV(pxb_bus->parent_dev);
position = g_list_index(pxb_dev_list, pxb_dev);
assert(position >= 0);
pxb_dev_base = DEVICE(pxb_dev);
main_host = PCI_HOST_BRIDGE(pxb_dev_base->parent_bus->parent);
main_host_sbd = SYS_BUS_DEVICE(main_host);
if (main_host_sbd->num_mmio > 0) {
return g_strdup_printf(TARGET_FMT_plx ",%x",
main_host_sbd->mmio[0].addr, position + 1);
}
if (main_host_sbd->num_pio > 0) {
return g_strdup_printf("i%04x,%x",
main_host_sbd->pio[0], position + 1);
}
return NULL;
}
|
{
"code": [],
"line_no": []
}
|
static char *FUNC_0(const SysBusDevice *VAR_0)
{
const PCIHostState *VAR_1;
const PCIBus *VAR_2;
const PXBDev *VAR_3;
int VAR_4;
const DeviceState *VAR_5;
const PCIHostState *VAR_6;
const SysBusDevice *VAR_7;
VAR_1 = PCI_HOST_BRIDGE(VAR_0);
VAR_2 = VAR_1->bus;
VAR_3 = PXB_DEV(VAR_2->parent_dev);
VAR_4 = g_list_index(pxb_dev_list, VAR_3);
assert(VAR_4 >= 0);
VAR_5 = DEVICE(VAR_3);
VAR_6 = PCI_HOST_BRIDGE(VAR_5->parent_bus->parent);
VAR_7 = SYS_BUS_DEVICE(VAR_6);
if (VAR_7->num_mmio > 0) {
return g_strdup_printf(TARGET_FMT_plx ",%x",
VAR_7->mmio[0].addr, VAR_4 + 1);
}
if (VAR_7->num_pio > 0) {
return g_strdup_printf("i%04x,%x",
VAR_7->pio[0], VAR_4 + 1);
}
return NULL;
}
|
[
"static char *FUNC_0(const SysBusDevice *VAR_0)\n{",
"const PCIHostState *VAR_1;",
"const PCIBus *VAR_2;",
"const PXBDev *VAR_3;",
"int VAR_4;",
"const DeviceState *VAR_5;",
"const PCIHostState *VAR_6;",
"const SysBusDevice *VAR_7;",
"VAR_1 = PCI_HOST_BRIDGE(VAR_0);",
"VAR_2 = VAR_1->bus;",
"VAR_3 = PXB_DEV(VAR_2->parent_dev);",
"VAR_4 = g_list_index(pxb_dev_list, VAR_3);",
"assert(VAR_4 >= 0);",
"VAR_5 = DEVICE(VAR_3);",
"VAR_6 = PCI_HOST_BRIDGE(VAR_5->parent_bus->parent);",
"VAR_7 = SYS_BUS_DEVICE(VAR_6);",
"if (VAR_7->num_mmio > 0) {",
"return g_strdup_printf(TARGET_FMT_plx \",%x\",\nVAR_7->mmio[0].addr, VAR_4 + 1);",
"}",
"if (VAR_7->num_pio > 0) {",
"return g_strdup_printf(\"i%04x,%x\",\nVAR_7->pio[0], VAR_4 + 1);",
"}",
"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
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
51,
53
],
[
55
],
[
57
],
[
59
]
] |
8,022 |
static int openfile(char *name, int flags, QDict *opts)
{
Error *local_err = NULL;
if (qemuio_blk) {
fprintf(stderr, "file open already, try 'help close'\n");
QDECREF(opts);
return 1;
}
qemuio_blk = blk_new_open("hda", name, NULL, opts, flags, &local_err);
if (!qemuio_blk) {
fprintf(stderr, "%s: can't open%s%s: %s\n", progname,
name ? " device " : "", name ?: "",
error_get_pretty(local_err));
error_free(local_err);
return 1;
}
bs = blk_bs(qemuio_blk);
if (bdrv_is_encrypted(bs)) {
char password[256];
printf("Disk image '%s' is encrypted.\n", name);
if (qemu_read_password(password, sizeof(password)) < 0) {
error_report("No password given");
goto error;
}
if (bdrv_set_key(bs, password) < 0) {
error_report("invalid password");
goto error;
}
}
return 0;
error:
blk_unref(qemuio_blk);
qemuio_blk = NULL;
return 1;
}
| true |
qemu
|
8caf02127e92939fff39b63a7ff1a5834d320191
|
static int openfile(char *name, int flags, QDict *opts)
{
Error *local_err = NULL;
if (qemuio_blk) {
fprintf(stderr, "file open already, try 'help close'\n");
QDECREF(opts);
return 1;
}
qemuio_blk = blk_new_open("hda", name, NULL, opts, flags, &local_err);
if (!qemuio_blk) {
fprintf(stderr, "%s: can't open%s%s: %s\n", progname,
name ? " device " : "", name ?: "",
error_get_pretty(local_err));
error_free(local_err);
return 1;
}
bs = blk_bs(qemuio_blk);
if (bdrv_is_encrypted(bs)) {
char password[256];
printf("Disk image '%s' is encrypted.\n", name);
if (qemu_read_password(password, sizeof(password)) < 0) {
error_report("No password given");
goto error;
}
if (bdrv_set_key(bs, password) < 0) {
error_report("invalid password");
goto error;
}
}
return 0;
error:
blk_unref(qemuio_blk);
qemuio_blk = NULL;
return 1;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(char *VAR_0, int VAR_1, QDict *VAR_2)
{
Error *local_err = NULL;
if (qemuio_blk) {
fprintf(stderr, "file open already, try 'help close'\n");
QDECREF(VAR_2);
return 1;
}
qemuio_blk = blk_new_open("hda", VAR_0, NULL, VAR_2, VAR_1, &local_err);
if (!qemuio_blk) {
fprintf(stderr, "%s: can't open%s%s: %s\n", progname,
VAR_0 ? " device " : "", VAR_0 ?: "",
error_get_pretty(local_err));
error_free(local_err);
return 1;
}
bs = blk_bs(qemuio_blk);
if (bdrv_is_encrypted(bs)) {
char VAR_3[256];
printf("Disk image '%s' is encrypted.\n", VAR_0);
if (qemu_read_password(VAR_3, sizeof(VAR_3)) < 0) {
error_report("No VAR_3 given");
goto error;
}
if (bdrv_set_key(bs, VAR_3) < 0) {
error_report("invalid VAR_3");
goto error;
}
}
return 0;
error:
blk_unref(qemuio_blk);
qemuio_blk = NULL;
return 1;
}
|
[
"static int FUNC_0(char *VAR_0, int VAR_1, QDict *VAR_2)\n{",
"Error *local_err = NULL;",
"if (qemuio_blk) {",
"fprintf(stderr, \"file open already, try 'help close'\\n\");",
"QDECREF(VAR_2);",
"return 1;",
"}",
"qemuio_blk = blk_new_open(\"hda\", VAR_0, NULL, VAR_2, VAR_1, &local_err);",
"if (!qemuio_blk) {",
"fprintf(stderr, \"%s: can't open%s%s: %s\\n\", progname,\nVAR_0 ? \" device \" : \"\", VAR_0 ?: \"\",\nerror_get_pretty(local_err));",
"error_free(local_err);",
"return 1;",
"}",
"bs = blk_bs(qemuio_blk);",
"if (bdrv_is_encrypted(bs)) {",
"char VAR_3[256];",
"printf(\"Disk image '%s' is encrypted.\\n\", VAR_0);",
"if (qemu_read_password(VAR_3, sizeof(VAR_3)) < 0) {",
"error_report(\"No VAR_3 given\");",
"goto error;",
"}",
"if (bdrv_set_key(bs, VAR_3) < 0) {",
"error_report(\"invalid VAR_3\");",
"goto error;",
"}",
"}",
"return 0;",
"error:\nblk_unref(qemuio_blk);",
"qemuio_blk = NULL;",
"return 1;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
10
],
[
12
],
[
14
],
[
16
],
[
18
],
[
22
],
[
24
],
[
26,
28,
30
],
[
32
],
[
34
],
[
36
],
[
40
],
[
42
],
[
44
],
[
46
],
[
48
],
[
50
],
[
52
],
[
54
],
[
56
],
[
58
],
[
60
],
[
62
],
[
64
],
[
70
],
[
74,
76
],
[
78
],
[
80
],
[
82
]
] |
8,023 |
static void calc_slice_sizes(VC2EncContext *s)
{
int slice_x, slice_y;
SliceArgs *enc_args = s->slice_args;
for (slice_y = 0; slice_y < s->num_y; slice_y++) {
for (slice_x = 0; slice_x < s->num_x; slice_x++) {
SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
args->ctx = s;
args->x = slice_x;
args->y = slice_y;
args->bits_ceil = s->slice_max_bytes << 3;
args->bits_floor = s->slice_min_bytes << 3;
memset(args->cache, 0, MAX_QUANT_INDEX*sizeof(*args->cache));
}
}
/* Determine quantization indices and bytes per slice */
s->avctx->execute(s->avctx, rate_control, enc_args, NULL, s->num_x*s->num_y,
sizeof(SliceArgs));
}
| true |
FFmpeg
|
b88be742fac7a77a8095e8155ba8790db4b77568
|
static void calc_slice_sizes(VC2EncContext *s)
{
int slice_x, slice_y;
SliceArgs *enc_args = s->slice_args;
for (slice_y = 0; slice_y < s->num_y; slice_y++) {
for (slice_x = 0; slice_x < s->num_x; slice_x++) {
SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
args->ctx = s;
args->x = slice_x;
args->y = slice_y;
args->bits_ceil = s->slice_max_bytes << 3;
args->bits_floor = s->slice_min_bytes << 3;
memset(args->cache, 0, MAX_QUANT_INDEX*sizeof(*args->cache));
}
}
s->avctx->execute(s->avctx, rate_control, enc_args, NULL, s->num_x*s->num_y,
sizeof(SliceArgs));
}
|
{
"code": [
"static void calc_slice_sizes(VC2EncContext *s)",
" int slice_x, slice_y;",
" args->x = slice_x;",
" args->y = slice_y;",
" args->bits_ceil = s->slice_max_bytes << 3;",
" memset(args->cache, 0, MAX_QUANT_INDEX*sizeof(*args->cache));",
" for (slice_y = 0; slice_y < s->num_y; slice_y++) {",
" for (slice_x = 0; slice_x < s->num_x; slice_x++) {",
" SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];",
" for (slice_y = 0; slice_y < s->num_y; slice_y++) {",
" for (slice_x = 0; slice_x < s->num_x; slice_x++) {"
],
"line_no": [
1,
5,
19,
21,
23,
27,
11,
13,
15,
11,
13
]
}
|
static void FUNC_0(VC2EncContext *VAR_0)
{
int VAR_1, VAR_2;
SliceArgs *enc_args = VAR_0->slice_args;
for (VAR_2 = 0; VAR_2 < VAR_0->num_y; VAR_2++) {
for (VAR_1 = 0; VAR_1 < VAR_0->num_x; VAR_1++) {
SliceArgs *args = &enc_args[VAR_0->num_x*VAR_2 + VAR_1];
args->ctx = VAR_0;
args->x = VAR_1;
args->y = VAR_2;
args->bits_ceil = VAR_0->slice_max_bytes << 3;
args->bits_floor = VAR_0->slice_min_bytes << 3;
memset(args->cache, 0, MAX_QUANT_INDEX*sizeof(*args->cache));
}
}
VAR_0->avctx->execute(VAR_0->avctx, rate_control, enc_args, NULL, VAR_0->num_x*VAR_0->num_y,
sizeof(SliceArgs));
}
|
[
"static void FUNC_0(VC2EncContext *VAR_0)\n{",
"int VAR_1, VAR_2;",
"SliceArgs *enc_args = VAR_0->slice_args;",
"for (VAR_2 = 0; VAR_2 < VAR_0->num_y; VAR_2++) {",
"for (VAR_1 = 0; VAR_1 < VAR_0->num_x; VAR_1++) {",
"SliceArgs *args = &enc_args[VAR_0->num_x*VAR_2 + VAR_1];",
"args->ctx = VAR_0;",
"args->x = VAR_1;",
"args->y = VAR_2;",
"args->bits_ceil = VAR_0->slice_max_bytes << 3;",
"args->bits_floor = VAR_0->slice_min_bytes << 3;",
"memset(args->cache, 0, MAX_QUANT_INDEX*sizeof(*args->cache));",
"}",
"}",
"VAR_0->avctx->execute(VAR_0->avctx, rate_control, enc_args, NULL, VAR_0->num_x*VAR_0->num_y,\nsizeof(SliceArgs));",
"}"
] |
[
1,
1,
0,
1,
1,
1,
0,
1,
1,
1,
0,
1,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
37,
39
],
[
41
]
] |
8,025 |
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const AVPacket *avpkt)
{
AVCodecInternal *avci = avctx->internal;
int ret;
// copy to ensure we do not change avpkt
AVPacket tmp = *avpkt;
if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
}
*got_picture_ptr = 0;
if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
avcodec_get_frame_defaults(picture);
if (!avctx->refcounted_frames)
av_frame_unref(&avci->to_free);
if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
int did_split = av_packet_split_side_data(&tmp);
apply_param_change(avctx, &tmp);
avctx->pkt = &tmp;
if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
&tmp);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
&tmp);
picture->pkt_dts = avpkt->dts;
if(!avctx->has_b_frames){
av_frame_set_pkt_pos(picture, avpkt->pos);
}
//FIXME these should be under if(!avctx->has_b_frames)
/* get_buffer is supposed to set frame parameters */
if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {
if (!picture->sample_aspect_ratio.num) picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
if (!picture->width) picture->width = avctx->width;
if (!picture->height) picture->height = avctx->height;
if (picture->format == AV_PIX_FMT_NONE) picture->format = avctx->pix_fmt;
}
}
add_metadata_from_side_data(avctx, picture);
emms_c(); //needed to avoid an emms_c() call before every return;
avctx->pkt = NULL;
if (did_split) {
ff_packet_free_side_data(&tmp);
if(ret == tmp.size)
ret = avpkt->size;
}
if (ret < 0 && picture->data[0])
av_frame_unref(picture);
if (*got_picture_ptr) {
if (!avctx->refcounted_frames) {
avci->to_free = *picture;
avci->to_free.extended_data = avci->to_free.data;
memset(picture->buf, 0, sizeof(picture->buf));
}
avctx->frame_number++;
av_frame_set_best_effort_timestamp(picture,
guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts));
}
} else
ret = 0;
/* many decoders assign whole AVFrames, thus overwriting extended_data;
* make sure it's set correctly */
picture->extended_data = picture->data;
return ret;
}
| true |
FFmpeg
|
41f3c60fbb7420f41295c8e0cf80acf9e71f72d0
|
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const AVPacket *avpkt)
{
AVCodecInternal *avci = avctx->internal;
int ret;
AVPacket tmp = *avpkt;
if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
}
*got_picture_ptr = 0;
if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
avcodec_get_frame_defaults(picture);
if (!avctx->refcounted_frames)
av_frame_unref(&avci->to_free);
if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
int did_split = av_packet_split_side_data(&tmp);
apply_param_change(avctx, &tmp);
avctx->pkt = &tmp;
if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
&tmp);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
&tmp);
picture->pkt_dts = avpkt->dts;
if(!avctx->has_b_frames){
av_frame_set_pkt_pos(picture, avpkt->pos);
}
if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {
if (!picture->sample_aspect_ratio.num) picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
if (!picture->width) picture->width = avctx->width;
if (!picture->height) picture->height = avctx->height;
if (picture->format == AV_PIX_FMT_NONE) picture->format = avctx->pix_fmt;
}
}
add_metadata_from_side_data(avctx, picture);
emms_c();
avctx->pkt = NULL;
if (did_split) {
ff_packet_free_side_data(&tmp);
if(ret == tmp.size)
ret = avpkt->size;
}
if (ret < 0 && picture->data[0])
av_frame_unref(picture);
if (*got_picture_ptr) {
if (!avctx->refcounted_frames) {
avci->to_free = *picture;
avci->to_free.extended_data = avci->to_free.data;
memset(picture->buf, 0, sizeof(picture->buf));
}
avctx->frame_number++;
av_frame_set_best_effort_timestamp(picture,
guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts));
}
} else
ret = 0;
picture->extended_data = picture->data;
return ret;
}
|
{
"code": [],
"line_no": []
}
|
int VAR_0 avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const AVPacket *avpkt)
{
AVCodecInternal *avci = avctx->internal;
int ret;
AVPacket tmp = *avpkt;
if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
}
*got_picture_ptr = 0;
if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
avcodec_get_frame_defaults(picture);
if (!avctx->refcounted_frames)
av_frame_unref(&avci->to_free);
if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
int did_split = av_packet_split_side_data(&tmp);
apply_param_change(avctx, &tmp);
avctx->pkt = &tmp;
if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
&tmp);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
&tmp);
picture->pkt_dts = avpkt->dts;
if(!avctx->has_b_frames){
av_frame_set_pkt_pos(picture, avpkt->pos);
}
if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {
if (!picture->sample_aspect_ratio.num) picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
if (!picture->width) picture->width = avctx->width;
if (!picture->height) picture->height = avctx->height;
if (picture->format == AV_PIX_FMT_NONE) picture->format = avctx->pix_fmt;
}
}
add_metadata_from_side_data(avctx, picture);
emms_c();
avctx->pkt = NULL;
if (did_split) {
ff_packet_free_side_data(&tmp);
if(ret == tmp.size)
ret = avpkt->size;
}
if (ret < 0 && picture->data[0])
av_frame_unref(picture);
if (*got_picture_ptr) {
if (!avctx->refcounted_frames) {
avci->to_free = *picture;
avci->to_free.extended_data = avci->to_free.data;
memset(picture->buf, 0, sizeof(picture->buf));
}
avctx->frame_number++;
av_frame_set_best_effort_timestamp(picture,
guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts));
}
} else
ret = 0;
picture->extended_data = picture->data;
return ret;
}
|
[
"int VAR_0 avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,\nint *got_picture_ptr,\nconst AVPacket *avpkt)\n{",
"AVCodecInternal *avci = avctx->internal;",
"int ret;",
"AVPacket tmp = *avpkt;",
"if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {",
"av_log(avctx, AV_LOG_ERROR, \"Invalid media type for video\\n\");",
"}",
"*got_picture_ptr = 0;",
"if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))\navcodec_get_frame_defaults(picture);",
"if (!avctx->refcounted_frames)\nav_frame_unref(&avci->to_free);",
"if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {",
"int did_split = av_packet_split_side_data(&tmp);",
"apply_param_change(avctx, &tmp);",
"avctx->pkt = &tmp;",
"if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)\nret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,\n&tmp);",
"else {",
"ret = avctx->codec->decode(avctx, picture, got_picture_ptr,\n&tmp);",
"picture->pkt_dts = avpkt->dts;",
"if(!avctx->has_b_frames){",
"av_frame_set_pkt_pos(picture, avpkt->pos);",
"}",
"if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {",
"if (!picture->sample_aspect_ratio.num) picture->sample_aspect_ratio = avctx->sample_aspect_ratio;",
"if (!picture->width) picture->width = avctx->width;",
"if (!picture->height) picture->height = avctx->height;",
"if (picture->format == AV_PIX_FMT_NONE) picture->format = avctx->pix_fmt;",
"}",
"}",
"add_metadata_from_side_data(avctx, picture);",
"emms_c();",
"avctx->pkt = NULL;",
"if (did_split) {",
"ff_packet_free_side_data(&tmp);",
"if(ret == tmp.size)\nret = avpkt->size;",
"}",
"if (ret < 0 && picture->data[0])\nav_frame_unref(picture);",
"if (*got_picture_ptr) {",
"if (!avctx->refcounted_frames) {",
"avci->to_free = *picture;",
"avci->to_free.extended_data = avci->to_free.data;",
"memset(picture->buf, 0, sizeof(picture->buf));",
"}",
"avctx->frame_number++;",
"av_frame_set_best_effort_timestamp(picture,\nguess_correct_pts(avctx,\npicture->pkt_pts,\npicture->pkt_dts));",
"}",
"} else",
"ret = 0;",
"picture->extended_data = picture->data;",
"return ret;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
21
],
[
23
],
[
26
],
[
30
],
[
32,
37
],
[
41,
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55,
57,
59
],
[
61
],
[
63,
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109,
111
],
[
113
],
[
117,
119
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
137
],
[
139,
141,
143,
145
],
[
147
],
[
149
],
[
151
],
[
159
],
[
163
],
[
165
]
] |
8,026 |
static int rdma_delete_block(RDMAContext *rdma, RDMALocalBlock *block)
{
RDMALocalBlocks *local = &rdma->local_ram_blocks;
RDMALocalBlock *old = local->block;
int x;
if (rdma->blockmap) {
g_hash_table_remove(rdma->blockmap, (void *)(uintptr_t)block->offset);
}
if (block->pmr) {
int j;
for (j = 0; j < block->nb_chunks; j++) {
if (!block->pmr[j]) {
continue;
}
ibv_dereg_mr(block->pmr[j]);
rdma->total_registrations--;
}
g_free(block->pmr);
block->pmr = NULL;
}
if (block->mr) {
ibv_dereg_mr(block->mr);
rdma->total_registrations--;
block->mr = NULL;
}
g_free(block->transit_bitmap);
block->transit_bitmap = NULL;
g_free(block->unregister_bitmap);
block->unregister_bitmap = NULL;
g_free(block->remote_keys);
block->remote_keys = NULL;
g_free(block->block_name);
block->block_name = NULL;
if (rdma->blockmap) {
for (x = 0; x < local->nb_blocks; x++) {
g_hash_table_remove(rdma->blockmap,
(void *)(uintptr_t)old[x].offset);
}
}
if (local->nb_blocks > 1) {
local->block = g_malloc0(sizeof(RDMALocalBlock) *
(local->nb_blocks - 1));
if (block->index) {
memcpy(local->block, old, sizeof(RDMALocalBlock) * block->index);
}
if (block->index < (local->nb_blocks - 1)) {
memcpy(local->block + block->index, old + (block->index + 1),
sizeof(RDMALocalBlock) *
(local->nb_blocks - (block->index + 1)));
}
} else {
assert(block == local->block);
local->block = NULL;
}
trace_rdma_delete_block(block, (uintptr_t)block->local_host_addr,
block->offset, block->length,
(uintptr_t)(block->local_host_addr + block->length),
BITS_TO_LONGS(block->nb_chunks) *
sizeof(unsigned long) * 8, block->nb_chunks);
g_free(old);
local->nb_blocks--;
if (local->nb_blocks && rdma->blockmap) {
for (x = 0; x < local->nb_blocks; x++) {
g_hash_table_insert(rdma->blockmap,
(void *)(uintptr_t)local->block[x].offset,
&local->block[x]);
}
}
return 0;
}
| true |
qemu
|
97f3ad35517e0d02c0149637d1bb10713c52b057
|
static int rdma_delete_block(RDMAContext *rdma, RDMALocalBlock *block)
{
RDMALocalBlocks *local = &rdma->local_ram_blocks;
RDMALocalBlock *old = local->block;
int x;
if (rdma->blockmap) {
g_hash_table_remove(rdma->blockmap, (void *)(uintptr_t)block->offset);
}
if (block->pmr) {
int j;
for (j = 0; j < block->nb_chunks; j++) {
if (!block->pmr[j]) {
continue;
}
ibv_dereg_mr(block->pmr[j]);
rdma->total_registrations--;
}
g_free(block->pmr);
block->pmr = NULL;
}
if (block->mr) {
ibv_dereg_mr(block->mr);
rdma->total_registrations--;
block->mr = NULL;
}
g_free(block->transit_bitmap);
block->transit_bitmap = NULL;
g_free(block->unregister_bitmap);
block->unregister_bitmap = NULL;
g_free(block->remote_keys);
block->remote_keys = NULL;
g_free(block->block_name);
block->block_name = NULL;
if (rdma->blockmap) {
for (x = 0; x < local->nb_blocks; x++) {
g_hash_table_remove(rdma->blockmap,
(void *)(uintptr_t)old[x].offset);
}
}
if (local->nb_blocks > 1) {
local->block = g_malloc0(sizeof(RDMALocalBlock) *
(local->nb_blocks - 1));
if (block->index) {
memcpy(local->block, old, sizeof(RDMALocalBlock) * block->index);
}
if (block->index < (local->nb_blocks - 1)) {
memcpy(local->block + block->index, old + (block->index + 1),
sizeof(RDMALocalBlock) *
(local->nb_blocks - (block->index + 1)));
}
} else {
assert(block == local->block);
local->block = NULL;
}
trace_rdma_delete_block(block, (uintptr_t)block->local_host_addr,
block->offset, block->length,
(uintptr_t)(block->local_host_addr + block->length),
BITS_TO_LONGS(block->nb_chunks) *
sizeof(unsigned long) * 8, block->nb_chunks);
g_free(old);
local->nb_blocks--;
if (local->nb_blocks && rdma->blockmap) {
for (x = 0; x < local->nb_blocks; x++) {
g_hash_table_insert(rdma->blockmap,
(void *)(uintptr_t)local->block[x].offset,
&local->block[x]);
}
}
return 0;
}
|
{
"code": [
" local->block = g_malloc0(sizeof(RDMALocalBlock) *",
" (local->nb_blocks - 1));"
],
"line_no": [
101,
103
]
}
|
static int FUNC_0(RDMAContext *VAR_0, RDMALocalBlock *VAR_1)
{
RDMALocalBlocks *local = &VAR_0->local_ram_blocks;
RDMALocalBlock *old = local->VAR_1;
int VAR_2;
if (VAR_0->blockmap) {
g_hash_table_remove(VAR_0->blockmap, (void *)(uintptr_t)VAR_1->offset);
}
if (VAR_1->pmr) {
int VAR_3;
for (VAR_3 = 0; VAR_3 < VAR_1->nb_chunks; VAR_3++) {
if (!VAR_1->pmr[VAR_3]) {
continue;
}
ibv_dereg_mr(VAR_1->pmr[VAR_3]);
VAR_0->total_registrations--;
}
g_free(VAR_1->pmr);
VAR_1->pmr = NULL;
}
if (VAR_1->mr) {
ibv_dereg_mr(VAR_1->mr);
VAR_0->total_registrations--;
VAR_1->mr = NULL;
}
g_free(VAR_1->transit_bitmap);
VAR_1->transit_bitmap = NULL;
g_free(VAR_1->unregister_bitmap);
VAR_1->unregister_bitmap = NULL;
g_free(VAR_1->remote_keys);
VAR_1->remote_keys = NULL;
g_free(VAR_1->block_name);
VAR_1->block_name = NULL;
if (VAR_0->blockmap) {
for (VAR_2 = 0; VAR_2 < local->nb_blocks; VAR_2++) {
g_hash_table_remove(VAR_0->blockmap,
(void *)(uintptr_t)old[VAR_2].offset);
}
}
if (local->nb_blocks > 1) {
local->VAR_1 = g_malloc0(sizeof(RDMALocalBlock) *
(local->nb_blocks - 1));
if (VAR_1->index) {
memcpy(local->VAR_1, old, sizeof(RDMALocalBlock) * VAR_1->index);
}
if (VAR_1->index < (local->nb_blocks - 1)) {
memcpy(local->VAR_1 + VAR_1->index, old + (VAR_1->index + 1),
sizeof(RDMALocalBlock) *
(local->nb_blocks - (VAR_1->index + 1)));
}
} else {
assert(VAR_1 == local->VAR_1);
local->VAR_1 = NULL;
}
trace_rdma_delete_block(VAR_1, (uintptr_t)VAR_1->local_host_addr,
VAR_1->offset, VAR_1->length,
(uintptr_t)(VAR_1->local_host_addr + VAR_1->length),
BITS_TO_LONGS(VAR_1->nb_chunks) *
sizeof(unsigned long) * 8, VAR_1->nb_chunks);
g_free(old);
local->nb_blocks--;
if (local->nb_blocks && VAR_0->blockmap) {
for (VAR_2 = 0; VAR_2 < local->nb_blocks; VAR_2++) {
g_hash_table_insert(VAR_0->blockmap,
(void *)(uintptr_t)local->VAR_1[VAR_2].offset,
&local->VAR_1[VAR_2]);
}
}
return 0;
}
|
[
"static int FUNC_0(RDMAContext *VAR_0, RDMALocalBlock *VAR_1)\n{",
"RDMALocalBlocks *local = &VAR_0->local_ram_blocks;",
"RDMALocalBlock *old = local->VAR_1;",
"int VAR_2;",
"if (VAR_0->blockmap) {",
"g_hash_table_remove(VAR_0->blockmap, (void *)(uintptr_t)VAR_1->offset);",
"}",
"if (VAR_1->pmr) {",
"int VAR_3;",
"for (VAR_3 = 0; VAR_3 < VAR_1->nb_chunks; VAR_3++) {",
"if (!VAR_1->pmr[VAR_3]) {",
"continue;",
"}",
"ibv_dereg_mr(VAR_1->pmr[VAR_3]);",
"VAR_0->total_registrations--;",
"}",
"g_free(VAR_1->pmr);",
"VAR_1->pmr = NULL;",
"}",
"if (VAR_1->mr) {",
"ibv_dereg_mr(VAR_1->mr);",
"VAR_0->total_registrations--;",
"VAR_1->mr = NULL;",
"}",
"g_free(VAR_1->transit_bitmap);",
"VAR_1->transit_bitmap = NULL;",
"g_free(VAR_1->unregister_bitmap);",
"VAR_1->unregister_bitmap = NULL;",
"g_free(VAR_1->remote_keys);",
"VAR_1->remote_keys = NULL;",
"g_free(VAR_1->block_name);",
"VAR_1->block_name = NULL;",
"if (VAR_0->blockmap) {",
"for (VAR_2 = 0; VAR_2 < local->nb_blocks; VAR_2++) {",
"g_hash_table_remove(VAR_0->blockmap,\n(void *)(uintptr_t)old[VAR_2].offset);",
"}",
"}",
"if (local->nb_blocks > 1) {",
"local->VAR_1 = g_malloc0(sizeof(RDMALocalBlock) *\n(local->nb_blocks - 1));",
"if (VAR_1->index) {",
"memcpy(local->VAR_1, old, sizeof(RDMALocalBlock) * VAR_1->index);",
"}",
"if (VAR_1->index < (local->nb_blocks - 1)) {",
"memcpy(local->VAR_1 + VAR_1->index, old + (VAR_1->index + 1),\nsizeof(RDMALocalBlock) *\n(local->nb_blocks - (VAR_1->index + 1)));",
"}",
"} else {",
"assert(VAR_1 == local->VAR_1);",
"local->VAR_1 = NULL;",
"}",
"trace_rdma_delete_block(VAR_1, (uintptr_t)VAR_1->local_host_addr,\nVAR_1->offset, VAR_1->length,\n(uintptr_t)(VAR_1->local_host_addr + VAR_1->length),\nBITS_TO_LONGS(VAR_1->nb_chunks) *\nsizeof(unsigned long) * 8, VAR_1->nb_chunks);",
"g_free(old);",
"local->nb_blocks--;",
"if (local->nb_blocks && VAR_0->blockmap) {",
"for (VAR_2 = 0; VAR_2 < local->nb_blocks; VAR_2++) {",
"g_hash_table_insert(VAR_0->blockmap,\n(void *)(uintptr_t)local->VAR_1[VAR_2].offset,\n&local->VAR_1[VAR_2]);",
"}",
"}",
"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,
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
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
65
],
[
67
],
[
71
],
[
73
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
97
],
[
101,
103
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117,
119,
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
135,
137,
139,
141,
143
],
[
147
],
[
151
],
[
155
],
[
157
],
[
159,
161,
163
],
[
165
],
[
167
],
[
171
],
[
173
]
] |
8,027 |
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
{
#if 1
level+=256;
if (n < 4) {
/* luminance */
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
} else {
/* chrominance */
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
}
#else
int size, v;
/* find number of bits */
size = 0;
v = abs(level);
while (v) {
v >>= 1;
size++;
}
if (n < 4) {
/* luminance */
put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
} else {
/* chrominance */
put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
}
/* encode remaining bits */
if (size > 0) {
if (level < 0)
level = (-level) ^ ((1 << size) - 1);
put_bits(&s->pb, size, level);
if (size > 8)
put_bits(&s->pb, 1, 1);
}
#endif
}
| true |
FFmpeg
|
49d2d1c35cc0438747dd8ef111163cb341f8f9fe
|
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
{
#if 1
level+=256;
if (n < 4) {
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
} else {
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
}
#else
int size, v;
size = 0;
v = abs(level);
while (v) {
v >>= 1;
size++;
}
if (n < 4) {
put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
} else {
put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
}
if (size > 0) {
if (level < 0)
level = (-level) ^ ((1 << size) - 1);
put_bits(&s->pb, size, level);
if (size > 8)
put_bits(&s->pb, 1, 1);
}
#endif
}
|
{
"code": [],
"line_no": []
}
|
static inline void FUNC_0(PutBitContext * VAR_0, int VAR_1, int VAR_2)
{
#if 1
VAR_1+=256;
if (VAR_2 < 4) {
put_bits(VAR_0, uni_DCtab_lum_len[VAR_1], uni_DCtab_lum_bits[VAR_1]);
} else {
put_bits(VAR_0, uni_DCtab_chrom_len[VAR_1], uni_DCtab_chrom_bits[VAR_1]);
}
#else
int size, v;
size = 0;
v = abs(VAR_1);
while (v) {
v >>= 1;
size++;
}
if (VAR_2 < 4) {
put_bits(&VAR_0->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
} else {
put_bits(&VAR_0->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
}
if (size > 0) {
if (VAR_1 < 0)
VAR_1 = (-VAR_1) ^ ((1 << size) - 1);
put_bits(&VAR_0->pb, size, VAR_1);
if (size > 8)
put_bits(&VAR_0->pb, 1, 1);
}
#endif
}
|
[
"static inline void FUNC_0(PutBitContext * VAR_0, int VAR_1, int VAR_2)\n{",
"#if 1\nVAR_1+=256;",
"if (VAR_2 < 4) {",
"put_bits(VAR_0, uni_DCtab_lum_len[VAR_1], uni_DCtab_lum_bits[VAR_1]);",
"} else {",
"put_bits(VAR_0, uni_DCtab_chrom_len[VAR_1], uni_DCtab_chrom_bits[VAR_1]);",
"}",
"#else\nint size, v;",
"size = 0;",
"v = abs(VAR_1);",
"while (v) {",
"v >>= 1;",
"size++;",
"}",
"if (VAR_2 < 4) {",
"put_bits(&VAR_0->pb, DCtab_lum[size][1], DCtab_lum[size][0]);",
"} else {",
"put_bits(&VAR_0->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);",
"}",
"if (size > 0) {",
"if (VAR_1 < 0)\nVAR_1 = (-VAR_1) ^ ((1 << size) - 1);",
"put_bits(&VAR_0->pb, size, VAR_1);",
"if (size > 8)\nput_bits(&VAR_0->pb, 1, 1);",
"}",
"#endif\n}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5,
8
],
[
10
],
[
14
],
[
16
],
[
20
],
[
22
],
[
24,
26
],
[
30
],
[
32
],
[
34
],
[
36
],
[
38
],
[
40
],
[
44
],
[
48
],
[
50
],
[
54
],
[
56
],
[
62
],
[
64,
66
],
[
68
],
[
70,
72
],
[
74
],
[
76,
78
]
] |
8,028 |
static int pick_formats(AVFilterGraph *graph)
{
int i, j, ret;
int change;
do{
change = 0;
for (i = 0; i < graph->filter_count; i++) {
AVFilterContext *filter = graph->filters[i];
if (filter->nb_inputs){
for (j = 0; j < filter->nb_inputs; j++){
if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_count == 1) {
pick_format(filter->inputs[j], NULL);
change = 1;
}
}
}
if (filter->nb_outputs){
for (j = 0; j < filter->nb_outputs; j++){
if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->format_count == 1) {
pick_format(filter->outputs[j], NULL);
change = 1;
}
}
}
if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
for (j = 0; j < filter->nb_outputs; j++) {
if(filter->outputs[j]->format<0) {
pick_format(filter->outputs[j], filter->inputs[0]);
change = 1;
}
}
}
}
}while(change);
for (i = 0; i < graph->filter_count; i++) {
AVFilterContext *filter = graph->filters[i];
for (j = 0; j < filter->nb_inputs; j++)
if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
return ret;
for (j = 0; j < filter->nb_outputs; j++)
if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
return ret;
}
return 0;
}
| false |
FFmpeg
|
b99bef17b44cdefdd91a5e07a4eba6a3cc4ee290
|
static int pick_formats(AVFilterGraph *graph)
{
int i, j, ret;
int change;
do{
change = 0;
for (i = 0; i < graph->filter_count; i++) {
AVFilterContext *filter = graph->filters[i];
if (filter->nb_inputs){
for (j = 0; j < filter->nb_inputs; j++){
if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_count == 1) {
pick_format(filter->inputs[j], NULL);
change = 1;
}
}
}
if (filter->nb_outputs){
for (j = 0; j < filter->nb_outputs; j++){
if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->format_count == 1) {
pick_format(filter->outputs[j], NULL);
change = 1;
}
}
}
if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
for (j = 0; j < filter->nb_outputs; j++) {
if(filter->outputs[j]->format<0) {
pick_format(filter->outputs[j], filter->inputs[0]);
change = 1;
}
}
}
}
}while(change);
for (i = 0; i < graph->filter_count; i++) {
AVFilterContext *filter = graph->filters[i];
for (j = 0; j < filter->nb_inputs; j++)
if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
return ret;
for (j = 0; j < filter->nb_outputs; j++)
if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
return ret;
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVFilterGraph *VAR_0)
{
int VAR_1, VAR_2, VAR_3;
int VAR_4;
do{
VAR_4 = 0;
for (VAR_1 = 0; VAR_1 < VAR_0->filter_count; VAR_1++) {
AVFilterContext *filter = VAR_0->filters[VAR_1];
if (filter->nb_inputs){
for (VAR_2 = 0; VAR_2 < filter->nb_inputs; VAR_2++){
if(filter->inputs[VAR_2]->in_formats && filter->inputs[VAR_2]->in_formats->format_count == 1) {
pick_format(filter->inputs[VAR_2], NULL);
VAR_4 = 1;
}
}
}
if (filter->nb_outputs){
for (VAR_2 = 0; VAR_2 < filter->nb_outputs; VAR_2++){
if(filter->outputs[VAR_2]->in_formats && filter->outputs[VAR_2]->in_formats->format_count == 1) {
pick_format(filter->outputs[VAR_2], NULL);
VAR_4 = 1;
}
}
}
if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
for (VAR_2 = 0; VAR_2 < filter->nb_outputs; VAR_2++) {
if(filter->outputs[VAR_2]->format<0) {
pick_format(filter->outputs[VAR_2], filter->inputs[0]);
VAR_4 = 1;
}
}
}
}
}while(VAR_4);
for (VAR_1 = 0; VAR_1 < VAR_0->filter_count; VAR_1++) {
AVFilterContext *filter = VAR_0->filters[VAR_1];
for (VAR_2 = 0; VAR_2 < filter->nb_inputs; VAR_2++)
if ((VAR_3 = pick_format(filter->inputs[VAR_2], NULL)) < 0)
return VAR_3;
for (VAR_2 = 0; VAR_2 < filter->nb_outputs; VAR_2++)
if ((VAR_3 = pick_format(filter->outputs[VAR_2], NULL)) < 0)
return VAR_3;
}
return 0;
}
|
[
"static int FUNC_0(AVFilterGraph *VAR_0)\n{",
"int VAR_1, VAR_2, VAR_3;",
"int VAR_4;",
"do{",
"VAR_4 = 0;",
"for (VAR_1 = 0; VAR_1 < VAR_0->filter_count; VAR_1++) {",
"AVFilterContext *filter = VAR_0->filters[VAR_1];",
"if (filter->nb_inputs){",
"for (VAR_2 = 0; VAR_2 < filter->nb_inputs; VAR_2++){",
"if(filter->inputs[VAR_2]->in_formats && filter->inputs[VAR_2]->in_formats->format_count == 1) {",
"pick_format(filter->inputs[VAR_2], NULL);",
"VAR_4 = 1;",
"}",
"}",
"}",
"if (filter->nb_outputs){",
"for (VAR_2 = 0; VAR_2 < filter->nb_outputs; VAR_2++){",
"if(filter->outputs[VAR_2]->in_formats && filter->outputs[VAR_2]->in_formats->format_count == 1) {",
"pick_format(filter->outputs[VAR_2], NULL);",
"VAR_4 = 1;",
"}",
"}",
"}",
"if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {",
"for (VAR_2 = 0; VAR_2 < filter->nb_outputs; VAR_2++) {",
"if(filter->outputs[VAR_2]->format<0) {",
"pick_format(filter->outputs[VAR_2], filter->inputs[0]);",
"VAR_4 = 1;",
"}",
"}",
"}",
"}",
"}while(VAR_4);",
"for (VAR_1 = 0; VAR_1 < VAR_0->filter_count; VAR_1++) {",
"AVFilterContext *filter = VAR_0->filters[VAR_1];",
"for (VAR_2 = 0; VAR_2 < filter->nb_inputs; VAR_2++)",
"if ((VAR_3 = pick_format(filter->inputs[VAR_2], NULL)) < 0)\nreturn VAR_3;",
"for (VAR_2 = 0; VAR_2 < filter->nb_outputs; VAR_2++)",
"if ((VAR_3 = pick_format(filter->outputs[VAR_2], NULL)) < 0)\nreturn VAR_3;",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
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
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
79
],
[
81,
83
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
95
]
] |
8,029 |
ff_yuv2packedX_altivec(SwsContext *c, const int16_t *lumFilter,
const int16_t **lumSrc, int lumFilterSize,
const int16_t *chrFilter, const int16_t **chrUSrc,
const int16_t **chrVSrc, int chrFilterSize,
const int16_t **alpSrc, uint8_t *dest,
int dstW, int dstY)
{
int i,j;
vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
vector signed short R0,G0,B0,R1,G1,B1;
vector unsigned char R,G,B;
vector unsigned char *out,*nout;
vector signed short RND = vec_splat_s16(1<<3);
vector unsigned short SCL = vec_splat_u16(4);
DECLARE_ALIGNED(16, unsigned int, scratch)[16];
vector signed short *YCoeffs, *CCoeffs;
YCoeffs = c->vYCoeffsBank+dstY*lumFilterSize;
CCoeffs = c->vCCoeffsBank+dstY*chrFilterSize;
out = (vector unsigned char *)dest;
for (i=0; i<dstW; i+=16) {
Y0 = RND;
Y1 = RND;
/* extract 16 coeffs from lumSrc */
for (j=0; j<lumFilterSize; j++) {
X0 = vec_ld (0, &lumSrc[j][i]);
X1 = vec_ld (16, &lumSrc[j][i]);
Y0 = vec_mradds (X0, YCoeffs[j], Y0);
Y1 = vec_mradds (X1, YCoeffs[j], Y1);
}
U = RND;
V = RND;
/* extract 8 coeffs from U,V */
for (j=0; j<chrFilterSize; j++) {
X = vec_ld (0, &chrUSrc[j][i/2]);
U = vec_mradds (X, CCoeffs[j], U);
X = vec_ld (0, &chrVSrc[j][i/2]);
V = vec_mradds (X, CCoeffs[j], V);
}
/* scale and clip signals */
Y0 = vec_sra (Y0, SCL);
Y1 = vec_sra (Y1, SCL);
U = vec_sra (U, SCL);
V = vec_sra (V, SCL);
Y0 = vec_clip_s16 (Y0);
Y1 = vec_clip_s16 (Y1);
U = vec_clip_s16 (U);
V = vec_clip_s16 (V);
/* now we have
Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
U= u0 u1 u2 u3 u4 u5 u6 u7 V= v0 v1 v2 v3 v4 v5 v6 v7
Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
U0= u0 u0 u1 u1 u2 u2 u3 u3 U1= u4 u4 u5 u5 u6 u6 u7 u7
V0= v0 v0 v1 v1 v2 v2 v3 v3 V1= v4 v4 v5 v5 v6 v6 v7 v7
*/
U0 = vec_mergeh (U,U);
V0 = vec_mergeh (V,V);
U1 = vec_mergel (U,U);
V1 = vec_mergel (V,V);
cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
R = vec_packclp (R0,R1);
G = vec_packclp (G0,G1);
B = vec_packclp (B0,B1);
switch(c->dstFormat) {
case PIX_FMT_ABGR: out_abgr (R,G,B,out); break;
case PIX_FMT_BGRA: out_bgra (R,G,B,out); break;
case PIX_FMT_RGBA: out_rgba (R,G,B,out); break;
case PIX_FMT_ARGB: out_argb (R,G,B,out); break;
case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;
case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;
default:
{
/* If this is reached, the caller should have called yuv2packedXinC
instead. */
static int printed_error_message;
if (!printed_error_message) {
av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
sws_format_name(c->dstFormat));
printed_error_message=1;
}
return;
}
}
}
if (i < dstW) {
i -= 16;
Y0 = RND;
Y1 = RND;
/* extract 16 coeffs from lumSrc */
for (j=0; j<lumFilterSize; j++) {
X0 = vec_ld (0, &lumSrc[j][i]);
X1 = vec_ld (16, &lumSrc[j][i]);
Y0 = vec_mradds (X0, YCoeffs[j], Y0);
Y1 = vec_mradds (X1, YCoeffs[j], Y1);
}
U = RND;
V = RND;
/* extract 8 coeffs from U,V */
for (j=0; j<chrFilterSize; j++) {
X = vec_ld (0, &chrUSrc[j][i/2]);
U = vec_mradds (X, CCoeffs[j], U);
X = vec_ld (0, &chrVSrc[j][i/2]);
V = vec_mradds (X, CCoeffs[j], V);
}
/* scale and clip signals */
Y0 = vec_sra (Y0, SCL);
Y1 = vec_sra (Y1, SCL);
U = vec_sra (U, SCL);
V = vec_sra (V, SCL);
Y0 = vec_clip_s16 (Y0);
Y1 = vec_clip_s16 (Y1);
U = vec_clip_s16 (U);
V = vec_clip_s16 (V);
/* now we have
Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
U = u0 u1 u2 u3 u4 u5 u6 u7 V = v0 v1 v2 v3 v4 v5 v6 v7
Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15
U0= u0 u0 u1 u1 u2 u2 u3 u3 U1= u4 u4 u5 u5 u6 u6 u7 u7
V0= v0 v0 v1 v1 v2 v2 v3 v3 V1= v4 v4 v5 v5 v6 v6 v7 v7
*/
U0 = vec_mergeh (U,U);
V0 = vec_mergeh (V,V);
U1 = vec_mergel (U,U);
V1 = vec_mergel (V,V);
cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
R = vec_packclp (R0,R1);
G = vec_packclp (G0,G1);
B = vec_packclp (B0,B1);
nout = (vector unsigned char *)scratch;
switch(c->dstFormat) {
case PIX_FMT_ABGR: out_abgr (R,G,B,nout); break;
case PIX_FMT_BGRA: out_bgra (R,G,B,nout); break;
case PIX_FMT_RGBA: out_rgba (R,G,B,nout); break;
case PIX_FMT_ARGB: out_argb (R,G,B,nout); break;
case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;
case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;
default:
/* Unreachable, I think. */
av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
sws_format_name(c->dstFormat));
return;
}
memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4);
}
}
| false |
FFmpeg
|
dc179ec81902e3c9d327f9e818454f2849308000
|
ff_yuv2packedX_altivec(SwsContext *c, const int16_t *lumFilter,
const int16_t **lumSrc, int lumFilterSize,
const int16_t *chrFilter, const int16_t **chrUSrc,
const int16_t **chrVSrc, int chrFilterSize,
const int16_t **alpSrc, uint8_t *dest,
int dstW, int dstY)
{
int i,j;
vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
vector signed short R0,G0,B0,R1,G1,B1;
vector unsigned char R,G,B;
vector unsigned char *out,*nout;
vector signed short RND = vec_splat_s16(1<<3);
vector unsigned short SCL = vec_splat_u16(4);
DECLARE_ALIGNED(16, unsigned int, scratch)[16];
vector signed short *YCoeffs, *CCoeffs;
YCoeffs = c->vYCoeffsBank+dstY*lumFilterSize;
CCoeffs = c->vCCoeffsBank+dstY*chrFilterSize;
out = (vector unsigned char *)dest;
for (i=0; i<dstW; i+=16) {
Y0 = RND;
Y1 = RND;
for (j=0; j<lumFilterSize; j++) {
X0 = vec_ld (0, &lumSrc[j][i]);
X1 = vec_ld (16, &lumSrc[j][i]);
Y0 = vec_mradds (X0, YCoeffs[j], Y0);
Y1 = vec_mradds (X1, YCoeffs[j], Y1);
}
U = RND;
V = RND;
for (j=0; j<chrFilterSize; j++) {
X = vec_ld (0, &chrUSrc[j][i/2]);
U = vec_mradds (X, CCoeffs[j], U);
X = vec_ld (0, &chrVSrc[j][i/2]);
V = vec_mradds (X, CCoeffs[j], V);
}
Y0 = vec_sra (Y0, SCL);
Y1 = vec_sra (Y1, SCL);
U = vec_sra (U, SCL);
V = vec_sra (V, SCL);
Y0 = vec_clip_s16 (Y0);
Y1 = vec_clip_s16 (Y1);
U = vec_clip_s16 (U);
V = vec_clip_s16 (V);
U0 = vec_mergeh (U,U);
V0 = vec_mergeh (V,V);
U1 = vec_mergel (U,U);
V1 = vec_mergel (V,V);
cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
R = vec_packclp (R0,R1);
G = vec_packclp (G0,G1);
B = vec_packclp (B0,B1);
switch(c->dstFormat) {
case PIX_FMT_ABGR: out_abgr (R,G,B,out); break;
case PIX_FMT_BGRA: out_bgra (R,G,B,out); break;
case PIX_FMT_RGBA: out_rgba (R,G,B,out); break;
case PIX_FMT_ARGB: out_argb (R,G,B,out); break;
case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;
case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;
default:
{
static int printed_error_message;
if (!printed_error_message) {
av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
sws_format_name(c->dstFormat));
printed_error_message=1;
}
return;
}
}
}
if (i < dstW) {
i -= 16;
Y0 = RND;
Y1 = RND;
for (j=0; j<lumFilterSize; j++) {
X0 = vec_ld (0, &lumSrc[j][i]);
X1 = vec_ld (16, &lumSrc[j][i]);
Y0 = vec_mradds (X0, YCoeffs[j], Y0);
Y1 = vec_mradds (X1, YCoeffs[j], Y1);
}
U = RND;
V = RND;
for (j=0; j<chrFilterSize; j++) {
X = vec_ld (0, &chrUSrc[j][i/2]);
U = vec_mradds (X, CCoeffs[j], U);
X = vec_ld (0, &chrVSrc[j][i/2]);
V = vec_mradds (X, CCoeffs[j], V);
}
Y0 = vec_sra (Y0, SCL);
Y1 = vec_sra (Y1, SCL);
U = vec_sra (U, SCL);
V = vec_sra (V, SCL);
Y0 = vec_clip_s16 (Y0);
Y1 = vec_clip_s16 (Y1);
U = vec_clip_s16 (U);
V = vec_clip_s16 (V);
U0 = vec_mergeh (U,U);
V0 = vec_mergeh (V,V);
U1 = vec_mergel (U,U);
V1 = vec_mergel (V,V);
cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
R = vec_packclp (R0,R1);
G = vec_packclp (G0,G1);
B = vec_packclp (B0,B1);
nout = (vector unsigned char *)scratch;
switch(c->dstFormat) {
case PIX_FMT_ABGR: out_abgr (R,G,B,nout); break;
case PIX_FMT_BGRA: out_bgra (R,G,B,nout); break;
case PIX_FMT_RGBA: out_rgba (R,G,B,nout); break;
case PIX_FMT_ARGB: out_argb (R,G,B,nout); break;
case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;
case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;
default:
av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
sws_format_name(c->dstFormat));
return;
}
memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4);
}
}
|
{
"code": [],
"line_no": []
}
|
FUNC_0(SwsContext *VAR_0, const int16_t *VAR_1,
const int16_t **VAR_2, int VAR_3,
const int16_t *VAR_4, const int16_t **VAR_5,
const int16_t **VAR_6, int VAR_7,
const int16_t **VAR_8, uint8_t *VAR_9,
int VAR_10, int VAR_11)
{
int VAR_12,VAR_13;
vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
vector signed short R0,G0,B0,R1,G1,B1;
vector unsigned char R,G,B;
vector unsigned char *out,*nout;
vector signed short RND = vec_splat_s16(1<<3);
vector unsigned short SCL = vec_splat_u16(4);
DECLARE_ALIGNED(16, unsigned int, scratch)[16];
vector signed short *YCoeffs, *CCoeffs;
YCoeffs = VAR_0->vYCoeffsBank+VAR_11*VAR_3;
CCoeffs = VAR_0->vCCoeffsBank+VAR_11*VAR_7;
out = (vector unsigned char *)VAR_9;
for (VAR_12=0; VAR_12<VAR_10; VAR_12+=16) {
Y0 = RND;
Y1 = RND;
for (VAR_13=0; VAR_13<VAR_3; VAR_13++) {
X0 = vec_ld (0, &VAR_2[VAR_13][VAR_12]);
X1 = vec_ld (16, &VAR_2[VAR_13][VAR_12]);
Y0 = vec_mradds (X0, YCoeffs[VAR_13], Y0);
Y1 = vec_mradds (X1, YCoeffs[VAR_13], Y1);
}
U = RND;
V = RND;
for (VAR_13=0; VAR_13<VAR_7; VAR_13++) {
X = vec_ld (0, &VAR_5[VAR_13][VAR_12/2]);
U = vec_mradds (X, CCoeffs[VAR_13], U);
X = vec_ld (0, &VAR_6[VAR_13][VAR_12/2]);
V = vec_mradds (X, CCoeffs[VAR_13], V);
}
Y0 = vec_sra (Y0, SCL);
Y1 = vec_sra (Y1, SCL);
U = vec_sra (U, SCL);
V = vec_sra (V, SCL);
Y0 = vec_clip_s16 (Y0);
Y1 = vec_clip_s16 (Y1);
U = vec_clip_s16 (U);
V = vec_clip_s16 (V);
U0 = vec_mergeh (U,U);
V0 = vec_mergeh (V,V);
U1 = vec_mergel (U,U);
V1 = vec_mergel (V,V);
cvtyuvtoRGB (VAR_0, Y0,U0,V0,&R0,&G0,&B0);
cvtyuvtoRGB (VAR_0, Y1,U1,V1,&R1,&G1,&B1);
R = vec_packclp (R0,R1);
G = vec_packclp (G0,G1);
B = vec_packclp (B0,B1);
switch(VAR_0->dstFormat) {
case PIX_FMT_ABGR: out_abgr (R,G,B,out); break;
case PIX_FMT_BGRA: out_bgra (R,G,B,out); break;
case PIX_FMT_RGBA: out_rgba (R,G,B,out); break;
case PIX_FMT_ARGB: out_argb (R,G,B,out); break;
case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;
case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;
default:
{
static int VAR_14;
if (!VAR_14) {
av_log(VAR_0, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
sws_format_name(VAR_0->dstFormat));
VAR_14=1;
}
return;
}
}
}
if (VAR_12 < VAR_10) {
VAR_12 -= 16;
Y0 = RND;
Y1 = RND;
for (VAR_13=0; VAR_13<VAR_3; VAR_13++) {
X0 = vec_ld (0, &VAR_2[VAR_13][VAR_12]);
X1 = vec_ld (16, &VAR_2[VAR_13][VAR_12]);
Y0 = vec_mradds (X0, YCoeffs[VAR_13], Y0);
Y1 = vec_mradds (X1, YCoeffs[VAR_13], Y1);
}
U = RND;
V = RND;
for (VAR_13=0; VAR_13<VAR_7; VAR_13++) {
X = vec_ld (0, &VAR_5[VAR_13][VAR_12/2]);
U = vec_mradds (X, CCoeffs[VAR_13], U);
X = vec_ld (0, &VAR_6[VAR_13][VAR_12/2]);
V = vec_mradds (X, CCoeffs[VAR_13], V);
}
Y0 = vec_sra (Y0, SCL);
Y1 = vec_sra (Y1, SCL);
U = vec_sra (U, SCL);
V = vec_sra (V, SCL);
Y0 = vec_clip_s16 (Y0);
Y1 = vec_clip_s16 (Y1);
U = vec_clip_s16 (U);
V = vec_clip_s16 (V);
U0 = vec_mergeh (U,U);
V0 = vec_mergeh (V,V);
U1 = vec_mergel (U,U);
V1 = vec_mergel (V,V);
cvtyuvtoRGB (VAR_0, Y0,U0,V0,&R0,&G0,&B0);
cvtyuvtoRGB (VAR_0, Y1,U1,V1,&R1,&G1,&B1);
R = vec_packclp (R0,R1);
G = vec_packclp (G0,G1);
B = vec_packclp (B0,B1);
nout = (vector unsigned char *)scratch;
switch(VAR_0->dstFormat) {
case PIX_FMT_ABGR: out_abgr (R,G,B,nout); break;
case PIX_FMT_BGRA: out_bgra (R,G,B,nout); break;
case PIX_FMT_RGBA: out_rgba (R,G,B,nout); break;
case PIX_FMT_ARGB: out_argb (R,G,B,nout); break;
case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;
case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;
default:
av_log(VAR_0, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
sws_format_name(VAR_0->dstFormat));
return;
}
memcpy (&((uint32_t*)VAR_9)[VAR_12], scratch, (VAR_10-VAR_12)/4);
}
}
|
[
"FUNC_0(SwsContext *VAR_0, const int16_t *VAR_1,\nconst int16_t **VAR_2, int VAR_3,\nconst int16_t *VAR_4, const int16_t **VAR_5,\nconst int16_t **VAR_6, int VAR_7,\nconst int16_t **VAR_8, uint8_t *VAR_9,\nint VAR_10, int VAR_11)\n{",
"int VAR_12,VAR_13;",
"vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;",
"vector signed short R0,G0,B0,R1,G1,B1;",
"vector unsigned char R,G,B;",
"vector unsigned char *out,*nout;",
"vector signed short RND = vec_splat_s16(1<<3);",
"vector unsigned short SCL = vec_splat_u16(4);",
"DECLARE_ALIGNED(16, unsigned int, scratch)[16];",
"vector signed short *YCoeffs, *CCoeffs;",
"YCoeffs = VAR_0->vYCoeffsBank+VAR_11*VAR_3;",
"CCoeffs = VAR_0->vCCoeffsBank+VAR_11*VAR_7;",
"out = (vector unsigned char *)VAR_9;",
"for (VAR_12=0; VAR_12<VAR_10; VAR_12+=16) {",
"Y0 = RND;",
"Y1 = RND;",
"for (VAR_13=0; VAR_13<VAR_3; VAR_13++) {",
"X0 = vec_ld (0, &VAR_2[VAR_13][VAR_12]);",
"X1 = vec_ld (16, &VAR_2[VAR_13][VAR_12]);",
"Y0 = vec_mradds (X0, YCoeffs[VAR_13], Y0);",
"Y1 = vec_mradds (X1, YCoeffs[VAR_13], Y1);",
"}",
"U = RND;",
"V = RND;",
"for (VAR_13=0; VAR_13<VAR_7; VAR_13++) {",
"X = vec_ld (0, &VAR_5[VAR_13][VAR_12/2]);",
"U = vec_mradds (X, CCoeffs[VAR_13], U);",
"X = vec_ld (0, &VAR_6[VAR_13][VAR_12/2]);",
"V = vec_mradds (X, CCoeffs[VAR_13], V);",
"}",
"Y0 = vec_sra (Y0, SCL);",
"Y1 = vec_sra (Y1, SCL);",
"U = vec_sra (U, SCL);",
"V = vec_sra (V, SCL);",
"Y0 = vec_clip_s16 (Y0);",
"Y1 = vec_clip_s16 (Y1);",
"U = vec_clip_s16 (U);",
"V = vec_clip_s16 (V);",
"U0 = vec_mergeh (U,U);",
"V0 = vec_mergeh (V,V);",
"U1 = vec_mergel (U,U);",
"V1 = vec_mergel (V,V);",
"cvtyuvtoRGB (VAR_0, Y0,U0,V0,&R0,&G0,&B0);",
"cvtyuvtoRGB (VAR_0, Y1,U1,V1,&R1,&G1,&B1);",
"R = vec_packclp (R0,R1);",
"G = vec_packclp (G0,G1);",
"B = vec_packclp (B0,B1);",
"switch(VAR_0->dstFormat) {",
"case PIX_FMT_ABGR: out_abgr (R,G,B,out); break;",
"case PIX_FMT_BGRA: out_bgra (R,G,B,out); break;",
"case PIX_FMT_RGBA: out_rgba (R,G,B,out); break;",
"case PIX_FMT_ARGB: out_argb (R,G,B,out); break;",
"case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;",
"case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;",
"default:\n{",
"static int VAR_14;",
"if (!VAR_14) {",
"av_log(VAR_0, AV_LOG_ERROR, \"altivec_yuv2packedX doesn't support %s output\\n\",\nsws_format_name(VAR_0->dstFormat));",
"VAR_14=1;",
"}",
"return;",
"}",
"}",
"}",
"if (VAR_12 < VAR_10) {",
"VAR_12 -= 16;",
"Y0 = RND;",
"Y1 = RND;",
"for (VAR_13=0; VAR_13<VAR_3; VAR_13++) {",
"X0 = vec_ld (0, &VAR_2[VAR_13][VAR_12]);",
"X1 = vec_ld (16, &VAR_2[VAR_13][VAR_12]);",
"Y0 = vec_mradds (X0, YCoeffs[VAR_13], Y0);",
"Y1 = vec_mradds (X1, YCoeffs[VAR_13], Y1);",
"}",
"U = RND;",
"V = RND;",
"for (VAR_13=0; VAR_13<VAR_7; VAR_13++) {",
"X = vec_ld (0, &VAR_5[VAR_13][VAR_12/2]);",
"U = vec_mradds (X, CCoeffs[VAR_13], U);",
"X = vec_ld (0, &VAR_6[VAR_13][VAR_12/2]);",
"V = vec_mradds (X, CCoeffs[VAR_13], V);",
"}",
"Y0 = vec_sra (Y0, SCL);",
"Y1 = vec_sra (Y1, SCL);",
"U = vec_sra (U, SCL);",
"V = vec_sra (V, SCL);",
"Y0 = vec_clip_s16 (Y0);",
"Y1 = vec_clip_s16 (Y1);",
"U = vec_clip_s16 (U);",
"V = vec_clip_s16 (V);",
"U0 = vec_mergeh (U,U);",
"V0 = vec_mergeh (V,V);",
"U1 = vec_mergel (U,U);",
"V1 = vec_mergel (V,V);",
"cvtyuvtoRGB (VAR_0, Y0,U0,V0,&R0,&G0,&B0);",
"cvtyuvtoRGB (VAR_0, Y1,U1,V1,&R1,&G1,&B1);",
"R = vec_packclp (R0,R1);",
"G = vec_packclp (G0,G1);",
"B = vec_packclp (B0,B1);",
"nout = (vector unsigned char *)scratch;",
"switch(VAR_0->dstFormat) {",
"case PIX_FMT_ABGR: out_abgr (R,G,B,nout); break;",
"case PIX_FMT_BGRA: out_bgra (R,G,B,nout); break;",
"case PIX_FMT_RGBA: out_rgba (R,G,B,nout); break;",
"case PIX_FMT_ARGB: out_argb (R,G,B,nout); break;",
"case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;",
"case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;",
"default:\nav_log(VAR_0, AV_LOG_ERROR, \"altivec_yuv2packedX doesn't support %s output\\n\",\nsws_format_name(VAR_0->dstFormat));",
"return;",
"}",
"memcpy (&((uint32_t*)VAR_9)[VAR_12], scratch, (VAR_10-VAR_12)/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,
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
],
[
37
],
[
41
],
[
43
],
[
47
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109
],
[
111
],
[
133
],
[
135
],
[
139
],
[
141
],
[
145
],
[
147
],
[
151
],
[
153
],
[
155
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173,
175
],
[
181
],
[
183
],
[
185,
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
],
[
209
],
[
211
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
229
],
[
231
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
251
],
[
253
],
[
255
],
[
257
],
[
261
],
[
263
],
[
265
],
[
267
],
[
289
],
[
291
],
[
295
],
[
297
],
[
301
],
[
303
],
[
307
],
[
309
],
[
311
],
[
315
],
[
317
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327
],
[
329
],
[
331,
335,
337
],
[
339
],
[
341
],
[
345
],
[
347
],
[
351
]
] |
8,031 |
static void arm_gic_common_realize(DeviceState *dev, Error **errp)
{
GICState *s = ARM_GIC_COMMON(dev);
int num_irq = s->num_irq;
if (s->num_cpu > GIC_NCPU) {
error_setg(errp, "requested %u CPUs exceeds GIC maximum %d",
s->num_cpu, GIC_NCPU);
s->num_irq += GIC_BASE_IRQ;
if (s->num_irq > GIC_MAXIRQ) {
error_setg(errp,
"requested %u interrupt lines exceeds GIC maximum %d",
num_irq, GIC_MAXIRQ);
/* ITLinesNumber is represented as (N / 32) - 1 (see
* gic_dist_readb) so this is an implementation imposed
* restriction, not an architectural one:
*/
if (s->num_irq < 32 || (s->num_irq % 32)) {
error_setg(errp,
"%d interrupt lines unsupported: not divisible by 32",
num_irq);
| true |
qemu
|
5543d1abb6e218a9d3b8887b777fd3947c86c4cf
|
static void arm_gic_common_realize(DeviceState *dev, Error **errp)
{
GICState *s = ARM_GIC_COMMON(dev);
int num_irq = s->num_irq;
if (s->num_cpu > GIC_NCPU) {
error_setg(errp, "requested %u CPUs exceeds GIC maximum %d",
s->num_cpu, GIC_NCPU);
s->num_irq += GIC_BASE_IRQ;
if (s->num_irq > GIC_MAXIRQ) {
error_setg(errp,
"requested %u interrupt lines exceeds GIC maximum %d",
num_irq, GIC_MAXIRQ);
if (s->num_irq < 32 || (s->num_irq % 32)) {
error_setg(errp,
"%d interrupt lines unsupported: not divisible by 32",
num_irq);
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
GICState *s = ARM_GIC_COMMON(VAR_0);
int VAR_2 = s->VAR_2;
if (s->num_cpu > GIC_NCPU) {
error_setg(VAR_1, "requested %u CPUs exceeds GIC maximum %d",
s->num_cpu, GIC_NCPU);
s->VAR_2 += GIC_BASE_IRQ;
if (s->VAR_2 > GIC_MAXIRQ) {
error_setg(VAR_1,
"requested %u interrupt lines exceeds GIC maximum %d",
VAR_2, GIC_MAXIRQ);
if (s->VAR_2 < 32 || (s->VAR_2 % 32)) {
error_setg(VAR_1,
"%d interrupt lines unsupported: not divisible by 32",
VAR_2);
|
[
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"GICState *s = ARM_GIC_COMMON(VAR_0);",
"int VAR_2 = s->VAR_2;",
"if (s->num_cpu > GIC_NCPU) {",
"error_setg(VAR_1, \"requested %u CPUs exceeds GIC maximum %d\",\ns->num_cpu, GIC_NCPU);",
"s->VAR_2 += GIC_BASE_IRQ;",
"if (s->VAR_2 > GIC_MAXIRQ) {",
"error_setg(VAR_1,\n\"requested %u interrupt lines exceeds GIC maximum %d\",\nVAR_2, GIC_MAXIRQ);",
"if (s->VAR_2 < 32 || (s->VAR_2 % 32)) {",
"error_setg(VAR_1,\n\"%d interrupt lines unsupported: not divisible by 32\",\nVAR_2);"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6,
7
],
[
8
],
[
9
],
[
10,
11,
12
],
[
17
],
[
18,
19,
20
]
] |
8,032 |
static int lance_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
SysBusPCNetState *d = SYSBUS_PCNET(dev);
PCNetState *s = &d->state;
memory_region_init_io(&s->mmio, OBJECT(d), &lance_mem_ops, d,
"lance-mmio", 4);
qdev_init_gpio_in(dev, parent_lance_reset, 1);
sysbus_init_mmio(sbd, &s->mmio);
sysbus_init_irq(sbd, &s->irq);
s->phys_mem_read = ledma_memory_read;
s->phys_mem_write = ledma_memory_write;
return pcnet_common_init(dev, s, &net_lance_info);
}
| true |
qemu
|
4c3b22459d3589cf84d1ccadc6b09e586497820d
|
static int lance_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
SysBusPCNetState *d = SYSBUS_PCNET(dev);
PCNetState *s = &d->state;
memory_region_init_io(&s->mmio, OBJECT(d), &lance_mem_ops, d,
"lance-mmio", 4);
qdev_init_gpio_in(dev, parent_lance_reset, 1);
sysbus_init_mmio(sbd, &s->mmio);
sysbus_init_irq(sbd, &s->irq);
s->phys_mem_read = ledma_memory_read;
s->phys_mem_write = ledma_memory_write;
return pcnet_common_init(dev, s, &net_lance_info);
}
|
{
"code": [
" return pcnet_common_init(dev, s, &net_lance_info);"
],
"line_no": [
35
]
}
|
static int FUNC_0(SysBusDevice *VAR_0)
{
DeviceState *dev = DEVICE(VAR_0);
SysBusPCNetState *d = SYSBUS_PCNET(dev);
PCNetState *s = &d->state;
memory_region_init_io(&s->mmio, OBJECT(d), &lance_mem_ops, d,
"lance-mmio", 4);
qdev_init_gpio_in(dev, parent_lance_reset, 1);
sysbus_init_mmio(VAR_0, &s->mmio);
sysbus_init_irq(VAR_0, &s->irq);
s->phys_mem_read = ledma_memory_read;
s->phys_mem_write = ledma_memory_write;
return pcnet_common_init(dev, s, &net_lance_info);
}
|
[
"static int FUNC_0(SysBusDevice *VAR_0)\n{",
"DeviceState *dev = DEVICE(VAR_0);",
"SysBusPCNetState *d = SYSBUS_PCNET(dev);",
"PCNetState *s = &d->state;",
"memory_region_init_io(&s->mmio, OBJECT(d), &lance_mem_ops, d,\n\"lance-mmio\", 4);",
"qdev_init_gpio_in(dev, parent_lance_reset, 1);",
"sysbus_init_mmio(VAR_0, &s->mmio);",
"sysbus_init_irq(VAR_0, &s->irq);",
"s->phys_mem_read = ledma_memory_read;",
"s->phys_mem_write = ledma_memory_write;",
"return pcnet_common_init(dev, s, &net_lance_info);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13,
15
],
[
19
],
[
23
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
]
] |
8,033 |
static int vc9_decode_init(AVCodecContext *avctx)
{
VC9Context *v = avctx->priv_data;
MpegEncContext *s = &v->s;
GetBitContext gb;
if (!avctx->extradata_size || !avctx->extradata) return -1;
avctx->pix_fmt = PIX_FMT_YUV420P;
v->s.avctx = avctx;
if(ff_h263_decode_init(avctx) < 0)
return -1;
if (vc9_init_common(v) < 0) return -1;
avctx->coded_width = avctx->width;
avctx->coded_height = avctx->height;
if (avctx->codec_id == CODEC_ID_WMV3)
{
int count = 0;
// looks like WMV3 has a sequence header stored in the extradata
// advanced sequence header may be before the first frame
// the last byte of the extradata is a version number, 1 for the
// samples we can decode
init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
decode_sequence_header(avctx, &gb);
count = avctx->extradata_size*8 - get_bits_count(&gb);
if (count>0)
{
av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
count, get_bits(&gb, count));
}
else
{
av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
}
}
avctx->has_b_frames= !!(avctx->max_b_frames);
s->mb_width = (avctx->coded_width+15)>>4;
s->mb_height = (avctx->coded_height+15)>>4;
/* Allocate mb bitplanes */
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
/* For predictors */
v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
if (!v->previous_line_cbpcy) return -1;
#if HAS_ADVANCED_PROFILE
if (v->profile > PROFILE_MAIN)
{
if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
return -1;
}
#endif
return 0;
}
| true |
FFmpeg
|
7cc84d241ba6ef8e27e4d057176a4ad385ad3d59
|
static int vc9_decode_init(AVCodecContext *avctx)
{
VC9Context *v = avctx->priv_data;
MpegEncContext *s = &v->s;
GetBitContext gb;
if (!avctx->extradata_size || !avctx->extradata) return -1;
avctx->pix_fmt = PIX_FMT_YUV420P;
v->s.avctx = avctx;
if(ff_h263_decode_init(avctx) < 0)
return -1;
if (vc9_init_common(v) < 0) return -1;
avctx->coded_width = avctx->width;
avctx->coded_height = avctx->height;
if (avctx->codec_id == CODEC_ID_WMV3)
{
int count = 0;
init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
decode_sequence_header(avctx, &gb);
count = avctx->extradata_size*8 - get_bits_count(&gb);
if (count>0)
{
av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
count, get_bits(&gb, count));
}
else
{
av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
}
}
avctx->has_b_frames= !!(avctx->max_b_frames);
s->mb_width = (avctx->coded_width+15)>>4;
s->mb_height = (avctx->coded_height+15)>>4;
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
if (!v->previous_line_cbpcy) return -1;
#if HAS_ADVANCED_PROFILE
if (v->profile > PROFILE_MAIN)
{
if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
return -1;
}
#endif
return 0;
}
|
{
"code": [
"#endif",
"#endif",
"#endif",
"#endif",
" if (v->profile > PROFILE_MAIN)",
"#endif",
" if (v->profile > PROFILE_MAIN)",
" if (v->profile > PROFILE_MAIN)",
" if (v->profile > PROFILE_MAIN)",
" init_get_bits(&gb, avctx->extradata, avctx->extradata_size);",
" decode_sequence_header(avctx, &gb);",
" if (v->profile > PROFILE_MAIN)",
" if (v->profile > PROFILE_MAIN)",
" if (v->profile > PROFILE_MAIN)",
" if (v->profile > PROFILE_MAIN)",
"#endif",
"#endif"
],
"line_no": [
135,
135,
135,
135,
121,
135,
121,
121,
121,
51,
55,
121,
121,
121,
121,
135,
135
]
}
|
static int FUNC_0(AVCodecContext *VAR_0)
{
VC9Context *v = VAR_0->priv_data;
MpegEncContext *s = &v->s;
GetBitContext gb;
if (!VAR_0->extradata_size || !VAR_0->extradata) return -1;
VAR_0->pix_fmt = PIX_FMT_YUV420P;
v->s.VAR_0 = VAR_0;
if(ff_h263_decode_init(VAR_0) < 0)
return -1;
if (vc9_init_common(v) < 0) return -1;
VAR_0->coded_width = VAR_0->width;
VAR_0->coded_height = VAR_0->height;
if (VAR_0->codec_id == CODEC_ID_WMV3)
{
int VAR_1 = 0;
init_get_bits(&gb, VAR_0->extradata, VAR_0->extradata_size);
decode_sequence_header(VAR_0, &gb);
VAR_1 = VAR_0->extradata_size*8 - get_bits_count(&gb);
if (VAR_1>0)
{
av_log(VAR_0, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
VAR_1, get_bits(&gb, VAR_1));
}
else
{
av_log(VAR_0, AV_LOG_INFO, "Read %i bits in overflow\n", -VAR_1);
}
}
VAR_0->has_b_frames= !!(VAR_0->max_b_frames);
s->mb_width = (VAR_0->coded_width+15)>>4;
s->mb_height = (VAR_0->coded_height+15)>>4;
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
return -1;
v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
if (!v->previous_line_cbpcy) return -1;
#if HAS_ADVANCED_PROFILE
if (v->profile > PROFILE_MAIN)
{
if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
return -1;
if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
return -1;
}
#endif
return 0;
}
|
[
"static int FUNC_0(AVCodecContext *VAR_0)\n{",
"VC9Context *v = VAR_0->priv_data;",
"MpegEncContext *s = &v->s;",
"GetBitContext gb;",
"if (!VAR_0->extradata_size || !VAR_0->extradata) return -1;",
"VAR_0->pix_fmt = PIX_FMT_YUV420P;",
"v->s.VAR_0 = VAR_0;",
"if(ff_h263_decode_init(VAR_0) < 0)\nreturn -1;",
"if (vc9_init_common(v) < 0) return -1;",
"VAR_0->coded_width = VAR_0->width;",
"VAR_0->coded_height = VAR_0->height;",
"if (VAR_0->codec_id == CODEC_ID_WMV3)\n{",
"int VAR_1 = 0;",
"init_get_bits(&gb, VAR_0->extradata, VAR_0->extradata_size);",
"decode_sequence_header(VAR_0, &gb);",
"VAR_1 = VAR_0->extradata_size*8 - get_bits_count(&gb);",
"if (VAR_1>0)\n{",
"av_log(VAR_0, AV_LOG_INFO, \"Extra data: %i bits left, value: %X\\n\",\nVAR_1, get_bits(&gb, VAR_1));",
"}",
"else\n{",
"av_log(VAR_0, AV_LOG_INFO, \"Read %i bits in overflow\\n\", -VAR_1);",
"}",
"}",
"VAR_0->has_b_frames= !!(VAR_0->max_b_frames);",
"s->mb_width = (VAR_0->coded_width+15)>>4;",
"s->mb_height = (VAR_0->coded_height+15)>>4;",
"if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)\nreturn -1;",
"if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)\nreturn -1;",
"if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)\nreturn -1;",
"if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)\nreturn -1;",
"v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);",
"if (!v->previous_line_cbpcy) return -1;",
"#if HAS_ADVANCED_PROFILE\nif (v->profile > PROFILE_MAIN)\n{",
"if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)\nreturn -1;",
"if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)\nreturn -1;",
"}",
"#endif\nreturn 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,
0,
0,
0,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21,
23
],
[
25
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
51
],
[
55
],
[
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
],
[
93,
95
],
[
97,
99
],
[
101,
103
],
[
105,
107
],
[
113
],
[
115
],
[
119,
121,
123
],
[
125,
127
],
[
129,
131
],
[
133
],
[
135,
139
],
[
141
]
] |
8,034 |
yuv2rgb48_2_c_template(SwsContext *c, const int32_t *buf[2],
const int32_t *ubuf[2], const int32_t *vbuf[2],
const int32_t *abuf[2], uint16_t *dest, int dstW,
int yalpha, int uvalpha, int y,
enum PixelFormat target)
{
const int32_t *buf0 = buf[0], *buf1 = buf[1],
*ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
*vbuf0 = vbuf[0], *vbuf1 = vbuf[1];
int yalpha1 = 4095 - yalpha;
int uvalpha1 = 4095 - uvalpha;
int i;
for (i = 0; i < ((dstW + 1) >> 1); i++) {
int Y1 = (buf0[i * 2] * yalpha1 + buf1[i * 2] * yalpha) >> 14;
int Y2 = (buf0[i * 2 + 1] * yalpha1 + buf1[i * 2 + 1] * yalpha) >> 14;
int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha + (-128 << 23)) >> 14;
int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha + (-128 << 23)) >> 14;
int R, G, B;
Y1 -= c->yuv2rgb_y_offset;
Y2 -= c->yuv2rgb_y_offset;
Y1 *= c->yuv2rgb_y_coeff;
Y2 *= c->yuv2rgb_y_coeff;
Y1 += 1 << 13;
Y2 += 1 << 13;
R = V * c->yuv2rgb_v2r_coeff;
G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
B = U * c->yuv2rgb_u2b_coeff;
output_pixel(&dest[0], av_clip_uintp2(R_B + Y1, 30) >> 14);
output_pixel(&dest[1], av_clip_uintp2( G + Y1, 30) >> 14);
output_pixel(&dest[2], av_clip_uintp2(B_R + Y1, 30) >> 14);
output_pixel(&dest[3], av_clip_uintp2(R_B + Y2, 30) >> 14);
output_pixel(&dest[4], av_clip_uintp2( G + Y2, 30) >> 14);
output_pixel(&dest[5], av_clip_uintp2(B_R + Y2, 30) >> 14);
dest += 6;
}
}
| true |
FFmpeg
|
4860625236475da20d0da954017e8c7fe412dea2
|
yuv2rgb48_2_c_template(SwsContext *c, const int32_t *buf[2],
const int32_t *ubuf[2], const int32_t *vbuf[2],
const int32_t *abuf[2], uint16_t *dest, int dstW,
int yalpha, int uvalpha, int y,
enum PixelFormat target)
{
const int32_t *buf0 = buf[0], *buf1 = buf[1],
*ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
*vbuf0 = vbuf[0], *vbuf1 = vbuf[1];
int yalpha1 = 4095 - yalpha;
int uvalpha1 = 4095 - uvalpha;
int i;
for (i = 0; i < ((dstW + 1) >> 1); i++) {
int Y1 = (buf0[i * 2] * yalpha1 + buf1[i * 2] * yalpha) >> 14;
int Y2 = (buf0[i * 2 + 1] * yalpha1 + buf1[i * 2 + 1] * yalpha) >> 14;
int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha + (-128 << 23)) >> 14;
int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha + (-128 << 23)) >> 14;
int R, G, B;
Y1 -= c->yuv2rgb_y_offset;
Y2 -= c->yuv2rgb_y_offset;
Y1 *= c->yuv2rgb_y_coeff;
Y2 *= c->yuv2rgb_y_coeff;
Y1 += 1 << 13;
Y2 += 1 << 13;
R = V * c->yuv2rgb_v2r_coeff;
G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
B = U * c->yuv2rgb_u2b_coeff;
output_pixel(&dest[0], av_clip_uintp2(R_B + Y1, 30) >> 14);
output_pixel(&dest[1], av_clip_uintp2( G + Y1, 30) >> 14);
output_pixel(&dest[2], av_clip_uintp2(B_R + Y1, 30) >> 14);
output_pixel(&dest[3], av_clip_uintp2(R_B + Y2, 30) >> 14);
output_pixel(&dest[4], av_clip_uintp2( G + Y2, 30) >> 14);
output_pixel(&dest[5], av_clip_uintp2(B_R + Y2, 30) >> 14);
dest += 6;
}
}
|
{
"code": [
" int yalpha1 = 4095 - yalpha;",
" int yalpha1 = 4095 - yalpha;",
" int uvalpha1 = 4095 - uvalpha;",
" int yalpha1 = 4095 - yalpha;",
" int uvalpha1 = 4095 - uvalpha;",
" int yalpha1 = 4095 - yalpha;",
" int uvalpha1 = 4095 - uvalpha;"
],
"line_no": [
19,
19,
21,
19,
21,
19,
21
]
}
|
FUNC_0(SwsContext *VAR_0, const int32_t *VAR_1[2],
const int32_t *VAR_2[2], const int32_t *VAR_3[2],
const int32_t *VAR_4[2], uint16_t *VAR_5, int VAR_6,
int VAR_7, int VAR_8, int VAR_9,
enum PixelFormat VAR_10)
{
const int32_t *VAR_11 = VAR_1[0], *buf1 = VAR_1[1],
*ubuf0 = VAR_2[0], *ubuf1 = VAR_2[1],
*vbuf0 = VAR_3[0], *vbuf1 = VAR_3[1];
int VAR_12 = 4095 - VAR_7;
int VAR_13 = 4095 - VAR_8;
int VAR_14;
for (VAR_14 = 0; VAR_14 < ((VAR_6 + 1) >> 1); VAR_14++) {
int VAR_15 = (VAR_11[VAR_14 * 2] * VAR_12 + buf1[VAR_14 * 2] * VAR_7) >> 14;
int VAR_16 = (VAR_11[VAR_14 * 2 + 1] * VAR_12 + buf1[VAR_14 * 2 + 1] * VAR_7) >> 14;
int VAR_17 = (ubuf0[VAR_14] * VAR_13 + ubuf1[VAR_14] * VAR_8 + (-128 << 23)) >> 14;
int VAR_18 = (vbuf0[VAR_14] * VAR_13 + vbuf1[VAR_14] * VAR_8 + (-128 << 23)) >> 14;
int VAR_19, VAR_20, VAR_21;
VAR_15 -= VAR_0->yuv2rgb_y_offset;
VAR_16 -= VAR_0->yuv2rgb_y_offset;
VAR_15 *= VAR_0->yuv2rgb_y_coeff;
VAR_16 *= VAR_0->yuv2rgb_y_coeff;
VAR_15 += 1 << 13;
VAR_16 += 1 << 13;
VAR_19 = VAR_18 * VAR_0->yuv2rgb_v2r_coeff;
VAR_20 = VAR_18 * VAR_0->yuv2rgb_v2g_coeff + VAR_17 * VAR_0->yuv2rgb_u2g_coeff;
VAR_21 = VAR_17 * VAR_0->yuv2rgb_u2b_coeff;
output_pixel(&VAR_5[0], av_clip_uintp2(R_B + VAR_15, 30) >> 14);
output_pixel(&VAR_5[1], av_clip_uintp2( VAR_20 + VAR_15, 30) >> 14);
output_pixel(&VAR_5[2], av_clip_uintp2(B_R + VAR_15, 30) >> 14);
output_pixel(&VAR_5[3], av_clip_uintp2(R_B + VAR_16, 30) >> 14);
output_pixel(&VAR_5[4], av_clip_uintp2( VAR_20 + VAR_16, 30) >> 14);
output_pixel(&VAR_5[5], av_clip_uintp2(B_R + VAR_16, 30) >> 14);
VAR_5 += 6;
}
}
|
[
"FUNC_0(SwsContext *VAR_0, const int32_t *VAR_1[2],\nconst int32_t *VAR_2[2], const int32_t *VAR_3[2],\nconst int32_t *VAR_4[2], uint16_t *VAR_5, int VAR_6,\nint VAR_7, int VAR_8, int VAR_9,\nenum PixelFormat VAR_10)\n{",
"const int32_t *VAR_11 = VAR_1[0], *buf1 = VAR_1[1],\n*ubuf0 = VAR_2[0], *ubuf1 = VAR_2[1],\n*vbuf0 = VAR_3[0], *vbuf1 = VAR_3[1];",
"int VAR_12 = 4095 - VAR_7;",
"int VAR_13 = 4095 - VAR_8;",
"int VAR_14;",
"for (VAR_14 = 0; VAR_14 < ((VAR_6 + 1) >> 1); VAR_14++) {",
"int VAR_15 = (VAR_11[VAR_14 * 2] * VAR_12 + buf1[VAR_14 * 2] * VAR_7) >> 14;",
"int VAR_16 = (VAR_11[VAR_14 * 2 + 1] * VAR_12 + buf1[VAR_14 * 2 + 1] * VAR_7) >> 14;",
"int VAR_17 = (ubuf0[VAR_14] * VAR_13 + ubuf1[VAR_14] * VAR_8 + (-128 << 23)) >> 14;",
"int VAR_18 = (vbuf0[VAR_14] * VAR_13 + vbuf1[VAR_14] * VAR_8 + (-128 << 23)) >> 14;",
"int VAR_19, VAR_20, VAR_21;",
"VAR_15 -= VAR_0->yuv2rgb_y_offset;",
"VAR_16 -= VAR_0->yuv2rgb_y_offset;",
"VAR_15 *= VAR_0->yuv2rgb_y_coeff;",
"VAR_16 *= VAR_0->yuv2rgb_y_coeff;",
"VAR_15 += 1 << 13;",
"VAR_16 += 1 << 13;",
"VAR_19 = VAR_18 * VAR_0->yuv2rgb_v2r_coeff;",
"VAR_20 = VAR_18 * VAR_0->yuv2rgb_v2g_coeff + VAR_17 * VAR_0->yuv2rgb_u2g_coeff;",
"VAR_21 = VAR_17 * VAR_0->yuv2rgb_u2b_coeff;",
"output_pixel(&VAR_5[0], av_clip_uintp2(R_B + VAR_15, 30) >> 14);",
"output_pixel(&VAR_5[1], av_clip_uintp2( VAR_20 + VAR_15, 30) >> 14);",
"output_pixel(&VAR_5[2], av_clip_uintp2(B_R + VAR_15, 30) >> 14);",
"output_pixel(&VAR_5[3], av_clip_uintp2(R_B + VAR_16, 30) >> 14);",
"output_pixel(&VAR_5[4], av_clip_uintp2( VAR_20 + VAR_16, 30) >> 14);",
"output_pixel(&VAR_5[5], av_clip_uintp2(B_R + VAR_16, 30) >> 14);",
"VAR_5 += 6;",
"}",
"}"
] |
[
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
] |
[
[
1,
3,
5,
7,
9,
11
],
[
13,
15,
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
]
] |
8,035 |
void memory_region_init_alias(MemoryRegion *mr,
Object *owner,
const char *name,
MemoryRegion *orig,
hwaddr offset,
uint64_t size)
{
memory_region_init(mr, owner, name, size);
memory_region_ref(orig);
mr->destructor = memory_region_destructor_alias;
mr->alias = orig;
mr->alias_offset = offset;
}
| true |
qemu
|
52c91dac6bd891656f297dab76da51fc8bc61309
|
void memory_region_init_alias(MemoryRegion *mr,
Object *owner,
const char *name,
MemoryRegion *orig,
hwaddr offset,
uint64_t size)
{
memory_region_init(mr, owner, name, size);
memory_region_ref(orig);
mr->destructor = memory_region_destructor_alias;
mr->alias = orig;
mr->alias_offset = offset;
}
|
{
"code": [
" memory_region_ref(orig);",
" mr->destructor = memory_region_destructor_alias;"
],
"line_no": [
17,
19
]
}
|
void FUNC_0(MemoryRegion *VAR_0,
Object *VAR_1,
const char *VAR_2,
MemoryRegion *VAR_3,
hwaddr VAR_4,
uint64_t VAR_5)
{
memory_region_init(VAR_0, VAR_1, VAR_2, VAR_5);
memory_region_ref(VAR_3);
VAR_0->destructor = memory_region_destructor_alias;
VAR_0->alias = VAR_3;
VAR_0->alias_offset = VAR_4;
}
|
[
"void FUNC_0(MemoryRegion *VAR_0,\nObject *VAR_1,\nconst char *VAR_2,\nMemoryRegion *VAR_3,\nhwaddr VAR_4,\nuint64_t VAR_5)\n{",
"memory_region_init(VAR_0, VAR_1, VAR_2, VAR_5);",
"memory_region_ref(VAR_3);",
"VAR_0->destructor = memory_region_destructor_alias;",
"VAR_0->alias = VAR_3;",
"VAR_0->alias_offset = VAR_4;",
"}"
] |
[
0,
0,
1,
1,
0,
0,
0
] |
[
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
]
] |
8,036 |
static void monitor_protocol_event_handler(void *opaque)
{
MonitorEventState *evstate = opaque;
int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
qemu_mutex_lock(&monitor_event_state_lock);
trace_monitor_protocol_event_handler(evstate->event,
evstate->data,
evstate->last,
now);
if (evstate->data) {
monitor_protocol_event_emit(evstate->event, evstate->data);
qobject_decref(evstate->data);
evstate->data = NULL;
}
evstate->last = now;
qemu_mutex_unlock(&monitor_event_state_lock);
}
| true |
qemu
|
c20b7fa4b2fedd979bcb0cc974bb5d08a10e3448
|
static void monitor_protocol_event_handler(void *opaque)
{
MonitorEventState *evstate = opaque;
int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
qemu_mutex_lock(&monitor_event_state_lock);
trace_monitor_protocol_event_handler(evstate->event,
evstate->data,
evstate->last,
now);
if (evstate->data) {
monitor_protocol_event_emit(evstate->event, evstate->data);
qobject_decref(evstate->data);
evstate->data = NULL;
}
evstate->last = now;
qemu_mutex_unlock(&monitor_event_state_lock);
}
|
{
"code": [
" qemu_mutex_lock(&monitor_event_state_lock);",
" qemu_mutex_unlock(&monitor_event_state_lock);",
" qemu_mutex_lock(&monitor_event_state_lock);",
" qemu_mutex_unlock(&monitor_event_state_lock);"
],
"line_no": [
11,
35,
11,
35
]
}
|
static void FUNC_0(void *VAR_0)
{
MonitorEventState *evstate = VAR_0;
int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
qemu_mutex_lock(&monitor_event_state_lock);
trace_monitor_protocol_event_handler(evstate->event,
evstate->data,
evstate->last,
now);
if (evstate->data) {
monitor_protocol_event_emit(evstate->event, evstate->data);
qobject_decref(evstate->data);
evstate->data = NULL;
}
evstate->last = now;
qemu_mutex_unlock(&monitor_event_state_lock);
}
|
[
"static void FUNC_0(void *VAR_0)\n{",
"MonitorEventState *evstate = VAR_0;",
"int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);",
"qemu_mutex_lock(&monitor_event_state_lock);",
"trace_monitor_protocol_event_handler(evstate->event,\nevstate->data,\nevstate->last,\nnow);",
"if (evstate->data) {",
"monitor_protocol_event_emit(evstate->event, evstate->data);",
"qobject_decref(evstate->data);",
"evstate->data = NULL;",
"}",
"evstate->last = now;",
"qemu_mutex_unlock(&monitor_event_state_lock);",
"}"
] |
[
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15,
17,
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
]
] |
8,037 |
static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
int64_t offset, int count)
{
int ret;
BDRVQcow2State *s = bs->opaque;
if (!QEMU_IS_ALIGNED(offset | count, s->cluster_size)) {
assert(count < s->cluster_size);
return -ENOTSUP;
}
qemu_co_mutex_lock(&s->lock);
ret = qcow2_discard_clusters(bs, offset, count >> BDRV_SECTOR_BITS,
QCOW2_DISCARD_REQUEST, false);
qemu_co_mutex_unlock(&s->lock);
return ret;
}
| true |
qemu
|
048c5fd1bfc787adcb1b726ce997e87fe44545fd
|
static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
int64_t offset, int count)
{
int ret;
BDRVQcow2State *s = bs->opaque;
if (!QEMU_IS_ALIGNED(offset | count, s->cluster_size)) {
assert(count < s->cluster_size);
return -ENOTSUP;
}
qemu_co_mutex_lock(&s->lock);
ret = qcow2_discard_clusters(bs, offset, count >> BDRV_SECTOR_BITS,
QCOW2_DISCARD_REQUEST, false);
qemu_co_mutex_unlock(&s->lock);
return ret;
}
|
{
"code": [
" return -ENOTSUP;"
],
"line_no": [
17
]
}
|
static coroutine_fn int FUNC_0(BlockDriverState *bs,
int64_t offset, int count)
{
int VAR_0;
BDRVQcow2State *s = bs->opaque;
if (!QEMU_IS_ALIGNED(offset | count, s->cluster_size)) {
assert(count < s->cluster_size);
return -ENOTSUP;
}
qemu_co_mutex_lock(&s->lock);
VAR_0 = qcow2_discard_clusters(bs, offset, count >> BDRV_SECTOR_BITS,
QCOW2_DISCARD_REQUEST, false);
qemu_co_mutex_unlock(&s->lock);
return VAR_0;
}
|
[
"static coroutine_fn int FUNC_0(BlockDriverState *bs,\nint64_t offset, int count)\n{",
"int VAR_0;",
"BDRVQcow2State *s = bs->opaque;",
"if (!QEMU_IS_ALIGNED(offset | count, s->cluster_size)) {",
"assert(count < s->cluster_size);",
"return -ENOTSUP;",
"}",
"qemu_co_mutex_lock(&s->lock);",
"VAR_0 = qcow2_discard_clusters(bs, offset, count >> BDRV_SECTOR_BITS,\nQCOW2_DISCARD_REQUEST, false);",
"qemu_co_mutex_unlock(&s->lock);",
"return VAR_0;",
"}"
] |
[
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
]
] |
8,038 |
void stb_tce(VIOsPAPRDevice *dev, uint64_t taddr, uint8_t val)
{
spapr_tce_dma_write(dev, taddr, &val, sizeof(val));
}
| true |
qemu
|
ad0ebb91cd8b5fdc4a583b03645677771f420a46
|
void stb_tce(VIOsPAPRDevice *dev, uint64_t taddr, uint8_t val)
{
spapr_tce_dma_write(dev, taddr, &val, sizeof(val));
}
|
{
"code": [
"void stb_tce(VIOsPAPRDevice *dev, uint64_t taddr, uint8_t val)",
" spapr_tce_dma_write(dev, taddr, &val, sizeof(val));",
" spapr_tce_dma_write(dev, taddr, &val, sizeof(val));",
" spapr_tce_dma_write(dev, taddr, &val, sizeof(val));",
" spapr_tce_dma_write(dev, taddr, &val, sizeof(val));"
],
"line_no": [
1,
5,
5,
5,
5
]
}
|
void FUNC_0(VIOsPAPRDevice *VAR_0, uint64_t VAR_1, uint8_t VAR_2)
{
spapr_tce_dma_write(VAR_0, VAR_1, &VAR_2, sizeof(VAR_2));
}
|
[
"void FUNC_0(VIOsPAPRDevice *VAR_0, uint64_t VAR_1, uint8_t VAR_2)\n{",
"spapr_tce_dma_write(VAR_0, VAR_1, &VAR_2, sizeof(VAR_2));",
"}"
] |
[
1,
1,
0
] |
[
[
1,
3
],
[
5
],
[
7
]
] |
8,039 |
static void to_meta_with_crop(AVCodecContext *avctx, AVFrame *p, int *dest)
{
int blockx, blocky, x, y;
int luma = 0;
int height = FFMIN(avctx->height, C64YRES);
int width = FFMIN(avctx->width , C64XRES);
uint8_t *src = p->data[0];
for (blocky = 0; blocky < C64YRES; blocky += 8) {
for (blockx = 0; blockx < C64XRES; blockx += 8) {
for (y = blocky; y < blocky + 8 && y < C64YRES; y++) {
for (x = blockx; x < blockx + 8 && x < C64XRES; x += 2) {
if(x < width && y < height) {
/* build average over 2 pixels */
luma = (src[(x + 0 + y * p->linesize[0])] +
src[(x + 1 + y * p->linesize[0])]) / 2;
/* write blocks as linear data now so they are suitable for elbg */
dest[0] = luma;
}
dest++;
}
}
}
}
}
| true |
FFmpeg
|
87513d654546a99f8ddb045ca4fa5d33778a617e
|
static void to_meta_with_crop(AVCodecContext *avctx, AVFrame *p, int *dest)
{
int blockx, blocky, x, y;
int luma = 0;
int height = FFMIN(avctx->height, C64YRES);
int width = FFMIN(avctx->width , C64XRES);
uint8_t *src = p->data[0];
for (blocky = 0; blocky < C64YRES; blocky += 8) {
for (blockx = 0; blockx < C64XRES; blockx += 8) {
for (y = blocky; y < blocky + 8 && y < C64YRES; y++) {
for (x = blockx; x < blockx + 8 && x < C64XRES; x += 2) {
if(x < width && y < height) {
luma = (src[(x + 0 + y * p->linesize[0])] +
src[(x + 1 + y * p->linesize[0])]) / 2;
dest[0] = luma;
}
dest++;
}
}
}
}
}
|
{
"code": [
" luma = (src[(x + 0 + y * p->linesize[0])] +",
" src[(x + 1 + y * p->linesize[0])]) / 2;"
],
"line_no": [
29,
31
]
}
|
static void FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1, int *VAR_2)
{
int VAR_3, VAR_4, VAR_5, VAR_6;
int VAR_7 = 0;
int VAR_8 = FFMIN(VAR_0->VAR_8, C64YRES);
int VAR_9 = FFMIN(VAR_0->VAR_9 , C64XRES);
uint8_t *src = VAR_1->data[0];
for (VAR_4 = 0; VAR_4 < C64YRES; VAR_4 += 8) {
for (VAR_3 = 0; VAR_3 < C64XRES; VAR_3 += 8) {
for (VAR_6 = VAR_4; VAR_6 < VAR_4 + 8 && VAR_6 < C64YRES; VAR_6++) {
for (VAR_5 = VAR_3; VAR_5 < VAR_3 + 8 && VAR_5 < C64XRES; VAR_5 += 2) {
if(VAR_5 < VAR_9 && VAR_6 < VAR_8) {
VAR_7 = (src[(VAR_5 + 0 + VAR_6 * VAR_1->linesize[0])] +
src[(VAR_5 + 1 + VAR_6 * VAR_1->linesize[0])]) / 2;
VAR_2[0] = VAR_7;
}
VAR_2++;
}
}
}
}
}
|
[
"static void FUNC_0(AVCodecContext *VAR_0, AVFrame *VAR_1, int *VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5, VAR_6;",
"int VAR_7 = 0;",
"int VAR_8 = FFMIN(VAR_0->VAR_8, C64YRES);",
"int VAR_9 = FFMIN(VAR_0->VAR_9 , C64XRES);",
"uint8_t *src = VAR_1->data[0];",
"for (VAR_4 = 0; VAR_4 < C64YRES; VAR_4 += 8) {",
"for (VAR_3 = 0; VAR_3 < C64XRES; VAR_3 += 8) {",
"for (VAR_6 = VAR_4; VAR_6 < VAR_4 + 8 && VAR_6 < C64YRES; VAR_6++) {",
"for (VAR_5 = VAR_3; VAR_5 < VAR_3 + 8 && VAR_5 < C64XRES; VAR_5 += 2) {",
"if(VAR_5 < VAR_9 && VAR_6 < VAR_8) {",
"VAR_7 = (src[(VAR_5 + 0 + VAR_6 * VAR_1->linesize[0])] +\nsrc[(VAR_5 + 1 + VAR_6 * VAR_1->linesize[0])]) / 2;",
"VAR_2[0] = VAR_7;",
"}",
"VAR_2++;",
"}",
"}",
"}",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29,
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
]
] |
8,040 |
static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
{
KLVPacket klv;
MXFContext *mxf = s->priv_data;
int ret;
while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
PRINT_KEY(s, "read packet", klv.key);
av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
ret = mxf_decrypt_triplet(s, pkt, &klv);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
return ret;
}
return 0;
}
if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
int index = mxf_get_stream_index(s, &klv);
int64_t next_ofs, next_klv;
AVStream *st;
MXFTrack *track;
AVCodecParameters *par;
if (index < 0) {
av_log(s, AV_LOG_ERROR,
"error getting stream index %"PRIu32"\n",
AV_RB32(klv.key + 12));
goto skip;
}
st = s->streams[index];
track = st->priv_data;
if (s->streams[index]->discard == AVDISCARD_ALL)
goto skip;
next_klv = avio_tell(s->pb) + klv.length;
next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
if (next_ofs >= 0 && next_klv > next_ofs) {
/* if this check is hit then it's possible OPAtom was treated as OP1a
* truncate the packet since it's probably very large (>2 GiB is common) */
avpriv_request_sample(s,
"OPAtom misinterpreted as OP1a? "
"KLV for edit unit %i extending into "
"next edit unit",
mxf->current_edit_unit);
klv.length = next_ofs - avio_tell(s->pb);
}
/* check for 8 channels AES3 element */
if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
pkt, klv.length);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
return ret;
}
} else {
ret = av_get_packet(s->pb, pkt, klv.length);
if (ret < 0)
return ret;
}
pkt->stream_index = index;
pkt->pos = klv.offset;
par = st->codecpar;
if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
/* mxf->current_edit_unit good - see if we have an
* index table to derive timestamps from */
MXFIndexTable *t = &mxf->index_tables[0];
if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
pkt->dts = mxf->current_edit_unit + t->first_dts;
pkt->pts = t->ptses[mxf->current_edit_unit];
} else if (track->intra_only) {
/* intra-only -> PTS = EditUnit.
* let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
pkt->pts = mxf->current_edit_unit;
}
} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
ret = mxf_set_audio_pts(mxf, par, pkt);
if (ret < 0)
return ret;
}
/* seek for truncated packets */
avio_seek(s->pb, next_klv, SEEK_SET);
return 0;
} else
skip:
avio_skip(s->pb, klv.length);
}
return avio_feof(s->pb) ? AVERROR_EOF : ret;
}
| true |
FFmpeg
|
fdb8c455b637f86e2e85503b7e090fa448164398
|
static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
{
KLVPacket klv;
MXFContext *mxf = s->priv_data;
int ret;
while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
PRINT_KEY(s, "read packet", klv.key);
av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
ret = mxf_decrypt_triplet(s, pkt, &klv);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
return ret;
}
return 0;
}
if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
int index = mxf_get_stream_index(s, &klv);
int64_t next_ofs, next_klv;
AVStream *st;
MXFTrack *track;
AVCodecParameters *par;
if (index < 0) {
av_log(s, AV_LOG_ERROR,
"error getting stream index %"PRIu32"\n",
AV_RB32(klv.key + 12));
goto skip;
}
st = s->streams[index];
track = st->priv_data;
if (s->streams[index]->discard == AVDISCARD_ALL)
goto skip;
next_klv = avio_tell(s->pb) + klv.length;
next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
if (next_ofs >= 0 && next_klv > next_ofs) {
avpriv_request_sample(s,
"OPAtom misinterpreted as OP1a? "
"KLV for edit unit %i extending into "
"next edit unit",
mxf->current_edit_unit);
klv.length = next_ofs - avio_tell(s->pb);
}
if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
pkt, klv.length);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
return ret;
}
} else {
ret = av_get_packet(s->pb, pkt, klv.length);
if (ret < 0)
return ret;
}
pkt->stream_index = index;
pkt->pos = klv.offset;
par = st->codecpar;
if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
MXFIndexTable *t = &mxf->index_tables[0];
if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
pkt->dts = mxf->current_edit_unit + t->first_dts;
pkt->pts = t->ptses[mxf->current_edit_unit];
} else if (track->intra_only) {
pkt->pts = mxf->current_edit_unit;
}
} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
ret = mxf_set_audio_pts(mxf, par, pkt);
if (ret < 0)
return ret;
}
avio_seek(s->pb, next_klv, SEEK_SET);
return 0;
} else
skip:
avio_skip(s->pb, klv.length);
}
return avio_feof(s->pb) ? AVERROR_EOF : ret;
}
|
{
"code": [
" } else if (track->intra_only) {"
],
"line_no": [
159
]
}
|
static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
KLVPacket klv;
MXFContext *mxf = VAR_0->priv_data;
int VAR_2;
while ((VAR_2 = klv_read_packet(&klv, VAR_0->pb)) == 0) {
PRINT_KEY(VAR_0, "read packet", klv.key);
av_log(VAR_0, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
VAR_2 = mxf_decrypt_triplet(VAR_0, VAR_1, &klv);
if (VAR_2 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "invalid encoded triplet\n");
return VAR_2;
}
return 0;
}
if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
int VAR_3 = mxf_get_stream_index(VAR_0, &klv);
int64_t next_ofs, next_klv;
AVStream *st;
MXFTrack *track;
AVCodecParameters *par;
if (VAR_3 < 0) {
av_log(VAR_0, AV_LOG_ERROR,
"error getting stream VAR_3 %"PRIu32"\n",
AV_RB32(klv.key + 12));
goto skip;
}
st = VAR_0->streams[VAR_3];
track = st->priv_data;
if (VAR_0->streams[VAR_3]->discard == AVDISCARD_ALL)
goto skip;
next_klv = avio_tell(VAR_0->pb) + klv.length;
next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
if (next_ofs >= 0 && next_klv > next_ofs) {
avpriv_request_sample(VAR_0,
"OPAtom misinterpreted as OP1a? "
"KLV for edit unit %i extending into "
"next edit unit",
mxf->current_edit_unit);
klv.length = next_ofs - avio_tell(VAR_0->pb);
}
if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
VAR_2 = mxf_get_d10_aes3_packet(VAR_0->pb, VAR_0->streams[VAR_3],
VAR_1, klv.length);
if (VAR_2 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
return VAR_2;
}
} else {
VAR_2 = av_get_packet(VAR_0->pb, VAR_1, klv.length);
if (VAR_2 < 0)
return VAR_2;
}
VAR_1->stream_index = VAR_3;
VAR_1->pos = klv.offset;
par = st->codecpar;
if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
MXFIndexTable *t = &mxf->index_tables[0];
if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
VAR_1->dts = mxf->current_edit_unit + t->first_dts;
VAR_1->pts = t->ptses[mxf->current_edit_unit];
} else if (track->intra_only) {
VAR_1->pts = mxf->current_edit_unit;
}
} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
VAR_2 = mxf_set_audio_pts(mxf, par, VAR_1);
if (VAR_2 < 0)
return VAR_2;
}
avio_seek(VAR_0->pb, next_klv, SEEK_SET);
return 0;
} else
skip:
avio_skip(VAR_0->pb, klv.length);
}
return avio_feof(VAR_0->pb) ? AVERROR_EOF : VAR_2;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"KLVPacket klv;",
"MXFContext *mxf = VAR_0->priv_data;",
"int VAR_2;",
"while ((VAR_2 = klv_read_packet(&klv, VAR_0->pb)) == 0) {",
"PRINT_KEY(VAR_0, \"read packet\", klv.key);",
"av_log(VAR_0, AV_LOG_TRACE, \"size %\"PRIu64\" offset %#\"PRIx64\"\\n\", klv.length, klv.offset);",
"if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {",
"VAR_2 = mxf_decrypt_triplet(VAR_0, VAR_1, &klv);",
"if (VAR_2 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"invalid encoded triplet\\n\");",
"return VAR_2;",
"}",
"return 0;",
"}",
"if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||\nIS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||\nIS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {",
"int VAR_3 = mxf_get_stream_index(VAR_0, &klv);",
"int64_t next_ofs, next_klv;",
"AVStream *st;",
"MXFTrack *track;",
"AVCodecParameters *par;",
"if (VAR_3 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR,\n\"error getting stream VAR_3 %\"PRIu32\"\\n\",\nAV_RB32(klv.key + 12));",
"goto skip;",
"}",
"st = VAR_0->streams[VAR_3];",
"track = st->priv_data;",
"if (VAR_0->streams[VAR_3]->discard == AVDISCARD_ALL)\ngoto skip;",
"next_klv = avio_tell(VAR_0->pb) + klv.length;",
"next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);",
"if (next_ofs >= 0 && next_klv > next_ofs) {",
"avpriv_request_sample(VAR_0,\n\"OPAtom misinterpreted as OP1a? \"\n\"KLV for edit unit %i extending into \"\n\"next edit unit\",\nmxf->current_edit_unit);",
"klv.length = next_ofs - avio_tell(VAR_0->pb);",
"}",
"if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {",
"VAR_2 = mxf_get_d10_aes3_packet(VAR_0->pb, VAR_0->streams[VAR_3],\nVAR_1, klv.length);",
"if (VAR_2 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error reading D-10 aes3 frame\\n\");",
"return VAR_2;",
"}",
"} else {",
"VAR_2 = av_get_packet(VAR_0->pb, VAR_1, klv.length);",
"if (VAR_2 < 0)\nreturn VAR_2;",
"}",
"VAR_1->stream_index = VAR_3;",
"VAR_1->pos = klv.offset;",
"par = st->codecpar;",
"if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {",
"MXFIndexTable *t = &mxf->index_tables[0];",
"if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {",
"VAR_1->dts = mxf->current_edit_unit + t->first_dts;",
"VAR_1->pts = t->ptses[mxf->current_edit_unit];",
"} else if (track->intra_only) {",
"VAR_1->pts = mxf->current_edit_unit;",
"}",
"} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {",
"VAR_2 = mxf_set_audio_pts(mxf, par, VAR_1);",
"if (VAR_2 < 0)\nreturn VAR_2;",
"}",
"avio_seek(VAR_0->pb, next_klv, SEEK_SET);",
"return 0;",
"} else",
"skip:\navio_skip(VAR_0->pb, klv.length);",
"}",
"return avio_feof(VAR_0->pb) ? AVERROR_EOF : VAR_2;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35,
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55,
57,
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
73,
75
],
[
79
],
[
81
],
[
85
],
[
91,
93,
95,
97,
99
],
[
101
],
[
103
],
[
109
],
[
111,
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127,
129
],
[
131
],
[
133
],
[
135
],
[
139
],
[
143
],
[
149
],
[
153
],
[
155
],
[
157
],
[
159
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173,
175
],
[
177
],
[
183
],
[
187
],
[
189
],
[
191,
193
],
[
195
],
[
197
],
[
199
]
] |
8,041 |
static int vorbis_floor1_decode(vorbis_context *vc,
vorbis_floor_data *vfu, float *vec)
{
vorbis_floor1 *vf = &vfu->t1;
GetBitContext *gb = &vc->gb;
uint16_t range_v[4] = { 256, 128, 86, 64 };
unsigned range = range_v[vf->multiplier - 1];
uint16_t floor1_Y[258];
uint16_t floor1_Y_final[258];
int floor1_flag[258];
unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;
int book, adx, ady, dy, off, predicted, err;
if (!get_bits1(gb)) // silence
return 1;
// Read values (or differences) for the floor's points
floor1_Y[0] = get_bits(gb, ilog(range - 1));
floor1_Y[1] = get_bits(gb, ilog(range - 1));
av_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
offset = 2;
for (i = 0; i < vf->partitions; ++i) {
partition_class = vf->partition_class[i];
cdim = vf->class_dimensions[partition_class];
cbits = vf->class_subclasses[partition_class];
csub = (1 << cbits) - 1;
cval = 0;
av_dlog(NULL, "Cbits %u\n", cbits);
if (cbits) // this reads all subclasses for this partition's class
cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
for (j = 0; j < cdim; ++j) {
book = vf->subclass_books[partition_class][cval & csub];
av_dlog(NULL, "book %d Cbits %u cval %u bits:%d\n",
book, cbits, cval, get_bits_count(gb));
cval = cval >> cbits;
if (book > -1) {
floor1_Y[offset+j] = get_vlc2(gb, vc->codebooks[book].vlc.table,
vc->codebooks[book].nb_bits, 3);
} else {
floor1_Y[offset+j] = 0;
}
av_dlog(NULL, " floor(%d) = %d \n",
vf->list[offset+j].x, floor1_Y[offset+j]);
}
offset+=cdim;
}
// Amplitude calculation from the differences
floor1_flag[0] = 1;
floor1_flag[1] = 1;
floor1_Y_final[0] = floor1_Y[0];
floor1_Y_final[1] = floor1_Y[1];
for (i = 2; i < vf->x_list_dim; ++i) {
unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
low_neigh_offs = vf->list[i].low;
high_neigh_offs = vf->list[i].high;
dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs]; // render_point begin
adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
ady = FFABS(dy);
err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
off = err / adx;
if (dy < 0) {
predicted = floor1_Y_final[low_neigh_offs] - off;
} else {
predicted = floor1_Y_final[low_neigh_offs] + off;
} // render_point end
val = floor1_Y[i];
highroom = range-predicted;
lowroom = predicted;
if (highroom < lowroom) {
room = highroom * 2;
} else {
room = lowroom * 2; // SPEC misspelling
}
if (val) {
floor1_flag[low_neigh_offs] = 1;
floor1_flag[high_neigh_offs] = 1;
floor1_flag[i] = 1;
if (val >= room) {
if (highroom > lowroom) {
floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);
} else {
floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);
}
} else {
if (val & 1) {
floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);
} else {
floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);
}
}
} else {
floor1_flag[i] = 0;
floor1_Y_final[i] = av_clip_uint16(predicted);
}
av_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
vf->list[i].x, floor1_Y_final[i], val);
}
// Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
av_dlog(NULL, " Floor decoded\n");
return 0;
}
| false |
FFmpeg
|
709cae2bcbc0ea2c5d46c932b3d8301cf8f98e6b
|
static int vorbis_floor1_decode(vorbis_context *vc,
vorbis_floor_data *vfu, float *vec)
{
vorbis_floor1 *vf = &vfu->t1;
GetBitContext *gb = &vc->gb;
uint16_t range_v[4] = { 256, 128, 86, 64 };
unsigned range = range_v[vf->multiplier - 1];
uint16_t floor1_Y[258];
uint16_t floor1_Y_final[258];
int floor1_flag[258];
unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;
int book, adx, ady, dy, off, predicted, err;
if (!get_bits1(gb))
return 1;
floor1_Y[0] = get_bits(gb, ilog(range - 1));
floor1_Y[1] = get_bits(gb, ilog(range - 1));
av_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
offset = 2;
for (i = 0; i < vf->partitions; ++i) {
partition_class = vf->partition_class[i];
cdim = vf->class_dimensions[partition_class];
cbits = vf->class_subclasses[partition_class];
csub = (1 << cbits) - 1;
cval = 0;
av_dlog(NULL, "Cbits %u\n", cbits);
if (cbits)
cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
for (j = 0; j < cdim; ++j) {
book = vf->subclass_books[partition_class][cval & csub];
av_dlog(NULL, "book %d Cbits %u cval %u bits:%d\n",
book, cbits, cval, get_bits_count(gb));
cval = cval >> cbits;
if (book > -1) {
floor1_Y[offset+j] = get_vlc2(gb, vc->codebooks[book].vlc.table,
vc->codebooks[book].nb_bits, 3);
} else {
floor1_Y[offset+j] = 0;
}
av_dlog(NULL, " floor(%d) = %d \n",
vf->list[offset+j].x, floor1_Y[offset+j]);
}
offset+=cdim;
}
floor1_flag[0] = 1;
floor1_flag[1] = 1;
floor1_Y_final[0] = floor1_Y[0];
floor1_Y_final[1] = floor1_Y[1];
for (i = 2; i < vf->x_list_dim; ++i) {
unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
low_neigh_offs = vf->list[i].low;
high_neigh_offs = vf->list[i].high;
dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs];
adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
ady = FFABS(dy);
err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
off = err / adx;
if (dy < 0) {
predicted = floor1_Y_final[low_neigh_offs] - off;
} else {
predicted = floor1_Y_final[low_neigh_offs] + off;
}
val = floor1_Y[i];
highroom = range-predicted;
lowroom = predicted;
if (highroom < lowroom) {
room = highroom * 2;
} else {
room = lowroom * 2;
}
if (val) {
floor1_flag[low_neigh_offs] = 1;
floor1_flag[high_neigh_offs] = 1;
floor1_flag[i] = 1;
if (val >= room) {
if (highroom > lowroom) {
floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);
} else {
floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);
}
} else {
if (val & 1) {
floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);
} else {
floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);
}
}
} else {
floor1_flag[i] = 0;
floor1_Y_final[i] = av_clip_uint16(predicted);
}
av_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
vf->list[i].x, floor1_Y_final[i], val);
}
ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
av_dlog(NULL, " Floor decoded\n");
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(vorbis_context *VAR_0,
vorbis_floor_data *VAR_1, float *VAR_2)
{
vorbis_floor1 *vf = &VAR_1->t1;
GetBitContext *gb = &VAR_0->gb;
uint16_t range_v[4] = { 256, 128, 86, 64 };
unsigned VAR_3 = range_v[vf->multiplier - 1];
uint16_t floor1_Y[258];
uint16_t floor1_Y_final[258];
int VAR_4[258];
unsigned VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;
int VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18, VAR_19;
if (!get_bits1(gb))
return 1;
floor1_Y[0] = get_bits(gb, ilog(VAR_3 - 1));
floor1_Y[1] = get_bits(gb, ilog(VAR_3 - 1));
av_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
VAR_10 = 2;
for (VAR_11 = 0; VAR_11 < vf->partitions; ++VAR_11) {
VAR_5 = vf->VAR_5[VAR_11];
VAR_6 = vf->class_dimensions[VAR_5];
VAR_7 = vf->class_subclasses[VAR_5];
VAR_8 = (1 << VAR_7) - 1;
VAR_9 = 0;
av_dlog(NULL, "Cbits %u\n", VAR_7);
if (VAR_7)
VAR_9 = get_vlc2(gb, VAR_0->codebooks[vf->class_masterbook[VAR_5]].vlc.table,
VAR_0->codebooks[vf->class_masterbook[VAR_5]].nb_bits, 3);
for (VAR_12 = 0; VAR_12 < VAR_6; ++VAR_12) {
VAR_13 = vf->subclass_books[VAR_5][VAR_9 & VAR_8];
av_dlog(NULL, "VAR_13 %d Cbits %u VAR_9 %u bits:%d\n",
VAR_13, VAR_7, VAR_9, get_bits_count(gb));
VAR_9 = VAR_9 >> VAR_7;
if (VAR_13 > -1) {
floor1_Y[VAR_10+VAR_12] = get_vlc2(gb, VAR_0->codebooks[VAR_13].vlc.table,
VAR_0->codebooks[VAR_13].nb_bits, 3);
} else {
floor1_Y[VAR_10+VAR_12] = 0;
}
av_dlog(NULL, " floor(%d) = %d \n",
vf->list[VAR_10+VAR_12].x, floor1_Y[VAR_10+VAR_12]);
}
VAR_10+=VAR_6;
}
VAR_4[0] = 1;
VAR_4[1] = 1;
floor1_Y_final[0] = floor1_Y[0];
floor1_Y_final[1] = floor1_Y[1];
for (VAR_11 = 2; VAR_11 < vf->x_list_dim; ++VAR_11) {
unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
low_neigh_offs = vf->list[VAR_11].low;
high_neigh_offs = vf->list[VAR_11].high;
VAR_16 = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs];
VAR_14 = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
VAR_15 = FFABS(VAR_16);
VAR_19 = VAR_15 * (vf->list[VAR_11].x - vf->list[low_neigh_offs].x);
VAR_17 = VAR_19 / VAR_14;
if (VAR_16 < 0) {
VAR_18 = floor1_Y_final[low_neigh_offs] - VAR_17;
} else {
VAR_18 = floor1_Y_final[low_neigh_offs] + VAR_17;
}
val = floor1_Y[VAR_11];
highroom = VAR_3-VAR_18;
lowroom = VAR_18;
if (highroom < lowroom) {
room = highroom * 2;
} else {
room = lowroom * 2;
}
if (val) {
VAR_4[low_neigh_offs] = 1;
VAR_4[high_neigh_offs] = 1;
VAR_4[VAR_11] = 1;
if (val >= room) {
if (highroom > lowroom) {
floor1_Y_final[VAR_11] = av_clip_uint16(val - lowroom + VAR_18);
} else {
floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18 - val + highroom - 1);
}
} else {
if (val & 1) {
floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18 - (val + 1) / 2);
} else {
floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18 + val / 2);
}
}
} else {
VAR_4[VAR_11] = 0;
floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18);
}
av_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
vf->list[VAR_11].x, floor1_Y_final[VAR_11], val);
}
ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, VAR_4, vf->multiplier, VAR_2, vf->list[1].x);
av_dlog(NULL, " Floor decoded\n");
return 0;
}
|
[
"static int FUNC_0(vorbis_context *VAR_0,\nvorbis_floor_data *VAR_1, float *VAR_2)\n{",
"vorbis_floor1 *vf = &VAR_1->t1;",
"GetBitContext *gb = &VAR_0->gb;",
"uint16_t range_v[4] = { 256, 128, 86, 64 };",
"unsigned VAR_3 = range_v[vf->multiplier - 1];",
"uint16_t floor1_Y[258];",
"uint16_t floor1_Y_final[258];",
"int VAR_4[258];",
"unsigned VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;",
"int VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18, VAR_19;",
"if (!get_bits1(gb))\nreturn 1;",
"floor1_Y[0] = get_bits(gb, ilog(VAR_3 - 1));",
"floor1_Y[1] = get_bits(gb, ilog(VAR_3 - 1));",
"av_dlog(NULL, \"floor 0 Y %d floor 1 Y %d \\n\", floor1_Y[0], floor1_Y[1]);",
"VAR_10 = 2;",
"for (VAR_11 = 0; VAR_11 < vf->partitions; ++VAR_11) {",
"VAR_5 = vf->VAR_5[VAR_11];",
"VAR_6 = vf->class_dimensions[VAR_5];",
"VAR_7 = vf->class_subclasses[VAR_5];",
"VAR_8 = (1 << VAR_7) - 1;",
"VAR_9 = 0;",
"av_dlog(NULL, \"Cbits %u\\n\", VAR_7);",
"if (VAR_7)\nVAR_9 = get_vlc2(gb, VAR_0->codebooks[vf->class_masterbook[VAR_5]].vlc.table,\nVAR_0->codebooks[vf->class_masterbook[VAR_5]].nb_bits, 3);",
"for (VAR_12 = 0; VAR_12 < VAR_6; ++VAR_12) {",
"VAR_13 = vf->subclass_books[VAR_5][VAR_9 & VAR_8];",
"av_dlog(NULL, \"VAR_13 %d Cbits %u VAR_9 %u bits:%d\\n\",\nVAR_13, VAR_7, VAR_9, get_bits_count(gb));",
"VAR_9 = VAR_9 >> VAR_7;",
"if (VAR_13 > -1) {",
"floor1_Y[VAR_10+VAR_12] = get_vlc2(gb, VAR_0->codebooks[VAR_13].vlc.table,\nVAR_0->codebooks[VAR_13].nb_bits, 3);",
"} else {",
"floor1_Y[VAR_10+VAR_12] = 0;",
"}",
"av_dlog(NULL, \" floor(%d) = %d \\n\",\nvf->list[VAR_10+VAR_12].x, floor1_Y[VAR_10+VAR_12]);",
"}",
"VAR_10+=VAR_6;",
"}",
"VAR_4[0] = 1;",
"VAR_4[1] = 1;",
"floor1_Y_final[0] = floor1_Y[0];",
"floor1_Y_final[1] = floor1_Y[1];",
"for (VAR_11 = 2; VAR_11 < vf->x_list_dim; ++VAR_11) {",
"unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;",
"low_neigh_offs = vf->list[VAR_11].low;",
"high_neigh_offs = vf->list[VAR_11].high;",
"VAR_16 = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs];",
"VAR_14 = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;",
"VAR_15 = FFABS(VAR_16);",
"VAR_19 = VAR_15 * (vf->list[VAR_11].x - vf->list[low_neigh_offs].x);",
"VAR_17 = VAR_19 / VAR_14;",
"if (VAR_16 < 0) {",
"VAR_18 = floor1_Y_final[low_neigh_offs] - VAR_17;",
"} else {",
"VAR_18 = floor1_Y_final[low_neigh_offs] + VAR_17;",
"}",
"val = floor1_Y[VAR_11];",
"highroom = VAR_3-VAR_18;",
"lowroom = VAR_18;",
"if (highroom < lowroom) {",
"room = highroom * 2;",
"} else {",
"room = lowroom * 2;",
"}",
"if (val) {",
"VAR_4[low_neigh_offs] = 1;",
"VAR_4[high_neigh_offs] = 1;",
"VAR_4[VAR_11] = 1;",
"if (val >= room) {",
"if (highroom > lowroom) {",
"floor1_Y_final[VAR_11] = av_clip_uint16(val - lowroom + VAR_18);",
"} else {",
"floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18 - val + highroom - 1);",
"}",
"} else {",
"if (val & 1) {",
"floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18 - (val + 1) / 2);",
"} else {",
"floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18 + val / 2);",
"}",
"}",
"} else {",
"VAR_4[VAR_11] = 0;",
"floor1_Y_final[VAR_11] = av_clip_uint16(VAR_18);",
"}",
"av_dlog(NULL, \" Decoded floor(%d) = %u / val %u\\n\",\nvf->list[VAR_11].x, floor1_Y_final[VAR_11], val);",
"}",
"ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, VAR_4, vf->multiplier, VAR_2, vf->list[1].x);",
"av_dlog(NULL, \" Floor decoded\\n\");",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
29,
31
],
[
39
],
[
41
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
69,
71,
73
],
[
77
],
[
79
],
[
83,
85
],
[
89
],
[
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
],
[
105,
107
],
[
109
],
[
111
],
[
113
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
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
],
[
223,
225
],
[
227
],
[
235
],
[
239
],
[
243
],
[
245
]
] |
8,042 |
static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
enum PixelFormat srcFormat, enum PixelFormat dstFormat,
int srcW, int srcH, int dstW, int dstH, int flags)
{
static enum PixelFormat cur_srcFormat;
static int cur_srcW, cur_srcH;
static uint8_t *src[4];
static int srcStride[4];
uint8_t *dst[4] = {0};
uint8_t *out[4] = {0};
int dstStride[4];
int i;
uint64_t ssdY, ssdU=0, ssdV=0, ssdA=0;
struct SwsContext *dstContext = NULL, *outContext = NULL;
uint32_t crc = 0;
int res = 0;
if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) {
struct SwsContext *srcContext = NULL;
int p;
for (p = 0; p < 4; p++)
if (src[p])
av_freep(&src[p]);
av_image_fill_linesizes(srcStride, srcFormat, srcW);
for (p = 0; p < 4; p++) {
if (srcStride[p])
src[p] = av_mallocz(srcStride[p]*srcH+16);
if (srcStride[p] && !src[p]) {
perror("Malloc");
res = -1;
goto end;
}
}
srcContext = sws_getContext(w, h, PIX_FMT_YUVA420P, srcW, srcH,
srcFormat, SWS_BILINEAR, NULL, NULL, NULL);
if (!srcContext) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name,
av_pix_fmt_descriptors[srcFormat].name);
res = -1;
goto end;
}
sws_scale(srcContext, ref, refStride, 0, h, src, srcStride);
sws_freeContext(srcContext);
cur_srcFormat = srcFormat;
cur_srcW = srcW;
cur_srcH = srcH;
}
av_image_fill_linesizes(dstStride, dstFormat, dstW);
for (i=0; i<4; i++) {
/* Image buffers passed into libswscale can be allocated any way you
* prefer, as long as they're aligned enough for the architecture, and
* they're freed appropriately (such as using av_free for buffers
* allocated with av_malloc). */
/* An extra 16 bytes is being allocated because some scalers may write
* out of bounds. */
if (dstStride[i])
dst[i]= av_mallocz(dstStride[i]*dstH+16);
if (refStride[i])
out[i]= av_mallocz(refStride[i]*h);
if ((dstStride[i] && !dst[i]) || (refStride[i] && !out[i])) {
perror("Malloc");
res = -1;
goto end;
}
}
dstContext= sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, NULL, NULL, NULL);
if (!dstContext) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[srcFormat].name,
av_pix_fmt_descriptors[dstFormat].name);
res = -1;
goto end;
}
outContext= sws_getContext(dstW, dstH, dstFormat, w, h, PIX_FMT_YUVA420P, flags, NULL, NULL, NULL);
if (!outContext) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[dstFormat].name,
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name);
res = -1;
goto end;
}
// printf("test %X %X %X -> %X %X %X\n", (int)ref[0], (int)ref[1], (int)ref[2],
// (int)src[0], (int)src[1], (int)src[2]);
printf(" %s %dx%d -> %s %3dx%3d flags=%2d",
av_pix_fmt_descriptors[srcFormat].name, srcW, srcH,
av_pix_fmt_descriptors[dstFormat].name, dstW, dstH,
flags);
fflush(stdout);
sws_scale(dstContext, src, srcStride, 0, srcH, dst, dstStride);
sws_scale(outContext, dst, dstStride, 0, dstH, out, refStride);
for (i = 0; i < 4 && dstStride[i]; i++) {
crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i], dstStride[i] * dstH);
}
ssdY= getSSD(ref[0], out[0], refStride[0], refStride[0], w, h);
if (hasChroma(srcFormat) && hasChroma(dstFormat)) {
//FIXME check that output is really gray
ssdU= getSSD(ref[1], out[1], refStride[1], refStride[1], (w+1)>>1, (h+1)>>1);
ssdV= getSSD(ref[2], out[2], refStride[2], refStride[2], (w+1)>>1, (h+1)>>1);
}
if (isALPHA(srcFormat) && isALPHA(dstFormat))
ssdA= getSSD(ref[3], out[3], refStride[3], refStride[3], w, h);
ssdY/= w*h;
ssdU/= w*h/4;
ssdV/= w*h/4;
ssdA/= w*h;
printf(" CRC=%08x SSD=%5"PRId64",%5"PRId64",%5"PRId64",%5"PRId64"\n",
crc, ssdY, ssdU, ssdV, ssdA);
end:
sws_freeContext(dstContext);
sws_freeContext(outContext);
for (i=0; i<4; i++) {
if (dstStride[i])
av_free(dst[i]);
if (refStride[i])
av_free(out[i]);
}
return res;
}
| false |
FFmpeg
|
4bf44785982278fae086d25063439cfa343382d7
|
static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
enum PixelFormat srcFormat, enum PixelFormat dstFormat,
int srcW, int srcH, int dstW, int dstH, int flags)
{
static enum PixelFormat cur_srcFormat;
static int cur_srcW, cur_srcH;
static uint8_t *src[4];
static int srcStride[4];
uint8_t *dst[4] = {0};
uint8_t *out[4] = {0};
int dstStride[4];
int i;
uint64_t ssdY, ssdU=0, ssdV=0, ssdA=0;
struct SwsContext *dstContext = NULL, *outContext = NULL;
uint32_t crc = 0;
int res = 0;
if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) {
struct SwsContext *srcContext = NULL;
int p;
for (p = 0; p < 4; p++)
if (src[p])
av_freep(&src[p]);
av_image_fill_linesizes(srcStride, srcFormat, srcW);
for (p = 0; p < 4; p++) {
if (srcStride[p])
src[p] = av_mallocz(srcStride[p]*srcH+16);
if (srcStride[p] && !src[p]) {
perror("Malloc");
res = -1;
goto end;
}
}
srcContext = sws_getContext(w, h, PIX_FMT_YUVA420P, srcW, srcH,
srcFormat, SWS_BILINEAR, NULL, NULL, NULL);
if (!srcContext) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name,
av_pix_fmt_descriptors[srcFormat].name);
res = -1;
goto end;
}
sws_scale(srcContext, ref, refStride, 0, h, src, srcStride);
sws_freeContext(srcContext);
cur_srcFormat = srcFormat;
cur_srcW = srcW;
cur_srcH = srcH;
}
av_image_fill_linesizes(dstStride, dstFormat, dstW);
for (i=0; i<4; i++) {
if (dstStride[i])
dst[i]= av_mallocz(dstStride[i]*dstH+16);
if (refStride[i])
out[i]= av_mallocz(refStride[i]*h);
if ((dstStride[i] && !dst[i]) || (refStride[i] && !out[i])) {
perror("Malloc");
res = -1;
goto end;
}
}
dstContext= sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, NULL, NULL, NULL);
if (!dstContext) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[srcFormat].name,
av_pix_fmt_descriptors[dstFormat].name);
res = -1;
goto end;
}
outContext= sws_getContext(dstW, dstH, dstFormat, w, h, PIX_FMT_YUVA420P, flags, NULL, NULL, NULL);
if (!outContext) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[dstFormat].name,
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name);
res = -1;
goto end;
}
printf(" %s %dx%d -> %s %3dx%3d flags=%2d",
av_pix_fmt_descriptors[srcFormat].name, srcW, srcH,
av_pix_fmt_descriptors[dstFormat].name, dstW, dstH,
flags);
fflush(stdout);
sws_scale(dstContext, src, srcStride, 0, srcH, dst, dstStride);
sws_scale(outContext, dst, dstStride, 0, dstH, out, refStride);
for (i = 0; i < 4 && dstStride[i]; i++) {
crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i], dstStride[i] * dstH);
}
ssdY= getSSD(ref[0], out[0], refStride[0], refStride[0], w, h);
if (hasChroma(srcFormat) && hasChroma(dstFormat)) {
ssdU= getSSD(ref[1], out[1], refStride[1], refStride[1], (w+1)>>1, (h+1)>>1);
ssdV= getSSD(ref[2], out[2], refStride[2], refStride[2], (w+1)>>1, (h+1)>>1);
}
if (isALPHA(srcFormat) && isALPHA(dstFormat))
ssdA= getSSD(ref[3], out[3], refStride[3], refStride[3], w, h);
ssdY/= w*h;
ssdU/= w*h/4;
ssdV/= w*h/4;
ssdA/= w*h;
printf(" CRC=%08x SSD=%5"PRId64",%5"PRId64",%5"PRId64",%5"PRId64"\n",
crc, ssdY, ssdU, ssdV, ssdA);
end:
sws_freeContext(dstContext);
sws_freeContext(outContext);
for (i=0; i<4; i++) {
if (dstStride[i])
av_free(dst[i]);
if (refStride[i])
av_free(out[i]);
}
return res;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(uint8_t *VAR_0[4], int VAR_1[4], int VAR_2, int VAR_3,
enum PixelFormat VAR_4, enum PixelFormat VAR_5,
int VAR_6, int VAR_7, int VAR_8, int VAR_9, int VAR_10)
{
static enum PixelFormat VAR_11;
static int VAR_12, VAR_13;
static uint8_t *VAR_14[4];
static int VAR_15[4];
uint8_t *dst[4] = {0};
uint8_t *out[4] = {0};
int VAR_16[4];
int VAR_17;
uint64_t ssdY, ssdU=0, ssdV=0, ssdA=0;
struct SwsContext *VAR_18 = NULL, *VAR_19 = NULL;
uint32_t crc = 0;
int VAR_20 = 0;
if (VAR_11 != VAR_4 || VAR_12 != VAR_6 || VAR_13 != VAR_7) {
struct SwsContext *VAR_21 = NULL;
int VAR_22;
for (VAR_22 = 0; VAR_22 < 4; VAR_22++)
if (VAR_14[VAR_22])
av_freep(&VAR_14[VAR_22]);
av_image_fill_linesizes(VAR_15, VAR_4, VAR_6);
for (VAR_22 = 0; VAR_22 < 4; VAR_22++) {
if (VAR_15[VAR_22])
VAR_14[VAR_22] = av_mallocz(VAR_15[VAR_22]*VAR_7+16);
if (VAR_15[VAR_22] && !VAR_14[VAR_22]) {
perror("Malloc");
VAR_20 = -1;
goto end;
}
}
VAR_21 = sws_getContext(VAR_2, VAR_3, PIX_FMT_YUVA420P, VAR_6, VAR_7,
VAR_4, SWS_BILINEAR, NULL, NULL, NULL);
if (!VAR_21) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name,
av_pix_fmt_descriptors[VAR_4].name);
VAR_20 = -1;
goto end;
}
sws_scale(VAR_21, VAR_0, VAR_1, 0, VAR_3, VAR_14, VAR_15);
sws_freeContext(VAR_21);
VAR_11 = VAR_4;
VAR_12 = VAR_6;
VAR_13 = VAR_7;
}
av_image_fill_linesizes(VAR_16, VAR_5, VAR_8);
for (VAR_17=0; VAR_17<4; VAR_17++) {
if (VAR_16[VAR_17])
dst[VAR_17]= av_mallocz(VAR_16[VAR_17]*VAR_9+16);
if (VAR_1[VAR_17])
out[VAR_17]= av_mallocz(VAR_1[VAR_17]*VAR_3);
if ((VAR_16[VAR_17] && !dst[VAR_17]) || (VAR_1[VAR_17] && !out[VAR_17])) {
perror("Malloc");
VAR_20 = -1;
goto end;
}
}
VAR_18= sws_getContext(VAR_6, VAR_7, VAR_4, VAR_8, VAR_9, VAR_5, VAR_10, NULL, NULL, NULL);
if (!VAR_18) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[VAR_4].name,
av_pix_fmt_descriptors[VAR_5].name);
VAR_20 = -1;
goto end;
}
VAR_19= sws_getContext(VAR_8, VAR_9, VAR_5, VAR_2, VAR_3, PIX_FMT_YUVA420P, VAR_10, NULL, NULL, NULL);
if (!VAR_19) {
fprintf(stderr, "Failed to get %s ---> %s\n",
av_pix_fmt_descriptors[VAR_5].name,
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name);
VAR_20 = -1;
goto end;
}
printf(" %s %dx%d -> %s %3dx%3d VAR_10=%2d",
av_pix_fmt_descriptors[VAR_4].name, VAR_6, VAR_7,
av_pix_fmt_descriptors[VAR_5].name, VAR_8, VAR_9,
VAR_10);
fflush(stdout);
sws_scale(VAR_18, VAR_14, VAR_15, 0, VAR_7, dst, VAR_16);
sws_scale(VAR_19, dst, VAR_16, 0, VAR_9, out, VAR_1);
for (VAR_17 = 0; VAR_17 < 4 && VAR_16[VAR_17]; VAR_17++) {
crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[VAR_17], VAR_16[VAR_17] * VAR_9);
}
ssdY= getSSD(VAR_0[0], out[0], VAR_1[0], VAR_1[0], VAR_2, VAR_3);
if (hasChroma(VAR_4) && hasChroma(VAR_5)) {
ssdU= getSSD(VAR_0[1], out[1], VAR_1[1], VAR_1[1], (VAR_2+1)>>1, (VAR_3+1)>>1);
ssdV= getSSD(VAR_0[2], out[2], VAR_1[2], VAR_1[2], (VAR_2+1)>>1, (VAR_3+1)>>1);
}
if (isALPHA(VAR_4) && isALPHA(VAR_5))
ssdA= getSSD(VAR_0[3], out[3], VAR_1[3], VAR_1[3], VAR_2, VAR_3);
ssdY/= VAR_2*VAR_3;
ssdU/= VAR_2*VAR_3/4;
ssdV/= VAR_2*VAR_3/4;
ssdA/= VAR_2*VAR_3;
printf(" CRC=%08x SSD=%5"PRId64",%5"PRId64",%5"PRId64",%5"PRId64"\n",
crc, ssdY, ssdU, ssdV, ssdA);
end:
sws_freeContext(VAR_18);
sws_freeContext(VAR_19);
for (VAR_17=0; VAR_17<4; VAR_17++) {
if (VAR_16[VAR_17])
av_free(dst[VAR_17]);
if (VAR_1[VAR_17])
av_free(out[VAR_17]);
}
return VAR_20;
}
|
[
"static int FUNC_0(uint8_t *VAR_0[4], int VAR_1[4], int VAR_2, int VAR_3,\nenum PixelFormat VAR_4, enum PixelFormat VAR_5,\nint VAR_6, int VAR_7, int VAR_8, int VAR_9, int VAR_10)\n{",
"static enum PixelFormat VAR_11;",
"static int VAR_12, VAR_13;",
"static uint8_t *VAR_14[4];",
"static int VAR_15[4];",
"uint8_t *dst[4] = {0};",
"uint8_t *out[4] = {0};",
"int VAR_16[4];",
"int VAR_17;",
"uint64_t ssdY, ssdU=0, ssdV=0, ssdA=0;",
"struct SwsContext *VAR_18 = NULL, *VAR_19 = NULL;",
"uint32_t crc = 0;",
"int VAR_20 = 0;",
"if (VAR_11 != VAR_4 || VAR_12 != VAR_6 || VAR_13 != VAR_7) {",
"struct SwsContext *VAR_21 = NULL;",
"int VAR_22;",
"for (VAR_22 = 0; VAR_22 < 4; VAR_22++)",
"if (VAR_14[VAR_22])\nav_freep(&VAR_14[VAR_22]);",
"av_image_fill_linesizes(VAR_15, VAR_4, VAR_6);",
"for (VAR_22 = 0; VAR_22 < 4; VAR_22++) {",
"if (VAR_15[VAR_22])\nVAR_14[VAR_22] = av_mallocz(VAR_15[VAR_22]*VAR_7+16);",
"if (VAR_15[VAR_22] && !VAR_14[VAR_22]) {",
"perror(\"Malloc\");",
"VAR_20 = -1;",
"goto end;",
"}",
"}",
"VAR_21 = sws_getContext(VAR_2, VAR_3, PIX_FMT_YUVA420P, VAR_6, VAR_7,\nVAR_4, SWS_BILINEAR, NULL, NULL, NULL);",
"if (!VAR_21) {",
"fprintf(stderr, \"Failed to get %s ---> %s\\n\",\nav_pix_fmt_descriptors[PIX_FMT_YUVA420P].name,\nav_pix_fmt_descriptors[VAR_4].name);",
"VAR_20 = -1;",
"goto end;",
"}",
"sws_scale(VAR_21, VAR_0, VAR_1, 0, VAR_3, VAR_14, VAR_15);",
"sws_freeContext(VAR_21);",
"VAR_11 = VAR_4;",
"VAR_12 = VAR_6;",
"VAR_13 = VAR_7;",
"}",
"av_image_fill_linesizes(VAR_16, VAR_5, VAR_8);",
"for (VAR_17=0; VAR_17<4; VAR_17++) {",
"if (VAR_16[VAR_17])\ndst[VAR_17]= av_mallocz(VAR_16[VAR_17]*VAR_9+16);",
"if (VAR_1[VAR_17])\nout[VAR_17]= av_mallocz(VAR_1[VAR_17]*VAR_3);",
"if ((VAR_16[VAR_17] && !dst[VAR_17]) || (VAR_1[VAR_17] && !out[VAR_17])) {",
"perror(\"Malloc\");",
"VAR_20 = -1;",
"goto end;",
"}",
"}",
"VAR_18= sws_getContext(VAR_6, VAR_7, VAR_4, VAR_8, VAR_9, VAR_5, VAR_10, NULL, NULL, NULL);",
"if (!VAR_18) {",
"fprintf(stderr, \"Failed to get %s ---> %s\\n\",\nav_pix_fmt_descriptors[VAR_4].name,\nav_pix_fmt_descriptors[VAR_5].name);",
"VAR_20 = -1;",
"goto end;",
"}",
"VAR_19= sws_getContext(VAR_8, VAR_9, VAR_5, VAR_2, VAR_3, PIX_FMT_YUVA420P, VAR_10, NULL, NULL, NULL);",
"if (!VAR_19) {",
"fprintf(stderr, \"Failed to get %s ---> %s\\n\",\nav_pix_fmt_descriptors[VAR_5].name,\nav_pix_fmt_descriptors[PIX_FMT_YUVA420P].name);",
"VAR_20 = -1;",
"goto end;",
"}",
"printf(\" %s %dx%d -> %s %3dx%3d VAR_10=%2d\",\nav_pix_fmt_descriptors[VAR_4].name, VAR_6, VAR_7,\nav_pix_fmt_descriptors[VAR_5].name, VAR_8, VAR_9,\nVAR_10);",
"fflush(stdout);",
"sws_scale(VAR_18, VAR_14, VAR_15, 0, VAR_7, dst, VAR_16);",
"sws_scale(VAR_19, dst, VAR_16, 0, VAR_9, out, VAR_1);",
"for (VAR_17 = 0; VAR_17 < 4 && VAR_16[VAR_17]; VAR_17++) {",
"crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[VAR_17], VAR_16[VAR_17] * VAR_9);",
"}",
"ssdY= getSSD(VAR_0[0], out[0], VAR_1[0], VAR_1[0], VAR_2, VAR_3);",
"if (hasChroma(VAR_4) && hasChroma(VAR_5)) {",
"ssdU= getSSD(VAR_0[1], out[1], VAR_1[1], VAR_1[1], (VAR_2+1)>>1, (VAR_3+1)>>1);",
"ssdV= getSSD(VAR_0[2], out[2], VAR_1[2], VAR_1[2], (VAR_2+1)>>1, (VAR_3+1)>>1);",
"}",
"if (isALPHA(VAR_4) && isALPHA(VAR_5))\nssdA= getSSD(VAR_0[3], out[3], VAR_1[3], VAR_1[3], VAR_2, VAR_3);",
"ssdY/= VAR_2*VAR_3;",
"ssdU/= VAR_2*VAR_3/4;",
"ssdV/= VAR_2*VAR_3/4;",
"ssdA/= VAR_2*VAR_3;",
"printf(\" CRC=%08x SSD=%5\"PRId64\",%5\"PRId64\",%5\"PRId64\",%5\"PRId64\"\\n\",\ncrc, ssdY, ssdU, ssdV, ssdA);",
"end:\nsws_freeContext(VAR_18);",
"sws_freeContext(VAR_19);",
"for (VAR_17=0; VAR_17<4; VAR_17++) {",
"if (VAR_16[VAR_17])\nav_free(dst[VAR_17]);",
"if (VAR_1[VAR_17])\nav_free(out[VAR_17]);",
"}",
"return VAR_20;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45,
47
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79,
81,
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
125,
127
],
[
129,
131
],
[
133
],
[
135
],
[
137
],
[
141
],
[
143
],
[
145
],
[
149
],
[
151
],
[
153,
155,
157
],
[
159
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171,
173,
175
],
[
177
],
[
181
],
[
183
],
[
191,
193,
195,
197
],
[
199
],
[
203
],
[
205
],
[
209
],
[
211
],
[
213
],
[
217
],
[
219
],
[
223
],
[
225
],
[
227
],
[
229,
231
],
[
235
],
[
237
],
[
239
],
[
241
],
[
245,
247
],
[
251,
255
],
[
257
],
[
261
],
[
263,
265
],
[
267,
269
],
[
271
],
[
275
],
[
277
]
] |
8,043 |
static uint64_t pl061_read(void *opaque, hwaddr offset,
unsigned size)
{
PL061State *s = (PL061State *)opaque;
if (offset >= 0xfd0 && offset < 0x1000) {
return s->id[(offset - 0xfd0) >> 2];
}
if (offset < 0x400) {
return s->data & (offset >> 2);
}
switch (offset) {
case 0x400: /* Direction */
return s->dir;
case 0x404: /* Interrupt sense */
return s->isense;
case 0x408: /* Interrupt both edges */
return s->ibe;
case 0x40c: /* Interrupt event */
return s->iev;
case 0x410: /* Interrupt mask */
return s->im;
case 0x414: /* Raw interrupt status */
return s->istate;
case 0x418: /* Masked interrupt status */
return s->istate & s->im;
case 0x420: /* Alternate function select */
return s->afsel;
case 0x500: /* 2mA drive */
return s->dr2r;
case 0x504: /* 4mA drive */
return s->dr4r;
case 0x508: /* 8mA drive */
return s->dr8r;
case 0x50c: /* Open drain */
return s->odr;
case 0x510: /* Pull-up */
return s->pur;
case 0x514: /* Pull-down */
return s->pdr;
case 0x518: /* Slew rate control */
return s->slr;
case 0x51c: /* Digital enable */
return s->den;
case 0x520: /* Lock */
return s->locked;
case 0x524: /* Commit */
return s->cr;
case 0x528: /* Analog mode select */
return s->amsel;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"pl061_read: Bad offset %x\n", (int)offset);
return 0;
}
}
| false |
qemu
|
09aa3bf382243151e77682b2e89f997349b306d8
|
static uint64_t pl061_read(void *opaque, hwaddr offset,
unsigned size)
{
PL061State *s = (PL061State *)opaque;
if (offset >= 0xfd0 && offset < 0x1000) {
return s->id[(offset - 0xfd0) >> 2];
}
if (offset < 0x400) {
return s->data & (offset >> 2);
}
switch (offset) {
case 0x400:
return s->dir;
case 0x404:
return s->isense;
case 0x408:
return s->ibe;
case 0x40c:
return s->iev;
case 0x410:
return s->im;
case 0x414:
return s->istate;
case 0x418:
return s->istate & s->im;
case 0x420:
return s->afsel;
case 0x500:
return s->dr2r;
case 0x504:
return s->dr4r;
case 0x508:
return s->dr8r;
case 0x50c:
return s->odr;
case 0x510:
return s->pur;
case 0x514:
return s->pdr;
case 0x518:
return s->slr;
case 0x51c:
return s->den;
case 0x520:
return s->locked;
case 0x524:
return s->cr;
case 0x528:
return s->amsel;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"pl061_read: Bad offset %x\n", (int)offset);
return 0;
}
}
|
{
"code": [],
"line_no": []
}
|
static uint64_t FUNC_0(void *opaque, hwaddr offset,
unsigned size)
{
PL061State *s = (PL061State *)opaque;
if (offset >= 0xfd0 && offset < 0x1000) {
return s->id[(offset - 0xfd0) >> 2];
}
if (offset < 0x400) {
return s->data & (offset >> 2);
}
switch (offset) {
case 0x400:
return s->dir;
case 0x404:
return s->isense;
case 0x408:
return s->ibe;
case 0x40c:
return s->iev;
case 0x410:
return s->im;
case 0x414:
return s->istate;
case 0x418:
return s->istate & s->im;
case 0x420:
return s->afsel;
case 0x500:
return s->dr2r;
case 0x504:
return s->dr4r;
case 0x508:
return s->dr8r;
case 0x50c:
return s->odr;
case 0x510:
return s->pur;
case 0x514:
return s->pdr;
case 0x518:
return s->slr;
case 0x51c:
return s->den;
case 0x520:
return s->locked;
case 0x524:
return s->cr;
case 0x528:
return s->amsel;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"FUNC_0: Bad offset %x\n", (int)offset);
return 0;
}
}
|
[
"static uint64_t FUNC_0(void *opaque, hwaddr offset,\nunsigned size)\n{",
"PL061State *s = (PL061State *)opaque;",
"if (offset >= 0xfd0 && offset < 0x1000) {",
"return s->id[(offset - 0xfd0) >> 2];",
"}",
"if (offset < 0x400) {",
"return s->data & (offset >> 2);",
"}",
"switch (offset) {",
"case 0x400:\nreturn s->dir;",
"case 0x404:\nreturn s->isense;",
"case 0x408:\nreturn s->ibe;",
"case 0x40c:\nreturn s->iev;",
"case 0x410:\nreturn s->im;",
"case 0x414:\nreturn s->istate;",
"case 0x418:\nreturn s->istate & s->im;",
"case 0x420:\nreturn s->afsel;",
"case 0x500:\nreturn s->dr2r;",
"case 0x504:\nreturn s->dr4r;",
"case 0x508:\nreturn s->dr8r;",
"case 0x50c:\nreturn s->odr;",
"case 0x510:\nreturn s->pur;",
"case 0x514:\nreturn s->pdr;",
"case 0x518:\nreturn s->slr;",
"case 0x51c:\nreturn s->den;",
"case 0x520:\nreturn s->locked;",
"case 0x524:\nreturn s->cr;",
"case 0x528:\nreturn s->amsel;",
"default:\nqemu_log_mask(LOG_GUEST_ERROR,\n\"FUNC_0: Bad offset %x\\n\", (int)offset);",
"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
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29,
31
],
[
33,
35
],
[
37,
39
],
[
41,
43
],
[
45,
47
],
[
49,
51
],
[
53,
55
],
[
57,
59
],
[
61,
63
],
[
65,
67
],
[
69,
71
],
[
73,
75
],
[
77,
79
],
[
81,
83
],
[
85,
87
],
[
89,
91
],
[
93,
95
],
[
97,
99
],
[
101,
103,
105
],
[
107
],
[
109
],
[
111
]
] |
8,045 |
void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
int is_write, hwaddr access_len)
{
if (buffer != bounce.buffer) {
MemoryRegion *mr;
ram_addr_t addr1;
mr = qemu_ram_addr_from_host(buffer, &addr1);
assert(mr != NULL);
if (is_write) {
while (access_len) {
unsigned l;
l = TARGET_PAGE_SIZE;
if (l > access_len)
l = access_len;
invalidate_and_set_dirty(addr1, l);
addr1 += l;
access_len -= l;
}
}
if (xen_enabled()) {
xen_invalidate_map_cache_entry(buffer);
}
memory_region_unref(mr);
return;
}
if (is_write) {
address_space_write(as, bounce.addr, bounce.buffer, access_len);
}
qemu_vfree(bounce.buffer);
bounce.buffer = NULL;
memory_region_unref(bounce.mr);
cpu_notify_map_clients();
}
| false |
qemu
|
6886867e9880830d735d8ae6f6cc63ed9eb2be0c
|
void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
int is_write, hwaddr access_len)
{
if (buffer != bounce.buffer) {
MemoryRegion *mr;
ram_addr_t addr1;
mr = qemu_ram_addr_from_host(buffer, &addr1);
assert(mr != NULL);
if (is_write) {
while (access_len) {
unsigned l;
l = TARGET_PAGE_SIZE;
if (l > access_len)
l = access_len;
invalidate_and_set_dirty(addr1, l);
addr1 += l;
access_len -= l;
}
}
if (xen_enabled()) {
xen_invalidate_map_cache_entry(buffer);
}
memory_region_unref(mr);
return;
}
if (is_write) {
address_space_write(as, bounce.addr, bounce.buffer, access_len);
}
qemu_vfree(bounce.buffer);
bounce.buffer = NULL;
memory_region_unref(bounce.mr);
cpu_notify_map_clients();
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(AddressSpace *VAR_0, void *VAR_1, hwaddr VAR_2,
int VAR_3, hwaddr VAR_4)
{
if (VAR_1 != bounce.VAR_1) {
MemoryRegion *mr;
ram_addr_t addr1;
mr = qemu_ram_addr_from_host(VAR_1, &addr1);
assert(mr != NULL);
if (VAR_3) {
while (VAR_4) {
unsigned VAR_5;
VAR_5 = TARGET_PAGE_SIZE;
if (VAR_5 > VAR_4)
VAR_5 = VAR_4;
invalidate_and_set_dirty(addr1, VAR_5);
addr1 += VAR_5;
VAR_4 -= VAR_5;
}
}
if (xen_enabled()) {
xen_invalidate_map_cache_entry(VAR_1);
}
memory_region_unref(mr);
return;
}
if (VAR_3) {
address_space_write(VAR_0, bounce.addr, bounce.VAR_1, VAR_4);
}
qemu_vfree(bounce.VAR_1);
bounce.VAR_1 = NULL;
memory_region_unref(bounce.mr);
cpu_notify_map_clients();
}
|
[
"void FUNC_0(AddressSpace *VAR_0, void *VAR_1, hwaddr VAR_2,\nint VAR_3, hwaddr VAR_4)\n{",
"if (VAR_1 != bounce.VAR_1) {",
"MemoryRegion *mr;",
"ram_addr_t addr1;",
"mr = qemu_ram_addr_from_host(VAR_1, &addr1);",
"assert(mr != NULL);",
"if (VAR_3) {",
"while (VAR_4) {",
"unsigned VAR_5;",
"VAR_5 = TARGET_PAGE_SIZE;",
"if (VAR_5 > VAR_4)\nVAR_5 = VAR_4;",
"invalidate_and_set_dirty(addr1, VAR_5);",
"addr1 += VAR_5;",
"VAR_4 -= VAR_5;",
"}",
"}",
"if (xen_enabled()) {",
"xen_invalidate_map_cache_entry(VAR_1);",
"}",
"memory_region_unref(mr);",
"return;",
"}",
"if (VAR_3) {",
"address_space_write(VAR_0, bounce.addr, bounce.VAR_1, VAR_4);",
"}",
"qemu_vfree(bounce.VAR_1);",
"bounce.VAR_1 = NULL;",
"memory_region_unref(bounce.mr);",
"cpu_notify_map_clients();",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
]
] |
8,047 |
int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
{
SaveStateEntry *se;
cpu_synchronize_all_states();
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL)
continue;
/* Section type */
qemu_put_byte(f, QEMU_VM_SECTION_END);
qemu_put_be32(f, se->section_id);
se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
}
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
int len;
if (se->save_state == NULL && se->vmsd == NULL)
continue;
/* Section type */
qemu_put_byte(f, QEMU_VM_SECTION_FULL);
qemu_put_be32(f, se->section_id);
/* ID string */
len = strlen(se->idstr);
qemu_put_byte(f, len);
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
qemu_put_be32(f, se->instance_id);
qemu_put_be32(f, se->version_id);
vmstate_save(f, se);
}
qemu_put_byte(f, QEMU_VM_EOF);
return qemu_file_get_error(f);
}
| false |
qemu
|
2975725f6b3d634dbe924ea9d9f4d86b8a5b217d
|
int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f)
{
SaveStateEntry *se;
cpu_synchronize_all_states();
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL)
continue;
qemu_put_byte(f, QEMU_VM_SECTION_END);
qemu_put_be32(f, se->section_id);
se->save_live_state(mon, f, QEMU_VM_SECTION_END, se->opaque);
}
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
int len;
if (se->save_state == NULL && se->vmsd == NULL)
continue;
qemu_put_byte(f, QEMU_VM_SECTION_FULL);
qemu_put_be32(f, se->section_id);
len = strlen(se->idstr);
qemu_put_byte(f, len);
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
qemu_put_be32(f, se->instance_id);
qemu_put_be32(f, se->version_id);
vmstate_save(f, se);
}
qemu_put_byte(f, QEMU_VM_EOF);
return qemu_file_get_error(f);
}
|
{
"code": [],
"line_no": []
}
|
int FUNC_0(Monitor *VAR_0, QEMUFile *VAR_1)
{
SaveStateEntry *se;
cpu_synchronize_all_states();
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL)
continue;
qemu_put_byte(VAR_1, QEMU_VM_SECTION_END);
qemu_put_be32(VAR_1, se->section_id);
se->save_live_state(VAR_0, VAR_1, QEMU_VM_SECTION_END, se->opaque);
}
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
int len;
if (se->save_state == NULL && se->vmsd == NULL)
continue;
qemu_put_byte(VAR_1, QEMU_VM_SECTION_FULL);
qemu_put_be32(VAR_1, se->section_id);
len = strlen(se->idstr);
qemu_put_byte(VAR_1, len);
qemu_put_buffer(VAR_1, (uint8_t *)se->idstr, len);
qemu_put_be32(VAR_1, se->instance_id);
qemu_put_be32(VAR_1, se->version_id);
vmstate_save(VAR_1, se);
}
qemu_put_byte(VAR_1, QEMU_VM_EOF);
return qemu_file_get_error(VAR_1);
}
|
[
"int FUNC_0(Monitor *VAR_0, QEMUFile *VAR_1)\n{",
"SaveStateEntry *se;",
"cpu_synchronize_all_states();",
"QTAILQ_FOREACH(se, &savevm_handlers, entry) {",
"if (se->save_live_state == NULL)\ncontinue;",
"qemu_put_byte(VAR_1, QEMU_VM_SECTION_END);",
"qemu_put_be32(VAR_1, se->section_id);",
"se->save_live_state(VAR_0, VAR_1, QEMU_VM_SECTION_END, se->opaque);",
"}",
"QTAILQ_FOREACH(se, &savevm_handlers, entry) {",
"int len;",
"if (se->save_state == NULL && se->vmsd == NULL)\ncontinue;",
"qemu_put_byte(VAR_1, QEMU_VM_SECTION_FULL);",
"qemu_put_be32(VAR_1, se->section_id);",
"len = strlen(se->idstr);",
"qemu_put_byte(VAR_1, len);",
"qemu_put_buffer(VAR_1, (uint8_t *)se->idstr, len);",
"qemu_put_be32(VAR_1, se->instance_id);",
"qemu_put_be32(VAR_1, se->version_id);",
"vmstate_save(VAR_1, se);",
"}",
"qemu_put_byte(VAR_1, QEMU_VM_EOF);",
"return qemu_file_get_error(VAR_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
],
[
9
],
[
13
],
[
15,
17
],
[
23
],
[
25
],
[
29
],
[
31
],
[
35
],
[
37
],
[
41,
43
],
[
49
],
[
51
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
71
],
[
73
],
[
77
],
[
81
],
[
83
]
] |
8,048 |
clk_setup_cb cpu_ppc_tb_init (CPUState *env, uint32_t freq)
{
ppc_tb_t *tb_env;
tb_env = qemu_mallocz(sizeof(ppc_tb_t));
if (tb_env == NULL)
return NULL;
env->tb_env = tb_env;
/* Create new timer */
tb_env->decr_timer = qemu_new_timer(vm_clock, &cpu_ppc_decr_cb, env);
#if defined(TARGET_PPC64H)
tb_env->hdecr_timer = qemu_new_timer(vm_clock, &cpu_ppc_hdecr_cb, env);
#endif /* defined(TARGET_PPC64H) */
cpu_ppc_set_tb_clk(env, freq);
return &cpu_ppc_set_tb_clk;
}
| false |
qemu
|
b172c56a6d849554f7e43adc95983a9d6c042689
|
clk_setup_cb cpu_ppc_tb_init (CPUState *env, uint32_t freq)
{
ppc_tb_t *tb_env;
tb_env = qemu_mallocz(sizeof(ppc_tb_t));
if (tb_env == NULL)
return NULL;
env->tb_env = tb_env;
tb_env->decr_timer = qemu_new_timer(vm_clock, &cpu_ppc_decr_cb, env);
#if defined(TARGET_PPC64H)
tb_env->hdecr_timer = qemu_new_timer(vm_clock, &cpu_ppc_hdecr_cb, env);
#endif
cpu_ppc_set_tb_clk(env, freq);
return &cpu_ppc_set_tb_clk;
}
|
{
"code": [],
"line_no": []
}
|
clk_setup_cb FUNC_0 (CPUState *env, uint32_t freq)
{
ppc_tb_t *tb_env;
tb_env = qemu_mallocz(sizeof(ppc_tb_t));
if (tb_env == NULL)
return NULL;
env->tb_env = tb_env;
tb_env->decr_timer = qemu_new_timer(vm_clock, &cpu_ppc_decr_cb, env);
#if defined(TARGET_PPC64H)
tb_env->hdecr_timer = qemu_new_timer(vm_clock, &cpu_ppc_hdecr_cb, env);
#endif
cpu_ppc_set_tb_clk(env, freq);
return &cpu_ppc_set_tb_clk;
}
|
[
"clk_setup_cb FUNC_0 (CPUState *env, uint32_t freq)\n{",
"ppc_tb_t *tb_env;",
"tb_env = qemu_mallocz(sizeof(ppc_tb_t));",
"if (tb_env == NULL)\nreturn NULL;",
"env->tb_env = tb_env;",
"tb_env->decr_timer = qemu_new_timer(vm_clock, &cpu_ppc_decr_cb, env);",
"#if defined(TARGET_PPC64H)\ntb_env->hdecr_timer = qemu_new_timer(vm_clock, &cpu_ppc_hdecr_cb, env);",
"#endif\ncpu_ppc_set_tb_clk(env, freq);",
"return &cpu_ppc_set_tb_clk;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15
],
[
19
],
[
21,
23
],
[
25,
27
],
[
31
],
[
33
]
] |
8,050 |
bool qemu_clock_has_timers(QEMUClockType type)
{
return timerlist_has_timers(
main_loop_tlg.tl[type]);
}
| false |
qemu
|
c2b38b277a7882a592f4f2ec955084b2b756daaa
|
bool qemu_clock_has_timers(QEMUClockType type)
{
return timerlist_has_timers(
main_loop_tlg.tl[type]);
}
|
{
"code": [],
"line_no": []
}
|
bool FUNC_0(QEMUClockType type)
{
return timerlist_has_timers(
main_loop_tlg.tl[type]);
}
|
[
"bool FUNC_0(QEMUClockType type)\n{",
"return timerlist_has_timers(\nmain_loop_tlg.tl[type]);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5,
7
],
[
9
]
] |
8,051 |
static uint64_t pxa2xx_i2c_read(void *opaque, hwaddr addr,
unsigned size)
{
PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
I2CSlave *slave;
addr -= s->offset;
switch (addr) {
case ICR:
return s->control;
case ISR:
return s->status | (i2c_bus_busy(s->bus) << 2);
case ISAR:
slave = I2C_SLAVE(s->slave);
return slave->address;
case IDBR:
return s->data;
case IBMR:
if (s->status & (1 << 2))
s->ibmr ^= 3; /* Fake SCL and SDA pin changes */
else
s->ibmr = 0;
return s->ibmr;
default:
printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
break;
}
return 0;
}
| false |
qemu
|
a89f364ae8740dfc31b321eed9ee454e996dc3c1
|
static uint64_t pxa2xx_i2c_read(void *opaque, hwaddr addr,
unsigned size)
{
PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
I2CSlave *slave;
addr -= s->offset;
switch (addr) {
case ICR:
return s->control;
case ISR:
return s->status | (i2c_bus_busy(s->bus) << 2);
case ISAR:
slave = I2C_SLAVE(s->slave);
return slave->address;
case IDBR:
return s->data;
case IBMR:
if (s->status & (1 << 2))
s->ibmr ^= 3;
else
s->ibmr = 0;
return s->ibmr;
default:
printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
break;
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static uint64_t FUNC_0(void *opaque, hwaddr addr,
unsigned size)
{
PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
I2CSlave *slave;
addr -= s->offset;
switch (addr) {
case ICR:
return s->control;
case ISR:
return s->status | (i2c_bus_busy(s->bus) << 2);
case ISAR:
slave = I2C_SLAVE(s->slave);
return slave->address;
case IDBR:
return s->data;
case IBMR:
if (s->status & (1 << 2))
s->ibmr ^= 3;
else
s->ibmr = 0;
return s->ibmr;
default:
printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr);
break;
}
return 0;
}
|
[
"static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{",
"PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;",
"I2CSlave *slave;",
"addr -= s->offset;",
"switch (addr) {",
"case ICR:\nreturn s->control;",
"case ISR:\nreturn s->status | (i2c_bus_busy(s->bus) << 2);",
"case ISAR:\nslave = I2C_SLAVE(s->slave);",
"return slave->address;",
"case IDBR:\nreturn s->data;",
"case IBMR:\nif (s->status & (1 << 2))\ns->ibmr ^= 3;",
"else\ns->ibmr = 0;",
"return s->ibmr;",
"default:\nprintf(\"%s: Bad register \" REG_FMT \"\\n\", __FUNCTION__, addr);",
"break;",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17,
19
],
[
21,
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
35,
37,
39
],
[
41,
43
],
[
45
],
[
47,
49
],
[
51
],
[
53
],
[
55
],
[
57
]
] |
8,052 |
uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
{
IDEBus *bus = opaque;
IDEState *s = idebus_active_if(bus);
uint32_t addr;
int ret, hob;
addr = addr1 & 7;
/* FIXME: HOB readback uses bit 7, but it's always set right now */
//hob = s->select & (1 << 7);
hob = 0;
switch(addr) {
case 0:
ret = 0xff;
break;
case 1:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
(s != bus->ifs && !s->bs))
ret = 0;
else if (!hob)
ret = s->error;
else
ret = s->hob_feature;
break;
case 2:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->nsector & 0xff;
else
ret = s->hob_nsector;
break;
case 3:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->sector;
else
ret = s->hob_sector;
break;
case 4:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->lcyl;
else
ret = s->hob_lcyl;
break;
case 5:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->hcyl;
else
ret = s->hob_hcyl;
break;
case 6:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else
ret = s->select;
break;
default:
case 7:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
(s != bus->ifs && !s->bs))
ret = 0;
else
ret = s->status;
qemu_irq_lower(bus->irq);
break;
}
#ifdef DEBUG_IDE
printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
#endif
return ret;
}
| false |
qemu
|
4be746345f13e99e468c60acbd3a355e8183e3ce
|
uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
{
IDEBus *bus = opaque;
IDEState *s = idebus_active_if(bus);
uint32_t addr;
int ret, hob;
addr = addr1 & 7;
hob = 0;
switch(addr) {
case 0:
ret = 0xff;
break;
case 1:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
(s != bus->ifs && !s->bs))
ret = 0;
else if (!hob)
ret = s->error;
else
ret = s->hob_feature;
break;
case 2:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->nsector & 0xff;
else
ret = s->hob_nsector;
break;
case 3:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->sector;
else
ret = s->hob_sector;
break;
case 4:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->lcyl;
else
ret = s->hob_lcyl;
break;
case 5:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else if (!hob)
ret = s->hcyl;
else
ret = s->hob_hcyl;
break;
case 6:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
ret = 0;
else
ret = s->select;
break;
default:
case 7:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
(s != bus->ifs && !s->bs))
ret = 0;
else
ret = s->status;
qemu_irq_lower(bus->irq);
break;
}
#ifdef DEBUG_IDE
printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
#endif
return ret;
}
|
{
"code": [],
"line_no": []
}
|
uint32_t FUNC_0(void *opaque, uint32_t addr1)
{
IDEBus *bus = opaque;
IDEState *s = idebus_active_if(bus);
uint32_t addr;
int VAR_0, VAR_1;
addr = addr1 & 7;
VAR_1 = 0;
switch(addr) {
case 0:
VAR_0 = 0xff;
break;
case 1:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
(s != bus->ifs && !s->bs))
VAR_0 = 0;
else if (!VAR_1)
VAR_0 = s->error;
else
VAR_0 = s->hob_feature;
break;
case 2:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
VAR_0 = 0;
else if (!VAR_1)
VAR_0 = s->nsector & 0xff;
else
VAR_0 = s->hob_nsector;
break;
case 3:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
VAR_0 = 0;
else if (!VAR_1)
VAR_0 = s->sector;
else
VAR_0 = s->hob_sector;
break;
case 4:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
VAR_0 = 0;
else if (!VAR_1)
VAR_0 = s->lcyl;
else
VAR_0 = s->hob_lcyl;
break;
case 5:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
VAR_0 = 0;
else if (!VAR_1)
VAR_0 = s->hcyl;
else
VAR_0 = s->hob_hcyl;
break;
case 6:
if (!bus->ifs[0].bs && !bus->ifs[1].bs)
VAR_0 = 0;
else
VAR_0 = s->select;
break;
default:
case 7:
if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
(s != bus->ifs && !s->bs))
VAR_0 = 0;
else
VAR_0 = s->status;
qemu_irq_lower(bus->irq);
break;
}
#ifdef DEBUG_IDE
printf("ide: read addr=0x%x val=%02x\n", addr1, VAR_0);
#endif
return VAR_0;
}
|
[
"uint32_t FUNC_0(void *opaque, uint32_t addr1)\n{",
"IDEBus *bus = opaque;",
"IDEState *s = idebus_active_if(bus);",
"uint32_t addr;",
"int VAR_0, VAR_1;",
"addr = addr1 & 7;",
"VAR_1 = 0;",
"switch(addr) {",
"case 0:\nVAR_0 = 0xff;",
"break;",
"case 1:\nif ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||\n(s != bus->ifs && !s->bs))\nVAR_0 = 0;",
"else if (!VAR_1)\nVAR_0 = s->error;",
"else\nVAR_0 = s->hob_feature;",
"break;",
"case 2:\nif (!bus->ifs[0].bs && !bus->ifs[1].bs)\nVAR_0 = 0;",
"else if (!VAR_1)\nVAR_0 = s->nsector & 0xff;",
"else\nVAR_0 = s->hob_nsector;",
"break;",
"case 3:\nif (!bus->ifs[0].bs && !bus->ifs[1].bs)\nVAR_0 = 0;",
"else if (!VAR_1)\nVAR_0 = s->sector;",
"else\nVAR_0 = s->hob_sector;",
"break;",
"case 4:\nif (!bus->ifs[0].bs && !bus->ifs[1].bs)\nVAR_0 = 0;",
"else if (!VAR_1)\nVAR_0 = s->lcyl;",
"else\nVAR_0 = s->hob_lcyl;",
"break;",
"case 5:\nif (!bus->ifs[0].bs && !bus->ifs[1].bs)\nVAR_0 = 0;",
"else if (!VAR_1)\nVAR_0 = s->hcyl;",
"else\nVAR_0 = s->hob_hcyl;",
"break;",
"case 6:\nif (!bus->ifs[0].bs && !bus->ifs[1].bs)\nVAR_0 = 0;",
"else\nVAR_0 = s->select;",
"break;",
"default:\ncase 7:\nif ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||\n(s != bus->ifs && !s->bs))\nVAR_0 = 0;",
"else\nVAR_0 = s->status;",
"qemu_irq_lower(bus->irq);",
"break;",
"}",
"#ifdef DEBUG_IDE\nprintf(\"ide: read addr=0x%x val=%02x\\n\", addr1, VAR_0);",
"#endif\nreturn 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
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33,
35,
37
],
[
39,
41
],
[
43,
45
],
[
47
],
[
49,
51,
53
],
[
55,
57
],
[
59,
61
],
[
63
],
[
65,
67,
69
],
[
71,
73
],
[
75,
77
],
[
79
],
[
81,
83,
85
],
[
87,
89
],
[
91,
93
],
[
95
],
[
97,
99,
101
],
[
103,
105
],
[
107,
109
],
[
111
],
[
113,
115,
117
],
[
119,
121
],
[
123
],
[
125,
127,
129,
131,
133
],
[
135,
137
],
[
139
],
[
141
],
[
143
],
[
145,
147
],
[
149,
151
],
[
153
]
] |
8,053 |
static void disas_fp_2src(DisasContext *s, uint32_t insn)
{
unsupported_encoding(s, insn);
}
| false |
qemu
|
459cc34290b2823403f9820345c8a83f66495e1d
|
static void disas_fp_2src(DisasContext *s, uint32_t insn)
{
unsupported_encoding(s, insn);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)
{
unsupported_encoding(VAR_0, VAR_1);
}
|
[
"static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)\n{",
"unsupported_encoding(VAR_0, VAR_1);",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
]
] |
8,054 |
static const char *io_port_to_string(uint32_t io_port)
{
if (io_port >= QXL_IO_RANGE_SIZE) {
return "out of range";
}
static const char *io_port_to_string[QXL_IO_RANGE_SIZE + 1] = {
[QXL_IO_NOTIFY_CMD] = "QXL_IO_NOTIFY_CMD",
[QXL_IO_NOTIFY_CURSOR] = "QXL_IO_NOTIFY_CURSOR",
[QXL_IO_UPDATE_AREA] = "QXL_IO_UPDATE_AREA",
[QXL_IO_UPDATE_IRQ] = "QXL_IO_UPDATE_IRQ",
[QXL_IO_NOTIFY_OOM] = "QXL_IO_NOTIFY_OOM",
[QXL_IO_RESET] = "QXL_IO_RESET",
[QXL_IO_SET_MODE] = "QXL_IO_SET_MODE",
[QXL_IO_LOG] = "QXL_IO_LOG",
[QXL_IO_MEMSLOT_ADD] = "QXL_IO_MEMSLOT_ADD",
[QXL_IO_MEMSLOT_DEL] = "QXL_IO_MEMSLOT_DEL",
[QXL_IO_DETACH_PRIMARY] = "QXL_IO_DETACH_PRIMARY",
[QXL_IO_ATTACH_PRIMARY] = "QXL_IO_ATTACH_PRIMARY",
[QXL_IO_CREATE_PRIMARY] = "QXL_IO_CREATE_PRIMARY",
[QXL_IO_DESTROY_PRIMARY] = "QXL_IO_DESTROY_PRIMARY",
[QXL_IO_DESTROY_SURFACE_WAIT] = "QXL_IO_DESTROY_SURFACE_WAIT",
[QXL_IO_DESTROY_ALL_SURFACES] = "QXL_IO_DESTROY_ALL_SURFACES",
#if SPICE_INTERFACE_QXL_MINOR >= 1
[QXL_IO_UPDATE_AREA_ASYNC] = "QXL_IO_UPDATE_AREA_ASYNC",
[QXL_IO_MEMSLOT_ADD_ASYNC] = "QXL_IO_MEMSLOT_ADD_ASYNC",
[QXL_IO_CREATE_PRIMARY_ASYNC] = "QXL_IO_CREATE_PRIMARY_ASYNC",
[QXL_IO_DESTROY_PRIMARY_ASYNC] = "QXL_IO_DESTROY_PRIMARY_ASYNC",
[QXL_IO_DESTROY_SURFACE_ASYNC] = "QXL_IO_DESTROY_SURFACE_ASYNC",
[QXL_IO_DESTROY_ALL_SURFACES_ASYNC]
= "QXL_IO_DESTROY_ALL_SURFACES_ASYNC",
[QXL_IO_FLUSH_SURFACES_ASYNC] = "QXL_IO_FLUSH_SURFACES_ASYNC",
[QXL_IO_FLUSH_RELEASE] = "QXL_IO_FLUSH_RELEASE",
#endif
};
return io_port_to_string[io_port];
}
| false |
qemu
|
4295e15aa730a95003a3639d6dad2eb1e65a59e2
|
static const char *io_port_to_string(uint32_t io_port)
{
if (io_port >= QXL_IO_RANGE_SIZE) {
return "out of range";
}
static const char *io_port_to_string[QXL_IO_RANGE_SIZE + 1] = {
[QXL_IO_NOTIFY_CMD] = "QXL_IO_NOTIFY_CMD",
[QXL_IO_NOTIFY_CURSOR] = "QXL_IO_NOTIFY_CURSOR",
[QXL_IO_UPDATE_AREA] = "QXL_IO_UPDATE_AREA",
[QXL_IO_UPDATE_IRQ] = "QXL_IO_UPDATE_IRQ",
[QXL_IO_NOTIFY_OOM] = "QXL_IO_NOTIFY_OOM",
[QXL_IO_RESET] = "QXL_IO_RESET",
[QXL_IO_SET_MODE] = "QXL_IO_SET_MODE",
[QXL_IO_LOG] = "QXL_IO_LOG",
[QXL_IO_MEMSLOT_ADD] = "QXL_IO_MEMSLOT_ADD",
[QXL_IO_MEMSLOT_DEL] = "QXL_IO_MEMSLOT_DEL",
[QXL_IO_DETACH_PRIMARY] = "QXL_IO_DETACH_PRIMARY",
[QXL_IO_ATTACH_PRIMARY] = "QXL_IO_ATTACH_PRIMARY",
[QXL_IO_CREATE_PRIMARY] = "QXL_IO_CREATE_PRIMARY",
[QXL_IO_DESTROY_PRIMARY] = "QXL_IO_DESTROY_PRIMARY",
[QXL_IO_DESTROY_SURFACE_WAIT] = "QXL_IO_DESTROY_SURFACE_WAIT",
[QXL_IO_DESTROY_ALL_SURFACES] = "QXL_IO_DESTROY_ALL_SURFACES",
#if SPICE_INTERFACE_QXL_MINOR >= 1
[QXL_IO_UPDATE_AREA_ASYNC] = "QXL_IO_UPDATE_AREA_ASYNC",
[QXL_IO_MEMSLOT_ADD_ASYNC] = "QXL_IO_MEMSLOT_ADD_ASYNC",
[QXL_IO_CREATE_PRIMARY_ASYNC] = "QXL_IO_CREATE_PRIMARY_ASYNC",
[QXL_IO_DESTROY_PRIMARY_ASYNC] = "QXL_IO_DESTROY_PRIMARY_ASYNC",
[QXL_IO_DESTROY_SURFACE_ASYNC] = "QXL_IO_DESTROY_SURFACE_ASYNC",
[QXL_IO_DESTROY_ALL_SURFACES_ASYNC]
= "QXL_IO_DESTROY_ALL_SURFACES_ASYNC",
[QXL_IO_FLUSH_SURFACES_ASYNC] = "QXL_IO_FLUSH_SURFACES_ASYNC",
[QXL_IO_FLUSH_RELEASE] = "QXL_IO_FLUSH_RELEASE",
#endif
};
return io_port_to_string[io_port];
}
|
{
"code": [],
"line_no": []
}
|
static const char *VAR_1(uint32_t VAR_0)
{
if (VAR_0 >= QXL_IO_RANGE_SIZE) {
return "out of range";
}
static const char *VAR_1[QXL_IO_RANGE_SIZE + 1] = {
[QXL_IO_NOTIFY_CMD] = "QXL_IO_NOTIFY_CMD",
[QXL_IO_NOTIFY_CURSOR] = "QXL_IO_NOTIFY_CURSOR",
[QXL_IO_UPDATE_AREA] = "QXL_IO_UPDATE_AREA",
[QXL_IO_UPDATE_IRQ] = "QXL_IO_UPDATE_IRQ",
[QXL_IO_NOTIFY_OOM] = "QXL_IO_NOTIFY_OOM",
[QXL_IO_RESET] = "QXL_IO_RESET",
[QXL_IO_SET_MODE] = "QXL_IO_SET_MODE",
[QXL_IO_LOG] = "QXL_IO_LOG",
[QXL_IO_MEMSLOT_ADD] = "QXL_IO_MEMSLOT_ADD",
[QXL_IO_MEMSLOT_DEL] = "QXL_IO_MEMSLOT_DEL",
[QXL_IO_DETACH_PRIMARY] = "QXL_IO_DETACH_PRIMARY",
[QXL_IO_ATTACH_PRIMARY] = "QXL_IO_ATTACH_PRIMARY",
[QXL_IO_CREATE_PRIMARY] = "QXL_IO_CREATE_PRIMARY",
[QXL_IO_DESTROY_PRIMARY] = "QXL_IO_DESTROY_PRIMARY",
[QXL_IO_DESTROY_SURFACE_WAIT] = "QXL_IO_DESTROY_SURFACE_WAIT",
[QXL_IO_DESTROY_ALL_SURFACES] = "QXL_IO_DESTROY_ALL_SURFACES",
#if SPICE_INTERFACE_QXL_MINOR >= 1
[QXL_IO_UPDATE_AREA_ASYNC] = "QXL_IO_UPDATE_AREA_ASYNC",
[QXL_IO_MEMSLOT_ADD_ASYNC] = "QXL_IO_MEMSLOT_ADD_ASYNC",
[QXL_IO_CREATE_PRIMARY_ASYNC] = "QXL_IO_CREATE_PRIMARY_ASYNC",
[QXL_IO_DESTROY_PRIMARY_ASYNC] = "QXL_IO_DESTROY_PRIMARY_ASYNC",
[QXL_IO_DESTROY_SURFACE_ASYNC] = "QXL_IO_DESTROY_SURFACE_ASYNC",
[QXL_IO_DESTROY_ALL_SURFACES_ASYNC]
= "QXL_IO_DESTROY_ALL_SURFACES_ASYNC",
[QXL_IO_FLUSH_SURFACES_ASYNC] = "QXL_IO_FLUSH_SURFACES_ASYNC",
[QXL_IO_FLUSH_RELEASE] = "QXL_IO_FLUSH_RELEASE",
#endif
};
return VAR_1[VAR_0];
}
|
[
"static const char *VAR_1(uint32_t VAR_0)\n{",
"if (VAR_0 >= QXL_IO_RANGE_SIZE) {",
"return \"out of range\";",
"}",
"static const char *VAR_1[QXL_IO_RANGE_SIZE + 1] = {",
"[QXL_IO_NOTIFY_CMD] = \"QXL_IO_NOTIFY_CMD\",\n[QXL_IO_NOTIFY_CURSOR] = \"QXL_IO_NOTIFY_CURSOR\",\n[QXL_IO_UPDATE_AREA] = \"QXL_IO_UPDATE_AREA\",\n[QXL_IO_UPDATE_IRQ] = \"QXL_IO_UPDATE_IRQ\",\n[QXL_IO_NOTIFY_OOM] = \"QXL_IO_NOTIFY_OOM\",\n[QXL_IO_RESET] = \"QXL_IO_RESET\",\n[QXL_IO_SET_MODE] = \"QXL_IO_SET_MODE\",\n[QXL_IO_LOG] = \"QXL_IO_LOG\",\n[QXL_IO_MEMSLOT_ADD] = \"QXL_IO_MEMSLOT_ADD\",\n[QXL_IO_MEMSLOT_DEL] = \"QXL_IO_MEMSLOT_DEL\",\n[QXL_IO_DETACH_PRIMARY] = \"QXL_IO_DETACH_PRIMARY\",\n[QXL_IO_ATTACH_PRIMARY] = \"QXL_IO_ATTACH_PRIMARY\",\n[QXL_IO_CREATE_PRIMARY] = \"QXL_IO_CREATE_PRIMARY\",\n[QXL_IO_DESTROY_PRIMARY] = \"QXL_IO_DESTROY_PRIMARY\",\n[QXL_IO_DESTROY_SURFACE_WAIT] = \"QXL_IO_DESTROY_SURFACE_WAIT\",\n[QXL_IO_DESTROY_ALL_SURFACES] = \"QXL_IO_DESTROY_ALL_SURFACES\",\n#if SPICE_INTERFACE_QXL_MINOR >= 1\n[QXL_IO_UPDATE_AREA_ASYNC] = \"QXL_IO_UPDATE_AREA_ASYNC\",\n[QXL_IO_MEMSLOT_ADD_ASYNC] = \"QXL_IO_MEMSLOT_ADD_ASYNC\",\n[QXL_IO_CREATE_PRIMARY_ASYNC] = \"QXL_IO_CREATE_PRIMARY_ASYNC\",\n[QXL_IO_DESTROY_PRIMARY_ASYNC] = \"QXL_IO_DESTROY_PRIMARY_ASYNC\",\n[QXL_IO_DESTROY_SURFACE_ASYNC] = \"QXL_IO_DESTROY_SURFACE_ASYNC\",\n[QXL_IO_DESTROY_ALL_SURFACES_ASYNC]\n= \"QXL_IO_DESTROY_ALL_SURFACES_ASYNC\",\n[QXL_IO_FLUSH_SURFACES_ASYNC] = \"QXL_IO_FLUSH_SURFACES_ASYNC\",\n[QXL_IO_FLUSH_RELEASE] = \"QXL_IO_FLUSH_RELEASE\",\n#endif\n};",
"return VAR_1[VAR_0];",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15,
17,
19,
21,
23,
25,
27,
29,
31,
33,
35,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
57,
59,
61,
63,
65,
67
],
[
69
],
[
71
]
] |
8,055 |
static int timer_load(QEMUFile *f, void *opaque, int version_id)
{
if (version_id != 1 && version_id != 2)
return -EINVAL;
if (cpu_ticks_enabled) {
return -EINVAL;
}
cpu_ticks_offset=qemu_get_be64(f);
ticks_per_sec=qemu_get_be64(f);
if (version_id == 2) {
cpu_clock_offset=qemu_get_be64(f);
}
return 0;
}
| false |
qemu
|
b03b2e48cb322cb695ff7a6666b25712140ea3c9
|
static int timer_load(QEMUFile *f, void *opaque, int version_id)
{
if (version_id != 1 && version_id != 2)
return -EINVAL;
if (cpu_ticks_enabled) {
return -EINVAL;
}
cpu_ticks_offset=qemu_get_be64(f);
ticks_per_sec=qemu_get_be64(f);
if (version_id == 2) {
cpu_clock_offset=qemu_get_be64(f);
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, int VAR_2)
{
if (VAR_2 != 1 && VAR_2 != 2)
return -EINVAL;
if (cpu_ticks_enabled) {
return -EINVAL;
}
cpu_ticks_offset=qemu_get_be64(VAR_0);
ticks_per_sec=qemu_get_be64(VAR_0);
if (VAR_2 == 2) {
cpu_clock_offset=qemu_get_be64(VAR_0);
}
return 0;
}
|
[
"static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, int VAR_2)\n{",
"if (VAR_2 != 1 && VAR_2 != 2)\nreturn -EINVAL;",
"if (cpu_ticks_enabled) {",
"return -EINVAL;",
"}",
"cpu_ticks_offset=qemu_get_be64(VAR_0);",
"ticks_per_sec=qemu_get_be64(VAR_0);",
"if (VAR_2 == 2) {",
"cpu_clock_offset=qemu_get_be64(VAR_0);",
"}",
"return 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
]
] |
8,056 |
void omap_uwire_attach(struct omap_uwire_s *s,
uWireSlave *slave, int chipselect)
{
if (chipselect < 0 || chipselect > 3) {
fprintf(stderr, "%s: Bad chipselect %i\n", __FUNCTION__, chipselect);
exit(-1);
}
s->chip[chipselect] = slave;
}
| false |
qemu
|
a89f364ae8740dfc31b321eed9ee454e996dc3c1
|
void omap_uwire_attach(struct omap_uwire_s *s,
uWireSlave *slave, int chipselect)
{
if (chipselect < 0 || chipselect > 3) {
fprintf(stderr, "%s: Bad chipselect %i\n", __FUNCTION__, chipselect);
exit(-1);
}
s->chip[chipselect] = slave;
}
|
{
"code": [],
"line_no": []
}
|
void FUNC_0(struct omap_uwire_s *VAR_0,
uWireSlave *VAR_1, int VAR_2)
{
if (VAR_2 < 0 || VAR_2 > 3) {
fprintf(stderr, "%VAR_0: Bad VAR_2 %i\n", __FUNCTION__, VAR_2);
exit(-1);
}
VAR_0->chip[VAR_2] = VAR_1;
}
|
[
"void FUNC_0(struct omap_uwire_s *VAR_0,\nuWireSlave *VAR_1, int VAR_2)\n{",
"if (VAR_2 < 0 || VAR_2 > 3) {",
"fprintf(stderr, \"%VAR_0: Bad VAR_2 %i\\n\", __FUNCTION__, VAR_2);",
"exit(-1);",
"}",
"VAR_0->chip[VAR_2] = VAR_1;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
]
] |
8,057 |
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max){
AVRational a0={0,1}, a1={1,0};
int sign= (num<0) ^ (den<0);
int64_t gcd= av_gcd(FFABS(num), FFABS(den));
if(gcd){
num = FFABS(num)/gcd;
den = FFABS(den)/gcd;
}
if(num<=max && den<=max){
a1= (AVRational){num, den};
den=0;
}
while(den){
uint64_t x = num / den;
int64_t next_den= num - den*x;
int64_t a2n= x*a1.num + a0.num;
int64_t a2d= x*a1.den + a0.den;
if(a2n > max || a2d > max){
if(a1.num) x= (max - a0.num) / a1.num;
if(a1.den) x= FFMIN(x, (max - a0.den) / a1.den);
if (den*(2*x*a1.den + a0.den) > num*a1.den)
a1 = (AVRational){x*a1.num + a0.num, x*a1.den + a0.den};
break;
}
a0= a1;
a1= (AVRational){a2n, a2d};
num= den;
den= next_den;
}
assert(av_gcd(a1.num, a1.den) <= 1U);
*dst_num = sign ? -a1.num : a1.num;
*dst_den = a1.den;
return den==0;
}
| false |
FFmpeg
|
b926b6282d3b9fc8115660ae013f74f4f8c06d30
|
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max){
AVRational a0={0,1}, a1={1,0};
int sign= (num<0) ^ (den<0);
int64_t gcd= av_gcd(FFABS(num), FFABS(den));
if(gcd){
num = FFABS(num)/gcd;
den = FFABS(den)/gcd;
}
if(num<=max && den<=max){
a1= (AVRational){num, den};
den=0;
}
while(den){
uint64_t x = num / den;
int64_t next_den= num - den*x;
int64_t a2n= x*a1.num + a0.num;
int64_t a2d= x*a1.den + a0.den;
if(a2n > max || a2d > max){
if(a1.num) x= (max - a0.num) / a1.num;
if(a1.den) x= FFMIN(x, (max - a0.den) / a1.den);
if (den*(2*x*a1.den + a0.den) > num*a1.den)
a1 = (AVRational){x*a1.num + a0.num, x*a1.den + a0.den};
break;
}
a0= a1;
a1= (AVRational){a2n, a2d};
num= den;
den= next_den;
}
assert(av_gcd(a1.num, a1.den) <= 1U);
*dst_num = sign ? -a1.num : a1.num;
*dst_den = a1.den;
return den==0;
}
|
{
"code": [],
"line_no": []
}
|
int FUNC_0(int *VAR_0, int *VAR_1, int64_t VAR_2, int64_t VAR_3, int64_t VAR_4){
AVRational a0={0,1}, a1={1,0};
int VAR_5= (VAR_2<0) ^ (VAR_3<0);
int64_t gcd= av_gcd(FFABS(VAR_2), FFABS(VAR_3));
if(gcd){
VAR_2 = FFABS(VAR_2)/gcd;
VAR_3 = FFABS(VAR_3)/gcd;
}
if(VAR_2<=VAR_4 && VAR_3<=VAR_4){
a1= (AVRational){VAR_2, VAR_3};
VAR_3=0;
}
while(VAR_3){
uint64_t x = VAR_2 / VAR_3;
int64_t next_den= VAR_2 - VAR_3*x;
int64_t a2n= x*a1.VAR_2 + a0.VAR_2;
int64_t a2d= x*a1.VAR_3 + a0.VAR_3;
if(a2n > VAR_4 || a2d > VAR_4){
if(a1.VAR_2) x= (VAR_4 - a0.VAR_2) / a1.VAR_2;
if(a1.VAR_3) x= FFMIN(x, (VAR_4 - a0.VAR_3) / a1.VAR_3);
if (VAR_3*(2*x*a1.VAR_3 + a0.VAR_3) > VAR_2*a1.VAR_3)
a1 = (AVRational){x*a1.VAR_2 + a0.VAR_2, x*a1.VAR_3 + a0.VAR_3};
break;
}
a0= a1;
a1= (AVRational){a2n, a2d};
VAR_2= VAR_3;
VAR_3= next_den;
}
assert(av_gcd(a1.VAR_2, a1.VAR_3) <= 1U);
*VAR_0 = VAR_5 ? -a1.VAR_2 : a1.VAR_2;
*VAR_1 = a1.VAR_3;
return VAR_3==0;
}
|
[
"int FUNC_0(int *VAR_0, int *VAR_1, int64_t VAR_2, int64_t VAR_3, int64_t VAR_4){",
"AVRational a0={0,1}, a1={1,0};",
"int VAR_5= (VAR_2<0) ^ (VAR_3<0);",
"int64_t gcd= av_gcd(FFABS(VAR_2), FFABS(VAR_3));",
"if(gcd){",
"VAR_2 = FFABS(VAR_2)/gcd;",
"VAR_3 = FFABS(VAR_3)/gcd;",
"}",
"if(VAR_2<=VAR_4 && VAR_3<=VAR_4){",
"a1= (AVRational){VAR_2, VAR_3};",
"VAR_3=0;",
"}",
"while(VAR_3){",
"uint64_t x = VAR_2 / VAR_3;",
"int64_t next_den= VAR_2 - VAR_3*x;",
"int64_t a2n= x*a1.VAR_2 + a0.VAR_2;",
"int64_t a2d= x*a1.VAR_3 + a0.VAR_3;",
"if(a2n > VAR_4 || a2d > VAR_4){",
"if(a1.VAR_2) x= (VAR_4 - a0.VAR_2) / a1.VAR_2;",
"if(a1.VAR_3) x= FFMIN(x, (VAR_4 - a0.VAR_3) / a1.VAR_3);",
"if (VAR_3*(2*x*a1.VAR_3 + a0.VAR_3) > VAR_2*a1.VAR_3)\na1 = (AVRational){x*a1.VAR_2 + a0.VAR_2, x*a1.VAR_3 + a0.VAR_3};",
"break;",
"}",
"a0= a1;",
"a1= (AVRational){a2n, a2d};",
"VAR_2= VAR_3;",
"VAR_3= next_den;",
"}",
"assert(av_gcd(a1.VAR_2, a1.VAR_3) <= 1U);",
"*VAR_0 = VAR_5 ? -a1.VAR_2 : a1.VAR_2;",
"*VAR_1 = a1.VAR_3;",
"return VAR_3==0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1
],
[
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
49,
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
79
],
[
81
]
] |
8,058 |
static void sigp_cpu_restart(void *arg)
{
CPUState *cs = arg;
S390CPU *cpu = S390_CPU(cs);
struct kvm_s390_irq irq = {
.type = KVM_S390_RESTART,
};
kvm_s390_vcpu_interrupt(cpu, &irq);
s390_cpu_set_state(CPU_STATE_OPERATING, cpu);
}
| false |
qemu
|
6eb8f212d2686ed9b17077d554465df7ae06f805
|
static void sigp_cpu_restart(void *arg)
{
CPUState *cs = arg;
S390CPU *cpu = S390_CPU(cs);
struct kvm_s390_irq irq = {
.type = KVM_S390_RESTART,
};
kvm_s390_vcpu_interrupt(cpu, &irq);
s390_cpu_set_state(CPU_STATE_OPERATING, cpu);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(void *VAR_0)
{
CPUState *cs = VAR_0;
S390CPU *cpu = S390_CPU(cs);
struct kvm_s390_irq VAR_1 = {
.type = KVM_S390_RESTART,
};
kvm_s390_vcpu_interrupt(cpu, &VAR_1);
s390_cpu_set_state(CPU_STATE_OPERATING, cpu);
}
|
[
"static void FUNC_0(void *VAR_0)\n{",
"CPUState *cs = VAR_0;",
"S390CPU *cpu = S390_CPU(cs);",
"struct kvm_s390_irq VAR_1 = {",
".type = KVM_S390_RESTART,\n};",
"kvm_s390_vcpu_interrupt(cpu, &VAR_1);",
"s390_cpu_set_state(CPU_STATE_OPERATING, cpu);",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11,
13
],
[
17
],
[
19
],
[
21
]
] |
8,059 |
print_insn_arg (const char *d,
unsigned char *buffer,
unsigned char *p0,
bfd_vma addr,
disassemble_info *info)
{
int val = 0;
int place = d[1];
unsigned char *p = p0;
int regno;
const char *regname;
unsigned char *p1;
double flval;
int flt_p;
bfd_signed_vma disp;
unsigned int uval;
switch (*d)
{
case 'c': /* Cache identifier. */
{
static const char *const cacheFieldName[] = { "nc", "dc", "ic", "bc" };
val = fetch_arg (buffer, place, 2, info);
(*info->fprintf_func) (info->stream, cacheFieldName[val]);
break;
}
case 'a': /* Address register indirect only. Cf. case '+'. */
{
(*info->fprintf_func)
(info->stream,
"%s@",
reg_names[fetch_arg (buffer, place, 3, info) + 8]);
break;
}
case '_': /* 32-bit absolute address for move16. */
{
uval = NEXTULONG (p);
(*info->print_address_func) (uval, info);
break;
}
case 'C':
(*info->fprintf_func) (info->stream, "%%ccr");
break;
case 'S':
(*info->fprintf_func) (info->stream, "%%sr");
break;
case 'U':
(*info->fprintf_func) (info->stream, "%%usp");
break;
case 'E':
(*info->fprintf_func) (info->stream, "%%acc");
break;
case 'G':
(*info->fprintf_func) (info->stream, "%%macsr");
break;
case 'H':
(*info->fprintf_func) (info->stream, "%%mask");
break;
case 'J':
{
/* FIXME: There's a problem here, different m68k processors call the
same address different names. This table can't get it right
because it doesn't know which processor it's disassembling for. */
static const struct { const char *name; int value; } names[]
= {{"%sfc", 0x000}, {"%dfc", 0x001}, {"%cacr", 0x002},
{"%tc", 0x003}, {"%itt0",0x004}, {"%itt1", 0x005},
{"%dtt0",0x006}, {"%dtt1",0x007}, {"%buscr",0x008},
{"%usp", 0x800}, {"%vbr", 0x801}, {"%caar", 0x802},
{"%msp", 0x803}, {"%isp", 0x804},
{"%flashbar", 0xc04}, {"%rambar", 0xc05}, /* mcf528x added these. */
/* Should we be calling this psr like we do in case 'Y'? */
{"%mmusr",0x805},
{"%urp", 0x806}, {"%srp", 0x807}, {"%pcr", 0x808}};
val = fetch_arg (buffer, place, 12, info);
for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
if (names[regno].value == val)
{
(*info->fprintf_func) (info->stream, "%s", names[regno].name);
break;
}
if (regno < 0)
(*info->fprintf_func) (info->stream, "%d", val);
}
break;
case 'Q':
val = fetch_arg (buffer, place, 3, info);
/* 0 means 8, except for the bkpt instruction... */
if (val == 0 && d[1] != 's')
val = 8;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'x':
val = fetch_arg (buffer, place, 3, info);
/* 0 means -1. */
if (val == 0)
val = -1;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'M':
if (place == 'h')
{
static const char *const scalefactor_name[] = { "<<", ">>" };
val = fetch_arg (buffer, place, 1, info);
(*info->fprintf_func) (info->stream, scalefactor_name[val]);
}
else
{
val = fetch_arg (buffer, place, 8, info);
if (val & 0x80)
val = val - 0x100;
(*info->fprintf_func) (info->stream, "#%d", val);
}
break;
case 'T':
val = fetch_arg (buffer, place, 4, info);
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'D':
(*info->fprintf_func) (info->stream, "%s",
reg_names[fetch_arg (buffer, place, 3, info)]);
break;
case 'A':
(*info->fprintf_func)
(info->stream, "%s",
reg_names[fetch_arg (buffer, place, 3, info) + 010]);
break;
case 'R':
(*info->fprintf_func)
(info->stream, "%s",
reg_names[fetch_arg (buffer, place, 4, info)]);
break;
case 'r':
regno = fetch_arg (buffer, place, 4, info);
if (regno > 7)
(*info->fprintf_func) (info->stream, "%s@", reg_names[regno]);
else
(*info->fprintf_func) (info->stream, "@(%s)", reg_names[regno]);
break;
case 'F':
(*info->fprintf_func)
(info->stream, "%%fp%d",
fetch_arg (buffer, place, 3, info));
break;
case 'O':
val = fetch_arg (buffer, place, 6, info);
if (val & 0x20)
(*info->fprintf_func) (info->stream, "%s", reg_names[val & 7]);
else
(*info->fprintf_func) (info->stream, "%d", val);
break;
case '+':
(*info->fprintf_func)
(info->stream, "%s@+",
reg_names[fetch_arg (buffer, place, 3, info) + 8]);
break;
case '-':
(*info->fprintf_func)
(info->stream, "%s@-",
reg_names[fetch_arg (buffer, place, 3, info) + 8]);
break;
case 'k':
if (place == 'k')
(*info->fprintf_func)
(info->stream, "{%s}",
reg_names[fetch_arg (buffer, place, 3, info)]);
else if (place == 'C')
{
val = fetch_arg (buffer, place, 7, info);
if (val > 63) /* This is a signed constant. */
val -= 128;
(*info->fprintf_func) (info->stream, "{#%d}", val);
}
else
return -2;
break;
case '#':
case '^':
p1 = buffer + (*d == '#' ? 2 : 4);
if (place == 's')
val = fetch_arg (buffer, place, 4, info);
else if (place == 'C')
val = fetch_arg (buffer, place, 7, info);
else if (place == '8')
val = fetch_arg (buffer, place, 3, info);
else if (place == '3')
val = fetch_arg (buffer, place, 8, info);
else if (place == 'b')
val = NEXTBYTE (p1);
else if (place == 'w' || place == 'W')
val = NEXTWORD (p1);
else if (place == 'l')
val = NEXTLONG (p1);
else
return -2;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'B':
if (place == 'b')
disp = NEXTBYTE (p);
else if (place == 'B')
disp = COERCE_SIGNED_CHAR (buffer[1]);
else if (place == 'w' || place == 'W')
disp = NEXTWORD (p);
else if (place == 'l' || place == 'L' || place == 'C')
disp = NEXTLONG (p);
else if (place == 'g')
{
disp = NEXTBYTE (buffer);
if (disp == 0)
disp = NEXTWORD (p);
else if (disp == -1)
disp = NEXTLONG (p);
}
else if (place == 'c')
{
if (buffer[1] & 0x40) /* If bit six is one, long offset. */
disp = NEXTLONG (p);
else
disp = NEXTWORD (p);
}
else
return -2;
(*info->print_address_func) (addr + disp, info);
break;
case 'd':
val = NEXTWORD (p);
(*info->fprintf_func)
(info->stream, "%s@(%d)",
reg_names[fetch_arg (buffer, place, 3, info) + 8], val);
break;
case 's':
(*info->fprintf_func) (info->stream, "%s",
fpcr_names[fetch_arg (buffer, place, 3, info)]);
break;
case 'e':
val = fetch_arg(buffer, place, 2, info);
(*info->fprintf_func) (info->stream, "%%acc%d", val);
break;
case 'g':
val = fetch_arg(buffer, place, 1, info);
(*info->fprintf_func) (info->stream, "%%accext%s", val==0 ? "01" : "23");
break;
case 'i':
val = fetch_arg(buffer, place, 2, info);
if (val == 1)
(*info->fprintf_func) (info->stream, "<<");
else if (val == 3)
(*info->fprintf_func) (info->stream, ">>");
else
return -1;
break;
case 'I':
/* Get coprocessor ID... */
val = fetch_arg (buffer, 'd', 3, info);
if (val != 1) /* Unusual coprocessor ID? */
(*info->fprintf_func) (info->stream, "(cpid=%d) ", val);
break;
case '4':
case '*':
case '~':
case '%':
case ';':
case '@':
case '!':
case '$':
case '?':
case '/':
case '&':
case '|':
case '<':
case '>':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'v':
case 'b':
case 'w':
case 'y':
case 'z':
if (place == 'd')
{
val = fetch_arg (buffer, 'x', 6, info);
val = ((val & 7) << 3) + ((val >> 3) & 7);
}
else
val = fetch_arg (buffer, 's', 6, info);
/* If the <ea> is invalid for *d, then reject this match. */
if (!m68k_valid_ea (*d, val))
return -1;
/* Get register number assuming address register. */
regno = (val & 7) + 8;
regname = reg_names[regno];
switch (val >> 3)
{
case 0:
(*info->fprintf_func) (info->stream, "%s", reg_names[val]);
break;
case 1:
(*info->fprintf_func) (info->stream, "%s", regname);
break;
case 2:
(*info->fprintf_func) (info->stream, "%s@", regname);
break;
case 3:
(*info->fprintf_func) (info->stream, "%s@+", regname);
break;
case 4:
(*info->fprintf_func) (info->stream, "%s@-", regname);
break;
case 5:
val = NEXTWORD (p);
(*info->fprintf_func) (info->stream, "%s@(%d)", regname, val);
break;
case 6:
p = print_indexed (regno, p, addr, info);
break;
case 7:
switch (val & 7)
{
case 0:
val = NEXTWORD (p);
(*info->print_address_func) (val, info);
break;
case 1:
uval = NEXTULONG (p);
(*info->print_address_func) (uval, info);
break;
case 2:
val = NEXTWORD (p);
(*info->fprintf_func) (info->stream, "%%pc@(");
(*info->print_address_func) (addr + val, info);
(*info->fprintf_func) (info->stream, ")");
break;
case 3:
p = print_indexed (-1, p, addr, info);
break;
case 4:
flt_p = 1; /* Assume it's a float... */
switch (place)
{
case 'b':
val = NEXTBYTE (p);
flt_p = 0;
break;
case 'w':
val = NEXTWORD (p);
flt_p = 0;
break;
case 'l':
val = NEXTLONG (p);
flt_p = 0;
break;
case 'f':
NEXTSINGLE (flval, p);
break;
case 'F':
NEXTDOUBLE (flval, p);
break;
case 'x':
NEXTEXTEND (flval, p);
break;
case 'p':
flval = NEXTPACKED (p);
break;
default:
return -1;
}
if (flt_p) /* Print a float? */
(*info->fprintf_func) (info->stream, "#%g", flval);
else
(*info->fprintf_func) (info->stream, "#%d", val);
break;
default:
return -1;
}
}
/* If place is '/', then this is the case of the mask bit for
mac/emac loads. Now that the arg has been printed, grab the
mask bit and if set, add a '&' to the arg. */
if (place == '/')
{
val = fetch_arg (buffer, place, 1, info);
if (val)
info->fprintf_func (info->stream, "&");
}
break;
case 'L':
case 'l':
if (place == 'w')
{
char doneany;
p1 = buffer + 2;
val = NEXTWORD (p1);
/* Move the pointer ahead if this point is farther ahead
than the last. */
p = p1 > p ? p1 : p;
if (val == 0)
{
(*info->fprintf_func) (info->stream, "#0");
break;
}
if (*d == 'l')
{
int newval = 0;
for (regno = 0; regno < 16; ++regno)
if (val & (0x8000 >> regno))
newval |= 1 << regno;
val = newval;
}
val &= 0xffff;
doneany = 0;
for (regno = 0; regno < 16; ++regno)
if (val & (1 << regno))
{
int first_regno;
if (doneany)
(*info->fprintf_func) (info->stream, "/");
doneany = 1;
(*info->fprintf_func) (info->stream, "%s", reg_names[regno]);
first_regno = regno;
while (val & (1 << (regno + 1)))
++regno;
if (regno > first_regno)
(*info->fprintf_func) (info->stream, "-%s",
reg_names[regno]);
}
}
else if (place == '3')
{
/* `fmovem' insn. */
char doneany;
val = fetch_arg (buffer, place, 8, info);
if (val == 0)
{
(*info->fprintf_func) (info->stream, "#0");
break;
}
if (*d == 'l')
{
int newval = 0;
for (regno = 0; regno < 8; ++regno)
if (val & (0x80 >> regno))
newval |= 1 << regno;
val = newval;
}
val &= 0xff;
doneany = 0;
for (regno = 0; regno < 8; ++regno)
if (val & (1 << regno))
{
int first_regno;
if (doneany)
(*info->fprintf_func) (info->stream, "/");
doneany = 1;
(*info->fprintf_func) (info->stream, "%%fp%d", regno);
first_regno = regno;
while (val & (1 << (regno + 1)))
++regno;
if (regno > first_regno)
(*info->fprintf_func) (info->stream, "-%%fp%d", regno);
}
}
else if (place == '8')
{
/* fmoveml for FP status registers. */
(*info->fprintf_func) (info->stream, "%s",
fpcr_names[fetch_arg (buffer, place, 3,
info)]);
}
else
return -2;
break;
case 'X':
place = '8';
case 'Y':
case 'Z':
case 'W':
case '0':
case '1':
case '2':
case '3':
{
int val = fetch_arg (buffer, place, 5, info);
const char *name = 0;
switch (val)
{
case 2: name = "%tt0"; break;
case 3: name = "%tt1"; break;
case 0x10: name = "%tc"; break;
case 0x11: name = "%drp"; break;
case 0x12: name = "%srp"; break;
case 0x13: name = "%crp"; break;
case 0x14: name = "%cal"; break;
case 0x15: name = "%val"; break;
case 0x16: name = "%scc"; break;
case 0x17: name = "%ac"; break;
case 0x18: name = "%psr"; break;
case 0x19: name = "%pcsr"; break;
case 0x1c:
case 0x1d:
{
int break_reg = ((buffer[3] >> 2) & 7);
(*info->fprintf_func)
(info->stream, val == 0x1c ? "%%bad%d" : "%%bac%d",
break_reg);
}
break;
default:
(*info->fprintf_func) (info->stream, "<mmu register %d>", val);
}
if (name)
(*info->fprintf_func) (info->stream, "%s", name);
}
break;
case 'f':
{
int fc = fetch_arg (buffer, place, 5, info);
if (fc == 1)
(*info->fprintf_func) (info->stream, "%%dfc");
else if (fc == 0)
(*info->fprintf_func) (info->stream, "%%sfc");
else
/* xgettext:c-format */
(*info->fprintf_func) (info->stream, _("<function code %d>"), fc);
}
break;
case 'V':
(*info->fprintf_func) (info->stream, "%%val");
break;
case 't':
{
int level = fetch_arg (buffer, place, 3, info);
(*info->fprintf_func) (info->stream, "%d", level);
}
break;
case 'u':
{
short is_upper = 0;
int reg = fetch_arg (buffer, place, 5, info);
if (reg & 0x10)
{
is_upper = 1;
reg &= 0xf;
}
(*info->fprintf_func) (info->stream, "%s%s",
reg_half_names[reg],
is_upper ? "u" : "l");
}
break;
default:
return -2;
}
return p - p0;
}
| false |
qemu
|
d14a68b6dc0cc01ddd4c1c7c5907b95c3938679c
|
print_insn_arg (const char *d,
unsigned char *buffer,
unsigned char *p0,
bfd_vma addr,
disassemble_info *info)
{
int val = 0;
int place = d[1];
unsigned char *p = p0;
int regno;
const char *regname;
unsigned char *p1;
double flval;
int flt_p;
bfd_signed_vma disp;
unsigned int uval;
switch (*d)
{
case 'c':
{
static const char *const cacheFieldName[] = { "nc", "dc", "ic", "bc" };
val = fetch_arg (buffer, place, 2, info);
(*info->fprintf_func) (info->stream, cacheFieldName[val]);
break;
}
case 'a':
{
(*info->fprintf_func)
(info->stream,
"%s@",
reg_names[fetch_arg (buffer, place, 3, info) + 8]);
break;
}
case '_':
{
uval = NEXTULONG (p);
(*info->print_address_func) (uval, info);
break;
}
case 'C':
(*info->fprintf_func) (info->stream, "%%ccr");
break;
case 'S':
(*info->fprintf_func) (info->stream, "%%sr");
break;
case 'U':
(*info->fprintf_func) (info->stream, "%%usp");
break;
case 'E':
(*info->fprintf_func) (info->stream, "%%acc");
break;
case 'G':
(*info->fprintf_func) (info->stream, "%%macsr");
break;
case 'H':
(*info->fprintf_func) (info->stream, "%%mask");
break;
case 'J':
{
static const struct { const char *name; int value; } names[]
= {{"%sfc", 0x000}, {"%dfc", 0x001}, {"%cacr", 0x002},
{"%tc", 0x003}, {"%itt0",0x004}, {"%itt1", 0x005},
{"%dtt0",0x006}, {"%dtt1",0x007}, {"%buscr",0x008},
{"%usp", 0x800}, {"%vbr", 0x801}, {"%caar", 0x802},
{"%msp", 0x803}, {"%isp", 0x804},
{"%flashbar", 0xc04}, {"%rambar", 0xc05},
{"%mmusr",0x805},
{"%urp", 0x806}, {"%srp", 0x807}, {"%pcr", 0x808}};
val = fetch_arg (buffer, place, 12, info);
for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
if (names[regno].value == val)
{
(*info->fprintf_func) (info->stream, "%s", names[regno].name);
break;
}
if (regno < 0)
(*info->fprintf_func) (info->stream, "%d", val);
}
break;
case 'Q':
val = fetch_arg (buffer, place, 3, info);
if (val == 0 && d[1] != 's')
val = 8;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'x':
val = fetch_arg (buffer, place, 3, info);
if (val == 0)
val = -1;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'M':
if (place == 'h')
{
static const char *const scalefactor_name[] = { "<<", ">>" };
val = fetch_arg (buffer, place, 1, info);
(*info->fprintf_func) (info->stream, scalefactor_name[val]);
}
else
{
val = fetch_arg (buffer, place, 8, info);
if (val & 0x80)
val = val - 0x100;
(*info->fprintf_func) (info->stream, "#%d", val);
}
break;
case 'T':
val = fetch_arg (buffer, place, 4, info);
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'D':
(*info->fprintf_func) (info->stream, "%s",
reg_names[fetch_arg (buffer, place, 3, info)]);
break;
case 'A':
(*info->fprintf_func)
(info->stream, "%s",
reg_names[fetch_arg (buffer, place, 3, info) + 010]);
break;
case 'R':
(*info->fprintf_func)
(info->stream, "%s",
reg_names[fetch_arg (buffer, place, 4, info)]);
break;
case 'r':
regno = fetch_arg (buffer, place, 4, info);
if (regno > 7)
(*info->fprintf_func) (info->stream, "%s@", reg_names[regno]);
else
(*info->fprintf_func) (info->stream, "@(%s)", reg_names[regno]);
break;
case 'F':
(*info->fprintf_func)
(info->stream, "%%fp%d",
fetch_arg (buffer, place, 3, info));
break;
case 'O':
val = fetch_arg (buffer, place, 6, info);
if (val & 0x20)
(*info->fprintf_func) (info->stream, "%s", reg_names[val & 7]);
else
(*info->fprintf_func) (info->stream, "%d", val);
break;
case '+':
(*info->fprintf_func)
(info->stream, "%s@+",
reg_names[fetch_arg (buffer, place, 3, info) + 8]);
break;
case '-':
(*info->fprintf_func)
(info->stream, "%s@-",
reg_names[fetch_arg (buffer, place, 3, info) + 8]);
break;
case 'k':
if (place == 'k')
(*info->fprintf_func)
(info->stream, "{%s}",
reg_names[fetch_arg (buffer, place, 3, info)]);
else if (place == 'C')
{
val = fetch_arg (buffer, place, 7, info);
if (val > 63)
val -= 128;
(*info->fprintf_func) (info->stream, "{#%d}", val);
}
else
return -2;
break;
case '#':
case '^':
p1 = buffer + (*d == '#' ? 2 : 4);
if (place == 's')
val = fetch_arg (buffer, place, 4, info);
else if (place == 'C')
val = fetch_arg (buffer, place, 7, info);
else if (place == '8')
val = fetch_arg (buffer, place, 3, info);
else if (place == '3')
val = fetch_arg (buffer, place, 8, info);
else if (place == 'b')
val = NEXTBYTE (p1);
else if (place == 'w' || place == 'W')
val = NEXTWORD (p1);
else if (place == 'l')
val = NEXTLONG (p1);
else
return -2;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
case 'B':
if (place == 'b')
disp = NEXTBYTE (p);
else if (place == 'B')
disp = COERCE_SIGNED_CHAR (buffer[1]);
else if (place == 'w' || place == 'W')
disp = NEXTWORD (p);
else if (place == 'l' || place == 'L' || place == 'C')
disp = NEXTLONG (p);
else if (place == 'g')
{
disp = NEXTBYTE (buffer);
if (disp == 0)
disp = NEXTWORD (p);
else if (disp == -1)
disp = NEXTLONG (p);
}
else if (place == 'c')
{
if (buffer[1] & 0x40)
disp = NEXTLONG (p);
else
disp = NEXTWORD (p);
}
else
return -2;
(*info->print_address_func) (addr + disp, info);
break;
case 'd':
val = NEXTWORD (p);
(*info->fprintf_func)
(info->stream, "%s@(%d)",
reg_names[fetch_arg (buffer, place, 3, info) + 8], val);
break;
case 's':
(*info->fprintf_func) (info->stream, "%s",
fpcr_names[fetch_arg (buffer, place, 3, info)]);
break;
case 'e':
val = fetch_arg(buffer, place, 2, info);
(*info->fprintf_func) (info->stream, "%%acc%d", val);
break;
case 'g':
val = fetch_arg(buffer, place, 1, info);
(*info->fprintf_func) (info->stream, "%%accext%s", val==0 ? "01" : "23");
break;
case 'i':
val = fetch_arg(buffer, place, 2, info);
if (val == 1)
(*info->fprintf_func) (info->stream, "<<");
else if (val == 3)
(*info->fprintf_func) (info->stream, ">>");
else
return -1;
break;
case 'I':
val = fetch_arg (buffer, 'd', 3, info);
if (val != 1)
(*info->fprintf_func) (info->stream, "(cpid=%d) ", val);
break;
case '4':
case '*':
case '~':
case '%':
case ';':
case '@':
case '!':
case '$':
case '?':
case '/':
case '&':
case '|':
case '<':
case '>':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'v':
case 'b':
case 'w':
case 'y':
case 'z':
if (place == 'd')
{
val = fetch_arg (buffer, 'x', 6, info);
val = ((val & 7) << 3) + ((val >> 3) & 7);
}
else
val = fetch_arg (buffer, 's', 6, info);
if (!m68k_valid_ea (*d, val))
return -1;
regno = (val & 7) + 8;
regname = reg_names[regno];
switch (val >> 3)
{
case 0:
(*info->fprintf_func) (info->stream, "%s", reg_names[val]);
break;
case 1:
(*info->fprintf_func) (info->stream, "%s", regname);
break;
case 2:
(*info->fprintf_func) (info->stream, "%s@", regname);
break;
case 3:
(*info->fprintf_func) (info->stream, "%s@+", regname);
break;
case 4:
(*info->fprintf_func) (info->stream, "%s@-", regname);
break;
case 5:
val = NEXTWORD (p);
(*info->fprintf_func) (info->stream, "%s@(%d)", regname, val);
break;
case 6:
p = print_indexed (regno, p, addr, info);
break;
case 7:
switch (val & 7)
{
case 0:
val = NEXTWORD (p);
(*info->print_address_func) (val, info);
break;
case 1:
uval = NEXTULONG (p);
(*info->print_address_func) (uval, info);
break;
case 2:
val = NEXTWORD (p);
(*info->fprintf_func) (info->stream, "%%pc@(");
(*info->print_address_func) (addr + val, info);
(*info->fprintf_func) (info->stream, ")");
break;
case 3:
p = print_indexed (-1, p, addr, info);
break;
case 4:
flt_p = 1;
switch (place)
{
case 'b':
val = NEXTBYTE (p);
flt_p = 0;
break;
case 'w':
val = NEXTWORD (p);
flt_p = 0;
break;
case 'l':
val = NEXTLONG (p);
flt_p = 0;
break;
case 'f':
NEXTSINGLE (flval, p);
break;
case 'F':
NEXTDOUBLE (flval, p);
break;
case 'x':
NEXTEXTEND (flval, p);
break;
case 'p':
flval = NEXTPACKED (p);
break;
default:
return -1;
}
if (flt_p)
(*info->fprintf_func) (info->stream, "#%g", flval);
else
(*info->fprintf_func) (info->stream, "#%d", val);
break;
default:
return -1;
}
}
if (place == '/')
{
val = fetch_arg (buffer, place, 1, info);
if (val)
info->fprintf_func (info->stream, "&");
}
break;
case 'L':
case 'l':
if (place == 'w')
{
char doneany;
p1 = buffer + 2;
val = NEXTWORD (p1);
p = p1 > p ? p1 : p;
if (val == 0)
{
(*info->fprintf_func) (info->stream, "#0");
break;
}
if (*d == 'l')
{
int newval = 0;
for (regno = 0; regno < 16; ++regno)
if (val & (0x8000 >> regno))
newval |= 1 << regno;
val = newval;
}
val &= 0xffff;
doneany = 0;
for (regno = 0; regno < 16; ++regno)
if (val & (1 << regno))
{
int first_regno;
if (doneany)
(*info->fprintf_func) (info->stream, "/");
doneany = 1;
(*info->fprintf_func) (info->stream, "%s", reg_names[regno]);
first_regno = regno;
while (val & (1 << (regno + 1)))
++regno;
if (regno > first_regno)
(*info->fprintf_func) (info->stream, "-%s",
reg_names[regno]);
}
}
else if (place == '3')
{
char doneany;
val = fetch_arg (buffer, place, 8, info);
if (val == 0)
{
(*info->fprintf_func) (info->stream, "#0");
break;
}
if (*d == 'l')
{
int newval = 0;
for (regno = 0; regno < 8; ++regno)
if (val & (0x80 >> regno))
newval |= 1 << regno;
val = newval;
}
val &= 0xff;
doneany = 0;
for (regno = 0; regno < 8; ++regno)
if (val & (1 << regno))
{
int first_regno;
if (doneany)
(*info->fprintf_func) (info->stream, "/");
doneany = 1;
(*info->fprintf_func) (info->stream, "%%fp%d", regno);
first_regno = regno;
while (val & (1 << (regno + 1)))
++regno;
if (regno > first_regno)
(*info->fprintf_func) (info->stream, "-%%fp%d", regno);
}
}
else if (place == '8')
{
(*info->fprintf_func) (info->stream, "%s",
fpcr_names[fetch_arg (buffer, place, 3,
info)]);
}
else
return -2;
break;
case 'X':
place = '8';
case 'Y':
case 'Z':
case 'W':
case '0':
case '1':
case '2':
case '3':
{
int val = fetch_arg (buffer, place, 5, info);
const char *name = 0;
switch (val)
{
case 2: name = "%tt0"; break;
case 3: name = "%tt1"; break;
case 0x10: name = "%tc"; break;
case 0x11: name = "%drp"; break;
case 0x12: name = "%srp"; break;
case 0x13: name = "%crp"; break;
case 0x14: name = "%cal"; break;
case 0x15: name = "%val"; break;
case 0x16: name = "%scc"; break;
case 0x17: name = "%ac"; break;
case 0x18: name = "%psr"; break;
case 0x19: name = "%pcsr"; break;
case 0x1c:
case 0x1d:
{
int break_reg = ((buffer[3] >> 2) & 7);
(*info->fprintf_func)
(info->stream, val == 0x1c ? "%%bad%d" : "%%bac%d",
break_reg);
}
break;
default:
(*info->fprintf_func) (info->stream, "<mmu register %d>", val);
}
if (name)
(*info->fprintf_func) (info->stream, "%s", name);
}
break;
case 'f':
{
int fc = fetch_arg (buffer, place, 5, info);
if (fc == 1)
(*info->fprintf_func) (info->stream, "%%dfc");
else if (fc == 0)
(*info->fprintf_func) (info->stream, "%%sfc");
else
(*info->fprintf_func) (info->stream, _("<function code %d>"), fc);
}
break;
case 'V':
(*info->fprintf_func) (info->stream, "%%val");
break;
case 't':
{
int level = fetch_arg (buffer, place, 3, info);
(*info->fprintf_func) (info->stream, "%d", level);
}
break;
case 'u':
{
short is_upper = 0;
int reg = fetch_arg (buffer, place, 5, info);
if (reg & 0x10)
{
is_upper = 1;
reg &= 0xf;
}
(*info->fprintf_func) (info->stream, "%s%s",
reg_half_names[reg],
is_upper ? "u" : "l");
}
break;
default:
return -2;
}
return p - p0;
}
|
{
"code": [],
"line_no": []
}
|
FUNC_0 (const char *VAR_0,
unsigned char *VAR_1,
unsigned char *VAR_2,
bfd_vma VAR_3,
disassemble_info *VAR_4)
{
int VAR_20 = 0;
int VAR_6 = VAR_0[1];
unsigned char *VAR_7 = VAR_2;
int VAR_8;
const char *VAR_9;
unsigned char *VAR_10;
double VAR_11;
int VAR_12;
bfd_signed_vma disp;
unsigned int VAR_13;
switch (*VAR_0)
{
case 'c':
{
static const char *const VAR_14[] = { "nc", "dc", "ic", "bc" };
VAR_20 = fetch_arg (VAR_1, VAR_6, 2, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, VAR_14[VAR_20]);
break;
}
case 'a':
{
(*VAR_4->fprintf_func)
(VAR_4->stream,
"%s@",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8]);
break;
}
case '_':
{
VAR_13 = NEXTULONG (VAR_7);
(*VAR_4->print_address_func) (VAR_13, VAR_4);
break;
}
case 'C':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%ccr");
break;
case 'S':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%sr");
break;
case 'U':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%usp");
break;
case 'E':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%acc");
break;
case 'G':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%macsr");
break;
case 'H':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%mask");
break;
case 'J':
{
static const struct { const char *VAR_20; int value; } VAR_15[]
= {{"%sfc", 0x000}, {"%dfc", 0x001}, {"%cacr", 0x002},
{"%tc", 0x003}, {"%itt0",0x004}, {"%itt1", 0x005},
{"%dtt0",0x006}, {"%dtt1",0x007}, {"%buscr",0x008},
{"%usp", 0x800}, {"%vbr", 0x801}, {"%caar", 0x802},
{"%msp", 0x803}, {"%isp", 0x804},
{"%flashbar", 0xc04}, {"%rambar", 0xc05},
{"%mmusr",0x805},
{"%urp", 0x806}, {"%srp", 0x807}, {"%pcr", 0x808}};
VAR_20 = fetch_arg (VAR_1, VAR_6, 12, VAR_4);
for (VAR_8 = sizeof VAR_15 / sizeof VAR_15[0] - 1; VAR_8 >= 0; VAR_8--)
if (VAR_15[VAR_8].value == VAR_20)
{
(*VAR_4->fprintf_func) (VAR_4->stream, "%s", VAR_15[VAR_8].VAR_20);
break;
}
if (VAR_8 < 0)
(*VAR_4->fprintf_func) (VAR_4->stream, "%VAR_0", VAR_20);
}
break;
case 'Q':
VAR_20 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);
if (VAR_20 == 0 && VAR_0[1] != 's')
VAR_20 = 8;
(*VAR_4->fprintf_func) (VAR_4->stream, "#%VAR_0", VAR_20);
break;
case 'x':
VAR_20 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);
if (VAR_20 == 0)
VAR_20 = -1;
(*VAR_4->fprintf_func) (VAR_4->stream, "#%VAR_0", VAR_20);
break;
case 'M':
if (VAR_6 == 'h')
{
static const char *const VAR_16[] = { "<<", ">>" };
VAR_20 = fetch_arg (VAR_1, VAR_6, 1, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, VAR_16[VAR_20]);
}
else
{
VAR_20 = fetch_arg (VAR_1, VAR_6, 8, VAR_4);
if (VAR_20 & 0x80)
VAR_20 = VAR_20 - 0x100;
(*VAR_4->fprintf_func) (VAR_4->stream, "#%VAR_0", VAR_20);
}
break;
case 'T':
VAR_20 = fetch_arg (VAR_1, VAR_6, 4, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, "#%VAR_0", VAR_20);
break;
case 'D':
(*VAR_4->fprintf_func) (VAR_4->stream, "%s",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4)]);
break;
case 'A':
(*VAR_4->fprintf_func)
(VAR_4->stream, "%s",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 010]);
break;
case 'R':
(*VAR_4->fprintf_func)
(VAR_4->stream, "%s",
reg_names[fetch_arg (VAR_1, VAR_6, 4, VAR_4)]);
break;
case 'r':
VAR_8 = fetch_arg (VAR_1, VAR_6, 4, VAR_4);
if (VAR_8 > 7)
(*VAR_4->fprintf_func) (VAR_4->stream, "%s@", reg_names[VAR_8]);
else
(*VAR_4->fprintf_func) (VAR_4->stream, "@(%s)", reg_names[VAR_8]);
break;
case 'F':
(*VAR_4->fprintf_func)
(VAR_4->stream, "%%fp%VAR_0",
fetch_arg (VAR_1, VAR_6, 3, VAR_4));
break;
case 'O':
VAR_20 = fetch_arg (VAR_1, VAR_6, 6, VAR_4);
if (VAR_20 & 0x20)
(*VAR_4->fprintf_func) (VAR_4->stream, "%s", reg_names[VAR_20 & 7]);
else
(*VAR_4->fprintf_func) (VAR_4->stream, "%VAR_0", VAR_20);
break;
case '+':
(*VAR_4->fprintf_func)
(VAR_4->stream, "%s@+",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8]);
break;
case '-':
(*VAR_4->fprintf_func)
(VAR_4->stream, "%s@-",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8]);
break;
case 'k':
if (VAR_6 == 'k')
(*VAR_4->fprintf_func)
(VAR_4->stream, "{%s}",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4)]);
else if (VAR_6 == 'C')
{
VAR_20 = fetch_arg (VAR_1, VAR_6, 7, VAR_4);
if (VAR_20 > 63)
VAR_20 -= 128;
(*VAR_4->fprintf_func) (VAR_4->stream, "{#%VAR_0}", VAR_20);
}
else
return -2;
break;
case '#':
case '^':
VAR_10 = VAR_1 + (*VAR_0 == '#' ? 2 : 4);
if (VAR_6 == 's')
VAR_20 = fetch_arg (VAR_1, VAR_6, 4, VAR_4);
else if (VAR_6 == 'C')
VAR_20 = fetch_arg (VAR_1, VAR_6, 7, VAR_4);
else if (VAR_6 == '8')
VAR_20 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);
else if (VAR_6 == '3')
VAR_20 = fetch_arg (VAR_1, VAR_6, 8, VAR_4);
else if (VAR_6 == 'b')
VAR_20 = NEXTBYTE (VAR_10);
else if (VAR_6 == 'w' || VAR_6 == 'W')
VAR_20 = NEXTWORD (VAR_10);
else if (VAR_6 == 'l')
VAR_20 = NEXTLONG (VAR_10);
else
return -2;
(*VAR_4->fprintf_func) (VAR_4->stream, "#%VAR_0", VAR_20);
break;
case 'B':
if (VAR_6 == 'b')
disp = NEXTBYTE (VAR_7);
else if (VAR_6 == 'B')
disp = COERCE_SIGNED_CHAR (VAR_1[1]);
else if (VAR_6 == 'w' || VAR_6 == 'W')
disp = NEXTWORD (VAR_7);
else if (VAR_6 == 'l' || VAR_6 == 'L' || VAR_6 == 'C')
disp = NEXTLONG (VAR_7);
else if (VAR_6 == 'g')
{
disp = NEXTBYTE (VAR_1);
if (disp == 0)
disp = NEXTWORD (VAR_7);
else if (disp == -1)
disp = NEXTLONG (VAR_7);
}
else if (VAR_6 == 'c')
{
if (VAR_1[1] & 0x40)
disp = NEXTLONG (VAR_7);
else
disp = NEXTWORD (VAR_7);
}
else
return -2;
(*VAR_4->print_address_func) (VAR_3 + disp, VAR_4);
break;
case 'VAR_0':
VAR_20 = NEXTWORD (VAR_7);
(*VAR_4->fprintf_func)
(VAR_4->stream, "%s@(%VAR_0)",
reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8], VAR_20);
break;
case 's':
(*VAR_4->fprintf_func) (VAR_4->stream, "%s",
fpcr_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4)]);
break;
case 'e':
VAR_20 = fetch_arg(VAR_1, VAR_6, 2, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, "%%acc%VAR_0", VAR_20);
break;
case 'g':
VAR_20 = fetch_arg(VAR_1, VAR_6, 1, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, "%%accext%s", VAR_20==0 ? "01" : "23");
break;
case 'i':
VAR_20 = fetch_arg(VAR_1, VAR_6, 2, VAR_4);
if (VAR_20 == 1)
(*VAR_4->fprintf_func) (VAR_4->stream, "<<");
else if (VAR_20 == 3)
(*VAR_4->fprintf_func) (VAR_4->stream, ">>");
else
return -1;
break;
case 'I':
VAR_20 = fetch_arg (VAR_1, 'VAR_0', 3, VAR_4);
if (VAR_20 != 1)
(*VAR_4->fprintf_func) (VAR_4->stream, "(cpid=%VAR_0) ", VAR_20);
break;
case '4':
case '*':
case '~':
case '%':
case ';':
case '@':
case '!':
case '$':
case '?':
case '/':
case '&':
case '|':
case '<':
case '>':
case 'm':
case 'n':
case 'o':
case 'VAR_7':
case 'q':
case 'v':
case 'b':
case 'w':
case 'y':
case 'z':
if (VAR_6 == 'VAR_0')
{
VAR_20 = fetch_arg (VAR_1, 'x', 6, VAR_4);
VAR_20 = ((VAR_20 & 7) << 3) + ((VAR_20 >> 3) & 7);
}
else
VAR_20 = fetch_arg (VAR_1, 's', 6, VAR_4);
if (!m68k_valid_ea (*VAR_0, VAR_20))
return -1;
VAR_8 = (VAR_20 & 7) + 8;
VAR_9 = reg_names[VAR_8];
switch (VAR_20 >> 3)
{
case 0:
(*VAR_4->fprintf_func) (VAR_4->stream, "%s", reg_names[VAR_20]);
break;
case 1:
(*VAR_4->fprintf_func) (VAR_4->stream, "%s", VAR_9);
break;
case 2:
(*VAR_4->fprintf_func) (VAR_4->stream, "%s@", VAR_9);
break;
case 3:
(*VAR_4->fprintf_func) (VAR_4->stream, "%s@+", VAR_9);
break;
case 4:
(*VAR_4->fprintf_func) (VAR_4->stream, "%s@-", VAR_9);
break;
case 5:
VAR_20 = NEXTWORD (VAR_7);
(*VAR_4->fprintf_func) (VAR_4->stream, "%s@(%VAR_0)", VAR_9, VAR_20);
break;
case 6:
VAR_7 = print_indexed (VAR_8, VAR_7, VAR_3, VAR_4);
break;
case 7:
switch (VAR_20 & 7)
{
case 0:
VAR_20 = NEXTWORD (VAR_7);
(*VAR_4->print_address_func) (VAR_20, VAR_4);
break;
case 1:
VAR_13 = NEXTULONG (VAR_7);
(*VAR_4->print_address_func) (VAR_13, VAR_4);
break;
case 2:
VAR_20 = NEXTWORD (VAR_7);
(*VAR_4->fprintf_func) (VAR_4->stream, "%%pc@(");
(*VAR_4->print_address_func) (VAR_3 + VAR_20, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, ")");
break;
case 3:
VAR_7 = print_indexed (-1, VAR_7, VAR_3, VAR_4);
break;
case 4:
VAR_12 = 1;
switch (VAR_6)
{
case 'b':
VAR_20 = NEXTBYTE (VAR_7);
VAR_12 = 0;
break;
case 'w':
VAR_20 = NEXTWORD (VAR_7);
VAR_12 = 0;
break;
case 'l':
VAR_20 = NEXTLONG (VAR_7);
VAR_12 = 0;
break;
case 'f':
NEXTSINGLE (VAR_11, VAR_7);
break;
case 'F':
NEXTDOUBLE (VAR_11, VAR_7);
break;
case 'x':
NEXTEXTEND (VAR_11, VAR_7);
break;
case 'VAR_7':
VAR_11 = NEXTPACKED (VAR_7);
break;
default:
return -1;
}
if (VAR_12)
(*VAR_4->fprintf_func) (VAR_4->stream, "#%g", VAR_11);
else
(*VAR_4->fprintf_func) (VAR_4->stream, "#%VAR_0", VAR_20);
break;
default:
return -1;
}
}
if (VAR_6 == '/')
{
VAR_20 = fetch_arg (VAR_1, VAR_6, 1, VAR_4);
if (VAR_20)
VAR_4->fprintf_func (VAR_4->stream, "&");
}
break;
case 'L':
case 'l':
if (VAR_6 == 'w')
{
char VAR_20;
VAR_10 = VAR_1 + 2;
VAR_20 = NEXTWORD (VAR_10);
VAR_7 = VAR_10 > VAR_7 ? VAR_10 : VAR_7;
if (VAR_20 == 0)
{
(*VAR_4->fprintf_func) (VAR_4->stream, "#0");
break;
}
if (*VAR_0 == 'l')
{
int VAR_20 = 0;
for (VAR_8 = 0; VAR_8 < 16; ++VAR_8)
if (VAR_20 & (0x8000 >> VAR_8))
VAR_20 |= 1 << VAR_8;
VAR_20 = VAR_20;
}
VAR_20 &= 0xffff;
VAR_20 = 0;
for (VAR_8 = 0; VAR_8 < 16; ++VAR_8)
if (VAR_20 & (1 << VAR_8))
{
int VAR_20;
if (VAR_20)
(*VAR_4->fprintf_func) (VAR_4->stream, "/");
VAR_20 = 1;
(*VAR_4->fprintf_func) (VAR_4->stream, "%s", reg_names[VAR_8]);
VAR_20 = VAR_8;
while (VAR_20 & (1 << (VAR_8 + 1)))
++VAR_8;
if (VAR_8 > VAR_20)
(*VAR_4->fprintf_func) (VAR_4->stream, "-%s",
reg_names[VAR_8]);
}
}
else if (VAR_6 == '3')
{
char VAR_20;
VAR_20 = fetch_arg (VAR_1, VAR_6, 8, VAR_4);
if (VAR_20 == 0)
{
(*VAR_4->fprintf_func) (VAR_4->stream, "#0");
break;
}
if (*VAR_0 == 'l')
{
int VAR_20 = 0;
for (VAR_8 = 0; VAR_8 < 8; ++VAR_8)
if (VAR_20 & (0x80 >> VAR_8))
VAR_20 |= 1 << VAR_8;
VAR_20 = VAR_20;
}
VAR_20 &= 0xff;
VAR_20 = 0;
for (VAR_8 = 0; VAR_8 < 8; ++VAR_8)
if (VAR_20 & (1 << VAR_8))
{
int VAR_20;
if (VAR_20)
(*VAR_4->fprintf_func) (VAR_4->stream, "/");
VAR_20 = 1;
(*VAR_4->fprintf_func) (VAR_4->stream, "%%fp%VAR_0", VAR_8);
VAR_20 = VAR_8;
while (VAR_20 & (1 << (VAR_8 + 1)))
++VAR_8;
if (VAR_8 > VAR_20)
(*VAR_4->fprintf_func) (VAR_4->stream, "-%%fp%VAR_0", VAR_8);
}
}
else if (VAR_6 == '8')
{
(*VAR_4->fprintf_func) (VAR_4->stream, "%s",
fpcr_names[fetch_arg (VAR_1, VAR_6, 3,
VAR_4)]);
}
else
return -2;
break;
case 'X':
VAR_6 = '8';
case 'Y':
case 'Z':
case 'W':
case '0':
case '1':
case '2':
case '3':
{
int VAR_20 = fetch_arg (VAR_1, VAR_6, 5, VAR_4);
const char *VAR_20 = 0;
switch (VAR_20)
{
case 2: VAR_20 = "%tt0"; break;
case 3: VAR_20 = "%tt1"; break;
case 0x10: VAR_20 = "%tc"; break;
case 0x11: VAR_20 = "%drp"; break;
case 0x12: VAR_20 = "%srp"; break;
case 0x13: VAR_20 = "%crp"; break;
case 0x14: VAR_20 = "%cal"; break;
case 0x15: VAR_20 = "%VAR_20"; break;
case 0x16: VAR_20 = "%scc"; break;
case 0x17: VAR_20 = "%ac"; break;
case 0x18: VAR_20 = "%psr"; break;
case 0x19: VAR_20 = "%pcsr"; break;
case 0x1c:
case 0x1d:
{
int VAR_21 = ((VAR_1[3] >> 2) & 7);
(*VAR_4->fprintf_func)
(VAR_4->stream, VAR_20 == 0x1c ? "%%bad%VAR_0" : "%%bac%VAR_0",
VAR_21);
}
break;
default:
(*VAR_4->fprintf_func) (VAR_4->stream, "<mmu register %VAR_0>", VAR_20);
}
if (VAR_20)
(*VAR_4->fprintf_func) (VAR_4->stream, "%s", VAR_20);
}
break;
case 'f':
{
int VAR_22 = fetch_arg (VAR_1, VAR_6, 5, VAR_4);
if (VAR_22 == 1)
(*VAR_4->fprintf_func) (VAR_4->stream, "%%dfc");
else if (VAR_22 == 0)
(*VAR_4->fprintf_func) (VAR_4->stream, "%%sfc");
else
(*VAR_4->fprintf_func) (VAR_4->stream, _("<function code %VAR_0>"), VAR_22);
}
break;
case 'V':
(*VAR_4->fprintf_func) (VAR_4->stream, "%%VAR_20");
break;
case 't':
{
int VAR_23 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);
(*VAR_4->fprintf_func) (VAR_4->stream, "%VAR_0", VAR_23);
}
break;
case 'u':
{
short VAR_24 = 0;
int VAR_25 = fetch_arg (VAR_1, VAR_6, 5, VAR_4);
if (VAR_25 & 0x10)
{
VAR_24 = 1;
VAR_25 &= 0xf;
}
(*VAR_4->fprintf_func) (VAR_4->stream, "%s%s",
reg_half_names[VAR_25],
VAR_24 ? "u" : "l");
}
break;
default:
return -2;
}
return VAR_7 - VAR_2;
}
|
[
"FUNC_0 (const char *VAR_0,\nunsigned char *VAR_1,\nunsigned char *VAR_2,\nbfd_vma VAR_3,\ndisassemble_info *VAR_4)\n{",
"int VAR_20 = 0;",
"int VAR_6 = VAR_0[1];",
"unsigned char *VAR_7 = VAR_2;",
"int VAR_8;",
"const char *VAR_9;",
"unsigned char *VAR_10;",
"double VAR_11;",
"int VAR_12;",
"bfd_signed_vma disp;",
"unsigned int VAR_13;",
"switch (*VAR_0)\n{",
"case 'c':\n{",
"static const char *const VAR_14[] = { \"nc\", \"dc\", \"ic\", \"bc\" };",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 2, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, VAR_14[VAR_20]);",
"break;",
"}",
"case 'a':\n{",
"(*VAR_4->fprintf_func)\n(VAR_4->stream,\n\"%s@\",\nreg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8]);",
"break;",
"}",
"case '_':\n{",
"VAR_13 = NEXTULONG (VAR_7);",
"(*VAR_4->print_address_func) (VAR_13, VAR_4);",
"break;",
"}",
"case 'C':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%ccr\");",
"break;",
"case 'S':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%sr\");",
"break;",
"case 'U':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%usp\");",
"break;",
"case 'E':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%acc\");",
"break;",
"case 'G':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%macsr\");",
"break;",
"case 'H':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%mask\");",
"break;",
"case 'J':\n{",
"static const struct { const char *VAR_20; int value; } VAR_15[]",
"= {{\"%sfc\", 0x000}, {\"%dfc\", 0x001}, {\"%cacr\", 0x002},",
"{\"%tc\", 0x003}, {\"%itt0\",0x004}, {\"%itt1\", 0x005},",
"{\"%dtt0\",0x006}, {\"%dtt1\",0x007}, {\"%buscr\",0x008},",
"{\"%usp\", 0x800}, {\"%vbr\", 0x801}, {\"%caar\", 0x802},",
"{\"%msp\", 0x803}, {\"%isp\", 0x804},",
"{\"%flashbar\", 0xc04}, {\"%rambar\", 0xc05},",
"{\"%mmusr\",0x805},",
"{\"%urp\", 0x806}, {\"%srp\", 0x807}, {\"%pcr\", 0x808}};",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 12, VAR_4);",
"for (VAR_8 = sizeof VAR_15 / sizeof VAR_15[0] - 1; VAR_8 >= 0; VAR_8--)",
"if (VAR_15[VAR_8].value == VAR_20)\n{",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\", VAR_15[VAR_8].VAR_20);",
"break;",
"}",
"if (VAR_8 < 0)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%VAR_0\", VAR_20);",
"}",
"break;",
"case 'Q':\nVAR_20 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);",
"if (VAR_20 == 0 && VAR_0[1] != 's')\nVAR_20 = 8;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#%VAR_0\", VAR_20);",
"break;",
"case 'x':\nVAR_20 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);",
"if (VAR_20 == 0)\nVAR_20 = -1;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#%VAR_0\", VAR_20);",
"break;",
"case 'M':\nif (VAR_6 == 'h')\n{",
"static const char *const VAR_16[] = { \"<<\", \">>\" };",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 1, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, VAR_16[VAR_20]);",
"}",
"else\n{",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 8, VAR_4);",
"if (VAR_20 & 0x80)\nVAR_20 = VAR_20 - 0x100;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#%VAR_0\", VAR_20);",
"}",
"break;",
"case 'T':\nVAR_20 = fetch_arg (VAR_1, VAR_6, 4, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#%VAR_0\", VAR_20);",
"break;",
"case 'D':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\",\nreg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4)]);",
"break;",
"case 'A':\n(*VAR_4->fprintf_func)\n(VAR_4->stream, \"%s\",\nreg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 010]);",
"break;",
"case 'R':\n(*VAR_4->fprintf_func)\n(VAR_4->stream, \"%s\",\nreg_names[fetch_arg (VAR_1, VAR_6, 4, VAR_4)]);",
"break;",
"case 'r':\nVAR_8 = fetch_arg (VAR_1, VAR_6, 4, VAR_4);",
"if (VAR_8 > 7)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s@\", reg_names[VAR_8]);",
"else\n(*VAR_4->fprintf_func) (VAR_4->stream, \"@(%s)\", reg_names[VAR_8]);",
"break;",
"case 'F':\n(*VAR_4->fprintf_func)\n(VAR_4->stream, \"%%fp%VAR_0\",\nfetch_arg (VAR_1, VAR_6, 3, VAR_4));",
"break;",
"case 'O':\nVAR_20 = fetch_arg (VAR_1, VAR_6, 6, VAR_4);",
"if (VAR_20 & 0x20)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\", reg_names[VAR_20 & 7]);",
"else\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%VAR_0\", VAR_20);",
"break;",
"case '+':\n(*VAR_4->fprintf_func)\n(VAR_4->stream, \"%s@+\",\nreg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8]);",
"break;",
"case '-':\n(*VAR_4->fprintf_func)\n(VAR_4->stream, \"%s@-\",\nreg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8]);",
"break;",
"case 'k':\nif (VAR_6 == 'k')\n(*VAR_4->fprintf_func)\n(VAR_4->stream, \"{%s}\",",
"reg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4)]);",
"else if (VAR_6 == 'C')\n{",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 7, VAR_4);",
"if (VAR_20 > 63)\nVAR_20 -= 128;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"{#%VAR_0}\", VAR_20);",
"}",
"else\nreturn -2;",
"break;",
"case '#':\ncase '^':\nVAR_10 = VAR_1 + (*VAR_0 == '#' ? 2 : 4);",
"if (VAR_6 == 's')\nVAR_20 = fetch_arg (VAR_1, VAR_6, 4, VAR_4);",
"else if (VAR_6 == 'C')\nVAR_20 = fetch_arg (VAR_1, VAR_6, 7, VAR_4);",
"else if (VAR_6 == '8')\nVAR_20 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);",
"else if (VAR_6 == '3')\nVAR_20 = fetch_arg (VAR_1, VAR_6, 8, VAR_4);",
"else if (VAR_6 == 'b')\nVAR_20 = NEXTBYTE (VAR_10);",
"else if (VAR_6 == 'w' || VAR_6 == 'W')\nVAR_20 = NEXTWORD (VAR_10);",
"else if (VAR_6 == 'l')\nVAR_20 = NEXTLONG (VAR_10);",
"else\nreturn -2;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#%VAR_0\", VAR_20);",
"break;",
"case 'B':\nif (VAR_6 == 'b')\ndisp = NEXTBYTE (VAR_7);",
"else if (VAR_6 == 'B')\ndisp = COERCE_SIGNED_CHAR (VAR_1[1]);",
"else if (VAR_6 == 'w' || VAR_6 == 'W')\ndisp = NEXTWORD (VAR_7);",
"else if (VAR_6 == 'l' || VAR_6 == 'L' || VAR_6 == 'C')\ndisp = NEXTLONG (VAR_7);",
"else if (VAR_6 == 'g')\n{",
"disp = NEXTBYTE (VAR_1);",
"if (disp == 0)\ndisp = NEXTWORD (VAR_7);",
"else if (disp == -1)\ndisp = NEXTLONG (VAR_7);",
"}",
"else if (VAR_6 == 'c')\n{",
"if (VAR_1[1] & 0x40)\ndisp = NEXTLONG (VAR_7);",
"else\ndisp = NEXTWORD (VAR_7);",
"}",
"else\nreturn -2;",
"(*VAR_4->print_address_func) (VAR_3 + disp, VAR_4);",
"break;",
"case 'VAR_0':\nVAR_20 = NEXTWORD (VAR_7);",
"(*VAR_4->fprintf_func)\n(VAR_4->stream, \"%s@(%VAR_0)\",\nreg_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4) + 8], VAR_20);",
"break;",
"case 's':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\",\nfpcr_names[fetch_arg (VAR_1, VAR_6, 3, VAR_4)]);",
"break;",
"case 'e':\nVAR_20 = fetch_arg(VAR_1, VAR_6, 2, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%%acc%VAR_0\", VAR_20);",
"break;",
"case 'g':\nVAR_20 = fetch_arg(VAR_1, VAR_6, 1, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%%accext%s\", VAR_20==0 ? \"01\" : \"23\");",
"break;",
"case 'i':\nVAR_20 = fetch_arg(VAR_1, VAR_6, 2, VAR_4);",
"if (VAR_20 == 1)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"<<\");",
"else if (VAR_20 == 3)\n(*VAR_4->fprintf_func) (VAR_4->stream, \">>\");",
"else\nreturn -1;",
"break;",
"case 'I':\nVAR_20 = fetch_arg (VAR_1, 'VAR_0', 3, VAR_4);",
"if (VAR_20 != 1)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"(cpid=%VAR_0) \", VAR_20);",
"break;",
"case '4':\ncase '*':\ncase '~':\ncase '%':\ncase ';':",
"case '@':\ncase '!':\ncase '$':\ncase '?':\ncase '/':\ncase '&':\ncase '|':\ncase '<':\ncase '>':\ncase 'm':\ncase 'n':\ncase 'o':\ncase 'VAR_7':\ncase 'q':\ncase 'v':\ncase 'b':\ncase 'w':\ncase 'y':\ncase 'z':\nif (VAR_6 == 'VAR_0')\n{",
"VAR_20 = fetch_arg (VAR_1, 'x', 6, VAR_4);",
"VAR_20 = ((VAR_20 & 7) << 3) + ((VAR_20 >> 3) & 7);",
"}",
"else\nVAR_20 = fetch_arg (VAR_1, 's', 6, VAR_4);",
"if (!m68k_valid_ea (*VAR_0, VAR_20))\nreturn -1;",
"VAR_8 = (VAR_20 & 7) + 8;",
"VAR_9 = reg_names[VAR_8];",
"switch (VAR_20 >> 3)\n{",
"case 0:\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\", reg_names[VAR_20]);",
"break;",
"case 1:\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\", VAR_9);",
"break;",
"case 2:\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s@\", VAR_9);",
"break;",
"case 3:\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s@+\", VAR_9);",
"break;",
"case 4:\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s@-\", VAR_9);",
"break;",
"case 5:\nVAR_20 = NEXTWORD (VAR_7);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%s@(%VAR_0)\", VAR_9, VAR_20);",
"break;",
"case 6:\nVAR_7 = print_indexed (VAR_8, VAR_7, VAR_3, VAR_4);",
"break;",
"case 7:\nswitch (VAR_20 & 7)\n{",
"case 0:\nVAR_20 = NEXTWORD (VAR_7);",
"(*VAR_4->print_address_func) (VAR_20, VAR_4);",
"break;",
"case 1:\nVAR_13 = NEXTULONG (VAR_7);",
"(*VAR_4->print_address_func) (VAR_13, VAR_4);",
"break;",
"case 2:\nVAR_20 = NEXTWORD (VAR_7);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%%pc@(\");",
"(*VAR_4->print_address_func) (VAR_3 + VAR_20, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \")\");",
"break;",
"case 3:\nVAR_7 = print_indexed (-1, VAR_7, VAR_3, VAR_4);",
"break;",
"case 4:\nVAR_12 = 1;",
"switch (VAR_6)\n{",
"case 'b':\nVAR_20 = NEXTBYTE (VAR_7);",
"VAR_12 = 0;",
"break;",
"case 'w':\nVAR_20 = NEXTWORD (VAR_7);",
"VAR_12 = 0;",
"break;",
"case 'l':\nVAR_20 = NEXTLONG (VAR_7);",
"VAR_12 = 0;",
"break;",
"case 'f':\nNEXTSINGLE (VAR_11, VAR_7);",
"break;",
"case 'F':\nNEXTDOUBLE (VAR_11, VAR_7);",
"break;",
"case 'x':\nNEXTEXTEND (VAR_11, VAR_7);",
"break;",
"case 'VAR_7':\nVAR_11 = NEXTPACKED (VAR_7);",
"break;",
"default:\nreturn -1;",
"}",
"if (VAR_12)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"#%g\", VAR_11);",
"else\n(*VAR_4->fprintf_func) (VAR_4->stream, \"#%VAR_0\", VAR_20);",
"break;",
"default:\nreturn -1;",
"}",
"}",
"if (VAR_6 == '/')\n{",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 1, VAR_4);",
"if (VAR_20)\nVAR_4->fprintf_func (VAR_4->stream, \"&\");",
"}",
"break;",
"case 'L':\ncase 'l':\nif (VAR_6 == 'w')\n{",
"char VAR_20;",
"VAR_10 = VAR_1 + 2;",
"VAR_20 = NEXTWORD (VAR_10);",
"VAR_7 = VAR_10 > VAR_7 ? VAR_10 : VAR_7;",
"if (VAR_20 == 0)\n{",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#0\");",
"break;",
"}",
"if (*VAR_0 == 'l')\n{",
"int VAR_20 = 0;",
"for (VAR_8 = 0; VAR_8 < 16; ++VAR_8)",
"if (VAR_20 & (0x8000 >> VAR_8))\nVAR_20 |= 1 << VAR_8;",
"VAR_20 = VAR_20;",
"}",
"VAR_20 &= 0xffff;",
"VAR_20 = 0;",
"for (VAR_8 = 0; VAR_8 < 16; ++VAR_8)",
"if (VAR_20 & (1 << VAR_8))\n{",
"int VAR_20;",
"if (VAR_20)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"/\");",
"VAR_20 = 1;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\", reg_names[VAR_8]);",
"VAR_20 = VAR_8;",
"while (VAR_20 & (1 << (VAR_8 + 1)))\n++VAR_8;",
"if (VAR_8 > VAR_20)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"-%s\",\nreg_names[VAR_8]);",
"}",
"}",
"else if (VAR_6 == '3')\n{",
"char VAR_20;",
"VAR_20 = fetch_arg (VAR_1, VAR_6, 8, VAR_4);",
"if (VAR_20 == 0)\n{",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"#0\");",
"break;",
"}",
"if (*VAR_0 == 'l')\n{",
"int VAR_20 = 0;",
"for (VAR_8 = 0; VAR_8 < 8; ++VAR_8)",
"if (VAR_20 & (0x80 >> VAR_8))\nVAR_20 |= 1 << VAR_8;",
"VAR_20 = VAR_20;",
"}",
"VAR_20 &= 0xff;",
"VAR_20 = 0;",
"for (VAR_8 = 0; VAR_8 < 8; ++VAR_8)",
"if (VAR_20 & (1 << VAR_8))\n{",
"int VAR_20;",
"if (VAR_20)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"/\");",
"VAR_20 = 1;",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%%fp%VAR_0\", VAR_8);",
"VAR_20 = VAR_8;",
"while (VAR_20 & (1 << (VAR_8 + 1)))\n++VAR_8;",
"if (VAR_8 > VAR_20)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"-%%fp%VAR_0\", VAR_8);",
"}",
"}",
"else if (VAR_6 == '8')\n{",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\",\nfpcr_names[fetch_arg (VAR_1, VAR_6, 3,\nVAR_4)]);",
"}",
"else\nreturn -2;",
"break;",
"case 'X':\nVAR_6 = '8';",
"case 'Y':\ncase 'Z':\ncase 'W':\ncase '0':\ncase '1':\ncase '2':\ncase '3':\n{",
"int VAR_20 = fetch_arg (VAR_1, VAR_6, 5, VAR_4);",
"const char *VAR_20 = 0;",
"switch (VAR_20)\n{",
"case 2: VAR_20 = \"%tt0\"; break;",
"case 3: VAR_20 = \"%tt1\"; break;",
"case 0x10: VAR_20 = \"%tc\"; break;",
"case 0x11: VAR_20 = \"%drp\"; break;",
"case 0x12: VAR_20 = \"%srp\"; break;",
"case 0x13: VAR_20 = \"%crp\"; break;",
"case 0x14: VAR_20 = \"%cal\"; break;",
"case 0x15: VAR_20 = \"%VAR_20\"; break;",
"case 0x16: VAR_20 = \"%scc\"; break;",
"case 0x17: VAR_20 = \"%ac\"; break;",
"case 0x18: VAR_20 = \"%psr\"; break;",
"case 0x19: VAR_20 = \"%pcsr\"; break;",
"case 0x1c:\ncase 0x1d:\n{",
"int VAR_21 = ((VAR_1[3] >> 2) & 7);",
"(*VAR_4->fprintf_func)\n(VAR_4->stream, VAR_20 == 0x1c ? \"%%bad%VAR_0\" : \"%%bac%VAR_0\",\nVAR_21);",
"}",
"break;",
"default:\n(*VAR_4->fprintf_func) (VAR_4->stream, \"<mmu register %VAR_0>\", VAR_20);",
"}",
"if (VAR_20)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%s\", VAR_20);",
"}",
"break;",
"case 'f':\n{",
"int VAR_22 = fetch_arg (VAR_1, VAR_6, 5, VAR_4);",
"if (VAR_22 == 1)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%dfc\");",
"else if (VAR_22 == 0)\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%sfc\");",
"else\n(*VAR_4->fprintf_func) (VAR_4->stream, _(\"<function code %VAR_0>\"), VAR_22);",
"}",
"break;",
"case 'V':\n(*VAR_4->fprintf_func) (VAR_4->stream, \"%%VAR_20\");",
"break;",
"case 't':\n{",
"int VAR_23 = fetch_arg (VAR_1, VAR_6, 3, VAR_4);",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%VAR_0\", VAR_23);",
"}",
"break;",
"case 'u':\n{",
"short VAR_24 = 0;",
"int VAR_25 = fetch_arg (VAR_1, VAR_6, 5, VAR_4);",
"if (VAR_25 & 0x10)\n{",
"VAR_24 = 1;",
"VAR_25 &= 0xf;",
"}",
"(*VAR_4->fprintf_func) (VAR_4->stream, \"%s%s\",\nreg_half_names[VAR_25],\nVAR_24 ? \"u\" : \"l\");",
"}",
"break;",
"default:\nreturn -2;",
"}",
"return VAR_7 - VAR_2;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35,
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
59,
61,
63,
65
],
[
67
],
[
69
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87,
89
],
[
91
],
[
95,
97
],
[
99
],
[
103,
105
],
[
107
],
[
111,
113
],
[
115
],
[
119,
121
],
[
123
],
[
127,
129
],
[
131
],
[
135,
137
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
163
],
[
167
],
[
171
],
[
173
],
[
175,
177
],
[
179
],
[
181
],
[
183
],
[
185,
187
],
[
189
],
[
191
],
[
195,
197
],
[
201,
203
],
[
205
],
[
207
],
[
211,
213
],
[
217,
219
],
[
221
],
[
223
],
[
227,
229,
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241,
243
],
[
245
],
[
247,
249
],
[
251
],
[
253
],
[
255
],
[
259,
261
],
[
263
],
[
265
],
[
269,
271,
273
],
[
275
],
[
279,
281,
283,
285
],
[
287
],
[
291,
293,
295,
297
],
[
299
],
[
303,
305
],
[
307,
309
],
[
311,
313
],
[
315
],
[
319,
321,
323,
325
],
[
327
],
[
331,
333
],
[
335,
337
],
[
339,
341
],
[
343
],
[
347,
349,
351,
353
],
[
355
],
[
359,
361,
363,
365
],
[
367
],
[
371,
373,
375,
377
],
[
379
],
[
381,
383
],
[
385
],
[
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
],
[
443
],
[
447,
449,
451
],
[
453,
455
],
[
457,
459
],
[
461,
463
],
[
465,
467
],
[
469
],
[
471,
473
],
[
475,
477
],
[
479
],
[
481,
483
],
[
485,
487
],
[
489,
491
],
[
493
],
[
495,
497
],
[
501
],
[
503
],
[
507,
509
],
[
511,
513,
515
],
[
517
],
[
521,
523,
525
],
[
527
],
[
531,
533
],
[
535
],
[
537
],
[
541,
543
],
[
545
],
[
547
],
[
551,
553
],
[
555,
557
],
[
559,
561
],
[
563,
565
],
[
567
],
[
571,
575
],
[
579,
581
],
[
583
],
[
587,
589,
591,
593,
595
],
[
597,
599,
601,
603,
605,
607,
609,
611,
613,
615,
617,
619,
621,
623,
625,
627,
629,
631,
633,
635,
637
],
[
639
],
[
641
],
[
643
],
[
645,
647
],
[
653,
655
],
[
661
],
[
663
],
[
665,
667
],
[
669,
671
],
[
673
],
[
677,
679
],
[
681
],
[
685,
687
],
[
689
],
[
693,
695
],
[
697
],
[
701,
703
],
[
705
],
[
709,
711
],
[
713
],
[
715
],
[
719,
721
],
[
723
],
[
727,
729,
731
],
[
733,
735
],
[
737
],
[
739
],
[
743,
745
],
[
747
],
[
749
],
[
753,
755
],
[
757
],
[
759
],
[
761
],
[
763
],
[
767,
769
],
[
771
],
[
775,
777
],
[
779,
781
],
[
783,
785
],
[
787
],
[
789
],
[
793,
795
],
[
797
],
[
799
],
[
803,
805
],
[
807
],
[
809
],
[
813,
815
],
[
817
],
[
821,
823
],
[
825
],
[
829,
831
],
[
833
],
[
837,
839
],
[
841
],
[
845,
847
],
[
849
],
[
851,
853
],
[
855,
857
],
[
859
],
[
863,
865
],
[
867
],
[
869
],
[
879,
881
],
[
883
],
[
885,
887
],
[
889
],
[
891
],
[
895,
897,
899,
901
],
[
903
],
[
905
],
[
907
],
[
913
],
[
915,
917
],
[
919
],
[
921
],
[
923
],
[
925,
927
],
[
929
],
[
933
],
[
935,
937
],
[
939
],
[
941
],
[
943
],
[
945
],
[
947
],
[
949,
951
],
[
953
],
[
957,
959
],
[
961
],
[
963
],
[
965
],
[
967,
969
],
[
971,
973,
975
],
[
977
],
[
979
],
[
981,
983
],
[
987
],
[
989
],
[
991,
993
],
[
995
],
[
997
],
[
999
],
[
1001,
1003
],
[
1005
],
[
1009
],
[
1011,
1013
],
[
1015
],
[
1017
],
[
1019
],
[
1021
],
[
1023
],
[
1025,
1027
],
[
1029
],
[
1031,
1033
],
[
1035
],
[
1037
],
[
1039
],
[
1041,
1043
],
[
1045,
1047
],
[
1049
],
[
1051
],
[
1053,
1055
],
[
1059,
1061,
1063
],
[
1065
],
[
1067,
1069
],
[
1071
],
[
1075,
1077
],
[
1079,
1081,
1083,
1085,
1087,
1089,
1091,
1093
],
[
1095
],
[
1097
],
[
1101,
1103
],
[
1105
],
[
1107
],
[
1109
],
[
1111
],
[
1113
],
[
1115
],
[
1117
],
[
1119
],
[
1121
],
[
1123
],
[
1125
],
[
1127
],
[
1129,
1131,
1133
],
[
1135
],
[
1139,
1141,
1143
],
[
1145
],
[
1147
],
[
1149,
1151
],
[
1153
],
[
1155,
1157
],
[
1159
],
[
1161
],
[
1165,
1167
],
[
1169
],
[
1173,
1175
],
[
1177,
1179
],
[
1181,
1185
],
[
1187
],
[
1189
],
[
1193,
1195
],
[
1197
],
[
1201,
1203
],
[
1205
],
[
1209
],
[
1211
],
[
1213
],
[
1217,
1219
],
[
1221
],
[
1223
],
[
1227,
1229
],
[
1231
],
[
1233
],
[
1235
],
[
1237,
1239,
1241
],
[
1243
],
[
1245
],
[
1249,
1251
],
[
1253
],
[
1257
],
[
1259
]
] |
8,060 |
static bool migration_object_check(MigrationState *ms, Error **errp)
{
if (!migrate_params_check(&ms->parameters, errp)) {
return false;
}
return true;
}
| false |
qemu
|
6b19a7d91c8de9904c67b87203a46e55db4181ab
|
static bool migration_object_check(MigrationState *ms, Error **errp)
{
if (!migrate_params_check(&ms->parameters, errp)) {
return false;
}
return true;
}
|
{
"code": [],
"line_no": []
}
|
static bool FUNC_0(MigrationState *ms, Error **errp)
{
if (!migrate_params_check(&ms->parameters, errp)) {
return false;
}
return true;
}
|
[
"static bool FUNC_0(MigrationState *ms, Error **errp)\n{",
"if (!migrate_params_check(&ms->parameters, errp)) {",
"return false;",
"}",
"return true;",
"}"
] |
[
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
]
] |
8,061 |
static MigrationState *migrate_init(Monitor *mon, int detach, int blk, int inc)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
memset(s, 0, sizeof(*s));
s->bandwidth_limit = bandwidth_limit;
s->blk = blk;
s->shared = inc;
/* s->mon is used for two things:
- pass fd in fd migration
- suspend/resume monitor for not detached migration
*/
s->mon = mon;
s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP;
if (!detach) {
migrate_fd_monitor_suspend(s, mon);
}
return s;
}
| false |
qemu
|
e1c37d0e94048502f9874e6356ce7136d4b05bdb
|
static MigrationState *migrate_init(Monitor *mon, int detach, int blk, int inc)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
memset(s, 0, sizeof(*s));
s->bandwidth_limit = bandwidth_limit;
s->blk = blk;
s->shared = inc;
s->mon = mon;
s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP;
if (!detach) {
migrate_fd_monitor_suspend(s, mon);
}
return s;
}
|
{
"code": [],
"line_no": []
}
|
static MigrationState *FUNC_0(Monitor *mon, int detach, int blk, int inc)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
memset(s, 0, sizeof(*s));
s->bandwidth_limit = bandwidth_limit;
s->blk = blk;
s->shared = inc;
s->mon = mon;
s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP;
if (!detach) {
migrate_fd_monitor_suspend(s, mon);
}
return s;
}
|
[
"static MigrationState *FUNC_0(Monitor *mon, int detach, int blk, int inc)\n{",
"MigrationState *s = migrate_get_current();",
"int64_t bandwidth_limit = s->bandwidth_limit;",
"memset(s, 0, sizeof(*s));",
"s->bandwidth_limit = bandwidth_limit;",
"s->blk = blk;",
"s->shared = inc;",
"s->mon = mon;",
"s->bandwidth_limit = bandwidth_limit;",
"s->state = MIG_STATE_SETUP;",
"if (!detach) {",
"migrate_fd_monitor_suspend(s, mon);",
"}",
"return s;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
]
] |
8,062 |
static int find_pte64(CPUPPCState *env, mmu_ctx_t *ctx, int h,
int rw, int type, int target_page_bits)
{
hwaddr pteg_off;
target_ulong pte0, pte1;
int i, good = -1;
int ret, r;
ret = -1; /* No entry found */
pteg_off = get_pteg_offset(env, ctx->hash[h], HASH_PTE_SIZE_64);
for (i = 0; i < 8; i++) {
if (env->external_htab) {
pte0 = ldq_p(env->external_htab + pteg_off + (i * 16));
pte1 = ldq_p(env->external_htab + pteg_off + (i * 16) + 8);
} else {
pte0 = ldq_phys(env->htab_base + pteg_off + (i * 16));
pte1 = ldq_phys(env->htab_base + pteg_off + (i * 16) + 8);
}
r = pte64_check(ctx, pte0, pte1, h, rw, type);
LOG_MMU("Load pte from %016" HWADDR_PRIx " => " TARGET_FMT_lx " "
TARGET_FMT_lx " %d %d %d " TARGET_FMT_lx "\n",
pteg_off + (i * 16), pte0, pte1, (int)(pte0 & 1), h,
(int)((pte0 >> 1) & 1), ctx->ptem);
switch (r) {
case -3:
/* PTE inconsistency */
return -1;
case -2:
/* Access violation */
ret = -2;
good = i;
break;
case -1:
default:
/* No PTE match */
break;
case 0:
/* access granted */
/* XXX: we should go on looping to check all PTEs consistency
* but if we can speed-up the whole thing as the
* result would be undefined if PTEs are not consistent.
*/
ret = 0;
good = i;
goto done;
}
}
if (good != -1) {
done:
LOG_MMU("found PTE at addr %08" HWADDR_PRIx " prot=%01x ret=%d\n",
ctx->raddr, ctx->prot, ret);
/* Update page flags */
pte1 = ctx->raddr;
if (pte_update_flags(ctx, &pte1, ret, rw) == 1) {
if (env->external_htab) {
stq_p(env->external_htab + pteg_off + (good * 16) + 8,
pte1);
} else {
stq_phys_notdirty(env->htab_base + pteg_off +
(good * 16) + 8, pte1);
}
}
}
/* We have a TLB that saves 4K pages, so let's
* split a huge page to 4k chunks */
if (target_page_bits != TARGET_PAGE_BITS) {
ctx->raddr |= (ctx->eaddr & ((1 << target_page_bits) - 1))
& TARGET_PAGE_MASK;
}
return ret;
}
| false |
qemu
|
496272a7018ba01aa2b87a1a5ed866ff85133401
|
static int find_pte64(CPUPPCState *env, mmu_ctx_t *ctx, int h,
int rw, int type, int target_page_bits)
{
hwaddr pteg_off;
target_ulong pte0, pte1;
int i, good = -1;
int ret, r;
ret = -1;
pteg_off = get_pteg_offset(env, ctx->hash[h], HASH_PTE_SIZE_64);
for (i = 0; i < 8; i++) {
if (env->external_htab) {
pte0 = ldq_p(env->external_htab + pteg_off + (i * 16));
pte1 = ldq_p(env->external_htab + pteg_off + (i * 16) + 8);
} else {
pte0 = ldq_phys(env->htab_base + pteg_off + (i * 16));
pte1 = ldq_phys(env->htab_base + pteg_off + (i * 16) + 8);
}
r = pte64_check(ctx, pte0, pte1, h, rw, type);
LOG_MMU("Load pte from %016" HWADDR_PRIx " => " TARGET_FMT_lx " "
TARGET_FMT_lx " %d %d %d " TARGET_FMT_lx "\n",
pteg_off + (i * 16), pte0, pte1, (int)(pte0 & 1), h,
(int)((pte0 >> 1) & 1), ctx->ptem);
switch (r) {
case -3:
return -1;
case -2:
ret = -2;
good = i;
break;
case -1:
default:
break;
case 0:
ret = 0;
good = i;
goto done;
}
}
if (good != -1) {
done:
LOG_MMU("found PTE at addr %08" HWADDR_PRIx " prot=%01x ret=%d\n",
ctx->raddr, ctx->prot, ret);
pte1 = ctx->raddr;
if (pte_update_flags(ctx, &pte1, ret, rw) == 1) {
if (env->external_htab) {
stq_p(env->external_htab + pteg_off + (good * 16) + 8,
pte1);
} else {
stq_phys_notdirty(env->htab_base + pteg_off +
(good * 16) + 8, pte1);
}
}
}
if (target_page_bits != TARGET_PAGE_BITS) {
ctx->raddr |= (ctx->eaddr & ((1 << target_page_bits) - 1))
& TARGET_PAGE_MASK;
}
return ret;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(CPUPPCState *VAR_0, mmu_ctx_t *VAR_1, int VAR_2,
int VAR_3, int VAR_4, int VAR_5)
{
hwaddr pteg_off;
target_ulong pte0, pte1;
int VAR_6, VAR_7 = -1;
int VAR_8, VAR_9;
VAR_8 = -1;
pteg_off = get_pteg_offset(VAR_0, VAR_1->hash[VAR_2], HASH_PTE_SIZE_64);
for (VAR_6 = 0; VAR_6 < 8; VAR_6++) {
if (VAR_0->external_htab) {
pte0 = ldq_p(VAR_0->external_htab + pteg_off + (VAR_6 * 16));
pte1 = ldq_p(VAR_0->external_htab + pteg_off + (VAR_6 * 16) + 8);
} else {
pte0 = ldq_phys(VAR_0->htab_base + pteg_off + (VAR_6 * 16));
pte1 = ldq_phys(VAR_0->htab_base + pteg_off + (VAR_6 * 16) + 8);
}
VAR_9 = pte64_check(VAR_1, pte0, pte1, VAR_2, VAR_3, VAR_4);
LOG_MMU("Load pte from %016" HWADDR_PRIx " => " TARGET_FMT_lx " "
TARGET_FMT_lx " %d %d %d " TARGET_FMT_lx "\n",
pteg_off + (VAR_6 * 16), pte0, pte1, (int)(pte0 & 1), VAR_2,
(int)((pte0 >> 1) & 1), VAR_1->ptem);
switch (VAR_9) {
case -3:
return -1;
case -2:
VAR_8 = -2;
VAR_7 = VAR_6;
break;
case -1:
default:
break;
case 0:
VAR_8 = 0;
VAR_7 = VAR_6;
goto done;
}
}
if (VAR_7 != -1) {
done:
LOG_MMU("found PTE at addr %08" HWADDR_PRIx " prot=%01x VAR_8=%d\n",
VAR_1->raddr, VAR_1->prot, VAR_8);
pte1 = VAR_1->raddr;
if (pte_update_flags(VAR_1, &pte1, VAR_8, VAR_3) == 1) {
if (VAR_0->external_htab) {
stq_p(VAR_0->external_htab + pteg_off + (VAR_7 * 16) + 8,
pte1);
} else {
stq_phys_notdirty(VAR_0->htab_base + pteg_off +
(VAR_7 * 16) + 8, pte1);
}
}
}
if (VAR_5 != TARGET_PAGE_BITS) {
VAR_1->raddr |= (VAR_1->eaddr & ((1 << VAR_5) - 1))
& TARGET_PAGE_MASK;
}
return VAR_8;
}
|
[
"static int FUNC_0(CPUPPCState *VAR_0, mmu_ctx_t *VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int VAR_5)\n{",
"hwaddr pteg_off;",
"target_ulong pte0, pte1;",
"int VAR_6, VAR_7 = -1;",
"int VAR_8, VAR_9;",
"VAR_8 = -1;",
"pteg_off = get_pteg_offset(VAR_0, VAR_1->hash[VAR_2], HASH_PTE_SIZE_64);",
"for (VAR_6 = 0; VAR_6 < 8; VAR_6++) {",
"if (VAR_0->external_htab) {",
"pte0 = ldq_p(VAR_0->external_htab + pteg_off + (VAR_6 * 16));",
"pte1 = ldq_p(VAR_0->external_htab + pteg_off + (VAR_6 * 16) + 8);",
"} else {",
"pte0 = ldq_phys(VAR_0->htab_base + pteg_off + (VAR_6 * 16));",
"pte1 = ldq_phys(VAR_0->htab_base + pteg_off + (VAR_6 * 16) + 8);",
"}",
"VAR_9 = pte64_check(VAR_1, pte0, pte1, VAR_2, VAR_3, VAR_4);",
"LOG_MMU(\"Load pte from %016\" HWADDR_PRIx \" => \" TARGET_FMT_lx \" \"\nTARGET_FMT_lx \" %d %d %d \" TARGET_FMT_lx \"\\n\",\npteg_off + (VAR_6 * 16), pte0, pte1, (int)(pte0 & 1), VAR_2,\n(int)((pte0 >> 1) & 1), VAR_1->ptem);",
"switch (VAR_9) {",
"case -3:\nreturn -1;",
"case -2:\nVAR_8 = -2;",
"VAR_7 = VAR_6;",
"break;",
"case -1:\ndefault:\nbreak;",
"case 0:\nVAR_8 = 0;",
"VAR_7 = VAR_6;",
"goto done;",
"}",
"}",
"if (VAR_7 != -1) {",
"done:\nLOG_MMU(\"found PTE at addr %08\" HWADDR_PRIx \" prot=%01x VAR_8=%d\\n\",\nVAR_1->raddr, VAR_1->prot, VAR_8);",
"pte1 = VAR_1->raddr;",
"if (pte_update_flags(VAR_1, &pte1, VAR_8, VAR_3) == 1) {",
"if (VAR_0->external_htab) {",
"stq_p(VAR_0->external_htab + pteg_off + (VAR_7 * 16) + 8,\npte1);",
"} else {",
"stq_phys_notdirty(VAR_0->htab_base + pteg_off +\n(VAR_7 * 16) + 8, pte1);",
"}",
"}",
"}",
"if (VAR_5 != TARGET_PAGE_BITS) {",
"VAR_1->raddr |= (VAR_1->eaddr & ((1 << VAR_5) - 1))\n& TARGET_PAGE_MASK;",
"}",
"return VAR_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,
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
],
[
39
],
[
41,
43,
45,
47
],
[
49
],
[
51,
55
],
[
57,
61
],
[
63
],
[
65
],
[
67,
69,
73
],
[
75,
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99,
101,
103
],
[
107
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
119,
121
],
[
123
],
[
125
],
[
127
],
[
135
],
[
137,
139
],
[
141
],
[
143
],
[
145
]
] |
8,063 |
static int qcow2_mark_dirty(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
uint64_t val;
int ret;
assert(s->qcow_version >= 3);
if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
return 0; /* already dirty */
}
val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
&val, sizeof(val));
if (ret < 0) {
return ret;
}
ret = bdrv_flush(bs->file);
if (ret < 0) {
return ret;
}
/* Only treat image as dirty if the header was updated successfully */
s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
return 0;
}
| false |
qemu
|
280d373579558f73a8b70e329d9a6206933d3809
|
static int qcow2_mark_dirty(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
uint64_t val;
int ret;
assert(s->qcow_version >= 3);
if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
return 0;
}
val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
&val, sizeof(val));
if (ret < 0) {
return ret;
}
ret = bdrv_flush(bs->file);
if (ret < 0) {
return ret;
}
s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(BlockDriverState *VAR_0)
{
BDRVQcowState *s = VAR_0->opaque;
uint64_t val;
int VAR_1;
assert(s->qcow_version >= 3);
if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
return 0;
}
val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
VAR_1 = bdrv_pwrite(VAR_0->file, offsetof(QCowHeader, incompatible_features),
&val, sizeof(val));
if (VAR_1 < 0) {
return VAR_1;
}
VAR_1 = bdrv_flush(VAR_0->file);
if (VAR_1 < 0) {
return VAR_1;
}
s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
return 0;
}
|
[
"static int FUNC_0(BlockDriverState *VAR_0)\n{",
"BDRVQcowState *s = VAR_0->opaque;",
"uint64_t val;",
"int VAR_1;",
"assert(s->qcow_version >= 3);",
"if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {",
"return 0;",
"}",
"val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);",
"VAR_1 = bdrv_pwrite(VAR_0->file, offsetof(QCowHeader, incompatible_features),\n&val, sizeof(val));",
"if (VAR_1 < 0) {",
"return VAR_1;",
"}",
"VAR_1 = bdrv_flush(VAR_0->file);",
"if (VAR_1 < 0) {",
"return VAR_1;",
"}",
"s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;",
"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
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
49
],
[
51
],
[
53
]
] |
8,064 |
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
int bpno, int bandno)
{
int mask = 3 << (bpno - 1), y0, x, y;
for (y0 = 0; y0 < height; y0 += 4)
for (x = 0; x < width; x++)
for (y = y0; y < height && y < y0 + 4; y++)
if ((t1->flags[y + 1][x + 1] & JPEG2000_T1_SIG_NB)
&& !(t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
if (ff_mqc_decode(&t1->mqc,
t1->mqc.cx_states +
ff_jpeg2000_getsigctxno(t1->flags[y + 1][x + 1],
bandno))) {
int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
&xorbit);
t1->data[y][x] =
(ff_mqc_decode(&t1->mqc,
t1->mqc.cx_states + ctxno) ^ xorbit)
? -mask : mask;
ff_jpeg2000_set_significance(t1, x, y,
t1->data[y][x] < 0);
}
t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
}
}
| false |
FFmpeg
|
64f6570c6e2c5a0344383e89c7897809f0c6e1f1
|
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
int bpno, int bandno)
{
int mask = 3 << (bpno - 1), y0, x, y;
for (y0 = 0; y0 < height; y0 += 4)
for (x = 0; x < width; x++)
for (y = y0; y < height && y < y0 + 4; y++)
if ((t1->flags[y + 1][x + 1] & JPEG2000_T1_SIG_NB)
&& !(t1->flags[y + 1][x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
if (ff_mqc_decode(&t1->mqc,
t1->mqc.cx_states +
ff_jpeg2000_getsigctxno(t1->flags[y + 1][x + 1],
bandno))) {
int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[y + 1][x + 1],
&xorbit);
t1->data[y][x] =
(ff_mqc_decode(&t1->mqc,
t1->mqc.cx_states + ctxno) ^ xorbit)
? -mask : mask;
ff_jpeg2000_set_significance(t1, x, y,
t1->data[y][x] < 0);
}
t1->flags[y + 1][x + 1] |= JPEG2000_T1_VIS;
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(Jpeg2000T1Context *VAR_0, int VAR_1, int VAR_2,
int VAR_3, int VAR_4)
{
int VAR_5 = 3 << (VAR_3 - 1), VAR_6, VAR_7, VAR_8;
for (VAR_6 = 0; VAR_6 < VAR_2; VAR_6 += 4)
for (VAR_7 = 0; VAR_7 < VAR_1; VAR_7++)
for (VAR_8 = VAR_6; VAR_8 < VAR_2 && VAR_8 < VAR_6 + 4; VAR_8++)
if ((VAR_0->flags[VAR_8 + 1][VAR_7 + 1] & JPEG2000_T1_SIG_NB)
&& !(VAR_0->flags[VAR_8 + 1][VAR_7 + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
if (ff_mqc_decode(&VAR_0->mqc,
VAR_0->mqc.cx_states +
ff_jpeg2000_getsigctxno(VAR_0->flags[VAR_8 + 1][VAR_7 + 1],
VAR_4))) {
int VAR_9, VAR_10 = ff_jpeg2000_getsgnctxno(VAR_0->flags[VAR_8 + 1][VAR_7 + 1],
&VAR_9);
VAR_0->data[VAR_8][VAR_7] =
(ff_mqc_decode(&VAR_0->mqc,
VAR_0->mqc.cx_states + VAR_10) ^ VAR_9)
? -VAR_5 : VAR_5;
ff_jpeg2000_set_significance(VAR_0, VAR_7, VAR_8,
VAR_0->data[VAR_8][VAR_7] < 0);
}
VAR_0->flags[VAR_8 + 1][VAR_7 + 1] |= JPEG2000_T1_VIS;
}
}
|
[
"static void FUNC_0(Jpeg2000T1Context *VAR_0, int VAR_1, int VAR_2,\nint VAR_3, int VAR_4)\n{",
"int VAR_5 = 3 << (VAR_3 - 1), VAR_6, VAR_7, VAR_8;",
"for (VAR_6 = 0; VAR_6 < VAR_2; VAR_6 += 4)",
"for (VAR_7 = 0; VAR_7 < VAR_1; VAR_7++)",
"for (VAR_8 = VAR_6; VAR_8 < VAR_2 && VAR_8 < VAR_6 + 4; VAR_8++)",
"if ((VAR_0->flags[VAR_8 + 1][VAR_7 + 1] & JPEG2000_T1_SIG_NB)\n&& !(VAR_0->flags[VAR_8 + 1][VAR_7 + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {",
"if (ff_mqc_decode(&VAR_0->mqc,\nVAR_0->mqc.cx_states +\nff_jpeg2000_getsigctxno(VAR_0->flags[VAR_8 + 1][VAR_7 + 1],\nVAR_4))) {",
"int VAR_9, VAR_10 = ff_jpeg2000_getsgnctxno(VAR_0->flags[VAR_8 + 1][VAR_7 + 1],\n&VAR_9);",
"VAR_0->data[VAR_8][VAR_7] =\n(ff_mqc_decode(&VAR_0->mqc,\nVAR_0->mqc.cx_states + VAR_10) ^ VAR_9)\n? -VAR_5 : VAR_5;",
"ff_jpeg2000_set_significance(VAR_0, VAR_7, VAR_8,\nVAR_0->data[VAR_8][VAR_7] < 0);",
"}",
"VAR_0->flags[VAR_8 + 1][VAR_7 + 1] |= JPEG2000_T1_VIS;",
"}",
"}"
] |
[
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
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
]
] |
8,066 |
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
{
uint8_t Stlm, ST, SP, tile_tlm, i;
bytestream_get_byte(&s->buf); /* Ztlm: skipped */
Stlm = bytestream_get_byte(&s->buf);
// too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
ST = (Stlm >> 4) & 0x03;
// TODO: Manage case of ST = 0b11 --> raise error
SP = (Stlm >> 6) & 0x01;
tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
for (i = 0; i < tile_tlm; i++) {
switch (ST) {
case 0:
break;
case 1:
bytestream_get_byte(&s->buf);
break;
case 2:
bytestream_get_be16(&s->buf);
break;
case 3:
bytestream_get_be32(&s->buf);
break;
}
if (SP == 0) {
bytestream_get_be16(&s->buf);
} else {
bytestream_get_be32(&s->buf);
}
}
return 0;
}
| false |
FFmpeg
|
0b42631641d998e509cde6fa344edc6ab5cb4ac8
|
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
{
uint8_t Stlm, ST, SP, tile_tlm, i;
bytestream_get_byte(&s->buf);
Stlm = bytestream_get_byte(&s->buf);
ST = (Stlm >> 4) & 0x03;
SP = (Stlm >> 6) & 0x01;
tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
for (i = 0; i < tile_tlm; i++) {
switch (ST) {
case 0:
break;
case 1:
bytestream_get_byte(&s->buf);
break;
case 2:
bytestream_get_be16(&s->buf);
break;
case 3:
bytestream_get_be32(&s->buf);
break;
}
if (SP == 0) {
bytestream_get_be16(&s->buf);
} else {
bytestream_get_be32(&s->buf);
}
}
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static uint8_t FUNC_0(Jpeg2000DecoderContext *s, int n)
{
uint8_t Stlm, ST, SP, tile_tlm, i;
bytestream_get_byte(&s->buf);
Stlm = bytestream_get_byte(&s->buf);
ST = (Stlm >> 4) & 0x03;
SP = (Stlm >> 6) & 0x01;
tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
for (i = 0; i < tile_tlm; i++) {
switch (ST) {
case 0:
break;
case 1:
bytestream_get_byte(&s->buf);
break;
case 2:
bytestream_get_be16(&s->buf);
break;
case 3:
bytestream_get_be32(&s->buf);
break;
}
if (SP == 0) {
bytestream_get_be16(&s->buf);
} else {
bytestream_get_be32(&s->buf);
}
}
return 0;
}
|
[
"static uint8_t FUNC_0(Jpeg2000DecoderContext *s, int n)\n{",
"uint8_t Stlm, ST, SP, tile_tlm, i;",
"bytestream_get_byte(&s->buf);",
"Stlm = bytestream_get_byte(&s->buf);",
"ST = (Stlm >> 4) & 0x03;",
"SP = (Stlm >> 6) & 0x01;",
"tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);",
"for (i = 0; i < tile_tlm; i++) {",
"switch (ST) {",
"case 0:\nbreak;",
"case 1:\nbytestream_get_byte(&s->buf);",
"break;",
"case 2:\nbytestream_get_be16(&s->buf);",
"break;",
"case 3:\nbytestream_get_be32(&s->buf);",
"break;",
"}",
"if (SP == 0) {",
"bytestream_get_be16(&s->buf);",
"} else {",
"bytestream_get_be32(&s->buf);",
"}",
"}",
"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
],
[
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
]
] |
8,067 |
static void esp_pci_io_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned int size)
{
PCIESPState *pci = opaque;
if (size < 4 || addr & 3) {
/* need to upgrade request: we only support 4-bytes accesses */
uint32_t current = 0, mask;
int shift;
if (addr < 0x40) {
current = pci->esp.wregs[addr >> 2];
} else if (addr < 0x60) {
current = pci->dma_regs[(addr - 0x40) >> 2];
} else if (addr < 0x74) {
current = pci->sbac;
}
shift = (4 - size) * 8;
mask = (~(uint32_t)0 << shift) >> shift;
shift = ((4 - (addr & 3)) & 3) * 8;
val <<= shift;
val |= current & ~(mask << shift);
addr &= ~3;
size = 4;
}
if (addr < 0x40) {
/* SCSI core reg */
esp_reg_write(&pci->esp, addr >> 2, val);
} else if (addr < 0x60) {
/* PCI DMA CCB */
esp_pci_dma_write(pci, (addr - 0x40) >> 2, val);
} else if (addr == 0x70) {
/* DMA SCSI Bus and control */
trace_esp_pci_sbac_write(pci->sbac, val);
pci->sbac = val;
} else {
trace_esp_pci_error_invalid_write((int)addr);
}
}
| false |
qemu
|
a8170e5e97ad17ca169c64ba87ae2f53850dab4c
|
static void esp_pci_io_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned int size)
{
PCIESPState *pci = opaque;
if (size < 4 || addr & 3) {
uint32_t current = 0, mask;
int shift;
if (addr < 0x40) {
current = pci->esp.wregs[addr >> 2];
} else if (addr < 0x60) {
current = pci->dma_regs[(addr - 0x40) >> 2];
} else if (addr < 0x74) {
current = pci->sbac;
}
shift = (4 - size) * 8;
mask = (~(uint32_t)0 << shift) >> shift;
shift = ((4 - (addr & 3)) & 3) * 8;
val <<= shift;
val |= current & ~(mask << shift);
addr &= ~3;
size = 4;
}
if (addr < 0x40) {
esp_reg_write(&pci->esp, addr >> 2, val);
} else if (addr < 0x60) {
esp_pci_dma_write(pci, (addr - 0x40) >> 2, val);
} else if (addr == 0x70) {
trace_esp_pci_sbac_write(pci->sbac, val);
pci->sbac = val;
} else {
trace_esp_pci_error_invalid_write((int)addr);
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned int VAR_3)
{
PCIESPState *pci = VAR_0;
if (VAR_3 < 4 || VAR_1 & 3) {
uint32_t current = 0, mask;
int VAR_4;
if (VAR_1 < 0x40) {
current = pci->esp.wregs[VAR_1 >> 2];
} else if (VAR_1 < 0x60) {
current = pci->dma_regs[(VAR_1 - 0x40) >> 2];
} else if (VAR_1 < 0x74) {
current = pci->sbac;
}
VAR_4 = (4 - VAR_3) * 8;
mask = (~(uint32_t)0 << VAR_4) >> VAR_4;
VAR_4 = ((4 - (VAR_1 & 3)) & 3) * 8;
VAR_2 <<= VAR_4;
VAR_2 |= current & ~(mask << VAR_4);
VAR_1 &= ~3;
VAR_3 = 4;
}
if (VAR_1 < 0x40) {
esp_reg_write(&pci->esp, VAR_1 >> 2, VAR_2);
} else if (VAR_1 < 0x60) {
esp_pci_dma_write(pci, (VAR_1 - 0x40) >> 2, VAR_2);
} else if (VAR_1 == 0x70) {
trace_esp_pci_sbac_write(pci->sbac, VAR_2);
pci->sbac = VAR_2;
} else {
trace_esp_pci_error_invalid_write((int)VAR_1);
}
}
|
[
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned int VAR_3)\n{",
"PCIESPState *pci = VAR_0;",
"if (VAR_3 < 4 || VAR_1 & 3) {",
"uint32_t current = 0, mask;",
"int VAR_4;",
"if (VAR_1 < 0x40) {",
"current = pci->esp.wregs[VAR_1 >> 2];",
"} else if (VAR_1 < 0x60) {",
"current = pci->dma_regs[(VAR_1 - 0x40) >> 2];",
"} else if (VAR_1 < 0x74) {",
"current = pci->sbac;",
"}",
"VAR_4 = (4 - VAR_3) * 8;",
"mask = (~(uint32_t)0 << VAR_4) >> VAR_4;",
"VAR_4 = ((4 - (VAR_1 & 3)) & 3) * 8;",
"VAR_2 <<= VAR_4;",
"VAR_2 |= current & ~(mask << VAR_4);",
"VAR_1 &= ~3;",
"VAR_3 = 4;",
"}",
"if (VAR_1 < 0x40) {",
"esp_reg_write(&pci->esp, VAR_1 >> 2, VAR_2);",
"} else if (VAR_1 < 0x60) {",
"esp_pci_dma_write(pci, (VAR_1 - 0x40) >> 2, VAR_2);",
"} else if (VAR_1 == 0x70) {",
"trace_esp_pci_sbac_write(pci->sbac, VAR_2);",
"pci->sbac = VAR_2;",
"} else {",
"trace_esp_pci_error_invalid_write((int)VAR_1);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
61
],
[
63
],
[
67
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
]
] |
8,068 |
static void spice_update_buttons(QemuSpicePointer *pointer,
int wheel, uint32_t button_mask)
{
static uint32_t bmap[INPUT_BUTTON__MAX] = {
[INPUT_BUTTON_LEFT] = 0x01,
[INPUT_BUTTON_MIDDLE] = 0x04,
[INPUT_BUTTON_RIGHT] = 0x02,
[INPUT_BUTTON_WHEEL_UP] = 0x10,
[INPUT_BUTTON_WHEEL_DOWN] = 0x20,
};
if (wheel < 0) {
button_mask |= 0x10;
}
if (wheel > 0) {
button_mask |= 0x20;
}
if (pointer->last_bmask == button_mask) {
return;
}
qemu_input_update_buttons(NULL, bmap, pointer->last_bmask, button_mask);
pointer->last_bmask = button_mask;
}
| false |
qemu
|
d20a580bc0eac9d489884f6d2ed28105880532b6
|
static void spice_update_buttons(QemuSpicePointer *pointer,
int wheel, uint32_t button_mask)
{
static uint32_t bmap[INPUT_BUTTON__MAX] = {
[INPUT_BUTTON_LEFT] = 0x01,
[INPUT_BUTTON_MIDDLE] = 0x04,
[INPUT_BUTTON_RIGHT] = 0x02,
[INPUT_BUTTON_WHEEL_UP] = 0x10,
[INPUT_BUTTON_WHEEL_DOWN] = 0x20,
};
if (wheel < 0) {
button_mask |= 0x10;
}
if (wheel > 0) {
button_mask |= 0x20;
}
if (pointer->last_bmask == button_mask) {
return;
}
qemu_input_update_buttons(NULL, bmap, pointer->last_bmask, button_mask);
pointer->last_bmask = button_mask;
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(QemuSpicePointer *VAR_0,
int VAR_1, uint32_t VAR_2)
{
static uint32_t VAR_3[INPUT_BUTTON__MAX] = {
[INPUT_BUTTON_LEFT] = 0x01,
[INPUT_BUTTON_MIDDLE] = 0x04,
[INPUT_BUTTON_RIGHT] = 0x02,
[INPUT_BUTTON_WHEEL_UP] = 0x10,
[INPUT_BUTTON_WHEEL_DOWN] = 0x20,
};
if (VAR_1 < 0) {
VAR_2 |= 0x10;
}
if (VAR_1 > 0) {
VAR_2 |= 0x20;
}
if (VAR_0->last_bmask == VAR_2) {
return;
}
qemu_input_update_buttons(NULL, VAR_3, VAR_0->last_bmask, VAR_2);
VAR_0->last_bmask = VAR_2;
}
|
[
"static void FUNC_0(QemuSpicePointer *VAR_0,\nint VAR_1, uint32_t VAR_2)\n{",
"static uint32_t VAR_3[INPUT_BUTTON__MAX] = {",
"[INPUT_BUTTON_LEFT] = 0x01,\n[INPUT_BUTTON_MIDDLE] = 0x04,\n[INPUT_BUTTON_RIGHT] = 0x02,\n[INPUT_BUTTON_WHEEL_UP] = 0x10,\n[INPUT_BUTTON_WHEEL_DOWN] = 0x20,\n};",
"if (VAR_1 < 0) {",
"VAR_2 |= 0x10;",
"}",
"if (VAR_1 > 0) {",
"VAR_2 |= 0x20;",
"}",
"if (VAR_0->last_bmask == VAR_2) {",
"return;",
"}",
"qemu_input_update_buttons(NULL, VAR_3, VAR_0->last_bmask, VAR_2);",
"VAR_0->last_bmask = VAR_2;",
"}"
] |
[
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
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
]
] |
8,069 |
Slirp *slirp_init(int restricted, struct in_addr vnetwork,
struct in_addr vnetmask, struct in_addr vhost,
const char *vhostname, const char *tftp_path,
const char *bootfile, struct in_addr vdhcp_start,
struct in_addr vnameserver, void *opaque)
{
Slirp *slirp = qemu_mallocz(sizeof(Slirp));
slirp_init_once();
slirp->restricted = restricted;
if_init(slirp);
ip_init(slirp);
/* Initialise mbufs *after* setting the MTU */
m_init(slirp);
slirp->vnetwork_addr = vnetwork;
slirp->vnetwork_mask = vnetmask;
slirp->vhost_addr = vhost;
if (vhostname) {
pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
vhostname);
}
if (tftp_path) {
slirp->tftp_prefix = qemu_strdup(tftp_path);
}
if (bootfile) {
slirp->bootp_filename = qemu_strdup(bootfile);
}
slirp->vdhcp_startaddr = vdhcp_start;
slirp->vnameserver_addr = vnameserver;
slirp->opaque = opaque;
register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp);
TAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
return slirp;
}
| false |
qemu
|
72cf2d4f0e181d0d3a3122e04129c58a95da713e
|
Slirp *slirp_init(int restricted, struct in_addr vnetwork,
struct in_addr vnetmask, struct in_addr vhost,
const char *vhostname, const char *tftp_path,
const char *bootfile, struct in_addr vdhcp_start,
struct in_addr vnameserver, void *opaque)
{
Slirp *slirp = qemu_mallocz(sizeof(Slirp));
slirp_init_once();
slirp->restricted = restricted;
if_init(slirp);
ip_init(slirp);
m_init(slirp);
slirp->vnetwork_addr = vnetwork;
slirp->vnetwork_mask = vnetmask;
slirp->vhost_addr = vhost;
if (vhostname) {
pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
vhostname);
}
if (tftp_path) {
slirp->tftp_prefix = qemu_strdup(tftp_path);
}
if (bootfile) {
slirp->bootp_filename = qemu_strdup(bootfile);
}
slirp->vdhcp_startaddr = vdhcp_start;
slirp->vnameserver_addr = vnameserver;
slirp->opaque = opaque;
register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp);
TAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
return slirp;
}
|
{
"code": [],
"line_no": []
}
|
Slirp *FUNC_0(int restricted, struct in_addr vnetwork,
struct in_addr vnetmask, struct in_addr vhost,
const char *vhostname, const char *tftp_path,
const char *bootfile, struct in_addr vdhcp_start,
struct in_addr vnameserver, void *opaque)
{
Slirp *slirp = qemu_mallocz(sizeof(Slirp));
slirp_init_once();
slirp->restricted = restricted;
if_init(slirp);
ip_init(slirp);
m_init(slirp);
slirp->vnetwork_addr = vnetwork;
slirp->vnetwork_mask = vnetmask;
slirp->vhost_addr = vhost;
if (vhostname) {
pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
vhostname);
}
if (tftp_path) {
slirp->tftp_prefix = qemu_strdup(tftp_path);
}
if (bootfile) {
slirp->bootp_filename = qemu_strdup(bootfile);
}
slirp->vdhcp_startaddr = vdhcp_start;
slirp->vnameserver_addr = vnameserver;
slirp->opaque = opaque;
register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp);
TAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
return slirp;
}
|
[
"Slirp *FUNC_0(int restricted, struct in_addr vnetwork,\nstruct in_addr vnetmask, struct in_addr vhost,\nconst char *vhostname, const char *tftp_path,\nconst char *bootfile, struct in_addr vdhcp_start,\nstruct in_addr vnameserver, void *opaque)\n{",
"Slirp *slirp = qemu_mallocz(sizeof(Slirp));",
"slirp_init_once();",
"slirp->restricted = restricted;",
"if_init(slirp);",
"ip_init(slirp);",
"m_init(slirp);",
"slirp->vnetwork_addr = vnetwork;",
"slirp->vnetwork_mask = vnetmask;",
"slirp->vhost_addr = vhost;",
"if (vhostname) {",
"pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),\nvhostname);",
"}",
"if (tftp_path) {",
"slirp->tftp_prefix = qemu_strdup(tftp_path);",
"}",
"if (bootfile) {",
"slirp->bootp_filename = qemu_strdup(bootfile);",
"}",
"slirp->vdhcp_startaddr = vdhcp_start;",
"slirp->vnameserver_addr = vnameserver;",
"slirp->opaque = opaque;",
"register_savevm(\"slirp\", 0, 3, slirp_state_save, slirp_state_load, slirp);",
"TAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);",
"return slirp;",
"}"
] |
[
0,
0,
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
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
73
],
[
77
],
[
81
],
[
83
]
] |
8,070 |
BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
Error **errp)
{
int64_t bitmap_size;
BdrvDirtyBitmap *bitmap;
assert((granularity & (granularity - 1)) == 0);
granularity >>= BDRV_SECTOR_BITS;
assert(granularity);
bitmap_size = bdrv_nb_sectors(bs);
if (bitmap_size < 0) {
error_setg_errno(errp, -bitmap_size, "could not get length of device");
errno = -bitmap_size;
return NULL;
}
bitmap = g_new0(BdrvDirtyBitmap, 1);
bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
return bitmap;
}
| false |
qemu
|
786a4ea82ec9c87e3a895cf41081029b285a5fe5
|
BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
Error **errp)
{
int64_t bitmap_size;
BdrvDirtyBitmap *bitmap;
assert((granularity & (granularity - 1)) == 0);
granularity >>= BDRV_SECTOR_BITS;
assert(granularity);
bitmap_size = bdrv_nb_sectors(bs);
if (bitmap_size < 0) {
error_setg_errno(errp, -bitmap_size, "could not get length of device");
errno = -bitmap_size;
return NULL;
}
bitmap = g_new0(BdrvDirtyBitmap, 1);
bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
return bitmap;
}
|
{
"code": [],
"line_no": []
}
|
BdrvDirtyBitmap *FUNC_0(BlockDriverState *bs, int granularity,
Error **errp)
{
int64_t bitmap_size;
BdrvDirtyBitmap *bitmap;
assert((granularity & (granularity - 1)) == 0);
granularity >>= BDRV_SECTOR_BITS;
assert(granularity);
bitmap_size = bdrv_nb_sectors(bs);
if (bitmap_size < 0) {
error_setg_errno(errp, -bitmap_size, "could not get length of device");
errno = -bitmap_size;
return NULL;
}
bitmap = g_new0(BdrvDirtyBitmap, 1);
bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
return bitmap;
}
|
[
"BdrvDirtyBitmap *FUNC_0(BlockDriverState *bs, int granularity,\nError **errp)\n{",
"int64_t bitmap_size;",
"BdrvDirtyBitmap *bitmap;",
"assert((granularity & (granularity - 1)) == 0);",
"granularity >>= BDRV_SECTOR_BITS;",
"assert(granularity);",
"bitmap_size = bdrv_nb_sectors(bs);",
"if (bitmap_size < 0) {",
"error_setg_errno(errp, -bitmap_size, \"could not get length of device\");",
"errno = -bitmap_size;",
"return NULL;",
"}",
"bitmap = g_new0(BdrvDirtyBitmap, 1);",
"bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);",
"QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);",
"return bitmap;",
"}"
] |
[
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
]
] |
8,072 |
static void mch_update_pciexbar(MCHPCIState *mch)
{
PCIDevice *pci_dev = PCI_DEVICE(mch);
BusState *bus = qdev_get_parent_bus(DEVICE(mch));
PCIExpressHost *pehb = PCIE_HOST_BRIDGE(bus->parent);
uint64_t pciexbar;
int enable;
uint64_t addr;
uint64_t addr_mask;
uint32_t length;
pciexbar = pci_get_quad(pci_dev->config + MCH_HOST_BRIDGE_PCIEXBAR);
enable = pciexbar & MCH_HOST_BRIDGE_PCIEXBAREN;
addr_mask = MCH_HOST_BRIDGE_PCIEXBAR_ADMSK;
switch (pciexbar & MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_MASK) {
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_256M:
length = 256 * 1024 * 1024;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_128M:
length = 128 * 1024 * 1024;
addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_128ADMSK |
MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_64M:
length = 64 * 1024 * 1024;
addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_RVD:
default:
enable = 0;
length = 0;
abort();
break;
}
addr = pciexbar & addr_mask;
pcie_host_mmcfg_update(pehb, enable, addr, length);
/* Leave enough space for the MCFG BAR */
/*
* TODO: this matches current bios behaviour, but it's not a power of two,
* which means an MTRR can't cover it exactly.
*/
if (enable) {
mch->pci_hole.begin = addr + length;
} else {
mch->pci_hole.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT;
}
}
| false |
qemu
|
a0efbf16604770b9d805bcf210ec29942321134f
|
static void mch_update_pciexbar(MCHPCIState *mch)
{
PCIDevice *pci_dev = PCI_DEVICE(mch);
BusState *bus = qdev_get_parent_bus(DEVICE(mch));
PCIExpressHost *pehb = PCIE_HOST_BRIDGE(bus->parent);
uint64_t pciexbar;
int enable;
uint64_t addr;
uint64_t addr_mask;
uint32_t length;
pciexbar = pci_get_quad(pci_dev->config + MCH_HOST_BRIDGE_PCIEXBAR);
enable = pciexbar & MCH_HOST_BRIDGE_PCIEXBAREN;
addr_mask = MCH_HOST_BRIDGE_PCIEXBAR_ADMSK;
switch (pciexbar & MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_MASK) {
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_256M:
length = 256 * 1024 * 1024;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_128M:
length = 128 * 1024 * 1024;
addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_128ADMSK |
MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_64M:
length = 64 * 1024 * 1024;
addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_RVD:
default:
enable = 0;
length = 0;
abort();
break;
}
addr = pciexbar & addr_mask;
pcie_host_mmcfg_update(pehb, enable, addr, length);
if (enable) {
mch->pci_hole.begin = addr + length;
} else {
mch->pci_hole.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT;
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(MCHPCIState *VAR_0)
{
PCIDevice *pci_dev = PCI_DEVICE(VAR_0);
BusState *bus = qdev_get_parent_bus(DEVICE(VAR_0));
PCIExpressHost *pehb = PCIE_HOST_BRIDGE(bus->parent);
uint64_t pciexbar;
int VAR_1;
uint64_t addr;
uint64_t addr_mask;
uint32_t length;
pciexbar = pci_get_quad(pci_dev->config + MCH_HOST_BRIDGE_PCIEXBAR);
VAR_1 = pciexbar & MCH_HOST_BRIDGE_PCIEXBAREN;
addr_mask = MCH_HOST_BRIDGE_PCIEXBAR_ADMSK;
switch (pciexbar & MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_MASK) {
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_256M:
length = 256 * 1024 * 1024;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_128M:
length = 128 * 1024 * 1024;
addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_128ADMSK |
MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_64M:
length = 64 * 1024 * 1024;
addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;
break;
case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_RVD:
default:
VAR_1 = 0;
length = 0;
abort();
break;
}
addr = pciexbar & addr_mask;
pcie_host_mmcfg_update(pehb, VAR_1, addr, length);
if (VAR_1) {
VAR_0->pci_hole.begin = addr + length;
} else {
VAR_0->pci_hole.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT;
}
}
|
[
"static void FUNC_0(MCHPCIState *VAR_0)\n{",
"PCIDevice *pci_dev = PCI_DEVICE(VAR_0);",
"BusState *bus = qdev_get_parent_bus(DEVICE(VAR_0));",
"PCIExpressHost *pehb = PCIE_HOST_BRIDGE(bus->parent);",
"uint64_t pciexbar;",
"int VAR_1;",
"uint64_t addr;",
"uint64_t addr_mask;",
"uint32_t length;",
"pciexbar = pci_get_quad(pci_dev->config + MCH_HOST_BRIDGE_PCIEXBAR);",
"VAR_1 = pciexbar & MCH_HOST_BRIDGE_PCIEXBAREN;",
"addr_mask = MCH_HOST_BRIDGE_PCIEXBAR_ADMSK;",
"switch (pciexbar & MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_MASK) {",
"case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_256M:\nlength = 256 * 1024 * 1024;",
"break;",
"case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_128M:\nlength = 128 * 1024 * 1024;",
"addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_128ADMSK |\nMCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;",
"break;",
"case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_64M:\nlength = 64 * 1024 * 1024;",
"addr_mask |= MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK;",
"break;",
"case MCH_HOST_BRIDGE_PCIEXBAR_LENGTH_RVD:\ndefault:\nVAR_1 = 0;",
"length = 0;",
"abort();",
"break;",
"}",
"addr = pciexbar & addr_mask;",
"pcie_host_mmcfg_update(pehb, VAR_1, addr, length);",
"if (VAR_1) {",
"VAR_0->pci_hole.begin = addr + length;",
"} else {",
"VAR_0->pci_hole.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT;",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
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
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
]
] |
8,074 |
static int get_cluster_duration(MOVTrack *track, int cluster_idx)
{
int64_t next_dts;
if (cluster_idx >= track->entry)
return 0;
if (cluster_idx + 1 == track->entry)
next_dts = track->track_duration + track->start_dts;
else
next_dts = track->cluster[cluster_idx + 1].dts;
return next_dts - track->cluster[cluster_idx].dts;
}
| false |
FFmpeg
|
20fa3fb93d0f3d3eab2b1f63a03168f492fae047
|
static int get_cluster_duration(MOVTrack *track, int cluster_idx)
{
int64_t next_dts;
if (cluster_idx >= track->entry)
return 0;
if (cluster_idx + 1 == track->entry)
next_dts = track->track_duration + track->start_dts;
else
next_dts = track->cluster[cluster_idx + 1].dts;
return next_dts - track->cluster[cluster_idx].dts;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(MOVTrack *VAR_0, int VAR_1)
{
int64_t next_dts;
if (VAR_1 >= VAR_0->entry)
return 0;
if (VAR_1 + 1 == VAR_0->entry)
next_dts = VAR_0->track_duration + VAR_0->start_dts;
else
next_dts = VAR_0->cluster[VAR_1 + 1].dts;
return next_dts - VAR_0->cluster[VAR_1].dts;
}
|
[
"static int FUNC_0(MOVTrack *VAR_0, int VAR_1)\n{",
"int64_t next_dts;",
"if (VAR_1 >= VAR_0->entry)\nreturn 0;",
"if (VAR_1 + 1 == VAR_0->entry)\nnext_dts = VAR_0->track_duration + VAR_0->start_dts;",
"else\nnext_dts = VAR_0->cluster[VAR_1 + 1].dts;",
"return next_dts - VAR_0->cluster[VAR_1].dts;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
11
],
[
15,
17
],
[
19,
21
],
[
25
],
[
27
]
] |
8,075 |
static inline int tcg_temp_new_internal(TCGType type, int temp_local)
{
TCGContext *s = &tcg_ctx;
TCGTemp *ts;
int idx, k;
k = type + (temp_local ? TCG_TYPE_COUNT : 0);
idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS);
if (idx < TCG_MAX_TEMPS) {
/* There is already an available temp with the right type. */
clear_bit(idx, s->free_temps[k].l);
ts = &s->temps[idx];
ts->temp_allocated = 1;
assert(ts->base_type == type);
assert(ts->temp_local == temp_local);
} else {
idx = s->nb_temps;
#if TCG_TARGET_REG_BITS == 32
if (type == TCG_TYPE_I64) {
tcg_temp_alloc(s, s->nb_temps + 2);
ts = &s->temps[s->nb_temps];
ts->base_type = type;
ts->type = TCG_TYPE_I32;
ts->temp_allocated = 1;
ts->temp_local = temp_local;
ts->name = NULL;
ts++;
ts->base_type = TCG_TYPE_I32;
ts->type = TCG_TYPE_I32;
ts->temp_allocated = 1;
ts->temp_local = temp_local;
ts->name = NULL;
s->nb_temps += 2;
} else
#endif
{
tcg_temp_alloc(s, s->nb_temps + 1);
ts = &s->temps[s->nb_temps];
ts->base_type = type;
ts->type = type;
ts->temp_allocated = 1;
ts->temp_local = temp_local;
ts->name = NULL;
s->nb_temps++;
}
}
#if defined(CONFIG_DEBUG_TCG)
s->temps_in_use++;
#endif
return idx;
}
| false |
qemu
|
f6aa2f7dee920f6f06fefe122cf2a58cabe3cac0
|
static inline int tcg_temp_new_internal(TCGType type, int temp_local)
{
TCGContext *s = &tcg_ctx;
TCGTemp *ts;
int idx, k;
k = type + (temp_local ? TCG_TYPE_COUNT : 0);
idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS);
if (idx < TCG_MAX_TEMPS) {
clear_bit(idx, s->free_temps[k].l);
ts = &s->temps[idx];
ts->temp_allocated = 1;
assert(ts->base_type == type);
assert(ts->temp_local == temp_local);
} else {
idx = s->nb_temps;
#if TCG_TARGET_REG_BITS == 32
if (type == TCG_TYPE_I64) {
tcg_temp_alloc(s, s->nb_temps + 2);
ts = &s->temps[s->nb_temps];
ts->base_type = type;
ts->type = TCG_TYPE_I32;
ts->temp_allocated = 1;
ts->temp_local = temp_local;
ts->name = NULL;
ts++;
ts->base_type = TCG_TYPE_I32;
ts->type = TCG_TYPE_I32;
ts->temp_allocated = 1;
ts->temp_local = temp_local;
ts->name = NULL;
s->nb_temps += 2;
} else
#endif
{
tcg_temp_alloc(s, s->nb_temps + 1);
ts = &s->temps[s->nb_temps];
ts->base_type = type;
ts->type = type;
ts->temp_allocated = 1;
ts->temp_local = temp_local;
ts->name = NULL;
s->nb_temps++;
}
}
#if defined(CONFIG_DEBUG_TCG)
s->temps_in_use++;
#endif
return idx;
}
|
{
"code": [],
"line_no": []
}
|
static inline int FUNC_0(TCGType VAR_0, int VAR_1)
{
TCGContext *s = &tcg_ctx;
TCGTemp *ts;
int VAR_2, VAR_3;
VAR_3 = VAR_0 + (VAR_1 ? TCG_TYPE_COUNT : 0);
VAR_2 = find_first_bit(s->free_temps[VAR_3].l, TCG_MAX_TEMPS);
if (VAR_2 < TCG_MAX_TEMPS) {
clear_bit(VAR_2, s->free_temps[VAR_3].l);
ts = &s->temps[VAR_2];
ts->temp_allocated = 1;
assert(ts->base_type == VAR_0);
assert(ts->VAR_1 == VAR_1);
} else {
VAR_2 = s->nb_temps;
#if TCG_TARGET_REG_BITS == 32
if (VAR_0 == TCG_TYPE_I64) {
tcg_temp_alloc(s, s->nb_temps + 2);
ts = &s->temps[s->nb_temps];
ts->base_type = VAR_0;
ts->VAR_0 = TCG_TYPE_I32;
ts->temp_allocated = 1;
ts->VAR_1 = VAR_1;
ts->name = NULL;
ts++;
ts->base_type = TCG_TYPE_I32;
ts->VAR_0 = TCG_TYPE_I32;
ts->temp_allocated = 1;
ts->VAR_1 = VAR_1;
ts->name = NULL;
s->nb_temps += 2;
} else
#endif
{
tcg_temp_alloc(s, s->nb_temps + 1);
ts = &s->temps[s->nb_temps];
ts->base_type = VAR_0;
ts->VAR_0 = VAR_0;
ts->temp_allocated = 1;
ts->VAR_1 = VAR_1;
ts->name = NULL;
s->nb_temps++;
}
}
#if defined(CONFIG_DEBUG_TCG)
s->temps_in_use++;
#endif
return VAR_2;
}
|
[
"static inline int FUNC_0(TCGType VAR_0, int VAR_1)\n{",
"TCGContext *s = &tcg_ctx;",
"TCGTemp *ts;",
"int VAR_2, VAR_3;",
"VAR_3 = VAR_0 + (VAR_1 ? TCG_TYPE_COUNT : 0);",
"VAR_2 = find_first_bit(s->free_temps[VAR_3].l, TCG_MAX_TEMPS);",
"if (VAR_2 < TCG_MAX_TEMPS) {",
"clear_bit(VAR_2, s->free_temps[VAR_3].l);",
"ts = &s->temps[VAR_2];",
"ts->temp_allocated = 1;",
"assert(ts->base_type == VAR_0);",
"assert(ts->VAR_1 == VAR_1);",
"} else {",
"VAR_2 = s->nb_temps;",
"#if TCG_TARGET_REG_BITS == 32\nif (VAR_0 == TCG_TYPE_I64) {",
"tcg_temp_alloc(s, s->nb_temps + 2);",
"ts = &s->temps[s->nb_temps];",
"ts->base_type = VAR_0;",
"ts->VAR_0 = TCG_TYPE_I32;",
"ts->temp_allocated = 1;",
"ts->VAR_1 = VAR_1;",
"ts->name = NULL;",
"ts++;",
"ts->base_type = TCG_TYPE_I32;",
"ts->VAR_0 = TCG_TYPE_I32;",
"ts->temp_allocated = 1;",
"ts->VAR_1 = VAR_1;",
"ts->name = NULL;",
"s->nb_temps += 2;",
"} else",
"#endif\n{",
"tcg_temp_alloc(s, s->nb_temps + 1);",
"ts = &s->temps[s->nb_temps];",
"ts->base_type = VAR_0;",
"ts->VAR_0 = VAR_0;",
"ts->temp_allocated = 1;",
"ts->VAR_1 = VAR_1;",
"ts->name = NULL;",
"s->nb_temps++;",
"}",
"}",
"#if defined(CONFIG_DEBUG_TCG)\ns->temps_in_use++;",
"#endif\nreturn VAR_2;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
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
],
[
97,
99
],
[
101,
103
],
[
105
]
] |
8,076 |
static void tcg_out_r(TCGContext *s, TCGArg t0)
{
assert(t0 < TCG_TARGET_NB_REGS);
tcg_out8(s, t0);
}
| false |
qemu
|
eabb7b91b36b202b4dac2df2d59d698e3aff197a
|
static void tcg_out_r(TCGContext *s, TCGArg t0)
{
assert(t0 < TCG_TARGET_NB_REGS);
tcg_out8(s, t0);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(TCGContext *VAR_0, TCGArg VAR_1)
{
assert(VAR_1 < TCG_TARGET_NB_REGS);
tcg_out8(VAR_0, VAR_1);
}
|
[
"static void FUNC_0(TCGContext *VAR_0, TCGArg VAR_1)\n{",
"assert(VAR_1 < TCG_TARGET_NB_REGS);",
"tcg_out8(VAR_0, VAR_1);",
"}"
] |
[
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
8,077 |
ISADevice *pc_find_fdc0(void)
{
int i;
Object *container;
CheckFdcState state = { 0 };
for (i = 0; i < ARRAY_SIZE(fdc_container_path); i++) {
container = container_get(qdev_get_machine(), fdc_container_path[i]);
object_child_foreach(container, check_fdc, &state);
}
if (state.multiple) {
error_report("warning: multiple floppy disk controllers with "
"iobase=0x3f0 have been found");
error_printf("the one being picked for CMOS setup might not reflect "
"your intent\n");
}
return state.floppy;
}
| false |
qemu
|
3dc6f8693694a649a9c83f1e2746565b47683923
|
ISADevice *pc_find_fdc0(void)
{
int i;
Object *container;
CheckFdcState state = { 0 };
for (i = 0; i < ARRAY_SIZE(fdc_container_path); i++) {
container = container_get(qdev_get_machine(), fdc_container_path[i]);
object_child_foreach(container, check_fdc, &state);
}
if (state.multiple) {
error_report("warning: multiple floppy disk controllers with "
"iobase=0x3f0 have been found");
error_printf("the one being picked for CMOS setup might not reflect "
"your intent\n");
}
return state.floppy;
}
|
{
"code": [],
"line_no": []
}
|
ISADevice *FUNC_0(void)
{
int VAR_0;
Object *container;
CheckFdcState state = { 0 };
for (VAR_0 = 0; VAR_0 < ARRAY_SIZE(fdc_container_path); VAR_0++) {
container = container_get(qdev_get_machine(), fdc_container_path[VAR_0]);
object_child_foreach(container, check_fdc, &state);
}
if (state.multiple) {
error_report("warning: multiple floppy disk controllers with "
"iobase=0x3f0 have been found");
error_printf("the one being picked for CMOS setup might not reflect "
"your intent\n");
}
return state.floppy;
}
|
[
"ISADevice *FUNC_0(void)\n{",
"int VAR_0;",
"Object *container;",
"CheckFdcState state = { 0 };",
"for (VAR_0 = 0; VAR_0 < ARRAY_SIZE(fdc_container_path); VAR_0++) {",
"container = container_get(qdev_get_machine(), fdc_container_path[VAR_0]);",
"object_child_foreach(container, check_fdc, &state);",
"}",
"if (state.multiple) {",
"error_report(\"warning: multiple floppy disk controllers with \"\n\"iobase=0x3f0 have been found\");",
"error_printf(\"the one being picked for CMOS setup might not reflect \"\n\"your intent\\n\");",
"}",
"return state.floppy;",
"}"
] |
[
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
],
[
37
],
[
39
]
] |
8,079 |
static void qvirtio_scsi_start(const char *extra_opts)
{
char *cmdline;
cmdline = g_strdup_printf(
"-drive id=drv0,if=none,file=/dev/null,format=raw "
"-device virtio-scsi-pci,id=vs0 "
"-device scsi-hd,bus=vs0.0,drive=drv0 %s",
extra_opts ? : "");
qtest_start(cmdline);
g_free(cmdline);
}
| false |
qemu
|
a980f7f2c2f4d7e9a1eba4f804cd66dbd458b6d4
|
static void qvirtio_scsi_start(const char *extra_opts)
{
char *cmdline;
cmdline = g_strdup_printf(
"-drive id=drv0,if=none,file=/dev/null,format=raw "
"-device virtio-scsi-pci,id=vs0 "
"-device scsi-hd,bus=vs0.0,drive=drv0 %s",
extra_opts ? : "");
qtest_start(cmdline);
g_free(cmdline);
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(const char *VAR_0)
{
char *VAR_1;
VAR_1 = g_strdup_printf(
"-drive id=drv0,if=none,file=/dev/null,format=raw "
"-device virtio-scsi-pci,id=vs0 "
"-device scsi-hd,bus=vs0.0,drive=drv0 %s",
VAR_0 ? : "");
qtest_start(VAR_1);
g_free(VAR_1);
}
|
[
"static void FUNC_0(const char *VAR_0)\n{",
"char *VAR_1;",
"VAR_1 = g_strdup_printf(\n\"-drive id=drv0,if=none,file=/dev/null,format=raw \"\n\"-device virtio-scsi-pci,id=vs0 \"\n\"-device scsi-hd,bus=vs0.0,drive=drv0 %s\",\nVAR_0 ? : \"\");",
"qtest_start(VAR_1);",
"g_free(VAR_1);",
"}"
] |
[
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
9,
11,
13,
15,
17
],
[
19
],
[
21
],
[
23
]
] |
8,080 |
static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
uint64_t map_addr, bool do_map)
{
struct kvm_s390_io_adapter_req req = {
.id = id,
.type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
.addr = map_addr,
};
struct kvm_device_attr attr = {
.group = KVM_DEV_FLIC_ADAPTER_MODIFY,
.addr = (uint64_t)&req,
};
KVMS390FLICState *flic = KVM_S390_FLIC(fs);
int r;
if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
/* nothing to do */
return 0;
}
r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
return r ? -errno : 0;
}
| false |
qemu
|
4cbd6c41fa3aa901e12e8158e8d22dd8f70f7a90
|
static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
uint64_t map_addr, bool do_map)
{
struct kvm_s390_io_adapter_req req = {
.id = id,
.type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
.addr = map_addr,
};
struct kvm_device_attr attr = {
.group = KVM_DEV_FLIC_ADAPTER_MODIFY,
.addr = (uint64_t)&req,
};
KVMS390FLICState *flic = KVM_S390_FLIC(fs);
int r;
if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
return 0;
}
r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
return r ? -errno : 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(S390FLICState *VAR_0, uint32_t VAR_1,
uint64_t VAR_2, bool VAR_3)
{
struct kvm_s390_io_adapter_req VAR_4 = {
.VAR_1 = VAR_1,
.type = VAR_3 ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
.addr = VAR_2,
};
struct kvm_device_attr VAR_5 = {
.group = KVM_DEV_FLIC_ADAPTER_MODIFY,
.addr = (uint64_t)&VAR_4,
};
KVMS390FLICState *flic = KVM_S390_FLIC(VAR_0);
int VAR_6;
if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
return 0;
}
VAR_6 = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &VAR_5);
return VAR_6 ? -errno : 0;
}
|
[
"static int FUNC_0(S390FLICState *VAR_0, uint32_t VAR_1,\nuint64_t VAR_2, bool VAR_3)\n{",
"struct kvm_s390_io_adapter_req VAR_4 = {",
".VAR_1 = VAR_1,\n.type = VAR_3 ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,\n.addr = VAR_2,\n};",
"struct kvm_device_attr VAR_5 = {",
".group = KVM_DEV_FLIC_ADAPTER_MODIFY,\n.addr = (uint64_t)&VAR_4,\n};",
"KVMS390FLICState *flic = KVM_S390_FLIC(VAR_0);",
"int VAR_6;",
"if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {",
"return 0;",
"}",
"VAR_6 = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &VAR_5);",
"return VAR_6 ? -errno : 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
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
]
] |
8,082 |
uint32_t HELPER(get_r13_banked)(CPUState *env, uint32_t mode)
{
return env->banked_r13[bank_number(mode)];
}
| false |
qemu
|
39ea3d4eaf1ff300ee55946108394729bc053dfa
|
uint32_t HELPER(get_r13_banked)(CPUState *env, uint32_t mode)
{
return env->banked_r13[bank_number(mode)];
}
|
{
"code": [],
"line_no": []
}
|
uint32_t FUNC_0(get_r13_banked)(CPUState *env, uint32_t mode)
{
return env->banked_r13[bank_number(mode)];
}
|
[
"uint32_t FUNC_0(get_r13_banked)(CPUState *env, uint32_t mode)\n{",
"return env->banked_r13[bank_number(mode)];",
"}"
] |
[
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
]
] |
8,083 |
static void usb_msd_set_bootindex(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
USBDevice *dev = USB_DEVICE(obj);
MSDState *s = USB_STORAGE_DEV(dev);
int32_t boot_index;
Error *local_err = NULL;
visit_type_int32(v, name, &boot_index, &local_err);
if (local_err) {
goto out;
}
/* check whether bootindex is present in fw_boot_order list */
check_boot_index(boot_index, &local_err);
if (local_err) {
goto out;
}
/* change bootindex to a new one */
s->conf.bootindex = boot_index;
if (s->scsi_dev) {
object_property_set_int(OBJECT(s->scsi_dev), boot_index, "bootindex",
&error_abort);
}
out:
if (local_err) {
error_propagate(errp, local_err);
}
}
| false |
qemu
|
621ff94d5074d88253a5818c6b9c4db718fbfc65
|
static void usb_msd_set_bootindex(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
USBDevice *dev = USB_DEVICE(obj);
MSDState *s = USB_STORAGE_DEV(dev);
int32_t boot_index;
Error *local_err = NULL;
visit_type_int32(v, name, &boot_index, &local_err);
if (local_err) {
goto out;
}
check_boot_index(boot_index, &local_err);
if (local_err) {
goto out;
}
s->conf.bootindex = boot_index;
if (s->scsi_dev) {
object_property_set_int(OBJECT(s->scsi_dev), boot_index, "bootindex",
&error_abort);
}
out:
if (local_err) {
error_propagate(errp, local_err);
}
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(Object *VAR_0, Visitor *VAR_1, const char *VAR_2,
void *VAR_3, Error **VAR_4)
{
USBDevice *dev = USB_DEVICE(VAR_0);
MSDState *s = USB_STORAGE_DEV(dev);
int32_t boot_index;
Error *local_err = NULL;
visit_type_int32(VAR_1, VAR_2, &boot_index, &local_err);
if (local_err) {
goto out;
}
check_boot_index(boot_index, &local_err);
if (local_err) {
goto out;
}
s->conf.bootindex = boot_index;
if (s->scsi_dev) {
object_property_set_int(OBJECT(s->scsi_dev), boot_index, "bootindex",
&error_abort);
}
out:
if (local_err) {
error_propagate(VAR_4, local_err);
}
}
|
[
"static void FUNC_0(Object *VAR_0, Visitor *VAR_1, const char *VAR_2,\nvoid *VAR_3, Error **VAR_4)\n{",
"USBDevice *dev = USB_DEVICE(VAR_0);",
"MSDState *s = USB_STORAGE_DEV(dev);",
"int32_t boot_index;",
"Error *local_err = NULL;",
"visit_type_int32(VAR_1, VAR_2, &boot_index, &local_err);",
"if (local_err) {",
"goto out;",
"}",
"check_boot_index(boot_index, &local_err);",
"if (local_err) {",
"goto out;",
"}",
"s->conf.bootindex = boot_index;",
"if (s->scsi_dev) {",
"object_property_set_int(OBJECT(s->scsi_dev), boot_index, \"bootindex\",\n&error_abort);",
"}",
"out:\nif (local_err) {",
"error_propagate(VAR_4, local_err);",
"}",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
41
],
[
43,
45
],
[
47
],
[
51,
53
],
[
55
],
[
57
],
[
59
]
] |
8,084 |
static void e100_pci_reset(EEPRO100State * s, E100PCIDeviceInfo *e100_device)
{
uint32_t device = s->device;
uint8_t *pci_conf = s->dev.config;
TRACE(OTHER, logout("%p\n", s));
/* PCI Vendor ID */
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
/* PCI Device ID */
pci_config_set_device_id(pci_conf, e100_device->device_id);
/* PCI Status */
pci_set_word(pci_conf + PCI_STATUS, PCI_STATUS_DEVSEL_MEDIUM |
PCI_STATUS_FAST_BACK);
/* PCI Revision ID */
pci_config_set_revision(pci_conf, e100_device->revision);
pci_config_set_class(pci_conf, PCI_CLASS_NETWORK_ETHERNET);
/* PCI Latency Timer */
pci_set_byte(pci_conf + PCI_LATENCY_TIMER, 0x20); /* latency timer = 32 clocks */
/* Capability Pointer is set by PCI framework. */
/* Interrupt Line */
/* Interrupt Pin */
pci_set_byte(pci_conf + PCI_INTERRUPT_PIN, 1); /* interrupt pin A */
/* Minimum Grant */
pci_set_byte(pci_conf + PCI_MIN_GNT, 0x08);
/* Maximum Latency */
pci_set_byte(pci_conf + PCI_MAX_LAT, 0x18);
s->stats_size = e100_device->stats_size;
s->has_extended_tcb_support = e100_device->has_extended_tcb_support;
switch (device) {
case i82550:
case i82551:
case i82557A:
case i82557B:
case i82557C:
case i82558A:
case i82558B:
case i82559A:
case i82559B:
case i82559ER:
case i82562:
case i82801:
break;
case i82559C:
#if EEPROM_SIZE > 0
pci_set_word(pci_conf + PCI_SUBSYSTEM_VENDOR_ID, PCI_VENDOR_ID_INTEL);
pci_set_word(pci_conf + PCI_SUBSYSTEM_ID, 0x0040);
#endif
break;
default:
logout("Device %X is undefined!\n", device);
}
/* Standard TxCB. */
s->configuration[6] |= BIT(4);
/* Standard statistical counters. */
s->configuration[6] |= BIT(5);
if (s->stats_size == 80) {
/* TODO: check TCO Statistical Counters bit. Documentation not clear. */
if (s->configuration[6] & BIT(2)) {
/* TCO statistical counters. */
assert(s->configuration[6] & BIT(5));
} else {
if (s->configuration[6] & BIT(5)) {
/* No extended statistical counters, i82557 compatible. */
s->stats_size = 64;
} else {
/* i82558 compatible. */
s->stats_size = 76;
}
}
} else {
if (s->configuration[6] & BIT(5)) {
/* No extended statistical counters. */
s->stats_size = 64;
}
}
assert(s->stats_size > 0 && s->stats_size <= sizeof(s->statistics));
if (e100_device->power_management) {
/* Power Management Capabilities */
int cfg_offset = 0xdc;
int r = pci_add_capability(&s->dev, PCI_CAP_ID_PM,
cfg_offset, PCI_PM_SIZEOF);
assert(r >= 0);
pci_set_word(pci_conf + cfg_offset + PCI_PM_PMC, 0x7e21);
#if 0 /* TODO: replace dummy code for power management emulation. */
/* TODO: Power Management Control / Status. */
pci_set_word(pci_conf + cfg_offset + PCI_PM_CTRL, 0x0000);
/* TODO: Ethernet Power Consumption Registers (i82559 and later). */
pci_set_byte(pci_conf + cfg_offset + PCI_PM_PPB_EXTENSIONS, 0x0000);
#endif
}
#if EEPROM_SIZE > 0
if (device == i82557C || device == i82558B || device == i82559C) {
/*
TODO: get vendor id from EEPROM for i82557C or later.
TODO: get device id from EEPROM for i82557C or later.
TODO: status bit 4 can be disabled by EEPROM for i82558, i82559.
TODO: header type is determined by EEPROM for i82559.
TODO: get subsystem id from EEPROM for i82557C or later.
TODO: get subsystem vendor id from EEPROM for i82557C or later.
TODO: exp. rom baddr depends on a bit in EEPROM for i82558 or later.
TODO: capability pointer depends on EEPROM for i82558.
*/
logout("Get device id and revision from EEPROM!!!\n");
}
#endif /* EEPROM_SIZE > 0 */
}
| false |
qemu
|
ad03502b3fa1c7e3046775077965030cc595b36e
|
static void e100_pci_reset(EEPRO100State * s, E100PCIDeviceInfo *e100_device)
{
uint32_t device = s->device;
uint8_t *pci_conf = s->dev.config;
TRACE(OTHER, logout("%p\n", s));
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
pci_config_set_device_id(pci_conf, e100_device->device_id);
pci_set_word(pci_conf + PCI_STATUS, PCI_STATUS_DEVSEL_MEDIUM |
PCI_STATUS_FAST_BACK);
pci_config_set_revision(pci_conf, e100_device->revision);
pci_config_set_class(pci_conf, PCI_CLASS_NETWORK_ETHERNET);
pci_set_byte(pci_conf + PCI_LATENCY_TIMER, 0x20);
pci_set_byte(pci_conf + PCI_INTERRUPT_PIN, 1);
pci_set_byte(pci_conf + PCI_MIN_GNT, 0x08);
pci_set_byte(pci_conf + PCI_MAX_LAT, 0x18);
s->stats_size = e100_device->stats_size;
s->has_extended_tcb_support = e100_device->has_extended_tcb_support;
switch (device) {
case i82550:
case i82551:
case i82557A:
case i82557B:
case i82557C:
case i82558A:
case i82558B:
case i82559A:
case i82559B:
case i82559ER:
case i82562:
case i82801:
break;
case i82559C:
#if EEPROM_SIZE > 0
pci_set_word(pci_conf + PCI_SUBSYSTEM_VENDOR_ID, PCI_VENDOR_ID_INTEL);
pci_set_word(pci_conf + PCI_SUBSYSTEM_ID, 0x0040);
#endif
break;
default:
logout("Device %X is undefined!\n", device);
}
s->configuration[6] |= BIT(4);
s->configuration[6] |= BIT(5);
if (s->stats_size == 80) {
if (s->configuration[6] & BIT(2)) {
assert(s->configuration[6] & BIT(5));
} else {
if (s->configuration[6] & BIT(5)) {
s->stats_size = 64;
} else {
s->stats_size = 76;
}
}
} else {
if (s->configuration[6] & BIT(5)) {
s->stats_size = 64;
}
}
assert(s->stats_size > 0 && s->stats_size <= sizeof(s->statistics));
if (e100_device->power_management) {
int cfg_offset = 0xdc;
int r = pci_add_capability(&s->dev, PCI_CAP_ID_PM,
cfg_offset, PCI_PM_SIZEOF);
assert(r >= 0);
pci_set_word(pci_conf + cfg_offset + PCI_PM_PMC, 0x7e21);
#if 0
pci_set_word(pci_conf + cfg_offset + PCI_PM_CTRL, 0x0000);
pci_set_byte(pci_conf + cfg_offset + PCI_PM_PPB_EXTENSIONS, 0x0000);
#endif
}
#if EEPROM_SIZE > 0
if (device == i82557C || device == i82558B || device == i82559C) {
logout("Get device id and revision from EEPROM!!!\n");
}
#endif
}
|
{
"code": [],
"line_no": []
}
|
static void FUNC_0(EEPRO100State * VAR_0, E100PCIDeviceInfo *VAR_1)
{
uint32_t device = VAR_0->device;
uint8_t *pci_conf = VAR_0->dev.config;
TRACE(OTHER, logout("%p\n", VAR_0));
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
pci_config_set_device_id(pci_conf, VAR_1->device_id);
pci_set_word(pci_conf + PCI_STATUS, PCI_STATUS_DEVSEL_MEDIUM |
PCI_STATUS_FAST_BACK);
pci_config_set_revision(pci_conf, VAR_1->revision);
pci_config_set_class(pci_conf, PCI_CLASS_NETWORK_ETHERNET);
pci_set_byte(pci_conf + PCI_LATENCY_TIMER, 0x20);
pci_set_byte(pci_conf + PCI_INTERRUPT_PIN, 1);
pci_set_byte(pci_conf + PCI_MIN_GNT, 0x08);
pci_set_byte(pci_conf + PCI_MAX_LAT, 0x18);
VAR_0->stats_size = VAR_1->stats_size;
VAR_0->has_extended_tcb_support = VAR_1->has_extended_tcb_support;
switch (device) {
case i82550:
case i82551:
case i82557A:
case i82557B:
case i82557C:
case i82558A:
case i82558B:
case i82559A:
case i82559B:
case i82559ER:
case i82562:
case i82801:
break;
case i82559C:
#if EEPROM_SIZE > 0
pci_set_word(pci_conf + PCI_SUBSYSTEM_VENDOR_ID, PCI_VENDOR_ID_INTEL);
pci_set_word(pci_conf + PCI_SUBSYSTEM_ID, 0x0040);
#endif
break;
default:
logout("Device %X is undefined!\n", device);
}
VAR_0->configuration[6] |= BIT(4);
VAR_0->configuration[6] |= BIT(5);
if (VAR_0->stats_size == 80) {
if (VAR_0->configuration[6] & BIT(2)) {
assert(VAR_0->configuration[6] & BIT(5));
} else {
if (VAR_0->configuration[6] & BIT(5)) {
VAR_0->stats_size = 64;
} else {
VAR_0->stats_size = 76;
}
}
} else {
if (VAR_0->configuration[6] & BIT(5)) {
VAR_0->stats_size = 64;
}
}
assert(VAR_0->stats_size > 0 && VAR_0->stats_size <= sizeof(VAR_0->statistics));
if (VAR_1->power_management) {
int VAR_2 = 0xdc;
int VAR_3 = pci_add_capability(&VAR_0->dev, PCI_CAP_ID_PM,
VAR_2, PCI_PM_SIZEOF);
assert(VAR_3 >= 0);
pci_set_word(pci_conf + VAR_2 + PCI_PM_PMC, 0x7e21);
#if 0
pci_set_word(pci_conf + VAR_2 + PCI_PM_CTRL, 0x0000);
pci_set_byte(pci_conf + VAR_2 + PCI_PM_PPB_EXTENSIONS, 0x0000);
#endif
}
#if EEPROM_SIZE > 0
if (device == i82557C || device == i82558B || device == i82559C) {
logout("Get device id and revision from EEPROM!!!\n");
}
#endif
}
|
[
"static void FUNC_0(EEPRO100State * VAR_0, E100PCIDeviceInfo *VAR_1)\n{",
"uint32_t device = VAR_0->device;",
"uint8_t *pci_conf = VAR_0->dev.config;",
"TRACE(OTHER, logout(\"%p\\n\", VAR_0));",
"pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);",
"pci_config_set_device_id(pci_conf, VAR_1->device_id);",
"pci_set_word(pci_conf + PCI_STATUS, PCI_STATUS_DEVSEL_MEDIUM |\nPCI_STATUS_FAST_BACK);",
"pci_config_set_revision(pci_conf, VAR_1->revision);",
"pci_config_set_class(pci_conf, PCI_CLASS_NETWORK_ETHERNET);",
"pci_set_byte(pci_conf + PCI_LATENCY_TIMER, 0x20);",
"pci_set_byte(pci_conf + PCI_INTERRUPT_PIN, 1);",
"pci_set_byte(pci_conf + PCI_MIN_GNT, 0x08);",
"pci_set_byte(pci_conf + PCI_MAX_LAT, 0x18);",
"VAR_0->stats_size = VAR_1->stats_size;",
"VAR_0->has_extended_tcb_support = VAR_1->has_extended_tcb_support;",
"switch (device) {",
"case i82550:\ncase i82551:\ncase i82557A:\ncase i82557B:\ncase i82557C:\ncase i82558A:\ncase i82558B:\ncase i82559A:\ncase i82559B:\ncase i82559ER:\ncase i82562:\ncase i82801:\nbreak;",
"case i82559C:\n#if EEPROM_SIZE > 0\npci_set_word(pci_conf + PCI_SUBSYSTEM_VENDOR_ID, PCI_VENDOR_ID_INTEL);",
"pci_set_word(pci_conf + PCI_SUBSYSTEM_ID, 0x0040);",
"#endif\nbreak;",
"default:\nlogout(\"Device %X is undefined!\\n\", device);",
"}",
"VAR_0->configuration[6] |= BIT(4);",
"VAR_0->configuration[6] |= BIT(5);",
"if (VAR_0->stats_size == 80) {",
"if (VAR_0->configuration[6] & BIT(2)) {",
"assert(VAR_0->configuration[6] & BIT(5));",
"} else {",
"if (VAR_0->configuration[6] & BIT(5)) {",
"VAR_0->stats_size = 64;",
"} else {",
"VAR_0->stats_size = 76;",
"}",
"}",
"} else {",
"if (VAR_0->configuration[6] & BIT(5)) {",
"VAR_0->stats_size = 64;",
"}",
"}",
"assert(VAR_0->stats_size > 0 && VAR_0->stats_size <= sizeof(VAR_0->statistics));",
"if (VAR_1->power_management) {",
"int VAR_2 = 0xdc;",
"int VAR_3 = pci_add_capability(&VAR_0->dev, PCI_CAP_ID_PM,\nVAR_2, PCI_PM_SIZEOF);",
"assert(VAR_3 >= 0);",
"pci_set_word(pci_conf + VAR_2 + PCI_PM_PMC, 0x7e21);",
"#if 0\npci_set_word(pci_conf + VAR_2 + PCI_PM_CTRL, 0x0000);",
"pci_set_byte(pci_conf + VAR_2 + PCI_PM_PPB_EXTENSIONS, 0x0000);",
"#endif\n}",
"#if EEPROM_SIZE > 0\nif (device == i82557C || device == i82558B || device == i82559C) {",
"logout(\"Get device id and revision from EEPROM!!!\\n\");",
"}",
"#endif\n}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
17
],
[
21
],
[
25,
27
],
[
31
],
[
33
],
[
37
],
[
45
],
[
49
],
[
53
],
[
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
],
[
113
],
[
119
],
[
123
],
[
127
],
[
131
],
[
133
],
[
135
],
[
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
171
],
[
173,
175
],
[
177
],
[
179
],
[
181,
185
],
[
189
],
[
191,
193
],
[
197,
199
],
[
221
],
[
223
],
[
225,
227
]
] |
8,087 |
int net_init_bridge(const NetClientOptions *opts, const char *name,
NetClientState *peer, Error **errp)
{
/* FIXME error_setg(errp, ...) on failure */
const NetdevBridgeOptions *bridge;
const char *helper, *br;
TAPState *s;
int fd, vnet_hdr;
assert(opts->kind == NET_CLIENT_OPTIONS_KIND_BRIDGE);
bridge = opts->bridge;
helper = bridge->has_helper ? bridge->helper : DEFAULT_BRIDGE_HELPER;
br = bridge->has_br ? bridge->br : DEFAULT_BRIDGE_INTERFACE;
fd = net_bridge_run_helper(helper, br);
if (fd == -1) {
return -1;
}
fcntl(fd, F_SETFL, O_NONBLOCK);
vnet_hdr = tap_probe_vnet_hdr(fd);
s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s,br=%s", helper,
br);
return 0;
}
| true |
qemu
|
a8a21be9855e0bb0947a7325d0d1741a8814f21e
|
int net_init_bridge(const NetClientOptions *opts, const char *name,
NetClientState *peer, Error **errp)
{
const NetdevBridgeOptions *bridge;
const char *helper, *br;
TAPState *s;
int fd, vnet_hdr;
assert(opts->kind == NET_CLIENT_OPTIONS_KIND_BRIDGE);
bridge = opts->bridge;
helper = bridge->has_helper ? bridge->helper : DEFAULT_BRIDGE_HELPER;
br = bridge->has_br ? bridge->br : DEFAULT_BRIDGE_INTERFACE;
fd = net_bridge_run_helper(helper, br);
if (fd == -1) {
return -1;
}
fcntl(fd, F_SETFL, O_NONBLOCK);
vnet_hdr = tap_probe_vnet_hdr(fd);
s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr);
snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s,br=%s", helper,
br);
return 0;
}
|
{
"code": [
" fd = net_bridge_run_helper(helper, br);"
],
"line_no": [
31
]
}
|
int FUNC_0(const NetClientOptions *VAR_0, const char *VAR_1,
NetClientState *VAR_2, Error **VAR_3)
{
const NetdevBridgeOptions *VAR_4;
const char *VAR_5, *VAR_6;
TAPState *s;
int VAR_7, VAR_8;
assert(VAR_0->kind == NET_CLIENT_OPTIONS_KIND_BRIDGE);
VAR_4 = VAR_0->VAR_4;
VAR_5 = VAR_4->has_helper ? VAR_4->VAR_5 : DEFAULT_BRIDGE_HELPER;
VAR_6 = VAR_4->has_br ? VAR_4->VAR_6 : DEFAULT_BRIDGE_INTERFACE;
VAR_7 = net_bridge_run_helper(VAR_5, VAR_6);
if (VAR_7 == -1) {
return -1;
}
fcntl(VAR_7, F_SETFL, O_NONBLOCK);
VAR_8 = tap_probe_vnet_hdr(VAR_7);
s = net_tap_fd_init(VAR_2, "VAR_4", VAR_1, VAR_7, VAR_8);
snprintf(s->nc.info_str, sizeof(s->nc.info_str), "VAR_5=%s,VAR_6=%s", VAR_5,
VAR_6);
return 0;
}
|
[
"int FUNC_0(const NetClientOptions *VAR_0, const char *VAR_1,\nNetClientState *VAR_2, Error **VAR_3)\n{",
"const NetdevBridgeOptions *VAR_4;",
"const char *VAR_5, *VAR_6;",
"TAPState *s;",
"int VAR_7, VAR_8;",
"assert(VAR_0->kind == NET_CLIENT_OPTIONS_KIND_BRIDGE);",
"VAR_4 = VAR_0->VAR_4;",
"VAR_5 = VAR_4->has_helper ? VAR_4->VAR_5 : DEFAULT_BRIDGE_HELPER;",
"VAR_6 = VAR_4->has_br ? VAR_4->VAR_6 : DEFAULT_BRIDGE_INTERFACE;",
"VAR_7 = net_bridge_run_helper(VAR_5, VAR_6);",
"if (VAR_7 == -1) {",
"return -1;",
"}",
"fcntl(VAR_7, F_SETFL, O_NONBLOCK);",
"VAR_8 = tap_probe_vnet_hdr(VAR_7);",
"s = net_tap_fd_init(VAR_2, \"VAR_4\", VAR_1, VAR_7, VAR_8);",
"snprintf(s->nc.info_str, sizeof(s->nc.info_str), \"VAR_5=%s,VAR_6=%s\", VAR_5,\nVAR_6);",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3,
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
49,
51
],
[
55
],
[
57
]
] |
8,089 |
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
int Al, const uint8_t *mb_bitmask,
int mb_bitmask_size,
const AVFrame *reference)
{
int i, mb_x, mb_y;
uint8_t *data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
int bytes_per_pixel = 1 + (s->bits > 8);
if (mb_bitmask) {
if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
return AVERROR_INVALIDDATA;
}
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
}
s->restart_count = 0;
for (i = 0; i < nb_components; i++) {
int c = s->comp_index[i];
data[c] = s->picture_ptr->data[c];
reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c] = s->linesize[c];
s->coefs_finished[c] |= 1;
}
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;
if (get_bits_left(&s->gb) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
-get_bits_left(&s->gb));
return AVERROR_INVALIDDATA;
}
for (i = 0; i < nb_components; i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
for (j = 0; j < n; j++) {
block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
if (s->interlaced && s->bottom_field)
block_offset += linesize[c] >> 1;
ptr = data[c] + block_offset;
if (!s->progressive) {
if (copy_mb)
mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
linesize[c], s->avctx->lowres);
else {
s->bdsp.clear_block(s->block);
if (decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
s->quant_matrixes[s->quant_sindex[i]]) < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x);
return AVERROR_INVALIDDATA;
}
s->idsp.idct_put(ptr, linesize[c], s->block);
if (s->bits & 7)
shift_output(s, ptr, linesize[c]);
}
} else {
int block_idx = s->block_stride[c] * (v * mb_y + y) +
(h * mb_x + x);
int16_t *block = s->blocks[c][block_idx];
if (Ah)
block[0] += get_bits1(&s->gb) *
s->quant_matrixes[s->quant_sindex[i]][0] << Al;
else if (decode_dc_progressive(s, block, i, s->dc_index[i],
s->quant_matrixes[s->quant_sindex[i]],
Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x);
return AVERROR_INVALIDDATA;
}
}
av_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
av_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
mb_x, mb_y, x, y, c, s->bottom_field,
(v * mb_y + y) * 8, (h * mb_x + x) * 8);
if (++x == h) {
x = 0;
y++;
}
}
}
handle_rstn(s, nb_components);
}
}
return 0;
}
| true |
FFmpeg
|
08509c8f86626815a3e9e68d600d1aacbb8df4bf
|
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
int Al, const uint8_t *mb_bitmask,
int mb_bitmask_size,
const AVFrame *reference)
{
int i, mb_x, mb_y;
uint8_t *data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb = {0};
int bytes_per_pixel = 1 + (s->bits > 8);
if (mb_bitmask) {
if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
return AVERROR_INVALIDDATA;
}
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
}
s->restart_count = 0;
for (i = 0; i < nb_components; i++) {
int c = s->comp_index[i];
data[c] = s->picture_ptr->data[c];
reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c] = s->linesize[c];
s->coefs_finished[c] |= 1;
}
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;
if (get_bits_left(&s->gb) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
-get_bits_left(&s->gb));
return AVERROR_INVALIDDATA;
}
for (i = 0; i < nb_components; i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
for (j = 0; j < n; j++) {
block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
if (s->interlaced && s->bottom_field)
block_offset += linesize[c] >> 1;
ptr = data[c] + block_offset;
if (!s->progressive) {
if (copy_mb)
mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
linesize[c], s->avctx->lowres);
else {
s->bdsp.clear_block(s->block);
if (decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
s->quant_matrixes[s->quant_sindex[i]]) < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x);
return AVERROR_INVALIDDATA;
}
s->idsp.idct_put(ptr, linesize[c], s->block);
if (s->bits & 7)
shift_output(s, ptr, linesize[c]);
}
} else {
int block_idx = s->block_stride[c] * (v * mb_y + y) +
(h * mb_x + x);
int16_t *block = s->blocks[c][block_idx];
if (Ah)
block[0] += get_bits1(&s->gb) *
s->quant_matrixes[s->quant_sindex[i]][0] << Al;
else if (decode_dc_progressive(s, block, i, s->dc_index[i],
s->quant_matrixes[s->quant_sindex[i]],
Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", mb_y, mb_x);
return AVERROR_INVALIDDATA;
}
}
av_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
av_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
mb_x, mb_y, x, y, c, s->bottom_field,
(v * mb_y + y) * 8, (h * mb_x + x) * 8);
if (++x == h) {
x = 0;
y++;
}
}
}
handle_rstn(s, nb_components);
}
}
return 0;
}
|
{
"code": [
" ptr = data[c] + block_offset;",
" if (copy_mb)",
" mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,",
" linesize[c], s->avctx->lowres);",
" else {",
" s->idsp.idct_put(ptr, linesize[c], s->block);",
" if (s->bits & 7)",
" shift_output(s, ptr, linesize[c]);"
],
"line_no": [
117,
121,
123,
125,
129,
147,
149,
151
]
}
|
static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1, int VAR_2,
int VAR_3, const uint8_t *VAR_4,
int VAR_5,
const AVFrame *VAR_6)
{
int VAR_7, VAR_8, VAR_9;
uint8_t *data[MAX_COMPONENTS];
const uint8_t *VAR_10[MAX_COMPONENTS];
int VAR_11[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb = {0};
int VAR_12 = 1 + (VAR_0->bits > 8);
if (VAR_4) {
if (VAR_5 != (VAR_0->mb_width * VAR_0->mb_height + 7)>>3) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_5 mismatches\n");
return AVERROR_INVALIDDATA;
}
init_get_bits(&mb_bitmask_gb, VAR_4, VAR_0->mb_width * VAR_0->mb_height);
}
VAR_0->restart_count = 0;
for (VAR_7 = 0; VAR_7 < VAR_1; VAR_7++) {
int VAR_13 = VAR_0->comp_index[VAR_7];
data[VAR_13] = VAR_0->picture_ptr->data[VAR_13];
VAR_10[VAR_13] = VAR_6 ? VAR_6->data[VAR_13] : NULL;
VAR_11[VAR_13] = VAR_0->VAR_11[VAR_13];
VAR_0->coefs_finished[VAR_13] |= 1;
}
for (VAR_9 = 0; VAR_9 < VAR_0->mb_height; VAR_9++) {
for (VAR_8 = 0; VAR_8 < VAR_0->mb_width; VAR_8++) {
const int copy_mb = VAR_4 && !get_bits1(&mb_bitmask_gb);
if (VAR_0->restart_interval && !VAR_0->restart_count)
VAR_0->restart_count = VAR_0->restart_interval;
if (get_bits_left(&VAR_0->gb) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "overread %d\n",
-get_bits_left(&VAR_0->gb));
return AVERROR_INVALIDDATA;
}
for (VAR_7 = 0; VAR_7 < VAR_1; VAR_7++) {
uint8_t *ptr;
int n, h, v, x, y, VAR_13, j;
int block_offset;
n = VAR_0->nb_blocks[VAR_7];
VAR_13 = VAR_0->comp_index[VAR_7];
h = VAR_0->h_scount[VAR_7];
v = VAR_0->v_scount[VAR_7];
x = 0;
y = 0;
for (j = 0; j < n; j++) {
block_offset = (((VAR_11[VAR_13] * (v * VAR_9 + y) * 8) +
(h * VAR_8 + x) * 8 * VAR_12) >> VAR_0->avctx->lowres);
if (VAR_0->interlaced && VAR_0->bottom_field)
block_offset += VAR_11[VAR_13] >> 1;
ptr = data[VAR_13] + block_offset;
if (!VAR_0->progressive) {
if (copy_mb)
mjpeg_copy_block(VAR_0, ptr, VAR_10[VAR_13] + block_offset,
VAR_11[VAR_13], VAR_0->avctx->lowres);
else {
VAR_0->bdsp.clear_block(VAR_0->block);
if (decode_block(VAR_0, VAR_0->block, VAR_7,
VAR_0->dc_index[VAR_7], VAR_0->ac_index[VAR_7],
VAR_0->quant_matrixes[VAR_0->quant_sindex[VAR_7]]) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", VAR_9, VAR_8);
return AVERROR_INVALIDDATA;
}
VAR_0->idsp.idct_put(ptr, VAR_11[VAR_13], VAR_0->block);
if (VAR_0->bits & 7)
shift_output(VAR_0, ptr, VAR_11[VAR_13]);
}
} else {
int block_idx = VAR_0->block_stride[VAR_13] * (v * VAR_9 + y) +
(h * VAR_8 + x);
int16_t *block = VAR_0->blocks[VAR_13][block_idx];
if (VAR_2)
block[0] += get_bits1(&VAR_0->gb) *
VAR_0->quant_matrixes[VAR_0->quant_sindex[VAR_7]][0] << VAR_3;
else if (decode_dc_progressive(VAR_0, block, VAR_7, VAR_0->dc_index[VAR_7],
VAR_0->quant_matrixes[VAR_0->quant_sindex[VAR_7]],
VAR_3) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR,
"error y=%d x=%d\n", VAR_9, VAR_8);
return AVERROR_INVALIDDATA;
}
}
av_dlog(VAR_0->avctx, "mb: %d %d processed\n", VAR_9, VAR_8);
av_dlog(VAR_0->avctx, "%d %d %d %d %d %d %d %d \n",
VAR_8, VAR_9, x, y, VAR_13, VAR_0->bottom_field,
(v * VAR_9 + y) * 8, (h * VAR_8 + x) * 8);
if (++x == h) {
x = 0;
y++;
}
}
}
handle_rstn(VAR_0, VAR_1);
}
}
return 0;
}
|
[
"static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1, int VAR_2,\nint VAR_3, const uint8_t *VAR_4,\nint VAR_5,\nconst AVFrame *VAR_6)\n{",
"int VAR_7, VAR_8, VAR_9;",
"uint8_t *data[MAX_COMPONENTS];",
"const uint8_t *VAR_10[MAX_COMPONENTS];",
"int VAR_11[MAX_COMPONENTS];",
"GetBitContext mb_bitmask_gb = {0};",
"int VAR_12 = 1 + (VAR_0->bits > 8);",
"if (VAR_4) {",
"if (VAR_5 != (VAR_0->mb_width * VAR_0->mb_height + 7)>>3) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_5 mismatches\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"init_get_bits(&mb_bitmask_gb, VAR_4, VAR_0->mb_width * VAR_0->mb_height);",
"}",
"VAR_0->restart_count = 0;",
"for (VAR_7 = 0; VAR_7 < VAR_1; VAR_7++) {",
"int VAR_13 = VAR_0->comp_index[VAR_7];",
"data[VAR_13] = VAR_0->picture_ptr->data[VAR_13];",
"VAR_10[VAR_13] = VAR_6 ? VAR_6->data[VAR_13] : NULL;",
"VAR_11[VAR_13] = VAR_0->VAR_11[VAR_13];",
"VAR_0->coefs_finished[VAR_13] |= 1;",
"}",
"for (VAR_9 = 0; VAR_9 < VAR_0->mb_height; VAR_9++) {",
"for (VAR_8 = 0; VAR_8 < VAR_0->mb_width; VAR_8++) {",
"const int copy_mb = VAR_4 && !get_bits1(&mb_bitmask_gb);",
"if (VAR_0->restart_interval && !VAR_0->restart_count)\nVAR_0->restart_count = VAR_0->restart_interval;",
"if (get_bits_left(&VAR_0->gb) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"overread %d\\n\",\n-get_bits_left(&VAR_0->gb));",
"return AVERROR_INVALIDDATA;",
"}",
"for (VAR_7 = 0; VAR_7 < VAR_1; VAR_7++) {",
"uint8_t *ptr;",
"int n, h, v, x, y, VAR_13, j;",
"int block_offset;",
"n = VAR_0->nb_blocks[VAR_7];",
"VAR_13 = VAR_0->comp_index[VAR_7];",
"h = VAR_0->h_scount[VAR_7];",
"v = VAR_0->v_scount[VAR_7];",
"x = 0;",
"y = 0;",
"for (j = 0; j < n; j++) {",
"block_offset = (((VAR_11[VAR_13] * (v * VAR_9 + y) * 8) +\n(h * VAR_8 + x) * 8 * VAR_12) >> VAR_0->avctx->lowres);",
"if (VAR_0->interlaced && VAR_0->bottom_field)\nblock_offset += VAR_11[VAR_13] >> 1;",
"ptr = data[VAR_13] + block_offset;",
"if (!VAR_0->progressive) {",
"if (copy_mb)\nmjpeg_copy_block(VAR_0, ptr, VAR_10[VAR_13] + block_offset,\nVAR_11[VAR_13], VAR_0->avctx->lowres);",
"else {",
"VAR_0->bdsp.clear_block(VAR_0->block);",
"if (decode_block(VAR_0, VAR_0->block, VAR_7,\nVAR_0->dc_index[VAR_7], VAR_0->ac_index[VAR_7],\nVAR_0->quant_matrixes[VAR_0->quant_sindex[VAR_7]]) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"error y=%d x=%d\\n\", VAR_9, VAR_8);",
"return AVERROR_INVALIDDATA;",
"}",
"VAR_0->idsp.idct_put(ptr, VAR_11[VAR_13], VAR_0->block);",
"if (VAR_0->bits & 7)\nshift_output(VAR_0, ptr, VAR_11[VAR_13]);",
"}",
"} else {",
"int block_idx = VAR_0->block_stride[VAR_13] * (v * VAR_9 + y) +\n(h * VAR_8 + x);",
"int16_t *block = VAR_0->blocks[VAR_13][block_idx];",
"if (VAR_2)\nblock[0] += get_bits1(&VAR_0->gb) *\nVAR_0->quant_matrixes[VAR_0->quant_sindex[VAR_7]][0] << VAR_3;",
"else if (decode_dc_progressive(VAR_0, block, VAR_7, VAR_0->dc_index[VAR_7],\nVAR_0->quant_matrixes[VAR_0->quant_sindex[VAR_7]],\nVAR_3) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"error y=%d x=%d\\n\", VAR_9, VAR_8);",
"return AVERROR_INVALIDDATA;",
"}",
"}",
"av_dlog(VAR_0->avctx, \"mb: %d %d processed\\n\", VAR_9, VAR_8);",
"av_dlog(VAR_0->avctx, \"%d %d %d %d %d %d %d %d \\n\",\nVAR_8, VAR_9, x, y, VAR_13, VAR_0->bottom_field,\n(v * VAR_9 + y) * 8, (h * VAR_8 + x) * 8);",
"if (++x == h) {",
"x = 0;",
"y++;",
"}",
"}",
"}",
"handle_rstn(VAR_0, VAR_1);",
"}",
"}",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
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
] |
[
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
69,
71
],
[
75
],
[
77,
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107,
109
],
[
113,
115
],
[
117
],
[
119
],
[
121,
123,
125
],
[
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
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
]
] |
8,090 |
int kvm_cpu_exec(CPUState *cpu)
{
struct kvm_run *run = cpu->kvm_run;
int ret, run_ret;
DPRINTF("kvm_cpu_exec()\n");
if (kvm_arch_process_async_events(cpu)) {
cpu->exit_request = 0;
return EXCP_HLT;
}
qemu_mutex_unlock_iothread();
do {
MemTxAttrs attrs;
if (cpu->kvm_vcpu_dirty) {
kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
cpu->kvm_vcpu_dirty = false;
}
kvm_arch_pre_run(cpu, run);
if (cpu->exit_request) {
DPRINTF("interrupt exit requested\n");
/*
* KVM requires us to reenter the kernel after IO exits to complete
* instruction emulation. This self-signal will ensure that we
* leave ASAP again.
*/
qemu_cpu_kick_self();
}
run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
attrs = kvm_arch_post_run(cpu, run);
if (run_ret < 0) {
if (run_ret == -EINTR || run_ret == -EAGAIN) {
DPRINTF("io window exit\n");
ret = EXCP_INTERRUPT;
break;
}
fprintf(stderr, "error: kvm run failed %s\n",
strerror(-run_ret));
#ifdef TARGET_PPC
if (run_ret == -EBUSY) {
fprintf(stderr,
"This is probably because your SMT is enabled.\n"
"VCPU can only run on primary threads with all "
"secondary threads offline.\n");
}
#endif
ret = -1;
break;
}
trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
switch (run->exit_reason) {
case KVM_EXIT_IO:
DPRINTF("handle_io\n");
/* Called outside BQL */
kvm_handle_io(run->io.port, attrs,
(uint8_t *)run + run->io.data_offset,
run->io.direction,
run->io.size,
run->io.count);
ret = 0;
break;
case KVM_EXIT_MMIO:
DPRINTF("handle_mmio\n");
/* Called outside BQL */
address_space_rw(&address_space_memory,
run->mmio.phys_addr, attrs,
run->mmio.data,
run->mmio.len,
run->mmio.is_write);
ret = 0;
break;
case KVM_EXIT_IRQ_WINDOW_OPEN:
DPRINTF("irq_window_open\n");
ret = EXCP_INTERRUPT;
break;
case KVM_EXIT_SHUTDOWN:
DPRINTF("shutdown\n");
qemu_system_reset_request();
ret = EXCP_INTERRUPT;
break;
case KVM_EXIT_UNKNOWN:
fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
(uint64_t)run->hw.hardware_exit_reason);
ret = -1;
break;
case KVM_EXIT_INTERNAL_ERROR:
ret = kvm_handle_internal_error(cpu, run);
break;
case KVM_EXIT_SYSTEM_EVENT:
switch (run->system_event.type) {
case KVM_SYSTEM_EVENT_SHUTDOWN:
qemu_system_shutdown_request();
ret = EXCP_INTERRUPT;
break;
case KVM_SYSTEM_EVENT_RESET:
qemu_system_reset_request();
ret = EXCP_INTERRUPT;
break;
case KVM_SYSTEM_EVENT_CRASH:
qemu_mutex_lock_iothread();
qemu_system_guest_panicked();
qemu_mutex_unlock_iothread();
ret = 0;
break;
default:
DPRINTF("kvm_arch_handle_exit\n");
ret = kvm_arch_handle_exit(cpu, run);
break;
}
break;
default:
DPRINTF("kvm_arch_handle_exit\n");
ret = kvm_arch_handle_exit(cpu, run);
break;
}
} while (ret == 0);
qemu_mutex_lock_iothread();
if (ret < 0) {
cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
vm_stop(RUN_STATE_INTERNAL_ERROR);
}
cpu->exit_request = 0;
return ret;
}
| true |
qemu
|
d187e08dc4d0793dab1a9747b72b17a1cf0d3e43
|
int kvm_cpu_exec(CPUState *cpu)
{
struct kvm_run *run = cpu->kvm_run;
int ret, run_ret;
DPRINTF("kvm_cpu_exec()\n");
if (kvm_arch_process_async_events(cpu)) {
cpu->exit_request = 0;
return EXCP_HLT;
}
qemu_mutex_unlock_iothread();
do {
MemTxAttrs attrs;
if (cpu->kvm_vcpu_dirty) {
kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
cpu->kvm_vcpu_dirty = false;
}
kvm_arch_pre_run(cpu, run);
if (cpu->exit_request) {
DPRINTF("interrupt exit requested\n");
qemu_cpu_kick_self();
}
run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
attrs = kvm_arch_post_run(cpu, run);
if (run_ret < 0) {
if (run_ret == -EINTR || run_ret == -EAGAIN) {
DPRINTF("io window exit\n");
ret = EXCP_INTERRUPT;
break;
}
fprintf(stderr, "error: kvm run failed %s\n",
strerror(-run_ret));
#ifdef TARGET_PPC
if (run_ret == -EBUSY) {
fprintf(stderr,
"This is probably because your SMT is enabled.\n"
"VCPU can only run on primary threads with all "
"secondary threads offline.\n");
}
#endif
ret = -1;
break;
}
trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
switch (run->exit_reason) {
case KVM_EXIT_IO:
DPRINTF("handle_io\n");
kvm_handle_io(run->io.port, attrs,
(uint8_t *)run + run->io.data_offset,
run->io.direction,
run->io.size,
run->io.count);
ret = 0;
break;
case KVM_EXIT_MMIO:
DPRINTF("handle_mmio\n");
address_space_rw(&address_space_memory,
run->mmio.phys_addr, attrs,
run->mmio.data,
run->mmio.len,
run->mmio.is_write);
ret = 0;
break;
case KVM_EXIT_IRQ_WINDOW_OPEN:
DPRINTF("irq_window_open\n");
ret = EXCP_INTERRUPT;
break;
case KVM_EXIT_SHUTDOWN:
DPRINTF("shutdown\n");
qemu_system_reset_request();
ret = EXCP_INTERRUPT;
break;
case KVM_EXIT_UNKNOWN:
fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
(uint64_t)run->hw.hardware_exit_reason);
ret = -1;
break;
case KVM_EXIT_INTERNAL_ERROR:
ret = kvm_handle_internal_error(cpu, run);
break;
case KVM_EXIT_SYSTEM_EVENT:
switch (run->system_event.type) {
case KVM_SYSTEM_EVENT_SHUTDOWN:
qemu_system_shutdown_request();
ret = EXCP_INTERRUPT;
break;
case KVM_SYSTEM_EVENT_RESET:
qemu_system_reset_request();
ret = EXCP_INTERRUPT;
break;
case KVM_SYSTEM_EVENT_CRASH:
qemu_mutex_lock_iothread();
qemu_system_guest_panicked();
qemu_mutex_unlock_iothread();
ret = 0;
break;
default:
DPRINTF("kvm_arch_handle_exit\n");
ret = kvm_arch_handle_exit(cpu, run);
break;
}
break;
default:
DPRINTF("kvm_arch_handle_exit\n");
ret = kvm_arch_handle_exit(cpu, run);
break;
}
} while (ret == 0);
qemu_mutex_lock_iothread();
if (ret < 0) {
cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
vm_stop(RUN_STATE_INTERNAL_ERROR);
}
cpu->exit_request = 0;
return ret;
}
|
{
"code": [],
"line_no": []
}
|
int FUNC_0(CPUState *VAR_0)
{
struct kvm_run *VAR_1 = VAR_0->kvm_run;
int VAR_2, VAR_3;
DPRINTF("FUNC_0()\n");
if (kvm_arch_process_async_events(VAR_0)) {
VAR_0->exit_request = 0;
return EXCP_HLT;
}
qemu_mutex_unlock_iothread();
do {
MemTxAttrs attrs;
if (VAR_0->kvm_vcpu_dirty) {
kvm_arch_put_registers(VAR_0, KVM_PUT_RUNTIME_STATE);
VAR_0->kvm_vcpu_dirty = false;
}
kvm_arch_pre_run(VAR_0, VAR_1);
if (VAR_0->exit_request) {
DPRINTF("interrupt exit requested\n");
qemu_cpu_kick_self();
}
VAR_3 = kvm_vcpu_ioctl(VAR_0, KVM_RUN, 0);
attrs = kvm_arch_post_run(VAR_0, VAR_1);
if (VAR_3 < 0) {
if (VAR_3 == -EINTR || VAR_3 == -EAGAIN) {
DPRINTF("io window exit\n");
VAR_2 = EXCP_INTERRUPT;
break;
}
fprintf(stderr, "error: kvm VAR_1 failed %s\n",
strerror(-VAR_3));
#ifdef TARGET_PPC
if (VAR_3 == -EBUSY) {
fprintf(stderr,
"This is probably because your SMT is enabled.\n"
"VCPU can only VAR_1 on primary threads with all "
"secondary threads offline.\n");
}
#endif
VAR_2 = -1;
break;
}
trace_kvm_run_exit(VAR_0->cpu_index, VAR_1->exit_reason);
switch (VAR_1->exit_reason) {
case KVM_EXIT_IO:
DPRINTF("handle_io\n");
kvm_handle_io(VAR_1->io.port, attrs,
(uint8_t *)VAR_1 + VAR_1->io.data_offset,
VAR_1->io.direction,
VAR_1->io.size,
VAR_1->io.count);
VAR_2 = 0;
break;
case KVM_EXIT_MMIO:
DPRINTF("handle_mmio\n");
address_space_rw(&address_space_memory,
VAR_1->mmio.phys_addr, attrs,
VAR_1->mmio.data,
VAR_1->mmio.len,
VAR_1->mmio.is_write);
VAR_2 = 0;
break;
case KVM_EXIT_IRQ_WINDOW_OPEN:
DPRINTF("irq_window_open\n");
VAR_2 = EXCP_INTERRUPT;
break;
case KVM_EXIT_SHUTDOWN:
DPRINTF("shutdown\n");
qemu_system_reset_request();
VAR_2 = EXCP_INTERRUPT;
break;
case KVM_EXIT_UNKNOWN:
fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
(uint64_t)VAR_1->hw.hardware_exit_reason);
VAR_2 = -1;
break;
case KVM_EXIT_INTERNAL_ERROR:
VAR_2 = kvm_handle_internal_error(VAR_0, VAR_1);
break;
case KVM_EXIT_SYSTEM_EVENT:
switch (VAR_1->system_event.type) {
case KVM_SYSTEM_EVENT_SHUTDOWN:
qemu_system_shutdown_request();
VAR_2 = EXCP_INTERRUPT;
break;
case KVM_SYSTEM_EVENT_RESET:
qemu_system_reset_request();
VAR_2 = EXCP_INTERRUPT;
break;
case KVM_SYSTEM_EVENT_CRASH:
qemu_mutex_lock_iothread();
qemu_system_guest_panicked();
qemu_mutex_unlock_iothread();
VAR_2 = 0;
break;
default:
DPRINTF("kvm_arch_handle_exit\n");
VAR_2 = kvm_arch_handle_exit(VAR_0, VAR_1);
break;
}
break;
default:
DPRINTF("kvm_arch_handle_exit\n");
VAR_2 = kvm_arch_handle_exit(VAR_0, VAR_1);
break;
}
} while (VAR_2 == 0);
qemu_mutex_lock_iothread();
if (VAR_2 < 0) {
cpu_dump_state(VAR_0, stderr, fprintf, CPU_DUMP_CODE);
vm_stop(RUN_STATE_INTERNAL_ERROR);
}
VAR_0->exit_request = 0;
return VAR_2;
}
|
[
"int FUNC_0(CPUState *VAR_0)\n{",
"struct kvm_run *VAR_1 = VAR_0->kvm_run;",
"int VAR_2, VAR_3;",
"DPRINTF(\"FUNC_0()\\n\");",
"if (kvm_arch_process_async_events(VAR_0)) {",
"VAR_0->exit_request = 0;",
"return EXCP_HLT;",
"}",
"qemu_mutex_unlock_iothread();",
"do {",
"MemTxAttrs attrs;",
"if (VAR_0->kvm_vcpu_dirty) {",
"kvm_arch_put_registers(VAR_0, KVM_PUT_RUNTIME_STATE);",
"VAR_0->kvm_vcpu_dirty = false;",
"}",
"kvm_arch_pre_run(VAR_0, VAR_1);",
"if (VAR_0->exit_request) {",
"DPRINTF(\"interrupt exit requested\\n\");",
"qemu_cpu_kick_self();",
"}",
"VAR_3 = kvm_vcpu_ioctl(VAR_0, KVM_RUN, 0);",
"attrs = kvm_arch_post_run(VAR_0, VAR_1);",
"if (VAR_3 < 0) {",
"if (VAR_3 == -EINTR || VAR_3 == -EAGAIN) {",
"DPRINTF(\"io window exit\\n\");",
"VAR_2 = EXCP_INTERRUPT;",
"break;",
"}",
"fprintf(stderr, \"error: kvm VAR_1 failed %s\\n\",\nstrerror(-VAR_3));",
"#ifdef TARGET_PPC\nif (VAR_3 == -EBUSY) {",
"fprintf(stderr,\n\"This is probably because your SMT is enabled.\\n\"\n\"VCPU can only VAR_1 on primary threads with all \"\n\"secondary threads offline.\\n\");",
"}",
"#endif\nVAR_2 = -1;",
"break;",
"}",
"trace_kvm_run_exit(VAR_0->cpu_index, VAR_1->exit_reason);",
"switch (VAR_1->exit_reason) {",
"case KVM_EXIT_IO:\nDPRINTF(\"handle_io\\n\");",
"kvm_handle_io(VAR_1->io.port, attrs,\n(uint8_t *)VAR_1 + VAR_1->io.data_offset,\nVAR_1->io.direction,\nVAR_1->io.size,\nVAR_1->io.count);",
"VAR_2 = 0;",
"break;",
"case KVM_EXIT_MMIO:\nDPRINTF(\"handle_mmio\\n\");",
"address_space_rw(&address_space_memory,\nVAR_1->mmio.phys_addr, attrs,\nVAR_1->mmio.data,\nVAR_1->mmio.len,\nVAR_1->mmio.is_write);",
"VAR_2 = 0;",
"break;",
"case KVM_EXIT_IRQ_WINDOW_OPEN:\nDPRINTF(\"irq_window_open\\n\");",
"VAR_2 = EXCP_INTERRUPT;",
"break;",
"case KVM_EXIT_SHUTDOWN:\nDPRINTF(\"shutdown\\n\");",
"qemu_system_reset_request();",
"VAR_2 = EXCP_INTERRUPT;",
"break;",
"case KVM_EXIT_UNKNOWN:\nfprintf(stderr, \"KVM: unknown exit, hardware reason %\" PRIx64 \"\\n\",\n(uint64_t)VAR_1->hw.hardware_exit_reason);",
"VAR_2 = -1;",
"break;",
"case KVM_EXIT_INTERNAL_ERROR:\nVAR_2 = kvm_handle_internal_error(VAR_0, VAR_1);",
"break;",
"case KVM_EXIT_SYSTEM_EVENT:\nswitch (VAR_1->system_event.type) {",
"case KVM_SYSTEM_EVENT_SHUTDOWN:\nqemu_system_shutdown_request();",
"VAR_2 = EXCP_INTERRUPT;",
"break;",
"case KVM_SYSTEM_EVENT_RESET:\nqemu_system_reset_request();",
"VAR_2 = EXCP_INTERRUPT;",
"break;",
"case KVM_SYSTEM_EVENT_CRASH:\nqemu_mutex_lock_iothread();",
"qemu_system_guest_panicked();",
"qemu_mutex_unlock_iothread();",
"VAR_2 = 0;",
"break;",
"default:\nDPRINTF(\"kvm_arch_handle_exit\\n\");",
"VAR_2 = kvm_arch_handle_exit(VAR_0, VAR_1);",
"break;",
"}",
"break;",
"default:\nDPRINTF(\"kvm_arch_handle_exit\\n\");",
"VAR_2 = kvm_arch_handle_exit(VAR_0, VAR_1);",
"break;",
"}",
"} while (VAR_2 == 0);",
"qemu_mutex_lock_iothread();",
"if (VAR_2 < 0) {",
"cpu_dump_state(VAR_0, stderr, fprintf, CPU_DUMP_CODE);",
"vm_stop(RUN_STATE_INTERNAL_ERROR);",
"}",
"VAR_0->exit_request = 0;",
"return VAR_2;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
61
],
[
63
],
[
67
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87,
89
],
[
91,
93
],
[
95,
97,
99,
101
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119,
121
],
[
125,
127,
129,
131,
133
],
[
135
],
[
137
],
[
139,
141
],
[
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,
216
],
[
218
],
[
220
],
[
222
],
[
224
],
[
226,
228
],
[
230
],
[
232
],
[
234
],
[
236
],
[
238,
240
],
[
242
],
[
244
],
[
246
],
[
248
],
[
252
],
[
256
],
[
258
],
[
260
],
[
262
],
[
266
],
[
268
],
[
270
]
] |
8,091 |
static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
AVIOContext *pb = s->pb;
AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int duration = pkt->duration;
int ret;
int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
if (ts == AV_NOPTS_VALUE) {
av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
return AVERROR(EINVAL);
}
if (!s->pb->seekable) {
if (!mkv->dyn_bc)
avio_open_dyn_buf(&mkv->dyn_bc);
pb = mkv->dyn_bc;
}
if (mkv->cluster_pos == -1) {
mkv->cluster_pos = avio_tell(s->pb);
mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));
mkv->cluster_pts = FFMAX(0, ts);
}
if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
} else if (codec->codec_id == AV_CODEC_ID_SSA) {
duration = mkv_write_ass_blocks(s, pb, pkt);
} else if (codec->codec_id == AV_CODEC_ID_SRT) {
duration = mkv_write_srt_blocks(s, pb, pkt);
} else {
ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size));
/* For backward compatibility, prefer convergence_duration. */
if (pkt->convergence_duration > 0) {
duration = pkt->convergence_duration;
}
mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 0);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
end_ebml_master(pb, blockgroup);
}
if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) {
ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts, mkv->cluster_pos);
if (ret < 0) return ret;
}
mkv->duration = FFMAX(mkv->duration, ts + duration);
return 0;
}
| false |
FFmpeg
|
b1f517f503139ab9d0c406228b53663e86a128df
|
static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
AVIOContext *pb = s->pb;
AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int duration = pkt->duration;
int ret;
int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
if (ts == AV_NOPTS_VALUE) {
av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
return AVERROR(EINVAL);
}
if (!s->pb->seekable) {
if (!mkv->dyn_bc)
avio_open_dyn_buf(&mkv->dyn_bc);
pb = mkv->dyn_bc;
}
if (mkv->cluster_pos == -1) {
mkv->cluster_pos = avio_tell(s->pb);
mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));
mkv->cluster_pts = FFMAX(0, ts);
}
if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
} else if (codec->codec_id == AV_CODEC_ID_SSA) {
duration = mkv_write_ass_blocks(s, pb, pkt);
} else if (codec->codec_id == AV_CODEC_ID_SRT) {
duration = mkv_write_srt_blocks(s, pb, pkt);
} else {
ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size));
if (pkt->convergence_duration > 0) {
duration = pkt->convergence_duration;
}
mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 0);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
end_ebml_master(pb, blockgroup);
}
if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) {
ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, ts, mkv->cluster_pos);
if (ret < 0) return ret;
}
mkv->duration = FFMAX(mkv->duration, ts + duration);
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
MatroskaMuxContext *mkv = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
AVCodecContext *codec = VAR_0->streams[VAR_1->stream_index]->codec;
int VAR_2 = !!(VAR_1->flags & AV_PKT_FLAG_KEY);
int VAR_3 = VAR_1->VAR_3;
int VAR_4;
int64_t ts = mkv->tracks[VAR_1->stream_index].write_dts ? VAR_1->dts : VAR_1->pts;
if (ts == AV_NOPTS_VALUE) {
av_log(VAR_0, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
return AVERROR(EINVAL);
}
if (!VAR_0->pb->seekable) {
if (!mkv->dyn_bc)
avio_open_dyn_buf(&mkv->dyn_bc);
pb = mkv->dyn_bc;
}
if (mkv->cluster_pos == -1) {
mkv->cluster_pos = avio_tell(VAR_0->pb);
mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);
put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));
mkv->cluster_pts = FFMAX(0, ts);
}
if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
mkv_write_block(VAR_0, pb, MATROSKA_ID_SIMPLEBLOCK, VAR_1, VAR_2 << 7);
} else if (codec->codec_id == AV_CODEC_ID_SSA) {
VAR_3 = mkv_write_ass_blocks(VAR_0, pb, VAR_1);
} else if (codec->codec_id == AV_CODEC_ID_SRT) {
VAR_3 = mkv_write_srt_blocks(VAR_0, pb, VAR_1);
} else {
ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(VAR_1->size));
if (VAR_1->convergence_duration > 0) {
VAR_3 = VAR_1->convergence_duration;
}
mkv_write_block(VAR_0, pb, MATROSKA_ID_BLOCK, VAR_1, 0);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, VAR_3);
end_ebml_master(pb, blockgroup);
}
if (codec->codec_type == AVMEDIA_TYPE_VIDEO && VAR_2) {
VAR_4 = mkv_add_cuepoint(mkv->cues, VAR_1->stream_index, ts, mkv->cluster_pos);
if (VAR_4 < 0) return VAR_4;
}
mkv->VAR_3 = FFMAX(mkv->VAR_3, ts + VAR_3);
return 0;
}
|
[
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"MatroskaMuxContext *mkv = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"AVCodecContext *codec = VAR_0->streams[VAR_1->stream_index]->codec;",
"int VAR_2 = !!(VAR_1->flags & AV_PKT_FLAG_KEY);",
"int VAR_3 = VAR_1->VAR_3;",
"int VAR_4;",
"int64_t ts = mkv->tracks[VAR_1->stream_index].write_dts ? VAR_1->dts : VAR_1->pts;",
"if (ts == AV_NOPTS_VALUE) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Can't write packet with unknown timestamp\\n\");",
"return AVERROR(EINVAL);",
"}",
"if (!VAR_0->pb->seekable) {",
"if (!mkv->dyn_bc)\navio_open_dyn_buf(&mkv->dyn_bc);",
"pb = mkv->dyn_bc;",
"}",
"if (mkv->cluster_pos == -1) {",
"mkv->cluster_pos = avio_tell(VAR_0->pb);",
"mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);",
"put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));",
"mkv->cluster_pts = FFMAX(0, ts);",
"}",
"if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {",
"mkv_write_block(VAR_0, pb, MATROSKA_ID_SIMPLEBLOCK, VAR_1, VAR_2 << 7);",
"} else if (codec->codec_id == AV_CODEC_ID_SSA) {",
"VAR_3 = mkv_write_ass_blocks(VAR_0, pb, VAR_1);",
"} else if (codec->codec_id == AV_CODEC_ID_SRT) {",
"VAR_3 = mkv_write_srt_blocks(VAR_0, pb, VAR_1);",
"} else {",
"ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(VAR_1->size));",
"if (VAR_1->convergence_duration > 0) {",
"VAR_3 = VAR_1->convergence_duration;",
"}",
"mkv_write_block(VAR_0, pb, MATROSKA_ID_BLOCK, VAR_1, 0);",
"put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, VAR_3);",
"end_ebml_master(pb, blockgroup);",
"}",
"if (codec->codec_type == AVMEDIA_TYPE_VIDEO && VAR_2) {",
"VAR_4 = mkv_add_cuepoint(mkv->cues, VAR_1->stream_index, ts, mkv->cluster_pos);",
"if (VAR_4 < 0) return VAR_4;",
"}",
"mkv->VAR_3 = FFMAX(mkv->VAR_3, ts + VAR_3);",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101
],
[
103
],
[
105
]
] |
8,092 |
static int adpcm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
ADPCMContext *c = avctx->priv_data;
ADPCMChannelStatus *cs;
int n, m, channel, i;
int block_predictor[2];
short *samples;
uint8_t *src;
int st; /* stereo */
/* DK3 ADPCM accounting variables */
unsigned char last_byte = 0;
unsigned char nibble;
int decode_top_nibble_next = 0;
int diff_channel;
samples = data;
src = buf;
st = avctx->channels == 2;
switch(avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_QT:
n = (buf_size - 2);/* >> 2*avctx->channels;*/
channel = c->channel;
cs = &(c->status[channel]);
/* (pppppp) (piiiiiii) */
/* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */
cs->predictor = (*src++) << 8;
cs->predictor |= (*src & 0x80);
cs->predictor &= 0xFF80;
/* sign extension */
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = (*src++) & 0x7F;
if (cs->step_index > 88) fprintf(stderr, "ERROR: step_index = %i\n", cs->step_index);
if (cs->step_index > 88) cs->step_index = 88;
cs->step = step_table[cs->step_index];
if (st && channel)
samples++;
*samples++ = cs->predictor;
samples += st;
for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
*samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F);
samples += avctx->channels;
*samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F);
samples += avctx->channels;
src ++;
}
if(st) { /* handle stereo interlacing */
c->channel = (channel + 1) % 2; /* we get one packet for left, then one for right data */
if(channel == 0) { /* wait for the other packet before outputing anything */
*data_size = 0;
return src - buf;
}
}
break;
case CODEC_ID_ADPCM_IMA_WAV:
if (avctx->block_align != 0 && buf_size > avctx->block_align)
buf_size = avctx->block_align;
// XXX: do as per-channel loop
cs = &(c->status[0]);
cs->predictor = (*src++) & 0x0FF;
cs->predictor |= ((*src++) << 8) & 0x0FF00;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
// XXX: is this correct ??: *samples++ = cs->predictor;
cs->step_index = *src++;
if (cs->step_index < 0) cs->step_index = 0;
if (cs->step_index > 88) cs->step_index = 88;
if (*src++) fprintf(stderr, "unused byte should be null !!\n"); /* unused */
if (st) {
cs = &(c->status[1]);
cs->predictor = (*src++) & 0x0FF;
cs->predictor |= ((*src++) << 8) & 0x0FF00;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
// XXX: is this correct ??: *samples++ = cs->predictor;
cs->step_index = *src++;
if (cs->step_index < 0) cs->step_index = 0;
if (cs->step_index > 88) cs->step_index = 88;
src++; /* if != 0 -> out-of-sync */
}
for(m=4; src < (buf + buf_size);) {
*samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F);
if (st)
*samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
if (st) {
*samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F);
if (!--m) {
m=4;
src+=4;
}
}
src++;
}
break;
case CODEC_ID_ADPCM_4XM:
cs = &(c->status[0]);
c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
if(st){
c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
}
c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
if(st){
c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
}
// if (cs->step_index < 0) cs->step_index = 0;
// if (cs->step_index > 88) cs->step_index = 88;
m= (buf_size - (src - buf))>>st;
//printf("%d %d %d %d\n", st, m, c->status[0].predictor, c->status[0].step_index);
//FIXME / XXX decode chanels individual & interleave samples
for(i=0; i<m; i++) {
*samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] & 0x0F);
if (st)
*samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] & 0x0F);
*samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] >> 4);
if (st)
*samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] >> 4);
}
src += m<<st;
break;
case CODEC_ID_ADPCM_MS:
if (avctx->block_align != 0 && buf_size > avctx->block_align)
buf_size = avctx->block_align;
n = buf_size - 7 * avctx->channels;
if (n < 0)
return -1;
block_predictor[0] = (*src++); /* should be bound */
block_predictor[0] = (block_predictor[0] < 0)?(0):((block_predictor[0] > 7)?(7):(block_predictor[0]));
block_predictor[1] = 0;
if (st)
block_predictor[1] = (*src++);
block_predictor[1] = (block_predictor[1] < 0)?(0):((block_predictor[1] > 7)?(7):(block_predictor[1]));
c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (c->status[0].idelta & 0x08000)
c->status[0].idelta -= 0x10000;
src+=2;
if (st)
c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (st && c->status[1].idelta & 0x08000)
c->status[1].idelta |= 0xFFFF0000;
if (st)
src+=2;
c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
src+=2;
if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (st) src+=2;
c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
src+=2;
if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (st) src+=2;
*samples++ = c->status[0].sample1;
if (st) *samples++ = c->status[1].sample1;
*samples++ = c->status[0].sample2;
if (st) *samples++ = c->status[1].sample2;
for(;n>0;n--) {
*samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
*samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
src ++;
}
break;
case CODEC_ID_ADPCM_IMA_DK4:
if (buf_size > BLKSIZE) {
if (avctx->block_align != 0)
buf_size = avctx->block_align;
else
buf_size = BLKSIZE;
}
c->status[0].predictor = (src[0] | (src[1] << 8));
c->status[0].step_index = src[2];
src += 4;
if(c->status[0].predictor & 0x8000)
c->status[0].predictor -= 0x10000;
*samples++ = c->status[0].predictor;
if (st) {
c->status[1].predictor = (src[0] | (src[1] << 8));
c->status[1].step_index = src[2];
src += 4;
if(c->status[1].predictor & 0x8000)
c->status[1].predictor -= 0x10000;
*samples++ = c->status[1].predictor;
}
while (src < buf + buf_size) {
/* take care of the top nibble (always left or mono channel) */
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
/* take care of the bottom nibble, which is right sample for
* stereo, or another mono sample */
if (st)
*samples++ = adpcm_ima_expand_nibble(&c->status[1],
src[0] & 0x0F);
else
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
src[0] & 0x0F);
src++;
}
break;
case CODEC_ID_ADPCM_IMA_DK3:
if (buf_size > BLKSIZE) {
if (avctx->block_align != 0)
buf_size = avctx->block_align;
else
buf_size = BLKSIZE;
}
c->status[0].predictor = (src[10] | (src[11] << 8));
c->status[1].predictor = (src[12] | (src[13] << 8));
c->status[0].step_index = src[14];
c->status[1].step_index = src[15];
/* sign extend the predictors */
if(c->status[0].predictor & 0x8000)
c->status[0].predictor -= 0x10000;
if(c->status[1].predictor & 0x8000)
c->status[1].predictor -= 0x10000;
src += 16;
diff_channel = c->status[1].predictor;
/* the DK3_GET_NEXT_NIBBLE macro issues the break statement when
* the buffer is consumed */
while (1) {
/* for this algorithm, c->status[0] is the sum channel and
* c->status[1] is the diff channel */
/* process the first predictor of the sum channel */
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], nibble);
/* process the diff channel predictor */
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[1], nibble);
/* process the first pair of stereo PCM samples */
diff_channel = (diff_channel + c->status[1].predictor) / 2;
*samples++ = c->status[0].predictor + c->status[1].predictor;
*samples++ = c->status[0].predictor - c->status[1].predictor;
/* process the second predictor of the sum channel */
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], nibble);
/* process the second pair of stereo PCM samples */
diff_channel = (diff_channel + c->status[1].predictor) / 2;
*samples++ = c->status[0].predictor + c->status[1].predictor;
*samples++ = c->status[0].predictor - c->status[1].predictor;
}
break;
case CODEC_ID_ADPCM_IMA_WS:
/* no per-block initialization; just start decoding the data */
while (src < buf + buf_size) {
if (st) {
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
*samples++ = adpcm_ima_expand_nibble(&c->status[1],
src[0] & 0x0F);
} else {
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
src[0] & 0x0F);
}
src++;
}
break;
case CODEC_ID_ADPCM_XA:
c->status[0].sample1 = c->status[0].sample2 =
c->status[1].sample1 = c->status[1].sample2 = 0;
while (buf_size >= 128) {
xa_decode(samples, src, &c->status[0], &c->status[1],
avctx->channels);
src += 128;
samples += 28 * 8;
buf_size -= 128;
}
break;
default:
*data_size = 0;
return -1;
}
*data_size = (uint8_t *)samples - (uint8_t *)data;
return src - buf;
}
| false |
FFmpeg
|
5c69a4fd682ae479f0921361b7953e6163bd3064
|
static int adpcm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
ADPCMContext *c = avctx->priv_data;
ADPCMChannelStatus *cs;
int n, m, channel, i;
int block_predictor[2];
short *samples;
uint8_t *src;
int st;
unsigned char last_byte = 0;
unsigned char nibble;
int decode_top_nibble_next = 0;
int diff_channel;
samples = data;
src = buf;
st = avctx->channels == 2;
switch(avctx->codec->id) {
case CODEC_ID_ADPCM_IMA_QT:
n = (buf_size - 2);
channel = c->channel;
cs = &(c->status[channel]);
cs->predictor = (*src++) << 8;
cs->predictor |= (*src & 0x80);
cs->predictor &= 0xFF80;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = (*src++) & 0x7F;
if (cs->step_index > 88) fprintf(stderr, "ERROR: step_index = %i\n", cs->step_index);
if (cs->step_index > 88) cs->step_index = 88;
cs->step = step_table[cs->step_index];
if (st && channel)
samples++;
*samples++ = cs->predictor;
samples += st;
for(m=32; n>0 && m>0; n--, m--) {
*samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F);
samples += avctx->channels;
*samples = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F);
samples += avctx->channels;
src ++;
}
if(st) {
c->channel = (channel + 1) % 2;
if(channel == 0) {
*data_size = 0;
return src - buf;
}
}
break;
case CODEC_ID_ADPCM_IMA_WAV:
if (avctx->block_align != 0 && buf_size > avctx->block_align)
buf_size = avctx->block_align;
cs = &(c->status[0]);
cs->predictor = (*src++) & 0x0FF;
cs->predictor |= ((*src++) << 8) & 0x0FF00;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = *src++;
if (cs->step_index < 0) cs->step_index = 0;
if (cs->step_index > 88) cs->step_index = 88;
if (*src++) fprintf(stderr, "unused byte should be null !!\n");
if (st) {
cs = &(c->status[1]);
cs->predictor = (*src++) & 0x0FF;
cs->predictor |= ((*src++) << 8) & 0x0FF00;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = *src++;
if (cs->step_index < 0) cs->step_index = 0;
if (cs->step_index > 88) cs->step_index = 88;
src++;
}
for(m=4; src < (buf + buf_size);) {
*samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F);
if (st)
*samples++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
if (st) {
*samples++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F);
if (!--m) {
m=4;
src+=4;
}
}
src++;
}
break;
case CODEC_ID_ADPCM_4XM:
cs = &(c->status[0]);
c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
if(st){
c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
}
c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
if(st){
c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
}
m= (buf_size - (src - buf))>>st;
for(i=0; i<m; i++) {
*samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] & 0x0F);
if (st)
*samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] & 0x0F);
*samples++ = adpcm_4xa_expand_nibble(&c->status[0], src[i] >> 4);
if (st)
*samples++ = adpcm_4xa_expand_nibble(&c->status[1], src[i+m] >> 4);
}
src += m<<st;
break;
case CODEC_ID_ADPCM_MS:
if (avctx->block_align != 0 && buf_size > avctx->block_align)
buf_size = avctx->block_align;
n = buf_size - 7 * avctx->channels;
if (n < 0)
return -1;
block_predictor[0] = (*src++);
block_predictor[0] = (block_predictor[0] < 0)?(0):((block_predictor[0] > 7)?(7):(block_predictor[0]));
block_predictor[1] = 0;
if (st)
block_predictor[1] = (*src++);
block_predictor[1] = (block_predictor[1] < 0)?(0):((block_predictor[1] > 7)?(7):(block_predictor[1]));
c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (c->status[0].idelta & 0x08000)
c->status[0].idelta -= 0x10000;
src+=2;
if (st)
c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (st && c->status[1].idelta & 0x08000)
c->status[1].idelta |= 0xFFFF0000;
if (st)
src+=2;
c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]];
c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]];
c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]];
c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]];
c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
src+=2;
if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (st) src+=2;
c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
src+=2;
if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (st) src+=2;
*samples++ = c->status[0].sample1;
if (st) *samples++ = c->status[1].sample1;
*samples++ = c->status[0].sample2;
if (st) *samples++ = c->status[1].sample2;
for(;n>0;n--) {
*samples++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
*samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F);
src ++;
}
break;
case CODEC_ID_ADPCM_IMA_DK4:
if (buf_size > BLKSIZE) {
if (avctx->block_align != 0)
buf_size = avctx->block_align;
else
buf_size = BLKSIZE;
}
c->status[0].predictor = (src[0] | (src[1] << 8));
c->status[0].step_index = src[2];
src += 4;
if(c->status[0].predictor & 0x8000)
c->status[0].predictor -= 0x10000;
*samples++ = c->status[0].predictor;
if (st) {
c->status[1].predictor = (src[0] | (src[1] << 8));
c->status[1].step_index = src[2];
src += 4;
if(c->status[1].predictor & 0x8000)
c->status[1].predictor -= 0x10000;
*samples++ = c->status[1].predictor;
}
while (src < buf + buf_size) {
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
if (st)
*samples++ = adpcm_ima_expand_nibble(&c->status[1],
src[0] & 0x0F);
else
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
src[0] & 0x0F);
src++;
}
break;
case CODEC_ID_ADPCM_IMA_DK3:
if (buf_size > BLKSIZE) {
if (avctx->block_align != 0)
buf_size = avctx->block_align;
else
buf_size = BLKSIZE;
}
c->status[0].predictor = (src[10] | (src[11] << 8));
c->status[1].predictor = (src[12] | (src[13] << 8));
c->status[0].step_index = src[14];
c->status[1].step_index = src[15];
if(c->status[0].predictor & 0x8000)
c->status[0].predictor -= 0x10000;
if(c->status[1].predictor & 0x8000)
c->status[1].predictor -= 0x10000;
src += 16;
diff_channel = c->status[1].predictor;
while (1) {
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], nibble);
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[1], nibble);
diff_channel = (diff_channel + c->status[1].predictor) / 2;
*samples++ = c->status[0].predictor + c->status[1].predictor;
*samples++ = c->status[0].predictor - c->status[1].predictor;
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], nibble);
diff_channel = (diff_channel + c->status[1].predictor) / 2;
*samples++ = c->status[0].predictor + c->status[1].predictor;
*samples++ = c->status[0].predictor - c->status[1].predictor;
}
break;
case CODEC_ID_ADPCM_IMA_WS:
while (src < buf + buf_size) {
if (st) {
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
*samples++ = adpcm_ima_expand_nibble(&c->status[1],
src[0] & 0x0F);
} else {
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
*samples++ = adpcm_ima_expand_nibble(&c->status[0],
src[0] & 0x0F);
}
src++;
}
break;
case CODEC_ID_ADPCM_XA:
c->status[0].sample1 = c->status[0].sample2 =
c->status[1].sample1 = c->status[1].sample2 = 0;
while (buf_size >= 128) {
xa_decode(samples, src, &c->status[0], &c->status[1],
avctx->channels);
src += 128;
samples += 28 * 8;
buf_size -= 128;
}
break;
default:
*data_size = 0;
return -1;
}
*data_size = (uint8_t *)samples - (uint8_t *)data;
return src - buf;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
uint8_t *VAR_3, int VAR_4)
{
ADPCMContext *c = VAR_0->priv_data;
ADPCMChannelStatus *cs;
int VAR_5, VAR_6, VAR_7, VAR_8;
int VAR_9[2];
short *VAR_10;
uint8_t *src;
int VAR_11;
unsigned char VAR_12 = 0;
unsigned char VAR_13;
int VAR_14 = 0;
int VAR_15;
VAR_10 = VAR_1;
src = VAR_3;
VAR_11 = VAR_0->channels == 2;
switch(VAR_0->codec->id) {
case CODEC_ID_ADPCM_IMA_QT:
VAR_5 = (VAR_4 - 2);
VAR_7 = c->VAR_7;
cs = &(c->status[VAR_7]);
cs->predictor = (*src++) << 8;
cs->predictor |= (*src & 0x80);
cs->predictor &= 0xFF80;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = (*src++) & 0x7F;
if (cs->step_index > 88) fprintf(stderr, "ERROR: step_index = %VAR_8\VAR_5", cs->step_index);
if (cs->step_index > 88) cs->step_index = 88;
cs->step = step_table[cs->step_index];
if (VAR_11 && VAR_7)
VAR_10++;
*VAR_10++ = cs->predictor;
VAR_10 += VAR_11;
for(VAR_6=32; VAR_5>0 && VAR_6>0; VAR_5--, VAR_6--) {
*VAR_10 = adpcm_ima_expand_nibble(cs, src[0] & 0x0F);
VAR_10 += VAR_0->channels;
*VAR_10 = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F);
VAR_10 += VAR_0->channels;
src ++;
}
if(VAR_11) {
c->VAR_7 = (VAR_7 + 1) % 2;
if(VAR_7 == 0) {
*VAR_2 = 0;
return src - VAR_3;
}
}
break;
case CODEC_ID_ADPCM_IMA_WAV:
if (VAR_0->block_align != 0 && VAR_4 > VAR_0->block_align)
VAR_4 = VAR_0->block_align;
cs = &(c->status[0]);
cs->predictor = (*src++) & 0x0FF;
cs->predictor |= ((*src++) << 8) & 0x0FF00;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = *src++;
if (cs->step_index < 0) cs->step_index = 0;
if (cs->step_index > 88) cs->step_index = 88;
if (*src++) fprintf(stderr, "unused byte should be null !!\VAR_5");
if (VAR_11) {
cs = &(c->status[1]);
cs->predictor = (*src++) & 0x0FF;
cs->predictor |= ((*src++) << 8) & 0x0FF00;
if(cs->predictor & 0x8000)
cs->predictor -= 0x10000;
CLAMP_TO_SHORT(cs->predictor);
cs->step_index = *src++;
if (cs->step_index < 0) cs->step_index = 0;
if (cs->step_index > 88) cs->step_index = 88;
src++;
}
for(VAR_6=4; src < (VAR_3 + VAR_4);) {
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F);
if (VAR_11)
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F);
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
if (VAR_11) {
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F);
if (!--VAR_6) {
VAR_6=4;
src+=4;
}
}
src++;
}
break;
case CODEC_ID_ADPCM_4XM:
cs = &(c->status[0]);
c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
if(VAR_11){
c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;
}
c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
if(VAR_11){
c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;
}
VAR_6= (VAR_4 - (src - VAR_3))>>VAR_11;
for(VAR_8=0; VAR_8<VAR_6; VAR_8++) {
*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[0], src[VAR_8] & 0x0F);
if (VAR_11)
*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[1], src[VAR_8+VAR_6] & 0x0F);
*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[0], src[VAR_8] >> 4);
if (VAR_11)
*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[1], src[VAR_8+VAR_6] >> 4);
}
src += VAR_6<<VAR_11;
break;
case CODEC_ID_ADPCM_MS:
if (VAR_0->block_align != 0 && VAR_4 > VAR_0->block_align)
VAR_4 = VAR_0->block_align;
VAR_5 = VAR_4 - 7 * VAR_0->channels;
if (VAR_5 < 0)
return -1;
VAR_9[0] = (*src++);
VAR_9[0] = (VAR_9[0] < 0)?(0):((VAR_9[0] > 7)?(7):(VAR_9[0]));
VAR_9[1] = 0;
if (VAR_11)
VAR_9[1] = (*src++);
VAR_9[1] = (VAR_9[1] < 0)?(0):((VAR_9[1] > 7)?(7):(VAR_9[1]));
c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (c->status[0].idelta & 0x08000)
c->status[0].idelta -= 0x10000;
src+=2;
if (VAR_11)
c->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (VAR_11 && c->status[1].idelta & 0x08000)
c->status[1].idelta |= 0xFFFF0000;
if (VAR_11)
src+=2;
c->status[0].coeff1 = AdaptCoeff1[VAR_9[0]];
c->status[0].coeff2 = AdaptCoeff2[VAR_9[0]];
c->status[1].coeff1 = AdaptCoeff1[VAR_9[1]];
c->status[1].coeff2 = AdaptCoeff2[VAR_9[1]];
c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
src+=2;
if (VAR_11) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (VAR_11) src+=2;
c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
src+=2;
if (VAR_11) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));
if (VAR_11) src+=2;
*VAR_10++ = c->status[0].sample1;
if (VAR_11) *VAR_10++ = c->status[1].sample1;
*VAR_10++ = c->status[0].sample2;
if (VAR_11) *VAR_10++ = c->status[1].sample2;
for(;VAR_5>0;VAR_5--) {
*VAR_10++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);
*VAR_10++ = adpcm_ms_expand_nibble(&c->status[VAR_11], src[0] & 0x0F);
src ++;
}
break;
case CODEC_ID_ADPCM_IMA_DK4:
if (VAR_4 > BLKSIZE) {
if (VAR_0->block_align != 0)
VAR_4 = VAR_0->block_align;
else
VAR_4 = BLKSIZE;
}
c->status[0].predictor = (src[0] | (src[1] << 8));
c->status[0].step_index = src[2];
src += 4;
if(c->status[0].predictor & 0x8000)
c->status[0].predictor -= 0x10000;
*VAR_10++ = c->status[0].predictor;
if (VAR_11) {
c->status[1].predictor = (src[0] | (src[1] << 8));
c->status[1].step_index = src[2];
src += 4;
if(c->status[1].predictor & 0x8000)
c->status[1].predictor -= 0x10000;
*VAR_10++ = c->status[1].predictor;
}
while (src < VAR_3 + VAR_4) {
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
if (VAR_11)
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1],
src[0] & 0x0F);
else
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],
src[0] & 0x0F);
src++;
}
break;
case CODEC_ID_ADPCM_IMA_DK3:
if (VAR_4 > BLKSIZE) {
if (VAR_0->block_align != 0)
VAR_4 = VAR_0->block_align;
else
VAR_4 = BLKSIZE;
}
c->status[0].predictor = (src[10] | (src[11] << 8));
c->status[1].predictor = (src[12] | (src[13] << 8));
c->status[0].step_index = src[14];
c->status[1].step_index = src[15];
if(c->status[0].predictor & 0x8000)
c->status[0].predictor -= 0x10000;
if(c->status[1].predictor & 0x8000)
c->status[1].predictor -= 0x10000;
src += 16;
VAR_15 = c->status[1].predictor;
while (1) {
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], VAR_13);
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[1], VAR_13);
VAR_15 = (VAR_15 + c->status[1].predictor) / 2;
*VAR_10++ = c->status[0].predictor + c->status[1].predictor;
*VAR_10++ = c->status[0].predictor - c->status[1].predictor;
DK3_GET_NEXT_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], VAR_13);
VAR_15 = (VAR_15 + c->status[1].predictor) / 2;
*VAR_10++ = c->status[0].predictor + c->status[1].predictor;
*VAR_10++ = c->status[0].predictor - c->status[1].predictor;
}
break;
case CODEC_ID_ADPCM_IMA_WS:
while (src < VAR_3 + VAR_4) {
if (VAR_11) {
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1],
src[0] & 0x0F);
} else {
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],
(src[0] >> 4) & 0x0F);
*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],
src[0] & 0x0F);
}
src++;
}
break;
case CODEC_ID_ADPCM_XA:
c->status[0].sample1 = c->status[0].sample2 =
c->status[1].sample1 = c->status[1].sample2 = 0;
while (VAR_4 >= 128) {
xa_decode(VAR_10, src, &c->status[0], &c->status[1],
VAR_0->channels);
src += 128;
VAR_10 += 28 * 8;
VAR_4 -= 128;
}
break;
default:
*VAR_2 = 0;
return -1;
}
*VAR_2 = (uint8_t *)VAR_10 - (uint8_t *)VAR_1;
return src - VAR_3;
}
|
[
"static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{",
"ADPCMContext *c = VAR_0->priv_data;",
"ADPCMChannelStatus *cs;",
"int VAR_5, VAR_6, VAR_7, VAR_8;",
"int VAR_9[2];",
"short *VAR_10;",
"uint8_t *src;",
"int VAR_11;",
"unsigned char VAR_12 = 0;",
"unsigned char VAR_13;",
"int VAR_14 = 0;",
"int VAR_15;",
"VAR_10 = VAR_1;",
"src = VAR_3;",
"VAR_11 = VAR_0->channels == 2;",
"switch(VAR_0->codec->id) {",
"case CODEC_ID_ADPCM_IMA_QT:\nVAR_5 = (VAR_4 - 2);",
"VAR_7 = c->VAR_7;",
"cs = &(c->status[VAR_7]);",
"cs->predictor = (*src++) << 8;",
"cs->predictor |= (*src & 0x80);",
"cs->predictor &= 0xFF80;",
"if(cs->predictor & 0x8000)\ncs->predictor -= 0x10000;",
"CLAMP_TO_SHORT(cs->predictor);",
"cs->step_index = (*src++) & 0x7F;",
"if (cs->step_index > 88) fprintf(stderr, \"ERROR: step_index = %VAR_8\\VAR_5\", cs->step_index);",
"if (cs->step_index > 88) cs->step_index = 88;",
"cs->step = step_table[cs->step_index];",
"if (VAR_11 && VAR_7)\nVAR_10++;",
"*VAR_10++ = cs->predictor;",
"VAR_10 += VAR_11;",
"for(VAR_6=32; VAR_5>0 && VAR_6>0; VAR_5--, VAR_6--) {",
"*VAR_10 = adpcm_ima_expand_nibble(cs, src[0] & 0x0F);",
"VAR_10 += VAR_0->channels;",
"*VAR_10 = adpcm_ima_expand_nibble(cs, (src[0] >> 4) & 0x0F);",
"VAR_10 += VAR_0->channels;",
"src ++;",
"}",
"if(VAR_11) {",
"c->VAR_7 = (VAR_7 + 1) % 2;",
"if(VAR_7 == 0) {",
"*VAR_2 = 0;",
"return src - VAR_3;",
"}",
"}",
"break;",
"case CODEC_ID_ADPCM_IMA_WAV:\nif (VAR_0->block_align != 0 && VAR_4 > VAR_0->block_align)\nVAR_4 = VAR_0->block_align;",
"cs = &(c->status[0]);",
"cs->predictor = (*src++) & 0x0FF;",
"cs->predictor |= ((*src++) << 8) & 0x0FF00;",
"if(cs->predictor & 0x8000)\ncs->predictor -= 0x10000;",
"CLAMP_TO_SHORT(cs->predictor);",
"cs->step_index = *src++;",
"if (cs->step_index < 0) cs->step_index = 0;",
"if (cs->step_index > 88) cs->step_index = 88;",
"if (*src++) fprintf(stderr, \"unused byte should be null !!\\VAR_5\");",
"if (VAR_11) {",
"cs = &(c->status[1]);",
"cs->predictor = (*src++) & 0x0FF;",
"cs->predictor |= ((*src++) << 8) & 0x0FF00;",
"if(cs->predictor & 0x8000)\ncs->predictor -= 0x10000;",
"CLAMP_TO_SHORT(cs->predictor);",
"cs->step_index = *src++;",
"if (cs->step_index < 0) cs->step_index = 0;",
"if (cs->step_index > 88) cs->step_index = 88;",
"src++;",
"}",
"for(VAR_6=4; src < (VAR_3 + VAR_4);) {",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0], src[0] & 0x0F);",
"if (VAR_11)\n*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1], src[4] & 0x0F);",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);",
"if (VAR_11) {",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1], (src[4] >> 4) & 0x0F);",
"if (!--VAR_6) {",
"VAR_6=4;",
"src+=4;",
"}",
"}",
"src++;",
"}",
"break;",
"case CODEC_ID_ADPCM_4XM:\ncs = &(c->status[0]);",
"c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;",
"if(VAR_11){",
"c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2;",
"}",
"c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;",
"if(VAR_11){",
"c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2;",
"}",
"VAR_6= (VAR_4 - (src - VAR_3))>>VAR_11;",
"for(VAR_8=0; VAR_8<VAR_6; VAR_8++) {",
"*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[0], src[VAR_8] & 0x0F);",
"if (VAR_11)\n*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[1], src[VAR_8+VAR_6] & 0x0F);",
"*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[0], src[VAR_8] >> 4);",
"if (VAR_11)\n*VAR_10++ = adpcm_4xa_expand_nibble(&c->status[1], src[VAR_8+VAR_6] >> 4);",
"}",
"src += VAR_6<<VAR_11;",
"break;",
"case CODEC_ID_ADPCM_MS:\nif (VAR_0->block_align != 0 && VAR_4 > VAR_0->block_align)\nVAR_4 = VAR_0->block_align;",
"VAR_5 = VAR_4 - 7 * VAR_0->channels;",
"if (VAR_5 < 0)\nreturn -1;",
"VAR_9[0] = (*src++);",
"VAR_9[0] = (VAR_9[0] < 0)?(0):((VAR_9[0] > 7)?(7):(VAR_9[0]));",
"VAR_9[1] = 0;",
"if (VAR_11)\nVAR_9[1] = (*src++);",
"VAR_9[1] = (VAR_9[1] < 0)?(0):((VAR_9[1] > 7)?(7):(VAR_9[1]));",
"c->status[0].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));",
"if (c->status[0].idelta & 0x08000)\nc->status[0].idelta -= 0x10000;",
"src+=2;",
"if (VAR_11)\nc->status[1].idelta = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));",
"if (VAR_11 && c->status[1].idelta & 0x08000)\nc->status[1].idelta |= 0xFFFF0000;",
"if (VAR_11)\nsrc+=2;",
"c->status[0].coeff1 = AdaptCoeff1[VAR_9[0]];",
"c->status[0].coeff2 = AdaptCoeff2[VAR_9[0]];",
"c->status[1].coeff1 = AdaptCoeff1[VAR_9[1]];",
"c->status[1].coeff2 = AdaptCoeff2[VAR_9[1]];",
"c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));",
"src+=2;",
"if (VAR_11) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));",
"if (VAR_11) src+=2;",
"c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));",
"src+=2;",
"if (VAR_11) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00));",
"if (VAR_11) src+=2;",
"*VAR_10++ = c->status[0].sample1;",
"if (VAR_11) *VAR_10++ = c->status[1].sample1;",
"*VAR_10++ = c->status[0].sample2;",
"if (VAR_11) *VAR_10++ = c->status[1].sample2;",
"for(;VAR_5>0;VAR_5--) {",
"*VAR_10++ = adpcm_ms_expand_nibble(&c->status[0], (src[0] >> 4) & 0x0F);",
"*VAR_10++ = adpcm_ms_expand_nibble(&c->status[VAR_11], src[0] & 0x0F);",
"src ++;",
"}",
"break;",
"case CODEC_ID_ADPCM_IMA_DK4:\nif (VAR_4 > BLKSIZE) {",
"if (VAR_0->block_align != 0)\nVAR_4 = VAR_0->block_align;",
"else\nVAR_4 = BLKSIZE;",
"}",
"c->status[0].predictor = (src[0] | (src[1] << 8));",
"c->status[0].step_index = src[2];",
"src += 4;",
"if(c->status[0].predictor & 0x8000)\nc->status[0].predictor -= 0x10000;",
"*VAR_10++ = c->status[0].predictor;",
"if (VAR_11) {",
"c->status[1].predictor = (src[0] | (src[1] << 8));",
"c->status[1].step_index = src[2];",
"src += 4;",
"if(c->status[1].predictor & 0x8000)\nc->status[1].predictor -= 0x10000;",
"*VAR_10++ = c->status[1].predictor;",
"}",
"while (src < VAR_3 + VAR_4) {",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],\n(src[0] >> 4) & 0x0F);",
"if (VAR_11)\n*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1],\nsrc[0] & 0x0F);",
"else\n*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],\nsrc[0] & 0x0F);",
"src++;",
"}",
"break;",
"case CODEC_ID_ADPCM_IMA_DK3:\nif (VAR_4 > BLKSIZE) {",
"if (VAR_0->block_align != 0)\nVAR_4 = VAR_0->block_align;",
"else\nVAR_4 = BLKSIZE;",
"}",
"c->status[0].predictor = (src[10] | (src[11] << 8));",
"c->status[1].predictor = (src[12] | (src[13] << 8));",
"c->status[0].step_index = src[14];",
"c->status[1].step_index = src[15];",
"if(c->status[0].predictor & 0x8000)\nc->status[0].predictor -= 0x10000;",
"if(c->status[1].predictor & 0x8000)\nc->status[1].predictor -= 0x10000;",
"src += 16;",
"VAR_15 = c->status[1].predictor;",
"while (1) {",
"DK3_GET_NEXT_NIBBLE();",
"adpcm_ima_expand_nibble(&c->status[0], VAR_13);",
"DK3_GET_NEXT_NIBBLE();",
"adpcm_ima_expand_nibble(&c->status[1], VAR_13);",
"VAR_15 = (VAR_15 + c->status[1].predictor) / 2;",
"*VAR_10++ = c->status[0].predictor + c->status[1].predictor;",
"*VAR_10++ = c->status[0].predictor - c->status[1].predictor;",
"DK3_GET_NEXT_NIBBLE();",
"adpcm_ima_expand_nibble(&c->status[0], VAR_13);",
"VAR_15 = (VAR_15 + c->status[1].predictor) / 2;",
"*VAR_10++ = c->status[0].predictor + c->status[1].predictor;",
"*VAR_10++ = c->status[0].predictor - c->status[1].predictor;",
"}",
"break;",
"case CODEC_ID_ADPCM_IMA_WS:\nwhile (src < VAR_3 + VAR_4) {",
"if (VAR_11) {",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],\n(src[0] >> 4) & 0x0F);",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[1],\nsrc[0] & 0x0F);",
"} else {",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],\n(src[0] >> 4) & 0x0F);",
"*VAR_10++ = adpcm_ima_expand_nibble(&c->status[0],\nsrc[0] & 0x0F);",
"}",
"src++;",
"}",
"break;",
"case CODEC_ID_ADPCM_XA:\nc->status[0].sample1 = c->status[0].sample2 =\nc->status[1].sample1 = c->status[1].sample2 = 0;",
"while (VAR_4 >= 128) {",
"xa_decode(VAR_10, src, &c->status[0], &c->status[1],\nVAR_0->channels);",
"src += 128;",
"VAR_10 += 28 * 8;",
"VAR_4 -= 128;",
"}",
"break;",
"default:\n*VAR_2 = 0;",
"return -1;",
"}",
"*VAR_2 = (uint8_t *)VAR_10 - (uint8_t *)VAR_1;",
"return src - VAR_3;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
43
],
[
47
],
[
49,
51
],
[
53
],
[
55
],
[
63
],
[
65
],
[
67
],
[
73,
75
],
[
79
],
[
83
],
[
87
],
[
89
],
[
93
],
[
97,
99
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141,
143,
145
],
[
151
],
[
153
],
[
155
],
[
157,
159
],
[
161
],
[
169
],
[
171
],
[
173
],
[
175
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187,
189
],
[
191
],
[
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
],
[
267
],
[
273
],
[
275
],
[
277,
279
],
[
281
],
[
283,
285
],
[
287
],
[
291
],
[
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
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
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
],
[
437,
439
],
[
447,
449,
451
],
[
453,
455,
457
],
[
461
],
[
463
],
[
465
],
[
467,
469
],
[
471,
473
],
[
475,
477
],
[
479
],
[
481
],
[
483
],
[
485
],
[
487
],
[
491,
493
],
[
495,
497
],
[
499
],
[
501
],
[
509
],
[
521
],
[
523
],
[
529
],
[
531
],
[
537
],
[
539
],
[
541
],
[
547
],
[
549
],
[
555
],
[
557
],
[
559
],
[
561
],
[
563
],
[
565,
569
],
[
573
],
[
575,
577
],
[
579,
581
],
[
583
],
[
585,
587
],
[
589,
591
],
[
593
],
[
597
],
[
599
],
[
601
],
[
603,
605,
607
],
[
609
],
[
611,
613
],
[
615
],
[
617
],
[
619
],
[
621
],
[
623
],
[
625,
627
],
[
629
],
[
631
],
[
633
],
[
635
],
[
637
]
] |
8,094 |
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
{
int32_t atom_size;
int found_codestream = 0, search_range = 10;
// Skip JPEG 2000 signature atom.
s->buf += 12;
while (!found_codestream && search_range) {
atom_size = AV_RB32(s->buf);
if (AV_RB32(s->buf + 4) == JP2_CODESTREAM) {
found_codestream = 1;
s->buf += 8;
} else {
s->buf += atom_size;
search_range--;
}
}
if (found_codestream)
return 1;
return 0;
}
| false |
FFmpeg
|
0b42631641d998e509cde6fa344edc6ab5cb4ac8
|
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
{
int32_t atom_size;
int found_codestream = 0, search_range = 10;
s->buf += 12;
while (!found_codestream && search_range) {
atom_size = AV_RB32(s->buf);
if (AV_RB32(s->buf + 4) == JP2_CODESTREAM) {
found_codestream = 1;
s->buf += 8;
} else {
s->buf += atom_size;
search_range--;
}
}
if (found_codestream)
return 1;
return 0;
}
|
{
"code": [],
"line_no": []
}
|
static int FUNC_0(Jpeg2000DecoderContext *VAR_0)
{
int32_t atom_size;
int VAR_1 = 0, VAR_2 = 10;
VAR_0->buf += 12;
while (!VAR_1 && VAR_2) {
atom_size = AV_RB32(VAR_0->buf);
if (AV_RB32(VAR_0->buf + 4) == JP2_CODESTREAM) {
VAR_1 = 1;
VAR_0->buf += 8;
} else {
VAR_0->buf += atom_size;
VAR_2--;
}
}
if (VAR_1)
return 1;
return 0;
}
|
[
"static int FUNC_0(Jpeg2000DecoderContext *VAR_0)\n{",
"int32_t atom_size;",
"int VAR_1 = 0, VAR_2 = 10;",
"VAR_0->buf += 12;",
"while (!VAR_1 && VAR_2) {",
"atom_size = AV_RB32(VAR_0->buf);",
"if (AV_RB32(VAR_0->buf + 4) == JP2_CODESTREAM) {",
"VAR_1 = 1;",
"VAR_0->buf += 8;",
"} else {",
"VAR_0->buf += atom_size;",
"VAR_2--;",
"}",
"}",
"if (VAR_1)\nreturn 1;",
"return 0;",
"}"
] |
[
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
[
1,
3
],
[
5
],
[
7
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39,
41
],
[
43
],
[
45
]
] |
8,096 |
parallel_ioport_write_sw(void *opaque, uint32_t addr, uint32_t val)
{
ParallelState *s = opaque;
pdebug("write addr=0x%02x val=0x%02x\n", addr, val);
addr &= 7;
switch(addr) {
case PARA_REG_DATA:
s->dataw = val;
parallel_update_irq(s);
break;
case PARA_REG_CTR:
val |= 0xc0;
if ((val & PARA_CTR_INIT) == 0 ) {
s->status = PARA_STS_BUSY;
s->status |= PARA_STS_ACK;
s->status |= PARA_STS_ONLINE;
s->status |= PARA_STS_ERROR;
}
else if (val & PARA_CTR_SELECT) {
if (val & PARA_CTR_STROBE) {
s->status &= ~PARA_STS_BUSY;
if ((s->control & PARA_CTR_STROBE) == 0)
qemu_chr_fe_write(s->chr, &s->dataw, 1);
} else {
if (s->control & PARA_CTR_INTEN) {
s->irq_pending = 1;
}
}
}
parallel_update_irq(s);
s->control = val;
break;
}
}
| true |
qemu
|
6ab3fc32ea640026726bc5f9f4db622d0954fb8a
|
parallel_ioport_write_sw(void *opaque, uint32_t addr, uint32_t val)
{
ParallelState *s = opaque;
pdebug("write addr=0x%02x val=0x%02x\n", addr, val);
addr &= 7;
switch(addr) {
case PARA_REG_DATA:
s->dataw = val;
parallel_update_irq(s);
break;
case PARA_REG_CTR:
val |= 0xc0;
if ((val & PARA_CTR_INIT) == 0 ) {
s->status = PARA_STS_BUSY;
s->status |= PARA_STS_ACK;
s->status |= PARA_STS_ONLINE;
s->status |= PARA_STS_ERROR;
}
else if (val & PARA_CTR_SELECT) {
if (val & PARA_CTR_STROBE) {
s->status &= ~PARA_STS_BUSY;
if ((s->control & PARA_CTR_STROBE) == 0)
qemu_chr_fe_write(s->chr, &s->dataw, 1);
} else {
if (s->control & PARA_CTR_INTEN) {
s->irq_pending = 1;
}
}
}
parallel_update_irq(s);
s->control = val;
break;
}
}
|
{
"code": [
" qemu_chr_fe_write(s->chr, &s->dataw, 1);"
],
"line_no": [
49
]
}
|
FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)
{
ParallelState *s = VAR_0;
pdebug("write VAR_1=0x%02x VAR_2=0x%02x\n", VAR_1, VAR_2);
VAR_1 &= 7;
switch(VAR_1) {
case PARA_REG_DATA:
s->dataw = VAR_2;
parallel_update_irq(s);
break;
case PARA_REG_CTR:
VAR_2 |= 0xc0;
if ((VAR_2 & PARA_CTR_INIT) == 0 ) {
s->status = PARA_STS_BUSY;
s->status |= PARA_STS_ACK;
s->status |= PARA_STS_ONLINE;
s->status |= PARA_STS_ERROR;
}
else if (VAR_2 & PARA_CTR_SELECT) {
if (VAR_2 & PARA_CTR_STROBE) {
s->status &= ~PARA_STS_BUSY;
if ((s->control & PARA_CTR_STROBE) == 0)
qemu_chr_fe_write(s->chr, &s->dataw, 1);
} else {
if (s->control & PARA_CTR_INTEN) {
s->irq_pending = 1;
}
}
}
parallel_update_irq(s);
s->control = VAR_2;
break;
}
}
|
[
"FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{",
"ParallelState *s = VAR_0;",
"pdebug(\"write VAR_1=0x%02x VAR_2=0x%02x\\n\", VAR_1, VAR_2);",
"VAR_1 &= 7;",
"switch(VAR_1) {",
"case PARA_REG_DATA:\ns->dataw = VAR_2;",
"parallel_update_irq(s);",
"break;",
"case PARA_REG_CTR:\nVAR_2 |= 0xc0;",
"if ((VAR_2 & PARA_CTR_INIT) == 0 ) {",
"s->status = PARA_STS_BUSY;",
"s->status |= PARA_STS_ACK;",
"s->status |= PARA_STS_ONLINE;",
"s->status |= PARA_STS_ERROR;",
"}",
"else if (VAR_2 & PARA_CTR_SELECT) {",
"if (VAR_2 & PARA_CTR_STROBE) {",
"s->status &= ~PARA_STS_BUSY;",
"if ((s->control & PARA_CTR_STROBE) == 0)\nqemu_chr_fe_write(s->chr, &s->dataw, 1);",
"} else {",
"if (s->control & PARA_CTR_INTEN) {",
"s->irq_pending = 1;",
"}",
"}",
"}",
"parallel_update_irq(s);",
"s->control = VAR_2;",
"break;",
"}",
"}"
] |
[
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
] |
[
[
1,
3
],
[
5
],
[
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
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.