id
int32 0
27.3k
| func
stringlengths 26
142k
| target
bool 2
classes | project
stringclasses 2
values | commit_id
stringlengths 40
40
| func_clean
stringlengths 26
131k
| vul_lines
dict | normalized_func
stringlengths 24
132k
| lines
sequencelengths 1
2.8k
| label
sequencelengths 1
2.8k
| line_no
sequencelengths 1
2.8k
|
|---|---|---|---|---|---|---|---|---|---|---|
23,862 | PCIDevice *pci_try_create(PCIBus *bus, int devfn, const char *name)
{
return pci_try_create_multifunction(bus, devfn, false, name);
}
| false | qemu | a369da5f31ddbdeb32a7f76622e480d3995fbb00 | PCIDevice *pci_try_create(PCIBus *bus, int devfn, const char *name)
{
return pci_try_create_multifunction(bus, devfn, false, name);
}
| {
"code": [],
"line_no": []
} | PCIDevice *FUNC_0(PCIBus *bus, int devfn, const char *name)
{
return pci_try_create_multifunction(bus, devfn, false, name);
}
| [
"PCIDevice *FUNC_0(PCIBus *bus, int devfn, const char *name)\n{",
"return pci_try_create_multifunction(bus, devfn, false, name);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
23,863 | int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset,
int nb_sectors, enum qcow2_discard_type type, bool full_discard)
{
BDRVQcow2State *s = bs->opaque;
uint64_t end_offset;
unsigned int nb_clusters;
int ret;
end_offset = offset + (nb_sectors << BDRV_SECTOR_BITS);
/* Round start up and end down */
offset = align_offset(offset, s->cluster_size);
end_offset = start_of_cluster(s, end_offset);
if (offset > end_offset) {
return 0;
}
nb_clusters = size_to_clusters(s, end_offset - offset);
s->cache_discards = true;
/* Each L2 table is handled by its own loop iteration */
while (nb_clusters > 0) {
ret = discard_single_l2(bs, offset, nb_clusters, type, full_discard);
if (ret < 0) {
goto fail;
}
nb_clusters -= ret;
offset += (ret * s->cluster_size);
}
ret = 0;
fail:
s->cache_discards = false;
qcow2_process_discards(bs, ret);
return ret;
}
| false | qemu | b6d36def6d9e9fd187327182d0abafc9b7085d8f | int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset,
int nb_sectors, enum qcow2_discard_type type, bool full_discard)
{
BDRVQcow2State *s = bs->opaque;
uint64_t end_offset;
unsigned int nb_clusters;
int ret;
end_offset = offset + (nb_sectors << BDRV_SECTOR_BITS);
offset = align_offset(offset, s->cluster_size);
end_offset = start_of_cluster(s, end_offset);
if (offset > end_offset) {
return 0;
}
nb_clusters = size_to_clusters(s, end_offset - offset);
s->cache_discards = true;
while (nb_clusters > 0) {
ret = discard_single_l2(bs, offset, nb_clusters, type, full_discard);
if (ret < 0) {
goto fail;
}
nb_clusters -= ret;
offset += (ret * s->cluster_size);
}
ret = 0;
fail:
s->cache_discards = false;
qcow2_process_discards(bs, ret);
return ret;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,
int VAR_2, enum qcow2_discard_type VAR_3, bool VAR_4)
{
BDRVQcow2State *s = VAR_0->opaque;
uint64_t end_offset;
unsigned int VAR_5;
int VAR_6;
end_offset = VAR_1 + (VAR_2 << BDRV_SECTOR_BITS);
VAR_1 = align_offset(VAR_1, s->cluster_size);
end_offset = start_of_cluster(s, end_offset);
if (VAR_1 > end_offset) {
return 0;
}
VAR_5 = size_to_clusters(s, end_offset - VAR_1);
s->cache_discards = true;
while (VAR_5 > 0) {
VAR_6 = discard_single_l2(VAR_0, VAR_1, VAR_5, VAR_3, VAR_4);
if (VAR_6 < 0) {
goto fail;
}
VAR_5 -= VAR_6;
VAR_1 += (VAR_6 * s->cluster_size);
}
VAR_6 = 0;
fail:
s->cache_discards = false;
qcow2_process_discards(VAR_0, VAR_6);
return VAR_6;
}
| [
"int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,\nint VAR_2, enum qcow2_discard_type VAR_3, bool VAR_4)\n{",
"BDRVQcow2State *s = VAR_0->opaque;",
"uint64_t end_offset;",
"unsigned int VAR_5;",
"int VAR_6;",
"end_offset = VAR_1 + (VAR_2 << BDRV_SECTOR_BITS);",
"VAR_1 = align_offset(VAR_1, s->cluster_size);",
"end_offset = start_of_cluster(s, end_offset);",
"if (VAR_1 > end_offset) {",
"return 0;",
"}",
"VAR_5 = size_to_clusters(s, end_offset - VAR_1);",
"s->cache_discards = true;",
"while (VAR_5 > 0) {",
"VAR_6 = discard_single_l2(VAR_0, VAR_1, VAR_5, VAR_3, VAR_4);",
"if (VAR_6 < 0) {",
"goto fail;",
"}",
"VAR_5 -= VAR_6;",
"VAR_1 += (VAR_6 * s->cluster_size);",
"}",
"VAR_6 = 0;",
"fail:\ns->cache_discards = false;",
"qcow2_process_discards(VAR_0, VAR_6);",
"return VAR_6;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
37
],
[
41
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69,
71
],
[
73
],
[
77
],
[
79
]
] |
23,864 | int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes)
{
uint8_t buf[4096];
target_phys_addr_t dst_begin = dst_addr;
size_t want, did;
while (nbytes) {
want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;
did = read(fd, buf, want);
if (did != want) break;
cpu_physical_memory_write_rom(dst_addr, buf, did);
dst_addr += did;
nbytes -= did;
}
return dst_addr - dst_begin;
}
| false | qemu | 45a50b1668822c23afc2a89f724654e176518bc4 | int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes)
{
uint8_t buf[4096];
target_phys_addr_t dst_begin = dst_addr;
size_t want, did;
while (nbytes) {
want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;
did = read(fd, buf, want);
if (did != want) break;
cpu_physical_memory_write_rom(dst_addr, buf, did);
dst_addr += did;
nbytes -= did;
}
return dst_addr - dst_begin;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(int VAR_0, target_phys_addr_t VAR_1, size_t VAR_2)
{
uint8_t buf[4096];
target_phys_addr_t dst_begin = VAR_1;
size_t want, did;
while (VAR_2) {
want = VAR_2 > sizeof(buf) ? sizeof(buf) : VAR_2;
did = read(VAR_0, buf, want);
if (did != want) break;
cpu_physical_memory_write_rom(VAR_1, buf, did);
VAR_1 += did;
VAR_2 -= did;
}
return VAR_1 - dst_begin;
}
| [
"int FUNC_0(int VAR_0, target_phys_addr_t VAR_1, size_t VAR_2)\n{",
"uint8_t buf[4096];",
"target_phys_addr_t dst_begin = VAR_1;",
"size_t want, did;",
"while (VAR_2) {",
"want = VAR_2 > sizeof(buf) ? sizeof(buf) : VAR_2;",
"did = read(VAR_0, buf, want);",
"if (did != want) break;",
"cpu_physical_memory_write_rom(VAR_1, buf, did);",
"VAR_1 += did;",
"VAR_2 -= did;",
"}",
"return VAR_1 - dst_begin;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
23,865 | static int gxf_probe(AVProbeData *p) {
static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
if (p->buf_size < 16)
return 0;
if (!memcmp(p->buf, startcode, sizeof(startcode)) &&
!memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))
return AVPROBE_SCORE_MAX;
return 0;
}
| false | FFmpeg | 87e8788680e16c51f6048af26f3f7830c35207a5 | static int gxf_probe(AVProbeData *p) {
static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc};
static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
if (p->buf_size < 16)
return 0;
if (!memcmp(p->buf, startcode, sizeof(startcode)) &&
!memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))
return AVPROBE_SCORE_MAX;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVProbeData *VAR_0) {
static const uint8_t VAR_1[] = {0, 0, 0, 0, 1, 0xbc};
static const uint8_t VAR_2[] = {0, 0, 0, 0, 0xe1, 0xe2};
if (VAR_0->buf_size < 16)
return 0;
if (!memcmp(VAR_0->buf, VAR_1, sizeof(VAR_1)) &&
!memcmp(&VAR_0->buf[16 - sizeof(VAR_2)], VAR_2, sizeof(VAR_2)))
return AVPROBE_SCORE_MAX;
return 0;
}
| [
"static int FUNC_0(AVProbeData *VAR_0) {",
"static const uint8_t VAR_1[] = {0, 0, 0, 0, 1, 0xbc};",
"static const uint8_t VAR_2[] = {0, 0, 0, 0, 0xe1, 0xe2};",
"if (VAR_0->buf_size < 16)\nreturn 0;",
"if (!memcmp(VAR_0->buf, VAR_1, sizeof(VAR_1)) &&\n!memcmp(&VAR_0->buf[16 - sizeof(VAR_2)], VAR_2, sizeof(VAR_2)))\nreturn AVPROBE_SCORE_MAX;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7,
9
],
[
11,
13,
15
],
[
17
],
[
19
]
] |
23,866 | uint32_t cpu_inl(CPUState *env, pio_addr_t addr)
{
uint32_t val;
val = ioport_read(2, addr);
LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
return val;
}
| false | qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | uint32_t cpu_inl(CPUState *env, pio_addr_t addr)
{
uint32_t val;
val = ioport_read(2, addr);
LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
return val;
}
| {
"code": [],
"line_no": []
} | uint32_t FUNC_0(CPUState *env, pio_addr_t addr)
{
uint32_t val;
val = ioport_read(2, addr);
LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
return val;
}
| [
"uint32_t FUNC_0(CPUState *env, pio_addr_t addr)\n{",
"uint32_t val;",
"val = ioport_read(2, addr);",
"LOG_IOPORT(\"inl : %04\"FMT_pioaddr\" %08\"PRIx32\"\\n\", addr, val);",
"#ifdef CONFIG_KQEMU\nif (env)\nenv->last_io_time = cpu_get_time_fast();",
"#endif\nreturn val;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11,
13,
15
],
[
17,
19
],
[
21
]
] |
23,867 | e1000_receive(void *opaque, const uint8_t *buf, size_t size)
{
E1000State *s = opaque;
struct e1000_rx_desc desc;
target_phys_addr_t base;
unsigned int n, rdt;
uint32_t rdh_start;
uint16_t vlan_special = 0;
uint8_t vlan_status = 0, vlan_offset = 0;
if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))
return;
if (size > s->rxbuf_size) {
DBGOUT(RX, "packet too large for buffers (%lu > %d)\n",
(unsigned long)size, s->rxbuf_size);
return;
}
if (!receive_filter(s, buf, size))
return;
if (vlan_enabled(s) && is_vlan_packet(s, buf)) {
vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(buf + 14)));
memmove((void *)(buf + 4), buf, 12);
vlan_status = E1000_RXD_STAT_VP;
vlan_offset = 4;
size -= 4;
}
rdh_start = s->mac_reg[RDH];
size += 4; // for the header
do {
if (s->mac_reg[RDH] == s->mac_reg[RDT] && s->check_rxov) {
set_ics(s, 0, E1000_ICS_RXO);
return;
}
base = ((uint64_t)s->mac_reg[RDBAH] << 32) + s->mac_reg[RDBAL] +
sizeof(desc) * s->mac_reg[RDH];
cpu_physical_memory_read(base, (void *)&desc, sizeof(desc));
desc.special = vlan_special;
desc.status |= (vlan_status | E1000_RXD_STAT_DD);
if (desc.buffer_addr) {
cpu_physical_memory_write(le64_to_cpu(desc.buffer_addr),
(void *)(buf + vlan_offset), size);
desc.length = cpu_to_le16(size);
desc.status |= E1000_RXD_STAT_EOP|E1000_RXD_STAT_IXSM;
} else // as per intel docs; skip descriptors with null buf addr
DBGOUT(RX, "Null RX descriptor!!\n");
cpu_physical_memory_write(base, (void *)&desc, sizeof(desc));
if (++s->mac_reg[RDH] * sizeof(desc) >= s->mac_reg[RDLEN])
s->mac_reg[RDH] = 0;
s->check_rxov = 1;
/* see comment in start_xmit; same here */
if (s->mac_reg[RDH] == rdh_start) {
DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n",
rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
set_ics(s, 0, E1000_ICS_RXO);
return;
}
} while (desc.buffer_addr == 0);
s->mac_reg[GPRC]++;
s->mac_reg[TPR]++;
n = s->mac_reg[TORL];
if ((s->mac_reg[TORL] += size) < n)
s->mac_reg[TORH]++;
n = E1000_ICS_RXT0;
if ((rdt = s->mac_reg[RDT]) < s->mac_reg[RDH])
rdt += s->mac_reg[RDLEN] / sizeof(desc);
if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) <= s->mac_reg[RDLEN] >>
s->rxbuf_min_shift)
n |= E1000_ICS_RXDMT0;
set_ics(s, 0, n);
}
| false | qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 | e1000_receive(void *opaque, const uint8_t *buf, size_t size)
{
E1000State *s = opaque;
struct e1000_rx_desc desc;
target_phys_addr_t base;
unsigned int n, rdt;
uint32_t rdh_start;
uint16_t vlan_special = 0;
uint8_t vlan_status = 0, vlan_offset = 0;
if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))
return;
if (size > s->rxbuf_size) {
DBGOUT(RX, "packet too large for buffers (%lu > %d)\n",
(unsigned long)size, s->rxbuf_size);
return;
}
if (!receive_filter(s, buf, size))
return;
if (vlan_enabled(s) && is_vlan_packet(s, buf)) {
vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(buf + 14)));
memmove((void *)(buf + 4), buf, 12);
vlan_status = E1000_RXD_STAT_VP;
vlan_offset = 4;
size -= 4;
}
rdh_start = s->mac_reg[RDH];
size += 4;
do {
if (s->mac_reg[RDH] == s->mac_reg[RDT] && s->check_rxov) {
set_ics(s, 0, E1000_ICS_RXO);
return;
}
base = ((uint64_t)s->mac_reg[RDBAH] << 32) + s->mac_reg[RDBAL] +
sizeof(desc) * s->mac_reg[RDH];
cpu_physical_memory_read(base, (void *)&desc, sizeof(desc));
desc.special = vlan_special;
desc.status |= (vlan_status | E1000_RXD_STAT_DD);
if (desc.buffer_addr) {
cpu_physical_memory_write(le64_to_cpu(desc.buffer_addr),
(void *)(buf + vlan_offset), size);
desc.length = cpu_to_le16(size);
desc.status |= E1000_RXD_STAT_EOP|E1000_RXD_STAT_IXSM;
} else
DBGOUT(RX, "Null RX descriptor!!\n");
cpu_physical_memory_write(base, (void *)&desc, sizeof(desc));
if (++s->mac_reg[RDH] * sizeof(desc) >= s->mac_reg[RDLEN])
s->mac_reg[RDH] = 0;
s->check_rxov = 1;
if (s->mac_reg[RDH] == rdh_start) {
DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n",
rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
set_ics(s, 0, E1000_ICS_RXO);
return;
}
} while (desc.buffer_addr == 0);
s->mac_reg[GPRC]++;
s->mac_reg[TPR]++;
n = s->mac_reg[TORL];
if ((s->mac_reg[TORL] += size) < n)
s->mac_reg[TORH]++;
n = E1000_ICS_RXT0;
if ((rdt = s->mac_reg[RDT]) < s->mac_reg[RDH])
rdt += s->mac_reg[RDLEN] / sizeof(desc);
if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) <= s->mac_reg[RDLEN] >>
s->rxbuf_min_shift)
n |= E1000_ICS_RXDMT0;
set_ics(s, 0, n);
}
| {
"code": [],
"line_no": []
} | FUNC_0(void *VAR_0, const uint8_t *VAR_1, size_t VAR_2)
{
E1000State *s = VAR_0;
struct e1000_rx_desc VAR_3;
target_phys_addr_t base;
unsigned int VAR_4, VAR_5;
uint32_t rdh_start;
uint16_t vlan_special = 0;
uint8_t vlan_status = 0, vlan_offset = 0;
if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))
return;
if (VAR_2 > s->rxbuf_size) {
DBGOUT(RX, "packet too large for buffers (%lu > %d)\VAR_4",
(unsigned long)VAR_2, s->rxbuf_size);
return;
}
if (!receive_filter(s, VAR_1, VAR_2))
return;
if (vlan_enabled(s) && is_vlan_packet(s, VAR_1)) {
vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(VAR_1 + 14)));
memmove((void *)(VAR_1 + 4), VAR_1, 12);
vlan_status = E1000_RXD_STAT_VP;
vlan_offset = 4;
VAR_2 -= 4;
}
rdh_start = s->mac_reg[RDH];
VAR_2 += 4;
do {
if (s->mac_reg[RDH] == s->mac_reg[RDT] && s->check_rxov) {
set_ics(s, 0, E1000_ICS_RXO);
return;
}
base = ((uint64_t)s->mac_reg[RDBAH] << 32) + s->mac_reg[RDBAL] +
sizeof(VAR_3) * s->mac_reg[RDH];
cpu_physical_memory_read(base, (void *)&VAR_3, sizeof(VAR_3));
VAR_3.special = vlan_special;
VAR_3.status |= (vlan_status | E1000_RXD_STAT_DD);
if (VAR_3.buffer_addr) {
cpu_physical_memory_write(le64_to_cpu(VAR_3.buffer_addr),
(void *)(VAR_1 + vlan_offset), VAR_2);
VAR_3.length = cpu_to_le16(VAR_2);
VAR_3.status |= E1000_RXD_STAT_EOP|E1000_RXD_STAT_IXSM;
} else
DBGOUT(RX, "Null RX descriptor!!\VAR_4");
cpu_physical_memory_write(base, (void *)&VAR_3, sizeof(VAR_3));
if (++s->mac_reg[RDH] * sizeof(VAR_3) >= s->mac_reg[RDLEN])
s->mac_reg[RDH] = 0;
s->check_rxov = 1;
if (s->mac_reg[RDH] == rdh_start) {
DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\VAR_4",
rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
set_ics(s, 0, E1000_ICS_RXO);
return;
}
} while (VAR_3.buffer_addr == 0);
s->mac_reg[GPRC]++;
s->mac_reg[TPR]++;
VAR_4 = s->mac_reg[TORL];
if ((s->mac_reg[TORL] += VAR_2) < VAR_4)
s->mac_reg[TORH]++;
VAR_4 = E1000_ICS_RXT0;
if ((VAR_5 = s->mac_reg[RDT]) < s->mac_reg[RDH])
VAR_5 += s->mac_reg[RDLEN] / sizeof(VAR_3);
if (((VAR_5 - s->mac_reg[RDH]) * sizeof(VAR_3)) <= s->mac_reg[RDLEN] >>
s->rxbuf_min_shift)
VAR_4 |= E1000_ICS_RXDMT0;
set_ics(s, 0, VAR_4);
}
| [
"FUNC_0(void *VAR_0, const uint8_t *VAR_1, size_t VAR_2)\n{",
"E1000State *s = VAR_0;",
"struct e1000_rx_desc VAR_3;",
"target_phys_addr_t base;",
"unsigned int VAR_4, VAR_5;",
"uint32_t rdh_start;",
"uint16_t vlan_special = 0;",
"uint8_t vlan_status = 0, vlan_offset = 0;",
"if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))\nreturn;",
"if (VAR_2 > s->rxbuf_size) {",
"DBGOUT(RX, \"packet too large for buffers (%lu > %d)\\VAR_4\",\n(unsigned long)VAR_2, s->rxbuf_size);",
"return;",
"}",
"if (!receive_filter(s, VAR_1, VAR_2))\nreturn;",
"if (vlan_enabled(s) && is_vlan_packet(s, VAR_1)) {",
"vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(VAR_1 + 14)));",
"memmove((void *)(VAR_1 + 4), VAR_1, 12);",
"vlan_status = E1000_RXD_STAT_VP;",
"vlan_offset = 4;",
"VAR_2 -= 4;",
"}",
"rdh_start = s->mac_reg[RDH];",
"VAR_2 += 4;",
"do {",
"if (s->mac_reg[RDH] == s->mac_reg[RDT] && s->check_rxov) {",
"set_ics(s, 0, E1000_ICS_RXO);",
"return;",
"}",
"base = ((uint64_t)s->mac_reg[RDBAH] << 32) + s->mac_reg[RDBAL] +\nsizeof(VAR_3) * s->mac_reg[RDH];",
"cpu_physical_memory_read(base, (void *)&VAR_3, sizeof(VAR_3));",
"VAR_3.special = vlan_special;",
"VAR_3.status |= (vlan_status | E1000_RXD_STAT_DD);",
"if (VAR_3.buffer_addr) {",
"cpu_physical_memory_write(le64_to_cpu(VAR_3.buffer_addr),\n(void *)(VAR_1 + vlan_offset), VAR_2);",
"VAR_3.length = cpu_to_le16(VAR_2);",
"VAR_3.status |= E1000_RXD_STAT_EOP|E1000_RXD_STAT_IXSM;",
"} else",
"DBGOUT(RX, \"Null RX descriptor!!\\VAR_4\");",
"cpu_physical_memory_write(base, (void *)&VAR_3, sizeof(VAR_3));",
"if (++s->mac_reg[RDH] * sizeof(VAR_3) >= s->mac_reg[RDLEN])\ns->mac_reg[RDH] = 0;",
"s->check_rxov = 1;",
"if (s->mac_reg[RDH] == rdh_start) {",
"DBGOUT(RXERR, \"RDH wraparound @%x, RDT %x, RDLEN %x\\VAR_4\",\nrdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);",
"set_ics(s, 0, E1000_ICS_RXO);",
"return;",
"}",
"} while (VAR_3.buffer_addr == 0);",
"s->mac_reg[GPRC]++;",
"s->mac_reg[TPR]++;",
"VAR_4 = s->mac_reg[TORL];",
"if ((s->mac_reg[TORL] += VAR_2) < VAR_4)\ns->mac_reg[TORH]++;",
"VAR_4 = E1000_ICS_RXT0;",
"if ((VAR_5 = s->mac_reg[RDT]) < s->mac_reg[RDH])\nVAR_5 += s->mac_reg[RDLEN] / sizeof(VAR_3);",
"if (((VAR_5 - s->mac_reg[RDH]) * sizeof(VAR_3)) <= s->mac_reg[RDLEN] >>\ns->rxbuf_min_shift)\nVAR_4 |= E1000_ICS_RXDMT0;",
"set_ics(s, 0, VAR_4);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21,
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
39,
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75,
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103,
105
],
[
107
],
[
111
],
[
113,
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
127
],
[
129
],
[
131
],
[
133,
135
],
[
139
],
[
141,
143
],
[
145,
147,
149
],
[
153
],
[
155
]
] |
23,868 | static uint64_t omap_mcbsp_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
int offset = addr & OMAP_MPUI_REG_MASK;
uint16_t ret;
if (size != 2) {
return omap_badwidth_read16(opaque, addr);
}
switch (offset) {
case 0x00: /* DRR2 */
if (((s->rcr[0] >> 5) & 7) < 3) /* RWDLEN1 */
return 0x0000;
/* Fall through. */
case 0x02: /* DRR1 */
if (s->rx_req < 2) {
printf("%s: Rx FIFO underrun\n", __FUNCTION__);
omap_mcbsp_rx_done(s);
} else {
s->tx_req -= 2;
if (s->codec && s->codec->in.len >= 2) {
ret = s->codec->in.fifo[s->codec->in.start ++] << 8;
ret |= s->codec->in.fifo[s->codec->in.start ++];
s->codec->in.len -= 2;
} else
ret = 0x0000;
if (!s->tx_req)
omap_mcbsp_rx_done(s);
return ret;
}
return 0x0000;
case 0x04: /* DXR2 */
case 0x06: /* DXR1 */
return 0x0000;
case 0x08: /* SPCR2 */
return s->spcr[1];
case 0x0a: /* SPCR1 */
return s->spcr[0];
case 0x0c: /* RCR2 */
return s->rcr[1];
case 0x0e: /* RCR1 */
return s->rcr[0];
case 0x10: /* XCR2 */
return s->xcr[1];
case 0x12: /* XCR1 */
return s->xcr[0];
case 0x14: /* SRGR2 */
return s->srgr[1];
case 0x16: /* SRGR1 */
return s->srgr[0];
case 0x18: /* MCR2 */
return s->mcr[1];
case 0x1a: /* MCR1 */
return s->mcr[0];
case 0x1c: /* RCERA */
return s->rcer[0];
case 0x1e: /* RCERB */
return s->rcer[1];
case 0x20: /* XCERA */
return s->xcer[0];
case 0x22: /* XCERB */
return s->xcer[1];
case 0x24: /* PCR0 */
return s->pcr;
case 0x26: /* RCERC */
return s->rcer[2];
case 0x28: /* RCERD */
return s->rcer[3];
case 0x2a: /* XCERC */
return s->xcer[2];
case 0x2c: /* XCERD */
return s->xcer[3];
case 0x2e: /* RCERE */
return s->rcer[4];
case 0x30: /* RCERF */
return s->rcer[5];
case 0x32: /* XCERE */
return s->xcer[4];
case 0x34: /* XCERF */
return s->xcer[5];
case 0x36: /* RCERG */
return s->rcer[6];
case 0x38: /* RCERH */
return s->rcer[7];
case 0x3a: /* XCERG */
return s->xcer[6];
case 0x3c: /* XCERH */
return s->xcer[7];
}
OMAP_BAD_REG(addr);
return 0;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static uint64_t omap_mcbsp_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
int offset = addr & OMAP_MPUI_REG_MASK;
uint16_t ret;
if (size != 2) {
return omap_badwidth_read16(opaque, addr);
}
switch (offset) {
case 0x00:
if (((s->rcr[0] >> 5) & 7) < 3)
return 0x0000;
case 0x02:
if (s->rx_req < 2) {
printf("%s: Rx FIFO underrun\n", __FUNCTION__);
omap_mcbsp_rx_done(s);
} else {
s->tx_req -= 2;
if (s->codec && s->codec->in.len >= 2) {
ret = s->codec->in.fifo[s->codec->in.start ++] << 8;
ret |= s->codec->in.fifo[s->codec->in.start ++];
s->codec->in.len -= 2;
} else
ret = 0x0000;
if (!s->tx_req)
omap_mcbsp_rx_done(s);
return ret;
}
return 0x0000;
case 0x04:
case 0x06:
return 0x0000;
case 0x08:
return s->spcr[1];
case 0x0a:
return s->spcr[0];
case 0x0c:
return s->rcr[1];
case 0x0e:
return s->rcr[0];
case 0x10:
return s->xcr[1];
case 0x12:
return s->xcr[0];
case 0x14:
return s->srgr[1];
case 0x16:
return s->srgr[0];
case 0x18:
return s->mcr[1];
case 0x1a:
return s->mcr[0];
case 0x1c:
return s->rcer[0];
case 0x1e:
return s->rcer[1];
case 0x20:
return s->xcer[0];
case 0x22:
return s->xcer[1];
case 0x24:
return s->pcr;
case 0x26:
return s->rcer[2];
case 0x28:
return s->rcer[3];
case 0x2a:
return s->xcer[2];
case 0x2c:
return s->xcer[3];
case 0x2e:
return s->rcer[4];
case 0x30:
return s->rcer[5];
case 0x32:
return s->xcer[4];
case 0x34:
return s->xcer[5];
case 0x36:
return s->rcer[6];
case 0x38:
return s->rcer[7];
case 0x3a:
return s->xcer[6];
case 0x3c:
return s->xcer[7];
}
OMAP_BAD_REG(addr);
return 0;
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,
unsigned size)
{
struct omap_mcbsp_s *VAR_0 = (struct omap_mcbsp_s *) opaque;
int VAR_1 = addr & OMAP_MPUI_REG_MASK;
uint16_t ret;
if (size != 2) {
return omap_badwidth_read16(opaque, addr);
}
switch (VAR_1) {
case 0x00:
if (((VAR_0->rcr[0] >> 5) & 7) < 3)
return 0x0000;
case 0x02:
if (VAR_0->rx_req < 2) {
printf("%VAR_0: Rx FIFO underrun\n", __FUNCTION__);
omap_mcbsp_rx_done(VAR_0);
} else {
VAR_0->tx_req -= 2;
if (VAR_0->codec && VAR_0->codec->in.len >= 2) {
ret = VAR_0->codec->in.fifo[VAR_0->codec->in.start ++] << 8;
ret |= VAR_0->codec->in.fifo[VAR_0->codec->in.start ++];
VAR_0->codec->in.len -= 2;
} else
ret = 0x0000;
if (!VAR_0->tx_req)
omap_mcbsp_rx_done(VAR_0);
return ret;
}
return 0x0000;
case 0x04:
case 0x06:
return 0x0000;
case 0x08:
return VAR_0->spcr[1];
case 0x0a:
return VAR_0->spcr[0];
case 0x0c:
return VAR_0->rcr[1];
case 0x0e:
return VAR_0->rcr[0];
case 0x10:
return VAR_0->xcr[1];
case 0x12:
return VAR_0->xcr[0];
case 0x14:
return VAR_0->srgr[1];
case 0x16:
return VAR_0->srgr[0];
case 0x18:
return VAR_0->mcr[1];
case 0x1a:
return VAR_0->mcr[0];
case 0x1c:
return VAR_0->rcer[0];
case 0x1e:
return VAR_0->rcer[1];
case 0x20:
return VAR_0->xcer[0];
case 0x22:
return VAR_0->xcer[1];
case 0x24:
return VAR_0->pcr;
case 0x26:
return VAR_0->rcer[2];
case 0x28:
return VAR_0->rcer[3];
case 0x2a:
return VAR_0->xcer[2];
case 0x2c:
return VAR_0->xcer[3];
case 0x2e:
return VAR_0->rcer[4];
case 0x30:
return VAR_0->rcer[5];
case 0x32:
return VAR_0->xcer[4];
case 0x34:
return VAR_0->xcer[5];
case 0x36:
return VAR_0->rcer[6];
case 0x38:
return VAR_0->rcer[7];
case 0x3a:
return VAR_0->xcer[6];
case 0x3c:
return VAR_0->xcer[7];
}
OMAP_BAD_REG(addr);
return 0;
}
| [
"static uint64_t FUNC_0(void *opaque, target_phys_addr_t addr,\nunsigned size)\n{",
"struct omap_mcbsp_s *VAR_0 = (struct omap_mcbsp_s *) opaque;",
"int VAR_1 = addr & OMAP_MPUI_REG_MASK;",
"uint16_t ret;",
"if (size != 2) {",
"return omap_badwidth_read16(opaque, addr);",
"}",
"switch (VAR_1) {",
"case 0x00:\nif (((VAR_0->rcr[0] >> 5) & 7) < 3)\nreturn 0x0000;",
"case 0x02:\nif (VAR_0->rx_req < 2) {",
"printf(\"%VAR_0: Rx FIFO underrun\\n\", __FUNCTION__);",
"omap_mcbsp_rx_done(VAR_0);",
"} else {",
"VAR_0->tx_req -= 2;",
"if (VAR_0->codec && VAR_0->codec->in.len >= 2) {",
"ret = VAR_0->codec->in.fifo[VAR_0->codec->in.start ++] << 8;",
"ret |= VAR_0->codec->in.fifo[VAR_0->codec->in.start ++];",
"VAR_0->codec->in.len -= 2;",
"} else",
"ret = 0x0000;",
"if (!VAR_0->tx_req)\nomap_mcbsp_rx_done(VAR_0);",
"return ret;",
"}",
"return 0x0000;",
"case 0x04:\ncase 0x06:\nreturn 0x0000;",
"case 0x08:\nreturn VAR_0->spcr[1];",
"case 0x0a:\nreturn VAR_0->spcr[0];",
"case 0x0c:\nreturn VAR_0->rcr[1];",
"case 0x0e:\nreturn VAR_0->rcr[0];",
"case 0x10:\nreturn VAR_0->xcr[1];",
"case 0x12:\nreturn VAR_0->xcr[0];",
"case 0x14:\nreturn VAR_0->srgr[1];",
"case 0x16:\nreturn VAR_0->srgr[0];",
"case 0x18:\nreturn VAR_0->mcr[1];",
"case 0x1a:\nreturn VAR_0->mcr[0];",
"case 0x1c:\nreturn VAR_0->rcer[0];",
"case 0x1e:\nreturn VAR_0->rcer[1];",
"case 0x20:\nreturn VAR_0->xcer[0];",
"case 0x22:\nreturn VAR_0->xcer[1];",
"case 0x24:\nreturn VAR_0->pcr;",
"case 0x26:\nreturn VAR_0->rcer[2];",
"case 0x28:\nreturn VAR_0->rcer[3];",
"case 0x2a:\nreturn VAR_0->xcer[2];",
"case 0x2c:\nreturn VAR_0->xcer[3];",
"case 0x2e:\nreturn VAR_0->rcer[4];",
"case 0x30:\nreturn VAR_0->rcer[5];",
"case 0x32:\nreturn VAR_0->xcer[4];",
"case 0x34:\nreturn VAR_0->xcer[5];",
"case 0x36:\nreturn VAR_0->rcer[6];",
"case 0x38:\nreturn VAR_0->rcer[7];",
"case 0x3a:\nreturn VAR_0->xcer[6];",
"case 0x3c:\nreturn VAR_0->xcer[7];",
"}",
"OMAP_BAD_REG(addr);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25,
27,
29
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
69,
71,
73
],
[
77,
79
],
[
81,
83
],
[
85,
87
],
[
89,
91
],
[
93,
95
],
[
97,
99
],
[
101,
103
],
[
105,
107
],
[
109,
111
],
[
113,
115
],
[
117,
119
],
[
121,
123
],
[
125,
127
],
[
129,
131
],
[
133,
135
],
[
137,
139
],
[
141,
143
],
[
145,
147
],
[
149,
151
],
[
153,
155
],
[
157,
159
],
[
161,
163
],
[
165,
167
],
[
169,
171
],
[
173,
175
],
[
177,
179
],
[
181,
183
],
[
185
],
[
189
],
[
191
],
[
193
]
] |
23,869 | static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req)
{
int status = VIRTIO_BLK_S_OK;
struct virtio_scsi_inhdr *scsi = NULL;
VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
VirtQueueElement *elem = &req->elem;
VirtIOBlock *blk = req->dev;
#ifdef __linux__
int i;
VirtIOBlockIoctlReq *ioctl_req;
#endif
/*
* We require at least one output segment each for the virtio_blk_outhdr
* and the SCSI command block.
*
* We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
* and the sense buffer pointer in the input segments.
*/
if (elem->out_num < 2 || elem->in_num < 3) {
status = VIRTIO_BLK_S_IOERR;
goto fail;
}
/*
* The scsi inhdr is placed in the second-to-last input segment, just
* before the regular inhdr.
*/
scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
if (!blk->conf.scsi) {
status = VIRTIO_BLK_S_UNSUPP;
goto fail;
}
/*
* No support for bidirection commands yet.
*/
if (elem->out_num > 2 && elem->in_num > 3) {
status = VIRTIO_BLK_S_UNSUPP;
goto fail;
}
#ifdef __linux__
ioctl_req = g_new0(VirtIOBlockIoctlReq, 1);
ioctl_req->req = req;
ioctl_req->hdr.interface_id = 'S';
ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len;
ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base;
ioctl_req->hdr.dxfer_len = 0;
if (elem->out_num > 2) {
/*
* If there are more than the minimally required 2 output segments
* there is write payload starting from the third iovec.
*/
ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV;
ioctl_req->hdr.iovec_count = elem->out_num - 2;
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len;
}
ioctl_req->hdr.dxferp = elem->out_sg + 2;
} else if (elem->in_num > 3) {
/*
* If we have more than 3 input segments the guest wants to actually
* read data.
*/
ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV;
ioctl_req->hdr.iovec_count = elem->in_num - 3;
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len;
}
ioctl_req->hdr.dxferp = elem->in_sg;
} else {
/*
* Some SCSI commands don't actually transfer any data.
*/
ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE;
}
ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;
ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;
blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr,
virtio_blk_ioctl_complete, ioctl_req);
return -EINPROGRESS;
#else
abort();
#endif
fail:
/* Just put anything nonzero so that the ioctl fails in the guest. */
if (scsi) {
virtio_stl_p(vdev, &scsi->errors, 255);
}
return status;
}
| false | qemu | a209f4615c6853a226e847810b6c607c71b6a046 | static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req)
{
int status = VIRTIO_BLK_S_OK;
struct virtio_scsi_inhdr *scsi = NULL;
VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
VirtQueueElement *elem = &req->elem;
VirtIOBlock *blk = req->dev;
#ifdef __linux__
int i;
VirtIOBlockIoctlReq *ioctl_req;
#endif
if (elem->out_num < 2 || elem->in_num < 3) {
status = VIRTIO_BLK_S_IOERR;
goto fail;
}
scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
if (!blk->conf.scsi) {
status = VIRTIO_BLK_S_UNSUPP;
goto fail;
}
if (elem->out_num > 2 && elem->in_num > 3) {
status = VIRTIO_BLK_S_UNSUPP;
goto fail;
}
#ifdef __linux__
ioctl_req = g_new0(VirtIOBlockIoctlReq, 1);
ioctl_req->req = req;
ioctl_req->hdr.interface_id = 'S';
ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len;
ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base;
ioctl_req->hdr.dxfer_len = 0;
if (elem->out_num > 2) {
ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV;
ioctl_req->hdr.iovec_count = elem->out_num - 2;
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len;
}
ioctl_req->hdr.dxferp = elem->out_sg + 2;
} else if (elem->in_num > 3) {
ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV;
ioctl_req->hdr.iovec_count = elem->in_num - 3;
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len;
}
ioctl_req->hdr.dxferp = elem->in_sg;
} else {
ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE;
}
ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;
ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;
blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr,
virtio_blk_ioctl_complete, ioctl_req);
return -EINPROGRESS;
#else
abort();
#endif
fail:
if (scsi) {
virtio_stl_p(vdev, &scsi->errors, 255);
}
return status;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(VirtIOBlockReq *VAR_0)
{
int VAR_1 = VIRTIO_BLK_S_OK;
struct virtio_scsi_inhdr *VAR_2 = NULL;
VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0->dev);
VirtQueueElement *elem = &VAR_0->elem;
VirtIOBlock *blk = VAR_0->dev;
#ifdef __linux__
int i;
VirtIOBlockIoctlReq *ioctl_req;
#endif
if (elem->out_num < 2 || elem->in_num < 3) {
VAR_1 = VIRTIO_BLK_S_IOERR;
goto fail;
}
VAR_2 = (void *)elem->in_sg[elem->in_num - 2].iov_base;
if (!blk->conf.VAR_2) {
VAR_1 = VIRTIO_BLK_S_UNSUPP;
goto fail;
}
if (elem->out_num > 2 && elem->in_num > 3) {
VAR_1 = VIRTIO_BLK_S_UNSUPP;
goto fail;
}
#ifdef __linux__
ioctl_req = g_new0(VirtIOBlockIoctlReq, 1);
ioctl_req->VAR_0 = VAR_0;
ioctl_req->hdr.interface_id = 'S';
ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len;
ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base;
ioctl_req->hdr.dxfer_len = 0;
if (elem->out_num > 2) {
ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV;
ioctl_req->hdr.iovec_count = elem->out_num - 2;
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len;
}
ioctl_req->hdr.dxferp = elem->out_sg + 2;
} else if (elem->in_num > 3) {
ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV;
ioctl_req->hdr.iovec_count = elem->in_num - 3;
for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len;
}
ioctl_req->hdr.dxferp = elem->in_sg;
} else {
ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE;
}
ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;
ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;
blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr,
virtio_blk_ioctl_complete, ioctl_req);
return -EINPROGRESS;
#else
abort();
#endif
fail:
if (VAR_2) {
virtio_stl_p(vdev, &VAR_2->errors, 255);
}
return VAR_1;
}
| [
"static int FUNC_0(VirtIOBlockReq *VAR_0)\n{",
"int VAR_1 = VIRTIO_BLK_S_OK;",
"struct virtio_scsi_inhdr *VAR_2 = NULL;",
"VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0->dev);",
"VirtQueueElement *elem = &VAR_0->elem;",
"VirtIOBlock *blk = VAR_0->dev;",
"#ifdef __linux__\nint i;",
"VirtIOBlockIoctlReq *ioctl_req;",
"#endif\nif (elem->out_num < 2 || elem->in_num < 3) {",
"VAR_1 = VIRTIO_BLK_S_IOERR;",
"goto fail;",
"}",
"VAR_2 = (void *)elem->in_sg[elem->in_num - 2].iov_base;",
"if (!blk->conf.VAR_2) {",
"VAR_1 = VIRTIO_BLK_S_UNSUPP;",
"goto fail;",
"}",
"if (elem->out_num > 2 && elem->in_num > 3) {",
"VAR_1 = VIRTIO_BLK_S_UNSUPP;",
"goto fail;",
"}",
"#ifdef __linux__\nioctl_req = g_new0(VirtIOBlockIoctlReq, 1);",
"ioctl_req->VAR_0 = VAR_0;",
"ioctl_req->hdr.interface_id = 'S';",
"ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len;",
"ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base;",
"ioctl_req->hdr.dxfer_len = 0;",
"if (elem->out_num > 2) {",
"ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV;",
"ioctl_req->hdr.iovec_count = elem->out_num - 2;",
"for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {",
"ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len;",
"}",
"ioctl_req->hdr.dxferp = elem->out_sg + 2;",
"} else if (elem->in_num > 3) {",
"ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV;",
"ioctl_req->hdr.iovec_count = elem->in_num - 3;",
"for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {",
"ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len;",
"}",
"ioctl_req->hdr.dxferp = elem->in_sg;",
"} else {",
"ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE;",
"}",
"ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;",
"ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;",
"blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr,\nvirtio_blk_ioctl_complete, ioctl_req);",
"return -EINPROGRESS;",
"#else\nabort();",
"#endif\nfail:\nif (VAR_2) {",
"virtio_stl_p(vdev, &VAR_2->errors, 255);",
"}",
"return VAR_1;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
41
],
[
43
],
[
45
],
[
47
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89,
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
115
],
[
117
],
[
121
],
[
123
],
[
125
],
[
129
],
[
133
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
165
],
[
167
],
[
171
],
[
173
],
[
177,
179
],
[
181
],
[
183,
185
],
[
187,
191,
195
],
[
197
],
[
199
],
[
201
],
[
203
]
] |
23,873 | static int targa_decode_rle(AVCodecContext *avctx, TargaContext *s, const uint8_t *src, int src_size, uint8_t *dst, int w, int h, int stride, int bpp)
{
int i, x, y;
int depth = (bpp + 1) >> 3;
int type, count;
int diff;
const uint8_t *src_end = src + src_size;
diff = stride - w * depth;
x = y = 0;
while(y < h){
CHECK_BUFFER_SIZE(src, src_end, 1, "image type");
type = *src++;
count = (type & 0x7F) + 1;
type &= 0x80;
if((x + count > w) && (x + count + 1 > (h - y) * w)){
av_log(avctx, AV_LOG_ERROR, "Packet went out of bounds: position (%i,%i) size %i\n", x, y, count);
return -1;
}
if(type){
CHECK_BUFFER_SIZE(src, src_end, depth, "image data");
}else{
CHECK_BUFFER_SIZE(src, src_end, count * depth, "image data");
}
for(i = 0; i < count; i++){
switch(depth){
case 1:
*dst = *src;
break;
case 2:
AV_WN16A(dst, AV_RN16A(src));
break;
case 3:
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
break;
case 4:
AV_WN32A(dst, AV_RN32A(src));
break;
}
dst += depth;
if(!type)
src += depth;
x++;
if(x == w){
x = 0;
y++;
dst += diff;
}
}
if(type)
src += depth;
}
return src_size;
}
| false | FFmpeg | eb3f81e4ef73bb8d7e2c75ff0e8cb43de1c7dac5 | static int targa_decode_rle(AVCodecContext *avctx, TargaContext *s, const uint8_t *src, int src_size, uint8_t *dst, int w, int h, int stride, int bpp)
{
int i, x, y;
int depth = (bpp + 1) >> 3;
int type, count;
int diff;
const uint8_t *src_end = src + src_size;
diff = stride - w * depth;
x = y = 0;
while(y < h){
CHECK_BUFFER_SIZE(src, src_end, 1, "image type");
type = *src++;
count = (type & 0x7F) + 1;
type &= 0x80;
if((x + count > w) && (x + count + 1 > (h - y) * w)){
av_log(avctx, AV_LOG_ERROR, "Packet went out of bounds: position (%i,%i) size %i\n", x, y, count);
return -1;
}
if(type){
CHECK_BUFFER_SIZE(src, src_end, depth, "image data");
}else{
CHECK_BUFFER_SIZE(src, src_end, count * depth, "image data");
}
for(i = 0; i < count; i++){
switch(depth){
case 1:
*dst = *src;
break;
case 2:
AV_WN16A(dst, AV_RN16A(src));
break;
case 3:
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
break;
case 4:
AV_WN32A(dst, AV_RN32A(src));
break;
}
dst += depth;
if(!type)
src += depth;
x++;
if(x == w){
x = 0;
y++;
dst += diff;
}
}
if(type)
src += depth;
}
return src_size;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, TargaContext *VAR_1, const uint8_t *VAR_2, int VAR_3, uint8_t *VAR_4, int VAR_5, int VAR_6, int VAR_7, int VAR_8)
{
int VAR_9, VAR_10, VAR_11;
int VAR_12 = (VAR_8 + 1) >> 3;
int VAR_13, VAR_14;
int VAR_15;
const uint8_t *VAR_16 = VAR_2 + VAR_3;
VAR_15 = VAR_7 - VAR_5 * VAR_12;
VAR_10 = VAR_11 = 0;
while(VAR_11 < VAR_6){
CHECK_BUFFER_SIZE(VAR_2, VAR_16, 1, "image VAR_13");
VAR_13 = *VAR_2++;
VAR_14 = (VAR_13 & 0x7F) + 1;
VAR_13 &= 0x80;
if((VAR_10 + VAR_14 > VAR_5) && (VAR_10 + VAR_14 + 1 > (VAR_6 - VAR_11) * VAR_5)){
av_log(VAR_0, AV_LOG_ERROR, "Packet went out of bounds: position (%VAR_9,%VAR_9) size %VAR_9\n", VAR_10, VAR_11, VAR_14);
return -1;
}
if(VAR_13){
CHECK_BUFFER_SIZE(VAR_2, VAR_16, VAR_12, "image data");
}else{
CHECK_BUFFER_SIZE(VAR_2, VAR_16, VAR_14 * VAR_12, "image data");
}
for(VAR_9 = 0; VAR_9 < VAR_14; VAR_9++){
switch(VAR_12){
case 1:
*VAR_4 = *VAR_2;
break;
case 2:
AV_WN16A(VAR_4, AV_RN16A(VAR_2));
break;
case 3:
VAR_4[0] = VAR_2[0];
VAR_4[1] = VAR_2[1];
VAR_4[2] = VAR_2[2];
break;
case 4:
AV_WN32A(VAR_4, AV_RN32A(VAR_2));
break;
}
VAR_4 += VAR_12;
if(!VAR_13)
VAR_2 += VAR_12;
VAR_10++;
if(VAR_10 == VAR_5){
VAR_10 = 0;
VAR_11++;
VAR_4 += VAR_15;
}
}
if(VAR_13)
VAR_2 += VAR_12;
}
return VAR_3;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, TargaContext *VAR_1, const uint8_t *VAR_2, int VAR_3, uint8_t *VAR_4, int VAR_5, int VAR_6, int VAR_7, int VAR_8)\n{",
"int VAR_9, VAR_10, VAR_11;",
"int VAR_12 = (VAR_8 + 1) >> 3;",
"int VAR_13, VAR_14;",
"int VAR_15;",
"const uint8_t *VAR_16 = VAR_2 + VAR_3;",
"VAR_15 = VAR_7 - VAR_5 * VAR_12;",
"VAR_10 = VAR_11 = 0;",
"while(VAR_11 < VAR_6){",
"CHECK_BUFFER_SIZE(VAR_2, VAR_16, 1, \"image VAR_13\");",
"VAR_13 = *VAR_2++;",
"VAR_14 = (VAR_13 & 0x7F) + 1;",
"VAR_13 &= 0x80;",
"if((VAR_10 + VAR_14 > VAR_5) && (VAR_10 + VAR_14 + 1 > (VAR_6 - VAR_11) * VAR_5)){",
"av_log(VAR_0, AV_LOG_ERROR, \"Packet went out of bounds: position (%VAR_9,%VAR_9) size %VAR_9\\n\", VAR_10, VAR_11, VAR_14);",
"return -1;",
"}",
"if(VAR_13){",
"CHECK_BUFFER_SIZE(VAR_2, VAR_16, VAR_12, \"image data\");",
"}else{",
"CHECK_BUFFER_SIZE(VAR_2, VAR_16, VAR_14 * VAR_12, \"image data\");",
"}",
"for(VAR_9 = 0; VAR_9 < VAR_14; VAR_9++){",
"switch(VAR_12){",
"case 1:\n*VAR_4 = *VAR_2;",
"break;",
"case 2:\nAV_WN16A(VAR_4, AV_RN16A(VAR_2));",
"break;",
"case 3:\nVAR_4[0] = VAR_2[0];",
"VAR_4[1] = VAR_2[1];",
"VAR_4[2] = VAR_2[2];",
"break;",
"case 4:\nAV_WN32A(VAR_4, AV_RN32A(VAR_2));",
"break;",
"}",
"VAR_4 += VAR_12;",
"if(!VAR_13)\nVAR_2 += VAR_12;",
"VAR_10++;",
"if(VAR_10 == VAR_5){",
"VAR_10 = 0;",
"VAR_11++;",
"VAR_4 += VAR_15;",
"}",
"}",
"if(VAR_13)\nVAR_2 += VAR_12;",
"}",
"return VAR_3;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
75,
77
],
[
79
],
[
81
],
[
83
],
[
85,
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
113
]
] |
23,874 | uint32_t pci_default_read_config(PCIDevice *d,
uint32_t address, int len)
{
uint32_t val = 0;
assert(len == 1 || len == 2 || len == 4);
len = MIN(len, pci_config_size(d) - address);
memcpy(&val, d->config + address, len);
return le32_to_cpu(val);
}
| true | qemu | 42e4126b793d15ec40f3a84017e1d8afecda1b6d | uint32_t pci_default_read_config(PCIDevice *d,
uint32_t address, int len)
{
uint32_t val = 0;
assert(len == 1 || len == 2 || len == 4);
len = MIN(len, pci_config_size(d) - address);
memcpy(&val, d->config + address, len);
return le32_to_cpu(val);
}
| {
"code": [
" assert(len == 1 || len == 2 || len == 4);",
" len = MIN(len, pci_config_size(d) - address);",
" assert(len == 1 || len == 2 || len == 4);",
" assert(len == 1 || len == 2 || len == 4);"
],
"line_no": [
9,
11,
9,
9
]
} | uint32_t FUNC_0(PCIDevice *d,
uint32_t address, int len)
{
uint32_t val = 0;
assert(len == 1 || len == 2 || len == 4);
len = MIN(len, pci_config_size(d) - address);
memcpy(&val, d->config + address, len);
return le32_to_cpu(val);
}
| [
"uint32_t FUNC_0(PCIDevice *d,\nuint32_t address, int len)\n{",
"uint32_t val = 0;",
"assert(len == 1 || len == 2 || len == 4);",
"len = MIN(len, pci_config_size(d) - address);",
"memcpy(&val, d->config + address, len);",
"return le32_to_cpu(val);",
"}"
] | [
0,
0,
1,
1,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
23,875 | static void gen_rfci_40x(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
/* Restore CPU state */
gen_helper_40x_rfci(cpu_env);
gen_sync_exception(ctx);
#endif
}
| true | qemu | 9b2fadda3e0196ffd485adde4fe9cdd6fae35300 | static void gen_rfci_40x(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_40x_rfci(cpu_env);
gen_sync_exception(ctx);
#endif
}
| {
"code": [
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#if defined(CONFIG_USER_ONLY)",
"#else",
" if (unlikely(ctx->pr)) {",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
"#else",
" if (unlikely(ctx->pr)) {",
"#endif",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);",
"#endif"
],
"line_no": [
13,
7,
11,
13,
7,
11,
13,
7,
13,
5,
9,
11,
25,
5,
9,
11,
25,
25,
5,
9,
11,
7,
11,
13,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
11,
25,
7,
13,
25,
7,
11,
13,
25,
7,
13,
25,
7,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
11,
25,
11,
25,
11,
25,
11,
25,
5,
7,
9,
11,
13,
25,
7,
11,
13,
25,
5,
7,
9,
11,
13,
25,
5,
7,
9,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
5,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25,
7,
11,
13,
25
]
} | static void FUNC_0(DisasContext *VAR_0)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(VAR_0->pr)) {
gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_40x_rfci(cpu_env);
gen_sync_exception(VAR_0);
#endif
}
| [
"static void FUNC_0(DisasContext *VAR_0)\n{",
"#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);",
"#else\nif (unlikely(VAR_0->pr)) {",
"gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);",
"return;",
"}",
"gen_helper_40x_rfci(cpu_env);",
"gen_sync_exception(VAR_0);",
"#endif\n}"
] | [
0,
1,
1,
1,
0,
0,
0,
0,
1
] | [
[
1,
3
],
[
5,
7
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25,
27
]
] |
23,876 | static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
uint8_t *buf, int buf_size)
{
RTSPState *rt = s->priv_data;
RTSPStream *rtsp_st;
fd_set rfds;
int fd, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0;
struct timeval tv;
for (;;) {
if (url_interrupt_cb())
return AVERROR(EINTR);
FD_ZERO(&rfds);
if (rt->rtsp_hd) {
tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
FD_SET(tcp_fd, &rfds);
} else {
fd_max = 0;
tcp_fd = -1;
}
for (i = 0; i < rt->nb_rtsp_streams; i++) {
rtsp_st = rt->rtsp_streams[i];
if (rtsp_st->rtp_handle) {
/* currently, we cannot probe RTCP handle because of
* blocking restrictions */
fd = url_get_file_handle(rtsp_st->rtp_handle);
if (fd > fd_max)
fd_max = fd;
FD_SET(fd, &rfds);
}
}
tv.tv_sec = 0;
tv.tv_usec = SELECT_TIMEOUT_MS * 1000;
n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
if (n > 0) {
timeout_cnt = 0;
for (i = 0; i < rt->nb_rtsp_streams; i++) {
rtsp_st = rt->rtsp_streams[i];
if (rtsp_st->rtp_handle) {
fd = url_get_file_handle(rtsp_st->rtp_handle);
if (FD_ISSET(fd, &rfds)) {
ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
if (ret > 0) {
*prtsp_st = rtsp_st;
return ret;
}
}
}
}
#if CONFIG_RTSP_DEMUXER
if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
RTSPMessageHeader reply;
ret = ff_rtsp_read_reply(s, &reply, NULL, 0);
if (ret < 0)
return ret;
/* XXX: parse message */
if (rt->state != RTSP_STATE_STREAMING)
return 0;
}
#endif
} else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
return FF_NETERROR(ETIMEDOUT);
} else if (n < 0 && errno != EINTR)
return AVERROR(errno);
}
}
| false | FFmpeg | a1ba71aace8cca10ba2a921caa105b17370b0d27 | static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
uint8_t *buf, int buf_size)
{
RTSPState *rt = s->priv_data;
RTSPStream *rtsp_st;
fd_set rfds;
int fd, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0;
struct timeval tv;
for (;;) {
if (url_interrupt_cb())
return AVERROR(EINTR);
FD_ZERO(&rfds);
if (rt->rtsp_hd) {
tcp_fd = fd_max = url_get_file_handle(rt->rtsp_hd);
FD_SET(tcp_fd, &rfds);
} else {
fd_max = 0;
tcp_fd = -1;
}
for (i = 0; i < rt->nb_rtsp_streams; i++) {
rtsp_st = rt->rtsp_streams[i];
if (rtsp_st->rtp_handle) {
fd = url_get_file_handle(rtsp_st->rtp_handle);
if (fd > fd_max)
fd_max = fd;
FD_SET(fd, &rfds);
}
}
tv.tv_sec = 0;
tv.tv_usec = SELECT_TIMEOUT_MS * 1000;
n = select(fd_max + 1, &rfds, NULL, NULL, &tv);
if (n > 0) {
timeout_cnt = 0;
for (i = 0; i < rt->nb_rtsp_streams; i++) {
rtsp_st = rt->rtsp_streams[i];
if (rtsp_st->rtp_handle) {
fd = url_get_file_handle(rtsp_st->rtp_handle);
if (FD_ISSET(fd, &rfds)) {
ret = url_read(rtsp_st->rtp_handle, buf, buf_size);
if (ret > 0) {
*prtsp_st = rtsp_st;
return ret;
}
}
}
}
#if CONFIG_RTSP_DEMUXER
if (tcp_fd != -1 && FD_ISSET(tcp_fd, &rfds)) {
RTSPMessageHeader reply;
ret = ff_rtsp_read_reply(s, &reply, NULL, 0);
if (ret < 0)
return ret;
if (rt->state != RTSP_STATE_STREAMING)
return 0;
}
#endif
} else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
return FF_NETERROR(ETIMEDOUT);
} else if (n < 0 && errno != EINTR)
return AVERROR(errno);
}
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, RTSPStream **VAR_1,
uint8_t *VAR_2, int VAR_3)
{
RTSPState *rt = VAR_0->priv_data;
RTSPStream *rtsp_st;
fd_set rfds;
int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10 = 0;
struct timeval VAR_11;
for (;;) {
if (url_interrupt_cb())
return AVERROR(EINTR);
FD_ZERO(&rfds);
if (rt->rtsp_hd) {
VAR_9 = VAR_5 = url_get_file_handle(rt->rtsp_hd);
FD_SET(VAR_9, &rfds);
} else {
VAR_5 = 0;
VAR_9 = -1;
}
for (VAR_7 = 0; VAR_7 < rt->nb_rtsp_streams; VAR_7++) {
rtsp_st = rt->rtsp_streams[VAR_7];
if (rtsp_st->rtp_handle) {
VAR_4 = url_get_file_handle(rtsp_st->rtp_handle);
if (VAR_4 > VAR_5)
VAR_5 = VAR_4;
FD_SET(VAR_4, &rfds);
}
}
VAR_11.tv_sec = 0;
VAR_11.tv_usec = SELECT_TIMEOUT_MS * 1000;
VAR_6 = select(VAR_5 + 1, &rfds, NULL, NULL, &VAR_11);
if (VAR_6 > 0) {
VAR_10 = 0;
for (VAR_7 = 0; VAR_7 < rt->nb_rtsp_streams; VAR_7++) {
rtsp_st = rt->rtsp_streams[VAR_7];
if (rtsp_st->rtp_handle) {
VAR_4 = url_get_file_handle(rtsp_st->rtp_handle);
if (FD_ISSET(VAR_4, &rfds)) {
VAR_8 = url_read(rtsp_st->rtp_handle, VAR_2, VAR_3);
if (VAR_8 > 0) {
*VAR_1 = rtsp_st;
return VAR_8;
}
}
}
}
#if CONFIG_RTSP_DEMUXER
if (VAR_9 != -1 && FD_ISSET(VAR_9, &rfds)) {
RTSPMessageHeader reply;
VAR_8 = ff_rtsp_read_reply(VAR_0, &reply, NULL, 0);
if (VAR_8 < 0)
return VAR_8;
if (rt->state != RTSP_STATE_STREAMING)
return 0;
}
#endif
} else if (VAR_6 == 0 && ++VAR_10 >= MAX_TIMEOUTS) {
return FF_NETERROR(ETIMEDOUT);
} else if (VAR_6 < 0 && errno != EINTR)
return AVERROR(errno);
}
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, RTSPStream **VAR_1,\nuint8_t *VAR_2, int VAR_3)\n{",
"RTSPState *rt = VAR_0->priv_data;",
"RTSPStream *rtsp_st;",
"fd_set rfds;",
"int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10 = 0;",
"struct timeval VAR_11;",
"for (;;) {",
"if (url_interrupt_cb())\nreturn AVERROR(EINTR);",
"FD_ZERO(&rfds);",
"if (rt->rtsp_hd) {",
"VAR_9 = VAR_5 = url_get_file_handle(rt->rtsp_hd);",
"FD_SET(VAR_9, &rfds);",
"} else {",
"VAR_5 = 0;",
"VAR_9 = -1;",
"}",
"for (VAR_7 = 0; VAR_7 < rt->nb_rtsp_streams; VAR_7++) {",
"rtsp_st = rt->rtsp_streams[VAR_7];",
"if (rtsp_st->rtp_handle) {",
"VAR_4 = url_get_file_handle(rtsp_st->rtp_handle);",
"if (VAR_4 > VAR_5)\nVAR_5 = VAR_4;",
"FD_SET(VAR_4, &rfds);",
"}",
"}",
"VAR_11.tv_sec = 0;",
"VAR_11.tv_usec = SELECT_TIMEOUT_MS * 1000;",
"VAR_6 = select(VAR_5 + 1, &rfds, NULL, NULL, &VAR_11);",
"if (VAR_6 > 0) {",
"VAR_10 = 0;",
"for (VAR_7 = 0; VAR_7 < rt->nb_rtsp_streams; VAR_7++) {",
"rtsp_st = rt->rtsp_streams[VAR_7];",
"if (rtsp_st->rtp_handle) {",
"VAR_4 = url_get_file_handle(rtsp_st->rtp_handle);",
"if (FD_ISSET(VAR_4, &rfds)) {",
"VAR_8 = url_read(rtsp_st->rtp_handle, VAR_2, VAR_3);",
"if (VAR_8 > 0) {",
"*VAR_1 = rtsp_st;",
"return VAR_8;",
"}",
"}",
"}",
"}",
"#if CONFIG_RTSP_DEMUXER\nif (VAR_9 != -1 && FD_ISSET(VAR_9, &rfds)) {",
"RTSPMessageHeader reply;",
"VAR_8 = ff_rtsp_read_reply(VAR_0, &reply, NULL, 0);",
"if (VAR_8 < 0)\nreturn VAR_8;",
"if (rt->state != RTSP_STATE_STREAMING)\nreturn 0;",
"}",
"#endif\n} else if (VAR_6 == 0 && ++VAR_10 >= MAX_TIMEOUTS) {",
"return FF_NETERROR(ETIMEDOUT);",
"} else if (VAR_6 < 0 && errno != EINTR)",
"return AVERROR(errno);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99,
101
],
[
103
],
[
107
],
[
109,
111
],
[
115,
117
],
[
119
],
[
121,
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
]
] |
23,878 | static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) {
AVCodecContext *acodec, *vcodec;
ByteIOContext *ioc;
AMFDataType amf_type;
char str_val[256];
double num_val;
num_val = 0;
ioc = s->pb;
amf_type = get_byte(ioc);
switch(amf_type) {
case AMF_DATA_TYPE_NUMBER:
num_val = av_int2dbl(get_be64(ioc)); break;
case AMF_DATA_TYPE_BOOL:
num_val = get_byte(ioc); break;
case AMF_DATA_TYPE_STRING:
if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
return -1;
break;
case AMF_DATA_TYPE_OBJECT: {
unsigned int keylen;
while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) {
url_fskip(ioc, keylen); //skip key string
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1; //if we couldn't skip, bomb out.
}
if(get_byte(ioc) != AMF_END_OF_OBJECT)
return -1;
}
break;
case AMF_DATA_TYPE_NULL:
case AMF_DATA_TYPE_UNDEFINED:
case AMF_DATA_TYPE_UNSUPPORTED:
break; //these take up no additional space
case AMF_DATA_TYPE_MIXEDARRAY:
url_fskip(ioc, 4); //skip 32-bit max array index
while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
//this is the only case in which we would want a nested parse to not skip over the object
if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
return -1;
}
if(get_byte(ioc) != AMF_END_OF_OBJECT)
return -1;
break;
case AMF_DATA_TYPE_ARRAY: {
unsigned int arraylen, i;
arraylen = get_be32(ioc);
for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) {
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1; //if we couldn't skip, bomb out.
}
}
break;
case AMF_DATA_TYPE_DATE:
url_fskip(ioc, 8 + 2); //timestamp (double) and UTC offset (int16)
break;
default: //unsupported type, we couldn't skip
return -1;
}
if(depth == 1 && key) { //only look for metadata values when we are not nested and key != NULL
acodec = astream ? astream->codec : NULL;
vcodec = vstream ? vstream->codec : NULL;
if(amf_type == AMF_DATA_TYPE_BOOL) {
} else if(amf_type == AMF_DATA_TYPE_NUMBER) {
if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
vcodec->bit_rate = num_val * 1024.0;
}
}
return 0;
}
| false | FFmpeg | df2bd71aeb3e68509e3afc5502ef7cd6e5a69583 | static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) {
AVCodecContext *acodec, *vcodec;
ByteIOContext *ioc;
AMFDataType amf_type;
char str_val[256];
double num_val;
num_val = 0;
ioc = s->pb;
amf_type = get_byte(ioc);
switch(amf_type) {
case AMF_DATA_TYPE_NUMBER:
num_val = av_int2dbl(get_be64(ioc)); break;
case AMF_DATA_TYPE_BOOL:
num_val = get_byte(ioc); break;
case AMF_DATA_TYPE_STRING:
if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
return -1;
break;
case AMF_DATA_TYPE_OBJECT: {
unsigned int keylen;
while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) {
url_fskip(ioc, keylen);
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1;
}
if(get_byte(ioc) != AMF_END_OF_OBJECT)
return -1;
}
break;
case AMF_DATA_TYPE_NULL:
case AMF_DATA_TYPE_UNDEFINED:
case AMF_DATA_TYPE_UNSUPPORTED:
break;
case AMF_DATA_TYPE_MIXEDARRAY:
url_fskip(ioc, 4);
while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
return -1;
}
if(get_byte(ioc) != AMF_END_OF_OBJECT)
return -1;
break;
case AMF_DATA_TYPE_ARRAY: {
unsigned int arraylen, i;
arraylen = get_be32(ioc);
for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) {
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1;
}
}
break;
case AMF_DATA_TYPE_DATE:
url_fskip(ioc, 8 + 2);
break;
default:
return -1;
}
if(depth == 1 && key) {
acodec = astream ? astream->codec : NULL;
vcodec = vstream ? vstream->codec : NULL;
if(amf_type == AMF_DATA_TYPE_BOOL) {
} else if(amf_type == AMF_DATA_TYPE_NUMBER) {
if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
vcodec->bit_rate = num_val * 1024.0;
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1, AVStream *VAR_2, const char *VAR_3, int64_t VAR_4, int VAR_5) {
AVCodecContext *acodec, *vcodec;
ByteIOContext *ioc;
AMFDataType amf_type;
char VAR_6[256];
double VAR_7;
VAR_7 = 0;
ioc = VAR_0->pb;
amf_type = get_byte(ioc);
switch(amf_type) {
case AMF_DATA_TYPE_NUMBER:
VAR_7 = av_int2dbl(get_be64(ioc)); break;
case AMF_DATA_TYPE_BOOL:
VAR_7 = get_byte(ioc); break;
case AMF_DATA_TYPE_STRING:
if(amf_get_string(ioc, VAR_6, sizeof(VAR_6)) < 0)
return -1;
break;
case AMF_DATA_TYPE_OBJECT: {
unsigned int VAR_8;
while(url_ftell(ioc) < VAR_4 - 2 && (VAR_8 = get_be16(ioc))) {
url_fskip(ioc, VAR_8);
if(FUNC_0(VAR_0, NULL, NULL, NULL, VAR_4, VAR_5 + 1) < 0)
return -1;
}
if(get_byte(ioc) != AMF_END_OF_OBJECT)
return -1;
}
break;
case AMF_DATA_TYPE_NULL:
case AMF_DATA_TYPE_UNDEFINED:
case AMF_DATA_TYPE_UNSUPPORTED:
break;
case AMF_DATA_TYPE_MIXEDARRAY:
url_fskip(ioc, 4);
while(url_ftell(ioc) < VAR_4 - 2 && amf_get_string(ioc, VAR_6, sizeof(VAR_6)) > 0) {
if(FUNC_0(VAR_0, VAR_1, VAR_2, VAR_6, VAR_4, VAR_5 + 1) < 0)
return -1;
}
if(get_byte(ioc) != AMF_END_OF_OBJECT)
return -1;
break;
case AMF_DATA_TYPE_ARRAY: {
unsigned int VAR_9, VAR_10;
VAR_9 = get_be32(ioc);
for(VAR_10 = 0; VAR_10 < VAR_9 && url_ftell(ioc) < VAR_4 - 1; VAR_10++) {
if(FUNC_0(VAR_0, NULL, NULL, NULL, VAR_4, VAR_5 + 1) < 0)
return -1;
}
}
break;
case AMF_DATA_TYPE_DATE:
url_fskip(ioc, 8 + 2);
break;
default:
return -1;
}
if(VAR_5 == 1 && VAR_3) {
acodec = VAR_1 ? VAR_1->codec : NULL;
vcodec = VAR_2 ? VAR_2->codec : NULL;
if(amf_type == AMF_DATA_TYPE_BOOL) {
} else if(amf_type == AMF_DATA_TYPE_NUMBER) {
if(!strcmp(VAR_3, "duration")) VAR_0->duration = VAR_7 * AV_TIME_BASE;
else if(!strcmp(VAR_3, "videodatarate") && vcodec && 0 <= (int)(VAR_7 * 1024.0))
vcodec->bit_rate = VAR_7 * 1024.0;
}
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1, AVStream *VAR_2, const char *VAR_3, int64_t VAR_4, int VAR_5) {",
"AVCodecContext *acodec, *vcodec;",
"ByteIOContext *ioc;",
"AMFDataType amf_type;",
"char VAR_6[256];",
"double VAR_7;",
"VAR_7 = 0;",
"ioc = VAR_0->pb;",
"amf_type = get_byte(ioc);",
"switch(amf_type) {",
"case AMF_DATA_TYPE_NUMBER:\nVAR_7 = av_int2dbl(get_be64(ioc)); break;",
"case AMF_DATA_TYPE_BOOL:\nVAR_7 = get_byte(ioc); break;",
"case AMF_DATA_TYPE_STRING:\nif(amf_get_string(ioc, VAR_6, sizeof(VAR_6)) < 0)\nreturn -1;",
"break;",
"case AMF_DATA_TYPE_OBJECT: {",
"unsigned int VAR_8;",
"while(url_ftell(ioc) < VAR_4 - 2 && (VAR_8 = get_be16(ioc))) {",
"url_fskip(ioc, VAR_8);",
"if(FUNC_0(VAR_0, NULL, NULL, NULL, VAR_4, VAR_5 + 1) < 0)\nreturn -1;",
"}",
"if(get_byte(ioc) != AMF_END_OF_OBJECT)\nreturn -1;",
"}",
"break;",
"case AMF_DATA_TYPE_NULL:\ncase AMF_DATA_TYPE_UNDEFINED:\ncase AMF_DATA_TYPE_UNSUPPORTED:\nbreak;",
"case AMF_DATA_TYPE_MIXEDARRAY:\nurl_fskip(ioc, 4);",
"while(url_ftell(ioc) < VAR_4 - 2 && amf_get_string(ioc, VAR_6, sizeof(VAR_6)) > 0) {",
"if(FUNC_0(VAR_0, VAR_1, VAR_2, VAR_6, VAR_4, VAR_5 + 1) < 0)\nreturn -1;",
"}",
"if(get_byte(ioc) != AMF_END_OF_OBJECT)\nreturn -1;",
"break;",
"case AMF_DATA_TYPE_ARRAY: {",
"unsigned int VAR_9, VAR_10;",
"VAR_9 = get_be32(ioc);",
"for(VAR_10 = 0; VAR_10 < VAR_9 && url_ftell(ioc) < VAR_4 - 1; VAR_10++) {",
"if(FUNC_0(VAR_0, NULL, NULL, NULL, VAR_4, VAR_5 + 1) < 0)\nreturn -1;",
"}",
"}",
"break;",
"case AMF_DATA_TYPE_DATE:\nurl_fskip(ioc, 8 + 2);",
"break;",
"default:\nreturn -1;",
"}",
"if(VAR_5 == 1 && VAR_3) {",
"acodec = VAR_1 ? VAR_1->codec : NULL;",
"vcodec = VAR_2 ? VAR_2->codec : NULL;",
"if(amf_type == AMF_DATA_TYPE_BOOL) {",
"} else if(amf_type == AMF_DATA_TYPE_NUMBER) {",
"if(!strcmp(VAR_3, \"duration\")) VAR_0->duration = VAR_7 * AV_TIME_BASE;",
"else if(!strcmp(VAR_3, \"videodatarate\") && vcodec && 0 <= (int)(VAR_7 * 1024.0))\nvcodec->bit_rate = VAR_7 * 1024.0;",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27,
29
],
[
31,
33
],
[
35,
37,
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67,
69,
71,
73
],
[
75,
77
],
[
79
],
[
83,
85
],
[
87
],
[
89,
91
],
[
93
],
[
95
],
[
97
],
[
101
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
113
],
[
115,
117
],
[
119
],
[
121,
123
],
[
125
],
[
129
],
[
131
],
[
133
],
[
137
],
[
139
],
[
141
],
[
143,
145
],
[
147
],
[
149
],
[
153
],
[
155
]
] |
23,879 | static void mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
{
uint8_t *key = av_strdup(t->key);
uint8_t *p = key;
const uint8_t *lang = NULL;
ebml_master tag;
if ((p = strrchr(p, '-')) &&
(lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
*p = 0;
p = key;
while (*p) {
if (*p == ' ')
*p = '_';
else if (*p >= 'a' && *p <= 'z')
*p -= 'a' - 'A';
p++;
}
tag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG, 0);
put_ebml_string(pb, MATROSKA_ID_TAGNAME, key);
if (lang)
put_ebml_string(pb, MATROSKA_ID_TAGLANG, lang);
put_ebml_string(pb, MATROSKA_ID_TAGSTRING, t->value);
end_ebml_master(pb, tag);
av_freep(&key);
}
| false | FFmpeg | b1306823d0b3ae998c8e10ad832004eb13bdd93e | static void mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
{
uint8_t *key = av_strdup(t->key);
uint8_t *p = key;
const uint8_t *lang = NULL;
ebml_master tag;
if ((p = strrchr(p, '-')) &&
(lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
*p = 0;
p = key;
while (*p) {
if (*p == ' ')
*p = '_';
else if (*p >= 'a' && *p <= 'z')
*p -= 'a' - 'A';
p++;
}
tag = start_ebml_master(pb, MATROSKA_ID_SIMPLETAG, 0);
put_ebml_string(pb, MATROSKA_ID_TAGNAME, key);
if (lang)
put_ebml_string(pb, MATROSKA_ID_TAGLANG, lang);
put_ebml_string(pb, MATROSKA_ID_TAGSTRING, t->value);
end_ebml_master(pb, tag);
av_freep(&key);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AVIOContext *VAR_0, AVDictionaryEntry *VAR_1)
{
uint8_t *key = av_strdup(VAR_1->key);
uint8_t *p = key;
const uint8_t *VAR_2 = NULL;
ebml_master tag;
if ((p = strrchr(p, '-')) &&
(VAR_2 = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
*p = 0;
p = key;
while (*p) {
if (*p == ' ')
*p = '_';
else if (*p >= 'a' && *p <= 'z')
*p -= 'a' - 'A';
p++;
}
tag = start_ebml_master(VAR_0, MATROSKA_ID_SIMPLETAG, 0);
put_ebml_string(VAR_0, MATROSKA_ID_TAGNAME, key);
if (VAR_2)
put_ebml_string(VAR_0, MATROSKA_ID_TAGLANG, VAR_2);
put_ebml_string(VAR_0, MATROSKA_ID_TAGSTRING, VAR_1->value);
end_ebml_master(VAR_0, tag);
av_freep(&key);
}
| [
"static void FUNC_0(AVIOContext *VAR_0, AVDictionaryEntry *VAR_1)\n{",
"uint8_t *key = av_strdup(VAR_1->key);",
"uint8_t *p = key;",
"const uint8_t *VAR_2 = NULL;",
"ebml_master tag;",
"if ((p = strrchr(p, '-')) &&\n(VAR_2 = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))\n*p = 0;",
"p = key;",
"while (*p) {",
"if (*p == ' ')\n*p = '_';",
"else if (*p >= 'a' && *p <= 'z')\n*p -= 'a' - 'A';",
"p++;",
"}",
"tag = start_ebml_master(VAR_0, MATROSKA_ID_SIMPLETAG, 0);",
"put_ebml_string(VAR_0, MATROSKA_ID_TAGNAME, key);",
"if (VAR_2)\nput_ebml_string(VAR_0, MATROSKA_ID_TAGLANG, VAR_2);",
"put_ebml_string(VAR_0, MATROSKA_ID_TAGSTRING, VAR_1->value);",
"end_ebml_master(VAR_0, tag);",
"av_freep(&key);",
"}"
] | [
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
],
[
23
],
[
25
],
[
27,
29
],
[
31,
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
55
],
[
57
]
] |
23,880 | static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
{
int cpb_count, i;
cpb_count = get_ue_golomb_31(&h->gb) + 1;
if (cpb_count > 32U) {
av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
return AVERROR_INVALIDDATA;
}
get_bits(&h->gb, 4); /* bit_rate_scale */
get_bits(&h->gb, 4); /* cpb_size_scale */
for (i = 0; i < cpb_count; i++) {
get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
get_bits1(&h->gb); /* cbr_flag */
}
sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
sps->time_offset_length = get_bits(&h->gb, 5);
sps->cpb_cnt = cpb_count;
return 0;
}
| false | FFmpeg | 3176217c60ca7828712985092d9102d331ea4f3d | static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
{
int cpb_count, i;
cpb_count = get_ue_golomb_31(&h->gb) + 1;
if (cpb_count > 32U) {
av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
return AVERROR_INVALIDDATA;
}
get_bits(&h->gb, 4);
get_bits(&h->gb, 4);
for (i = 0; i < cpb_count; i++) {
get_ue_golomb_long(&h->gb);
get_ue_golomb_long(&h->gb);
get_bits1(&h->gb);
}
sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
sps->time_offset_length = get_bits(&h->gb, 5);
sps->cpb_cnt = cpb_count;
return 0;
}
| {
"code": [],
"line_no": []
} | static inline int FUNC_0(H264Context *VAR_0, SPS *VAR_1)
{
int VAR_2, VAR_3;
VAR_2 = get_ue_golomb_31(&VAR_0->gb) + 1;
if (VAR_2 > 32U) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_2 %d invalid\n", VAR_2);
return AVERROR_INVALIDDATA;
}
get_bits(&VAR_0->gb, 4);
get_bits(&VAR_0->gb, 4);
for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {
get_ue_golomb_long(&VAR_0->gb);
get_ue_golomb_long(&VAR_0->gb);
get_bits1(&VAR_0->gb);
}
VAR_1->initial_cpb_removal_delay_length = get_bits(&VAR_0->gb, 5) + 1;
VAR_1->cpb_removal_delay_length = get_bits(&VAR_0->gb, 5) + 1;
VAR_1->dpb_output_delay_length = get_bits(&VAR_0->gb, 5) + 1;
VAR_1->time_offset_length = get_bits(&VAR_0->gb, 5);
VAR_1->cpb_cnt = VAR_2;
return 0;
}
| [
"static inline int FUNC_0(H264Context *VAR_0, SPS *VAR_1)\n{",
"int VAR_2, VAR_3;",
"VAR_2 = get_ue_golomb_31(&VAR_0->gb) + 1;",
"if (VAR_2 > 32U) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"VAR_2 %d invalid\\n\", VAR_2);",
"return AVERROR_INVALIDDATA;",
"}",
"get_bits(&VAR_0->gb, 4);",
"get_bits(&VAR_0->gb, 4);",
"for (VAR_3 = 0; VAR_3 < VAR_2; VAR_3++) {",
"get_ue_golomb_long(&VAR_0->gb);",
"get_ue_golomb_long(&VAR_0->gb);",
"get_bits1(&VAR_0->gb);",
"}",
"VAR_1->initial_cpb_removal_delay_length = get_bits(&VAR_0->gb, 5) + 1;",
"VAR_1->cpb_removal_delay_length = get_bits(&VAR_0->gb, 5) + 1;",
"VAR_1->dpb_output_delay_length = get_bits(&VAR_0->gb, 5) + 1;",
"VAR_1->time_offset_length = get_bits(&VAR_0->gb, 5);",
"VAR_1->cpb_cnt = VAR_2;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
]
] |
23,881 | int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt) {
int i, j, t, rconpointer = 0;
uint8_t tk[8][4];
int KC= key_bits>>5;
int rounds= KC + 6;
uint8_t log8[256];
uint8_t alog8[512];
if(!enc_multbl[4][1023]){
j=1;
for(i=0; i<255; i++){
alog8[i]=
alog8[i+255]= j;
log8[j]= i;
j^= j+j;
if(j>255) j^= 0x11B;
}
for(i=0; i<256; i++){
j= i ? alog8[255-log8[i]] : 0;
j ^= (j<<1) ^ (j<<2) ^ (j<<3) ^ (j<<4);
j = (j ^ (j>>8) ^ 99) & 255;
inv_sbox[j]= i;
sbox [i]= j;
}
init_multbl2(dec_multbl[0], (int[4]){0xe, 0x9, 0xd, 0xb}, log8, alog8, inv_sbox);
init_multbl2(enc_multbl[0], (int[4]){0x2, 0x1, 0x1, 0x3}, log8, alog8, sbox);
}
if(key_bits!=128 && key_bits!=192 && key_bits!=256)
return -1;
a->rounds= rounds;
memcpy(tk, key, KC*4);
for(t= 0; t < (rounds+1)*16;) {
memcpy(a->round_key[0][0]+t, tk, KC*4);
t+= KC*4;
for(i = 0; i < 4; i++)
tk[0][i] ^= sbox[tk[KC-1][(i+1)&3]];
tk[0][0] ^= rcon[rconpointer++];
for(j = 1; j < KC; j++){
if(KC != 8 || j != KC>>1)
for(i = 0; i < 4; i++) tk[j][i] ^= tk[j-1][i];
else
for(i = 0; i < 4; i++) tk[j][i] ^= sbox[tk[j-1][i]];
}
}
if(decrypt){
for(i=1; i<rounds; i++){
uint8_t tmp[3][16];
memcpy(tmp[2], a->round_key[i][0], 16);
subshift(tmp[1], 0, sbox);
mix(tmp, dec_multbl, 1, 3);
memcpy(a->round_key[i][0], tmp[0], 16);
}
}else{
for(i=0; i<(rounds+1)>>1; i++){
for(j=0; j<16; j++)
FFSWAP(int, a->round_key[i][0][j], a->round_key[rounds-i][0][j]);
}
}
return 0;
}
| false | FFmpeg | 79d4c96a1a708f8da145121cee118c7bdd596344 | int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt) {
int i, j, t, rconpointer = 0;
uint8_t tk[8][4];
int KC= key_bits>>5;
int rounds= KC + 6;
uint8_t log8[256];
uint8_t alog8[512];
if(!enc_multbl[4][1023]){
j=1;
for(i=0; i<255; i++){
alog8[i]=
alog8[i+255]= j;
log8[j]= i;
j^= j+j;
if(j>255) j^= 0x11B;
}
for(i=0; i<256; i++){
j= i ? alog8[255-log8[i]] : 0;
j ^= (j<<1) ^ (j<<2) ^ (j<<3) ^ (j<<4);
j = (j ^ (j>>8) ^ 99) & 255;
inv_sbox[j]= i;
sbox [i]= j;
}
init_multbl2(dec_multbl[0], (int[4]){0xe, 0x9, 0xd, 0xb}, log8, alog8, inv_sbox);
init_multbl2(enc_multbl[0], (int[4]){0x2, 0x1, 0x1, 0x3}, log8, alog8, sbox);
}
if(key_bits!=128 && key_bits!=192 && key_bits!=256)
return -1;
a->rounds= rounds;
memcpy(tk, key, KC*4);
for(t= 0; t < (rounds+1)*16;) {
memcpy(a->round_key[0][0]+t, tk, KC*4);
t+= KC*4;
for(i = 0; i < 4; i++)
tk[0][i] ^= sbox[tk[KC-1][(i+1)&3]];
tk[0][0] ^= rcon[rconpointer++];
for(j = 1; j < KC; j++){
if(KC != 8 || j != KC>>1)
for(i = 0; i < 4; i++) tk[j][i] ^= tk[j-1][i];
else
for(i = 0; i < 4; i++) tk[j][i] ^= sbox[tk[j-1][i]];
}
}
if(decrypt){
for(i=1; i<rounds; i++){
uint8_t tmp[3][16];
memcpy(tmp[2], a->round_key[i][0], 16);
subshift(tmp[1], 0, sbox);
mix(tmp, dec_multbl, 1, 3);
memcpy(a->round_key[i][0], tmp[0], 16);
}
}else{
for(i=0; i<(rounds+1)>>1; i++){
for(j=0; j<16; j++)
FFSWAP(int, a->round_key[i][0][j], a->round_key[rounds-i][0][j]);
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(AVAES *VAR_0, const uint8_t *VAR_1, int VAR_2, int VAR_3) {
int VAR_4, VAR_5, VAR_6, VAR_7 = 0;
uint8_t tk[8][4];
int VAR_8= VAR_2>>5;
int VAR_9= VAR_8 + 6;
uint8_t log8[256];
uint8_t alog8[512];
if(!enc_multbl[4][1023]){
VAR_5=1;
for(VAR_4=0; VAR_4<255; VAR_4++){
alog8[VAR_4]=
alog8[VAR_4+255]= VAR_5;
log8[VAR_5]= VAR_4;
VAR_5^= VAR_5+VAR_5;
if(VAR_5>255) VAR_5^= 0x11B;
}
for(VAR_4=0; VAR_4<256; VAR_4++){
VAR_5= VAR_4 ? alog8[255-log8[VAR_4]] : 0;
VAR_5 ^= (VAR_5<<1) ^ (VAR_5<<2) ^ (VAR_5<<3) ^ (VAR_5<<4);
VAR_5 = (VAR_5 ^ (VAR_5>>8) ^ 99) & 255;
inv_sbox[VAR_5]= VAR_4;
sbox [VAR_4]= VAR_5;
}
init_multbl2(dec_multbl[0], (int[4]){0xe, 0x9, 0xd, 0xb}, log8, alog8, inv_sbox);
init_multbl2(enc_multbl[0], (int[4]){0x2, 0x1, 0x1, 0x3}, log8, alog8, sbox);
}
if(VAR_2!=128 && VAR_2!=192 && VAR_2!=256)
return -1;
VAR_0->VAR_9= VAR_9;
memcpy(tk, VAR_1, VAR_8*4);
for(VAR_6= 0; VAR_6 < (VAR_9+1)*16;) {
memcpy(VAR_0->round_key[0][0]+VAR_6, tk, VAR_8*4);
VAR_6+= VAR_8*4;
for(VAR_4 = 0; VAR_4 < 4; VAR_4++)
tk[0][VAR_4] ^= sbox[tk[VAR_8-1][(VAR_4+1)&3]];
tk[0][0] ^= rcon[VAR_7++];
for(VAR_5 = 1; VAR_5 < VAR_8; VAR_5++){
if(VAR_8 != 8 || VAR_5 != VAR_8>>1)
for(VAR_4 = 0; VAR_4 < 4; VAR_4++) tk[VAR_5][VAR_4] ^= tk[VAR_5-1][VAR_4];
else
for(VAR_4 = 0; VAR_4 < 4; VAR_4++) tk[VAR_5][VAR_4] ^= sbox[tk[VAR_5-1][VAR_4]];
}
}
if(VAR_3){
for(VAR_4=1; VAR_4<VAR_9; VAR_4++){
uint8_t tmp[3][16];
memcpy(tmp[2], VAR_0->round_key[VAR_4][0], 16);
subshift(tmp[1], 0, sbox);
mix(tmp, dec_multbl, 1, 3);
memcpy(VAR_0->round_key[VAR_4][0], tmp[0], 16);
}
}else{
for(VAR_4=0; VAR_4<(VAR_9+1)>>1; VAR_4++){
for(VAR_5=0; VAR_5<16; VAR_5++)
FFSWAP(int, VAR_0->round_key[VAR_4][0][VAR_5], VAR_0->round_key[VAR_9-VAR_4][0][VAR_5]);
}
}
return 0;
}
| [
"int FUNC_0(AVAES *VAR_0, const uint8_t *VAR_1, int VAR_2, int VAR_3) {",
"int VAR_4, VAR_5, VAR_6, VAR_7 = 0;",
"uint8_t tk[8][4];",
"int VAR_8= VAR_2>>5;",
"int VAR_9= VAR_8 + 6;",
"uint8_t log8[256];",
"uint8_t alog8[512];",
"if(!enc_multbl[4][1023]){",
"VAR_5=1;",
"for(VAR_4=0; VAR_4<255; VAR_4++){",
"alog8[VAR_4]=\nalog8[VAR_4+255]= VAR_5;",
"log8[VAR_5]= VAR_4;",
"VAR_5^= VAR_5+VAR_5;",
"if(VAR_5>255) VAR_5^= 0x11B;",
"}",
"for(VAR_4=0; VAR_4<256; VAR_4++){",
"VAR_5= VAR_4 ? alog8[255-log8[VAR_4]] : 0;",
"VAR_5 ^= (VAR_5<<1) ^ (VAR_5<<2) ^ (VAR_5<<3) ^ (VAR_5<<4);",
"VAR_5 = (VAR_5 ^ (VAR_5>>8) ^ 99) & 255;",
"inv_sbox[VAR_5]= VAR_4;",
"sbox [VAR_4]= VAR_5;",
"}",
"init_multbl2(dec_multbl[0], (int[4]){0xe, 0x9, 0xd, 0xb}, log8, alog8, inv_sbox);",
"init_multbl2(enc_multbl[0], (int[4]){0x2, 0x1, 0x1, 0x3}, log8, alog8, sbox);",
"}",
"if(VAR_2!=128 && VAR_2!=192 && VAR_2!=256)\nreturn -1;",
"VAR_0->VAR_9= VAR_9;",
"memcpy(tk, VAR_1, VAR_8*4);",
"for(VAR_6= 0; VAR_6 < (VAR_9+1)*16;) {",
"memcpy(VAR_0->round_key[0][0]+VAR_6, tk, VAR_8*4);",
"VAR_6+= VAR_8*4;",
"for(VAR_4 = 0; VAR_4 < 4; VAR_4++)",
"tk[0][VAR_4] ^= sbox[tk[VAR_8-1][(VAR_4+1)&3]];",
"tk[0][0] ^= rcon[VAR_7++];",
"for(VAR_5 = 1; VAR_5 < VAR_8; VAR_5++){",
"if(VAR_8 != 8 || VAR_5 != VAR_8>>1)\nfor(VAR_4 = 0; VAR_4 < 4; VAR_4++) tk[VAR_5][VAR_4] ^= tk[VAR_5-1][VAR_4];",
"else\nfor(VAR_4 = 0; VAR_4 < 4; VAR_4++) tk[VAR_5][VAR_4] ^= sbox[tk[VAR_5-1][VAR_4]];",
"}",
"}",
"if(VAR_3){",
"for(VAR_4=1; VAR_4<VAR_9; VAR_4++){",
"uint8_t tmp[3][16];",
"memcpy(tmp[2], VAR_0->round_key[VAR_4][0], 16);",
"subshift(tmp[1], 0, sbox);",
"mix(tmp, dec_multbl, 1, 3);",
"memcpy(VAR_0->round_key[VAR_4][0], tmp[0], 16);",
"}",
"}else{",
"for(VAR_4=0; VAR_4<(VAR_9+1)>>1; VAR_4++){",
"for(VAR_5=0; VAR_5<16; VAR_5++)",
"FFSWAP(int, VAR_0->round_key[VAR_4][0][VAR_5], VAR_0->round_key[VAR_9-VAR_4][0][VAR_5]);",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57,
59
],
[
63
],
[
67
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89,
91
],
[
93,
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
]
] |
23,882 | static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
{
VideoData *s = s1->priv_data;
AVStream *st;
int video_fd;
int desired_palette, desired_depth;
struct video_tuner tuner;
struct video_audio audio;
struct video_picture pict;
int j;
int vformat_num = FF_ARRAY_ELEMS(video_formats);
av_log(s1, AV_LOG_WARNING, "V4L input device is deprecated and will be removed in the next release.");
if (ap->time_base.den <= 0) {
av_log(s1, AV_LOG_ERROR, "Wrong time base (%d)\n", ap->time_base.den);
return -1;
}
s->time_base = ap->time_base;
s->video_win.width = ap->width;
s->video_win.height = ap->height;
st = avformat_new_stream(s1, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
video_fd = open(s1->filename, O_RDWR);
if (video_fd < 0) {
av_log(s1, AV_LOG_ERROR, "%s: %s\n", s1->filename, strerror(errno));
goto fail;
}
if (ioctl(video_fd, VIDIOCGCAP, &s->video_cap) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCGCAP: %s\n", strerror(errno));
goto fail;
}
if (!(s->video_cap.type & VID_TYPE_CAPTURE)) {
av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not handle capture\n");
goto fail;
}
/* no values set, autodetect them */
if (s->video_win.width <= 0 || s->video_win.height <= 0) {
if (ioctl(video_fd, VIDIOCGWIN, &s->video_win, sizeof(s->video_win)) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCGWIN: %s\n", strerror(errno));
goto fail;
}
}
if(av_image_check_size(s->video_win.width, s->video_win.height, 0, s1) < 0)
return -1;
desired_palette = -1;
desired_depth = -1;
for (j = 0; j < vformat_num; j++) {
if (ap->pix_fmt == video_formats[j].pix_fmt) {
desired_palette = video_formats[j].palette;
desired_depth = video_formats[j].depth;
break;
}
}
/* set tv standard */
if (!ioctl(video_fd, VIDIOCGTUNER, &tuner)) {
tuner.mode = s->standard;
ioctl(video_fd, VIDIOCSTUNER, &tuner);
}
/* unmute audio */
audio.audio = 0;
ioctl(video_fd, VIDIOCGAUDIO, &audio);
memcpy(&s->audio_saved, &audio, sizeof(audio));
audio.flags &= ~VIDEO_AUDIO_MUTE;
ioctl(video_fd, VIDIOCSAUDIO, &audio);
ioctl(video_fd, VIDIOCGPICT, &pict);
av_dlog(s1, "v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\n",
pict.colour, pict.hue, pict.brightness, pict.contrast, pict.whiteness);
/* try to choose a suitable video format */
pict.palette = desired_palette;
pict.depth= desired_depth;
if (desired_palette == -1 || ioctl(video_fd, VIDIOCSPICT, &pict) < 0) {
for (j = 0; j < vformat_num; j++) {
pict.palette = video_formats[j].palette;
pict.depth = video_formats[j].depth;
if (-1 != ioctl(video_fd, VIDIOCSPICT, &pict))
break;
}
if (j >= vformat_num)
goto fail1;
}
if (ioctl(video_fd, VIDIOCGMBUF, &s->gb_buffers) < 0) {
/* try to use read based access */
int val;
s->video_win.x = 0;
s->video_win.y = 0;
s->video_win.chromakey = -1;
s->video_win.flags = 0;
if (ioctl(video_fd, VIDIOCSWIN, s->video_win) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCSWIN: %s\n", strerror(errno));
goto fail;
}
s->frame_format = pict.palette;
val = 1;
if (ioctl(video_fd, VIDIOCCAPTURE, &val) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCCAPTURE: %s\n", strerror(errno));
goto fail;
}
s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
s->use_mmap = 0;
} else {
s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, video_fd, 0);
if ((unsigned char*)-1 == s->video_buf) {
s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, video_fd, 0);
if ((unsigned char*)-1 == s->video_buf) {
av_log(s1, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
goto fail;
}
}
s->gb_frame = 0;
s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
/* start to grab the first frame */
s->gb_buf.frame = s->gb_frame % s->gb_buffers.frames;
s->gb_buf.height = s->video_win.height;
s->gb_buf.width = s->video_win.width;
s->gb_buf.format = pict.palette;
if (ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
if (errno != EAGAIN) {
fail1:
av_log(s1, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
} else {
av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not receive any video signal\n");
}
goto fail;
}
for (j = 1; j < s->gb_buffers.frames; j++) {
s->gb_buf.frame = j;
ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf);
}
s->frame_format = s->gb_buf.format;
s->use_mmap = 1;
}
for (j = 0; j < vformat_num; j++) {
if (s->frame_format == video_formats[j].palette) {
s->frame_size = s->video_win.width * s->video_win.height * video_formats[j].depth / 8;
st->codec->pix_fmt = video_formats[j].pix_fmt;
break;
}
}
if (j >= vformat_num)
goto fail;
s->fd = video_fd;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = s->video_win.width;
st->codec->height = s->video_win.height;
st->codec->time_base = s->time_base;
st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;
return 0;
fail:
if (video_fd >= 0)
close(video_fd);
return AVERROR(EIO);
}
| false | FFmpeg | 229843aa359ae0c9519977d7fa952688db63f559 | static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
{
VideoData *s = s1->priv_data;
AVStream *st;
int video_fd;
int desired_palette, desired_depth;
struct video_tuner tuner;
struct video_audio audio;
struct video_picture pict;
int j;
int vformat_num = FF_ARRAY_ELEMS(video_formats);
av_log(s1, AV_LOG_WARNING, "V4L input device is deprecated and will be removed in the next release.");
if (ap->time_base.den <= 0) {
av_log(s1, AV_LOG_ERROR, "Wrong time base (%d)\n", ap->time_base.den);
return -1;
}
s->time_base = ap->time_base;
s->video_win.width = ap->width;
s->video_win.height = ap->height;
st = avformat_new_stream(s1, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
video_fd = open(s1->filename, O_RDWR);
if (video_fd < 0) {
av_log(s1, AV_LOG_ERROR, "%s: %s\n", s1->filename, strerror(errno));
goto fail;
}
if (ioctl(video_fd, VIDIOCGCAP, &s->video_cap) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCGCAP: %s\n", strerror(errno));
goto fail;
}
if (!(s->video_cap.type & VID_TYPE_CAPTURE)) {
av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not handle capture\n");
goto fail;
}
if (s->video_win.width <= 0 || s->video_win.height <= 0) {
if (ioctl(video_fd, VIDIOCGWIN, &s->video_win, sizeof(s->video_win)) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCGWIN: %s\n", strerror(errno));
goto fail;
}
}
if(av_image_check_size(s->video_win.width, s->video_win.height, 0, s1) < 0)
return -1;
desired_palette = -1;
desired_depth = -1;
for (j = 0; j < vformat_num; j++) {
if (ap->pix_fmt == video_formats[j].pix_fmt) {
desired_palette = video_formats[j].palette;
desired_depth = video_formats[j].depth;
break;
}
}
if (!ioctl(video_fd, VIDIOCGTUNER, &tuner)) {
tuner.mode = s->standard;
ioctl(video_fd, VIDIOCSTUNER, &tuner);
}
audio.audio = 0;
ioctl(video_fd, VIDIOCGAUDIO, &audio);
memcpy(&s->audio_saved, &audio, sizeof(audio));
audio.flags &= ~VIDEO_AUDIO_MUTE;
ioctl(video_fd, VIDIOCSAUDIO, &audio);
ioctl(video_fd, VIDIOCGPICT, &pict);
av_dlog(s1, "v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\n",
pict.colour, pict.hue, pict.brightness, pict.contrast, pict.whiteness);
pict.palette = desired_palette;
pict.depth= desired_depth;
if (desired_palette == -1 || ioctl(video_fd, VIDIOCSPICT, &pict) < 0) {
for (j = 0; j < vformat_num; j++) {
pict.palette = video_formats[j].palette;
pict.depth = video_formats[j].depth;
if (-1 != ioctl(video_fd, VIDIOCSPICT, &pict))
break;
}
if (j >= vformat_num)
goto fail1;
}
if (ioctl(video_fd, VIDIOCGMBUF, &s->gb_buffers) < 0) {
int val;
s->video_win.x = 0;
s->video_win.y = 0;
s->video_win.chromakey = -1;
s->video_win.flags = 0;
if (ioctl(video_fd, VIDIOCSWIN, s->video_win) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCSWIN: %s\n", strerror(errno));
goto fail;
}
s->frame_format = pict.palette;
val = 1;
if (ioctl(video_fd, VIDIOCCAPTURE, &val) < 0) {
av_log(s1, AV_LOG_ERROR, "VIDIOCCAPTURE: %s\n", strerror(errno));
goto fail;
}
s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
s->use_mmap = 0;
} else {
s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, video_fd, 0);
if ((unsigned char*)-1 == s->video_buf) {
s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, video_fd, 0);
if ((unsigned char*)-1 == s->video_buf) {
av_log(s1, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
goto fail;
}
}
s->gb_frame = 0;
s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
s->gb_buf.frame = s->gb_frame % s->gb_buffers.frames;
s->gb_buf.height = s->video_win.height;
s->gb_buf.width = s->video_win.width;
s->gb_buf.format = pict.palette;
if (ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
if (errno != EAGAIN) {
fail1:
av_log(s1, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
} else {
av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not receive any video signal\n");
}
goto fail;
}
for (j = 1; j < s->gb_buffers.frames; j++) {
s->gb_buf.frame = j;
ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf);
}
s->frame_format = s->gb_buf.format;
s->use_mmap = 1;
}
for (j = 0; j < vformat_num; j++) {
if (s->frame_format == video_formats[j].palette) {
s->frame_size = s->video_win.width * s->video_win.height * video_formats[j].depth / 8;
st->codec->pix_fmt = video_formats[j].pix_fmt;
break;
}
}
if (j >= vformat_num)
goto fail;
s->fd = video_fd;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = s->video_win.width;
st->codec->height = s->video_win.height;
st->codec->time_base = s->time_base;
st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;
return 0;
fail:
if (video_fd >= 0)
close(video_fd);
return AVERROR(EIO);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVFormatParameters *VAR_1)
{
VideoData *s = VAR_0->priv_data;
AVStream *st;
int VAR_2;
int VAR_3, VAR_4;
struct video_tuner VAR_5;
struct video_audio VAR_6;
struct video_picture VAR_7;
int VAR_8;
int VAR_9 = FF_ARRAY_ELEMS(video_formats);
av_log(VAR_0, AV_LOG_WARNING, "V4L input device is deprecated and will be removed in the next release.");
if (VAR_1->time_base.den <= 0) {
av_log(VAR_0, AV_LOG_ERROR, "Wrong time base (%d)\n", VAR_1->time_base.den);
return -1;
}
s->time_base = VAR_1->time_base;
s->video_win.width = VAR_1->width;
s->video_win.height = VAR_1->height;
st = avformat_new_stream(VAR_0, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
VAR_2 = open(VAR_0->filename, O_RDWR);
if (VAR_2 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "%s: %s\n", VAR_0->filename, strerror(errno));
goto fail;
}
if (ioctl(VAR_2, VIDIOCGCAP, &s->video_cap) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "VIDIOCGCAP: %s\n", strerror(errno));
goto fail;
}
if (!(s->video_cap.type & VID_TYPE_CAPTURE)) {
av_log(VAR_0, AV_LOG_ERROR, "Fatal: grab device does not handle capture\n");
goto fail;
}
if (s->video_win.width <= 0 || s->video_win.height <= 0) {
if (ioctl(VAR_2, VIDIOCGWIN, &s->video_win, sizeof(s->video_win)) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "VIDIOCGWIN: %s\n", strerror(errno));
goto fail;
}
}
if(av_image_check_size(s->video_win.width, s->video_win.height, 0, VAR_0) < 0)
return -1;
VAR_3 = -1;
VAR_4 = -1;
for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {
if (VAR_1->pix_fmt == video_formats[VAR_8].pix_fmt) {
VAR_3 = video_formats[VAR_8].palette;
VAR_4 = video_formats[VAR_8].depth;
break;
}
}
if (!ioctl(VAR_2, VIDIOCGTUNER, &VAR_5)) {
VAR_5.mode = s->standard;
ioctl(VAR_2, VIDIOCSTUNER, &VAR_5);
}
VAR_6.VAR_6 = 0;
ioctl(VAR_2, VIDIOCGAUDIO, &VAR_6);
memcpy(&s->audio_saved, &VAR_6, sizeof(VAR_6));
VAR_6.flags &= ~VIDEO_AUDIO_MUTE;
ioctl(VAR_2, VIDIOCSAUDIO, &VAR_6);
ioctl(VAR_2, VIDIOCGPICT, &VAR_7);
av_dlog(VAR_0, "v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\n",
VAR_7.colour, VAR_7.hue, VAR_7.brightness, VAR_7.contrast, VAR_7.whiteness);
VAR_7.palette = VAR_3;
VAR_7.depth= VAR_4;
if (VAR_3 == -1 || ioctl(VAR_2, VIDIOCSPICT, &VAR_7) < 0) {
for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {
VAR_7.palette = video_formats[VAR_8].palette;
VAR_7.depth = video_formats[VAR_8].depth;
if (-1 != ioctl(VAR_2, VIDIOCSPICT, &VAR_7))
break;
}
if (VAR_8 >= VAR_9)
goto fail1;
}
if (ioctl(VAR_2, VIDIOCGMBUF, &s->gb_buffers) < 0) {
int VAR_10;
s->video_win.x = 0;
s->video_win.y = 0;
s->video_win.chromakey = -1;
s->video_win.flags = 0;
if (ioctl(VAR_2, VIDIOCSWIN, s->video_win) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "VIDIOCSWIN: %s\n", strerror(errno));
goto fail;
}
s->frame_format = VAR_7.palette;
VAR_10 = 1;
if (ioctl(VAR_2, VIDIOCCAPTURE, &VAR_10) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "VIDIOCCAPTURE: %s\n", strerror(errno));
goto fail;
}
s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
s->use_mmap = 0;
} else {
s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, VAR_2, 0);
if ((unsigned char*)-1 == s->video_buf) {
s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, VAR_2, 0);
if ((unsigned char*)-1 == s->video_buf) {
av_log(VAR_0, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
goto fail;
}
}
s->gb_frame = 0;
s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
s->gb_buf.frame = s->gb_frame % s->gb_buffers.frames;
s->gb_buf.height = s->video_win.height;
s->gb_buf.width = s->video_win.width;
s->gb_buf.format = VAR_7.palette;
if (ioctl(VAR_2, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
if (errno != EAGAIN) {
fail1:
av_log(VAR_0, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
} else {
av_log(VAR_0, AV_LOG_ERROR, "Fatal: grab device does not receive any video signal\n");
}
goto fail;
}
for (VAR_8 = 1; VAR_8 < s->gb_buffers.frames; VAR_8++) {
s->gb_buf.frame = VAR_8;
ioctl(VAR_2, VIDIOCMCAPTURE, &s->gb_buf);
}
s->frame_format = s->gb_buf.format;
s->use_mmap = 1;
}
for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {
if (s->frame_format == video_formats[VAR_8].palette) {
s->frame_size = s->video_win.width * s->video_win.height * video_formats[VAR_8].depth / 8;
st->codec->pix_fmt = video_formats[VAR_8].pix_fmt;
break;
}
}
if (VAR_8 >= VAR_9)
goto fail;
s->fd = VAR_2;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = s->video_win.width;
st->codec->height = s->video_win.height;
st->codec->time_base = s->time_base;
st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;
return 0;
fail:
if (VAR_2 >= 0)
close(VAR_2);
return AVERROR(EIO);
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVFormatParameters *VAR_1)\n{",
"VideoData *s = VAR_0->priv_data;",
"AVStream *st;",
"int VAR_2;",
"int VAR_3, VAR_4;",
"struct video_tuner VAR_5;",
"struct video_audio VAR_6;",
"struct video_picture VAR_7;",
"int VAR_8;",
"int VAR_9 = FF_ARRAY_ELEMS(video_formats);",
"av_log(VAR_0, AV_LOG_WARNING, \"V4L input device is deprecated and will be removed in the next release.\");",
"if (VAR_1->time_base.den <= 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Wrong time base (%d)\\n\", VAR_1->time_base.den);",
"return -1;",
"}",
"s->time_base = VAR_1->time_base;",
"s->video_win.width = VAR_1->width;",
"s->video_win.height = VAR_1->height;",
"st = avformat_new_stream(VAR_0, NULL);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"avpriv_set_pts_info(st, 64, 1, 1000000);",
"VAR_2 = open(VAR_0->filename, O_RDWR);",
"if (VAR_2 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"%s: %s\\n\", VAR_0->filename, strerror(errno));",
"goto fail;",
"}",
"if (ioctl(VAR_2, VIDIOCGCAP, &s->video_cap) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"VIDIOCGCAP: %s\\n\", strerror(errno));",
"goto fail;",
"}",
"if (!(s->video_cap.type & VID_TYPE_CAPTURE)) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Fatal: grab device does not handle capture\\n\");",
"goto fail;",
"}",
"if (s->video_win.width <= 0 || s->video_win.height <= 0) {",
"if (ioctl(VAR_2, VIDIOCGWIN, &s->video_win, sizeof(s->video_win)) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"VIDIOCGWIN: %s\\n\", strerror(errno));",
"goto fail;",
"}",
"}",
"if(av_image_check_size(s->video_win.width, s->video_win.height, 0, VAR_0) < 0)\nreturn -1;",
"VAR_3 = -1;",
"VAR_4 = -1;",
"for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {",
"if (VAR_1->pix_fmt == video_formats[VAR_8].pix_fmt) {",
"VAR_3 = video_formats[VAR_8].palette;",
"VAR_4 = video_formats[VAR_8].depth;",
"break;",
"}",
"}",
"if (!ioctl(VAR_2, VIDIOCGTUNER, &VAR_5)) {",
"VAR_5.mode = s->standard;",
"ioctl(VAR_2, VIDIOCSTUNER, &VAR_5);",
"}",
"VAR_6.VAR_6 = 0;",
"ioctl(VAR_2, VIDIOCGAUDIO, &VAR_6);",
"memcpy(&s->audio_saved, &VAR_6, sizeof(VAR_6));",
"VAR_6.flags &= ~VIDEO_AUDIO_MUTE;",
"ioctl(VAR_2, VIDIOCSAUDIO, &VAR_6);",
"ioctl(VAR_2, VIDIOCGPICT, &VAR_7);",
"av_dlog(VAR_0, \"v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\\n\",\nVAR_7.colour, VAR_7.hue, VAR_7.brightness, VAR_7.contrast, VAR_7.whiteness);",
"VAR_7.palette = VAR_3;",
"VAR_7.depth= VAR_4;",
"if (VAR_3 == -1 || ioctl(VAR_2, VIDIOCSPICT, &VAR_7) < 0) {",
"for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {",
"VAR_7.palette = video_formats[VAR_8].palette;",
"VAR_7.depth = video_formats[VAR_8].depth;",
"if (-1 != ioctl(VAR_2, VIDIOCSPICT, &VAR_7))\nbreak;",
"}",
"if (VAR_8 >= VAR_9)\ngoto fail1;",
"}",
"if (ioctl(VAR_2, VIDIOCGMBUF, &s->gb_buffers) < 0) {",
"int VAR_10;",
"s->video_win.x = 0;",
"s->video_win.y = 0;",
"s->video_win.chromakey = -1;",
"s->video_win.flags = 0;",
"if (ioctl(VAR_2, VIDIOCSWIN, s->video_win) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"VIDIOCSWIN: %s\\n\", strerror(errno));",
"goto fail;",
"}",
"s->frame_format = VAR_7.palette;",
"VAR_10 = 1;",
"if (ioctl(VAR_2, VIDIOCCAPTURE, &VAR_10) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"VIDIOCCAPTURE: %s\\n\", strerror(errno));",
"goto fail;",
"}",
"s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;",
"s->use_mmap = 0;",
"} else {",
"s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, VAR_2, 0);",
"if ((unsigned char*)-1 == s->video_buf) {",
"s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, VAR_2, 0);",
"if ((unsigned char*)-1 == s->video_buf) {",
"av_log(VAR_0, AV_LOG_ERROR, \"mmap: %s\\n\", strerror(errno));",
"goto fail;",
"}",
"}",
"s->gb_frame = 0;",
"s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;",
"s->gb_buf.frame = s->gb_frame % s->gb_buffers.frames;",
"s->gb_buf.height = s->video_win.height;",
"s->gb_buf.width = s->video_win.width;",
"s->gb_buf.format = VAR_7.palette;",
"if (ioctl(VAR_2, VIDIOCMCAPTURE, &s->gb_buf) < 0) {",
"if (errno != EAGAIN) {",
"fail1:\nav_log(VAR_0, AV_LOG_ERROR, \"VIDIOCMCAPTURE: %s\\n\", strerror(errno));",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"Fatal: grab device does not receive any video signal\\n\");",
"}",
"goto fail;",
"}",
"for (VAR_8 = 1; VAR_8 < s->gb_buffers.frames; VAR_8++) {",
"s->gb_buf.frame = VAR_8;",
"ioctl(VAR_2, VIDIOCMCAPTURE, &s->gb_buf);",
"}",
"s->frame_format = s->gb_buf.format;",
"s->use_mmap = 1;",
"}",
"for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {",
"if (s->frame_format == video_formats[VAR_8].palette) {",
"s->frame_size = s->video_win.width * s->video_win.height * video_formats[VAR_8].depth / 8;",
"st->codec->pix_fmt = video_formats[VAR_8].pix_fmt;",
"break;",
"}",
"}",
"if (VAR_8 >= VAR_9)\ngoto fail;",
"s->fd = VAR_2;",
"st->codec->codec_type = AVMEDIA_TYPE_VIDEO;",
"st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;",
"st->codec->width = s->video_win.width;",
"st->codec->height = s->video_win.height;",
"st->codec->time_base = s->time_base;",
"st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;",
"return 0;",
"fail:\nif (VAR_2 >= 0)\nclose(VAR_2);",
"return AVERROR(EIO);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
47
],
[
49,
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105,
107
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
133
],
[
135
],
[
137
],
[
139
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159,
161
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177,
179
],
[
181
],
[
183,
185
],
[
187
],
[
191
],
[
195
],
[
199
],
[
201
],
[
203
],
[
205
],
[
209
],
[
211
],
[
213
],
[
215
],
[
219
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
265
],
[
267
],
[
269
],
[
271
],
[
275
],
[
277
],
[
279,
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303
],
[
305
],
[
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
321
],
[
325,
327
],
[
331
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
349
],
[
351,
353,
355
],
[
357
],
[
359
]
] |
23,883 | int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
{
put_be32(pb, 0x14 ); /* size */
put_tag(pb, "ftyp");
if (!strcmp("3gp", s->oformat->name))
put_tag(pb, "3gp4");
else
put_tag(pb, "isom");
put_be32(pb, 0x200 );
if (!strcmp("3gp", s->oformat->name))
put_tag(pb, "3gp4");
else
put_tag(pb, "mp41");
return 0x14;
}
| false | FFmpeg | 69dde1ad36b7d95b8b9268f414aa6c076212ed41 | int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
{
put_be32(pb, 0x14 );
put_tag(pb, "ftyp");
if (!strcmp("3gp", s->oformat->name))
put_tag(pb, "3gp4");
else
put_tag(pb, "isom");
put_be32(pb, 0x200 );
if (!strcmp("3gp", s->oformat->name))
put_tag(pb, "3gp4");
else
put_tag(pb, "mp41");
return 0x14;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(ByteIOContext *VAR_0, AVFormatContext *VAR_1)
{
put_be32(VAR_0, 0x14 );
put_tag(VAR_0, "ftyp");
if (!strcmp("3gp", VAR_1->oformat->name))
put_tag(VAR_0, "3gp4");
else
put_tag(VAR_0, "isom");
put_be32(VAR_0, 0x200 );
if (!strcmp("3gp", VAR_1->oformat->name))
put_tag(VAR_0, "3gp4");
else
put_tag(VAR_0, "mp41");
return 0x14;
}
| [
"int FUNC_0(ByteIOContext *VAR_0, AVFormatContext *VAR_1)\n{",
"put_be32(VAR_0, 0x14 );",
"put_tag(VAR_0, \"ftyp\");",
"if (!strcmp(\"3gp\", VAR_1->oformat->name))\nput_tag(VAR_0, \"3gp4\");",
"else\nput_tag(VAR_0, \"isom\");",
"put_be32(VAR_0, 0x200 );",
"if (!strcmp(\"3gp\", VAR_1->oformat->name))\nput_tag(VAR_0, \"3gp4\");",
"else\nput_tag(VAR_0, \"mp41\");",
"return 0x14;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15,
17
],
[
21
],
[
25,
27
],
[
29,
31
],
[
35
],
[
37
]
] |
23,884 | int qemu_strtoul(const char *nptr, const char **endptr, int base,
unsigned long *result)
{
char *p;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtoul(nptr, &p, base);
err = check_strtox_error(endptr, p, errno);
}
return err;
}
| true | qemu | 47d4be12c3997343e436c6cca89aefbbbeb70863 | int qemu_strtoul(const char *nptr, const char **endptr, int base,
unsigned long *result)
{
char *p;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtoul(nptr, &p, base);
err = check_strtox_error(endptr, p, errno);
}
return err;
}
| {
"code": [
" err = check_strtox_error(endptr, p, errno);",
" err = check_strtox_error(endptr, p, errno);",
" err = check_strtox_error(endptr, p, errno);",
" err = check_strtox_error(endptr, p, errno);"
],
"line_no": [
27,
27,
27,
27
]
} | int FUNC_0(const char *VAR_0, const char **VAR_1, int VAR_2,
unsigned long *VAR_3)
{
char *VAR_4;
int VAR_5 = 0;
if (!VAR_0) {
if (VAR_1) {
*VAR_1 = VAR_0;
}
VAR_5 = -EINVAL;
} else {
errno = 0;
*VAR_3 = strtoul(VAR_0, &VAR_4, VAR_2);
VAR_5 = check_strtox_error(VAR_1, VAR_4, errno);
}
return VAR_5;
}
| [
"int FUNC_0(const char *VAR_0, const char **VAR_1, int VAR_2,\nunsigned long *VAR_3)\n{",
"char *VAR_4;",
"int VAR_5 = 0;",
"if (!VAR_0) {",
"if (VAR_1) {",
"*VAR_1 = VAR_0;",
"}",
"VAR_5 = -EINVAL;",
"} else {",
"errno = 0;",
"*VAR_3 = strtoul(VAR_0, &VAR_4, VAR_2);",
"VAR_5 = check_strtox_error(VAR_1, VAR_4, errno);",
"}",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
23,885 | static void virtio_9p_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
dc->props = virtio_9p_properties;
set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
vdc->realize = virtio_9p_device_realize;
vdc->get_features = virtio_9p_get_features;
vdc->get_config = virtio_9p_get_config;
} | true | qemu | 6cecf093735f2e5af7d0e29d957350320044e354 | static void virtio_9p_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
dc->props = virtio_9p_properties;
set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
vdc->realize = virtio_9p_device_realize;
vdc->get_features = virtio_9p_get_features;
vdc->get_config = virtio_9p_get_config;
} | {
"code": [],
"line_no": []
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(VAR_0);
dc->props = virtio_9p_properties;
set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
vdc->realize = virtio_9p_device_realize;
vdc->get_features = virtio_9p_get_features;
vdc->get_config = virtio_9p_get_config;
} | [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(VAR_0);",
"dc->props = virtio_9p_properties;",
"set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);",
"vdc->realize = virtio_9p_device_realize;",
"vdc->get_features = virtio_9p_get_features;",
"vdc->get_config = virtio_9p_get_config;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
18
],
[
20
],
[
22
]
] |
23,886 | static void stereo_processing(PSContext *ps, float (*l)[32][2], float (*r)[32][2], int is34)
{
int e, b, k;
float (*H11)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H11;
float (*H12)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H12;
float (*H21)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H21;
float (*H22)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H22;
int8_t *opd_hist = ps->opd_hist;
int8_t *ipd_hist = ps->ipd_hist;
int8_t iid_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t icc_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t ipd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t opd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t (*iid_mapped)[PS_MAX_NR_IIDICC] = iid_mapped_buf;
int8_t (*icc_mapped)[PS_MAX_NR_IIDICC] = icc_mapped_buf;
int8_t (*ipd_mapped)[PS_MAX_NR_IIDICC] = ipd_mapped_buf;
int8_t (*opd_mapped)[PS_MAX_NR_IIDICC] = opd_mapped_buf;
const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20;
TABLE_CONST float (*H_LUT)[8][4] = (PS_BASELINE || ps->icc_mode < 3) ? HA : HB;
//Remapping
if (ps->num_env_old) {
memcpy(H11[0][0], H11[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H11[0][0][0]));
memcpy(H11[1][0], H11[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H11[1][0][0]));
memcpy(H12[0][0], H12[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H12[0][0][0]));
memcpy(H12[1][0], H12[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H12[1][0][0]));
memcpy(H21[0][0], H21[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H21[0][0][0]));
memcpy(H21[1][0], H21[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H21[1][0][0]));
memcpy(H22[0][0], H22[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H22[0][0][0]));
memcpy(H22[1][0], H22[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H22[1][0][0]));
}
if (is34) {
remap34(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1);
remap34(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1);
if (ps->enable_ipdopd) {
remap34(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0);
remap34(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0);
}
if (!ps->is34bands_old) {
map_val_20_to_34(H11[0][0]);
map_val_20_to_34(H11[1][0]);
map_val_20_to_34(H12[0][0]);
map_val_20_to_34(H12[1][0]);
map_val_20_to_34(H21[0][0]);
map_val_20_to_34(H21[1][0]);
map_val_20_to_34(H22[0][0]);
map_val_20_to_34(H22[1][0]);
ipdopd_reset(ipd_hist, opd_hist);
}
} else {
remap20(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1);
remap20(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1);
if (ps->enable_ipdopd) {
remap20(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0);
remap20(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0);
}
if (ps->is34bands_old) {
map_val_34_to_20(H11[0][0]);
map_val_34_to_20(H11[1][0]);
map_val_34_to_20(H12[0][0]);
map_val_34_to_20(H12[1][0]);
map_val_34_to_20(H21[0][0]);
map_val_34_to_20(H21[1][0]);
map_val_34_to_20(H22[0][0]);
map_val_34_to_20(H22[1][0]);
ipdopd_reset(ipd_hist, opd_hist);
}
}
//Mixing
for (e = 0; e < ps->num_env; e++) {
for (b = 0; b < NR_PAR_BANDS[is34]; b++) {
float h11, h12, h21, h22;
h11 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][0];
h12 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][1];
h21 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][2];
h22 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][3];
if (!PS_BASELINE && ps->enable_ipdopd && 2*b <= NR_PAR_BANDS[is34]) {
//The spec say says to only run this smoother when enable_ipdopd
//is set but the reference decoder appears to run it constantly
float h11i, h12i, h21i, h22i;
float ipd_adj_re, ipd_adj_im;
int opd_idx = opd_hist[b] * 8 + opd_mapped[e][b];
int ipd_idx = ipd_hist[b] * 8 + ipd_mapped[e][b];
float opd_re = pd_re_smooth[opd_idx];
float opd_im = pd_im_smooth[opd_idx];
float ipd_re = pd_re_smooth[ipd_idx];
float ipd_im = pd_im_smooth[ipd_idx];
opd_hist[b] = opd_idx & 0x3F;
ipd_hist[b] = ipd_idx & 0x3F;
ipd_adj_re = opd_re*ipd_re + opd_im*ipd_im;
ipd_adj_im = opd_im*ipd_re - opd_re*ipd_im;
h11i = h11 * opd_im;
h11 = h11 * opd_re;
h12i = h12 * ipd_adj_im;
h12 = h12 * ipd_adj_re;
h21i = h21 * opd_im;
h21 = h21 * opd_re;
h22i = h22 * ipd_adj_im;
h22 = h22 * ipd_adj_re;
H11[1][e+1][b] = h11i;
H12[1][e+1][b] = h12i;
H21[1][e+1][b] = h21i;
H22[1][e+1][b] = h22i;
}
H11[0][e+1][b] = h11;
H12[0][e+1][b] = h12;
H21[0][e+1][b] = h21;
H22[0][e+1][b] = h22;
}
for (k = 0; k < NR_BANDS[is34]; k++) {
float h[2][4];
float h_step[2][4];
int start = ps->border_position[e];
int stop = ps->border_position[e+1];
float width = 1.f / (stop - start);
b = k_to_i[k];
h[0][0] = H11[0][e][b];
h[0][1] = H12[0][e][b];
h[0][2] = H21[0][e][b];
h[0][3] = H22[0][e][b];
if (!PS_BASELINE && ps->enable_ipdopd) {
//Is this necessary? ps_04_new seems unchanged
if ((is34 && k <= 13 && k >= 9) || (!is34 && k <= 1)) {
h[1][0] = -H11[1][e][b];
h[1][1] = -H12[1][e][b];
h[1][2] = -H21[1][e][b];
h[1][3] = -H22[1][e][b];
} else {
h[1][0] = H11[1][e][b];
h[1][1] = H12[1][e][b];
h[1][2] = H21[1][e][b];
h[1][3] = H22[1][e][b];
}
}
//Interpolation
h_step[0][0] = (H11[0][e+1][b] - h[0][0]) * width;
h_step[0][1] = (H12[0][e+1][b] - h[0][1]) * width;
h_step[0][2] = (H21[0][e+1][b] - h[0][2]) * width;
h_step[0][3] = (H22[0][e+1][b] - h[0][3]) * width;
if (!PS_BASELINE && ps->enable_ipdopd) {
h_step[1][0] = (H11[1][e+1][b] - h[1][0]) * width;
h_step[1][1] = (H12[1][e+1][b] - h[1][1]) * width;
h_step[1][2] = (H21[1][e+1][b] - h[1][2]) * width;
h_step[1][3] = (H22[1][e+1][b] - h[1][3]) * width;
}
ps->dsp.stereo_interpolate[!PS_BASELINE && ps->enable_ipdopd](
l[k] + start + 1, r[k] + start + 1,
h, h_step, stop - start);
}
}
}
| true | FFmpeg | 6433b393ba2b1b410ff18e386f84781a760549f5 | static void stereo_processing(PSContext *ps, float (*l)[32][2], float (*r)[32][2], int is34)
{
int e, b, k;
float (*H11)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H11;
float (*H12)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H12;
float (*H21)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H21;
float (*H22)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H22;
int8_t *opd_hist = ps->opd_hist;
int8_t *ipd_hist = ps->ipd_hist;
int8_t iid_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t icc_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t ipd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t opd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t (*iid_mapped)[PS_MAX_NR_IIDICC] = iid_mapped_buf;
int8_t (*icc_mapped)[PS_MAX_NR_IIDICC] = icc_mapped_buf;
int8_t (*ipd_mapped)[PS_MAX_NR_IIDICC] = ipd_mapped_buf;
int8_t (*opd_mapped)[PS_MAX_NR_IIDICC] = opd_mapped_buf;
const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20;
TABLE_CONST float (*H_LUT)[8][4] = (PS_BASELINE || ps->icc_mode < 3) ? HA : HB;
if (ps->num_env_old) {
memcpy(H11[0][0], H11[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H11[0][0][0]));
memcpy(H11[1][0], H11[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H11[1][0][0]));
memcpy(H12[0][0], H12[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H12[0][0][0]));
memcpy(H12[1][0], H12[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H12[1][0][0]));
memcpy(H21[0][0], H21[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H21[0][0][0]));
memcpy(H21[1][0], H21[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H21[1][0][0]));
memcpy(H22[0][0], H22[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H22[0][0][0]));
memcpy(H22[1][0], H22[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H22[1][0][0]));
}
if (is34) {
remap34(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1);
remap34(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1);
if (ps->enable_ipdopd) {
remap34(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0);
remap34(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0);
}
if (!ps->is34bands_old) {
map_val_20_to_34(H11[0][0]);
map_val_20_to_34(H11[1][0]);
map_val_20_to_34(H12[0][0]);
map_val_20_to_34(H12[1][0]);
map_val_20_to_34(H21[0][0]);
map_val_20_to_34(H21[1][0]);
map_val_20_to_34(H22[0][0]);
map_val_20_to_34(H22[1][0]);
ipdopd_reset(ipd_hist, opd_hist);
}
} else {
remap20(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1);
remap20(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1);
if (ps->enable_ipdopd) {
remap20(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0);
remap20(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0);
}
if (ps->is34bands_old) {
map_val_34_to_20(H11[0][0]);
map_val_34_to_20(H11[1][0]);
map_val_34_to_20(H12[0][0]);
map_val_34_to_20(H12[1][0]);
map_val_34_to_20(H21[0][0]);
map_val_34_to_20(H21[1][0]);
map_val_34_to_20(H22[0][0]);
map_val_34_to_20(H22[1][0]);
ipdopd_reset(ipd_hist, opd_hist);
}
}
for (e = 0; e < ps->num_env; e++) {
for (b = 0; b < NR_PAR_BANDS[is34]; b++) {
float h11, h12, h21, h22;
h11 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][0];
h12 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][1];
h21 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][2];
h22 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][3];
if (!PS_BASELINE && ps->enable_ipdopd && 2*b <= NR_PAR_BANDS[is34]) {
float h11i, h12i, h21i, h22i;
float ipd_adj_re, ipd_adj_im;
int opd_idx = opd_hist[b] * 8 + opd_mapped[e][b];
int ipd_idx = ipd_hist[b] * 8 + ipd_mapped[e][b];
float opd_re = pd_re_smooth[opd_idx];
float opd_im = pd_im_smooth[opd_idx];
float ipd_re = pd_re_smooth[ipd_idx];
float ipd_im = pd_im_smooth[ipd_idx];
opd_hist[b] = opd_idx & 0x3F;
ipd_hist[b] = ipd_idx & 0x3F;
ipd_adj_re = opd_re*ipd_re + opd_im*ipd_im;
ipd_adj_im = opd_im*ipd_re - opd_re*ipd_im;
h11i = h11 * opd_im;
h11 = h11 * opd_re;
h12i = h12 * ipd_adj_im;
h12 = h12 * ipd_adj_re;
h21i = h21 * opd_im;
h21 = h21 * opd_re;
h22i = h22 * ipd_adj_im;
h22 = h22 * ipd_adj_re;
H11[1][e+1][b] = h11i;
H12[1][e+1][b] = h12i;
H21[1][e+1][b] = h21i;
H22[1][e+1][b] = h22i;
}
H11[0][e+1][b] = h11;
H12[0][e+1][b] = h12;
H21[0][e+1][b] = h21;
H22[0][e+1][b] = h22;
}
for (k = 0; k < NR_BANDS[is34]; k++) {
float h[2][4];
float h_step[2][4];
int start = ps->border_position[e];
int stop = ps->border_position[e+1];
float width = 1.f / (stop - start);
b = k_to_i[k];
h[0][0] = H11[0][e][b];
h[0][1] = H12[0][e][b];
h[0][2] = H21[0][e][b];
h[0][3] = H22[0][e][b];
if (!PS_BASELINE && ps->enable_ipdopd) {
if ((is34 && k <= 13 && k >= 9) || (!is34 && k <= 1)) {
h[1][0] = -H11[1][e][b];
h[1][1] = -H12[1][e][b];
h[1][2] = -H21[1][e][b];
h[1][3] = -H22[1][e][b];
} else {
h[1][0] = H11[1][e][b];
h[1][1] = H12[1][e][b];
h[1][2] = H21[1][e][b];
h[1][3] = H22[1][e][b];
}
}
h_step[0][0] = (H11[0][e+1][b] - h[0][0]) * width;
h_step[0][1] = (H12[0][e+1][b] - h[0][1]) * width;
h_step[0][2] = (H21[0][e+1][b] - h[0][2]) * width;
h_step[0][3] = (H22[0][e+1][b] - h[0][3]) * width;
if (!PS_BASELINE && ps->enable_ipdopd) {
h_step[1][0] = (H11[1][e+1][b] - h[1][0]) * width;
h_step[1][1] = (H12[1][e+1][b] - h[1][1]) * width;
h_step[1][2] = (H21[1][e+1][b] - h[1][2]) * width;
h_step[1][3] = (H22[1][e+1][b] - h[1][3]) * width;
}
ps->dsp.stereo_interpolate[!PS_BASELINE && ps->enable_ipdopd](
l[k] + start + 1, r[k] + start + 1,
h, h_step, stop - start);
}
}
}
| {
"code": [
" if (!PS_BASELINE && ps->enable_ipdopd && 2*b <= NR_PAR_BANDS[is34]) {"
],
"line_no": [
161
]
} | static void FUNC_0(PSContext *VAR_0, float (*VAR_1)[32][2], float (*VAR_2)[32][2], int VAR_3)
{
int VAR_4, VAR_5, VAR_6;
float (*VAR_7)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_7;
float (*VAR_8)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_8;
float (*VAR_9)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_9;
float (*VAR_10)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_10;
int8_t *opd_hist = VAR_0->opd_hist;
int8_t *ipd_hist = VAR_0->ipd_hist;
int8_t iid_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t icc_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t ipd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t opd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];
int8_t (*iid_mapped)[PS_MAX_NR_IIDICC] = iid_mapped_buf;
int8_t (*icc_mapped)[PS_MAX_NR_IIDICC] = icc_mapped_buf;
int8_t (*ipd_mapped)[PS_MAX_NR_IIDICC] = ipd_mapped_buf;
int8_t (*opd_mapped)[PS_MAX_NR_IIDICC] = opd_mapped_buf;
const int8_t *VAR_11 = VAR_3 ? k_to_i_34 : k_to_i_20;
TABLE_CONST float (*H_LUT)[8][4] = (PS_BASELINE || VAR_0->icc_mode < 3) ? HA : HB;
if (VAR_0->num_env_old) {
memcpy(VAR_7[0][0], VAR_7[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_7[0][0][0]));
memcpy(VAR_7[1][0], VAR_7[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_7[1][0][0]));
memcpy(VAR_8[0][0], VAR_8[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_8[0][0][0]));
memcpy(VAR_8[1][0], VAR_8[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_8[1][0][0]));
memcpy(VAR_9[0][0], VAR_9[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_9[0][0][0]));
memcpy(VAR_9[1][0], VAR_9[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_9[1][0][0]));
memcpy(VAR_10[0][0], VAR_10[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_10[0][0][0]));
memcpy(VAR_10[1][0], VAR_10[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_10[1][0][0]));
}
if (VAR_3) {
remap34(&iid_mapped, VAR_0->iid_par, VAR_0->nr_iid_par, VAR_0->num_env, 1);
remap34(&icc_mapped, VAR_0->icc_par, VAR_0->nr_icc_par, VAR_0->num_env, 1);
if (VAR_0->enable_ipdopd) {
remap34(&ipd_mapped, VAR_0->ipd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);
remap34(&opd_mapped, VAR_0->opd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);
}
if (!VAR_0->is34bands_old) {
map_val_20_to_34(VAR_7[0][0]);
map_val_20_to_34(VAR_7[1][0]);
map_val_20_to_34(VAR_8[0][0]);
map_val_20_to_34(VAR_8[1][0]);
map_val_20_to_34(VAR_9[0][0]);
map_val_20_to_34(VAR_9[1][0]);
map_val_20_to_34(VAR_10[0][0]);
map_val_20_to_34(VAR_10[1][0]);
ipdopd_reset(ipd_hist, opd_hist);
}
} else {
remap20(&iid_mapped, VAR_0->iid_par, VAR_0->nr_iid_par, VAR_0->num_env, 1);
remap20(&icc_mapped, VAR_0->icc_par, VAR_0->nr_icc_par, VAR_0->num_env, 1);
if (VAR_0->enable_ipdopd) {
remap20(&ipd_mapped, VAR_0->ipd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);
remap20(&opd_mapped, VAR_0->opd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);
}
if (VAR_0->is34bands_old) {
map_val_34_to_20(VAR_7[0][0]);
map_val_34_to_20(VAR_7[1][0]);
map_val_34_to_20(VAR_8[0][0]);
map_val_34_to_20(VAR_8[1][0]);
map_val_34_to_20(VAR_9[0][0]);
map_val_34_to_20(VAR_9[1][0]);
map_val_34_to_20(VAR_10[0][0]);
map_val_34_to_20(VAR_10[1][0]);
ipdopd_reset(ipd_hist, opd_hist);
}
}
for (VAR_4 = 0; VAR_4 < VAR_0->num_env; VAR_4++) {
for (VAR_5 = 0; VAR_5 < NR_PAR_BANDS[VAR_3]; VAR_5++) {
float h11, h12, h21, h22;
h11 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][0];
h12 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][1];
h21 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][2];
h22 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][3];
if (!PS_BASELINE && VAR_0->enable_ipdopd && 2*VAR_5 <= NR_PAR_BANDS[VAR_3]) {
float h11i, h12i, h21i, h22i;
float ipd_adj_re, ipd_adj_im;
int opd_idx = opd_hist[VAR_5] * 8 + opd_mapped[VAR_4][VAR_5];
int ipd_idx = ipd_hist[VAR_5] * 8 + ipd_mapped[VAR_4][VAR_5];
float opd_re = pd_re_smooth[opd_idx];
float opd_im = pd_im_smooth[opd_idx];
float ipd_re = pd_re_smooth[ipd_idx];
float ipd_im = pd_im_smooth[ipd_idx];
opd_hist[VAR_5] = opd_idx & 0x3F;
ipd_hist[VAR_5] = ipd_idx & 0x3F;
ipd_adj_re = opd_re*ipd_re + opd_im*ipd_im;
ipd_adj_im = opd_im*ipd_re - opd_re*ipd_im;
h11i = h11 * opd_im;
h11 = h11 * opd_re;
h12i = h12 * ipd_adj_im;
h12 = h12 * ipd_adj_re;
h21i = h21 * opd_im;
h21 = h21 * opd_re;
h22i = h22 * ipd_adj_im;
h22 = h22 * ipd_adj_re;
VAR_7[1][VAR_4+1][VAR_5] = h11i;
VAR_8[1][VAR_4+1][VAR_5] = h12i;
VAR_9[1][VAR_4+1][VAR_5] = h21i;
VAR_10[1][VAR_4+1][VAR_5] = h22i;
}
VAR_7[0][VAR_4+1][VAR_5] = h11;
VAR_8[0][VAR_4+1][VAR_5] = h12;
VAR_9[0][VAR_4+1][VAR_5] = h21;
VAR_10[0][VAR_4+1][VAR_5] = h22;
}
for (VAR_6 = 0; VAR_6 < NR_BANDS[VAR_3]; VAR_6++) {
float h[2][4];
float h_step[2][4];
int start = VAR_0->border_position[VAR_4];
int stop = VAR_0->border_position[VAR_4+1];
float width = 1.f / (stop - start);
VAR_5 = VAR_11[VAR_6];
h[0][0] = VAR_7[0][VAR_4][VAR_5];
h[0][1] = VAR_8[0][VAR_4][VAR_5];
h[0][2] = VAR_9[0][VAR_4][VAR_5];
h[0][3] = VAR_10[0][VAR_4][VAR_5];
if (!PS_BASELINE && VAR_0->enable_ipdopd) {
if ((VAR_3 && VAR_6 <= 13 && VAR_6 >= 9) || (!VAR_3 && VAR_6 <= 1)) {
h[1][0] = -VAR_7[1][VAR_4][VAR_5];
h[1][1] = -VAR_8[1][VAR_4][VAR_5];
h[1][2] = -VAR_9[1][VAR_4][VAR_5];
h[1][3] = -VAR_10[1][VAR_4][VAR_5];
} else {
h[1][0] = VAR_7[1][VAR_4][VAR_5];
h[1][1] = VAR_8[1][VAR_4][VAR_5];
h[1][2] = VAR_9[1][VAR_4][VAR_5];
h[1][3] = VAR_10[1][VAR_4][VAR_5];
}
}
h_step[0][0] = (VAR_7[0][VAR_4+1][VAR_5] - h[0][0]) * width;
h_step[0][1] = (VAR_8[0][VAR_4+1][VAR_5] - h[0][1]) * width;
h_step[0][2] = (VAR_9[0][VAR_4+1][VAR_5] - h[0][2]) * width;
h_step[0][3] = (VAR_10[0][VAR_4+1][VAR_5] - h[0][3]) * width;
if (!PS_BASELINE && VAR_0->enable_ipdopd) {
h_step[1][0] = (VAR_7[1][VAR_4+1][VAR_5] - h[1][0]) * width;
h_step[1][1] = (VAR_8[1][VAR_4+1][VAR_5] - h[1][1]) * width;
h_step[1][2] = (VAR_9[1][VAR_4+1][VAR_5] - h[1][2]) * width;
h_step[1][3] = (VAR_10[1][VAR_4+1][VAR_5] - h[1][3]) * width;
}
VAR_0->dsp.stereo_interpolate[!PS_BASELINE && VAR_0->enable_ipdopd](
VAR_1[VAR_6] + start + 1, VAR_2[VAR_6] + start + 1,
h, h_step, stop - start);
}
}
}
| [
"static void FUNC_0(PSContext *VAR_0, float (*VAR_1)[32][2], float (*VAR_2)[32][2], int VAR_3)\n{",
"int VAR_4, VAR_5, VAR_6;",
"float (*VAR_7)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_7;",
"float (*VAR_8)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_8;",
"float (*VAR_9)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_9;",
"float (*VAR_10)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = VAR_0->VAR_10;",
"int8_t *opd_hist = VAR_0->opd_hist;",
"int8_t *ipd_hist = VAR_0->ipd_hist;",
"int8_t iid_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];",
"int8_t icc_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];",
"int8_t ipd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];",
"int8_t opd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC];",
"int8_t (*iid_mapped)[PS_MAX_NR_IIDICC] = iid_mapped_buf;",
"int8_t (*icc_mapped)[PS_MAX_NR_IIDICC] = icc_mapped_buf;",
"int8_t (*ipd_mapped)[PS_MAX_NR_IIDICC] = ipd_mapped_buf;",
"int8_t (*opd_mapped)[PS_MAX_NR_IIDICC] = opd_mapped_buf;",
"const int8_t *VAR_11 = VAR_3 ? k_to_i_34 : k_to_i_20;",
"TABLE_CONST float (*H_LUT)[8][4] = (PS_BASELINE || VAR_0->icc_mode < 3) ? HA : HB;",
"if (VAR_0->num_env_old) {",
"memcpy(VAR_7[0][0], VAR_7[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_7[0][0][0]));",
"memcpy(VAR_7[1][0], VAR_7[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_7[1][0][0]));",
"memcpy(VAR_8[0][0], VAR_8[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_8[0][0][0]));",
"memcpy(VAR_8[1][0], VAR_8[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_8[1][0][0]));",
"memcpy(VAR_9[0][0], VAR_9[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_9[0][0][0]));",
"memcpy(VAR_9[1][0], VAR_9[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_9[1][0][0]));",
"memcpy(VAR_10[0][0], VAR_10[0][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_10[0][0][0]));",
"memcpy(VAR_10[1][0], VAR_10[1][VAR_0->num_env_old], PS_MAX_NR_IIDICC*sizeof(VAR_10[1][0][0]));",
"}",
"if (VAR_3) {",
"remap34(&iid_mapped, VAR_0->iid_par, VAR_0->nr_iid_par, VAR_0->num_env, 1);",
"remap34(&icc_mapped, VAR_0->icc_par, VAR_0->nr_icc_par, VAR_0->num_env, 1);",
"if (VAR_0->enable_ipdopd) {",
"remap34(&ipd_mapped, VAR_0->ipd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);",
"remap34(&opd_mapped, VAR_0->opd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);",
"}",
"if (!VAR_0->is34bands_old) {",
"map_val_20_to_34(VAR_7[0][0]);",
"map_val_20_to_34(VAR_7[1][0]);",
"map_val_20_to_34(VAR_8[0][0]);",
"map_val_20_to_34(VAR_8[1][0]);",
"map_val_20_to_34(VAR_9[0][0]);",
"map_val_20_to_34(VAR_9[1][0]);",
"map_val_20_to_34(VAR_10[0][0]);",
"map_val_20_to_34(VAR_10[1][0]);",
"ipdopd_reset(ipd_hist, opd_hist);",
"}",
"} else {",
"remap20(&iid_mapped, VAR_0->iid_par, VAR_0->nr_iid_par, VAR_0->num_env, 1);",
"remap20(&icc_mapped, VAR_0->icc_par, VAR_0->nr_icc_par, VAR_0->num_env, 1);",
"if (VAR_0->enable_ipdopd) {",
"remap20(&ipd_mapped, VAR_0->ipd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);",
"remap20(&opd_mapped, VAR_0->opd_par, VAR_0->nr_ipdopd_par, VAR_0->num_env, 0);",
"}",
"if (VAR_0->is34bands_old) {",
"map_val_34_to_20(VAR_7[0][0]);",
"map_val_34_to_20(VAR_7[1][0]);",
"map_val_34_to_20(VAR_8[0][0]);",
"map_val_34_to_20(VAR_8[1][0]);",
"map_val_34_to_20(VAR_9[0][0]);",
"map_val_34_to_20(VAR_9[1][0]);",
"map_val_34_to_20(VAR_10[0][0]);",
"map_val_34_to_20(VAR_10[1][0]);",
"ipdopd_reset(ipd_hist, opd_hist);",
"}",
"}",
"for (VAR_4 = 0; VAR_4 < VAR_0->num_env; VAR_4++) {",
"for (VAR_5 = 0; VAR_5 < NR_PAR_BANDS[VAR_3]; VAR_5++) {",
"float h11, h12, h21, h22;",
"h11 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][0];",
"h12 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][1];",
"h21 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][2];",
"h22 = H_LUT[iid_mapped[VAR_4][VAR_5] + 7 + 23 * VAR_0->iid_quant][icc_mapped[VAR_4][VAR_5]][3];",
"if (!PS_BASELINE && VAR_0->enable_ipdopd && 2*VAR_5 <= NR_PAR_BANDS[VAR_3]) {",
"float h11i, h12i, h21i, h22i;",
"float ipd_adj_re, ipd_adj_im;",
"int opd_idx = opd_hist[VAR_5] * 8 + opd_mapped[VAR_4][VAR_5];",
"int ipd_idx = ipd_hist[VAR_5] * 8 + ipd_mapped[VAR_4][VAR_5];",
"float opd_re = pd_re_smooth[opd_idx];",
"float opd_im = pd_im_smooth[opd_idx];",
"float ipd_re = pd_re_smooth[ipd_idx];",
"float ipd_im = pd_im_smooth[ipd_idx];",
"opd_hist[VAR_5] = opd_idx & 0x3F;",
"ipd_hist[VAR_5] = ipd_idx & 0x3F;",
"ipd_adj_re = opd_re*ipd_re + opd_im*ipd_im;",
"ipd_adj_im = opd_im*ipd_re - opd_re*ipd_im;",
"h11i = h11 * opd_im;",
"h11 = h11 * opd_re;",
"h12i = h12 * ipd_adj_im;",
"h12 = h12 * ipd_adj_re;",
"h21i = h21 * opd_im;",
"h21 = h21 * opd_re;",
"h22i = h22 * ipd_adj_im;",
"h22 = h22 * ipd_adj_re;",
"VAR_7[1][VAR_4+1][VAR_5] = h11i;",
"VAR_8[1][VAR_4+1][VAR_5] = h12i;",
"VAR_9[1][VAR_4+1][VAR_5] = h21i;",
"VAR_10[1][VAR_4+1][VAR_5] = h22i;",
"}",
"VAR_7[0][VAR_4+1][VAR_5] = h11;",
"VAR_8[0][VAR_4+1][VAR_5] = h12;",
"VAR_9[0][VAR_4+1][VAR_5] = h21;",
"VAR_10[0][VAR_4+1][VAR_5] = h22;",
"}",
"for (VAR_6 = 0; VAR_6 < NR_BANDS[VAR_3]; VAR_6++) {",
"float h[2][4];",
"float h_step[2][4];",
"int start = VAR_0->border_position[VAR_4];",
"int stop = VAR_0->border_position[VAR_4+1];",
"float width = 1.f / (stop - start);",
"VAR_5 = VAR_11[VAR_6];",
"h[0][0] = VAR_7[0][VAR_4][VAR_5];",
"h[0][1] = VAR_8[0][VAR_4][VAR_5];",
"h[0][2] = VAR_9[0][VAR_4][VAR_5];",
"h[0][3] = VAR_10[0][VAR_4][VAR_5];",
"if (!PS_BASELINE && VAR_0->enable_ipdopd) {",
"if ((VAR_3 && VAR_6 <= 13 && VAR_6 >= 9) || (!VAR_3 && VAR_6 <= 1)) {",
"h[1][0] = -VAR_7[1][VAR_4][VAR_5];",
"h[1][1] = -VAR_8[1][VAR_4][VAR_5];",
"h[1][2] = -VAR_9[1][VAR_4][VAR_5];",
"h[1][3] = -VAR_10[1][VAR_4][VAR_5];",
"} else {",
"h[1][0] = VAR_7[1][VAR_4][VAR_5];",
"h[1][1] = VAR_8[1][VAR_4][VAR_5];",
"h[1][2] = VAR_9[1][VAR_4][VAR_5];",
"h[1][3] = VAR_10[1][VAR_4][VAR_5];",
"}",
"}",
"h_step[0][0] = (VAR_7[0][VAR_4+1][VAR_5] - h[0][0]) * width;",
"h_step[0][1] = (VAR_8[0][VAR_4+1][VAR_5] - h[0][1]) * width;",
"h_step[0][2] = (VAR_9[0][VAR_4+1][VAR_5] - h[0][2]) * width;",
"h_step[0][3] = (VAR_10[0][VAR_4+1][VAR_5] - h[0][3]) * width;",
"if (!PS_BASELINE && VAR_0->enable_ipdopd) {",
"h_step[1][0] = (VAR_7[1][VAR_4+1][VAR_5] - h[1][0]) * width;",
"h_step[1][1] = (VAR_8[1][VAR_4+1][VAR_5] - h[1][1]) * width;",
"h_step[1][2] = (VAR_9[1][VAR_4+1][VAR_5] - h[1][2]) * width;",
"h_step[1][3] = (VAR_10[1][VAR_4+1][VAR_5] - h[1][3]) * width;",
"}",
"VAR_0->dsp.stereo_interpolate[!PS_BASELINE && VAR_0->enable_ipdopd](\nVAR_1[VAR_6] + start + 1, VAR_2[VAR_6] + start + 1,\nh, h_step, stop - start);",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301,
303,
305
],
[
307
],
[
309
],
[
311
]
] |
23,887 | static void openpic_gbl_write(void *opaque, hwaddr addr, uint64_t val,
unsigned len)
{
OpenPICState *opp = opaque;
IRQ_dst_t *dst;
int idx;
DPRINTF("%s: addr " TARGET_FMT_plx " <= %08x\n", __func__, addr, val);
if (addr & 0xF)
return;
switch (addr) {
case 0x00: /* Block Revision Register1 (BRR1) is Readonly */
break;
case 0x40:
case 0x50:
case 0x60:
case 0x70:
case 0x80:
case 0x90:
case 0xA0:
case 0xB0:
openpic_cpu_write_internal(opp, addr, val, get_current_cpu());
break;
case 0x1000: /* FREP */
break;
case 0x1020: /* GLBC */
if (val & GLBC_RESET) {
openpic_reset(&opp->busdev.qdev);
}
break;
case 0x1080: /* VENI */
break;
case 0x1090: /* PINT */
for (idx = 0; idx < opp->nb_cpus; idx++) {
if ((val & (1 << idx)) && !(opp->pint & (1 << idx))) {
DPRINTF("Raise OpenPIC RESET output for CPU %d\n", idx);
dst = &opp->dst[idx];
qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_RESET]);
} else if (!(val & (1 << idx)) && (opp->pint & (1 << idx))) {
DPRINTF("Lower OpenPIC RESET output for CPU %d\n", idx);
dst = &opp->dst[idx];
qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_RESET]);
}
}
opp->pint = val;
break;
case 0x10A0: /* IPI_IPVP */
case 0x10B0:
case 0x10C0:
case 0x10D0:
{
int idx;
idx = (addr - 0x10A0) >> 4;
write_IRQreg_ipvp(opp, opp->irq_ipi0 + idx, val);
}
break;
case 0x10E0: /* SPVE */
opp->spve = val & opp->vector_mask;
break;
default:
break;
}
}
| true | qemu | af7e9e74c6a62a5bcd911726a9e88d28b61490e0 | static void openpic_gbl_write(void *opaque, hwaddr addr, uint64_t val,
unsigned len)
{
OpenPICState *opp = opaque;
IRQ_dst_t *dst;
int idx;
DPRINTF("%s: addr " TARGET_FMT_plx " <= %08x\n", __func__, addr, val);
if (addr & 0xF)
return;
switch (addr) {
case 0x00:
break;
case 0x40:
case 0x50:
case 0x60:
case 0x70:
case 0x80:
case 0x90:
case 0xA0:
case 0xB0:
openpic_cpu_write_internal(opp, addr, val, get_current_cpu());
break;
case 0x1000:
break;
case 0x1020:
if (val & GLBC_RESET) {
openpic_reset(&opp->busdev.qdev);
}
break;
case 0x1080:
break;
case 0x1090:
for (idx = 0; idx < opp->nb_cpus; idx++) {
if ((val & (1 << idx)) && !(opp->pint & (1 << idx))) {
DPRINTF("Raise OpenPIC RESET output for CPU %d\n", idx);
dst = &opp->dst[idx];
qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_RESET]);
} else if (!(val & (1 << idx)) && (opp->pint & (1 << idx))) {
DPRINTF("Lower OpenPIC RESET output for CPU %d\n", idx);
dst = &opp->dst[idx];
qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_RESET]);
}
}
opp->pint = val;
break;
case 0x10A0:
case 0x10B0:
case 0x10C0:
case 0x10D0:
{
int idx;
idx = (addr - 0x10A0) >> 4;
write_IRQreg_ipvp(opp, opp->irq_ipi0 + idx, val);
}
break;
case 0x10E0:
opp->spve = val & opp->vector_mask;
break;
default:
break;
}
}
| {
"code": [
" IRQ_dst_t *dst;",
" IRQ_dst_t *dst;",
" if (addr & 0xF)",
" if (addr & 0xF)",
" if (addr & 0xF)",
" if (addr & 0xF)",
" if (addr & 0xF)",
" IRQ_dst_t *dst;",
" if (addr & 0xF)",
" IRQ_dst_t *dst;",
" if (addr & 0xF)"
],
"line_no": [
9,
9,
17,
17,
17,
17,
17,
9,
17,
9,
17
]
} | static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,
unsigned VAR_3)
{
OpenPICState *opp = VAR_0;
IRQ_dst_t *dst;
int VAR_5;
DPRINTF("%s: VAR_1 " TARGET_FMT_plx " <= %08x\n", __func__, VAR_1, VAR_2);
if (VAR_1 & 0xF)
return;
switch (VAR_1) {
case 0x00:
break;
case 0x40:
case 0x50:
case 0x60:
case 0x70:
case 0x80:
case 0x90:
case 0xA0:
case 0xB0:
openpic_cpu_write_internal(opp, VAR_1, VAR_2, get_current_cpu());
break;
case 0x1000:
break;
case 0x1020:
if (VAR_2 & GLBC_RESET) {
openpic_reset(&opp->busdev.qdev);
}
break;
case 0x1080:
break;
case 0x1090:
for (VAR_5 = 0; VAR_5 < opp->nb_cpus; VAR_5++) {
if ((VAR_2 & (1 << VAR_5)) && !(opp->pint & (1 << VAR_5))) {
DPRINTF("Raise OpenPIC RESET output for CPU %d\n", VAR_5);
dst = &opp->dst[VAR_5];
qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_RESET]);
} else if (!(VAR_2 & (1 << VAR_5)) && (opp->pint & (1 << VAR_5))) {
DPRINTF("Lower OpenPIC RESET output for CPU %d\n", VAR_5);
dst = &opp->dst[VAR_5];
qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_RESET]);
}
}
opp->pint = VAR_2;
break;
case 0x10A0:
case 0x10B0:
case 0x10C0:
case 0x10D0:
{
int VAR_5;
VAR_5 = (VAR_1 - 0x10A0) >> 4;
write_IRQreg_ipvp(opp, opp->irq_ipi0 + VAR_5, VAR_2);
}
break;
case 0x10E0:
opp->spve = VAR_2 & opp->vector_mask;
break;
default:
break;
}
}
| [
"static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{",
"OpenPICState *opp = VAR_0;",
"IRQ_dst_t *dst;",
"int VAR_5;",
"DPRINTF(\"%s: VAR_1 \" TARGET_FMT_plx \" <= %08x\\n\", __func__, VAR_1, VAR_2);",
"if (VAR_1 & 0xF)\nreturn;",
"switch (VAR_1) {",
"case 0x00:\nbreak;",
"case 0x40:\ncase 0x50:\ncase 0x60:\ncase 0x70:\ncase 0x80:\ncase 0x90:\ncase 0xA0:\ncase 0xB0:\nopenpic_cpu_write_internal(opp, VAR_1, VAR_2, get_current_cpu());",
"break;",
"case 0x1000:\nbreak;",
"case 0x1020:\nif (VAR_2 & GLBC_RESET) {",
"openpic_reset(&opp->busdev.qdev);",
"}",
"break;",
"case 0x1080:\nbreak;",
"case 0x1090:\nfor (VAR_5 = 0; VAR_5 < opp->nb_cpus; VAR_5++) {",
"if ((VAR_2 & (1 << VAR_5)) && !(opp->pint & (1 << VAR_5))) {",
"DPRINTF(\"Raise OpenPIC RESET output for CPU %d\\n\", VAR_5);",
"dst = &opp->dst[VAR_5];",
"qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_RESET]);",
"} else if (!(VAR_2 & (1 << VAR_5)) && (opp->pint & (1 << VAR_5))) {",
"DPRINTF(\"Lower OpenPIC RESET output for CPU %d\\n\", VAR_5);",
"dst = &opp->dst[VAR_5];",
"qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_RESET]);",
"}",
"}",
"opp->pint = VAR_2;",
"break;",
"case 0x10A0:\ncase 0x10B0:\ncase 0x10C0:\ncase 0x10D0:\n{",
"int VAR_5;",
"VAR_5 = (VAR_1 - 0x10A0) >> 4;",
"write_IRQreg_ipvp(opp, opp->irq_ipi0 + VAR_5, VAR_2);",
"}",
"break;",
"case 0x10E0:\nopp->spve = VAR_2 & opp->vector_mask;",
"break;",
"default:\nbreak;",
"}",
"}"
] | [
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17,
19
],
[
21
],
[
23,
25
],
[
27,
29,
31,
33,
35,
37,
39,
41,
43
],
[
45
],
[
47,
49
],
[
51,
53
],
[
55
],
[
57
],
[
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93,
95,
97,
99,
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
119,
121
],
[
123
],
[
125
]
] |
23,889 | static int decode_header(MPADecodeContext *s, uint32_t header)
{
int sample_rate, frame_size, mpeg25, padding;
int sample_rate_index, bitrate_index;
if (header & (1<<20)) {
s->lsf = (header & (1<<19)) ? 0 : 1;
mpeg25 = 0;
} else {
s->lsf = 1;
mpeg25 = 1;
}
s->layer = 4 - ((header >> 17) & 3);
/* extract frequency */
sample_rate_index = (header >> 10) & 3;
sample_rate = mpa_freq_tab[sample_rate_index] >> (s->lsf + mpeg25);
sample_rate_index += 3 * (s->lsf + mpeg25);
s->sample_rate_index = sample_rate_index;
s->error_protection = ((header >> 16) & 1) ^ 1;
s->sample_rate = sample_rate;
bitrate_index = (header >> 12) & 0xf;
padding = (header >> 9) & 1;
//extension = (header >> 8) & 1;
s->mode = (header >> 6) & 3;
s->mode_ext = (header >> 4) & 3;
//copyright = (header >> 3) & 1;
//original = (header >> 2) & 1;
//emphasis = header & 3;
if (s->mode == MPA_MONO)
s->nb_channels = 1;
else
s->nb_channels = 2;
if (bitrate_index != 0) {
frame_size = mpa_bitrate_tab[s->lsf][s->layer - 1][bitrate_index];
s->bit_rate = frame_size * 1000;
switch(s->layer) {
case 1:
frame_size = (frame_size * 12000) / sample_rate;
frame_size = (frame_size + padding) * 4;
break;
case 2:
frame_size = (frame_size * 144000) / sample_rate;
frame_size += padding;
break;
default:
case 3:
frame_size = (frame_size * 144000) / (sample_rate << s->lsf);
frame_size += padding;
break;
}
s->frame_size = frame_size;
} else {
/* if no frame size computed, signal it */
if (!s->free_format_frame_size)
return 1;
/* free format: compute bitrate and real frame size from the
frame size we extracted by reading the bitstream */
s->frame_size = s->free_format_frame_size;
switch(s->layer) {
case 1:
s->frame_size += padding * 4;
s->bit_rate = (s->frame_size * sample_rate) / 48000;
break;
case 2:
s->frame_size += padding;
s->bit_rate = (s->frame_size * sample_rate) / 144000;
break;
default:
case 3:
s->frame_size += padding;
s->bit_rate = (s->frame_size * (sample_rate << s->lsf)) / 144000;
break;
}
}
#if defined(DEBUG)
dprintf("layer%d, %d Hz, %d kbits/s, ",
s->layer, s->sample_rate, s->bit_rate);
if (s->nb_channels == 2) {
if (s->layer == 3) {
if (s->mode_ext & MODE_EXT_MS_STEREO)
dprintf("ms-");
if (s->mode_ext & MODE_EXT_I_STEREO)
dprintf("i-");
}
dprintf("stereo");
} else {
dprintf("mono");
}
dprintf("\n");
#endif
return 0;
}
| true | FFmpeg | 8e453fc3c76ee59c111fa5b40e87341d2bab2dcd | static int decode_header(MPADecodeContext *s, uint32_t header)
{
int sample_rate, frame_size, mpeg25, padding;
int sample_rate_index, bitrate_index;
if (header & (1<<20)) {
s->lsf = (header & (1<<19)) ? 0 : 1;
mpeg25 = 0;
} else {
s->lsf = 1;
mpeg25 = 1;
}
s->layer = 4 - ((header >> 17) & 3);
sample_rate_index = (header >> 10) & 3;
sample_rate = mpa_freq_tab[sample_rate_index] >> (s->lsf + mpeg25);
sample_rate_index += 3 * (s->lsf + mpeg25);
s->sample_rate_index = sample_rate_index;
s->error_protection = ((header >> 16) & 1) ^ 1;
s->sample_rate = sample_rate;
bitrate_index = (header >> 12) & 0xf;
padding = (header >> 9) & 1;
s->mode = (header >> 6) & 3;
s->mode_ext = (header >> 4) & 3;
if (s->mode == MPA_MONO)
s->nb_channels = 1;
else
s->nb_channels = 2;
if (bitrate_index != 0) {
frame_size = mpa_bitrate_tab[s->lsf][s->layer - 1][bitrate_index];
s->bit_rate = frame_size * 1000;
switch(s->layer) {
case 1:
frame_size = (frame_size * 12000) / sample_rate;
frame_size = (frame_size + padding) * 4;
break;
case 2:
frame_size = (frame_size * 144000) / sample_rate;
frame_size += padding;
break;
default:
case 3:
frame_size = (frame_size * 144000) / (sample_rate << s->lsf);
frame_size += padding;
break;
}
s->frame_size = frame_size;
} else {
if (!s->free_format_frame_size)
return 1;
s->frame_size = s->free_format_frame_size;
switch(s->layer) {
case 1:
s->frame_size += padding * 4;
s->bit_rate = (s->frame_size * sample_rate) / 48000;
break;
case 2:
s->frame_size += padding;
s->bit_rate = (s->frame_size * sample_rate) / 144000;
break;
default:
case 3:
s->frame_size += padding;
s->bit_rate = (s->frame_size * (sample_rate << s->lsf)) / 144000;
break;
}
}
#if defined(DEBUG)
dprintf("layer%d, %d Hz, %d kbits/s, ",
s->layer, s->sample_rate, s->bit_rate);
if (s->nb_channels == 2) {
if (s->layer == 3) {
if (s->mode_ext & MODE_EXT_MS_STEREO)
dprintf("ms-");
if (s->mode_ext & MODE_EXT_I_STEREO)
dprintf("i-");
}
dprintf("stereo");
} else {
dprintf("mono");
}
dprintf("\n");
#endif
return 0;
}
| {
"code": [
" if (!s->free_format_frame_size)",
" return 1;",
" s->frame_size = s->free_format_frame_size;",
" switch(s->layer) {",
" case 1:",
" s->frame_size += padding * 4;",
" s->bit_rate = (s->frame_size * sample_rate) / 48000;",
" break;",
" case 2:",
" s->frame_size += padding;",
" s->bit_rate = (s->frame_size * sample_rate) / 144000;",
" break;",
" default:",
" case 3:",
" s->frame_size += padding;",
" s->bit_rate = (s->frame_size * (sample_rate << s->lsf)) / 144000;",
" break;"
],
"line_no": [
113,
115,
121,
77,
79,
127,
129,
85,
87,
135,
137,
85,
95,
97,
135,
147,
85
]
} | static int FUNC_0(MPADecodeContext *VAR_0, uint32_t VAR_1)
{
int VAR_2, VAR_3, VAR_4, VAR_5;
int VAR_6, VAR_7;
if (VAR_1 & (1<<20)) {
VAR_0->lsf = (VAR_1 & (1<<19)) ? 0 : 1;
VAR_4 = 0;
} else {
VAR_0->lsf = 1;
VAR_4 = 1;
}
VAR_0->layer = 4 - ((VAR_1 >> 17) & 3);
VAR_6 = (VAR_1 >> 10) & 3;
VAR_2 = mpa_freq_tab[VAR_6] >> (VAR_0->lsf + VAR_4);
VAR_6 += 3 * (VAR_0->lsf + VAR_4);
VAR_0->VAR_6 = VAR_6;
VAR_0->error_protection = ((VAR_1 >> 16) & 1) ^ 1;
VAR_0->VAR_2 = VAR_2;
VAR_7 = (VAR_1 >> 12) & 0xf;
VAR_5 = (VAR_1 >> 9) & 1;
VAR_0->mode = (VAR_1 >> 6) & 3;
VAR_0->mode_ext = (VAR_1 >> 4) & 3;
if (VAR_0->mode == MPA_MONO)
VAR_0->nb_channels = 1;
else
VAR_0->nb_channels = 2;
if (VAR_7 != 0) {
VAR_3 = mpa_bitrate_tab[VAR_0->lsf][VAR_0->layer - 1][VAR_7];
VAR_0->bit_rate = VAR_3 * 1000;
switch(VAR_0->layer) {
case 1:
VAR_3 = (VAR_3 * 12000) / VAR_2;
VAR_3 = (VAR_3 + VAR_5) * 4;
break;
case 2:
VAR_3 = (VAR_3 * 144000) / VAR_2;
VAR_3 += VAR_5;
break;
default:
case 3:
VAR_3 = (VAR_3 * 144000) / (VAR_2 << VAR_0->lsf);
VAR_3 += VAR_5;
break;
}
VAR_0->VAR_3 = VAR_3;
} else {
if (!VAR_0->free_format_frame_size)
return 1;
VAR_0->VAR_3 = VAR_0->free_format_frame_size;
switch(VAR_0->layer) {
case 1:
VAR_0->VAR_3 += VAR_5 * 4;
VAR_0->bit_rate = (VAR_0->VAR_3 * VAR_2) / 48000;
break;
case 2:
VAR_0->VAR_3 += VAR_5;
VAR_0->bit_rate = (VAR_0->VAR_3 * VAR_2) / 144000;
break;
default:
case 3:
VAR_0->VAR_3 += VAR_5;
VAR_0->bit_rate = (VAR_0->VAR_3 * (VAR_2 << VAR_0->lsf)) / 144000;
break;
}
}
#if defined(DEBUG)
dprintf("layer%d, %d Hz, %d kbits/VAR_0, ",
VAR_0->layer, VAR_0->VAR_2, VAR_0->bit_rate);
if (VAR_0->nb_channels == 2) {
if (VAR_0->layer == 3) {
if (VAR_0->mode_ext & MODE_EXT_MS_STEREO)
dprintf("ms-");
if (VAR_0->mode_ext & MODE_EXT_I_STEREO)
dprintf("i-");
}
dprintf("stereo");
} else {
dprintf("mono");
}
dprintf("\n");
#endif
return 0;
}
| [
"static int FUNC_0(MPADecodeContext *VAR_0, uint32_t VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4, VAR_5;",
"int VAR_6, VAR_7;",
"if (VAR_1 & (1<<20)) {",
"VAR_0->lsf = (VAR_1 & (1<<19)) ? 0 : 1;",
"VAR_4 = 0;",
"} else {",
"VAR_0->lsf = 1;",
"VAR_4 = 1;",
"}",
"VAR_0->layer = 4 - ((VAR_1 >> 17) & 3);",
"VAR_6 = (VAR_1 >> 10) & 3;",
"VAR_2 = mpa_freq_tab[VAR_6] >> (VAR_0->lsf + VAR_4);",
"VAR_6 += 3 * (VAR_0->lsf + VAR_4);",
"VAR_0->VAR_6 = VAR_6;",
"VAR_0->error_protection = ((VAR_1 >> 16) & 1) ^ 1;",
"VAR_0->VAR_2 = VAR_2;",
"VAR_7 = (VAR_1 >> 12) & 0xf;",
"VAR_5 = (VAR_1 >> 9) & 1;",
"VAR_0->mode = (VAR_1 >> 6) & 3;",
"VAR_0->mode_ext = (VAR_1 >> 4) & 3;",
"if (VAR_0->mode == MPA_MONO)\nVAR_0->nb_channels = 1;",
"else\nVAR_0->nb_channels = 2;",
"if (VAR_7 != 0) {",
"VAR_3 = mpa_bitrate_tab[VAR_0->lsf][VAR_0->layer - 1][VAR_7];",
"VAR_0->bit_rate = VAR_3 * 1000;",
"switch(VAR_0->layer) {",
"case 1:\nVAR_3 = (VAR_3 * 12000) / VAR_2;",
"VAR_3 = (VAR_3 + VAR_5) * 4;",
"break;",
"case 2:\nVAR_3 = (VAR_3 * 144000) / VAR_2;",
"VAR_3 += VAR_5;",
"break;",
"default:\ncase 3:\nVAR_3 = (VAR_3 * 144000) / (VAR_2 << VAR_0->lsf);",
"VAR_3 += VAR_5;",
"break;",
"}",
"VAR_0->VAR_3 = VAR_3;",
"} else {",
"if (!VAR_0->free_format_frame_size)\nreturn 1;",
"VAR_0->VAR_3 = VAR_0->free_format_frame_size;",
"switch(VAR_0->layer) {",
"case 1:\nVAR_0->VAR_3 += VAR_5 * 4;",
"VAR_0->bit_rate = (VAR_0->VAR_3 * VAR_2) / 48000;",
"break;",
"case 2:\nVAR_0->VAR_3 += VAR_5;",
"VAR_0->bit_rate = (VAR_0->VAR_3 * VAR_2) / 144000;",
"break;",
"default:\ncase 3:\nVAR_0->VAR_3 += VAR_5;",
"VAR_0->bit_rate = (VAR_0->VAR_3 * (VAR_2 << VAR_0->lsf)) / 144000;",
"break;",
"}",
"}",
"#if defined(DEBUG)\ndprintf(\"layer%d, %d Hz, %d kbits/VAR_0, \",\nVAR_0->layer, VAR_0->VAR_2, VAR_0->bit_rate);",
"if (VAR_0->nb_channels == 2) {",
"if (VAR_0->layer == 3) {",
"if (VAR_0->mode_ext & MODE_EXT_MS_STEREO)\ndprintf(\"ms-\");",
"if (VAR_0->mode_ext & MODE_EXT_I_STEREO)\ndprintf(\"i-\");",
"}",
"dprintf(\"stereo\");",
"} else {",
"dprintf(\"mono\");",
"}",
"dprintf(\"\\n\");",
"#endif\nreturn 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
1,
1,
0,
0,
1,
0,
0,
0,
0,
0,
1,
1,
0,
1,
1,
0,
1,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
49
],
[
51
],
[
61,
63
],
[
65,
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
95,
97,
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
113,
115
],
[
121
],
[
123
],
[
125,
127
],
[
129
],
[
131
],
[
133,
135
],
[
137
],
[
139
],
[
141,
143,
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157,
159,
161
],
[
163
],
[
165
],
[
167,
169
],
[
171,
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187,
189
],
[
191
]
] |
23,890 | void HELPER(divs)(CPUM68KState *env, uint32_t word)
{
int32_t num;
int32_t den;
int32_t quot;
int32_t rem;
num = env->div1;
den = env->div2;
if (den == 0) {
raise_exception(env, EXCP_DIV0);
}
quot = num / den;
rem = num % den;
env->cc_v = (word && quot != (int16_t)quot ? -1 : 0);
env->cc_z = quot;
env->cc_n = quot;
env->cc_c = 0;
env->div1 = quot;
env->div2 = rem;
}
| true | qemu | 0ccb9c1d8128a020720d5c6abf99a470742a1b94 | void HELPER(divs)(CPUM68KState *env, uint32_t word)
{
int32_t num;
int32_t den;
int32_t quot;
int32_t rem;
num = env->div1;
den = env->div2;
if (den == 0) {
raise_exception(env, EXCP_DIV0);
}
quot = num / den;
rem = num % den;
env->cc_v = (word && quot != (int16_t)quot ? -1 : 0);
env->cc_z = quot;
env->cc_n = quot;
env->cc_c = 0;
env->div1 = quot;
env->div2 = rem;
}
| {
"code": [
" num = env->div1;",
" den = env->div2;",
" raise_exception(env, EXCP_DIV0);",
" env->div1 = quot;",
" env->div2 = rem;",
"void HELPER(divs)(CPUM68KState *env, uint32_t word)",
" int32_t num;",
" int32_t den;",
" int32_t quot;",
" num = env->div1;",
" den = env->div2;",
" raise_exception(env, EXCP_DIV0);",
" env->cc_v = (word && quot != (int16_t)quot ? -1 : 0);",
" env->cc_c = 0;",
" env->div1 = quot;",
" env->div2 = rem;"
],
"line_no": [
15,
17,
21,
41,
43,
1,
5,
7,
9,
15,
17,
21,
31,
37,
41,
43
]
} | void FUNC_0(divs)(CPUM68KState *env, uint32_t word)
{
int32_t num;
int32_t den;
int32_t quot;
int32_t rem;
num = env->div1;
den = env->div2;
if (den == 0) {
raise_exception(env, EXCP_DIV0);
}
quot = num / den;
rem = num % den;
env->cc_v = (word && quot != (int16_t)quot ? -1 : 0);
env->cc_z = quot;
env->cc_n = quot;
env->cc_c = 0;
env->div1 = quot;
env->div2 = rem;
}
| [
"void FUNC_0(divs)(CPUM68KState *env, uint32_t word)\n{",
"int32_t num;",
"int32_t den;",
"int32_t quot;",
"int32_t rem;",
"num = env->div1;",
"den = env->div2;",
"if (den == 0) {",
"raise_exception(env, EXCP_DIV0);",
"}",
"quot = num / den;",
"rem = num % den;",
"env->cc_v = (word && quot != (int16_t)quot ? -1 : 0);",
"env->cc_z = quot;",
"env->cc_n = quot;",
"env->cc_c = 0;",
"env->div1 = quot;",
"env->div2 = rem;",
"}"
] | [
1,
1,
1,
1,
0,
1,
1,
0,
1,
0,
0,
0,
1,
0,
0,
1,
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
]
] |
23,891 | static void dma_bdrv_cb(void *opaque, int ret)
{
DMAAIOCB *dbs = (DMAAIOCB *)opaque;
target_phys_addr_t cur_addr, cur_len;
void *mem;
dbs->acb = NULL;
dbs->sector_num += dbs->iov.size / 512;
dma_bdrv_unmap(dbs);
qemu_iovec_reset(&dbs->iov);
if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) {
dbs->common.cb(dbs->common.opaque, ret);
qemu_iovec_destroy(&dbs->iov);
qemu_aio_release(dbs);
return;
}
while (dbs->sg_cur_index < dbs->sg->nsg) {
cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;
cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;
mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);
if (!mem)
break;
qemu_iovec_add(&dbs->iov, mem, cur_len);
dbs->sg_cur_byte += cur_len;
if (dbs->sg_cur_byte == dbs->sg->sg[dbs->sg_cur_index].len) {
dbs->sg_cur_byte = 0;
++dbs->sg_cur_index;
}
}
if (dbs->iov.size == 0) {
cpu_register_map_client(dbs, continue_after_map_failure);
return;
}
dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,
dbs->iov.size / 512, dma_bdrv_cb, dbs);
if (!dbs->acb) {
dma_bdrv_unmap(dbs);
qemu_iovec_destroy(&dbs->iov);
return;
}
}
| true | qemu | c3adb5b9168a57790b5074489b6f0275ac3cc8b5 | static void dma_bdrv_cb(void *opaque, int ret)
{
DMAAIOCB *dbs = (DMAAIOCB *)opaque;
target_phys_addr_t cur_addr, cur_len;
void *mem;
dbs->acb = NULL;
dbs->sector_num += dbs->iov.size / 512;
dma_bdrv_unmap(dbs);
qemu_iovec_reset(&dbs->iov);
if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) {
dbs->common.cb(dbs->common.opaque, ret);
qemu_iovec_destroy(&dbs->iov);
qemu_aio_release(dbs);
return;
}
while (dbs->sg_cur_index < dbs->sg->nsg) {
cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;
cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;
mem = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);
if (!mem)
break;
qemu_iovec_add(&dbs->iov, mem, cur_len);
dbs->sg_cur_byte += cur_len;
if (dbs->sg_cur_byte == dbs->sg->sg[dbs->sg_cur_index].len) {
dbs->sg_cur_byte = 0;
++dbs->sg_cur_index;
}
}
if (dbs->iov.size == 0) {
cpu_register_map_client(dbs, continue_after_map_failure);
return;
}
dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,
dbs->iov.size / 512, dma_bdrv_cb, dbs);
if (!dbs->acb) {
dma_bdrv_unmap(dbs);
qemu_iovec_destroy(&dbs->iov);
return;
}
}
| {
"code": [
" qemu_iovec_reset(&dbs->iov);",
" dbs->common.cb(dbs->common.opaque, ret);",
" qemu_iovec_destroy(&dbs->iov);",
" qemu_aio_release(dbs);",
" dma_bdrv_unmap(dbs);",
" qemu_iovec_destroy(&dbs->iov);",
" if (!dbs->acb) {",
" qemu_aio_release(dbs);"
],
"line_no": [
19,
25,
27,
29,
81,
27,
79,
29
]
} | static void FUNC_0(void *VAR_0, int VAR_1)
{
DMAAIOCB *dbs = (DMAAIOCB *)VAR_0;
target_phys_addr_t cur_addr, cur_len;
void *VAR_2;
dbs->acb = NULL;
dbs->sector_num += dbs->iov.size / 512;
dma_bdrv_unmap(dbs);
qemu_iovec_reset(&dbs->iov);
if (dbs->sg_cur_index == dbs->sg->nsg || VAR_1 < 0) {
dbs->common.cb(dbs->common.VAR_0, VAR_1);
qemu_iovec_destroy(&dbs->iov);
qemu_aio_release(dbs);
return;
}
while (dbs->sg_cur_index < dbs->sg->nsg) {
cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;
cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;
VAR_2 = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);
if (!VAR_2)
break;
qemu_iovec_add(&dbs->iov, VAR_2, cur_len);
dbs->sg_cur_byte += cur_len;
if (dbs->sg_cur_byte == dbs->sg->sg[dbs->sg_cur_index].len) {
dbs->sg_cur_byte = 0;
++dbs->sg_cur_index;
}
}
if (dbs->iov.size == 0) {
cpu_register_map_client(dbs, continue_after_map_failure);
return;
}
dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,
dbs->iov.size / 512, FUNC_0, dbs);
if (!dbs->acb) {
dma_bdrv_unmap(dbs);
qemu_iovec_destroy(&dbs->iov);
return;
}
}
| [
"static void FUNC_0(void *VAR_0, int VAR_1)\n{",
"DMAAIOCB *dbs = (DMAAIOCB *)VAR_0;",
"target_phys_addr_t cur_addr, cur_len;",
"void *VAR_2;",
"dbs->acb = NULL;",
"dbs->sector_num += dbs->iov.size / 512;",
"dma_bdrv_unmap(dbs);",
"qemu_iovec_reset(&dbs->iov);",
"if (dbs->sg_cur_index == dbs->sg->nsg || VAR_1 < 0) {",
"dbs->common.cb(dbs->common.VAR_0, VAR_1);",
"qemu_iovec_destroy(&dbs->iov);",
"qemu_aio_release(dbs);",
"return;",
"}",
"while (dbs->sg_cur_index < dbs->sg->nsg) {",
"cur_addr = dbs->sg->sg[dbs->sg_cur_index].base + dbs->sg_cur_byte;",
"cur_len = dbs->sg->sg[dbs->sg_cur_index].len - dbs->sg_cur_byte;",
"VAR_2 = cpu_physical_memory_map(cur_addr, &cur_len, !dbs->to_dev);",
"if (!VAR_2)\nbreak;",
"qemu_iovec_add(&dbs->iov, VAR_2, cur_len);",
"dbs->sg_cur_byte += cur_len;",
"if (dbs->sg_cur_byte == dbs->sg->sg[dbs->sg_cur_index].len) {",
"dbs->sg_cur_byte = 0;",
"++dbs->sg_cur_index;",
"}",
"}",
"if (dbs->iov.size == 0) {",
"cpu_register_map_client(dbs, continue_after_map_failure);",
"return;",
"}",
"dbs->acb = dbs->io_func(dbs->bs, dbs->sector_num, &dbs->iov,\ndbs->iov.size / 512, FUNC_0, dbs);",
"if (!dbs->acb) {",
"dma_bdrv_unmap(dbs);",
"qemu_iovec_destroy(&dbs->iov);",
"return;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75,
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
]
] |
23,892 | static uint64_t fw_cfg_data_mem_read(void *opaque, hwaddr addr,
unsigned size)
{
FWCfgState *s = opaque;
uint8_t buf[8];
unsigned i;
for (i = 0; i < size; ++i) {
buf[i] = fw_cfg_read(s);
}
switch (size) {
case 1:
return buf[0];
case 2:
return lduw_he_p(buf);
case 4:
return (uint32_t)ldl_he_p(buf);
case 8:
return ldq_he_p(buf);
}
abort();
}
| true | qemu | 36b62ae6a58f9a588fd33be9386e18a2b90103f5 | static uint64_t fw_cfg_data_mem_read(void *opaque, hwaddr addr,
unsigned size)
{
FWCfgState *s = opaque;
uint8_t buf[8];
unsigned i;
for (i = 0; i < size; ++i) {
buf[i] = fw_cfg_read(s);
}
switch (size) {
case 1:
return buf[0];
case 2:
return lduw_he_p(buf);
case 4:
return (uint32_t)ldl_he_p(buf);
case 8:
return ldq_he_p(buf);
}
abort();
}
| {
"code": [
" uint8_t buf[8];",
" buf[i] = fw_cfg_read(s);",
" switch (size) {",
" case 1:",
" return buf[0];",
" case 2:",
" return lduw_he_p(buf);",
" case 4:",
" return (uint32_t)ldl_he_p(buf);",
" case 8:",
" return ldq_he_p(buf);",
" abort();",
" uint8_t buf[8];",
" unsigned i;",
" switch (size) {",
" case 1:",
" case 2:",
" case 4:",
" case 8:",
" for (i = 0; i < size; ++i) {"
],
"line_no": [
9,
17,
21,
23,
25,
27,
29,
31,
33,
35,
37,
41,
9,
11,
21,
23,
27,
31,
35,
15
]
} | static uint64_t FUNC_0(void *opaque, hwaddr addr,
unsigned size)
{
FWCfgState *s = opaque;
uint8_t buf[8];
unsigned VAR_0;
for (VAR_0 = 0; VAR_0 < size; ++VAR_0) {
buf[VAR_0] = fw_cfg_read(s);
}
switch (size) {
case 1:
return buf[0];
case 2:
return lduw_he_p(buf);
case 4:
return (uint32_t)ldl_he_p(buf);
case 8:
return ldq_he_p(buf);
}
abort();
}
| [
"static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{",
"FWCfgState *s = opaque;",
"uint8_t buf[8];",
"unsigned VAR_0;",
"for (VAR_0 = 0; VAR_0 < size; ++VAR_0) {",
"buf[VAR_0] = fw_cfg_read(s);",
"}",
"switch (size) {",
"case 1:\nreturn buf[0];",
"case 2:\nreturn lduw_he_p(buf);",
"case 4:\nreturn (uint32_t)ldl_he_p(buf);",
"case 8:\nreturn ldq_he_p(buf);",
"}",
"abort();",
"}"
] | [
0,
0,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27,
29
],
[
31,
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
]
] |
23,893 | static void test_redirector_rx(void)
{
#ifndef _WIN32
/* socketpair(PF_UNIX) which does not exist on windows */
int backend_sock[2], send_sock;
char *cmdline;
uint32_t ret = 0, len = 0;
char send_buf[] = "Hello!!";
char sock_path0[] = "filter-redirector0.XXXXXX";
char sock_path1[] = "filter-redirector1.XXXXXX";
char *recv_buf;
uint32_t size = sizeof(send_buf);
size = htonl(size);
ret = socketpair(PF_UNIX, SOCK_STREAM, 0, backend_sock);
g_assert_cmpint(ret, !=, -1);
ret = mkstemp(sock_path0);
g_assert_cmpint(ret, !=, -1);
ret = mkstemp(sock_path1);
g_assert_cmpint(ret, !=, -1);
cmdline = g_strdup_printf("-netdev socket,id=qtest-bn0,fd=%d "
"-device rtl8139,netdev=qtest-bn0,id=qtest-e0 "
"-chardev socket,id=redirector0,path=%s,server,nowait "
"-chardev socket,id=redirector1,path=%s,server,nowait "
"-chardev socket,id=redirector2,path=%s,nowait "
"-object filter-redirector,id=qtest-f0,netdev=qtest-bn0,"
"queue=rx,indev=redirector0 "
"-object filter-redirector,id=qtest-f1,netdev=qtest-bn0,"
"queue=rx,outdev=redirector2 "
"-object filter-redirector,id=qtest-f2,netdev=qtest-bn0,"
"queue=rx,indev=redirector1 "
, backend_sock[1], sock_path0, sock_path1, sock_path0);
qtest_start(cmdline);
g_free(cmdline);
struct iovec iov[] = {
{
.iov_base = &size,
.iov_len = sizeof(size),
}, {
.iov_base = send_buf,
.iov_len = sizeof(send_buf),
},
};
send_sock = unix_connect(sock_path1, NULL);
g_assert_cmpint(send_sock, !=, -1);
/* send a qmp command to guarantee that 'connected' is setting to true. */
qmp("{ 'execute' : 'query-status'}");
ret = iov_send(send_sock, iov, 2, 0, sizeof(size) + sizeof(send_buf));
g_assert_cmpint(ret, ==, sizeof(send_buf) + sizeof(size));
close(send_sock);
ret = qemu_recv(backend_sock[0], &len, sizeof(len), 0);
g_assert_cmpint(ret, ==, sizeof(len));
len = ntohl(len);
g_assert_cmpint(len, ==, sizeof(send_buf));
recv_buf = g_malloc(len);
ret = qemu_recv(backend_sock[0], recv_buf, len, 0);
g_assert_cmpstr(recv_buf, ==, send_buf);
g_free(recv_buf);
unlink(sock_path0);
unlink(sock_path1);
qtest_end();
#endif
}
| true | qemu | dc491fead04a92a612df93b85b0ebf9dcc3f6684 | static void test_redirector_rx(void)
{
#ifndef _WIN32
int backend_sock[2], send_sock;
char *cmdline;
uint32_t ret = 0, len = 0;
char send_buf[] = "Hello!!";
char sock_path0[] = "filter-redirector0.XXXXXX";
char sock_path1[] = "filter-redirector1.XXXXXX";
char *recv_buf;
uint32_t size = sizeof(send_buf);
size = htonl(size);
ret = socketpair(PF_UNIX, SOCK_STREAM, 0, backend_sock);
g_assert_cmpint(ret, !=, -1);
ret = mkstemp(sock_path0);
g_assert_cmpint(ret, !=, -1);
ret = mkstemp(sock_path1);
g_assert_cmpint(ret, !=, -1);
cmdline = g_strdup_printf("-netdev socket,id=qtest-bn0,fd=%d "
"-device rtl8139,netdev=qtest-bn0,id=qtest-e0 "
"-chardev socket,id=redirector0,path=%s,server,nowait "
"-chardev socket,id=redirector1,path=%s,server,nowait "
"-chardev socket,id=redirector2,path=%s,nowait "
"-object filter-redirector,id=qtest-f0,netdev=qtest-bn0,"
"queue=rx,indev=redirector0 "
"-object filter-redirector,id=qtest-f1,netdev=qtest-bn0,"
"queue=rx,outdev=redirector2 "
"-object filter-redirector,id=qtest-f2,netdev=qtest-bn0,"
"queue=rx,indev=redirector1 "
, backend_sock[1], sock_path0, sock_path1, sock_path0);
qtest_start(cmdline);
g_free(cmdline);
struct iovec iov[] = {
{
.iov_base = &size,
.iov_len = sizeof(size),
}, {
.iov_base = send_buf,
.iov_len = sizeof(send_buf),
},
};
send_sock = unix_connect(sock_path1, NULL);
g_assert_cmpint(send_sock, !=, -1);
qmp("{ 'execute' : 'query-status'}");
ret = iov_send(send_sock, iov, 2, 0, sizeof(size) + sizeof(send_buf));
g_assert_cmpint(ret, ==, sizeof(send_buf) + sizeof(size));
close(send_sock);
ret = qemu_recv(backend_sock[0], &len, sizeof(len), 0);
g_assert_cmpint(ret, ==, sizeof(len));
len = ntohl(len);
g_assert_cmpint(len, ==, sizeof(send_buf));
recv_buf = g_malloc(len);
ret = qemu_recv(backend_sock[0], recv_buf, len, 0);
g_assert_cmpstr(recv_buf, ==, send_buf);
g_free(recv_buf);
unlink(sock_path0);
unlink(sock_path1);
qtest_end();
#endif
}
| {
"code": [
" qmp(\"{ 'execute' : 'query-status'}\");",
" qmp(\"{ 'execute' : 'query-status'}\");",
" qmp(\"{ 'execute' : 'query-status'}\");"
],
"line_no": [
103,
103,
103
]
} | static void FUNC_0(void)
{
#ifndef _WIN32
int VAR_0[2], VAR_1;
char *VAR_2;
uint32_t ret = 0, len = 0;
char VAR_3[] = "Hello!!";
char VAR_4[] = "filter-redirector0.XXXXXX";
char VAR_5[] = "filter-redirector1.XXXXXX";
char *VAR_6;
uint32_t size = sizeof(VAR_3);
size = htonl(size);
ret = socketpair(PF_UNIX, SOCK_STREAM, 0, VAR_0);
g_assert_cmpint(ret, !=, -1);
ret = mkstemp(VAR_4);
g_assert_cmpint(ret, !=, -1);
ret = mkstemp(VAR_5);
g_assert_cmpint(ret, !=, -1);
VAR_2 = g_strdup_printf("-netdev socket,id=qtest-bn0,fd=%d "
"-device rtl8139,netdev=qtest-bn0,id=qtest-e0 "
"-chardev socket,id=redirector0,path=%s,server,nowait "
"-chardev socket,id=redirector1,path=%s,server,nowait "
"-chardev socket,id=redirector2,path=%s,nowait "
"-object filter-redirector,id=qtest-f0,netdev=qtest-bn0,"
"queue=rx,indev=redirector0 "
"-object filter-redirector,id=qtest-f1,netdev=qtest-bn0,"
"queue=rx,outdev=redirector2 "
"-object filter-redirector,id=qtest-f2,netdev=qtest-bn0,"
"queue=rx,indev=redirector1 "
, VAR_0[1], VAR_4, VAR_5, VAR_4);
qtest_start(VAR_2);
g_free(VAR_2);
struct iovec VAR_7[] = {
{
.iov_base = &size,
.iov_len = sizeof(size),
}, {
.iov_base = VAR_3,
.iov_len = sizeof(VAR_3),
},
};
VAR_1 = unix_connect(VAR_5, NULL);
g_assert_cmpint(VAR_1, !=, -1);
qmp("{ 'execute' : 'query-status'}");
ret = iov_send(VAR_1, VAR_7, 2, 0, sizeof(size) + sizeof(VAR_3));
g_assert_cmpint(ret, ==, sizeof(VAR_3) + sizeof(size));
close(VAR_1);
ret = qemu_recv(VAR_0[0], &len, sizeof(len), 0);
g_assert_cmpint(ret, ==, sizeof(len));
len = ntohl(len);
g_assert_cmpint(len, ==, sizeof(VAR_3));
VAR_6 = g_malloc(len);
ret = qemu_recv(VAR_0[0], VAR_6, len, 0);
g_assert_cmpstr(VAR_6, ==, VAR_3);
g_free(VAR_6);
unlink(VAR_4);
unlink(VAR_5);
qtest_end();
#endif
}
| [
"static void FUNC_0(void)\n{",
"#ifndef _WIN32\nint VAR_0[2], VAR_1;",
"char *VAR_2;",
"uint32_t ret = 0, len = 0;",
"char VAR_3[] = \"Hello!!\";",
"char VAR_4[] = \"filter-redirector0.XXXXXX\";",
"char VAR_5[] = \"filter-redirector1.XXXXXX\";",
"char *VAR_6;",
"uint32_t size = sizeof(VAR_3);",
"size = htonl(size);",
"ret = socketpair(PF_UNIX, SOCK_STREAM, 0, VAR_0);",
"g_assert_cmpint(ret, !=, -1);",
"ret = mkstemp(VAR_4);",
"g_assert_cmpint(ret, !=, -1);",
"ret = mkstemp(VAR_5);",
"g_assert_cmpint(ret, !=, -1);",
"VAR_2 = g_strdup_printf(\"-netdev socket,id=qtest-bn0,fd=%d \"\n\"-device rtl8139,netdev=qtest-bn0,id=qtest-e0 \"\n\"-chardev socket,id=redirector0,path=%s,server,nowait \"\n\"-chardev socket,id=redirector1,path=%s,server,nowait \"\n\"-chardev socket,id=redirector2,path=%s,nowait \"\n\"-object filter-redirector,id=qtest-f0,netdev=qtest-bn0,\"\n\"queue=rx,indev=redirector0 \"\n\"-object filter-redirector,id=qtest-f1,netdev=qtest-bn0,\"\n\"queue=rx,outdev=redirector2 \"\n\"-object filter-redirector,id=qtest-f2,netdev=qtest-bn0,\"\n\"queue=rx,indev=redirector1 \"\n, VAR_0[1], VAR_4, VAR_5, VAR_4);",
"qtest_start(VAR_2);",
"g_free(VAR_2);",
"struct iovec VAR_7[] = {",
"{",
".iov_base = &size,\n.iov_len = sizeof(size),\n}, {",
".iov_base = VAR_3,\n.iov_len = sizeof(VAR_3),\n},",
"};",
"VAR_1 = unix_connect(VAR_5, NULL);",
"g_assert_cmpint(VAR_1, !=, -1);",
"qmp(\"{ 'execute' : 'query-status'}\");",
"ret = iov_send(VAR_1, VAR_7, 2, 0, sizeof(size) + sizeof(VAR_3));",
"g_assert_cmpint(ret, ==, sizeof(VAR_3) + sizeof(size));",
"close(VAR_1);",
"ret = qemu_recv(VAR_0[0], &len, sizeof(len), 0);",
"g_assert_cmpint(ret, ==, sizeof(len));",
"len = ntohl(len);",
"g_assert_cmpint(len, ==, sizeof(VAR_3));",
"VAR_6 = g_malloc(len);",
"ret = qemu_recv(VAR_0[0], VAR_6, len, 0);",
"g_assert_cmpstr(VAR_6, ==, VAR_3);",
"g_free(VAR_6);",
"unlink(VAR_4);",
"unlink(VAR_5);",
"qtest_end();",
"#endif\n}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47,
49,
51,
53,
55,
57,
59,
61,
63,
65,
67,
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81,
83,
85
],
[
87,
89,
91
],
[
93
],
[
97
],
[
99
],
[
103
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
],
[
137
],
[
139
],
[
143,
145
]
] |
23,896 | int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
target_phys_addr_t paddr, int prot,
int is_user, int is_softmmu)
{
PhysPageDesc *p;
unsigned long pd;
unsigned int index;
target_ulong address;
target_phys_addr_t addend;
int ret;
CPUTLBEntry *te;
int i;
p = phys_page_find(paddr >> TARGET_PAGE_BITS);
if (!p) {
pd = IO_MEM_UNASSIGNED;
pd = p->phys_offset;
#if defined(DEBUG_TLB)
printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x%08x prot=%x u=%d smmu=%d pd=0x%08lx\n",
vaddr, (int)paddr, prot, is_user, is_softmmu, pd);
#endif
ret = 0;
#if !defined(CONFIG_SOFTMMU)
if (is_softmmu)
#endif
{
if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
/* IO memory case */
address = vaddr | pd;
addend = paddr;
/* standard memory */
address = vaddr;
addend = (unsigned long)phys_ram_base + (pd & TARGET_PAGE_MASK);
index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
addend -= vaddr;
te = &env->tlb_table[is_user][index];
te->addend = addend;
if (prot & PAGE_READ) {
te->addr_read = address;
te->addr_read = -1;
if (prot & PAGE_EXEC) {
te->addr_code = address;
te->addr_code = -1;
if (prot & PAGE_WRITE) {
if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
(pd & IO_MEM_ROMD)) {
/* write access calls the I/O callback */
te->addr_write = vaddr |
(pd & ~(TARGET_PAGE_MASK | IO_MEM_ROMD));
} else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
!cpu_physical_memory_is_dirty(pd)) {
te->addr_write = vaddr | IO_MEM_NOTDIRTY;
te->addr_write = address;
te->addr_write = -1;
#if !defined(CONFIG_SOFTMMU)
else {
if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
/* IO access: no mapping is done as it will be handled by the
soft MMU */
if (!(env->hflags & HF_SOFTMMU_MASK))
ret = 2;
void *map_addr;
if (vaddr >= MMAP_AREA_END) {
ret = 2;
if (prot & PROT_WRITE) {
if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
#if defined(TARGET_HAS_SMC) || 1
first_tb ||
#endif
((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
!cpu_physical_memory_is_dirty(pd))) {
/* ROM: we do as if code was inside */
/* if code is present, we only map as read only and save the
original mapping */
VirtPageDesc *vp;
vp = virt_page_find_alloc(vaddr >> TARGET_PAGE_BITS, 1);
vp->phys_addr = pd;
vp->prot = prot;
vp->valid_tag = virt_valid_tag;
prot &= ~PAGE_WRITE;
map_addr = mmap((void *)vaddr, TARGET_PAGE_SIZE, prot,
MAP_SHARED | MAP_FIXED, phys_ram_fd, (pd & TARGET_PAGE_MASK));
if (map_addr == MAP_FAILED) {
cpu_abort(env, "mmap failed when mapped physical address 0x%08x to virtual address 0x%08x\n",
paddr, vaddr);
#endif
return ret; | true | qemu | 6658ffb81ee56a510d7d77025872a508a9adce3a | int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
target_phys_addr_t paddr, int prot,
int is_user, int is_softmmu)
{
PhysPageDesc *p;
unsigned long pd;
unsigned int index;
target_ulong address;
target_phys_addr_t addend;
int ret;
CPUTLBEntry *te;
int i;
p = phys_page_find(paddr >> TARGET_PAGE_BITS);
if (!p) {
pd = IO_MEM_UNASSIGNED;
pd = p->phys_offset;
#if defined(DEBUG_TLB)
printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x%08x prot=%x u=%d smmu=%d pd=0x%08lx\n",
vaddr, (int)paddr, prot, is_user, is_softmmu, pd);
#endif
ret = 0;
#if !defined(CONFIG_SOFTMMU)
if (is_softmmu)
#endif
{
if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
address = vaddr | pd;
addend = paddr;
address = vaddr;
addend = (unsigned long)phys_ram_base + (pd & TARGET_PAGE_MASK);
index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
addend -= vaddr;
te = &env->tlb_table[is_user][index];
te->addend = addend;
if (prot & PAGE_READ) {
te->addr_read = address;
te->addr_read = -1;
if (prot & PAGE_EXEC) {
te->addr_code = address;
te->addr_code = -1;
if (prot & PAGE_WRITE) {
if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
(pd & IO_MEM_ROMD)) {
te->addr_write = vaddr |
(pd & ~(TARGET_PAGE_MASK | IO_MEM_ROMD));
} else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
!cpu_physical_memory_is_dirty(pd)) {
te->addr_write = vaddr | IO_MEM_NOTDIRTY;
te->addr_write = address;
te->addr_write = -1;
#if !defined(CONFIG_SOFTMMU)
else {
if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
if (!(env->hflags & HF_SOFTMMU_MASK))
ret = 2;
void *map_addr;
if (vaddr >= MMAP_AREA_END) {
ret = 2;
if (prot & PROT_WRITE) {
if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
#if defined(TARGET_HAS_SMC) || 1
first_tb ||
#endif
((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
!cpu_physical_memory_is_dirty(pd))) {
VirtPageDesc *vp;
vp = virt_page_find_alloc(vaddr >> TARGET_PAGE_BITS, 1);
vp->phys_addr = pd;
vp->prot = prot;
vp->valid_tag = virt_valid_tag;
prot &= ~PAGE_WRITE;
map_addr = mmap((void *)vaddr, TARGET_PAGE_SIZE, prot,
MAP_SHARED | MAP_FIXED, phys_ram_fd, (pd & TARGET_PAGE_MASK));
if (map_addr == MAP_FAILED) {
cpu_abort(env, "mmap failed when mapped physical address 0x%08x to virtual address 0x%08x\n",
paddr, vaddr);
#endif
return ret; | {
"code": [],
"line_no": []
} | int FUNC_0(CPUState *VAR_0, target_ulong VAR_1,
target_phys_addr_t VAR_2, int VAR_3,
int VAR_4, int VAR_5)
{
PhysPageDesc *p;
unsigned long VAR_6;
unsigned int VAR_7;
target_ulong address;
target_phys_addr_t addend;
int VAR_8;
CPUTLBEntry *te;
int VAR_9;
p = phys_page_find(VAR_2 >> TARGET_PAGE_BITS);
if (!p) {
VAR_6 = IO_MEM_UNASSIGNED;
VAR_6 = p->phys_offset;
#if defined(DEBUG_TLB)
printf("tlb_set_page: VAR_1=" TARGET_FMT_lx " VAR_2=0x%08x VAR_3=%x u=%d smmu=%d VAR_6=0x%08lx\n",
VAR_1, (int)VAR_2, VAR_3, VAR_4, VAR_5, VAR_6);
#endif
VAR_8 = 0;
#if !defined(CONFIG_SOFTMMU)
if (VAR_5)
#endif
{
if ((VAR_6 & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(VAR_6 & IO_MEM_ROMD)) {
address = VAR_1 | VAR_6;
addend = VAR_2;
address = VAR_1;
addend = (unsigned long)phys_ram_base + (VAR_6 & TARGET_PAGE_MASK);
VAR_7 = (VAR_1 >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
addend -= VAR_1;
te = &VAR_0->tlb_table[VAR_4][VAR_7];
te->addend = addend;
if (VAR_3 & PAGE_READ) {
te->addr_read = address;
te->addr_read = -1;
if (VAR_3 & PAGE_EXEC) {
te->addr_code = address;
te->addr_code = -1;
if (VAR_3 & PAGE_WRITE) {
if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
(VAR_6 & IO_MEM_ROMD)) {
te->addr_write = VAR_1 |
(VAR_6 & ~(TARGET_PAGE_MASK | IO_MEM_ROMD));
} else if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
!cpu_physical_memory_is_dirty(VAR_6)) {
te->addr_write = VAR_1 | IO_MEM_NOTDIRTY;
te->addr_write = address;
te->addr_write = -1;
#if !defined(CONFIG_SOFTMMU)
else {
if ((VAR_6 & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
if (!(VAR_0->hflags & HF_SOFTMMU_MASK))
VAR_8 = 2;
void *map_addr;
if (VAR_1 >= MMAP_AREA_END) {
VAR_8 = 2;
if (VAR_3 & PROT_WRITE) {
if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
#if defined(TARGET_HAS_SMC) || 1
first_tb ||
#endif
((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
!cpu_physical_memory_is_dirty(VAR_6))) {
VirtPageDesc *vp;
vp = virt_page_find_alloc(VAR_1 >> TARGET_PAGE_BITS, 1);
vp->phys_addr = VAR_6;
vp->VAR_3 = VAR_3;
vp->valid_tag = virt_valid_tag;
VAR_3 &= ~PAGE_WRITE;
map_addr = mmap((void *)VAR_1, TARGET_PAGE_SIZE, VAR_3,
MAP_SHARED | MAP_FIXED, phys_ram_fd, (VAR_6 & TARGET_PAGE_MASK));
if (map_addr == MAP_FAILED) {
cpu_abort(VAR_0, "mmap failed when mapped physical address 0x%08x to virtual address 0x%08x\n",
VAR_2, VAR_1);
#endif
return VAR_8; | [
"int FUNC_0(CPUState *VAR_0, target_ulong VAR_1,\ntarget_phys_addr_t VAR_2, int VAR_3,\nint VAR_4, int VAR_5)\n{",
"PhysPageDesc *p;",
"unsigned long VAR_6;",
"unsigned int VAR_7;",
"target_ulong address;",
"target_phys_addr_t addend;",
"int VAR_8;",
"CPUTLBEntry *te;",
"int VAR_9;",
"p = phys_page_find(VAR_2 >> TARGET_PAGE_BITS);",
"if (!p) {",
"VAR_6 = IO_MEM_UNASSIGNED;",
"VAR_6 = p->phys_offset;",
"#if defined(DEBUG_TLB)\nprintf(\"tlb_set_page: VAR_1=\" TARGET_FMT_lx \" VAR_2=0x%08x VAR_3=%x u=%d smmu=%d VAR_6=0x%08lx\\n\",\nVAR_1, (int)VAR_2, VAR_3, VAR_4, VAR_5, VAR_6);",
"#endif\nVAR_8 = 0;",
"#if !defined(CONFIG_SOFTMMU)\nif (VAR_5)\n#endif\n{",
"if ((VAR_6 & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(VAR_6 & IO_MEM_ROMD)) {",
"address = VAR_1 | VAR_6;",
"addend = VAR_2;",
"address = VAR_1;",
"addend = (unsigned long)phys_ram_base + (VAR_6 & TARGET_PAGE_MASK);",
"VAR_7 = (VAR_1 >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);",
"addend -= VAR_1;",
"te = &VAR_0->tlb_table[VAR_4][VAR_7];",
"te->addend = addend;",
"if (VAR_3 & PAGE_READ) {",
"te->addr_read = address;",
"te->addr_read = -1;",
"if (VAR_3 & PAGE_EXEC) {",
"te->addr_code = address;",
"te->addr_code = -1;",
"if (VAR_3 & PAGE_WRITE) {",
"if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||\n(VAR_6 & IO_MEM_ROMD)) {",
"te->addr_write = VAR_1 |\n(VAR_6 & ~(TARGET_PAGE_MASK | IO_MEM_ROMD));",
"} else if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&",
"!cpu_physical_memory_is_dirty(VAR_6)) {",
"te->addr_write = VAR_1 | IO_MEM_NOTDIRTY;",
"te->addr_write = address;",
"te->addr_write = -1;",
"#if !defined(CONFIG_SOFTMMU)\nelse {",
"if ((VAR_6 & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {",
"if (!(VAR_0->hflags & HF_SOFTMMU_MASK))\nVAR_8 = 2;",
"void *map_addr;",
"if (VAR_1 >= MMAP_AREA_END) {",
"VAR_8 = 2;",
"if (VAR_3 & PROT_WRITE) {",
"if ((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||\n#if defined(TARGET_HAS_SMC) || 1\nfirst_tb ||\n#endif\n((VAR_6 & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&\n!cpu_physical_memory_is_dirty(VAR_6))) {",
"VirtPageDesc *vp;",
"vp = virt_page_find_alloc(VAR_1 >> TARGET_PAGE_BITS, 1);",
"vp->phys_addr = VAR_6;",
"vp->VAR_3 = VAR_3;",
"vp->valid_tag = virt_valid_tag;",
"VAR_3 &= ~PAGE_WRITE;",
"map_addr = mmap((void *)VAR_1, TARGET_PAGE_SIZE, VAR_3,\nMAP_SHARED | MAP_FIXED, phys_ram_fd, (VAR_6 & TARGET_PAGE_MASK));",
"if (map_addr == MAP_FAILED) {",
"cpu_abort(VAR_0, \"mmap failed when mapped physical address 0x%08x to virtual address 0x%08x\\n\",\nVAR_2, VAR_1);",
"#endif\nreturn VAR_8;"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2,
3,
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17,
18,
19
],
[
20,
21
],
[
22,
23,
24,
25
],
[
26
],
[
28
],
[
29
],
[
31
],
[
32
],
[
33
],
[
34
],
[
35
],
[
36
],
[
37
],
[
38
],
[
39
],
[
40
],
[
41
],
[
42
],
[
43
],
[
44,
45
],
[
47,
48
],
[
49
],
[
50
],
[
51
],
[
52
],
[
53
],
[
54,
55
],
[
56
],
[
59,
60
],
[
61
],
[
62
],
[
63
],
[
64
],
[
65,
66,
67,
68,
69,
70
],
[
74
],
[
75
],
[
76
],
[
77
],
[
78
],
[
79
],
[
80,
81
],
[
82
],
[
83,
84
],
[
85,
86
]
] |
23,897 | static void qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len)
{
/* Allocate buffer for zero writes */
if (acb->flags & QED_AIOCB_ZERO) {
struct iovec *iov = acb->qiov->iov;
if (!iov->iov_base) {
iov->iov_base = qemu_blockalign(acb->common.bs, iov->iov_len);
memset(iov->iov_base, 0, iov->iov_len);
}
}
/* Calculate the I/O vector */
acb->cur_cluster = offset;
qemu_iovec_concat(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);
/* Do the actual write */
qed_aio_write_main(acb, 0);
}
| true | qemu | 4f4896db5fb2285df016ff927508560c89b845a4 | static void qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len)
{
if (acb->flags & QED_AIOCB_ZERO) {
struct iovec *iov = acb->qiov->iov;
if (!iov->iov_base) {
iov->iov_base = qemu_blockalign(acb->common.bs, iov->iov_len);
memset(iov->iov_base, 0, iov->iov_len);
}
}
acb->cur_cluster = offset;
qemu_iovec_concat(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);
qed_aio_write_main(acb, 0);
}
| {
"code": [
" iov->iov_base = qemu_blockalign(acb->common.bs, iov->iov_len);"
],
"line_no": [
15
]
} | static void FUNC_0(QEDAIOCB *VAR_0, uint64_t VAR_1, size_t VAR_2)
{
if (VAR_0->flags & QED_AIOCB_ZERO) {
struct iovec *VAR_3 = VAR_0->qiov->VAR_3;
if (!VAR_3->iov_base) {
VAR_3->iov_base = qemu_blockalign(VAR_0->common.bs, VAR_3->iov_len);
memset(VAR_3->iov_base, 0, VAR_3->iov_len);
}
}
VAR_0->cur_cluster = VAR_1;
qemu_iovec_concat(&VAR_0->cur_qiov, VAR_0->qiov, VAR_0->qiov_offset, VAR_2);
qed_aio_write_main(VAR_0, 0);
}
| [
"static void FUNC_0(QEDAIOCB *VAR_0, uint64_t VAR_1, size_t VAR_2)\n{",
"if (VAR_0->flags & QED_AIOCB_ZERO) {",
"struct iovec *VAR_3 = VAR_0->qiov->VAR_3;",
"if (!VAR_3->iov_base) {",
"VAR_3->iov_base = qemu_blockalign(VAR_0->common.bs, VAR_3->iov_len);",
"memset(VAR_3->iov_base, 0, VAR_3->iov_len);",
"}",
"}",
"VAR_0->cur_cluster = VAR_1;",
"qemu_iovec_concat(&VAR_0->cur_qiov, VAR_0->qiov, VAR_0->qiov_offset, VAR_2);",
"qed_aio_write_main(VAR_0, 0);",
"}"
] | [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
27
],
[
29
],
[
35
],
[
37
]
] |
23,898 | static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame,
int line, int left, uint8_t lru[3][8])
{
int x, y;
int width = frame->width;
int stride = frame->linesize[0];
uint8_t *dst = frame->data[0] + stride * line;
for (y = 0; y < left && get_bits_left(gb) > 16; y++) {
for (x = 0; x < width; x++) {
dst[x * 3 + 0] = decode_sym(gb, lru[0]);
dst[x * 3 + 1] = decode_sym(gb, lru[1]);
dst[x * 3 + 2] = decode_sym(gb, lru[2]);
}
dst += stride;
}
return y;
}
| true | FFmpeg | 6e1a167c5564085385488b4f579e9efb987d4bfa | static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame,
int line, int left, uint8_t lru[3][8])
{
int x, y;
int width = frame->width;
int stride = frame->linesize[0];
uint8_t *dst = frame->data[0] + stride * line;
for (y = 0; y < left && get_bits_left(gb) > 16; y++) {
for (x = 0; x < width; x++) {
dst[x * 3 + 0] = decode_sym(gb, lru[0]);
dst[x * 3 + 1] = decode_sym(gb, lru[1]);
dst[x * 3 + 2] = decode_sym(gb, lru[2]);
}
dst += stride;
}
return y;
}
| {
"code": [
" for (y = 0; y < left && get_bits_left(gb) > 16; y++) {",
" for (y = 0; y < left && get_bits_left(gb) > 16; y++) {",
" for (y = 0; y < left && get_bits_left(gb) > 16; y++) {"
],
"line_no": [
17,
17,
17
]
} | static int FUNC_0(GetBitContext *VAR_0, AVFrame *VAR_1,
int VAR_2, int VAR_3, uint8_t VAR_4[3][8])
{
int VAR_5, VAR_6;
int VAR_7 = VAR_1->VAR_7;
int VAR_8 = VAR_1->linesize[0];
uint8_t *dst = VAR_1->data[0] + VAR_8 * VAR_2;
for (VAR_6 = 0; VAR_6 < VAR_3 && get_bits_left(VAR_0) > 16; VAR_6++) {
for (VAR_5 = 0; VAR_5 < VAR_7; VAR_5++) {
dst[VAR_5 * 3 + 0] = decode_sym(VAR_0, VAR_4[0]);
dst[VAR_5 * 3 + 1] = decode_sym(VAR_0, VAR_4[1]);
dst[VAR_5 * 3 + 2] = decode_sym(VAR_0, VAR_4[2]);
}
dst += VAR_8;
}
return VAR_6;
}
| [
"static int FUNC_0(GetBitContext *VAR_0, AVFrame *VAR_1,\nint VAR_2, int VAR_3, uint8_t VAR_4[3][8])\n{",
"int VAR_5, VAR_6;",
"int VAR_7 = VAR_1->VAR_7;",
"int VAR_8 = VAR_1->linesize[0];",
"uint8_t *dst = VAR_1->data[0] + VAR_8 * VAR_2;",
"for (VAR_6 = 0; VAR_6 < VAR_3 && get_bits_left(VAR_0) > 16; VAR_6++) {",
"for (VAR_5 = 0; VAR_5 < VAR_7; VAR_5++) {",
"dst[VAR_5 * 3 + 0] = decode_sym(VAR_0, VAR_4[0]);",
"dst[VAR_5 * 3 + 1] = decode_sym(VAR_0, VAR_4[1]);",
"dst[VAR_5 * 3 + 2] = decode_sym(VAR_0, VAR_4[2]);",
"}",
"dst += VAR_8;",
"}",
"return VAR_6;",
"}"
] | [
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
]
] |
23,900 | static int mjpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
MJpegDecodeContext *s = avctx->priv_data;
uint8_t *buf_end, *buf_ptr;
int i, start_code;
AVPicture *picture = data;
*data_size = 0;
/* no supplementary picture */
if (buf_size == 0)
return 0;
buf_ptr = buf;
buf_end = buf + buf_size;
while (buf_ptr < buf_end) {
/* find start next marker */
start_code = find_marker(&buf_ptr, buf_end);
{
/* EOF */
if (start_code < 0) {
goto the_end;
} else {
dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
if ((buf_end - buf_ptr) > s->buffer_size)
{
av_free(s->buffer);
s->buffer_size = buf_end-buf_ptr;
s->buffer = av_malloc(s->buffer_size);
dprintf("buffer too small, expanding to %d bytes\n",
s->buffer_size);
}
/* unescape buffer of SOS */
if (start_code == SOS)
{
uint8_t *src = buf_ptr;
uint8_t *dst = s->buffer;
while (src<buf_end)
{
uint8_t x = *(src++);
*(dst++) = x;
if (x == 0xff)
{
while(*src == 0xff) src++;
x = *(src++);
if (x >= 0xd0 && x <= 0xd7)
*(dst++) = x;
else if (x)
break;
}
}
init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
dprintf("escaping removed %d bytes\n",
(buf_end - buf_ptr) - (dst - s->buffer));
}
else
init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
s->start_code = start_code;
if(s->avctx->debug & FF_DEBUG_STARTCODE){
printf("startcode: %X\n", start_code);
}
/* process markers */
if (start_code >= 0xd0 && start_code <= 0xd7) {
dprintf("restart marker: %d\n", start_code&0x0f);
} else if (s->first_picture) {
/* APP fields */
if (start_code >= 0xe0 && start_code <= 0xef)
mjpeg_decode_app(s);
/* Comment */
else if (start_code == COM)
mjpeg_decode_com(s);
}
switch(start_code) {
case SOI:
s->restart_interval = 0;
/* nothing to do on SOI */
break;
case DQT:
mjpeg_decode_dqt(s);
break;
case DHT:
mjpeg_decode_dht(s);
break;
case SOF0:
s->lossless=0;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case SOF3:
s->lossless=1;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case EOI:
eoi_parser:
{
if (s->interlaced) {
s->bottom_field ^= 1;
/* if not bottom field, do not output image yet */
if (s->bottom_field)
goto not_the_end;
}
for(i=0;i<3;i++) {
picture->data[i] = s->current_picture[i];
picture->linesize[i] = (s->interlaced) ?
s->linesize[i] >> 1 : s->linesize[i];
}
*data_size = sizeof(AVPicture);
avctx->height = s->height;
if (s->interlaced)
avctx->height *= 2;
avctx->width = s->width;
/* XXX: not complete test ! */
switch((s->h_count[0] << 4) | s->v_count[0]) {
case 0x11:
if(s->rgb){
avctx->pix_fmt = PIX_FMT_RGBA32;
}else
avctx->pix_fmt = PIX_FMT_YUV444P;
break;
case 0x21:
avctx->pix_fmt = PIX_FMT_YUV422P;
break;
default:
case 0x22:
avctx->pix_fmt = PIX_FMT_YUV420P;
break;
}
/* dummy quality */
/* XXX: infer it with matrix */
// avctx->quality = 3;
goto the_end;
}
break;
case SOS:
mjpeg_decode_sos(s);
/* buggy avid puts EOI every 10-20th frame */
/* if restart period is over process EOI */
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
goto eoi_parser;
break;
case DRI:
mjpeg_decode_dri(s);
break;
case SOF1:
case SOF2:
case SOF5:
case SOF6:
case SOF7:
case SOF9:
case SOF10:
case SOF11:
case SOF13:
case SOF14:
case SOF15:
case JPG:
printf("mjpeg: unsupported coding type (%x)\n", start_code);
break;
// default:
// printf("mjpeg: unsupported marker (%x)\n", start_code);
// break;
}
not_the_end:
/* eof process start code */
buf_ptr += (get_bits_count(&s->gb)+7)/8;
dprintf("marker parser used %d bytes (%d bits)\n",
(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
}
}
}
the_end:
dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
// return buf_end - buf_ptr;
return buf_ptr - buf;
}
| false | FFmpeg | 0273ceebbd01f9fd5238558e6151e0b9aa3305ab | static int mjpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
MJpegDecodeContext *s = avctx->priv_data;
uint8_t *buf_end, *buf_ptr;
int i, start_code;
AVPicture *picture = data;
*data_size = 0;
if (buf_size == 0)
return 0;
buf_ptr = buf;
buf_end = buf + buf_size;
while (buf_ptr < buf_end) {
start_code = find_marker(&buf_ptr, buf_end);
{
if (start_code < 0) {
goto the_end;
} else {
dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
if ((buf_end - buf_ptr) > s->buffer_size)
{
av_free(s->buffer);
s->buffer_size = buf_end-buf_ptr;
s->buffer = av_malloc(s->buffer_size);
dprintf("buffer too small, expanding to %d bytes\n",
s->buffer_size);
}
if (start_code == SOS)
{
uint8_t *src = buf_ptr;
uint8_t *dst = s->buffer;
while (src<buf_end)
{
uint8_t x = *(src++);
*(dst++) = x;
if (x == 0xff)
{
while(*src == 0xff) src++;
x = *(src++);
if (x >= 0xd0 && x <= 0xd7)
*(dst++) = x;
else if (x)
break;
}
}
init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
dprintf("escaping removed %d bytes\n",
(buf_end - buf_ptr) - (dst - s->buffer));
}
else
init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
s->start_code = start_code;
if(s->avctx->debug & FF_DEBUG_STARTCODE){
printf("startcode: %X\n", start_code);
}
if (start_code >= 0xd0 && start_code <= 0xd7) {
dprintf("restart marker: %d\n", start_code&0x0f);
} else if (s->first_picture) {
if (start_code >= 0xe0 && start_code <= 0xef)
mjpeg_decode_app(s);
else if (start_code == COM)
mjpeg_decode_com(s);
}
switch(start_code) {
case SOI:
s->restart_interval = 0;
break;
case DQT:
mjpeg_decode_dqt(s);
break;
case DHT:
mjpeg_decode_dht(s);
break;
case SOF0:
s->lossless=0;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case SOF3:
s->lossless=1;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case EOI:
eoi_parser:
{
if (s->interlaced) {
s->bottom_field ^= 1;
if (s->bottom_field)
goto not_the_end;
}
for(i=0;i<3;i++) {
picture->data[i] = s->current_picture[i];
picture->linesize[i] = (s->interlaced) ?
s->linesize[i] >> 1 : s->linesize[i];
}
*data_size = sizeof(AVPicture);
avctx->height = s->height;
if (s->interlaced)
avctx->height *= 2;
avctx->width = s->width;
switch((s->h_count[0] << 4) | s->v_count[0]) {
case 0x11:
if(s->rgb){
avctx->pix_fmt = PIX_FMT_RGBA32;
}else
avctx->pix_fmt = PIX_FMT_YUV444P;
break;
case 0x21:
avctx->pix_fmt = PIX_FMT_YUV422P;
break;
default:
case 0x22:
avctx->pix_fmt = PIX_FMT_YUV420P;
break;
}
goto the_end;
}
break;
case SOS:
mjpeg_decode_sos(s);
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
goto eoi_parser;
break;
case DRI:
mjpeg_decode_dri(s);
break;
case SOF1:
case SOF2:
case SOF5:
case SOF6:
case SOF7:
case SOF9:
case SOF10:
case SOF11:
case SOF13:
case SOF14:
case SOF15:
case JPG:
printf("mjpeg: unsupported coding type (%x)\n", start_code);
break;
}
not_the_end:
buf_ptr += (get_bits_count(&s->gb)+7)/8;
dprintf("marker parser used %d bytes (%d bits)\n",
(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
}
}
}
the_end:
dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
return buf_ptr - buf;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
uint8_t *VAR_3, int VAR_4)
{
MJpegDecodeContext *s = VAR_0->priv_data;
uint8_t *buf_end, *buf_ptr;
int VAR_5, VAR_6;
AVPicture *picture = VAR_1;
*VAR_2 = 0;
if (VAR_4 == 0)
return 0;
buf_ptr = VAR_3;
buf_end = VAR_3 + VAR_4;
while (buf_ptr < buf_end) {
VAR_6 = find_marker(&buf_ptr, buf_end);
{
if (VAR_6 < 0) {
goto the_end;
} else {
dprintf("marker=%x avail_size_in_buf=%d\n", VAR_6, buf_end - buf_ptr);
if ((buf_end - buf_ptr) > s->buffer_size)
{
av_free(s->buffer);
s->buffer_size = buf_end-buf_ptr;
s->buffer = av_malloc(s->buffer_size);
dprintf("buffer too small, expanding to %d bytes\n",
s->buffer_size);
}
if (VAR_6 == SOS)
{
uint8_t *src = buf_ptr;
uint8_t *dst = s->buffer;
while (src<buf_end)
{
uint8_t x = *(src++);
*(dst++) = x;
if (x == 0xff)
{
while(*src == 0xff) src++;
x = *(src++);
if (x >= 0xd0 && x <= 0xd7)
*(dst++) = x;
else if (x)
break;
}
}
init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
dprintf("escaping removed %d bytes\n",
(buf_end - buf_ptr) - (dst - s->buffer));
}
else
init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
s->VAR_6 = VAR_6;
if(s->VAR_0->debug & FF_DEBUG_STARTCODE){
printf("startcode: %X\n", VAR_6);
}
if (VAR_6 >= 0xd0 && VAR_6 <= 0xd7) {
dprintf("restart marker: %d\n", VAR_6&0x0f);
} else if (s->first_picture) {
if (VAR_6 >= 0xe0 && VAR_6 <= 0xef)
mjpeg_decode_app(s);
else if (VAR_6 == COM)
mjpeg_decode_com(s);
}
switch(VAR_6) {
case SOI:
s->restart_interval = 0;
break;
case DQT:
mjpeg_decode_dqt(s);
break;
case DHT:
mjpeg_decode_dht(s);
break;
case SOF0:
s->lossless=0;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case SOF3:
s->lossless=1;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case EOI:
eoi_parser:
{
if (s->interlaced) {
s->bottom_field ^= 1;
if (s->bottom_field)
goto not_the_end;
}
for(VAR_5=0;VAR_5<3;VAR_5++) {
picture->VAR_1[VAR_5] = s->current_picture[VAR_5];
picture->linesize[VAR_5] = (s->interlaced) ?
s->linesize[VAR_5] >> 1 : s->linesize[VAR_5];
}
*VAR_2 = sizeof(AVPicture);
VAR_0->height = s->height;
if (s->interlaced)
VAR_0->height *= 2;
VAR_0->width = s->width;
switch((s->h_count[0] << 4) | s->v_count[0]) {
case 0x11:
if(s->rgb){
VAR_0->pix_fmt = PIX_FMT_RGBA32;
}else
VAR_0->pix_fmt = PIX_FMT_YUV444P;
break;
case 0x21:
VAR_0->pix_fmt = PIX_FMT_YUV422P;
break;
default:
case 0x22:
VAR_0->pix_fmt = PIX_FMT_YUV420P;
break;
}
goto the_end;
}
break;
case SOS:
mjpeg_decode_sos(s);
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
goto eoi_parser;
break;
case DRI:
mjpeg_decode_dri(s);
break;
case SOF1:
case SOF2:
case SOF5:
case SOF6:
case SOF7:
case SOF9:
case SOF10:
case SOF11:
case SOF13:
case SOF14:
case SOF15:
case JPG:
printf("mjpeg: unsupported coding type (%x)\n", VAR_6);
break;
}
not_the_end:
buf_ptr += (get_bits_count(&s->gb)+7)/8;
dprintf("marker parser used %d bytes (%d bits)\n",
(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
}
}
}
the_end:
dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
return buf_ptr - VAR_3;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{",
"MJpegDecodeContext *s = VAR_0->priv_data;",
"uint8_t *buf_end, *buf_ptr;",
"int VAR_5, VAR_6;",
"AVPicture *picture = VAR_1;",
"*VAR_2 = 0;",
"if (VAR_4 == 0)\nreturn 0;",
"buf_ptr = VAR_3;",
"buf_end = VAR_3 + VAR_4;",
"while (buf_ptr < buf_end) {",
"VAR_6 = find_marker(&buf_ptr, buf_end);",
"{",
"if (VAR_6 < 0) {",
"goto the_end;",
"} else {",
"dprintf(\"marker=%x avail_size_in_buf=%d\\n\", VAR_6, buf_end - buf_ptr);",
"if ((buf_end - buf_ptr) > s->buffer_size)\n{",
"av_free(s->buffer);",
"s->buffer_size = buf_end-buf_ptr;",
"s->buffer = av_malloc(s->buffer_size);",
"dprintf(\"buffer too small, expanding to %d bytes\\n\",\ns->buffer_size);",
"}",
"if (VAR_6 == SOS)\n{",
"uint8_t *src = buf_ptr;",
"uint8_t *dst = s->buffer;",
"while (src<buf_end)\n{",
"uint8_t x = *(src++);",
"*(dst++) = x;",
"if (x == 0xff)\n{",
"while(*src == 0xff) src++;",
"x = *(src++);",
"if (x >= 0xd0 && x <= 0xd7)\n*(dst++) = x;",
"else if (x)\nbreak;",
"}",
"}",
"init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);",
"dprintf(\"escaping removed %d bytes\\n\",\n(buf_end - buf_ptr) - (dst - s->buffer));",
"}",
"else\ninit_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);",
"s->VAR_6 = VAR_6;",
"if(s->VAR_0->debug & FF_DEBUG_STARTCODE){",
"printf(\"startcode: %X\\n\", VAR_6);",
"}",
"if (VAR_6 >= 0xd0 && VAR_6 <= 0xd7) {",
"dprintf(\"restart marker: %d\\n\", VAR_6&0x0f);",
"} else if (s->first_picture) {",
"if (VAR_6 >= 0xe0 && VAR_6 <= 0xef)\nmjpeg_decode_app(s);",
"else if (VAR_6 == COM)\nmjpeg_decode_com(s);",
"}",
"switch(VAR_6) {",
"case SOI:\ns->restart_interval = 0;",
"break;",
"case DQT:\nmjpeg_decode_dqt(s);",
"break;",
"case DHT:\nmjpeg_decode_dht(s);",
"break;",
"case SOF0:\ns->lossless=0;",
"if (mjpeg_decode_sof(s) < 0)\nreturn -1;",
"break;",
"case SOF3:\ns->lossless=1;",
"if (mjpeg_decode_sof(s) < 0)\nreturn -1;",
"break;",
"case EOI:\neoi_parser:\n{",
"if (s->interlaced) {",
"s->bottom_field ^= 1;",
"if (s->bottom_field)\ngoto not_the_end;",
"}",
"for(VAR_5=0;VAR_5<3;VAR_5++) {",
"picture->VAR_1[VAR_5] = s->current_picture[VAR_5];",
"picture->linesize[VAR_5] = (s->interlaced) ?\ns->linesize[VAR_5] >> 1 : s->linesize[VAR_5];",
"}",
"*VAR_2 = sizeof(AVPicture);",
"VAR_0->height = s->height;",
"if (s->interlaced)\nVAR_0->height *= 2;",
"VAR_0->width = s->width;",
"switch((s->h_count[0] << 4) | s->v_count[0]) {",
"case 0x11:\nif(s->rgb){",
"VAR_0->pix_fmt = PIX_FMT_RGBA32;",
"}else",
"VAR_0->pix_fmt = PIX_FMT_YUV444P;",
"break;",
"case 0x21:\nVAR_0->pix_fmt = PIX_FMT_YUV422P;",
"break;",
"default:\ncase 0x22:\nVAR_0->pix_fmt = PIX_FMT_YUV420P;",
"break;",
"}",
"goto the_end;",
"}",
"break;",
"case SOS:\nmjpeg_decode_sos(s);",
"if ((s->buggy_avid && !s->interlaced) || s->restart_interval)\ngoto eoi_parser;",
"break;",
"case DRI:\nmjpeg_decode_dri(s);",
"break;",
"case SOF1:\ncase SOF2:\ncase SOF5:\ncase SOF6:\ncase SOF7:\ncase SOF9:\ncase SOF10:\ncase SOF11:\ncase SOF13:\ncase SOF14:\ncase SOF15:\ncase JPG:\nprintf(\"mjpeg: unsupported coding type (%x)\\n\", VAR_6);",
"break;",
"}",
"not_the_end:\nbuf_ptr += (get_bits_count(&s->gb)+7)/8;",
"dprintf(\"marker parser used %d bytes (%d bits)\\n\",\n(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));",
"}",
"}",
"}",
"the_end:\ndprintf(\"mjpeg decode frame unused %d bytes\\n\", buf_end - buf_ptr);",
"return buf_ptr - VAR_3;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
25,
27
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65,
67
],
[
69
],
[
75,
77
],
[
79
],
[
81
],
[
85,
87
],
[
89
],
[
93
],
[
95,
97
],
[
99
],
[
103
],
[
105,
107
],
[
109,
111
],
[
113
],
[
115
],
[
117
],
[
121,
123
],
[
125
],
[
127,
129
],
[
133
],
[
135
],
[
137
],
[
139
],
[
145
],
[
147
],
[
149
],
[
153,
155
],
[
159,
161
],
[
163
],
[
167
],
[
169,
171
],
[
175
],
[
177,
179
],
[
181
],
[
183,
185
],
[
187
],
[
189,
191
],
[
193,
195
],
[
197
],
[
199,
201
],
[
203,
205
],
[
207
],
[
209,
211,
213
],
[
215
],
[
217
],
[
221,
223
],
[
225
],
[
227
],
[
229
],
[
231,
233
],
[
235
],
[
237
],
[
239
],
[
241,
243
],
[
245
],
[
249
],
[
251,
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263,
265
],
[
267
],
[
269,
271,
273
],
[
275
],
[
277
],
[
285
],
[
287
],
[
289
],
[
291,
293
],
[
299,
301
],
[
303
],
[
305,
307
],
[
309
],
[
311,
313,
315,
317,
319,
321,
323,
325,
327,
329,
331,
333,
335
],
[
337
],
[
345
],
[
349,
353
],
[
355,
357
],
[
359
],
[
361
],
[
363
],
[
365,
367
],
[
371
],
[
373
]
] |
23,901 | static void do_ext_interrupt(CPUS390XState *env)
{
S390CPU *cpu = s390_env_get_cpu(env);
uint64_t mask, addr;
LowCore *lowcore;
ExtQueue *q;
if (!(env->psw.mask & PSW_MASK_EXT)) {
cpu_abort(CPU(cpu), "Ext int w/o ext mask\n");
}
if (env->ext_index < 0 || env->ext_index > MAX_EXT_QUEUE) {
cpu_abort(CPU(cpu), "Ext queue overrun: %d\n", env->ext_index);
}
q = &env->ext_queue[env->ext_index];
lowcore = cpu_map_lowcore(env);
lowcore->ext_int_code = cpu_to_be16(q->code);
lowcore->ext_params = cpu_to_be32(q->param);
lowcore->ext_params2 = cpu_to_be64(q->param64);
lowcore->external_old_psw.mask = cpu_to_be64(get_psw_mask(env));
lowcore->external_old_psw.addr = cpu_to_be64(env->psw.addr);
lowcore->cpu_addr = cpu_to_be16(env->cpu_num | VIRTIO_SUBCODE_64);
mask = be64_to_cpu(lowcore->external_new_psw.mask);
addr = be64_to_cpu(lowcore->external_new_psw.addr);
cpu_unmap_lowcore(lowcore);
env->ext_index--;
if (env->ext_index == -1) {
env->pending_int &= ~INTERRUPT_EXT;
}
DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,
env->psw.mask, env->psw.addr);
load_psw(env, mask, addr);
}
| true | qemu | 1a71992376792a0d11ea27688bd1a21cdffd1826 | static void do_ext_interrupt(CPUS390XState *env)
{
S390CPU *cpu = s390_env_get_cpu(env);
uint64_t mask, addr;
LowCore *lowcore;
ExtQueue *q;
if (!(env->psw.mask & PSW_MASK_EXT)) {
cpu_abort(CPU(cpu), "Ext int w/o ext mask\n");
}
if (env->ext_index < 0 || env->ext_index > MAX_EXT_QUEUE) {
cpu_abort(CPU(cpu), "Ext queue overrun: %d\n", env->ext_index);
}
q = &env->ext_queue[env->ext_index];
lowcore = cpu_map_lowcore(env);
lowcore->ext_int_code = cpu_to_be16(q->code);
lowcore->ext_params = cpu_to_be32(q->param);
lowcore->ext_params2 = cpu_to_be64(q->param64);
lowcore->external_old_psw.mask = cpu_to_be64(get_psw_mask(env));
lowcore->external_old_psw.addr = cpu_to_be64(env->psw.addr);
lowcore->cpu_addr = cpu_to_be16(env->cpu_num | VIRTIO_SUBCODE_64);
mask = be64_to_cpu(lowcore->external_new_psw.mask);
addr = be64_to_cpu(lowcore->external_new_psw.addr);
cpu_unmap_lowcore(lowcore);
env->ext_index--;
if (env->ext_index == -1) {
env->pending_int &= ~INTERRUPT_EXT;
}
DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,
env->psw.mask, env->psw.addr);
load_psw(env, mask, addr);
}
| {
"code": [
" if (env->ext_index < 0 || env->ext_index > MAX_EXT_QUEUE) {"
],
"line_no": [
23
]
} | static void FUNC_0(CPUS390XState *VAR_0)
{
S390CPU *cpu = s390_env_get_cpu(VAR_0);
uint64_t mask, addr;
LowCore *lowcore;
ExtQueue *q;
if (!(VAR_0->psw.mask & PSW_MASK_EXT)) {
cpu_abort(CPU(cpu), "Ext int w/o ext mask\n");
}
if (VAR_0->ext_index < 0 || VAR_0->ext_index > MAX_EXT_QUEUE) {
cpu_abort(CPU(cpu), "Ext queue overrun: %d\n", VAR_0->ext_index);
}
q = &VAR_0->ext_queue[VAR_0->ext_index];
lowcore = cpu_map_lowcore(VAR_0);
lowcore->ext_int_code = cpu_to_be16(q->code);
lowcore->ext_params = cpu_to_be32(q->param);
lowcore->ext_params2 = cpu_to_be64(q->param64);
lowcore->external_old_psw.mask = cpu_to_be64(get_psw_mask(VAR_0));
lowcore->external_old_psw.addr = cpu_to_be64(VAR_0->psw.addr);
lowcore->cpu_addr = cpu_to_be16(VAR_0->cpu_num | VIRTIO_SUBCODE_64);
mask = be64_to_cpu(lowcore->external_new_psw.mask);
addr = be64_to_cpu(lowcore->external_new_psw.addr);
cpu_unmap_lowcore(lowcore);
VAR_0->ext_index--;
if (VAR_0->ext_index == -1) {
VAR_0->pending_int &= ~INTERRUPT_EXT;
}
DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,
VAR_0->psw.mask, VAR_0->psw.addr);
load_psw(VAR_0, mask, addr);
}
| [
"static void FUNC_0(CPUS390XState *VAR_0)\n{",
"S390CPU *cpu = s390_env_get_cpu(VAR_0);",
"uint64_t mask, addr;",
"LowCore *lowcore;",
"ExtQueue *q;",
"if (!(VAR_0->psw.mask & PSW_MASK_EXT)) {",
"cpu_abort(CPU(cpu), \"Ext int w/o ext mask\\n\");",
"}",
"if (VAR_0->ext_index < 0 || VAR_0->ext_index > MAX_EXT_QUEUE) {",
"cpu_abort(CPU(cpu), \"Ext queue overrun: %d\\n\", VAR_0->ext_index);",
"}",
"q = &VAR_0->ext_queue[VAR_0->ext_index];",
"lowcore = cpu_map_lowcore(VAR_0);",
"lowcore->ext_int_code = cpu_to_be16(q->code);",
"lowcore->ext_params = cpu_to_be32(q->param);",
"lowcore->ext_params2 = cpu_to_be64(q->param64);",
"lowcore->external_old_psw.mask = cpu_to_be64(get_psw_mask(VAR_0));",
"lowcore->external_old_psw.addr = cpu_to_be64(VAR_0->psw.addr);",
"lowcore->cpu_addr = cpu_to_be16(VAR_0->cpu_num | VIRTIO_SUBCODE_64);",
"mask = be64_to_cpu(lowcore->external_new_psw.mask);",
"addr = be64_to_cpu(lowcore->external_new_psw.addr);",
"cpu_unmap_lowcore(lowcore);",
"VAR_0->ext_index--;",
"if (VAR_0->ext_index == -1) {",
"VAR_0->pending_int &= ~INTERRUPT_EXT;",
"}",
"DPRINTF(\"%s: %\" PRIx64 \" %\" PRIx64 \"\\n\", __func__,\nVAR_0->psw.mask, VAR_0->psw.addr);",
"load_psw(VAR_0, mask, addr);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69,
71
],
[
75
],
[
77
]
] |
23,902 | static struct omap_rtc_s *omap_rtc_init(MemoryRegion *system_memory,
hwaddr base,
qemu_irq timerirq, qemu_irq alarmirq,
omap_clk clk)
{
struct omap_rtc_s *s = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
s->irq = timerirq;
s->alarm = alarmirq;
s->clk = timer_new_ms(rtc_clock, omap_rtc_tick, s);
omap_rtc_reset(s);
memory_region_init_io(&s->iomem, NULL, &omap_rtc_ops, s,
"omap-rtc", 0x800);
memory_region_add_subregion(system_memory, base, &s->iomem);
return s;
}
| true | qemu | b45c03f585ea9bb1af76c73e82195418c294919d | static struct omap_rtc_s *omap_rtc_init(MemoryRegion *system_memory,
hwaddr base,
qemu_irq timerirq, qemu_irq alarmirq,
omap_clk clk)
{
struct omap_rtc_s *s = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
s->irq = timerirq;
s->alarm = alarmirq;
s->clk = timer_new_ms(rtc_clock, omap_rtc_tick, s);
omap_rtc_reset(s);
memory_region_init_io(&s->iomem, NULL, &omap_rtc_ops, s,
"omap-rtc", 0x800);
memory_region_add_subregion(system_memory, base, &s->iomem);
return s;
}
| {
"code": [
" struct omap_rtc_s *s = (struct omap_rtc_s *)",
" g_malloc0(sizeof(struct omap_rtc_s));"
],
"line_no": [
11,
13
]
} | static struct omap_rtc_s *FUNC_0(MemoryRegion *VAR_0,
hwaddr VAR_1,
qemu_irq VAR_2, qemu_irq VAR_3,
omap_clk VAR_4)
{
struct omap_rtc_s *VAR_5 = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
VAR_5->irq = VAR_2;
VAR_5->alarm = VAR_3;
VAR_5->VAR_4 = timer_new_ms(rtc_clock, omap_rtc_tick, VAR_5);
omap_rtc_reset(VAR_5);
memory_region_init_io(&VAR_5->iomem, NULL, &omap_rtc_ops, VAR_5,
"omap-rtc", 0x800);
memory_region_add_subregion(VAR_0, VAR_1, &VAR_5->iomem);
return VAR_5;
}
| [
"static struct omap_rtc_s *FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nqemu_irq VAR_2, qemu_irq VAR_3,\nomap_clk VAR_4)\n{",
"struct omap_rtc_s *VAR_5 = (struct omap_rtc_s *)\ng_malloc0(sizeof(struct omap_rtc_s));",
"VAR_5->irq = VAR_2;",
"VAR_5->alarm = VAR_3;",
"VAR_5->VAR_4 = timer_new_ms(rtc_clock, omap_rtc_tick, VAR_5);",
"omap_rtc_reset(VAR_5);",
"memory_region_init_io(&VAR_5->iomem, NULL, &omap_rtc_ops, VAR_5,\n\"omap-rtc\", 0x800);",
"memory_region_add_subregion(VAR_0, VAR_1, &VAR_5->iomem);",
"return VAR_5;",
"}"
] | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11,
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29,
31
],
[
33
],
[
37
],
[
39
]
] |
23,904 | static void gen_mtmsrd(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
return;
}
if (ctx->opcode & 0x00010000) {
/* Special form that does not need any synchronisation */
TCGv t0 = tcg_temp_new();
tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], (1 << MSR_RI) | (1 << MSR_EE));
tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(target_ulong)((1 << MSR_RI) | (1 << MSR_EE)));
tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
tcg_temp_free(t0);
} else {
/* XXX: we need to update nip before the store
* if we enter power saving mode, we will exit the loop
* directly from ppc_store_msr
*/
gen_update_nip(ctx, ctx->nip);
gen_helper_store_msr(cpu_env, cpu_gpr[rS(ctx->opcode)]);
/* Must stop the translation as machine state (may have) changed */
/* Note that mtmsr is not always defined as context-synchronizing */
gen_stop_exception(ctx);
}
#endif
}
| true | qemu | 9b2fadda3e0196ffd485adde4fe9cdd6fae35300 | static void gen_mtmsrd(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
return;
}
if (ctx->opcode & 0x00010000) {
TCGv t0 = tcg_temp_new();
tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], (1 << MSR_RI) | (1 << MSR_EE));
tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(target_ulong)((1 << MSR_RI) | (1 << MSR_EE)));
tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
tcg_temp_free(t0);
} else {
gen_update_nip(ctx, ctx->nip);
gen_helper_store_msr(cpu_env, cpu_gpr[rS(ctx->opcode)]);
gen_stop_exception(ctx);
}
#endif
}
| {
"code": [
" if (unlikely(ctx->pr)) {",
" if (unlikely(ctx->pr)) {",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#else",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (ctx->opcode & 0x00010000) {",
" if (unlikely(ctx->pr)) {",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
"#endif",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
" if (unlikely(ctx->pr)) {",
" gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
"#else",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
"#else",
" if (unlikely(ctx->pr)) {",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
"#else",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
"#if defined(CONFIG_USER_ONLY)",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif",
" if (unlikely(ctx->pr)) {",
"#endif"
],
"line_no": [
11,
11,
5,
7,
9,
11,
13,
55,
5,
7,
9,
11,
13,
55,
55,
5,
7,
9,
11,
13,
19,
11,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
55,
11,
55,
55,
55,
11,
55,
11,
55,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
7,
11,
13,
55,
5,
9,
11,
55,
11,
55,
5,
9,
11,
55,
5,
9,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
5,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55,
11,
55
]
} | static void FUNC_0(DisasContext *VAR_0)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_REG);
#else
if (unlikely(VAR_0->pr)) {
gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_REG);
return;
}
if (VAR_0->opcode & 0x00010000) {
TCGv t0 = tcg_temp_new();
tcg_gen_andi_tl(t0, cpu_gpr[rS(VAR_0->opcode)], (1 << MSR_RI) | (1 << MSR_EE));
tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(target_ulong)((1 << MSR_RI) | (1 << MSR_EE)));
tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
tcg_temp_free(t0);
} else {
gen_update_nip(VAR_0, VAR_0->nip);
gen_helper_store_msr(cpu_env, cpu_gpr[rS(VAR_0->opcode)]);
gen_stop_exception(VAR_0);
}
#endif
}
| [
"static void FUNC_0(DisasContext *VAR_0)\n{",
"#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_REG);",
"#else\nif (unlikely(VAR_0->pr)) {",
"gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_REG);",
"return;",
"}",
"if (VAR_0->opcode & 0x00010000) {",
"TCGv t0 = tcg_temp_new();",
"tcg_gen_andi_tl(t0, cpu_gpr[rS(VAR_0->opcode)], (1 << MSR_RI) | (1 << MSR_EE));",
"tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(target_ulong)((1 << MSR_RI) | (1 << MSR_EE)));",
"tcg_gen_or_tl(cpu_msr, cpu_msr, t0);",
"tcg_temp_free(t0);",
"} else {",
"gen_update_nip(VAR_0, VAR_0->nip);",
"gen_helper_store_msr(cpu_env, cpu_gpr[rS(VAR_0->opcode)]);",
"gen_stop_exception(VAR_0);",
"}",
"#endif\n}"
] | [
0,
1,
1,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1
] | [
[
1,
3
],
[
5,
7
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
43
],
[
45
],
[
51
],
[
53
],
[
55,
57
]
] |
23,905 | static av_cold int svq3_decode_init(AVCodecContext *avctx)
{
SVQ3Context *svq3 = avctx->priv_data;
H264Context *h = &svq3->h;
MpegEncContext *s = &h->s;
int m;
unsigned char *extradata;
unsigned char *extradata_end;
unsigned int size;
int marker_found = 0;
if (ff_h264_decode_init(avctx) < 0)
return -1;
s->flags = avctx->flags;
s->flags2 = avctx->flags2;
s->unrestricted_mv = 1;
h->is_complex=1;
h->sps.chroma_format_idc = 1;
avctx->pix_fmt = avctx->codec->pix_fmts[0];
if (!s->context_initialized) {
h->chroma_qp[0] = h->chroma_qp[1] = 4;
svq3->halfpel_flag = 1;
svq3->thirdpel_flag = 1;
svq3->unknown_flag = 0;
/* prowl for the "SEQH" marker in the extradata */
extradata = (unsigned char *)avctx->extradata;
extradata_end = avctx->extradata + avctx->extradata_size;
if (extradata) {
for (m = 0; m + 8 < avctx->extradata_size; m++) {
if (!memcmp(extradata, "SEQH", 4)) {
marker_found = 1;
break;
}
extradata++;
}
}
/* if a match was found, parse the extra data */
if (marker_found) {
GetBitContext gb;
int frame_size_code;
size = AV_RB32(&extradata[4]);
if (size > extradata_end - extradata - 8)
return AVERROR_INVALIDDATA;
init_get_bits(&gb, extradata + 8, size*8);
/* 'frame size code' and optional 'width, height' */
frame_size_code = get_bits(&gb, 3);
switch (frame_size_code) {
case 0: avctx->width = 160; avctx->height = 120; break;
case 1: avctx->width = 128; avctx->height = 96; break;
case 2: avctx->width = 176; avctx->height = 144; break;
case 3: avctx->width = 352; avctx->height = 288; break;
case 4: avctx->width = 704; avctx->height = 576; break;
case 5: avctx->width = 240; avctx->height = 180; break;
case 6: avctx->width = 320; avctx->height = 240; break;
case 7:
avctx->width = get_bits(&gb, 12);
avctx->height = get_bits(&gb, 12);
break;
}
svq3->halfpel_flag = get_bits1(&gb);
svq3->thirdpel_flag = get_bits1(&gb);
/* unknown fields */
skip_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
s->low_delay = get_bits1(&gb);
/* unknown field */
skip_bits1(&gb);
while (get_bits1(&gb)) {
skip_bits(&gb, 8);
}
svq3->unknown_flag = get_bits1(&gb);
avctx->has_b_frames = !s->low_delay;
if (svq3->unknown_flag) {
#if CONFIG_ZLIB
unsigned watermark_width = svq3_get_ue_golomb(&gb);
unsigned watermark_height = svq3_get_ue_golomb(&gb);
int u1 = svq3_get_ue_golomb(&gb);
int u2 = get_bits(&gb, 8);
int u3 = get_bits(&gb, 2);
int u4 = svq3_get_ue_golomb(&gb);
unsigned long buf_len = watermark_width*watermark_height*4;
int offset = (get_bits_count(&gb)+7)>>3;
uint8_t *buf;
if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
return -1;
buf = av_malloc(buf_len);
av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
av_free(buf);
return -1;
}
svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
av_free(buf);
#else
av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
return -1;
#endif
}
}
s->width = avctx->width;
s->height = avctx->height;
if (ff_MPV_common_init(s) < 0)
return -1;
h->b_stride = 4*s->mb_width;
if (ff_h264_alloc_tables(h) < 0) {
av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
return AVERROR(ENOMEM);
}
}
return 0;
}
| true | FFmpeg | 4fa706a4a64f9e06b08c1a42a62893ff2f7de82f | static av_cold int svq3_decode_init(AVCodecContext *avctx)
{
SVQ3Context *svq3 = avctx->priv_data;
H264Context *h = &svq3->h;
MpegEncContext *s = &h->s;
int m;
unsigned char *extradata;
unsigned char *extradata_end;
unsigned int size;
int marker_found = 0;
if (ff_h264_decode_init(avctx) < 0)
return -1;
s->flags = avctx->flags;
s->flags2 = avctx->flags2;
s->unrestricted_mv = 1;
h->is_complex=1;
h->sps.chroma_format_idc = 1;
avctx->pix_fmt = avctx->codec->pix_fmts[0];
if (!s->context_initialized) {
h->chroma_qp[0] = h->chroma_qp[1] = 4;
svq3->halfpel_flag = 1;
svq3->thirdpel_flag = 1;
svq3->unknown_flag = 0;
extradata = (unsigned char *)avctx->extradata;
extradata_end = avctx->extradata + avctx->extradata_size;
if (extradata) {
for (m = 0; m + 8 < avctx->extradata_size; m++) {
if (!memcmp(extradata, "SEQH", 4)) {
marker_found = 1;
break;
}
extradata++;
}
}
if (marker_found) {
GetBitContext gb;
int frame_size_code;
size = AV_RB32(&extradata[4]);
if (size > extradata_end - extradata - 8)
return AVERROR_INVALIDDATA;
init_get_bits(&gb, extradata + 8, size*8);
frame_size_code = get_bits(&gb, 3);
switch (frame_size_code) {
case 0: avctx->width = 160; avctx->height = 120; break;
case 1: avctx->width = 128; avctx->height = 96; break;
case 2: avctx->width = 176; avctx->height = 144; break;
case 3: avctx->width = 352; avctx->height = 288; break;
case 4: avctx->width = 704; avctx->height = 576; break;
case 5: avctx->width = 240; avctx->height = 180; break;
case 6: avctx->width = 320; avctx->height = 240; break;
case 7:
avctx->width = get_bits(&gb, 12);
avctx->height = get_bits(&gb, 12);
break;
}
svq3->halfpel_flag = get_bits1(&gb);
svq3->thirdpel_flag = get_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
s->low_delay = get_bits1(&gb);
skip_bits1(&gb);
while (get_bits1(&gb)) {
skip_bits(&gb, 8);
}
svq3->unknown_flag = get_bits1(&gb);
avctx->has_b_frames = !s->low_delay;
if (svq3->unknown_flag) {
#if CONFIG_ZLIB
unsigned watermark_width = svq3_get_ue_golomb(&gb);
unsigned watermark_height = svq3_get_ue_golomb(&gb);
int u1 = svq3_get_ue_golomb(&gb);
int u2 = get_bits(&gb, 8);
int u3 = get_bits(&gb, 2);
int u4 = svq3_get_ue_golomb(&gb);
unsigned long buf_len = watermark_width*watermark_height*4;
int offset = (get_bits_count(&gb)+7)>>3;
uint8_t *buf;
if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
return -1;
buf = av_malloc(buf_len);
av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
av_free(buf);
return -1;
}
svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
av_free(buf);
#else
av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
return -1;
#endif
}
}
s->width = avctx->width;
s->height = avctx->height;
if (ff_MPV_common_init(s) < 0)
return -1;
h->b_stride = 4*s->mb_width;
if (ff_h264_alloc_tables(h) < 0) {
av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
return AVERROR(ENOMEM);
}
}
return 0;
}
| {
"code": [
" if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)"
],
"line_no": [
203
]
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
SVQ3Context *svq3 = avctx->priv_data;
H264Context *h = &svq3->h;
MpegEncContext *s = &h->s;
int VAR_0;
unsigned char *VAR_1;
unsigned char *VAR_2;
unsigned int VAR_3;
int VAR_4 = 0;
if (ff_h264_decode_init(avctx) < 0)
return -1;
s->flags = avctx->flags;
s->flags2 = avctx->flags2;
s->unrestricted_mv = 1;
h->is_complex=1;
h->sps.chroma_format_idc = 1;
avctx->pix_fmt = avctx->codec->pix_fmts[0];
if (!s->context_initialized) {
h->chroma_qp[0] = h->chroma_qp[1] = 4;
svq3->halfpel_flag = 1;
svq3->thirdpel_flag = 1;
svq3->unknown_flag = 0;
VAR_1 = (unsigned char *)avctx->VAR_1;
VAR_2 = avctx->VAR_1 + avctx->extradata_size;
if (VAR_1) {
for (VAR_0 = 0; VAR_0 + 8 < avctx->extradata_size; VAR_0++) {
if (!memcmp(VAR_1, "SEQH", 4)) {
VAR_4 = 1;
break;
}
VAR_1++;
}
}
if (VAR_4) {
GetBitContext gb;
int VAR_5;
VAR_3 = AV_RB32(&VAR_1[4]);
if (VAR_3 > VAR_2 - VAR_1 - 8)
return AVERROR_INVALIDDATA;
init_get_bits(&gb, VAR_1 + 8, VAR_3*8);
VAR_5 = get_bits(&gb, 3);
switch (VAR_5) {
case 0: avctx->width = 160; avctx->height = 120; break;
case 1: avctx->width = 128; avctx->height = 96; break;
case 2: avctx->width = 176; avctx->height = 144; break;
case 3: avctx->width = 352; avctx->height = 288; break;
case 4: avctx->width = 704; avctx->height = 576; break;
case 5: avctx->width = 240; avctx->height = 180; break;
case 6: avctx->width = 320; avctx->height = 240; break;
case 7:
avctx->width = get_bits(&gb, 12);
avctx->height = get_bits(&gb, 12);
break;
}
svq3->halfpel_flag = get_bits1(&gb);
svq3->thirdpel_flag = get_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
skip_bits1(&gb);
s->low_delay = get_bits1(&gb);
skip_bits1(&gb);
while (get_bits1(&gb)) {
skip_bits(&gb, 8);
}
svq3->unknown_flag = get_bits1(&gb);
avctx->has_b_frames = !s->low_delay;
if (svq3->unknown_flag) {
#if CONFIG_ZLIB
unsigned watermark_width = svq3_get_ue_golomb(&gb);
unsigned watermark_height = svq3_get_ue_golomb(&gb);
int u1 = svq3_get_ue_golomb(&gb);
int u2 = get_bits(&gb, 8);
int u3 = get_bits(&gb, 2);
int u4 = svq3_get_ue_golomb(&gb);
unsigned long buf_len = watermark_width*watermark_height*4;
int offset = (get_bits_count(&gb)+7)>>3;
uint8_t *buf;
if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
return -1;
buf = av_malloc(buf_len);
av_log(avctx, AV_LOG_DEBUG, "watermark VAR_3: %dx%d\n", watermark_width, watermark_height);
av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data VAR_3: %d offset: %d\n", u1, u2, u3, u4, offset);
if (uncompress(buf, &buf_len, VAR_1 + 8 + offset, VAR_3 - offset) != Z_OK) {
av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
av_free(buf);
return -1;
}
svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
av_free(buf);
#else
av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
return -1;
#endif
}
}
s->width = avctx->width;
s->height = avctx->height;
if (ff_MPV_common_init(s) < 0)
return -1;
h->b_stride = 4*s->mb_width;
if (ff_h264_alloc_tables(h) < 0) {
av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
return AVERROR(ENOMEM);
}
}
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"SVQ3Context *svq3 = avctx->priv_data;",
"H264Context *h = &svq3->h;",
"MpegEncContext *s = &h->s;",
"int VAR_0;",
"unsigned char *VAR_1;",
"unsigned char *VAR_2;",
"unsigned int VAR_3;",
"int VAR_4 = 0;",
"if (ff_h264_decode_init(avctx) < 0)\nreturn -1;",
"s->flags = avctx->flags;",
"s->flags2 = avctx->flags2;",
"s->unrestricted_mv = 1;",
"h->is_complex=1;",
"h->sps.chroma_format_idc = 1;",
"avctx->pix_fmt = avctx->codec->pix_fmts[0];",
"if (!s->context_initialized) {",
"h->chroma_qp[0] = h->chroma_qp[1] = 4;",
"svq3->halfpel_flag = 1;",
"svq3->thirdpel_flag = 1;",
"svq3->unknown_flag = 0;",
"VAR_1 = (unsigned char *)avctx->VAR_1;",
"VAR_2 = avctx->VAR_1 + avctx->extradata_size;",
"if (VAR_1) {",
"for (VAR_0 = 0; VAR_0 + 8 < avctx->extradata_size; VAR_0++) {",
"if (!memcmp(VAR_1, \"SEQH\", 4)) {",
"VAR_4 = 1;",
"break;",
"}",
"VAR_1++;",
"}",
"}",
"if (VAR_4) {",
"GetBitContext gb;",
"int VAR_5;",
"VAR_3 = AV_RB32(&VAR_1[4]);",
"if (VAR_3 > VAR_2 - VAR_1 - 8)\nreturn AVERROR_INVALIDDATA;",
"init_get_bits(&gb, VAR_1 + 8, VAR_3*8);",
"VAR_5 = get_bits(&gb, 3);",
"switch (VAR_5) {",
"case 0: avctx->width = 160; avctx->height = 120; break;",
"case 1: avctx->width = 128; avctx->height = 96; break;",
"case 2: avctx->width = 176; avctx->height = 144; break;",
"case 3: avctx->width = 352; avctx->height = 288; break;",
"case 4: avctx->width = 704; avctx->height = 576; break;",
"case 5: avctx->width = 240; avctx->height = 180; break;",
"case 6: avctx->width = 320; avctx->height = 240; break;",
"case 7:\navctx->width = get_bits(&gb, 12);",
"avctx->height = get_bits(&gb, 12);",
"break;",
"}",
"svq3->halfpel_flag = get_bits1(&gb);",
"svq3->thirdpel_flag = get_bits1(&gb);",
"skip_bits1(&gb);",
"skip_bits1(&gb);",
"skip_bits1(&gb);",
"skip_bits1(&gb);",
"s->low_delay = get_bits1(&gb);",
"skip_bits1(&gb);",
"while (get_bits1(&gb)) {",
"skip_bits(&gb, 8);",
"}",
"svq3->unknown_flag = get_bits1(&gb);",
"avctx->has_b_frames = !s->low_delay;",
"if (svq3->unknown_flag) {",
"#if CONFIG_ZLIB\nunsigned watermark_width = svq3_get_ue_golomb(&gb);",
"unsigned watermark_height = svq3_get_ue_golomb(&gb);",
"int u1 = svq3_get_ue_golomb(&gb);",
"int u2 = get_bits(&gb, 8);",
"int u3 = get_bits(&gb, 2);",
"int u4 = svq3_get_ue_golomb(&gb);",
"unsigned long buf_len = watermark_width*watermark_height*4;",
"int offset = (get_bits_count(&gb)+7)>>3;",
"uint8_t *buf;",
"if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)\nreturn -1;",
"buf = av_malloc(buf_len);",
"av_log(avctx, AV_LOG_DEBUG, \"watermark VAR_3: %dx%d\\n\", watermark_width, watermark_height);",
"av_log(avctx, AV_LOG_DEBUG, \"u1: %x u2: %x u3: %x compressed data VAR_3: %d offset: %d\\n\", u1, u2, u3, u4, offset);",
"if (uncompress(buf, &buf_len, VAR_1 + 8 + offset, VAR_3 - offset) != Z_OK) {",
"av_log(avctx, AV_LOG_ERROR, \"could not uncompress watermark logo\\n\");",
"av_free(buf);",
"return -1;",
"}",
"svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);",
"svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;",
"av_log(avctx, AV_LOG_DEBUG, \"watermark key %#x\\n\", svq3->watermark_key);",
"av_free(buf);",
"#else\nav_log(avctx, AV_LOG_ERROR, \"this svq3 file contains watermark which need zlib support compiled in\\n\");",
"return -1;",
"#endif\n}",
"}",
"s->width = avctx->width;",
"s->height = avctx->height;",
"if (ff_MPV_common_init(s) < 0)\nreturn -1;",
"h->b_stride = 4*s->mb_width;",
"if (ff_h264_alloc_tables(h) < 0) {",
"av_log(avctx, AV_LOG_ERROR, \"svq3 memory allocation failed\\n\");",
"return AVERROR(ENOMEM);",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
87
],
[
91
],
[
93
],
[
97
],
[
99,
101
],
[
103
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127,
129
],
[
131
],
[
133
],
[
135
],
[
139
],
[
141
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157
],
[
163
],
[
167
],
[
169
],
[
171
],
[
175
],
[
177
],
[
179
],
[
181,
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203,
205
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233,
235
],
[
237
],
[
239,
241
],
[
243
],
[
247
],
[
249
],
[
253,
255
],
[
259
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
275
],
[
277
]
] |
23,906 | int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
VP56Context *s = avctx->priv_data;
AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
int remaining_buf_size = avpkt->size;
int is_alpha, av_uninit(alpha_offset);
if (s->has_alpha) {
if (remaining_buf_size < 3)
return -1;
alpha_offset = bytestream_get_be24(&buf);
remaining_buf_size -= 3;
if (remaining_buf_size < alpha_offset)
return -1;
}
for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
s->modelp = &s->models[is_alpha];
res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
if (!res)
return -1;
if (res == 2) {
int i;
for (i = 0; i < 4; i++) {
if (s->frames[i].data[0])
avctx->release_buffer(avctx, &s->frames[i]);
}
if (is_alpha)
return -1;
}
if (!is_alpha) {
p->reference = 1;
if (avctx->get_buffer(avctx, p) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(avctx)) {
avctx->release_buffer(avctx, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = AV_PICTURE_TYPE_I;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = AV_PICTURE_TYPE_P;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
/* main macroblocks loop */
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_FRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, is_alpha);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (p->key_frame || golden_frame) {
if (s->framep[VP56_FRAME_GOLDEN]->data[0] &&
s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]);
s->framep[VP56_FRAME_GOLDEN] = p;
}
if (s->has_alpha) {
FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
s->framep[VP56_FRAME_GOLDEN2]);
buf += alpha_offset;
remaining_buf_size -= alpha_offset;
}
}
if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED]);
else
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED2]);
} else if (s->framep[VP56_FRAME_PREVIOUS]->data[0])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]);
FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
s->framep[VP56_FRAME_PREVIOUS]);
p->qstride = 0;
p->qscale_table = s->qscale_table;
p->qscale_type = FF_QSCALE_TYPE_VP56;
*(AVFrame*)data = *p;
*data_size = sizeof(AVFrame);
return avpkt->size;
}
| false | FFmpeg | 7c249d4fbaf4431b20a90a3c942f3370c0039d9e | int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
VP56Context *s = avctx->priv_data;
AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
int remaining_buf_size = avpkt->size;
int is_alpha, av_uninit(alpha_offset);
if (s->has_alpha) {
if (remaining_buf_size < 3)
return -1;
alpha_offset = bytestream_get_be24(&buf);
remaining_buf_size -= 3;
if (remaining_buf_size < alpha_offset)
return -1;
}
for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
s->modelp = &s->models[is_alpha];
res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
if (!res)
return -1;
if (res == 2) {
int i;
for (i = 0; i < 4; i++) {
if (s->frames[i].data[0])
avctx->release_buffer(avctx, &s->frames[i]);
}
if (is_alpha)
return -1;
}
if (!is_alpha) {
p->reference = 1;
if (avctx->get_buffer(avctx, p) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(avctx)) {
avctx->release_buffer(avctx, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = AV_PICTURE_TYPE_I;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = AV_PICTURE_TYPE_P;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_FRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, is_alpha);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (p->key_frame || golden_frame) {
if (s->framep[VP56_FRAME_GOLDEN]->data[0] &&
s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]);
s->framep[VP56_FRAME_GOLDEN] = p;
}
if (s->has_alpha) {
FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
s->framep[VP56_FRAME_GOLDEN2]);
buf += alpha_offset;
remaining_buf_size -= alpha_offset;
}
}
if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED]);
else
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED2]);
} else if (s->framep[VP56_FRAME_PREVIOUS]->data[0])
avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]);
FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
s->framep[VP56_FRAME_PREVIOUS]);
p->qstride = 0;
p->qscale_table = s->qscale_table;
p->qscale_type = FF_QSCALE_TYPE_VP56;
*(AVFrame*)data = *p;
*data_size = sizeof(AVFrame);
return avpkt->size;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{
const uint8_t *VAR_4 = VAR_3->VAR_1;
VP56Context *s = VAR_0->priv_data;
AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
int VAR_5 = VAR_3->size;
int VAR_6, FUNC_1(alpha_offset);
if (s->has_alpha) {
if (VAR_5 < 3)
return -1;
alpha_offset = bytestream_get_be24(&VAR_4);
VAR_5 -= 3;
if (VAR_5 < alpha_offset)
return -1;
}
for (VAR_6=0; VAR_6 < 1+s->has_alpha; VAR_6++) {
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
s->modelp = &s->models[VAR_6];
res = s->parse_header(s, VAR_4, VAR_5, &golden_frame);
if (!res)
return -1;
if (res == 2) {
int i;
for (i = 0; i < 4; i++) {
if (s->frames[i].VAR_1[0])
VAR_0->release_buffer(VAR_0, &s->frames[i]);
}
if (VAR_6)
return -1;
}
if (!VAR_6) {
p->reference = 1;
if (VAR_0->get_buffer(VAR_0, p) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(VAR_0)) {
VAR_0->release_buffer(VAR_0, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = AV_PICTURE_TYPE_I;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = AV_PICTURE_TYPE_P;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_FRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, VAR_6);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (p->key_frame || golden_frame) {
if (s->framep[VP56_FRAME_GOLDEN]->VAR_1[0] &&
s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
VAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_GOLDEN]);
s->framep[VP56_FRAME_GOLDEN] = p;
}
if (s->has_alpha) {
FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
s->framep[VP56_FRAME_GOLDEN2]);
VAR_4 += alpha_offset;
VAR_5 -= alpha_offset;
}
}
if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED]);
else
FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
s->framep[VP56_FRAME_UNUSED2]);
} else if (s->framep[VP56_FRAME_PREVIOUS]->VAR_1[0])
VAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_PREVIOUS]);
FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
s->framep[VP56_FRAME_PREVIOUS]);
p->qstride = 0;
p->qscale_table = s->qscale_table;
p->qscale_type = FF_QSCALE_TYPE_VP56;
*(AVFrame*)VAR_1 = *p;
*VAR_2 = sizeof(AVFrame);
return VAR_3->size;
}
| [
"int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"VP56Context *s = VAR_0->priv_data;",
"AVFrame *const p = s->framep[VP56_FRAME_CURRENT];",
"int VAR_5 = VAR_3->size;",
"int VAR_6, FUNC_1(alpha_offset);",
"if (s->has_alpha) {",
"if (VAR_5 < 3)\nreturn -1;",
"alpha_offset = bytestream_get_be24(&VAR_4);",
"VAR_5 -= 3;",
"if (VAR_5 < alpha_offset)\nreturn -1;",
"}",
"for (VAR_6=0; VAR_6 < 1+s->has_alpha; VAR_6++) {",
"int mb_row, mb_col, mb_row_flip, mb_offset = 0;",
"int block, y, uv, stride_y, stride_uv;",
"int golden_frame = 0;",
"int res;",
"s->modelp = &s->models[VAR_6];",
"res = s->parse_header(s, VAR_4, VAR_5, &golden_frame);",
"if (!res)\nreturn -1;",
"if (res == 2) {",
"int i;",
"for (i = 0; i < 4; i++) {",
"if (s->frames[i].VAR_1[0])\nVAR_0->release_buffer(VAR_0, &s->frames[i]);",
"}",
"if (VAR_6)\nreturn -1;",
"}",
"if (!VAR_6) {",
"p->reference = 1;",
"if (VAR_0->get_buffer(VAR_0, p) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"get_buffer() failed\\n\");",
"return -1;",
"}",
"if (res == 2)\nif (vp56_size_changed(VAR_0)) {",
"VAR_0->release_buffer(VAR_0, p);",
"return -1;",
"}",
"}",
"if (p->key_frame) {",
"p->pict_type = AV_PICTURE_TYPE_I;",
"s->default_models_init(s);",
"for (block=0; block<s->mb_height*s->mb_width; block++)",
"s->macroblocks[block].type = VP56_MB_INTRA;",
"} else {",
"p->pict_type = AV_PICTURE_TYPE_P;",
"vp56_parse_mb_type_models(s);",
"s->parse_vector_models(s);",
"s->mb_type = VP56_MB_INTER_NOVEC_PF;",
"}",
"s->parse_coeff_models(s);",
"memset(s->prev_dc, 0, sizeof(s->prev_dc));",
"s->prev_dc[1][VP56_FRAME_CURRENT] = 128;",
"s->prev_dc[2][VP56_FRAME_CURRENT] = 128;",
"for (block=0; block < 4*s->mb_width+6; block++) {",
"s->above_blocks[block].ref_frame = VP56_FRAME_NONE;",
"s->above_blocks[block].dc_coeff = 0;",
"s->above_blocks[block].not_null_dc = 0;",
"}",
"s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;",
"s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;",
"stride_y = p->linesize[0];",
"stride_uv = p->linesize[1];",
"if (s->flip < 0)\nmb_offset = 7;",
"for (mb_row=0; mb_row<s->mb_height; mb_row++) {",
"if (s->flip < 0)\nmb_row_flip = s->mb_height - mb_row - 1;",
"else\nmb_row_flip = mb_row;",
"for (block=0; block<4; block++) {",
"s->left_block[block].ref_frame = VP56_FRAME_NONE;",
"s->left_block[block].dc_coeff = 0;",
"s->left_block[block].not_null_dc = 0;",
"}",
"memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));",
"memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));",
"s->above_block_idx[0] = 1;",
"s->above_block_idx[1] = 2;",
"s->above_block_idx[2] = 1;",
"s->above_block_idx[3] = 2;",
"s->above_block_idx[4] = 2*s->mb_width + 2 + 1;",
"s->above_block_idx[5] = 3*s->mb_width + 4 + 1;",
"s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;",
"s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;",
"s->block_offset[1] = s->block_offset[0] + 8;",
"s->block_offset[3] = s->block_offset[2] + 8;",
"s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;",
"s->block_offset[5] = s->block_offset[4];",
"for (mb_col=0; mb_col<s->mb_width; mb_col++) {",
"vp56_decode_mb(s, mb_row, mb_col, VAR_6);",
"for (y=0; y<4; y++) {",
"s->above_block_idx[y] += 2;",
"s->block_offset[y] += 16;",
"}",
"for (uv=4; uv<6; uv++) {",
"s->above_block_idx[uv] += 1;",
"s->block_offset[uv] += 8;",
"}",
"}",
"}",
"if (p->key_frame || golden_frame) {",
"if (s->framep[VP56_FRAME_GOLDEN]->VAR_1[0] &&\ns->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])\nVAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_GOLDEN]);",
"s->framep[VP56_FRAME_GOLDEN] = p;",
"}",
"if (s->has_alpha) {",
"FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],\ns->framep[VP56_FRAME_GOLDEN2]);",
"VAR_4 += alpha_offset;",
"VAR_5 -= alpha_offset;",
"}",
"}",
"if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||\ns->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {",
"if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&\ns->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])\nFFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],\ns->framep[VP56_FRAME_UNUSED]);",
"else\nFFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],\ns->framep[VP56_FRAME_UNUSED2]);",
"} else if (s->framep[VP56_FRAME_PREVIOUS]->VAR_1[0])",
"VAR_0->release_buffer(VAR_0, s->framep[VP56_FRAME_PREVIOUS]);",
"FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],\ns->framep[VP56_FRAME_PREVIOUS]);",
"p->qstride = 0;",
"p->qscale_table = s->qscale_table;",
"p->qscale_type = FF_QSCALE_TYPE_VP56;",
"*(AVFrame*)VAR_1 = *p;",
"*VAR_2 = sizeof(AVFrame);",
"return VAR_3->size;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
53
],
[
55,
57
],
[
61
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
73,
75
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95,
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133
],
[
137
],
[
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
163
],
[
167,
169
],
[
175
],
[
177,
179
],
[
181,
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
231
],
[
233
],
[
237
],
[
239
],
[
241
],
[
243
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
261
],
[
263,
265,
267
],
[
269
],
[
271
],
[
275
],
[
277,
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
291,
293
],
[
295,
297,
299,
301
],
[
303,
305,
307
],
[
309
],
[
311
],
[
313,
315
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327
],
[
331
],
[
333
]
] |
23,907 | static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
int tag, len;
get_be32(pb); /* version + flags */
len = mp4_read_descr(c, pb, &tag);
if (tag == MP4ESDescrTag) {
get_be16(pb); /* ID */
get_byte(pb); /* priority */
} else
get_be16(pb); /* ID */
len = mp4_read_descr(c, pb, &tag);
if (tag == MP4DecConfigDescrTag) {
int object_type_id = get_byte(pb);
get_byte(pb); /* stream type */
get_be24(pb); /* buffer size db */
get_be32(pb); /* max bitrate */
get_be32(pb); /* avg bitrate */
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
dprintf(c->fc, "esds object type id %d\n", object_type_id);
len = mp4_read_descr(c, pb, &tag);
if (tag == MP4DecSpecificDescrTag) {
dprintf(c->fc, "Specific MPEG4 header len=%d\n", len);
if((uint64_t)len > (1<<30))
return -1;
st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, len);
st->codec->extradata_size = len;
if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg;
ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size);
if (cfg.chan_config > 7)
return -1;
st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config];
if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
else
st->codec->sample_rate = cfg.sample_rate; // ext sample rate ?
dprintf(c->fc, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type)))
st->codec->codec_id = CODEC_ID_AAC;
}
}
}
return 0;
}
| false | FFmpeg | 6a63ff19b6a7fe3bc32c7fb4a62fca8f65786432 | static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
int tag, len;
get_be32(pb);
len = mp4_read_descr(c, pb, &tag);
if (tag == MP4ESDescrTag) {
get_be16(pb);
get_byte(pb);
} else
get_be16(pb);
len = mp4_read_descr(c, pb, &tag);
if (tag == MP4DecConfigDescrTag) {
int object_type_id = get_byte(pb);
get_byte(pb);
get_be24(pb);
get_be32(pb);
get_be32(pb);
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
dprintf(c->fc, "esds object type id %d\n", object_type_id);
len = mp4_read_descr(c, pb, &tag);
if (tag == MP4DecSpecificDescrTag) {
dprintf(c->fc, "Specific MPEG4 header len=%d\n", len);
if((uint64_t)len > (1<<30))
return -1;
st->codec->extradata = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, len);
st->codec->extradata_size = len;
if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg;
ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size);
if (cfg.chan_config > 7)
return -1;
st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config];
if (cfg.object_type == 29 && cfg.sampling_index < 3)
st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
else
st->codec->sample_rate = cfg.sample_rate;
dprintf(c->fc, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type)))
st->codec->codec_id = CODEC_ID_AAC;
}
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)
{
AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];
int VAR_3, VAR_4;
get_be32(VAR_1);
VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);
if (VAR_3 == MP4ESDescrTag) {
get_be16(VAR_1);
get_byte(VAR_1);
} else
get_be16(VAR_1);
VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);
if (VAR_3 == MP4DecConfigDescrTag) {
int VAR_5 = get_byte(VAR_1);
get_byte(VAR_1);
get_be24(VAR_1);
get_be32(VAR_1);
get_be32(VAR_1);
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, VAR_5);
dprintf(VAR_0->fc, "esds object type id %d\n", VAR_5);
VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);
if (VAR_3 == MP4DecSpecificDescrTag) {
dprintf(VAR_0->fc, "Specific MPEG4 header VAR_4=%d\n", VAR_4);
if((uint64_t)VAR_4 > (1<<30))
return -1;
st->codec->extradata = av_mallocz(VAR_4 + FF_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata)
return AVERROR(ENOMEM);
get_buffer(VAR_1, st->codec->extradata, VAR_4);
st->codec->extradata_size = VAR_4;
if (st->codec->codec_id == CODEC_ID_AAC) {
MPEG4AudioConfig cfg;
ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size);
if (cfg.chan_config > 7)
return -1;
st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config];
if (cfg.object_type == 29 && cfg.sampling_index < 3)
st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
else
st->codec->sample_rate = cfg.sample_rate;
dprintf(VAR_0->fc, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type)))
st->codec->codec_id = CODEC_ID_AAC;
}
}
}
return 0;
}
| [
"static int FUNC_0(MOVContext *VAR_0, ByteIOContext *VAR_1, MOVAtom VAR_2)\n{",
"AVStream *st = VAR_0->fc->streams[VAR_0->fc->nb_streams-1];",
"int VAR_3, VAR_4;",
"get_be32(VAR_1);",
"VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);",
"if (VAR_3 == MP4ESDescrTag) {",
"get_be16(VAR_1);",
"get_byte(VAR_1);",
"} else",
"get_be16(VAR_1);",
"VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);",
"if (VAR_3 == MP4DecConfigDescrTag) {",
"int VAR_5 = get_byte(VAR_1);",
"get_byte(VAR_1);",
"get_be24(VAR_1);",
"get_be32(VAR_1);",
"get_be32(VAR_1);",
"st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, VAR_5);",
"dprintf(VAR_0->fc, \"esds object type id %d\\n\", VAR_5);",
"VAR_4 = mp4_read_descr(VAR_0, VAR_1, &VAR_3);",
"if (VAR_3 == MP4DecSpecificDescrTag) {",
"dprintf(VAR_0->fc, \"Specific MPEG4 header VAR_4=%d\\n\", VAR_4);",
"if((uint64_t)VAR_4 > (1<<30))\nreturn -1;",
"st->codec->extradata = av_mallocz(VAR_4 + FF_INPUT_BUFFER_PADDING_SIZE);",
"if (!st->codec->extradata)\nreturn AVERROR(ENOMEM);",
"get_buffer(VAR_1, st->codec->extradata, VAR_4);",
"st->codec->extradata_size = VAR_4;",
"if (st->codec->codec_id == CODEC_ID_AAC) {",
"MPEG4AudioConfig cfg;",
"ff_mpeg4audio_get_config(&cfg, st->codec->extradata,\nst->codec->extradata_size);",
"if (cfg.chan_config > 7)\nreturn -1;",
"st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config];",
"if (cfg.object_type == 29 && cfg.sampling_index < 3)\nst->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];",
"else\nst->codec->sample_rate = cfg.sample_rate;",
"dprintf(VAR_0->fc, \"mp4a config channels %d obj %d ext obj %d \"\n\"sample rate %d ext sample rate %d\\n\", st->codec->channels,\ncfg.object_type, cfg.ext_object_type,\ncfg.sample_rate, cfg.ext_sample_rate);",
"if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types,\ncfg.object_type)))\nst->codec->codec_id = CODEC_ID_AAC;",
"}",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71,
73
],
[
75,
77
],
[
79
],
[
81,
83
],
[
85,
87
],
[
89,
91,
93,
95
],
[
97,
99,
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
]
] |
23,908 | av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
{
NVENCContext *ctx = avctx->priv_data;
NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
int i;
av_frame_free(&avctx->coded_frame);
if (ctx->in) {
for (i = 0; i < ctx->nb_surfaces; ++i) {
nv->nvEncDestroyInputBuffer(ctx->nvenc_ctx, ctx->in[i].in);
nv->nvEncDestroyBitstreamBuffer(ctx->nvenc_ctx, ctx->out[i].out);
}
}
av_freep(&ctx->in);
av_freep(&ctx->out);
if (ctx->nvenc_ctx)
nv->nvEncDestroyEncoder(ctx->nvenc_ctx);
if (ctx->cu_context)
ctx->nvel.cu_ctx_destroy(ctx->cu_context);
if (ctx->nvel.nvenc)
dlclose(ctx->nvel.nvenc);
if (ctx->nvel.cuda)
dlclose(ctx->nvel.cuda);
return 0;
}
| false | FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 | av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
{
NVENCContext *ctx = avctx->priv_data;
NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
int i;
av_frame_free(&avctx->coded_frame);
if (ctx->in) {
for (i = 0; i < ctx->nb_surfaces; ++i) {
nv->nvEncDestroyInputBuffer(ctx->nvenc_ctx, ctx->in[i].in);
nv->nvEncDestroyBitstreamBuffer(ctx->nvenc_ctx, ctx->out[i].out);
}
}
av_freep(&ctx->in);
av_freep(&ctx->out);
if (ctx->nvenc_ctx)
nv->nvEncDestroyEncoder(ctx->nvenc_ctx);
if (ctx->cu_context)
ctx->nvel.cu_ctx_destroy(ctx->cu_context);
if (ctx->nvel.nvenc)
dlclose(ctx->nvel.nvenc);
if (ctx->nvel.cuda)
dlclose(ctx->nvel.cuda);
return 0;
}
| {
"code": [],
"line_no": []
} | av_cold int FUNC_0(AVCodecContext *avctx)
{
NVENCContext *ctx = avctx->priv_data;
NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
int VAR_0;
av_frame_free(&avctx->coded_frame);
if (ctx->in) {
for (VAR_0 = 0; VAR_0 < ctx->nb_surfaces; ++VAR_0) {
nv->nvEncDestroyInputBuffer(ctx->nvenc_ctx, ctx->in[VAR_0].in);
nv->nvEncDestroyBitstreamBuffer(ctx->nvenc_ctx, ctx->out[VAR_0].out);
}
}
av_freep(&ctx->in);
av_freep(&ctx->out);
if (ctx->nvenc_ctx)
nv->nvEncDestroyEncoder(ctx->nvenc_ctx);
if (ctx->cu_context)
ctx->nvel.cu_ctx_destroy(ctx->cu_context);
if (ctx->nvel.nvenc)
dlclose(ctx->nvel.nvenc);
if (ctx->nvel.cuda)
dlclose(ctx->nvel.cuda);
return 0;
}
| [
"av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"NVENCContext *ctx = avctx->priv_data;",
"NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;",
"int VAR_0;",
"av_frame_free(&avctx->coded_frame);",
"if (ctx->in) {",
"for (VAR_0 = 0; VAR_0 < ctx->nb_surfaces; ++VAR_0) {",
"nv->nvEncDestroyInputBuffer(ctx->nvenc_ctx, ctx->in[VAR_0].in);",
"nv->nvEncDestroyBitstreamBuffer(ctx->nvenc_ctx, ctx->out[VAR_0].out);",
"}",
"}",
"av_freep(&ctx->in);",
"av_freep(&ctx->out);",
"if (ctx->nvenc_ctx)\nnv->nvEncDestroyEncoder(ctx->nvenc_ctx);",
"if (ctx->cu_context)\nctx->nvel.cu_ctx_destroy(ctx->cu_context);",
"if (ctx->nvel.nvenc)\ndlclose(ctx->nvel.nvenc);",
"if (ctx->nvel.cuda)\ndlclose(ctx->nvel.cuda);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37,
39
],
[
43,
45
],
[
49,
51
],
[
55,
57
],
[
61
],
[
63
]
] |
23,909 | static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list,
int type)
{
while (list != NULL && list->packet != NULL) {
if (list->packet->type == type)
return list;
list = list->next;
}
return NULL;
}
| false | FFmpeg | 4b1f5e5090abed6c618c8ba380cd7d28d140f867 | static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list,
int type)
{
while (list != NULL && list->packet != NULL) {
if (list->packet->type == type)
return list;
list = list->next;
}
return NULL;
}
| {
"code": [],
"line_no": []
} | static QDM2SubPNode *FUNC_0(QDM2SubPNode *list,
int type)
{
while (list != NULL && list->packet != NULL) {
if (list->packet->type == type)
return list;
list = list->next;
}
return NULL;
}
| [
"static QDM2SubPNode *FUNC_0(QDM2SubPNode *list,\nint type)\n{",
"while (list != NULL && list->packet != NULL) {",
"if (list->packet->type == type)\nreturn list;",
"list = list->next;",
"}",
"return NULL;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
23,910 | static int segment_end(AVFormatContext *s, int write_trailer, int is_last)
{
SegmentContext *seg = s->priv_data;
AVFormatContext *oc = seg->avf;
int ret = 0;
av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */
if (write_trailer)
ret = av_write_trailer(oc);
if (ret < 0)
av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n",
oc->filename);
if (seg->list) {
if (seg->list_size || seg->list_type == LIST_TYPE_M3U8) {
SegmentListEntry *entry = av_mallocz(sizeof(*entry));
if (!entry) {
ret = AVERROR(ENOMEM);
goto end;
}
/* append new element */
memcpy(entry, &seg->cur_entry, sizeof(*entry));
if (!seg->segment_list_entries)
seg->segment_list_entries = seg->segment_list_entries_end = entry;
else
seg->segment_list_entries_end->next = entry;
seg->segment_list_entries_end = entry;
/* drop first item */
if (seg->list_size && seg->segment_count > seg->list_size) {
entry = seg->segment_list_entries;
seg->segment_list_entries = seg->segment_list_entries->next;
av_free(entry->filename);
av_freep(&entry);
}
avio_close(seg->list_pb);
if ((ret = segment_list_open(s)) < 0)
goto end;
for (entry = seg->segment_list_entries; entry; entry = entry->next)
segment_list_print_entry(seg->list_pb, seg->list_type, entry, s);
if (seg->list_type == LIST_TYPE_M3U8 && is_last)
avio_printf(seg->list_pb, "#EXT-X-ENDLIST\n");
} else {
segment_list_print_entry(seg->list_pb, seg->list_type, &seg->cur_entry, s);
}
avio_flush(seg->list_pb);
}
av_log(s, AV_LOG_VERBOSE, "segment:'%s' count:%d ended\n",
seg->avf->filename, seg->segment_count);
seg->segment_count++;
end:
avio_close(oc->pb);
return ret;
}
| false | FFmpeg | fa6716c66d31385a0f306c2a3f46f44e0d928ff9 | static int segment_end(AVFormatContext *s, int write_trailer, int is_last)
{
SegmentContext *seg = s->priv_data;
AVFormatContext *oc = seg->avf;
int ret = 0;
av_write_frame(oc, NULL);
if (write_trailer)
ret = av_write_trailer(oc);
if (ret < 0)
av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n",
oc->filename);
if (seg->list) {
if (seg->list_size || seg->list_type == LIST_TYPE_M3U8) {
SegmentListEntry *entry = av_mallocz(sizeof(*entry));
if (!entry) {
ret = AVERROR(ENOMEM);
goto end;
}
memcpy(entry, &seg->cur_entry, sizeof(*entry));
if (!seg->segment_list_entries)
seg->segment_list_entries = seg->segment_list_entries_end = entry;
else
seg->segment_list_entries_end->next = entry;
seg->segment_list_entries_end = entry;
if (seg->list_size && seg->segment_count > seg->list_size) {
entry = seg->segment_list_entries;
seg->segment_list_entries = seg->segment_list_entries->next;
av_free(entry->filename);
av_freep(&entry);
}
avio_close(seg->list_pb);
if ((ret = segment_list_open(s)) < 0)
goto end;
for (entry = seg->segment_list_entries; entry; entry = entry->next)
segment_list_print_entry(seg->list_pb, seg->list_type, entry, s);
if (seg->list_type == LIST_TYPE_M3U8 && is_last)
avio_printf(seg->list_pb, "#EXT-X-ENDLIST\n");
} else {
segment_list_print_entry(seg->list_pb, seg->list_type, &seg->cur_entry, s);
}
avio_flush(seg->list_pb);
}
av_log(s, AV_LOG_VERBOSE, "segment:'%s' count:%d ended\n",
seg->avf->filename, seg->segment_count);
seg->segment_count++;
end:
avio_close(oc->pb);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, int VAR_1, int VAR_2)
{
SegmentContext *seg = VAR_0->priv_data;
AVFormatContext *oc = seg->avf;
int VAR_3 = 0;
av_write_frame(oc, NULL);
if (VAR_1)
VAR_3 = av_write_trailer(oc);
if (VAR_3 < 0)
av_log(VAR_0, AV_LOG_ERROR, "Failure occurred when ending segment '%VAR_0'\n",
oc->filename);
if (seg->list) {
if (seg->list_size || seg->list_type == LIST_TYPE_M3U8) {
SegmentListEntry *entry = av_mallocz(sizeof(*entry));
if (!entry) {
VAR_3 = AVERROR(ENOMEM);
goto end;
}
memcpy(entry, &seg->cur_entry, sizeof(*entry));
if (!seg->segment_list_entries)
seg->segment_list_entries = seg->segment_list_entries_end = entry;
else
seg->segment_list_entries_end->next = entry;
seg->segment_list_entries_end = entry;
if (seg->list_size && seg->segment_count > seg->list_size) {
entry = seg->segment_list_entries;
seg->segment_list_entries = seg->segment_list_entries->next;
av_free(entry->filename);
av_freep(&entry);
}
avio_close(seg->list_pb);
if ((VAR_3 = segment_list_open(VAR_0)) < 0)
goto end;
for (entry = seg->segment_list_entries; entry; entry = entry->next)
segment_list_print_entry(seg->list_pb, seg->list_type, entry, VAR_0);
if (seg->list_type == LIST_TYPE_M3U8 && VAR_2)
avio_printf(seg->list_pb, "#EXT-X-ENDLIST\n");
} else {
segment_list_print_entry(seg->list_pb, seg->list_type, &seg->cur_entry, VAR_0);
}
avio_flush(seg->list_pb);
}
av_log(VAR_0, AV_LOG_VERBOSE, "segment:'%VAR_0' count:%d ended\n",
seg->avf->filename, seg->segment_count);
seg->segment_count++;
end:
avio_close(oc->pb);
return VAR_3;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, int VAR_1, int VAR_2)\n{",
"SegmentContext *seg = VAR_0->priv_data;",
"AVFormatContext *oc = seg->avf;",
"int VAR_3 = 0;",
"av_write_frame(oc, NULL);",
"if (VAR_1)\nVAR_3 = av_write_trailer(oc);",
"if (VAR_3 < 0)\nav_log(VAR_0, AV_LOG_ERROR, \"Failure occurred when ending segment '%VAR_0'\\n\",\noc->filename);",
"if (seg->list) {",
"if (seg->list_size || seg->list_type == LIST_TYPE_M3U8) {",
"SegmentListEntry *entry = av_mallocz(sizeof(*entry));",
"if (!entry) {",
"VAR_3 = AVERROR(ENOMEM);",
"goto end;",
"}",
"memcpy(entry, &seg->cur_entry, sizeof(*entry));",
"if (!seg->segment_list_entries)\nseg->segment_list_entries = seg->segment_list_entries_end = entry;",
"else\nseg->segment_list_entries_end->next = entry;",
"seg->segment_list_entries_end = entry;",
"if (seg->list_size && seg->segment_count > seg->list_size) {",
"entry = seg->segment_list_entries;",
"seg->segment_list_entries = seg->segment_list_entries->next;",
"av_free(entry->filename);",
"av_freep(&entry);",
"}",
"avio_close(seg->list_pb);",
"if ((VAR_3 = segment_list_open(VAR_0)) < 0)\ngoto end;",
"for (entry = seg->segment_list_entries; entry; entry = entry->next)",
"segment_list_print_entry(seg->list_pb, seg->list_type, entry, VAR_0);",
"if (seg->list_type == LIST_TYPE_M3U8 && VAR_2)\navio_printf(seg->list_pb, \"#EXT-X-ENDLIST\\n\");",
"} else {",
"segment_list_print_entry(seg->list_pb, seg->list_type, &seg->cur_entry, VAR_0);",
"}",
"avio_flush(seg->list_pb);",
"}",
"av_log(VAR_0, AV_LOG_VERBOSE, \"segment:'%VAR_0' count:%d ended\\n\",\nseg->avf->filename, seg->segment_count);",
"seg->segment_count++;",
"end:\navio_close(oc->pb);",
"return VAR_3;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
21,
23,
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
47
],
[
49,
51
],
[
53,
55
],
[
57
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103,
105
],
[
107
],
[
111,
113
],
[
117
],
[
119
]
] |
23,913 | static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
{
char layout_name[256];
AVCodecContext *enc = ost->st->codec;
AVCodecContext *dec = ist->st->codec;
if (dec->channel_layout &&
av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
av_get_channel_layout_string(layout_name, sizeof(layout_name),
dec->channels, dec->channel_layout);
av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
layout_name);
dec->channel_layout = 0;
}
if (!dec->channel_layout) {
if (enc->channel_layout && dec->channels == enc->channels) {
dec->channel_layout = enc->channel_layout;
} else {
dec->channel_layout = av_get_default_channel_layout(dec->channels);
if (!dec->channel_layout) {
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
"layout for Input Stream #%d.%d\n", ist->file_index,
ist->st->index);
exit_program(1);
}
}
av_get_channel_layout_string(layout_name, sizeof(layout_name),
dec->channels, dec->channel_layout);
av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
"#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
}
if (!enc->channel_layout) {
if (dec->channels == enc->channels) {
enc->channel_layout = dec->channel_layout;
return;
} else {
enc->channel_layout = av_get_default_channel_layout(enc->channels);
}
if (!enc->channel_layout) {
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
"for Output Stream #%d.%d\n", ost->file_index,
ost->st->index);
exit_program(1);
}
av_get_channel_layout_string(layout_name, sizeof(layout_name),
enc->channels, enc->channel_layout);
av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
"#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
}
}
| true | FFmpeg | 369cb092ecbbaff20bb0a2a1d60536c3bc04a8f0 | static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
{
char layout_name[256];
AVCodecContext *enc = ost->st->codec;
AVCodecContext *dec = ist->st->codec;
if (dec->channel_layout &&
av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
av_get_channel_layout_string(layout_name, sizeof(layout_name),
dec->channels, dec->channel_layout);
av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
layout_name);
dec->channel_layout = 0;
}
if (!dec->channel_layout) {
if (enc->channel_layout && dec->channels == enc->channels) {
dec->channel_layout = enc->channel_layout;
} else {
dec->channel_layout = av_get_default_channel_layout(dec->channels);
if (!dec->channel_layout) {
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
"layout for Input Stream #%d.%d\n", ist->file_index,
ist->st->index);
exit_program(1);
}
}
av_get_channel_layout_string(layout_name, sizeof(layout_name),
dec->channels, dec->channel_layout);
av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
"#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
}
if (!enc->channel_layout) {
if (dec->channels == enc->channels) {
enc->channel_layout = dec->channel_layout;
return;
} else {
enc->channel_layout = av_get_default_channel_layout(enc->channels);
}
if (!enc->channel_layout) {
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
"for Output Stream #%d.%d\n", ost->file_index,
ost->st->index);
exit_program(1);
}
av_get_channel_layout_string(layout_name, sizeof(layout_name),
enc->channels, enc->channel_layout);
av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
"#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
}
}
| {
"code": [
" exit_program(1);",
"static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)",
" char layout_name[256];",
" AVCodecContext *enc = ost->st->codec;",
" AVCodecContext *dec = ist->st->codec;",
" if (dec->channel_layout &&",
" av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {",
" av_get_channel_layout_string(layout_name, sizeof(layout_name),",
" dec->channels, dec->channel_layout);",
" av_log(NULL, AV_LOG_ERROR, \"New channel layout (%s) is invalid\\n\",",
" layout_name);",
" dec->channel_layout = 0;",
" if (!dec->channel_layout) {",
" if (enc->channel_layout && dec->channels == enc->channels) {",
" dec->channel_layout = enc->channel_layout;",
" } else {",
" dec->channel_layout = av_get_default_channel_layout(dec->channels);",
" if (!dec->channel_layout) {",
" av_log(NULL, AV_LOG_FATAL, \"Unable to find default channel \"",
" \"layout for Input Stream #%d.%d\\n\", ist->file_index,",
" ist->st->index);",
" exit_program(1);",
" av_get_channel_layout_string(layout_name, sizeof(layout_name),",
" dec->channels, dec->channel_layout);",
" av_log(NULL, AV_LOG_WARNING, \"Guessed Channel Layout for Input Stream \"",
" \"#%d.%d : %s\\n\", ist->file_index, ist->st->index, layout_name);",
" if (!enc->channel_layout) {",
" if (dec->channels == enc->channels) {",
" enc->channel_layout = dec->channel_layout;",
" } else {",
" enc->channel_layout = av_get_default_channel_layout(enc->channels);",
" if (!enc->channel_layout) {",
" av_log(NULL, AV_LOG_FATAL, \"Unable to find default channel layout \"",
" \"for Output Stream #%d.%d\\n\", ost->file_index,",
" ost->st->index);",
" exit_program(1);",
" av_get_channel_layout_string(layout_name, sizeof(layout_name),",
" enc->channels, enc->channel_layout);",
" av_log(NULL, AV_LOG_WARNING, \"Guessed Channel Layout for Output Stream \"",
" \"#%d.%d : %s\\n\", ost->file_index, ost->st->index, layout_name);",
" exit_program(1);",
" exit_program(1);",
" AVCodecContext *enc = ost->st->codec;",
" AVCodecContext *dec = ist->st->codec;",
" exit_program(1);",
" exit_program(1);"
],
"line_no": [
87,
1,
5,
7,
9,
13,
15,
17,
19,
21,
23,
25,
29,
31,
33,
35,
37,
41,
43,
45,
47,
49,
17,
19,
59,
61,
65,
67,
69,
35,
75,
79,
81,
83,
85,
87,
17,
93,
95,
97,
49,
87,
7,
9,
49,
87
]
} | static void FUNC_0(OutputStream *VAR_0, InputStream *VAR_1)
{
char VAR_2[256];
AVCodecContext *enc = VAR_0->st->codec;
AVCodecContext *dec = VAR_1->st->codec;
if (dec->channel_layout &&
av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
av_get_channel_layout_string(VAR_2, sizeof(VAR_2),
dec->channels, dec->channel_layout);
av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
VAR_2);
dec->channel_layout = 0;
}
if (!dec->channel_layout) {
if (enc->channel_layout && dec->channels == enc->channels) {
dec->channel_layout = enc->channel_layout;
} else {
dec->channel_layout = av_get_default_channel_layout(dec->channels);
if (!dec->channel_layout) {
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
"layout for Input Stream #%d.%d\n", VAR_1->file_index,
VAR_1->st->index);
exit_program(1);
}
}
av_get_channel_layout_string(VAR_2, sizeof(VAR_2),
dec->channels, dec->channel_layout);
av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
"#%d.%d : %s\n", VAR_1->file_index, VAR_1->st->index, VAR_2);
}
if (!enc->channel_layout) {
if (dec->channels == enc->channels) {
enc->channel_layout = dec->channel_layout;
return;
} else {
enc->channel_layout = av_get_default_channel_layout(enc->channels);
}
if (!enc->channel_layout) {
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
"for Output Stream #%d.%d\n", VAR_0->file_index,
VAR_0->st->index);
exit_program(1);
}
av_get_channel_layout_string(VAR_2, sizeof(VAR_2),
enc->channels, enc->channel_layout);
av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
"#%d.%d : %s\n", VAR_0->file_index, VAR_0->st->index, VAR_2);
}
}
| [
"static void FUNC_0(OutputStream *VAR_0, InputStream *VAR_1)\n{",
"char VAR_2[256];",
"AVCodecContext *enc = VAR_0->st->codec;",
"AVCodecContext *dec = VAR_1->st->codec;",
"if (dec->channel_layout &&\nav_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {",
"av_get_channel_layout_string(VAR_2, sizeof(VAR_2),\ndec->channels, dec->channel_layout);",
"av_log(NULL, AV_LOG_ERROR, \"New channel layout (%s) is invalid\\n\",\nVAR_2);",
"dec->channel_layout = 0;",
"}",
"if (!dec->channel_layout) {",
"if (enc->channel_layout && dec->channels == enc->channels) {",
"dec->channel_layout = enc->channel_layout;",
"} else {",
"dec->channel_layout = av_get_default_channel_layout(dec->channels);",
"if (!dec->channel_layout) {",
"av_log(NULL, AV_LOG_FATAL, \"Unable to find default channel \"\n\"layout for Input Stream #%d.%d\\n\", VAR_1->file_index,\nVAR_1->st->index);",
"exit_program(1);",
"}",
"}",
"av_get_channel_layout_string(VAR_2, sizeof(VAR_2),\ndec->channels, dec->channel_layout);",
"av_log(NULL, AV_LOG_WARNING, \"Guessed Channel Layout for Input Stream \"\n\"#%d.%d : %s\\n\", VAR_1->file_index, VAR_1->st->index, VAR_2);",
"}",
"if (!enc->channel_layout) {",
"if (dec->channels == enc->channels) {",
"enc->channel_layout = dec->channel_layout;",
"return;",
"} else {",
"enc->channel_layout = av_get_default_channel_layout(enc->channels);",
"}",
"if (!enc->channel_layout) {",
"av_log(NULL, AV_LOG_FATAL, \"Unable to find default channel layout \"\n\"for Output Stream #%d.%d\\n\", VAR_0->file_index,\nVAR_0->st->index);",
"exit_program(1);",
"}",
"av_get_channel_layout_string(VAR_2, sizeof(VAR_2),\nenc->channels, enc->channel_layout);",
"av_log(NULL, AV_LOG_WARNING, \"Guessed Channel Layout for Output Stream \"\n\"#%d.%d : %s\\n\", VAR_0->file_index, VAR_0->st->index, VAR_2);",
"}",
"}"
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
0,
1,
1,
1,
1,
0,
0,
0,
1,
0,
1,
1,
1,
0,
0,
1,
0,
1,
1,
1,
0,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13,
15
],
[
17,
19
],
[
21,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43,
45,
47
],
[
49
],
[
51
],
[
53
],
[
55,
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81,
83,
85
],
[
87
],
[
89
],
[
91,
93
],
[
95,
97
],
[
99
],
[
101
]
] |
23,914 | int cache_insert(PageCache *cache, uint64_t addr, const uint8_t *pdata)
{
CacheItem *it = NULL;
g_assert(cache);
g_assert(cache->page_cache);
/* actual update of entry */
it = cache_get_by_addr(cache, addr);
/* allocate page */
if (!it->it_data) {
it->it_data = g_try_malloc(cache->page_size);
if (!it->it_data) {
DPRINTF("Error allocating page\n");
return -1;
}
cache->num_items++;
}
memcpy(it->it_data, pdata, cache->page_size);
it->it_age = ++cache->max_item_age;
it->it_addr = addr;
return 0;
}
| true | qemu | 27af7d6ea5015e5ef1f7985eab94a8a218267a2b | int cache_insert(PageCache *cache, uint64_t addr, const uint8_t *pdata)
{
CacheItem *it = NULL;
g_assert(cache);
g_assert(cache->page_cache);
it = cache_get_by_addr(cache, addr);
if (!it->it_data) {
it->it_data = g_try_malloc(cache->page_size);
if (!it->it_data) {
DPRINTF("Error allocating page\n");
return -1;
}
cache->num_items++;
}
memcpy(it->it_data, pdata, cache->page_size);
it->it_age = ++cache->max_item_age;
it->it_addr = addr;
return 0;
}
| {
"code": [
"int cache_insert(PageCache *cache, uint64_t addr, const uint8_t *pdata)",
" it->it_age = ++cache->max_item_age;"
],
"line_no": [
1,
47
]
} | int FUNC_0(PageCache *VAR_0, uint64_t VAR_1, const uint8_t *VAR_2)
{
CacheItem *it = NULL;
g_assert(VAR_0);
g_assert(VAR_0->page_cache);
it = cache_get_by_addr(VAR_0, VAR_1);
if (!it->it_data) {
it->it_data = g_try_malloc(VAR_0->page_size);
if (!it->it_data) {
DPRINTF("Error allocating page\n");
return -1;
}
VAR_0->num_items++;
}
memcpy(it->it_data, VAR_2, VAR_0->page_size);
it->it_age = ++VAR_0->max_item_age;
it->it_addr = VAR_1;
return 0;
}
| [
"int FUNC_0(PageCache *VAR_0, uint64_t VAR_1, const uint8_t *VAR_2)\n{",
"CacheItem *it = NULL;",
"g_assert(VAR_0);",
"g_assert(VAR_0->page_cache);",
"it = cache_get_by_addr(VAR_0, VAR_1);",
"if (!it->it_data) {",
"it->it_data = g_try_malloc(VAR_0->page_size);",
"if (!it->it_data) {",
"DPRINTF(\"Error allocating page\\n\");",
"return -1;",
"}",
"VAR_0->num_items++;",
"}",
"memcpy(it->it_data, VAR_2, VAR_0->page_size);",
"it->it_age = ++VAR_0->max_item_age;",
"it->it_addr = VAR_1;",
"return 0;",
"}"
] | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3
],
[
7
],
[
11
],
[
13
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
47
],
[
49
],
[
53
],
[
55
]
] |
23,915 | static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
{
#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
switch (sps->pix_fmt) {
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUVJ420P:
#if CONFIG_HEVC_DXVA2_HWACCEL
*fmt++ = AV_PIX_FMT_DXVA2_VLD;
#endif
#if CONFIG_HEVC_D3D11VA_HWACCEL
*fmt++ = AV_PIX_FMT_D3D11VA_VLD;
#endif
#if CONFIG_HEVC_VAAPI_HWACCEL
*fmt++ = AV_PIX_FMT_VAAPI;
#endif
#if CONFIG_HEVC_VDPAU_HWACCEL
*fmt++ = AV_PIX_FMT_VDPAU;
#endif
break;
case AV_PIX_FMT_YUV420P10:
#if CONFIG_HEVC_DXVA2_HWACCEL
*fmt++ = AV_PIX_FMT_DXVA2_VLD;
#endif
#if CONFIG_HEVC_D3D11VA_HWACCEL
*fmt++ = AV_PIX_FMT_D3D11VA_VLD;
#endif
#if CONFIG_HEVC_VAAPI_HWACCEL
*fmt++ = AV_PIX_FMT_VAAPI;
#endif
break;
}
*fmt++ = sps->pix_fmt;
*fmt = AV_PIX_FMT_NONE;
return ff_get_format(s->avctx, pix_fmts);
}
| true | FFmpeg | 78a5fc4579deb63e1e6b93cd4d6e2ec2dceff931 | static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
{
#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
switch (sps->pix_fmt) {
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUVJ420P:
#if CONFIG_HEVC_DXVA2_HWACCEL
*fmt++ = AV_PIX_FMT_DXVA2_VLD;
#endif
#if CONFIG_HEVC_D3D11VA_HWACCEL
*fmt++ = AV_PIX_FMT_D3D11VA_VLD;
#endif
#if CONFIG_HEVC_VAAPI_HWACCEL
*fmt++ = AV_PIX_FMT_VAAPI;
#endif
#if CONFIG_HEVC_VDPAU_HWACCEL
*fmt++ = AV_PIX_FMT_VDPAU;
#endif
break;
case AV_PIX_FMT_YUV420P10:
#if CONFIG_HEVC_DXVA2_HWACCEL
*fmt++ = AV_PIX_FMT_DXVA2_VLD;
#endif
#if CONFIG_HEVC_D3D11VA_HWACCEL
*fmt++ = AV_PIX_FMT_D3D11VA_VLD;
#endif
#if CONFIG_HEVC_VAAPI_HWACCEL
*fmt++ = AV_PIX_FMT_VAAPI;
#endif
break;
}
*fmt++ = sps->pix_fmt;
*fmt = AV_PIX_FMT_NONE;
return ff_get_format(s->avctx, pix_fmts);
}
| {
"code": [
" return ff_get_format(s->avctx, pix_fmts);"
],
"line_no": [
75
]
} | static enum AVPixelFormat FUNC_0(HEVCContext *VAR_0, const HEVCSPS *VAR_1)
{
#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
enum AVPixelFormat VAR_2[HWACCEL_MAX + 2], *fmt = VAR_2;
switch (VAR_1->pix_fmt) {
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUVJ420P:
#if CONFIG_HEVC_DXVA2_HWACCEL
*fmt++ = AV_PIX_FMT_DXVA2_VLD;
#endif
#if CONFIG_HEVC_D3D11VA_HWACCEL
*fmt++ = AV_PIX_FMT_D3D11VA_VLD;
#endif
#if CONFIG_HEVC_VAAPI_HWACCEL
*fmt++ = AV_PIX_FMT_VAAPI;
#endif
#if CONFIG_HEVC_VDPAU_HWACCEL
*fmt++ = AV_PIX_FMT_VDPAU;
#endif
break;
case AV_PIX_FMT_YUV420P10:
#if CONFIG_HEVC_DXVA2_HWACCEL
*fmt++ = AV_PIX_FMT_DXVA2_VLD;
#endif
#if CONFIG_HEVC_D3D11VA_HWACCEL
*fmt++ = AV_PIX_FMT_D3D11VA_VLD;
#endif
#if CONFIG_HEVC_VAAPI_HWACCEL
*fmt++ = AV_PIX_FMT_VAAPI;
#endif
break;
}
*fmt++ = VAR_1->pix_fmt;
*fmt = AV_PIX_FMT_NONE;
return ff_get_format(VAR_0->avctx, VAR_2);
}
| [
"static enum AVPixelFormat FUNC_0(HEVCContext *VAR_0, const HEVCSPS *VAR_1)\n{",
"#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)\nenum AVPixelFormat VAR_2[HWACCEL_MAX + 2], *fmt = VAR_2;",
"switch (VAR_1->pix_fmt) {",
"case AV_PIX_FMT_YUV420P:\ncase AV_PIX_FMT_YUVJ420P:\n#if CONFIG_HEVC_DXVA2_HWACCEL\n*fmt++ = AV_PIX_FMT_DXVA2_VLD;",
"#endif\n#if CONFIG_HEVC_D3D11VA_HWACCEL\n*fmt++ = AV_PIX_FMT_D3D11VA_VLD;",
"#endif\n#if CONFIG_HEVC_VAAPI_HWACCEL\n*fmt++ = AV_PIX_FMT_VAAPI;",
"#endif\n#if CONFIG_HEVC_VDPAU_HWACCEL\n*fmt++ = AV_PIX_FMT_VDPAU;",
"#endif\nbreak;",
"case AV_PIX_FMT_YUV420P10:\n#if CONFIG_HEVC_DXVA2_HWACCEL\n*fmt++ = AV_PIX_FMT_DXVA2_VLD;",
"#endif\n#if CONFIG_HEVC_D3D11VA_HWACCEL\n*fmt++ = AV_PIX_FMT_D3D11VA_VLD;",
"#endif\n#if CONFIG_HEVC_VAAPI_HWACCEL\n*fmt++ = AV_PIX_FMT_VAAPI;",
"#endif\nbreak;",
"}",
"*fmt++ = VAR_1->pix_fmt;",
"*fmt = AV_PIX_FMT_NONE;",
"return ff_get_format(VAR_0->avctx, VAR_2);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0
] | [
[
1,
3
],
[
5,
7
],
[
11
],
[
13,
15,
17,
19
],
[
21,
23,
25
],
[
27,
29,
31
],
[
33,
35,
37
],
[
39,
41
],
[
43,
45,
47
],
[
49,
51,
53
],
[
55,
57,
59
],
[
61,
63
],
[
65
],
[
69
],
[
71
],
[
75
],
[
77
]
] |
23,917 | static int sd_open(BlockDriverState *bs, const char *filename, int flags)
{
int ret, fd;
uint32_t vid = 0;
BDRVSheepdogState *s = bs->opaque;
char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
uint32_t snapid;
char *buf = NULL;
strstart(filename, "sheepdog:", (const char **)&filename);
QLIST_INIT(&s->inflight_aio_head);
QLIST_INIT(&s->pending_aio_head);
s->fd = -1;
memset(vdi, 0, sizeof(vdi));
memset(tag, 0, sizeof(tag));
if (parse_vdiname(s, filename, vdi, &snapid, tag) < 0) {
ret = -EINVAL;
goto out;
}
s->fd = get_sheep_fd(s);
if (s->fd < 0) {
ret = s->fd;
goto out;
}
ret = find_vdi_name(s, vdi, snapid, tag, &vid, 0);
if (ret) {
goto out;
}
s->cache_enabled = 1;
s->flush_fd = connect_to_sdog(s->addr, s->port);
if (s->flush_fd < 0) {
error_report("failed to connect");
ret = s->flush_fd;
goto out;
}
if (snapid || tag[0] != '\0') {
dprintf("%" PRIx32 " snapshot inode was open.\n", vid);
s->is_snapshot = 1;
}
fd = connect_to_sdog(s->addr, s->port);
if (fd < 0) {
error_report("failed to connect");
ret = fd;
goto out;
}
buf = g_malloc(SD_INODE_SIZE);
ret = read_object(fd, buf, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,
s->cache_enabled);
closesocket(fd);
if (ret) {
goto out;
}
memcpy(&s->inode, buf, sizeof(s->inode));
s->min_dirty_data_idx = UINT32_MAX;
s->max_dirty_data_idx = 0;
bs->total_sectors = s->inode.vdi_size / SECTOR_SIZE;
strncpy(s->name, vdi, sizeof(s->name));
qemu_co_mutex_init(&s->lock);
g_free(buf);
return 0;
out:
qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL);
if (s->fd >= 0) {
closesocket(s->fd);
}
g_free(buf);
return ret;
}
| true | qemu | 3178e2755ec5a7fb1afe583fb6ac2622c2c42184 | static int sd_open(BlockDriverState *bs, const char *filename, int flags)
{
int ret, fd;
uint32_t vid = 0;
BDRVSheepdogState *s = bs->opaque;
char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
uint32_t snapid;
char *buf = NULL;
strstart(filename, "sheepdog:", (const char **)&filename);
QLIST_INIT(&s->inflight_aio_head);
QLIST_INIT(&s->pending_aio_head);
s->fd = -1;
memset(vdi, 0, sizeof(vdi));
memset(tag, 0, sizeof(tag));
if (parse_vdiname(s, filename, vdi, &snapid, tag) < 0) {
ret = -EINVAL;
goto out;
}
s->fd = get_sheep_fd(s);
if (s->fd < 0) {
ret = s->fd;
goto out;
}
ret = find_vdi_name(s, vdi, snapid, tag, &vid, 0);
if (ret) {
goto out;
}
s->cache_enabled = 1;
s->flush_fd = connect_to_sdog(s->addr, s->port);
if (s->flush_fd < 0) {
error_report("failed to connect");
ret = s->flush_fd;
goto out;
}
if (snapid || tag[0] != '\0') {
dprintf("%" PRIx32 " snapshot inode was open.\n", vid);
s->is_snapshot = 1;
}
fd = connect_to_sdog(s->addr, s->port);
if (fd < 0) {
error_report("failed to connect");
ret = fd;
goto out;
}
buf = g_malloc(SD_INODE_SIZE);
ret = read_object(fd, buf, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,
s->cache_enabled);
closesocket(fd);
if (ret) {
goto out;
}
memcpy(&s->inode, buf, sizeof(s->inode));
s->min_dirty_data_idx = UINT32_MAX;
s->max_dirty_data_idx = 0;
bs->total_sectors = s->inode.vdi_size / SECTOR_SIZE;
strncpy(s->name, vdi, sizeof(s->name));
qemu_co_mutex_init(&s->lock);
g_free(buf);
return 0;
out:
qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL);
if (s->fd >= 0) {
closesocket(s->fd);
}
g_free(buf);
return ret;
}
| {
"code": [
" strncpy(s->name, vdi, sizeof(s->name));",
" memset(vdi, 0, sizeof(vdi));",
" memset(tag, 0, sizeof(tag));"
],
"line_no": [
135,
31,
33
]
} | static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1, int VAR_2)
{
int VAR_3, VAR_4;
uint32_t vid = 0;
BDRVSheepdogState *s = VAR_0->opaque;
char VAR_5[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
uint32_t snapid;
char *VAR_6 = NULL;
strstart(VAR_1, "sheepdog:", (const char **)&VAR_1);
QLIST_INIT(&s->inflight_aio_head);
QLIST_INIT(&s->pending_aio_head);
s->VAR_4 = -1;
memset(VAR_5, 0, sizeof(VAR_5));
memset(tag, 0, sizeof(tag));
if (parse_vdiname(s, VAR_1, VAR_5, &snapid, tag) < 0) {
VAR_3 = -EINVAL;
goto out;
}
s->VAR_4 = get_sheep_fd(s);
if (s->VAR_4 < 0) {
VAR_3 = s->VAR_4;
goto out;
}
VAR_3 = find_vdi_name(s, VAR_5, snapid, tag, &vid, 0);
if (VAR_3) {
goto out;
}
s->cache_enabled = 1;
s->flush_fd = connect_to_sdog(s->addr, s->port);
if (s->flush_fd < 0) {
error_report("failed to connect");
VAR_3 = s->flush_fd;
goto out;
}
if (snapid || tag[0] != '\0') {
dprintf("%" PRIx32 " snapshot inode was open.\n", vid);
s->is_snapshot = 1;
}
VAR_4 = connect_to_sdog(s->addr, s->port);
if (VAR_4 < 0) {
error_report("failed to connect");
VAR_3 = VAR_4;
goto out;
}
VAR_6 = g_malloc(SD_INODE_SIZE);
VAR_3 = read_object(VAR_4, VAR_6, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,
s->cache_enabled);
closesocket(VAR_4);
if (VAR_3) {
goto out;
}
memcpy(&s->inode, VAR_6, sizeof(s->inode));
s->min_dirty_data_idx = UINT32_MAX;
s->max_dirty_data_idx = 0;
VAR_0->total_sectors = s->inode.vdi_size / SECTOR_SIZE;
strncpy(s->name, VAR_5, sizeof(s->name));
qemu_co_mutex_init(&s->lock);
g_free(VAR_6);
return 0;
out:
qemu_aio_set_fd_handler(s->VAR_4, NULL, NULL, NULL, NULL);
if (s->VAR_4 >= 0) {
closesocket(s->VAR_4);
}
g_free(VAR_6);
return VAR_3;
}
| [
"static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1, int VAR_2)\n{",
"int VAR_3, VAR_4;",
"uint32_t vid = 0;",
"BDRVSheepdogState *s = VAR_0->opaque;",
"char VAR_5[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];",
"uint32_t snapid;",
"char *VAR_6 = NULL;",
"strstart(VAR_1, \"sheepdog:\", (const char **)&VAR_1);",
"QLIST_INIT(&s->inflight_aio_head);",
"QLIST_INIT(&s->pending_aio_head);",
"s->VAR_4 = -1;",
"memset(VAR_5, 0, sizeof(VAR_5));",
"memset(tag, 0, sizeof(tag));",
"if (parse_vdiname(s, VAR_1, VAR_5, &snapid, tag) < 0) {",
"VAR_3 = -EINVAL;",
"goto out;",
"}",
"s->VAR_4 = get_sheep_fd(s);",
"if (s->VAR_4 < 0) {",
"VAR_3 = s->VAR_4;",
"goto out;",
"}",
"VAR_3 = find_vdi_name(s, VAR_5, snapid, tag, &vid, 0);",
"if (VAR_3) {",
"goto out;",
"}",
"s->cache_enabled = 1;",
"s->flush_fd = connect_to_sdog(s->addr, s->port);",
"if (s->flush_fd < 0) {",
"error_report(\"failed to connect\");",
"VAR_3 = s->flush_fd;",
"goto out;",
"}",
"if (snapid || tag[0] != '\\0') {",
"dprintf(\"%\" PRIx32 \" snapshot inode was open.\\n\", vid);",
"s->is_snapshot = 1;",
"}",
"VAR_4 = connect_to_sdog(s->addr, s->port);",
"if (VAR_4 < 0) {",
"error_report(\"failed to connect\");",
"VAR_3 = VAR_4;",
"goto out;",
"}",
"VAR_6 = g_malloc(SD_INODE_SIZE);",
"VAR_3 = read_object(VAR_4, VAR_6, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,\ns->cache_enabled);",
"closesocket(VAR_4);",
"if (VAR_3) {",
"goto out;",
"}",
"memcpy(&s->inode, VAR_6, sizeof(s->inode));",
"s->min_dirty_data_idx = UINT32_MAX;",
"s->max_dirty_data_idx = 0;",
"VAR_0->total_sectors = s->inode.vdi_size / SECTOR_SIZE;",
"strncpy(s->name, VAR_5, sizeof(s->name));",
"qemu_co_mutex_init(&s->lock);",
"g_free(VAR_6);",
"return 0;",
"out:\nqemu_aio_set_fd_handler(s->VAR_4, NULL, NULL, NULL, NULL);",
"if (s->VAR_4 >= 0) {",
"closesocket(s->VAR_4);",
"}",
"g_free(VAR_6);",
"return VAR_3;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107,
109
],
[
113
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143,
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
]
] |
23,919 | static void qvirtio_9p_pci_stop(QVirtIO9P *v9p)
{
qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
g_free(v9p->dev);
qvirtio_9p_stop(v9p);
}
| true | qemu | 2b880bcdbeb87b9cb4e325dd6e872373458f82d9 | static void qvirtio_9p_pci_stop(QVirtIO9P *v9p)
{
qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
g_free(v9p->dev);
qvirtio_9p_stop(v9p);
}
| {
"code": [
" g_free(v9p->dev);"
],
"line_no": [
9
]
} | static void FUNC_0(QVirtIO9P *VAR_0)
{
qvirtqueue_cleanup(VAR_0->dev->bus, VAR_0->vq, VAR_0->qs->alloc);
qvirtio_pci_device_disable(container_of(VAR_0->dev, QVirtioPCIDevice, vdev));
g_free(VAR_0->dev);
qvirtio_9p_stop(VAR_0);
}
| [
"static void FUNC_0(QVirtIO9P *VAR_0)\n{",
"qvirtqueue_cleanup(VAR_0->dev->bus, VAR_0->vq, VAR_0->qs->alloc);",
"qvirtio_pci_device_disable(container_of(VAR_0->dev, QVirtioPCIDevice, vdev));",
"g_free(VAR_0->dev);",
"qvirtio_9p_stop(VAR_0);",
"}"
] | [
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
23,920 | static av_cold int pnm_encode_init(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
avctx->coded_frame->key_frame = 1;
return 0;
}
| false | FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 | static av_cold int pnm_encode_init(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
avctx->coded_frame->key_frame = 1;
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (!avctx->coded_frame)
return AVERROR(ENOMEM);
avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
avctx->coded_frame->key_frame = 1;
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"avctx->coded_frame = av_frame_alloc();",
"if (!avctx->coded_frame)\nreturn AVERROR(ENOMEM);",
"avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;",
"avctx->coded_frame->key_frame = 1;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
13
],
[
15
],
[
19
],
[
21
]
] |
23,921 | static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
int point_transform, int nb_components)
{
int i, mb_x, mb_y, mask;
int bits= (s->bits+7)&~7;
int resync_mb_y = 0;
int resync_mb_x = 0;
point_transform += bits - s->bits;
mask = ((1 << s->bits) - 1) << point_transform;
av_assert0(nb_components>=1 && nb_components<=4);
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
if (s->restart_interval && !s->restart_count){
s->restart_count = s->restart_interval;
resync_mb_x = mb_x;
resync_mb_y = mb_y;
}
if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
for (i = 0; i < nb_components; i++) {
uint8_t *ptr;
uint16_t *ptr16;
int n, h, v, x, y, c, j, linesize;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
linesize= s->linesize[c];
if(bits>8) linesize /= 2;
for(j=0; j<n; j++) {
int pred, dc;
dc = mjpeg_decode_dc(s, s->dc_index[i]);
if(dc == 0xFFFFF)
return -1;
if(bits<=8){
ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
if(y==0 && toprow){
if(x==0 && leftcol){
pred= 1 << (bits - 1);
}else{
pred= ptr[-1];
}
}else{
if(x==0 && leftcol){
pred= ptr[-linesize];
}else{
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
}
}
if (s->interlaced && s->bottom_field)
ptr += linesize >> 1;
pred &= mask;
*ptr= pred + (dc << point_transform);
}else{
ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
if(y==0 && toprow){
if(x==0 && leftcol){
pred= 1 << (bits - 1);
}else{
pred= ptr16[-1];
}
}else{
if(x==0 && leftcol){
pred= ptr16[-linesize];
}else{
PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
}
}
if (s->interlaced && s->bottom_field)
ptr16 += linesize >> 1;
pred &= mask;
*ptr16= pred + (dc << point_transform);
}
if (++x == h) {
x = 0;
y++;
}
}
}
} else {
for (i = 0; i < nb_components; i++) {
uint8_t *ptr;
uint16_t *ptr16;
int n, h, v, x, y, c, j, linesize, dc;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
linesize = s->linesize[c];
if(bits>8) linesize /= 2;
for (j = 0; j < n; j++) {
int pred;
dc = mjpeg_decode_dc(s, s->dc_index[i]);
if(dc == 0xFFFFF)
return -1;
if(bits<=8){
ptr = s->picture_ptr->data[c] +
(linesize * (v * mb_y + y)) +
(h * mb_x + x); //FIXME optimize this crap
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
pred &= mask;
*ptr = pred + (dc << point_transform);
}else{
ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
pred &= mask;
*ptr16= pred + (dc << point_transform);
}
if (++x == h) {
x = 0;
y++;
}
}
}
}
if (s->restart_interval && !--s->restart_count) {
align_get_bits(&s->gb);
skip_bits(&s->gb, 16); /* skip RSTn */
}
}
}
return 0;
}
| false | FFmpeg | d24888ef19ba38b787b11d1ee091a3d94920c76a | static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
int point_transform, int nb_components)
{
int i, mb_x, mb_y, mask;
int bits= (s->bits+7)&~7;
int resync_mb_y = 0;
int resync_mb_x = 0;
point_transform += bits - s->bits;
mask = ((1 << s->bits) - 1) << point_transform;
av_assert0(nb_components>=1 && nb_components<=4);
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
if (s->restart_interval && !s->restart_count){
s->restart_count = s->restart_interval;
resync_mb_x = mb_x;
resync_mb_y = mb_y;
}
if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
for (i = 0; i < nb_components; i++) {
uint8_t *ptr;
uint16_t *ptr16;
int n, h, v, x, y, c, j, linesize;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
linesize= s->linesize[c];
if(bits>8) linesize /= 2;
for(j=0; j<n; j++) {
int pred, dc;
dc = mjpeg_decode_dc(s, s->dc_index[i]);
if(dc == 0xFFFFF)
return -1;
if(bits<=8){
ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x);
if(y==0 && toprow){
if(x==0 && leftcol){
pred= 1 << (bits - 1);
}else{
pred= ptr[-1];
}
}else{
if(x==0 && leftcol){
pred= ptr[-linesize];
}else{
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
}
}
if (s->interlaced && s->bottom_field)
ptr += linesize >> 1;
pred &= mask;
*ptr= pred + (dc << point_transform);
}else{
ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
if(y==0 && toprow){
if(x==0 && leftcol){
pred= 1 << (bits - 1);
}else{
pred= ptr16[-1];
}
}else{
if(x==0 && leftcol){
pred= ptr16[-linesize];
}else{
PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
}
}
if (s->interlaced && s->bottom_field)
ptr16 += linesize >> 1;
pred &= mask;
*ptr16= pred + (dc << point_transform);
}
if (++x == h) {
x = 0;
y++;
}
}
}
} else {
for (i = 0; i < nb_components; i++) {
uint8_t *ptr;
uint16_t *ptr16;
int n, h, v, x, y, c, j, linesize, dc;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
linesize = s->linesize[c];
if(bits>8) linesize /= 2;
for (j = 0; j < n; j++) {
int pred;
dc = mjpeg_decode_dc(s, s->dc_index[i]);
if(dc == 0xFFFFF)
return -1;
if(bits<=8){
ptr = s->picture_ptr->data[c] +
(linesize * (v * mb_y + y)) +
(h * mb_x + x);
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
pred &= mask;
*ptr = pred + (dc << point_transform);
}else{
ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
pred &= mask;
*ptr16= pred + (dc << point_transform);
}
if (++x == h) {
x = 0;
y++;
}
}
}
}
if (s->restart_interval && !--s->restart_count) {
align_get_bits(&s->gb);
skip_bits(&s->gb, 16);
}
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1,
int VAR_2, int VAR_3)
{
int VAR_4, VAR_5, VAR_6, VAR_7;
int VAR_8= (VAR_0->VAR_8+7)&~7;
int VAR_9 = 0;
int VAR_10 = 0;
VAR_2 += VAR_8 - VAR_0->VAR_8;
VAR_7 = ((1 << VAR_0->VAR_8) - 1) << VAR_2;
av_assert0(VAR_3>=1 && VAR_3<=4);
for (VAR_6 = 0; VAR_6 < VAR_0->mb_height; VAR_6++) {
for (VAR_5 = 0; VAR_5 < VAR_0->mb_width; VAR_5++) {
if (VAR_0->restart_interval && !VAR_0->restart_count){
VAR_0->restart_count = VAR_0->restart_interval;
VAR_10 = VAR_5;
VAR_9 = VAR_6;
}
if(!VAR_5 || VAR_6 == VAR_9 || VAR_6 == VAR_9+1 && VAR_5 < VAR_10 || VAR_0->interlaced){
int toprow = VAR_6 == VAR_9 || VAR_6 == VAR_9+1 && VAR_5 < VAR_10;
int leftcol = !VAR_5 || VAR_6 == VAR_9 && VAR_5 == VAR_10;
for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {
uint8_t *ptr;
uint16_t *ptr16;
int n, h, v, x, y, c, j, linesize;
n = VAR_0->nb_blocks[VAR_4];
c = VAR_0->comp_index[VAR_4];
h = VAR_0->h_scount[VAR_4];
v = VAR_0->v_scount[VAR_4];
x = 0;
y = 0;
linesize= VAR_0->linesize[c];
if(VAR_8>8) linesize /= 2;
for(j=0; j<n; j++) {
int pred, dc;
dc = mjpeg_decode_dc(VAR_0, VAR_0->dc_index[VAR_4]);
if(dc == 0xFFFFF)
return -1;
if(VAR_8<=8){
ptr = VAR_0->picture_ptr->data[c] + (linesize * (v * VAR_6 + y)) + (h * VAR_5 + x);
if(y==0 && toprow){
if(x==0 && leftcol){
pred= 1 << (VAR_8 - 1);
}else{
pred= ptr[-1];
}
}else{
if(x==0 && leftcol){
pred= ptr[-linesize];
}else{
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], VAR_1);
}
}
if (VAR_0->interlaced && VAR_0->bottom_field)
ptr += linesize >> 1;
pred &= VAR_7;
*ptr= pred + (dc << VAR_2);
}else{
ptr16 = (uint16_t*)(VAR_0->picture_ptr->data[c] + 2*(linesize * (v * VAR_6 + y)) + 2*(h * VAR_5 + x));
if(y==0 && toprow){
if(x==0 && leftcol){
pred= 1 << (VAR_8 - 1);
}else{
pred= ptr16[-1];
}
}else{
if(x==0 && leftcol){
pred= ptr16[-linesize];
}else{
PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], VAR_1);
}
}
if (VAR_0->interlaced && VAR_0->bottom_field)
ptr16 += linesize >> 1;
pred &= VAR_7;
*ptr16= pred + (dc << VAR_2);
}
if (++x == h) {
x = 0;
y++;
}
}
}
} else {
for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {
uint8_t *ptr;
uint16_t *ptr16;
int n, h, v, x, y, c, j, linesize, dc;
n = VAR_0->nb_blocks[VAR_4];
c = VAR_0->comp_index[VAR_4];
h = VAR_0->h_scount[VAR_4];
v = VAR_0->v_scount[VAR_4];
x = 0;
y = 0;
linesize = VAR_0->linesize[c];
if(VAR_8>8) linesize /= 2;
for (j = 0; j < n; j++) {
int pred;
dc = mjpeg_decode_dc(VAR_0, VAR_0->dc_index[VAR_4]);
if(dc == 0xFFFFF)
return -1;
if(VAR_8<=8){
ptr = VAR_0->picture_ptr->data[c] +
(linesize * (v * VAR_6 + y)) +
(h * VAR_5 + x);
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], VAR_1);
pred &= VAR_7;
*ptr = pred + (dc << VAR_2);
}else{
ptr16 = (uint16_t*)(VAR_0->picture_ptr->data[c] + 2*(linesize * (v * VAR_6 + y)) + 2*(h * VAR_5 + x));
PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], VAR_1);
pred &= VAR_7;
*ptr16= pred + (dc << VAR_2);
}
if (++x == h) {
x = 0;
y++;
}
}
}
}
if (VAR_0->restart_interval && !--VAR_0->restart_count) {
align_get_bits(&VAR_0->gb);
skip_bits(&VAR_0->gb, 16);
}
}
}
return 0;
}
| [
"static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1,\nint VAR_2, int VAR_3)\n{",
"int VAR_4, VAR_5, VAR_6, VAR_7;",
"int VAR_8= (VAR_0->VAR_8+7)&~7;",
"int VAR_9 = 0;",
"int VAR_10 = 0;",
"VAR_2 += VAR_8 - VAR_0->VAR_8;",
"VAR_7 = ((1 << VAR_0->VAR_8) - 1) << VAR_2;",
"av_assert0(VAR_3>=1 && VAR_3<=4);",
"for (VAR_6 = 0; VAR_6 < VAR_0->mb_height; VAR_6++) {",
"for (VAR_5 = 0; VAR_5 < VAR_0->mb_width; VAR_5++) {",
"if (VAR_0->restart_interval && !VAR_0->restart_count){",
"VAR_0->restart_count = VAR_0->restart_interval;",
"VAR_10 = VAR_5;",
"VAR_9 = VAR_6;",
"}",
"if(!VAR_5 || VAR_6 == VAR_9 || VAR_6 == VAR_9+1 && VAR_5 < VAR_10 || VAR_0->interlaced){",
"int toprow = VAR_6 == VAR_9 || VAR_6 == VAR_9+1 && VAR_5 < VAR_10;",
"int leftcol = !VAR_5 || VAR_6 == VAR_9 && VAR_5 == VAR_10;",
"for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {",
"uint8_t *ptr;",
"uint16_t *ptr16;",
"int n, h, v, x, y, c, j, linesize;",
"n = VAR_0->nb_blocks[VAR_4];",
"c = VAR_0->comp_index[VAR_4];",
"h = VAR_0->h_scount[VAR_4];",
"v = VAR_0->v_scount[VAR_4];",
"x = 0;",
"y = 0;",
"linesize= VAR_0->linesize[c];",
"if(VAR_8>8) linesize /= 2;",
"for(j=0; j<n; j++) {",
"int pred, dc;",
"dc = mjpeg_decode_dc(VAR_0, VAR_0->dc_index[VAR_4]);",
"if(dc == 0xFFFFF)\nreturn -1;",
"if(VAR_8<=8){",
"ptr = VAR_0->picture_ptr->data[c] + (linesize * (v * VAR_6 + y)) + (h * VAR_5 + x);",
"if(y==0 && toprow){",
"if(x==0 && leftcol){",
"pred= 1 << (VAR_8 - 1);",
"}else{",
"pred= ptr[-1];",
"}",
"}else{",
"if(x==0 && leftcol){",
"pred= ptr[-linesize];",
"}else{",
"PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], VAR_1);",
"}",
"}",
"if (VAR_0->interlaced && VAR_0->bottom_field)\nptr += linesize >> 1;",
"pred &= VAR_7;",
"*ptr= pred + (dc << VAR_2);",
"}else{",
"ptr16 = (uint16_t*)(VAR_0->picture_ptr->data[c] + 2*(linesize * (v * VAR_6 + y)) + 2*(h * VAR_5 + x));",
"if(y==0 && toprow){",
"if(x==0 && leftcol){",
"pred= 1 << (VAR_8 - 1);",
"}else{",
"pred= ptr16[-1];",
"}",
"}else{",
"if(x==0 && leftcol){",
"pred= ptr16[-linesize];",
"}else{",
"PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], VAR_1);",
"}",
"}",
"if (VAR_0->interlaced && VAR_0->bottom_field)\nptr16 += linesize >> 1;",
"pred &= VAR_7;",
"*ptr16= pred + (dc << VAR_2);",
"}",
"if (++x == h) {",
"x = 0;",
"y++;",
"}",
"}",
"}",
"} else {",
"for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {",
"uint8_t *ptr;",
"uint16_t *ptr16;",
"int n, h, v, x, y, c, j, linesize, dc;",
"n = VAR_0->nb_blocks[VAR_4];",
"c = VAR_0->comp_index[VAR_4];",
"h = VAR_0->h_scount[VAR_4];",
"v = VAR_0->v_scount[VAR_4];",
"x = 0;",
"y = 0;",
"linesize = VAR_0->linesize[c];",
"if(VAR_8>8) linesize /= 2;",
"for (j = 0; j < n; j++) {",
"int pred;",
"dc = mjpeg_decode_dc(VAR_0, VAR_0->dc_index[VAR_4]);",
"if(dc == 0xFFFFF)\nreturn -1;",
"if(VAR_8<=8){",
"ptr = VAR_0->picture_ptr->data[c] +\n(linesize * (v * VAR_6 + y)) +\n(h * VAR_5 + x);",
"PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], VAR_1);",
"pred &= VAR_7;",
"*ptr = pred + (dc << VAR_2);",
"}else{",
"ptr16 = (uint16_t*)(VAR_0->picture_ptr->data[c] + 2*(linesize * (v * VAR_6 + y)) + 2*(h * VAR_5 + x));",
"PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], VAR_1);",
"pred &= VAR_7;",
"*ptr16= pred + (dc << VAR_2);",
"}",
"if (++x == h) {",
"x = 0;",
"y++;",
"}",
"}",
"}",
"}",
"if (VAR_0->restart_interval && !--VAR_0->restart_count) {",
"align_get_bits(&VAR_0->gb);",
"skip_bits(&VAR_0->gb, 16);",
"}",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
77
],
[
79
],
[
83
],
[
85,
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
121,
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161,
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
209
],
[
213
],
[
215
],
[
219
],
[
221,
223
],
[
225
],
[
227,
229,
231
],
[
233
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
249
],
[
251
],
[
253
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283
],
[
285
]
] |
23,923 | static void virtio_blk_dma_restart_cb(void *opaque, int running,
RunState state)
{
VirtIOBlock *s = opaque;
if (!running) {
return;
}
if (!s->bh) {
s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);
qemu_bh_schedule(s->bh);
}
}
| false | qemu | 4407c1c56adb0d3ef2bcbf577592d72278d6e11f | static void virtio_blk_dma_restart_cb(void *opaque, int running,
RunState state)
{
VirtIOBlock *s = opaque;
if (!running) {
return;
}
if (!s->bh) {
s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);
qemu_bh_schedule(s->bh);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, int VAR_1,
RunState VAR_2)
{
VirtIOBlock *s = VAR_0;
if (!VAR_1) {
return;
}
if (!s->bh) {
s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);
qemu_bh_schedule(s->bh);
}
}
| [
"static void FUNC_0(void *VAR_0, int VAR_1,\nRunState VAR_2)\n{",
"VirtIOBlock *s = VAR_0;",
"if (!VAR_1) {",
"return;",
"}",
"if (!s->bh) {",
"s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s);",
"qemu_bh_schedule(s->bh);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
]
] |
23,925 | int parse_debug_env(const char *name, int max, int initial)
{
char *debug_env = getenv(name);
char *inv = NULL;
int debug;
if (!debug_env) {
return initial;
}
debug = strtol(debug_env, &inv, 10);
if (inv == debug_env) {
return initial;
}
if (debug < 0 || debug > max) {
fprintf(stderr, "warning: %s not in [0, %d]", name, max);
return initial;
}
return debug;
}
| false | qemu | cc5d0e04ee313d0ceee5d8e4e697142eaf240dca | int parse_debug_env(const char *name, int max, int initial)
{
char *debug_env = getenv(name);
char *inv = NULL;
int debug;
if (!debug_env) {
return initial;
}
debug = strtol(debug_env, &inv, 10);
if (inv == debug_env) {
return initial;
}
if (debug < 0 || debug > max) {
fprintf(stderr, "warning: %s not in [0, %d]", name, max);
return initial;
}
return debug;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(const char *VAR_0, int VAR_1, int VAR_2)
{
char *VAR_3 = getenv(VAR_0);
char *VAR_4 = NULL;
int VAR_5;
if (!VAR_3) {
return VAR_2;
}
VAR_5 = strtol(VAR_3, &VAR_4, 10);
if (VAR_4 == VAR_3) {
return VAR_2;
}
if (VAR_5 < 0 || VAR_5 > VAR_1) {
fprintf(stderr, "warning: %s not in [0, %d]", VAR_0, VAR_1);
return VAR_2;
}
return VAR_5;
}
| [
"int FUNC_0(const char *VAR_0, int VAR_1, int VAR_2)\n{",
"char *VAR_3 = getenv(VAR_0);",
"char *VAR_4 = NULL;",
"int VAR_5;",
"if (!VAR_3) {",
"return VAR_2;",
"}",
"VAR_5 = strtol(VAR_3, &VAR_4, 10);",
"if (VAR_4 == VAR_3) {",
"return VAR_2;",
"}",
"if (VAR_5 < 0 || VAR_5 > VAR_1) {",
"fprintf(stderr, \"warning: %s not in [0, %d]\", VAR_0, VAR_1);",
"return VAR_2;",
"}",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
]
] |
23,926 | static void vfio_listener_region_del(MemoryListener *listener,
MemoryRegionSection *section)
{
VFIOContainer *container = container_of(listener, VFIOContainer, listener);
hwaddr iova, end;
Int128 llend, llsize;
int ret;
if (vfio_listener_skipped_section(section)) {
trace_vfio_listener_region_del_skip(
section->offset_within_address_space,
section->offset_within_address_space +
int128_get64(int128_sub(section->size, int128_one())));
return;
}
if (unlikely((section->offset_within_address_space & ~TARGET_PAGE_MASK) !=
(section->offset_within_region & ~TARGET_PAGE_MASK))) {
error_report("%s received unaligned region", __func__);
return;
}
if (memory_region_is_iommu(section->mr)) {
VFIOGuestIOMMU *giommu;
QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) {
if (giommu->iommu == section->mr) {
memory_region_unregister_iommu_notifier(giommu->iommu,
&giommu->n);
QLIST_REMOVE(giommu, giommu_next);
g_free(giommu);
break;
}
}
/*
* FIXME: We assume the one big unmap below is adequate to
* remove any individual page mappings in the IOMMU which
* might have been copied into VFIO. This works for a page table
* based IOMMU where a big unmap flattens a large range of IO-PTEs.
* That may not be true for all IOMMU types.
*/
}
iova = TARGET_PAGE_ALIGN(section->offset_within_address_space);
llend = int128_make64(section->offset_within_address_space);
llend = int128_add(llend, section->size);
llend = int128_and(llend, int128_exts64(TARGET_PAGE_MASK));
if (int128_ge(int128_make64(iova), llend)) {
return;
}
end = int128_get64(int128_sub(llend, int128_one()));
llsize = int128_sub(llend, int128_make64(iova));
trace_vfio_listener_region_del(iova, end);
ret = vfio_dma_unmap(container, iova, int128_get64(llsize));
memory_region_unref(section->mr);
if (ret) {
error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
"0x%"HWADDR_PRIx") = %d (%m)",
container, iova, int128_get64(llsize), ret);
}
if (container->iommu_type == VFIO_SPAPR_TCE_v2_IOMMU) {
vfio_spapr_remove_window(container,
section->offset_within_address_space);
if (vfio_host_win_del(container,
section->offset_within_address_space,
section->offset_within_address_space +
int128_get64(section->size) - 1) < 0) {
hw_error("%s: Cannot delete missing window at %"HWADDR_PRIx,
__func__, section->offset_within_address_space);
}
}
}
| false | qemu | 698feb5e13a2d763369909ce33f2bd7a7c1c11c0 | static void vfio_listener_region_del(MemoryListener *listener,
MemoryRegionSection *section)
{
VFIOContainer *container = container_of(listener, VFIOContainer, listener);
hwaddr iova, end;
Int128 llend, llsize;
int ret;
if (vfio_listener_skipped_section(section)) {
trace_vfio_listener_region_del_skip(
section->offset_within_address_space,
section->offset_within_address_space +
int128_get64(int128_sub(section->size, int128_one())));
return;
}
if (unlikely((section->offset_within_address_space & ~TARGET_PAGE_MASK) !=
(section->offset_within_region & ~TARGET_PAGE_MASK))) {
error_report("%s received unaligned region", __func__);
return;
}
if (memory_region_is_iommu(section->mr)) {
VFIOGuestIOMMU *giommu;
QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) {
if (giommu->iommu == section->mr) {
memory_region_unregister_iommu_notifier(giommu->iommu,
&giommu->n);
QLIST_REMOVE(giommu, giommu_next);
g_free(giommu);
break;
}
}
}
iova = TARGET_PAGE_ALIGN(section->offset_within_address_space);
llend = int128_make64(section->offset_within_address_space);
llend = int128_add(llend, section->size);
llend = int128_and(llend, int128_exts64(TARGET_PAGE_MASK));
if (int128_ge(int128_make64(iova), llend)) {
return;
}
end = int128_get64(int128_sub(llend, int128_one()));
llsize = int128_sub(llend, int128_make64(iova));
trace_vfio_listener_region_del(iova, end);
ret = vfio_dma_unmap(container, iova, int128_get64(llsize));
memory_region_unref(section->mr);
if (ret) {
error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
"0x%"HWADDR_PRIx") = %d (%m)",
container, iova, int128_get64(llsize), ret);
}
if (container->iommu_type == VFIO_SPAPR_TCE_v2_IOMMU) {
vfio_spapr_remove_window(container,
section->offset_within_address_space);
if (vfio_host_win_del(container,
section->offset_within_address_space,
section->offset_within_address_space +
int128_get64(section->size) - 1) < 0) {
hw_error("%s: Cannot delete missing window at %"HWADDR_PRIx,
__func__, section->offset_within_address_space);
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(MemoryListener *VAR_0,
MemoryRegionSection *VAR_1)
{
VFIOContainer *container = container_of(VAR_0, VFIOContainer, VAR_0);
hwaddr iova, end;
Int128 llend, llsize;
int VAR_2;
if (vfio_listener_skipped_section(VAR_1)) {
trace_vfio_listener_region_del_skip(
VAR_1->offset_within_address_space,
VAR_1->offset_within_address_space +
int128_get64(int128_sub(VAR_1->size, int128_one())));
return;
}
if (unlikely((VAR_1->offset_within_address_space & ~TARGET_PAGE_MASK) !=
(VAR_1->offset_within_region & ~TARGET_PAGE_MASK))) {
error_report("%s received unaligned region", __func__);
return;
}
if (memory_region_is_iommu(VAR_1->mr)) {
VFIOGuestIOMMU *giommu;
QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) {
if (giommu->iommu == VAR_1->mr) {
memory_region_unregister_iommu_notifier(giommu->iommu,
&giommu->n);
QLIST_REMOVE(giommu, giommu_next);
g_free(giommu);
break;
}
}
}
iova = TARGET_PAGE_ALIGN(VAR_1->offset_within_address_space);
llend = int128_make64(VAR_1->offset_within_address_space);
llend = int128_add(llend, VAR_1->size);
llend = int128_and(llend, int128_exts64(TARGET_PAGE_MASK));
if (int128_ge(int128_make64(iova), llend)) {
return;
}
end = int128_get64(int128_sub(llend, int128_one()));
llsize = int128_sub(llend, int128_make64(iova));
trace_vfio_listener_region_del(iova, end);
VAR_2 = vfio_dma_unmap(container, iova, int128_get64(llsize));
memory_region_unref(VAR_1->mr);
if (VAR_2) {
error_report("vfio_dma_unmap(%p, 0x%"HWADDR_PRIx", "
"0x%"HWADDR_PRIx") = %d (%m)",
container, iova, int128_get64(llsize), VAR_2);
}
if (container->iommu_type == VFIO_SPAPR_TCE_v2_IOMMU) {
vfio_spapr_remove_window(container,
VAR_1->offset_within_address_space);
if (vfio_host_win_del(container,
VAR_1->offset_within_address_space,
VAR_1->offset_within_address_space +
int128_get64(VAR_1->size) - 1) < 0) {
hw_error("%s: Cannot delete missing window at %"HWADDR_PRIx,
__func__, VAR_1->offset_within_address_space);
}
}
}
| [
"static void FUNC_0(MemoryListener *VAR_0,\nMemoryRegionSection *VAR_1)\n{",
"VFIOContainer *container = container_of(VAR_0, VFIOContainer, VAR_0);",
"hwaddr iova, end;",
"Int128 llend, llsize;",
"int VAR_2;",
"if (vfio_listener_skipped_section(VAR_1)) {",
"trace_vfio_listener_region_del_skip(\nVAR_1->offset_within_address_space,\nVAR_1->offset_within_address_space +\nint128_get64(int128_sub(VAR_1->size, int128_one())));",
"return;",
"}",
"if (unlikely((VAR_1->offset_within_address_space & ~TARGET_PAGE_MASK) !=\n(VAR_1->offset_within_region & ~TARGET_PAGE_MASK))) {",
"error_report(\"%s received unaligned region\", __func__);",
"return;",
"}",
"if (memory_region_is_iommu(VAR_1->mr)) {",
"VFIOGuestIOMMU *giommu;",
"QLIST_FOREACH(giommu, &container->giommu_list, giommu_next) {",
"if (giommu->iommu == VAR_1->mr) {",
"memory_region_unregister_iommu_notifier(giommu->iommu,\n&giommu->n);",
"QLIST_REMOVE(giommu, giommu_next);",
"g_free(giommu);",
"break;",
"}",
"}",
"}",
"iova = TARGET_PAGE_ALIGN(VAR_1->offset_within_address_space);",
"llend = int128_make64(VAR_1->offset_within_address_space);",
"llend = int128_add(llend, VAR_1->size);",
"llend = int128_and(llend, int128_exts64(TARGET_PAGE_MASK));",
"if (int128_ge(int128_make64(iova), llend)) {",
"return;",
"}",
"end = int128_get64(int128_sub(llend, int128_one()));",
"llsize = int128_sub(llend, int128_make64(iova));",
"trace_vfio_listener_region_del(iova, end);",
"VAR_2 = vfio_dma_unmap(container, iova, int128_get64(llsize));",
"memory_region_unref(VAR_1->mr);",
"if (VAR_2) {",
"error_report(\"vfio_dma_unmap(%p, 0x%\"HWADDR_PRIx\", \"\n\"0x%\"HWADDR_PRIx\") = %d (%m)\",\ncontainer, iova, int128_get64(llsize), VAR_2);",
"}",
"if (container->iommu_type == VFIO_SPAPR_TCE_v2_IOMMU) {",
"vfio_spapr_remove_window(container,\nVAR_1->offset_within_address_space);",
"if (vfio_host_win_del(container,\nVAR_1->offset_within_address_space,\nVAR_1->offset_within_address_space +\nint128_get64(VAR_1->size) - 1) < 0) {",
"hw_error(\"%s: Cannot delete missing window at %\"HWADDR_PRIx,\n__func__, VAR_1->offset_within_address_space);",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
113
],
[
117
],
[
119
],
[
121
],
[
123,
125,
127
],
[
129
],
[
133
],
[
135,
137
],
[
139,
141,
143,
145
],
[
147,
149
],
[
151
],
[
153
],
[
155
]
] |
23,927 | VirtIOSCSIReq *virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq)
{
VirtIOSCSIReq *req;
VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s;
const size_t zero_skip = offsetof(VirtIOSCSIReq, vring);
req = g_malloc(sizeof(*req) + vs->cdb_size);
req->vq = vq;
req->dev = s;
qemu_sglist_init(&req->qsgl, DEVICE(s), 8, &address_space_memory);
qemu_iovec_init(&req->resp_iov, 1);
memset((uint8_t *)req + zero_skip, 0, sizeof(*req) - zero_skip);
return req;
}
| false | qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | VirtIOSCSIReq *virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq)
{
VirtIOSCSIReq *req;
VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s;
const size_t zero_skip = offsetof(VirtIOSCSIReq, vring);
req = g_malloc(sizeof(*req) + vs->cdb_size);
req->vq = vq;
req->dev = s;
qemu_sglist_init(&req->qsgl, DEVICE(s), 8, &address_space_memory);
qemu_iovec_init(&req->resp_iov, 1);
memset((uint8_t *)req + zero_skip, 0, sizeof(*req) - zero_skip);
return req;
}
| {
"code": [],
"line_no": []
} | VirtIOSCSIReq *FUNC_0(VirtIOSCSI *s, VirtQueue *vq)
{
VirtIOSCSIReq *req;
VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s;
const size_t VAR_0 = offsetof(VirtIOSCSIReq, vring);
req = g_malloc(sizeof(*req) + vs->cdb_size);
req->vq = vq;
req->dev = s;
qemu_sglist_init(&req->qsgl, DEVICE(s), 8, &address_space_memory);
qemu_iovec_init(&req->resp_iov, 1);
memset((uint8_t *)req + VAR_0, 0, sizeof(*req) - VAR_0);
return req;
}
| [
"VirtIOSCSIReq *FUNC_0(VirtIOSCSI *s, VirtQueue *vq)\n{",
"VirtIOSCSIReq *req;",
"VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s;",
"const size_t VAR_0 = offsetof(VirtIOSCSIReq, vring);",
"req = g_malloc(sizeof(*req) + vs->cdb_size);",
"req->vq = vq;",
"req->dev = s;",
"qemu_sglist_init(&req->qsgl, DEVICE(s), 8, &address_space_memory);",
"qemu_iovec_init(&req->resp_iov, 1);",
"memset((uint8_t *)req + VAR_0, 0, sizeof(*req) - VAR_0);",
"return req;",
"}"
] | [
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
]
] |
23,928 | static void qemu_cpu_kick_thread(CPUState *cpu)
{
#ifndef _WIN32
int err;
err = pthread_kill(cpu->thread->thread, SIG_IPI);
if (err) {
fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
exit(1);
}
#else /* _WIN32 */
if (!qemu_cpu_is_self(cpu)) {
SuspendThread(cpu->hThread);
cpu_signal(0);
ResumeThread(cpu->hThread);
}
#endif
}
| false | qemu | ed9164a3549f93204d6b096136cda2ce54e9f03a | static void qemu_cpu_kick_thread(CPUState *cpu)
{
#ifndef _WIN32
int err;
err = pthread_kill(cpu->thread->thread, SIG_IPI);
if (err) {
fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
exit(1);
}
#else
if (!qemu_cpu_is_self(cpu)) {
SuspendThread(cpu->hThread);
cpu_signal(0);
ResumeThread(cpu->hThread);
}
#endif
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(CPUState *VAR_0)
{
#ifndef _WIN32
int VAR_1;
VAR_1 = pthread_kill(VAR_0->thread->thread, SIG_IPI);
if (VAR_1) {
fprintf(stderr, "qemu:%s: %s", __func__, strerror(VAR_1));
exit(1);
}
#else
if (!qemu_cpu_is_self(VAR_0)) {
SuspendThread(VAR_0->hThread);
cpu_signal(0);
ResumeThread(VAR_0->hThread);
}
#endif
}
| [
"static void FUNC_0(CPUState *VAR_0)\n{",
"#ifndef _WIN32\nint VAR_1;",
"VAR_1 = pthread_kill(VAR_0->thread->thread, SIG_IPI);",
"if (VAR_1) {",
"fprintf(stderr, \"qemu:%s: %s\", __func__, strerror(VAR_1));",
"exit(1);",
"}",
"#else\nif (!qemu_cpu_is_self(VAR_0)) {",
"SuspendThread(VAR_0->hThread);",
"cpu_signal(0);",
"ResumeThread(VAR_0->hThread);",
"}",
"#endif\n}"
] | [
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
]
] |
23,930 | bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
{
BlockDriverInfo bdi;
if (bs->backing_hd) {
return false;
}
if (bdrv_get_info(bs, &bdi) == 0) {
return bdi.unallocated_blocks_are_zero;
}
return false;
}
| false | qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
{
BlockDriverInfo bdi;
if (bs->backing_hd) {
return false;
}
if (bdrv_get_info(bs, &bdi) == 0) {
return bdi.unallocated_blocks_are_zero;
}
return false;
}
| {
"code": [],
"line_no": []
} | bool FUNC_0(BlockDriverState *bs)
{
BlockDriverInfo bdi;
if (bs->backing_hd) {
return false;
}
if (bdrv_get_info(bs, &bdi) == 0) {
return bdi.unallocated_blocks_are_zero;
}
return false;
}
| [
"bool FUNC_0(BlockDriverState *bs)\n{",
"BlockDriverInfo bdi;",
"if (bs->backing_hd) {",
"return false;",
"}",
"if (bdrv_get_info(bs, &bdi) == 0) {",
"return bdi.unallocated_blocks_are_zero;",
"}",
"return false;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
]
] |
23,931 | static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features,
Error **errp)
{
VirtIONet *n = VIRTIO_NET(vdev);
NetClientState *nc = qemu_get_queue(n->nic);
/* Firstly sync all virtio-net possible supported features */
features |= n->host_features;
virtio_add_feature(&features, VIRTIO_NET_F_MAC);
if (!peer_has_vnet_hdr(n)) {
virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
}
if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
}
if (!get_vhost_net(nc->peer)) {
return features;
}
return vhost_net_get_features(get_vhost_net(nc->peer), features);
}
| false | qemu | 75ebec11afe49539f71cc1c494e3010f91c86adb | static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features,
Error **errp)
{
VirtIONet *n = VIRTIO_NET(vdev);
NetClientState *nc = qemu_get_queue(n->nic);
features |= n->host_features;
virtio_add_feature(&features, VIRTIO_NET_F_MAC);
if (!peer_has_vnet_hdr(n)) {
virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
}
if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
}
if (!get_vhost_net(nc->peer)) {
return features;
}
return vhost_net_get_features(get_vhost_net(nc->peer), features);
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(VirtIODevice *vdev, uint64_t features,
Error **errp)
{
VirtIONet *n = VIRTIO_NET(vdev);
NetClientState *nc = qemu_get_queue(n->nic);
features |= n->host_features;
virtio_add_feature(&features, VIRTIO_NET_F_MAC);
if (!peer_has_vnet_hdr(n)) {
virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
}
if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
}
if (!get_vhost_net(nc->peer)) {
return features;
}
return vhost_net_get_features(get_vhost_net(nc->peer), features);
}
| [
"static uint64_t FUNC_0(VirtIODevice *vdev, uint64_t features,\nError **errp)\n{",
"VirtIONet *n = VIRTIO_NET(vdev);",
"NetClientState *nc = qemu_get_queue(n->nic);",
"features |= n->host_features;",
"virtio_add_feature(&features, VIRTIO_NET_F_MAC);",
"if (!peer_has_vnet_hdr(n)) {",
"virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);",
"virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);",
"virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);",
"virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);",
"virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);",
"virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);",
"virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);",
"virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);",
"}",
"if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {",
"virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);",
"virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);",
"}",
"if (!get_vhost_net(nc->peer)) {",
"return features;",
"}",
"return vhost_net_get_features(get_vhost_net(nc->peer), features);",
"}"
] | [
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
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
]
] |
23,932 | PXA2xxState *pxa270_init(MemoryRegion *address_space,
unsigned int sdram_size, const char *revision)
{
PXA2xxState *s;
int i;
DriveInfo *dinfo;
s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
if (revision && strncmp(revision, "pxa27", 5)) {
fprintf(stderr, "Machine requires a PXA27x processor.\n");
exit(1);
}
if (!revision)
revision = "pxa270";
s->cpu = cpu_arm_init(revision);
if (s->cpu == NULL) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
s->reset = qemu_allocate_irq(pxa2xx_reset, s, 0);
/* SDRAM & Internal Memory Storage */
memory_region_init_ram(&s->sdram, NULL, "pxa270.sdram", sdram_size,
&error_abort);
vmstate_register_ram_global(&s->sdram);
memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
memory_region_init_ram(&s->internal, NULL, "pxa270.internal", 0x40000,
&error_abort);
vmstate_register_ram_global(&s->internal);
memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
&s->internal);
s->pic = pxa2xx_pic_init(0x40d00000, s->cpu);
s->dma = pxa27x_dma_init(0x40000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
sysbus_create_varargs("pxa27x-timer", 0x40a00000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
qdev_get_gpio_in(s->pic, PXA27X_PIC_OST_4_11),
NULL);
s->gpio = pxa2xx_gpio_init(0x40e00000, s->cpu, s->pic, 121);
dinfo = drive_get(IF_SD, 0, 0);
if (!dinfo) {
fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1);
}
s->mmc = pxa2xx_mmci_init(address_space, 0x41100000,
blk_bs(blk_by_legacy_dinfo(dinfo)),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
for (i = 0; pxa270_serial[i].io_base; i++) {
if (serial_hds[i]) {
serial_mm_init(address_space, pxa270_serial[i].io_base, 2,
qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),
14857000 / 16, serial_hds[i],
DEVICE_NATIVE_ENDIAN);
} else {
break;
}
}
if (serial_hds[i])
s->fir = pxa2xx_fir_init(address_space, 0x40800000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
serial_hds[i]);
s->lcd = pxa2xx_lcdc_init(address_space, 0x44000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
s->cm_base = 0x41300000;
s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */
s->clkcfg = 0x00000009; /* Turbo mode active */
memory_region_init_io(&s->cm_iomem, NULL, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
pxa2xx_setup_cp14(s);
s->mm_base = 0x48000000;
s->mm_regs[MDMRS >> 2] = 0x00020002;
s->mm_regs[MDREFR >> 2] = 0x03ca4000;
s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */
memory_region_init_io(&s->mm_iomem, NULL, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
s->pm_base = 0x40f00000;
memory_region_init_io(&s->pm_iomem, NULL, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
for (i = 0; pxa27x_ssp[i].io_base; i ++);
s->ssp = (SSIBus **)g_malloc0(sizeof(SSIBus *) * i);
for (i = 0; pxa27x_ssp[i].io_base; i ++) {
DeviceState *dev;
dev = sysbus_create_simple(TYPE_PXA2XX_SSP, pxa27x_ssp[i].io_base,
qdev_get_gpio_in(s->pic, pxa27x_ssp[i].irqn));
s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
}
if (usb_enabled(false)) {
sysbus_create_simple("sysbus-ohci", 0x4c000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
}
s->pcmcia[0] = pxa2xx_pcmcia_init(address_space, 0x20000000);
s->pcmcia[1] = pxa2xx_pcmcia_init(address_space, 0x30000000);
sysbus_create_simple(TYPE_PXA2XX_RTC, 0x40900000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
s->i2c[0] = pxa2xx_i2c_init(0x40301600,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
s->kp = pxa27x_keypad_init(address_space, 0x41500000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_KEYPAD));
/* GPIO1 resets the processor */
/* The handler can be overridden by board-specific code */
qdev_connect_gpio_out(s->gpio, 1, s->reset);
return s;
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | PXA2xxState *pxa270_init(MemoryRegion *address_space,
unsigned int sdram_size, const char *revision)
{
PXA2xxState *s;
int i;
DriveInfo *dinfo;
s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
if (revision && strncmp(revision, "pxa27", 5)) {
fprintf(stderr, "Machine requires a PXA27x processor.\n");
exit(1);
}
if (!revision)
revision = "pxa270";
s->cpu = cpu_arm_init(revision);
if (s->cpu == NULL) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
s->reset = qemu_allocate_irq(pxa2xx_reset, s, 0);
memory_region_init_ram(&s->sdram, NULL, "pxa270.sdram", sdram_size,
&error_abort);
vmstate_register_ram_global(&s->sdram);
memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
memory_region_init_ram(&s->internal, NULL, "pxa270.internal", 0x40000,
&error_abort);
vmstate_register_ram_global(&s->internal);
memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
&s->internal);
s->pic = pxa2xx_pic_init(0x40d00000, s->cpu);
s->dma = pxa27x_dma_init(0x40000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
sysbus_create_varargs("pxa27x-timer", 0x40a00000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
qdev_get_gpio_in(s->pic, PXA27X_PIC_OST_4_11),
NULL);
s->gpio = pxa2xx_gpio_init(0x40e00000, s->cpu, s->pic, 121);
dinfo = drive_get(IF_SD, 0, 0);
if (!dinfo) {
fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1);
}
s->mmc = pxa2xx_mmci_init(address_space, 0x41100000,
blk_bs(blk_by_legacy_dinfo(dinfo)),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
for (i = 0; pxa270_serial[i].io_base; i++) {
if (serial_hds[i]) {
serial_mm_init(address_space, pxa270_serial[i].io_base, 2,
qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),
14857000 / 16, serial_hds[i],
DEVICE_NATIVE_ENDIAN);
} else {
break;
}
}
if (serial_hds[i])
s->fir = pxa2xx_fir_init(address_space, 0x40800000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
serial_hds[i]);
s->lcd = pxa2xx_lcdc_init(address_space, 0x44000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
s->cm_base = 0x41300000;
s->cm_regs[CCCR >> 2] = 0x02000210;
s->clkcfg = 0x00000009;
memory_region_init_io(&s->cm_iomem, NULL, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
pxa2xx_setup_cp14(s);
s->mm_base = 0x48000000;
s->mm_regs[MDMRS >> 2] = 0x00020002;
s->mm_regs[MDREFR >> 2] = 0x03ca4000;
s->mm_regs[MECR >> 2] = 0x00000001;
memory_region_init_io(&s->mm_iomem, NULL, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
s->pm_base = 0x40f00000;
memory_region_init_io(&s->pm_iomem, NULL, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
for (i = 0; pxa27x_ssp[i].io_base; i ++);
s->ssp = (SSIBus **)g_malloc0(sizeof(SSIBus *) * i);
for (i = 0; pxa27x_ssp[i].io_base; i ++) {
DeviceState *dev;
dev = sysbus_create_simple(TYPE_PXA2XX_SSP, pxa27x_ssp[i].io_base,
qdev_get_gpio_in(s->pic, pxa27x_ssp[i].irqn));
s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
}
if (usb_enabled(false)) {
sysbus_create_simple("sysbus-ohci", 0x4c000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
}
s->pcmcia[0] = pxa2xx_pcmcia_init(address_space, 0x20000000);
s->pcmcia[1] = pxa2xx_pcmcia_init(address_space, 0x30000000);
sysbus_create_simple(TYPE_PXA2XX_RTC, 0x40900000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
s->i2c[0] = pxa2xx_i2c_init(0x40301600,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
s->kp = pxa27x_keypad_init(address_space, 0x41500000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_KEYPAD));
qdev_connect_gpio_out(s->gpio, 1, s->reset);
return s;
}
| {
"code": [],
"line_no": []
} | PXA2xxState *FUNC_0(MemoryRegion *address_space,
unsigned int sdram_size, const char *revision)
{
PXA2xxState *s;
int VAR_0;
DriveInfo *dinfo;
s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
if (revision && strncmp(revision, "pxa27", 5)) {
fprintf(stderr, "Machine requires a PXA27x processor.\n");
exit(1);
}
if (!revision)
revision = "pxa270";
s->cpu = cpu_arm_init(revision);
if (s->cpu == NULL) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
s->reset = qemu_allocate_irq(pxa2xx_reset, s, 0);
memory_region_init_ram(&s->sdram, NULL, "pxa270.sdram", sdram_size,
&error_abort);
vmstate_register_ram_global(&s->sdram);
memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
memory_region_init_ram(&s->internal, NULL, "pxa270.internal", 0x40000,
&error_abort);
vmstate_register_ram_global(&s->internal);
memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
&s->internal);
s->pic = pxa2xx_pic_init(0x40d00000, s->cpu);
s->dma = pxa27x_dma_init(0x40000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
sysbus_create_varargs("pxa27x-timer", 0x40a00000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
qdev_get_gpio_in(s->pic, PXA27X_PIC_OST_4_11),
NULL);
s->gpio = pxa2xx_gpio_init(0x40e00000, s->cpu, s->pic, 121);
dinfo = drive_get(IF_SD, 0, 0);
if (!dinfo) {
fprintf(stderr, "qemu: missing SecureDigital device\n");
exit(1);
}
s->mmc = pxa2xx_mmci_init(address_space, 0x41100000,
blk_bs(blk_by_legacy_dinfo(dinfo)),
qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
for (VAR_0 = 0; pxa270_serial[VAR_0].io_base; VAR_0++) {
if (serial_hds[VAR_0]) {
serial_mm_init(address_space, pxa270_serial[VAR_0].io_base, 2,
qdev_get_gpio_in(s->pic, pxa270_serial[VAR_0].irqn),
14857000 / 16, serial_hds[VAR_0],
DEVICE_NATIVE_ENDIAN);
} else {
break;
}
}
if (serial_hds[VAR_0])
s->fir = pxa2xx_fir_init(address_space, 0x40800000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
serial_hds[VAR_0]);
s->lcd = pxa2xx_lcdc_init(address_space, 0x44000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
s->cm_base = 0x41300000;
s->cm_regs[CCCR >> 2] = 0x02000210;
s->clkcfg = 0x00000009;
memory_region_init_io(&s->cm_iomem, NULL, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
pxa2xx_setup_cp14(s);
s->mm_base = 0x48000000;
s->mm_regs[MDMRS >> 2] = 0x00020002;
s->mm_regs[MDREFR >> 2] = 0x03ca4000;
s->mm_regs[MECR >> 2] = 0x00000001;
memory_region_init_io(&s->mm_iomem, NULL, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
s->pm_base = 0x40f00000;
memory_region_init_io(&s->pm_iomem, NULL, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
for (VAR_0 = 0; pxa27x_ssp[VAR_0].io_base; VAR_0 ++);
s->ssp = (SSIBus **)g_malloc0(sizeof(SSIBus *) * VAR_0);
for (VAR_0 = 0; pxa27x_ssp[VAR_0].io_base; VAR_0 ++) {
DeviceState *dev;
dev = sysbus_create_simple(TYPE_PXA2XX_SSP, pxa27x_ssp[VAR_0].io_base,
qdev_get_gpio_in(s->pic, pxa27x_ssp[VAR_0].irqn));
s->ssp[VAR_0] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
}
if (usb_enabled(false)) {
sysbus_create_simple("sysbus-ohci", 0x4c000000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
}
s->pcmcia[0] = pxa2xx_pcmcia_init(address_space, 0x20000000);
s->pcmcia[1] = pxa2xx_pcmcia_init(address_space, 0x30000000);
sysbus_create_simple(TYPE_PXA2XX_RTC, 0x40900000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
s->i2c[0] = pxa2xx_i2c_init(0x40301600,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
s->kp = pxa27x_keypad_init(address_space, 0x41500000,
qdev_get_gpio_in(s->pic, PXA2XX_PIC_KEYPAD));
qdev_connect_gpio_out(s->gpio, 1, s->reset);
return s;
}
| [
"PXA2xxState *FUNC_0(MemoryRegion *address_space,\nunsigned int sdram_size, const char *revision)\n{",
"PXA2xxState *s;",
"int VAR_0;",
"DriveInfo *dinfo;",
"s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));",
"if (revision && strncmp(revision, \"pxa27\", 5)) {",
"fprintf(stderr, \"Machine requires a PXA27x processor.\\n\");",
"exit(1);",
"}",
"if (!revision)\nrevision = \"pxa270\";",
"s->cpu = cpu_arm_init(revision);",
"if (s->cpu == NULL) {",
"fprintf(stderr, \"Unable to find CPU definition\\n\");",
"exit(1);",
"}",
"s->reset = qemu_allocate_irq(pxa2xx_reset, s, 0);",
"memory_region_init_ram(&s->sdram, NULL, \"pxa270.sdram\", sdram_size,\n&error_abort);",
"vmstate_register_ram_global(&s->sdram);",
"memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);",
"memory_region_init_ram(&s->internal, NULL, \"pxa270.internal\", 0x40000,\n&error_abort);",
"vmstate_register_ram_global(&s->internal);",
"memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,\n&s->internal);",
"s->pic = pxa2xx_pic_init(0x40d00000, s->cpu);",
"s->dma = pxa27x_dma_init(0x40000000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));",
"sysbus_create_varargs(\"pxa27x-timer\", 0x40a00000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),\nqdev_get_gpio_in(s->pic, PXA27X_PIC_OST_4_11),\nNULL);",
"s->gpio = pxa2xx_gpio_init(0x40e00000, s->cpu, s->pic, 121);",
"dinfo = drive_get(IF_SD, 0, 0);",
"if (!dinfo) {",
"fprintf(stderr, \"qemu: missing SecureDigital device\\n\");",
"exit(1);",
"}",
"s->mmc = pxa2xx_mmci_init(address_space, 0x41100000,\nblk_bs(blk_by_legacy_dinfo(dinfo)),\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),\nqdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),\nqdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));",
"for (VAR_0 = 0; pxa270_serial[VAR_0].io_base; VAR_0++) {",
"if (serial_hds[VAR_0]) {",
"serial_mm_init(address_space, pxa270_serial[VAR_0].io_base, 2,\nqdev_get_gpio_in(s->pic, pxa270_serial[VAR_0].irqn),\n14857000 / 16, serial_hds[VAR_0],\nDEVICE_NATIVE_ENDIAN);",
"} else {",
"break;",
"}",
"}",
"if (serial_hds[VAR_0])\ns->fir = pxa2xx_fir_init(address_space, 0x40800000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),\nqdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),\nqdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),\nserial_hds[VAR_0]);",
"s->lcd = pxa2xx_lcdc_init(address_space, 0x44000000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));",
"s->cm_base = 0x41300000;",
"s->cm_regs[CCCR >> 2] = 0x02000210;",
"s->clkcfg = 0x00000009;",
"memory_region_init_io(&s->cm_iomem, NULL, &pxa2xx_cm_ops, s, \"pxa2xx-cm\", 0x1000);",
"memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);",
"vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);",
"pxa2xx_setup_cp14(s);",
"s->mm_base = 0x48000000;",
"s->mm_regs[MDMRS >> 2] = 0x00020002;",
"s->mm_regs[MDREFR >> 2] = 0x03ca4000;",
"s->mm_regs[MECR >> 2] = 0x00000001;",
"memory_region_init_io(&s->mm_iomem, NULL, &pxa2xx_mm_ops, s, \"pxa2xx-mm\", 0x1000);",
"memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);",
"vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);",
"s->pm_base = 0x40f00000;",
"memory_region_init_io(&s->pm_iomem, NULL, &pxa2xx_pm_ops, s, \"pxa2xx-pm\", 0x100);",
"memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);",
"vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);",
"for (VAR_0 = 0; pxa27x_ssp[VAR_0].io_base; VAR_0 ++);",
"s->ssp = (SSIBus **)g_malloc0(sizeof(SSIBus *) * VAR_0);",
"for (VAR_0 = 0; pxa27x_ssp[VAR_0].io_base; VAR_0 ++) {",
"DeviceState *dev;",
"dev = sysbus_create_simple(TYPE_PXA2XX_SSP, pxa27x_ssp[VAR_0].io_base,\nqdev_get_gpio_in(s->pic, pxa27x_ssp[VAR_0].irqn));",
"s->ssp[VAR_0] = (SSIBus *)qdev_get_child_bus(dev, \"ssi\");",
"}",
"if (usb_enabled(false)) {",
"sysbus_create_simple(\"sysbus-ohci\", 0x4c000000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));",
"}",
"s->pcmcia[0] = pxa2xx_pcmcia_init(address_space, 0x20000000);",
"s->pcmcia[1] = pxa2xx_pcmcia_init(address_space, 0x30000000);",
"sysbus_create_simple(TYPE_PXA2XX_RTC, 0x40900000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));",
"s->i2c[0] = pxa2xx_i2c_init(0x40301600,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);",
"s->i2c[1] = pxa2xx_i2c_init(0x40f00100,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);",
"s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),\nqdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),\nqdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));",
"s->kp = pxa27x_keypad_init(address_space, 0x41500000,\nqdev_get_gpio_in(s->pic, PXA2XX_PIC_KEYPAD));",
"qdev_connect_gpio_out(s->gpio, 1, s->reset);",
"return s;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
47,
49
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61,
63
],
[
67
],
[
71,
73
],
[
77,
79,
81,
83,
85,
87,
89
],
[
93
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107,
109,
111,
113,
115
],
[
119
],
[
121
],
[
123,
125,
127,
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139,
141,
143,
145,
147,
149
],
[
153,
155
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
173
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211,
213
],
[
215
],
[
217
],
[
221
],
[
223,
225
],
[
227
],
[
231
],
[
233
],
[
237,
239
],
[
243,
245
],
[
247,
249
],
[
253,
255,
257,
259
],
[
263,
265
],
[
273
],
[
275
],
[
277
]
] |
23,934 | static gboolean pty_chr_timer(gpointer opaque)
{
struct CharDriverState *chr = opaque;
PtyCharDriver *s = chr->opaque;
if (s->connected) {
goto out;
}
if (s->polling) {
/* If we arrive here without polling being cleared due
* read returning -EIO, then we are (re-)connected */
pty_chr_state(chr, 1);
goto out;
}
/* Next poll ... */
pty_chr_update_read_handler(chr);
out:
return FALSE;
}
| false | qemu | 85a67692d04e15a6b7d5a0e2b9d573d8bffbe108 | static gboolean pty_chr_timer(gpointer opaque)
{
struct CharDriverState *chr = opaque;
PtyCharDriver *s = chr->opaque;
if (s->connected) {
goto out;
}
if (s->polling) {
pty_chr_state(chr, 1);
goto out;
}
pty_chr_update_read_handler(chr);
out:
return FALSE;
}
| {
"code": [],
"line_no": []
} | static gboolean FUNC_0(gpointer opaque)
{
struct CharDriverState *VAR_0 = opaque;
PtyCharDriver *s = VAR_0->opaque;
if (s->connected) {
goto out;
}
if (s->polling) {
pty_chr_state(VAR_0, 1);
goto out;
}
pty_chr_update_read_handler(VAR_0);
out:
return FALSE;
}
| [
"static gboolean FUNC_0(gpointer opaque)\n{",
"struct CharDriverState *VAR_0 = opaque;",
"PtyCharDriver *s = VAR_0->opaque;",
"if (s->connected) {",
"goto out;",
"}",
"if (s->polling) {",
"pty_chr_state(VAR_0, 1);",
"goto out;",
"}",
"pty_chr_update_read_handler(VAR_0);",
"out:\nreturn FALSE;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
33
],
[
37,
39
],
[
41
]
] |
23,935 | static void virtio_scsi_reset(VirtIODevice *vdev)
{
VirtIOSCSI *s = VIRTIO_SCSI(vdev);
VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
if (s->ctx) {
virtio_scsi_dataplane_stop(s);
}
s->resetting++;
qbus_reset_all(&s->bus.qbus);
s->resetting--;
vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;
vs->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;
s->events_dropped = false;
}
| false | qemu | ad07cd69ecaffbaa015459a46975ab32e50df805 | static void virtio_scsi_reset(VirtIODevice *vdev)
{
VirtIOSCSI *s = VIRTIO_SCSI(vdev);
VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
if (s->ctx) {
virtio_scsi_dataplane_stop(s);
}
s->resetting++;
qbus_reset_all(&s->bus.qbus);
s->resetting--;
vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;
vs->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;
s->events_dropped = false;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(VirtIODevice *VAR_0)
{
VirtIOSCSI *s = VIRTIO_SCSI(VAR_0);
VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(VAR_0);
if (s->ctx) {
virtio_scsi_dataplane_stop(s);
}
s->resetting++;
qbus_reset_all(&s->bus.qbus);
s->resetting--;
vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;
vs->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;
s->events_dropped = false;
}
| [
"static void FUNC_0(VirtIODevice *VAR_0)\n{",
"VirtIOSCSI *s = VIRTIO_SCSI(VAR_0);",
"VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(VAR_0);",
"if (s->ctx) {",
"virtio_scsi_dataplane_stop(s);",
"}",
"s->resetting++;",
"qbus_reset_all(&s->bus.qbus);",
"s->resetting--;",
"vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;",
"vs->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;",
"s->events_dropped = false;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
]
] |
23,936 | int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
BlockDriverState *bs;
int force = qdict_get_int(qdict, "force");
const char *filename = qdict_get_str(qdict, "device");
bs = bdrv_find(filename);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, filename);
return -1;
}
return eject_device(mon, bs, force);
}
| false | qemu | eb159d13ee36a9ef2a83e3ab66f1b2ae1cc2d9f1 | int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
BlockDriverState *bs;
int force = qdict_get_int(qdict, "force");
const char *filename = qdict_get_str(qdict, "device");
bs = bdrv_find(filename);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, filename);
return -1;
}
return eject_device(mon, bs, force);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)
{
BlockDriverState *bs;
int VAR_3 = qdict_get_int(VAR_1, "VAR_3");
const char *VAR_4 = qdict_get_str(VAR_1, "device");
bs = bdrv_find(VAR_4);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, VAR_4);
return -1;
}
return eject_device(VAR_0, bs, VAR_3);
}
| [
"int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)\n{",
"BlockDriverState *bs;",
"int VAR_3 = qdict_get_int(VAR_1, \"VAR_3\");",
"const char *VAR_4 = qdict_get_str(VAR_1, \"device\");",
"bs = bdrv_find(VAR_4);",
"if (!bs) {",
"qerror_report(QERR_DEVICE_NOT_FOUND, VAR_4);",
"return -1;",
"}",
"return eject_device(VAR_0, bs, VAR_3);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
]
] |
23,937 | static int qxl_post_load(void *opaque, int version)
{
PCIQXLDevice* d = opaque;
uint8_t *ram_start = d->vga.vram_ptr;
QXLCommandExt *cmds;
int in, out, i, newmode;
dprint(d, 1, "%s: start\n", __FUNCTION__);
assert(d->last_release_offset < d->vga.vram_size);
if (d->last_release_offset == 0) {
d->last_release = NULL;
} else {
d->last_release = (QXLReleaseInfo *)(ram_start + d->last_release_offset);
}
d->modes = (QXLModes*)((uint8_t*)d->rom + d->rom->modes_offset);
dprint(d, 1, "%s: restore mode (%s)\n", __FUNCTION__,
qxl_mode_to_string(d->mode));
newmode = d->mode;
d->mode = QXL_MODE_UNDEFINED;
switch (newmode) {
case QXL_MODE_UNDEFINED:
break;
case QXL_MODE_VGA:
qxl_enter_vga_mode(d);
break;
case QXL_MODE_NATIVE:
for (i = 0; i < NUM_MEMSLOTS; i++) {
if (!d->guest_slots[i].active) {
continue;
}
qxl_add_memslot(d, i, 0, QXL_SYNC);
}
qxl_create_guest_primary(d, 1, QXL_SYNC);
/* replay surface-create and cursor-set commands */
cmds = g_malloc0(sizeof(QXLCommandExt) * (NUM_SURFACES + 1));
for (in = 0, out = 0; in < NUM_SURFACES; in++) {
if (d->guest_surfaces.cmds[in] == 0) {
continue;
}
cmds[out].cmd.data = d->guest_surfaces.cmds[in];
cmds[out].cmd.type = QXL_CMD_SURFACE;
cmds[out].group_id = MEMSLOT_GROUP_GUEST;
out++;
}
cmds[out].cmd.data = d->guest_cursor;
cmds[out].cmd.type = QXL_CMD_CURSOR;
cmds[out].group_id = MEMSLOT_GROUP_GUEST;
out++;
qxl_spice_loadvm_commands(d, cmds, out);
g_free(cmds);
break;
case QXL_MODE_COMPAT:
qxl_set_mode(d, d->shadow_rom.mode, 1);
break;
}
dprint(d, 1, "%s: done\n", __FUNCTION__);
return 0;
}
| false | qemu | 30f6da6656c94964ba8677928588592d9667007e | static int qxl_post_load(void *opaque, int version)
{
PCIQXLDevice* d = opaque;
uint8_t *ram_start = d->vga.vram_ptr;
QXLCommandExt *cmds;
int in, out, i, newmode;
dprint(d, 1, "%s: start\n", __FUNCTION__);
assert(d->last_release_offset < d->vga.vram_size);
if (d->last_release_offset == 0) {
d->last_release = NULL;
} else {
d->last_release = (QXLReleaseInfo *)(ram_start + d->last_release_offset);
}
d->modes = (QXLModes*)((uint8_t*)d->rom + d->rom->modes_offset);
dprint(d, 1, "%s: restore mode (%s)\n", __FUNCTION__,
qxl_mode_to_string(d->mode));
newmode = d->mode;
d->mode = QXL_MODE_UNDEFINED;
switch (newmode) {
case QXL_MODE_UNDEFINED:
break;
case QXL_MODE_VGA:
qxl_enter_vga_mode(d);
break;
case QXL_MODE_NATIVE:
for (i = 0; i < NUM_MEMSLOTS; i++) {
if (!d->guest_slots[i].active) {
continue;
}
qxl_add_memslot(d, i, 0, QXL_SYNC);
}
qxl_create_guest_primary(d, 1, QXL_SYNC);
cmds = g_malloc0(sizeof(QXLCommandExt) * (NUM_SURFACES + 1));
for (in = 0, out = 0; in < NUM_SURFACES; in++) {
if (d->guest_surfaces.cmds[in] == 0) {
continue;
}
cmds[out].cmd.data = d->guest_surfaces.cmds[in];
cmds[out].cmd.type = QXL_CMD_SURFACE;
cmds[out].group_id = MEMSLOT_GROUP_GUEST;
out++;
}
cmds[out].cmd.data = d->guest_cursor;
cmds[out].cmd.type = QXL_CMD_CURSOR;
cmds[out].group_id = MEMSLOT_GROUP_GUEST;
out++;
qxl_spice_loadvm_commands(d, cmds, out);
g_free(cmds);
break;
case QXL_MODE_COMPAT:
qxl_set_mode(d, d->shadow_rom.mode, 1);
break;
}
dprint(d, 1, "%s: done\n", __FUNCTION__);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(void *VAR_0, int VAR_1)
{
PCIQXLDevice* d = VAR_0;
uint8_t *ram_start = d->vga.vram_ptr;
QXLCommandExt *cmds;
int VAR_2, VAR_3, VAR_4, VAR_5;
dprint(d, 1, "%s: start\n", __FUNCTION__);
assert(d->last_release_offset < d->vga.vram_size);
if (d->last_release_offset == 0) {
d->last_release = NULL;
} else {
d->last_release = (QXLReleaseInfo *)(ram_start + d->last_release_offset);
}
d->modes = (QXLModes*)((uint8_t*)d->rom + d->rom->modes_offset);
dprint(d, 1, "%s: restore mode (%s)\n", __FUNCTION__,
qxl_mode_to_string(d->mode));
VAR_5 = d->mode;
d->mode = QXL_MODE_UNDEFINED;
switch (VAR_5) {
case QXL_MODE_UNDEFINED:
break;
case QXL_MODE_VGA:
qxl_enter_vga_mode(d);
break;
case QXL_MODE_NATIVE:
for (VAR_4 = 0; VAR_4 < NUM_MEMSLOTS; VAR_4++) {
if (!d->guest_slots[VAR_4].active) {
continue;
}
qxl_add_memslot(d, VAR_4, 0, QXL_SYNC);
}
qxl_create_guest_primary(d, 1, QXL_SYNC);
cmds = g_malloc0(sizeof(QXLCommandExt) * (NUM_SURFACES + 1));
for (VAR_2 = 0, VAR_3 = 0; VAR_2 < NUM_SURFACES; VAR_2++) {
if (d->guest_surfaces.cmds[VAR_2] == 0) {
continue;
}
cmds[VAR_3].cmd.data = d->guest_surfaces.cmds[VAR_2];
cmds[VAR_3].cmd.type = QXL_CMD_SURFACE;
cmds[VAR_3].group_id = MEMSLOT_GROUP_GUEST;
VAR_3++;
}
cmds[VAR_3].cmd.data = d->guest_cursor;
cmds[VAR_3].cmd.type = QXL_CMD_CURSOR;
cmds[VAR_3].group_id = MEMSLOT_GROUP_GUEST;
VAR_3++;
qxl_spice_loadvm_commands(d, cmds, VAR_3);
g_free(cmds);
break;
case QXL_MODE_COMPAT:
qxl_set_mode(d, d->shadow_rom.mode, 1);
break;
}
dprint(d, 1, "%s: done\n", __FUNCTION__);
return 0;
}
| [
"static int FUNC_0(void *VAR_0, int VAR_1)\n{",
"PCIQXLDevice* d = VAR_0;",
"uint8_t *ram_start = d->vga.vram_ptr;",
"QXLCommandExt *cmds;",
"int VAR_2, VAR_3, VAR_4, VAR_5;",
"dprint(d, 1, \"%s: start\\n\", __FUNCTION__);",
"assert(d->last_release_offset < d->vga.vram_size);",
"if (d->last_release_offset == 0) {",
"d->last_release = NULL;",
"} else {",
"d->last_release = (QXLReleaseInfo *)(ram_start + d->last_release_offset);",
"}",
"d->modes = (QXLModes*)((uint8_t*)d->rom + d->rom->modes_offset);",
"dprint(d, 1, \"%s: restore mode (%s)\\n\", __FUNCTION__,\nqxl_mode_to_string(d->mode));",
"VAR_5 = d->mode;",
"d->mode = QXL_MODE_UNDEFINED;",
"switch (VAR_5) {",
"case QXL_MODE_UNDEFINED:\nbreak;",
"case QXL_MODE_VGA:\nqxl_enter_vga_mode(d);",
"break;",
"case QXL_MODE_NATIVE:\nfor (VAR_4 = 0; VAR_4 < NUM_MEMSLOTS; VAR_4++) {",
"if (!d->guest_slots[VAR_4].active) {",
"continue;",
"}",
"qxl_add_memslot(d, VAR_4, 0, QXL_SYNC);",
"}",
"qxl_create_guest_primary(d, 1, QXL_SYNC);",
"cmds = g_malloc0(sizeof(QXLCommandExt) * (NUM_SURFACES + 1));",
"for (VAR_2 = 0, VAR_3 = 0; VAR_2 < NUM_SURFACES; VAR_2++) {",
"if (d->guest_surfaces.cmds[VAR_2] == 0) {",
"continue;",
"}",
"cmds[VAR_3].cmd.data = d->guest_surfaces.cmds[VAR_2];",
"cmds[VAR_3].cmd.type = QXL_CMD_SURFACE;",
"cmds[VAR_3].group_id = MEMSLOT_GROUP_GUEST;",
"VAR_3++;",
"}",
"cmds[VAR_3].cmd.data = d->guest_cursor;",
"cmds[VAR_3].cmd.type = QXL_CMD_CURSOR;",
"cmds[VAR_3].group_id = MEMSLOT_GROUP_GUEST;",
"VAR_3++;",
"qxl_spice_loadvm_commands(d, cmds, VAR_3);",
"g_free(cmds);",
"break;",
"case QXL_MODE_COMPAT:\nqxl_set_mode(d, d->shadow_rom.mode, 1);",
"break;",
"}",
"dprint(d, 1, \"%s: done\\n\", __FUNCTION__);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47,
49
],
[
51,
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113,
115
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
]
] |
23,939 | static void musicpal_init(MachineState *machine)
{
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->initrd_filename;
ARMCPU *cpu;
qemu_irq pic[32];
DeviceState *dev;
DeviceState *i2c_dev;
DeviceState *lcd_dev;
DeviceState *key_dev;
DeviceState *wm8750_dev;
SysBusDevice *s;
I2CBus *i2c;
int i;
unsigned long flash_size;
DriveInfo *dinfo;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *sram = g_new(MemoryRegion, 1);
if (!cpu_model) {
cpu_model = "arm926";
}
cpu = cpu_arm_init(cpu_model);
if (!cpu) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
/* For now we use a fixed - the original - RAM size */
memory_region_init_ram(ram, NULL, "musicpal.ram", MP_RAM_DEFAULT_SIZE,
&error_abort);
vmstate_register_ram_global(ram);
memory_region_add_subregion(address_space_mem, 0, ram);
memory_region_init_ram(sram, NULL, "musicpal.sram", MP_SRAM_SIZE,
&error_abort);
vmstate_register_ram_global(sram);
memory_region_add_subregion(address_space_mem, MP_SRAM_BASE, sram);
dev = sysbus_create_simple(TYPE_MV88W8618_PIC, MP_PIC_BASE,
qdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ));
for (i = 0; i < 32; i++) {
pic[i] = qdev_get_gpio_in(dev, i);
}
sysbus_create_varargs(TYPE_MV88W8618_PIT, MP_PIT_BASE, pic[MP_TIMER1_IRQ],
pic[MP_TIMER2_IRQ], pic[MP_TIMER3_IRQ],
pic[MP_TIMER4_IRQ], NULL);
if (serial_hds[0]) {
serial_mm_init(address_space_mem, MP_UART1_BASE, 2, pic[MP_UART1_IRQ],
1825000, serial_hds[0], DEVICE_NATIVE_ENDIAN);
}
if (serial_hds[1]) {
serial_mm_init(address_space_mem, MP_UART2_BASE, 2, pic[MP_UART2_IRQ],
1825000, serial_hds[1], DEVICE_NATIVE_ENDIAN);
}
/* Register flash */
dinfo = drive_get(IF_PFLASH, 0, 0);
if (dinfo) {
BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo));
flash_size = bdrv_getlength(bs);
if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 &&
flash_size != 32*1024*1024) {
fprintf(stderr, "Invalid flash image size\n");
exit(1);
}
/*
* The original U-Boot accesses the flash at 0xFE000000 instead of
* 0xFF800000 (if there is 8 MB flash). So remap flash access if the
* image is smaller than 32 MB.
*/
#ifdef TARGET_WORDS_BIGENDIAN
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", flash_size,
bs, 0x10000, (flash_size + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / flash_size,
2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 1);
#else
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", flash_size,
bs, 0x10000, (flash_size + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / flash_size,
2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 0);
#endif
}
sysbus_create_simple(TYPE_MV88W8618_FLASHCFG, MP_FLASHCFG_BASE, NULL);
qemu_check_nic_model(&nd_table[0], "mv88w8618");
dev = qdev_create(NULL, TYPE_MV88W8618_ETH);
qdev_set_nic_properties(dev, &nd_table[0]);
qdev_init_nofail(dev);
sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, MP_ETH_BASE);
sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[MP_ETH_IRQ]);
sysbus_create_simple("mv88w8618_wlan", MP_WLAN_BASE, NULL);
sysbus_create_simple(TYPE_MUSICPAL_MISC, MP_MISC_BASE, NULL);
dev = sysbus_create_simple(TYPE_MUSICPAL_GPIO, MP_GPIO_BASE,
pic[MP_GPIO_IRQ]);
i2c_dev = sysbus_create_simple("gpio_i2c", -1, NULL);
i2c = (I2CBus *)qdev_get_child_bus(i2c_dev, "i2c");
lcd_dev = sysbus_create_simple(TYPE_MUSICPAL_LCD, MP_LCD_BASE, NULL);
key_dev = sysbus_create_simple(TYPE_MUSICPAL_KEY, -1, NULL);
/* I2C read data */
qdev_connect_gpio_out(i2c_dev, 0,
qdev_get_gpio_in(dev, MP_GPIO_I2C_DATA_BIT));
/* I2C data */
qdev_connect_gpio_out(dev, 3, qdev_get_gpio_in(i2c_dev, 0));
/* I2C clock */
qdev_connect_gpio_out(dev, 4, qdev_get_gpio_in(i2c_dev, 1));
for (i = 0; i < 3; i++) {
qdev_connect_gpio_out(dev, i, qdev_get_gpio_in(lcd_dev, i));
}
for (i = 0; i < 4; i++) {
qdev_connect_gpio_out(key_dev, i, qdev_get_gpio_in(dev, i + 8));
}
for (i = 4; i < 8; i++) {
qdev_connect_gpio_out(key_dev, i, qdev_get_gpio_in(dev, i + 15));
}
wm8750_dev = i2c_create_slave(i2c, "wm8750", MP_WM_ADDR);
dev = qdev_create(NULL, "mv88w8618_audio");
s = SYS_BUS_DEVICE(dev);
qdev_prop_set_ptr(dev, "wm8750", wm8750_dev);
qdev_init_nofail(dev);
sysbus_mmio_map(s, 0, MP_AUDIO_BASE);
sysbus_connect_irq(s, 0, pic[MP_AUDIO_IRQ]);
musicpal_binfo.ram_size = MP_RAM_DEFAULT_SIZE;
musicpal_binfo.kernel_filename = kernel_filename;
musicpal_binfo.kernel_cmdline = kernel_cmdline;
musicpal_binfo.initrd_filename = initrd_filename;
arm_load_kernel(cpu, &musicpal_binfo);
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | static void musicpal_init(MachineState *machine)
{
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->initrd_filename;
ARMCPU *cpu;
qemu_irq pic[32];
DeviceState *dev;
DeviceState *i2c_dev;
DeviceState *lcd_dev;
DeviceState *key_dev;
DeviceState *wm8750_dev;
SysBusDevice *s;
I2CBus *i2c;
int i;
unsigned long flash_size;
DriveInfo *dinfo;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *sram = g_new(MemoryRegion, 1);
if (!cpu_model) {
cpu_model = "arm926";
}
cpu = cpu_arm_init(cpu_model);
if (!cpu) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
memory_region_init_ram(ram, NULL, "musicpal.ram", MP_RAM_DEFAULT_SIZE,
&error_abort);
vmstate_register_ram_global(ram);
memory_region_add_subregion(address_space_mem, 0, ram);
memory_region_init_ram(sram, NULL, "musicpal.sram", MP_SRAM_SIZE,
&error_abort);
vmstate_register_ram_global(sram);
memory_region_add_subregion(address_space_mem, MP_SRAM_BASE, sram);
dev = sysbus_create_simple(TYPE_MV88W8618_PIC, MP_PIC_BASE,
qdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ));
for (i = 0; i < 32; i++) {
pic[i] = qdev_get_gpio_in(dev, i);
}
sysbus_create_varargs(TYPE_MV88W8618_PIT, MP_PIT_BASE, pic[MP_TIMER1_IRQ],
pic[MP_TIMER2_IRQ], pic[MP_TIMER3_IRQ],
pic[MP_TIMER4_IRQ], NULL);
if (serial_hds[0]) {
serial_mm_init(address_space_mem, MP_UART1_BASE, 2, pic[MP_UART1_IRQ],
1825000, serial_hds[0], DEVICE_NATIVE_ENDIAN);
}
if (serial_hds[1]) {
serial_mm_init(address_space_mem, MP_UART2_BASE, 2, pic[MP_UART2_IRQ],
1825000, serial_hds[1], DEVICE_NATIVE_ENDIAN);
}
dinfo = drive_get(IF_PFLASH, 0, 0);
if (dinfo) {
BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo));
flash_size = bdrv_getlength(bs);
if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 &&
flash_size != 32*1024*1024) {
fprintf(stderr, "Invalid flash image size\n");
exit(1);
}
#ifdef TARGET_WORDS_BIGENDIAN
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", flash_size,
bs, 0x10000, (flash_size + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / flash_size,
2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 1);
#else
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", flash_size,
bs, 0x10000, (flash_size + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / flash_size,
2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 0);
#endif
}
sysbus_create_simple(TYPE_MV88W8618_FLASHCFG, MP_FLASHCFG_BASE, NULL);
qemu_check_nic_model(&nd_table[0], "mv88w8618");
dev = qdev_create(NULL, TYPE_MV88W8618_ETH);
qdev_set_nic_properties(dev, &nd_table[0]);
qdev_init_nofail(dev);
sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, MP_ETH_BASE);
sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[MP_ETH_IRQ]);
sysbus_create_simple("mv88w8618_wlan", MP_WLAN_BASE, NULL);
sysbus_create_simple(TYPE_MUSICPAL_MISC, MP_MISC_BASE, NULL);
dev = sysbus_create_simple(TYPE_MUSICPAL_GPIO, MP_GPIO_BASE,
pic[MP_GPIO_IRQ]);
i2c_dev = sysbus_create_simple("gpio_i2c", -1, NULL);
i2c = (I2CBus *)qdev_get_child_bus(i2c_dev, "i2c");
lcd_dev = sysbus_create_simple(TYPE_MUSICPAL_LCD, MP_LCD_BASE, NULL);
key_dev = sysbus_create_simple(TYPE_MUSICPAL_KEY, -1, NULL);
qdev_connect_gpio_out(i2c_dev, 0,
qdev_get_gpio_in(dev, MP_GPIO_I2C_DATA_BIT));
qdev_connect_gpio_out(dev, 3, qdev_get_gpio_in(i2c_dev, 0));
qdev_connect_gpio_out(dev, 4, qdev_get_gpio_in(i2c_dev, 1));
for (i = 0; i < 3; i++) {
qdev_connect_gpio_out(dev, i, qdev_get_gpio_in(lcd_dev, i));
}
for (i = 0; i < 4; i++) {
qdev_connect_gpio_out(key_dev, i, qdev_get_gpio_in(dev, i + 8));
}
for (i = 4; i < 8; i++) {
qdev_connect_gpio_out(key_dev, i, qdev_get_gpio_in(dev, i + 15));
}
wm8750_dev = i2c_create_slave(i2c, "wm8750", MP_WM_ADDR);
dev = qdev_create(NULL, "mv88w8618_audio");
s = SYS_BUS_DEVICE(dev);
qdev_prop_set_ptr(dev, "wm8750", wm8750_dev);
qdev_init_nofail(dev);
sysbus_mmio_map(s, 0, MP_AUDIO_BASE);
sysbus_connect_irq(s, 0, pic[MP_AUDIO_IRQ]);
musicpal_binfo.ram_size = MP_RAM_DEFAULT_SIZE;
musicpal_binfo.kernel_filename = kernel_filename;
musicpal_binfo.kernel_cmdline = kernel_cmdline;
musicpal_binfo.initrd_filename = initrd_filename;
arm_load_kernel(cpu, &musicpal_binfo);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(MachineState *VAR_0)
{
const char *VAR_1 = VAR_0->VAR_1;
const char *VAR_2 = VAR_0->VAR_2;
const char *VAR_3 = VAR_0->VAR_3;
const char *VAR_4 = VAR_0->VAR_4;
ARMCPU *cpu;
qemu_irq pic[32];
DeviceState *dev;
DeviceState *i2c_dev;
DeviceState *lcd_dev;
DeviceState *key_dev;
DeviceState *wm8750_dev;
SysBusDevice *s;
I2CBus *i2c;
int VAR_5;
unsigned long VAR_6;
DriveInfo *dinfo;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *sram = g_new(MemoryRegion, 1);
if (!VAR_1) {
VAR_1 = "arm926";
}
cpu = cpu_arm_init(VAR_1);
if (!cpu) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
memory_region_init_ram(ram, NULL, "musicpal.ram", MP_RAM_DEFAULT_SIZE,
&error_abort);
vmstate_register_ram_global(ram);
memory_region_add_subregion(address_space_mem, 0, ram);
memory_region_init_ram(sram, NULL, "musicpal.sram", MP_SRAM_SIZE,
&error_abort);
vmstate_register_ram_global(sram);
memory_region_add_subregion(address_space_mem, MP_SRAM_BASE, sram);
dev = sysbus_create_simple(TYPE_MV88W8618_PIC, MP_PIC_BASE,
qdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ));
for (VAR_5 = 0; VAR_5 < 32; VAR_5++) {
pic[VAR_5] = qdev_get_gpio_in(dev, VAR_5);
}
sysbus_create_varargs(TYPE_MV88W8618_PIT, MP_PIT_BASE, pic[MP_TIMER1_IRQ],
pic[MP_TIMER2_IRQ], pic[MP_TIMER3_IRQ],
pic[MP_TIMER4_IRQ], NULL);
if (serial_hds[0]) {
serial_mm_init(address_space_mem, MP_UART1_BASE, 2, pic[MP_UART1_IRQ],
1825000, serial_hds[0], DEVICE_NATIVE_ENDIAN);
}
if (serial_hds[1]) {
serial_mm_init(address_space_mem, MP_UART2_BASE, 2, pic[MP_UART2_IRQ],
1825000, serial_hds[1], DEVICE_NATIVE_ENDIAN);
}
dinfo = drive_get(IF_PFLASH, 0, 0);
if (dinfo) {
BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo));
VAR_6 = bdrv_getlength(bs);
if (VAR_6 != 8*1024*1024 && VAR_6 != 16*1024*1024 &&
VAR_6 != 32*1024*1024) {
fprintf(stderr, "Invalid flash image size\n");
exit(1);
}
#ifdef TARGET_WORDS_BIGENDIAN
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", VAR_6,
bs, 0x10000, (VAR_6 + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / VAR_6,
2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 1);
#else
pflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,
"musicpal.flash", VAR_6,
bs, 0x10000, (VAR_6 + 0xffff) >> 16,
MP_FLASH_SIZE_MAX / VAR_6,
2, 0x00BF, 0x236D, 0x0000, 0x0000,
0x5555, 0x2AAA, 0);
#endif
}
sysbus_create_simple(TYPE_MV88W8618_FLASHCFG, MP_FLASHCFG_BASE, NULL);
qemu_check_nic_model(&nd_table[0], "mv88w8618");
dev = qdev_create(NULL, TYPE_MV88W8618_ETH);
qdev_set_nic_properties(dev, &nd_table[0]);
qdev_init_nofail(dev);
sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, MP_ETH_BASE);
sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[MP_ETH_IRQ]);
sysbus_create_simple("mv88w8618_wlan", MP_WLAN_BASE, NULL);
sysbus_create_simple(TYPE_MUSICPAL_MISC, MP_MISC_BASE, NULL);
dev = sysbus_create_simple(TYPE_MUSICPAL_GPIO, MP_GPIO_BASE,
pic[MP_GPIO_IRQ]);
i2c_dev = sysbus_create_simple("gpio_i2c", -1, NULL);
i2c = (I2CBus *)qdev_get_child_bus(i2c_dev, "i2c");
lcd_dev = sysbus_create_simple(TYPE_MUSICPAL_LCD, MP_LCD_BASE, NULL);
key_dev = sysbus_create_simple(TYPE_MUSICPAL_KEY, -1, NULL);
qdev_connect_gpio_out(i2c_dev, 0,
qdev_get_gpio_in(dev, MP_GPIO_I2C_DATA_BIT));
qdev_connect_gpio_out(dev, 3, qdev_get_gpio_in(i2c_dev, 0));
qdev_connect_gpio_out(dev, 4, qdev_get_gpio_in(i2c_dev, 1));
for (VAR_5 = 0; VAR_5 < 3; VAR_5++) {
qdev_connect_gpio_out(dev, VAR_5, qdev_get_gpio_in(lcd_dev, VAR_5));
}
for (VAR_5 = 0; VAR_5 < 4; VAR_5++) {
qdev_connect_gpio_out(key_dev, VAR_5, qdev_get_gpio_in(dev, VAR_5 + 8));
}
for (VAR_5 = 4; VAR_5 < 8; VAR_5++) {
qdev_connect_gpio_out(key_dev, VAR_5, qdev_get_gpio_in(dev, VAR_5 + 15));
}
wm8750_dev = i2c_create_slave(i2c, "wm8750", MP_WM_ADDR);
dev = qdev_create(NULL, "mv88w8618_audio");
s = SYS_BUS_DEVICE(dev);
qdev_prop_set_ptr(dev, "wm8750", wm8750_dev);
qdev_init_nofail(dev);
sysbus_mmio_map(s, 0, MP_AUDIO_BASE);
sysbus_connect_irq(s, 0, pic[MP_AUDIO_IRQ]);
musicpal_binfo.ram_size = MP_RAM_DEFAULT_SIZE;
musicpal_binfo.VAR_2 = VAR_2;
musicpal_binfo.VAR_3 = VAR_3;
musicpal_binfo.VAR_4 = VAR_4;
arm_load_kernel(cpu, &musicpal_binfo);
}
| [
"static void FUNC_0(MachineState *VAR_0)\n{",
"const char *VAR_1 = VAR_0->VAR_1;",
"const char *VAR_2 = VAR_0->VAR_2;",
"const char *VAR_3 = VAR_0->VAR_3;",
"const char *VAR_4 = VAR_0->VAR_4;",
"ARMCPU *cpu;",
"qemu_irq pic[32];",
"DeviceState *dev;",
"DeviceState *i2c_dev;",
"DeviceState *lcd_dev;",
"DeviceState *key_dev;",
"DeviceState *wm8750_dev;",
"SysBusDevice *s;",
"I2CBus *i2c;",
"int VAR_5;",
"unsigned long VAR_6;",
"DriveInfo *dinfo;",
"MemoryRegion *address_space_mem = get_system_memory();",
"MemoryRegion *ram = g_new(MemoryRegion, 1);",
"MemoryRegion *sram = g_new(MemoryRegion, 1);",
"if (!VAR_1) {",
"VAR_1 = \"arm926\";",
"}",
"cpu = cpu_arm_init(VAR_1);",
"if (!cpu) {",
"fprintf(stderr, \"Unable to find CPU definition\\n\");",
"exit(1);",
"}",
"memory_region_init_ram(ram, NULL, \"musicpal.ram\", MP_RAM_DEFAULT_SIZE,\n&error_abort);",
"vmstate_register_ram_global(ram);",
"memory_region_add_subregion(address_space_mem, 0, ram);",
"memory_region_init_ram(sram, NULL, \"musicpal.sram\", MP_SRAM_SIZE,\n&error_abort);",
"vmstate_register_ram_global(sram);",
"memory_region_add_subregion(address_space_mem, MP_SRAM_BASE, sram);",
"dev = sysbus_create_simple(TYPE_MV88W8618_PIC, MP_PIC_BASE,\nqdev_get_gpio_in(DEVICE(cpu), ARM_CPU_IRQ));",
"for (VAR_5 = 0; VAR_5 < 32; VAR_5++) {",
"pic[VAR_5] = qdev_get_gpio_in(dev, VAR_5);",
"}",
"sysbus_create_varargs(TYPE_MV88W8618_PIT, MP_PIT_BASE, pic[MP_TIMER1_IRQ],\npic[MP_TIMER2_IRQ], pic[MP_TIMER3_IRQ],\npic[MP_TIMER4_IRQ], NULL);",
"if (serial_hds[0]) {",
"serial_mm_init(address_space_mem, MP_UART1_BASE, 2, pic[MP_UART1_IRQ],\n1825000, serial_hds[0], DEVICE_NATIVE_ENDIAN);",
"}",
"if (serial_hds[1]) {",
"serial_mm_init(address_space_mem, MP_UART2_BASE, 2, pic[MP_UART2_IRQ],\n1825000, serial_hds[1], DEVICE_NATIVE_ENDIAN);",
"}",
"dinfo = drive_get(IF_PFLASH, 0, 0);",
"if (dinfo) {",
"BlockDriverState *bs = blk_bs(blk_by_legacy_dinfo(dinfo));",
"VAR_6 = bdrv_getlength(bs);",
"if (VAR_6 != 8*1024*1024 && VAR_6 != 16*1024*1024 &&\nVAR_6 != 32*1024*1024) {",
"fprintf(stderr, \"Invalid flash image size\\n\");",
"exit(1);",
"}",
"#ifdef TARGET_WORDS_BIGENDIAN\npflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,\n\"musicpal.flash\", VAR_6,\nbs, 0x10000, (VAR_6 + 0xffff) >> 16,\nMP_FLASH_SIZE_MAX / VAR_6,\n2, 0x00BF, 0x236D, 0x0000, 0x0000,\n0x5555, 0x2AAA, 1);",
"#else\npflash_cfi02_register(0x100000000ULL-MP_FLASH_SIZE_MAX, NULL,\n\"musicpal.flash\", VAR_6,\nbs, 0x10000, (VAR_6 + 0xffff) >> 16,\nMP_FLASH_SIZE_MAX / VAR_6,\n2, 0x00BF, 0x236D, 0x0000, 0x0000,\n0x5555, 0x2AAA, 0);",
"#endif\n}",
"sysbus_create_simple(TYPE_MV88W8618_FLASHCFG, MP_FLASHCFG_BASE, NULL);",
"qemu_check_nic_model(&nd_table[0], \"mv88w8618\");",
"dev = qdev_create(NULL, TYPE_MV88W8618_ETH);",
"qdev_set_nic_properties(dev, &nd_table[0]);",
"qdev_init_nofail(dev);",
"sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, MP_ETH_BASE);",
"sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[MP_ETH_IRQ]);",
"sysbus_create_simple(\"mv88w8618_wlan\", MP_WLAN_BASE, NULL);",
"sysbus_create_simple(TYPE_MUSICPAL_MISC, MP_MISC_BASE, NULL);",
"dev = sysbus_create_simple(TYPE_MUSICPAL_GPIO, MP_GPIO_BASE,\npic[MP_GPIO_IRQ]);",
"i2c_dev = sysbus_create_simple(\"gpio_i2c\", -1, NULL);",
"i2c = (I2CBus *)qdev_get_child_bus(i2c_dev, \"i2c\");",
"lcd_dev = sysbus_create_simple(TYPE_MUSICPAL_LCD, MP_LCD_BASE, NULL);",
"key_dev = sysbus_create_simple(TYPE_MUSICPAL_KEY, -1, NULL);",
"qdev_connect_gpio_out(i2c_dev, 0,\nqdev_get_gpio_in(dev, MP_GPIO_I2C_DATA_BIT));",
"qdev_connect_gpio_out(dev, 3, qdev_get_gpio_in(i2c_dev, 0));",
"qdev_connect_gpio_out(dev, 4, qdev_get_gpio_in(i2c_dev, 1));",
"for (VAR_5 = 0; VAR_5 < 3; VAR_5++) {",
"qdev_connect_gpio_out(dev, VAR_5, qdev_get_gpio_in(lcd_dev, VAR_5));",
"}",
"for (VAR_5 = 0; VAR_5 < 4; VAR_5++) {",
"qdev_connect_gpio_out(key_dev, VAR_5, qdev_get_gpio_in(dev, VAR_5 + 8));",
"}",
"for (VAR_5 = 4; VAR_5 < 8; VAR_5++) {",
"qdev_connect_gpio_out(key_dev, VAR_5, qdev_get_gpio_in(dev, VAR_5 + 15));",
"}",
"wm8750_dev = i2c_create_slave(i2c, \"wm8750\", MP_WM_ADDR);",
"dev = qdev_create(NULL, \"mv88w8618_audio\");",
"s = SYS_BUS_DEVICE(dev);",
"qdev_prop_set_ptr(dev, \"wm8750\", wm8750_dev);",
"qdev_init_nofail(dev);",
"sysbus_mmio_map(s, 0, MP_AUDIO_BASE);",
"sysbus_connect_irq(s, 0, pic[MP_AUDIO_IRQ]);",
"musicpal_binfo.ram_size = MP_RAM_DEFAULT_SIZE;",
"musicpal_binfo.VAR_2 = VAR_2;",
"musicpal_binfo.VAR_3 = VAR_3;",
"musicpal_binfo.VAR_4 = VAR_4;",
"arm_load_kernel(cpu, &musicpal_binfo);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
65,
67
],
[
69
],
[
71
],
[
75,
77
],
[
79
],
[
81
],
[
85,
87
],
[
89
],
[
91
],
[
93
],
[
95,
97,
99
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133,
135
],
[
137
],
[
139
],
[
141
],
[
155,
157,
159,
161,
163,
165,
167
],
[
169,
171,
173,
175,
177,
179,
181
],
[
183,
187
],
[
189
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
207
],
[
211
],
[
215,
217
],
[
219
],
[
221
],
[
225
],
[
227
],
[
233,
235
],
[
239
],
[
243
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
]
] |
23,940 | static int read_table(AVFormatContext *avctx, AVStream *st,
int (*parse)(AVFormatContext *avctx, AVStream *st,
const char *name, int size))
{
int count, i;
AVIOContext *pb = avctx->pb;
avio_skip(pb, 4);
count = avio_rb32(pb);
avio_skip(pb, 4);
for (i = 0; i < count; i++) {
char name[17];
int size;
avio_read(pb, name, 16);
name[sizeof(name) - 1] = 0;
size = avio_rb32(pb);
if (size < 0) {
av_log(avctx, AV_LOG_ERROR, "entry size %d is invalid\n", size);
return AVERROR_INVALIDDATA;
}
if (parse(avctx, st, name, size) < 0) {
avpriv_request_sample(avctx, "Variable %s", name);
avio_skip(pb, size);
}
}
return 0;
}
| false | FFmpeg | 3f4fccf4d6d2a9a6db46bfca0e6fb648d8e3708b | static int read_table(AVFormatContext *avctx, AVStream *st,
int (*parse)(AVFormatContext *avctx, AVStream *st,
const char *name, int size))
{
int count, i;
AVIOContext *pb = avctx->pb;
avio_skip(pb, 4);
count = avio_rb32(pb);
avio_skip(pb, 4);
for (i = 0; i < count; i++) {
char name[17];
int size;
avio_read(pb, name, 16);
name[sizeof(name) - 1] = 0;
size = avio_rb32(pb);
if (size < 0) {
av_log(avctx, AV_LOG_ERROR, "entry size %d is invalid\n", size);
return AVERROR_INVALIDDATA;
}
if (parse(avctx, st, name, size) < 0) {
avpriv_request_sample(avctx, "Variable %s", name);
avio_skip(pb, size);
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_3, AVStream *VAR_3,
int (*VAR_2)(AVFormatContext *VAR_3, AVStream *VAR_3,
const char *VAR_7, int VAR_7))
{
int VAR_5, VAR_6;
AVIOContext *pb = VAR_3->pb;
avio_skip(pb, 4);
VAR_5 = avio_rb32(pb);
avio_skip(pb, 4);
for (VAR_6 = 0; VAR_6 < VAR_5; VAR_6++) {
char VAR_7[17];
int VAR_7;
avio_read(pb, VAR_7, 16);
VAR_7[sizeof(VAR_7) - 1] = 0;
VAR_7 = avio_rb32(pb);
if (VAR_7 < 0) {
av_log(VAR_3, AV_LOG_ERROR, "entry VAR_7 %d is invalid\n", VAR_7);
return AVERROR_INVALIDDATA;
}
if (VAR_2(VAR_3, VAR_3, VAR_7, VAR_7) < 0) {
avpriv_request_sample(VAR_3, "Variable %s", VAR_7);
avio_skip(pb, VAR_7);
}
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_3, AVStream *VAR_3,\nint (*VAR_2)(AVFormatContext *VAR_3, AVStream *VAR_3,\nconst char *VAR_7, int VAR_7))\n{",
"int VAR_5, VAR_6;",
"AVIOContext *pb = VAR_3->pb;",
"avio_skip(pb, 4);",
"VAR_5 = avio_rb32(pb);",
"avio_skip(pb, 4);",
"for (VAR_6 = 0; VAR_6 < VAR_5; VAR_6++) {",
"char VAR_7[17];",
"int VAR_7;",
"avio_read(pb, VAR_7, 16);",
"VAR_7[sizeof(VAR_7) - 1] = 0;",
"VAR_7 = avio_rb32(pb);",
"if (VAR_7 < 0) {",
"av_log(VAR_3, AV_LOG_ERROR, \"entry VAR_7 %d is invalid\\n\", VAR_7);",
"return AVERROR_INVALIDDATA;",
"}",
"if (VAR_2(VAR_3, VAR_3, VAR_7, VAR_7) < 0) {",
"avpriv_request_sample(VAR_3, \"Variable %s\", VAR_7);",
"avio_skip(pb, VAR_7);",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
]
] |
23,941 | int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f)
{
uint8_t buf[4096];
target_phys_addr_t dst_begin = dst_addr;
size_t want, did;
while (nbytes) {
want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;
did = fread(buf, 1, want, f);
cpu_physical_memory_write_rom(dst_addr, buf, did);
dst_addr += did;
nbytes -= did;
if (did != want)
break;
}
return dst_addr - dst_begin;
}
| false | qemu | 45a50b1668822c23afc2a89f724654e176518bc4 | int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f)
{
uint8_t buf[4096];
target_phys_addr_t dst_begin = dst_addr;
size_t want, did;
while (nbytes) {
want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;
did = fread(buf, 1, want, f);
cpu_physical_memory_write_rom(dst_addr, buf, did);
dst_addr += did;
nbytes -= did;
if (did != want)
break;
}
return dst_addr - dst_begin;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(target_phys_addr_t VAR_0, size_t VAR_1, FILE *VAR_2)
{
uint8_t buf[4096];
target_phys_addr_t dst_begin = VAR_0;
size_t want, did;
while (VAR_1) {
want = VAR_1 > sizeof(buf) ? sizeof(buf) : VAR_1;
did = fread(buf, 1, want, VAR_2);
cpu_physical_memory_write_rom(VAR_0, buf, did);
VAR_0 += did;
VAR_1 -= did;
if (did != want)
break;
}
return VAR_0 - dst_begin;
}
| [
"int FUNC_0(target_phys_addr_t VAR_0, size_t VAR_1, FILE *VAR_2)\n{",
"uint8_t buf[4096];",
"target_phys_addr_t dst_begin = VAR_0;",
"size_t want, did;",
"while (VAR_1) {",
"want = VAR_1 > sizeof(buf) ? sizeof(buf) : VAR_1;",
"did = fread(buf, 1, want, VAR_2);",
"cpu_physical_memory_write_rom(VAR_0, buf, did);",
"VAR_0 += did;",
"VAR_1 -= did;",
"if (did != want)\nbreak;",
"}",
"return VAR_0 - dst_begin;",
"}"
] | [
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
]
] |
23,943 | void avpriv_do_elbg(int *points, int dim, int numpoints, int *codebook,
int numCB, int max_steps, int *closest_cb,
AVLFG *rand_state)
{
int dist;
elbg_data elbg_d;
elbg_data *elbg = &elbg_d;
int i, j, k, last_error, steps=0;
int *dist_cb = av_malloc(numpoints*sizeof(int));
int *size_part = av_malloc(numCB*sizeof(int));
cell *list_buffer = av_malloc(numpoints*sizeof(cell));
cell *free_cells;
int best_dist, best_idx = 0;
elbg->error = INT_MAX;
elbg->dim = dim;
elbg->numCB = numCB;
elbg->codebook = codebook;
elbg->cells = av_malloc(numCB*sizeof(cell *));
elbg->utility = av_malloc(numCB*sizeof(int));
elbg->nearest_cb = closest_cb;
elbg->points = points;
elbg->utility_inc = av_malloc(numCB*sizeof(int));
elbg->scratchbuf = av_malloc(5*dim*sizeof(int));
elbg->rand_state = rand_state;
do {
free_cells = list_buffer;
last_error = elbg->error;
steps++;
memset(elbg->utility, 0, numCB*sizeof(int));
memset(elbg->cells, 0, numCB*sizeof(cell *));
elbg->error = 0;
/* This loop evaluate the actual Voronoi partition. It is the most
costly part of the algorithm. */
for (i=0; i < numpoints; i++) {
best_dist = distance_limited(elbg->points + i*elbg->dim, elbg->codebook + best_idx*elbg->dim, dim, INT_MAX);
for (k=0; k < elbg->numCB; k++) {
dist = distance_limited(elbg->points + i*elbg->dim, elbg->codebook + k*elbg->dim, dim, best_dist);
if (dist < best_dist) {
best_dist = dist;
best_idx = k;
}
}
elbg->nearest_cb[i] = best_idx;
dist_cb[i] = best_dist;
elbg->error += dist_cb[i];
elbg->utility[elbg->nearest_cb[i]] += dist_cb[i];
free_cells->index = i;
free_cells->next = elbg->cells[elbg->nearest_cb[i]];
elbg->cells[elbg->nearest_cb[i]] = free_cells;
free_cells++;
}
do_shiftings(elbg);
memset(size_part, 0, numCB*sizeof(int));
memset(elbg->codebook, 0, elbg->numCB*dim*sizeof(int));
for (i=0; i < numpoints; i++) {
size_part[elbg->nearest_cb[i]]++;
for (j=0; j < elbg->dim; j++)
elbg->codebook[elbg->nearest_cb[i]*elbg->dim + j] +=
elbg->points[i*elbg->dim + j];
}
for (i=0; i < elbg->numCB; i++)
vect_division(elbg->codebook + i*elbg->dim,
elbg->codebook + i*elbg->dim, size_part[i], elbg->dim);
} while(((last_error - elbg->error) > DELTA_ERR_MAX*elbg->error) &&
(steps < max_steps));
av_free(dist_cb);
av_free(size_part);
av_free(elbg->utility);
av_free(list_buffer);
av_free(elbg->cells);
av_free(elbg->utility_inc);
av_free(elbg->scratchbuf);
}
| true | FFmpeg | 87ecefdab0097537c5c30014e57b19113ab05eee | void avpriv_do_elbg(int *points, int dim, int numpoints, int *codebook,
int numCB, int max_steps, int *closest_cb,
AVLFG *rand_state)
{
int dist;
elbg_data elbg_d;
elbg_data *elbg = &elbg_d;
int i, j, k, last_error, steps=0;
int *dist_cb = av_malloc(numpoints*sizeof(int));
int *size_part = av_malloc(numCB*sizeof(int));
cell *list_buffer = av_malloc(numpoints*sizeof(cell));
cell *free_cells;
int best_dist, best_idx = 0;
elbg->error = INT_MAX;
elbg->dim = dim;
elbg->numCB = numCB;
elbg->codebook = codebook;
elbg->cells = av_malloc(numCB*sizeof(cell *));
elbg->utility = av_malloc(numCB*sizeof(int));
elbg->nearest_cb = closest_cb;
elbg->points = points;
elbg->utility_inc = av_malloc(numCB*sizeof(int));
elbg->scratchbuf = av_malloc(5*dim*sizeof(int));
elbg->rand_state = rand_state;
do {
free_cells = list_buffer;
last_error = elbg->error;
steps++;
memset(elbg->utility, 0, numCB*sizeof(int));
memset(elbg->cells, 0, numCB*sizeof(cell *));
elbg->error = 0;
for (i=0; i < numpoints; i++) {
best_dist = distance_limited(elbg->points + i*elbg->dim, elbg->codebook + best_idx*elbg->dim, dim, INT_MAX);
for (k=0; k < elbg->numCB; k++) {
dist = distance_limited(elbg->points + i*elbg->dim, elbg->codebook + k*elbg->dim, dim, best_dist);
if (dist < best_dist) {
best_dist = dist;
best_idx = k;
}
}
elbg->nearest_cb[i] = best_idx;
dist_cb[i] = best_dist;
elbg->error += dist_cb[i];
elbg->utility[elbg->nearest_cb[i]] += dist_cb[i];
free_cells->index = i;
free_cells->next = elbg->cells[elbg->nearest_cb[i]];
elbg->cells[elbg->nearest_cb[i]] = free_cells;
free_cells++;
}
do_shiftings(elbg);
memset(size_part, 0, numCB*sizeof(int));
memset(elbg->codebook, 0, elbg->numCB*dim*sizeof(int));
for (i=0; i < numpoints; i++) {
size_part[elbg->nearest_cb[i]]++;
for (j=0; j < elbg->dim; j++)
elbg->codebook[elbg->nearest_cb[i]*elbg->dim + j] +=
elbg->points[i*elbg->dim + j];
}
for (i=0; i < elbg->numCB; i++)
vect_division(elbg->codebook + i*elbg->dim,
elbg->codebook + i*elbg->dim, size_part[i], elbg->dim);
} while(((last_error - elbg->error) > DELTA_ERR_MAX*elbg->error) &&
(steps < max_steps));
av_free(dist_cb);
av_free(size_part);
av_free(elbg->utility);
av_free(list_buffer);
av_free(elbg->cells);
av_free(elbg->utility_inc);
av_free(elbg->scratchbuf);
}
| {
"code": [
" elbg->utility_inc = av_malloc(numCB*sizeof(int));"
],
"line_no": [
45
]
} | void FUNC_0(int *VAR_0, int VAR_1, int VAR_2, int *VAR_3,
int VAR_4, int VAR_5, int *VAR_6,
AVLFG *VAR_7)
{
int VAR_8;
elbg_data elbg_d;
elbg_data *elbg = &elbg_d;
int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13=0;
int *VAR_14 = av_malloc(VAR_2*sizeof(int));
int *VAR_15 = av_malloc(VAR_4*sizeof(int));
cell *list_buffer = av_malloc(VAR_2*sizeof(cell));
cell *free_cells;
int VAR_16, VAR_17 = 0;
elbg->error = INT_MAX;
elbg->VAR_1 = VAR_1;
elbg->VAR_4 = VAR_4;
elbg->VAR_3 = VAR_3;
elbg->cells = av_malloc(VAR_4*sizeof(cell *));
elbg->utility = av_malloc(VAR_4*sizeof(int));
elbg->nearest_cb = VAR_6;
elbg->VAR_0 = VAR_0;
elbg->utility_inc = av_malloc(VAR_4*sizeof(int));
elbg->scratchbuf = av_malloc(5*VAR_1*sizeof(int));
elbg->VAR_7 = VAR_7;
do {
free_cells = list_buffer;
VAR_12 = elbg->error;
VAR_13++;
memset(elbg->utility, 0, VAR_4*sizeof(int));
memset(elbg->cells, 0, VAR_4*sizeof(cell *));
elbg->error = 0;
for (VAR_9=0; VAR_9 < VAR_2; VAR_9++) {
VAR_16 = distance_limited(elbg->VAR_0 + VAR_9*elbg->VAR_1, elbg->VAR_3 + VAR_17*elbg->VAR_1, VAR_1, INT_MAX);
for (VAR_11=0; VAR_11 < elbg->VAR_4; VAR_11++) {
VAR_8 = distance_limited(elbg->VAR_0 + VAR_9*elbg->VAR_1, elbg->VAR_3 + VAR_11*elbg->VAR_1, VAR_1, VAR_16);
if (VAR_8 < VAR_16) {
VAR_16 = VAR_8;
VAR_17 = VAR_11;
}
}
elbg->nearest_cb[VAR_9] = VAR_17;
VAR_14[VAR_9] = VAR_16;
elbg->error += VAR_14[VAR_9];
elbg->utility[elbg->nearest_cb[VAR_9]] += VAR_14[VAR_9];
free_cells->index = VAR_9;
free_cells->next = elbg->cells[elbg->nearest_cb[VAR_9]];
elbg->cells[elbg->nearest_cb[VAR_9]] = free_cells;
free_cells++;
}
do_shiftings(elbg);
memset(VAR_15, 0, VAR_4*sizeof(int));
memset(elbg->VAR_3, 0, elbg->VAR_4*VAR_1*sizeof(int));
for (VAR_9=0; VAR_9 < VAR_2; VAR_9++) {
VAR_15[elbg->nearest_cb[VAR_9]]++;
for (VAR_10=0; VAR_10 < elbg->VAR_1; VAR_10++)
elbg->VAR_3[elbg->nearest_cb[VAR_9]*elbg->VAR_1 + VAR_10] +=
elbg->VAR_0[VAR_9*elbg->VAR_1 + VAR_10];
}
for (VAR_9=0; VAR_9 < elbg->VAR_4; VAR_9++)
vect_division(elbg->VAR_3 + VAR_9*elbg->VAR_1,
elbg->VAR_3 + VAR_9*elbg->VAR_1, VAR_15[VAR_9], elbg->VAR_1);
} while(((VAR_12 - elbg->error) > DELTA_ERR_MAX*elbg->error) &&
(VAR_13 < VAR_5));
av_free(VAR_14);
av_free(VAR_15);
av_free(elbg->utility);
av_free(list_buffer);
av_free(elbg->cells);
av_free(elbg->utility_inc);
av_free(elbg->scratchbuf);
}
| [
"void FUNC_0(int *VAR_0, int VAR_1, int VAR_2, int *VAR_3,\nint VAR_4, int VAR_5, int *VAR_6,\nAVLFG *VAR_7)\n{",
"int VAR_8;",
"elbg_data elbg_d;",
"elbg_data *elbg = &elbg_d;",
"int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13=0;",
"int *VAR_14 = av_malloc(VAR_2*sizeof(int));",
"int *VAR_15 = av_malloc(VAR_4*sizeof(int));",
"cell *list_buffer = av_malloc(VAR_2*sizeof(cell));",
"cell *free_cells;",
"int VAR_16, VAR_17 = 0;",
"elbg->error = INT_MAX;",
"elbg->VAR_1 = VAR_1;",
"elbg->VAR_4 = VAR_4;",
"elbg->VAR_3 = VAR_3;",
"elbg->cells = av_malloc(VAR_4*sizeof(cell *));",
"elbg->utility = av_malloc(VAR_4*sizeof(int));",
"elbg->nearest_cb = VAR_6;",
"elbg->VAR_0 = VAR_0;",
"elbg->utility_inc = av_malloc(VAR_4*sizeof(int));",
"elbg->scratchbuf = av_malloc(5*VAR_1*sizeof(int));",
"elbg->VAR_7 = VAR_7;",
"do {",
"free_cells = list_buffer;",
"VAR_12 = elbg->error;",
"VAR_13++;",
"memset(elbg->utility, 0, VAR_4*sizeof(int));",
"memset(elbg->cells, 0, VAR_4*sizeof(cell *));",
"elbg->error = 0;",
"for (VAR_9=0; VAR_9 < VAR_2; VAR_9++) {",
"VAR_16 = distance_limited(elbg->VAR_0 + VAR_9*elbg->VAR_1, elbg->VAR_3 + VAR_17*elbg->VAR_1, VAR_1, INT_MAX);",
"for (VAR_11=0; VAR_11 < elbg->VAR_4; VAR_11++) {",
"VAR_8 = distance_limited(elbg->VAR_0 + VAR_9*elbg->VAR_1, elbg->VAR_3 + VAR_11*elbg->VAR_1, VAR_1, VAR_16);",
"if (VAR_8 < VAR_16) {",
"VAR_16 = VAR_8;",
"VAR_17 = VAR_11;",
"}",
"}",
"elbg->nearest_cb[VAR_9] = VAR_17;",
"VAR_14[VAR_9] = VAR_16;",
"elbg->error += VAR_14[VAR_9];",
"elbg->utility[elbg->nearest_cb[VAR_9]] += VAR_14[VAR_9];",
"free_cells->index = VAR_9;",
"free_cells->next = elbg->cells[elbg->nearest_cb[VAR_9]];",
"elbg->cells[elbg->nearest_cb[VAR_9]] = free_cells;",
"free_cells++;",
"}",
"do_shiftings(elbg);",
"memset(VAR_15, 0, VAR_4*sizeof(int));",
"memset(elbg->VAR_3, 0, elbg->VAR_4*VAR_1*sizeof(int));",
"for (VAR_9=0; VAR_9 < VAR_2; VAR_9++) {",
"VAR_15[elbg->nearest_cb[VAR_9]]++;",
"for (VAR_10=0; VAR_10 < elbg->VAR_1; VAR_10++)",
"elbg->VAR_3[elbg->nearest_cb[VAR_9]*elbg->VAR_1 + VAR_10] +=\nelbg->VAR_0[VAR_9*elbg->VAR_1 + VAR_10];",
"}",
"for (VAR_9=0; VAR_9 < elbg->VAR_4; VAR_9++)",
"vect_division(elbg->VAR_3 + VAR_9*elbg->VAR_1,\nelbg->VAR_3 + VAR_9*elbg->VAR_1, VAR_15[VAR_9], elbg->VAR_1);",
"} while(((VAR_12 - elbg->error) > DELTA_ERR_MAX*elbg->error) &&",
"(VAR_13 < VAR_5));",
"av_free(VAR_14);",
"av_free(VAR_15);",
"av_free(elbg->utility);",
"av_free(list_buffer);",
"av_free(elbg->cells);",
"av_free(elbg->utility_inc);",
"av_free(elbg->scratchbuf);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
119
],
[
123
],
[
127
],
[
129
],
[
131
],
[
133,
135
],
[
137
],
[
141
],
[
143,
145
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
]
] |
23,944 | void qmp_blockdev_change_medium(const char *device, const char *filename,
bool has_format, const char *format,
bool has_read_only,
BlockdevChangeReadOnlyMode read_only,
Error **errp)
{
BlockBackend *blk;
BlockDriverState *medium_bs = NULL;
int bdrv_flags, ret;
QDict *options = NULL;
Error *err = NULL;
blk = blk_by_name(device);
if (!blk) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", device);
goto fail;
}
if (blk_bs(blk)) {
blk_update_root_state(blk);
}
bdrv_flags = blk_get_open_flags_from_root_state(blk);
if (!has_read_only) {
read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
}
switch (read_only) {
case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:
break;
case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:
bdrv_flags &= ~BDRV_O_RDWR;
break;
case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:
bdrv_flags |= BDRV_O_RDWR;
break;
default:
abort();
}
if (has_format) {
options = qdict_new();
qdict_put(options, "driver", qstring_from_str(format));
}
assert(!medium_bs);
ret = bdrv_open(&medium_bs, filename, NULL, options, bdrv_flags, errp);
if (ret < 0) {
goto fail;
}
blk_apply_root_state(blk, medium_bs);
bdrv_add_key(medium_bs, NULL, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_blockdev_open_tray(device, false, false, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_x_blockdev_remove_medium(device, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_blockdev_insert_anon_medium(device, medium_bs, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_blockdev_close_tray(device, errp);
fail:
/* If the medium has been inserted, the device has its own reference, so
* ours must be relinquished; and if it has not been inserted successfully,
* the reference must be relinquished anyway */
bdrv_unref(medium_bs);
} | true | qemu | 156abc2f901617834307d93f3c066250957f75b1 | void qmp_blockdev_change_medium(const char *device, const char *filename,
bool has_format, const char *format,
bool has_read_only,
BlockdevChangeReadOnlyMode read_only,
Error **errp)
{
BlockBackend *blk;
BlockDriverState *medium_bs = NULL;
int bdrv_flags, ret;
QDict *options = NULL;
Error *err = NULL;
blk = blk_by_name(device);
if (!blk) {
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", device);
goto fail;
}
if (blk_bs(blk)) {
blk_update_root_state(blk);
}
bdrv_flags = blk_get_open_flags_from_root_state(blk);
if (!has_read_only) {
read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
}
switch (read_only) {
case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:
break;
case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:
bdrv_flags &= ~BDRV_O_RDWR;
break;
case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:
bdrv_flags |= BDRV_O_RDWR;
break;
default:
abort();
}
if (has_format) {
options = qdict_new();
qdict_put(options, "driver", qstring_from_str(format));
}
assert(!medium_bs);
ret = bdrv_open(&medium_bs, filename, NULL, options, bdrv_flags, errp);
if (ret < 0) {
goto fail;
}
blk_apply_root_state(blk, medium_bs);
bdrv_add_key(medium_bs, NULL, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_blockdev_open_tray(device, false, false, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_x_blockdev_remove_medium(device, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_blockdev_insert_anon_medium(device, medium_bs, &err);
if (err) {
error_propagate(errp, err);
goto fail;
}
qmp_blockdev_close_tray(device, errp);
fail:
bdrv_unref(medium_bs);
} | {
"code": [],
"line_no": []
} | void FUNC_0(const char *VAR_0, const char *VAR_1,
bool VAR_2, const char *VAR_3,
bool VAR_4,
BlockdevChangeReadOnlyMode VAR_5,
Error **VAR_6)
{
BlockBackend *blk;
BlockDriverState *medium_bs = NULL;
int VAR_7, VAR_8;
QDict *options = NULL;
Error *err = NULL;
blk = blk_by_name(VAR_0);
if (!blk) {
error_set(VAR_6, ERROR_CLASS_DEVICE_NOT_FOUND,
"Device '%s' not found", VAR_0);
goto fail;
}
if (blk_bs(blk)) {
blk_update_root_state(blk);
}
VAR_7 = blk_get_open_flags_from_root_state(blk);
if (!VAR_4) {
VAR_5 = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;
}
switch (VAR_5) {
case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:
break;
case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:
VAR_7 &= ~BDRV_O_RDWR;
break;
case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:
VAR_7 |= BDRV_O_RDWR;
break;
default:
abort();
}
if (VAR_2) {
options = qdict_new();
qdict_put(options, "driver", qstring_from_str(VAR_3));
}
assert(!medium_bs);
VAR_8 = bdrv_open(&medium_bs, VAR_1, NULL, options, VAR_7, VAR_6);
if (VAR_8 < 0) {
goto fail;
}
blk_apply_root_state(blk, medium_bs);
bdrv_add_key(medium_bs, NULL, &err);
if (err) {
error_propagate(VAR_6, err);
goto fail;
}
qmp_blockdev_open_tray(VAR_0, false, false, &err);
if (err) {
error_propagate(VAR_6, err);
goto fail;
}
qmp_x_blockdev_remove_medium(VAR_0, &err);
if (err) {
error_propagate(VAR_6, err);
goto fail;
}
qmp_blockdev_insert_anon_medium(VAR_0, medium_bs, &err);
if (err) {
error_propagate(VAR_6, err);
goto fail;
}
qmp_blockdev_close_tray(VAR_0, VAR_6);
fail:
bdrv_unref(medium_bs);
} | [
"void FUNC_0(const char *VAR_0, const char *VAR_1,\nbool VAR_2, const char *VAR_3,\nbool VAR_4,\nBlockdevChangeReadOnlyMode VAR_5,\nError **VAR_6)\n{",
"BlockBackend *blk;",
"BlockDriverState *medium_bs = NULL;",
"int VAR_7, VAR_8;",
"QDict *options = NULL;",
"Error *err = NULL;",
"blk = blk_by_name(VAR_0);",
"if (!blk) {",
"error_set(VAR_6, ERROR_CLASS_DEVICE_NOT_FOUND,\n\"Device '%s' not found\", VAR_0);",
"goto fail;",
"}",
"if (blk_bs(blk)) {",
"blk_update_root_state(blk);",
"}",
"VAR_7 = blk_get_open_flags_from_root_state(blk);",
"if (!VAR_4) {",
"VAR_5 = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN;",
"}",
"switch (VAR_5) {",
"case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN:\nbreak;",
"case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY:\nVAR_7 &= ~BDRV_O_RDWR;",
"break;",
"case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE:\nVAR_7 |= BDRV_O_RDWR;",
"break;",
"default:\nabort();",
"}",
"if (VAR_2) {",
"options = qdict_new();",
"qdict_put(options, \"driver\", qstring_from_str(VAR_3));",
"}",
"assert(!medium_bs);",
"VAR_8 = bdrv_open(&medium_bs, VAR_1, NULL, options, VAR_7, VAR_6);",
"if (VAR_8 < 0) {",
"goto fail;",
"}",
"blk_apply_root_state(blk, medium_bs);",
"bdrv_add_key(medium_bs, NULL, &err);",
"if (err) {",
"error_propagate(VAR_6, err);",
"goto fail;",
"}",
"qmp_blockdev_open_tray(VAR_0, false, false, &err);",
"if (err) {",
"error_propagate(VAR_6, err);",
"goto fail;",
"}",
"qmp_x_blockdev_remove_medium(VAR_0, &err);",
"if (err) {",
"error_propagate(VAR_6, err);",
"goto fail;",
"}",
"qmp_blockdev_insert_anon_medium(VAR_0, medium_bs, &err);",
"if (err) {",
"error_propagate(VAR_6, err);",
"goto fail;",
"}",
"qmp_blockdev_close_tray(VAR_0, VAR_6);",
"fail:\nbdrv_unref(medium_bs);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
47
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63,
65
],
[
69,
71
],
[
73
],
[
77,
79
],
[
81
],
[
85,
87
],
[
89
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
171,
179
],
[
181
]
] |
23,945 | static void v9fs_link(void *opaque)
{
V9fsPDU *pdu = opaque;
int32_t dfid, oldfid;
V9fsFidState *dfidp, *oldfidp;
V9fsString name;
size_t offset = 7;
int err = 0;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
if (err < 0) {
trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);
if (name_is_illegal(name.data)) {
err = -ENOENT;
dfidp = get_fid(pdu, dfid);
if (dfidp == NULL) {
err = -ENOENT;
oldfidp = get_fid(pdu, oldfid);
if (oldfidp == NULL) {
err = -ENOENT;
goto out;
err = v9fs_co_link(pdu, oldfidp, dfidp, &name);
if (!err) {
err = offset;
out:
put_fid(pdu, dfidp);
out_nofid:
v9fs_string_free(&name);
pdu_complete(pdu, err); | true | qemu | 805b5d98c649d26fc44d2d7755a97f18e62b438a | static void v9fs_link(void *opaque)
{
V9fsPDU *pdu = opaque;
int32_t dfid, oldfid;
V9fsFidState *dfidp, *oldfidp;
V9fsString name;
size_t offset = 7;
int err = 0;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
if (err < 0) {
trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);
if (name_is_illegal(name.data)) {
err = -ENOENT;
dfidp = get_fid(pdu, dfid);
if (dfidp == NULL) {
err = -ENOENT;
oldfidp = get_fid(pdu, oldfid);
if (oldfidp == NULL) {
err = -ENOENT;
goto out;
err = v9fs_co_link(pdu, oldfidp, dfidp, &name);
if (!err) {
err = offset;
out:
put_fid(pdu, dfidp);
out_nofid:
v9fs_string_free(&name);
pdu_complete(pdu, err); | {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
V9fsPDU *pdu = VAR_0;
int32_t dfid, oldfid;
V9fsFidState *dfidp, *oldfidp;
V9fsString name;
size_t offset = 7;
int VAR_1 = 0;
v9fs_string_init(&name);
VAR_1 = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
if (VAR_1 < 0) {
trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);
if (name_is_illegal(name.data)) {
VAR_1 = -ENOENT;
dfidp = get_fid(pdu, dfid);
if (dfidp == NULL) {
VAR_1 = -ENOENT;
oldfidp = get_fid(pdu, oldfid);
if (oldfidp == NULL) {
VAR_1 = -ENOENT;
goto out;
VAR_1 = v9fs_co_link(pdu, oldfidp, dfidp, &name);
if (!VAR_1) {
VAR_1 = offset;
out:
put_fid(pdu, dfidp);
out_nofid:
v9fs_string_free(&name);
pdu_complete(pdu, VAR_1); | [
"static void FUNC_0(void *VAR_0)\n{",
"V9fsPDU *pdu = VAR_0;",
"int32_t dfid, oldfid;",
"V9fsFidState *dfidp, *oldfidp;",
"V9fsString name;",
"size_t offset = 7;",
"int VAR_1 = 0;",
"v9fs_string_init(&name);",
"VAR_1 = pdu_unmarshal(pdu, offset, \"dds\", &dfid, &oldfid, &name);",
"if (VAR_1 < 0) {",
"trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.data);",
"if (name_is_illegal(name.data)) {",
"VAR_1 = -ENOENT;",
"dfidp = get_fid(pdu, dfid);",
"if (dfidp == NULL) {",
"VAR_1 = -ENOENT;",
"oldfidp = get_fid(pdu, oldfid);",
"if (oldfidp == NULL) {",
"VAR_1 = -ENOENT;",
"goto out;",
"VAR_1 = v9fs_co_link(pdu, oldfidp, dfidp, &name);",
"if (!VAR_1) {",
"VAR_1 = offset;",
"out:\nput_fid(pdu, dfidp);",
"out_nofid:\nv9fs_string_free(&name);",
"pdu_complete(pdu, VAR_1);"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22
],
[
23
],
[
24
],
[
25,
26
],
[
27,
28
],
[
29
]
] |
23,946 | static PCIDevice *nic_init(PCIBus * bus, NICInfo * nd, uint32_t device)
{
PCIEEPRO100State *d;
EEPRO100State *s;
logout("\n");
d = (PCIEEPRO100State *) pci_register_device(bus, nd->model,
sizeof(PCIEEPRO100State), -1,
NULL, NULL);
s = &d->eepro100;
s->device = device;
s->pci_dev = &d->dev;
pci_reset(s);
/* Add 64 * 2 EEPROM. i82557 and i82558 support a 64 word EEPROM,
* i82559 and later support 64 or 256 word EEPROM. */
s->eeprom = eeprom93xx_new(EEPROM_SIZE);
/* Handler for memory-mapped I/O */
d->eepro100.mmio_index =
cpu_register_io_memory(0, pci_mmio_read, pci_mmio_write, s);
pci_register_io_region(&d->dev, 0, PCI_MEM_SIZE,
PCI_ADDRESS_SPACE_MEM |
PCI_ADDRESS_SPACE_MEM_PREFETCH, pci_mmio_map);
pci_register_io_region(&d->dev, 1, PCI_IO_SIZE, PCI_ADDRESS_SPACE_IO,
pci_map);
pci_register_io_region(&d->dev, 2, PCI_FLASH_SIZE, PCI_ADDRESS_SPACE_MEM,
pci_mmio_map);
memcpy(s->macaddr, nd->macaddr, 6);
logout("macaddr: %s\n", nic_dump(&s->macaddr[0], 6));
assert(s->region[1] == 0);
nic_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
nic_receive, nic_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
qemu_register_reset(nic_reset, s);
register_savevm(s->vc->model, -1, 3, nic_save, nic_load, s);
return (PCIDevice *)d;
}
| true | qemu | b946a1533209f61a93e34898aebb5b43154b99c3 | static PCIDevice *nic_init(PCIBus * bus, NICInfo * nd, uint32_t device)
{
PCIEEPRO100State *d;
EEPRO100State *s;
logout("\n");
d = (PCIEEPRO100State *) pci_register_device(bus, nd->model,
sizeof(PCIEEPRO100State), -1,
NULL, NULL);
s = &d->eepro100;
s->device = device;
s->pci_dev = &d->dev;
pci_reset(s);
s->eeprom = eeprom93xx_new(EEPROM_SIZE);
d->eepro100.mmio_index =
cpu_register_io_memory(0, pci_mmio_read, pci_mmio_write, s);
pci_register_io_region(&d->dev, 0, PCI_MEM_SIZE,
PCI_ADDRESS_SPACE_MEM |
PCI_ADDRESS_SPACE_MEM_PREFETCH, pci_mmio_map);
pci_register_io_region(&d->dev, 1, PCI_IO_SIZE, PCI_ADDRESS_SPACE_IO,
pci_map);
pci_register_io_region(&d->dev, 2, PCI_FLASH_SIZE, PCI_ADDRESS_SPACE_MEM,
pci_mmio_map);
memcpy(s->macaddr, nd->macaddr, 6);
logout("macaddr: %s\n", nic_dump(&s->macaddr[0], 6));
assert(s->region[1] == 0);
nic_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
nic_receive, nic_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
qemu_register_reset(nic_reset, s);
register_savevm(s->vc->model, -1, 3, nic_save, nic_load, s);
return (PCIDevice *)d;
}
| {
"code": [
" nic_receive, nic_can_receive, s);",
" nic_receive, nic_can_receive, s);"
],
"line_no": [
81,
81
]
} | static PCIDevice *FUNC_0(PCIBus * bus, NICInfo * nd, uint32_t device)
{
PCIEEPRO100State *d;
EEPRO100State *s;
logout("\n");
d = (PCIEEPRO100State *) pci_register_device(bus, nd->model,
sizeof(PCIEEPRO100State), -1,
NULL, NULL);
s = &d->eepro100;
s->device = device;
s->pci_dev = &d->dev;
pci_reset(s);
s->eeprom = eeprom93xx_new(EEPROM_SIZE);
d->eepro100.mmio_index =
cpu_register_io_memory(0, pci_mmio_read, pci_mmio_write, s);
pci_register_io_region(&d->dev, 0, PCI_MEM_SIZE,
PCI_ADDRESS_SPACE_MEM |
PCI_ADDRESS_SPACE_MEM_PREFETCH, pci_mmio_map);
pci_register_io_region(&d->dev, 1, PCI_IO_SIZE, PCI_ADDRESS_SPACE_IO,
pci_map);
pci_register_io_region(&d->dev, 2, PCI_FLASH_SIZE, PCI_ADDRESS_SPACE_MEM,
pci_mmio_map);
memcpy(s->macaddr, nd->macaddr, 6);
logout("macaddr: %s\n", nic_dump(&s->macaddr[0], 6));
assert(s->region[1] == 0);
nic_reset(s);
s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
nic_receive, nic_can_receive, s);
qemu_format_nic_info_str(s->vc, s->macaddr);
qemu_register_reset(nic_reset, s);
register_savevm(s->vc->model, -1, 3, nic_save, nic_load, s);
return (PCIDevice *)d;
}
| [
"static PCIDevice *FUNC_0(PCIBus * bus, NICInfo * nd, uint32_t device)\n{",
"PCIEEPRO100State *d;",
"EEPRO100State *s;",
"logout(\"\\n\");",
"d = (PCIEEPRO100State *) pci_register_device(bus, nd->model,\nsizeof(PCIEEPRO100State), -1,\nNULL, NULL);",
"s = &d->eepro100;",
"s->device = device;",
"s->pci_dev = &d->dev;",
"pci_reset(s);",
"s->eeprom = eeprom93xx_new(EEPROM_SIZE);",
"d->eepro100.mmio_index =\ncpu_register_io_memory(0, pci_mmio_read, pci_mmio_write, s);",
"pci_register_io_region(&d->dev, 0, PCI_MEM_SIZE,\nPCI_ADDRESS_SPACE_MEM |\nPCI_ADDRESS_SPACE_MEM_PREFETCH, pci_mmio_map);",
"pci_register_io_region(&d->dev, 1, PCI_IO_SIZE, PCI_ADDRESS_SPACE_IO,\npci_map);",
"pci_register_io_region(&d->dev, 2, PCI_FLASH_SIZE, PCI_ADDRESS_SPACE_MEM,\npci_mmio_map);",
"memcpy(s->macaddr, nd->macaddr, 6);",
"logout(\"macaddr: %s\\n\", nic_dump(&s->macaddr[0], 6));",
"assert(s->region[1] == 0);",
"nic_reset(s);",
"s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,\nnic_receive, nic_can_receive, s);",
"qemu_format_nic_info_str(s->vc, s->macaddr);",
"qemu_register_reset(nic_reset, s);",
"register_savevm(s->vc->model, -1, 3, nic_save, nic_load, s);",
"return (PCIDevice *)d;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15,
17,
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
39
],
[
45,
47
],
[
51,
53,
55
],
[
57,
59
],
[
61,
63
],
[
67
],
[
69
],
[
71
],
[
75
],
[
79,
81
],
[
85
],
[
89
],
[
93
],
[
95
],
[
97
]
] |
23,948 | void coroutine_fn co_aio_sleep_ns(AioContext *ctx, QEMUClockType type,
int64_t ns)
{
CoSleepCB sleep_cb = {
.co = qemu_coroutine_self(),
};
sleep_cb.ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &sleep_cb);
timer_mod(sleep_cb.ts, qemu_clock_get_ns(type) + ns);
qemu_coroutine_yield();
timer_del(sleep_cb.ts);
timer_free(sleep_cb.ts); | true | qemu | 6133b39f3c36623425a6ede9e89d93175fde15cd | void coroutine_fn co_aio_sleep_ns(AioContext *ctx, QEMUClockType type,
int64_t ns)
{
CoSleepCB sleep_cb = {
.co = qemu_coroutine_self(),
};
sleep_cb.ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &sleep_cb);
timer_mod(sleep_cb.ts, qemu_clock_get_ns(type) + ns);
qemu_coroutine_yield();
timer_del(sleep_cb.ts);
timer_free(sleep_cb.ts); | {
"code": [],
"line_no": []
} | void VAR_0 co_aio_sleep_ns(AioContext *ctx, QEMUClockType type,
int64_t ns)
{
CoSleepCB sleep_cb = {
.co = qemu_coroutine_self(),
};
sleep_cb.ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &sleep_cb);
timer_mod(sleep_cb.ts, qemu_clock_get_ns(type) + ns);
qemu_coroutine_yield();
timer_del(sleep_cb.ts);
timer_free(sleep_cb.ts); | [
"void VAR_0 co_aio_sleep_ns(AioContext *ctx, QEMUClockType type,\nint64_t ns)\n{",
"CoSleepCB sleep_cb = {",
".co = qemu_coroutine_self(),\n};",
"sleep_cb.ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &sleep_cb);",
"timer_mod(sleep_cb.ts, qemu_clock_get_ns(type) + ns);",
"qemu_coroutine_yield();",
"timer_del(sleep_cb.ts);",
"timer_free(sleep_cb.ts);"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2,
3
],
[
4
],
[
5,
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
]
] |
23,950 | void cpu_set_log(int log_flags)
{
loglevel = log_flags;
if (loglevel && !logfile) {
logfile = fopen(logfilename, log_append ? "a" : "w");
if (!logfile) {
perror(logfilename);
_exit(1);
}
#if !defined(CONFIG_SOFTMMU)
/* must avoid mmap() usage of glibc by setting a buffer "by hand" */
{
static char logfile_buf[4096];
setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
}
#elif !defined(_WIN32)
/* Win32 doesn't support line-buffering and requires size >= 2 */
setvbuf(logfile, NULL, _IOLBF, 0);
#endif
log_append = 1;
}
if (!loglevel && logfile) {
fclose(logfile);
logfile = NULL;
}
}
| true | qemu | daf767b16aeb32e5b9a77066ba130fe723f875ca | void cpu_set_log(int log_flags)
{
loglevel = log_flags;
if (loglevel && !logfile) {
logfile = fopen(logfilename, log_append ? "a" : "w");
if (!logfile) {
perror(logfilename);
_exit(1);
}
#if !defined(CONFIG_SOFTMMU)
{
static char logfile_buf[4096];
setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
}
#elif !defined(_WIN32)
setvbuf(logfile, NULL, _IOLBF, 0);
#endif
log_append = 1;
}
if (!loglevel && logfile) {
fclose(logfile);
logfile = NULL;
}
}
| {
"code": [
"#elif !defined(_WIN32)"
],
"line_no": [
31
]
} | void FUNC_0(int VAR_0)
{
loglevel = VAR_0;
if (loglevel && !logfile) {
logfile = fopen(logfilename, log_append ? "a" : "w");
if (!logfile) {
perror(logfilename);
_exit(1);
}
#if !defined(CONFIG_SOFTMMU)
{
static char VAR_1[4096];
setvbuf(logfile, VAR_1, _IOLBF, sizeof(VAR_1));
}
#elif !defined(_WIN32)
setvbuf(logfile, NULL, _IOLBF, 0);
#endif
log_append = 1;
}
if (!loglevel && logfile) {
fclose(logfile);
logfile = NULL;
}
}
| [
"void FUNC_0(int VAR_0)\n{",
"loglevel = VAR_0;",
"if (loglevel && !logfile) {",
"logfile = fopen(logfilename, log_append ? \"a\" : \"w\");",
"if (!logfile) {",
"perror(logfilename);",
"_exit(1);",
"}",
"#if !defined(CONFIG_SOFTMMU)\n{",
"static char VAR_1[4096];",
"setvbuf(logfile, VAR_1, _IOLBF, sizeof(VAR_1));",
"}",
"#elif !defined(_WIN32)\nsetvbuf(logfile, NULL, _IOLBF, 0);",
"#endif\nlog_append = 1;",
"}",
"if (!loglevel && logfile) {",
"fclose(logfile);",
"logfile = NULL;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19,
23
],
[
25
],
[
27
],
[
29
],
[
31,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
]
] |
23,951 | void helper_ocbi(CPUSH4State *env, uint32_t address)
{
memory_content **current = &(env->movcal_backup);
while (*current)
{
uint32_t a = (*current)->address;
if ((a & ~0x1F) == (address & ~0x1F))
{
memory_content *next = (*current)->next;
cpu_stl_data(env, a, (*current)->value);
if (next == NULL)
{
env->movcal_backup_tail = current;
}
free (*current);
*current = next;
break;
}
}
}
| true | qemu | 01a720125f5e2f0a23d2682b39dead2fcc820066 | void helper_ocbi(CPUSH4State *env, uint32_t address)
{
memory_content **current = &(env->movcal_backup);
while (*current)
{
uint32_t a = (*current)->address;
if ((a & ~0x1F) == (address & ~0x1F))
{
memory_content *next = (*current)->next;
cpu_stl_data(env, a, (*current)->value);
if (next == NULL)
{
env->movcal_backup_tail = current;
}
free (*current);
*current = next;
break;
}
}
}
| {
"code": [
"\t free (*current);"
],
"line_no": [
33
]
} | void FUNC_0(CPUSH4State *VAR_0, uint32_t VAR_1)
{
memory_content **current = &(VAR_0->movcal_backup);
while (*current)
{
uint32_t a = (*current)->VAR_1;
if ((a & ~0x1F) == (VAR_1 & ~0x1F))
{
memory_content *next = (*current)->next;
cpu_stl_data(VAR_0, a, (*current)->value);
if (next == NULL)
{
VAR_0->movcal_backup_tail = current;
}
free (*current);
*current = next;
break;
}
}
}
| [
"void FUNC_0(CPUSH4State *VAR_0, uint32_t VAR_1)\n{",
"memory_content **current = &(VAR_0->movcal_backup);",
"while (*current)\n{",
"uint32_t a = (*current)->VAR_1;",
"if ((a & ~0x1F) == (VAR_1 & ~0x1F))\n{",
"memory_content *next = (*current)->next;",
"cpu_stl_data(VAR_0, a, (*current)->value);",
"if (next == NULL)\n{",
"VAR_0->movcal_backup_tail = current;",
"}",
"free (*current);",
"*current = next;",
"break;",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
11
],
[
13,
15
],
[
17
],
[
19
],
[
23,
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
]
] |
23,952 | static int xmv_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
XMVDemuxContext *xmv = s->priv_data;
int result;
if (xmv->video.current_frame == xmv->video.frame_count) {
/* No frames left in this packet, so we fetch a new one */
result = xmv_fetch_new_packet(s);
if (result)
return result;
}
if (xmv->current_stream == 0) {
/* Fetch a video frame */
result = xmv_fetch_video_packet(s, pkt);
} else {
/* Fetch an audio frame */
result = xmv_fetch_audio_packet(s, pkt, xmv->current_stream - 1);
}
if (result)
return result;
/* Increase our counters */
if (++xmv->current_stream >= xmv->stream_count) {
xmv->current_stream = 0;
xmv->video.current_frame += 1;
}
return 0;
}
| false | FFmpeg | 79c4a338e4b2bf0bc6f81c9f455994f673a92f78 | static int xmv_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
XMVDemuxContext *xmv = s->priv_data;
int result;
if (xmv->video.current_frame == xmv->video.frame_count) {
result = xmv_fetch_new_packet(s);
if (result)
return result;
}
if (xmv->current_stream == 0) {
result = xmv_fetch_video_packet(s, pkt);
} else {
result = xmv_fetch_audio_packet(s, pkt, xmv->current_stream - 1);
}
if (result)
return result;
if (++xmv->current_stream >= xmv->stream_count) {
xmv->current_stream = 0;
xmv->video.current_frame += 1;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0,
AVPacket *VAR_1)
{
XMVDemuxContext *xmv = VAR_0->priv_data;
int VAR_2;
if (xmv->video.current_frame == xmv->video.frame_count) {
VAR_2 = xmv_fetch_new_packet(VAR_0);
if (VAR_2)
return VAR_2;
}
if (xmv->current_stream == 0) {
VAR_2 = xmv_fetch_video_packet(VAR_0, VAR_1);
} else {
VAR_2 = xmv_fetch_audio_packet(VAR_0, VAR_1, xmv->current_stream - 1);
}
if (VAR_2)
return VAR_2;
if (++xmv->current_stream >= xmv->stream_count) {
xmv->current_stream = 0;
xmv->video.current_frame += 1;
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0,\nAVPacket *VAR_1)\n{",
"XMVDemuxContext *xmv = VAR_0->priv_data;",
"int VAR_2;",
"if (xmv->video.current_frame == xmv->video.frame_count) {",
"VAR_2 = xmv_fetch_new_packet(VAR_0);",
"if (VAR_2)\nreturn VAR_2;",
"}",
"if (xmv->current_stream == 0) {",
"VAR_2 = xmv_fetch_video_packet(VAR_0, VAR_1);",
"} else {",
"VAR_2 = xmv_fetch_audio_packet(VAR_0, VAR_1, xmv->current_stream - 1);",
"}",
"if (VAR_2)\nreturn VAR_2;",
"if (++xmv->current_stream >= xmv->stream_count) {",
"xmv->current_stream = 0;",
"xmv->video.current_frame += 1;",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
19
],
[
21,
23
],
[
25
],
[
29
],
[
35
],
[
37
],
[
43
],
[
45
],
[
47,
49
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
]
] |
23,953 | static void render_memory_region(FlatView *view,
MemoryRegion *mr,
target_phys_addr_t base,
AddrRange clip)
{
MemoryRegion *subregion;
unsigned i;
target_phys_addr_t offset_in_region;
uint64_t remain;
uint64_t now;
FlatRange fr;
AddrRange tmp;
base += mr->addr;
tmp = addrrange_make(base, mr->size);
if (!addrrange_intersects(tmp, clip)) {
return;
}
clip = addrrange_intersection(tmp, clip);
if (mr->alias) {
base -= mr->alias->addr;
base -= mr->alias_offset;
render_memory_region(view, mr->alias, base, clip);
return;
}
/* Render subregions in priority order. */
QTAILQ_FOREACH(subregion, &mr->subregions, subregions_link) {
render_memory_region(view, subregion, base, clip);
}
if (!mr->terminates) {
return;
}
offset_in_region = clip.start - base;
base = clip.start;
remain = clip.size;
/* Render the region itself into any gaps left by the current view. */
for (i = 0; i < view->nr && remain; ++i) {
if (base >= addrrange_end(view->ranges[i].addr)) {
continue;
}
if (base < view->ranges[i].addr.start) {
now = MIN(remain, view->ranges[i].addr.start - base);
fr.mr = mr;
fr.offset_in_region = offset_in_region;
fr.addr = addrrange_make(base, now);
fr.dirty_log_mask = mr->dirty_log_mask;
flatview_insert(view, i, &fr);
++i;
base += now;
offset_in_region += now;
remain -= now;
}
if (base == view->ranges[i].addr.start) {
now = MIN(remain, view->ranges[i].addr.size);
base += now;
offset_in_region += now;
remain -= now;
}
}
if (remain) {
fr.mr = mr;
fr.offset_in_region = offset_in_region;
fr.addr = addrrange_make(base, remain);
fr.dirty_log_mask = mr->dirty_log_mask;
flatview_insert(view, i, &fr);
}
}
| true | qemu | 8417cebfda193c7f9ca70be5e308eaa92cf84b94 | static void render_memory_region(FlatView *view,
MemoryRegion *mr,
target_phys_addr_t base,
AddrRange clip)
{
MemoryRegion *subregion;
unsigned i;
target_phys_addr_t offset_in_region;
uint64_t remain;
uint64_t now;
FlatRange fr;
AddrRange tmp;
base += mr->addr;
tmp = addrrange_make(base, mr->size);
if (!addrrange_intersects(tmp, clip)) {
return;
}
clip = addrrange_intersection(tmp, clip);
if (mr->alias) {
base -= mr->alias->addr;
base -= mr->alias_offset;
render_memory_region(view, mr->alias, base, clip);
return;
}
QTAILQ_FOREACH(subregion, &mr->subregions, subregions_link) {
render_memory_region(view, subregion, base, clip);
}
if (!mr->terminates) {
return;
}
offset_in_region = clip.start - base;
base = clip.start;
remain = clip.size;
for (i = 0; i < view->nr && remain; ++i) {
if (base >= addrrange_end(view->ranges[i].addr)) {
continue;
}
if (base < view->ranges[i].addr.start) {
now = MIN(remain, view->ranges[i].addr.start - base);
fr.mr = mr;
fr.offset_in_region = offset_in_region;
fr.addr = addrrange_make(base, now);
fr.dirty_log_mask = mr->dirty_log_mask;
flatview_insert(view, i, &fr);
++i;
base += now;
offset_in_region += now;
remain -= now;
}
if (base == view->ranges[i].addr.start) {
now = MIN(remain, view->ranges[i].addr.size);
base += now;
offset_in_region += now;
remain -= now;
}
}
if (remain) {
fr.mr = mr;
fr.offset_in_region = offset_in_region;
fr.addr = addrrange_make(base, remain);
fr.dirty_log_mask = mr->dirty_log_mask;
flatview_insert(view, i, &fr);
}
}
| {
"code": [
" uint64_t remain;",
" uint64_t now;"
],
"line_no": [
17,
19
]
} | static void FUNC_0(FlatView *VAR_0,
MemoryRegion *VAR_1,
target_phys_addr_t VAR_2,
AddrRange VAR_3)
{
MemoryRegion *subregion;
unsigned VAR_4;
target_phys_addr_t offset_in_region;
uint64_t remain;
uint64_t now;
FlatRange fr;
AddrRange tmp;
VAR_2 += VAR_1->addr;
tmp = addrrange_make(VAR_2, VAR_1->size);
if (!addrrange_intersects(tmp, VAR_3)) {
return;
}
VAR_3 = addrrange_intersection(tmp, VAR_3);
if (VAR_1->alias) {
VAR_2 -= VAR_1->alias->addr;
VAR_2 -= VAR_1->alias_offset;
FUNC_0(VAR_0, VAR_1->alias, VAR_2, VAR_3);
return;
}
QTAILQ_FOREACH(subregion, &VAR_1->subregions, subregions_link) {
FUNC_0(VAR_0, subregion, VAR_2, VAR_3);
}
if (!VAR_1->terminates) {
return;
}
offset_in_region = VAR_3.start - VAR_2;
VAR_2 = VAR_3.start;
remain = VAR_3.size;
for (VAR_4 = 0; VAR_4 < VAR_0->nr && remain; ++VAR_4) {
if (VAR_2 >= addrrange_end(VAR_0->ranges[VAR_4].addr)) {
continue;
}
if (VAR_2 < VAR_0->ranges[VAR_4].addr.start) {
now = MIN(remain, VAR_0->ranges[VAR_4].addr.start - VAR_2);
fr.VAR_1 = VAR_1;
fr.offset_in_region = offset_in_region;
fr.addr = addrrange_make(VAR_2, now);
fr.dirty_log_mask = VAR_1->dirty_log_mask;
flatview_insert(VAR_0, VAR_4, &fr);
++VAR_4;
VAR_2 += now;
offset_in_region += now;
remain -= now;
}
if (VAR_2 == VAR_0->ranges[VAR_4].addr.start) {
now = MIN(remain, VAR_0->ranges[VAR_4].addr.size);
VAR_2 += now;
offset_in_region += now;
remain -= now;
}
}
if (remain) {
fr.VAR_1 = VAR_1;
fr.offset_in_region = offset_in_region;
fr.addr = addrrange_make(VAR_2, remain);
fr.dirty_log_mask = VAR_1->dirty_log_mask;
flatview_insert(VAR_0, VAR_4, &fr);
}
}
| [
"static void FUNC_0(FlatView *VAR_0,\nMemoryRegion *VAR_1,\ntarget_phys_addr_t VAR_2,\nAddrRange VAR_3)\n{",
"MemoryRegion *subregion;",
"unsigned VAR_4;",
"target_phys_addr_t offset_in_region;",
"uint64_t remain;",
"uint64_t now;",
"FlatRange fr;",
"AddrRange tmp;",
"VAR_2 += VAR_1->addr;",
"tmp = addrrange_make(VAR_2, VAR_1->size);",
"if (!addrrange_intersects(tmp, VAR_3)) {",
"return;",
"}",
"VAR_3 = addrrange_intersection(tmp, VAR_3);",
"if (VAR_1->alias) {",
"VAR_2 -= VAR_1->alias->addr;",
"VAR_2 -= VAR_1->alias_offset;",
"FUNC_0(VAR_0, VAR_1->alias, VAR_2, VAR_3);",
"return;",
"}",
"QTAILQ_FOREACH(subregion, &VAR_1->subregions, subregions_link) {",
"FUNC_0(VAR_0, subregion, VAR_2, VAR_3);",
"}",
"if (!VAR_1->terminates) {",
"return;",
"}",
"offset_in_region = VAR_3.start - VAR_2;",
"VAR_2 = VAR_3.start;",
"remain = VAR_3.size;",
"for (VAR_4 = 0; VAR_4 < VAR_0->nr && remain; ++VAR_4) {",
"if (VAR_2 >= addrrange_end(VAR_0->ranges[VAR_4].addr)) {",
"continue;",
"}",
"if (VAR_2 < VAR_0->ranges[VAR_4].addr.start) {",
"now = MIN(remain, VAR_0->ranges[VAR_4].addr.start - VAR_2);",
"fr.VAR_1 = VAR_1;",
"fr.offset_in_region = offset_in_region;",
"fr.addr = addrrange_make(VAR_2, now);",
"fr.dirty_log_mask = VAR_1->dirty_log_mask;",
"flatview_insert(VAR_0, VAR_4, &fr);",
"++VAR_4;",
"VAR_2 += now;",
"offset_in_region += now;",
"remain -= now;",
"}",
"if (VAR_2 == VAR_0->ranges[VAR_4].addr.start) {",
"now = MIN(remain, VAR_0->ranges[VAR_4].addr.size);",
"VAR_2 += now;",
"offset_in_region += now;",
"remain -= now;",
"}",
"}",
"if (remain) {",
"fr.VAR_1 = VAR_1;",
"fr.offset_in_region = offset_in_region;",
"fr.addr = addrrange_make(VAR_2, remain);",
"fr.dirty_log_mask = VAR_1->dirty_log_mask;",
"flatview_insert(VAR_0, VAR_4, &fr);",
"}",
"}"
] | [
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
31
],
[
35
],
[
37
],
[
39
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
]
] |
23,954 | void fw_cfg_add_i32(FWCfgState *s, uint16_t key, uint32_t value)
{
uint32_t *copy;
copy = g_malloc(sizeof(value));
*copy = cpu_to_le32(value);
fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value));
}
| true | qemu | 089da572b956ef0f8f5b8d5917358e07892a77c2 | void fw_cfg_add_i32(FWCfgState *s, uint16_t key, uint32_t value)
{
uint32_t *copy;
copy = g_malloc(sizeof(value));
*copy = cpu_to_le32(value);
fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value));
}
| {
"code": [
" fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value));",
" fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value));",
" fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value));"
],
"line_no": [
13,
13,
13
]
} | void FUNC_0(FWCfgState *VAR_0, uint16_t VAR_1, uint32_t VAR_2)
{
uint32_t *copy;
copy = g_malloc(sizeof(VAR_2));
*copy = cpu_to_le32(VAR_2);
fw_cfg_add_bytes(VAR_0, VAR_1, (uint8_t *)copy, sizeof(VAR_2));
}
| [
"void FUNC_0(FWCfgState *VAR_0, uint16_t VAR_1, uint32_t VAR_2)\n{",
"uint32_t *copy;",
"copy = g_malloc(sizeof(VAR_2));",
"*copy = cpu_to_le32(VAR_2);",
"fw_cfg_add_bytes(VAR_0, VAR_1, (uint8_t *)copy, sizeof(VAR_2));",
"}"
] | [
0,
0,
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
23,955 | struct omap_lcd_panel_s *omap_lcdc_init(MemoryRegion *sysmem,
hwaddr base,
qemu_irq irq,
struct omap_dma_lcd_channel_s *dma,
omap_clk clk)
{
struct omap_lcd_panel_s *s = (struct omap_lcd_panel_s *)
g_malloc0(sizeof(struct omap_lcd_panel_s));
s->irq = irq;
s->dma = dma;
s->sysmem = sysmem;
omap_lcdc_reset(s);
memory_region_init_io(&s->iomem, NULL, &omap_lcdc_ops, s, "omap.lcdc", 0x100);
memory_region_add_subregion(sysmem, base, &s->iomem);
s->con = graphic_console_init(NULL, 0, &omap_ops, s);
return s;
}
| true | qemu | b45c03f585ea9bb1af76c73e82195418c294919d | struct omap_lcd_panel_s *omap_lcdc_init(MemoryRegion *sysmem,
hwaddr base,
qemu_irq irq,
struct omap_dma_lcd_channel_s *dma,
omap_clk clk)
{
struct omap_lcd_panel_s *s = (struct omap_lcd_panel_s *)
g_malloc0(sizeof(struct omap_lcd_panel_s));
s->irq = irq;
s->dma = dma;
s->sysmem = sysmem;
omap_lcdc_reset(s);
memory_region_init_io(&s->iomem, NULL, &omap_lcdc_ops, s, "omap.lcdc", 0x100);
memory_region_add_subregion(sysmem, base, &s->iomem);
s->con = graphic_console_init(NULL, 0, &omap_ops, s);
return s;
}
| {
"code": [
" struct omap_lcd_panel_s *s = (struct omap_lcd_panel_s *)",
" g_malloc0(sizeof(struct omap_lcd_panel_s));"
],
"line_no": [
13,
15
]
} | struct omap_lcd_panel_s *FUNC_0(MemoryRegion *VAR_0,
hwaddr VAR_1,
qemu_irq VAR_2,
struct omap_dma_lcd_channel_s *VAR_3,
omap_clk VAR_4)
{
struct omap_lcd_panel_s *VAR_5 = (struct omap_lcd_panel_s *)
g_malloc0(sizeof(struct omap_lcd_panel_s));
VAR_5->VAR_2 = VAR_2;
VAR_5->VAR_3 = VAR_3;
VAR_5->VAR_0 = VAR_0;
omap_lcdc_reset(VAR_5);
memory_region_init_io(&VAR_5->iomem, NULL, &omap_lcdc_ops, VAR_5, "omap.lcdc", 0x100);
memory_region_add_subregion(VAR_0, VAR_1, &VAR_5->iomem);
VAR_5->con = graphic_console_init(NULL, 0, &omap_ops, VAR_5);
return VAR_5;
}
| [
"struct omap_lcd_panel_s *FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nqemu_irq VAR_2,\nstruct omap_dma_lcd_channel_s *VAR_3,\nomap_clk VAR_4)\n{",
"struct omap_lcd_panel_s *VAR_5 = (struct omap_lcd_panel_s *)\ng_malloc0(sizeof(struct omap_lcd_panel_s));",
"VAR_5->VAR_2 = VAR_2;",
"VAR_5->VAR_3 = VAR_3;",
"VAR_5->VAR_0 = VAR_0;",
"omap_lcdc_reset(VAR_5);",
"memory_region_init_io(&VAR_5->iomem, NULL, &omap_lcdc_ops, VAR_5, \"omap.lcdc\", 0x100);",
"memory_region_add_subregion(VAR_0, VAR_1, &VAR_5->iomem);",
"VAR_5->con = graphic_console_init(NULL, 0, &omap_ops, VAR_5);",
"return VAR_5;",
"}"
] | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11
],
[
13,
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
]
] |
23,957 | static void virtio_crypto_free_request(VirtIOCryptoReq *req)
{
if (req) {
if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) {
g_free(req->u.sym_op_info);
}
g_free(req);
}
}
| true | qemu | 02ed3e7c1665205ddae052774d6f26c71d3d9b30 | static void virtio_crypto_free_request(VirtIOCryptoReq *req)
{
if (req) {
if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) {
g_free(req->u.sym_op_info);
}
g_free(req);
}
}
| {
"code": [
" g_free(req->u.sym_op_info);"
],
"line_no": [
9
]
} | static void FUNC_0(VirtIOCryptoReq *VAR_0)
{
if (VAR_0) {
if (VAR_0->flags == CRYPTODEV_BACKEND_ALG_SYM) {
g_free(VAR_0->u.sym_op_info);
}
g_free(VAR_0);
}
}
| [
"static void FUNC_0(VirtIOCryptoReq *VAR_0)\n{",
"if (VAR_0) {",
"if (VAR_0->flags == CRYPTODEV_BACKEND_ALG_SYM) {",
"g_free(VAR_0->u.sym_op_info);",
"}",
"g_free(VAR_0);",
"}",
"}"
] | [
0,
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
23,958 | void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,
int unused, int size)
{
if (is_exec)
helper_raise_exception(EXCP_IBE);
else
helper_raise_exception(EXCP_DBE);
}
| true | qemu | b14ef7c9ab41ea824c3ccadb070ad95567cca84e | void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,
int unused, int size)
{
if (is_exec)
helper_raise_exception(EXCP_IBE);
else
helper_raise_exception(EXCP_DBE);
}
| {
"code": [
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,",
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,",
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,",
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,",
" int unused, int size)",
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,",
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,",
"void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,"
],
"line_no": [
1,
1,
1,
1,
3,
1,
1,
1
]
} | void FUNC_0(target_phys_addr_t VAR_0, int VAR_1, int VAR_2,
int VAR_3, int VAR_4)
{
if (VAR_2)
helper_raise_exception(EXCP_IBE);
else
helper_raise_exception(EXCP_DBE);
}
| [
"void FUNC_0(target_phys_addr_t VAR_0, int VAR_1, int VAR_2,\nint VAR_3, int VAR_4)\n{",
"if (VAR_2)\nhelper_raise_exception(EXCP_IBE);",
"else\nhelper_raise_exception(EXCP_DBE);",
"}"
] | [
1,
0,
0,
0
] | [
[
1,
3,
5
],
[
7,
9
],
[
11,
13
],
[
15
]
] |
23,959 | static void qemu_aio_complete(void *opaque, int ret)
{
struct ioreq *ioreq = opaque;
if (ret != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n",
ioreq->req.operation == BLKIF_OP_READ ? "read" : "write");
ioreq->aio_errors++;
}
ioreq->aio_inflight--;
if (ioreq->presync) {
ioreq->presync = 0;
ioreq_runio_qemu_aio(ioreq);
return;
}
if (ioreq->aio_inflight > 0) {
return;
}
if (ioreq->postsync) {
ioreq->postsync = 0;
ioreq->aio_inflight++;
blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq);
return;
}
ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;
ioreq_unmap(ioreq);
ioreq_finish(ioreq);
switch (ioreq->req.operation) {
case BLKIF_OP_WRITE:
case BLKIF_OP_FLUSH_DISKCACHE:
if (!ioreq->req.nr_segments) {
break;
}
case BLKIF_OP_READ:
block_acct_done(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct);
break;
case BLKIF_OP_DISCARD:
default:
break;
}
qemu_bh_schedule(ioreq->blkdev->bh);
}
| true | qemu | 57ee366ce9cf8d9f7a52b7b654b9db78fe887349 | static void qemu_aio_complete(void *opaque, int ret)
{
struct ioreq *ioreq = opaque;
if (ret != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n",
ioreq->req.operation == BLKIF_OP_READ ? "read" : "write");
ioreq->aio_errors++;
}
ioreq->aio_inflight--;
if (ioreq->presync) {
ioreq->presync = 0;
ioreq_runio_qemu_aio(ioreq);
return;
}
if (ioreq->aio_inflight > 0) {
return;
}
if (ioreq->postsync) {
ioreq->postsync = 0;
ioreq->aio_inflight++;
blk_aio_flush(ioreq->blkdev->blk, qemu_aio_complete, ioreq);
return;
}
ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;
ioreq_unmap(ioreq);
ioreq_finish(ioreq);
switch (ioreq->req.operation) {
case BLKIF_OP_WRITE:
case BLKIF_OP_FLUSH_DISKCACHE:
if (!ioreq->req.nr_segments) {
break;
}
case BLKIF_OP_READ:
block_acct_done(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct);
break;
case BLKIF_OP_DISCARD:
default:
break;
}
qemu_bh_schedule(ioreq->blkdev->bh);
}
| {
"code": [
" block_acct_done(blk_get_stats(ioreq->blkdev->blk), &ioreq->acct);"
],
"line_no": [
73
]
} | static void FUNC_0(void *VAR_0, int VAR_1)
{
struct VAR_2 *VAR_2 = VAR_0;
if (VAR_1 != 0) {
xen_be_printf(&VAR_2->blkdev->xendev, 0, "%s I/O error\n",
VAR_2->req.operation == BLKIF_OP_READ ? "read" : "write");
VAR_2->aio_errors++;
}
VAR_2->aio_inflight--;
if (VAR_2->presync) {
VAR_2->presync = 0;
ioreq_runio_qemu_aio(VAR_2);
return;
}
if (VAR_2->aio_inflight > 0) {
return;
}
if (VAR_2->postsync) {
VAR_2->postsync = 0;
VAR_2->aio_inflight++;
blk_aio_flush(VAR_2->blkdev->blk, FUNC_0, VAR_2);
return;
}
VAR_2->status = VAR_2->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;
ioreq_unmap(VAR_2);
ioreq_finish(VAR_2);
switch (VAR_2->req.operation) {
case BLKIF_OP_WRITE:
case BLKIF_OP_FLUSH_DISKCACHE:
if (!VAR_2->req.nr_segments) {
break;
}
case BLKIF_OP_READ:
block_acct_done(blk_get_stats(VAR_2->blkdev->blk), &VAR_2->acct);
break;
case BLKIF_OP_DISCARD:
default:
break;
}
qemu_bh_schedule(VAR_2->blkdev->bh);
}
| [
"static void FUNC_0(void *VAR_0, int VAR_1)\n{",
"struct VAR_2 *VAR_2 = VAR_0;",
"if (VAR_1 != 0) {",
"xen_be_printf(&VAR_2->blkdev->xendev, 0, \"%s I/O error\\n\",\nVAR_2->req.operation == BLKIF_OP_READ ? \"read\" : \"write\");",
"VAR_2->aio_errors++;",
"}",
"VAR_2->aio_inflight--;",
"if (VAR_2->presync) {",
"VAR_2->presync = 0;",
"ioreq_runio_qemu_aio(VAR_2);",
"return;",
"}",
"if (VAR_2->aio_inflight > 0) {",
"return;",
"}",
"if (VAR_2->postsync) {",
"VAR_2->postsync = 0;",
"VAR_2->aio_inflight++;",
"blk_aio_flush(VAR_2->blkdev->blk, FUNC_0, VAR_2);",
"return;",
"}",
"VAR_2->status = VAR_2->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;",
"ioreq_unmap(VAR_2);",
"ioreq_finish(VAR_2);",
"switch (VAR_2->req.operation) {",
"case BLKIF_OP_WRITE:\ncase BLKIF_OP_FLUSH_DISKCACHE:\nif (!VAR_2->req.nr_segments) {",
"break;",
"}",
"case BLKIF_OP_READ:\nblock_acct_done(blk_get_stats(VAR_2->blkdev->blk), &VAR_2->acct);",
"break;",
"case BLKIF_OP_DISCARD:\ndefault:\nbreak;",
"}",
"qemu_bh_schedule(VAR_2->blkdev->bh);",
"}"
] | [
0,
0,
0,
0,
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
] | [
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15
],
[
17
],
[
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,
81
],
[
83
],
[
85
],
[
87
]
] |
23,960 | static void spapr_msi_setmsg(PCIDevice *pdev, hwaddr addr, bool msix,
unsigned first_irq, unsigned req_num)
{
unsigned i;
MSIMessage msg = { .address = addr, .data = first_irq };
if (!msix) {
msi_set_message(pdev, msg);
trace_spapr_pci_msi_setup(pdev->name, 0, msg.address);
return;
}
for (i = 0; i < req_num; ++i, ++msg.data) {
msix_set_message(pdev, i, msg);
trace_spapr_pci_msi_setup(pdev->name, i, msg.address);
}
}
| true | qemu | 9a321e92343891e30f6fe8bfaad40454ae358bfb | static void spapr_msi_setmsg(PCIDevice *pdev, hwaddr addr, bool msix,
unsigned first_irq, unsigned req_num)
{
unsigned i;
MSIMessage msg = { .address = addr, .data = first_irq };
if (!msix) {
msi_set_message(pdev, msg);
trace_spapr_pci_msi_setup(pdev->name, 0, msg.address);
return;
}
for (i = 0; i < req_num; ++i, ++msg.data) {
msix_set_message(pdev, i, msg);
trace_spapr_pci_msi_setup(pdev->name, i, msg.address);
}
}
| {
"code": [
" for (i = 0; i < req_num; ++i, ++msg.data) {"
],
"line_no": [
25
]
} | static void FUNC_0(PCIDevice *VAR_0, hwaddr VAR_1, bool VAR_2,
unsigned VAR_3, unsigned VAR_4)
{
unsigned VAR_5;
MSIMessage msg = { .address = VAR_1, .data = VAR_3 };
if (!VAR_2) {
msi_set_message(VAR_0, msg);
trace_spapr_pci_msi_setup(VAR_0->name, 0, msg.address);
return;
}
for (VAR_5 = 0; VAR_5 < VAR_4; ++VAR_5, ++msg.data) {
msix_set_message(VAR_0, VAR_5, msg);
trace_spapr_pci_msi_setup(VAR_0->name, VAR_5, msg.address);
}
}
| [
"static void FUNC_0(PCIDevice *VAR_0, hwaddr VAR_1, bool VAR_2,\nunsigned VAR_3, unsigned VAR_4)\n{",
"unsigned VAR_5;",
"MSIMessage msg = { .address = VAR_1, .data = VAR_3 };",
"if (!VAR_2) {",
"msi_set_message(VAR_0, msg);",
"trace_spapr_pci_msi_setup(VAR_0->name, 0, msg.address);",
"return;",
"}",
"for (VAR_5 = 0; VAR_5 < VAR_4; ++VAR_5, ++msg.data) {",
"msix_set_message(VAR_0, VAR_5, msg);",
"trace_spapr_pci_msi_setup(VAR_0->name, VAR_5, msg.address);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
23,961 | static void spapr_reset_htab(sPAPRMachineState *spapr)
{
long shift;
int index;
shift = kvmppc_reset_htab(spapr->htab_shift);
if (shift > 0) {
if (shift != spapr->htab_shift) {
error_setg(&error_abort, "Requested HTAB allocation failed during reset");
}
/* Tell readers to update their file descriptor */
if (spapr->htab_fd >= 0) {
spapr->htab_fd_stale = true;
}
} else {
memset(spapr->htab, 0, HTAB_SIZE(spapr));
for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) {
DIRTY_HPTE(HPTE(spapr->htab, index));
}
}
/* Update the RMA size if necessary */
if (spapr->vrma_adjust) {
spapr->rma_size = kvmppc_rma_size(spapr_node0_size(),
spapr->htab_shift);
}
}
| true | qemu | b41d320fef705289d2b73f4949731eb2e189161d | static void spapr_reset_htab(sPAPRMachineState *spapr)
{
long shift;
int index;
shift = kvmppc_reset_htab(spapr->htab_shift);
if (shift > 0) {
if (shift != spapr->htab_shift) {
error_setg(&error_abort, "Requested HTAB allocation failed during reset");
}
if (spapr->htab_fd >= 0) {
spapr->htab_fd_stale = true;
}
} else {
memset(spapr->htab, 0, HTAB_SIZE(spapr));
for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) {
DIRTY_HPTE(HPTE(spapr->htab, index));
}
}
if (spapr->vrma_adjust) {
spapr->rma_size = kvmppc_rma_size(spapr_node0_size(),
spapr->htab_shift);
}
}
| {
"code": [
" if (shift > 0) {",
" if (shift > 0) {"
],
"line_no": [
13,
13
]
} | static void FUNC_0(sPAPRMachineState *VAR_0)
{
long VAR_1;
int VAR_2;
VAR_1 = kvmppc_reset_htab(VAR_0->htab_shift);
if (VAR_1 > 0) {
if (VAR_1 != VAR_0->htab_shift) {
error_setg(&error_abort, "Requested HTAB allocation failed during reset");
}
if (VAR_0->htab_fd >= 0) {
VAR_0->htab_fd_stale = true;
}
} else {
memset(VAR_0->htab, 0, HTAB_SIZE(VAR_0));
for (VAR_2 = 0; VAR_2 < HTAB_SIZE(VAR_0) / HASH_PTE_SIZE_64; VAR_2++) {
DIRTY_HPTE(HPTE(VAR_0->htab, VAR_2));
}
}
if (VAR_0->vrma_adjust) {
VAR_0->rma_size = kvmppc_rma_size(spapr_node0_size(),
VAR_0->htab_shift);
}
}
| [
"static void FUNC_0(sPAPRMachineState *VAR_0)\n{",
"long VAR_1;",
"int VAR_2;",
"VAR_1 = kvmppc_reset_htab(VAR_0->htab_shift);",
"if (VAR_1 > 0) {",
"if (VAR_1 != VAR_0->htab_shift) {",
"error_setg(&error_abort, \"Requested HTAB allocation failed during reset\");",
"}",
"if (VAR_0->htab_fd >= 0) {",
"VAR_0->htab_fd_stale = true;",
"}",
"} else {",
"memset(VAR_0->htab, 0, HTAB_SIZE(VAR_0));",
"for (VAR_2 = 0; VAR_2 < HTAB_SIZE(VAR_0) / HASH_PTE_SIZE_64; VAR_2++) {",
"DIRTY_HPTE(HPTE(VAR_0->htab, VAR_2));",
"}",
"}",
"if (VAR_0->vrma_adjust) {",
"VAR_0->rma_size = kvmppc_rma_size(spapr_node0_size(),\nVAR_0->htab_shift);",
"}",
"}"
] | [
0,
0,
0,
0,
1,
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
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
49
],
[
51,
53
],
[
55
],
[
57
]
] |
23,962 | void raise_irq_cpu_hotplug(void)
{
qemu_irq_raise(irq_cpu_hotplug);
}
| true | qemu | 7b53f2940e3bf43ae50c929330a4837ca4da7a94 | void raise_irq_cpu_hotplug(void)
{
qemu_irq_raise(irq_cpu_hotplug);
}
| {
"code": [
" qemu_irq_raise(irq_cpu_hotplug);"
],
"line_no": [
5
]
} | void FUNC_0(void)
{
qemu_irq_raise(irq_cpu_hotplug);
}
| [
"void FUNC_0(void)\n{",
"qemu_irq_raise(irq_cpu_hotplug);",
"}"
] | [
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
23,963 | static void uhci_queue_free(UHCIQueue *queue)
{
UHCIState *s = queue->uhci;
UHCIAsync *async;
while (!QTAILQ_EMPTY(&queue->asyncs)) {
async = QTAILQ_FIRST(&queue->asyncs);
uhci_async_cancel(async);
}
trace_usb_uhci_queue_del(queue->token);
QTAILQ_REMOVE(&s->queues, queue, next);
g_free(queue);
}
| true | qemu | 66a08cbe6ad1aebec8eecf58b3ba042e19dd1649 | static void uhci_queue_free(UHCIQueue *queue)
{
UHCIState *s = queue->uhci;
UHCIAsync *async;
while (!QTAILQ_EMPTY(&queue->asyncs)) {
async = QTAILQ_FIRST(&queue->asyncs);
uhci_async_cancel(async);
}
trace_usb_uhci_queue_del(queue->token);
QTAILQ_REMOVE(&s->queues, queue, next);
g_free(queue);
}
| {
"code": [
"static void uhci_queue_free(UHCIQueue *queue)",
" trace_usb_uhci_queue_del(queue->token);"
],
"line_no": [
1,
21
]
} | static void FUNC_0(UHCIQueue *VAR_0)
{
UHCIState *s = VAR_0->uhci;
UHCIAsync *async;
while (!QTAILQ_EMPTY(&VAR_0->asyncs)) {
async = QTAILQ_FIRST(&VAR_0->asyncs);
uhci_async_cancel(async);
}
trace_usb_uhci_queue_del(VAR_0->token);
QTAILQ_REMOVE(&s->queues, VAR_0, next);
g_free(VAR_0);
}
| [
"static void FUNC_0(UHCIQueue *VAR_0)\n{",
"UHCIState *s = VAR_0->uhci;",
"UHCIAsync *async;",
"while (!QTAILQ_EMPTY(&VAR_0->asyncs)) {",
"async = QTAILQ_FIRST(&VAR_0->asyncs);",
"uhci_async_cancel(async);",
"}",
"trace_usb_uhci_queue_del(VAR_0->token);",
"QTAILQ_REMOVE(&s->queues, VAR_0, next);",
"g_free(VAR_0);",
"}"
] | [
1,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
]
] |
23,964 | static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
SBRData *ch_data, int e_a[2])
{
int e, i, m;
memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
for (e = 0; e < ch_data->bs_num_env; e++) {
const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
int k;
for (i = 0; i < ilim; i++)
for (m = table[i]; m < table[i + 1]; m++)
sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
// ch_data->bs_num_noise > 1 => 2 noise floors
k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
for (i = 0; i < sbr->n_q; i++)
for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
for (i = 0; i < sbr->n[1]; i++) {
if (ch_data->bs_add_harmonic_flag) {
const unsigned int m_midpoint =
(sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
(e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
}
}
for (i = 0; i < ilim; i++) {
int additional_sinusoid_present = 0;
for (m = table[i]; m < table[i + 1]; m++) {
if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
additional_sinusoid_present = 1;
break;
}
}
memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
(table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
}
}
memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
}
| false | FFmpeg | b00307ecd04f80d8021c50f9fa76fd452e54a3d1 | static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
SBRData *ch_data, int e_a[2])
{
int e, i, m;
memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
for (e = 0; e < ch_data->bs_num_env; e++) {
const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
int k;
for (i = 0; i < ilim; i++)
for (m = table[i]; m < table[i + 1]; m++)
sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
for (i = 0; i < sbr->n_q; i++)
for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
for (i = 0; i < sbr->n[1]; i++) {
if (ch_data->bs_add_harmonic_flag) {
const unsigned int m_midpoint =
(sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
(e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
}
}
for (i = 0; i < ilim; i++) {
int additional_sinusoid_present = 0;
for (m = table[i]; m < table[i + 1]; m++) {
if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
additional_sinusoid_present = 1;
break;
}
}
memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
(table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
}
}
memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AACContext *VAR_0, SpectralBandReplication *VAR_1,
SBRData *VAR_2, int VAR_3[2])
{
int VAR_4, VAR_5, VAR_6;
memset(VAR_2->s_indexmapped[1], 0, 7*sizeof(VAR_2->s_indexmapped[1]));
for (VAR_4 = 0; VAR_4 < VAR_2->bs_num_env; VAR_4++) {
const unsigned int ilim = VAR_1->n[VAR_2->bs_freq_res[VAR_4 + 1]];
uint16_t *table = VAR_2->bs_freq_res[VAR_4 + 1] ? VAR_1->f_tablehigh : VAR_1->f_tablelow;
int k;
for (VAR_5 = 0; VAR_5 < ilim; VAR_5++)
for (VAR_6 = table[VAR_5]; VAR_6 < table[VAR_5 + 1]; VAR_6++)
VAR_1->e_origmapped[VAR_4][VAR_6 - VAR_1->kx[1]] = VAR_2->env_facs[VAR_4+1][VAR_5];
k = (VAR_2->bs_num_noise > 1) && (VAR_2->t_env[VAR_4] >= VAR_2->t_q[1]);
for (VAR_5 = 0; VAR_5 < VAR_1->n_q; VAR_5++)
for (VAR_6 = VAR_1->f_tablenoise[VAR_5]; VAR_6 < VAR_1->f_tablenoise[VAR_5 + 1]; VAR_6++)
VAR_1->q_mapped[VAR_4][VAR_6 - VAR_1->kx[1]] = VAR_2->noise_facs[k+1][VAR_5];
for (VAR_5 = 0; VAR_5 < VAR_1->n[1]; VAR_5++) {
if (VAR_2->bs_add_harmonic_flag) {
const unsigned int m_midpoint =
(VAR_1->f_tablehigh[VAR_5] + VAR_1->f_tablehigh[VAR_5 + 1]) >> 1;
VAR_2->s_indexmapped[VAR_4 + 1][m_midpoint - VAR_1->kx[1]] = VAR_2->bs_add_harmonic[VAR_5] *
(VAR_4 >= VAR_3[1] || (VAR_2->s_indexmapped[0][m_midpoint - VAR_1->kx[1]] == 1));
}
}
for (VAR_5 = 0; VAR_5 < ilim; VAR_5++) {
int additional_sinusoid_present = 0;
for (VAR_6 = table[VAR_5]; VAR_6 < table[VAR_5 + 1]; VAR_6++) {
if (VAR_2->s_indexmapped[VAR_4 + 1][VAR_6 - VAR_1->kx[1]]) {
additional_sinusoid_present = 1;
break;
}
}
memset(&VAR_1->s_mapped[VAR_4][table[VAR_5] - VAR_1->kx[1]], additional_sinusoid_present,
(table[VAR_5 + 1] - table[VAR_5]) * sizeof(VAR_1->s_mapped[VAR_4][0]));
}
}
memcpy(VAR_2->s_indexmapped[0], VAR_2->s_indexmapped[VAR_2->bs_num_env], sizeof(VAR_2->s_indexmapped[0]));
}
| [
"static void FUNC_0(AACContext *VAR_0, SpectralBandReplication *VAR_1,\nSBRData *VAR_2, int VAR_3[2])\n{",
"int VAR_4, VAR_5, VAR_6;",
"memset(VAR_2->s_indexmapped[1], 0, 7*sizeof(VAR_2->s_indexmapped[1]));",
"for (VAR_4 = 0; VAR_4 < VAR_2->bs_num_env; VAR_4++) {",
"const unsigned int ilim = VAR_1->n[VAR_2->bs_freq_res[VAR_4 + 1]];",
"uint16_t *table = VAR_2->bs_freq_res[VAR_4 + 1] ? VAR_1->f_tablehigh : VAR_1->f_tablelow;",
"int k;",
"for (VAR_5 = 0; VAR_5 < ilim; VAR_5++)",
"for (VAR_6 = table[VAR_5]; VAR_6 < table[VAR_5 + 1]; VAR_6++)",
"VAR_1->e_origmapped[VAR_4][VAR_6 - VAR_1->kx[1]] = VAR_2->env_facs[VAR_4+1][VAR_5];",
"k = (VAR_2->bs_num_noise > 1) && (VAR_2->t_env[VAR_4] >= VAR_2->t_q[1]);",
"for (VAR_5 = 0; VAR_5 < VAR_1->n_q; VAR_5++)",
"for (VAR_6 = VAR_1->f_tablenoise[VAR_5]; VAR_6 < VAR_1->f_tablenoise[VAR_5 + 1]; VAR_6++)",
"VAR_1->q_mapped[VAR_4][VAR_6 - VAR_1->kx[1]] = VAR_2->noise_facs[k+1][VAR_5];",
"for (VAR_5 = 0; VAR_5 < VAR_1->n[1]; VAR_5++) {",
"if (VAR_2->bs_add_harmonic_flag) {",
"const unsigned int m_midpoint =\n(VAR_1->f_tablehigh[VAR_5] + VAR_1->f_tablehigh[VAR_5 + 1]) >> 1;",
"VAR_2->s_indexmapped[VAR_4 + 1][m_midpoint - VAR_1->kx[1]] = VAR_2->bs_add_harmonic[VAR_5] *\n(VAR_4 >= VAR_3[1] || (VAR_2->s_indexmapped[0][m_midpoint - VAR_1->kx[1]] == 1));",
"}",
"}",
"for (VAR_5 = 0; VAR_5 < ilim; VAR_5++) {",
"int additional_sinusoid_present = 0;",
"for (VAR_6 = table[VAR_5]; VAR_6 < table[VAR_5 + 1]; VAR_6++) {",
"if (VAR_2->s_indexmapped[VAR_4 + 1][VAR_6 - VAR_1->kx[1]]) {",
"additional_sinusoid_present = 1;",
"break;",
"}",
"}",
"memset(&VAR_1->s_mapped[VAR_4][table[VAR_5] - VAR_1->kx[1]], additional_sinusoid_present,\n(table[VAR_5 + 1] - table[VAR_5]) * sizeof(VAR_1->s_mapped[VAR_4][0]));",
"}",
"}",
"memcpy(VAR_2->s_indexmapped[0], VAR_2->s_indexmapped[VAR_2->bs_num_env], sizeof(VAR_2->s_indexmapped[0]));",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47,
49
],
[
53,
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
89
],
[
91
]
] |
23,966 | static void draw_mandelbrot(AVFilterContext *ctx, uint32_t *color, int linesize, int64_t pts)
{
MBContext *mb = ctx->priv;
int x,y,i, in_cidx=0, next_cidx=0, tmp_cidx;
double scale= mb->start_scale*pow(mb->end_scale/mb->start_scale, pts/mb->end_pts);
int use_zyklus=0;
fill_from_cache(ctx, NULL, &in_cidx, NULL, mb->start_y+scale*(-mb->h/2-0.5), scale);
tmp_cidx= in_cidx;
memset(color, 0, sizeof(*color)*mb->w);
for(y=0; y<mb->h; y++){
int y1= y+1;
const double ci=mb->start_y+scale*(y-mb->h/2);
fill_from_cache(ctx, NULL, &in_cidx, &next_cidx, ci, scale);
if(y1<mb->h){
memset(color+linesize*y1, 0, sizeof(*color)*mb->w);
fill_from_cache(ctx, color+linesize*y1, &tmp_cidx, NULL, ci + 3*scale/2, scale);
}
for(x=0; x<mb->w; x++){
float epsilon;
const double cr=mb->start_x+scale*(x-mb->w/2);
double zr=cr;
double zi=ci;
uint32_t c=0;
double dv= mb->dither / (double)(1LL<<32);
mb->dither= mb->dither*1664525+1013904223;
if(color[x + y*linesize] & 0xFF000000)
continue;
if(interpol(mb, color, x, y, linesize)){
if(next_cidx < mb->cache_allocated){
mb->next_cache[next_cidx ].p[0]= cr;
mb->next_cache[next_cidx ].p[1]= ci;
mb->next_cache[next_cidx++].val = color[x + y*linesize];
}
continue;
}
use_zyklus= (x==0 || mb->inner!=BLACK ||color[x-1 + y*linesize] == 0xFF000000);
if(use_zyklus)
epsilon= scale*1*sqrt(SQR(x-mb->w/2) + SQR(y-mb->h/2))/mb->w;
#define Z_Z2_C(outr,outi,inr,ini)\
outr= inr*inr - ini*ini + cr;\
outi= 2*inr*ini + ci;
#define Z_Z2_C_ZYKLUS(outr,outi,inr,ini, Z)\
Z_Z2_C(outr,outi,inr,ini)\
if(use_zyklus){\
if(Z && fabs(mb->zyklus[i>>1][0]-outr)+fabs(mb->zyklus[i>>1][1]-outi) <= epsilon)\
break;\
}\
mb->zyklus[i][0]= outr;\
mb->zyklus[i][1]= outi;\
for(i=0; i<mb->maxiter-8; i++){
double t;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
i++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
i++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
i++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
if(zr*zr + zi*zi > mb->bailout){
i-= FFMIN(7, i);
for(; i<mb->maxiter; i++){
zr= mb->zyklus[i][0];
zi= mb->zyklus[i][1];
if(zr*zr + zi*zi > mb->bailout){
switch(mb->outer){
case ITERATION_COUNT: zr = i; break;
case NORMALIZED_ITERATION_COUNT: zr= i + log2(log(mb->bailout) / log(zr*zr + zi*zi)); break;
}
c= lrintf((sin(zr)+1)*127) + lrintf((sin(zr/1.234)+1)*127)*256*256 + lrintf((sin(zr/100)+1)*127)*256;
break;
}
}
break;
}
}
if(!c){
if(mb->inner==PERIOD){
int j;
for(j=i-1; j; j--)
if(SQR(mb->zyklus[j][0]-zr) + SQR(mb->zyklus[j][1]-zi) < epsilon*epsilon*10)
break;
if(j){
c= i-j;
c= ((c<<5)&0xE0) + ((c<<16)&0xE000) + ((c<<27)&0xE00000);
}
}else if(mb->inner==CONVTIME){
c= floor(i*255.0/mb->maxiter+dv)*0x010101;
} else if(mb->inner==MINCOL){
int j;
double closest=9999;
int closest_index=0;
for(j=i-1; j>=0; j--)
if(SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]) < closest){
closest= SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]);
closest_index= j;
}
closest = sqrt(closest);
c= lrintf((mb->zyklus[closest_index][0]/closest+1)*127+dv) + lrintf((mb->zyklus[closest_index][1]/closest+1)*127+dv)*256;
}
}
c |= 0xFF000000;
color[x + y*linesize]= c;
if(next_cidx < mb->cache_allocated){
mb->next_cache[next_cidx ].p[0]= cr;
mb->next_cache[next_cidx ].p[1]= ci;
mb->next_cache[next_cidx++].val = c;
}
}
fill_from_cache(ctx, NULL, &in_cidx, &next_cidx, ci + scale/2, scale);
}
FFSWAP(void*, mb->next_cache, mb->point_cache);
mb->cache_used = next_cidx;
if(mb->cache_used == mb->cache_allocated)
av_log(0, AV_LOG_INFO, "Mandelbrot cache is too small!\n");
}
| true | FFmpeg | 656911d84da9205c004c17c9fb14815f86a7db93 | static void draw_mandelbrot(AVFilterContext *ctx, uint32_t *color, int linesize, int64_t pts)
{
MBContext *mb = ctx->priv;
int x,y,i, in_cidx=0, next_cidx=0, tmp_cidx;
double scale= mb->start_scale*pow(mb->end_scale/mb->start_scale, pts/mb->end_pts);
int use_zyklus=0;
fill_from_cache(ctx, NULL, &in_cidx, NULL, mb->start_y+scale*(-mb->h/2-0.5), scale);
tmp_cidx= in_cidx;
memset(color, 0, sizeof(*color)*mb->w);
for(y=0; y<mb->h; y++){
int y1= y+1;
const double ci=mb->start_y+scale*(y-mb->h/2);
fill_from_cache(ctx, NULL, &in_cidx, &next_cidx, ci, scale);
if(y1<mb->h){
memset(color+linesize*y1, 0, sizeof(*color)*mb->w);
fill_from_cache(ctx, color+linesize*y1, &tmp_cidx, NULL, ci + 3*scale/2, scale);
}
for(x=0; x<mb->w; x++){
float epsilon;
const double cr=mb->start_x+scale*(x-mb->w/2);
double zr=cr;
double zi=ci;
uint32_t c=0;
double dv= mb->dither / (double)(1LL<<32);
mb->dither= mb->dither*1664525+1013904223;
if(color[x + y*linesize] & 0xFF000000)
continue;
if(interpol(mb, color, x, y, linesize)){
if(next_cidx < mb->cache_allocated){
mb->next_cache[next_cidx ].p[0]= cr;
mb->next_cache[next_cidx ].p[1]= ci;
mb->next_cache[next_cidx++].val = color[x + y*linesize];
}
continue;
}
use_zyklus= (x==0 || mb->inner!=BLACK ||color[x-1 + y*linesize] == 0xFF000000);
if(use_zyklus)
epsilon= scale*1*sqrt(SQR(x-mb->w/2) + SQR(y-mb->h/2))/mb->w;
#define Z_Z2_C(outr,outi,inr,ini)\
outr= inr*inr - ini*ini + cr;\
outi= 2*inr*ini + ci;
#define Z_Z2_C_ZYKLUS(outr,outi,inr,ini, Z)\
Z_Z2_C(outr,outi,inr,ini)\
if(use_zyklus){\
if(Z && fabs(mb->zyklus[i>>1][0]-outr)+fabs(mb->zyklus[i>>1][1]-outi) <= epsilon)\
break;\
}\
mb->zyklus[i][0]= outr;\
mb->zyklus[i][1]= outi;\
for(i=0; i<mb->maxiter-8; i++){
double t;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
i++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
i++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
i++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
i++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
if(zr*zr + zi*zi > mb->bailout){
i-= FFMIN(7, i);
for(; i<mb->maxiter; i++){
zr= mb->zyklus[i][0];
zi= mb->zyklus[i][1];
if(zr*zr + zi*zi > mb->bailout){
switch(mb->outer){
case ITERATION_COUNT: zr = i; break;
case NORMALIZED_ITERATION_COUNT: zr= i + log2(log(mb->bailout) / log(zr*zr + zi*zi)); break;
}
c= lrintf((sin(zr)+1)*127) + lrintf((sin(zr/1.234)+1)*127)*256*256 + lrintf((sin(zr/100)+1)*127)*256;
break;
}
}
break;
}
}
if(!c){
if(mb->inner==PERIOD){
int j;
for(j=i-1; j; j--)
if(SQR(mb->zyklus[j][0]-zr) + SQR(mb->zyklus[j][1]-zi) < epsilon*epsilon*10)
break;
if(j){
c= i-j;
c= ((c<<5)&0xE0) + ((c<<16)&0xE000) + ((c<<27)&0xE00000);
}
}else if(mb->inner==CONVTIME){
c= floor(i*255.0/mb->maxiter+dv)*0x010101;
} else if(mb->inner==MINCOL){
int j;
double closest=9999;
int closest_index=0;
for(j=i-1; j>=0; j--)
if(SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]) < closest){
closest= SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]);
closest_index= j;
}
closest = sqrt(closest);
c= lrintf((mb->zyklus[closest_index][0]/closest+1)*127+dv) + lrintf((mb->zyklus[closest_index][1]/closest+1)*127+dv)*256;
}
}
c |= 0xFF000000;
color[x + y*linesize]= c;
if(next_cidx < mb->cache_allocated){
mb->next_cache[next_cidx ].p[0]= cr;
mb->next_cache[next_cidx ].p[1]= ci;
mb->next_cache[next_cidx++].val = c;
}
}
fill_from_cache(ctx, NULL, &in_cidx, &next_cidx, ci + scale/2, scale);
}
FFSWAP(void*, mb->next_cache, mb->point_cache);
mb->cache_used = next_cidx;
if(mb->cache_used == mb->cache_allocated)
av_log(0, AV_LOG_INFO, "Mandelbrot cache is too small!\n");
}
| {
"code": [
" float epsilon;"
],
"line_no": [
39
]
} | static void FUNC_0(AVFilterContext *VAR_0, uint32_t *VAR_1, int VAR_2, int64_t VAR_3)
{
MBContext *mb = VAR_0->priv;
int VAR_4,VAR_5,VAR_6, VAR_7=0, VAR_8=0, VAR_9;
double VAR_10= mb->start_scale*pow(mb->end_scale/mb->start_scale, VAR_3/mb->end_pts);
int VAR_11=0;
fill_from_cache(VAR_0, NULL, &VAR_7, NULL, mb->start_y+VAR_10*(-mb->h/2-0.5), VAR_10);
VAR_9= VAR_7;
memset(VAR_1, 0, sizeof(*VAR_1)*mb->w);
for(VAR_5=0; VAR_5<mb->h; VAR_5++){
int y1= VAR_5+1;
const double ci=mb->start_y+VAR_10*(VAR_5-mb->h/2);
fill_from_cache(VAR_0, NULL, &VAR_7, &VAR_8, ci, VAR_10);
if(y1<mb->h){
memset(VAR_1+VAR_2*y1, 0, sizeof(*VAR_1)*mb->w);
fill_from_cache(VAR_0, VAR_1+VAR_2*y1, &VAR_9, NULL, ci + 3*VAR_10/2, VAR_10);
}
for(VAR_4=0; VAR_4<mb->w; VAR_4++){
float epsilon;
const double cr=mb->start_x+VAR_10*(VAR_4-mb->w/2);
double zr=cr;
double zi=ci;
uint32_t c=0;
double dv= mb->dither / (double)(1LL<<32);
mb->dither= mb->dither*1664525+1013904223;
if(VAR_1[VAR_4 + VAR_5*VAR_2] & 0xFF000000)
continue;
if(interpol(mb, VAR_1, VAR_4, VAR_5, VAR_2)){
if(VAR_8 < mb->cache_allocated){
mb->next_cache[VAR_8 ].p[0]= cr;
mb->next_cache[VAR_8 ].p[1]= ci;
mb->next_cache[VAR_8++].val = VAR_1[VAR_4 + VAR_5*VAR_2];
}
continue;
}
VAR_11= (VAR_4==0 || mb->inner!=BLACK ||VAR_1[VAR_4-1 + VAR_5*VAR_2] == 0xFF000000);
if(VAR_11)
epsilon= VAR_10*1*sqrt(SQR(VAR_4-mb->w/2) + SQR(VAR_5-mb->h/2))/mb->w;
#define Z_Z2_C(outr,outi,inr,ini)\
outr= inr*inr - ini*ini + cr;\
outi= 2*inr*ini + ci;
#define Z_Z2_C_ZYKLUS(outr,outi,inr,ini, Z)\
Z_Z2_C(outr,outi,inr,ini)\
if(VAR_11){\
if(Z && fabs(mb->zyklus[VAR_6>>1][0]-outr)+fabs(mb->zyklus[VAR_6>>1][1]-outi) <= epsilon)\
break;\
}\
mb->zyklus[VAR_6][0]= outr;\
mb->zyklus[VAR_6][1]= outi;\
for(VAR_6=0; VAR_6<mb->maxiter-8; VAR_6++){
double t;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
VAR_6++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
VAR_6++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
VAR_6++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
VAR_6++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
VAR_6++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
VAR_6++;
Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
VAR_6++;
Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
if(zr*zr + zi*zi > mb->bailout){
VAR_6-= FFMIN(7, VAR_6);
for(; VAR_6<mb->maxiter; VAR_6++){
zr= mb->zyklus[VAR_6][0];
zi= mb->zyklus[VAR_6][1];
if(zr*zr + zi*zi > mb->bailout){
switch(mb->outer){
case ITERATION_COUNT: zr = VAR_6; break;
case NORMALIZED_ITERATION_COUNT: zr= VAR_6 + log2(log(mb->bailout) / log(zr*zr + zi*zi)); break;
}
c= lrintf((sin(zr)+1)*127) + lrintf((sin(zr/1.234)+1)*127)*256*256 + lrintf((sin(zr/100)+1)*127)*256;
break;
}
}
break;
}
}
if(!c){
if(mb->inner==PERIOD){
int j;
for(j=VAR_6-1; j; j--)
if(SQR(mb->zyklus[j][0]-zr) + SQR(mb->zyklus[j][1]-zi) < epsilon*epsilon*10)
break;
if(j){
c= VAR_6-j;
c= ((c<<5)&0xE0) + ((c<<16)&0xE000) + ((c<<27)&0xE00000);
}
}else if(mb->inner==CONVTIME){
c= floor(VAR_6*255.0/mb->maxiter+dv)*0x010101;
} else if(mb->inner==MINCOL){
int j;
double closest=9999;
int closest_index=0;
for(j=VAR_6-1; j>=0; j--)
if(SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]) < closest){
closest= SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]);
closest_index= j;
}
closest = sqrt(closest);
c= lrintf((mb->zyklus[closest_index][0]/closest+1)*127+dv) + lrintf((mb->zyklus[closest_index][1]/closest+1)*127+dv)*256;
}
}
c |= 0xFF000000;
VAR_1[VAR_4 + VAR_5*VAR_2]= c;
if(VAR_8 < mb->cache_allocated){
mb->next_cache[VAR_8 ].p[0]= cr;
mb->next_cache[VAR_8 ].p[1]= ci;
mb->next_cache[VAR_8++].val = c;
}
}
fill_from_cache(VAR_0, NULL, &VAR_7, &VAR_8, ci + VAR_10/2, VAR_10);
}
FFSWAP(void*, mb->next_cache, mb->point_cache);
mb->cache_used = VAR_8;
if(mb->cache_used == mb->cache_allocated)
av_log(0, AV_LOG_INFO, "Mandelbrot cache is too small!\n");
}
| [
"static void FUNC_0(AVFilterContext *VAR_0, uint32_t *VAR_1, int VAR_2, int64_t VAR_3)\n{",
"MBContext *mb = VAR_0->priv;",
"int VAR_4,VAR_5,VAR_6, VAR_7=0, VAR_8=0, VAR_9;",
"double VAR_10= mb->start_scale*pow(mb->end_scale/mb->start_scale, VAR_3/mb->end_pts);",
"int VAR_11=0;",
"fill_from_cache(VAR_0, NULL, &VAR_7, NULL, mb->start_y+VAR_10*(-mb->h/2-0.5), VAR_10);",
"VAR_9= VAR_7;",
"memset(VAR_1, 0, sizeof(*VAR_1)*mb->w);",
"for(VAR_5=0; VAR_5<mb->h; VAR_5++){",
"int y1= VAR_5+1;",
"const double ci=mb->start_y+VAR_10*(VAR_5-mb->h/2);",
"fill_from_cache(VAR_0, NULL, &VAR_7, &VAR_8, ci, VAR_10);",
"if(y1<mb->h){",
"memset(VAR_1+VAR_2*y1, 0, sizeof(*VAR_1)*mb->w);",
"fill_from_cache(VAR_0, VAR_1+VAR_2*y1, &VAR_9, NULL, ci + 3*VAR_10/2, VAR_10);",
"}",
"for(VAR_4=0; VAR_4<mb->w; VAR_4++){",
"float epsilon;",
"const double cr=mb->start_x+VAR_10*(VAR_4-mb->w/2);",
"double zr=cr;",
"double zi=ci;",
"uint32_t c=0;",
"double dv= mb->dither / (double)(1LL<<32);",
"mb->dither= mb->dither*1664525+1013904223;",
"if(VAR_1[VAR_4 + VAR_5*VAR_2] & 0xFF000000)\ncontinue;",
"if(interpol(mb, VAR_1, VAR_4, VAR_5, VAR_2)){",
"if(VAR_8 < mb->cache_allocated){",
"mb->next_cache[VAR_8 ].p[0]= cr;",
"mb->next_cache[VAR_8 ].p[1]= ci;",
"mb->next_cache[VAR_8++].val = VAR_1[VAR_4 + VAR_5*VAR_2];",
"}",
"continue;",
"}",
"VAR_11= (VAR_4==0 || mb->inner!=BLACK ||VAR_1[VAR_4-1 + VAR_5*VAR_2] == 0xFF000000);",
"if(VAR_11)\nepsilon= VAR_10*1*sqrt(SQR(VAR_4-mb->w/2) + SQR(VAR_5-mb->h/2))/mb->w;",
"#define Z_Z2_C(outr,outi,inr,ini)\\\noutr= inr*inr - ini*ini + cr;\\",
"outi= 2*inr*ini + ci;",
"#define Z_Z2_C_ZYKLUS(outr,outi,inr,ini, Z)\\\nZ_Z2_C(outr,outi,inr,ini)\\\nif(VAR_11){\\",
"if(Z && fabs(mb->zyklus[VAR_6>>1][0]-outr)+fabs(mb->zyklus[VAR_6>>1][1]-outi) <= epsilon)\\\nbreak;\\",
"}\\",
"mb->zyklus[VAR_6][0]= outr;\\",
"mb->zyklus[VAR_6][1]= outi;\\",
"for(VAR_6=0; VAR_6<mb->maxiter-8; VAR_6++){",
"double t;",
"Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)\nVAR_6++;",
"Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)\nif(zr*zr + zi*zi > mb->bailout){",
"VAR_6-= FFMIN(7, VAR_6);",
"for(; VAR_6<mb->maxiter; VAR_6++){",
"zr= mb->zyklus[VAR_6][0];",
"zi= mb->zyklus[VAR_6][1];",
"if(zr*zr + zi*zi > mb->bailout){",
"switch(mb->outer){",
"case ITERATION_COUNT: zr = VAR_6; break;",
"case NORMALIZED_ITERATION_COUNT: zr= VAR_6 + log2(log(mb->bailout) / log(zr*zr + zi*zi)); break;",
"}",
"c= lrintf((sin(zr)+1)*127) + lrintf((sin(zr/1.234)+1)*127)*256*256 + lrintf((sin(zr/100)+1)*127)*256;",
"break;",
"}",
"}",
"break;",
"}",
"}",
"if(!c){",
"if(mb->inner==PERIOD){",
"int j;",
"for(j=VAR_6-1; j; j--)",
"if(SQR(mb->zyklus[j][0]-zr) + SQR(mb->zyklus[j][1]-zi) < epsilon*epsilon*10)\nbreak;",
"if(j){",
"c= VAR_6-j;",
"c= ((c<<5)&0xE0) + ((c<<16)&0xE000) + ((c<<27)&0xE00000);",
"}",
"}else if(mb->inner==CONVTIME){",
"c= floor(VAR_6*255.0/mb->maxiter+dv)*0x010101;",
"} else if(mb->inner==MINCOL){",
"int j;",
"double closest=9999;",
"int closest_index=0;",
"for(j=VAR_6-1; j>=0; j--)",
"if(SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]) < closest){",
"closest= SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]);",
"closest_index= j;",
"}",
"closest = sqrt(closest);",
"c= lrintf((mb->zyklus[closest_index][0]/closest+1)*127+dv) + lrintf((mb->zyklus[closest_index][1]/closest+1)*127+dv)*256;",
"}",
"}",
"c |= 0xFF000000;",
"VAR_1[VAR_4 + VAR_5*VAR_2]= c;",
"if(VAR_8 < mb->cache_allocated){",
"mb->next_cache[VAR_8 ].p[0]= cr;",
"mb->next_cache[VAR_8 ].p[1]= ci;",
"mb->next_cache[VAR_8++].val = c;",
"}",
"}",
"fill_from_cache(VAR_0, NULL, &VAR_7, &VAR_8, ci + VAR_10/2, VAR_10);",
"}",
"FFSWAP(void*, mb->next_cache, mb->point_cache);",
"mb->cache_used = VAR_8;",
"if(mb->cache_used == mb->cache_allocated)\nav_log(0, AV_LOG_INFO, \"Mandelbrot cache is too small!\\n\");",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79,
81
],
[
85,
87
],
[
89
],
[
93,
95,
97
],
[
99,
101
],
[
103
],
[
105
],
[
107
],
[
115
],
[
117
],
[
119,
121
],
[
123,
125
],
[
127,
129
],
[
131,
133
],
[
135,
137
],
[
139,
141
],
[
143,
145
],
[
147,
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191,
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257,
259
],
[
261
]
] |
23,967 | static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb,
RMDemuxContext *rm, RMStream *vst,
AVPacket *pkt, int len, int *pseq,
int64_t *timestamp)
{
int hdr, seq, pic_num, len2, pos;
int type;
hdr = avio_r8(pb); len--;
type = hdr >> 6;
if(type != 3){ // not frame as a part of packet
seq = avio_r8(pb); len--;
}
if(type != 1){ // not whole frame
len2 = get_num(pb, &len);
pos = get_num(pb, &len);
pic_num = avio_r8(pb); len--;
}
if(len<0)
return -1;
rm->remaining_len = len;
if(type&1){ // frame, not slice
if(type == 3){ // frame as a part of packet
len= len2;
*timestamp = pos;
}
if(rm->remaining_len < len)
return -1;
rm->remaining_len -= len;
if(av_new_packet(pkt, len + 9) < 0)
return AVERROR(EIO);
pkt->data[0] = 0;
AV_WL32(pkt->data + 1, 1);
AV_WL32(pkt->data + 5, 0);
avio_read(pb, pkt->data + 9, len);
return 0;
}
//now we have to deal with single slice
*pseq = seq;
if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){
vst->slices = ((hdr & 0x3F) << 1) + 1;
vst->videobufsize = len2 + 8*vst->slices + 1;
av_free_packet(&vst->pkt); //FIXME this should be output.
if(av_new_packet(&vst->pkt, vst->videobufsize) < 0)
return AVERROR(ENOMEM);
vst->videobufpos = 8*vst->slices + 1;
vst->cur_slice = 0;
vst->curpic_num = pic_num;
vst->pktpos = avio_tell(pb);
}
if(type == 2)
len = FFMIN(len, pos);
if(++vst->cur_slice > vst->slices)
return 1;
AV_WL32(vst->pkt.data - 7 + 8*vst->cur_slice, 1);
AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1);
if(vst->videobufpos + len > vst->videobufsize)
return 1;
if (avio_read(pb, vst->pkt.data + vst->videobufpos, len) != len)
return AVERROR(EIO);
vst->videobufpos += len;
rm->remaining_len-= len;
if (type == 2 || vst->videobufpos == vst->videobufsize) {
vst->pkt.data[0] = vst->cur_slice-1;
*pkt= vst->pkt;
vst->pkt.data= NULL;
vst->pkt.size= 0;
if(vst->slices != vst->cur_slice) //FIXME find out how to set slices correct from the begin
memmove(pkt->data + 1 + 8*vst->cur_slice, pkt->data + 1 + 8*vst->slices,
vst->videobufpos - 1 - 8*vst->slices);
pkt->size = vst->videobufpos + 8*(vst->cur_slice - vst->slices);
pkt->pts = AV_NOPTS_VALUE;
pkt->pos = vst->pktpos;
vst->slices = 0;
return 0;
}
return 1;
}
| true | FFmpeg | 7fc73d9ab781f66b63f3bbe2f384f4f639ae78e9 | static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb,
RMDemuxContext *rm, RMStream *vst,
AVPacket *pkt, int len, int *pseq,
int64_t *timestamp)
{
int hdr, seq, pic_num, len2, pos;
int type;
hdr = avio_r8(pb); len--;
type = hdr >> 6;
if(type != 3){
seq = avio_r8(pb); len--;
}
if(type != 1){
len2 = get_num(pb, &len);
pos = get_num(pb, &len);
pic_num = avio_r8(pb); len--;
}
if(len<0)
return -1;
rm->remaining_len = len;
if(type&1){
if(type == 3){
len= len2;
*timestamp = pos;
}
if(rm->remaining_len < len)
return -1;
rm->remaining_len -= len;
if(av_new_packet(pkt, len + 9) < 0)
return AVERROR(EIO);
pkt->data[0] = 0;
AV_WL32(pkt->data + 1, 1);
AV_WL32(pkt->data + 5, 0);
avio_read(pb, pkt->data + 9, len);
return 0;
}
*pseq = seq;
if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){
vst->slices = ((hdr & 0x3F) << 1) + 1;
vst->videobufsize = len2 + 8*vst->slices + 1;
av_free_packet(&vst->pkt);
if(av_new_packet(&vst->pkt, vst->videobufsize) < 0)
return AVERROR(ENOMEM);
vst->videobufpos = 8*vst->slices + 1;
vst->cur_slice = 0;
vst->curpic_num = pic_num;
vst->pktpos = avio_tell(pb);
}
if(type == 2)
len = FFMIN(len, pos);
if(++vst->cur_slice > vst->slices)
return 1;
AV_WL32(vst->pkt.data - 7 + 8*vst->cur_slice, 1);
AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1);
if(vst->videobufpos + len > vst->videobufsize)
return 1;
if (avio_read(pb, vst->pkt.data + vst->videobufpos, len) != len)
return AVERROR(EIO);
vst->videobufpos += len;
rm->remaining_len-= len;
if (type == 2 || vst->videobufpos == vst->videobufsize) {
vst->pkt.data[0] = vst->cur_slice-1;
*pkt= vst->pkt;
vst->pkt.data= NULL;
vst->pkt.size= 0;
if(vst->slices != vst->cur_slice)
memmove(pkt->data + 1 + 8*vst->cur_slice, pkt->data + 1 + 8*vst->slices,
vst->videobufpos - 1 - 8*vst->slices);
pkt->size = vst->videobufpos + 8*(vst->cur_slice - vst->slices);
pkt->pts = AV_NOPTS_VALUE;
pkt->pos = vst->pktpos;
vst->slices = 0;
return 0;
}
return 1;
}
| {
"code": [
" int hdr, seq, pic_num, len2, pos;"
],
"line_no": [
11
]
} | static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1,
RMDemuxContext *VAR_2, RMStream *VAR_3,
AVPacket *VAR_4, int VAR_5, int *VAR_6,
int64_t *VAR_7)
{
int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;
int VAR_13;
VAR_8 = avio_r8(VAR_1); VAR_5--;
VAR_13 = VAR_8 >> 6;
if(VAR_13 != 3){
VAR_9 = avio_r8(VAR_1); VAR_5--;
}
if(VAR_13 != 1){
VAR_11 = get_num(VAR_1, &VAR_5);
VAR_12 = get_num(VAR_1, &VAR_5);
VAR_10 = avio_r8(VAR_1); VAR_5--;
}
if(VAR_5<0)
return -1;
VAR_2->remaining_len = VAR_5;
if(VAR_13&1){
if(VAR_13 == 3){
VAR_5= VAR_11;
*VAR_7 = VAR_12;
}
if(VAR_2->remaining_len < VAR_5)
return -1;
VAR_2->remaining_len -= VAR_5;
if(av_new_packet(VAR_4, VAR_5 + 9) < 0)
return AVERROR(EIO);
VAR_4->data[0] = 0;
AV_WL32(VAR_4->data + 1, 1);
AV_WL32(VAR_4->data + 5, 0);
avio_read(VAR_1, VAR_4->data + 9, VAR_5);
return 0;
}
*VAR_6 = VAR_9;
if((VAR_9 & 0x7F) == 1 || VAR_3->curpic_num != VAR_10){
VAR_3->slices = ((VAR_8 & 0x3F) << 1) + 1;
VAR_3->videobufsize = VAR_11 + 8*VAR_3->slices + 1;
av_free_packet(&VAR_3->VAR_4);
if(av_new_packet(&VAR_3->VAR_4, VAR_3->videobufsize) < 0)
return AVERROR(ENOMEM);
VAR_3->videobufpos = 8*VAR_3->slices + 1;
VAR_3->cur_slice = 0;
VAR_3->curpic_num = VAR_10;
VAR_3->pktpos = avio_tell(VAR_1);
}
if(VAR_13 == 2)
VAR_5 = FFMIN(VAR_5, VAR_12);
if(++VAR_3->cur_slice > VAR_3->slices)
return 1;
AV_WL32(VAR_3->VAR_4.data - 7 + 8*VAR_3->cur_slice, 1);
AV_WL32(VAR_3->VAR_4.data - 3 + 8*VAR_3->cur_slice, VAR_3->videobufpos - 8*VAR_3->slices - 1);
if(VAR_3->videobufpos + VAR_5 > VAR_3->videobufsize)
return 1;
if (avio_read(VAR_1, VAR_3->VAR_4.data + VAR_3->videobufpos, VAR_5) != VAR_5)
return AVERROR(EIO);
VAR_3->videobufpos += VAR_5;
VAR_2->remaining_len-= VAR_5;
if (VAR_13 == 2 || VAR_3->videobufpos == VAR_3->videobufsize) {
VAR_3->VAR_4.data[0] = VAR_3->cur_slice-1;
*VAR_4= VAR_3->VAR_4;
VAR_3->VAR_4.data= NULL;
VAR_3->VAR_4.size= 0;
if(VAR_3->slices != VAR_3->cur_slice)
memmove(VAR_4->data + 1 + 8*VAR_3->cur_slice, VAR_4->data + 1 + 8*VAR_3->slices,
VAR_3->videobufpos - 1 - 8*VAR_3->slices);
VAR_4->size = VAR_3->videobufpos + 8*(VAR_3->cur_slice - VAR_3->slices);
VAR_4->pts = AV_NOPTS_VALUE;
VAR_4->VAR_12 = VAR_3->pktpos;
VAR_3->slices = 0;
return 0;
}
return 1;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1,\nRMDemuxContext *VAR_2, RMStream *VAR_3,\nAVPacket *VAR_4, int VAR_5, int *VAR_6,\nint64_t *VAR_7)\n{",
"int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;",
"int VAR_13;",
"VAR_8 = avio_r8(VAR_1); VAR_5--;",
"VAR_13 = VAR_8 >> 6;",
"if(VAR_13 != 3){",
"VAR_9 = avio_r8(VAR_1); VAR_5--;",
"}",
"if(VAR_13 != 1){",
"VAR_11 = get_num(VAR_1, &VAR_5);",
"VAR_12 = get_num(VAR_1, &VAR_5);",
"VAR_10 = avio_r8(VAR_1); VAR_5--;",
"}",
"if(VAR_5<0)\nreturn -1;",
"VAR_2->remaining_len = VAR_5;",
"if(VAR_13&1){",
"if(VAR_13 == 3){",
"VAR_5= VAR_11;",
"*VAR_7 = VAR_12;",
"}",
"if(VAR_2->remaining_len < VAR_5)\nreturn -1;",
"VAR_2->remaining_len -= VAR_5;",
"if(av_new_packet(VAR_4, VAR_5 + 9) < 0)\nreturn AVERROR(EIO);",
"VAR_4->data[0] = 0;",
"AV_WL32(VAR_4->data + 1, 1);",
"AV_WL32(VAR_4->data + 5, 0);",
"avio_read(VAR_1, VAR_4->data + 9, VAR_5);",
"return 0;",
"}",
"*VAR_6 = VAR_9;",
"if((VAR_9 & 0x7F) == 1 || VAR_3->curpic_num != VAR_10){",
"VAR_3->slices = ((VAR_8 & 0x3F) << 1) + 1;",
"VAR_3->videobufsize = VAR_11 + 8*VAR_3->slices + 1;",
"av_free_packet(&VAR_3->VAR_4);",
"if(av_new_packet(&VAR_3->VAR_4, VAR_3->videobufsize) < 0)\nreturn AVERROR(ENOMEM);",
"VAR_3->videobufpos = 8*VAR_3->slices + 1;",
"VAR_3->cur_slice = 0;",
"VAR_3->curpic_num = VAR_10;",
"VAR_3->pktpos = avio_tell(VAR_1);",
"}",
"if(VAR_13 == 2)\nVAR_5 = FFMIN(VAR_5, VAR_12);",
"if(++VAR_3->cur_slice > VAR_3->slices)\nreturn 1;",
"AV_WL32(VAR_3->VAR_4.data - 7 + 8*VAR_3->cur_slice, 1);",
"AV_WL32(VAR_3->VAR_4.data - 3 + 8*VAR_3->cur_slice, VAR_3->videobufpos - 8*VAR_3->slices - 1);",
"if(VAR_3->videobufpos + VAR_5 > VAR_3->videobufsize)\nreturn 1;",
"if (avio_read(VAR_1, VAR_3->VAR_4.data + VAR_3->videobufpos, VAR_5) != VAR_5)\nreturn AVERROR(EIO);",
"VAR_3->videobufpos += VAR_5;",
"VAR_2->remaining_len-= VAR_5;",
"if (VAR_13 == 2 || VAR_3->videobufpos == VAR_3->videobufsize) {",
"VAR_3->VAR_4.data[0] = VAR_3->cur_slice-1;",
"*VAR_4= VAR_3->VAR_4;",
"VAR_3->VAR_4.data= NULL;",
"VAR_3->VAR_4.size= 0;",
"if(VAR_3->slices != VAR_3->cur_slice)\nmemmove(VAR_4->data + 1 + 8*VAR_3->cur_slice, VAR_4->data + 1 + 8*VAR_3->slices,\nVAR_3->videobufpos - 1 - 8*VAR_3->slices);",
"VAR_4->size = VAR_3->videobufpos + 8*(VAR_3->cur_slice - VAR_3->slices);",
"VAR_4->pts = AV_NOPTS_VALUE;",
"VAR_4->VAR_12 = VAR_3->pktpos;",
"VAR_3->slices = 0;",
"return 0;",
"}",
"return 1;",
"}"
] | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91,
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
111,
113
],
[
115
],
[
117
],
[
119,
121
],
[
123,
125
],
[
127
],
[
129
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143,
145,
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
163
],
[
165
]
] |
23,968 | aio_write_f(int argc, char **argv)
{
int nr_iov, c;
int pattern = 0xcd;
struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
BlockDriverAIOCB *acb;
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
ctx->Cflag = 1;
break;
case 'q':
ctx->qflag = 1;
break;
case 'P':
pattern = atoi(optarg);
break;
default:
return command_usage(&aio_write_cmd);
}
}
if (optind > argc - 2)
return command_usage(&aio_write_cmd);
ctx->offset = cvtnum(argv[optind]);
if (ctx->offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
if (ctx->offset & 0x1ff) {
printf("offset %lld is not sector aligned\n",
(long long)ctx->offset);
return 0;
}
nr_iov = argc - optind;
ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
gettimeofday(&ctx->t1, NULL);
acb = bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
ctx->qiov.size >> 9, aio_write_done, ctx);
if (!acb)
return -EIO;
return 0;
}
| true | qemu | 7d8abfcb50a33aed369bbd267852cf04009c49e9 | aio_write_f(int argc, char **argv)
{
int nr_iov, c;
int pattern = 0xcd;
struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
BlockDriverAIOCB *acb;
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
ctx->Cflag = 1;
break;
case 'q':
ctx->qflag = 1;
break;
case 'P':
pattern = atoi(optarg);
break;
default:
return command_usage(&aio_write_cmd);
}
}
if (optind > argc - 2)
return command_usage(&aio_write_cmd);
ctx->offset = cvtnum(argv[optind]);
if (ctx->offset < 0) {
printf("non-numeric length argument -- %s\n", argv[optind]);
return 0;
}
optind++;
if (ctx->offset & 0x1ff) {
printf("offset %lld is not sector aligned\n",
(long long)ctx->offset);
return 0;
}
nr_iov = argc - optind;
ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern);
gettimeofday(&ctx->t1, NULL);
acb = bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
ctx->qiov.size >> 9, aio_write_done, ctx);
if (!acb)
return -EIO;
return 0;
}
| {
"code": [
"\t\treturn 0;",
"\t\treturn 0;",
"\t\treturn 0;",
"\t\treturn 0;",
"\t\treturn 0;",
"\t\treturn 0;",
"\t\treturn 0;",
"\t\treturn 0;",
"\tif (optind > argc - 2)",
"\tif (!acb)",
"\tif (optind > argc - 2)",
"\tif (!acb)"
],
"line_no": [
59,
59,
59,
59,
59,
59,
59,
59,
47,
91,
47,
91
]
} | FUNC_0(int VAR_0, char **VAR_1)
{
int VAR_2, VAR_3;
int VAR_4 = 0xcd;
struct aio_ctx *VAR_5 = calloc(1, sizeof(struct aio_ctx));
BlockDriverAIOCB *acb;
while ((VAR_3 = getopt(VAR_0, VAR_1, "CqP:")) != EOF) {
switch (VAR_3) {
case 'C':
VAR_5->Cflag = 1;
break;
case 'q':
VAR_5->qflag = 1;
break;
case 'P':
VAR_4 = atoi(optarg);
break;
default:
return command_usage(&aio_write_cmd);
}
}
if (optind > VAR_0 - 2)
return command_usage(&aio_write_cmd);
VAR_5->offset = cvtnum(VAR_1[optind]);
if (VAR_5->offset < 0) {
printf("non-numeric length argument -- %s\n", VAR_1[optind]);
return 0;
}
optind++;
if (VAR_5->offset & 0x1ff) {
printf("offset %lld is not sector aligned\n",
(long long)VAR_5->offset);
return 0;
}
VAR_2 = VAR_0 - optind;
VAR_5->buf = create_iovec(&VAR_5->qiov, &VAR_1[optind], VAR_2, VAR_4);
gettimeofday(&VAR_5->t1, NULL);
acb = bdrv_aio_writev(bs, VAR_5->offset >> 9, &VAR_5->qiov,
VAR_5->qiov.size >> 9, aio_write_done, VAR_5);
if (!acb)
return -EIO;
return 0;
}
| [
"FUNC_0(int VAR_0, char **VAR_1)\n{",
"int VAR_2, VAR_3;",
"int VAR_4 = 0xcd;",
"struct aio_ctx *VAR_5 = calloc(1, sizeof(struct aio_ctx));",
"BlockDriverAIOCB *acb;",
"while ((VAR_3 = getopt(VAR_0, VAR_1, \"CqP:\")) != EOF) {",
"switch (VAR_3) {",
"case 'C':\nVAR_5->Cflag = 1;",
"break;",
"case 'q':\nVAR_5->qflag = 1;",
"break;",
"case 'P':\nVAR_4 = atoi(optarg);",
"break;",
"default:\nreturn command_usage(&aio_write_cmd);",
"}",
"}",
"if (optind > VAR_0 - 2)\nreturn command_usage(&aio_write_cmd);",
"VAR_5->offset = cvtnum(VAR_1[optind]);",
"if (VAR_5->offset < 0) {",
"printf(\"non-numeric length argument -- %s\\n\", VAR_1[optind]);",
"return 0;",
"}",
"optind++;",
"if (VAR_5->offset & 0x1ff) {",
"printf(\"offset %lld is not sector aligned\\n\",\n(long long)VAR_5->offset);",
"return 0;",
"}",
"VAR_2 = VAR_0 - optind;",
"VAR_5->buf = create_iovec(&VAR_5->qiov, &VAR_1[optind], VAR_2, VAR_4);",
"gettimeofday(&VAR_5->t1, NULL);",
"acb = bdrv_aio_writev(bs, VAR_5->offset >> 9, &VAR_5->qiov,\nVAR_5->qiov.size >> 9, aio_write_done, VAR_5);",
"if (!acb)\nreturn -EIO;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
47,
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
85
],
[
87,
89
],
[
91,
93
],
[
97
],
[
99
]
] |
23,969 | static void debugcon_ioport_write(void *opaque, hwaddr addr, uint64_t val,
unsigned width)
{
DebugconState *s = opaque;
unsigned char ch = val;
#ifdef DEBUG_DEBUGCON
printf(" [debugcon: write addr=0x%04" HWADDR_PRIx " val=0x%02" PRIx64 "]\n", addr, val);
#endif
qemu_chr_fe_write(s->chr, &ch, 1);
}
| true | qemu | 6ab3fc32ea640026726bc5f9f4db622d0954fb8a | static void debugcon_ioport_write(void *opaque, hwaddr addr, uint64_t val,
unsigned width)
{
DebugconState *s = opaque;
unsigned char ch = val;
#ifdef DEBUG_DEBUGCON
printf(" [debugcon: write addr=0x%04" HWADDR_PRIx " val=0x%02" PRIx64 "]\n", addr, val);
#endif
qemu_chr_fe_write(s->chr, &ch, 1);
}
| {
"code": [
" qemu_chr_fe_write(s->chr, &ch, 1);"
],
"line_no": [
21
]
} | static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,
unsigned VAR_3)
{
DebugconState *s = VAR_0;
unsigned char VAR_4 = VAR_2;
#ifdef DEBUG_DEBUGCON
printf(" [debugcon: write VAR_1=0x%04" HWADDR_PRIx " VAR_2=0x%02" PRIx64 "]\n", VAR_1, VAR_2);
#endif
qemu_chr_fe_write(s->chr, &VAR_4, 1);
}
| [
"static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{",
"DebugconState *s = VAR_0;",
"unsigned char VAR_4 = VAR_2;",
"#ifdef DEBUG_DEBUGCON\nprintf(\" [debugcon: write VAR_1=0x%04\" HWADDR_PRIx \" VAR_2=0x%02\" PRIx64 \"]\\n\", VAR_1, VAR_2);",
"#endif\nqemu_chr_fe_write(s->chr, &VAR_4, 1);",
"}"
] | [
0,
0,
0,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13,
15
],
[
17,
21
],
[
23
]
] |
23,970 | static void nal_send(AVFormatContext *s1, const uint8_t *buf, int size, int last)
{
RTPMuxContext *s = s1->priv_data;
av_log(s1, AV_LOG_DEBUG, "Sending NAL %x of len %d M=%d\n", buf[0] & 0x1F, size, last);
if (size <= s->max_payload_size) {
int buffered_size = s->buf_ptr - s->buf;
// Flush buffered NAL units if the current unit doesn't fit
if (buffered_size + 2 + size > s->max_payload_size) {
flush_buffered(s1, 0);
buffered_size = 0;
}
// If we aren't using mode 0, and the NAL unit fits including the
// framing (2 bytes length, plus 1 byte for the STAP-A marker),
// write the unit to the buffer as a STAP-A packet, otherwise flush
// and send as single NAL.
if (buffered_size + 3 + size <= s->max_payload_size &&
!(s->flags & FF_RTP_FLAG_H264_MODE0)) {
if (buffered_size == 0)
*s->buf_ptr++ = 24;
AV_WB16(s->buf_ptr, size);
s->buf_ptr += 2;
memcpy(s->buf_ptr, buf, size);
s->buf_ptr += size;
s->buffered_nals++;
} else {
flush_buffered(s1, 0);
ff_rtp_send_data(s1, buf, size, last);
}
} else {
uint8_t type = buf[0] & 0x1F;
uint8_t nri = buf[0] & 0x60;
flush_buffered(s1, 0);
if (s->flags & FF_RTP_FLAG_H264_MODE0) {
av_log(s1, AV_LOG_ERROR,
"NAL size %d > %d, try -slice-max-size %d\n", size,
s->max_payload_size, s->max_payload_size);
return;
}
av_log(s1, AV_LOG_DEBUG, "NAL size %d > %d\n", size, s->max_payload_size);
s->buf[0] = 28; /* FU Indicator; Type = 28 ---> FU-A */
s->buf[0] |= nri;
s->buf[1] = type;
s->buf[1] |= 1 << 7;
buf += 1;
size -= 1;
while (size + 2 > s->max_payload_size) {
memcpy(&s->buf[2], buf, s->max_payload_size - 2);
ff_rtp_send_data(s1, s->buf, s->max_payload_size, 0);
buf += s->max_payload_size - 2;
size -= s->max_payload_size - 2;
s->buf[1] &= ~(1 << 7);
}
s->buf[1] |= 1 << 6;
memcpy(&s->buf[2], buf, size);
ff_rtp_send_data(s1, s->buf, size + 2, last);
}
}
| true | FFmpeg | c82bf15dca00f67a701d126e47ea9075fc9459cb | static void nal_send(AVFormatContext *s1, const uint8_t *buf, int size, int last)
{
RTPMuxContext *s = s1->priv_data;
av_log(s1, AV_LOG_DEBUG, "Sending NAL %x of len %d M=%d\n", buf[0] & 0x1F, size, last);
if (size <= s->max_payload_size) {
int buffered_size = s->buf_ptr - s->buf;
if (buffered_size + 2 + size > s->max_payload_size) {
flush_buffered(s1, 0);
buffered_size = 0;
}
if (buffered_size + 3 + size <= s->max_payload_size &&
!(s->flags & FF_RTP_FLAG_H264_MODE0)) {
if (buffered_size == 0)
*s->buf_ptr++ = 24;
AV_WB16(s->buf_ptr, size);
s->buf_ptr += 2;
memcpy(s->buf_ptr, buf, size);
s->buf_ptr += size;
s->buffered_nals++;
} else {
flush_buffered(s1, 0);
ff_rtp_send_data(s1, buf, size, last);
}
} else {
uint8_t type = buf[0] & 0x1F;
uint8_t nri = buf[0] & 0x60;
flush_buffered(s1, 0);
if (s->flags & FF_RTP_FLAG_H264_MODE0) {
av_log(s1, AV_LOG_ERROR,
"NAL size %d > %d, try -slice-max-size %d\n", size,
s->max_payload_size, s->max_payload_size);
return;
}
av_log(s1, AV_LOG_DEBUG, "NAL size %d > %d\n", size, s->max_payload_size);
s->buf[0] = 28;
s->buf[0] |= nri;
s->buf[1] = type;
s->buf[1] |= 1 << 7;
buf += 1;
size -= 1;
while (size + 2 > s->max_payload_size) {
memcpy(&s->buf[2], buf, s->max_payload_size - 2);
ff_rtp_send_data(s1, s->buf, s->max_payload_size, 0);
buf += s->max_payload_size - 2;
size -= s->max_payload_size - 2;
s->buf[1] &= ~(1 << 7);
}
s->buf[1] |= 1 << 6;
memcpy(&s->buf[2], buf, size);
ff_rtp_send_data(s1, s->buf, size + 2, last);
}
}
| {
"code": [
" RTPMuxContext *s = s1->priv_data;",
"static void nal_send(AVFormatContext *s1, const uint8_t *buf, int size, int last)",
" RTPMuxContext *s = s1->priv_data;",
" av_log(s1, AV_LOG_DEBUG, \"Sending NAL %x of len %d M=%d\\n\", buf[0] & 0x1F, size, last);",
" if (size <= s->max_payload_size) {",
" int buffered_size = s->buf_ptr - s->buf;",
" if (buffered_size + 2 + size > s->max_payload_size) {",
" flush_buffered(s1, 0);",
" buffered_size = 0;",
" if (buffered_size + 3 + size <= s->max_payload_size &&",
" !(s->flags & FF_RTP_FLAG_H264_MODE0)) {",
" if (buffered_size == 0)",
" *s->buf_ptr++ = 24;",
" AV_WB16(s->buf_ptr, size);",
" s->buf_ptr += 2;",
" memcpy(s->buf_ptr, buf, size);",
" s->buf_ptr += size;",
" s->buffered_nals++;",
" } else {",
" flush_buffered(s1, 0);",
" ff_rtp_send_data(s1, buf, size, last);",
" } else {",
" uint8_t type = buf[0] & 0x1F;",
" uint8_t nri = buf[0] & 0x60;",
" flush_buffered(s1, 0);",
" if (s->flags & FF_RTP_FLAG_H264_MODE0) {",
" av_log(s1, AV_LOG_ERROR,",
" \"NAL size %d > %d, try -slice-max-size %d\\n\", size,",
" s->max_payload_size, s->max_payload_size);",
" av_log(s1, AV_LOG_DEBUG, \"NAL size %d > %d\\n\", size, s->max_payload_size);",
" s->buf[0] |= nri;",
" s->buf[1] = type;",
" s->buf[1] |= 1 << 7;",
" buf += 1;",
" size -= 1;",
" while (size + 2 > s->max_payload_size) {",
" memcpy(&s->buf[2], buf, s->max_payload_size - 2);",
" ff_rtp_send_data(s1, s->buf, s->max_payload_size, 0);",
" buf += s->max_payload_size - 2;",
" size -= s->max_payload_size - 2;",
" s->buf[1] &= ~(1 << 7);",
" s->buf[1] |= 1 << 6;",
" memcpy(&s->buf[2], buf, size);",
" ff_rtp_send_data(s1, s->buf, size + 2, last);",
" RTPMuxContext *s = s1->priv_data;",
" } else {",
" RTPMuxContext *s = s1->priv_data;",
" buffered_size = 0;",
" } else {",
" } else {",
" } else {"
],
"line_no": [
5,
1,
5,
9,
11,
13,
17,
19,
21,
33,
35,
37,
39,
41,
43,
45,
47,
49,
51,
19,
55,
59,
61,
63,
67,
69,
71,
73,
75,
81,
85,
87,
89,
91,
93,
95,
97,
99,
101,
103,
105,
109,
111,
113,
5,
51,
5,
21,
51,
59,
51
]
} | static void FUNC_0(AVFormatContext *VAR_0, const uint8_t *VAR_1, int VAR_2, int VAR_3)
{
RTPMuxContext *s = VAR_0->priv_data;
av_log(VAR_0, AV_LOG_DEBUG, "Sending NAL %x of len %d M=%d\n", VAR_1[0] & 0x1F, VAR_2, VAR_3);
if (VAR_2 <= s->max_payload_size) {
int VAR_4 = s->buf_ptr - s->VAR_1;
if (VAR_4 + 2 + VAR_2 > s->max_payload_size) {
flush_buffered(VAR_0, 0);
VAR_4 = 0;
}
if (VAR_4 + 3 + VAR_2 <= s->max_payload_size &&
!(s->flags & FF_RTP_FLAG_H264_MODE0)) {
if (VAR_4 == 0)
*s->buf_ptr++ = 24;
AV_WB16(s->buf_ptr, VAR_2);
s->buf_ptr += 2;
memcpy(s->buf_ptr, VAR_1, VAR_2);
s->buf_ptr += VAR_2;
s->buffered_nals++;
} else {
flush_buffered(VAR_0, 0);
ff_rtp_send_data(VAR_0, VAR_1, VAR_2, VAR_3);
}
} else {
uint8_t type = VAR_1[0] & 0x1F;
uint8_t nri = VAR_1[0] & 0x60;
flush_buffered(VAR_0, 0);
if (s->flags & FF_RTP_FLAG_H264_MODE0) {
av_log(VAR_0, AV_LOG_ERROR,
"NAL VAR_2 %d > %d, try -slice-max-VAR_2 %d\n", VAR_2,
s->max_payload_size, s->max_payload_size);
return;
}
av_log(VAR_0, AV_LOG_DEBUG, "NAL VAR_2 %d > %d\n", VAR_2, s->max_payload_size);
s->VAR_1[0] = 28;
s->VAR_1[0] |= nri;
s->VAR_1[1] = type;
s->VAR_1[1] |= 1 << 7;
VAR_1 += 1;
VAR_2 -= 1;
while (VAR_2 + 2 > s->max_payload_size) {
memcpy(&s->VAR_1[2], VAR_1, s->max_payload_size - 2);
ff_rtp_send_data(VAR_0, s->VAR_1, s->max_payload_size, 0);
VAR_1 += s->max_payload_size - 2;
VAR_2 -= s->max_payload_size - 2;
s->VAR_1[1] &= ~(1 << 7);
}
s->VAR_1[1] |= 1 << 6;
memcpy(&s->VAR_1[2], VAR_1, VAR_2);
ff_rtp_send_data(VAR_0, s->VAR_1, VAR_2 + 2, VAR_3);
}
}
| [
"static void FUNC_0(AVFormatContext *VAR_0, const uint8_t *VAR_1, int VAR_2, int VAR_3)\n{",
"RTPMuxContext *s = VAR_0->priv_data;",
"av_log(VAR_0, AV_LOG_DEBUG, \"Sending NAL %x of len %d M=%d\\n\", VAR_1[0] & 0x1F, VAR_2, VAR_3);",
"if (VAR_2 <= s->max_payload_size) {",
"int VAR_4 = s->buf_ptr - s->VAR_1;",
"if (VAR_4 + 2 + VAR_2 > s->max_payload_size) {",
"flush_buffered(VAR_0, 0);",
"VAR_4 = 0;",
"}",
"if (VAR_4 + 3 + VAR_2 <= s->max_payload_size &&\n!(s->flags & FF_RTP_FLAG_H264_MODE0)) {",
"if (VAR_4 == 0)\n*s->buf_ptr++ = 24;",
"AV_WB16(s->buf_ptr, VAR_2);",
"s->buf_ptr += 2;",
"memcpy(s->buf_ptr, VAR_1, VAR_2);",
"s->buf_ptr += VAR_2;",
"s->buffered_nals++;",
"} else {",
"flush_buffered(VAR_0, 0);",
"ff_rtp_send_data(VAR_0, VAR_1, VAR_2, VAR_3);",
"}",
"} else {",
"uint8_t type = VAR_1[0] & 0x1F;",
"uint8_t nri = VAR_1[0] & 0x60;",
"flush_buffered(VAR_0, 0);",
"if (s->flags & FF_RTP_FLAG_H264_MODE0) {",
"av_log(VAR_0, AV_LOG_ERROR,\n\"NAL VAR_2 %d > %d, try -slice-max-VAR_2 %d\\n\", VAR_2,\ns->max_payload_size, s->max_payload_size);",
"return;",
"}",
"av_log(VAR_0, AV_LOG_DEBUG, \"NAL VAR_2 %d > %d\\n\", VAR_2, s->max_payload_size);",
"s->VAR_1[0] = 28;",
"s->VAR_1[0] |= nri;",
"s->VAR_1[1] = type;",
"s->VAR_1[1] |= 1 << 7;",
"VAR_1 += 1;",
"VAR_2 -= 1;",
"while (VAR_2 + 2 > s->max_payload_size) {",
"memcpy(&s->VAR_1[2], VAR_1, s->max_payload_size - 2);",
"ff_rtp_send_data(VAR_0, s->VAR_1, s->max_payload_size, 0);",
"VAR_1 += s->max_payload_size - 2;",
"VAR_2 -= s->max_payload_size - 2;",
"s->VAR_1[1] &= ~(1 << 7);",
"}",
"s->VAR_1[1] |= 1 << 6;",
"memcpy(&s->VAR_1[2], VAR_1, VAR_2);",
"ff_rtp_send_data(VAR_0, s->VAR_1, VAR_2 + 2, VAR_3);",
"}",
"}"
] | [
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0,
1,
0,
0,
1,
1,
1,
1,
1,
0,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
33,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71,
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
]
] |
23,971 | static av_always_inline int vmnc_get_pixel(const uint8_t *buf, int bpp, int be)
{
switch (bpp * 2 + be) {
case 2:
case 3:
return *buf;
case 4:
return AV_RL16(buf);
case 5:
return AV_RB16(buf);
case 8:
return AV_RL32(buf);
case 9:
return AV_RB32(buf);
default:
return 0;
}
}
| true | FFmpeg | 61cd19b8bc32185c8caf64d89d1b0909877a0707 | static av_always_inline int vmnc_get_pixel(const uint8_t *buf, int bpp, int be)
{
switch (bpp * 2 + be) {
case 2:
case 3:
return *buf;
case 4:
return AV_RL16(buf);
case 5:
return AV_RB16(buf);
case 8:
return AV_RL32(buf);
case 9:
return AV_RB32(buf);
default:
return 0;
}
}
| {
"code": [
"static av_always_inline int vmnc_get_pixel(const uint8_t *buf, int bpp, int be)",
" return *buf;",
" return AV_RL16(buf);",
" return AV_RB16(buf);",
" return AV_RL32(buf);",
" return AV_RB32(buf);",
" default:",
" return 0;"
],
"line_no": [
1,
11,
15,
19,
23,
27,
29,
31
]
} | static av_always_inline int FUNC_0(const uint8_t *buf, int bpp, int be)
{
switch (bpp * 2 + be) {
case 2:
case 3:
return *buf;
case 4:
return AV_RL16(buf);
case 5:
return AV_RB16(buf);
case 8:
return AV_RL32(buf);
case 9:
return AV_RB32(buf);
default:
return 0;
}
}
| [
"static av_always_inline int FUNC_0(const uint8_t *buf, int bpp, int be)\n{",
"switch (bpp * 2 + be) {",
"case 2:\ncase 3:\nreturn *buf;",
"case 4:\nreturn AV_RL16(buf);",
"case 5:\nreturn AV_RB16(buf);",
"case 8:\nreturn AV_RL32(buf);",
"case 9:\nreturn AV_RB32(buf);",
"default:\nreturn 0;",
"}",
"}"
] | [
1,
0,
1,
1,
1,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9,
11
],
[
13,
15
],
[
17,
19
],
[
21,
23
],
[
25,
27
],
[
29,
31
],
[
33
],
[
35
]
] |
23,972 | static void test_wait_event_notifier(void)
{
EventNotifierTestData data = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
g_assert(aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 1);
event_notifier_set(&data.e);
g_assert(aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0);
g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL);
g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
event_notifier_cleanup(&data.e);
}
| true | qemu | 164a101f28a53cd3db60ed874e7c3630e7988ed8 | static void test_wait_event_notifier(void)
{
EventNotifierTestData data = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
g_assert(aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 1);
event_notifier_set(&data.e);
g_assert(aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0);
g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL);
g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
event_notifier_cleanup(&data.e);
}
| {
"code": [
" g_assert(aio_poll(ctx, false));",
" g_assert(aio_poll(ctx, false));",
" g_assert(aio_poll(ctx, false));",
" g_assert(aio_poll(ctx, false));"
],
"line_no": [
11,
11,
11,
11
]
} | static void FUNC_0(void)
{
EventNotifierTestData data = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
g_assert(aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 1);
event_notifier_set(&data.e);
g_assert(aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0);
g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL);
g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1);
event_notifier_cleanup(&data.e);
}
| [
"static void FUNC_0(void)\n{",
"EventNotifierTestData data = { .n = 0, .active = 1 };",
"event_notifier_init(&data.e, false);",
"aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);",
"g_assert(aio_poll(ctx, false));",
"g_assert_cmpint(data.n, ==, 0);",
"g_assert_cmpint(data.active, ==, 1);",
"event_notifier_set(&data.e);",
"g_assert(aio_poll(ctx, false));",
"g_assert_cmpint(data.n, ==, 1);",
"g_assert_cmpint(data.active, ==, 0);",
"g_assert(!aio_poll(ctx, false));",
"g_assert_cmpint(data.n, ==, 1);",
"g_assert_cmpint(data.active, ==, 0);",
"aio_set_event_notifier(ctx, &data.e, NULL, NULL);",
"g_assert(!aio_poll(ctx, false));",
"g_assert_cmpint(data.n, ==, 1);",
"event_notifier_cleanup(&data.e);",
"}"
] | [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
]
] |
23,973 | target_ulong helper_rdhwr_synci_step(CPUMIPSState *env)
{
check_hwrena(env, 1);
return env->SYNCI_Step;
}
| true | qemu | d96391c1ffeb30a0afa695c86579517c69d9a889 | target_ulong helper_rdhwr_synci_step(CPUMIPSState *env)
{
check_hwrena(env, 1);
return env->SYNCI_Step;
}
| {
"code": [
" check_hwrena(env, 1);"
],
"line_no": [
5
]
} | target_ulong FUNC_0(CPUMIPSState *env)
{
check_hwrena(env, 1);
return env->SYNCI_Step;
}
| [
"target_ulong FUNC_0(CPUMIPSState *env)\n{",
"check_hwrena(env, 1);",
"return env->SYNCI_Step;",
"}"
] | [
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
23,974 | static int get_moov_size(AVFormatContext *s)
{
int ret;
AVIOContext *moov_buf;
MOVMuxContext *mov = s->priv_data;
if ((ret = ffio_open_null_buf(&moov_buf)) < 0)
return ret;
mov_write_moov_tag(moov_buf, mov, s);
return ffio_close_null_buf(moov_buf);
}
| true | FFmpeg | da048c6d24729d3bab6ccb0ac340ea129e3e88d5 | static int get_moov_size(AVFormatContext *s)
{
int ret;
AVIOContext *moov_buf;
MOVMuxContext *mov = s->priv_data;
if ((ret = ffio_open_null_buf(&moov_buf)) < 0)
return ret;
mov_write_moov_tag(moov_buf, mov, s);
return ffio_close_null_buf(moov_buf);
}
| {
"code": [
" mov_write_moov_tag(moov_buf, mov, s);"
],
"line_no": [
17
]
} | static int FUNC_0(AVFormatContext *VAR_0)
{
int VAR_1;
AVIOContext *moov_buf;
MOVMuxContext *mov = VAR_0->priv_data;
if ((VAR_1 = ffio_open_null_buf(&moov_buf)) < 0)
return VAR_1;
mov_write_moov_tag(moov_buf, mov, VAR_0);
return ffio_close_null_buf(moov_buf);
}
| [
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"int VAR_1;",
"AVIOContext *moov_buf;",
"MOVMuxContext *mov = VAR_0->priv_data;",
"if ((VAR_1 = ffio_open_null_buf(&moov_buf)) < 0)\nreturn VAR_1;",
"mov_write_moov_tag(moov_buf, mov, VAR_0);",
"return ffio_close_null_buf(moov_buf);",
"}"
] | [
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13,
15
],
[
17
],
[
19
],
[
21
]
] |
23,975 | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
{
MpegEncContext *s = &v->s;
uint8_t *srcY;
int dxy, mx, my, src_x, src_y;
int off;
int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
int v_edge_pos = s->v_edge_pos >> v->field_mode;
uint8_t (*luty)[256];
int use_ic;
if ((!v->field_mode ||
(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
!v->s.last_picture.f.data[0])
return;
mx = s->mv[dir][n][0];
my = s->mv[dir][n][1];
if (!dir) {
if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
srcY = s->current_picture.f.data[0];
luty = v->curr_luty;
use_ic = v->curr_use_ic;
} else {
srcY = s->last_picture.f.data[0];
luty = v->last_luty;
use_ic = v->last_use_ic;
}
} else {
srcY = s->next_picture.f.data[0];
luty = v->next_luty;
use_ic = v->next_use_ic;
}
if (!srcY) {
av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
return;
}
if (v->field_mode) {
if (v->cur_field_type != v->ref_field_type[dir])
my = my - 2 + 4 * v->cur_field_type;
}
if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
int same_count = 0, opp_count = 0, k;
int chosen_mv[2][4][2], f;
int tx, ty;
for (k = 0; k < 4; k++) {
f = v->mv_f[0][s->block_index[k] + v->blocks_off];
chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
opp_count += f;
same_count += 1 - f;
}
f = opp_count > same_count;
switch (f ? opp_count : same_count) {
case 4:
tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
chosen_mv[f][2][0], chosen_mv[f][3][0]);
ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
chosen_mv[f][2][1], chosen_mv[f][3][1]);
break;
case 3:
tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
break;
case 2:
tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
break;
}
s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
for (k = 0; k < 4; k++)
v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
}
if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
int qx, qy;
int width = s->avctx->coded_width;
int height = s->avctx->coded_height >> 1;
if (s->pict_type == AV_PICTURE_TYPE_P) {
s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
}
qx = (s->mb_x * 16) + (mx >> 2);
qy = (s->mb_y * 8) + (my >> 3);
if (qx < -17)
mx -= 4 * (qx + 17);
else if (qx > width)
mx -= 4 * (qx - width);
if (qy < -18)
my -= 8 * (qy + 18);
else if (qy > height + 1)
my -= 8 * (qy - height - 1);
}
if ((v->fcm == ILACE_FRAME) && fieldmv)
off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
else
off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
if (!fieldmv)
src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
else
src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
if (v->profile != PROFILE_ADVANCED) {
src_x = av_clip(src_x, -16, s->mb_width * 16);
src_y = av_clip(src_y, -16, s->mb_height * 16);
} else {
src_x = av_clip(src_x, -17, s->avctx->coded_width);
if (v->fcm == ILACE_FRAME) {
if (src_y & 1)
src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
else
src_y = av_clip(src_y, -18, s->avctx->coded_height);
} else {
src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
}
}
srcY += src_y * s->linesize + src_x;
if (v->field_mode && v->ref_field_type[dir])
srcY += s->current_picture_ptr->f.linesize[0];
if (fieldmv && !(src_y & 1))
v_edge_pos--;
if (fieldmv && (src_y & 1) && src_y < 4)
src_y--;
if (v->rangeredfrm || use_ic
|| s->h_edge_pos < 13 || v_edge_pos < 23
|| (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
|| (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
srcY -= s->mspel * (1 + (s->linesize << fieldmv));
/* check emulate edge stride and offset */
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
s->linesize, s->linesize,
9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
src_x - s->mspel, src_y - (s->mspel << fieldmv),
s->h_edge_pos, v_edge_pos);
srcY = s->edge_emu_buffer;
/* if we deal with range reduction we need to scale source blocks */
if (v->rangeredfrm) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = ((src[i] - 128) >> 1) + 128;
src += s->linesize << fieldmv;
}
}
/* if we deal with intensity compensation we need to scale source blocks */
if (use_ic) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = luty[f][src[i]];
src += s->linesize << fieldmv;
}
}
srcY += s->mspel * (1 + (s->linesize << fieldmv));
}
if (s->mspel) {
dxy = ((my & 3) << 2) | (mx & 3);
if (avg)
v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
else
v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
} else { // hpel mc - always used for luma
dxy = (my & 2) | ((mx & 2) >> 1);
if (!v->rnd)
s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
else
s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
}
}
| true | FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
{
MpegEncContext *s = &v->s;
uint8_t *srcY;
int dxy, mx, my, src_x, src_y;
int off;
int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
int v_edge_pos = s->v_edge_pos >> v->field_mode;
uint8_t (*luty)[256];
int use_ic;
if ((!v->field_mode ||
(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
!v->s.last_picture.f.data[0])
return;
mx = s->mv[dir][n][0];
my = s->mv[dir][n][1];
if (!dir) {
if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
srcY = s->current_picture.f.data[0];
luty = v->curr_luty;
use_ic = v->curr_use_ic;
} else {
srcY = s->last_picture.f.data[0];
luty = v->last_luty;
use_ic = v->last_use_ic;
}
} else {
srcY = s->next_picture.f.data[0];
luty = v->next_luty;
use_ic = v->next_use_ic;
}
if (!srcY) {
av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
return;
}
if (v->field_mode) {
if (v->cur_field_type != v->ref_field_type[dir])
my = my - 2 + 4 * v->cur_field_type;
}
if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
int same_count = 0, opp_count = 0, k;
int chosen_mv[2][4][2], f;
int tx, ty;
for (k = 0; k < 4; k++) {
f = v->mv_f[0][s->block_index[k] + v->blocks_off];
chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
opp_count += f;
same_count += 1 - f;
}
f = opp_count > same_count;
switch (f ? opp_count : same_count) {
case 4:
tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
chosen_mv[f][2][0], chosen_mv[f][3][0]);
ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
chosen_mv[f][2][1], chosen_mv[f][3][1]);
break;
case 3:
tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
break;
case 2:
tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
break;
}
s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
for (k = 0; k < 4; k++)
v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
}
if (v->fcm == ILACE_FRAME) {
int qx, qy;
int width = s->avctx->coded_width;
int height = s->avctx->coded_height >> 1;
if (s->pict_type == AV_PICTURE_TYPE_P) {
s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
}
qx = (s->mb_x * 16) + (mx >> 2);
qy = (s->mb_y * 8) + (my >> 3);
if (qx < -17)
mx -= 4 * (qx + 17);
else if (qx > width)
mx -= 4 * (qx - width);
if (qy < -18)
my -= 8 * (qy + 18);
else if (qy > height + 1)
my -= 8 * (qy - height - 1);
}
if ((v->fcm == ILACE_FRAME) && fieldmv)
off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
else
off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
if (!fieldmv)
src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
else
src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
if (v->profile != PROFILE_ADVANCED) {
src_x = av_clip(src_x, -16, s->mb_width * 16);
src_y = av_clip(src_y, -16, s->mb_height * 16);
} else {
src_x = av_clip(src_x, -17, s->avctx->coded_width);
if (v->fcm == ILACE_FRAME) {
if (src_y & 1)
src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
else
src_y = av_clip(src_y, -18, s->avctx->coded_height);
} else {
src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
}
}
srcY += src_y * s->linesize + src_x;
if (v->field_mode && v->ref_field_type[dir])
srcY += s->current_picture_ptr->f.linesize[0];
if (fieldmv && !(src_y & 1))
v_edge_pos--;
if (fieldmv && (src_y & 1) && src_y < 4)
src_y--;
if (v->rangeredfrm || use_ic
|| s->h_edge_pos < 13 || v_edge_pos < 23
|| (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
|| (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
srcY -= s->mspel * (1 + (s->linesize << fieldmv));
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
s->linesize, s->linesize,
9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
src_x - s->mspel, src_y - (s->mspel << fieldmv),
s->h_edge_pos, v_edge_pos);
srcY = s->edge_emu_buffer;
if (v->rangeredfrm) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = ((src[i] - 128) >> 1) + 128;
src += s->linesize << fieldmv;
}
}
if (use_ic) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = luty[f][src[i]];
src += s->linesize << fieldmv;
}
}
srcY += s->mspel * (1 + (s->linesize << fieldmv));
}
if (s->mspel) {
dxy = ((my & 3) << 2) | (mx & 3);
if (avg)
v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
else
v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
} else {
dxy = (my & 2) | ((mx & 2) >> 1);
if (!v->rnd)
s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
else
s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
}
}
| {
"code": [
" !v->s.last_picture.f.data[0])",
" srcY = s->current_picture.f.data[0];",
" srcY = s->last_picture.f.data[0];",
" srcY = s->next_picture.f.data[0];",
" srcY += s->current_picture_ptr->f.linesize[0];",
" !v->s.last_picture.f.data[0])",
" srcY = s->current_picture.f.data[0];",
" srcY = s->last_picture.f.data[0];",
" srcY = s->next_picture.f.data[0];",
" srcY += s->current_picture_ptr->f.linesize[0];",
" srcY += s->current_picture_ptr->f.linesize[0];"
],
"line_no": [
27,
43,
51,
61,
257,
27,
43,
51,
61,
257,
257
]
} | static void FUNC_0(VC1Context *VAR_0, int VAR_1, int VAR_2, int VAR_3)
{
MpegEncContext *s = &VAR_0->s;
uint8_t *srcY;
int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;
int VAR_9;
int VAR_10 = (VAR_0->fcm == ILACE_FRAME) ? VAR_0->blk_mv_type[s->block_index[VAR_1]] : 0;
int VAR_11 = s->VAR_11 >> VAR_0->field_mode;
uint8_t (*luty)[256];
int VAR_12;
if ((!VAR_0->field_mode ||
(VAR_0->ref_field_type[VAR_2] == 1 && VAR_0->cur_field_type == 1)) &&
!VAR_0->s.last_picture.VAR_17.data[0])
return;
VAR_5 = s->mv[VAR_2][VAR_1][0];
VAR_6 = s->mv[VAR_2][VAR_1][1];
if (!VAR_2) {
if (VAR_0->field_mode && (VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2]) && VAR_0->second_field) {
srcY = s->current_picture.VAR_17.data[0];
luty = VAR_0->curr_luty;
VAR_12 = VAR_0->curr_use_ic;
} else {
srcY = s->last_picture.VAR_17.data[0];
luty = VAR_0->last_luty;
VAR_12 = VAR_0->last_use_ic;
}
} else {
srcY = s->next_picture.VAR_17.data[0];
luty = VAR_0->next_luty;
VAR_12 = VAR_0->next_use_ic;
}
if (!srcY) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\VAR_1");
return;
}
if (VAR_0->field_mode) {
if (VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2])
VAR_6 = VAR_6 - 2 + 4 * VAR_0->cur_field_type;
}
if (s->pict_type == AV_PICTURE_TYPE_P && VAR_1 == 3 && VAR_0->field_mode) {
int VAR_13 = 0, VAR_14 = 0, VAR_15;
int VAR_16[2][4][2], VAR_17;
int VAR_18, VAR_19;
for (VAR_15 = 0; VAR_15 < 4; VAR_15++) {
VAR_17 = VAR_0->mv_f[0][s->block_index[VAR_15] + VAR_0->blocks_off];
VAR_16[VAR_17][VAR_17 ? VAR_14 : VAR_13][0] = s->mv[0][VAR_15][0];
VAR_16[VAR_17][VAR_17 ? VAR_14 : VAR_13][1] = s->mv[0][VAR_15][1];
VAR_14 += VAR_17;
VAR_13 += 1 - VAR_17;
}
VAR_17 = VAR_14 > VAR_13;
switch (VAR_17 ? VAR_14 : VAR_13) {
case 4:
VAR_18 = median4(VAR_16[VAR_17][0][0], VAR_16[VAR_17][1][0],
VAR_16[VAR_17][2][0], VAR_16[VAR_17][3][0]);
VAR_19 = median4(VAR_16[VAR_17][0][1], VAR_16[VAR_17][1][1],
VAR_16[VAR_17][2][1], VAR_16[VAR_17][3][1]);
break;
case 3:
VAR_18 = mid_pred(VAR_16[VAR_17][0][0], VAR_16[VAR_17][1][0], VAR_16[VAR_17][2][0]);
VAR_19 = mid_pred(VAR_16[VAR_17][0][1], VAR_16[VAR_17][1][1], VAR_16[VAR_17][2][1]);
break;
case 2:
VAR_18 = (VAR_16[VAR_17][0][0] + VAR_16[VAR_17][1][0]) / 2;
VAR_19 = (VAR_16[VAR_17][0][1] + VAR_16[VAR_17][1][1]) / 2;
break;
}
s->current_picture.motion_val[1][s->block_index[0] + VAR_0->blocks_off][0] = VAR_18;
s->current_picture.motion_val[1][s->block_index[0] + VAR_0->blocks_off][1] = VAR_19;
for (VAR_15 = 0; VAR_15 < 4; VAR_15++)
VAR_0->mv_f[1][s->block_index[VAR_15] + VAR_0->blocks_off] = VAR_17;
}
if (VAR_0->fcm == ILACE_FRAME) {
int VAR_20, VAR_21;
int VAR_22 = s->avctx->coded_width;
int VAR_23 = s->avctx->coded_height >> 1;
if (s->pict_type == AV_PICTURE_TYPE_P) {
s->current_picture.motion_val[1][s->block_index[VAR_1] + VAR_0->blocks_off][0] = VAR_5;
s->current_picture.motion_val[1][s->block_index[VAR_1] + VAR_0->blocks_off][1] = VAR_6;
}
VAR_20 = (s->mb_x * 16) + (VAR_5 >> 2);
VAR_21 = (s->mb_y * 8) + (VAR_6 >> 3);
if (VAR_20 < -17)
VAR_5 -= 4 * (VAR_20 + 17);
else if (VAR_20 > VAR_22)
VAR_5 -= 4 * (VAR_20 - VAR_22);
if (VAR_21 < -18)
VAR_6 -= 8 * (VAR_21 + 18);
else if (VAR_21 > VAR_23 + 1)
VAR_6 -= 8 * (VAR_21 - VAR_23 - 1);
}
if ((VAR_0->fcm == ILACE_FRAME) && VAR_10)
VAR_9 = ((VAR_1 > 1) ? s->linesize : 0) + (VAR_1 & 1) * 8;
else
VAR_9 = s->linesize * 4 * (VAR_1 & 2) + (VAR_1 & 1) * 8;
VAR_7 = s->mb_x * 16 + (VAR_1 & 1) * 8 + (VAR_5 >> 2);
if (!VAR_10)
VAR_8 = s->mb_y * 16 + (VAR_1 & 2) * 4 + (VAR_6 >> 2);
else
VAR_8 = s->mb_y * 16 + ((VAR_1 > 1) ? 1 : 0) + (VAR_6 >> 2);
if (VAR_0->profile != PROFILE_ADVANCED) {
VAR_7 = av_clip(VAR_7, -16, s->mb_width * 16);
VAR_8 = av_clip(VAR_8, -16, s->mb_height * 16);
} else {
VAR_7 = av_clip(VAR_7, -17, s->avctx->coded_width);
if (VAR_0->fcm == ILACE_FRAME) {
if (VAR_8 & 1)
VAR_8 = av_clip(VAR_8, -17, s->avctx->coded_height + 1);
else
VAR_8 = av_clip(VAR_8, -18, s->avctx->coded_height);
} else {
VAR_8 = av_clip(VAR_8, -18, s->avctx->coded_height + 1);
}
}
srcY += VAR_8 * s->linesize + VAR_7;
if (VAR_0->field_mode && VAR_0->ref_field_type[VAR_2])
srcY += s->current_picture_ptr->VAR_17.linesize[0];
if (VAR_10 && !(VAR_8 & 1))
VAR_11--;
if (VAR_10 && (VAR_8 & 1) && VAR_8 < 4)
VAR_8--;
if (VAR_0->rangeredfrm || VAR_12
|| s->h_edge_pos < 13 || VAR_11 < 23
|| (unsigned)(VAR_7 - s->mspel) > s->h_edge_pos - (VAR_5 & 3) - 8 - s->mspel * 2
|| (unsigned)(VAR_8 - (s->mspel << VAR_10)) > VAR_11 - (VAR_6 & 3) - ((8 + s->mspel * 2) << VAR_10)) {
srcY -= s->mspel * (1 + (s->linesize << VAR_10));
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
s->linesize, s->linesize,
9 + s->mspel * 2, (9 + s->mspel * 2) << VAR_10,
VAR_7 - s->mspel, VAR_8 - (s->mspel << VAR_10),
s->h_edge_pos, VAR_11);
srcY = s->edge_emu_buffer;
if (VAR_0->rangeredfrm) {
int VAR_26, VAR_26;
uint8_t *src;
src = srcY;
for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++) {
for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++)
src[VAR_26] = ((src[VAR_26] - 128) >> 1) + 128;
src += s->linesize << VAR_10;
}
}
if (VAR_12) {
int VAR_26, VAR_26;
uint8_t *src;
src = srcY;
for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++) {
int VAR_17 = VAR_0->field_mode ? VAR_0->ref_field_type[VAR_2] : (((VAR_26<<VAR_10)+VAR_8 - (s->mspel << VAR_10)) & 1);
for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++)
src[VAR_26] = luty[VAR_17][src[VAR_26]];
src += s->linesize << VAR_10;
}
}
srcY += s->mspel * (1 + (s->linesize << VAR_10));
}
if (s->mspel) {
VAR_4 = ((VAR_6 & 3) << 2) | (VAR_5 & 3);
if (VAR_3)
VAR_0->vc1dsp.avg_vc1_mspel_pixels_tab[VAR_4](s->dest[0] + VAR_9, srcY, s->linesize << VAR_10, VAR_0->rnd);
else
VAR_0->vc1dsp.put_vc1_mspel_pixels_tab[VAR_4](s->dest[0] + VAR_9, srcY, s->linesize << VAR_10, VAR_0->rnd);
} else {
VAR_4 = (VAR_6 & 2) | ((VAR_5 & 2) >> 1);
if (!VAR_0->rnd)
s->hdsp.put_pixels_tab[1][VAR_4](s->dest[0] + VAR_9, srcY, s->linesize, 8);
else
s->hdsp.put_no_rnd_pixels_tab[1][VAR_4](s->dest[0] + VAR_9, srcY, s->linesize, 8);
}
}
| [
"static void FUNC_0(VC1Context *VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{",
"MpegEncContext *s = &VAR_0->s;",
"uint8_t *srcY;",
"int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;",
"int VAR_9;",
"int VAR_10 = (VAR_0->fcm == ILACE_FRAME) ? VAR_0->blk_mv_type[s->block_index[VAR_1]] : 0;",
"int VAR_11 = s->VAR_11 >> VAR_0->field_mode;",
"uint8_t (*luty)[256];",
"int VAR_12;",
"if ((!VAR_0->field_mode ||\n(VAR_0->ref_field_type[VAR_2] == 1 && VAR_0->cur_field_type == 1)) &&\n!VAR_0->s.last_picture.VAR_17.data[0])\nreturn;",
"VAR_5 = s->mv[VAR_2][VAR_1][0];",
"VAR_6 = s->mv[VAR_2][VAR_1][1];",
"if (!VAR_2) {",
"if (VAR_0->field_mode && (VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2]) && VAR_0->second_field) {",
"srcY = s->current_picture.VAR_17.data[0];",
"luty = VAR_0->curr_luty;",
"VAR_12 = VAR_0->curr_use_ic;",
"} else {",
"srcY = s->last_picture.VAR_17.data[0];",
"luty = VAR_0->last_luty;",
"VAR_12 = VAR_0->last_use_ic;",
"}",
"} else {",
"srcY = s->next_picture.VAR_17.data[0];",
"luty = VAR_0->next_luty;",
"VAR_12 = VAR_0->next_use_ic;",
"}",
"if (!srcY) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"Referenced frame missing.\\VAR_1\");",
"return;",
"}",
"if (VAR_0->field_mode) {",
"if (VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2])\nVAR_6 = VAR_6 - 2 + 4 * VAR_0->cur_field_type;",
"}",
"if (s->pict_type == AV_PICTURE_TYPE_P && VAR_1 == 3 && VAR_0->field_mode) {",
"int VAR_13 = 0, VAR_14 = 0, VAR_15;",
"int VAR_16[2][4][2], VAR_17;",
"int VAR_18, VAR_19;",
"for (VAR_15 = 0; VAR_15 < 4; VAR_15++) {",
"VAR_17 = VAR_0->mv_f[0][s->block_index[VAR_15] + VAR_0->blocks_off];",
"VAR_16[VAR_17][VAR_17 ? VAR_14 : VAR_13][0] = s->mv[0][VAR_15][0];",
"VAR_16[VAR_17][VAR_17 ? VAR_14 : VAR_13][1] = s->mv[0][VAR_15][1];",
"VAR_14 += VAR_17;",
"VAR_13 += 1 - VAR_17;",
"}",
"VAR_17 = VAR_14 > VAR_13;",
"switch (VAR_17 ? VAR_14 : VAR_13) {",
"case 4:\nVAR_18 = median4(VAR_16[VAR_17][0][0], VAR_16[VAR_17][1][0],\nVAR_16[VAR_17][2][0], VAR_16[VAR_17][3][0]);",
"VAR_19 = median4(VAR_16[VAR_17][0][1], VAR_16[VAR_17][1][1],\nVAR_16[VAR_17][2][1], VAR_16[VAR_17][3][1]);",
"break;",
"case 3:\nVAR_18 = mid_pred(VAR_16[VAR_17][0][0], VAR_16[VAR_17][1][0], VAR_16[VAR_17][2][0]);",
"VAR_19 = mid_pred(VAR_16[VAR_17][0][1], VAR_16[VAR_17][1][1], VAR_16[VAR_17][2][1]);",
"break;",
"case 2:\nVAR_18 = (VAR_16[VAR_17][0][0] + VAR_16[VAR_17][1][0]) / 2;",
"VAR_19 = (VAR_16[VAR_17][0][1] + VAR_16[VAR_17][1][1]) / 2;",
"break;",
"}",
"s->current_picture.motion_val[1][s->block_index[0] + VAR_0->blocks_off][0] = VAR_18;",
"s->current_picture.motion_val[1][s->block_index[0] + VAR_0->blocks_off][1] = VAR_19;",
"for (VAR_15 = 0; VAR_15 < 4; VAR_15++)",
"VAR_0->mv_f[1][s->block_index[VAR_15] + VAR_0->blocks_off] = VAR_17;",
"}",
"if (VAR_0->fcm == ILACE_FRAME) {",
"int VAR_20, VAR_21;",
"int VAR_22 = s->avctx->coded_width;",
"int VAR_23 = s->avctx->coded_height >> 1;",
"if (s->pict_type == AV_PICTURE_TYPE_P) {",
"s->current_picture.motion_val[1][s->block_index[VAR_1] + VAR_0->blocks_off][0] = VAR_5;",
"s->current_picture.motion_val[1][s->block_index[VAR_1] + VAR_0->blocks_off][1] = VAR_6;",
"}",
"VAR_20 = (s->mb_x * 16) + (VAR_5 >> 2);",
"VAR_21 = (s->mb_y * 8) + (VAR_6 >> 3);",
"if (VAR_20 < -17)\nVAR_5 -= 4 * (VAR_20 + 17);",
"else if (VAR_20 > VAR_22)\nVAR_5 -= 4 * (VAR_20 - VAR_22);",
"if (VAR_21 < -18)\nVAR_6 -= 8 * (VAR_21 + 18);",
"else if (VAR_21 > VAR_23 + 1)\nVAR_6 -= 8 * (VAR_21 - VAR_23 - 1);",
"}",
"if ((VAR_0->fcm == ILACE_FRAME) && VAR_10)\nVAR_9 = ((VAR_1 > 1) ? s->linesize : 0) + (VAR_1 & 1) * 8;",
"else\nVAR_9 = s->linesize * 4 * (VAR_1 & 2) + (VAR_1 & 1) * 8;",
"VAR_7 = s->mb_x * 16 + (VAR_1 & 1) * 8 + (VAR_5 >> 2);",
"if (!VAR_10)\nVAR_8 = s->mb_y * 16 + (VAR_1 & 2) * 4 + (VAR_6 >> 2);",
"else\nVAR_8 = s->mb_y * 16 + ((VAR_1 > 1) ? 1 : 0) + (VAR_6 >> 2);",
"if (VAR_0->profile != PROFILE_ADVANCED) {",
"VAR_7 = av_clip(VAR_7, -16, s->mb_width * 16);",
"VAR_8 = av_clip(VAR_8, -16, s->mb_height * 16);",
"} else {",
"VAR_7 = av_clip(VAR_7, -17, s->avctx->coded_width);",
"if (VAR_0->fcm == ILACE_FRAME) {",
"if (VAR_8 & 1)\nVAR_8 = av_clip(VAR_8, -17, s->avctx->coded_height + 1);",
"else\nVAR_8 = av_clip(VAR_8, -18, s->avctx->coded_height);",
"} else {",
"VAR_8 = av_clip(VAR_8, -18, s->avctx->coded_height + 1);",
"}",
"}",
"srcY += VAR_8 * s->linesize + VAR_7;",
"if (VAR_0->field_mode && VAR_0->ref_field_type[VAR_2])\nsrcY += s->current_picture_ptr->VAR_17.linesize[0];",
"if (VAR_10 && !(VAR_8 & 1))\nVAR_11--;",
"if (VAR_10 && (VAR_8 & 1) && VAR_8 < 4)\nVAR_8--;",
"if (VAR_0->rangeredfrm || VAR_12\n|| s->h_edge_pos < 13 || VAR_11 < 23\n|| (unsigned)(VAR_7 - s->mspel) > s->h_edge_pos - (VAR_5 & 3) - 8 - s->mspel * 2\n|| (unsigned)(VAR_8 - (s->mspel << VAR_10)) > VAR_11 - (VAR_6 & 3) - ((8 + s->mspel * 2) << VAR_10)) {",
"srcY -= s->mspel * (1 + (s->linesize << VAR_10));",
"s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,\ns->linesize, s->linesize,\n9 + s->mspel * 2, (9 + s->mspel * 2) << VAR_10,\nVAR_7 - s->mspel, VAR_8 - (s->mspel << VAR_10),\ns->h_edge_pos, VAR_11);",
"srcY = s->edge_emu_buffer;",
"if (VAR_0->rangeredfrm) {",
"int VAR_26, VAR_26;",
"uint8_t *src;",
"src = srcY;",
"for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++) {",
"for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++)",
"src[VAR_26] = ((src[VAR_26] - 128) >> 1) + 128;",
"src += s->linesize << VAR_10;",
"}",
"}",
"if (VAR_12) {",
"int VAR_26, VAR_26;",
"uint8_t *src;",
"src = srcY;",
"for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++) {",
"int VAR_17 = VAR_0->field_mode ? VAR_0->ref_field_type[VAR_2] : (((VAR_26<<VAR_10)+VAR_8 - (s->mspel << VAR_10)) & 1);",
"for (VAR_26 = 0; VAR_26 < 9 + s->mspel * 2; VAR_26++)",
"src[VAR_26] = luty[VAR_17][src[VAR_26]];",
"src += s->linesize << VAR_10;",
"}",
"}",
"srcY += s->mspel * (1 + (s->linesize << VAR_10));",
"}",
"if (s->mspel) {",
"VAR_4 = ((VAR_6 & 3) << 2) | (VAR_5 & 3);",
"if (VAR_3)\nVAR_0->vc1dsp.avg_vc1_mspel_pixels_tab[VAR_4](s->dest[0] + VAR_9, srcY, s->linesize << VAR_10, VAR_0->rnd);",
"else\nVAR_0->vc1dsp.put_vc1_mspel_pixels_tab[VAR_4](s->dest[0] + VAR_9, srcY, s->linesize << VAR_10, VAR_0->rnd);",
"} else {",
"VAR_4 = (VAR_6 & 2) | ((VAR_5 & 2) >> 1);",
"if (!VAR_0->rnd)\ns->hdsp.put_pixels_tab[1][VAR_4](s->dest[0] + VAR_9, srcY, s->linesize, 8);",
"else\ns->hdsp.put_no_rnd_pixels_tab[1][VAR_4](s->dest[0] + VAR_9, srcY, s->linesize, 8);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25,
27,
29
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83,
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117,
119,
121
],
[
123,
125
],
[
127
],
[
129,
131
],
[
133
],
[
135
],
[
137,
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
181,
183
],
[
185,
187
],
[
189,
191
],
[
193,
195
],
[
197
],
[
201,
203
],
[
205,
207
],
[
211
],
[
213,
215
],
[
217,
219
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235,
237
],
[
239,
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
253
],
[
255,
257
],
[
261,
263
],
[
265,
267
],
[
269,
271,
273,
275
],
[
277
],
[
281,
283,
285,
287,
289
],
[
291
],
[
295
],
[
297
],
[
299
],
[
303
],
[
305
],
[
307
],
[
309
],
[
311
],
[
313
],
[
315
],
[
319
],
[
321
],
[
323
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
349
],
[
351
],
[
353,
355
],
[
357,
359
],
[
361
],
[
363
],
[
365,
367
],
[
369,
371
],
[
373
],
[
375
]
] |
23,976 | static int recover(WtvContext *wtv, uint64_t broken_pos)
{
AVIOContext *pb = wtv->pb;
int i;
for (i = 0; i < wtv->nb_index_entries; i++) {
if (wtv->index_entries[i].pos > broken_pos) {
int ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);
if (ret < 0)
return ret;
wtv->pts = wtv->index_entries[i].timestamp;
return 0;
}
}
return AVERROR(EIO);
}
| true | FFmpeg | d44e0d8b930732a4a247b4884d75cf62b4ad3664 | static int recover(WtvContext *wtv, uint64_t broken_pos)
{
AVIOContext *pb = wtv->pb;
int i;
for (i = 0; i < wtv->nb_index_entries; i++) {
if (wtv->index_entries[i].pos > broken_pos) {
int ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);
if (ret < 0)
return ret;
wtv->pts = wtv->index_entries[i].timestamp;
return 0;
}
}
return AVERROR(EIO);
}
| {
"code": [
" int ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET);"
],
"line_no": [
13
]
} | static int FUNC_0(WtvContext *VAR_0, uint64_t VAR_1)
{
AVIOContext *pb = VAR_0->pb;
int VAR_2;
for (VAR_2 = 0; VAR_2 < VAR_0->nb_index_entries; VAR_2++) {
if (VAR_0->index_entries[VAR_2].pos > VAR_1) {
int ret = avio_seek(pb, VAR_0->index_entries[VAR_2].pos, SEEK_SET);
if (ret < 0)
return ret;
VAR_0->pts = VAR_0->index_entries[VAR_2].timestamp;
return 0;
}
}
return AVERROR(EIO);
}
| [
"static int FUNC_0(WtvContext *VAR_0, uint64_t VAR_1)\n{",
"AVIOContext *pb = VAR_0->pb;",
"int VAR_2;",
"for (VAR_2 = 0; VAR_2 < VAR_0->nb_index_entries; VAR_2++) {",
"if (VAR_0->index_entries[VAR_2].pos > VAR_1) {",
"int ret = avio_seek(pb, VAR_0->index_entries[VAR_2].pos, SEEK_SET);",
"if (ret < 0)\nreturn ret;",
"VAR_0->pts = VAR_0->index_entries[VAR_2].timestamp;",
"return 0;",
"}",
"}",
"return AVERROR(EIO);",
"}"
] | [
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
]
] |
23,977 | static always_inline void mpeg_motion_lowres(MpegEncContext *s,
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
int field_based, int bottom_field, int field_select,
uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
int motion_x, int motion_y, int h)
{
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
const int lowres= s->avctx->lowres;
const int block_s= 8>>lowres;
const int s_mask= (2<<lowres)-1;
const int h_edge_pos = s->h_edge_pos >> lowres;
const int v_edge_pos = s->v_edge_pos >> lowres;
linesize = s->current_picture.linesize[0] << field_based;
uvlinesize = s->current_picture.linesize[1] << field_based;
if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
motion_x/=2;
motion_y/=2;
}
if(field_based){
motion_y += (bottom_field - field_select)*((1<<lowres)-1);
}
sx= motion_x & s_mask;
sy= motion_y & s_mask;
src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
if (s->out_format == FMT_H263) {
uvsx = ((motion_x>>1) & s_mask) | (sx&1);
uvsy = ((motion_y>>1) & s_mask) | (sy&1);
uvsrc_x = src_x>>1;
uvsrc_y = src_y>>1;
}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
mx = motion_x / 4;
my = motion_y / 4;
uvsx = (2*mx) & s_mask;
uvsy = (2*my) & s_mask;
uvsrc_x = s->mb_x*block_s + (mx >> lowres);
uvsrc_y = s->mb_y*block_s + (my >> lowres);
} else {
mx = motion_x / 2;
my = motion_y / 2;
uvsx = mx & s_mask;
uvsy = my & s_mask;
uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
}
ptr_y = ref_picture[0] + src_y * linesize + src_x;
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
ptr_y = s->edge_emu_buffer;
if(!(s->flags&CODEC_FLAG_GRAY)){
uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
ptr_cb= uvbuf;
ptr_cr= uvbuf+16;
}
}
if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
dest_y += s->linesize;
dest_cb+= s->uvlinesize;
dest_cr+= s->uvlinesize;
}
if(field_select){
ptr_y += s->linesize;
ptr_cb+= s->uvlinesize;
ptr_cr+= s->uvlinesize;
}
sx <<= 2 - lowres;
sy <<= 2 - lowres;
pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
if(!(s->flags&CODEC_FLAG_GRAY)){
uvsx <<= 2 - lowres;
uvsy <<= 2 - lowres;
pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
}
} | true | FFmpeg | 5f6c92d40c2003471b005cc05430ec8488000867 | static always_inline void mpeg_motion_lowres(MpegEncContext *s,
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
int field_based, int bottom_field, int field_select,
uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
int motion_x, int motion_y, int h)
{
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
const int lowres= s->avctx->lowres;
const int block_s= 8>>lowres;
const int s_mask= (2<<lowres)-1;
const int h_edge_pos = s->h_edge_pos >> lowres;
const int v_edge_pos = s->v_edge_pos >> lowres;
linesize = s->current_picture.linesize[0] << field_based;
uvlinesize = s->current_picture.linesize[1] << field_based;
if(s->quarter_sample){
motion_x/=2;
motion_y/=2;
}
if(field_based){
motion_y += (bottom_field - field_select)*((1<<lowres)-1);
}
sx= motion_x & s_mask;
sy= motion_y & s_mask;
src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
if (s->out_format == FMT_H263) {
uvsx = ((motion_x>>1) & s_mask) | (sx&1);
uvsy = ((motion_y>>1) & s_mask) | (sy&1);
uvsrc_x = src_x>>1;
uvsrc_y = src_y>>1;
}else if(s->out_format == FMT_H261){
mx = motion_x / 4;
my = motion_y / 4;
uvsx = (2*mx) & s_mask;
uvsy = (2*my) & s_mask;
uvsrc_x = s->mb_x*block_s + (mx >> lowres);
uvsrc_y = s->mb_y*block_s + (my >> lowres);
} else {
mx = motion_x / 2;
my = motion_y / 2;
uvsx = mx & s_mask;
uvsy = my & s_mask;
uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
}
ptr_y = ref_picture[0] + src_y * linesize + src_x;
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
ptr_y = s->edge_emu_buffer;
if(!(s->flags&CODEC_FLAG_GRAY)){
uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
ptr_cb= uvbuf;
ptr_cr= uvbuf+16;
}
}
if(bottom_field){
dest_y += s->linesize;
dest_cb+= s->uvlinesize;
dest_cr+= s->uvlinesize;
}
if(field_select){
ptr_y += s->linesize;
ptr_cb+= s->uvlinesize;
ptr_cr+= s->uvlinesize;
}
sx <<= 2 - lowres;
sy <<= 2 - lowres;
pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
if(!(s->flags&CODEC_FLAG_GRAY)){
uvsx <<= 2 - lowres;
uvsy <<= 2 - lowres;
pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
}
} | {
"code": [],
"line_no": []
} | static always_inline void FUNC_0(MpegEncContext *s,
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
int field_based, int bottom_field, int field_select,
uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
int motion_x, int motion_y, int h)
{
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;
const int VAR_12= s->avctx->VAR_12;
const int VAR_13= 8>>VAR_12;
const int VAR_14= (2<<VAR_12)-1;
const int VAR_15 = s->VAR_15 >> VAR_12;
const int VAR_16 = s->VAR_16 >> VAR_12;
VAR_7 = s->current_picture.VAR_7[0] << field_based;
VAR_6 = s->current_picture.VAR_7[1] << field_based;
if(s->quarter_sample){
motion_x/=2;
motion_y/=2;
}
if(field_based){
motion_y += (bottom_field - field_select)*((1<<VAR_12)-1);
}
VAR_8= motion_x & VAR_14;
VAR_9= motion_y & VAR_14;
VAR_2 = s->mb_x*2*VAR_13 + (motion_x >> (VAR_12+1));
VAR_3 =(s->mb_y*2*VAR_13>>field_based) + (motion_y >> (VAR_12+1));
if (s->out_format == FMT_H263) {
VAR_10 = ((motion_x>>1) & VAR_14) | (VAR_8&1);
VAR_11 = ((motion_y>>1) & VAR_14) | (VAR_9&1);
VAR_4 = VAR_2>>1;
VAR_5 = VAR_3>>1;
}else if(s->out_format == FMT_H261){
VAR_0 = motion_x / 4;
VAR_1 = motion_y / 4;
VAR_10 = (2*VAR_0) & VAR_14;
VAR_11 = (2*VAR_1) & VAR_14;
VAR_4 = s->mb_x*VAR_13 + (VAR_0 >> VAR_12);
VAR_5 = s->mb_y*VAR_13 + (VAR_1 >> VAR_12);
} else {
VAR_0 = motion_x / 2;
VAR_1 = motion_y / 2;
VAR_10 = VAR_0 & VAR_14;
VAR_11 = VAR_1 & VAR_14;
VAR_4 = s->mb_x*VAR_13 + (VAR_0 >> (VAR_12+1));
VAR_5 =(s->mb_y*VAR_13>>field_based) + (VAR_1 >> (VAR_12+1));
}
ptr_y = ref_picture[0] + VAR_3 * VAR_7 + VAR_2;
ptr_cb = ref_picture[1] + VAR_5 * VAR_6 + VAR_4;
ptr_cr = ref_picture[2] + VAR_5 * VAR_6 + VAR_4;
if( (unsigned)VAR_2 > VAR_15 - (!!VAR_8) - 2*VAR_13
|| (unsigned)VAR_3 >(VAR_16 >> field_based) - (!!VAR_9) - h){
ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->VAR_7, 17, 17+field_based,
VAR_2, VAR_3<<field_based, VAR_15, VAR_16);
ptr_y = s->edge_emu_buffer;
if(!(s->flags&CODEC_FLAG_GRAY)){
uint8_t *uvbuf= s->edge_emu_buffer+18*s->VAR_7;
ff_emulated_edge_mc(uvbuf , ptr_cb, s->VAR_6, 9, 9+field_based,
VAR_4, VAR_5<<field_based, VAR_15>>1, VAR_16>>1);
ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->VAR_6, 9, 9+field_based,
VAR_4, VAR_5<<field_based, VAR_15>>1, VAR_16>>1);
ptr_cb= uvbuf;
ptr_cr= uvbuf+16;
}
}
if(bottom_field){
dest_y += s->VAR_7;
dest_cb+= s->VAR_6;
dest_cr+= s->VAR_6;
}
if(field_select){
ptr_y += s->VAR_7;
ptr_cb+= s->VAR_6;
ptr_cr+= s->VAR_6;
}
VAR_8 <<= 2 - VAR_12;
VAR_9 <<= 2 - VAR_12;
pix_op[VAR_12-1](dest_y, ptr_y, VAR_7, h, VAR_8, VAR_9);
if(!(s->flags&CODEC_FLAG_GRAY)){
VAR_10 <<= 2 - VAR_12;
VAR_11 <<= 2 - VAR_12;
pix_op[VAR_12](dest_cb, ptr_cb, VAR_6, h >> s->chroma_y_shift, VAR_10, VAR_11);
pix_op[VAR_12](dest_cr, ptr_cr, VAR_6, h >> s->chroma_y_shift, VAR_10, VAR_11);
}
} | [
"static always_inline void FUNC_0(MpegEncContext *s,\nuint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,\nint field_based, int bottom_field, int field_select,\nuint8_t **ref_picture, h264_chroma_mc_func *pix_op,\nint motion_x, int motion_y, int h)\n{",
"uint8_t *ptr_y, *ptr_cb, *ptr_cr;",
"int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;",
"const int VAR_12= s->avctx->VAR_12;",
"const int VAR_13= 8>>VAR_12;",
"const int VAR_14= (2<<VAR_12)-1;",
"const int VAR_15 = s->VAR_15 >> VAR_12;",
"const int VAR_16 = s->VAR_16 >> VAR_12;",
"VAR_7 = s->current_picture.VAR_7[0] << field_based;",
"VAR_6 = s->current_picture.VAR_7[1] << field_based;",
"if(s->quarter_sample){",
"motion_x/=2;",
"motion_y/=2;",
"}",
"if(field_based){",
"motion_y += (bottom_field - field_select)*((1<<VAR_12)-1);",
"}",
"VAR_8= motion_x & VAR_14;",
"VAR_9= motion_y & VAR_14;",
"VAR_2 = s->mb_x*2*VAR_13 + (motion_x >> (VAR_12+1));",
"VAR_3 =(s->mb_y*2*VAR_13>>field_based) + (motion_y >> (VAR_12+1));",
"if (s->out_format == FMT_H263) {",
"VAR_10 = ((motion_x>>1) & VAR_14) | (VAR_8&1);",
"VAR_11 = ((motion_y>>1) & VAR_14) | (VAR_9&1);",
"VAR_4 = VAR_2>>1;",
"VAR_5 = VAR_3>>1;",
"}else if(s->out_format == FMT_H261){",
"VAR_0 = motion_x / 4;",
"VAR_1 = motion_y / 4;",
"VAR_10 = (2*VAR_0) & VAR_14;",
"VAR_11 = (2*VAR_1) & VAR_14;",
"VAR_4 = s->mb_x*VAR_13 + (VAR_0 >> VAR_12);",
"VAR_5 = s->mb_y*VAR_13 + (VAR_1 >> VAR_12);",
"} else {",
"VAR_0 = motion_x / 2;",
"VAR_1 = motion_y / 2;",
"VAR_10 = VAR_0 & VAR_14;",
"VAR_11 = VAR_1 & VAR_14;",
"VAR_4 = s->mb_x*VAR_13 + (VAR_0 >> (VAR_12+1));",
"VAR_5 =(s->mb_y*VAR_13>>field_based) + (VAR_1 >> (VAR_12+1));",
"}",
"ptr_y = ref_picture[0] + VAR_3 * VAR_7 + VAR_2;",
"ptr_cb = ref_picture[1] + VAR_5 * VAR_6 + VAR_4;",
"ptr_cr = ref_picture[2] + VAR_5 * VAR_6 + VAR_4;",
"if( (unsigned)VAR_2 > VAR_15 - (!!VAR_8) - 2*VAR_13\n|| (unsigned)VAR_3 >(VAR_16 >> field_based) - (!!VAR_9) - h){",
"ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->VAR_7, 17, 17+field_based,\nVAR_2, VAR_3<<field_based, VAR_15, VAR_16);",
"ptr_y = s->edge_emu_buffer;",
"if(!(s->flags&CODEC_FLAG_GRAY)){",
"uint8_t *uvbuf= s->edge_emu_buffer+18*s->VAR_7;",
"ff_emulated_edge_mc(uvbuf , ptr_cb, s->VAR_6, 9, 9+field_based,\nVAR_4, VAR_5<<field_based, VAR_15>>1, VAR_16>>1);",
"ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->VAR_6, 9, 9+field_based,\nVAR_4, VAR_5<<field_based, VAR_15>>1, VAR_16>>1);",
"ptr_cb= uvbuf;",
"ptr_cr= uvbuf+16;",
"}",
"}",
"if(bottom_field){",
"dest_y += s->VAR_7;",
"dest_cb+= s->VAR_6;",
"dest_cr+= s->VAR_6;",
"}",
"if(field_select){",
"ptr_y += s->VAR_7;",
"ptr_cb+= s->VAR_6;",
"ptr_cr+= s->VAR_6;",
"}",
"VAR_8 <<= 2 - VAR_12;",
"VAR_9 <<= 2 - VAR_12;",
"pix_op[VAR_12-1](dest_y, ptr_y, VAR_7, h, VAR_8, VAR_9);",
"if(!(s->flags&CODEC_FLAG_GRAY)){",
"VAR_10 <<= 2 - VAR_12;",
"VAR_11 <<= 2 - VAR_12;",
"pix_op[VAR_12](dest_cb, ptr_cb, VAR_6, h >> s->chroma_y_shift, VAR_10, VAR_11);",
"pix_op[VAR_12](dest_cr, ptr_cr, VAR_6, h >> s->chroma_y_shift, VAR_10, VAR_11);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
111,
113
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
125,
127
],
[
129,
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
169
],
[
171
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
188
]
] |
23,978 | static void qxl_reset_state(PCIQXLDevice *d)
{
QXLRam *ram = d->ram;
QXLRom *rom = d->rom;
assert(SPICE_RING_IS_EMPTY(&ram->cmd_ring));
assert(SPICE_RING_IS_EMPTY(&ram->cursor_ring));
d->shadow_rom.update_id = cpu_to_le32(0);
*rom = d->shadow_rom;
qxl_rom_set_dirty(d);
init_qxl_ram(d);
d->num_free_res = 0;
d->last_release = NULL;
memset(&d->ssd.dirty, 0, sizeof(d->ssd.dirty));
}
| true | qemu | 8927cfbba232e28304734f7afd463c1b84134031 | static void qxl_reset_state(PCIQXLDevice *d)
{
QXLRam *ram = d->ram;
QXLRom *rom = d->rom;
assert(SPICE_RING_IS_EMPTY(&ram->cmd_ring));
assert(SPICE_RING_IS_EMPTY(&ram->cursor_ring));
d->shadow_rom.update_id = cpu_to_le32(0);
*rom = d->shadow_rom;
qxl_rom_set_dirty(d);
init_qxl_ram(d);
d->num_free_res = 0;
d->last_release = NULL;
memset(&d->ssd.dirty, 0, sizeof(d->ssd.dirty));
}
| {
"code": [
" assert(SPICE_RING_IS_EMPTY(&ram->cmd_ring));",
" assert(SPICE_RING_IS_EMPTY(&ram->cursor_ring));"
],
"line_no": [
11,
13
]
} | static void FUNC_0(PCIQXLDevice *VAR_0)
{
QXLRam *ram = VAR_0->ram;
QXLRom *rom = VAR_0->rom;
assert(SPICE_RING_IS_EMPTY(&ram->cmd_ring));
assert(SPICE_RING_IS_EMPTY(&ram->cursor_ring));
VAR_0->shadow_rom.update_id = cpu_to_le32(0);
*rom = VAR_0->shadow_rom;
qxl_rom_set_dirty(VAR_0);
init_qxl_ram(VAR_0);
VAR_0->num_free_res = 0;
VAR_0->last_release = NULL;
memset(&VAR_0->ssd.dirty, 0, sizeof(VAR_0->ssd.dirty));
}
| [
"static void FUNC_0(PCIQXLDevice *VAR_0)\n{",
"QXLRam *ram = VAR_0->ram;",
"QXLRom *rom = VAR_0->rom;",
"assert(SPICE_RING_IS_EMPTY(&ram->cmd_ring));",
"assert(SPICE_RING_IS_EMPTY(&ram->cursor_ring));",
"VAR_0->shadow_rom.update_id = cpu_to_le32(0);",
"*rom = VAR_0->shadow_rom;",
"qxl_rom_set_dirty(VAR_0);",
"init_qxl_ram(VAR_0);",
"VAR_0->num_free_res = 0;",
"VAR_0->last_release = NULL;",
"memset(&VAR_0->ssd.dirty, 0, sizeof(VAR_0->ssd.dirty));",
"}"
] | [
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
]
] |
23,979 | static const uint8_t *decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
int i, si, di;
uint8_t *dst;
int bufidx;
// src[0]&0x80; //forbidden bit
h->nal_ref_idc= src[0]>>5;
h->nal_unit_type= src[0]&0x1F;
src++; length--;
#if 0
for(i=0; i<length; i++)
printf("%2X ", src[i]);
#endif
for(i=0; i+1<length; i+=2){
if(src[i]) continue;
if(i>0 && src[i-1]==0) i--;
if(i+2<length && src[i+1]==0 && src[i+2]<=3){
if(src[i+2]!=3){
/* startcode, so we must be past the end */
length=i;
}
break;
}
}
if(i>=length-1){ //no escaped 0
*dst_length= length;
*consumed= length+1; //+1 for the header
return src;
}
bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length);
dst= h->rbsp_buffer[bufidx];
if (dst == NULL){
return NULL;
}
//printf("decoding esc\n");
si=di=0;
while(si<length){
//remove escapes (very rare 1:2^22)
if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
if(src[si+2]==3){ //escape
dst[di++]= 0;
dst[di++]= 0;
si+=3;
continue;
}else //next start code
break;
}
dst[di++]= src[si++];
}
*dst_length= di;
*consumed= si + 1;//+1 for the header
//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
return dst;
}
| true | FFmpeg | d43696309a64a19e2e738f9e7aa94f6c96409aee | static const uint8_t *decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
int i, si, di;
uint8_t *dst;
int bufidx;
h->nal_ref_idc= src[0]>>5;
h->nal_unit_type= src[0]&0x1F;
src++; length--;
#if 0
for(i=0; i<length; i++)
printf("%2X ", src[i]);
#endif
for(i=0; i+1<length; i+=2){
if(src[i]) continue;
if(i>0 && src[i-1]==0) i--;
if(i+2<length && src[i+1]==0 && src[i+2]<=3){
if(src[i+2]!=3){
length=i;
}
break;
}
}
if(i>=length-1){
*dst_length= length;
*consumed= length+1;
return src;
}
bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0;
h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length);
dst= h->rbsp_buffer[bufidx];
if (dst == NULL){
return NULL;
}
si=di=0;
while(si<length){
if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
if(src[si+2]==3){
dst[di++]= 0;
dst[di++]= 0;
si+=3;
continue;
}else
break;
}
dst[di++]= src[si++];
}
*dst_length= di;
*consumed= si + 1;
return dst;
}
| {
"code": [
" h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length);"
],
"line_no": [
67
]
} | static const uint8_t *FUNC_0(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
int VAR_0, VAR_1, VAR_2;
uint8_t *dst;
int VAR_3;
h->nal_ref_idc= src[0]>>5;
h->nal_unit_type= src[0]&0x1F;
src++; length--;
#if 0
for(VAR_0=0; VAR_0<length; VAR_0++)
printf("%2X ", src[VAR_0]);
#endif
for(VAR_0=0; VAR_0+1<length; VAR_0+=2){
if(src[VAR_0]) continue;
if(VAR_0>0 && src[VAR_0-1]==0) VAR_0--;
if(VAR_0+2<length && src[VAR_0+1]==0 && src[VAR_0+2]<=3){
if(src[VAR_0+2]!=3){
length=VAR_0;
}
break;
}
}
if(VAR_0>=length-1){
*dst_length= length;
*consumed= length+1;
return src;
}
VAR_3 = h->nal_unit_type == NAL_DPC ? 1 : 0;
h->rbsp_buffer[VAR_3]= av_fast_realloc(h->rbsp_buffer[VAR_3], &h->rbsp_buffer_size[VAR_3], length);
dst= h->rbsp_buffer[VAR_3];
if (dst == NULL){
return NULL;
}
VAR_1=VAR_2=0;
while(VAR_1<length){
if(VAR_1+2<length && src[VAR_1]==0 && src[VAR_1+1]==0 && src[VAR_1+2]<=3){
if(src[VAR_1+2]==3){
dst[VAR_2++]= 0;
dst[VAR_2++]= 0;
VAR_1+=3;
continue;
}else
break;
}
dst[VAR_2++]= src[VAR_1++];
}
*dst_length= VAR_2;
*consumed= VAR_1 + 1;
return dst;
}
| [
"static const uint8_t *FUNC_0(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){",
"int VAR_0, VAR_1, VAR_2;",
"uint8_t *dst;",
"int VAR_3;",
"h->nal_ref_idc= src[0]>>5;",
"h->nal_unit_type= src[0]&0x1F;",
"src++; length--;",
"#if 0\nfor(VAR_0=0; VAR_0<length; VAR_0++)",
"printf(\"%2X \", src[VAR_0]);",
"#endif\nfor(VAR_0=0; VAR_0+1<length; VAR_0+=2){",
"if(src[VAR_0]) continue;",
"if(VAR_0>0 && src[VAR_0-1]==0) VAR_0--;",
"if(VAR_0+2<length && src[VAR_0+1]==0 && src[VAR_0+2]<=3){",
"if(src[VAR_0+2]!=3){",
"length=VAR_0;",
"}",
"break;",
"}",
"}",
"if(VAR_0>=length-1){",
"*dst_length= length;",
"*consumed= length+1;",
"return src;",
"}",
"VAR_3 = h->nal_unit_type == NAL_DPC ? 1 : 0;",
"h->rbsp_buffer[VAR_3]= av_fast_realloc(h->rbsp_buffer[VAR_3], &h->rbsp_buffer_size[VAR_3], length);",
"dst= h->rbsp_buffer[VAR_3];",
"if (dst == NULL){",
"return NULL;",
"}",
"VAR_1=VAR_2=0;",
"while(VAR_1<length){",
"if(VAR_1+2<length && src[VAR_1]==0 && src[VAR_1+1]==0 && src[VAR_1+2]<=3){",
"if(src[VAR_1+2]==3){",
"dst[VAR_2++]= 0;",
"dst[VAR_2++]= 0;",
"VAR_1+=3;",
"continue;",
"}else",
"break;",
"}",
"dst[VAR_2++]= src[VAR_1++];",
"}",
"*dst_length= VAR_2;",
"*consumed= VAR_1 + 1;",
"return dst;",
"}"
] | [
0,
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
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
77
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
115
],
[
117
],
[
121
],
[
123
]
] |
23,980 | static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
{
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
target_ulong msr, new_msr, vector;
int srr0, srr1, asrr0, asrr1;
int lpes0, lpes1, lev, ail;
if (0) {
/* XXX: find a suitable condition to enable the hypervisor mode */
lpes0 = (env->spr[SPR_LPCR] >> 1) & 1;
lpes1 = (env->spr[SPR_LPCR] >> 2) & 1;
} else {
/* Those values ensure we won't enter the hypervisor mode */
lpes0 = 0;
lpes1 = 1;
}
qemu_log_mask(CPU_LOG_INT, "Raise exception at " TARGET_FMT_lx
" => %08x (%02x)\n", env->nip, excp, env->error_code);
/* new srr1 value excluding must-be-zero bits */
if (excp_model == POWERPC_EXCP_BOOKE) {
msr = env->msr;
} else {
msr = env->msr & ~0x783f0000ULL;
}
/* new interrupt handler msr */
new_msr = env->msr & ((target_ulong)1 << MSR_ME);
/* target registers */
srr0 = SPR_SRR0;
srr1 = SPR_SRR1;
asrr0 = -1;
asrr1 = -1;
/* Exception targetting modifiers
*
* AIL is initialized here but can be cleared by
* selected exceptions
*/
#if defined(TARGET_PPC64)
if (excp_model == POWERPC_EXCP_POWER7 ||
excp_model == POWERPC_EXCP_POWER8) {
if (excp_model == POWERPC_EXCP_POWER8) {
ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
} else {
ail = 0;
}
} else
#endif /* defined(TARGET_PPC64) */
{
ail = 0;
}
switch (excp) {
case POWERPC_EXCP_NONE:
/* Should never happen */
return;
case POWERPC_EXCP_CRITICAL: /* Critical input */
switch (excp_model) {
case POWERPC_EXCP_40x:
srr0 = SPR_40x_SRR2;
srr1 = SPR_40x_SRR3;
break;
case POWERPC_EXCP_BOOKE:
srr0 = SPR_BOOKE_CSRR0;
srr1 = SPR_BOOKE_CSRR1;
break;
case POWERPC_EXCP_G2:
break;
default:
goto excp_invalid;
}
goto store_next;
case POWERPC_EXCP_MCHECK: /* Machine check exception */
if (msr_me == 0) {
/* Machine check exception is not enabled.
* Enter checkstop state.
*/
fprintf(stderr, "Machine check while not allowed. "
"Entering checkstop state\n");
if (qemu_log_separate()) {
qemu_log("Machine check while not allowed. "
"Entering checkstop state\n");
}
cs->halted = 1;
cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
}
if (0) {
/* XXX: find a suitable condition to enable the hypervisor mode */
new_msr |= (target_ulong)MSR_HVB;
}
ail = 0;
/* machine check exceptions don't have ME set */
new_msr &= ~((target_ulong)1 << MSR_ME);
/* XXX: should also have something loaded in DAR / DSISR */
switch (excp_model) {
case POWERPC_EXCP_40x:
srr0 = SPR_40x_SRR2;
srr1 = SPR_40x_SRR3;
break;
case POWERPC_EXCP_BOOKE:
/* FIXME: choose one or the other based on CPU type */
srr0 = SPR_BOOKE_MCSRR0;
srr1 = SPR_BOOKE_MCSRR1;
asrr0 = SPR_BOOKE_CSRR0;
asrr1 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
goto store_next;
case POWERPC_EXCP_DSI: /* Data storage exception */
LOG_EXCP("DSI exception: DSISR=" TARGET_FMT_lx" DAR=" TARGET_FMT_lx
"\n", env->spr[SPR_DSISR], env->spr[SPR_DAR]);
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_ISI: /* Instruction storage exception */
LOG_EXCP("ISI exception: msr=" TARGET_FMT_lx ", nip=" TARGET_FMT_lx
"\n", msr, env->nip);
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= env->error_code;
goto store_next;
case POWERPC_EXCP_EXTERNAL: /* External input */
cs = CPU(cpu);
if (lpes0 == 1) {
new_msr |= (target_ulong)MSR_HVB;
}
if (env->mpic_proxy) {
/* IACK the IRQ on delivery */
env->spr[SPR_BOOKE_EPR] = ldl_phys(cs->as, env->mpic_iack);
}
goto store_next;
case POWERPC_EXCP_ALIGN: /* Alignment exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
/* XXX: this is false */
/* Get rS/rD and rA from faulting opcode */
env->spr[SPR_DSISR] |= (cpu_ldl_code(env, (env->nip - 4))
& 0x03FF0000) >> 16;
goto store_next;
case POWERPC_EXCP_PROGRAM: /* Program exception */
switch (env->error_code & ~0xF) {
case POWERPC_EXCP_FP:
if ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {
LOG_EXCP("Ignore floating point exception\n");
cs->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
return;
}
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00100000;
if (msr_fe0 == msr_fe1) {
goto store_next;
}
msr |= 0x00010000;
break;
case POWERPC_EXCP_INVAL:
LOG_EXCP("Invalid instruction at " TARGET_FMT_lx "\n", env->nip);
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00080000;
env->spr[SPR_BOOKE_ESR] = ESR_PIL;
break;
case POWERPC_EXCP_PRIV:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00040000;
env->spr[SPR_BOOKE_ESR] = ESR_PPR;
break;
case POWERPC_EXCP_TRAP:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00020000;
env->spr[SPR_BOOKE_ESR] = ESR_PTR;
break;
default:
/* Should never occur */
cpu_abort(cs, "Invalid program exception %d. Aborting\n",
env->error_code);
break;
}
goto store_current;
case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_SYSCALL: /* System call exception */
dump_syscall(env);
lev = env->error_code;
if ((lev == 1) && cpu_ppc_hypercall) {
cpu_ppc_hypercall(cpu);
return;
}
if (lev == 1 || (lpes0 == 0 && lpes1 == 0)) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
goto store_current;
case POWERPC_EXCP_DECR: /* Decrementer exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
/* FIT on 4xx */
LOG_EXCP("FIT exception\n");
goto store_next;
case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
LOG_EXCP("WDT exception\n");
switch (excp_model) {
case POWERPC_EXCP_BOOKE:
srr0 = SPR_BOOKE_CSRR0;
srr1 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
goto store_next;
case POWERPC_EXCP_DTLB: /* Data TLB error */
goto store_next;
case POWERPC_EXCP_ITLB: /* Instruction TLB error */
goto store_next;
case POWERPC_EXCP_DEBUG: /* Debug interrupt */
switch (excp_model) {
case POWERPC_EXCP_BOOKE:
/* FIXME: choose one or the other based on CPU type */
srr0 = SPR_BOOKE_DSRR0;
srr1 = SPR_BOOKE_DSRR1;
asrr0 = SPR_BOOKE_CSRR0;
asrr1 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
/* XXX: TODO */
cpu_abort(cs, "Debug exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavailable */
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_current;
case POWERPC_EXCP_EFPDI: /* Embedded floating-point data interrupt */
/* XXX: TODO */
cpu_abort(cs, "Embedded floating point data exception "
"is not implemented yet !\n");
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_next;
case POWERPC_EXCP_EFPRI: /* Embedded floating-point round interrupt */
/* XXX: TODO */
cpu_abort(cs, "Embedded floating point round exception "
"is not implemented yet !\n");
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_next;
case POWERPC_EXCP_EPERFM: /* Embedded performance monitor interrupt */
/* XXX: TODO */
cpu_abort(cs,
"Performance counter exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
goto store_next;
case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
srr0 = SPR_BOOKE_CSRR0;
srr1 = SPR_BOOKE_CSRR1;
goto store_next;
case POWERPC_EXCP_RESET: /* System reset exception */
if (msr_pow) {
/* indicate that we resumed from power save mode */
msr |= 0x10000;
} else {
new_msr &= ~((target_ulong)1 << MSR_ME);
}
if (0) {
/* XXX: find a suitable condition to enable the hypervisor mode */
new_msr |= (target_ulong)MSR_HVB;
}
ail = 0;
goto store_next;
case POWERPC_EXCP_DSEG: /* Data segment exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_ISEG: /* Instruction segment exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_TRACE: /* Trace exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HISI: /* Hypervisor instruction storage exception */
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment exception */
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_VPU: /* Vector unavailable exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_VSXU: /* VSX unavailable exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_FU: /* Facility unavailable exception */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_PIT: /* Programmable interval timer interrupt */
LOG_EXCP("PIT exception\n");
goto store_next;
case POWERPC_EXCP_IO: /* IO error exception */
/* XXX: TODO */
cpu_abort(cs, "601 IO error exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_RUNM: /* Run mode exception */
/* XXX: TODO */
cpu_abort(cs, "601 run mode exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_EMUL: /* Emulation trap exception */
/* XXX: TODO */
cpu_abort(cs, "602 emulation trap exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
if (lpes1 == 0) { /* XXX: check this */
new_msr |= (target_ulong)MSR_HVB;
}
switch (excp_model) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
goto tlb_miss_tgpr;
case POWERPC_EXCP_7x5:
goto tlb_miss;
case POWERPC_EXCP_74xx:
goto tlb_miss_74xx;
default:
cpu_abort(cs, "Invalid instruction TLB miss exception\n");
break;
}
break;
case POWERPC_EXCP_DLTLB: /* Data load TLB miss */
if (lpes1 == 0) { /* XXX: check this */
new_msr |= (target_ulong)MSR_HVB;
}
switch (excp_model) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
goto tlb_miss_tgpr;
case POWERPC_EXCP_7x5:
goto tlb_miss;
case POWERPC_EXCP_74xx:
goto tlb_miss_74xx;
default:
cpu_abort(cs, "Invalid data load TLB miss exception\n");
break;
}
break;
case POWERPC_EXCP_DSTLB: /* Data store TLB miss */
if (lpes1 == 0) { /* XXX: check this */
new_msr |= (target_ulong)MSR_HVB;
}
switch (excp_model) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
tlb_miss_tgpr:
/* Swap temporary saved registers with GPRs */
if (!(new_msr & ((target_ulong)1 << MSR_TGPR))) {
new_msr |= (target_ulong)1 << MSR_TGPR;
hreg_swap_gpr_tgpr(env);
}
goto tlb_miss;
case POWERPC_EXCP_7x5:
tlb_miss:
#if defined(DEBUG_SOFTWARE_TLB)
if (qemu_log_enabled()) {
const char *es;
target_ulong *miss, *cmp;
int en;
if (excp == POWERPC_EXCP_IFTLB) {
es = "I";
en = 'I';
miss = &env->spr[SPR_IMISS];
cmp = &env->spr[SPR_ICMP];
} else {
if (excp == POWERPC_EXCP_DLTLB) {
es = "DL";
} else {
es = "DS";
}
en = 'D';
miss = &env->spr[SPR_DMISS];
cmp = &env->spr[SPR_DCMP];
}
qemu_log("6xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
TARGET_FMT_lx " H1 " TARGET_FMT_lx " H2 "
TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
env->spr[SPR_HASH1], env->spr[SPR_HASH2],
env->error_code);
}
#endif
msr |= env->crf[0] << 28;
msr |= env->error_code; /* key, D/I, S/L bits */
/* Set way using a LRU mechanism */
msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
break;
case POWERPC_EXCP_74xx:
tlb_miss_74xx:
#if defined(DEBUG_SOFTWARE_TLB)
if (qemu_log_enabled()) {
const char *es;
target_ulong *miss, *cmp;
int en;
if (excp == POWERPC_EXCP_IFTLB) {
es = "I";
en = 'I';
miss = &env->spr[SPR_TLBMISS];
cmp = &env->spr[SPR_PTEHI];
} else {
if (excp == POWERPC_EXCP_DLTLB) {
es = "DL";
} else {
es = "DS";
}
en = 'D';
miss = &env->spr[SPR_TLBMISS];
cmp = &env->spr[SPR_PTEHI];
}
qemu_log("74xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
env->error_code);
}
#endif
msr |= env->error_code; /* key bit */
break;
default:
cpu_abort(cs, "Invalid data store TLB miss exception\n");
break;
}
goto store_next;
case POWERPC_EXCP_FPA: /* Floating-point assist exception */
/* XXX: TODO */
cpu_abort(cs, "Floating point assist exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_DABR: /* Data address breakpoint */
/* XXX: TODO */
cpu_abort(cs, "DABR exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
/* XXX: TODO */
cpu_abort(cs, "IABR exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SMI: /* System management interrupt */
/* XXX: TODO */
cpu_abort(cs, "SMI exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_THERM: /* Thermal interrupt */
/* XXX: TODO */
cpu_abort(cs, "Thermal management exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_PERFM: /* Embedded performance monitor interrupt */
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
/* XXX: TODO */
cpu_abort(cs,
"Performance counter exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_VPUA: /* Vector assist exception */
/* XXX: TODO */
cpu_abort(cs, "VPU assist exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SOFTP: /* Soft patch exception */
/* XXX: TODO */
cpu_abort(cs,
"970 soft-patch exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_MAINT: /* Maintenance exception */
/* XXX: TODO */
cpu_abort(cs,
"970 maintenance exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_MEXTBR: /* Maskable external breakpoint */
/* XXX: TODO */
cpu_abort(cs, "Maskable external exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_NMEXTBR: /* Non maskable external breakpoint */
/* XXX: TODO */
cpu_abort(cs, "Non maskable external exception "
"is not implemented yet !\n");
goto store_next;
default:
excp_invalid:
cpu_abort(cs, "Invalid PowerPC exception %d. Aborting\n", excp);
break;
store_current:
/* save current instruction location */
env->spr[srr0] = env->nip - 4;
break;
store_next:
/* save next instruction location */
env->spr[srr0] = env->nip;
break;
}
/* Save MSR */
env->spr[srr1] = msr;
/* If any alternate SRR register are defined, duplicate saved values */
if (asrr0 != -1) {
env->spr[asrr0] = env->spr[srr0];
}
if (asrr1 != -1) {
env->spr[asrr1] = env->spr[srr1];
}
if (env->spr[SPR_LPCR] & LPCR_AIL) {
new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
}
#ifdef TARGET_PPC64
if (excp_model == POWERPC_EXCP_POWER7 ||
excp_model == POWERPC_EXCP_POWER8) {
if (env->spr[SPR_LPCR] & LPCR_ILE) {
new_msr |= (target_ulong)1 << MSR_LE;
}
} else if (msr_ile) {
new_msr |= (target_ulong)1 << MSR_LE;
}
#else
if (msr_ile) {
new_msr |= (target_ulong)1 << MSR_LE;
}
#endif
/* Jump to handler */
vector = env->excp_vectors[excp];
if (vector == (target_ulong)-1ULL) {
cpu_abort(cs, "Raised an exception without defined vector %d\n",
excp);
}
vector |= env->excp_prefix;
/* AIL only works if there is no HV transition and we are running with
* translations enabled
*/
if (!((msr >> MSR_IR) & 1) || !((msr >> MSR_DR) & 1)) {
ail = 0;
}
/* Handle AIL */
if (ail) {
new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
switch(ail) {
case AIL_0001_8000:
vector |= 0x18000;
break;
case AIL_C000_0000_0000_4000:
vector |= 0xc000000000004000ull;
break;
default:
cpu_abort(cs, "Invalid AIL combination %d\n", ail);
break;
}
}
#if defined(TARGET_PPC64)
if (excp_model == POWERPC_EXCP_BOOKE) {
if (env->spr[SPR_BOOKE_EPCR] & EPCR_ICM) {
/* Cat.64-bit: EPCR.ICM is copied to MSR.CM */
new_msr |= (target_ulong)1 << MSR_CM;
} else {
vector = (uint32_t)vector;
}
} else {
if (!msr_isf && !(env->mmu_model & POWERPC_MMU_64)) {
vector = (uint32_t)vector;
} else {
new_msr |= (target_ulong)1 << MSR_SF;
}
}
#endif
/* We don't use hreg_store_msr here as already have treated
* any special case that could occur. Just store MSR and update hflags
*
* Note: We *MUST* not use hreg_store_msr() as-is anyway because it
* will prevent setting of the HV bit which some exceptions might need
* to do.
*/
env->msr = new_msr & env->msr_mask;
hreg_compute_hflags(env);
env->nip = vector;
/* Reset exception state */
cs->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
/* Any interrupt is context synchronizing, check if TCG TLB
* needs a delayed flush on ppc64
*/
check_tlb_flush(env);
}
| true | qemu | 6d49d6d4edb8106f1a83375d91fa518c631ba00f | static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
{
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
target_ulong msr, new_msr, vector;
int srr0, srr1, asrr0, asrr1;
int lpes0, lpes1, lev, ail;
if (0) {
lpes0 = (env->spr[SPR_LPCR] >> 1) & 1;
lpes1 = (env->spr[SPR_LPCR] >> 2) & 1;
} else {
lpes0 = 0;
lpes1 = 1;
}
qemu_log_mask(CPU_LOG_INT, "Raise exception at " TARGET_FMT_lx
" => %08x (%02x)\n", env->nip, excp, env->error_code);
if (excp_model == POWERPC_EXCP_BOOKE) {
msr = env->msr;
} else {
msr = env->msr & ~0x783f0000ULL;
}
new_msr = env->msr & ((target_ulong)1 << MSR_ME);
srr0 = SPR_SRR0;
srr1 = SPR_SRR1;
asrr0 = -1;
asrr1 = -1;
#if defined(TARGET_PPC64)
if (excp_model == POWERPC_EXCP_POWER7 ||
excp_model == POWERPC_EXCP_POWER8) {
if (excp_model == POWERPC_EXCP_POWER8) {
ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
} else {
ail = 0;
}
} else
#endif
{
ail = 0;
}
switch (excp) {
case POWERPC_EXCP_NONE:
return;
case POWERPC_EXCP_CRITICAL:
switch (excp_model) {
case POWERPC_EXCP_40x:
srr0 = SPR_40x_SRR2;
srr1 = SPR_40x_SRR3;
break;
case POWERPC_EXCP_BOOKE:
srr0 = SPR_BOOKE_CSRR0;
srr1 = SPR_BOOKE_CSRR1;
break;
case POWERPC_EXCP_G2:
break;
default:
goto excp_invalid;
}
goto store_next;
case POWERPC_EXCP_MCHECK:
if (msr_me == 0) {
fprintf(stderr, "Machine check while not allowed. "
"Entering checkstop state\n");
if (qemu_log_separate()) {
qemu_log("Machine check while not allowed. "
"Entering checkstop state\n");
}
cs->halted = 1;
cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
}
if (0) {
new_msr |= (target_ulong)MSR_HVB;
}
ail = 0;
new_msr &= ~((target_ulong)1 << MSR_ME);
switch (excp_model) {
case POWERPC_EXCP_40x:
srr0 = SPR_40x_SRR2;
srr1 = SPR_40x_SRR3;
break;
case POWERPC_EXCP_BOOKE:
srr0 = SPR_BOOKE_MCSRR0;
srr1 = SPR_BOOKE_MCSRR1;
asrr0 = SPR_BOOKE_CSRR0;
asrr1 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
goto store_next;
case POWERPC_EXCP_DSI:
LOG_EXCP("DSI exception: DSISR=" TARGET_FMT_lx" DAR=" TARGET_FMT_lx
"\n", env->spr[SPR_DSISR], env->spr[SPR_DAR]);
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_ISI:
LOG_EXCP("ISI exception: msr=" TARGET_FMT_lx ", nip=" TARGET_FMT_lx
"\n", msr, env->nip);
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= env->error_code;
goto store_next;
case POWERPC_EXCP_EXTERNAL:
cs = CPU(cpu);
if (lpes0 == 1) {
new_msr |= (target_ulong)MSR_HVB;
}
if (env->mpic_proxy) {
env->spr[SPR_BOOKE_EPR] = ldl_phys(cs->as, env->mpic_iack);
}
goto store_next;
case POWERPC_EXCP_ALIGN:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
env->spr[SPR_DSISR] |= (cpu_ldl_code(env, (env->nip - 4))
& 0x03FF0000) >> 16;
goto store_next;
case POWERPC_EXCP_PROGRAM:
switch (env->error_code & ~0xF) {
case POWERPC_EXCP_FP:
if ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {
LOG_EXCP("Ignore floating point exception\n");
cs->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
return;
}
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00100000;
if (msr_fe0 == msr_fe1) {
goto store_next;
}
msr |= 0x00010000;
break;
case POWERPC_EXCP_INVAL:
LOG_EXCP("Invalid instruction at " TARGET_FMT_lx "\n", env->nip);
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00080000;
env->spr[SPR_BOOKE_ESR] = ESR_PIL;
break;
case POWERPC_EXCP_PRIV:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00040000;
env->spr[SPR_BOOKE_ESR] = ESR_PPR;
break;
case POWERPC_EXCP_TRAP:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00020000;
env->spr[SPR_BOOKE_ESR] = ESR_PTR;
break;
default:
cpu_abort(cs, "Invalid program exception %d. Aborting\n",
env->error_code);
break;
}
goto store_current;
case POWERPC_EXCP_FPU:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_SYSCALL:
dump_syscall(env);
lev = env->error_code;
if ((lev == 1) && cpu_ppc_hypercall) {
cpu_ppc_hypercall(cpu);
return;
}
if (lev == 1 || (lpes0 == 0 && lpes1 == 0)) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_APU:
goto store_current;
case POWERPC_EXCP_DECR:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_FIT:
LOG_EXCP("FIT exception\n");
goto store_next;
case POWERPC_EXCP_WDT:
LOG_EXCP("WDT exception\n");
switch (excp_model) {
case POWERPC_EXCP_BOOKE:
srr0 = SPR_BOOKE_CSRR0;
srr1 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
goto store_next;
case POWERPC_EXCP_DTLB:
goto store_next;
case POWERPC_EXCP_ITLB:
goto store_next;
case POWERPC_EXCP_DEBUG:
switch (excp_model) {
case POWERPC_EXCP_BOOKE:
srr0 = SPR_BOOKE_DSRR0;
srr1 = SPR_BOOKE_DSRR1;
asrr0 = SPR_BOOKE_CSRR0;
asrr1 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
cpu_abort(cs, "Debug exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SPEU:
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_current;
case POWERPC_EXCP_EFPDI:
cpu_abort(cs, "Embedded floating point data exception "
"is not implemented yet !\n");
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_next;
case POWERPC_EXCP_EFPRI:
cpu_abort(cs, "Embedded floating point round exception "
"is not implemented yet !\n");
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_next;
case POWERPC_EXCP_EPERFM:
cpu_abort(cs,
"Performance counter exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_DOORI:
goto store_next;
case POWERPC_EXCP_DOORCI:
srr0 = SPR_BOOKE_CSRR0;
srr1 = SPR_BOOKE_CSRR1;
goto store_next;
case POWERPC_EXCP_RESET:
if (msr_pow) {
msr |= 0x10000;
} else {
new_msr &= ~((target_ulong)1 << MSR_ME);
}
if (0) {
new_msr |= (target_ulong)MSR_HVB;
}
ail = 0;
goto store_next;
case POWERPC_EXCP_DSEG:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_ISEG:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_HDECR:
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_TRACE:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_HDSI:
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HISI:
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HDSEG:
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HISEG:
srr0 = SPR_HSRR0;
srr1 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_VPU:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_VSXU:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_FU:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_PIT:
LOG_EXCP("PIT exception\n");
goto store_next;
case POWERPC_EXCP_IO:
cpu_abort(cs, "601 IO error exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_RUNM:
cpu_abort(cs, "601 run mode exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_EMUL:
cpu_abort(cs, "602 emulation trap exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_IFTLB:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
switch (excp_model) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
goto tlb_miss_tgpr;
case POWERPC_EXCP_7x5:
goto tlb_miss;
case POWERPC_EXCP_74xx:
goto tlb_miss_74xx;
default:
cpu_abort(cs, "Invalid instruction TLB miss exception\n");
break;
}
break;
case POWERPC_EXCP_DLTLB:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
switch (excp_model) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
goto tlb_miss_tgpr;
case POWERPC_EXCP_7x5:
goto tlb_miss;
case POWERPC_EXCP_74xx:
goto tlb_miss_74xx;
default:
cpu_abort(cs, "Invalid data load TLB miss exception\n");
break;
}
break;
case POWERPC_EXCP_DSTLB:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
switch (excp_model) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
tlb_miss_tgpr:
if (!(new_msr & ((target_ulong)1 << MSR_TGPR))) {
new_msr |= (target_ulong)1 << MSR_TGPR;
hreg_swap_gpr_tgpr(env);
}
goto tlb_miss;
case POWERPC_EXCP_7x5:
tlb_miss:
#if defined(DEBUG_SOFTWARE_TLB)
if (qemu_log_enabled()) {
const char *es;
target_ulong *miss, *cmp;
int en;
if (excp == POWERPC_EXCP_IFTLB) {
es = "I";
en = 'I';
miss = &env->spr[SPR_IMISS];
cmp = &env->spr[SPR_ICMP];
} else {
if (excp == POWERPC_EXCP_DLTLB) {
es = "DL";
} else {
es = "DS";
}
en = 'D';
miss = &env->spr[SPR_DMISS];
cmp = &env->spr[SPR_DCMP];
}
qemu_log("6xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
TARGET_FMT_lx " H1 " TARGET_FMT_lx " H2 "
TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
env->spr[SPR_HASH1], env->spr[SPR_HASH2],
env->error_code);
}
#endif
msr |= env->crf[0] << 28;
msr |= env->error_code;
msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
break;
case POWERPC_EXCP_74xx:
tlb_miss_74xx:
#if defined(DEBUG_SOFTWARE_TLB)
if (qemu_log_enabled()) {
const char *es;
target_ulong *miss, *cmp;
int en;
if (excp == POWERPC_EXCP_IFTLB) {
es = "I";
en = 'I';
miss = &env->spr[SPR_TLBMISS];
cmp = &env->spr[SPR_PTEHI];
} else {
if (excp == POWERPC_EXCP_DLTLB) {
es = "DL";
} else {
es = "DS";
}
en = 'D';
miss = &env->spr[SPR_TLBMISS];
cmp = &env->spr[SPR_PTEHI];
}
qemu_log("74xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
env->error_code);
}
#endif
msr |= env->error_code;
break;
default:
cpu_abort(cs, "Invalid data store TLB miss exception\n");
break;
}
goto store_next;
case POWERPC_EXCP_FPA:
cpu_abort(cs, "Floating point assist exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_DABR:
cpu_abort(cs, "DABR exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_IABR:
cpu_abort(cs, "IABR exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SMI:
cpu_abort(cs, "SMI exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_THERM:
cpu_abort(cs, "Thermal management exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_PERFM:
if (lpes1 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
cpu_abort(cs,
"Performance counter exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_VPUA:
cpu_abort(cs, "VPU assist exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SOFTP:
cpu_abort(cs,
"970 soft-patch exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_MAINT:
cpu_abort(cs,
"970 maintenance exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_MEXTBR:
cpu_abort(cs, "Maskable external exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_NMEXTBR:
cpu_abort(cs, "Non maskable external exception "
"is not implemented yet !\n");
goto store_next;
default:
excp_invalid:
cpu_abort(cs, "Invalid PowerPC exception %d. Aborting\n", excp);
break;
store_current:
env->spr[srr0] = env->nip - 4;
break;
store_next:
env->spr[srr0] = env->nip;
break;
}
env->spr[srr1] = msr;
if (asrr0 != -1) {
env->spr[asrr0] = env->spr[srr0];
}
if (asrr1 != -1) {
env->spr[asrr1] = env->spr[srr1];
}
if (env->spr[SPR_LPCR] & LPCR_AIL) {
new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
}
#ifdef TARGET_PPC64
if (excp_model == POWERPC_EXCP_POWER7 ||
excp_model == POWERPC_EXCP_POWER8) {
if (env->spr[SPR_LPCR] & LPCR_ILE) {
new_msr |= (target_ulong)1 << MSR_LE;
}
} else if (msr_ile) {
new_msr |= (target_ulong)1 << MSR_LE;
}
#else
if (msr_ile) {
new_msr |= (target_ulong)1 << MSR_LE;
}
#endif
vector = env->excp_vectors[excp];
if (vector == (target_ulong)-1ULL) {
cpu_abort(cs, "Raised an exception without defined vector %d\n",
excp);
}
vector |= env->excp_prefix;
if (!((msr >> MSR_IR) & 1) || !((msr >> MSR_DR) & 1)) {
ail = 0;
}
if (ail) {
new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
switch(ail) {
case AIL_0001_8000:
vector |= 0x18000;
break;
case AIL_C000_0000_0000_4000:
vector |= 0xc000000000004000ull;
break;
default:
cpu_abort(cs, "Invalid AIL combination %d\n", ail);
break;
}
}
#if defined(TARGET_PPC64)
if (excp_model == POWERPC_EXCP_BOOKE) {
if (env->spr[SPR_BOOKE_EPCR] & EPCR_ICM) {
new_msr |= (target_ulong)1 << MSR_CM;
} else {
vector = (uint32_t)vector;
}
} else {
if (!msr_isf && !(env->mmu_model & POWERPC_MMU_64)) {
vector = (uint32_t)vector;
} else {
new_msr |= (target_ulong)1 << MSR_SF;
}
}
#endif
env->msr = new_msr & env->msr_mask;
hreg_compute_hflags(env);
env->nip = vector;
cs->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
check_tlb_flush(env);
}
| {
"code": [
" int srr0, srr1, asrr0, asrr1;",
" int lpes0, lpes1, lev, ail;",
" if (0) {",
" lpes0 = (env->spr[SPR_LPCR] >> 1) & 1;",
" lpes1 = (env->spr[SPR_LPCR] >> 2) & 1;",
" } else {",
" lpes0 = 0;",
" lpes1 = 1;",
" new_msr = env->msr & ((target_ulong)1 << MSR_ME);",
" if (0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes0 == 1) {",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lev == 1 || (lpes0 == 0 && lpes1 == 0)) {",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" new_msr |= (target_ulong)MSR_HVB;",
" new_msr |= (target_ulong)MSR_HVB;",
" new_msr |= (target_ulong)MSR_HVB;",
" if (lpes1 == 0) {",
" new_msr |= (target_ulong)MSR_HVB;",
" if (env->spr[SPR_LPCR] & LPCR_AIL) {",
" new_msr |= (1 << MSR_IR) | (1 << MSR_DR);",
" if (excp_model == POWERPC_EXCP_POWER7 ||",
" excp_model == POWERPC_EXCP_POWER8) {",
" if (env->spr[SPR_LPCR] & LPCR_ILE) {",
" if (!((msr >> MSR_IR) & 1) || !((msr >> MSR_DR) & 1)) {"
],
"line_no": [
11,
13,
17,
21,
23,
25,
29,
31,
59,
181,
185,
239,
185,
239,
185,
269,
239,
185,
321,
323,
321,
323,
321,
323,
321,
323,
239,
185,
421,
239,
185,
181,
185,
239,
185,
239,
185,
239,
185,
239,
185,
239,
185,
239,
185,
185,
185,
185,
239,
185,
1145,
1147,
87,
89,
1159,
1205
]
} | static inline void FUNC_0(PowerPCCPU *VAR_0, int VAR_1, int VAR_2)
{
CPUState *cs = CPU(VAR_0);
CPUPPCState *env = &VAR_0->env;
target_ulong msr, new_msr, vector;
int VAR_3, VAR_4, VAR_5, VAR_6;
int VAR_7, VAR_8, VAR_9, VAR_10;
if (0) {
VAR_7 = (env->spr[SPR_LPCR] >> 1) & 1;
VAR_8 = (env->spr[SPR_LPCR] >> 2) & 1;
} else {
VAR_7 = 0;
VAR_8 = 1;
}
qemu_log_mask(CPU_LOG_INT, "Raise exception at " TARGET_FMT_lx
" => %08x (%02x)\n", env->nip, VAR_2, env->error_code);
if (VAR_1 == POWERPC_EXCP_BOOKE) {
msr = env->msr;
} else {
msr = env->msr & ~0x783f0000ULL;
}
new_msr = env->msr & ((target_ulong)1 << MSR_ME);
VAR_3 = SPR_SRR0;
VAR_4 = SPR_SRR1;
VAR_5 = -1;
VAR_6 = -1;
#if defined(TARGET_PPC64)
if (VAR_1 == POWERPC_EXCP_POWER7 ||
VAR_1 == POWERPC_EXCP_POWER8) {
if (VAR_1 == POWERPC_EXCP_POWER8) {
VAR_10 = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
} else {
VAR_10 = 0;
}
} else
#endif
{
VAR_10 = 0;
}
switch (VAR_2) {
case POWERPC_EXCP_NONE:
return;
case POWERPC_EXCP_CRITICAL:
switch (VAR_1) {
case POWERPC_EXCP_40x:
VAR_3 = SPR_40x_SRR2;
VAR_4 = SPR_40x_SRR3;
break;
case POWERPC_EXCP_BOOKE:
VAR_3 = SPR_BOOKE_CSRR0;
VAR_4 = SPR_BOOKE_CSRR1;
break;
case POWERPC_EXCP_G2:
break;
default:
goto excp_invalid;
}
goto store_next;
case POWERPC_EXCP_MCHECK:
if (msr_me == 0) {
fprintf(stderr, "Machine check while not allowed. "
"Entering checkstop state\n");
if (qemu_log_separate()) {
qemu_log("Machine check while not allowed. "
"Entering checkstop state\n");
}
cs->halted = 1;
cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
}
if (0) {
new_msr |= (target_ulong)MSR_HVB;
}
VAR_10 = 0;
new_msr &= ~((target_ulong)1 << MSR_ME);
switch (VAR_1) {
case POWERPC_EXCP_40x:
VAR_3 = SPR_40x_SRR2;
VAR_4 = SPR_40x_SRR3;
break;
case POWERPC_EXCP_BOOKE:
VAR_3 = SPR_BOOKE_MCSRR0;
VAR_4 = SPR_BOOKE_MCSRR1;
VAR_5 = SPR_BOOKE_CSRR0;
VAR_6 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
goto store_next;
case POWERPC_EXCP_DSI:
LOG_EXCP("DSI exception: DSISR=" TARGET_FMT_lx" DAR=" TARGET_FMT_lx
"\n", env->spr[SPR_DSISR], env->spr[SPR_DAR]);
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_ISI:
LOG_EXCP("ISI exception: msr=" TARGET_FMT_lx ", nip=" TARGET_FMT_lx
"\n", msr, env->nip);
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= env->error_code;
goto store_next;
case POWERPC_EXCP_EXTERNAL:
cs = CPU(VAR_0);
if (VAR_7 == 1) {
new_msr |= (target_ulong)MSR_HVB;
}
if (env->mpic_proxy) {
env->spr[SPR_BOOKE_EPR] = ldl_phys(cs->as, env->mpic_iack);
}
goto store_next;
case POWERPC_EXCP_ALIGN:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
env->spr[SPR_DSISR] |= (cpu_ldl_code(env, (env->nip - 4))
& 0x03FF0000) >> 16;
goto store_next;
case POWERPC_EXCP_PROGRAM:
switch (env->error_code & ~0xF) {
case POWERPC_EXCP_FP:
if ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {
LOG_EXCP("Ignore floating point exception\n");
cs->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
return;
}
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00100000;
if (msr_fe0 == msr_fe1) {
goto store_next;
}
msr |= 0x00010000;
break;
case POWERPC_EXCP_INVAL:
LOG_EXCP("Invalid instruction at " TARGET_FMT_lx "\n", env->nip);
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00080000;
env->spr[SPR_BOOKE_ESR] = ESR_PIL;
break;
case POWERPC_EXCP_PRIV:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00040000;
env->spr[SPR_BOOKE_ESR] = ESR_PPR;
break;
case POWERPC_EXCP_TRAP:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
msr |= 0x00020000;
env->spr[SPR_BOOKE_ESR] = ESR_PTR;
break;
default:
cpu_abort(cs, "Invalid program exception %d. Aborting\n",
env->error_code);
break;
}
goto store_current;
case POWERPC_EXCP_FPU:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_SYSCALL:
dump_syscall(env);
VAR_9 = env->error_code;
if ((VAR_9 == 1) && cpu_ppc_hypercall) {
cpu_ppc_hypercall(VAR_0);
return;
}
if (VAR_9 == 1 || (VAR_7 == 0 && VAR_8 == 0)) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_APU:
goto store_current;
case POWERPC_EXCP_DECR:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_FIT:
LOG_EXCP("FIT exception\n");
goto store_next;
case POWERPC_EXCP_WDT:
LOG_EXCP("WDT exception\n");
switch (VAR_1) {
case POWERPC_EXCP_BOOKE:
VAR_3 = SPR_BOOKE_CSRR0;
VAR_4 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
goto store_next;
case POWERPC_EXCP_DTLB:
goto store_next;
case POWERPC_EXCP_ITLB:
goto store_next;
case POWERPC_EXCP_DEBUG:
switch (VAR_1) {
case POWERPC_EXCP_BOOKE:
VAR_3 = SPR_BOOKE_DSRR0;
VAR_4 = SPR_BOOKE_DSRR1;
VAR_5 = SPR_BOOKE_CSRR0;
VAR_6 = SPR_BOOKE_CSRR1;
break;
default:
break;
}
cpu_abort(cs, "Debug exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SPEU:
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_current;
case POWERPC_EXCP_EFPDI:
cpu_abort(cs, "Embedded floating point data exception "
"is not implemented yet !\n");
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_next;
case POWERPC_EXCP_EFPRI:
cpu_abort(cs, "Embedded floating point round exception "
"is not implemented yet !\n");
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
goto store_next;
case POWERPC_EXCP_EPERFM:
cpu_abort(cs,
"Performance counter exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_DOORI:
goto store_next;
case POWERPC_EXCP_DOORCI:
VAR_3 = SPR_BOOKE_CSRR0;
VAR_4 = SPR_BOOKE_CSRR1;
goto store_next;
case POWERPC_EXCP_RESET:
if (msr_pow) {
msr |= 0x10000;
} else {
new_msr &= ~((target_ulong)1 << MSR_ME);
}
if (0) {
new_msr |= (target_ulong)MSR_HVB;
}
VAR_10 = 0;
goto store_next;
case POWERPC_EXCP_DSEG:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_ISEG:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_HDECR:
VAR_3 = SPR_HSRR0;
VAR_4 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_TRACE:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_next;
case POWERPC_EXCP_HDSI:
VAR_3 = SPR_HSRR0;
VAR_4 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HISI:
VAR_3 = SPR_HSRR0;
VAR_4 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HDSEG:
VAR_3 = SPR_HSRR0;
VAR_4 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_HISEG:
VAR_3 = SPR_HSRR0;
VAR_4 = SPR_HSRR1;
new_msr |= (target_ulong)MSR_HVB;
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
goto store_next;
case POWERPC_EXCP_VPU:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_VSXU:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_FU:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
goto store_current;
case POWERPC_EXCP_PIT:
LOG_EXCP("PIT exception\n");
goto store_next;
case POWERPC_EXCP_IO:
cpu_abort(cs, "601 IO error exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_RUNM:
cpu_abort(cs, "601 run mode exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_EMUL:
cpu_abort(cs, "602 emulation trap exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_IFTLB:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
switch (VAR_1) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
goto tlb_miss_tgpr;
case POWERPC_EXCP_7x5:
goto tlb_miss;
case POWERPC_EXCP_74xx:
goto tlb_miss_74xx;
default:
cpu_abort(cs, "Invalid instruction TLB miss exception\n");
break;
}
break;
case POWERPC_EXCP_DLTLB:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
switch (VAR_1) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
goto tlb_miss_tgpr;
case POWERPC_EXCP_7x5:
goto tlb_miss;
case POWERPC_EXCP_74xx:
goto tlb_miss_74xx;
default:
cpu_abort(cs, "Invalid data load TLB miss exception\n");
break;
}
break;
case POWERPC_EXCP_DSTLB:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
switch (VAR_1) {
case POWERPC_EXCP_602:
case POWERPC_EXCP_603:
case POWERPC_EXCP_603E:
case POWERPC_EXCP_G2:
tlb_miss_tgpr:
if (!(new_msr & ((target_ulong)1 << MSR_TGPR))) {
new_msr |= (target_ulong)1 << MSR_TGPR;
hreg_swap_gpr_tgpr(env);
}
goto tlb_miss;
case POWERPC_EXCP_7x5:
tlb_miss:
#if defined(DEBUG_SOFTWARE_TLB)
if (qemu_log_enabled()) {
const char *es;
target_ulong *miss, *cmp;
int en;
if (VAR_2 == POWERPC_EXCP_IFTLB) {
es = "I";
en = 'I';
miss = &env->spr[SPR_IMISS];
cmp = &env->spr[SPR_ICMP];
} else {
if (VAR_2 == POWERPC_EXCP_DLTLB) {
es = "DL";
} else {
es = "DS";
}
en = 'D';
miss = &env->spr[SPR_DMISS];
cmp = &env->spr[SPR_DCMP];
}
qemu_log("6xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
TARGET_FMT_lx " H1 " TARGET_FMT_lx " H2 "
TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
env->spr[SPR_HASH1], env->spr[SPR_HASH2],
env->error_code);
}
#endif
msr |= env->crf[0] << 28;
msr |= env->error_code;
msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
break;
case POWERPC_EXCP_74xx:
tlb_miss_74xx:
#if defined(DEBUG_SOFTWARE_TLB)
if (qemu_log_enabled()) {
const char *es;
target_ulong *miss, *cmp;
int en;
if (VAR_2 == POWERPC_EXCP_IFTLB) {
es = "I";
en = 'I';
miss = &env->spr[SPR_TLBMISS];
cmp = &env->spr[SPR_PTEHI];
} else {
if (VAR_2 == POWERPC_EXCP_DLTLB) {
es = "DL";
} else {
es = "DS";
}
en = 'D';
miss = &env->spr[SPR_TLBMISS];
cmp = &env->spr[SPR_PTEHI];
}
qemu_log("74xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
env->error_code);
}
#endif
msr |= env->error_code;
break;
default:
cpu_abort(cs, "Invalid data store TLB miss exception\n");
break;
}
goto store_next;
case POWERPC_EXCP_FPA:
cpu_abort(cs, "Floating point assist exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_DABR:
cpu_abort(cs, "DABR exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_IABR:
cpu_abort(cs, "IABR exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SMI:
cpu_abort(cs, "SMI exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_THERM:
cpu_abort(cs, "Thermal management exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_PERFM:
if (VAR_8 == 0) {
new_msr |= (target_ulong)MSR_HVB;
}
cpu_abort(cs,
"Performance counter exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_VPUA:
cpu_abort(cs, "VPU assist exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_SOFTP:
cpu_abort(cs,
"970 soft-patch exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_MAINT:
cpu_abort(cs,
"970 maintenance exception is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_MEXTBR:
cpu_abort(cs, "Maskable external exception "
"is not implemented yet !\n");
goto store_next;
case POWERPC_EXCP_NMEXTBR:
cpu_abort(cs, "Non maskable external exception "
"is not implemented yet !\n");
goto store_next;
default:
excp_invalid:
cpu_abort(cs, "Invalid PowerPC exception %d. Aborting\n", VAR_2);
break;
store_current:
env->spr[VAR_3] = env->nip - 4;
break;
store_next:
env->spr[VAR_3] = env->nip;
break;
}
env->spr[VAR_4] = msr;
if (VAR_5 != -1) {
env->spr[VAR_5] = env->spr[VAR_3];
}
if (VAR_6 != -1) {
env->spr[VAR_6] = env->spr[VAR_4];
}
if (env->spr[SPR_LPCR] & LPCR_AIL) {
new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
}
#ifdef TARGET_PPC64
if (VAR_1 == POWERPC_EXCP_POWER7 ||
VAR_1 == POWERPC_EXCP_POWER8) {
if (env->spr[SPR_LPCR] & LPCR_ILE) {
new_msr |= (target_ulong)1 << MSR_LE;
}
} else if (msr_ile) {
new_msr |= (target_ulong)1 << MSR_LE;
}
#else
if (msr_ile) {
new_msr |= (target_ulong)1 << MSR_LE;
}
#endif
vector = env->excp_vectors[VAR_2];
if (vector == (target_ulong)-1ULL) {
cpu_abort(cs, "Raised an exception without defined vector %d\n",
VAR_2);
}
vector |= env->excp_prefix;
if (!((msr >> MSR_IR) & 1) || !((msr >> MSR_DR) & 1)) {
VAR_10 = 0;
}
if (VAR_10) {
new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
switch(VAR_10) {
case AIL_0001_8000:
vector |= 0x18000;
break;
case AIL_C000_0000_0000_4000:
vector |= 0xc000000000004000ull;
break;
default:
cpu_abort(cs, "Invalid AIL combination %d\n", VAR_10);
break;
}
}
#if defined(TARGET_PPC64)
if (VAR_1 == POWERPC_EXCP_BOOKE) {
if (env->spr[SPR_BOOKE_EPCR] & EPCR_ICM) {
new_msr |= (target_ulong)1 << MSR_CM;
} else {
vector = (uint32_t)vector;
}
} else {
if (!msr_isf && !(env->mmu_model & POWERPC_MMU_64)) {
vector = (uint32_t)vector;
} else {
new_msr |= (target_ulong)1 << MSR_SF;
}
}
#endif
env->msr = new_msr & env->msr_mask;
hreg_compute_hflags(env);
env->nip = vector;
cs->exception_index = POWERPC_EXCP_NONE;
env->error_code = 0;
check_tlb_flush(env);
}
| [
"static inline void FUNC_0(PowerPCCPU *VAR_0, int VAR_1, int VAR_2)\n{",
"CPUState *cs = CPU(VAR_0);",
"CPUPPCState *env = &VAR_0->env;",
"target_ulong msr, new_msr, vector;",
"int VAR_3, VAR_4, VAR_5, VAR_6;",
"int VAR_7, VAR_8, VAR_9, VAR_10;",
"if (0) {",
"VAR_7 = (env->spr[SPR_LPCR] >> 1) & 1;",
"VAR_8 = (env->spr[SPR_LPCR] >> 2) & 1;",
"} else {",
"VAR_7 = 0;",
"VAR_8 = 1;",
"}",
"qemu_log_mask(CPU_LOG_INT, \"Raise exception at \" TARGET_FMT_lx\n\" => %08x (%02x)\\n\", env->nip, VAR_2, env->error_code);",
"if (VAR_1 == POWERPC_EXCP_BOOKE) {",
"msr = env->msr;",
"} else {",
"msr = env->msr & ~0x783f0000ULL;",
"}",
"new_msr = env->msr & ((target_ulong)1 << MSR_ME);",
"VAR_3 = SPR_SRR0;",
"VAR_4 = SPR_SRR1;",
"VAR_5 = -1;",
"VAR_6 = -1;",
"#if defined(TARGET_PPC64)\nif (VAR_1 == POWERPC_EXCP_POWER7 ||\nVAR_1 == POWERPC_EXCP_POWER8) {",
"if (VAR_1 == POWERPC_EXCP_POWER8) {",
"VAR_10 = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;",
"} else {",
"VAR_10 = 0;",
"}",
"} else",
"#endif\n{",
"VAR_10 = 0;",
"}",
"switch (VAR_2) {",
"case POWERPC_EXCP_NONE:\nreturn;",
"case POWERPC_EXCP_CRITICAL:\nswitch (VAR_1) {",
"case POWERPC_EXCP_40x:\nVAR_3 = SPR_40x_SRR2;",
"VAR_4 = SPR_40x_SRR3;",
"break;",
"case POWERPC_EXCP_BOOKE:\nVAR_3 = SPR_BOOKE_CSRR0;",
"VAR_4 = SPR_BOOKE_CSRR1;",
"break;",
"case POWERPC_EXCP_G2:\nbreak;",
"default:\ngoto excp_invalid;",
"}",
"goto store_next;",
"case POWERPC_EXCP_MCHECK:\nif (msr_me == 0) {",
"fprintf(stderr, \"Machine check while not allowed. \"\n\"Entering checkstop state\\n\");",
"if (qemu_log_separate()) {",
"qemu_log(\"Machine check while not allowed. \"\n\"Entering checkstop state\\n\");",
"}",
"cs->halted = 1;",
"cs->interrupt_request |= CPU_INTERRUPT_EXITTB;",
"}",
"if (0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"VAR_10 = 0;",
"new_msr &= ~((target_ulong)1 << MSR_ME);",
"switch (VAR_1) {",
"case POWERPC_EXCP_40x:\nVAR_3 = SPR_40x_SRR2;",
"VAR_4 = SPR_40x_SRR3;",
"break;",
"case POWERPC_EXCP_BOOKE:\nVAR_3 = SPR_BOOKE_MCSRR0;",
"VAR_4 = SPR_BOOKE_MCSRR1;",
"VAR_5 = SPR_BOOKE_CSRR0;",
"VAR_6 = SPR_BOOKE_CSRR1;",
"break;",
"default:\nbreak;",
"}",
"goto store_next;",
"case POWERPC_EXCP_DSI:\nLOG_EXCP(\"DSI exception: DSISR=\" TARGET_FMT_lx\" DAR=\" TARGET_FMT_lx\n\"\\n\", env->spr[SPR_DSISR], env->spr[SPR_DAR]);",
"if (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_next;",
"case POWERPC_EXCP_ISI:\nLOG_EXCP(\"ISI exception: msr=\" TARGET_FMT_lx \", nip=\" TARGET_FMT_lx\n\"\\n\", msr, env->nip);",
"if (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"msr |= env->error_code;",
"goto store_next;",
"case POWERPC_EXCP_EXTERNAL:\ncs = CPU(VAR_0);",
"if (VAR_7 == 1) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"if (env->mpic_proxy) {",
"env->spr[SPR_BOOKE_EPR] = ldl_phys(cs->as, env->mpic_iack);",
"}",
"goto store_next;",
"case POWERPC_EXCP_ALIGN:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"env->spr[SPR_DSISR] |= (cpu_ldl_code(env, (env->nip - 4))\n& 0x03FF0000) >> 16;",
"goto store_next;",
"case POWERPC_EXCP_PROGRAM:\nswitch (env->error_code & ~0xF) {",
"case POWERPC_EXCP_FP:\nif ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {",
"LOG_EXCP(\"Ignore floating point exception\\n\");",
"cs->exception_index = POWERPC_EXCP_NONE;",
"env->error_code = 0;",
"return;",
"}",
"if (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"msr |= 0x00100000;",
"if (msr_fe0 == msr_fe1) {",
"goto store_next;",
"}",
"msr |= 0x00010000;",
"break;",
"case POWERPC_EXCP_INVAL:\nLOG_EXCP(\"Invalid instruction at \" TARGET_FMT_lx \"\\n\", env->nip);",
"if (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"msr |= 0x00080000;",
"env->spr[SPR_BOOKE_ESR] = ESR_PIL;",
"break;",
"case POWERPC_EXCP_PRIV:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"msr |= 0x00040000;",
"env->spr[SPR_BOOKE_ESR] = ESR_PPR;",
"break;",
"case POWERPC_EXCP_TRAP:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"msr |= 0x00020000;",
"env->spr[SPR_BOOKE_ESR] = ESR_PTR;",
"break;",
"default:\ncpu_abort(cs, \"Invalid program exception %d. Aborting\\n\",\nenv->error_code);",
"break;",
"}",
"goto store_current;",
"case POWERPC_EXCP_FPU:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_current;",
"case POWERPC_EXCP_SYSCALL:\ndump_syscall(env);",
"VAR_9 = env->error_code;",
"if ((VAR_9 == 1) && cpu_ppc_hypercall) {",
"cpu_ppc_hypercall(VAR_0);",
"return;",
"}",
"if (VAR_9 == 1 || (VAR_7 == 0 && VAR_8 == 0)) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_next;",
"case POWERPC_EXCP_APU:\ngoto store_current;",
"case POWERPC_EXCP_DECR:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_next;",
"case POWERPC_EXCP_FIT:\nLOG_EXCP(\"FIT exception\\n\");",
"goto store_next;",
"case POWERPC_EXCP_WDT:\nLOG_EXCP(\"WDT exception\\n\");",
"switch (VAR_1) {",
"case POWERPC_EXCP_BOOKE:\nVAR_3 = SPR_BOOKE_CSRR0;",
"VAR_4 = SPR_BOOKE_CSRR1;",
"break;",
"default:\nbreak;",
"}",
"goto store_next;",
"case POWERPC_EXCP_DTLB:\ngoto store_next;",
"case POWERPC_EXCP_ITLB:\ngoto store_next;",
"case POWERPC_EXCP_DEBUG:\nswitch (VAR_1) {",
"case POWERPC_EXCP_BOOKE:\nVAR_3 = SPR_BOOKE_DSRR0;",
"VAR_4 = SPR_BOOKE_DSRR1;",
"VAR_5 = SPR_BOOKE_CSRR0;",
"VAR_6 = SPR_BOOKE_CSRR1;",
"break;",
"default:\nbreak;",
"}",
"cpu_abort(cs, \"Debug exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_SPEU:\nenv->spr[SPR_BOOKE_ESR] = ESR_SPV;",
"goto store_current;",
"case POWERPC_EXCP_EFPDI:\ncpu_abort(cs, \"Embedded floating point data exception \"\n\"is not implemented yet !\\n\");",
"env->spr[SPR_BOOKE_ESR] = ESR_SPV;",
"goto store_next;",
"case POWERPC_EXCP_EFPRI:\ncpu_abort(cs, \"Embedded floating point round exception \"\n\"is not implemented yet !\\n\");",
"env->spr[SPR_BOOKE_ESR] = ESR_SPV;",
"goto store_next;",
"case POWERPC_EXCP_EPERFM:\ncpu_abort(cs,\n\"Performance counter exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_DOORI:\ngoto store_next;",
"case POWERPC_EXCP_DOORCI:\nVAR_3 = SPR_BOOKE_CSRR0;",
"VAR_4 = SPR_BOOKE_CSRR1;",
"goto store_next;",
"case POWERPC_EXCP_RESET:\nif (msr_pow) {",
"msr |= 0x10000;",
"} else {",
"new_msr &= ~((target_ulong)1 << MSR_ME);",
"}",
"if (0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"VAR_10 = 0;",
"goto store_next;",
"case POWERPC_EXCP_DSEG:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_next;",
"case POWERPC_EXCP_ISEG:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_next;",
"case POWERPC_EXCP_HDECR:\nVAR_3 = SPR_HSRR0;",
"VAR_4 = SPR_HSRR1;",
"new_msr |= (target_ulong)MSR_HVB;",
"new_msr |= env->msr & ((target_ulong)1 << MSR_RI);",
"goto store_next;",
"case POWERPC_EXCP_TRACE:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_next;",
"case POWERPC_EXCP_HDSI:\nVAR_3 = SPR_HSRR0;",
"VAR_4 = SPR_HSRR1;",
"new_msr |= (target_ulong)MSR_HVB;",
"new_msr |= env->msr & ((target_ulong)1 << MSR_RI);",
"goto store_next;",
"case POWERPC_EXCP_HISI:\nVAR_3 = SPR_HSRR0;",
"VAR_4 = SPR_HSRR1;",
"new_msr |= (target_ulong)MSR_HVB;",
"new_msr |= env->msr & ((target_ulong)1 << MSR_RI);",
"goto store_next;",
"case POWERPC_EXCP_HDSEG:\nVAR_3 = SPR_HSRR0;",
"VAR_4 = SPR_HSRR1;",
"new_msr |= (target_ulong)MSR_HVB;",
"new_msr |= env->msr & ((target_ulong)1 << MSR_RI);",
"goto store_next;",
"case POWERPC_EXCP_HISEG:\nVAR_3 = SPR_HSRR0;",
"VAR_4 = SPR_HSRR1;",
"new_msr |= (target_ulong)MSR_HVB;",
"new_msr |= env->msr & ((target_ulong)1 << MSR_RI);",
"goto store_next;",
"case POWERPC_EXCP_VPU:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_current;",
"case POWERPC_EXCP_VSXU:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_current;",
"case POWERPC_EXCP_FU:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"goto store_current;",
"case POWERPC_EXCP_PIT:\nLOG_EXCP(\"PIT exception\\n\");",
"goto store_next;",
"case POWERPC_EXCP_IO:\ncpu_abort(cs, \"601 IO error exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_RUNM:\ncpu_abort(cs, \"601 run mode exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_EMUL:\ncpu_abort(cs, \"602 emulation trap exception \"\n\"is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_IFTLB:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"switch (VAR_1) {",
"case POWERPC_EXCP_602:\ncase POWERPC_EXCP_603:\ncase POWERPC_EXCP_603E:\ncase POWERPC_EXCP_G2:\ngoto tlb_miss_tgpr;",
"case POWERPC_EXCP_7x5:\ngoto tlb_miss;",
"case POWERPC_EXCP_74xx:\ngoto tlb_miss_74xx;",
"default:\ncpu_abort(cs, \"Invalid instruction TLB miss exception\\n\");",
"break;",
"}",
"break;",
"case POWERPC_EXCP_DLTLB:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"switch (VAR_1) {",
"case POWERPC_EXCP_602:\ncase POWERPC_EXCP_603:\ncase POWERPC_EXCP_603E:\ncase POWERPC_EXCP_G2:\ngoto tlb_miss_tgpr;",
"case POWERPC_EXCP_7x5:\ngoto tlb_miss;",
"case POWERPC_EXCP_74xx:\ngoto tlb_miss_74xx;",
"default:\ncpu_abort(cs, \"Invalid data load TLB miss exception\\n\");",
"break;",
"}",
"break;",
"case POWERPC_EXCP_DSTLB:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"switch (VAR_1) {",
"case POWERPC_EXCP_602:\ncase POWERPC_EXCP_603:\ncase POWERPC_EXCP_603E:\ncase POWERPC_EXCP_G2:\ntlb_miss_tgpr:\nif (!(new_msr & ((target_ulong)1 << MSR_TGPR))) {",
"new_msr |= (target_ulong)1 << MSR_TGPR;",
"hreg_swap_gpr_tgpr(env);",
"}",
"goto tlb_miss;",
"case POWERPC_EXCP_7x5:\ntlb_miss:\n#if defined(DEBUG_SOFTWARE_TLB)\nif (qemu_log_enabled()) {",
"const char *es;",
"target_ulong *miss, *cmp;",
"int en;",
"if (VAR_2 == POWERPC_EXCP_IFTLB) {",
"es = \"I\";",
"en = 'I';",
"miss = &env->spr[SPR_IMISS];",
"cmp = &env->spr[SPR_ICMP];",
"} else {",
"if (VAR_2 == POWERPC_EXCP_DLTLB) {",
"es = \"DL\";",
"} else {",
"es = \"DS\";",
"}",
"en = 'D';",
"miss = &env->spr[SPR_DMISS];",
"cmp = &env->spr[SPR_DCMP];",
"}",
"qemu_log(\"6xx %sTLB miss: %cM \" TARGET_FMT_lx \" %cC \"\nTARGET_FMT_lx \" H1 \" TARGET_FMT_lx \" H2 \"\nTARGET_FMT_lx \" %08x\\n\", es, en, *miss, en, *cmp,\nenv->spr[SPR_HASH1], env->spr[SPR_HASH2],\nenv->error_code);",
"}",
"#endif\nmsr |= env->crf[0] << 28;",
"msr |= env->error_code;",
"msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;",
"break;",
"case POWERPC_EXCP_74xx:\ntlb_miss_74xx:\n#if defined(DEBUG_SOFTWARE_TLB)\nif (qemu_log_enabled()) {",
"const char *es;",
"target_ulong *miss, *cmp;",
"int en;",
"if (VAR_2 == POWERPC_EXCP_IFTLB) {",
"es = \"I\";",
"en = 'I';",
"miss = &env->spr[SPR_TLBMISS];",
"cmp = &env->spr[SPR_PTEHI];",
"} else {",
"if (VAR_2 == POWERPC_EXCP_DLTLB) {",
"es = \"DL\";",
"} else {",
"es = \"DS\";",
"}",
"en = 'D';",
"miss = &env->spr[SPR_TLBMISS];",
"cmp = &env->spr[SPR_PTEHI];",
"}",
"qemu_log(\"74xx %sTLB miss: %cM \" TARGET_FMT_lx \" %cC \"\nTARGET_FMT_lx \" %08x\\n\", es, en, *miss, en, *cmp,\nenv->error_code);",
"}",
"#endif\nmsr |= env->error_code;",
"break;",
"default:\ncpu_abort(cs, \"Invalid data store TLB miss exception\\n\");",
"break;",
"}",
"goto store_next;",
"case POWERPC_EXCP_FPA:\ncpu_abort(cs, \"Floating point assist exception \"\n\"is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_DABR:\ncpu_abort(cs, \"DABR exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_IABR:\ncpu_abort(cs, \"IABR exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_SMI:\ncpu_abort(cs, \"SMI exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_THERM:\ncpu_abort(cs, \"Thermal management exception \"\n\"is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_PERFM:\nif (VAR_8 == 0) {",
"new_msr |= (target_ulong)MSR_HVB;",
"}",
"cpu_abort(cs,\n\"Performance counter exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_VPUA:\ncpu_abort(cs, \"VPU assist exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_SOFTP:\ncpu_abort(cs,\n\"970 soft-patch exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_MAINT:\ncpu_abort(cs,\n\"970 maintenance exception is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_MEXTBR:\ncpu_abort(cs, \"Maskable external exception \"\n\"is not implemented yet !\\n\");",
"goto store_next;",
"case POWERPC_EXCP_NMEXTBR:\ncpu_abort(cs, \"Non maskable external exception \"\n\"is not implemented yet !\\n\");",
"goto store_next;",
"default:\nexcp_invalid:\ncpu_abort(cs, \"Invalid PowerPC exception %d. Aborting\\n\", VAR_2);",
"break;",
"store_current:\nenv->spr[VAR_3] = env->nip - 4;",
"break;",
"store_next:\nenv->spr[VAR_3] = env->nip;",
"break;",
"}",
"env->spr[VAR_4] = msr;",
"if (VAR_5 != -1) {",
"env->spr[VAR_5] = env->spr[VAR_3];",
"}",
"if (VAR_6 != -1) {",
"env->spr[VAR_6] = env->spr[VAR_4];",
"}",
"if (env->spr[SPR_LPCR] & LPCR_AIL) {",
"new_msr |= (1 << MSR_IR) | (1 << MSR_DR);",
"}",
"#ifdef TARGET_PPC64\nif (VAR_1 == POWERPC_EXCP_POWER7 ||\nVAR_1 == POWERPC_EXCP_POWER8) {",
"if (env->spr[SPR_LPCR] & LPCR_ILE) {",
"new_msr |= (target_ulong)1 << MSR_LE;",
"}",
"} else if (msr_ile) {",
"new_msr |= (target_ulong)1 << MSR_LE;",
"}",
"#else\nif (msr_ile) {",
"new_msr |= (target_ulong)1 << MSR_LE;",
"}",
"#endif\nvector = env->excp_vectors[VAR_2];",
"if (vector == (target_ulong)-1ULL) {",
"cpu_abort(cs, \"Raised an exception without defined vector %d\\n\",\nVAR_2);",
"}",
"vector |= env->excp_prefix;",
"if (!((msr >> MSR_IR) & 1) || !((msr >> MSR_DR) & 1)) {",
"VAR_10 = 0;",
"}",
"if (VAR_10) {",
"new_msr |= (1 << MSR_IR) | (1 << MSR_DR);",
"switch(VAR_10) {",
"case AIL_0001_8000:\nvector |= 0x18000;",
"break;",
"case AIL_C000_0000_0000_4000:\nvector |= 0xc000000000004000ull;",
"break;",
"default:\ncpu_abort(cs, \"Invalid AIL combination %d\\n\", VAR_10);",
"break;",
"}",
"}",
"#if defined(TARGET_PPC64)\nif (VAR_1 == POWERPC_EXCP_BOOKE) {",
"if (env->spr[SPR_BOOKE_EPCR] & EPCR_ICM) {",
"new_msr |= (target_ulong)1 << MSR_CM;",
"} else {",
"vector = (uint32_t)vector;",
"}",
"} else {",
"if (!msr_isf && !(env->mmu_model & POWERPC_MMU_64)) {",
"vector = (uint32_t)vector;",
"} else {",
"new_msr |= (target_ulong)1 << MSR_SF;",
"}",
"}",
"#endif\nenv->msr = new_msr & env->msr_mask;",
"hreg_compute_hflags(env);",
"env->nip = vector;",
"cs->exception_index = POWERPC_EXCP_NONE;",
"env->error_code = 0;",
"check_tlb_flush(env);",
"}"
] | [
0,
0,
0,
0,
1,
1,
1,
1,
1,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
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,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
37,
39
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
59
],
[
65
],
[
67
],
[
69
],
[
71
],
[
85,
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
113
],
[
115,
119
],
[
121,
123
],
[
125,
127
],
[
129
],
[
131
],
[
133,
135
],
[
137
],
[
139
],
[
141,
143
],
[
145,
147
],
[
149
],
[
151
],
[
153,
155
],
[
163,
165
],
[
167
],
[
169,
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
185
],
[
187
],
[
189
],
[
195
],
[
201
],
[
203,
205
],
[
207
],
[
209
],
[
211,
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225,
227
],
[
229
],
[
231
],
[
233,
235,
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247,
249,
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263,
265
],
[
269
],
[
271
],
[
273
],
[
275
],
[
279
],
[
281
],
[
283
],
[
285,
287
],
[
289
],
[
291
],
[
297,
299
],
[
301
],
[
303,
305
],
[
307,
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339,
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355,
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369,
371
],
[
373
],
[
375
],
[
377
],
[
379
],
[
381
],
[
383,
387,
389
],
[
391
],
[
393
],
[
395
],
[
397,
399
],
[
401
],
[
403
],
[
405
],
[
407,
409
],
[
411
],
[
413
],
[
415
],
[
417
],
[
419
],
[
421
],
[
423
],
[
425
],
[
427
],
[
429,
431
],
[
433,
435
],
[
437
],
[
439
],
[
441
],
[
443,
447
],
[
449
],
[
451,
453
],
[
455
],
[
457,
459
],
[
461
],
[
463
],
[
465,
467
],
[
469
],
[
471
],
[
473,
475
],
[
477,
479
],
[
481,
483
],
[
485,
489
],
[
491
],
[
493
],
[
495
],
[
497
],
[
499,
501
],
[
503
],
[
507
],
[
509
],
[
511,
513
],
[
515
],
[
517,
521,
523
],
[
525
],
[
527
],
[
529,
533,
535
],
[
537
],
[
539
],
[
541,
545,
547
],
[
549
],
[
551,
553
],
[
555,
557
],
[
559
],
[
561
],
[
563,
565
],
[
569
],
[
571
],
[
573
],
[
575
],
[
579
],
[
583
],
[
585
],
[
587
],
[
589
],
[
591,
593
],
[
595
],
[
597
],
[
599
],
[
601,
603
],
[
605
],
[
607
],
[
609
],
[
611,
613
],
[
615
],
[
617
],
[
619
],
[
621
],
[
623,
625
],
[
627
],
[
629
],
[
631
],
[
633,
635
],
[
637
],
[
639
],
[
641
],
[
643
],
[
645,
647
],
[
649
],
[
651
],
[
653
],
[
655
],
[
657,
659
],
[
661
],
[
663
],
[
665
],
[
667
],
[
669,
671
],
[
673
],
[
675
],
[
677
],
[
679
],
[
681,
683
],
[
685
],
[
687
],
[
689
],
[
691,
693
],
[
695
],
[
697
],
[
699
],
[
701,
703
],
[
705
],
[
707
],
[
709
],
[
711,
713
],
[
715
],
[
717,
721
],
[
723
],
[
725,
729
],
[
731
],
[
733,
737,
739
],
[
741
],
[
743,
745
],
[
747
],
[
749
],
[
751
],
[
753,
755,
757,
759,
761
],
[
763,
765
],
[
767,
769
],
[
771,
773
],
[
775
],
[
777
],
[
779
],
[
781,
783
],
[
785
],
[
787
],
[
789
],
[
791,
793,
795,
797,
799
],
[
801,
803
],
[
805,
807
],
[
809,
811
],
[
813
],
[
815
],
[
817
],
[
819,
821
],
[
823
],
[
825
],
[
827
],
[
829,
831,
833,
835,
837,
841
],
[
843
],
[
845
],
[
847
],
[
849
],
[
851,
853,
855,
857
],
[
859
],
[
861
],
[
863
],
[
867
],
[
869
],
[
871
],
[
873
],
[
875
],
[
877
],
[
879
],
[
881
],
[
883
],
[
885
],
[
887
],
[
889
],
[
891
],
[
893
],
[
895
],
[
897,
899,
901,
903,
905
],
[
907
],
[
909,
911
],
[
913
],
[
917
],
[
919
],
[
921,
923,
925,
927
],
[
929
],
[
931
],
[
933
],
[
937
],
[
939
],
[
941
],
[
943
],
[
945
],
[
947
],
[
949
],
[
951
],
[
953
],
[
955
],
[
957
],
[
959
],
[
961
],
[
963
],
[
965
],
[
967,
969,
971
],
[
973
],
[
975,
977
],
[
979
],
[
981,
983
],
[
985
],
[
987
],
[
989
],
[
991,
995,
997
],
[
999
],
[
1001,
1005
],
[
1007
],
[
1009,
1013
],
[
1015
],
[
1017,
1021
],
[
1023
],
[
1025,
1029,
1031
],
[
1033
],
[
1035,
1037
],
[
1039
],
[
1041
],
[
1045,
1047
],
[
1049
],
[
1051,
1055
],
[
1057
],
[
1059,
1063,
1065
],
[
1067
],
[
1069,
1073,
1075
],
[
1077
],
[
1079,
1083,
1085
],
[
1087
],
[
1089,
1093,
1095
],
[
1097
],
[
1099,
1101,
1103
],
[
1105
],
[
1107,
1111
],
[
1113
],
[
1115,
1119
],
[
1121
],
[
1123
],
[
1127
],
[
1131
],
[
1133
],
[
1135
],
[
1137
],
[
1139
],
[
1141
],
[
1145
],
[
1147
],
[
1149
],
[
1153,
1155,
1157
],
[
1159
],
[
1161
],
[
1163
],
[
1165
],
[
1167
],
[
1169
],
[
1171,
1173
],
[
1175
],
[
1177
],
[
1179,
1185
],
[
1187
],
[
1189,
1191
],
[
1193
],
[
1195
],
[
1205
],
[
1207
],
[
1209
],
[
1213
],
[
1215
],
[
1217
],
[
1219,
1221
],
[
1223
],
[
1225,
1227
],
[
1229
],
[
1231,
1233
],
[
1235
],
[
1237
],
[
1239
],
[
1243,
1245
],
[
1247
],
[
1251
],
[
1253
],
[
1255
],
[
1257
],
[
1259
],
[
1261
],
[
1263
],
[
1265
],
[
1267
],
[
1269
],
[
1271
],
[
1273,
1289
],
[
1291
],
[
1293
],
[
1297
],
[
1299
],
[
1309
],
[
1311
]
] |
23,981 | static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
uint64_t off, uint32_t count,
struct iovec *sg, int cnt)
{
int i, to_copy;
ssize_t err = 0;
int write_count;
int64_t xattr_len;
size_t offset = 7;
xattr_len = fidp->fs.xattr.len;
write_count = xattr_len - off;
if (write_count > count) {
write_count = count;
} else if (write_count < 0) {
/*
* write beyond XATTR value len specified in
* xattrcreate
*/
err = -ENOSPC;
goto out;
}
err = pdu_marshal(pdu, offset, "d", write_count);
if (err < 0) {
return err;
}
err += offset;
fidp->fs.xattr.copied_len += write_count;
/*
* Now copy the content from sg list
*/
for (i = 0; i < cnt; i++) {
if (write_count > sg[i].iov_len) {
to_copy = sg[i].iov_len;
} else {
to_copy = write_count;
}
memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
/* updating vs->off since we are not using below */
off += to_copy;
write_count -= to_copy;
}
out:
return err;
}
| true | qemu | 7e55d65c56a03dcd2c5d7c49d37c5a74b55d4bd6 | static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
uint64_t off, uint32_t count,
struct iovec *sg, int cnt)
{
int i, to_copy;
ssize_t err = 0;
int write_count;
int64_t xattr_len;
size_t offset = 7;
xattr_len = fidp->fs.xattr.len;
write_count = xattr_len - off;
if (write_count > count) {
write_count = count;
} else if (write_count < 0) {
err = -ENOSPC;
goto out;
}
err = pdu_marshal(pdu, offset, "d", write_count);
if (err < 0) {
return err;
}
err += offset;
fidp->fs.xattr.copied_len += write_count;
for (i = 0; i < cnt; i++) {
if (write_count > sg[i].iov_len) {
to_copy = sg[i].iov_len;
} else {
to_copy = write_count;
}
memcpy((char *)fidp->fs.xattr.value + off, sg[i].iov_base, to_copy);
off += to_copy;
write_count -= to_copy;
}
out:
return err;
}
| {
"code": [
" int64_t xattr_len;",
" xattr_len = fidp->fs.xattr.len;",
" int write_count;",
" int64_t xattr_len;",
" xattr_len = fidp->fs.xattr.len;",
" write_count = xattr_len - off;",
" if (write_count > count) {",
" write_count = count;",
" } else if (write_count < 0) {"
],
"line_no": [
15,
23,
13,
15,
23,
25,
27,
29,
31
]
} | static int FUNC_0(V9fsState *VAR_0, V9fsPDU *VAR_1, V9fsFidState *VAR_2,
uint64_t VAR_3, uint32_t VAR_4,
struct iovec *VAR_5, int VAR_6)
{
int VAR_7, VAR_8;
ssize_t err = 0;
int VAR_9;
int64_t xattr_len;
size_t offset = 7;
xattr_len = VAR_2->fs.xattr.len;
VAR_9 = xattr_len - VAR_3;
if (VAR_9 > VAR_4) {
VAR_9 = VAR_4;
} else if (VAR_9 < 0) {
err = -ENOSPC;
goto out;
}
err = pdu_marshal(VAR_1, offset, "d", VAR_9);
if (err < 0) {
return err;
}
err += offset;
VAR_2->fs.xattr.copied_len += VAR_9;
for (VAR_7 = 0; VAR_7 < VAR_6; VAR_7++) {
if (VAR_9 > VAR_5[VAR_7].iov_len) {
VAR_8 = VAR_5[VAR_7].iov_len;
} else {
VAR_8 = VAR_9;
}
memcpy((char *)VAR_2->fs.xattr.value + VAR_3, VAR_5[VAR_7].iov_base, VAR_8);
VAR_3 += VAR_8;
VAR_9 -= VAR_8;
}
out:
return err;
}
| [
"static int FUNC_0(V9fsState *VAR_0, V9fsPDU *VAR_1, V9fsFidState *VAR_2,\nuint64_t VAR_3, uint32_t VAR_4,\nstruct iovec *VAR_5, int VAR_6)\n{",
"int VAR_7, VAR_8;",
"ssize_t err = 0;",
"int VAR_9;",
"int64_t xattr_len;",
"size_t offset = 7;",
"xattr_len = VAR_2->fs.xattr.len;",
"VAR_9 = xattr_len - VAR_3;",
"if (VAR_9 > VAR_4) {",
"VAR_9 = VAR_4;",
"} else if (VAR_9 < 0) {",
"err = -ENOSPC;",
"goto out;",
"}",
"err = pdu_marshal(VAR_1, offset, \"d\", VAR_9);",
"if (err < 0) {",
"return err;",
"}",
"err += offset;",
"VAR_2->fs.xattr.copied_len += VAR_9;",
"for (VAR_7 = 0; VAR_7 < VAR_6; VAR_7++) {",
"if (VAR_9 > VAR_5[VAR_7].iov_len) {",
"VAR_8 = VAR_5[VAR_7].iov_len;",
"} else {",
"VAR_8 = VAR_9;",
"}",
"memcpy((char *)VAR_2->fs.xattr.value + VAR_3, VAR_5[VAR_7].iov_base, VAR_8);",
"VAR_3 += VAR_8;",
"VAR_9 -= VAR_8;",
"}",
"out:\nreturn err;",
"}"
] | [
0,
0,
0,
1,
1,
0,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87,
89
],
[
91
]
] |
23,982 | static void test_retry_flush(const char *machine)
{
QPCIDevice *dev;
void *bmdma_base, *ide_base;
uint8_t data;
const char *s;
prepare_blkdebug_script(debug_path, "flush_to_disk");
ide_test_start(
"-vnc none "
"-drive file=blkdebug:%s:%s,if=ide,cache=writeback,format=raw,"
"rerror=stop,werror=stop",
debug_path, tmp_path);
dev = get_pci_device(&bmdma_base, &ide_base);
qtest_irq_intercept_in(global_qtest, "ioapic");
/* Dirty media so that CMD_FLUSH_CACHE will actually go to disk */
make_dirty(0);
/* FLUSH CACHE command on device 0*/
qpci_io_writeb(dev, ide_base + reg_device, 0);
qpci_io_writeb(dev, ide_base + reg_command, CMD_FLUSH_CACHE);
/* Check status while request is in flight*/
data = qpci_io_readb(dev, ide_base + reg_status);
assert_bit_set(data, BSY | DRDY);
assert_bit_clear(data, DF | ERR | DRQ);
qmp_eventwait("STOP");
/* Complete the command */
s = "{'execute':'cont' }";
qmp_discard_response(s);
/* Check registers */
data = qpci_io_readb(dev, ide_base + reg_device);
g_assert_cmpint(data & DEV, ==, 0);
do {
data = qpci_io_readb(dev, ide_base + reg_status);
} while (data & BSY);
assert_bit_set(data, DRDY);
assert_bit_clear(data, BSY | DF | ERR | DRQ);
ide_test_quit();
}
| true | qemu | b4ba67d9a702507793c2724e56f98e9b0f7be02b | static void test_retry_flush(const char *machine)
{
QPCIDevice *dev;
void *bmdma_base, *ide_base;
uint8_t data;
const char *s;
prepare_blkdebug_script(debug_path, "flush_to_disk");
ide_test_start(
"-vnc none "
"-drive file=blkdebug:%s:%s,if=ide,cache=writeback,format=raw,"
"rerror=stop,werror=stop",
debug_path, tmp_path);
dev = get_pci_device(&bmdma_base, &ide_base);
qtest_irq_intercept_in(global_qtest, "ioapic");
make_dirty(0);
qpci_io_writeb(dev, ide_base + reg_device, 0);
qpci_io_writeb(dev, ide_base + reg_command, CMD_FLUSH_CACHE);
data = qpci_io_readb(dev, ide_base + reg_status);
assert_bit_set(data, BSY | DRDY);
assert_bit_clear(data, DF | ERR | DRQ);
qmp_eventwait("STOP");
s = "{'execute':'cont' }";
qmp_discard_response(s);
data = qpci_io_readb(dev, ide_base + reg_device);
g_assert_cmpint(data & DEV, ==, 0);
do {
data = qpci_io_readb(dev, ide_base + reg_status);
} while (data & BSY);
assert_bit_set(data, DRDY);
assert_bit_clear(data, BSY | DF | ERR | DRQ);
ide_test_quit();
}
| {
"code": [
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" qpci_io_writeb(dev, ide_base + reg_device, 0);",
" data = qpci_io_readb(dev, ide_base + reg_device);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" qpci_io_writeb(dev, ide_base + reg_device, 0);",
" qpci_io_writeb(dev, ide_base + reg_command, CMD_FLUSH_CACHE);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" data = qpci_io_readb(dev, ide_base + reg_device);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" qpci_io_writeb(dev, ide_base + reg_device, 0);",
" qpci_io_writeb(dev, ide_base + reg_command, CMD_FLUSH_CACHE);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" data = qpci_io_readb(dev, ide_base + reg_device);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" qpci_io_writeb(dev, ide_base + reg_device, 0);",
" qpci_io_writeb(dev, ide_base + reg_command, CMD_FLUSH_CACHE);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" data = qpci_io_readb(dev, ide_base + reg_status);",
" void *bmdma_base, *ide_base;",
" dev = get_pci_device(&bmdma_base, &ide_base);",
" qpci_io_writeb(dev, ide_base + reg_device, 0);"
],
"line_no": [
31,
7,
31,
7,
31,
7,
31,
7,
31,
7,
31,
7,
31,
47,
77,
85,
55,
7,
31,
7,
31,
47,
49,
55,
77,
85,
7,
31,
47,
49,
55,
77,
85,
7,
31,
47,
49,
7,
31,
85,
7,
31,
47
]
} | static void FUNC_0(const char *VAR_0)
{
QPCIDevice *dev;
void *VAR_1, *VAR_2;
uint8_t data;
const char *VAR_3;
prepare_blkdebug_script(debug_path, "flush_to_disk");
ide_test_start(
"-vnc none "
"-drive file=blkdebug:%VAR_3:%VAR_3,if=ide,cache=writeback,format=raw,"
"rerror=stop,werror=stop",
debug_path, tmp_path);
dev = get_pci_device(&VAR_1, &VAR_2);
qtest_irq_intercept_in(global_qtest, "ioapic");
make_dirty(0);
qpci_io_writeb(dev, VAR_2 + reg_device, 0);
qpci_io_writeb(dev, VAR_2 + reg_command, CMD_FLUSH_CACHE);
data = qpci_io_readb(dev, VAR_2 + reg_status);
assert_bit_set(data, BSY | DRDY);
assert_bit_clear(data, DF | ERR | DRQ);
qmp_eventwait("STOP");
VAR_3 = "{'execute':'cont' }";
qmp_discard_response(VAR_3);
data = qpci_io_readb(dev, VAR_2 + reg_device);
g_assert_cmpint(data & DEV, ==, 0);
do {
data = qpci_io_readb(dev, VAR_2 + reg_status);
} while (data & BSY);
assert_bit_set(data, DRDY);
assert_bit_clear(data, BSY | DF | ERR | DRQ);
ide_test_quit();
}
| [
"static void FUNC_0(const char *VAR_0)\n{",
"QPCIDevice *dev;",
"void *VAR_1, *VAR_2;",
"uint8_t data;",
"const char *VAR_3;",
"prepare_blkdebug_script(debug_path, \"flush_to_disk\");",
"ide_test_start(\n\"-vnc none \"\n\"-drive file=blkdebug:%VAR_3:%VAR_3,if=ide,cache=writeback,format=raw,\"\n\"rerror=stop,werror=stop\",\ndebug_path, tmp_path);",
"dev = get_pci_device(&VAR_1, &VAR_2);",
"qtest_irq_intercept_in(global_qtest, \"ioapic\");",
"make_dirty(0);",
"qpci_io_writeb(dev, VAR_2 + reg_device, 0);",
"qpci_io_writeb(dev, VAR_2 + reg_command, CMD_FLUSH_CACHE);",
"data = qpci_io_readb(dev, VAR_2 + reg_status);",
"assert_bit_set(data, BSY | DRDY);",
"assert_bit_clear(data, DF | ERR | DRQ);",
"qmp_eventwait(\"STOP\");",
"VAR_3 = \"{'execute':'cont' }\";",
"qmp_discard_response(VAR_3);",
"data = qpci_io_readb(dev, VAR_2 + reg_device);",
"g_assert_cmpint(data & DEV, ==, 0);",
"do {",
"data = qpci_io_readb(dev, VAR_2 + reg_status);",
"} while (data & BSY);",
"assert_bit_set(data, DRDY);",
"assert_bit_clear(data, BSY | DF | ERR | DRQ);",
"ide_test_quit();",
"}"
] | [
0,
0,
1,
0,
0,
0,
0,
1,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19,
21,
23,
25,
27
],
[
31
],
[
35
],
[
41
],
[
47
],
[
49
],
[
55
],
[
57
],
[
59
],
[
63
],
[
69
],
[
71
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
97
],
[
99
]
] |
23,983 | static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
{
GetBitContext gb;
HuffContext h[4];
VLC vlc[4];
int16_t *samples = data;
int val;
int i, res;
int unp_size;
int bits, stereo;
int pred[2] = {0, 0};
unp_size = AV_RL32(buf);
init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
if(!get_bits1(&gb)){
av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
*data_size = 0;
return 1;
}
stereo = get_bits1(&gb);
bits = get_bits1(&gb);
if ((unp_size << !bits) > *data_size) {
av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
return -1;
}
memset(vlc, 0, sizeof(VLC) * 4);
memset(h, 0, sizeof(HuffContext) * 4);
// Initialize
for(i = 0; i < (1 << (bits + stereo)); i++) {
h[i].length = 256;
h[i].maxlength = 0;
h[i].current = 0;
h[i].bits = av_mallocz(256 * 4);
h[i].lengths = av_mallocz(256 * sizeof(int));
h[i].values = av_mallocz(256 * sizeof(int));
skip_bits1(&gb);
smacker_decode_tree(&gb, &h[i], 0, 0);
skip_bits1(&gb);
if(h[i].current > 1) {
res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
h[i].lengths, sizeof(int), sizeof(int),
h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
}
}
if(bits) { //decode 16-bit data
for(i = stereo; i >= 0; i--)
pred[i] = bswap_16(get_bits(&gb, 16));
for(i = 0; i < stereo; i++)
*samples++ = pred[i];
for(i = 0; i < unp_size / 2; i++) {
if(i & stereo) {
if(vlc[2].table)
res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[2].values[res];
if(vlc[3].table)
res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[3].values[res] << 8;
pred[1] += (int16_t)val;
*samples++ = pred[1];
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[0].values[res];
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[1].values[res] << 8;
pred[0] += val;
*samples++ = pred[0];
}
}
} else { //8-bit data
for(i = stereo; i >= 0; i--)
pred[i] = get_bits(&gb, 8);
for(i = 0; i < stereo; i++)
*samples++ = (pred[i] - 0x80) << 8;
for(i = 0; i < unp_size; i++) {
if(i & stereo){
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
pred[1] += (int8_t)h[1].values[res];
*samples++ = (pred[1] - 0x80) << 8;
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
pred[0] += (int8_t)h[0].values[res];
*samples++ = (pred[0] - 0x80) << 8;
}
}
unp_size *= 2;
}
for(i = 0; i < 4; i++) {
if(vlc[i].table)
free_vlc(&vlc[i]);
if(h[i].bits)
av_free(h[i].bits);
if(h[i].lengths)
av_free(h[i].lengths);
if(h[i].values)
av_free(h[i].values);
}
*data_size = unp_size;
return buf_size;
}
| true | FFmpeg | f0dd9d4505675daa0f4fda6fcf4274416a23bf24 | static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
{
GetBitContext gb;
HuffContext h[4];
VLC vlc[4];
int16_t *samples = data;
int val;
int i, res;
int unp_size;
int bits, stereo;
int pred[2] = {0, 0};
unp_size = AV_RL32(buf);
init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
if(!get_bits1(&gb)){
av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
*data_size = 0;
return 1;
}
stereo = get_bits1(&gb);
bits = get_bits1(&gb);
if ((unp_size << !bits) > *data_size) {
av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
return -1;
}
memset(vlc, 0, sizeof(VLC) * 4);
memset(h, 0, sizeof(HuffContext) * 4);
for(i = 0; i < (1 << (bits + stereo)); i++) {
h[i].length = 256;
h[i].maxlength = 0;
h[i].current = 0;
h[i].bits = av_mallocz(256 * 4);
h[i].lengths = av_mallocz(256 * sizeof(int));
h[i].values = av_mallocz(256 * sizeof(int));
skip_bits1(&gb);
smacker_decode_tree(&gb, &h[i], 0, 0);
skip_bits1(&gb);
if(h[i].current > 1) {
res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
h[i].lengths, sizeof(int), sizeof(int),
h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
}
}
if(bits) {
for(i = stereo; i >= 0; i--)
pred[i] = bswap_16(get_bits(&gb, 16));
for(i = 0; i < stereo; i++)
*samples++ = pred[i];
for(i = 0; i < unp_size / 2; i++) {
if(i & stereo) {
if(vlc[2].table)
res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[2].values[res];
if(vlc[3].table)
res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[3].values[res] << 8;
pred[1] += (int16_t)val;
*samples++ = pred[1];
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[0].values[res];
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[1].values[res] << 8;
pred[0] += val;
*samples++ = pred[0];
}
}
} else {
for(i = stereo; i >= 0; i--)
pred[i] = get_bits(&gb, 8);
for(i = 0; i < stereo; i++)
*samples++ = (pred[i] - 0x80) << 8;
for(i = 0; i < unp_size; i++) {
if(i & stereo){
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
pred[1] += (int8_t)h[1].values[res];
*samples++ = (pred[1] - 0x80) << 8;
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
pred[0] += (int8_t)h[0].values[res];
*samples++ = (pred[0] - 0x80) << 8;
}
}
unp_size *= 2;
}
for(i = 0; i < 4; i++) {
if(vlc[i].table)
free_vlc(&vlc[i]);
if(h[i].bits)
av_free(h[i].bits);
if(h[i].lengths)
av_free(h[i].lengths);
if(h[i].values)
av_free(h[i].values);
}
*data_size = unp_size;
return buf_size;
}
| {
"code": [
" if ((unp_size << !bits) > *data_size) {"
],
"line_no": [
47
]
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2, uint8_t *VAR_3, int VAR_4)
{
GetBitContext gb;
HuffContext h[4];
VLC vlc[4];
int16_t *samples = VAR_1;
int VAR_5;
int VAR_6, VAR_7;
int VAR_8;
int VAR_9, VAR_10;
int VAR_11[2] = {0, 0};
VAR_8 = AV_RL32(VAR_3);
init_get_bits(&gb, VAR_3 + 4, (VAR_4 - 4) * 8);
if(!get_bits1(&gb)){
av_log(VAR_0, AV_LOG_INFO, "Sound: no VAR_1\n");
*VAR_2 = 0;
return 1;
}
VAR_10 = get_bits1(&gb);
VAR_9 = get_bits1(&gb);
if ((VAR_8 << !VAR_9) > *VAR_2) {
av_log(VAR_0, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
return -1;
}
memset(vlc, 0, sizeof(VLC) * 4);
memset(h, 0, sizeof(HuffContext) * 4);
for(VAR_6 = 0; VAR_6 < (1 << (VAR_9 + VAR_10)); VAR_6++) {
h[VAR_6].length = 256;
h[VAR_6].maxlength = 0;
h[VAR_6].current = 0;
h[VAR_6].VAR_9 = av_mallocz(256 * 4);
h[VAR_6].lengths = av_mallocz(256 * sizeof(int));
h[VAR_6].values = av_mallocz(256 * sizeof(int));
skip_bits1(&gb);
smacker_decode_tree(&gb, &h[VAR_6], 0, 0);
skip_bits1(&gb);
if(h[VAR_6].current > 1) {
VAR_7 = init_vlc(&vlc[VAR_6], SMKTREE_BITS, h[VAR_6].length,
h[VAR_6].lengths, sizeof(int), sizeof(int),
h[VAR_6].VAR_9, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(VAR_7 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
}
}
if(VAR_9) {
for(VAR_6 = VAR_10; VAR_6 >= 0; VAR_6--)
VAR_11[VAR_6] = bswap_16(get_bits(&gb, 16));
for(VAR_6 = 0; VAR_6 < VAR_10; VAR_6++)
*samples++ = VAR_11[VAR_6];
for(VAR_6 = 0; VAR_6 < VAR_8 / 2; VAR_6++) {
if(VAR_6 & VAR_10) {
if(vlc[2].table)
VAR_7 = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
else
VAR_7 = 0;
VAR_5 = h[2].values[VAR_7];
if(vlc[3].table)
VAR_7 = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
else
VAR_7 = 0;
VAR_5 |= h[3].values[VAR_7] << 8;
VAR_11[1] += (int16_t)VAR_5;
*samples++ = VAR_11[1];
} else {
if(vlc[0].table)
VAR_7 = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
VAR_7 = 0;
VAR_5 = h[0].values[VAR_7];
if(vlc[1].table)
VAR_7 = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
VAR_7 = 0;
VAR_5 |= h[1].values[VAR_7] << 8;
VAR_11[0] += VAR_5;
*samples++ = VAR_11[0];
}
}
} else {
for(VAR_6 = VAR_10; VAR_6 >= 0; VAR_6--)
VAR_11[VAR_6] = get_bits(&gb, 8);
for(VAR_6 = 0; VAR_6 < VAR_10; VAR_6++)
*samples++ = (VAR_11[VAR_6] - 0x80) << 8;
for(VAR_6 = 0; VAR_6 < VAR_8; VAR_6++) {
if(VAR_6 & VAR_10){
if(vlc[1].table)
VAR_7 = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
VAR_7 = 0;
VAR_11[1] += (int8_t)h[1].values[VAR_7];
*samples++ = (VAR_11[1] - 0x80) << 8;
} else {
if(vlc[0].table)
VAR_7 = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
VAR_7 = 0;
VAR_11[0] += (int8_t)h[0].values[VAR_7];
*samples++ = (VAR_11[0] - 0x80) << 8;
}
}
VAR_8 *= 2;
}
for(VAR_6 = 0; VAR_6 < 4; VAR_6++) {
if(vlc[VAR_6].table)
free_vlc(&vlc[VAR_6]);
if(h[VAR_6].VAR_9)
av_free(h[VAR_6].VAR_9);
if(h[VAR_6].lengths)
av_free(h[VAR_6].lengths);
if(h[VAR_6].values)
av_free(h[VAR_6].values);
}
*VAR_2 = VAR_8;
return VAR_4;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2, uint8_t *VAR_3, int VAR_4)\n{",
"GetBitContext gb;",
"HuffContext h[4];",
"VLC vlc[4];",
"int16_t *samples = VAR_1;",
"int VAR_5;",
"int VAR_6, VAR_7;",
"int VAR_8;",
"int VAR_9, VAR_10;",
"int VAR_11[2] = {0, 0};",
"VAR_8 = AV_RL32(VAR_3);",
"init_get_bits(&gb, VAR_3 + 4, (VAR_4 - 4) * 8);",
"if(!get_bits1(&gb)){",
"av_log(VAR_0, AV_LOG_INFO, \"Sound: no VAR_1\\n\");",
"*VAR_2 = 0;",
"return 1;",
"}",
"VAR_10 = get_bits1(&gb);",
"VAR_9 = get_bits1(&gb);",
"if ((VAR_8 << !VAR_9) > *VAR_2) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Frame is too large to fit in buffer\\n\");",
"return -1;",
"}",
"memset(vlc, 0, sizeof(VLC) * 4);",
"memset(h, 0, sizeof(HuffContext) * 4);",
"for(VAR_6 = 0; VAR_6 < (1 << (VAR_9 + VAR_10)); VAR_6++) {",
"h[VAR_6].length = 256;",
"h[VAR_6].maxlength = 0;",
"h[VAR_6].current = 0;",
"h[VAR_6].VAR_9 = av_mallocz(256 * 4);",
"h[VAR_6].lengths = av_mallocz(256 * sizeof(int));",
"h[VAR_6].values = av_mallocz(256 * sizeof(int));",
"skip_bits1(&gb);",
"smacker_decode_tree(&gb, &h[VAR_6], 0, 0);",
"skip_bits1(&gb);",
"if(h[VAR_6].current > 1) {",
"VAR_7 = init_vlc(&vlc[VAR_6], SMKTREE_BITS, h[VAR_6].length,\nh[VAR_6].lengths, sizeof(int), sizeof(int),\nh[VAR_6].VAR_9, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);",
"if(VAR_7 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Cannot build VLC table\\n\");",
"return -1;",
"}",
"}",
"}",
"if(VAR_9) {",
"for(VAR_6 = VAR_10; VAR_6 >= 0; VAR_6--)",
"VAR_11[VAR_6] = bswap_16(get_bits(&gb, 16));",
"for(VAR_6 = 0; VAR_6 < VAR_10; VAR_6++)",
"*samples++ = VAR_11[VAR_6];",
"for(VAR_6 = 0; VAR_6 < VAR_8 / 2; VAR_6++) {",
"if(VAR_6 & VAR_10) {",
"if(vlc[2].table)\nVAR_7 = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);",
"else\nVAR_7 = 0;",
"VAR_5 = h[2].values[VAR_7];",
"if(vlc[3].table)\nVAR_7 = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);",
"else\nVAR_7 = 0;",
"VAR_5 |= h[3].values[VAR_7] << 8;",
"VAR_11[1] += (int16_t)VAR_5;",
"*samples++ = VAR_11[1];",
"} else {",
"if(vlc[0].table)\nVAR_7 = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);",
"else\nVAR_7 = 0;",
"VAR_5 = h[0].values[VAR_7];",
"if(vlc[1].table)\nVAR_7 = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);",
"else\nVAR_7 = 0;",
"VAR_5 |= h[1].values[VAR_7] << 8;",
"VAR_11[0] += VAR_5;",
"*samples++ = VAR_11[0];",
"}",
"}",
"} else {",
"for(VAR_6 = VAR_10; VAR_6 >= 0; VAR_6--)",
"VAR_11[VAR_6] = get_bits(&gb, 8);",
"for(VAR_6 = 0; VAR_6 < VAR_10; VAR_6++)",
"*samples++ = (VAR_11[VAR_6] - 0x80) << 8;",
"for(VAR_6 = 0; VAR_6 < VAR_8; VAR_6++) {",
"if(VAR_6 & VAR_10){",
"if(vlc[1].table)\nVAR_7 = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);",
"else\nVAR_7 = 0;",
"VAR_11[1] += (int8_t)h[1].values[VAR_7];",
"*samples++ = (VAR_11[1] - 0x80) << 8;",
"} else {",
"if(vlc[0].table)\nVAR_7 = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);",
"else\nVAR_7 = 0;",
"VAR_11[0] += (int8_t)h[0].values[VAR_7];",
"*samples++ = (VAR_11[0] - 0x80) << 8;",
"}",
"}",
"VAR_8 *= 2;",
"}",
"for(VAR_6 = 0; VAR_6 < 4; VAR_6++) {",
"if(vlc[VAR_6].table)\nfree_vlc(&vlc[VAR_6]);",
"if(h[VAR_6].VAR_9)\nav_free(h[VAR_6].VAR_9);",
"if(h[VAR_6].lengths)\nav_free(h[VAR_6].lengths);",
"if(h[VAR_6].values)\nav_free(h[VAR_6].values);",
"}",
"*VAR_2 = VAR_8;",
"return VAR_4;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85,
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117,
119
],
[
121,
123
],
[
125
],
[
127,
129
],
[
131,
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143,
145
],
[
147,
149
],
[
151
],
[
153,
155
],
[
157,
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185,
187
],
[
189,
191
],
[
193
],
[
195
],
[
197
],
[
199,
201
],
[
203,
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
221
],
[
223,
225
],
[
227,
229
],
[
231,
233
],
[
235,
237
],
[
239
],
[
243
],
[
245
],
[
247
]
] |
23,984 | void do_brinc (void)
{
uint32_t a, b, d, mask;
mask = (uint32_t)(-1UL) >> MASKBITS;
b = T1_64 & mask;
a = T0_64 & mask;
d = word_reverse(1 + word_reverse(a | ~mask));
T0_64 = (T0_64 & ~mask) | (d & mask);
}
| true | qemu | 6f2d8978728c48ca46f5c01835438508aace5c64 | void do_brinc (void)
{
uint32_t a, b, d, mask;
mask = (uint32_t)(-1UL) >> MASKBITS;
b = T1_64 & mask;
a = T0_64 & mask;
d = word_reverse(1 + word_reverse(a | ~mask));
T0_64 = (T0_64 & ~mask) | (d & mask);
}
| {
"code": [
" mask = (uint32_t)(-1UL) >> MASKBITS;"
],
"line_no": [
9
]
} | void FUNC_0 (void)
{
uint32_t a, b, d, mask;
mask = (uint32_t)(-1UL) >> MASKBITS;
b = T1_64 & mask;
a = T0_64 & mask;
d = word_reverse(1 + word_reverse(a | ~mask));
T0_64 = (T0_64 & ~mask) | (d & mask);
}
| [
"void FUNC_0 (void)\n{",
"uint32_t a, b, d, mask;",
"mask = (uint32_t)(-1UL) >> MASKBITS;",
"b = T1_64 & mask;",
"a = T0_64 & mask;",
"d = word_reverse(1 + word_reverse(a | ~mask));",
"T0_64 = (T0_64 & ~mask) | (d & mask);",
"}"
] | [
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.