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 |
|---|---|---|---|---|---|---|---|---|---|---|
14,070 | static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp)
{
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
CcwDevice *ccw_dev = CCW_DEVICE(dev);
CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
DeviceState *parent = DEVICE(ccw_dev);
BusState *qbus = qdev_get_parent_bus(parent);
VirtualCssBus *cbus = VIRTUAL_CSS_BUS(qbus);
SubchDev *sch;
Error *err = NULL;
sch = css_create_sch(ccw_dev->devno, true, cbus->squash_mcss, errp);
if (!sch) {
return;
}
if (!virtio_ccw_rev_max(dev) && dev->force_revision_1) {
error_setg(&err, "Invalid value of property max_rev "
"(is %d expected >= 1)", virtio_ccw_rev_max(dev));
goto out_err;
}
sch->driver_data = dev;
sch->ccw_cb = virtio_ccw_cb;
sch->disable_cb = virtio_sch_disable_cb;
sch->id.reserved = 0xff;
sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
sch->do_subchannel_work = do_subchannel_work_virtual;
ccw_dev->sch = sch;
dev->indicators = NULL;
dev->revision = -1;
css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
trace_virtio_ccw_new_device(
sch->cssid, sch->ssid, sch->schid, sch->devno,
ccw_dev->devno.valid ? "user-configured" : "auto-configured");
if (!kvm_eventfds_enabled()) {
dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;
}
if (k->realize) {
k->realize(dev, &err);
if (err) {
goto out_err;
}
}
ck->realize(ccw_dev, &err);
if (err) {
goto out_err;
}
return;
out_err:
error_propagate(errp, err);
css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
ccw_dev->sch = NULL;
g_free(sch);
}
| true | qemu | cda3c19ff56d1b567631ce17f7a3bdb47cfa9455 | static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp)
{
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
CcwDevice *ccw_dev = CCW_DEVICE(dev);
CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
DeviceState *parent = DEVICE(ccw_dev);
BusState *qbus = qdev_get_parent_bus(parent);
VirtualCssBus *cbus = VIRTUAL_CSS_BUS(qbus);
SubchDev *sch;
Error *err = NULL;
sch = css_create_sch(ccw_dev->devno, true, cbus->squash_mcss, errp);
if (!sch) {
return;
}
if (!virtio_ccw_rev_max(dev) && dev->force_revision_1) {
error_setg(&err, "Invalid value of property max_rev "
"(is %d expected >= 1)", virtio_ccw_rev_max(dev));
goto out_err;
}
sch->driver_data = dev;
sch->ccw_cb = virtio_ccw_cb;
sch->disable_cb = virtio_sch_disable_cb;
sch->id.reserved = 0xff;
sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
sch->do_subchannel_work = do_subchannel_work_virtual;
ccw_dev->sch = sch;
dev->indicators = NULL;
dev->revision = -1;
css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
trace_virtio_ccw_new_device(
sch->cssid, sch->ssid, sch->schid, sch->devno,
ccw_dev->devno.valid ? "user-configured" : "auto-configured");
if (!kvm_eventfds_enabled()) {
dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;
}
if (k->realize) {
k->realize(dev, &err);
if (err) {
goto out_err;
}
}
ck->realize(ccw_dev, &err);
if (err) {
goto out_err;
}
return;
out_err:
error_propagate(errp, err);
css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
ccw_dev->sch = NULL;
g_free(sch);
}
| {
"code": [
" if (!kvm_eventfds_enabled()) {"
],
"line_no": [
73
]
} | static void FUNC_0(VirtioCcwDevice *VAR_0, Error **VAR_1)
{
VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(VAR_0);
CcwDevice *ccw_dev = CCW_DEVICE(VAR_0);
CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
DeviceState *parent = DEVICE(ccw_dev);
BusState *qbus = qdev_get_parent_bus(parent);
VirtualCssBus *cbus = VIRTUAL_CSS_BUS(qbus);
SubchDev *sch;
Error *err = NULL;
sch = css_create_sch(ccw_dev->devno, true, cbus->squash_mcss, VAR_1);
if (!sch) {
return;
}
if (!virtio_ccw_rev_max(VAR_0) && VAR_0->force_revision_1) {
error_setg(&err, "Invalid value of property max_rev "
"(is %d expected >= 1)", virtio_ccw_rev_max(VAR_0));
goto out_err;
}
sch->driver_data = VAR_0;
sch->ccw_cb = virtio_ccw_cb;
sch->disable_cb = virtio_sch_disable_cb;
sch->id.reserved = 0xff;
sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
sch->do_subchannel_work = do_subchannel_work_virtual;
ccw_dev->sch = sch;
VAR_0->indicators = NULL;
VAR_0->revision = -1;
css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
trace_virtio_ccw_new_device(
sch->cssid, sch->ssid, sch->schid, sch->devno,
ccw_dev->devno.valid ? "user-configured" : "auto-configured");
if (!kvm_eventfds_enabled()) {
VAR_0->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;
}
if (k->realize) {
k->realize(VAR_0, &err);
if (err) {
goto out_err;
}
}
ck->realize(ccw_dev, &err);
if (err) {
goto out_err;
}
return;
out_err:
error_propagate(VAR_1, err);
css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
ccw_dev->sch = NULL;
g_free(sch);
}
| [
"static void FUNC_0(VirtioCcwDevice *VAR_0, Error **VAR_1)\n{",
"VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(VAR_0);",
"CcwDevice *ccw_dev = CCW_DEVICE(VAR_0);",
"CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);",
"DeviceState *parent = DEVICE(ccw_dev);",
"BusState *qbus = qdev_get_parent_bus... | [
0,
0,
0,
0,
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[... |
14,071 | static void virtio_balloon_to_target(void *opaque, ram_addr_t target,
MonitorCompletion cb, void *cb_data)
{
VirtIOBalloon *dev = opaque;
if (target > ram_size) {
target = ram_size;
}
if (target) {
dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
virtio_notify_config(&dev->vdev);
} else {
virtio_balloon_stat(opaque, cb, cb_data);
}
}
| true | qemu | 30fb2ca603e8b8d0f02630ef18bc0d0637a88ffa | static void virtio_balloon_to_target(void *opaque, ram_addr_t target,
MonitorCompletion cb, void *cb_data)
{
VirtIOBalloon *dev = opaque;
if (target > ram_size) {
target = ram_size;
}
if (target) {
dev->num_pages = (ram_size - target) >> VIRTIO_BALLOON_PFN_SHIFT;
virtio_notify_config(&dev->vdev);
} else {
virtio_balloon_stat(opaque, cb, cb_data);
}
}
| {
"code": [
"static void virtio_balloon_to_target(void *opaque, ram_addr_t target,",
" MonitorCompletion cb, void *cb_data)",
" } else {",
" virtio_balloon_stat(opaque, cb, cb_data);"
],
"line_no": [
1,
3,
23,
25
]
} | static void FUNC_0(void *VAR_0, ram_addr_t VAR_1,
MonitorCompletion VAR_2, void *VAR_3)
{
VirtIOBalloon *dev = VAR_0;
if (VAR_1 > ram_size) {
VAR_1 = ram_size;
}
if (VAR_1) {
dev->num_pages = (ram_size - VAR_1) >> VIRTIO_BALLOON_PFN_SHIFT;
virtio_notify_config(&dev->vdev);
} else {
virtio_balloon_stat(VAR_0, VAR_2, VAR_3);
}
}
| [
"static void FUNC_0(void *VAR_0, ram_addr_t VAR_1,\nMonitorCompletion VAR_2, void *VAR_3)\n{",
"VirtIOBalloon *dev = VAR_0;",
"if (VAR_1 > ram_size) {",
"VAR_1 = ram_size;",
"}",
"if (VAR_1) {",
"dev->num_pages = (ram_size - VAR_1) >> VIRTIO_BALLOON_PFN_SHIFT;",
"virtio_notify_config(&dev->vdev);",
... | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
]
] |
14,072 | void helper_rsm(CPUX86State *env)
{
X86CPU *cpu = x86_env_get_cpu(env);
CPUState *cs = CPU(cpu);
target_ulong sm_state;
int i, offset;
uint32_t val;
sm_state = env->smbase + 0x8000;
#ifdef TARGET_X86_64
cpu_load_efer(env, x86_ldq_phys(cs, sm_state + 0x7ed0));
env->gdt.base = x86_ldq_phys(cs, sm_state + 0x7e68);
env->gdt.limit = x86_ldl_phys(cs, sm_state + 0x7e64);
env->ldt.selector = x86_lduw_phys(cs, sm_state + 0x7e70);
env->ldt.base = x86_ldq_phys(cs, sm_state + 0x7e78);
env->ldt.limit = x86_ldl_phys(cs, sm_state + 0x7e74);
env->ldt.flags = (x86_lduw_phys(cs, sm_state + 0x7e72) & 0xf0ff) << 8;
env->idt.base = x86_ldq_phys(cs, sm_state + 0x7e88);
env->idt.limit = x86_ldl_phys(cs, sm_state + 0x7e84);
env->tr.selector = x86_lduw_phys(cs, sm_state + 0x7e90);
env->tr.base = x86_ldq_phys(cs, sm_state + 0x7e98);
env->tr.limit = x86_ldl_phys(cs, sm_state + 0x7e94);
env->tr.flags = (x86_lduw_phys(cs, sm_state + 0x7e92) & 0xf0ff) << 8;
env->regs[R_EAX] = x86_ldq_phys(cs, sm_state + 0x7ff8);
env->regs[R_ECX] = x86_ldq_phys(cs, sm_state + 0x7ff0);
env->regs[R_EDX] = x86_ldq_phys(cs, sm_state + 0x7fe8);
env->regs[R_EBX] = x86_ldq_phys(cs, sm_state + 0x7fe0);
env->regs[R_ESP] = x86_ldq_phys(cs, sm_state + 0x7fd8);
env->regs[R_EBP] = x86_ldq_phys(cs, sm_state + 0x7fd0);
env->regs[R_ESI] = x86_ldq_phys(cs, sm_state + 0x7fc8);
env->regs[R_EDI] = x86_ldq_phys(cs, sm_state + 0x7fc0);
for (i = 8; i < 16; i++) {
env->regs[i] = x86_ldq_phys(cs, sm_state + 0x7ff8 - i * 8);
}
env->eip = x86_ldq_phys(cs, sm_state + 0x7f78);
cpu_load_eflags(env, x86_ldl_phys(cs, sm_state + 0x7f70),
~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
env->dr[6] = x86_ldl_phys(cs, sm_state + 0x7f68);
env->dr[7] = x86_ldl_phys(cs, sm_state + 0x7f60);
cpu_x86_update_cr4(env, x86_ldl_phys(cs, sm_state + 0x7f48));
cpu_x86_update_cr3(env, x86_ldq_phys(cs, sm_state + 0x7f50));
cpu_x86_update_cr0(env, x86_ldl_phys(cs, sm_state + 0x7f58));
for (i = 0; i < 6; i++) {
offset = 0x7e00 + i * 16;
cpu_x86_load_seg_cache(env, i,
x86_lduw_phys(cs, sm_state + offset),
x86_ldq_phys(cs, sm_state + offset + 8),
x86_ldl_phys(cs, sm_state + offset + 4),
(x86_lduw_phys(cs, sm_state + offset + 2) &
0xf0ff) << 8);
}
val = x86_ldl_phys(cs, sm_state + 0x7efc); /* revision ID */
if (val & 0x20000) {
env->smbase = x86_ldl_phys(cs, sm_state + 0x7f00);
}
#else
cpu_x86_update_cr0(env, x86_ldl_phys(cs, sm_state + 0x7ffc));
cpu_x86_update_cr3(env, x86_ldl_phys(cs, sm_state + 0x7ff8));
cpu_load_eflags(env, x86_ldl_phys(cs, sm_state + 0x7ff4),
~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
env->eip = x86_ldl_phys(cs, sm_state + 0x7ff0);
env->regs[R_EDI] = x86_ldl_phys(cs, sm_state + 0x7fec);
env->regs[R_ESI] = x86_ldl_phys(cs, sm_state + 0x7fe8);
env->regs[R_EBP] = x86_ldl_phys(cs, sm_state + 0x7fe4);
env->regs[R_ESP] = x86_ldl_phys(cs, sm_state + 0x7fe0);
env->regs[R_EBX] = x86_ldl_phys(cs, sm_state + 0x7fdc);
env->regs[R_EDX] = x86_ldl_phys(cs, sm_state + 0x7fd8);
env->regs[R_ECX] = x86_ldl_phys(cs, sm_state + 0x7fd4);
env->regs[R_EAX] = x86_ldl_phys(cs, sm_state + 0x7fd0);
env->dr[6] = x86_ldl_phys(cs, sm_state + 0x7fcc);
env->dr[7] = x86_ldl_phys(cs, sm_state + 0x7fc8);
env->tr.selector = x86_ldl_phys(cs, sm_state + 0x7fc4) & 0xffff;
env->tr.base = x86_ldl_phys(cs, sm_state + 0x7f64);
env->tr.limit = x86_ldl_phys(cs, sm_state + 0x7f60);
env->tr.flags = (x86_ldl_phys(cs, sm_state + 0x7f5c) & 0xf0ff) << 8;
env->ldt.selector = x86_ldl_phys(cs, sm_state + 0x7fc0) & 0xffff;
env->ldt.base = x86_ldl_phys(cs, sm_state + 0x7f80);
env->ldt.limit = x86_ldl_phys(cs, sm_state + 0x7f7c);
env->ldt.flags = (x86_ldl_phys(cs, sm_state + 0x7f78) & 0xf0ff) << 8;
env->gdt.base = x86_ldl_phys(cs, sm_state + 0x7f74);
env->gdt.limit = x86_ldl_phys(cs, sm_state + 0x7f70);
env->idt.base = x86_ldl_phys(cs, sm_state + 0x7f58);
env->idt.limit = x86_ldl_phys(cs, sm_state + 0x7f54);
for (i = 0; i < 6; i++) {
if (i < 3) {
offset = 0x7f84 + i * 12;
} else {
offset = 0x7f2c + (i - 3) * 12;
}
cpu_x86_load_seg_cache(env, i,
x86_ldl_phys(cs,
sm_state + 0x7fa8 + i * 4) & 0xffff,
x86_ldl_phys(cs, sm_state + offset + 8),
x86_ldl_phys(cs, sm_state + offset + 4),
(x86_ldl_phys(cs,
sm_state + offset) & 0xf0ff) << 8);
}
cpu_x86_update_cr4(env, x86_ldl_phys(cs, sm_state + 0x7f14));
val = x86_ldl_phys(cs, sm_state + 0x7efc); /* revision ID */
if (val & 0x20000) {
env->smbase = x86_ldl_phys(cs, sm_state + 0x7ef8);
}
#endif
if ((env->hflags2 & HF2_SMM_INSIDE_NMI_MASK) == 0) {
env->hflags2 &= ~HF2_NMI_MASK;
}
env->hflags2 &= ~HF2_SMM_INSIDE_NMI_MASK;
env->hflags &= ~HF_SMM_MASK;
cpu_smm_update(cpu);
qemu_log_mask(CPU_LOG_INT, "SMM: after RSM\n");
log_cpu_state_mask(CPU_LOG_INT, CPU(cpu), CPU_DUMP_CCOP);
} | true | qemu | 8d04fb55dec381bc5105cb47f29d918e579e8cbd | void helper_rsm(CPUX86State *env)
{
X86CPU *cpu = x86_env_get_cpu(env);
CPUState *cs = CPU(cpu);
target_ulong sm_state;
int i, offset;
uint32_t val;
sm_state = env->smbase + 0x8000;
#ifdef TARGET_X86_64
cpu_load_efer(env, x86_ldq_phys(cs, sm_state + 0x7ed0));
env->gdt.base = x86_ldq_phys(cs, sm_state + 0x7e68);
env->gdt.limit = x86_ldl_phys(cs, sm_state + 0x7e64);
env->ldt.selector = x86_lduw_phys(cs, sm_state + 0x7e70);
env->ldt.base = x86_ldq_phys(cs, sm_state + 0x7e78);
env->ldt.limit = x86_ldl_phys(cs, sm_state + 0x7e74);
env->ldt.flags = (x86_lduw_phys(cs, sm_state + 0x7e72) & 0xf0ff) << 8;
env->idt.base = x86_ldq_phys(cs, sm_state + 0x7e88);
env->idt.limit = x86_ldl_phys(cs, sm_state + 0x7e84);
env->tr.selector = x86_lduw_phys(cs, sm_state + 0x7e90);
env->tr.base = x86_ldq_phys(cs, sm_state + 0x7e98);
env->tr.limit = x86_ldl_phys(cs, sm_state + 0x7e94);
env->tr.flags = (x86_lduw_phys(cs, sm_state + 0x7e92) & 0xf0ff) << 8;
env->regs[R_EAX] = x86_ldq_phys(cs, sm_state + 0x7ff8);
env->regs[R_ECX] = x86_ldq_phys(cs, sm_state + 0x7ff0);
env->regs[R_EDX] = x86_ldq_phys(cs, sm_state + 0x7fe8);
env->regs[R_EBX] = x86_ldq_phys(cs, sm_state + 0x7fe0);
env->regs[R_ESP] = x86_ldq_phys(cs, sm_state + 0x7fd8);
env->regs[R_EBP] = x86_ldq_phys(cs, sm_state + 0x7fd0);
env->regs[R_ESI] = x86_ldq_phys(cs, sm_state + 0x7fc8);
env->regs[R_EDI] = x86_ldq_phys(cs, sm_state + 0x7fc0);
for (i = 8; i < 16; i++) {
env->regs[i] = x86_ldq_phys(cs, sm_state + 0x7ff8 - i * 8);
}
env->eip = x86_ldq_phys(cs, sm_state + 0x7f78);
cpu_load_eflags(env, x86_ldl_phys(cs, sm_state + 0x7f70),
~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
env->dr[6] = x86_ldl_phys(cs, sm_state + 0x7f68);
env->dr[7] = x86_ldl_phys(cs, sm_state + 0x7f60);
cpu_x86_update_cr4(env, x86_ldl_phys(cs, sm_state + 0x7f48));
cpu_x86_update_cr3(env, x86_ldq_phys(cs, sm_state + 0x7f50));
cpu_x86_update_cr0(env, x86_ldl_phys(cs, sm_state + 0x7f58));
for (i = 0; i < 6; i++) {
offset = 0x7e00 + i * 16;
cpu_x86_load_seg_cache(env, i,
x86_lduw_phys(cs, sm_state + offset),
x86_ldq_phys(cs, sm_state + offset + 8),
x86_ldl_phys(cs, sm_state + offset + 4),
(x86_lduw_phys(cs, sm_state + offset + 2) &
0xf0ff) << 8);
}
val = x86_ldl_phys(cs, sm_state + 0x7efc);
if (val & 0x20000) {
env->smbase = x86_ldl_phys(cs, sm_state + 0x7f00);
}
#else
cpu_x86_update_cr0(env, x86_ldl_phys(cs, sm_state + 0x7ffc));
cpu_x86_update_cr3(env, x86_ldl_phys(cs, sm_state + 0x7ff8));
cpu_load_eflags(env, x86_ldl_phys(cs, sm_state + 0x7ff4),
~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
env->eip = x86_ldl_phys(cs, sm_state + 0x7ff0);
env->regs[R_EDI] = x86_ldl_phys(cs, sm_state + 0x7fec);
env->regs[R_ESI] = x86_ldl_phys(cs, sm_state + 0x7fe8);
env->regs[R_EBP] = x86_ldl_phys(cs, sm_state + 0x7fe4);
env->regs[R_ESP] = x86_ldl_phys(cs, sm_state + 0x7fe0);
env->regs[R_EBX] = x86_ldl_phys(cs, sm_state + 0x7fdc);
env->regs[R_EDX] = x86_ldl_phys(cs, sm_state + 0x7fd8);
env->regs[R_ECX] = x86_ldl_phys(cs, sm_state + 0x7fd4);
env->regs[R_EAX] = x86_ldl_phys(cs, sm_state + 0x7fd0);
env->dr[6] = x86_ldl_phys(cs, sm_state + 0x7fcc);
env->dr[7] = x86_ldl_phys(cs, sm_state + 0x7fc8);
env->tr.selector = x86_ldl_phys(cs, sm_state + 0x7fc4) & 0xffff;
env->tr.base = x86_ldl_phys(cs, sm_state + 0x7f64);
env->tr.limit = x86_ldl_phys(cs, sm_state + 0x7f60);
env->tr.flags = (x86_ldl_phys(cs, sm_state + 0x7f5c) & 0xf0ff) << 8;
env->ldt.selector = x86_ldl_phys(cs, sm_state + 0x7fc0) & 0xffff;
env->ldt.base = x86_ldl_phys(cs, sm_state + 0x7f80);
env->ldt.limit = x86_ldl_phys(cs, sm_state + 0x7f7c);
env->ldt.flags = (x86_ldl_phys(cs, sm_state + 0x7f78) & 0xf0ff) << 8;
env->gdt.base = x86_ldl_phys(cs, sm_state + 0x7f74);
env->gdt.limit = x86_ldl_phys(cs, sm_state + 0x7f70);
env->idt.base = x86_ldl_phys(cs, sm_state + 0x7f58);
env->idt.limit = x86_ldl_phys(cs, sm_state + 0x7f54);
for (i = 0; i < 6; i++) {
if (i < 3) {
offset = 0x7f84 + i * 12;
} else {
offset = 0x7f2c + (i - 3) * 12;
}
cpu_x86_load_seg_cache(env, i,
x86_ldl_phys(cs,
sm_state + 0x7fa8 + i * 4) & 0xffff,
x86_ldl_phys(cs, sm_state + offset + 8),
x86_ldl_phys(cs, sm_state + offset + 4),
(x86_ldl_phys(cs,
sm_state + offset) & 0xf0ff) << 8);
}
cpu_x86_update_cr4(env, x86_ldl_phys(cs, sm_state + 0x7f14));
val = x86_ldl_phys(cs, sm_state + 0x7efc);
if (val & 0x20000) {
env->smbase = x86_ldl_phys(cs, sm_state + 0x7ef8);
}
#endif
if ((env->hflags2 & HF2_SMM_INSIDE_NMI_MASK) == 0) {
env->hflags2 &= ~HF2_NMI_MASK;
}
env->hflags2 &= ~HF2_SMM_INSIDE_NMI_MASK;
env->hflags &= ~HF_SMM_MASK;
cpu_smm_update(cpu);
qemu_log_mask(CPU_LOG_INT, "SMM: after RSM\n");
log_cpu_state_mask(CPU_LOG_INT, CPU(cpu), CPU_DUMP_CCOP);
} | {
"code": [],
"line_no": []
} | void FUNC_0(CPUX86State *VAR_0)
{
X86CPU *cpu = x86_env_get_cpu(VAR_0);
CPUState *cs = CPU(cpu);
target_ulong sm_state;
int VAR_1, VAR_2;
uint32_t val;
sm_state = VAR_0->smbase + 0x8000;
#ifdef TARGET_X86_64
cpu_load_efer(VAR_0, x86_ldq_phys(cs, sm_state + 0x7ed0));
VAR_0->gdt.base = x86_ldq_phys(cs, sm_state + 0x7e68);
VAR_0->gdt.limit = x86_ldl_phys(cs, sm_state + 0x7e64);
VAR_0->ldt.selector = x86_lduw_phys(cs, sm_state + 0x7e70);
VAR_0->ldt.base = x86_ldq_phys(cs, sm_state + 0x7e78);
VAR_0->ldt.limit = x86_ldl_phys(cs, sm_state + 0x7e74);
VAR_0->ldt.flags = (x86_lduw_phys(cs, sm_state + 0x7e72) & 0xf0ff) << 8;
VAR_0->idt.base = x86_ldq_phys(cs, sm_state + 0x7e88);
VAR_0->idt.limit = x86_ldl_phys(cs, sm_state + 0x7e84);
VAR_0->tr.selector = x86_lduw_phys(cs, sm_state + 0x7e90);
VAR_0->tr.base = x86_ldq_phys(cs, sm_state + 0x7e98);
VAR_0->tr.limit = x86_ldl_phys(cs, sm_state + 0x7e94);
VAR_0->tr.flags = (x86_lduw_phys(cs, sm_state + 0x7e92) & 0xf0ff) << 8;
VAR_0->regs[R_EAX] = x86_ldq_phys(cs, sm_state + 0x7ff8);
VAR_0->regs[R_ECX] = x86_ldq_phys(cs, sm_state + 0x7ff0);
VAR_0->regs[R_EDX] = x86_ldq_phys(cs, sm_state + 0x7fe8);
VAR_0->regs[R_EBX] = x86_ldq_phys(cs, sm_state + 0x7fe0);
VAR_0->regs[R_ESP] = x86_ldq_phys(cs, sm_state + 0x7fd8);
VAR_0->regs[R_EBP] = x86_ldq_phys(cs, sm_state + 0x7fd0);
VAR_0->regs[R_ESI] = x86_ldq_phys(cs, sm_state + 0x7fc8);
VAR_0->regs[R_EDI] = x86_ldq_phys(cs, sm_state + 0x7fc0);
for (VAR_1 = 8; VAR_1 < 16; VAR_1++) {
VAR_0->regs[VAR_1] = x86_ldq_phys(cs, sm_state + 0x7ff8 - VAR_1 * 8);
}
VAR_0->eip = x86_ldq_phys(cs, sm_state + 0x7f78);
cpu_load_eflags(VAR_0, x86_ldl_phys(cs, sm_state + 0x7f70),
~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
VAR_0->dr[6] = x86_ldl_phys(cs, sm_state + 0x7f68);
VAR_0->dr[7] = x86_ldl_phys(cs, sm_state + 0x7f60);
cpu_x86_update_cr4(VAR_0, x86_ldl_phys(cs, sm_state + 0x7f48));
cpu_x86_update_cr3(VAR_0, x86_ldq_phys(cs, sm_state + 0x7f50));
cpu_x86_update_cr0(VAR_0, x86_ldl_phys(cs, sm_state + 0x7f58));
for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {
VAR_2 = 0x7e00 + VAR_1 * 16;
cpu_x86_load_seg_cache(VAR_0, VAR_1,
x86_lduw_phys(cs, sm_state + VAR_2),
x86_ldq_phys(cs, sm_state + VAR_2 + 8),
x86_ldl_phys(cs, sm_state + VAR_2 + 4),
(x86_lduw_phys(cs, sm_state + VAR_2 + 2) &
0xf0ff) << 8);
}
val = x86_ldl_phys(cs, sm_state + 0x7efc);
if (val & 0x20000) {
VAR_0->smbase = x86_ldl_phys(cs, sm_state + 0x7f00);
}
#else
cpu_x86_update_cr0(VAR_0, x86_ldl_phys(cs, sm_state + 0x7ffc));
cpu_x86_update_cr3(VAR_0, x86_ldl_phys(cs, sm_state + 0x7ff8));
cpu_load_eflags(VAR_0, x86_ldl_phys(cs, sm_state + 0x7ff4),
~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
VAR_0->eip = x86_ldl_phys(cs, sm_state + 0x7ff0);
VAR_0->regs[R_EDI] = x86_ldl_phys(cs, sm_state + 0x7fec);
VAR_0->regs[R_ESI] = x86_ldl_phys(cs, sm_state + 0x7fe8);
VAR_0->regs[R_EBP] = x86_ldl_phys(cs, sm_state + 0x7fe4);
VAR_0->regs[R_ESP] = x86_ldl_phys(cs, sm_state + 0x7fe0);
VAR_0->regs[R_EBX] = x86_ldl_phys(cs, sm_state + 0x7fdc);
VAR_0->regs[R_EDX] = x86_ldl_phys(cs, sm_state + 0x7fd8);
VAR_0->regs[R_ECX] = x86_ldl_phys(cs, sm_state + 0x7fd4);
VAR_0->regs[R_EAX] = x86_ldl_phys(cs, sm_state + 0x7fd0);
VAR_0->dr[6] = x86_ldl_phys(cs, sm_state + 0x7fcc);
VAR_0->dr[7] = x86_ldl_phys(cs, sm_state + 0x7fc8);
VAR_0->tr.selector = x86_ldl_phys(cs, sm_state + 0x7fc4) & 0xffff;
VAR_0->tr.base = x86_ldl_phys(cs, sm_state + 0x7f64);
VAR_0->tr.limit = x86_ldl_phys(cs, sm_state + 0x7f60);
VAR_0->tr.flags = (x86_ldl_phys(cs, sm_state + 0x7f5c) & 0xf0ff) << 8;
VAR_0->ldt.selector = x86_ldl_phys(cs, sm_state + 0x7fc0) & 0xffff;
VAR_0->ldt.base = x86_ldl_phys(cs, sm_state + 0x7f80);
VAR_0->ldt.limit = x86_ldl_phys(cs, sm_state + 0x7f7c);
VAR_0->ldt.flags = (x86_ldl_phys(cs, sm_state + 0x7f78) & 0xf0ff) << 8;
VAR_0->gdt.base = x86_ldl_phys(cs, sm_state + 0x7f74);
VAR_0->gdt.limit = x86_ldl_phys(cs, sm_state + 0x7f70);
VAR_0->idt.base = x86_ldl_phys(cs, sm_state + 0x7f58);
VAR_0->idt.limit = x86_ldl_phys(cs, sm_state + 0x7f54);
for (VAR_1 = 0; VAR_1 < 6; VAR_1++) {
if (VAR_1 < 3) {
VAR_2 = 0x7f84 + VAR_1 * 12;
} else {
VAR_2 = 0x7f2c + (VAR_1 - 3) * 12;
}
cpu_x86_load_seg_cache(VAR_0, VAR_1,
x86_ldl_phys(cs,
sm_state + 0x7fa8 + VAR_1 * 4) & 0xffff,
x86_ldl_phys(cs, sm_state + VAR_2 + 8),
x86_ldl_phys(cs, sm_state + VAR_2 + 4),
(x86_ldl_phys(cs,
sm_state + VAR_2) & 0xf0ff) << 8);
}
cpu_x86_update_cr4(VAR_0, x86_ldl_phys(cs, sm_state + 0x7f14));
val = x86_ldl_phys(cs, sm_state + 0x7efc);
if (val & 0x20000) {
VAR_0->smbase = x86_ldl_phys(cs, sm_state + 0x7ef8);
}
#endif
if ((VAR_0->hflags2 & HF2_SMM_INSIDE_NMI_MASK) == 0) {
VAR_0->hflags2 &= ~HF2_NMI_MASK;
}
VAR_0->hflags2 &= ~HF2_SMM_INSIDE_NMI_MASK;
VAR_0->hflags &= ~HF_SMM_MASK;
cpu_smm_update(cpu);
qemu_log_mask(CPU_LOG_INT, "SMM: after RSM\n");
log_cpu_state_mask(CPU_LOG_INT, CPU(cpu), CPU_DUMP_CCOP);
} | [
"void FUNC_0(CPUX86State *VAR_0)\n{",
"X86CPU *cpu = x86_env_get_cpu(VAR_0);",
"CPUState *cs = CPU(cpu);",
"target_ulong sm_state;",
"int VAR_1, VAR_2;",
"uint32_t val;",
"sm_state = VAR_0->smbase + 0x8000;",
"#ifdef TARGET_X86_64\ncpu_load_efer(VAR_0, x86_ldq_phys(cs, sm_state + 0x7ed0));",
"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... | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9,
10
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
... |
14,073 | bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
{
int i;
for (i = 0; i < qiov->niov; i++) {
if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
return false;
}
if (qiov->iov[i].iov_len % bs->buffer_alignment) {
return false;
}
}
return true;
}
| true | qemu | 339064d5063924e5176842abbf6c8089f3479c5b | bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
{
int i;
for (i = 0; i < qiov->niov; i++) {
if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
return false;
}
if (qiov->iov[i].iov_len % bs->buffer_alignment) {
return false;
}
}
return true;
}
| {
"code": [
" if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {",
" if (qiov->iov[i].iov_len % bs->buffer_alignment) {"
],
"line_no": [
11,
17
]
} | bool FUNC_0(BlockDriverState *bs, QEMUIOVector *qiov)
{
int VAR_0;
for (VAR_0 = 0; VAR_0 < qiov->niov; VAR_0++) {
if ((uintptr_t) qiov->iov[VAR_0].iov_base % bs->buffer_alignment) {
return false;
}
if (qiov->iov[VAR_0].iov_len % bs->buffer_alignment) {
return false;
}
}
return true;
}
| [
"bool FUNC_0(BlockDriverState *bs, QEMUIOVector *qiov)\n{",
"int VAR_0;",
"for (VAR_0 = 0; VAR_0 < qiov->niov; VAR_0++) {",
"if ((uintptr_t) qiov->iov[VAR_0].iov_base % bs->buffer_alignment) {",
"return false;",
"}",
"if (qiov->iov[VAR_0].iov_len % bs->buffer_alignment) {",
"return false;",
"}",
"... | [
0,
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
]
] |
14,074 | static int read_key(void)
{
#if HAVE_TERMIOS_H
int n = 1;
unsigned char ch;
struct timeval tv;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 0;
n = select(1, &rfds, NULL, NULL, &tv);
if (n > 0) {
n = read(0, &ch, 1);
if (n == 1)
return ch;
return n;
}
#elif HAVE_CONIO_H
if(kbhit())
return(getch());
#endif
return -1;
}
| true | FFmpeg | cb48e245e6e770f146220fac0a8bd4dc1a5e006c | static int read_key(void)
{
#if HAVE_TERMIOS_H
int n = 1;
unsigned char ch;
struct timeval tv;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 0;
n = select(1, &rfds, NULL, NULL, &tv);
if (n > 0) {
n = read(0, &ch, 1);
if (n == 1)
return ch;
return n;
}
#elif HAVE_CONIO_H
if(kbhit())
return(getch());
#endif
return -1;
}
| {
"code": [
"#if HAVE_TERMIOS_H",
"#elif HAVE_CONIO_H",
"#if HAVE_TERMIOS_H",
"#endif",
"#if HAVE_TERMIOS_H",
"#endif",
"#if HAVE_TERMIOS_H",
"#endif",
"#if HAVE_TERMIOS_H",
" int n = 1;",
" unsigned char ch;",
" struct timeval tv;",
" fd_set rfds;",
" FD_ZERO(&rfds);",
" FD_SET(0, &rfds);",
" tv.tv_sec = 0;",
" tv.tv_usec = 0;",
" n = select(1, &rfds, NULL, NULL, &tv);",
" if (n > 0) {",
" n = read(0, &ch, 1);",
" if (n == 1)",
" return ch;",
" return n;",
"#elif HAVE_CONIO_H"
],
"line_no": [
5,
41,
5,
47,
5,
47,
5,
47,
5,
7,
9,
11,
13,
17,
19,
21,
23,
25,
27,
29,
31,
33,
37,
41
]
} | static int FUNC_0(void)
{
#if HAVE_TERMIOS_H
int n = 1;
unsigned char ch;
struct timeval tv;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 0;
n = select(1, &rfds, NULL, NULL, &tv);
if (n > 0) {
n = read(0, &ch, 1);
if (n == 1)
return ch;
return n;
}
#elif HAVE_CONIO_H
if(kbhit())
return(getch());
#endif
return -1;
}
| [
"static int FUNC_0(void)\n{",
"#if HAVE_TERMIOS_H\nint n = 1;",
"unsigned char ch;",
"struct timeval tv;",
"fd_set rfds;",
"FD_ZERO(&rfds);",
"FD_SET(0, &rfds);",
"tv.tv_sec = 0;",
"tv.tv_usec = 0;",
"n = select(1, &rfds, NULL, NULL, &tv);",
"if (n > 0) {",
"n = read(0, &ch, 1);",
"if (n == ... | [
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
0
] | [
[
1,
3
],
[
5,
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31,
33
],
[
37
],
[
39
],
[
41,
43,
45
],
[
47,
49
],
[... |
14,075 | int main(int argc, char *argv[])
{
int fd_in, fd_out, comp_len, uncomp_len, i, last_out;
char buf_in[1024], buf_out[65536];
z_stream zstream;
struct stat statbuf;
if (argc < 3) {
printf("Usage: %s <infile.swf> <outfile.swf>\n", argv[0]);
return 1;
}
fd_in = open(argv[1], O_RDONLY);
if (fd_in < 0) {
perror("Error opening input file");
return 1;
}
fd_out = open(argv[2], O_WRONLY | O_CREAT, 00644);
if (fd_out < 0) {
perror("Error opening output file");
close(fd_in);
return 1;
}
if (read(fd_in, &buf_in, 8) != 8) {
printf("Header error\n");
close(fd_in);
close(fd_out);
return 1;
}
if (buf_in[0] != 'C' || buf_in[1] != 'W' || buf_in[2] != 'S') {
printf("Not a compressed flash file\n");
return 1;
}
fstat(fd_in, &statbuf);
comp_len = statbuf.st_size;
uncomp_len = buf_in[4] | (buf_in[5] << 8) | (buf_in[6] << 16) | (buf_in[7] << 24);
printf("Compressed size: %d Uncompressed size: %d\n",
comp_len - 4, uncomp_len - 4);
// write out modified header
buf_in[0] = 'F';
if (write(fd_out, &buf_in, 8) < 8) {
perror("Error writing output file");
return 1;
}
zstream.zalloc = NULL;
zstream.zfree = NULL;
zstream.opaque = NULL;
if (inflateInit(&zstream) != Z_OK) {
fprintf(stderr, "inflateInit failed\n");
return 1;
}
for (i = 0; i < comp_len - 8;) {
int ret, len = read(fd_in, &buf_in, 1024);
dbgprintf("read %d bytes\n", len);
last_out = zstream.total_out;
zstream.next_in = &buf_in[0];
zstream.avail_in = len;
zstream.next_out = &buf_out[0];
zstream.avail_out = 65536;
ret = inflate(&zstream, Z_SYNC_FLUSH);
if (ret != Z_STREAM_END && ret != Z_OK) {
printf("Error while decompressing: %d\n", ret);
inflateEnd(&zstream);
return 1;
}
dbgprintf("a_in: %d t_in: %lu a_out: %d t_out: %lu -- %lu out\n",
zstream.avail_in, zstream.total_in, zstream.avail_out,
zstream.total_out, zstream.total_out - last_out);
if (write(fd_out, &buf_out, zstream.total_out - last_out) <
zstream.total_out - last_out) {
perror("Error writing output file");
return 1;
}
i += len;
if (ret == Z_STREAM_END || ret == Z_BUF_ERROR)
break;
}
if (zstream.total_out != uncomp_len - 8) {
printf("Size mismatch (%lu != %d), updating header...\n",
zstream.total_out, uncomp_len - 8);
buf_in[0] = (zstream.total_out + 8) & 0xff;
buf_in[1] = ((zstream.total_out + 8) >> 8) & 0xff;
buf_in[2] = ((zstream.total_out + 8) >> 16) & 0xff;
buf_in[3] = ((zstream.total_out + 8) >> 24) & 0xff;
if ( lseek(fd_out, 4, SEEK_SET) < 0
|| write(fd_out, &buf_in, 4) < 4) {
perror("Error writing output file");
return 1;
}
}
inflateEnd(&zstream);
close(fd_in);
close(fd_out);
return 0;
}
| false | FFmpeg | 5b45b66220ffdf37619dbd70e41df31651db3f93 | int main(int argc, char *argv[])
{
int fd_in, fd_out, comp_len, uncomp_len, i, last_out;
char buf_in[1024], buf_out[65536];
z_stream zstream;
struct stat statbuf;
if (argc < 3) {
printf("Usage: %s <infile.swf> <outfile.swf>\n", argv[0]);
return 1;
}
fd_in = open(argv[1], O_RDONLY);
if (fd_in < 0) {
perror("Error opening input file");
return 1;
}
fd_out = open(argv[2], O_WRONLY | O_CREAT, 00644);
if (fd_out < 0) {
perror("Error opening output file");
close(fd_in);
return 1;
}
if (read(fd_in, &buf_in, 8) != 8) {
printf("Header error\n");
close(fd_in);
close(fd_out);
return 1;
}
if (buf_in[0] != 'C' || buf_in[1] != 'W' || buf_in[2] != 'S') {
printf("Not a compressed flash file\n");
return 1;
}
fstat(fd_in, &statbuf);
comp_len = statbuf.st_size;
uncomp_len = buf_in[4] | (buf_in[5] << 8) | (buf_in[6] << 16) | (buf_in[7] << 24);
printf("Compressed size: %d Uncompressed size: %d\n",
comp_len - 4, uncomp_len - 4);
buf_in[0] = 'F';
if (write(fd_out, &buf_in, 8) < 8) {
perror("Error writing output file");
return 1;
}
zstream.zalloc = NULL;
zstream.zfree = NULL;
zstream.opaque = NULL;
if (inflateInit(&zstream) != Z_OK) {
fprintf(stderr, "inflateInit failed\n");
return 1;
}
for (i = 0; i < comp_len - 8;) {
int ret, len = read(fd_in, &buf_in, 1024);
dbgprintf("read %d bytes\n", len);
last_out = zstream.total_out;
zstream.next_in = &buf_in[0];
zstream.avail_in = len;
zstream.next_out = &buf_out[0];
zstream.avail_out = 65536;
ret = inflate(&zstream, Z_SYNC_FLUSH);
if (ret != Z_STREAM_END && ret != Z_OK) {
printf("Error while decompressing: %d\n", ret);
inflateEnd(&zstream);
return 1;
}
dbgprintf("a_in: %d t_in: %lu a_out: %d t_out: %lu -- %lu out\n",
zstream.avail_in, zstream.total_in, zstream.avail_out,
zstream.total_out, zstream.total_out - last_out);
if (write(fd_out, &buf_out, zstream.total_out - last_out) <
zstream.total_out - last_out) {
perror("Error writing output file");
return 1;
}
i += len;
if (ret == Z_STREAM_END || ret == Z_BUF_ERROR)
break;
}
if (zstream.total_out != uncomp_len - 8) {
printf("Size mismatch (%lu != %d), updating header...\n",
zstream.total_out, uncomp_len - 8);
buf_in[0] = (zstream.total_out + 8) & 0xff;
buf_in[1] = ((zstream.total_out + 8) >> 8) & 0xff;
buf_in[2] = ((zstream.total_out + 8) >> 16) & 0xff;
buf_in[3] = ((zstream.total_out + 8) >> 24) & 0xff;
if ( lseek(fd_out, 4, SEEK_SET) < 0
|| write(fd_out, &buf_in, 4) < 4) {
perror("Error writing output file");
return 1;
}
}
inflateEnd(&zstream);
close(fd_in);
close(fd_out);
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(int VAR_0, char *VAR_1[])
{
int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;
char VAR_8[1024], VAR_9[65536];
z_stream zstream;
struct stat VAR_10;
if (VAR_0 < 3) {
printf("Usage: %s <infile.swf> <outfile.swf>\n", VAR_1[0]);
return 1;
}
VAR_2 = open(VAR_1[1], O_RDONLY);
if (VAR_2 < 0) {
perror("Error opening input file");
return 1;
}
VAR_3 = open(VAR_1[2], O_WRONLY | O_CREAT, 00644);
if (VAR_3 < 0) {
perror("Error opening output file");
close(VAR_2);
return 1;
}
if (read(VAR_2, &VAR_8, 8) != 8) {
printf("Header error\n");
close(VAR_2);
close(VAR_3);
return 1;
}
if (VAR_8[0] != 'C' || VAR_8[1] != 'W' || VAR_8[2] != 'S') {
printf("Not a compressed flash file\n");
return 1;
}
fstat(VAR_2, &VAR_10);
VAR_4 = VAR_10.st_size;
VAR_5 = VAR_8[4] | (VAR_8[5] << 8) | (VAR_8[6] << 16) | (VAR_8[7] << 24);
printf("Compressed size: %d Uncompressed size: %d\n",
VAR_4 - 4, VAR_5 - 4);
VAR_8[0] = 'F';
if (write(VAR_3, &VAR_8, 8) < 8) {
perror("Error writing output file");
return 1;
}
zstream.zalloc = NULL;
zstream.zfree = NULL;
zstream.opaque = NULL;
if (inflateInit(&zstream) != Z_OK) {
fprintf(stderr, "inflateInit failed\n");
return 1;
}
for (VAR_6 = 0; VAR_6 < VAR_4 - 8;) {
int VAR_11, VAR_12 = read(VAR_2, &VAR_8, 1024);
dbgprintf("read %d bytes\n", VAR_12);
VAR_7 = zstream.total_out;
zstream.next_in = &VAR_8[0];
zstream.avail_in = VAR_12;
zstream.next_out = &VAR_9[0];
zstream.avail_out = 65536;
VAR_11 = inflate(&zstream, Z_SYNC_FLUSH);
if (VAR_11 != Z_STREAM_END && VAR_11 != Z_OK) {
printf("Error while decompressing: %d\n", VAR_11);
inflateEnd(&zstream);
return 1;
}
dbgprintf("a_in: %d t_in: %lu a_out: %d t_out: %lu -- %lu out\n",
zstream.avail_in, zstream.total_in, zstream.avail_out,
zstream.total_out, zstream.total_out - VAR_7);
if (write(VAR_3, &VAR_9, zstream.total_out - VAR_7) <
zstream.total_out - VAR_7) {
perror("Error writing output file");
return 1;
}
VAR_6 += VAR_12;
if (VAR_11 == Z_STREAM_END || VAR_11 == Z_BUF_ERROR)
break;
}
if (zstream.total_out != VAR_5 - 8) {
printf("Size mismatch (%lu != %d), updating header...\n",
zstream.total_out, VAR_5 - 8);
VAR_8[0] = (zstream.total_out + 8) & 0xff;
VAR_8[1] = ((zstream.total_out + 8) >> 8) & 0xff;
VAR_8[2] = ((zstream.total_out + 8) >> 16) & 0xff;
VAR_8[3] = ((zstream.total_out + 8) >> 24) & 0xff;
if ( lseek(VAR_3, 4, SEEK_SET) < 0
|| write(VAR_3, &VAR_8, 4) < 4) {
perror("Error writing output file");
return 1;
}
}
inflateEnd(&zstream);
close(VAR_2);
close(VAR_3);
return 0;
}
| [
"int FUNC_0(int VAR_0, char *VAR_1[])\n{",
"int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;",
"char VAR_8[1024], VAR_9[65536];",
"z_stream zstream;",
"struct stat VAR_10;",
"if (VAR_0 < 3) {",
"printf(\"Usage: %s <infile.swf> <outfile.swf>\\n\", VAR_1[0]);",
"return 1;",
"}",
"VAR_2 = open(VAR_1[1],... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
... |
14,077 | static void os_host_main_loop_wait(int *timeout)
{
int ret, ret2, i;
PollingEntry *pe;
/* XXX: need to suppress polling by better using win32 events */
ret = 0;
for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
ret |= pe->func(pe->opaque);
}
if (ret == 0) {
int err;
WaitObjects *w = &wait_objects;
qemu_mutex_unlock_iothread();
ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
qemu_mutex_lock_iothread();
if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
if (w->func[ret - WAIT_OBJECT_0]) {
w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
}
/* Check for additional signaled events */
for (i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
/* Check if event is signaled */
ret2 = WaitForSingleObject(w->events[i], 0);
if (ret2 == WAIT_OBJECT_0) {
if (w->func[i]) {
w->func[i](w->opaque[i]);
}
} else if (ret2 != WAIT_TIMEOUT) {
err = GetLastError();
fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
}
}
} else if (ret != WAIT_TIMEOUT) {
err = GetLastError();
fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
}
}
*timeout = 0;
}
| false | qemu | 15455536df5ef652759ccf465d5e6f73acb493df | static void os_host_main_loop_wait(int *timeout)
{
int ret, ret2, i;
PollingEntry *pe;
ret = 0;
for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
ret |= pe->func(pe->opaque);
}
if (ret == 0) {
int err;
WaitObjects *w = &wait_objects;
qemu_mutex_unlock_iothread();
ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
qemu_mutex_lock_iothread();
if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
if (w->func[ret - WAIT_OBJECT_0]) {
w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
}
for (i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
ret2 = WaitForSingleObject(w->events[i], 0);
if (ret2 == WAIT_OBJECT_0) {
if (w->func[i]) {
w->func[i](w->opaque[i]);
}
} else if (ret2 != WAIT_TIMEOUT) {
err = GetLastError();
fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
}
}
} else if (ret != WAIT_TIMEOUT) {
err = GetLastError();
fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
}
}
*timeout = 0;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(int *VAR_0)
{
int VAR_1, VAR_2, VAR_3;
PollingEntry *pe;
VAR_1 = 0;
for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
VAR_1 |= pe->func(pe->opaque);
}
if (VAR_1 == 0) {
int VAR_4;
WaitObjects *w = &wait_objects;
qemu_mutex_unlock_iothread();
VAR_1 = WaitForMultipleObjects(w->num, w->events, FALSE, *VAR_0);
qemu_mutex_lock_iothread();
if (WAIT_OBJECT_0 + 0 <= VAR_1 && VAR_1 <= WAIT_OBJECT_0 + w->num - 1) {
if (w->func[VAR_1 - WAIT_OBJECT_0]) {
w->func[VAR_1 - WAIT_OBJECT_0](w->opaque[VAR_1 - WAIT_OBJECT_0]);
}
for (VAR_3 = (VAR_1 - WAIT_OBJECT_0 + 1); VAR_3 < w->num; VAR_3++) {
VAR_2 = WaitForSingleObject(w->events[VAR_3], 0);
if (VAR_2 == WAIT_OBJECT_0) {
if (w->func[VAR_3]) {
w->func[VAR_3](w->opaque[VAR_3]);
}
} else if (VAR_2 != WAIT_TIMEOUT) {
VAR_4 = GetLastError();
fprintf(stderr, "WaitForSingleObject error %d %d\n", VAR_3, VAR_4);
}
}
} else if (VAR_1 != WAIT_TIMEOUT) {
VAR_4 = GetLastError();
fprintf(stderr, "WaitForMultipleObjects error %d %d\n", VAR_1, VAR_4);
}
}
*VAR_0 = 0;
}
| [
"static void FUNC_0(int *VAR_0)\n{",
"int VAR_1, VAR_2, VAR_3;",
"PollingEntry *pe;",
"VAR_1 = 0;",
"for (pe = first_polling_entry; pe != NULL; pe = pe->next) {",
"VAR_1 |= pe->func(pe->opaque);",
"}",
"if (VAR_1 == 0) {",
"int VAR_4;",
"WaitObjects *w = &wait_objects;",
"qemu_mutex_unlock_iothr... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
47
],
[
51
],
[
53... |
14,078 | static int v9fs_synth_get_dentry(V9fsSynthNode *dir, struct dirent *entry,
struct dirent **result, off_t off)
{
int i = 0;
V9fsSynthNode *node;
rcu_read_lock();
QLIST_FOREACH(node, &dir->child, sibling) {
/* This is the off child of the directory */
if (i == off) {
break;
}
i++;
}
rcu_read_unlock();
if (!node) {
/* end of directory */
*result = NULL;
return 0;
}
v9fs_synth_direntry(node, entry, off);
*result = entry;
return 0;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e | static int v9fs_synth_get_dentry(V9fsSynthNode *dir, struct dirent *entry,
struct dirent **result, off_t off)
{
int i = 0;
V9fsSynthNode *node;
rcu_read_lock();
QLIST_FOREACH(node, &dir->child, sibling) {
if (i == off) {
break;
}
i++;
}
rcu_read_unlock();
if (!node) {
*result = NULL;
return 0;
}
v9fs_synth_direntry(node, entry, off);
*result = entry;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(V9fsSynthNode *VAR_0, struct dirent *VAR_1,
struct dirent **VAR_2, off_t VAR_3)
{
int VAR_4 = 0;
V9fsSynthNode *node;
rcu_read_lock();
QLIST_FOREACH(node, &VAR_0->child, sibling) {
if (VAR_4 == VAR_3) {
break;
}
VAR_4++;
}
rcu_read_unlock();
if (!node) {
*VAR_2 = NULL;
return 0;
}
v9fs_synth_direntry(node, VAR_1, VAR_3);
*VAR_2 = VAR_1;
return 0;
}
| [
"static int FUNC_0(V9fsSynthNode *VAR_0, struct dirent *VAR_1,\nstruct dirent **VAR_2, off_t VAR_3)\n{",
"int VAR_4 = 0;",
"V9fsSynthNode *node;",
"rcu_read_lock();",
"QLIST_FOREACH(node, &VAR_0->child, sibling) {",
"if (VAR_4 == VAR_3) {",
"break;",
"}",
"VAR_4++;",
"}",
"rcu_read_unlock();",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
]
] |
14,079 | int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) {
if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0;
}
aSign = extractFloat32Sign( a );
bSign = extractFloat32Sign( b );
if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
return ( a != b ) && ( aSign ^ ( a < b ) );
}
| false | qemu | f090c9d4ad5812fb92843d6470a1111c15190c4c | int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) {
if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0;
}
aSign = extractFloat32Sign( a );
bSign = extractFloat32Sign( b );
if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
return ( a != b ) && ( aSign ^ ( a < b ) );
}
| {
"code": [],
"line_no": []
} | int FUNC_0( float32 VAR_0, float32 VAR_1 STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat32Exp( VAR_0 ) == 0xFF ) && extractFloat32Frac( VAR_0 ) )
|| ( ( extractFloat32Exp( VAR_1 ) == 0xFF ) && extractFloat32Frac( VAR_1 ) )
) {
if ( float32_is_signaling_nan( VAR_0 ) || float32_is_signaling_nan( VAR_1 ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0;
}
aSign = extractFloat32Sign( VAR_0 );
bSign = extractFloat32Sign( VAR_1 );
if ( aSign != bSign ) return aSign && ( (bits32) ( ( VAR_0 | VAR_1 )<<1 ) != 0 );
return ( VAR_0 != VAR_1 ) && ( aSign ^ ( VAR_0 < VAR_1 ) );
}
| [
"int FUNC_0( float32 VAR_0, float32 VAR_1 STATUS_PARAM )\n{",
"flag aSign, bSign;",
"if ( ( ( extractFloat32Exp( VAR_0 ) == 0xFF ) && extractFloat32Frac( VAR_0 ) )\n|| ( ( extractFloat32Exp( VAR_1 ) == 0xFF ) && extractFloat32Frac( VAR_1 ) )\n) {",
"if ( float32_is_signaling_nan( VAR_0 ) || float32_is_sign... | [
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
],
[
35
]
] |
14,080 | static void utf8_string(void)
{
/*
* FIXME Current behavior for invalid UTF-8 sequences is
* incorrect. This test expects current, incorrect results.
* They're all marked "bug:" below, and are to be replaced by
* correct ones as the bugs get fixed.
*
* The JSON parser rejects some invalid sequences, but accepts
* others without correcting the problem.
*
* The JSON formatter replaces some invalid sequences by U+FFFF (a
* noncharacter), and goes wonky for others.
*
* For both directions, we should either reject all invalid
* sequences, or minimize overlong sequences and replace all other
* invalid sequences by a suitable replacement character. A
* common choice for replacement is U+FFFD.
*
* Problem: we can't easily deal with embedded U+0000. Parsing
* the JSON string "this \\u0000" is fun" yields "this \0 is fun",
* which gets misinterpreted as NUL-terminated "this ". We should
* consider using overlong encoding \xC0\x80 for U+0000 ("modified
* UTF-8").
*
* Test cases are scraped from Markus Kuhn's UTF-8 decoder
* capability and stress test at
* http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
*/
static const struct {
const char *json_in;
const char *utf8_out;
const char *json_out; /* defaults to @json_in */
const char *utf8_in; /* defaults to @utf8_out */
} test_cases[] = {
/*
* Bug markers used here:
* - bug: not corrected
* JSON parser fails to correct invalid sequence(s)
* - bug: rejected
* JSON parser rejects invalid sequence(s)
* We may choose to define this as feature
* - bug: want "\"...\""
* JSON formatter produces incorrect result, this is the
* correct one, assuming replacement character U+FFFF
* - bug: want "..." (no \")
* JSON parser produces incorrect result, this is the
* correct one, assuming replacement character U+FFFF
* We may choose to reject instead of replace
* Not marked explicitly, but trivial to find:
* - JSON formatter replacing invalid sequence by \\uFFFF is a
* bug if we want it to fail for invalid sequences.
*/
/* 1 Some correct UTF-8 text */
{
/* a bit of German */
"\"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
" jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.\"",
"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
" jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.",
"\"Falsches \\u00DCben von Xylophonmusik qu\\u00E4lt"
" jeden gr\\u00F6\\u00DFeren Zwerg.\"",
},
{
/* a bit of Greek */
"\"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5\"",
"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
"\"\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5\"",
},
/* 2 Boundary condition test cases */
/* 2.1 First possible sequence of a certain length */
/* 2.1.1 1 byte U+0000 */
{
"\"\\u0000\"",
"", /* bug: want overlong "\xC0\x80" */
"\"\"", /* bug: want "\"\\u0000\"" */
},
/* 2.1.2 2 bytes U+0080 */
{
"\"\xC2\x80\"",
"\xC2\x80",
"\"\\u0080\"",
},
/* 2.1.3 3 bytes U+0800 */
{
"\"\xE0\xA0\x80\"",
"\xE0\xA0\x80",
"\"\\u0800\"",
},
/* 2.1.4 4 bytes U+10000 */
{
"\"\xF0\x90\x80\x80\"",
"\xF0\x90\x80\x80",
"\"\\u0400\\uFFFF\"", /* bug: want "\"\\uD800\\uDC00\"" */
},
/* 2.1.5 5 bytes U+200000 */
{
"\"\xF8\x88\x80\x80\x80\"",
NULL, /* bug: rejected */
"\"\\u8200\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xF8\x88\x80\x80\x80",
},
/* 2.1.6 6 bytes U+4000000 */
{
"\"\xFC\x84\x80\x80\x80\x80\"",
NULL, /* bug: rejected */
"\"\\uC100\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xFC\x84\x80\x80\x80\x80",
},
/* 2.2 Last possible sequence of a certain length */
/* 2.2.1 1 byte U+007F */
{
"\"\x7F\"",
"\x7F",
"\"\177\"",
},
/* 2.2.2 2 bytes U+07FF */
{
"\"\xDF\xBF\"",
"\xDF\xBF",
"\"\\u07FF\"",
},
/* 2.2.3 3 bytes U+FFFF */
{
"\"\xEF\xBF\xBF\"",
"\xEF\xBF\xBF",
"\"\\uFFFF\"",
},
/* 2.2.4 4 bytes U+1FFFFF */
{
"\"\xF7\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\u7FFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xF7\xBF\xBF\xBF",
},
/* 2.2.5 5 bytes U+3FFFFFF */
{
"\"\xFB\xBF\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\uBFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xFB\xBF\xBF\xBF\xBF",
},
/* 2.2.6 6 bytes U+7FFFFFFF */
{
"\"\xFD\xBF\xBF\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\uDFFF\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xFD\xBF\xBF\xBF\xBF\xBF",
},
/* 2.3 Other boundary conditions */
{
/* U+D7FF */
"\"\xED\x9F\xBF\"",
"\xED\x9F\xBF",
"\"\\uD7FF\"",
},
{
/* U+E000 */
"\"\xEE\x80\x80\"",
"\xEE\x80\x80",
"\"\\uE000\"",
},
{
/* U+FFFD */
"\"\xEF\xBF\xBD\"",
"\xEF\xBF\xBD",
"\"\\uFFFD\"",
},
{
/* U+10FFFF */
"\"\xF4\x8F\xBF\xBF\"",
"\xF4\x8F\xBF\xBF",
"\"\\u43FF\\uFFFF\"", /* bug: want "\"\\uDBFF\\uDFFF\"" */
},
{
/* U+110000 */
"\"\xF4\x90\x80\x80\"",
"\xF4\x90\x80\x80",
"\"\\u4400\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
},
/* 3 Malformed sequences */
/* 3.1 Unexpected continuation bytes */
/* 3.1.1 First continuation byte */
{
"\"\x80\"",
"\x80", /* bug: not corrected */
"\"\\uFFFF\"",
},
/* 3.1.2 Last continuation byte */
{
"\"\xBF\"",
"\xBF", /* bug: not corrected */
"\"\\uFFFF\"",
},
/* 3.1.3 2 continuation bytes */
{
"\"\x80\xBF\"",
"\x80\xBF", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\"",
},
/* 3.1.4 3 continuation bytes */
{
"\"\x80\xBF\x80\"",
"\x80\xBF\x80", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\\uFFFF\"",
},
/* 3.1.5 4 continuation bytes */
{
"\"\x80\xBF\x80\xBF\"",
"\x80\xBF\x80\xBF", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
/* 3.1.6 5 continuation bytes */
{
"\"\x80\xBF\x80\xBF\x80\"",
"\x80\xBF\x80\xBF\x80", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
/* 3.1.7 6 continuation bytes */
{
"\"\x80\xBF\x80\xBF\x80\xBF\"",
"\x80\xBF\x80\xBF\x80\xBF", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
/* 3.1.8 7 continuation bytes */
{
"\"\x80\xBF\x80\xBF\x80\xBF\x80\"",
"\x80\xBF\x80\xBF\x80\xBF\x80", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
/* 3.1.9 Sequence of all 64 possible continuation bytes */
{
"\"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
"\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
"\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
"\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
"\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\"",
/* bug: not corrected */
"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
"\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
"\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
"\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
"\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\""
},
/* 3.2 Lonely start characters */
/* 3.2.1 All 32 first bytes of 2-byte sequences, followed by space */
{
"\"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
"\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
"\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
"\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF \"",
NULL, /* bug: rejected */
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
"\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
"\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
"\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
},
/* 3.2.2 All 16 first bytes of 3-byte sequences, followed by space */
{
"\"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
"\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF \"",
/* bug: not corrected */
"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
"\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
},
/* 3.2.3 All 8 first bytes of 4-byte sequences, followed by space */
{
"\"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 \"",
NULL, /* bug: rejected */
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
},
/* 3.2.4 All 4 first bytes of 5-byte sequences, followed by space */
{
"\"\xF8 \xF9 \xFA \xFB \"",
NULL, /* bug: rejected */
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xF8 \xF9 \xFA \xFB ",
},
/* 3.2.5 All 2 first bytes of 6-byte sequences, followed by space */
{
"\"\xFC \xFD \"",
NULL, /* bug: rejected */
"\"\\uFFFF \\uFFFF \"",
"\xFC \xFD ",
},
/* 3.3 Sequences with last continuation byte missing */
/* 3.3.1 2-byte sequence with last byte missing (U+0000) */
{
"\"\xC0\"",
NULL, /* bug: rejected */
"\"\\uFFFF\"",
"\xC0",
},
/* 3.3.2 3-byte sequence with last byte missing (U+0000) */
{
"\"\xE0\x80\"",
"\xE0\x80", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
},
/* 3.3.3 4-byte sequence with last byte missing (U+0000) */
{
"\"\xF0\x80\x80\"",
"\xF0\x80\x80", /* bug: not corrected */
"\"\\u0000\"", /* bug: want "\"\\uFFFF\"" */
},
/* 3.3.4 5-byte sequence with last byte missing (U+0000) */
{
/* invalid */
"\"\xF8\x80\x80\x80\"", /* bug: not corrected */
NULL, /* bug: rejected */
"\"\\u8000\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xF8\x80\x80\x80",
},
/* 3.3.5 6-byte sequence with last byte missing (U+0000) */
{
"\"\xFC\x80\x80\x80\x80\"",
NULL, /* bug: rejected */
"\"\\uC000\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xFC\x80\x80\x80\x80",
},
/* 3.3.6 2-byte sequence with last byte missing (U+07FF) */
{
"\"\xDF\"",
"\xDF", /* bug: not corrected */
"\"\\uFFFF\"",
},
/* 3.3.7 3-byte sequence with last byte missing (U+FFFF) */
{
"\"\xEF\xBF\"",
"\xEF\xBF", /* bug: not corrected */
"\"\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
},
/* 3.3.8 4-byte sequence with last byte missing (U+1FFFFF) */
{
"\"\xF7\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\u7FFF\"", /* bug: want "\"\\uFFFF\"" */
"\xF7\xBF\xBF",
},
/* 3.3.9 5-byte sequence with last byte missing (U+3FFFFFF) */
{
"\"\xFB\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\uBFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xFB\xBF\xBF\xBF",
},
/* 3.3.10 6-byte sequence with last byte missing (U+7FFFFFFF) */
{
"\"\xFD\xBF\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\uDFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"", */
"\xFD\xBF\xBF\xBF\xBF",
},
/* 3.4 Concatenation of incomplete sequences */
{
"\"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
"\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
/* bug: want "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"" */
"\"\\u0020\\uFFFF\\u0000\\u8000\\uFFFF\\uC000\\uFFFF\\uFFFF"
"\\u07EF\\uFFFF\\u7FFF\\uBFFF\\uFFFF\\uDFFF\\uFFFF\\uFFFF\"",
"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
"\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF",
},
/* 3.5 Impossible bytes */
{
"\"\xFE\"",
NULL, /* bug: rejected */
"\"\\uFFFF\"",
"\xFE",
},
{
"\"\xFF\"",
NULL, /* bug: rejected */
"\"\\uFFFF\"",
"\xFF",
},
{
"\"\xFE\xFE\xFF\xFF\"",
NULL, /* bug: rejected */
/* bug: want "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"" */
"\"\\uEFBF\\uFFFF\"",
"\xFE\xFE\xFF\xFF",
},
/* 4 Overlong sequences */
/* 4.1 Overlong '/' */
{
"\"\xC0\xAF\"",
NULL, /* bug: rejected */
"\"\\u002F\"", /* bug: want "\"/\"" */
"\xC0\xAF",
},
{
"\"\xE0\x80\xAF\"",
"\xE0\x80\xAF", /* bug: not corrected */
"\"\\u002F\"", /* bug: want "\"/\"" */
},
{
"\"\xF0\x80\x80\xAF\"",
"\xF0\x80\x80\xAF", /* bug: not corrected */
"\"\\u0000\\uFFFF\"" /* bug: want "\"/\"" */
},
{
"\"\xF8\x80\x80\x80\xAF\"",
NULL, /* bug: rejected */
"\"\\u8000\\uFFFF\\uFFFF\"", /* bug: want "\"/\"" */
"\xF8\x80\x80\x80\xAF",
},
{
"\"\xFC\x80\x80\x80\x80\xAF\"",
NULL, /* bug: rejected */
"\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"/\"" */
"\xFC\x80\x80\x80\x80\xAF",
},
/* 4.2 Maximum overlong sequences */
{
/* \U+007F */
"\"\xC1\xBF\"",
NULL, /* bug: rejected */
"\"\\u007F\"", /* bug: want "\"\177\"" */
"\xC1\xBF",
},
{
/* \U+07FF */
"\"\xE0\x9F\xBF\"",
"\xE0\x9F\xBF", /* bug: not corrected */
"\"\\u07FF\"",
},
{
/* \U+FFFF */
"\"\xF0\x8F\xBF\xBF\"",
"\xF0\x8F\xBF\xBF", /* bug: not corrected */
"\"\\u03FF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+1FFFFF */
"\"\xF8\x87\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\u81FF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xF8\x87\xBF\xBF\xBF",
},
{
/* \U+3FFFFFF */
"\"\xFC\x83\xBF\xBF\xBF\xBF\"",
NULL, /* bug: rejected */
"\"\\uC0FF\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */
"\xFC\x83\xBF\xBF\xBF\xBF",
},
/* 4.3 Overlong representation of the NUL character */
{
/* \U+0000 */
"\"\xC0\x80\"",
NULL, /* bug: rejected */
"\"\\u0000\"",
"\xC0\x80",
},
{
/* \U+0000 */
"\"\xE0\x80\x80\"",
"\xE0\x80\x80", /* bug: not corrected */
"\"\\u0000\"",
},
{
/* \U+0000 */
"\"\xF0\x80\x80\x80\"",
"\xF0\x80\x80\x80", /* bug: not corrected */
"\"\\u0000\\uFFFF\"", /* bug: want "\"\\u0000\"" */
},
{
/* \U+0000 */
"\"\xF8\x80\x80\x80\x80\"",
NULL, /* bug: rejected */
"\"\\u8000\\uFFFF\\uFFFF\"", /* bug: want "\"\\u0000\"" */
"\xF8\x80\x80\x80\x80",
},
{
/* \U+0000 */
"\"\xFC\x80\x80\x80\x80\x80\"",
NULL, /* bug: rejected */
"\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\u0000\"" */
"\xFC\x80\x80\x80\x80\x80",
},
/* 5 Illegal code positions */
/* 5.1 Single UTF-16 surrogates */
{
/* \U+D800 */
"\"\xED\xA0\x80\"",
"\xED\xA0\x80", /* bug: not corrected */
"\"\\uD800\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+DB7F */
"\"\xED\xAD\xBF\"",
"\xED\xAD\xBF", /* bug: not corrected */
"\"\\uDB7F\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+DB80 */
"\"\xED\xAE\x80\"",
"\xED\xAE\x80", /* bug: not corrected */
"\"\\uDB80\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+DBFF */
"\"\xED\xAF\xBF\"",
"\xED\xAF\xBF", /* bug: not corrected */
"\"\\uDBFF\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+DC00 */
"\"\xED\xB0\x80\"",
"\xED\xB0\x80", /* bug: not corrected */
"\"\\uDC00\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+DF80 */
"\"\xED\xBE\x80\"",
"\xED\xBE\x80", /* bug: not corrected */
"\"\\uDF80\"", /* bug: want "\"\\uFFFF\"" */
},
{
/* \U+DFFF */
"\"\xED\xBF\xBF\"",
"\xED\xBF\xBF", /* bug: not corrected */
"\"\\uDFFF\"", /* bug: want "\"\\uFFFF\"" */
},
/* 5.2 Paired UTF-16 surrogates */
{
/* \U+D800\U+DC00 */
"\"\xED\xA0\x80\xED\xB0\x80\"",
"\xED\xA0\x80\xED\xB0\x80", /* bug: not corrected */
"\"\\uD800\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+D800\U+DFFF */
"\"\xED\xA0\x80\xED\xBF\xBF\"",
"\xED\xA0\x80\xED\xBF\xBF", /* bug: not corrected */
"\"\\uD800\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+DB7F\U+DC00 */
"\"\xED\xAD\xBF\xED\xB0\x80\"",
"\xED\xAD\xBF\xED\xB0\x80", /* bug: not corrected */
"\"\\uDB7F\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+DB7F\U+DFFF */
"\"\xED\xAD\xBF\xED\xBF\xBF\"",
"\xED\xAD\xBF\xED\xBF\xBF", /* bug: not corrected */
"\"\\uDB7F\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+DB80\U+DC00 */
"\"\xED\xAE\x80\xED\xB0\x80\"",
"\xED\xAE\x80\xED\xB0\x80", /* bug: not corrected */
"\"\\uDB80\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+DB80\U+DFFF */
"\"\xED\xAE\x80\xED\xBF\xBF\"",
"\xED\xAE\x80\xED\xBF\xBF", /* bug: not corrected */
"\"\\uDB80\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+DBFF\U+DC00 */
"\"\xED\xAF\xBF\xED\xB0\x80\"",
"\xED\xAF\xBF\xED\xB0\x80", /* bug: not corrected */
"\"\\uDBFF\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
{
/* \U+DBFF\U+DFFF */
"\"\xED\xAF\xBF\xED\xBF\xBF\"",
"\xED\xAF\xBF\xED\xBF\xBF", /* bug: not corrected */
"\"\\uDBFF\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */
},
/* 5.3 Other illegal code positions */
{
/* \U+FFFE */
"\"\xEF\xBF\xBE\"",
"\xEF\xBF\xBE", /* bug: not corrected */
"\"\\uFFFE\"", /* bug: not corrected */
},
{
/* \U+FFFF */
"\"\xEF\xBF\xBF\"",
"\xEF\xBF\xBF", /* bug: not corrected */
"\"\\uFFFF\"", /* bug: not corrected */
},
{}
};
int i;
QObject *obj;
QString *str;
const char *json_in, *utf8_out, *utf8_in, *json_out;
for (i = 0; test_cases[i].json_in; i++) {
json_in = test_cases[i].json_in;
utf8_out = test_cases[i].utf8_out;
utf8_in = test_cases[i].utf8_in ?: test_cases[i].utf8_out;
json_out = test_cases[i].json_out ?: test_cases[i].json_in;
obj = qobject_from_json(json_in);
if (utf8_out) {
g_assert(obj);
g_assert(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
} else {
g_assert(!obj);
}
qobject_decref(obj);
obj = QOBJECT(qstring_from_str(utf8_in));
str = qobject_to_json(obj);
if (json_out) {
g_assert(str);
g_assert_cmpstr(qstring_get_str(str), ==, json_out);
} else {
g_assert(!str);
}
QDECREF(str);
qobject_decref(obj);
/*
* Disabled, because json_out currently contains the crap
* qobject_to_json() produces.
* FIXME Enable once these bugs have been fixed.
*/
if (0 && json_out != json_in) {
obj = qobject_from_json(json_out);
g_assert(obj);
g_assert(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
}
}
}
| false | qemu | d6244e2ce48b353402eff271d382ee6fd47ce166 | static void utf8_string(void)
{
static const struct {
const char *json_in;
const char *utf8_out;
const char *json_out;
const char *utf8_in;
} test_cases[] = {
{
"\"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
" jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.\"",
"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
" jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.",
"\"Falsches \\u00DCben von Xylophonmusik qu\\u00E4lt"
" jeden gr\\u00F6\\u00DFeren Zwerg.\"",
},
{
"\"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5\"",
"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
"\"\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5\"",
},
{
"\"\\u0000\"",
"",
"\"\"",
},
{
"\"\xC2\x80\"",
"\xC2\x80",
"\"\\u0080\"",
},
{
"\"\xE0\xA0\x80\"",
"\xE0\xA0\x80",
"\"\\u0800\"",
},
{
"\"\xF0\x90\x80\x80\"",
"\xF0\x90\x80\x80",
"\"\\u0400\\uFFFF\"",
},
{
"\"\xF8\x88\x80\x80\x80\"",
NULL,
"\"\\u8200\\uFFFF\\uFFFF\"",
"\xF8\x88\x80\x80\x80",
},
{
"\"\xFC\x84\x80\x80\x80\x80\"",
NULL,
"\"\\uC100\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x84\x80\x80\x80\x80",
},
{
"\"\x7F\"",
"\x7F",
"\"\177\"",
},
{
"\"\xDF\xBF\"",
"\xDF\xBF",
"\"\\u07FF\"",
},
{
"\"\xEF\xBF\xBF\"",
"\xEF\xBF\xBF",
"\"\\uFFFF\"",
},
{
"\"\xF7\xBF\xBF\xBF\"",
NULL,
"\"\\u7FFF\\uFFFF\"",
"\xF7\xBF\xBF\xBF",
},
{
"\"\xFB\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uBFFF\\uFFFF\\uFFFF\"",
"\xFB\xBF\xBF\xBF\xBF",
},
{
"\"\xFD\xBF\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uDFFF\\uFFFF\\uFFFF\\uFFFF\"",
"\xFD\xBF\xBF\xBF\xBF\xBF",
},
{
"\"\xED\x9F\xBF\"",
"\xED\x9F\xBF",
"\"\\uD7FF\"",
},
{
"\"\xEE\x80\x80\"",
"\xEE\x80\x80",
"\"\\uE000\"",
},
{
"\"\xEF\xBF\xBD\"",
"\xEF\xBF\xBD",
"\"\\uFFFD\"",
},
{
"\"\xF4\x8F\xBF\xBF\"",
"\xF4\x8F\xBF\xBF",
"\"\\u43FF\\uFFFF\"",
},
{
"\"\xF4\x90\x80\x80\"",
"\xF4\x90\x80\x80",
"\"\\u4400\\uFFFF\"",
},
{
"\"\x80\"",
"\x80",
"\"\\uFFFF\"",
},
{
"\"\xBF\"",
"\xBF",
"\"\\uFFFF\"",
},
{
"\"\x80\xBF\"",
"\x80\xBF",
"\"\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\"",
"\x80\xBF\x80",
"\"\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\"",
"\x80\xBF\x80\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\x80\"",
"\x80\xBF\x80\xBF\x80",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\x80\xBF\"",
"\x80\xBF\x80\xBF\x80\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\x80\xBF\x80\"",
"\x80\xBF\x80\xBF\x80\xBF\x80",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
"\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
"\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
"\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
"\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\"",
"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
"\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
"\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
"\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
"\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\""
},
{
"\"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
"\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
"\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
"\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF \"",
NULL,
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
"\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
"\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
"\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
},
{
"\"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
"\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF \"",
"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
"\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
},
{
"\"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 \"",
NULL,
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
},
{
"\"\xF8 \xF9 \xFA \xFB \"",
NULL,
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xF8 \xF9 \xFA \xFB ",
},
{
"\"\xFC \xFD \"",
NULL,
"\"\\uFFFF \\uFFFF \"",
"\xFC \xFD ",
},
{
"\"\xC0\"",
NULL,
"\"\\uFFFF\"",
"\xC0",
},
{
"\"\xE0\x80\"",
"\xE0\x80",
"\"\\uFFFF\\uFFFF\"",
},
{
"\"\xF0\x80\x80\"",
"\xF0\x80\x80",
"\"\\u0000\"",
},
{
"\"\xF8\x80\x80\x80\"",
NULL,
"\"\\u8000\\uFFFF\"",
"\xF8\x80\x80\x80",
},
{
"\"\xFC\x80\x80\x80\x80\"",
NULL,
"\"\\uC000\\uFFFF\\uFFFF\"",
"\xFC\x80\x80\x80\x80",
},
{
"\"\xDF\"",
"\xDF",
"\"\\uFFFF\"",
},
{
"\"\xEF\xBF\"",
"\xEF\xBF",
"\"\\uFFFF\\uFFFF\"",
},
{
"\"\xF7\xBF\xBF\"",
NULL,
"\"\\u7FFF\"",
"\xF7\xBF\xBF",
},
{
"\"\xFB\xBF\xBF\xBF\"",
NULL,
"\"\\uBFFF\\uFFFF\"",
"\xFB\xBF\xBF\xBF",
},
{
"\"\xFD\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uDFFF\\uFFFF\\uFFFF\"",
"\xFD\xBF\xBF\xBF\xBF",
},
{
"\"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
"\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\u0020\\uFFFF\\u0000\\u8000\\uFFFF\\uC000\\uFFFF\\uFFFF"
"\\u07EF\\uFFFF\\u7FFF\\uBFFF\\uFFFF\\uDFFF\\uFFFF\\uFFFF\"",
"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
"\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF",
},
{
"\"\xFE\"",
NULL,
"\"\\uFFFF\"",
"\xFE",
},
{
"\"\xFF\"",
NULL,
"\"\\uFFFF\"",
"\xFF",
},
{
"\"\xFE\xFE\xFF\xFF\"",
NULL,
"\"\\uEFBF\\uFFFF\"",
"\xFE\xFE\xFF\xFF",
},
{
"\"\xC0\xAF\"",
NULL,
"\"\\u002F\"",
"\xC0\xAF",
},
{
"\"\xE0\x80\xAF\"",
"\xE0\x80\xAF",
"\"\\u002F\"",
},
{
"\"\xF0\x80\x80\xAF\"",
"\xF0\x80\x80\xAF",
"\"\\u0000\\uFFFF\""
},
{
"\"\xF8\x80\x80\x80\xAF\"",
NULL,
"\"\\u8000\\uFFFF\\uFFFF\"",
"\xF8\x80\x80\x80\xAF",
},
{
"\"\xFC\x80\x80\x80\x80\xAF\"",
NULL,
"\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x80\x80\x80\x80\xAF",
},
{
"\"\xC1\xBF\"",
NULL,
"\"\\u007F\"",
"\xC1\xBF",
},
{
"\"\xE0\x9F\xBF\"",
"\xE0\x9F\xBF",
"\"\\u07FF\"",
},
{
"\"\xF0\x8F\xBF\xBF\"",
"\xF0\x8F\xBF\xBF",
"\"\\u03FF\\uFFFF\"",
},
{
"\"\xF8\x87\xBF\xBF\xBF\"",
NULL,
"\"\\u81FF\\uFFFF\\uFFFF\"",
"\xF8\x87\xBF\xBF\xBF",
},
{
"\"\xFC\x83\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uC0FF\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x83\xBF\xBF\xBF\xBF",
},
{
"\"\xC0\x80\"",
NULL,
"\"\\u0000\"",
"\xC0\x80",
},
{
"\"\xE0\x80\x80\"",
"\xE0\x80\x80",
"\"\\u0000\"",
},
{
"\"\xF0\x80\x80\x80\"",
"\xF0\x80\x80\x80",
"\"\\u0000\\uFFFF\"",
},
{
"\"\xF8\x80\x80\x80\x80\"",
NULL,
"\"\\u8000\\uFFFF\\uFFFF\"",
"\xF8\x80\x80\x80\x80",
},
{
"\"\xFC\x80\x80\x80\x80\x80\"",
NULL,
"\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x80\x80\x80\x80\x80",
},
{
"\"\xED\xA0\x80\"",
"\xED\xA0\x80",
"\"\\uD800\"",
},
{
"\"\xED\xAD\xBF\"",
"\xED\xAD\xBF",
"\"\\uDB7F\"",
},
{
"\"\xED\xAE\x80\"",
"\xED\xAE\x80",
"\"\\uDB80\"",
},
{
"\"\xED\xAF\xBF\"",
"\xED\xAF\xBF",
"\"\\uDBFF\"",
},
{
"\"\xED\xB0\x80\"",
"\xED\xB0\x80",
"\"\\uDC00\"",
},
{
"\"\xED\xBE\x80\"",
"\xED\xBE\x80",
"\"\\uDF80\"",
},
{
"\"\xED\xBF\xBF\"",
"\xED\xBF\xBF",
"\"\\uDFFF\"",
},
{
"\"\xED\xA0\x80\xED\xB0\x80\"",
"\xED\xA0\x80\xED\xB0\x80",
"\"\\uD800\\uDC00\"",
},
{
"\"\xED\xA0\x80\xED\xBF\xBF\"",
"\xED\xA0\x80\xED\xBF\xBF",
"\"\\uD800\\uDFFF\"",
},
{
"\"\xED\xAD\xBF\xED\xB0\x80\"",
"\xED\xAD\xBF\xED\xB0\x80",
"\"\\uDB7F\\uDC00\"",
},
{
"\"\xED\xAD\xBF\xED\xBF\xBF\"",
"\xED\xAD\xBF\xED\xBF\xBF",
"\"\\uDB7F\\uDFFF\"",
},
{
"\"\xED\xAE\x80\xED\xB0\x80\"",
"\xED\xAE\x80\xED\xB0\x80",
"\"\\uDB80\\uDC00\"",
},
{
"\"\xED\xAE\x80\xED\xBF\xBF\"",
"\xED\xAE\x80\xED\xBF\xBF",
"\"\\uDB80\\uDFFF\"",
},
{
"\"\xED\xAF\xBF\xED\xB0\x80\"",
"\xED\xAF\xBF\xED\xB0\x80",
"\"\\uDBFF\\uDC00\"",
},
{
"\"\xED\xAF\xBF\xED\xBF\xBF\"",
"\xED\xAF\xBF\xED\xBF\xBF",
"\"\\uDBFF\\uDFFF\"",
},
{
"\"\xEF\xBF\xBE\"",
"\xEF\xBF\xBE",
"\"\\uFFFE\"",
},
{
"\"\xEF\xBF\xBF\"",
"\xEF\xBF\xBF",
"\"\\uFFFF\"",
},
{}
};
int i;
QObject *obj;
QString *str;
const char *json_in, *utf8_out, *utf8_in, *json_out;
for (i = 0; test_cases[i].json_in; i++) {
json_in = test_cases[i].json_in;
utf8_out = test_cases[i].utf8_out;
utf8_in = test_cases[i].utf8_in ?: test_cases[i].utf8_out;
json_out = test_cases[i].json_out ?: test_cases[i].json_in;
obj = qobject_from_json(json_in);
if (utf8_out) {
g_assert(obj);
g_assert(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
} else {
g_assert(!obj);
}
qobject_decref(obj);
obj = QOBJECT(qstring_from_str(utf8_in));
str = qobject_to_json(obj);
if (json_out) {
g_assert(str);
g_assert_cmpstr(qstring_get_str(str), ==, json_out);
} else {
g_assert(!str);
}
QDECREF(str);
qobject_decref(obj);
if (0 && json_out != json_in) {
obj = qobject_from_json(json_out);
g_assert(obj);
g_assert(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
static const struct {
const char *VAR_2;
const char *VAR_3;
const char *VAR_5;
const char *VAR_4;
} VAR_0[] = {
{
"\"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
" jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.\"",
"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
" jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.",
"\"Falsches \\u00DCben von Xylophonmusik qu\\u00E4lt"
" jeden gr\\u00F6\\u00DFeren Zwerg.\"",
},
{
"\"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5\"",
"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
"\"\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5\"",
},
{
"\"\\u0000\"",
"",
"\"\"",
},
{
"\"\xC2\x80\"",
"\xC2\x80",
"\"\\u0080\"",
},
{
"\"\xE0\xA0\x80\"",
"\xE0\xA0\x80",
"\"\\u0800\"",
},
{
"\"\xF0\x90\x80\x80\"",
"\xF0\x90\x80\x80",
"\"\\u0400\\uFFFF\"",
},
{
"\"\xF8\x88\x80\x80\x80\"",
NULL,
"\"\\u8200\\uFFFF\\uFFFF\"",
"\xF8\x88\x80\x80\x80",
},
{
"\"\xFC\x84\x80\x80\x80\x80\"",
NULL,
"\"\\uC100\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x84\x80\x80\x80\x80",
},
{
"\"\x7F\"",
"\x7F",
"\"\177\"",
},
{
"\"\xDF\xBF\"",
"\xDF\xBF",
"\"\\u07FF\"",
},
{
"\"\xEF\xBF\xBF\"",
"\xEF\xBF\xBF",
"\"\\uFFFF\"",
},
{
"\"\xF7\xBF\xBF\xBF\"",
NULL,
"\"\\u7FFF\\uFFFF\"",
"\xF7\xBF\xBF\xBF",
},
{
"\"\xFB\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uBFFF\\uFFFF\\uFFFF\"",
"\xFB\xBF\xBF\xBF\xBF",
},
{
"\"\xFD\xBF\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uDFFF\\uFFFF\\uFFFF\\uFFFF\"",
"\xFD\xBF\xBF\xBF\xBF\xBF",
},
{
"\"\xED\x9F\xBF\"",
"\xED\x9F\xBF",
"\"\\uD7FF\"",
},
{
"\"\xEE\x80\x80\"",
"\xEE\x80\x80",
"\"\\uE000\"",
},
{
"\"\xEF\xBF\xBD\"",
"\xEF\xBF\xBD",
"\"\\uFFFD\"",
},
{
"\"\xF4\x8F\xBF\xBF\"",
"\xF4\x8F\xBF\xBF",
"\"\\u43FF\\uFFFF\"",
},
{
"\"\xF4\x90\x80\x80\"",
"\xF4\x90\x80\x80",
"\"\\u4400\\uFFFF\"",
},
{
"\"\x80\"",
"\x80",
"\"\\uFFFF\"",
},
{
"\"\xBF\"",
"\xBF",
"\"\\uFFFF\"",
},
{
"\"\x80\xBF\"",
"\x80\xBF",
"\"\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\"",
"\x80\xBF\x80",
"\"\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\"",
"\x80\xBF\x80\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\x80\"",
"\x80\xBF\x80\xBF\x80",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\x80\xBF\"",
"\x80\xBF\x80\xBF\x80\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\xBF\x80\xBF\x80\xBF\x80\"",
"\x80\xBF\x80\xBF\x80\xBF\x80",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"",
},
{
"\"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
"\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
"\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
"\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
"\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\"",
"\x80\x81\x82\x83\x84\x85\x86\x87"
"\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
"\x90\x91\x92\x93\x94\x95\x96\x97"
"\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
"\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
"\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
"\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
"\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
"\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF"
"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\""
},
{
"\"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
"\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
"\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
"\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF \"",
NULL,
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
"\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
"\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
"\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
},
{
"\"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
"\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF \"",
"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
"\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF "
"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
},
{
"\"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 \"",
NULL,
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
},
{
"\"\xF8 \xF9 \xFA \xFB \"",
NULL,
"\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \"",
"\xF8 \xF9 \xFA \xFB ",
},
{
"\"\xFC \xFD \"",
NULL,
"\"\\uFFFF \\uFFFF \"",
"\xFC \xFD ",
},
{
"\"\xC0\"",
NULL,
"\"\\uFFFF\"",
"\xC0",
},
{
"\"\xE0\x80\"",
"\xE0\x80",
"\"\\uFFFF\\uFFFF\"",
},
{
"\"\xF0\x80\x80\"",
"\xF0\x80\x80",
"\"\\u0000\"",
},
{
"\"\xF8\x80\x80\x80\"",
NULL,
"\"\\u8000\\uFFFF\"",
"\xF8\x80\x80\x80",
},
{
"\"\xFC\x80\x80\x80\x80\"",
NULL,
"\"\\uC000\\uFFFF\\uFFFF\"",
"\xFC\x80\x80\x80\x80",
},
{
"\"\xDF\"",
"\xDF",
"\"\\uFFFF\"",
},
{
"\"\xEF\xBF\"",
"\xEF\xBF",
"\"\\uFFFF\\uFFFF\"",
},
{
"\"\xF7\xBF\xBF\"",
NULL,
"\"\\u7FFF\"",
"\xF7\xBF\xBF",
},
{
"\"\xFB\xBF\xBF\xBF\"",
NULL,
"\"\\uBFFF\\uFFFF\"",
"\xFB\xBF\xBF\xBF",
},
{
"\"\xFD\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uDFFF\\uFFFF\\uFFFF\"",
"\xFD\xBF\xBF\xBF\xBF",
},
{
"\"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
"\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\u0020\\uFFFF\\u0000\\u8000\\uFFFF\\uC000\\uFFFF\\uFFFF"
"\\u07EF\\uFFFF\\u7FFF\\uBFFF\\uFFFF\\uDFFF\\uFFFF\\uFFFF\"",
"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
"\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF",
},
{
"\"\xFE\"",
NULL,
"\"\\uFFFF\"",
"\xFE",
},
{
"\"\xFF\"",
NULL,
"\"\\uFFFF\"",
"\xFF",
},
{
"\"\xFE\xFE\xFF\xFF\"",
NULL,
"\"\\uEFBF\\uFFFF\"",
"\xFE\xFE\xFF\xFF",
},
{
"\"\xC0\xAF\"",
NULL,
"\"\\u002F\"",
"\xC0\xAF",
},
{
"\"\xE0\x80\xAF\"",
"\xE0\x80\xAF",
"\"\\u002F\"",
},
{
"\"\xF0\x80\x80\xAF\"",
"\xF0\x80\x80\xAF",
"\"\\u0000\\uFFFF\""
},
{
"\"\xF8\x80\x80\x80\xAF\"",
NULL,
"\"\\u8000\\uFFFF\\uFFFF\"",
"\xF8\x80\x80\x80\xAF",
},
{
"\"\xFC\x80\x80\x80\x80\xAF\"",
NULL,
"\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x80\x80\x80\x80\xAF",
},
{
"\"\xC1\xBF\"",
NULL,
"\"\\u007F\"",
"\xC1\xBF",
},
{
"\"\xE0\x9F\xBF\"",
"\xE0\x9F\xBF",
"\"\\u07FF\"",
},
{
"\"\xF0\x8F\xBF\xBF\"",
"\xF0\x8F\xBF\xBF",
"\"\\u03FF\\uFFFF\"",
},
{
"\"\xF8\x87\xBF\xBF\xBF\"",
NULL,
"\"\\u81FF\\uFFFF\\uFFFF\"",
"\xF8\x87\xBF\xBF\xBF",
},
{
"\"\xFC\x83\xBF\xBF\xBF\xBF\"",
NULL,
"\"\\uC0FF\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x83\xBF\xBF\xBF\xBF",
},
{
"\"\xC0\x80\"",
NULL,
"\"\\u0000\"",
"\xC0\x80",
},
{
"\"\xE0\x80\x80\"",
"\xE0\x80\x80",
"\"\\u0000\"",
},
{
"\"\xF0\x80\x80\x80\"",
"\xF0\x80\x80\x80",
"\"\\u0000\\uFFFF\"",
},
{
"\"\xF8\x80\x80\x80\x80\"",
NULL,
"\"\\u8000\\uFFFF\\uFFFF\"",
"\xF8\x80\x80\x80\x80",
},
{
"\"\xFC\x80\x80\x80\x80\x80\"",
NULL,
"\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"",
"\xFC\x80\x80\x80\x80\x80",
},
{
"\"\xED\xA0\x80\"",
"\xED\xA0\x80",
"\"\\uD800\"",
},
{
"\"\xED\xAD\xBF\"",
"\xED\xAD\xBF",
"\"\\uDB7F\"",
},
{
"\"\xED\xAE\x80\"",
"\xED\xAE\x80",
"\"\\uDB80\"",
},
{
"\"\xED\xAF\xBF\"",
"\xED\xAF\xBF",
"\"\\uDBFF\"",
},
{
"\"\xED\xB0\x80\"",
"\xED\xB0\x80",
"\"\\uDC00\"",
},
{
"\"\xED\xBE\x80\"",
"\xED\xBE\x80",
"\"\\uDF80\"",
},
{
"\"\xED\xBF\xBF\"",
"\xED\xBF\xBF",
"\"\\uDFFF\"",
},
{
"\"\xED\xA0\x80\xED\xB0\x80\"",
"\xED\xA0\x80\xED\xB0\x80",
"\"\\uD800\\uDC00\"",
},
{
"\"\xED\xA0\x80\xED\xBF\xBF\"",
"\xED\xA0\x80\xED\xBF\xBF",
"\"\\uD800\\uDFFF\"",
},
{
"\"\xED\xAD\xBF\xED\xB0\x80\"",
"\xED\xAD\xBF\xED\xB0\x80",
"\"\\uDB7F\\uDC00\"",
},
{
"\"\xED\xAD\xBF\xED\xBF\xBF\"",
"\xED\xAD\xBF\xED\xBF\xBF",
"\"\\uDB7F\\uDFFF\"",
},
{
"\"\xED\xAE\x80\xED\xB0\x80\"",
"\xED\xAE\x80\xED\xB0\x80",
"\"\\uDB80\\uDC00\"",
},
{
"\"\xED\xAE\x80\xED\xBF\xBF\"",
"\xED\xAE\x80\xED\xBF\xBF",
"\"\\uDB80\\uDFFF\"",
},
{
"\"\xED\xAF\xBF\xED\xB0\x80\"",
"\xED\xAF\xBF\xED\xB0\x80",
"\"\\uDBFF\\uDC00\"",
},
{
"\"\xED\xAF\xBF\xED\xBF\xBF\"",
"\xED\xAF\xBF\xED\xBF\xBF",
"\"\\uDBFF\\uDFFF\"",
},
{
"\"\xEF\xBF\xBE\"",
"\xEF\xBF\xBE",
"\"\\uFFFE\"",
},
{
"\"\xEF\xBF\xBF\"",
"\xEF\xBF\xBF",
"\"\\uFFFF\"",
},
{}
};
int VAR_1;
QObject *obj;
QString *str;
const char *VAR_2, *VAR_3, *VAR_4, *VAR_5;
for (VAR_1 = 0; VAR_0[VAR_1].VAR_2; VAR_1++) {
VAR_2 = VAR_0[VAR_1].VAR_2;
VAR_3 = VAR_0[VAR_1].VAR_3;
VAR_4 = VAR_0[VAR_1].VAR_4 ?: VAR_0[VAR_1].VAR_3;
VAR_5 = VAR_0[VAR_1].VAR_5 ?: VAR_0[VAR_1].VAR_2;
obj = qobject_from_json(VAR_2);
if (VAR_3) {
g_assert(obj);
g_assert(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
g_assert_cmpstr(qstring_get_str(str), ==, VAR_3);
} else {
g_assert(!obj);
}
qobject_decref(obj);
obj = QOBJECT(qstring_from_str(VAR_4));
str = qobject_to_json(obj);
if (VAR_5) {
g_assert(str);
g_assert_cmpstr(qstring_get_str(str), ==, VAR_5);
} else {
g_assert(!str);
}
QDECREF(str);
qobject_decref(obj);
if (0 && VAR_5 != VAR_2) {
obj = qobject_from_json(VAR_5);
g_assert(obj);
g_assert(qobject_type(obj) == QTYPE_QSTRING);
str = qobject_to_qstring(obj);
g_assert_cmpstr(qstring_get_str(str), ==, VAR_3);
}
}
}
| [
"static void FUNC_0(void)\n{",
"static const struct {",
"const char *VAR_2;",
"const char *VAR_3;",
"const char *VAR_5;",
"const char *VAR_4;",
"} VAR_0[] = {",
"{",
"\"\\\"Falsches \\xC3\\x9C\" \"ben von Xylophonmusik qu\\xC3\\xA4lt\"\n\" jeden gr\\xC3\\xB6\\xC3\\x9F\" \"eren Zwerg.\\\"\",\n\"Falsc... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
111
],
[
115,
117,
119,
121,
123,
125,
127
],
[
129
],
[
133,
135,
137,
139
],
[
147
],
[
149,
151,
153,
... |
14,081 | static void virtio_net_cleanup(NetClientState *nc)
{
VirtIONet *n = qemu_get_nic_opaque(nc);
n->nic = NULL;
}
| false | qemu | 57407ea44cc0a3d630b9b89a2be011f1955ce5c1 | static void virtio_net_cleanup(NetClientState *nc)
{
VirtIONet *n = qemu_get_nic_opaque(nc);
n->nic = NULL;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(NetClientState *VAR_0)
{
VirtIONet *n = qemu_get_nic_opaque(VAR_0);
n->nic = NULL;
}
| [
"static void FUNC_0(NetClientState *VAR_0)\n{",
"VirtIONet *n = qemu_get_nic_opaque(VAR_0);",
"n->nic = NULL;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
]
] |
14,082 | static uint64_t exynos4210_uart_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
Exynos4210UartState *s = (Exynos4210UartState *)opaque;
uint32_t res;
switch (offset) {
case UERSTAT: /* Read Only */
res = s->reg[I_(UERSTAT)];
s->reg[I_(UERSTAT)] = 0;
return res;
case UFSTAT: /* Read Only */
s->reg[I_(UFSTAT)] = fifo_elements_number(&s->rx) & 0xff;
if (fifo_empty_elements_number(&s->rx) == 0) {
s->reg[I_(UFSTAT)] |= UFSTAT_Rx_FIFO_FULL;
s->reg[I_(UFSTAT)] &= ~0xff;
}
return s->reg[I_(UFSTAT)];
case URXH:
if (s->reg[I_(UFCON)] & UFCON_FIFO_ENABLE) {
if (fifo_elements_number(&s->rx)) {
res = fifo_retrieve(&s->rx);
#if DEBUG_Rx_DATA
fprintf(stderr, "%c", res);
#endif
if (!fifo_elements_number(&s->rx)) {
s->reg[I_(UTRSTAT)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY;
} else {
s->reg[I_(UTRSTAT)] |= UTRSTAT_Rx_BUFFER_DATA_READY;
}
} else {
s->reg[I_(UINTSP)] |= UINTSP_ERROR;
exynos4210_uart_update_irq(s);
res = 0;
}
} else {
s->reg[I_(UTRSTAT)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY;
res = s->reg[I_(URXH)];
}
return res;
case UTXH:
PRINT_DEBUG("UART%d: Trying to read from WO register: %s [%04x]\n",
s->channel, exynos4210_uart_regname(offset), offset);
break;
default:
return s->reg[I_(offset)];
}
return 0;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static uint64_t exynos4210_uart_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
Exynos4210UartState *s = (Exynos4210UartState *)opaque;
uint32_t res;
switch (offset) {
case UERSTAT:
res = s->reg[I_(UERSTAT)];
s->reg[I_(UERSTAT)] = 0;
return res;
case UFSTAT:
s->reg[I_(UFSTAT)] = fifo_elements_number(&s->rx) & 0xff;
if (fifo_empty_elements_number(&s->rx) == 0) {
s->reg[I_(UFSTAT)] |= UFSTAT_Rx_FIFO_FULL;
s->reg[I_(UFSTAT)] &= ~0xff;
}
return s->reg[I_(UFSTAT)];
case URXH:
if (s->reg[I_(UFCON)] & UFCON_FIFO_ENABLE) {
if (fifo_elements_number(&s->rx)) {
res = fifo_retrieve(&s->rx);
#if DEBUG_Rx_DATA
fprintf(stderr, "%c", res);
#endif
if (!fifo_elements_number(&s->rx)) {
s->reg[I_(UTRSTAT)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY;
} else {
s->reg[I_(UTRSTAT)] |= UTRSTAT_Rx_BUFFER_DATA_READY;
}
} else {
s->reg[I_(UINTSP)] |= UINTSP_ERROR;
exynos4210_uart_update_irq(s);
res = 0;
}
} else {
s->reg[I_(UTRSTAT)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY;
res = s->reg[I_(URXH)];
}
return res;
case UTXH:
PRINT_DEBUG("UART%d: Trying to read from WO register: %s [%04x]\n",
s->channel, exynos4210_uart_regname(offset), offset);
break;
default:
return s->reg[I_(offset)];
}
return 0;
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(void *opaque, target_phys_addr_t offset,
unsigned size)
{
Exynos4210UartState *s = (Exynos4210UartState *)opaque;
uint32_t res;
switch (offset) {
case UERSTAT:
res = s->reg[I_(UERSTAT)];
s->reg[I_(UERSTAT)] = 0;
return res;
case UFSTAT:
s->reg[I_(UFSTAT)] = fifo_elements_number(&s->rx) & 0xff;
if (fifo_empty_elements_number(&s->rx) == 0) {
s->reg[I_(UFSTAT)] |= UFSTAT_Rx_FIFO_FULL;
s->reg[I_(UFSTAT)] &= ~0xff;
}
return s->reg[I_(UFSTAT)];
case URXH:
if (s->reg[I_(UFCON)] & UFCON_FIFO_ENABLE) {
if (fifo_elements_number(&s->rx)) {
res = fifo_retrieve(&s->rx);
#if DEBUG_Rx_DATA
fprintf(stderr, "%c", res);
#endif
if (!fifo_elements_number(&s->rx)) {
s->reg[I_(UTRSTAT)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY;
} else {
s->reg[I_(UTRSTAT)] |= UTRSTAT_Rx_BUFFER_DATA_READY;
}
} else {
s->reg[I_(UINTSP)] |= UINTSP_ERROR;
exynos4210_uart_update_irq(s);
res = 0;
}
} else {
s->reg[I_(UTRSTAT)] &= ~UTRSTAT_Rx_BUFFER_DATA_READY;
res = s->reg[I_(URXH)];
}
return res;
case UTXH:
PRINT_DEBUG("UART%d: Trying to read from WO register: %s [%04x]\n",
s->channel, exynos4210_uart_regname(offset), offset);
break;
default:
return s->reg[I_(offset)];
}
return 0;
}
| [
"static uint64_t FUNC_0(void *opaque, target_phys_addr_t offset,\nunsigned size)\n{",
"Exynos4210UartState *s = (Exynos4210UartState *)opaque;",
"uint32_t res;",
"switch (offset) {",
"case UERSTAT:\nres = s->reg[I_(UERSTAT)];",
"s->reg[I_(UERSTAT)] = 0;",
"return res;",
"case UFSTAT:\ns->reg[I_(UFSTAT... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[... |
14,083 | void i2c_end_transfer(I2CBus *bus)
{
I2CSlaveClass *sc;
I2CNode *node, *next;
if (QLIST_EMPTY(&bus->current_devs)) {
return;
}
QLIST_FOREACH_SAFE(node, &bus->current_devs, next, next) {
sc = I2C_SLAVE_GET_CLASS(node->elt);
if (sc->event) {
sc->event(node->elt, I2C_FINISH);
}
QLIST_REMOVE(node, next);
g_free(node);
}
bus->broadcast = false;
}
| false | qemu | 0fa758c3a069bc59a0d903d69028971c46d1a119 | void i2c_end_transfer(I2CBus *bus)
{
I2CSlaveClass *sc;
I2CNode *node, *next;
if (QLIST_EMPTY(&bus->current_devs)) {
return;
}
QLIST_FOREACH_SAFE(node, &bus->current_devs, next, next) {
sc = I2C_SLAVE_GET_CLASS(node->elt);
if (sc->event) {
sc->event(node->elt, I2C_FINISH);
}
QLIST_REMOVE(node, next);
g_free(node);
}
bus->broadcast = false;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(I2CBus *VAR_0)
{
I2CSlaveClass *sc;
I2CNode *node, *next;
if (QLIST_EMPTY(&VAR_0->current_devs)) {
return;
}
QLIST_FOREACH_SAFE(node, &VAR_0->current_devs, next, next) {
sc = I2C_SLAVE_GET_CLASS(node->elt);
if (sc->event) {
sc->event(node->elt, I2C_FINISH);
}
QLIST_REMOVE(node, next);
g_free(node);
}
VAR_0->broadcast = false;
}
| [
"void FUNC_0(I2CBus *VAR_0)\n{",
"I2CSlaveClass *sc;",
"I2CNode *node, *next;",
"if (QLIST_EMPTY(&VAR_0->current_devs)) {",
"return;",
"}",
"QLIST_FOREACH_SAFE(node, &VAR_0->current_devs, next, next) {",
"sc = I2C_SLAVE_GET_CLASS(node->elt);",
"if (sc->event) {",
"sc->event(node->elt, I2C_FINISH);... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
]
] |
14,084 | static av_cold int encode_end(AVCodecContext *avctx)
{
LclEncContext *c = avctx->priv_data;
av_freep(&avctx->extradata);
deflateEnd(&c->zstream);
av_frame_free(&avctx->coded_frame);
return 0;
}
| false | FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 | static av_cold int encode_end(AVCodecContext *avctx)
{
LclEncContext *c = avctx->priv_data;
av_freep(&avctx->extradata);
deflateEnd(&c->zstream);
av_frame_free(&avctx->coded_frame);
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
LclEncContext *c = avctx->priv_data;
av_freep(&avctx->extradata);
deflateEnd(&c->zstream);
av_frame_free(&avctx->coded_frame);
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"LclEncContext *c = avctx->priv_data;",
"av_freep(&avctx->extradata);",
"deflateEnd(&c->zstream);",
"av_frame_free(&avctx->coded_frame);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
]
] |
14,085 | static void sysbus_mmio_map_common(SysBusDevice *dev, int n, hwaddr addr,
bool may_overlap, unsigned priority)
{
assert(n >= 0 && n < dev->num_mmio);
if (dev->mmio[n].addr == addr) {
/* ??? region already mapped here. */
return;
}
if (dev->mmio[n].addr != (hwaddr)-1) {
/* Unregister previous mapping. */
memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory);
}
dev->mmio[n].addr = addr;
if (may_overlap) {
memory_region_add_subregion_overlap(get_system_memory(),
addr,
dev->mmio[n].memory,
priority);
}
else {
memory_region_add_subregion(get_system_memory(),
addr,
dev->mmio[n].memory);
}
}
| false | qemu | a1ff8ae0666ffcbe78ae7e28812dd30db6bb7131 | static void sysbus_mmio_map_common(SysBusDevice *dev, int n, hwaddr addr,
bool may_overlap, unsigned priority)
{
assert(n >= 0 && n < dev->num_mmio);
if (dev->mmio[n].addr == addr) {
return;
}
if (dev->mmio[n].addr != (hwaddr)-1) {
memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory);
}
dev->mmio[n].addr = addr;
if (may_overlap) {
memory_region_add_subregion_overlap(get_system_memory(),
addr,
dev->mmio[n].memory,
priority);
}
else {
memory_region_add_subregion(get_system_memory(),
addr,
dev->mmio[n].memory);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(SysBusDevice *VAR_0, int VAR_1, hwaddr VAR_2,
bool VAR_3, unsigned VAR_4)
{
assert(VAR_1 >= 0 && VAR_1 < VAR_0->num_mmio);
if (VAR_0->mmio[VAR_1].VAR_2 == VAR_2) {
return;
}
if (VAR_0->mmio[VAR_1].VAR_2 != (hwaddr)-1) {
memory_region_del_subregion(get_system_memory(), VAR_0->mmio[VAR_1].memory);
}
VAR_0->mmio[VAR_1].VAR_2 = VAR_2;
if (VAR_3) {
memory_region_add_subregion_overlap(get_system_memory(),
VAR_2,
VAR_0->mmio[VAR_1].memory,
VAR_4);
}
else {
memory_region_add_subregion(get_system_memory(),
VAR_2,
VAR_0->mmio[VAR_1].memory);
}
}
| [
"static void FUNC_0(SysBusDevice *VAR_0, int VAR_1, hwaddr VAR_2,\nbool VAR_3, unsigned VAR_4)\n{",
"assert(VAR_1 >= 0 && VAR_1 < VAR_0->num_mmio);",
"if (VAR_0->mmio[VAR_1].VAR_2 == VAR_2) {",
"return;",
"}",
"if (VAR_0->mmio[VAR_1].VAR_2 != (hwaddr)-1) {",
"memory_region_del_subregion(get_system_memor... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31,
33,
35,
37
],
[
39
],
[
41
],
[
43,
45,
47
],
[
49
],
[
51
]
] |
14,086 | static void x86_cpuid_get_apic_id(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
X86CPU *cpu = X86_CPU(obj);
int64_t value = cpu->apic_id;
visit_type_int(v, name, &value, errp);
}
| false | qemu | 2da00e3176abac34ca7a6aab1f5bbb94a0d03fc5 | static void x86_cpuid_get_apic_id(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
X86CPU *cpu = X86_CPU(obj);
int64_t value = cpu->apic_id;
visit_type_int(v, name, &value, errp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Object *VAR_0, Visitor *VAR_1, const char *VAR_2,
void *VAR_3, Error **VAR_4)
{
X86CPU *cpu = X86_CPU(VAR_0);
int64_t value = cpu->apic_id;
visit_type_int(VAR_1, VAR_2, &value, VAR_4);
}
| [
"static void FUNC_0(Object *VAR_0, Visitor *VAR_1, const char *VAR_2,\nvoid *VAR_3, Error **VAR_4)\n{",
"X86CPU *cpu = X86_CPU(VAR_0);",
"int64_t value = cpu->apic_id;",
"visit_type_int(VAR_1, VAR_2, &value, VAR_4);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
]
] |
14,087 | static int local_lsetxattr(FsContext *ctx, const char *path, const char *name,
void *value, size_t size, int flags)
{
if ((ctx->fs_sm == SM_MAPPED) &&
(strncmp(name, "user.virtfs.", 12) == 0)) {
/*
* Don't allow fetch of user.virtfs namesapce
* in case of mapped security
*/
errno = EACCES;
return -1;
}
return lsetxattr(rpath(ctx, path), name, value, size, flags);
}
| false | qemu | fc22118d9bb56ec71655b936a29513c140e6c289 | static int local_lsetxattr(FsContext *ctx, const char *path, const char *name,
void *value, size_t size, int flags)
{
if ((ctx->fs_sm == SM_MAPPED) &&
(strncmp(name, "user.virtfs.", 12) == 0)) {
errno = EACCES;
return -1;
}
return lsetxattr(rpath(ctx, path), name, value, size, flags);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(FsContext *VAR_0, const char *VAR_1, const char *VAR_2,
void *VAR_3, size_t VAR_4, int VAR_5)
{
if ((VAR_0->fs_sm == SM_MAPPED) &&
(strncmp(VAR_2, "user.virtfs.", 12) == 0)) {
errno = EACCES;
return -1;
}
return lsetxattr(rpath(VAR_0, VAR_1), VAR_2, VAR_3, VAR_4, VAR_5);
}
| [
"static int FUNC_0(FsContext *VAR_0, const char *VAR_1, const char *VAR_2,\nvoid *VAR_3, size_t VAR_4, int VAR_5)\n{",
"if ((VAR_0->fs_sm == SM_MAPPED) &&\n(strncmp(VAR_2, \"user.virtfs.\", 12) == 0)) {",
"errno = EACCES;",
"return -1;",
"}",
"return lsetxattr(rpath(VAR_0, VAR_1), VAR_2, VAR_3, VAR_4, VAR... | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7,
9
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
]
] |
14,089 | int xen_be_bind_evtchn(struct XenDevice *xendev)
{
if (xendev->local_port != -1) {
return 0;
}
xendev->local_port = xc_evtchn_bind_interdomain
(xendev->evtchndev, xendev->dom, xendev->remote_port);
if (xendev->local_port == -1) {
xen_be_printf(xendev, 0, "xc_evtchn_bind_interdomain failed\n");
return -1;
}
xen_be_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
qemu_set_fd_handler(xc_evtchn_fd(xendev->evtchndev),
xen_be_evtchn_event, NULL, xendev);
return 0;
}
| false | qemu | a2db2a1edd06a50b8a862c654cf993368cf9f1d9 | int xen_be_bind_evtchn(struct XenDevice *xendev)
{
if (xendev->local_port != -1) {
return 0;
}
xendev->local_port = xc_evtchn_bind_interdomain
(xendev->evtchndev, xendev->dom, xendev->remote_port);
if (xendev->local_port == -1) {
xen_be_printf(xendev, 0, "xc_evtchn_bind_interdomain failed\n");
return -1;
}
xen_be_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
qemu_set_fd_handler(xc_evtchn_fd(xendev->evtchndev),
xen_be_evtchn_event, NULL, xendev);
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(struct XenDevice *VAR_0)
{
if (VAR_0->local_port != -1) {
return 0;
}
VAR_0->local_port = xc_evtchn_bind_interdomain
(VAR_0->evtchndev, VAR_0->dom, VAR_0->remote_port);
if (VAR_0->local_port == -1) {
xen_be_printf(VAR_0, 0, "xc_evtchn_bind_interdomain failed\n");
return -1;
}
xen_be_printf(VAR_0, 2, "bind evtchn port %d\n", VAR_0->local_port);
qemu_set_fd_handler(xc_evtchn_fd(VAR_0->evtchndev),
xen_be_evtchn_event, NULL, VAR_0);
return 0;
}
| [
"int FUNC_0(struct XenDevice *VAR_0)\n{",
"if (VAR_0->local_port != -1) {",
"return 0;",
"}",
"VAR_0->local_port = xc_evtchn_bind_interdomain\n(VAR_0->evtchndev, VAR_0->dom, VAR_0->remote_port);",
"if (VAR_0->local_port == -1) {",
"xen_be_printf(VAR_0, 0, \"xc_evtchn_bind_interdomain failed\\n\");",
"... | [
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
]
] |
14,091 | BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
QDict *options, int flags)
{
assert(bs != NULL);
BlockReopenQueueEntry *bs_entry;
BdrvChild *child;
QDict *old_options;
if (bs_queue == NULL) {
bs_queue = g_new0(BlockReopenQueue, 1);
QSIMPLEQ_INIT(bs_queue);
}
if (!options) {
options = qdict_new();
}
old_options = qdict_clone_shallow(bs->options);
qdict_join(options, old_options, false);
QDECREF(old_options);
/* bdrv_open() masks this flag out */
flags &= ~BDRV_O_PROTOCOL;
QLIST_FOREACH(child, &bs->children, next) {
int child_flags;
if (child->bs->inherits_from != bs) {
continue;
}
child_flags = child->role->inherit_flags(flags);
/* TODO Pass down child flags (backing.*, extents.*, ...) */
bdrv_reopen_queue(bs_queue, child->bs, NULL, child_flags);
}
bs_entry = g_new0(BlockReopenQueueEntry, 1);
QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
bs_entry->state.bs = bs;
bs_entry->state.options = options;
bs_entry->state.flags = flags;
return bs_queue;
}
| false | qemu | cddff5bae1c8e0e21a5e6da04eff1d0a4423e5f3 | BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
QDict *options, int flags)
{
assert(bs != NULL);
BlockReopenQueueEntry *bs_entry;
BdrvChild *child;
QDict *old_options;
if (bs_queue == NULL) {
bs_queue = g_new0(BlockReopenQueue, 1);
QSIMPLEQ_INIT(bs_queue);
}
if (!options) {
options = qdict_new();
}
old_options = qdict_clone_shallow(bs->options);
qdict_join(options, old_options, false);
QDECREF(old_options);
flags &= ~BDRV_O_PROTOCOL;
QLIST_FOREACH(child, &bs->children, next) {
int child_flags;
if (child->bs->inherits_from != bs) {
continue;
}
child_flags = child->role->inherit_flags(flags);
bdrv_reopen_queue(bs_queue, child->bs, NULL, child_flags);
}
bs_entry = g_new0(BlockReopenQueueEntry, 1);
QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
bs_entry->state.bs = bs;
bs_entry->state.options = options;
bs_entry->state.flags = flags;
return bs_queue;
}
| {
"code": [],
"line_no": []
} | BlockReopenQueue *FUNC_0(BlockReopenQueue *bs_queue,
BlockDriverState *bs,
QDict *options, int flags)
{
assert(bs != NULL);
BlockReopenQueueEntry *bs_entry;
BdrvChild *child;
QDict *old_options;
if (bs_queue == NULL) {
bs_queue = g_new0(BlockReopenQueue, 1);
QSIMPLEQ_INIT(bs_queue);
}
if (!options) {
options = qdict_new();
}
old_options = qdict_clone_shallow(bs->options);
qdict_join(options, old_options, false);
QDECREF(old_options);
flags &= ~BDRV_O_PROTOCOL;
QLIST_FOREACH(child, &bs->children, next) {
int child_flags;
if (child->bs->inherits_from != bs) {
continue;
}
child_flags = child->role->inherit_flags(flags);
FUNC_0(bs_queue, child->bs, NULL, child_flags);
}
bs_entry = g_new0(BlockReopenQueueEntry, 1);
QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
bs_entry->state.bs = bs;
bs_entry->state.options = options;
bs_entry->state.flags = flags;
return bs_queue;
}
| [
"BlockReopenQueue *FUNC_0(BlockReopenQueue *bs_queue,\nBlockDriverState *bs,\nQDict *options, int flags)\n{",
"assert(bs != NULL);",
"BlockReopenQueueEntry *bs_entry;",
"BdrvChild *child;",
"QDict *old_options;",
"if (bs_queue == NULL) {",
"bs_queue = g_new0(BlockReopenQueue, 1);",
"QSIMPLEQ_INIT(bs_q... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
49
],
[
53
],
[
55
],
[
59
... |
14,092 | static ssize_t test_block_read_func(QCryptoBlock *block,
void *opaque,
size_t offset,
uint8_t *buf,
size_t buflen,
Error **errp)
{
Buffer *header = opaque;
g_assert_cmpint(offset + buflen, <=, header->capacity);
memcpy(buf, header->buffer + offset, buflen);
return buflen;
}
| false | qemu | e4a3507e86a1ef1453d603031bca27d5ac4cff3c | static ssize_t test_block_read_func(QCryptoBlock *block,
void *opaque,
size_t offset,
uint8_t *buf,
size_t buflen,
Error **errp)
{
Buffer *header = opaque;
g_assert_cmpint(offset + buflen, <=, header->capacity);
memcpy(buf, header->buffer + offset, buflen);
return buflen;
}
| {
"code": [],
"line_no": []
} | static ssize_t FUNC_0(QCryptoBlock *block,
void *opaque,
size_t offset,
uint8_t *buf,
size_t buflen,
Error **errp)
{
Buffer *header = opaque;
g_assert_cmpint(offset + buflen, <=, header->capacity);
memcpy(buf, header->buffer + offset, buflen);
return buflen;
}
| [
"static ssize_t FUNC_0(QCryptoBlock *block,\nvoid *opaque,\nsize_t offset,\nuint8_t *buf,\nsize_t buflen,\nError **errp)\n{",
"Buffer *header = opaque;",
"g_assert_cmpint(offset + buflen, <=, header->capacity);",
"memcpy(buf, header->buffer + offset, buflen);",
"return buflen;",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
19
],
[
23
],
[
27
],
[
29
]
] |
14,093 | static void pollfds_cleanup(Notifier *n, void *unused)
{
g_assert(npfd == 0);
g_free(pollfds);
g_free(nodes);
nalloc = 0;
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | static void pollfds_cleanup(Notifier *n, void *unused)
{
g_assert(npfd == 0);
g_free(pollfds);
g_free(nodes);
nalloc = 0;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Notifier *VAR_0, void *VAR_1)
{
g_assert(npfd == 0);
g_free(pollfds);
g_free(nodes);
nalloc = 0;
}
| [
"static void FUNC_0(Notifier *VAR_0, void *VAR_1)\n{",
"g_assert(npfd == 0);",
"g_free(pollfds);",
"g_free(nodes);",
"nalloc = 0;",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
14,094 | static void xen_domain_watcher(void)
{
int qemu_running = 1;
int fd[2], i, n, rc;
char byte;
pipe(fd);
if (fork() != 0)
return; /* not child */
/* close all file handles, except stdio/out/err,
* our watch pipe and the xen interface handle */
n = getdtablesize();
for (i = 3; i < n; i++) {
if (i == fd[0])
continue;
if (i == xen_xc)
continue;
close(i);
}
/* ignore term signals */
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
/* wait for qemu exiting */
while (qemu_running) {
rc = read(fd[0], &byte, 1);
switch (rc) {
case -1:
if (errno == EINTR)
continue;
qemu_log("%s: Huh? read error: %s\n", __FUNCTION__, strerror(errno));
qemu_running = 0;
break;
case 0:
/* EOF -> qemu exited */
qemu_running = 0;
break;
default:
qemu_log("%s: Huh? data on the watch pipe?\n", __FUNCTION__);
break;
}
}
/* cleanup */
qemu_log("%s: destroy domain %d\n", __FUNCTION__, xen_domid);
xc_domain_destroy(xen_xc, xen_domid);
_exit(0);
}
| false | qemu | acdc3f0c59d076099c63425158c4811aaee984b6 | static void xen_domain_watcher(void)
{
int qemu_running = 1;
int fd[2], i, n, rc;
char byte;
pipe(fd);
if (fork() != 0)
return;
n = getdtablesize();
for (i = 3; i < n; i++) {
if (i == fd[0])
continue;
if (i == xen_xc)
continue;
close(i);
}
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
while (qemu_running) {
rc = read(fd[0], &byte, 1);
switch (rc) {
case -1:
if (errno == EINTR)
continue;
qemu_log("%s: Huh? read error: %s\n", __FUNCTION__, strerror(errno));
qemu_running = 0;
break;
case 0:
qemu_running = 0;
break;
default:
qemu_log("%s: Huh? data on the watch pipe?\n", __FUNCTION__);
break;
}
}
qemu_log("%s: destroy domain %d\n", __FUNCTION__, xen_domid);
xc_domain_destroy(xen_xc, xen_domid);
_exit(0);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
int VAR_0 = 1;
int VAR_1[2], VAR_2, VAR_3, VAR_4;
char VAR_5;
pipe(VAR_1);
if (fork() != 0)
return;
VAR_3 = getdtablesize();
for (VAR_2 = 3; VAR_2 < VAR_3; VAR_2++) {
if (VAR_2 == VAR_1[0])
continue;
if (VAR_2 == xen_xc)
continue;
close(VAR_2);
}
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
while (VAR_0) {
VAR_4 = read(VAR_1[0], &VAR_5, 1);
switch (VAR_4) {
case -1:
if (errno == EINTR)
continue;
qemu_log("%s: Huh? read error: %s\VAR_3", __FUNCTION__, strerror(errno));
VAR_0 = 0;
break;
case 0:
VAR_0 = 0;
break;
default:
qemu_log("%s: Huh? data on the watch pipe?\VAR_3", __FUNCTION__);
break;
}
}
qemu_log("%s: destroy domain %d\VAR_3", __FUNCTION__, xen_domid);
xc_domain_destroy(xen_xc, xen_domid);
_exit(0);
}
| [
"static void FUNC_0(void)\n{",
"int VAR_0 = 1;",
"int VAR_1[2], VAR_2, VAR_3, VAR_4;",
"char VAR_5;",
"pipe(VAR_1);",
"if (fork() != 0)\nreturn;",
"VAR_3 = getdtablesize();",
"for (VAR_2 = 3; VAR_2 < VAR_3; VAR_2++) {",
"if (VAR_2 == VAR_1[0])\ncontinue;",
"if (VAR_2 == xen_xc)\ncontinue;",
"clo... | [
0,
0,
0,
0,
0,
0,
0,
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
],
[
25
],
[
27
],
[
29,
31
],
[
33,
35
],
[
37
],
[
39
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59,
61,... |
14,095 | static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){
MpegEncContext * const s = &h->s;
AVCodecContext * const avctx= s->avctx;
int buf_index=0;
#if 0
int i;
for(i=0; i<32; i++){
printf("%X ", buf[i]);
}
#endif
for(;;){
int consumed;
int dst_length;
int bit_length;
uint8_t *ptr;
// start code prefix search
for(; buf_index + 3 < buf_size; buf_index++){
// this should allways succeed in the first iteration
if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
break;
}
if(buf_index+3 >= buf_size) break;
buf_index+=3;
ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, buf_size - buf_index);
if(ptr[dst_length - 1] == 0) dst_length--;
bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
if(s->avctx->debug&FF_DEBUG_STARTCODE){
av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d length %d\n", h->nal_unit_type, buf_index, dst_length);
}
buf_index += consumed;
if(h->nal_ref_idc < s->hurry_up)
continue;
switch(h->nal_unit_type){
case NAL_IDR_SLICE:
idr(h); //FIXME ensure we dont loose some frames if there is reordering
case NAL_SLICE:
init_get_bits(&s->gb, ptr, bit_length);
h->intra_gb_ptr=
h->inter_gb_ptr= &s->gb;
s->data_partitioning = 0;
if(decode_slice_header(h) < 0) return -1;
if(h->redundant_pic_count==0)
decode_slice(h);
break;
case NAL_DPA:
init_get_bits(&s->gb, ptr, bit_length);
h->intra_gb_ptr=
h->inter_gb_ptr= NULL;
s->data_partitioning = 1;
if(decode_slice_header(h) < 0) return -1;
break;
case NAL_DPB:
init_get_bits(&h->intra_gb, ptr, bit_length);
h->intra_gb_ptr= &h->intra_gb;
break;
case NAL_DPC:
init_get_bits(&h->inter_gb, ptr, bit_length);
h->inter_gb_ptr= &h->inter_gb;
if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning)
decode_slice(h);
break;
case NAL_SEI:
break;
case NAL_SPS:
init_get_bits(&s->gb, ptr, bit_length);
decode_seq_parameter_set(h);
if(s->flags& CODEC_FLAG_LOW_DELAY)
s->low_delay=1;
avctx->has_b_frames= !s->low_delay;
break;
case NAL_PPS:
init_get_bits(&s->gb, ptr, bit_length);
decode_picture_parameter_set(h);
break;
case NAL_PICTURE_DELIMITER:
break;
case NAL_FILTER_DATA:
break;
}
//FIXME move after where irt is set
s->current_picture.pict_type= s->pict_type;
s->current_picture.key_frame= s->pict_type == I_TYPE;
}
if(!s->current_picture_ptr) return buf_index; //no frame
h->prev_frame_num_offset= h->frame_num_offset;
h->prev_frame_num= h->frame_num;
if(s->current_picture_ptr->reference){
h->prev_poc_msb= h->poc_msb;
h->prev_poc_lsb= h->poc_lsb;
}
if(s->current_picture_ptr->reference)
execute_ref_pic_marking(h, h->mmco, h->mmco_index);
else
assert(h->mmco_index==0);
ff_er_frame_end(s);
if( h->disable_deblocking_filter_idc != 1 ) {
filter_frame( h );
}
MPV_frame_end(s);
return buf_index;
}
| false | FFmpeg | 53c05b1eacd5f7dbfa3651b45e797adaea0a5ff8 | static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){
MpegEncContext * const s = &h->s;
AVCodecContext * const avctx= s->avctx;
int buf_index=0;
#if 0
int i;
for(i=0; i<32; i++){
printf("%X ", buf[i]);
}
#endif
for(;;){
int consumed;
int dst_length;
int bit_length;
uint8_t *ptr;
for(; buf_index + 3 < buf_size; buf_index++){
if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
break;
}
if(buf_index+3 >= buf_size) break;
buf_index+=3;
ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, buf_size - buf_index);
if(ptr[dst_length - 1] == 0) dst_length--;
bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
if(s->avctx->debug&FF_DEBUG_STARTCODE){
av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d length %d\n", h->nal_unit_type, buf_index, dst_length);
}
buf_index += consumed;
if(h->nal_ref_idc < s->hurry_up)
continue;
switch(h->nal_unit_type){
case NAL_IDR_SLICE:
idr(h);
case NAL_SLICE:
init_get_bits(&s->gb, ptr, bit_length);
h->intra_gb_ptr=
h->inter_gb_ptr= &s->gb;
s->data_partitioning = 0;
if(decode_slice_header(h) < 0) return -1;
if(h->redundant_pic_count==0)
decode_slice(h);
break;
case NAL_DPA:
init_get_bits(&s->gb, ptr, bit_length);
h->intra_gb_ptr=
h->inter_gb_ptr= NULL;
s->data_partitioning = 1;
if(decode_slice_header(h) < 0) return -1;
break;
case NAL_DPB:
init_get_bits(&h->intra_gb, ptr, bit_length);
h->intra_gb_ptr= &h->intra_gb;
break;
case NAL_DPC:
init_get_bits(&h->inter_gb, ptr, bit_length);
h->inter_gb_ptr= &h->inter_gb;
if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning)
decode_slice(h);
break;
case NAL_SEI:
break;
case NAL_SPS:
init_get_bits(&s->gb, ptr, bit_length);
decode_seq_parameter_set(h);
if(s->flags& CODEC_FLAG_LOW_DELAY)
s->low_delay=1;
avctx->has_b_frames= !s->low_delay;
break;
case NAL_PPS:
init_get_bits(&s->gb, ptr, bit_length);
decode_picture_parameter_set(h);
break;
case NAL_PICTURE_DELIMITER:
break;
case NAL_FILTER_DATA:
break;
}
s->current_picture.pict_type= s->pict_type;
s->current_picture.key_frame= s->pict_type == I_TYPE;
}
if(!s->current_picture_ptr) return buf_index;
h->prev_frame_num_offset= h->frame_num_offset;
h->prev_frame_num= h->frame_num;
if(s->current_picture_ptr->reference){
h->prev_poc_msb= h->poc_msb;
h->prev_poc_lsb= h->poc_lsb;
}
if(s->current_picture_ptr->reference)
execute_ref_pic_marking(h, h->mmco, h->mmco_index);
else
assert(h->mmco_index==0);
ff_er_frame_end(s);
if( h->disable_deblocking_filter_idc != 1 ) {
filter_frame( h );
}
MPV_frame_end(s);
return buf_index;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(H264Context *VAR_0, uint8_t *VAR_1, int VAR_2){
MpegEncContext * const s = &VAR_0->s;
AVCodecContext * const avctx= s->avctx;
int VAR_3=0;
#if 0
int i;
for(i=0; i<32; i++){
printf("%X ", VAR_1[i]);
}
#endif
for(;;){
int VAR_4;
int VAR_5;
int VAR_6;
uint8_t *ptr;
for(; VAR_3 + 3 < VAR_2; VAR_3++){
if(VAR_1[VAR_3] == 0 && VAR_1[VAR_3+1] == 0 && VAR_1[VAR_3+2] == 1)
break;
}
if(VAR_3+3 >= VAR_2) break;
VAR_3+=3;
ptr= decode_nal(VAR_0, VAR_1 + VAR_3, &VAR_5, &VAR_4, VAR_2 - VAR_3);
if(ptr[VAR_5 - 1] == 0) VAR_5--;
VAR_6= 8*VAR_5 - decode_rbsp_trailing(ptr + VAR_5 - 1);
if(s->avctx->debug&FF_DEBUG_STARTCODE){
av_log(VAR_0->s.avctx, AV_LOG_DEBUG, "NAL %d at %d length %d\n", VAR_0->nal_unit_type, VAR_3, VAR_5);
}
VAR_3 += VAR_4;
if(VAR_0->nal_ref_idc < s->hurry_up)
continue;
switch(VAR_0->nal_unit_type){
case NAL_IDR_SLICE:
idr(VAR_0);
case NAL_SLICE:
init_get_bits(&s->gb, ptr, VAR_6);
VAR_0->intra_gb_ptr=
VAR_0->inter_gb_ptr= &s->gb;
s->data_partitioning = 0;
if(decode_slice_header(VAR_0) < 0) return -1;
if(VAR_0->redundant_pic_count==0)
decode_slice(VAR_0);
break;
case NAL_DPA:
init_get_bits(&s->gb, ptr, VAR_6);
VAR_0->intra_gb_ptr=
VAR_0->inter_gb_ptr= NULL;
s->data_partitioning = 1;
if(decode_slice_header(VAR_0) < 0) return -1;
break;
case NAL_DPB:
init_get_bits(&VAR_0->intra_gb, ptr, VAR_6);
VAR_0->intra_gb_ptr= &VAR_0->intra_gb;
break;
case NAL_DPC:
init_get_bits(&VAR_0->inter_gb, ptr, VAR_6);
VAR_0->inter_gb_ptr= &VAR_0->inter_gb;
if(VAR_0->redundant_pic_count==0 && VAR_0->intra_gb_ptr && s->data_partitioning)
decode_slice(VAR_0);
break;
case NAL_SEI:
break;
case NAL_SPS:
init_get_bits(&s->gb, ptr, VAR_6);
decode_seq_parameter_set(VAR_0);
if(s->flags& CODEC_FLAG_LOW_DELAY)
s->low_delay=1;
avctx->has_b_frames= !s->low_delay;
break;
case NAL_PPS:
init_get_bits(&s->gb, ptr, VAR_6);
decode_picture_parameter_set(VAR_0);
break;
case NAL_PICTURE_DELIMITER:
break;
case NAL_FILTER_DATA:
break;
}
s->current_picture.pict_type= s->pict_type;
s->current_picture.key_frame= s->pict_type == I_TYPE;
}
if(!s->current_picture_ptr) return VAR_3;
VAR_0->prev_frame_num_offset= VAR_0->frame_num_offset;
VAR_0->prev_frame_num= VAR_0->frame_num;
if(s->current_picture_ptr->reference){
VAR_0->prev_poc_msb= VAR_0->poc_msb;
VAR_0->prev_poc_lsb= VAR_0->poc_lsb;
}
if(s->current_picture_ptr->reference)
execute_ref_pic_marking(VAR_0, VAR_0->mmco, VAR_0->mmco_index);
else
assert(VAR_0->mmco_index==0);
ff_er_frame_end(s);
if( VAR_0->disable_deblocking_filter_idc != 1 ) {
filter_frame( VAR_0 );
}
MPV_frame_end(s);
return VAR_3;
}
| [
"static int FUNC_0(H264Context *VAR_0, uint8_t *VAR_1, int VAR_2){",
"MpegEncContext * const s = &VAR_0->s;",
"AVCodecContext * const avctx= s->avctx;",
"int VAR_3=0;",
"#if 0\nint i;",
"for(i=0; i<32; i++){",
"printf(\"%X \", VAR_1[i]);",
"}",
"#endif\nfor(;;){",
"int VAR_4;",
"int VAR_5;",
"... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
35
],
[
39,
41
],
[
43
],
[
47
],
[
51
],
[
55
... |
14,096 | static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe, unsigned char *buf, int buf_size)
{
int num_strips, strip, i, y, nexty, size, temp_size, best_size;
AVPicture last_pict, pict, scratch_pict;
int64_t best_score = 0, score, score_temp;
#ifdef CINEPAK_REPORT_SERR
int64_t best_serr = 0, serr, serr_temp;
#endif
int best_nstrips;
if(s->pix_fmt == AV_PIX_FMT_RGB24) {
int x;
// build a copy of the given frame in the correct colorspace
for(y = 0; y < s->h; y += 2) {
for(x = 0; x < s->w; x += 2) {
uint8_t *ir[2]; int32_t r, g, b, rr, gg, bb;
ir[0] = ((AVPicture*)frame)->data[0] + x*3 + y*((AVPicture*)frame)->linesize[0];
ir[1] = ir[0] + ((AVPicture*)frame)->linesize[0];
get_sub_picture(s, x, y, (AVPicture*)s->input_frame, &scratch_pict);
r = g = b = 0;
for(i=0; i<4; ++i) {
int i1, i2;
i1 = (i&1); i2 = (i>=2);
rr = ir[i2][i1*3+0];
gg = ir[i2][i1*3+1];
bb = ir[i2][i1*3+2];
r += rr; g += gg; b += bb;
// using fixed point arithmetic for portable repeatability, scaling by 2^23
// "Y"
// rr = 0.2857*rr + 0.5714*gg + 0.1429*bb;
rr = (2396625*rr + 4793251*gg + 1198732*bb) >> 23;
if( rr < 0) rr = 0;
else if (rr > 255) rr = 255;
scratch_pict.data[0][i1 + i2*scratch_pict.linesize[0]] = rr;
}
// let us scale down as late as possible
// r /= 4; g /= 4; b /= 4;
// "U"
// rr = -0.1429*r - 0.2857*g + 0.4286*b;
rr = (-299683*r - 599156*g + 898839*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[1][0] = rr + 128; // quantize needs unsigned
// "V"
// rr = 0.3571*r - 0.2857*g - 0.0714*b;
rr = (748893*r - 599156*g - 149737*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[2][0] = rr + 128; // quantize needs unsigned
}
}
}
//would be nice but quite certainly incompatible with vintage players:
// support encoding zero strips (meaning skip the whole frame)
for(num_strips = s->min_strips; num_strips <= s->max_strips && num_strips <= s->h / MB_SIZE; num_strips++) {
score = 0;
size = 0;
#ifdef CINEPAK_REPORT_SERR
serr = 0;
#endif
for(y = 0, strip = 1; y < s->h; strip++, y = nexty) {
int strip_height;
nexty = strip * s->h / num_strips; // <= s->h
//make nexty the next multiple of 4 if not already there
if(nexty & 3)
nexty += 4 - (nexty & 3);
strip_height = nexty - y;
if(strip_height <= 0) { // can this ever happen?
av_log(s->avctx, AV_LOG_INFO, "skipping zero height strip %i of %i\n", strip, num_strips);
continue;
}
if(s->pix_fmt == AV_PIX_FMT_RGB24)
get_sub_picture(s, 0, y, (AVPicture*)s->input_frame, &pict);
else
get_sub_picture(s, 0, y, (AVPicture*)frame, &pict);
get_sub_picture(s, 0, y, (AVPicture*)s->last_frame, &last_pict);
get_sub_picture(s, 0, y, (AVPicture*)s->scratch_frame, &scratch_pict);
if((temp_size = rd_strip(s, y, strip_height, isakeyframe, &last_pict, &pict, &scratch_pict, s->frame_buf + size + CVID_HEADER_SIZE, &score_temp
#ifdef CINEPAK_REPORT_SERR
, &serr_temp
#endif
)) < 0)
return temp_size;
score += score_temp;
#ifdef CINEPAK_REPORT_SERR
serr += serr_temp;
#endif
size += temp_size;
//av_log(s->avctx, AV_LOG_INFO, "strip %d, isakeyframe=%d", strip, isakeyframe);
//av_log(s->avctx, AV_LOG_INFO, "\n");
}
if(best_score == 0 || score < best_score) {
best_score = score;
#ifdef CINEPAK_REPORT_SERR
best_serr = serr;
#endif
best_size = size + write_cvid_header(s, s->frame_buf, num_strips, size, isakeyframe);
//av_log(s->avctx, AV_LOG_INFO, "best number of strips so far: %2i, %12lli, %i B\n", num_strips, (long long int)score, best_size);
#ifdef CINEPAK_REPORT_SERR
av_log(s->avctx, AV_LOG_INFO, "best number of strips so far: %2i, %12lli, %i B\n", num_strips, (long long int)serr, best_size);
#endif
FFSWAP(AVFrame *, s->best_frame, s->scratch_frame);
memcpy(buf, s->frame_buf, best_size);
best_nstrips = num_strips;
}
// avoid trying too many strip numbers without a real reason
// (this makes the processing of the very first frame faster)
if(num_strips - best_nstrips > 4)
break;
}
// let the number of strips slowly adapt to the changes in the contents,
// compared to full bruteforcing every time this will occasionally lead
// to some r/d performance loss but makes encoding up to several times faster
if(!s->strip_number_delta_range) {
if(best_nstrips == s->max_strips) { // let us try to step up
s->max_strips = best_nstrips + 1;
if(s->max_strips >= s->max_max_strips)
s->max_strips = s->max_max_strips;
} else { // try to step down
s->max_strips = best_nstrips;
}
s->min_strips = s->max_strips - 1;
if(s->min_strips < s->min_min_strips)
s->min_strips = s->min_min_strips;
} else {
s->max_strips = best_nstrips + s->strip_number_delta_range;
if(s->max_strips >= s->max_max_strips)
s->max_strips = s->max_max_strips;
s->min_strips = best_nstrips - s->strip_number_delta_range;
if(s->min_strips < s->min_min_strips)
s->min_strips = s->min_min_strips;
}
return best_size;
}
| true | FFmpeg | 364e8904ce915a3fbb1bb86c29e81e9475b37fb9 | static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe, unsigned char *buf, int buf_size)
{
int num_strips, strip, i, y, nexty, size, temp_size, best_size;
AVPicture last_pict, pict, scratch_pict;
int64_t best_score = 0, score, score_temp;
#ifdef CINEPAK_REPORT_SERR
int64_t best_serr = 0, serr, serr_temp;
#endif
int best_nstrips;
if(s->pix_fmt == AV_PIX_FMT_RGB24) {
int x;
for(y = 0; y < s->h; y += 2) {
for(x = 0; x < s->w; x += 2) {
uint8_t *ir[2]; int32_t r, g, b, rr, gg, bb;
ir[0] = ((AVPicture*)frame)->data[0] + x*3 + y*((AVPicture*)frame)->linesize[0];
ir[1] = ir[0] + ((AVPicture*)frame)->linesize[0];
get_sub_picture(s, x, y, (AVPicture*)s->input_frame, &scratch_pict);
r = g = b = 0;
for(i=0; i<4; ++i) {
int i1, i2;
i1 = (i&1); i2 = (i>=2);
rr = ir[i2][i1*3+0];
gg = ir[i2][i1*3+1];
bb = ir[i2][i1*3+2];
r += rr; g += gg; b += bb;
rr = (2396625*rr + 4793251*gg + 1198732*bb) >> 23;
if( rr < 0) rr = 0;
else if (rr > 255) rr = 255;
scratch_pict.data[0][i1 + i2*scratch_pict.linesize[0]] = rr;
}
rr = (-299683*r - 599156*g + 898839*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[1][0] = rr + 128;
rr = (748893*r - 599156*g - 149737*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[2][0] = rr + 128;
}
}
}
for(num_strips = s->min_strips; num_strips <= s->max_strips && num_strips <= s->h / MB_SIZE; num_strips++) {
score = 0;
size = 0;
#ifdef CINEPAK_REPORT_SERR
serr = 0;
#endif
for(y = 0, strip = 1; y < s->h; strip++, y = nexty) {
int strip_height;
nexty = strip * s->h / num_strips;
if(nexty & 3)
nexty += 4 - (nexty & 3);
strip_height = nexty - y;
if(strip_height <= 0) {
av_log(s->avctx, AV_LOG_INFO, "skipping zero height strip %i of %i\n", strip, num_strips);
continue;
}
if(s->pix_fmt == AV_PIX_FMT_RGB24)
get_sub_picture(s, 0, y, (AVPicture*)s->input_frame, &pict);
else
get_sub_picture(s, 0, y, (AVPicture*)frame, &pict);
get_sub_picture(s, 0, y, (AVPicture*)s->last_frame, &last_pict);
get_sub_picture(s, 0, y, (AVPicture*)s->scratch_frame, &scratch_pict);
if((temp_size = rd_strip(s, y, strip_height, isakeyframe, &last_pict, &pict, &scratch_pict, s->frame_buf + size + CVID_HEADER_SIZE, &score_temp
#ifdef CINEPAK_REPORT_SERR
, &serr_temp
#endif
)) < 0)
return temp_size;
score += score_temp;
#ifdef CINEPAK_REPORT_SERR
serr += serr_temp;
#endif
size += temp_size;
}
if(best_score == 0 || score < best_score) {
best_score = score;
#ifdef CINEPAK_REPORT_SERR
best_serr = serr;
#endif
best_size = size + write_cvid_header(s, s->frame_buf, num_strips, size, isakeyframe);
#ifdef CINEPAK_REPORT_SERR
av_log(s->avctx, AV_LOG_INFO, "best number of strips so far: %2i, %12lli, %i B\n", num_strips, (long long int)serr, best_size);
#endif
FFSWAP(AVFrame *, s->best_frame, s->scratch_frame);
memcpy(buf, s->frame_buf, best_size);
best_nstrips = num_strips;
}
if(num_strips - best_nstrips > 4)
break;
}
if(!s->strip_number_delta_range) {
if(best_nstrips == s->max_strips) {
s->max_strips = best_nstrips + 1;
if(s->max_strips >= s->max_max_strips)
s->max_strips = s->max_max_strips;
} else {
s->max_strips = best_nstrips;
}
s->min_strips = s->max_strips - 1;
if(s->min_strips < s->min_min_strips)
s->min_strips = s->min_min_strips;
} else {
s->max_strips = best_nstrips + s->strip_number_delta_range;
if(s->max_strips >= s->max_max_strips)
s->max_strips = s->max_max_strips;
s->min_strips = best_nstrips - s->strip_number_delta_range;
if(s->min_strips < s->min_min_strips)
s->min_strips = s->min_min_strips;
}
return best_size;
}
| {
"code": [
" int num_strips, strip, i, y, nexty, size, temp_size, best_size;",
" int best_nstrips;"
],
"line_no": [
5,
19
]
} | static int FUNC_0(CinepakEncContext *VAR_0, const AVFrame *VAR_1, int VAR_2, unsigned char *VAR_3, int VAR_4)
{
int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;
AVPicture last_pict, pict, scratch_pict;
int64_t best_score = 0, score, score_temp;
#ifdef CINEPAK_REPORT_SERR
int64_t best_serr = 0, serr, serr_temp;
#endif
int VAR_13;
if(VAR_0->pix_fmt == AV_PIX_FMT_RGB24) {
int VAR_14;
for(VAR_8 = 0; VAR_8 < VAR_0->h; VAR_8 += 2) {
for(VAR_14 = 0; VAR_14 < VAR_0->w; VAR_14 += 2) {
uint8_t *ir[2]; int32_t r, g, b, rr, gg, bb;
ir[0] = ((AVPicture*)VAR_1)->data[0] + VAR_14*3 + VAR_8*((AVPicture*)VAR_1)->linesize[0];
ir[1] = ir[0] + ((AVPicture*)VAR_1)->linesize[0];
get_sub_picture(VAR_0, VAR_14, VAR_8, (AVPicture*)VAR_0->input_frame, &scratch_pict);
r = g = b = 0;
for(VAR_7=0; VAR_7<4; ++VAR_7) {
int i1, i2;
i1 = (VAR_7&1); i2 = (VAR_7>=2);
rr = ir[i2][i1*3+0];
gg = ir[i2][i1*3+1];
bb = ir[i2][i1*3+2];
r += rr; g += gg; b += bb;
rr = (2396625*rr + 4793251*gg + 1198732*bb) >> 23;
if( rr < 0) rr = 0;
else if (rr > 255) rr = 255;
scratch_pict.data[0][i1 + i2*scratch_pict.linesize[0]] = rr;
}
rr = (-299683*r - 599156*g + 898839*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[1][0] = rr + 128;
rr = (748893*r - 599156*g - 149737*b) >> 23;
if( rr < -128) rr = -128;
else if (rr > 127) rr = 127;
scratch_pict.data[2][0] = rr + 128;
}
}
}
for(VAR_5 = VAR_0->min_strips; VAR_5 <= VAR_0->max_strips && VAR_5 <= VAR_0->h / MB_SIZE; VAR_5++) {
score = 0;
VAR_10 = 0;
#ifdef CINEPAK_REPORT_SERR
serr = 0;
#endif
for(VAR_8 = 0, VAR_6 = 1; VAR_8 < VAR_0->h; VAR_6++, VAR_8 = VAR_9) {
int strip_height;
VAR_9 = VAR_6 * VAR_0->h / VAR_5;
if(VAR_9 & 3)
VAR_9 += 4 - (VAR_9 & 3);
strip_height = VAR_9 - VAR_8;
if(strip_height <= 0) {
av_log(VAR_0->avctx, AV_LOG_INFO, "skipping zero height VAR_6 %VAR_7 of %VAR_7\n", VAR_6, VAR_5);
continue;
}
if(VAR_0->pix_fmt == AV_PIX_FMT_RGB24)
get_sub_picture(VAR_0, 0, VAR_8, (AVPicture*)VAR_0->input_frame, &pict);
else
get_sub_picture(VAR_0, 0, VAR_8, (AVPicture*)VAR_1, &pict);
get_sub_picture(VAR_0, 0, VAR_8, (AVPicture*)VAR_0->last_frame, &last_pict);
get_sub_picture(VAR_0, 0, VAR_8, (AVPicture*)VAR_0->scratch_frame, &scratch_pict);
if((VAR_11 = rd_strip(VAR_0, VAR_8, strip_height, VAR_2, &last_pict, &pict, &scratch_pict, VAR_0->frame_buf + VAR_10 + CVID_HEADER_SIZE, &score_temp
#ifdef CINEPAK_REPORT_SERR
, &serr_temp
#endif
)) < 0)
return VAR_11;
score += score_temp;
#ifdef CINEPAK_REPORT_SERR
serr += serr_temp;
#endif
VAR_10 += VAR_11;
}
if(best_score == 0 || score < best_score) {
best_score = score;
#ifdef CINEPAK_REPORT_SERR
best_serr = serr;
#endif
VAR_12 = VAR_10 + write_cvid_header(VAR_0, VAR_0->frame_buf, VAR_5, VAR_10, VAR_2);
#ifdef CINEPAK_REPORT_SERR
av_log(VAR_0->avctx, AV_LOG_INFO, "best number of strips so far: %2i, %12lli, %VAR_7 B\n", VAR_5, (long long int)serr, VAR_12);
#endif
FFSWAP(AVFrame *, VAR_0->best_frame, VAR_0->scratch_frame);
memcpy(VAR_3, VAR_0->frame_buf, VAR_12);
VAR_13 = VAR_5;
}
if(VAR_5 - VAR_13 > 4)
break;
}
if(!VAR_0->strip_number_delta_range) {
if(VAR_13 == VAR_0->max_strips) {
VAR_0->max_strips = VAR_13 + 1;
if(VAR_0->max_strips >= VAR_0->max_max_strips)
VAR_0->max_strips = VAR_0->max_max_strips;
} else {
VAR_0->max_strips = VAR_13;
}
VAR_0->min_strips = VAR_0->max_strips - 1;
if(VAR_0->min_strips < VAR_0->min_min_strips)
VAR_0->min_strips = VAR_0->min_min_strips;
} else {
VAR_0->max_strips = VAR_13 + VAR_0->strip_number_delta_range;
if(VAR_0->max_strips >= VAR_0->max_max_strips)
VAR_0->max_strips = VAR_0->max_max_strips;
VAR_0->min_strips = VAR_13 - VAR_0->strip_number_delta_range;
if(VAR_0->min_strips < VAR_0->min_min_strips)
VAR_0->min_strips = VAR_0->min_min_strips;
}
return VAR_12;
}
| [
"static int FUNC_0(CinepakEncContext *VAR_0, const AVFrame *VAR_1, int VAR_2, unsigned char *VAR_3, int VAR_4)\n{",
"int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;",
"AVPicture last_pict, pict, scratch_pict;",
"int64_t best_score = 0, score, score_temp;",
"#ifdef CINEPAK_REPORT_SERR\nint64_t... | [
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11,
13
],
[
15,
19
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
... |
14,097 | static int vty_getchars(VIOsPAPRDevice *sdev, uint8_t *buf, int max)
{
VIOsPAPRVTYDevice *dev = VIO_SPAPR_VTY_DEVICE(sdev);
int n = 0;
while ((n < max) && (dev->out != dev->in)) {
buf[n++] = dev->buf[dev->out++ % VTERM_BUFSIZE];
qemu_chr_fe_accept_input(&dev->chardev);
return n; | true | qemu | 6c3bc244d3cbdc5545504fda4fae0238ec36a3c0 | static int vty_getchars(VIOsPAPRDevice *sdev, uint8_t *buf, int max)
{
VIOsPAPRVTYDevice *dev = VIO_SPAPR_VTY_DEVICE(sdev);
int n = 0;
while ((n < max) && (dev->out != dev->in)) {
buf[n++] = dev->buf[dev->out++ % VTERM_BUFSIZE];
qemu_chr_fe_accept_input(&dev->chardev);
return n; | {
"code": [],
"line_no": []
} | static int FUNC_0(VIOsPAPRDevice *VAR_0, uint8_t *VAR_1, int VAR_2)
{
VIOsPAPRVTYDevice *dev = VIO_SPAPR_VTY_DEVICE(VAR_0);
int VAR_3 = 0;
while ((VAR_3 < VAR_2) && (dev->out != dev->in)) {
VAR_1[VAR_3++] = dev->VAR_1[dev->out++ % VTERM_BUFSIZE];
qemu_chr_fe_accept_input(&dev->chardev);
return VAR_3; | [
"static int FUNC_0(VIOsPAPRDevice *VAR_0, uint8_t *VAR_1, int VAR_2)\n{",
"VIOsPAPRVTYDevice *dev = VIO_SPAPR_VTY_DEVICE(VAR_0);",
"int VAR_3 = 0;",
"while ((VAR_3 < VAR_2) && (dev->out != dev->in)) {",
"VAR_1[VAR_3++] = dev->VAR_1[dev->out++ % VTERM_BUFSIZE];",
"qemu_chr_fe_accept_input(&dev->chardev);",... | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
]
] |
14,098 | int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route,
uint64_t address, uint32_t data, PCIDevice *dev)
{
S390PCIBusDevice *pbdev;
uint32_t fid = data >> ZPCI_MSI_VEC_BITS;
uint32_t vec = data & ZPCI_MSI_VEC_MASK;
pbdev = s390_pci_find_dev_by_fid(fid);
if (!pbdev) {
DPRINTF("add_msi_route no dev\n");
return -ENODEV;
}
pbdev->routes.adapter.ind_offset = vec;
route->type = KVM_IRQ_ROUTING_S390_ADAPTER;
route->flags = 0;
route->u.adapter.summary_addr = pbdev->routes.adapter.summary_addr;
route->u.adapter.ind_addr = pbdev->routes.adapter.ind_addr;
route->u.adapter.summary_offset = pbdev->routes.adapter.summary_offset;
route->u.adapter.ind_offset = pbdev->routes.adapter.ind_offset;
route->u.adapter.adapter_id = pbdev->routes.adapter.adapter_id;
return 0;
}
| true | qemu | cdd85eb2804018ab46a742ebf64dc5366b9fae73 | int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route,
uint64_t address, uint32_t data, PCIDevice *dev)
{
S390PCIBusDevice *pbdev;
uint32_t fid = data >> ZPCI_MSI_VEC_BITS;
uint32_t vec = data & ZPCI_MSI_VEC_MASK;
pbdev = s390_pci_find_dev_by_fid(fid);
if (!pbdev) {
DPRINTF("add_msi_route no dev\n");
return -ENODEV;
}
pbdev->routes.adapter.ind_offset = vec;
route->type = KVM_IRQ_ROUTING_S390_ADAPTER;
route->flags = 0;
route->u.adapter.summary_addr = pbdev->routes.adapter.summary_addr;
route->u.adapter.ind_addr = pbdev->routes.adapter.ind_addr;
route->u.adapter.summary_offset = pbdev->routes.adapter.summary_offset;
route->u.adapter.ind_offset = pbdev->routes.adapter.ind_offset;
route->u.adapter.adapter_id = pbdev->routes.adapter.adapter_id;
return 0;
}
| {
"code": [
" uint32_t fid = data >> ZPCI_MSI_VEC_BITS;",
" pbdev = s390_pci_find_dev_by_fid(fid);",
" uint32_t fid = data >> ZPCI_MSI_VEC_BITS;",
" pbdev = s390_pci_find_dev_by_fid(fid);"
],
"line_no": [
9,
15,
9,
15
]
} | int FUNC_0(struct kvm_irq_routing_entry *VAR_0,
uint64_t VAR_1, uint32_t VAR_2, PCIDevice *VAR_3)
{
S390PCIBusDevice *pbdev;
uint32_t fid = VAR_2 >> ZPCI_MSI_VEC_BITS;
uint32_t vec = VAR_2 & ZPCI_MSI_VEC_MASK;
pbdev = s390_pci_find_dev_by_fid(fid);
if (!pbdev) {
DPRINTF("add_msi_route no VAR_3\n");
return -ENODEV;
}
pbdev->routes.adapter.ind_offset = vec;
VAR_0->type = KVM_IRQ_ROUTING_S390_ADAPTER;
VAR_0->flags = 0;
VAR_0->u.adapter.summary_addr = pbdev->routes.adapter.summary_addr;
VAR_0->u.adapter.ind_addr = pbdev->routes.adapter.ind_addr;
VAR_0->u.adapter.summary_offset = pbdev->routes.adapter.summary_offset;
VAR_0->u.adapter.ind_offset = pbdev->routes.adapter.ind_offset;
VAR_0->u.adapter.adapter_id = pbdev->routes.adapter.adapter_id;
return 0;
}
| [
"int FUNC_0(struct kvm_irq_routing_entry *VAR_0,\nuint64_t VAR_1, uint32_t VAR_2, PCIDevice *VAR_3)\n{",
"S390PCIBusDevice *pbdev;",
"uint32_t fid = VAR_2 >> ZPCI_MSI_VEC_BITS;",
"uint32_t vec = VAR_2 & ZPCI_MSI_VEC_MASK;",
"pbdev = s390_pci_find_dev_by_fid(fid);",
"if (!pbdev) {",
"DPRINTF(\"add_msi_ro... | [
0,
0,
1,
0,
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
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
]
] |
14,100 | static void spapr_machine_device_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());
if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
uint32_t node;
if (!smc->dr_lmb_enabled) {
error_setg(errp, "Memory hotplug not supported for this machine");
return;
}
node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp);
if (*errp) {
return;
}
spapr_memory_plug(hotplug_dev, dev, node, errp);
}
}
| true | qemu | b556854bd8524c26b8be98ab1bfdf0826831e793 | static void spapr_machine_device_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());
if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
uint32_t node;
if (!smc->dr_lmb_enabled) {
error_setg(errp, "Memory hotplug not supported for this machine");
return;
}
node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp);
if (*errp) {
return;
}
spapr_memory_plug(hotplug_dev, dev, node, errp);
}
}
| {
"code": [
" uint32_t node;"
],
"line_no": [
13
]
} | static void FUNC_0(HotplugHandler *VAR_0,
DeviceState *VAR_1, Error **VAR_2)
{
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());
if (object_dynamic_cast(OBJECT(VAR_1), TYPE_PC_DIMM)) {
uint32_t node;
if (!smc->dr_lmb_enabled) {
error_setg(VAR_2, "Memory hotplug not supported for this machine");
return;
}
node = object_property_get_int(OBJECT(VAR_1), PC_DIMM_NODE_PROP, VAR_2);
if (*VAR_2) {
return;
}
spapr_memory_plug(VAR_0, VAR_1, node, VAR_2);
}
}
| [
"static void FUNC_0(HotplugHandler *VAR_0,\nDeviceState *VAR_1, Error **VAR_2)\n{",
"sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());",
"if (object_dynamic_cast(OBJECT(VAR_1), TYPE_PC_DIMM)) {",
"uint32_t node;",
"if (!smc->dr_lmb_enabled) {",
"error_setg(VAR_2, \"Memory hotplug not s... | [
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
]
] |
14,101 | void spapr_events_init(sPAPRMachineState *spapr)
{
QTAILQ_INIT(&spapr->pending_events);
spapr->check_exception_irq = xics_alloc(spapr->icp, 0, 0, false);
spapr->epow_notifier.notify = spapr_powerdown_req;
qemu_register_powerdown_notifier(&spapr->epow_notifier);
spapr_rtas_register(RTAS_CHECK_EXCEPTION, "check-exception",
check_exception);
spapr_rtas_register(RTAS_EVENT_SCAN, "event-scan", event_scan);
}
| true | qemu | a005b3ef50439b5bc6b2eb0b5bda8e8c7c2368bf | void spapr_events_init(sPAPRMachineState *spapr)
{
QTAILQ_INIT(&spapr->pending_events);
spapr->check_exception_irq = xics_alloc(spapr->icp, 0, 0, false);
spapr->epow_notifier.notify = spapr_powerdown_req;
qemu_register_powerdown_notifier(&spapr->epow_notifier);
spapr_rtas_register(RTAS_CHECK_EXCEPTION, "check-exception",
check_exception);
spapr_rtas_register(RTAS_EVENT_SCAN, "event-scan", event_scan);
}
| {
"code": [
" spapr->check_exception_irq = xics_alloc(spapr->icp, 0, 0, false);"
],
"line_no": [
7
]
} | void FUNC_0(sPAPRMachineState *VAR_0)
{
QTAILQ_INIT(&VAR_0->pending_events);
VAR_0->check_exception_irq = xics_alloc(VAR_0->icp, 0, 0, false);
VAR_0->epow_notifier.notify = spapr_powerdown_req;
qemu_register_powerdown_notifier(&VAR_0->epow_notifier);
spapr_rtas_register(RTAS_CHECK_EXCEPTION, "check-exception",
check_exception);
spapr_rtas_register(RTAS_EVENT_SCAN, "event-scan", event_scan);
}
| [
"void FUNC_0(sPAPRMachineState *VAR_0)\n{",
"QTAILQ_INIT(&VAR_0->pending_events);",
"VAR_0->check_exception_irq = xics_alloc(VAR_0->icp, 0, 0, false);",
"VAR_0->epow_notifier.notify = spapr_powerdown_req;",
"qemu_register_powerdown_notifier(&VAR_0->epow_notifier);",
"spapr_rtas_register(RTAS_CHECK_EXCEPTI... | [
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17
],
[
19
]
] |
14,103 | static void test_visitor_in_uint(TestInputVisitorData *data,
const void *unused)
{
Error *err = NULL;
uint64_t res = 0;
int64_t i64;
double dbl;
int value = 42;
Visitor *v;
v = visitor_input_test_init(data, "%d", value);
visit_type_uint64(v, NULL, &res, &error_abort);
g_assert_cmpuint(res, ==, (uint64_t)value);
visit_type_int(v, NULL, &i64, &error_abort);
g_assert_cmpint(i64, ==, value);
visit_type_number(v, NULL, &dbl, &error_abort);
g_assert_cmpfloat(dbl, ==, value);
/* BUG: value between INT64_MIN and -1 accepted modulo 2^64 */
v = visitor_input_test_init(data, "%d", -value);
visit_type_uint64(v, NULL, &res, &error_abort);
g_assert_cmpuint(res, ==, (uint64_t)-value);
/* BUG: value between INT64_MAX+1 and UINT64_MAX rejected */
v = visitor_input_test_init(data, "18446744073709551574");
visit_type_uint64(v, NULL, &res, &err);
error_free_or_abort(&err);
visit_type_number(v, NULL, &dbl, &error_abort);
g_assert_cmpfloat(dbl, ==, 18446744073709552000.0);
}
| true | qemu | 5923f85fb82df7c8c60a89458a5ae856045e5ab1 | static void test_visitor_in_uint(TestInputVisitorData *data,
const void *unused)
{
Error *err = NULL;
uint64_t res = 0;
int64_t i64;
double dbl;
int value = 42;
Visitor *v;
v = visitor_input_test_init(data, "%d", value);
visit_type_uint64(v, NULL, &res, &error_abort);
g_assert_cmpuint(res, ==, (uint64_t)value);
visit_type_int(v, NULL, &i64, &error_abort);
g_assert_cmpint(i64, ==, value);
visit_type_number(v, NULL, &dbl, &error_abort);
g_assert_cmpfloat(dbl, ==, value);
v = visitor_input_test_init(data, "%d", -value);
visit_type_uint64(v, NULL, &res, &error_abort);
g_assert_cmpuint(res, ==, (uint64_t)-value);
v = visitor_input_test_init(data, "18446744073709551574");
visit_type_uint64(v, NULL, &res, &err);
error_free_or_abort(&err);
visit_type_number(v, NULL, &dbl, &error_abort);
g_assert_cmpfloat(dbl, ==, 18446744073709552000.0);
}
| {
"code": [
" Error *err = NULL;",
" visit_type_uint64(v, NULL, &res, &err);",
" error_free_or_abort(&err);"
],
"line_no": [
7,
63,
65
]
} | static void FUNC_0(TestInputVisitorData *VAR_0,
const void *VAR_1)
{
Error *err = NULL;
uint64_t res = 0;
int64_t i64;
double VAR_2;
int VAR_3 = 42;
Visitor *v;
v = visitor_input_test_init(VAR_0, "%d", VAR_3);
visit_type_uint64(v, NULL, &res, &error_abort);
g_assert_cmpuint(res, ==, (uint64_t)VAR_3);
visit_type_int(v, NULL, &i64, &error_abort);
g_assert_cmpint(i64, ==, VAR_3);
visit_type_number(v, NULL, &VAR_2, &error_abort);
g_assert_cmpfloat(VAR_2, ==, VAR_3);
v = visitor_input_test_init(VAR_0, "%d", -VAR_3);
visit_type_uint64(v, NULL, &res, &error_abort);
g_assert_cmpuint(res, ==, (uint64_t)-VAR_3);
v = visitor_input_test_init(VAR_0, "18446744073709551574");
visit_type_uint64(v, NULL, &res, &err);
error_free_or_abort(&err);
visit_type_number(v, NULL, &VAR_2, &error_abort);
g_assert_cmpfloat(VAR_2, ==, 18446744073709552000.0);
}
| [
"static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"Error *err = NULL;",
"uint64_t res = 0;",
"int64_t i64;",
"double VAR_2;",
"int VAR_3 = 42;",
"Visitor *v;",
"v = visitor_input_test_init(VAR_0, \"%d\", VAR_3);",
"visit_type_uint64(v, NULL, &res, &error_abort);",
"g_assert... | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
45
],
[
49
],
[
51
],
[
59
],
[
63
],
[... |
14,104 | static int kvm_check_many_ioeventfds(void)
{
/* Userspace can use ioeventfd for io notification. This requires a host
* that supports eventfd(2) and an I/O thread; since eventfd does not
* support SIGIO it cannot interrupt the vcpu.
*
* Older kernels have a 6 device limit on the KVM io bus. Find out so we
* can avoid creating too many ioeventfds.
*/
#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)
int ioeventfds[7];
int i, ret = 0;
for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
if (ioeventfds[i] < 0) {
break;
}
ret = kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, true);
if (ret < 0) {
close(ioeventfds[i]);
break;
}
}
/* Decide whether many devices are supported or not */
ret = i == ARRAY_SIZE(ioeventfds);
while (i-- > 0) {
kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, false);
close(ioeventfds[i]);
}
return ret;
#else
return 0;
#endif
}
| true | qemu | 12d4536f7d911b6d87a766ad7300482ea663cea2 | static int kvm_check_many_ioeventfds(void)
{
#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)
int ioeventfds[7];
int i, ret = 0;
for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
if (ioeventfds[i] < 0) {
break;
}
ret = kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, true);
if (ret < 0) {
close(ioeventfds[i]);
break;
}
}
ret = i == ARRAY_SIZE(ioeventfds);
while (i-- > 0) {
kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, false);
close(ioeventfds[i]);
}
return ret;
#else
return 0;
#endif
}
| {
"code": [
"#endif",
"#endif",
"#endif",
"#else",
"#endif",
"#else",
"#endif",
"#endif",
"#else",
"#endif",
"#endif",
" break;",
"#endif",
"#else",
"#endif",
"#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)",
"#endif",
"#endif",
"#endif",
"#endif",
"#else",
"#endif"
],
"line_no": [
69,
69,
69,
65,
69,
65,
69,
69,
65,
69,
69,
31,
69,
65,
69,
19,
69,
69,
69,
69,
65,
69
]
} | static int FUNC_0(void)
{
#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)
int ioeventfds[7];
int i, ret = 0;
for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
if (ioeventfds[i] < 0) {
break;
}
ret = kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, true);
if (ret < 0) {
close(ioeventfds[i]);
break;
}
}
ret = i == ARRAY_SIZE(ioeventfds);
while (i-- > 0) {
kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, false);
close(ioeventfds[i]);
}
return ret;
#else
return 0;
#endif
}
| [
"static int FUNC_0(void)\n{",
"#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)\nint ioeventfds[7];",
"int i, ret = 0;",
"for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {",
"ioeventfds[i] = eventfd(0, EFD_CLOEXEC);",
"if (ioeventfds[i] < 0) {",
"break;",
"}",
"ret = kvm_set_ioeventfd_pio_word(i... | [
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1
] | [
[
1,
3
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
... |
14,105 | static int init_common(VC9Context *v)
{
static int done = 0;
int i;
v->mv_type_mb_plane = v->direct_mb_plane = v->skip_mb_plane = NULL;
v->pq = -1;
#if HAS_ADVANCED_PROFILE
v->ac_pred_plane = v->over_flags_plane = NULL;
v->hrd_rate = v->hrd_buffer = NULL;
#endif
#if 0 // spec -> actual tables converter
for(i=0; i<64; i++){
int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];
av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
}
for(i=0; i<64; i++){
int code= vc9_norm6_spec[i][2] + vc9_norm6_spec[i][4];
av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
}
#endif
if(!done)
{
done = 1;
INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,
vc9_bfraction_bits, 1, 1,
vc9_bfraction_codes, 1, 1, 1);
INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,
vc9_norm2_bits, 1, 1,
vc9_norm2_codes, 1, 1, 1);
INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,
vc9_norm6_bits, 1, 1,
vc9_norm6_codes, 2, 2, 1);
INIT_VLC(&vc9_cbpcy_i_vlc, VC9_CBPCY_I_VLC_BITS, 64,
vc9_cbpcy_i_bits, 1, 1,
vc9_cbpcy_i_codes, 2, 2, 1);
INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
vc9_imode_bits, 1, 1,
vc9_imode_codes, 1, 1, 1);
for(i=0; i<3; i++)
{
INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
vc9_4mv_block_pattern_bits[i], 1, 1,
vc9_4mv_block_pattern_codes[i], 1, 1, 1);
INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,
vc9_cbpcy_p_bits[i], 1, 1,
vc9_cbpcy_p_codes[i], 2, 2, 1);
}
for (i=0; i<2; i++)
{
INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,
vc9_mv_diff_bits[i], 1, 1,
vc9_mv_diff_codes[i], 2, 2, 1);
INIT_VLC(&vc9_luma_dc_vlc[i], VC9_LUMA_DC_VLC_BITS, 120,
vc9_luma_dc_bits[i], 1, 1,
vc9_luma_dc_codes[i], 4, 4, 1);
INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
vc9_ttmb_bits[i], 1, 1,
vc9_ttmb_codes[i], 2, 2, 1);
}
}
return 0;
}
| false | FFmpeg | e5540b3fd30367ce3cc33b2f34a04b660dbc4b38 | static int init_common(VC9Context *v)
{
static int done = 0;
int i;
v->mv_type_mb_plane = v->direct_mb_plane = v->skip_mb_plane = NULL;
v->pq = -1;
#if HAS_ADVANCED_PROFILE
v->ac_pred_plane = v->over_flags_plane = NULL;
v->hrd_rate = v->hrd_buffer = NULL;
#endif
#if 0
for(i=0; i<64; i++){
int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];
av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
}
for(i=0; i<64; i++){
int code= vc9_norm6_spec[i][2] + vc9_norm6_spec[i][4];
av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
}
#endif
if(!done)
{
done = 1;
INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,
vc9_bfraction_bits, 1, 1,
vc9_bfraction_codes, 1, 1, 1);
INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,
vc9_norm2_bits, 1, 1,
vc9_norm2_codes, 1, 1, 1);
INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,
vc9_norm6_bits, 1, 1,
vc9_norm6_codes, 2, 2, 1);
INIT_VLC(&vc9_cbpcy_i_vlc, VC9_CBPCY_I_VLC_BITS, 64,
vc9_cbpcy_i_bits, 1, 1,
vc9_cbpcy_i_codes, 2, 2, 1);
INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
vc9_imode_bits, 1, 1,
vc9_imode_codes, 1, 1, 1);
for(i=0; i<3; i++)
{
INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
vc9_4mv_block_pattern_bits[i], 1, 1,
vc9_4mv_block_pattern_codes[i], 1, 1, 1);
INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,
vc9_cbpcy_p_bits[i], 1, 1,
vc9_cbpcy_p_codes[i], 2, 2, 1);
}
for (i=0; i<2; i++)
{
INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,
vc9_mv_diff_bits[i], 1, 1,
vc9_mv_diff_codes[i], 2, 2, 1);
INIT_VLC(&vc9_luma_dc_vlc[i], VC9_LUMA_DC_VLC_BITS, 120,
vc9_luma_dc_bits[i], 1, 1,
vc9_luma_dc_codes[i], 4, 4, 1);
INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
vc9_ttmb_bits[i], 1, 1,
vc9_ttmb_codes[i], 2, 2, 1);
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(VC9Context *VAR_0)
{
static int VAR_1 = 0;
int VAR_2;
VAR_0->mv_type_mb_plane = VAR_0->direct_mb_plane = VAR_0->skip_mb_plane = NULL;
VAR_0->pq = -1;
#if HAS_ADVANCED_PROFILE
VAR_0->ac_pred_plane = VAR_0->over_flags_plane = NULL;
VAR_0->hrd_rate = VAR_0->hrd_buffer = NULL;
#endif
#if 0
for(VAR_2=0; VAR_2<64; VAR_2++){
int code= (vc9_norm6_spec[VAR_2][1] << vc9_norm6_spec[VAR_2][4]) + vc9_norm6_spec[VAR_2][3];
av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
if(VAR_2%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
}
for(VAR_2=0; VAR_2<64; VAR_2++){
int code= vc9_norm6_spec[VAR_2][2] + vc9_norm6_spec[VAR_2][4];
av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
if(VAR_2%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
}
#endif
if(!VAR_1)
{
VAR_1 = 1;
INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,
vc9_bfraction_bits, 1, 1,
vc9_bfraction_codes, 1, 1, 1);
INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,
vc9_norm2_bits, 1, 1,
vc9_norm2_codes, 1, 1, 1);
INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,
vc9_norm6_bits, 1, 1,
vc9_norm6_codes, 2, 2, 1);
INIT_VLC(&vc9_cbpcy_i_vlc, VC9_CBPCY_I_VLC_BITS, 64,
vc9_cbpcy_i_bits, 1, 1,
vc9_cbpcy_i_codes, 2, 2, 1);
INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
vc9_imode_bits, 1, 1,
vc9_imode_codes, 1, 1, 1);
for(VAR_2=0; VAR_2<3; VAR_2++)
{
INIT_VLC(&vc9_4mv_block_pattern_vlc[VAR_2], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
vc9_4mv_block_pattern_bits[VAR_2], 1, 1,
vc9_4mv_block_pattern_codes[VAR_2], 1, 1, 1);
INIT_VLC(&vc9_cbpcy_p_vlc[VAR_2], VC9_CBPCY_P_VLC_BITS, 64,
vc9_cbpcy_p_bits[VAR_2], 1, 1,
vc9_cbpcy_p_codes[VAR_2], 2, 2, 1);
}
for (VAR_2=0; VAR_2<2; VAR_2++)
{
INIT_VLC(&vc9_mv_diff_vlc[VAR_2], VC9_MV_DIFF_VLC_BITS, 73,
vc9_mv_diff_bits[VAR_2], 1, 1,
vc9_mv_diff_codes[VAR_2], 2, 2, 1);
INIT_VLC(&vc9_luma_dc_vlc[VAR_2], VC9_LUMA_DC_VLC_BITS, 120,
vc9_luma_dc_bits[VAR_2], 1, 1,
vc9_luma_dc_codes[VAR_2], 4, 4, 1);
INIT_VLC(&vc9_ttmb_vlc[VAR_2], VC9_TTMB_VLC_BITS, 16,
vc9_ttmb_bits[VAR_2], 1, 1,
vc9_ttmb_codes[VAR_2], 2, 2, 1);
}
}
return 0;
}
| [
"static int FUNC_0(VC9Context *VAR_0)\n{",
"static int VAR_1 = 0;",
"int VAR_2;",
"VAR_0->mv_type_mb_plane = VAR_0->direct_mb_plane = VAR_0->skip_mb_plane = NULL;",
"VAR_0->pq = -1;",
"#if HAS_ADVANCED_PROFILE\nVAR_0->ac_pred_plane = VAR_0->over_flags_plane = NULL;",
"VAR_0->hrd_rate = VAR_0->hrd_buffer... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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... |
14,106 | static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
{
AVStream *st = s->streams[pkt->stream_index];
AVIOContext *pb = s->pb;
AVFrame *frame;
int* first_pkt = s->priv_data;
int width, height, h_chroma_shift, v_chroma_shift;
int i;
char buf2[Y4M_LINE_MAX + 1];
uint8_t *ptr, *ptr1, *ptr2;
frame = (AVFrame *)pkt->data;
/* for the first packet we have to output the header as well */
if (*first_pkt) {
*first_pkt = 0;
if (yuv4_generate_header(s, buf2) < 0) {
av_log(s, AV_LOG_ERROR,
"Error. YUV4MPEG stream header write failed.\n");
return AVERROR(EIO);
} else {
avio_write(pb, buf2, strlen(buf2));
}
}
/* construct frame header */
avio_printf(s->pb, "%s\n", Y4M_FRAME_MAGIC);
width = st->codecpar->width;
height = st->codecpar->height;
ptr = frame->data[0];
switch (st->codecpar->format) {
case AV_PIX_FMT_GRAY8:
case AV_PIX_FMT_YUV411P:
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUV422P:
case AV_PIX_FMT_YUV444P:
break;
case AV_PIX_FMT_GRAY16:
case AV_PIX_FMT_YUV420P9:
case AV_PIX_FMT_YUV422P9:
case AV_PIX_FMT_YUV444P9:
case AV_PIX_FMT_YUV420P10:
case AV_PIX_FMT_YUV422P10:
case AV_PIX_FMT_YUV444P10:
case AV_PIX_FMT_YUV420P12:
case AV_PIX_FMT_YUV422P12:
case AV_PIX_FMT_YUV444P12:
case AV_PIX_FMT_YUV420P14:
case AV_PIX_FMT_YUV422P14:
case AV_PIX_FMT_YUV444P14:
case AV_PIX_FMT_YUV420P16:
case AV_PIX_FMT_YUV422P16:
case AV_PIX_FMT_YUV444P16:
width *= 2;
break;
default:
av_log(s, AV_LOG_ERROR, "The pixel format '%s' is not supported.\n",
av_get_pix_fmt_name(st->codecpar->format));
return AVERROR(EINVAL);
}
for (i = 0; i < height; i++) {
avio_write(pb, ptr, width);
ptr += frame->linesize[0];
}
if (st->codecpar->format != AV_PIX_FMT_GRAY8 &&
st->codecpar->format != AV_PIX_FMT_GRAY16) {
// Adjust for smaller Cb and Cr planes
av_pix_fmt_get_chroma_sub_sample(st->codecpar->format, &h_chroma_shift,
&v_chroma_shift);
// Shift right, rounding up
width = AV_CEIL_RSHIFT(width, h_chroma_shift);
height = AV_CEIL_RSHIFT(height, v_chroma_shift);
ptr1 = frame->data[1];
ptr2 = frame->data[2];
for (i = 0; i < height; i++) { /* Cb */
avio_write(pb, ptr1, width);
ptr1 += frame->linesize[1];
}
for (i = 0; i < height; i++) { /* Cr */
avio_write(pb, ptr2, width);
ptr2 += frame->linesize[2];
}
}
return 0;
}
| false | FFmpeg | a4743d2574254aa0c494b337947e8c9880c7ead7 | static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
{
AVStream *st = s->streams[pkt->stream_index];
AVIOContext *pb = s->pb;
AVFrame *frame;
int* first_pkt = s->priv_data;
int width, height, h_chroma_shift, v_chroma_shift;
int i;
char buf2[Y4M_LINE_MAX + 1];
uint8_t *ptr, *ptr1, *ptr2;
frame = (AVFrame *)pkt->data;
if (*first_pkt) {
*first_pkt = 0;
if (yuv4_generate_header(s, buf2) < 0) {
av_log(s, AV_LOG_ERROR,
"Error. YUV4MPEG stream header write failed.\n");
return AVERROR(EIO);
} else {
avio_write(pb, buf2, strlen(buf2));
}
}
avio_printf(s->pb, "%s\n", Y4M_FRAME_MAGIC);
width = st->codecpar->width;
height = st->codecpar->height;
ptr = frame->data[0];
switch (st->codecpar->format) {
case AV_PIX_FMT_GRAY8:
case AV_PIX_FMT_YUV411P:
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUV422P:
case AV_PIX_FMT_YUV444P:
break;
case AV_PIX_FMT_GRAY16:
case AV_PIX_FMT_YUV420P9:
case AV_PIX_FMT_YUV422P9:
case AV_PIX_FMT_YUV444P9:
case AV_PIX_FMT_YUV420P10:
case AV_PIX_FMT_YUV422P10:
case AV_PIX_FMT_YUV444P10:
case AV_PIX_FMT_YUV420P12:
case AV_PIX_FMT_YUV422P12:
case AV_PIX_FMT_YUV444P12:
case AV_PIX_FMT_YUV420P14:
case AV_PIX_FMT_YUV422P14:
case AV_PIX_FMT_YUV444P14:
case AV_PIX_FMT_YUV420P16:
case AV_PIX_FMT_YUV422P16:
case AV_PIX_FMT_YUV444P16:
width *= 2;
break;
default:
av_log(s, AV_LOG_ERROR, "The pixel format '%s' is not supported.\n",
av_get_pix_fmt_name(st->codecpar->format));
return AVERROR(EINVAL);
}
for (i = 0; i < height; i++) {
avio_write(pb, ptr, width);
ptr += frame->linesize[0];
}
if (st->codecpar->format != AV_PIX_FMT_GRAY8 &&
st->codecpar->format != AV_PIX_FMT_GRAY16) {
av_pix_fmt_get_chroma_sub_sample(st->codecpar->format, &h_chroma_shift,
&v_chroma_shift);
width = AV_CEIL_RSHIFT(width, h_chroma_shift);
height = AV_CEIL_RSHIFT(height, v_chroma_shift);
ptr1 = frame->data[1];
ptr2 = frame->data[2];
for (i = 0; i < height; i++) {
avio_write(pb, ptr1, width);
ptr1 += frame->linesize[1];
}
for (i = 0; i < height; i++) {
avio_write(pb, ptr2, width);
ptr2 += frame->linesize[2];
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
AVStream *st = VAR_0->streams[VAR_1->stream_index];
AVIOContext *pb = VAR_0->pb;
AVFrame *frame;
int* VAR_2 = VAR_0->priv_data;
int VAR_3, VAR_4, VAR_5, VAR_6;
int VAR_7;
char VAR_8[Y4M_LINE_MAX + 1];
uint8_t *ptr, *ptr1, *ptr2;
frame = (AVFrame *)VAR_1->data;
if (*VAR_2) {
*VAR_2 = 0;
if (yuv4_generate_header(VAR_0, VAR_8) < 0) {
av_log(VAR_0, AV_LOG_ERROR,
"Error. YUV4MPEG stream header write failed.\n");
return AVERROR(EIO);
} else {
avio_write(pb, VAR_8, strlen(VAR_8));
}
}
avio_printf(VAR_0->pb, "%VAR_0\n", Y4M_FRAME_MAGIC);
VAR_3 = st->codecpar->VAR_3;
VAR_4 = st->codecpar->VAR_4;
ptr = frame->data[0];
switch (st->codecpar->format) {
case AV_PIX_FMT_GRAY8:
case AV_PIX_FMT_YUV411P:
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUV422P:
case AV_PIX_FMT_YUV444P:
break;
case AV_PIX_FMT_GRAY16:
case AV_PIX_FMT_YUV420P9:
case AV_PIX_FMT_YUV422P9:
case AV_PIX_FMT_YUV444P9:
case AV_PIX_FMT_YUV420P10:
case AV_PIX_FMT_YUV422P10:
case AV_PIX_FMT_YUV444P10:
case AV_PIX_FMT_YUV420P12:
case AV_PIX_FMT_YUV422P12:
case AV_PIX_FMT_YUV444P12:
case AV_PIX_FMT_YUV420P14:
case AV_PIX_FMT_YUV422P14:
case AV_PIX_FMT_YUV444P14:
case AV_PIX_FMT_YUV420P16:
case AV_PIX_FMT_YUV422P16:
case AV_PIX_FMT_YUV444P16:
VAR_3 *= 2;
break;
default:
av_log(VAR_0, AV_LOG_ERROR, "The pixel format '%VAR_0' is not supported.\n",
av_get_pix_fmt_name(st->codecpar->format));
return AVERROR(EINVAL);
}
for (VAR_7 = 0; VAR_7 < VAR_4; VAR_7++) {
avio_write(pb, ptr, VAR_3);
ptr += frame->linesize[0];
}
if (st->codecpar->format != AV_PIX_FMT_GRAY8 &&
st->codecpar->format != AV_PIX_FMT_GRAY16) {
av_pix_fmt_get_chroma_sub_sample(st->codecpar->format, &VAR_5,
&VAR_6);
VAR_3 = AV_CEIL_RSHIFT(VAR_3, VAR_5);
VAR_4 = AV_CEIL_RSHIFT(VAR_4, VAR_6);
ptr1 = frame->data[1];
ptr2 = frame->data[2];
for (VAR_7 = 0; VAR_7 < VAR_4; VAR_7++) {
avio_write(pb, ptr1, VAR_3);
ptr1 += frame->linesize[1];
}
for (VAR_7 = 0; VAR_7 < VAR_4; VAR_7++) {
avio_write(pb, ptr2, VAR_3);
ptr2 += frame->linesize[2];
}
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"AVStream *st = VAR_0->streams[VAR_1->stream_index];",
"AVIOContext *pb = VAR_0->pb;",
"AVFrame *frame;",
"int* VAR_2 = VAR_0->priv_data;",
"int VAR_3, VAR_4, VAR_5, VAR_6;",
"int VAR_7;",
"char VAR_8[Y4M_LINE_MAX + 1];",
"uint8_t *ptr... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[... |
14,107 | static void FUNC(transquant_bypass4x4)(uint8_t *_dst, int16_t *coeffs,
ptrdiff_t stride)
{
int x, y;
pixel *dst = (pixel *)_dst;
stride /= sizeof(pixel);
for (y = 0; y < 4; y++) {
for (x = 0; x < 4; x++) {
dst[x] += *coeffs;
coeffs++;
}
dst += stride;
}
}
| false | FFmpeg | c9fe0caf7a1abde7ca0b1a359f551103064867b1 | static void FUNC(transquant_bypass4x4)(uint8_t *_dst, int16_t *coeffs,
ptrdiff_t stride)
{
int x, y;
pixel *dst = (pixel *)_dst;
stride /= sizeof(pixel);
for (y = 0; y < 4; y++) {
for (x = 0; x < 4; x++) {
dst[x] += *coeffs;
coeffs++;
}
dst += stride;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(transquant_bypass4x4)(uint8_t *_dst, int16_t *coeffs,
ptrdiff_t stride)
{
int VAR_0, VAR_1;
pixel *dst = (pixel *)_dst;
stride /= sizeof(pixel);
for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {
for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {
dst[VAR_0] += *coeffs;
coeffs++;
}
dst += stride;
}
}
| [
"static void FUNC_0(transquant_bypass4x4)(uint8_t *_dst, int16_t *coeffs,\nptrdiff_t stride)\n{",
"int VAR_0, VAR_1;",
"pixel *dst = (pixel *)_dst;",
"stride /= sizeof(pixel);",
"for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {",
"for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {",
"dst[VAR_0] += *coeffs;",
"coeffs++;",
"... | [
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
]
] |
14,109 | static int RENAME(epzs_motion_search4)(MpegEncContext * s,
int *mx_ptr, int *my_ptr,
int P[10][2], int pred_x, int pred_y,
uint8_t *src_data[3],
uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2],
int ref_mv_scale, uint8_t * const mv_penalty)
{
int best[2]={0, 0};
int d, dmin;
const int shift= 1+s->quarter_sample;
uint32_t *map= s->me.map;
int map_generation;
const int penalty_factor= s->me.penalty_factor;
const int size=1;
const int h=8;
const int ref_mv_stride= s->mb_stride;
const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
me_cmp_func cmp, chroma_cmp;
LOAD_COMMON
cmp= s->dsp.me_cmp[size];
chroma_cmp= s->dsp.me_cmp[size+1];
map_generation= update_map_generation(s);
dmin = 1000000;
//printf("%d %d %d %d //",xmin, ymin, xmax, ymax);
/* first line */
if (s->first_slice_line) {
CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
}else{
CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
//FIXME try some early stop
if(dmin>64*2){
CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
}
}
if(dmin>64*4){
CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
if(s->end_mb_y == s->mb_height || s->mb_y+1<s->end_mb_y) //FIXME replace at least with last_slice_line
CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
}
if(s->me.dia_size==-1)
dmin= RENAME(funny_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
else if(s->me.dia_size<-1)
dmin= RENAME(sab_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
else if(s->me.dia_size<2)
dmin= RENAME(small_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
else
dmin= RENAME(var_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
*mx_ptr= best[0];
*my_ptr= best[1];
// printf("%d %d %d \n", best[0], best[1], dmin);
return dmin;
}
| false | FFmpeg | 80ee9fc0e305b815b4b67bbf8fa9ceccdc1d369e | static int RENAME(epzs_motion_search4)(MpegEncContext * s,
int *mx_ptr, int *my_ptr,
int P[10][2], int pred_x, int pred_y,
uint8_t *src_data[3],
uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2],
int ref_mv_scale, uint8_t * const mv_penalty)
{
int best[2]={0, 0};
int d, dmin;
const int shift= 1+s->quarter_sample;
uint32_t *map= s->me.map;
int map_generation;
const int penalty_factor= s->me.penalty_factor;
const int size=1;
const int h=8;
const int ref_mv_stride= s->mb_stride;
const int ref_mv_xy= s->mb_x + s->mb_y *ref_mv_stride;
me_cmp_func cmp, chroma_cmp;
LOAD_COMMON
cmp= s->dsp.me_cmp[size];
chroma_cmp= s->dsp.me_cmp[size+1];
map_generation= update_map_generation(s);
dmin = 1000000;
if (s->first_slice_line) {
CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
}else{
CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
if(dmin>64*2){
CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
}
}
if(dmin>64*4){
CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
if(s->end_mb_y == s->mb_height || s->mb_y+1<s->end_mb_y)
CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
}
if(s->me.dia_size==-1)
dmin= RENAME(funny_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
else if(s->me.dia_size<-1)
dmin= RENAME(sab_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
else if(s->me.dia_size<2)
dmin= RENAME(small_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
else
dmin= RENAME(var_diamond_search)(s, best, dmin, src_data, ref_data, stride, uvstride,
pred_x, pred_y, penalty_factor,
shift, map, map_generation, size, h, mv_penalty);
*mx_ptr= best[0];
*my_ptr= best[1];
return dmin;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(epzs_motion_search4)(MpegEncContext * s,
int *mx_ptr, int *my_ptr,
int P[10][2], int pred_x, int pred_y,
uint8_t *src_data[3],
uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2],
int ref_mv_scale, uint8_t * const mv_penalty)
{
int VAR_0[2]={0, 0};
int VAR_1, VAR_2;
const int VAR_3= 1+s->quarter_sample;
uint32_t *map= s->me.map;
int VAR_4;
const int VAR_5= s->me.VAR_5;
const int VAR_6=1;
const int VAR_7=8;
const int VAR_8= s->mb_stride;
const int VAR_9= s->mb_x + s->mb_y *VAR_8;
me_cmp_func cmp, chroma_cmp;
LOAD_COMMON
cmp= s->dsp.me_cmp[VAR_6];
chroma_cmp= s->dsp.me_cmp[VAR_6+1];
VAR_4= update_map_generation(s);
VAR_2 = 1000000;
if (s->first_slice_line) {
CHECK_MV(P_LEFT[0]>>VAR_3, P_LEFT[1]>>VAR_3)
CHECK_CLIPED_MV((last_mv[VAR_9][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[VAR_9][1]*ref_mv_scale + (1<<15))>>16)
CHECK_MV(P_MV1[0]>>VAR_3, P_MV1[1]>>VAR_3)
}else{
CHECK_MV(P_MV1[0]>>VAR_3, P_MV1[1]>>VAR_3)
if(VAR_2>64*2){
CHECK_MV(P_MEDIAN[0]>>VAR_3, P_MEDIAN[1]>>VAR_3)
CHECK_MV(P_LEFT[0]>>VAR_3, P_LEFT[1]>>VAR_3)
CHECK_MV(P_TOP[0]>>VAR_3, P_TOP[1]>>VAR_3)
CHECK_MV(P_TOPRIGHT[0]>>VAR_3, P_TOPRIGHT[1]>>VAR_3)
CHECK_CLIPED_MV((last_mv[VAR_9][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[VAR_9][1]*ref_mv_scale + (1<<15))>>16)
}
}
if(VAR_2>64*4){
CHECK_CLIPED_MV((last_mv[VAR_9+1][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[VAR_9+1][1]*ref_mv_scale + (1<<15))>>16)
if(s->end_mb_y == s->mb_height || s->mb_y+1<s->end_mb_y)
CHECK_CLIPED_MV((last_mv[VAR_9+VAR_8][0]*ref_mv_scale + (1<<15))>>16,
(last_mv[VAR_9+VAR_8][1]*ref_mv_scale + (1<<15))>>16)
}
if(s->me.dia_size==-1)
VAR_2= FUNC_0(funny_diamond_search)(s, VAR_0, VAR_2, src_data, ref_data, stride, uvstride,
pred_x, pred_y, VAR_5,
VAR_3, map, VAR_4, VAR_6, VAR_7, mv_penalty);
else if(s->me.dia_size<-1)
VAR_2= FUNC_0(sab_diamond_search)(s, VAR_0, VAR_2, src_data, ref_data, stride, uvstride,
pred_x, pred_y, VAR_5,
VAR_3, map, VAR_4, VAR_6, VAR_7, mv_penalty);
else if(s->me.dia_size<2)
VAR_2= FUNC_0(small_diamond_search)(s, VAR_0, VAR_2, src_data, ref_data, stride, uvstride,
pred_x, pred_y, VAR_5,
VAR_3, map, VAR_4, VAR_6, VAR_7, mv_penalty);
else
VAR_2= FUNC_0(var_diamond_search)(s, VAR_0, VAR_2, src_data, ref_data, stride, uvstride,
pred_x, pred_y, VAR_5,
VAR_3, map, VAR_4, VAR_6, VAR_7, mv_penalty);
*mx_ptr= VAR_0[0];
*my_ptr= VAR_0[1];
return VAR_2;
}
| [
"static int FUNC_0(epzs_motion_search4)(MpegEncContext * s,\nint *mx_ptr, int *my_ptr,\nint P[10][2], int pred_x, int pred_y,\nuint8_t *src_data[3],\nuint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2],\nint ref_mv_scale, uint8_t * const mv_penalty)\n{",
"int VAR_0[2]={0, 0};",
"int VAR_1, 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
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
41
],
[
43
],
[
47
],
[
51
],
[
57
... |
14,110 | static int ftp_passive_mode(FTPContext *s)
{
char *res = NULL, *start, *end;
int i;
const char *command = "PASV\r\n";
const int pasv_codes[] = {227, 0};
if (!ftp_send_command(s, command, pasv_codes, &res))
goto fail;
start = NULL;
for (i = 0; i < strlen(res); ++i) {
if (res[i] == '(') {
start = res + i + 1;
} else if (res[i] == ')') {
end = res + i;
break;
}
}
if (!start || !end)
goto fail;
*end = '\0';
/* skip ip */
if (!av_strtok(start, ",", &end)) goto fail;
if (!av_strtok(end, ",", &end)) goto fail;
if (!av_strtok(end, ",", &end)) goto fail;
if (!av_strtok(end, ",", &end)) goto fail;
/* parse port number */
start = av_strtok(end, ",", &end);
if (!start) goto fail;
s->server_data_port = atoi(start) * 256;
start = av_strtok(end, ",", &end);
if (!start) goto fail;
s->server_data_port += atoi(start);
av_dlog(s, "Server data port: %d\n", s->server_data_port);
av_free(res);
return 0;
fail:
av_free(res);
s->server_data_port = -1;
return AVERROR(EIO);
}
| false | FFmpeg | ddbcc48b646737c8bff7f8e28e0a69dca65509cf | static int ftp_passive_mode(FTPContext *s)
{
char *res = NULL, *start, *end;
int i;
const char *command = "PASV\r\n";
const int pasv_codes[] = {227, 0};
if (!ftp_send_command(s, command, pasv_codes, &res))
goto fail;
start = NULL;
for (i = 0; i < strlen(res); ++i) {
if (res[i] == '(') {
start = res + i + 1;
} else if (res[i] == ')') {
end = res + i;
break;
}
}
if (!start || !end)
goto fail;
*end = '\0';
if (!av_strtok(start, ",", &end)) goto fail;
if (!av_strtok(end, ",", &end)) goto fail;
if (!av_strtok(end, ",", &end)) goto fail;
if (!av_strtok(end, ",", &end)) goto fail;
start = av_strtok(end, ",", &end);
if (!start) goto fail;
s->server_data_port = atoi(start) * 256;
start = av_strtok(end, ",", &end);
if (!start) goto fail;
s->server_data_port += atoi(start);
av_dlog(s, "Server data port: %d\n", s->server_data_port);
av_free(res);
return 0;
fail:
av_free(res);
s->server_data_port = -1;
return AVERROR(EIO);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(FTPContext *VAR_0)
{
char *VAR_1 = NULL, *VAR_2, *VAR_3;
int VAR_4;
const char *VAR_5 = "PASV\r\n";
const int VAR_6[] = {227, 0};
if (!ftp_send_command(VAR_0, VAR_5, VAR_6, &VAR_1))
goto fail;
VAR_2 = NULL;
for (VAR_4 = 0; VAR_4 < strlen(VAR_1); ++VAR_4) {
if (VAR_1[VAR_4] == '(') {
VAR_2 = VAR_1 + VAR_4 + 1;
} else if (VAR_1[VAR_4] == ')') {
VAR_3 = VAR_1 + VAR_4;
break;
}
}
if (!VAR_2 || !VAR_3)
goto fail;
*VAR_3 = '\0';
if (!av_strtok(VAR_2, ",", &VAR_3)) goto fail;
if (!av_strtok(VAR_3, ",", &VAR_3)) goto fail;
if (!av_strtok(VAR_3, ",", &VAR_3)) goto fail;
if (!av_strtok(VAR_3, ",", &VAR_3)) goto fail;
VAR_2 = av_strtok(VAR_3, ",", &VAR_3);
if (!VAR_2) goto fail;
VAR_0->server_data_port = atoi(VAR_2) * 256;
VAR_2 = av_strtok(VAR_3, ",", &VAR_3);
if (!VAR_2) goto fail;
VAR_0->server_data_port += atoi(VAR_2);
av_dlog(VAR_0, "Server data port: %d\n", VAR_0->server_data_port);
av_free(VAR_1);
return 0;
fail:
av_free(VAR_1);
VAR_0->server_data_port = -1;
return AVERROR(EIO);
}
| [
"static int FUNC_0(FTPContext *VAR_0)\n{",
"char *VAR_1 = NULL, *VAR_2, *VAR_3;",
"int VAR_4;",
"const char *VAR_5 = \"PASV\\r\\n\";",
"const int VAR_6[] = {227, 0};",
"if (!ftp_send_command(VAR_0, VAR_5, VAR_6, &VAR_1))\ngoto fail;",
"VAR_2 = NULL;",
"for (VAR_4 = 0; VAR_4 < strlen(VAR_1); ++VAR_4) {... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15,
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
41
],
[
45
],
[
49
],
[
51
... |
14,111 | void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
VirtIOBlockDataPlane **dataplane,
Error **errp)
{
VirtIOBlockDataPlane *s;
Error *local_err = NULL;
*dataplane = NULL;
if (!blk->data_plane) {
return;
}
if (blk->scsi) {
error_setg(errp,
"device is incompatible with x-data-plane, use scsi=off");
return;
}
if (blk->config_wce) {
error_setg(errp, "device is incompatible with x-data-plane, "
"use config-wce=off");
return;
}
/* If dataplane is (re-)enabled while the guest is running there could be
* block jobs that can conflict.
*/
if (bdrv_op_is_blocked(blk->conf.bs, BLOCK_OP_TYPE_DATAPLANE, &local_err)) {
error_report("cannot start dataplane thread: %s",
error_get_pretty(local_err));
error_free(local_err);
return;
}
s = g_new0(VirtIOBlockDataPlane, 1);
s->vdev = vdev;
s->blk = blk;
if (blk->iothread) {
s->iothread = blk->iothread;
object_ref(OBJECT(s->iothread));
} else {
/* Create per-device IOThread if none specified. This is for
* x-data-plane option compatibility. If x-data-plane is removed we
* can drop this.
*/
object_initialize(&s->internal_iothread_obj,
sizeof(s->internal_iothread_obj),
TYPE_IOTHREAD);
user_creatable_complete(OBJECT(&s->internal_iothread_obj), &error_abort);
s->iothread = &s->internal_iothread_obj;
}
s->ctx = iothread_get_aio_context(s->iothread);
error_setg(&s->blocker, "block device is in use by data plane");
bdrv_op_block_all(blk->conf.bs, s->blocker);
*dataplane = s;
}
| false | qemu | 6d7e73d62fa32813b6f6a3575db2e9b5e0d43387 | void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
VirtIOBlockDataPlane **dataplane,
Error **errp)
{
VirtIOBlockDataPlane *s;
Error *local_err = NULL;
*dataplane = NULL;
if (!blk->data_plane) {
return;
}
if (blk->scsi) {
error_setg(errp,
"device is incompatible with x-data-plane, use scsi=off");
return;
}
if (blk->config_wce) {
error_setg(errp, "device is incompatible with x-data-plane, "
"use config-wce=off");
return;
}
if (bdrv_op_is_blocked(blk->conf.bs, BLOCK_OP_TYPE_DATAPLANE, &local_err)) {
error_report("cannot start dataplane thread: %s",
error_get_pretty(local_err));
error_free(local_err);
return;
}
s = g_new0(VirtIOBlockDataPlane, 1);
s->vdev = vdev;
s->blk = blk;
if (blk->iothread) {
s->iothread = blk->iothread;
object_ref(OBJECT(s->iothread));
} else {
object_initialize(&s->internal_iothread_obj,
sizeof(s->internal_iothread_obj),
TYPE_IOTHREAD);
user_creatable_complete(OBJECT(&s->internal_iothread_obj), &error_abort);
s->iothread = &s->internal_iothread_obj;
}
s->ctx = iothread_get_aio_context(s->iothread);
error_setg(&s->blocker, "block device is in use by data plane");
bdrv_op_block_all(blk->conf.bs, s->blocker);
*dataplane = s;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(VirtIODevice *VAR_0, VirtIOBlkConf *VAR_1,
VirtIOBlockDataPlane **VAR_2,
Error **VAR_3)
{
VirtIOBlockDataPlane *s;
Error *local_err = NULL;
*VAR_2 = NULL;
if (!VAR_1->data_plane) {
return;
}
if (VAR_1->scsi) {
error_setg(VAR_3,
"device is incompatible with x-data-plane, use scsi=off");
return;
}
if (VAR_1->config_wce) {
error_setg(VAR_3, "device is incompatible with x-data-plane, "
"use config-wce=off");
return;
}
if (bdrv_op_is_blocked(VAR_1->conf.bs, BLOCK_OP_TYPE_DATAPLANE, &local_err)) {
error_report("cannot start VAR_2 thread: %s",
error_get_pretty(local_err));
error_free(local_err);
return;
}
s = g_new0(VirtIOBlockDataPlane, 1);
s->VAR_0 = VAR_0;
s->VAR_1 = VAR_1;
if (VAR_1->iothread) {
s->iothread = VAR_1->iothread;
object_ref(OBJECT(s->iothread));
} else {
object_initialize(&s->internal_iothread_obj,
sizeof(s->internal_iothread_obj),
TYPE_IOTHREAD);
user_creatable_complete(OBJECT(&s->internal_iothread_obj), &error_abort);
s->iothread = &s->internal_iothread_obj;
}
s->ctx = iothread_get_aio_context(s->iothread);
error_setg(&s->blocker, "block device is in use by data plane");
bdrv_op_block_all(VAR_1->conf.bs, s->blocker);
*VAR_2 = s;
}
| [
"void FUNC_0(VirtIODevice *VAR_0, VirtIOBlkConf *VAR_1,\nVirtIOBlockDataPlane **VAR_2,\nError **VAR_3)\n{",
"VirtIOBlockDataPlane *s;",
"Error *local_err = NULL;",
"*VAR_2 = NULL;",
"if (!VAR_1->data_plane) {",
"return;",
"}",
"if (VAR_1->scsi) {",
"error_setg(VAR_3,\n\"device is incompatible with x... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
57
],
[
59,
61
],
[... |
14,112 | static Suite *QList_suite(void)
{
Suite *s;
TCase *qlist_public_tcase;
s = suite_create("QList suite");
qlist_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qlist_public_tcase);
tcase_add_test(qlist_public_tcase, qlist_new_test);
tcase_add_test(qlist_public_tcase, qlist_append_test);
tcase_add_test(qlist_public_tcase, qobject_to_qlist_test);
tcase_add_test(qlist_public_tcase, qlist_destroy_test);
tcase_add_test(qlist_public_tcase, qlist_iter_test);
return s;
}
| false | qemu | 91479dd0b5bd3b087b92ddd7bc3f2c54982cfe17 | static Suite *QList_suite(void)
{
Suite *s;
TCase *qlist_public_tcase;
s = suite_create("QList suite");
qlist_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qlist_public_tcase);
tcase_add_test(qlist_public_tcase, qlist_new_test);
tcase_add_test(qlist_public_tcase, qlist_append_test);
tcase_add_test(qlist_public_tcase, qobject_to_qlist_test);
tcase_add_test(qlist_public_tcase, qlist_destroy_test);
tcase_add_test(qlist_public_tcase, qlist_iter_test);
return s;
}
| {
"code": [],
"line_no": []
} | static Suite *FUNC_0(void)
{
Suite *s;
TCase *qlist_public_tcase;
s = suite_create("QList suite");
qlist_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qlist_public_tcase);
tcase_add_test(qlist_public_tcase, qlist_new_test);
tcase_add_test(qlist_public_tcase, qlist_append_test);
tcase_add_test(qlist_public_tcase, qobject_to_qlist_test);
tcase_add_test(qlist_public_tcase, qlist_destroy_test);
tcase_add_test(qlist_public_tcase, qlist_iter_test);
return s;
}
| [
"static Suite *FUNC_0(void)\n{",
"Suite *s;",
"TCase *qlist_public_tcase;",
"s = suite_create(\"QList suite\");",
"qlist_public_tcase = tcase_create(\"Public Interface\");",
"suite_add_tcase(s, qlist_public_tcase);",
"tcase_add_test(qlist_public_tcase, qlist_new_test);",
"tcase_add_test(qlist_public_t... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
]
] |
14,113 | static void spr_write_decr (DisasContext *ctx, int sprn, int gprn)
{
if (use_icount) {
gen_io_start();
}
gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
if (use_icount) {
gen_io_end();
gen_stop_exception(ctx);
}
}
| false | qemu | bd79255d2571a3c68820117caf94ea9afe1d527e | static void spr_write_decr (DisasContext *ctx, int sprn, int gprn)
{
if (use_icount) {
gen_io_start();
}
gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
if (use_icount) {
gen_io_end();
gen_stop_exception(ctx);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (DisasContext *VAR_0, int VAR_1, int VAR_2)
{
if (use_icount) {
gen_io_start();
}
gen_helper_store_decr(cpu_env, cpu_gpr[VAR_2]);
if (use_icount) {
gen_io_end();
gen_stop_exception(VAR_0);
}
}
| [
"static void FUNC_0 (DisasContext *VAR_0, int VAR_1, int VAR_2)\n{",
"if (use_icount) {",
"gen_io_start();",
"}",
"gen_helper_store_decr(cpu_env, cpu_gpr[VAR_2]);",
"if (use_icount) {",
"gen_io_end();",
"gen_stop_exception(VAR_0);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
14,114 | static inline void IRQ_resetbit(IRQQueue *q, int n_IRQ)
{
reset_bit(q->queue, n_IRQ);
}
| false | qemu | e69a17f65e9f12f33c48b04a789e49d40a8993f5 | static inline void IRQ_resetbit(IRQQueue *q, int n_IRQ)
{
reset_bit(q->queue, n_IRQ);
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(IRQQueue *VAR_0, int VAR_1)
{
reset_bit(VAR_0->queue, VAR_1);
}
| [
"static inline void FUNC_0(IRQQueue *VAR_0, int VAR_1)\n{",
"reset_bit(VAR_0->queue, VAR_1);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
14,115 | static void rtas_write_pci_config(sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
uint32_t val, size, addr;
PCIDevice *dev = find_dev(spapr, 0, rtas_ld(args, 0));
if (!dev) {
rtas_st(rets, 0, -1);
return;
}
val = rtas_ld(args, 2);
size = rtas_ld(args, 1);
addr = rtas_pci_cfgaddr(rtas_ld(args, 0));
pci_host_config_write_common(dev, addr, pci_config_size(dev), val, size);
rtas_st(rets, 0, 0);
}
| false | qemu | 88045ac55592cacc92567aa46cb6917854bf7241 | static void rtas_write_pci_config(sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
uint32_t val, size, addr;
PCIDevice *dev = find_dev(spapr, 0, rtas_ld(args, 0));
if (!dev) {
rtas_st(rets, 0, -1);
return;
}
val = rtas_ld(args, 2);
size = rtas_ld(args, 1);
addr = rtas_pci_cfgaddr(rtas_ld(args, 0));
pci_host_config_write_common(dev, addr, pci_config_size(dev), val, size);
rtas_st(rets, 0, 0);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(sPAPREnvironment *VAR_0,
uint32_t VAR_1, uint32_t VAR_2,
target_ulong VAR_3,
uint32_t VAR_4, target_ulong VAR_5)
{
uint32_t val, size, addr;
PCIDevice *dev = find_dev(VAR_0, 0, rtas_ld(VAR_3, 0));
if (!dev) {
rtas_st(VAR_5, 0, -1);
return;
}
val = rtas_ld(VAR_3, 2);
size = rtas_ld(VAR_3, 1);
addr = rtas_pci_cfgaddr(rtas_ld(VAR_3, 0));
pci_host_config_write_common(dev, addr, pci_config_size(dev), val, size);
rtas_st(VAR_5, 0, 0);
}
| [
"static void FUNC_0(sPAPREnvironment *VAR_0,\nuint32_t VAR_1, uint32_t VAR_2,\ntarget_ulong VAR_3,\nuint32_t VAR_4, target_ulong VAR_5)\n{",
"uint32_t val, size, addr;",
"PCIDevice *dev = find_dev(VAR_0, 0, rtas_ld(VAR_3, 0));",
"if (!dev) {",
"rtas_st(VAR_5, 0, -1);",
"return;",
"}",
"val = rtas_ld(V... | [
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
]
] |
14,116 | static void virtio_mmio_device_plugged(DeviceState *opaque)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
proxy->host_features |= (0x1 << VIRTIO_F_NOTIFY_ON_EMPTY);
proxy->host_features = virtio_bus_get_vdev_features(&proxy->bus,
proxy->host_features);
}
| false | qemu | 0cd09c3a6cc2230ba38c462fc410b4acce59eb6f | static void virtio_mmio_device_plugged(DeviceState *opaque)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
proxy->host_features |= (0x1 << VIRTIO_F_NOTIFY_ON_EMPTY);
proxy->host_features = virtio_bus_get_vdev_features(&proxy->bus,
proxy->host_features);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(VAR_0);
proxy->host_features |= (0x1 << VIRTIO_F_NOTIFY_ON_EMPTY);
proxy->host_features = virtio_bus_get_vdev_features(&proxy->bus,
proxy->host_features);
}
| [
"static void FUNC_0(DeviceState *VAR_0)\n{",
"VirtIOMMIOProxy *proxy = VIRTIO_MMIO(VAR_0);",
"proxy->host_features |= (0x1 << VIRTIO_F_NOTIFY_ON_EMPTY);",
"proxy->host_features = virtio_bus_get_vdev_features(&proxy->bus,\nproxy->host_features);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15
]
] |
14,117 | static void virtio_serial_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->init = virtio_serial_init_pci;
k->exit = virtio_serial_exit_pci;
k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
k->revision = VIRTIO_PCI_ABI_VERSION;
k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
dc->alias = "virtio-serial";
dc->reset = virtio_pci_reset;
dc->props = virtio_serial_properties;
}
| false | qemu | 6acbe4c6f18e7de00481ff30574262b58526de45 | static void virtio_serial_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->init = virtio_serial_init_pci;
k->exit = virtio_serial_exit_pci;
k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
k->revision = VIRTIO_PCI_ABI_VERSION;
k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
dc->alias = "virtio-serial";
dc->reset = virtio_pci_reset;
dc->props = virtio_serial_properties;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
PCIDeviceClass *k = PCI_DEVICE_CLASS(VAR_0);
k->init = virtio_serial_init_pci;
k->exit = virtio_serial_exit_pci;
k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
k->revision = VIRTIO_PCI_ABI_VERSION;
k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
dc->alias = "virtio-serial";
dc->reset = virtio_pci_reset;
dc->props = virtio_serial_properties;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"PCIDeviceClass *k = PCI_DEVICE_CLASS(VAR_0);",
"k->init = virtio_serial_init_pci;",
"k->exit = virtio_serial_exit_pci;",
"k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;",
"k->device_id = PCI_DEVICE_ID_VIR... | [
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
]
] |
14,119 | static VncServerInfo *vnc_server_info_get(VncDisplay *vd)
{
VncServerInfo *info;
Error *err = NULL;
info = g_malloc(sizeof(*info));
info->base = g_malloc(sizeof(*info->base));
vnc_init_basic_info_from_server_addr(vd->lsock, info->base, &err);
info->has_auth = true;
info->auth = g_strdup(vnc_auth_name(vd));
if (err) {
qapi_free_VncServerInfo(info);
info = NULL;
error_free(err);
}
return info;
}
| false | qemu | ddf21908961073199f3d186204da4810f2ea150b | static VncServerInfo *vnc_server_info_get(VncDisplay *vd)
{
VncServerInfo *info;
Error *err = NULL;
info = g_malloc(sizeof(*info));
info->base = g_malloc(sizeof(*info->base));
vnc_init_basic_info_from_server_addr(vd->lsock, info->base, &err);
info->has_auth = true;
info->auth = g_strdup(vnc_auth_name(vd));
if (err) {
qapi_free_VncServerInfo(info);
info = NULL;
error_free(err);
}
return info;
}
| {
"code": [],
"line_no": []
} | static VncServerInfo *FUNC_0(VncDisplay *vd)
{
VncServerInfo *info;
Error *err = NULL;
info = g_malloc(sizeof(*info));
info->base = g_malloc(sizeof(*info->base));
vnc_init_basic_info_from_server_addr(vd->lsock, info->base, &err);
info->has_auth = true;
info->auth = g_strdup(vnc_auth_name(vd));
if (err) {
qapi_free_VncServerInfo(info);
info = NULL;
error_free(err);
}
return info;
}
| [
"static VncServerInfo *FUNC_0(VncDisplay *vd)\n{",
"VncServerInfo *info;",
"Error *err = NULL;",
"info = g_malloc(sizeof(*info));",
"info->base = g_malloc(sizeof(*info->base));",
"vnc_init_basic_info_from_server_addr(vd->lsock, info->base, &err);",
"info->has_auth = true;",
"info->auth = g_strdup(vnc_... | [
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
]
] |
14,120 | static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
{
const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec;
if(!name)
return CODEC_ID_NONE;
codec = encoder ?
avcodec_find_encoder_by_name(name) :
avcodec_find_decoder_by_name(name);
if(!codec) {
fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
ffmpeg_exit(1);
}
if(codec->type != type) {
fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
ffmpeg_exit(1);
}
if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
strict > FF_COMPLIANCE_EXPERIMENTAL) {
fprintf(stderr, "%s '%s' is experimental and might produce bad "
"results.\nAdd '-strict experimental' if you want to use it.\n",
codec_string, codec->name);
codec = encoder ?
avcodec_find_encoder(codec->id) :
avcodec_find_decoder(codec->id);
if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
fprintf(stderr, "Or use the non experimental %s '%s'.\n",
codec_string, codec->name);
ffmpeg_exit(1);
}
return codec->id;
}
| false | FFmpeg | a9eb4f0899de04a3093a04f461611c6f0664398e | static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
{
const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec;
if(!name)
return CODEC_ID_NONE;
codec = encoder ?
avcodec_find_encoder_by_name(name) :
avcodec_find_decoder_by_name(name);
if(!codec) {
fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
ffmpeg_exit(1);
}
if(codec->type != type) {
fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
ffmpeg_exit(1);
}
if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
strict > FF_COMPLIANCE_EXPERIMENTAL) {
fprintf(stderr, "%s '%s' is experimental and might produce bad "
"results.\nAdd '-strict experimental' if you want to use it.\n",
codec_string, codec->name);
codec = encoder ?
avcodec_find_encoder(codec->id) :
avcodec_find_decoder(codec->id);
if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
fprintf(stderr, "Or use the non experimental %s '%s'.\n",
codec_string, codec->name);
ffmpeg_exit(1);
}
return codec->id;
}
| {
"code": [],
"line_no": []
} | static enum CodecID FUNC_0(const char *VAR_0, int VAR_1, int VAR_2, int VAR_3)
{
const char *VAR_4 = VAR_2 ? "VAR_2" : "decoder";
AVCodec *codec;
if(!VAR_0)
return CODEC_ID_NONE;
codec = VAR_2 ?
avcodec_find_encoder_by_name(VAR_0) :
avcodec_find_decoder_by_name(VAR_0);
if(!codec) {
fprintf(stderr, "Unknown %s '%s'\n", VAR_4, VAR_0);
ffmpeg_exit(1);
}
if(codec->VAR_1 != VAR_1) {
fprintf(stderr, "Invalid %s VAR_1 '%s'\n", VAR_4, VAR_0);
ffmpeg_exit(1);
}
if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
VAR_3 > FF_COMPLIANCE_EXPERIMENTAL) {
fprintf(stderr, "%s '%s' is experimental and might produce bad "
"results.\nAdd '-VAR_3 experimental' if you want to use it.\n",
VAR_4, codec->VAR_0);
codec = VAR_2 ?
avcodec_find_encoder(codec->id) :
avcodec_find_decoder(codec->id);
if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
fprintf(stderr, "Or use the non experimental %s '%s'.\n",
VAR_4, codec->VAR_0);
ffmpeg_exit(1);
}
return codec->id;
}
| [
"static enum CodecID FUNC_0(const char *VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{",
"const char *VAR_4 = VAR_2 ? \"VAR_2\" : \"decoder\";",
"AVCodec *codec;",
"if(!VAR_0)\nreturn CODEC_ID_NONE;",
"codec = VAR_2 ?\navcodec_find_encoder_by_name(VAR_0) :\navcodec_find_decoder_by_name(VAR_0);",
"if(!codec) {... | [
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... |
14,122 | static void xen_ram_init(ram_addr_t ram_size)
{
RAMBlock *new_block;
ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
new_block = qemu_mallocz(sizeof (*new_block));
pstrcpy(new_block->idstr, sizeof (new_block->idstr), "xen.ram");
new_block->host = NULL;
new_block->offset = 0;
new_block->length = ram_size;
QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
new_block->length >> TARGET_PAGE_BITS);
memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
0xff, new_block->length >> TARGET_PAGE_BITS);
if (ram_size >= 0xe0000000 ) {
above_4g_mem_size = ram_size - 0xe0000000;
below_4g_mem_size = 0xe0000000;
} else {
below_4g_mem_size = ram_size;
}
cpu_register_physical_memory(0, below_4g_mem_size, new_block->offset);
#if TARGET_PHYS_ADDR_BITS > 32
if (above_4g_mem_size > 0) {
cpu_register_physical_memory(0x100000000ULL, above_4g_mem_size,
new_block->offset + below_4g_mem_size);
}
#endif
}
| false | qemu | 8a369e20e701c9d220834e0daa027e65acd35214 | static void xen_ram_init(ram_addr_t ram_size)
{
RAMBlock *new_block;
ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
new_block = qemu_mallocz(sizeof (*new_block));
pstrcpy(new_block->idstr, sizeof (new_block->idstr), "xen.ram");
new_block->host = NULL;
new_block->offset = 0;
new_block->length = ram_size;
QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
new_block->length >> TARGET_PAGE_BITS);
memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
0xff, new_block->length >> TARGET_PAGE_BITS);
if (ram_size >= 0xe0000000 ) {
above_4g_mem_size = ram_size - 0xe0000000;
below_4g_mem_size = 0xe0000000;
} else {
below_4g_mem_size = ram_size;
}
cpu_register_physical_memory(0, below_4g_mem_size, new_block->offset);
#if TARGET_PHYS_ADDR_BITS > 32
if (above_4g_mem_size > 0) {
cpu_register_physical_memory(0x100000000ULL, above_4g_mem_size,
new_block->offset + below_4g_mem_size);
}
#endif
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ram_addr_t VAR_0)
{
RAMBlock *new_block;
ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
new_block = qemu_mallocz(sizeof (*new_block));
pstrcpy(new_block->idstr, sizeof (new_block->idstr), "xen.ram");
new_block->host = NULL;
new_block->offset = 0;
new_block->length = VAR_0;
QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
new_block->length >> TARGET_PAGE_BITS);
memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
0xff, new_block->length >> TARGET_PAGE_BITS);
if (VAR_0 >= 0xe0000000 ) {
above_4g_mem_size = VAR_0 - 0xe0000000;
below_4g_mem_size = 0xe0000000;
} else {
below_4g_mem_size = VAR_0;
}
cpu_register_physical_memory(0, below_4g_mem_size, new_block->offset);
#if TARGET_PHYS_ADDR_BITS > 32
if (above_4g_mem_size > 0) {
cpu_register_physical_memory(0x100000000ULL, above_4g_mem_size,
new_block->offset + below_4g_mem_size);
}
#endif
}
| [
"static void FUNC_0(ram_addr_t VAR_0)\n{",
"RAMBlock *new_block;",
"ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;",
"new_block = qemu_mallocz(sizeof (*new_block));",
"pstrcpy(new_block->idstr, sizeof (new_block->idstr), \"xen.ram\");",
"new_block->host = NULL;",
"new_block->offset = 0;",
"new_b... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
27,
29
],
[
31,
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53... |
14,123 | static int tight_init_stream(VncState *vs, int stream_id,
int level, int strategy)
{
z_streamp zstream = &vs->tight_stream[stream_id];
if (zstream->opaque == NULL) {
int err;
VNC_DEBUG("VNC: TIGHT: initializing zlib stream %d\n", stream_id);
VNC_DEBUG("VNC: TIGHT: opaque = %p | vs = %p\n", zstream->opaque, vs);
zstream->zalloc = vnc_zlib_zalloc;
zstream->zfree = vnc_zlib_zfree;
err = deflateInit2(zstream, level, Z_DEFLATED, MAX_WBITS,
MAX_MEM_LEVEL, strategy);
if (err != Z_OK) {
fprintf(stderr, "VNC: error initializing zlib\n");
return -1;
}
vs->tight_levels[stream_id] = level;
zstream->opaque = vs;
}
if (vs->tight_levels[stream_id] != level) {
if (deflateParams(zstream, level, strategy) != Z_OK) {
return -1;
}
vs->tight_levels[stream_id] = level;
}
return 0;
}
| false | qemu | 245f7b51c0ea04fb2224b1127430a096c91aee70 | static int tight_init_stream(VncState *vs, int stream_id,
int level, int strategy)
{
z_streamp zstream = &vs->tight_stream[stream_id];
if (zstream->opaque == NULL) {
int err;
VNC_DEBUG("VNC: TIGHT: initializing zlib stream %d\n", stream_id);
VNC_DEBUG("VNC: TIGHT: opaque = %p | vs = %p\n", zstream->opaque, vs);
zstream->zalloc = vnc_zlib_zalloc;
zstream->zfree = vnc_zlib_zfree;
err = deflateInit2(zstream, level, Z_DEFLATED, MAX_WBITS,
MAX_MEM_LEVEL, strategy);
if (err != Z_OK) {
fprintf(stderr, "VNC: error initializing zlib\n");
return -1;
}
vs->tight_levels[stream_id] = level;
zstream->opaque = vs;
}
if (vs->tight_levels[stream_id] != level) {
if (deflateParams(zstream, level, strategy) != Z_OK) {
return -1;
}
vs->tight_levels[stream_id] = level;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(VncState *VAR_0, int VAR_1,
int VAR_2, int VAR_3)
{
z_streamp zstream = &VAR_0->tight_stream[VAR_1];
if (zstream->opaque == NULL) {
int VAR_4;
VNC_DEBUG("VNC: TIGHT: initializing zlib stream %d\n", VAR_1);
VNC_DEBUG("VNC: TIGHT: opaque = %p | VAR_0 = %p\n", zstream->opaque, VAR_0);
zstream->zalloc = vnc_zlib_zalloc;
zstream->zfree = vnc_zlib_zfree;
VAR_4 = deflateInit2(zstream, VAR_2, Z_DEFLATED, MAX_WBITS,
MAX_MEM_LEVEL, VAR_3);
if (VAR_4 != Z_OK) {
fprintf(stderr, "VNC: error initializing zlib\n");
return -1;
}
VAR_0->tight_levels[VAR_1] = VAR_2;
zstream->opaque = VAR_0;
}
if (VAR_0->tight_levels[VAR_1] != VAR_2) {
if (deflateParams(zstream, VAR_2, VAR_3) != Z_OK) {
return -1;
}
VAR_0->tight_levels[VAR_1] = VAR_2;
}
return 0;
}
| [
"static int FUNC_0(VncState *VAR_0, int VAR_1,\nint VAR_2, int VAR_3)\n{",
"z_streamp zstream = &VAR_0->tight_stream[VAR_1];",
"if (zstream->opaque == NULL) {",
"int VAR_4;",
"VNC_DEBUG(\"VNC: TIGHT: initializing zlib stream %d\\n\", VAR_1);",
"VNC_DEBUG(\"VNC: TIGHT: opaque = %p | VAR_0 = %p\\n\", zstrea... | [
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
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27,
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55... |
14,124 | static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
{
ReadInfo *read_info = (ReadInfo *) sccb;
MachineState *machine = MACHINE(qdev_get_machine());
sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
CPUState *cpu;
int cpu_count = 0;
int rnsize, rnmax;
int slots = MIN(machine->ram_slots, s390_get_memslot_count(kvm_state));
IplParameterBlock *ipib = s390_ipl_get_iplb();
CPU_FOREACH(cpu) {
cpu_count++;
}
/* CPU information */
read_info->entries_cpu = cpu_to_be16(cpu_count);
read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries));
read_info->highest_cpu = cpu_to_be16(max_cpus);
read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
/* Configuration Characteristic (Extension) */
s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR,
read_info->conf_char);
s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
read_info->conf_char_ext);
prepare_cpu_entries(sclp, read_info->entries, cpu_count);
read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
SCLP_HAS_PCI_RECONFIG);
/* Memory Hotplug is only supported for the ccw machine type */
if (mhd) {
mhd->standby_subregion_size = MEM_SECTION_SIZE;
/* Deduct the memory slot already used for core */
if (slots > 0) {
while ((mhd->standby_subregion_size * (slots - 1)
< mhd->standby_mem_size)) {
mhd->standby_subregion_size = mhd->standby_subregion_size << 1;
}
}
/*
* Initialize mapping of guest standby memory sections indicating which
* are and are not online. Assume all standby memory begins offline.
*/
if (mhd->standby_state_map == 0) {
if (mhd->standby_mem_size % mhd->standby_subregion_size) {
mhd->standby_state_map = g_malloc0((mhd->standby_mem_size /
mhd->standby_subregion_size + 1) *
(mhd->standby_subregion_size /
MEM_SECTION_SIZE));
} else {
mhd->standby_state_map = g_malloc0(mhd->standby_mem_size /
MEM_SECTION_SIZE);
}
}
mhd->padded_ram_size = ram_size + mhd->pad_size;
mhd->rzm = 1 << mhd->increment_size;
read_info->facilities |= cpu_to_be64(SCLP_FC_ASSIGN_ATTACH_READ_STOR);
}
read_info->mha_pow = s390_get_mha_pow();
read_info->hmfai = cpu_to_be32(s390_get_hmfai());
rnsize = 1 << (sclp->increment_size - 20);
if (rnsize <= 128) {
read_info->rnsize = rnsize;
} else {
read_info->rnsize = 0;
read_info->rnsize2 = cpu_to_be32(rnsize);
}
rnmax = machine->maxram_size >> sclp->increment_size;
if (rnmax < 0x10000) {
read_info->rnmax = cpu_to_be16(rnmax);
} else {
read_info->rnmax = cpu_to_be16(0);
read_info->rnmax2 = cpu_to_be64(rnmax);
}
if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) {
memcpy(&read_info->loadparm, &ipib->loadparm,
sizeof(read_info->loadparm));
} else {
s390_ipl_set_loadparm(read_info->loadparm);
}
sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
}
| false | qemu | 80b7a265362c870f95fb5ca1f7e7a02c0fa0db3e | static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
{
ReadInfo *read_info = (ReadInfo *) sccb;
MachineState *machine = MACHINE(qdev_get_machine());
sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
CPUState *cpu;
int cpu_count = 0;
int rnsize, rnmax;
int slots = MIN(machine->ram_slots, s390_get_memslot_count(kvm_state));
IplParameterBlock *ipib = s390_ipl_get_iplb();
CPU_FOREACH(cpu) {
cpu_count++;
}
read_info->entries_cpu = cpu_to_be16(cpu_count);
read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries));
read_info->highest_cpu = cpu_to_be16(max_cpus);
read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR,
read_info->conf_char);
s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
read_info->conf_char_ext);
prepare_cpu_entries(sclp, read_info->entries, cpu_count);
read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
SCLP_HAS_PCI_RECONFIG);
if (mhd) {
mhd->standby_subregion_size = MEM_SECTION_SIZE;
if (slots > 0) {
while ((mhd->standby_subregion_size * (slots - 1)
< mhd->standby_mem_size)) {
mhd->standby_subregion_size = mhd->standby_subregion_size << 1;
}
}
if (mhd->standby_state_map == 0) {
if (mhd->standby_mem_size % mhd->standby_subregion_size) {
mhd->standby_state_map = g_malloc0((mhd->standby_mem_size /
mhd->standby_subregion_size + 1) *
(mhd->standby_subregion_size /
MEM_SECTION_SIZE));
} else {
mhd->standby_state_map = g_malloc0(mhd->standby_mem_size /
MEM_SECTION_SIZE);
}
}
mhd->padded_ram_size = ram_size + mhd->pad_size;
mhd->rzm = 1 << mhd->increment_size;
read_info->facilities |= cpu_to_be64(SCLP_FC_ASSIGN_ATTACH_READ_STOR);
}
read_info->mha_pow = s390_get_mha_pow();
read_info->hmfai = cpu_to_be32(s390_get_hmfai());
rnsize = 1 << (sclp->increment_size - 20);
if (rnsize <= 128) {
read_info->rnsize = rnsize;
} else {
read_info->rnsize = 0;
read_info->rnsize2 = cpu_to_be32(rnsize);
}
rnmax = machine->maxram_size >> sclp->increment_size;
if (rnmax < 0x10000) {
read_info->rnmax = cpu_to_be16(rnmax);
} else {
read_info->rnmax = cpu_to_be16(0);
read_info->rnmax2 = cpu_to_be64(rnmax);
}
if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) {
memcpy(&read_info->loadparm, &ipib->loadparm,
sizeof(read_info->loadparm));
} else {
s390_ipl_set_loadparm(read_info->loadparm);
}
sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(SCLPDevice *VAR_0, SCCB *VAR_1)
{
ReadInfo *read_info = (ReadInfo *) VAR_1;
MachineState *machine = MACHINE(qdev_get_machine());
sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
CPUState *cpu;
int VAR_2 = 0;
int VAR_3, VAR_4;
int VAR_5 = MIN(machine->ram_slots, s390_get_memslot_count(kvm_state));
IplParameterBlock *ipib = s390_ipl_get_iplb();
CPU_FOREACH(cpu) {
VAR_2++;
}
read_info->entries_cpu = cpu_to_be16(VAR_2);
read_info->offset_cpu = cpu_to_be16(offsetof(ReadInfo, entries));
read_info->highest_cpu = cpu_to_be16(max_cpus);
read_info->ibc_val = cpu_to_be32(s390_get_ibc_val());
s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR,
read_info->conf_char);
s390_get_feat_block(S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
read_info->conf_char_ext);
prepare_cpu_entries(VAR_0, read_info->entries, VAR_2);
read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
SCLP_HAS_PCI_RECONFIG);
if (mhd) {
mhd->standby_subregion_size = MEM_SECTION_SIZE;
if (VAR_5 > 0) {
while ((mhd->standby_subregion_size * (VAR_5 - 1)
< mhd->standby_mem_size)) {
mhd->standby_subregion_size = mhd->standby_subregion_size << 1;
}
}
if (mhd->standby_state_map == 0) {
if (mhd->standby_mem_size % mhd->standby_subregion_size) {
mhd->standby_state_map = g_malloc0((mhd->standby_mem_size /
mhd->standby_subregion_size + 1) *
(mhd->standby_subregion_size /
MEM_SECTION_SIZE));
} else {
mhd->standby_state_map = g_malloc0(mhd->standby_mem_size /
MEM_SECTION_SIZE);
}
}
mhd->padded_ram_size = ram_size + mhd->pad_size;
mhd->rzm = 1 << mhd->increment_size;
read_info->facilities |= cpu_to_be64(SCLP_FC_ASSIGN_ATTACH_READ_STOR);
}
read_info->mha_pow = s390_get_mha_pow();
read_info->hmfai = cpu_to_be32(s390_get_hmfai());
VAR_3 = 1 << (VAR_0->increment_size - 20);
if (VAR_3 <= 128) {
read_info->VAR_3 = VAR_3;
} else {
read_info->VAR_3 = 0;
read_info->rnsize2 = cpu_to_be32(VAR_3);
}
VAR_4 = machine->maxram_size >> VAR_0->increment_size;
if (VAR_4 < 0x10000) {
read_info->VAR_4 = cpu_to_be16(VAR_4);
} else {
read_info->VAR_4 = cpu_to_be16(0);
read_info->rnmax2 = cpu_to_be64(VAR_4);
}
if (ipib && ipib->flags & DIAG308_FLAGS_LP_VALID) {
memcpy(&read_info->loadparm, &ipib->loadparm,
sizeof(read_info->loadparm));
} else {
s390_ipl_set_loadparm(read_info->loadparm);
}
VAR_1->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
}
| [
"static void FUNC_0(SCLPDevice *VAR_0, SCCB *VAR_1)\n{",
"ReadInfo *read_info = (ReadInfo *) VAR_1;",
"MachineState *machine = MACHINE(qdev_get_machine());",
"sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();",
"CPUState *cpu;",
"int VAR_2 = 0;",
"int VAR_3, VAR_4;",
"int VAR_5 = MIN(machine-... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
33
],
[
35
],
[
37
],
[
41
],
[
47,
49
],
[
51,
53
],
[
57
... |
14,125 | static void init_proc_970GX (CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
/* Time base */
gen_tbl(env);
/* Hardware implementation registers */
/* XXX : not implemented */
spr_register(env, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_clear,
0x60000000);
/* XXX : not implemented */
spr_register(env, SPR_HID1, "HID1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_HID2, "HID2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_970_HID5, "HID5",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* Memory management */
/* XXX: not correct */
gen_low_BATs(env);
#if 0 // TODO
env->slb_nr = 32;
#endif
init_excp_970(env);
env->dcache_line_size = 128;
env->icache_line_size = 128;
/* Allocate hardware IRQ controller */
ppc970_irq_init(env);
#if !defined(CONFIG_USER_ONLY)
/* Hardware reset vector */
env->hreset_vector = 0x0000000000000100ULL;
#endif
}
| false | qemu | e57448f11cb29c9b36acd117349070fe290465fa | static void init_proc_970GX (CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
gen_tbl(env);
spr_register(env, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_clear,
0x60000000);
spr_register(env, SPR_HID1, "HID1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_HID2, "HID2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_970_HID5, "HID5",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
gen_low_BATs(env);
#if 0
env->slb_nr = 32;
#endif
init_excp_970(env);
env->dcache_line_size = 128;
env->icache_line_size = 128;
ppc970_irq_init(env);
#if !defined(CONFIG_USER_ONLY)
env->hreset_vector = 0x0000000000000100ULL;
#endif
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (CPUPPCState *VAR_0)
{
gen_spr_ne_601(VAR_0);
gen_spr_7xx(VAR_0);
gen_tbl(VAR_0);
spr_register(VAR_0, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_clear,
0x60000000);
spr_register(VAR_0, SPR_HID1, "HID1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_HID2, "HID2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_970_HID5, "HID5",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
gen_low_BATs(VAR_0);
#if 0
VAR_0->slb_nr = 32;
#endif
init_excp_970(VAR_0);
VAR_0->dcache_line_size = 128;
VAR_0->icache_line_size = 128;
ppc970_irq_init(VAR_0);
#if !defined(CONFIG_USER_ONLY)
VAR_0->hreset_vector = 0x0000000000000100ULL;
#endif
}
| [
"static void FUNC_0 (CPUPPCState *VAR_0)\n{",
"gen_spr_ne_601(VAR_0);",
"gen_spr_7xx(VAR_0);",
"gen_tbl(VAR_0);",
"spr_register(VAR_0, SPR_HID0, \"HID0\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, &spr_write_clear,\n0x60000000);",
"spr_register(VAR_0, SPR_HID1, \"HID1\",\nSPR_NOACCESS, SPR_NOACCESS... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
17,
19,
21,
23
],
[
27,
29,
31,
33
],
[
37,
39,
41,
43
],
[
47,
49,
51,
53
],
[
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
71... |
14,127 | static void QEMU_NORETURN force_sig(int sig)
{
int host_sig;
host_sig = target_to_host_signal(sig);
fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
sig, strsignal(host_sig));
#if 1
gdb_signalled(thread_env, sig);
_exit(-host_sig);
#else
{
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = SIG_DFL;
sigaction(SIGABRT, &act, NULL);
abort();
}
#endif
}
| false | qemu | 603e4fd7b1e034f79181a53df9719818f80ba364 | static void QEMU_NORETURN force_sig(int sig)
{
int host_sig;
host_sig = target_to_host_signal(sig);
fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
sig, strsignal(host_sig));
#if 1
gdb_signalled(thread_env, sig);
_exit(-host_sig);
#else
{
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = SIG_DFL;
sigaction(SIGABRT, &act, NULL);
abort();
}
#endif
}
| {
"code": [],
"line_no": []
} | static void VAR_0 force_sig(int sig)
{
int host_sig;
host_sig = target_to_host_signal(sig);
fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
sig, strsignal(host_sig));
#if 1
gdb_signalled(thread_env, sig);
_exit(-host_sig);
#else
{
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = SIG_DFL;
sigaction(SIGABRT, &act, NULL);
abort();
}
#endif
}
| [
"static void VAR_0 force_sig(int sig)\n{",
"int host_sig;",
"host_sig = target_to_host_signal(sig);",
"fprintf(stderr, \"qemu: uncaught target signal %d (%s) - exiting\\n\",\nsig, strsignal(host_sig));",
"#if 1\ngdb_signalled(thread_env, sig);",
"_exit(-host_sig);",
"#else\n{",
"struct sigaction act;"... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9,
11
],
[
13,
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
]
] |
14,128 | static void sd_close(BlockDriverState *bs)
{
Error *local_err = NULL;
BDRVSheepdogState *s = bs->opaque;
SheepdogVdiReq hdr;
SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
unsigned int wlen, rlen = 0;
int fd, ret;
DPRINTF("%s\n", s->name);
fd = connect_to_sdog(s, &local_err);
if (fd < 0) {
error_report_err(local_err);
return;
}
memset(&hdr, 0, sizeof(hdr));
hdr.opcode = SD_OP_RELEASE_VDI;
hdr.type = LOCK_TYPE_NORMAL;
hdr.base_vdi_id = s->inode.vdi_id;
wlen = strlen(s->name) + 1;
hdr.data_length = wlen;
hdr.flags = SD_FLAG_CMD_WRITE;
ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
s->name, &wlen, &rlen);
closesocket(fd);
if (!ret && rsp->result != SD_RES_SUCCESS &&
rsp->result != SD_RES_VDI_NOT_LOCKED) {
error_report("%s, %s", sd_strerror(rsp->result), s->name);
}
aio_set_fd_handler(bdrv_get_aio_context(bs), s->fd,
false, NULL, NULL, NULL, NULL);
closesocket(s->fd);
qapi_free_SocketAddressLegacy(s->addr);
}
| false | qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | static void sd_close(BlockDriverState *bs)
{
Error *local_err = NULL;
BDRVSheepdogState *s = bs->opaque;
SheepdogVdiReq hdr;
SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
unsigned int wlen, rlen = 0;
int fd, ret;
DPRINTF("%s\n", s->name);
fd = connect_to_sdog(s, &local_err);
if (fd < 0) {
error_report_err(local_err);
return;
}
memset(&hdr, 0, sizeof(hdr));
hdr.opcode = SD_OP_RELEASE_VDI;
hdr.type = LOCK_TYPE_NORMAL;
hdr.base_vdi_id = s->inode.vdi_id;
wlen = strlen(s->name) + 1;
hdr.data_length = wlen;
hdr.flags = SD_FLAG_CMD_WRITE;
ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
s->name, &wlen, &rlen);
closesocket(fd);
if (!ret && rsp->result != SD_RES_SUCCESS &&
rsp->result != SD_RES_VDI_NOT_LOCKED) {
error_report("%s, %s", sd_strerror(rsp->result), s->name);
}
aio_set_fd_handler(bdrv_get_aio_context(bs), s->fd,
false, NULL, NULL, NULL, NULL);
closesocket(s->fd);
qapi_free_SocketAddressLegacy(s->addr);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(BlockDriverState *VAR_0)
{
Error *local_err = NULL;
BDRVSheepdogState *s = VAR_0->opaque;
SheepdogVdiReq hdr;
SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
unsigned int VAR_1, VAR_2 = 0;
int VAR_3, VAR_4;
DPRINTF("%s\n", s->name);
VAR_3 = connect_to_sdog(s, &local_err);
if (VAR_3 < 0) {
error_report_err(local_err);
return;
}
memset(&hdr, 0, sizeof(hdr));
hdr.opcode = SD_OP_RELEASE_VDI;
hdr.type = LOCK_TYPE_NORMAL;
hdr.base_vdi_id = s->inode.vdi_id;
VAR_1 = strlen(s->name) + 1;
hdr.data_length = VAR_1;
hdr.flags = SD_FLAG_CMD_WRITE;
VAR_4 = do_req(VAR_3, s->VAR_0, (SheepdogReq *)&hdr,
s->name, &VAR_1, &VAR_2);
closesocket(VAR_3);
if (!VAR_4 && rsp->result != SD_RES_SUCCESS &&
rsp->result != SD_RES_VDI_NOT_LOCKED) {
error_report("%s, %s", sd_strerror(rsp->result), s->name);
}
aio_set_fd_handler(bdrv_get_aio_context(VAR_0), s->VAR_3,
false, NULL, NULL, NULL, NULL);
closesocket(s->VAR_3);
qapi_free_SocketAddressLegacy(s->addr);
}
| [
"static void FUNC_0(BlockDriverState *VAR_0)\n{",
"Error *local_err = NULL;",
"BDRVSheepdogState *s = VAR_0->opaque;",
"SheepdogVdiReq hdr;",
"SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;",
"unsigned int VAR_1, VAR_2 = 0;",
"int VAR_3, VAR_4;",
"DPRINTF(\"%s\\n\", s->name);",
"VAR_3 = connect_to_sd... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
... |
14,129 | static uint64_t malta_fpga_read(void *opaque, hwaddr addr,
unsigned size)
{
MaltaFPGAState *s = opaque;
uint32_t val = 0;
uint32_t saddr;
saddr = (addr & 0xfffff);
switch (saddr) {
/* SWITCH Register */
case 0x00200:
val = 0x00000000; /* All switches closed */
break;
/* STATUS Register */
case 0x00208:
#ifdef TARGET_WORDS_BIGENDIAN
val = 0x00000012;
#else
val = 0x00000010;
#endif
break;
/* JMPRS Register */
case 0x00210:
val = 0x00;
break;
/* LEDBAR Register */
case 0x00408:
val = s->leds;
break;
/* BRKRES Register */
case 0x00508:
val = s->brk;
break;
/* UART Registers are handled directly by the serial device */
/* GPOUT Register */
case 0x00a00:
val = s->gpout;
break;
/* XXX: implement a real I2C controller */
/* GPINP Register */
case 0x00a08:
/* IN = OUT until a real I2C control is implemented */
if (s->i2csel)
val = s->i2cout;
else
val = 0x00;
break;
/* I2CINP Register */
case 0x00b00:
val = ((s->i2cin & ~1) | eeprom24c0x_read());
break;
/* I2COE Register */
case 0x00b08:
val = s->i2coe;
break;
/* I2COUT Register */
case 0x00b10:
val = s->i2cout;
break;
/* I2CSEL Register */
case 0x00b18:
val = s->i2csel;
break;
default:
#if 0
printf ("malta_fpga_read: Bad register offset 0x" TARGET_FMT_lx "\n",
addr);
#endif
break;
}
return val;
}
| false | qemu | 35c648078aa493c3b976840eb7cf2e53ab5b7a2d | static uint64_t malta_fpga_read(void *opaque, hwaddr addr,
unsigned size)
{
MaltaFPGAState *s = opaque;
uint32_t val = 0;
uint32_t saddr;
saddr = (addr & 0xfffff);
switch (saddr) {
case 0x00200:
val = 0x00000000;
break;
case 0x00208:
#ifdef TARGET_WORDS_BIGENDIAN
val = 0x00000012;
#else
val = 0x00000010;
#endif
break;
case 0x00210:
val = 0x00;
break;
case 0x00408:
val = s->leds;
break;
case 0x00508:
val = s->brk;
break;
case 0x00a00:
val = s->gpout;
break;
case 0x00a08:
if (s->i2csel)
val = s->i2cout;
else
val = 0x00;
break;
case 0x00b00:
val = ((s->i2cin & ~1) | eeprom24c0x_read());
break;
case 0x00b08:
val = s->i2coe;
break;
case 0x00b10:
val = s->i2cout;
break;
case 0x00b18:
val = s->i2csel;
break;
default:
#if 0
printf ("malta_fpga_read: Bad register offset 0x" TARGET_FMT_lx "\n",
addr);
#endif
break;
}
return val;
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(void *opaque, hwaddr addr,
unsigned size)
{
MaltaFPGAState *s = opaque;
uint32_t val = 0;
uint32_t saddr;
saddr = (addr & 0xfffff);
switch (saddr) {
case 0x00200:
val = 0x00000000;
break;
case 0x00208:
#ifdef TARGET_WORDS_BIGENDIAN
val = 0x00000012;
#else
val = 0x00000010;
#endif
break;
case 0x00210:
val = 0x00;
break;
case 0x00408:
val = s->leds;
break;
case 0x00508:
val = s->brk;
break;
case 0x00a00:
val = s->gpout;
break;
case 0x00a08:
if (s->i2csel)
val = s->i2cout;
else
val = 0x00;
break;
case 0x00b00:
val = ((s->i2cin & ~1) | eeprom24c0x_read());
break;
case 0x00b08:
val = s->i2coe;
break;
case 0x00b10:
val = s->i2cout;
break;
case 0x00b18:
val = s->i2csel;
break;
default:
#if 0
printf ("FUNC_0: Bad register offset 0x" TARGET_FMT_lx "\n",
addr);
#endif
break;
}
return val;
}
| [
"static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{",
"MaltaFPGAState *s = opaque;",
"uint32_t val = 0;",
"uint32_t saddr;",
"saddr = (addr & 0xfffff);",
"switch (saddr) {",
"case 0x00200:\nval = 0x00000000;",
"break;",
"case 0x00208:\n#ifdef TARGET_WORDS_BIGENDIAN\nval = 0x0000001... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
25,
27
],
[
29
],
[
35,
37,
39
],
[
41,
43
],
[
45,
47
],
[
53,
55
],
[
57
],
[
63,
65
],
[
67
],
[
73,... |
14,131 | static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
{
MpegEncContext *s = &ctx->m;
int time_incr, time_increment;
int64_t pts;
s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* pict type: I = 0 , P = 1 */
if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
ctx->vol_control_parameters == 0 && !(s->flags & CODEC_FLAG_LOW_DELAY)) {
av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
s->low_delay = 0;
}
s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
if (s->partitioned_frame)
s->decode_mb = mpeg4_decode_partitioned_mb;
else
s->decode_mb = mpeg4_decode_mb;
time_incr = 0;
while (get_bits1(gb) != 0)
time_incr++;
check_marker(gb, "before time_increment");
if (ctx->time_increment_bits == 0 ||
!(show_bits(gb, ctx->time_increment_bits + 1) & 1)) {
av_log(s->avctx, AV_LOG_WARNING,
"time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n", ctx->time_increment_bits);
for (ctx->time_increment_bits = 1;
ctx->time_increment_bits < 16;
ctx->time_increment_bits++) {
if (s->pict_type == AV_PICTURE_TYPE_P ||
(s->pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE)) {
if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
break;
} else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
break;
}
av_log(s->avctx, AV_LOG_WARNING,
"time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits);
if (s->avctx->framerate.num && 4*s->avctx->framerate.num < 1<<ctx->time_increment_bits) {
s->avctx->framerate.num = 1<<ctx->time_increment_bits;
s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
}
}
if (IS_3IV1)
time_increment = get_bits1(gb); // FIXME investigate further
else
time_increment = get_bits(gb, ctx->time_increment_bits);
if (s->pict_type != AV_PICTURE_TYPE_B) {
s->last_time_base = s->time_base;
s->time_base += time_incr;
s->time = s->time_base * s->avctx->framerate.num + time_increment;
if (s->workaround_bugs & FF_BUG_UMP4) {
if (s->time < s->last_non_b_time) {
/* header is not mpeg-4-compatible, broken encoder,
* trying to workaround */
s->time_base++;
s->time += s->avctx->framerate.num;
}
}
s->pp_time = s->time - s->last_non_b_time;
s->last_non_b_time = s->time;
} else {
s->time = (s->last_time_base + time_incr) * s->avctx->framerate.num + time_increment;
s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
if (s->pp_time <= s->pb_time ||
s->pp_time <= s->pp_time - s->pb_time ||
s->pp_time <= 0) {
/* messed up order, maybe after seeking? skipping current b-frame */
return FRAME_SKIPPED;
}
ff_mpeg4_init_direct_mv(s);
if (ctx->t_frame == 0)
ctx->t_frame = s->pb_time;
if (ctx->t_frame == 0)
ctx->t_frame = 1; // 1/0 protection
s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, ctx->t_frame) -
ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
s->pb_field_time = (ROUNDED_DIV(s->time, ctx->t_frame) -
ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) {
s->pb_field_time = 2;
s->pp_field_time = 4;
if (!s->progressive_sequence)
return FRAME_SKIPPED;
}
}
if (s->avctx->framerate.den)
pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
else
pts = AV_NOPTS_VALUE;
if (s->avctx->debug&FF_DEBUG_PTS)
av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
pts);
check_marker(gb, "before vop_coded");
/* vop coded */
if (get_bits1(gb) != 1) {
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
return FRAME_SKIPPED;
}
if (ctx->new_pred)
decode_new_pred(ctx, gb);
if (ctx->shape != BIN_ONLY_SHAPE &&
(s->pict_type == AV_PICTURE_TYPE_P ||
(s->pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE))) {
/* rounding type for motion estimation */
s->no_rounding = get_bits1(gb);
} else {
s->no_rounding = 0;
}
// FIXME reduced res stuff
if (ctx->shape != RECT_SHAPE) {
if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
skip_bits(gb, 13); /* width */
skip_bits1(gb); /* marker */
skip_bits(gb, 13); /* height */
skip_bits1(gb); /* marker */
skip_bits(gb, 13); /* hor_spat_ref */
skip_bits1(gb); /* marker */
skip_bits(gb, 13); /* ver_spat_ref */
}
skip_bits1(gb); /* change_CR_disable */
if (get_bits1(gb) != 0)
skip_bits(gb, 8); /* constant_alpha_value */
}
// FIXME complexity estimation stuff
if (ctx->shape != BIN_ONLY_SHAPE) {
skip_bits_long(gb, ctx->cplx_estimation_trash_i);
if (s->pict_type != AV_PICTURE_TYPE_I)
skip_bits_long(gb, ctx->cplx_estimation_trash_p);
if (s->pict_type == AV_PICTURE_TYPE_B)
skip_bits_long(gb, ctx->cplx_estimation_trash_b);
if (get_bits_left(gb) < 3) {
av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
return AVERROR_INVALIDDATA;
}
ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
if (!s->progressive_sequence) {
s->top_field_first = get_bits1(gb);
s->alternate_scan = get_bits1(gb);
} else
s->alternate_scan = 0;
}
if (s->alternate_scan) {
ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
} else {
ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
}
if (s->pict_type == AV_PICTURE_TYPE_S &&
(ctx->vol_sprite_usage == STATIC_SPRITE ||
ctx->vol_sprite_usage == GMC_SPRITE)) {
if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
return AVERROR_INVALIDDATA;
if (ctx->sprite_brightness_change)
av_log(s->avctx, AV_LOG_ERROR,
"sprite_brightness_change not supported\n");
if (ctx->vol_sprite_usage == STATIC_SPRITE)
av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
}
if (ctx->shape != BIN_ONLY_SHAPE) {
s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (qscale=0)\n");
return AVERROR_INVALIDDATA; // makes no sense to continue, as there is nothing left from the image then
}
if (s->pict_type != AV_PICTURE_TYPE_I) {
s->f_code = get_bits(gb, 3); /* fcode_for */
if (s->f_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (f_code=0)\n");
s->f_code = 1;
return AVERROR_INVALIDDATA; // makes no sense to continue, as there is nothing left from the image then
}
} else
s->f_code = 1;
if (s->pict_type == AV_PICTURE_TYPE_B) {
s->b_code = get_bits(gb, 3);
if (s->b_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (b_code=0)\n");
s->b_code=1;
return AVERROR_INVALIDDATA; // makes no sense to continue, as the MV decoding will break very quickly
}
} else
s->b_code = 1;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG,
"qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64" tincr:%d\n",
s->qscale, s->f_code, s->b_code,
s->pict_type == AV_PICTURE_TYPE_I ? "I" : (s->pict_type == AV_PICTURE_TYPE_P ? "P" : (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
s->top_field_first, s->quarter_sample ? "q" : "h",
s->data_partitioning, ctx->resync_marker,
ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
1 - s->no_rounding, s->vo_type,
ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
ctx->cplx_estimation_trash_b,
s->time,
time_increment
);
}
if (!ctx->scalability) {
if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
skip_bits1(gb); // vop shape coding type
} else {
if (ctx->enhancement_type) {
int load_backward_shape = get_bits1(gb);
if (load_backward_shape)
av_log(s->avctx, AV_LOG_ERROR,
"load backward shape isn't supported\n");
}
skip_bits(gb, 2); // ref_select_code
}
}
/* detect buggy encoders which don't set the low_delay flag
* (divx4/xvid/opendivx). Note we cannot detect divx5 without b-frames
* easily (although it's buggy too) */
if (s->vo_type == 0 && ctx->vol_control_parameters == 0 &&
ctx->divx_version == -1 && s->picture_number == 0) {
av_log(s->avctx, AV_LOG_WARNING,
"looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
s->low_delay = 1;
}
s->picture_number++; // better than pic number==0 always ;)
// FIXME add short header support
s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;
if (s->workaround_bugs & FF_BUG_EDGE) {
s->h_edge_pos = s->width;
s->v_edge_pos = s->height;
}
return 0;
}
| false | FFmpeg | 9a0f60a0f89a7a71839dfa9def5a26f2037aed62 | static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
{
MpegEncContext *s = &ctx->m;
int time_incr, time_increment;
int64_t pts;
s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;
if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
ctx->vol_control_parameters == 0 && !(s->flags & CODEC_FLAG_LOW_DELAY)) {
av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
s->low_delay = 0;
}
s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
if (s->partitioned_frame)
s->decode_mb = mpeg4_decode_partitioned_mb;
else
s->decode_mb = mpeg4_decode_mb;
time_incr = 0;
while (get_bits1(gb) != 0)
time_incr++;
check_marker(gb, "before time_increment");
if (ctx->time_increment_bits == 0 ||
!(show_bits(gb, ctx->time_increment_bits + 1) & 1)) {
av_log(s->avctx, AV_LOG_WARNING,
"time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n", ctx->time_increment_bits);
for (ctx->time_increment_bits = 1;
ctx->time_increment_bits < 16;
ctx->time_increment_bits++) {
if (s->pict_type == AV_PICTURE_TYPE_P ||
(s->pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE)) {
if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
break;
} else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
break;
}
av_log(s->avctx, AV_LOG_WARNING,
"time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits);
if (s->avctx->framerate.num && 4*s->avctx->framerate.num < 1<<ctx->time_increment_bits) {
s->avctx->framerate.num = 1<<ctx->time_increment_bits;
s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
}
}
if (IS_3IV1)
time_increment = get_bits1(gb);
else
time_increment = get_bits(gb, ctx->time_increment_bits);
if (s->pict_type != AV_PICTURE_TYPE_B) {
s->last_time_base = s->time_base;
s->time_base += time_incr;
s->time = s->time_base * s->avctx->framerate.num + time_increment;
if (s->workaround_bugs & FF_BUG_UMP4) {
if (s->time < s->last_non_b_time) {
s->time_base++;
s->time += s->avctx->framerate.num;
}
}
s->pp_time = s->time - s->last_non_b_time;
s->last_non_b_time = s->time;
} else {
s->time = (s->last_time_base + time_incr) * s->avctx->framerate.num + time_increment;
s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
if (s->pp_time <= s->pb_time ||
s->pp_time <= s->pp_time - s->pb_time ||
s->pp_time <= 0) {
return FRAME_SKIPPED;
}
ff_mpeg4_init_direct_mv(s);
if (ctx->t_frame == 0)
ctx->t_frame = s->pb_time;
if (ctx->t_frame == 0)
ctx->t_frame = 1;
s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, ctx->t_frame) -
ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
s->pb_field_time = (ROUNDED_DIV(s->time, ctx->t_frame) -
ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) {
s->pb_field_time = 2;
s->pp_field_time = 4;
if (!s->progressive_sequence)
return FRAME_SKIPPED;
}
}
if (s->avctx->framerate.den)
pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
else
pts = AV_NOPTS_VALUE;
if (s->avctx->debug&FF_DEBUG_PTS)
av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
pts);
check_marker(gb, "before vop_coded");
if (get_bits1(gb) != 1) {
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
return FRAME_SKIPPED;
}
if (ctx->new_pred)
decode_new_pred(ctx, gb);
if (ctx->shape != BIN_ONLY_SHAPE &&
(s->pict_type == AV_PICTURE_TYPE_P ||
(s->pict_type == AV_PICTURE_TYPE_S &&
ctx->vol_sprite_usage == GMC_SPRITE))) {
s->no_rounding = get_bits1(gb);
} else {
s->no_rounding = 0;
}
if (ctx->shape != RECT_SHAPE) {
if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
skip_bits(gb, 13);
skip_bits1(gb);
skip_bits(gb, 13);
skip_bits1(gb);
skip_bits(gb, 13);
skip_bits1(gb);
skip_bits(gb, 13);
}
skip_bits1(gb);
if (get_bits1(gb) != 0)
skip_bits(gb, 8);
}
if (ctx->shape != BIN_ONLY_SHAPE) {
skip_bits_long(gb, ctx->cplx_estimation_trash_i);
if (s->pict_type != AV_PICTURE_TYPE_I)
skip_bits_long(gb, ctx->cplx_estimation_trash_p);
if (s->pict_type == AV_PICTURE_TYPE_B)
skip_bits_long(gb, ctx->cplx_estimation_trash_b);
if (get_bits_left(gb) < 3) {
av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
return AVERROR_INVALIDDATA;
}
ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
if (!s->progressive_sequence) {
s->top_field_first = get_bits1(gb);
s->alternate_scan = get_bits1(gb);
} else
s->alternate_scan = 0;
}
if (s->alternate_scan) {
ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
} else {
ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
}
if (s->pict_type == AV_PICTURE_TYPE_S &&
(ctx->vol_sprite_usage == STATIC_SPRITE ||
ctx->vol_sprite_usage == GMC_SPRITE)) {
if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
return AVERROR_INVALIDDATA;
if (ctx->sprite_brightness_change)
av_log(s->avctx, AV_LOG_ERROR,
"sprite_brightness_change not supported\n");
if (ctx->vol_sprite_usage == STATIC_SPRITE)
av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
}
if (ctx->shape != BIN_ONLY_SHAPE) {
s->chroma_qscale = s->qscale = get_bits(gb, s->quant_precision);
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (qscale=0)\n");
return AVERROR_INVALIDDATA;
}
if (s->pict_type != AV_PICTURE_TYPE_I) {
s->f_code = get_bits(gb, 3);
if (s->f_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (f_code=0)\n");
s->f_code = 1;
return AVERROR_INVALIDDATA;
}
} else
s->f_code = 1;
if (s->pict_type == AV_PICTURE_TYPE_B) {
s->b_code = get_bits(gb, 3);
if (s->b_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (b_code=0)\n");
s->b_code=1;
return AVERROR_INVALIDDATA;
}
} else
s->b_code = 1;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG,
"qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64" tincr:%d\n",
s->qscale, s->f_code, s->b_code,
s->pict_type == AV_PICTURE_TYPE_I ? "I" : (s->pict_type == AV_PICTURE_TYPE_P ? "P" : (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
s->top_field_first, s->quarter_sample ? "q" : "h",
s->data_partitioning, ctx->resync_marker,
ctx->num_sprite_warping_points, s->sprite_warping_accuracy,
1 - s->no_rounding, s->vo_type,
ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
ctx->cplx_estimation_trash_b,
s->time,
time_increment
);
}
if (!ctx->scalability) {
if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
skip_bits1(gb);
} else {
if (ctx->enhancement_type) {
int load_backward_shape = get_bits1(gb);
if (load_backward_shape)
av_log(s->avctx, AV_LOG_ERROR,
"load backward shape isn't supported\n");
}
skip_bits(gb, 2);
}
}
if (s->vo_type == 0 && ctx->vol_control_parameters == 0 &&
ctx->divx_version == -1 && s->picture_number == 0) {
av_log(s->avctx, AV_LOG_WARNING,
"looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
s->low_delay = 1;
}
s->picture_number++;
s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;
if (s->workaround_bugs & FF_BUG_EDGE) {
s->h_edge_pos = s->width;
s->v_edge_pos = s->height;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(Mpeg4DecContext *VAR_0, GetBitContext *VAR_1)
{
MpegEncContext *s = &VAR_0->m;
int VAR_2, VAR_3;
int64_t pts;
s->pict_type = get_bits(VAR_1, 2) + AV_PICTURE_TYPE_I;
if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
VAR_0->vol_control_parameters == 0 && !(s->flags & CODEC_FLAG_LOW_DELAY)) {
av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
s->low_delay = 0;
}
s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
if (s->partitioned_frame)
s->decode_mb = mpeg4_decode_partitioned_mb;
else
s->decode_mb = mpeg4_decode_mb;
VAR_2 = 0;
while (get_bits1(VAR_1) != 0)
VAR_2++;
check_marker(VAR_1, "before VAR_3");
if (VAR_0->time_increment_bits == 0 ||
!(show_bits(VAR_1, VAR_0->time_increment_bits + 1) & 1)) {
av_log(s->avctx, AV_LOG_WARNING,
"time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n", VAR_0->time_increment_bits);
for (VAR_0->time_increment_bits = 1;
VAR_0->time_increment_bits < 16;
VAR_0->time_increment_bits++) {
if (s->pict_type == AV_PICTURE_TYPE_P ||
(s->pict_type == AV_PICTURE_TYPE_S &&
VAR_0->vol_sprite_usage == GMC_SPRITE)) {
if ((show_bits(VAR_1, VAR_0->time_increment_bits + 6) & 0x37) == 0x30)
break;
} else if ((show_bits(VAR_1, VAR_0->time_increment_bits + 5) & 0x1F) == 0x18)
break;
}
av_log(s->avctx, AV_LOG_WARNING,
"time_increment_bits set to %d bits, based on bitstream analysis\n", VAR_0->time_increment_bits);
if (s->avctx->framerate.num && 4*s->avctx->framerate.num < 1<<VAR_0->time_increment_bits) {
s->avctx->framerate.num = 1<<VAR_0->time_increment_bits;
s->avctx->time_base = av_inv_q(av_mul_q(s->avctx->framerate, (AVRational){s->avctx->ticks_per_frame, 1}));
}
}
if (IS_3IV1)
VAR_3 = get_bits1(VAR_1);
else
VAR_3 = get_bits(VAR_1, VAR_0->time_increment_bits);
if (s->pict_type != AV_PICTURE_TYPE_B) {
s->last_time_base = s->time_base;
s->time_base += VAR_2;
s->time = s->time_base * s->avctx->framerate.num + VAR_3;
if (s->workaround_bugs & FF_BUG_UMP4) {
if (s->time < s->last_non_b_time) {
s->time_base++;
s->time += s->avctx->framerate.num;
}
}
s->pp_time = s->time - s->last_non_b_time;
s->last_non_b_time = s->time;
} else {
s->time = (s->last_time_base + VAR_2) * s->avctx->framerate.num + VAR_3;
s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
if (s->pp_time <= s->pb_time ||
s->pp_time <= s->pp_time - s->pb_time ||
s->pp_time <= 0) {
return FRAME_SKIPPED;
}
ff_mpeg4_init_direct_mv(s);
if (VAR_0->t_frame == 0)
VAR_0->t_frame = s->pb_time;
if (VAR_0->t_frame == 0)
VAR_0->t_frame = 1;
s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, VAR_0->t_frame) -
ROUNDED_DIV(s->last_non_b_time - s->pp_time, VAR_0->t_frame)) * 2;
s->pb_field_time = (ROUNDED_DIV(s->time, VAR_0->t_frame) -
ROUNDED_DIV(s->last_non_b_time - s->pp_time, VAR_0->t_frame)) * 2;
if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) {
s->pb_field_time = 2;
s->pp_field_time = 4;
if (!s->progressive_sequence)
return FRAME_SKIPPED;
}
}
if (s->avctx->framerate.den)
pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
else
pts = AV_NOPTS_VALUE;
if (s->avctx->debug&FF_DEBUG_PTS)
av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
pts);
check_marker(VAR_1, "before vop_coded");
if (get_bits1(VAR_1) != 1) {
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
return FRAME_SKIPPED;
}
if (VAR_0->new_pred)
decode_new_pred(VAR_0, VAR_1);
if (VAR_0->shape != BIN_ONLY_SHAPE &&
(s->pict_type == AV_PICTURE_TYPE_P ||
(s->pict_type == AV_PICTURE_TYPE_S &&
VAR_0->vol_sprite_usage == GMC_SPRITE))) {
s->no_rounding = get_bits1(VAR_1);
} else {
s->no_rounding = 0;
}
if (VAR_0->shape != RECT_SHAPE) {
if (VAR_0->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
skip_bits(VAR_1, 13);
skip_bits1(VAR_1);
skip_bits(VAR_1, 13);
skip_bits1(VAR_1);
skip_bits(VAR_1, 13);
skip_bits1(VAR_1);
skip_bits(VAR_1, 13);
}
skip_bits1(VAR_1);
if (get_bits1(VAR_1) != 0)
skip_bits(VAR_1, 8);
}
if (VAR_0->shape != BIN_ONLY_SHAPE) {
skip_bits_long(VAR_1, VAR_0->cplx_estimation_trash_i);
if (s->pict_type != AV_PICTURE_TYPE_I)
skip_bits_long(VAR_1, VAR_0->cplx_estimation_trash_p);
if (s->pict_type == AV_PICTURE_TYPE_B)
skip_bits_long(VAR_1, VAR_0->cplx_estimation_trash_b);
if (get_bits_left(VAR_1) < 3) {
av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
return AVERROR_INVALIDDATA;
}
VAR_0->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(VAR_1, 3)];
if (!s->progressive_sequence) {
s->top_field_first = get_bits1(VAR_1);
s->alternate_scan = get_bits1(VAR_1);
} else
s->alternate_scan = 0;
}
if (s->alternate_scan) {
ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
} else {
ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
}
if (s->pict_type == AV_PICTURE_TYPE_S &&
(VAR_0->vol_sprite_usage == STATIC_SPRITE ||
VAR_0->vol_sprite_usage == GMC_SPRITE)) {
if (mpeg4_decode_sprite_trajectory(VAR_0, VAR_1) < 0)
return AVERROR_INVALIDDATA;
if (VAR_0->sprite_brightness_change)
av_log(s->avctx, AV_LOG_ERROR,
"sprite_brightness_change not supported\n");
if (VAR_0->vol_sprite_usage == STATIC_SPRITE)
av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
}
if (VAR_0->shape != BIN_ONLY_SHAPE) {
s->chroma_qscale = s->qscale = get_bits(VAR_1, s->quant_precision);
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (qscale=0)\n");
return AVERROR_INVALIDDATA;
}
if (s->pict_type != AV_PICTURE_TYPE_I) {
s->f_code = get_bits(VAR_1, 3);
if (s->f_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (f_code=0)\n");
s->f_code = 1;
return AVERROR_INVALIDDATA;
}
} else
s->f_code = 1;
if (s->pict_type == AV_PICTURE_TYPE_B) {
s->b_code = get_bits(VAR_1, 3);
if (s->b_code == 0) {
av_log(s->avctx, AV_LOG_ERROR,
"Error, header damaged or not MPEG4 header (b_code=0)\n");
s->b_code=1;
return AVERROR_INVALIDDATA;
}
} else
s->b_code = 1;
if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG,
"qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64" tincr:%d\n",
s->qscale, s->f_code, s->b_code,
s->pict_type == AV_PICTURE_TYPE_I ? "I" : (s->pict_type == AV_PICTURE_TYPE_P ? "P" : (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
VAR_1->size_in_bits,s->progressive_sequence, s->alternate_scan,
s->top_field_first, s->quarter_sample ? "q" : "h",
s->data_partitioning, VAR_0->resync_marker,
VAR_0->num_sprite_warping_points, s->sprite_warping_accuracy,
1 - s->no_rounding, s->vo_type,
VAR_0->vol_control_parameters ? " VOLC" : " ", VAR_0->intra_dc_threshold,
VAR_0->cplx_estimation_trash_i, VAR_0->cplx_estimation_trash_p,
VAR_0->cplx_estimation_trash_b,
s->time,
VAR_3
);
}
if (!VAR_0->scalability) {
if (VAR_0->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
skip_bits1(VAR_1);
} else {
if (VAR_0->enhancement_type) {
int VAR_4 = get_bits1(VAR_1);
if (VAR_4)
av_log(s->avctx, AV_LOG_ERROR,
"load backward shape isn't supported\n");
}
skip_bits(VAR_1, 2);
}
}
if (s->vo_type == 0 && VAR_0->vol_control_parameters == 0 &&
VAR_0->divx_version == -1 && s->picture_number == 0) {
av_log(s->avctx, AV_LOG_WARNING,
"looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
s->low_delay = 1;
}
s->picture_number++;
s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;
if (s->workaround_bugs & FF_BUG_EDGE) {
s->h_edge_pos = s->width;
s->v_edge_pos = s->height;
}
return 0;
}
| [
"static int FUNC_0(Mpeg4DecContext *VAR_0, GetBitContext *VAR_1)\n{",
"MpegEncContext *s = &VAR_0->m;",
"int VAR_2, VAR_3;",
"int64_t pts;",
"s->pict_type = get_bits(VAR_1, 2) + AV_PICTURE_TYPE_I;",
"if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&\nVAR_0->vol_control_parameters == 0 && !(s->flags... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29,
31
],
[
33,
35
],
[
39
],
[
41,
43
],
[
47
],
[
51,
53
],
[
55,
57
... |
14,134 | static void event_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
dc->bus_type = TYPE_SCLP_EVENTS_BUS;
dc->unplug = qdev_simple_unplug_cb;
dc->init = event_qdev_init;
dc->exit = event_qdev_exit;
}
| true | qemu | c804c2a71752dd1e150cde768d8c54b02fa8bad9 | static void event_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
dc->bus_type = TYPE_SCLP_EVENTS_BUS;
dc->unplug = qdev_simple_unplug_cb;
dc->init = event_qdev_init;
dc->exit = event_qdev_exit;
}
| {
"code": [
" dc->init = event_qdev_init;",
" dc->exit = event_qdev_exit;"
],
"line_no": [
13,
15
]
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
dc->bus_type = TYPE_SCLP_EVENTS_BUS;
dc->unplug = qdev_simple_unplug_cb;
dc->init = event_qdev_init;
dc->exit = event_qdev_exit;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"dc->bus_type = TYPE_SCLP_EVENTS_BUS;",
"dc->unplug = qdev_simple_unplug_cb;",
"dc->init = event_qdev_init;",
"dc->exit = event_qdev_exit;",
"}"
] | [
0,
0,
0,
0,
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
14,135 | static int dvvideo_init(AVCodecContext *avctx)
{
DVVideoContext *s = avctx->priv_data;
DSPContext dsp;
static int done=0;
int i, j;
if (!done) {
VLC dv_vlc;
uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
uint8_t new_dv_vlc_len[NB_DV_VLC*2];
uint8_t new_dv_vlc_run[NB_DV_VLC*2];
int16_t new_dv_vlc_level[NB_DV_VLC*2];
done = 1;
dv_vlc_map = av_mallocz(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
if (!dv_vlc_map)
return -ENOMEM;
/* dv_anchor lets each thread know its Id */
dv_anchor = av_malloc(12*27*sizeof(void*));
if (!dv_anchor) {
av_free(dv_vlc_map);
return -ENOMEM;
}
for (i=0; i<12*27; i++)
dv_anchor[i] = (void*)(size_t)i;
/* it's faster to include sign bit in a generic VLC parsing scheme */
for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
new_dv_vlc_bits[j] = dv_vlc_bits[i];
new_dv_vlc_len[j] = dv_vlc_len[i];
new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = dv_vlc_level[i];
if (dv_vlc_level[i]) {
new_dv_vlc_bits[j] <<= 1;
new_dv_vlc_len[j]++;
j++;
new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = -dv_vlc_level[i];
}
}
/* NOTE: as a trick, we use the fact the no codes are unused
to accelerate the parsing of partial codes */
init_vlc(&dv_vlc, TEX_VLC_BITS, j,
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2);
dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
if (!dv_rl_vlc) {
av_free(dv_anchor);
av_free(dv_vlc_map);
return -ENOMEM;
}
for(i = 0; i < dv_vlc.table_size; i++){
int code= dv_vlc.table[i][0];
int len = dv_vlc.table[i][1];
int level, run;
if(len<0){ //more bits needed
run= 0;
level= code;
} else {
run= new_dv_vlc_run[code] + 1;
level= new_dv_vlc_level[code];
}
dv_rl_vlc[i].len = len;
dv_rl_vlc[i].level = level;
dv_rl_vlc[i].run = run;
}
free_vlc(&dv_vlc);
for (i = 0; i < NB_DV_VLC - 1; i++) {
if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
continue;
if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
continue;
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
(!!dv_vlc_level[i]);
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
(!!dv_vlc_level[i]);
}
for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
#ifdef DV_CODEC_TINY_TARGET
for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
if (dv_vlc_map[i][j].size == 0) {
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
(dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
dv_vlc_map[0][j].size;
}
}
#else
for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
if (dv_vlc_map[i][j].size == 0) {
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
(dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
dv_vlc_map[0][j].size;
}
dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
dv_vlc_map[i][j].vlc | 1;
dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
dv_vlc_map[i][j].size;
}
#endif
}
}
/* Generic DSP setup */
dsputil_init(&dsp, avctx);
s->get_pixels = dsp.get_pixels;
/* 88DCT setup */
s->fdct[0] = dsp.fdct;
s->idct_put[0] = dsp.idct_put;
for (i=0; i<64; i++)
s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
/* 248DCT setup */
s->fdct[1] = dsp.fdct248;
s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP
memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
/* XXX: do it only for constant case */
dv_build_unquantize_tables(s, dsp.idct_permutation);
/* FIXME: I really don't think this should be here */
if (dv_codec_profile(avctx))
avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt;
avctx->coded_frame = &s->picture;
return 0;
}
| false | FFmpeg | 5da42be1921604a97e6180f242c78c484a179314 | static int dvvideo_init(AVCodecContext *avctx)
{
DVVideoContext *s = avctx->priv_data;
DSPContext dsp;
static int done=0;
int i, j;
if (!done) {
VLC dv_vlc;
uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
uint8_t new_dv_vlc_len[NB_DV_VLC*2];
uint8_t new_dv_vlc_run[NB_DV_VLC*2];
int16_t new_dv_vlc_level[NB_DV_VLC*2];
done = 1;
dv_vlc_map = av_mallocz(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
if (!dv_vlc_map)
return -ENOMEM;
dv_anchor = av_malloc(12*27*sizeof(void*));
if (!dv_anchor) {
av_free(dv_vlc_map);
return -ENOMEM;
}
for (i=0; i<12*27; i++)
dv_anchor[i] = (void*)(size_t)i;
for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
new_dv_vlc_bits[j] = dv_vlc_bits[i];
new_dv_vlc_len[j] = dv_vlc_len[i];
new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = dv_vlc_level[i];
if (dv_vlc_level[i]) {
new_dv_vlc_bits[j] <<= 1;
new_dv_vlc_len[j]++;
j++;
new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = -dv_vlc_level[i];
}
}
init_vlc(&dv_vlc, TEX_VLC_BITS, j,
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2);
dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
if (!dv_rl_vlc) {
av_free(dv_anchor);
av_free(dv_vlc_map);
return -ENOMEM;
}
for(i = 0; i < dv_vlc.table_size; i++){
int code= dv_vlc.table[i][0];
int len = dv_vlc.table[i][1];
int level, run;
if(len<0){
run= 0;
level= code;
} else {
run= new_dv_vlc_run[code] + 1;
level= new_dv_vlc_level[code];
}
dv_rl_vlc[i].len = len;
dv_rl_vlc[i].level = level;
dv_rl_vlc[i].run = run;
}
free_vlc(&dv_vlc);
for (i = 0; i < NB_DV_VLC - 1; i++) {
if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
continue;
if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
continue;
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
(!!dv_vlc_level[i]);
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
(!!dv_vlc_level[i]);
}
for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
#ifdef DV_CODEC_TINY_TARGET
for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
if (dv_vlc_map[i][j].size == 0) {
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
(dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
dv_vlc_map[0][j].size;
}
}
#else
for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
if (dv_vlc_map[i][j].size == 0) {
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
(dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
dv_vlc_map[0][j].size;
}
dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
dv_vlc_map[i][j].vlc | 1;
dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
dv_vlc_map[i][j].size;
}
#endif
}
}
dsputil_init(&dsp, avctx);
s->get_pixels = dsp.get_pixels;
s->fdct[0] = dsp.fdct;
s->idct_put[0] = dsp.idct_put;
for (i=0; i<64; i++)
s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
s->fdct[1] = dsp.fdct248;
s->idct_put[1] = simple_idct248_put;
memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
dv_build_unquantize_tables(s, dsp.idct_permutation);
if (dv_codec_profile(avctx))
avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt;
avctx->coded_frame = &s->picture;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0)
{
DVVideoContext *s = VAR_0->priv_data;
DSPContext dsp;
static int VAR_1=0;
int VAR_2, VAR_3;
if (!VAR_1) {
VLC dv_vlc;
uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
uint8_t new_dv_vlc_len[NB_DV_VLC*2];
uint8_t new_dv_vlc_run[NB_DV_VLC*2];
int16_t new_dv_vlc_level[NB_DV_VLC*2];
VAR_1 = 1;
dv_vlc_map = av_mallocz(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
if (!dv_vlc_map)
return -ENOMEM;
dv_anchor = av_malloc(12*27*sizeof(void*));
if (!dv_anchor) {
av_free(dv_vlc_map);
return -ENOMEM;
}
for (VAR_2=0; VAR_2<12*27; VAR_2++)
dv_anchor[VAR_2] = (void*)(size_t)VAR_2;
for (VAR_2=0, VAR_3=0; VAR_2<NB_DV_VLC; VAR_2++, VAR_3++) {
new_dv_vlc_bits[VAR_3] = dv_vlc_bits[VAR_2];
new_dv_vlc_len[VAR_3] = dv_vlc_len[VAR_2];
new_dv_vlc_run[VAR_3] = dv_vlc_run[VAR_2];
new_dv_vlc_level[VAR_3] = dv_vlc_level[VAR_2];
if (dv_vlc_level[VAR_2]) {
new_dv_vlc_bits[VAR_3] <<= 1;
new_dv_vlc_len[VAR_3]++;
VAR_3++;
new_dv_vlc_bits[VAR_3] = (dv_vlc_bits[VAR_2] << 1) | 1;
new_dv_vlc_len[VAR_3] = dv_vlc_len[VAR_2] + 1;
new_dv_vlc_run[VAR_3] = dv_vlc_run[VAR_2];
new_dv_vlc_level[VAR_3] = -dv_vlc_level[VAR_2];
}
}
init_vlc(&dv_vlc, TEX_VLC_BITS, VAR_3,
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2);
dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
if (!dv_rl_vlc) {
av_free(dv_anchor);
av_free(dv_vlc_map);
return -ENOMEM;
}
for(VAR_2 = 0; VAR_2 < dv_vlc.table_size; VAR_2++){
int code= dv_vlc.table[VAR_2][0];
int len = dv_vlc.table[VAR_2][1];
int level, run;
if(len<0){
run= 0;
level= code;
} else {
run= new_dv_vlc_run[code] + 1;
level= new_dv_vlc_level[code];
}
dv_rl_vlc[VAR_2].len = len;
dv_rl_vlc[VAR_2].level = level;
dv_rl_vlc[VAR_2].run = run;
}
free_vlc(&dv_vlc);
for (VAR_2 = 0; VAR_2 < NB_DV_VLC - 1; VAR_2++) {
if (dv_vlc_run[VAR_2] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[VAR_2] >= DV_VLC_MAP_LEV_SIZE)
continue;
if (dv_vlc_map[dv_vlc_run[VAR_2]][dv_vlc_level[VAR_2]].size != 0)
continue;
dv_vlc_map[dv_vlc_run[VAR_2]][dv_vlc_level[VAR_2]].vlc = dv_vlc_bits[VAR_2] <<
(!!dv_vlc_level[VAR_2]);
dv_vlc_map[dv_vlc_run[VAR_2]][dv_vlc_level[VAR_2]].size = dv_vlc_len[VAR_2] +
(!!dv_vlc_level[VAR_2]);
}
for (VAR_2 = 0; VAR_2 < DV_VLC_MAP_RUN_SIZE; VAR_2++) {
#ifdef DV_CODEC_TINY_TARGET
for (VAR_3 = 1; VAR_3 < DV_VLC_MAP_LEV_SIZE; VAR_3++) {
if (dv_vlc_map[VAR_2][VAR_3].size == 0) {
dv_vlc_map[VAR_2][VAR_3].vlc = dv_vlc_map[0][VAR_3].vlc |
(dv_vlc_map[VAR_2-1][0].vlc << (dv_vlc_map[0][VAR_3].size));
dv_vlc_map[VAR_2][VAR_3].size = dv_vlc_map[VAR_2-1][0].size +
dv_vlc_map[0][VAR_3].size;
}
}
#else
for (VAR_3 = 1; VAR_3 < DV_VLC_MAP_LEV_SIZE/2; VAR_3++) {
if (dv_vlc_map[VAR_2][VAR_3].size == 0) {
dv_vlc_map[VAR_2][VAR_3].vlc = dv_vlc_map[0][VAR_3].vlc |
(dv_vlc_map[VAR_2-1][0].vlc << (dv_vlc_map[0][VAR_3].size));
dv_vlc_map[VAR_2][VAR_3].size = dv_vlc_map[VAR_2-1][0].size +
dv_vlc_map[0][VAR_3].size;
}
dv_vlc_map[VAR_2][((uint16_t)(-VAR_3))&0x1ff].vlc =
dv_vlc_map[VAR_2][VAR_3].vlc | 1;
dv_vlc_map[VAR_2][((uint16_t)(-VAR_3))&0x1ff].size =
dv_vlc_map[VAR_2][VAR_3].size;
}
#endif
}
}
dsputil_init(&dsp, VAR_0);
s->get_pixels = dsp.get_pixels;
s->fdct[0] = dsp.fdct;
s->idct_put[0] = dsp.idct_put;
for (VAR_2=0; VAR_2<64; VAR_2++)
s->dv_zigzag[0][VAR_2] = dsp.idct_permutation[ff_zigzag_direct[VAR_2]];
s->fdct[1] = dsp.fdct248;
s->idct_put[1] = simple_idct248_put;
memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
dv_build_unquantize_tables(s, dsp.idct_permutation);
if (dv_codec_profile(VAR_0))
VAR_0->pix_fmt = dv_codec_profile(VAR_0)->pix_fmt;
VAR_0->coded_frame = &s->picture;
return 0;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0)\n{",
"DVVideoContext *s = VAR_0->priv_data;",
"DSPContext dsp;",
"static int VAR_1=0;",
"int VAR_2, VAR_3;",
"if (!VAR_1) {",
"VLC dv_vlc;",
"uint16_t new_dv_vlc_bits[NB_DV_VLC*2];",
"uint8_t new_dv_vlc_len[NB_DV_VLC*2];",
"uint8_t new_dv_vlc_run[NB_DV_VLC... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
33
],
[
35,
37
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[... |
14,137 | static int wv_read_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
WVContext *wc = s->priv_data;
AVStream *st;
int ret;
wc->block_parsed = 0;
for (;;) {
if ((ret = wv_read_block_header(s, pb, 0)) < 0)
return ret;
if (!AV_RN32(wc->extra))
avio_skip(pb, wc->blksize - 24);
else
break;
}
/* now we are ready: build format streams */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_WAVPACK;
st->codec->channels = wc->chan;
st->codec->channel_layout = wc->chmask;
st->codec->sample_rate = wc->rate;
st->codec->bits_per_coded_sample = wc->bpp;
avpriv_set_pts_info(st, 64, 1, wc->rate);
st->start_time = 0;
st->duration = wc->samples;
if (s->pb->seekable) {
int64_t cur = avio_tell(s->pb);
wc->apetag_start = ff_ape_parse_tag(s);
if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
ff_id3v1_read(s);
avio_seek(s->pb, cur, SEEK_SET);
}
return 0;
}
| false | FFmpeg | 039341eb43945f02867cfe2fe2514eaec4b81ace | static int wv_read_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
WVContext *wc = s->priv_data;
AVStream *st;
int ret;
wc->block_parsed = 0;
for (;;) {
if ((ret = wv_read_block_header(s, pb, 0)) < 0)
return ret;
if (!AV_RN32(wc->extra))
avio_skip(pb, wc->blksize - 24);
else
break;
}
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_WAVPACK;
st->codec->channels = wc->chan;
st->codec->channel_layout = wc->chmask;
st->codec->sample_rate = wc->rate;
st->codec->bits_per_coded_sample = wc->bpp;
avpriv_set_pts_info(st, 64, 1, wc->rate);
st->start_time = 0;
st->duration = wc->samples;
if (s->pb->seekable) {
int64_t cur = avio_tell(s->pb);
wc->apetag_start = ff_ape_parse_tag(s);
if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
ff_id3v1_read(s);
avio_seek(s->pb, cur, SEEK_SET);
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0)
{
AVIOContext *pb = VAR_0->pb;
WVContext *wc = VAR_0->priv_data;
AVStream *st;
int VAR_1;
wc->block_parsed = 0;
for (;;) {
if ((VAR_1 = wv_read_block_header(VAR_0, pb, 0)) < 0)
return VAR_1;
if (!AV_RN32(wc->extra))
avio_skip(pb, wc->blksize - 24);
else
break;
}
st = avformat_new_stream(VAR_0, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_WAVPACK;
st->codec->channels = wc->chan;
st->codec->channel_layout = wc->chmask;
st->codec->sample_rate = wc->rate;
st->codec->bits_per_coded_sample = wc->bpp;
avpriv_set_pts_info(st, 64, 1, wc->rate);
st->start_time = 0;
st->duration = wc->samples;
if (VAR_0->pb->seekable) {
int64_t cur = avio_tell(VAR_0->pb);
wc->apetag_start = ff_ape_parse_tag(VAR_0);
if (!av_dict_get(VAR_0->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
ff_id3v1_read(VAR_0);
avio_seek(VAR_0->pb, cur, SEEK_SET);
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"AVIOContext *pb = VAR_0->pb;",
"WVContext *wc = VAR_0->priv_data;",
"AVStream *st;",
"int VAR_1;",
"wc->block_parsed = 0;",
"for (;;) {",
"if ((VAR_1 = wv_read_block_header(VAR_0, pb, 0)) < 0)\nreturn VAR_1;",
"if (!AV_RN32(wc->extra))\navio_skip(pb, ... | [
0,
0,
0,
0,
0,
0,
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
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
... |
14,138 | static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr,
uint64_t asc, target_ulong *raddr, int *flags,
int rw, bool exc)
{
uint64_t asce = 0;
int level;
int r;
switch (asc) {
case PSW_ASC_PRIMARY:
PTE_DPRINTF("%s: asc=primary\n", __func__);
asce = env->cregs[1];
break;
case PSW_ASC_SECONDARY:
PTE_DPRINTF("%s: asc=secondary\n", __func__);
asce = env->cregs[7];
break;
case PSW_ASC_HOME:
PTE_DPRINTF("%s: asc=home\n", __func__);
asce = env->cregs[13];
break;
}
if (asce & _ASCE_REAL_SPACE) {
/* direct mapping */
*raddr = vaddr;
return 0;
}
level = asce & _ASCE_TYPE_MASK;
switch (level) {
case _ASCE_TYPE_REGION1:
if ((vaddr >> 62) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_REG_FIRST_TRANS, asc, rw, exc);
return -1;
}
break;
case _ASCE_TYPE_REGION2:
if (vaddr & 0xffe0000000000000ULL) {
DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64
" 0xffe0000000000000ULL\n", __func__, vaddr);
trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);
return -1;
}
if ((vaddr >> 51 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_REG_SEC_TRANS, asc, rw, exc);
return -1;
}
break;
case _ASCE_TYPE_REGION3:
if (vaddr & 0xfffffc0000000000ULL) {
DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64
" 0xfffffc0000000000ULL\n", __func__, vaddr);
trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);
return -1;
}
if ((vaddr >> 40 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_REG_THIRD_TRANS, asc, rw, exc);
return -1;
}
break;
case _ASCE_TYPE_SEGMENT:
if (vaddr & 0xffffffff80000000ULL) {
DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64
" 0xffffffff80000000ULL\n", __func__, vaddr);
trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);
return -1;
}
if ((vaddr >> 29 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_SEGMENT_TRANS, asc, rw, exc);
return -1;
}
break;
}
r = mmu_translate_region(env, vaddr, asc, asce, level, raddr, flags, rw,
exc);
if ((rw == 1) && !(*flags & PAGE_WRITE)) {
trigger_prot_fault(env, vaddr, asc, rw, exc);
return -1;
}
return r;
}
| true | qemu | d267571be419d389184916b56f862a8f143e67c5 | static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr,
uint64_t asc, target_ulong *raddr, int *flags,
int rw, bool exc)
{
uint64_t asce = 0;
int level;
int r;
switch (asc) {
case PSW_ASC_PRIMARY:
PTE_DPRINTF("%s: asc=primary\n", __func__);
asce = env->cregs[1];
break;
case PSW_ASC_SECONDARY:
PTE_DPRINTF("%s: asc=secondary\n", __func__);
asce = env->cregs[7];
break;
case PSW_ASC_HOME:
PTE_DPRINTF("%s: asc=home\n", __func__);
asce = env->cregs[13];
break;
}
if (asce & _ASCE_REAL_SPACE) {
*raddr = vaddr;
return 0;
}
level = asce & _ASCE_TYPE_MASK;
switch (level) {
case _ASCE_TYPE_REGION1:
if ((vaddr >> 62) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_REG_FIRST_TRANS, asc, rw, exc);
return -1;
}
break;
case _ASCE_TYPE_REGION2:
if (vaddr & 0xffe0000000000000ULL) {
DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64
" 0xffe0000000000000ULL\n", __func__, vaddr);
trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);
return -1;
}
if ((vaddr >> 51 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_REG_SEC_TRANS, asc, rw, exc);
return -1;
}
break;
case _ASCE_TYPE_REGION3:
if (vaddr & 0xfffffc0000000000ULL) {
DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64
" 0xfffffc0000000000ULL\n", __func__, vaddr);
trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);
return -1;
}
if ((vaddr >> 40 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_REG_THIRD_TRANS, asc, rw, exc);
return -1;
}
break;
case _ASCE_TYPE_SEGMENT:
if (vaddr & 0xffffffff80000000ULL) {
DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64
" 0xffffffff80000000ULL\n", __func__, vaddr);
trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);
return -1;
}
if ((vaddr >> 29 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(env, vaddr, PGM_SEGMENT_TRANS, asc, rw, exc);
return -1;
}
break;
}
r = mmu_translate_region(env, vaddr, asc, asce, level, raddr, flags, rw,
exc);
if ((rw == 1) && !(*flags & PAGE_WRITE)) {
trigger_prot_fault(env, vaddr, asc, rw, exc);
return -1;
}
return r;
}
| {
"code": [
" trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);",
" trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);",
" trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw, exc);"
],
"line_no": [
83,
83,
83
]
} | static int FUNC_0(CPUS390XState *VAR_0, target_ulong VAR_1,
uint64_t VAR_2, target_ulong *VAR_3, int *VAR_4,
int VAR_5, bool VAR_6)
{
uint64_t asce = 0;
int VAR_7;
int VAR_8;
switch (VAR_2) {
case PSW_ASC_PRIMARY:
PTE_DPRINTF("%s: VAR_2=primary\n", __func__);
asce = VAR_0->cregs[1];
break;
case PSW_ASC_SECONDARY:
PTE_DPRINTF("%s: VAR_2=secondary\n", __func__);
asce = VAR_0->cregs[7];
break;
case PSW_ASC_HOME:
PTE_DPRINTF("%s: VAR_2=home\n", __func__);
asce = VAR_0->cregs[13];
break;
}
if (asce & _ASCE_REAL_SPACE) {
*VAR_3 = VAR_1;
return 0;
}
VAR_7 = asce & _ASCE_TYPE_MASK;
switch (VAR_7) {
case _ASCE_TYPE_REGION1:
if ((VAR_1 >> 62) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(VAR_0, VAR_1, PGM_REG_FIRST_TRANS, VAR_2, VAR_5, VAR_6);
return -1;
}
break;
case _ASCE_TYPE_REGION2:
if (VAR_1 & 0xffe0000000000000ULL) {
DPRINTF("%s: VAR_1 doesn't fit 0x%16" PRIx64
" 0xffe0000000000000ULL\n", __func__, VAR_1);
trigger_page_fault(VAR_0, VAR_1, PGM_TRANS_SPEC, VAR_2, VAR_5, VAR_6);
return -1;
}
if ((VAR_1 >> 51 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(VAR_0, VAR_1, PGM_REG_SEC_TRANS, VAR_2, VAR_5, VAR_6);
return -1;
}
break;
case _ASCE_TYPE_REGION3:
if (VAR_1 & 0xfffffc0000000000ULL) {
DPRINTF("%s: VAR_1 doesn't fit 0x%16" PRIx64
" 0xfffffc0000000000ULL\n", __func__, VAR_1);
trigger_page_fault(VAR_0, VAR_1, PGM_TRANS_SPEC, VAR_2, VAR_5, VAR_6);
return -1;
}
if ((VAR_1 >> 40 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(VAR_0, VAR_1, PGM_REG_THIRD_TRANS, VAR_2, VAR_5, VAR_6);
return -1;
}
break;
case _ASCE_TYPE_SEGMENT:
if (VAR_1 & 0xffffffff80000000ULL) {
DPRINTF("%s: VAR_1 doesn't fit 0x%16" PRIx64
" 0xffffffff80000000ULL\n", __func__, VAR_1);
trigger_page_fault(VAR_0, VAR_1, PGM_TRANS_SPEC, VAR_2, VAR_5, VAR_6);
return -1;
}
if ((VAR_1 >> 29 & 3) > (asce & _ASCE_TABLE_LENGTH)) {
trigger_page_fault(VAR_0, VAR_1, PGM_SEGMENT_TRANS, VAR_2, VAR_5, VAR_6);
return -1;
}
break;
}
VAR_8 = mmu_translate_region(VAR_0, VAR_1, VAR_2, asce, VAR_7, VAR_3, VAR_4, VAR_5,
VAR_6);
if ((VAR_5 == 1) && !(*VAR_4 & PAGE_WRITE)) {
trigger_prot_fault(VAR_0, VAR_1, VAR_2, VAR_5, VAR_6);
return -1;
}
return VAR_8;
}
| [
"static int FUNC_0(CPUS390XState *VAR_0, target_ulong VAR_1,\nuint64_t VAR_2, target_ulong *VAR_3, int *VAR_4,\nint VAR_5, bool VAR_6)\n{",
"uint64_t asce = 0;",
"int VAR_7;",
"int VAR_8;",
"switch (VAR_2) {",
"case PSW_ASC_PRIMARY:\nPTE_DPRINTF(\"%s: VAR_2=primary\\n\", __func__);",
"asce = VAR_0->creg... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
51
],
[... |
14,139 | void helper_check_tlb_flush(CPUPPCState *env)
{
check_tlb_flush(env);
}
| true | qemu | e3cffe6fad29e07d401eabb913a6d88501d5c143 | void helper_check_tlb_flush(CPUPPCState *env)
{
check_tlb_flush(env);
}
| {
"code": [
" check_tlb_flush(env);",
" check_tlb_flush(env);",
" check_tlb_flush(env);",
"void helper_check_tlb_flush(CPUPPCState *env)",
" check_tlb_flush(env);"
],
"line_no": [
5,
5,
5,
1,
5
]
} | void FUNC_0(CPUPPCState *VAR_0)
{
check_tlb_flush(VAR_0);
}
| [
"void FUNC_0(CPUPPCState *VAR_0)\n{",
"check_tlb_flush(VAR_0);",
"}"
] | [
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
14,140 | void *pci_assign_dev_load_option_rom(PCIDevice *dev, struct Object *owner,
int *size, unsigned int domain,
unsigned int bus, unsigned int slot,
unsigned int function)
{
char name[32], rom_file[64];
FILE *fp;
uint8_t val;
struct stat st;
void *ptr = NULL;
/* If loading ROM from file, pci handles it */
if (dev->romfile || !dev->rom_bar) {
return NULL;
}
snprintf(rom_file, sizeof(rom_file),
"/sys/bus/pci/devices/%04x:%02x:%02x.%01x/rom",
domain, bus, slot, function);
if (stat(rom_file, &st)) {
return NULL;
}
if (access(rom_file, F_OK)) {
error_report("pci-assign: Insufficient privileges for %s", rom_file);
return NULL;
}
/* Write "1" to the ROM file to enable it */
fp = fopen(rom_file, "r+");
if (fp == NULL) {
return NULL;
}
val = 1;
if (fwrite(&val, 1, 1, fp) != 1) {
goto close_rom;
}
fseek(fp, 0, SEEK_SET);
snprintf(name, sizeof(name), "%s.rom", object_get_typename(owner));
memory_region_init_ram(&dev->rom, owner, name, st.st_size, &error_abort);
vmstate_register_ram(&dev->rom, &dev->qdev);
ptr = memory_region_get_ram_ptr(&dev->rom);
memset(ptr, 0xff, st.st_size);
if (!fread(ptr, 1, st.st_size, fp)) {
error_report("pci-assign: Cannot read from host %s", rom_file);
error_printf("Device option ROM contents are probably invalid "
"(check dmesg).\nSkip option ROM probe with rombar=0, "
"or load from file with romfile=\n");
goto close_rom;
}
pci_register_bar(dev, PCI_ROM_SLOT, 0, &dev->rom);
dev->has_rom = true;
*size = st.st_size;
close_rom:
/* Write "0" to disable ROM */
fseek(fp, 0, SEEK_SET);
val = 0;
if (!fwrite(&val, 1, 1, fp)) {
DEBUG("%s\n", "Failed to disable pci-sysfs rom file");
}
fclose(fp);
return ptr;
}
| true | qemu | 6268520d7df9b3f183bb4397218c9287441bc04f | void *pci_assign_dev_load_option_rom(PCIDevice *dev, struct Object *owner,
int *size, unsigned int domain,
unsigned int bus, unsigned int slot,
unsigned int function)
{
char name[32], rom_file[64];
FILE *fp;
uint8_t val;
struct stat st;
void *ptr = NULL;
if (dev->romfile || !dev->rom_bar) {
return NULL;
}
snprintf(rom_file, sizeof(rom_file),
"/sys/bus/pci/devices/%04x:%02x:%02x.%01x/rom",
domain, bus, slot, function);
if (stat(rom_file, &st)) {
return NULL;
}
if (access(rom_file, F_OK)) {
error_report("pci-assign: Insufficient privileges for %s", rom_file);
return NULL;
}
fp = fopen(rom_file, "r+");
if (fp == NULL) {
return NULL;
}
val = 1;
if (fwrite(&val, 1, 1, fp) != 1) {
goto close_rom;
}
fseek(fp, 0, SEEK_SET);
snprintf(name, sizeof(name), "%s.rom", object_get_typename(owner));
memory_region_init_ram(&dev->rom, owner, name, st.st_size, &error_abort);
vmstate_register_ram(&dev->rom, &dev->qdev);
ptr = memory_region_get_ram_ptr(&dev->rom);
memset(ptr, 0xff, st.st_size);
if (!fread(ptr, 1, st.st_size, fp)) {
error_report("pci-assign: Cannot read from host %s", rom_file);
error_printf("Device option ROM contents are probably invalid "
"(check dmesg).\nSkip option ROM probe with rombar=0, "
"or load from file with romfile=\n");
goto close_rom;
}
pci_register_bar(dev, PCI_ROM_SLOT, 0, &dev->rom);
dev->has_rom = true;
*size = st.st_size;
close_rom:
fseek(fp, 0, SEEK_SET);
val = 0;
if (!fwrite(&val, 1, 1, fp)) {
DEBUG("%s\n", "Failed to disable pci-sysfs rom file");
}
fclose(fp);
return ptr;
}
| {
"code": [
" if (access(rom_file, F_OK)) {",
" error_report(\"pci-assign: Insufficient privileges for %s\", rom_file);",
" return NULL;"
],
"line_no": [
49,
51,
27
]
} | void *FUNC_0(PCIDevice *VAR_0, struct Object *VAR_1,
int *VAR_2, unsigned int VAR_3,
unsigned int VAR_4, unsigned int VAR_5,
unsigned int VAR_6)
{
char VAR_7[32], VAR_8[64];
FILE *fp;
uint8_t val;
struct stat VAR_9;
void *VAR_10 = NULL;
if (VAR_0->romfile || !VAR_0->rom_bar) {
return NULL;
}
snprintf(VAR_8, sizeof(VAR_8),
"/sys/VAR_4/pci/devices/%04x:%02x:%02x.%01x/rom",
VAR_3, VAR_4, VAR_5, VAR_6);
if (stat(VAR_8, &VAR_9)) {
return NULL;
}
if (access(VAR_8, F_OK)) {
error_report("pci-assign: Insufficient privileges for %s", VAR_8);
return NULL;
}
fp = fopen(VAR_8, "r+");
if (fp == NULL) {
return NULL;
}
val = 1;
if (fwrite(&val, 1, 1, fp) != 1) {
goto close_rom;
}
fseek(fp, 0, SEEK_SET);
snprintf(VAR_7, sizeof(VAR_7), "%s.rom", object_get_typename(VAR_1));
memory_region_init_ram(&VAR_0->rom, VAR_1, VAR_7, VAR_9.st_size, &error_abort);
vmstate_register_ram(&VAR_0->rom, &VAR_0->qdev);
VAR_10 = memory_region_get_ram_ptr(&VAR_0->rom);
memset(VAR_10, 0xff, VAR_9.st_size);
if (!fread(VAR_10, 1, VAR_9.st_size, fp)) {
error_report("pci-assign: Cannot read from host %s", VAR_8);
error_printf("Device option ROM contents are probably invalid "
"(check dmesg).\nSkip option ROM probe with rombar=0, "
"or load from file with romfile=\n");
goto close_rom;
}
pci_register_bar(VAR_0, PCI_ROM_SLOT, 0, &VAR_0->rom);
VAR_0->has_rom = true;
*VAR_2 = VAR_9.st_size;
close_rom:
fseek(fp, 0, SEEK_SET);
val = 0;
if (!fwrite(&val, 1, 1, fp)) {
DEBUG("%s\n", "Failed to disable pci-sysfs rom file");
}
fclose(fp);
return VAR_10;
}
| [
"void *FUNC_0(PCIDevice *VAR_0, struct Object *VAR_1,\nint *VAR_2, unsigned int VAR_3,\nunsigned int VAR_4, unsigned int VAR_5,\nunsigned int VAR_6)\n{",
"char VAR_7[32], VAR_8[64];",
"FILE *fp;",
"uint8_t val;",
"struct stat VAR_9;",
"void *VAR_10 = NULL;",
"if (VAR_0->romfile || !VAR_0->rom_bar) {",
... | [
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
33,
35,
37
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[... |
14,142 | static void nbd_reply_ready(void *opaque)
{
BDRVNBDState *s = opaque;
uint64_t i;
if (s->reply.handle == 0) {
/* No reply already in flight. Fetch a header. */
if (nbd_receive_reply(s->sock, &s->reply) < 0) {
s->reply.handle = 0;
goto fail;
}
}
/* There's no need for a mutex on the receive side, because the
* handler acts as a synchronization point and ensures that only
* one coroutine is called until the reply finishes. */
i = HANDLE_TO_INDEX(s, s->reply.handle);
if (i >= MAX_NBD_REQUESTS) {
goto fail;
}
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
return;
}
fail:
for (i = 0; i < MAX_NBD_REQUESTS; i++) {
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
}
}
}
| true | qemu | 7fe7b68b32ba609faeeee03556aac0eb1b187c91 | static void nbd_reply_ready(void *opaque)
{
BDRVNBDState *s = opaque;
uint64_t i;
if (s->reply.handle == 0) {
if (nbd_receive_reply(s->sock, &s->reply) < 0) {
s->reply.handle = 0;
goto fail;
}
}
i = HANDLE_TO_INDEX(s, s->reply.handle);
if (i >= MAX_NBD_REQUESTS) {
goto fail;
}
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
return;
}
fail:
for (i = 0; i < MAX_NBD_REQUESTS; i++) {
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
}
}
}
| {
"code": [
" if (nbd_receive_reply(s->sock, &s->reply) < 0) {"
],
"line_no": [
15
]
} | static void FUNC_0(void *VAR_0)
{
BDRVNBDState *s = VAR_0;
uint64_t i;
if (s->reply.handle == 0) {
if (nbd_receive_reply(s->sock, &s->reply) < 0) {
s->reply.handle = 0;
goto fail;
}
}
i = HANDLE_TO_INDEX(s, s->reply.handle);
if (i >= MAX_NBD_REQUESTS) {
goto fail;
}
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
return;
}
fail:
for (i = 0; i < MAX_NBD_REQUESTS; i++) {
if (s->recv_coroutine[i]) {
qemu_coroutine_enter(s->recv_coroutine[i], NULL);
}
}
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"BDRVNBDState *s = VAR_0;",
"uint64_t i;",
"if (s->reply.handle == 0) {",
"if (nbd_receive_reply(s->sock, &s->reply) < 0) {",
"s->reply.handle = 0;",
"goto fail;",
"}",
"}",
"i = HANDLE_TO_INDEX(s, s->reply.handle);",
"if (i >= MAX_NBD_REQUESTS) {",
"goto ... | [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53,
55
],
[
57
],
... |
14,143 | static void quantize_and_encode_band_cost_UPAIR12_mips(struct AACEncContext *s,
PutBitContext *pb, const float *in, float *out,
const float *scaled, int size, int scale_idx,
int cb, const float lambda, const float uplim,
int *bits, const float ROUNDING)
{
const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
const float IQ = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
int i;
int qc1, qc2, qc3, qc4;
uint8_t *p_bits = (uint8_t*) ff_aac_spectral_bits[cb-1];
uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[cb-1];
float *p_vec = (float *)ff_aac_codebook_vectors[cb-1];
abs_pow34_v(s->scoefs, in, size);
scaled = s->scoefs;
for (i = 0; i < size; i += 4) {
int curidx1, curidx2, sign1, count1, sign2, count2;
int *in_int = (int *)&in[i];
uint8_t v_bits;
unsigned int v_codes;
int t0, t1, t2, t3, t4;
const float *vec1, *vec2;
qc1 = scaled[i ] * Q34 + ROUND_STANDARD;
qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
__asm__ volatile (
".set push \n\t"
".set noreorder \n\t"
"ori %[t4], $zero, 12 \n\t"
"ori %[sign1], $zero, 0 \n\t"
"ori %[sign2], $zero, 0 \n\t"
"slt %[t0], %[t4], %[qc1] \n\t"
"slt %[t1], %[t4], %[qc2] \n\t"
"slt %[t2], %[t4], %[qc3] \n\t"
"slt %[t3], %[t4], %[qc4] \n\t"
"movn %[qc1], %[t4], %[t0] \n\t"
"movn %[qc2], %[t4], %[t1] \n\t"
"movn %[qc3], %[t4], %[t2] \n\t"
"movn %[qc4], %[t4], %[t3] \n\t"
"lw %[t0], 0(%[in_int]) \n\t"
"lw %[t1], 4(%[in_int]) \n\t"
"lw %[t2], 8(%[in_int]) \n\t"
"lw %[t3], 12(%[in_int]) \n\t"
"slt %[t0], %[t0], $zero \n\t"
"movn %[sign1], %[t0], %[qc1] \n\t"
"slt %[t2], %[t2], $zero \n\t"
"movn %[sign2], %[t2], %[qc3] \n\t"
"slt %[t1], %[t1], $zero \n\t"
"sll %[t0], %[sign1], 1 \n\t"
"or %[t0], %[t0], %[t1] \n\t"
"movn %[sign1], %[t0], %[qc2] \n\t"
"slt %[t3], %[t3], $zero \n\t"
"sll %[t0], %[sign2], 1 \n\t"
"or %[t0], %[t0], %[t3] \n\t"
"movn %[sign2], %[t0], %[qc4] \n\t"
"slt %[count1], $zero, %[qc1] \n\t"
"slt %[t1], $zero, %[qc2] \n\t"
"slt %[count2], $zero, %[qc3] \n\t"
"slt %[t2], $zero, %[qc4] \n\t"
"addu %[count1], %[count1], %[t1] \n\t"
"addu %[count2], %[count2], %[t2] \n\t"
".set pop \n\t"
: [qc1]"+r"(qc1), [qc2]"+r"(qc2),
[qc3]"+r"(qc3), [qc4]"+r"(qc4),
[sign1]"=&r"(sign1), [count1]"=&r"(count1),
[sign2]"=&r"(sign2), [count2]"=&r"(count2),
[t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
[t4]"=&r"(t4)
: [in_int]"r"(in_int)
: "memory"
);
curidx1 = 13 * qc1;
curidx1 += qc2;
v_codes = (p_codes[curidx1] << count1) | sign1;
v_bits = p_bits[curidx1] + count1;
put_bits(pb, v_bits, v_codes);
curidx2 = 13 * qc3;
curidx2 += qc4;
v_codes = (p_codes[curidx2] << count2) | sign2;
v_bits = p_bits[curidx2] + count2;
put_bits(pb, v_bits, v_codes);
if (out) {
vec1 = &p_vec[curidx1*2];
vec2 = &p_vec[curidx2*2];
out[i+0] = copysignf(vec1[0] * IQ, in[i+0]);
out[i+1] = copysignf(vec1[1] * IQ, in[i+1]);
out[i+2] = copysignf(vec2[0] * IQ, in[i+2]);
out[i+3] = copysignf(vec2[1] * IQ, in[i+3]);
}
}
}
| true | FFmpeg | 01ecb7172b684f1c4b3e748f95c5a9a494ca36ec | static void quantize_and_encode_band_cost_UPAIR12_mips(struct AACEncContext *s,
PutBitContext *pb, const float *in, float *out,
const float *scaled, int size, int scale_idx,
int cb, const float lambda, const float uplim,
int *bits, const float ROUNDING)
{
const float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
const float IQ = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
int i;
int qc1, qc2, qc3, qc4;
uint8_t *p_bits = (uint8_t*) ff_aac_spectral_bits[cb-1];
uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[cb-1];
float *p_vec = (float *)ff_aac_codebook_vectors[cb-1];
abs_pow34_v(s->scoefs, in, size);
scaled = s->scoefs;
for (i = 0; i < size; i += 4) {
int curidx1, curidx2, sign1, count1, sign2, count2;
int *in_int = (int *)&in[i];
uint8_t v_bits;
unsigned int v_codes;
int t0, t1, t2, t3, t4;
const float *vec1, *vec2;
qc1 = scaled[i ] * Q34 + ROUND_STANDARD;
qc2 = scaled[i+1] * Q34 + ROUND_STANDARD;
qc3 = scaled[i+2] * Q34 + ROUND_STANDARD;
qc4 = scaled[i+3] * Q34 + ROUND_STANDARD;
__asm__ volatile (
".set push \n\t"
".set noreorder \n\t"
"ori %[t4], $zero, 12 \n\t"
"ori %[sign1], $zero, 0 \n\t"
"ori %[sign2], $zero, 0 \n\t"
"slt %[t0], %[t4], %[qc1] \n\t"
"slt %[t1], %[t4], %[qc2] \n\t"
"slt %[t2], %[t4], %[qc3] \n\t"
"slt %[t3], %[t4], %[qc4] \n\t"
"movn %[qc1], %[t4], %[t0] \n\t"
"movn %[qc2], %[t4], %[t1] \n\t"
"movn %[qc3], %[t4], %[t2] \n\t"
"movn %[qc4], %[t4], %[t3] \n\t"
"lw %[t0], 0(%[in_int]) \n\t"
"lw %[t1], 4(%[in_int]) \n\t"
"lw %[t2], 8(%[in_int]) \n\t"
"lw %[t3], 12(%[in_int]) \n\t"
"slt %[t0], %[t0], $zero \n\t"
"movn %[sign1], %[t0], %[qc1] \n\t"
"slt %[t2], %[t2], $zero \n\t"
"movn %[sign2], %[t2], %[qc3] \n\t"
"slt %[t1], %[t1], $zero \n\t"
"sll %[t0], %[sign1], 1 \n\t"
"or %[t0], %[t0], %[t1] \n\t"
"movn %[sign1], %[t0], %[qc2] \n\t"
"slt %[t3], %[t3], $zero \n\t"
"sll %[t0], %[sign2], 1 \n\t"
"or %[t0], %[t0], %[t3] \n\t"
"movn %[sign2], %[t0], %[qc4] \n\t"
"slt %[count1], $zero, %[qc1] \n\t"
"slt %[t1], $zero, %[qc2] \n\t"
"slt %[count2], $zero, %[qc3] \n\t"
"slt %[t2], $zero, %[qc4] \n\t"
"addu %[count1], %[count1], %[t1] \n\t"
"addu %[count2], %[count2], %[t2] \n\t"
".set pop \n\t"
: [qc1]"+r"(qc1), [qc2]"+r"(qc2),
[qc3]"+r"(qc3), [qc4]"+r"(qc4),
[sign1]"=&r"(sign1), [count1]"=&r"(count1),
[sign2]"=&r"(sign2), [count2]"=&r"(count2),
[t0]"=&r"(t0), [t1]"=&r"(t1), [t2]"=&r"(t2), [t3]"=&r"(t3),
[t4]"=&r"(t4)
: [in_int]"r"(in_int)
: "memory"
);
curidx1 = 13 * qc1;
curidx1 += qc2;
v_codes = (p_codes[curidx1] << count1) | sign1;
v_bits = p_bits[curidx1] + count1;
put_bits(pb, v_bits, v_codes);
curidx2 = 13 * qc3;
curidx2 += qc4;
v_codes = (p_codes[curidx2] << count2) | sign2;
v_bits = p_bits[curidx2] + count2;
put_bits(pb, v_bits, v_codes);
if (out) {
vec1 = &p_vec[curidx1*2];
vec2 = &p_vec[curidx2*2];
out[i+0] = copysignf(vec1[0] * IQ, in[i+0]);
out[i+1] = copysignf(vec1[1] * IQ, in[i+1]);
out[i+2] = copysignf(vec2[0] * IQ, in[i+2]);
out[i+3] = copysignf(vec2[1] * IQ, in[i+3]);
}
}
}
| {
"code": [
" if (out) {",
" if (out) {",
" if (out) {",
" vec2 = &p_vec[curidx2*2];",
" if (out) {",
" vec1 = &p_vec[curidx1*2];",
" vec2 = &p_vec[curidx2*2];",
" out[i+0] = copysignf(vec1[0] * IQ, in[i+0]);",
" out[i+1] = copysignf(vec1[1] * IQ, in[i+1]);",
" out[i+2] = copysignf(vec2[0] * IQ, in[i+2]);",
" out[i+3] = copysignf(vec2[1] * IQ, in[i+3]);",
" int *bits, const float ROUNDING)",
" if (out) {",
" vec1 = &p_vec[curidx1*2];",
" vec2 = &p_vec[curidx2*2];",
" out[i+0] = copysignf(vec1[0] * IQ, in[i+0]);",
" out[i+1] = copysignf(vec1[1] * IQ, in[i+1]);",
" out[i+2] = copysignf(vec2[0] * IQ, in[i+2]);",
" out[i+3] = copysignf(vec2[1] * IQ, in[i+3]);"
],
"line_no": [
189,
189,
189,
193,
189,
191,
193,
195,
197,
199,
201,
9,
189,
191,
193,
195,
197,
199,
201
]
} | static void FUNC_0(struct AACEncContext *VAR_0,
PutBitContext *VAR_1, const float *VAR_2, float *VAR_3,
const float *VAR_4, int VAR_5, int VAR_6,
int VAR_7, const float VAR_8, const float VAR_9,
int *VAR_10, const float VAR_11)
{
const float VAR_12 = ff_aac_pow34sf_tab[POW_SF2_ZERO - VAR_6 + SCALE_ONE_POS - SCALE_DIV_512];
const float VAR_13 = ff_aac_pow2sf_tab [POW_SF2_ZERO + VAR_6 - SCALE_ONE_POS + SCALE_DIV_512];
int VAR_14;
int VAR_15, VAR_16, VAR_17, VAR_18;
uint8_t *p_bits = (uint8_t*) ff_aac_spectral_bits[VAR_7-1];
uint16_t *p_codes = (uint16_t*)ff_aac_spectral_codes[VAR_7-1];
float *VAR_19 = (float *)ff_aac_codebook_vectors[VAR_7-1];
abs_pow34_v(VAR_0->scoefs, VAR_2, VAR_5);
VAR_4 = VAR_0->scoefs;
for (VAR_14 = 0; VAR_14 < VAR_5; VAR_14 += 4) {
int VAR_20, VAR_21, VAR_22, VAR_23, VAR_24, VAR_25;
int *VAR_26 = (int *)&VAR_2[VAR_14];
uint8_t v_bits;
unsigned int VAR_27;
int VAR_28, VAR_29, VAR_30, VAR_31, VAR_32;
const float *VAR_33, *VAR_34;
VAR_15 = VAR_4[VAR_14 ] * VAR_12 + ROUND_STANDARD;
VAR_16 = VAR_4[VAR_14+1] * VAR_12 + ROUND_STANDARD;
VAR_17 = VAR_4[VAR_14+2] * VAR_12 + ROUND_STANDARD;
VAR_18 = VAR_4[VAR_14+3] * VAR_12 + ROUND_STANDARD;
__asm__ volatile (
".set push \n\t"
".set noreorder \n\t"
"ori %[VAR_32], $zero, 12 \n\t"
"ori %[VAR_22], $zero, 0 \n\t"
"ori %[VAR_24], $zero, 0 \n\t"
"slt %[VAR_28], %[VAR_32], %[VAR_15] \n\t"
"slt %[VAR_29], %[VAR_32], %[VAR_16] \n\t"
"slt %[VAR_30], %[VAR_32], %[VAR_17] \n\t"
"slt %[VAR_31], %[VAR_32], %[VAR_18] \n\t"
"movn %[VAR_15], %[VAR_32], %[VAR_28] \n\t"
"movn %[VAR_16], %[VAR_32], %[VAR_29] \n\t"
"movn %[VAR_17], %[VAR_32], %[VAR_30] \n\t"
"movn %[VAR_18], %[VAR_32], %[VAR_31] \n\t"
"lw %[VAR_28], 0(%[VAR_26]) \n\t"
"lw %[VAR_29], 4(%[VAR_26]) \n\t"
"lw %[VAR_30], 8(%[VAR_26]) \n\t"
"lw %[VAR_31], 12(%[VAR_26]) \n\t"
"slt %[VAR_28], %[VAR_28], $zero \n\t"
"movn %[VAR_22], %[VAR_28], %[VAR_15] \n\t"
"slt %[VAR_30], %[VAR_30], $zero \n\t"
"movn %[VAR_24], %[VAR_30], %[VAR_17] \n\t"
"slt %[VAR_29], %[VAR_29], $zero \n\t"
"sll %[VAR_28], %[VAR_22], 1 \n\t"
"or %[VAR_28], %[VAR_28], %[VAR_29] \n\t"
"movn %[VAR_22], %[VAR_28], %[VAR_16] \n\t"
"slt %[VAR_31], %[VAR_31], $zero \n\t"
"sll %[VAR_28], %[VAR_24], 1 \n\t"
"or %[VAR_28], %[VAR_28], %[VAR_31] \n\t"
"movn %[VAR_24], %[VAR_28], %[VAR_18] \n\t"
"slt %[VAR_23], $zero, %[VAR_15] \n\t"
"slt %[VAR_29], $zero, %[VAR_16] \n\t"
"slt %[VAR_25], $zero, %[VAR_17] \n\t"
"slt %[VAR_30], $zero, %[VAR_18] \n\t"
"addu %[VAR_23], %[VAR_23], %[VAR_29] \n\t"
"addu %[VAR_25], %[VAR_25], %[VAR_30] \n\t"
".set pop \n\t"
: [VAR_15]"+r"(VAR_15), [VAR_16]"+r"(VAR_16),
[VAR_17]"+r"(VAR_17), [VAR_18]"+r"(VAR_18),
[VAR_22]"=&r"(VAR_22), [VAR_23]"=&r"(VAR_23),
[VAR_24]"=&r"(VAR_24), [VAR_25]"=&r"(VAR_25),
[VAR_28]"=&r"(VAR_28), [VAR_29]"=&r"(VAR_29), [VAR_30]"=&r"(VAR_30), [VAR_31]"=&r"(VAR_31),
[VAR_32]"=&r"(VAR_32)
: [VAR_26]"r"(VAR_26)
: "memory"
);
VAR_20 = 13 * VAR_15;
VAR_20 += VAR_16;
VAR_27 = (p_codes[VAR_20] << VAR_23) | VAR_22;
v_bits = p_bits[VAR_20] + VAR_23;
put_bits(VAR_1, v_bits, VAR_27);
VAR_21 = 13 * VAR_17;
VAR_21 += VAR_18;
VAR_27 = (p_codes[VAR_21] << VAR_25) | VAR_24;
v_bits = p_bits[VAR_21] + VAR_25;
put_bits(VAR_1, v_bits, VAR_27);
if (VAR_3) {
VAR_33 = &VAR_19[VAR_20*2];
VAR_34 = &VAR_19[VAR_21*2];
VAR_3[VAR_14+0] = copysignf(VAR_33[0] * VAR_13, VAR_2[VAR_14+0]);
VAR_3[VAR_14+1] = copysignf(VAR_33[1] * VAR_13, VAR_2[VAR_14+1]);
VAR_3[VAR_14+2] = copysignf(VAR_34[0] * VAR_13, VAR_2[VAR_14+2]);
VAR_3[VAR_14+3] = copysignf(VAR_34[1] * VAR_13, VAR_2[VAR_14+3]);
}
}
}
| [
"static void FUNC_0(struct AACEncContext *VAR_0,\nPutBitContext *VAR_1, const float *VAR_2, float *VAR_3,\nconst float *VAR_4, int VAR_5, int VAR_6,\nint VAR_7, const float VAR_8, const float VAR_9,\nint *VAR_10, const float VAR_11)\n{",
"const float VAR_12 = ff_aac_pow34sf_tab[POW_SF2_ZERO - VAR_6 + SCALE_ONE_PO... | [
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,
1,
1,
1,
1,
1,
1,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
... |
14,145 | static int ast_probe(AVProbeData *p)
{
if (AV_RL32(p->buf) == MKTAG('S','T','R','M') &&
AV_RB16(p->buf + 10) &&
AV_RB16(p->buf + 12) &&
AV_RB32(p->buf + 16))
return AVPROBE_SCORE_MAX / 3 * 2;
return 0;
}
| true | FFmpeg | cbe84b4ffae4619417e119ed63d7c49826feac81 | static int ast_probe(AVProbeData *p)
{
if (AV_RL32(p->buf) == MKTAG('S','T','R','M') &&
AV_RB16(p->buf + 10) &&
AV_RB16(p->buf + 12) &&
AV_RB32(p->buf + 16))
return AVPROBE_SCORE_MAX / 3 * 2;
return 0;
}
| {
"code": [
" if (AV_RL32(p->buf) == MKTAG('S','T','R','M') &&",
" AV_RB16(p->buf + 10) &&",
" AV_RB16(p->buf + 12) &&",
" AV_RB32(p->buf + 16))",
" return AVPROBE_SCORE_MAX / 3 * 2;",
" return 0;"
],
"line_no": [
5,
7,
9,
11,
13,
15
]
} | static int FUNC_0(AVProbeData *VAR_0)
{
if (AV_RL32(VAR_0->buf) == MKTAG('S','T','R','M') &&
AV_RB16(VAR_0->buf + 10) &&
AV_RB16(VAR_0->buf + 12) &&
AV_RB32(VAR_0->buf + 16))
return AVPROBE_SCORE_MAX / 3 * 2;
return 0;
}
| [
"static int FUNC_0(AVProbeData *VAR_0)\n{",
"if (AV_RL32(VAR_0->buf) == MKTAG('S','T','R','M') &&\nAV_RB16(VAR_0->buf + 10) &&\nAV_RB16(VAR_0->buf + 12) &&\nAV_RB32(VAR_0->buf + 16))\nreturn AVPROBE_SCORE_MAX / 3 * 2;",
"return 0;",
"}"
] | [
0,
1,
1,
0
] | [
[
1,
3
],
[
5,
7,
9,
11,
13
],
[
15
],
[
17
]
] |
14,148 | target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
{
check_hwrena(env, 3);
return env->CCRes;
}
| true | qemu | d96391c1ffeb30a0afa695c86579517c69d9a889 | target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
{
check_hwrena(env, 3);
return env->CCRes;
}
| {
"code": [
" check_hwrena(env, 3);"
],
"line_no": [
5
]
} | target_ulong FUNC_0(CPUMIPSState *env)
{
check_hwrena(env, 3);
return env->CCRes;
}
| [
"target_ulong FUNC_0(CPUMIPSState *env)\n{",
"check_hwrena(env, 3);",
"return env->CCRes;",
"}"
] | [
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
14,149 | void qemu_get_guest_simple_memory_mapping(MemoryMappingList *list)
{
RAMBlock *block;
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
create_new_memory_mapping(list, block->offset, 0, block->length);
}
}
| true | qemu | 56c4bfb3f07f3107894c00281276aea4f5e8834d | void qemu_get_guest_simple_memory_mapping(MemoryMappingList *list)
{
RAMBlock *block;
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
create_new_memory_mapping(list, block->offset, 0, block->length);
}
}
| {
"code": [
" RAMBlock *block;",
" RAMBlock *block;",
" QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
" RAMBlock *block;",
" RAMBlock *block;",
" QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
" RAMBlock *block;",
" QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
"void qemu_get_guest_simple_memory_mapping(MemoryMappingList *list)",
" RAMBlock *block;",
" QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
" create_new_memory_mapping(list, block->offset, 0, block->length);",
" RAMBlock *block;"
],
"line_no": [
5,
5,
9,
5,
5,
9,
5,
9,
1,
5,
9,
11,
5
]
} | void FUNC_0(MemoryMappingList *VAR_0)
{
RAMBlock *block;
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
create_new_memory_mapping(VAR_0, block->offset, 0, block->length);
}
}
| [
"void FUNC_0(MemoryMappingList *VAR_0)\n{",
"RAMBlock *block;",
"QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
"create_new_memory_mapping(VAR_0, block->offset, 0, block->length);",
"}",
"}"
] | [
1,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
14,150 | static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
{
RPLContext *rpl = s->priv_data;
AVIOContext *pb = s->pb;
AVStream* stream;
AVIndexEntry* index_entry;
uint32_t ret;
if (rpl->chunk_part == s->nb_streams) {
rpl->chunk_number++;
rpl->chunk_part = 0;
}
stream = s->streams[rpl->chunk_part];
if (rpl->chunk_number >= stream->nb_index_entries)
return AVERROR_EOF;
index_entry = &stream->index_entries[rpl->chunk_number];
if (rpl->frame_in_part == 0)
if (avio_seek(pb, index_entry->pos, SEEK_SET) < 0)
return AVERROR(EIO);
if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
stream->codec->codec_tag == 124) {
// We have to split Escape 124 frames because there are
// multiple frames per chunk in Escape 124 samples.
uint32_t frame_size;
avio_skip(pb, 4); /* flags */
frame_size = avio_rl32(pb);
if (avio_seek(pb, -8, SEEK_CUR) < 0)
return AVERROR(EIO);
ret = av_get_packet(pb, pkt, frame_size);
if (ret != frame_size) {
av_free_packet(pkt);
return AVERROR(EIO);
}
pkt->duration = 1;
pkt->pts = index_entry->timestamp + rpl->frame_in_part;
pkt->stream_index = rpl->chunk_part;
rpl->frame_in_part++;
if (rpl->frame_in_part == rpl->frames_per_chunk) {
rpl->frame_in_part = 0;
rpl->chunk_part++;
}
} else {
ret = av_get_packet(pb, pkt, index_entry->size);
if (ret != index_entry->size) {
av_free_packet(pkt);
return AVERROR(EIO);
}
if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
// frames_per_chunk should always be one here; the header
// parsing will warn if it isn't.
pkt->duration = rpl->frames_per_chunk;
} else {
// All the audio codecs supported in this container
// (at least so far) are constant-bitrate.
pkt->duration = ret * 8;
}
pkt->pts = index_entry->timestamp;
pkt->stream_index = rpl->chunk_part;
rpl->chunk_part++;
}
// None of the Escape formats have keyframes, and the ADPCM
// format used doesn't have keyframes.
if (rpl->chunk_number == 0 && rpl->frame_in_part == 0)
pkt->flags |= AV_PKT_FLAG_KEY;
return ret;
}
| true | FFmpeg | f968166439e4d4fc9f352ea20b8922d42ca5c7b1 | static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
{
RPLContext *rpl = s->priv_data;
AVIOContext *pb = s->pb;
AVStream* stream;
AVIndexEntry* index_entry;
uint32_t ret;
if (rpl->chunk_part == s->nb_streams) {
rpl->chunk_number++;
rpl->chunk_part = 0;
}
stream = s->streams[rpl->chunk_part];
if (rpl->chunk_number >= stream->nb_index_entries)
return AVERROR_EOF;
index_entry = &stream->index_entries[rpl->chunk_number];
if (rpl->frame_in_part == 0)
if (avio_seek(pb, index_entry->pos, SEEK_SET) < 0)
return AVERROR(EIO);
if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
stream->codec->codec_tag == 124) {
uint32_t frame_size;
avio_skip(pb, 4);
frame_size = avio_rl32(pb);
if (avio_seek(pb, -8, SEEK_CUR) < 0)
return AVERROR(EIO);
ret = av_get_packet(pb, pkt, frame_size);
if (ret != frame_size) {
av_free_packet(pkt);
return AVERROR(EIO);
}
pkt->duration = 1;
pkt->pts = index_entry->timestamp + rpl->frame_in_part;
pkt->stream_index = rpl->chunk_part;
rpl->frame_in_part++;
if (rpl->frame_in_part == rpl->frames_per_chunk) {
rpl->frame_in_part = 0;
rpl->chunk_part++;
}
} else {
ret = av_get_packet(pb, pkt, index_entry->size);
if (ret != index_entry->size) {
av_free_packet(pkt);
return AVERROR(EIO);
}
if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
pkt->duration = rpl->frames_per_chunk;
} else {
pkt->duration = ret * 8;
}
pkt->pts = index_entry->timestamp;
pkt->stream_index = rpl->chunk_part;
rpl->chunk_part++;
}
if (rpl->chunk_number == 0 && rpl->frame_in_part == 0)
pkt->flags |= AV_PKT_FLAG_KEY;
return ret;
}
| {
"code": [
" uint32_t ret;"
],
"line_no": [
13
]
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
RPLContext *rpl = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
AVStream* stream;
AVIndexEntry* index_entry;
uint32_t ret;
if (rpl->chunk_part == VAR_0->nb_streams) {
rpl->chunk_number++;
rpl->chunk_part = 0;
}
stream = VAR_0->streams[rpl->chunk_part];
if (rpl->chunk_number >= stream->nb_index_entries)
return AVERROR_EOF;
index_entry = &stream->index_entries[rpl->chunk_number];
if (rpl->frame_in_part == 0)
if (avio_seek(pb, index_entry->pos, SEEK_SET) < 0)
return AVERROR(EIO);
if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
stream->codec->codec_tag == 124) {
uint32_t frame_size;
avio_skip(pb, 4);
frame_size = avio_rl32(pb);
if (avio_seek(pb, -8, SEEK_CUR) < 0)
return AVERROR(EIO);
ret = av_get_packet(pb, VAR_1, frame_size);
if (ret != frame_size) {
av_free_packet(VAR_1);
return AVERROR(EIO);
}
VAR_1->duration = 1;
VAR_1->pts = index_entry->timestamp + rpl->frame_in_part;
VAR_1->stream_index = rpl->chunk_part;
rpl->frame_in_part++;
if (rpl->frame_in_part == rpl->frames_per_chunk) {
rpl->frame_in_part = 0;
rpl->chunk_part++;
}
} else {
ret = av_get_packet(pb, VAR_1, index_entry->size);
if (ret != index_entry->size) {
av_free_packet(VAR_1);
return AVERROR(EIO);
}
if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
VAR_1->duration = rpl->frames_per_chunk;
} else {
VAR_1->duration = ret * 8;
}
VAR_1->pts = index_entry->timestamp;
VAR_1->stream_index = rpl->chunk_part;
rpl->chunk_part++;
}
if (rpl->chunk_number == 0 && rpl->frame_in_part == 0)
VAR_1->flags |= AV_PKT_FLAG_KEY;
return ret;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"RPLContext *rpl = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"AVStream* stream;",
"AVIndexEntry* index_entry;",
"uint32_t ret;",
"if (rpl->chunk_part == VAR_0->nb_streams) {",
"rpl->chunk_number++;",
"rpl->chunk_part = 0;",
... | [
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
31,
33
],
[
37
],
[
41,
43,
45
],
[
49,
51
],
[
57
],
[
61
],
[
63
... |
14,151 | static void acpi_set_pci_info(void)
{
PCIBus *bus = find_i440fx(); /* TODO: Q35 support */
unsigned bsel_alloc = 0;
if (bus) {
/* Scan all PCI buses. Set property to enable acpi based hotplug. */
pci_for_each_bus_depth_first(bus, acpi_set_bsel, NULL, &bsel_alloc);
}
}
| true | qemu | f0c9d64a68b776374ec4732424a3e27753ce37b6 | static void acpi_set_pci_info(void)
{
PCIBus *bus = find_i440fx();
unsigned bsel_alloc = 0;
if (bus) {
pci_for_each_bus_depth_first(bus, acpi_set_bsel, NULL, &bsel_alloc);
}
}
| {
"code": [
" unsigned bsel_alloc = 0;"
],
"line_no": [
7
]
} | static void FUNC_0(void)
{
PCIBus *bus = find_i440fx();
unsigned VAR_0 = 0;
if (bus) {
pci_for_each_bus_depth_first(bus, acpi_set_bsel, NULL, &VAR_0);
}
}
| [
"static void FUNC_0(void)\n{",
"PCIBus *bus = find_i440fx();",
"unsigned VAR_0 = 0;",
"if (bus) {",
"pci_for_each_bus_depth_first(bus, acpi_set_bsel, NULL, &VAR_0);",
"}",
"}"
] | [
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
]
] |
14,152 | static void qvirtio_pci_set_features(QVirtioDevice *d, uint32_t features)
{
QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
qpci_io_writel(dev->pdev, dev->addr + VIRTIO_PCI_GUEST_FEATURES, features);
}
| true | qemu | b4ba67d9a702507793c2724e56f98e9b0f7be02b | static void qvirtio_pci_set_features(QVirtioDevice *d, uint32_t features)
{
QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
qpci_io_writel(dev->pdev, dev->addr + VIRTIO_PCI_GUEST_FEATURES, features);
}
| {
"code": [
" qpci_io_writel(dev->pdev, dev->addr + VIRTIO_PCI_GUEST_FEATURES, features);"
],
"line_no": [
7
]
} | static void FUNC_0(QVirtioDevice *VAR_0, uint32_t VAR_1)
{
QVirtioPCIDevice *dev = (QVirtioPCIDevice *)VAR_0;
qpci_io_writel(dev->pdev, dev->addr + VIRTIO_PCI_GUEST_FEATURES, VAR_1);
}
| [
"static void FUNC_0(QVirtioDevice *VAR_0, uint32_t VAR_1)\n{",
"QVirtioPCIDevice *dev = (QVirtioPCIDevice *)VAR_0;",
"qpci_io_writel(dev->pdev, dev->addr + VIRTIO_PCI_GUEST_FEATURES, VAR_1);",
"}"
] | [
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
14,153 | static int xhci_fire_ctl_transfer(XHCIState *xhci, XHCITransfer *xfer)
{
XHCITRB *trb_setup, *trb_status;
uint8_t bmRequestType, bRequest;
uint16_t wValue, wLength, wIndex;
XHCIPort *port;
USBDevice *dev;
int ret;
DPRINTF("xhci_fire_ctl_transfer(slot=%d)\n", xfer->slotid);
trb_setup = &xfer->trbs[0];
trb_status = &xfer->trbs[xfer->trb_count-1];
/* at most one Event Data TRB allowed after STATUS */
if (TRB_TYPE(*trb_status) == TR_EVDATA && xfer->trb_count > 2) {
trb_status--;
}
/* do some sanity checks */
if (TRB_TYPE(*trb_setup) != TR_SETUP) {
fprintf(stderr, "xhci: ep0 first TD not SETUP: %d\n",
TRB_TYPE(*trb_setup));
return -1;
}
if (TRB_TYPE(*trb_status) != TR_STATUS) {
fprintf(stderr, "xhci: ep0 last TD not STATUS: %d\n",
TRB_TYPE(*trb_status));
return -1;
}
if (!(trb_setup->control & TRB_TR_IDT)) {
fprintf(stderr, "xhci: Setup TRB doesn't have IDT set\n");
return -1;
}
if ((trb_setup->status & 0x1ffff) != 8) {
fprintf(stderr, "xhci: Setup TRB has bad length (%d)\n",
(trb_setup->status & 0x1ffff));
return -1;
}
bmRequestType = trb_setup->parameter;
bRequest = trb_setup->parameter >> 8;
wValue = trb_setup->parameter >> 16;
wIndex = trb_setup->parameter >> 32;
wLength = trb_setup->parameter >> 48;
if (xfer->data && xfer->data_alloced < wLength) {
xfer->data_alloced = 0;
g_free(xfer->data);
xfer->data = NULL;
}
if (!xfer->data) {
DPRINTF("xhci: alloc %d bytes data\n", wLength);
xfer->data = g_malloc(wLength+1);
xfer->data_alloced = wLength;
}
xfer->data_length = wLength;
port = &xhci->ports[xhci->slots[xfer->slotid-1].port-1];
dev = xhci_find_device(port, xhci->slots[xfer->slotid-1].devaddr);
if (!dev) {
fprintf(stderr, "xhci: slot %d port %d has no device\n", xfer->slotid,
xhci->slots[xfer->slotid-1].port);
return -1;
}
xfer->in_xfer = bmRequestType & USB_DIR_IN;
xfer->iso_xfer = false;
xhci_setup_packet(xfer, dev);
if (!xfer->in_xfer) {
xhci_xfer_data(xfer, xfer->data, wLength, 0, 1, 0);
}
ret = usb_device_handle_control(dev, &xfer->packet,
(bmRequestType << 8) | bRequest,
wValue, wIndex, wLength, xfer->data);
xhci_complete_packet(xfer, ret);
if (!xfer->running_async && !xfer->running_retry) {
xhci_kick_ep(xhci, xfer->slotid, xfer->epid);
}
return 0;
}
| true | qemu | 2850ca9ed1023ce30ecd0582a66ded7a180e7616 | static int xhci_fire_ctl_transfer(XHCIState *xhci, XHCITransfer *xfer)
{
XHCITRB *trb_setup, *trb_status;
uint8_t bmRequestType, bRequest;
uint16_t wValue, wLength, wIndex;
XHCIPort *port;
USBDevice *dev;
int ret;
DPRINTF("xhci_fire_ctl_transfer(slot=%d)\n", xfer->slotid);
trb_setup = &xfer->trbs[0];
trb_status = &xfer->trbs[xfer->trb_count-1];
if (TRB_TYPE(*trb_status) == TR_EVDATA && xfer->trb_count > 2) {
trb_status--;
}
if (TRB_TYPE(*trb_setup) != TR_SETUP) {
fprintf(stderr, "xhci: ep0 first TD not SETUP: %d\n",
TRB_TYPE(*trb_setup));
return -1;
}
if (TRB_TYPE(*trb_status) != TR_STATUS) {
fprintf(stderr, "xhci: ep0 last TD not STATUS: %d\n",
TRB_TYPE(*trb_status));
return -1;
}
if (!(trb_setup->control & TRB_TR_IDT)) {
fprintf(stderr, "xhci: Setup TRB doesn't have IDT set\n");
return -1;
}
if ((trb_setup->status & 0x1ffff) != 8) {
fprintf(stderr, "xhci: Setup TRB has bad length (%d)\n",
(trb_setup->status & 0x1ffff));
return -1;
}
bmRequestType = trb_setup->parameter;
bRequest = trb_setup->parameter >> 8;
wValue = trb_setup->parameter >> 16;
wIndex = trb_setup->parameter >> 32;
wLength = trb_setup->parameter >> 48;
if (xfer->data && xfer->data_alloced < wLength) {
xfer->data_alloced = 0;
g_free(xfer->data);
xfer->data = NULL;
}
if (!xfer->data) {
DPRINTF("xhci: alloc %d bytes data\n", wLength);
xfer->data = g_malloc(wLength+1);
xfer->data_alloced = wLength;
}
xfer->data_length = wLength;
port = &xhci->ports[xhci->slots[xfer->slotid-1].port-1];
dev = xhci_find_device(port, xhci->slots[xfer->slotid-1].devaddr);
if (!dev) {
fprintf(stderr, "xhci: slot %d port %d has no device\n", xfer->slotid,
xhci->slots[xfer->slotid-1].port);
return -1;
}
xfer->in_xfer = bmRequestType & USB_DIR_IN;
xfer->iso_xfer = false;
xhci_setup_packet(xfer, dev);
if (!xfer->in_xfer) {
xhci_xfer_data(xfer, xfer->data, wLength, 0, 1, 0);
}
ret = usb_device_handle_control(dev, &xfer->packet,
(bmRequestType << 8) | bRequest,
wValue, wIndex, wLength, xfer->data);
xhci_complete_packet(xfer, ret);
if (!xfer->running_async && !xfer->running_retry) {
xhci_kick_ep(xhci, xfer->slotid, xfer->epid);
}
return 0;
}
| {
"code": [
" uint8_t bmRequestType, bRequest;",
" uint16_t wValue, wLength, wIndex;",
" bRequest = trb_setup->parameter >> 8;",
" wValue = trb_setup->parameter >> 16;",
" wIndex = trb_setup->parameter >> 32;",
" ret = usb_device_handle_control(dev, &xfer->packet,",
" (bmRequestType << 8) | bRequest,",
" wValue, wIndex, wLength, xfer->data);"
],
"line_no": [
7,
9,
83,
85,
87,
147,
149,
151
]
} | static int FUNC_0(XHCIState *VAR_0, XHCITransfer *VAR_1)
{
XHCITRB *trb_setup, *trb_status;
uint8_t bmRequestType, bRequest;
uint16_t wValue, wLength, wIndex;
XHCIPort *port;
USBDevice *dev;
int VAR_2;
DPRINTF("FUNC_0(slot=%d)\n", VAR_1->slotid);
trb_setup = &VAR_1->trbs[0];
trb_status = &VAR_1->trbs[VAR_1->trb_count-1];
if (TRB_TYPE(*trb_status) == TR_EVDATA && VAR_1->trb_count > 2) {
trb_status--;
}
if (TRB_TYPE(*trb_setup) != TR_SETUP) {
fprintf(stderr, "VAR_0: ep0 first TD not SETUP: %d\n",
TRB_TYPE(*trb_setup));
return -1;
}
if (TRB_TYPE(*trb_status) != TR_STATUS) {
fprintf(stderr, "VAR_0: ep0 last TD not STATUS: %d\n",
TRB_TYPE(*trb_status));
return -1;
}
if (!(trb_setup->control & TRB_TR_IDT)) {
fprintf(stderr, "VAR_0: Setup TRB doesn't have IDT set\n");
return -1;
}
if ((trb_setup->status & 0x1ffff) != 8) {
fprintf(stderr, "VAR_0: Setup TRB has bad length (%d)\n",
(trb_setup->status & 0x1ffff));
return -1;
}
bmRequestType = trb_setup->parameter;
bRequest = trb_setup->parameter >> 8;
wValue = trb_setup->parameter >> 16;
wIndex = trb_setup->parameter >> 32;
wLength = trb_setup->parameter >> 48;
if (VAR_1->data && VAR_1->data_alloced < wLength) {
VAR_1->data_alloced = 0;
g_free(VAR_1->data);
VAR_1->data = NULL;
}
if (!VAR_1->data) {
DPRINTF("VAR_0: alloc %d bytes data\n", wLength);
VAR_1->data = g_malloc(wLength+1);
VAR_1->data_alloced = wLength;
}
VAR_1->data_length = wLength;
port = &VAR_0->ports[VAR_0->slots[VAR_1->slotid-1].port-1];
dev = xhci_find_device(port, VAR_0->slots[VAR_1->slotid-1].devaddr);
if (!dev) {
fprintf(stderr, "VAR_0: slot %d port %d has no device\n", VAR_1->slotid,
VAR_0->slots[VAR_1->slotid-1].port);
return -1;
}
VAR_1->in_xfer = bmRequestType & USB_DIR_IN;
VAR_1->iso_xfer = false;
xhci_setup_packet(VAR_1, dev);
if (!VAR_1->in_xfer) {
xhci_xfer_data(VAR_1, VAR_1->data, wLength, 0, 1, 0);
}
VAR_2 = usb_device_handle_control(dev, &VAR_1->packet,
(bmRequestType << 8) | bRequest,
wValue, wIndex, wLength, VAR_1->data);
xhci_complete_packet(VAR_1, VAR_2);
if (!VAR_1->running_async && !VAR_1->running_retry) {
xhci_kick_ep(VAR_0, VAR_1->slotid, VAR_1->epid);
}
return 0;
}
| [
"static int FUNC_0(XHCIState *VAR_0, XHCITransfer *VAR_1)\n{",
"XHCITRB *trb_setup, *trb_status;",
"uint8_t bmRequestType, bRequest;",
"uint16_t wValue, wLength, wIndex;",
"XHCIPort *port;",
"USBDevice *dev;",
"int VAR_2;",
"DPRINTF(\"FUNC_0(slot=%d)\\n\", VAR_1->slotid);",
"trb_setup = &VAR_1->trbs... | [
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
31
],
[
33
],
[
35
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
51
],
[
53,
55
... |
14,154 | static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c)
{
DCAContext *dca = s->avctx->priv_data;
int ch, nsamples = s->nframesamples;
DCAXllChSet *o;
// Verify that core is compatible
if (!(dca->packet & DCA_PACKET_CORE)) {
av_log(s->avctx, AV_LOG_ERROR, "Residual encoded channels are present without core\n");
return AVERROR(EINVAL);
}
if (c->freq != dca->core.output_rate) {
av_log(s->avctx, AV_LOG_WARNING, "Sample rate mismatch between core (%d Hz) and XLL (%d Hz)\n", dca->core.output_rate, c->freq);
return AVERROR_INVALIDDATA;
}
if (nsamples != dca->core.npcmsamples) {
av_log(s->avctx, AV_LOG_WARNING, "Number of samples per frame mismatch between core (%d) and XLL (%d)\n", dca->core.npcmsamples, nsamples);
return AVERROR_INVALIDDATA;
}
// See if this channel set is downmixed and find the next channel set in
// hierarchy. If downmixed, undo core pre-scaling before combining with
// residual (residual is not scaled).
o = find_next_hier_dmix_chset(s, c);
// Reduce core bit width and combine with residual
for (ch = 0; ch < c->nchannels; ch++) {
int n, spkr, shift, round;
int32_t *src, *dst;
if (c->residual_encode & (1 << ch))
continue;
// Map this channel to core speaker
spkr = ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]);
if (spkr < 0) {
av_log(s->avctx, AV_LOG_WARNING, "Residual encoded channel (%d) references unavailable core channel\n", c->ch_remap[ch]);
return AVERROR_INVALIDDATA;
}
// Account for LSB width
shift = 24 - c->pcm_bit_res + chs_get_lsb_width(s, c, 0, ch);
if (shift > 24) {
av_log(s->avctx, AV_LOG_WARNING, "Invalid core shift (%d bits)\n", shift);
return AVERROR_INVALIDDATA;
}
round = shift > 0 ? 1 << (shift - 1) : 0;
src = dca->core.output_samples[spkr];
dst = c->bands[0].msb_sample_buffer[ch];
if (o) {
// Undo embedded core downmix pre-scaling
int scale_inv = o->dmix_scale_inv[c->hier_ofs + ch];
for (n = 0; n < nsamples; n++)
dst[n] += (SUINT)clip23((mul16(src[n], scale_inv) + round) >> shift);
} else {
// No downmix scaling
for (n = 0; n < nsamples; n++)
dst[n] += (src[n] + round) >> shift;
}
}
return 0;
}
| true | FFmpeg | ce010655a6b82d49bd8df179d73bcb5802a273c1 | static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c)
{
DCAContext *dca = s->avctx->priv_data;
int ch, nsamples = s->nframesamples;
DCAXllChSet *o;
if (!(dca->packet & DCA_PACKET_CORE)) {
av_log(s->avctx, AV_LOG_ERROR, "Residual encoded channels are present without core\n");
return AVERROR(EINVAL);
}
if (c->freq != dca->core.output_rate) {
av_log(s->avctx, AV_LOG_WARNING, "Sample rate mismatch between core (%d Hz) and XLL (%d Hz)\n", dca->core.output_rate, c->freq);
return AVERROR_INVALIDDATA;
}
if (nsamples != dca->core.npcmsamples) {
av_log(s->avctx, AV_LOG_WARNING, "Number of samples per frame mismatch between core (%d) and XLL (%d)\n", dca->core.npcmsamples, nsamples);
return AVERROR_INVALIDDATA;
}
o = find_next_hier_dmix_chset(s, c);
for (ch = 0; ch < c->nchannels; ch++) {
int n, spkr, shift, round;
int32_t *src, *dst;
if (c->residual_encode & (1 << ch))
continue;
spkr = ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]);
if (spkr < 0) {
av_log(s->avctx, AV_LOG_WARNING, "Residual encoded channel (%d) references unavailable core channel\n", c->ch_remap[ch]);
return AVERROR_INVALIDDATA;
}
shift = 24 - c->pcm_bit_res + chs_get_lsb_width(s, c, 0, ch);
if (shift > 24) {
av_log(s->avctx, AV_LOG_WARNING, "Invalid core shift (%d bits)\n", shift);
return AVERROR_INVALIDDATA;
}
round = shift > 0 ? 1 << (shift - 1) : 0;
src = dca->core.output_samples[spkr];
dst = c->bands[0].msb_sample_buffer[ch];
if (o) {
int scale_inv = o->dmix_scale_inv[c->hier_ofs + ch];
for (n = 0; n < nsamples; n++)
dst[n] += (SUINT)clip23((mul16(src[n], scale_inv) + round) >> shift);
} else {
for (n = 0; n < nsamples; n++)
dst[n] += (src[n] + round) >> shift;
}
}
return 0;
}
| {
"code": [
" dst[n] += (src[n] + round) >> shift;"
],
"line_no": [
123
]
} | static int FUNC_0(DCAXllDecoder *VAR_0, DCAXllChSet *VAR_1)
{
DCAContext *dca = VAR_0->avctx->priv_data;
int VAR_2, VAR_3 = VAR_0->nframesamples;
DCAXllChSet *o;
if (!(dca->packet & DCA_PACKET_CORE)) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Residual encoded channels are present without core\n");
return AVERROR(EINVAL);
}
if (VAR_1->freq != dca->core.output_rate) {
av_log(VAR_0->avctx, AV_LOG_WARNING, "Sample rate mismatch between core (%d Hz) and XLL (%d Hz)\n", dca->core.output_rate, VAR_1->freq);
return AVERROR_INVALIDDATA;
}
if (VAR_3 != dca->core.npcmsamples) {
av_log(VAR_0->avctx, AV_LOG_WARNING, "Number of samples per frame mismatch between core (%d) and XLL (%d)\n", dca->core.npcmsamples, VAR_3);
return AVERROR_INVALIDDATA;
}
o = find_next_hier_dmix_chset(VAR_0, VAR_1);
for (VAR_2 = 0; VAR_2 < VAR_1->nchannels; VAR_2++) {
int n, spkr, shift, round;
int32_t *src, *dst;
if (VAR_1->residual_encode & (1 << VAR_2))
continue;
spkr = ff_dca_core_map_spkr(&dca->core, VAR_1->ch_remap[VAR_2]);
if (spkr < 0) {
av_log(VAR_0->avctx, AV_LOG_WARNING, "Residual encoded channel (%d) references unavailable core channel\n", VAR_1->ch_remap[VAR_2]);
return AVERROR_INVALIDDATA;
}
shift = 24 - VAR_1->pcm_bit_res + chs_get_lsb_width(VAR_0, VAR_1, 0, VAR_2);
if (shift > 24) {
av_log(VAR_0->avctx, AV_LOG_WARNING, "Invalid core shift (%d bits)\n", shift);
return AVERROR_INVALIDDATA;
}
round = shift > 0 ? 1 << (shift - 1) : 0;
src = dca->core.output_samples[spkr];
dst = VAR_1->bands[0].msb_sample_buffer[VAR_2];
if (o) {
int scale_inv = o->dmix_scale_inv[VAR_1->hier_ofs + VAR_2];
for (n = 0; n < VAR_3; n++)
dst[n] += (SUINT)clip23((mul16(src[n], scale_inv) + round) >> shift);
} else {
for (n = 0; n < VAR_3; n++)
dst[n] += (src[n] + round) >> shift;
}
}
return 0;
}
| [
"static int FUNC_0(DCAXllDecoder *VAR_0, DCAXllChSet *VAR_1)\n{",
"DCAContext *dca = VAR_0->avctx->priv_data;",
"int VAR_2, VAR_3 = VAR_0->nframesamples;",
"DCAXllChSet *o;",
"if (!(dca->packet & DCA_PACKET_CORE)) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"Residual encoded channels are present without core... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
51
],
[
57
],
[
59
],
[
61
... |
14,155 | static void boston_mach_class_init(MachineClass *mc)
{
mc->desc = "MIPS Boston";
mc->init = boston_mach_init;
mc->block_default_type = IF_IDE;
mc->default_ram_size = 2 * G_BYTE;
mc->max_cpus = 16;
}
| true | qemu | 2d896b454a0e19ec4c1ddbb0e0b65b7e54fcedf3 | static void boston_mach_class_init(MachineClass *mc)
{
mc->desc = "MIPS Boston";
mc->init = boston_mach_init;
mc->block_default_type = IF_IDE;
mc->default_ram_size = 2 * G_BYTE;
mc->max_cpus = 16;
}
| {
"code": [
"static void boston_mach_class_init(MachineClass *mc)",
" mc->desc = \"MIPS Boston\";",
" mc->init = boston_mach_init;",
" mc->block_default_type = IF_IDE;",
" mc->default_ram_size = 2 * G_BYTE;",
" mc->max_cpus = 16;"
],
"line_no": [
1,
5,
7,
9,
11,
13
]
} | static void FUNC_0(MachineClass *VAR_0)
{
VAR_0->desc = "MIPS Boston";
VAR_0->init = boston_mach_init;
VAR_0->block_default_type = IF_IDE;
VAR_0->default_ram_size = 2 * G_BYTE;
VAR_0->max_cpus = 16;
}
| [
"static void FUNC_0(MachineClass *VAR_0)\n{",
"VAR_0->desc = \"MIPS Boston\";",
"VAR_0->init = boston_mach_init;",
"VAR_0->block_default_type = IF_IDE;",
"VAR_0->default_ram_size = 2 * G_BYTE;",
"VAR_0->max_cpus = 16;",
"}"
] | [
1,
1,
1,
1,
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
14,156 | PAETH(mmx2, ABS3_MMX2)
#ifdef HAVE_SSSE3
PAETH(ssse3, ABS3_SSSE3)
#endif
#define QPEL_V_LOW(m3,m4,m5,m6, pw_20, pw_3, rnd, in0, in1, in2, in7, out, OP)\
"paddw " #m4 ", " #m3 " \n\t" /* x1 */\
"movq "MANGLE(ff_pw_20)", %%mm4 \n\t" /* 20 */\
"pmullw " #m3 ", %%mm4 \n\t" /* 20x1 */\
"movq "#in7", " #m3 " \n\t" /* d */\
"movq "#in0", %%mm5 \n\t" /* D */\
"paddw " #m3 ", %%mm5 \n\t" /* x4 */\
"psubw %%mm5, %%mm4 \n\t" /* 20x1 - x4 */\
"movq "#in1", %%mm5 \n\t" /* C */\
"movq "#in2", %%mm6 \n\t" /* B */\
"paddw " #m6 ", %%mm5 \n\t" /* x3 */\
"paddw " #m5 ", %%mm6 \n\t" /* x2 */\
"paddw %%mm6, %%mm6 \n\t" /* 2x2 */\
"psubw %%mm6, %%mm5 \n\t" /* -2x2 + x3 */\
"pmullw "MANGLE(ff_pw_3)", %%mm5 \n\t" /* -6x2 + 3x3 */\
"paddw " #rnd ", %%mm4 \n\t" /* x2 */\
"paddw %%mm4, %%mm5 \n\t" /* 20x1 - 6x2 + 3x3 - x4 */\
"psraw $5, %%mm5 \n\t"\
"packuswb %%mm5, %%mm5 \n\t"\
OP(%%mm5, out, %%mm7, d)
#define QPEL_BASE(OPNAME, ROUNDER, RND, OP_MMX2, OP_3DNOW)\
static void OPNAME ## mpeg4_qpel16_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
uint64_t temp;\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t" /* ABCDEFGH */\
"movq %%mm0, %%mm1 \n\t" /* ABCDEFGH */\
"movq %%mm0, %%mm2 \n\t" /* ABCDEFGH */\
"punpcklbw %%mm7, %%mm0 \n\t" /* 0A0B0C0D */\
"punpckhbw %%mm7, %%mm1 \n\t" /* 0E0F0G0H */\
"pshufw $0x90, %%mm0, %%mm5 \n\t" /* 0A0A0B0C */\
"pshufw $0x41, %%mm0, %%mm6 \n\t" /* 0B0A0A0B */\
"movq %%mm2, %%mm3 \n\t" /* ABCDEFGH */\
"movq %%mm2, %%mm4 \n\t" /* ABCDEFGH */\
"psllq $8, %%mm2 \n\t" /* 0ABCDEFG */\
"psllq $16, %%mm3 \n\t" /* 00ABCDEF */\
"psllq $24, %%mm4 \n\t" /* 000ABCDE */\
"punpckhbw %%mm7, %%mm2 \n\t" /* 0D0E0F0G */\
"punpckhbw %%mm7, %%mm3 \n\t" /* 0C0D0E0F */\
"punpckhbw %%mm7, %%mm4 \n\t" /* 0B0C0D0E */\
"paddw %%mm3, %%mm5 \n\t" /* b */\
"paddw %%mm2, %%mm6 \n\t" /* c */\
"paddw %%mm5, %%mm5 \n\t" /* 2b */\
"psubw %%mm5, %%mm6 \n\t" /* c - 2b */\
"pshufw $0x06, %%mm0, %%mm5 \n\t" /* 0C0B0A0A */\
"pmullw "MANGLE(ff_pw_3)", %%mm6 \n\t" /* 3c - 6b */\
"paddw %%mm4, %%mm0 \n\t" /* a */\
"paddw %%mm1, %%mm5 \n\t" /* d */\
"pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" /* 20a */\
"psubw %%mm5, %%mm0 \n\t" /* 20a - d */\
"paddw %6, %%mm6 \n\t"\
"paddw %%mm6, %%mm0 \n\t" /* 20a - 6b + 3c - d */\
"psraw $5, %%mm0 \n\t"\
"movq %%mm0, %5 \n\t"\
/* mm1=EFGH, mm2=DEFG, mm3=CDEF, mm4=BCDE, mm7=0 */\
\
"movq 5(%0), %%mm0 \n\t" /* FGHIJKLM */\
"movq %%mm0, %%mm5 \n\t" /* FGHIJKLM */\
"movq %%mm0, %%mm6 \n\t" /* FGHIJKLM */\
"psrlq $8, %%mm0 \n\t" /* GHIJKLM0 */\
"psrlq $16, %%mm5 \n\t" /* HIJKLM00 */\
"punpcklbw %%mm7, %%mm0 \n\t" /* 0G0H0I0J */\
"punpcklbw %%mm7, %%mm5 \n\t" /* 0H0I0J0K */\
"paddw %%mm0, %%mm2 \n\t" /* b */\
"paddw %%mm5, %%mm3 \n\t" /* c */\
"paddw %%mm2, %%mm2 \n\t" /* 2b */\
"psubw %%mm2, %%mm3 \n\t" /* c - 2b */\
"movq %%mm6, %%mm2 \n\t" /* FGHIJKLM */\
"psrlq $24, %%mm6 \n\t" /* IJKLM000 */\
"punpcklbw %%mm7, %%mm2 \n\t" /* 0F0G0H0I */\
"punpcklbw %%mm7, %%mm6 \n\t" /* 0I0J0K0L */\
"pmullw "MANGLE(ff_pw_3)", %%mm3 \n\t" /* 3c - 6b */\
"paddw %%mm2, %%mm1 \n\t" /* a */\
"paddw %%mm6, %%mm4 \n\t" /* d */\
"pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" /* 20a */\
"psubw %%mm4, %%mm3 \n\t" /* - 6b +3c - d */\
"paddw %6, %%mm1 \n\t"\
"paddw %%mm1, %%mm3 \n\t" /* 20a - 6b +3c - d */\
"psraw $5, %%mm3 \n\t"\
"movq %5, %%mm1 \n\t"\
"packuswb %%mm3, %%mm1 \n\t"\
OP_MMX2(%%mm1, (%1),%%mm4, q)\
/* mm0= GHIJ, mm2=FGHI, mm5=HIJK, mm6=IJKL, mm7=0 */\
\
"movq 9(%0), %%mm1 \n\t" /* JKLMNOPQ */\
"movq %%mm1, %%mm4 \n\t" /* JKLMNOPQ */\
"movq %%mm1, %%mm3 \n\t" /* JKLMNOPQ */\
"psrlq $8, %%mm1 \n\t" /* KLMNOPQ0 */\
"psrlq $16, %%mm4 \n\t" /* LMNOPQ00 */\
"punpcklbw %%mm7, %%mm1 \n\t" /* 0K0L0M0N */\
"punpcklbw %%mm7, %%mm4 \n\t" /* 0L0M0N0O */\
"paddw %%mm1, %%mm5 \n\t" /* b */\
"paddw %%mm4, %%mm0 \n\t" /* c */\
"paddw %%mm5, %%mm5 \n\t" /* 2b */\
"psubw %%mm5, %%mm0 \n\t" /* c - 2b */\
"movq %%mm3, %%mm5 \n\t" /* JKLMNOPQ */\
"psrlq $24, %%mm3 \n\t" /* MNOPQ000 */\
"pmullw "MANGLE(ff_pw_3)", %%mm0 \n\t" /* 3c - 6b */\
"punpcklbw %%mm7, %%mm3 \n\t" /* 0M0N0O0P */\
"paddw %%mm3, %%mm2 \n\t" /* d */\
"psubw %%mm2, %%mm0 \n\t" /* -6b + 3c - d */\
"movq %%mm5, %%mm2 \n\t" /* JKLMNOPQ */\
"punpcklbw %%mm7, %%mm2 \n\t" /* 0J0K0L0M */\
"punpckhbw %%mm7, %%mm5 \n\t" /* 0N0O0P0Q */\
"paddw %%mm2, %%mm6 \n\t" /* a */\
"pmullw "MANGLE(ff_pw_20)", %%mm6 \n\t" /* 20a */\
"paddw %6, %%mm0 \n\t"\
"paddw %%mm6, %%mm0 \n\t" /* 20a - 6b + 3c - d */\
"psraw $5, %%mm0 \n\t"\
/* mm1=KLMN, mm2=JKLM, mm3=MNOP, mm4=LMNO, mm5=NOPQ mm7=0 */\
\
"paddw %%mm5, %%mm3 \n\t" /* a */\
"pshufw $0xF9, %%mm5, %%mm6 \n\t" /* 0O0P0Q0Q */\
"paddw %%mm4, %%mm6 \n\t" /* b */\
"pshufw $0xBE, %%mm5, %%mm4 \n\t" /* 0P0Q0Q0P */\
"pshufw $0x6F, %%mm5, %%mm5 \n\t" /* 0Q0Q0P0O */\
"paddw %%mm1, %%mm4 \n\t" /* c */\
"paddw %%mm2, %%mm5 \n\t" /* d */\
"paddw %%mm6, %%mm6 \n\t" /* 2b */\
"psubw %%mm6, %%mm4 \n\t" /* c - 2b */\
"pmullw "MANGLE(ff_pw_20)", %%mm3 \n\t" /* 20a */\
"pmullw "MANGLE(ff_pw_3)", %%mm4 \n\t" /* 3c - 6b */\
"psubw %%mm5, %%mm3 \n\t" /* -6b + 3c - d */\
"paddw %6, %%mm4 \n\t"\
"paddw %%mm3, %%mm4 \n\t" /* 20a - 6b + 3c - d */\
"psraw $5, %%mm4 \n\t"\
"packuswb %%mm4, %%mm0 \n\t"\
OP_MMX2(%%mm0, 8(%1), %%mm4, q)\
\
"add %3, %0 \n\t"\
"add %4, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+a"(src), "+c"(dst), "+g"(h)\
: "d"((long)srcStride), "S"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
: "memory"\
);\
}\
\
static void OPNAME ## mpeg4_qpel16_h_lowpass_3dnow(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
int i;\
int16_t temp[16];\
/* quick HACK, XXX FIXME MUST be optimized */\
for(i=0; i<h; i++)\
{\
temp[ 0]= (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]);\
temp[ 1]= (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]);\
temp[ 2]= (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]);\
temp[ 3]= (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]);\
temp[ 4]= (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]);\
temp[ 5]= (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]);\
temp[ 6]= (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]);\
temp[ 7]= (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]);\
temp[ 8]= (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]);\
temp[ 9]= (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]);\
temp[10]= (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]);\
temp[11]= (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]);\
temp[12]= (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]);\
temp[13]= (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]);\
temp[14]= (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]);\
temp[15]= (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]);\
asm volatile(\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, (%1), %%mm1, q)\
"movq 16(%0), %%mm0 \n\t"\
"movq 24(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, 8(%1), %%mm1, q)\
:: "r"(temp), "r"(dst), "m"(ROUNDER)\
: "memory"\
);\
dst+=dstStride;\
src+=srcStride;\
}\
}\
\
static void OPNAME ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t" /* ABCDEFGH */\
"movq %%mm0, %%mm1 \n\t" /* ABCDEFGH */\
"movq %%mm0, %%mm2 \n\t" /* ABCDEFGH */\
"punpcklbw %%mm7, %%mm0 \n\t" /* 0A0B0C0D */\
"punpckhbw %%mm7, %%mm1 \n\t" /* 0E0F0G0H */\
"pshufw $0x90, %%mm0, %%mm5 \n\t" /* 0A0A0B0C */\
"pshufw $0x41, %%mm0, %%mm6 \n\t" /* 0B0A0A0B */\
"movq %%mm2, %%mm3 \n\t" /* ABCDEFGH */\
"movq %%mm2, %%mm4 \n\t" /* ABCDEFGH */\
"psllq $8, %%mm2 \n\t" /* 0ABCDEFG */\
"psllq $16, %%mm3 \n\t" /* 00ABCDEF */\
"psllq $24, %%mm4 \n\t" /* 000ABCDE */\
"punpckhbw %%mm7, %%mm2 \n\t" /* 0D0E0F0G */\
"punpckhbw %%mm7, %%mm3 \n\t" /* 0C0D0E0F */\
"punpckhbw %%mm7, %%mm4 \n\t" /* 0B0C0D0E */\
"paddw %%mm3, %%mm5 \n\t" /* b */\
"paddw %%mm2, %%mm6 \n\t" /* c */\
"paddw %%mm5, %%mm5 \n\t" /* 2b */\
"psubw %%mm5, %%mm6 \n\t" /* c - 2b */\
"pshufw $0x06, %%mm0, %%mm5 \n\t" /* 0C0B0A0A */\
"pmullw "MANGLE(ff_pw_3)", %%mm6 \n\t" /* 3c - 6b */\
"paddw %%mm4, %%mm0 \n\t" /* a */\
"paddw %%mm1, %%mm5 \n\t" /* d */\
"pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" /* 20a */\
"psubw %%mm5, %%mm0 \n\t" /* 20a - d */\
"paddw %5, %%mm6 \n\t"\
"paddw %%mm6, %%mm0 \n\t" /* 20a - 6b + 3c - d */\
"psraw $5, %%mm0 \n\t"\
/* mm1=EFGH, mm2=DEFG, mm3=CDEF, mm4=BCDE, mm7=0 */\
\
"movd 5(%0), %%mm5 \n\t" /* FGHI */\
"punpcklbw %%mm7, %%mm5 \n\t" /* 0F0G0H0I */\
"pshufw $0xF9, %%mm5, %%mm6 \n\t" /* 0G0H0I0I */\
"paddw %%mm5, %%mm1 \n\t" /* a */\
"paddw %%mm6, %%mm2 \n\t" /* b */\
"pshufw $0xBE, %%mm5, %%mm6 \n\t" /* 0H0I0I0H */\
"pshufw $0x6F, %%mm5, %%mm5 \n\t" /* 0I0I0H0G */\
"paddw %%mm6, %%mm3 \n\t" /* c */\
"paddw %%mm5, %%mm4 \n\t" /* d */\
"paddw %%mm2, %%mm2 \n\t" /* 2b */\
"psubw %%mm2, %%mm3 \n\t" /* c - 2b */\
"pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" /* 20a */\
"pmullw "MANGLE(ff_pw_3)", %%mm3 \n\t" /* 3c - 6b */\
"psubw %%mm4, %%mm3 \n\t" /* -6b + 3c - d */\
"paddw %5, %%mm1 \n\t"\
"paddw %%mm1, %%mm3 \n\t" /* 20a - 6b + 3c - d */\
"psraw $5, %%mm3 \n\t"\
"packuswb %%mm3, %%mm0 \n\t"\
OP_MMX2(%%mm0, (%1), %%mm4, q)\
\
"add %3, %0 \n\t"\
"add %4, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+a"(src), "+c"(dst), "+g"(h)\
: "S"((long)srcStride), "D"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER)\
: "memory"\
);\
}\
\
static void OPNAME ## mpeg4_qpel8_h_lowpass_3dnow(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
int i;\
int16_t temp[8];\
/* quick HACK, XXX FIXME MUST be optimized */\
for(i=0; i<h; i++)\
{\
temp[ 0]= (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]);\
temp[ 1]= (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]);\
temp[ 2]= (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]);\
temp[ 3]= (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]);\
temp[ 4]= (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]);\
temp[ 5]= (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 8]);\
temp[ 6]= (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 8])*3 - (src[ 3]+src[ 7]);\
temp[ 7]= (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 8])*6 + (src[ 5]+src[ 7])*3 - (src[ 4]+src[ 6]);\
asm volatile(\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, (%1), %%mm1, q)\
:: "r"(temp), "r"(dst), "m"(ROUNDER)\
:"memory"\
);\
dst+=dstStride;\
src+=srcStride;\
}\
}
#define QPEL_OP(OPNAME, ROUNDER, RND, OP, MMX)\
\
static void OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[17*4];\
uint64_t *temp_ptr= temp;\
int count= 17;\
\
/*FIXME unroll */\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq (%0), %%mm1 \n\t"\
"movq 8(%0), %%mm2 \n\t"\
"movq 8(%0), %%mm3 \n\t"\
"punpcklbw %%mm7, %%mm0 \n\t"\
"punpckhbw %%mm7, %%mm1 \n\t"\
"punpcklbw %%mm7, %%mm2 \n\t"\
"punpckhbw %%mm7, %%mm3 \n\t"\
"movq %%mm0, (%1) \n\t"\
"movq %%mm1, 17*8(%1) \n\t"\
"movq %%mm2, 2*17*8(%1) \n\t"\
"movq %%mm3, 3*17*8(%1) \n\t"\
"add $8, %1 \n\t"\
"add %3, %0 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+r" (src), "+r" (temp_ptr), "+r"(count)\
: "r" ((long)srcStride)\
: "memory"\
);\
\
temp_ptr= temp;\
count=4;\
\
/*FIXME reorder for speed */\
asm volatile(\
/*"pxor %%mm7, %%mm7 \n\t"*/\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"movq 16(%0), %%mm2 \n\t"\
"movq 24(%0), %%mm3 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0), 8(%0), (%0), 32(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 8(%0), (%0), (%0), 40(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, (%0), (%0), 8(%0), 48(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, (%0), 8(%0), 16(%0), 56(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 72(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 80(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 88(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 40(%0), 48(%0), 56(%0), 96(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 48(%0), 56(%0), 64(%0),104(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 56(%0), 64(%0), 72(%0),112(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 64(%0), 72(%0), 80(%0),120(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 72(%0), 80(%0), 88(%0),128(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 80(%0), 88(%0), 96(%0),128(%0), (%1, %3), OP)\
"add %4, %1 \n\t" \
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 88(%0), 96(%0),104(%0),120(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 96(%0),104(%0),112(%0),112(%0), (%1, %3), OP)\
\
"add $136, %0 \n\t"\
"add %6, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
\
: "+r"(temp_ptr), "+r"(dst), "+g"(count)\
: "r"((long)dstStride), "r"(2*(long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER), "g"(4-14*(long)dstStride)\
:"memory"\
);\
}\
\
static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[9*2];\
uint64_t *temp_ptr= temp;\
int count= 9;\
\
/*FIXME unroll */\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq (%0), %%mm1 \n\t"\
"punpcklbw %%mm7, %%mm0 \n\t"\
"punpckhbw %%mm7, %%mm1 \n\t"\
"movq %%mm0, (%1) \n\t"\
"movq %%mm1, 9*8(%1) \n\t"\
"add $8, %1 \n\t"\
"add %3, %0 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+r" (src), "+r" (temp_ptr), "+r"(count)\
: "r" ((long)srcStride)\
: "memory"\
);\
\
temp_ptr= temp;\
count=2;\
\
/*FIXME reorder for speed */\
asm volatile(\
/*"pxor %%mm7, %%mm7 \n\t"*/\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"movq 16(%0), %%mm2 \n\t"\
"movq 24(%0), %%mm3 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0), 8(%0), (%0), 32(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 8(%0), (%0), (%0), 40(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, (%0), (%0), 8(%0), 48(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, (%0), 8(%0), 16(%0), 56(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 64(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 56(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 48(%0), (%1, %3), OP)\
\
"add $72, %0 \n\t"\
"add %6, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
\
: "+r"(temp_ptr), "+r"(dst), "+g"(count)\
: "r"((long)dstStride), "r"(2*(long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER), "g"(4-6*(long)dstStride)\
: "memory"\
);\
}\
\
static void OPNAME ## qpel8_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels8_ ## MMX(dst, src, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel8_h_lowpass_ ## MMX(dst, src, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, src+1, half, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
OPNAME ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, src, stride, stride);\
}\
\
static void OPNAME ## qpel8_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
OPNAME ## pixels8_l2_ ## MMX(dst, src+stride, half, stride, stride, 8);\
}\
static void OPNAME ## qpel8_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void OPNAME ## qpel8_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void OPNAME ## qpel8_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void OPNAME ## qpel16_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels16_ ## MMX(dst, src, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel16_h_lowpass_ ## MMX(dst, src, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, src+1, half, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, src, stride, stride);\
}\
\
static void OPNAME ## qpel16_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
OPNAME ## pixels16_l2_ ## MMX(dst, src+stride, half, stride, stride, 16);\
}\
static void OPNAME ## qpel16_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}\
static void OPNAME ## qpel16_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}\
static void OPNAME ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}
#define PUT_OP(a,b,temp, size) "mov" #size " " #a ", " #b " \n\t"
#define AVG_3DNOW_OP(a,b,temp, size) \
"mov" #size " " #b ", " #temp " \n\t"\
"pavgusb " #temp ", " #a " \n\t"\
"mov" #size " " #a ", " #b " \n\t"
#define AVG_MMX2_OP(a,b,temp, size) \
"mov" #size " " #b ", " #temp " \n\t"\
"pavgb " #temp ", " #a " \n\t"\
"mov" #size " " #a ", " #b " \n\t"
QPEL_BASE(put_ , ff_pw_16, _ , PUT_OP, PUT_OP)
QPEL_BASE(avg_ , ff_pw_16, _ , AVG_MMX2_OP, AVG_3DNOW_OP)
QPEL_BASE(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, PUT_OP)
QPEL_OP(put_ , ff_pw_16, _ , PUT_OP, 3dnow)
QPEL_OP(avg_ , ff_pw_16, _ , AVG_3DNOW_OP, 3dnow)
QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, 3dnow)
QPEL_OP(put_ , ff_pw_16, _ , PUT_OP, mmx2)
QPEL_OP(avg_ , ff_pw_16, _ , AVG_MMX2_OP, mmx2)
QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, mmx2)
/***********************************/
/* bilinear qpel: not compliant to any spec, only for -lavdopts fast */
#define QPEL_2TAP_XY(OPNAME, SIZE, MMX, XY, HPEL)\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc ## XY ## _ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels ## SIZE ## HPEL(dst, src, stride, SIZE);\
}
#define QPEL_2TAP_L3(OPNAME, SIZE, MMX, XY, S0, S1, S2)\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc ## XY ## _ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## 2tap_qpel ## SIZE ## _l3_ ## MMX(dst, src+S0, stride, SIZE, S1, S2);\
}
#define QPEL_2TAP(OPNAME, SIZE, MMX)\
QPEL_2TAP_XY(OPNAME, SIZE, MMX, 20, _x2_ ## MMX)\
QPEL_2TAP_XY(OPNAME, SIZE, MMX, 02, _y2_ ## MMX)\
QPEL_2TAP_XY(OPNAME, SIZE, MMX, 22, _xy2_mmx)\
static const qpel_mc_func OPNAME ## 2tap_qpel ## SIZE ## _mc00_ ## MMX =\
OPNAME ## qpel ## SIZE ## _mc00_ ## MMX;\
static const qpel_mc_func OPNAME ## 2tap_qpel ## SIZE ## _mc21_ ## MMX =\
OPNAME ## 2tap_qpel ## SIZE ## _mc20_ ## MMX;\
static const qpel_mc_func OPNAME ## 2tap_qpel ## SIZE ## _mc12_ ## MMX =\
OPNAME ## 2tap_qpel ## SIZE ## _mc02_ ## MMX;\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels ## SIZE ## _y2_ ## MMX(dst, src+1, stride, SIZE);\
}\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels ## SIZE ## _x2_ ## MMX(dst, src+stride, stride, SIZE);\
}\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 10, 0, 1, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 30, 1, -1, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 01, 0, stride, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 03, stride, -stride, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 11, 0, stride, 1)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 31, 1, stride, -1)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 13, stride, -stride, 1)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 33, stride+1, -stride, -1)\
QPEL_2TAP(put_, 16, mmx2)
QPEL_2TAP(avg_, 16, mmx2)
QPEL_2TAP(put_, 8, mmx2)
QPEL_2TAP(avg_, 8, mmx2)
QPEL_2TAP(put_, 16, 3dnow)
QPEL_2TAP(avg_, 16, 3dnow)
QPEL_2TAP(put_, 8, 3dnow)
QPEL_2TAP(avg_, 8, 3dnow)
#if 0
static void just_return() { return; }
#endif
static void gmc_mmx(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height){
const int w = 8;
const int ix = ox>>(16+shift);
const int iy = oy>>(16+shift);
const int oxs = ox>>4;
const int oys = oy>>4;
const int dxxs = dxx>>4;
const int dxys = dxy>>4;
const int dyxs = dyx>>4;
const int dyys = dyy>>4;
const uint16_t r4[4] = {r,r,r,r};
const uint16_t dxy4[4] = {dxys,dxys,dxys,dxys};
const uint16_t dyy4[4] = {dyys,dyys,dyys,dyys};
const uint64_t shift2 = 2*shift;
uint8_t edge_buf[(h+1)*stride];
int x, y;
const int dxw = (dxx-(1<<(16+shift)))*(w-1);
const int dyh = (dyy-(1<<(16+shift)))*(h-1);
const int dxh = dxy*(h-1);
const int dyw = dyx*(w-1);
if( // non-constant fullpel offset (3% of blocks)
((ox^(ox+dxw)) | (ox^(ox+dxh)) | (ox^(ox+dxw+dxh)) |
(oy^(oy+dyw)) | (oy^(oy+dyh)) | (oy^(oy+dyw+dyh))) >> (16+shift)
// uses more than 16 bits of subpel mv (only at huge resolution)
|| (dxx|dxy|dyx|dyy)&15 )
{
//FIXME could still use mmx for some of the rows
ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r, width, height);
return;
}
src += ix + iy*stride;
if( (unsigned)ix >= width-w ||
(unsigned)iy >= height-h )
{
ff_emulated_edge_mc(edge_buf, src, stride, w+1, h+1, ix, iy, width, height);
src = edge_buf;
}
asm volatile(
"movd %0, %%mm6 \n\t"
"pxor %%mm7, %%mm7 \n\t"
"punpcklwd %%mm6, %%mm6 \n\t"
"punpcklwd %%mm6, %%mm6 \n\t"
:: "r"(1<<shift)
);
for(x=0; x<w; x+=4){
uint16_t dx4[4] = { oxs - dxys + dxxs*(x+0),
oxs - dxys + dxxs*(x+1),
oxs - dxys + dxxs*(x+2),
oxs - dxys + dxxs*(x+3) };
uint16_t dy4[4] = { oys - dyys + dyxs*(x+0),
oys - dyys + dyxs*(x+1),
oys - dyys + dyxs*(x+2),
oys - dyys + dyxs*(x+3) };
for(y=0; y<h; y++){
asm volatile(
"movq %0, %%mm4 \n\t"
"movq %1, %%mm5 \n\t"
"paddw %2, %%mm4 \n\t"
"paddw %3, %%mm5 \n\t"
"movq %%mm4, %0 \n\t"
"movq %%mm5, %1 \n\t"
"psrlw $12, %%mm4 \n\t"
"psrlw $12, %%mm5 \n\t"
: "+m"(*dx4), "+m"(*dy4)
: "m"(*dxy4), "m"(*dyy4)
);
asm volatile(
"movq %%mm6, %%mm2 \n\t"
"movq %%mm6, %%mm1 \n\t"
"psubw %%mm4, %%mm2 \n\t"
"psubw %%mm5, %%mm1 \n\t"
"movq %%mm2, %%mm0 \n\t"
"movq %%mm4, %%mm3 \n\t"
"pmullw %%mm1, %%mm0 \n\t" // (s-dx)*(s-dy)
"pmullw %%mm5, %%mm3 \n\t" // dx*dy
"pmullw %%mm5, %%mm2 \n\t" // (s-dx)*dy
"pmullw %%mm4, %%mm1 \n\t" // dx*(s-dy)
"movd %4, %%mm5 \n\t"
"movd %3, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"pmullw %%mm5, %%mm3 \n\t" // src[1,1] * dx*dy
"pmullw %%mm4, %%mm2 \n\t" // src[0,1] * (s-dx)*dy
"movd %2, %%mm5 \n\t"
"movd %1, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"pmullw %%mm5, %%mm1 \n\t" // src[1,0] * dx*(s-dy)
"pmullw %%mm4, %%mm0 \n\t" // src[0,0] * (s-dx)*(s-dy)
"paddw %5, %%mm1 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm1, %%mm0 \n\t"
"paddw %%mm2, %%mm0 \n\t"
"psrlw %6, %%mm0 \n\t"
"packuswb %%mm0, %%mm0 \n\t"
"movd %%mm0, %0 \n\t"
: "=m"(dst[x+y*stride])
: "m"(src[0]), "m"(src[1]),
"m"(src[stride]), "m"(src[stride+1]),
"m"(*r4), "m"(shift2)
);
src += stride;
}
src += 4-h*stride;
}
}
| false | FFmpeg | 943032b155d10918f115810b4a61e66da7aeeed3 | PAETH(mmx2, ABS3_MMX2)
#ifdef HAVE_SSSE3
PAETH(ssse3, ABS3_SSSE3)
#endif
#define QPEL_V_LOW(m3,m4,m5,m6, pw_20, pw_3, rnd, in0, in1, in2, in7, out, OP)\
"paddw " #m4 ", " #m3 " \n\t" \
"movq "MANGLE(ff_pw_20)", %%mm4 \n\t" \
"pmullw " #m3 ", %%mm4 \n\t" \
"movq "#in7", " #m3 " \n\t" \
"movq "#in0", %%mm5 \n\t" \
"paddw " #m3 ", %%mm5 \n\t" \
"psubw %%mm5, %%mm4 \n\t" \
"movq "#in1", %%mm5 \n\t" \
"movq "#in2", %%mm6 \n\t" \
"paddw " #m6 ", %%mm5 \n\t" \
"paddw " #m5 ", %%mm6 \n\t" \
"paddw %%mm6, %%mm6 \n\t" \
"psubw %%mm6, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm5 \n\t" \
"paddw " #rnd ", %%mm4 \n\t" \
"paddw %%mm4, %%mm5 \n\t" \
"psraw $5, %%mm5 \n\t"\
"packuswb %%mm5, %%mm5 \n\t"\
OP(%%mm5, out, %%mm7, d)
#define QPEL_BASE(OPNAME, ROUNDER, RND, OP_MMX2, OP_3DNOW)\
static void OPNAME ## mpeg4_qpel16_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
uint64_t temp;\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t" \
"movq %%mm0, %%mm1 \n\t" \
"movq %%mm0, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm0 \n\t" \
"punpckhbw %%mm7, %%mm1 \n\t" \
"pshufw $0x90, %%mm0, %%mm5 \n\t" \
"pshufw $0x41, %%mm0, %%mm6 \n\t" \
"movq %%mm2, %%mm3 \n\t" \
"movq %%mm2, %%mm4 \n\t" \
"psllq $8, %%mm2 \n\t" \
"psllq $16, %%mm3 \n\t" \
"psllq $24, %%mm4 \n\t" \
"punpckhbw %%mm7, %%mm2 \n\t" \
"punpckhbw %%mm7, %%mm3 \n\t" \
"punpckhbw %%mm7, %%mm4 \n\t" \
"paddw %%mm3, %%mm5 \n\t" \
"paddw %%mm2, %%mm6 \n\t" \
"paddw %%mm5, %%mm5 \n\t" \
"psubw %%mm5, %%mm6 \n\t" \
"pshufw $0x06, %%mm0, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm6 \n\t" \
"paddw %%mm4, %%mm0 \n\t" \
"paddw %%mm1, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" \
"psubw %%mm5, %%mm0 \n\t" \
"paddw %6, %%mm6 \n\t"\
"paddw %%mm6, %%mm0 \n\t" \
"psraw $5, %%mm0 \n\t"\
"movq %%mm0, %5 \n\t"\
\
\
"movq 5(%0), %%mm0 \n\t" \
"movq %%mm0, %%mm5 \n\t" \
"movq %%mm0, %%mm6 \n\t" \
"psrlq $8, %%mm0 \n\t" \
"psrlq $16, %%mm5 \n\t" \
"punpcklbw %%mm7, %%mm0 \n\t" \
"punpcklbw %%mm7, %%mm5 \n\t" \
"paddw %%mm0, %%mm2 \n\t" \
"paddw %%mm5, %%mm3 \n\t" \
"paddw %%mm2, %%mm2 \n\t" \
"psubw %%mm2, %%mm3 \n\t" \
"movq %%mm6, %%mm2 \n\t" \
"psrlq $24, %%mm6 \n\t" \
"punpcklbw %%mm7, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm6 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm3 \n\t" \
"paddw %%mm2, %%mm1 \n\t" \
"paddw %%mm6, %%mm4 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" \
"psubw %%mm4, %%mm3 \n\t" \
"paddw %6, %%mm1 \n\t"\
"paddw %%mm1, %%mm3 \n\t" \
"psraw $5, %%mm3 \n\t"\
"movq %5, %%mm1 \n\t"\
"packuswb %%mm3, %%mm1 \n\t"\
OP_MMX2(%%mm1, (%1),%%mm4, q)\
\
\
"movq 9(%0), %%mm1 \n\t" \
"movq %%mm1, %%mm4 \n\t" \
"movq %%mm1, %%mm3 \n\t" \
"psrlq $8, %%mm1 \n\t" \
"psrlq $16, %%mm4 \n\t" \
"punpcklbw %%mm7, %%mm1 \n\t" \
"punpcklbw %%mm7, %%mm4 \n\t" \
"paddw %%mm1, %%mm5 \n\t" \
"paddw %%mm4, %%mm0 \n\t" \
"paddw %%mm5, %%mm5 \n\t" \
"psubw %%mm5, %%mm0 \n\t" \
"movq %%mm3, %%mm5 \n\t" \
"psrlq $24, %%mm3 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm0 \n\t" \
"punpcklbw %%mm7, %%mm3 \n\t" \
"paddw %%mm3, %%mm2 \n\t" \
"psubw %%mm2, %%mm0 \n\t" \
"movq %%mm5, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm2 \n\t" \
"punpckhbw %%mm7, %%mm5 \n\t" \
"paddw %%mm2, %%mm6 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm6 \n\t" \
"paddw %6, %%mm0 \n\t"\
"paddw %%mm6, %%mm0 \n\t" \
"psraw $5, %%mm0 \n\t"\
\
\
"paddw %%mm5, %%mm3 \n\t" \
"pshufw $0xF9, %%mm5, %%mm6 \n\t" \
"paddw %%mm4, %%mm6 \n\t" \
"pshufw $0xBE, %%mm5, %%mm4 \n\t" \
"pshufw $0x6F, %%mm5, %%mm5 \n\t" \
"paddw %%mm1, %%mm4 \n\t" \
"paddw %%mm2, %%mm5 \n\t" \
"paddw %%mm6, %%mm6 \n\t" \
"psubw %%mm6, %%mm4 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm3 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm4 \n\t" \
"psubw %%mm5, %%mm3 \n\t" \
"paddw %6, %%mm4 \n\t"\
"paddw %%mm3, %%mm4 \n\t" \
"psraw $5, %%mm4 \n\t"\
"packuswb %%mm4, %%mm0 \n\t"\
OP_MMX2(%%mm0, 8(%1), %%mm4, q)\
\
"add %3, %0 \n\t"\
"add %4, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+a"(src), "+c"(dst), "+g"(h)\
: "d"((long)srcStride), "S"((long)dstStride), "m"(temp), "m"(ROUNDER)\
: "memory"\
);\
}\
\
static void OPNAME ## mpeg4_qpel16_h_lowpass_3dnow(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
int i;\
int16_t temp[16];\
\
for(i=0; i<h; i++)\
{\
temp[ 0]= (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]);\
temp[ 1]= (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]);\
temp[ 2]= (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]);\
temp[ 3]= (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]);\
temp[ 4]= (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]);\
temp[ 5]= (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]);\
temp[ 6]= (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]);\
temp[ 7]= (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]);\
temp[ 8]= (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]);\
temp[ 9]= (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]);\
temp[10]= (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]);\
temp[11]= (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]);\
temp[12]= (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]);\
temp[13]= (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]);\
temp[14]= (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]);\
temp[15]= (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]);\
asm volatile(\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, (%1), %%mm1, q)\
"movq 16(%0), %%mm0 \n\t"\
"movq 24(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, 8(%1), %%mm1, q)\
:: "r"(temp), "r"(dst), "m"(ROUNDER)\
: "memory"\
);\
dst+=dstStride;\
src+=srcStride;\
}\
}\
\
static void OPNAME ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t" \
"movq %%mm0, %%mm1 \n\t" \
"movq %%mm0, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm0 \n\t" \
"punpckhbw %%mm7, %%mm1 \n\t" \
"pshufw $0x90, %%mm0, %%mm5 \n\t" \
"pshufw $0x41, %%mm0, %%mm6 \n\t" \
"movq %%mm2, %%mm3 \n\t" \
"movq %%mm2, %%mm4 \n\t" \
"psllq $8, %%mm2 \n\t" \
"psllq $16, %%mm3 \n\t" \
"psllq $24, %%mm4 \n\t" \
"punpckhbw %%mm7, %%mm2 \n\t" \
"punpckhbw %%mm7, %%mm3 \n\t" \
"punpckhbw %%mm7, %%mm4 \n\t" \
"paddw %%mm3, %%mm5 \n\t" \
"paddw %%mm2, %%mm6 \n\t" \
"paddw %%mm5, %%mm5 \n\t" \
"psubw %%mm5, %%mm6 \n\t" \
"pshufw $0x06, %%mm0, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm6 \n\t" \
"paddw %%mm4, %%mm0 \n\t" \
"paddw %%mm1, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" \
"psubw %%mm5, %%mm0 \n\t" \
"paddw %5, %%mm6 \n\t"\
"paddw %%mm6, %%mm0 \n\t" \
"psraw $5, %%mm0 \n\t"\
\
\
"movd 5(%0), %%mm5 \n\t" \
"punpcklbw %%mm7, %%mm5 \n\t" \
"pshufw $0xF9, %%mm5, %%mm6 \n\t" \
"paddw %%mm5, %%mm1 \n\t" \
"paddw %%mm6, %%mm2 \n\t" \
"pshufw $0xBE, %%mm5, %%mm6 \n\t" \
"pshufw $0x6F, %%mm5, %%mm5 \n\t" \
"paddw %%mm6, %%mm3 \n\t" \
"paddw %%mm5, %%mm4 \n\t" \
"paddw %%mm2, %%mm2 \n\t" \
"psubw %%mm2, %%mm3 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm3 \n\t" \
"psubw %%mm4, %%mm3 \n\t" \
"paddw %5, %%mm1 \n\t"\
"paddw %%mm1, %%mm3 \n\t" \
"psraw $5, %%mm3 \n\t"\
"packuswb %%mm3, %%mm0 \n\t"\
OP_MMX2(%%mm0, (%1), %%mm4, q)\
\
"add %3, %0 \n\t"\
"add %4, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+a"(src), "+c"(dst), "+g"(h)\
: "S"((long)srcStride), "D"((long)dstStride), "m"(ROUNDER)\
: "memory"\
);\
}\
\
static void OPNAME ## mpeg4_qpel8_h_lowpass_3dnow(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
int i;\
int16_t temp[8];\
\
for(i=0; i<h; i++)\
{\
temp[ 0]= (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]);\
temp[ 1]= (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]);\
temp[ 2]= (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]);\
temp[ 3]= (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]);\
temp[ 4]= (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]);\
temp[ 5]= (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 8]);\
temp[ 6]= (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 8])*3 - (src[ 3]+src[ 7]);\
temp[ 7]= (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 8])*6 + (src[ 5]+src[ 7])*3 - (src[ 4]+src[ 6]);\
asm volatile(\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, (%1), %%mm1, q)\
:: "r"(temp), "r"(dst), "m"(ROUNDER)\
:"memory"\
);\
dst+=dstStride;\
src+=srcStride;\
}\
}
#define QPEL_OP(OPNAME, ROUNDER, RND, OP, MMX)\
\
static void OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[17*4];\
uint64_t *temp_ptr= temp;\
int count= 17;\
\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq (%0), %%mm1 \n\t"\
"movq 8(%0), %%mm2 \n\t"\
"movq 8(%0), %%mm3 \n\t"\
"punpcklbw %%mm7, %%mm0 \n\t"\
"punpckhbw %%mm7, %%mm1 \n\t"\
"punpcklbw %%mm7, %%mm2 \n\t"\
"punpckhbw %%mm7, %%mm3 \n\t"\
"movq %%mm0, (%1) \n\t"\
"movq %%mm1, 17*8(%1) \n\t"\
"movq %%mm2, 2*17*8(%1) \n\t"\
"movq %%mm3, 3*17*8(%1) \n\t"\
"add $8, %1 \n\t"\
"add %3, %0 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+r" (src), "+r" (temp_ptr), "+r"(count)\
: "r" ((long)srcStride)\
: "memory"\
);\
\
temp_ptr= temp;\
count=4;\
\
\
asm volatile(\
\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"movq 16(%0), %%mm2 \n\t"\
"movq 24(%0), %%mm3 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0), 8(%0), (%0), 32(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 8(%0), (%0), (%0), 40(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, (%0), (%0), 8(%0), 48(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, (%0), 8(%0), 16(%0), 56(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 72(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 80(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 88(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 40(%0), 48(%0), 56(%0), 96(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 48(%0), 56(%0), 64(%0),104(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 56(%0), 64(%0), 72(%0),112(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 64(%0), 72(%0), 80(%0),120(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 72(%0), 80(%0), 88(%0),128(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 80(%0), 88(%0), 96(%0),128(%0), (%1, %3), OP)\
"add %4, %1 \n\t" \
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 88(%0), 96(%0),104(%0),120(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 96(%0),104(%0),112(%0),112(%0), (%1, %3), OP)\
\
"add $136, %0 \n\t"\
"add %6, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
\
: "+r"(temp_ptr), "+r"(dst), "+g"(count)\
: "r"((long)dstStride), "r"(2*(long)dstStride), "m"(ROUNDER), "g"(4-14*(long)dstStride)\
:"memory"\
);\
}\
\
static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[9*2];\
uint64_t *temp_ptr= temp;\
int count= 9;\
\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq (%0), %%mm1 \n\t"\
"punpcklbw %%mm7, %%mm0 \n\t"\
"punpckhbw %%mm7, %%mm1 \n\t"\
"movq %%mm0, (%1) \n\t"\
"movq %%mm1, 9*8(%1) \n\t"\
"add $8, %1 \n\t"\
"add %3, %0 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+r" (src), "+r" (temp_ptr), "+r"(count)\
: "r" ((long)srcStride)\
: "memory"\
);\
\
temp_ptr= temp;\
count=2;\
\
\
asm volatile(\
\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"movq 16(%0), %%mm2 \n\t"\
"movq 24(%0), %%mm3 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0), 8(%0), (%0), 32(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 8(%0), (%0), (%0), 40(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, (%0), (%0), 8(%0), 48(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, (%0), 8(%0), 16(%0), 56(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 64(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 56(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 48(%0), (%1, %3), OP)\
\
"add $72, %0 \n\t"\
"add %6, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
\
: "+r"(temp_ptr), "+r"(dst), "+g"(count)\
: "r"((long)dstStride), "r"(2*(long)dstStride), "m"(ROUNDER), "g"(4-6*(long)dstStride)\
: "memory"\
);\
}\
\
static void OPNAME ## qpel8_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels8_ ## MMX(dst, src, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel8_h_lowpass_ ## MMX(dst, src, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, src+1, half, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
OPNAME ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
}\
\
static void OPNAME ## qpel8_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, src, stride, stride);\
}\
\
static void OPNAME ## qpel8_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
OPNAME ## pixels8_l2_ ## MMX(dst, src+stride, half, stride, stride, 8);\
}\
static void OPNAME ## qpel8_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void OPNAME ## qpel8_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void OPNAME ## qpel8_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void OPNAME ## qpel8_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void OPNAME ## qpel16_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels16_ ## MMX(dst, src, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel16_h_lowpass_ ## MMX(dst, src, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, src+1, half, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
}\
\
static void OPNAME ## qpel16_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, src, stride, stride);\
}\
\
static void OPNAME ## qpel16_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
OPNAME ## pixels16_l2_ ## MMX(dst, src+stride, half, stride, stride, 16);\
}\
static void OPNAME ## qpel16_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void OPNAME ## qpel16_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}\
static void OPNAME ## qpel16_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}\
static void OPNAME ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}
#define PUT_OP(a,b,temp, size) "mov" #size " " #a ", " #b " \n\t"
#define AVG_3DNOW_OP(a,b,temp, size) \
"mov" #size " " #b ", " #temp " \n\t"\
"pavgusb " #temp ", " #a " \n\t"\
"mov" #size " " #a ", " #b " \n\t"
#define AVG_MMX2_OP(a,b,temp, size) \
"mov" #size " " #b ", " #temp " \n\t"\
"pavgb " #temp ", " #a " \n\t"\
"mov" #size " " #a ", " #b " \n\t"
QPEL_BASE(put_ , ff_pw_16, _ , PUT_OP, PUT_OP)
QPEL_BASE(avg_ , ff_pw_16, _ , AVG_MMX2_OP, AVG_3DNOW_OP)
QPEL_BASE(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, PUT_OP)
QPEL_OP(put_ , ff_pw_16, _ , PUT_OP, 3dnow)
QPEL_OP(avg_ , ff_pw_16, _ , AVG_3DNOW_OP, 3dnow)
QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, 3dnow)
QPEL_OP(put_ , ff_pw_16, _ , PUT_OP, mmx2)
QPEL_OP(avg_ , ff_pw_16, _ , AVG_MMX2_OP, mmx2)
QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, mmx2)
#define QPEL_2TAP_XY(OPNAME, SIZE, MMX, XY, HPEL)\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc ## XY ## _ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels ## SIZE ## HPEL(dst, src, stride, SIZE);\
}
#define QPEL_2TAP_L3(OPNAME, SIZE, MMX, XY, S0, S1, S2)\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc ## XY ## _ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## 2tap_qpel ## SIZE ## _l3_ ## MMX(dst, src+S0, stride, SIZE, S1, S2);\
}
#define QPEL_2TAP(OPNAME, SIZE, MMX)\
QPEL_2TAP_XY(OPNAME, SIZE, MMX, 20, _x2_ ## MMX)\
QPEL_2TAP_XY(OPNAME, SIZE, MMX, 02, _y2_ ## MMX)\
QPEL_2TAP_XY(OPNAME, SIZE, MMX, 22, _xy2_mmx)\
static const qpel_mc_func OPNAME ## 2tap_qpel ## SIZE ## _mc00_ ## MMX =\
OPNAME ## qpel ## SIZE ## _mc00_ ## MMX;\
static const qpel_mc_func OPNAME ## 2tap_qpel ## SIZE ## _mc21_ ## MMX =\
OPNAME ## 2tap_qpel ## SIZE ## _mc20_ ## MMX;\
static const qpel_mc_func OPNAME ## 2tap_qpel ## SIZE ## _mc12_ ## MMX =\
OPNAME ## 2tap_qpel ## SIZE ## _mc02_ ## MMX;\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels ## SIZE ## _y2_ ## MMX(dst, src+1, stride, SIZE);\
}\
static void OPNAME ## 2tap_qpel ## SIZE ## _mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
OPNAME ## pixels ## SIZE ## _x2_ ## MMX(dst, src+stride, stride, SIZE);\
}\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 10, 0, 1, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 30, 1, -1, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 01, 0, stride, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 03, stride, -stride, 0)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 11, 0, stride, 1)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 31, 1, stride, -1)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 13, stride, -stride, 1)\
QPEL_2TAP_L3(OPNAME, SIZE, MMX, 33, stride+1, -stride, -1)\
QPEL_2TAP(put_, 16, mmx2)
QPEL_2TAP(avg_, 16, mmx2)
QPEL_2TAP(put_, 8, mmx2)
QPEL_2TAP(avg_, 8, mmx2)
QPEL_2TAP(put_, 16, 3dnow)
QPEL_2TAP(avg_, 16, 3dnow)
QPEL_2TAP(put_, 8, 3dnow)
QPEL_2TAP(avg_, 8, 3dnow)
#if 0
static void just_return() { return; }
#endif
static void gmc_mmx(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height){
const int w = 8;
const int ix = ox>>(16+shift);
const int iy = oy>>(16+shift);
const int oxs = ox>>4;
const int oys = oy>>4;
const int dxxs = dxx>>4;
const int dxys = dxy>>4;
const int dyxs = dyx>>4;
const int dyys = dyy>>4;
const uint16_t r4[4] = {r,r,r,r};
const uint16_t dxy4[4] = {dxys,dxys,dxys,dxys};
const uint16_t dyy4[4] = {dyys,dyys,dyys,dyys};
const uint64_t shift2 = 2*shift;
uint8_t edge_buf[(h+1)*stride];
int x, y;
const int dxw = (dxx-(1<<(16+shift)))*(w-1);
const int dyh = (dyy-(1<<(16+shift)))*(h-1);
const int dxh = dxy*(h-1);
const int dyw = dyx*(w-1);
if(
((ox^(ox+dxw)) | (ox^(ox+dxh)) | (ox^(ox+dxw+dxh)) |
(oy^(oy+dyw)) | (oy^(oy+dyh)) | (oy^(oy+dyw+dyh))) >> (16+shift)
|| (dxx|dxy|dyx|dyy)&15 )
{
ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r, width, height);
return;
}
src += ix + iy*stride;
if( (unsigned)ix >= width-w ||
(unsigned)iy >= height-h )
{
ff_emulated_edge_mc(edge_buf, src, stride, w+1, h+1, ix, iy, width, height);
src = edge_buf;
}
asm volatile(
"movd %0, %%mm6 \n\t"
"pxor %%mm7, %%mm7 \n\t"
"punpcklwd %%mm6, %%mm6 \n\t"
"punpcklwd %%mm6, %%mm6 \n\t"
:: "r"(1<<shift)
);
for(x=0; x<w; x+=4){
uint16_t dx4[4] = { oxs - dxys + dxxs*(x+0),
oxs - dxys + dxxs*(x+1),
oxs - dxys + dxxs*(x+2),
oxs - dxys + dxxs*(x+3) };
uint16_t dy4[4] = { oys - dyys + dyxs*(x+0),
oys - dyys + dyxs*(x+1),
oys - dyys + dyxs*(x+2),
oys - dyys + dyxs*(x+3) };
for(y=0; y<h; y++){
asm volatile(
"movq %0, %%mm4 \n\t"
"movq %1, %%mm5 \n\t"
"paddw %2, %%mm4 \n\t"
"paddw %3, %%mm5 \n\t"
"movq %%mm4, %0 \n\t"
"movq %%mm5, %1 \n\t"
"psrlw $12, %%mm4 \n\t"
"psrlw $12, %%mm5 \n\t"
: "+m"(*dx4), "+m"(*dy4)
: "m"(*dxy4), "m"(*dyy4)
);
asm volatile(
"movq %%mm6, %%mm2 \n\t"
"movq %%mm6, %%mm1 \n\t"
"psubw %%mm4, %%mm2 \n\t"
"psubw %%mm5, %%mm1 \n\t"
"movq %%mm2, %%mm0 \n\t"
"movq %%mm4, %%mm3 \n\t"
"pmullw %%mm1, %%mm0 \n\t"
"pmullw %%mm5, %%mm3 \n\t"
"pmullw %%mm5, %%mm2 \n\t"
"pmullw %%mm4, %%mm1 \n\t"
"movd %4, %%mm5 \n\t"
"movd %3, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"pmullw %%mm5, %%mm3 \n\t"
"pmullw %%mm4, %%mm2 \n\t"
"movd %2, %%mm5 \n\t"
"movd %1, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"pmullw %%mm5, %%mm1 \n\t"
"pmullw %%mm4, %%mm0 \n\t"
"paddw %5, %%mm1 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm1, %%mm0 \n\t"
"paddw %%mm2, %%mm0 \n\t"
"psrlw %6, %%mm0 \n\t"
"packuswb %%mm0, %%mm0 \n\t"
"movd %%mm0, %0 \n\t"
: "=m"(dst[x+y*stride])
: "m"(src[0]), "m"(src[1]),
"m"(src[stride]), "m"(src[stride+1]),
"m"(*r4), "m"(shift2)
);
src += stride;
}
src += 4-h*stride;
}
}
| {
"code": [],
"line_no": []
} | PAETH(mmx2, ABS3_MMX2)
#ifdef HAVE_SSSE3
PAETH(ssse3, ABS3_SSSE3)
#endif
#define QPEL_V_LOW(m3,m4,m5,m6, pw_20, pw_3, rnd, in0, in1, in2, in7, out, OP)\
"paddw " #m4 ", " #m3 " \n\t" \
"movq "MANGLE(ff_pw_20)", %%mm4 \n\t" \
"pmullw " #m3 ", %%mm4 \n\t" \
"movq "#in7", " #m3 " \n\t" \
"movq "#in0", %%mm5 \n\t" \
"paddw " #m3 ", %%mm5 \n\t" \
"psubw %%mm5, %%mm4 \n\t" \
"movq "#in1", %%mm5 \n\t" \
"movq "#in2", %%mm6 \n\t" \
"paddw " #m6 ", %%mm5 \n\t" \
"paddw " #m5 ", %%mm6 \n\t" \
"paddw %%mm6, %%mm6 \n\t" \
"psubw %%mm6, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm5 \n\t" \
"paddw " #rnd ", %%mm4 \n\t" \
"paddw %%mm4, %%mm5 \n\t" \
"psraw $5, %%mm5 \n\t"\
"packuswb %%mm5, %%mm5 \n\t"\
OP(%%mm5, out, %%mm7, d)
#define QPEL_BASE(VAR_1, ROUNDER, RND, OP_MMX2, OP_3DNOW)\
static void VAR_1 ## mpeg4_qpel16_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
uint64_t temp;\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t" \
"movq %%mm0, %%mm1 \n\t" \
"movq %%mm0, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm0 \n\t" \
"punpckhbw %%mm7, %%mm1 \n\t" \
"pshufw $0x90, %%mm0, %%mm5 \n\t" \
"pshufw $0x41, %%mm0, %%mm6 \n\t" \
"movq %%mm2, %%mm3 \n\t" \
"movq %%mm2, %%mm4 \n\t" \
"psllq $8, %%mm2 \n\t" \
"psllq $16, %%mm3 \n\t" \
"psllq $24, %%mm4 \n\t" \
"punpckhbw %%mm7, %%mm2 \n\t" \
"punpckhbw %%mm7, %%mm3 \n\t" \
"punpckhbw %%mm7, %%mm4 \n\t" \
"paddw %%mm3, %%mm5 \n\t" \
"paddw %%mm2, %%mm6 \n\t" \
"paddw %%mm5, %%mm5 \n\t" \
"psubw %%mm5, %%mm6 \n\t" \
"pshufw $0x06, %%mm0, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm6 \n\t" \
"paddw %%mm4, %%mm0 \n\t" \
"paddw %%mm1, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" \
"psubw %%mm5, %%mm0 \n\t" \
"paddw %6, %%mm6 \n\t"\
"paddw %%mm6, %%mm0 \n\t" \
"psraw $5, %%mm0 \n\t"\
"movq %%mm0, %5 \n\t"\
\
\
"movq 5(%0), %%mm0 \n\t" \
"movq %%mm0, %%mm5 \n\t" \
"movq %%mm0, %%mm6 \n\t" \
"psrlq $8, %%mm0 \n\t" \
"psrlq $16, %%mm5 \n\t" \
"punpcklbw %%mm7, %%mm0 \n\t" \
"punpcklbw %%mm7, %%mm5 \n\t" \
"paddw %%mm0, %%mm2 \n\t" \
"paddw %%mm5, %%mm3 \n\t" \
"paddw %%mm2, %%mm2 \n\t" \
"psubw %%mm2, %%mm3 \n\t" \
"movq %%mm6, %%mm2 \n\t" \
"psrlq $24, %%mm6 \n\t" \
"punpcklbw %%mm7, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm6 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm3 \n\t" \
"paddw %%mm2, %%mm1 \n\t" \
"paddw %%mm6, %%mm4 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" \
"psubw %%mm4, %%mm3 \n\t" \
"paddw %6, %%mm1 \n\t"\
"paddw %%mm1, %%mm3 \n\t" \
"psraw $5, %%mm3 \n\t"\
"movq %5, %%mm1 \n\t"\
"packuswb %%mm3, %%mm1 \n\t"\
OP_MMX2(%%mm1, (%1),%%mm4, q)\
\
\
"movq 9(%0), %%mm1 \n\t" \
"movq %%mm1, %%mm4 \n\t" \
"movq %%mm1, %%mm3 \n\t" \
"psrlq $8, %%mm1 \n\t" \
"psrlq $16, %%mm4 \n\t" \
"punpcklbw %%mm7, %%mm1 \n\t" \
"punpcklbw %%mm7, %%mm4 \n\t" \
"paddw %%mm1, %%mm5 \n\t" \
"paddw %%mm4, %%mm0 \n\t" \
"paddw %%mm5, %%mm5 \n\t" \
"psubw %%mm5, %%mm0 \n\t" \
"movq %%mm3, %%mm5 \n\t" \
"psrlq $24, %%mm3 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm0 \n\t" \
"punpcklbw %%mm7, %%mm3 \n\t" \
"paddw %%mm3, %%mm2 \n\t" \
"psubw %%mm2, %%mm0 \n\t" \
"movq %%mm5, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm2 \n\t" \
"punpckhbw %%mm7, %%mm5 \n\t" \
"paddw %%mm2, %%mm6 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm6 \n\t" \
"paddw %6, %%mm0 \n\t"\
"paddw %%mm6, %%mm0 \n\t" \
"psraw $5, %%mm0 \n\t"\
\
\
"paddw %%mm5, %%mm3 \n\t" \
"pshufw $0xF9, %%mm5, %%mm6 \n\t" \
"paddw %%mm4, %%mm6 \n\t" \
"pshufw $0xBE, %%mm5, %%mm4 \n\t" \
"pshufw $0x6F, %%mm5, %%mm5 \n\t" \
"paddw %%mm1, %%mm4 \n\t" \
"paddw %%mm2, %%mm5 \n\t" \
"paddw %%mm6, %%mm6 \n\t" \
"psubw %%mm6, %%mm4 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm3 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm4 \n\t" \
"psubw %%mm5, %%mm3 \n\t" \
"paddw %6, %%mm4 \n\t"\
"paddw %%mm3, %%mm4 \n\t" \
"psraw $5, %%mm4 \n\t"\
"packuswb %%mm4, %%mm0 \n\t"\
OP_MMX2(%%mm0, 8(%1), %%mm4, q)\
\
"add %3, %0 \n\t"\
"add %4, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+a"(src), "+c"(dst), "+g"(h)\
: "d"((long)srcStride), "S"((long)dstStride), "m"(temp), "m"(ROUNDER)\
: "memory"\
);\
}\
\
static void VAR_1 ## mpeg4_qpel16_h_lowpass_3dnow(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
int i;\
int16_t temp[16];\
\
for(i=0; i<h; i++)\
{\
temp[ 0]= (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]);\
temp[ 1]= (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]);\
temp[ 2]= (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]);\
temp[ 3]= (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]);\
temp[ 4]= (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]);\
temp[ 5]= (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]);\
temp[ 6]= (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]);\
temp[ 7]= (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]);\
temp[ 8]= (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]);\
temp[ 9]= (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]);\
temp[10]= (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]);\
temp[11]= (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]);\
temp[12]= (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]);\
temp[13]= (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]);\
temp[14]= (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]);\
temp[15]= (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]);\
asm volatile(\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, (%1), %%mm1, q)\
"movq 16(%0), %%mm0 \n\t"\
"movq 24(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, 8(%1), %%mm1, q)\
:: "r"(temp), "r"(dst), "m"(ROUNDER)\
: "memory"\
);\
dst+=dstStride;\
src+=srcStride;\
}\
}\
\
static void VAR_1 ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t" \
"movq %%mm0, %%mm1 \n\t" \
"movq %%mm0, %%mm2 \n\t" \
"punpcklbw %%mm7, %%mm0 \n\t" \
"punpckhbw %%mm7, %%mm1 \n\t" \
"pshufw $0x90, %%mm0, %%mm5 \n\t" \
"pshufw $0x41, %%mm0, %%mm6 \n\t" \
"movq %%mm2, %%mm3 \n\t" \
"movq %%mm2, %%mm4 \n\t" \
"psllq $8, %%mm2 \n\t" \
"psllq $16, %%mm3 \n\t" \
"psllq $24, %%mm4 \n\t" \
"punpckhbw %%mm7, %%mm2 \n\t" \
"punpckhbw %%mm7, %%mm3 \n\t" \
"punpckhbw %%mm7, %%mm4 \n\t" \
"paddw %%mm3, %%mm5 \n\t" \
"paddw %%mm2, %%mm6 \n\t" \
"paddw %%mm5, %%mm5 \n\t" \
"psubw %%mm5, %%mm6 \n\t" \
"pshufw $0x06, %%mm0, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm6 \n\t" \
"paddw %%mm4, %%mm0 \n\t" \
"paddw %%mm1, %%mm5 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" \
"psubw %%mm5, %%mm0 \n\t" \
"paddw %5, %%mm6 \n\t"\
"paddw %%mm6, %%mm0 \n\t" \
"psraw $5, %%mm0 \n\t"\
\
\
"movd 5(%0), %%mm5 \n\t" \
"punpcklbw %%mm7, %%mm5 \n\t" \
"pshufw $0xF9, %%mm5, %%mm6 \n\t" \
"paddw %%mm5, %%mm1 \n\t" \
"paddw %%mm6, %%mm2 \n\t" \
"pshufw $0xBE, %%mm5, %%mm6 \n\t" \
"pshufw $0x6F, %%mm5, %%mm5 \n\t" \
"paddw %%mm6, %%mm3 \n\t" \
"paddw %%mm5, %%mm4 \n\t" \
"paddw %%mm2, %%mm2 \n\t" \
"psubw %%mm2, %%mm3 \n\t" \
"pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" \
"pmullw "MANGLE(ff_pw_3)", %%mm3 \n\t" \
"psubw %%mm4, %%mm3 \n\t" \
"paddw %5, %%mm1 \n\t"\
"paddw %%mm1, %%mm3 \n\t" \
"psraw $5, %%mm3 \n\t"\
"packuswb %%mm3, %%mm0 \n\t"\
OP_MMX2(%%mm0, (%1), %%mm4, q)\
\
"add %3, %0 \n\t"\
"add %4, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+a"(src), "+c"(dst), "+g"(h)\
: "S"((long)srcStride), "D"((long)dstStride), "m"(ROUNDER)\
: "memory"\
);\
}\
\
static void VAR_1 ## mpeg4_qpel8_h_lowpass_3dnow(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
int i;\
int16_t temp[8];\
\
for(i=0; i<h; i++)\
{\
temp[ 0]= (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]);\
temp[ 1]= (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]);\
temp[ 2]= (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]);\
temp[ 3]= (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]);\
temp[ 4]= (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]);\
temp[ 5]= (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 8]);\
temp[ 6]= (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 8])*3 - (src[ 3]+src[ 7]);\
temp[ 7]= (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 8])*6 + (src[ 5]+src[ 7])*3 - (src[ 4]+src[ 6]);\
asm volatile(\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"paddw %2, %%mm0 \n\t"\
"paddw %2, %%mm1 \n\t"\
"psraw $5, %%mm0 \n\t"\
"psraw $5, %%mm1 \n\t"\
"packuswb %%mm1, %%mm0 \n\t"\
OP_3DNOW(%%mm0, (%1), %%mm1, q)\
:: "r"(temp), "r"(dst), "m"(ROUNDER)\
:"memory"\
);\
dst+=dstStride;\
src+=srcStride;\
}\
}
#define QPEL_OP(VAR_1, ROUNDER, RND, OP, MMX)\
\
static void VAR_1 ## mpeg4_qpel16_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[17*4];\
uint64_t *temp_ptr= temp;\
int count= 17;\
\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq (%0), %%mm1 \n\t"\
"movq 8(%0), %%mm2 \n\t"\
"movq 8(%0), %%mm3 \n\t"\
"punpcklbw %%mm7, %%mm0 \n\t"\
"punpckhbw %%mm7, %%mm1 \n\t"\
"punpcklbw %%mm7, %%mm2 \n\t"\
"punpckhbw %%mm7, %%mm3 \n\t"\
"movq %%mm0, (%1) \n\t"\
"movq %%mm1, 17*8(%1) \n\t"\
"movq %%mm2, 2*17*8(%1) \n\t"\
"movq %%mm3, 3*17*8(%1) \n\t"\
"add $8, %1 \n\t"\
"add %3, %0 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+r" (src), "+r" (temp_ptr), "+r"(count)\
: "r" ((long)srcStride)\
: "memory"\
);\
\
temp_ptr= temp;\
count=4;\
\
\
asm volatile(\
\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"movq 16(%0), %%mm2 \n\t"\
"movq 24(%0), %%mm3 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0), 8(%0), (%0), 32(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 8(%0), (%0), (%0), 40(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, (%0), (%0), 8(%0), 48(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, (%0), 8(%0), 16(%0), 56(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 72(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 80(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 88(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 40(%0), 48(%0), 56(%0), 96(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 48(%0), 56(%0), 64(%0),104(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 56(%0), 64(%0), 72(%0),112(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 64(%0), 72(%0), 80(%0),120(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 72(%0), 80(%0), 88(%0),128(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 80(%0), 88(%0), 96(%0),128(%0), (%1, %3), OP)\
"add %4, %1 \n\t" \
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 88(%0), 96(%0),104(%0),120(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 96(%0),104(%0),112(%0),112(%0), (%1, %3), OP)\
\
"add $136, %0 \n\t"\
"add %6, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
\
: "+r"(temp_ptr), "+r"(dst), "+g"(count)\
: "r"((long)dstStride), "r"(2*(long)dstStride), "m"(ROUNDER), "g"(4-14*(long)dstStride)\
:"memory"\
);\
}\
\
static void VAR_1 ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[9*2];\
uint64_t *temp_ptr= temp;\
int count= 9;\
\
\
asm volatile(\
"pxor %%mm7, %%mm7 \n\t"\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq (%0), %%mm1 \n\t"\
"punpcklbw %%mm7, %%mm0 \n\t"\
"punpckhbw %%mm7, %%mm1 \n\t"\
"movq %%mm0, (%1) \n\t"\
"movq %%mm1, 9*8(%1) \n\t"\
"add $8, %1 \n\t"\
"add %3, %0 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
: "+r" (src), "+r" (temp_ptr), "+r"(count)\
: "r" ((long)srcStride)\
: "memory"\
);\
\
temp_ptr= temp;\
count=2;\
\
\
asm volatile(\
\
"1: \n\t"\
"movq (%0), %%mm0 \n\t"\
"movq 8(%0), %%mm1 \n\t"\
"movq 16(%0), %%mm2 \n\t"\
"movq 24(%0), %%mm3 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0), 8(%0), (%0), 32(%0), (%1), OP)\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 8(%0), (%0), (%0), 40(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, (%0), (%0), 8(%0), 48(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, (%0), 8(%0), 16(%0), 56(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
\
QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 64(%0), (%1, %3), OP)\
"add %4, %1 \n\t"\
QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 56(%0), (%1), OP)\
QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 48(%0), (%1, %3), OP)\
\
"add $72, %0 \n\t"\
"add %6, %1 \n\t"\
"decl %2 \n\t"\
" jnz 1b \n\t"\
\
: "+r"(temp_ptr), "+r"(dst), "+g"(count)\
: "r"((long)dstStride), "r"(2*(long)dstStride), "m"(ROUNDER), "g"(4-6*(long)dstStride)\
: "memory"\
);\
}\
\
static void VAR_1 ## qpel8_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## pixels8_ ## MMX(dst, src, stride, 8);\
}\
\
static void VAR_1 ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
}\
\
static void VAR_1 ## qpel8_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## mpeg4_qpel8_h_lowpass_ ## MMX(dst, src, stride, stride, 8);\
}\
\
static void VAR_1 ## qpel8_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, src+1, half, stride, stride, 8);\
}\
\
static void VAR_1 ## qpel8_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
VAR_1 ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
}\
\
static void VAR_1 ## qpel8_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, src, stride, stride);\
}\
\
static void VAR_1 ## qpel8_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[8];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
VAR_1 ## pixels8_l2_ ## MMX(dst, src+stride, half, stride, stride, 8);\
}\
static void VAR_1 ## qpel8_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void VAR_1 ## qpel8_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void VAR_1 ## qpel8_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void VAR_1 ## qpel8_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void VAR_1 ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
}\
static void VAR_1 ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half) + 64;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
VAR_1 ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
}\
static void VAR_1 ## qpel8_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
VAR_1 ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void VAR_1 ## qpel8_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[8 + 9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
VAR_1 ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void VAR_1 ## qpel8_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[9];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
VAR_1 ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
}\
static void VAR_1 ## qpel16_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## pixels16_ ## MMX(dst, src, stride, 16);\
}\
\
static void VAR_1 ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
}\
\
static void VAR_1 ## qpel16_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## mpeg4_qpel16_h_lowpass_ ## MMX(dst, src, stride, stride, 16);\
}\
\
static void VAR_1 ## qpel16_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, src+1, half, stride, stride, 16);\
}\
\
static void VAR_1 ## qpel16_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
VAR_1 ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
}\
\
static void VAR_1 ## qpel16_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, src, stride, stride);\
}\
\
static void VAR_1 ## qpel16_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t temp[32];\
uint8_t * const half= (uint8_t*)temp;\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
VAR_1 ## pixels16_l2_ ## MMX(dst, src+stride, half, stride, stride, 16);\
}\
static void VAR_1 ## qpel16_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void VAR_1 ## qpel16_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void VAR_1 ## qpel16_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void VAR_1 ## qpel16_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void VAR_1 ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
}\
static void VAR_1 ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[16*2 + 17*2];\
uint8_t * const halfH= ((uint8_t*)half) + 256;\
uint8_t * const halfHV= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
VAR_1 ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
}\
static void VAR_1 ## qpel16_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
VAR_1 ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}\
static void VAR_1 ## qpel16_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
VAR_1 ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}\
static void VAR_1 ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
uint64_t half[17*2];\
uint8_t * const halfH= ((uint8_t*)half);\
put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
VAR_1 ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
}
#define PUT_OP(a,b,temp, size) "mov" #size " " #a ", " #b " \n\t"
#define AVG_3DNOW_OP(a,b,temp, size) \
"mov" #size " " #b ", " #temp " \n\t"\
"pavgusb " #temp ", " #a " \n\t"\
"mov" #size " " #a ", " #b " \n\t"
#define AVG_MMX2_OP(a,b,temp, size) \
"mov" #size " " #b ", " #temp " \n\t"\
"pavgb " #temp ", " #a " \n\t"\
"mov" #size " " #a ", " #b " \n\t"
QPEL_BASE(put_ , ff_pw_16, _ , PUT_OP, PUT_OP)
QPEL_BASE(avg_ , ff_pw_16, _ , AVG_MMX2_OP, AVG_3DNOW_OP)
QPEL_BASE(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, PUT_OP)
QPEL_OP(put_ , ff_pw_16, _ , PUT_OP, 3dnow)
QPEL_OP(avg_ , ff_pw_16, _ , AVG_3DNOW_OP, 3dnow)
QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, 3dnow)
QPEL_OP(put_ , ff_pw_16, _ , PUT_OP, mmx2)
QPEL_OP(avg_ , ff_pw_16, _ , AVG_MMX2_OP, mmx2)
QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, mmx2)
#define QPEL_2TAP_XY(VAR_1, SIZE, MMX, XY, HPEL)\
static void VAR_1 ## 2tap_qpel ## SIZE ## _mc ## XY ## _ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## pixels ## SIZE ## HPEL(dst, src, stride, SIZE);\
}
#define QPEL_2TAP_L3(VAR_1, SIZE, MMX, XY, S0, S1, S2)\
static void VAR_1 ## 2tap_qpel ## SIZE ## _mc ## XY ## _ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## 2tap_qpel ## SIZE ## _l3_ ## MMX(dst, src+S0, stride, SIZE, S1, S2);\
}
#define QPEL_2TAP(VAR_1, SIZE, MMX)\
QPEL_2TAP_XY(VAR_1, SIZE, MMX, 20, _x2_ ## MMX)\
QPEL_2TAP_XY(VAR_1, SIZE, MMX, 02, _y2_ ## MMX)\
QPEL_2TAP_XY(VAR_1, SIZE, MMX, 22, _xy2_mmx)\
static const qpel_mc_func VAR_1 ## 2tap_qpel ## SIZE ## _mc00_ ## MMX =\
VAR_1 ## qpel ## SIZE ## _mc00_ ## MMX;\
static const qpel_mc_func VAR_1 ## 2tap_qpel ## SIZE ## _mc21_ ## MMX =\
VAR_1 ## 2tap_qpel ## SIZE ## _mc20_ ## MMX;\
static const qpel_mc_func VAR_1 ## 2tap_qpel ## SIZE ## _mc12_ ## MMX =\
VAR_1 ## 2tap_qpel ## SIZE ## _mc02_ ## MMX;\
static void VAR_1 ## 2tap_qpel ## SIZE ## _mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## pixels ## SIZE ## _y2_ ## MMX(dst, src+1, stride, SIZE);\
}\
static void VAR_1 ## 2tap_qpel ## SIZE ## _mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
VAR_1 ## pixels ## SIZE ## _x2_ ## MMX(dst, src+stride, stride, SIZE);\
}\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 10, 0, 1, 0)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 30, 1, -1, 0)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 01, 0, stride, 0)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 03, stride, -stride, 0)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 11, 0, stride, 1)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 31, 1, stride, -1)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 13, stride, -stride, 1)\
QPEL_2TAP_L3(VAR_1, SIZE, MMX, 33, stride+1, -stride, -1)\
QPEL_2TAP(put_, 16, mmx2)
QPEL_2TAP(avg_, 16, mmx2)
QPEL_2TAP(put_, 8, mmx2)
QPEL_2TAP(avg_, 8, mmx2)
QPEL_2TAP(put_, 16, 3dnow)
QPEL_2TAP(avg_, 16, 3dnow)
QPEL_2TAP(put_, 8, 3dnow)
QPEL_2TAP(avg_, 8, 3dnow)
#if 0
static void just_return() { return; }
#endif
static void gmc_mmx(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height){
const int w = 8;
const int ix = ox>>(16+shift);
const int iy = oy>>(16+shift);
const int oxs = ox>>4;
const int oys = oy>>4;
const int dxxs = dxx>>4;
const int dxys = dxy>>4;
const int dyxs = dyx>>4;
const int dyys = dyy>>4;
const uint16_t r4[4] = {r,r,r,r};
const uint16_t dxy4[4] = {dxys,dxys,dxys,dxys};
const uint16_t dyy4[4] = {dyys,dyys,dyys,dyys};
const uint64_t shift2 = 2*shift;
uint8_t edge_buf[(h+1)*stride];
int x, y;
const int dxw = (dxx-(1<<(16+shift)))*(w-1);
const int dyh = (dyy-(1<<(16+shift)))*(h-1);
const int dxh = dxy*(h-1);
const int dyw = dyx*(w-1);
if(
((ox^(ox+dxw)) | (ox^(ox+dxh)) | (ox^(ox+dxw+dxh)) |
(oy^(oy+dyw)) | (oy^(oy+dyh)) | (oy^(oy+dyw+dyh))) >> (16+shift)
|| (dxx|dxy|dyx|dyy)&15 )
{
ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r, width, height);
return;
}
src += ix + iy*stride;
if( (unsigned)ix >= width-w ||
(unsigned)iy >= height-h )
{
ff_emulated_edge_mc(edge_buf, src, stride, w+1, h+1, ix, iy, width, height);
src = edge_buf;
}
asm volatile(
"movd %0, %%mm6 \n\t"
"pxor %%mm7, %%mm7 \n\t"
"punpcklwd %%mm6, %%mm6 \n\t"
"punpcklwd %%mm6, %%mm6 \n\t"
:: "r"(1<<shift)
);
for(x=0; x<w; x+=4){
uint16_t dx4[4] = { oxs - dxys + dxxs*(x+0),
oxs - dxys + dxxs*(x+1),
oxs - dxys + dxxs*(x+2),
oxs - dxys + dxxs*(x+3) };
uint16_t dy4[4] = { oys - dyys + dyxs*(x+0),
oys - dyys + dyxs*(x+1),
oys - dyys + dyxs*(x+2),
oys - dyys + dyxs*(x+3) };
for(y=0; y<h; y++){
asm volatile(
"movq %0, %%mm4 \n\t"
"movq %1, %%mm5 \n\t"
"paddw %2, %%mm4 \n\t"
"paddw %3, %%mm5 \n\t"
"movq %%mm4, %0 \n\t"
"movq %%mm5, %1 \n\t"
"psrlw $12, %%mm4 \n\t"
"psrlw $12, %%mm5 \n\t"
: "+m"(*dx4), "+m"(*dy4)
: "m"(*dxy4), "m"(*dyy4)
);
asm volatile(
"movq %%mm6, %%mm2 \n\t"
"movq %%mm6, %%mm1 \n\t"
"psubw %%mm4, %%mm2 \n\t"
"psubw %%mm5, %%mm1 \n\t"
"movq %%mm2, %%mm0 \n\t"
"movq %%mm4, %%mm3 \n\t"
"pmullw %%mm1, %%mm0 \n\t"
"pmullw %%mm5, %%mm3 \n\t"
"pmullw %%mm5, %%mm2 \n\t"
"pmullw %%mm4, %%mm1 \n\t"
"movd %4, %%mm5 \n\t"
"movd %3, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"pmullw %%mm5, %%mm3 \n\t"
"pmullw %%mm4, %%mm2 \n\t"
"movd %2, %%mm5 \n\t"
"movd %1, %%mm4 \n\t"
"punpcklbw %%mm7, %%mm5 \n\t"
"punpcklbw %%mm7, %%mm4 \n\t"
"pmullw %%mm5, %%mm1 \n\t"
"pmullw %%mm4, %%mm0 \n\t"
"paddw %5, %%mm1 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm1, %%mm0 \n\t"
"paddw %%mm2, %%mm0 \n\t"
"psrlw %6, %%mm0 \n\t"
"packuswb %%mm0, %%mm0 \n\t"
"movd %%mm0, %0 \n\t"
: "=m"(dst[x+y*stride])
: "m"(src[0]), "m"(src[1]),
"m"(src[stride]), "m"(src[stride+1]),
"m"(*r4), "m"(shift2)
);
src += stride;
}
src += 4-h*stride;
}
}
| [
"PAETH(mmx2, ABS3_MMX2)\n#ifdef HAVE_SSSE3\nPAETH(ssse3, ABS3_SSSE3)\n#endif\n#define QPEL_V_LOW(m3,m4,m5,m6, pw_20, pw_3, rnd, in0, in1, in2, in7, out, OP)\\\n\"paddw \" #m4 \", \" #m3 \" \\n\\t\" \\\n\"movq \"MANGLE(ff_pw_20)\", %%mm4 \\n\\t\" \\\n\"pmullw \" #m3 \", %%mm4 \\n\\t\" \\\n\"mo... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
53,
55
],
[
57
],
[
59,
61,
63,
65,
67,
69,
71,
73,
75,
77,
79... |
14,157 | static av_cold void mdct_end(AC3MDCTContext *mdct)
{
mdct->nbits = 0;
av_freep(&mdct->costab);
av_freep(&mdct->sintab);
av_freep(&mdct->xcos1);
av_freep(&mdct->xsin1);
av_freep(&mdct->rot_tmp);
av_freep(&mdct->cplx_tmp);
}
| false | FFmpeg | 79997def65fd2313b48a5f3c3a884c6149ae9b5d | static av_cold void mdct_end(AC3MDCTContext *mdct)
{
mdct->nbits = 0;
av_freep(&mdct->costab);
av_freep(&mdct->sintab);
av_freep(&mdct->xcos1);
av_freep(&mdct->xsin1);
av_freep(&mdct->rot_tmp);
av_freep(&mdct->cplx_tmp);
}
| {
"code": [],
"line_no": []
} | static av_cold void FUNC_0(AC3MDCTContext *mdct)
{
mdct->nbits = 0;
av_freep(&mdct->costab);
av_freep(&mdct->sintab);
av_freep(&mdct->xcos1);
av_freep(&mdct->xsin1);
av_freep(&mdct->rot_tmp);
av_freep(&mdct->cplx_tmp);
}
| [
"static av_cold void FUNC_0(AC3MDCTContext *mdct)\n{",
"mdct->nbits = 0;",
"av_freep(&mdct->costab);",
"av_freep(&mdct->sintab);",
"av_freep(&mdct->xcos1);",
"av_freep(&mdct->xsin1);",
"av_freep(&mdct->rot_tmp);",
"av_freep(&mdct->cplx_tmp);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
14,158 | static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb, int * posts, float * floor, int samples) {
int range = 255 / fc->multiplier + 1;
int coded[fc->values]; // first 2 values are unused
int i, counter;
int lx, ly;
put_bits(pb, 1, 1); // non zero
put_bits(pb, ilog(range - 1), posts[0]);
put_bits(pb, ilog(range - 1), posts[1]);
for (i = 2; i < fc->values; i++) {
int predicted = render_point(fc->list[fc->list[i].low].x,
posts[fc->list[i].low],
fc->list[fc->list[i].high].x,
posts[fc->list[i].high],
fc->list[i].x);
int highroom = range - predicted;
int lowroom = predicted;
int room = FFMIN(highroom, lowroom);
if (predicted == posts[i]) {
coded[i] = 0; // must be used later as flag!
continue;
} else {
if (!coded[fc->list[i].low]) coded[fc->list[i].low] = -1;
if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1;
}
if (posts[i] > predicted) {
if (posts[i] - predicted > room) coded[i] = posts[i] - predicted + lowroom;
else coded[i] = (posts[i] - predicted) << 1;
} else {
if (predicted - posts[i] > room) coded[i] = predicted - posts[i] + highroom - 1;
else coded[i] = ((predicted - posts[i]) << 1) - 1;
}
}
counter = 2;
for (i = 0; i < fc->partitions; i++) {
floor_class_t * c = &fc->classes[fc->partition_to_class[i]];
int k, cval = 0, csub = 1<<c->subclass;
if (c->subclass) {
codebook_t * book = &venc->codebooks[c->masterbook];
int cshift = 0;
for (k = 0; k < c->dim; k++) {
int l;
for (l = 0; l < csub; l++) {
int maxval = 1;
if (c->books[l] != -1) maxval = venc->codebooks[c->books[l]].nentries;
// coded could be -1, but this still works, cause thats 0
if (coded[counter + k] < maxval) break;
}
assert(l != csub);
cval |= l << cshift;
cshift += c->subclass;
}
assert(cval < book->nentries);
put_bits(pb, book->entries[cval].len, book->entries[cval].codeword);
}
for (k = 0; k < c->dim; k++) {
int book = c->books[cval & (csub-1)];
int entry = coded[counter++];
cval >>= c->subclass;
if (book == -1) continue;
if (entry == -1) entry = 0;
assert(entry < venc->codebooks[book].nentries);
assert(entry >= 0);
put_bits(pb, venc->codebooks[book].entries[entry].len, venc->codebooks[book].entries[entry].codeword);
}
}
lx = 0;
ly = posts[0] * fc->multiplier; // sorted 0 is still 0
coded[0] = coded[1] = 1;
for (i = 1; i < fc->values; i++) {
int pos = fc->list[i].sort;
if (coded[pos]) {
render_line(lx, ly, fc->list[pos].x, posts[pos] * fc->multiplier, floor, samples);
lx = fc->list[pos].x;
ly = posts[pos] * fc->multiplier;
}
if (lx >= samples) break;
}
if (lx < samples) render_line(lx, ly, samples, ly, floor, samples);
}
| false | FFmpeg | 40b6c7213356693a98c90746f5665da581e0135d | static void floor_encode(venc_context_t * venc, floor_t * fc, PutBitContext * pb, int * posts, float * floor, int samples) {
int range = 255 / fc->multiplier + 1;
int coded[fc->values];
int i, counter;
int lx, ly;
put_bits(pb, 1, 1);
put_bits(pb, ilog(range - 1), posts[0]);
put_bits(pb, ilog(range - 1), posts[1]);
for (i = 2; i < fc->values; i++) {
int predicted = render_point(fc->list[fc->list[i].low].x,
posts[fc->list[i].low],
fc->list[fc->list[i].high].x,
posts[fc->list[i].high],
fc->list[i].x);
int highroom = range - predicted;
int lowroom = predicted;
int room = FFMIN(highroom, lowroom);
if (predicted == posts[i]) {
coded[i] = 0;
continue;
} else {
if (!coded[fc->list[i].low]) coded[fc->list[i].low] = -1;
if (!coded[fc->list[i].high]) coded[fc->list[i].high] = -1;
}
if (posts[i] > predicted) {
if (posts[i] - predicted > room) coded[i] = posts[i] - predicted + lowroom;
else coded[i] = (posts[i] - predicted) << 1;
} else {
if (predicted - posts[i] > room) coded[i] = predicted - posts[i] + highroom - 1;
else coded[i] = ((predicted - posts[i]) << 1) - 1;
}
}
counter = 2;
for (i = 0; i < fc->partitions; i++) {
floor_class_t * c = &fc->classes[fc->partition_to_class[i]];
int k, cval = 0, csub = 1<<c->subclass;
if (c->subclass) {
codebook_t * book = &venc->codebooks[c->masterbook];
int cshift = 0;
for (k = 0; k < c->dim; k++) {
int l;
for (l = 0; l < csub; l++) {
int maxval = 1;
if (c->books[l] != -1) maxval = venc->codebooks[c->books[l]].nentries;
if (coded[counter + k] < maxval) break;
}
assert(l != csub);
cval |= l << cshift;
cshift += c->subclass;
}
assert(cval < book->nentries);
put_bits(pb, book->entries[cval].len, book->entries[cval].codeword);
}
for (k = 0; k < c->dim; k++) {
int book = c->books[cval & (csub-1)];
int entry = coded[counter++];
cval >>= c->subclass;
if (book == -1) continue;
if (entry == -1) entry = 0;
assert(entry < venc->codebooks[book].nentries);
assert(entry >= 0);
put_bits(pb, venc->codebooks[book].entries[entry].len, venc->codebooks[book].entries[entry].codeword);
}
}
lx = 0;
ly = posts[0] * fc->multiplier;
coded[0] = coded[1] = 1;
for (i = 1; i < fc->values; i++) {
int pos = fc->list[i].sort;
if (coded[pos]) {
render_line(lx, ly, fc->list[pos].x, posts[pos] * fc->multiplier, floor, samples);
lx = fc->list[pos].x;
ly = posts[pos] * fc->multiplier;
}
if (lx >= samples) break;
}
if (lx < samples) render_line(lx, ly, samples, ly, floor, samples);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(venc_context_t * VAR_0, floor_t * VAR_1, PutBitContext * VAR_2, int * VAR_3, float * VAR_4, int VAR_5) {
int VAR_6 = 255 / VAR_1->multiplier + 1;
int VAR_7[VAR_1->values];
int VAR_8, VAR_9;
int VAR_10, VAR_11;
put_bits(VAR_2, 1, 1);
put_bits(VAR_2, ilog(VAR_6 - 1), VAR_3[0]);
put_bits(VAR_2, ilog(VAR_6 - 1), VAR_3[1]);
for (VAR_8 = 2; VAR_8 < VAR_1->values; VAR_8++) {
int predicted = render_point(VAR_1->list[VAR_1->list[VAR_8].low].x,
VAR_3[VAR_1->list[VAR_8].low],
VAR_1->list[VAR_1->list[VAR_8].high].x,
VAR_3[VAR_1->list[VAR_8].high],
VAR_1->list[VAR_8].x);
int highroom = VAR_6 - predicted;
int lowroom = predicted;
int room = FFMIN(highroom, lowroom);
if (predicted == VAR_3[VAR_8]) {
VAR_7[VAR_8] = 0;
continue;
} else {
if (!VAR_7[VAR_1->list[VAR_8].low]) VAR_7[VAR_1->list[VAR_8].low] = -1;
if (!VAR_7[VAR_1->list[VAR_8].high]) VAR_7[VAR_1->list[VAR_8].high] = -1;
}
if (VAR_3[VAR_8] > predicted) {
if (VAR_3[VAR_8] - predicted > room) VAR_7[VAR_8] = VAR_3[VAR_8] - predicted + lowroom;
else VAR_7[VAR_8] = (VAR_3[VAR_8] - predicted) << 1;
} else {
if (predicted - VAR_3[VAR_8] > room) VAR_7[VAR_8] = predicted - VAR_3[VAR_8] + highroom - 1;
else VAR_7[VAR_8] = ((predicted - VAR_3[VAR_8]) << 1) - 1;
}
}
VAR_9 = 2;
for (VAR_8 = 0; VAR_8 < VAR_1->partitions; VAR_8++) {
floor_class_t * c = &VAR_1->classes[VAR_1->partition_to_class[VAR_8]];
int k, cval = 0, csub = 1<<c->subclass;
if (c->subclass) {
codebook_t * book = &VAR_0->codebooks[c->masterbook];
int cshift = 0;
for (k = 0; k < c->dim; k++) {
int l;
for (l = 0; l < csub; l++) {
int maxval = 1;
if (c->books[l] != -1) maxval = VAR_0->codebooks[c->books[l]].nentries;
if (VAR_7[VAR_9 + k] < maxval) break;
}
assert(l != csub);
cval |= l << cshift;
cshift += c->subclass;
}
assert(cval < book->nentries);
put_bits(VAR_2, book->entries[cval].len, book->entries[cval].codeword);
}
for (k = 0; k < c->dim; k++) {
int book = c->books[cval & (csub-1)];
int entry = VAR_7[VAR_9++];
cval >>= c->subclass;
if (book == -1) continue;
if (entry == -1) entry = 0;
assert(entry < VAR_0->codebooks[book].nentries);
assert(entry >= 0);
put_bits(VAR_2, VAR_0->codebooks[book].entries[entry].len, VAR_0->codebooks[book].entries[entry].codeword);
}
}
VAR_10 = 0;
VAR_11 = VAR_3[0] * VAR_1->multiplier;
VAR_7[0] = VAR_7[1] = 1;
for (VAR_8 = 1; VAR_8 < VAR_1->values; VAR_8++) {
int pos = VAR_1->list[VAR_8].sort;
if (VAR_7[pos]) {
render_line(VAR_10, VAR_11, VAR_1->list[pos].x, VAR_3[pos] * VAR_1->multiplier, VAR_4, VAR_5);
VAR_10 = VAR_1->list[pos].x;
VAR_11 = VAR_3[pos] * VAR_1->multiplier;
}
if (VAR_10 >= VAR_5) break;
}
if (VAR_10 < VAR_5) render_line(VAR_10, VAR_11, VAR_5, VAR_11, VAR_4, VAR_5);
}
| [
"static void FUNC_0(venc_context_t * VAR_0, floor_t * VAR_1, PutBitContext * VAR_2, int * VAR_3, float * VAR_4, int VAR_5) {",
"int VAR_6 = 255 / VAR_1->multiplier + 1;",
"int VAR_7[VAR_1->values];",
"int VAR_8, VAR_9;",
"int VAR_10, VAR_11;",
"put_bits(VAR_2, 1, 1);",
"put_bits(VAR_2, ilog(VAR_6 - 1), ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23,
25,
27,
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[... |
14,159 | dshow_cycle_formats(AVFormatContext *avctx, enum dshowDeviceType devtype,
IPin *pin, int *pformat_set)
{
struct dshow_ctx *ctx = avctx->priv_data;
IAMStreamConfig *config = NULL;
AM_MEDIA_TYPE *type = NULL;
int format_set = 0;
void *caps = NULL;
int i, n, size;
if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)
return;
if (IAMStreamConfig_GetNumberOfCapabilities(config, &n, &size) != S_OK)
goto end;
caps = av_malloc(size);
if (!caps)
goto end;
for (i = 0; i < n && !format_set; i++) {
IAMStreamConfig_GetStreamCaps(config, i, &type, (void *) caps);
#if DSHOWDEBUG
ff_print_AM_MEDIA_TYPE(type);
#endif
if (devtype == VideoDevice) {
VIDEO_STREAM_CONFIG_CAPS *vcaps = caps;
BITMAPINFOHEADER *bih;
int64_t *fr;
const AVCodecTag *const tags[] = { avformat_get_riff_video_tags(), NULL };
#if DSHOWDEBUG
ff_print_VIDEO_STREAM_CONFIG_CAPS(vcaps);
#endif
if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {
VIDEOINFOHEADER *v = (void *) type->pbFormat;
fr = &v->AvgTimePerFrame;
bih = &v->bmiHeader;
} else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {
VIDEOINFOHEADER2 *v = (void *) type->pbFormat;
fr = &v->AvgTimePerFrame;
bih = &v->bmiHeader;
} else {
goto next;
}
if (!pformat_set) {
enum AVPixelFormat pix_fmt = dshow_pixfmt(bih->biCompression, bih->biBitCount);
if (pix_fmt == AV_PIX_FMT_NONE) {
enum AVCodecID codec_id = av_codec_get_id(tags, bih->biCompression);
AVCodec *codec = avcodec_find_decoder(codec_id);
if (codec_id == AV_CODEC_ID_NONE || !codec) {
av_log(avctx, AV_LOG_INFO, " unknown compression type 0x%X", (int) bih->biCompression);
} else {
av_log(avctx, AV_LOG_INFO, " vcodec=%s", codec->name);
}
} else {
av_log(avctx, AV_LOG_INFO, " pixel_format=%s", av_get_pix_fmt_name(pix_fmt));
}
av_log(avctx, AV_LOG_INFO, " min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\n",
vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,
1e7 / vcaps->MaxFrameInterval,
vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,
1e7 / vcaps->MinFrameInterval);
continue;
}
if (ctx->video_codec_id != AV_CODEC_ID_RAWVIDEO) {
if (ctx->video_codec_id != av_codec_get_id(tags, bih->biCompression))
goto next;
}
if (ctx->pixel_format != AV_PIX_FMT_NONE &&
ctx->pixel_format != dshow_pixfmt(bih->biCompression, bih->biBitCount)) {
goto next;
}
if (ctx->framerate) {
int64_t framerate = ((int64_t) ctx->requested_framerate.den*10000000)
/ ctx->requested_framerate.num;
if (framerate > vcaps->MaxFrameInterval ||
framerate < vcaps->MinFrameInterval)
goto next;
*fr = framerate;
}
if (ctx->requested_width && ctx->requested_height) {
if (ctx->requested_width > vcaps->MaxOutputSize.cx ||
ctx->requested_width < vcaps->MinOutputSize.cx ||
ctx->requested_height > vcaps->MaxOutputSize.cy ||
ctx->requested_height < vcaps->MinOutputSize.cy)
goto next;
bih->biWidth = ctx->requested_width;
bih->biHeight = ctx->requested_height;
}
} else {
AUDIO_STREAM_CONFIG_CAPS *acaps = caps;
WAVEFORMATEX *fx;
#if DSHOWDEBUG
ff_print_AUDIO_STREAM_CONFIG_CAPS(acaps);
#endif
if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {
fx = (void *) type->pbFormat;
} else {
goto next;
}
if (!pformat_set) {
av_log(avctx, AV_LOG_INFO, " min ch=%lu bits=%lu rate=%6lu max ch=%lu bits=%lu rate=%6lu\n",
acaps->MinimumChannels, acaps->MinimumBitsPerSample, acaps->MinimumSampleFrequency,
acaps->MaximumChannels, acaps->MaximumBitsPerSample, acaps->MaximumSampleFrequency);
continue;
}
if (ctx->sample_rate) {
if (ctx->sample_rate > acaps->MaximumSampleFrequency ||
ctx->sample_rate < acaps->MinimumSampleFrequency)
goto next;
fx->nSamplesPerSec = ctx->sample_rate;
}
if (ctx->sample_size) {
if (ctx->sample_size > acaps->MaximumBitsPerSample ||
ctx->sample_size < acaps->MinimumBitsPerSample)
goto next;
fx->wBitsPerSample = ctx->sample_size;
}
if (ctx->channels) {
if (ctx->channels > acaps->MaximumChannels ||
ctx->channels < acaps->MinimumChannels)
goto next;
fx->nChannels = ctx->channels;
}
}
if (IAMStreamConfig_SetFormat(config, type) != S_OK)
goto next;
format_set = 1;
next:
if (type->pbFormat)
CoTaskMemFree(type->pbFormat);
CoTaskMemFree(type);
}
end:
IAMStreamConfig_Release(config);
if (caps)
av_free(caps);
if (pformat_set)
*pformat_set = format_set;
}
| false | FFmpeg | 9c3a8693a20da3ad89a327bf778e13c2cd74c81c | dshow_cycle_formats(AVFormatContext *avctx, enum dshowDeviceType devtype,
IPin *pin, int *pformat_set)
{
struct dshow_ctx *ctx = avctx->priv_data;
IAMStreamConfig *config = NULL;
AM_MEDIA_TYPE *type = NULL;
int format_set = 0;
void *caps = NULL;
int i, n, size;
if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)
return;
if (IAMStreamConfig_GetNumberOfCapabilities(config, &n, &size) != S_OK)
goto end;
caps = av_malloc(size);
if (!caps)
goto end;
for (i = 0; i < n && !format_set; i++) {
IAMStreamConfig_GetStreamCaps(config, i, &type, (void *) caps);
#if DSHOWDEBUG
ff_print_AM_MEDIA_TYPE(type);
#endif
if (devtype == VideoDevice) {
VIDEO_STREAM_CONFIG_CAPS *vcaps = caps;
BITMAPINFOHEADER *bih;
int64_t *fr;
const AVCodecTag *const tags[] = { avformat_get_riff_video_tags(), NULL };
#if DSHOWDEBUG
ff_print_VIDEO_STREAM_CONFIG_CAPS(vcaps);
#endif
if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {
VIDEOINFOHEADER *v = (void *) type->pbFormat;
fr = &v->AvgTimePerFrame;
bih = &v->bmiHeader;
} else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {
VIDEOINFOHEADER2 *v = (void *) type->pbFormat;
fr = &v->AvgTimePerFrame;
bih = &v->bmiHeader;
} else {
goto next;
}
if (!pformat_set) {
enum AVPixelFormat pix_fmt = dshow_pixfmt(bih->biCompression, bih->biBitCount);
if (pix_fmt == AV_PIX_FMT_NONE) {
enum AVCodecID codec_id = av_codec_get_id(tags, bih->biCompression);
AVCodec *codec = avcodec_find_decoder(codec_id);
if (codec_id == AV_CODEC_ID_NONE || !codec) {
av_log(avctx, AV_LOG_INFO, " unknown compression type 0x%X", (int) bih->biCompression);
} else {
av_log(avctx, AV_LOG_INFO, " vcodec=%s", codec->name);
}
} else {
av_log(avctx, AV_LOG_INFO, " pixel_format=%s", av_get_pix_fmt_name(pix_fmt));
}
av_log(avctx, AV_LOG_INFO, " min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\n",
vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,
1e7 / vcaps->MaxFrameInterval,
vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,
1e7 / vcaps->MinFrameInterval);
continue;
}
if (ctx->video_codec_id != AV_CODEC_ID_RAWVIDEO) {
if (ctx->video_codec_id != av_codec_get_id(tags, bih->biCompression))
goto next;
}
if (ctx->pixel_format != AV_PIX_FMT_NONE &&
ctx->pixel_format != dshow_pixfmt(bih->biCompression, bih->biBitCount)) {
goto next;
}
if (ctx->framerate) {
int64_t framerate = ((int64_t) ctx->requested_framerate.den*10000000)
/ ctx->requested_framerate.num;
if (framerate > vcaps->MaxFrameInterval ||
framerate < vcaps->MinFrameInterval)
goto next;
*fr = framerate;
}
if (ctx->requested_width && ctx->requested_height) {
if (ctx->requested_width > vcaps->MaxOutputSize.cx ||
ctx->requested_width < vcaps->MinOutputSize.cx ||
ctx->requested_height > vcaps->MaxOutputSize.cy ||
ctx->requested_height < vcaps->MinOutputSize.cy)
goto next;
bih->biWidth = ctx->requested_width;
bih->biHeight = ctx->requested_height;
}
} else {
AUDIO_STREAM_CONFIG_CAPS *acaps = caps;
WAVEFORMATEX *fx;
#if DSHOWDEBUG
ff_print_AUDIO_STREAM_CONFIG_CAPS(acaps);
#endif
if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {
fx = (void *) type->pbFormat;
} else {
goto next;
}
if (!pformat_set) {
av_log(avctx, AV_LOG_INFO, " min ch=%lu bits=%lu rate=%6lu max ch=%lu bits=%lu rate=%6lu\n",
acaps->MinimumChannels, acaps->MinimumBitsPerSample, acaps->MinimumSampleFrequency,
acaps->MaximumChannels, acaps->MaximumBitsPerSample, acaps->MaximumSampleFrequency);
continue;
}
if (ctx->sample_rate) {
if (ctx->sample_rate > acaps->MaximumSampleFrequency ||
ctx->sample_rate < acaps->MinimumSampleFrequency)
goto next;
fx->nSamplesPerSec = ctx->sample_rate;
}
if (ctx->sample_size) {
if (ctx->sample_size > acaps->MaximumBitsPerSample ||
ctx->sample_size < acaps->MinimumBitsPerSample)
goto next;
fx->wBitsPerSample = ctx->sample_size;
}
if (ctx->channels) {
if (ctx->channels > acaps->MaximumChannels ||
ctx->channels < acaps->MinimumChannels)
goto next;
fx->nChannels = ctx->channels;
}
}
if (IAMStreamConfig_SetFormat(config, type) != S_OK)
goto next;
format_set = 1;
next:
if (type->pbFormat)
CoTaskMemFree(type->pbFormat);
CoTaskMemFree(type);
}
end:
IAMStreamConfig_Release(config);
if (caps)
av_free(caps);
if (pformat_set)
*pformat_set = format_set;
}
| {
"code": [],
"line_no": []
} | FUNC_0(AVFormatContext *VAR_0, enum dshowDeviceType VAR_1,
IPin *VAR_2, int *VAR_3)
{
struct dshow_ctx *VAR_4 = VAR_0->priv_data;
IAMStreamConfig *config = NULL;
AM_MEDIA_TYPE *type = NULL;
int VAR_5 = 0;
void *VAR_6 = NULL;
int VAR_7, VAR_8, VAR_9;
if (IPin_QueryInterface(VAR_2, &IID_IAMStreamConfig, (void **) &config) != S_OK)
return;
if (IAMStreamConfig_GetNumberOfCapabilities(config, &VAR_8, &VAR_9) != S_OK)
goto end;
VAR_6 = av_malloc(VAR_9);
if (!VAR_6)
goto end;
for (VAR_7 = 0; VAR_7 < VAR_8 && !VAR_5; VAR_7++) {
IAMStreamConfig_GetStreamCaps(config, VAR_7, &type, (void *) VAR_6);
#if DSHOWDEBUG
ff_print_AM_MEDIA_TYPE(type);
#endif
if (VAR_1 == VideoDevice) {
VIDEO_STREAM_CONFIG_CAPS *vcaps = VAR_6;
BITMAPINFOHEADER *bih;
int64_t *fr;
const AVCodecTag *const VAR_10[] = { avformat_get_riff_video_tags(), NULL };
#if DSHOWDEBUG
ff_print_VIDEO_STREAM_CONFIG_CAPS(vcaps);
#endif
if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {
VIDEOINFOHEADER *v = (void *) type->pbFormat;
fr = &v->AvgTimePerFrame;
bih = &v->bmiHeader;
} else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {
VIDEOINFOHEADER2 *v = (void *) type->pbFormat;
fr = &v->AvgTimePerFrame;
bih = &v->bmiHeader;
} else {
goto next;
}
if (!VAR_3) {
enum AVPixelFormat VAR_11 = dshow_pixfmt(bih->biCompression, bih->biBitCount);
if (VAR_11 == AV_PIX_FMT_NONE) {
enum AVCodecID VAR_12 = av_codec_get_id(VAR_10, bih->biCompression);
AVCodec *codec = avcodec_find_decoder(VAR_12);
if (VAR_12 == AV_CODEC_ID_NONE || !codec) {
av_log(VAR_0, AV_LOG_INFO, " unknown compression type 0x%X", (int) bih->biCompression);
} else {
av_log(VAR_0, AV_LOG_INFO, " vcodec=%s", codec->name);
}
} else {
av_log(VAR_0, AV_LOG_INFO, " pixel_format=%s", av_get_pix_fmt_name(VAR_11));
}
av_log(VAR_0, AV_LOG_INFO, " min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\VAR_8",
vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,
1e7 / vcaps->MaxFrameInterval,
vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,
1e7 / vcaps->MinFrameInterval);
continue;
}
if (VAR_4->video_codec_id != AV_CODEC_ID_RAWVIDEO) {
if (VAR_4->video_codec_id != av_codec_get_id(VAR_10, bih->biCompression))
goto next;
}
if (VAR_4->pixel_format != AV_PIX_FMT_NONE &&
VAR_4->pixel_format != dshow_pixfmt(bih->biCompression, bih->biBitCount)) {
goto next;
}
if (VAR_4->framerate) {
int64_t framerate = ((int64_t) VAR_4->requested_framerate.den*10000000)
/ VAR_4->requested_framerate.num;
if (framerate > vcaps->MaxFrameInterval ||
framerate < vcaps->MinFrameInterval)
goto next;
*fr = framerate;
}
if (VAR_4->requested_width && VAR_4->requested_height) {
if (VAR_4->requested_width > vcaps->MaxOutputSize.cx ||
VAR_4->requested_width < vcaps->MinOutputSize.cx ||
VAR_4->requested_height > vcaps->MaxOutputSize.cy ||
VAR_4->requested_height < vcaps->MinOutputSize.cy)
goto next;
bih->biWidth = VAR_4->requested_width;
bih->biHeight = VAR_4->requested_height;
}
} else {
AUDIO_STREAM_CONFIG_CAPS *acaps = VAR_6;
WAVEFORMATEX *fx;
#if DSHOWDEBUG
ff_print_AUDIO_STREAM_CONFIG_CAPS(acaps);
#endif
if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {
fx = (void *) type->pbFormat;
} else {
goto next;
}
if (!VAR_3) {
av_log(VAR_0, AV_LOG_INFO, " min ch=%lu bits=%lu rate=%6lu max ch=%lu bits=%lu rate=%6lu\VAR_8",
acaps->MinimumChannels, acaps->MinimumBitsPerSample, acaps->MinimumSampleFrequency,
acaps->MaximumChannels, acaps->MaximumBitsPerSample, acaps->MaximumSampleFrequency);
continue;
}
if (VAR_4->sample_rate) {
if (VAR_4->sample_rate > acaps->MaximumSampleFrequency ||
VAR_4->sample_rate < acaps->MinimumSampleFrequency)
goto next;
fx->nSamplesPerSec = VAR_4->sample_rate;
}
if (VAR_4->sample_size) {
if (VAR_4->sample_size > acaps->MaximumBitsPerSample ||
VAR_4->sample_size < acaps->MinimumBitsPerSample)
goto next;
fx->wBitsPerSample = VAR_4->sample_size;
}
if (VAR_4->channels) {
if (VAR_4->channels > acaps->MaximumChannels ||
VAR_4->channels < acaps->MinimumChannels)
goto next;
fx->nChannels = VAR_4->channels;
}
}
if (IAMStreamConfig_SetFormat(config, type) != S_OK)
goto next;
VAR_5 = 1;
next:
if (type->pbFormat)
CoTaskMemFree(type->pbFormat);
CoTaskMemFree(type);
}
end:
IAMStreamConfig_Release(config);
if (VAR_6)
av_free(VAR_6);
if (VAR_3)
*VAR_3 = VAR_5;
}
| [
"FUNC_0(AVFormatContext *VAR_0, enum dshowDeviceType VAR_1,\nIPin *VAR_2, int *VAR_3)\n{",
"struct dshow_ctx *VAR_4 = VAR_0->priv_data;",
"IAMStreamConfig *config = NULL;",
"AM_MEDIA_TYPE *type = NULL;",
"int VAR_5 = 0;",
"void *VAR_6 = NULL;",
"int VAR_7, VAR_8, VAR_9;",
"if (IPin_QueryInterface(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... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21,
23
],
[
25,
27
],
[
31
],
[
33,
35
],
[
39
],
[
41
],
[
45,
47
],
[
49,
53
],
[
55
],
[
57
... |
14,160 | static void usbredir_log_data(USBRedirDevice *dev, const char *desc,
const uint8_t *data, int len)
{
int i, j, n;
if (dev->debug < usbredirparser_debug_data) {
return;
}
for (i = 0; i < len; i += j) {
char buf[128];
n = sprintf(buf, "%s", desc);
for (j = 0; j < 8 && i + j < len; j++) {
n += sprintf(buf + n, " %02X", data[i + j]);
}
error_report("%s", buf);
}
}
| true | qemu | bd4a683505b27adc1ac809f71e918e58573d851d | static void usbredir_log_data(USBRedirDevice *dev, const char *desc,
const uint8_t *data, int len)
{
int i, j, n;
if (dev->debug < usbredirparser_debug_data) {
return;
}
for (i = 0; i < len; i += j) {
char buf[128];
n = sprintf(buf, "%s", desc);
for (j = 0; j < 8 && i + j < len; j++) {
n += sprintf(buf + n, " %02X", data[i + j]);
}
error_report("%s", buf);
}
}
| {
"code": [
" int i, j, n;",
" for (i = 0; i < len; i += j) {",
" char buf[128];",
" n = sprintf(buf, \"%s\", desc);",
" for (j = 0; j < 8 && i + j < len; j++) {",
" n += sprintf(buf + n, \" %02X\", data[i + j]);",
" error_report(\"%s\", buf);"
],
"line_no": [
7,
19,
21,
25,
27,
29,
33
]
} | static void FUNC_0(USBRedirDevice *VAR_0, const char *VAR_1,
const uint8_t *VAR_2, int VAR_3)
{
int VAR_4, VAR_5, VAR_6;
if (VAR_0->debug < usbredirparser_debug_data) {
return;
}
for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4 += VAR_5) {
char VAR_7[128];
VAR_6 = sprintf(VAR_7, "%s", VAR_1);
for (VAR_5 = 0; VAR_5 < 8 && VAR_4 + VAR_5 < VAR_3; VAR_5++) {
VAR_6 += sprintf(VAR_7 + VAR_6, " %02X", VAR_2[VAR_4 + VAR_5]);
}
error_report("%s", VAR_7);
}
}
| [
"static void FUNC_0(USBRedirDevice *VAR_0, const char *VAR_1,\nconst uint8_t *VAR_2, int VAR_3)\n{",
"int VAR_4, VAR_5, VAR_6;",
"if (VAR_0->debug < usbredirparser_debug_data) {",
"return;",
"}",
"for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4 += VAR_5) {",
"char VAR_7[128];",
"VAR_6 = sprintf(VAR_7, \"%s\", VA... | [
0,
1,
0,
0,
0,
1,
1,
1,
1,
1,
0,
1,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
]
] |
14,161 | static void typhoon_pcihost_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
k->init = typhoon_pcihost_init;
dc->no_user = 1;
}
| true | qemu | efec3dd631d94160288392721a5f9c39e50fb2bc | static void typhoon_pcihost_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
k->init = typhoon_pcihost_init;
dc->no_user = 1;
}
| {
"code": [
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;"
],
"line_no": [
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13
]
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(VAR_0);
k->init = typhoon_pcihost_init;
dc->no_user = 1;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(VAR_0);",
"k->init = typhoon_pcihost_init;",
"dc->no_user = 1;",
"}"
] | [
0,
0,
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
]
] |
14,163 | static int mp_decode_frame(MPADecodeContext *s,
OUT_INT *samples, const uint8_t *buf, int buf_size)
{
int i, nb_frames, ch;
OUT_INT *samples_ptr;
init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE)*8);
/* skip error protection field */
if (s->error_protection)
skip_bits(&s->gb, 16);
dprintf(s->avctx, "frame %d:\n", s->frame_count);
switch(s->layer) {
case 1:
s->avctx->frame_size = 384;
nb_frames = mp_decode_layer1(s);
break;
case 2:
s->avctx->frame_size = 1152;
nb_frames = mp_decode_layer2(s);
break;
case 3:
s->avctx->frame_size = s->lsf ? 576 : 1152;
default:
nb_frames = mp_decode_layer3(s);
s->last_buf_size=0;
if(s->in_gb.buffer){
align_get_bits(&s->gb);
i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
if(i >= 0 && i <= BACKSTEP_SIZE){
memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
s->last_buf_size=i;
}else
av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
s->gb= s->in_gb;
s->in_gb.buffer= NULL;
}
align_get_bits(&s->gb);
assert((get_bits_count(&s->gb) & 7) == 0);
i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
if(i<0 || i > BACKSTEP_SIZE || nb_frames<0){
av_log(s->avctx, AV_LOG_WARNING, "invalid new backstep %d\n", i);
i= FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
}
assert(i <= buf_size - HEADER_SIZE && i>= 0);
memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
s->last_buf_size += i;
break;
}
/* apply the synthesis filter */
for(ch=0;ch<s->nb_channels;ch++) {
samples_ptr = samples + ch;
for(i=0;i<nb_frames;i++) {
ff_mpa_synth_filter(s->synth_buf[ch], &(s->synth_buf_offset[ch]),
window, &s->dither_state,
samples_ptr, s->nb_channels,
s->sb_samples[ch][i]);
samples_ptr += 32 * s->nb_channels;
}
}
return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
}
| false | FFmpeg | 1d4113d0532ff01f9db5964333eb1a3997d9fb86 | static int mp_decode_frame(MPADecodeContext *s,
OUT_INT *samples, const uint8_t *buf, int buf_size)
{
int i, nb_frames, ch;
OUT_INT *samples_ptr;
init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE)*8);
if (s->error_protection)
skip_bits(&s->gb, 16);
dprintf(s->avctx, "frame %d:\n", s->frame_count);
switch(s->layer) {
case 1:
s->avctx->frame_size = 384;
nb_frames = mp_decode_layer1(s);
break;
case 2:
s->avctx->frame_size = 1152;
nb_frames = mp_decode_layer2(s);
break;
case 3:
s->avctx->frame_size = s->lsf ? 576 : 1152;
default:
nb_frames = mp_decode_layer3(s);
s->last_buf_size=0;
if(s->in_gb.buffer){
align_get_bits(&s->gb);
i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
if(i >= 0 && i <= BACKSTEP_SIZE){
memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
s->last_buf_size=i;
}else
av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
s->gb= s->in_gb;
s->in_gb.buffer= NULL;
}
align_get_bits(&s->gb);
assert((get_bits_count(&s->gb) & 7) == 0);
i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
if(i<0 || i > BACKSTEP_SIZE || nb_frames<0){
av_log(s->avctx, AV_LOG_WARNING, "invalid new backstep %d\n", i);
i= FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
}
assert(i <= buf_size - HEADER_SIZE && i>= 0);
memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
s->last_buf_size += i;
break;
}
for(ch=0;ch<s->nb_channels;ch++) {
samples_ptr = samples + ch;
for(i=0;i<nb_frames;i++) {
ff_mpa_synth_filter(s->synth_buf[ch], &(s->synth_buf_offset[ch]),
window, &s->dither_state,
samples_ptr, s->nb_channels,
s->sb_samples[ch][i]);
samples_ptr += 32 * s->nb_channels;
}
}
return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(MPADecodeContext *VAR_0,
OUT_INT *VAR_1, const uint8_t *VAR_2, int VAR_3)
{
int VAR_4, VAR_5, VAR_6;
OUT_INT *samples_ptr;
init_get_bits(&VAR_0->gb, VAR_2 + HEADER_SIZE, (VAR_3 - HEADER_SIZE)*8);
if (VAR_0->error_protection)
skip_bits(&VAR_0->gb, 16);
dprintf(VAR_0->avctx, "frame %d:\n", VAR_0->frame_count);
switch(VAR_0->layer) {
case 1:
VAR_0->avctx->frame_size = 384;
VAR_5 = mp_decode_layer1(VAR_0);
break;
case 2:
VAR_0->avctx->frame_size = 1152;
VAR_5 = mp_decode_layer2(VAR_0);
break;
case 3:
VAR_0->avctx->frame_size = VAR_0->lsf ? 576 : 1152;
default:
VAR_5 = mp_decode_layer3(VAR_0);
VAR_0->last_buf_size=0;
if(VAR_0->in_gb.buffer){
align_get_bits(&VAR_0->gb);
VAR_4= (VAR_0->gb.size_in_bits - get_bits_count(&VAR_0->gb))>>3;
if(VAR_4 >= 0 && VAR_4 <= BACKSTEP_SIZE){
memmove(VAR_0->last_buf, VAR_0->gb.buffer + (get_bits_count(&VAR_0->gb)>>3), VAR_4);
VAR_0->last_buf_size=VAR_4;
}else
av_log(VAR_0->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", VAR_4);
VAR_0->gb= VAR_0->in_gb;
VAR_0->in_gb.buffer= NULL;
}
align_get_bits(&VAR_0->gb);
assert((get_bits_count(&VAR_0->gb) & 7) == 0);
VAR_4= (VAR_0->gb.size_in_bits - get_bits_count(&VAR_0->gb))>>3;
if(VAR_4<0 || VAR_4 > BACKSTEP_SIZE || VAR_5<0){
av_log(VAR_0->avctx, AV_LOG_WARNING, "invalid new backstep %d\n", VAR_4);
VAR_4= FFMIN(BACKSTEP_SIZE, VAR_3 - HEADER_SIZE);
}
assert(VAR_4 <= VAR_3 - HEADER_SIZE && VAR_4>= 0);
memcpy(VAR_0->last_buf + VAR_0->last_buf_size, VAR_0->gb.buffer + VAR_3 - HEADER_SIZE - VAR_4, VAR_4);
VAR_0->last_buf_size += VAR_4;
break;
}
for(VAR_6=0;VAR_6<VAR_0->nb_channels;VAR_6++) {
samples_ptr = VAR_1 + VAR_6;
for(VAR_4=0;VAR_4<VAR_5;VAR_4++) {
ff_mpa_synth_filter(VAR_0->synth_buf[VAR_6], &(VAR_0->synth_buf_offset[VAR_6]),
window, &VAR_0->dither_state,
samples_ptr, VAR_0->nb_channels,
VAR_0->sb_samples[VAR_6][VAR_4]);
samples_ptr += 32 * VAR_0->nb_channels;
}
}
return VAR_5 * 32 * sizeof(OUT_INT) * VAR_0->nb_channels;
}
| [
"static int FUNC_0(MPADecodeContext *VAR_0,\nOUT_INT *VAR_1, const uint8_t *VAR_2, int VAR_3)\n{",
"int VAR_4, VAR_5, VAR_6;",
"OUT_INT *samples_ptr;",
"init_get_bits(&VAR_0->gb, VAR_2 + HEADER_SIZE, (VAR_3 - HEADER_SIZE)*8);",
"if (VAR_0->error_protection)\nskip_bits(&VAR_0->gb, 16);",
"dprintf(VAR_0->av... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
19,
21
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[
49,
51
],
[
55
],
[
57
... |
14,164 | static int encode_dvb_subtitles(DVBSubtitleContext *s,
uint8_t *outbuf, const AVSubtitle *h)
{
uint8_t *q, *pseg_len;
int page_id, region_id, clut_id, object_id, i, bpp_index, page_state;
q = outbuf;
page_id = 1;
if (h->num_rects == 0 || h->rects == NULL)
return -1;
*q++ = 0x00; /* subtitle_stream_id */
/* page composition segment */
*q++ = 0x0f; /* sync_byte */
*q++ = 0x10; /* segment_type */
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2; /* segment length */
*q++ = 30; /* page_timeout (seconds) */
if (s->hide_state)
page_state = 0; /* normal case */
else
page_state = 2; /* mode change */
/* page_version = 0 + page_state */
*q++ = (s->object_version << 4) | (page_state << 2) | 3;
for (region_id = 0; region_id < h->num_rects; region_id++) {
*q++ = region_id;
*q++ = 0xff; /* reserved */
bytestream_put_be16(&q, h->rects[region_id]->x); /* left pos */
bytestream_put_be16(&q, h->rects[region_id]->y); /* top pos */
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
if (!s->hide_state) {
for (clut_id = 0; clut_id < h->num_rects; clut_id++) {
/* CLUT segment */
if (h->rects[clut_id]->nb_colors <= 4) {
/* 2 bpp, some decoders do not support it correctly */
bpp_index = 0;
} else if (h->rects[clut_id]->nb_colors <= 16) {
/* 4 bpp, standard encoding */
bpp_index = 1;
} else {
return -1;
}
*q++ = 0x0f; /* sync byte */
*q++ = 0x12; /* CLUT definition segment */
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2; /* segment length */
*q++ = clut_id;
*q++ = (0 << 4) | 0xf; /* version = 0 */
for(i = 0; i < h->rects[clut_id]->nb_colors; i++) {
*q++ = i; /* clut_entry_id */
*q++ = (1 << (7 - bpp_index)) | (0xf << 1) | 1; /* 2 bits/pixel full range */
{
int a, r, g, b;
uint32_t x= ((uint32_t*)h->rects[clut_id]->pict.data[1])[i];
a = (x >> 24) & 0xff;
r = (x >> 16) & 0xff;
g = (x >> 8) & 0xff;
b = (x >> 0) & 0xff;
*q++ = RGB_TO_Y_CCIR(r, g, b);
*q++ = RGB_TO_V_CCIR(r, g, b, 0);
*q++ = RGB_TO_U_CCIR(r, g, b, 0);
*q++ = 255 - a;
}
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
}
for (region_id = 0; region_id < h->num_rects; region_id++) {
/* region composition segment */
if (h->rects[region_id]->nb_colors <= 4) {
/* 2 bpp, some decoders do not support it correctly */
bpp_index = 0;
} else if (h->rects[region_id]->nb_colors <= 16) {
/* 4 bpp, standard encoding */
bpp_index = 1;
} else {
return -1;
}
*q++ = 0x0f; /* sync_byte */
*q++ = 0x11; /* segment_type */
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2; /* segment length */
*q++ = region_id;
*q++ = (s->object_version << 4) | (0 << 3) | 0x07; /* version , no fill */
bytestream_put_be16(&q, h->rects[region_id]->w); /* region width */
bytestream_put_be16(&q, h->rects[region_id]->h); /* region height */
*q++ = ((1 + bpp_index) << 5) | ((1 + bpp_index) << 2) | 0x03;
*q++ = region_id; /* clut_id == region_id */
*q++ = 0; /* 8 bit fill colors */
*q++ = 0x03; /* 4 bit and 2 bit fill colors */
if (!s->hide_state) {
bytestream_put_be16(&q, region_id); /* object_id == region_id */
*q++ = (0 << 6) | (0 << 4);
*q++ = 0;
*q++ = 0xf0;
*q++ = 0;
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
if (!s->hide_state) {
for (object_id = 0; object_id < h->num_rects; object_id++) {
/* Object Data segment */
if (h->rects[object_id]->nb_colors <= 4) {
/* 2 bpp, some decoders do not support it correctly */
bpp_index = 0;
} else if (h->rects[object_id]->nb_colors <= 16) {
/* 4 bpp, standard encoding */
bpp_index = 1;
} else {
return -1;
}
*q++ = 0x0f; /* sync byte */
*q++ = 0x13;
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2; /* segment length */
bytestream_put_be16(&q, object_id);
*q++ = (s->object_version << 4) | (0 << 2) | (0 << 1) | 1; /* version = 0,
onject_coding_method,
non_modifying_color_flag */
{
uint8_t *ptop_field_len, *pbottom_field_len, *top_ptr, *bottom_ptr;
void (*dvb_encode_rle)(uint8_t **pq,
const uint8_t *bitmap, int linesize,
int w, int h);
ptop_field_len = q;
q += 2;
pbottom_field_len = q;
q += 2;
if (bpp_index == 0)
dvb_encode_rle = dvb_encode_rle2;
else
dvb_encode_rle = dvb_encode_rle4;
top_ptr = q;
dvb_encode_rle(&q, h->rects[object_id]->pict.data[0], h->rects[object_id]->w * 2,
h->rects[object_id]->w, h->rects[object_id]->h >> 1);
bottom_ptr = q;
dvb_encode_rle(&q, h->rects[object_id]->pict.data[0] + h->rects[object_id]->w,
h->rects[object_id]->w * 2, h->rects[object_id]->w,
h->rects[object_id]->h >> 1);
bytestream_put_be16(&ptop_field_len, bottom_ptr - top_ptr);
bytestream_put_be16(&pbottom_field_len, q - bottom_ptr);
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
}
/* end of display set segment */
*q++ = 0x0f; /* sync_byte */
*q++ = 0x80; /* segment_type */
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2; /* segment length */
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
*q++ = 0xff; /* end of PES data */
s->object_version = (s->object_version + 1) & 0xf;
s->hide_state = !s->hide_state;
return q - outbuf;
}
| false | FFmpeg | f929ab0569ff31ed5a59b0b0adb7ce09df3fca39 | static int encode_dvb_subtitles(DVBSubtitleContext *s,
uint8_t *outbuf, const AVSubtitle *h)
{
uint8_t *q, *pseg_len;
int page_id, region_id, clut_id, object_id, i, bpp_index, page_state;
q = outbuf;
page_id = 1;
if (h->num_rects == 0 || h->rects == NULL)
return -1;
*q++ = 0x00;
*q++ = 0x0f;
*q++ = 0x10;
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2;
*q++ = 30;
if (s->hide_state)
page_state = 0;
else
page_state = 2;
*q++ = (s->object_version << 4) | (page_state << 2) | 3;
for (region_id = 0; region_id < h->num_rects; region_id++) {
*q++ = region_id;
*q++ = 0xff;
bytestream_put_be16(&q, h->rects[region_id]->x);
bytestream_put_be16(&q, h->rects[region_id]->y);
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
if (!s->hide_state) {
for (clut_id = 0; clut_id < h->num_rects; clut_id++) {
if (h->rects[clut_id]->nb_colors <= 4) {
bpp_index = 0;
} else if (h->rects[clut_id]->nb_colors <= 16) {
bpp_index = 1;
} else {
return -1;
}
*q++ = 0x0f;
*q++ = 0x12;
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2;
*q++ = clut_id;
*q++ = (0 << 4) | 0xf;
for(i = 0; i < h->rects[clut_id]->nb_colors; i++) {
*q++ = i;
*q++ = (1 << (7 - bpp_index)) | (0xf << 1) | 1;
{
int a, r, g, b;
uint32_t x= ((uint32_t*)h->rects[clut_id]->pict.data[1])[i];
a = (x >> 24) & 0xff;
r = (x >> 16) & 0xff;
g = (x >> 8) & 0xff;
b = (x >> 0) & 0xff;
*q++ = RGB_TO_Y_CCIR(r, g, b);
*q++ = RGB_TO_V_CCIR(r, g, b, 0);
*q++ = RGB_TO_U_CCIR(r, g, b, 0);
*q++ = 255 - a;
}
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
}
for (region_id = 0; region_id < h->num_rects; region_id++) {
if (h->rects[region_id]->nb_colors <= 4) {
bpp_index = 0;
} else if (h->rects[region_id]->nb_colors <= 16) {
bpp_index = 1;
} else {
return -1;
}
*q++ = 0x0f;
*q++ = 0x11;
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2;
*q++ = region_id;
*q++ = (s->object_version << 4) | (0 << 3) | 0x07;
bytestream_put_be16(&q, h->rects[region_id]->w);
bytestream_put_be16(&q, h->rects[region_id]->h);
*q++ = ((1 + bpp_index) << 5) | ((1 + bpp_index) << 2) | 0x03;
*q++ = region_id;
*q++ = 0;
*q++ = 0x03;
if (!s->hide_state) {
bytestream_put_be16(&q, region_id);
*q++ = (0 << 6) | (0 << 4);
*q++ = 0;
*q++ = 0xf0;
*q++ = 0;
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
if (!s->hide_state) {
for (object_id = 0; object_id < h->num_rects; object_id++) {
if (h->rects[object_id]->nb_colors <= 4) {
bpp_index = 0;
} else if (h->rects[object_id]->nb_colors <= 16) {
bpp_index = 1;
} else {
return -1;
}
*q++ = 0x0f;
*q++ = 0x13;
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2;
bytestream_put_be16(&q, object_id);
*q++ = (s->object_version << 4) | (0 << 2) | (0 << 1) | 1;
{
uint8_t *ptop_field_len, *pbottom_field_len, *top_ptr, *bottom_ptr;
void (*dvb_encode_rle)(uint8_t **pq,
const uint8_t *bitmap, int linesize,
int w, int h);
ptop_field_len = q;
q += 2;
pbottom_field_len = q;
q += 2;
if (bpp_index == 0)
dvb_encode_rle = dvb_encode_rle2;
else
dvb_encode_rle = dvb_encode_rle4;
top_ptr = q;
dvb_encode_rle(&q, h->rects[object_id]->pict.data[0], h->rects[object_id]->w * 2,
h->rects[object_id]->w, h->rects[object_id]->h >> 1);
bottom_ptr = q;
dvb_encode_rle(&q, h->rects[object_id]->pict.data[0] + h->rects[object_id]->w,
h->rects[object_id]->w * 2, h->rects[object_id]->w,
h->rects[object_id]->h >> 1);
bytestream_put_be16(&ptop_field_len, bottom_ptr - top_ptr);
bytestream_put_be16(&pbottom_field_len, q - bottom_ptr);
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
}
*q++ = 0x0f;
*q++ = 0x80;
bytestream_put_be16(&q, page_id);
pseg_len = q;
q += 2;
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
*q++ = 0xff;
s->object_version = (s->object_version + 1) & 0xf;
s->hide_state = !s->hide_state;
return q - outbuf;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(DVBSubtitleContext *VAR_0,
uint8_t *VAR_1, const AVSubtitle *VAR_2)
{
uint8_t *q, *pseg_len;
int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;
q = VAR_1;
VAR_3 = 1;
if (VAR_2->num_rects == 0 || VAR_2->rects == NULL)
return -1;
*q++ = 0x00;
*q++ = 0x0f;
*q++ = 0x10;
bytestream_put_be16(&q, VAR_3);
pseg_len = q;
q += 2;
*q++ = 30;
if (VAR_0->hide_state)
VAR_9 = 0;
else
VAR_9 = 2;
*q++ = (VAR_0->object_version << 4) | (VAR_9 << 2) | 3;
for (VAR_4 = 0; VAR_4 < VAR_2->num_rects; VAR_4++) {
*q++ = VAR_4;
*q++ = 0xff;
bytestream_put_be16(&q, VAR_2->rects[VAR_4]->x);
bytestream_put_be16(&q, VAR_2->rects[VAR_4]->y);
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
if (!VAR_0->hide_state) {
for (VAR_5 = 0; VAR_5 < VAR_2->num_rects; VAR_5++) {
if (VAR_2->rects[VAR_5]->nb_colors <= 4) {
VAR_8 = 0;
} else if (VAR_2->rects[VAR_5]->nb_colors <= 16) {
VAR_8 = 1;
} else {
return -1;
}
*q++ = 0x0f;
*q++ = 0x12;
bytestream_put_be16(&q, VAR_3);
pseg_len = q;
q += 2;
*q++ = VAR_5;
*q++ = (0 << 4) | 0xf;
for(VAR_7 = 0; VAR_7 < VAR_2->rects[VAR_5]->nb_colors; VAR_7++) {
*q++ = VAR_7;
*q++ = (1 << (7 - VAR_8)) | (0xf << 1) | 1;
{
int a, r, g, b;
uint32_t x= ((uint32_t*)VAR_2->rects[VAR_5]->pict.data[1])[VAR_7];
a = (x >> 24) & 0xff;
r = (x >> 16) & 0xff;
g = (x >> 8) & 0xff;
b = (x >> 0) & 0xff;
*q++ = RGB_TO_Y_CCIR(r, g, b);
*q++ = RGB_TO_V_CCIR(r, g, b, 0);
*q++ = RGB_TO_U_CCIR(r, g, b, 0);
*q++ = 255 - a;
}
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
}
for (VAR_4 = 0; VAR_4 < VAR_2->num_rects; VAR_4++) {
if (VAR_2->rects[VAR_4]->nb_colors <= 4) {
VAR_8 = 0;
} else if (VAR_2->rects[VAR_4]->nb_colors <= 16) {
VAR_8 = 1;
} else {
return -1;
}
*q++ = 0x0f;
*q++ = 0x11;
bytestream_put_be16(&q, VAR_3);
pseg_len = q;
q += 2;
*q++ = VAR_4;
*q++ = (VAR_0->object_version << 4) | (0 << 3) | 0x07;
bytestream_put_be16(&q, VAR_2->rects[VAR_4]->w);
bytestream_put_be16(&q, VAR_2->rects[VAR_4]->VAR_2);
*q++ = ((1 + VAR_8) << 5) | ((1 + VAR_8) << 2) | 0x03;
*q++ = VAR_4;
*q++ = 0;
*q++ = 0x03;
if (!VAR_0->hide_state) {
bytestream_put_be16(&q, VAR_4);
*q++ = (0 << 6) | (0 << 4);
*q++ = 0;
*q++ = 0xf0;
*q++ = 0;
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
if (!VAR_0->hide_state) {
for (VAR_6 = 0; VAR_6 < VAR_2->num_rects; VAR_6++) {
if (VAR_2->rects[VAR_6]->nb_colors <= 4) {
VAR_8 = 0;
} else if (VAR_2->rects[VAR_6]->nb_colors <= 16) {
VAR_8 = 1;
} else {
return -1;
}
*q++ = 0x0f;
*q++ = 0x13;
bytestream_put_be16(&q, VAR_3);
pseg_len = q;
q += 2;
bytestream_put_be16(&q, VAR_6);
*q++ = (VAR_0->object_version << 4) | (0 << 2) | (0 << 1) | 1;
{
uint8_t *ptop_field_len, *pbottom_field_len, *top_ptr, *bottom_ptr;
void (*dvb_encode_rle)(uint8_t **pq,
const uint8_t *bitmap, int linesize,
int w, int VAR_2);
ptop_field_len = q;
q += 2;
pbottom_field_len = q;
q += 2;
if (VAR_8 == 0)
dvb_encode_rle = dvb_encode_rle2;
else
dvb_encode_rle = dvb_encode_rle4;
top_ptr = q;
dvb_encode_rle(&q, VAR_2->rects[VAR_6]->pict.data[0], VAR_2->rects[VAR_6]->w * 2,
VAR_2->rects[VAR_6]->w, VAR_2->rects[VAR_6]->VAR_2 >> 1);
bottom_ptr = q;
dvb_encode_rle(&q, VAR_2->rects[VAR_6]->pict.data[0] + VAR_2->rects[VAR_6]->w,
VAR_2->rects[VAR_6]->w * 2, VAR_2->rects[VAR_6]->w,
VAR_2->rects[VAR_6]->VAR_2 >> 1);
bytestream_put_be16(&ptop_field_len, bottom_ptr - top_ptr);
bytestream_put_be16(&pbottom_field_len, q - bottom_ptr);
}
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
}
}
*q++ = 0x0f;
*q++ = 0x80;
bytestream_put_be16(&q, VAR_3);
pseg_len = q;
q += 2;
bytestream_put_be16(&pseg_len, q - pseg_len - 2);
*q++ = 0xff;
VAR_0->object_version = (VAR_0->object_version + 1) & 0xf;
VAR_0->hide_state = !VAR_0->hide_state;
return q - VAR_1;
}
| [
"static int FUNC_0(DVBSubtitleContext *VAR_0,\nuint8_t *VAR_1, const AVSubtitle *VAR_2)\n{",
"uint8_t *q, *pseg_len;",
"int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;",
"q = VAR_1;",
"VAR_3 = 1;",
"if (VAR_2->num_rects == 0 || VAR_2->rects == NULL)\nreturn -1;",
"*q++ = 0x00;",
"*q++ = 0x0f;",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
23,
25
],
[
29
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49,
51
],
[
53,
55
],
[
59
],
[
63
],
[
65
... |
14,165 | int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
{
RTSPState *rt = s->priv_data;
AVStream *st = NULL;
int reordering_queue_size = rt->reordering_queue_size;
if (reordering_queue_size < 0) {
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
reordering_queue_size = 0;
else
reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
}
/* open the RTP context */
if (rtsp_st->stream_index >= 0)
st = s->streams[rtsp_st->stream_index];
if (!st)
s->ctx_flags |= AVFMTCTX_NOHEADER;
if (CONFIG_RTSP_MUXER && s->oformat) {
int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
s, st, rtsp_st->rtp_handle,
RTSP_TCP_MAX_PACKET_SIZE,
rtsp_st->stream_index);
/* Ownership of rtp_handle is passed to the rtp mux context */
rtsp_st->rtp_handle = NULL;
if (ret < 0)
return ret;
st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
} else if (rt->transport == RTSP_TRANSPORT_RAW) {
return 0; // Don't need to open any parser here
} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
rtsp_st->dynamic_protocol_context,
rtsp_st->dynamic_handler);
else if (CONFIG_RTPDEC)
rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
rtsp_st->sdp_payload_type,
reordering_queue_size);
if (!rtsp_st->transport_priv) {
return AVERROR(ENOMEM);
} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) {
if (rtsp_st->dynamic_handler) {
ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
rtsp_st->dynamic_protocol_context,
rtsp_st->dynamic_handler);
}
if (rtsp_st->crypto_suite[0])
ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
rtsp_st->crypto_suite,
rtsp_st->crypto_params);
}
return 0;
}
| false | FFmpeg | f03dfe118b6426a2348d4f8db2daa9cd506b34fb | int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
{
RTSPState *rt = s->priv_data;
AVStream *st = NULL;
int reordering_queue_size = rt->reordering_queue_size;
if (reordering_queue_size < 0) {
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
reordering_queue_size = 0;
else
reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
}
if (rtsp_st->stream_index >= 0)
st = s->streams[rtsp_st->stream_index];
if (!st)
s->ctx_flags |= AVFMTCTX_NOHEADER;
if (CONFIG_RTSP_MUXER && s->oformat) {
int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
s, st, rtsp_st->rtp_handle,
RTSP_TCP_MAX_PACKET_SIZE,
rtsp_st->stream_index);
rtsp_st->rtp_handle = NULL;
if (ret < 0)
return ret;
st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
} else if (rt->transport == RTSP_TRANSPORT_RAW) {
return 0;
} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
rtsp_st->dynamic_protocol_context,
rtsp_st->dynamic_handler);
else if (CONFIG_RTPDEC)
rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
rtsp_st->sdp_payload_type,
reordering_queue_size);
if (!rtsp_st->transport_priv) {
return AVERROR(ENOMEM);
} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) {
if (rtsp_st->dynamic_handler) {
ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
rtsp_st->dynamic_protocol_context,
rtsp_st->dynamic_handler);
}
if (rtsp_st->crypto_suite[0])
ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
rtsp_st->crypto_suite,
rtsp_st->crypto_params);
}
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(AVFormatContext *VAR_0, RTSPStream *VAR_1)
{
RTSPState *rt = VAR_0->priv_data;
AVStream *st = NULL;
int VAR_2 = rt->VAR_2;
if (VAR_2 < 0) {
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !VAR_0->max_delay)
VAR_2 = 0;
else
VAR_2 = RTP_REORDER_QUEUE_DEFAULT_SIZE;
}
if (VAR_1->stream_index >= 0)
st = VAR_0->streams[VAR_1->stream_index];
if (!st)
VAR_0->ctx_flags |= AVFMTCTX_NOHEADER;
if (CONFIG_RTSP_MUXER && VAR_0->oformat) {
int VAR_3 = ff_rtp_chain_mux_open((AVFormatContext **)&VAR_1->transport_priv,
VAR_0, st, VAR_1->rtp_handle,
RTSP_TCP_MAX_PACKET_SIZE,
VAR_1->stream_index);
VAR_1->rtp_handle = NULL;
if (VAR_3 < 0)
return VAR_3;
st->time_base = ((AVFormatContext*)VAR_1->transport_priv)->streams[0]->time_base;
} else if (rt->transport == RTSP_TRANSPORT_RAW) {
return 0;
} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
VAR_1->transport_priv = ff_rdt_parse_open(VAR_0, st->index,
VAR_1->dynamic_protocol_context,
VAR_1->dynamic_handler);
else if (CONFIG_RTPDEC)
VAR_1->transport_priv = ff_rtp_parse_open(VAR_0, st,
VAR_1->sdp_payload_type,
VAR_2);
if (!VAR_1->transport_priv) {
return AVERROR(ENOMEM);
} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP) {
if (VAR_1->dynamic_handler) {
ff_rtp_parse_set_dynamic_protocol(VAR_1->transport_priv,
VAR_1->dynamic_protocol_context,
VAR_1->dynamic_handler);
}
if (VAR_1->crypto_suite[0])
ff_rtp_parse_set_crypto(VAR_1->transport_priv,
VAR_1->crypto_suite,
VAR_1->crypto_params);
}
return 0;
}
| [
"int FUNC_0(AVFormatContext *VAR_0, RTSPStream *VAR_1)\n{",
"RTSPState *rt = VAR_0->priv_data;",
"AVStream *st = NULL;",
"int VAR_2 = rt->VAR_2;",
"if (VAR_2 < 0) {",
"if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !VAR_0->max_delay)\nVAR_2 = 0;",
"else\nVAR_2 = RTP_REORDER_QUEUE_DEFAULT_SIZE;",... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17,
19
],
[
21
],
[
27,
29
],
[
31,
33
],
[
37
],
[
39,
41,
43,
45
],
[
49
],
[
51,
53
],
[
55
],
[
57
... |
14,166 | int ff_h264_set_parameter_from_sps(H264Context *h)
{
if (h->flags & CODEC_FLAG_LOW_DELAY ||
(h->sps.bitstream_restriction_flag &&
!h->sps.num_reorder_frames)) {
if (h->avctx->has_b_frames > 1 || h->delayed_pic[0])
av_log(h->avctx, AV_LOG_WARNING, "Delayed frames seen. "
"Reenabling low delay requires a codec flush.\n");
else
h->low_delay = 1;
}
if (h->avctx->has_b_frames < 2)
h->avctx->has_b_frames = !h->low_delay;
if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
h->cur_chroma_format_idc = h->sps.chroma_format_idc;
h->pixel_shift = h->sps.bit_depth_luma > 8;
ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);
ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
if (CONFIG_ERROR_RESILIENCE)
ff_me_cmp_init(&h->mecc, h->avctx);
ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);
} else {
av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
h->sps.bit_depth_luma);
return AVERROR_INVALIDDATA;
}
}
return 0;
}
| false | FFmpeg | cf1e0786ed64e69614760bfb4ecd7adbde8e6094 | int ff_h264_set_parameter_from_sps(H264Context *h)
{
if (h->flags & CODEC_FLAG_LOW_DELAY ||
(h->sps.bitstream_restriction_flag &&
!h->sps.num_reorder_frames)) {
if (h->avctx->has_b_frames > 1 || h->delayed_pic[0])
av_log(h->avctx, AV_LOG_WARNING, "Delayed frames seen. "
"Reenabling low delay requires a codec flush.\n");
else
h->low_delay = 1;
}
if (h->avctx->has_b_frames < 2)
h->avctx->has_b_frames = !h->low_delay;
if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
h->cur_chroma_format_idc = h->sps.chroma_format_idc;
h->pixel_shift = h->sps.bit_depth_luma > 8;
ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);
ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
if (CONFIG_ERROR_RESILIENCE)
ff_me_cmp_init(&h->mecc, h->avctx);
ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);
} else {
av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
h->sps.bit_depth_luma);
return AVERROR_INVALIDDATA;
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(H264Context *VAR_0)
{
if (VAR_0->flags & CODEC_FLAG_LOW_DELAY ||
(VAR_0->sps.bitstream_restriction_flag &&
!VAR_0->sps.num_reorder_frames)) {
if (VAR_0->avctx->has_b_frames > 1 || VAR_0->delayed_pic[0])
av_log(VAR_0->avctx, AV_LOG_WARNING, "Delayed frames seen. "
"Reenabling low delay requires a codec flush.\n");
else
VAR_0->low_delay = 1;
}
if (VAR_0->avctx->has_b_frames < 2)
VAR_0->avctx->has_b_frames = !VAR_0->low_delay;
if (VAR_0->avctx->bits_per_raw_sample != VAR_0->sps.bit_depth_luma ||
VAR_0->cur_chroma_format_idc != VAR_0->sps.chroma_format_idc) {
if (VAR_0->sps.bit_depth_luma >= 8 && VAR_0->sps.bit_depth_luma <= 10) {
VAR_0->avctx->bits_per_raw_sample = VAR_0->sps.bit_depth_luma;
VAR_0->cur_chroma_format_idc = VAR_0->sps.chroma_format_idc;
VAR_0->pixel_shift = VAR_0->sps.bit_depth_luma > 8;
ff_h264dsp_init(&VAR_0->h264dsp, VAR_0->sps.bit_depth_luma,
VAR_0->sps.chroma_format_idc);
ff_h264chroma_init(&VAR_0->h264chroma, VAR_0->sps.bit_depth_chroma);
ff_h264qpel_init(&VAR_0->h264qpel, VAR_0->sps.bit_depth_luma);
ff_h264_pred_init(&VAR_0->hpc, VAR_0->avctx->codec_id, VAR_0->sps.bit_depth_luma,
VAR_0->sps.chroma_format_idc);
if (CONFIG_ERROR_RESILIENCE)
ff_me_cmp_init(&VAR_0->mecc, VAR_0->avctx);
ff_videodsp_init(&VAR_0->vdsp, VAR_0->sps.bit_depth_luma);
} else {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
VAR_0->sps.bit_depth_luma);
return AVERROR_INVALIDDATA;
}
}
return 0;
}
| [
"int FUNC_0(H264Context *VAR_0)\n{",
"if (VAR_0->flags & CODEC_FLAG_LOW_DELAY ||\n(VAR_0->sps.bitstream_restriction_flag &&\n!VAR_0->sps.num_reorder_frames)) {",
"if (VAR_0->avctx->has_b_frames > 1 || VAR_0->delayed_pic[0])\nav_log(VAR_0->avctx, AV_LOG_WARNING, \"Delayed frames seen. \"\n\"Reenabling low delay ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7,
9
],
[
11,
13,
15
],
[
17,
19
],
[
21
],
[
25,
27
],
[
31,
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45,
47
],
[
49
],
[
51
],
[
53,
55
],
[... |
14,167 | void ff_weight_h264_pixels4_8_msa(uint8_t *src, int stride,
int height, int log2_denom,
int weight_src, int offset)
{
avc_wgt_4width_msa(src, stride,
height, log2_denom, weight_src, offset);
}
| false | FFmpeg | bcd7bf7eeb09a395cc01698842d1b8be9af483fc | void ff_weight_h264_pixels4_8_msa(uint8_t *src, int stride,
int height, int log2_denom,
int weight_src, int offset)
{
avc_wgt_4width_msa(src, stride,
height, log2_denom, weight_src, offset);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, int VAR_1,
int VAR_2, int VAR_3,
int VAR_4, int VAR_5)
{
avc_wgt_4width_msa(VAR_0, VAR_1,
VAR_2, VAR_3, VAR_4, VAR_5);
}
| [
"void FUNC_0(uint8_t *VAR_0, int VAR_1,\nint VAR_2, int VAR_3,\nint VAR_4, int VAR_5)\n{",
"avc_wgt_4width_msa(VAR_0, VAR_1,\nVAR_2, VAR_3, VAR_4, VAR_5);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9,
11
],
[
13
]
] |
14,169 | static av_cold int vaapi_encode_h265_init_constant_bitrate(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = ctx->priv_data;
int hrd_buffer_size;
int hrd_initial_buffer_fullness;
if (avctx->bit_rate > INT32_MAX) {
av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
"higher is not supported.\n");
return AVERROR(EINVAL);
}
if (avctx->rc_buffer_size)
hrd_buffer_size = avctx->rc_buffer_size;
else
hrd_buffer_size = avctx->bit_rate;
if (avctx->rc_initial_buffer_occupancy)
hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
else
hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
priv->rc_params.rc = (VAEncMiscParameterRateControl) {
.bits_per_second = avctx->bit_rate,
.target_percentage = 66,
.window_size = 1000,
.initial_qp = (avctx->qmax >= 0 ? avctx->qmax : 40),
.min_qp = (avctx->qmin >= 0 ? avctx->qmin : 20),
.basic_unit_size = 0,
};
ctx->global_params[ctx->nb_global_params] =
&priv->rc_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->rc_params);
priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
.initial_buffer_fullness = hrd_initial_buffer_fullness,
.buffer_size = hrd_buffer_size,
};
ctx->global_params[ctx->nb_global_params] =
&priv->hrd_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->hrd_params);
// These still need to be set for pic_init_qp/slice_qp_delta.
priv->fixed_qp_idr = 30;
priv->fixed_qp_p = 30;
priv->fixed_qp_b = 30;
av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
avctx->bit_rate);
return 0;
}
| false | FFmpeg | c8241e730f116f1c9cfc0b34110aa7f052e05332 | static av_cold int vaapi_encode_h265_init_constant_bitrate(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = ctx->priv_data;
int hrd_buffer_size;
int hrd_initial_buffer_fullness;
if (avctx->bit_rate > INT32_MAX) {
av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
"higher is not supported.\n");
return AVERROR(EINVAL);
}
if (avctx->rc_buffer_size)
hrd_buffer_size = avctx->rc_buffer_size;
else
hrd_buffer_size = avctx->bit_rate;
if (avctx->rc_initial_buffer_occupancy)
hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
else
hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
priv->rc_params.rc = (VAEncMiscParameterRateControl) {
.bits_per_second = avctx->bit_rate,
.target_percentage = 66,
.window_size = 1000,
.initial_qp = (avctx->qmax >= 0 ? avctx->qmax : 40),
.min_qp = (avctx->qmin >= 0 ? avctx->qmin : 20),
.basic_unit_size = 0,
};
ctx->global_params[ctx->nb_global_params] =
&priv->rc_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->rc_params);
priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
.initial_buffer_fullness = hrd_initial_buffer_fullness,
.buffer_size = hrd_buffer_size,
};
ctx->global_params[ctx->nb_global_params] =
&priv->hrd_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->hrd_params);
priv->fixed_qp_idr = 30;
priv->fixed_qp_p = 30;
priv->fixed_qp_b = 30;
av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
avctx->bit_rate);
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = ctx->priv_data;
int VAR_0;
int VAR_1;
if (avctx->bit_rate > INT32_MAX) {
av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
"higher is not supported.\n");
return AVERROR(EINVAL);
}
if (avctx->rc_buffer_size)
VAR_0 = avctx->rc_buffer_size;
else
VAR_0 = avctx->bit_rate;
if (avctx->rc_initial_buffer_occupancy)
VAR_1 = avctx->rc_initial_buffer_occupancy;
else
VAR_1 = VAR_0 * 3 / 4;
priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
priv->rc_params.rc = (VAEncMiscParameterRateControl) {
.bits_per_second = avctx->bit_rate,
.target_percentage = 66,
.window_size = 1000,
.initial_qp = (avctx->qmax >= 0 ? avctx->qmax : 40),
.min_qp = (avctx->qmin >= 0 ? avctx->qmin : 20),
.basic_unit_size = 0,
};
ctx->global_params[ctx->nb_global_params] =
&priv->rc_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->rc_params);
priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
.initial_buffer_fullness = VAR_1,
.buffer_size = VAR_0,
};
ctx->global_params[ctx->nb_global_params] =
&priv->hrd_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->hrd_params);
priv->fixed_qp_idr = 30;
priv->fixed_qp_p = 30;
priv->fixed_qp_b = 30;
av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
avctx->bit_rate);
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"VAAPIEncodeContext *ctx = avctx->priv_data;",
"VAAPIEncodeH265Context *priv = ctx->priv_data;",
"int VAR_0;",
"int VAR_1;",
"if (avctx->bit_rate > INT32_MAX) {",
"av_log(avctx, AV_LOG_ERROR, \"Target bitrate of 2^31 bps or \"\n\"higher is not ... | [
0,
0,
0,
0,
0,
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
],
[
27,
29
],
[
31,
33
],
[
35,
37
],
[
39,
41
],
[
45
],
[
47
],
[
49,
51,
53,
55,... |
14,170 | static int filter_query_formats(AVFilterContext *ctx)
{
int ret, i;
AVFilterFormats *formats;
AVFilterChannelLayouts *chlayouts;
AVFilterFormats *samplerates;
enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
AVMEDIA_TYPE_VIDEO;
if ((ret = ctx->filter->query_formats(ctx)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
ctx->name, av_err2str(ret));
return ret;
}
for (i = 0; i < ctx->nb_inputs; i++)
sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);
for (i = 0; i < ctx->nb_outputs; i++)
sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);
formats = ff_all_formats(type);
if (!formats)
return AVERROR(ENOMEM);
ff_set_common_formats(ctx, formats);
if (type == AVMEDIA_TYPE_AUDIO) {
samplerates = ff_all_samplerates();
if (!samplerates)
return AVERROR(ENOMEM);
ff_set_common_samplerates(ctx, samplerates);
chlayouts = ff_all_channel_layouts();
if (!chlayouts)
return AVERROR(ENOMEM);
ff_set_common_channel_layouts(ctx, chlayouts);
}
return 0;
}
| false | FFmpeg | 125acd215250ead008938266efcacd56743f3a2a | static int filter_query_formats(AVFilterContext *ctx)
{
int ret, i;
AVFilterFormats *formats;
AVFilterChannelLayouts *chlayouts;
AVFilterFormats *samplerates;
enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
AVMEDIA_TYPE_VIDEO;
if ((ret = ctx->filter->query_formats(ctx)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
ctx->name, av_err2str(ret));
return ret;
}
for (i = 0; i < ctx->nb_inputs; i++)
sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);
for (i = 0; i < ctx->nb_outputs; i++)
sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);
formats = ff_all_formats(type);
if (!formats)
return AVERROR(ENOMEM);
ff_set_common_formats(ctx, formats);
if (type == AVMEDIA_TYPE_AUDIO) {
samplerates = ff_all_samplerates();
if (!samplerates)
return AVERROR(ENOMEM);
ff_set_common_samplerates(ctx, samplerates);
chlayouts = ff_all_channel_layouts();
if (!chlayouts)
return AVERROR(ENOMEM);
ff_set_common_channel_layouts(ctx, chlayouts);
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFilterContext *VAR_0)
{
int VAR_1, VAR_2;
AVFilterFormats *formats;
AVFilterChannelLayouts *chlayouts;
AVFilterFormats *samplerates;
enum AVMediaType VAR_3 = VAR_0->inputs && VAR_0->inputs [0] ? VAR_0->inputs [0]->VAR_3 :
VAR_0->outputs && VAR_0->outputs[0] ? VAR_0->outputs[0]->VAR_3 :
AVMEDIA_TYPE_VIDEO;
if ((VAR_1 = VAR_0->filter->query_formats(VAR_0)) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
VAR_0->name, av_err2str(VAR_1));
return VAR_1;
}
for (VAR_2 = 0; VAR_2 < VAR_0->nb_inputs; VAR_2++)
sanitize_channel_layouts(VAR_0, VAR_0->inputs[VAR_2]->out_channel_layouts);
for (VAR_2 = 0; VAR_2 < VAR_0->nb_outputs; VAR_2++)
sanitize_channel_layouts(VAR_0, VAR_0->outputs[VAR_2]->in_channel_layouts);
formats = ff_all_formats(VAR_3);
if (!formats)
return AVERROR(ENOMEM);
ff_set_common_formats(VAR_0, formats);
if (VAR_3 == AVMEDIA_TYPE_AUDIO) {
samplerates = ff_all_samplerates();
if (!samplerates)
return AVERROR(ENOMEM);
ff_set_common_samplerates(VAR_0, samplerates);
chlayouts = ff_all_channel_layouts();
if (!chlayouts)
return AVERROR(ENOMEM);
ff_set_common_channel_layouts(VAR_0, chlayouts);
}
return 0;
}
| [
"static int FUNC_0(AVFilterContext *VAR_0)\n{",
"int VAR_1, VAR_2;",
"AVFilterFormats *formats;",
"AVFilterChannelLayouts *chlayouts;",
"AVFilterFormats *samplerates;",
"enum AVMediaType VAR_3 = VAR_0->inputs && VAR_0->inputs [0] ? VAR_0->inputs [0]->VAR_3 :\nVAR_0->outputs && VAR_0->outputs[0] ? 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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15,
17
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45,
47
],
[
49
],
[
51
... |
14,171 | static int coroutine_fn sd_co_rw_vector(void *p)
{
SheepdogAIOCB *acb = p;
int ret = 0;
unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;
unsigned long idx = acb->sector_num * BDRV_SECTOR_SIZE / SD_DATA_OBJ_SIZE;
uint64_t oid;
uint64_t offset = (acb->sector_num * BDRV_SECTOR_SIZE) % SD_DATA_OBJ_SIZE;
BDRVSheepdogState *s = acb->common.bs->opaque;
SheepdogInode *inode = &s->inode;
AIOReq *aio_req;
if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
/*
* In the case we open the snapshot VDI, Sheepdog creates the
* writable VDI when we do a write operation first.
*/
ret = sd_create_branch(s);
if (ret) {
acb->ret = -EIO;
goto out;
}
}
/*
* Make sure we don't free the aiocb before we are done with all requests.
* This additional reference is dropped at the end of this function.
*/
acb->nr_pending++;
while (done != total) {
uint8_t flags = 0;
uint64_t old_oid = 0;
bool create = false;
oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
len = MIN(total - done, SD_DATA_OBJ_SIZE - offset);
switch (acb->aiocb_type) {
case AIOCB_READ_UDATA:
if (!inode->data_vdi_id[idx]) {
qemu_iovec_memset(acb->qiov, done, 0, len);
goto done;
}
break;
case AIOCB_WRITE_UDATA:
if (!inode->data_vdi_id[idx]) {
create = true;
} else if (!is_data_obj_writable(inode, idx)) {
/* Copy-On-Write */
create = true;
old_oid = oid;
flags = SD_FLAG_CMD_COW;
}
break;
case AIOCB_DISCARD_OBJ:
/*
* We discard the object only when the whole object is
* 1) allocated 2) trimmed. Otherwise, simply skip it.
*/
if (len != SD_DATA_OBJ_SIZE || inode->data_vdi_id[idx] == 0) {
goto done;
}
break;
default:
break;
}
if (create) {
DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
inode->vdi_id, oid,
vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
oid = vid_to_data_oid(inode->vdi_id, idx);
DPRINTF("new oid %" PRIx64 "\n", oid);
}
aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
if (create) {
AIOReq *areq;
QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {
if (areq->oid == oid) {
/*
* Sheepdog cannot handle simultaneous create
* requests to the same object. So we cannot send
* the request until the previous request
* finishes.
*/
aio_req->flags = 0;
aio_req->base_oid = 0;
QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req,
aio_siblings);
goto done;
}
}
}
QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, create,
acb->aiocb_type);
done:
offset = 0;
idx++;
done += len;
}
out:
if (!--acb->nr_pending) {
return acb->ret;
}
return 1;
}
| true | qemu | 80308d33ec70834a80351a79eba106049b44a366 | static int coroutine_fn sd_co_rw_vector(void *p)
{
SheepdogAIOCB *acb = p;
int ret = 0;
unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;
unsigned long idx = acb->sector_num * BDRV_SECTOR_SIZE / SD_DATA_OBJ_SIZE;
uint64_t oid;
uint64_t offset = (acb->sector_num * BDRV_SECTOR_SIZE) % SD_DATA_OBJ_SIZE;
BDRVSheepdogState *s = acb->common.bs->opaque;
SheepdogInode *inode = &s->inode;
AIOReq *aio_req;
if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
ret = sd_create_branch(s);
if (ret) {
acb->ret = -EIO;
goto out;
}
}
acb->nr_pending++;
while (done != total) {
uint8_t flags = 0;
uint64_t old_oid = 0;
bool create = false;
oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
len = MIN(total - done, SD_DATA_OBJ_SIZE - offset);
switch (acb->aiocb_type) {
case AIOCB_READ_UDATA:
if (!inode->data_vdi_id[idx]) {
qemu_iovec_memset(acb->qiov, done, 0, len);
goto done;
}
break;
case AIOCB_WRITE_UDATA:
if (!inode->data_vdi_id[idx]) {
create = true;
} else if (!is_data_obj_writable(inode, idx)) {
create = true;
old_oid = oid;
flags = SD_FLAG_CMD_COW;
}
break;
case AIOCB_DISCARD_OBJ:
if (len != SD_DATA_OBJ_SIZE || inode->data_vdi_id[idx] == 0) {
goto done;
}
break;
default:
break;
}
if (create) {
DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
inode->vdi_id, oid,
vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
oid = vid_to_data_oid(inode->vdi_id, idx);
DPRINTF("new oid %" PRIx64 "\n", oid);
}
aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
if (create) {
AIOReq *areq;
QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {
if (areq->oid == oid) {
aio_req->flags = 0;
aio_req->base_oid = 0;
QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req,
aio_siblings);
goto done;
}
}
}
QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, create,
acb->aiocb_type);
done:
offset = 0;
idx++;
done += len;
}
out:
if (!--acb->nr_pending) {
return acb->ret;
}
return 1;
}
| {
"code": [
" goto out;",
" AIOReq *areq;",
" QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {",
" if (areq->oid == oid) {",
" aio_req->flags = 0;",
" aio_req->base_oid = 0;",
" QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req,",
" aio_siblings);",
" goto done;",
" QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);"
],
"line_no": [
41,
161,
163,
165,
179,
181,
183,
185,
187,
197
]
} | static int VAR_0 sd_co_rw_vector(void *p)
{
SheepdogAIOCB *acb = p;
int ret = 0;
unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;
unsigned long idx = acb->sector_num * BDRV_SECTOR_SIZE / SD_DATA_OBJ_SIZE;
uint64_t oid;
uint64_t offset = (acb->sector_num * BDRV_SECTOR_SIZE) % SD_DATA_OBJ_SIZE;
BDRVSheepdogState *s = acb->common.bs->opaque;
SheepdogInode *inode = &s->inode;
AIOReq *aio_req;
if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
ret = sd_create_branch(s);
if (ret) {
acb->ret = -EIO;
goto out;
}
}
acb->nr_pending++;
while (done != total) {
uint8_t flags = 0;
uint64_t old_oid = 0;
bool create = false;
oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
len = MIN(total - done, SD_DATA_OBJ_SIZE - offset);
switch (acb->aiocb_type) {
case AIOCB_READ_UDATA:
if (!inode->data_vdi_id[idx]) {
qemu_iovec_memset(acb->qiov, done, 0, len);
goto done;
}
break;
case AIOCB_WRITE_UDATA:
if (!inode->data_vdi_id[idx]) {
create = true;
} else if (!is_data_obj_writable(inode, idx)) {
create = true;
old_oid = oid;
flags = SD_FLAG_CMD_COW;
}
break;
case AIOCB_DISCARD_OBJ:
if (len != SD_DATA_OBJ_SIZE || inode->data_vdi_id[idx] == 0) {
goto done;
}
break;
default:
break;
}
if (create) {
DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
inode->vdi_id, oid,
vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
oid = vid_to_data_oid(inode->vdi_id, idx);
DPRINTF("new oid %" PRIx64 "\n", oid);
}
aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
if (create) {
AIOReq *areq;
QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {
if (areq->oid == oid) {
aio_req->flags = 0;
aio_req->base_oid = 0;
QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req,
aio_siblings);
goto done;
}
}
}
QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, create,
acb->aiocb_type);
done:
offset = 0;
idx++;
done += len;
}
out:
if (!--acb->nr_pending) {
return acb->ret;
}
return 1;
}
| [
"static int VAR_0 sd_co_rw_vector(void *p)\n{",
"SheepdogAIOCB *acb = p;",
"int ret = 0;",
"unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;",
"unsigned long idx = acb->sector_num * BDRV_SECTOR_SIZE / SD_DATA_OBJ_SIZE;",
"uint64_t oid;",
"uint64_t offset = (acb->sector_num * BDRV... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
57
],
[
61
],
[
63
... |
14,173 | static qemu_irq *ppce500_init_mpic(MachineState *machine, PPCE500Params *params,
MemoryRegion *ccsr, qemu_irq **irqs)
{
qemu_irq *mpic;
DeviceState *dev = NULL;
SysBusDevice *s;
int i;
mpic = g_new0(qemu_irq, 256);
if (kvm_enabled()) {
Error *err = NULL;
if (machine_kernel_irqchip_allowed(machine)) {
dev = ppce500_init_mpic_kvm(params, irqs, &err);
}
if (machine_kernel_irqchip_required(machine) && !dev) {
error_reportf_err(err,
"kernel_irqchip requested but unavailable: ");
exit(1);
}
}
if (!dev) {
dev = ppce500_init_mpic_qemu(params, irqs);
}
for (i = 0; i < 256; i++) {
mpic[i] = qdev_get_gpio_in(dev, i);
}
s = SYS_BUS_DEVICE(dev);
memory_region_add_subregion(ccsr, MPC8544_MPIC_REGS_OFFSET,
s->mmio[0].memory);
return mpic;
}
| true | qemu | c91c187f715aded9e1ac28412bba41fd3cbaf010 | static qemu_irq *ppce500_init_mpic(MachineState *machine, PPCE500Params *params,
MemoryRegion *ccsr, qemu_irq **irqs)
{
qemu_irq *mpic;
DeviceState *dev = NULL;
SysBusDevice *s;
int i;
mpic = g_new0(qemu_irq, 256);
if (kvm_enabled()) {
Error *err = NULL;
if (machine_kernel_irqchip_allowed(machine)) {
dev = ppce500_init_mpic_kvm(params, irqs, &err);
}
if (machine_kernel_irqchip_required(machine) && !dev) {
error_reportf_err(err,
"kernel_irqchip requested but unavailable: ");
exit(1);
}
}
if (!dev) {
dev = ppce500_init_mpic_qemu(params, irqs);
}
for (i = 0; i < 256; i++) {
mpic[i] = qdev_get_gpio_in(dev, i);
}
s = SYS_BUS_DEVICE(dev);
memory_region_add_subregion(ccsr, MPC8544_MPIC_REGS_OFFSET,
s->mmio[0].memory);
return mpic;
}
| {
"code": [
"static qemu_irq *ppce500_init_mpic(MachineState *machine, PPCE500Params *params,",
" MemoryRegion *ccsr, qemu_irq **irqs)",
" qemu_irq *mpic;",
" int i;",
" mpic = g_new0(qemu_irq, 256);",
" for (i = 0; i < 256; i++) {",
" mpic[i] = qdev_get_gpio_in(dev, i);",
" return mpic;"
],
"line_no": [
1,
3,
7,
13,
17,
55,
57,
71
]
} | static qemu_irq *FUNC_0(MachineState *machine, PPCE500Params *params,
MemoryRegion *ccsr, qemu_irq **irqs)
{
qemu_irq *mpic;
DeviceState *dev = NULL;
SysBusDevice *s;
int VAR_0;
mpic = g_new0(qemu_irq, 256);
if (kvm_enabled()) {
Error *err = NULL;
if (machine_kernel_irqchip_allowed(machine)) {
dev = ppce500_init_mpic_kvm(params, irqs, &err);
}
if (machine_kernel_irqchip_required(machine) && !dev) {
error_reportf_err(err,
"kernel_irqchip requested but unavailable: ");
exit(1);
}
}
if (!dev) {
dev = ppce500_init_mpic_qemu(params, irqs);
}
for (VAR_0 = 0; VAR_0 < 256; VAR_0++) {
mpic[VAR_0] = qdev_get_gpio_in(dev, VAR_0);
}
s = SYS_BUS_DEVICE(dev);
memory_region_add_subregion(ccsr, MPC8544_MPIC_REGS_OFFSET,
s->mmio[0].memory);
return mpic;
}
| [
"static qemu_irq *FUNC_0(MachineState *machine, PPCE500Params *params,\nMemoryRegion *ccsr, qemu_irq **irqs)\n{",
"qemu_irq *mpic;",
"DeviceState *dev = NULL;",
"SysBusDevice *s;",
"int VAR_0;",
"mpic = g_new0(qemu_irq, 256);",
"if (kvm_enabled()) {",
"Error *err = NULL;",
"if (machine_kernel_irqchi... | [
1,
1,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
... |
14,174 | static ExitStatus trans_fop_ded(DisasContext *ctx, uint32_t insn,
const DisasInsn *di)
{
unsigned rt = extract32(insn, 0, 5);
unsigned ra = extract32(insn, 21, 5);
return do_fop_ded(ctx, rt, ra, di->f_ded);
}
| true | qemu | eff235eb2bcd7092901f4698a7907e742f3b7f2f | static ExitStatus trans_fop_ded(DisasContext *ctx, uint32_t insn,
const DisasInsn *di)
{
unsigned rt = extract32(insn, 0, 5);
unsigned ra = extract32(insn, 21, 5);
return do_fop_ded(ctx, rt, ra, di->f_ded);
}
| {
"code": [
" return do_fop_ded(ctx, rt, ra, di->f_ded);"
],
"line_no": [
11
]
} | static ExitStatus FUNC_0(DisasContext *ctx, uint32_t insn,
const DisasInsn *di)
{
unsigned VAR_0 = extract32(insn, 0, 5);
unsigned VAR_1 = extract32(insn, 21, 5);
return do_fop_ded(ctx, VAR_0, VAR_1, di->f_ded);
}
| [
"static ExitStatus FUNC_0(DisasContext *ctx, uint32_t insn,\nconst DisasInsn *di)\n{",
"unsigned VAR_0 = extract32(insn, 0, 5);",
"unsigned VAR_1 = extract32(insn, 21, 5);",
"return do_fop_ded(ctx, VAR_0, VAR_1, di->f_ded);",
"}"
] | [
0,
0,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
14,175 | static void xhci_xfer_report(XHCITransfer *xfer)
{
uint32_t edtla = 0;
unsigned int left;
bool reported = 0;
bool shortpkt = 0;
XHCIEvent event = {ER_TRANSFER, CC_SUCCESS};
XHCIState *xhci = xfer->xhci;
int i;
left = xfer->packet.actual_length;
for (i = 0; i < xfer->trb_count; i++) {
XHCITRB *trb = &xfer->trbs[i];
unsigned int chunk = 0;
switch (TRB_TYPE(*trb)) {
case TR_DATA:
case TR_NORMAL:
case TR_ISOCH:
chunk = trb->status & 0x1ffff;
if (chunk > left) {
chunk = left;
if (xfer->status == CC_SUCCESS) {
shortpkt = 1;
}
}
left -= chunk;
edtla += chunk;
break;
case TR_STATUS:
reported = 0;
shortpkt = 0;
break;
}
if (!reported && ((trb->control & TRB_TR_IOC) ||
(shortpkt && (trb->control & TRB_TR_ISP)) ||
(xfer->status != CC_SUCCESS && left == 0))) {
event.slotid = xfer->slotid;
event.epid = xfer->epid;
event.length = (trb->status & 0x1ffff) - chunk;
event.flags = 0;
event.ptr = trb->addr;
if (xfer->status == CC_SUCCESS) {
event.ccode = shortpkt ? CC_SHORT_PACKET : CC_SUCCESS;
} else {
event.ccode = xfer->status;
}
if (TRB_TYPE(*trb) == TR_EVDATA) {
event.ptr = trb->parameter;
event.flags |= TRB_EV_ED;
event.length = edtla & 0xffffff;
DPRINTF("xhci_xfer_data: EDTLA=%d\n", event.length);
edtla = 0;
}
xhci_event(xhci, &event, TRB_INTR(*trb));
reported = 1;
if (xfer->status != CC_SUCCESS) {
return;
}
}
}
}
| true | qemu | aa6857891df614c620e6e9fc4bc4af6e0e49cafd | static void xhci_xfer_report(XHCITransfer *xfer)
{
uint32_t edtla = 0;
unsigned int left;
bool reported = 0;
bool shortpkt = 0;
XHCIEvent event = {ER_TRANSFER, CC_SUCCESS};
XHCIState *xhci = xfer->xhci;
int i;
left = xfer->packet.actual_length;
for (i = 0; i < xfer->trb_count; i++) {
XHCITRB *trb = &xfer->trbs[i];
unsigned int chunk = 0;
switch (TRB_TYPE(*trb)) {
case TR_DATA:
case TR_NORMAL:
case TR_ISOCH:
chunk = trb->status & 0x1ffff;
if (chunk > left) {
chunk = left;
if (xfer->status == CC_SUCCESS) {
shortpkt = 1;
}
}
left -= chunk;
edtla += chunk;
break;
case TR_STATUS:
reported = 0;
shortpkt = 0;
break;
}
if (!reported && ((trb->control & TRB_TR_IOC) ||
(shortpkt && (trb->control & TRB_TR_ISP)) ||
(xfer->status != CC_SUCCESS && left == 0))) {
event.slotid = xfer->slotid;
event.epid = xfer->epid;
event.length = (trb->status & 0x1ffff) - chunk;
event.flags = 0;
event.ptr = trb->addr;
if (xfer->status == CC_SUCCESS) {
event.ccode = shortpkt ? CC_SHORT_PACKET : CC_SUCCESS;
} else {
event.ccode = xfer->status;
}
if (TRB_TYPE(*trb) == TR_EVDATA) {
event.ptr = trb->parameter;
event.flags |= TRB_EV_ED;
event.length = edtla & 0xffffff;
DPRINTF("xhci_xfer_data: EDTLA=%d\n", event.length);
edtla = 0;
}
xhci_event(xhci, &event, TRB_INTR(*trb));
reported = 1;
if (xfer->status != CC_SUCCESS) {
return;
}
}
}
}
| {
"code": [
" if (!reported && ((trb->control & TRB_TR_IOC) ||",
" (shortpkt && (trb->control & TRB_TR_ISP)) ||",
" (xfer->status != CC_SUCCESS && left == 0))) {"
],
"line_no": [
73,
75,
77
]
} | static void FUNC_0(XHCITransfer *VAR_0)
{
uint32_t edtla = 0;
unsigned int VAR_1;
bool reported = 0;
bool shortpkt = 0;
XHCIEvent event = {ER_TRANSFER, CC_SUCCESS};
XHCIState *xhci = VAR_0->xhci;
int VAR_2;
VAR_1 = VAR_0->packet.actual_length;
for (VAR_2 = 0; VAR_2 < VAR_0->trb_count; VAR_2++) {
XHCITRB *trb = &VAR_0->trbs[VAR_2];
unsigned int chunk = 0;
switch (TRB_TYPE(*trb)) {
case TR_DATA:
case TR_NORMAL:
case TR_ISOCH:
chunk = trb->status & 0x1ffff;
if (chunk > VAR_1) {
chunk = VAR_1;
if (VAR_0->status == CC_SUCCESS) {
shortpkt = 1;
}
}
VAR_1 -= chunk;
edtla += chunk;
break;
case TR_STATUS:
reported = 0;
shortpkt = 0;
break;
}
if (!reported && ((trb->control & TRB_TR_IOC) ||
(shortpkt && (trb->control & TRB_TR_ISP)) ||
(VAR_0->status != CC_SUCCESS && VAR_1 == 0))) {
event.slotid = VAR_0->slotid;
event.epid = VAR_0->epid;
event.length = (trb->status & 0x1ffff) - chunk;
event.flags = 0;
event.ptr = trb->addr;
if (VAR_0->status == CC_SUCCESS) {
event.ccode = shortpkt ? CC_SHORT_PACKET : CC_SUCCESS;
} else {
event.ccode = VAR_0->status;
}
if (TRB_TYPE(*trb) == TR_EVDATA) {
event.ptr = trb->parameter;
event.flags |= TRB_EV_ED;
event.length = edtla & 0xffffff;
DPRINTF("xhci_xfer_data: EDTLA=%d\n", event.length);
edtla = 0;
}
xhci_event(xhci, &event, TRB_INTR(*trb));
reported = 1;
if (VAR_0->status != CC_SUCCESS) {
return;
}
}
}
}
| [
"static void FUNC_0(XHCITransfer *VAR_0)\n{",
"uint32_t edtla = 0;",
"unsigned int VAR_1;",
"bool reported = 0;",
"bool shortpkt = 0;",
"XHCIEvent event = {ER_TRANSFER, CC_SUCCESS};",
"XHCIState *xhci = VAR_0->xhci;",
"int VAR_2;",
"VAR_1 = VAR_0->packet.actual_length;",
"for (VAR_2 = 0; VAR_2 < V... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35,
37,
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[... |
14,177 | static void usb_hid_handle_destroy(USBDevice *dev)
{
USBHIDState *s = (USBHIDState *)dev;
if (s->kind != USB_KEYBOARD)
qemu_remove_mouse_event_handler(s->ptr.eh_entry);
/* TODO: else */
}
| true | qemu | 46aaebff40f942e7b17b426916a3dee9b8b6f274 | static void usb_hid_handle_destroy(USBDevice *dev)
{
USBHIDState *s = (USBHIDState *)dev;
if (s->kind != USB_KEYBOARD)
qemu_remove_mouse_event_handler(s->ptr.eh_entry);
}
| {
"code": [
" if (s->kind != USB_KEYBOARD)"
],
"line_no": [
9
]
} | static void FUNC_0(USBDevice *VAR_0)
{
USBHIDState *s = (USBHIDState *)VAR_0;
if (s->kind != USB_KEYBOARD)
qemu_remove_mouse_event_handler(s->ptr.eh_entry);
}
| [
"static void FUNC_0(USBDevice *VAR_0)\n{",
"USBHIDState *s = (USBHIDState *)VAR_0;",
"if (s->kind != USB_KEYBOARD)\nqemu_remove_mouse_event_handler(s->ptr.eh_entry);",
"}"
] | [
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
9,
11
],
[
15
]
] |
14,178 | static void do_subtitle_out(AVFormatContext *s,
OutputStream *ost,
InputStream *ist,
AVSubtitle *sub,
int64_t pts)
{
int subtitle_out_max_size = 1024 * 1024;
int subtitle_out_size, nb, i;
AVCodecContext *enc;
AVPacket pkt;
if (pts == AV_NOPTS_VALUE) {
av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
if (exit_on_error)
exit_program(1);
return;
}
enc = ost->st->codec;
if (!subtitle_out) {
subtitle_out = av_malloc(subtitle_out_max_size);
}
/* Note: DVB subtitle need one packet to draw them and one other
packet to clear them */
/* XXX: signal it in the codec context ? */
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
nb = 2;
else
nb = 1;
for (i = 0; i < nb; i++) {
ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
if (!check_recording_time(ost))
return;
sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
// start_display_time is required to be 0
sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
sub->end_display_time -= sub->start_display_time;
sub->start_display_time = 0;
subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
subtitle_out_max_size, sub);
if (subtitle_out_size < 0) {
av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
exit_program(1);
}
av_init_packet(&pkt);
pkt.data = subtitle_out;
pkt.size = subtitle_out_size;
pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
/* XXX: the pts correction is handled here. Maybe handling
it in the codec would be better */
if (i == 0)
pkt.pts += 90 * sub->start_display_time;
else
pkt.pts += 90 * sub->end_display_time;
}
write_frame(s, &pkt, ost);
subtitle_size += pkt.size;
}
}
| true | FFmpeg | 53a3748ed23136615e488dc463b91aa57c0e9ec6 | static void do_subtitle_out(AVFormatContext *s,
OutputStream *ost,
InputStream *ist,
AVSubtitle *sub,
int64_t pts)
{
int subtitle_out_max_size = 1024 * 1024;
int subtitle_out_size, nb, i;
AVCodecContext *enc;
AVPacket pkt;
if (pts == AV_NOPTS_VALUE) {
av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
if (exit_on_error)
exit_program(1);
return;
}
enc = ost->st->codec;
if (!subtitle_out) {
subtitle_out = av_malloc(subtitle_out_max_size);
}
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
nb = 2;
else
nb = 1;
for (i = 0; i < nb; i++) {
ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
if (!check_recording_time(ost))
return;
sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
sub->end_display_time -= sub->start_display_time;
sub->start_display_time = 0;
subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
subtitle_out_max_size, sub);
if (subtitle_out_size < 0) {
av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
exit_program(1);
}
av_init_packet(&pkt);
pkt.data = subtitle_out;
pkt.size = subtitle_out_size;
pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
if (i == 0)
pkt.pts += 90 * sub->start_display_time;
else
pkt.pts += 90 * sub->end_display_time;
}
write_frame(s, &pkt, ost);
subtitle_size += pkt.size;
}
}
| {
"code": [
" ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);",
" sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);"
],
"line_no": [
67,
75
]
} | static void FUNC_0(AVFormatContext *VAR_0,
OutputStream *VAR_1,
InputStream *VAR_2,
AVSubtitle *VAR_3,
int64_t VAR_4)
{
int VAR_5 = 1024 * 1024;
int VAR_6, VAR_7, VAR_8;
AVCodecContext *enc;
AVPacket pkt;
if (VAR_4 == AV_NOPTS_VALUE) {
av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a VAR_4\n");
if (exit_on_error)
exit_program(1);
return;
}
enc = VAR_1->st->codec;
if (!subtitle_out) {
subtitle_out = av_malloc(VAR_5);
}
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
VAR_7 = 2;
else
VAR_7 = 1;
for (VAR_8 = 0; VAR_8 < VAR_7; VAR_8++) {
VAR_1->sync_opts = av_rescale_q(VAR_4, VAR_2->st->time_base, enc->time_base);
if (!check_recording_time(VAR_1))
return;
VAR_3->VAR_4 = av_rescale_q(VAR_4, VAR_2->st->time_base, AV_TIME_BASE_Q);
VAR_3->VAR_4 += av_rescale_q(VAR_3->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
VAR_3->end_display_time -= VAR_3->start_display_time;
VAR_3->start_display_time = 0;
VAR_6 = avcodec_encode_subtitle(enc, subtitle_out,
VAR_5, VAR_3);
if (VAR_6 < 0) {
av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
exit_program(1);
}
av_init_packet(&pkt);
pkt.data = subtitle_out;
pkt.size = VAR_6;
pkt.VAR_4 = av_rescale_q(VAR_3->VAR_4, AV_TIME_BASE_Q, VAR_1->st->time_base);
pkt.duration = av_rescale_q(VAR_3->end_display_time, (AVRational){ 1, 1000 }, VAR_1->st->time_base);
if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
if (VAR_8 == 0)
pkt.VAR_4 += 90 * VAR_3->start_display_time;
else
pkt.VAR_4 += 90 * VAR_3->end_display_time;
}
write_frame(VAR_0, &pkt, VAR_1);
subtitle_size += pkt.size;
}
}
| [
"static void FUNC_0(AVFormatContext *VAR_0,\nOutputStream *VAR_1,\nInputStream *VAR_2,\nAVSubtitle *VAR_3,\nint64_t VAR_4)\n{",
"int VAR_5 = 1024 * 1024;",
"int VAR_6, VAR_7, VAR_8;",
"AVCodecContext *enc;",
"AVPacket pkt;",
"if (VAR_4 == AV_NOPTS_VALUE) {",
"av_log(NULL, AV_LOG_ERROR, \"Subtitle packet... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
37
],
[
41
],
[
43
],
[
45
],
[
55,
57
],
[
59,
61
],
[... |
14,179 | static CharDriverState *qmp_chardev_open_file(ChardevFile *file, Error **errp)
{
int flags, in = -1, out = -1;
flags = O_WRONLY | O_TRUNC | O_CREAT | O_BINARY;
out = qmp_chardev_open_file_source(file->out, flags, errp);
if (error_is_set(errp)) {
return NULL;
}
if (file->has_in) {
flags = O_RDONLY;
in = qmp_chardev_open_file_source(file->in, flags, errp);
if (error_is_set(errp)) {
qemu_close(out);
return NULL;
}
}
return qemu_chr_open_fd(in, out);
}
| true | qemu | 5f758366c0710d23e43f4d0f83816b98616a13d0 | static CharDriverState *qmp_chardev_open_file(ChardevFile *file, Error **errp)
{
int flags, in = -1, out = -1;
flags = O_WRONLY | O_TRUNC | O_CREAT | O_BINARY;
out = qmp_chardev_open_file_source(file->out, flags, errp);
if (error_is_set(errp)) {
return NULL;
}
if (file->has_in) {
flags = O_RDONLY;
in = qmp_chardev_open_file_source(file->in, flags, errp);
if (error_is_set(errp)) {
qemu_close(out);
return NULL;
}
}
return qemu_chr_open_fd(in, out);
}
| {
"code": [
" if (error_is_set(errp)) {",
" int flags, in = -1, out = -1;",
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {"
],
"line_no": [
27,
5,
13,
27,
13,
13,
13,
13
]
} | static CharDriverState *FUNC_0(ChardevFile *file, Error **errp)
{
int VAR_0, VAR_1 = -1, VAR_2 = -1;
VAR_0 = O_WRONLY | O_TRUNC | O_CREAT | O_BINARY;
VAR_2 = qmp_chardev_open_file_source(file->VAR_2, VAR_0, errp);
if (error_is_set(errp)) {
return NULL;
}
if (file->has_in) {
VAR_0 = O_RDONLY;
VAR_1 = qmp_chardev_open_file_source(file->VAR_1, VAR_0, errp);
if (error_is_set(errp)) {
qemu_close(VAR_2);
return NULL;
}
}
return qemu_chr_open_fd(VAR_1, VAR_2);
}
| [
"static CharDriverState *FUNC_0(ChardevFile *file, Error **errp)\n{",
"int VAR_0, VAR_1 = -1, VAR_2 = -1;",
"VAR_0 = O_WRONLY | O_TRUNC | O_CREAT | O_BINARY;",
"VAR_2 = qmp_chardev_open_file_source(file->VAR_2, VAR_0, errp);",
"if (error_is_set(errp)) {",
"return NULL;",
"}",
"if (file->has_in) {",
... | [
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
]
] |
14,181 | static void gen_advance_ccount_cond(DisasContext *dc)
{
if (dc->ccount_delta > 0) {
TCGv_i32 tmp = tcg_const_i32(dc->ccount_delta);
gen_helper_advance_ccount(cpu_env, tmp);
tcg_temp_free(tmp);
}
}
| true | qemu | 2db59a76c421cdd1039d10e32a9798952d3ff5ba | static void gen_advance_ccount_cond(DisasContext *dc)
{
if (dc->ccount_delta > 0) {
TCGv_i32 tmp = tcg_const_i32(dc->ccount_delta);
gen_helper_advance_ccount(cpu_env, tmp);
tcg_temp_free(tmp);
}
}
| {
"code": [
"static void gen_advance_ccount_cond(DisasContext *dc)"
],
"line_no": [
1
]
} | static void FUNC_0(DisasContext *VAR_0)
{
if (VAR_0->ccount_delta > 0) {
TCGv_i32 tmp = tcg_const_i32(VAR_0->ccount_delta);
gen_helper_advance_ccount(cpu_env, tmp);
tcg_temp_free(tmp);
}
}
| [
"static void FUNC_0(DisasContext *VAR_0)\n{",
"if (VAR_0->ccount_delta > 0) {",
"TCGv_i32 tmp = tcg_const_i32(VAR_0->ccount_delta);",
"gen_helper_advance_ccount(cpu_env, tmp);",
"tcg_temp_free(tmp);",
"}",
"}"
] | [
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
14,182 | static inline void RENAME(hcscale_fast)(SwsContext *c, int16_t *dst1, int16_t *dst2,
long dstWidth, const uint8_t *src1,
const uint8_t *src2, int srcW, int xInc)
{
int32_t *filterPos = c->hChrFilterPos;
int16_t *filter = c->hChrFilter;
int canMMX2BeUsed = c->canMMX2BeUsed;
void *mmx2FilterCode= c->chrMmx2FilterCode;
int i;
#if defined(PIC)
DECLARE_ALIGNED(8, uint64_t, ebxsave);
#endif
__asm__ volatile(
#if defined(PIC)
"mov %%"REG_b", %7 \n\t"
#endif
"pxor %%mm7, %%mm7 \n\t"
"mov %0, %%"REG_c" \n\t"
"mov %1, %%"REG_D" \n\t"
"mov %2, %%"REG_d" \n\t"
"mov %3, %%"REG_b" \n\t"
"xor %%"REG_a", %%"REG_a" \n\t" // i
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
"xor %%"REG_a", %%"REG_a" \n\t" // i
"mov %5, %%"REG_c" \n\t" // src
"mov %6, %%"REG_D" \n\t" // buf2
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
#if defined(PIC)
"mov %7, %%"REG_b" \n\t"
#endif
:: "m" (src1), "m" (dst1), "m" (filter), "m" (filterPos),
"m" (mmx2FilterCode), "m" (src2), "m"(dst2)
#if defined(PIC)
,"m" (ebxsave)
#endif
: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
#if !defined(PIC)
,"%"REG_b
#endif
);
for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) {
dst1[i] = src1[srcW-1]*128;
dst2[i] = src2[srcW-1]*128;
}
}
| true | FFmpeg | 39d607e5bbc25ad9629683702b510e865434ef21 | static inline void RENAME(hcscale_fast)(SwsContext *c, int16_t *dst1, int16_t *dst2,
long dstWidth, const uint8_t *src1,
const uint8_t *src2, int srcW, int xInc)
{
int32_t *filterPos = c->hChrFilterPos;
int16_t *filter = c->hChrFilter;
int canMMX2BeUsed = c->canMMX2BeUsed;
void *mmx2FilterCode= c->chrMmx2FilterCode;
int i;
#if defined(PIC)
DECLARE_ALIGNED(8, uint64_t, ebxsave);
#endif
__asm__ volatile(
#if defined(PIC)
"mov %%"REG_b", %7 \n\t"
#endif
"pxor %%mm7, %%mm7 \n\t"
"mov %0, %%"REG_c" \n\t"
"mov %1, %%"REG_D" \n\t"
"mov %2, %%"REG_d" \n\t"
"mov %3, %%"REG_b" \n\t"
"xor %%"REG_a", %%"REG_a" \n\t"
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
"xor %%"REG_a", %%"REG_a" \n\t"
"mov %5, %%"REG_c" \n\t"
"mov %6, %%"REG_D" \n\t"
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
#if defined(PIC)
"mov %7, %%"REG_b" \n\t"
#endif
:: "m" (src1), "m" (dst1), "m" (filter), "m" (filterPos),
"m" (mmx2FilterCode), "m" (src2), "m"(dst2)
#if defined(PIC)
,"m" (ebxsave)
#endif
: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
#if !defined(PIC)
,"%"REG_b
#endif
);
for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) {
dst1[i] = src1[srcW-1]*128;
dst2[i] = src2[srcW-1]*128;
}
}
| {
"code": [
" int canMMX2BeUsed = c->canMMX2BeUsed;",
" int canMMX2BeUsed = c->canMMX2BeUsed;"
],
"line_no": [
13,
13
]
} | static inline void FUNC_0(hcscale_fast)(SwsContext *c, int16_t *dst1, int16_t *dst2,
long dstWidth, const uint8_t *src1,
const uint8_t *src2, int srcW, int xInc)
{
int32_t *filterPos = c->hChrFilterPos;
int16_t *filter = c->hChrFilter;
int VAR_0 = c->VAR_0;
void *VAR_1= c->chrMmx2FilterCode;
int VAR_2;
#if defined(PIC)
DECLARE_ALIGNED(8, uint64_t, ebxsave);
#endif
__asm__ volatile(
#if defined(PIC)
"mov %%"REG_b", %7 \n\t"
#endif
"pxor %%mm7, %%mm7 \n\t"
"mov %0, %%"REG_c" \n\t"
"mov %1, %%"REG_D" \n\t"
"mov %2, %%"REG_d" \n\t"
"mov %3, %%"REG_b" \n\t"
"xor %%"REG_a", %%"REG_a" \n\t"
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
"xor %%"REG_a", %%"REG_a" \n\t"
"mov %5, %%"REG_c" \n\t"
"mov %6, %%"REG_D" \n\t"
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
CALL_MMX2_FILTER_CODE
#if defined(PIC)
"mov %7, %%"REG_b" \n\t"
#endif
:: "m" (src1), "m" (dst1), "m" (filter), "m" (filterPos),
"m" (VAR_1), "m" (src2), "m"(dst2)
#if defined(PIC)
,"m" (ebxsave)
#endif
: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
#if !defined(PIC)
,"%"REG_b
#endif
);
for (VAR_2=dstWidth-1; (VAR_2*xInc)>>16 >=srcW-1; VAR_2--) {
dst1[VAR_2] = src1[srcW-1]*128;
dst2[VAR_2] = src2[srcW-1]*128;
}
}
| [
"static inline void FUNC_0(hcscale_fast)(SwsContext *c, int16_t *dst1, int16_t *dst2,\nlong dstWidth, const uint8_t *src1,\nconst uint8_t *src2, int srcW, int xInc)\n{",
"int32_t *filterPos = c->hChrFilterPos;",
"int16_t *filter = c->hChrFilter;",
"int VAR_0 = c->VAR_0;",
"void *VAR_1= c->chrMmx2... | [
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19,
21
],
[
23,
27,
29,
31,
33,
35,
37,
39,
41,
43,
45,
47,
49,
51,
55,
57,
59,
61,
63,
65,
67,
69,... |
14,183 | static av_cold int fbdev_read_header(AVFormatContext *avctx)
{
FBDevContext *fbdev = avctx->priv_data;
AVStream *st = NULL;
enum AVPixelFormat pix_fmt;
int ret, flags = O_RDONLY;
if (!(st = avformat_new_stream(avctx, NULL)))
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
/* NONBLOCK is ignored by the fbdev driver, only set for consistency */
if (avctx->flags & AVFMT_FLAG_NONBLOCK)
flags |= O_NONBLOCK;
if ((fbdev->fd = avpriv_open(avctx->filename, flags)) == -1) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"Could not open framebuffer device '%s': %s\n",
avctx->filename, strerror(ret));
return ret;
}
if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"FBIOGET_VSCREENINFO: %s\n", strerror(errno));
goto fail;
}
if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"FBIOGET_FSCREENINFO: %s\n", strerror(errno));
goto fail;
}
pix_fmt = get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
if (pix_fmt == AV_PIX_FMT_NONE) {
ret = AVERROR(EINVAL);
av_log(avctx, AV_LOG_ERROR,
"Framebuffer pixel format not supported.\n");
goto fail;
}
fbdev->width = fbdev->varinfo.xres;
fbdev->height = fbdev->varinfo.yres;
fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
fbdev->frame_linesize = fbdev->width * fbdev->bytes_per_pixel;
fbdev->frame_size = fbdev->frame_linesize * fbdev->height;
fbdev->time_frame = AV_NOPTS_VALUE;
fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
if (fbdev->data == MAP_FAILED) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", strerror(errno));
goto fail;
}
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = fbdev->width;
st->codec->height = fbdev->height;
st->codec->pix_fmt = pix_fmt;
st->codec->time_base = av_inv_q(fbdev->framerate_q);
st->codec->bit_rate =
fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
av_log(avctx, AV_LOG_INFO,
"w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
av_get_pix_fmt_name(pix_fmt),
fbdev->framerate_q.num, fbdev->framerate_q.den,
st->codec->bit_rate);
return 0;
fail:
close(fbdev->fd);
return ret;
}
| false | FFmpeg | f6b56b1f26a1e40a47d85d24b42cd5475cd3b04f | static av_cold int fbdev_read_header(AVFormatContext *avctx)
{
FBDevContext *fbdev = avctx->priv_data;
AVStream *st = NULL;
enum AVPixelFormat pix_fmt;
int ret, flags = O_RDONLY;
if (!(st = avformat_new_stream(avctx, NULL)))
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
if (avctx->flags & AVFMT_FLAG_NONBLOCK)
flags |= O_NONBLOCK;
if ((fbdev->fd = avpriv_open(avctx->filename, flags)) == -1) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"Could not open framebuffer device '%s': %s\n",
avctx->filename, strerror(ret));
return ret;
}
if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"FBIOGET_VSCREENINFO: %s\n", strerror(errno));
goto fail;
}
if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"FBIOGET_FSCREENINFO: %s\n", strerror(errno));
goto fail;
}
pix_fmt = get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
if (pix_fmt == AV_PIX_FMT_NONE) {
ret = AVERROR(EINVAL);
av_log(avctx, AV_LOG_ERROR,
"Framebuffer pixel format not supported.\n");
goto fail;
}
fbdev->width = fbdev->varinfo.xres;
fbdev->height = fbdev->varinfo.yres;
fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
fbdev->frame_linesize = fbdev->width * fbdev->bytes_per_pixel;
fbdev->frame_size = fbdev->frame_linesize * fbdev->height;
fbdev->time_frame = AV_NOPTS_VALUE;
fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
if (fbdev->data == MAP_FAILED) {
ret = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", strerror(errno));
goto fail;
}
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = fbdev->width;
st->codec->height = fbdev->height;
st->codec->pix_fmt = pix_fmt;
st->codec->time_base = av_inv_q(fbdev->framerate_q);
st->codec->bit_rate =
fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
av_log(avctx, AV_LOG_INFO,
"w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
av_get_pix_fmt_name(pix_fmt),
fbdev->framerate_q.num, fbdev->framerate_q.den,
st->codec->bit_rate);
return 0;
fail:
close(fbdev->fd);
return ret;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVFormatContext *avctx)
{
FBDevContext *fbdev = avctx->priv_data;
AVStream *st = NULL;
enum AVPixelFormat VAR_0;
int VAR_1, VAR_2 = O_RDONLY;
if (!(st = avformat_new_stream(avctx, NULL)))
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
if (avctx->VAR_2 & AVFMT_FLAG_NONBLOCK)
VAR_2 |= O_NONBLOCK;
if ((fbdev->fd = avpriv_open(avctx->filename, VAR_2)) == -1) {
VAR_1 = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"Could not open framebuffer device '%s': %s\n",
avctx->filename, strerror(VAR_1));
return VAR_1;
}
if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
VAR_1 = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"FBIOGET_VSCREENINFO: %s\n", strerror(errno));
goto fail;
}
if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
VAR_1 = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR,
"FBIOGET_FSCREENINFO: %s\n", strerror(errno));
goto fail;
}
VAR_0 = get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
if (VAR_0 == AV_PIX_FMT_NONE) {
VAR_1 = AVERROR(EINVAL);
av_log(avctx, AV_LOG_ERROR,
"Framebuffer pixel format not supported.\n");
goto fail;
}
fbdev->width = fbdev->varinfo.xres;
fbdev->height = fbdev->varinfo.yres;
fbdev->bytes_per_pixel = (fbdev->varinfo.bits_per_pixel + 7) >> 3;
fbdev->frame_linesize = fbdev->width * fbdev->bytes_per_pixel;
fbdev->frame_size = fbdev->frame_linesize * fbdev->height;
fbdev->time_frame = AV_NOPTS_VALUE;
fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
if (fbdev->data == MAP_FAILED) {
VAR_1 = AVERROR(errno);
av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", strerror(errno));
goto fail;
}
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = fbdev->width;
st->codec->height = fbdev->height;
st->codec->VAR_0 = VAR_0;
st->codec->time_base = av_inv_q(fbdev->framerate_q);
st->codec->bit_rate =
fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
av_log(avctx, AV_LOG_INFO,
"w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
av_get_pix_fmt_name(VAR_0),
fbdev->framerate_q.num, fbdev->framerate_q.den,
st->codec->bit_rate);
return 0;
fail:
close(fbdev->fd);
return VAR_1;
}
| [
"static av_cold int FUNC_0(AVFormatContext *avctx)\n{",
"FBDevContext *fbdev = avctx->priv_data;",
"AVStream *st = NULL;",
"enum AVPixelFormat VAR_0;",
"int VAR_1, VAR_2 = O_RDONLY;",
"if (!(st = avformat_new_stream(avctx, NULL)))\nreturn AVERROR(ENOMEM);",
"avpriv_set_pts_info(st, 64, 1, 1000000);",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15,
17
],
[
19
],
[
25,
27
],
[
31
],
[
33
],
[
35,
37,
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51,
53
],
[
55
],
[... |
14,184 | void ff_build_rac_states(RangeCoder *c, int factor, int max_p){
const int64_t one= 1LL<<32;
int64_t p;
int last_p8, p8, i;
memset(c->zero_state, 0, sizeof(c->zero_state));
memset(c-> one_state, 0, sizeof(c-> one_state));
#if 0
for(i=1; i<256; i++){
if(c->one_state[i])
continue;
p= (i*one + 128) >> 8;
last_p8= i;
for(;;){
p+= ((one-p)*factor + one/2) >> 32;
p8= (256*p + one/2) >> 32; //FIXME try without the one
if(p8 <= last_p8) p8= last_p8+1;
if(p8 > max_p) p8= max_p;
if(p8 < last_p8)
break;
c->one_state[last_p8]= p8;
if(p8 == last_p8)
break;
last_p8= p8;
}
}
#endif
#if 1
last_p8= 0;
p= one/2;
for(i=0; i<128; i++){
p8= (256*p + one/2) >> 32; //FIXME try without the one
if(p8 <= last_p8) p8= last_p8+1;
if(last_p8 && last_p8<256 && p8<=max_p)
c->one_state[last_p8]= p8;
p+= ((one-p)*factor + one/2) >> 32;
last_p8= p8;
}
#endif
for(i=256-max_p; i<=max_p; i++){
if(c->one_state[i])
continue;
p= (i*one + 128) >> 8;
p+= ((one-p)*factor + one/2) >> 32;
p8= (256*p + one/2) >> 32; //FIXME try without the one
if(p8 <= i) p8= i+1;
if(p8 > max_p) p8= max_p;
c->one_state[ i]= p8;
}
for(i=0; i<256; i++)
c->zero_state[i]= 256-c->one_state[256-i];
#if 0
for(i=0; i<256; i++)
av_log(NULL, AV_LOG_DEBUG, "%3d %3d\n", i, c->one_state[i]);
#endif
}
| false | FFmpeg | 003ebe100b9d9cd4ae32b16b38865714bfb6df44 | void ff_build_rac_states(RangeCoder *c, int factor, int max_p){
const int64_t one= 1LL<<32;
int64_t p;
int last_p8, p8, i;
memset(c->zero_state, 0, sizeof(c->zero_state));
memset(c-> one_state, 0, sizeof(c-> one_state));
#if 0
for(i=1; i<256; i++){
if(c->one_state[i])
continue;
p= (i*one + 128) >> 8;
last_p8= i;
for(;;){
p+= ((one-p)*factor + one/2) >> 32;
p8= (256*p + one/2) >> 32;
if(p8 <= last_p8) p8= last_p8+1;
if(p8 > max_p) p8= max_p;
if(p8 < last_p8)
break;
c->one_state[last_p8]= p8;
if(p8 == last_p8)
break;
last_p8= p8;
}
}
#endif
#if 1
last_p8= 0;
p= one/2;
for(i=0; i<128; i++){
p8= (256*p + one/2) >> 32;
if(p8 <= last_p8) p8= last_p8+1;
if(last_p8 && last_p8<256 && p8<=max_p)
c->one_state[last_p8]= p8;
p+= ((one-p)*factor + one/2) >> 32;
last_p8= p8;
}
#endif
for(i=256-max_p; i<=max_p; i++){
if(c->one_state[i])
continue;
p= (i*one + 128) >> 8;
p+= ((one-p)*factor + one/2) >> 32;
p8= (256*p + one/2) >> 32;
if(p8 <= i) p8= i+1;
if(p8 > max_p) p8= max_p;
c->one_state[ i]= p8;
}
for(i=0; i<256; i++)
c->zero_state[i]= 256-c->one_state[256-i];
#if 0
for(i=0; i<256; i++)
av_log(NULL, AV_LOG_DEBUG, "%3d %3d\n", i, c->one_state[i]);
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(RangeCoder *VAR_0, int VAR_1, int VAR_2){
const int64_t VAR_3= 1LL<<32;
int64_t p;
int VAR_4, VAR_5, VAR_6;
memset(VAR_0->zero_state, 0, sizeof(VAR_0->zero_state));
memset(VAR_0-> one_state, 0, sizeof(VAR_0-> one_state));
#if 0
for(VAR_6=1; VAR_6<256; VAR_6++){
if(VAR_0->one_state[VAR_6])
continue;
p= (VAR_6*VAR_3 + 128) >> 8;
VAR_4= VAR_6;
for(;;){
p+= ((VAR_3-p)*VAR_1 + VAR_3/2) >> 32;
VAR_5= (256*p + VAR_3/2) >> 32;
if(VAR_5 <= VAR_4) VAR_5= VAR_4+1;
if(VAR_5 > VAR_2) VAR_5= VAR_2;
if(VAR_5 < VAR_4)
break;
VAR_0->one_state[VAR_4]= VAR_5;
if(VAR_5 == VAR_4)
break;
VAR_4= VAR_5;
}
}
#endif
#if 1
VAR_4= 0;
p= VAR_3/2;
for(VAR_6=0; VAR_6<128; VAR_6++){
VAR_5= (256*p + VAR_3/2) >> 32;
if(VAR_5 <= VAR_4) VAR_5= VAR_4+1;
if(VAR_4 && VAR_4<256 && VAR_5<=VAR_2)
VAR_0->one_state[VAR_4]= VAR_5;
p+= ((VAR_3-p)*VAR_1 + VAR_3/2) >> 32;
VAR_4= VAR_5;
}
#endif
for(VAR_6=256-VAR_2; VAR_6<=VAR_2; VAR_6++){
if(VAR_0->one_state[VAR_6])
continue;
p= (VAR_6*VAR_3 + 128) >> 8;
p+= ((VAR_3-p)*VAR_1 + VAR_3/2) >> 32;
VAR_5= (256*p + VAR_3/2) >> 32;
if(VAR_5 <= VAR_6) VAR_5= VAR_6+1;
if(VAR_5 > VAR_2) VAR_5= VAR_2;
VAR_0->one_state[ VAR_6]= VAR_5;
}
for(VAR_6=0; VAR_6<256; VAR_6++)
VAR_0->zero_state[VAR_6]= 256-VAR_0->one_state[256-VAR_6];
#if 0
for(VAR_6=0; VAR_6<256; VAR_6++)
av_log(NULL, AV_LOG_DEBUG, "%3d %3d\n", VAR_6, VAR_0->one_state[VAR_6]);
#endif
}
| [
"void FUNC_0(RangeCoder *VAR_0, int VAR_1, int VAR_2){",
"const int64_t VAR_3= 1LL<<32;",
"int64_t p;",
"int VAR_4, VAR_5, VAR_6;",
"memset(VAR_0->zero_state, 0, sizeof(VAR_0->zero_state));",
"memset(VAR_0-> one_state, 0, sizeof(VAR_0-> one_state));",
"#if 0\nfor(VAR_6=1; VAR_6<256; VAR_6++){",
"if(VA... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
17,
19
],
[
21,
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47,
49
],
... |
14,185 | static void test_notify(void)
{
g_assert(!aio_poll(ctx, false));
aio_notify(ctx);
g_assert(!aio_poll(ctx, true));
g_assert(!aio_poll(ctx, false));
}
| true | qemu | eabc977973103527bbb8fed69c91cfaa6691f8ab | static void test_notify(void)
{
g_assert(!aio_poll(ctx, false));
aio_notify(ctx);
g_assert(!aio_poll(ctx, true));
g_assert(!aio_poll(ctx, false));
}
| {
"code": [
"static void test_notify(void)",
" g_assert(!aio_poll(ctx, false));",
" aio_notify(ctx);",
" g_assert(!aio_poll(ctx, true));",
" g_assert(!aio_poll(ctx, false));",
" aio_notify(ctx);"
],
"line_no": [
1,
5,
7,
9,
5,
7
]
} | static void FUNC_0(void)
{
g_assert(!aio_poll(ctx, false));
aio_notify(ctx);
g_assert(!aio_poll(ctx, true));
g_assert(!aio_poll(ctx, false));
}
| [
"static void FUNC_0(void)\n{",
"g_assert(!aio_poll(ctx, false));",
"aio_notify(ctx);",
"g_assert(!aio_poll(ctx, true));",
"g_assert(!aio_poll(ctx, false));",
"}"
] | [
1,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
14,186 | static int scsi_qdev_init(DeviceState *qdev)
{
SCSIDevice *dev = SCSI_DEVICE(qdev);
SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
SCSIDevice *d;
int rc = -1;
if (dev->channel > bus->info->max_channel) {
error_report("bad scsi channel id: %d", dev->channel);
goto err;
}
if (dev->id != -1 && dev->id > bus->info->max_target) {
error_report("bad scsi device id: %d", dev->id);
goto err;
}
if (dev->id == -1) {
int id = -1;
if (dev->lun == -1) {
dev->lun = 0;
}
do {
d = scsi_device_find(bus, dev->channel, ++id, dev->lun);
} while (d && d->lun == dev->lun && id <= bus->info->max_target);
if (id > bus->info->max_target) {
error_report("no free target");
goto err;
}
dev->id = id;
} else if (dev->lun == -1) {
int lun = -1;
do {
d = scsi_device_find(bus, dev->channel, dev->id, ++lun);
} while (d && d->lun == lun && lun < bus->info->max_lun);
if (lun > bus->info->max_lun) {
error_report("no free lun");
goto err;
}
dev->lun = lun;
} else {
d = scsi_device_find(bus, dev->channel, dev->id, dev->lun);
if (dev->lun == d->lun && dev != d) {
qdev_free(&d->qdev);
}
}
QTAILQ_INIT(&dev->requests);
rc = scsi_device_init(dev);
if (rc == 0) {
dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
dev);
}
err:
return rc;
}
| true | qemu | d3d250bddb3f6aa6c26e9dadf10e82d9fd8bfce3 | static int scsi_qdev_init(DeviceState *qdev)
{
SCSIDevice *dev = SCSI_DEVICE(qdev);
SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
SCSIDevice *d;
int rc = -1;
if (dev->channel > bus->info->max_channel) {
error_report("bad scsi channel id: %d", dev->channel);
goto err;
}
if (dev->id != -1 && dev->id > bus->info->max_target) {
error_report("bad scsi device id: %d", dev->id);
goto err;
}
if (dev->id == -1) {
int id = -1;
if (dev->lun == -1) {
dev->lun = 0;
}
do {
d = scsi_device_find(bus, dev->channel, ++id, dev->lun);
} while (d && d->lun == dev->lun && id <= bus->info->max_target);
if (id > bus->info->max_target) {
error_report("no free target");
goto err;
}
dev->id = id;
} else if (dev->lun == -1) {
int lun = -1;
do {
d = scsi_device_find(bus, dev->channel, dev->id, ++lun);
} while (d && d->lun == lun && lun < bus->info->max_lun);
if (lun > bus->info->max_lun) {
error_report("no free lun");
goto err;
}
dev->lun = lun;
} else {
d = scsi_device_find(bus, dev->channel, dev->id, dev->lun);
if (dev->lun == d->lun && dev != d) {
qdev_free(&d->qdev);
}
}
QTAILQ_INIT(&dev->requests);
rc = scsi_device_init(dev);
if (rc == 0) {
dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
dev);
}
err:
return rc;
}
| {
"code": [
" } while (d && d->lun == dev->lun && id <= bus->info->max_target);",
" if (id > bus->info->max_target) {",
" if (lun > bus->info->max_lun) {",
" if (dev->lun == d->lun && dev != d) {"
],
"line_no": [
47,
49,
69,
83
]
} | static int FUNC_0(DeviceState *VAR_0)
{
SCSIDevice *dev = SCSI_DEVICE(VAR_0);
SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->VAR_0.parent_bus);
SCSIDevice *d;
int VAR_1 = -1;
if (dev->channel > bus->info->max_channel) {
error_report("bad scsi channel VAR_2: %d", dev->channel);
goto err;
}
if (dev->VAR_2 != -1 && dev->VAR_2 > bus->info->max_target) {
error_report("bad scsi device VAR_2: %d", dev->VAR_2);
goto err;
}
if (dev->VAR_2 == -1) {
int VAR_2 = -1;
if (dev->VAR_3 == -1) {
dev->VAR_3 = 0;
}
do {
d = scsi_device_find(bus, dev->channel, ++VAR_2, dev->VAR_3);
} while (d && d->VAR_3 == dev->VAR_3 && VAR_2 <= bus->info->max_target);
if (VAR_2 > bus->info->max_target) {
error_report("no free target");
goto err;
}
dev->VAR_2 = VAR_2;
} else if (dev->VAR_3 == -1) {
int VAR_3 = -1;
do {
d = scsi_device_find(bus, dev->channel, dev->VAR_2, ++VAR_3);
} while (d && d->VAR_3 == VAR_3 && VAR_3 < bus->info->max_lun);
if (VAR_3 > bus->info->max_lun) {
error_report("no free VAR_3");
goto err;
}
dev->VAR_3 = VAR_3;
} else {
d = scsi_device_find(bus, dev->channel, dev->VAR_2, dev->VAR_3);
if (dev->VAR_3 == d->VAR_3 && dev != d) {
qdev_free(&d->VAR_0);
}
}
QTAILQ_INIT(&dev->requests);
VAR_1 = scsi_device_init(dev);
if (VAR_1 == 0) {
dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
dev);
}
err:
return VAR_1;
}
| [
"static int FUNC_0(DeviceState *VAR_0)\n{",
"SCSIDevice *dev = SCSI_DEVICE(VAR_0);",
"SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->VAR_0.parent_bus);",
"SCSIDevice *d;",
"int VAR_1 = -1;",
"if (dev->channel > bus->info->max_channel) {",
"error_report(\"bad scsi channel VAR_2: %d\", dev->channel);",
"g... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
... |
14,187 | static const char *addr2str(target_phys_addr_t addr)
{
return nr2str(ehci_mmio_names, ARRAY_SIZE(ehci_mmio_names), addr);
}
| true | qemu | 3e4f910c8d490a1490409a7e381dbbb229f9d272 | static const char *addr2str(target_phys_addr_t addr)
{
return nr2str(ehci_mmio_names, ARRAY_SIZE(ehci_mmio_names), addr);
}
| {
"code": [
" return nr2str(ehci_mmio_names, ARRAY_SIZE(ehci_mmio_names), addr);"
],
"line_no": [
5
]
} | static const char *FUNC_0(target_phys_addr_t VAR_0)
{
return nr2str(ehci_mmio_names, ARRAY_SIZE(ehci_mmio_names), VAR_0);
}
| [
"static const char *FUNC_0(target_phys_addr_t VAR_0)\n{",
"return nr2str(ehci_mmio_names, ARRAY_SIZE(ehci_mmio_names), VAR_0);",
"}"
] | [
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
14,188 | static int dca_convert_bitstream(uint8_t * src, int src_size, uint8_t * dst,
int max_size)
{
uint32_t mrk;
int i, tmp;
uint16_t *ssrc = (uint16_t *) src, *sdst = (uint16_t *) dst;
PutBitContext pb;
mrk = AV_RB32(src);
switch (mrk) {
case DCA_MARKER_RAW_BE:
memcpy(dst, src, FFMIN(src_size, max_size));
return FFMIN(src_size, max_size);
case DCA_MARKER_RAW_LE:
for (i = 0; i < (FFMIN(src_size, max_size) + 1) >> 1; i++)
*sdst++ = bswap_16(*ssrc++);
return FFMIN(src_size, max_size);
case DCA_MARKER_14B_BE:
case DCA_MARKER_14B_LE:
init_put_bits(&pb, dst, max_size);
for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
put_bits(&pb, 14, tmp);
}
flush_put_bits(&pb);
return (put_bits_count(&pb) + 7) >> 3;
default:
}
} | true | FFmpeg | 9f1473b304ae11ee09b7ae22016c951fdce31dd2 | static int dca_convert_bitstream(uint8_t * src, int src_size, uint8_t * dst,
int max_size)
{
uint32_t mrk;
int i, tmp;
uint16_t *ssrc = (uint16_t *) src, *sdst = (uint16_t *) dst;
PutBitContext pb;
mrk = AV_RB32(src);
switch (mrk) {
case DCA_MARKER_RAW_BE:
memcpy(dst, src, FFMIN(src_size, max_size));
return FFMIN(src_size, max_size);
case DCA_MARKER_RAW_LE:
for (i = 0; i < (FFMIN(src_size, max_size) + 1) >> 1; i++)
*sdst++ = bswap_16(*ssrc++);
return FFMIN(src_size, max_size);
case DCA_MARKER_14B_BE:
case DCA_MARKER_14B_LE:
init_put_bits(&pb, dst, max_size);
for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
put_bits(&pb, 14, tmp);
}
flush_put_bits(&pb);
return (put_bits_count(&pb) + 7) >> 3;
default:
}
} | {
"code": [],
"line_no": []
} | static int FUNC_0(uint8_t * VAR_0, int VAR_1, uint8_t * VAR_2,
int VAR_3)
{
uint32_t mrk;
int VAR_4, VAR_5;
uint16_t *ssrc = (uint16_t *) VAR_0, *sdst = (uint16_t *) VAR_2;
PutBitContext pb;
mrk = AV_RB32(VAR_0);
switch (mrk) {
case DCA_MARKER_RAW_BE:
memcpy(VAR_2, VAR_0, FFMIN(VAR_1, VAR_3));
return FFMIN(VAR_1, VAR_3);
case DCA_MARKER_RAW_LE:
for (VAR_4 = 0; VAR_4 < (FFMIN(VAR_1, VAR_3) + 1) >> 1; VAR_4++)
*sdst++ = bswap_16(*ssrc++);
return FFMIN(VAR_1, VAR_3);
case DCA_MARKER_14B_BE:
case DCA_MARKER_14B_LE:
init_put_bits(&pb, VAR_2, VAR_3);
for (VAR_4 = 0; VAR_4 < (VAR_1 + 1) >> 1; VAR_4++, VAR_0 += 2) {
VAR_5 = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(VAR_0) : AV_RL16(VAR_0)) & 0x3FFF;
put_bits(&pb, 14, VAR_5);
}
flush_put_bits(&pb);
return (put_bits_count(&pb) + 7) >> 3;
default:
}
} | [
"static int FUNC_0(uint8_t * VAR_0, int VAR_1, uint8_t * VAR_2,\nint VAR_3)\n{",
"uint32_t mrk;",
"int VAR_4, VAR_5;",
"uint16_t *ssrc = (uint16_t *) VAR_0, *sdst = (uint16_t *) VAR_2;",
"PutBitContext pb;",
"mrk = AV_RB32(VAR_0);",
"switch (mrk) {",
"case DCA_MARKER_RAW_BE:\nmemcpy(VAR_2, VAR_0, FFMI... | [
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
],
[
... |
14,189 | static void *spapr_create_fdt_skel(hwaddr initrd_base,
hwaddr initrd_size,
hwaddr kernel_size,
bool little_endian,
const char *boot_device,
const char *kernel_cmdline,
uint32_t epow_irq)
{
void *fdt;
CPUState *cs;
uint32_t start_prop = cpu_to_be32(initrd_base);
uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size);
GString *hypertas = g_string_sized_new(256);
GString *qemu_hypertas = g_string_sized_new(256);
uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)};
uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(smp_cpus)};
int smt = kvmppc_smt_threads();
unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80};
QemuOpts *opts = qemu_opts_find(qemu_find_opts("smp-opts"), NULL);
unsigned sockets = opts ? qemu_opt_get_number(opts, "sockets", 0) : 0;
uint32_t cpus_per_socket = sockets ? (smp_cpus / sockets) : 1;
add_str(hypertas, "hcall-pft");
add_str(hypertas, "hcall-term");
add_str(hypertas, "hcall-dabr");
add_str(hypertas, "hcall-interrupt");
add_str(hypertas, "hcall-tce");
add_str(hypertas, "hcall-vio");
add_str(hypertas, "hcall-splpar");
add_str(hypertas, "hcall-bulk");
add_str(hypertas, "hcall-set-mode");
add_str(qemu_hypertas, "hcall-memop1");
fdt = g_malloc0(FDT_MAX_SIZE);
_FDT((fdt_create(fdt, FDT_MAX_SIZE)));
if (kernel_size) {
_FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size)));
}
if (initrd_size) {
_FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size)));
}
_FDT((fdt_finish_reservemap(fdt)));
/* Root node */
_FDT((fdt_begin_node(fdt, "")));
_FDT((fdt_property_string(fdt, "device_type", "chrp")));
_FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)")));
_FDT((fdt_property_string(fdt, "compatible", "qemu,pseries")));
_FDT((fdt_property_cell(fdt, "#address-cells", 0x2)));
_FDT((fdt_property_cell(fdt, "#size-cells", 0x2)));
/* /chosen */
_FDT((fdt_begin_node(fdt, "chosen")));
/* Set Form1_affinity */
_FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5))));
_FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline)));
_FDT((fdt_property(fdt, "linux,initrd-start",
&start_prop, sizeof(start_prop))));
_FDT((fdt_property(fdt, "linux,initrd-end",
&end_prop, sizeof(end_prop))));
if (kernel_size) {
uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),
cpu_to_be64(kernel_size) };
_FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop))));
if (little_endian) {
_FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0)));
}
}
if (boot_device) {
_FDT((fdt_property_string(fdt, "qemu,boot-device", boot_device)));
}
if (boot_menu) {
_FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu)));
}
_FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width)));
_FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height)));
_FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth)));
_FDT((fdt_end_node(fdt)));
/* cpus */
_FDT((fdt_begin_node(fdt, "cpus")));
_FDT((fdt_property_cell(fdt, "#address-cells", 0x1)));
_FDT((fdt_property_cell(fdt, "#size-cells", 0x0)));
CPU_FOREACH(cs) {
PowerPCCPU *cpu = POWERPC_CPU(cs);
CPUPPCState *env = &cpu->env;
DeviceClass *dc = DEVICE_GET_CLASS(cs);
PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
int index = ppc_get_vcpu_dt_id(cpu);
char *nodename;
uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
0xffffffff, 0xffffffff};
uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ;
uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
uint32_t page_sizes_prop[64];
size_t page_sizes_prop_size;
if ((index % smt) != 0) {
continue;
}
nodename = g_strdup_printf("%s@%x", dc->fw_name, index);
_FDT((fdt_begin_node(fdt, nodename)));
g_free(nodename);
_FDT((fdt_property_cell(fdt, "reg", index)));
_FDT((fdt_property_string(fdt, "device_type", "cpu")));
_FDT((fdt_property_cell(fdt, "cpu-version", env->spr[SPR_PVR])));
_FDT((fdt_property_cell(fdt, "d-cache-block-size",
env->dcache_line_size)));
_FDT((fdt_property_cell(fdt, "d-cache-line-size",
env->dcache_line_size)));
_FDT((fdt_property_cell(fdt, "i-cache-block-size",
env->icache_line_size)));
_FDT((fdt_property_cell(fdt, "i-cache-line-size",
env->icache_line_size)));
if (pcc->l1_dcache_size) {
_FDT((fdt_property_cell(fdt, "d-cache-size", pcc->l1_dcache_size)));
} else {
fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n");
}
if (pcc->l1_icache_size) {
_FDT((fdt_property_cell(fdt, "i-cache-size", pcc->l1_icache_size)));
} else {
fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n");
}
_FDT((fdt_property_cell(fdt, "timebase-frequency", tbfreq)));
_FDT((fdt_property_cell(fdt, "clock-frequency", cpufreq)));
_FDT((fdt_property_cell(fdt, "ibm,slb-size", env->slb_nr)));
_FDT((fdt_property_string(fdt, "status", "okay")));
_FDT((fdt_property(fdt, "64-bit", NULL, 0)));
if (env->spr_cb[SPR_PURR].oea_read) {
_FDT((fdt_property(fdt, "ibm,purr", NULL, 0)));
}
if (env->mmu_model & POWERPC_MMU_1TSEG) {
_FDT((fdt_property(fdt, "ibm,processor-segment-sizes",
segs, sizeof(segs))));
}
/* Advertise VMX/VSX (vector extensions) if available
* 0 / no property == no vector extensions
* 1 == VMX / Altivec available
* 2 == VSX available */
if (env->insns_flags & PPC_ALTIVEC) {
uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1;
_FDT((fdt_property_cell(fdt, "ibm,vmx", vmx)));
}
/* Advertise DFP (Decimal Floating Point) if available
* 0 / no property == no DFP
* 1 == DFP available */
if (env->insns_flags2 & PPC2_DFP) {
_FDT((fdt_property_cell(fdt, "ibm,dfp", 1)));
}
page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop,
sizeof(page_sizes_prop));
if (page_sizes_prop_size) {
_FDT((fdt_property(fdt, "ibm,segment-page-sizes",
page_sizes_prop, page_sizes_prop_size)));
}
_FDT((fdt_property_cell(fdt, "ibm,chip-id",
cs->cpu_index / cpus_per_socket)));
_FDT((fdt_end_node(fdt)));
}
_FDT((fdt_end_node(fdt)));
/* RTAS */
_FDT((fdt_begin_node(fdt, "rtas")));
if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {
add_str(hypertas, "hcall-multi-tce");
}
_FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str,
hypertas->len)));
g_string_free(hypertas, TRUE);
_FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str,
qemu_hypertas->len)));
g_string_free(qemu_hypertas, TRUE);
_FDT((fdt_property(fdt, "ibm,associativity-reference-points",
refpoints, sizeof(refpoints))));
_FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX)));
_FDT((fdt_end_node(fdt)));
/* interrupt controller */
_FDT((fdt_begin_node(fdt, "interrupt-controller")));
_FDT((fdt_property_string(fdt, "device_type",
"PowerPC-External-Interrupt-Presentation")));
_FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp")));
_FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
_FDT((fdt_property(fdt, "ibm,interrupt-server-ranges",
interrupt_server_ranges_prop,
sizeof(interrupt_server_ranges_prop))));
_FDT((fdt_property_cell(fdt, "#interrupt-cells", 2)));
_FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP)));
_FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP)));
_FDT((fdt_end_node(fdt)));
/* vdevice */
_FDT((fdt_begin_node(fdt, "vdevice")));
_FDT((fdt_property_string(fdt, "device_type", "vdevice")));
_FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice")));
_FDT((fdt_property_cell(fdt, "#address-cells", 0x1)));
_FDT((fdt_property_cell(fdt, "#size-cells", 0x0)));
_FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2)));
_FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
_FDT((fdt_end_node(fdt)));
/* event-sources */
spapr_events_fdt_skel(fdt, epow_irq);
/* /hypervisor node */
if (kvm_enabled()) {
uint8_t hypercall[16];
/* indicate KVM hypercall interface */
_FDT((fdt_begin_node(fdt, "hypervisor")));
_FDT((fdt_property_string(fdt, "compatible", "linux,kvm")));
if (kvmppc_has_cap_fixup_hcalls()) {
* Older KVM versions with older guest kernels were broken with the
* magic page, don't allow the guest to map it.
kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,
sizeof(hypercall));
_FDT((fdt_property(fdt, "hcall-instructions", hypercall,
sizeof(hypercall))));
}
_FDT((fdt_end_node(fdt)));
}
_FDT((fdt_end_node(fdt))); /* close root node */
_FDT((fdt_finish(fdt)));
return fdt;
} | true | qemu | 2e14072f9e859272c7b94b8e189bd30bb4954aa1 | static void *spapr_create_fdt_skel(hwaddr initrd_base,
hwaddr initrd_size,
hwaddr kernel_size,
bool little_endian,
const char *boot_device,
const char *kernel_cmdline,
uint32_t epow_irq)
{
void *fdt;
CPUState *cs;
uint32_t start_prop = cpu_to_be32(initrd_base);
uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size);
GString *hypertas = g_string_sized_new(256);
GString *qemu_hypertas = g_string_sized_new(256);
uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)};
uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(smp_cpus)};
int smt = kvmppc_smt_threads();
unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80};
QemuOpts *opts = qemu_opts_find(qemu_find_opts("smp-opts"), NULL);
unsigned sockets = opts ? qemu_opt_get_number(opts, "sockets", 0) : 0;
uint32_t cpus_per_socket = sockets ? (smp_cpus / sockets) : 1;
add_str(hypertas, "hcall-pft");
add_str(hypertas, "hcall-term");
add_str(hypertas, "hcall-dabr");
add_str(hypertas, "hcall-interrupt");
add_str(hypertas, "hcall-tce");
add_str(hypertas, "hcall-vio");
add_str(hypertas, "hcall-splpar");
add_str(hypertas, "hcall-bulk");
add_str(hypertas, "hcall-set-mode");
add_str(qemu_hypertas, "hcall-memop1");
fdt = g_malloc0(FDT_MAX_SIZE);
_FDT((fdt_create(fdt, FDT_MAX_SIZE)));
if (kernel_size) {
_FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size)));
}
if (initrd_size) {
_FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size)));
}
_FDT((fdt_finish_reservemap(fdt)));
_FDT((fdt_begin_node(fdt, "")));
_FDT((fdt_property_string(fdt, "device_type", "chrp")));
_FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)")));
_FDT((fdt_property_string(fdt, "compatible", "qemu,pseries")));
_FDT((fdt_property_cell(fdt, "#address-cells", 0x2)));
_FDT((fdt_property_cell(fdt, "#size-cells", 0x2)));
_FDT((fdt_begin_node(fdt, "chosen")));
_FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5))));
_FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline)));
_FDT((fdt_property(fdt, "linux,initrd-start",
&start_prop, sizeof(start_prop))));
_FDT((fdt_property(fdt, "linux,initrd-end",
&end_prop, sizeof(end_prop))));
if (kernel_size) {
uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),
cpu_to_be64(kernel_size) };
_FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop))));
if (little_endian) {
_FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0)));
}
}
if (boot_device) {
_FDT((fdt_property_string(fdt, "qemu,boot-device", boot_device)));
}
if (boot_menu) {
_FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu)));
}
_FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width)));
_FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height)));
_FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth)));
_FDT((fdt_end_node(fdt)));
_FDT((fdt_begin_node(fdt, "cpus")));
_FDT((fdt_property_cell(fdt, "#address-cells", 0x1)));
_FDT((fdt_property_cell(fdt, "#size-cells", 0x0)));
CPU_FOREACH(cs) {
PowerPCCPU *cpu = POWERPC_CPU(cs);
CPUPPCState *env = &cpu->env;
DeviceClass *dc = DEVICE_GET_CLASS(cs);
PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
int index = ppc_get_vcpu_dt_id(cpu);
char *nodename;
uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
0xffffffff, 0xffffffff};
uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ;
uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
uint32_t page_sizes_prop[64];
size_t page_sizes_prop_size;
if ((index % smt) != 0) {
continue;
}
nodename = g_strdup_printf("%s@%x", dc->fw_name, index);
_FDT((fdt_begin_node(fdt, nodename)));
g_free(nodename);
_FDT((fdt_property_cell(fdt, "reg", index)));
_FDT((fdt_property_string(fdt, "device_type", "cpu")));
_FDT((fdt_property_cell(fdt, "cpu-version", env->spr[SPR_PVR])));
_FDT((fdt_property_cell(fdt, "d-cache-block-size",
env->dcache_line_size)));
_FDT((fdt_property_cell(fdt, "d-cache-line-size",
env->dcache_line_size)));
_FDT((fdt_property_cell(fdt, "i-cache-block-size",
env->icache_line_size)));
_FDT((fdt_property_cell(fdt, "i-cache-line-size",
env->icache_line_size)));
if (pcc->l1_dcache_size) {
_FDT((fdt_property_cell(fdt, "d-cache-size", pcc->l1_dcache_size)));
} else {
fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n");
}
if (pcc->l1_icache_size) {
_FDT((fdt_property_cell(fdt, "i-cache-size", pcc->l1_icache_size)));
} else {
fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n");
}
_FDT((fdt_property_cell(fdt, "timebase-frequency", tbfreq)));
_FDT((fdt_property_cell(fdt, "clock-frequency", cpufreq)));
_FDT((fdt_property_cell(fdt, "ibm,slb-size", env->slb_nr)));
_FDT((fdt_property_string(fdt, "status", "okay")));
_FDT((fdt_property(fdt, "64-bit", NULL, 0)));
if (env->spr_cb[SPR_PURR].oea_read) {
_FDT((fdt_property(fdt, "ibm,purr", NULL, 0)));
}
if (env->mmu_model & POWERPC_MMU_1TSEG) {
_FDT((fdt_property(fdt, "ibm,processor-segment-sizes",
segs, sizeof(segs))));
}
if (env->insns_flags & PPC_ALTIVEC) {
uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1;
_FDT((fdt_property_cell(fdt, "ibm,vmx", vmx)));
}
if (env->insns_flags2 & PPC2_DFP) {
_FDT((fdt_property_cell(fdt, "ibm,dfp", 1)));
}
page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop,
sizeof(page_sizes_prop));
if (page_sizes_prop_size) {
_FDT((fdt_property(fdt, "ibm,segment-page-sizes",
page_sizes_prop, page_sizes_prop_size)));
}
_FDT((fdt_property_cell(fdt, "ibm,chip-id",
cs->cpu_index / cpus_per_socket)));
_FDT((fdt_end_node(fdt)));
}
_FDT((fdt_end_node(fdt)));
_FDT((fdt_begin_node(fdt, "rtas")));
if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {
add_str(hypertas, "hcall-multi-tce");
}
_FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str,
hypertas->len)));
g_string_free(hypertas, TRUE);
_FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str,
qemu_hypertas->len)));
g_string_free(qemu_hypertas, TRUE);
_FDT((fdt_property(fdt, "ibm,associativity-reference-points",
refpoints, sizeof(refpoints))));
_FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX)));
_FDT((fdt_end_node(fdt)));
_FDT((fdt_begin_node(fdt, "interrupt-controller")));
_FDT((fdt_property_string(fdt, "device_type",
"PowerPC-External-Interrupt-Presentation")));
_FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp")));
_FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
_FDT((fdt_property(fdt, "ibm,interrupt-server-ranges",
interrupt_server_ranges_prop,
sizeof(interrupt_server_ranges_prop))));
_FDT((fdt_property_cell(fdt, "#interrupt-cells", 2)));
_FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP)));
_FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP)));
_FDT((fdt_end_node(fdt)));
_FDT((fdt_begin_node(fdt, "vdevice")));
_FDT((fdt_property_string(fdt, "device_type", "vdevice")));
_FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice")));
_FDT((fdt_property_cell(fdt, "#address-cells", 0x1)));
_FDT((fdt_property_cell(fdt, "#size-cells", 0x0)));
_FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2)));
_FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
_FDT((fdt_end_node(fdt)));
spapr_events_fdt_skel(fdt, epow_irq);
if (kvm_enabled()) {
uint8_t hypercall[16];
_FDT((fdt_begin_node(fdt, "hypervisor")));
_FDT((fdt_property_string(fdt, "compatible", "linux,kvm")));
if (kvmppc_has_cap_fixup_hcalls()) {
* Older KVM versions with older guest kernels were broken with the
* magic page, don't allow the guest to map it.
kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,
sizeof(hypercall));
_FDT((fdt_property(fdt, "hcall-instructions", hypercall,
sizeof(hypercall))));
}
_FDT((fdt_end_node(fdt)));
}
_FDT((fdt_end_node(fdt)));
_FDT((fdt_finish(fdt)));
return fdt;
} | {
"code": [],
"line_no": []
} | static void *FUNC_0(hwaddr VAR_0,
hwaddr VAR_1,
hwaddr VAR_2,
bool VAR_3,
const char *VAR_4,
const char *VAR_5,
uint32_t VAR_6)
{
void *VAR_7;
CPUState *cs;
uint32_t start_prop = cpu_to_be32(VAR_0);
uint32_t end_prop = cpu_to_be32(VAR_0 + VAR_1);
GString *hypertas = g_string_sized_new(256);
GString *qemu_hypertas = g_string_sized_new(256);
uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)};
uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(smp_cpus)};
int VAR_8 = kvmppc_smt_threads();
unsigned char VAR_9[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80};
QemuOpts *opts = qemu_opts_find(qemu_find_opts("smp-opts"), NULL);
unsigned VAR_10 = opts ? qemu_opt_get_number(opts, "VAR_10", 0) : 0;
uint32_t cpus_per_socket = VAR_10 ? (smp_cpus / VAR_10) : 1;
add_str(hypertas, "hcall-pft");
add_str(hypertas, "hcall-term");
add_str(hypertas, "hcall-dabr");
add_str(hypertas, "hcall-interrupt");
add_str(hypertas, "hcall-tce");
add_str(hypertas, "hcall-vio");
add_str(hypertas, "hcall-splpar");
add_str(hypertas, "hcall-bulk");
add_str(hypertas, "hcall-set-mode");
add_str(qemu_hypertas, "hcall-memop1");
VAR_7 = g_malloc0(FDT_MAX_SIZE);
_FDT((fdt_create(VAR_7, FDT_MAX_SIZE)));
if (VAR_2) {
_FDT((fdt_add_reservemap_entry(VAR_7, KERNEL_LOAD_ADDR, VAR_2)));
}
if (VAR_1) {
_FDT((fdt_add_reservemap_entry(VAR_7, VAR_0, VAR_1)));
}
_FDT((fdt_finish_reservemap(VAR_7)));
_FDT((fdt_begin_node(VAR_7, "")));
_FDT((fdt_property_string(VAR_7, "device_type", "chrp")));
_FDT((fdt_property_string(VAR_7, "model", "IBM pSeries (emulated by qemu)")));
_FDT((fdt_property_string(VAR_7, "compatible", "qemu,pseries")));
_FDT((fdt_property_cell(VAR_7, "#address-cells", 0x2)));
_FDT((fdt_property_cell(VAR_7, "#size-cells", 0x2)));
_FDT((fdt_begin_node(VAR_7, "chosen")));
_FDT((fdt_property(VAR_7, "ibm,architecture-vec-5", VAR_9, sizeof(VAR_9))));
_FDT((fdt_property_string(VAR_7, "bootargs", VAR_5)));
_FDT((fdt_property(VAR_7, "linux,initrd-start",
&start_prop, sizeof(start_prop))));
_FDT((fdt_property(VAR_7, "linux,initrd-end",
&end_prop, sizeof(end_prop))));
if (VAR_2) {
uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),
cpu_to_be64(VAR_2) };
_FDT((fdt_property(VAR_7, "qemu,boot-kernel", &kprop, sizeof(kprop))));
if (VAR_3) {
_FDT((fdt_property(VAR_7, "qemu,boot-kernel-le", NULL, 0)));
}
}
if (VAR_4) {
_FDT((fdt_property_string(VAR_7, "qemu,boot-device", VAR_4)));
}
if (boot_menu) {
_FDT((fdt_property_cell(VAR_7, "qemu,boot-menu", boot_menu)));
}
_FDT((fdt_property_cell(VAR_7, "qemu,graphic-width", graphic_width)));
_FDT((fdt_property_cell(VAR_7, "qemu,graphic-height", graphic_height)));
_FDT((fdt_property_cell(VAR_7, "qemu,graphic-depth", graphic_depth)));
_FDT((fdt_end_node(VAR_7)));
_FDT((fdt_begin_node(VAR_7, "cpus")));
_FDT((fdt_property_cell(VAR_7, "#address-cells", 0x1)));
_FDT((fdt_property_cell(VAR_7, "#size-cells", 0x0)));
CPU_FOREACH(cs) {
PowerPCCPU *cpu = POWERPC_CPU(cs);
CPUPPCState *env = &cpu->env;
DeviceClass *dc = DEVICE_GET_CLASS(cs);
PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
int index = ppc_get_vcpu_dt_id(cpu);
char *nodename;
uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
0xffffffff, 0xffffffff};
uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ;
uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
uint32_t page_sizes_prop[64];
size_t page_sizes_prop_size;
if ((index % VAR_8) != 0) {
continue;
}
nodename = g_strdup_printf("%s@%x", dc->fw_name, index);
_FDT((fdt_begin_node(VAR_7, nodename)));
g_free(nodename);
_FDT((fdt_property_cell(VAR_7, "reg", index)));
_FDT((fdt_property_string(VAR_7, "device_type", "cpu")));
_FDT((fdt_property_cell(VAR_7, "cpu-version", env->spr[SPR_PVR])));
_FDT((fdt_property_cell(VAR_7, "d-cache-block-size",
env->dcache_line_size)));
_FDT((fdt_property_cell(VAR_7, "d-cache-line-size",
env->dcache_line_size)));
_FDT((fdt_property_cell(VAR_7, "i-cache-block-size",
env->icache_line_size)));
_FDT((fdt_property_cell(VAR_7, "i-cache-line-size",
env->icache_line_size)));
if (pcc->l1_dcache_size) {
_FDT((fdt_property_cell(VAR_7, "d-cache-size", pcc->l1_dcache_size)));
} else {
fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n");
}
if (pcc->l1_icache_size) {
_FDT((fdt_property_cell(VAR_7, "i-cache-size", pcc->l1_icache_size)));
} else {
fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n");
}
_FDT((fdt_property_cell(VAR_7, "timebase-frequency", tbfreq)));
_FDT((fdt_property_cell(VAR_7, "clock-frequency", cpufreq)));
_FDT((fdt_property_cell(VAR_7, "ibm,slb-size", env->slb_nr)));
_FDT((fdt_property_string(VAR_7, "status", "okay")));
_FDT((fdt_property(VAR_7, "64-bit", NULL, 0)));
if (env->spr_cb[SPR_PURR].oea_read) {
_FDT((fdt_property(VAR_7, "ibm,purr", NULL, 0)));
}
if (env->mmu_model & POWERPC_MMU_1TSEG) {
_FDT((fdt_property(VAR_7, "ibm,processor-segment-sizes",
segs, sizeof(segs))));
}
if (env->insns_flags & PPC_ALTIVEC) {
uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1;
_FDT((fdt_property_cell(VAR_7, "ibm,vmx", vmx)));
}
if (env->insns_flags2 & PPC2_DFP) {
_FDT((fdt_property_cell(VAR_7, "ibm,dfp", 1)));
}
page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop,
sizeof(page_sizes_prop));
if (page_sizes_prop_size) {
_FDT((fdt_property(VAR_7, "ibm,segment-page-sizes",
page_sizes_prop, page_sizes_prop_size)));
}
_FDT((fdt_property_cell(VAR_7, "ibm,chip-id",
cs->cpu_index / cpus_per_socket)));
_FDT((fdt_end_node(VAR_7)));
}
_FDT((fdt_end_node(VAR_7)));
_FDT((fdt_begin_node(VAR_7, "rtas")));
if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {
add_str(hypertas, "hcall-multi-tce");
}
_FDT((fdt_property(VAR_7, "ibm,hypertas-functions", hypertas->str,
hypertas->len)));
g_string_free(hypertas, TRUE);
_FDT((fdt_property(VAR_7, "qemu,hypertas-functions", qemu_hypertas->str,
qemu_hypertas->len)));
g_string_free(qemu_hypertas, TRUE);
_FDT((fdt_property(VAR_7, "ibm,associativity-reference-points",
refpoints, sizeof(refpoints))));
_FDT((fdt_property_cell(VAR_7, "rtas-error-log-max", RTAS_ERROR_LOG_MAX)));
_FDT((fdt_end_node(VAR_7)));
_FDT((fdt_begin_node(VAR_7, "interrupt-controller")));
_FDT((fdt_property_string(VAR_7, "device_type",
"PowerPC-External-Interrupt-Presentation")));
_FDT((fdt_property_string(VAR_7, "compatible", "IBM,ppc-xicp")));
_FDT((fdt_property(VAR_7, "interrupt-controller", NULL, 0)));
_FDT((fdt_property(VAR_7, "ibm,interrupt-server-ranges",
interrupt_server_ranges_prop,
sizeof(interrupt_server_ranges_prop))));
_FDT((fdt_property_cell(VAR_7, "#interrupt-cells", 2)));
_FDT((fdt_property_cell(VAR_7, "linux,phandle", PHANDLE_XICP)));
_FDT((fdt_property_cell(VAR_7, "phandle", PHANDLE_XICP)));
_FDT((fdt_end_node(VAR_7)));
_FDT((fdt_begin_node(VAR_7, "vdevice")));
_FDT((fdt_property_string(VAR_7, "device_type", "vdevice")));
_FDT((fdt_property_string(VAR_7, "compatible", "IBM,vdevice")));
_FDT((fdt_property_cell(VAR_7, "#address-cells", 0x1)));
_FDT((fdt_property_cell(VAR_7, "#size-cells", 0x0)));
_FDT((fdt_property_cell(VAR_7, "#interrupt-cells", 0x2)));
_FDT((fdt_property(VAR_7, "interrupt-controller", NULL, 0)));
_FDT((fdt_end_node(VAR_7)));
spapr_events_fdt_skel(VAR_7, VAR_6);
if (kvm_enabled()) {
uint8_t hypercall[16];
_FDT((fdt_begin_node(VAR_7, "hypervisor")));
_FDT((fdt_property_string(VAR_7, "compatible", "linux,kvm")));
if (kvmppc_has_cap_fixup_hcalls()) {
* Older KVM versions with older guest kernels were broken with the
* magic page, don't allow the guest to map it.
kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,
sizeof(hypercall));
_FDT((fdt_property(VAR_7, "hcall-instructions", hypercall,
sizeof(hypercall))));
}
_FDT((fdt_end_node(VAR_7)));
}
_FDT((fdt_end_node(VAR_7)));
_FDT((fdt_finish(VAR_7)));
return VAR_7;
} | [
"static void *FUNC_0(hwaddr VAR_0,\nhwaddr VAR_1,\nhwaddr VAR_2,\nbool VAR_3,\nconst char *VAR_4,\nconst char *VAR_5,\nuint32_t VAR_6)\n{",
"void *VAR_7;",
"CPUState *cs;",
"uint32_t start_prop = cpu_to_be32(VAR_0);",
"uint32_t end_prop = cpu_to_be32(VAR_0 + VAR_1);",
"GString *hypertas = g_string_sized_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,
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
],... |
14,190 | static void vga_screen_dump(void *opaque, const char *filename)
{
VGAState *s = (VGAState *)opaque;
if (!(s->ar_index & 0x20))
vga_screen_dump_blank(s, filename);
else if (s->gr[6] & 1)
vga_screen_dump_graphic(s, filename);
else
vga_screen_dump_text(s, filename);
}
| true | qemu | 9586fefefe383a9aa25ad99bde9a6b240309ca33 | static void vga_screen_dump(void *opaque, const char *filename)
{
VGAState *s = (VGAState *)opaque;
if (!(s->ar_index & 0x20))
vga_screen_dump_blank(s, filename);
else if (s->gr[6] & 1)
vga_screen_dump_graphic(s, filename);
else
vga_screen_dump_text(s, filename);
}
| {
"code": [
" if (!(s->ar_index & 0x20))",
" vga_screen_dump_blank(s, filename);",
" else if (s->gr[6] & 1)",
" vga_screen_dump_graphic(s, filename);"
],
"line_no": [
9,
11,
13,
15
]
} | static void FUNC_0(void *VAR_0, const char *VAR_1)
{
VGAState *s = (VGAState *)VAR_0;
if (!(s->ar_index & 0x20))
vga_screen_dump_blank(s, VAR_1);
else if (s->gr[6] & 1)
vga_screen_dump_graphic(s, VAR_1);
else
vga_screen_dump_text(s, VAR_1);
}
| [
"static void FUNC_0(void *VAR_0, const char *VAR_1)\n{",
"VGAState *s = (VGAState *)VAR_0;",
"if (!(s->ar_index & 0x20))\nvga_screen_dump_blank(s, VAR_1);",
"else if (s->gr[6] & 1)\nvga_screen_dump_graphic(s, VAR_1);",
"else\nvga_screen_dump_text(s, VAR_1);",
"}"
] | [
0,
0,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
9,
11
],
[
13,
15
],
[
17,
19
],
[
21
]
] |
14,191 | static void bamboo_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
const char *cpu_model)
{
unsigned int pci_irq_nrs[4] = { 28, 27, 26, 25 };
PCIBus *pcibus;
CPUState *env;
uint64_t elf_entry;
uint64_t elf_lowaddr;
target_phys_addr_t entry = 0;
target_phys_addr_t loadaddr = 0;
target_long initrd_size = 0;
int success;
int i;
/* Setup CPU. */
env = ppc440ep_init(&ram_size, &pcibus, pci_irq_nrs, 1, cpu_model);
if (pcibus) {
/* Register network interfaces. */
for (i = 0; i < nb_nics; i++) {
/* There are no PCI NICs on the Bamboo board, but there are
* PCI slots, so we can pick whatever default model we want. */
pci_nic_init_nofail(&nd_table[i], "e1000", NULL);
}
}
/* Load kernel. */
if (kernel_filename) {
success = load_uimage(kernel_filename, &entry, &loadaddr, NULL);
if (success < 0) {
success = load_elf(kernel_filename, NULL, NULL, &elf_entry,
&elf_lowaddr, NULL, 1, ELF_MACHINE, 0);
entry = elf_entry;
loadaddr = elf_lowaddr;
}
/* XXX try again as binary */
if (success < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
}
/* Load initrd. */
if (initrd_filename) {
initrd_size = load_image_targphys(initrd_filename, RAMDISK_ADDR,
ram_size - RAMDISK_ADDR);
if (initrd_size < 0) {
fprintf(stderr, "qemu: could not load ram disk '%s' at %x\n",
initrd_filename, RAMDISK_ADDR);
exit(1);
}
}
/* If we're loading a kernel directly, we must load the device tree too. */
if (kernel_filename) {
if (bamboo_load_device_tree(FDT_ADDR, ram_size, RAMDISK_ADDR,
initrd_size, kernel_cmdline) < 0) {
fprintf(stderr, "couldn't load device tree\n");
exit(1);
}
cpu_synchronize_state(env);
/* Set initial guest state. */
env->gpr[1] = (16<<20) - 8;
env->gpr[3] = FDT_ADDR;
env->nip = entry;
/* XXX we currently depend on KVM to create some initial TLB entries. */
}
if (kvm_enabled())
kvmppc_init();
}
| true | qemu | 64a4d100b502f24d0116437b9e5678c032a233e6 | static void bamboo_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
const char *cpu_model)
{
unsigned int pci_irq_nrs[4] = { 28, 27, 26, 25 };
PCIBus *pcibus;
CPUState *env;
uint64_t elf_entry;
uint64_t elf_lowaddr;
target_phys_addr_t entry = 0;
target_phys_addr_t loadaddr = 0;
target_long initrd_size = 0;
int success;
int i;
env = ppc440ep_init(&ram_size, &pcibus, pci_irq_nrs, 1, cpu_model);
if (pcibus) {
for (i = 0; i < nb_nics; i++) {
pci_nic_init_nofail(&nd_table[i], "e1000", NULL);
}
}
if (kernel_filename) {
success = load_uimage(kernel_filename, &entry, &loadaddr, NULL);
if (success < 0) {
success = load_elf(kernel_filename, NULL, NULL, &elf_entry,
&elf_lowaddr, NULL, 1, ELF_MACHINE, 0);
entry = elf_entry;
loadaddr = elf_lowaddr;
}
if (success < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
}
if (initrd_filename) {
initrd_size = load_image_targphys(initrd_filename, RAMDISK_ADDR,
ram_size - RAMDISK_ADDR);
if (initrd_size < 0) {
fprintf(stderr, "qemu: could not load ram disk '%s' at %x\n",
initrd_filename, RAMDISK_ADDR);
exit(1);
}
}
if (kernel_filename) {
if (bamboo_load_device_tree(FDT_ADDR, ram_size, RAMDISK_ADDR,
initrd_size, kernel_cmdline) < 0) {
fprintf(stderr, "couldn't load device tree\n");
exit(1);
}
cpu_synchronize_state(env);
env->gpr[1] = (16<<20) - 8;
env->gpr[3] = FDT_ADDR;
env->nip = entry;
}
if (kvm_enabled())
kvmppc_init();
}
| {
"code": [
" cpu_synchronize_state(env);",
" cpu_synchronize_state(env);"
],
"line_no": [
135,
135
]
} | static void FUNC_0(ram_addr_t VAR_0,
const char *VAR_1,
const char *VAR_2,
const char *VAR_3,
const char *VAR_4,
const char *VAR_5)
{
unsigned int VAR_6[4] = { 28, 27, 26, 25 };
PCIBus *pcibus;
CPUState *env;
uint64_t elf_entry;
uint64_t elf_lowaddr;
target_phys_addr_t entry = 0;
target_phys_addr_t loadaddr = 0;
target_long initrd_size = 0;
int VAR_7;
int VAR_8;
env = ppc440ep_init(&VAR_0, &pcibus, VAR_6, 1, VAR_5);
if (pcibus) {
for (VAR_8 = 0; VAR_8 < nb_nics; VAR_8++) {
pci_nic_init_nofail(&nd_table[VAR_8], "e1000", NULL);
}
}
if (VAR_2) {
VAR_7 = load_uimage(VAR_2, &entry, &loadaddr, NULL);
if (VAR_7 < 0) {
VAR_7 = load_elf(VAR_2, NULL, NULL, &elf_entry,
&elf_lowaddr, NULL, 1, ELF_MACHINE, 0);
entry = elf_entry;
loadaddr = elf_lowaddr;
}
if (VAR_7 < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n",
VAR_2);
exit(1);
}
}
if (VAR_4) {
initrd_size = load_image_targphys(VAR_4, RAMDISK_ADDR,
VAR_0 - RAMDISK_ADDR);
if (initrd_size < 0) {
fprintf(stderr, "qemu: could not load ram disk '%s' at %x\n",
VAR_4, RAMDISK_ADDR);
exit(1);
}
}
if (VAR_2) {
if (bamboo_load_device_tree(FDT_ADDR, VAR_0, RAMDISK_ADDR,
initrd_size, VAR_3) < 0) {
fprintf(stderr, "couldn't load device tree\n");
exit(1);
}
cpu_synchronize_state(env);
env->gpr[1] = (16<<20) - 8;
env->gpr[3] = FDT_ADDR;
env->nip = entry;
}
if (kvm_enabled())
kvmppc_init();
}
| [
"static void FUNC_0(ram_addr_t VAR_0,\nconst char *VAR_1,\nconst char *VAR_2,\nconst char *VAR_3,\nconst char *VAR_4,\nconst char *VAR_5)\n{",
"unsigned int VAR_6[4] = { 28, 27, 26, 25 };",
"PCIBus *pcibus;",
"CPUState *env;",
"uint64_t elf_entry;",
"uint64_t elf_lowaddr;",
"target_phys_addr_t entry = 0... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
39
],
[
43
],
[
47
],
[
53
],
[
55
],
[
57
],
[... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.