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
|
|---|---|---|---|---|---|---|---|---|---|---|
21,494 | char* qdev_get_fw_dev_path(DeviceState *dev)
{
char path[128];
int l;
l = qdev_get_fw_dev_path_helper(dev, path, 128);
path[l-1] = '\0';
return strdup(path);
}
| false | qemu | a5cf8262e4eb9c4646434e2c6211ef8608db3233 | char* qdev_get_fw_dev_path(DeviceState *dev)
{
char path[128];
int l;
l = qdev_get_fw_dev_path_helper(dev, path, 128);
path[l-1] = '\0';
return strdup(path);
}
| {
"code": [],
"line_no": []
} | char* FUNC_0(DeviceState *VAR_0)
{
char VAR_1[128];
int VAR_2;
VAR_2 = qdev_get_fw_dev_path_helper(VAR_0, VAR_1, 128);
VAR_1[VAR_2-1] = '\0';
return strdup(VAR_1);
}
| [
"char* FUNC_0(DeviceState *VAR_0)\n{",
"char VAR_1[128];",
"int VAR_2;",
"VAR_2 = qdev_get_fw_dev_path_helper(VAR_0, VAR_1, 128);",
"VAR_1[VAR_2-1] = '\\0';",
"return strdup(VAR_1);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
19
],
[
21
]
] |
21,495 | static ssize_t drop_sync(QIOChannel *ioc, size_t size)
{
ssize_t ret, dropped = size;
char small[1024];
char *buffer;
buffer = sizeof(small) < size ? small : g_malloc(MIN(65536, size));
while (size > 0) {
ret = read_sync(ioc, buffer, MIN(65536, size));
if (ret < 0) {
goto cleanup;
}
assert(ret <= size);
size -= ret;
}
ret = dropped;
cleanup:
if (buffer != small) {
g_free(buffer);
}
return ret;
}
| false | qemu | a5068244b4f0c994791303b6186b6f732adab6c2 | static ssize_t drop_sync(QIOChannel *ioc, size_t size)
{
ssize_t ret, dropped = size;
char small[1024];
char *buffer;
buffer = sizeof(small) < size ? small : g_malloc(MIN(65536, size));
while (size > 0) {
ret = read_sync(ioc, buffer, MIN(65536, size));
if (ret < 0) {
goto cleanup;
}
assert(ret <= size);
size -= ret;
}
ret = dropped;
cleanup:
if (buffer != small) {
g_free(buffer);
}
return ret;
}
| {
"code": [],
"line_no": []
} | static ssize_t FUNC_0(QIOChannel *ioc, size_t size)
{
ssize_t ret, dropped = size;
char VAR_0[1024];
char *VAR_1;
VAR_1 = sizeof(VAR_0) < size ? VAR_0 : g_malloc(MIN(65536, size));
while (size > 0) {
ret = read_sync(ioc, VAR_1, MIN(65536, size));
if (ret < 0) {
goto cleanup;
}
assert(ret <= size);
size -= ret;
}
ret = dropped;
cleanup:
if (VAR_1 != VAR_0) {
g_free(VAR_1);
}
return ret;
}
| [
"static ssize_t FUNC_0(QIOChannel *ioc, size_t size)\n{",
"ssize_t ret, dropped = size;",
"char VAR_0[1024];",
"char *VAR_1;",
"VAR_1 = sizeof(VAR_0) < size ? VAR_0 : g_malloc(MIN(65536, size));",
"while (size > 0) {",
"ret = read_sync(ioc, VAR_1, MIN(65536, size));",
"if (ret < 0) {",
"goto cleanup;",
"}",
"assert(ret <= size);",
"size -= ret;",
"}",
"ret = dropped;",
"cleanup:\nif (VAR_1 != VAR_0) {",
"g_free(VAR_1);",
"}",
"return ret;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45
]
] |
21,496 | static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
| false | qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
| {
"code": [],
"line_no": []
} | static BlockAIOCB *FUNC_0(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockCompletionFunc *cb, void *opaque)
{
return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
}
| [
"static BlockAIOCB *FUNC_0(BlockDriverState *bs,\nint64_t sector_num, QEMUIOVector *qiov, int nb_sectors,\nBlockCompletionFunc *cb, void *opaque)\n{",
"return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
]
] |
21,497 | static int seek_frame_generic(AVFormatContext *s,
int stream_index, int64_t timestamp, int flags)
{
int index;
int64_t ret;
AVStream *st;
AVIndexEntry *ie;
st = s->streams[stream_index];
index = av_index_search_timestamp(st, timestamp, flags);
if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
return -1;
if(index < 0 || index==st->nb_index_entries-1){
AVPacket pkt;
int nonkey=0;
if(st->nb_index_entries){
assert(st->index_entries);
ie= &st->index_entries[st->nb_index_entries-1];
if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
return ret;
ff_update_cur_dts(s, st, ie->timestamp);
}else{
if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
return ret;
}
for (;;) {
int read_status;
do{
read_status = av_read_frame(s, &pkt);
} while (read_status == AVERROR(EAGAIN));
if (read_status < 0)
break;
av_free_packet(&pkt);
if(stream_index == pkt.stream_index && pkt.dts > timestamp){
if(pkt.flags & AV_PKT_FLAG_KEY)
break;
if(nonkey++ > 1000){
av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
break;
}
}
}
index = av_index_search_timestamp(st, timestamp, flags);
}
if (index < 0)
return -1;
ff_read_frame_flush(s);
AV_NOWARN_DEPRECATED(
if (s->iformat->read_seek){
if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
return 0;
}
)
ie = &st->index_entries[index];
if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
return ret;
ff_update_cur_dts(s, st, ie->timestamp);
return 0;
}
| false | FFmpeg | 36a60fad6215db39e9cd9523e3425f64464046c7 | static int seek_frame_generic(AVFormatContext *s,
int stream_index, int64_t timestamp, int flags)
{
int index;
int64_t ret;
AVStream *st;
AVIndexEntry *ie;
st = s->streams[stream_index];
index = av_index_search_timestamp(st, timestamp, flags);
if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
return -1;
if(index < 0 || index==st->nb_index_entries-1){
AVPacket pkt;
int nonkey=0;
if(st->nb_index_entries){
assert(st->index_entries);
ie= &st->index_entries[st->nb_index_entries-1];
if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
return ret;
ff_update_cur_dts(s, st, ie->timestamp);
}else{
if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
return ret;
}
for (;;) {
int read_status;
do{
read_status = av_read_frame(s, &pkt);
} while (read_status == AVERROR(EAGAIN));
if (read_status < 0)
break;
av_free_packet(&pkt);
if(stream_index == pkt.stream_index && pkt.dts > timestamp){
if(pkt.flags & AV_PKT_FLAG_KEY)
break;
if(nonkey++ > 1000){
av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
break;
}
}
}
index = av_index_search_timestamp(st, timestamp, flags);
}
if (index < 0)
return -1;
ff_read_frame_flush(s);
AV_NOWARN_DEPRECATED(
if (s->iformat->read_seek){
if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
return 0;
}
)
ie = &st->index_entries[index];
if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
return ret;
ff_update_cur_dts(s, st, ie->timestamp);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0,
int VAR_1, int64_t VAR_2, int VAR_3)
{
int VAR_4;
int64_t ret;
AVStream *st;
AVIndexEntry *ie;
st = VAR_0->streams[VAR_1];
VAR_4 = av_index_search_timestamp(st, VAR_2, VAR_3);
if(VAR_4 < 0 && st->nb_index_entries && VAR_2 < st->index_entries[0].VAR_2)
return -1;
if(VAR_4 < 0 || VAR_4==st->nb_index_entries-1){
AVPacket pkt;
int VAR_5=0;
if(st->nb_index_entries){
assert(st->index_entries);
ie= &st->index_entries[st->nb_index_entries-1];
if ((ret = avio_seek(VAR_0->pb, ie->pos, SEEK_SET)) < 0)
return ret;
ff_update_cur_dts(VAR_0, st, ie->VAR_2);
}else{
if ((ret = avio_seek(VAR_0->pb, VAR_0->data_offset, SEEK_SET)) < 0)
return ret;
}
for (;;) {
int VAR_6;
do{
VAR_6 = av_read_frame(VAR_0, &pkt);
} while (VAR_6 == AVERROR(EAGAIN));
if (VAR_6 < 0)
break;
av_free_packet(&pkt);
if(VAR_1 == pkt.VAR_1 && pkt.dts > VAR_2){
if(pkt.VAR_3 & AV_PKT_FLAG_KEY)
break;
if(VAR_5++ > 1000){
av_log(VAR_0, AV_LOG_ERROR,"FUNC_0 failed as this stream seems to contain no keyframes after the target VAR_2, %d non keyframes found\n", VAR_5);
break;
}
}
}
VAR_4 = av_index_search_timestamp(st, VAR_2, VAR_3);
}
if (VAR_4 < 0)
return -1;
ff_read_frame_flush(VAR_0);
AV_NOWARN_DEPRECATED(
if (VAR_0->iformat->read_seek){
if(VAR_0->iformat->read_seek(VAR_0, VAR_1, VAR_2, VAR_3) >= 0)
return 0;
}
)
ie = &st->index_entries[VAR_4];
if ((ret = avio_seek(VAR_0->pb, ie->pos, SEEK_SET)) < 0)
return ret;
ff_update_cur_dts(VAR_0, st, ie->VAR_2);
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0,\nint VAR_1, int64_t VAR_2, int VAR_3)\n{",
"int VAR_4;",
"int64_t ret;",
"AVStream *st;",
"AVIndexEntry *ie;",
"st = VAR_0->streams[VAR_1];",
"VAR_4 = av_index_search_timestamp(st, VAR_2, VAR_3);",
"if(VAR_4 < 0 && st->nb_index_entries && VAR_2 < st->index_entries[0].VAR_2)\nreturn -1;",
"if(VAR_4 < 0 || VAR_4==st->nb_index_entries-1){",
"AVPacket pkt;",
"int VAR_5=0;",
"if(st->nb_index_entries){",
"assert(st->index_entries);",
"ie= &st->index_entries[st->nb_index_entries-1];",
"if ((ret = avio_seek(VAR_0->pb, ie->pos, SEEK_SET)) < 0)\nreturn ret;",
"ff_update_cur_dts(VAR_0, st, ie->VAR_2);",
"}else{",
"if ((ret = avio_seek(VAR_0->pb, VAR_0->data_offset, SEEK_SET)) < 0)\nreturn ret;",
"}",
"for (;;) {",
"int VAR_6;",
"do{",
"VAR_6 = av_read_frame(VAR_0, &pkt);",
"} while (VAR_6 == AVERROR(EAGAIN));",
"if (VAR_6 < 0)\nbreak;",
"av_free_packet(&pkt);",
"if(VAR_1 == pkt.VAR_1 && pkt.dts > VAR_2){",
"if(pkt.VAR_3 & AV_PKT_FLAG_KEY)\nbreak;",
"if(VAR_5++ > 1000){",
"av_log(VAR_0, AV_LOG_ERROR,\"FUNC_0 failed as this stream seems to contain no keyframes after the target VAR_2, %d non keyframes found\\n\", VAR_5);",
"break;",
"}",
"}",
"}",
"VAR_4 = av_index_search_timestamp(st, VAR_2, VAR_3);",
"}",
"if (VAR_4 < 0)\nreturn -1;",
"ff_read_frame_flush(VAR_0);",
"AV_NOWARN_DEPRECATED(\nif (VAR_0->iformat->read_seek){",
"if(VAR_0->iformat->read_seek(VAR_0, VAR_1, VAR_2, VAR_3) >= 0)\nreturn 0;",
"}",
")\nie = &st->index_entries[VAR_4];",
"if ((ret = avio_seek(VAR_0->pb, ie->pos, SEEK_SET)) < 0)\nreturn ret;",
"ff_update_cur_dts(VAR_0, st, ie->VAR_2);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
25,
27
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
77,
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97,
99
],
[
103
],
[
105,
107
],
[
109,
111
],
[
113
],
[
115,
117
],
[
119,
121
],
[
123
],
[
127
],
[
129
]
] |
21,498 | static void dvbsub_parse_page_segment(AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubRegionDisplay *display;
DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
const uint8_t *buf_end = buf + buf_size;
int region_id;
int page_state;
if (buf_size < 1)
return;
ctx->time_out = *buf++;
page_state = ((*buf++) >> 2) & 3;
av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
if (page_state == 2) {
delete_state(ctx);
}
tmp_display_list = ctx->display_list;
ctx->display_list = NULL;
ctx->display_list_size = 0;
while (buf + 5 < buf_end) {
region_id = *buf++;
buf += 1;
display = tmp_display_list;
tmp_ptr = &tmp_display_list;
while (display && display->region_id != region_id) {
tmp_ptr = &display->next;
display = display->next;
}
if (!display)
display = av_mallocz(sizeof(DVBSubRegionDisplay));
display->region_id = region_id;
display->x_pos = AV_RB16(buf);
buf += 2;
display->y_pos = AV_RB16(buf);
buf += 2;
*tmp_ptr = display->next;
display->next = ctx->display_list;
ctx->display_list = display;
ctx->display_list_size++;
av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
}
while (tmp_display_list) {
display = tmp_display_list;
tmp_display_list = display->next;
av_free(display);
}
}
| false | FFmpeg | 607ad990d31e6be52980970e5ce8cd25ab3de812 | static void dvbsub_parse_page_segment(AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubRegionDisplay *display;
DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
const uint8_t *buf_end = buf + buf_size;
int region_id;
int page_state;
if (buf_size < 1)
return;
ctx->time_out = *buf++;
page_state = ((*buf++) >> 2) & 3;
av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
if (page_state == 2) {
delete_state(ctx);
}
tmp_display_list = ctx->display_list;
ctx->display_list = NULL;
ctx->display_list_size = 0;
while (buf + 5 < buf_end) {
region_id = *buf++;
buf += 1;
display = tmp_display_list;
tmp_ptr = &tmp_display_list;
while (display && display->region_id != region_id) {
tmp_ptr = &display->next;
display = display->next;
}
if (!display)
display = av_mallocz(sizeof(DVBSubRegionDisplay));
display->region_id = region_id;
display->x_pos = AV_RB16(buf);
buf += 2;
display->y_pos = AV_RB16(buf);
buf += 2;
*tmp_ptr = display->next;
display->next = ctx->display_list;
ctx->display_list = display;
ctx->display_list_size++;
av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
}
while (tmp_display_list) {
display = tmp_display_list;
tmp_display_list = display->next;
av_free(display);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AVCodecContext *VAR_0,
const uint8_t *VAR_1, int VAR_2)
{
DVBSubContext *ctx = VAR_0->priv_data;
DVBSubRegionDisplay *display;
DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
const uint8_t *VAR_3 = VAR_1 + VAR_2;
int VAR_4;
int VAR_5;
if (VAR_2 < 1)
return;
ctx->time_out = *VAR_1++;
VAR_5 = ((*VAR_1++) >> 2) & 3;
av_dlog(VAR_0, "Page time out %ds, state %d\n", ctx->time_out, VAR_5);
if (VAR_5 == 2) {
delete_state(ctx);
}
tmp_display_list = ctx->display_list;
ctx->display_list = NULL;
ctx->display_list_size = 0;
while (VAR_1 + 5 < VAR_3) {
VAR_4 = *VAR_1++;
VAR_1 += 1;
display = tmp_display_list;
tmp_ptr = &tmp_display_list;
while (display && display->VAR_4 != VAR_4) {
tmp_ptr = &display->next;
display = display->next;
}
if (!display)
display = av_mallocz(sizeof(DVBSubRegionDisplay));
display->VAR_4 = VAR_4;
display->x_pos = AV_RB16(VAR_1);
VAR_1 += 2;
display->y_pos = AV_RB16(VAR_1);
VAR_1 += 2;
*tmp_ptr = display->next;
display->next = ctx->display_list;
ctx->display_list = display;
ctx->display_list_size++;
av_dlog(VAR_0, "Region %d, (%d,%d)\n", VAR_4, display->x_pos, display->y_pos);
}
while (tmp_display_list) {
display = tmp_display_list;
tmp_display_list = display->next;
av_free(display);
}
}
| [
"static void FUNC_0(AVCodecContext *VAR_0,\nconst uint8_t *VAR_1, int VAR_2)\n{",
"DVBSubContext *ctx = VAR_0->priv_data;",
"DVBSubRegionDisplay *display;",
"DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;",
"const uint8_t *VAR_3 = VAR_1 + VAR_2;",
"int VAR_4;",
"int VAR_5;",
"if (VAR_2 < 1)\nreturn;",
"ctx->time_out = *VAR_1++;",
"VAR_5 = ((*VAR_1++) >> 2) & 3;",
"av_dlog(VAR_0, \"Page time out %ds, state %d\\n\", ctx->time_out, VAR_5);",
"if (VAR_5 == 2) {",
"delete_state(ctx);",
"}",
"tmp_display_list = ctx->display_list;",
"ctx->display_list = NULL;",
"ctx->display_list_size = 0;",
"while (VAR_1 + 5 < VAR_3) {",
"VAR_4 = *VAR_1++;",
"VAR_1 += 1;",
"display = tmp_display_list;",
"tmp_ptr = &tmp_display_list;",
"while (display && display->VAR_4 != VAR_4) {",
"tmp_ptr = &display->next;",
"display = display->next;",
"}",
"if (!display)\ndisplay = av_mallocz(sizeof(DVBSubRegionDisplay));",
"display->VAR_4 = VAR_4;",
"display->x_pos = AV_RB16(VAR_1);",
"VAR_1 += 2;",
"display->y_pos = AV_RB16(VAR_1);",
"VAR_1 += 2;",
"*tmp_ptr = display->next;",
"display->next = ctx->display_list;",
"ctx->display_list = display;",
"ctx->display_list_size++;",
"av_dlog(VAR_0, \"Region %d, (%d,%d)\\n\", VAR_4, display->x_pos, display->y_pos);",
"}",
"while (tmp_display_list) {",
"display = tmp_display_list;",
"tmp_display_list = display->next;",
"av_free(display);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79,
81
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
117
],
[
119
],
[
123
],
[
127
],
[
129
],
[
133
]
] |
21,499 | static void test_qemu_strtoul_negative(void)
{
const char *str = " \t -321";
char f = 'X';
const char *endptr = &f;
unsigned long res = 999;
int err;
err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, -321ul);
g_assert(endptr == str + strlen(str));
}
| false | qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | static void test_qemu_strtoul_negative(void)
{
const char *str = " \t -321";
char f = 'X';
const char *endptr = &f;
unsigned long res = 999;
int err;
err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, -321ul);
g_assert(endptr == str + strlen(str));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
const char *VAR_0 = " \t -321";
char VAR_1 = 'X';
const char *VAR_2 = &VAR_1;
unsigned long VAR_3 = 999;
int VAR_4;
VAR_4 = qemu_strtoul(VAR_0, &VAR_2, 0, &VAR_3);
g_assert_cmpint(VAR_4, ==, 0);
g_assert_cmpint(VAR_3, ==, -321ul);
g_assert(VAR_2 == VAR_0 + strlen(VAR_0));
}
| [
"static void FUNC_0(void)\n{",
"const char *VAR_0 = \" \\t -321\";",
"char VAR_1 = 'X';",
"const char *VAR_2 = &VAR_1;",
"unsigned long VAR_3 = 999;",
"int VAR_4;",
"VAR_4 = qemu_strtoul(VAR_0, &VAR_2, 0, &VAR_3);",
"g_assert_cmpint(VAR_4, ==, 0);",
"g_assert_cmpint(VAR_3, ==, -321ul);",
"g_assert(VAR_2 == VAR_0 + strlen(VAR_0));",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
]
] |
21,500 | static int is_cpuid_supported(void)
{
return 1;
}
| false | qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | static int is_cpuid_supported(void)
{
return 1;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(void)
{
return 1;
}
| [
"static int FUNC_0(void)\n{",
"return 1;",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
21,501 | void vnc_display_init(const char *id)
{
VncDisplay *vs;
if (vnc_display_find(id) != NULL) {
return;
}
vs = g_malloc0(sizeof(*vs));
vs->id = strdup(id);
QTAILQ_INSERT_TAIL(&vnc_displays, vs, next);
vs->lsock = -1;
#ifdef CONFIG_VNC_WS
vs->lwebsock = -1;
#endif
QTAILQ_INIT(&vs->clients);
vs->expires = TIME_MAX;
if (keyboard_layout) {
trace_vnc_key_map_init(keyboard_layout);
vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
} else {
vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
}
if (!vs->kbd_layout)
exit(1);
qemu_mutex_init(&vs->mutex);
vnc_start_worker_thread();
vs->dcl.ops = &dcl_ops;
register_displaychangelistener(&vs->dcl);
}
| false | qemu | 8e9b0d24fb986d4241ae3b77752eca5dab4cb486 | void vnc_display_init(const char *id)
{
VncDisplay *vs;
if (vnc_display_find(id) != NULL) {
return;
}
vs = g_malloc0(sizeof(*vs));
vs->id = strdup(id);
QTAILQ_INSERT_TAIL(&vnc_displays, vs, next);
vs->lsock = -1;
#ifdef CONFIG_VNC_WS
vs->lwebsock = -1;
#endif
QTAILQ_INIT(&vs->clients);
vs->expires = TIME_MAX;
if (keyboard_layout) {
trace_vnc_key_map_init(keyboard_layout);
vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
} else {
vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
}
if (!vs->kbd_layout)
exit(1);
qemu_mutex_init(&vs->mutex);
vnc_start_worker_thread();
vs->dcl.ops = &dcl_ops;
register_displaychangelistener(&vs->dcl);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(const char *VAR_0)
{
VncDisplay *vs;
if (vnc_display_find(VAR_0) != NULL) {
return;
}
vs = g_malloc0(sizeof(*vs));
vs->VAR_0 = strdup(VAR_0);
QTAILQ_INSERT_TAIL(&vnc_displays, vs, next);
vs->lsock = -1;
#ifdef CONFIG_VNC_WS
vs->lwebsock = -1;
#endif
QTAILQ_INIT(&vs->clients);
vs->expires = TIME_MAX;
if (keyboard_layout) {
trace_vnc_key_map_init(keyboard_layout);
vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
} else {
vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
}
if (!vs->kbd_layout)
exit(1);
qemu_mutex_init(&vs->mutex);
vnc_start_worker_thread();
vs->dcl.ops = &dcl_ops;
register_displaychangelistener(&vs->dcl);
}
| [
"void FUNC_0(const char *VAR_0)\n{",
"VncDisplay *vs;",
"if (vnc_display_find(VAR_0) != NULL) {",
"return;",
"}",
"vs = g_malloc0(sizeof(*vs));",
"vs->VAR_0 = strdup(VAR_0);",
"QTAILQ_INSERT_TAIL(&vnc_displays, vs, next);",
"vs->lsock = -1;",
"#ifdef CONFIG_VNC_WS\nvs->lwebsock = -1;",
"#endif\nQTAILQ_INIT(&vs->clients);",
"vs->expires = TIME_MAX;",
"if (keyboard_layout) {",
"trace_vnc_key_map_init(keyboard_layout);",
"vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);",
"} else {",
"vs->kbd_layout = init_keyboard_layout(name2keysym, \"en-us\");",
"}",
"if (!vs->kbd_layout)\nexit(1);",
"qemu_mutex_init(&vs->mutex);",
"vnc_start_worker_thread();",
"vs->dcl.ops = &dcl_ops;",
"register_displaychangelistener(&vs->dcl);",
"}"
] | [
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
],
[
19
],
[
21
],
[
25
],
[
27,
29
],
[
31,
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
]
] |
21,502 | static int get_key(const char **ropts, const char *delim, char *key, unsigned key_size)
{
unsigned key_pos = 0;
const char *opts = *ropts;
opts += strspn(opts, WHITESPACES);
while (is_key_char(*opts)) {
key[key_pos++] = *opts;
if (key_pos == key_size)
key_pos--;
(opts)++;
}
opts += strspn(opts, WHITESPACES);
if (!*opts || !strchr(delim, *opts))
return AVERROR(EINVAL);
opts++;
key[key_pos++] = 0;
if (key_pos == key_size)
key[key_pos - 4] = key[key_pos - 3] = key[key_pos - 2] = '.';
*ropts = opts;
return 0;
}
| false | FFmpeg | e021eeb9f06f4f4d83690d07b47cdcc4172a61e1 | static int get_key(const char **ropts, const char *delim, char *key, unsigned key_size)
{
unsigned key_pos = 0;
const char *opts = *ropts;
opts += strspn(opts, WHITESPACES);
while (is_key_char(*opts)) {
key[key_pos++] = *opts;
if (key_pos == key_size)
key_pos--;
(opts)++;
}
opts += strspn(opts, WHITESPACES);
if (!*opts || !strchr(delim, *opts))
return AVERROR(EINVAL);
opts++;
key[key_pos++] = 0;
if (key_pos == key_size)
key[key_pos - 4] = key[key_pos - 3] = key[key_pos - 2] = '.';
*ropts = opts;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(const char **VAR_0, const char *VAR_1, char *VAR_2, unsigned VAR_3)
{
unsigned VAR_4 = 0;
const char *VAR_5 = *VAR_0;
VAR_5 += strspn(VAR_5, WHITESPACES);
while (is_key_char(*VAR_5)) {
VAR_2[VAR_4++] = *VAR_5;
if (VAR_4 == VAR_3)
VAR_4--;
(VAR_5)++;
}
VAR_5 += strspn(VAR_5, WHITESPACES);
if (!*VAR_5 || !strchr(VAR_1, *VAR_5))
return AVERROR(EINVAL);
VAR_5++;
VAR_2[VAR_4++] = 0;
if (VAR_4 == VAR_3)
VAR_2[VAR_4 - 4] = VAR_2[VAR_4 - 3] = VAR_2[VAR_4 - 2] = '.';
*VAR_0 = VAR_5;
return 0;
}
| [
"static int FUNC_0(const char **VAR_0, const char *VAR_1, char *VAR_2, unsigned VAR_3)\n{",
"unsigned VAR_4 = 0;",
"const char *VAR_5 = *VAR_0;",
"VAR_5 += strspn(VAR_5, WHITESPACES);",
"while (is_key_char(*VAR_5)) {",
"VAR_2[VAR_4++] = *VAR_5;",
"if (VAR_4 == VAR_3)\nVAR_4--;",
"(VAR_5)++;",
"}",
"VAR_5 += strspn(VAR_5, WHITESPACES);",
"if (!*VAR_5 || !strchr(VAR_1, *VAR_5))\nreturn AVERROR(EINVAL);",
"VAR_5++;",
"VAR_2[VAR_4++] = 0;",
"if (VAR_4 == VAR_3)\nVAR_2[VAR_4 - 4] = VAR_2[VAR_4 - 3] = VAR_2[VAR_4 - 2] = '.';",
"*VAR_0 = VAR_5;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
]
] |
21,503 | static void expand_timestamps(void *log, struct sbg_script *s)
{
int i, nb_rel = 0;
int64_t now, cur_ts, delta = 0;
for (i = 0; i < s->nb_tseq; i++)
nb_rel += s->tseq[i].ts.type == 'N';
if (nb_rel == s->nb_tseq) {
/* All ts are relative to NOW: consider NOW = 0 */
now = 0;
if (s->start_ts != AV_NOPTS_VALUE)
av_log(log, AV_LOG_WARNING,
"Start time ignored in a purely relative script.\n");
} else if (nb_rel == 0 && s->start_ts != AV_NOPTS_VALUE ||
s->opt_start_at_first) {
/* All ts are absolute and start time is specified */
if (s->start_ts == AV_NOPTS_VALUE)
s->start_ts = s->tseq[0].ts.t;
now = s->start_ts;
} else {
/* Mixed relative/absolute ts: expand */
time_t now0;
struct tm *tm, tmpbuf;
av_log(log, AV_LOG_WARNING,
"Scripts with mixed absolute and relative timestamps can give "
"unexpected results (pause, seeking, time zone change).\n");
#undef time
time(&now0);
tm = localtime_r(&now0, &tmpbuf);
now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
now0 % DAY;
av_log(log, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",
(int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);
now *= AV_TIME_BASE;
for (i = 0; i < s->nb_tseq; i++) {
if (s->tseq[i].ts.type == 'N') {
s->tseq[i].ts.t += now;
s->tseq[i].ts.type = 'T'; /* not necessary */
}
}
}
if (s->start_ts == AV_NOPTS_VALUE)
s->start_ts = s->opt_start_at_first ? s->tseq[0].ts.t : now;
s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
AV_NOPTS_VALUE; /* may be overridden later by -E option */
cur_ts = now;
for (i = 0; i < s->nb_tseq; i++) {
if (s->tseq[i].ts.t + delta < cur_ts)
delta += DAY_TS;
cur_ts = s->tseq[i].ts.t += delta;
}
}
| false | FFmpeg | dbefbb61b785cd77810c032f5cdb499d2a92df07 | static void expand_timestamps(void *log, struct sbg_script *s)
{
int i, nb_rel = 0;
int64_t now, cur_ts, delta = 0;
for (i = 0; i < s->nb_tseq; i++)
nb_rel += s->tseq[i].ts.type == 'N';
if (nb_rel == s->nb_tseq) {
now = 0;
if (s->start_ts != AV_NOPTS_VALUE)
av_log(log, AV_LOG_WARNING,
"Start time ignored in a purely relative script.\n");
} else if (nb_rel == 0 && s->start_ts != AV_NOPTS_VALUE ||
s->opt_start_at_first) {
if (s->start_ts == AV_NOPTS_VALUE)
s->start_ts = s->tseq[0].ts.t;
now = s->start_ts;
} else {
time_t now0;
struct tm *tm, tmpbuf;
av_log(log, AV_LOG_WARNING,
"Scripts with mixed absolute and relative timestamps can give "
"unexpected results (pause, seeking, time zone change).\n");
#undef time
time(&now0);
tm = localtime_r(&now0, &tmpbuf);
now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
now0 % DAY;
av_log(log, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",
(int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);
now *= AV_TIME_BASE;
for (i = 0; i < s->nb_tseq; i++) {
if (s->tseq[i].ts.type == 'N') {
s->tseq[i].ts.t += now;
s->tseq[i].ts.type = 'T';
}
}
}
if (s->start_ts == AV_NOPTS_VALUE)
s->start_ts = s->opt_start_at_first ? s->tseq[0].ts.t : now;
s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
AV_NOPTS_VALUE;
cur_ts = now;
for (i = 0; i < s->nb_tseq; i++) {
if (s->tseq[i].ts.t + delta < cur_ts)
delta += DAY_TS;
cur_ts = s->tseq[i].ts.t += delta;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, struct sbg_script *VAR_1)
{
int VAR_2, VAR_3 = 0;
int64_t now, cur_ts, delta = 0;
for (VAR_2 = 0; VAR_2 < VAR_1->nb_tseq; VAR_2++)
VAR_3 += VAR_1->tseq[VAR_2].ts.type == 'N';
if (VAR_3 == VAR_1->nb_tseq) {
now = 0;
if (VAR_1->start_ts != AV_NOPTS_VALUE)
av_log(VAR_0, AV_LOG_WARNING,
"Start time ignored in a purely relative script.\n");
} else if (VAR_3 == 0 && VAR_1->start_ts != AV_NOPTS_VALUE ||
VAR_1->opt_start_at_first) {
if (VAR_1->start_ts == AV_NOPTS_VALUE)
VAR_1->start_ts = VAR_1->tseq[0].ts.t;
now = VAR_1->start_ts;
} else {
time_t now0;
struct VAR_4 *VAR_4, VAR_5;
av_log(VAR_0, AV_LOG_WARNING,
"Scripts with mixed absolute and relative timestamps can give "
"unexpected results (pause, seeking, time zone change).\n");
#undef time
time(&now0);
VAR_4 = localtime_r(&now0, &VAR_5);
now = VAR_4 ? VAR_4->tm_hour * 3600 + VAR_4->tm_min * 60 + VAR_4->tm_sec :
now0 % DAY;
av_log(VAR_0, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",
(int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);
now *= AV_TIME_BASE;
for (VAR_2 = 0; VAR_2 < VAR_1->nb_tseq; VAR_2++) {
if (VAR_1->tseq[VAR_2].ts.type == 'N') {
VAR_1->tseq[VAR_2].ts.t += now;
VAR_1->tseq[VAR_2].ts.type = 'T';
}
}
}
if (VAR_1->start_ts == AV_NOPTS_VALUE)
VAR_1->start_ts = VAR_1->opt_start_at_first ? VAR_1->tseq[0].ts.t : now;
VAR_1->end_ts = VAR_1->opt_duration ? VAR_1->start_ts + VAR_1->opt_duration :
AV_NOPTS_VALUE;
cur_ts = now;
for (VAR_2 = 0; VAR_2 < VAR_1->nb_tseq; VAR_2++) {
if (VAR_1->tseq[VAR_2].ts.t + delta < cur_ts)
delta += DAY_TS;
cur_ts = VAR_1->tseq[VAR_2].ts.t += delta;
}
}
| [
"static void FUNC_0(void *VAR_0, struct sbg_script *VAR_1)\n{",
"int VAR_2, VAR_3 = 0;",
"int64_t now, cur_ts, delta = 0;",
"for (VAR_2 = 0; VAR_2 < VAR_1->nb_tseq; VAR_2++)",
"VAR_3 += VAR_1->tseq[VAR_2].ts.type == 'N';",
"if (VAR_3 == VAR_1->nb_tseq) {",
"now = 0;",
"if (VAR_1->start_ts != AV_NOPTS_VALUE)\nav_log(VAR_0, AV_LOG_WARNING,\n\"Start time ignored in a purely relative script.\\n\");",
"} else if (VAR_3 == 0 && VAR_1->start_ts != AV_NOPTS_VALUE ||",
"VAR_1->opt_start_at_first) {",
"if (VAR_1->start_ts == AV_NOPTS_VALUE)\nVAR_1->start_ts = VAR_1->tseq[0].ts.t;",
"now = VAR_1->start_ts;",
"} else {",
"time_t now0;",
"struct VAR_4 *VAR_4, VAR_5;",
"av_log(VAR_0, AV_LOG_WARNING,\n\"Scripts with mixed absolute and relative timestamps can give \"\n\"unexpected results (pause, seeking, time zone change).\\n\");",
"#undef time\ntime(&now0);",
"VAR_4 = localtime_r(&now0, &VAR_5);",
"now = VAR_4 ? VAR_4->tm_hour * 3600 + VAR_4->tm_min * 60 + VAR_4->tm_sec :\nnow0 % DAY;",
"av_log(VAR_0, AV_LOG_INFO, \"Using %02d:%02d:%02d as NOW.\\n\",\n(int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);",
"now *= AV_TIME_BASE;",
"for (VAR_2 = 0; VAR_2 < VAR_1->nb_tseq; VAR_2++) {",
"if (VAR_1->tseq[VAR_2].ts.type == 'N') {",
"VAR_1->tseq[VAR_2].ts.t += now;",
"VAR_1->tseq[VAR_2].ts.type = 'T';",
"}",
"}",
"}",
"if (VAR_1->start_ts == AV_NOPTS_VALUE)\nVAR_1->start_ts = VAR_1->opt_start_at_first ? VAR_1->tseq[0].ts.t : now;",
"VAR_1->end_ts = VAR_1->opt_duration ? VAR_1->start_ts + VAR_1->opt_duration :\nAV_NOPTS_VALUE;",
"cur_ts = now;",
"for (VAR_2 = 0; VAR_2 < VAR_1->nb_tseq; VAR_2++) {",
"if (VAR_1->tseq[VAR_2].ts.t + delta < cur_ts)\ndelta += DAY_TS;",
"cur_ts = VAR_1->tseq[VAR_2].ts.t += delta;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23,
25
],
[
27
],
[
29
],
[
33,
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
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
]
] |
21,504 | static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
heap_elem_t h[size];
int up[2*size];
int len[2*size];
int offset, i, next;
for(offset=1; ; offset<<=1){
for(i=0; i<size; i++){
h[i].name = i;
h[i].val = (stats[i] << 8) + offset;
}
for(i=size/2-1; i>=0; i--)
heap_sift(h, i, size);
for(next=size; next<size*2-1; next++){
// merge the two smallest entries, and put it back in the heap
uint64_t min1v = h[0].val;
up[h[0].name] = next;
h[0].val = INT64_MAX;
heap_sift(h, 0, size);
up[h[0].name] = next;
h[0].name = next;
h[0].val += min1v;
heap_sift(h, 0, size);
}
len[2*size-2] = 0;
for(i=2*size-3; i>=size; i--)
len[i] = len[up[i]] + 1;
for(i=0; i<size; i++) {
dst[i] = len[up[i]] + 1;
if(dst[i] > 32) break;
}
if(i==size) break;
}
}
| false | FFmpeg | 2bf4aa2e937737deb781706673f806d4388cf796 | static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
heap_elem_t h[size];
int up[2*size];
int len[2*size];
int offset, i, next;
for(offset=1; ; offset<<=1){
for(i=0; i<size; i++){
h[i].name = i;
h[i].val = (stats[i] << 8) + offset;
}
for(i=size/2-1; i>=0; i--)
heap_sift(h, i, size);
for(next=size; next<size*2-1; next++){
uint64_t min1v = h[0].val;
up[h[0].name] = next;
h[0].val = INT64_MAX;
heap_sift(h, 0, size);
up[h[0].name] = next;
h[0].name = next;
h[0].val += min1v;
heap_sift(h, 0, size);
}
len[2*size-2] = 0;
for(i=2*size-3; i>=size; i--)
len[i] = len[up[i]] + 1;
for(i=0; i<size; i++) {
dst[i] = len[up[i]] + 1;
if(dst[i] > 32) break;
}
if(i==size) break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(uint8_t *VAR_0, uint64_t *VAR_1, int VAR_2){
heap_elem_t h[VAR_2];
int VAR_3[2*VAR_2];
int VAR_4[2*VAR_2];
int VAR_5, VAR_6, VAR_7;
for(VAR_5=1; ; VAR_5<<=1){
for(VAR_6=0; VAR_6<VAR_2; VAR_6++){
h[VAR_6].name = VAR_6;
h[VAR_6].val = (VAR_1[VAR_6] << 8) + VAR_5;
}
for(VAR_6=VAR_2/2-1; VAR_6>=0; VAR_6--)
heap_sift(h, VAR_6, VAR_2);
for(VAR_7=VAR_2; VAR_7<VAR_2*2-1; VAR_7++){
uint64_t min1v = h[0].val;
VAR_3[h[0].name] = VAR_7;
h[0].val = INT64_MAX;
heap_sift(h, 0, VAR_2);
VAR_3[h[0].name] = VAR_7;
h[0].name = VAR_7;
h[0].val += min1v;
heap_sift(h, 0, VAR_2);
}
VAR_4[2*VAR_2-2] = 0;
for(VAR_6=2*VAR_2-3; VAR_6>=VAR_2; VAR_6--)
VAR_4[VAR_6] = VAR_4[VAR_3[VAR_6]] + 1;
for(VAR_6=0; VAR_6<VAR_2; VAR_6++) {
VAR_0[VAR_6] = VAR_4[VAR_3[VAR_6]] + 1;
if(VAR_0[VAR_6] > 32) break;
}
if(VAR_6==VAR_2) break;
}
}
| [
"static void FUNC_0(uint8_t *VAR_0, uint64_t *VAR_1, int VAR_2){",
"heap_elem_t h[VAR_2];",
"int VAR_3[2*VAR_2];",
"int VAR_4[2*VAR_2];",
"int VAR_5, VAR_6, VAR_7;",
"for(VAR_5=1; ; VAR_5<<=1){",
"for(VAR_6=0; VAR_6<VAR_2; VAR_6++){",
"h[VAR_6].name = VAR_6;",
"h[VAR_6].val = (VAR_1[VAR_6] << 8) + VAR_5;",
"}",
"for(VAR_6=VAR_2/2-1; VAR_6>=0; VAR_6--)",
"heap_sift(h, VAR_6, VAR_2);",
"for(VAR_7=VAR_2; VAR_7<VAR_2*2-1; VAR_7++){",
"uint64_t min1v = h[0].val;",
"VAR_3[h[0].name] = VAR_7;",
"h[0].val = INT64_MAX;",
"heap_sift(h, 0, VAR_2);",
"VAR_3[h[0].name] = VAR_7;",
"h[0].name = VAR_7;",
"h[0].val += min1v;",
"heap_sift(h, 0, VAR_2);",
"}",
"VAR_4[2*VAR_2-2] = 0;",
"for(VAR_6=2*VAR_2-3; VAR_6>=VAR_2; VAR_6--)",
"VAR_4[VAR_6] = VAR_4[VAR_3[VAR_6]] + 1;",
"for(VAR_6=0; VAR_6<VAR_2; VAR_6++) {",
"VAR_0[VAR_6] = VAR_4[VAR_3[VAR_6]] + 1;",
"if(VAR_0[VAR_6] > 32) break;",
"}",
"if(VAR_6==VAR_2) break;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
]
] |
21,505 | static int scale_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
{
AVFilterContext *avctx = inlink->dst;
AVFilterLink *outlink = avctx->outputs[0];
ScaleVAAPIContext *ctx = avctx->priv;
AVFrame *output_frame = NULL;
VASurfaceID input_surface, output_surface;
VAProcPipelineParameterBuffer params;
VABufferID params_id;
VAStatus vas;
int err;
av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(input_frame->format),
input_frame->width, input_frame->height, input_frame->pts);
if (ctx->va_context == VA_INVALID_ID)
return AVERROR(EINVAL);
input_surface = (VASurfaceID)(uintptr_t)input_frame->data[3];
av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale input.\n",
input_surface);
output_frame = av_frame_alloc();
if (!output_frame) {
av_log(ctx, AV_LOG_ERROR, "Failed to allocate output frame.");
err = AVERROR(ENOMEM);
goto fail;
}
err = av_hwframe_get_buffer(ctx->output_frames_ref, output_frame, 0);
if (err < 0) {
av_log(ctx, AV_LOG_ERROR, "Failed to get surface for "
"output: %d\n.", err);
}
output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale output.\n",
output_surface);
memset(¶ms, 0, sizeof(params));
params.surface = input_surface;
params.surface_region = 0;
params.surface_color_standard =
vaapi_proc_colour_standard(input_frame->colorspace);
params.output_region = 0;
params.output_background_color = 0xff000000;
params.output_color_standard = params.surface_color_standard;
params.pipeline_flags = 0;
params.filter_flags = VA_FILTER_SCALING_HQ;
vas = vaBeginPicture(ctx->hwctx->display,
ctx->va_context, output_surface);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to attach new picture: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
VAProcPipelineParameterBufferType,
sizeof(params), 1, ¶ms, ¶ms_id);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to create parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail_after_begin;
}
av_log(ctx, AV_LOG_DEBUG, "Pipeline parameter buffer is %#x.\n",
params_id);
vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
¶ms_id, 1);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to render parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail_after_begin;
}
vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to start picture processing: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail_after_render;
}
if (ctx->hwctx->driver_quirks &
AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
// And ignore.
}
}
av_frame_copy_props(output_frame, input_frame);
av_frame_free(&input_frame);
av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(output_frame->format),
output_frame->width, output_frame->height, output_frame->pts);
return ff_filter_frame(outlink, output_frame);
// We want to make sure that if vaBeginPicture has been called, we also
// call vaRenderPicture and vaEndPicture. These calls may well fail or
// do something else nasty, but once we're in this failure case there
// isn't much else we can do.
fail_after_begin:
vaRenderPicture(ctx->hwctx->display, ctx->va_context, ¶ms_id, 1);
fail_after_render:
vaEndPicture(ctx->hwctx->display, ctx->va_context);
fail:
av_frame_free(&input_frame);
av_frame_free(&output_frame);
return err;
}
| false | FFmpeg | bdf7610eb266fd3de650040c97328791868abd82 | static int scale_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
{
AVFilterContext *avctx = inlink->dst;
AVFilterLink *outlink = avctx->outputs[0];
ScaleVAAPIContext *ctx = avctx->priv;
AVFrame *output_frame = NULL;
VASurfaceID input_surface, output_surface;
VAProcPipelineParameterBuffer params;
VABufferID params_id;
VAStatus vas;
int err;
av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(input_frame->format),
input_frame->width, input_frame->height, input_frame->pts);
if (ctx->va_context == VA_INVALID_ID)
return AVERROR(EINVAL);
input_surface = (VASurfaceID)(uintptr_t)input_frame->data[3];
av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale input.\n",
input_surface);
output_frame = av_frame_alloc();
if (!output_frame) {
av_log(ctx, AV_LOG_ERROR, "Failed to allocate output frame.");
err = AVERROR(ENOMEM);
goto fail;
}
err = av_hwframe_get_buffer(ctx->output_frames_ref, output_frame, 0);
if (err < 0) {
av_log(ctx, AV_LOG_ERROR, "Failed to get surface for "
"output: %d\n.", err);
}
output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale output.\n",
output_surface);
memset(¶ms, 0, sizeof(params));
params.surface = input_surface;
params.surface_region = 0;
params.surface_color_standard =
vaapi_proc_colour_standard(input_frame->colorspace);
params.output_region = 0;
params.output_background_color = 0xff000000;
params.output_color_standard = params.surface_color_standard;
params.pipeline_flags = 0;
params.filter_flags = VA_FILTER_SCALING_HQ;
vas = vaBeginPicture(ctx->hwctx->display,
ctx->va_context, output_surface);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to attach new picture: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
VAProcPipelineParameterBufferType,
sizeof(params), 1, ¶ms, ¶ms_id);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to create parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail_after_begin;
}
av_log(ctx, AV_LOG_DEBUG, "Pipeline parameter buffer is %#x.\n",
params_id);
vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
¶ms_id, 1);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to render parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail_after_begin;
}
vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to start picture processing: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail_after_render;
}
if (ctx->hwctx->driver_quirks &
AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
}
}
av_frame_copy_props(output_frame, input_frame);
av_frame_free(&input_frame);
av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(output_frame->format),
output_frame->width, output_frame->height, output_frame->pts);
return ff_filter_frame(outlink, output_frame);
fail_after_begin:
vaRenderPicture(ctx->hwctx->display, ctx->va_context, ¶ms_id, 1);
fail_after_render:
vaEndPicture(ctx->hwctx->display, ctx->va_context);
fail:
av_frame_free(&input_frame);
av_frame_free(&output_frame);
return err;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFilterLink *VAR_0, AVFrame *VAR_1)
{
AVFilterContext *avctx = VAR_0->dst;
AVFilterLink *outlink = avctx->outputs[0];
ScaleVAAPIContext *ctx = avctx->priv;
AVFrame *output_frame = NULL;
VASurfaceID input_surface, output_surface;
VAProcPipelineParameterBuffer params;
VABufferID params_id;
VAStatus vas;
int VAR_2;
av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(VAR_1->format),
VAR_1->width, VAR_1->height, VAR_1->pts);
if (ctx->va_context == VA_INVALID_ID)
return AVERROR(EINVAL);
input_surface = (VASurfaceID)(uintptr_t)VAR_1->data[3];
av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale input.\n",
input_surface);
output_frame = av_frame_alloc();
if (!output_frame) {
av_log(ctx, AV_LOG_ERROR, "Failed to allocate output frame.");
VAR_2 = AVERROR(ENOMEM);
goto fail;
}
VAR_2 = av_hwframe_get_buffer(ctx->output_frames_ref, output_frame, 0);
if (VAR_2 < 0) {
av_log(ctx, AV_LOG_ERROR, "Failed to get surface for "
"output: %d\n.", VAR_2);
}
output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale output.\n",
output_surface);
memset(¶ms, 0, sizeof(params));
params.surface = input_surface;
params.surface_region = 0;
params.surface_color_standard =
vaapi_proc_colour_standard(VAR_1->colorspace);
params.output_region = 0;
params.output_background_color = 0xff000000;
params.output_color_standard = params.surface_color_standard;
params.pipeline_flags = 0;
params.filter_flags = VA_FILTER_SCALING_HQ;
vas = vaBeginPicture(ctx->hwctx->display,
ctx->va_context, output_surface);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to attach new picture: "
"%d (%s).\n", vas, vaErrorStr(vas));
VAR_2 = AVERROR(EIO);
goto fail;
}
vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
VAProcPipelineParameterBufferType,
sizeof(params), 1, ¶ms, ¶ms_id);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to create parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
VAR_2 = AVERROR(EIO);
goto fail_after_begin;
}
av_log(ctx, AV_LOG_DEBUG, "Pipeline parameter buffer is %#x.\n",
params_id);
vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
¶ms_id, 1);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to render parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
VAR_2 = AVERROR(EIO);
goto fail_after_begin;
}
vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to start picture processing: "
"%d (%s).\n", vas, vaErrorStr(vas));
VAR_2 = AVERROR(EIO);
goto fail_after_render;
}
if (ctx->hwctx->driver_quirks &
AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
if (vas != VA_STATUS_SUCCESS) {
av_log(ctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
"%d (%s).\n", vas, vaErrorStr(vas));
}
}
av_frame_copy_props(output_frame, VAR_1);
av_frame_free(&VAR_1);
av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(output_frame->format),
output_frame->width, output_frame->height, output_frame->pts);
return ff_filter_frame(outlink, output_frame);
fail_after_begin:
vaRenderPicture(ctx->hwctx->display, ctx->va_context, ¶ms_id, 1);
fail_after_render:
vaEndPicture(ctx->hwctx->display, ctx->va_context);
fail:
av_frame_free(&VAR_1);
av_frame_free(&output_frame);
return VAR_2;
}
| [
"static int FUNC_0(AVFilterLink *VAR_0, AVFrame *VAR_1)\n{",
"AVFilterContext *avctx = VAR_0->dst;",
"AVFilterLink *outlink = avctx->outputs[0];",
"ScaleVAAPIContext *ctx = avctx->priv;",
"AVFrame *output_frame = NULL;",
"VASurfaceID input_surface, output_surface;",
"VAProcPipelineParameterBuffer params;",
"VABufferID params_id;",
"VAStatus vas;",
"int VAR_2;",
"av_log(ctx, AV_LOG_DEBUG, \"Filter input: %s, %ux%u (%\"PRId64\").\\n\",\nav_get_pix_fmt_name(VAR_1->format),\nVAR_1->width, VAR_1->height, VAR_1->pts);",
"if (ctx->va_context == VA_INVALID_ID)\nreturn AVERROR(EINVAL);",
"input_surface = (VASurfaceID)(uintptr_t)VAR_1->data[3];",
"av_log(ctx, AV_LOG_DEBUG, \"Using surface %#x for scale input.\\n\",\ninput_surface);",
"output_frame = av_frame_alloc();",
"if (!output_frame) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to allocate output frame.\");",
"VAR_2 = AVERROR(ENOMEM);",
"goto fail;",
"}",
"VAR_2 = av_hwframe_get_buffer(ctx->output_frames_ref, output_frame, 0);",
"if (VAR_2 < 0) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to get surface for \"\n\"output: %d\\n.\", VAR_2);",
"}",
"output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];",
"av_log(ctx, AV_LOG_DEBUG, \"Using surface %#x for scale output.\\n\",\noutput_surface);",
"memset(¶ms, 0, sizeof(params));",
"params.surface = input_surface;",
"params.surface_region = 0;",
"params.surface_color_standard =\nvaapi_proc_colour_standard(VAR_1->colorspace);",
"params.output_region = 0;",
"params.output_background_color = 0xff000000;",
"params.output_color_standard = params.surface_color_standard;",
"params.pipeline_flags = 0;",
"params.filter_flags = VA_FILTER_SCALING_HQ;",
"vas = vaBeginPicture(ctx->hwctx->display,\nctx->va_context, output_surface);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to attach new picture: \"\n\"%d (%s).\\n\", vas, vaErrorStr(vas));",
"VAR_2 = AVERROR(EIO);",
"goto fail;",
"}",
"vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,\nVAProcPipelineParameterBufferType,\nsizeof(params), 1, ¶ms, ¶ms_id);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to create parameter buffer: \"\n\"%d (%s).\\n\", vas, vaErrorStr(vas));",
"VAR_2 = AVERROR(EIO);",
"goto fail_after_begin;",
"}",
"av_log(ctx, AV_LOG_DEBUG, \"Pipeline parameter buffer is %#x.\\n\",\nparams_id);",
"vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,\n¶ms_id, 1);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to render parameter buffer: \"\n\"%d (%s).\\n\", vas, vaErrorStr(vas));",
"VAR_2 = AVERROR(EIO);",
"goto fail_after_begin;",
"}",
"vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to start picture processing: \"\n\"%d (%s).\\n\", vas, vaErrorStr(vas));",
"VAR_2 = AVERROR(EIO);",
"goto fail_after_render;",
"}",
"if (ctx->hwctx->driver_quirks &\nAV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {",
"vas = vaDestroyBuffer(ctx->hwctx->display, params_id);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(ctx, AV_LOG_ERROR, \"Failed to free parameter buffer: \"\n\"%d (%s).\\n\", vas, vaErrorStr(vas));",
"}",
"}",
"av_frame_copy_props(output_frame, VAR_1);",
"av_frame_free(&VAR_1);",
"av_log(ctx, AV_LOG_DEBUG, \"Filter output: %s, %ux%u (%\"PRId64\").\\n\",\nav_get_pix_fmt_name(output_frame->format),\noutput_frame->width, output_frame->height, output_frame->pts);",
"return ff_filter_frame(outlink, output_frame);",
"fail_after_begin:\nvaRenderPicture(ctx->hwctx->display, ctx->va_context, ¶ms_id, 1);",
"fail_after_render:\nvaEndPicture(ctx->hwctx->display, ctx->va_context);",
"fail:\nav_frame_free(&VAR_1);",
"av_frame_free(&output_frame);",
"return VAR_2;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25,
27,
29
],
[
33,
35
],
[
39
],
[
41,
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65,
67
],
[
69
],
[
73
],
[
75,
77
],
[
81
],
[
85
],
[
87
],
[
89,
91
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
109,
111
],
[
113
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
127,
129,
131
],
[
133
],
[
135,
137
],
[
139
],
[
141
],
[
143
],
[
145,
147
],
[
151,
153
],
[
155
],
[
157,
159
],
[
161
],
[
163
],
[
165
],
[
169
],
[
171
],
[
173,
175
],
[
177
],
[
179
],
[
181
],
[
185,
187
],
[
189
],
[
191
],
[
193,
195
],
[
199
],
[
201
],
[
205
],
[
207
],
[
211,
213,
215
],
[
219
],
[
231,
233
],
[
235,
237
],
[
239,
241
],
[
243
],
[
245
],
[
247
]
] |
21,506 | static int get_packet(URLContext *s, int for_header)
{
RTMPContext *rt = s->priv_data;
int ret;
uint8_t *p;
const uint8_t *next;
uint32_t data_size;
uint32_t ts, cts, pts=0;
if (rt->state == STATE_STOPPED)
return AVERROR_EOF;
for (;;) {
RTMPPacket rpkt = { 0 };
if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
rt->chunk_size, rt->prev_pkt[0])) <= 0) {
if (ret == 0) {
return AVERROR(EAGAIN);
} else {
return AVERROR(EIO);
}
}
rt->bytes_read += ret;
if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {
av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
gen_bytes_read(s, rt, rpkt.timestamp + 1);
rt->last_bytes_read = rt->bytes_read;
}
ret = rtmp_parse_result(s, rt, &rpkt);
if (ret < 0) {//serious error in current packet
ff_rtmp_packet_destroy(&rpkt);
return -1;
}
if (rt->state == STATE_STOPPED) {
ff_rtmp_packet_destroy(&rpkt);
return AVERROR_EOF;
}
if (for_header && (rt->state == STATE_PLAYING || rt->state == STATE_PUBLISHING)) {
ff_rtmp_packet_destroy(&rpkt);
return 0;
}
if (!rpkt.data_size || !rt->is_input) {
ff_rtmp_packet_destroy(&rpkt);
continue;
}
if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||
(rpkt.type == RTMP_PT_NOTIFY && !memcmp("\002\000\012onMetaData", rpkt.data, 13))) {
ts = rpkt.timestamp;
// generate packet header and put data into buffer for FLV demuxer
rt->flv_off = 0;
rt->flv_size = rpkt.data_size + 15;
rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);
bytestream_put_byte(&p, rpkt.type);
bytestream_put_be24(&p, rpkt.data_size);
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
bytestream_put_be24(&p, 0);
bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);
bytestream_put_be32(&p, 0);
ff_rtmp_packet_destroy(&rpkt);
return 0;
} else if (rpkt.type == RTMP_PT_METADATA) {
// we got raw FLV data, make it available for FLV demuxer
rt->flv_off = 0;
rt->flv_size = rpkt.data_size;
rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
/* rewrite timestamps */
next = rpkt.data;
ts = rpkt.timestamp;
while (next - rpkt.data < rpkt.data_size - 11) {
next++;
data_size = bytestream_get_be24(&next);
p=next;
cts = bytestream_get_be24(&next);
cts |= bytestream_get_byte(&next) << 24;
if (pts==0)
pts=cts;
ts += cts - pts;
pts = cts;
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
next += data_size + 3 + 4;
}
memcpy(rt->flv_data, rpkt.data, rpkt.data_size);
ff_rtmp_packet_destroy(&rpkt);
return 0;
}
ff_rtmp_packet_destroy(&rpkt);
}
}
| true | FFmpeg | 0849a0ebb2c94856c3a94cb114a1412e44904c28 | static int get_packet(URLContext *s, int for_header)
{
RTMPContext *rt = s->priv_data;
int ret;
uint8_t *p;
const uint8_t *next;
uint32_t data_size;
uint32_t ts, cts, pts=0;
if (rt->state == STATE_STOPPED)
return AVERROR_EOF;
for (;;) {
RTMPPacket rpkt = { 0 };
if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
rt->chunk_size, rt->prev_pkt[0])) <= 0) {
if (ret == 0) {
return AVERROR(EAGAIN);
} else {
return AVERROR(EIO);
}
}
rt->bytes_read += ret;
if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {
av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
gen_bytes_read(s, rt, rpkt.timestamp + 1);
rt->last_bytes_read = rt->bytes_read;
}
ret = rtmp_parse_result(s, rt, &rpkt);
if (ret < 0) {
ff_rtmp_packet_destroy(&rpkt);
return -1;
}
if (rt->state == STATE_STOPPED) {
ff_rtmp_packet_destroy(&rpkt);
return AVERROR_EOF;
}
if (for_header && (rt->state == STATE_PLAYING || rt->state == STATE_PUBLISHING)) {
ff_rtmp_packet_destroy(&rpkt);
return 0;
}
if (!rpkt.data_size || !rt->is_input) {
ff_rtmp_packet_destroy(&rpkt);
continue;
}
if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||
(rpkt.type == RTMP_PT_NOTIFY && !memcmp("\002\000\012onMetaData", rpkt.data, 13))) {
ts = rpkt.timestamp;
rt->flv_off = 0;
rt->flv_size = rpkt.data_size + 15;
rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);
bytestream_put_byte(&p, rpkt.type);
bytestream_put_be24(&p, rpkt.data_size);
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
bytestream_put_be24(&p, 0);
bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);
bytestream_put_be32(&p, 0);
ff_rtmp_packet_destroy(&rpkt);
return 0;
} else if (rpkt.type == RTMP_PT_METADATA) {
rt->flv_off = 0;
rt->flv_size = rpkt.data_size;
rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
next = rpkt.data;
ts = rpkt.timestamp;
while (next - rpkt.data < rpkt.data_size - 11) {
next++;
data_size = bytestream_get_be24(&next);
p=next;
cts = bytestream_get_be24(&next);
cts |= bytestream_get_byte(&next) << 24;
if (pts==0)
pts=cts;
ts += cts - pts;
pts = cts;
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
next += data_size + 3 + 4;
}
memcpy(rt->flv_data, rpkt.data, rpkt.data_size);
ff_rtmp_packet_destroy(&rpkt);
return 0;
}
ff_rtmp_packet_destroy(&rpkt);
}
}
| {
"code": [
" if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {"
],
"line_no": [
47
]
} | static int FUNC_0(URLContext *VAR_0, int VAR_1)
{
RTMPContext *rt = VAR_0->priv_data;
int VAR_2;
uint8_t *p;
const uint8_t *VAR_3;
uint32_t data_size;
uint32_t ts, cts, pts=0;
if (rt->state == STATE_STOPPED)
return AVERROR_EOF;
for (;;) {
RTMPPacket rpkt = { 0 };
if ((VAR_2 = ff_rtmp_packet_read(rt->stream, &rpkt,
rt->chunk_size, rt->prev_pkt[0])) <= 0) {
if (VAR_2 == 0) {
return AVERROR(EAGAIN);
} else {
return AVERROR(EIO);
}
}
rt->bytes_read += VAR_2;
if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {
av_log(VAR_0, AV_LOG_DEBUG, "Sending bytes read report\n");
gen_bytes_read(VAR_0, rt, rpkt.timestamp + 1);
rt->last_bytes_read = rt->bytes_read;
}
VAR_2 = rtmp_parse_result(VAR_0, rt, &rpkt);
if (VAR_2 < 0) {
ff_rtmp_packet_destroy(&rpkt);
return -1;
}
if (rt->state == STATE_STOPPED) {
ff_rtmp_packet_destroy(&rpkt);
return AVERROR_EOF;
}
if (VAR_1 && (rt->state == STATE_PLAYING || rt->state == STATE_PUBLISHING)) {
ff_rtmp_packet_destroy(&rpkt);
return 0;
}
if (!rpkt.data_size || !rt->is_input) {
ff_rtmp_packet_destroy(&rpkt);
continue;
}
if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||
(rpkt.type == RTMP_PT_NOTIFY && !memcmp("\002\000\012onMetaData", rpkt.data, 13))) {
ts = rpkt.timestamp;
rt->flv_off = 0;
rt->flv_size = rpkt.data_size + 15;
rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);
bytestream_put_byte(&p, rpkt.type);
bytestream_put_be24(&p, rpkt.data_size);
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
bytestream_put_be24(&p, 0);
bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);
bytestream_put_be32(&p, 0);
ff_rtmp_packet_destroy(&rpkt);
return 0;
} else if (rpkt.type == RTMP_PT_METADATA) {
rt->flv_off = 0;
rt->flv_size = rpkt.data_size;
rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
VAR_3 = rpkt.data;
ts = rpkt.timestamp;
while (VAR_3 - rpkt.data < rpkt.data_size - 11) {
VAR_3++;
data_size = bytestream_get_be24(&VAR_3);
p=VAR_3;
cts = bytestream_get_be24(&VAR_3);
cts |= bytestream_get_byte(&VAR_3) << 24;
if (pts==0)
pts=cts;
ts += cts - pts;
pts = cts;
bytestream_put_be24(&p, ts);
bytestream_put_byte(&p, ts >> 24);
VAR_3 += data_size + 3 + 4;
}
memcpy(rt->flv_data, rpkt.data, rpkt.data_size);
ff_rtmp_packet_destroy(&rpkt);
return 0;
}
ff_rtmp_packet_destroy(&rpkt);
}
}
| [
"static int FUNC_0(URLContext *VAR_0, int VAR_1)\n{",
"RTMPContext *rt = VAR_0->priv_data;",
"int VAR_2;",
"uint8_t *p;",
"const uint8_t *VAR_3;",
"uint32_t data_size;",
"uint32_t ts, cts, pts=0;",
"if (rt->state == STATE_STOPPED)\nreturn AVERROR_EOF;",
"for (;;) {",
"RTMPPacket rpkt = { 0 };",
"if ((VAR_2 = ff_rtmp_packet_read(rt->stream, &rpkt,\nrt->chunk_size, rt->prev_pkt[0])) <= 0) {",
"if (VAR_2 == 0) {",
"return AVERROR(EAGAIN);",
"} else {",
"return AVERROR(EIO);",
"}",
"}",
"rt->bytes_read += VAR_2;",
"if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {",
"av_log(VAR_0, AV_LOG_DEBUG, \"Sending bytes read report\\n\");",
"gen_bytes_read(VAR_0, rt, rpkt.timestamp + 1);",
"rt->last_bytes_read = rt->bytes_read;",
"}",
"VAR_2 = rtmp_parse_result(VAR_0, rt, &rpkt);",
"if (VAR_2 < 0) {",
"ff_rtmp_packet_destroy(&rpkt);",
"return -1;",
"}",
"if (rt->state == STATE_STOPPED) {",
"ff_rtmp_packet_destroy(&rpkt);",
"return AVERROR_EOF;",
"}",
"if (VAR_1 && (rt->state == STATE_PLAYING || rt->state == STATE_PUBLISHING)) {",
"ff_rtmp_packet_destroy(&rpkt);",
"return 0;",
"}",
"if (!rpkt.data_size || !rt->is_input) {",
"ff_rtmp_packet_destroy(&rpkt);",
"continue;",
"}",
"if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||\n(rpkt.type == RTMP_PT_NOTIFY && !memcmp(\"\\002\\000\\012onMetaData\", rpkt.data, 13))) {",
"ts = rpkt.timestamp;",
"rt->flv_off = 0;",
"rt->flv_size = rpkt.data_size + 15;",
"rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);",
"bytestream_put_byte(&p, rpkt.type);",
"bytestream_put_be24(&p, rpkt.data_size);",
"bytestream_put_be24(&p, ts);",
"bytestream_put_byte(&p, ts >> 24);",
"bytestream_put_be24(&p, 0);",
"bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);",
"bytestream_put_be32(&p, 0);",
"ff_rtmp_packet_destroy(&rpkt);",
"return 0;",
"} else if (rpkt.type == RTMP_PT_METADATA) {",
"rt->flv_off = 0;",
"rt->flv_size = rpkt.data_size;",
"rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);",
"VAR_3 = rpkt.data;",
"ts = rpkt.timestamp;",
"while (VAR_3 - rpkt.data < rpkt.data_size - 11) {",
"VAR_3++;",
"data_size = bytestream_get_be24(&VAR_3);",
"p=VAR_3;",
"cts = bytestream_get_be24(&VAR_3);",
"cts |= bytestream_get_byte(&VAR_3) << 24;",
"if (pts==0)\npts=cts;",
"ts += cts - pts;",
"pts = cts;",
"bytestream_put_be24(&p, ts);",
"bytestream_put_byte(&p, ts >> 24);",
"VAR_3 += data_size + 3 + 4;",
"}",
"memcpy(rt->flv_data, rpkt.data, rpkt.data_size);",
"ff_rtmp_packet_destroy(&rpkt);",
"return 0;",
"}",
"ff_rtmp_packet_destroy(&rpkt);",
"}",
"}"
] | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19,
21
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93,
95
],
[
97
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155,
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
]
] |
21,507 | static void save_display_set(DVBSubContext *ctx)
{
DVBSubRegion *region;
DVBSubRegionDisplay *display;
DVBSubCLUT *clut;
uint32_t *clut_table;
int x_pos, y_pos, width, height;
int x, y, y_off, x_off;
uint32_t *pbuf;
char filename[32];
static int fileno_index = 0;
x_pos = -1;
y_pos = -1;
width = 0;
height = 0;
for (display = ctx->display_list; display; display = display->next) {
region = get_region(ctx, display->region_id);
if (x_pos == -1) {
x_pos = display->x_pos;
y_pos = display->y_pos;
width = region->width;
height = region->height;
} else {
if (display->x_pos < x_pos) {
width += (x_pos - display->x_pos);
x_pos = display->x_pos;
}
if (display->y_pos < y_pos) {
height += (y_pos - display->y_pos);
y_pos = display->y_pos;
}
if (display->x_pos + region->width > x_pos + width) {
width = display->x_pos + region->width - x_pos;
}
if (display->y_pos + region->height > y_pos + height) {
height = display->y_pos + region->height - y_pos;
}
}
}
if (x_pos >= 0) {
pbuf = av_malloc(width * height * 4);
for (display = ctx->display_list; display; display = display->next) {
region = get_region(ctx, display->region_id);
x_off = display->x_pos - x_pos;
y_off = display->y_pos - y_pos;
clut = get_clut(ctx, region->clut);
if (!clut)
clut = &default_clut;
switch (region->depth) {
case 2:
clut_table = clut->clut4;
break;
case 8:
clut_table = clut->clut256;
break;
case 4:
default:
clut_table = clut->clut16;
break;
}
for (y = 0; y < region->height; y++) {
for (x = 0; x < region->width; x++) {
pbuf[((y + y_off) * width) + x_off + x] =
clut_table[region->pbuf[y * region->width + x]];
}
}
}
snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
png_save2(filename, pbuf, width, height);
av_freep(&pbuf);
}
fileno_index++;
} | true | FFmpeg | 8de0990e9f22d7f728f70d5a03f3e78fc958f658 | static void save_display_set(DVBSubContext *ctx)
{
DVBSubRegion *region;
DVBSubRegionDisplay *display;
DVBSubCLUT *clut;
uint32_t *clut_table;
int x_pos, y_pos, width, height;
int x, y, y_off, x_off;
uint32_t *pbuf;
char filename[32];
static int fileno_index = 0;
x_pos = -1;
y_pos = -1;
width = 0;
height = 0;
for (display = ctx->display_list; display; display = display->next) {
region = get_region(ctx, display->region_id);
if (x_pos == -1) {
x_pos = display->x_pos;
y_pos = display->y_pos;
width = region->width;
height = region->height;
} else {
if (display->x_pos < x_pos) {
width += (x_pos - display->x_pos);
x_pos = display->x_pos;
}
if (display->y_pos < y_pos) {
height += (y_pos - display->y_pos);
y_pos = display->y_pos;
}
if (display->x_pos + region->width > x_pos + width) {
width = display->x_pos + region->width - x_pos;
}
if (display->y_pos + region->height > y_pos + height) {
height = display->y_pos + region->height - y_pos;
}
}
}
if (x_pos >= 0) {
pbuf = av_malloc(width * height * 4);
for (display = ctx->display_list; display; display = display->next) {
region = get_region(ctx, display->region_id);
x_off = display->x_pos - x_pos;
y_off = display->y_pos - y_pos;
clut = get_clut(ctx, region->clut);
if (!clut)
clut = &default_clut;
switch (region->depth) {
case 2:
clut_table = clut->clut4;
break;
case 8:
clut_table = clut->clut256;
break;
case 4:
default:
clut_table = clut->clut16;
break;
}
for (y = 0; y < region->height; y++) {
for (x = 0; x < region->width; x++) {
pbuf[((y + y_off) * width) + x_off + x] =
clut_table[region->pbuf[y * region->width + x]];
}
}
}
snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
png_save2(filename, pbuf, width, height);
av_freep(&pbuf);
}
fileno_index++;
} | {
"code": [],
"line_no": []
} | static void FUNC_0(DVBSubContext *VAR_0)
{
DVBSubRegion *region;
DVBSubRegionDisplay *display;
DVBSubCLUT *clut;
uint32_t *clut_table;
int VAR_1, VAR_2, VAR_3, VAR_4;
int VAR_5, VAR_6, VAR_7, VAR_8;
uint32_t *pbuf;
char VAR_9[32];
static int VAR_10 = 0;
VAR_1 = -1;
VAR_2 = -1;
VAR_3 = 0;
VAR_4 = 0;
for (display = VAR_0->display_list; display; display = display->next) {
region = get_region(VAR_0, display->region_id);
if (VAR_1 == -1) {
VAR_1 = display->VAR_1;
VAR_2 = display->VAR_2;
VAR_3 = region->VAR_3;
VAR_4 = region->VAR_4;
} else {
if (display->VAR_1 < VAR_1) {
VAR_3 += (VAR_1 - display->VAR_1);
VAR_1 = display->VAR_1;
}
if (display->VAR_2 < VAR_2) {
VAR_4 += (VAR_2 - display->VAR_2);
VAR_2 = display->VAR_2;
}
if (display->VAR_1 + region->VAR_3 > VAR_1 + VAR_3) {
VAR_3 = display->VAR_1 + region->VAR_3 - VAR_1;
}
if (display->VAR_2 + region->VAR_4 > VAR_2 + VAR_4) {
VAR_4 = display->VAR_2 + region->VAR_4 - VAR_2;
}
}
}
if (VAR_1 >= 0) {
pbuf = av_malloc(VAR_3 * VAR_4 * 4);
for (display = VAR_0->display_list; display; display = display->next) {
region = get_region(VAR_0, display->region_id);
VAR_8 = display->VAR_1 - VAR_1;
VAR_7 = display->VAR_2 - VAR_2;
clut = get_clut(VAR_0, region->clut);
if (!clut)
clut = &default_clut;
switch (region->depth) {
case 2:
clut_table = clut->clut4;
break;
case 8:
clut_table = clut->clut256;
break;
case 4:
default:
clut_table = clut->clut16;
break;
}
for (VAR_6 = 0; VAR_6 < region->VAR_4; VAR_6++) {
for (VAR_5 = 0; VAR_5 < region->VAR_3; VAR_5++) {
pbuf[((VAR_6 + VAR_7) * VAR_3) + VAR_8 + VAR_5] =
clut_table[region->pbuf[VAR_6 * region->VAR_3 + VAR_5]];
}
}
}
snprintf(VAR_9, sizeof(VAR_9), "dvbs.%d", VAR_10);
png_save2(VAR_9, pbuf, VAR_3, VAR_4);
av_freep(&pbuf);
}
VAR_10++;
} | [
"static void FUNC_0(DVBSubContext *VAR_0)\n{",
"DVBSubRegion *region;",
"DVBSubRegionDisplay *display;",
"DVBSubCLUT *clut;",
"uint32_t *clut_table;",
"int VAR_1, VAR_2, VAR_3, VAR_4;",
"int VAR_5, VAR_6, VAR_7, VAR_8;",
"uint32_t *pbuf;",
"char VAR_9[32];",
"static int VAR_10 = 0;",
"VAR_1 = -1;",
"VAR_2 = -1;",
"VAR_3 = 0;",
"VAR_4 = 0;",
"for (display = VAR_0->display_list; display; display = display->next) {",
"region = get_region(VAR_0, display->region_id);",
"if (VAR_1 == -1) {",
"VAR_1 = display->VAR_1;",
"VAR_2 = display->VAR_2;",
"VAR_3 = region->VAR_3;",
"VAR_4 = region->VAR_4;",
"} else {",
"if (display->VAR_1 < VAR_1) {",
"VAR_3 += (VAR_1 - display->VAR_1);",
"VAR_1 = display->VAR_1;",
"}",
"if (display->VAR_2 < VAR_2) {",
"VAR_4 += (VAR_2 - display->VAR_2);",
"VAR_2 = display->VAR_2;",
"}",
"if (display->VAR_1 + region->VAR_3 > VAR_1 + VAR_3) {",
"VAR_3 = display->VAR_1 + region->VAR_3 - VAR_1;",
"}",
"if (display->VAR_2 + region->VAR_4 > VAR_2 + VAR_4) {",
"VAR_4 = display->VAR_2 + region->VAR_4 - VAR_2;",
"}",
"}",
"}",
"if (VAR_1 >= 0) {",
"pbuf = av_malloc(VAR_3 * VAR_4 * 4);",
"for (display = VAR_0->display_list; display; display = display->next) {",
"region = get_region(VAR_0, display->region_id);",
"VAR_8 = display->VAR_1 - VAR_1;",
"VAR_7 = display->VAR_2 - VAR_2;",
"clut = get_clut(VAR_0, region->clut);",
"if (!clut)\nclut = &default_clut;",
"switch (region->depth) {",
"case 2:\nclut_table = clut->clut4;",
"break;",
"case 8:\nclut_table = clut->clut256;",
"break;",
"case 4:\ndefault:\nclut_table = clut->clut16;",
"break;",
"}",
"for (VAR_6 = 0; VAR_6 < region->VAR_4; VAR_6++) {",
"for (VAR_5 = 0; VAR_5 < region->VAR_3; VAR_5++) {",
"pbuf[((VAR_6 + VAR_7) * VAR_3) + VAR_8 + VAR_5] =\nclut_table[region->pbuf[VAR_6 * region->VAR_3 + VAR_5]];",
"}",
"}",
"}",
"snprintf(VAR_9, sizeof(VAR_9), \"dvbs.%d\", VAR_10);",
"png_save2(VAR_9, pbuf, VAR_3, VAR_4);",
"av_freep(&pbuf);",
"}",
"VAR_10++;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
30
],
[
31
],
[
32
],
[
33
],
[
34
],
[
35
],
[
36
],
[
37
],
[
38
],
[
39
],
[
40
],
[
41
],
[
42
],
[
43
],
[
44
],
[
45
],
[
46
],
[
47,
48
],
[
49
],
[
50,
51
],
[
52
],
[
53,
54
],
[
55
],
[
56,
57,
58
],
[
59
],
[
60
],
[
61
],
[
62
],
[
63,
64
],
[
65
],
[
66
],
[
67
],
[
68
],
[
69
],
[
70
],
[
71
],
[
72
],
[
73
]
] |
21,509 | int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
void *log_ctx)
{
char *tail, color_string2[128];
const ColorEntry *entry;
int len, hex_offset = 0;
if (color_string[0] == '#') {
hex_offset = 1;
} else if (!strncmp(color_string, "0x", 2))
hex_offset = 2;
if (slen < 0)
slen = strlen(color_string);
av_strlcpy(color_string2, color_string + hex_offset,
FFMIN(slen-hex_offset+1, sizeof(color_string2)));
if ((tail = strchr(color_string2, ALPHA_SEP)))
*tail++ = 0;
len = strlen(color_string2);
rgba_color[3] = 255;
if (!av_strcasecmp(color_string2, "random") || !av_strcasecmp(color_string2, "bikeshed")) {
int rgba = av_get_random_seed();
rgba_color[0] = rgba >> 24;
rgba_color[1] = rgba >> 16;
rgba_color[2] = rgba >> 8;
rgba_color[3] = rgba;
} else if (hex_offset ||
strspn(color_string2, "0123456789ABCDEFabcdef") == len) {
char *tail;
unsigned int rgba = strtoul(color_string2, &tail, 16);
if (*tail || (len != 6 && len != 8)) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid 0xRRGGBB[AA] color string: '%s'\n", color_string2);
return AVERROR(EINVAL);
}
if (len == 8) {
rgba_color[3] = rgba;
rgba >>= 8;
}
rgba_color[0] = rgba >> 16;
rgba_color[1] = rgba >> 8;
rgba_color[2] = rgba;
} else {
entry = bsearch(color_string2,
color_table,
FF_ARRAY_ELEMS(color_table),
sizeof(ColorEntry),
color_table_compare);
if (!entry) {
av_log(log_ctx, AV_LOG_ERROR, "Cannot find color '%s'\n", color_string2);
return AVERROR(EINVAL);
}
memcpy(rgba_color, entry->rgb_color, 3);
}
if (tail) {
unsigned long int alpha;
const char *alpha_string = tail;
if (!strncmp(alpha_string, "0x", 2)) {
alpha = strtoul(alpha_string, &tail, 16);
} else {
alpha = 255 * strtod(alpha_string, &tail);
}
if (tail == alpha_string || *tail || alpha > 255) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid alpha value specifier '%s' in '%s'\n",
alpha_string, color_string);
return AVERROR(EINVAL);
}
rgba_color[3] = alpha;
}
return 0;
}
| true | FFmpeg | 2b336df3cb9d9bcc12c4b398ea1dbdfe224d152e | int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
void *log_ctx)
{
char *tail, color_string2[128];
const ColorEntry *entry;
int len, hex_offset = 0;
if (color_string[0] == '#') {
hex_offset = 1;
} else if (!strncmp(color_string, "0x", 2))
hex_offset = 2;
if (slen < 0)
slen = strlen(color_string);
av_strlcpy(color_string2, color_string + hex_offset,
FFMIN(slen-hex_offset+1, sizeof(color_string2)));
if ((tail = strchr(color_string2, ALPHA_SEP)))
*tail++ = 0;
len = strlen(color_string2);
rgba_color[3] = 255;
if (!av_strcasecmp(color_string2, "random") || !av_strcasecmp(color_string2, "bikeshed")) {
int rgba = av_get_random_seed();
rgba_color[0] = rgba >> 24;
rgba_color[1] = rgba >> 16;
rgba_color[2] = rgba >> 8;
rgba_color[3] = rgba;
} else if (hex_offset ||
strspn(color_string2, "0123456789ABCDEFabcdef") == len) {
char *tail;
unsigned int rgba = strtoul(color_string2, &tail, 16);
if (*tail || (len != 6 && len != 8)) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid 0xRRGGBB[AA] color string: '%s'\n", color_string2);
return AVERROR(EINVAL);
}
if (len == 8) {
rgba_color[3] = rgba;
rgba >>= 8;
}
rgba_color[0] = rgba >> 16;
rgba_color[1] = rgba >> 8;
rgba_color[2] = rgba;
} else {
entry = bsearch(color_string2,
color_table,
FF_ARRAY_ELEMS(color_table),
sizeof(ColorEntry),
color_table_compare);
if (!entry) {
av_log(log_ctx, AV_LOG_ERROR, "Cannot find color '%s'\n", color_string2);
return AVERROR(EINVAL);
}
memcpy(rgba_color, entry->rgb_color, 3);
}
if (tail) {
unsigned long int alpha;
const char *alpha_string = tail;
if (!strncmp(alpha_string, "0x", 2)) {
alpha = strtoul(alpha_string, &tail, 16);
} else {
alpha = 255 * strtod(alpha_string, &tail);
}
if (tail == alpha_string || *tail || alpha > 255) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid alpha value specifier '%s' in '%s'\n",
alpha_string, color_string);
return AVERROR(EINVAL);
}
rgba_color[3] = alpha;
}
return 0;
}
| {
"code": [
" alpha = 255 * strtod(alpha_string, &tail);"
],
"line_no": [
125
]
} | int FUNC_0(uint8_t *VAR_0, const char *VAR_1, int VAR_2,
void *VAR_3)
{
char *VAR_10, VAR_5[128];
const ColorEntry *VAR_6;
int VAR_7, VAR_8 = 0;
if (VAR_1[0] == '#') {
VAR_8 = 1;
} else if (!strncmp(VAR_1, "0x", 2))
VAR_8 = 2;
if (VAR_2 < 0)
VAR_2 = strlen(VAR_1);
av_strlcpy(VAR_5, VAR_1 + VAR_8,
FFMIN(VAR_2-VAR_8+1, sizeof(VAR_5)));
if ((VAR_10 = strchr(VAR_5, ALPHA_SEP)))
*VAR_10++ = 0;
VAR_7 = strlen(VAR_5);
VAR_0[3] = 255;
if (!av_strcasecmp(VAR_5, "random") || !av_strcasecmp(VAR_5, "bikeshed")) {
int VAR_10 = av_get_random_seed();
VAR_0[0] = VAR_10 >> 24;
VAR_0[1] = VAR_10 >> 16;
VAR_0[2] = VAR_10 >> 8;
VAR_0[3] = VAR_10;
} else if (VAR_8 ||
strspn(VAR_5, "0123456789ABCDEFabcdef") == VAR_7) {
char *VAR_10;
unsigned int VAR_10 = strtoul(VAR_5, &VAR_10, 16);
if (*VAR_10 || (VAR_7 != 6 && VAR_7 != 8)) {
av_log(VAR_3, AV_LOG_ERROR, "Invalid 0xRRGGBB[AA] color string: '%s'\n", VAR_5);
return AVERROR(EINVAL);
}
if (VAR_7 == 8) {
VAR_0[3] = VAR_10;
VAR_10 >>= 8;
}
VAR_0[0] = VAR_10 >> 16;
VAR_0[1] = VAR_10 >> 8;
VAR_0[2] = VAR_10;
} else {
VAR_6 = bsearch(VAR_5,
color_table,
FF_ARRAY_ELEMS(color_table),
sizeof(ColorEntry),
color_table_compare);
if (!VAR_6) {
av_log(VAR_3, AV_LOG_ERROR, "Cannot find color '%s'\n", VAR_5);
return AVERROR(EINVAL);
}
memcpy(VAR_0, VAR_6->rgb_color, 3);
}
if (VAR_10) {
unsigned long int VAR_10;
const char *VAR_11 = VAR_10;
if (!strncmp(VAR_11, "0x", 2)) {
VAR_10 = strtoul(VAR_11, &VAR_10, 16);
} else {
VAR_10 = 255 * strtod(VAR_11, &VAR_10);
}
if (VAR_10 == VAR_11 || *VAR_10 || VAR_10 > 255) {
av_log(VAR_3, AV_LOG_ERROR, "Invalid VAR_10 value specifier '%s' in '%s'\n",
VAR_11, VAR_1);
return AVERROR(EINVAL);
}
VAR_0[3] = VAR_10;
}
return 0;
}
| [
"int FUNC_0(uint8_t *VAR_0, const char *VAR_1, int VAR_2,\nvoid *VAR_3)\n{",
"char *VAR_10, VAR_5[128];",
"const ColorEntry *VAR_6;",
"int VAR_7, VAR_8 = 0;",
"if (VAR_1[0] == '#') {",
"VAR_8 = 1;",
"} else if (!strncmp(VAR_1, \"0x\", 2))",
"VAR_8 = 2;",
"if (VAR_2 < 0)\nVAR_2 = strlen(VAR_1);",
"av_strlcpy(VAR_5, VAR_1 + VAR_8,\nFFMIN(VAR_2-VAR_8+1, sizeof(VAR_5)));",
"if ((VAR_10 = strchr(VAR_5, ALPHA_SEP)))\n*VAR_10++ = 0;",
"VAR_7 = strlen(VAR_5);",
"VAR_0[3] = 255;",
"if (!av_strcasecmp(VAR_5, \"random\") || !av_strcasecmp(VAR_5, \"bikeshed\")) {",
"int VAR_10 = av_get_random_seed();",
"VAR_0[0] = VAR_10 >> 24;",
"VAR_0[1] = VAR_10 >> 16;",
"VAR_0[2] = VAR_10 >> 8;",
"VAR_0[3] = VAR_10;",
"} else if (VAR_8 ||",
"strspn(VAR_5, \"0123456789ABCDEFabcdef\") == VAR_7) {",
"char *VAR_10;",
"unsigned int VAR_10 = strtoul(VAR_5, &VAR_10, 16);",
"if (*VAR_10 || (VAR_7 != 6 && VAR_7 != 8)) {",
"av_log(VAR_3, AV_LOG_ERROR, \"Invalid 0xRRGGBB[AA] color string: '%s'\\n\", VAR_5);",
"return AVERROR(EINVAL);",
"}",
"if (VAR_7 == 8) {",
"VAR_0[3] = VAR_10;",
"VAR_10 >>= 8;",
"}",
"VAR_0[0] = VAR_10 >> 16;",
"VAR_0[1] = VAR_10 >> 8;",
"VAR_0[2] = VAR_10;",
"} else {",
"VAR_6 = bsearch(VAR_5,\ncolor_table,\nFF_ARRAY_ELEMS(color_table),\nsizeof(ColorEntry),\ncolor_table_compare);",
"if (!VAR_6) {",
"av_log(VAR_3, AV_LOG_ERROR, \"Cannot find color '%s'\\n\", VAR_5);",
"return AVERROR(EINVAL);",
"}",
"memcpy(VAR_0, VAR_6->rgb_color, 3);",
"}",
"if (VAR_10) {",
"unsigned long int VAR_10;",
"const char *VAR_11 = VAR_10;",
"if (!strncmp(VAR_11, \"0x\", 2)) {",
"VAR_10 = strtoul(VAR_11, &VAR_10, 16);",
"} else {",
"VAR_10 = 255 * strtod(VAR_11, &VAR_10);",
"}",
"if (VAR_10 == VAR_11 || *VAR_10 || VAR_10 > 255) {",
"av_log(VAR_3, AV_LOG_ERROR, \"Invalid VAR_10 value specifier '%s' in '%s'\\n\",\nVAR_11, VAR_1);",
"return AVERROR(EINVAL);",
"}",
"VAR_0[3] = VAR_10;",
"}",
"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,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25,
27
],
[
29,
31
],
[
33,
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89,
91,
93,
95,
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133,
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149
]
] |
21,510 | int i2c_start_transfer(I2CBus *bus, uint8_t address, int recv)
{
BusChild *kid;
I2CSlaveClass *sc;
I2CNode *node;
if (address == 0x00) {
/*
* This is a broadcast, the current_devs will be all the devices of the
* bus.
*/
bus->broadcast = true;
}
QTAILQ_FOREACH(kid, &bus->qbus.children, sibling) {
DeviceState *qdev = kid->child;
I2CSlave *candidate = I2C_SLAVE(qdev);
if ((candidate->address == address) || (bus->broadcast)) {
node = g_malloc(sizeof(struct I2CNode));
node->elt = candidate;
QLIST_INSERT_HEAD(&bus->current_devs, node, next);
if (!bus->broadcast) {
break;
}
}
}
if (QLIST_EMPTY(&bus->current_devs)) {
return 1;
}
QLIST_FOREACH(node, &bus->current_devs, next) {
sc = I2C_SLAVE_GET_CLASS(node->elt);
/* If the bus is already busy, assume this is a repeated
start condition. */
if (sc->event) {
sc->event(node->elt, recv ? I2C_START_RECV : I2C_START_SEND);
}
}
return 0;
}
| true | qemu | 71ae65e552fc6e03572e430009b98b80b40f1c4d | int i2c_start_transfer(I2CBus *bus, uint8_t address, int recv)
{
BusChild *kid;
I2CSlaveClass *sc;
I2CNode *node;
if (address == 0x00) {
bus->broadcast = true;
}
QTAILQ_FOREACH(kid, &bus->qbus.children, sibling) {
DeviceState *qdev = kid->child;
I2CSlave *candidate = I2C_SLAVE(qdev);
if ((candidate->address == address) || (bus->broadcast)) {
node = g_malloc(sizeof(struct I2CNode));
node->elt = candidate;
QLIST_INSERT_HEAD(&bus->current_devs, node, next);
if (!bus->broadcast) {
break;
}
}
}
if (QLIST_EMPTY(&bus->current_devs)) {
return 1;
}
QLIST_FOREACH(node, &bus->current_devs, next) {
sc = I2C_SLAVE_GET_CLASS(node->elt);
if (sc->event) {
sc->event(node->elt, recv ? I2C_START_RECV : I2C_START_SEND);
}
}
return 0;
}
| {
"code": [
" if (address == 0x00) {"
],
"line_no": [
13
]
} | int FUNC_0(I2CBus *VAR_0, uint8_t VAR_1, int VAR_2)
{
BusChild *kid;
I2CSlaveClass *sc;
I2CNode *node;
if (VAR_1 == 0x00) {
VAR_0->broadcast = true;
}
QTAILQ_FOREACH(kid, &VAR_0->qbus.children, sibling) {
DeviceState *qdev = kid->child;
I2CSlave *candidate = I2C_SLAVE(qdev);
if ((candidate->VAR_1 == VAR_1) || (VAR_0->broadcast)) {
node = g_malloc(sizeof(struct I2CNode));
node->elt = candidate;
QLIST_INSERT_HEAD(&VAR_0->current_devs, node, next);
if (!VAR_0->broadcast) {
break;
}
}
}
if (QLIST_EMPTY(&VAR_0->current_devs)) {
return 1;
}
QLIST_FOREACH(node, &VAR_0->current_devs, next) {
sc = I2C_SLAVE_GET_CLASS(node->elt);
if (sc->event) {
sc->event(node->elt, VAR_2 ? I2C_START_RECV : I2C_START_SEND);
}
}
return 0;
}
| [
"int FUNC_0(I2CBus *VAR_0, uint8_t VAR_1, int VAR_2)\n{",
"BusChild *kid;",
"I2CSlaveClass *sc;",
"I2CNode *node;",
"if (VAR_1 == 0x00) {",
"VAR_0->broadcast = true;",
"}",
"QTAILQ_FOREACH(kid, &VAR_0->qbus.children, sibling) {",
"DeviceState *qdev = kid->child;",
"I2CSlave *candidate = I2C_SLAVE(qdev);",
"if ((candidate->VAR_1 == VAR_1) || (VAR_0->broadcast)) {",
"node = g_malloc(sizeof(struct I2CNode));",
"node->elt = candidate;",
"QLIST_INSERT_HEAD(&VAR_0->current_devs, node, next);",
"if (!VAR_0->broadcast) {",
"break;",
"}",
"}",
"}",
"if (QLIST_EMPTY(&VAR_0->current_devs)) {",
"return 1;",
"}",
"QLIST_FOREACH(node, &VAR_0->current_devs, next) {",
"sc = I2C_SLAVE_GET_CLASS(node->elt);",
"if (sc->event) {",
"sc->event(node->elt, VAR_2 ? I2C_START_RECV : I2C_START_SEND);",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
]
] |
21,512 | void ff_MPV_encode_init_x86(MpegEncContext *s)
{
int mm_flags = av_get_cpu_flags();
const int dct_algo = s->avctx->dct_algo;
if (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX) {
#if HAVE_MMX_INLINE
if (mm_flags & AV_CPU_FLAG_MMX && HAVE_MMX)
s->dct_quantize = dct_quantize_MMX;
#endif
#if HAVE_MMXEXT_INLINE
if (mm_flags & AV_CPU_FLAG_MMXEXT && HAVE_MMXEXT)
s->dct_quantize = dct_quantize_MMX2;
#endif
#if HAVE_SSE2_INLINE
if (mm_flags & AV_CPU_FLAG_SSE2 && HAVE_SSE2)
s->dct_quantize = dct_quantize_SSE2;
#endif
#if HAVE_SSSE3_INLINE
if (mm_flags & AV_CPU_FLAG_SSSE3)
s->dct_quantize = dct_quantize_SSSE3;
#endif
}
}
| false | FFmpeg | e0c6cce44729d94e2a5507a4b6d031f23e8bd7b6 | void ff_MPV_encode_init_x86(MpegEncContext *s)
{
int mm_flags = av_get_cpu_flags();
const int dct_algo = s->avctx->dct_algo;
if (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX) {
#if HAVE_MMX_INLINE
if (mm_flags & AV_CPU_FLAG_MMX && HAVE_MMX)
s->dct_quantize = dct_quantize_MMX;
#endif
#if HAVE_MMXEXT_INLINE
if (mm_flags & AV_CPU_FLAG_MMXEXT && HAVE_MMXEXT)
s->dct_quantize = dct_quantize_MMX2;
#endif
#if HAVE_SSE2_INLINE
if (mm_flags & AV_CPU_FLAG_SSE2 && HAVE_SSE2)
s->dct_quantize = dct_quantize_SSE2;
#endif
#if HAVE_SSSE3_INLINE
if (mm_flags & AV_CPU_FLAG_SSSE3)
s->dct_quantize = dct_quantize_SSSE3;
#endif
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(MpegEncContext *VAR_0)
{
int VAR_1 = av_get_cpu_flags();
const int VAR_2 = VAR_0->avctx->VAR_2;
if (VAR_2 == FF_DCT_AUTO || VAR_2 == FF_DCT_MMX) {
#if HAVE_MMX_INLINE
if (VAR_1 & AV_CPU_FLAG_MMX && HAVE_MMX)
VAR_0->dct_quantize = dct_quantize_MMX;
#endif
#if HAVE_MMXEXT_INLINE
if (VAR_1 & AV_CPU_FLAG_MMXEXT && HAVE_MMXEXT)
VAR_0->dct_quantize = dct_quantize_MMX2;
#endif
#if HAVE_SSE2_INLINE
if (VAR_1 & AV_CPU_FLAG_SSE2 && HAVE_SSE2)
VAR_0->dct_quantize = dct_quantize_SSE2;
#endif
#if HAVE_SSSE3_INLINE
if (VAR_1 & AV_CPU_FLAG_SSSE3)
VAR_0->dct_quantize = dct_quantize_SSSE3;
#endif
}
}
| [
"void FUNC_0(MpegEncContext *VAR_0)\n{",
"int VAR_1 = av_get_cpu_flags();",
"const int VAR_2 = VAR_0->avctx->VAR_2;",
"if (VAR_2 == FF_DCT_AUTO || VAR_2 == FF_DCT_MMX) {",
"#if HAVE_MMX_INLINE\nif (VAR_1 & AV_CPU_FLAG_MMX && HAVE_MMX)\nVAR_0->dct_quantize = dct_quantize_MMX;",
"#endif\n#if HAVE_MMXEXT_INLINE\nif (VAR_1 & AV_CPU_FLAG_MMXEXT && HAVE_MMXEXT)\nVAR_0->dct_quantize = dct_quantize_MMX2;",
"#endif\n#if HAVE_SSE2_INLINE\nif (VAR_1 & AV_CPU_FLAG_SSE2 && HAVE_SSE2)\nVAR_0->dct_quantize = dct_quantize_SSE2;",
"#endif\n#if HAVE_SSSE3_INLINE\nif (VAR_1 & AV_CPU_FLAG_SSSE3)\nVAR_0->dct_quantize = dct_quantize_SSSE3;",
"#endif\n}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15,
17
],
[
19,
21,
23,
25
],
[
27,
29,
31,
33
],
[
35,
37,
39,
41
],
[
43,
45
],
[
47
]
] |
21,514 | static void smbios_build_type_1_fields(void)
{
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str),
type1.manufacturer);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str),
type1.product);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str),
type1.version);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str),
type1.serial);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str),
type1.sku);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str),
type1.family);
if (qemu_uuid_set) {
/* We don't encode the UUID in the "wire format" here because this
* function is for legacy mode and needs to keep the guest ABI, and
* because we don't know what's the SMBIOS version advertised by the
* BIOS.
*/
smbios_add_field(1, offsetof(struct smbios_type_1, uuid),
qemu_uuid, 16);
}
}
| false | qemu | 9c5ce8db2e5c2769ed2fd3d91928dd1853b5ce7c | static void smbios_build_type_1_fields(void)
{
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str),
type1.manufacturer);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str),
type1.product);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str),
type1.version);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str),
type1.serial);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str),
type1.sku);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str),
type1.family);
if (qemu_uuid_set) {
smbios_add_field(1, offsetof(struct smbios_type_1, uuid),
qemu_uuid, 16);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str),
type1.manufacturer);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str),
type1.product);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str),
type1.version);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str),
type1.serial);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str),
type1.sku);
smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str),
type1.family);
if (qemu_uuid_set) {
smbios_add_field(1, offsetof(struct smbios_type_1, uuid),
qemu_uuid, 16);
}
}
| [
"static void FUNC_0(void)\n{",
"smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str),\ntype1.manufacturer);",
"smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str),\ntype1.product);",
"smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str),\ntype1.version);",
"smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str),\ntype1.serial);",
"smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str),\ntype1.sku);",
"smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str),\ntype1.family);",
"if (qemu_uuid_set) {",
"smbios_add_field(1, offsetof(struct smbios_type_1, uuid),\nqemu_uuid, 16);",
"}",
"}"
] | [
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
],
[
41,
43
],
[
45
],
[
47
]
] |
21,515 | static inline int mirror_clip_sectors(MirrorBlockJob *s,
int64_t sector_num,
int nb_sectors)
{
return MIN(nb_sectors,
s->bdev_length / BDRV_SECTOR_SIZE - sector_num);
}
| false | qemu | fb2ef7919bd7b125a2ff6cb70689a7ab93b9d05a | static inline int mirror_clip_sectors(MirrorBlockJob *s,
int64_t sector_num,
int nb_sectors)
{
return MIN(nb_sectors,
s->bdev_length / BDRV_SECTOR_SIZE - sector_num);
}
| {
"code": [],
"line_no": []
} | static inline int FUNC_0(MirrorBlockJob *VAR_0,
int64_t VAR_1,
int VAR_2)
{
return MIN(VAR_2,
VAR_0->bdev_length / BDRV_SECTOR_SIZE - VAR_1);
}
| [
"static inline int FUNC_0(MirrorBlockJob *VAR_0,\nint64_t VAR_1,\nint VAR_2)\n{",
"return MIN(VAR_2,\nVAR_0->bdev_length / BDRV_SECTOR_SIZE - VAR_1);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9,
11
],
[
13
]
] |
21,516 | static void bcm2835_property_mbox_push(BCM2835PropertyState *s, uint32_t value)
{
uint32_t tag;
uint32_t bufsize;
uint32_t tot_len;
size_t resplen;
uint32_t tmp;
value &= ~0xf;
s->addr = value;
tot_len = ldl_phys(&s->dma_as, value);
/* @(addr + 4) : Buffer response code */
value = s->addr + 8;
while (value + 8 <= s->addr + tot_len) {
tag = ldl_phys(&s->dma_as, value);
bufsize = ldl_phys(&s->dma_as, value + 4);
/* @(value + 8) : Request/response indicator */
resplen = 0;
switch (tag) {
case 0x00000000: /* End tag */
break;
case 0x00000001: /* Get firmware revision */
stl_phys(&s->dma_as, value + 12, 346337);
resplen = 4;
break;
case 0x00010001: /* Get board model */
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board model NYI\n", tag);
resplen = 4;
break;
case 0x00010002: /* Get board revision */
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board revision NYI\n", tag);
resplen = 4;
break;
case 0x00010003: /* Get board MAC address */
resplen = sizeof(s->macaddr.a);
dma_memory_write(&s->dma_as, value + 12, s->macaddr.a, resplen);
break;
case 0x00010004: /* Get board serial */
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board serial NYI\n", tag);
resplen = 8;
break;
case 0x00010005: /* Get ARM memory */
/* base */
stl_phys(&s->dma_as, value + 12, 0);
/* size */
stl_phys(&s->dma_as, value + 16, s->ram_size);
resplen = 8;
break;
case 0x00028001: /* Set power state */
/* Assume that whatever device they asked for exists,
* and we'll just claim we set it to the desired state
*/
tmp = ldl_phys(&s->dma_as, value + 16);
stl_phys(&s->dma_as, value + 16, (tmp & 1));
resplen = 8;
break;
/* Clocks */
case 0x00030001: /* Get clock state */
stl_phys(&s->dma_as, value + 16, 0x1);
resplen = 8;
break;
case 0x00038001: /* Set clock state */
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x set clock state NYI\n", tag);
resplen = 8;
break;
case 0x00030002: /* Get clock rate */
case 0x00030004: /* Get max clock rate */
case 0x00030007: /* Get min clock rate */
switch (ldl_phys(&s->dma_as, value + 12)) {
case 1: /* EMMC */
stl_phys(&s->dma_as, value + 16, 50000000);
break;
case 2: /* UART */
stl_phys(&s->dma_as, value + 16, 3000000);
break;
default:
stl_phys(&s->dma_as, value + 16, 700000000);
break;
}
resplen = 8;
break;
case 0x00038002: /* Set clock rate */
case 0x00038004: /* Set max clock rate */
case 0x00038007: /* Set min clock rate */
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x set clock rates NYI\n", tag);
resplen = 8;
break;
/* Temperature */
case 0x00030006: /* Get temperature */
stl_phys(&s->dma_as, value + 16, 25000);
resplen = 8;
break;
case 0x0003000A: /* Get max temperature */
stl_phys(&s->dma_as, value + 16, 99000);
resplen = 8;
break;
case 0x00060001: /* Get DMA channels */
/* channels 2-5 */
stl_phys(&s->dma_as, value + 12, 0x003C);
resplen = 4;
break;
case 0x00050001: /* Get command line */
resplen = 0;
break;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"bcm2835_property: unhandled tag %08x\n", tag);
break;
}
if (tag == 0) {
break;
}
stl_phys(&s->dma_as, value + 8, (1 << 31) | resplen);
value += bufsize + 12;
}
/* Buffer response code */
stl_phys(&s->dma_as, s->addr + 4, (1 << 31));
}
| false | qemu | f0afa73164778570083504a185d7498884c68d65 | static void bcm2835_property_mbox_push(BCM2835PropertyState *s, uint32_t value)
{
uint32_t tag;
uint32_t bufsize;
uint32_t tot_len;
size_t resplen;
uint32_t tmp;
value &= ~0xf;
s->addr = value;
tot_len = ldl_phys(&s->dma_as, value);
value = s->addr + 8;
while (value + 8 <= s->addr + tot_len) {
tag = ldl_phys(&s->dma_as, value);
bufsize = ldl_phys(&s->dma_as, value + 4);
resplen = 0;
switch (tag) {
case 0x00000000:
break;
case 0x00000001:
stl_phys(&s->dma_as, value + 12, 346337);
resplen = 4;
break;
case 0x00010001:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board model NYI\n", tag);
resplen = 4;
break;
case 0x00010002:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board revision NYI\n", tag);
resplen = 4;
break;
case 0x00010003:
resplen = sizeof(s->macaddr.a);
dma_memory_write(&s->dma_as, value + 12, s->macaddr.a, resplen);
break;
case 0x00010004:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board serial NYI\n", tag);
resplen = 8;
break;
case 0x00010005:
stl_phys(&s->dma_as, value + 12, 0);
stl_phys(&s->dma_as, value + 16, s->ram_size);
resplen = 8;
break;
case 0x00028001:
tmp = ldl_phys(&s->dma_as, value + 16);
stl_phys(&s->dma_as, value + 16, (tmp & 1));
resplen = 8;
break;
case 0x00030001:
stl_phys(&s->dma_as, value + 16, 0x1);
resplen = 8;
break;
case 0x00038001:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x set clock state NYI\n", tag);
resplen = 8;
break;
case 0x00030002:
case 0x00030004:
case 0x00030007:
switch (ldl_phys(&s->dma_as, value + 12)) {
case 1:
stl_phys(&s->dma_as, value + 16, 50000000);
break;
case 2:
stl_phys(&s->dma_as, value + 16, 3000000);
break;
default:
stl_phys(&s->dma_as, value + 16, 700000000);
break;
}
resplen = 8;
break;
case 0x00038002:
case 0x00038004:
case 0x00038007:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x set clock rates NYI\n", tag);
resplen = 8;
break;
case 0x00030006:
stl_phys(&s->dma_as, value + 16, 25000);
resplen = 8;
break;
case 0x0003000A:
stl_phys(&s->dma_as, value + 16, 99000);
resplen = 8;
break;
case 0x00060001:
stl_phys(&s->dma_as, value + 12, 0x003C);
resplen = 4;
break;
case 0x00050001:
resplen = 0;
break;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"bcm2835_property: unhandled tag %08x\n", tag);
break;
}
if (tag == 0) {
break;
}
stl_phys(&s->dma_as, value + 8, (1 << 31) | resplen);
value += bufsize + 12;
}
stl_phys(&s->dma_as, s->addr + 4, (1 << 31));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(BCM2835PropertyState *VAR_0, uint32_t VAR_1)
{
uint32_t tag;
uint32_t bufsize;
uint32_t tot_len;
size_t resplen;
uint32_t tmp;
VAR_1 &= ~0xf;
VAR_0->addr = VAR_1;
tot_len = ldl_phys(&VAR_0->dma_as, VAR_1);
VAR_1 = VAR_0->addr + 8;
while (VAR_1 + 8 <= VAR_0->addr + tot_len) {
tag = ldl_phys(&VAR_0->dma_as, VAR_1);
bufsize = ldl_phys(&VAR_0->dma_as, VAR_1 + 4);
resplen = 0;
switch (tag) {
case 0x00000000:
break;
case 0x00000001:
stl_phys(&VAR_0->dma_as, VAR_1 + 12, 346337);
resplen = 4;
break;
case 0x00010001:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board model NYI\n", tag);
resplen = 4;
break;
case 0x00010002:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board revision NYI\n", tag);
resplen = 4;
break;
case 0x00010003:
resplen = sizeof(VAR_0->macaddr.a);
dma_memory_write(&VAR_0->dma_as, VAR_1 + 12, VAR_0->macaddr.a, resplen);
break;
case 0x00010004:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x get board serial NYI\n", tag);
resplen = 8;
break;
case 0x00010005:
stl_phys(&VAR_0->dma_as, VAR_1 + 12, 0);
stl_phys(&VAR_0->dma_as, VAR_1 + 16, VAR_0->ram_size);
resplen = 8;
break;
case 0x00028001:
tmp = ldl_phys(&VAR_0->dma_as, VAR_1 + 16);
stl_phys(&VAR_0->dma_as, VAR_1 + 16, (tmp & 1));
resplen = 8;
break;
case 0x00030001:
stl_phys(&VAR_0->dma_as, VAR_1 + 16, 0x1);
resplen = 8;
break;
case 0x00038001:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x set clock state NYI\n", tag);
resplen = 8;
break;
case 0x00030002:
case 0x00030004:
case 0x00030007:
switch (ldl_phys(&VAR_0->dma_as, VAR_1 + 12)) {
case 1:
stl_phys(&VAR_0->dma_as, VAR_1 + 16, 50000000);
break;
case 2:
stl_phys(&VAR_0->dma_as, VAR_1 + 16, 3000000);
break;
default:
stl_phys(&VAR_0->dma_as, VAR_1 + 16, 700000000);
break;
}
resplen = 8;
break;
case 0x00038002:
case 0x00038004:
case 0x00038007:
qemu_log_mask(LOG_UNIMP,
"bcm2835_property: %x set clock rates NYI\n", tag);
resplen = 8;
break;
case 0x00030006:
stl_phys(&VAR_0->dma_as, VAR_1 + 16, 25000);
resplen = 8;
break;
case 0x0003000A:
stl_phys(&VAR_0->dma_as, VAR_1 + 16, 99000);
resplen = 8;
break;
case 0x00060001:
stl_phys(&VAR_0->dma_as, VAR_1 + 12, 0x003C);
resplen = 4;
break;
case 0x00050001:
resplen = 0;
break;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"bcm2835_property: unhandled tag %08x\n", tag);
break;
}
if (tag == 0) {
break;
}
stl_phys(&VAR_0->dma_as, VAR_1 + 8, (1 << 31) | resplen);
VAR_1 += bufsize + 12;
}
stl_phys(&VAR_0->dma_as, VAR_0->addr + 4, (1 << 31));
}
| [
"static void FUNC_0(BCM2835PropertyState *VAR_0, uint32_t VAR_1)\n{",
"uint32_t tag;",
"uint32_t bufsize;",
"uint32_t tot_len;",
"size_t resplen;",
"uint32_t tmp;",
"VAR_1 &= ~0xf;",
"VAR_0->addr = VAR_1;",
"tot_len = ldl_phys(&VAR_0->dma_as, VAR_1);",
"VAR_1 = VAR_0->addr + 8;",
"while (VAR_1 + 8 <= VAR_0->addr + tot_len) {",
"tag = ldl_phys(&VAR_0->dma_as, VAR_1);",
"bufsize = ldl_phys(&VAR_0->dma_as, VAR_1 + 4);",
"resplen = 0;",
"switch (tag) {",
"case 0x00000000:\nbreak;",
"case 0x00000001:\nstl_phys(&VAR_0->dma_as, VAR_1 + 12, 346337);",
"resplen = 4;",
"break;",
"case 0x00010001:\nqemu_log_mask(LOG_UNIMP,\n\"bcm2835_property: %x get board model NYI\\n\", tag);",
"resplen = 4;",
"break;",
"case 0x00010002:\nqemu_log_mask(LOG_UNIMP,\n\"bcm2835_property: %x get board revision NYI\\n\", tag);",
"resplen = 4;",
"break;",
"case 0x00010003:\nresplen = sizeof(VAR_0->macaddr.a);",
"dma_memory_write(&VAR_0->dma_as, VAR_1 + 12, VAR_0->macaddr.a, resplen);",
"break;",
"case 0x00010004:\nqemu_log_mask(LOG_UNIMP,\n\"bcm2835_property: %x get board serial NYI\\n\", tag);",
"resplen = 8;",
"break;",
"case 0x00010005:\nstl_phys(&VAR_0->dma_as, VAR_1 + 12, 0);",
"stl_phys(&VAR_0->dma_as, VAR_1 + 16, VAR_0->ram_size);",
"resplen = 8;",
"break;",
"case 0x00028001:\ntmp = ldl_phys(&VAR_0->dma_as, VAR_1 + 16);",
"stl_phys(&VAR_0->dma_as, VAR_1 + 16, (tmp & 1));",
"resplen = 8;",
"break;",
"case 0x00030001:\nstl_phys(&VAR_0->dma_as, VAR_1 + 16, 0x1);",
"resplen = 8;",
"break;",
"case 0x00038001:\nqemu_log_mask(LOG_UNIMP,\n\"bcm2835_property: %x set clock state NYI\\n\", tag);",
"resplen = 8;",
"break;",
"case 0x00030002:\ncase 0x00030004:\ncase 0x00030007:\nswitch (ldl_phys(&VAR_0->dma_as, VAR_1 + 12)) {",
"case 1:\nstl_phys(&VAR_0->dma_as, VAR_1 + 16, 50000000);",
"break;",
"case 2:\nstl_phys(&VAR_0->dma_as, VAR_1 + 16, 3000000);",
"break;",
"default:\nstl_phys(&VAR_0->dma_as, VAR_1 + 16, 700000000);",
"break;",
"}",
"resplen = 8;",
"break;",
"case 0x00038002:\ncase 0x00038004:\ncase 0x00038007:\nqemu_log_mask(LOG_UNIMP,\n\"bcm2835_property: %x set clock rates NYI\\n\", tag);",
"resplen = 8;",
"break;",
"case 0x00030006:\nstl_phys(&VAR_0->dma_as, VAR_1 + 16, 25000);",
"resplen = 8;",
"break;",
"case 0x0003000A:\nstl_phys(&VAR_0->dma_as, VAR_1 + 16, 99000);",
"resplen = 8;",
"break;",
"case 0x00060001:\nstl_phys(&VAR_0->dma_as, VAR_1 + 12, 0x003C);",
"resplen = 4;",
"break;",
"case 0x00050001:\nresplen = 0;",
"break;",
"default:\nqemu_log_mask(LOG_GUEST_ERROR,\n\"bcm2835_property: unhandled tag %08x\\n\", tag);",
"break;",
"}",
"if (tag == 0) {",
"break;",
"}",
"stl_phys(&VAR_0->dma_as, VAR_1 + 8, (1 << 31) | resplen);",
"VAR_1 += bufsize + 12;",
"}",
"stl_phys(&VAR_0->dma_as, VAR_0->addr + 4, (1 << 31));",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
25
],
[
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,
99
],
[
103
],
[
105
],
[
107
],
[
109,
117
],
[
119
],
[
121
],
[
123
],
[
131,
133
],
[
135
],
[
137
],
[
141,
143,
145
],
[
147
],
[
149
],
[
153,
155,
157,
159
],
[
161,
163
],
[
165
],
[
167,
169
],
[
171
],
[
173,
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187,
189,
191,
193,
195
],
[
197
],
[
199
],
[
207,
209
],
[
211
],
[
213
],
[
217,
219
],
[
221
],
[
223
],
[
229,
233
],
[
235
],
[
237
],
[
241,
243
],
[
245
],
[
249,
251,
253
],
[
255
],
[
257
],
[
261
],
[
263
],
[
265
],
[
269
],
[
271
],
[
273
],
[
279
],
[
281
]
] |
21,517 | ObjectClass *object_class_dynamic_cast(ObjectClass *class,
const char *typename)
{
TypeImpl *target_type = type_get_by_name(typename);
TypeImpl *type = class->type;
ObjectClass *ret = NULL;
if (type->num_interfaces && type_is_ancestor(target_type, type_interface)) {
int found = 0;
GSList *i;
for (i = class->interfaces; i; i = i->next) {
ObjectClass *target_class = i->data;
if (type_is_ancestor(target_class->type, target_type)) {
ret = target_class;
found++;
}
}
/* The match was ambiguous, don't allow a cast */
if (found > 1) {
ret = NULL;
}
} else if (type_is_ancestor(type, target_type)) {
ret = class;
}
return ret;
}
| false | qemu | 00e2ceae6c55bef40f5128a3e606f5c44351e0f9 | ObjectClass *object_class_dynamic_cast(ObjectClass *class,
const char *typename)
{
TypeImpl *target_type = type_get_by_name(typename);
TypeImpl *type = class->type;
ObjectClass *ret = NULL;
if (type->num_interfaces && type_is_ancestor(target_type, type_interface)) {
int found = 0;
GSList *i;
for (i = class->interfaces; i; i = i->next) {
ObjectClass *target_class = i->data;
if (type_is_ancestor(target_class->type, target_type)) {
ret = target_class;
found++;
}
}
if (found > 1) {
ret = NULL;
}
} else if (type_is_ancestor(type, target_type)) {
ret = class;
}
return ret;
}
| {
"code": [],
"line_no": []
} | ObjectClass *FUNC_0(ObjectClass *class,
const char *typename)
{
TypeImpl *target_type = type_get_by_name(typename);
TypeImpl *type = class->type;
ObjectClass *ret = NULL;
if (type->num_interfaces && type_is_ancestor(target_type, type_interface)) {
int VAR_0 = 0;
GSList *i;
for (i = class->interfaces; i; i = i->next) {
ObjectClass *target_class = i->data;
if (type_is_ancestor(target_class->type, target_type)) {
ret = target_class;
VAR_0++;
}
}
if (VAR_0 > 1) {
ret = NULL;
}
} else if (type_is_ancestor(type, target_type)) {
ret = class;
}
return ret;
}
| [
"ObjectClass *FUNC_0(ObjectClass *class,\nconst char *typename)\n{",
"TypeImpl *target_type = type_get_by_name(typename);",
"TypeImpl *type = class->type;",
"ObjectClass *ret = NULL;",
"if (type->num_interfaces && type_is_ancestor(target_type, type_interface)) {",
"int VAR_0 = 0;",
"GSList *i;",
"for (i = class->interfaces; i; i = i->next) {",
"ObjectClass *target_class = i->data;",
"if (type_is_ancestor(target_class->type, target_type)) {",
"ret = target_class;",
"VAR_0++;",
"}",
"}",
"if (VAR_0 > 1) {",
"ret = NULL;",
"}",
"} else if (type_is_ancestor(type, target_type)) {",
"ret = class;",
"}",
"return ret;",
"}"
] | [
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
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
]
] |
21,518 | static void sdhci_send_command(SDHCIState *s)
{
SDRequest request;
uint8_t response[16];
int rlen;
s->errintsts = 0;
s->acmd12errsts = 0;
request.cmd = s->cmdreg >> 8;
request.arg = s->argument;
DPRINT_L1("sending CMD%u ARG[0x%08x]\n", request.cmd, request.arg);
rlen = sd_do_command(s->card, &request, response);
if (s->cmdreg & SDHC_CMD_RESPONSE) {
if (rlen == 4) {
s->rspreg[0] = (response[0] << 24) | (response[1] << 16) |
(response[2] << 8) | response[3];
s->rspreg[1] = s->rspreg[2] = s->rspreg[3] = 0;
DPRINT_L1("Response: RSPREG[31..0]=0x%08x\n", s->rspreg[0]);
} else if (rlen == 16) {
s->rspreg[0] = (response[11] << 24) | (response[12] << 16) |
(response[13] << 8) | response[14];
s->rspreg[1] = (response[7] << 24) | (response[8] << 16) |
(response[9] << 8) | response[10];
s->rspreg[2] = (response[3] << 24) | (response[4] << 16) |
(response[5] << 8) | response[6];
s->rspreg[3] = (response[0] << 16) | (response[1] << 8) |
response[2];
DPRINT_L1("Response received:\n RSPREG[127..96]=0x%08x, RSPREG[95.."
"64]=0x%08x,\n RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x\n",
s->rspreg[3], s->rspreg[2], s->rspreg[1], s->rspreg[0]);
} else {
ERRPRINT("Timeout waiting for command response\n");
if (s->errintstsen & SDHC_EISEN_CMDTIMEOUT) {
s->errintsts |= SDHC_EIS_CMDTIMEOUT;
s->norintsts |= SDHC_NIS_ERR;
}
}
if ((s->norintstsen & SDHC_NISEN_TRSCMP) &&
(s->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY) {
s->norintsts |= SDHC_NIS_TRSCMP;
}
} else if (rlen != 0 && (s->errintstsen & SDHC_EISEN_CMDIDX)) {
s->errintsts |= SDHC_EIS_CMDIDX;
s->norintsts |= SDHC_NIS_ERR;
}
if (s->norintstsen & SDHC_NISEN_CMDCMP) {
s->norintsts |= SDHC_NIS_CMDCMP;
}
sdhci_update_irq(s);
if (s->blksize && (s->cmdreg & SDHC_CMD_DATA_PRESENT)) {
s->data_count = 0;
sdhci_do_data_transfer(s);
}
}
| false | qemu | d368ba4376b2c1c24175c74b3733b8fe64dbe8a6 | static void sdhci_send_command(SDHCIState *s)
{
SDRequest request;
uint8_t response[16];
int rlen;
s->errintsts = 0;
s->acmd12errsts = 0;
request.cmd = s->cmdreg >> 8;
request.arg = s->argument;
DPRINT_L1("sending CMD%u ARG[0x%08x]\n", request.cmd, request.arg);
rlen = sd_do_command(s->card, &request, response);
if (s->cmdreg & SDHC_CMD_RESPONSE) {
if (rlen == 4) {
s->rspreg[0] = (response[0] << 24) | (response[1] << 16) |
(response[2] << 8) | response[3];
s->rspreg[1] = s->rspreg[2] = s->rspreg[3] = 0;
DPRINT_L1("Response: RSPREG[31..0]=0x%08x\n", s->rspreg[0]);
} else if (rlen == 16) {
s->rspreg[0] = (response[11] << 24) | (response[12] << 16) |
(response[13] << 8) | response[14];
s->rspreg[1] = (response[7] << 24) | (response[8] << 16) |
(response[9] << 8) | response[10];
s->rspreg[2] = (response[3] << 24) | (response[4] << 16) |
(response[5] << 8) | response[6];
s->rspreg[3] = (response[0] << 16) | (response[1] << 8) |
response[2];
DPRINT_L1("Response received:\n RSPREG[127..96]=0x%08x, RSPREG[95.."
"64]=0x%08x,\n RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x\n",
s->rspreg[3], s->rspreg[2], s->rspreg[1], s->rspreg[0]);
} else {
ERRPRINT("Timeout waiting for command response\n");
if (s->errintstsen & SDHC_EISEN_CMDTIMEOUT) {
s->errintsts |= SDHC_EIS_CMDTIMEOUT;
s->norintsts |= SDHC_NIS_ERR;
}
}
if ((s->norintstsen & SDHC_NISEN_TRSCMP) &&
(s->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY) {
s->norintsts |= SDHC_NIS_TRSCMP;
}
} else if (rlen != 0 && (s->errintstsen & SDHC_EISEN_CMDIDX)) {
s->errintsts |= SDHC_EIS_CMDIDX;
s->norintsts |= SDHC_NIS_ERR;
}
if (s->norintstsen & SDHC_NISEN_CMDCMP) {
s->norintsts |= SDHC_NIS_CMDCMP;
}
sdhci_update_irq(s);
if (s->blksize && (s->cmdreg & SDHC_CMD_DATA_PRESENT)) {
s->data_count = 0;
sdhci_do_data_transfer(s);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(SDHCIState *VAR_0)
{
SDRequest request;
uint8_t response[16];
int VAR_1;
VAR_0->errintsts = 0;
VAR_0->acmd12errsts = 0;
request.cmd = VAR_0->cmdreg >> 8;
request.arg = VAR_0->argument;
DPRINT_L1("sending CMD%u ARG[0x%08x]\n", request.cmd, request.arg);
VAR_1 = sd_do_command(VAR_0->card, &request, response);
if (VAR_0->cmdreg & SDHC_CMD_RESPONSE) {
if (VAR_1 == 4) {
VAR_0->rspreg[0] = (response[0] << 24) | (response[1] << 16) |
(response[2] << 8) | response[3];
VAR_0->rspreg[1] = VAR_0->rspreg[2] = VAR_0->rspreg[3] = 0;
DPRINT_L1("Response: RSPREG[31..0]=0x%08x\n", VAR_0->rspreg[0]);
} else if (VAR_1 == 16) {
VAR_0->rspreg[0] = (response[11] << 24) | (response[12] << 16) |
(response[13] << 8) | response[14];
VAR_0->rspreg[1] = (response[7] << 24) | (response[8] << 16) |
(response[9] << 8) | response[10];
VAR_0->rspreg[2] = (response[3] << 24) | (response[4] << 16) |
(response[5] << 8) | response[6];
VAR_0->rspreg[3] = (response[0] << 16) | (response[1] << 8) |
response[2];
DPRINT_L1("Response received:\n RSPREG[127..96]=0x%08x, RSPREG[95.."
"64]=0x%08x,\n RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x\n",
VAR_0->rspreg[3], VAR_0->rspreg[2], VAR_0->rspreg[1], VAR_0->rspreg[0]);
} else {
ERRPRINT("Timeout waiting for command response\n");
if (VAR_0->errintstsen & SDHC_EISEN_CMDTIMEOUT) {
VAR_0->errintsts |= SDHC_EIS_CMDTIMEOUT;
VAR_0->norintsts |= SDHC_NIS_ERR;
}
}
if ((VAR_0->norintstsen & SDHC_NISEN_TRSCMP) &&
(VAR_0->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY) {
VAR_0->norintsts |= SDHC_NIS_TRSCMP;
}
} else if (VAR_1 != 0 && (VAR_0->errintstsen & SDHC_EISEN_CMDIDX)) {
VAR_0->errintsts |= SDHC_EIS_CMDIDX;
VAR_0->norintsts |= SDHC_NIS_ERR;
}
if (VAR_0->norintstsen & SDHC_NISEN_CMDCMP) {
VAR_0->norintsts |= SDHC_NIS_CMDCMP;
}
sdhci_update_irq(VAR_0);
if (VAR_0->blksize && (VAR_0->cmdreg & SDHC_CMD_DATA_PRESENT)) {
VAR_0->data_count = 0;
sdhci_do_data_transfer(VAR_0);
}
}
| [
"static void FUNC_0(SDHCIState *VAR_0)\n{",
"SDRequest request;",
"uint8_t response[16];",
"int VAR_1;",
"VAR_0->errintsts = 0;",
"VAR_0->acmd12errsts = 0;",
"request.cmd = VAR_0->cmdreg >> 8;",
"request.arg = VAR_0->argument;",
"DPRINT_L1(\"sending CMD%u ARG[0x%08x]\\n\", request.cmd, request.arg);",
"VAR_1 = sd_do_command(VAR_0->card, &request, response);",
"if (VAR_0->cmdreg & SDHC_CMD_RESPONSE) {",
"if (VAR_1 == 4) {",
"VAR_0->rspreg[0] = (response[0] << 24) | (response[1] << 16) |\n(response[2] << 8) | response[3];",
"VAR_0->rspreg[1] = VAR_0->rspreg[2] = VAR_0->rspreg[3] = 0;",
"DPRINT_L1(\"Response: RSPREG[31..0]=0x%08x\\n\", VAR_0->rspreg[0]);",
"} else if (VAR_1 == 16) {",
"VAR_0->rspreg[0] = (response[11] << 24) | (response[12] << 16) |\n(response[13] << 8) | response[14];",
"VAR_0->rspreg[1] = (response[7] << 24) | (response[8] << 16) |\n(response[9] << 8) | response[10];",
"VAR_0->rspreg[2] = (response[3] << 24) | (response[4] << 16) |\n(response[5] << 8) | response[6];",
"VAR_0->rspreg[3] = (response[0] << 16) | (response[1] << 8) |\nresponse[2];",
"DPRINT_L1(\"Response received:\\n RSPREG[127..96]=0x%08x, RSPREG[95..\"\n\"64]=0x%08x,\\n RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x\\n\",\nVAR_0->rspreg[3], VAR_0->rspreg[2], VAR_0->rspreg[1], VAR_0->rspreg[0]);",
"} else {",
"ERRPRINT(\"Timeout waiting for command response\\n\");",
"if (VAR_0->errintstsen & SDHC_EISEN_CMDTIMEOUT) {",
"VAR_0->errintsts |= SDHC_EIS_CMDTIMEOUT;",
"VAR_0->norintsts |= SDHC_NIS_ERR;",
"}",
"}",
"if ((VAR_0->norintstsen & SDHC_NISEN_TRSCMP) &&\n(VAR_0->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY) {",
"VAR_0->norintsts |= SDHC_NIS_TRSCMP;",
"}",
"} else if (VAR_1 != 0 && (VAR_0->errintstsen & SDHC_EISEN_CMDIDX)) {",
"VAR_0->errintsts |= SDHC_EIS_CMDIDX;",
"VAR_0->norintsts |= SDHC_NIS_ERR;",
"}",
"if (VAR_0->norintstsen & SDHC_NISEN_CMDCMP) {",
"VAR_0->norintsts |= SDHC_NIS_CMDCMP;",
"}",
"sdhci_update_irq(VAR_0);",
"if (VAR_0->blksize && (VAR_0->cmdreg & SDHC_CMD_DATA_PRESENT)) {",
"VAR_0->data_count = 0;",
"sdhci_do_data_transfer(VAR_0);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
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
],
[
79,
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
97
],
[
99
],
[
101
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
]
] |
21,519 | static void ss5_init(int ram_size, int vga_ram_size, int boot_device,
DisplayState *ds, const char **fd_filename, int snapshot,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
if (cpu_model == NULL)
cpu_model = "Fujitsu MB86904";
sun4m_common_init(ram_size, boot_device, ds, kernel_filename,
kernel_cmdline, initrd_filename, cpu_model,
0);
}
| false | qemu | 4edebb0e8e14a5b934114b5ff74cb86437bb2532 | static void ss5_init(int ram_size, int vga_ram_size, int boot_device,
DisplayState *ds, const char **fd_filename, int snapshot,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
if (cpu_model == NULL)
cpu_model = "Fujitsu MB86904";
sun4m_common_init(ram_size, boot_device, ds, kernel_filename,
kernel_cmdline, initrd_filename, cpu_model,
0);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(int VAR_0, int VAR_1, int VAR_2,
DisplayState *VAR_3, const char **VAR_4, int VAR_5,
const char *VAR_6, const char *VAR_7,
const char *VAR_8, const char *VAR_9)
{
if (VAR_9 == NULL)
VAR_9 = "Fujitsu MB86904";
sun4m_common_init(VAR_0, VAR_2, VAR_3, VAR_6,
VAR_7, VAR_8, VAR_9,
0);
}
| [
"static void FUNC_0(int VAR_0, int VAR_1, int VAR_2,\nDisplayState *VAR_3, const char **VAR_4, int VAR_5,\nconst char *VAR_6, const char *VAR_7,\nconst char *VAR_8, const char *VAR_9)\n{",
"if (VAR_9 == NULL)\nVAR_9 = \"Fujitsu MB86904\";",
"sun4m_common_init(VAR_0, VAR_2, VAR_3, VAR_6,\nVAR_7, VAR_8, VAR_9,\n0);",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11,
13
],
[
15,
17,
19
],
[
21
]
] |
21,520 | const char *qemu_opt_get(QemuOpts *opts, const char *name)
{
QemuOpt *opt = qemu_opt_find(opts, name);
if (!opt) {
const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name);
if (desc && desc->def_value_str) {
return desc->def_value_str;
}
}
return opt ? opt->str : NULL;
}
| false | qemu | 435db4cf29b88b6612e30acda01cd18788dff458 | const char *qemu_opt_get(QemuOpts *opts, const char *name)
{
QemuOpt *opt = qemu_opt_find(opts, name);
if (!opt) {
const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name);
if (desc && desc->def_value_str) {
return desc->def_value_str;
}
}
return opt ? opt->str : NULL;
}
| {
"code": [],
"line_no": []
} | const char *FUNC_0(QemuOpts *VAR_0, const char *VAR_1)
{
QemuOpt *opt = qemu_opt_find(VAR_0, VAR_1);
if (!opt) {
const QemuOptDesc *VAR_2 = find_desc_by_name(VAR_0->list->VAR_2, VAR_1);
if (VAR_2 && VAR_2->def_value_str) {
return VAR_2->def_value_str;
}
}
return opt ? opt->str : NULL;
}
| [
"const char *FUNC_0(QemuOpts *VAR_0, const char *VAR_1)\n{",
"QemuOpt *opt = qemu_opt_find(VAR_0, VAR_1);",
"if (!opt) {",
"const QemuOptDesc *VAR_2 = find_desc_by_name(VAR_0->list->VAR_2, VAR_1);",
"if (VAR_2 && VAR_2->def_value_str) {",
"return VAR_2->def_value_str;",
"}",
"}",
"return opt ? opt->str : NULL;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
21,521 | void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
{
QEMUTimer **pt, *t;
qemu_del_timer(ts);
/* add the timer in the sorted list */
/* NOTE: this code must be signal safe because
qemu_timer_expired() can be called from a signal. */
pt = &active_timers[ts->clock->type];
for(;;) {
t = *pt;
if (!t)
break;
if (t->expire_time > expire_time)
break;
pt = &t->next;
}
ts->expire_time = expire_time;
ts->next = *pt;
*pt = ts;
/* Rearm if necessary */
if (pt == &active_timers[ts->clock->type]) {
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
qemu_rearm_alarm_timer(alarm_timer);
}
/* Interrupt execution to force deadline recalculation. */
if (use_icount)
qemu_notify_event();
}
}
| false | qemu | cd48d7e8f322cdb05692b023b168816ed6306fc4 | void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
{
QEMUTimer **pt, *t;
qemu_del_timer(ts);
pt = &active_timers[ts->clock->type];
for(;;) {
t = *pt;
if (!t)
break;
if (t->expire_time > expire_time)
break;
pt = &t->next;
}
ts->expire_time = expire_time;
ts->next = *pt;
*pt = ts;
if (pt == &active_timers[ts->clock->type]) {
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
qemu_rearm_alarm_timer(alarm_timer);
}
if (use_icount)
qemu_notify_event();
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(QEMUTimer *VAR_0, int64_t VAR_1)
{
QEMUTimer **pt, *t;
qemu_del_timer(VAR_0);
pt = &active_timers[VAR_0->clock->type];
for(;;) {
t = *pt;
if (!t)
break;
if (t->VAR_1 > VAR_1)
break;
pt = &t->next;
}
VAR_0->VAR_1 = VAR_1;
VAR_0->next = *pt;
*pt = VAR_0;
if (pt == &active_timers[VAR_0->clock->type]) {
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
qemu_rearm_alarm_timer(alarm_timer);
}
if (use_icount)
qemu_notify_event();
}
}
| [
"void FUNC_0(QEMUTimer *VAR_0, int64_t VAR_1)\n{",
"QEMUTimer **pt, *t;",
"qemu_del_timer(VAR_0);",
"pt = &active_timers[VAR_0->clock->type];",
"for(;;) {",
"t = *pt;",
"if (!t)\nbreak;",
"if (t->VAR_1 > VAR_1)\nbreak;",
"pt = &t->next;",
"}",
"VAR_0->VAR_1 = VAR_1;",
"VAR_0->next = *pt;",
"*pt = VAR_0;",
"if (pt == &active_timers[VAR_0->clock->type]) {",
"if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {",
"qemu_rearm_alarm_timer(alarm_timer);",
"}",
"if (use_icount)\nqemu_notify_event();",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57,
59
],
[
61
],
[
63
]
] |
21,522 | static void qemu_system_suspend(void)
{
pause_all_vcpus();
notifier_list_notify(&suspend_notifiers, NULL);
runstate_set(RUN_STATE_SUSPENDED);
monitor_protocol_event(QEVENT_SUSPEND, NULL);
is_suspended = true;
}
| false | qemu | 9abc62f6445795522d1bf5bf17f642e44eaf032d | static void qemu_system_suspend(void)
{
pause_all_vcpus();
notifier_list_notify(&suspend_notifiers, NULL);
runstate_set(RUN_STATE_SUSPENDED);
monitor_protocol_event(QEVENT_SUSPEND, NULL);
is_suspended = true;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
pause_all_vcpus();
notifier_list_notify(&suspend_notifiers, NULL);
runstate_set(RUN_STATE_SUSPENDED);
monitor_protocol_event(QEVENT_SUSPEND, NULL);
is_suspended = true;
}
| [
"static void FUNC_0(void)\n{",
"pause_all_vcpus();",
"notifier_list_notify(&suspend_notifiers, NULL);",
"runstate_set(RUN_STATE_SUSPENDED);",
"monitor_protocol_event(QEVENT_SUSPEND, NULL);",
"is_suspended = true;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
21,523 | static void RENAME(yuv2rgb565_1)(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, enum PixelFormat dstFormat,
int flags, int y)
{
const uint16_t *buf1= buf0; //FIXME needed for RGB1/BGR1
if (uvalpha < 2048) { // note this is not correct (shifts chrominance by 0.5 pixels) but it is a bit faster
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5)
"pxor %%mm7, %%mm7 \n\t"
/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
#ifdef DITHER1XBPP
"paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
"paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
"paddusb "RED_DITHER"(%5), %%mm5 \n\t"
#endif
WRITERGB16(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5)
"pxor %%mm7, %%mm7 \n\t"
/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
#ifdef DITHER1XBPP
"paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
"paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
"paddusb "RED_DITHER"(%5), %%mm5 \n\t"
#endif
WRITERGB16(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
}
}
| false | FFmpeg | 13a099799e89a76eb921ca452e1b04a7a28a9855 | static void RENAME(yuv2rgb565_1)(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, enum PixelFormat dstFormat,
int flags, int y)
{
const uint16_t *buf1= buf0;
if (uvalpha < 2048) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5)
"pxor %%mm7, %%mm7 \n\t"
#ifdef DITHER1XBPP
"paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
"paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
"paddusb "RED_DITHER"(%5), %%mm5 \n\t"
#endif
WRITERGB16(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5)
"pxor %%mm7, %%mm7 \n\t"
#ifdef DITHER1XBPP
"paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
"paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
"paddusb "RED_DITHER"(%5), %%mm5 \n\t"
#endif
WRITERGB16(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(yuv2rgb565_1)(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, enum PixelFormat dstFormat,
int flags, int y)
{
const uint16_t *VAR_0= buf0;
if (uvalpha < 2048) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5)
"pxor %%mm7, %%mm7 \n\t"
#ifdef DITHER1XBPP
"paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
"paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
"paddusb "RED_DITHER"(%5), %%mm5 \n\t"
#endif
WRITERGB16(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (VAR_0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5)
"pxor %%mm7, %%mm7 \n\t"
#ifdef DITHER1XBPP
"paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
"paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
"paddusb "RED_DITHER"(%5), %%mm5 \n\t"
#endif
WRITERGB16(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (VAR_0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
}
}
| [
"static void FUNC_0(yuv2rgb565_1)(SwsContext *c, const uint16_t *buf0,\nconst uint16_t *ubuf0, const uint16_t *ubuf1,\nconst uint16_t *vbuf0, const uint16_t *vbuf1,\nconst uint16_t *abuf0, uint8_t *dest,\nint dstW, int uvalpha, enum PixelFormat dstFormat,\nint flags, int y)\n{",
"const uint16_t *VAR_0= buf0;",
"if (uvalpha < 2048) {",
"__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1(%%REGBP, %5)\n\"pxor %%mm7, %%mm7 \\n\\t\"\n#ifdef DITHER1XBPP\n\"paddusb \"BLUE_DITHER\"(%5), %%mm2 \\n\\t\"\n\"paddusb \"GREEN_DITHER\"(%5), %%mm4 \\n\\t\"\n\"paddusb \"RED_DITHER\"(%5), %%mm5 \\n\\t\"\n#endif\nWRITERGB16(%%REGb, 8280(%5), %%REGBP)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);",
"} else {",
"__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1b(%%REGBP, %5)\n\"pxor %%mm7, %%mm7 \\n\\t\"\n#ifdef DITHER1XBPP\n\"paddusb \"BLUE_DITHER\"(%5), %%mm2 \\n\\t\"\n\"paddusb \"GREEN_DITHER\"(%5), %%mm4 \\n\\t\"\n\"paddusb \"RED_DITHER\"(%5), %%mm5 \\n\\t\"\n#endif\nWRITERGB16(%%REGb, 8280(%5), %%REGBP)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither)\n);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
19
],
[
21,
23,
25,
27,
29,
31,
35,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55
],
[
57
],
[
59,
61,
63,
65,
67,
69,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93
],
[
95
],
[
97
]
] |
21,524 | static void numa_node_parse_cpus(int nodenr, const char *cpus)
{
char *endptr;
unsigned long long value, endvalue;
value = strtoull(cpus, &endptr, 10);
if (*endptr == '-') {
endvalue = strtoull(endptr+1, &endptr, 10);
} else {
endvalue = value;
}
if (!(endvalue < MAX_CPUMASK_BITS)) {
endvalue = MAX_CPUMASK_BITS - 1;
fprintf(stderr,
"A max of %d CPUs are supported in a guest\n",
MAX_CPUMASK_BITS);
}
bitmap_set(node_cpumask[nodenr], value, endvalue-value+1);
}
| false | qemu | c881e20eed4911ab6f8c674f2b1bf225a2cdde71 | static void numa_node_parse_cpus(int nodenr, const char *cpus)
{
char *endptr;
unsigned long long value, endvalue;
value = strtoull(cpus, &endptr, 10);
if (*endptr == '-') {
endvalue = strtoull(endptr+1, &endptr, 10);
} else {
endvalue = value;
}
if (!(endvalue < MAX_CPUMASK_BITS)) {
endvalue = MAX_CPUMASK_BITS - 1;
fprintf(stderr,
"A max of %d CPUs are supported in a guest\n",
MAX_CPUMASK_BITS);
}
bitmap_set(node_cpumask[nodenr], value, endvalue-value+1);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(int VAR_0, const char *VAR_1)
{
char *VAR_2;
unsigned long long VAR_3, VAR_4;
VAR_3 = strtoull(VAR_1, &VAR_2, 10);
if (*VAR_2 == '-') {
VAR_4 = strtoull(VAR_2+1, &VAR_2, 10);
} else {
VAR_4 = VAR_3;
}
if (!(VAR_4 < MAX_CPUMASK_BITS)) {
VAR_4 = MAX_CPUMASK_BITS - 1;
fprintf(stderr,
"A max of %d CPUs are supported in a guest\n",
MAX_CPUMASK_BITS);
}
bitmap_set(node_cpumask[VAR_0], VAR_3, VAR_4-VAR_3+1);
}
| [
"static void FUNC_0(int VAR_0, const char *VAR_1)\n{",
"char *VAR_2;",
"unsigned long long VAR_3, VAR_4;",
"VAR_3 = strtoull(VAR_1, &VAR_2, 10);",
"if (*VAR_2 == '-') {",
"VAR_4 = strtoull(VAR_2+1, &VAR_2, 10);",
"} else {",
"VAR_4 = VAR_3;",
"}",
"if (!(VAR_4 < MAX_CPUMASK_BITS)) {",
"VAR_4 = MAX_CPUMASK_BITS - 1;",
"fprintf(stderr,\n\"A max of %d CPUs are supported in a guest\\n\",\nMAX_CPUMASK_BITS);",
"}",
"bitmap_set(node_cpumask[VAR_0], VAR_3, VAR_4-VAR_3+1);",
"}"
] | [
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
],
[
25
],
[
27
],
[
29,
31,
33
],
[
35
],
[
39
],
[
41
]
] |
21,525 | static void icount_dummy_timer(void *opaque)
{
(void)opaque;
}
| false | qemu | e76d1798faa6d29f54c0930a034b67f3ecdb947d | static void icount_dummy_timer(void *opaque)
{
(void)opaque;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
(void)VAR_0;
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"(void)VAR_0;",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
21,526 | static int gdb_set_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
{
if (n < 32) {
env->fpr[n] = ldfq_p(mem_buf);
return 8;
}
if (n == 32) {
/* FPSCR not implemented */
return 4;
}
return 0;
}
| false | qemu | d6478bc7e92db4669fac701d7bb8c51756b61d8a | static int gdb_set_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
{
if (n < 32) {
env->fpr[n] = ldfq_p(mem_buf);
return 8;
}
if (n == 32) {
return 4;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(CPUPPCState *VAR_0, uint8_t *VAR_1, int VAR_2)
{
if (VAR_2 < 32) {
VAR_0->fpr[VAR_2] = ldfq_p(VAR_1);
return 8;
}
if (VAR_2 == 32) {
return 4;
}
return 0;
}
| [
"static int FUNC_0(CPUPPCState *VAR_0, uint8_t *VAR_1, int VAR_2)\n{",
"if (VAR_2 < 32) {",
"VAR_0->fpr[VAR_2] = ldfq_p(VAR_1);",
"return 8;",
"}",
"if (VAR_2 == 32) {",
"return 4;",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
21,527 | static inline void decode(DisasContext *dc)
{
uint32_t ir;
int i;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
tcg_gen_debug_insn_start(dc->pc);
}
dc->ir = ir = ldl_code(dc->pc);
LOG_DIS("%8.8x\t", dc->ir);
/* try guessing 'empty' instruction memory, although it may be a valid
* instruction sequence (eg. srui r0, r0, 0) */
if (dc->ir) {
dc->nr_nops = 0;
} else {
LOG_DIS("nr_nops=%d\t", dc->nr_nops);
dc->nr_nops++;
if (dc->nr_nops > 4) {
cpu_abort(dc->env, "fetching nop sequence\n");
}
}
dc->opcode = EXTRACT_FIELD(ir, 26, 31);
dc->imm5 = EXTRACT_FIELD(ir, 0, 4);
dc->imm16 = EXTRACT_FIELD(ir, 0, 15);
dc->imm26 = EXTRACT_FIELD(ir, 0, 25);
dc->csr = EXTRACT_FIELD(ir, 21, 25);
dc->r0 = EXTRACT_FIELD(ir, 21, 25);
dc->r1 = EXTRACT_FIELD(ir, 16, 20);
dc->r2 = EXTRACT_FIELD(ir, 11, 15);
/* bit 31 seems to indicate insn type. */
if (ir & (1 << 31)) {
dc->format = OP_FMT_RR;
} else {
dc->format = OP_FMT_RI;
}
/* Large switch for all insns. */
for (i = 0; i < ARRAY_SIZE(decinfo); i++) {
if ((dc->opcode & decinfo[i].mask) == decinfo[i].bits) {
decinfo[i].dec(dc);
return;
}
}
cpu_abort(dc->env, "unknown opcode 0x%02x\n", dc->opcode);
}
| false | qemu | a5086f95421e43c7b9e1b28a111aae0be4848117 | static inline void decode(DisasContext *dc)
{
uint32_t ir;
int i;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
tcg_gen_debug_insn_start(dc->pc);
}
dc->ir = ir = ldl_code(dc->pc);
LOG_DIS("%8.8x\t", dc->ir);
if (dc->ir) {
dc->nr_nops = 0;
} else {
LOG_DIS("nr_nops=%d\t", dc->nr_nops);
dc->nr_nops++;
if (dc->nr_nops > 4) {
cpu_abort(dc->env, "fetching nop sequence\n");
}
}
dc->opcode = EXTRACT_FIELD(ir, 26, 31);
dc->imm5 = EXTRACT_FIELD(ir, 0, 4);
dc->imm16 = EXTRACT_FIELD(ir, 0, 15);
dc->imm26 = EXTRACT_FIELD(ir, 0, 25);
dc->csr = EXTRACT_FIELD(ir, 21, 25);
dc->r0 = EXTRACT_FIELD(ir, 21, 25);
dc->r1 = EXTRACT_FIELD(ir, 16, 20);
dc->r2 = EXTRACT_FIELD(ir, 11, 15);
if (ir & (1 << 31)) {
dc->format = OP_FMT_RR;
} else {
dc->format = OP_FMT_RI;
}
for (i = 0; i < ARRAY_SIZE(decinfo); i++) {
if ((dc->opcode & decinfo[i].mask) == decinfo[i].bits) {
decinfo[i].dec(dc);
return;
}
}
cpu_abort(dc->env, "unknown opcode 0x%02x\n", dc->opcode);
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(DisasContext *VAR_0)
{
uint32_t ir;
int VAR_1;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
tcg_gen_debug_insn_start(VAR_0->pc);
}
VAR_0->ir = ir = ldl_code(VAR_0->pc);
LOG_DIS("%8.8x\t", VAR_0->ir);
if (VAR_0->ir) {
VAR_0->nr_nops = 0;
} else {
LOG_DIS("nr_nops=%d\t", VAR_0->nr_nops);
VAR_0->nr_nops++;
if (VAR_0->nr_nops > 4) {
cpu_abort(VAR_0->env, "fetching nop sequence\n");
}
}
VAR_0->opcode = EXTRACT_FIELD(ir, 26, 31);
VAR_0->imm5 = EXTRACT_FIELD(ir, 0, 4);
VAR_0->imm16 = EXTRACT_FIELD(ir, 0, 15);
VAR_0->imm26 = EXTRACT_FIELD(ir, 0, 25);
VAR_0->csr = EXTRACT_FIELD(ir, 21, 25);
VAR_0->r0 = EXTRACT_FIELD(ir, 21, 25);
VAR_0->r1 = EXTRACT_FIELD(ir, 16, 20);
VAR_0->r2 = EXTRACT_FIELD(ir, 11, 15);
if (ir & (1 << 31)) {
VAR_0->format = OP_FMT_RR;
} else {
VAR_0->format = OP_FMT_RI;
}
for (VAR_1 = 0; VAR_1 < ARRAY_SIZE(decinfo); VAR_1++) {
if ((VAR_0->opcode & decinfo[VAR_1].mask) == decinfo[VAR_1].bits) {
decinfo[VAR_1].dec(VAR_0);
return;
}
}
cpu_abort(VAR_0->env, "unknown opcode 0x%02x\n", VAR_0->opcode);
}
| [
"static inline void FUNC_0(DisasContext *VAR_0)\n{",
"uint32_t ir;",
"int VAR_1;",
"if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {",
"tcg_gen_debug_insn_start(VAR_0->pc);",
"}",
"VAR_0->ir = ir = ldl_code(VAR_0->pc);",
"LOG_DIS(\"%8.8x\\t\", VAR_0->ir);",
"if (VAR_0->ir) {",
"VAR_0->nr_nops = 0;",
"} else {",
"LOG_DIS(\"nr_nops=%d\\t\", VAR_0->nr_nops);",
"VAR_0->nr_nops++;",
"if (VAR_0->nr_nops > 4) {",
"cpu_abort(VAR_0->env, \"fetching nop sequence\\n\");",
"}",
"}",
"VAR_0->opcode = EXTRACT_FIELD(ir, 26, 31);",
"VAR_0->imm5 = EXTRACT_FIELD(ir, 0, 4);",
"VAR_0->imm16 = EXTRACT_FIELD(ir, 0, 15);",
"VAR_0->imm26 = EXTRACT_FIELD(ir, 0, 25);",
"VAR_0->csr = EXTRACT_FIELD(ir, 21, 25);",
"VAR_0->r0 = EXTRACT_FIELD(ir, 21, 25);",
"VAR_0->r1 = EXTRACT_FIELD(ir, 16, 20);",
"VAR_0->r2 = EXTRACT_FIELD(ir, 11, 15);",
"if (ir & (1 << 31)) {",
"VAR_0->format = OP_FMT_RR;",
"} else {",
"VAR_0->format = OP_FMT_RI;",
"}",
"for (VAR_1 = 0; VAR_1 < ARRAY_SIZE(decinfo); VAR_1++) {",
"if ((VAR_0->opcode & decinfo[VAR_1].mask) == decinfo[VAR_1].bits) {",
"decinfo[VAR_1].dec(VAR_0);",
"return;",
"}",
"}",
"cpu_abort(VAR_0->env, \"unknown opcode 0x%02x\\n\", VAR_0->opcode);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101
],
[
103
]
] |
21,528 | void memory_region_init_iommu(MemoryRegion *mr,
Object *owner,
const MemoryRegionIOMMUOps *ops,
const char *name,
uint64_t size)
{
memory_region_init(mr, owner, name, size);
mr->iommu_ops = ops,
mr->terminates = true; /* then re-forwards */
notifier_list_init(&mr->iommu_notify);
}
| false | qemu | cdb3081269347fd9271fd1b7a9df312e2953bdd9 | void memory_region_init_iommu(MemoryRegion *mr,
Object *owner,
const MemoryRegionIOMMUOps *ops,
const char *name,
uint64_t size)
{
memory_region_init(mr, owner, name, size);
mr->iommu_ops = ops,
mr->terminates = true;
notifier_list_init(&mr->iommu_notify);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(MemoryRegion *VAR_0,
Object *VAR_1,
const MemoryRegionIOMMUOps *VAR_2,
const char *VAR_3,
uint64_t VAR_4)
{
memory_region_init(VAR_0, VAR_1, VAR_3, VAR_4);
VAR_0->iommu_ops = VAR_2,
VAR_0->terminates = true;
notifier_list_init(&VAR_0->iommu_notify);
}
| [
"void FUNC_0(MemoryRegion *VAR_0,\nObject *VAR_1,\nconst MemoryRegionIOMMUOps *VAR_2,\nconst char *VAR_3,\nuint64_t VAR_4)\n{",
"memory_region_init(VAR_0, VAR_1, VAR_3, VAR_4);",
"VAR_0->iommu_ops = VAR_2,\nVAR_0->terminates = true;",
"notifier_list_init(&VAR_0->iommu_notify);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15,
17
],
[
19
],
[
21
]
] |
21,529 | void helper_movl_drN_T0(CPUX86State *env, int reg, target_ulong t0)
{
#ifndef CONFIG_USER_ONLY
if (reg < 4) {
if (hw_breakpoint_enabled(env->dr[7], reg)
&& hw_breakpoint_type(env->dr[7], reg) != DR7_TYPE_IO_RW) {
hw_breakpoint_remove(env, reg);
env->dr[reg] = t0;
hw_breakpoint_insert(env, reg);
} else {
env->dr[reg] = t0;
}
} else if (reg == 7) {
cpu_x86_update_dr7(env, t0);
} else {
env->dr[reg] = t0;
}
#endif
}
| false | qemu | d0052339236072bbf08c1d600c0906126b1ab258 | void helper_movl_drN_T0(CPUX86State *env, int reg, target_ulong t0)
{
#ifndef CONFIG_USER_ONLY
if (reg < 4) {
if (hw_breakpoint_enabled(env->dr[7], reg)
&& hw_breakpoint_type(env->dr[7], reg) != DR7_TYPE_IO_RW) {
hw_breakpoint_remove(env, reg);
env->dr[reg] = t0;
hw_breakpoint_insert(env, reg);
} else {
env->dr[reg] = t0;
}
} else if (reg == 7) {
cpu_x86_update_dr7(env, t0);
} else {
env->dr[reg] = t0;
}
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUX86State *VAR_0, int VAR_1, target_ulong VAR_2)
{
#ifndef CONFIG_USER_ONLY
if (VAR_1 < 4) {
if (hw_breakpoint_enabled(VAR_0->dr[7], VAR_1)
&& hw_breakpoint_type(VAR_0->dr[7], VAR_1) != DR7_TYPE_IO_RW) {
hw_breakpoint_remove(VAR_0, VAR_1);
VAR_0->dr[VAR_1] = VAR_2;
hw_breakpoint_insert(VAR_0, VAR_1);
} else {
VAR_0->dr[VAR_1] = VAR_2;
}
} else if (VAR_1 == 7) {
cpu_x86_update_dr7(VAR_0, VAR_2);
} else {
VAR_0->dr[VAR_1] = VAR_2;
}
#endif
}
| [
"void FUNC_0(CPUX86State *VAR_0, int VAR_1, target_ulong VAR_2)\n{",
"#ifndef CONFIG_USER_ONLY\nif (VAR_1 < 4) {",
"if (hw_breakpoint_enabled(VAR_0->dr[7], VAR_1)\n&& hw_breakpoint_type(VAR_0->dr[7], VAR_1) != DR7_TYPE_IO_RW) {",
"hw_breakpoint_remove(VAR_0, VAR_1);",
"VAR_0->dr[VAR_1] = VAR_2;",
"hw_breakpoint_insert(VAR_0, VAR_1);",
"} else {",
"VAR_0->dr[VAR_1] = VAR_2;",
"}",
"} else if (VAR_1 == 7) {",
"cpu_x86_update_dr7(VAR_0, VAR_2);",
"} else {",
"VAR_0->dr[VAR_1] = VAR_2;",
"}",
"#endif\n}"
] | [
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
]
] |
21,530 | QDict *qdict_new(void)
{
QDict *qdict;
qdict = g_malloc0(sizeof(*qdict));
QOBJECT_INIT(qdict, &qdict_type);
return qdict;
}
| false | qemu | 55e1819c509b3d9c10a54678b9c585bbda13889e | QDict *qdict_new(void)
{
QDict *qdict;
qdict = g_malloc0(sizeof(*qdict));
QOBJECT_INIT(qdict, &qdict_type);
return qdict;
}
| {
"code": [],
"line_no": []
} | QDict *FUNC_0(void)
{
QDict *qdict;
qdict = g_malloc0(sizeof(*qdict));
QOBJECT_INIT(qdict, &qdict_type);
return qdict;
}
| [
"QDict *FUNC_0(void)\n{",
"QDict *qdict;",
"qdict = g_malloc0(sizeof(*qdict));",
"QOBJECT_INIT(qdict, &qdict_type);",
"return qdict;",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
15
],
[
17
]
] |
21,532 | int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
unsigned int *bytes, uint64_t *cluster_offset)
{
BDRVQcow2State *s = bs->opaque;
unsigned int l2_index;
uint64_t l1_index, l2_offset, *l2_table;
int l1_bits, c;
unsigned int offset_in_cluster;
uint64_t bytes_available, bytes_needed, nb_clusters;
int ret;
offset_in_cluster = offset_into_cluster(s, offset);
bytes_needed = (uint64_t) *bytes + offset_in_cluster;
l1_bits = s->l2_bits + s->cluster_bits;
/* compute how many bytes there are between the start of the cluster
* containing offset and the end of the l1 entry */
bytes_available = (1ULL << l1_bits) - (offset & ((1ULL << l1_bits) - 1))
+ offset_in_cluster;
if (bytes_needed > bytes_available) {
bytes_needed = bytes_available;
}
*cluster_offset = 0;
/* seek to the l2 offset in the l1 table */
l1_index = offset >> l1_bits;
if (l1_index >= s->l1_size) {
ret = QCOW2_CLUSTER_UNALLOCATED;
goto out;
}
l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
if (!l2_offset) {
ret = QCOW2_CLUSTER_UNALLOCATED;
goto out;
}
if (offset_into_cluster(s, l2_offset)) {
qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64
" unaligned (L1 index: %#" PRIx64 ")",
l2_offset, l1_index);
return -EIO;
}
/* load the l2 table in memory */
ret = l2_load(bs, l2_offset, &l2_table);
if (ret < 0) {
return ret;
}
/* find the cluster offset for the given disk offset */
l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
*cluster_offset = be64_to_cpu(l2_table[l2_index]);
nb_clusters = size_to_clusters(s, bytes_needed);
/* bytes_needed <= *bytes + offset_in_cluster, both of which are unsigned
* integers; the minimum cluster size is 512, so this assertion is always
* true */
assert(nb_clusters <= INT_MAX);
ret = qcow2_get_cluster_type(*cluster_offset);
switch (ret) {
case QCOW2_CLUSTER_COMPRESSED:
/* Compressed clusters can only be processed one by one */
c = 1;
*cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
break;
case QCOW2_CLUSTER_ZERO:
if (s->qcow_version < 3) {
qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found"
" in pre-v3 image (L2 offset: %#" PRIx64
", L2 index: %#x)", l2_offset, l2_index);
ret = -EIO;
goto fail;
}
c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index],
QCOW2_CLUSTER_ZERO);
*cluster_offset = 0;
break;
case QCOW2_CLUSTER_UNALLOCATED:
/* how many empty clusters ? */
c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index],
QCOW2_CLUSTER_UNALLOCATED);
*cluster_offset = 0;
break;
case QCOW2_CLUSTER_NORMAL:
/* how many allocated clusters ? */
c = count_contiguous_clusters(nb_clusters, s->cluster_size,
&l2_table[l2_index], QCOW_OFLAG_ZERO);
*cluster_offset &= L2E_OFFSET_MASK;
if (offset_into_cluster(s, *cluster_offset)) {
qcow2_signal_corruption(bs, true, -1, -1, "Data cluster offset %#"
PRIx64 " unaligned (L2 offset: %#" PRIx64
", L2 index: %#x)", *cluster_offset,
l2_offset, l2_index);
ret = -EIO;
goto fail;
}
break;
default:
abort();
}
qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
bytes_available = (int64_t)c * s->cluster_size;
out:
if (bytes_available > bytes_needed) {
bytes_available = bytes_needed;
}
/* bytes_available <= bytes_needed <= *bytes + offset_in_cluster;
* subtracting offset_in_cluster will therefore definitely yield something
* not exceeding UINT_MAX */
assert(bytes_available - offset_in_cluster <= UINT_MAX);
*bytes = bytes_available - offset_in_cluster;
return ret;
fail:
qcow2_cache_put(bs, s->l2_table_cache, (void **)&l2_table);
return ret;
}
| false | qemu | 4341df8a83d6a528a1e2855735f87fc3aab42b70 | int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
unsigned int *bytes, uint64_t *cluster_offset)
{
BDRVQcow2State *s = bs->opaque;
unsigned int l2_index;
uint64_t l1_index, l2_offset, *l2_table;
int l1_bits, c;
unsigned int offset_in_cluster;
uint64_t bytes_available, bytes_needed, nb_clusters;
int ret;
offset_in_cluster = offset_into_cluster(s, offset);
bytes_needed = (uint64_t) *bytes + offset_in_cluster;
l1_bits = s->l2_bits + s->cluster_bits;
bytes_available = (1ULL << l1_bits) - (offset & ((1ULL << l1_bits) - 1))
+ offset_in_cluster;
if (bytes_needed > bytes_available) {
bytes_needed = bytes_available;
}
*cluster_offset = 0;
l1_index = offset >> l1_bits;
if (l1_index >= s->l1_size) {
ret = QCOW2_CLUSTER_UNALLOCATED;
goto out;
}
l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
if (!l2_offset) {
ret = QCOW2_CLUSTER_UNALLOCATED;
goto out;
}
if (offset_into_cluster(s, l2_offset)) {
qcow2_signal_corruption(bs, true, -1, -1, "L2 table offset %#" PRIx64
" unaligned (L1 index: %#" PRIx64 ")",
l2_offset, l1_index);
return -EIO;
}
ret = l2_load(bs, l2_offset, &l2_table);
if (ret < 0) {
return ret;
}
l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
*cluster_offset = be64_to_cpu(l2_table[l2_index]);
nb_clusters = size_to_clusters(s, bytes_needed);
assert(nb_clusters <= INT_MAX);
ret = qcow2_get_cluster_type(*cluster_offset);
switch (ret) {
case QCOW2_CLUSTER_COMPRESSED:
c = 1;
*cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
break;
case QCOW2_CLUSTER_ZERO:
if (s->qcow_version < 3) {
qcow2_signal_corruption(bs, true, -1, -1, "Zero cluster entry found"
" in pre-v3 image (L2 offset: %#" PRIx64
", L2 index: %#x)", l2_offset, l2_index);
ret = -EIO;
goto fail;
}
c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index],
QCOW2_CLUSTER_ZERO);
*cluster_offset = 0;
break;
case QCOW2_CLUSTER_UNALLOCATED:
c = count_contiguous_clusters_by_type(nb_clusters, &l2_table[l2_index],
QCOW2_CLUSTER_UNALLOCATED);
*cluster_offset = 0;
break;
case QCOW2_CLUSTER_NORMAL:
c = count_contiguous_clusters(nb_clusters, s->cluster_size,
&l2_table[l2_index], QCOW_OFLAG_ZERO);
*cluster_offset &= L2E_OFFSET_MASK;
if (offset_into_cluster(s, *cluster_offset)) {
qcow2_signal_corruption(bs, true, -1, -1, "Data cluster offset %#"
PRIx64 " unaligned (L2 offset: %#" PRIx64
", L2 index: %#x)", *cluster_offset,
l2_offset, l2_index);
ret = -EIO;
goto fail;
}
break;
default:
abort();
}
qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
bytes_available = (int64_t)c * s->cluster_size;
out:
if (bytes_available > bytes_needed) {
bytes_available = bytes_needed;
}
assert(bytes_available - offset_in_cluster <= UINT_MAX);
*bytes = bytes_available - offset_in_cluster;
return ret;
fail:
qcow2_cache_put(bs, s->l2_table_cache, (void **)&l2_table);
return ret;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,
unsigned int *VAR_2, uint64_t *VAR_3)
{
BDRVQcow2State *s = VAR_0->opaque;
unsigned int VAR_4;
uint64_t l1_index, l2_offset, *l2_table;
int VAR_5, VAR_6;
unsigned int VAR_7;
uint64_t bytes_available, bytes_needed, nb_clusters;
int VAR_8;
VAR_7 = offset_into_cluster(s, VAR_1);
bytes_needed = (uint64_t) *VAR_2 + VAR_7;
VAR_5 = s->l2_bits + s->cluster_bits;
bytes_available = (1ULL << VAR_5) - (VAR_1 & ((1ULL << VAR_5) - 1))
+ VAR_7;
if (bytes_needed > bytes_available) {
bytes_needed = bytes_available;
}
*VAR_3 = 0;
l1_index = VAR_1 >> VAR_5;
if (l1_index >= s->l1_size) {
VAR_8 = QCOW2_CLUSTER_UNALLOCATED;
goto out;
}
l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;
if (!l2_offset) {
VAR_8 = QCOW2_CLUSTER_UNALLOCATED;
goto out;
}
if (offset_into_cluster(s, l2_offset)) {
qcow2_signal_corruption(VAR_0, true, -1, -1, "L2 table VAR_1 %#" PRIx64
" unaligned (L1 index: %#" PRIx64 ")",
l2_offset, l1_index);
return -EIO;
}
VAR_8 = l2_load(VAR_0, l2_offset, &l2_table);
if (VAR_8 < 0) {
return VAR_8;
}
VAR_4 = (VAR_1 >> s->cluster_bits) & (s->l2_size - 1);
*VAR_3 = be64_to_cpu(l2_table[VAR_4]);
nb_clusters = size_to_clusters(s, bytes_needed);
assert(nb_clusters <= INT_MAX);
VAR_8 = qcow2_get_cluster_type(*VAR_3);
switch (VAR_8) {
case QCOW2_CLUSTER_COMPRESSED:
VAR_6 = 1;
*VAR_3 &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
break;
case QCOW2_CLUSTER_ZERO:
if (s->qcow_version < 3) {
qcow2_signal_corruption(VAR_0, true, -1, -1, "Zero cluster entry found"
" in pre-v3 image (L2 VAR_1: %#" PRIx64
", L2 index: %#x)", l2_offset, VAR_4);
VAR_8 = -EIO;
goto fail;
}
VAR_6 = count_contiguous_clusters_by_type(nb_clusters, &l2_table[VAR_4],
QCOW2_CLUSTER_ZERO);
*VAR_3 = 0;
break;
case QCOW2_CLUSTER_UNALLOCATED:
VAR_6 = count_contiguous_clusters_by_type(nb_clusters, &l2_table[VAR_4],
QCOW2_CLUSTER_UNALLOCATED);
*VAR_3 = 0;
break;
case QCOW2_CLUSTER_NORMAL:
VAR_6 = count_contiguous_clusters(nb_clusters, s->cluster_size,
&l2_table[VAR_4], QCOW_OFLAG_ZERO);
*VAR_3 &= L2E_OFFSET_MASK;
if (offset_into_cluster(s, *VAR_3)) {
qcow2_signal_corruption(VAR_0, true, -1, -1, "Data cluster VAR_1 %#"
PRIx64 " unaligned (L2 VAR_1: %#" PRIx64
", L2 index: %#x)", *VAR_3,
l2_offset, VAR_4);
VAR_8 = -EIO;
goto fail;
}
break;
default:
abort();
}
qcow2_cache_put(VAR_0, s->l2_table_cache, (void**) &l2_table);
bytes_available = (int64_t)VAR_6 * s->cluster_size;
out:
if (bytes_available > bytes_needed) {
bytes_available = bytes_needed;
}
assert(bytes_available - VAR_7 <= UINT_MAX);
*VAR_2 = bytes_available - VAR_7;
return VAR_8;
fail:
qcow2_cache_put(VAR_0, s->l2_table_cache, (void **)&l2_table);
return VAR_8;
}
| [
"int FUNC_0(BlockDriverState *VAR_0, uint64_t VAR_1,\nunsigned int *VAR_2, uint64_t *VAR_3)\n{",
"BDRVQcow2State *s = VAR_0->opaque;",
"unsigned int VAR_4;",
"uint64_t l1_index, l2_offset, *l2_table;",
"int VAR_5, VAR_6;",
"unsigned int VAR_7;",
"uint64_t bytes_available, bytes_needed, nb_clusters;",
"int VAR_8;",
"VAR_7 = offset_into_cluster(s, VAR_1);",
"bytes_needed = (uint64_t) *VAR_2 + VAR_7;",
"VAR_5 = s->l2_bits + s->cluster_bits;",
"bytes_available = (1ULL << VAR_5) - (VAR_1 & ((1ULL << VAR_5) - 1))\n+ VAR_7;",
"if (bytes_needed > bytes_available) {",
"bytes_needed = bytes_available;",
"}",
"*VAR_3 = 0;",
"l1_index = VAR_1 >> VAR_5;",
"if (l1_index >= s->l1_size) {",
"VAR_8 = QCOW2_CLUSTER_UNALLOCATED;",
"goto out;",
"}",
"l2_offset = s->l1_table[l1_index] & L1E_OFFSET_MASK;",
"if (!l2_offset) {",
"VAR_8 = QCOW2_CLUSTER_UNALLOCATED;",
"goto out;",
"}",
"if (offset_into_cluster(s, l2_offset)) {",
"qcow2_signal_corruption(VAR_0, true, -1, -1, \"L2 table VAR_1 %#\" PRIx64\n\" unaligned (L1 index: %#\" PRIx64 \")\",\nl2_offset, l1_index);",
"return -EIO;",
"}",
"VAR_8 = l2_load(VAR_0, l2_offset, &l2_table);",
"if (VAR_8 < 0) {",
"return VAR_8;",
"}",
"VAR_4 = (VAR_1 >> s->cluster_bits) & (s->l2_size - 1);",
"*VAR_3 = be64_to_cpu(l2_table[VAR_4]);",
"nb_clusters = size_to_clusters(s, bytes_needed);",
"assert(nb_clusters <= INT_MAX);",
"VAR_8 = qcow2_get_cluster_type(*VAR_3);",
"switch (VAR_8) {",
"case QCOW2_CLUSTER_COMPRESSED:\nVAR_6 = 1;",
"*VAR_3 &= L2E_COMPRESSED_OFFSET_SIZE_MASK;",
"break;",
"case QCOW2_CLUSTER_ZERO:\nif (s->qcow_version < 3) {",
"qcow2_signal_corruption(VAR_0, true, -1, -1, \"Zero cluster entry found\"\n\" in pre-v3 image (L2 VAR_1: %#\" PRIx64\n\", L2 index: %#x)\", l2_offset, VAR_4);",
"VAR_8 = -EIO;",
"goto fail;",
"}",
"VAR_6 = count_contiguous_clusters_by_type(nb_clusters, &l2_table[VAR_4],\nQCOW2_CLUSTER_ZERO);",
"*VAR_3 = 0;",
"break;",
"case QCOW2_CLUSTER_UNALLOCATED:\nVAR_6 = count_contiguous_clusters_by_type(nb_clusters, &l2_table[VAR_4],\nQCOW2_CLUSTER_UNALLOCATED);",
"*VAR_3 = 0;",
"break;",
"case QCOW2_CLUSTER_NORMAL:\nVAR_6 = count_contiguous_clusters(nb_clusters, s->cluster_size,\n&l2_table[VAR_4], QCOW_OFLAG_ZERO);",
"*VAR_3 &= L2E_OFFSET_MASK;",
"if (offset_into_cluster(s, *VAR_3)) {",
"qcow2_signal_corruption(VAR_0, true, -1, -1, \"Data cluster VAR_1 %#\"\nPRIx64 \" unaligned (L2 VAR_1: %#\" PRIx64\n\", L2 index: %#x)\", *VAR_3,\nl2_offset, VAR_4);",
"VAR_8 = -EIO;",
"goto fail;",
"}",
"break;",
"default:\nabort();",
"}",
"qcow2_cache_put(VAR_0, s->l2_table_cache, (void**) &l2_table);",
"bytes_available = (int64_t)VAR_6 * s->cluster_size;",
"out:\nif (bytes_available > bytes_needed) {",
"bytes_available = bytes_needed;",
"}",
"assert(bytes_available - VAR_7 <= UINT_MAX);",
"*VAR_2 = bytes_available - VAR_7;",
"return VAR_8;",
"fail:\nqcow2_cache_put(VAR_0, s->l2_table_cache, (void **)&l2_table);",
"return VAR_8;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
37,
39
],
[
43
],
[
45
],
[
47
],
[
51
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85,
87,
89
],
[
91
],
[
93
],
[
101
],
[
103
],
[
105
],
[
107
],
[
115
],
[
117
],
[
121
],
[
129
],
[
133
],
[
135
],
[
137,
141
],
[
143
],
[
145
],
[
147,
149
],
[
151,
153,
155
],
[
157
],
[
159
],
[
161
],
[
163,
165
],
[
167
],
[
169
],
[
171,
175,
177
],
[
179
],
[
181
],
[
183,
187,
189
],
[
191
],
[
193
],
[
195,
197,
199,
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211,
213
],
[
215
],
[
219
],
[
223
],
[
227,
229
],
[
231
],
[
233
],
[
243
],
[
245
],
[
249
],
[
253,
255
],
[
257
],
[
259
]
] |
21,533 | mips_mipssim_init (ram_addr_t ram_size, int vga_ram_size,
const char *boot_device, DisplayState *ds,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
char buf[1024];
unsigned long bios_offset;
CPUState *env;
int bios_size;
/* Init CPUs. */
if (cpu_model == NULL) {
#ifdef TARGET_MIPS64
cpu_model = "5Kf";
#else
cpu_model = "24Kf";
#endif
}
env = cpu_init(cpu_model);
if (!env) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
qemu_register_reset(main_cpu_reset, env);
/* Allocate RAM. */
cpu_register_physical_memory(0, ram_size, IO_MEM_RAM);
/* Load a BIOS / boot exception handler image. */
bios_offset = ram_size + vga_ram_size;
if (bios_name == NULL)
bios_name = BIOS_FILENAME;
snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name);
bios_size = load_image(buf, phys_ram_base + bios_offset);
if ((bios_size < 0 || bios_size > BIOS_SIZE) && !kernel_filename) {
/* Bail out if we have neither a kernel image nor boot vector code. */
fprintf(stderr,
"qemu: Could not load MIPS bios '%s', and no -kernel argument was specified\n",
buf);
exit(1);
} else {
/* Map the BIOS / boot exception handler. */
cpu_register_physical_memory(0x1fc00000LL,
bios_size, bios_offset | IO_MEM_ROM);
/* We have a boot vector start address. */
env->active_tc.PC = (target_long)(int32_t)0xbfc00000;
}
if (kernel_filename) {
loaderparams.ram_size = ram_size;
loaderparams.kernel_filename = kernel_filename;
loaderparams.kernel_cmdline = kernel_cmdline;
loaderparams.initrd_filename = initrd_filename;
load_kernel(env);
}
/* Init CPU internal devices. */
cpu_mips_irq_init_cpu(env);
cpu_mips_clock_init(env);
/* Register 64 KB of ISA IO space at 0x1fd00000. */
isa_mmio_init(0x1fd00000, 0x00010000);
/* A single 16450 sits at offset 0x3f8. It is attached to
MIPS CPU INT2, which is interrupt 4. */
if (serial_hds[0])
serial_init(0x3f8, env->irq[4], 115200, serial_hds[0]);
if (nd_table[0].vlan) {
if (nd_table[0].model == NULL
|| strcmp(nd_table[0].model, "mipsnet") == 0) {
/* MIPSnet uses the MIPS CPU INT0, which is interrupt 2. */
mipsnet_init(0x4200, env->irq[2], &nd_table[0]);
} else if (strcmp(nd_table[0].model, "?") == 0) {
fprintf(stderr, "qemu: Supported NICs: mipsnet\n");
exit (1);
} else {
fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
exit (1);
}
}
}
| false | qemu | 0ae18ceeaaa2c1749e742c4b112f6c3bf0896408 | mips_mipssim_init (ram_addr_t ram_size, int vga_ram_size,
const char *boot_device, DisplayState *ds,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
char buf[1024];
unsigned long bios_offset;
CPUState *env;
int bios_size;
if (cpu_model == NULL) {
#ifdef TARGET_MIPS64
cpu_model = "5Kf";
#else
cpu_model = "24Kf";
#endif
}
env = cpu_init(cpu_model);
if (!env) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
qemu_register_reset(main_cpu_reset, env);
cpu_register_physical_memory(0, ram_size, IO_MEM_RAM);
bios_offset = ram_size + vga_ram_size;
if (bios_name == NULL)
bios_name = BIOS_FILENAME;
snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name);
bios_size = load_image(buf, phys_ram_base + bios_offset);
if ((bios_size < 0 || bios_size > BIOS_SIZE) && !kernel_filename) {
fprintf(stderr,
"qemu: Could not load MIPS bios '%s', and no -kernel argument was specified\n",
buf);
exit(1);
} else {
cpu_register_physical_memory(0x1fc00000LL,
bios_size, bios_offset | IO_MEM_ROM);
env->active_tc.PC = (target_long)(int32_t)0xbfc00000;
}
if (kernel_filename) {
loaderparams.ram_size = ram_size;
loaderparams.kernel_filename = kernel_filename;
loaderparams.kernel_cmdline = kernel_cmdline;
loaderparams.initrd_filename = initrd_filename;
load_kernel(env);
}
cpu_mips_irq_init_cpu(env);
cpu_mips_clock_init(env);
isa_mmio_init(0x1fd00000, 0x00010000);
if (serial_hds[0])
serial_init(0x3f8, env->irq[4], 115200, serial_hds[0]);
if (nd_table[0].vlan) {
if (nd_table[0].model == NULL
|| strcmp(nd_table[0].model, "mipsnet") == 0) {
mipsnet_init(0x4200, env->irq[2], &nd_table[0]);
} else if (strcmp(nd_table[0].model, "?") == 0) {
fprintf(stderr, "qemu: Supported NICs: mipsnet\n");
exit (1);
} else {
fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
exit (1);
}
}
}
| {
"code": [],
"line_no": []
} | FUNC_0 (ram_addr_t VAR_0, int VAR_1,
const char *VAR_2, DisplayState *VAR_3,
const char *VAR_4, const char *VAR_5,
const char *VAR_6, const char *VAR_7)
{
char VAR_8[1024];
unsigned long VAR_9;
CPUState *env;
int VAR_10;
if (VAR_7 == NULL) {
#ifdef TARGET_MIPS64
VAR_7 = "5Kf";
#else
VAR_7 = "24Kf";
#endif
}
env = cpu_init(VAR_7);
if (!env) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
}
qemu_register_reset(main_cpu_reset, env);
cpu_register_physical_memory(0, VAR_0, IO_MEM_RAM);
VAR_9 = VAR_0 + VAR_1;
if (bios_name == NULL)
bios_name = BIOS_FILENAME;
snprintf(VAR_8, sizeof(VAR_8), "%s/%s", bios_dir, bios_name);
VAR_10 = load_image(VAR_8, phys_ram_base + VAR_9);
if ((VAR_10 < 0 || VAR_10 > BIOS_SIZE) && !VAR_4) {
fprintf(stderr,
"qemu: Could not load MIPS bios '%s', and no -kernel argument was specified\n",
VAR_8);
exit(1);
} else {
cpu_register_physical_memory(0x1fc00000LL,
VAR_10, VAR_9 | IO_MEM_ROM);
env->active_tc.PC = (target_long)(int32_t)0xbfc00000;
}
if (VAR_4) {
loaderparams.VAR_0 = VAR_0;
loaderparams.VAR_4 = VAR_4;
loaderparams.VAR_5 = VAR_5;
loaderparams.VAR_6 = VAR_6;
load_kernel(env);
}
cpu_mips_irq_init_cpu(env);
cpu_mips_clock_init(env);
isa_mmio_init(0x1fd00000, 0x00010000);
if (serial_hds[0])
serial_init(0x3f8, env->irq[4], 115200, serial_hds[0]);
if (nd_table[0].vlan) {
if (nd_table[0].model == NULL
|| strcmp(nd_table[0].model, "mipsnet") == 0) {
mipsnet_init(0x4200, env->irq[2], &nd_table[0]);
} else if (strcmp(nd_table[0].model, "?") == 0) {
fprintf(stderr, "qemu: Supported NICs: mipsnet\n");
exit (1);
} else {
fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd_table[0].model);
exit (1);
}
}
}
| [
"FUNC_0 (ram_addr_t VAR_0, int VAR_1,\nconst char *VAR_2, DisplayState *VAR_3,\nconst char *VAR_4, const char *VAR_5,\nconst char *VAR_6, const char *VAR_7)\n{",
"char VAR_8[1024];",
"unsigned long VAR_9;",
"CPUState *env;",
"int VAR_10;",
"if (VAR_7 == NULL) {",
"#ifdef TARGET_MIPS64\nVAR_7 = \"5Kf\";",
"#else\nVAR_7 = \"24Kf\";",
"#endif\n}",
"env = cpu_init(VAR_7);",
"if (!env) {",
"fprintf(stderr, \"Unable to find CPU definition\\n\");",
"exit(1);",
"}",
"qemu_register_reset(main_cpu_reset, env);",
"cpu_register_physical_memory(0, VAR_0, IO_MEM_RAM);",
"VAR_9 = VAR_0 + VAR_1;",
"if (bios_name == NULL)\nbios_name = BIOS_FILENAME;",
"snprintf(VAR_8, sizeof(VAR_8), \"%s/%s\", bios_dir, bios_name);",
"VAR_10 = load_image(VAR_8, phys_ram_base + VAR_9);",
"if ((VAR_10 < 0 || VAR_10 > BIOS_SIZE) && !VAR_4) {",
"fprintf(stderr,\n\"qemu: Could not load MIPS bios '%s', and no -kernel argument was specified\\n\",\nVAR_8);",
"exit(1);",
"} else {",
"cpu_register_physical_memory(0x1fc00000LL,\nVAR_10, VAR_9 | IO_MEM_ROM);",
"env->active_tc.PC = (target_long)(int32_t)0xbfc00000;",
"}",
"if (VAR_4) {",
"loaderparams.VAR_0 = VAR_0;",
"loaderparams.VAR_4 = VAR_4;",
"loaderparams.VAR_5 = VAR_5;",
"loaderparams.VAR_6 = VAR_6;",
"load_kernel(env);",
"}",
"cpu_mips_irq_init_cpu(env);",
"cpu_mips_clock_init(env);",
"isa_mmio_init(0x1fd00000, 0x00010000);",
"if (serial_hds[0])\nserial_init(0x3f8, env->irq[4], 115200, serial_hds[0]);",
"if (nd_table[0].vlan) {",
"if (nd_table[0].model == NULL\n|| strcmp(nd_table[0].model, \"mipsnet\") == 0) {",
"mipsnet_init(0x4200, env->irq[2], &nd_table[0]);",
"} else if (strcmp(nd_table[0].model, \"?\") == 0) {",
"fprintf(stderr, \"qemu: Supported NICs: mipsnet\\n\");",
"exit (1);",
"} else {",
"fprintf(stderr, \"qemu: Unsupported NIC: %s\\n\", nd_table[0].model);",
"exit (1);",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
23
],
[
25,
27
],
[
29,
31
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
53
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
73,
75,
77
],
[
79
],
[
81
],
[
85,
87
],
[
91
],
[
93
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
115
],
[
117
],
[
123
],
[
131,
133
],
[
137
],
[
139,
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
]
] |
21,534 | static inline void RENAME(LEToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)
{
#if COMPILE_TEMPLATE_MMX
__asm__ volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"movq (%2, %%"REG_a",2), %%mm2 \n\t"
"movq 8(%2, %%"REG_a",2), %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"psrlw $8, %%mm2 \n\t"
"psrlw $8, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, (%3, %%"REG_a") \n\t"
"movq %%mm2, (%4, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src1+width*2), "r" (src2+width*2), "r" (dstU+width), "r" (dstV+width)
: "%"REG_a
);
#else
int i;
// FIXME I don't think this code is right for YUV444/422, since then h is not subsampled so
// we need to skip each second pixel. Same for BEToUV.
for (i=0; i<width; i++) {
dstU[i]= src1[2*i + 1];
dstV[i]= src2[2*i + 1];
}
#endif
}
| false | FFmpeg | d1adad3cca407f493c3637e20ecd4f7124e69212 | static inline void RENAME(LEToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)
{
#if COMPILE_TEMPLATE_MMX
__asm__ volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"movq (%2, %%"REG_a",2), %%mm2 \n\t"
"movq 8(%2, %%"REG_a",2), %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"psrlw $8, %%mm2 \n\t"
"psrlw $8, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, (%3, %%"REG_a") \n\t"
"movq %%mm2, (%4, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src1+width*2), "r" (src2+width*2), "r" (dstU+width), "r" (dstV+width)
: "%"REG_a
);
#else
int i;
for (i=0; i<width; i++) {
dstU[i]= src1[2*i + 1];
dstV[i]= src2[2*i + 1];
}
#endif
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(LEToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)
{
#if COMPILE_TEMPLATE_MMX
__asm__ volatile(
"mov %0, %%"REG_a" \n\t"
"1: \n\t"
"movq (%1, %%"REG_a",2), %%mm0 \n\t"
"movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
"movq (%2, %%"REG_a",2), %%mm2 \n\t"
"movq 8(%2, %%"REG_a",2), %%mm3 \n\t"
"psrlw $8, %%mm0 \n\t"
"psrlw $8, %%mm1 \n\t"
"psrlw $8, %%mm2 \n\t"
"psrlw $8, %%mm3 \n\t"
"packuswb %%mm1, %%mm0 \n\t"
"packuswb %%mm3, %%mm2 \n\t"
"movq %%mm0, (%3, %%"REG_a") \n\t"
"movq %%mm2, (%4, %%"REG_a") \n\t"
"add $8, %%"REG_a" \n\t"
" js 1b \n\t"
: : "g" ((x86_reg)-width), "r" (src1+width*2), "r" (src2+width*2), "r" (dstU+width), "r" (dstV+width)
: "%"REG_a
);
#else
int VAR_0;
for (VAR_0=0; VAR_0<width; VAR_0++) {
dstU[VAR_0]= src1[2*VAR_0 + 1];
dstV[VAR_0]= src2[2*VAR_0 + 1];
}
#endif
}
| [
"static inline void FUNC_0(LEToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)\n{",
"#if COMPILE_TEMPLATE_MMX\n__asm__ volatile(\n\"mov %0, %%\"REG_a\" \\n\\t\"\n\"1: \\n\\t\"\n\"movq (%1, %%\"REG_a\",2), %%mm0 \\n\\t\"\n\"movq 8(%1, %%\"REG_a\",2), %%mm1 \\n\\t\"\n\"movq (%2, %%\"REG_a\",2), %%mm2 \\n\\t\"\n\"movq 8(%2, %%\"REG_a\",2), %%mm3 \\n\\t\"\n\"psrlw $8, %%mm0 \\n\\t\"\n\"psrlw $8, %%mm1 \\n\\t\"\n\"psrlw $8, %%mm2 \\n\\t\"\n\"psrlw $8, %%mm3 \\n\\t\"\n\"packuswb %%mm1, %%mm0 \\n\\t\"\n\"packuswb %%mm3, %%mm2 \\n\\t\"\n\"movq %%mm0, (%3, %%\"REG_a\") \\n\\t\"\n\"movq %%mm2, (%4, %%\"REG_a\") \\n\\t\"\n\"add $8, %%\"REG_a\" \\n\\t\"\n\" js 1b \\n\\t\"\n: : \"g\" ((x86_reg)-width), \"r\" (src1+width*2), \"r\" (src2+width*2), \"r\" (dstU+width), \"r\" (dstV+width)\n: \"%\"REG_a\n);",
"#else\nint VAR_0;",
"for (VAR_0=0; VAR_0<width; VAR_0++) {",
"dstU[VAR_0]= src1[2*VAR_0 + 1];",
"dstV[VAR_0]= src2[2*VAR_0 + 1];",
"}",
"#endif\n}"
] | [
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
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63,
65
]
] |
21,535 | static target_phys_addr_t intel_hda_addr(uint32_t lbase, uint32_t ubase)
{
target_phys_addr_t addr;
addr = ((uint64_t)ubase << 32) | lbase;
return addr;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static target_phys_addr_t intel_hda_addr(uint32_t lbase, uint32_t ubase)
{
target_phys_addr_t addr;
addr = ((uint64_t)ubase << 32) | lbase;
return addr;
}
| {
"code": [],
"line_no": []
} | static target_phys_addr_t FUNC_0(uint32_t lbase, uint32_t ubase)
{
target_phys_addr_t addr;
addr = ((uint64_t)ubase << 32) | lbase;
return addr;
}
| [
"static target_phys_addr_t FUNC_0(uint32_t lbase, uint32_t ubase)\n{",
"target_phys_addr_t addr;",
"addr = ((uint64_t)ubase << 32) | lbase;",
"return addr;",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
]
] |
21,536 | static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
Error **errp)
{
Error *local_err = NULL;
BlockMeasureInfo *info;
uint64_t required = 0; /* bytes that contribute to required size */
uint64_t virtual_size; /* disk size as seen by guest */
uint64_t refcount_bits;
uint64_t l2_tables;
size_t cluster_size;
int version;
char *optstr;
PreallocMode prealloc;
bool has_backing_file;
/* Parse image creation options */
cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
if (local_err) {
goto err;
}
version = qcow2_opt_get_version_del(opts, &local_err);
if (local_err) {
goto err;
}
refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
if (local_err) {
goto err;
}
optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr,
PREALLOC_MODE_OFF, &local_err);
g_free(optstr);
if (local_err) {
goto err;
}
optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
has_backing_file = !!optstr;
g_free(optstr);
virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
cluster_size);
/* Check that virtual disk size is valid */
l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
cluster_size / sizeof(uint64_t));
if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) {
error_setg(&local_err, "The image size is too large "
"(try using a larger cluster size)");
goto err;
}
/* Account for input image */
if (in_bs) {
int64_t ssize = bdrv_getlength(in_bs);
if (ssize < 0) {
error_setg_errno(&local_err, -ssize,
"Unable to get image virtual_size");
goto err;
}
virtual_size = align_offset(ssize, cluster_size);
if (has_backing_file) {
/* We don't how much of the backing chain is shared by the input
* image and the new image file. In the worst case the new image's
* backing file has nothing in common with the input image. Be
* conservative and assume all clusters need to be written.
*/
required = virtual_size;
} else {
int64_t offset;
int pnum = 0;
for (offset = 0; offset < ssize;
offset += pnum * BDRV_SECTOR_SIZE) {
int nb_sectors = MIN(ssize - offset,
BDRV_REQUEST_MAX_BYTES) / BDRV_SECTOR_SIZE;
BlockDriverState *file;
int64_t ret;
ret = bdrv_get_block_status_above(in_bs, NULL,
offset >> BDRV_SECTOR_BITS,
nb_sectors,
&pnum, &file);
if (ret < 0) {
error_setg_errno(&local_err, -ret,
"Unable to get block status");
goto err;
}
if (ret & BDRV_BLOCK_ZERO) {
/* Skip zero regions (safe with no backing file) */
} else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
(BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
/* Extend pnum to end of cluster for next iteration */
pnum = (ROUND_UP(offset + pnum * BDRV_SECTOR_SIZE,
cluster_size) - offset) >> BDRV_SECTOR_BITS;
/* Count clusters we've seen */
required += offset % cluster_size + pnum * BDRV_SECTOR_SIZE;
}
}
}
}
/* Take into account preallocation. Nothing special is needed for
* PREALLOC_MODE_METADATA since metadata is always counted.
*/
if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
required = virtual_size;
}
info = g_new(BlockMeasureInfo, 1);
info->fully_allocated =
qcow2_calc_prealloc_size(virtual_size, cluster_size,
ctz32(refcount_bits));
/* Remove data clusters that are not required. This overestimates the
* required size because metadata needed for the fully allocated file is
* still counted.
*/
info->required = info->fully_allocated - virtual_size + required;
return info;
err:
error_propagate(errp, local_err);
return NULL;
}
| false | qemu | 298a1665a2800f7264e483c2dd1f551574243a2f | static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
Error **errp)
{
Error *local_err = NULL;
BlockMeasureInfo *info;
uint64_t required = 0;
uint64_t virtual_size;
uint64_t refcount_bits;
uint64_t l2_tables;
size_t cluster_size;
int version;
char *optstr;
PreallocMode prealloc;
bool has_backing_file;
cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
if (local_err) {
goto err;
}
version = qcow2_opt_get_version_del(opts, &local_err);
if (local_err) {
goto err;
}
refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
if (local_err) {
goto err;
}
optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr,
PREALLOC_MODE_OFF, &local_err);
g_free(optstr);
if (local_err) {
goto err;
}
optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
has_backing_file = !!optstr;
g_free(optstr);
virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
cluster_size);
l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
cluster_size / sizeof(uint64_t));
if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) {
error_setg(&local_err, "The image size is too large "
"(try using a larger cluster size)");
goto err;
}
if (in_bs) {
int64_t ssize = bdrv_getlength(in_bs);
if (ssize < 0) {
error_setg_errno(&local_err, -ssize,
"Unable to get image virtual_size");
goto err;
}
virtual_size = align_offset(ssize, cluster_size);
if (has_backing_file) {
required = virtual_size;
} else {
int64_t offset;
int pnum = 0;
for (offset = 0; offset < ssize;
offset += pnum * BDRV_SECTOR_SIZE) {
int nb_sectors = MIN(ssize - offset,
BDRV_REQUEST_MAX_BYTES) / BDRV_SECTOR_SIZE;
BlockDriverState *file;
int64_t ret;
ret = bdrv_get_block_status_above(in_bs, NULL,
offset >> BDRV_SECTOR_BITS,
nb_sectors,
&pnum, &file);
if (ret < 0) {
error_setg_errno(&local_err, -ret,
"Unable to get block status");
goto err;
}
if (ret & BDRV_BLOCK_ZERO) {
} else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
(BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
pnum = (ROUND_UP(offset + pnum * BDRV_SECTOR_SIZE,
cluster_size) - offset) >> BDRV_SECTOR_BITS;
required += offset % cluster_size + pnum * BDRV_SECTOR_SIZE;
}
}
}
}
if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
required = virtual_size;
}
info = g_new(BlockMeasureInfo, 1);
info->fully_allocated =
qcow2_calc_prealloc_size(virtual_size, cluster_size,
ctz32(refcount_bits));
info->required = info->fully_allocated - virtual_size + required;
return info;
err:
error_propagate(errp, local_err);
return NULL;
}
| {
"code": [],
"line_no": []
} | static BlockMeasureInfo *FUNC_0(QemuOpts *opts, BlockDriverState *in_bs,
Error **errp)
{
Error *local_err = NULL;
BlockMeasureInfo *info;
uint64_t required = 0;
uint64_t virtual_size;
uint64_t refcount_bits;
uint64_t l2_tables;
size_t cluster_size;
int VAR_0;
char *VAR_1;
PreallocMode prealloc;
bool has_backing_file;
cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
if (local_err) {
goto err;
}
VAR_0 = qcow2_opt_get_version_del(opts, &local_err);
if (local_err) {
goto err;
}
refcount_bits = qcow2_opt_get_refcount_bits_del(opts, VAR_0, &local_err);
if (local_err) {
goto err;
}
VAR_1 = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
prealloc = qapi_enum_parse(&PreallocMode_lookup, VAR_1,
PREALLOC_MODE_OFF, &local_err);
g_free(VAR_1);
if (local_err) {
goto err;
}
VAR_1 = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
has_backing_file = !!VAR_1;
g_free(VAR_1);
virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
cluster_size);
l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
cluster_size / sizeof(uint64_t));
if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) {
error_setg(&local_err, "The image size is too large "
"(try using a larger cluster size)");
goto err;
}
if (in_bs) {
int64_t ssize = bdrv_getlength(in_bs);
if (ssize < 0) {
error_setg_errno(&local_err, -ssize,
"Unable to get image virtual_size");
goto err;
}
virtual_size = align_offset(ssize, cluster_size);
if (has_backing_file) {
required = virtual_size;
} else {
int64_t offset;
int VAR_2 = 0;
for (offset = 0; offset < ssize;
offset += VAR_2 * BDRV_SECTOR_SIZE) {
int nb_sectors = MIN(ssize - offset,
BDRV_REQUEST_MAX_BYTES) / BDRV_SECTOR_SIZE;
BlockDriverState *file;
int64_t ret;
ret = bdrv_get_block_status_above(in_bs, NULL,
offset >> BDRV_SECTOR_BITS,
nb_sectors,
&VAR_2, &file);
if (ret < 0) {
error_setg_errno(&local_err, -ret,
"Unable to get block status");
goto err;
}
if (ret & BDRV_BLOCK_ZERO) {
} else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
(BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
VAR_2 = (ROUND_UP(offset + VAR_2 * BDRV_SECTOR_SIZE,
cluster_size) - offset) >> BDRV_SECTOR_BITS;
required += offset % cluster_size + VAR_2 * BDRV_SECTOR_SIZE;
}
}
}
}
if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
required = virtual_size;
}
info = g_new(BlockMeasureInfo, 1);
info->fully_allocated =
qcow2_calc_prealloc_size(virtual_size, cluster_size,
ctz32(refcount_bits));
info->required = info->fully_allocated - virtual_size + required;
return info;
err:
error_propagate(errp, local_err);
return NULL;
}
| [
"static BlockMeasureInfo *FUNC_0(QemuOpts *opts, BlockDriverState *in_bs,\nError **errp)\n{",
"Error *local_err = NULL;",
"BlockMeasureInfo *info;",
"uint64_t required = 0;",
"uint64_t virtual_size;",
"uint64_t refcount_bits;",
"uint64_t l2_tables;",
"size_t cluster_size;",
"int VAR_0;",
"char *VAR_1;",
"PreallocMode prealloc;",
"bool has_backing_file;",
"cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);",
"if (local_err) {",
"goto err;",
"}",
"VAR_0 = qcow2_opt_get_version_del(opts, &local_err);",
"if (local_err) {",
"goto err;",
"}",
"refcount_bits = qcow2_opt_get_refcount_bits_del(opts, VAR_0, &local_err);",
"if (local_err) {",
"goto err;",
"}",
"VAR_1 = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);",
"prealloc = qapi_enum_parse(&PreallocMode_lookup, VAR_1,\nPREALLOC_MODE_OFF, &local_err);",
"g_free(VAR_1);",
"if (local_err) {",
"goto err;",
"}",
"VAR_1 = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);",
"has_backing_file = !!VAR_1;",
"g_free(VAR_1);",
"virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),\ncluster_size);",
"l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,\ncluster_size / sizeof(uint64_t));",
"if (l2_tables * sizeof(uint64_t) > QCOW_MAX_L1_SIZE) {",
"error_setg(&local_err, \"The image size is too large \"\n\"(try using a larger cluster size)\");",
"goto err;",
"}",
"if (in_bs) {",
"int64_t ssize = bdrv_getlength(in_bs);",
"if (ssize < 0) {",
"error_setg_errno(&local_err, -ssize,\n\"Unable to get image virtual_size\");",
"goto err;",
"}",
"virtual_size = align_offset(ssize, cluster_size);",
"if (has_backing_file) {",
"required = virtual_size;",
"} else {",
"int64_t offset;",
"int VAR_2 = 0;",
"for (offset = 0; offset < ssize;",
"offset += VAR_2 * BDRV_SECTOR_SIZE) {",
"int nb_sectors = MIN(ssize - offset,\nBDRV_REQUEST_MAX_BYTES) / BDRV_SECTOR_SIZE;",
"BlockDriverState *file;",
"int64_t ret;",
"ret = bdrv_get_block_status_above(in_bs, NULL,\noffset >> BDRV_SECTOR_BITS,\nnb_sectors,\n&VAR_2, &file);",
"if (ret < 0) {",
"error_setg_errno(&local_err, -ret,\n\"Unable to get block status\");",
"goto err;",
"}",
"if (ret & BDRV_BLOCK_ZERO) {",
"} else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==",
"(BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {",
"VAR_2 = (ROUND_UP(offset + VAR_2 * BDRV_SECTOR_SIZE,\ncluster_size) - offset) >> BDRV_SECTOR_BITS;",
"required += offset % cluster_size + VAR_2 * BDRV_SECTOR_SIZE;",
"}",
"}",
"}",
"}",
"if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {",
"required = virtual_size;",
"}",
"info = g_new(BlockMeasureInfo, 1);",
"info->fully_allocated =\nqcow2_calc_prealloc_size(virtual_size, cluster_size,\nctz32(refcount_bits));",
"info->required = info->fully_allocated - virtual_size + required;",
"return info;",
"err:\nerror_propagate(errp, local_err);",
"return NULL;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
87,
89
],
[
95,
97
],
[
99
],
[
101,
103
],
[
105
],
[
107
],
[
113
],
[
115
],
[
117
],
[
119,
121
],
[
123
],
[
125
],
[
129
],
[
133
],
[
145
],
[
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159,
161
],
[
163
],
[
165
],
[
169,
171,
173,
175
],
[
177
],
[
179,
181
],
[
183
],
[
185
],
[
189
],
[
193
],
[
195
],
[
199,
201
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
225
],
[
227
],
[
229
],
[
233
],
[
235,
237,
239
],
[
251
],
[
253
],
[
257,
259
],
[
261
],
[
263
]
] |
21,537 | static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
{
int ret;
RawAIOCB *acb = (RawAIOCB *)blockacb;
RawAIOCB **pacb;
ret = aio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
if (ret == AIO_NOTCANCELED) {
/* fail safe: if the aio could not be canceled, we wait for
it */
while (aio_error(&acb->aiocb) == EINPROGRESS);
}
/* remove the callback from the queue */
pacb = &posix_aio_state->first_aio;
for(;;) {
if (*pacb == NULL) {
break;
} else if (*pacb == acb) {
*pacb = acb->next;
raw_fd_pool_put(acb);
qemu_aio_release(acb);
break;
}
pacb = &acb->next;
}
}
| false | qemu | 3c529d935923a70519557d420db1d5a09a65086a | static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
{
int ret;
RawAIOCB *acb = (RawAIOCB *)blockacb;
RawAIOCB **pacb;
ret = aio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
if (ret == AIO_NOTCANCELED) {
while (aio_error(&acb->aiocb) == EINPROGRESS);
}
pacb = &posix_aio_state->first_aio;
for(;;) {
if (*pacb == NULL) {
break;
} else if (*pacb == acb) {
*pacb = acb->next;
raw_fd_pool_put(acb);
qemu_aio_release(acb);
break;
}
pacb = &acb->next;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(BlockDriverAIOCB *VAR_0)
{
int VAR_1;
RawAIOCB *acb = (RawAIOCB *)VAR_0;
RawAIOCB **pacb;
VAR_1 = aio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
if (VAR_1 == AIO_NOTCANCELED) {
while (aio_error(&acb->aiocb) == EINPROGRESS);
}
pacb = &posix_aio_state->first_aio;
for(;;) {
if (*pacb == NULL) {
break;
} else if (*pacb == acb) {
*pacb = acb->next;
raw_fd_pool_put(acb);
qemu_aio_release(acb);
break;
}
pacb = &acb->next;
}
}
| [
"static void FUNC_0(BlockDriverAIOCB *VAR_0)\n{",
"int VAR_1;",
"RawAIOCB *acb = (RawAIOCB *)VAR_0;",
"RawAIOCB **pacb;",
"VAR_1 = aio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);",
"if (VAR_1 == AIO_NOTCANCELED) {",
"while (aio_error(&acb->aiocb) == EINPROGRESS);",
"}",
"pacb = &posix_aio_state->first_aio;",
"for(;;) {",
"if (*pacb == NULL) {",
"break;",
"} else if (*pacb == acb) {",
"*pacb = acb->next;",
"raw_fd_pool_put(acb);",
"qemu_aio_release(acb);",
"break;",
"}",
"pacb = &acb->next;",
"}",
"}"
] | [
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
],
[
21
],
[
23
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
]
] |
21,539 | void check_file_fixed_eof_mmaps(void)
{
char *addr;
char *cp;
unsigned int *p1;
uintptr_t p;
int i;
/* Find a suitable address to start with. */
addr = mmap(NULL, pagesize * 44, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
fprintf (stderr, "%s addr=%p", __func__, (void *)addr);
fail_unless (addr != MAP_FAILED);
for (i = 0; i < 0x10; i++)
{
/* Create submaps within our unfixed map. */
p1 = mmap(addr, pagesize, PROT_READ,
MAP_PRIVATE | MAP_FIXED,
test_fd,
(test_fsize - sizeof *p1) & ~pagemask);
fail_unless (p1 != MAP_FAILED);
/* Make sure we get pages aligned with the pagesize. The
target expects this. */
p = (uintptr_t) p1;
fail_unless ((p & pagemask) == 0);
/* Verify that the file maps was made correctly. */
fail_unless (p1[(test_fsize & pagemask) / sizeof *p1 - 1]
== ((test_fsize - sizeof *p1) / sizeof *p1));
/* Verify that the end of page is accessable and zeroed. */
cp = (void *)p1;
fail_unless (cp[pagesize - 4] == 0);
munmap (p1, pagesize);
addr += pagesize;
}
fprintf (stderr, " passed\n");
}
| false | qemu | 64c7b9d8e07936383db181876b59c597d6a1ff69 | void check_file_fixed_eof_mmaps(void)
{
char *addr;
char *cp;
unsigned int *p1;
uintptr_t p;
int i;
addr = mmap(NULL, pagesize * 44, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
fprintf (stderr, "%s addr=%p", __func__, (void *)addr);
fail_unless (addr != MAP_FAILED);
for (i = 0; i < 0x10; i++)
{
p1 = mmap(addr, pagesize, PROT_READ,
MAP_PRIVATE | MAP_FIXED,
test_fd,
(test_fsize - sizeof *p1) & ~pagemask);
fail_unless (p1 != MAP_FAILED);
p = (uintptr_t) p1;
fail_unless ((p & pagemask) == 0);
fail_unless (p1[(test_fsize & pagemask) / sizeof *p1 - 1]
== ((test_fsize - sizeof *p1) / sizeof *p1));
cp = (void *)p1;
fail_unless (cp[pagesize - 4] == 0);
munmap (p1, pagesize);
addr += pagesize;
}
fprintf (stderr, " passed\n");
}
| {
"code": [],
"line_no": []
} | void FUNC_0(void)
{
char *VAR_0;
char *VAR_1;
unsigned int *VAR_2;
uintptr_t p;
int VAR_3;
VAR_0 = mmap(NULL, pagesize * 44, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
fprintf (stderr, "%s VAR_0=%p", __func__, (void *)VAR_0);
fail_unless (VAR_0 != MAP_FAILED);
for (VAR_3 = 0; VAR_3 < 0x10; VAR_3++)
{
VAR_2 = mmap(VAR_0, pagesize, PROT_READ,
MAP_PRIVATE | MAP_FIXED,
test_fd,
(test_fsize - sizeof *VAR_2) & ~pagemask);
fail_unless (VAR_2 != MAP_FAILED);
p = (uintptr_t) VAR_2;
fail_unless ((p & pagemask) == 0);
fail_unless (VAR_2[(test_fsize & pagemask) / sizeof *VAR_2 - 1]
== ((test_fsize - sizeof *VAR_2) / sizeof *VAR_2));
VAR_1 = (void *)VAR_2;
fail_unless (VAR_1[pagesize - 4] == 0);
munmap (VAR_2, pagesize);
VAR_0 += pagesize;
}
fprintf (stderr, " passed\n");
}
| [
"void FUNC_0(void)\n{",
"char *VAR_0;",
"char *VAR_1;",
"unsigned int *VAR_2;",
"uintptr_t p;",
"int VAR_3;",
"VAR_0 = mmap(NULL, pagesize * 44, PROT_READ,\nMAP_PRIVATE | MAP_ANONYMOUS,\n-1, 0);",
"fprintf (stderr, \"%s VAR_0=%p\", __func__, (void *)VAR_0);",
"fail_unless (VAR_0 != MAP_FAILED);",
"for (VAR_3 = 0; VAR_3 < 0x10; VAR_3++)",
"{",
"VAR_2 = mmap(VAR_0, pagesize, PROT_READ,\nMAP_PRIVATE | MAP_FIXED,\ntest_fd,\n(test_fsize - sizeof *VAR_2) & ~pagemask);",
"fail_unless (VAR_2 != MAP_FAILED);",
"p = (uintptr_t) VAR_2;",
"fail_unless ((p & pagemask) == 0);",
"fail_unless (VAR_2[(test_fsize & pagemask) / sizeof *VAR_2 - 1]\n== ((test_fsize - sizeof *VAR_2) / sizeof *VAR_2));",
"VAR_1 = (void *)VAR_2;",
"fail_unless (VAR_1[pagesize - 4] == 0);",
"munmap (VAR_2, pagesize);",
"VAR_0 += pagesize;",
"}",
"fprintf (stderr, \" passed\\n\");",
"}"
] | [
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
],
[
19,
21,
23
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39,
41,
43,
45
],
[
49
],
[
57
],
[
59
],
[
65,
67
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
]
] |
21,540 | static void nbd_attach_aio_context(BlockDriverState *bs,
AioContext *new_context)
{
BDRVNBDState *s = bs->opaque;
nbd_client_session_attach_aio_context(&s->client, new_context);
}
| false | qemu | f53a829bb9ef14be800556cbc02d8b20fc1050a7 | static void nbd_attach_aio_context(BlockDriverState *bs,
AioContext *new_context)
{
BDRVNBDState *s = bs->opaque;
nbd_client_session_attach_aio_context(&s->client, new_context);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(BlockDriverState *VAR_0,
AioContext *VAR_1)
{
BDRVNBDState *s = VAR_0->opaque;
nbd_client_session_attach_aio_context(&s->client, VAR_1);
}
| [
"static void FUNC_0(BlockDriverState *VAR_0,\nAioContext *VAR_1)\n{",
"BDRVNBDState *s = VAR_0->opaque;",
"nbd_client_session_attach_aio_context(&s->client, VAR_1);",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
]
] |
21,541 | void bmdma_cmd_writeb(void *opaque, uint32_t addr, uint32_t val)
{
BMDMAState *bm = opaque;
#ifdef DEBUG_IDE
printf("%s: 0x%08x\n", __func__, val);
#endif
/* Ignore writes to SSBM if it keeps the old value */
if ((val & BM_CMD_START) != (bm->cmd & BM_CMD_START)) {
if (!(val & BM_CMD_START)) {
/*
* We can't cancel Scatter Gather DMA in the middle of the
* operation or a partial (not full) DMA transfer would reach
* the storage so we wait for completion instead (we beahve
* like if the DMA was completed by the time the guest trying
* to cancel dma with bmdma_cmd_writeb with BM_CMD_START not
* set).
*
* In the future we'll be able to safely cancel the I/O if the
* whole DMA operation will be submitted to disk with a single
* aio operation with preadv/pwritev.
*/
if (bm->bus->dma->aiocb) {
qemu_aio_flush();
#ifdef DEBUG_IDE
if (bm->bus->dma->aiocb)
printf("ide_dma_cancel: aiocb still pending\n");
if (bm->status & BM_STATUS_DMAING)
printf("ide_dma_cancel: BM_STATUS_DMAING still pending\n");
#endif
}
} else {
bm->cur_addr = bm->addr;
if (!(bm->status & BM_STATUS_DMAING)) {
bm->status |= BM_STATUS_DMAING;
/* start dma transfer if possible */
if (bm->dma_cb)
bm->dma_cb(bmdma_active_if(bm), 0);
}
}
}
bm->cmd = val & 0x09;
}
| false | qemu | 2860e3eb9695d7596507e82b98074937fbd7fa18 | void bmdma_cmd_writeb(void *opaque, uint32_t addr, uint32_t val)
{
BMDMAState *bm = opaque;
#ifdef DEBUG_IDE
printf("%s: 0x%08x\n", __func__, val);
#endif
if ((val & BM_CMD_START) != (bm->cmd & BM_CMD_START)) {
if (!(val & BM_CMD_START)) {
if (bm->bus->dma->aiocb) {
qemu_aio_flush();
#ifdef DEBUG_IDE
if (bm->bus->dma->aiocb)
printf("ide_dma_cancel: aiocb still pending\n");
if (bm->status & BM_STATUS_DMAING)
printf("ide_dma_cancel: BM_STATUS_DMAING still pending\n");
#endif
}
} else {
bm->cur_addr = bm->addr;
if (!(bm->status & BM_STATUS_DMAING)) {
bm->status |= BM_STATUS_DMAING;
if (bm->dma_cb)
bm->dma_cb(bmdma_active_if(bm), 0);
}
}
}
bm->cmd = val & 0x09;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)
{
BMDMAState *bm = VAR_0;
#ifdef DEBUG_IDE
printf("%s: 0x%08x\n", __func__, VAR_2);
#endif
if ((VAR_2 & BM_CMD_START) != (bm->cmd & BM_CMD_START)) {
if (!(VAR_2 & BM_CMD_START)) {
if (bm->bus->dma->aiocb) {
qemu_aio_flush();
#ifdef DEBUG_IDE
if (bm->bus->dma->aiocb)
printf("ide_dma_cancel: aiocb still pending\n");
if (bm->status & BM_STATUS_DMAING)
printf("ide_dma_cancel: BM_STATUS_DMAING still pending\n");
#endif
}
} else {
bm->cur_addr = bm->VAR_1;
if (!(bm->status & BM_STATUS_DMAING)) {
bm->status |= BM_STATUS_DMAING;
if (bm->dma_cb)
bm->dma_cb(bmdma_active_if(bm), 0);
}
}
}
bm->cmd = VAR_2 & 0x09;
}
| [
"void FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{",
"BMDMAState *bm = VAR_0;",
"#ifdef DEBUG_IDE\nprintf(\"%s: 0x%08x\\n\", __func__, VAR_2);",
"#endif\nif ((VAR_2 & BM_CMD_START) != (bm->cmd & BM_CMD_START)) {",
"if (!(VAR_2 & BM_CMD_START)) {",
"if (bm->bus->dma->aiocb) {",
"qemu_aio_flush();",
"#ifdef DEBUG_IDE\nif (bm->bus->dma->aiocb)\nprintf(\"ide_dma_cancel: aiocb still pending\\n\");",
"if (bm->status & BM_STATUS_DMAING)\nprintf(\"ide_dma_cancel: BM_STATUS_DMAING still pending\\n\");",
"#endif\n}",
"} else {",
"bm->cur_addr = bm->VAR_1;",
"if (!(bm->status & BM_STATUS_DMAING)) {",
"bm->status |= BM_STATUS_DMAING;",
"if (bm->dma_cb)\nbm->dma_cb(bmdma_active_if(bm), 0);",
"}",
"}",
"}",
"bm->cmd = VAR_2 & 0x09;",
"}"
] | [
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,
17
],
[
19
],
[
45
],
[
47
],
[
49,
51,
53
],
[
55,
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
]
] |
21,542 | uint32_t qemu_devtree_get_phandle(void *fdt, const char *path)
{
uint32_t r;
r = fdt_get_phandle(fdt, findnode_nofail(fdt, path));
if (r <= 0) {
fprintf(stderr, "%s: Couldn't get phandle for %s: %s\n", __func__,
path, fdt_strerror(r));
exit(1);
}
return r;
}
| false | qemu | 909a196d2754388d3b15a34b688095c655792124 | uint32_t qemu_devtree_get_phandle(void *fdt, const char *path)
{
uint32_t r;
r = fdt_get_phandle(fdt, findnode_nofail(fdt, path));
if (r <= 0) {
fprintf(stderr, "%s: Couldn't get phandle for %s: %s\n", __func__,
path, fdt_strerror(r));
exit(1);
}
return r;
}
| {
"code": [],
"line_no": []
} | uint32_t FUNC_0(void *fdt, const char *path)
{
uint32_t r;
r = fdt_get_phandle(fdt, findnode_nofail(fdt, path));
if (r <= 0) {
fprintf(stderr, "%s: Couldn't get phandle for %s: %s\n", __func__,
path, fdt_strerror(r));
exit(1);
}
return r;
}
| [
"uint32_t FUNC_0(void *fdt, const char *path)\n{",
"uint32_t r;",
"r = fdt_get_phandle(fdt, findnode_nofail(fdt, path));",
"if (r <= 0) {",
"fprintf(stderr, \"%s: Couldn't get phandle for %s: %s\\n\", __func__,\npath, fdt_strerror(r));",
"exit(1);",
"}",
"return r;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13,
15
],
[
17
],
[
19
],
[
23
],
[
25
]
] |
21,543 | static char *SocketAddress_to_str(const char *prefix, SocketAddressLegacy *addr,
bool is_listen, bool is_telnet)
{
switch (addr->type) {
case SOCKET_ADDRESS_LEGACY_KIND_INET:
return g_strdup_printf("%s%s:%s:%s%s", prefix,
is_telnet ? "telnet" : "tcp",
addr->u.inet.data->host,
addr->u.inet.data->port,
is_listen ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_UNIX:
return g_strdup_printf("%sunix:%s%s", prefix,
addr->u.q_unix.data->path,
is_listen ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_FD:
return g_strdup_printf("%sfd:%s%s", prefix, addr->u.fd.data->str,
is_listen ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:
return g_strdup_printf("%svsock:%s:%s", prefix,
addr->u.vsock.data->cid,
addr->u.vsock.data->port);
default:
abort();
}
}
| false | qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | static char *SocketAddress_to_str(const char *prefix, SocketAddressLegacy *addr,
bool is_listen, bool is_telnet)
{
switch (addr->type) {
case SOCKET_ADDRESS_LEGACY_KIND_INET:
return g_strdup_printf("%s%s:%s:%s%s", prefix,
is_telnet ? "telnet" : "tcp",
addr->u.inet.data->host,
addr->u.inet.data->port,
is_listen ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_UNIX:
return g_strdup_printf("%sunix:%s%s", prefix,
addr->u.q_unix.data->path,
is_listen ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_FD:
return g_strdup_printf("%sfd:%s%s", prefix, addr->u.fd.data->str,
is_listen ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:
return g_strdup_printf("%svsock:%s:%s", prefix,
addr->u.vsock.data->cid,
addr->u.vsock.data->port);
default:
abort();
}
}
| {
"code": [],
"line_no": []
} | static char *FUNC_0(const char *VAR_0, SocketAddressLegacy *VAR_1,
bool VAR_2, bool VAR_3)
{
switch (VAR_1->type) {
case SOCKET_ADDRESS_LEGACY_KIND_INET:
return g_strdup_printf("%s%s:%s:%s%s", VAR_0,
VAR_3 ? "telnet" : "tcp",
VAR_1->u.inet.data->host,
VAR_1->u.inet.data->port,
VAR_2 ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_UNIX:
return g_strdup_printf("%sunix:%s%s", VAR_0,
VAR_1->u.q_unix.data->path,
VAR_2 ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_FD:
return g_strdup_printf("%sfd:%s%s", VAR_0, VAR_1->u.fd.data->str,
VAR_2 ? ",server" : "");
break;
case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:
return g_strdup_printf("%svsock:%s:%s", VAR_0,
VAR_1->u.vsock.data->cid,
VAR_1->u.vsock.data->port);
default:
abort();
}
}
| [
"static char *FUNC_0(const char *VAR_0, SocketAddressLegacy *VAR_1,\nbool VAR_2, bool VAR_3)\n{",
"switch (VAR_1->type) {",
"case SOCKET_ADDRESS_LEGACY_KIND_INET:\nreturn g_strdup_printf(\"%s%s:%s:%s%s\", VAR_0,\nVAR_3 ? \"telnet\" : \"tcp\",\nVAR_1->u.inet.data->host,\nVAR_1->u.inet.data->port,\nVAR_2 ? \",server\" : \"\");",
"break;",
"case SOCKET_ADDRESS_LEGACY_KIND_UNIX:\nreturn g_strdup_printf(\"%sunix:%s%s\", VAR_0,\nVAR_1->u.q_unix.data->path,\nVAR_2 ? \",server\" : \"\");",
"break;",
"case SOCKET_ADDRESS_LEGACY_KIND_FD:\nreturn g_strdup_printf(\"%sfd:%s%s\", VAR_0, VAR_1->u.fd.data->str,\nVAR_2 ? \",server\" : \"\");",
"break;",
"case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:\nreturn g_strdup_printf(\"%svsock:%s:%s\", VAR_0,\nVAR_1->u.vsock.data->cid,\nVAR_1->u.vsock.data->port);",
"default:\nabort();",
"}",
"}"
] | [
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
],
[
53
],
[
55
]
] |
21,544 | void handle_vm86_fault(CPUX86State *env)
{
TaskState *ts = env->opaque;
uint8_t *csp, *pc, *ssp;
unsigned int ip, sp, newflags, newip, newcs, opcode, intno;
int data32, pref_done;
csp = (uint8_t *)(env->segs[R_CS] << 4);
ip = env->eip & 0xffff;
pc = csp + ip;
ssp = (uint8_t *)(env->segs[R_SS] << 4);
sp = env->regs[R_ESP] & 0xffff;
#if defined(DEBUG_VM86)
fprintf(logfile, "VM86 exception %04x:%08x %02x %02x\n",
env->segs[R_CS], env->eip, pc[0], pc[1]);
#endif
data32 = 0;
pref_done = 0;
do {
opcode = csp[ip];
ADD16(ip, 1);
switch (opcode) {
case 0x66: /* 32-bit data */ data32=1; break;
case 0x67: /* 32-bit address */ break;
case 0x2e: /* CS */ break;
case 0x3e: /* DS */ break;
case 0x26: /* ES */ break;
case 0x36: /* SS */ break;
case 0x65: /* GS */ break;
case 0x64: /* FS */ break;
case 0xf2: /* repnz */ break;
case 0xf3: /* rep */ break;
default: pref_done = 1;
}
} while (!pref_done);
/* VM86 mode */
switch(opcode) {
case 0x9c: /* pushf */
ADD16(env->eip, 2);
if (data32) {
vm_putl(ssp, sp - 4, get_vflags(env));
ADD16(env->regs[R_ESP], -4);
} else {
vm_putw(ssp, sp - 2, get_vflags(env));
ADD16(env->regs[R_ESP], -2);
}
env->eip = ip;
VM86_FAULT_RETURN;
case 0x9d: /* popf */
if (data32) {
newflags = vm_getl(ssp, sp);
ADD16(env->regs[R_ESP], 4);
} else {
newflags = vm_getw(ssp, sp);
ADD16(env->regs[R_ESP], 2);
}
env->eip = ip;
CHECK_IF_IN_TRAP();
if (data32) {
if (set_vflags_long(newflags, env))
return;
} else {
if (set_vflags_short(newflags, env))
return;
}
VM86_FAULT_RETURN;
case 0xcd: /* int */
intno = csp[ip];
ADD16(ip, 1);
env->eip = ip;
if (ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_active) {
if ( (ts->vm86plus.vm86plus.vm86dbg_intxxtab[intno >> 3] >>
(intno &7)) & 1) {
return_to_32bit(env, TARGET_VM86_INTx + (intno << 8));
return;
}
}
do_int(env, intno);
break;
case 0xcf: /* iret */
if (data32) {
newip = vm_getl(ssp, sp) & 0xffff;
newcs = vm_getl(ssp, sp + 4) & 0xffff;
newflags = vm_getl(ssp, sp + 8);
ADD16(env->regs[R_ESP], 12);
} else {
newip = vm_getw(ssp, sp);
newcs = vm_getw(ssp, sp + 2);
newflags = vm_getw(ssp, sp + 4);
ADD16(env->regs[R_ESP], 6);
}
env->eip = newip;
cpu_x86_load_seg(env, R_CS, newcs);
CHECK_IF_IN_TRAP();
if (data32) {
if (set_vflags_long(newflags, env))
return;
} else {
if (set_vflags_short(newflags, env))
return;
}
VM86_FAULT_RETURN;
case 0xfa: /* cli */
env->eip = ip;
clear_IF(env);
VM86_FAULT_RETURN;
case 0xfb: /* sti */
env->eip = ip;
if (set_IF(env))
return;
VM86_FAULT_RETURN;
default:
/* real VM86 GPF exception */
return_to_32bit(env, TARGET_VM86_UNKNOWN);
break;
}
}
| false | qemu | 3ebcc707d20643e9fefa24a4396de577b1163755 | void handle_vm86_fault(CPUX86State *env)
{
TaskState *ts = env->opaque;
uint8_t *csp, *pc, *ssp;
unsigned int ip, sp, newflags, newip, newcs, opcode, intno;
int data32, pref_done;
csp = (uint8_t *)(env->segs[R_CS] << 4);
ip = env->eip & 0xffff;
pc = csp + ip;
ssp = (uint8_t *)(env->segs[R_SS] << 4);
sp = env->regs[R_ESP] & 0xffff;
#if defined(DEBUG_VM86)
fprintf(logfile, "VM86 exception %04x:%08x %02x %02x\n",
env->segs[R_CS], env->eip, pc[0], pc[1]);
#endif
data32 = 0;
pref_done = 0;
do {
opcode = csp[ip];
ADD16(ip, 1);
switch (opcode) {
case 0x66: data32=1; break;
case 0x67: break;
case 0x2e: break;
case 0x3e: break;
case 0x26: break;
case 0x36: break;
case 0x65: break;
case 0x64: break;
case 0xf2: break;
case 0xf3: break;
default: pref_done = 1;
}
} while (!pref_done);
switch(opcode) {
case 0x9c:
ADD16(env->eip, 2);
if (data32) {
vm_putl(ssp, sp - 4, get_vflags(env));
ADD16(env->regs[R_ESP], -4);
} else {
vm_putw(ssp, sp - 2, get_vflags(env));
ADD16(env->regs[R_ESP], -2);
}
env->eip = ip;
VM86_FAULT_RETURN;
case 0x9d:
if (data32) {
newflags = vm_getl(ssp, sp);
ADD16(env->regs[R_ESP], 4);
} else {
newflags = vm_getw(ssp, sp);
ADD16(env->regs[R_ESP], 2);
}
env->eip = ip;
CHECK_IF_IN_TRAP();
if (data32) {
if (set_vflags_long(newflags, env))
return;
} else {
if (set_vflags_short(newflags, env))
return;
}
VM86_FAULT_RETURN;
case 0xcd:
intno = csp[ip];
ADD16(ip, 1);
env->eip = ip;
if (ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_active) {
if ( (ts->vm86plus.vm86plus.vm86dbg_intxxtab[intno >> 3] >>
(intno &7)) & 1) {
return_to_32bit(env, TARGET_VM86_INTx + (intno << 8));
return;
}
}
do_int(env, intno);
break;
case 0xcf:
if (data32) {
newip = vm_getl(ssp, sp) & 0xffff;
newcs = vm_getl(ssp, sp + 4) & 0xffff;
newflags = vm_getl(ssp, sp + 8);
ADD16(env->regs[R_ESP], 12);
} else {
newip = vm_getw(ssp, sp);
newcs = vm_getw(ssp, sp + 2);
newflags = vm_getw(ssp, sp + 4);
ADD16(env->regs[R_ESP], 6);
}
env->eip = newip;
cpu_x86_load_seg(env, R_CS, newcs);
CHECK_IF_IN_TRAP();
if (data32) {
if (set_vflags_long(newflags, env))
return;
} else {
if (set_vflags_short(newflags, env))
return;
}
VM86_FAULT_RETURN;
case 0xfa:
env->eip = ip;
clear_IF(env);
VM86_FAULT_RETURN;
case 0xfb:
env->eip = ip;
if (set_IF(env))
return;
VM86_FAULT_RETURN;
default:
return_to_32bit(env, TARGET_VM86_UNKNOWN);
break;
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUX86State *VAR_0)
{
TaskState *ts = VAR_0->opaque;
uint8_t *csp, *pc, *ssp;
unsigned int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;
int VAR_8, VAR_9;
csp = (uint8_t *)(VAR_0->segs[R_CS] << 4);
VAR_1 = VAR_0->eip & 0xffff;
pc = csp + VAR_1;
ssp = (uint8_t *)(VAR_0->segs[R_SS] << 4);
VAR_2 = VAR_0->regs[R_ESP] & 0xffff;
#if defined(DEBUG_VM86)
fprintf(logfile, "VM86 exception %04x:%08x %02x %02x\n",
VAR_0->segs[R_CS], VAR_0->eip, pc[0], pc[1]);
#endif
VAR_8 = 0;
VAR_9 = 0;
do {
VAR_6 = csp[VAR_1];
ADD16(VAR_1, 1);
switch (VAR_6) {
case 0x66: VAR_8=1; break;
case 0x67: break;
case 0x2e: break;
case 0x3e: break;
case 0x26: break;
case 0x36: break;
case 0x65: break;
case 0x64: break;
case 0xf2: break;
case 0xf3: break;
default: VAR_9 = 1;
}
} while (!VAR_9);
switch(VAR_6) {
case 0x9c:
ADD16(VAR_0->eip, 2);
if (VAR_8) {
vm_putl(ssp, VAR_2 - 4, get_vflags(VAR_0));
ADD16(VAR_0->regs[R_ESP], -4);
} else {
vm_putw(ssp, VAR_2 - 2, get_vflags(VAR_0));
ADD16(VAR_0->regs[R_ESP], -2);
}
VAR_0->eip = VAR_1;
VM86_FAULT_RETURN;
case 0x9d:
if (VAR_8) {
VAR_3 = vm_getl(ssp, VAR_2);
ADD16(VAR_0->regs[R_ESP], 4);
} else {
VAR_3 = vm_getw(ssp, VAR_2);
ADD16(VAR_0->regs[R_ESP], 2);
}
VAR_0->eip = VAR_1;
CHECK_IF_IN_TRAP();
if (VAR_8) {
if (set_vflags_long(VAR_3, VAR_0))
return;
} else {
if (set_vflags_short(VAR_3, VAR_0))
return;
}
VM86_FAULT_RETURN;
case 0xcd:
VAR_7 = csp[VAR_1];
ADD16(VAR_1, 1);
VAR_0->eip = VAR_1;
if (ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_active) {
if ( (ts->vm86plus.vm86plus.vm86dbg_intxxtab[VAR_7 >> 3] >>
(VAR_7 &7)) & 1) {
return_to_32bit(VAR_0, TARGET_VM86_INTx + (VAR_7 << 8));
return;
}
}
do_int(VAR_0, VAR_7);
break;
case 0xcf:
if (VAR_8) {
VAR_4 = vm_getl(ssp, VAR_2) & 0xffff;
VAR_5 = vm_getl(ssp, VAR_2 + 4) & 0xffff;
VAR_3 = vm_getl(ssp, VAR_2 + 8);
ADD16(VAR_0->regs[R_ESP], 12);
} else {
VAR_4 = vm_getw(ssp, VAR_2);
VAR_5 = vm_getw(ssp, VAR_2 + 2);
VAR_3 = vm_getw(ssp, VAR_2 + 4);
ADD16(VAR_0->regs[R_ESP], 6);
}
VAR_0->eip = VAR_4;
cpu_x86_load_seg(VAR_0, R_CS, VAR_5);
CHECK_IF_IN_TRAP();
if (VAR_8) {
if (set_vflags_long(VAR_3, VAR_0))
return;
} else {
if (set_vflags_short(VAR_3, VAR_0))
return;
}
VM86_FAULT_RETURN;
case 0xfa:
VAR_0->eip = VAR_1;
clear_IF(VAR_0);
VM86_FAULT_RETURN;
case 0xfb:
VAR_0->eip = VAR_1;
if (set_IF(VAR_0))
return;
VM86_FAULT_RETURN;
default:
return_to_32bit(VAR_0, TARGET_VM86_UNKNOWN);
break;
}
}
| [
"void FUNC_0(CPUX86State *VAR_0)\n{",
"TaskState *ts = VAR_0->opaque;",
"uint8_t *csp, *pc, *ssp;",
"unsigned int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;",
"int VAR_8, VAR_9;",
"csp = (uint8_t *)(VAR_0->segs[R_CS] << 4);",
"VAR_1 = VAR_0->eip & 0xffff;",
"pc = csp + VAR_1;",
"ssp = (uint8_t *)(VAR_0->segs[R_SS] << 4);",
"VAR_2 = VAR_0->regs[R_ESP] & 0xffff;",
"#if defined(DEBUG_VM86)\nfprintf(logfile, \"VM86 exception %04x:%08x %02x %02x\\n\",\nVAR_0->segs[R_CS], VAR_0->eip, pc[0], pc[1]);",
"#endif\nVAR_8 = 0;",
"VAR_9 = 0;",
"do {",
"VAR_6 = csp[VAR_1];",
"ADD16(VAR_1, 1);",
"switch (VAR_6) {",
"case 0x66: VAR_8=1; break;",
"case 0x67: break;",
"case 0x2e: break;",
"case 0x3e: break;",
"case 0x26: break;",
"case 0x36: break;",
"case 0x65: break;",
"case 0x64: break;",
"case 0xf2: \t break;",
"case 0xf3: break;",
"default: VAR_9 = 1;",
"}",
"} while (!VAR_9);",
"switch(VAR_6) {",
"case 0x9c:\nADD16(VAR_0->eip, 2);",
"if (VAR_8) {",
"vm_putl(ssp, VAR_2 - 4, get_vflags(VAR_0));",
"ADD16(VAR_0->regs[R_ESP], -4);",
"} else {",
"vm_putw(ssp, VAR_2 - 2, get_vflags(VAR_0));",
"ADD16(VAR_0->regs[R_ESP], -2);",
"}",
"VAR_0->eip = VAR_1;",
"VM86_FAULT_RETURN;",
"case 0x9d:\nif (VAR_8) {",
"VAR_3 = vm_getl(ssp, VAR_2);",
"ADD16(VAR_0->regs[R_ESP], 4);",
"} else {",
"VAR_3 = vm_getw(ssp, VAR_2);",
"ADD16(VAR_0->regs[R_ESP], 2);",
"}",
"VAR_0->eip = VAR_1;",
"CHECK_IF_IN_TRAP();",
"if (VAR_8) {",
"if (set_vflags_long(VAR_3, VAR_0))\nreturn;",
"} else {",
"if (set_vflags_short(VAR_3, VAR_0))\nreturn;",
"}",
"VM86_FAULT_RETURN;",
"case 0xcd:\nVAR_7 = csp[VAR_1];",
"ADD16(VAR_1, 1);",
"VAR_0->eip = VAR_1;",
"if (ts->vm86plus.vm86plus.flags & TARGET_vm86dbg_active) {",
"if ( (ts->vm86plus.vm86plus.vm86dbg_intxxtab[VAR_7 >> 3] >>\n(VAR_7 &7)) & 1) {",
"return_to_32bit(VAR_0, TARGET_VM86_INTx + (VAR_7 << 8));",
"return;",
"}",
"}",
"do_int(VAR_0, VAR_7);",
"break;",
"case 0xcf:\nif (VAR_8) {",
"VAR_4 = vm_getl(ssp, VAR_2) & 0xffff;",
"VAR_5 = vm_getl(ssp, VAR_2 + 4) & 0xffff;",
"VAR_3 = vm_getl(ssp, VAR_2 + 8);",
"ADD16(VAR_0->regs[R_ESP], 12);",
"} else {",
"VAR_4 = vm_getw(ssp, VAR_2);",
"VAR_5 = vm_getw(ssp, VAR_2 + 2);",
"VAR_3 = vm_getw(ssp, VAR_2 + 4);",
"ADD16(VAR_0->regs[R_ESP], 6);",
"}",
"VAR_0->eip = VAR_4;",
"cpu_x86_load_seg(VAR_0, R_CS, VAR_5);",
"CHECK_IF_IN_TRAP();",
"if (VAR_8) {",
"if (set_vflags_long(VAR_3, VAR_0))\nreturn;",
"} else {",
"if (set_vflags_short(VAR_3, VAR_0))\nreturn;",
"}",
"VM86_FAULT_RETURN;",
"case 0xfa:\nVAR_0->eip = VAR_1;",
"clear_IF(VAR_0);",
"VM86_FAULT_RETURN;",
"case 0xfb:\nVAR_0->eip = VAR_1;",
"if (set_IF(VAR_0))\nreturn;",
"VM86_FAULT_RETURN;",
"default:\nreturn_to_32bit(VAR_0, TARGET_VM86_UNKNOWN);",
"break;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29,
31,
33
],
[
35,
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
],
[
107,
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129,
131
],
[
133
],
[
135,
137
],
[
139
],
[
141
],
[
145,
147
],
[
149
],
[
151
],
[
153
],
[
155,
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
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
],
[
231,
233
],
[
235,
237
],
[
239
],
[
243,
247
],
[
249
],
[
251
],
[
253
]
] |
21,545 | static MemTxResult gic_cpu_write(GICState *s, int cpu, int offset,
uint32_t value, MemTxAttrs attrs)
{
switch (offset) {
case 0x00: /* Control */
gic_set_cpu_control(s, cpu, value, attrs);
break;
case 0x04: /* Priority mask */
s->priority_mask[cpu] = (value & 0xff);
break;
case 0x08: /* Binary Point */
if (s->security_extn && !attrs.secure) {
s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);
} else {
s->bpr[cpu] = MAX(value & 0x7, GIC_MIN_BPR);
}
break;
case 0x10: /* End Of Interrupt */
gic_complete_irq(s, cpu, value & 0x3ff);
return MEMTX_OK;
case 0x1c: /* Aliased Binary Point */
if (!gic_has_groups(s) || (s->security_extn && !attrs.secure)) {
/* unimplemented, or NS access: RAZ/WI */
return MEMTX_OK;
} else {
s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);
}
break;
case 0xd0: case 0xd4: case 0xd8: case 0xdc:
qemu_log_mask(LOG_UNIMP, "Writing APR not implemented\n");
break;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"gic_cpu_write: Bad offset %x\n", (int)offset);
return MEMTX_ERROR;
}
gic_update(s);
return MEMTX_OK;
}
| false | qemu | 8150847061f8d2606101bfff77cc6ec86b081ab0 | static MemTxResult gic_cpu_write(GICState *s, int cpu, int offset,
uint32_t value, MemTxAttrs attrs)
{
switch (offset) {
case 0x00:
gic_set_cpu_control(s, cpu, value, attrs);
break;
case 0x04:
s->priority_mask[cpu] = (value & 0xff);
break;
case 0x08:
if (s->security_extn && !attrs.secure) {
s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);
} else {
s->bpr[cpu] = MAX(value & 0x7, GIC_MIN_BPR);
}
break;
case 0x10:
gic_complete_irq(s, cpu, value & 0x3ff);
return MEMTX_OK;
case 0x1c:
if (!gic_has_groups(s) || (s->security_extn && !attrs.secure)) {
return MEMTX_OK;
} else {
s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);
}
break;
case 0xd0: case 0xd4: case 0xd8: case 0xdc:
qemu_log_mask(LOG_UNIMP, "Writing APR not implemented\n");
break;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"gic_cpu_write: Bad offset %x\n", (int)offset);
return MEMTX_ERROR;
}
gic_update(s);
return MEMTX_OK;
}
| {
"code": [],
"line_no": []
} | static MemTxResult FUNC_0(GICState *s, int cpu, int offset,
uint32_t value, MemTxAttrs attrs)
{
switch (offset) {
case 0x00:
gic_set_cpu_control(s, cpu, value, attrs);
break;
case 0x04:
s->priority_mask[cpu] = (value & 0xff);
break;
case 0x08:
if (s->security_extn && !attrs.secure) {
s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);
} else {
s->bpr[cpu] = MAX(value & 0x7, GIC_MIN_BPR);
}
break;
case 0x10:
gic_complete_irq(s, cpu, value & 0x3ff);
return MEMTX_OK;
case 0x1c:
if (!gic_has_groups(s) || (s->security_extn && !attrs.secure)) {
return MEMTX_OK;
} else {
s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);
}
break;
case 0xd0: case 0xd4: case 0xd8: case 0xdc:
qemu_log_mask(LOG_UNIMP, "Writing APR not implemented\n");
break;
default:
qemu_log_mask(LOG_GUEST_ERROR,
"FUNC_0: Bad offset %x\n", (int)offset);
return MEMTX_ERROR;
}
gic_update(s);
return MEMTX_OK;
}
| [
"static MemTxResult FUNC_0(GICState *s, int cpu, int offset,\nuint32_t value, MemTxAttrs attrs)\n{",
"switch (offset) {",
"case 0x00:\ngic_set_cpu_control(s, cpu, value, attrs);",
"break;",
"case 0x04:\ns->priority_mask[cpu] = (value & 0xff);",
"break;",
"case 0x08:\nif (s->security_extn && !attrs.secure) {",
"s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);",
"} else {",
"s->bpr[cpu] = MAX(value & 0x7, GIC_MIN_BPR);",
"}",
"break;",
"case 0x10:\ngic_complete_irq(s, cpu, value & 0x3ff);",
"return MEMTX_OK;",
"case 0x1c:\nif (!gic_has_groups(s) || (s->security_extn && !attrs.secure)) {",
"return MEMTX_OK;",
"} else {",
"s->abpr[cpu] = MAX(value & 0x7, GIC_MIN_ABPR);",
"}",
"break;",
"case 0xd0: case 0xd4: case 0xd8: case 0xdc:\nqemu_log_mask(LOG_UNIMP, \"Writing APR not implemented\\n\");",
"break;",
"default:\nqemu_log_mask(LOG_GUEST_ERROR,\n\"FUNC_0: Bad offset %x\\n\", (int)offset);",
"return MEMTX_ERROR;",
"}",
"gic_update(s);",
"return MEMTX_OK;",
"}"
] | [
0,
0,
0,
0,
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
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57,
59
],
[
61
],
[
63,
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
]
] |
21,546 | static int op_to_movi(int op)
{
switch (op_bits(op)) {
case 32:
return INDEX_op_movi_i32;
#if TCG_TARGET_REG_BITS == 64
case 64:
return INDEX_op_movi_i64;
#endif
default:
fprintf(stderr, "op_to_movi: unexpected return value of "
"function op_bits.\n");
tcg_abort();
}
}
| false | qemu | 25c4d9cc845fb58f624dae8c0f690e20c70e7a1d | static int op_to_movi(int op)
{
switch (op_bits(op)) {
case 32:
return INDEX_op_movi_i32;
#if TCG_TARGET_REG_BITS == 64
case 64:
return INDEX_op_movi_i64;
#endif
default:
fprintf(stderr, "op_to_movi: unexpected return value of "
"function op_bits.\n");
tcg_abort();
}
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(int VAR_0)
{
switch (op_bits(VAR_0)) {
case 32:
return INDEX_op_movi_i32;
#if TCG_TARGET_REG_BITS == 64
case 64:
return INDEX_op_movi_i64;
#endif
default:
fprintf(stderr, "FUNC_0: unexpected return value of "
"function op_bits.\n");
tcg_abort();
}
}
| [
"static int FUNC_0(int VAR_0)\n{",
"switch (op_bits(VAR_0)) {",
"case 32:\nreturn INDEX_op_movi_i32;",
"#if TCG_TARGET_REG_BITS == 64\ncase 64:\nreturn INDEX_op_movi_i64;",
"#endif\ndefault:\nfprintf(stderr, \"FUNC_0: unexpected return value of \"\n\"function op_bits.\\n\");",
"tcg_abort();",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
11,
13,
15
],
[
17,
19,
21,
23
],
[
25
],
[
27
],
[
29
]
] |
21,547 | static void dbdma_end(DBDMA_io *io)
{
DBDMA_channel *ch = io->channel;
dbdma_cmd *current = &ch->current;
if (conditional_wait(ch))
goto wait;
current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
current->res_count = cpu_to_le16(be32_to_cpu(io->len));
dbdma_cmdptr_save(ch);
if (io->is_last)
ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
conditional_interrupt(ch);
conditional_branch(ch);
wait:
ch->processing = 0;
if ((ch->regs[DBDMA_STATUS] & cpu_to_be32(RUN)) &&
(ch->regs[DBDMA_STATUS] & cpu_to_be32(ACTIVE)))
channel_run(ch);
}
| false | qemu | ad674e53b5cce265fadafbde2c6a4f190345cd00 | static void dbdma_end(DBDMA_io *io)
{
DBDMA_channel *ch = io->channel;
dbdma_cmd *current = &ch->current;
if (conditional_wait(ch))
goto wait;
current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
current->res_count = cpu_to_le16(be32_to_cpu(io->len));
dbdma_cmdptr_save(ch);
if (io->is_last)
ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
conditional_interrupt(ch);
conditional_branch(ch);
wait:
ch->processing = 0;
if ((ch->regs[DBDMA_STATUS] & cpu_to_be32(RUN)) &&
(ch->regs[DBDMA_STATUS] & cpu_to_be32(ACTIVE)))
channel_run(ch);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DBDMA_io *VAR_0)
{
DBDMA_channel *ch = VAR_0->channel;
dbdma_cmd *current = &ch->current;
if (conditional_wait(ch))
goto wait;
current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));
current->res_count = cpu_to_le16(be32_to_cpu(VAR_0->len));
dbdma_cmdptr_save(ch);
if (VAR_0->is_last)
ch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);
conditional_interrupt(ch);
conditional_branch(ch);
wait:
ch->processing = 0;
if ((ch->regs[DBDMA_STATUS] & cpu_to_be32(RUN)) &&
(ch->regs[DBDMA_STATUS] & cpu_to_be32(ACTIVE)))
channel_run(ch);
}
| [
"static void FUNC_0(DBDMA_io *VAR_0)\n{",
"DBDMA_channel *ch = VAR_0->channel;",
"dbdma_cmd *current = &ch->current;",
"if (conditional_wait(ch))\ngoto wait;",
"current->xfer_status = cpu_to_le16(be32_to_cpu(ch->regs[DBDMA_STATUS]));",
"current->res_count = cpu_to_le16(be32_to_cpu(VAR_0->len));",
"dbdma_cmdptr_save(ch);",
"if (VAR_0->is_last)\nch->regs[DBDMA_STATUS] &= cpu_to_be32(~FLUSH);",
"conditional_interrupt(ch);",
"conditional_branch(ch);",
"wait:\nch->processing = 0;",
"if ((ch->regs[DBDMA_STATUS] & cpu_to_be32(RUN)) &&\n(ch->regs[DBDMA_STATUS] & cpu_to_be32(ACTIVE)))\nchannel_run(ch);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
29
],
[
31
],
[
35,
37
],
[
39,
41,
43
],
[
45
]
] |
21,548 | static void nfs_process_read(void *arg)
{
NFSClient *client = arg;
aio_context_acquire(client->aio_context);
nfs_service(client->context, POLLIN);
nfs_set_events(client);
aio_context_release(client->aio_context);
}
| false | qemu | 37d1e4d9bfac846a1331375aab3d13b54a048c01 | static void nfs_process_read(void *arg)
{
NFSClient *client = arg;
aio_context_acquire(client->aio_context);
nfs_service(client->context, POLLIN);
nfs_set_events(client);
aio_context_release(client->aio_context);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
NFSClient *client = VAR_0;
aio_context_acquire(client->aio_context);
nfs_service(client->context, POLLIN);
nfs_set_events(client);
aio_context_release(client->aio_context);
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"NFSClient *client = VAR_0;",
"aio_context_acquire(client->aio_context);",
"nfs_service(client->context, POLLIN);",
"nfs_set_events(client);",
"aio_context_release(client->aio_context);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
21,550 | int qemu_init_main_loop(void)
{
int ret;
qemu_init_sigbus();
ret = qemu_signal_init();
if (ret) {
return ret;
}
/* Note eventfd must be drained before signalfd handlers run */
ret = qemu_event_init();
if (ret) {
return ret;
}
qemu_cond_init(&qemu_cpu_cond);
qemu_cond_init(&qemu_system_cond);
qemu_cond_init(&qemu_pause_cond);
qemu_cond_init(&qemu_work_cond);
qemu_cond_init(&qemu_io_proceeded_cond);
qemu_mutex_init(&qemu_global_mutex);
qemu_mutex_lock(&qemu_global_mutex);
qemu_thread_get_self(&io_thread);
return 0;
}
| false | qemu | fa7d1867578b6a1afc39d4ece8629a1e92baddd7 | int qemu_init_main_loop(void)
{
int ret;
qemu_init_sigbus();
ret = qemu_signal_init();
if (ret) {
return ret;
}
ret = qemu_event_init();
if (ret) {
return ret;
}
qemu_cond_init(&qemu_cpu_cond);
qemu_cond_init(&qemu_system_cond);
qemu_cond_init(&qemu_pause_cond);
qemu_cond_init(&qemu_work_cond);
qemu_cond_init(&qemu_io_proceeded_cond);
qemu_mutex_init(&qemu_global_mutex);
qemu_mutex_lock(&qemu_global_mutex);
qemu_thread_get_self(&io_thread);
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(void)
{
int VAR_0;
qemu_init_sigbus();
VAR_0 = qemu_signal_init();
if (VAR_0) {
return VAR_0;
}
VAR_0 = qemu_event_init();
if (VAR_0) {
return VAR_0;
}
qemu_cond_init(&qemu_cpu_cond);
qemu_cond_init(&qemu_system_cond);
qemu_cond_init(&qemu_pause_cond);
qemu_cond_init(&qemu_work_cond);
qemu_cond_init(&qemu_io_proceeded_cond);
qemu_mutex_init(&qemu_global_mutex);
qemu_mutex_lock(&qemu_global_mutex);
qemu_thread_get_self(&io_thread);
return 0;
}
| [
"int FUNC_0(void)\n{",
"int VAR_0;",
"qemu_init_sigbus();",
"VAR_0 = qemu_signal_init();",
"if (VAR_0) {",
"return VAR_0;",
"}",
"VAR_0 = qemu_event_init();",
"if (VAR_0) {",
"return VAR_0;",
"}",
"qemu_cond_init(&qemu_cpu_cond);",
"qemu_cond_init(&qemu_system_cond);",
"qemu_cond_init(&qemu_pause_cond);",
"qemu_cond_init(&qemu_work_cond);",
"qemu_cond_init(&qemu_io_proceeded_cond);",
"qemu_mutex_init(&qemu_global_mutex);",
"qemu_mutex_lock(&qemu_global_mutex);",
"qemu_thread_get_self(&io_thread);",
"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
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
55
],
[
57
]
] |
21,551 | static bool blit_is_unsafe(struct CirrusVGAState *s, bool dst_only)
{
/* should be the case, see cirrus_bitblt_start */
assert(s->cirrus_blt_width > 0);
assert(s->cirrus_blt_height > 0);
if (s->cirrus_blt_width > CIRRUS_BLTBUFSIZE) {
return true;
}
if (blit_region_is_unsafe(s, s->cirrus_blt_dstpitch,
s->cirrus_blt_dstaddr & s->cirrus_addr_mask)) {
return true;
}
if (dst_only) {
return false;
}
if (blit_region_is_unsafe(s, s->cirrus_blt_srcpitch,
s->cirrus_blt_srcaddr & s->cirrus_addr_mask)) {
return true;
}
return false;
}
| false | qemu | 5858dd1801883309bdd208d72ddb81c4e9fee30c | static bool blit_is_unsafe(struct CirrusVGAState *s, bool dst_only)
{
assert(s->cirrus_blt_width > 0);
assert(s->cirrus_blt_height > 0);
if (s->cirrus_blt_width > CIRRUS_BLTBUFSIZE) {
return true;
}
if (blit_region_is_unsafe(s, s->cirrus_blt_dstpitch,
s->cirrus_blt_dstaddr & s->cirrus_addr_mask)) {
return true;
}
if (dst_only) {
return false;
}
if (blit_region_is_unsafe(s, s->cirrus_blt_srcpitch,
s->cirrus_blt_srcaddr & s->cirrus_addr_mask)) {
return true;
}
return false;
}
| {
"code": [],
"line_no": []
} | static bool FUNC_0(struct CirrusVGAState *s, bool dst_only)
{
assert(s->cirrus_blt_width > 0);
assert(s->cirrus_blt_height > 0);
if (s->cirrus_blt_width > CIRRUS_BLTBUFSIZE) {
return true;
}
if (blit_region_is_unsafe(s, s->cirrus_blt_dstpitch,
s->cirrus_blt_dstaddr & s->cirrus_addr_mask)) {
return true;
}
if (dst_only) {
return false;
}
if (blit_region_is_unsafe(s, s->cirrus_blt_srcpitch,
s->cirrus_blt_srcaddr & s->cirrus_addr_mask)) {
return true;
}
return false;
}
| [
"static bool FUNC_0(struct CirrusVGAState *s, bool dst_only)\n{",
"assert(s->cirrus_blt_width > 0);",
"assert(s->cirrus_blt_height > 0);",
"if (s->cirrus_blt_width > CIRRUS_BLTBUFSIZE) {",
"return true;",
"}",
"if (blit_region_is_unsafe(s, s->cirrus_blt_dstpitch,\ns->cirrus_blt_dstaddr & s->cirrus_addr_mask)) {",
"return true;",
"}",
"if (dst_only) {",
"return false;",
"}",
"if (blit_region_is_unsafe(s, s->cirrus_blt_srcpitch,\ns->cirrus_blt_srcaddr & s->cirrus_addr_mask)) {",
"return true;",
"}",
"return false;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
45
],
[
47
]
] |
21,552 | static void virtio_pci_register_devices(void)
{
type_register_static(&virtio_blk_info);
type_register_static_alias(&virtio_blk_info, "virtio-blk");
type_register_static(&virtio_net_info);
type_register_static_alias(&virtio_net_info, "virtio-net");
type_register_static(&virtio_serial_info);
type_register_static_alias(&virtio_serial_info, "virtio-serial");
type_register_static(&virtio_balloon_info);
type_register_static_alias(&virtio_balloon_info, "virtio-balloon");
}
| false | qemu | 6acbe4c6f18e7de00481ff30574262b58526de45 | static void virtio_pci_register_devices(void)
{
type_register_static(&virtio_blk_info);
type_register_static_alias(&virtio_blk_info, "virtio-blk");
type_register_static(&virtio_net_info);
type_register_static_alias(&virtio_net_info, "virtio-net");
type_register_static(&virtio_serial_info);
type_register_static_alias(&virtio_serial_info, "virtio-serial");
type_register_static(&virtio_balloon_info);
type_register_static_alias(&virtio_balloon_info, "virtio-balloon");
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
type_register_static(&virtio_blk_info);
type_register_static_alias(&virtio_blk_info, "virtio-blk");
type_register_static(&virtio_net_info);
type_register_static_alias(&virtio_net_info, "virtio-net");
type_register_static(&virtio_serial_info);
type_register_static_alias(&virtio_serial_info, "virtio-serial");
type_register_static(&virtio_balloon_info);
type_register_static_alias(&virtio_balloon_info, "virtio-balloon");
}
| [
"static void FUNC_0(void)\n{",
"type_register_static(&virtio_blk_info);",
"type_register_static_alias(&virtio_blk_info, \"virtio-blk\");",
"type_register_static(&virtio_net_info);",
"type_register_static_alias(&virtio_net_info, \"virtio-net\");",
"type_register_static(&virtio_serial_info);",
"type_register_static_alias(&virtio_serial_info, \"virtio-serial\");",
"type_register_static(&virtio_balloon_info);",
"type_register_static_alias(&virtio_balloon_info, \"virtio-balloon\");",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
21,553 | static MemTxResult nvic_sysreg_read(void *opaque, hwaddr addr,
uint64_t *data, unsigned size,
MemTxAttrs attrs)
{
NVICState *s = (NVICState *)opaque;
uint32_t offset = addr;
unsigned i, startvec, end;
uint32_t val;
if (attrs.user && !nvic_user_access_ok(s, addr)) {
/* Generate BusFault for unprivileged accesses */
return MEMTX_ERROR;
}
switch (offset) {
/* reads of set and clear both return the status */
case 0x100 ... 0x13f: /* NVIC Set enable */
offset += 0x80;
/* fall through */
case 0x180 ... 0x1bf: /* NVIC Clear enable */
val = 0;
startvec = offset - 0x180 + NVIC_FIRST_IRQ; /* vector # */
for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
if (s->vectors[startvec + i].enabled) {
val |= (1 << i);
}
}
break;
case 0x200 ... 0x23f: /* NVIC Set pend */
offset += 0x80;
/* fall through */
case 0x280 ... 0x2bf: /* NVIC Clear pend */
val = 0;
startvec = offset - 0x280 + NVIC_FIRST_IRQ; /* vector # */
for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
if (s->vectors[startvec + i].pending) {
val |= (1 << i);
}
}
break;
case 0x300 ... 0x33f: /* NVIC Active */
val = 0;
startvec = offset - 0x300 + NVIC_FIRST_IRQ; /* vector # */
for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
if (s->vectors[startvec + i].active) {
val |= (1 << i);
}
}
break;
case 0x400 ... 0x5ef: /* NVIC Priority */
val = 0;
startvec = offset - 0x400 + NVIC_FIRST_IRQ; /* vector # */
for (i = 0; i < size && startvec + i < s->num_irq; i++) {
val |= s->vectors[startvec + i].prio << (8 * i);
}
break;
case 0xd18 ... 0xd23: /* System Handler Priority. */
val = 0;
for (i = 0; i < size; i++) {
val |= s->vectors[(offset - 0xd14) + i].prio << (i * 8);
}
break;
case 0xfe0 ... 0xfff: /* ID. */
if (offset & 3) {
val = 0;
} else {
val = nvic_id[(offset - 0xfe0) >> 2];
}
break;
default:
if (size == 4) {
val = nvic_readl(s, offset);
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"NVIC: Bad read of size %d at offset 0x%x\n",
size, offset);
val = 0;
}
}
trace_nvic_sysreg_read(addr, val, size);
*data = val;
return MEMTX_OK;
}
| false | qemu | 45db7ba681ede57113a67499840e69ee586bcdf2 | static MemTxResult nvic_sysreg_read(void *opaque, hwaddr addr,
uint64_t *data, unsigned size,
MemTxAttrs attrs)
{
NVICState *s = (NVICState *)opaque;
uint32_t offset = addr;
unsigned i, startvec, end;
uint32_t val;
if (attrs.user && !nvic_user_access_ok(s, addr)) {
return MEMTX_ERROR;
}
switch (offset) {
case 0x100 ... 0x13f:
offset += 0x80;
case 0x180 ... 0x1bf:
val = 0;
startvec = offset - 0x180 + NVIC_FIRST_IRQ;
for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
if (s->vectors[startvec + i].enabled) {
val |= (1 << i);
}
}
break;
case 0x200 ... 0x23f:
offset += 0x80;
case 0x280 ... 0x2bf:
val = 0;
startvec = offset - 0x280 + NVIC_FIRST_IRQ;
for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
if (s->vectors[startvec + i].pending) {
val |= (1 << i);
}
}
break;
case 0x300 ... 0x33f:
val = 0;
startvec = offset - 0x300 + NVIC_FIRST_IRQ;
for (i = 0, end = size * 8; i < end && startvec + i < s->num_irq; i++) {
if (s->vectors[startvec + i].active) {
val |= (1 << i);
}
}
break;
case 0x400 ... 0x5ef:
val = 0;
startvec = offset - 0x400 + NVIC_FIRST_IRQ;
for (i = 0; i < size && startvec + i < s->num_irq; i++) {
val |= s->vectors[startvec + i].prio << (8 * i);
}
break;
case 0xd18 ... 0xd23:
val = 0;
for (i = 0; i < size; i++) {
val |= s->vectors[(offset - 0xd14) + i].prio << (i * 8);
}
break;
case 0xfe0 ... 0xfff:
if (offset & 3) {
val = 0;
} else {
val = nvic_id[(offset - 0xfe0) >> 2];
}
break;
default:
if (size == 4) {
val = nvic_readl(s, offset);
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"NVIC: Bad read of size %d at offset 0x%x\n",
size, offset);
val = 0;
}
}
trace_nvic_sysreg_read(addr, val, size);
*data = val;
return MEMTX_OK;
}
| {
"code": [],
"line_no": []
} | static MemTxResult FUNC_0(void *opaque, hwaddr addr,
uint64_t *data, unsigned size,
MemTxAttrs attrs)
{
NVICState *s = (NVICState *)opaque;
uint32_t offset = addr;
unsigned VAR_0, VAR_1, VAR_2;
uint32_t val;
if (attrs.user && !nvic_user_access_ok(s, addr)) {
return MEMTX_ERROR;
}
switch (offset) {
case 0x100 ... 0x13f:
offset += 0x80;
case 0x180 ... 0x1bf:
val = 0;
VAR_1 = offset - 0x180 + NVIC_FIRST_IRQ;
for (VAR_0 = 0, VAR_2 = size * 8; VAR_0 < VAR_2 && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {
if (s->vectors[VAR_1 + VAR_0].enabled) {
val |= (1 << VAR_0);
}
}
break;
case 0x200 ... 0x23f:
offset += 0x80;
case 0x280 ... 0x2bf:
val = 0;
VAR_1 = offset - 0x280 + NVIC_FIRST_IRQ;
for (VAR_0 = 0, VAR_2 = size * 8; VAR_0 < VAR_2 && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {
if (s->vectors[VAR_1 + VAR_0].pending) {
val |= (1 << VAR_0);
}
}
break;
case 0x300 ... 0x33f:
val = 0;
VAR_1 = offset - 0x300 + NVIC_FIRST_IRQ;
for (VAR_0 = 0, VAR_2 = size * 8; VAR_0 < VAR_2 && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {
if (s->vectors[VAR_1 + VAR_0].active) {
val |= (1 << VAR_0);
}
}
break;
case 0x400 ... 0x5ef:
val = 0;
VAR_1 = offset - 0x400 + NVIC_FIRST_IRQ;
for (VAR_0 = 0; VAR_0 < size && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {
val |= s->vectors[VAR_1 + VAR_0].prio << (8 * VAR_0);
}
break;
case 0xd18 ... 0xd23:
val = 0;
for (VAR_0 = 0; VAR_0 < size; VAR_0++) {
val |= s->vectors[(offset - 0xd14) + VAR_0].prio << (VAR_0 * 8);
}
break;
case 0xfe0 ... 0xfff:
if (offset & 3) {
val = 0;
} else {
val = nvic_id[(offset - 0xfe0) >> 2];
}
break;
default:
if (size == 4) {
val = nvic_readl(s, offset);
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"NVIC: Bad read of size %d at offset 0x%x\n",
size, offset);
val = 0;
}
}
trace_nvic_sysreg_read(addr, val, size);
*data = val;
return MEMTX_OK;
}
| [
"static MemTxResult FUNC_0(void *opaque, hwaddr addr,\nuint64_t *data, unsigned size,\nMemTxAttrs attrs)\n{",
"NVICState *s = (NVICState *)opaque;",
"uint32_t offset = addr;",
"unsigned VAR_0, VAR_1, VAR_2;",
"uint32_t val;",
"if (attrs.user && !nvic_user_access_ok(s, addr)) {",
"return MEMTX_ERROR;",
"}",
"switch (offset) {",
"case 0x100 ... 0x13f:\noffset += 0x80;",
"case 0x180 ... 0x1bf:\nval = 0;",
"VAR_1 = offset - 0x180 + NVIC_FIRST_IRQ;",
"for (VAR_0 = 0, VAR_2 = size * 8; VAR_0 < VAR_2 && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {",
"if (s->vectors[VAR_1 + VAR_0].enabled) {",
"val |= (1 << VAR_0);",
"}",
"}",
"break;",
"case 0x200 ... 0x23f:\noffset += 0x80;",
"case 0x280 ... 0x2bf:\nval = 0;",
"VAR_1 = offset - 0x280 + NVIC_FIRST_IRQ;",
"for (VAR_0 = 0, VAR_2 = size * 8; VAR_0 < VAR_2 && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {",
"if (s->vectors[VAR_1 + VAR_0].pending) {",
"val |= (1 << VAR_0);",
"}",
"}",
"break;",
"case 0x300 ... 0x33f:\nval = 0;",
"VAR_1 = offset - 0x300 + NVIC_FIRST_IRQ;",
"for (VAR_0 = 0, VAR_2 = size * 8; VAR_0 < VAR_2 && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {",
"if (s->vectors[VAR_1 + VAR_0].active) {",
"val |= (1 << VAR_0);",
"}",
"}",
"break;",
"case 0x400 ... 0x5ef:\nval = 0;",
"VAR_1 = offset - 0x400 + NVIC_FIRST_IRQ;",
"for (VAR_0 = 0; VAR_0 < size && VAR_1 + VAR_0 < s->num_irq; VAR_0++) {",
"val |= s->vectors[VAR_1 + VAR_0].prio << (8 * VAR_0);",
"}",
"break;",
"case 0xd18 ... 0xd23:\nval = 0;",
"for (VAR_0 = 0; VAR_0 < size; VAR_0++) {",
"val |= s->vectors[(offset - 0xd14) + VAR_0].prio << (VAR_0 * 8);",
"}",
"break;",
"case 0xfe0 ... 0xfff:\nif (offset & 3) {",
"val = 0;",
"} else {",
"val = nvic_id[(offset - 0xfe0) >> 2];",
"}",
"break;",
"default:\nif (size == 4) {",
"val = nvic_readl(s, offset);",
"} else {",
"qemu_log_mask(LOG_GUEST_ERROR,\n\"NVIC: Bad read of size %d at offset 0x%x\\n\",\nsize, offset);",
"val = 0;",
"}",
"}",
"trace_nvic_sysreg_read(addr, val, size);",
"*data = val;",
"return MEMTX_OK;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
29
],
[
33,
35
],
[
39,
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59,
61
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119,
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131,
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145,
147
],
[
149
],
[
151
],
[
153,
155,
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
169
],
[
171
],
[
173
]
] |
21,554 | coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask iTask;
struct unmap_list list;
if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {
return -ENOTSUP;
}
if (!iscsilun->lbp.lbpu) {
/* UNMAP is not supported by the target */
return 0;
}
list.lba = offset / iscsilun->block_size;
list.num = count / iscsilun->block_size;
iscsi_co_init_iscsitask(iscsilun, &iTask);
retry:
if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,
iscsi_co_generic_cb, &iTask) == NULL) {
return -ENOMEM;
}
while (!iTask.complete) {
iscsi_set_events(iscsilun);
qemu_coroutine_yield();
}
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
iTask.task = NULL;
}
if (iTask.do_retry) {
iTask.complete = 0;
goto retry;
}
if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {
/* the target might fail with a check condition if it
is not happy with the alignment of the UNMAP request
we silently fail in this case */
return 0;
}
if (iTask.status != SCSI_STATUS_GOOD) {
return iTask.err_code;
}
iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,
count >> BDRV_SECTOR_BITS);
return 0;
}
| false | qemu | d045c466d9e62b4321fadf586d024d54ddfd8bd4 | coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask iTask;
struct unmap_list list;
if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {
return -ENOTSUP;
}
if (!iscsilun->lbp.lbpu) {
return 0;
}
list.lba = offset / iscsilun->block_size;
list.num = count / iscsilun->block_size;
iscsi_co_init_iscsitask(iscsilun, &iTask);
retry:
if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,
iscsi_co_generic_cb, &iTask) == NULL) {
return -ENOMEM;
}
while (!iTask.complete) {
iscsi_set_events(iscsilun);
qemu_coroutine_yield();
}
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
iTask.task = NULL;
}
if (iTask.do_retry) {
iTask.complete = 0;
goto retry;
}
if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {
return 0;
}
if (iTask.status != SCSI_STATUS_GOOD) {
return iTask.err_code;
}
iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,
count >> BDRV_SECTOR_BITS);
return 0;
}
| {
"code": [],
"line_no": []
} | coroutine_fn FUNC_0(BlockDriverState *bs, int64_t offset, int count)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask VAR_0;
struct unmap_list VAR_1;
if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {
return -ENOTSUP;
}
if (!iscsilun->lbp.lbpu) {
return 0;
}
VAR_1.lba = offset / iscsilun->block_size;
VAR_1.num = count / iscsilun->block_size;
iscsi_co_init_iscsitask(iscsilun, &VAR_0);
retry:
if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &VAR_1, 1,
iscsi_co_generic_cb, &VAR_0) == NULL) {
return -ENOMEM;
}
while (!VAR_0.complete) {
iscsi_set_events(iscsilun);
qemu_coroutine_yield();
}
if (VAR_0.task != NULL) {
scsi_free_scsi_task(VAR_0.task);
VAR_0.task = NULL;
}
if (VAR_0.do_retry) {
VAR_0.complete = 0;
goto retry;
}
if (VAR_0.status == SCSI_STATUS_CHECK_CONDITION) {
return 0;
}
if (VAR_0.status != SCSI_STATUS_GOOD) {
return VAR_0.err_code;
}
iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,
count >> BDRV_SECTOR_BITS);
return 0;
}
| [
"coroutine_fn FUNC_0(BlockDriverState *bs, int64_t offset, int count)\n{",
"IscsiLun *iscsilun = bs->opaque;",
"struct IscsiTask VAR_0;",
"struct unmap_list VAR_1;",
"if (!is_byte_request_lun_aligned(offset, count, iscsilun)) {",
"return -ENOTSUP;",
"}",
"if (!iscsilun->lbp.lbpu) {",
"return 0;",
"}",
"VAR_1.lba = offset / iscsilun->block_size;",
"VAR_1.num = count / iscsilun->block_size;",
"iscsi_co_init_iscsitask(iscsilun, &VAR_0);",
"retry:\nif (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &VAR_1, 1,\niscsi_co_generic_cb, &VAR_0) == NULL) {",
"return -ENOMEM;",
"}",
"while (!VAR_0.complete) {",
"iscsi_set_events(iscsilun);",
"qemu_coroutine_yield();",
"}",
"if (VAR_0.task != NULL) {",
"scsi_free_scsi_task(VAR_0.task);",
"VAR_0.task = NULL;",
"}",
"if (VAR_0.do_retry) {",
"VAR_0.complete = 0;",
"goto retry;",
"}",
"if (VAR_0.status == SCSI_STATUS_CHECK_CONDITION) {",
"return 0;",
"}",
"if (VAR_0.status != SCSI_STATUS_GOOD) {",
"return VAR_0.err_code;",
"}",
"iscsi_allocmap_set_invalid(iscsilun, offset >> BDRV_SECTOR_BITS,\ncount >> BDRV_SECTOR_BITS);",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39,
41,
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
103,
105
],
[
109
],
[
111
]
] |
21,556 | static ssize_t qio_channel_command_writev(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
int *fds,
size_t nfds,
Error **errp)
{
QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
ssize_t ret;
retry:
ret = writev(cioc->writefd, iov, niov);
if (ret <= 0) {
if (errno == EAGAIN ||
errno == EWOULDBLOCK) {
return QIO_CHANNEL_ERR_BLOCK;
}
if (errno == EINTR) {
goto retry;
}
error_setg_errno(errp, errno, "%s",
"Unable to write to command");
return -1;
}
return ret;
}
| false | qemu | 30fd3e27907dfd1c0c66cc1339657af1a2ce1d4b | static ssize_t qio_channel_command_writev(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
int *fds,
size_t nfds,
Error **errp)
{
QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
ssize_t ret;
retry:
ret = writev(cioc->writefd, iov, niov);
if (ret <= 0) {
if (errno == EAGAIN ||
errno == EWOULDBLOCK) {
return QIO_CHANNEL_ERR_BLOCK;
}
if (errno == EINTR) {
goto retry;
}
error_setg_errno(errp, errno, "%s",
"Unable to write to command");
return -1;
}
return ret;
}
| {
"code": [],
"line_no": []
} | static ssize_t FUNC_0(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
int *fds,
size_t nfds,
Error **errp)
{
QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
ssize_t ret;
retry:
ret = writev(cioc->writefd, iov, niov);
if (ret <= 0) {
if (errno == EAGAIN ||
errno == EWOULDBLOCK) {
return QIO_CHANNEL_ERR_BLOCK;
}
if (errno == EINTR) {
goto retry;
}
error_setg_errno(errp, errno, "%s",
"Unable to write to command");
return -1;
}
return ret;
}
| [
"static ssize_t FUNC_0(QIOChannel *ioc,\nconst struct iovec *iov,\nsize_t niov,\nint *fds,\nsize_t nfds,\nError **errp)\n{",
"QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);",
"ssize_t ret;",
"retry:\nret = writev(cioc->writefd, iov, niov);",
"if (ret <= 0) {",
"if (errno == EAGAIN ||\nerrno == EWOULDBLOCK) {",
"return QIO_CHANNEL_ERR_BLOCK;",
"}",
"if (errno == EINTR) {",
"goto retry;",
"}",
"error_setg_errno(errp, errno, \"%s\",\n\"Unable to write to command\");",
"return -1;",
"}",
"return ret;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
17
],
[
21,
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
]
] |
21,557 | static void v9fs_synth_fill_statbuf(V9fsSynthNode *node, struct stat *stbuf)
{
stbuf->st_dev = 0;
stbuf->st_ino = node->attr->inode;
stbuf->st_mode = node->attr->mode;
stbuf->st_nlink = node->attr->nlink;
stbuf->st_uid = 0;
stbuf->st_gid = 0;
stbuf->st_rdev = 0;
stbuf->st_size = 0;
stbuf->st_blksize = 0;
stbuf->st_blocks = 0;
stbuf->st_atime = 0;
stbuf->st_mtime = 0;
stbuf->st_ctime = 0;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e | static void v9fs_synth_fill_statbuf(V9fsSynthNode *node, struct stat *stbuf)
{
stbuf->st_dev = 0;
stbuf->st_ino = node->attr->inode;
stbuf->st_mode = node->attr->mode;
stbuf->st_nlink = node->attr->nlink;
stbuf->st_uid = 0;
stbuf->st_gid = 0;
stbuf->st_rdev = 0;
stbuf->st_size = 0;
stbuf->st_blksize = 0;
stbuf->st_blocks = 0;
stbuf->st_atime = 0;
stbuf->st_mtime = 0;
stbuf->st_ctime = 0;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(V9fsSynthNode *VAR_0, struct stat *VAR_1)
{
VAR_1->st_dev = 0;
VAR_1->st_ino = VAR_0->attr->inode;
VAR_1->st_mode = VAR_0->attr->mode;
VAR_1->st_nlink = VAR_0->attr->nlink;
VAR_1->st_uid = 0;
VAR_1->st_gid = 0;
VAR_1->st_rdev = 0;
VAR_1->st_size = 0;
VAR_1->st_blksize = 0;
VAR_1->st_blocks = 0;
VAR_1->st_atime = 0;
VAR_1->st_mtime = 0;
VAR_1->st_ctime = 0;
}
| [
"static void FUNC_0(V9fsSynthNode *VAR_0, struct stat *VAR_1)\n{",
"VAR_1->st_dev = 0;",
"VAR_1->st_ino = VAR_0->attr->inode;",
"VAR_1->st_mode = VAR_0->attr->mode;",
"VAR_1->st_nlink = VAR_0->attr->nlink;",
"VAR_1->st_uid = 0;",
"VAR_1->st_gid = 0;",
"VAR_1->st_rdev = 0;",
"VAR_1->st_size = 0;",
"VAR_1->st_blksize = 0;",
"VAR_1->st_blocks = 0;",
"VAR_1->st_atime = 0;",
"VAR_1->st_mtime = 0;",
"VAR_1->st_ctime = 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
]
] |
21,558 | void cpu_exec_init(CPUState *env)
{
CPUState **penv;
int cpu_index;
#if defined(CONFIG_USER_ONLY)
cpu_list_lock();
#endif
env->next_cpu = NULL;
penv = &first_cpu;
cpu_index = 0;
while (*penv != NULL) {
penv = &(*penv)->next_cpu;
cpu_index++;
}
env->cpu_index = cpu_index;
env->numa_node = 0;
TAILQ_INIT(&env->breakpoints);
TAILQ_INIT(&env->watchpoints);
*penv = env;
#if defined(CONFIG_USER_ONLY)
cpu_list_unlock();
#endif
#if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
vmstate_register(cpu_index, &vmstate_cpu_common, env);
register_savevm("cpu", cpu_index, CPU_SAVE_VERSION,
cpu_save, cpu_load, env);
#endif
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | void cpu_exec_init(CPUState *env)
{
CPUState **penv;
int cpu_index;
#if defined(CONFIG_USER_ONLY)
cpu_list_lock();
#endif
env->next_cpu = NULL;
penv = &first_cpu;
cpu_index = 0;
while (*penv != NULL) {
penv = &(*penv)->next_cpu;
cpu_index++;
}
env->cpu_index = cpu_index;
env->numa_node = 0;
TAILQ_INIT(&env->breakpoints);
TAILQ_INIT(&env->watchpoints);
*penv = env;
#if defined(CONFIG_USER_ONLY)
cpu_list_unlock();
#endif
#if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
vmstate_register(cpu_index, &vmstate_cpu_common, env);
register_savevm("cpu", cpu_index, CPU_SAVE_VERSION,
cpu_save, cpu_load, env);
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUState *VAR_0)
{
CPUState **penv;
int VAR_1;
#if defined(CONFIG_USER_ONLY)
cpu_list_lock();
#endif
VAR_0->next_cpu = NULL;
penv = &first_cpu;
VAR_1 = 0;
while (*penv != NULL) {
penv = &(*penv)->next_cpu;
VAR_1++;
}
VAR_0->VAR_1 = VAR_1;
VAR_0->numa_node = 0;
TAILQ_INIT(&VAR_0->breakpoints);
TAILQ_INIT(&VAR_0->watchpoints);
*penv = VAR_0;
#if defined(CONFIG_USER_ONLY)
cpu_list_unlock();
#endif
#if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
vmstate_register(VAR_1, &vmstate_cpu_common, VAR_0);
register_savevm("cpu", VAR_1, CPU_SAVE_VERSION,
cpu_save, cpu_load, VAR_0);
#endif
}
| [
"void FUNC_0(CPUState *VAR_0)\n{",
"CPUState **penv;",
"int VAR_1;",
"#if defined(CONFIG_USER_ONLY)\ncpu_list_lock();",
"#endif\nVAR_0->next_cpu = NULL;",
"penv = &first_cpu;",
"VAR_1 = 0;",
"while (*penv != NULL) {",
"penv = &(*penv)->next_cpu;",
"VAR_1++;",
"}",
"VAR_0->VAR_1 = VAR_1;",
"VAR_0->numa_node = 0;",
"TAILQ_INIT(&VAR_0->breakpoints);",
"TAILQ_INIT(&VAR_0->watchpoints);",
"*penv = VAR_0;",
"#if defined(CONFIG_USER_ONLY)\ncpu_list_unlock();",
"#endif\n#if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)\nvmstate_register(VAR_1, &vmstate_cpu_common, VAR_0);",
"register_savevm(\"cpu\", VAR_1, CPU_SAVE_VERSION,\ncpu_save, cpu_load, VAR_0);",
"#endif\n}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15,
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45,
47,
49
],
[
51,
53
],
[
55,
57
]
] |
21,559 | static void sdhci_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SDHCIClass *k = SDHCI_CLASS(klass);
dc->vmsd = &sdhci_vmstate;
dc->props = sdhci_properties;
dc->reset = sdhci_generic_reset;
dc->realize = sdhci_realize;
k->reset = sdhci_reset;
k->mem_read = sdhci_read;
k->mem_write = sdhci_write;
k->send_command = sdhci_send_command;
k->can_issue_command = sdhci_can_issue_command;
k->data_transfer = sdhci_data_transfer;
k->end_data_transfer = sdhci_end_transfer;
k->do_sdma_single = sdhci_sdma_transfer_single_block;
k->do_sdma_multi = sdhci_sdma_transfer_multi_blocks;
k->do_adma = sdhci_do_adma;
k->read_block_from_card = sdhci_read_block_from_card;
k->write_block_to_card = sdhci_write_block_to_card;
k->bdata_read = sdhci_read_dataport;
k->bdata_write = sdhci_write_dataport;
}
| false | qemu | d368ba4376b2c1c24175c74b3733b8fe64dbe8a6 | static void sdhci_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SDHCIClass *k = SDHCI_CLASS(klass);
dc->vmsd = &sdhci_vmstate;
dc->props = sdhci_properties;
dc->reset = sdhci_generic_reset;
dc->realize = sdhci_realize;
k->reset = sdhci_reset;
k->mem_read = sdhci_read;
k->mem_write = sdhci_write;
k->send_command = sdhci_send_command;
k->can_issue_command = sdhci_can_issue_command;
k->data_transfer = sdhci_data_transfer;
k->end_data_transfer = sdhci_end_transfer;
k->do_sdma_single = sdhci_sdma_transfer_single_block;
k->do_sdma_multi = sdhci_sdma_transfer_multi_blocks;
k->do_adma = sdhci_do_adma;
k->read_block_from_card = sdhci_read_block_from_card;
k->write_block_to_card = sdhci_write_block_to_card;
k->bdata_read = sdhci_read_dataport;
k->bdata_write = sdhci_write_dataport;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
SDHCIClass *k = SDHCI_CLASS(VAR_0);
dc->vmsd = &sdhci_vmstate;
dc->props = sdhci_properties;
dc->reset = sdhci_generic_reset;
dc->realize = sdhci_realize;
k->reset = sdhci_reset;
k->mem_read = sdhci_read;
k->mem_write = sdhci_write;
k->send_command = sdhci_send_command;
k->can_issue_command = sdhci_can_issue_command;
k->data_transfer = sdhci_data_transfer;
k->end_data_transfer = sdhci_end_transfer;
k->do_sdma_single = sdhci_sdma_transfer_single_block;
k->do_sdma_multi = sdhci_sdma_transfer_multi_blocks;
k->do_adma = sdhci_do_adma;
k->read_block_from_card = sdhci_read_block_from_card;
k->write_block_to_card = sdhci_write_block_to_card;
k->bdata_read = sdhci_read_dataport;
k->bdata_write = sdhci_write_dataport;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"SDHCIClass *k = SDHCI_CLASS(VAR_0);",
"dc->vmsd = &sdhci_vmstate;",
"dc->props = sdhci_properties;",
"dc->reset = sdhci_generic_reset;",
"dc->realize = sdhci_realize;",
"k->reset = sdhci_reset;",
"k->mem_read = sdhci_read;",
"k->mem_write = sdhci_write;",
"k->send_command = sdhci_send_command;",
"k->can_issue_command = sdhci_can_issue_command;",
"k->data_transfer = sdhci_data_transfer;",
"k->end_data_transfer = sdhci_end_transfer;",
"k->do_sdma_single = sdhci_sdma_transfer_single_block;",
"k->do_sdma_multi = sdhci_sdma_transfer_multi_blocks;",
"k->do_adma = sdhci_do_adma;",
"k->read_block_from_card = sdhci_read_block_from_card;",
"k->write_block_to_card = sdhci_write_block_to_card;",
"k->bdata_read = sdhci_read_dataport;",
"k->bdata_write = sdhci_write_dataport;",
"}"
] | [
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
],
[
49
]
] |
21,560 | static void ppc_heathrow_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
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;
const char *boot_device = machine->boot_order;
MemoryRegion *sysmem = get_system_memory();
PowerPCCPU *cpu = NULL;
CPUPPCState *env = NULL;
char *filename;
qemu_irq *pic, **heathrow_irqs;
int linux_boot, i;
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *bios = g_new(MemoryRegion, 1);
MemoryRegion *isa = g_new(MemoryRegion, 1);
uint32_t kernel_base, initrd_base, cmdline_base = 0;
int32_t kernel_size, initrd_size;
PCIBus *pci_bus;
PCIDevice *macio;
MACIOIDEState *macio_ide;
DeviceState *dev;
BusState *adb_bus;
int bios_size;
MemoryRegion *pic_mem;
MemoryRegion *escc_mem, *escc_bar = g_new(MemoryRegion, 1);
uint16_t ppc_boot_device;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
void *fw_cfg;
linux_boot = (kernel_filename != NULL);
/* init CPUs */
if (cpu_model == NULL)
cpu_model = "G3";
for (i = 0; i < smp_cpus; i++) {
cpu = cpu_ppc_init(cpu_model);
if (cpu == NULL) {
fprintf(stderr, "Unable to find PowerPC CPU definition\n");
exit(1);
}
env = &cpu->env;
/* Set time-base frequency to 16.6 Mhz */
cpu_ppc_tb_init(env, TBFREQ);
qemu_register_reset(ppc_heathrow_reset, cpu);
}
/* allocate RAM */
if (ram_size > (2047 << 20)) {
fprintf(stderr,
"qemu: Too much memory for this machine: %d MB, maximum 2047 MB\n",
((unsigned int)ram_size / (1 << 20)));
exit(1);
}
memory_region_allocate_system_memory(ram, NULL, "ppc_heathrow.ram",
ram_size);
memory_region_add_subregion(sysmem, 0, ram);
/* allocate and load BIOS */
memory_region_init_ram(bios, NULL, "ppc_heathrow.bios", BIOS_SIZE);
vmstate_register_ram_global(bios);
if (bios_name == NULL)
bios_name = PROM_FILENAME;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
memory_region_set_readonly(bios, true);
memory_region_add_subregion(sysmem, PROM_ADDR, bios);
/* Load OpenBIOS (ELF) */
if (filename) {
bios_size = load_elf(filename, 0, NULL, NULL, NULL, NULL,
1, ELF_MACHINE, 0);
g_free(filename);
} else {
bios_size = -1;
}
if (bios_size < 0 || bios_size > BIOS_SIZE) {
hw_error("qemu: could not load PowerPC bios '%s'\n", bios_name);
exit(1);
}
if (linux_boot) {
uint64_t lowaddr = 0;
int bswap_needed;
#ifdef BSWAP_NEEDED
bswap_needed = 1;
#else
bswap_needed = 0;
#endif
kernel_base = KERNEL_LOAD_ADDR;
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0);
if (kernel_size < 0)
kernel_size = load_aout(kernel_filename, kernel_base,
ram_size - kernel_base, bswap_needed,
TARGET_PAGE_SIZE);
if (kernel_size < 0)
kernel_size = load_image_targphys(kernel_filename,
kernel_base,
ram_size - kernel_base);
if (kernel_size < 0) {
hw_error("qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
/* load initrd */
if (initrd_filename) {
initrd_base = round_page(kernel_base + kernel_size + KERNEL_GAP);
initrd_size = load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
if (initrd_size < 0) {
hw_error("qemu: could not load initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
cmdline_base = round_page(initrd_base + initrd_size);
} else {
initrd_base = 0;
initrd_size = 0;
cmdline_base = round_page(kernel_base + kernel_size + KERNEL_GAP);
}
ppc_boot_device = 'm';
} else {
kernel_base = 0;
kernel_size = 0;
initrd_base = 0;
initrd_size = 0;
ppc_boot_device = '\0';
for (i = 0; boot_device[i] != '\0'; i++) {
/* TOFIX: for now, the second IDE channel is not properly
* used by OHW. The Mac floppy disk are not emulated.
* For now, OHW cannot boot from the network.
*/
#if 0
if (boot_device[i] >= 'a' && boot_device[i] <= 'f') {
ppc_boot_device = boot_device[i];
break;
}
#else
if (boot_device[i] >= 'c' && boot_device[i] <= 'd') {
ppc_boot_device = boot_device[i];
break;
}
#endif
}
if (ppc_boot_device == '\0') {
fprintf(stderr, "No valid boot device for G3 Beige machine\n");
exit(1);
}
}
/* Register 2 MB of ISA IO space */
memory_region_init_alias(isa, NULL, "isa_mmio",
get_system_io(), 0, 0x00200000);
memory_region_add_subregion(sysmem, 0xfe000000, isa);
/* XXX: we register only 1 output pin for heathrow PIC */
heathrow_irqs = g_malloc0(smp_cpus * sizeof(qemu_irq *));
heathrow_irqs[0] =
g_malloc0(smp_cpus * sizeof(qemu_irq) * 1);
/* Connect the heathrow PIC outputs to the 6xx bus */
for (i = 0; i < smp_cpus; i++) {
switch (PPC_INPUT(env)) {
case PPC_FLAGS_INPUT_6xx:
heathrow_irqs[i] = heathrow_irqs[0] + (i * 1);
heathrow_irqs[i][0] =
((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT];
break;
default:
hw_error("Bus model not supported on OldWorld Mac machine\n");
}
}
/* init basic PC hardware */
if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {
hw_error("Only 6xx bus is supported on heathrow machine\n");
}
pic = heathrow_pic_init(&pic_mem, 1, heathrow_irqs);
pci_bus = pci_grackle_init(0xfec00000, pic,
get_system_memory(),
get_system_io());
pci_vga_init(pci_bus);
escc_mem = escc_init(0, pic[0x0f], pic[0x10], serial_hds[0],
serial_hds[1], ESCC_CLOCK, 4);
memory_region_init_alias(escc_bar, NULL, "escc-bar",
escc_mem, 0, memory_region_size(escc_mem));
for(i = 0; i < nb_nics; i++)
pci_nic_init_nofail(&nd_table[i], pci_bus, "ne2k_pci", NULL);
ide_drive_get(hd, MAX_IDE_BUS);
macio = pci_create(pci_bus, -1, TYPE_OLDWORLD_MACIO);
dev = DEVICE(macio);
qdev_connect_gpio_out(dev, 0, pic[0x12]); /* CUDA */
qdev_connect_gpio_out(dev, 1, pic[0x0D]); /* IDE-0 */
qdev_connect_gpio_out(dev, 2, pic[0x02]); /* IDE-0 DMA */
qdev_connect_gpio_out(dev, 3, pic[0x0E]); /* IDE-1 */
qdev_connect_gpio_out(dev, 4, pic[0x03]); /* IDE-1 DMA */
macio_init(macio, pic_mem, escc_bar);
macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),
"ide[0]"));
macio_ide_init_drives(macio_ide, hd);
macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),
"ide[1]"));
macio_ide_init_drives(macio_ide, &hd[MAX_IDE_DEVS]);
dev = DEVICE(object_resolve_path_component(OBJECT(macio), "cuda"));
adb_bus = qdev_get_child_bus(dev, "adb.0");
dev = qdev_create(adb_bus, TYPE_ADB_KEYBOARD);
qdev_init_nofail(dev);
dev = qdev_create(adb_bus, TYPE_ADB_MOUSE);
qdev_init_nofail(dev);
if (usb_enabled(false)) {
pci_create_simple(pci_bus, -1, "pci-ohci");
}
if (graphic_depth != 15 && graphic_depth != 32 && graphic_depth != 8)
graphic_depth = 15;
/* No PCI init: the BIOS will do it */
fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);
fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);
fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, ARCH_HEATHROW);
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, kernel_base);
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
if (kernel_cmdline) {
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, cmdline_base);
pstrcpy_targphys("cmdline", cmdline_base, TARGET_PAGE_SIZE, kernel_cmdline);
} else {
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
}
fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, initrd_base);
fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size);
fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, ppc_boot_device);
fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_WIDTH, graphic_width);
fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_HEIGHT, graphic_height);
fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_DEPTH, graphic_depth);
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_IS_KVM, kvm_enabled());
if (kvm_enabled()) {
#ifdef CONFIG_KVM
uint8_t *hypercall;
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_TBFREQ, kvmppc_get_tbfreq());
hypercall = g_malloc(16);
kvmppc_get_hypercall(env, hypercall, 16);
fw_cfg_add_bytes(fw_cfg, FW_CFG_PPC_KVM_HC, hypercall, 16);
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_KVM_PID, getpid());
#endif
} else {
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_TBFREQ, TBFREQ);
}
/* Mac OS X requires a "known good" clock-frequency value; pass it one. */
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_CLOCKFREQ, CLOCKFREQ);
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_BUSFREQ, BUSFREQ);
qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);
}
| false | qemu | caae6c961107c4c55731a86572f9a1f53837636b | static void ppc_heathrow_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
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;
const char *boot_device = machine->boot_order;
MemoryRegion *sysmem = get_system_memory();
PowerPCCPU *cpu = NULL;
CPUPPCState *env = NULL;
char *filename;
qemu_irq *pic, **heathrow_irqs;
int linux_boot, i;
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *bios = g_new(MemoryRegion, 1);
MemoryRegion *isa = g_new(MemoryRegion, 1);
uint32_t kernel_base, initrd_base, cmdline_base = 0;
int32_t kernel_size, initrd_size;
PCIBus *pci_bus;
PCIDevice *macio;
MACIOIDEState *macio_ide;
DeviceState *dev;
BusState *adb_bus;
int bios_size;
MemoryRegion *pic_mem;
MemoryRegion *escc_mem, *escc_bar = g_new(MemoryRegion, 1);
uint16_t ppc_boot_device;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
void *fw_cfg;
linux_boot = (kernel_filename != NULL);
if (cpu_model == NULL)
cpu_model = "G3";
for (i = 0; i < smp_cpus; i++) {
cpu = cpu_ppc_init(cpu_model);
if (cpu == NULL) {
fprintf(stderr, "Unable to find PowerPC CPU definition\n");
exit(1);
}
env = &cpu->env;
cpu_ppc_tb_init(env, TBFREQ);
qemu_register_reset(ppc_heathrow_reset, cpu);
}
if (ram_size > (2047 << 20)) {
fprintf(stderr,
"qemu: Too much memory for this machine: %d MB, maximum 2047 MB\n",
((unsigned int)ram_size / (1 << 20)));
exit(1);
}
memory_region_allocate_system_memory(ram, NULL, "ppc_heathrow.ram",
ram_size);
memory_region_add_subregion(sysmem, 0, ram);
memory_region_init_ram(bios, NULL, "ppc_heathrow.bios", BIOS_SIZE);
vmstate_register_ram_global(bios);
if (bios_name == NULL)
bios_name = PROM_FILENAME;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
memory_region_set_readonly(bios, true);
memory_region_add_subregion(sysmem, PROM_ADDR, bios);
if (filename) {
bios_size = load_elf(filename, 0, NULL, NULL, NULL, NULL,
1, ELF_MACHINE, 0);
g_free(filename);
} else {
bios_size = -1;
}
if (bios_size < 0 || bios_size > BIOS_SIZE) {
hw_error("qemu: could not load PowerPC bios '%s'\n", bios_name);
exit(1);
}
if (linux_boot) {
uint64_t lowaddr = 0;
int bswap_needed;
#ifdef BSWAP_NEEDED
bswap_needed = 1;
#else
bswap_needed = 0;
#endif
kernel_base = KERNEL_LOAD_ADDR;
kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0);
if (kernel_size < 0)
kernel_size = load_aout(kernel_filename, kernel_base,
ram_size - kernel_base, bswap_needed,
TARGET_PAGE_SIZE);
if (kernel_size < 0)
kernel_size = load_image_targphys(kernel_filename,
kernel_base,
ram_size - kernel_base);
if (kernel_size < 0) {
hw_error("qemu: could not load kernel '%s'\n",
kernel_filename);
exit(1);
}
if (initrd_filename) {
initrd_base = round_page(kernel_base + kernel_size + KERNEL_GAP);
initrd_size = load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
if (initrd_size < 0) {
hw_error("qemu: could not load initial ram disk '%s'\n",
initrd_filename);
exit(1);
}
cmdline_base = round_page(initrd_base + initrd_size);
} else {
initrd_base = 0;
initrd_size = 0;
cmdline_base = round_page(kernel_base + kernel_size + KERNEL_GAP);
}
ppc_boot_device = 'm';
} else {
kernel_base = 0;
kernel_size = 0;
initrd_base = 0;
initrd_size = 0;
ppc_boot_device = '\0';
for (i = 0; boot_device[i] != '\0'; i++) {
#if 0
if (boot_device[i] >= 'a' && boot_device[i] <= 'f') {
ppc_boot_device = boot_device[i];
break;
}
#else
if (boot_device[i] >= 'c' && boot_device[i] <= 'd') {
ppc_boot_device = boot_device[i];
break;
}
#endif
}
if (ppc_boot_device == '\0') {
fprintf(stderr, "No valid boot device for G3 Beige machine\n");
exit(1);
}
}
memory_region_init_alias(isa, NULL, "isa_mmio",
get_system_io(), 0, 0x00200000);
memory_region_add_subregion(sysmem, 0xfe000000, isa);
heathrow_irqs = g_malloc0(smp_cpus * sizeof(qemu_irq *));
heathrow_irqs[0] =
g_malloc0(smp_cpus * sizeof(qemu_irq) * 1);
for (i = 0; i < smp_cpus; i++) {
switch (PPC_INPUT(env)) {
case PPC_FLAGS_INPUT_6xx:
heathrow_irqs[i] = heathrow_irqs[0] + (i * 1);
heathrow_irqs[i][0] =
((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT];
break;
default:
hw_error("Bus model not supported on OldWorld Mac machine\n");
}
}
if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {
hw_error("Only 6xx bus is supported on heathrow machine\n");
}
pic = heathrow_pic_init(&pic_mem, 1, heathrow_irqs);
pci_bus = pci_grackle_init(0xfec00000, pic,
get_system_memory(),
get_system_io());
pci_vga_init(pci_bus);
escc_mem = escc_init(0, pic[0x0f], pic[0x10], serial_hds[0],
serial_hds[1], ESCC_CLOCK, 4);
memory_region_init_alias(escc_bar, NULL, "escc-bar",
escc_mem, 0, memory_region_size(escc_mem));
for(i = 0; i < nb_nics; i++)
pci_nic_init_nofail(&nd_table[i], pci_bus, "ne2k_pci", NULL);
ide_drive_get(hd, MAX_IDE_BUS);
macio = pci_create(pci_bus, -1, TYPE_OLDWORLD_MACIO);
dev = DEVICE(macio);
qdev_connect_gpio_out(dev, 0, pic[0x12]);
qdev_connect_gpio_out(dev, 1, pic[0x0D]);
qdev_connect_gpio_out(dev, 2, pic[0x02]);
qdev_connect_gpio_out(dev, 3, pic[0x0E]);
qdev_connect_gpio_out(dev, 4, pic[0x03]);
macio_init(macio, pic_mem, escc_bar);
macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),
"ide[0]"));
macio_ide_init_drives(macio_ide, hd);
macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),
"ide[1]"));
macio_ide_init_drives(macio_ide, &hd[MAX_IDE_DEVS]);
dev = DEVICE(object_resolve_path_component(OBJECT(macio), "cuda"));
adb_bus = qdev_get_child_bus(dev, "adb.0");
dev = qdev_create(adb_bus, TYPE_ADB_KEYBOARD);
qdev_init_nofail(dev);
dev = qdev_create(adb_bus, TYPE_ADB_MOUSE);
qdev_init_nofail(dev);
if (usb_enabled(false)) {
pci_create_simple(pci_bus, -1, "pci-ohci");
}
if (graphic_depth != 15 && graphic_depth != 32 && graphic_depth != 8)
graphic_depth = 15;
fw_cfg = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);
fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);
fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, ARCH_HEATHROW);
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, kernel_base);
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size);
if (kernel_cmdline) {
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, cmdline_base);
pstrcpy_targphys("cmdline", cmdline_base, TARGET_PAGE_SIZE, kernel_cmdline);
} else {
fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0);
}
fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, initrd_base);
fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size);
fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, ppc_boot_device);
fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_WIDTH, graphic_width);
fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_HEIGHT, graphic_height);
fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_DEPTH, graphic_depth);
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_IS_KVM, kvm_enabled());
if (kvm_enabled()) {
#ifdef CONFIG_KVM
uint8_t *hypercall;
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_TBFREQ, kvmppc_get_tbfreq());
hypercall = g_malloc(16);
kvmppc_get_hypercall(env, hypercall, 16);
fw_cfg_add_bytes(fw_cfg, FW_CFG_PPC_KVM_HC, hypercall, 16);
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_KVM_PID, getpid());
#endif
} else {
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_TBFREQ, TBFREQ);
}
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_CLOCKFREQ, CLOCKFREQ);
fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_BUSFREQ, BUSFREQ);
qemu_register_boot_set(fw_cfg_boot_set, fw_cfg);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(MachineState *VAR_0)
{
ram_addr_t ram_size = VAR_0->ram_size;
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;
const char *VAR_5 = VAR_0->boot_order;
MemoryRegion *sysmem = get_system_memory();
PowerPCCPU *cpu = NULL;
CPUPPCState *env = NULL;
char *VAR_6;
qemu_irq *pic, **heathrow_irqs;
int VAR_7, VAR_8;
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *bios = g_new(MemoryRegion, 1);
MemoryRegion *isa = g_new(MemoryRegion, 1);
uint32_t kernel_base, initrd_base, cmdline_base = 0;
int32_t kernel_size, initrd_size;
PCIBus *pci_bus;
PCIDevice *macio;
MACIOIDEState *macio_ide;
DeviceState *dev;
BusState *adb_bus;
int VAR_9;
MemoryRegion *pic_mem;
MemoryRegion *escc_mem, *escc_bar = g_new(MemoryRegion, 1);
uint16_t ppc_boot_device;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
void *VAR_10;
VAR_7 = (VAR_2 != NULL);
if (VAR_1 == NULL)
VAR_1 = "G3";
for (VAR_8 = 0; VAR_8 < smp_cpus; VAR_8++) {
cpu = cpu_ppc_init(VAR_1);
if (cpu == NULL) {
fprintf(stderr, "Unable to find PowerPC CPU definition\n");
exit(1);
}
env = &cpu->env;
cpu_ppc_tb_init(env, TBFREQ);
qemu_register_reset(ppc_heathrow_reset, cpu);
}
if (ram_size > (2047 << 20)) {
fprintf(stderr,
"qemu: Too much memory for this VAR_0: %d MB, maximum 2047 MB\n",
((unsigned int)ram_size / (1 << 20)));
exit(1);
}
memory_region_allocate_system_memory(ram, NULL, "ppc_heathrow.ram",
ram_size);
memory_region_add_subregion(sysmem, 0, ram);
memory_region_init_ram(bios, NULL, "ppc_heathrow.bios", BIOS_SIZE);
vmstate_register_ram_global(bios);
if (bios_name == NULL)
bios_name = PROM_FILENAME;
VAR_6 = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
memory_region_set_readonly(bios, true);
memory_region_add_subregion(sysmem, PROM_ADDR, bios);
if (VAR_6) {
VAR_9 = load_elf(VAR_6, 0, NULL, NULL, NULL, NULL,
1, ELF_MACHINE, 0);
g_free(VAR_6);
} else {
VAR_9 = -1;
}
if (VAR_9 < 0 || VAR_9 > BIOS_SIZE) {
hw_error("qemu: could not load PowerPC bios '%s'\n", bios_name);
exit(1);
}
if (VAR_7) {
uint64_t lowaddr = 0;
int VAR_11;
#ifdef BSWAP_NEEDED
VAR_11 = 1;
#else
VAR_11 = 0;
#endif
kernel_base = KERNEL_LOAD_ADDR;
kernel_size = load_elf(VAR_2, translate_kernel_address, NULL,
NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0);
if (kernel_size < 0)
kernel_size = load_aout(VAR_2, kernel_base,
ram_size - kernel_base, VAR_11,
TARGET_PAGE_SIZE);
if (kernel_size < 0)
kernel_size = load_image_targphys(VAR_2,
kernel_base,
ram_size - kernel_base);
if (kernel_size < 0) {
hw_error("qemu: could not load kernel '%s'\n",
VAR_2);
exit(1);
}
if (VAR_4) {
initrd_base = round_page(kernel_base + kernel_size + KERNEL_GAP);
initrd_size = load_image_targphys(VAR_4, initrd_base,
ram_size - initrd_base);
if (initrd_size < 0) {
hw_error("qemu: could not load initial ram disk '%s'\n",
VAR_4);
exit(1);
}
cmdline_base = round_page(initrd_base + initrd_size);
} else {
initrd_base = 0;
initrd_size = 0;
cmdline_base = round_page(kernel_base + kernel_size + KERNEL_GAP);
}
ppc_boot_device = 'm';
} else {
kernel_base = 0;
kernel_size = 0;
initrd_base = 0;
initrd_size = 0;
ppc_boot_device = '\0';
for (VAR_8 = 0; VAR_5[VAR_8] != '\0'; VAR_8++) {
#if 0
if (VAR_5[VAR_8] >= 'a' && VAR_5[VAR_8] <= 'f') {
ppc_boot_device = VAR_5[VAR_8];
break;
}
#else
if (VAR_5[VAR_8] >= 'c' && VAR_5[VAR_8] <= 'd') {
ppc_boot_device = VAR_5[VAR_8];
break;
}
#endif
}
if (ppc_boot_device == '\0') {
fprintf(stderr, "No valid boot device for G3 Beige VAR_0\n");
exit(1);
}
}
memory_region_init_alias(isa, NULL, "isa_mmio",
get_system_io(), 0, 0x00200000);
memory_region_add_subregion(sysmem, 0xfe000000, isa);
heathrow_irqs = g_malloc0(smp_cpus * sizeof(qemu_irq *));
heathrow_irqs[0] =
g_malloc0(smp_cpus * sizeof(qemu_irq) * 1);
for (VAR_8 = 0; VAR_8 < smp_cpus; VAR_8++) {
switch (PPC_INPUT(env)) {
case PPC_FLAGS_INPUT_6xx:
heathrow_irqs[VAR_8] = heathrow_irqs[0] + (VAR_8 * 1);
heathrow_irqs[VAR_8][0] =
((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT];
break;
default:
hw_error("Bus model not supported on OldWorld Mac VAR_0\n");
}
}
if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {
hw_error("Only 6xx bus is supported on heathrow VAR_0\n");
}
pic = heathrow_pic_init(&pic_mem, 1, heathrow_irqs);
pci_bus = pci_grackle_init(0xfec00000, pic,
get_system_memory(),
get_system_io());
pci_vga_init(pci_bus);
escc_mem = escc_init(0, pic[0x0f], pic[0x10], serial_hds[0],
serial_hds[1], ESCC_CLOCK, 4);
memory_region_init_alias(escc_bar, NULL, "escc-bar",
escc_mem, 0, memory_region_size(escc_mem));
for(VAR_8 = 0; VAR_8 < nb_nics; VAR_8++)
pci_nic_init_nofail(&nd_table[VAR_8], pci_bus, "ne2k_pci", NULL);
ide_drive_get(hd, MAX_IDE_BUS);
macio = pci_create(pci_bus, -1, TYPE_OLDWORLD_MACIO);
dev = DEVICE(macio);
qdev_connect_gpio_out(dev, 0, pic[0x12]);
qdev_connect_gpio_out(dev, 1, pic[0x0D]);
qdev_connect_gpio_out(dev, 2, pic[0x02]);
qdev_connect_gpio_out(dev, 3, pic[0x0E]);
qdev_connect_gpio_out(dev, 4, pic[0x03]);
macio_init(macio, pic_mem, escc_bar);
macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),
"ide[0]"));
macio_ide_init_drives(macio_ide, hd);
macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),
"ide[1]"));
macio_ide_init_drives(macio_ide, &hd[MAX_IDE_DEVS]);
dev = DEVICE(object_resolve_path_component(OBJECT(macio), "cuda"));
adb_bus = qdev_get_child_bus(dev, "adb.0");
dev = qdev_create(adb_bus, TYPE_ADB_KEYBOARD);
qdev_init_nofail(dev);
dev = qdev_create(adb_bus, TYPE_ADB_MOUSE);
qdev_init_nofail(dev);
if (usb_enabled(false)) {
pci_create_simple(pci_bus, -1, "pci-ohci");
}
if (graphic_depth != 15 && graphic_depth != 32 && graphic_depth != 8)
graphic_depth = 15;
VAR_10 = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);
fw_cfg_add_i16(VAR_10, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);
fw_cfg_add_i32(VAR_10, FW_CFG_ID, 1);
fw_cfg_add_i64(VAR_10, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
fw_cfg_add_i16(VAR_10, FW_CFG_MACHINE_ID, ARCH_HEATHROW);
fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_ADDR, kernel_base);
fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_SIZE, kernel_size);
if (VAR_3) {
fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_CMDLINE, cmdline_base);
pstrcpy_targphys("cmdline", cmdline_base, TARGET_PAGE_SIZE, VAR_3);
} else {
fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_CMDLINE, 0);
}
fw_cfg_add_i32(VAR_10, FW_CFG_INITRD_ADDR, initrd_base);
fw_cfg_add_i32(VAR_10, FW_CFG_INITRD_SIZE, initrd_size);
fw_cfg_add_i16(VAR_10, FW_CFG_BOOT_DEVICE, ppc_boot_device);
fw_cfg_add_i16(VAR_10, FW_CFG_PPC_WIDTH, graphic_width);
fw_cfg_add_i16(VAR_10, FW_CFG_PPC_HEIGHT, graphic_height);
fw_cfg_add_i16(VAR_10, FW_CFG_PPC_DEPTH, graphic_depth);
fw_cfg_add_i32(VAR_10, FW_CFG_PPC_IS_KVM, kvm_enabled());
if (kvm_enabled()) {
#ifdef CONFIG_KVM
uint8_t *hypercall;
fw_cfg_add_i32(VAR_10, FW_CFG_PPC_TBFREQ, kvmppc_get_tbfreq());
hypercall = g_malloc(16);
kvmppc_get_hypercall(env, hypercall, 16);
fw_cfg_add_bytes(VAR_10, FW_CFG_PPC_KVM_HC, hypercall, 16);
fw_cfg_add_i32(VAR_10, FW_CFG_PPC_KVM_PID, getpid());
#endif
} else {
fw_cfg_add_i32(VAR_10, FW_CFG_PPC_TBFREQ, TBFREQ);
}
fw_cfg_add_i32(VAR_10, FW_CFG_PPC_CLOCKFREQ, CLOCKFREQ);
fw_cfg_add_i32(VAR_10, FW_CFG_PPC_BUSFREQ, BUSFREQ);
qemu_register_boot_set(fw_cfg_boot_set, VAR_10);
}
| [
"static void FUNC_0(MachineState *VAR_0)\n{",
"ram_addr_t ram_size = VAR_0->ram_size;",
"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;",
"const char *VAR_5 = VAR_0->boot_order;",
"MemoryRegion *sysmem = get_system_memory();",
"PowerPCCPU *cpu = NULL;",
"CPUPPCState *env = NULL;",
"char *VAR_6;",
"qemu_irq *pic, **heathrow_irqs;",
"int VAR_7, VAR_8;",
"MemoryRegion *ram = g_new(MemoryRegion, 1);",
"MemoryRegion *bios = g_new(MemoryRegion, 1);",
"MemoryRegion *isa = g_new(MemoryRegion, 1);",
"uint32_t kernel_base, initrd_base, cmdline_base = 0;",
"int32_t kernel_size, initrd_size;",
"PCIBus *pci_bus;",
"PCIDevice *macio;",
"MACIOIDEState *macio_ide;",
"DeviceState *dev;",
"BusState *adb_bus;",
"int VAR_9;",
"MemoryRegion *pic_mem;",
"MemoryRegion *escc_mem, *escc_bar = g_new(MemoryRegion, 1);",
"uint16_t ppc_boot_device;",
"DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];",
"void *VAR_10;",
"VAR_7 = (VAR_2 != NULL);",
"if (VAR_1 == NULL)\nVAR_1 = \"G3\";",
"for (VAR_8 = 0; VAR_8 < smp_cpus; VAR_8++) {",
"cpu = cpu_ppc_init(VAR_1);",
"if (cpu == NULL) {",
"fprintf(stderr, \"Unable to find PowerPC CPU definition\\n\");",
"exit(1);",
"}",
"env = &cpu->env;",
"cpu_ppc_tb_init(env, TBFREQ);",
"qemu_register_reset(ppc_heathrow_reset, cpu);",
"}",
"if (ram_size > (2047 << 20)) {",
"fprintf(stderr,\n\"qemu: Too much memory for this VAR_0: %d MB, maximum 2047 MB\\n\",\n((unsigned int)ram_size / (1 << 20)));",
"exit(1);",
"}",
"memory_region_allocate_system_memory(ram, NULL, \"ppc_heathrow.ram\",\nram_size);",
"memory_region_add_subregion(sysmem, 0, ram);",
"memory_region_init_ram(bios, NULL, \"ppc_heathrow.bios\", BIOS_SIZE);",
"vmstate_register_ram_global(bios);",
"if (bios_name == NULL)\nbios_name = PROM_FILENAME;",
"VAR_6 = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);",
"memory_region_set_readonly(bios, true);",
"memory_region_add_subregion(sysmem, PROM_ADDR, bios);",
"if (VAR_6) {",
"VAR_9 = load_elf(VAR_6, 0, NULL, NULL, NULL, NULL,\n1, ELF_MACHINE, 0);",
"g_free(VAR_6);",
"} else {",
"VAR_9 = -1;",
"}",
"if (VAR_9 < 0 || VAR_9 > BIOS_SIZE) {",
"hw_error(\"qemu: could not load PowerPC bios '%s'\\n\", bios_name);",
"exit(1);",
"}",
"if (VAR_7) {",
"uint64_t lowaddr = 0;",
"int VAR_11;",
"#ifdef BSWAP_NEEDED\nVAR_11 = 1;",
"#else\nVAR_11 = 0;",
"#endif\nkernel_base = KERNEL_LOAD_ADDR;",
"kernel_size = load_elf(VAR_2, translate_kernel_address, NULL,\nNULL, &lowaddr, NULL, 1, ELF_MACHINE, 0);",
"if (kernel_size < 0)\nkernel_size = load_aout(VAR_2, kernel_base,\nram_size - kernel_base, VAR_11,\nTARGET_PAGE_SIZE);",
"if (kernel_size < 0)\nkernel_size = load_image_targphys(VAR_2,\nkernel_base,\nram_size - kernel_base);",
"if (kernel_size < 0) {",
"hw_error(\"qemu: could not load kernel '%s'\\n\",\nVAR_2);",
"exit(1);",
"}",
"if (VAR_4) {",
"initrd_base = round_page(kernel_base + kernel_size + KERNEL_GAP);",
"initrd_size = load_image_targphys(VAR_4, initrd_base,\nram_size - initrd_base);",
"if (initrd_size < 0) {",
"hw_error(\"qemu: could not load initial ram disk '%s'\\n\",\nVAR_4);",
"exit(1);",
"}",
"cmdline_base = round_page(initrd_base + initrd_size);",
"} else {",
"initrd_base = 0;",
"initrd_size = 0;",
"cmdline_base = round_page(kernel_base + kernel_size + KERNEL_GAP);",
"}",
"ppc_boot_device = 'm';",
"} else {",
"kernel_base = 0;",
"kernel_size = 0;",
"initrd_base = 0;",
"initrd_size = 0;",
"ppc_boot_device = '\\0';",
"for (VAR_8 = 0; VAR_5[VAR_8] != '\\0'; VAR_8++) {",
"#if 0\nif (VAR_5[VAR_8] >= 'a' && VAR_5[VAR_8] <= 'f') {",
"ppc_boot_device = VAR_5[VAR_8];",
"break;",
"}",
"#else\nif (VAR_5[VAR_8] >= 'c' && VAR_5[VAR_8] <= 'd') {",
"ppc_boot_device = VAR_5[VAR_8];",
"break;",
"}",
"#endif\n}",
"if (ppc_boot_device == '\\0') {",
"fprintf(stderr, \"No valid boot device for G3 Beige VAR_0\\n\");",
"exit(1);",
"}",
"}",
"memory_region_init_alias(isa, NULL, \"isa_mmio\",\nget_system_io(), 0, 0x00200000);",
"memory_region_add_subregion(sysmem, 0xfe000000, isa);",
"heathrow_irqs = g_malloc0(smp_cpus * sizeof(qemu_irq *));",
"heathrow_irqs[0] =\ng_malloc0(smp_cpus * sizeof(qemu_irq) * 1);",
"for (VAR_8 = 0; VAR_8 < smp_cpus; VAR_8++) {",
"switch (PPC_INPUT(env)) {",
"case PPC_FLAGS_INPUT_6xx:\nheathrow_irqs[VAR_8] = heathrow_irqs[0] + (VAR_8 * 1);",
"heathrow_irqs[VAR_8][0] =\n((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT];",
"break;",
"default:\nhw_error(\"Bus model not supported on OldWorld Mac VAR_0\\n\");",
"}",
"}",
"if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {",
"hw_error(\"Only 6xx bus is supported on heathrow VAR_0\\n\");",
"}",
"pic = heathrow_pic_init(&pic_mem, 1, heathrow_irqs);",
"pci_bus = pci_grackle_init(0xfec00000, pic,\nget_system_memory(),\nget_system_io());",
"pci_vga_init(pci_bus);",
"escc_mem = escc_init(0, pic[0x0f], pic[0x10], serial_hds[0],\nserial_hds[1], ESCC_CLOCK, 4);",
"memory_region_init_alias(escc_bar, NULL, \"escc-bar\",\nescc_mem, 0, memory_region_size(escc_mem));",
"for(VAR_8 = 0; VAR_8 < nb_nics; VAR_8++)",
"pci_nic_init_nofail(&nd_table[VAR_8], pci_bus, \"ne2k_pci\", NULL);",
"ide_drive_get(hd, MAX_IDE_BUS);",
"macio = pci_create(pci_bus, -1, TYPE_OLDWORLD_MACIO);",
"dev = DEVICE(macio);",
"qdev_connect_gpio_out(dev, 0, pic[0x12]);",
"qdev_connect_gpio_out(dev, 1, pic[0x0D]);",
"qdev_connect_gpio_out(dev, 2, pic[0x02]);",
"qdev_connect_gpio_out(dev, 3, pic[0x0E]);",
"qdev_connect_gpio_out(dev, 4, pic[0x03]);",
"macio_init(macio, pic_mem, escc_bar);",
"macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),\n\"ide[0]\"));",
"macio_ide_init_drives(macio_ide, hd);",
"macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio),\n\"ide[1]\"));",
"macio_ide_init_drives(macio_ide, &hd[MAX_IDE_DEVS]);",
"dev = DEVICE(object_resolve_path_component(OBJECT(macio), \"cuda\"));",
"adb_bus = qdev_get_child_bus(dev, \"adb.0\");",
"dev = qdev_create(adb_bus, TYPE_ADB_KEYBOARD);",
"qdev_init_nofail(dev);",
"dev = qdev_create(adb_bus, TYPE_ADB_MOUSE);",
"qdev_init_nofail(dev);",
"if (usb_enabled(false)) {",
"pci_create_simple(pci_bus, -1, \"pci-ohci\");",
"}",
"if (graphic_depth != 15 && graphic_depth != 32 && graphic_depth != 8)\ngraphic_depth = 15;",
"VAR_10 = fw_cfg_init(0, 0, CFG_ADDR, CFG_ADDR + 2);",
"fw_cfg_add_i16(VAR_10, FW_CFG_MAX_CPUS, (uint16_t)max_cpus);",
"fw_cfg_add_i32(VAR_10, FW_CFG_ID, 1);",
"fw_cfg_add_i64(VAR_10, FW_CFG_RAM_SIZE, (uint64_t)ram_size);",
"fw_cfg_add_i16(VAR_10, FW_CFG_MACHINE_ID, ARCH_HEATHROW);",
"fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_ADDR, kernel_base);",
"fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_SIZE, kernel_size);",
"if (VAR_3) {",
"fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_CMDLINE, cmdline_base);",
"pstrcpy_targphys(\"cmdline\", cmdline_base, TARGET_PAGE_SIZE, VAR_3);",
"} else {",
"fw_cfg_add_i32(VAR_10, FW_CFG_KERNEL_CMDLINE, 0);",
"}",
"fw_cfg_add_i32(VAR_10, FW_CFG_INITRD_ADDR, initrd_base);",
"fw_cfg_add_i32(VAR_10, FW_CFG_INITRD_SIZE, initrd_size);",
"fw_cfg_add_i16(VAR_10, FW_CFG_BOOT_DEVICE, ppc_boot_device);",
"fw_cfg_add_i16(VAR_10, FW_CFG_PPC_WIDTH, graphic_width);",
"fw_cfg_add_i16(VAR_10, FW_CFG_PPC_HEIGHT, graphic_height);",
"fw_cfg_add_i16(VAR_10, FW_CFG_PPC_DEPTH, graphic_depth);",
"fw_cfg_add_i32(VAR_10, FW_CFG_PPC_IS_KVM, kvm_enabled());",
"if (kvm_enabled()) {",
"#ifdef CONFIG_KVM\nuint8_t *hypercall;",
"fw_cfg_add_i32(VAR_10, FW_CFG_PPC_TBFREQ, kvmppc_get_tbfreq());",
"hypercall = g_malloc(16);",
"kvmppc_get_hypercall(env, hypercall, 16);",
"fw_cfg_add_bytes(VAR_10, FW_CFG_PPC_KVM_HC, hypercall, 16);",
"fw_cfg_add_i32(VAR_10, FW_CFG_PPC_KVM_PID, getpid());",
"#endif\n} else {",
"fw_cfg_add_i32(VAR_10, FW_CFG_PPC_TBFREQ, TBFREQ);",
"}",
"fw_cfg_add_i32(VAR_10, FW_CFG_PPC_CLOCKFREQ, CLOCKFREQ);",
"fw_cfg_add_i32(VAR_10, FW_CFG_PPC_BUSFREQ, BUSFREQ);",
"qemu_register_boot_set(fw_cfg_boot_set, VAR_10);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
69,
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
91
],
[
93
],
[
95
],
[
101
],
[
103,
105,
107
],
[
109
],
[
111
],
[
115,
117
],
[
119
],
[
125
],
[
127
],
[
131,
133
],
[
135
],
[
137
],
[
139
],
[
145
],
[
147,
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
169
],
[
171
],
[
173
],
[
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
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
275,
277
],
[
279
],
[
281
],
[
283
],
[
285,
287
],
[
289
],
[
291
],
[
293
],
[
295,
297
],
[
299
],
[
301
],
[
303
],
[
305
],
[
307
],
[
313,
315
],
[
317
],
[
323
],
[
325,
327
],
[
331
],
[
333
],
[
335,
337
],
[
339,
341
],
[
343
],
[
345,
347
],
[
349
],
[
351
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365,
367,
369
],
[
371
],
[
375,
377
],
[
379,
381
],
[
385
],
[
387
],
[
393
],
[
397
],
[
399
],
[
401
],
[
403
],
[
405
],
[
407
],
[
409
],
[
411
],
[
415,
417
],
[
419
],
[
423,
425
],
[
427
],
[
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
445
],
[
447
],
[
449
],
[
453,
455
],
[
463
],
[
465
],
[
467
],
[
469
],
[
471
],
[
473
],
[
475
],
[
477
],
[
479
],
[
481
],
[
483
],
[
485
],
[
487
],
[
489
],
[
491
],
[
493
],
[
497
],
[
499
],
[
501
],
[
505
],
[
507
],
[
509,
511
],
[
515
],
[
517
],
[
519
],
[
521
],
[
523
],
[
525,
527
],
[
529
],
[
531
],
[
535
],
[
537
],
[
541
],
[
543
]
] |
21,562 | static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
int ctb_addr_ts)
{
HEVCLocalContext *lc = &s->HEVClc;
int ctb_size = 1 << s->ps.sps->log2_ctb_size;
int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
if (s->ps.pps->entropy_coding_sync_enabled_flag) {
if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
lc->first_qp_group = 1;
lc->end_of_tiles_x = s->ps.sps->width;
} else if (s->ps.pps->tiles_enabled_flag) {
if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
lc->start_of_tiles_x = x_ctb;
lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
lc->first_qp_group = 1;
}
} else {
lc->end_of_tiles_x = s->ps.sps->width;
}
lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
lc->boundary_flags = 0;
if (s->ps.pps->tiles_enabled_flag) {
if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
lc->boundary_flags |= BOUNDARY_LEFT_TILE;
if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
lc->boundary_flags |= BOUNDARY_UPPER_TILE;
if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
} else {
if (!ctb_addr_in_slice > 0)
lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
if (ctb_addr_in_slice < s->ps.sps->ctb_width)
lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
}
lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
}
| false | FFmpeg | b8b13acd70a1c1b6c044f967d78cb82f1a53887b | static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
int ctb_addr_ts)
{
HEVCLocalContext *lc = &s->HEVClc;
int ctb_size = 1 << s->ps.sps->log2_ctb_size;
int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
if (s->ps.pps->entropy_coding_sync_enabled_flag) {
if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
lc->first_qp_group = 1;
lc->end_of_tiles_x = s->ps.sps->width;
} else if (s->ps.pps->tiles_enabled_flag) {
if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
lc->start_of_tiles_x = x_ctb;
lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
lc->first_qp_group = 1;
}
} else {
lc->end_of_tiles_x = s->ps.sps->width;
}
lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
lc->boundary_flags = 0;
if (s->ps.pps->tiles_enabled_flag) {
if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
lc->boundary_flags |= BOUNDARY_LEFT_TILE;
if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
lc->boundary_flags |= BOUNDARY_UPPER_TILE;
if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
} else {
if (!ctb_addr_in_slice > 0)
lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
if (ctb_addr_in_slice < s->ps.sps->ctb_width)
lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
}
lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(HEVCContext *VAR_0, int VAR_1, int VAR_2,
int VAR_3)
{
HEVCLocalContext *lc = &VAR_0->HEVClc;
int VAR_4 = 1 << VAR_0->ps.sps->log2_ctb_size;
int VAR_5 = VAR_0->ps.pps->ctb_addr_ts_to_rs[VAR_3];
int VAR_6 = VAR_5 - VAR_0->sh.slice_addr;
VAR_0->tab_slice_address[VAR_5] = VAR_0->sh.slice_addr;
if (VAR_0->ps.pps->entropy_coding_sync_enabled_flag) {
if (VAR_1 == 0 && (VAR_2 & (VAR_4 - 1)) == 0)
lc->first_qp_group = 1;
lc->end_of_tiles_x = VAR_0->ps.sps->width;
} else if (VAR_0->ps.pps->tiles_enabled_flag) {
if (VAR_3 && VAR_0->ps.pps->tile_id[VAR_3] != VAR_0->ps.pps->tile_id[VAR_3 - 1]) {
int VAR_7 = VAR_0->ps.pps->col_idxX[VAR_1 >> VAR_0->ps.sps->log2_ctb_size];
lc->start_of_tiles_x = VAR_1;
lc->end_of_tiles_x = VAR_1 + (VAR_0->ps.pps->column_width[VAR_7] << VAR_0->ps.sps->log2_ctb_size);
lc->first_qp_group = 1;
}
} else {
lc->end_of_tiles_x = VAR_0->ps.sps->width;
}
lc->end_of_tiles_y = FFMIN(VAR_2 + VAR_4, VAR_0->ps.sps->height);
lc->boundary_flags = 0;
if (VAR_0->ps.pps->tiles_enabled_flag) {
if (VAR_1 > 0 && VAR_0->ps.pps->tile_id[VAR_3] != VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5 - 1]])
lc->boundary_flags |= BOUNDARY_LEFT_TILE;
if (VAR_1 > 0 && VAR_0->tab_slice_address[VAR_5] != VAR_0->tab_slice_address[VAR_5 - 1])
lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
if (VAR_2 > 0 && VAR_0->ps.pps->tile_id[VAR_3] != VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5 - VAR_0->ps.sps->ctb_width]])
lc->boundary_flags |= BOUNDARY_UPPER_TILE;
if (VAR_2 > 0 && VAR_0->tab_slice_address[VAR_5] != VAR_0->tab_slice_address[VAR_5 - VAR_0->ps.sps->ctb_width])
lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
} else {
if (!VAR_6 > 0)
lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
if (VAR_6 < VAR_0->ps.sps->ctb_width)
lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
}
lc->ctb_left_flag = ((VAR_1 > 0) && (VAR_6 > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
lc->ctb_up_flag = ((VAR_2 > 0) && (VAR_6 >= VAR_0->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
lc->ctb_up_right_flag = ((VAR_2 > 0) && (VAR_6+1 >= VAR_0->ps.sps->ctb_width) && (VAR_0->ps.pps->tile_id[VAR_3] == VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5+1 - VAR_0->ps.sps->ctb_width]]));
lc->ctb_up_left_flag = ((VAR_1 > 0) && (VAR_2 > 0) && (VAR_6-1 >= VAR_0->ps.sps->ctb_width) && (VAR_0->ps.pps->tile_id[VAR_3] == VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5-1 - VAR_0->ps.sps->ctb_width]]));
}
| [
"static void FUNC_0(HEVCContext *VAR_0, int VAR_1, int VAR_2,\nint VAR_3)\n{",
"HEVCLocalContext *lc = &VAR_0->HEVClc;",
"int VAR_4 = 1 << VAR_0->ps.sps->log2_ctb_size;",
"int VAR_5 = VAR_0->ps.pps->ctb_addr_ts_to_rs[VAR_3];",
"int VAR_6 = VAR_5 - VAR_0->sh.slice_addr;",
"VAR_0->tab_slice_address[VAR_5] = VAR_0->sh.slice_addr;",
"if (VAR_0->ps.pps->entropy_coding_sync_enabled_flag) {",
"if (VAR_1 == 0 && (VAR_2 & (VAR_4 - 1)) == 0)\nlc->first_qp_group = 1;",
"lc->end_of_tiles_x = VAR_0->ps.sps->width;",
"} else if (VAR_0->ps.pps->tiles_enabled_flag) {",
"if (VAR_3 && VAR_0->ps.pps->tile_id[VAR_3] != VAR_0->ps.pps->tile_id[VAR_3 - 1]) {",
"int VAR_7 = VAR_0->ps.pps->col_idxX[VAR_1 >> VAR_0->ps.sps->log2_ctb_size];",
"lc->start_of_tiles_x = VAR_1;",
"lc->end_of_tiles_x = VAR_1 + (VAR_0->ps.pps->column_width[VAR_7] << VAR_0->ps.sps->log2_ctb_size);",
"lc->first_qp_group = 1;",
"}",
"} else {",
"lc->end_of_tiles_x = VAR_0->ps.sps->width;",
"}",
"lc->end_of_tiles_y = FFMIN(VAR_2 + VAR_4, VAR_0->ps.sps->height);",
"lc->boundary_flags = 0;",
"if (VAR_0->ps.pps->tiles_enabled_flag) {",
"if (VAR_1 > 0 && VAR_0->ps.pps->tile_id[VAR_3] != VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5 - 1]])\nlc->boundary_flags |= BOUNDARY_LEFT_TILE;",
"if (VAR_1 > 0 && VAR_0->tab_slice_address[VAR_5] != VAR_0->tab_slice_address[VAR_5 - 1])\nlc->boundary_flags |= BOUNDARY_LEFT_SLICE;",
"if (VAR_2 > 0 && VAR_0->ps.pps->tile_id[VAR_3] != VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5 - VAR_0->ps.sps->ctb_width]])\nlc->boundary_flags |= BOUNDARY_UPPER_TILE;",
"if (VAR_2 > 0 && VAR_0->tab_slice_address[VAR_5] != VAR_0->tab_slice_address[VAR_5 - VAR_0->ps.sps->ctb_width])\nlc->boundary_flags |= BOUNDARY_UPPER_SLICE;",
"} else {",
"if (!VAR_6 > 0)\nlc->boundary_flags |= BOUNDARY_LEFT_SLICE;",
"if (VAR_6 < VAR_0->ps.sps->ctb_width)\nlc->boundary_flags |= BOUNDARY_UPPER_SLICE;",
"}",
"lc->ctb_left_flag = ((VAR_1 > 0) && (VAR_6 > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));",
"lc->ctb_up_flag = ((VAR_2 > 0) && (VAR_6 >= VAR_0->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));",
"lc->ctb_up_right_flag = ((VAR_2 > 0) && (VAR_6+1 >= VAR_0->ps.sps->ctb_width) && (VAR_0->ps.pps->tile_id[VAR_3] == VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5+1 - VAR_0->ps.sps->ctb_width]]));",
"lc->ctb_up_left_flag = ((VAR_1 > 0) && (VAR_2 > 0) && (VAR_6-1 >= VAR_0->ps.sps->ctb_width) && (VAR_0->ps.pps->tile_id[VAR_3] == VAR_0->ps.pps->tile_id[VAR_0->ps.pps->ctb_addr_rs_to_ts[VAR_5-1 - VAR_0->ps.sps->ctb_width]]));",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
55
],
[
57
],
[
59,
61
],
[
63,
65
],
[
67,
69
],
[
71,
73
],
[
75
],
[
77,
79
],
[
81,
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
]
] |
21,563 | static void scsi_qdev_unrealize(DeviceState *qdev, Error **errp)
{
SCSIDevice *dev = SCSI_DEVICE(qdev);
if (dev->vmsentry) {
qemu_del_vm_change_state_handler(dev->vmsentry);
}
scsi_device_unrealize(dev, errp);
}
| false | qemu | fb7b5c0df6e3c501973ce4d57eb2b1d4344a519d | static void scsi_qdev_unrealize(DeviceState *qdev, Error **errp)
{
SCSIDevice *dev = SCSI_DEVICE(qdev);
if (dev->vmsentry) {
qemu_del_vm_change_state_handler(dev->vmsentry);
}
scsi_device_unrealize(dev, errp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
SCSIDevice *dev = SCSI_DEVICE(VAR_0);
if (dev->vmsentry) {
qemu_del_vm_change_state_handler(dev->vmsentry);
}
scsi_device_unrealize(dev, VAR_1);
}
| [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"SCSIDevice *dev = SCSI_DEVICE(VAR_0);",
"if (dev->vmsentry) {",
"qemu_del_vm_change_state_handler(dev->vmsentry);",
"}",
"scsi_device_unrealize(dev, VAR_1);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
21,565 | static void xen_set_memory(struct MemoryListener *listener,
MemoryRegionSection *section,
bool add)
{
XenIOState *state = container_of(listener, XenIOState, memory_listener);
hwaddr start_addr = section->offset_within_address_space;
ram_addr_t size = int128_get64(section->size);
bool log_dirty = memory_region_is_logging(section->mr);
hvmmem_type_t mem_type;
if (!memory_region_is_ram(section->mr)) {
return;
}
if (!(section->mr != &ram_memory
&& ( (log_dirty && add) || (!log_dirty && !add)))) {
return;
}
trace_xen_client_set_memory(start_addr, size, log_dirty);
start_addr &= TARGET_PAGE_MASK;
size = TARGET_PAGE_ALIGN(size);
if (add) {
if (!memory_region_is_rom(section->mr)) {
xen_add_to_physmap(state, start_addr, size,
section->mr, section->offset_within_region);
} else {
mem_type = HVMMEM_ram_ro;
if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,
start_addr >> TARGET_PAGE_BITS,
size >> TARGET_PAGE_BITS)) {
DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n",
start_addr);
}
}
} else {
if (xen_remove_from_physmap(state, start_addr, size) < 0) {
DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr);
}
}
}
| true | qemu | 3996e85c1822e05c50250f8d2d1e57b6bea1229d | static void xen_set_memory(struct MemoryListener *listener,
MemoryRegionSection *section,
bool add)
{
XenIOState *state = container_of(listener, XenIOState, memory_listener);
hwaddr start_addr = section->offset_within_address_space;
ram_addr_t size = int128_get64(section->size);
bool log_dirty = memory_region_is_logging(section->mr);
hvmmem_type_t mem_type;
if (!memory_region_is_ram(section->mr)) {
return;
}
if (!(section->mr != &ram_memory
&& ( (log_dirty && add) || (!log_dirty && !add)))) {
return;
}
trace_xen_client_set_memory(start_addr, size, log_dirty);
start_addr &= TARGET_PAGE_MASK;
size = TARGET_PAGE_ALIGN(size);
if (add) {
if (!memory_region_is_rom(section->mr)) {
xen_add_to_physmap(state, start_addr, size,
section->mr, section->offset_within_region);
} else {
mem_type = HVMMEM_ram_ro;
if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,
start_addr >> TARGET_PAGE_BITS,
size >> TARGET_PAGE_BITS)) {
DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n",
start_addr);
}
}
} else {
if (xen_remove_from_physmap(state, start_addr, size) < 0) {
DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr);
}
}
}
| {
"code": [
" if (!(section->mr != &ram_memory",
" && ( (log_dirty && add) || (!log_dirty && !add)))) {"
],
"line_no": [
29,
31
]
} | static void FUNC_0(struct MemoryListener *VAR_0,
MemoryRegionSection *VAR_1,
bool VAR_2)
{
XenIOState *state = container_of(VAR_0, XenIOState, memory_listener);
hwaddr start_addr = VAR_1->offset_within_address_space;
ram_addr_t size = int128_get64(VAR_1->size);
bool log_dirty = memory_region_is_logging(VAR_1->mr);
hvmmem_type_t mem_type;
if (!memory_region_is_ram(VAR_1->mr)) {
return;
}
if (!(VAR_1->mr != &ram_memory
&& ( (log_dirty && VAR_2) || (!log_dirty && !VAR_2)))) {
return;
}
trace_xen_client_set_memory(start_addr, size, log_dirty);
start_addr &= TARGET_PAGE_MASK;
size = TARGET_PAGE_ALIGN(size);
if (VAR_2) {
if (!memory_region_is_rom(VAR_1->mr)) {
xen_add_to_physmap(state, start_addr, size,
VAR_1->mr, VAR_1->offset_within_region);
} else {
mem_type = HVMMEM_ram_ro;
if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,
start_addr >> TARGET_PAGE_BITS,
size >> TARGET_PAGE_BITS)) {
DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n",
start_addr);
}
}
} else {
if (xen_remove_from_physmap(state, start_addr, size) < 0) {
DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr);
}
}
}
| [
"static void FUNC_0(struct MemoryListener *VAR_0,\nMemoryRegionSection *VAR_1,\nbool VAR_2)\n{",
"XenIOState *state = container_of(VAR_0, XenIOState, memory_listener);",
"hwaddr start_addr = VAR_1->offset_within_address_space;",
"ram_addr_t size = int128_get64(VAR_1->size);",
"bool log_dirty = memory_region_is_logging(VAR_1->mr);",
"hvmmem_type_t mem_type;",
"if (!memory_region_is_ram(VAR_1->mr)) {",
"return;",
"}",
"if (!(VAR_1->mr != &ram_memory\n&& ( (log_dirty && VAR_2) || (!log_dirty && !VAR_2)))) {",
"return;",
"}",
"trace_xen_client_set_memory(start_addr, size, log_dirty);",
"start_addr &= TARGET_PAGE_MASK;",
"size = TARGET_PAGE_ALIGN(size);",
"if (VAR_2) {",
"if (!memory_region_is_rom(VAR_1->mr)) {",
"xen_add_to_physmap(state, start_addr, size,\nVAR_1->mr, VAR_1->offset_within_region);",
"} else {",
"mem_type = HVMMEM_ram_ro;",
"if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,\nstart_addr >> TARGET_PAGE_BITS,\nsize >> TARGET_PAGE_BITS)) {",
"DPRINTF(\"xc_hvm_set_mem_type error, addr: \"TARGET_FMT_plx\"\\n\",\nstart_addr);",
"}",
"}",
"} else {",
"if (xen_remove_from_physmap(state, start_addr, size) < 0) {",
"DPRINTF(\"physmapping does not exist at \"TARGET_FMT_plx\"\\n\", start_addr);",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29,
31
],
[
33
],
[
35
],
[
39
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61,
63,
65
],
[
67,
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
]
] |
21,566 | opts_check_list(Visitor *v, Error **errp)
{
/*
* FIXME should set error when unvisited elements remain. Mostly
* harmless, as the generated visits always visit all elements.
*/
}
| true | qemu | 21f88d021d0d2b4ecee8f6cd6ca63a943a3ce71d | opts_check_list(Visitor *v, Error **errp)
{
}
| {
"code": [],
"line_no": []
} | FUNC_0(Visitor *VAR_0, Error **VAR_1)
{
}
| [
"FUNC_0(Visitor *VAR_0, Error **VAR_1)\n{",
"}"
] | [
0,
0
] | [
[
1,
3
],
[
13
]
] |
21,568 | static int vorbis_packet(AVFormatContext *s, int idx)
{
struct ogg *ogg = s->priv_data;
struct ogg_stream *os = ogg->streams + idx;
struct oggvorbis_private *priv = os->private;
int duration;
/* first packet handling
here we parse the duration of each packet in the first page and compare
the total duration to the page granule to find the encoder delay and
set the first timestamp */
if (!os->lastpts) {
int seg;
uint8_t *last_pkt = os->buf + os->pstart;
uint8_t *next_pkt = last_pkt;
int first_duration = 0;
avpriv_vorbis_parse_reset(&priv->vp);
duration = 0;
for (seg = 0; seg < os->nsegs; seg++) {
if (os->segments[seg] < 255) {
int d = avpriv_vorbis_parse_frame(&priv->vp, last_pkt, 1);
if (d < 0) {
duration = os->granule;
break;
}
if (!duration)
first_duration = d;
duration += d;
last_pkt = next_pkt + os->segments[seg];
}
next_pkt += os->segments[seg];
}
os->lastpts = os->lastdts = os->granule - duration;
s->streams[idx]->start_time = os->lastpts + first_duration;
if (s->streams[idx]->duration)
s->streams[idx]->duration -= s->streams[idx]->start_time;
s->streams[idx]->cur_dts = AV_NOPTS_VALUE;
priv->final_pts = AV_NOPTS_VALUE;
avpriv_vorbis_parse_reset(&priv->vp);
}
/* parse packet duration */
if (os->psize > 0) {
duration = avpriv_vorbis_parse_frame(&priv->vp, os->buf + os->pstart, 1);
if (duration <= 0) {
os->pflags |= AV_PKT_FLAG_CORRUPT;
return 0;
}
os->pduration = duration;
}
/* final packet handling
here we save the pts of the first packet in the final page, sum up all
packet durations in the final page except for the last one, and compare
to the page granule to find the duration of the final packet */
if (os->flags & OGG_FLAG_EOS) {
if (os->lastpts != AV_NOPTS_VALUE) {
priv->final_pts = os->lastpts;
priv->final_duration = 0;
}
if (os->segp == os->nsegs)
os->pduration = os->granule - priv->final_pts - priv->final_duration;
priv->final_duration += os->pduration;
}
return 0;
}
| true | FFmpeg | ca4a3f4a08de04344e5cb16b506564969a43ed7e | static int vorbis_packet(AVFormatContext *s, int idx)
{
struct ogg *ogg = s->priv_data;
struct ogg_stream *os = ogg->streams + idx;
struct oggvorbis_private *priv = os->private;
int duration;
if (!os->lastpts) {
int seg;
uint8_t *last_pkt = os->buf + os->pstart;
uint8_t *next_pkt = last_pkt;
int first_duration = 0;
avpriv_vorbis_parse_reset(&priv->vp);
duration = 0;
for (seg = 0; seg < os->nsegs; seg++) {
if (os->segments[seg] < 255) {
int d = avpriv_vorbis_parse_frame(&priv->vp, last_pkt, 1);
if (d < 0) {
duration = os->granule;
break;
}
if (!duration)
first_duration = d;
duration += d;
last_pkt = next_pkt + os->segments[seg];
}
next_pkt += os->segments[seg];
}
os->lastpts = os->lastdts = os->granule - duration;
s->streams[idx]->start_time = os->lastpts + first_duration;
if (s->streams[idx]->duration)
s->streams[idx]->duration -= s->streams[idx]->start_time;
s->streams[idx]->cur_dts = AV_NOPTS_VALUE;
priv->final_pts = AV_NOPTS_VALUE;
avpriv_vorbis_parse_reset(&priv->vp);
}
if (os->psize > 0) {
duration = avpriv_vorbis_parse_frame(&priv->vp, os->buf + os->pstart, 1);
if (duration <= 0) {
os->pflags |= AV_PKT_FLAG_CORRUPT;
return 0;
}
os->pduration = duration;
}
if (os->flags & OGG_FLAG_EOS) {
if (os->lastpts != AV_NOPTS_VALUE) {
priv->final_pts = os->lastpts;
priv->final_duration = 0;
}
if (os->segp == os->nsegs)
os->pduration = os->granule - priv->final_pts - priv->final_duration;
priv->final_duration += os->pduration;
}
return 0;
}
| {
"code": [
" s->streams[idx]->cur_dts = AV_NOPTS_VALUE;"
],
"line_no": [
75
]
} | static int FUNC_0(AVFormatContext *VAR_0, int VAR_1)
{
struct VAR_2 *VAR_2 = VAR_0->priv_data;
struct ogg_stream *VAR_3 = VAR_2->streams + VAR_1;
struct oggvorbis_private *VAR_4 = VAR_3->private;
int VAR_5;
if (!VAR_3->lastpts) {
int VAR_6;
uint8_t *last_pkt = VAR_3->buf + VAR_3->pstart;
uint8_t *next_pkt = last_pkt;
int VAR_7 = 0;
avpriv_vorbis_parse_reset(&VAR_4->vp);
VAR_5 = 0;
for (VAR_6 = 0; VAR_6 < VAR_3->nsegs; VAR_6++) {
if (VAR_3->segments[VAR_6] < 255) {
int VAR_8 = avpriv_vorbis_parse_frame(&VAR_4->vp, last_pkt, 1);
if (VAR_8 < 0) {
VAR_5 = VAR_3->granule;
break;
}
if (!VAR_5)
VAR_7 = VAR_8;
VAR_5 += VAR_8;
last_pkt = next_pkt + VAR_3->segments[VAR_6];
}
next_pkt += VAR_3->segments[VAR_6];
}
VAR_3->lastpts = VAR_3->lastdts = VAR_3->granule - VAR_5;
VAR_0->streams[VAR_1]->start_time = VAR_3->lastpts + VAR_7;
if (VAR_0->streams[VAR_1]->VAR_5)
VAR_0->streams[VAR_1]->VAR_5 -= VAR_0->streams[VAR_1]->start_time;
VAR_0->streams[VAR_1]->cur_dts = AV_NOPTS_VALUE;
VAR_4->final_pts = AV_NOPTS_VALUE;
avpriv_vorbis_parse_reset(&VAR_4->vp);
}
if (VAR_3->psize > 0) {
VAR_5 = avpriv_vorbis_parse_frame(&VAR_4->vp, VAR_3->buf + VAR_3->pstart, 1);
if (VAR_5 <= 0) {
VAR_3->pflags |= AV_PKT_FLAG_CORRUPT;
return 0;
}
VAR_3->pduration = VAR_5;
}
if (VAR_3->flags & OGG_FLAG_EOS) {
if (VAR_3->lastpts != AV_NOPTS_VALUE) {
VAR_4->final_pts = VAR_3->lastpts;
VAR_4->final_duration = 0;
}
if (VAR_3->segp == VAR_3->nsegs)
VAR_3->pduration = VAR_3->granule - VAR_4->final_pts - VAR_4->final_duration;
VAR_4->final_duration += VAR_3->pduration;
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{",
"struct VAR_2 *VAR_2 = VAR_0->priv_data;",
"struct ogg_stream *VAR_3 = VAR_2->streams + VAR_1;",
"struct oggvorbis_private *VAR_4 = VAR_3->private;",
"int VAR_5;",
"if (!VAR_3->lastpts) {",
"int VAR_6;",
"uint8_t *last_pkt = VAR_3->buf + VAR_3->pstart;",
"uint8_t *next_pkt = last_pkt;",
"int VAR_7 = 0;",
"avpriv_vorbis_parse_reset(&VAR_4->vp);",
"VAR_5 = 0;",
"for (VAR_6 = 0; VAR_6 < VAR_3->nsegs; VAR_6++) {",
"if (VAR_3->segments[VAR_6] < 255) {",
"int VAR_8 = avpriv_vorbis_parse_frame(&VAR_4->vp, last_pkt, 1);",
"if (VAR_8 < 0) {",
"VAR_5 = VAR_3->granule;",
"break;",
"}",
"if (!VAR_5)\nVAR_7 = VAR_8;",
"VAR_5 += VAR_8;",
"last_pkt = next_pkt + VAR_3->segments[VAR_6];",
"}",
"next_pkt += VAR_3->segments[VAR_6];",
"}",
"VAR_3->lastpts = VAR_3->lastdts = VAR_3->granule - VAR_5;",
"VAR_0->streams[VAR_1]->start_time = VAR_3->lastpts + VAR_7;",
"if (VAR_0->streams[VAR_1]->VAR_5)\nVAR_0->streams[VAR_1]->VAR_5 -= VAR_0->streams[VAR_1]->start_time;",
"VAR_0->streams[VAR_1]->cur_dts = AV_NOPTS_VALUE;",
"VAR_4->final_pts = AV_NOPTS_VALUE;",
"avpriv_vorbis_parse_reset(&VAR_4->vp);",
"}",
"if (VAR_3->psize > 0) {",
"VAR_5 = avpriv_vorbis_parse_frame(&VAR_4->vp, VAR_3->buf + VAR_3->pstart, 1);",
"if (VAR_5 <= 0) {",
"VAR_3->pflags |= AV_PKT_FLAG_CORRUPT;",
"return 0;",
"}",
"VAR_3->pduration = VAR_5;",
"}",
"if (VAR_3->flags & OGG_FLAG_EOS) {",
"if (VAR_3->lastpts != AV_NOPTS_VALUE) {",
"VAR_4->final_pts = VAR_3->lastpts;",
"VAR_4->final_duration = 0;",
"}",
"if (VAR_3->segp == VAR_3->nsegs)\nVAR_3->pduration = VAR_3->granule - VAR_4->final_pts - VAR_4->final_duration;",
"VAR_4->final_duration += VAR_3->pduration;",
"}",
"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,
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
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123,
125
],
[
127
],
[
129
],
[
133
],
[
135
]
] |
21,570 | static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf)
{
SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
int32_t len;
uint8_t command;
command = buf[0];
if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) {
scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
}
switch (command) {
case READ_6:
case READ_10:
case READ_12:
case READ_16:
len = r->req.cmd.xfer / s->qdev.blocksize;
DPRINTF("Read (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len);
if (r->req.cmd.buf[1] & 0xe0) {
goto illegal_request;
}
if (r->req.cmd.lba > s->qdev.max_lba) {
goto illegal_lba;
}
r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
r->sector_count = len * (s->qdev.blocksize / 512);
break;
case VERIFY_10:
case VERIFY_12:
case VERIFY_16:
case WRITE_6:
case WRITE_10:
case WRITE_12:
case WRITE_16:
case WRITE_VERIFY_10:
case WRITE_VERIFY_12:
case WRITE_VERIFY_16:
len = r->req.cmd.xfer / s->qdev.blocksize;
DPRINTF("Write %s(sector %" PRId64 ", count %d)\n",
(command & 0xe) == 0xe ? "And Verify " : "",
r->req.cmd.lba, len);
if (r->req.cmd.buf[1] & 0xe0) {
goto illegal_request;
}
if (r->req.cmd.lba > s->qdev.max_lba) {
goto illegal_lba;
}
r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
r->sector_count = len * (s->qdev.blocksize / 512);
break;
default:
abort();
illegal_lba:
scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
}
if (r->sector_count == 0) {
scsi_req_complete(&r->req, GOOD);
}
assert(r->iov.iov_len == 0);
if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
return -r->sector_count * 512;
} else {
return r->sector_count * 512;
}
} | true | qemu | 96bdbbab55976b106f9db2b61042ebf5f0493e5a | static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf)
{
SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
int32_t len;
uint8_t command;
command = buf[0];
if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) {
scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
}
switch (command) {
case READ_6:
case READ_10:
case READ_12:
case READ_16:
len = r->req.cmd.xfer / s->qdev.blocksize;
DPRINTF("Read (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len);
if (r->req.cmd.buf[1] & 0xe0) {
goto illegal_request;
}
if (r->req.cmd.lba > s->qdev.max_lba) {
goto illegal_lba;
}
r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
r->sector_count = len * (s->qdev.blocksize / 512);
break;
case VERIFY_10:
case VERIFY_12:
case VERIFY_16:
case WRITE_6:
case WRITE_10:
case WRITE_12:
case WRITE_16:
case WRITE_VERIFY_10:
case WRITE_VERIFY_12:
case WRITE_VERIFY_16:
len = r->req.cmd.xfer / s->qdev.blocksize;
DPRINTF("Write %s(sector %" PRId64 ", count %d)\n",
(command & 0xe) == 0xe ? "And Verify " : "",
r->req.cmd.lba, len);
if (r->req.cmd.buf[1] & 0xe0) {
goto illegal_request;
}
if (r->req.cmd.lba > s->qdev.max_lba) {
goto illegal_lba;
}
r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
r->sector_count = len * (s->qdev.blocksize / 512);
break;
default:
abort();
illegal_lba:
scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
}
if (r->sector_count == 0) {
scsi_req_complete(&r->req, GOOD);
}
assert(r->iov.iov_len == 0);
if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
return -r->sector_count * 512;
} else {
return r->sector_count * 512;
}
} | {
"code": [],
"line_no": []
} | static int32_t FUNC_0(SCSIRequest *req, uint8_t *buf)
{
SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
int32_t len;
uint8_t command;
command = buf[0];
if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) {
scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
}
switch (command) {
case READ_6:
case READ_10:
case READ_12:
case READ_16:
len = r->req.cmd.xfer / s->qdev.blocksize;
DPRINTF("Read (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len);
if (r->req.cmd.buf[1] & 0xe0) {
goto illegal_request;
}
if (r->req.cmd.lba > s->qdev.max_lba) {
goto illegal_lba;
}
r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
r->sector_count = len * (s->qdev.blocksize / 512);
break;
case VERIFY_10:
case VERIFY_12:
case VERIFY_16:
case WRITE_6:
case WRITE_10:
case WRITE_12:
case WRITE_16:
case WRITE_VERIFY_10:
case WRITE_VERIFY_12:
case WRITE_VERIFY_16:
len = r->req.cmd.xfer / s->qdev.blocksize;
DPRINTF("Write %s(sector %" PRId64 ", count %d)\n",
(command & 0xe) == 0xe ? "And Verify " : "",
r->req.cmd.lba, len);
if (r->req.cmd.buf[1] & 0xe0) {
goto illegal_request;
}
if (r->req.cmd.lba > s->qdev.max_lba) {
goto illegal_lba;
}
r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
r->sector_count = len * (s->qdev.blocksize / 512);
break;
default:
abort();
illegal_lba:
scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
}
if (r->sector_count == 0) {
scsi_req_complete(&r->req, GOOD);
}
assert(r->iov.iov_len == 0);
if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
return -r->sector_count * 512;
} else {
return r->sector_count * 512;
}
} | [
"static int32_t FUNC_0(SCSIRequest *req, uint8_t *buf)\n{",
"SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);",
"SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);",
"int32_t len;",
"uint8_t command;",
"command = buf[0];",
"if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) {",
"scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));",
"}",
"switch (command) {",
"case READ_6:\ncase READ_10:\ncase READ_12:\ncase READ_16:\nlen = r->req.cmd.xfer / s->qdev.blocksize;",
"DPRINTF(\"Read (sector %\" PRId64 \", count %d)\\n\", r->req.cmd.lba, len);",
"if (r->req.cmd.buf[1] & 0xe0) {",
"goto illegal_request;",
"}",
"if (r->req.cmd.lba > s->qdev.max_lba) {",
"goto illegal_lba;",
"}",
"r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);",
"r->sector_count = len * (s->qdev.blocksize / 512);",
"break;",
"case VERIFY_10:\ncase VERIFY_12:\ncase VERIFY_16:\ncase WRITE_6:\ncase WRITE_10:\ncase WRITE_12:\ncase WRITE_16:\ncase WRITE_VERIFY_10:\ncase WRITE_VERIFY_12:\ncase WRITE_VERIFY_16:\nlen = r->req.cmd.xfer / s->qdev.blocksize;",
"DPRINTF(\"Write %s(sector %\" PRId64 \", count %d)\\n\",\n(command & 0xe) == 0xe ? \"And Verify \" : \"\",\nr->req.cmd.lba, len);",
"if (r->req.cmd.buf[1] & 0xe0) {",
"goto illegal_request;",
"}",
"if (r->req.cmd.lba > s->qdev.max_lba) {",
"goto illegal_lba;",
"}",
"r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);",
"r->sector_count = len * (s->qdev.blocksize / 512);",
"break;",
"default:\nabort();",
"illegal_lba:\nscsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));",
"}",
"if (r->sector_count == 0) {",
"scsi_req_complete(&r->req, GOOD);",
"}",
"assert(r->iov.iov_len == 0);",
"if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {",
"return -r->sector_count * 512;",
"} else {",
"return r->sector_count * 512;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
24
],
[
28
],
[
30,
32,
34,
36,
38
],
[
40
],
[
42
],
[
44
],
[
46
],
[
48
],
[
50
],
[
52
],
[
54
],
[
56
],
[
58
],
[
60,
62,
64,
66,
68,
70,
72,
74,
76,
78,
80
],
[
82,
84,
86
],
[
88
],
[
90
],
[
92
],
[
94
],
[
96
],
[
98
],
[
100
],
[
102
],
[
104
],
[
106,
108
],
[
113,
115
],
[
118
],
[
120
],
[
122
],
[
124
],
[
126
],
[
128
],
[
130
],
[
132
],
[
134
],
[
136
],
[
138
]
] |
21,571 | static void coroutine_fn mirror_run(void *opaque)
{
MirrorBlockJob *s = opaque;
MirrorExitData *data;
BlockDriverState *bs = s->common.bs;
int64_t sector_num, end, sectors_per_chunk, length;
uint64_t last_pause_ns;
BlockDriverInfo bdi;
char backing_filename[1024];
int ret = 0;
int n;
if (block_job_is_cancelled(&s->common)) {
goto immediate_exit;
}
s->bdev_length = bdrv_getlength(bs);
if (s->bdev_length < 0) {
ret = s->bdev_length;
goto immediate_exit;
} else if (s->bdev_length == 0) {
/* Report BLOCK_JOB_READY and wait for complete. */
block_job_event_ready(&s->common);
s->synced = true;
while (!block_job_is_cancelled(&s->common) && !s->should_complete) {
block_job_yield(&s->common);
}
s->common.cancelled = false;
goto immediate_exit;
}
length = DIV_ROUND_UP(s->bdev_length, s->granularity);
s->in_flight_bitmap = bitmap_new(length);
/* If we have no backing file yet in the destination, we cannot let
* the destination do COW. Instead, we copy sectors around the
* dirty data if needed. We need a bitmap to do that.
*/
bdrv_get_backing_filename(s->target, backing_filename,
sizeof(backing_filename));
if (backing_filename[0] && !s->target->backing_hd) {
ret = bdrv_get_info(s->target, &bdi);
if (ret < 0) {
goto immediate_exit;
}
if (s->granularity < bdi.cluster_size) {
s->buf_size = MAX(s->buf_size, bdi.cluster_size);
s->cow_bitmap = bitmap_new(length);
}
}
end = s->bdev_length / BDRV_SECTOR_SIZE;
s->buf = qemu_try_blockalign(bs, s->buf_size);
if (s->buf == NULL) {
ret = -ENOMEM;
goto immediate_exit;
}
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
mirror_free_init(s);
if (!s->is_none_mode) {
/* First part, loop on the sectors and initialize the dirty bitmap. */
BlockDriverState *base = s->base;
for (sector_num = 0; sector_num < end; ) {
int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1;
ret = bdrv_is_allocated_above(bs, base,
sector_num, next - sector_num, &n);
if (ret < 0) {
goto immediate_exit;
}
assert(n > 0);
if (ret == 1) {
bdrv_set_dirty(bs, sector_num, n);
sector_num = next;
} else {
sector_num += n;
}
}
}
bdrv_dirty_iter_init(bs, s->dirty_bitmap, &s->hbi);
last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
for (;;) {
uint64_t delay_ns = 0;
int64_t cnt;
bool should_complete;
if (s->ret < 0) {
ret = s->ret;
goto immediate_exit;
}
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
/* s->common.offset contains the number of bytes already processed so
* far, cnt is the number of dirty sectors remaining and
* s->sectors_in_flight is the number of sectors currently being
* processed; together those are the current total operation length */
s->common.len = s->common.offset +
(cnt + s->sectors_in_flight) * BDRV_SECTOR_SIZE;
/* Note that even when no rate limit is applied we need to yield
* periodically with no pending I/O so that qemu_aio_flush() returns.
* We do so every SLICE_TIME nanoseconds, or when there is an error,
* or when the source is clean, whichever comes first.
*/
if (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - last_pause_ns < SLICE_TIME &&
s->common.iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
if (s->in_flight == MAX_IN_FLIGHT || s->buf_free_count == 0 ||
(cnt == 0 && s->in_flight > 0)) {
trace_mirror_yield(s, s->in_flight, s->buf_free_count, cnt);
qemu_coroutine_yield();
continue;
} else if (cnt != 0) {
delay_ns = mirror_iteration(s);
if (delay_ns == 0) {
continue;
}
}
}
should_complete = false;
if (s->in_flight == 0 && cnt == 0) {
trace_mirror_before_flush(s);
ret = bdrv_flush(s->target);
if (ret < 0) {
if (mirror_error_action(s, false, -ret) ==
BLOCK_ERROR_ACTION_REPORT) {
goto immediate_exit;
}
} else {
/* We're out of the streaming phase. From now on, if the job
* is cancelled we will actually complete all pending I/O and
* report completion. This way, block-job-cancel will leave
* the target in a consistent state.
*/
if (!s->synced) {
block_job_event_ready(&s->common);
s->synced = true;
}
should_complete = s->should_complete ||
block_job_is_cancelled(&s->common);
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
}
}
if (cnt == 0 && should_complete) {
/* The dirty bitmap is not updated while operations are pending.
* If we're about to exit, wait for pending operations before
* calling bdrv_get_dirty_count(bs), or we may exit while the
* source has dirty data to copy!
*
* Note that I/O can be submitted by the guest while
* mirror_populate runs.
*/
trace_mirror_before_drain(s, cnt);
bdrv_drain(bs);
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
}
ret = 0;
trace_mirror_before_sleep(s, cnt, s->synced, delay_ns);
if (!s->synced) {
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
if (block_job_is_cancelled(&s->common)) {
break;
}
} else if (!should_complete) {
delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0);
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
} else if (cnt == 0) {
/* The two disks are in sync. Exit and report successful
* completion.
*/
assert(QLIST_EMPTY(&bs->tracked_requests));
s->common.cancelled = false;
break;
}
last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
}
immediate_exit:
if (s->in_flight > 0) {
/* We get here only if something went wrong. Either the job failed,
* or it was cancelled prematurely so that we do not guarantee that
* the target is a copy of the source.
*/
assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common)));
mirror_drain(s);
}
assert(s->in_flight == 0);
qemu_vfree(s->buf);
g_free(s->cow_bitmap);
g_free(s->in_flight_bitmap);
bdrv_release_dirty_bitmap(bs, s->dirty_bitmap);
bdrv_iostatus_disable(s->target);
data = g_malloc(sizeof(*data));
data->ret = ret;
block_job_defer_to_main_loop(&s->common, mirror_exit, data);
}
| true | qemu | c4237dfa635900e4d1cdc6038d5efe3507f45f0c | static void coroutine_fn mirror_run(void *opaque)
{
MirrorBlockJob *s = opaque;
MirrorExitData *data;
BlockDriverState *bs = s->common.bs;
int64_t sector_num, end, sectors_per_chunk, length;
uint64_t last_pause_ns;
BlockDriverInfo bdi;
char backing_filename[1024];
int ret = 0;
int n;
if (block_job_is_cancelled(&s->common)) {
goto immediate_exit;
}
s->bdev_length = bdrv_getlength(bs);
if (s->bdev_length < 0) {
ret = s->bdev_length;
goto immediate_exit;
} else if (s->bdev_length == 0) {
block_job_event_ready(&s->common);
s->synced = true;
while (!block_job_is_cancelled(&s->common) && !s->should_complete) {
block_job_yield(&s->common);
}
s->common.cancelled = false;
goto immediate_exit;
}
length = DIV_ROUND_UP(s->bdev_length, s->granularity);
s->in_flight_bitmap = bitmap_new(length);
bdrv_get_backing_filename(s->target, backing_filename,
sizeof(backing_filename));
if (backing_filename[0] && !s->target->backing_hd) {
ret = bdrv_get_info(s->target, &bdi);
if (ret < 0) {
goto immediate_exit;
}
if (s->granularity < bdi.cluster_size) {
s->buf_size = MAX(s->buf_size, bdi.cluster_size);
s->cow_bitmap = bitmap_new(length);
}
}
end = s->bdev_length / BDRV_SECTOR_SIZE;
s->buf = qemu_try_blockalign(bs, s->buf_size);
if (s->buf == NULL) {
ret = -ENOMEM;
goto immediate_exit;
}
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
mirror_free_init(s);
if (!s->is_none_mode) {
BlockDriverState *base = s->base;
for (sector_num = 0; sector_num < end; ) {
int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1;
ret = bdrv_is_allocated_above(bs, base,
sector_num, next - sector_num, &n);
if (ret < 0) {
goto immediate_exit;
}
assert(n > 0);
if (ret == 1) {
bdrv_set_dirty(bs, sector_num, n);
sector_num = next;
} else {
sector_num += n;
}
}
}
bdrv_dirty_iter_init(bs, s->dirty_bitmap, &s->hbi);
last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
for (;;) {
uint64_t delay_ns = 0;
int64_t cnt;
bool should_complete;
if (s->ret < 0) {
ret = s->ret;
goto immediate_exit;
}
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
s->common.len = s->common.offset +
(cnt + s->sectors_in_flight) * BDRV_SECTOR_SIZE;
if (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - last_pause_ns < SLICE_TIME &&
s->common.iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
if (s->in_flight == MAX_IN_FLIGHT || s->buf_free_count == 0 ||
(cnt == 0 && s->in_flight > 0)) {
trace_mirror_yield(s, s->in_flight, s->buf_free_count, cnt);
qemu_coroutine_yield();
continue;
} else if (cnt != 0) {
delay_ns = mirror_iteration(s);
if (delay_ns == 0) {
continue;
}
}
}
should_complete = false;
if (s->in_flight == 0 && cnt == 0) {
trace_mirror_before_flush(s);
ret = bdrv_flush(s->target);
if (ret < 0) {
if (mirror_error_action(s, false, -ret) ==
BLOCK_ERROR_ACTION_REPORT) {
goto immediate_exit;
}
} else {
if (!s->synced) {
block_job_event_ready(&s->common);
s->synced = true;
}
should_complete = s->should_complete ||
block_job_is_cancelled(&s->common);
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
}
}
if (cnt == 0 && should_complete) {
trace_mirror_before_drain(s, cnt);
bdrv_drain(bs);
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
}
ret = 0;
trace_mirror_before_sleep(s, cnt, s->synced, delay_ns);
if (!s->synced) {
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
if (block_job_is_cancelled(&s->common)) {
break;
}
} else if (!should_complete) {
delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0);
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
} else if (cnt == 0) {
assert(QLIST_EMPTY(&bs->tracked_requests));
s->common.cancelled = false;
break;
}
last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
}
immediate_exit:
if (s->in_flight > 0) {
assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common)));
mirror_drain(s);
}
assert(s->in_flight == 0);
qemu_vfree(s->buf);
g_free(s->cow_bitmap);
g_free(s->in_flight_bitmap);
bdrv_release_dirty_bitmap(bs, s->dirty_bitmap);
bdrv_iostatus_disable(s->target);
data = g_malloc(sizeof(*data));
data->ret = ret;
block_job_defer_to_main_loop(&s->common, mirror_exit, data);
}
| {
"code": [
" bdrv_set_dirty(bs, sector_num, n);"
],
"line_no": [
151
]
} | static void VAR_0 mirror_run(void *opaque)
{
MirrorBlockJob *s = opaque;
MirrorExitData *data;
BlockDriverState *bs = s->common.bs;
int64_t sector_num, end, sectors_per_chunk, length;
uint64_t last_pause_ns;
BlockDriverInfo bdi;
char backing_filename[1024];
int ret = 0;
int n;
if (block_job_is_cancelled(&s->common)) {
goto immediate_exit;
}
s->bdev_length = bdrv_getlength(bs);
if (s->bdev_length < 0) {
ret = s->bdev_length;
goto immediate_exit;
} else if (s->bdev_length == 0) {
block_job_event_ready(&s->common);
s->synced = true;
while (!block_job_is_cancelled(&s->common) && !s->should_complete) {
block_job_yield(&s->common);
}
s->common.cancelled = false;
goto immediate_exit;
}
length = DIV_ROUND_UP(s->bdev_length, s->granularity);
s->in_flight_bitmap = bitmap_new(length);
bdrv_get_backing_filename(s->target, backing_filename,
sizeof(backing_filename));
if (backing_filename[0] && !s->target->backing_hd) {
ret = bdrv_get_info(s->target, &bdi);
if (ret < 0) {
goto immediate_exit;
}
if (s->granularity < bdi.cluster_size) {
s->buf_size = MAX(s->buf_size, bdi.cluster_size);
s->cow_bitmap = bitmap_new(length);
}
}
end = s->bdev_length / BDRV_SECTOR_SIZE;
s->buf = qemu_try_blockalign(bs, s->buf_size);
if (s->buf == NULL) {
ret = -ENOMEM;
goto immediate_exit;
}
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
mirror_free_init(s);
if (!s->is_none_mode) {
BlockDriverState *base = s->base;
for (sector_num = 0; sector_num < end; ) {
int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1;
ret = bdrv_is_allocated_above(bs, base,
sector_num, next - sector_num, &n);
if (ret < 0) {
goto immediate_exit;
}
assert(n > 0);
if (ret == 1) {
bdrv_set_dirty(bs, sector_num, n);
sector_num = next;
} else {
sector_num += n;
}
}
}
bdrv_dirty_iter_init(bs, s->dirty_bitmap, &s->hbi);
last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
for (;;) {
uint64_t delay_ns = 0;
int64_t cnt;
bool should_complete;
if (s->ret < 0) {
ret = s->ret;
goto immediate_exit;
}
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
s->common.len = s->common.offset +
(cnt + s->sectors_in_flight) * BDRV_SECTOR_SIZE;
if (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - last_pause_ns < SLICE_TIME &&
s->common.iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
if (s->in_flight == MAX_IN_FLIGHT || s->buf_free_count == 0 ||
(cnt == 0 && s->in_flight > 0)) {
trace_mirror_yield(s, s->in_flight, s->buf_free_count, cnt);
qemu_coroutine_yield();
continue;
} else if (cnt != 0) {
delay_ns = mirror_iteration(s);
if (delay_ns == 0) {
continue;
}
}
}
should_complete = false;
if (s->in_flight == 0 && cnt == 0) {
trace_mirror_before_flush(s);
ret = bdrv_flush(s->target);
if (ret < 0) {
if (mirror_error_action(s, false, -ret) ==
BLOCK_ERROR_ACTION_REPORT) {
goto immediate_exit;
}
} else {
if (!s->synced) {
block_job_event_ready(&s->common);
s->synced = true;
}
should_complete = s->should_complete ||
block_job_is_cancelled(&s->common);
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
}
}
if (cnt == 0 && should_complete) {
trace_mirror_before_drain(s, cnt);
bdrv_drain(bs);
cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);
}
ret = 0;
trace_mirror_before_sleep(s, cnt, s->synced, delay_ns);
if (!s->synced) {
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
if (block_job_is_cancelled(&s->common)) {
break;
}
} else if (!should_complete) {
delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0);
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
} else if (cnt == 0) {
assert(QLIST_EMPTY(&bs->tracked_requests));
s->common.cancelled = false;
break;
}
last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
}
immediate_exit:
if (s->in_flight > 0) {
assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common)));
mirror_drain(s);
}
assert(s->in_flight == 0);
qemu_vfree(s->buf);
g_free(s->cow_bitmap);
g_free(s->in_flight_bitmap);
bdrv_release_dirty_bitmap(bs, s->dirty_bitmap);
bdrv_iostatus_disable(s->target);
data = g_malloc(sizeof(*data));
data->ret = ret;
block_job_defer_to_main_loop(&s->common, mirror_exit, data);
}
| [
"static void VAR_0 mirror_run(void *opaque)\n{",
"MirrorBlockJob *s = opaque;",
"MirrorExitData *data;",
"BlockDriverState *bs = s->common.bs;",
"int64_t sector_num, end, sectors_per_chunk, length;",
"uint64_t last_pause_ns;",
"BlockDriverInfo bdi;",
"char backing_filename[1024];",
"int ret = 0;",
"int n;",
"if (block_job_is_cancelled(&s->common)) {",
"goto immediate_exit;",
"}",
"s->bdev_length = bdrv_getlength(bs);",
"if (s->bdev_length < 0) {",
"ret = s->bdev_length;",
"goto immediate_exit;",
"} else if (s->bdev_length == 0) {",
"block_job_event_ready(&s->common);",
"s->synced = true;",
"while (!block_job_is_cancelled(&s->common) && !s->should_complete) {",
"block_job_yield(&s->common);",
"}",
"s->common.cancelled = false;",
"goto immediate_exit;",
"}",
"length = DIV_ROUND_UP(s->bdev_length, s->granularity);",
"s->in_flight_bitmap = bitmap_new(length);",
"bdrv_get_backing_filename(s->target, backing_filename,\nsizeof(backing_filename));",
"if (backing_filename[0] && !s->target->backing_hd) {",
"ret = bdrv_get_info(s->target, &bdi);",
"if (ret < 0) {",
"goto immediate_exit;",
"}",
"if (s->granularity < bdi.cluster_size) {",
"s->buf_size = MAX(s->buf_size, bdi.cluster_size);",
"s->cow_bitmap = bitmap_new(length);",
"}",
"}",
"end = s->bdev_length / BDRV_SECTOR_SIZE;",
"s->buf = qemu_try_blockalign(bs, s->buf_size);",
"if (s->buf == NULL) {",
"ret = -ENOMEM;",
"goto immediate_exit;",
"}",
"sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;",
"mirror_free_init(s);",
"if (!s->is_none_mode) {",
"BlockDriverState *base = s->base;",
"for (sector_num = 0; sector_num < end; ) {",
"int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1;",
"ret = bdrv_is_allocated_above(bs, base,\nsector_num, next - sector_num, &n);",
"if (ret < 0) {",
"goto immediate_exit;",
"}",
"assert(n > 0);",
"if (ret == 1) {",
"bdrv_set_dirty(bs, sector_num, n);",
"sector_num = next;",
"} else {",
"sector_num += n;",
"}",
"}",
"}",
"bdrv_dirty_iter_init(bs, s->dirty_bitmap, &s->hbi);",
"last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);",
"for (;;) {",
"uint64_t delay_ns = 0;",
"int64_t cnt;",
"bool should_complete;",
"if (s->ret < 0) {",
"ret = s->ret;",
"goto immediate_exit;",
"}",
"cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);",
"s->common.len = s->common.offset +\n(cnt + s->sectors_in_flight) * BDRV_SECTOR_SIZE;",
"if (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - last_pause_ns < SLICE_TIME &&\ns->common.iostatus == BLOCK_DEVICE_IO_STATUS_OK) {",
"if (s->in_flight == MAX_IN_FLIGHT || s->buf_free_count == 0 ||\n(cnt == 0 && s->in_flight > 0)) {",
"trace_mirror_yield(s, s->in_flight, s->buf_free_count, cnt);",
"qemu_coroutine_yield();",
"continue;",
"} else if (cnt != 0) {",
"delay_ns = mirror_iteration(s);",
"if (delay_ns == 0) {",
"continue;",
"}",
"}",
"}",
"should_complete = false;",
"if (s->in_flight == 0 && cnt == 0) {",
"trace_mirror_before_flush(s);",
"ret = bdrv_flush(s->target);",
"if (ret < 0) {",
"if (mirror_error_action(s, false, -ret) ==\nBLOCK_ERROR_ACTION_REPORT) {",
"goto immediate_exit;",
"}",
"} else {",
"if (!s->synced) {",
"block_job_event_ready(&s->common);",
"s->synced = true;",
"}",
"should_complete = s->should_complete ||\nblock_job_is_cancelled(&s->common);",
"cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);",
"}",
"}",
"if (cnt == 0 && should_complete) {",
"trace_mirror_before_drain(s, cnt);",
"bdrv_drain(bs);",
"cnt = bdrv_get_dirty_count(bs, s->dirty_bitmap);",
"}",
"ret = 0;",
"trace_mirror_before_sleep(s, cnt, s->synced, delay_ns);",
"if (!s->synced) {",
"block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);",
"if (block_job_is_cancelled(&s->common)) {",
"break;",
"}",
"} else if (!should_complete) {",
"delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0);",
"block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);",
"} else if (cnt == 0) {",
"assert(QLIST_EMPTY(&bs->tracked_requests));",
"s->common.cancelled = false;",
"break;",
"}",
"last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);",
"}",
"immediate_exit:\nif (s->in_flight > 0) {",
"assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common)));",
"mirror_drain(s);",
"}",
"assert(s->in_flight == 0);",
"qemu_vfree(s->buf);",
"g_free(s->cow_bitmap);",
"g_free(s->in_flight_bitmap);",
"bdrv_release_dirty_bitmap(bs, s->dirty_bitmap);",
"bdrv_iostatus_disable(s->target);",
"data = g_malloc(sizeof(*data));",
"data->ret = ret;",
"block_job_defer_to_main_loop(&s->common, mirror_exit, data);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
77,
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
117
],
[
119
],
[
123
],
[
127
],
[
129
],
[
131
],
[
133,
135
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
181
],
[
183
],
[
185
],
[
187
],
[
191
],
[
201,
203
],
[
217,
219
],
[
221,
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257,
259
],
[
261
],
[
263
],
[
265
],
[
277
],
[
279
],
[
281
],
[
283
],
[
287,
289
],
[
291
],
[
293
],
[
295
],
[
299
],
[
317
],
[
319
],
[
321
],
[
323
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
369,
371
],
[
381
],
[
383
],
[
385
],
[
389
],
[
391
],
[
393
],
[
395
],
[
397
],
[
399
],
[
403
],
[
405
],
[
407
],
[
409
]
] |
21,572 | int object_property_get_enum(Object *obj, const char *name,
const char *strings[], Error **errp)
{
StringOutputVisitor *sov;
StringInputVisitor *siv;
int ret;
sov = string_output_visitor_new(false);
object_property_get(obj, string_output_get_visitor(sov), name, errp);
siv = string_input_visitor_new(string_output_get_string(sov));
string_output_visitor_cleanup(sov);
visit_type_enum(string_input_get_visitor(siv),
&ret, strings, NULL, name, errp);
string_input_visitor_cleanup(siv);
return ret;
}
| true | qemu | 976620ac4018db142d82cd42bb7774f40290ce7e | int object_property_get_enum(Object *obj, const char *name,
const char *strings[], Error **errp)
{
StringOutputVisitor *sov;
StringInputVisitor *siv;
int ret;
sov = string_output_visitor_new(false);
object_property_get(obj, string_output_get_visitor(sov), name, errp);
siv = string_input_visitor_new(string_output_get_string(sov));
string_output_visitor_cleanup(sov);
visit_type_enum(string_input_get_visitor(siv),
&ret, strings, NULL, name, errp);
string_input_visitor_cleanup(siv);
return ret;
}
| {
"code": [
" siv = string_input_visitor_new(string_output_get_string(sov));"
],
"line_no": [
19
]
} | int FUNC_0(Object *VAR_0, const char *VAR_1,
const char *VAR_2[], Error **VAR_3)
{
StringOutputVisitor *sov;
StringInputVisitor *siv;
int VAR_4;
sov = string_output_visitor_new(false);
object_property_get(VAR_0, string_output_get_visitor(sov), VAR_1, VAR_3);
siv = string_input_visitor_new(string_output_get_string(sov));
string_output_visitor_cleanup(sov);
visit_type_enum(string_input_get_visitor(siv),
&VAR_4, VAR_2, NULL, VAR_1, VAR_3);
string_input_visitor_cleanup(siv);
return VAR_4;
}
| [
"int FUNC_0(Object *VAR_0, const char *VAR_1,\nconst char *VAR_2[], Error **VAR_3)\n{",
"StringOutputVisitor *sov;",
"StringInputVisitor *siv;",
"int VAR_4;",
"sov = string_output_visitor_new(false);",
"object_property_get(VAR_0, string_output_get_visitor(sov), VAR_1, VAR_3);",
"siv = string_input_visitor_new(string_output_get_string(sov));",
"string_output_visitor_cleanup(sov);",
"visit_type_enum(string_input_get_visitor(siv),\n&VAR_4, VAR_2, NULL, VAR_1, VAR_3);",
"string_input_visitor_cleanup(siv);",
"return VAR_4;",
"}"
] | [
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
31
],
[
33
]
] |
21,573 | int ff_vaapi_render_picture(FFVAContext *vactx, VASurfaceID surface)
{
VABufferID va_buffers[3];
unsigned int n_va_buffers = 0;
if (!vactx->pic_param_buf_id)
return 0;
vaUnmapBuffer(vactx->display, vactx->pic_param_buf_id);
va_buffers[n_va_buffers++] = vactx->pic_param_buf_id;
if (vactx->iq_matrix_buf_id) {
vaUnmapBuffer(vactx->display, vactx->iq_matrix_buf_id);
va_buffers[n_va_buffers++] = vactx->iq_matrix_buf_id;
}
if (vactx->bitplane_buf_id) {
vaUnmapBuffer(vactx->display, vactx->bitplane_buf_id);
va_buffers[n_va_buffers++] = vactx->bitplane_buf_id;
}
if (vaBeginPicture(vactx->display, vactx->context_id,
surface) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(vactx->display, vactx->context_id,
va_buffers, n_va_buffers) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(vactx->display, vactx->context_id,
vactx->slice_buf_ids,
vactx->n_slice_buf_ids) != VA_STATUS_SUCCESS)
return -1;
if (vaEndPicture(vactx->display, vactx->context_id) != VA_STATUS_SUCCESS)
return -1;
return 0;
}
| false | FFmpeg | 8813d55fa5978660d9f4e7dbe1f50da9922be08d | int ff_vaapi_render_picture(FFVAContext *vactx, VASurfaceID surface)
{
VABufferID va_buffers[3];
unsigned int n_va_buffers = 0;
if (!vactx->pic_param_buf_id)
return 0;
vaUnmapBuffer(vactx->display, vactx->pic_param_buf_id);
va_buffers[n_va_buffers++] = vactx->pic_param_buf_id;
if (vactx->iq_matrix_buf_id) {
vaUnmapBuffer(vactx->display, vactx->iq_matrix_buf_id);
va_buffers[n_va_buffers++] = vactx->iq_matrix_buf_id;
}
if (vactx->bitplane_buf_id) {
vaUnmapBuffer(vactx->display, vactx->bitplane_buf_id);
va_buffers[n_va_buffers++] = vactx->bitplane_buf_id;
}
if (vaBeginPicture(vactx->display, vactx->context_id,
surface) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(vactx->display, vactx->context_id,
va_buffers, n_va_buffers) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(vactx->display, vactx->context_id,
vactx->slice_buf_ids,
vactx->n_slice_buf_ids) != VA_STATUS_SUCCESS)
return -1;
if (vaEndPicture(vactx->display, vactx->context_id) != VA_STATUS_SUCCESS)
return -1;
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(FFVAContext *VAR_0, VASurfaceID VAR_1)
{
VABufferID va_buffers[3];
unsigned int VAR_2 = 0;
if (!VAR_0->pic_param_buf_id)
return 0;
vaUnmapBuffer(VAR_0->display, VAR_0->pic_param_buf_id);
va_buffers[VAR_2++] = VAR_0->pic_param_buf_id;
if (VAR_0->iq_matrix_buf_id) {
vaUnmapBuffer(VAR_0->display, VAR_0->iq_matrix_buf_id);
va_buffers[VAR_2++] = VAR_0->iq_matrix_buf_id;
}
if (VAR_0->bitplane_buf_id) {
vaUnmapBuffer(VAR_0->display, VAR_0->bitplane_buf_id);
va_buffers[VAR_2++] = VAR_0->bitplane_buf_id;
}
if (vaBeginPicture(VAR_0->display, VAR_0->context_id,
VAR_1) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(VAR_0->display, VAR_0->context_id,
va_buffers, VAR_2) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(VAR_0->display, VAR_0->context_id,
VAR_0->slice_buf_ids,
VAR_0->n_slice_buf_ids) != VA_STATUS_SUCCESS)
return -1;
if (vaEndPicture(VAR_0->display, VAR_0->context_id) != VA_STATUS_SUCCESS)
return -1;
return 0;
}
| [
"int FUNC_0(FFVAContext *VAR_0, VASurfaceID VAR_1)\n{",
"VABufferID va_buffers[3];",
"unsigned int VAR_2 = 0;",
"if (!VAR_0->pic_param_buf_id)\nreturn 0;",
"vaUnmapBuffer(VAR_0->display, VAR_0->pic_param_buf_id);",
"va_buffers[VAR_2++] = VAR_0->pic_param_buf_id;",
"if (VAR_0->iq_matrix_buf_id) {",
"vaUnmapBuffer(VAR_0->display, VAR_0->iq_matrix_buf_id);",
"va_buffers[VAR_2++] = VAR_0->iq_matrix_buf_id;",
"}",
"if (VAR_0->bitplane_buf_id) {",
"vaUnmapBuffer(VAR_0->display, VAR_0->bitplane_buf_id);",
"va_buffers[VAR_2++] = VAR_0->bitplane_buf_id;",
"}",
"if (vaBeginPicture(VAR_0->display, VAR_0->context_id,\nVAR_1) != VA_STATUS_SUCCESS)\nreturn -1;",
"if (vaRenderPicture(VAR_0->display, VAR_0->context_id,\nva_buffers, VAR_2) != VA_STATUS_SUCCESS)\nreturn -1;",
"if (vaRenderPicture(VAR_0->display, VAR_0->context_id,\nVAR_0->slice_buf_ids,\nVAR_0->n_slice_buf_ids) != VA_STATUS_SUCCESS)\nreturn -1;",
"if (vaEndPicture(VAR_0->display, VAR_0->context_id) != VA_STATUS_SUCCESS)\nreturn -1;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43,
45,
47
],
[
51,
53,
55
],
[
59,
61,
63,
65
],
[
69,
71
],
[
75
],
[
77
]
] |
21,574 | static void loop_filter(H264Context *h){
MpegEncContext * const s = &h->s;
uint8_t *dest_y, *dest_cb, *dest_cr;
int linesize, uvlinesize, mb_x, mb_y;
const int end_mb_y= s->mb_y + FRAME_MBAFF;
const int old_slice_type= h->slice_type;
if(h->deblocking_filter) {
for(mb_x= 0; mb_x<s->mb_width; mb_x++){
for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){
int list, mb_xy, mb_type;
mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;
h->slice_num= h->slice_table[mb_xy];
mb_type= s->current_picture.mb_type[mb_xy];
h->list_count= h->list_counts[mb_xy];
if(FRAME_MBAFF)
h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
s->mb_x= mb_x;
s->mb_y= mb_y;
dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
//FIXME simplify above
if (MB_FIELD) {
linesize = h->mb_linesize = s->linesize * 2;
uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
if(mb_y&1){ //FIXME move out of this function?
dest_y -= s->linesize*15;
dest_cb-= s->uvlinesize*7;
dest_cr-= s->uvlinesize*7;
}
} else {
linesize = h->mb_linesize = s->linesize;
uvlinesize = h->mb_uvlinesize = s->uvlinesize;
}
backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
if(fill_filter_caches(h, mb_type) < 0)
continue;
h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
if (FRAME_MBAFF) {
ff_h264_filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
} else {
ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
}
}
}
}
h->slice_type= old_slice_type;
s->mb_x= 0;
s->mb_y= end_mb_y - FRAME_MBAFF;
}
| false | FFmpeg | aaa995d7f29cba39b1fe05b6f0a807bfc7a09f43 | static void loop_filter(H264Context *h){
MpegEncContext * const s = &h->s;
uint8_t *dest_y, *dest_cb, *dest_cr;
int linesize, uvlinesize, mb_x, mb_y;
const int end_mb_y= s->mb_y + FRAME_MBAFF;
const int old_slice_type= h->slice_type;
if(h->deblocking_filter) {
for(mb_x= 0; mb_x<s->mb_width; mb_x++){
for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){
int list, mb_xy, mb_type;
mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;
h->slice_num= h->slice_table[mb_xy];
mb_type= s->current_picture.mb_type[mb_xy];
h->list_count= h->list_counts[mb_xy];
if(FRAME_MBAFF)
h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
s->mb_x= mb_x;
s->mb_y= mb_y;
dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16;
dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
if (MB_FIELD) {
linesize = h->mb_linesize = s->linesize * 2;
uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
if(mb_y&1){
dest_y -= s->linesize*15;
dest_cb-= s->uvlinesize*7;
dest_cr-= s->uvlinesize*7;
}
} else {
linesize = h->mb_linesize = s->linesize;
uvlinesize = h->mb_uvlinesize = s->uvlinesize;
}
backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
if(fill_filter_caches(h, mb_type) < 0)
continue;
h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
if (FRAME_MBAFF) {
ff_h264_filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
} else {
ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
}
}
}
}
h->slice_type= old_slice_type;
s->mb_x= 0;
s->mb_y= end_mb_y - FRAME_MBAFF;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(H264Context *VAR_0){
MpegEncContext * const s = &VAR_0->s;
uint8_t *dest_y, *dest_cb, *dest_cr;
int VAR_1, VAR_2, VAR_3, VAR_4;
const int VAR_5= s->VAR_4 + FRAME_MBAFF;
const int VAR_6= VAR_0->slice_type;
if(VAR_0->deblocking_filter) {
for(VAR_3= 0; VAR_3<s->mb_width; VAR_3++){
for(VAR_4=VAR_5 - FRAME_MBAFF; VAR_4<= VAR_5; VAR_4++){
int list, mb_xy, mb_type;
mb_xy = VAR_0->mb_xy = VAR_3 + VAR_4*s->mb_stride;
VAR_0->slice_num= VAR_0->slice_table[mb_xy];
mb_type= s->current_picture.mb_type[mb_xy];
VAR_0->list_count= VAR_0->list_counts[mb_xy];
if(FRAME_MBAFF)
VAR_0->mb_mbaff = VAR_0->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
s->VAR_3= VAR_3;
s->VAR_4= VAR_4;
dest_y = s->current_picture.data[0] + (VAR_3 + VAR_4 * s->VAR_1 ) * 16;
dest_cb = s->current_picture.data[1] + (VAR_3 + VAR_4 * s->VAR_2) * 8;
dest_cr = s->current_picture.data[2] + (VAR_3 + VAR_4 * s->VAR_2) * 8;
if (MB_FIELD) {
VAR_1 = VAR_0->mb_linesize = s->VAR_1 * 2;
VAR_2 = VAR_0->mb_uvlinesize = s->VAR_2 * 2;
if(VAR_4&1){
dest_y -= s->VAR_1*15;
dest_cb-= s->VAR_2*7;
dest_cr-= s->VAR_2*7;
}
} else {
VAR_1 = VAR_0->mb_linesize = s->VAR_1;
VAR_2 = VAR_0->mb_uvlinesize = s->VAR_2;
}
backup_mb_border(VAR_0, dest_y, dest_cb, dest_cr, VAR_1, VAR_2, 0);
if(fill_filter_caches(VAR_0, mb_type) < 0)
continue;
VAR_0->chroma_qp[0] = get_chroma_qp(VAR_0, 0, s->current_picture.qscale_table[mb_xy]);
VAR_0->chroma_qp[1] = get_chroma_qp(VAR_0, 1, s->current_picture.qscale_table[mb_xy]);
if (FRAME_MBAFF) {
ff_h264_filter_mb (VAR_0, VAR_3, VAR_4, dest_y, dest_cb, dest_cr, VAR_1, VAR_2);
} else {
ff_h264_filter_mb_fast(VAR_0, VAR_3, VAR_4, dest_y, dest_cb, dest_cr, VAR_1, VAR_2);
}
}
}
}
VAR_0->slice_type= VAR_6;
s->VAR_3= 0;
s->VAR_4= VAR_5 - FRAME_MBAFF;
}
| [
"static void FUNC_0(H264Context *VAR_0){",
"MpegEncContext * const s = &VAR_0->s;",
"uint8_t *dest_y, *dest_cb, *dest_cr;",
"int VAR_1, VAR_2, VAR_3, VAR_4;",
"const int VAR_5= s->VAR_4 + FRAME_MBAFF;",
"const int VAR_6= VAR_0->slice_type;",
"if(VAR_0->deblocking_filter) {",
"for(VAR_3= 0; VAR_3<s->mb_width; VAR_3++){",
"for(VAR_4=VAR_5 - FRAME_MBAFF; VAR_4<= VAR_5; VAR_4++){",
"int list, mb_xy, mb_type;",
"mb_xy = VAR_0->mb_xy = VAR_3 + VAR_4*s->mb_stride;",
"VAR_0->slice_num= VAR_0->slice_table[mb_xy];",
"mb_type= s->current_picture.mb_type[mb_xy];",
"VAR_0->list_count= VAR_0->list_counts[mb_xy];",
"if(FRAME_MBAFF)\nVAR_0->mb_mbaff = VAR_0->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);",
"s->VAR_3= VAR_3;",
"s->VAR_4= VAR_4;",
"dest_y = s->current_picture.data[0] + (VAR_3 + VAR_4 * s->VAR_1 ) * 16;",
"dest_cb = s->current_picture.data[1] + (VAR_3 + VAR_4 * s->VAR_2) * 8;",
"dest_cr = s->current_picture.data[2] + (VAR_3 + VAR_4 * s->VAR_2) * 8;",
"if (MB_FIELD) {",
"VAR_1 = VAR_0->mb_linesize = s->VAR_1 * 2;",
"VAR_2 = VAR_0->mb_uvlinesize = s->VAR_2 * 2;",
"if(VAR_4&1){",
"dest_y -= s->VAR_1*15;",
"dest_cb-= s->VAR_2*7;",
"dest_cr-= s->VAR_2*7;",
"}",
"} else {",
"VAR_1 = VAR_0->mb_linesize = s->VAR_1;",
"VAR_2 = VAR_0->mb_uvlinesize = s->VAR_2;",
"}",
"backup_mb_border(VAR_0, dest_y, dest_cb, dest_cr, VAR_1, VAR_2, 0);",
"if(fill_filter_caches(VAR_0, mb_type) < 0)\ncontinue;",
"VAR_0->chroma_qp[0] = get_chroma_qp(VAR_0, 0, s->current_picture.qscale_table[mb_xy]);",
"VAR_0->chroma_qp[1] = get_chroma_qp(VAR_0, 1, s->current_picture.qscale_table[mb_xy]);",
"if (FRAME_MBAFF) {",
"ff_h264_filter_mb (VAR_0, VAR_3, VAR_4, dest_y, dest_cb, dest_cr, VAR_1, VAR_2);",
"} else {",
"ff_h264_filter_mb_fast(VAR_0, VAR_3, VAR_4, dest_y, dest_cb, dest_cr, VAR_1, VAR_2);",
"}",
"}",
"}",
"}",
"VAR_0->slice_type= VAR_6;",
"s->VAR_3= 0;",
"s->VAR_4= VAR_5 - FRAME_MBAFF;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33,
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
]
] |
21,575 | static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track,
int64_t moof_offset)
{
int64_t pos = avio_tell(pb);
uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
MOV_TFHD_BASE_DATA_OFFSET;
if (!track->entry) {
flags |= MOV_TFHD_DURATION_IS_EMPTY;
} else {
flags |= MOV_TFHD_DEFAULT_FLAGS;
}
/* Don't set a default sample size, the silverlight player refuses
* to play files with that set. Don't set a default sample duration,
* WMP freaks out if it is set. */
if (track->mode == MODE_ISM)
flags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION);
avio_wb32(pb, 0); /* size placeholder */
ffio_wfourcc(pb, "tfhd");
avio_w8(pb, 0); /* version */
avio_wb24(pb, flags);
avio_wb32(pb, track->track_id); /* track-id */
if (flags & MOV_TFHD_BASE_DATA_OFFSET)
avio_wb64(pb, moof_offset);
if (flags & MOV_TFHD_DEFAULT_DURATION) {
track->default_duration = get_cluster_duration(track, 0);
avio_wb32(pb, track->default_duration);
}
if (flags & MOV_TFHD_DEFAULT_SIZE) {
track->default_size = track->entry ? track->cluster[0].size : 1;
avio_wb32(pb, track->default_size);
} else
track->default_size = -1;
if (flags & MOV_TFHD_DEFAULT_FLAGS) {
track->default_sample_flags =
track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
(MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
avio_wb32(pb, track->default_sample_flags);
}
return update_size(pb, pos);
}
| false | FFmpeg | 28e6b7b9b4e0a6ec05575cffedd56e1319f8691f | static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track,
int64_t moof_offset)
{
int64_t pos = avio_tell(pb);
uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
MOV_TFHD_BASE_DATA_OFFSET;
if (!track->entry) {
flags |= MOV_TFHD_DURATION_IS_EMPTY;
} else {
flags |= MOV_TFHD_DEFAULT_FLAGS;
}
if (track->mode == MODE_ISM)
flags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION);
avio_wb32(pb, 0);
ffio_wfourcc(pb, "tfhd");
avio_w8(pb, 0);
avio_wb24(pb, flags);
avio_wb32(pb, track->track_id);
if (flags & MOV_TFHD_BASE_DATA_OFFSET)
avio_wb64(pb, moof_offset);
if (flags & MOV_TFHD_DEFAULT_DURATION) {
track->default_duration = get_cluster_duration(track, 0);
avio_wb32(pb, track->default_duration);
}
if (flags & MOV_TFHD_DEFAULT_SIZE) {
track->default_size = track->entry ? track->cluster[0].size : 1;
avio_wb32(pb, track->default_size);
} else
track->default_size = -1;
if (flags & MOV_TFHD_DEFAULT_FLAGS) {
track->default_sample_flags =
track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
(MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
avio_wb32(pb, track->default_sample_flags);
}
return update_size(pb, pos);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVIOContext *VAR_0, MOVTrack *VAR_1,
int64_t VAR_2)
{
int64_t pos = avio_tell(VAR_0);
uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
MOV_TFHD_BASE_DATA_OFFSET;
if (!VAR_1->entry) {
flags |= MOV_TFHD_DURATION_IS_EMPTY;
} else {
flags |= MOV_TFHD_DEFAULT_FLAGS;
}
if (VAR_1->mode == MODE_ISM)
flags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION);
avio_wb32(VAR_0, 0);
ffio_wfourcc(VAR_0, "tfhd");
avio_w8(VAR_0, 0);
avio_wb24(VAR_0, flags);
avio_wb32(VAR_0, VAR_1->track_id);
if (flags & MOV_TFHD_BASE_DATA_OFFSET)
avio_wb64(VAR_0, VAR_2);
if (flags & MOV_TFHD_DEFAULT_DURATION) {
VAR_1->default_duration = get_cluster_duration(VAR_1, 0);
avio_wb32(VAR_0, VAR_1->default_duration);
}
if (flags & MOV_TFHD_DEFAULT_SIZE) {
VAR_1->default_size = VAR_1->entry ? VAR_1->cluster[0].size : 1;
avio_wb32(VAR_0, VAR_1->default_size);
} else
VAR_1->default_size = -1;
if (flags & MOV_TFHD_DEFAULT_FLAGS) {
VAR_1->default_sample_flags =
VAR_1->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
(MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
avio_wb32(VAR_0, VAR_1->default_sample_flags);
}
return update_size(VAR_0, pos);
}
| [
"static int FUNC_0(AVIOContext *VAR_0, MOVTrack *VAR_1,\nint64_t VAR_2)\n{",
"int64_t pos = avio_tell(VAR_0);",
"uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |\nMOV_TFHD_BASE_DATA_OFFSET;",
"if (!VAR_1->entry) {",
"flags |= MOV_TFHD_DURATION_IS_EMPTY;",
"} else {",
"flags |= MOV_TFHD_DEFAULT_FLAGS;",
"}",
"if (VAR_1->mode == MODE_ISM)\nflags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION);",
"avio_wb32(VAR_0, 0);",
"ffio_wfourcc(VAR_0, \"tfhd\");",
"avio_w8(VAR_0, 0);",
"avio_wb24(VAR_0, flags);",
"avio_wb32(VAR_0, VAR_1->track_id);",
"if (flags & MOV_TFHD_BASE_DATA_OFFSET)\navio_wb64(VAR_0, VAR_2);",
"if (flags & MOV_TFHD_DEFAULT_DURATION) {",
"VAR_1->default_duration = get_cluster_duration(VAR_1, 0);",
"avio_wb32(VAR_0, VAR_1->default_duration);",
"}",
"if (flags & MOV_TFHD_DEFAULT_SIZE) {",
"VAR_1->default_size = VAR_1->entry ? VAR_1->cluster[0].size : 1;",
"avio_wb32(VAR_0, VAR_1->default_size);",
"} else",
"VAR_1->default_size = -1;",
"if (flags & MOV_TFHD_DEFAULT_FLAGS) {",
"VAR_1->default_sample_flags =\nVAR_1->enc->codec_type == AVMEDIA_TYPE_VIDEO ?\n(MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :\nMOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;",
"avio_wb32(VAR_0, VAR_1->default_sample_flags);",
"}",
"return update_size(VAR_0, pos);",
"}"
] | [
0,
0,
0,
0,
0,
0,
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
],
[
31,
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49,
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75,
77,
79,
81
],
[
83
],
[
85
],
[
89
],
[
91
]
] |
21,577 | static int normalize_samples(AC3EncodeContext *s)
{
int v = 14 - log2_tab(s, s->windowed_samples, AC3_WINDOW_SIZE);
lshift_tab(s->windowed_samples, AC3_WINDOW_SIZE, v);
return v - 9;
}
| true | FFmpeg | 323e6fead07c75f418e4b60704a4f437bb3483b2 | static int normalize_samples(AC3EncodeContext *s)
{
int v = 14 - log2_tab(s, s->windowed_samples, AC3_WINDOW_SIZE);
lshift_tab(s->windowed_samples, AC3_WINDOW_SIZE, v);
return v - 9;
}
| {
"code": [
" return v - 9;"
],
"line_no": [
9
]
} | static int FUNC_0(AC3EncodeContext *VAR_0)
{
int VAR_1 = 14 - log2_tab(VAR_0, VAR_0->windowed_samples, AC3_WINDOW_SIZE);
lshift_tab(VAR_0->windowed_samples, AC3_WINDOW_SIZE, VAR_1);
return VAR_1 - 9;
}
| [
"static int FUNC_0(AC3EncodeContext *VAR_0)\n{",
"int VAR_1 = 14 - log2_tab(VAR_0, VAR_0->windowed_samples, AC3_WINDOW_SIZE);",
"lshift_tab(VAR_0->windowed_samples, AC3_WINDOW_SIZE, VAR_1);",
"return VAR_1 - 9;",
"}"
] | [
0,
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
] |
21,578 | uint32_t HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
{
int r = sclp_service_call(env, r1, r2);
if (r < 0) {
program_interrupt(env, -r, 4);
return 0;
}
return r;
}
| true | qemu | 8d04fb55dec381bc5105cb47f29d918e579e8cbd | uint32_t HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
{
int r = sclp_service_call(env, r1, r2);
if (r < 0) {
program_interrupt(env, -r, 4);
return 0;
}
return r;
}
| {
"code": [
" return 0;"
],
"line_no": [
11
]
} | uint32_t FUNC_0(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
{
int VAR_0 = sclp_service_call(env, r1, r2);
if (VAR_0 < 0) {
program_interrupt(env, -VAR_0, 4);
return 0;
}
return VAR_0;
}
| [
"uint32_t FUNC_0(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)\n{",
"int VAR_0 = sclp_service_call(env, r1, r2);",
"if (VAR_0 < 0) {",
"program_interrupt(env, -VAR_0, 4);",
"return 0;",
"}",
"return VAR_0;",
"}"
] | [
0,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
21,579 | static void test_query_cpus(const void *data)
{
char *cli;
QDict *resp;
QList *cpus;
const QObject *e;
cli = make_cli(data, "-smp 8 -numa node,cpus=0-3 -numa node,cpus=4-7");
qtest_start(cli);
cpus = get_cpus(&resp);
g_assert(cpus);
while ((e = qlist_pop(cpus))) {
QDict *cpu, *props;
int64_t cpu_idx, node;
cpu = qobject_to_qdict(e);
g_assert(qdict_haskey(cpu, "CPU"));
g_assert(qdict_haskey(cpu, "props"));
cpu_idx = qdict_get_int(cpu, "CPU");
props = qdict_get_qdict(cpu, "props");
g_assert(qdict_haskey(props, "node-id"));
node = qdict_get_int(props, "node-id");
if (cpu_idx >= 0 && cpu_idx < 4) {
g_assert_cmpint(node, ==, 0);
} else {
g_assert_cmpint(node, ==, 1);
}
}
QDECREF(resp);
qtest_end();
g_free(cli);
}
| true | qemu | 5e39d89d20b17cf6fb7f09d181d34f17b2ae2160 | static void test_query_cpus(const void *data)
{
char *cli;
QDict *resp;
QList *cpus;
const QObject *e;
cli = make_cli(data, "-smp 8 -numa node,cpus=0-3 -numa node,cpus=4-7");
qtest_start(cli);
cpus = get_cpus(&resp);
g_assert(cpus);
while ((e = qlist_pop(cpus))) {
QDict *cpu, *props;
int64_t cpu_idx, node;
cpu = qobject_to_qdict(e);
g_assert(qdict_haskey(cpu, "CPU"));
g_assert(qdict_haskey(cpu, "props"));
cpu_idx = qdict_get_int(cpu, "CPU");
props = qdict_get_qdict(cpu, "props");
g_assert(qdict_haskey(props, "node-id"));
node = qdict_get_int(props, "node-id");
if (cpu_idx >= 0 && cpu_idx < 4) {
g_assert_cmpint(node, ==, 0);
} else {
g_assert_cmpint(node, ==, 1);
}
}
QDECREF(resp);
qtest_end();
g_free(cli);
}
| {
"code": [
" const QObject *e;",
" const QObject *e;",
" const QObject *e;",
" const QObject *e;"
],
"line_no": [
11,
11,
11,
11
]
} | static void FUNC_0(const void *VAR_0)
{
char *VAR_1;
QDict *resp;
QList *cpus;
const QObject *VAR_2;
VAR_1 = make_cli(VAR_0, "-smp 8 -numa node,cpus=0-3 -numa node,cpus=4-7");
qtest_start(VAR_1);
cpus = get_cpus(&resp);
g_assert(cpus);
while ((VAR_2 = qlist_pop(cpus))) {
QDict *cpu, *props;
int64_t cpu_idx, node;
cpu = qobject_to_qdict(VAR_2);
g_assert(qdict_haskey(cpu, "CPU"));
g_assert(qdict_haskey(cpu, "props"));
cpu_idx = qdict_get_int(cpu, "CPU");
props = qdict_get_qdict(cpu, "props");
g_assert(qdict_haskey(props, "node-id"));
node = qdict_get_int(props, "node-id");
if (cpu_idx >= 0 && cpu_idx < 4) {
g_assert_cmpint(node, ==, 0);
} else {
g_assert_cmpint(node, ==, 1);
}
}
QDECREF(resp);
qtest_end();
g_free(VAR_1);
}
| [
"static void FUNC_0(const void *VAR_0)\n{",
"char *VAR_1;",
"QDict *resp;",
"QList *cpus;",
"const QObject *VAR_2;",
"VAR_1 = make_cli(VAR_0, \"-smp 8 -numa node,cpus=0-3 -numa node,cpus=4-7\");",
"qtest_start(VAR_1);",
"cpus = get_cpus(&resp);",
"g_assert(cpus);",
"while ((VAR_2 = qlist_pop(cpus))) {",
"QDict *cpu, *props;",
"int64_t cpu_idx, node;",
"cpu = qobject_to_qdict(VAR_2);",
"g_assert(qdict_haskey(cpu, \"CPU\"));",
"g_assert(qdict_haskey(cpu, \"props\"));",
"cpu_idx = qdict_get_int(cpu, \"CPU\");",
"props = qdict_get_qdict(cpu, \"props\");",
"g_assert(qdict_haskey(props, \"node-id\"));",
"node = qdict_get_int(props, \"node-id\");",
"if (cpu_idx >= 0 && cpu_idx < 4) {",
"g_assert_cmpint(node, ==, 0);",
"} else {",
"g_assert_cmpint(node, ==, 1);",
"}",
"}",
"QDECREF(resp);",
"qtest_end();",
"g_free(VAR_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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
]
] |
21,580 | int virtio_scsi_common_exit(VirtIOSCSICommon *vs)
{
VirtIODevice *vdev = VIRTIO_DEVICE(vs);
g_free(vs->cmd_vqs);
virtio_cleanup(vdev);
return 0;
}
| true | qemu | e3c9d76acc984218264bbc6435b0c09f959ed9b8 | int virtio_scsi_common_exit(VirtIOSCSICommon *vs)
{
VirtIODevice *vdev = VIRTIO_DEVICE(vs);
g_free(vs->cmd_vqs);
virtio_cleanup(vdev);
return 0;
}
| {
"code": [
"int virtio_scsi_common_exit(VirtIOSCSICommon *vs)",
" return 0;"
],
"line_no": [
1,
13
]
} | int FUNC_0(VirtIOSCSICommon *VAR_0)
{
VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);
g_free(VAR_0->cmd_vqs);
virtio_cleanup(vdev);
return 0;
}
| [
"int FUNC_0(VirtIOSCSICommon *VAR_0)\n{",
"VirtIODevice *vdev = VIRTIO_DEVICE(VAR_0);",
"g_free(VAR_0->cmd_vqs);",
"virtio_cleanup(vdev);",
"return 0;",
"}"
] | [
1,
0,
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
21,581 | static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
int pred_order, int bps)
{
const int blocksize = s->blocksize;
unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
int i;
int ret;
/* warm up samples */
for (i = 0; i < pred_order; i++) {
decoded[i] = get_sbits_long(&s->gb, bps);
}
if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
return ret;
if (pred_order > 0)
a = decoded[pred_order-1];
if (pred_order > 1)
b = a - decoded[pred_order-2];
if (pred_order > 2)
c = b - decoded[pred_order-2] + decoded[pred_order-3];
if (pred_order > 3)
d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
switch (pred_order) {
case 0:
break;
case 1:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += decoded[i];
break;
case 2:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += b += decoded[i];
break;
case 3:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += b += c += decoded[i];
break;
case 4:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += b += c += d += decoded[i];
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
return AVERROR_INVALIDDATA;
}
return 0;
}
| true | FFmpeg | 3d23f7a0969bf76ad6dcdc2c4a5cd3ae884745a8 | static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
int pred_order, int bps)
{
const int blocksize = s->blocksize;
unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
int i;
int ret;
for (i = 0; i < pred_order; i++) {
decoded[i] = get_sbits_long(&s->gb, bps);
}
if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
return ret;
if (pred_order > 0)
a = decoded[pred_order-1];
if (pred_order > 1)
b = a - decoded[pred_order-2];
if (pred_order > 2)
c = b - decoded[pred_order-2] + decoded[pred_order-3];
if (pred_order > 3)
d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
switch (pred_order) {
case 0:
break;
case 1:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += decoded[i];
break;
case 2:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += b += decoded[i];
break;
case 3:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += b += c += decoded[i];
break;
case 4:
for (i = pred_order; i < blocksize; i++)
decoded[i] = a += b += c += d += decoded[i];
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
return AVERROR_INVALIDDATA;
}
return 0;
}
| {
"code": [
" d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];"
],
"line_no": [
47
]
} | static int FUNC_0(FLACContext *VAR_0, int32_t *VAR_1,
int VAR_2, int VAR_3)
{
const int VAR_4 = VAR_0->VAR_4;
unsigned FUNC_1(a), FUNC_1(b), FUNC_1(c), FUNC_1(d);
int VAR_5;
int VAR_6;
for (VAR_5 = 0; VAR_5 < VAR_2; VAR_5++) {
VAR_1[VAR_5] = get_sbits_long(&VAR_0->gb, VAR_3);
}
if ((VAR_6 = decode_residuals(VAR_0, VAR_1, VAR_2)) < 0)
return VAR_6;
if (VAR_2 > 0)
a = VAR_1[VAR_2-1];
if (VAR_2 > 1)
b = a - VAR_1[VAR_2-2];
if (VAR_2 > 2)
c = b - VAR_1[VAR_2-2] + VAR_1[VAR_2-3];
if (VAR_2 > 3)
d = c - VAR_1[VAR_2-2] + 2*VAR_1[VAR_2-3] - VAR_1[VAR_2-4];
switch (VAR_2) {
case 0:
break;
case 1:
for (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)
VAR_1[VAR_5] = a += VAR_1[VAR_5];
break;
case 2:
for (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)
VAR_1[VAR_5] = a += b += VAR_1[VAR_5];
break;
case 3:
for (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)
VAR_1[VAR_5] = a += b += c += VAR_1[VAR_5];
break;
case 4:
for (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)
VAR_1[VAR_5] = a += b += c += d += VAR_1[VAR_5];
break;
default:
av_log(VAR_0->avctx, AV_LOG_ERROR, "illegal pred order %d\n", VAR_2);
return AVERROR_INVALIDDATA;
}
return 0;
}
| [
"static int FUNC_0(FLACContext *VAR_0, int32_t *VAR_1,\nint VAR_2, int VAR_3)\n{",
"const int VAR_4 = VAR_0->VAR_4;",
"unsigned FUNC_1(a), FUNC_1(b), FUNC_1(c), FUNC_1(d);",
"int VAR_5;",
"int VAR_6;",
"for (VAR_5 = 0; VAR_5 < VAR_2; VAR_5++) {",
"VAR_1[VAR_5] = get_sbits_long(&VAR_0->gb, VAR_3);",
"}",
"if ((VAR_6 = decode_residuals(VAR_0, VAR_1, VAR_2)) < 0)\nreturn VAR_6;",
"if (VAR_2 > 0)\na = VAR_1[VAR_2-1];",
"if (VAR_2 > 1)\nb = a - VAR_1[VAR_2-2];",
"if (VAR_2 > 2)\nc = b - VAR_1[VAR_2-2] + VAR_1[VAR_2-3];",
"if (VAR_2 > 3)\nd = c - VAR_1[VAR_2-2] + 2*VAR_1[VAR_2-3] - VAR_1[VAR_2-4];",
"switch (VAR_2) {",
"case 0:\nbreak;",
"case 1:\nfor (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)",
"VAR_1[VAR_5] = a += VAR_1[VAR_5];",
"break;",
"case 2:\nfor (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)",
"VAR_1[VAR_5] = a += b += VAR_1[VAR_5];",
"break;",
"case 3:\nfor (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)",
"VAR_1[VAR_5] = a += b += c += VAR_1[VAR_5];",
"break;",
"case 4:\nfor (VAR_5 = VAR_2; VAR_5 < VAR_4; VAR_5++)",
"VAR_1[VAR_5] = a += b += c += d += VAR_1[VAR_5];",
"break;",
"default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"illegal pred order %d\\n\", VAR_2);",
"return AVERROR_INVALIDDATA;",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
19
],
[
21
],
[
23
],
[
27,
29
],
[
33,
35
],
[
37,
39
],
[
41,
43
],
[
45,
47
],
[
51
],
[
53,
55
],
[
57,
59
],
[
61
],
[
63
],
[
65,
67
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81,
83
],
[
85
],
[
87
],
[
89,
91
],
[
93
],
[
95
],
[
99
],
[
101
]
] |
21,582 | static int add_tonal_components(float *spectrum, int num_components,
TonalComponent *components)
{
int i, j, last_pos = -1;
float *input, *output;
for (i = 0; i < num_components; i++) {
last_pos = FFMAX(components[i].pos + components[i].num_coefs, last_pos);
input = components[i].coef;
output = &spectrum[components[i].pos];
for (j = 0; j < components[i].num_coefs; j++)
output[i] += input[i];
}
return last_pos;
}
| false | FFmpeg | 0e3afacd4d8fbe1c21e0bc16bd707809cd87380f | static int add_tonal_components(float *spectrum, int num_components,
TonalComponent *components)
{
int i, j, last_pos = -1;
float *input, *output;
for (i = 0; i < num_components; i++) {
last_pos = FFMAX(components[i].pos + components[i].num_coefs, last_pos);
input = components[i].coef;
output = &spectrum[components[i].pos];
for (j = 0; j < components[i].num_coefs; j++)
output[i] += input[i];
}
return last_pos;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(float *VAR_0, int VAR_1,
TonalComponent *VAR_2)
{
int VAR_3, VAR_4, VAR_5 = -1;
float *VAR_6, *VAR_7;
for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {
VAR_5 = FFMAX(VAR_2[VAR_3].pos + VAR_2[VAR_3].num_coefs, VAR_5);
VAR_6 = VAR_2[VAR_3].coef;
VAR_7 = &VAR_0[VAR_2[VAR_3].pos];
for (VAR_4 = 0; VAR_4 < VAR_2[VAR_3].num_coefs; VAR_4++)
VAR_7[VAR_3] += VAR_6[VAR_3];
}
return VAR_5;
}
| [
"static int FUNC_0(float *VAR_0, int VAR_1,\nTonalComponent *VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5 = -1;",
"float *VAR_6, *VAR_7;",
"for (VAR_3 = 0; VAR_3 < VAR_1; VAR_3++) {",
"VAR_5 = FFMAX(VAR_2[VAR_3].pos + VAR_2[VAR_3].num_coefs, VAR_5);",
"VAR_6 = VAR_2[VAR_3].coef;",
"VAR_7 = &VAR_0[VAR_2[VAR_3].pos];",
"for (VAR_4 = 0; VAR_4 < VAR_2[VAR_3].num_coefs; VAR_4++)",
"VAR_7[VAR_3] += VAR_6[VAR_3];",
"}",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
]
] |
21,588 | static int qemu_rdma_write_flush(QEMUFile *f, RDMAContext *rdma)
{
int ret;
if (!rdma->current_length) {
return 0;
}
ret = qemu_rdma_write_one(f, rdma,
rdma->current_index, rdma->current_addr, rdma->current_length);
if (ret < 0) {
return ret;
}
if (ret == 0) {
rdma->nb_sent++;
DDDPRINTF("sent total: %d\n", rdma->nb_sent);
}
rdma->current_length = 0;
rdma->current_addr = 0;
return 0;
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | static int qemu_rdma_write_flush(QEMUFile *f, RDMAContext *rdma)
{
int ret;
if (!rdma->current_length) {
return 0;
}
ret = qemu_rdma_write_one(f, rdma,
rdma->current_index, rdma->current_addr, rdma->current_length);
if (ret < 0) {
return ret;
}
if (ret == 0) {
rdma->nb_sent++;
DDDPRINTF("sent total: %d\n", rdma->nb_sent);
}
rdma->current_length = 0;
rdma->current_addr = 0;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(QEMUFile *VAR_0, RDMAContext *VAR_1)
{
int VAR_2;
if (!VAR_1->current_length) {
return 0;
}
VAR_2 = qemu_rdma_write_one(VAR_0, VAR_1,
VAR_1->current_index, VAR_1->current_addr, VAR_1->current_length);
if (VAR_2 < 0) {
return VAR_2;
}
if (VAR_2 == 0) {
VAR_1->nb_sent++;
DDDPRINTF("sent total: %d\n", VAR_1->nb_sent);
}
VAR_1->current_length = 0;
VAR_1->current_addr = 0;
return 0;
}
| [
"static int FUNC_0(QEMUFile *VAR_0, RDMAContext *VAR_1)\n{",
"int VAR_2;",
"if (!VAR_1->current_length) {",
"return 0;",
"}",
"VAR_2 = qemu_rdma_write_one(VAR_0, VAR_1,\nVAR_1->current_index, VAR_1->current_addr, VAR_1->current_length);",
"if (VAR_2 < 0) {",
"return VAR_2;",
"}",
"if (VAR_2 == 0) {",
"VAR_1->nb_sent++;",
"DDDPRINTF(\"sent total: %d\\n\", VAR_1->nb_sent);",
"}",
"VAR_1->current_length = 0;",
"VAR_1->current_addr = 0;",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17,
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
47
],
[
49
]
] |
21,590 | Exynos4210State *exynos4210_init(MemoryRegion *system_mem,
unsigned long ram_size)
{
int i, n;
Exynos4210State *s = g_new(Exynos4210State, 1);
qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];
unsigned long mem_size;
DeviceState *dev;
SysBusDevice *busdev;
ObjectClass *cpu_oc;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, "cortex-a9");
assert(cpu_oc);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
Object *cpuobj = object_new(object_class_get_name(cpu_oc));
/* By default A9 CPUs have EL3 enabled. This board does not currently
* support EL3 so the CPU EL3 property is disabled before realization.
*/
if (object_property_find(cpuobj, "has_el3", NULL)) {
object_property_set_bool(cpuobj, false, "has_el3", &error_fatal);
}
s->cpu[n] = ARM_CPU(cpuobj);
object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,
"reset-cbar", &error_abort);
object_property_set_bool(cpuobj, true, "realized", &error_fatal);
}
/*** IRQs ***/
s->irq_table = exynos4210_init_irq(&s->irqs);
/* IRQ Gate */
for (i = 0; i < EXYNOS4210_NCPUS; i++) {
dev = qdev_create(NULL, "exynos4210.irq_gate");
qdev_prop_set_uint32(dev, "n_in", EXYNOS4210_IRQ_GATE_NINPUTS);
qdev_init_nofail(dev);
/* Get IRQ Gate input in gate_irq */
for (n = 0; n < EXYNOS4210_IRQ_GATE_NINPUTS; n++) {
gate_irq[i][n] = qdev_get_gpio_in(dev, n);
}
busdev = SYS_BUS_DEVICE(dev);
/* Connect IRQ Gate output to CPU's IRQ line */
sysbus_connect_irq(busdev, 0,
qdev_get_gpio_in(DEVICE(s->cpu[i]), ARM_CPU_IRQ));
}
/* Private memory region and Internal GIC */
dev = qdev_create(NULL, "a9mpcore_priv");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][0]);
}
for (n = 0; n < EXYNOS4210_INT_GIC_NIRQ; n++) {
s->irqs.int_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
/* Cache controller */
sysbus_create_simple("l2x0", EXYNOS4210_L2X0_BASE_ADDR, NULL);
/* External GIC */
dev = qdev_create(NULL, "exynos4210.gic");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
/* Map CPU interface */
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);
/* Map Distributer interface */
sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][1]);
}
for (n = 0; n < EXYNOS4210_EXT_GIC_NIRQ; n++) {
s->irqs.ext_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
/* Internal Interrupt Combiner */
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.int_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);
sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);
/* External Interrupt Combiner */
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_prop_set_uint32(dev, "external", 1);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.ext_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);
/* Initialize board IRQs. */
exynos4210_init_board_irqs(&s->irqs);
/*** Memory ***/
/* Chip-ID and OMR */
memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,
NULL, "exynos4210.chipid", sizeof(chipid_and_omr));
memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,
&s->chipid_mem);
/* Internal ROM */
memory_region_init_ram(&s->irom_mem, NULL, "exynos4210.irom",
EXYNOS4210_IROM_SIZE, &error_fatal);
vmstate_register_ram_global(&s->irom_mem);
memory_region_set_readonly(&s->irom_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,
&s->irom_mem);
/* mirror of iROM */
memory_region_init_alias(&s->irom_alias_mem, NULL, "exynos4210.irom_alias",
&s->irom_mem,
0,
EXYNOS4210_IROM_SIZE);
memory_region_set_readonly(&s->irom_alias_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,
&s->irom_alias_mem);
/* Internal RAM */
memory_region_init_ram(&s->iram_mem, NULL, "exynos4210.iram",
EXYNOS4210_IRAM_SIZE, &error_fatal);
vmstate_register_ram_global(&s->iram_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,
&s->iram_mem);
/* DRAM */
mem_size = ram_size;
if (mem_size > EXYNOS4210_DRAM_MAX_SIZE) {
memory_region_init_ram(&s->dram1_mem, NULL, "exynos4210.dram1",
mem_size - EXYNOS4210_DRAM_MAX_SIZE, &error_fatal);
vmstate_register_ram_global(&s->dram1_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,
&s->dram1_mem);
mem_size = EXYNOS4210_DRAM_MAX_SIZE;
}
memory_region_init_ram(&s->dram0_mem, NULL, "exynos4210.dram0", mem_size,
&error_fatal);
vmstate_register_ram_global(&s->dram0_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,
&s->dram0_mem);
/* PMU.
* The only reason of existence at the moment is that secondary CPU boot
* loader uses PMU INFORM5 register as a holding pen.
*/
sysbus_create_simple("exynos4210.pmu", EXYNOS4210_PMU_BASE_ADDR, NULL);
/* PWM */
sysbus_create_varargs("exynos4210.pwm", EXYNOS4210_PWM_BASE_ADDR,
s->irq_table[exynos4210_get_irq(22, 0)],
s->irq_table[exynos4210_get_irq(22, 1)],
s->irq_table[exynos4210_get_irq(22, 2)],
s->irq_table[exynos4210_get_irq(22, 3)],
s->irq_table[exynos4210_get_irq(22, 4)],
NULL);
/* RTC */
sysbus_create_varargs("exynos4210.rtc", EXYNOS4210_RTC_BASE_ADDR,
s->irq_table[exynos4210_get_irq(23, 0)],
s->irq_table[exynos4210_get_irq(23, 1)],
NULL);
/* Multi Core Timer */
dev = qdev_create(NULL, "exynos4210.mct");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < 4; n++) {
/* Connect global timer interrupts to Combiner gpio_in */
sysbus_connect_irq(busdev, n,
s->irq_table[exynos4210_get_irq(1, 4 + n)]);
}
/* Connect local timer interrupts to Combiner gpio_in */
sysbus_connect_irq(busdev, 4,
s->irq_table[exynos4210_get_irq(51, 0)]);
sysbus_connect_irq(busdev, 5,
s->irq_table[exynos4210_get_irq(35, 3)]);
sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);
/*** I2C ***/
for (n = 0; n < EXYNOS4210_I2C_NUMBER; n++) {
uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * n;
qemu_irq i2c_irq;
if (n < 8) {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, n)];
} else {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];
}
dev = qdev_create(NULL, "exynos4210.i2c");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, i2c_irq);
sysbus_mmio_map(busdev, 0, addr);
s->i2c_if[n] = (I2CBus *)qdev_get_child_bus(dev, "i2c");
}
/*** UARTs ***/
exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,
EXYNOS4210_UART0_FIFO_SIZE, 0, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);
exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,
EXYNOS4210_UART1_FIFO_SIZE, 1, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);
exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,
EXYNOS4210_UART2_FIFO_SIZE, 2, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);
exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,
EXYNOS4210_UART3_FIFO_SIZE, 3, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);
/*** Display controller (FIMD) ***/
sysbus_create_varargs("exynos4210.fimd", EXYNOS4210_FIMD0_BASE_ADDR,
s->irq_table[exynos4210_get_irq(11, 0)],
s->irq_table[exynos4210_get_irq(11, 1)],
s->irq_table[exynos4210_get_irq(11, 2)],
NULL);
sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
s->irq_table[exynos4210_get_irq(28, 3)]);
return s;
} | true | qemu | 1e0228fd20aa46ac1f02cffee946cdd4ffaf8b96 | Exynos4210State *exynos4210_init(MemoryRegion *system_mem,
unsigned long ram_size)
{
int i, n;
Exynos4210State *s = g_new(Exynos4210State, 1);
qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];
unsigned long mem_size;
DeviceState *dev;
SysBusDevice *busdev;
ObjectClass *cpu_oc;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, "cortex-a9");
assert(cpu_oc);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
Object *cpuobj = object_new(object_class_get_name(cpu_oc));
if (object_property_find(cpuobj, "has_el3", NULL)) {
object_property_set_bool(cpuobj, false, "has_el3", &error_fatal);
}
s->cpu[n] = ARM_CPU(cpuobj);
object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,
"reset-cbar", &error_abort);
object_property_set_bool(cpuobj, true, "realized", &error_fatal);
}
s->irq_table = exynos4210_init_irq(&s->irqs);
for (i = 0; i < EXYNOS4210_NCPUS; i++) {
dev = qdev_create(NULL, "exynos4210.irq_gate");
qdev_prop_set_uint32(dev, "n_in", EXYNOS4210_IRQ_GATE_NINPUTS);
qdev_init_nofail(dev);
for (n = 0; n < EXYNOS4210_IRQ_GATE_NINPUTS; n++) {
gate_irq[i][n] = qdev_get_gpio_in(dev, n);
}
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0,
qdev_get_gpio_in(DEVICE(s->cpu[i]), ARM_CPU_IRQ));
}
dev = qdev_create(NULL, "a9mpcore_priv");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][0]);
}
for (n = 0; n < EXYNOS4210_INT_GIC_NIRQ; n++) {
s->irqs.int_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
sysbus_create_simple("l2x0", EXYNOS4210_L2X0_BASE_ADDR, NULL);
dev = qdev_create(NULL, "exynos4210.gic");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);
sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);
for (n = 0; n < EXYNOS4210_NCPUS; n++) {
sysbus_connect_irq(busdev, n, gate_irq[n][1]);
}
for (n = 0; n < EXYNOS4210_EXT_GIC_NIRQ; n++) {
s->irqs.ext_gic_irq[n] = qdev_get_gpio_in(dev, n);
}
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.int_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);
sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_prop_set_uint32(dev, "external", 1);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; n++) {
sysbus_connect_irq(busdev, n, s->irqs.ext_gic_irq[n]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);
exynos4210_init_board_irqs(&s->irqs);
memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,
NULL, "exynos4210.chipid", sizeof(chipid_and_omr));
memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,
&s->chipid_mem);
memory_region_init_ram(&s->irom_mem, NULL, "exynos4210.irom",
EXYNOS4210_IROM_SIZE, &error_fatal);
vmstate_register_ram_global(&s->irom_mem);
memory_region_set_readonly(&s->irom_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,
&s->irom_mem);
memory_region_init_alias(&s->irom_alias_mem, NULL, "exynos4210.irom_alias",
&s->irom_mem,
0,
EXYNOS4210_IROM_SIZE);
memory_region_set_readonly(&s->irom_alias_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,
&s->irom_alias_mem);
memory_region_init_ram(&s->iram_mem, NULL, "exynos4210.iram",
EXYNOS4210_IRAM_SIZE, &error_fatal);
vmstate_register_ram_global(&s->iram_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,
&s->iram_mem);
mem_size = ram_size;
if (mem_size > EXYNOS4210_DRAM_MAX_SIZE) {
memory_region_init_ram(&s->dram1_mem, NULL, "exynos4210.dram1",
mem_size - EXYNOS4210_DRAM_MAX_SIZE, &error_fatal);
vmstate_register_ram_global(&s->dram1_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,
&s->dram1_mem);
mem_size = EXYNOS4210_DRAM_MAX_SIZE;
}
memory_region_init_ram(&s->dram0_mem, NULL, "exynos4210.dram0", mem_size,
&error_fatal);
vmstate_register_ram_global(&s->dram0_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,
&s->dram0_mem);
sysbus_create_simple("exynos4210.pmu", EXYNOS4210_PMU_BASE_ADDR, NULL);
sysbus_create_varargs("exynos4210.pwm", EXYNOS4210_PWM_BASE_ADDR,
s->irq_table[exynos4210_get_irq(22, 0)],
s->irq_table[exynos4210_get_irq(22, 1)],
s->irq_table[exynos4210_get_irq(22, 2)],
s->irq_table[exynos4210_get_irq(22, 3)],
s->irq_table[exynos4210_get_irq(22, 4)],
NULL);
sysbus_create_varargs("exynos4210.rtc", EXYNOS4210_RTC_BASE_ADDR,
s->irq_table[exynos4210_get_irq(23, 0)],
s->irq_table[exynos4210_get_irq(23, 1)],
NULL);
dev = qdev_create(NULL, "exynos4210.mct");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (n = 0; n < 4; n++) {
sysbus_connect_irq(busdev, n,
s->irq_table[exynos4210_get_irq(1, 4 + n)]);
}
sysbus_connect_irq(busdev, 4,
s->irq_table[exynos4210_get_irq(51, 0)]);
sysbus_connect_irq(busdev, 5,
s->irq_table[exynos4210_get_irq(35, 3)]);
sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);
for (n = 0; n < EXYNOS4210_I2C_NUMBER; n++) {
uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * n;
qemu_irq i2c_irq;
if (n < 8) {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, n)];
} else {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];
}
dev = qdev_create(NULL, "exynos4210.i2c");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, i2c_irq);
sysbus_mmio_map(busdev, 0, addr);
s->i2c_if[n] = (I2CBus *)qdev_get_child_bus(dev, "i2c");
}
exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,
EXYNOS4210_UART0_FIFO_SIZE, 0, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);
exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,
EXYNOS4210_UART1_FIFO_SIZE, 1, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);
exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,
EXYNOS4210_UART2_FIFO_SIZE, 2, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);
exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,
EXYNOS4210_UART3_FIFO_SIZE, 3, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);
sysbus_create_varargs("exynos4210.fimd", EXYNOS4210_FIMD0_BASE_ADDR,
s->irq_table[exynos4210_get_irq(11, 0)],
s->irq_table[exynos4210_get_irq(11, 1)],
s->irq_table[exynos4210_get_irq(11, 2)],
NULL);
sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
s->irq_table[exynos4210_get_irq(28, 3)]);
return s;
} | {
"code": [],
"line_no": []
} | Exynos4210State *FUNC_0(MemoryRegion *system_mem,
unsigned long ram_size)
{
int VAR_0, VAR_1;
Exynos4210State *s = g_new(Exynos4210State, 1);
qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];
unsigned long VAR_2;
DeviceState *dev;
SysBusDevice *busdev;
ObjectClass *cpu_oc;
cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, "cortex-a9");
assert(cpu_oc);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {
Object *cpuobj = object_new(object_class_get_name(cpu_oc));
if (object_property_find(cpuobj, "has_el3", NULL)) {
object_property_set_bool(cpuobj, false, "has_el3", &error_fatal);
}
s->cpu[VAR_1] = ARM_CPU(cpuobj);
object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,
"reset-cbar", &error_abort);
object_property_set_bool(cpuobj, true, "realized", &error_fatal);
}
s->irq_table = exynos4210_init_irq(&s->irqs);
for (VAR_0 = 0; VAR_0 < EXYNOS4210_NCPUS; VAR_0++) {
dev = qdev_create(NULL, "exynos4210.irq_gate");
qdev_prop_set_uint32(dev, "n_in", EXYNOS4210_IRQ_GATE_NINPUTS);
qdev_init_nofail(dev);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_IRQ_GATE_NINPUTS; VAR_1++) {
gate_irq[VAR_0][VAR_1] = qdev_get_gpio_in(dev, VAR_1);
}
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0,
qdev_get_gpio_in(DEVICE(s->cpu[VAR_0]), ARM_CPU_IRQ));
}
dev = qdev_create(NULL, "a9mpcore_priv");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][0]);
}
for (VAR_1 = 0; VAR_1 < EXYNOS4210_INT_GIC_NIRQ; VAR_1++) {
s->irqs.int_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);
}
sysbus_create_simple("l2x0", EXYNOS4210_L2X0_BASE_ADDR, NULL);
dev = qdev_create(NULL, "exynos4210.gic");
qdev_prop_set_uint32(dev, "num-cpu", EXYNOS4210_NCPUS);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);
sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][1]);
}
for (VAR_1 = 0; VAR_1 < EXYNOS4210_EXT_GIC_NIRQ; VAR_1++) {
s->irqs.ext_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);
}
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, s->irqs.int_gic_irq[VAR_1]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);
sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);
dev = qdev_create(NULL, "exynos4210.combiner");
qdev_prop_set_uint32(dev, "external", 1);
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1, s->irqs.ext_gic_irq[VAR_1]);
}
exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);
sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);
exynos4210_init_board_irqs(&s->irqs);
memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,
NULL, "exynos4210.chipid", sizeof(chipid_and_omr));
memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,
&s->chipid_mem);
memory_region_init_ram(&s->irom_mem, NULL, "exynos4210.irom",
EXYNOS4210_IROM_SIZE, &error_fatal);
vmstate_register_ram_global(&s->irom_mem);
memory_region_set_readonly(&s->irom_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,
&s->irom_mem);
memory_region_init_alias(&s->irom_alias_mem, NULL, "exynos4210.irom_alias",
&s->irom_mem,
0,
EXYNOS4210_IROM_SIZE);
memory_region_set_readonly(&s->irom_alias_mem, true);
memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,
&s->irom_alias_mem);
memory_region_init_ram(&s->iram_mem, NULL, "exynos4210.iram",
EXYNOS4210_IRAM_SIZE, &error_fatal);
vmstate_register_ram_global(&s->iram_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,
&s->iram_mem);
VAR_2 = ram_size;
if (VAR_2 > EXYNOS4210_DRAM_MAX_SIZE) {
memory_region_init_ram(&s->dram1_mem, NULL, "exynos4210.dram1",
VAR_2 - EXYNOS4210_DRAM_MAX_SIZE, &error_fatal);
vmstate_register_ram_global(&s->dram1_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,
&s->dram1_mem);
VAR_2 = EXYNOS4210_DRAM_MAX_SIZE;
}
memory_region_init_ram(&s->dram0_mem, NULL, "exynos4210.dram0", VAR_2,
&error_fatal);
vmstate_register_ram_global(&s->dram0_mem);
memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,
&s->dram0_mem);
sysbus_create_simple("exynos4210.pmu", EXYNOS4210_PMU_BASE_ADDR, NULL);
sysbus_create_varargs("exynos4210.pwm", EXYNOS4210_PWM_BASE_ADDR,
s->irq_table[exynos4210_get_irq(22, 0)],
s->irq_table[exynos4210_get_irq(22, 1)],
s->irq_table[exynos4210_get_irq(22, 2)],
s->irq_table[exynos4210_get_irq(22, 3)],
s->irq_table[exynos4210_get_irq(22, 4)],
NULL);
sysbus_create_varargs("exynos4210.rtc", EXYNOS4210_RTC_BASE_ADDR,
s->irq_table[exynos4210_get_irq(23, 0)],
s->irq_table[exynos4210_get_irq(23, 1)],
NULL);
dev = qdev_create(NULL, "exynos4210.mct");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {
sysbus_connect_irq(busdev, VAR_1,
s->irq_table[exynos4210_get_irq(1, 4 + VAR_1)]);
}
sysbus_connect_irq(busdev, 4,
s->irq_table[exynos4210_get_irq(51, 0)]);
sysbus_connect_irq(busdev, 5,
s->irq_table[exynos4210_get_irq(35, 3)]);
sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);
for (VAR_1 = 0; VAR_1 < EXYNOS4210_I2C_NUMBER; VAR_1++) {
uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * VAR_1;
qemu_irq i2c_irq;
if (VAR_1 < 8) {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, VAR_1)];
} else {
i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];
}
dev = qdev_create(NULL, "exynos4210.i2c");
qdev_init_nofail(dev);
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, i2c_irq);
sysbus_mmio_map(busdev, 0, addr);
s->i2c_if[VAR_1] = (I2CBus *)qdev_get_child_bus(dev, "i2c");
}
exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,
EXYNOS4210_UART0_FIFO_SIZE, 0, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);
exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,
EXYNOS4210_UART1_FIFO_SIZE, 1, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);
exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,
EXYNOS4210_UART2_FIFO_SIZE, 2, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);
exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,
EXYNOS4210_UART3_FIFO_SIZE, 3, NULL,
s->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);
sysbus_create_varargs("exynos4210.fimd", EXYNOS4210_FIMD0_BASE_ADDR,
s->irq_table[exynos4210_get_irq(11, 0)],
s->irq_table[exynos4210_get_irq(11, 1)],
s->irq_table[exynos4210_get_irq(11, 2)],
NULL);
sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,
s->irq_table[exynos4210_get_irq(28, 3)]);
return s;
} | [
"Exynos4210State *FUNC_0(MemoryRegion *system_mem,\nunsigned long ram_size)\n{",
"int VAR_0, VAR_1;",
"Exynos4210State *s = g_new(Exynos4210State, 1);",
"qemu_irq gate_irq[EXYNOS4210_NCPUS][EXYNOS4210_IRQ_GATE_NINPUTS];",
"unsigned long VAR_2;",
"DeviceState *dev;",
"SysBusDevice *busdev;",
"ObjectClass *cpu_oc;",
"cpu_oc = cpu_class_by_name(TYPE_ARM_CPU, \"cortex-a9\");",
"assert(cpu_oc);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {",
"Object *cpuobj = object_new(object_class_get_name(cpu_oc));",
"if (object_property_find(cpuobj, \"has_el3\", NULL)) {",
"object_property_set_bool(cpuobj, false, \"has_el3\", &error_fatal);",
"}",
"s->cpu[VAR_1] = ARM_CPU(cpuobj);",
"object_property_set_int(cpuobj, EXYNOS4210_SMP_PRIVATE_BASE_ADDR,\n\"reset-cbar\", &error_abort);",
"object_property_set_bool(cpuobj, true, \"realized\", &error_fatal);",
"}",
"s->irq_table = exynos4210_init_irq(&s->irqs);",
"for (VAR_0 = 0; VAR_0 < EXYNOS4210_NCPUS; VAR_0++) {",
"dev = qdev_create(NULL, \"exynos4210.irq_gate\");",
"qdev_prop_set_uint32(dev, \"n_in\", EXYNOS4210_IRQ_GATE_NINPUTS);",
"qdev_init_nofail(dev);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_IRQ_GATE_NINPUTS; VAR_1++) {",
"gate_irq[VAR_0][VAR_1] = qdev_get_gpio_in(dev, VAR_1);",
"}",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_connect_irq(busdev, 0,\nqdev_get_gpio_in(DEVICE(s->cpu[VAR_0]), ARM_CPU_IRQ));",
"}",
"dev = qdev_create(NULL, \"a9mpcore_priv\");",
"qdev_prop_set_uint32(dev, \"num-cpu\", EXYNOS4210_NCPUS);",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_SMP_PRIVATE_BASE_ADDR);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][0]);",
"}",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_INT_GIC_NIRQ; VAR_1++) {",
"s->irqs.int_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);",
"}",
"sysbus_create_simple(\"l2x0\", EXYNOS4210_L2X0_BASE_ADDR, NULL);",
"dev = qdev_create(NULL, \"exynos4210.gic\");",
"qdev_prop_set_uint32(dev, \"num-cpu\", EXYNOS4210_NCPUS);",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_GIC_CPU_BASE_ADDR);",
"sysbus_mmio_map(busdev, 1, EXYNOS4210_EXT_GIC_DIST_BASE_ADDR);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_NCPUS; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, gate_irq[VAR_1][1]);",
"}",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_EXT_GIC_NIRQ; VAR_1++) {",
"s->irqs.ext_gic_irq[VAR_1] = qdev_get_gpio_in(dev, VAR_1);",
"}",
"dev = qdev_create(NULL, \"exynos4210.combiner\");",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, s->irqs.int_gic_irq[VAR_1]);",
"}",
"exynos4210_combiner_get_gpioin(&s->irqs, dev, 0);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_INT_COMBINER_BASE_ADDR);",
"dev = qdev_create(NULL, \"exynos4210.combiner\");",
"qdev_prop_set_uint32(dev, \"external\", 1);",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_MAX_INT_COMBINER_OUT_IRQ; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1, s->irqs.ext_gic_irq[VAR_1]);",
"}",
"exynos4210_combiner_get_gpioin(&s->irqs, dev, 1);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_EXT_COMBINER_BASE_ADDR);",
"exynos4210_init_board_irqs(&s->irqs);",
"memory_region_init_io(&s->chipid_mem, NULL, &exynos4210_chipid_and_omr_ops,\nNULL, \"exynos4210.chipid\", sizeof(chipid_and_omr));",
"memory_region_add_subregion(system_mem, EXYNOS4210_CHIPID_ADDR,\n&s->chipid_mem);",
"memory_region_init_ram(&s->irom_mem, NULL, \"exynos4210.irom\",\nEXYNOS4210_IROM_SIZE, &error_fatal);",
"vmstate_register_ram_global(&s->irom_mem);",
"memory_region_set_readonly(&s->irom_mem, true);",
"memory_region_add_subregion(system_mem, EXYNOS4210_IROM_BASE_ADDR,\n&s->irom_mem);",
"memory_region_init_alias(&s->irom_alias_mem, NULL, \"exynos4210.irom_alias\",\n&s->irom_mem,\n0,\nEXYNOS4210_IROM_SIZE);",
"memory_region_set_readonly(&s->irom_alias_mem, true);",
"memory_region_add_subregion(system_mem, EXYNOS4210_IROM_MIRROR_BASE_ADDR,\n&s->irom_alias_mem);",
"memory_region_init_ram(&s->iram_mem, NULL, \"exynos4210.iram\",\nEXYNOS4210_IRAM_SIZE, &error_fatal);",
"vmstate_register_ram_global(&s->iram_mem);",
"memory_region_add_subregion(system_mem, EXYNOS4210_IRAM_BASE_ADDR,\n&s->iram_mem);",
"VAR_2 = ram_size;",
"if (VAR_2 > EXYNOS4210_DRAM_MAX_SIZE) {",
"memory_region_init_ram(&s->dram1_mem, NULL, \"exynos4210.dram1\",\nVAR_2 - EXYNOS4210_DRAM_MAX_SIZE, &error_fatal);",
"vmstate_register_ram_global(&s->dram1_mem);",
"memory_region_add_subregion(system_mem, EXYNOS4210_DRAM1_BASE_ADDR,\n&s->dram1_mem);",
"VAR_2 = EXYNOS4210_DRAM_MAX_SIZE;",
"}",
"memory_region_init_ram(&s->dram0_mem, NULL, \"exynos4210.dram0\", VAR_2,\n&error_fatal);",
"vmstate_register_ram_global(&s->dram0_mem);",
"memory_region_add_subregion(system_mem, EXYNOS4210_DRAM0_BASE_ADDR,\n&s->dram0_mem);",
"sysbus_create_simple(\"exynos4210.pmu\", EXYNOS4210_PMU_BASE_ADDR, NULL);",
"sysbus_create_varargs(\"exynos4210.pwm\", EXYNOS4210_PWM_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(22, 0)],\ns->irq_table[exynos4210_get_irq(22, 1)],\ns->irq_table[exynos4210_get_irq(22, 2)],\ns->irq_table[exynos4210_get_irq(22, 3)],\ns->irq_table[exynos4210_get_irq(22, 4)],\nNULL);",
"sysbus_create_varargs(\"exynos4210.rtc\", EXYNOS4210_RTC_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(23, 0)],\ns->irq_table[exynos4210_get_irq(23, 1)],\nNULL);",
"dev = qdev_create(NULL, \"exynos4210.mct\");",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {",
"sysbus_connect_irq(busdev, VAR_1,\ns->irq_table[exynos4210_get_irq(1, 4 + VAR_1)]);",
"}",
"sysbus_connect_irq(busdev, 4,\ns->irq_table[exynos4210_get_irq(51, 0)]);",
"sysbus_connect_irq(busdev, 5,\ns->irq_table[exynos4210_get_irq(35, 3)]);",
"sysbus_mmio_map(busdev, 0, EXYNOS4210_MCT_BASE_ADDR);",
"for (VAR_1 = 0; VAR_1 < EXYNOS4210_I2C_NUMBER; VAR_1++) {",
"uint32_t addr = EXYNOS4210_I2C_BASE_ADDR + EXYNOS4210_I2C_SHIFT * VAR_1;",
"qemu_irq i2c_irq;",
"if (VAR_1 < 8) {",
"i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_I2C_INTG, VAR_1)];",
"} else {",
"i2c_irq = s->irq_table[exynos4210_get_irq(EXYNOS4210_HDMI_INTG, 1)];",
"}",
"dev = qdev_create(NULL, \"exynos4210.i2c\");",
"qdev_init_nofail(dev);",
"busdev = SYS_BUS_DEVICE(dev);",
"sysbus_connect_irq(busdev, 0, i2c_irq);",
"sysbus_mmio_map(busdev, 0, addr);",
"s->i2c_if[VAR_1] = (I2CBus *)qdev_get_child_bus(dev, \"i2c\");",
"}",
"exynos4210_uart_create(EXYNOS4210_UART0_BASE_ADDR,\nEXYNOS4210_UART0_FIFO_SIZE, 0, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 0)]);",
"exynos4210_uart_create(EXYNOS4210_UART1_BASE_ADDR,\nEXYNOS4210_UART1_FIFO_SIZE, 1, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 1)]);",
"exynos4210_uart_create(EXYNOS4210_UART2_BASE_ADDR,\nEXYNOS4210_UART2_FIFO_SIZE, 2, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 2)]);",
"exynos4210_uart_create(EXYNOS4210_UART3_BASE_ADDR,\nEXYNOS4210_UART3_FIFO_SIZE, 3, NULL,\ns->irq_table[exynos4210_get_irq(EXYNOS4210_UART_INT_GRP, 3)]);",
"sysbus_create_varargs(\"exynos4210.fimd\", EXYNOS4210_FIMD0_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(11, 0)],\ns->irq_table[exynos4210_get_irq(11, 1)],\ns->irq_table[exynos4210_get_irq(11, 2)],\nNULL);",
"sysbus_create_simple(TYPE_EXYNOS4210_EHCI, EXYNOS4210_EHCI_BASE_ADDR,\ns->irq_table[exynos4210_get_irq(28, 3)]);",
"return s;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22,
23
],
[
24
],
[
25
],
[
27
],
[
29
],
[
30
],
[
31
],
[
32
],
[
34
],
[
35
],
[
36
],
[
37
],
[
39,
40
],
[
41
],
[
43
],
[
44
],
[
45
],
[
46
],
[
47
],
[
48
],
[
49
],
[
50
],
[
51
],
[
52
],
[
53
],
[
55
],
[
57
],
[
58
],
[
59
],
[
60
],
[
62
],
[
64
],
[
65
],
[
66
],
[
67
],
[
68
],
[
69
],
[
70
],
[
72
],
[
73
],
[
74
],
[
75
],
[
76
],
[
77
],
[
78
],
[
79
],
[
81
],
[
82
],
[
83
],
[
84
],
[
85
],
[
86
],
[
87
],
[
88
],
[
89
],
[
91
],
[
94,
95
],
[
96,
97
],
[
99,
100
],
[
101
],
[
102
],
[
103,
104
],
[
106,
107,
108,
109
],
[
110
],
[
111,
112
],
[
114,
115
],
[
116
],
[
117,
118
],
[
120
],
[
121
],
[
122,
123
],
[
124
],
[
125,
126
],
[
127
],
[
128
],
[
129,
130
],
[
131
],
[
132,
133
],
[
138
],
[
140,
141,
142,
143,
144,
145,
146
],
[
148,
149,
150,
151
],
[
153
],
[
154
],
[
155
],
[
156
],
[
158,
159
],
[
160
],
[
162,
163
],
[
164,
165
],
[
166
],
[
168
],
[
169
],
[
170
],
[
171
],
[
172
],
[
173
],
[
174
],
[
175
],
[
176
],
[
177
],
[
178
],
[
179
],
[
180
],
[
181
],
[
182
],
[
184,
185,
186
],
[
187,
188,
189
],
[
190,
191,
192
],
[
193,
194,
195
],
[
197,
198,
199,
200,
201
],
[
202,
203
],
[
204
],
[
205
]
] |
21,591 | static void *clone_func(void *arg)
{
new_thread_info *info = arg;
CPUArchState *env;
CPUState *cpu;
TaskState *ts;
rcu_register_thread();
env = info->env;
cpu = ENV_GET_CPU(env);
thread_cpu = cpu;
ts = (TaskState *)cpu->opaque;
info->tid = gettid();
cpu->host_tid = info->tid;
task_settid(ts);
if (info->child_tidptr)
put_user_u32(info->tid, info->child_tidptr);
if (info->parent_tidptr)
put_user_u32(info->tid, info->parent_tidptr);
/* Enable signals. */
sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
/* Signal to the parent that we're ready. */
pthread_mutex_lock(&info->mutex);
pthread_cond_broadcast(&info->cond);
pthread_mutex_unlock(&info->mutex);
/* Wait until the parent has finshed initializing the tls state. */
pthread_mutex_lock(&clone_lock);
pthread_mutex_unlock(&clone_lock);
cpu_loop(env);
/* never exits */
return NULL;
}
| true | qemu | bd88c780e6a17188f7fd676f3a056e5db21500e0 | static void *clone_func(void *arg)
{
new_thread_info *info = arg;
CPUArchState *env;
CPUState *cpu;
TaskState *ts;
rcu_register_thread();
env = info->env;
cpu = ENV_GET_CPU(env);
thread_cpu = cpu;
ts = (TaskState *)cpu->opaque;
info->tid = gettid();
cpu->host_tid = info->tid;
task_settid(ts);
if (info->child_tidptr)
put_user_u32(info->tid, info->child_tidptr);
if (info->parent_tidptr)
put_user_u32(info->tid, info->parent_tidptr);
sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
pthread_mutex_lock(&info->mutex);
pthread_cond_broadcast(&info->cond);
pthread_mutex_unlock(&info->mutex);
pthread_mutex_lock(&clone_lock);
pthread_mutex_unlock(&clone_lock);
cpu_loop(env);
return NULL;
}
| {
"code": [
" cpu->host_tid = info->tid;"
],
"line_no": [
27
]
} | static void *FUNC_0(void *VAR_0)
{
new_thread_info *info = VAR_0;
CPUArchState *env;
CPUState *cpu;
TaskState *ts;
rcu_register_thread();
env = info->env;
cpu = ENV_GET_CPU(env);
thread_cpu = cpu;
ts = (TaskState *)cpu->opaque;
info->tid = gettid();
cpu->host_tid = info->tid;
task_settid(ts);
if (info->child_tidptr)
put_user_u32(info->tid, info->child_tidptr);
if (info->parent_tidptr)
put_user_u32(info->tid, info->parent_tidptr);
sigprocmask(SIG_SETMASK, &info->sigmask, NULL);
pthread_mutex_lock(&info->mutex);
pthread_cond_broadcast(&info->cond);
pthread_mutex_unlock(&info->mutex);
pthread_mutex_lock(&clone_lock);
pthread_mutex_unlock(&clone_lock);
cpu_loop(env);
return NULL;
}
| [
"static void *FUNC_0(void *VAR_0)\n{",
"new_thread_info *info = VAR_0;",
"CPUArchState *env;",
"CPUState *cpu;",
"TaskState *ts;",
"rcu_register_thread();",
"env = info->env;",
"cpu = ENV_GET_CPU(env);",
"thread_cpu = cpu;",
"ts = (TaskState *)cpu->opaque;",
"info->tid = gettid();",
"cpu->host_tid = info->tid;",
"task_settid(ts);",
"if (info->child_tidptr)\nput_user_u32(info->tid, info->child_tidptr);",
"if (info->parent_tidptr)\nput_user_u32(info->tid, info->parent_tidptr);",
"sigprocmask(SIG_SETMASK, &info->sigmask, NULL);",
"pthread_mutex_lock(&info->mutex);",
"pthread_cond_broadcast(&info->cond);",
"pthread_mutex_unlock(&info->mutex);",
"pthread_mutex_lock(&clone_lock);",
"pthread_mutex_unlock(&clone_lock);",
"cpu_loop(env);",
"return NULL;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31,
33
],
[
35,
37
],
[
41
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
]
] |
21,592 | static inline void RENAME(yuv2rgb32_1)(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, enum PixelFormat dstFormat,
int flags, int y)
{
x86_reg uv_off = c->uv_off << 1;
const uint16_t *buf1= buf0; //FIXME needed for RGB1/BGR1
if (uvalpha < 2048) { // note this is not correct (shifts chrominance by 0.5 pixels) but it is a bit faster
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5, %6)
YSCALEYUV2RGB1_ALPHA(%%REGBP)
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (abuf0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5, %6)
"pcmpeqd %%mm7, %%mm7 \n\t"
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
}
} else {
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5, %6)
YSCALEYUV2RGB1_ALPHA(%%REGBP)
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (abuf0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5, %6)
"pcmpeqd %%mm7, %%mm7 \n\t"
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
}
}
}
| true | FFmpeg | 009f829dde811af654af7110326aea3a72c05d5e | static inline void RENAME(yuv2rgb32_1)(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, enum PixelFormat dstFormat,
int flags, int y)
{
x86_reg uv_off = c->uv_off << 1;
const uint16_t *buf1= buf0;
if (uvalpha < 2048) {
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5, %6)
YSCALEYUV2RGB1_ALPHA(%%REGBP)
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (abuf0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5, %6)
"pcmpeqd %%mm7, %%mm7 \n\t"
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
}
} else {
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5, %6)
YSCALEYUV2RGB1_ALPHA(%%REGBP)
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (abuf0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5, %6)
"pcmpeqd %%mm7, %%mm7 \n\t"
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (buf1), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
}
}
}
| {
"code": [
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" YSCALEYUV2RGB1(%%REGBP, %5, %6)",
" \"a\" (&c->redDither), \"m\"(uv_off)",
" YSCALEYUV2RGB1(%%REGBP, %5, %6)",
" \"a\" (&c->redDither), \"m\"(uv_off)",
" YSCALEYUV2RGB1b(%%REGBP, %5, %6)",
" \"a\" (&c->redDither), \"m\"(uv_off)",
" YSCALEYUV2RGB1b(%%REGBP, %5, %6)",
" \"a\" (&c->redDither), \"m\"(uv_off)",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;",
" x86_reg uv_off = c->uv_off << 1;"
],
"line_no": [
15,
15,
15,
15,
15,
15,
33,
45,
33,
45,
89,
45,
89,
45,
15,
15,
15,
15
]
} | static inline void FUNC_0(yuv2rgb32_1)(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, enum PixelFormat dstFormat,
int flags, int y)
{
x86_reg uv_off = c->uv_off << 1;
const uint16_t *VAR_0= buf0;
if (uvalpha < 2048) {
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5, %6)
YSCALEYUV2RGB1_ALPHA(%%REGBP)
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (abuf0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1(%%REGBP, %5, %6)
"pcmpeqd %%mm7, %%mm7 \n\t"
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (VAR_0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
}
} else {
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5, %6)
YSCALEYUV2RGB1_ALPHA(%%REGBP)
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (abuf0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
} else {
__asm__ volatile(
"mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
"mov %4, %%"REG_b" \n\t"
"push %%"REG_BP" \n\t"
YSCALEYUV2RGB1b(%%REGBP, %5, %6)
"pcmpeqd %%mm7, %%mm7 \n\t"
WRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (VAR_0), "S" (ubuf0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither), "m"(uv_off)
);
}
}
}
| [
"static inline void FUNC_0(yuv2rgb32_1)(SwsContext *c, const uint16_t *buf0,\nconst uint16_t *ubuf0, const uint16_t *ubuf1,\nconst uint16_t *vbuf0, const uint16_t *vbuf1,\nconst uint16_t *abuf0, uint8_t *dest,\nint dstW, int uvalpha, enum PixelFormat dstFormat,\nint flags, int y)\n{",
"x86_reg uv_off = c->uv_off << 1;",
"const uint16_t *VAR_0= buf0;",
"if (uvalpha < 2048) {",
"if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {",
"__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1(%%REGBP, %5, %6)\nYSCALEYUV2RGB1_ALPHA(%%REGBP)\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (abuf0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither), \"m\"(uv_off)\n);",
"} else {",
"__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1(%%REGBP, %5, %6)\n\"pcmpeqd %%mm7, %%mm7 \\n\\t\"\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither), \"m\"(uv_off)\n);",
"}",
"} else {",
"if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {",
"__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1b(%%REGBP, %5, %6)\nYSCALEYUV2RGB1_ALPHA(%%REGBP)\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (abuf0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither), \"m\"(uv_off)\n);",
"} else {",
"__asm__ volatile(\n\"mov %%\"REG_b\", \"ESP_OFFSET\"(%5) \\n\\t\"\n\"mov %4, %%\"REG_b\" \\n\\t\"\n\"push %%\"REG_BP\" \\n\\t\"\nYSCALEYUV2RGB1b(%%REGBP, %5, %6)\n\"pcmpeqd %%mm7, %%mm7 \\n\\t\"\nWRITEBGR32(%%REGb, 8280(%5), %%REGBP, %%mm2, %%mm4, %%mm5, %%mm7, %%mm0, %%mm1, %%mm3, %%mm6)\n\"pop %%\"REG_BP\" \\n\\t\"\n\"mov \"ESP_OFFSET\"(%5), %%\"REG_b\" \\n\\t\"\n:: \"c\" (buf0), \"d\" (VAR_0), \"S\" (ubuf0), \"D\" (ubuf1), \"m\" (dest),\n\"a\" (&c->redDither), \"m\"(uv_off)\n);",
"}",
"}",
"}"
] | [
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25,
27,
29,
31,
33,
35,
37,
39,
41,
43,
45,
47
],
[
49
],
[
51,
53,
55,
57,
59,
61,
63,
65,
67,
69,
71,
73
],
[
75
],
[
77
],
[
79
],
[
81,
83,
85,
87,
89,
91,
93,
95,
97,
99,
101,
103
],
[
105
],
[
107,
109,
111,
113,
115,
117,
119,
121,
123,
125,
127,
129
],
[
131
],
[
133
],
[
135
]
] |
21,593 | QInt *qobject_to_qint(const QObject *obj)
{
if (qobject_type(obj) != QTYPE_QINT)
return NULL;
return container_of(obj, QInt, base);
}
| true | qemu | fcf73f66a67f5e58c18216f8c8651e38cf4d90af | QInt *qobject_to_qint(const QObject *obj)
{
if (qobject_type(obj) != QTYPE_QINT)
return NULL;
return container_of(obj, QInt, base);
}
| {
"code": [
" if (qobject_type(obj) != QTYPE_QINT)"
],
"line_no": [
5
]
} | QInt *FUNC_0(const QObject *obj)
{
if (qobject_type(obj) != QTYPE_QINT)
return NULL;
return container_of(obj, QInt, base);
}
| [
"QInt *FUNC_0(const QObject *obj)\n{",
"if (qobject_type(obj) != QTYPE_QINT)\nreturn NULL;",
"return container_of(obj, QInt, base);",
"}"
] | [
0,
1,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
11
],
[
13
]
] |
21,594 | static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
{
int compno;
int x;
int y;
int *image_line;
int frame_index;
const int numcomps = image->numcomps;
for (compno = 0; compno < numcomps; ++compno) {
if (image->comps[compno].w > frame->linesize[0] / numcomps) {
av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
return 0;
}
}
for (compno = 0; compno < numcomps; ++compno) {
for (y = 0; y < avctx->height; ++y) {
image_line = image->comps[compno].data + y * image->comps[compno].w;
frame_index = y * frame->linesize[0] + compno;
for (x = 0; x < avctx->width; ++x) {
image_line[x] = frame->data[0][frame_index];
frame_index += numcomps;
}
for (; x < image->comps[compno].w; ++x) {
image_line[x] = image_line[x - 1];
}
}
for (; y < image->comps[compno].h; ++y) {
image_line = image->comps[compno].data + y * image->comps[compno].w;
for (x = 0; x < image->comps[compno].w; ++x) {
image_line[x] = image_line[x - image->comps[compno].w];
}
}
}
return 1;
}
| true | FFmpeg | 56706ac0d5723cb549fec2602e798ab1bf6004cd | static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
{
int compno;
int x;
int y;
int *image_line;
int frame_index;
const int numcomps = image->numcomps;
for (compno = 0; compno < numcomps; ++compno) {
if (image->comps[compno].w > frame->linesize[0] / numcomps) {
av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
return 0;
}
}
for (compno = 0; compno < numcomps; ++compno) {
for (y = 0; y < avctx->height; ++y) {
image_line = image->comps[compno].data + y * image->comps[compno].w;
frame_index = y * frame->linesize[0] + compno;
for (x = 0; x < avctx->width; ++x) {
image_line[x] = frame->data[0][frame_index];
frame_index += numcomps;
}
for (; x < image->comps[compno].w; ++x) {
image_line[x] = image_line[x - 1];
}
}
for (; y < image->comps[compno].h; ++y) {
image_line = image->comps[compno].data + y * image->comps[compno].w;
for (x = 0; x < image->comps[compno].w; ++x) {
image_line[x] = image_line[x - image->comps[compno].w];
}
}
}
return 1;
}
| {
"code": [
" image_line[x] = image_line[x - image->comps[compno].w];",
" image_line[x] = image_line[x - image->comps[compno].w];",
" image_line[x] = image_line[x - image->comps[compno].w];",
" image_line[x] = image_line[x - image->comps[compno].w];",
" image_line[x] = image_line[x - image->comps[compno].w];"
],
"line_no": [
63,
63,
63,
63,
63
]
} | static int FUNC_0(AVCodecContext *VAR_0, const AVFrame *VAR_1, opj_image_t *VAR_2)
{
int VAR_3;
int VAR_4;
int VAR_5;
int *VAR_6;
int VAR_7;
const int VAR_8 = VAR_2->VAR_8;
for (VAR_3 = 0; VAR_3 < VAR_8; ++VAR_3) {
if (VAR_2->comps[VAR_3].w > VAR_1->linesize[0] / VAR_8) {
av_log(VAR_0, AV_LOG_ERROR, "Error: VAR_1's linesize is too small for the VAR_2\n");
return 0;
}
}
for (VAR_3 = 0; VAR_3 < VAR_8; ++VAR_3) {
for (VAR_5 = 0; VAR_5 < VAR_0->height; ++VAR_5) {
VAR_6 = VAR_2->comps[VAR_3].data + VAR_5 * VAR_2->comps[VAR_3].w;
VAR_7 = VAR_5 * VAR_1->linesize[0] + VAR_3;
for (VAR_4 = 0; VAR_4 < VAR_0->width; ++VAR_4) {
VAR_6[VAR_4] = VAR_1->data[0][VAR_7];
VAR_7 += VAR_8;
}
for (; VAR_4 < VAR_2->comps[VAR_3].w; ++VAR_4) {
VAR_6[VAR_4] = VAR_6[VAR_4 - 1];
}
}
for (; VAR_5 < VAR_2->comps[VAR_3].h; ++VAR_5) {
VAR_6 = VAR_2->comps[VAR_3].data + VAR_5 * VAR_2->comps[VAR_3].w;
for (VAR_4 = 0; VAR_4 < VAR_2->comps[VAR_3].w; ++VAR_4) {
VAR_6[VAR_4] = VAR_6[VAR_4 - VAR_2->comps[VAR_3].w];
}
}
}
return 1;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, const AVFrame *VAR_1, opj_image_t *VAR_2)\n{",
"int VAR_3;",
"int VAR_4;",
"int VAR_5;",
"int *VAR_6;",
"int VAR_7;",
"const int VAR_8 = VAR_2->VAR_8;",
"for (VAR_3 = 0; VAR_3 < VAR_8; ++VAR_3) {",
"if (VAR_2->comps[VAR_3].w > VAR_1->linesize[0] / VAR_8) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Error: VAR_1's linesize is too small for the VAR_2\\n\");",
"return 0;",
"}",
"}",
"for (VAR_3 = 0; VAR_3 < VAR_8; ++VAR_3) {",
"for (VAR_5 = 0; VAR_5 < VAR_0->height; ++VAR_5) {",
"VAR_6 = VAR_2->comps[VAR_3].data + VAR_5 * VAR_2->comps[VAR_3].w;",
"VAR_7 = VAR_5 * VAR_1->linesize[0] + VAR_3;",
"for (VAR_4 = 0; VAR_4 < VAR_0->width; ++VAR_4) {",
"VAR_6[VAR_4] = VAR_1->data[0][VAR_7];",
"VAR_7 += VAR_8;",
"}",
"for (; VAR_4 < VAR_2->comps[VAR_3].w; ++VAR_4) {",
"VAR_6[VAR_4] = VAR_6[VAR_4 - 1];",
"}",
"}",
"for (; VAR_5 < VAR_2->comps[VAR_3].h; ++VAR_5) {",
"VAR_6 = VAR_2->comps[VAR_3].data + VAR_5 * VAR_2->comps[VAR_3].w;",
"for (VAR_4 = 0; VAR_4 < VAR_2->comps[VAR_3].w; ++VAR_4) {",
"VAR_6[VAR_4] = VAR_6[VAR_4 - VAR_2->comps[VAR_3].w];",
"}",
"}",
"}",
"return 1;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
]
] |
21,595 | static int spapr_msicfg_find(sPAPRPHBState *phb, uint32_t config_addr,
bool alloc_new)
{
int i;
for (i = 0; i < SPAPR_MSIX_MAX_DEVS; ++i) {
if (!phb->msi_table[i].nvec) {
break;
}
if (phb->msi_table[i].config_addr == config_addr) {
return i;
}
}
if ((i < SPAPR_MSIX_MAX_DEVS) && alloc_new) {
trace_spapr_pci_msi("Allocating new MSI config", i, config_addr);
return i;
}
return -1;
}
| true | qemu | 9a321e92343891e30f6fe8bfaad40454ae358bfb | static int spapr_msicfg_find(sPAPRPHBState *phb, uint32_t config_addr,
bool alloc_new)
{
int i;
for (i = 0; i < SPAPR_MSIX_MAX_DEVS; ++i) {
if (!phb->msi_table[i].nvec) {
break;
}
if (phb->msi_table[i].config_addr == config_addr) {
return i;
}
}
if ((i < SPAPR_MSIX_MAX_DEVS) && alloc_new) {
trace_spapr_pci_msi("Allocating new MSI config", i, config_addr);
return i;
}
return -1;
}
| {
"code": [
"static int spapr_msicfg_find(sPAPRPHBState *phb, uint32_t config_addr,",
" bool alloc_new)",
" int i;",
" for (i = 0; i < SPAPR_MSIX_MAX_DEVS; ++i) {",
" if (!phb->msi_table[i].nvec) {",
" break;",
" if (phb->msi_table[i].config_addr == config_addr) {",
" return i;",
" if ((i < SPAPR_MSIX_MAX_DEVS) && alloc_new) {",
" trace_spapr_pci_msi(\"Allocating new MSI config\", i, config_addr);",
" return i;",
" return -1;"
],
"line_no": [
1,
3,
7,
11,
13,
15,
19,
21,
27,
29,
31,
37
]
} | static int FUNC_0(sPAPRPHBState *VAR_0, uint32_t VAR_1,
bool VAR_2)
{
int VAR_3;
for (VAR_3 = 0; VAR_3 < SPAPR_MSIX_MAX_DEVS; ++VAR_3) {
if (!VAR_0->msi_table[VAR_3].nvec) {
break;
}
if (VAR_0->msi_table[VAR_3].VAR_1 == VAR_1) {
return VAR_3;
}
}
if ((VAR_3 < SPAPR_MSIX_MAX_DEVS) && VAR_2) {
trace_spapr_pci_msi("Allocating new MSI config", VAR_3, VAR_1);
return VAR_3;
}
return -1;
}
| [
"static int FUNC_0(sPAPRPHBState *VAR_0, uint32_t VAR_1,\nbool VAR_2)\n{",
"int VAR_3;",
"for (VAR_3 = 0; VAR_3 < SPAPR_MSIX_MAX_DEVS; ++VAR_3) {",
"if (!VAR_0->msi_table[VAR_3].nvec) {",
"break;",
"}",
"if (VAR_0->msi_table[VAR_3].VAR_1 == VAR_1) {",
"return VAR_3;",
"}",
"}",
"if ((VAR_3 < SPAPR_MSIX_MAX_DEVS) && VAR_2) {",
"trace_spapr_pci_msi(\"Allocating new MSI config\", VAR_3, VAR_1);",
"return VAR_3;",
"}",
"return -1;",
"}"
] | [
1,
1,
1,
1,
1,
0,
1,
1,
0,
0,
1,
1,
1,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
]
] |
21,596 | static void fdctrl_connect_drives(FDCtrl *fdctrl)
{
unsigned int i;
FDrive *drive;
for (i = 0; i < MAX_FD; i++) {
drive = &fdctrl->drives[i];
fd_init(drive);
fd_revalidate(drive);
if (drive->bs) {
bdrv_set_removable(drive->bs, 1);
}
}
}
| true | qemu | b47b35250fbfa062aedf6ab6e5faab84c4a76f4f | static void fdctrl_connect_drives(FDCtrl *fdctrl)
{
unsigned int i;
FDrive *drive;
for (i = 0; i < MAX_FD; i++) {
drive = &fdctrl->drives[i];
fd_init(drive);
fd_revalidate(drive);
if (drive->bs) {
bdrv_set_removable(drive->bs, 1);
}
}
}
| {
"code": [
"static void fdctrl_connect_drives(FDCtrl *fdctrl)"
],
"line_no": [
1
]
} | static void FUNC_0(FDCtrl *VAR_0)
{
unsigned int VAR_1;
FDrive *drive;
for (VAR_1 = 0; VAR_1 < MAX_FD; VAR_1++) {
drive = &VAR_0->drives[VAR_1];
fd_init(drive);
fd_revalidate(drive);
if (drive->bs) {
bdrv_set_removable(drive->bs, 1);
}
}
}
| [
"static void FUNC_0(FDCtrl *VAR_0)\n{",
"unsigned int VAR_1;",
"FDrive *drive;",
"for (VAR_1 = 0; VAR_1 < MAX_FD; VAR_1++) {",
"drive = &VAR_0->drives[VAR_1];",
"fd_init(drive);",
"fd_revalidate(drive);",
"if (drive->bs) {",
"bdrv_set_removable(drive->bs, 1);",
"}",
"}",
"}"
] | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
]
] |
21,597 | static av_cold int decode_init(AVCodecContext *avctx)
{
ASV1Context *const a = avctx->priv_data;
const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
int i;
if (avctx->extradata_size < 1) {
av_log(avctx, AV_LOG_ERROR, "No extradata provided\n");
return AVERROR_INVALIDDATA;
}
ff_asv_common_init(avctx);
ff_blockdsp_init(&a->bdsp, avctx);
ff_idctdsp_init(&a->idsp, avctx);
init_vlcs(a);
ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
a->inv_qscale = avctx->extradata[0];
if (a->inv_qscale == 0) {
av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
if (avctx->codec_id == AV_CODEC_ID_ASV1)
a->inv_qscale = 6;
else
a->inv_qscale = 10;
}
for (i = 0; i < 64; i++) {
int index = ff_asv_scantab[i];
a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
a->inv_qscale;
}
return 0;
}
| false | FFmpeg | dcc39ee10e82833ce24aa57926c00ffeb1948198 | static av_cold int decode_init(AVCodecContext *avctx)
{
ASV1Context *const a = avctx->priv_data;
const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
int i;
if (avctx->extradata_size < 1) {
av_log(avctx, AV_LOG_ERROR, "No extradata provided\n");
return AVERROR_INVALIDDATA;
}
ff_asv_common_init(avctx);
ff_blockdsp_init(&a->bdsp, avctx);
ff_idctdsp_init(&a->idsp, avctx);
init_vlcs(a);
ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
a->inv_qscale = avctx->extradata[0];
if (a->inv_qscale == 0) {
av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
if (avctx->codec_id == AV_CODEC_ID_ASV1)
a->inv_qscale = 6;
else
a->inv_qscale = 10;
}
for (i = 0; i < 64; i++) {
int index = ff_asv_scantab[i];
a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
a->inv_qscale;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
ASV1Context *const a = avctx->priv_data;
const int VAR_0 = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
int VAR_1;
if (avctx->extradata_size < 1) {
av_log(avctx, AV_LOG_ERROR, "No extradata provided\n");
return AVERROR_INVALIDDATA;
}
ff_asv_common_init(avctx);
ff_blockdsp_init(&a->bdsp, avctx);
ff_idctdsp_init(&a->idsp, avctx);
init_vlcs(a);
ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
a->inv_qscale = avctx->extradata[0];
if (a->inv_qscale == 0) {
av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
if (avctx->codec_id == AV_CODEC_ID_ASV1)
a->inv_qscale = 6;
else
a->inv_qscale = 10;
}
for (VAR_1 = 0; VAR_1 < 64; VAR_1++) {
int VAR_2 = ff_asv_scantab[VAR_1];
a->intra_matrix[VAR_1] = 64 * VAR_0 * ff_mpeg1_default_intra_matrix[VAR_2] /
a->inv_qscale;
}
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"ASV1Context *const a = avctx->priv_data;",
"const int VAR_0 = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;",
"int VAR_1;",
"if (avctx->extradata_size < 1) {",
"av_log(avctx, AV_LOG_ERROR, \"No extradata provided\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"ff_asv_common_init(avctx);",
"ff_blockdsp_init(&a->bdsp, avctx);",
"ff_idctdsp_init(&a->idsp, avctx);",
"init_vlcs(a);",
"ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);",
"avctx->pix_fmt = AV_PIX_FMT_YUV420P;",
"a->inv_qscale = avctx->extradata[0];",
"if (a->inv_qscale == 0) {",
"av_log(avctx, AV_LOG_ERROR, \"illegal qscale 0\\n\");",
"if (avctx->codec_id == AV_CODEC_ID_ASV1)\na->inv_qscale = 6;",
"else\na->inv_qscale = 10;",
"}",
"for (VAR_1 = 0; VAR_1 < 64; VAR_1++) {",
"int VAR_2 = ff_asv_scantab[VAR_1];",
"a->intra_matrix[VAR_1] = 64 * VAR_0 * ff_mpeg1_default_intra_matrix[VAR_2] /\na->inv_qscale;",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
47,
49
],
[
51
],
[
55
],
[
57
],
[
61,
63
],
[
65
],
[
69
],
[
71
]
] |
21,598 | int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
const AVFrame *reference)
{
int len, nb_components, i, h, v, predictor, point_transform;
int index, id, ret;
const int block_size = s->lossless ? 1 : 8;
int ilv, prev_shift;
if (!s->got_picture) {
av_log(s->avctx, AV_LOG_WARNING,
"Can not process SOS before SOF, skipping\n");
return -1;
}
av_assert0(s->picture_ptr->data[0]);
/* XXX: verify len field validity */
len = get_bits(&s->gb, 16);
nb_components = get_bits(&s->gb, 8);
if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
av_log(s->avctx, AV_LOG_ERROR,
"decode_sos: nb_components (%d) unsupported\n", nb_components);
return AVERROR_PATCHWELCOME;
}
if (len != 6 + 2 * nb_components) {
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
return AVERROR_INVALIDDATA;
}
for (i = 0; i < nb_components; i++) {
id = get_bits(&s->gb, 8) - 1;
av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
/* find component index */
for (index = 0; index < s->nb_components; index++)
if (id == s->component_id[index])
break;
if (index == s->nb_components) {
av_log(s->avctx, AV_LOG_ERROR,
"decode_sos: index(%d) out of components\n", index);
return AVERROR_INVALIDDATA;
}
/* Metasoft MJPEG codec has Cb and Cr swapped */
if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
&& nb_components == 3 && s->nb_components == 3 && i)
index = 3 - i;
if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
index = (i+2)%3;
if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
index = (index+2)%3;
s->comp_index[i] = index;
s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
s->h_scount[i] = s->h_count[index];
s->v_scount[i] = s->v_count[index];
s->dc_index[i] = get_bits(&s->gb, 4);
s->ac_index[i] = get_bits(&s->gb, 4);
if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
goto out_of_range;
if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table))
goto out_of_range;
}
predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
if(s->avctx->codec_tag != AV_RL32("CJPG")){
prev_shift = get_bits(&s->gb, 4); /* Ah */
point_transform = get_bits(&s->gb, 4); /* Al */
}else
prev_shift = point_transform = 0;
if (nb_components > 1) {
/* interleaved stream */
s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
} else if (!s->ls) { /* skip this for JPEG-LS */
h = s->h_max / s->h_scount[0];
v = s->v_max / s->v_scount[0];
s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
s->nb_blocks[0] = 1;
s->h_scount[0] = 1;
s->v_scount[0] = 1;
}
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
/* mjpeg-b can have padding bytes between sos and image data, skip them */
for (i = s->mjpb_skiptosod; i > 0; i--)
skip_bits(&s->gb, 8);
next_field:
for (i = 0; i < nb_components; i++)
s->last_dc[i] = 1024;
if (s->lossless) {
av_assert0(s->picture_ptr == &s->picture);
if (CONFIG_JPEGLS_DECODER && s->ls) {
// for () {
// reset_ls_coding_parameters(s, 0);
if ((ret = ff_jpegls_decode_picture(s, predictor,
point_transform, ilv)) < 0)
return ret;
} else {
if (s->rgb) {
if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
return ret;
} else {
if ((ret = ljpeg_decode_yuv_scan(s, predictor,
point_transform,
nb_components)) < 0)
return ret;
}
}
} else {
if (s->progressive && predictor) {
av_assert0(s->picture_ptr == &s->picture);
if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
ilv, prev_shift,
point_transform)) < 0)
return ret;
} else {
if ((ret = mjpeg_decode_scan(s, nb_components,
prev_shift, point_transform,
mb_bitmask, reference)) < 0)
return ret;
}
}
if (s->interlaced &&
get_bits_left(&s->gb) > 32 &&
show_bits(&s->gb, 8) == 0xFF) {
GetBitContext bak = s->gb;
align_get_bits(&bak);
if (show_bits(&bak, 16) == 0xFFD1) {
av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
s->gb = bak;
skip_bits(&s->gb, 16);
s->bottom_field ^= 1;
goto next_field;
}
}
emms_c();
return 0;
out_of_range:
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
return AVERROR_INVALIDDATA;
}
| false | FFmpeg | 94e86ae15a4328b22f6f103b9fd9b6a9ee0c676c | int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
const AVFrame *reference)
{
int len, nb_components, i, h, v, predictor, point_transform;
int index, id, ret;
const int block_size = s->lossless ? 1 : 8;
int ilv, prev_shift;
if (!s->got_picture) {
av_log(s->avctx, AV_LOG_WARNING,
"Can not process SOS before SOF, skipping\n");
return -1;
}
av_assert0(s->picture_ptr->data[0]);
len = get_bits(&s->gb, 16);
nb_components = get_bits(&s->gb, 8);
if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
av_log(s->avctx, AV_LOG_ERROR,
"decode_sos: nb_components (%d) unsupported\n", nb_components);
return AVERROR_PATCHWELCOME;
}
if (len != 6 + 2 * nb_components) {
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
return AVERROR_INVALIDDATA;
}
for (i = 0; i < nb_components; i++) {
id = get_bits(&s->gb, 8) - 1;
av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
for (index = 0; index < s->nb_components; index++)
if (id == s->component_id[index])
break;
if (index == s->nb_components) {
av_log(s->avctx, AV_LOG_ERROR,
"decode_sos: index(%d) out of components\n", index);
return AVERROR_INVALIDDATA;
}
if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
&& nb_components == 3 && s->nb_components == 3 && i)
index = 3 - i;
if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
index = (i+2)%3;
if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
index = (index+2)%3;
s->comp_index[i] = index;
s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
s->h_scount[i] = s->h_count[index];
s->v_scount[i] = s->v_count[index];
s->dc_index[i] = get_bits(&s->gb, 4);
s->ac_index[i] = get_bits(&s->gb, 4);
if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
goto out_of_range;
if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table))
goto out_of_range;
}
predictor = get_bits(&s->gb, 8);
ilv = get_bits(&s->gb, 8);
if(s->avctx->codec_tag != AV_RL32("CJPG")){
prev_shift = get_bits(&s->gb, 4);
point_transform = get_bits(&s->gb, 4);
}else
prev_shift = point_transform = 0;
if (nb_components > 1) {
s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
} else if (!s->ls) {
h = s->h_max / s->h_scount[0];
v = s->v_max / s->v_scount[0];
s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
s->nb_blocks[0] = 1;
s->h_scount[0] = 1;
s->v_scount[0] = 1;
}
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
for (i = s->mjpb_skiptosod; i > 0; i--)
skip_bits(&s->gb, 8);
next_field:
for (i = 0; i < nb_components; i++)
s->last_dc[i] = 1024;
if (s->lossless) {
av_assert0(s->picture_ptr == &s->picture);
if (CONFIG_JPEGLS_DECODER && s->ls) {
if ((ret = ff_jpegls_decode_picture(s, predictor,
point_transform, ilv)) < 0)
return ret;
} else {
if (s->rgb) {
if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
return ret;
} else {
if ((ret = ljpeg_decode_yuv_scan(s, predictor,
point_transform,
nb_components)) < 0)
return ret;
}
}
} else {
if (s->progressive && predictor) {
av_assert0(s->picture_ptr == &s->picture);
if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
ilv, prev_shift,
point_transform)) < 0)
return ret;
} else {
if ((ret = mjpeg_decode_scan(s, nb_components,
prev_shift, point_transform,
mb_bitmask, reference)) < 0)
return ret;
}
}
if (s->interlaced &&
get_bits_left(&s->gb) > 32 &&
show_bits(&s->gb, 8) == 0xFF) {
GetBitContext bak = s->gb;
align_get_bits(&bak);
if (show_bits(&bak, 16) == 0xFFD1) {
av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
s->gb = bak;
skip_bits(&s->gb, 16);
s->bottom_field ^= 1;
goto next_field;
}
}
emms_c();
return 0;
out_of_range:
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
return AVERROR_INVALIDDATA;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(MJpegDecodeContext *VAR_0, const uint8_t *VAR_1,
const AVFrame *VAR_2)
{
int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;
int VAR_10, VAR_11, VAR_12;
const int VAR_13 = VAR_0->lossless ? 1 : 8;
int VAR_14, VAR_15;
if (!VAR_0->got_picture) {
av_log(VAR_0->avctx, AV_LOG_WARNING,
"Can not process SOS before SOF, skipping\n");
return -1;
}
av_assert0(VAR_0->picture_ptr->data[0]);
VAR_3 = get_bits(&VAR_0->gb, 16);
VAR_4 = get_bits(&VAR_0->gb, 8);
if (VAR_4 == 0 || VAR_4 > MAX_COMPONENTS) {
av_log(VAR_0->avctx, AV_LOG_ERROR,
"decode_sos: VAR_4 (%d) unsupported\n", VAR_4);
return AVERROR_PATCHWELCOME;
}
if (VAR_3 != 6 + 2 * VAR_4) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "decode_sos: invalid VAR_3 (%d)\n", VAR_3);
return AVERROR_INVALIDDATA;
}
for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {
VAR_11 = get_bits(&VAR_0->gb, 8) - 1;
av_log(VAR_0->avctx, AV_LOG_DEBUG, "component: %d\n", VAR_11);
for (VAR_10 = 0; VAR_10 < VAR_0->VAR_4; VAR_10++)
if (VAR_11 == VAR_0->component_id[VAR_10])
break;
if (VAR_10 == VAR_0->VAR_4) {
av_log(VAR_0->avctx, AV_LOG_ERROR,
"decode_sos: VAR_10(%d) out of components\n", VAR_10);
return AVERROR_INVALIDDATA;
}
if (VAR_0->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
&& VAR_4 == 3 && VAR_0->VAR_4 == 3 && VAR_5)
VAR_10 = 3 - VAR_5;
if(VAR_4 == 3 && VAR_0->VAR_4 == 3 && VAR_0->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
VAR_10 = (VAR_5+2)%3;
if(VAR_4 == 1 && VAR_0->VAR_4 == 3 && VAR_0->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
VAR_10 = (VAR_10+2)%3;
VAR_0->comp_index[VAR_5] = VAR_10;
VAR_0->nb_blocks[VAR_5] = VAR_0->h_count[VAR_10] * VAR_0->v_count[VAR_10];
VAR_0->h_scount[VAR_5] = VAR_0->h_count[VAR_10];
VAR_0->v_scount[VAR_5] = VAR_0->v_count[VAR_10];
VAR_0->dc_index[VAR_5] = get_bits(&VAR_0->gb, 4);
VAR_0->ac_index[VAR_5] = get_bits(&VAR_0->gb, 4);
if (VAR_0->dc_index[VAR_5] < 0 || VAR_0->ac_index[VAR_5] < 0 ||
VAR_0->dc_index[VAR_5] >= 4 || VAR_0->ac_index[VAR_5] >= 4)
goto out_of_range;
if (!VAR_0->vlcs[0][VAR_0->dc_index[VAR_5]].table || !(VAR_0->progressive ? VAR_0->vlcs[2][VAR_0->ac_index[0]].table : VAR_0->vlcs[1][VAR_0->ac_index[VAR_5]].table))
goto out_of_range;
}
VAR_8 = get_bits(&VAR_0->gb, 8);
VAR_14 = get_bits(&VAR_0->gb, 8);
if(VAR_0->avctx->codec_tag != AV_RL32("CJPG")){
VAR_15 = get_bits(&VAR_0->gb, 4);
VAR_9 = get_bits(&VAR_0->gb, 4);
}else
VAR_15 = VAR_9 = 0;
if (VAR_4 > 1) {
VAR_0->mb_width = (VAR_0->width + VAR_0->h_max * VAR_13 - 1) / (VAR_0->h_max * VAR_13);
VAR_0->mb_height = (VAR_0->height + VAR_0->v_max * VAR_13 - 1) / (VAR_0->v_max * VAR_13);
} else if (!VAR_0->ls) {
VAR_6 = VAR_0->h_max / VAR_0->h_scount[0];
VAR_7 = VAR_0->v_max / VAR_0->v_scount[0];
VAR_0->mb_width = (VAR_0->width + VAR_6 * VAR_13 - 1) / (VAR_6 * VAR_13);
VAR_0->mb_height = (VAR_0->height + VAR_7 * VAR_13 - 1) / (VAR_7 * VAR_13);
VAR_0->nb_blocks[0] = 1;
VAR_0->h_scount[0] = 1;
VAR_0->v_scount[0] = 1;
}
if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(VAR_0->avctx, AV_LOG_DEBUG, "%VAR_0 %VAR_0 p:%d >>:%d VAR_14:%d bits:%d skip:%d %VAR_0 comp:%d\n",
VAR_0->lossless ? "lossless" : "sequential DCT", VAR_0->rgb ? "RGB" : "",
VAR_8, VAR_9, VAR_14, VAR_0->bits, VAR_0->mjpb_skiptosod,
VAR_0->pegasus_rct ? "PRCT" : (VAR_0->rct ? "RCT" : ""), VAR_4);
for (VAR_5 = VAR_0->mjpb_skiptosod; VAR_5 > 0; VAR_5--)
skip_bits(&VAR_0->gb, 8);
next_field:
for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++)
VAR_0->last_dc[VAR_5] = 1024;
if (VAR_0->lossless) {
av_assert0(VAR_0->picture_ptr == &VAR_0->picture);
if (CONFIG_JPEGLS_DECODER && VAR_0->ls) {
if ((VAR_12 = ff_jpegls_decode_picture(VAR_0, VAR_8,
VAR_9, VAR_14)) < 0)
return VAR_12;
} else {
if (VAR_0->rgb) {
if ((VAR_12 = ljpeg_decode_rgb_scan(VAR_0, VAR_4, VAR_8, VAR_9)) < 0)
return VAR_12;
} else {
if ((VAR_12 = ljpeg_decode_yuv_scan(VAR_0, VAR_8,
VAR_9,
VAR_4)) < 0)
return VAR_12;
}
}
} else {
if (VAR_0->progressive && VAR_8) {
av_assert0(VAR_0->picture_ptr == &VAR_0->picture);
if ((VAR_12 = mjpeg_decode_scan_progressive_ac(VAR_0, VAR_8,
VAR_14, VAR_15,
VAR_9)) < 0)
return VAR_12;
} else {
if ((VAR_12 = mjpeg_decode_scan(VAR_0, VAR_4,
VAR_15, VAR_9,
VAR_1, VAR_2)) < 0)
return VAR_12;
}
}
if (VAR_0->interlaced &&
get_bits_left(&VAR_0->gb) > 32 &&
show_bits(&VAR_0->gb, 8) == 0xFF) {
GetBitContext bak = VAR_0->gb;
align_get_bits(&bak);
if (show_bits(&bak, 16) == 0xFFD1) {
av_log(VAR_0->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
VAR_0->gb = bak;
skip_bits(&VAR_0->gb, 16);
VAR_0->bottom_field ^= 1;
goto next_field;
}
}
emms_c();
return 0;
out_of_range:
av_log(VAR_0->avctx, AV_LOG_ERROR, "decode_sos: ac/dc VAR_10 out of range\n");
return AVERROR_INVALIDDATA;
}
| [
"int FUNC_0(MJpegDecodeContext *VAR_0, const uint8_t *VAR_1,\nconst AVFrame *VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;",
"int VAR_10, VAR_11, VAR_12;",
"const int VAR_13 = VAR_0->lossless ? 1 : 8;",
"int VAR_14, VAR_15;",
"if (!VAR_0->got_picture) {",
"av_log(VAR_0->avctx, AV_LOG_WARNING,\n\"Can not process SOS before SOF, skipping\\n\");",
"return -1;",
"}",
"av_assert0(VAR_0->picture_ptr->data[0]);",
"VAR_3 = get_bits(&VAR_0->gb, 16);",
"VAR_4 = get_bits(&VAR_0->gb, 8);",
"if (VAR_4 == 0 || VAR_4 > MAX_COMPONENTS) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"decode_sos: VAR_4 (%d) unsupported\\n\", VAR_4);",
"return AVERROR_PATCHWELCOME;",
"}",
"if (VAR_3 != 6 + 2 * VAR_4) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"decode_sos: invalid VAR_3 (%d)\\n\", VAR_3);",
"return AVERROR_INVALIDDATA;",
"}",
"for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {",
"VAR_11 = get_bits(&VAR_0->gb, 8) - 1;",
"av_log(VAR_0->avctx, AV_LOG_DEBUG, \"component: %d\\n\", VAR_11);",
"for (VAR_10 = 0; VAR_10 < VAR_0->VAR_4; VAR_10++)",
"if (VAR_11 == VAR_0->component_id[VAR_10])\nbreak;",
"if (VAR_10 == VAR_0->VAR_4) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR,\n\"decode_sos: VAR_10(%d) out of components\\n\", VAR_10);",
"return AVERROR_INVALIDDATA;",
"}",
"if (VAR_0->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')\n&& VAR_4 == 3 && VAR_0->VAR_4 == 3 && VAR_5)\nVAR_10 = 3 - VAR_5;",
"if(VAR_4 == 3 && VAR_0->VAR_4 == 3 && VAR_0->avctx->pix_fmt == AV_PIX_FMT_GBR24P)\nVAR_10 = (VAR_5+2)%3;",
"if(VAR_4 == 1 && VAR_0->VAR_4 == 3 && VAR_0->avctx->pix_fmt == AV_PIX_FMT_GBR24P)\nVAR_10 = (VAR_10+2)%3;",
"VAR_0->comp_index[VAR_5] = VAR_10;",
"VAR_0->nb_blocks[VAR_5] = VAR_0->h_count[VAR_10] * VAR_0->v_count[VAR_10];",
"VAR_0->h_scount[VAR_5] = VAR_0->h_count[VAR_10];",
"VAR_0->v_scount[VAR_5] = VAR_0->v_count[VAR_10];",
"VAR_0->dc_index[VAR_5] = get_bits(&VAR_0->gb, 4);",
"VAR_0->ac_index[VAR_5] = get_bits(&VAR_0->gb, 4);",
"if (VAR_0->dc_index[VAR_5] < 0 || VAR_0->ac_index[VAR_5] < 0 ||\nVAR_0->dc_index[VAR_5] >= 4 || VAR_0->ac_index[VAR_5] >= 4)\ngoto out_of_range;",
"if (!VAR_0->vlcs[0][VAR_0->dc_index[VAR_5]].table || !(VAR_0->progressive ? VAR_0->vlcs[2][VAR_0->ac_index[0]].table : VAR_0->vlcs[1][VAR_0->ac_index[VAR_5]].table))\ngoto out_of_range;",
"}",
"VAR_8 = get_bits(&VAR_0->gb, 8);",
"VAR_14 = get_bits(&VAR_0->gb, 8);",
"if(VAR_0->avctx->codec_tag != AV_RL32(\"CJPG\")){",
"VAR_15 = get_bits(&VAR_0->gb, 4);",
"VAR_9 = get_bits(&VAR_0->gb, 4);",
"}else",
"VAR_15 = VAR_9 = 0;",
"if (VAR_4 > 1) {",
"VAR_0->mb_width = (VAR_0->width + VAR_0->h_max * VAR_13 - 1) / (VAR_0->h_max * VAR_13);",
"VAR_0->mb_height = (VAR_0->height + VAR_0->v_max * VAR_13 - 1) / (VAR_0->v_max * VAR_13);",
"} else if (!VAR_0->ls) {",
"VAR_6 = VAR_0->h_max / VAR_0->h_scount[0];",
"VAR_7 = VAR_0->v_max / VAR_0->v_scount[0];",
"VAR_0->mb_width = (VAR_0->width + VAR_6 * VAR_13 - 1) / (VAR_6 * VAR_13);",
"VAR_0->mb_height = (VAR_0->height + VAR_7 * VAR_13 - 1) / (VAR_7 * VAR_13);",
"VAR_0->nb_blocks[0] = 1;",
"VAR_0->h_scount[0] = 1;",
"VAR_0->v_scount[0] = 1;",
"}",
"if (VAR_0->avctx->debug & FF_DEBUG_PICT_INFO)\nav_log(VAR_0->avctx, AV_LOG_DEBUG, \"%VAR_0 %VAR_0 p:%d >>:%d VAR_14:%d bits:%d skip:%d %VAR_0 comp:%d\\n\",\nVAR_0->lossless ? \"lossless\" : \"sequential DCT\", VAR_0->rgb ? \"RGB\" : \"\",\nVAR_8, VAR_9, VAR_14, VAR_0->bits, VAR_0->mjpb_skiptosod,\nVAR_0->pegasus_rct ? \"PRCT\" : (VAR_0->rct ? \"RCT\" : \"\"), VAR_4);",
"for (VAR_5 = VAR_0->mjpb_skiptosod; VAR_5 > 0; VAR_5--)",
"skip_bits(&VAR_0->gb, 8);",
"next_field:\nfor (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++)",
"VAR_0->last_dc[VAR_5] = 1024;",
"if (VAR_0->lossless) {",
"av_assert0(VAR_0->picture_ptr == &VAR_0->picture);",
"if (CONFIG_JPEGLS_DECODER && VAR_0->ls) {",
"if ((VAR_12 = ff_jpegls_decode_picture(VAR_0, VAR_8,\nVAR_9, VAR_14)) < 0)\nreturn VAR_12;",
"} else {",
"if (VAR_0->rgb) {",
"if ((VAR_12 = ljpeg_decode_rgb_scan(VAR_0, VAR_4, VAR_8, VAR_9)) < 0)\nreturn VAR_12;",
"} else {",
"if ((VAR_12 = ljpeg_decode_yuv_scan(VAR_0, VAR_8,\nVAR_9,\nVAR_4)) < 0)\nreturn VAR_12;",
"}",
"}",
"} else {",
"if (VAR_0->progressive && VAR_8) {",
"av_assert0(VAR_0->picture_ptr == &VAR_0->picture);",
"if ((VAR_12 = mjpeg_decode_scan_progressive_ac(VAR_0, VAR_8,\nVAR_14, VAR_15,\nVAR_9)) < 0)\nreturn VAR_12;",
"} else {",
"if ((VAR_12 = mjpeg_decode_scan(VAR_0, VAR_4,\nVAR_15, VAR_9,\nVAR_1, VAR_2)) < 0)\nreturn VAR_12;",
"}",
"}",
"if (VAR_0->interlaced &&\nget_bits_left(&VAR_0->gb) > 32 &&\nshow_bits(&VAR_0->gb, 8) == 0xFF) {",
"GetBitContext bak = VAR_0->gb;",
"align_get_bits(&bak);",
"if (show_bits(&bak, 16) == 0xFFD1) {",
"av_log(VAR_0->avctx, AV_LOG_DEBUG, \"AVRn interlaced picture marker found\\n\");",
"VAR_0->gb = bak;",
"skip_bits(&VAR_0->gb, 16);",
"VAR_0->bottom_field ^= 1;",
"goto next_field;",
"}",
"}",
"emms_c();",
"return 0;",
"out_of_range:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"decode_sos: ac/dc VAR_10 out of range\\n\");",
"return AVERROR_INVALIDDATA;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65,
67
],
[
69
],
[
71,
73
],
[
75
],
[
77
],
[
81,
83,
85
],
[
89,
91
],
[
93,
95
],
[
99
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
117,
119,
121
],
[
123,
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
175,
177,
179,
181,
183
],
[
191
],
[
193
],
[
197,
199
],
[
201
],
[
205
],
[
207
],
[
209
],
[
217,
219,
221
],
[
223
],
[
225
],
[
227,
229
],
[
231
],
[
233,
235,
237,
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251,
253,
255,
257
],
[
259
],
[
261,
263,
265,
267
],
[
269
],
[
271
],
[
275,
277,
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
297
],
[
299
],
[
301
],
[
305
],
[
307
],
[
309,
311
],
[
313
],
[
315
]
] |
21,599 | static void do_video_out(AVFormatContext *s,
AVOutputStream *ost,
AVInputStream *ist,
AVFrame *in_picture,
int *frame_size, AVOutputStream *audio_sync)
{
int nb_frames, i, ret;
AVFrame *final_picture, *formatted_picture;
AVFrame picture_format_temp, picture_crop_temp;
static uint8_t *video_buffer= NULL;
uint8_t *buf = NULL, *buf1 = NULL;
AVCodecContext *enc, *dec;
enum PixelFormat target_pixfmt;
#define VIDEO_BUFFER_SIZE (1024*1024)
avcodec_get_frame_defaults(&picture_format_temp);
avcodec_get_frame_defaults(&picture_crop_temp);
enc = &ost->st->codec;
dec = &ist->st->codec;
/* by default, we output a single frame */
nb_frames = 1;
*frame_size = 0;
if(sync_method){
double vdelta;
vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
//FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
if (vdelta < -1.1)
nb_frames = 0;
else if (vdelta > 1.1)
nb_frames = 2;
//printf("vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
}
ost->sync_opts+= nb_frames;
if (nb_frames <= 0)
return;
if (!video_buffer)
video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
if (!video_buffer)
return;
/* convert pixel format if needed */
target_pixfmt = ost->video_resample || ost->video_pad
? PIX_FMT_YUV420P : enc->pix_fmt;
if (dec->pix_fmt != target_pixfmt) {
int size;
/* create temporary picture */
size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
buf = av_malloc(size);
if (!buf)
return;
formatted_picture = &picture_format_temp;
avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
(AVPicture *)in_picture, dec->pix_fmt,
dec->width, dec->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
} else {
formatted_picture = in_picture;
}
/* XXX: resampling could be done before raw format conversion in
some cases to go faster */
/* XXX: only works for YUV420P */
if (ost->video_resample) {
final_picture = &ost->pict_tmp;
img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
ost->padtop, ost->padbottom, ost->padleft, ost->padright,
padcolor);
}
if (enc->pix_fmt != PIX_FMT_YUV420P) {
int size;
av_free(buf);
/* create temporary picture */
size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
buf = av_malloc(size);
if (!buf)
return;
final_picture = &picture_format_temp;
avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
(AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
enc->width, enc->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
}
} else if (ost->video_crop) {
picture_crop_temp.data[0] = formatted_picture->data[0] +
(ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
picture_crop_temp.data[1] = formatted_picture->data[1] +
((ost->topBand >> 1) * formatted_picture->linesize[1]) +
(ost->leftBand >> 1);
picture_crop_temp.data[2] = formatted_picture->data[2] +
((ost->topBand >> 1) * formatted_picture->linesize[2]) +
(ost->leftBand >> 1);
picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
final_picture = &picture_crop_temp;
} else if (ost->video_pad) {
final_picture = &ost->pict_tmp;
for (i = 0; i < 3; i++) {
uint8_t *optr, *iptr;
int shift = (i == 0) ? 0 : 1;
int y, yheight;
/* set offset to start writing image into */
optr = final_picture->data[i] + (((final_picture->linesize[i] *
ost->padtop) + ost->padleft) >> shift);
iptr = formatted_picture->data[i];
yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
for (y = 0; y < yheight; y++) {
/* copy unpadded image row into padded image row */
memcpy(optr, iptr, formatted_picture->linesize[i]);
optr += final_picture->linesize[i];
iptr += formatted_picture->linesize[i];
}
}
fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
ost->padtop, ost->padbottom, ost->padleft, ost->padright,
padcolor);
if (enc->pix_fmt != PIX_FMT_YUV420P) {
int size;
av_free(buf);
/* create temporary picture */
size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
buf = av_malloc(size);
if (!buf)
return;
final_picture = &picture_format_temp;
avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
(AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
enc->width, enc->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
}
} else {
final_picture = formatted_picture;
}
/* duplicates frame if needed */
/* XXX: pb because no interleaving */
for(i=0;i<nb_frames;i++) {
AVPacket pkt;
av_init_packet(&pkt);
pkt.stream_index= ost->index;
if (s->oformat->flags & AVFMT_RAWPICTURE) {
/* raw pictures are written as AVPicture structure to
avoid any copies. We support temorarily the older
method. */
AVFrame* old_frame = enc->coded_frame;
enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
pkt.data= (uint8_t *)final_picture;
pkt.size= sizeof(AVPicture);
if(dec->coded_frame)
pkt.pts= dec->coded_frame->pts;
if(dec->coded_frame && dec->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
av_write_frame(s, &pkt);
enc->coded_frame = old_frame;
} else {
AVFrame big_picture;
big_picture= *final_picture;
/* better than nothing: use input picture interlaced
settings */
big_picture.interlaced_frame = in_picture->interlaced_frame;
if(do_interlace_me || do_interlace_dct){
if(top_field_first == -1)
big_picture.top_field_first = in_picture->top_field_first;
else
big_picture.top_field_first = 1;
}
/* handles sameq here. This is not correct because it may
not be a global option */
if (same_quality) {
big_picture.quality = ist->st->quality;
}else
big_picture.quality = ost->st->quality;
if(!me_threshold)
big_picture.pict_type = 0;
big_picture.pts = AV_NOPTS_VALUE; //FIXME
ret = avcodec_encode_video(enc,
video_buffer, VIDEO_BUFFER_SIZE,
&big_picture);
//enc->frame_number = enc->real_pict_num;
if(ret){
pkt.data= video_buffer;
pkt.size= ret;
if(enc->coded_frame)
pkt.pts= enc->coded_frame->pts;
if(enc->coded_frame && enc->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
av_write_frame(s, &pkt);
*frame_size = ret;
//fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
// enc->frame_number-1, enc->real_pict_num, ret,
// enc->pict_type);
/* if two pass, output log */
if (ost->logfile && enc->stats_out) {
fprintf(ost->logfile, "%s", enc->stats_out);
}
}
}
ost->frame_number++;
}
the_end:
av_free(buf);
av_free(buf1);
}
| false | FFmpeg | 3c895fc098f7637f6d5ec3a9d6766e724a8b9e41 | static void do_video_out(AVFormatContext *s,
AVOutputStream *ost,
AVInputStream *ist,
AVFrame *in_picture,
int *frame_size, AVOutputStream *audio_sync)
{
int nb_frames, i, ret;
AVFrame *final_picture, *formatted_picture;
AVFrame picture_format_temp, picture_crop_temp;
static uint8_t *video_buffer= NULL;
uint8_t *buf = NULL, *buf1 = NULL;
AVCodecContext *enc, *dec;
enum PixelFormat target_pixfmt;
#define VIDEO_BUFFER_SIZE (1024*1024)
avcodec_get_frame_defaults(&picture_format_temp);
avcodec_get_frame_defaults(&picture_crop_temp);
enc = &ost->st->codec;
dec = &ist->st->codec;
nb_frames = 1;
*frame_size = 0;
if(sync_method){
double vdelta;
vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
if (vdelta < -1.1)
nb_frames = 0;
else if (vdelta > 1.1)
nb_frames = 2;
}
ost->sync_opts+= nb_frames;
if (nb_frames <= 0)
return;
if (!video_buffer)
video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
if (!video_buffer)
return;
target_pixfmt = ost->video_resample || ost->video_pad
? PIX_FMT_YUV420P : enc->pix_fmt;
if (dec->pix_fmt != target_pixfmt) {
int size;
size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
buf = av_malloc(size);
if (!buf)
return;
formatted_picture = &picture_format_temp;
avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
(AVPicture *)in_picture, dec->pix_fmt,
dec->width, dec->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
} else {
formatted_picture = in_picture;
}
if (ost->video_resample) {
final_picture = &ost->pict_tmp;
img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
ost->padtop, ost->padbottom, ost->padleft, ost->padright,
padcolor);
}
if (enc->pix_fmt != PIX_FMT_YUV420P) {
int size;
av_free(buf);
size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
buf = av_malloc(size);
if (!buf)
return;
final_picture = &picture_format_temp;
avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
(AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
enc->width, enc->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
}
} else if (ost->video_crop) {
picture_crop_temp.data[0] = formatted_picture->data[0] +
(ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
picture_crop_temp.data[1] = formatted_picture->data[1] +
((ost->topBand >> 1) * formatted_picture->linesize[1]) +
(ost->leftBand >> 1);
picture_crop_temp.data[2] = formatted_picture->data[2] +
((ost->topBand >> 1) * formatted_picture->linesize[2]) +
(ost->leftBand >> 1);
picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
final_picture = &picture_crop_temp;
} else if (ost->video_pad) {
final_picture = &ost->pict_tmp;
for (i = 0; i < 3; i++) {
uint8_t *optr, *iptr;
int shift = (i == 0) ? 0 : 1;
int y, yheight;
optr = final_picture->data[i] + (((final_picture->linesize[i] *
ost->padtop) + ost->padleft) >> shift);
iptr = formatted_picture->data[i];
yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
for (y = 0; y < yheight; y++) {
memcpy(optr, iptr, formatted_picture->linesize[i]);
optr += final_picture->linesize[i];
iptr += formatted_picture->linesize[i];
}
}
fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
ost->padtop, ost->padbottom, ost->padleft, ost->padright,
padcolor);
if (enc->pix_fmt != PIX_FMT_YUV420P) {
int size;
av_free(buf);
size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
buf = av_malloc(size);
if (!buf)
return;
final_picture = &picture_format_temp;
avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
(AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
enc->width, enc->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
}
} else {
final_picture = formatted_picture;
}
for(i=0;i<nb_frames;i++) {
AVPacket pkt;
av_init_packet(&pkt);
pkt.stream_index= ost->index;
if (s->oformat->flags & AVFMT_RAWPICTURE) {
AVFrame* old_frame = enc->coded_frame;
enc->coded_frame = dec->coded_frame;
pkt.data= (uint8_t *)final_picture;
pkt.size= sizeof(AVPicture);
if(dec->coded_frame)
pkt.pts= dec->coded_frame->pts;
if(dec->coded_frame && dec->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
av_write_frame(s, &pkt);
enc->coded_frame = old_frame;
} else {
AVFrame big_picture;
big_picture= *final_picture;
big_picture.interlaced_frame = in_picture->interlaced_frame;
if(do_interlace_me || do_interlace_dct){
if(top_field_first == -1)
big_picture.top_field_first = in_picture->top_field_first;
else
big_picture.top_field_first = 1;
}
if (same_quality) {
big_picture.quality = ist->st->quality;
}else
big_picture.quality = ost->st->quality;
if(!me_threshold)
big_picture.pict_type = 0;
big_picture.pts = AV_NOPTS_VALUE;
ret = avcodec_encode_video(enc,
video_buffer, VIDEO_BUFFER_SIZE,
&big_picture);
if(ret){
pkt.data= video_buffer;
pkt.size= ret;
if(enc->coded_frame)
pkt.pts= enc->coded_frame->pts;
if(enc->coded_frame && enc->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
av_write_frame(s, &pkt);
*frame_size = ret;
if (ost->logfile && enc->stats_out) {
fprintf(ost->logfile, "%s", enc->stats_out);
}
}
}
ost->frame_number++;
}
the_end:
av_free(buf);
av_free(buf1);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AVFormatContext *VAR_0,
AVOutputStream *VAR_1,
AVInputStream *VAR_2,
AVFrame *VAR_3,
int *VAR_4, AVOutputStream *VAR_5)
{
int VAR_6, VAR_7, VAR_8;
AVFrame *final_picture, *formatted_picture;
AVFrame picture_format_temp, picture_crop_temp;
static uint8_t *VAR_9= NULL;
uint8_t *buf = NULL, *buf1 = NULL;
AVCodecContext *enc, *dec;
enum PixelFormat VAR_10;
#define VIDEO_BUFFER_SIZE (1024*1024)
avcodec_get_frame_defaults(&picture_format_temp);
avcodec_get_frame_defaults(&picture_crop_temp);
enc = &VAR_1->st->codec;
dec = &VAR_2->st->codec;
VAR_6 = 1;
*VAR_4 = 0;
if(sync_method){
double VAR_11;
VAR_11 = VAR_1->sync_ipts * enc->frame_rate / enc->frame_rate_base - VAR_1->sync_opts;
if (VAR_11 < -1.1)
VAR_6 = 0;
else if (VAR_11 > 1.1)
VAR_6 = 2;
}
VAR_1->sync_opts+= VAR_6;
if (VAR_6 <= 0)
return;
if (!VAR_9)
VAR_9 = av_malloc(VIDEO_BUFFER_SIZE);
if (!VAR_9)
return;
VAR_10 = VAR_1->video_resample || VAR_1->video_pad
? PIX_FMT_YUV420P : enc->pix_fmt;
if (dec->pix_fmt != VAR_10) {
int VAR_16;
VAR_16 = avpicture_get_size(VAR_10, dec->width, dec->height);
buf = av_malloc(VAR_16);
if (!buf)
return;
formatted_picture = &picture_format_temp;
avpicture_fill((AVPicture*)formatted_picture, buf, VAR_10, dec->width, dec->height);
if (img_convert((AVPicture*)formatted_picture, VAR_10,
(AVPicture *)VAR_3, dec->pix_fmt,
dec->width, dec->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
} else {
formatted_picture = VAR_3;
}
if (VAR_1->video_resample) {
final_picture = &VAR_1->pict_tmp;
img_resample(VAR_1->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
if (VAR_1->padtop || VAR_1->padbottom || VAR_1->padleft || VAR_1->padright) {
fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
VAR_1->padtop, VAR_1->padbottom, VAR_1->padleft, VAR_1->padright,
padcolor);
}
if (enc->pix_fmt != PIX_FMT_YUV420P) {
int VAR_16;
av_free(buf);
VAR_16 = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
buf = av_malloc(VAR_16);
if (!buf)
return;
final_picture = &picture_format_temp;
avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
(AVPicture*)&VAR_1->pict_tmp, PIX_FMT_YUV420P,
enc->width, enc->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
}
} else if (VAR_1->video_crop) {
picture_crop_temp.data[0] = formatted_picture->data[0] +
(VAR_1->topBand * formatted_picture->linesize[0]) + VAR_1->leftBand;
picture_crop_temp.data[1] = formatted_picture->data[1] +
((VAR_1->topBand >> 1) * formatted_picture->linesize[1]) +
(VAR_1->leftBand >> 1);
picture_crop_temp.data[2] = formatted_picture->data[2] +
((VAR_1->topBand >> 1) * formatted_picture->linesize[2]) +
(VAR_1->leftBand >> 1);
picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
final_picture = &picture_crop_temp;
} else if (VAR_1->video_pad) {
final_picture = &VAR_1->pict_tmp;
for (VAR_7 = 0; VAR_7 < 3; VAR_7++) {
uint8_t *optr, *iptr;
int VAR_13 = (VAR_7 == 0) ? 0 : 1;
int VAR_14, VAR_15;
optr = final_picture->data[VAR_7] + (((final_picture->linesize[VAR_7] *
VAR_1->padtop) + VAR_1->padleft) >> VAR_13);
iptr = formatted_picture->data[VAR_7];
VAR_15 = (enc->height - VAR_1->padtop - VAR_1->padbottom) >> VAR_13;
for (VAR_14 = 0; VAR_14 < VAR_15; VAR_14++) {
memcpy(optr, iptr, formatted_picture->linesize[VAR_7]);
optr += final_picture->linesize[VAR_7];
iptr += formatted_picture->linesize[VAR_7];
}
}
fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
VAR_1->padtop, VAR_1->padbottom, VAR_1->padleft, VAR_1->padright,
padcolor);
if (enc->pix_fmt != PIX_FMT_YUV420P) {
int VAR_16;
av_free(buf);
VAR_16 = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
buf = av_malloc(VAR_16);
if (!buf)
return;
final_picture = &picture_format_temp;
avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
(AVPicture*)&VAR_1->pict_tmp, PIX_FMT_YUV420P,
enc->width, enc->height) < 0) {
if (verbose >= 0)
fprintf(stderr, "pixel format conversion not handled\n");
goto the_end;
}
}
} else {
final_picture = formatted_picture;
}
for(VAR_7=0;VAR_7<VAR_6;VAR_7++) {
AVPacket pkt;
av_init_packet(&pkt);
pkt.stream_index= VAR_1->index;
if (VAR_0->oformat->flags & AVFMT_RAWPICTURE) {
AVFrame* old_frame = enc->coded_frame;
enc->coded_frame = dec->coded_frame;
pkt.data= (uint8_t *)final_picture;
pkt.VAR_16= sizeof(AVPicture);
if(dec->coded_frame)
pkt.pts= dec->coded_frame->pts;
if(dec->coded_frame && dec->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
av_write_frame(VAR_0, &pkt);
enc->coded_frame = old_frame;
} else {
AVFrame big_picture;
big_picture= *final_picture;
big_picture.interlaced_frame = VAR_3->interlaced_frame;
if(do_interlace_me || do_interlace_dct){
if(top_field_first == -1)
big_picture.top_field_first = VAR_3->top_field_first;
else
big_picture.top_field_first = 1;
}
if (same_quality) {
big_picture.quality = VAR_2->st->quality;
}else
big_picture.quality = VAR_1->st->quality;
if(!me_threshold)
big_picture.pict_type = 0;
big_picture.pts = AV_NOPTS_VALUE;
VAR_8 = avcodec_encode_video(enc,
VAR_9, VIDEO_BUFFER_SIZE,
&big_picture);
if(VAR_8){
pkt.data= VAR_9;
pkt.VAR_16= VAR_8;
if(enc->coded_frame)
pkt.pts= enc->coded_frame->pts;
if(enc->coded_frame && enc->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
av_write_frame(VAR_0, &pkt);
*VAR_4 = VAR_8;
if (VAR_1->logfile && enc->stats_out) {
fprintf(VAR_1->logfile, "%VAR_0", enc->stats_out);
}
}
}
VAR_1->frame_number++;
}
the_end:
av_free(buf);
av_free(buf1);
}
| [
"static void FUNC_0(AVFormatContext *VAR_0,\nAVOutputStream *VAR_1,\nAVInputStream *VAR_2,\nAVFrame *VAR_3,\nint *VAR_4, AVOutputStream *VAR_5)\n{",
"int VAR_6, VAR_7, VAR_8;",
"AVFrame *final_picture, *formatted_picture;",
"AVFrame picture_format_temp, picture_crop_temp;",
"static uint8_t *VAR_9= NULL;",
"uint8_t *buf = NULL, *buf1 = NULL;",
"AVCodecContext *enc, *dec;",
"enum PixelFormat VAR_10;",
"#define VIDEO_BUFFER_SIZE (1024*1024)\navcodec_get_frame_defaults(&picture_format_temp);",
"avcodec_get_frame_defaults(&picture_crop_temp);",
"enc = &VAR_1->st->codec;",
"dec = &VAR_2->st->codec;",
"VAR_6 = 1;",
"*VAR_4 = 0;",
"if(sync_method){",
"double VAR_11;",
"VAR_11 = VAR_1->sync_ipts * enc->frame_rate / enc->frame_rate_base - VAR_1->sync_opts;",
"if (VAR_11 < -1.1)\nVAR_6 = 0;",
"else if (VAR_11 > 1.1)\nVAR_6 = 2;",
"}",
"VAR_1->sync_opts+= VAR_6;",
"if (VAR_6 <= 0)\nreturn;",
"if (!VAR_9)\nVAR_9 = av_malloc(VIDEO_BUFFER_SIZE);",
"if (!VAR_9)\nreturn;",
"VAR_10 = VAR_1->video_resample || VAR_1->video_pad\n? PIX_FMT_YUV420P : enc->pix_fmt;",
"if (dec->pix_fmt != VAR_10) {",
"int VAR_16;",
"VAR_16 = avpicture_get_size(VAR_10, dec->width, dec->height);",
"buf = av_malloc(VAR_16);",
"if (!buf)\nreturn;",
"formatted_picture = &picture_format_temp;",
"avpicture_fill((AVPicture*)formatted_picture, buf, VAR_10, dec->width, dec->height);",
"if (img_convert((AVPicture*)formatted_picture, VAR_10,\n(AVPicture *)VAR_3, dec->pix_fmt,\ndec->width, dec->height) < 0) {",
"if (verbose >= 0)\nfprintf(stderr, \"pixel format conversion not handled\\n\");",
"goto the_end;",
"}",
"} else {",
"formatted_picture = VAR_3;",
"}",
"if (VAR_1->video_resample) {",
"final_picture = &VAR_1->pict_tmp;",
"img_resample(VAR_1->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);",
"if (VAR_1->padtop || VAR_1->padbottom || VAR_1->padleft || VAR_1->padright) {",
"fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,\nVAR_1->padtop, VAR_1->padbottom, VAR_1->padleft, VAR_1->padright,\npadcolor);",
"}",
"if (enc->pix_fmt != PIX_FMT_YUV420P) {",
"int VAR_16;",
"av_free(buf);",
"VAR_16 = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);",
"buf = av_malloc(VAR_16);",
"if (!buf)\nreturn;",
"final_picture = &picture_format_temp;",
"avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);",
"if (img_convert((AVPicture*)final_picture, enc->pix_fmt,\n(AVPicture*)&VAR_1->pict_tmp, PIX_FMT_YUV420P,\nenc->width, enc->height) < 0) {",
"if (verbose >= 0)\nfprintf(stderr, \"pixel format conversion not handled\\n\");",
"goto the_end;",
"}",
"}",
"} else if (VAR_1->video_crop) {",
"picture_crop_temp.data[0] = formatted_picture->data[0] +\n(VAR_1->topBand * formatted_picture->linesize[0]) + VAR_1->leftBand;",
"picture_crop_temp.data[1] = formatted_picture->data[1] +\n((VAR_1->topBand >> 1) * formatted_picture->linesize[1]) +\n(VAR_1->leftBand >> 1);",
"picture_crop_temp.data[2] = formatted_picture->data[2] +\n((VAR_1->topBand >> 1) * formatted_picture->linesize[2]) +\n(VAR_1->leftBand >> 1);",
"picture_crop_temp.linesize[0] = formatted_picture->linesize[0];",
"picture_crop_temp.linesize[1] = formatted_picture->linesize[1];",
"picture_crop_temp.linesize[2] = formatted_picture->linesize[2];",
"final_picture = &picture_crop_temp;",
"} else if (VAR_1->video_pad) {",
"final_picture = &VAR_1->pict_tmp;",
"for (VAR_7 = 0; VAR_7 < 3; VAR_7++) {",
"uint8_t *optr, *iptr;",
"int VAR_13 = (VAR_7 == 0) ? 0 : 1;",
"int VAR_14, VAR_15;",
"optr = final_picture->data[VAR_7] + (((final_picture->linesize[VAR_7] *\nVAR_1->padtop) + VAR_1->padleft) >> VAR_13);",
"iptr = formatted_picture->data[VAR_7];",
"VAR_15 = (enc->height - VAR_1->padtop - VAR_1->padbottom) >> VAR_13;",
"for (VAR_14 = 0; VAR_14 < VAR_15; VAR_14++) {",
"memcpy(optr, iptr, formatted_picture->linesize[VAR_7]);",
"optr += final_picture->linesize[VAR_7];",
"iptr += formatted_picture->linesize[VAR_7];",
"}",
"}",
"fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,\nVAR_1->padtop, VAR_1->padbottom, VAR_1->padleft, VAR_1->padright,\npadcolor);",
"if (enc->pix_fmt != PIX_FMT_YUV420P) {",
"int VAR_16;",
"av_free(buf);",
"VAR_16 = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);",
"buf = av_malloc(VAR_16);",
"if (!buf)\nreturn;",
"final_picture = &picture_format_temp;",
"avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);",
"if (img_convert((AVPicture*)final_picture, enc->pix_fmt,\n(AVPicture*)&VAR_1->pict_tmp, PIX_FMT_YUV420P,\nenc->width, enc->height) < 0) {",
"if (verbose >= 0)\nfprintf(stderr, \"pixel format conversion not handled\\n\");",
"goto the_end;",
"}",
"}",
"} else {",
"final_picture = formatted_picture;",
"}",
"for(VAR_7=0;VAR_7<VAR_6;VAR_7++) {",
"AVPacket pkt;",
"av_init_packet(&pkt);",
"pkt.stream_index= VAR_1->index;",
"if (VAR_0->oformat->flags & AVFMT_RAWPICTURE) {",
"AVFrame* old_frame = enc->coded_frame;",
"enc->coded_frame = dec->coded_frame;",
"pkt.data= (uint8_t *)final_picture;",
"pkt.VAR_16= sizeof(AVPicture);",
"if(dec->coded_frame)\npkt.pts= dec->coded_frame->pts;",
"if(dec->coded_frame && dec->coded_frame->key_frame)\npkt.flags |= PKT_FLAG_KEY;",
"av_write_frame(VAR_0, &pkt);",
"enc->coded_frame = old_frame;",
"} else {",
"AVFrame big_picture;",
"big_picture= *final_picture;",
"big_picture.interlaced_frame = VAR_3->interlaced_frame;",
"if(do_interlace_me || do_interlace_dct){",
"if(top_field_first == -1)\nbig_picture.top_field_first = VAR_3->top_field_first;",
"else\nbig_picture.top_field_first = 1;",
"}",
"if (same_quality) {",
"big_picture.quality = VAR_2->st->quality;",
"}else",
"big_picture.quality = VAR_1->st->quality;",
"if(!me_threshold)\nbig_picture.pict_type = 0;",
"big_picture.pts = AV_NOPTS_VALUE;",
"VAR_8 = avcodec_encode_video(enc,\nVAR_9, VIDEO_BUFFER_SIZE,\n&big_picture);",
"if(VAR_8){",
"pkt.data= VAR_9;",
"pkt.VAR_16= VAR_8;",
"if(enc->coded_frame)\npkt.pts= enc->coded_frame->pts;",
"if(enc->coded_frame && enc->coded_frame->key_frame)\npkt.flags |= PKT_FLAG_KEY;",
"av_write_frame(VAR_0, &pkt);",
"*VAR_4 = VAR_8;",
"if (VAR_1->logfile && enc->stats_out) {",
"fprintf(VAR_1->logfile, \"%VAR_0\", enc->stats_out);",
"}",
"}",
"}",
"VAR_1->frame_number++;",
"}",
"the_end:\nav_free(buf);",
"av_free(buf1);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
33
],
[
35
],
[
39
],
[
41
],
[
47
],
[
51
],
[
55
],
[
57
],
[
59
],
[
63,
65
],
[
67,
69
],
[
73
],
[
75
],
[
79,
81
],
[
85,
87
],
[
89,
91
],
[
97,
99
],
[
101
],
[
103
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
119
],
[
123,
125,
127
],
[
131,
133
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
155
],
[
157
],
[
159
],
[
163
],
[
165,
167,
169
],
[
171
],
[
175
],
[
177
],
[
181
],
[
185
],
[
187
],
[
189,
191
],
[
193
],
[
195
],
[
199,
201,
203
],
[
207,
209
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221,
223
],
[
227,
229,
231
],
[
235,
237,
239
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
257
],
[
259
],
[
261
],
[
263
],
[
269,
271
],
[
273
],
[
277
],
[
279
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
295,
297,
299
],
[
303
],
[
305
],
[
309
],
[
313
],
[
315
],
[
317,
319
],
[
321
],
[
323
],
[
327,
329,
331
],
[
335,
337
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
357
],
[
359
],
[
361
],
[
363
],
[
367
],
[
375
],
[
377
],
[
379
],
[
381
],
[
383,
385
],
[
387,
389
],
[
393
],
[
395
],
[
397
],
[
399
],
[
403
],
[
409
],
[
411
],
[
413,
415
],
[
417,
419
],
[
421
],
[
429
],
[
431
],
[
433
],
[
435
],
[
437,
439
],
[
441
],
[
443,
445,
447
],
[
451
],
[
453
],
[
455
],
[
457,
459
],
[
461,
463
],
[
465
],
[
467
],
[
477
],
[
479
],
[
481
],
[
483
],
[
485
],
[
487
],
[
489
],
[
491,
493
],
[
495
],
[
497
]
] |
21,600 | static void av_always_inline filter_mb_edgecv( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[index_a];
const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
tc[0] = tc0_table[index_a][bS[0]]+1;
tc[1] = tc0_table[index_a][bS[1]]+1;
tc[2] = tc0_table[index_a][bS[2]]+1;
tc[3] = tc0_table[index_a][bS[3]]+1;
h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
| false | FFmpeg | a4f6be86d67ae30d494fbe8a470bc32b715d75a9 | static void av_always_inline filter_mb_edgecv( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[index_a];
const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
tc[0] = tc0_table[index_a][bS[0]]+1;
tc[1] = tc0_table[index_a][bS[1]]+1;
tc[2] = tc0_table[index_a][bS[2]]+1;
tc[3] = tc0_table[index_a][bS[3]]+1;
h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
| {
"code": [],
"line_no": []
} | static void VAR_0 filter_mb_edgecv( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[index_a];
const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
tc[0] = tc0_table[index_a][bS[0]]+1;
tc[1] = tc0_table[index_a][bS[1]]+1;
tc[2] = tc0_table[index_a][bS[2]]+1;
tc[3] = tc0_table[index_a][bS[3]]+1;
h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
| [
"static void VAR_0 filter_mb_edgecv( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h ) {",
"const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);",
"const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;",
"const int alpha = alpha_table[index_a];",
"const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];",
"if (alpha ==0 || beta == 0) return;",
"if( bS[0] < 4 ) {",
"int8_t tc[4];",
"tc[0] = tc0_table[index_a][bS[0]]+1;",
"tc[1] = tc0_table[index_a][bS[1]]+1;",
"tc[2] = tc0_table[index_a][bS[2]]+1;",
"tc[3] = tc0_table[index_a][bS[3]]+1;",
"h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);",
"} else {",
"h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);",
"}",
"}"
] | [
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
]
] |
21,602 | int ff_h263_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MpegEncContext *s = avctx->priv_data;
int ret;
AVFrame *pict = data;
#ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc();
#endif
#ifdef DEBUG
av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
if(buf_size>0)
av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
#endif
s->flags= avctx->flags;
s->flags2= avctx->flags2;
/* no supplementary picture */
if (buf_size == 0) {
/* special case for last picture */
if (s->low_delay==0 && s->next_picture_ptr) {
*pict= *(AVFrame*)s->next_picture_ptr;
s->next_picture_ptr= NULL;
*data_size = sizeof(AVFrame);
}
return 0;
}
if(s->flags&CODEC_FLAG_TRUNCATED){
int next;
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
}else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){
next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
}else{
av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
return -1;
}
if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
return buf_size;
}
retry:
if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){ //divx 5.01+/xvid frame reorder
init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
}else
init_get_bits(&s->gb, buf, buf_size*8);
s->bitstream_buffer_size=0;
if (!s->context_initialized) {
if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
return -1;
}
/* We need to set current_picture_ptr before reading the header,
* otherwise we cannot store anyting in there */
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
int i= ff_find_unused_picture(s, 0);
s->current_picture_ptr= &s->picture[i];
}
/* let's go :-) */
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) {
ret= ff_wmv2_decode_picture_header(s);
} else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {
ret = msmpeg4_decode_picture_header(s);
} else if (s->h263_pred) {
if(s->avctx->extradata_size && s->picture_number==0){
GetBitContext gb;
init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
ret = ff_mpeg4_decode_picture_header(s, &gb);
}
ret = ff_mpeg4_decode_picture_header(s, &s->gb);
} else if (s->codec_id == CODEC_ID_H263I) {
ret = intel_h263_decode_picture_header(s);
} else if (s->h263_flv) {
ret = flv_h263_decode_picture_header(s);
} else {
ret = h263_decode_picture_header(s);
}
if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size);
/* skip if the header was thrashed */
if (ret < 0){
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
return -1;
}
avctx->has_b_frames= !s->low_delay;
if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
if(s->stream_codec_tag == AV_RL32("XVID") ||
s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") ||
s->codec_tag == AV_RL32("RMP4"))
s->xvid_build= -1;
#if 0
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
&& s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc
s->xvid_build= -1;
#endif
}
if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
s->divx_version= 400; //divx 4
}
if(s->xvid_build && s->divx_version){
s->divx_version=
s->divx_build= 0;
}
if(s->workaround_bugs&FF_BUG_AUTODETECT){
if(s->codec_tag == AV_RL32("XVIX"))
s->workaround_bugs|= FF_BUG_XVID_ILACE;
if(s->codec_tag == AV_RL32("UMP4")){
s->workaround_bugs|= FF_BUG_UMP4;
}
if(s->divx_version>=500 && s->divx_build<1814){
s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
}
if(s->divx_version>502 && s->divx_build<1814){
s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
}
if(s->xvid_build && s->xvid_build<=3)
s->padding_bug_score= 256*256*256*64;
if(s->xvid_build && s->xvid_build<=1)
s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
if(s->xvid_build && s->xvid_build<=12)
s->workaround_bugs|= FF_BUG_EDGE;
if(s->xvid_build && s->xvid_build<=32)
s->workaround_bugs|= FF_BUG_DC_CLIP;
#define SET_QPEL_FUNC(postfix1, postfix2) \
s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
if(s->lavc_build && s->lavc_build<4653)
s->workaround_bugs|= FF_BUG_STD_QPEL;
if(s->lavc_build && s->lavc_build<4655)
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
if(s->lavc_build && s->lavc_build<4670){
s->workaround_bugs|= FF_BUG_EDGE;
}
if(s->lavc_build && s->lavc_build<=4712)
s->workaround_bugs|= FF_BUG_DC_CLIP;
if(s->divx_version)
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
//printf("padding_bug_score: %d\n", s->padding_bug_score);
if(s->divx_version==501 && s->divx_build==20020416)
s->padding_bug_score= 256*256*256*64;
if(s->divx_version && s->divx_version<500){
s->workaround_bugs|= FF_BUG_EDGE;
}
if(s->divx_version)
s->workaround_bugs|= FF_BUG_HPEL_CHROMA;
#if 0
if(s->divx_version==500)
s->padding_bug_score= 256*256*256*64;
/* very ugly XVID padding bug detection FIXME/XXX solve this differently
* Let us hope this at least works.
*/
if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
&& s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
s->workaround_bugs|= FF_BUG_NO_PADDING;
if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok
s->workaround_bugs|= FF_BUG_NO_PADDING;
#endif
}
if(s->workaround_bugs& FF_BUG_STD_QPEL){
SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
}
if(avctx->debug & FF_DEBUG_BUGS)
av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,
s->divx_packed ? "p" : "");
#if 0 // dump bits per frame / qp / complexity
{
static FILE *f=NULL;
if(!f) f=fopen("rate_qp_cplx.txt", "w");
fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
}
#endif
#if HAVE_MMX
if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & FF_MM_MMX)){
avctx->idct_algo= FF_IDCT_XVIDMMX;
avctx->coded_width= 0; // force reinit
// dsputil_init(&s->dsp, avctx);
s->picture_number=0;
}
#endif
/* After H263 & mpeg4 header decode we have the height, width,*/
/* and other parameters. So then we could init the picture */
/* FIXME: By the way H263 decoder is evolving it should have */
/* an H263EncContext */
if ( s->width != avctx->coded_width
|| s->height != avctx->coded_height) {
/* H.263 could change picture size any time */
ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
s->parse_context.buffer=0;
MPV_common_end(s);
s->parse_context= pc;
}
if (!s->context_initialized) {
avcodec_set_dimensions(avctx, s->width, s->height);
goto retry;
}
if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I))
s->gob_index = ff_h263_get_gob_height(s);
// for hurry_up==5
s->current_picture.pict_type= s->pict_type;
s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
/* skip B-frames if we don't have reference frames */
if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size);
/* skip b frames if we are in a hurry */
if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size);
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
|| (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
|| avctx->skip_frame >= AVDISCARD_ALL)
return get_consumed_bytes(s, buf_size);
/* skip everything if we are in a hurry>=5 */
if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
if(s->next_p_frame_damaged){
if(s->pict_type==FF_B_TYPE)
return get_consumed_bytes(s, buf_size);
else
s->next_p_frame_damaged=0;
}
if((s->avctx->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){
s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
}else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){
s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
}else{
s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
}
if(MPV_frame_start(s, avctx) < 0)
return -1;
if (avctx->hwaccel) {
if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
return -1;
}
#ifdef DEBUG
av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
#endif
ff_er_frame_start(s);
//the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
//which is not available before MPV_frame_start()
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){
ret = ff_wmv2_decode_secondary_picture_header(s);
if(ret<0) return ret;
if(ret==1) goto intrax8_decoded;
}
/* decode each macroblock */
s->mb_x=0;
s->mb_y=0;
decode_slice(s);
while(s->mb_y<s->mb_height){
if(s->msmpeg4_version){
if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
break;
}else{
if(ff_h263_resync(s)<0)
break;
}
if(s->msmpeg4_version<4 && s->h263_pred)
ff_mpeg4_clean_buffers(s);
decode_slice(s);
}
if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE)
if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, buf_size) < 0){
s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
}
/* divx 5.01+ bistream reorder stuff */
if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){
int current_pos= get_bits_count(&s->gb)>>3;
int startcode_found=0;
if(buf_size - current_pos > 5){
int i;
for(i=current_pos; i<buf_size-3; i++){
if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
startcode_found=1;
break;
}
}
}
if(s->gb.buffer == s->bitstream_buffer && buf_size>20){ //xvid style
startcode_found=1;
current_pos=0;
}
if(startcode_found){
av_fast_malloc(
&s->bitstream_buffer,
&s->allocated_bitstream_buffer_size,
buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE);
if (!s->bitstream_buffer)
return AVERROR(ENOMEM);
memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
s->bitstream_buffer_size= buf_size - current_pos;
}
}
intrax8_decoded:
ff_er_frame_end(s);
if (avctx->hwaccel) {
if (avctx->hwaccel->end_frame(avctx) < 0)
return -1;
}
MPV_frame_end(s);
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
assert(s->current_picture.pict_type == s->pict_type);
if (s->pict_type == FF_B_TYPE || s->low_delay) {
*pict= *(AVFrame*)s->current_picture_ptr;
} else if (s->last_picture_ptr != NULL) {
*pict= *(AVFrame*)s->last_picture_ptr;
}
if(s->last_picture_ptr || s->low_delay){
*data_size = sizeof(AVFrame);
ff_print_debug_info(s, pict);
}
/* Return the Picture timestamp as the frame number */
/* we subtract 1 because it is added on utils.c */
avctx->frame_number = s->picture_number - 1;
#ifdef PRINT_FRAME_TIME
av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
#endif
return get_consumed_bytes(s, buf_size);
}
| false | FFmpeg | 87e302bfd8ffbc6cdb20920029013956b10ace63 | int ff_h263_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MpegEncContext *s = avctx->priv_data;
int ret;
AVFrame *pict = data;
#ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc();
#endif
#ifdef DEBUG
av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
if(buf_size>0)
av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
#endif
s->flags= avctx->flags;
s->flags2= avctx->flags2;
if (buf_size == 0) {
if (s->low_delay==0 && s->next_picture_ptr) {
*pict= *(AVFrame*)s->next_picture_ptr;
s->next_picture_ptr= NULL;
*data_size = sizeof(AVFrame);
}
return 0;
}
if(s->flags&CODEC_FLAG_TRUNCATED){
int next;
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
}else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){
next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
}else{
av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
return -1;
}
if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
return buf_size;
}
retry:
if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){
init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
}else
init_get_bits(&s->gb, buf, buf_size*8);
s->bitstream_buffer_size=0;
if (!s->context_initialized) {
if (MPV_common_init(s) < 0)
return -1;
}
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
int i= ff_find_unused_picture(s, 0);
s->current_picture_ptr= &s->picture[i];
}
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) {
ret= ff_wmv2_decode_picture_header(s);
} else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {
ret = msmpeg4_decode_picture_header(s);
} else if (s->h263_pred) {
if(s->avctx->extradata_size && s->picture_number==0){
GetBitContext gb;
init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
ret = ff_mpeg4_decode_picture_header(s, &gb);
}
ret = ff_mpeg4_decode_picture_header(s, &s->gb);
} else if (s->codec_id == CODEC_ID_H263I) {
ret = intel_h263_decode_picture_header(s);
} else if (s->h263_flv) {
ret = flv_h263_decode_picture_header(s);
} else {
ret = h263_decode_picture_header(s);
}
if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size);
if (ret < 0){
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
return -1;
}
avctx->has_b_frames= !s->low_delay;
if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
if(s->stream_codec_tag == AV_RL32("XVID") ||
s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") ||
s->codec_tag == AV_RL32("RMP4"))
s->xvid_build= -1;
#if 0
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
&& s->padding_bug_score > 0 && s->low_delay)
s->xvid_build= -1;
#endif
}
if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
s->divx_version= 400;
}
if(s->xvid_build && s->divx_version){
s->divx_version=
s->divx_build= 0;
}
if(s->workaround_bugs&FF_BUG_AUTODETECT){
if(s->codec_tag == AV_RL32("XVIX"))
s->workaround_bugs|= FF_BUG_XVID_ILACE;
if(s->codec_tag == AV_RL32("UMP4")){
s->workaround_bugs|= FF_BUG_UMP4;
}
if(s->divx_version>=500 && s->divx_build<1814){
s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
}
if(s->divx_version>502 && s->divx_build<1814){
s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
}
if(s->xvid_build && s->xvid_build<=3)
s->padding_bug_score= 256*256*256*64;
if(s->xvid_build && s->xvid_build<=1)
s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
if(s->xvid_build && s->xvid_build<=12)
s->workaround_bugs|= FF_BUG_EDGE;
if(s->xvid_build && s->xvid_build<=32)
s->workaround_bugs|= FF_BUG_DC_CLIP;
#define SET_QPEL_FUNC(postfix1, postfix2) \
s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
if(s->lavc_build && s->lavc_build<4653)
s->workaround_bugs|= FF_BUG_STD_QPEL;
if(s->lavc_build && s->lavc_build<4655)
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
if(s->lavc_build && s->lavc_build<4670){
s->workaround_bugs|= FF_BUG_EDGE;
}
if(s->lavc_build && s->lavc_build<=4712)
s->workaround_bugs|= FF_BUG_DC_CLIP;
if(s->divx_version)
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
if(s->divx_version==501 && s->divx_build==20020416)
s->padding_bug_score= 256*256*256*64;
if(s->divx_version && s->divx_version<500){
s->workaround_bugs|= FF_BUG_EDGE;
}
if(s->divx_version)
s->workaround_bugs|= FF_BUG_HPEL_CHROMA;
#if 0
if(s->divx_version==500)
s->padding_bug_score= 256*256*256*64;
if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
&& s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
s->workaround_bugs|= FF_BUG_NO_PADDING;
if(s->lavc_build && s->lavc_build<4609)
s->workaround_bugs|= FF_BUG_NO_PADDING;
#endif
}
if(s->workaround_bugs& FF_BUG_STD_QPEL){
SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
}
if(avctx->debug & FF_DEBUG_BUGS)
av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,
s->divx_packed ? "p" : "");
#if 0
{
static FILE *f=NULL;
if(!f) f=fopen("rate_qp_cplx.txt", "w");
fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
}
#endif
#if HAVE_MMX
if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & FF_MM_MMX)){
avctx->idct_algo= FF_IDCT_XVIDMMX;
avctx->coded_width= 0;
s->picture_number=0;
}
#endif
if ( s->width != avctx->coded_width
|| s->height != avctx->coded_height) {
ParseContext pc= s->parse_context;
s->parse_context.buffer=0;
MPV_common_end(s);
s->parse_context= pc;
}
if (!s->context_initialized) {
avcodec_set_dimensions(avctx, s->width, s->height);
goto retry;
}
if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I))
s->gob_index = ff_h263_get_gob_height(s);
s->current_picture.pict_type= s->pict_type;
s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size);
if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size);
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
|| (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
|| avctx->skip_frame >= AVDISCARD_ALL)
return get_consumed_bytes(s, buf_size);
if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
if(s->next_p_frame_damaged){
if(s->pict_type==FF_B_TYPE)
return get_consumed_bytes(s, buf_size);
else
s->next_p_frame_damaged=0;
}
if((s->avctx->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){
s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
}else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){
s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
}else{
s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
}
if(MPV_frame_start(s, avctx) < 0)
return -1;
if (avctx->hwaccel) {
if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
return -1;
}
#ifdef DEBUG
av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
#endif
ff_er_frame_start(s);
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){
ret = ff_wmv2_decode_secondary_picture_header(s);
if(ret<0) return ret;
if(ret==1) goto intrax8_decoded;
}
s->mb_x=0;
s->mb_y=0;
decode_slice(s);
while(s->mb_y<s->mb_height){
if(s->msmpeg4_version){
if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
break;
}else{
if(ff_h263_resync(s)<0)
break;
}
if(s->msmpeg4_version<4 && s->h263_pred)
ff_mpeg4_clean_buffers(s);
decode_slice(s);
}
if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE)
if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, buf_size) < 0){
s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
}
if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){
int current_pos= get_bits_count(&s->gb)>>3;
int startcode_found=0;
if(buf_size - current_pos > 5){
int i;
for(i=current_pos; i<buf_size-3; i++){
if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
startcode_found=1;
break;
}
}
}
if(s->gb.buffer == s->bitstream_buffer && buf_size>20){
startcode_found=1;
current_pos=0;
}
if(startcode_found){
av_fast_malloc(
&s->bitstream_buffer,
&s->allocated_bitstream_buffer_size,
buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE);
if (!s->bitstream_buffer)
return AVERROR(ENOMEM);
memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
s->bitstream_buffer_size= buf_size - current_pos;
}
}
intrax8_decoded:
ff_er_frame_end(s);
if (avctx->hwaccel) {
if (avctx->hwaccel->end_frame(avctx) < 0)
return -1;
}
MPV_frame_end(s);
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
assert(s->current_picture.pict_type == s->pict_type);
if (s->pict_type == FF_B_TYPE || s->low_delay) {
*pict= *(AVFrame*)s->current_picture_ptr;
} else if (s->last_picture_ptr != NULL) {
*pict= *(AVFrame*)s->last_picture_ptr;
}
if(s->last_picture_ptr || s->low_delay){
*data_size = sizeof(AVFrame);
ff_print_debug_info(s, pict);
}
avctx->frame_number = s->picture_number - 1;
#ifdef PRINT_FRAME_TIME
av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
#endif
return get_consumed_bytes(s, buf_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;
int VAR_5 = VAR_3->size;
MpegEncContext *s = VAR_0->priv_data;
int VAR_6;
AVFrame *pict = VAR_1;
#ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc();
#endif
#ifdef DEBUG
av_log(VAR_0, AV_LOG_DEBUG, "*****frame %d size=%d\n", VAR_0->frame_number, VAR_5);
if(VAR_5>0)
av_log(VAR_0, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", VAR_4[0], VAR_4[1], VAR_4[2], VAR_4[3]);
#endif
s->flags= VAR_0->flags;
s->flags2= VAR_0->flags2;
if (VAR_5 == 0) {
if (s->low_delay==0 && s->next_picture_ptr) {
*pict= *(AVFrame*)s->next_picture_ptr;
s->next_picture_ptr= NULL;
*VAR_2 = sizeof(AVFrame);
}
return 0;
}
if(s->flags&CODEC_FLAG_TRUNCATED){
int VAR_7;
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
VAR_7= ff_mpeg4_find_frame_end(&s->parse_context, VAR_4, VAR_5);
}else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){
VAR_7= ff_h263_find_frame_end(&s->parse_context, VAR_4, VAR_5);
}else{
av_log(s->VAR_0, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
return -1;
}
if( ff_combine_frame(&s->parse_context, VAR_7, (const uint8_t **)&VAR_4, &VAR_5) < 0 )
return VAR_5;
}
retry:
if(s->bitstream_buffer_size && (s->divx_packed || VAR_5<20)){
init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
}else
init_get_bits(&s->gb, VAR_4, VAR_5*8);
s->bitstream_buffer_size=0;
if (!s->context_initialized) {
if (MPV_common_init(s) < 0)
return -1;
}
if(s->current_picture_ptr==NULL || s->current_picture_ptr->VAR_1[0]){
int VAR_11= ff_find_unused_picture(s, 0);
s->current_picture_ptr= &s->picture[VAR_11];
}
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) {
VAR_6= ff_wmv2_decode_picture_header(s);
} else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {
VAR_6 = msmpeg4_decode_picture_header(s);
} else if (s->h263_pred) {
if(s->VAR_0->extradata_size && s->picture_number==0){
GetBitContext gb;
init_get_bits(&gb, s->VAR_0->extradata, s->VAR_0->extradata_size*8);
VAR_6 = ff_mpeg4_decode_picture_header(s, &gb);
}
VAR_6 = ff_mpeg4_decode_picture_header(s, &s->gb);
} else if (s->codec_id == CODEC_ID_H263I) {
VAR_6 = intel_h263_decode_picture_header(s);
} else if (s->h263_flv) {
VAR_6 = flv_h263_decode_picture_header(s);
} else {
VAR_6 = h263_decode_picture_header(s);
}
if(VAR_6==FRAME_SKIPPED) return get_consumed_bytes(s, VAR_5);
if (VAR_6 < 0){
av_log(s->VAR_0, AV_LOG_ERROR, "header damaged\n");
return -1;
}
VAR_0->has_b_frames= !s->low_delay;
if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
if(s->stream_codec_tag == AV_RL32("XVID") ||
s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") ||
s->codec_tag == AV_RL32("RMP4"))
s->xvid_build= -1;
#if 0
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
&& s->padding_bug_score > 0 && s->low_delay)
s->xvid_build= -1;
#endif
}
if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
s->divx_version= 400;
}
if(s->xvid_build && s->divx_version){
s->divx_version=
s->divx_build= 0;
}
if(s->workaround_bugs&FF_BUG_AUTODETECT){
if(s->codec_tag == AV_RL32("XVIX"))
s->workaround_bugs|= FF_BUG_XVID_ILACE;
if(s->codec_tag == AV_RL32("UMP4")){
s->workaround_bugs|= FF_BUG_UMP4;
}
if(s->divx_version>=500 && s->divx_build<1814){
s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
}
if(s->divx_version>502 && s->divx_build<1814){
s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
}
if(s->xvid_build && s->xvid_build<=3)
s->padding_bug_score= 256*256*256*64;
if(s->xvid_build && s->xvid_build<=1)
s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
if(s->xvid_build && s->xvid_build<=12)
s->workaround_bugs|= FF_BUG_EDGE;
if(s->xvid_build && s->xvid_build<=32)
s->workaround_bugs|= FF_BUG_DC_CLIP;
#define SET_QPEL_FUNC(postfix1, postfix2) \
s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
if(s->lavc_build && s->lavc_build<4653)
s->workaround_bugs|= FF_BUG_STD_QPEL;
if(s->lavc_build && s->lavc_build<4655)
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
if(s->lavc_build && s->lavc_build<4670){
s->workaround_bugs|= FF_BUG_EDGE;
}
if(s->lavc_build && s->lavc_build<=4712)
s->workaround_bugs|= FF_BUG_DC_CLIP;
if(s->divx_version)
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
if(s->divx_version==501 && s->divx_build==20020416)
s->padding_bug_score= 256*256*256*64;
if(s->divx_version && s->divx_version<500){
s->workaround_bugs|= FF_BUG_EDGE;
}
if(s->divx_version)
s->workaround_bugs|= FF_BUG_HPEL_CHROMA;
#if 0
if(s->divx_version==500)
s->padding_bug_score= 256*256*256*64;
if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
&& s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
s->workaround_bugs|= FF_BUG_NO_PADDING;
if(s->lavc_build && s->lavc_build<4609)
s->workaround_bugs|= FF_BUG_NO_PADDING;
#endif
}
if(s->workaround_bugs& FF_BUG_STD_QPEL){
SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
}
if(VAR_0->debug & FF_DEBUG_BUGS)
av_log(s->VAR_0, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,
s->divx_packed ? "p" : "");
#if 0
{
static FILE *f=NULL;
if(!f) f=fopen("rate_qp_cplx.txt", "w");
fprintf(f, "%d %d %f\n", VAR_5, s->qscale, VAR_5*(double)s->qscale);
}
#endif
#if HAVE_MMX
if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && VAR_0->idct_algo == FF_IDCT_AUTO && (mm_flags & FF_MM_MMX)){
VAR_0->idct_algo= FF_IDCT_XVIDMMX;
VAR_0->coded_width= 0;
s->picture_number=0;
}
#endif
if ( s->width != VAR_0->coded_width
|| s->height != VAR_0->coded_height) {
ParseContext pc= s->parse_context;
s->parse_context.buffer=0;
MPV_common_end(s);
s->parse_context= pc;
}
if (!s->context_initialized) {
avcodec_set_dimensions(VAR_0, s->width, s->height);
goto retry;
}
if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I))
s->gob_index = ff_h263_get_gob_height(s);
s->current_picture.pict_type= s->pict_type;
s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, VAR_5);
if(VAR_0->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, VAR_5);
if( (VAR_0->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
|| (VAR_0->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
|| VAR_0->skip_frame >= AVDISCARD_ALL)
return get_consumed_bytes(s, VAR_5);
if(VAR_0->hurry_up>=5) return get_consumed_bytes(s, VAR_5);
if(s->next_p_frame_damaged){
if(s->pict_type==FF_B_TYPE)
return get_consumed_bytes(s, VAR_5);
else
s->next_p_frame_damaged=0;
}
if((s->VAR_0->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){
s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
}else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){
s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
}else{
s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
}
if(MPV_frame_start(s, VAR_0) < 0)
return -1;
if (VAR_0->hwaccel) {
if (VAR_0->hwaccel->start_frame(VAR_0, VAR_4, VAR_5) < 0)
return -1;
}
#ifdef DEBUG
av_log(VAR_0, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
#endif
ff_er_frame_start(s);
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){
VAR_6 = ff_wmv2_decode_secondary_picture_header(s);
if(VAR_6<0) return VAR_6;
if(VAR_6==1) goto intrax8_decoded;
}
s->mb_x=0;
s->mb_y=0;
decode_slice(s);
while(s->mb_y<s->mb_height){
if(s->msmpeg4_version){
if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
break;
}else{
if(ff_h263_resync(s)<0)
break;
}
if(s->msmpeg4_version<4 && s->h263_pred)
ff_mpeg4_clean_buffers(s);
decode_slice(s);
}
if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE)
if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, VAR_5) < 0){
s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
}
if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){
int VAR_9= get_bits_count(&s->gb)>>3;
int VAR_10=0;
if(VAR_5 - VAR_9 > 5){
int VAR_11;
for(VAR_11=VAR_9; VAR_11<VAR_5-3; VAR_11++){
if(VAR_4[VAR_11]==0 && VAR_4[VAR_11+1]==0 && VAR_4[VAR_11+2]==1 && VAR_4[VAR_11+3]==0xB6){
VAR_10=1;
break;
}
}
}
if(s->gb.buffer == s->bitstream_buffer && VAR_5>20){
VAR_10=1;
VAR_9=0;
}
if(VAR_10){
av_fast_malloc(
&s->bitstream_buffer,
&s->allocated_bitstream_buffer_size,
VAR_5 - VAR_9 + FF_INPUT_BUFFER_PADDING_SIZE);
if (!s->bitstream_buffer)
return AVERROR(ENOMEM);
memcpy(s->bitstream_buffer, VAR_4 + VAR_9, VAR_5 - VAR_9);
s->bitstream_buffer_size= VAR_5 - VAR_9;
}
}
intrax8_decoded:
ff_er_frame_end(s);
if (VAR_0->hwaccel) {
if (VAR_0->hwaccel->end_frame(VAR_0) < 0)
return -1;
}
MPV_frame_end(s);
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
assert(s->current_picture.pict_type == s->pict_type);
if (s->pict_type == FF_B_TYPE || s->low_delay) {
*pict= *(AVFrame*)s->current_picture_ptr;
} else if (s->last_picture_ptr != NULL) {
*pict= *(AVFrame*)s->last_picture_ptr;
}
if(s->last_picture_ptr || s->low_delay){
*VAR_2 = sizeof(AVFrame);
ff_print_debug_info(s, pict);
}
VAR_0->frame_number = s->picture_number - 1;
#ifdef PRINT_FRAME_TIME
av_log(VAR_0, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
#endif
return get_consumed_bytes(s, VAR_5);
}
| [
"int FUNC_0(AVCodecContext *VAR_0,\nvoid *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"MpegEncContext *s = VAR_0->priv_data;",
"int VAR_6;",
"AVFrame *pict = VAR_1;",
"#ifdef PRINT_FRAME_TIME\nuint64_t time= rdtsc();",
"#endif\n#ifdef DEBUG\nav_log(VAR_0, AV_LOG_DEBUG, \"*****frame %d size=%d\\n\", VAR_0->frame_number, VAR_5);",
"if(VAR_5>0)\nav_log(VAR_0, AV_LOG_DEBUG, \"bytes=%x %x %x %x\\n\", VAR_4[0], VAR_4[1], VAR_4[2], VAR_4[3]);",
"#endif\ns->flags= VAR_0->flags;",
"s->flags2= VAR_0->flags2;",
"if (VAR_5 == 0) {",
"if (s->low_delay==0 && s->next_picture_ptr) {",
"*pict= *(AVFrame*)s->next_picture_ptr;",
"s->next_picture_ptr= NULL;",
"*VAR_2 = sizeof(AVFrame);",
"}",
"return 0;",
"}",
"if(s->flags&CODEC_FLAG_TRUNCATED){",
"int VAR_7;",
"if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){",
"VAR_7= ff_mpeg4_find_frame_end(&s->parse_context, VAR_4, VAR_5);",
"}else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){",
"VAR_7= ff_h263_find_frame_end(&s->parse_context, VAR_4, VAR_5);",
"}else{",
"av_log(s->VAR_0, AV_LOG_ERROR, \"this codec does not support truncated bitstreams\\n\");",
"return -1;",
"}",
"if( ff_combine_frame(&s->parse_context, VAR_7, (const uint8_t **)&VAR_4, &VAR_5) < 0 )\nreturn VAR_5;",
"}",
"retry:\nif(s->bitstream_buffer_size && (s->divx_packed || VAR_5<20)){",
"init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);",
"}else",
"init_get_bits(&s->gb, VAR_4, VAR_5*8);",
"s->bitstream_buffer_size=0;",
"if (!s->context_initialized) {",
"if (MPV_common_init(s) < 0)\nreturn -1;",
"}",
"if(s->current_picture_ptr==NULL || s->current_picture_ptr->VAR_1[0]){",
"int VAR_11= ff_find_unused_picture(s, 0);",
"s->current_picture_ptr= &s->picture[VAR_11];",
"}",
"if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) {",
"VAR_6= ff_wmv2_decode_picture_header(s);",
"} else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {",
"VAR_6 = msmpeg4_decode_picture_header(s);",
"} else if (s->h263_pred) {",
"if(s->VAR_0->extradata_size && s->picture_number==0){",
"GetBitContext gb;",
"init_get_bits(&gb, s->VAR_0->extradata, s->VAR_0->extradata_size*8);",
"VAR_6 = ff_mpeg4_decode_picture_header(s, &gb);",
"}",
"VAR_6 = ff_mpeg4_decode_picture_header(s, &s->gb);",
"} else if (s->codec_id == CODEC_ID_H263I) {",
"VAR_6 = intel_h263_decode_picture_header(s);",
"} else if (s->h263_flv) {",
"VAR_6 = flv_h263_decode_picture_header(s);",
"} else {",
"VAR_6 = h263_decode_picture_header(s);",
"}",
"if(VAR_6==FRAME_SKIPPED) return get_consumed_bytes(s, VAR_5);",
"if (VAR_6 < 0){",
"av_log(s->VAR_0, AV_LOG_ERROR, \"header damaged\\n\");",
"return -1;",
"}",
"VAR_0->has_b_frames= !s->low_delay;",
"if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){",
"if(s->stream_codec_tag == AV_RL32(\"XVID\") ||\ns->codec_tag == AV_RL32(\"XVID\") || s->codec_tag == AV_RL32(\"XVIX\") ||\ns->codec_tag == AV_RL32(\"RMP4\"))\ns->xvid_build= -1;",
"#if 0\nif(s->codec_tag == AV_RL32(\"DIVX\") && s->vo_type==0 && s->vol_control_parameters==1\n&& s->padding_bug_score > 0 && s->low_delay)\ns->xvid_build= -1;",
"#endif\n}",
"if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){",
"if(s->codec_tag == AV_RL32(\"DIVX\") && s->vo_type==0 && s->vol_control_parameters==0)\ns->divx_version= 400;",
"}",
"if(s->xvid_build && s->divx_version){",
"s->divx_version=\ns->divx_build= 0;",
"}",
"if(s->workaround_bugs&FF_BUG_AUTODETECT){",
"if(s->codec_tag == AV_RL32(\"XVIX\"))\ns->workaround_bugs|= FF_BUG_XVID_ILACE;",
"if(s->codec_tag == AV_RL32(\"UMP4\")){",
"s->workaround_bugs|= FF_BUG_UMP4;",
"}",
"if(s->divx_version>=500 && s->divx_build<1814){",
"s->workaround_bugs|= FF_BUG_QPEL_CHROMA;",
"}",
"if(s->divx_version>502 && s->divx_build<1814){",
"s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;",
"}",
"if(s->xvid_build && s->xvid_build<=3)\ns->padding_bug_score= 256*256*256*64;",
"if(s->xvid_build && s->xvid_build<=1)\ns->workaround_bugs|= FF_BUG_QPEL_CHROMA;",
"if(s->xvid_build && s->xvid_build<=12)\ns->workaround_bugs|= FF_BUG_EDGE;",
"if(s->xvid_build && s->xvid_build<=32)\ns->workaround_bugs|= FF_BUG_DC_CLIP;",
"#define SET_QPEL_FUNC(postfix1, postfix2) \\\ns->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\\",
"s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\\",
"s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;",
"if(s->lavc_build && s->lavc_build<4653)\ns->workaround_bugs|= FF_BUG_STD_QPEL;",
"if(s->lavc_build && s->lavc_build<4655)\ns->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;",
"if(s->lavc_build && s->lavc_build<4670){",
"s->workaround_bugs|= FF_BUG_EDGE;",
"}",
"if(s->lavc_build && s->lavc_build<=4712)\ns->workaround_bugs|= FF_BUG_DC_CLIP;",
"if(s->divx_version)\ns->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;",
"if(s->divx_version==501 && s->divx_build==20020416)\ns->padding_bug_score= 256*256*256*64;",
"if(s->divx_version && s->divx_version<500){",
"s->workaround_bugs|= FF_BUG_EDGE;",
"}",
"if(s->divx_version)\ns->workaround_bugs|= FF_BUG_HPEL_CHROMA;",
"#if 0\nif(s->divx_version==500)\ns->padding_bug_score= 256*256*256*64;",
"if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0\n&& s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)\ns->workaround_bugs|= FF_BUG_NO_PADDING;",
"if(s->lavc_build && s->lavc_build<4609)\ns->workaround_bugs|= FF_BUG_NO_PADDING;",
"#endif\n}",
"if(s->workaround_bugs& FF_BUG_STD_QPEL){",
"SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)\nSET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)\n}",
"if(VAR_0->debug & FF_DEBUG_BUGS)\nav_log(s->VAR_0, AV_LOG_DEBUG, \"bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\\n\",\ns->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,\ns->divx_packed ? \"p\" : \"\");",
"#if 0\n{",
"static FILE *f=NULL;",
"if(!f) f=fopen(\"rate_qp_cplx.txt\", \"w\");",
"fprintf(f, \"%d %d %f\\n\", VAR_5, s->qscale, VAR_5*(double)s->qscale);",
"}",
"#endif\n#if HAVE_MMX\nif(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && VAR_0->idct_algo == FF_IDCT_AUTO && (mm_flags & FF_MM_MMX)){",
"VAR_0->idct_algo= FF_IDCT_XVIDMMX;",
"VAR_0->coded_width= 0;",
"s->picture_number=0;",
"}",
"#endif\nif ( s->width != VAR_0->coded_width\n|| s->height != VAR_0->coded_height) {",
"ParseContext pc= s->parse_context;",
"s->parse_context.buffer=0;",
"MPV_common_end(s);",
"s->parse_context= pc;",
"}",
"if (!s->context_initialized) {",
"avcodec_set_dimensions(VAR_0, s->width, s->height);",
"goto retry;",
"}",
"if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I))\ns->gob_index = ff_h263_get_gob_height(s);",
"s->current_picture.pict_type= s->pict_type;",
"s->current_picture.key_frame= s->pict_type == FF_I_TYPE;",
"if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, VAR_5);",
"if(VAR_0->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, VAR_5);",
"if( (VAR_0->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)\n|| (VAR_0->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)\n|| VAR_0->skip_frame >= AVDISCARD_ALL)\nreturn get_consumed_bytes(s, VAR_5);",
"if(VAR_0->hurry_up>=5) return get_consumed_bytes(s, VAR_5);",
"if(s->next_p_frame_damaged){",
"if(s->pict_type==FF_B_TYPE)\nreturn get_consumed_bytes(s, VAR_5);",
"else\ns->next_p_frame_damaged=0;",
"}",
"if((s->VAR_0->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){",
"s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;",
"s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;",
"}else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){",
"s->me.qpel_put= s->dsp.put_qpel_pixels_tab;",
"s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;",
"}else{",
"s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab;",
"s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;",
"}",
"if(MPV_frame_start(s, VAR_0) < 0)\nreturn -1;",
"if (VAR_0->hwaccel) {",
"if (VAR_0->hwaccel->start_frame(VAR_0, VAR_4, VAR_5) < 0)\nreturn -1;",
"}",
"#ifdef DEBUG\nav_log(VAR_0, AV_LOG_DEBUG, \"qscale=%d\\n\", s->qscale);",
"#endif\nff_er_frame_start(s);",
"if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){",
"VAR_6 = ff_wmv2_decode_secondary_picture_header(s);",
"if(VAR_6<0) return VAR_6;",
"if(VAR_6==1) goto intrax8_decoded;",
"}",
"s->mb_x=0;",
"s->mb_y=0;",
"decode_slice(s);",
"while(s->mb_y<s->mb_height){",
"if(s->msmpeg4_version){",
"if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)\nbreak;",
"}else{",
"if(ff_h263_resync(s)<0)\nbreak;",
"}",
"if(s->msmpeg4_version<4 && s->h263_pred)\nff_mpeg4_clean_buffers(s);",
"decode_slice(s);",
"}",
"if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE)\nif(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, VAR_5) < 0){",
"s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;",
"}",
"if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){",
"int VAR_9= get_bits_count(&s->gb)>>3;",
"int VAR_10=0;",
"if(VAR_5 - VAR_9 > 5){",
"int VAR_11;",
"for(VAR_11=VAR_9; VAR_11<VAR_5-3; VAR_11++){",
"if(VAR_4[VAR_11]==0 && VAR_4[VAR_11+1]==0 && VAR_4[VAR_11+2]==1 && VAR_4[VAR_11+3]==0xB6){",
"VAR_10=1;",
"break;",
"}",
"}",
"}",
"if(s->gb.buffer == s->bitstream_buffer && VAR_5>20){",
"VAR_10=1;",
"VAR_9=0;",
"}",
"if(VAR_10){",
"av_fast_malloc(\n&s->bitstream_buffer,\n&s->allocated_bitstream_buffer_size,\nVAR_5 - VAR_9 + FF_INPUT_BUFFER_PADDING_SIZE);",
"if (!s->bitstream_buffer)\nreturn AVERROR(ENOMEM);",
"memcpy(s->bitstream_buffer, VAR_4 + VAR_9, VAR_5 - VAR_9);",
"s->bitstream_buffer_size= VAR_5 - VAR_9;",
"}",
"}",
"intrax8_decoded:\nff_er_frame_end(s);",
"if (VAR_0->hwaccel) {",
"if (VAR_0->hwaccel->end_frame(VAR_0) < 0)\nreturn -1;",
"}",
"MPV_frame_end(s);",
"assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);",
"assert(s->current_picture.pict_type == s->pict_type);",
"if (s->pict_type == FF_B_TYPE || s->low_delay) {",
"*pict= *(AVFrame*)s->current_picture_ptr;",
"} else if (s->last_picture_ptr != NULL) {",
"*pict= *(AVFrame*)s->last_picture_ptr;",
"}",
"if(s->last_picture_ptr || s->low_delay){",
"*VAR_2 = sizeof(AVFrame);",
"ff_print_debug_info(s, pict);",
"}",
"VAR_0->frame_number = s->picture_number - 1;",
"#ifdef PRINT_FRAME_TIME\nav_log(VAR_0, AV_LOG_DEBUG, \"%\"PRId64\"\\n\", rdtsc()-time);",
"#endif\nreturn get_consumed_bytes(s, VAR_5);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21,
23
],
[
25,
27,
29
],
[
31,
33
],
[
35,
37
],
[
39
],
[
45
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
63
],
[
65
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
93,
95
],
[
97
],
[
103,
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119
],
[
121,
123
],
[
125
],
[
133
],
[
135
],
[
137
],
[
139
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
185
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201
],
[
205
],
[
207,
209,
211,
213
],
[
215,
217,
219,
221
],
[
223,
225
],
[
229
],
[
231,
233
],
[
235
],
[
239
],
[
241,
243
],
[
245
],
[
249
],
[
251,
253
],
[
257
],
[
259
],
[
261
],
[
265
],
[
267
],
[
269
],
[
273
],
[
275
],
[
277
],
[
281,
283
],
[
287,
289
],
[
293,
295
],
[
299,
301
],
[
305,
307
],
[
309
],
[
311
],
[
315,
317
],
[
321,
323
],
[
327
],
[
329
],
[
331
],
[
335,
337
],
[
341,
343
],
[
347,
349
],
[
353
],
[
355
],
[
357
],
[
361,
363
],
[
365,
367,
369
],
[
379,
381,
383
],
[
387,
389
],
[
391,
393
],
[
397
],
[
399,
401,
403,
405,
407,
409,
413,
415,
417,
419,
421,
423,
425
],
[
429,
431,
433,
435
],
[
439,
441
],
[
443
],
[
445
],
[
447
],
[
449
],
[
451,
455,
457
],
[
459
],
[
461
],
[
465
],
[
467
],
[
469,
483,
485
],
[
489
],
[
491
],
[
493
],
[
495
],
[
497
],
[
499
],
[
501
],
[
505
],
[
507
],
[
511,
513
],
[
519
],
[
521
],
[
527
],
[
531
],
[
533,
535,
537,
539
],
[
543
],
[
547
],
[
549,
551
],
[
553,
555
],
[
557
],
[
561
],
[
563
],
[
565
],
[
567
],
[
569
],
[
571
],
[
573
],
[
575
],
[
577
],
[
579
],
[
583,
585
],
[
589
],
[
591,
593
],
[
595
],
[
599,
601
],
[
603,
607
],
[
615
],
[
617
],
[
619
],
[
621
],
[
623
],
[
629
],
[
631
],
[
635
],
[
637
],
[
639
],
[
641,
643
],
[
645
],
[
647,
649
],
[
651
],
[
655,
657
],
[
661
],
[
663
],
[
667,
669
],
[
671
],
[
673
],
[
679
],
[
681
],
[
683
],
[
687
],
[
689
],
[
691
],
[
693
],
[
695
],
[
697
],
[
699
],
[
701
],
[
703
],
[
705
],
[
707
],
[
709
],
[
711
],
[
715
],
[
717,
719,
721,
723
],
[
725,
727
],
[
729
],
[
731
],
[
733
],
[
735
],
[
739,
741
],
[
745
],
[
747,
749
],
[
751
],
[
755
],
[
759
],
[
761
],
[
763
],
[
765
],
[
767
],
[
769
],
[
771
],
[
775
],
[
777
],
[
779
],
[
781
],
[
789
],
[
793,
795
],
[
797,
801
],
[
803
]
] |
21,603 | static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
{
AVFrame *decoded_frame, *filtered_frame = NULL;
void *buffer_to_free = NULL;
int i, ret = 0;
float quality;
#if CONFIG_AVFILTER
int frame_available = 1;
#endif
if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM);
else
avcodec_get_frame_defaults(ist->decoded_frame);
decoded_frame = ist->decoded_frame;
pkt->pts = *pkt_pts;
pkt->dts = ist->last_dts;
*pkt_pts = AV_NOPTS_VALUE;
ret = avcodec_decode_video2(ist->st->codec,
decoded_frame, got_output, pkt);
if (ret < 0)
return ret;
quality = same_quant ? decoded_frame->quality : 0;
if (!*got_output) {
/* no picture yet */
return ret;
}
decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
decoded_frame->pkt_dts);
pkt->size = 0;
pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
rate_emu_sleep(ist);
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = &output_streams[i];
int frame_size, resample_changed;
if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
continue;
#if CONFIG_AVFILTER
resample_changed = ost->resample_width != decoded_frame->width ||
ost->resample_height != decoded_frame->height ||
ost->resample_pix_fmt != decoded_frame->format;
if (resample_changed) {
av_log(NULL, AV_LOG_INFO,
"Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
ist->file_index, ist->st->index,
ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
avfilter_graph_free(&ost->graph);
if (configure_video_filters(ist, ost)) {
av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
exit_program(1);
}
ost->resample_width = decoded_frame->width;
ost->resample_height = decoded_frame->height;
ost->resample_pix_fmt = decoded_frame->format;
}
if (ist->st->sample_aspect_ratio.num)
decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
FrameBuffer *buf = decoded_frame->opaque;
AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
decoded_frame->data, decoded_frame->linesize,
AV_PERM_READ | AV_PERM_PRESERVE,
ist->st->codec->width, ist->st->codec->height,
ist->st->codec->pix_fmt);
avfilter_copy_frame_props(fb, decoded_frame);
fb->buf->priv = buf;
fb->buf->free = filter_release_buffer;
buf->refcount++;
av_buffersrc_buffer(ost->input_video_filter, fb);
} else
av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
decoded_frame->pts, decoded_frame->sample_aspect_ratio);
if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
av_free(buffer_to_free);
return AVERROR(ENOMEM);
} else
avcodec_get_frame_defaults(ist->filtered_frame);
filtered_frame = ist->filtered_frame;
frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
while (frame_available) {
AVRational ist_pts_tb;
if (ost->output_video_filter)
get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
if (ost->picref)
filtered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
if (ost->picref->video && !ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
#else
filtered_frame = decoded_frame;
#endif
do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
same_quant ? quality : ost->st->codec->global_quality);
if (vstats_filename && frame_size)
do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
#if CONFIG_AVFILTER
frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
if (ost->picref)
avfilter_unref_buffer(ost->picref);
}
#endif
}
av_free(buffer_to_free);
return ret;
}
| false | FFmpeg | 2636e691ce5347756a2c05b3105b0277c1b9acb4 | static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
{
AVFrame *decoded_frame, *filtered_frame = NULL;
void *buffer_to_free = NULL;
int i, ret = 0;
float quality;
#if CONFIG_AVFILTER
int frame_available = 1;
#endif
if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM);
else
avcodec_get_frame_defaults(ist->decoded_frame);
decoded_frame = ist->decoded_frame;
pkt->pts = *pkt_pts;
pkt->dts = ist->last_dts;
*pkt_pts = AV_NOPTS_VALUE;
ret = avcodec_decode_video2(ist->st->codec,
decoded_frame, got_output, pkt);
if (ret < 0)
return ret;
quality = same_quant ? decoded_frame->quality : 0;
if (!*got_output) {
return ret;
}
decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
decoded_frame->pkt_dts);
pkt->size = 0;
pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
rate_emu_sleep(ist);
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = &output_streams[i];
int frame_size, resample_changed;
if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
continue;
#if CONFIG_AVFILTER
resample_changed = ost->resample_width != decoded_frame->width ||
ost->resample_height != decoded_frame->height ||
ost->resample_pix_fmt != decoded_frame->format;
if (resample_changed) {
av_log(NULL, AV_LOG_INFO,
"Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
ist->file_index, ist->st->index,
ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
avfilter_graph_free(&ost->graph);
if (configure_video_filters(ist, ost)) {
av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
exit_program(1);
}
ost->resample_width = decoded_frame->width;
ost->resample_height = decoded_frame->height;
ost->resample_pix_fmt = decoded_frame->format;
}
if (ist->st->sample_aspect_ratio.num)
decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
FrameBuffer *buf = decoded_frame->opaque;
AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
decoded_frame->data, decoded_frame->linesize,
AV_PERM_READ | AV_PERM_PRESERVE,
ist->st->codec->width, ist->st->codec->height,
ist->st->codec->pix_fmt);
avfilter_copy_frame_props(fb, decoded_frame);
fb->buf->priv = buf;
fb->buf->free = filter_release_buffer;
buf->refcount++;
av_buffersrc_buffer(ost->input_video_filter, fb);
} else
av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
decoded_frame->pts, decoded_frame->sample_aspect_ratio);
if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
av_free(buffer_to_free);
return AVERROR(ENOMEM);
} else
avcodec_get_frame_defaults(ist->filtered_frame);
filtered_frame = ist->filtered_frame;
frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
while (frame_available) {
AVRational ist_pts_tb;
if (ost->output_video_filter)
get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
if (ost->picref)
filtered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
if (ost->picref->video && !ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
#else
filtered_frame = decoded_frame;
#endif
do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
same_quant ? quality : ost->st->codec->global_quality);
if (vstats_filename && frame_size)
do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
#if CONFIG_AVFILTER
frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
if (ost->picref)
avfilter_unref_buffer(ost->picref);
}
#endif
}
av_free(buffer_to_free);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(InputStream *VAR_0, AVPacket *VAR_1, int *VAR_2, int64_t *VAR_3)
{
AVFrame *decoded_frame, *filtered_frame = NULL;
void *VAR_4 = NULL;
int VAR_5, VAR_6 = 0;
float VAR_7;
#if CONFIG_AVFILTER
int frame_available = 1;
#endif
if (!VAR_0->decoded_frame && !(VAR_0->decoded_frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM);
else
avcodec_get_frame_defaults(VAR_0->decoded_frame);
decoded_frame = VAR_0->decoded_frame;
VAR_1->pts = *VAR_3;
VAR_1->dts = VAR_0->last_dts;
*VAR_3 = AV_NOPTS_VALUE;
VAR_6 = avcodec_decode_video2(VAR_0->st->codec,
decoded_frame, VAR_2, VAR_1);
if (VAR_6 < 0)
return VAR_6;
VAR_7 = same_quant ? decoded_frame->VAR_7 : 0;
if (!*VAR_2) {
return VAR_6;
}
decoded_frame->pts = guess_correct_pts(&VAR_0->pts_ctx, decoded_frame->VAR_3,
decoded_frame->pkt_dts);
VAR_1->size = 0;
pre_process_video_frame(VAR_0, (AVPicture *)decoded_frame, &VAR_4);
rate_emu_sleep(VAR_0);
for (VAR_5 = 0; VAR_5 < nb_output_streams; VAR_5++) {
OutputStream *ost = &output_streams[VAR_5];
int frame_size, resample_changed;
if (!check_output_constraints(VAR_0, ost) || !ost->encoding_needed)
continue;
#if CONFIG_AVFILTER
resample_changed = ost->resample_width != decoded_frame->width ||
ost->resample_height != decoded_frame->height ||
ost->resample_pix_fmt != decoded_frame->format;
if (resample_changed) {
av_log(NULL, AV_LOG_INFO,
"Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
VAR_0->file_index, VAR_0->st->index,
ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
avfilter_graph_free(&ost->graph);
if (configure_video_filters(VAR_0, ost)) {
av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
exit_program(1);
}
ost->resample_width = decoded_frame->width;
ost->resample_height = decoded_frame->height;
ost->resample_pix_fmt = decoded_frame->format;
}
if (VAR_0->st->sample_aspect_ratio.num)
decoded_frame->sample_aspect_ratio = VAR_0->st->sample_aspect_ratio;
if (VAR_0->st->codec->codec->capabilities & CODEC_CAP_DR1) {
FrameBuffer *buf = decoded_frame->opaque;
AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
decoded_frame->data, decoded_frame->linesize,
AV_PERM_READ | AV_PERM_PRESERVE,
VAR_0->st->codec->width, VAR_0->st->codec->height,
VAR_0->st->codec->pix_fmt);
avfilter_copy_frame_props(fb, decoded_frame);
fb->buf->priv = buf;
fb->buf->free = filter_release_buffer;
buf->refcount++;
av_buffersrc_buffer(ost->input_video_filter, fb);
} else
av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
decoded_frame->pts, decoded_frame->sample_aspect_ratio);
if (!VAR_0->filtered_frame && !(VAR_0->filtered_frame = avcodec_alloc_frame())) {
av_free(VAR_4);
return AVERROR(ENOMEM);
} else
avcodec_get_frame_defaults(VAR_0->filtered_frame);
filtered_frame = VAR_0->filtered_frame;
frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
while (frame_available) {
AVRational ist_pts_tb;
if (ost->output_video_filter)
get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
if (ost->picref)
filtered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
if (ost->picref->video && !ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
#else
filtered_frame = decoded_frame;
#endif
do_video_out(output_files[ost->file_index].ctx, ost, VAR_0, filtered_frame, &frame_size,
same_quant ? VAR_7 : ost->st->codec->global_quality);
if (vstats_filename && frame_size)
do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
#if CONFIG_AVFILTER
frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
if (ost->picref)
avfilter_unref_buffer(ost->picref);
}
#endif
}
av_free(VAR_4);
return VAR_6;
}
| [
"static int FUNC_0(InputStream *VAR_0, AVPacket *VAR_1, int *VAR_2, int64_t *VAR_3)\n{",
"AVFrame *decoded_frame, *filtered_frame = NULL;",
"void *VAR_4 = NULL;",
"int VAR_5, VAR_6 = 0;",
"float VAR_7;",
"#if CONFIG_AVFILTER\nint frame_available = 1;",
"#endif\nif (!VAR_0->decoded_frame && !(VAR_0->decoded_frame = avcodec_alloc_frame()))\nreturn AVERROR(ENOMEM);",
"else\navcodec_get_frame_defaults(VAR_0->decoded_frame);",
"decoded_frame = VAR_0->decoded_frame;",
"VAR_1->pts = *VAR_3;",
"VAR_1->dts = VAR_0->last_dts;",
"*VAR_3 = AV_NOPTS_VALUE;",
"VAR_6 = avcodec_decode_video2(VAR_0->st->codec,\ndecoded_frame, VAR_2, VAR_1);",
"if (VAR_6 < 0)\nreturn VAR_6;",
"VAR_7 = same_quant ? decoded_frame->VAR_7 : 0;",
"if (!*VAR_2) {",
"return VAR_6;",
"}",
"decoded_frame->pts = guess_correct_pts(&VAR_0->pts_ctx, decoded_frame->VAR_3,\ndecoded_frame->pkt_dts);",
"VAR_1->size = 0;",
"pre_process_video_frame(VAR_0, (AVPicture *)decoded_frame, &VAR_4);",
"rate_emu_sleep(VAR_0);",
"for (VAR_5 = 0; VAR_5 < nb_output_streams; VAR_5++) {",
"OutputStream *ost = &output_streams[VAR_5];",
"int frame_size, resample_changed;",
"if (!check_output_constraints(VAR_0, ost) || !ost->encoding_needed)\ncontinue;",
"#if CONFIG_AVFILTER\nresample_changed = ost->resample_width != decoded_frame->width ||\nost->resample_height != decoded_frame->height ||\nost->resample_pix_fmt != decoded_frame->format;",
"if (resample_changed) {",
"av_log(NULL, AV_LOG_INFO,\n\"Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\\n\",\nVAR_0->file_index, VAR_0->st->index,\nost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),\ndecoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));",
"avfilter_graph_free(&ost->graph);",
"if (configure_video_filters(VAR_0, ost)) {",
"av_log(NULL, AV_LOG_FATAL, \"Error reinitializing filters!\\n\");",
"exit_program(1);",
"}",
"ost->resample_width = decoded_frame->width;",
"ost->resample_height = decoded_frame->height;",
"ost->resample_pix_fmt = decoded_frame->format;",
"}",
"if (VAR_0->st->sample_aspect_ratio.num)\ndecoded_frame->sample_aspect_ratio = VAR_0->st->sample_aspect_ratio;",
"if (VAR_0->st->codec->codec->capabilities & CODEC_CAP_DR1) {",
"FrameBuffer *buf = decoded_frame->opaque;",
"AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(\ndecoded_frame->data, decoded_frame->linesize,\nAV_PERM_READ | AV_PERM_PRESERVE,\nVAR_0->st->codec->width, VAR_0->st->codec->height,\nVAR_0->st->codec->pix_fmt);",
"avfilter_copy_frame_props(fb, decoded_frame);",
"fb->buf->priv = buf;",
"fb->buf->free = filter_release_buffer;",
"buf->refcount++;",
"av_buffersrc_buffer(ost->input_video_filter, fb);",
"} else",
"av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,\ndecoded_frame->pts, decoded_frame->sample_aspect_ratio);",
"if (!VAR_0->filtered_frame && !(VAR_0->filtered_frame = avcodec_alloc_frame())) {",
"av_free(VAR_4);",
"return AVERROR(ENOMEM);",
"} else",
"avcodec_get_frame_defaults(VAR_0->filtered_frame);",
"filtered_frame = VAR_0->filtered_frame;",
"frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);",
"while (frame_available) {",
"AVRational ist_pts_tb;",
"if (ost->output_video_filter)\nget_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);",
"if (ost->picref)\nfiltered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);",
"if (ost->picref->video && !ost->frame_aspect_ratio)\nost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;",
"#else\nfiltered_frame = decoded_frame;",
"#endif\ndo_video_out(output_files[ost->file_index].ctx, ost, VAR_0, filtered_frame, &frame_size,\nsame_quant ? VAR_7 : ost->st->codec->global_quality);",
"if (vstats_filename && frame_size)\ndo_video_stats(output_files[ost->file_index].ctx, ost, frame_size);",
"#if CONFIG_AVFILTER\nframe_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);",
"if (ost->picref)\navfilter_unref_buffer(ost->picref);",
"}",
"#endif\n}",
"av_free(VAR_4);",
"return VAR_6;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17,
21,
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39,
41
],
[
43,
45
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
69
],
[
73
],
[
75
],
[
77
],
[
81,
83
],
[
87,
89,
91,
93
],
[
95
],
[
97,
99,
101,
103,
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131,
133
],
[
135
],
[
137
],
[
139,
141,
143,
145,
147
],
[
151
],
[
153
],
[
155
],
[
159
],
[
161
],
[
163
],
[
165,
167
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
185
],
[
187
],
[
189
],
[
191,
193
],
[
195,
197
],
[
199,
201
],
[
203,
205
],
[
207,
211,
213
],
[
215,
217
],
[
219,
221
],
[
223,
225
],
[
227
],
[
229,
231
],
[
235
],
[
237
],
[
239
]
] |
21,604 | enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
{
if (bps > 64U)
return AV_CODEC_ID_NONE;
if (flt) {
switch (bps) {
case 32:
return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
case 64:
return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
default:
return AV_CODEC_ID_NONE;
}
} else {
bps += 7;
bps >>= 3;
if (sflags & (1 << (bps - 1))) {
switch (bps) {
case 1:
return AV_CODEC_ID_PCM_S8;
case 2:
return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
case 3:
return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
case 4:
return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
default:
return AV_CODEC_ID_NONE;
}
} else {
switch (bps) {
case 1:
return AV_CODEC_ID_PCM_U8;
case 2:
return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
case 3:
return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
case 4:
return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
default:
return AV_CODEC_ID_NONE;
}
}
}
}
| false | FFmpeg | 2875745d354ab0ebc4af1ebaca5c5a8d26ccdc03 | enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
{
if (bps > 64U)
return AV_CODEC_ID_NONE;
if (flt) {
switch (bps) {
case 32:
return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
case 64:
return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
default:
return AV_CODEC_ID_NONE;
}
} else {
bps += 7;
bps >>= 3;
if (sflags & (1 << (bps - 1))) {
switch (bps) {
case 1:
return AV_CODEC_ID_PCM_S8;
case 2:
return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
case 3:
return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
case 4:
return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
default:
return AV_CODEC_ID_NONE;
}
} else {
switch (bps) {
case 1:
return AV_CODEC_ID_PCM_U8;
case 2:
return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
case 3:
return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
case 4:
return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
default:
return AV_CODEC_ID_NONE;
}
}
}
}
| {
"code": [],
"line_no": []
} | enum AVCodecID FUNC_0(int VAR_0, int VAR_1, int VAR_2, int VAR_3)
{
if (VAR_0 > 64U)
return AV_CODEC_ID_NONE;
if (VAR_1) {
switch (VAR_0) {
case 32:
return VAR_2 ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
case 64:
return VAR_2 ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
default:
return AV_CODEC_ID_NONE;
}
} else {
VAR_0 += 7;
VAR_0 >>= 3;
if (VAR_3 & (1 << (VAR_0 - 1))) {
switch (VAR_0) {
case 1:
return AV_CODEC_ID_PCM_S8;
case 2:
return VAR_2 ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
case 3:
return VAR_2 ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
case 4:
return VAR_2 ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
default:
return AV_CODEC_ID_NONE;
}
} else {
switch (VAR_0) {
case 1:
return AV_CODEC_ID_PCM_U8;
case 2:
return VAR_2 ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
case 3:
return VAR_2 ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
case 4:
return VAR_2 ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
default:
return AV_CODEC_ID_NONE;
}
}
}
}
| [
"enum AVCodecID FUNC_0(int VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{",
"if (VAR_0 > 64U)\nreturn AV_CODEC_ID_NONE;",
"if (VAR_1) {",
"switch (VAR_0) {",
"case 32:\nreturn VAR_2 ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;",
"case 64:\nreturn VAR_2 ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;",
"default:\nreturn AV_CODEC_ID_NONE;",
"}",
"} else {",
"VAR_0 += 7;",
"VAR_0 >>= 3;",
"if (VAR_3 & (1 << (VAR_0 - 1))) {",
"switch (VAR_0) {",
"case 1:\nreturn AV_CODEC_ID_PCM_S8;",
"case 2:\nreturn VAR_2 ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;",
"case 3:\nreturn VAR_2 ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;",
"case 4:\nreturn VAR_2 ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;",
"default:\nreturn AV_CODEC_ID_NONE;",
"}",
"} else {",
"switch (VAR_0) {",
"case 1:\nreturn AV_CODEC_ID_PCM_U8;",
"case 2:\nreturn VAR_2 ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;",
"case 3:\nreturn VAR_2 ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;",
"case 4:\nreturn VAR_2 ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;",
"default:\nreturn AV_CODEC_ID_NONE;",
"}",
"}",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
11
],
[
13
],
[
15,
17
],
[
19,
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
41
],
[
43,
45
],
[
47,
49
],
[
51,
53
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65,
67
],
[
69,
71
],
[
73,
75
],
[
77,
79
],
[
81,
83
],
[
85
],
[
87
],
[
89
],
[
91
]
] |
21,605 | static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max)
{
int sb, j, k, n, ch, run, channels;
int joined_stereo, zero_encoding, chs;
int type34_first;
float type34_div = 0;
float type34_predictor;
float samples[10], sign_bits[16];
if (length == 0) {
// If no data use noise
for (sb=sb_min; sb < sb_max; sb++)
build_sb_samples_from_noise (q, sb);
return 0;
}
for (sb = sb_min; sb < sb_max; sb++) {
FIX_NOISE_IDX(q->noise_idx);
channels = q->nb_channels;
if (q->nb_channels <= 1 || sb < 12)
joined_stereo = 0;
else if (sb >= 24)
joined_stereo = 1;
else
joined_stereo = (BITS_LEFT(length,gb) >= 1) ? get_bits1 (gb) : 0;
if (joined_stereo) {
if (BITS_LEFT(length,gb) >= 16)
for (j = 0; j < 16; j++)
sign_bits[j] = get_bits1 (gb);
for (j = 0; j < 64; j++)
if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])
q->coding_method[0][sb][j] = q->coding_method[1][sb][j];
fix_coding_method_array(sb, q->nb_channels, q->coding_method);
channels = 1;
}
for (ch = 0; ch < channels; ch++) {
zero_encoding = (BITS_LEFT(length,gb) >= 1) ? get_bits1(gb) : 0;
type34_predictor = 0.0;
type34_first = 1;
for (j = 0; j < 128; ) {
switch (q->coding_method[ch][sb][j / 2]) {
case 8:
if (BITS_LEFT(length,gb) >= 10) {
if (zero_encoding) {
for (k = 0; k < 5; k++) {
if ((j + 2 * k) >= 128)
break;
samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0;
}
} else {
n = get_bits(gb, 8);
for (k = 0; k < 5; k++)
samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
}
for (k = 0; k < 5; k++)
samples[2 * k + 1] = SB_DITHERING_NOISE(sb,q->noise_idx);
} else {
for (k = 0; k < 10; k++)
samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 10;
break;
case 10:
if (BITS_LEFT(length,gb) >= 1) {
float f = 0.81;
if (get_bits1(gb))
f = -f;
f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;
samples[0] = f;
} else {
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 1;
break;
case 16:
if (BITS_LEFT(length,gb) >= 10) {
if (zero_encoding) {
for (k = 0; k < 5; k++) {
if ((j + k) >= 128)
break;
samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)];
}
} else {
n = get_bits (gb, 8);
for (k = 0; k < 5; k++)
samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
}
} else {
for (k = 0; k < 5; k++)
samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 5;
break;
case 24:
if (BITS_LEFT(length,gb) >= 7) {
n = get_bits(gb, 7);
for (k = 0; k < 3; k++)
samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;
} else {
for (k = 0; k < 3; k++)
samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 3;
break;
case 30:
if (BITS_LEFT(length,gb) >= 4)
samples[0] = type30_dequant[qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1)];
else
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
run = 1;
break;
case 34:
if (BITS_LEFT(length,gb) >= 7) {
if (type34_first) {
type34_div = (float)(1 << get_bits(gb, 2));
samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0;
type34_predictor = samples[0];
type34_first = 0;
} else {
unsigned v = qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1);
if (v >= FF_ARRAY_ELEMS(type34_delta))
return AVERROR_INVALIDDATA;
samples[0] = type34_delta[v] / type34_div + type34_predictor;
type34_predictor = samples[0];
}
} else {
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 1;
break;
default:
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
run = 1;
break;
}
if (joined_stereo) {
float tmp[10][MPA_MAX_CHANNELS];
for (k = 0; k < run; k++) {
tmp[k][0] = samples[k];
tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k];
}
for (chs = 0; chs < q->nb_channels; chs++)
for (k = 0; k < run; k++)
if ((j + k) < 128)
q->sb_samples[chs][j + k][sb] = q->tone_level[chs][sb][((j + k)/2)] * tmp[k][chs];
} else {
for (k = 0; k < run; k++)
if ((j + k) < 128)
q->sb_samples[ch][j + k][sb] = q->tone_level[ch][sb][(j + k)/2] * samples[k];
}
j += run;
} // j loop
} // channel loop
} // subband loop
return 0;
}
| false | FFmpeg | fe91becc2dcf32fc4bc56b00b4533d34ec3d27f5 | static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max)
{
int sb, j, k, n, ch, run, channels;
int joined_stereo, zero_encoding, chs;
int type34_first;
float type34_div = 0;
float type34_predictor;
float samples[10], sign_bits[16];
if (length == 0) {
for (sb=sb_min; sb < sb_max; sb++)
build_sb_samples_from_noise (q, sb);
return 0;
}
for (sb = sb_min; sb < sb_max; sb++) {
FIX_NOISE_IDX(q->noise_idx);
channels = q->nb_channels;
if (q->nb_channels <= 1 || sb < 12)
joined_stereo = 0;
else if (sb >= 24)
joined_stereo = 1;
else
joined_stereo = (BITS_LEFT(length,gb) >= 1) ? get_bits1 (gb) : 0;
if (joined_stereo) {
if (BITS_LEFT(length,gb) >= 16)
for (j = 0; j < 16; j++)
sign_bits[j] = get_bits1 (gb);
for (j = 0; j < 64; j++)
if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])
q->coding_method[0][sb][j] = q->coding_method[1][sb][j];
fix_coding_method_array(sb, q->nb_channels, q->coding_method);
channels = 1;
}
for (ch = 0; ch < channels; ch++) {
zero_encoding = (BITS_LEFT(length,gb) >= 1) ? get_bits1(gb) : 0;
type34_predictor = 0.0;
type34_first = 1;
for (j = 0; j < 128; ) {
switch (q->coding_method[ch][sb][j / 2]) {
case 8:
if (BITS_LEFT(length,gb) >= 10) {
if (zero_encoding) {
for (k = 0; k < 5; k++) {
if ((j + 2 * k) >= 128)
break;
samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0;
}
} else {
n = get_bits(gb, 8);
for (k = 0; k < 5; k++)
samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
}
for (k = 0; k < 5; k++)
samples[2 * k + 1] = SB_DITHERING_NOISE(sb,q->noise_idx);
} else {
for (k = 0; k < 10; k++)
samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 10;
break;
case 10:
if (BITS_LEFT(length,gb) >= 1) {
float f = 0.81;
if (get_bits1(gb))
f = -f;
f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;
samples[0] = f;
} else {
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 1;
break;
case 16:
if (BITS_LEFT(length,gb) >= 10) {
if (zero_encoding) {
for (k = 0; k < 5; k++) {
if ((j + k) >= 128)
break;
samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)];
}
} else {
n = get_bits (gb, 8);
for (k = 0; k < 5; k++)
samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
}
} else {
for (k = 0; k < 5; k++)
samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 5;
break;
case 24:
if (BITS_LEFT(length,gb) >= 7) {
n = get_bits(gb, 7);
for (k = 0; k < 3; k++)
samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;
} else {
for (k = 0; k < 3; k++)
samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 3;
break;
case 30:
if (BITS_LEFT(length,gb) >= 4)
samples[0] = type30_dequant[qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1)];
else
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
run = 1;
break;
case 34:
if (BITS_LEFT(length,gb) >= 7) {
if (type34_first) {
type34_div = (float)(1 << get_bits(gb, 2));
samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0;
type34_predictor = samples[0];
type34_first = 0;
} else {
unsigned v = qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1);
if (v >= FF_ARRAY_ELEMS(type34_delta))
return AVERROR_INVALIDDATA;
samples[0] = type34_delta[v] / type34_div + type34_predictor;
type34_predictor = samples[0];
}
} else {
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
}
run = 1;
break;
default:
samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
run = 1;
break;
}
if (joined_stereo) {
float tmp[10][MPA_MAX_CHANNELS];
for (k = 0; k < run; k++) {
tmp[k][0] = samples[k];
tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k];
}
for (chs = 0; chs < q->nb_channels; chs++)
for (k = 0; k < run; k++)
if ((j + k) < 128)
q->sb_samples[chs][j + k][sb] = q->tone_level[chs][sb][((j + k)/2)] * tmp[k][chs];
} else {
for (k = 0; k < run; k++)
if ((j + k) < 128)
q->sb_samples[ch][j + k][sb] = q->tone_level[ch][sb][(j + k)/2] * samples[k];
}
j += run;
}
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0 (QDM2Context *VAR_0, GetBitContext *VAR_1, int VAR_2, int VAR_3, int VAR_4)
{
int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;
int VAR_12, VAR_13, VAR_14;
int VAR_15;
float VAR_16 = 0;
float VAR_17;
float VAR_18[10], VAR_19[16];
if (VAR_2 == 0) {
for (VAR_5=VAR_3; VAR_5 < VAR_4; VAR_5++)
build_sb_samples_from_noise (VAR_0, VAR_5);
return 0;
}
for (VAR_5 = VAR_3; VAR_5 < VAR_4; VAR_5++) {
FIX_NOISE_IDX(VAR_0->noise_idx);
VAR_11 = VAR_0->nb_channels;
if (VAR_0->nb_channels <= 1 || VAR_5 < 12)
VAR_12 = 0;
else if (VAR_5 >= 24)
VAR_12 = 1;
else
VAR_12 = (BITS_LEFT(VAR_2,VAR_1) >= 1) ? get_bits1 (VAR_1) : 0;
if (VAR_12) {
if (BITS_LEFT(VAR_2,VAR_1) >= 16)
for (VAR_6 = 0; VAR_6 < 16; VAR_6++)
VAR_19[VAR_6] = get_bits1 (VAR_1);
for (VAR_6 = 0; VAR_6 < 64; VAR_6++)
if (VAR_0->coding_method[1][VAR_5][VAR_6] > VAR_0->coding_method[0][VAR_5][VAR_6])
VAR_0->coding_method[0][VAR_5][VAR_6] = VAR_0->coding_method[1][VAR_5][VAR_6];
fix_coding_method_array(VAR_5, VAR_0->nb_channels, VAR_0->coding_method);
VAR_11 = 1;
}
for (VAR_9 = 0; VAR_9 < VAR_11; VAR_9++) {
VAR_13 = (BITS_LEFT(VAR_2,VAR_1) >= 1) ? get_bits1(VAR_1) : 0;
VAR_17 = 0.0;
VAR_15 = 1;
for (VAR_6 = 0; VAR_6 < 128; ) {
switch (VAR_0->coding_method[VAR_9][VAR_5][VAR_6 / 2]) {
case 8:
if (BITS_LEFT(VAR_2,VAR_1) >= 10) {
if (VAR_13) {
for (VAR_7 = 0; VAR_7 < 5; VAR_7++) {
if ((VAR_6 + 2 * VAR_7) >= 128)
break;
VAR_18[2 * VAR_7] = get_bits1(VAR_1) ? dequant_1bit[VAR_12][2 * get_bits1(VAR_1)] : 0;
}
} else {
VAR_8 = get_bits(VAR_1, 8);
for (VAR_7 = 0; VAR_7 < 5; VAR_7++)
VAR_18[2 * VAR_7] = dequant_1bit[VAR_12][random_dequant_index[VAR_8][VAR_7]];
}
for (VAR_7 = 0; VAR_7 < 5; VAR_7++)
VAR_18[2 * VAR_7 + 1] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
} else {
for (VAR_7 = 0; VAR_7 < 10; VAR_7++)
VAR_18[VAR_7] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
}
VAR_10 = 10;
break;
case 10:
if (BITS_LEFT(VAR_2,VAR_1) >= 1) {
float VAR_20 = 0.81;
if (get_bits1(VAR_1))
VAR_20 = -VAR_20;
VAR_20 -= noise_samples[((VAR_5 + 1) * (VAR_6 +5 * VAR_9 + 1)) & 127] * 9.0 / 40.0;
VAR_18[0] = VAR_20;
} else {
VAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
}
VAR_10 = 1;
break;
case 16:
if (BITS_LEFT(VAR_2,VAR_1) >= 10) {
if (VAR_13) {
for (VAR_7 = 0; VAR_7 < 5; VAR_7++) {
if ((VAR_6 + VAR_7) >= 128)
break;
VAR_18[VAR_7] = (get_bits1(VAR_1) == 0) ? 0 : dequant_1bit[VAR_12][2 * get_bits1(VAR_1)];
}
} else {
VAR_8 = get_bits (VAR_1, 8);
for (VAR_7 = 0; VAR_7 < 5; VAR_7++)
VAR_18[VAR_7] = dequant_1bit[VAR_12][random_dequant_index[VAR_8][VAR_7]];
}
} else {
for (VAR_7 = 0; VAR_7 < 5; VAR_7++)
VAR_18[VAR_7] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
}
VAR_10 = 5;
break;
case 24:
if (BITS_LEFT(VAR_2,VAR_1) >= 7) {
VAR_8 = get_bits(VAR_1, 7);
for (VAR_7 = 0; VAR_7 < 3; VAR_7++)
VAR_18[VAR_7] = (random_dequant_type24[VAR_8][VAR_7] - 2.0) * 0.5;
} else {
for (VAR_7 = 0; VAR_7 < 3; VAR_7++)
VAR_18[VAR_7] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
}
VAR_10 = 3;
break;
case 30:
if (BITS_LEFT(VAR_2,VAR_1) >= 4)
VAR_18[0] = type30_dequant[qdm2_get_vlc(VAR_1, &vlc_tab_type30, 0, 1)];
else
VAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
VAR_10 = 1;
break;
case 34:
if (BITS_LEFT(VAR_2,VAR_1) >= 7) {
if (VAR_15) {
VAR_16 = (float)(1 << get_bits(VAR_1, 2));
VAR_18[0] = ((float)get_bits(VAR_1, 5) - 16.0) / 15.0;
VAR_17 = VAR_18[0];
VAR_15 = 0;
} else {
unsigned VAR_21 = qdm2_get_vlc(VAR_1, &vlc_tab_type34, 0, 1);
if (VAR_21 >= FF_ARRAY_ELEMS(type34_delta))
return AVERROR_INVALIDDATA;
VAR_18[0] = type34_delta[VAR_21] / VAR_16 + VAR_17;
VAR_17 = VAR_18[0];
}
} else {
VAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
}
VAR_10 = 1;
break;
default:
VAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);
VAR_10 = 1;
break;
}
if (VAR_12) {
float VAR_22[10][MPA_MAX_CHANNELS];
for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) {
VAR_22[VAR_7][0] = VAR_18[VAR_7];
VAR_22[VAR_7][1] = (VAR_19[(VAR_6 + VAR_7) / 8]) ? -VAR_18[VAR_7] : VAR_18[VAR_7];
}
for (VAR_14 = 0; VAR_14 < VAR_0->nb_channels; VAR_14++)
for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)
if ((VAR_6 + VAR_7) < 128)
VAR_0->sb_samples[VAR_14][VAR_6 + VAR_7][VAR_5] = VAR_0->tone_level[VAR_14][VAR_5][((VAR_6 + VAR_7)/2)] * VAR_22[VAR_7][VAR_14];
} else {
for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)
if ((VAR_6 + VAR_7) < 128)
VAR_0->sb_samples[VAR_9][VAR_6 + VAR_7][VAR_5] = VAR_0->tone_level[VAR_9][VAR_5][(VAR_6 + VAR_7)/2] * VAR_18[VAR_7];
}
VAR_6 += VAR_10;
}
}
}
return 0;
}
| [
"static int FUNC_0 (QDM2Context *VAR_0, GetBitContext *VAR_1, int VAR_2, int VAR_3, int VAR_4)\n{",
"int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11;",
"int VAR_12, VAR_13, VAR_14;",
"int VAR_15;",
"float VAR_16 = 0;",
"float VAR_17;",
"float VAR_18[10], VAR_19[16];",
"if (VAR_2 == 0) {",
"for (VAR_5=VAR_3; VAR_5 < VAR_4; VAR_5++)",
"build_sb_samples_from_noise (VAR_0, VAR_5);",
"return 0;",
"}",
"for (VAR_5 = VAR_3; VAR_5 < VAR_4; VAR_5++) {",
"FIX_NOISE_IDX(VAR_0->noise_idx);",
"VAR_11 = VAR_0->nb_channels;",
"if (VAR_0->nb_channels <= 1 || VAR_5 < 12)\nVAR_12 = 0;",
"else if (VAR_5 >= 24)\nVAR_12 = 1;",
"else\nVAR_12 = (BITS_LEFT(VAR_2,VAR_1) >= 1) ? get_bits1 (VAR_1) : 0;",
"if (VAR_12) {",
"if (BITS_LEFT(VAR_2,VAR_1) >= 16)\nfor (VAR_6 = 0; VAR_6 < 16; VAR_6++)",
"VAR_19[VAR_6] = get_bits1 (VAR_1);",
"for (VAR_6 = 0; VAR_6 < 64; VAR_6++)",
"if (VAR_0->coding_method[1][VAR_5][VAR_6] > VAR_0->coding_method[0][VAR_5][VAR_6])\nVAR_0->coding_method[0][VAR_5][VAR_6] = VAR_0->coding_method[1][VAR_5][VAR_6];",
"fix_coding_method_array(VAR_5, VAR_0->nb_channels, VAR_0->coding_method);",
"VAR_11 = 1;",
"}",
"for (VAR_9 = 0; VAR_9 < VAR_11; VAR_9++) {",
"VAR_13 = (BITS_LEFT(VAR_2,VAR_1) >= 1) ? get_bits1(VAR_1) : 0;",
"VAR_17 = 0.0;",
"VAR_15 = 1;",
"for (VAR_6 = 0; VAR_6 < 128; ) {",
"switch (VAR_0->coding_method[VAR_9][VAR_5][VAR_6 / 2]) {",
"case 8:\nif (BITS_LEFT(VAR_2,VAR_1) >= 10) {",
"if (VAR_13) {",
"for (VAR_7 = 0; VAR_7 < 5; VAR_7++) {",
"if ((VAR_6 + 2 * VAR_7) >= 128)\nbreak;",
"VAR_18[2 * VAR_7] = get_bits1(VAR_1) ? dequant_1bit[VAR_12][2 * get_bits1(VAR_1)] : 0;",
"}",
"} else {",
"VAR_8 = get_bits(VAR_1, 8);",
"for (VAR_7 = 0; VAR_7 < 5; VAR_7++)",
"VAR_18[2 * VAR_7] = dequant_1bit[VAR_12][random_dequant_index[VAR_8][VAR_7]];",
"}",
"for (VAR_7 = 0; VAR_7 < 5; VAR_7++)",
"VAR_18[2 * VAR_7 + 1] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"} else {",
"for (VAR_7 = 0; VAR_7 < 10; VAR_7++)",
"VAR_18[VAR_7] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"}",
"VAR_10 = 10;",
"break;",
"case 10:\nif (BITS_LEFT(VAR_2,VAR_1) >= 1) {",
"float VAR_20 = 0.81;",
"if (get_bits1(VAR_1))\nVAR_20 = -VAR_20;",
"VAR_20 -= noise_samples[((VAR_5 + 1) * (VAR_6 +5 * VAR_9 + 1)) & 127] * 9.0 / 40.0;",
"VAR_18[0] = VAR_20;",
"} else {",
"VAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"}",
"VAR_10 = 1;",
"break;",
"case 16:\nif (BITS_LEFT(VAR_2,VAR_1) >= 10) {",
"if (VAR_13) {",
"for (VAR_7 = 0; VAR_7 < 5; VAR_7++) {",
"if ((VAR_6 + VAR_7) >= 128)\nbreak;",
"VAR_18[VAR_7] = (get_bits1(VAR_1) == 0) ? 0 : dequant_1bit[VAR_12][2 * get_bits1(VAR_1)];",
"}",
"} else {",
"VAR_8 = get_bits (VAR_1, 8);",
"for (VAR_7 = 0; VAR_7 < 5; VAR_7++)",
"VAR_18[VAR_7] = dequant_1bit[VAR_12][random_dequant_index[VAR_8][VAR_7]];",
"}",
"} else {",
"for (VAR_7 = 0; VAR_7 < 5; VAR_7++)",
"VAR_18[VAR_7] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"}",
"VAR_10 = 5;",
"break;",
"case 24:\nif (BITS_LEFT(VAR_2,VAR_1) >= 7) {",
"VAR_8 = get_bits(VAR_1, 7);",
"for (VAR_7 = 0; VAR_7 < 3; VAR_7++)",
"VAR_18[VAR_7] = (random_dequant_type24[VAR_8][VAR_7] - 2.0) * 0.5;",
"} else {",
"for (VAR_7 = 0; VAR_7 < 3; VAR_7++)",
"VAR_18[VAR_7] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"}",
"VAR_10 = 3;",
"break;",
"case 30:\nif (BITS_LEFT(VAR_2,VAR_1) >= 4)\nVAR_18[0] = type30_dequant[qdm2_get_vlc(VAR_1, &vlc_tab_type30, 0, 1)];",
"else\nVAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"VAR_10 = 1;",
"break;",
"case 34:\nif (BITS_LEFT(VAR_2,VAR_1) >= 7) {",
"if (VAR_15) {",
"VAR_16 = (float)(1 << get_bits(VAR_1, 2));",
"VAR_18[0] = ((float)get_bits(VAR_1, 5) - 16.0) / 15.0;",
"VAR_17 = VAR_18[0];",
"VAR_15 = 0;",
"} else {",
"unsigned VAR_21 = qdm2_get_vlc(VAR_1, &vlc_tab_type34, 0, 1);",
"if (VAR_21 >= FF_ARRAY_ELEMS(type34_delta))\nreturn AVERROR_INVALIDDATA;",
"VAR_18[0] = type34_delta[VAR_21] / VAR_16 + VAR_17;",
"VAR_17 = VAR_18[0];",
"}",
"} else {",
"VAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"}",
"VAR_10 = 1;",
"break;",
"default:\nVAR_18[0] = SB_DITHERING_NOISE(VAR_5,VAR_0->noise_idx);",
"VAR_10 = 1;",
"break;",
"}",
"if (VAR_12) {",
"float VAR_22[10][MPA_MAX_CHANNELS];",
"for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++) {",
"VAR_22[VAR_7][0] = VAR_18[VAR_7];",
"VAR_22[VAR_7][1] = (VAR_19[(VAR_6 + VAR_7) / 8]) ? -VAR_18[VAR_7] : VAR_18[VAR_7];",
"}",
"for (VAR_14 = 0; VAR_14 < VAR_0->nb_channels; VAR_14++)",
"for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)",
"if ((VAR_6 + VAR_7) < 128)\nVAR_0->sb_samples[VAR_14][VAR_6 + VAR_7][VAR_5] = VAR_0->tone_level[VAR_14][VAR_5][((VAR_6 + VAR_7)/2)] * VAR_22[VAR_7][VAR_14];",
"} else {",
"for (VAR_7 = 0; VAR_7 < VAR_10; VAR_7++)",
"if ((VAR_6 + VAR_7) < 128)\nVAR_0->sb_samples[VAR_9][VAR_6 + VAR_7][VAR_5] = VAR_0->tone_level[VAR_9][VAR_5][(VAR_6 + VAR_7)/2] * VAR_18[VAR_7];",
"}",
"VAR_6 += VAR_10;",
"}",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
29
],
[
31
],
[
35
],
[
37
],
[
41
],
[
45,
47
],
[
49,
51
],
[
53,
55
],
[
59
],
[
61,
63
],
[
65
],
[
69
],
[
71,
73
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99,
101
],
[
103
],
[
105
],
[
107,
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
143,
145
],
[
147
],
[
151,
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
171,
173
],
[
175
],
[
177
],
[
179,
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
211,
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
235,
237,
239
],
[
241,
243
],
[
247
],
[
249
],
[
253,
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271,
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
293,
295
],
[
297
],
[
299
],
[
301
],
[
305
],
[
307
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
321
],
[
323,
325
],
[
327
],
[
329
],
[
331,
333
],
[
335
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
]
] |
21,606 | static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
{
PadContext *pad = inlink->dst->priv;
AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0);
int plane;
inlink->dst->outputs[0]->out_buf = outpicref;
for (plane = 0; plane < 4 && outpicref->data[plane]; plane++) {
int hsub = (plane == 1 || plane == 2) ? pad->hsub : 0;
int vsub = (plane == 1 || plane == 2) ? pad->vsub : 0;
outpicref->data[plane] -= (pad->x >> hsub) * pad->line_step[plane] +
(pad->y >> vsub) * outpicref->linesize[plane];
}
outpicref->video->w = pad->w;
outpicref->video->h = pad->h;
avfilter_start_frame(inlink->dst->outputs[0], outpicref);
}
| false | FFmpeg | e3331706fcc9888ee85f0b9f763e4d006b178c14 | static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
{
PadContext *pad = inlink->dst->priv;
AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0);
int plane;
inlink->dst->outputs[0]->out_buf = outpicref;
for (plane = 0; plane < 4 && outpicref->data[plane]; plane++) {
int hsub = (plane == 1 || plane == 2) ? pad->hsub : 0;
int vsub = (plane == 1 || plane == 2) ? pad->vsub : 0;
outpicref->data[plane] -= (pad->x >> hsub) * pad->line_step[plane] +
(pad->y >> vsub) * outpicref->linesize[plane];
}
outpicref->video->w = pad->w;
outpicref->video->h = pad->h;
avfilter_start_frame(inlink->dst->outputs[0], outpicref);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AVFilterLink *VAR_0, AVFilterBufferRef *VAR_1)
{
PadContext *pad = VAR_0->dst->priv;
AVFilterBufferRef *outpicref = avfilter_ref_buffer(VAR_1, ~0);
int VAR_2;
VAR_0->dst->outputs[0]->out_buf = outpicref;
for (VAR_2 = 0; VAR_2 < 4 && outpicref->data[VAR_2]; VAR_2++) {
int hsub = (VAR_2 == 1 || VAR_2 == 2) ? pad->hsub : 0;
int vsub = (VAR_2 == 1 || VAR_2 == 2) ? pad->vsub : 0;
outpicref->data[VAR_2] -= (pad->x >> hsub) * pad->line_step[VAR_2] +
(pad->y >> vsub) * outpicref->linesize[VAR_2];
}
outpicref->video->w = pad->w;
outpicref->video->h = pad->h;
avfilter_start_frame(VAR_0->dst->outputs[0], outpicref);
}
| [
"static void FUNC_0(AVFilterLink *VAR_0, AVFilterBufferRef *VAR_1)\n{",
"PadContext *pad = VAR_0->dst->priv;",
"AVFilterBufferRef *outpicref = avfilter_ref_buffer(VAR_1, ~0);",
"int VAR_2;",
"VAR_0->dst->outputs[0]->out_buf = outpicref;",
"for (VAR_2 = 0; VAR_2 < 4 && outpicref->data[VAR_2]; VAR_2++) {",
"int hsub = (VAR_2 == 1 || VAR_2 == 2) ? pad->hsub : 0;",
"int vsub = (VAR_2 == 1 || VAR_2 == 2) ? pad->vsub : 0;",
"outpicref->data[VAR_2] -= (pad->x >> hsub) * pad->line_step[VAR_2] +\n(pad->y >> vsub) * outpicref->linesize[VAR_2];",
"}",
"outpicref->video->w = pad->w;",
"outpicref->video->h = pad->h;",
"avfilter_start_frame(VAR_0->dst->outputs[0], outpicref);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25,
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
41
]
] |
21,608 | static int thread_init(AVCodecContext *avctx)
{
int i;
ThreadContext *c;
int thread_count = avctx->thread_count;
if (!thread_count) {
int nb_cpus = get_logical_cpus(avctx);
// use number of cores + 1 as thread count if there is motre than one
if (nb_cpus > 1)
thread_count = avctx->thread_count = nb_cpus + 1;
}
if (thread_count <= 1) {
avctx->active_thread_type = 0;
return 0;
}
c = av_mallocz(sizeof(ThreadContext));
if (!c)
return -1;
c->workers = av_mallocz(sizeof(pthread_t)*thread_count);
if (!c->workers) {
av_free(c);
return -1;
}
avctx->thread_opaque = c;
c->current_job = 0;
c->job_count = 0;
c->job_size = 0;
c->done = 0;
pthread_cond_init(&c->current_job_cond, NULL);
pthread_cond_init(&c->last_job_cond, NULL);
pthread_mutex_init(&c->current_job_lock, NULL);
pthread_mutex_lock(&c->current_job_lock);
for (i=0; i<thread_count; i++) {
if(pthread_create(&c->workers[i], NULL, worker, avctx)) {
avctx->thread_count = i;
pthread_mutex_unlock(&c->current_job_lock);
ff_thread_free(avctx);
return -1;
}
}
avcodec_thread_park_workers(c, thread_count);
avctx->execute = avcodec_thread_execute;
avctx->execute2 = avcodec_thread_execute2;
return 0;
}
| false | FFmpeg | b12d21733975f9001eecb480fc28e5e4473b1327 | static int thread_init(AVCodecContext *avctx)
{
int i;
ThreadContext *c;
int thread_count = avctx->thread_count;
if (!thread_count) {
int nb_cpus = get_logical_cpus(avctx);
if (nb_cpus > 1)
thread_count = avctx->thread_count = nb_cpus + 1;
}
if (thread_count <= 1) {
avctx->active_thread_type = 0;
return 0;
}
c = av_mallocz(sizeof(ThreadContext));
if (!c)
return -1;
c->workers = av_mallocz(sizeof(pthread_t)*thread_count);
if (!c->workers) {
av_free(c);
return -1;
}
avctx->thread_opaque = c;
c->current_job = 0;
c->job_count = 0;
c->job_size = 0;
c->done = 0;
pthread_cond_init(&c->current_job_cond, NULL);
pthread_cond_init(&c->last_job_cond, NULL);
pthread_mutex_init(&c->current_job_lock, NULL);
pthread_mutex_lock(&c->current_job_lock);
for (i=0; i<thread_count; i++) {
if(pthread_create(&c->workers[i], NULL, worker, avctx)) {
avctx->thread_count = i;
pthread_mutex_unlock(&c->current_job_lock);
ff_thread_free(avctx);
return -1;
}
}
avcodec_thread_park_workers(c, thread_count);
avctx->execute = avcodec_thread_execute;
avctx->execute2 = avcodec_thread_execute2;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0)
{
int VAR_1;
ThreadContext *c;
int VAR_2 = VAR_0->VAR_2;
if (!VAR_2) {
int VAR_3 = get_logical_cpus(VAR_0);
if (VAR_3 > 1)
VAR_2 = VAR_0->VAR_2 = VAR_3 + 1;
}
if (VAR_2 <= 1) {
VAR_0->active_thread_type = 0;
return 0;
}
c = av_mallocz(sizeof(ThreadContext));
if (!c)
return -1;
c->workers = av_mallocz(sizeof(pthread_t)*VAR_2);
if (!c->workers) {
av_free(c);
return -1;
}
VAR_0->thread_opaque = c;
c->current_job = 0;
c->job_count = 0;
c->job_size = 0;
c->done = 0;
pthread_cond_init(&c->current_job_cond, NULL);
pthread_cond_init(&c->last_job_cond, NULL);
pthread_mutex_init(&c->current_job_lock, NULL);
pthread_mutex_lock(&c->current_job_lock);
for (VAR_1=0; VAR_1<VAR_2; VAR_1++) {
if(pthread_create(&c->workers[VAR_1], NULL, worker, VAR_0)) {
VAR_0->VAR_2 = VAR_1;
pthread_mutex_unlock(&c->current_job_lock);
ff_thread_free(VAR_0);
return -1;
}
}
avcodec_thread_park_workers(c, VAR_2);
VAR_0->execute = avcodec_thread_execute;
VAR_0->execute2 = avcodec_thread_execute2;
return 0;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0)\n{",
"int VAR_1;",
"ThreadContext *c;",
"int VAR_2 = VAR_0->VAR_2;",
"if (!VAR_2) {",
"int VAR_3 = get_logical_cpus(VAR_0);",
"if (VAR_3 > 1)\nVAR_2 = VAR_0->VAR_2 = VAR_3 + 1;",
"}",
"if (VAR_2 <= 1) {",
"VAR_0->active_thread_type = 0;",
"return 0;",
"}",
"c = av_mallocz(sizeof(ThreadContext));",
"if (!c)\nreturn -1;",
"c->workers = av_mallocz(sizeof(pthread_t)*VAR_2);",
"if (!c->workers) {",
"av_free(c);",
"return -1;",
"}",
"VAR_0->thread_opaque = c;",
"c->current_job = 0;",
"c->job_count = 0;",
"c->job_size = 0;",
"c->done = 0;",
"pthread_cond_init(&c->current_job_cond, NULL);",
"pthread_cond_init(&c->last_job_cond, NULL);",
"pthread_mutex_init(&c->current_job_lock, NULL);",
"pthread_mutex_lock(&c->current_job_lock);",
"for (VAR_1=0; VAR_1<VAR_2; VAR_1++) {",
"if(pthread_create(&c->workers[VAR_1], NULL, worker, VAR_0)) {",
"VAR_0->VAR_2 = VAR_1;",
"pthread_mutex_unlock(&c->current_job_lock);",
"ff_thread_free(VAR_0);",
"return -1;",
"}",
"}",
"avcodec_thread_park_workers(c, VAR_2);",
"VAR_0->execute = avcodec_thread_execute;",
"VAR_0->execute2 = avcodec_thread_execute2;",
"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
],
[
9
],
[
13
],
[
15
],
[
19,
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39,
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
93
],
[
97
],
[
99
],
[
101
],
[
103
]
] |
21,609 | static av_cold int vtenc_init(AVCodecContext *avctx)
{
CFMutableDictionaryRef enc_info;
CFMutableDictionaryRef pixel_buffer_info;
CMVideoCodecType codec_type;
VTEncContext *vtctx = avctx->priv_data;
CFStringRef profile_level;
CFBooleanRef has_b_frames_cfbool;
CFNumberRef gamma_level = NULL;
int status;
codec_type = get_cm_codec_type(avctx->codec_id);
if (!codec_type) {
av_log(avctx, AV_LOG_ERROR, "Error: no mapping for AVCodecID %d\n", avctx->codec_id);
return AVERROR(EINVAL);
}
vtctx->has_b_frames = avctx->max_b_frames > 0;
if(vtctx->has_b_frames && vtctx->profile == H264_PROF_BASELINE){
av_log(avctx, AV_LOG_WARNING, "Cannot use B-frames with baseline profile. Output will not contain B-frames.\n");
vtctx->has_b_frames = false;
}
if (vtctx->entropy == VT_CABAC && vtctx->profile == H264_PROF_BASELINE) {
av_log(avctx, AV_LOG_WARNING, "CABAC entropy requires 'main' or 'high' profile, but baseline was requested. Encode will not use CABAC entropy.\n");
vtctx->entropy = VT_ENTROPY_NOT_SET;
}
if (!get_vt_profile_level(avctx, &profile_level)) return AVERROR(EINVAL);
vtctx->session = NULL;
enc_info = CFDictionaryCreateMutable(
kCFAllocatorDefault,
20,
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks
);
if (!enc_info) return AVERROR(ENOMEM);
#if !TARGET_OS_IPHONE
if (!vtctx->allow_sw) {
CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
} else {
CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
}
#endif
if (avctx->pix_fmt != AV_PIX_FMT_VIDEOTOOLBOX) {
status = create_cv_pixel_buffer_info(avctx, &pixel_buffer_info);
if (status)
goto init_cleanup;
} else {
pixel_buffer_info = NULL;
}
pthread_mutex_init(&vtctx->lock, NULL);
pthread_cond_init(&vtctx->cv_sample_sent, NULL);
vtctx->dts_delta = vtctx->has_b_frames ? -1 : 0;
get_cv_transfer_function(avctx, &vtctx->transfer_function, &gamma_level);
get_cv_ycbcr_matrix(avctx, &vtctx->ycbcr_matrix);
get_cv_color_primaries(avctx, &vtctx->color_primaries);
if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
status = vtenc_populate_extradata(avctx,
codec_type,
profile_level,
gamma_level,
enc_info,
pixel_buffer_info);
if (status)
goto init_cleanup;
}
status = vtenc_create_encoder(avctx,
codec_type,
profile_level,
gamma_level,
enc_info,
pixel_buffer_info,
&vtctx->session);
if (status < 0)
goto init_cleanup;
status = VTSessionCopyProperty(vtctx->session,
kVTCompressionPropertyKey_AllowFrameReordering,
kCFAllocatorDefault,
&has_b_frames_cfbool);
if (!status) {
//Some devices don't output B-frames for main profile, even if requested.
vtctx->has_b_frames = CFBooleanGetValue(has_b_frames_cfbool);
CFRelease(has_b_frames_cfbool);
}
avctx->has_b_frames = vtctx->has_b_frames;
init_cleanup:
if (gamma_level)
CFRelease(gamma_level);
if (pixel_buffer_info)
CFRelease(pixel_buffer_info);
CFRelease(enc_info);
return status;
}
| false | FFmpeg | dcd3418a35aab7ef283b68ed9997ce4ac204094e | static av_cold int vtenc_init(AVCodecContext *avctx)
{
CFMutableDictionaryRef enc_info;
CFMutableDictionaryRef pixel_buffer_info;
CMVideoCodecType codec_type;
VTEncContext *vtctx = avctx->priv_data;
CFStringRef profile_level;
CFBooleanRef has_b_frames_cfbool;
CFNumberRef gamma_level = NULL;
int status;
codec_type = get_cm_codec_type(avctx->codec_id);
if (!codec_type) {
av_log(avctx, AV_LOG_ERROR, "Error: no mapping for AVCodecID %d\n", avctx->codec_id);
return AVERROR(EINVAL);
}
vtctx->has_b_frames = avctx->max_b_frames > 0;
if(vtctx->has_b_frames && vtctx->profile == H264_PROF_BASELINE){
av_log(avctx, AV_LOG_WARNING, "Cannot use B-frames with baseline profile. Output will not contain B-frames.\n");
vtctx->has_b_frames = false;
}
if (vtctx->entropy == VT_CABAC && vtctx->profile == H264_PROF_BASELINE) {
av_log(avctx, AV_LOG_WARNING, "CABAC entropy requires 'main' or 'high' profile, but baseline was requested. Encode will not use CABAC entropy.\n");
vtctx->entropy = VT_ENTROPY_NOT_SET;
}
if (!get_vt_profile_level(avctx, &profile_level)) return AVERROR(EINVAL);
vtctx->session = NULL;
enc_info = CFDictionaryCreateMutable(
kCFAllocatorDefault,
20,
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks
);
if (!enc_info) return AVERROR(ENOMEM);
#if !TARGET_OS_IPHONE
if (!vtctx->allow_sw) {
CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
} else {
CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
}
#endif
if (avctx->pix_fmt != AV_PIX_FMT_VIDEOTOOLBOX) {
status = create_cv_pixel_buffer_info(avctx, &pixel_buffer_info);
if (status)
goto init_cleanup;
} else {
pixel_buffer_info = NULL;
}
pthread_mutex_init(&vtctx->lock, NULL);
pthread_cond_init(&vtctx->cv_sample_sent, NULL);
vtctx->dts_delta = vtctx->has_b_frames ? -1 : 0;
get_cv_transfer_function(avctx, &vtctx->transfer_function, &gamma_level);
get_cv_ycbcr_matrix(avctx, &vtctx->ycbcr_matrix);
get_cv_color_primaries(avctx, &vtctx->color_primaries);
if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
status = vtenc_populate_extradata(avctx,
codec_type,
profile_level,
gamma_level,
enc_info,
pixel_buffer_info);
if (status)
goto init_cleanup;
}
status = vtenc_create_encoder(avctx,
codec_type,
profile_level,
gamma_level,
enc_info,
pixel_buffer_info,
&vtctx->session);
if (status < 0)
goto init_cleanup;
status = VTSessionCopyProperty(vtctx->session,
kVTCompressionPropertyKey_AllowFrameReordering,
kCFAllocatorDefault,
&has_b_frames_cfbool);
if (!status) {
vtctx->has_b_frames = CFBooleanGetValue(has_b_frames_cfbool);
CFRelease(has_b_frames_cfbool);
}
avctx->has_b_frames = vtctx->has_b_frames;
init_cleanup:
if (gamma_level)
CFRelease(gamma_level);
if (pixel_buffer_info)
CFRelease(pixel_buffer_info);
CFRelease(enc_info);
return status;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
CFMutableDictionaryRef enc_info;
CFMutableDictionaryRef pixel_buffer_info;
CMVideoCodecType codec_type;
VTEncContext *vtctx = avctx->priv_data;
CFStringRef profile_level;
CFBooleanRef has_b_frames_cfbool;
CFNumberRef gamma_level = NULL;
int VAR_0;
codec_type = get_cm_codec_type(avctx->codec_id);
if (!codec_type) {
av_log(avctx, AV_LOG_ERROR, "Error: no mapping for AVCodecID %d\n", avctx->codec_id);
return AVERROR(EINVAL);
}
vtctx->has_b_frames = avctx->max_b_frames > 0;
if(vtctx->has_b_frames && vtctx->profile == H264_PROF_BASELINE){
av_log(avctx, AV_LOG_WARNING, "Cannot use B-frames with baseline profile. Output will not contain B-frames.\n");
vtctx->has_b_frames = false;
}
if (vtctx->entropy == VT_CABAC && vtctx->profile == H264_PROF_BASELINE) {
av_log(avctx, AV_LOG_WARNING, "CABAC entropy requires 'main' or 'high' profile, but baseline was requested. Encode will not use CABAC entropy.\n");
vtctx->entropy = VT_ENTROPY_NOT_SET;
}
if (!get_vt_profile_level(avctx, &profile_level)) return AVERROR(EINVAL);
vtctx->session = NULL;
enc_info = CFDictionaryCreateMutable(
kCFAllocatorDefault,
20,
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks
);
if (!enc_info) return AVERROR(ENOMEM);
#if !TARGET_OS_IPHONE
if (!vtctx->allow_sw) {
CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
} else {
CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
}
#endif
if (avctx->pix_fmt != AV_PIX_FMT_VIDEOTOOLBOX) {
VAR_0 = create_cv_pixel_buffer_info(avctx, &pixel_buffer_info);
if (VAR_0)
goto init_cleanup;
} else {
pixel_buffer_info = NULL;
}
pthread_mutex_init(&vtctx->lock, NULL);
pthread_cond_init(&vtctx->cv_sample_sent, NULL);
vtctx->dts_delta = vtctx->has_b_frames ? -1 : 0;
get_cv_transfer_function(avctx, &vtctx->transfer_function, &gamma_level);
get_cv_ycbcr_matrix(avctx, &vtctx->ycbcr_matrix);
get_cv_color_primaries(avctx, &vtctx->color_primaries);
if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
VAR_0 = vtenc_populate_extradata(avctx,
codec_type,
profile_level,
gamma_level,
enc_info,
pixel_buffer_info);
if (VAR_0)
goto init_cleanup;
}
VAR_0 = vtenc_create_encoder(avctx,
codec_type,
profile_level,
gamma_level,
enc_info,
pixel_buffer_info,
&vtctx->session);
if (VAR_0 < 0)
goto init_cleanup;
VAR_0 = VTSessionCopyProperty(vtctx->session,
kVTCompressionPropertyKey_AllowFrameReordering,
kCFAllocatorDefault,
&has_b_frames_cfbool);
if (!VAR_0) {
vtctx->has_b_frames = CFBooleanGetValue(has_b_frames_cfbool);
CFRelease(has_b_frames_cfbool);
}
avctx->has_b_frames = vtctx->has_b_frames;
init_cleanup:
if (gamma_level)
CFRelease(gamma_level);
if (pixel_buffer_info)
CFRelease(pixel_buffer_info);
CFRelease(enc_info);
return VAR_0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"CFMutableDictionaryRef enc_info;",
"CFMutableDictionaryRef pixel_buffer_info;",
"CMVideoCodecType codec_type;",
"VTEncContext *vtctx = avctx->priv_data;",
"CFStringRef profile_level;",
"CFBooleanRef has_b_frames_cfbool;",
"CFNumberRef gamma_level = NULL;",
"int VAR_0;",
"codec_type = get_cm_codec_type(avctx->codec_id);",
"if (!codec_type) {",
"av_log(avctx, AV_LOG_ERROR, \"Error: no mapping for AVCodecID %d\\n\", avctx->codec_id);",
"return AVERROR(EINVAL);",
"}",
"vtctx->has_b_frames = avctx->max_b_frames > 0;",
"if(vtctx->has_b_frames && vtctx->profile == H264_PROF_BASELINE){",
"av_log(avctx, AV_LOG_WARNING, \"Cannot use B-frames with baseline profile. Output will not contain B-frames.\\n\");",
"vtctx->has_b_frames = false;",
"}",
"if (vtctx->entropy == VT_CABAC && vtctx->profile == H264_PROF_BASELINE) {",
"av_log(avctx, AV_LOG_WARNING, \"CABAC entropy requires 'main' or 'high' profile, but baseline was requested. Encode will not use CABAC entropy.\\n\");",
"vtctx->entropy = VT_ENTROPY_NOT_SET;",
"}",
"if (!get_vt_profile_level(avctx, &profile_level)) return AVERROR(EINVAL);",
"vtctx->session = NULL;",
"enc_info = CFDictionaryCreateMutable(\nkCFAllocatorDefault,\n20,\n&kCFCopyStringDictionaryKeyCallBacks,\n&kCFTypeDictionaryValueCallBacks\n);",
"if (!enc_info) return AVERROR(ENOMEM);",
"#if !TARGET_OS_IPHONE\nif (!vtctx->allow_sw) {",
"CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);",
"} else {",
"CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder, kCFBooleanTrue);",
"}",
"#endif\nif (avctx->pix_fmt != AV_PIX_FMT_VIDEOTOOLBOX) {",
"VAR_0 = create_cv_pixel_buffer_info(avctx, &pixel_buffer_info);",
"if (VAR_0)\ngoto init_cleanup;",
"} else {",
"pixel_buffer_info = NULL;",
"}",
"pthread_mutex_init(&vtctx->lock, NULL);",
"pthread_cond_init(&vtctx->cv_sample_sent, NULL);",
"vtctx->dts_delta = vtctx->has_b_frames ? -1 : 0;",
"get_cv_transfer_function(avctx, &vtctx->transfer_function, &gamma_level);",
"get_cv_ycbcr_matrix(avctx, &vtctx->ycbcr_matrix);",
"get_cv_color_primaries(avctx, &vtctx->color_primaries);",
"if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {",
"VAR_0 = vtenc_populate_extradata(avctx,\ncodec_type,\nprofile_level,\ngamma_level,\nenc_info,\npixel_buffer_info);",
"if (VAR_0)\ngoto init_cleanup;",
"}",
"VAR_0 = vtenc_create_encoder(avctx,\ncodec_type,\nprofile_level,\ngamma_level,\nenc_info,\npixel_buffer_info,\n&vtctx->session);",
"if (VAR_0 < 0)\ngoto init_cleanup;",
"VAR_0 = VTSessionCopyProperty(vtctx->session,\nkVTCompressionPropertyKey_AllowFrameReordering,\nkCFAllocatorDefault,\n&has_b_frames_cfbool);",
"if (!VAR_0) {",
"vtctx->has_b_frames = CFBooleanGetValue(has_b_frames_cfbool);",
"CFRelease(has_b_frames_cfbool);",
"}",
"avctx->has_b_frames = vtctx->has_b_frames;",
"init_cleanup:\nif (gamma_level)\nCFRelease(gamma_level);",
"if (pixel_buffer_info)\nCFRelease(pixel_buffer_info);",
"CFRelease(enc_info);",
"return VAR_0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
61
],
[
65,
67,
69,
71,
73,
75
],
[
79
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95,
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119
],
[
123
],
[
125
],
[
127
],
[
133
],
[
135,
137,
139,
141,
143,
145
],
[
147,
149
],
[
151
],
[
155,
157,
159,
161,
163,
165,
167
],
[
171,
173
],
[
177,
179,
181,
183
],
[
187
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201,
203,
205
],
[
209,
211
],
[
215
],
[
219
],
[
221
]
] |
21,610 | av_cold void ff_dsputil_init_alpha(DSPContext *c, AVCodecContext *avctx)
{
const int high_bit_depth = avctx->bits_per_raw_sample > 8;
/* amask clears all bits that correspond to present features. */
if (amask(AMASK_MVI) == 0) {
c->put_pixels_clamped = put_pixels_clamped_mvi_asm;
c->add_pixels_clamped = add_pixels_clamped_mvi_asm;
if (!high_bit_depth)
c->get_pixels = get_pixels_mvi;
c->diff_pixels = diff_pixels_mvi;
c->sad[0] = pix_abs16x16_mvi_asm;
c->sad[1] = pix_abs8x8_mvi;
c->pix_abs[0][0] = pix_abs16x16_mvi_asm;
c->pix_abs[1][0] = pix_abs8x8_mvi;
c->pix_abs[0][1] = pix_abs16x16_x2_mvi;
c->pix_abs[0][2] = pix_abs16x16_y2_mvi;
c->pix_abs[0][3] = pix_abs16x16_xy2_mvi;
}
put_pixels_clamped_axp_p = c->put_pixels_clamped;
add_pixels_clamped_axp_p = c->add_pixels_clamped;
if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&
(avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLEALPHA)) {
c->idct_put = ff_simple_idct_put_axp;
c->idct_add = ff_simple_idct_add_axp;
c->idct = ff_simple_idct_axp;
}
}
| true | FFmpeg | 550bda741cfe0e471a70e40529a9ab02d31b7049 | av_cold void ff_dsputil_init_alpha(DSPContext *c, AVCodecContext *avctx)
{
const int high_bit_depth = avctx->bits_per_raw_sample > 8;
if (amask(AMASK_MVI) == 0) {
c->put_pixels_clamped = put_pixels_clamped_mvi_asm;
c->add_pixels_clamped = add_pixels_clamped_mvi_asm;
if (!high_bit_depth)
c->get_pixels = get_pixels_mvi;
c->diff_pixels = diff_pixels_mvi;
c->sad[0] = pix_abs16x16_mvi_asm;
c->sad[1] = pix_abs8x8_mvi;
c->pix_abs[0][0] = pix_abs16x16_mvi_asm;
c->pix_abs[1][0] = pix_abs8x8_mvi;
c->pix_abs[0][1] = pix_abs16x16_x2_mvi;
c->pix_abs[0][2] = pix_abs16x16_y2_mvi;
c->pix_abs[0][3] = pix_abs16x16_xy2_mvi;
}
put_pixels_clamped_axp_p = c->put_pixels_clamped;
add_pixels_clamped_axp_p = c->add_pixels_clamped;
if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&
(avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLEALPHA)) {
c->idct_put = ff_simple_idct_put_axp;
c->idct_add = ff_simple_idct_add_axp;
c->idct = ff_simple_idct_axp;
}
}
| {
"code": [
" c->put_pixels_clamped = put_pixels_clamped_mvi_asm;",
" c->add_pixels_clamped = add_pixels_clamped_mvi_asm;",
" put_pixels_clamped_axp_p = c->put_pixels_clamped;",
" add_pixels_clamped_axp_p = c->add_pixels_clamped;",
" if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&",
" (avctx->idct_algo == FF_IDCT_AUTO ||",
" avctx->idct_algo == FF_IDCT_SIMPLEALPHA)) {",
" c->idct_put = ff_simple_idct_put_axp;",
" c->idct_add = ff_simple_idct_add_axp;",
" c->idct = ff_simple_idct_axp;"
],
"line_no": [
13,
15,
43,
45,
49,
51,
53,
55,
57,
59
]
} | av_cold void FUNC_0(DSPContext *c, AVCodecContext *avctx)
{
const int VAR_0 = avctx->bits_per_raw_sample > 8;
if (amask(AMASK_MVI) == 0) {
c->put_pixels_clamped = put_pixels_clamped_mvi_asm;
c->add_pixels_clamped = add_pixels_clamped_mvi_asm;
if (!VAR_0)
c->get_pixels = get_pixels_mvi;
c->diff_pixels = diff_pixels_mvi;
c->sad[0] = pix_abs16x16_mvi_asm;
c->sad[1] = pix_abs8x8_mvi;
c->pix_abs[0][0] = pix_abs16x16_mvi_asm;
c->pix_abs[1][0] = pix_abs8x8_mvi;
c->pix_abs[0][1] = pix_abs16x16_x2_mvi;
c->pix_abs[0][2] = pix_abs16x16_y2_mvi;
c->pix_abs[0][3] = pix_abs16x16_xy2_mvi;
}
put_pixels_clamped_axp_p = c->put_pixels_clamped;
add_pixels_clamped_axp_p = c->add_pixels_clamped;
if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&
(avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLEALPHA)) {
c->idct_put = ff_simple_idct_put_axp;
c->idct_add = ff_simple_idct_add_axp;
c->idct = ff_simple_idct_axp;
}
}
| [
"av_cold void FUNC_0(DSPContext *c, AVCodecContext *avctx)\n{",
"const int VAR_0 = avctx->bits_per_raw_sample > 8;",
"if (amask(AMASK_MVI) == 0) {",
"c->put_pixels_clamped = put_pixels_clamped_mvi_asm;",
"c->add_pixels_clamped = add_pixels_clamped_mvi_asm;",
"if (!VAR_0)\nc->get_pixels = get_pixels_mvi;",
"c->diff_pixels = diff_pixels_mvi;",
"c->sad[0] = pix_abs16x16_mvi_asm;",
"c->sad[1] = pix_abs8x8_mvi;",
"c->pix_abs[0][0] = pix_abs16x16_mvi_asm;",
"c->pix_abs[1][0] = pix_abs8x8_mvi;",
"c->pix_abs[0][1] = pix_abs16x16_x2_mvi;",
"c->pix_abs[0][2] = pix_abs16x16_y2_mvi;",
"c->pix_abs[0][3] = pix_abs16x16_xy2_mvi;",
"}",
"put_pixels_clamped_axp_p = c->put_pixels_clamped;",
"add_pixels_clamped_axp_p = c->add_pixels_clamped;",
"if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&\n(avctx->idct_algo == FF_IDCT_AUTO ||\navctx->idct_algo == FF_IDCT_SIMPLEALPHA)) {",
"c->idct_put = ff_simple_idct_put_axp;",
"c->idct_add = ff_simple_idct_add_axp;",
"c->idct = ff_simple_idct_axp;",
"}",
"}"
] | [
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
11
],
[
13
],
[
15
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
49,
51,
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
]
] |
21,611 | static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx,
RowContext *row,
int n,
int index_bits,
int level_bias,
int level_shift,
int dc_shift)
{
int i, j, index1, index2, len, flags;
int level, component, sign;
const int *scale;
const uint8_t *weight_matrix;
const uint8_t *ac_info = ctx->cid_table->ac_info;
int16_t *block = row->blocks[n];
const int eob_index = ctx->cid_table->eob_index;
int ret = 0;
OPEN_READER(bs, &row->gb);
ctx->bdsp.clear_block(block);
if (!ctx->is_444) {
if (n & 2) {
component = 1 + (n & 1);
scale = row->chroma_scale;
weight_matrix = ctx->cid_table->chroma_weight;
} else {
component = 0;
scale = row->luma_scale;
weight_matrix = ctx->cid_table->luma_weight;
}
} else {
component = (n >> 1) % 3;
if (component) {
scale = row->chroma_scale;
weight_matrix = ctx->cid_table->chroma_weight;
} else {
scale = row->luma_scale;
weight_matrix = ctx->cid_table->luma_weight;
}
}
UPDATE_CACHE(bs, &row->gb);
GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
if (len) {
level = GET_CACHE(bs, &row->gb);
LAST_SKIP_BITS(bs, &row->gb, len);
sign = ~level >> 31;
level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
row->last_dc[component] += level * (1 << dc_shift);
}
block[0] = row->last_dc[component];
i = 0;
UPDATE_CACHE(bs, &row->gb);
GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
DNXHD_VLC_BITS, 2);
while (index1 != eob_index) {
level = ac_info[2*index1+0];
flags = ac_info[2*index1+1];
sign = SHOW_SBITS(bs, &row->gb, 1);
SKIP_BITS(bs, &row->gb, 1);
if (flags & 1) {
level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
SKIP_BITS(bs, &row->gb, index_bits);
}
if (flags & 2) {
UPDATE_CACHE(bs, &row->gb);
GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
DNXHD_VLC_BITS, 2);
i += ctx->cid_table->run[index2];
}
if (++i > 63) {
av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
ret = -1;
break;
}
j = ctx->scantable.permutated[i];
level *= scale[i];
level += scale[i] >> 1;
if (level_bias < 32 || weight_matrix[i] != level_bias)
level += level_bias; // 1<<(level_shift-1)
level >>= level_shift;
block[j] = (level ^ sign) - sign;
UPDATE_CACHE(bs, &row->gb);
GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
DNXHD_VLC_BITS, 2);
}
CLOSE_READER(bs, &row->gb);
return ret;
}
| true | FFmpeg | b2be76c0a472b729756ed7a91225c209d0dd1d2e | static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx,
RowContext *row,
int n,
int index_bits,
int level_bias,
int level_shift,
int dc_shift)
{
int i, j, index1, index2, len, flags;
int level, component, sign;
const int *scale;
const uint8_t *weight_matrix;
const uint8_t *ac_info = ctx->cid_table->ac_info;
int16_t *block = row->blocks[n];
const int eob_index = ctx->cid_table->eob_index;
int ret = 0;
OPEN_READER(bs, &row->gb);
ctx->bdsp.clear_block(block);
if (!ctx->is_444) {
if (n & 2) {
component = 1 + (n & 1);
scale = row->chroma_scale;
weight_matrix = ctx->cid_table->chroma_weight;
} else {
component = 0;
scale = row->luma_scale;
weight_matrix = ctx->cid_table->luma_weight;
}
} else {
component = (n >> 1) % 3;
if (component) {
scale = row->chroma_scale;
weight_matrix = ctx->cid_table->chroma_weight;
} else {
scale = row->luma_scale;
weight_matrix = ctx->cid_table->luma_weight;
}
}
UPDATE_CACHE(bs, &row->gb);
GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
if (len) {
level = GET_CACHE(bs, &row->gb);
LAST_SKIP_BITS(bs, &row->gb, len);
sign = ~level >> 31;
level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
row->last_dc[component] += level * (1 << dc_shift);
}
block[0] = row->last_dc[component];
i = 0;
UPDATE_CACHE(bs, &row->gb);
GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
DNXHD_VLC_BITS, 2);
while (index1 != eob_index) {
level = ac_info[2*index1+0];
flags = ac_info[2*index1+1];
sign = SHOW_SBITS(bs, &row->gb, 1);
SKIP_BITS(bs, &row->gb, 1);
if (flags & 1) {
level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
SKIP_BITS(bs, &row->gb, index_bits);
}
if (flags & 2) {
UPDATE_CACHE(bs, &row->gb);
GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
DNXHD_VLC_BITS, 2);
i += ctx->cid_table->run[index2];
}
if (++i > 63) {
av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
ret = -1;
break;
}
j = ctx->scantable.permutated[i];
level *= scale[i];
level += scale[i] >> 1;
if (level_bias < 32 || weight_matrix[i] != level_bias)
level += level_bias;
level >>= level_shift;
block[j] = (level ^ sign) - sign;
UPDATE_CACHE(bs, &row->gb);
GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
DNXHD_VLC_BITS, 2);
}
CLOSE_READER(bs, &row->gb);
return ret;
}
| {
"code": [],
"line_no": []
} | static av_always_inline int FUNC_0(const DNXHDContext *ctx,
RowContext *row,
int n,
int index_bits,
int level_bias,
int level_shift,
int dc_shift)
{
int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5;
int VAR_6, VAR_7, VAR_8;
const int *VAR_9;
const uint8_t *VAR_10;
const uint8_t *VAR_11 = ctx->cid_table->VAR_11;
int16_t *block = row->blocks[n];
const int VAR_12 = ctx->cid_table->VAR_12;
int VAR_13 = 0;
OPEN_READER(bs, &row->gb);
ctx->bdsp.clear_block(block);
if (!ctx->is_444) {
if (n & 2) {
VAR_7 = 1 + (n & 1);
VAR_9 = row->chroma_scale;
VAR_10 = ctx->cid_table->chroma_weight;
} else {
VAR_7 = 0;
VAR_9 = row->luma_scale;
VAR_10 = ctx->cid_table->luma_weight;
}
} else {
VAR_7 = (n >> 1) % 3;
if (VAR_7) {
VAR_9 = row->chroma_scale;
VAR_10 = ctx->cid_table->chroma_weight;
} else {
VAR_9 = row->luma_scale;
VAR_10 = ctx->cid_table->luma_weight;
}
}
UPDATE_CACHE(bs, &row->gb);
GET_VLC(VAR_4, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
if (VAR_4) {
VAR_6 = GET_CACHE(bs, &row->gb);
LAST_SKIP_BITS(bs, &row->gb, VAR_4);
VAR_8 = ~VAR_6 >> 31;
VAR_6 = (NEG_USR32(VAR_8 ^ VAR_6, VAR_4) ^ VAR_8) - VAR_8;
row->last_dc[VAR_7] += VAR_6 * (1 << dc_shift);
}
block[0] = row->last_dc[VAR_7];
VAR_0 = 0;
UPDATE_CACHE(bs, &row->gb);
GET_VLC(VAR_2, bs, &row->gb, ctx->ac_vlc.table,
DNXHD_VLC_BITS, 2);
while (VAR_2 != VAR_12) {
VAR_6 = VAR_11[2*VAR_2+0];
VAR_5 = VAR_11[2*VAR_2+1];
VAR_8 = SHOW_SBITS(bs, &row->gb, 1);
SKIP_BITS(bs, &row->gb, 1);
if (VAR_5 & 1) {
VAR_6 += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
SKIP_BITS(bs, &row->gb, index_bits);
}
if (VAR_5 & 2) {
UPDATE_CACHE(bs, &row->gb);
GET_VLC(VAR_3, bs, &row->gb, ctx->run_vlc.table,
DNXHD_VLC_BITS, 2);
VAR_0 += ctx->cid_table->run[VAR_3];
}
if (++VAR_0 > 63) {
av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, VAR_0);
VAR_13 = -1;
break;
}
VAR_1 = ctx->scantable.permutated[VAR_0];
VAR_6 *= VAR_9[VAR_0];
VAR_6 += VAR_9[VAR_0] >> 1;
if (level_bias < 32 || VAR_10[VAR_0] != level_bias)
VAR_6 += level_bias;
VAR_6 >>= level_shift;
block[VAR_1] = (VAR_6 ^ VAR_8) - VAR_8;
UPDATE_CACHE(bs, &row->gb);
GET_VLC(VAR_2, bs, &row->gb, ctx->ac_vlc.table,
DNXHD_VLC_BITS, 2);
}
CLOSE_READER(bs, &row->gb);
return VAR_13;
}
| [
"static av_always_inline int FUNC_0(const DNXHDContext *ctx,\nRowContext *row,\nint n,\nint index_bits,\nint level_bias,\nint level_shift,\nint dc_shift)\n{",
"int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5;",
"int VAR_6, VAR_7, VAR_8;",
"const int *VAR_9;",
"const uint8_t *VAR_10;",
"const uint8_t *VAR_11 = ctx->cid_table->VAR_11;",
"int16_t *block = row->blocks[n];",
"const int VAR_12 = ctx->cid_table->VAR_12;",
"int VAR_13 = 0;",
"OPEN_READER(bs, &row->gb);",
"ctx->bdsp.clear_block(block);",
"if (!ctx->is_444) {",
"if (n & 2) {",
"VAR_7 = 1 + (n & 1);",
"VAR_9 = row->chroma_scale;",
"VAR_10 = ctx->cid_table->chroma_weight;",
"} else {",
"VAR_7 = 0;",
"VAR_9 = row->luma_scale;",
"VAR_10 = ctx->cid_table->luma_weight;",
"}",
"} else {",
"VAR_7 = (n >> 1) % 3;",
"if (VAR_7) {",
"VAR_9 = row->chroma_scale;",
"VAR_10 = ctx->cid_table->chroma_weight;",
"} else {",
"VAR_9 = row->luma_scale;",
"VAR_10 = ctx->cid_table->luma_weight;",
"}",
"}",
"UPDATE_CACHE(bs, &row->gb);",
"GET_VLC(VAR_4, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);",
"if (VAR_4) {",
"VAR_6 = GET_CACHE(bs, &row->gb);",
"LAST_SKIP_BITS(bs, &row->gb, VAR_4);",
"VAR_8 = ~VAR_6 >> 31;",
"VAR_6 = (NEG_USR32(VAR_8 ^ VAR_6, VAR_4) ^ VAR_8) - VAR_8;",
"row->last_dc[VAR_7] += VAR_6 * (1 << dc_shift);",
"}",
"block[0] = row->last_dc[VAR_7];",
"VAR_0 = 0;",
"UPDATE_CACHE(bs, &row->gb);",
"GET_VLC(VAR_2, bs, &row->gb, ctx->ac_vlc.table,\nDNXHD_VLC_BITS, 2);",
"while (VAR_2 != VAR_12) {",
"VAR_6 = VAR_11[2*VAR_2+0];",
"VAR_5 = VAR_11[2*VAR_2+1];",
"VAR_8 = SHOW_SBITS(bs, &row->gb, 1);",
"SKIP_BITS(bs, &row->gb, 1);",
"if (VAR_5 & 1) {",
"VAR_6 += SHOW_UBITS(bs, &row->gb, index_bits) << 7;",
"SKIP_BITS(bs, &row->gb, index_bits);",
"}",
"if (VAR_5 & 2) {",
"UPDATE_CACHE(bs, &row->gb);",
"GET_VLC(VAR_3, bs, &row->gb, ctx->run_vlc.table,\nDNXHD_VLC_BITS, 2);",
"VAR_0 += ctx->cid_table->run[VAR_3];",
"}",
"if (++VAR_0 > 63) {",
"av_log(ctx->avctx, AV_LOG_ERROR, \"ac tex damaged %d, %d\\n\", n, VAR_0);",
"VAR_13 = -1;",
"break;",
"}",
"VAR_1 = ctx->scantable.permutated[VAR_0];",
"VAR_6 *= VAR_9[VAR_0];",
"VAR_6 += VAR_9[VAR_0] >> 1;",
"if (level_bias < 32 || VAR_10[VAR_0] != level_bias)\nVAR_6 += level_bias;",
"VAR_6 >>= level_shift;",
"block[VAR_1] = (VAR_6 ^ VAR_8) - VAR_8;",
"UPDATE_CACHE(bs, &row->gb);",
"GET_VLC(VAR_2, bs, &row->gb, ctx->ac_vlc.table,\nDNXHD_VLC_BITS, 2);",
"}",
"CLOSE_READER(bs, &row->gb);",
"return VAR_13;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
109
],
[
111,
113
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
141
],
[
143
],
[
145,
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
169
],
[
171
],
[
173,
175
],
[
177
],
[
181
],
[
185
],
[
187,
189
],
[
191
],
[
195
],
[
197
],
[
199
]
] |
21,613 | static void pci_write(void *opaque, hwaddr addr, uint64_t data,
unsigned int size)
{
AcpiPciHpState *s = opaque;
switch (addr) {
case PCI_EJ_BASE:
if (s->hotplug_select >= ACPI_PCIHP_MAX_HOTPLUG_BUS) {
break;
}
acpi_pcihp_eject_slot(s, s->hotplug_select, data);
ACPI_PCIHP_DPRINTF("pciej write %" HWADDR_PRIx " <== %" PRIu64 "\n",
addr, data);
break;
case PCI_SEL_BASE:
s->hotplug_select = data;
ACPI_PCIHP_DPRINTF("pcisel write %" HWADDR_PRIx " <== %" PRIu64 "\n",
addr, data);
default:
break;
}
}
| false | qemu | f5855994fee2f8815dc86b8453e4a63e290aea05 | static void pci_write(void *opaque, hwaddr addr, uint64_t data,
unsigned int size)
{
AcpiPciHpState *s = opaque;
switch (addr) {
case PCI_EJ_BASE:
if (s->hotplug_select >= ACPI_PCIHP_MAX_HOTPLUG_BUS) {
break;
}
acpi_pcihp_eject_slot(s, s->hotplug_select, data);
ACPI_PCIHP_DPRINTF("pciej write %" HWADDR_PRIx " <== %" PRIu64 "\n",
addr, data);
break;
case PCI_SEL_BASE:
s->hotplug_select = data;
ACPI_PCIHP_DPRINTF("pcisel write %" HWADDR_PRIx " <== %" PRIu64 "\n",
addr, data);
default:
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,
unsigned int VAR_3)
{
AcpiPciHpState *s = VAR_0;
switch (VAR_1) {
case PCI_EJ_BASE:
if (s->hotplug_select >= ACPI_PCIHP_MAX_HOTPLUG_BUS) {
break;
}
acpi_pcihp_eject_slot(s, s->hotplug_select, VAR_2);
ACPI_PCIHP_DPRINTF("pciej write %" HWADDR_PRIx " <== %" PRIu64 "\n",
VAR_1, VAR_2);
break;
case PCI_SEL_BASE:
s->hotplug_select = VAR_2;
ACPI_PCIHP_DPRINTF("pcisel write %" HWADDR_PRIx " <== %" PRIu64 "\n",
VAR_1, VAR_2);
default:
break;
}
}
| [
"static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned int VAR_3)\n{",
"AcpiPciHpState *s = VAR_0;",
"switch (VAR_1) {",
"case PCI_EJ_BASE:\nif (s->hotplug_select >= ACPI_PCIHP_MAX_HOTPLUG_BUS) {",
"break;",
"}",
"acpi_pcihp_eject_slot(s, s->hotplug_select, VAR_2);",
"ACPI_PCIHP_DPRINTF(\"pciej write %\" HWADDR_PRIx \" <== %\" PRIu64 \"\\n\",\nVAR_1, VAR_2);",
"break;",
"case PCI_SEL_BASE:\ns->hotplug_select = VAR_2;",
"ACPI_PCIHP_DPRINTF(\"pcisel write %\" HWADDR_PRIx \" <== %\" PRIu64 \"\\n\",\nVAR_1, VAR_2);",
"default:\nbreak;",
"}",
"}"
] | [
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
]
] |
21,614 | int64_t qemu_strtosz(const char *nptr, char **end)
{
return do_strtosz(nptr, end, 'B', 1024);
}
| false | qemu | f17fd4fdf0df3d2f3444399d04c38d22b9a3e1b7 | int64_t qemu_strtosz(const char *nptr, char **end)
{
return do_strtosz(nptr, end, 'B', 1024);
}
| {
"code": [],
"line_no": []
} | int64_t FUNC_0(const char *nptr, char **end)
{
return do_strtosz(nptr, end, 'B', 1024);
}
| [
"int64_t FUNC_0(const char *nptr, char **end)\n{",
"return do_strtosz(nptr, end, 'B', 1024);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.