id int32 0 27.3k | func stringlengths 26 142k | target bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 | func_clean stringlengths 26 131k | vul_lines dict | normalized_func stringlengths 24 132k | lines listlengths 1 2.8k | label listlengths 1 2.8k | line_no listlengths 1 2.8k |
|---|---|---|---|---|---|---|---|---|---|---|
15,569 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt) {
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
NuvContext *c = avctx->priv_data;
AVFrame *picture = data;
int orig_size = buf_size;
int keyframe;
int result;
enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',
NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',
NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} comptype;
if (buf_size < 12) {
av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");
return -1;
}
// codec data (rtjpeg quant tables)
if (buf[0] == 'D' && buf[1] == 'R') {
int ret;
// skip rest of the frameheader.
buf = &buf[12];
buf_size -= 12;
ret = get_quant(avctx, c, buf, buf_size);
if (ret < 0)
return ret;
ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height, c->lq, c->cq);
return orig_size;
}
if (buf[0] != 'V' || buf_size < 12) {
av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");
return -1;
}
comptype = buf[1];
switch (comptype) {
case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG:
keyframe = !buf[2]; break;
case NUV_COPY_LAST:
keyframe = 0; break;
default:
keyframe = 1; break;
}
// skip rest of the frameheader.
buf = &buf[12];
buf_size -= 12;
if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {
int outlen = c->decomp_size, inlen = buf_size;
if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen))
av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");
buf = c->decomp_buf;
buf_size = c->decomp_size;
}
if (c->codec_frameheader) {
int w, h, q;
if (buf_size < 12) {
av_log(avctx, AV_LOG_ERROR, "invalid nuv video frame\n");
return -1;
}
w = AV_RL16(&buf[6]);
h = AV_RL16(&buf[8]);
q = buf[10];
if (!codec_reinit(avctx, w, h, q))
return -1;
buf = &buf[12];
buf_size -= 12;
}
if (keyframe && c->pic.data[0])
avctx->release_buffer(avctx, &c->pic);
c->pic.reference = 3;
c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |
FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
result = avctx->reget_buffer(avctx, &c->pic);
if (result < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
c->pic.key_frame = keyframe;
// decompress/copy/whatever data
switch (comptype) {
case NUV_LZO:
case NUV_UNCOMPRESSED: {
int height = c->height;
if (buf_size < c->width * height * 3 / 2) {
av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");
height = buf_size / c->width / 3 * 2;
}
copy_frame(&c->pic, buf, c->width, height);
break;
}
case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG: {
ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, buf, buf_size);
break;
}
case NUV_BLACK: {
memset(c->pic.data[0], 0, c->width * c->height);
memset(c->pic.data[1], 128, c->width * c->height / 4);
memset(c->pic.data[2], 128, c->width * c->height / 4);
break;
}
case NUV_COPY_LAST: {
/* nothing more to do here */
break;
}
default:
av_log(avctx, AV_LOG_ERROR, "unknown compression\n");
return -1;
}
*picture = c->pic;
*data_size = sizeof(AVFrame);
return orig_size;
}
| false | FFmpeg | 859a579e9bbf47fae2e09494c43bcf813dcb2fad | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt) {
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
NuvContext *c = avctx->priv_data;
AVFrame *picture = data;
int orig_size = buf_size;
int keyframe;
int result;
enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',
NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',
NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} comptype;
if (buf_size < 12) {
av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");
return -1;
}
if (buf[0] == 'D' && buf[1] == 'R') {
int ret;
buf = &buf[12];
buf_size -= 12;
ret = get_quant(avctx, c, buf, buf_size);
if (ret < 0)
return ret;
ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height, c->lq, c->cq);
return orig_size;
}
if (buf[0] != 'V' || buf_size < 12) {
av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");
return -1;
}
comptype = buf[1];
switch (comptype) {
case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG:
keyframe = !buf[2]; break;
case NUV_COPY_LAST:
keyframe = 0; break;
default:
keyframe = 1; break;
}
buf = &buf[12];
buf_size -= 12;
if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {
int outlen = c->decomp_size, inlen = buf_size;
if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen))
av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");
buf = c->decomp_buf;
buf_size = c->decomp_size;
}
if (c->codec_frameheader) {
int w, h, q;
if (buf_size < 12) {
av_log(avctx, AV_LOG_ERROR, "invalid nuv video frame\n");
return -1;
}
w = AV_RL16(&buf[6]);
h = AV_RL16(&buf[8]);
q = buf[10];
if (!codec_reinit(avctx, w, h, q))
return -1;
buf = &buf[12];
buf_size -= 12;
}
if (keyframe && c->pic.data[0])
avctx->release_buffer(avctx, &c->pic);
c->pic.reference = 3;
c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |
FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
result = avctx->reget_buffer(avctx, &c->pic);
if (result < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
c->pic.key_frame = keyframe;
switch (comptype) {
case NUV_LZO:
case NUV_UNCOMPRESSED: {
int height = c->height;
if (buf_size < c->width * height * 3 / 2) {
av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");
height = buf_size / c->width / 3 * 2;
}
copy_frame(&c->pic, buf, c->width, height);
break;
}
case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG: {
ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, buf, buf_size);
break;
}
case NUV_BLACK: {
memset(c->pic.data[0], 0, c->width * c->height);
memset(c->pic.data[1], 128, c->width * c->height / 4);
memset(c->pic.data[2], 128, c->width * c->height / 4);
break;
}
case NUV_COPY_LAST: {
break;
}
default:
av_log(avctx, AV_LOG_ERROR, "unknown compression\n");
return -1;
}
*picture = c->pic;
*data_size = sizeof(AVFrame);
return orig_size;
}
| {
"code": [],
"line_no": []
} | static 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;
NuvContext *c = VAR_0->priv_data;
AVFrame *picture = VAR_1;
int VAR_6 = VAR_5;
int VAR_7;
int VAR_8;
enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',
NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',
NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} VAR_9;
if (VAR_5 < 12) {
av_log(VAR_0, AV_LOG_ERROR, "coded frame too small\n");
return -1;
}
if (VAR_4[0] == 'D' && VAR_4[1] == 'R') {
int VAR_10;
VAR_4 = &VAR_4[12];
VAR_5 -= 12;
VAR_10 = get_quant(VAR_0, c, VAR_4, VAR_5);
if (VAR_10 < 0)
return VAR_10;
ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->VAR_16, c->lq, c->cq);
return VAR_6;
}
if (VAR_4[0] != 'V' || VAR_5 < 12) {
av_log(VAR_0, AV_LOG_ERROR, "not a nuv video frame\n");
return -1;
}
VAR_9 = VAR_4[1];
switch (VAR_9) {
case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG:
VAR_7 = !VAR_4[2]; break;
case NUV_COPY_LAST:
VAR_7 = 0; break;
default:
VAR_7 = 1; break;
}
VAR_4 = &VAR_4[12];
VAR_5 -= 12;
if (VAR_9 == NUV_RTJPEG_IN_LZO || VAR_9 == NUV_LZO) {
int VAR_11 = c->decomp_size, VAR_12 = VAR_5;
if (av_lzo1x_decode(c->decomp_buf, &VAR_11, VAR_4, &VAR_12))
av_log(VAR_0, AV_LOG_ERROR, "error during lzo decompression\n");
VAR_4 = c->decomp_buf;
VAR_5 = c->decomp_size;
}
if (c->codec_frameheader) {
int VAR_13, VAR_14, VAR_15;
if (VAR_5 < 12) {
av_log(VAR_0, AV_LOG_ERROR, "invalid nuv video frame\n");
return -1;
}
VAR_13 = AV_RL16(&VAR_4[6]);
VAR_14 = AV_RL16(&VAR_4[8]);
VAR_15 = VAR_4[10];
if (!codec_reinit(VAR_0, VAR_13, VAR_14, VAR_15))
return -1;
VAR_4 = &VAR_4[12];
VAR_5 -= 12;
}
if (VAR_7 && c->pic.VAR_1[0])
VAR_0->release_buffer(VAR_0, &c->pic);
c->pic.reference = 3;
c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |
FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
VAR_8 = VAR_0->reget_buffer(VAR_0, &c->pic);
if (VAR_8 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
c->pic.pict_type = VAR_7 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
c->pic.key_frame = VAR_7;
switch (VAR_9) {
case NUV_LZO:
case NUV_UNCOMPRESSED: {
int VAR_16 = c->VAR_16;
if (VAR_5 < c->width * VAR_16 * 3 / 2) {
av_log(VAR_0, AV_LOG_ERROR, "uncompressed frame too short\n");
VAR_16 = VAR_5 / c->width / 3 * 2;
}
copy_frame(&c->pic, VAR_4, c->width, VAR_16);
break;
}
case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG: {
ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, VAR_4, VAR_5);
break;
}
case NUV_BLACK: {
memset(c->pic.VAR_1[0], 0, c->width * c->VAR_16);
memset(c->pic.VAR_1[1], 128, c->width * c->VAR_16 / 4);
memset(c->pic.VAR_1[2], 128, c->width * c->VAR_16 / 4);
break;
}
case NUV_COPY_LAST: {
break;
}
default:
av_log(VAR_0, AV_LOG_ERROR, "unknown compression\n");
return -1;
}
*picture = c->pic;
*VAR_2 = sizeof(AVFrame);
return VAR_6;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3) {",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"NuvContext *c = VAR_0->priv_data;",
"AVFrame *picture = VAR_1;",
"int VAR_6 = VAR_5;",
"int VAR_7;",
"int VAR_8;",
"enum {NUV_UNCOMPRESSED = '... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21,
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[... |
15,570 | qio_channel_websock_extract_headers(char *buffer,
QIOChannelWebsockHTTPHeader *hdrs,
size_t nhdrsalloc,
Error **errp)
{
char *nl, *sep, *tmp;
size_t nhdrs = 0;
/*
* First parse the HTTP protocol greeting of format:
*
* $METHOD $PATH $VERSION
*
* e.g.
*
* GET / HTTP/1.1
*/
nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
if (!nl) {
error_setg(errp, "Missing HTTP header delimiter");
return 0;
}
*nl = '\0';
tmp = strchr(buffer, ' ');
if (!tmp) {
error_setg(errp, "Missing HTTP path delimiter");
return 0;
}
*tmp = '\0';
if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {
error_setg(errp, "Unsupported HTTP method %s", buffer);
return 0;
}
buffer = tmp + 1;
tmp = strchr(buffer, ' ');
if (!tmp) {
error_setg(errp, "Missing HTTP version delimiter");
return 0;
}
*tmp = '\0';
if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
error_setg(errp, "Unexpected HTTP path %s", buffer);
return 0;
}
buffer = tmp + 1;
if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {
error_setg(errp, "Unsupported HTTP version %s", buffer);
return 0;
}
buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
/*
* Now parse all the header fields of format
*
* $NAME: $VALUE
*
* e.g.
*
* Cache-control: no-cache
*/
do {
QIOChannelWebsockHTTPHeader *hdr;
nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
if (nl) {
*nl = '\0';
}
sep = strchr(buffer, ':');
if (!sep) {
error_setg(errp, "Malformed HTTP header");
return 0;
}
*sep = '\0';
sep++;
while (*sep == ' ') {
sep++;
}
if (nhdrs >= nhdrsalloc) {
error_setg(errp, "Too many HTTP headers");
return 0;
}
hdr = &hdrs[nhdrs++];
hdr->name = buffer;
hdr->value = sep;
/* Canonicalize header name for easier identification later */
for (tmp = hdr->name; *tmp; tmp++) {
*tmp = g_ascii_tolower(*tmp);
}
if (nl) {
buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
}
} while (nl != NULL);
return nhdrs;
}
| true | qemu | f69a8bde29354493ff8aea64cc9cb3b531d16337 | qio_channel_websock_extract_headers(char *buffer,
QIOChannelWebsockHTTPHeader *hdrs,
size_t nhdrsalloc,
Error **errp)
{
char *nl, *sep, *tmp;
size_t nhdrs = 0;
nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
if (!nl) {
error_setg(errp, "Missing HTTP header delimiter");
return 0;
}
*nl = '\0';
tmp = strchr(buffer, ' ');
if (!tmp) {
error_setg(errp, "Missing HTTP path delimiter");
return 0;
}
*tmp = '\0';
if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {
error_setg(errp, "Unsupported HTTP method %s", buffer);
return 0;
}
buffer = tmp + 1;
tmp = strchr(buffer, ' ');
if (!tmp) {
error_setg(errp, "Missing HTTP version delimiter");
return 0;
}
*tmp = '\0';
if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
error_setg(errp, "Unexpected HTTP path %s", buffer);
return 0;
}
buffer = tmp + 1;
if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {
error_setg(errp, "Unsupported HTTP version %s", buffer);
return 0;
}
buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
do {
QIOChannelWebsockHTTPHeader *hdr;
nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
if (nl) {
*nl = '\0';
}
sep = strchr(buffer, ':');
if (!sep) {
error_setg(errp, "Malformed HTTP header");
return 0;
}
*sep = '\0';
sep++;
while (*sep == ' ') {
sep++;
}
if (nhdrs >= nhdrsalloc) {
error_setg(errp, "Too many HTTP headers");
return 0;
}
hdr = &hdrs[nhdrs++];
hdr->name = buffer;
hdr->value = sep;
for (tmp = hdr->name; *tmp; tmp++) {
*tmp = g_ascii_tolower(*tmp);
}
if (nl) {
buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
}
} while (nl != NULL);
return nhdrs;
}
| {
"code": [
"qio_channel_websock_extract_headers(char *buffer,",
" return 0;",
" return 0;",
" return 0;",
" return 0;",
" return 0;",
" return 0;"
],
"line_no": [
1,
43,
43,
43,
43,
159,
159
]
} | FUNC_0(char *VAR_0,
QIOChannelWebsockHTTPHeader *VAR_1,
size_t VAR_2,
Error **VAR_3)
{
char *VAR_4, *VAR_5, *VAR_6;
size_t nhdrs = 0;
VAR_4 = strstr(VAR_0, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
if (!VAR_4) {
error_setg(VAR_3, "Missing HTTP header delimiter");
return 0;
}
*VAR_4 = '\0';
VAR_6 = strchr(VAR_0, ' ');
if (!VAR_6) {
error_setg(VAR_3, "Missing HTTP path delimiter");
return 0;
}
*VAR_6 = '\0';
if (!g_str_equal(VAR_0, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {
error_setg(VAR_3, "Unsupported HTTP method %s", VAR_0);
return 0;
}
VAR_0 = VAR_6 + 1;
VAR_6 = strchr(VAR_0, ' ');
if (!VAR_6) {
error_setg(VAR_3, "Missing HTTP version delimiter");
return 0;
}
*VAR_6 = '\0';
if (!g_str_equal(VAR_0, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {
error_setg(VAR_3, "Unexpected HTTP path %s", VAR_0);
return 0;
}
VAR_0 = VAR_6 + 1;
if (!g_str_equal(VAR_0, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {
error_setg(VAR_3, "Unsupported HTTP version %s", VAR_0);
return 0;
}
VAR_0 = VAR_4 + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
do {
QIOChannelWebsockHTTPHeader *hdr;
VAR_4 = strstr(VAR_0, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
if (VAR_4) {
*VAR_4 = '\0';
}
VAR_5 = strchr(VAR_0, ':');
if (!VAR_5) {
error_setg(VAR_3, "Malformed HTTP header");
return 0;
}
*VAR_5 = '\0';
VAR_5++;
while (*VAR_5 == ' ') {
VAR_5++;
}
if (nhdrs >= VAR_2) {
error_setg(VAR_3, "Too many HTTP headers");
return 0;
}
hdr = &VAR_1[nhdrs++];
hdr->name = VAR_0;
hdr->value = VAR_5;
for (VAR_6 = hdr->name; *VAR_6; VAR_6++) {
*VAR_6 = g_ascii_tolower(*VAR_6);
}
if (VAR_4) {
VAR_0 = VAR_4 + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);
}
} while (VAR_4 != NULL);
return nhdrs;
}
| [
"FUNC_0(char *VAR_0,\nQIOChannelWebsockHTTPHeader *VAR_1,\nsize_t VAR_2,\nError **VAR_3)\n{",
"char *VAR_4, *VAR_5, *VAR_6;",
"size_t nhdrs = 0;",
"VAR_4 = strstr(VAR_0, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);",
"if (!VAR_4) {",
"error_setg(VAR_3, \"Missing HTTP header delimiter\");",
"return 0;",
"}",
... | [
1,
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,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[... |
15,571 | static inline void cris_ftag_d(unsigned int x)
{
register unsigned int v asm("$r10") = x;
asm ("ftagd\t[%0]\n" : : "r" (v) );
}
| true | qemu | 21ce148c7ec71ee32834061355a5ecfd1a11f90f | static inline void cris_ftag_d(unsigned int x)
{
register unsigned int v asm("$r10") = x;
asm ("ftagd\t[%0]\n" : : "r" (v) );
}
| {
"code": [
"static inline void cris_ftag_d(unsigned int x)"
],
"line_no": [
1
]
} | static inline void FUNC_0(unsigned int VAR_0)
{
register unsigned int VAR_1 asm("$r10") = VAR_0;
asm ("ftagd\t[%0]\n" : : "r" (VAR_1) );
}
| [
"static inline void FUNC_0(unsigned int VAR_0)\n{",
"register unsigned int VAR_1 asm(\"$r10\") = VAR_0;",
"asm (\"ftagd\\t[%0]\\n\" : : \"r\" (VAR_1) );",
"}"
] | [
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
15,572 | int spapr_h_cas_compose_response(sPAPRMachineState *spapr,
target_ulong addr, target_ulong size,
sPAPROptionVector *ov5_updates)
{
void *fdt, *fdt_skel;
sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
if (spapr_hotplugged_dev_before_cas()) {
return 1;
size -= sizeof(hdr);
/* Create skeleton */
fdt_skel = g_malloc0(size);
_FDT((fdt_create(fdt_skel, size)));
_FDT((fdt_begin_node(fdt_skel, "")));
_FDT((fdt_end_node(fdt_skel)));
_FDT((fdt_finish(fdt_skel)));
fdt = g_malloc0(size);
_FDT((fdt_open_into(fdt_skel, fdt, size)));
g_free(fdt_skel);
/* Fixup cpu nodes */
_FDT((spapr_fixup_cpu_dt(fdt, spapr)));
if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) {
return -1;
/* Pack resulting tree */
_FDT((fdt_pack(fdt)));
if (fdt_totalsize(fdt) + sizeof(hdr) > size) {
trace_spapr_cas_failed(size);
return -1;
cpu_physical_memory_write(addr, &hdr, sizeof(hdr));
cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt));
trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr));
g_free(fdt);
return 0; | true | qemu | 827b17c468b0dae69f82f852958d16f4bf6d6bf0 | int spapr_h_cas_compose_response(sPAPRMachineState *spapr,
target_ulong addr, target_ulong size,
sPAPROptionVector *ov5_updates)
{
void *fdt, *fdt_skel;
sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
if (spapr_hotplugged_dev_before_cas()) {
return 1;
size -= sizeof(hdr);
fdt_skel = g_malloc0(size);
_FDT((fdt_create(fdt_skel, size)));
_FDT((fdt_begin_node(fdt_skel, "")));
_FDT((fdt_end_node(fdt_skel)));
_FDT((fdt_finish(fdt_skel)));
fdt = g_malloc0(size);
_FDT((fdt_open_into(fdt_skel, fdt, size)));
g_free(fdt_skel);
_FDT((spapr_fixup_cpu_dt(fdt, spapr)));
if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) {
return -1;
_FDT((fdt_pack(fdt)));
if (fdt_totalsize(fdt) + sizeof(hdr) > size) {
trace_spapr_cas_failed(size);
return -1;
cpu_physical_memory_write(addr, &hdr, sizeof(hdr));
cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt));
trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr));
g_free(fdt);
return 0; | {
"code": [],
"line_no": []
} | int FUNC_0(sPAPRMachineState *VAR_0,
target_ulong VAR_1, target_ulong VAR_2,
sPAPROptionVector *VAR_3)
{
void *VAR_4, *VAR_5;
sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
if (spapr_hotplugged_dev_before_cas()) {
return 1;
VAR_2 -= sizeof(hdr);
VAR_5 = g_malloc0(VAR_2);
_FDT((fdt_create(VAR_5, VAR_2)));
_FDT((fdt_begin_node(VAR_5, "")));
_FDT((fdt_end_node(VAR_5)));
_FDT((fdt_finish(VAR_5)));
VAR_4 = g_malloc0(VAR_2);
_FDT((fdt_open_into(VAR_5, VAR_4, VAR_2)));
g_free(VAR_5);
_FDT((spapr_fixup_cpu_dt(VAR_4, VAR_0)));
if (spapr_dt_cas_updates(VAR_0, VAR_4, VAR_3)) {
return -1;
_FDT((fdt_pack(VAR_4)));
if (fdt_totalsize(VAR_4) + sizeof(hdr) > VAR_2) {
trace_spapr_cas_failed(VAR_2);
return -1;
cpu_physical_memory_write(VAR_1, &hdr, sizeof(hdr));
cpu_physical_memory_write(VAR_1 + sizeof(hdr), VAR_4, fdt_totalsize(VAR_4));
trace_spapr_cas_continue(fdt_totalsize(VAR_4) + sizeof(hdr));
g_free(VAR_4);
return 0; | [
"int FUNC_0(sPAPRMachineState *VAR_0,\ntarget_ulong VAR_1, target_ulong VAR_2,\nsPAPROptionVector *VAR_3)\n{",
"void *VAR_4, *VAR_5;",
"sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };",
"if (spapr_hotplugged_dev_before_cas()) {",
"return 1;",
"VAR_2 -= sizeof(hdr);",
"VAR_5 = g_malloc0(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
] | [
[
1,
2,
3,
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
20
],
[
21
],
[
22
],
[
24
],
[
25
],... |
15,573 | static void wav_destroy (void *opaque)
{
WAVState *wav = opaque;
uint8_t rlen[4];
uint8_t dlen[4];
uint32_t datalen = wav->bytes;
uint32_t rifflen = datalen + 36;
if (!wav->f) {
return;
}
le_store (rlen, rifflen, 4);
le_store (dlen, datalen, 4);
qemu_fseek (wav->f, 4, SEEK_SET);
qemu_put_buffer (wav->f, rlen, 4);
qemu_fseek (wav->f, 32, SEEK_CUR);
qemu_put_buffer (wav->f, dlen, 4);
qemu_fclose (wav->f);
if (wav->path) {
qemu_free (wav->path);
}
}
| true | qemu | e84a4fedf74983ad0517b4754f927a96a2eea7ce | static void wav_destroy (void *opaque)
{
WAVState *wav = opaque;
uint8_t rlen[4];
uint8_t dlen[4];
uint32_t datalen = wav->bytes;
uint32_t rifflen = datalen + 36;
if (!wav->f) {
return;
}
le_store (rlen, rifflen, 4);
le_store (dlen, datalen, 4);
qemu_fseek (wav->f, 4, SEEK_SET);
qemu_put_buffer (wav->f, rlen, 4);
qemu_fseek (wav->f, 32, SEEK_CUR);
qemu_put_buffer (wav->f, dlen, 4);
qemu_fclose (wav->f);
if (wav->path) {
qemu_free (wav->path);
}
}
| {
"code": [
" if (!wav->f) {",
" le_store (rlen, rifflen, 4);",
" le_store (dlen, datalen, 4);",
" qemu_fseek (wav->f, 4, SEEK_SET);",
" qemu_put_buffer (wav->f, rlen, 4);",
" qemu_fseek (wav->f, 32, SEEK_CUR);",
" qemu_put_buffer (wav->f, dlen, 4);",
" qemu_fclose (wav->f);",
" if (wav->path) {",
" qemu_free (wav->path);"
],
"line_no": [
17,
25,
27,
31,
33,
37,
39,
41,
43,
45
]
} | static void FUNC_0 (void *VAR_0)
{
WAVState *wav = VAR_0;
uint8_t rlen[4];
uint8_t dlen[4];
uint32_t datalen = wav->bytes;
uint32_t rifflen = datalen + 36;
if (!wav->f) {
return;
}
le_store (rlen, rifflen, 4);
le_store (dlen, datalen, 4);
qemu_fseek (wav->f, 4, SEEK_SET);
qemu_put_buffer (wav->f, rlen, 4);
qemu_fseek (wav->f, 32, SEEK_CUR);
qemu_put_buffer (wav->f, dlen, 4);
qemu_fclose (wav->f);
if (wav->path) {
qemu_free (wav->path);
}
}
| [
"static void FUNC_0 (void *VAR_0)\n{",
"WAVState *wav = VAR_0;",
"uint8_t rlen[4];",
"uint8_t dlen[4];",
"uint32_t datalen = wav->bytes;",
"uint32_t rifflen = datalen + 36;",
"if (!wav->f) {",
"return;",
"}",
"le_store (rlen, rifflen, 4);",
"le_store (dlen, datalen, 4);",
"qemu_fseek (wav->f, ... | [
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
... |
15,574 | void event_notifier_cleanup(EventNotifier *e)
{
CloseHandle(e->event);
} | true | qemu | aa262928595d431bfee7914cb7d9d79197f887a2 | void event_notifier_cleanup(EventNotifier *e)
{
CloseHandle(e->event);
} | {
"code": [],
"line_no": []
} | void FUNC_0(EventNotifier *VAR_0)
{
CloseHandle(VAR_0->event);
} | [
"void FUNC_0(EventNotifier *VAR_0)\n{",
"CloseHandle(VAR_0->event);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
8
]
] |
15,575 | static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
unsigned int c, const unsigned int *div_blocks,
unsigned int *js_blocks)
{
unsigned int b;
ALSBlockData bd = { 0 };
bd.ra_block = ra_frame;
bd.const_block = ctx->const_block;
bd.shift_lsbs = ctx->shift_lsbs;
bd.opt_order = ctx->opt_order;
bd.store_prev_samples = ctx->store_prev_samples;
bd.use_ltp = ctx->use_ltp;
bd.ltp_lag = ctx->ltp_lag;
bd.ltp_gain = ctx->ltp_gain[0];
bd.quant_cof = ctx->quant_cof[0];
bd.lpc_cof = ctx->lpc_cof[0];
bd.prev_raw_samples = ctx->prev_raw_samples;
bd.raw_samples = ctx->raw_samples[c];
for (b = 0; b < ctx->num_blocks; b++) {
bd.block_length = div_blocks[b];
if (read_decode_block(ctx, &bd)) {
// damaged block, write zero for the rest of the frame
zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
return -1;
}
bd.raw_samples += div_blocks[b];
bd.ra_block = 0;
}
return 0;
}
| true | FFmpeg | ca488ad480360dfafcb5766f7bfbb567a0638979 | static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
unsigned int c, const unsigned int *div_blocks,
unsigned int *js_blocks)
{
unsigned int b;
ALSBlockData bd = { 0 };
bd.ra_block = ra_frame;
bd.const_block = ctx->const_block;
bd.shift_lsbs = ctx->shift_lsbs;
bd.opt_order = ctx->opt_order;
bd.store_prev_samples = ctx->store_prev_samples;
bd.use_ltp = ctx->use_ltp;
bd.ltp_lag = ctx->ltp_lag;
bd.ltp_gain = ctx->ltp_gain[0];
bd.quant_cof = ctx->quant_cof[0];
bd.lpc_cof = ctx->lpc_cof[0];
bd.prev_raw_samples = ctx->prev_raw_samples;
bd.raw_samples = ctx->raw_samples[c];
for (b = 0; b < ctx->num_blocks; b++) {
bd.block_length = div_blocks[b];
if (read_decode_block(ctx, &bd)) {
zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
return -1;
}
bd.raw_samples += div_blocks[b];
bd.ra_block = 0;
}
return 0;
}
| {
"code": [
" return -1;",
" return -1;",
" return -1;",
" return 0;",
" if (read_decode_block(ctx, &bd)) {",
" return -1;",
" return -1;",
" return -1;"
],
"line_no": [
55,
55,
55,
67,
49,
55,
55,
55
]
} | static int FUNC_0(ALSDecContext *VAR_0, unsigned int VAR_1,
unsigned int VAR_2, const unsigned int *VAR_3,
unsigned int *VAR_4)
{
unsigned int VAR_5;
ALSBlockData bd = { 0 };
bd.ra_block = VAR_1;
bd.const_block = VAR_0->const_block;
bd.shift_lsbs = VAR_0->shift_lsbs;
bd.opt_order = VAR_0->opt_order;
bd.store_prev_samples = VAR_0->store_prev_samples;
bd.use_ltp = VAR_0->use_ltp;
bd.ltp_lag = VAR_0->ltp_lag;
bd.ltp_gain = VAR_0->ltp_gain[0];
bd.quant_cof = VAR_0->quant_cof[0];
bd.lpc_cof = VAR_0->lpc_cof[0];
bd.prev_raw_samples = VAR_0->prev_raw_samples;
bd.raw_samples = VAR_0->raw_samples[VAR_2];
for (VAR_5 = 0; VAR_5 < VAR_0->num_blocks; VAR_5++) {
bd.block_length = VAR_3[VAR_5];
if (read_decode_block(VAR_0, &bd)) {
zero_remaining(VAR_5, VAR_0->num_blocks, VAR_3, bd.raw_samples);
return -1;
}
bd.raw_samples += VAR_3[VAR_5];
bd.ra_block = 0;
}
return 0;
}
| [
"static int FUNC_0(ALSDecContext *VAR_0, unsigned int VAR_1,\nunsigned int VAR_2, const unsigned int *VAR_3,\nunsigned int *VAR_4)\n{",
"unsigned int VAR_5;",
"ALSBlockData bd = { 0 };",
"bd.ra_block = VAR_1;",
"bd.const_block = VAR_0->const_block;",
"bd.shift_lsbs = VAR_0->shift_lsbs;"... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
1,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
43
],
[
45
],
[
49
],
[
53
... |
15,576 | int ff_load_image(uint8_t *data[4], int linesize[4],
int *w, int *h, enum AVPixelFormat *pix_fmt,
const char *filename, void *log_ctx)
{
AVInputFormat *iformat = NULL;
AVFormatContext *format_ctx = NULL;
AVCodec *codec;
AVCodecContext *codec_ctx;
AVFrame *frame;
int frame_decoded, ret = 0;
AVPacket pkt;
av_register_all();
iformat = av_find_input_format("image2");
if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {
av_log(log_ctx, AV_LOG_ERROR,
"Failed to open input file '%s'\n", filename);
return ret;
}
codec_ctx = format_ctx->streams[0]->codec;
codec = avcodec_find_decoder(codec_ctx->codec_id);
if (!codec) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to find codec\n");
ret = AVERROR(EINVAL);
goto end;
}
if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to open codec\n");
goto end;
}
if (!(frame = avcodec_alloc_frame()) ) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to alloc frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
ret = av_read_frame(format_ctx, &pkt);
if (ret < 0) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to read frame from file\n");
goto end;
}
ret = avcodec_decode_video2(codec_ctx, frame, &frame_decoded, &pkt);
if (ret < 0 || !frame_decoded) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to decode image from file\n");
goto end;
}
ret = 0;
*w = frame->width;
*h = frame->height;
*pix_fmt = frame->format;
if ((ret = av_image_alloc(data, linesize, *w, *h, *pix_fmt, 16)) < 0)
goto end;
ret = 0;
av_image_copy(data, linesize, (const uint8_t **)frame->data, frame->linesize, *pix_fmt, *w, *h);
end:
if (codec_ctx)
avcodec_close(codec_ctx);
if (format_ctx)
avformat_close_input(&format_ctx);
av_freep(&frame);
if (ret < 0)
av_log(log_ctx, AV_LOG_ERROR, "Error loading image file '%s'\n", filename);
return ret;
}
| true | FFmpeg | fd9e88fe6018bc72cd0aa10afc3c1a68df8c6558 | int ff_load_image(uint8_t *data[4], int linesize[4],
int *w, int *h, enum AVPixelFormat *pix_fmt,
const char *filename, void *log_ctx)
{
AVInputFormat *iformat = NULL;
AVFormatContext *format_ctx = NULL;
AVCodec *codec;
AVCodecContext *codec_ctx;
AVFrame *frame;
int frame_decoded, ret = 0;
AVPacket pkt;
av_register_all();
iformat = av_find_input_format("image2");
if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {
av_log(log_ctx, AV_LOG_ERROR,
"Failed to open input file '%s'\n", filename);
return ret;
}
codec_ctx = format_ctx->streams[0]->codec;
codec = avcodec_find_decoder(codec_ctx->codec_id);
if (!codec) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to find codec\n");
ret = AVERROR(EINVAL);
goto end;
}
if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to open codec\n");
goto end;
}
if (!(frame = avcodec_alloc_frame()) ) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to alloc frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
ret = av_read_frame(format_ctx, &pkt);
if (ret < 0) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to read frame from file\n");
goto end;
}
ret = avcodec_decode_video2(codec_ctx, frame, &frame_decoded, &pkt);
if (ret < 0 || !frame_decoded) {
av_log(log_ctx, AV_LOG_ERROR, "Failed to decode image from file\n");
goto end;
}
ret = 0;
*w = frame->width;
*h = frame->height;
*pix_fmt = frame->format;
if ((ret = av_image_alloc(data, linesize, *w, *h, *pix_fmt, 16)) < 0)
goto end;
ret = 0;
av_image_copy(data, linesize, (const uint8_t **)frame->data, frame->linesize, *pix_fmt, *w, *h);
end:
if (codec_ctx)
avcodec_close(codec_ctx);
if (format_ctx)
avformat_close_input(&format_ctx);
av_freep(&frame);
if (ret < 0)
av_log(log_ctx, AV_LOG_ERROR, "Error loading image file '%s'\n", filename);
return ret;
}
| {
"code": [
" if (codec_ctx)",
" avcodec_close(codec_ctx);"
],
"line_no": [
129,
131
]
} | int FUNC_0(uint8_t *VAR_0[4], int VAR_1[4],
int *VAR_2, int *VAR_3, enum AVPixelFormat *VAR_4,
const char *VAR_5, void *VAR_6)
{
AVInputFormat *iformat = NULL;
AVFormatContext *format_ctx = NULL;
AVCodec *codec;
AVCodecContext *codec_ctx;
AVFrame *frame;
int VAR_7, VAR_8 = 0;
AVPacket pkt;
av_register_all();
iformat = av_find_input_format("image2");
if ((VAR_8 = avformat_open_input(&format_ctx, VAR_5, iformat, NULL)) < 0) {
av_log(VAR_6, AV_LOG_ERROR,
"Failed to open input file '%s'\n", VAR_5);
return VAR_8;
}
codec_ctx = format_ctx->streams[0]->codec;
codec = avcodec_find_decoder(codec_ctx->codec_id);
if (!codec) {
av_log(VAR_6, AV_LOG_ERROR, "Failed to find codec\n");
VAR_8 = AVERROR(EINVAL);
goto end;
}
if ((VAR_8 = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
av_log(VAR_6, AV_LOG_ERROR, "Failed to open codec\n");
goto end;
}
if (!(frame = avcodec_alloc_frame()) ) {
av_log(VAR_6, AV_LOG_ERROR, "Failed to alloc frame\n");
VAR_8 = AVERROR(ENOMEM);
goto end;
}
VAR_8 = av_read_frame(format_ctx, &pkt);
if (VAR_8 < 0) {
av_log(VAR_6, AV_LOG_ERROR, "Failed to read frame from file\n");
goto end;
}
VAR_8 = avcodec_decode_video2(codec_ctx, frame, &VAR_7, &pkt);
if (VAR_8 < 0 || !VAR_7) {
av_log(VAR_6, AV_LOG_ERROR, "Failed to decode image from file\n");
goto end;
}
VAR_8 = 0;
*VAR_2 = frame->width;
*VAR_3 = frame->height;
*VAR_4 = frame->format;
if ((VAR_8 = av_image_alloc(VAR_0, VAR_1, *VAR_2, *VAR_3, *VAR_4, 16)) < 0)
goto end;
VAR_8 = 0;
av_image_copy(VAR_0, VAR_1, (const uint8_t **)frame->VAR_0, frame->VAR_1, *VAR_4, *VAR_2, *VAR_3);
end:
if (codec_ctx)
avcodec_close(codec_ctx);
if (format_ctx)
avformat_close_input(&format_ctx);
av_freep(&frame);
if (VAR_8 < 0)
av_log(VAR_6, AV_LOG_ERROR, "Error loading image file '%s'\n", VAR_5);
return VAR_8;
}
| [
"int FUNC_0(uint8_t *VAR_0[4], int VAR_1[4],\nint *VAR_2, int *VAR_3, enum AVPixelFormat *VAR_4,\nconst char *VAR_5, void *VAR_6)\n{",
"AVInputFormat *iformat = NULL;",
"AVFormatContext *format_ctx = NULL;",
"AVCodec *codec;",
"AVCodecContext *codec_ctx;",
"AVFrame *frame;",
"int VAR_7, 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,
1,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[... |
15,579 | int ff_h264_set_parameter_from_sps(H264Context *h)
{
if (h->flags & CODEC_FLAG_LOW_DELAY ||
(h->sps.bitstream_restriction_flag &&
!h->sps.num_reorder_frames)) {
if (h->avctx->has_b_frames > 1 || h->delayed_pic[0])
av_log(h->avctx, AV_LOG_WARNING, "Delayed frames seen. "
"Reenabling low delay requires a codec flush.\n");
else
h->low_delay = 1;
}
if (h->avctx->has_b_frames < 2)
h->avctx->has_b_frames = !h->low_delay;
if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
if (h->avctx->codec &&
h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU &&
(h->sps.bit_depth_luma != 8 || h->sps.chroma_format_idc > 1)) {
av_log(h->avctx, AV_LOG_ERROR,
"VDPAU decoding does not support video colorspace.\n");
return AVERROR_INVALIDDATA;
}
if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 14 &&
h->sps.bit_depth_luma != 11 && h->sps.bit_depth_luma != 13) {
h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
h->cur_chroma_format_idc = h->sps.chroma_format_idc;
h->pixel_shift = h->sps.bit_depth_luma > 8;
ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);
ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);
} else {
av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
h->sps.bit_depth_luma);
return AVERROR_INVALIDDATA;
}
}
return 0;
}
| true | FFmpeg | 354db19ff44c3e33ba1a4298d1b3eaefb0ddc7e3 | int ff_h264_set_parameter_from_sps(H264Context *h)
{
if (h->flags & CODEC_FLAG_LOW_DELAY ||
(h->sps.bitstream_restriction_flag &&
!h->sps.num_reorder_frames)) {
if (h->avctx->has_b_frames > 1 || h->delayed_pic[0])
av_log(h->avctx, AV_LOG_WARNING, "Delayed frames seen. "
"Reenabling low delay requires a codec flush.\n");
else
h->low_delay = 1;
}
if (h->avctx->has_b_frames < 2)
h->avctx->has_b_frames = !h->low_delay;
if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
if (h->avctx->codec &&
h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU &&
(h->sps.bit_depth_luma != 8 || h->sps.chroma_format_idc > 1)) {
av_log(h->avctx, AV_LOG_ERROR,
"VDPAU decoding does not support video colorspace.\n");
return AVERROR_INVALIDDATA;
}
if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 14 &&
h->sps.bit_depth_luma != 11 && h->sps.bit_depth_luma != 13) {
h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
h->cur_chroma_format_idc = h->sps.chroma_format_idc;
h->pixel_shift = h->sps.bit_depth_luma > 8;
ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);
ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,
h->sps.chroma_format_idc);
ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);
} else {
av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
h->sps.bit_depth_luma);
return AVERROR_INVALIDDATA;
}
}
return 0;
}
| {
"code": [
" if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||"
],
"line_no": [
31
]
} | int FUNC_0(H264Context *VAR_0)
{
if (VAR_0->flags & CODEC_FLAG_LOW_DELAY ||
(VAR_0->sps.bitstream_restriction_flag &&
!VAR_0->sps.num_reorder_frames)) {
if (VAR_0->avctx->has_b_frames > 1 || VAR_0->delayed_pic[0])
av_log(VAR_0->avctx, AV_LOG_WARNING, "Delayed frames seen. "
"Reenabling low delay requires a codec flush.\n");
else
VAR_0->low_delay = 1;
}
if (VAR_0->avctx->has_b_frames < 2)
VAR_0->avctx->has_b_frames = !VAR_0->low_delay;
if (VAR_0->avctx->bits_per_raw_sample != VAR_0->sps.bit_depth_luma ||
VAR_0->cur_chroma_format_idc != VAR_0->sps.chroma_format_idc) {
if (VAR_0->avctx->codec &&
VAR_0->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU &&
(VAR_0->sps.bit_depth_luma != 8 || VAR_0->sps.chroma_format_idc > 1)) {
av_log(VAR_0->avctx, AV_LOG_ERROR,
"VDPAU decoding does not support video colorspace.\n");
return AVERROR_INVALIDDATA;
}
if (VAR_0->sps.bit_depth_luma >= 8 && VAR_0->sps.bit_depth_luma <= 14 &&
VAR_0->sps.bit_depth_luma != 11 && VAR_0->sps.bit_depth_luma != 13) {
VAR_0->avctx->bits_per_raw_sample = VAR_0->sps.bit_depth_luma;
VAR_0->cur_chroma_format_idc = VAR_0->sps.chroma_format_idc;
VAR_0->pixel_shift = VAR_0->sps.bit_depth_luma > 8;
ff_h264dsp_init(&VAR_0->h264dsp, VAR_0->sps.bit_depth_luma,
VAR_0->sps.chroma_format_idc);
ff_h264chroma_init(&VAR_0->h264chroma, VAR_0->sps.bit_depth_chroma);
ff_h264qpel_init(&VAR_0->h264qpel, VAR_0->sps.bit_depth_luma);
ff_h264_pred_init(&VAR_0->hpc, VAR_0->avctx->codec_id, VAR_0->sps.bit_depth_luma,
VAR_0->sps.chroma_format_idc);
ff_videodsp_init(&VAR_0->vdsp, VAR_0->sps.bit_depth_luma);
} else {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
VAR_0->sps.bit_depth_luma);
return AVERROR_INVALIDDATA;
}
}
return 0;
}
| [
"int FUNC_0(H264Context *VAR_0)\n{",
"if (VAR_0->flags & CODEC_FLAG_LOW_DELAY ||\n(VAR_0->sps.bitstream_restriction_flag &&\n!VAR_0->sps.num_reorder_frames)) {",
"if (VAR_0->avctx->has_b_frames > 1 || VAR_0->delayed_pic[0])\nav_log(VAR_0->avctx, AV_LOG_WARNING, \"Delayed frames seen. \"\n\"Reenabling low delay ... | [
0,
0,
0,
0,
0,
0,
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,
19
],
[
21
],
[
25,
27
],
[
31,
33
],
[
35,
37,
39
],
[
41,
43
],
[
45
],
[
47
],
[
49,
51
],
[
53
],
[
55
],
[... |
15,580 | static void gen_compute_branch(DisasContext *ctx, uint32_t opc, int r1,
int r2 , int32_t constant , int32_t offset)
{
TCGv temp, temp2;
int n;
switch (opc) {
/* SB-format jumps */
case OPC1_16_SB_J:
case OPC1_32_B_J:
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_32_B_CALL:
case OPC1_16_SB_CALL:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_16_SB_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], 0, offset);
break;
case OPC1_16_SB_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], 0, offset);
break;
/* SBC-format jumps */
case OPC1_16_SBC_JEQ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant, offset);
break;
case OPC1_16_SBC_JNE:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], constant, offset);
break;
/* SBRN-format jumps */
case OPC1_16_SBRN_JZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
tcg_temp_free(temp);
break;
case OPC1_16_SBRN_JNZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
tcg_temp_free(temp);
break;
/* SBR-format jumps */
case OPC1_16_SBR_JEQ:
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNE:
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JNZ_A:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_JGEZ:
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JGTZ:
gen_branch_condi(ctx, TCG_COND_GT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLEZ:
gen_branch_condi(ctx, TCG_COND_LE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLTZ:
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ_A:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_LOOP:
gen_loop(ctx, r1, offset * 2 - 32);
break;
/* SR-format jumps */
case OPC1_16_SR_JI:
tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], 0xfffffffe);
tcg_gen_exit_tb(0);
break;
case OPC2_32_SYS_RET:
case OPC2_16_SR_RET:
gen_helper_ret(cpu_env);
tcg_gen_exit_tb(0);
break;
/* B-format */
case OPC1_32_B_CALLA:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_FCALL:
gen_fcall_save_ctx(ctx);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_32_B_FCALLA:
gen_fcall_save_ctx(ctx);
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JLA:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
/* fall through */
case OPC1_32_B_JA:
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JL:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
/* BOL format */
case OPCM_32_BRC_EQ_NEQ:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JEQ) {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], constant, offset);
} else {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], constant, offset);
}
break;
case OPCM_32_BRC_GE:
if (MASK_OP_BRC_OP2(ctx->opcode) == OP2_32_BRC_JGE) {
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_GEU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JLT:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JLT) {
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_LTU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JNE:
temp = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* subi is unconditional */
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* addi is unconditional */
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
}
tcg_temp_free(temp);
break;
/* BRN format */
case OPCM_32_BRN_JTT:
n = MASK_OP_BRN_N(ctx->opcode);
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[r1], (1 << n));
if (MASK_OP_BRN_OP2(ctx->opcode) == OPC2_32_BRN_JNZ_T) {
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
}
tcg_temp_free(temp);
break;
/* BRR Format */
case OPCM_32_BRR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_ADDR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ_A) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
}
break;
case OPCM_32_BRR_GE:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JGE) {
gen_branch_cond(ctx, TCG_COND_GE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_GEU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_JLT:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JLT) {
gen_branch_cond(ctx, TCG_COND_LT, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_LTU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_LOOP:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_LOOP) {
gen_loop(ctx, r2, offset * 2);
} else {
/* OPC2_32_BRR_LOOPU */
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
}
break;
case OPCM_32_BRR_JNE:
temp = tcg_temp_new();
temp2 = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRR_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* also save r2, in case of r1 == r2, so r2 is not decremented */
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
/* subi is unconditional */
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
/* also save r2, in case of r1 == r2, so r2 is not decremented */
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
/* addi is unconditional */
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
}
tcg_temp_free(temp);
tcg_temp_free(temp2);
break;
case OPCM_32_BRR_JNZ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JNZ_A) {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
}
break;
default:
printf("Branch Error at %x\n", ctx->pc);
}
ctx->bstate = BS_BRANCH;
}
| true | qemu | f678f671ba654d4610f0e43d175c8c1b2fad10df | static void gen_compute_branch(DisasContext *ctx, uint32_t opc, int r1,
int r2 , int32_t constant , int32_t offset)
{
TCGv temp, temp2;
int n;
switch (opc) {
case OPC1_16_SB_J:
case OPC1_32_B_J:
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_32_B_CALL:
case OPC1_16_SB_CALL:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_16_SB_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], 0, offset);
break;
case OPC1_16_SB_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], 0, offset);
break;
case OPC1_16_SBC_JEQ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[15], constant, offset);
break;
case OPC1_16_SBC_JNE:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[15], constant, offset);
break;
case OPC1_16_SBRN_JZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
tcg_temp_free(temp);
break;
case OPC1_16_SBRN_JNZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << constant);
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
tcg_temp_free(temp);
break;
case OPC1_16_SBR_JEQ:
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNE:
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[15],
offset);
break;
case OPC1_16_SBR_JNZ:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JNZ_A:
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_JGEZ:
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JGTZ:
gen_branch_condi(ctx, TCG_COND_GT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLEZ:
gen_branch_condi(ctx, TCG_COND_LE, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JLTZ:
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], 0, offset);
break;
case OPC1_16_SBR_JZ_A:
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
break;
case OPC1_16_SBR_LOOP:
gen_loop(ctx, r1, offset * 2 - 32);
break;
case OPC1_16_SR_JI:
tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[r1], 0xfffffffe);
tcg_gen_exit_tb(0);
break;
case OPC2_32_SYS_RET:
case OPC2_16_SR_RET:
gen_helper_ret(cpu_env);
tcg_gen_exit_tb(0);
break;
case OPC1_32_B_CALLA:
gen_helper_1arg(call, ctx->next_pc);
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_FCALL:
gen_fcall_save_ctx(ctx);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPC1_32_B_FCALLA:
gen_fcall_save_ctx(ctx);
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JLA:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
case OPC1_32_B_JA:
gen_goto_tb(ctx, 0, EA_B_ABSOLUT(offset));
break;
case OPC1_32_B_JL:
tcg_gen_movi_tl(cpu_gpr_a[11], ctx->next_pc);
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
break;
case OPCM_32_BRC_EQ_NEQ:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JEQ) {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_d[r1], constant, offset);
} else {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_d[r1], constant, offset);
}
break;
case OPCM_32_BRC_GE:
if (MASK_OP_BRC_OP2(ctx->opcode) == OP2_32_BRC_JGE) {
gen_branch_condi(ctx, TCG_COND_GE, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_GEU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JLT:
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JLT) {
gen_branch_condi(ctx, TCG_COND_LT, cpu_gpr_d[r1], constant, offset);
} else {
constant = MASK_OP_BRC_CONST4(ctx->opcode);
gen_branch_condi(ctx, TCG_COND_LTU, cpu_gpr_d[r1], constant,
offset);
}
break;
case OPCM_32_BRC_JNE:
temp = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRC_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_condi(ctx, TCG_COND_NE, temp, constant, offset);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRN_JTT:
n = MASK_OP_BRN_N(ctx->opcode);
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[r1], (1 << n));
if (MASK_OP_BRN_OP2(ctx->opcode) == OPC2_32_BRN_JNZ_T) {
gen_branch_condi(ctx, TCG_COND_NE, temp, 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, temp, 0, offset);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_ADDR_EQ_NEQ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JEQ_A) {
gen_branch_cond(ctx, TCG_COND_EQ, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_NE, cpu_gpr_a[r1], cpu_gpr_a[r2],
offset);
}
break;
case OPCM_32_BRR_GE:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JGE) {
gen_branch_cond(ctx, TCG_COND_GE, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_GEU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_JLT:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JLT) {
gen_branch_cond(ctx, TCG_COND_LT, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
} else {
gen_branch_cond(ctx, TCG_COND_LTU, cpu_gpr_d[r1], cpu_gpr_d[r2],
offset);
}
break;
case OPCM_32_BRR_LOOP:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_LOOP) {
gen_loop(ctx, r2, offset * 2);
} else {
gen_goto_tb(ctx, 0, ctx->pc + offset * 2);
}
break;
case OPCM_32_BRR_JNE:
temp = tcg_temp_new();
temp2 = tcg_temp_new();
if (MASK_OP_BRC_OP2(ctx->opcode) == OPC2_32_BRR_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
tcg_gen_subi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[r2]);
tcg_gen_addi_tl(cpu_gpr_d[r1], cpu_gpr_d[r1], 1);
gen_branch_cond(ctx, TCG_COND_NE, temp, temp2, offset);
}
tcg_temp_free(temp);
tcg_temp_free(temp2);
break;
case OPCM_32_BRR_JNZ:
if (MASK_OP_BRR_OP2(ctx->opcode) == OPC2_32_BRR_JNZ_A) {
gen_branch_condi(ctx, TCG_COND_NE, cpu_gpr_a[r1], 0, offset);
} else {
gen_branch_condi(ctx, TCG_COND_EQ, cpu_gpr_a[r1], 0, offset);
}
break;
default:
printf("Branch Error at %x\n", ctx->pc);
}
ctx->bstate = BS_BRANCH;
}
| {
"code": [
" printf(\"Branch Error at %x\\n\", ctx->pc);"
],
"line_no": [
483
]
} | static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, int VAR_2,
int VAR_3 , int32_t VAR_4 , int32_t VAR_5)
{
TCGv temp, temp2;
int VAR_6;
switch (VAR_1) {
case OPC1_16_SB_J:
case OPC1_32_B_J:
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPC1_32_B_CALL:
case OPC1_16_SB_CALL:
gen_helper_1arg(call, VAR_0->next_pc);
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPC1_16_SB_JZ:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[15], 0, VAR_5);
break;
case OPC1_16_SB_JNZ:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[15], 0, VAR_5);
break;
case OPC1_16_SBC_JEQ:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[15], VAR_4, VAR_5);
break;
case OPC1_16_SBC_JNE:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[15], VAR_4, VAR_5);
break;
case OPC1_16_SBRN_JZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << VAR_4);
gen_branch_condi(VAR_0, TCG_COND_EQ, temp, 0, VAR_5);
tcg_temp_free(temp);
break;
case OPC1_16_SBRN_JNZ_T:
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[15], 0x1u << VAR_4);
gen_branch_condi(VAR_0, TCG_COND_NE, temp, 0, VAR_5);
tcg_temp_free(temp);
break;
case OPC1_16_SBR_JEQ:
gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], cpu_gpr_d[15],
VAR_5);
break;
case OPC1_16_SBR_JNE:
gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], cpu_gpr_d[15],
VAR_5);
break;
case OPC1_16_SBR_JNZ:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JNZ_A:
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JGEZ:
gen_branch_condi(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JGTZ:
gen_branch_condi(VAR_0, TCG_COND_GT, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JLEZ:
gen_branch_condi(VAR_0, TCG_COND_LE, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JLTZ:
gen_branch_condi(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JZ:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_JZ_A:
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], 0, VAR_5);
break;
case OPC1_16_SBR_LOOP:
gen_loop(VAR_0, VAR_2, VAR_5 * 2 - 32);
break;
case OPC1_16_SR_JI:
tcg_gen_andi_tl(cpu_PC, cpu_gpr_a[VAR_2], 0xfffffffe);
tcg_gen_exit_tb(0);
break;
case OPC2_32_SYS_RET:
case OPC2_16_SR_RET:
gen_helper_ret(cpu_env);
tcg_gen_exit_tb(0);
break;
case OPC1_32_B_CALLA:
gen_helper_1arg(call, VAR_0->next_pc);
gen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));
break;
case OPC1_32_B_FCALL:
gen_fcall_save_ctx(VAR_0);
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPC1_32_B_FCALLA:
gen_fcall_save_ctx(VAR_0);
gen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));
break;
case OPC1_32_B_JLA:
tcg_gen_movi_tl(cpu_gpr_a[11], VAR_0->next_pc);
case OPC1_32_B_JA:
gen_goto_tb(VAR_0, 0, EA_B_ABSOLUT(VAR_5));
break;
case OPC1_32_B_JL:
tcg_gen_movi_tl(cpu_gpr_a[11], VAR_0->next_pc);
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
break;
case OPCM_32_BRC_EQ_NEQ:
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JEQ) {
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
} else {
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
}
break;
case OPCM_32_BRC_GE:
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OP2_32_BRC_JGE) {
gen_branch_condi(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
} else {
VAR_4 = MASK_OP_BRC_CONST4(VAR_0->opcode);
gen_branch_condi(VAR_0, TCG_COND_GEU, cpu_gpr_d[VAR_2], VAR_4,
VAR_5);
}
break;
case OPCM_32_BRC_JLT:
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JLT) {
gen_branch_condi(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], VAR_4, VAR_5);
} else {
VAR_4 = MASK_OP_BRC_CONST4(VAR_0->opcode);
gen_branch_condi(VAR_0, TCG_COND_LTU, cpu_gpr_d[VAR_2], VAR_4,
VAR_5);
}
break;
case OPCM_32_BRC_JNE:
temp = tcg_temp_new();
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRC_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_subi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_condi(VAR_0, TCG_COND_NE, temp, VAR_4, VAR_5);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_addi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_condi(VAR_0, TCG_COND_NE, temp, VAR_4, VAR_5);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRN_JTT:
VAR_6 = MASK_OP_BRN_N(VAR_0->opcode);
temp = tcg_temp_new();
tcg_gen_andi_tl(temp, cpu_gpr_d[VAR_2], (1 << VAR_6));
if (MASK_OP_BRN_OP2(VAR_0->opcode) == OPC2_32_BRN_JNZ_T) {
gen_branch_condi(VAR_0, TCG_COND_NE, temp, 0, VAR_5);
} else {
gen_branch_condi(VAR_0, TCG_COND_EQ, temp, 0, VAR_5);
}
tcg_temp_free(temp);
break;
case OPCM_32_BRR_EQ_NEQ:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JEQ) {
gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_ADDR_EQ_NEQ:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JEQ_A) {
gen_branch_cond(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], cpu_gpr_a[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], cpu_gpr_a[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_GE:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JGE) {
gen_branch_cond(VAR_0, TCG_COND_GE, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_GEU, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_JLT:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JLT) {
gen_branch_cond(VAR_0, TCG_COND_LT, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
} else {
gen_branch_cond(VAR_0, TCG_COND_LTU, cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_3],
VAR_5);
}
break;
case OPCM_32_BRR_LOOP:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_LOOP) {
gen_loop(VAR_0, VAR_3, VAR_5 * 2);
} else {
gen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);
}
break;
case OPCM_32_BRR_JNE:
temp = tcg_temp_new();
temp2 = tcg_temp_new();
if (MASK_OP_BRC_OP2(VAR_0->opcode) == OPC2_32_BRR_JNED) {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[VAR_3]);
tcg_gen_subi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_cond(VAR_0, TCG_COND_NE, temp, temp2, VAR_5);
} else {
tcg_gen_mov_tl(temp, cpu_gpr_d[VAR_2]);
tcg_gen_mov_tl(temp2, cpu_gpr_d[VAR_3]);
tcg_gen_addi_tl(cpu_gpr_d[VAR_2], cpu_gpr_d[VAR_2], 1);
gen_branch_cond(VAR_0, TCG_COND_NE, temp, temp2, VAR_5);
}
tcg_temp_free(temp);
tcg_temp_free(temp2);
break;
case OPCM_32_BRR_JNZ:
if (MASK_OP_BRR_OP2(VAR_0->opcode) == OPC2_32_BRR_JNZ_A) {
gen_branch_condi(VAR_0, TCG_COND_NE, cpu_gpr_a[VAR_2], 0, VAR_5);
} else {
gen_branch_condi(VAR_0, TCG_COND_EQ, cpu_gpr_a[VAR_2], 0, VAR_5);
}
break;
default:
printf("Branch Error at %x\VAR_6", VAR_0->pc);
}
VAR_0->bstate = BS_BRANCH;
}
| [
"static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1, int VAR_2,\nint VAR_3 , int32_t VAR_4 , int32_t VAR_5)\n{",
"TCGv temp, temp2;",
"int VAR_6;",
"switch (VAR_1) {",
"case OPC1_16_SB_J:\ncase OPC1_32_B_J:\ngen_goto_tb(VAR_0, 0, VAR_0->pc + VAR_5 * 2);",
"break;",
"case OPC1_32_B_CALL:\ncase OPC1_1... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
17,
19,
21
],
[
23
],
[
25,
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
49,
51
],
[
53
],
[
55,... |
15,581 | static inline void RENAME(bgr16ToY)(uint8_t *dst, uint8_t *src, int width)
{
int i;
for(i=0; i<width; i++)
{
int d= ((uint16_t*)src)[i];
int b= d&0x1F;
int g= (d>>5)&0x3F;
int r= (d>>11)&0x1F;
dst[i]= ((2*RY*r + GY*g + 2*BY*b)>>(RGB2YUV_SHIFT-2)) + 16;
}
}
| true | FFmpeg | 2da0d70d5eebe42f9fcd27ee554419ebe2a5da06 | static inline void RENAME(bgr16ToY)(uint8_t *dst, uint8_t *src, int width)
{
int i;
for(i=0; i<width; i++)
{
int d= ((uint16_t*)src)[i];
int b= d&0x1F;
int g= (d>>5)&0x3F;
int r= (d>>11)&0x1F;
dst[i]= ((2*RY*r + GY*g + 2*BY*b)>>(RGB2YUV_SHIFT-2)) + 16;
}
}
| {
"code": [
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\t\tint d= ((uint16_t*)src)[i];",
"\t\tint b= d&0x1F;",
"\t\tint g= (d>>5)&0x3F;",
"\t\tint r= (d>>11)&0x1F;",
"\t\tdst[i]= ((2*RY*r + GY*g + 2*BY*b)>>(RGB2YUV_SHIFT-2)) + 16;",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\t\tint d= ((uint16_t*)src)[i];",
"\t\tint b= d&0x1F;",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\t\tint d= ((uint16_t*)src)[i];",
"\t\tint g= (d>>5)&0x3F;",
"\t\tdst[i]= ((2*RY*r + GY*g + 2*BY*b)>>(RGB2YUV_SHIFT-2)) + 16;",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\t\tint d= ((uint16_t*)src)[i];",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tfor(i=0; i<width; i++)",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;"
],
"line_no": [
5,
5,
5,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
11,
13,
15,
17,
21,
5,
7,
5,
7,
11,
13,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
5,
7,
11,
15,
21,
5,
7,
5,
7,
11,
5,
7,
5,
7,
5,
7,
5,
5,
5,
5,
5
]
} | static inline void FUNC_0(bgr16ToY)(uint8_t *dst, uint8_t *src, int width)
{
int VAR_0;
for(VAR_0=0; VAR_0<width; VAR_0++)
{
int d= ((uint16_t*)src)[VAR_0];
int b= d&0x1F;
int g= (d>>5)&0x3F;
int r= (d>>11)&0x1F;
dst[VAR_0]= ((2*RY*r + GY*g + 2*BY*b)>>(RGB2YUV_SHIFT-2)) + 16;
}
}
| [
"static inline void FUNC_0(bgr16ToY)(uint8_t *dst, uint8_t *src, int width)\n{",
"int VAR_0;",
"for(VAR_0=0; VAR_0<width; VAR_0++)",
"{",
"int d= ((uint16_t*)src)[VAR_0];",
"int b= d&0x1F;",
"int g= (d>>5)&0x3F;",
"int r= (d>>11)&0x1F;",
"dst[VAR_0]= ((2*RY*r + GY*g + 2*BY*b)>>(RGB2YUV_SHIFT-2)) + 1... | [
0,
1,
1,
0,
1,
1,
1,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
]
] |
15,584 | static int film_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
FilmDemuxContext *film = s->priv_data;
AVIOContext *pb = s->pb;
film_sample *sample;
int ret = 0;
int i;
int left, right;
if (film->current_sample >= film->sample_count)
sample = &film->sample_table[film->current_sample];
/* position the stream (will probably be there anyway) */
avio_seek(pb, sample->sample_offset, SEEK_SET);
/* do a special song and dance when loading FILM Cinepak chunks */
if ((sample->stream == film->video_stream_index) &&
(film->video_type == CODEC_ID_CINEPAK)) {
pkt->pos= avio_tell(pb);
if (av_new_packet(pkt, sample->sample_size))
return AVERROR(ENOMEM);
avio_read(pb, pkt->data, sample->sample_size);
} else if ((sample->stream == film->audio_stream_index) &&
(film->audio_channels == 2) &&
(film->audio_type != CODEC_ID_ADPCM_ADX)) {
/* stereo PCM needs to be interleaved */
if (av_new_packet(pkt, sample->sample_size))
return AVERROR(ENOMEM);
/* make sure the interleave buffer is large enough */
if (sample->sample_size > film->stereo_buffer_size) {
av_free(film->stereo_buffer);
film->stereo_buffer_size = sample->sample_size;
film->stereo_buffer = av_malloc(film->stereo_buffer_size);
if (!film->stereo_buffer) {
film->stereo_buffer_size = 0;
return AVERROR(ENOMEM);
}
}
pkt->pos= avio_tell(pb);
ret = avio_read(pb, film->stereo_buffer, sample->sample_size);
if (ret != sample->sample_size)
ret = AVERROR(EIO);
left = 0;
right = sample->sample_size / 2;
for (i = 0; i < sample->sample_size; ) {
if (film->audio_bits == 8) {
pkt->data[i++] = film->stereo_buffer[left++];
pkt->data[i++] = film->stereo_buffer[right++];
} else {
pkt->data[i++] = film->stereo_buffer[left++];
pkt->data[i++] = film->stereo_buffer[left++];
pkt->data[i++] = film->stereo_buffer[right++];
pkt->data[i++] = film->stereo_buffer[right++];
}
}
} else {
ret= av_get_packet(pb, pkt, sample->sample_size);
if (ret != sample->sample_size)
ret = AVERROR(EIO);
}
pkt->stream_index = sample->stream;
pkt->pts = sample->pts;
film->current_sample++;
return ret;
} | true | FFmpeg | 1795fed7bc7a8b8109757cb5f27198c5b05698b5 | static int film_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
FilmDemuxContext *film = s->priv_data;
AVIOContext *pb = s->pb;
film_sample *sample;
int ret = 0;
int i;
int left, right;
if (film->current_sample >= film->sample_count)
sample = &film->sample_table[film->current_sample];
avio_seek(pb, sample->sample_offset, SEEK_SET);
if ((sample->stream == film->video_stream_index) &&
(film->video_type == CODEC_ID_CINEPAK)) {
pkt->pos= avio_tell(pb);
if (av_new_packet(pkt, sample->sample_size))
return AVERROR(ENOMEM);
avio_read(pb, pkt->data, sample->sample_size);
} else if ((sample->stream == film->audio_stream_index) &&
(film->audio_channels == 2) &&
(film->audio_type != CODEC_ID_ADPCM_ADX)) {
if (av_new_packet(pkt, sample->sample_size))
return AVERROR(ENOMEM);
if (sample->sample_size > film->stereo_buffer_size) {
av_free(film->stereo_buffer);
film->stereo_buffer_size = sample->sample_size;
film->stereo_buffer = av_malloc(film->stereo_buffer_size);
if (!film->stereo_buffer) {
film->stereo_buffer_size = 0;
return AVERROR(ENOMEM);
}
}
pkt->pos= avio_tell(pb);
ret = avio_read(pb, film->stereo_buffer, sample->sample_size);
if (ret != sample->sample_size)
ret = AVERROR(EIO);
left = 0;
right = sample->sample_size / 2;
for (i = 0; i < sample->sample_size; ) {
if (film->audio_bits == 8) {
pkt->data[i++] = film->stereo_buffer[left++];
pkt->data[i++] = film->stereo_buffer[right++];
} else {
pkt->data[i++] = film->stereo_buffer[left++];
pkt->data[i++] = film->stereo_buffer[left++];
pkt->data[i++] = film->stereo_buffer[right++];
pkt->data[i++] = film->stereo_buffer[right++];
}
}
} else {
ret= av_get_packet(pb, pkt, sample->sample_size);
if (ret != sample->sample_size)
ret = AVERROR(EIO);
}
pkt->stream_index = sample->stream;
pkt->pts = sample->pts;
film->current_sample++;
return ret;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0,
AVPacket *VAR_1)
{
FilmDemuxContext *film = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
film_sample *sample;
int VAR_2 = 0;
int VAR_3;
int VAR_4, VAR_5;
if (film->current_sample >= film->sample_count)
sample = &film->sample_table[film->current_sample];
avio_seek(pb, sample->sample_offset, SEEK_SET);
if ((sample->stream == film->video_stream_index) &&
(film->video_type == CODEC_ID_CINEPAK)) {
VAR_1->pos= avio_tell(pb);
if (av_new_packet(VAR_1, sample->sample_size))
return AVERROR(ENOMEM);
avio_read(pb, VAR_1->data, sample->sample_size);
} else if ((sample->stream == film->audio_stream_index) &&
(film->audio_channels == 2) &&
(film->audio_type != CODEC_ID_ADPCM_ADX)) {
if (av_new_packet(VAR_1, sample->sample_size))
return AVERROR(ENOMEM);
if (sample->sample_size > film->stereo_buffer_size) {
av_free(film->stereo_buffer);
film->stereo_buffer_size = sample->sample_size;
film->stereo_buffer = av_malloc(film->stereo_buffer_size);
if (!film->stereo_buffer) {
film->stereo_buffer_size = 0;
return AVERROR(ENOMEM);
}
}
VAR_1->pos= avio_tell(pb);
VAR_2 = avio_read(pb, film->stereo_buffer, sample->sample_size);
if (VAR_2 != sample->sample_size)
VAR_2 = AVERROR(EIO);
VAR_4 = 0;
VAR_5 = sample->sample_size / 2;
for (VAR_3 = 0; VAR_3 < sample->sample_size; ) {
if (film->audio_bits == 8) {
VAR_1->data[VAR_3++] = film->stereo_buffer[VAR_4++];
VAR_1->data[VAR_3++] = film->stereo_buffer[VAR_5++];
} else {
VAR_1->data[VAR_3++] = film->stereo_buffer[VAR_4++];
VAR_1->data[VAR_3++] = film->stereo_buffer[VAR_4++];
VAR_1->data[VAR_3++] = film->stereo_buffer[VAR_5++];
VAR_1->data[VAR_3++] = film->stereo_buffer[VAR_5++];
}
}
} else {
VAR_2= av_get_packet(pb, VAR_1, sample->sample_size);
if (VAR_2 != sample->sample_size)
VAR_2 = AVERROR(EIO);
}
VAR_1->stream_index = sample->stream;
VAR_1->pts = sample->pts;
film->current_sample++;
return VAR_2;
} | [
"static int FUNC_0(AVFormatContext *VAR_0,\nAVPacket *VAR_1)\n{",
"FilmDemuxContext *film = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"film_sample *sample;",
"int VAR_2 = 0;",
"int VAR_3;",
"int VAR_4, VAR_5;",
"if (film->current_sample >= film->sample_count)\nsample = &film->sample_table[fi... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
26
],
[
32
],
[
38,
40
],
[
42
],
[
44,
46
],
[
48
],
[
50
],
[
52,
54
],
[
62,
64
],
[
70
... |
15,585 | static void tcg_out_qemu_st(TCGContext* s, TCGReg data_reg, TCGReg addr_reg,
TCGMemOpIdx oi)
{
TCGMemOp opc = get_memop(oi);
#ifdef CONFIG_SOFTMMU
unsigned mem_index = get_mmuidx(oi);
tcg_insn_unit *label_ptr;
TCGReg base_reg;
base_reg = tcg_out_tlb_read(s, addr_reg, opc, mem_index, 0);
label_ptr = s->code_ptr + 1;
tcg_out_insn(s, RI, BRC, S390_CC_NE, 0);
tcg_out_qemu_st_direct(s, opc, data_reg, base_reg, TCG_REG_R2, 0);
add_qemu_ldst_label(s, 0, oi, data_reg, addr_reg, s->code_ptr, label_ptr);
#else
TCGReg index_reg;
tcg_target_long disp;
tcg_prepare_user_ldst(s, &addr_reg, &index_reg, &disp);
tcg_out_qemu_st_direct(s, opc, data_reg, addr_reg, index_reg, disp);
#endif
}
| true | qemu | cd3b29b745b0ff393b2d37317837bc726b8dacc8 | static void tcg_out_qemu_st(TCGContext* s, TCGReg data_reg, TCGReg addr_reg,
TCGMemOpIdx oi)
{
TCGMemOp opc = get_memop(oi);
#ifdef CONFIG_SOFTMMU
unsigned mem_index = get_mmuidx(oi);
tcg_insn_unit *label_ptr;
TCGReg base_reg;
base_reg = tcg_out_tlb_read(s, addr_reg, opc, mem_index, 0);
label_ptr = s->code_ptr + 1;
tcg_out_insn(s, RI, BRC, S390_CC_NE, 0);
tcg_out_qemu_st_direct(s, opc, data_reg, base_reg, TCG_REG_R2, 0);
add_qemu_ldst_label(s, 0, oi, data_reg, addr_reg, s->code_ptr, label_ptr);
#else
TCGReg index_reg;
tcg_target_long disp;
tcg_prepare_user_ldst(s, &addr_reg, &index_reg, &disp);
tcg_out_qemu_st_direct(s, opc, data_reg, addr_reg, index_reg, disp);
#endif
}
| {
"code": [
" label_ptr = s->code_ptr + 1;",
" tcg_out_insn(s, RI, BRC, S390_CC_NE, 0);",
" label_ptr = s->code_ptr + 1;",
" tcg_out_insn(s, RI, BRC, S390_CC_NE, 0);"
],
"line_no": [
23,
25,
23,
25
]
} | static void FUNC_0(TCGContext* VAR_0, TCGReg VAR_1, TCGReg VAR_2,
TCGMemOpIdx VAR_3)
{
TCGMemOp opc = get_memop(VAR_3);
#ifdef CONFIG_SOFTMMU
unsigned mem_index = get_mmuidx(VAR_3);
tcg_insn_unit *label_ptr;
TCGReg base_reg;
base_reg = tcg_out_tlb_read(VAR_0, VAR_2, opc, mem_index, 0);
label_ptr = VAR_0->code_ptr + 1;
tcg_out_insn(VAR_0, RI, BRC, S390_CC_NE, 0);
tcg_out_qemu_st_direct(VAR_0, opc, VAR_1, base_reg, TCG_REG_R2, 0);
add_qemu_ldst_label(VAR_0, 0, VAR_3, VAR_1, VAR_2, VAR_0->code_ptr, label_ptr);
#else
TCGReg index_reg;
tcg_target_long disp;
tcg_prepare_user_ldst(VAR_0, &VAR_2, &index_reg, &disp);
tcg_out_qemu_st_direct(VAR_0, opc, VAR_1, VAR_2, index_reg, disp);
#endif
}
| [
"static void FUNC_0(TCGContext* VAR_0, TCGReg VAR_1, TCGReg VAR_2,\nTCGMemOpIdx VAR_3)\n{",
"TCGMemOp opc = get_memop(VAR_3);",
"#ifdef CONFIG_SOFTMMU\nunsigned mem_index = get_mmuidx(VAR_3);",
"tcg_insn_unit *label_ptr;",
"TCGReg base_reg;",
"base_reg = tcg_out_tlb_read(VAR_0, VAR_2, opc, mem_index, 0);"... | [
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9,
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
29
],
[
33
],
[
35,
37
],
[
39
],
[
43
],
[
45
],
[
47,
49
]
] |
15,586 | static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
{
int64_t sector_num, end;
BlockDriverState *base = s->base;
BlockDriverState *bs = s->source;
BlockDriverState *target_bs = blk_bs(s->target);
int ret, n;
end = s->bdev_length / BDRV_SECTOR_SIZE;
if (base == NULL && !bdrv_has_zero_init(target_bs)) {
if (!bdrv_can_write_zeroes_with_unmap(target_bs)) {
bdrv_set_dirty_bitmap(s->dirty_bitmap, 0, end);
return 0;
}
s->initial_zeroing_ongoing = true;
for (sector_num = 0; sector_num < end; ) {
int nb_sectors = MIN(end - sector_num,
QEMU_ALIGN_DOWN(INT_MAX, s->granularity) >> BDRV_SECTOR_BITS);
mirror_throttle(s);
if (block_job_is_cancelled(&s->common)) {
s->initial_zeroing_ongoing = false;
return 0;
}
if (s->in_flight >= MAX_IN_FLIGHT) {
trace_mirror_yield(s, s->in_flight, s->buf_free_count, -1);
mirror_wait_for_io(s);
continue;
}
mirror_do_zero_or_discard(s, sector_num, nb_sectors, false);
sector_num += nb_sectors;
}
mirror_wait_for_all_io(s);
s->initial_zeroing_ongoing = false;
}
/* First part, loop on the sectors and initialize the dirty bitmap. */
for (sector_num = 0; sector_num < end; ) {
/* Just to make sure we are not exceeding int limit. */
int nb_sectors = MIN(INT_MAX >> BDRV_SECTOR_BITS,
end - sector_num);
mirror_throttle(s);
if (block_job_is_cancelled(&s->common)) {
return 0;
}
ret = bdrv_is_allocated_above(bs, base, sector_num, nb_sectors, &n);
if (ret < 0) {
return ret;
}
assert(n > 0);
if (ret == 1) {
bdrv_set_dirty_bitmap(s->dirty_bitmap, sector_num, n);
}
sector_num += n;
}
return 0;
}
| true | qemu | 67adf4b39806df42b4c96377b37004de0df3a1fd | static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
{
int64_t sector_num, end;
BlockDriverState *base = s->base;
BlockDriverState *bs = s->source;
BlockDriverState *target_bs = blk_bs(s->target);
int ret, n;
end = s->bdev_length / BDRV_SECTOR_SIZE;
if (base == NULL && !bdrv_has_zero_init(target_bs)) {
if (!bdrv_can_write_zeroes_with_unmap(target_bs)) {
bdrv_set_dirty_bitmap(s->dirty_bitmap, 0, end);
return 0;
}
s->initial_zeroing_ongoing = true;
for (sector_num = 0; sector_num < end; ) {
int nb_sectors = MIN(end - sector_num,
QEMU_ALIGN_DOWN(INT_MAX, s->granularity) >> BDRV_SECTOR_BITS);
mirror_throttle(s);
if (block_job_is_cancelled(&s->common)) {
s->initial_zeroing_ongoing = false;
return 0;
}
if (s->in_flight >= MAX_IN_FLIGHT) {
trace_mirror_yield(s, s->in_flight, s->buf_free_count, -1);
mirror_wait_for_io(s);
continue;
}
mirror_do_zero_or_discard(s, sector_num, nb_sectors, false);
sector_num += nb_sectors;
}
mirror_wait_for_all_io(s);
s->initial_zeroing_ongoing = false;
}
for (sector_num = 0; sector_num < end; ) {
int nb_sectors = MIN(INT_MAX >> BDRV_SECTOR_BITS,
end - sector_num);
mirror_throttle(s);
if (block_job_is_cancelled(&s->common)) {
return 0;
}
ret = bdrv_is_allocated_above(bs, base, sector_num, nb_sectors, &n);
if (ret < 0) {
return ret;
}
assert(n > 0);
if (ret == 1) {
bdrv_set_dirty_bitmap(s->dirty_bitmap, sector_num, n);
}
sector_num += n;
}
return 0;
}
| {
"code": [
" trace_mirror_yield(s, s->in_flight, s->buf_free_count, -1);"
],
"line_no": [
59
]
} | static int VAR_0 mirror_dirty_init(MirrorBlockJob *s)
{
int64_t sector_num, end;
BlockDriverState *base = s->base;
BlockDriverState *bs = s->source;
BlockDriverState *target_bs = blk_bs(s->target);
int ret, n;
end = s->bdev_length / BDRV_SECTOR_SIZE;
if (base == NULL && !bdrv_has_zero_init(target_bs)) {
if (!bdrv_can_write_zeroes_with_unmap(target_bs)) {
bdrv_set_dirty_bitmap(s->dirty_bitmap, 0, end);
return 0;
}
s->initial_zeroing_ongoing = true;
for (sector_num = 0; sector_num < end; ) {
int nb_sectors = MIN(end - sector_num,
QEMU_ALIGN_DOWN(INT_MAX, s->granularity) >> BDRV_SECTOR_BITS);
mirror_throttle(s);
if (block_job_is_cancelled(&s->common)) {
s->initial_zeroing_ongoing = false;
return 0;
}
if (s->in_flight >= MAX_IN_FLIGHT) {
trace_mirror_yield(s, s->in_flight, s->buf_free_count, -1);
mirror_wait_for_io(s);
continue;
}
mirror_do_zero_or_discard(s, sector_num, nb_sectors, false);
sector_num += nb_sectors;
}
mirror_wait_for_all_io(s);
s->initial_zeroing_ongoing = false;
}
for (sector_num = 0; sector_num < end; ) {
int nb_sectors = MIN(INT_MAX >> BDRV_SECTOR_BITS,
end - sector_num);
mirror_throttle(s);
if (block_job_is_cancelled(&s->common)) {
return 0;
}
ret = bdrv_is_allocated_above(bs, base, sector_num, nb_sectors, &n);
if (ret < 0) {
return ret;
}
assert(n > 0);
if (ret == 1) {
bdrv_set_dirty_bitmap(s->dirty_bitmap, sector_num, n);
}
sector_num += n;
}
return 0;
}
| [
"static int VAR_0 mirror_dirty_init(MirrorBlockJob *s)\n{",
"int64_t sector_num, end;",
"BlockDriverState *base = s->base;",
"BlockDriverState *bs = s->source;",
"BlockDriverState *target_bs = blk_bs(s->target);",
"int ret, n;",
"end = s->bdev_length / BDRV_SECTOR_SIZE;",
"if (base == NULL && !bdrv_ha... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37,
39
],
[
43
],
[
47
],
[
49
],
[
51
],
[... |
15,587 | uint32_t do_arm_semihosting(CPUARMState *env)
{
target_ulong args;
char * s;
int nr;
uint32_t ret;
uint32_t len;
#ifdef CONFIG_USER_ONLY
TaskState *ts = env->opaque;
#else
CPUARMState *ts = env;
#endif
nr = env->regs[0];
args = env->regs[1];
switch (nr) {
case TARGET_SYS_OPEN:
if (!(s = lock_user_string(ARG(0))))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
if (ARG(1) >= 12)
return (uint32_t)-1;
if (strcmp(s, ":tt") == 0) {
if (ARG(1) < 4)
return STDIN_FILENO;
else
return STDOUT_FILENO;
}
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0),
(int)ARG(2)+1, gdb_open_modeflags[ARG(1)]);
return env->regs[0];
} else {
ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644));
}
unlock_user(s, ARG(0), 0);
return ret;
case TARGET_SYS_CLOSE:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0));
return env->regs[0];
} else {
return set_swi_errno(ts, close(ARG(0)));
}
case TARGET_SYS_WRITEC:
{
char c;
if (get_user_u8(c, args))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
/* Write to debug console. stderr is near enough. */
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args);
return env->regs[0];
} else {
return write(STDERR_FILENO, &c, 1);
}
}
case TARGET_SYS_WRITE0:
if (!(s = lock_user_string(args)))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
len = strlen(s);
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
ret = env->regs[0];
} else {
ret = write(STDERR_FILENO, s, len);
}
unlock_user(s, args, 0);
return ret;
case TARGET_SYS_WRITE:
len = ARG(2);
if (use_gdb_syscalls()) {
arm_semi_syscall_len = len;
gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len);
return env->regs[0];
} else {
if (!(s = lock_user(VERIFY_READ, ARG(1), len, 1)))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
ret = set_swi_errno(ts, write(ARG(0), s, len));
unlock_user(s, ARG(1), 0);
if (ret == (uint32_t)-1)
return -1;
return len - ret;
}
case TARGET_SYS_READ:
len = ARG(2);
if (use_gdb_syscalls()) {
arm_semi_syscall_len = len;
gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len);
return env->regs[0];
} else {
if (!(s = lock_user(VERIFY_WRITE, ARG(1), len, 0)))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
do
ret = set_swi_errno(ts, read(ARG(0), s, len));
while (ret == -1 && errno == EINTR);
unlock_user(s, ARG(1), len);
if (ret == (uint32_t)-1)
return -1;
return len - ret;
}
case TARGET_SYS_READC:
/* XXX: Read from debug console. Not implemented. */
return 0;
case TARGET_SYS_ISTTY:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0));
return env->regs[0];
} else {
return isatty(ARG(0));
}
case TARGET_SYS_SEEK:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", ARG(0), ARG(1));
return env->regs[0];
} else {
ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET));
if (ret == (uint32_t)-1)
return -1;
return 0;
}
case TARGET_SYS_FLEN:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x",
ARG(0), env->regs[13]-64);
return env->regs[0];
} else {
struct stat buf;
ret = set_swi_errno(ts, fstat(ARG(0), &buf));
if (ret == (uint32_t)-1)
return -1;
return buf.st_size;
}
case TARGET_SYS_TMPNAM:
/* XXX: Not implemented. */
return -1;
case TARGET_SYS_REMOVE:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1)+1);
ret = env->regs[0];
} else {
if (!(s = lock_user_string(ARG(0))))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
ret = set_swi_errno(ts, remove(s));
unlock_user(s, ARG(0), 0);
}
return ret;
case TARGET_SYS_RENAME:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "rename,%s,%s",
ARG(0), (int)ARG(1)+1, ARG(2), (int)ARG(3)+1);
return env->regs[0];
} else {
char *s2;
s = lock_user_string(ARG(0));
s2 = lock_user_string(ARG(2));
if (!s || !s2)
/* FIXME - should this error code be -TARGET_EFAULT ? */
ret = (uint32_t)-1;
else
ret = set_swi_errno(ts, rename(s, s2));
if (s2)
unlock_user(s2, ARG(2), 0);
if (s)
unlock_user(s, ARG(0), 0);
return ret;
}
case TARGET_SYS_CLOCK:
return clock() / (CLOCKS_PER_SEC / 100);
case TARGET_SYS_TIME:
return set_swi_errno(ts, time(NULL));
case TARGET_SYS_SYSTEM:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1)+1);
return env->regs[0];
} else {
if (!(s = lock_user_string(ARG(0))))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
ret = set_swi_errno(ts, system(s));
unlock_user(s, ARG(0), 0);
return ret;
}
case TARGET_SYS_ERRNO:
#ifdef CONFIG_USER_ONLY
return ts->swi_errno;
#else
return syscall_err;
#endif
case TARGET_SYS_GET_CMDLINE:
{
/* Build a command-line from the original argv.
*
* The inputs are:
* * ARG(0), pointer to a buffer of at least the size
* specified in ARG(1).
* * ARG(1), size of the buffer pointed to by ARG(0) in
* bytes.
*
* The outputs are:
* * ARG(0), pointer to null-terminated string of the
* command line.
* * ARG(1), length of the string pointed to by ARG(0).
*/
char *output_buffer;
size_t input_size = ARG(1);
size_t output_size;
int status = 0;
/* Compute the size of the output string. */
#if !defined(CONFIG_USER_ONLY)
output_size = strlen(ts->boot_info->kernel_filename)
+ 1 /* Separating space. */
+ strlen(ts->boot_info->kernel_cmdline)
+ 1; /* Terminating null byte. */
#else
unsigned int i;
output_size = ts->info->arg_end - ts->info->arg_start;
if (!output_size) {
/* We special-case the "empty command line" case (argc==0).
Just provide the terminating 0. */
output_size = 1;
}
#endif
if (output_size > input_size) {
/* Not enough space to store command-line arguments. */
return -1;
}
/* Adjust the command-line length. */
SET_ARG(1, output_size - 1);
/* Lock the buffer on the ARM side. */
output_buffer = lock_user(VERIFY_WRITE, ARG(0), output_size, 0);
if (!output_buffer) {
return -1;
}
/* Copy the command-line arguments. */
#if !defined(CONFIG_USER_ONLY)
pstrcpy(output_buffer, output_size, ts->boot_info->kernel_filename);
pstrcat(output_buffer, output_size, " ");
pstrcat(output_buffer, output_size, ts->boot_info->kernel_cmdline);
#else
if (output_size == 1) {
/* Empty command-line. */
output_buffer[0] = '\0';
goto out;
}
if (copy_from_user(output_buffer, ts->info->arg_start,
output_size)) {
status = -1;
goto out;
}
/* Separate arguments by white spaces. */
for (i = 0; i < output_size - 1; i++) {
if (output_buffer[i] == 0) {
output_buffer[i] = ' ';
}
}
out:
#endif
/* Unlock the buffer on the ARM side. */
unlock_user(output_buffer, ARG(0), output_size);
return status;
}
case TARGET_SYS_HEAPINFO:
{
uint32_t *ptr;
uint32_t limit;
#ifdef CONFIG_USER_ONLY
/* Some C libraries assume the heap immediately follows .bss, so
allocate it using sbrk. */
if (!ts->heap_limit) {
abi_ulong ret;
ts->heap_base = do_brk(0);
limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
/* Try a big heap, and reduce the size if that fails. */
for (;;) {
ret = do_brk(limit);
if (ret >= limit) {
break;
}
limit = (ts->heap_base >> 1) + (limit >> 1);
}
ts->heap_limit = limit;
}
if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
ptr[0] = tswap32(ts->heap_base);
ptr[1] = tswap32(ts->heap_limit);
ptr[2] = tswap32(ts->stack_base);
ptr[3] = tswap32(0); /* Stack limit. */
unlock_user(ptr, ARG(0), 16);
#else
limit = ram_size;
if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
/* FIXME - should this error code be -TARGET_EFAULT ? */
return (uint32_t)-1;
/* TODO: Make this use the limit of the loaded application. */
ptr[0] = tswap32(limit / 2);
ptr[1] = tswap32(limit);
ptr[2] = tswap32(limit); /* Stack base */
ptr[3] = tswap32(0); /* Stack limit. */
unlock_user(ptr, ARG(0), 16);
#endif
return 0;
}
case TARGET_SYS_EXIT:
gdb_exit(env, 0);
exit(0);
default:
fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
cpu_dump_state(env, stderr, fprintf, 0);
abort();
}
}
| true | qemu | 396bef4b3846bf4e80a2bee38e9a2d8554d0f251 | uint32_t do_arm_semihosting(CPUARMState *env)
{
target_ulong args;
char * s;
int nr;
uint32_t ret;
uint32_t len;
#ifdef CONFIG_USER_ONLY
TaskState *ts = env->opaque;
#else
CPUARMState *ts = env;
#endif
nr = env->regs[0];
args = env->regs[1];
switch (nr) {
case TARGET_SYS_OPEN:
if (!(s = lock_user_string(ARG(0))))
return (uint32_t)-1;
if (ARG(1) >= 12)
return (uint32_t)-1;
if (strcmp(s, ":tt") == 0) {
if (ARG(1) < 4)
return STDIN_FILENO;
else
return STDOUT_FILENO;
}
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0),
(int)ARG(2)+1, gdb_open_modeflags[ARG(1)]);
return env->regs[0];
} else {
ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644));
}
unlock_user(s, ARG(0), 0);
return ret;
case TARGET_SYS_CLOSE:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0));
return env->regs[0];
} else {
return set_swi_errno(ts, close(ARG(0)));
}
case TARGET_SYS_WRITEC:
{
char c;
if (get_user_u8(c, args))
return (uint32_t)-1;
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args);
return env->regs[0];
} else {
return write(STDERR_FILENO, &c, 1);
}
}
case TARGET_SYS_WRITE0:
if (!(s = lock_user_string(args)))
return (uint32_t)-1;
len = strlen(s);
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
ret = env->regs[0];
} else {
ret = write(STDERR_FILENO, s, len);
}
unlock_user(s, args, 0);
return ret;
case TARGET_SYS_WRITE:
len = ARG(2);
if (use_gdb_syscalls()) {
arm_semi_syscall_len = len;
gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len);
return env->regs[0];
} else {
if (!(s = lock_user(VERIFY_READ, ARG(1), len, 1)))
return (uint32_t)-1;
ret = set_swi_errno(ts, write(ARG(0), s, len));
unlock_user(s, ARG(1), 0);
if (ret == (uint32_t)-1)
return -1;
return len - ret;
}
case TARGET_SYS_READ:
len = ARG(2);
if (use_gdb_syscalls()) {
arm_semi_syscall_len = len;
gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len);
return env->regs[0];
} else {
if (!(s = lock_user(VERIFY_WRITE, ARG(1), len, 0)))
return (uint32_t)-1;
do
ret = set_swi_errno(ts, read(ARG(0), s, len));
while (ret == -1 && errno == EINTR);
unlock_user(s, ARG(1), len);
if (ret == (uint32_t)-1)
return -1;
return len - ret;
}
case TARGET_SYS_READC:
return 0;
case TARGET_SYS_ISTTY:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0));
return env->regs[0];
} else {
return isatty(ARG(0));
}
case TARGET_SYS_SEEK:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", ARG(0), ARG(1));
return env->regs[0];
} else {
ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET));
if (ret == (uint32_t)-1)
return -1;
return 0;
}
case TARGET_SYS_FLEN:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x",
ARG(0), env->regs[13]-64);
return env->regs[0];
} else {
struct stat buf;
ret = set_swi_errno(ts, fstat(ARG(0), &buf));
if (ret == (uint32_t)-1)
return -1;
return buf.st_size;
}
case TARGET_SYS_TMPNAM:
return -1;
case TARGET_SYS_REMOVE:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1)+1);
ret = env->regs[0];
} else {
if (!(s = lock_user_string(ARG(0))))
return (uint32_t)-1;
ret = set_swi_errno(ts, remove(s));
unlock_user(s, ARG(0), 0);
}
return ret;
case TARGET_SYS_RENAME:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "rename,%s,%s",
ARG(0), (int)ARG(1)+1, ARG(2), (int)ARG(3)+1);
return env->regs[0];
} else {
char *s2;
s = lock_user_string(ARG(0));
s2 = lock_user_string(ARG(2));
if (!s || !s2)
ret = (uint32_t)-1;
else
ret = set_swi_errno(ts, rename(s, s2));
if (s2)
unlock_user(s2, ARG(2), 0);
if (s)
unlock_user(s, ARG(0), 0);
return ret;
}
case TARGET_SYS_CLOCK:
return clock() / (CLOCKS_PER_SEC / 100);
case TARGET_SYS_TIME:
return set_swi_errno(ts, time(NULL));
case TARGET_SYS_SYSTEM:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1)+1);
return env->regs[0];
} else {
if (!(s = lock_user_string(ARG(0))))
return (uint32_t)-1;
ret = set_swi_errno(ts, system(s));
unlock_user(s, ARG(0), 0);
return ret;
}
case TARGET_SYS_ERRNO:
#ifdef CONFIG_USER_ONLY
return ts->swi_errno;
#else
return syscall_err;
#endif
case TARGET_SYS_GET_CMDLINE:
{
char *output_buffer;
size_t input_size = ARG(1);
size_t output_size;
int status = 0;
#if !defined(CONFIG_USER_ONLY)
output_size = strlen(ts->boot_info->kernel_filename)
+ 1
+ strlen(ts->boot_info->kernel_cmdline)
+ 1;
#else
unsigned int i;
output_size = ts->info->arg_end - ts->info->arg_start;
if (!output_size) {
output_size = 1;
}
#endif
if (output_size > input_size) {
return -1;
}
SET_ARG(1, output_size - 1);
output_buffer = lock_user(VERIFY_WRITE, ARG(0), output_size, 0);
if (!output_buffer) {
return -1;
}
#if !defined(CONFIG_USER_ONLY)
pstrcpy(output_buffer, output_size, ts->boot_info->kernel_filename);
pstrcat(output_buffer, output_size, " ");
pstrcat(output_buffer, output_size, ts->boot_info->kernel_cmdline);
#else
if (output_size == 1) {
output_buffer[0] = '\0';
goto out;
}
if (copy_from_user(output_buffer, ts->info->arg_start,
output_size)) {
status = -1;
goto out;
}
for (i = 0; i < output_size - 1; i++) {
if (output_buffer[i] == 0) {
output_buffer[i] = ' ';
}
}
out:
#endif
unlock_user(output_buffer, ARG(0), output_size);
return status;
}
case TARGET_SYS_HEAPINFO:
{
uint32_t *ptr;
uint32_t limit;
#ifdef CONFIG_USER_ONLY
if (!ts->heap_limit) {
abi_ulong ret;
ts->heap_base = do_brk(0);
limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
for (;;) {
ret = do_brk(limit);
if (ret >= limit) {
break;
}
limit = (ts->heap_base >> 1) + (limit >> 1);
}
ts->heap_limit = limit;
}
if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
return (uint32_t)-1;
ptr[0] = tswap32(ts->heap_base);
ptr[1] = tswap32(ts->heap_limit);
ptr[2] = tswap32(ts->stack_base);
ptr[3] = tswap32(0);
unlock_user(ptr, ARG(0), 16);
#else
limit = ram_size;
if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
return (uint32_t)-1;
ptr[0] = tswap32(limit / 2);
ptr[1] = tswap32(limit);
ptr[2] = tswap32(limit);
ptr[3] = tswap32(0);
unlock_user(ptr, ARG(0), 16);
#endif
return 0;
}
case TARGET_SYS_EXIT:
gdb_exit(env, 0);
exit(0);
default:
fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
cpu_dump_state(env, stderr, fprintf, 0);
abort();
}
}
| {
"code": [
" if (ARG(1) >= 12)",
" if (ARG(1) < 4)",
" return STDIN_FILENO;",
" return STDOUT_FILENO;",
" return env->regs[0];"
],
"line_no": [
41,
47,
49,
53,
63
]
} | uint32_t FUNC_0(CPUARMState *env)
{
target_ulong args;
char * VAR_0;
int VAR_1;
uint32_t ret;
uint32_t len;
#ifdef CONFIG_USER_ONLY
TaskState *ts = env->opaque;
#else
CPUARMState *ts = env;
#endif
VAR_1 = env->regs[0];
args = env->regs[1];
switch (VAR_1) {
case TARGET_SYS_OPEN:
if (!(VAR_0 = lock_user_string(ARG(0))))
return (uint32_t)-1;
if (ARG(1) >= 12)
return (uint32_t)-1;
if (strcmp(VAR_0, ":tt") == 0) {
if (ARG(1) < 4)
return STDIN_FILENO;
else
return STDOUT_FILENO;
}
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "open,%VAR_0,%x,1a4", ARG(0),
(int)ARG(2)+1, gdb_open_modeflags[ARG(1)]);
return env->regs[0];
} else {
ret = set_swi_errno(ts, open(VAR_0, open_modeflags[ARG(1)], 0644));
}
unlock_user(VAR_0, ARG(0), 0);
return ret;
case TARGET_SYS_CLOSE:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0));
return env->regs[0];
} else {
return set_swi_errno(ts, close(ARG(0)));
}
case TARGET_SYS_WRITEC:
{
char VAR_2;
if (get_user_u8(VAR_2, args))
return (uint32_t)-1;
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args);
return env->regs[0];
} else {
return write(STDERR_FILENO, &VAR_2, 1);
}
}
case TARGET_SYS_WRITE0:
if (!(VAR_0 = lock_user_string(args)))
return (uint32_t)-1;
len = strlen(VAR_0);
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
ret = env->regs[0];
} else {
ret = write(STDERR_FILENO, VAR_0, len);
}
unlock_user(VAR_0, args, 0);
return ret;
case TARGET_SYS_WRITE:
len = ARG(2);
if (use_gdb_syscalls()) {
arm_semi_syscall_len = len;
gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len);
return env->regs[0];
} else {
if (!(VAR_0 = lock_user(VERIFY_READ, ARG(1), len, 1)))
return (uint32_t)-1;
ret = set_swi_errno(ts, write(ARG(0), VAR_0, len));
unlock_user(VAR_0, ARG(1), 0);
if (ret == (uint32_t)-1)
return -1;
return len - ret;
}
case TARGET_SYS_READ:
len = ARG(2);
if (use_gdb_syscalls()) {
arm_semi_syscall_len = len;
gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len);
return env->regs[0];
} else {
if (!(VAR_0 = lock_user(VERIFY_WRITE, ARG(1), len, 0)))
return (uint32_t)-1;
do
ret = set_swi_errno(ts, read(ARG(0), VAR_0, len));
while (ret == -1 && errno == EINTR);
unlock_user(VAR_0, ARG(1), len);
if (ret == (uint32_t)-1)
return -1;
return len - ret;
}
case TARGET_SYS_READC:
return 0;
case TARGET_SYS_ISTTY:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0));
return env->regs[0];
} else {
return isatty(ARG(0));
}
case TARGET_SYS_SEEK:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", ARG(0), ARG(1));
return env->regs[0];
} else {
ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET));
if (ret == (uint32_t)-1)
return -1;
return 0;
}
case TARGET_SYS_FLEN:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x",
ARG(0), env->regs[13]-64);
return env->regs[0];
} else {
struct stat VAR_3;
ret = set_swi_errno(ts, fstat(ARG(0), &VAR_3));
if (ret == (uint32_t)-1)
return -1;
return VAR_3.st_size;
}
case TARGET_SYS_TMPNAM:
return -1;
case TARGET_SYS_REMOVE:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "unlink,%VAR_0", ARG(0), (int)ARG(1)+1);
ret = env->regs[0];
} else {
if (!(VAR_0 = lock_user_string(ARG(0))))
return (uint32_t)-1;
ret = set_swi_errno(ts, remove(VAR_0));
unlock_user(VAR_0, ARG(0), 0);
}
return ret;
case TARGET_SYS_RENAME:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "rename,%VAR_0,%VAR_0",
ARG(0), (int)ARG(1)+1, ARG(2), (int)ARG(3)+1);
return env->regs[0];
} else {
char *VAR_4;
VAR_0 = lock_user_string(ARG(0));
VAR_4 = lock_user_string(ARG(2));
if (!VAR_0 || !VAR_4)
ret = (uint32_t)-1;
else
ret = set_swi_errno(ts, rename(VAR_0, VAR_4));
if (VAR_4)
unlock_user(VAR_4, ARG(2), 0);
if (VAR_0)
unlock_user(VAR_0, ARG(0), 0);
return ret;
}
case TARGET_SYS_CLOCK:
return clock() / (CLOCKS_PER_SEC / 100);
case TARGET_SYS_TIME:
return set_swi_errno(ts, time(NULL));
case TARGET_SYS_SYSTEM:
if (use_gdb_syscalls()) {
gdb_do_syscall(arm_semi_cb, "system,%VAR_0", ARG(0), (int)ARG(1)+1);
return env->regs[0];
} else {
if (!(VAR_0 = lock_user_string(ARG(0))))
return (uint32_t)-1;
ret = set_swi_errno(ts, system(VAR_0));
unlock_user(VAR_0, ARG(0), 0);
return ret;
}
case TARGET_SYS_ERRNO:
#ifdef CONFIG_USER_ONLY
return ts->swi_errno;
#else
return syscall_err;
#endif
case TARGET_SYS_GET_CMDLINE:
{
char *VAR_5;
size_t input_size = ARG(1);
size_t output_size;
int VAR_6 = 0;
#if !defined(CONFIG_USER_ONLY)
output_size = strlen(ts->boot_info->kernel_filename)
+ 1
+ strlen(ts->boot_info->kernel_cmdline)
+ 1;
#else
unsigned int i;
output_size = ts->info->arg_end - ts->info->arg_start;
if (!output_size) {
output_size = 1;
}
#endif
if (output_size > input_size) {
return -1;
}
SET_ARG(1, output_size - 1);
VAR_5 = lock_user(VERIFY_WRITE, ARG(0), output_size, 0);
if (!VAR_5) {
return -1;
}
#if !defined(CONFIG_USER_ONLY)
pstrcpy(VAR_5, output_size, ts->boot_info->kernel_filename);
pstrcat(VAR_5, output_size, " ");
pstrcat(VAR_5, output_size, ts->boot_info->kernel_cmdline);
#else
if (output_size == 1) {
VAR_5[0] = '\0';
goto out;
}
if (copy_from_user(VAR_5, ts->info->arg_start,
output_size)) {
VAR_6 = -1;
goto out;
}
for (i = 0; i < output_size - 1; i++) {
if (VAR_5[i] == 0) {
VAR_5[i] = ' ';
}
}
out:
#endif
unlock_user(VAR_5, ARG(0), output_size);
return VAR_6;
}
case TARGET_SYS_HEAPINFO:
{
uint32_t *ptr;
uint32_t limit;
#ifdef CONFIG_USER_ONLY
if (!ts->heap_limit) {
abi_ulong ret;
ts->heap_base = do_brk(0);
limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
for (;;) {
ret = do_brk(limit);
if (ret >= limit) {
break;
}
limit = (ts->heap_base >> 1) + (limit >> 1);
}
ts->heap_limit = limit;
}
if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
return (uint32_t)-1;
ptr[0] = tswap32(ts->heap_base);
ptr[1] = tswap32(ts->heap_limit);
ptr[2] = tswap32(ts->stack_base);
ptr[3] = tswap32(0);
unlock_user(ptr, ARG(0), 16);
#else
limit = ram_size;
if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
return (uint32_t)-1;
ptr[0] = tswap32(limit / 2);
ptr[1] = tswap32(limit);
ptr[2] = tswap32(limit);
ptr[3] = tswap32(0);
unlock_user(ptr, ARG(0), 16);
#endif
return 0;
}
case TARGET_SYS_EXIT:
gdb_exit(env, 0);
exit(0);
default:
fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", VAR_1);
cpu_dump_state(env, stderr, fprintf, 0);
abort();
}
}
| [
"uint32_t FUNC_0(CPUARMState *env)\n{",
"target_ulong args;",
"char * VAR_0;",
"int VAR_1;",
"uint32_t ret;",
"uint32_t len;",
"#ifdef CONFIG_USER_ONLY\nTaskState *ts = env->opaque;",
"#else\nCPUARMState *ts = env;",
"#endif\nVAR_1 = env->regs[0];",
"args = env->regs[1];",
"switch (VAR_1) {",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15,
17
],
[
19,
21
],
[
23,
27
],
[
29
],
[
31
],
[
33,
35,
39
],
[
41,
43
],
[
45
],
[
47,
49
],
[
51,
53
... |
15,588 | static void video_audio_display(VideoState *s)
{
int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
int ch, channels, h, h2, bgcolor, fgcolor;
int16_t time_diff;
int rdft_bits, nb_freq;
for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
;
nb_freq = 1 << (rdft_bits - 1);
/* compute display index : center on currently output samples */
channels = s->audio_tgt.channels;
nb_display_channels = channels;
if (!s->paused) {
int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
n = 2 * channels;
delay = s->audio_write_buf_size;
delay /= n;
/* to be more precise, we take into account the time spent since
the last buffer computation */
if (audio_callback_time) {
time_diff = av_gettime() - audio_callback_time;
delay -= (time_diff * s->audio_tgt.freq) / 1000000;
}
delay += 2 * data_used;
if (delay < data_used)
delay = data_used;
i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
if (s->show_mode == SHOW_MODE_WAVES) {
h = INT_MIN;
for (i = 0; i < 1000; i += channels) {
int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
int a = s->sample_array[idx];
int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
int score = a - d;
if (h < score && (b ^ c) < 0) {
h = score;
i_start = idx;
}
}
}
s->last_i_start = i_start;
} else {
i_start = s->last_i_start;
}
bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
if (s->show_mode == SHOW_MODE_WAVES) {
fill_rectangle(screen,
s->xleft, s->ytop, s->width, s->height,
bgcolor, 0);
fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
/* total height for one channel */
h = s->height / nb_display_channels;
/* graph height / 2 */
h2 = (h * 9) / 20;
for (ch = 0; ch < nb_display_channels; ch++) {
i = i_start + ch;
y1 = s->ytop + ch * h + (h / 2); /* position of center line */
for (x = 0; x < s->width; x++) {
y = (s->sample_array[i] * h2) >> 15;
if (y < 0) {
y = -y;
ys = y1 - y;
} else {
ys = y1;
}
fill_rectangle(screen,
s->xleft + x, ys, 1, y,
fgcolor, 0);
i += channels;
if (i >= SAMPLE_ARRAY_SIZE)
i -= SAMPLE_ARRAY_SIZE;
}
}
fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
for (ch = 1; ch < nb_display_channels; ch++) {
y = s->ytop + ch * h;
fill_rectangle(screen,
s->xleft, y, s->width, 1,
fgcolor, 0);
}
SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
} else {
nb_display_channels= FFMIN(nb_display_channels, 2);
if (rdft_bits != s->rdft_bits) {
av_rdft_end(s->rdft);
av_free(s->rdft_data);
s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
s->rdft_bits = rdft_bits;
s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
}
{
FFTSample *data[2];
for (ch = 0; ch < nb_display_channels; ch++) {
data[ch] = s->rdft_data + 2 * nb_freq * ch;
i = i_start + ch;
for (x = 0; x < 2 * nb_freq; x++) {
double w = (x-nb_freq) * (1.0 / nb_freq);
data[ch][x] = s->sample_array[i] * (1.0 - w * w);
i += channels;
if (i >= SAMPLE_ARRAY_SIZE)
i -= SAMPLE_ARRAY_SIZE;
}
av_rdft_calc(s->rdft, data[ch]);
}
// least efficient way to do this, we should of course directly access it but its more than fast enough
for (y = 0; y < s->height; y++) {
double w = 1 / sqrt(nb_freq);
int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));
int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
+ data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
a = FFMIN(a, 255);
b = FFMIN(b, 255);
fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
fill_rectangle(screen,
s->xpos, s->height-y, 1, 1,
fgcolor, 0);
}
}
SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
if (!s->paused)
s->xpos++;
if (s->xpos >= s->width)
s->xpos= s->xleft;
}
}
| true | FFmpeg | 92b50b71a1e4e78fa2828dc2e0a4428674a8a9b0 | static void video_audio_display(VideoState *s)
{
int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
int ch, channels, h, h2, bgcolor, fgcolor;
int16_t time_diff;
int rdft_bits, nb_freq;
for (rdft_bits = 1; (1 << rdft_bits) < 2 * s->height; rdft_bits++)
;
nb_freq = 1 << (rdft_bits - 1);
channels = s->audio_tgt.channels;
nb_display_channels = channels;
if (!s->paused) {
int data_used= s->show_mode == SHOW_MODE_WAVES ? s->width : (2*nb_freq);
n = 2 * channels;
delay = s->audio_write_buf_size;
delay /= n;
if (audio_callback_time) {
time_diff = av_gettime() - audio_callback_time;
delay -= (time_diff * s->audio_tgt.freq) / 1000000;
}
delay += 2 * data_used;
if (delay < data_used)
delay = data_used;
i_start= x = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
if (s->show_mode == SHOW_MODE_WAVES) {
h = INT_MIN;
for (i = 0; i < 1000; i += channels) {
int idx = (SAMPLE_ARRAY_SIZE + x - i) % SAMPLE_ARRAY_SIZE;
int a = s->sample_array[idx];
int b = s->sample_array[(idx + 4 * channels) % SAMPLE_ARRAY_SIZE];
int c = s->sample_array[(idx + 5 * channels) % SAMPLE_ARRAY_SIZE];
int d = s->sample_array[(idx + 9 * channels) % SAMPLE_ARRAY_SIZE];
int score = a - d;
if (h < score && (b ^ c) < 0) {
h = score;
i_start = idx;
}
}
}
s->last_i_start = i_start;
} else {
i_start = s->last_i_start;
}
bgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
if (s->show_mode == SHOW_MODE_WAVES) {
fill_rectangle(screen,
s->xleft, s->ytop, s->width, s->height,
bgcolor, 0);
fgcolor = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
h = s->height / nb_display_channels;
h2 = (h * 9) / 20;
for (ch = 0; ch < nb_display_channels; ch++) {
i = i_start + ch;
y1 = s->ytop + ch * h + (h / 2);
for (x = 0; x < s->width; x++) {
y = (s->sample_array[i] * h2) >> 15;
if (y < 0) {
y = -y;
ys = y1 - y;
} else {
ys = y1;
}
fill_rectangle(screen,
s->xleft + x, ys, 1, y,
fgcolor, 0);
i += channels;
if (i >= SAMPLE_ARRAY_SIZE)
i -= SAMPLE_ARRAY_SIZE;
}
}
fgcolor = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
for (ch = 1; ch < nb_display_channels; ch++) {
y = s->ytop + ch * h;
fill_rectangle(screen,
s->xleft, y, s->width, 1,
fgcolor, 0);
}
SDL_UpdateRect(screen, s->xleft, s->ytop, s->width, s->height);
} else {
nb_display_channels= FFMIN(nb_display_channels, 2);
if (rdft_bits != s->rdft_bits) {
av_rdft_end(s->rdft);
av_free(s->rdft_data);
s->rdft = av_rdft_init(rdft_bits, DFT_R2C);
s->rdft_bits = rdft_bits;
s->rdft_data = av_malloc(4 * nb_freq * sizeof(*s->rdft_data));
}
{
FFTSample *data[2];
for (ch = 0; ch < nb_display_channels; ch++) {
data[ch] = s->rdft_data + 2 * nb_freq * ch;
i = i_start + ch;
for (x = 0; x < 2 * nb_freq; x++) {
double w = (x-nb_freq) * (1.0 / nb_freq);
data[ch][x] = s->sample_array[i] * (1.0 - w * w);
i += channels;
if (i >= SAMPLE_ARRAY_SIZE)
i -= SAMPLE_ARRAY_SIZE;
}
av_rdft_calc(s->rdft, data[ch]);
}
for (y = 0; y < s->height; y++) {
double w = 1 / sqrt(nb_freq);
int a = sqrt(w * sqrt(data[0][2 * y + 0] * data[0][2 * y + 0] + data[0][2 * y + 1] * data[0][2 * y + 1]));
int b = (nb_display_channels == 2 ) ? sqrt(w * sqrt(data[1][2 * y + 0] * data[1][2 * y + 0]
+ data[1][2 * y + 1] * data[1][2 * y + 1])) : a;
a = FFMIN(a, 255);
b = FFMIN(b, 255);
fgcolor = SDL_MapRGB(screen->format, a, b, (a + b) / 2);
fill_rectangle(screen,
s->xpos, s->height-y, 1, 1,
fgcolor, 0);
}
}
SDL_UpdateRect(screen, s->xpos, s->ytop, 1, s->height);
if (!s->paused)
s->xpos++;
if (s->xpos >= s->width)
s->xpos= s->xleft;
}
}
| {
"code": [
" int16_t time_diff;"
],
"line_no": [
9
]
} | static void FUNC_0(VideoState *VAR_0)
{
int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;
int VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15;
int16_t time_diff;
int VAR_16, VAR_17;
for (VAR_16 = 1; (1 << VAR_16) < 2 * VAR_0->height; VAR_16++)
;
VAR_17 = 1 << (VAR_16 - 1);
VAR_11 = VAR_0->audio_tgt.VAR_11;
VAR_9 = VAR_11;
if (!VAR_0->paused) {
int VAR_18= VAR_0->show_mode == SHOW_MODE_WAVES ? VAR_0->width : (2*VAR_17);
VAR_8 = 2 * VAR_11;
VAR_7 = VAR_0->audio_write_buf_size;
VAR_7 /= VAR_8;
if (audio_callback_time) {
time_diff = av_gettime() - audio_callback_time;
VAR_7 -= (time_diff * VAR_0->audio_tgt.freq) / 1000000;
}
VAR_7 += 2 * VAR_18;
if (VAR_7 < VAR_18)
VAR_7 = VAR_18;
VAR_2= VAR_3 = compute_mod(VAR_0->sample_array_index - VAR_7 * VAR_11, SAMPLE_ARRAY_SIZE);
if (VAR_0->show_mode == SHOW_MODE_WAVES) {
VAR_12 = INT_MIN;
for (VAR_1 = 0; VAR_1 < 1000; VAR_1 += VAR_11) {
int VAR_19 = (SAMPLE_ARRAY_SIZE + VAR_3 - VAR_1) % SAMPLE_ARRAY_SIZE;
int VAR_20 = VAR_0->sample_array[VAR_19];
int VAR_21 = VAR_0->sample_array[(VAR_19 + 4 * VAR_11) % SAMPLE_ARRAY_SIZE];
int VAR_22 = VAR_0->sample_array[(VAR_19 + 5 * VAR_11) % SAMPLE_ARRAY_SIZE];
int VAR_23 = VAR_0->sample_array[(VAR_19 + 9 * VAR_11) % SAMPLE_ARRAY_SIZE];
int VAR_24 = VAR_20 - VAR_23;
if (VAR_12 < VAR_24 && (VAR_21 ^ VAR_22) < 0) {
VAR_12 = VAR_24;
VAR_2 = VAR_19;
}
}
}
VAR_0->last_i_start = VAR_2;
} else {
VAR_2 = VAR_0->last_i_start;
}
VAR_14 = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
if (VAR_0->show_mode == SHOW_MODE_WAVES) {
fill_rectangle(screen,
VAR_0->xleft, VAR_0->ytop, VAR_0->width, VAR_0->height,
VAR_14, 0);
VAR_15 = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
VAR_12 = VAR_0->height / VAR_9;
VAR_13 = (VAR_12 * 9) / 20;
for (VAR_10 = 0; VAR_10 < VAR_9; VAR_10++) {
VAR_1 = VAR_2 + VAR_10;
VAR_4 = VAR_0->ytop + VAR_10 * VAR_12 + (VAR_12 / 2);
for (VAR_3 = 0; VAR_3 < VAR_0->width; VAR_3++) {
VAR_5 = (VAR_0->sample_array[VAR_1] * VAR_13) >> 15;
if (VAR_5 < 0) {
VAR_5 = -VAR_5;
VAR_6 = VAR_4 - VAR_5;
} else {
VAR_6 = VAR_4;
}
fill_rectangle(screen,
VAR_0->xleft + VAR_3, VAR_6, 1, VAR_5,
VAR_15, 0);
VAR_1 += VAR_11;
if (VAR_1 >= SAMPLE_ARRAY_SIZE)
VAR_1 -= SAMPLE_ARRAY_SIZE;
}
}
VAR_15 = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
for (VAR_10 = 1; VAR_10 < VAR_9; VAR_10++) {
VAR_5 = VAR_0->ytop + VAR_10 * VAR_12;
fill_rectangle(screen,
VAR_0->xleft, VAR_5, VAR_0->width, 1,
VAR_15, 0);
}
SDL_UpdateRect(screen, VAR_0->xleft, VAR_0->ytop, VAR_0->width, VAR_0->height);
} else {
VAR_9= FFMIN(VAR_9, 2);
if (VAR_16 != VAR_0->VAR_16) {
av_rdft_end(VAR_0->rdft);
av_free(VAR_0->rdft_data);
VAR_0->rdft = av_rdft_init(VAR_16, DFT_R2C);
VAR_0->VAR_16 = VAR_16;
VAR_0->rdft_data = av_malloc(4 * VAR_17 * sizeof(*VAR_0->rdft_data));
}
{
FFTSample *data[2];
for (VAR_10 = 0; VAR_10 < VAR_9; VAR_10++) {
data[VAR_10] = VAR_0->rdft_data + 2 * VAR_17 * VAR_10;
VAR_1 = VAR_2 + VAR_10;
for (VAR_3 = 0; VAR_3 < 2 * VAR_17; VAR_3++) {
double VAR_25 = (VAR_3-VAR_17) * (1.0 / VAR_17);
data[VAR_10][VAR_3] = VAR_0->sample_array[VAR_1] * (1.0 - VAR_25 * VAR_25);
VAR_1 += VAR_11;
if (VAR_1 >= SAMPLE_ARRAY_SIZE)
VAR_1 -= SAMPLE_ARRAY_SIZE;
}
av_rdft_calc(VAR_0->rdft, data[VAR_10]);
}
for (VAR_5 = 0; VAR_5 < VAR_0->height; VAR_5++) {
double VAR_25 = 1 / sqrt(VAR_17);
int VAR_20 = sqrt(VAR_25 * sqrt(data[0][2 * VAR_5 + 0] * data[0][2 * VAR_5 + 0] + data[0][2 * VAR_5 + 1] * data[0][2 * VAR_5 + 1]));
int VAR_21 = (VAR_9 == 2 ) ? sqrt(VAR_25 * sqrt(data[1][2 * VAR_5 + 0] * data[1][2 * VAR_5 + 0]
+ data[1][2 * VAR_5 + 1] * data[1][2 * VAR_5 + 1])) : VAR_20;
VAR_20 = FFMIN(VAR_20, 255);
VAR_21 = FFMIN(VAR_21, 255);
VAR_15 = SDL_MapRGB(screen->format, VAR_20, VAR_21, (VAR_20 + VAR_21) / 2);
fill_rectangle(screen,
VAR_0->xpos, VAR_0->height-VAR_5, 1, 1,
VAR_15, 0);
}
}
SDL_UpdateRect(screen, VAR_0->xpos, VAR_0->ytop, 1, VAR_0->height);
if (!VAR_0->paused)
VAR_0->xpos++;
if (VAR_0->xpos >= VAR_0->width)
VAR_0->xpos= VAR_0->xleft;
}
}
| [
"static void FUNC_0(VideoState *VAR_0)\n{",
"int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7, VAR_8, VAR_9;",
"int VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15;",
"int16_t time_diff;",
"int VAR_16, VAR_17;",
"for (VAR_16 = 1; (1 << VAR_16) < 2 * VAR_0->height; VAR_16++)",
";",
"VAR_17 = 1 << (VA... | [
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... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
... |
15,590 | static int dirac_unpack_prediction_parameters(DiracContext *s)
{
static const uint8_t default_blen[] = { 4, 12, 16, 24 };
static const uint8_t default_bsep[] = { 4, 8, 12, 16 };
GetBitContext *gb = &s->gb;
unsigned idx, ref;
align_get_bits(gb);
/* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
/* Luma and Chroma are equal. 11.2.3 */
idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
if (idx > 4) {
av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
return -1;
}
if (idx == 0) {
s->plane[0].xblen = svq3_get_ue_golomb(gb);
s->plane[0].yblen = svq3_get_ue_golomb(gb);
s->plane[0].xbsep = svq3_get_ue_golomb(gb);
s->plane[0].ybsep = svq3_get_ue_golomb(gb);
} else {
/*[DIRAC_STD] preset_block_params(index). Table 11.1 */
s->plane[0].xblen = default_blen[idx-1];
s->plane[0].yblen = default_blen[idx-1];
s->plane[0].xbsep = default_bsep[idx-1];
s->plane[0].ybsep = default_bsep[idx-1];
}
/*[DIRAC_STD] 11.2.4 motion_data_dimensions()
Calculated in function dirac_unpack_block_motion_data */
if (s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) {
av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
return -1;
}
if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
av_log(s->avctx, AV_LOG_ERROR, "Block seperation greater than size\n");
return -1;
}
if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
return -1;
}
/*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
Read motion vector precision */
s->mv_precision = svq3_get_ue_golomb(gb);
if (s->mv_precision > 3) {
av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
return -1;
}
/*[DIRAC_STD] 11.2.6 Global motion. global_motion()
Read the global motion compensation parameters */
s->globalmc_flag = get_bits1(gb);
if (s->globalmc_flag) {
memset(s->globalmc, 0, sizeof(s->globalmc));
/* [DIRAC_STD] pan_tilt(gparams) */
for (ref = 0; ref < s->num_refs; ref++) {
if (get_bits1(gb)) {
s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
}
/* [DIRAC_STD] zoom_rotate_shear(gparams)
zoom/rotation/shear parameters */
if (get_bits1(gb)) {
s->globalmc[ref].zrs_exp = svq3_get_ue_golomb(gb);
s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
} else {
s->globalmc[ref].zrs[0][0] = 1;
s->globalmc[ref].zrs[1][1] = 1;
}
/* [DIRAC_STD] perspective(gparams) */
if (get_bits1(gb)) {
s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb);
s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb);
}
}
}
/*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
Picture prediction mode, not currently used. */
if (svq3_get_ue_golomb(gb)) {
av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
return -1;
}
/* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
just data read, weight calculation will be done later on. */
s->weight_log2denom = 1;
s->weight[0] = 1;
s->weight[1] = 1;
if (get_bits1(gb)) {
s->weight_log2denom = svq3_get_ue_golomb(gb);
s->weight[0] = dirac_get_se_golomb(gb);
if (s->num_refs == 2)
s->weight[1] = dirac_get_se_golomb(gb);
}
return 0;
}
| true | FFmpeg | 601d072e68fb2967e561980336bea0b0625e629e | static int dirac_unpack_prediction_parameters(DiracContext *s)
{
static const uint8_t default_blen[] = { 4, 12, 16, 24 };
static const uint8_t default_bsep[] = { 4, 8, 12, 16 };
GetBitContext *gb = &s->gb;
unsigned idx, ref;
align_get_bits(gb);
idx = svq3_get_ue_golomb(gb);
if (idx > 4) {
av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
return -1;
}
if (idx == 0) {
s->plane[0].xblen = svq3_get_ue_golomb(gb);
s->plane[0].yblen = svq3_get_ue_golomb(gb);
s->plane[0].xbsep = svq3_get_ue_golomb(gb);
s->plane[0].ybsep = svq3_get_ue_golomb(gb);
} else {
s->plane[0].xblen = default_blen[idx-1];
s->plane[0].yblen = default_blen[idx-1];
s->plane[0].xbsep = default_bsep[idx-1];
s->plane[0].ybsep = default_bsep[idx-1];
}
if (s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) {
av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
return -1;
}
if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
av_log(s->avctx, AV_LOG_ERROR, "Block seperation greater than size\n");
return -1;
}
if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
return -1;
}
s->mv_precision = svq3_get_ue_golomb(gb);
if (s->mv_precision > 3) {
av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
return -1;
}
s->globalmc_flag = get_bits1(gb);
if (s->globalmc_flag) {
memset(s->globalmc, 0, sizeof(s->globalmc));
for (ref = 0; ref < s->num_refs; ref++) {
if (get_bits1(gb)) {
s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
}
if (get_bits1(gb)) {
s->globalmc[ref].zrs_exp = svq3_get_ue_golomb(gb);
s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
} else {
s->globalmc[ref].zrs[0][0] = 1;
s->globalmc[ref].zrs[1][1] = 1;
}
if (get_bits1(gb)) {
s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb);
s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb);
}
}
}
if (svq3_get_ue_golomb(gb)) {
av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
return -1;
}
s->weight_log2denom = 1;
s->weight[0] = 1;
s->weight[1] = 1;
if (get_bits1(gb)) {
s->weight_log2denom = svq3_get_ue_golomb(gb);
s->weight[0] = dirac_get_se_golomb(gb);
if (s->num_refs == 2)
s->weight[1] = dirac_get_se_golomb(gb);
}
return 0;
}
| {
"code": [
" if (s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) {"
],
"line_no": [
67
]
} | static int FUNC_0(DiracContext *VAR_0)
{
static const uint8_t VAR_1[] = { 4, 12, 16, 24 };
static const uint8_t VAR_2[] = { 4, 8, 12, 16 };
GetBitContext *gb = &VAR_0->gb;
unsigned VAR_3, VAR_4;
align_get_bits(gb);
VAR_3 = svq3_get_ue_golomb(gb);
if (VAR_3 > 4) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
return -1;
}
if (VAR_3 == 0) {
VAR_0->plane[0].xblen = svq3_get_ue_golomb(gb);
VAR_0->plane[0].yblen = svq3_get_ue_golomb(gb);
VAR_0->plane[0].xbsep = svq3_get_ue_golomb(gb);
VAR_0->plane[0].ybsep = svq3_get_ue_golomb(gb);
} else {
VAR_0->plane[0].xblen = VAR_1[VAR_3-1];
VAR_0->plane[0].yblen = VAR_1[VAR_3-1];
VAR_0->plane[0].xbsep = VAR_2[VAR_3-1];
VAR_0->plane[0].ybsep = VAR_2[VAR_3-1];
}
if (VAR_0->plane[0].xbsep < VAR_0->plane[0].xblen/2 || VAR_0->plane[0].ybsep < VAR_0->plane[0].yblen/2) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Block separation too small\n");
return -1;
}
if (VAR_0->plane[0].xbsep > VAR_0->plane[0].xblen || VAR_0->plane[0].ybsep > VAR_0->plane[0].yblen) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Block seperation greater than size\n");
return -1;
}
if (FFMAX(VAR_0->plane[0].xblen, VAR_0->plane[0].yblen) > MAX_BLOCKSIZE) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
return -1;
}
VAR_0->mv_precision = svq3_get_ue_golomb(gb);
if (VAR_0->mv_precision > 3) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
return -1;
}
VAR_0->globalmc_flag = get_bits1(gb);
if (VAR_0->globalmc_flag) {
memset(VAR_0->globalmc, 0, sizeof(VAR_0->globalmc));
for (VAR_4 = 0; VAR_4 < VAR_0->num_refs; VAR_4++) {
if (get_bits1(gb)) {
VAR_0->globalmc[VAR_4].pan_tilt[0] = dirac_get_se_golomb(gb);
VAR_0->globalmc[VAR_4].pan_tilt[1] = dirac_get_se_golomb(gb);
}
if (get_bits1(gb)) {
VAR_0->globalmc[VAR_4].zrs_exp = svq3_get_ue_golomb(gb);
VAR_0->globalmc[VAR_4].zrs[0][0] = dirac_get_se_golomb(gb);
VAR_0->globalmc[VAR_4].zrs[0][1] = dirac_get_se_golomb(gb);
VAR_0->globalmc[VAR_4].zrs[1][0] = dirac_get_se_golomb(gb);
VAR_0->globalmc[VAR_4].zrs[1][1] = dirac_get_se_golomb(gb);
} else {
VAR_0->globalmc[VAR_4].zrs[0][0] = 1;
VAR_0->globalmc[VAR_4].zrs[1][1] = 1;
}
if (get_bits1(gb)) {
VAR_0->globalmc[VAR_4].perspective_exp = svq3_get_ue_golomb(gb);
VAR_0->globalmc[VAR_4].perspective[0] = dirac_get_se_golomb(gb);
VAR_0->globalmc[VAR_4].perspective[1] = dirac_get_se_golomb(gb);
}
}
}
if (svq3_get_ue_golomb(gb)) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
return -1;
}
VAR_0->weight_log2denom = 1;
VAR_0->weight[0] = 1;
VAR_0->weight[1] = 1;
if (get_bits1(gb)) {
VAR_0->weight_log2denom = svq3_get_ue_golomb(gb);
VAR_0->weight[0] = dirac_get_se_golomb(gb);
if (VAR_0->num_refs == 2)
VAR_0->weight[1] = dirac_get_se_golomb(gb);
}
return 0;
}
| [
"static int FUNC_0(DiracContext *VAR_0)\n{",
"static const uint8_t VAR_1[] = { 4, 12, 16, 24 };",
"static const uint8_t VAR_2[] = { 4, 8, 12, 16 };",
"GetBitContext *gb = &VAR_0->gb;",
"unsigned VAR_3, VAR_4;",
"align_get_bits(gb);",
"VAR_3 = svq3_get_ue_golomb(gb);",
"if (VAR_3 > 4) {",
"av_log(VA... | [
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... | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55... |
15,591 | static int check_timecode(void *log_ctx, AVTimecode *tc)
{
if (tc->fps <= 0) {
av_log(log_ctx, AV_LOG_ERROR, "Timecode frame rate must be specified\n");
return AVERROR(EINVAL);
}
if ((tc->flags & AV_TIMECODE_FLAG_DROPFRAME) && tc->fps != 30 && tc->fps != 60) {
av_log(log_ctx, AV_LOG_ERROR, "Drop frame is only allowed with 30000/1001 or 60000/1001 FPS\n");
return AVERROR(EINVAL);
}
if (check_fps(tc->fps) < 0) {
av_log(log_ctx, AV_LOG_WARNING, "Using non-standard frame rate %d/%d\n",
tc->rate.num, tc->rate.den);
}
return 0;
}
| true | FFmpeg | b46dcd5209a77254345ae098b83a872634c5591b | static int check_timecode(void *log_ctx, AVTimecode *tc)
{
if (tc->fps <= 0) {
av_log(log_ctx, AV_LOG_ERROR, "Timecode frame rate must be specified\n");
return AVERROR(EINVAL);
}
if ((tc->flags & AV_TIMECODE_FLAG_DROPFRAME) && tc->fps != 30 && tc->fps != 60) {
av_log(log_ctx, AV_LOG_ERROR, "Drop frame is only allowed with 30000/1001 or 60000/1001 FPS\n");
return AVERROR(EINVAL);
}
if (check_fps(tc->fps) < 0) {
av_log(log_ctx, AV_LOG_WARNING, "Using non-standard frame rate %d/%d\n",
tc->rate.num, tc->rate.den);
}
return 0;
}
| {
"code": [
" if (tc->fps <= 0) {"
],
"line_no": [
5
]
} | static int FUNC_0(void *VAR_0, AVTimecode *VAR_1)
{
if (VAR_1->fps <= 0) {
av_log(VAR_0, AV_LOG_ERROR, "Timecode frame rate must be specified\n");
return AVERROR(EINVAL);
}
if ((VAR_1->flags & AV_TIMECODE_FLAG_DROPFRAME) && VAR_1->fps != 30 && VAR_1->fps != 60) {
av_log(VAR_0, AV_LOG_ERROR, "Drop frame is only allowed with 30000/1001 or 60000/1001 FPS\n");
return AVERROR(EINVAL);
}
if (check_fps(VAR_1->fps) < 0) {
av_log(VAR_0, AV_LOG_WARNING, "Using non-standard frame rate %d/%d\n",
VAR_1->rate.num, VAR_1->rate.den);
}
return 0;
}
| [
"static int FUNC_0(void *VAR_0, AVTimecode *VAR_1)\n{",
"if (VAR_1->fps <= 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Timecode frame rate must be specified\\n\");",
"return AVERROR(EINVAL);",
"}",
"if ((VAR_1->flags & AV_TIMECODE_FLAG_DROPFRAME) && VAR_1->fps != 30 && VAR_1->fps != 60) {",
"av_log(VAR_0, AV_... | [
0,
1,
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
]
] |
15,592 | static void RENAME(yuv2rgb555_1)(SwsContext *c, const int16_t *buf0,
const int16_t *ubuf[2], const int16_t *bguf[2],
const int16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, int y)
{
const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];
const int16_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
WRITERGB15(%%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
WRITERGB15(%%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)
);
}
}
| true | FFmpeg | 1bab6f852c7ca433285d19f65c701885fa69cc57 | static void RENAME(yuv2rgb555_1)(SwsContext *c, const int16_t *buf0,
const int16_t *ubuf[2], const int16_t *bguf[2],
const int16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, int y)
{
const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];
const int16_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
WRITERGB15(%%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
WRITERGB15(%%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": [
" const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];",
" const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];",
" const int16_t *ubuf[2], const int16_t *bguf[2],",
" const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];",
" const int16_t *ubuf[2], const int16_t *bguf[2],",
" const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];",
" const int16_t *ubuf0 = ubuf[0], *ubuf1 = ubuf[1];"
],
"line_no": [
11,
11,
3,
11,
3,
11,
11
]
} | static void FUNC_0(yuv2rgb555_1)(SwsContext *c, const int16_t *buf0,
const int16_t *ubuf[2], const int16_t *bguf[2],
const int16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, int y)
{
const int16_t *VAR_0 = ubuf[0], *ubuf1 = ubuf[1];
const int16_t *VAR_1= 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
WRITERGB15(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (VAR_1), "S" (VAR_0), "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
WRITERGB15(%%REGb, 8280(%5), %%REGBP)
"pop %%"REG_BP" \n\t"
"mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
:: "c" (buf0), "d" (VAR_1), "S" (VAR_0), "D" (ubuf1), "m" (dest),
"a" (&c->redDither)
);
}
}
| [
"static void FUNC_0(yuv2rgb555_1)(SwsContext *c, const int16_t *buf0,\nconst int16_t *ubuf[2], const int16_t *bguf[2],\nconst int16_t *abuf0, uint8_t *dest,\nint dstW, int uvalpha, int y)\n{",
"const int16_t *VAR_0 = ubuf[0], *ubuf1 = ubuf[1];",
"const int16_t *VAR_1= buf0;",
"if (uvalpha < 2048) {",
"__asm... | [
1,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
17
],
[
19,
21,
23,
25,
27,
29,
33,
35,
37,
39,
41,
43,
45,
47,
49,
51,
53
],
[
55
],
[
57,
59,
61,
63,
65,
67,
71,
73,... |
15,593 | static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubRegion *region = get_region(ctx, display->region_id);
const uint8_t *buf_end = buf + buf_size;
uint8_t *pbuf;
int x_pos, y_pos;
int i;
uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
uint8_t *map_table;
av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
top_bottom ? "bottom" : "top");
#ifdef DEBUG_PACKET_CONTENTS
for (i = 0; i < buf_size; i++) {
if (i % 16 == 0)
av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);
av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
if (i % 16 == 15)
av_log(avctx, AV_LOG_INFO, "\n");
}
if (i % 16)
av_log(avctx, AV_LOG_INFO, "\n");
#endif
if (region == 0)
return;
pbuf = region->pbuf;
x_pos = display->x_pos;
y_pos = display->y_pos;
if ((y_pos & 1) != top_bottom)
y_pos++;
while (buf < buf_end) {
if (x_pos > region->width || y_pos > region->height) {
av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
return;
}
switch (*buf++) {
case 0x10:
if (region->depth == 8)
map_table = map2to8;
else if (region->depth == 4)
map_table = map2to4;
else
map_table = NULL;
x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, map_table);
break;
case 0x11:
if (region->depth < 4) {
av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
return;
}
if (region->depth == 8)
map_table = map4to8;
else
map_table = NULL;
x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, map_table);
break;
case 0x12:
if (region->depth < 8) {
av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
return;
}
x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, NULL);
break;
case 0x20:
map2to4[0] = (*buf) >> 4;
map2to4[1] = (*buf++) & 0xf;
map2to4[2] = (*buf) >> 4;
map2to4[3] = (*buf++) & 0xf;
break;
case 0x21:
for (i = 0; i < 4; i++)
map2to8[i] = *buf++;
break;
case 0x22:
for (i = 0; i < 16; i++)
map4to8[i] = *buf++;
break;
case 0xf0:
x_pos = display->x_pos;
y_pos += 2;
break;
default:
av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
}
}
}
| true | FFmpeg | 52b2e95cd9f829b83b879a0694173d4ef1558c46 | static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,
const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubRegion *region = get_region(ctx, display->region_id);
const uint8_t *buf_end = buf + buf_size;
uint8_t *pbuf;
int x_pos, y_pos;
int i;
uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
uint8_t *map_table;
av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
top_bottom ? "bottom" : "top");
#ifdef DEBUG_PACKET_CONTENTS
for (i = 0; i < buf_size; i++) {
if (i % 16 == 0)
av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);
av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
if (i % 16 == 15)
av_log(avctx, AV_LOG_INFO, "\n");
}
if (i % 16)
av_log(avctx, AV_LOG_INFO, "\n");
#endif
if (region == 0)
return;
pbuf = region->pbuf;
x_pos = display->x_pos;
y_pos = display->y_pos;
if ((y_pos & 1) != top_bottom)
y_pos++;
while (buf < buf_end) {
if (x_pos > region->width || y_pos > region->height) {
av_log(avctx, AV_LOG_ERROR, "Invalid object location!\n");
return;
}
switch (*buf++) {
case 0x10:
if (region->depth == 8)
map_table = map2to8;
else if (region->depth == 4)
map_table = map2to4;
else
map_table = NULL;
x_pos += dvbsub_read_2bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, map_table);
break;
case 0x11:
if (region->depth < 4) {
av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
return;
}
if (region->depth == 8)
map_table = map4to8;
else
map_table = NULL;
x_pos += dvbsub_read_4bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, map_table);
break;
case 0x12:
if (region->depth < 8) {
av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
return;
}
x_pos += dvbsub_read_8bit_string(pbuf + (y_pos * region->width) + x_pos,
region->width - x_pos, &buf, buf_size,
non_mod, NULL);
break;
case 0x20:
map2to4[0] = (*buf) >> 4;
map2to4[1] = (*buf++) & 0xf;
map2to4[2] = (*buf) >> 4;
map2to4[3] = (*buf++) & 0xf;
break;
case 0x21:
for (i = 0; i < 4; i++)
map2to8[i] = *buf++;
break;
case 0x22:
for (i = 0; i < 16; i++)
map4to8[i] = *buf++;
break;
case 0xf0:
x_pos = display->x_pos;
y_pos += 2;
break;
default:
av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
}
}
}
| {
"code": [
" region->width - x_pos, &buf, buf_size,",
" region->width - x_pos, &buf, buf_size,",
" region->width - x_pos, &buf, buf_size,"
],
"line_no": [
125,
125,
125
]
} | static void FUNC_0(AVCodecContext *VAR_0, DVBSubObjectDisplay *VAR_1,
const uint8_t *VAR_2, int VAR_3, int VAR_4, int VAR_5)
{
DVBSubContext *ctx = VAR_0->priv_data;
DVBSubRegion *region = get_region(ctx, VAR_1->region_id);
const uint8_t *VAR_6 = VAR_2 + VAR_3;
uint8_t *pbuf;
int VAR_7, VAR_8;
int VAR_9;
uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
uint8_t *map_table;
av_dlog(VAR_0, "DVB pixel block size %d, %s field:\n", VAR_3,
VAR_4 ? "bottom" : "top");
#ifdef DEBUG_PACKET_CONTENTS
for (VAR_9 = 0; VAR_9 < VAR_3; VAR_9++) {
if (VAR_9 % 16 == 0)
av_log(VAR_0, AV_LOG_INFO, "0x%08p: ", VAR_2+VAR_9);
av_log(VAR_0, AV_LOG_INFO, "%02x ", VAR_2[VAR_9]);
if (VAR_9 % 16 == 15)
av_log(VAR_0, AV_LOG_INFO, "\n");
}
if (VAR_9 % 16)
av_log(VAR_0, AV_LOG_INFO, "\n");
#endif
if (region == 0)
return;
pbuf = region->pbuf;
VAR_7 = VAR_1->VAR_7;
VAR_8 = VAR_1->VAR_8;
if ((VAR_8 & 1) != VAR_4)
VAR_8++;
while (VAR_2 < VAR_6) {
if (VAR_7 > region->width || VAR_8 > region->height) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid object location!\n");
return;
}
switch (*VAR_2++) {
case 0x10:
if (region->depth == 8)
map_table = map2to8;
else if (region->depth == 4)
map_table = map2to4;
else
map_table = NULL;
VAR_7 += dvbsub_read_2bit_string(pbuf + (VAR_8 * region->width) + VAR_7,
region->width - VAR_7, &VAR_2, VAR_3,
VAR_5, map_table);
break;
case 0x11:
if (region->depth < 4) {
av_log(VAR_0, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
return;
}
if (region->depth == 8)
map_table = map4to8;
else
map_table = NULL;
VAR_7 += dvbsub_read_4bit_string(pbuf + (VAR_8 * region->width) + VAR_7,
region->width - VAR_7, &VAR_2, VAR_3,
VAR_5, map_table);
break;
case 0x12:
if (region->depth < 8) {
av_log(VAR_0, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
return;
}
VAR_7 += dvbsub_read_8bit_string(pbuf + (VAR_8 * region->width) + VAR_7,
region->width - VAR_7, &VAR_2, VAR_3,
VAR_5, NULL);
break;
case 0x20:
map2to4[0] = (*VAR_2) >> 4;
map2to4[1] = (*VAR_2++) & 0xf;
map2to4[2] = (*VAR_2) >> 4;
map2to4[3] = (*VAR_2++) & 0xf;
break;
case 0x21:
for (VAR_9 = 0; VAR_9 < 4; VAR_9++)
map2to8[VAR_9] = *VAR_2++;
break;
case 0x22:
for (VAR_9 = 0; VAR_9 < 16; VAR_9++)
map4to8[VAR_9] = *VAR_2++;
break;
case 0xf0:
VAR_7 = VAR_1->VAR_7;
VAR_8 += 2;
break;
default:
av_log(VAR_0, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(VAR_2-1));
}
}
}
| [
"static void FUNC_0(AVCodecContext *VAR_0, DVBSubObjectDisplay *VAR_1,\nconst uint8_t *VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{",
"DVBSubContext *ctx = VAR_0->priv_data;",
"DVBSubRegion *region = get_region(ctx, VAR_1->region_id);",
"const uint8_t *VAR_6 = VAR_2 + VAR_3;",
"uint8_t *pbuf;",
"int VAR_7, ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35,
37
],
[
41,
43
],
[
45,
47
],
[
51
],
[
53,
55
],
... |
15,595 | static inline void gen_op_sdivx(TCGv dst, TCGv src1, TCGv src2)
{
int l1, l2;
l1 = gen_new_label();
l2 = gen_new_label();
tcg_gen_mov_tl(cpu_cc_src, src1);
tcg_gen_mov_tl(cpu_cc_src2, src2);
gen_trap_ifdivzero_tl(cpu_cc_src2);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src, INT64_MIN, l1);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src2, -1, l1);
tcg_gen_movi_i64(dst, INT64_MIN);
tcg_gen_br(l2);
gen_set_label(l1);
tcg_gen_div_i64(dst, cpu_cc_src, cpu_cc_src2);
gen_set_label(l2);
}
| true | qemu | 8e91ed308062e742610e4cfdfd4a09bc045ead45 | static inline void gen_op_sdivx(TCGv dst, TCGv src1, TCGv src2)
{
int l1, l2;
l1 = gen_new_label();
l2 = gen_new_label();
tcg_gen_mov_tl(cpu_cc_src, src1);
tcg_gen_mov_tl(cpu_cc_src2, src2);
gen_trap_ifdivzero_tl(cpu_cc_src2);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src, INT64_MIN, l1);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src2, -1, l1);
tcg_gen_movi_i64(dst, INT64_MIN);
tcg_gen_br(l2);
gen_set_label(l1);
tcg_gen_div_i64(dst, cpu_cc_src, cpu_cc_src2);
gen_set_label(l2);
}
| {
"code": [
" tcg_gen_mov_tl(cpu_cc_src, src1);",
" tcg_gen_mov_tl(cpu_cc_src2, src2);",
" gen_trap_ifdivzero_tl(cpu_cc_src2);",
" tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src, INT64_MIN, l1);",
" tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src2, -1, l1);",
" tcg_gen_div_i64(dst, cpu_cc_src, cpu_cc_src2);"
],
"line_no": [
13,
15,
17,
19,
21,
29
]
} | static inline void FUNC_0(TCGv VAR_0, TCGv VAR_1, TCGv VAR_2)
{
int VAR_3, VAR_4;
VAR_3 = gen_new_label();
VAR_4 = gen_new_label();
tcg_gen_mov_tl(cpu_cc_src, VAR_1);
tcg_gen_mov_tl(cpu_cc_src2, VAR_2);
gen_trap_ifdivzero_tl(cpu_cc_src2);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src, INT64_MIN, VAR_3);
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_src2, -1, VAR_3);
tcg_gen_movi_i64(VAR_0, INT64_MIN);
tcg_gen_br(VAR_4);
gen_set_label(VAR_3);
tcg_gen_div_i64(VAR_0, cpu_cc_src, cpu_cc_src2);
gen_set_label(VAR_4);
}
| [
"static inline void FUNC_0(TCGv VAR_0, TCGv VAR_1, TCGv VAR_2)\n{",
"int VAR_3, VAR_4;",
"VAR_3 = gen_new_label();",
"VAR_4 = gen_new_label();",
"tcg_gen_mov_tl(cpu_cc_src, VAR_1);",
"tcg_gen_mov_tl(cpu_cc_src2, VAR_2);",
"gen_trap_ifdivzero_tl(cpu_cc_src2);",
"tcg_gen_brcondi_tl(TCG_COND_NE, cpu_cc_s... | [
0,
0,
0,
0,
1,
1,
1,
1,
1,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
15,596 | static void iterative_me(SnowContext *s){
int pass, mb_x, mb_y;
const int b_width = s->b_width << s->block_max_depth;
const int b_height= s->b_height << s->block_max_depth;
const int b_stride= b_width;
int color[3];
for(pass=0; pass<50; pass++){
int change= 0;
for(mb_y= 0; mb_y<b_height; mb_y++){
for(mb_x= 0; mb_x<b_width; mb_x++){
int dia_change, i, j;
int best_rd= INT_MAX;
BlockNode backup;
const int index= mb_x + mb_y * b_stride;
BlockNode *block= &s->block[index];
BlockNode *tb = mb_y ? &s->block[index-b_stride ] : &null_block;
BlockNode *lb = mb_x ? &s->block[index -1] : &null_block;
BlockNode *rb = mb_x<b_width ? &s->block[index +1] : &null_block;
BlockNode *bb = mb_y<b_height ? &s->block[index+b_stride ] : &null_block;
BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : &null_block;
BlockNode *trb= mb_x<b_width && mb_y ? &s->block[index-b_stride+1] : &null_block;
BlockNode *blb= mb_x && mb_y<b_height ? &s->block[index+b_stride-1] : &null_block;
BlockNode *brb= mb_x<b_width && mb_y<b_height ? &s->block[index+b_stride+1] : &null_block;
if(pass && (block->type & BLOCK_OPT))
continue;
block->type |= BLOCK_OPT;
backup= *block;
if(!s->me_cache_generation)
memset(s->me_cache, 0, sizeof(s->me_cache));
s->me_cache_generation += 1<<22;
// get previous score (cant be cached due to OBMC)
check_block(s, mb_x, mb_y, (int[2]){block->mx, block->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){0, 0}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){tb->mx, tb->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){lb->mx, lb->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){rb->mx, rb->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){bb->mx, bb->my}, 0, &best_rd);
/* fullpel ME */
//FIXME avoid subpel interpol / round to nearest integer
do{
dia_change=0;
for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
for(j=0; j<i; j++){
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+4*(i-j), block->my+(4*j)}, 0, &best_rd);
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx-4*(i-j), block->my-(4*j)}, 0, &best_rd);
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+4*(i-j), block->my-(4*j)}, 0, &best_rd);
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx-4*(i-j), block->my+(4*j)}, 0, &best_rd);
}
}
}while(dia_change);
/* subpel ME */
do{
static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
dia_change=0;
for(i=0; i<8; i++)
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+square[i][0], block->my+square[i][1]}, 0, &best_rd);
}while(dia_change);
//FIXME or try the standard 2 pass qpel or similar
for(i=0; i<3; i++){
color[i]= get_dc(s, mb_x, mb_y, i);
}
check_block(s, mb_x, mb_y, color, 1, &best_rd);
//FIXME RD style color selection
if(!same_block(block, &backup)){
if(tb != &null_block) tb ->type &= ~BLOCK_OPT;
if(lb != &null_block) lb ->type &= ~BLOCK_OPT;
if(rb != &null_block) rb ->type &= ~BLOCK_OPT;
if(bb != &null_block) bb ->type &= ~BLOCK_OPT;
if(tlb!= &null_block) tlb->type &= ~BLOCK_OPT;
if(trb!= &null_block) trb->type &= ~BLOCK_OPT;
if(blb!= &null_block) blb->type &= ~BLOCK_OPT;
if(brb!= &null_block) brb->type &= ~BLOCK_OPT;
change ++;
}
}
}
av_log(NULL, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);
if(!change)
break;
}
}
| true | FFmpeg | 13705b69ebe9e375fdb52469760a0fbb5f593cc1 | static void iterative_me(SnowContext *s){
int pass, mb_x, mb_y;
const int b_width = s->b_width << s->block_max_depth;
const int b_height= s->b_height << s->block_max_depth;
const int b_stride= b_width;
int color[3];
for(pass=0; pass<50; pass++){
int change= 0;
for(mb_y= 0; mb_y<b_height; mb_y++){
for(mb_x= 0; mb_x<b_width; mb_x++){
int dia_change, i, j;
int best_rd= INT_MAX;
BlockNode backup;
const int index= mb_x + mb_y * b_stride;
BlockNode *block= &s->block[index];
BlockNode *tb = mb_y ? &s->block[index-b_stride ] : &null_block;
BlockNode *lb = mb_x ? &s->block[index -1] : &null_block;
BlockNode *rb = mb_x<b_width ? &s->block[index +1] : &null_block;
BlockNode *bb = mb_y<b_height ? &s->block[index+b_stride ] : &null_block;
BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : &null_block;
BlockNode *trb= mb_x<b_width && mb_y ? &s->block[index-b_stride+1] : &null_block;
BlockNode *blb= mb_x && mb_y<b_height ? &s->block[index+b_stride-1] : &null_block;
BlockNode *brb= mb_x<b_width && mb_y<b_height ? &s->block[index+b_stride+1] : &null_block;
if(pass && (block->type & BLOCK_OPT))
continue;
block->type |= BLOCK_OPT;
backup= *block;
if(!s->me_cache_generation)
memset(s->me_cache, 0, sizeof(s->me_cache));
s->me_cache_generation += 1<<22;
check_block(s, mb_x, mb_y, (int[2]){block->mx, block->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){0, 0}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){tb->mx, tb->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){lb->mx, lb->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){rb->mx, rb->my}, 0, &best_rd);
check_block(s, mb_x, mb_y, (int[2]){bb->mx, bb->my}, 0, &best_rd);
do{
dia_change=0;
for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
for(j=0; j<i; j++){
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+4*(i-j), block->my+(4*j)}, 0, &best_rd);
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx-4*(i-j), block->my-(4*j)}, 0, &best_rd);
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+4*(i-j), block->my-(4*j)}, 0, &best_rd);
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx-4*(i-j), block->my+(4*j)}, 0, &best_rd);
}
}
}while(dia_change);
do{
static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
dia_change=0;
for(i=0; i<8; i++)
dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+square[i][0], block->my+square[i][1]}, 0, &best_rd);
}while(dia_change);
for(i=0; i<3; i++){
color[i]= get_dc(s, mb_x, mb_y, i);
}
check_block(s, mb_x, mb_y, color, 1, &best_rd);
if(!same_block(block, &backup)){
if(tb != &null_block) tb ->type &= ~BLOCK_OPT;
if(lb != &null_block) lb ->type &= ~BLOCK_OPT;
if(rb != &null_block) rb ->type &= ~BLOCK_OPT;
if(bb != &null_block) bb ->type &= ~BLOCK_OPT;
if(tlb!= &null_block) tlb->type &= ~BLOCK_OPT;
if(trb!= &null_block) trb->type &= ~BLOCK_OPT;
if(blb!= &null_block) blb->type &= ~BLOCK_OPT;
if(brb!= &null_block) brb->type &= ~BLOCK_OPT;
change ++;
}
}
}
av_log(NULL, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);
if(!change)
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(SnowContext *VAR_0){
int VAR_1, VAR_2, VAR_3;
const int VAR_4 = VAR_0->VAR_4 << VAR_0->block_max_depth;
const int VAR_5= VAR_0->VAR_5 << VAR_0->block_max_depth;
const int VAR_6= VAR_4;
int VAR_7[3];
for(VAR_1=0; VAR_1<50; VAR_1++){
int VAR_8= 0;
for(VAR_3= 0; VAR_3<VAR_5; VAR_3++){
for(VAR_2= 0; VAR_2<VAR_4; VAR_2++){
int VAR_9, VAR_10, VAR_11;
int VAR_12= INT_MAX;
BlockNode backup;
const int VAR_13= VAR_2 + VAR_3 * VAR_6;
BlockNode *block= &VAR_0->block[VAR_13];
BlockNode *tb = VAR_3 ? &VAR_0->block[VAR_13-VAR_6 ] : &null_block;
BlockNode *lb = VAR_2 ? &VAR_0->block[VAR_13 -1] : &null_block;
BlockNode *rb = VAR_2<VAR_4 ? &VAR_0->block[VAR_13 +1] : &null_block;
BlockNode *bb = VAR_3<VAR_5 ? &VAR_0->block[VAR_13+VAR_6 ] : &null_block;
BlockNode *tlb= VAR_2 && VAR_3 ? &VAR_0->block[VAR_13-VAR_6-1] : &null_block;
BlockNode *trb= VAR_2<VAR_4 && VAR_3 ? &VAR_0->block[VAR_13-VAR_6+1] : &null_block;
BlockNode *blb= VAR_2 && VAR_3<VAR_5 ? &VAR_0->block[VAR_13+VAR_6-1] : &null_block;
BlockNode *brb= VAR_2<VAR_4 && VAR_3<VAR_5 ? &VAR_0->block[VAR_13+VAR_6+1] : &null_block;
if(VAR_1 && (block->type & BLOCK_OPT))
continue;
block->type |= BLOCK_OPT;
backup= *block;
if(!VAR_0->me_cache_generation)
memset(VAR_0->me_cache, 0, sizeof(VAR_0->me_cache));
VAR_0->me_cache_generation += 1<<22;
check_block(VAR_0, VAR_2, VAR_3, (int[2]){block->mx, block->my}, 0, &VAR_12);
check_block(VAR_0, VAR_2, VAR_3, (int[2]){0, 0}, 0, &VAR_12);
check_block(VAR_0, VAR_2, VAR_3, (int[2]){tb->mx, tb->my}, 0, &VAR_12);
check_block(VAR_0, VAR_2, VAR_3, (int[2]){lb->mx, lb->my}, 0, &VAR_12);
check_block(VAR_0, VAR_2, VAR_3, (int[2]){rb->mx, rb->my}, 0, &VAR_12);
check_block(VAR_0, VAR_2, VAR_3, (int[2]){bb->mx, bb->my}, 0, &VAR_12);
do{
VAR_9=0;
for(VAR_10=0; VAR_10<FFMAX(VAR_0->avctx->dia_size, 1); VAR_10++){
for(VAR_11=0; VAR_11<VAR_10; VAR_11++){
VAR_9 |= check_block(VAR_0, VAR_2, VAR_3, (int[2]){block->mx+4*(VAR_10-VAR_11), block->my+(4*VAR_11)}, 0, &VAR_12);
VAR_9 |= check_block(VAR_0, VAR_2, VAR_3, (int[2]){block->mx-4*(VAR_10-VAR_11), block->my-(4*VAR_11)}, 0, &VAR_12);
VAR_9 |= check_block(VAR_0, VAR_2, VAR_3, (int[2]){block->mx+4*(VAR_10-VAR_11), block->my-(4*VAR_11)}, 0, &VAR_12);
VAR_9 |= check_block(VAR_0, VAR_2, VAR_3, (int[2]){block->mx-4*(VAR_10-VAR_11), block->my+(4*VAR_11)}, 0, &VAR_12);
}
}
}while(VAR_9);
do{
static const int VAR_14[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
VAR_9=0;
for(VAR_10=0; VAR_10<8; VAR_10++)
VAR_9 |= check_block(VAR_0, VAR_2, VAR_3, (int[2]){block->mx+VAR_14[VAR_10][0], block->my+VAR_14[VAR_10][1]}, 0, &VAR_12);
}while(VAR_9);
for(VAR_10=0; VAR_10<3; VAR_10++){
VAR_7[VAR_10]= get_dc(VAR_0, VAR_2, VAR_3, VAR_10);
}
check_block(VAR_0, VAR_2, VAR_3, VAR_7, 1, &VAR_12);
if(!same_block(block, &backup)){
if(tb != &null_block) tb ->type &= ~BLOCK_OPT;
if(lb != &null_block) lb ->type &= ~BLOCK_OPT;
if(rb != &null_block) rb ->type &= ~BLOCK_OPT;
if(bb != &null_block) bb ->type &= ~BLOCK_OPT;
if(tlb!= &null_block) tlb->type &= ~BLOCK_OPT;
if(trb!= &null_block) trb->type &= ~BLOCK_OPT;
if(blb!= &null_block) blb->type &= ~BLOCK_OPT;
if(brb!= &null_block) brb->type &= ~BLOCK_OPT;
VAR_8 ++;
}
}
}
av_log(NULL, AV_LOG_ERROR, "VAR_1:%d changed:%d\n", VAR_1, VAR_8);
if(!VAR_8)
break;
}
}
| [
"static void FUNC_0(SnowContext *VAR_0){",
"int VAR_1, VAR_2, VAR_3;",
"const int VAR_4 = VAR_0->VAR_4 << VAR_0->block_max_depth;",
"const int VAR_5= VAR_0->VAR_5 << VAR_0->block_max_depth;",
"const int VAR_6= VAR_4;",
"int VAR_7[3];",
"for(VAR_1=0; VAR_1<50; VAR_1++){",
"int VAR_8= 0;",
"for(VAR_3... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[... |
15,597 | static void coroutine_fn v9fs_xattrcreate(void *opaque)
{
int flags;
int32_t fid;
int64_t size;
ssize_t err = 0;
V9fsString name;
size_t offset = 7;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp;
V9fsPDU *pdu = opaque;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags);
if (err < 0) {
goto out_nofid;
}
trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags);
file_fidp = get_fid(pdu, fid);
if (file_fidp == NULL) {
err = -EINVAL;
goto out_nofid;
}
/* Make the file fid point to xattr */
xattr_fidp = file_fidp;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = 0;
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fs.xattr.flags = flags;
v9fs_string_init(&xattr_fidp->fs.xattr.name);
v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
xattr_fidp->fs.xattr.value = g_malloc(size);
err = offset;
put_fid(pdu, file_fidp);
out_nofid:
pdu_complete(pdu, err);
v9fs_string_free(&name);
}
| true | qemu | eb687602853b4ae656e9236ee4222609f3a6887d | static void coroutine_fn v9fs_xattrcreate(void *opaque)
{
int flags;
int32_t fid;
int64_t size;
ssize_t err = 0;
V9fsString name;
size_t offset = 7;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp;
V9fsPDU *pdu = opaque;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags);
if (err < 0) {
goto out_nofid;
}
trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags);
file_fidp = get_fid(pdu, fid);
if (file_fidp == NULL) {
err = -EINVAL;
goto out_nofid;
}
xattr_fidp = file_fidp;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = 0;
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fs.xattr.flags = flags;
v9fs_string_init(&xattr_fidp->fs.xattr.name);
v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
xattr_fidp->fs.xattr.value = g_malloc(size);
err = offset;
put_fid(pdu, file_fidp);
out_nofid:
pdu_complete(pdu, err);
v9fs_string_free(&name);
}
| {
"code": [
" xattr_fidp->fs.xattr.value = g_malloc(size);"
],
"line_no": [
65
]
} | static void VAR_0 v9fs_xattrcreate(void *opaque)
{
int flags;
int32_t fid;
int64_t size;
ssize_t err = 0;
V9fsString name;
size_t offset = 7;
V9fsFidState *file_fidp;
V9fsFidState *xattr_fidp;
V9fsPDU *pdu = opaque;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags);
if (err < 0) {
goto out_nofid;
}
trace_v9fs_xattrcreate(pdu->tag, pdu->id, fid, name.data, size, flags);
file_fidp = get_fid(pdu, fid);
if (file_fidp == NULL) {
err = -EINVAL;
goto out_nofid;
}
xattr_fidp = file_fidp;
xattr_fidp->fid_type = P9_FID_XATTR;
xattr_fidp->fs.xattr.copied_len = 0;
xattr_fidp->fs.xattr.len = size;
xattr_fidp->fs.xattr.flags = flags;
v9fs_string_init(&xattr_fidp->fs.xattr.name);
v9fs_string_copy(&xattr_fidp->fs.xattr.name, &name);
xattr_fidp->fs.xattr.value = g_malloc(size);
err = offset;
put_fid(pdu, file_fidp);
out_nofid:
pdu_complete(pdu, err);
v9fs_string_free(&name);
}
| [
"static void VAR_0 v9fs_xattrcreate(void *opaque)\n{",
"int flags;",
"int32_t fid;",
"int64_t size;",
"ssize_t err = 0;",
"V9fsString name;",
"size_t offset = 7;",
"V9fsFidState *file_fidp;",
"V9fsFidState *xattr_fidp;",
"V9fsPDU *pdu = opaque;",
"v9fs_string_init(&name);",
"err = pdu_unmarsha... | [
0,
0,
0,
0,
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
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
... |
15,598 | static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
int size, int64_t pos, uint64_t cluster_time,
uint64_t block_duration, int is_keyframe,
uint8_t *additional, uint64_t additional_id, int additional_size,
int64_t cluster_pos, int64_t discard_padding)
{
uint64_t timecode = AV_NOPTS_VALUE;
MatroskaTrack *track;
int res = 0;
AVStream *st;
int16_t block_time;
uint32_t *lace_size = NULL;
int n, flags, laces = 0;
uint64_t num;
int trust_default_duration = 1;
if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
return n;
}
data += n;
size -= n;
track = matroska_find_track_by_num(matroska, num);
if (!track || !track->stream) {
av_log(matroska->ctx, AV_LOG_INFO,
"Invalid stream %"PRIu64" or size %u\n", num, size);
return AVERROR_INVALIDDATA;
} else if (size <= 3)
return 0;
st = track->stream;
if (st->discard >= AVDISCARD_ALL)
return res;
av_assert1(block_duration != AV_NOPTS_VALUE);
block_time = sign_extend(AV_RB16(data), 16);
data += 2;
flags = *data++;
size -= 3;
if (is_keyframe == -1)
is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
if (cluster_time != (uint64_t) -1 &&
(block_time >= 0 || cluster_time >= -block_time)) {
timecode = cluster_time + block_time - track->codec_delay_in_track_tb;
if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
timecode < track->end_timecode)
is_keyframe = 0; /* overlapping subtitles are not key frame */
if (is_keyframe)
av_add_index_entry(st, cluster_pos, timecode, 0, 0,
AVINDEX_KEYFRAME);
}
if (matroska->skip_to_keyframe &&
track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
if (timecode < matroska->skip_to_timecode)
return res;
if (is_keyframe)
matroska->skip_to_keyframe = 0;
else if (!st->skip_to_keyframe) {
av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
matroska->skip_to_keyframe = 0;
}
}
res = matroska_parse_laces(matroska, &data, &size, (flags & 0x06) >> 1,
&lace_size, &laces);
if (res)
goto end;
if (track->audio.samplerate == 8000) {
// If this is needed for more codecs, then add them here
if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
if (track->audio.samplerate != st->codecpar->sample_rate || !st->codecpar->frame_size)
trust_default_duration = 0;
}
}
if (!block_duration && trust_default_duration)
block_duration = track->default_duration * laces / matroska->time_scale;
if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
track->end_timecode =
FFMAX(track->end_timecode, timecode + block_duration);
for (n = 0; n < laces; n++) {
int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
if (lace_size[n] > size) {
av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
break;
}
if ((st->codecpar->codec_id == AV_CODEC_ID_RA_288 ||
st->codecpar->codec_id == AV_CODEC_ID_COOK ||
st->codecpar->codec_id == AV_CODEC_ID_SIPR ||
st->codecpar->codec_id == AV_CODEC_ID_ATRAC3) &&
st->codecpar->block_align && track->audio.sub_packet_size) {
res = matroska_parse_rm_audio(matroska, track, st, data,
lace_size[n],
timecode, pos);
if (res)
goto end;
} else if (st->codecpar->codec_id == AV_CODEC_ID_WEBVTT) {
res = matroska_parse_webvtt(matroska, track, st,
data, lace_size[n],
timecode, lace_duration,
pos);
if (res)
goto end;
} else {
res = matroska_parse_frame(matroska, track, st, data, lace_size[n],
timecode, lace_duration, pos,
!n ? is_keyframe : 0,
additional, additional_id, additional_size,
discard_padding);
if (res)
goto end;
}
if (timecode != AV_NOPTS_VALUE)
timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
data += lace_size[n];
size -= lace_size[n];
}
end:
av_free(lace_size);
return res;
}
| true | FFmpeg | d59820f6fec3fd112436fb7712e4f9d6d768b664 | static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
int size, int64_t pos, uint64_t cluster_time,
uint64_t block_duration, int is_keyframe,
uint8_t *additional, uint64_t additional_id, int additional_size,
int64_t cluster_pos, int64_t discard_padding)
{
uint64_t timecode = AV_NOPTS_VALUE;
MatroskaTrack *track;
int res = 0;
AVStream *st;
int16_t block_time;
uint32_t *lace_size = NULL;
int n, flags, laces = 0;
uint64_t num;
int trust_default_duration = 1;
if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
return n;
}
data += n;
size -= n;
track = matroska_find_track_by_num(matroska, num);
if (!track || !track->stream) {
av_log(matroska->ctx, AV_LOG_INFO,
"Invalid stream %"PRIu64" or size %u\n", num, size);
return AVERROR_INVALIDDATA;
} else if (size <= 3)
return 0;
st = track->stream;
if (st->discard >= AVDISCARD_ALL)
return res;
av_assert1(block_duration != AV_NOPTS_VALUE);
block_time = sign_extend(AV_RB16(data), 16);
data += 2;
flags = *data++;
size -= 3;
if (is_keyframe == -1)
is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
if (cluster_time != (uint64_t) -1 &&
(block_time >= 0 || cluster_time >= -block_time)) {
timecode = cluster_time + block_time - track->codec_delay_in_track_tb;
if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
timecode < track->end_timecode)
is_keyframe = 0;
if (is_keyframe)
av_add_index_entry(st, cluster_pos, timecode, 0, 0,
AVINDEX_KEYFRAME);
}
if (matroska->skip_to_keyframe &&
track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
if (timecode < matroska->skip_to_timecode)
return res;
if (is_keyframe)
matroska->skip_to_keyframe = 0;
else if (!st->skip_to_keyframe) {
av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
matroska->skip_to_keyframe = 0;
}
}
res = matroska_parse_laces(matroska, &data, &size, (flags & 0x06) >> 1,
&lace_size, &laces);
if (res)
goto end;
if (track->audio.samplerate == 8000) {
if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
if (track->audio.samplerate != st->codecpar->sample_rate || !st->codecpar->frame_size)
trust_default_duration = 0;
}
}
if (!block_duration && trust_default_duration)
block_duration = track->default_duration * laces / matroska->time_scale;
if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
track->end_timecode =
FFMAX(track->end_timecode, timecode + block_duration);
for (n = 0; n < laces; n++) {
int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
if (lace_size[n] > size) {
av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
break;
}
if ((st->codecpar->codec_id == AV_CODEC_ID_RA_288 ||
st->codecpar->codec_id == AV_CODEC_ID_COOK ||
st->codecpar->codec_id == AV_CODEC_ID_SIPR ||
st->codecpar->codec_id == AV_CODEC_ID_ATRAC3) &&
st->codecpar->block_align && track->audio.sub_packet_size) {
res = matroska_parse_rm_audio(matroska, track, st, data,
lace_size[n],
timecode, pos);
if (res)
goto end;
} else if (st->codecpar->codec_id == AV_CODEC_ID_WEBVTT) {
res = matroska_parse_webvtt(matroska, track, st,
data, lace_size[n],
timecode, lace_duration,
pos);
if (res)
goto end;
} else {
res = matroska_parse_frame(matroska, track, st, data, lace_size[n],
timecode, lace_duration, pos,
!n ? is_keyframe : 0,
additional, additional_id, additional_size,
discard_padding);
if (res)
goto end;
}
if (timecode != AV_NOPTS_VALUE)
timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
data += lace_size[n];
size -= lace_size[n];
}
end:
av_free(lace_size);
return res;
}
| {
"code": [
" if (timecode < matroska->skip_to_timecode)"
],
"line_no": [
111
]
} | static int FUNC_0(MatroskaDemuxContext *VAR_0, uint8_t *VAR_1,
int VAR_2, int64_t VAR_3, uint64_t VAR_4,
uint64_t VAR_5, int VAR_6,
uint8_t *VAR_7, uint64_t VAR_8, int VAR_9,
int64_t VAR_10, int64_t VAR_11)
{
uint64_t timecode = AV_NOPTS_VALUE;
MatroskaTrack *track;
int VAR_12 = 0;
AVStream *st;
int16_t block_time;
uint32_t *lace_size = NULL;
int VAR_13, VAR_14, VAR_15 = 0;
uint64_t num;
int VAR_16 = 1;
if ((VAR_13 = matroska_ebmlnum_uint(VAR_0, VAR_1, VAR_2, &num)) < 0) {
av_log(VAR_0->ctx, AV_LOG_ERROR, "EBML block VAR_1 error\VAR_13");
return VAR_13;
}
VAR_1 += VAR_13;
VAR_2 -= VAR_13;
track = matroska_find_track_by_num(VAR_0, num);
if (!track || !track->stream) {
av_log(VAR_0->ctx, AV_LOG_INFO,
"Invalid stream %"PRIu64" or VAR_2 %u\VAR_13", num, VAR_2);
return AVERROR_INVALIDDATA;
} else if (VAR_2 <= 3)
return 0;
st = track->stream;
if (st->discard >= AVDISCARD_ALL)
return VAR_12;
av_assert1(VAR_5 != AV_NOPTS_VALUE);
block_time = sign_extend(AV_RB16(VAR_1), 16);
VAR_1 += 2;
VAR_14 = *VAR_1++;
VAR_2 -= 3;
if (VAR_6 == -1)
VAR_6 = VAR_14 & 0x80 ? AV_PKT_FLAG_KEY : 0;
if (VAR_4 != (uint64_t) -1 &&
(block_time >= 0 || VAR_4 >= -block_time)) {
timecode = VAR_4 + block_time - track->codec_delay_in_track_tb;
if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
timecode < track->end_timecode)
VAR_6 = 0;
if (VAR_6)
av_add_index_entry(st, VAR_10, timecode, 0, 0,
AVINDEX_KEYFRAME);
}
if (VAR_0->skip_to_keyframe &&
track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
if (timecode < VAR_0->skip_to_timecode)
return VAR_12;
if (VAR_6)
VAR_0->skip_to_keyframe = 0;
else if (!st->skip_to_keyframe) {
av_log(VAR_0->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\VAR_13");
VAR_0->skip_to_keyframe = 0;
}
}
VAR_12 = matroska_parse_laces(VAR_0, &VAR_1, &VAR_2, (VAR_14 & 0x06) >> 1,
&lace_size, &VAR_15);
if (VAR_12)
goto end;
if (track->audio.samplerate == 8000) {
if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
if (track->audio.samplerate != st->codecpar->sample_rate || !st->codecpar->frame_size)
VAR_16 = 0;
}
}
if (!VAR_5 && VAR_16)
VAR_5 = track->default_duration * VAR_15 / VAR_0->time_scale;
if (VAR_4 != (uint64_t)-1 && (block_time >= 0 || VAR_4 >= -block_time))
track->end_timecode =
FFMAX(track->end_timecode, timecode + VAR_5);
for (VAR_13 = 0; VAR_13 < VAR_15; VAR_13++) {
int64_t lace_duration = VAR_5*(VAR_13+1) / VAR_15 - VAR_5*VAR_13 / VAR_15;
if (lace_size[VAR_13] > VAR_2) {
av_log(VAR_0->ctx, AV_LOG_ERROR, "Invalid packet VAR_2\VAR_13");
break;
}
if ((st->codecpar->codec_id == AV_CODEC_ID_RA_288 ||
st->codecpar->codec_id == AV_CODEC_ID_COOK ||
st->codecpar->codec_id == AV_CODEC_ID_SIPR ||
st->codecpar->codec_id == AV_CODEC_ID_ATRAC3) &&
st->codecpar->block_align && track->audio.sub_packet_size) {
VAR_12 = matroska_parse_rm_audio(VAR_0, track, st, VAR_1,
lace_size[VAR_13],
timecode, VAR_3);
if (VAR_12)
goto end;
} else if (st->codecpar->codec_id == AV_CODEC_ID_WEBVTT) {
VAR_12 = matroska_parse_webvtt(VAR_0, track, st,
VAR_1, lace_size[VAR_13],
timecode, lace_duration,
VAR_3);
if (VAR_12)
goto end;
} else {
VAR_12 = matroska_parse_frame(VAR_0, track, st, VAR_1, lace_size[VAR_13],
timecode, lace_duration, VAR_3,
!VAR_13 ? VAR_6 : 0,
VAR_7, VAR_8, VAR_9,
VAR_11);
if (VAR_12)
goto end;
}
if (timecode != AV_NOPTS_VALUE)
timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
VAR_1 += lace_size[VAR_13];
VAR_2 -= lace_size[VAR_13];
}
end:
av_free(lace_size);
return VAR_12;
}
| [
"static int FUNC_0(MatroskaDemuxContext *VAR_0, uint8_t *VAR_1,\nint VAR_2, int64_t VAR_3, uint64_t VAR_4,\nuint64_t VAR_5, int VAR_6,\nuint8_t *VAR_7, uint64_t VAR_8, int VAR_9,\nint64_t VAR_10, int64_t VAR_11)\n{",
"uint64_t timecode = AV_NOPTS_VALUE;",
"MatroskaTrack *track;",
"int VAR_12 = 0;",
"AVStrea... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
... |
15,599 | void cpu_x86_dump_state(CPUX86State *env, FILE *f, int flags)
{
int eflags, i;
char cc_op_name[32];
static const char *seg_name[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
eflags = env->eflags;
fprintf(f, "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
"ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
"EIP=%08x EFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d\n",
env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX], env->regs[R_EDX],
env->regs[R_ESI], env->regs[R_EDI], env->regs[R_EBP], env->regs[R_ESP],
env->eip, eflags,
eflags & DF_MASK ? 'D' : '-',
eflags & CC_O ? 'O' : '-',
eflags & CC_S ? 'S' : '-',
eflags & CC_Z ? 'Z' : '-',
eflags & CC_A ? 'A' : '-',
eflags & CC_P ? 'P' : '-',
eflags & CC_C ? 'C' : '-',
env->hflags & HF_CPL_MASK,
(env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
(env->a20_mask >> 20) & 1);
for(i = 0; i < 6; i++) {
SegmentCache *sc = &env->segs[i];
fprintf(f, "%s =%04x %08x %08x %08x\n",
seg_name[i],
sc->selector,
(int)sc->base,
sc->limit,
sc->flags);
}
fprintf(f, "LDT=%04x %08x %08x %08x\n",
env->ldt.selector,
(int)env->ldt.base,
env->ldt.limit,
env->ldt.flags);
fprintf(f, "TR =%04x %08x %08x %08x\n",
env->tr.selector,
(int)env->tr.base,
env->tr.limit,
env->tr.flags);
fprintf(f, "GDT= %08x %08x\n",
(int)env->gdt.base, env->gdt.limit);
fprintf(f, "IDT= %08x %08x\n",
(int)env->idt.base, env->idt.limit);
fprintf(f, "CR0=%08x CR2=%08x CR3=%08x CR4=%08x\n",
env->cr[0], env->cr[2], env->cr[3], env->cr[4]);
if (flags & X86_DUMP_CCOP) {
if ((unsigned)env->cc_op < CC_OP_NB)
strcpy(cc_op_name, cc_op_str[env->cc_op]);
else
snprintf(cc_op_name, sizeof(cc_op_name), "[%d]", env->cc_op);
fprintf(f, "CCS=%08x CCD=%08x CCO=%-8s\n",
env->cc_src, env->cc_dst, cc_op_name);
}
if (flags & X86_DUMP_FPU) {
fprintf(f, "ST0=%f ST1=%f ST2=%f ST3=%f\n",
(double)env->fpregs[0],
(double)env->fpregs[1],
(double)env->fpregs[2],
(double)env->fpregs[3]);
fprintf(f, "ST4=%f ST5=%f ST6=%f ST7=%f\n",
(double)env->fpregs[4],
(double)env->fpregs[5],
(double)env->fpregs[7],
(double)env->fpregs[8]);
}
}
| true | qemu | eba2af633fb8fa3b20ad578184d79e1f0eabcefe | void cpu_x86_dump_state(CPUX86State *env, FILE *f, int flags)
{
int eflags, i;
char cc_op_name[32];
static const char *seg_name[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
eflags = env->eflags;
fprintf(f, "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
"ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
"EIP=%08x EFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d\n",
env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX], env->regs[R_EDX],
env->regs[R_ESI], env->regs[R_EDI], env->regs[R_EBP], env->regs[R_ESP],
env->eip, eflags,
eflags & DF_MASK ? 'D' : '-',
eflags & CC_O ? 'O' : '-',
eflags & CC_S ? 'S' : '-',
eflags & CC_Z ? 'Z' : '-',
eflags & CC_A ? 'A' : '-',
eflags & CC_P ? 'P' : '-',
eflags & CC_C ? 'C' : '-',
env->hflags & HF_CPL_MASK,
(env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
(env->a20_mask >> 20) & 1);
for(i = 0; i < 6; i++) {
SegmentCache *sc = &env->segs[i];
fprintf(f, "%s =%04x %08x %08x %08x\n",
seg_name[i],
sc->selector,
(int)sc->base,
sc->limit,
sc->flags);
}
fprintf(f, "LDT=%04x %08x %08x %08x\n",
env->ldt.selector,
(int)env->ldt.base,
env->ldt.limit,
env->ldt.flags);
fprintf(f, "TR =%04x %08x %08x %08x\n",
env->tr.selector,
(int)env->tr.base,
env->tr.limit,
env->tr.flags);
fprintf(f, "GDT= %08x %08x\n",
(int)env->gdt.base, env->gdt.limit);
fprintf(f, "IDT= %08x %08x\n",
(int)env->idt.base, env->idt.limit);
fprintf(f, "CR0=%08x CR2=%08x CR3=%08x CR4=%08x\n",
env->cr[0], env->cr[2], env->cr[3], env->cr[4]);
if (flags & X86_DUMP_CCOP) {
if ((unsigned)env->cc_op < CC_OP_NB)
strcpy(cc_op_name, cc_op_str[env->cc_op]);
else
snprintf(cc_op_name, sizeof(cc_op_name), "[%d]", env->cc_op);
fprintf(f, "CCS=%08x CCD=%08x CCO=%-8s\n",
env->cc_src, env->cc_dst, cc_op_name);
}
if (flags & X86_DUMP_FPU) {
fprintf(f, "ST0=%f ST1=%f ST2=%f ST3=%f\n",
(double)env->fpregs[0],
(double)env->fpregs[1],
(double)env->fpregs[2],
(double)env->fpregs[3]);
fprintf(f, "ST4=%f ST5=%f ST6=%f ST7=%f\n",
(double)env->fpregs[4],
(double)env->fpregs[5],
(double)env->fpregs[7],
(double)env->fpregs[8]);
}
}
| {
"code": [
" strcpy(cc_op_name, cc_op_str[env->cc_op]);"
],
"line_no": [
103
]
} | void FUNC_0(CPUX86State *VAR_0, FILE *VAR_1, int VAR_2)
{
int VAR_3, VAR_4;
char VAR_5[32];
static const char *VAR_6[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
VAR_3 = VAR_0->VAR_3;
fprintf(VAR_1, "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
"ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
"EIP=%08x EFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d\n",
VAR_0->regs[R_EAX], VAR_0->regs[R_EBX], VAR_0->regs[R_ECX], VAR_0->regs[R_EDX],
VAR_0->regs[R_ESI], VAR_0->regs[R_EDI], VAR_0->regs[R_EBP], VAR_0->regs[R_ESP],
VAR_0->eip, VAR_3,
VAR_3 & DF_MASK ? 'D' : '-',
VAR_3 & CC_O ? 'O' : '-',
VAR_3 & CC_S ? 'S' : '-',
VAR_3 & CC_Z ? 'Z' : '-',
VAR_3 & CC_A ? 'A' : '-',
VAR_3 & CC_P ? 'P' : '-',
VAR_3 & CC_C ? 'C' : '-',
VAR_0->hflags & HF_CPL_MASK,
(VAR_0->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
(VAR_0->a20_mask >> 20) & 1);
for(VAR_4 = 0; VAR_4 < 6; VAR_4++) {
SegmentCache *sc = &VAR_0->segs[VAR_4];
fprintf(VAR_1, "%s =%04x %08x %08x %08x\n",
VAR_6[VAR_4],
sc->selector,
(int)sc->base,
sc->limit,
sc->VAR_2);
}
fprintf(VAR_1, "LDT=%04x %08x %08x %08x\n",
VAR_0->ldt.selector,
(int)VAR_0->ldt.base,
VAR_0->ldt.limit,
VAR_0->ldt.VAR_2);
fprintf(VAR_1, "TR =%04x %08x %08x %08x\n",
VAR_0->tr.selector,
(int)VAR_0->tr.base,
VAR_0->tr.limit,
VAR_0->tr.VAR_2);
fprintf(VAR_1, "GDT= %08x %08x\n",
(int)VAR_0->gdt.base, VAR_0->gdt.limit);
fprintf(VAR_1, "IDT= %08x %08x\n",
(int)VAR_0->idt.base, VAR_0->idt.limit);
fprintf(VAR_1, "CR0=%08x CR2=%08x CR3=%08x CR4=%08x\n",
VAR_0->cr[0], VAR_0->cr[2], VAR_0->cr[3], VAR_0->cr[4]);
if (VAR_2 & X86_DUMP_CCOP) {
if ((unsigned)VAR_0->cc_op < CC_OP_NB)
strcpy(VAR_5, cc_op_str[VAR_0->cc_op]);
else
snprintf(VAR_5, sizeof(VAR_5), "[%d]", VAR_0->cc_op);
fprintf(VAR_1, "CCS=%08x CCD=%08x CCO=%-8s\n",
VAR_0->cc_src, VAR_0->cc_dst, VAR_5);
}
if (VAR_2 & X86_DUMP_FPU) {
fprintf(VAR_1, "ST0=%VAR_1 ST1=%VAR_1 ST2=%VAR_1 ST3=%VAR_1\n",
(double)VAR_0->fpregs[0],
(double)VAR_0->fpregs[1],
(double)VAR_0->fpregs[2],
(double)VAR_0->fpregs[3]);
fprintf(VAR_1, "ST4=%VAR_1 ST5=%VAR_1 ST6=%VAR_1 ST7=%VAR_1\n",
(double)VAR_0->fpregs[4],
(double)VAR_0->fpregs[5],
(double)VAR_0->fpregs[7],
(double)VAR_0->fpregs[8]);
}
}
| [
"void FUNC_0(CPUX86State *VAR_0, FILE *VAR_1, int VAR_2)\n{",
"int VAR_3, VAR_4;",
"char VAR_5[32];",
"static const char *VAR_6[6] = { \"ES\", \"CS\", \"SS\", \"DS\", \"FS\", \"GS\" };",
"VAR_3 = VAR_0->VAR_3;",
"fprintf(VAR_1, \"EAX=%08x EBX=%08x ECX=%08x EDX=%08x\\n\"\n\"ESI=%08x EDI=%08x EBP=%08x ESP=%... | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15,
17,
19,
21,
23,
25,
27,
29,
31,
33,
35,
37,
39,
41,
43,
45
],
[
47
],
[
49
],
[
51,
53,
55,
57,
59,
61
],
[
63
... |
15,600 | static void memory_region_read_accessor(MemoryRegion *mr,
hwaddr addr,
uint64_t *value,
unsigned size,
unsigned shift,
uint64_t mask)
{
uint64_t tmp;
if (mr->flush_coalesced_mmio) {
qemu_flush_coalesced_mmio_buffer();
}
tmp = mr->ops->read(mr->opaque, addr, size);
trace_memory_region_ops_read(mr, addr, tmp, size);
*value |= (tmp & mask) << shift;
}
| true | qemu | cc05c43ad942165ecc6ffd39e41991bee43af044 | static void memory_region_read_accessor(MemoryRegion *mr,
hwaddr addr,
uint64_t *value,
unsigned size,
unsigned shift,
uint64_t mask)
{
uint64_t tmp;
if (mr->flush_coalesced_mmio) {
qemu_flush_coalesced_mmio_buffer();
}
tmp = mr->ops->read(mr->opaque, addr, size);
trace_memory_region_ops_read(mr, addr, tmp, size);
*value |= (tmp & mask) << shift;
}
| {
"code": [
"static void memory_region_read_accessor(MemoryRegion *mr,",
" hwaddr addr,",
" uint64_t *value,",
" unsigned size,",
" unsigned shift,",
" uint64_t mask)",
" uint64_t tmp;",
" tmp = mr->ops->read(mr->opaque, addr, size);",
" hwaddr addr,"
],
"line_no": [
1,
3,
5,
7,
9,
11,
15,
25,
3
]
} | static void FUNC_0(MemoryRegion *VAR_0,
hwaddr VAR_1,
uint64_t *VAR_2,
unsigned VAR_3,
unsigned VAR_4,
uint64_t VAR_5)
{
uint64_t tmp;
if (VAR_0->flush_coalesced_mmio) {
qemu_flush_coalesced_mmio_buffer();
}
tmp = VAR_0->ops->read(VAR_0->opaque, VAR_1, VAR_3);
trace_memory_region_ops_read(VAR_0, VAR_1, tmp, VAR_3);
*VAR_2 |= (tmp & VAR_5) << VAR_4;
}
| [
"static void FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nuint64_t *VAR_2,\nunsigned VAR_3,\nunsigned VAR_4,\nuint64_t VAR_5)\n{",
"uint64_t tmp;",
"if (VAR_0->flush_coalesced_mmio) {",
"qemu_flush_coalesced_mmio_buffer();",
"}",
"tmp = VAR_0->ops->read(VAR_0->opaque, VAR_1, VAR_3);",
"trace_memory_regio... | [
1,
1,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
]
] |
15,601 | static void dec_load(DisasContext *dc)
{
TCGv t, *addr;
unsigned int size;
size = 1 << (dc->opcode & 3);
LOG_DIS("l %x %d\n", dc->opcode, size);
t_sync_flags(dc);
addr = compute_ldst_addr(dc, &t);
/* If we get a fault on a dslot, the jmpstate better be in sync. */
sync_jmpstate(dc);
/* Verify alignment if needed. */
if ((dc->env->pvr.regs[2] & PVR2_UNALIGNED_EXC_MASK) && size > 1) {
gen_helper_memalign(*addr, tcg_const_tl(dc->rd),
tcg_const_tl(0), tcg_const_tl(size - 1));
if (dc->rd) {
gen_load(dc, cpu_R[dc->rd], *addr, size);
} else {
gen_load(dc, env_imm, *addr, size);
if (addr == &t)
tcg_temp_free(t);
| true | qemu | 0187688f3270433269fc7d4909ad36dc5c5db7aa | static void dec_load(DisasContext *dc)
{
TCGv t, *addr;
unsigned int size;
size = 1 << (dc->opcode & 3);
LOG_DIS("l %x %d\n", dc->opcode, size);
t_sync_flags(dc);
addr = compute_ldst_addr(dc, &t);
sync_jmpstate(dc);
if ((dc->env->pvr.regs[2] & PVR2_UNALIGNED_EXC_MASK) && size > 1) {
gen_helper_memalign(*addr, tcg_const_tl(dc->rd),
tcg_const_tl(0), tcg_const_tl(size - 1));
if (dc->rd) {
gen_load(dc, cpu_R[dc->rd], *addr, size);
} else {
gen_load(dc, env_imm, *addr, size);
if (addr == &t)
tcg_temp_free(t);
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0)
{
TCGv t, *addr;
unsigned int VAR_1;
VAR_1 = 1 << (VAR_0->opcode & 3);
LOG_DIS("l %x %d\n", VAR_0->opcode, VAR_1);
t_sync_flags(VAR_0);
addr = compute_ldst_addr(VAR_0, &t);
sync_jmpstate(VAR_0);
if ((VAR_0->env->pvr.regs[2] & PVR2_UNALIGNED_EXC_MASK) && VAR_1 > 1) {
gen_helper_memalign(*addr, tcg_const_tl(VAR_0->rd),
tcg_const_tl(0), tcg_const_tl(VAR_1 - 1));
if (VAR_0->rd) {
gen_load(VAR_0, cpu_R[VAR_0->rd], *addr, VAR_1);
} else {
gen_load(VAR_0, env_imm, *addr, VAR_1);
if (addr == &t)
tcg_temp_free(t);
| [
"static void FUNC_0(DisasContext *VAR_0)\n{",
"TCGv t, *addr;",
"unsigned int VAR_1;",
"VAR_1 = 1 << (VAR_0->opcode & 3);",
"LOG_DIS(\"l %x %d\\n\", VAR_0->opcode, VAR_1);",
"t_sync_flags(VAR_0);",
"addr = compute_ldst_addr(VAR_0, &t);",
"sync_jmpstate(VAR_0);",
"if ((VAR_0->env->pvr.regs[2] & PVR2_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
21
],
[
23
],
[
25
],
[
31
],
[
37
],
[
39,
41
],
[
46
],
[
48
],
[
50
],
[
52
],
[
57,
59
]
] |
15,602 | static void test_visitor_in_int_overflow(TestInputVisitorData *data,
const void *unused)
{
int64_t res = 0;
Error *err = NULL;
Visitor *v;
/* this will overflow a Qint/int64, so should be deserialized into
* a QFloat/double field instead, leading to an error if we pass it
* to visit_type_int. confirm this.
*/
v = visitor_input_test_init(data, "%f", DBL_MAX);
visit_type_int(v, &res, NULL, &err);
g_assert(err);
error_free(err);
}
| true | qemu | a12a5a1a0132527afe87c079e4aae4aad372bd94 | static void test_visitor_in_int_overflow(TestInputVisitorData *data,
const void *unused)
{
int64_t res = 0;
Error *err = NULL;
Visitor *v;
v = visitor_input_test_init(data, "%f", DBL_MAX);
visit_type_int(v, &res, NULL, &err);
g_assert(err);
error_free(err);
}
| {
"code": [
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);",
" g_assert(err);",
" error_free(err);"
],
"line_no": [
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31,
29,
31
]
} | static void FUNC_0(TestInputVisitorData *VAR_0,
const void *VAR_1)
{
int64_t res = 0;
Error *err = NULL;
Visitor *v;
v = visitor_input_test_init(VAR_0, "%f", DBL_MAX);
visit_type_int(v, &res, NULL, &err);
g_assert(err);
error_free(err);
}
| [
"static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"int64_t res = 0;",
"Error *err = NULL;",
"Visitor *v;",
"v = visitor_input_test_init(VAR_0, \"%f\", DBL_MAX);",
"visit_type_int(v, &res, NULL, &err);",
"g_assert(err);",
"error_free(err);",
"}"
] | [
0,
0,
0,
0,
0,
0,
1,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
15,603 | static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
int num, den, presentation_delayed, delay, i;
int64_t offset;
if (s->flags & AVFMT_FLAG_NOFILLIN)
return;
if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
pkt->dts= AV_NOPTS_VALUE;
if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
//FIXME Set low_delay = 0 when has_b_frames = 1
st->codec->has_b_frames = 1;
/* do we have a video B-frame ? */
delay= st->codec->has_b_frames;
presentation_delayed = 0;
// ignore delay caused by frame threading so that the mpeg2-without-dts
// warning will not trigger
if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
delay -= st->codec->thread_count-1;
/* XXX: need has_b_frame, but cannot get it if the codec is
not initialized */
if (delay &&
pc && pc->pict_type != AV_PICTURE_TYPE_B)
presentation_delayed = 1;
if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
pkt->dts -= 1LL<<st->pts_wrap_bits;
}
// some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
// we take the conservative approach and discard both
// Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
pkt->dts= pkt->pts= AV_NOPTS_VALUE;
}
if (pkt->duration == 0) {
compute_frame_duration(&num, &den, st, pc, pkt);
if (den && num) {
pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
if(pkt->duration != 0 && s->packet_buffer)
update_initial_durations(s, st, pkt);
}
}
/* correct timestamps with byte offset if demuxers only have timestamps
on packet boundaries */
if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
/* this will estimate bitrate based on this frame's duration and size */
offset = av_rescale(pc->offset, pkt->duration, pkt->size);
if(pkt->pts != AV_NOPTS_VALUE)
pkt->pts += offset;
if(pkt->dts != AV_NOPTS_VALUE)
pkt->dts += offset;
}
if (pc && pc->dts_sync_point >= 0) {
// we have synchronization info from the parser
int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
if (den > 0) {
int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
if (pkt->dts != AV_NOPTS_VALUE) {
// got DTS from the stream, update reference timestamp
st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
} else if (st->reference_dts != AV_NOPTS_VALUE) {
// compute DTS based on reference timestamp
pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
}
if (pc->dts_sync_point > 0)
st->reference_dts = pkt->dts; // new reference
}
}
/* This may be redundant, but it should not hurt. */
if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
presentation_delayed = 1;
// av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
/* interpolate PTS and DTS if they are not present */
//We skip H264 currently because delay and has_b_frames are not reliably set
if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
if (presentation_delayed) {
/* DTS = decompression timestamp */
/* PTS = presentation timestamp */
if (pkt->dts == AV_NOPTS_VALUE)
pkt->dts = st->last_IP_pts;
update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
if (pkt->dts == AV_NOPTS_VALUE)
pkt->dts = st->cur_dts;
/* this is tricky: the dts must be incremented by the duration
of the frame we are displaying, i.e. the last I- or P-frame */
if (st->last_IP_duration == 0)
st->last_IP_duration = pkt->duration;
if(pkt->dts != AV_NOPTS_VALUE)
st->cur_dts = pkt->dts + st->last_IP_duration;
st->last_IP_duration = pkt->duration;
st->last_IP_pts= pkt->pts;
/* cannot compute PTS if not present (we can compute it only
by knowing the future */
} else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
pkt->pts += pkt->duration;
// av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
}
}
/* presentation is not delayed : PTS and DTS are the same */
if(pkt->pts == AV_NOPTS_VALUE)
pkt->pts = pkt->dts;
update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
if(pkt->pts == AV_NOPTS_VALUE)
pkt->pts = st->cur_dts;
pkt->dts = pkt->pts;
if(pkt->pts != AV_NOPTS_VALUE)
st->cur_dts = pkt->pts + pkt->duration;
}
}
if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
st->pts_buffer[0]= pkt->pts;
for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
if(pkt->dts == AV_NOPTS_VALUE)
pkt->dts= st->pts_buffer[0];
if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
}
if(pkt->dts > st->cur_dts)
st->cur_dts = pkt->dts;
}
// av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
/* update flags */
if(is_intra_only(st->codec))
pkt->flags |= AV_PKT_FLAG_KEY;
else if (pc) {
pkt->flags = 0;
/* keyframe computation */
if (pc->key_frame == 1)
pkt->flags |= AV_PKT_FLAG_KEY;
else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
pkt->flags |= AV_PKT_FLAG_KEY;
}
if (pc)
pkt->convergence_duration = pc->convergence_duration;
}
| true | FFmpeg | 26ae9a5d7c448a3eb42641b546ee8d585ab716e6 | static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
int num, den, presentation_delayed, delay, i;
int64_t offset;
if (s->flags & AVFMT_FLAG_NOFILLIN)
return;
if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
pkt->dts= AV_NOPTS_VALUE;
if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
st->codec->has_b_frames = 1;
delay= st->codec->has_b_frames;
presentation_delayed = 0;
if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
delay -= st->codec->thread_count-1;
if (delay &&
pc && pc->pict_type != AV_PICTURE_TYPE_B)
presentation_delayed = 1;
if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
pkt->dts -= 1LL<<st->pts_wrap_bits;
}
if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
pkt->dts= pkt->pts= AV_NOPTS_VALUE;
}
if (pkt->duration == 0) {
compute_frame_duration(&num, &den, st, pc, pkt);
if (den && num) {
pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
if(pkt->duration != 0 && s->packet_buffer)
update_initial_durations(s, st, pkt);
}
}
if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
offset = av_rescale(pc->offset, pkt->duration, pkt->size);
if(pkt->pts != AV_NOPTS_VALUE)
pkt->pts += offset;
if(pkt->dts != AV_NOPTS_VALUE)
pkt->dts += offset;
}
if (pc && pc->dts_sync_point >= 0) {
int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
if (den > 0) {
int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
if (pkt->dts != AV_NOPTS_VALUE) {
st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
} else if (st->reference_dts != AV_NOPTS_VALUE) {
pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
}
if (pc->dts_sync_point > 0)
st->reference_dts = pkt->dts;
}
}
if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
presentation_delayed = 1;
if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
if (presentation_delayed) {
if (pkt->dts == AV_NOPTS_VALUE)
pkt->dts = st->last_IP_pts;
update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
if (pkt->dts == AV_NOPTS_VALUE)
pkt->dts = st->cur_dts;
if (st->last_IP_duration == 0)
st->last_IP_duration = pkt->duration;
if(pkt->dts != AV_NOPTS_VALUE)
st->cur_dts = pkt->dts + st->last_IP_duration;
st->last_IP_duration = pkt->duration;
st->last_IP_pts= pkt->pts;
} else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
pkt->pts += pkt->duration;
}
}
if(pkt->pts == AV_NOPTS_VALUE)
pkt->pts = pkt->dts;
update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
if(pkt->pts == AV_NOPTS_VALUE)
pkt->pts = st->cur_dts;
pkt->dts = pkt->pts;
if(pkt->pts != AV_NOPTS_VALUE)
st->cur_dts = pkt->pts + pkt->duration;
}
}
if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
st->pts_buffer[0]= pkt->pts;
for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
if(pkt->dts == AV_NOPTS_VALUE)
pkt->dts= st->pts_buffer[0];
if(st->codec->codec_id == CODEC_ID_H264){
update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
}
if(pkt->dts > st->cur_dts)
st->cur_dts = pkt->dts;
}
if(is_intra_only(st->codec))
pkt->flags |= AV_PKT_FLAG_KEY;
else if (pc) {
pkt->flags = 0;
if (pc->key_frame == 1)
pkt->flags |= AV_PKT_FLAG_KEY;
else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
pkt->flags |= AV_PKT_FLAG_KEY;
}
if (pc)
pkt->convergence_duration = pc->convergence_duration;
}
| {
"code": [
" if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)",
" delay -= st->codec->thread_count-1;"
],
"line_no": [
45,
47
]
} | static void FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1,
AVCodecParserContext *VAR_2, AVPacket *VAR_3)
{
int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;
int64_t offset;
if (VAR_0->flags & AVFMT_FLAG_NOFILLIN)
return;
if((VAR_0->flags & AVFMT_FLAG_IGNDTS) && VAR_3->pts != AV_NOPTS_VALUE)
VAR_3->dts= AV_NOPTS_VALUE;
if (VAR_1->codec->codec_id != CODEC_ID_H264 && VAR_2 && VAR_2->pict_type == AV_PICTURE_TYPE_B)
VAR_1->codec->has_b_frames = 1;
VAR_7= VAR_1->codec->has_b_frames;
VAR_6 = 0;
if (VAR_7 && VAR_1->codec->active_thread_type&FF_THREAD_FRAME)
VAR_7 -= VAR_1->codec->thread_count-1;
if (VAR_7 &&
VAR_2 && VAR_2->pict_type != AV_PICTURE_TYPE_B)
VAR_6 = 1;
if(VAR_3->pts != AV_NOPTS_VALUE && VAR_3->dts != AV_NOPTS_VALUE && VAR_3->dts - (1LL<<(VAR_1->pts_wrap_bits-1)) > VAR_3->pts && VAR_1->pts_wrap_bits<63){
VAR_3->dts -= 1LL<<VAR_1->pts_wrap_bits;
}
if(VAR_7==1 && VAR_3->dts == VAR_3->pts && VAR_3->dts != AV_NOPTS_VALUE && VAR_6){
av_log(VAR_0, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", VAR_3->dts);
VAR_3->dts= VAR_3->pts= AV_NOPTS_VALUE;
}
if (VAR_3->duration == 0) {
compute_frame_duration(&VAR_4, &VAR_5, VAR_1, VAR_2, VAR_3);
if (VAR_5 && VAR_4) {
VAR_3->duration = av_rescale_rnd(1, VAR_4 * (int64_t)VAR_1->time_base.VAR_5, VAR_5 * (int64_t)VAR_1->time_base.VAR_4, AV_ROUND_DOWN);
if(VAR_3->duration != 0 && VAR_0->packet_buffer)
update_initial_durations(VAR_0, VAR_1, VAR_3);
}
}
if(VAR_2 && VAR_1->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && VAR_3->size){
offset = av_rescale(VAR_2->offset, VAR_3->duration, VAR_3->size);
if(VAR_3->pts != AV_NOPTS_VALUE)
VAR_3->pts += offset;
if(VAR_3->dts != AV_NOPTS_VALUE)
VAR_3->dts += offset;
}
if (VAR_2 && VAR_2->dts_sync_point >= 0) {
int64_t VAR_5 = VAR_1->codec->time_base.VAR_5 * (int64_t) VAR_1->time_base.VAR_4;
if (VAR_5 > 0) {
int64_t VAR_4 = VAR_1->codec->time_base.VAR_4 * (int64_t) VAR_1->time_base.VAR_5;
if (VAR_3->dts != AV_NOPTS_VALUE) {
VAR_1->reference_dts = VAR_3->dts - VAR_2->dts_ref_dts_delta * VAR_4 / VAR_5;
VAR_3->pts = VAR_3->dts + VAR_2->pts_dts_delta * VAR_4 / VAR_5;
} else if (VAR_1->reference_dts != AV_NOPTS_VALUE) {
VAR_3->dts = VAR_1->reference_dts + VAR_2->dts_ref_dts_delta * VAR_4 / VAR_5;
VAR_3->pts = VAR_3->dts + VAR_2->pts_dts_delta * VAR_4 / VAR_5;
}
if (VAR_2->dts_sync_point > 0)
VAR_1->reference_dts = VAR_3->dts;
}
}
if(VAR_3->dts != AV_NOPTS_VALUE && VAR_3->pts != AV_NOPTS_VALUE && VAR_3->pts > VAR_3->dts)
VAR_6 = 1;
if((VAR_7==0 || (VAR_7==1 && VAR_2)) && VAR_1->codec->codec_id != CODEC_ID_H264){
if (VAR_6) {
if (VAR_3->dts == AV_NOPTS_VALUE)
VAR_3->dts = VAR_1->last_IP_pts;
update_initial_timestamps(VAR_0, VAR_3->stream_index, VAR_3->dts, VAR_3->pts);
if (VAR_3->dts == AV_NOPTS_VALUE)
VAR_3->dts = VAR_1->cur_dts;
if (VAR_1->last_IP_duration == 0)
VAR_1->last_IP_duration = VAR_3->duration;
if(VAR_3->dts != AV_NOPTS_VALUE)
VAR_1->cur_dts = VAR_3->dts + VAR_1->last_IP_duration;
VAR_1->last_IP_duration = VAR_3->duration;
VAR_1->last_IP_pts= VAR_3->pts;
} else if(VAR_3->pts != AV_NOPTS_VALUE || VAR_3->dts != AV_NOPTS_VALUE || VAR_3->duration){
if(VAR_3->pts != AV_NOPTS_VALUE && VAR_3->duration){
int64_t old_diff= FFABS(VAR_1->cur_dts - VAR_3->duration - VAR_3->pts);
int64_t new_diff= FFABS(VAR_1->cur_dts - VAR_3->pts);
if(old_diff < new_diff && old_diff < (VAR_3->duration>>3)){
VAR_3->pts += VAR_3->duration;
}
}
if(VAR_3->pts == AV_NOPTS_VALUE)
VAR_3->pts = VAR_3->dts;
update_initial_timestamps(VAR_0, VAR_3->stream_index, VAR_3->pts, VAR_3->pts);
if(VAR_3->pts == AV_NOPTS_VALUE)
VAR_3->pts = VAR_1->cur_dts;
VAR_3->dts = VAR_3->pts;
if(VAR_3->pts != AV_NOPTS_VALUE)
VAR_1->cur_dts = VAR_3->pts + VAR_3->duration;
}
}
if(VAR_3->pts != AV_NOPTS_VALUE && VAR_7 <= MAX_REORDER_DELAY){
VAR_1->pts_buffer[0]= VAR_3->pts;
for(VAR_8=0; VAR_8<VAR_7 && VAR_1->pts_buffer[VAR_8] > VAR_1->pts_buffer[VAR_8+1]; VAR_8++)
FFSWAP(int64_t, VAR_1->pts_buffer[VAR_8], VAR_1->pts_buffer[VAR_8+1]);
if(VAR_3->dts == AV_NOPTS_VALUE)
VAR_3->dts= VAR_1->pts_buffer[0];
if(VAR_1->codec->codec_id == CODEC_ID_H264){
update_initial_timestamps(VAR_0, VAR_3->stream_index, VAR_3->dts, VAR_3->pts);
}
if(VAR_3->dts > VAR_1->cur_dts)
VAR_1->cur_dts = VAR_3->dts;
}
if(is_intra_only(VAR_1->codec))
VAR_3->flags |= AV_PKT_FLAG_KEY;
else if (VAR_2) {
VAR_3->flags = 0;
if (VAR_2->key_frame == 1)
VAR_3->flags |= AV_PKT_FLAG_KEY;
else if (VAR_2->key_frame == -1 && VAR_2->pict_type == AV_PICTURE_TYPE_I)
VAR_3->flags |= AV_PKT_FLAG_KEY;
}
if (VAR_2)
VAR_3->convergence_duration = VAR_2->convergence_duration;
}
| [
"static void FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1,\nAVCodecParserContext *VAR_2, AVPacket *VAR_3)\n{",
"int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8;",
"int64_t offset;",
"if (VAR_0->flags & AVFMT_FLAG_NOFILLIN)\nreturn;",
"if((VAR_0->flags & AVFMT_FLAG_IGNDTS) && VAR_3->pts != AV_NOPTS_VALUE)\nVAR_3->dt... | [
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... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13,
15
],
[
19,
21
],
[
25,
29
],
[
35
],
[
37
],
[
45,
47
],
[
55,
57,
59
],
[
63
],
[
65
],
[
67
],
[
77
],
[
79
],
[
81
],
[... |
15,604 | static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
ShowWavesContext *showwaves = ctx->priv;
const int nb_samples = insamples->audio->nb_samples;
AVFilterBufferRef *outpicref = showwaves->outpicref;
int linesize = outpicref ? outpicref->linesize[0] : 0;
int16_t *p = (int16_t *)insamples->data[0];
int nb_channels = av_get_channel_layout_nb_channels(insamples->audio->channel_layout);
int i, j, h;
const int n = showwaves->n;
const int x = 255 / (nb_channels * n); /* multiplication factor, pre-computed to avoid in-loop divisions */
/* draw data in the buffer */
for (i = 0; i < nb_samples; i++) {
if (showwaves->buf_idx == 0 && showwaves->sample_count_mod == 0) {
showwaves->outpicref = outpicref =
ff_get_video_buffer(outlink, AV_PERM_WRITE|AV_PERM_ALIGN,
outlink->w, outlink->h);
outpicref->video->w = outlink->w;
outpicref->video->h = outlink->h;
outpicref->pts = insamples->pts +
av_rescale_q((p - (int16_t *)insamples->data[0]) / nb_channels,
(AVRational){ 1, inlink->sample_rate },
outlink->time_base);
linesize = outpicref->linesize[0];
memset(outpicref->data[0], 0, showwaves->h*linesize);
}
for (j = 0; j < nb_channels; j++) {
h = showwaves->h/2 - av_rescale(*p++, showwaves->h/2, MAX_INT16);
if (h >= 0 && h < outlink->h)
*(outpicref->data[0] + showwaves->buf_idx + h * linesize) += x;
}
showwaves->sample_count_mod++;
if (showwaves->sample_count_mod == n) {
showwaves->sample_count_mod = 0;
showwaves->buf_idx++;
}
if (showwaves->buf_idx == showwaves->w)
push_frame(outlink);
}
avfilter_unref_buffer(insamples);
return 0;
}
| false | FFmpeg | 5f634480d1c4ed7711a15d1be07e49177cf351c1 | static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
ShowWavesContext *showwaves = ctx->priv;
const int nb_samples = insamples->audio->nb_samples;
AVFilterBufferRef *outpicref = showwaves->outpicref;
int linesize = outpicref ? outpicref->linesize[0] : 0;
int16_t *p = (int16_t *)insamples->data[0];
int nb_channels = av_get_channel_layout_nb_channels(insamples->audio->channel_layout);
int i, j, h;
const int n = showwaves->n;
const int x = 255 / (nb_channels * n);
for (i = 0; i < nb_samples; i++) {
if (showwaves->buf_idx == 0 && showwaves->sample_count_mod == 0) {
showwaves->outpicref = outpicref =
ff_get_video_buffer(outlink, AV_PERM_WRITE|AV_PERM_ALIGN,
outlink->w, outlink->h);
outpicref->video->w = outlink->w;
outpicref->video->h = outlink->h;
outpicref->pts = insamples->pts +
av_rescale_q((p - (int16_t *)insamples->data[0]) / nb_channels,
(AVRational){ 1, inlink->sample_rate },
outlink->time_base);
linesize = outpicref->linesize[0];
memset(outpicref->data[0], 0, showwaves->h*linesize);
}
for (j = 0; j < nb_channels; j++) {
h = showwaves->h/2 - av_rescale(*p++, showwaves->h/2, MAX_INT16);
if (h >= 0 && h < outlink->h)
*(outpicref->data[0] + showwaves->buf_idx + h * linesize) += x;
}
showwaves->sample_count_mod++;
if (showwaves->sample_count_mod == n) {
showwaves->sample_count_mod = 0;
showwaves->buf_idx++;
}
if (showwaves->buf_idx == showwaves->w)
push_frame(outlink);
}
avfilter_unref_buffer(insamples);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFilterLink *VAR_0, AVFilterBufferRef *VAR_1)
{
AVFilterContext *ctx = VAR_0->dst;
AVFilterLink *outlink = ctx->outputs[0];
ShowWavesContext *showwaves = ctx->priv;
const int VAR_2 = VAR_1->audio->VAR_2;
AVFilterBufferRef *outpicref = showwaves->outpicref;
int VAR_3 = outpicref ? outpicref->VAR_3[0] : 0;
int16_t *p = (int16_t *)VAR_1->data[0];
int VAR_4 = av_get_channel_layout_nb_channels(VAR_1->audio->channel_layout);
int VAR_5, VAR_6, VAR_7;
const int VAR_8 = showwaves->VAR_8;
const int VAR_9 = 255 / (VAR_4 * VAR_8);
for (VAR_5 = 0; VAR_5 < VAR_2; VAR_5++) {
if (showwaves->buf_idx == 0 && showwaves->sample_count_mod == 0) {
showwaves->outpicref = outpicref =
ff_get_video_buffer(outlink, AV_PERM_WRITE|AV_PERM_ALIGN,
outlink->w, outlink->VAR_7);
outpicref->video->w = outlink->w;
outpicref->video->VAR_7 = outlink->VAR_7;
outpicref->pts = VAR_1->pts +
av_rescale_q((p - (int16_t *)VAR_1->data[0]) / VAR_4,
(AVRational){ 1, VAR_0->sample_rate },
outlink->time_base);
VAR_3 = outpicref->VAR_3[0];
memset(outpicref->data[0], 0, showwaves->VAR_7*VAR_3);
}
for (VAR_6 = 0; VAR_6 < VAR_4; VAR_6++) {
VAR_7 = showwaves->VAR_7/2 - av_rescale(*p++, showwaves->VAR_7/2, MAX_INT16);
if (VAR_7 >= 0 && VAR_7 < outlink->VAR_7)
*(outpicref->data[0] + showwaves->buf_idx + VAR_7 * VAR_3) += VAR_9;
}
showwaves->sample_count_mod++;
if (showwaves->sample_count_mod == VAR_8) {
showwaves->sample_count_mod = 0;
showwaves->buf_idx++;
}
if (showwaves->buf_idx == showwaves->w)
push_frame(outlink);
}
avfilter_unref_buffer(VAR_1);
return 0;
}
| [
"static int FUNC_0(AVFilterLink *VAR_0, AVFilterBufferRef *VAR_1)\n{",
"AVFilterContext *ctx = VAR_0->dst;",
"AVFilterLink *outlink = ctx->outputs[0];",
"ShowWavesContext *showwaves = ctx->priv;",
"const int VAR_2 = VAR_1->audio->VAR_2;",
"AVFilterBufferRef *outpicref = showwaves->outpicref;",
"int 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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
31
],
[
33
],
[
35,
37,
39
],
[
41
],
[
43
],
[
45,
47,
49
... |
15,605 | static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order,
int c_bits)
{
int i;
const float *quant_arr = tns_tmp2_map[c_bits];
for (i = 0; i < order; i++) {
idx[i] = quant_array_idx((float)coef[i], quant_arr, c_bits ? 16 : 8);
lpc[i] = quant_arr[idx[i]];
}
}
| false | FFmpeg | d55f83de4d419d22d2fd2c0b9ff4ce6bf93847d6 | static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order,
int c_bits)
{
int i;
const float *quant_arr = tns_tmp2_map[c_bits];
for (i = 0; i < order; i++) {
idx[i] = quant_array_idx((float)coef[i], quant_arr, c_bits ? 16 : 8);
lpc[i] = quant_arr[idx[i]];
}
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(double *VAR_0, int *VAR_1, float *VAR_2, int VAR_3,
int VAR_4)
{
int VAR_5;
const float *VAR_6 = tns_tmp2_map[VAR_4];
for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++) {
VAR_1[VAR_5] = quant_array_idx((float)VAR_0[VAR_5], VAR_6, VAR_4 ? 16 : 8);
VAR_2[VAR_5] = VAR_6[VAR_1[VAR_5]];
}
}
| [
"static inline void FUNC_0(double *VAR_0, int *VAR_1, float *VAR_2, int VAR_3,\nint VAR_4)\n{",
"int VAR_5;",
"const float *VAR_6 = tns_tmp2_map[VAR_4];",
"for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++) {",
"VAR_1[VAR_5] = quant_array_idx((float)VAR_0[VAR_5], VAR_6, VAR_4 ? 16 : 8);",
"VAR_2[VAR_5] = VAR_6[VAR_1... | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
15,606 | static void scsi_block_class_initfn(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
sc->realize = scsi_block_realize;
sc->unrealize = scsi_unrealize;
sc->alloc_req = scsi_block_new_request;
sc->parse_cdb = scsi_block_parse_cdb;
dc->fw_name = "disk";
dc->desc = "SCSI block device passthrough";
dc->reset = scsi_disk_reset;
dc->props = scsi_block_properties;
dc->vmsd = &vmstate_scsi_disk_state;
}
| false | qemu | fb7b5c0df6e3c501973ce4d57eb2b1d4344a519d | static void scsi_block_class_initfn(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
sc->realize = scsi_block_realize;
sc->unrealize = scsi_unrealize;
sc->alloc_req = scsi_block_new_request;
sc->parse_cdb = scsi_block_parse_cdb;
dc->fw_name = "disk";
dc->desc = "SCSI block device passthrough";
dc->reset = scsi_disk_reset;
dc->props = scsi_block_properties;
dc->vmsd = &vmstate_scsi_disk_state;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(VAR_0);
sc->realize = scsi_block_realize;
sc->unrealize = scsi_unrealize;
sc->alloc_req = scsi_block_new_request;
sc->parse_cdb = scsi_block_parse_cdb;
dc->fw_name = "disk";
dc->desc = "SCSI block device passthrough";
dc->reset = scsi_disk_reset;
dc->props = scsi_block_properties;
dc->vmsd = &vmstate_scsi_disk_state;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(VAR_0);",
"sc->realize = scsi_block_realize;",
"sc->unrealize = scsi_unrealize;",
"sc->alloc_req = scsi_block_new_request;",
"sc->parse_cdb = scsi_bl... | [
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
]
] |
15,607 | static inline target_phys_addr_t get_pgaddr(target_phys_addr_t sdr1,
int sdr_sh,
target_phys_addr_t hash,
target_phys_addr_t mask)
{
return (sdr1 & ((target_phys_addr_t)(-1ULL) << sdr_sh)) | (hash & mask);
}
| false | qemu | bb593904c18e22ea0671dfa1b02e24982f2bf0ea | static inline target_phys_addr_t get_pgaddr(target_phys_addr_t sdr1,
int sdr_sh,
target_phys_addr_t hash,
target_phys_addr_t mask)
{
return (sdr1 & ((target_phys_addr_t)(-1ULL) << sdr_sh)) | (hash & mask);
}
| {
"code": [],
"line_no": []
} | static inline target_phys_addr_t FUNC_0(target_phys_addr_t sdr1,
int sdr_sh,
target_phys_addr_t hash,
target_phys_addr_t mask)
{
return (sdr1 & ((target_phys_addr_t)(-1ULL) << sdr_sh)) | (hash & mask);
}
| [
"static inline target_phys_addr_t FUNC_0(target_phys_addr_t sdr1,\nint sdr_sh,\ntarget_phys_addr_t hash,\ntarget_phys_addr_t mask)\n{",
"return (sdr1 & ((target_phys_addr_t)(-1ULL) << sdr_sh)) | (hash & mask);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
]
] |
15,608 | int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed,
Error **errp)
{
int ret = 0;
VHDXHeader *hdr;
VHDXLogSequence logs = { 0 };
hdr = s->headers[s->curr_header];
*flushed = false;
/* s->log.hdr is freed in vhdx_close() */
if (s->log.hdr == NULL) {
s->log.hdr = qemu_blockalign(bs, sizeof(VHDXLogEntryHeader));
}
s->log.offset = hdr->log_offset;
s->log.length = hdr->log_length;
if (s->log.offset < VHDX_LOG_MIN_SIZE ||
s->log.offset % VHDX_LOG_MIN_SIZE) {
ret = -EINVAL;
goto exit;
}
/* per spec, only log version of 0 is supported */
if (hdr->log_version != 0) {
ret = -EINVAL;
goto exit;
}
/* If either the log guid, or log length is zero,
* then a replay log is not present */
if (guid_eq(hdr->log_guid, zero_guid)) {
goto exit;
}
if (hdr->log_length == 0) {
goto exit;
}
if (hdr->log_length % VHDX_LOG_MIN_SIZE) {
ret = -EINVAL;
goto exit;
}
/* The log is present, we need to find if and where there is an active
* sequence of valid entries present in the log. */
ret = vhdx_log_search(bs, s, &logs);
if (ret < 0) {
goto exit;
}
if (logs.valid) {
if (bs->read_only) {
ret = -EPERM;
error_setg_errno(errp, EPERM,
"VHDX image file '%s' opened read-only, but "
"contains a log that needs to be replayed. To "
"replay the log, execute:\n qemu-img check -r "
"all '%s'",
bs->filename, bs->filename);
goto exit;
}
/* now flush the log */
ret = vhdx_log_flush(bs, s, &logs);
if (ret < 0) {
goto exit;
}
*flushed = true;
}
exit:
return ret;
}
| false | qemu | bf89e87427fb99b994eb0dfb710bb4b45785f733 | int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed,
Error **errp)
{
int ret = 0;
VHDXHeader *hdr;
VHDXLogSequence logs = { 0 };
hdr = s->headers[s->curr_header];
*flushed = false;
if (s->log.hdr == NULL) {
s->log.hdr = qemu_blockalign(bs, sizeof(VHDXLogEntryHeader));
}
s->log.offset = hdr->log_offset;
s->log.length = hdr->log_length;
if (s->log.offset < VHDX_LOG_MIN_SIZE ||
s->log.offset % VHDX_LOG_MIN_SIZE) {
ret = -EINVAL;
goto exit;
}
if (hdr->log_version != 0) {
ret = -EINVAL;
goto exit;
}
if (guid_eq(hdr->log_guid, zero_guid)) {
goto exit;
}
if (hdr->log_length == 0) {
goto exit;
}
if (hdr->log_length % VHDX_LOG_MIN_SIZE) {
ret = -EINVAL;
goto exit;
}
ret = vhdx_log_search(bs, s, &logs);
if (ret < 0) {
goto exit;
}
if (logs.valid) {
if (bs->read_only) {
ret = -EPERM;
error_setg_errno(errp, EPERM,
"VHDX image file '%s' opened read-only, but "
"contains a log that needs to be replayed. To "
"replay the log, execute:\n qemu-img check -r "
"all '%s'",
bs->filename, bs->filename);
goto exit;
}
ret = vhdx_log_flush(bs, s, &logs);
if (ret < 0) {
goto exit;
}
*flushed = true;
}
exit:
return ret;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(BlockDriverState *VAR_0, BDRVVHDXState *VAR_1, bool *VAR_2,
Error **VAR_3)
{
int VAR_4 = 0;
VHDXHeader *hdr;
VHDXLogSequence logs = { 0 };
hdr = VAR_1->headers[VAR_1->curr_header];
*VAR_2 = false;
if (VAR_1->log.hdr == NULL) {
VAR_1->log.hdr = qemu_blockalign(VAR_0, sizeof(VHDXLogEntryHeader));
}
VAR_1->log.offset = hdr->log_offset;
VAR_1->log.length = hdr->log_length;
if (VAR_1->log.offset < VHDX_LOG_MIN_SIZE ||
VAR_1->log.offset % VHDX_LOG_MIN_SIZE) {
VAR_4 = -EINVAL;
goto exit;
}
if (hdr->log_version != 0) {
VAR_4 = -EINVAL;
goto exit;
}
if (guid_eq(hdr->log_guid, zero_guid)) {
goto exit;
}
if (hdr->log_length == 0) {
goto exit;
}
if (hdr->log_length % VHDX_LOG_MIN_SIZE) {
VAR_4 = -EINVAL;
goto exit;
}
VAR_4 = vhdx_log_search(VAR_0, VAR_1, &logs);
if (VAR_4 < 0) {
goto exit;
}
if (logs.valid) {
if (VAR_0->read_only) {
VAR_4 = -EPERM;
error_setg_errno(VAR_3, EPERM,
"VHDX image file '%VAR_1' opened read-only, but "
"contains a log that needs to be replayed. To "
"replay the log, execute:\n qemu-img check -r "
"all '%VAR_1'",
VAR_0->filename, VAR_0->filename);
goto exit;
}
VAR_4 = vhdx_log_flush(VAR_0, VAR_1, &logs);
if (VAR_4 < 0) {
goto exit;
}
*VAR_2 = true;
}
exit:
return VAR_4;
}
| [
"int FUNC_0(BlockDriverState *VAR_0, BDRVVHDXState *VAR_1, bool *VAR_2,\nError **VAR_3)\n{",
"int VAR_4 = 0;",
"VHDXHeader *hdr;",
"VHDXLogSequence logs = { 0 };",
"hdr = VAR_1->headers[VAR_1->curr_header];",
"*VAR_2 = false;",
"if (VAR_1->log.hdr == NULL) {",
"VAR_1->log.hdr = qemu_blockalign(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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59
... |
15,609 | static gboolean fd_trampoline(GIOChannel *chan, GIOCondition cond, gpointer opaque)
{
IOTrampoline *tramp = opaque;
if ((cond & G_IO_IN) && tramp->fd_read) {
tramp->fd_read(tramp->opaque);
}
if ((cond & G_IO_OUT) && tramp->fd_write) {
tramp->fd_write(tramp->opaque);
}
return TRUE;
}
| false | qemu | be08e65e01f1c50fa1552c4f892443cb25bb98e4 | static gboolean fd_trampoline(GIOChannel *chan, GIOCondition cond, gpointer opaque)
{
IOTrampoline *tramp = opaque;
if ((cond & G_IO_IN) && tramp->fd_read) {
tramp->fd_read(tramp->opaque);
}
if ((cond & G_IO_OUT) && tramp->fd_write) {
tramp->fd_write(tramp->opaque);
}
return TRUE;
}
| {
"code": [],
"line_no": []
} | static gboolean FUNC_0(GIOChannel *chan, GIOCondition cond, gpointer opaque)
{
IOTrampoline *tramp = opaque;
if ((cond & G_IO_IN) && tramp->fd_read) {
tramp->fd_read(tramp->opaque);
}
if ((cond & G_IO_OUT) && tramp->fd_write) {
tramp->fd_write(tramp->opaque);
}
return TRUE;
}
| [
"static gboolean FUNC_0(GIOChannel *chan, GIOCondition cond, gpointer opaque)\n{",
"IOTrampoline *tramp = opaque;",
"if ((cond & G_IO_IN) && tramp->fd_read) {",
"tramp->fd_read(tramp->opaque);",
"}",
"if ((cond & G_IO_OUT) && tramp->fd_write) {",
"tramp->fd_write(tramp->opaque);",
"}",
"return TRUE;... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
]
] |
15,610 | static void s390_virtio_serial_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
k->init = s390_virtio_serial_init;
dc->props = s390_virtio_serial_properties;
dc->alias = "virtio-serial";
}
| false | qemu | 6acbe4c6f18e7de00481ff30574262b58526de45 | static void s390_virtio_serial_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
k->init = s390_virtio_serial_init;
dc->props = s390_virtio_serial_properties;
dc->alias = "virtio-serial";
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(VAR_0);
k->init = s390_virtio_serial_init;
dc->props = s390_virtio_serial_properties;
dc->alias = "virtio-serial";
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(VAR_0);",
"k->init = s390_virtio_serial_init;",
"dc->props = s390_virtio_serial_properties;",
"dc->alias = \"virtio-serial\";",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
15,611 | static uint64_t get_fourcc(AVIOContext *bc)
{
unsigned int len = ffio_read_varlen(bc);
if (len == 2)
return avio_rl16(bc);
else if (len == 4)
return avio_rl32(bc);
else
return -1;
}
| false | FFmpeg | 7ccc0ed6a0cedbe80443779a805ec90335cd832f | static uint64_t get_fourcc(AVIOContext *bc)
{
unsigned int len = ffio_read_varlen(bc);
if (len == 2)
return avio_rl16(bc);
else if (len == 4)
return avio_rl32(bc);
else
return -1;
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(AVIOContext *bc)
{
unsigned int VAR_0 = ffio_read_varlen(bc);
if (VAR_0 == 2)
return avio_rl16(bc);
else if (VAR_0 == 4)
return avio_rl32(bc);
else
return -1;
}
| [
"static uint64_t FUNC_0(AVIOContext *bc)\n{",
"unsigned int VAR_0 = ffio_read_varlen(bc);",
"if (VAR_0 == 2)\nreturn avio_rl16(bc);",
"else if (VAR_0 == 4)\nreturn avio_rl32(bc);",
"else\nreturn -1;",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9,
11
],
[
13,
15
],
[
17,
19
],
[
21
]
] |
15,613 | void qemu_chr_be_generic_open(CharDriverState *s)
{
if (s->idle_tag == 0) {
s->idle_tag = g_idle_add(qemu_chr_be_generic_open_bh, s);
}
}
| false | qemu | bd5c51ee6c4f1c79cae5ad2516d711a27b4ea8ec | void qemu_chr_be_generic_open(CharDriverState *s)
{
if (s->idle_tag == 0) {
s->idle_tag = g_idle_add(qemu_chr_be_generic_open_bh, s);
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CharDriverState *VAR_0)
{
if (VAR_0->idle_tag == 0) {
VAR_0->idle_tag = g_idle_add(qemu_chr_be_generic_open_bh, VAR_0);
}
}
| [
"void FUNC_0(CharDriverState *VAR_0)\n{",
"if (VAR_0->idle_tag == 0) {",
"VAR_0->idle_tag = g_idle_add(qemu_chr_be_generic_open_bh, VAR_0);",
"}",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
] |
15,614 | static void write_fp_dreg(DisasContext *s, int reg, TCGv_i64 v)
{
TCGv_i64 tcg_zero = tcg_const_i64(0);
tcg_gen_st_i64(v, cpu_env, fp_reg_offset(reg, MO_64));
tcg_gen_st_i64(tcg_zero, cpu_env, fp_reg_hi_offset(reg));
tcg_temp_free_i64(tcg_zero);
}
| false | qemu | 90e496386fe7fd32c189561f846b7913f95b8cf4 | static void write_fp_dreg(DisasContext *s, int reg, TCGv_i64 v)
{
TCGv_i64 tcg_zero = tcg_const_i64(0);
tcg_gen_st_i64(v, cpu_env, fp_reg_offset(reg, MO_64));
tcg_gen_st_i64(tcg_zero, cpu_env, fp_reg_hi_offset(reg));
tcg_temp_free_i64(tcg_zero);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, int VAR_1, TCGv_i64 VAR_2)
{
TCGv_i64 tcg_zero = tcg_const_i64(0);
tcg_gen_st_i64(VAR_2, cpu_env, fp_reg_offset(VAR_1, MO_64));
tcg_gen_st_i64(tcg_zero, cpu_env, fp_reg_hi_offset(VAR_1));
tcg_temp_free_i64(tcg_zero);
}
| [
"static void FUNC_0(DisasContext *VAR_0, int VAR_1, TCGv_i64 VAR_2)\n{",
"TCGv_i64 tcg_zero = tcg_const_i64(0);",
"tcg_gen_st_i64(VAR_2, cpu_env, fp_reg_offset(VAR_1, MO_64));",
"tcg_gen_st_i64(tcg_zero, cpu_env, fp_reg_hi_offset(VAR_1));",
"tcg_temp_free_i64(tcg_zero);",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
15,616 | static int ac3_probe(AVProbeData *p)
{
int max_frames, first_frames = 0, frames;
uint8_t *buf, *buf2, *end;
AC3HeaderInfo hdr;
if(p->buf_size < 7)
return 0;
max_frames = 0;
buf = p->buf;
end = buf + p->buf_size;
for(; buf < end; buf++) {
buf2 = buf;
for(frames = 0; buf2 < end; frames++) {
if(ff_ac3_parse_header(buf2, &hdr) < 0)
break;
buf2 += hdr.frame_size;
}
max_frames = FFMAX(max_frames, frames);
if(buf == p->buf)
first_frames = frames;
}
if (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
else if(max_frames>=1) return 1;
else return 0;
}
| false | FFmpeg | d1a4544de904cc76fea32d9d22252152ebb18edb | static int ac3_probe(AVProbeData *p)
{
int max_frames, first_frames = 0, frames;
uint8_t *buf, *buf2, *end;
AC3HeaderInfo hdr;
if(p->buf_size < 7)
return 0;
max_frames = 0;
buf = p->buf;
end = buf + p->buf_size;
for(; buf < end; buf++) {
buf2 = buf;
for(frames = 0; buf2 < end; frames++) {
if(ff_ac3_parse_header(buf2, &hdr) < 0)
break;
buf2 += hdr.frame_size;
}
max_frames = FFMAX(max_frames, frames);
if(buf == p->buf)
first_frames = frames;
}
if (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
else if(max_frames>=1) return 1;
else return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVProbeData *VAR_0)
{
int VAR_1, VAR_2 = 0, VAR_3;
uint8_t *buf, *buf2, *end;
AC3HeaderInfo hdr;
if(VAR_0->buf_size < 7)
return 0;
VAR_1 = 0;
buf = VAR_0->buf;
end = buf + VAR_0->buf_size;
for(; buf < end; buf++) {
buf2 = buf;
for(VAR_3 = 0; buf2 < end; VAR_3++) {
if(ff_ac3_parse_header(buf2, &hdr) < 0)
break;
buf2 += hdr.frame_size;
}
VAR_1 = FFMAX(VAR_1, VAR_3);
if(buf == VAR_0->buf)
VAR_2 = VAR_3;
}
if (VAR_2>=3) return AVPROBE_SCORE_MAX * 3 / 4;
else if(VAR_1>=3) return AVPROBE_SCORE_MAX / 2;
else if(VAR_1>=1) return 1;
else return 0;
}
| [
"static int FUNC_0(AVProbeData *VAR_0)\n{",
"int VAR_1, VAR_2 = 0, VAR_3;",
"uint8_t *buf, *buf2, *end;",
"AC3HeaderInfo hdr;",
"if(VAR_0->buf_size < 7)\nreturn 0;",
"VAR_1 = 0;",
"buf = VAR_0->buf;",
"end = buf + VAR_0->buf_size;",
"for(; buf < end; buf++) {",
"buf2 = buf;",
"for(VAR_3 = 0; buf... | [
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
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[... |
15,617 | int init_put_byte(ByteIOContext *s,
unsigned char *buffer,
int buffer_size,
int write_flag,
void *opaque,
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
void (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
int (*seek)(void *opaque, offset_t offset, int whence))
{
s->buffer = buffer;
s->buffer_size = buffer_size;
s->buf_ptr = buffer;
s->write_flag = write_flag;
if (!s->write_flag)
s->buf_end = buffer;
else
s->buf_end = buffer + buffer_size;
s->opaque = opaque;
s->write_packet = write_packet;
s->read_packet = read_packet;
s->seek = seek;
s->pos = 0;
s->must_flush = 0;
s->eof_reached = 0;
s->is_streamed = 0;
s->max_packet_size = 0;
s->checksum_ptr= NULL;
s->update_checksum= NULL;
return 0;
}
| false | FFmpeg | 465e1dadbef7596a3eb87089a66bb4ecdc26d3c4 | int init_put_byte(ByteIOContext *s,
unsigned char *buffer,
int buffer_size,
int write_flag,
void *opaque,
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
void (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
int (*seek)(void *opaque, offset_t offset, int whence))
{
s->buffer = buffer;
s->buffer_size = buffer_size;
s->buf_ptr = buffer;
s->write_flag = write_flag;
if (!s->write_flag)
s->buf_end = buffer;
else
s->buf_end = buffer + buffer_size;
s->opaque = opaque;
s->write_packet = write_packet;
s->read_packet = read_packet;
s->seek = seek;
s->pos = 0;
s->must_flush = 0;
s->eof_reached = 0;
s->is_streamed = 0;
s->max_packet_size = 0;
s->checksum_ptr= NULL;
s->update_checksum= NULL;
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(ByteIOContext *VAR_0,
unsigned char *VAR_1,
int VAR_2,
int VAR_3,
void *VAR_10,
int (*VAR_5)(void *VAR_10, uint8_t *VAR_9, int VAR_9),
void (*VAR_8)(void *VAR_10, uint8_t *VAR_9, int VAR_9),
int (*VAR_9)(void *VAR_10, offset_t VAR_10, int VAR_11))
{
VAR_0->VAR_1 = VAR_1;
VAR_0->VAR_2 = VAR_2;
VAR_0->buf_ptr = VAR_1;
VAR_0->VAR_3 = VAR_3;
if (!VAR_0->VAR_3)
VAR_0->buf_end = VAR_1;
else
VAR_0->buf_end = VAR_1 + VAR_2;
VAR_0->VAR_10 = VAR_10;
VAR_0->VAR_8 = VAR_8;
VAR_0->VAR_5 = VAR_5;
VAR_0->VAR_9 = VAR_9;
VAR_0->pos = 0;
VAR_0->must_flush = 0;
VAR_0->eof_reached = 0;
VAR_0->is_streamed = 0;
VAR_0->max_packet_size = 0;
VAR_0->checksum_ptr= NULL;
VAR_0->update_checksum= NULL;
return 0;
}
| [
"int FUNC_0(ByteIOContext *VAR_0,\nunsigned char *VAR_1,\nint VAR_2,\nint VAR_3,\nvoid *VAR_10,\nint (*VAR_5)(void *VAR_10, uint8_t *VAR_9, int VAR_9),\nvoid (*VAR_8)(void *VAR_10, uint8_t *VAR_9, int VAR_9),\nint (*VAR_9)(void *VAR_10, offset_t VAR_10, int VAR_11))\n{",
"VAR_0->VAR_1 = VAR_1;",
"VAR_0->VAR_2 =... | [
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
],
[... |
15,618 | static void do_interrupt_v7m(CPUARMState *env)
{
uint32_t xpsr = xpsr_read(env);
uint32_t lr;
uint32_t addr;
lr = 0xfffffff1;
if (env->v7m.current_sp)
lr |= 4;
if (env->v7m.exception == 0)
lr |= 8;
/* For exceptions we just mark as pending on the NVIC, and let that
handle it. */
/* TODO: Need to escalate if the current priority is higher than the
one we're raising. */
switch (env->exception_index) {
case EXCP_UDEF:
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE);
return;
case EXCP_SWI:
env->regs[15] += 2;
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SVC);
return;
case EXCP_PREFETCH_ABORT:
case EXCP_DATA_ABORT:
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_MEM);
return;
case EXCP_BKPT:
if (semihosting_enabled) {
int nr;
nr = lduw_code(env->regs[15]) & 0xff;
if (nr == 0xab) {
env->regs[15] += 2;
env->regs[0] = do_arm_semihosting(env);
return;
}
}
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_DEBUG);
return;
case EXCP_IRQ:
env->v7m.exception = armv7m_nvic_acknowledge_irq(env->nvic);
break;
case EXCP_EXCEPTION_EXIT:
do_v7m_exception_exit(env);
return;
default:
cpu_abort(env, "Unhandled exception 0x%x\n", env->exception_index);
return; /* Never happens. Keep compiler happy. */
}
/* Align stack pointer. */
/* ??? Should only do this if Configuration Control Register
STACKALIGN bit is set. */
if (env->regs[13] & 4) {
env->regs[13] -= 4;
xpsr |= 0x200;
}
/* Switch to the handler mode. */
v7m_push(env, xpsr);
v7m_push(env, env->regs[15]);
v7m_push(env, env->regs[14]);
v7m_push(env, env->regs[12]);
v7m_push(env, env->regs[3]);
v7m_push(env, env->regs[2]);
v7m_push(env, env->regs[1]);
v7m_push(env, env->regs[0]);
switch_v7m_sp(env, 0);
/* Clear IT bits */
env->condexec_bits = 0;
env->regs[14] = lr;
addr = ldl_phys(env->v7m.vecbase + env->v7m.exception * 4);
env->regs[15] = addr & 0xfffffffe;
env->thumb = addr & 1;
}
| true | qemu | d8fd2954996255ba6ad610917e7849832d0120b7 | static void do_interrupt_v7m(CPUARMState *env)
{
uint32_t xpsr = xpsr_read(env);
uint32_t lr;
uint32_t addr;
lr = 0xfffffff1;
if (env->v7m.current_sp)
lr |= 4;
if (env->v7m.exception == 0)
lr |= 8;
switch (env->exception_index) {
case EXCP_UDEF:
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_USAGE);
return;
case EXCP_SWI:
env->regs[15] += 2;
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_SVC);
return;
case EXCP_PREFETCH_ABORT:
case EXCP_DATA_ABORT:
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_MEM);
return;
case EXCP_BKPT:
if (semihosting_enabled) {
int nr;
nr = lduw_code(env->regs[15]) & 0xff;
if (nr == 0xab) {
env->regs[15] += 2;
env->regs[0] = do_arm_semihosting(env);
return;
}
}
armv7m_nvic_set_pending(env->nvic, ARMV7M_EXCP_DEBUG);
return;
case EXCP_IRQ:
env->v7m.exception = armv7m_nvic_acknowledge_irq(env->nvic);
break;
case EXCP_EXCEPTION_EXIT:
do_v7m_exception_exit(env);
return;
default:
cpu_abort(env, "Unhandled exception 0x%x\n", env->exception_index);
return;
}
if (env->regs[13] & 4) {
env->regs[13] -= 4;
xpsr |= 0x200;
}
v7m_push(env, xpsr);
v7m_push(env, env->regs[15]);
v7m_push(env, env->regs[14]);
v7m_push(env, env->regs[12]);
v7m_push(env, env->regs[3]);
v7m_push(env, env->regs[2]);
v7m_push(env, env->regs[1]);
v7m_push(env, env->regs[0]);
switch_v7m_sp(env, 0);
env->condexec_bits = 0;
env->regs[14] = lr;
addr = ldl_phys(env->v7m.vecbase + env->v7m.exception * 4);
env->regs[15] = addr & 0xfffffffe;
env->thumb = addr & 1;
}
| {
"code": [
" nr = lduw_code(env->regs[15]) & 0xff;"
],
"line_no": [
63
]
} | static void FUNC_0(CPUARMState *VAR_0)
{
uint32_t xpsr = xpsr_read(VAR_0);
uint32_t lr;
uint32_t addr;
lr = 0xfffffff1;
if (VAR_0->v7m.current_sp)
lr |= 4;
if (VAR_0->v7m.exception == 0)
lr |= 8;
switch (VAR_0->exception_index) {
case EXCP_UDEF:
armv7m_nvic_set_pending(VAR_0->nvic, ARMV7M_EXCP_USAGE);
return;
case EXCP_SWI:
VAR_0->regs[15] += 2;
armv7m_nvic_set_pending(VAR_0->nvic, ARMV7M_EXCP_SVC);
return;
case EXCP_PREFETCH_ABORT:
case EXCP_DATA_ABORT:
armv7m_nvic_set_pending(VAR_0->nvic, ARMV7M_EXCP_MEM);
return;
case EXCP_BKPT:
if (semihosting_enabled) {
int VAR_1;
VAR_1 = lduw_code(VAR_0->regs[15]) & 0xff;
if (VAR_1 == 0xab) {
VAR_0->regs[15] += 2;
VAR_0->regs[0] = do_arm_semihosting(VAR_0);
return;
}
}
armv7m_nvic_set_pending(VAR_0->nvic, ARMV7M_EXCP_DEBUG);
return;
case EXCP_IRQ:
VAR_0->v7m.exception = armv7m_nvic_acknowledge_irq(VAR_0->nvic);
break;
case EXCP_EXCEPTION_EXIT:
do_v7m_exception_exit(VAR_0);
return;
default:
cpu_abort(VAR_0, "Unhandled exception 0x%x\n", VAR_0->exception_index);
return;
}
if (VAR_0->regs[13] & 4) {
VAR_0->regs[13] -= 4;
xpsr |= 0x200;
}
v7m_push(VAR_0, xpsr);
v7m_push(VAR_0, VAR_0->regs[15]);
v7m_push(VAR_0, VAR_0->regs[14]);
v7m_push(VAR_0, VAR_0->regs[12]);
v7m_push(VAR_0, VAR_0->regs[3]);
v7m_push(VAR_0, VAR_0->regs[2]);
v7m_push(VAR_0, VAR_0->regs[1]);
v7m_push(VAR_0, VAR_0->regs[0]);
switch_v7m_sp(VAR_0, 0);
VAR_0->condexec_bits = 0;
VAR_0->regs[14] = lr;
addr = ldl_phys(VAR_0->v7m.vecbase + VAR_0->v7m.exception * 4);
VAR_0->regs[15] = addr & 0xfffffffe;
VAR_0->thumb = addr & 1;
}
| [
"static void FUNC_0(CPUARMState *VAR_0)\n{",
"uint32_t xpsr = xpsr_read(VAR_0);",
"uint32_t lr;",
"uint32_t addr;",
"lr = 0xfffffff1;",
"if (VAR_0->v7m.current_sp)\nlr |= 4;",
"if (VAR_0->v7m.exception == 0)\nlr |= 8;",
"switch (VAR_0->exception_index) {",
"case EXCP_UDEF:\narmv7m_nvic_set_pending(V... | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
19,
21
],
[
33
],
[
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49,
51,
53
],
[
55
],
[
57,
59
],
[... |
15,619 | static int aac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AACContext *ac = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
int buf_consumed;
int buf_offset;
int err;
int new_extradata_size;
const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
AV_PKT_DATA_NEW_EXTRADATA,
&new_extradata_size);
int jp_dualmono_size;
const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
AV_PKT_DATA_JP_DUALMONO,
&jp_dualmono_size);
if (new_extradata && 0) {
av_free(avctx->extradata);
avctx->extradata = av_mallocz(new_extradata_size +
FF_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata)
return AVERROR(ENOMEM);
avctx->extradata_size = new_extradata_size;
memcpy(avctx->extradata, new_extradata, new_extradata_size);
push_output_configuration(ac);
if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
avctx->extradata,
avctx->extradata_size*8, 1) < 0) {
pop_output_configuration(ac);
}
}
ac->dmono_mode = 0;
if (jp_dualmono && jp_dualmono_size > 0)
ac->dmono_mode = 1 + *jp_dualmono;
if (ac->force_dmono_mode >= 0)
ac->dmono_mode = ac->force_dmono_mode;
init_get_bits(&gb, buf, buf_size * 8);
if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt)) < 0)
return err;
buf_consumed = (get_bits_count(&gb) + 7) >> 3;
for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
if (buf[buf_offset])
break;
return buf_size > buf_offset ? buf_consumed : buf_size;
} | true | FFmpeg | b563afe6fa9345a62750055998a28a3926c02334 | static int aac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AACContext *ac = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
int buf_consumed;
int buf_offset;
int err;
int new_extradata_size;
const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
AV_PKT_DATA_NEW_EXTRADATA,
&new_extradata_size);
int jp_dualmono_size;
const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
AV_PKT_DATA_JP_DUALMONO,
&jp_dualmono_size);
if (new_extradata && 0) {
av_free(avctx->extradata);
avctx->extradata = av_mallocz(new_extradata_size +
FF_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata)
return AVERROR(ENOMEM);
avctx->extradata_size = new_extradata_size;
memcpy(avctx->extradata, new_extradata, new_extradata_size);
push_output_configuration(ac);
if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
avctx->extradata,
avctx->extradata_size*8, 1) < 0) {
pop_output_configuration(ac);
}
}
ac->dmono_mode = 0;
if (jp_dualmono && jp_dualmono_size > 0)
ac->dmono_mode = 1 + *jp_dualmono;
if (ac->force_dmono_mode >= 0)
ac->dmono_mode = ac->force_dmono_mode;
init_get_bits(&gb, buf, buf_size * 8);
if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt)) < 0)
return err;
buf_consumed = (get_bits_count(&gb) + 7) >> 3;
for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
if (buf[buf_offset])
break;
return buf_size > buf_offset ? buf_consumed : buf_size;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,
int *VAR_2, AVPacket *VAR_3)
{
AACContext *ac = VAR_0->priv_data;
const uint8_t *VAR_4 = VAR_3->VAR_1;
int VAR_5 = VAR_3->size;
GetBitContext gb;
int VAR_6;
int VAR_7;
int VAR_8;
int VAR_9;
const uint8_t *VAR_10 = av_packet_get_side_data(VAR_3,
AV_PKT_DATA_NEW_EXTRADATA,
&VAR_9);
int VAR_11;
const uint8_t *VAR_12 = av_packet_get_side_data(VAR_3,
AV_PKT_DATA_JP_DUALMONO,
&VAR_11);
if (VAR_10 && 0) {
av_free(VAR_0->extradata);
VAR_0->extradata = av_mallocz(VAR_9 +
FF_INPUT_BUFFER_PADDING_SIZE);
if (!VAR_0->extradata)
return AVERROR(ENOMEM);
VAR_0->extradata_size = VAR_9;
memcpy(VAR_0->extradata, VAR_10, VAR_9);
push_output_configuration(ac);
if (decode_audio_specific_config(ac, ac->VAR_0, &ac->oc[1].m4ac,
VAR_0->extradata,
VAR_0->extradata_size*8, 1) < 0) {
pop_output_configuration(ac);
}
}
ac->dmono_mode = 0;
if (VAR_12 && VAR_11 > 0)
ac->dmono_mode = 1 + *VAR_12;
if (ac->force_dmono_mode >= 0)
ac->dmono_mode = ac->force_dmono_mode;
init_get_bits(&gb, VAR_4, VAR_5 * 8);
if ((VAR_8 = aac_decode_frame_int(VAR_0, VAR_1, VAR_2, &gb, VAR_3)) < 0)
return VAR_8;
VAR_6 = (get_bits_count(&gb) + 7) >> 3;
for (VAR_7 = VAR_6; VAR_7 < VAR_5; VAR_7++)
if (VAR_4[VAR_7])
break;
return VAR_5 > VAR_7 ? VAR_6 : VAR_5;
} | [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{",
"AACContext *ac = VAR_0->priv_data;",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"GetBitContext gb;",
"int VAR_6;",
"int VAR_7;",
"int VAR_8;",
"int VAR_9;",
"const uint8_t *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
] | [
[
1,
2,
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12,
13,
14
],
[
15
],
[
16,
17,
18
],
[
19
],
[
20
],
[
21,
22
],
[
23,
24
],
[
... |
15,620 | static void block_job_unref(BlockJob *job)
{
if (--job->refcnt == 0) {
BlockDriverState *bs = blk_bs(job->blk);
bs->job = NULL;
block_job_remove_all_bdrv(job);
blk_remove_aio_context_notifier(job->blk,
block_job_attached_aio_context,
block_job_detach_aio_context, job);
blk_unref(job->blk);
error_free(job->blocker);
g_free(job->id);
QLIST_REMOVE(job, job_list);
g_free(job);
}
}
| true | qemu | 4172a00373b2c81374293becc02b16b7f8c76659 | static void block_job_unref(BlockJob *job)
{
if (--job->refcnt == 0) {
BlockDriverState *bs = blk_bs(job->blk);
bs->job = NULL;
block_job_remove_all_bdrv(job);
blk_remove_aio_context_notifier(job->blk,
block_job_attached_aio_context,
block_job_detach_aio_context, job);
blk_unref(job->blk);
error_free(job->blocker);
g_free(job->id);
QLIST_REMOVE(job, job_list);
g_free(job);
}
}
| {
"code": [
"static void block_job_unref(BlockJob *job)"
],
"line_no": [
1
]
} | static void FUNC_0(BlockJob *VAR_0)
{
if (--VAR_0->refcnt == 0) {
BlockDriverState *bs = blk_bs(VAR_0->blk);
bs->VAR_0 = NULL;
block_job_remove_all_bdrv(VAR_0);
blk_remove_aio_context_notifier(VAR_0->blk,
block_job_attached_aio_context,
block_job_detach_aio_context, VAR_0);
blk_unref(VAR_0->blk);
error_free(VAR_0->blocker);
g_free(VAR_0->id);
QLIST_REMOVE(VAR_0, job_list);
g_free(VAR_0);
}
}
| [
"static void FUNC_0(BlockJob *VAR_0)\n{",
"if (--VAR_0->refcnt == 0) {",
"BlockDriverState *bs = blk_bs(VAR_0->blk);",
"bs->VAR_0 = NULL;",
"block_job_remove_all_bdrv(VAR_0);",
"blk_remove_aio_context_notifier(VAR_0->blk,\nblock_job_attached_aio_context,\nblock_job_detach_aio_context, VAR_0);",
"blk_unr... | [
1,
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
]
] |
15,621 | static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int packet_size, ret, width, height;
AVStream *st = s->streams[0];
width = st->codec->width;
height = st->codec->height;
packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
if (packet_size < 0)
return -1;
ret= av_get_packet(s->pb, pkt, packet_size);
pkt->pts=
pkt->dts= pkt->pos / packet_size;
pkt->stream_index = 0;
if (ret != packet_size)
return AVERROR(EIO);
return 0;
}
| true | FFmpeg | 22a7e19b50cc1627dd16e22c5e89b1f92f1d0c0e | static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int packet_size, ret, width, height;
AVStream *st = s->streams[0];
width = st->codec->width;
height = st->codec->height;
packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
if (packet_size < 0)
return -1;
ret= av_get_packet(s->pb, pkt, packet_size);
pkt->pts=
pkt->dts= pkt->pos / packet_size;
pkt->stream_index = 0;
if (ret != packet_size)
return AVERROR(EIO);
return 0;
}
| {
"code": [
" if (ret != packet_size)"
],
"line_no": [
35
]
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
int VAR_2, VAR_3, VAR_4, VAR_5;
AVStream *st = VAR_0->streams[0];
VAR_4 = st->codec->VAR_4;
VAR_5 = st->codec->VAR_5;
VAR_2 = avpicture_get_size(st->codec->pix_fmt, VAR_4, VAR_5);
if (VAR_2 < 0)
return -1;
VAR_3= av_get_packet(VAR_0->pb, VAR_1, VAR_2);
VAR_1->pts=
VAR_1->dts= VAR_1->pos / VAR_2;
VAR_1->stream_index = 0;
if (VAR_3 != VAR_2)
return AVERROR(EIO);
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4, VAR_5;",
"AVStream *st = VAR_0->streams[0];",
"VAR_4 = st->codec->VAR_4;",
"VAR_5 = st->codec->VAR_5;",
"VAR_2 = avpicture_get_size(st->codec->pix_fmt, VAR_4, VAR_5);",
"if (VAR_2 < 0)\nreturn -1;",
"VAR_3= av_g... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19,
21
],
[
25
],
[
27,
29
],
[
33
],
[
35,
37
],
[
39
],
[
41
]
] |
15,623 | static int mpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
Mpeg1Context *s = avctx->priv_data;
AVFrame *picture = data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
av_dlog(avctx, "fill_buffer\n");
if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
/* special case for last picture */
if (s2->low_delay == 0 && s2->next_picture_ptr) {
*picture = s2->next_picture_ptr->f;
s2->next_picture_ptr = NULL;
*data_size = sizeof(AVFrame);
}
return buf_size;
}
if (s2->flags & CODEC_FLAG_TRUNCATED) {
int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
if (ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0)
return buf_size;
}
s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
|| s2->codec_tag == AV_RL32("BW10")
))
vcr2_init_sequence(avctx);
s->slice_count = 0;
if (avctx->extradata && !avctx->frame_number) {
int ret = decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
return ret;
}
return decode_chunks(avctx, picture, data_size, buf, buf_size);
} | true | FFmpeg | 951cbea56fdc03ef96d07fbd7e5bed755d42ac8a | static int mpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
Mpeg1Context *s = avctx->priv_data;
AVFrame *picture = data;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
av_dlog(avctx, "fill_buffer\n");
if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
if (s2->low_delay == 0 && s2->next_picture_ptr) {
*picture = s2->next_picture_ptr->f;
s2->next_picture_ptr = NULL;
*data_size = sizeof(AVFrame);
}
return buf_size;
}
if (s2->flags & CODEC_FLAG_TRUNCATED) {
int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size, NULL);
if (ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0)
return buf_size;
}
s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
|| s2->codec_tag == AV_RL32("BW10")
))
vcr2_init_sequence(avctx);
s->slice_count = 0;
if (avctx->extradata && !avctx->frame_number) {
int ret = decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
return ret;
}
return decode_chunks(avctx, picture, data_size, buf, buf_size);
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{
const uint8_t *VAR_4 = VAR_3->VAR_1;
int VAR_5 = VAR_3->size;
Mpeg1Context *s = VAR_0->priv_data;
AVFrame *picture = VAR_1;
MpegEncContext *s2 = &s->mpeg_enc_ctx;
av_dlog(VAR_0, "fill_buffer\n");
if (VAR_5 == 0 || (VAR_5 == 4 && AV_RB32(VAR_4) == SEQ_END_CODE)) {
if (s2->low_delay == 0 && s2->next_picture_ptr) {
*picture = s2->next_picture_ptr->f;
s2->next_picture_ptr = NULL;
*VAR_2 = sizeof(AVFrame);
}
return VAR_5;
}
if (s2->flags & CODEC_FLAG_TRUNCATED) {
int VAR_6 = ff_mpeg1_find_frame_end(&s2->parse_context, VAR_4, VAR_5, NULL);
if (ff_combine_frame(&s2->parse_context, VAR_6, (const uint8_t **)&VAR_4, &VAR_5) < 0)
return VAR_5;
}
s2->codec_tag = avpriv_toupper4(VAR_0->codec_tag);
if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
|| s2->codec_tag == AV_RL32("BW10")
))
vcr2_init_sequence(VAR_0);
s->slice_count = 0;
if (VAR_0->extradata && !VAR_0->frame_number) {
int VAR_7 = decode_chunks(VAR_0, picture, VAR_2, VAR_0->extradata, VAR_0->extradata_size);
if (VAR_7 < 0 && (VAR_0->err_recognition & AV_EF_EXPLODE))
return VAR_7;
}
return decode_chunks(VAR_0, picture, VAR_2, VAR_4, VAR_5);
} | [
"static 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;",
"Mpeg1Context *s = VAR_0->priv_data;",
"AVFrame *picture = VAR_1;",
"MpegEncContext *s2 = &s->mpeg_enc_ctx;",
"av_dlog(VAR_0, \"fill_buffer\\n\")... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
51,
53
],
[... |
15,624 | void ff_h264_remove_all_refs(H264Context *h)
{
int i;
for (i = 0; i < 16; i++) {
remove_long(h, i, 0);
}
assert(h->long_ref_count == 0);
if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
ff_h264_unref_picture(h, &h->last_pic_for_ec);
if (h->short_ref[0]->f->buf[0])
ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
}
for (i = 0; i < h->short_ref_count; i++) {
unreference_pic(h, h->short_ref[i], 0);
h->short_ref[i] = NULL;
}
h->short_ref_count = 0;
memset(h->default_ref, 0, sizeof(h->default_ref));
}
| true | FFmpeg | b6eaa3928e198554a3934dd5ad6eac4d16f27df2 | void ff_h264_remove_all_refs(H264Context *h)
{
int i;
for (i = 0; i < 16; i++) {
remove_long(h, i, 0);
}
assert(h->long_ref_count == 0);
if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
ff_h264_unref_picture(h, &h->last_pic_for_ec);
if (h->short_ref[0]->f->buf[0])
ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
}
for (i = 0; i < h->short_ref_count; i++) {
unreference_pic(h, h->short_ref[i], 0);
h->short_ref[i] = NULL;
}
h->short_ref_count = 0;
memset(h->default_ref, 0, sizeof(h->default_ref));
}
| {
"code": [
" if (h->short_ref[0]->f->buf[0])",
" ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);"
],
"line_no": [
23,
25
]
} | void FUNC_0(H264Context *VAR_0)
{
int VAR_1;
for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {
remove_long(VAR_0, VAR_1, 0);
}
assert(VAR_0->long_ref_count == 0);
if (VAR_0->short_ref_count && !VAR_0->last_pic_for_ec.f->data[0]) {
ff_h264_unref_picture(VAR_0, &VAR_0->last_pic_for_ec);
if (VAR_0->short_ref[0]->f->buf[0])
ff_h264_ref_picture(VAR_0, &VAR_0->last_pic_for_ec, VAR_0->short_ref[0]);
}
for (VAR_1 = 0; VAR_1 < VAR_0->short_ref_count; VAR_1++) {
unreference_pic(VAR_0, VAR_0->short_ref[VAR_1], 0);
VAR_0->short_ref[VAR_1] = NULL;
}
VAR_0->short_ref_count = 0;
memset(VAR_0->default_ref, 0, sizeof(VAR_0->default_ref));
}
| [
"void FUNC_0(H264Context *VAR_0)\n{",
"int VAR_1;",
"for (VAR_1 = 0; VAR_1 < 16; VAR_1++) {",
"remove_long(VAR_0, VAR_1, 0);",
"}",
"assert(VAR_0->long_ref_count == 0);",
"if (VAR_0->short_ref_count && !VAR_0->last_pic_for_ec.f->data[0]) {",
"ff_h264_unref_picture(VAR_0, &VAR_0->last_pic_for_ec);",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
]
] |
15,625 | static int oss_init_in (HWVoiceIn *hw, struct audsettings *as)
{
OSSVoiceIn *oss = (OSSVoiceIn *) hw;
struct oss_params req, obt;
int endianness;
int err;
int fd;
audfmt_e effective_fmt;
struct audsettings obt_as;
oss->fd = -1;
req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
req.freq = as->freq;
req.nchannels = as->nchannels;
req.fragsize = conf.fragsize;
req.nfrags = conf.nfrags;
if (oss_open (1, &req, &obt, &fd)) {
return -1;
}
err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
if (err) {
oss_anal_close (&fd);
return -1;
}
obt_as.freq = obt.freq;
obt_as.nchannels = obt.nchannels;
obt_as.fmt = effective_fmt;
obt_as.endianness = endianness;
audio_pcm_init_info (&hw->info, &obt_as);
oss->nfrags = obt.nfrags;
oss->fragsize = obt.fragsize;
if (obt.nfrags * obt.fragsize & hw->info.align) {
dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
obt.nfrags * obt.fragsize, hw->info.align + 1);
}
hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift;
oss->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
if (!oss->pcm_buf) {
dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
hw->samples, 1 << hw->info.shift);
oss_anal_close (&fd);
return -1;
}
oss->fd = fd;
return 0;
}
| true | qemu | 5706db1deb061ee9affdcea81e59c4c2cad7c41e | static int oss_init_in (HWVoiceIn *hw, struct audsettings *as)
{
OSSVoiceIn *oss = (OSSVoiceIn *) hw;
struct oss_params req, obt;
int endianness;
int err;
int fd;
audfmt_e effective_fmt;
struct audsettings obt_as;
oss->fd = -1;
req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
req.freq = as->freq;
req.nchannels = as->nchannels;
req.fragsize = conf.fragsize;
req.nfrags = conf.nfrags;
if (oss_open (1, &req, &obt, &fd)) {
return -1;
}
err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
if (err) {
oss_anal_close (&fd);
return -1;
}
obt_as.freq = obt.freq;
obt_as.nchannels = obt.nchannels;
obt_as.fmt = effective_fmt;
obt_as.endianness = endianness;
audio_pcm_init_info (&hw->info, &obt_as);
oss->nfrags = obt.nfrags;
oss->fragsize = obt.fragsize;
if (obt.nfrags * obt.fragsize & hw->info.align) {
dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
obt.nfrags * obt.fragsize, hw->info.align + 1);
}
hw->samples = (obt.nfrags * obt.fragsize) >> hw->info.shift;
oss->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
if (!oss->pcm_buf) {
dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
hw->samples, 1 << hw->info.shift);
oss_anal_close (&fd);
return -1;
}
oss->fd = fd;
return 0;
}
| {
"code": [
"static int oss_init_in (HWVoiceIn *hw, struct audsettings *as)"
],
"line_no": [
1
]
} | static int FUNC_0 (HWVoiceIn *VAR_0, struct audsettings *VAR_1)
{
OSSVoiceIn *oss = (OSSVoiceIn *) VAR_0;
struct oss_params VAR_2, VAR_3;
int VAR_4;
int VAR_5;
int VAR_6;
audfmt_e effective_fmt;
struct audsettings VAR_7;
oss->VAR_6 = -1;
VAR_2.fmt = aud_to_ossfmt (VAR_1->fmt, VAR_1->VAR_4);
VAR_2.freq = VAR_1->freq;
VAR_2.nchannels = VAR_1->nchannels;
VAR_2.fragsize = conf.fragsize;
VAR_2.nfrags = conf.nfrags;
if (oss_open (1, &VAR_2, &VAR_3, &VAR_6)) {
return -1;
}
VAR_5 = oss_to_audfmt (VAR_3.fmt, &effective_fmt, &VAR_4);
if (VAR_5) {
oss_anal_close (&VAR_6);
return -1;
}
VAR_7.freq = VAR_3.freq;
VAR_7.nchannels = VAR_3.nchannels;
VAR_7.fmt = effective_fmt;
VAR_7.VAR_4 = VAR_4;
audio_pcm_init_info (&VAR_0->info, &VAR_7);
oss->nfrags = VAR_3.nfrags;
oss->fragsize = VAR_3.fragsize;
if (VAR_3.nfrags * VAR_3.fragsize & VAR_0->info.align) {
dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
VAR_3.nfrags * VAR_3.fragsize, VAR_0->info.align + 1);
}
VAR_0->samples = (VAR_3.nfrags * VAR_3.fragsize) >> VAR_0->info.shift;
oss->pcm_buf = audio_calloc (AUDIO_FUNC, VAR_0->samples, 1 << VAR_0->info.shift);
if (!oss->pcm_buf) {
dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
VAR_0->samples, 1 << VAR_0->info.shift);
oss_anal_close (&VAR_6);
return -1;
}
oss->VAR_6 = VAR_6;
return 0;
}
| [
"static int FUNC_0 (HWVoiceIn *VAR_0, struct audsettings *VAR_1)\n{",
"OSSVoiceIn *oss = (OSSVoiceIn *) VAR_0;",
"struct oss_params VAR_2, VAR_3;",
"int VAR_4;",
"int VAR_5;",
"int VAR_6;",
"audfmt_e effective_fmt;",
"struct audsettings VAR_7;",
"oss->VAR_6 = -1;",
"VAR_2.fmt = aud_to_ossfmt (VAR_... | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
... |
15,626 | int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
{
int i;
int usesVFilter, usesHFilter;
int unscaled;
SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
int srcW= c->srcW;
int srcH= c->srcH;
int dstW= c->dstW;
int dstH= c->dstH;
int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 16, 16), dst_stride_px = dst_stride >> 1;
int flags, cpu_flags;
enum PixelFormat srcFormat= c->srcFormat;
enum PixelFormat dstFormat= c->dstFormat;
cpu_flags = av_get_cpu_flags();
flags = c->flags;
emms_c();
if (!rgb15to16) sws_rgb2rgb_init();
unscaled = (srcW == dstW && srcH == dstH);
if (!isSupportedIn(srcFormat)) {
av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n", sws_format_name(srcFormat));
return AVERROR(EINVAL);
}
if (!isSupportedOut(dstFormat)) {
av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n", sws_format_name(dstFormat));
return AVERROR(EINVAL);
}
i= flags & ( SWS_POINT
|SWS_AREA
|SWS_BILINEAR
|SWS_FAST_BILINEAR
|SWS_BICUBIC
|SWS_X
|SWS_GAUSS
|SWS_LANCZOS
|SWS_SINC
|SWS_SPLINE
|SWS_BICUBLIN);
if(!i || (i & (i-1))) {
av_log(c, AV_LOG_ERROR, "Exactly one scaler algorithm must be chosen\n");
return AVERROR(EINVAL);
}
/* sanity check */
if (srcW<4 || srcH<1 || dstW<8 || dstH<1) { //FIXME check if these are enough and try to lowwer them after fixing the relevant parts of the code
av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
srcW, srcH, dstW, dstH);
return AVERROR(EINVAL);
}
if (!dstFilter) dstFilter= &dummyFilter;
if (!srcFilter) srcFilter= &dummyFilter;
c->lumXInc= ((srcW<<16) + (dstW>>1))/dstW;
c->lumYInc= ((srcH<<16) + (dstH>>1))/dstH;
c->dstFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[dstFormat]);
c->srcFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[srcFormat]);
c->vRounder= 4* 0x0001000100010001ULL;
usesVFilter = (srcFilter->lumV && srcFilter->lumV->length>1) ||
(srcFilter->chrV && srcFilter->chrV->length>1) ||
(dstFilter->lumV && dstFilter->lumV->length>1) ||
(dstFilter->chrV && dstFilter->chrV->length>1);
usesHFilter = (srcFilter->lumH && srcFilter->lumH->length>1) ||
(srcFilter->chrH && srcFilter->chrH->length>1) ||
(dstFilter->lumH && dstFilter->lumH->length>1) ||
(dstFilter->chrH && dstFilter->chrH->length>1);
getSubSampleFactors(&c->chrSrcHSubSample, &c->chrSrcVSubSample, srcFormat);
getSubSampleFactors(&c->chrDstHSubSample, &c->chrDstVSubSample, dstFormat);
// reuse chroma for 2 pixels RGB/BGR unless user wants full chroma interpolation
if (flags & SWS_FULL_CHR_H_INT &&
dstFormat != PIX_FMT_RGBA &&
dstFormat != PIX_FMT_ARGB &&
dstFormat != PIX_FMT_BGRA &&
dstFormat != PIX_FMT_ABGR &&
dstFormat != PIX_FMT_RGB24 &&
dstFormat != PIX_FMT_BGR24) {
av_log(c, AV_LOG_ERROR,
"full chroma interpolation for destination format '%s' not yet implemented\n",
sws_format_name(dstFormat));
flags &= ~SWS_FULL_CHR_H_INT;
c->flags = flags;
}
if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) c->chrDstHSubSample=1;
// drop some chroma lines if the user wants it
c->vChrDrop= (flags&SWS_SRC_V_CHR_DROP_MASK)>>SWS_SRC_V_CHR_DROP_SHIFT;
c->chrSrcVSubSample+= c->vChrDrop;
// drop every other pixel for chroma calculation unless user wants full chroma
if (isAnyRGB(srcFormat) && !(flags&SWS_FULL_CHR_H_INP)
&& srcFormat!=PIX_FMT_RGB8 && srcFormat!=PIX_FMT_BGR8
&& srcFormat!=PIX_FMT_RGB4 && srcFormat!=PIX_FMT_BGR4
&& srcFormat!=PIX_FMT_RGB4_BYTE && srcFormat!=PIX_FMT_BGR4_BYTE
&& ((dstW>>c->chrDstHSubSample) <= (srcW>>1) || (flags&SWS_FAST_BILINEAR)))
c->chrSrcHSubSample=1;
// Note the -((-x)>>y) is so that we always round toward +inf.
c->chrSrcW= -((-srcW) >> c->chrSrcHSubSample);
c->chrSrcH= -((-srcH) >> c->chrSrcVSubSample);
c->chrDstW= -((-dstW) >> c->chrDstHSubSample);
c->chrDstH= -((-dstH) >> c->chrDstVSubSample);
/* unscaled special cases */
if (unscaled && !usesHFilter && !usesVFilter && (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
ff_get_unscaled_swscale(c);
if (c->swScale) {
if (flags&SWS_PRINT_INFO)
av_log(c, AV_LOG_INFO, "using unscaled %s -> %s special converter\n",
sws_format_name(srcFormat), sws_format_name(dstFormat));
return 0;
}
}
c->scalingBpp = FFMAX(av_pix_fmt_descriptors[srcFormat].comp[0].depth_minus1,
av_pix_fmt_descriptors[dstFormat].comp[0].depth_minus1) >= 8 ? 16 : 8;
if (c->scalingBpp == 16)
dst_stride <<= 1;
FF_ALLOC_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW, 16) * 2 * c->scalingBpp >> 3, fail);
if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2 && c->scalingBpp == 8) {
c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
if (!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR)) {
if (flags&SWS_PRINT_INFO)
av_log(c, AV_LOG_INFO, "output width is not a multiple of 32 -> no MMX2 scaler\n");
}
if (usesHFilter) c->canMMX2BeUsed=0;
}
else
c->canMMX2BeUsed=0;
c->chrXInc= ((c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;
c->chrYInc= ((c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;
// match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
// but only for the FAST_BILINEAR mode otherwise do correct scaling
// n-2 is the last chrominance sample available
// this is not perfect, but no one should notice the difference, the more correct variant
// would be like the vertical one, but that would require some special code for the
// first and last pixel
if (flags&SWS_FAST_BILINEAR) {
if (c->canMMX2BeUsed) {
c->lumXInc+= 20;
c->chrXInc+= 20;
}
//we don't use the x86 asm scaler if MMX is available
else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
c->chrXInc = ((c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;
}
}
/* precalculate horizontal scaler filter coefficients */
{
#if HAVE_MMX2
// can't downscale !!!
if (c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR)) {
c->lumMmx2FilterCodeSize = initMMX2HScaler( dstW, c->lumXInc, NULL, NULL, NULL, 8);
c->chrMmx2FilterCodeSize = initMMX2HScaler(c->chrDstW, c->chrXInc, NULL, NULL, NULL, 4);
#ifdef MAP_ANONYMOUS
c->lumMmx2FilterCode = mmap(NULL, c->lumMmx2FilterCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
c->chrMmx2FilterCode = mmap(NULL, c->chrMmx2FilterCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
#elif HAVE_VIRTUALALLOC
c->lumMmx2FilterCode = VirtualAlloc(NULL, c->lumMmx2FilterCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
c->chrMmx2FilterCode = VirtualAlloc(NULL, c->chrMmx2FilterCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
#else
c->lumMmx2FilterCode = av_malloc(c->lumMmx2FilterCodeSize);
c->chrMmx2FilterCode = av_malloc(c->chrMmx2FilterCodeSize);
#endif
if (!c->lumMmx2FilterCode || !c->chrMmx2FilterCode)
return AVERROR(ENOMEM);
FF_ALLOCZ_OR_GOTO(c, c->hLumFilter , (dstW /8+8)*sizeof(int16_t), fail);
FF_ALLOCZ_OR_GOTO(c, c->hChrFilter , (c->chrDstW /4+8)*sizeof(int16_t), fail);
FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW /2/8+8)*sizeof(int32_t), fail);
FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW/2/4+8)*sizeof(int32_t), fail);
initMMX2HScaler( dstW, c->lumXInc, c->lumMmx2FilterCode, c->hLumFilter, c->hLumFilterPos, 8);
initMMX2HScaler(c->chrDstW, c->chrXInc, c->chrMmx2FilterCode, c->hChrFilter, c->hChrFilterPos, 4);
#ifdef MAP_ANONYMOUS
mprotect(c->lumMmx2FilterCode, c->lumMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
mprotect(c->chrMmx2FilterCode, c->chrMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
#endif
} else
#endif /* HAVE_MMX2 */
{
const int filterAlign=
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? 4 :
(HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) ? 8 :
1;
if (initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
srcW , dstW, filterAlign, 1<<14,
(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags, cpu_flags,
srcFilter->lumH, dstFilter->lumH, c->param) < 0)
goto fail;
if (initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
c->chrSrcW, c->chrDstW, filterAlign, 1<<14,
(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags, cpu_flags,
srcFilter->chrH, dstFilter->chrH, c->param) < 0)
goto fail;
}
} // initialize horizontal stuff
/* precalculate vertical scaler filter coefficients */
{
const int filterAlign=
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) && (flags & SWS_ACCURATE_RND) ? 2 :
(HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) ? 8 :
1;
if (initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
srcH , dstH, filterAlign, (1<<12),
(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags, cpu_flags,
srcFilter->lumV, dstFilter->lumV, c->param) < 0)
goto fail;
if (initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
c->chrSrcH, c->chrDstH, filterAlign, (1<<12),
(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags, cpu_flags,
srcFilter->chrV, dstFilter->chrV, c->param) < 0)
goto fail;
#if HAVE_ALTIVEC
FF_ALLOC_OR_GOTO(c, c->vYCoeffsBank, sizeof (vector signed short)*c->vLumFilterSize*c->dstH, fail);
FF_ALLOC_OR_GOTO(c, c->vCCoeffsBank, sizeof (vector signed short)*c->vChrFilterSize*c->chrDstH, fail);
for (i=0;i<c->vLumFilterSize*c->dstH;i++) {
int j;
short *p = (short *)&c->vYCoeffsBank[i];
for (j=0;j<8;j++)
p[j] = c->vLumFilter[i];
}
for (i=0;i<c->vChrFilterSize*c->chrDstH;i++) {
int j;
short *p = (short *)&c->vCCoeffsBank[i];
for (j=0;j<8;j++)
p[j] = c->vChrFilter[i];
}
#endif
}
// calculate buffer sizes so that they won't run out while handling these damn slices
c->vLumBufSize= c->vLumFilterSize;
c->vChrBufSize= c->vChrFilterSize;
for (i=0; i<dstH; i++) {
int chrI= i*c->chrDstH / dstH;
int nextSlice= FFMAX(c->vLumFilterPos[i ] + c->vLumFilterSize - 1,
((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));
nextSlice>>= c->chrSrcVSubSample;
nextSlice<<= c->chrSrcVSubSample;
if (c->vLumFilterPos[i ] + c->vLumBufSize < nextSlice)
c->vLumBufSize= nextSlice - c->vLumFilterPos[i];
if (c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>c->chrSrcVSubSample))
c->vChrBufSize= (nextSlice>>c->chrSrcVSubSample) - c->vChrFilterPos[chrI];
}
// allocate pixbufs (we use dynamic allocation because otherwise we would need to
// allocate several megabytes to handle all possible cases)
FF_ALLOC_OR_GOTO(c, c->lumPixBuf, c->vLumBufSize*2*sizeof(int16_t*), fail);
FF_ALLOC_OR_GOTO(c, c->chrUPixBuf, c->vChrBufSize*2*sizeof(int16_t*), fail);
FF_ALLOC_OR_GOTO(c, c->chrVPixBuf, c->vChrBufSize*2*sizeof(int16_t*), fail);
if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat))
FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf, c->vLumBufSize*2*sizeof(int16_t*), fail);
//Note we need at least one pixel more at the end because of the MMX code (just in case someone wanna replace the 4000/8000)
/* align at 16 bytes for AltiVec */
for (i=0; i<c->vLumBufSize; i++) {
FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf[i+c->vLumBufSize], dst_stride+1, fail);
c->lumPixBuf[i] = c->lumPixBuf[i+c->vLumBufSize];
}
c->uv_off_px = dst_stride_px;
c->uv_off_byte = dst_stride;
for (i=0; i<c->vChrBufSize; i++) {
FF_ALLOC_OR_GOTO(c, c->chrUPixBuf[i+c->vChrBufSize], dst_stride*2+1, fail);
c->chrUPixBuf[i] = c->chrUPixBuf[i+c->vChrBufSize];
c->chrVPixBuf[i] = c->chrVPixBuf[i+c->vChrBufSize] = c->chrUPixBuf[i] + (dst_stride >> 1);
}
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf)
for (i=0; i<c->vLumBufSize; i++) {
FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf[i+c->vLumBufSize], dst_stride+1, fail);
c->alpPixBuf[i] = c->alpPixBuf[i+c->vLumBufSize];
}
//try to avoid drawing green stuff between the right end and the stride end
for (i=0; i<c->vChrBufSize; i++)
memset(c->chrUPixBuf[i], 64, dst_stride*2+1);
assert(c->chrDstH <= dstH);
if (flags&SWS_PRINT_INFO) {
if (flags&SWS_FAST_BILINEAR) av_log(c, AV_LOG_INFO, "FAST_BILINEAR scaler, ");
else if (flags&SWS_BILINEAR) av_log(c, AV_LOG_INFO, "BILINEAR scaler, ");
else if (flags&SWS_BICUBIC) av_log(c, AV_LOG_INFO, "BICUBIC scaler, ");
else if (flags&SWS_X) av_log(c, AV_LOG_INFO, "Experimental scaler, ");
else if (flags&SWS_POINT) av_log(c, AV_LOG_INFO, "Nearest Neighbor / POINT scaler, ");
else if (flags&SWS_AREA) av_log(c, AV_LOG_INFO, "Area Averaging scaler, ");
else if (flags&SWS_BICUBLIN) av_log(c, AV_LOG_INFO, "luma BICUBIC / chroma BILINEAR scaler, ");
else if (flags&SWS_GAUSS) av_log(c, AV_LOG_INFO, "Gaussian scaler, ");
else if (flags&SWS_SINC) av_log(c, AV_LOG_INFO, "Sinc scaler, ");
else if (flags&SWS_LANCZOS) av_log(c, AV_LOG_INFO, "Lanczos scaler, ");
else if (flags&SWS_SPLINE) av_log(c, AV_LOG_INFO, "Bicubic spline scaler, ");
else av_log(c, AV_LOG_INFO, "ehh flags invalid?! ");
av_log(c, AV_LOG_INFO, "from %s to %s%s ",
sws_format_name(srcFormat),
#ifdef DITHER1XBPP
dstFormat == PIX_FMT_BGR555 || dstFormat == PIX_FMT_BGR565 ||
dstFormat == PIX_FMT_RGB444BE || dstFormat == PIX_FMT_RGB444LE ||
dstFormat == PIX_FMT_BGR444BE || dstFormat == PIX_FMT_BGR444LE ? "dithered " : "",
#else
"",
#endif
sws_format_name(dstFormat));
if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2) av_log(c, AV_LOG_INFO, "using MMX2\n");
else if (HAVE_AMD3DNOW && cpu_flags & AV_CPU_FLAG_3DNOW) av_log(c, AV_LOG_INFO, "using 3DNOW\n");
else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) av_log(c, AV_LOG_INFO, "using MMX\n");
else if (HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) av_log(c, AV_LOG_INFO, "using AltiVec\n");
else av_log(c, AV_LOG_INFO, "using C\n");
if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
if (c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))
av_log(c, AV_LOG_VERBOSE, "using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
else {
if (c->hLumFilterSize==4)
av_log(c, AV_LOG_VERBOSE, "using 4-tap MMX scaler for horizontal luminance scaling\n");
else if (c->hLumFilterSize==8)
av_log(c, AV_LOG_VERBOSE, "using 8-tap MMX scaler for horizontal luminance scaling\n");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap MMX scaler for horizontal luminance scaling\n");
if (c->hChrFilterSize==4)
av_log(c, AV_LOG_VERBOSE, "using 4-tap MMX scaler for horizontal chrominance scaling\n");
else if (c->hChrFilterSize==8)
av_log(c, AV_LOG_VERBOSE, "using 8-tap MMX scaler for horizontal chrominance scaling\n");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap MMX scaler for horizontal chrominance scaling\n");
}
} else {
#if HAVE_MMX
av_log(c, AV_LOG_VERBOSE, "using x86 asm scaler for horizontal scaling\n");
#else
if (flags & SWS_FAST_BILINEAR)
av_log(c, AV_LOG_VERBOSE, "using FAST_BILINEAR C scaler for horizontal scaling\n");
else
av_log(c, AV_LOG_VERBOSE, "using C scaler for horizontal scaling\n");
#endif
}
if (isPlanarYUV(dstFormat)) {
if (c->vLumFilterSize==1)
av_log(c, AV_LOG_VERBOSE, "using 1-tap %s \"scaler\" for vertical scaling (YV12 like)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap %s scaler for vertical scaling (YV12 like)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
} else {
if (c->vLumFilterSize==1 && c->vChrFilterSize==2)
av_log(c, AV_LOG_VERBOSE, "using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
" 2-tap scaler for vertical chrominance scaling (BGR)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (c->vLumFilterSize==2 && c->vChrFilterSize==2)
av_log(c, AV_LOG_VERBOSE, "using 2-tap linear %s scaler for vertical scaling (BGR)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap %s scaler for vertical scaling (BGR)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
}
if (dstFormat==PIX_FMT_BGR24)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR24 converter\n",
(HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2) ? "MMX2" :
((HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C"));
else if (dstFormat==PIX_FMT_RGB32)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR32 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (dstFormat==PIX_FMT_BGR565)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR16 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (dstFormat==PIX_FMT_BGR555)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR15 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (dstFormat == PIX_FMT_RGB444BE || dstFormat == PIX_FMT_RGB444LE ||
dstFormat == PIX_FMT_BGR444BE || dstFormat == PIX_FMT_BGR444LE)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR12 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
av_log(c, AV_LOG_DEBUG, "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
av_log(c, AV_LOG_DEBUG, "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);
}
c->swScale= ff_getSwsFunc(c);
return 0;
fail: //FIXME replace things by appropriate error codes
return -1;
}
| true | FFmpeg | baba2eedacbbaecf55bdb89dbfe32c69799df99f | int sws_init_context(SwsContext *c, SwsFilter *srcFilter, SwsFilter *dstFilter)
{
int i;
int usesVFilter, usesHFilter;
int unscaled;
SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
int srcW= c->srcW;
int srcH= c->srcH;
int dstW= c->dstW;
int dstH= c->dstH;
int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 16, 16), dst_stride_px = dst_stride >> 1;
int flags, cpu_flags;
enum PixelFormat srcFormat= c->srcFormat;
enum PixelFormat dstFormat= c->dstFormat;
cpu_flags = av_get_cpu_flags();
flags = c->flags;
emms_c();
if (!rgb15to16) sws_rgb2rgb_init();
unscaled = (srcW == dstW && srcH == dstH);
if (!isSupportedIn(srcFormat)) {
av_log(c, AV_LOG_ERROR, "%s is not supported as input pixel format\n", sws_format_name(srcFormat));
return AVERROR(EINVAL);
}
if (!isSupportedOut(dstFormat)) {
av_log(c, AV_LOG_ERROR, "%s is not supported as output pixel format\n", sws_format_name(dstFormat));
return AVERROR(EINVAL);
}
i= flags & ( SWS_POINT
|SWS_AREA
|SWS_BILINEAR
|SWS_FAST_BILINEAR
|SWS_BICUBIC
|SWS_X
|SWS_GAUSS
|SWS_LANCZOS
|SWS_SINC
|SWS_SPLINE
|SWS_BICUBLIN);
if(!i || (i & (i-1))) {
av_log(c, AV_LOG_ERROR, "Exactly one scaler algorithm must be chosen\n");
return AVERROR(EINVAL);
}
if (srcW<4 || srcH<1 || dstW<8 || dstH<1) {
av_log(c, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
srcW, srcH, dstW, dstH);
return AVERROR(EINVAL);
}
if (!dstFilter) dstFilter= &dummyFilter;
if (!srcFilter) srcFilter= &dummyFilter;
c->lumXInc= ((srcW<<16) + (dstW>>1))/dstW;
c->lumYInc= ((srcH<<16) + (dstH>>1))/dstH;
c->dstFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[dstFormat]);
c->srcFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[srcFormat]);
c->vRounder= 4* 0x0001000100010001ULL;
usesVFilter = (srcFilter->lumV && srcFilter->lumV->length>1) ||
(srcFilter->chrV && srcFilter->chrV->length>1) ||
(dstFilter->lumV && dstFilter->lumV->length>1) ||
(dstFilter->chrV && dstFilter->chrV->length>1);
usesHFilter = (srcFilter->lumH && srcFilter->lumH->length>1) ||
(srcFilter->chrH && srcFilter->chrH->length>1) ||
(dstFilter->lumH && dstFilter->lumH->length>1) ||
(dstFilter->chrH && dstFilter->chrH->length>1);
getSubSampleFactors(&c->chrSrcHSubSample, &c->chrSrcVSubSample, srcFormat);
getSubSampleFactors(&c->chrDstHSubSample, &c->chrDstVSubSample, dstFormat);
if (flags & SWS_FULL_CHR_H_INT &&
dstFormat != PIX_FMT_RGBA &&
dstFormat != PIX_FMT_ARGB &&
dstFormat != PIX_FMT_BGRA &&
dstFormat != PIX_FMT_ABGR &&
dstFormat != PIX_FMT_RGB24 &&
dstFormat != PIX_FMT_BGR24) {
av_log(c, AV_LOG_ERROR,
"full chroma interpolation for destination format '%s' not yet implemented\n",
sws_format_name(dstFormat));
flags &= ~SWS_FULL_CHR_H_INT;
c->flags = flags;
}
if (isAnyRGB(dstFormat) && !(flags&SWS_FULL_CHR_H_INT)) c->chrDstHSubSample=1;
c->vChrDrop= (flags&SWS_SRC_V_CHR_DROP_MASK)>>SWS_SRC_V_CHR_DROP_SHIFT;
c->chrSrcVSubSample+= c->vChrDrop;
if (isAnyRGB(srcFormat) && !(flags&SWS_FULL_CHR_H_INP)
&& srcFormat!=PIX_FMT_RGB8 && srcFormat!=PIX_FMT_BGR8
&& srcFormat!=PIX_FMT_RGB4 && srcFormat!=PIX_FMT_BGR4
&& srcFormat!=PIX_FMT_RGB4_BYTE && srcFormat!=PIX_FMT_BGR4_BYTE
&& ((dstW>>c->chrDstHSubSample) <= (srcW>>1) || (flags&SWS_FAST_BILINEAR)))
c->chrSrcHSubSample=1;
c->chrSrcW= -((-srcW) >> c->chrSrcHSubSample);
c->chrSrcH= -((-srcH) >> c->chrSrcVSubSample);
c->chrDstW= -((-dstW) >> c->chrDstHSubSample);
c->chrDstH= -((-dstH) >> c->chrDstVSubSample);
if (unscaled && !usesHFilter && !usesVFilter && (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
ff_get_unscaled_swscale(c);
if (c->swScale) {
if (flags&SWS_PRINT_INFO)
av_log(c, AV_LOG_INFO, "using unscaled %s -> %s special converter\n",
sws_format_name(srcFormat), sws_format_name(dstFormat));
return 0;
}
}
c->scalingBpp = FFMAX(av_pix_fmt_descriptors[srcFormat].comp[0].depth_minus1,
av_pix_fmt_descriptors[dstFormat].comp[0].depth_minus1) >= 8 ? 16 : 8;
if (c->scalingBpp == 16)
dst_stride <<= 1;
FF_ALLOC_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW, 16) * 2 * c->scalingBpp >> 3, fail);
if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2 && c->scalingBpp == 8) {
c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
if (!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR)) {
if (flags&SWS_PRINT_INFO)
av_log(c, AV_LOG_INFO, "output width is not a multiple of 32 -> no MMX2 scaler\n");
}
if (usesHFilter) c->canMMX2BeUsed=0;
}
else
c->canMMX2BeUsed=0;
c->chrXInc= ((c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;
c->chrYInc= ((c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;
if (flags&SWS_FAST_BILINEAR) {
if (c->canMMX2BeUsed) {
c->lumXInc+= 20;
c->chrXInc+= 20;
}
else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
c->chrXInc = ((c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;
}
}
{
#if HAVE_MMX2
if (c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR)) {
c->lumMmx2FilterCodeSize = initMMX2HScaler( dstW, c->lumXInc, NULL, NULL, NULL, 8);
c->chrMmx2FilterCodeSize = initMMX2HScaler(c->chrDstW, c->chrXInc, NULL, NULL, NULL, 4);
#ifdef MAP_ANONYMOUS
c->lumMmx2FilterCode = mmap(NULL, c->lumMmx2FilterCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
c->chrMmx2FilterCode = mmap(NULL, c->chrMmx2FilterCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
#elif HAVE_VIRTUALALLOC
c->lumMmx2FilterCode = VirtualAlloc(NULL, c->lumMmx2FilterCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
c->chrMmx2FilterCode = VirtualAlloc(NULL, c->chrMmx2FilterCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
#else
c->lumMmx2FilterCode = av_malloc(c->lumMmx2FilterCodeSize);
c->chrMmx2FilterCode = av_malloc(c->chrMmx2FilterCodeSize);
#endif
if (!c->lumMmx2FilterCode || !c->chrMmx2FilterCode)
return AVERROR(ENOMEM);
FF_ALLOCZ_OR_GOTO(c, c->hLumFilter , (dstW /8+8)*sizeof(int16_t), fail);
FF_ALLOCZ_OR_GOTO(c, c->hChrFilter , (c->chrDstW /4+8)*sizeof(int16_t), fail);
FF_ALLOCZ_OR_GOTO(c, c->hLumFilterPos, (dstW /2/8+8)*sizeof(int32_t), fail);
FF_ALLOCZ_OR_GOTO(c, c->hChrFilterPos, (c->chrDstW/2/4+8)*sizeof(int32_t), fail);
initMMX2HScaler( dstW, c->lumXInc, c->lumMmx2FilterCode, c->hLumFilter, c->hLumFilterPos, 8);
initMMX2HScaler(c->chrDstW, c->chrXInc, c->chrMmx2FilterCode, c->hChrFilter, c->hChrFilterPos, 4);
#ifdef MAP_ANONYMOUS
mprotect(c->lumMmx2FilterCode, c->lumMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
mprotect(c->chrMmx2FilterCode, c->chrMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
#endif
} else
#endif
{
const int filterAlign=
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? 4 :
(HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) ? 8 :
1;
if (initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
srcW , dstW, filterAlign, 1<<14,
(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags, cpu_flags,
srcFilter->lumH, dstFilter->lumH, c->param) < 0)
goto fail;
if (initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
c->chrSrcW, c->chrDstW, filterAlign, 1<<14,
(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags, cpu_flags,
srcFilter->chrH, dstFilter->chrH, c->param) < 0)
goto fail;
}
}
{
const int filterAlign=
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) && (flags & SWS_ACCURATE_RND) ? 2 :
(HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) ? 8 :
1;
if (initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
srcH , dstH, filterAlign, (1<<12),
(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags, cpu_flags,
srcFilter->lumV, dstFilter->lumV, c->param) < 0)
goto fail;
if (initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
c->chrSrcH, c->chrDstH, filterAlign, (1<<12),
(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags, cpu_flags,
srcFilter->chrV, dstFilter->chrV, c->param) < 0)
goto fail;
#if HAVE_ALTIVEC
FF_ALLOC_OR_GOTO(c, c->vYCoeffsBank, sizeof (vector signed short)*c->vLumFilterSize*c->dstH, fail);
FF_ALLOC_OR_GOTO(c, c->vCCoeffsBank, sizeof (vector signed short)*c->vChrFilterSize*c->chrDstH, fail);
for (i=0;i<c->vLumFilterSize*c->dstH;i++) {
int j;
short *p = (short *)&c->vYCoeffsBank[i];
for (j=0;j<8;j++)
p[j] = c->vLumFilter[i];
}
for (i=0;i<c->vChrFilterSize*c->chrDstH;i++) {
int j;
short *p = (short *)&c->vCCoeffsBank[i];
for (j=0;j<8;j++)
p[j] = c->vChrFilter[i];
}
#endif
}
c->vLumBufSize= c->vLumFilterSize;
c->vChrBufSize= c->vChrFilterSize;
for (i=0; i<dstH; i++) {
int chrI= i*c->chrDstH / dstH;
int nextSlice= FFMAX(c->vLumFilterPos[i ] + c->vLumFilterSize - 1,
((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));
nextSlice>>= c->chrSrcVSubSample;
nextSlice<<= c->chrSrcVSubSample;
if (c->vLumFilterPos[i ] + c->vLumBufSize < nextSlice)
c->vLumBufSize= nextSlice - c->vLumFilterPos[i];
if (c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>c->chrSrcVSubSample))
c->vChrBufSize= (nextSlice>>c->chrSrcVSubSample) - c->vChrFilterPos[chrI];
}
FF_ALLOC_OR_GOTO(c, c->lumPixBuf, c->vLumBufSize*2*sizeof(int16_t*), fail);
FF_ALLOC_OR_GOTO(c, c->chrUPixBuf, c->vChrBufSize*2*sizeof(int16_t*), fail);
FF_ALLOC_OR_GOTO(c, c->chrVPixBuf, c->vChrBufSize*2*sizeof(int16_t*), fail);
if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat) && isALPHA(c->dstFormat))
FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf, c->vLumBufSize*2*sizeof(int16_t*), fail);
for (i=0; i<c->vLumBufSize; i++) {
FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf[i+c->vLumBufSize], dst_stride+1, fail);
c->lumPixBuf[i] = c->lumPixBuf[i+c->vLumBufSize];
}
c->uv_off_px = dst_stride_px;
c->uv_off_byte = dst_stride;
for (i=0; i<c->vChrBufSize; i++) {
FF_ALLOC_OR_GOTO(c, c->chrUPixBuf[i+c->vChrBufSize], dst_stride*2+1, fail);
c->chrUPixBuf[i] = c->chrUPixBuf[i+c->vChrBufSize];
c->chrVPixBuf[i] = c->chrVPixBuf[i+c->vChrBufSize] = c->chrUPixBuf[i] + (dst_stride >> 1);
}
if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf)
for (i=0; i<c->vLumBufSize; i++) {
FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf[i+c->vLumBufSize], dst_stride+1, fail);
c->alpPixBuf[i] = c->alpPixBuf[i+c->vLumBufSize];
}
for (i=0; i<c->vChrBufSize; i++)
memset(c->chrUPixBuf[i], 64, dst_stride*2+1);
assert(c->chrDstH <= dstH);
if (flags&SWS_PRINT_INFO) {
if (flags&SWS_FAST_BILINEAR) av_log(c, AV_LOG_INFO, "FAST_BILINEAR scaler, ");
else if (flags&SWS_BILINEAR) av_log(c, AV_LOG_INFO, "BILINEAR scaler, ");
else if (flags&SWS_BICUBIC) av_log(c, AV_LOG_INFO, "BICUBIC scaler, ");
else if (flags&SWS_X) av_log(c, AV_LOG_INFO, "Experimental scaler, ");
else if (flags&SWS_POINT) av_log(c, AV_LOG_INFO, "Nearest Neighbor / POINT scaler, ");
else if (flags&SWS_AREA) av_log(c, AV_LOG_INFO, "Area Averaging scaler, ");
else if (flags&SWS_BICUBLIN) av_log(c, AV_LOG_INFO, "luma BICUBIC / chroma BILINEAR scaler, ");
else if (flags&SWS_GAUSS) av_log(c, AV_LOG_INFO, "Gaussian scaler, ");
else if (flags&SWS_SINC) av_log(c, AV_LOG_INFO, "Sinc scaler, ");
else if (flags&SWS_LANCZOS) av_log(c, AV_LOG_INFO, "Lanczos scaler, ");
else if (flags&SWS_SPLINE) av_log(c, AV_LOG_INFO, "Bicubic spline scaler, ");
else av_log(c, AV_LOG_INFO, "ehh flags invalid?! ");
av_log(c, AV_LOG_INFO, "from %s to %s%s ",
sws_format_name(srcFormat),
#ifdef DITHER1XBPP
dstFormat == PIX_FMT_BGR555 || dstFormat == PIX_FMT_BGR565 ||
dstFormat == PIX_FMT_RGB444BE || dstFormat == PIX_FMT_RGB444LE ||
dstFormat == PIX_FMT_BGR444BE || dstFormat == PIX_FMT_BGR444LE ? "dithered " : "",
#else
"",
#endif
sws_format_name(dstFormat));
if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2) av_log(c, AV_LOG_INFO, "using MMX2\n");
else if (HAVE_AMD3DNOW && cpu_flags & AV_CPU_FLAG_3DNOW) av_log(c, AV_LOG_INFO, "using 3DNOW\n");
else if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) av_log(c, AV_LOG_INFO, "using MMX\n");
else if (HAVE_ALTIVEC && cpu_flags & AV_CPU_FLAG_ALTIVEC) av_log(c, AV_LOG_INFO, "using AltiVec\n");
else av_log(c, AV_LOG_INFO, "using C\n");
if (HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) {
if (c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))
av_log(c, AV_LOG_VERBOSE, "using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
else {
if (c->hLumFilterSize==4)
av_log(c, AV_LOG_VERBOSE, "using 4-tap MMX scaler for horizontal luminance scaling\n");
else if (c->hLumFilterSize==8)
av_log(c, AV_LOG_VERBOSE, "using 8-tap MMX scaler for horizontal luminance scaling\n");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap MMX scaler for horizontal luminance scaling\n");
if (c->hChrFilterSize==4)
av_log(c, AV_LOG_VERBOSE, "using 4-tap MMX scaler for horizontal chrominance scaling\n");
else if (c->hChrFilterSize==8)
av_log(c, AV_LOG_VERBOSE, "using 8-tap MMX scaler for horizontal chrominance scaling\n");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap MMX scaler for horizontal chrominance scaling\n");
}
} else {
#if HAVE_MMX
av_log(c, AV_LOG_VERBOSE, "using x86 asm scaler for horizontal scaling\n");
#else
if (flags & SWS_FAST_BILINEAR)
av_log(c, AV_LOG_VERBOSE, "using FAST_BILINEAR C scaler for horizontal scaling\n");
else
av_log(c, AV_LOG_VERBOSE, "using C scaler for horizontal scaling\n");
#endif
}
if (isPlanarYUV(dstFormat)) {
if (c->vLumFilterSize==1)
av_log(c, AV_LOG_VERBOSE, "using 1-tap %s \"scaler\" for vertical scaling (YV12 like)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap %s scaler for vertical scaling (YV12 like)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
} else {
if (c->vLumFilterSize==1 && c->vChrFilterSize==2)
av_log(c, AV_LOG_VERBOSE, "using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
" 2-tap scaler for vertical chrominance scaling (BGR)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (c->vLumFilterSize==2 && c->vChrFilterSize==2)
av_log(c, AV_LOG_VERBOSE, "using 2-tap linear %s scaler for vertical scaling (BGR)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else
av_log(c, AV_LOG_VERBOSE, "using n-tap %s scaler for vertical scaling (BGR)\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
}
if (dstFormat==PIX_FMT_BGR24)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR24 converter\n",
(HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2) ? "MMX2" :
((HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C"));
else if (dstFormat==PIX_FMT_RGB32)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR32 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (dstFormat==PIX_FMT_BGR565)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR16 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (dstFormat==PIX_FMT_BGR555)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR15 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (dstFormat == PIX_FMT_RGB444BE || dstFormat == PIX_FMT_RGB444LE ||
dstFormat == PIX_FMT_BGR444BE || dstFormat == PIX_FMT_BGR444LE)
av_log(c, AV_LOG_VERBOSE, "using %s YV12->BGR12 converter\n",
(HAVE_MMX && cpu_flags & AV_CPU_FLAG_MMX) ? "MMX" : "C");
av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
av_log(c, AV_LOG_DEBUG, "lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
av_log(c, AV_LOG_DEBUG, "chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);
}
c->swScale= ff_getSwsFunc(c);
return 0;
fail:
return -1;
}
| {
"code": [
" FF_ALLOCZ_OR_GOTO(c, c->lumPixBuf[i+c->vLumBufSize], dst_stride+1, fail);",
" c->uv_off_px = dst_stride_px;",
" c->uv_off_byte = dst_stride;",
" FF_ALLOC_OR_GOTO(c, c->chrUPixBuf[i+c->vChrBufSize], dst_stride*2+1, fail);",
" c->chrVPixBuf[i] = c->chrVPixBuf[i+c->vChrBufSize] = c->chrUPixBuf[i] + (dst_stride >> 1);",
" FF_ALLOCZ_OR_GOTO(c, c->alpPixBuf[i+c->vLumBufSize], dst_stride+1, fail);"
],
"line_no": [
551,
557,
559,
563,
567,
575
]
} | int FUNC_0(SwsContext *VAR_0, SwsFilter *VAR_1, SwsFilter *VAR_2)
{
int VAR_3;
int VAR_4, VAR_5;
int VAR_6;
SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
int VAR_7= VAR_0->VAR_7;
int VAR_8= VAR_0->VAR_8;
int VAR_9= VAR_0->VAR_9;
int VAR_10= VAR_0->VAR_10;
int VAR_11 = FFALIGN(VAR_9 * sizeof(int16_t) + 16, 16), VAR_12 = VAR_11 >> 1;
int VAR_13, VAR_14;
enum PixelFormat VAR_15= VAR_0->VAR_15;
enum PixelFormat VAR_16= VAR_0->VAR_16;
VAR_14 = av_get_cpu_flags();
VAR_13 = VAR_0->VAR_13;
emms_c();
if (!rgb15to16) sws_rgb2rgb_init();
VAR_6 = (VAR_7 == VAR_9 && VAR_8 == VAR_10);
if (!isSupportedIn(VAR_15)) {
av_log(VAR_0, AV_LOG_ERROR, "%s is not supported as input pixel format\n", sws_format_name(VAR_15));
return AVERROR(EINVAL);
}
if (!isSupportedOut(VAR_16)) {
av_log(VAR_0, AV_LOG_ERROR, "%s is not supported as output pixel format\n", sws_format_name(VAR_16));
return AVERROR(EINVAL);
}
VAR_3= VAR_13 & ( SWS_POINT
|SWS_AREA
|SWS_BILINEAR
|SWS_FAST_BILINEAR
|SWS_BICUBIC
|SWS_X
|SWS_GAUSS
|SWS_LANCZOS
|SWS_SINC
|SWS_SPLINE
|SWS_BICUBLIN);
if(!VAR_3 || (VAR_3 & (VAR_3-1))) {
av_log(VAR_0, AV_LOG_ERROR, "Exactly one scaler algorithm must be chosen\n");
return AVERROR(EINVAL);
}
if (VAR_7<4 || VAR_8<1 || VAR_9<8 || VAR_10<1) {
av_log(VAR_0, AV_LOG_ERROR, "%dx%d -> %dx%d is invalid scaling dimension\n",
VAR_7, VAR_8, VAR_9, VAR_10);
return AVERROR(EINVAL);
}
if (!VAR_2) VAR_2= &dummyFilter;
if (!VAR_1) VAR_1= &dummyFilter;
VAR_0->lumXInc= ((VAR_7<<16) + (VAR_9>>1))/VAR_9;
VAR_0->lumYInc= ((VAR_8<<16) + (VAR_10>>1))/VAR_10;
VAR_0->dstFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[VAR_16]);
VAR_0->srcFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[VAR_15]);
VAR_0->vRounder= 4* 0x0001000100010001ULL;
VAR_4 = (VAR_1->lumV && VAR_1->lumV->length>1) ||
(VAR_1->chrV && VAR_1->chrV->length>1) ||
(VAR_2->lumV && VAR_2->lumV->length>1) ||
(VAR_2->chrV && VAR_2->chrV->length>1);
VAR_5 = (VAR_1->lumH && VAR_1->lumH->length>1) ||
(VAR_1->chrH && VAR_1->chrH->length>1) ||
(VAR_2->lumH && VAR_2->lumH->length>1) ||
(VAR_2->chrH && VAR_2->chrH->length>1);
getSubSampleFactors(&VAR_0->chrSrcHSubSample, &VAR_0->chrSrcVSubSample, VAR_15);
getSubSampleFactors(&VAR_0->chrDstHSubSample, &VAR_0->chrDstVSubSample, VAR_16);
if (VAR_13 & SWS_FULL_CHR_H_INT &&
VAR_16 != PIX_FMT_RGBA &&
VAR_16 != PIX_FMT_ARGB &&
VAR_16 != PIX_FMT_BGRA &&
VAR_16 != PIX_FMT_ABGR &&
VAR_16 != PIX_FMT_RGB24 &&
VAR_16 != PIX_FMT_BGR24) {
av_log(VAR_0, AV_LOG_ERROR,
"full chroma interpolation for destination format '%s' not yet implemented\n",
sws_format_name(VAR_16));
VAR_13 &= ~SWS_FULL_CHR_H_INT;
VAR_0->VAR_13 = VAR_13;
}
if (isAnyRGB(VAR_16) && !(VAR_13&SWS_FULL_CHR_H_INT)) VAR_0->chrDstHSubSample=1;
VAR_0->vChrDrop= (VAR_13&SWS_SRC_V_CHR_DROP_MASK)>>SWS_SRC_V_CHR_DROP_SHIFT;
VAR_0->chrSrcVSubSample+= VAR_0->vChrDrop;
if (isAnyRGB(VAR_15) && !(VAR_13&SWS_FULL_CHR_H_INP)
&& VAR_15!=PIX_FMT_RGB8 && VAR_15!=PIX_FMT_BGR8
&& VAR_15!=PIX_FMT_RGB4 && VAR_15!=PIX_FMT_BGR4
&& VAR_15!=PIX_FMT_RGB4_BYTE && VAR_15!=PIX_FMT_BGR4_BYTE
&& ((VAR_9>>VAR_0->chrDstHSubSample) <= (VAR_7>>1) || (VAR_13&SWS_FAST_BILINEAR)))
VAR_0->chrSrcHSubSample=1;
VAR_0->chrSrcW= -((-VAR_7) >> VAR_0->chrSrcHSubSample);
VAR_0->chrSrcH= -((-VAR_8) >> VAR_0->chrSrcVSubSample);
VAR_0->chrDstW= -((-VAR_9) >> VAR_0->chrDstHSubSample);
VAR_0->chrDstH= -((-VAR_10) >> VAR_0->chrDstVSubSample);
if (VAR_6 && !VAR_5 && !VAR_4 && (VAR_0->srcRange == VAR_0->dstRange || isAnyRGB(VAR_16))) {
ff_get_unscaled_swscale(VAR_0);
if (VAR_0->swScale) {
if (VAR_13&SWS_PRINT_INFO)
av_log(VAR_0, AV_LOG_INFO, "using VAR_6 %s -> %s special converter\n",
sws_format_name(VAR_15), sws_format_name(VAR_16));
return 0;
}
}
VAR_0->scalingBpp = FFMAX(av_pix_fmt_descriptors[VAR_15].comp[0].depth_minus1,
av_pix_fmt_descriptors[VAR_16].comp[0].depth_minus1) >= 8 ? 16 : 8;
if (VAR_0->scalingBpp == 16)
VAR_11 <<= 1;
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->formatConvBuffer, FFALIGN(VAR_7, 16) * 2 * VAR_0->scalingBpp >> 3, fail);
if (HAVE_MMX2 && VAR_14 & AV_CPU_FLAG_MMX2 && VAR_0->scalingBpp == 8) {
VAR_0->canMMX2BeUsed= (VAR_9 >=VAR_7 && (VAR_9&31)==0 && (VAR_7&15)==0) ? 1 : 0;
if (!VAR_0->canMMX2BeUsed && VAR_9 >=VAR_7 && (VAR_7&15)==0 && (VAR_13&SWS_FAST_BILINEAR)) {
if (VAR_13&SWS_PRINT_INFO)
av_log(VAR_0, AV_LOG_INFO, "output width is not a multiple of 32 -> no MMX2 scaler\n");
}
if (VAR_5) VAR_0->canMMX2BeUsed=0;
}
else
VAR_0->canMMX2BeUsed=0;
VAR_0->chrXInc= ((VAR_0->chrSrcW<<16) + (VAR_0->chrDstW>>1))/VAR_0->chrDstW;
VAR_0->chrYInc= ((VAR_0->chrSrcH<<16) + (VAR_0->chrDstH>>1))/VAR_0->chrDstH;
if (VAR_13&SWS_FAST_BILINEAR) {
if (VAR_0->canMMX2BeUsed) {
VAR_0->lumXInc+= 20;
VAR_0->chrXInc+= 20;
}
else if (HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) {
VAR_0->lumXInc = ((VAR_7-2)<<16)/(VAR_9-2) - 20;
VAR_0->chrXInc = ((VAR_0->chrSrcW-2)<<16)/(VAR_0->chrDstW-2) - 20;
}
}
{
#if HAVE_MMX2
if (VAR_0->canMMX2BeUsed && (VAR_13 & SWS_FAST_BILINEAR)) {
VAR_0->lumMmx2FilterCodeSize = initMMX2HScaler( VAR_9, VAR_0->lumXInc, NULL, NULL, NULL, 8);
VAR_0->chrMmx2FilterCodeSize = initMMX2HScaler(VAR_0->chrDstW, VAR_0->chrXInc, NULL, NULL, NULL, 4);
#ifdef MAP_ANONYMOUS
VAR_0->lumMmx2FilterCode = mmap(NULL, VAR_0->lumMmx2FilterCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
VAR_0->chrMmx2FilterCode = mmap(NULL, VAR_0->chrMmx2FilterCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
#elif HAVE_VIRTUALALLOC
VAR_0->lumMmx2FilterCode = VirtualAlloc(NULL, VAR_0->lumMmx2FilterCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
VAR_0->chrMmx2FilterCode = VirtualAlloc(NULL, VAR_0->chrMmx2FilterCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
#else
VAR_0->lumMmx2FilterCode = av_malloc(VAR_0->lumMmx2FilterCodeSize);
VAR_0->chrMmx2FilterCode = av_malloc(VAR_0->chrMmx2FilterCodeSize);
#endif
if (!VAR_0->lumMmx2FilterCode || !VAR_0->chrMmx2FilterCode)
return AVERROR(ENOMEM);
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->hLumFilter , (VAR_9 /8+8)*sizeof(int16_t), fail);
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->hChrFilter , (VAR_0->chrDstW /4+8)*sizeof(int16_t), fail);
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->hLumFilterPos, (VAR_9 /2/8+8)*sizeof(int32_t), fail);
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->hChrFilterPos, (VAR_0->chrDstW/2/4+8)*sizeof(int32_t), fail);
initMMX2HScaler( VAR_9, VAR_0->lumXInc, VAR_0->lumMmx2FilterCode, VAR_0->hLumFilter, VAR_0->hLumFilterPos, 8);
initMMX2HScaler(VAR_0->chrDstW, VAR_0->chrXInc, VAR_0->chrMmx2FilterCode, VAR_0->hChrFilter, VAR_0->hChrFilterPos, 4);
#ifdef MAP_ANONYMOUS
mprotect(VAR_0->lumMmx2FilterCode, VAR_0->lumMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
mprotect(VAR_0->chrMmx2FilterCode, VAR_0->chrMmx2FilterCodeSize, PROT_EXEC | PROT_READ);
#endif
} else
#endif
{
const int VAR_18=
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? 4 :
(HAVE_ALTIVEC && VAR_14 & AV_CPU_FLAG_ALTIVEC) ? 8 :
1;
if (initFilter(&VAR_0->hLumFilter, &VAR_0->hLumFilterPos, &VAR_0->hLumFilterSize, VAR_0->lumXInc,
VAR_7 , VAR_9, VAR_18, 1<<14,
(VAR_13&SWS_BICUBLIN) ? (VAR_13|SWS_BICUBIC) : VAR_13, VAR_14,
VAR_1->lumH, VAR_2->lumH, VAR_0->param) < 0)
goto fail;
if (initFilter(&VAR_0->hChrFilter, &VAR_0->hChrFilterPos, &VAR_0->hChrFilterSize, VAR_0->chrXInc,
VAR_0->chrSrcW, VAR_0->chrDstW, VAR_18, 1<<14,
(VAR_13&SWS_BICUBLIN) ? (VAR_13|SWS_BILINEAR) : VAR_13, VAR_14,
VAR_1->chrH, VAR_2->chrH, VAR_0->param) < 0)
goto fail;
}
}
{
const int VAR_18=
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) && (VAR_13 & SWS_ACCURATE_RND) ? 2 :
(HAVE_ALTIVEC && VAR_14 & AV_CPU_FLAG_ALTIVEC) ? 8 :
1;
if (initFilter(&VAR_0->vLumFilter, &VAR_0->vLumFilterPos, &VAR_0->vLumFilterSize, VAR_0->lumYInc,
VAR_8 , VAR_10, VAR_18, (1<<12),
(VAR_13&SWS_BICUBLIN) ? (VAR_13|SWS_BICUBIC) : VAR_13, VAR_14,
VAR_1->lumV, VAR_2->lumV, VAR_0->param) < 0)
goto fail;
if (initFilter(&VAR_0->vChrFilter, &VAR_0->vChrFilterPos, &VAR_0->vChrFilterSize, VAR_0->chrYInc,
VAR_0->chrSrcH, VAR_0->chrDstH, VAR_18, (1<<12),
(VAR_13&SWS_BICUBLIN) ? (VAR_13|SWS_BILINEAR) : VAR_13, VAR_14,
VAR_1->chrV, VAR_2->chrV, VAR_0->param) < 0)
goto fail;
#if HAVE_ALTIVEC
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->vYCoeffsBank, sizeof (vector signed short)*VAR_0->vLumFilterSize*VAR_0->VAR_10, fail);
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->vCCoeffsBank, sizeof (vector signed short)*VAR_0->vChrFilterSize*VAR_0->chrDstH, fail);
for (VAR_3=0;VAR_3<VAR_0->vLumFilterSize*VAR_0->VAR_10;VAR_3++) {
int j;
short *p = (short *)&VAR_0->vYCoeffsBank[VAR_3];
for (j=0;j<8;j++)
p[j] = VAR_0->vLumFilter[VAR_3];
}
for (VAR_3=0;VAR_3<VAR_0->vChrFilterSize*VAR_0->chrDstH;VAR_3++) {
int j;
short *p = (short *)&VAR_0->vCCoeffsBank[VAR_3];
for (j=0;j<8;j++)
p[j] = VAR_0->vChrFilter[VAR_3];
}
#endif
}
VAR_0->vLumBufSize= VAR_0->vLumFilterSize;
VAR_0->vChrBufSize= VAR_0->vChrFilterSize;
for (VAR_3=0; VAR_3<VAR_10; VAR_3++) {
int VAR_18= VAR_3*VAR_0->chrDstH / VAR_10;
int VAR_19= FFMAX(VAR_0->vLumFilterPos[VAR_3 ] + VAR_0->vLumFilterSize - 1,
((VAR_0->vChrFilterPos[VAR_18] + VAR_0->vChrFilterSize - 1)<<VAR_0->chrSrcVSubSample));
VAR_19>>= VAR_0->chrSrcVSubSample;
VAR_19<<= VAR_0->chrSrcVSubSample;
if (VAR_0->vLumFilterPos[VAR_3 ] + VAR_0->vLumBufSize < VAR_19)
VAR_0->vLumBufSize= VAR_19 - VAR_0->vLumFilterPos[VAR_3];
if (VAR_0->vChrFilterPos[VAR_18] + VAR_0->vChrBufSize < (VAR_19>>VAR_0->chrSrcVSubSample))
VAR_0->vChrBufSize= (VAR_19>>VAR_0->chrSrcVSubSample) - VAR_0->vChrFilterPos[VAR_18];
}
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->lumPixBuf, VAR_0->vLumBufSize*2*sizeof(int16_t*), fail);
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->chrUPixBuf, VAR_0->vChrBufSize*2*sizeof(int16_t*), fail);
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->chrVPixBuf, VAR_0->vChrBufSize*2*sizeof(int16_t*), fail);
if (CONFIG_SWSCALE_ALPHA && isALPHA(VAR_0->VAR_15) && isALPHA(VAR_0->VAR_16))
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->alpPixBuf, VAR_0->vLumBufSize*2*sizeof(int16_t*), fail);
for (VAR_3=0; VAR_3<VAR_0->vLumBufSize; VAR_3++) {
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->lumPixBuf[VAR_3+VAR_0->vLumBufSize], VAR_11+1, fail);
VAR_0->lumPixBuf[VAR_3] = VAR_0->lumPixBuf[VAR_3+VAR_0->vLumBufSize];
}
VAR_0->uv_off_px = VAR_12;
VAR_0->uv_off_byte = VAR_11;
for (VAR_3=0; VAR_3<VAR_0->vChrBufSize; VAR_3++) {
FF_ALLOC_OR_GOTO(VAR_0, VAR_0->chrUPixBuf[VAR_3+VAR_0->vChrBufSize], VAR_11*2+1, fail);
VAR_0->chrUPixBuf[VAR_3] = VAR_0->chrUPixBuf[VAR_3+VAR_0->vChrBufSize];
VAR_0->chrVPixBuf[VAR_3] = VAR_0->chrVPixBuf[VAR_3+VAR_0->vChrBufSize] = VAR_0->chrUPixBuf[VAR_3] + (VAR_11 >> 1);
}
if (CONFIG_SWSCALE_ALPHA && VAR_0->alpPixBuf)
for (VAR_3=0; VAR_3<VAR_0->vLumBufSize; VAR_3++) {
FF_ALLOCZ_OR_GOTO(VAR_0, VAR_0->alpPixBuf[VAR_3+VAR_0->vLumBufSize], VAR_11+1, fail);
VAR_0->alpPixBuf[VAR_3] = VAR_0->alpPixBuf[VAR_3+VAR_0->vLumBufSize];
}
for (VAR_3=0; VAR_3<VAR_0->vChrBufSize; VAR_3++)
memset(VAR_0->chrUPixBuf[VAR_3], 64, VAR_11*2+1);
assert(VAR_0->chrDstH <= VAR_10);
if (VAR_13&SWS_PRINT_INFO) {
if (VAR_13&SWS_FAST_BILINEAR) av_log(VAR_0, AV_LOG_INFO, "FAST_BILINEAR scaler, ");
else if (VAR_13&SWS_BILINEAR) av_log(VAR_0, AV_LOG_INFO, "BILINEAR scaler, ");
else if (VAR_13&SWS_BICUBIC) av_log(VAR_0, AV_LOG_INFO, "BICUBIC scaler, ");
else if (VAR_13&SWS_X) av_log(VAR_0, AV_LOG_INFO, "Experimental scaler, ");
else if (VAR_13&SWS_POINT) av_log(VAR_0, AV_LOG_INFO, "Nearest Neighbor / POINT scaler, ");
else if (VAR_13&SWS_AREA) av_log(VAR_0, AV_LOG_INFO, "Area Averaging scaler, ");
else if (VAR_13&SWS_BICUBLIN) av_log(VAR_0, AV_LOG_INFO, "luma BICUBIC / chroma BILINEAR scaler, ");
else if (VAR_13&SWS_GAUSS) av_log(VAR_0, AV_LOG_INFO, "Gaussian scaler, ");
else if (VAR_13&SWS_SINC) av_log(VAR_0, AV_LOG_INFO, "Sinc scaler, ");
else if (VAR_13&SWS_LANCZOS) av_log(VAR_0, AV_LOG_INFO, "Lanczos scaler, ");
else if (VAR_13&SWS_SPLINE) av_log(VAR_0, AV_LOG_INFO, "Bicubic spline scaler, ");
else av_log(VAR_0, AV_LOG_INFO, "ehh VAR_13 invalid?! ");
av_log(VAR_0, AV_LOG_INFO, "from %s to %s%s ",
sws_format_name(VAR_15),
#ifdef DITHER1XBPP
VAR_16 == PIX_FMT_BGR555 || VAR_16 == PIX_FMT_BGR565 ||
VAR_16 == PIX_FMT_RGB444BE || VAR_16 == PIX_FMT_RGB444LE ||
VAR_16 == PIX_FMT_BGR444BE || VAR_16 == PIX_FMT_BGR444LE ? "dithered " : "",
#else
"",
#endif
sws_format_name(VAR_16));
if (HAVE_MMX2 && VAR_14 & AV_CPU_FLAG_MMX2) av_log(VAR_0, AV_LOG_INFO, "using MMX2\n");
else if (HAVE_AMD3DNOW && VAR_14 & AV_CPU_FLAG_3DNOW) av_log(VAR_0, AV_LOG_INFO, "using 3DNOW\n");
else if (HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) av_log(VAR_0, AV_LOG_INFO, "using MMX\n");
else if (HAVE_ALTIVEC && VAR_14 & AV_CPU_FLAG_ALTIVEC) av_log(VAR_0, AV_LOG_INFO, "using AltiVec\n");
else av_log(VAR_0, AV_LOG_INFO, "using C\n");
if (HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) {
if (VAR_0->canMMX2BeUsed && (VAR_13&SWS_FAST_BILINEAR))
av_log(VAR_0, AV_LOG_VERBOSE, "using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
else {
if (VAR_0->hLumFilterSize==4)
av_log(VAR_0, AV_LOG_VERBOSE, "using 4-tap MMX scaler for horizontal luminance scaling\n");
else if (VAR_0->hLumFilterSize==8)
av_log(VAR_0, AV_LOG_VERBOSE, "using 8-tap MMX scaler for horizontal luminance scaling\n");
else
av_log(VAR_0, AV_LOG_VERBOSE, "using n-tap MMX scaler for horizontal luminance scaling\n");
if (VAR_0->hChrFilterSize==4)
av_log(VAR_0, AV_LOG_VERBOSE, "using 4-tap MMX scaler for horizontal chrominance scaling\n");
else if (VAR_0->hChrFilterSize==8)
av_log(VAR_0, AV_LOG_VERBOSE, "using 8-tap MMX scaler for horizontal chrominance scaling\n");
else
av_log(VAR_0, AV_LOG_VERBOSE, "using n-tap MMX scaler for horizontal chrominance scaling\n");
}
} else {
#if HAVE_MMX
av_log(VAR_0, AV_LOG_VERBOSE, "using x86 asm scaler for horizontal scaling\n");
#else
if (VAR_13 & SWS_FAST_BILINEAR)
av_log(VAR_0, AV_LOG_VERBOSE, "using FAST_BILINEAR C scaler for horizontal scaling\n");
else
av_log(VAR_0, AV_LOG_VERBOSE, "using C scaler for horizontal scaling\n");
#endif
}
if (isPlanarYUV(VAR_16)) {
if (VAR_0->vLumFilterSize==1)
av_log(VAR_0, AV_LOG_VERBOSE, "using 1-tap %s \"scaler\" for vertical scaling (YV12 like)\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else
av_log(VAR_0, AV_LOG_VERBOSE, "using n-tap %s scaler for vertical scaling (YV12 like)\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
} else {
if (VAR_0->vLumFilterSize==1 && VAR_0->vChrFilterSize==2)
av_log(VAR_0, AV_LOG_VERBOSE, "using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
" 2-tap scaler for vertical chrominance scaling (BGR)\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (VAR_0->vLumFilterSize==2 && VAR_0->vChrFilterSize==2)
av_log(VAR_0, AV_LOG_VERBOSE, "using 2-tap linear %s scaler for vertical scaling (BGR)\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else
av_log(VAR_0, AV_LOG_VERBOSE, "using n-tap %s scaler for vertical scaling (BGR)\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
}
if (VAR_16==PIX_FMT_BGR24)
av_log(VAR_0, AV_LOG_VERBOSE, "using %s YV12->BGR24 converter\n",
(HAVE_MMX2 && VAR_14 & AV_CPU_FLAG_MMX2) ? "MMX2" :
((HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C"));
else if (VAR_16==PIX_FMT_RGB32)
av_log(VAR_0, AV_LOG_VERBOSE, "using %s YV12->BGR32 converter\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (VAR_16==PIX_FMT_BGR565)
av_log(VAR_0, AV_LOG_VERBOSE, "using %s YV12->BGR16 converter\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (VAR_16==PIX_FMT_BGR555)
av_log(VAR_0, AV_LOG_VERBOSE, "using %s YV12->BGR15 converter\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
else if (VAR_16 == PIX_FMT_RGB444BE || VAR_16 == PIX_FMT_RGB444LE ||
VAR_16 == PIX_FMT_BGR444BE || VAR_16 == PIX_FMT_BGR444LE)
av_log(VAR_0, AV_LOG_VERBOSE, "using %s YV12->BGR12 converter\n",
(HAVE_MMX && VAR_14 & AV_CPU_FLAG_MMX) ? "MMX" : "C");
av_log(VAR_0, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", VAR_7, VAR_8, VAR_9, VAR_10);
av_log(VAR_0, AV_LOG_DEBUG, "lum VAR_7=%d VAR_8=%d VAR_9=%d VAR_10=%d xInc=%d yInc=%d\n",
VAR_0->VAR_7, VAR_0->VAR_8, VAR_0->VAR_9, VAR_0->VAR_10, VAR_0->lumXInc, VAR_0->lumYInc);
av_log(VAR_0, AV_LOG_DEBUG, "chr VAR_7=%d VAR_8=%d VAR_9=%d VAR_10=%d xInc=%d yInc=%d\n",
VAR_0->chrSrcW, VAR_0->chrSrcH, VAR_0->chrDstW, VAR_0->chrDstH, VAR_0->chrXInc, VAR_0->chrYInc);
}
VAR_0->swScale= ff_getSwsFunc(VAR_0);
return 0;
fail:
return -1;
}
| [
"int FUNC_0(SwsContext *VAR_0, SwsFilter *VAR_1, SwsFilter *VAR_2)\n{",
"int VAR_3;",
"int VAR_4, VAR_5;",
"int VAR_6;",
"SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};",
"int VAR_7= VAR_0->VAR_7;",
"int VAR_8= VAR_0->VAR_8;",
"int VAR_9= VAR_0->VAR_9;",
"int VAR_10= VAR_0->VAR_10;",
"int VAR_11... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
45
],
[
47
... |
15,627 | static int kvmppc_get_pvinfo(CPUPPCState *env, struct kvm_ppc_pvinfo *pvinfo)
{
PowerPCCPU *cpu = ppc_env_get_cpu(env);
CPUState *cs = CPU(cpu);
if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_PVINFO) &&
!kvm_vm_ioctl(cs->kvm_state, KVM_PPC_GET_PVINFO, pvinfo)) {
return 0;
}
return 1;
}
| false | qemu | 6fd33a750214a866772dd77573cfa24c27ad956d | static int kvmppc_get_pvinfo(CPUPPCState *env, struct kvm_ppc_pvinfo *pvinfo)
{
PowerPCCPU *cpu = ppc_env_get_cpu(env);
CPUState *cs = CPU(cpu);
if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_PVINFO) &&
!kvm_vm_ioctl(cs->kvm_state, KVM_PPC_GET_PVINFO, pvinfo)) {
return 0;
}
return 1;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(CPUPPCState *VAR_0, struct kvm_ppc_pvinfo *VAR_1)
{
PowerPCCPU *cpu = ppc_env_get_cpu(VAR_0);
CPUState *cs = CPU(cpu);
if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_PVINFO) &&
!kvm_vm_ioctl(cs->kvm_state, KVM_PPC_GET_PVINFO, VAR_1)) {
return 0;
}
return 1;
}
| [
"static int FUNC_0(CPUPPCState *VAR_0, struct kvm_ppc_pvinfo *VAR_1)\n{",
"PowerPCCPU *cpu = ppc_env_get_cpu(VAR_0);",
"CPUState *cs = CPU(cpu);",
"if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_PVINFO) &&\n!kvm_vm_ioctl(cs->kvm_state, KVM_PPC_GET_PVINFO, VAR_1)) {",
"return 0;",
"}",
"return 1;... | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15
],
[
17
],
[
21
],
[
23
]
] |
15,629 | static void vncws_tls_handshake_io(void *opaque)
{
struct VncState *vs = (struct VncState *)opaque;
VNC_DEBUG("Handshake IO continue\n");
vncws_start_tls_handshake(vs);
}
| false | qemu | 51941e4695c6f6c1f786bacef7e8c3a477570e04 | static void vncws_tls_handshake_io(void *opaque)
{
struct VncState *vs = (struct VncState *)opaque;
VNC_DEBUG("Handshake IO continue\n");
vncws_start_tls_handshake(vs);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
struct VncState *VAR_1 = (struct VncState *)VAR_0;
VNC_DEBUG("Handshake IO continue\n");
vncws_start_tls_handshake(VAR_1);
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"struct VncState *VAR_1 = (struct VncState *)VAR_0;",
"VNC_DEBUG(\"Handshake IO continue\\n\");",
"vncws_start_tls_handshake(VAR_1);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
]
] |
15,630 | static void pause_all_vcpus(void)
{
CPUState *penv = first_cpu;
while (penv) {
penv->stop = 1;
qemu_thread_signal(penv->thread, SIGUSR1);
qemu_cpu_kick(penv);
penv = (CPUState *)penv->next_cpu;
}
while (!all_vcpus_paused()) {
qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
penv = first_cpu;
while (penv) {
qemu_thread_signal(penv->thread, SIGUSR1);
penv = (CPUState *)penv->next_cpu;
}
}
}
| false | qemu | cc84de9570ffe01a9c3c169bd62ab9586a9a080c | static void pause_all_vcpus(void)
{
CPUState *penv = first_cpu;
while (penv) {
penv->stop = 1;
qemu_thread_signal(penv->thread, SIGUSR1);
qemu_cpu_kick(penv);
penv = (CPUState *)penv->next_cpu;
}
while (!all_vcpus_paused()) {
qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
penv = first_cpu;
while (penv) {
qemu_thread_signal(penv->thread, SIGUSR1);
penv = (CPUState *)penv->next_cpu;
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
CPUState *penv = first_cpu;
while (penv) {
penv->stop = 1;
qemu_thread_signal(penv->thread, SIGUSR1);
qemu_cpu_kick(penv);
penv = (CPUState *)penv->next_cpu;
}
while (!all_vcpus_paused()) {
qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
penv = first_cpu;
while (penv) {
qemu_thread_signal(penv->thread, SIGUSR1);
penv = (CPUState *)penv->next_cpu;
}
}
}
| [
"static void FUNC_0(void)\n{",
"CPUState *penv = first_cpu;",
"while (penv) {",
"penv->stop = 1;",
"qemu_thread_signal(penv->thread, SIGUSR1);",
"qemu_cpu_kick(penv);",
"penv = (CPUState *)penv->next_cpu;",
"}",
"while (!all_vcpus_paused()) {",
"qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_m... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
]
] |
15,631 | static void pnv_icp_realize(DeviceState *dev, Error **errp)
{
PnvICPState *icp = PNV_ICP(dev);
memory_region_init_io(&icp->mmio, OBJECT(dev), &pnv_icp_ops,
icp, "icp-thread", 0x1000);
}
| false | qemu | 100f738850639a108d6767316ce4dcc1d1ea4ae4 | static void pnv_icp_realize(DeviceState *dev, Error **errp)
{
PnvICPState *icp = PNV_ICP(dev);
memory_region_init_io(&icp->mmio, OBJECT(dev), &pnv_icp_ops,
icp, "icp-thread", 0x1000);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
PnvICPState *icp = PNV_ICP(VAR_0);
memory_region_init_io(&icp->mmio, OBJECT(VAR_0), &pnv_icp_ops,
icp, "icp-thread", 0x1000);
}
| [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"PnvICPState *icp = PNV_ICP(VAR_0);",
"memory_region_init_io(&icp->mmio, OBJECT(VAR_0), &pnv_icp_ops,\nicp, \"icp-thread\", 0x1000);",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9,
11
],
[
13
]
] |
15,632 | static void usb_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
k->bus_type = TYPE_USB_BUS;
k->init = usb_qdev_init;
k->unplug = qdev_simple_unplug_cb;
k->exit = usb_qdev_exit;
k->props = usb_props;
}
| false | qemu | 7d553f27fce284805d7f94603932045ee3bbb979 | static void usb_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
k->bus_type = TYPE_USB_BUS;
k->init = usb_qdev_init;
k->unplug = qdev_simple_unplug_cb;
k->exit = usb_qdev_exit;
k->props = usb_props;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *k = DEVICE_CLASS(VAR_0);
k->bus_type = TYPE_USB_BUS;
k->init = usb_qdev_init;
k->unplug = qdev_simple_unplug_cb;
k->exit = usb_qdev_exit;
k->props = usb_props;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *k = DEVICE_CLASS(VAR_0);",
"k->bus_type = TYPE_USB_BUS;",
"k->init = usb_qdev_init;",
"k->unplug = qdev_simple_unplug_cb;",
"k->exit = usb_qdev_exit;",
"k->props = usb_props;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
15,633 | static void qmp_output_type_bool(Visitor *v, const char *name, bool *obj,
Error **errp)
{
QmpOutputVisitor *qov = to_qov(v);
qmp_output_add(qov, name, qbool_from_bool(*obj));
}
| false | qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | static void qmp_output_type_bool(Visitor *v, const char *name, bool *obj,
Error **errp)
{
QmpOutputVisitor *qov = to_qov(v);
qmp_output_add(qov, name, qbool_from_bool(*obj));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Visitor *VAR_0, const char *VAR_1, bool *VAR_2,
Error **VAR_3)
{
QmpOutputVisitor *qov = to_qov(VAR_0);
qmp_output_add(qov, VAR_1, qbool_from_bool(*VAR_2));
}
| [
"static void FUNC_0(Visitor *VAR_0, const char *VAR_1, bool *VAR_2,\nError **VAR_3)\n{",
"QmpOutputVisitor *qov = to_qov(VAR_0);",
"qmp_output_add(qov, VAR_1, qbool_from_bool(*VAR_2));",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
]
] |
15,636 | static unsigned int * create_elf_tables(char *p, int argc, int envc,
struct elfhdr * exec,
unsigned long load_addr,
unsigned long load_bias,
unsigned long interp_load_addr, int ibcs,
struct image_info *info)
{
target_ulong *argv, *envp;
target_ulong *sp, *csp;
/*
* Force 16 byte _final_ alignment here for generality.
*/
sp = (unsigned int *) (~15UL & (unsigned long) p);
csp = sp;
csp -= (DLINFO_ITEMS + 1) * 2;
#ifdef DLINFO_ARCH_ITEMS
csp -= DLINFO_ARCH_ITEMS*2;
#endif
csp -= envc+1;
csp -= argc+1;
csp -= (!ibcs ? 3 : 1); /* argc itself */
if ((unsigned long)csp & 15UL)
sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
#define NEW_AUX_ENT(nr, id, val) \
put_user (tswapl(id), sp + (nr * 2)); \
put_user (tswapl(val), sp + (nr * 2 + 1))
sp -= 2;
NEW_AUX_ENT (0, AT_NULL, 0);
sp -= DLINFO_ITEMS*2;
NEW_AUX_ENT( 0, AT_PHDR, (target_ulong)(load_addr + exec->e_phoff));
NEW_AUX_ENT( 1, AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
NEW_AUX_ENT( 2, AT_PHNUM, (target_ulong)(exec->e_phnum));
NEW_AUX_ENT( 3, AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
NEW_AUX_ENT( 4, AT_BASE, (target_ulong)(interp_load_addr));
NEW_AUX_ENT( 5, AT_FLAGS, (target_ulong)0);
NEW_AUX_ENT( 6, AT_ENTRY, load_bias + exec->e_entry);
NEW_AUX_ENT( 7, AT_UID, (target_ulong) getuid());
NEW_AUX_ENT( 8, AT_EUID, (target_ulong) geteuid());
NEW_AUX_ENT( 9, AT_GID, (target_ulong) getgid());
NEW_AUX_ENT(11, AT_EGID, (target_ulong) getegid());
#ifdef ARCH_DLINFO
/*
* ARCH_DLINFO must come last so platform specific code can enforce
* special alignment requirements on the AUXV if necessary (eg. PPC).
*/
ARCH_DLINFO;
#endif
#undef NEW_AUX_ENT
sp -= envc+1;
envp = sp;
sp -= argc+1;
argv = sp;
if (!ibcs) {
put_user(tswapl((target_ulong)envp),--sp);
put_user(tswapl((target_ulong)argv),--sp);
}
put_user(tswapl(argc),--sp);
info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
while (argc-->0) {
put_user(tswapl((target_ulong)p),argv++);
while (get_user(p++)) /* nothing */ ;
}
put_user(0,argv);
info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
while (envc-->0) {
put_user(tswapl((target_ulong)p),envp++);
while (get_user(p++)) /* nothing */ ;
}
put_user(0,envp);
info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
return sp;
}
| false | qemu | edf779ffccc836661a7b654d320571a6c220caea | static unsigned int * create_elf_tables(char *p, int argc, int envc,
struct elfhdr * exec,
unsigned long load_addr,
unsigned long load_bias,
unsigned long interp_load_addr, int ibcs,
struct image_info *info)
{
target_ulong *argv, *envp;
target_ulong *sp, *csp;
sp = (unsigned int *) (~15UL & (unsigned long) p);
csp = sp;
csp -= (DLINFO_ITEMS + 1) * 2;
#ifdef DLINFO_ARCH_ITEMS
csp -= DLINFO_ARCH_ITEMS*2;
#endif
csp -= envc+1;
csp -= argc+1;
csp -= (!ibcs ? 3 : 1);
if ((unsigned long)csp & 15UL)
sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
#define NEW_AUX_ENT(nr, id, val) \
put_user (tswapl(id), sp + (nr * 2)); \
put_user (tswapl(val), sp + (nr * 2 + 1))
sp -= 2;
NEW_AUX_ENT (0, AT_NULL, 0);
sp -= DLINFO_ITEMS*2;
NEW_AUX_ENT( 0, AT_PHDR, (target_ulong)(load_addr + exec->e_phoff));
NEW_AUX_ENT( 1, AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
NEW_AUX_ENT( 2, AT_PHNUM, (target_ulong)(exec->e_phnum));
NEW_AUX_ENT( 3, AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
NEW_AUX_ENT( 4, AT_BASE, (target_ulong)(interp_load_addr));
NEW_AUX_ENT( 5, AT_FLAGS, (target_ulong)0);
NEW_AUX_ENT( 6, AT_ENTRY, load_bias + exec->e_entry);
NEW_AUX_ENT( 7, AT_UID, (target_ulong) getuid());
NEW_AUX_ENT( 8, AT_EUID, (target_ulong) geteuid());
NEW_AUX_ENT( 9, AT_GID, (target_ulong) getgid());
NEW_AUX_ENT(11, AT_EGID, (target_ulong) getegid());
#ifdef ARCH_DLINFO
ARCH_DLINFO;
#endif
#undef NEW_AUX_ENT
sp -= envc+1;
envp = sp;
sp -= argc+1;
argv = sp;
if (!ibcs) {
put_user(tswapl((target_ulong)envp),--sp);
put_user(tswapl((target_ulong)argv),--sp);
}
put_user(tswapl(argc),--sp);
info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
while (argc-->0) {
put_user(tswapl((target_ulong)p),argv++);
while (get_user(p++)) ;
}
put_user(0,argv);
info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
while (envc-->0) {
put_user(tswapl((target_ulong)p),envp++);
while (get_user(p++)) ;
}
put_user(0,envp);
info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
return sp;
}
| {
"code": [],
"line_no": []
} | static unsigned int * FUNC_0(char *VAR_0, int VAR_1, int VAR_2,
struct elfhdr * VAR_3,
unsigned long VAR_4,
unsigned long VAR_5,
unsigned long VAR_6, int VAR_7,
struct image_info *VAR_8)
{
target_ulong *argv, *envp;
target_ulong *sp, *csp;
sp = (unsigned int *) (~15UL & (unsigned long) VAR_0);
csp = sp;
csp -= (DLINFO_ITEMS + 1) * 2;
#ifdef DLINFO_ARCH_ITEMS
csp -= DLINFO_ARCH_ITEMS*2;
#endif
csp -= VAR_2+1;
csp -= VAR_1+1;
csp -= (!VAR_7 ? 3 : 1);
if ((unsigned long)csp & 15UL)
sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
#define NEW_AUX_ENT(nr, id, val) \
put_user (tswapl(id), sp + (nr * 2)); \
put_user (tswapl(val), sp + (nr * 2 + 1))
sp -= 2;
NEW_AUX_ENT (0, AT_NULL, 0);
sp -= DLINFO_ITEMS*2;
NEW_AUX_ENT( 0, AT_PHDR, (target_ulong)(VAR_4 + VAR_3->e_phoff));
NEW_AUX_ENT( 1, AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
NEW_AUX_ENT( 2, AT_PHNUM, (target_ulong)(VAR_3->e_phnum));
NEW_AUX_ENT( 3, AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
NEW_AUX_ENT( 4, AT_BASE, (target_ulong)(VAR_6));
NEW_AUX_ENT( 5, AT_FLAGS, (target_ulong)0);
NEW_AUX_ENT( 6, AT_ENTRY, VAR_5 + VAR_3->e_entry);
NEW_AUX_ENT( 7, AT_UID, (target_ulong) getuid());
NEW_AUX_ENT( 8, AT_EUID, (target_ulong) geteuid());
NEW_AUX_ENT( 9, AT_GID, (target_ulong) getgid());
NEW_AUX_ENT(11, AT_EGID, (target_ulong) getegid());
#ifdef ARCH_DLINFO
ARCH_DLINFO;
#endif
#undef NEW_AUX_ENT
sp -= VAR_2+1;
envp = sp;
sp -= VAR_1+1;
argv = sp;
if (!VAR_7) {
put_user(tswapl((target_ulong)envp),--sp);
put_user(tswapl((target_ulong)argv),--sp);
}
put_user(tswapl(VAR_1),--sp);
VAR_8->arg_start = (unsigned int)((unsigned long)VAR_0 & 0xffffffff);
while (VAR_1-->0) {
put_user(tswapl((target_ulong)VAR_0),argv++);
while (get_user(VAR_0++)) ;
}
put_user(0,argv);
VAR_8->arg_end = VAR_8->env_start = (unsigned int)((unsigned long)VAR_0 & 0xffffffff);
while (VAR_2-->0) {
put_user(tswapl((target_ulong)VAR_0),envp++);
while (get_user(VAR_0++)) ;
}
put_user(0,envp);
VAR_8->env_end = (unsigned int)((unsigned long)VAR_0 & 0xffffffff);
return sp;
}
| [
"static unsigned int * FUNC_0(char *VAR_0, int VAR_1, int VAR_2,\nstruct elfhdr * VAR_3,\nunsigned long VAR_4,\nunsigned long VAR_5,\nunsigned long VAR_6, int VAR_7,\nstruct image_info *VAR_8)\n{",
"target_ulong *argv, *envp;",
"target_ulong *sp, *csp;",
"sp = (unsigned int *) (~15UL & (unsigned long) VAR_0);... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
17
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[
51,
53
],
[
55,
57
],
[
59
],
[
63
... |
15,637 | static void assigned_dev_msix_mmio_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
AssignedDevice *adev = opaque;
PCIDevice *pdev = &adev->dev;
uint16_t ctrl;
MSIXTableEntry orig;
int i = addr >> 4;
if (i >= adev->msix_max) {
return; /* Drop write */
}
ctrl = pci_get_word(pdev->config + pdev->msix_cap + PCI_MSIX_FLAGS);
DEBUG("write to MSI-X table offset 0x%lx, val 0x%lx\n", addr, val);
if (ctrl & PCI_MSIX_FLAGS_ENABLE) {
orig = adev->msix_table[i];
}
memcpy((uint8_t *)adev->msix_table + addr, &val, size);
if (ctrl & PCI_MSIX_FLAGS_ENABLE) {
MSIXTableEntry *entry = &adev->msix_table[i];
if (!assigned_dev_msix_masked(&orig) &&
assigned_dev_msix_masked(entry)) {
/*
* Vector masked, disable it
*
* XXX It's not clear if we can or should actually attempt
* to mask or disable the interrupt. KVM doesn't have
* support for pending bits and kvm_assign_set_msix_entry
* doesn't modify the device hardware mask. Interrupts
* while masked are simply not injected to the guest, so
* are lost. Can we get away with always injecting an
* interrupt on unmask?
*/
} else if (assigned_dev_msix_masked(&orig) &&
!assigned_dev_msix_masked(entry)) {
/* Vector unmasked */
if (i >= adev->msi_virq_nr || adev->msi_virq[i] < 0) {
/* Previously unassigned vector, start from scratch */
assigned_dev_update_msix(pdev);
return;
} else {
/* Update an existing, previously masked vector */
MSIMessage msg;
int ret;
msg.address = entry->addr_lo |
((uint64_t)entry->addr_hi << 32);
msg.data = entry->data;
ret = kvm_irqchip_update_msi_route(kvm_state,
adev->msi_virq[i], msg);
if (ret) {
error_report("Error updating irq routing entry (%d)", ret);
}
}
}
}
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void assigned_dev_msix_mmio_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
AssignedDevice *adev = opaque;
PCIDevice *pdev = &adev->dev;
uint16_t ctrl;
MSIXTableEntry orig;
int i = addr >> 4;
if (i >= adev->msix_max) {
return;
}
ctrl = pci_get_word(pdev->config + pdev->msix_cap + PCI_MSIX_FLAGS);
DEBUG("write to MSI-X table offset 0x%lx, val 0x%lx\n", addr, val);
if (ctrl & PCI_MSIX_FLAGS_ENABLE) {
orig = adev->msix_table[i];
}
memcpy((uint8_t *)adev->msix_table + addr, &val, size);
if (ctrl & PCI_MSIX_FLAGS_ENABLE) {
MSIXTableEntry *entry = &adev->msix_table[i];
if (!assigned_dev_msix_masked(&orig) &&
assigned_dev_msix_masked(entry)) {
} else if (assigned_dev_msix_masked(&orig) &&
!assigned_dev_msix_masked(entry)) {
if (i >= adev->msi_virq_nr || adev->msi_virq[i] < 0) {
assigned_dev_update_msix(pdev);
return;
} else {
MSIMessage msg;
int ret;
msg.address = entry->addr_lo |
((uint64_t)entry->addr_hi << 32);
msg.data = entry->data;
ret = kvm_irqchip_update_msi_route(kvm_state,
adev->msi_virq[i], msg);
if (ret) {
error_report("Error updating irq routing entry (%d)", ret);
}
}
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned VAR_3)
{
AssignedDevice *adev = VAR_0;
PCIDevice *pdev = &adev->dev;
uint16_t ctrl;
MSIXTableEntry orig;
int VAR_4 = VAR_1 >> 4;
if (VAR_4 >= adev->msix_max) {
return;
}
ctrl = pci_get_word(pdev->config + pdev->msix_cap + PCI_MSIX_FLAGS);
DEBUG("write to MSI-X table offset 0x%lx, VAR_2 0x%lx\n", VAR_1, VAR_2);
if (ctrl & PCI_MSIX_FLAGS_ENABLE) {
orig = adev->msix_table[VAR_4];
}
memcpy((uint8_t *)adev->msix_table + VAR_1, &VAR_2, VAR_3);
if (ctrl & PCI_MSIX_FLAGS_ENABLE) {
MSIXTableEntry *entry = &adev->msix_table[VAR_4];
if (!assigned_dev_msix_masked(&orig) &&
assigned_dev_msix_masked(entry)) {
} else if (assigned_dev_msix_masked(&orig) &&
!assigned_dev_msix_masked(entry)) {
if (VAR_4 >= adev->msi_virq_nr || adev->msi_virq[VAR_4] < 0) {
assigned_dev_update_msix(pdev);
return;
} else {
MSIMessage msg;
int VAR_5;
msg.address = entry->addr_lo |
((uint64_t)entry->addr_hi << 32);
msg.data = entry->data;
VAR_5 = kvm_irqchip_update_msi_route(kvm_state,
adev->msi_virq[VAR_4], msg);
if (VAR_5) {
error_report("Error updating irq routing entry (%d)", VAR_5);
}
}
}
}
}
| [
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{",
"AssignedDevice *adev = VAR_0;",
"PCIDevice *pdev = &adev->dev;",
"uint16_t ctrl;",
"MSIXTableEntry orig;",
"int VAR_4 = VAR_1 >> 4;",
"if (VAR_4 >= adev->msix_max) {",
"return;",
"}",
"ctrl = pci_get_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
27
],
[
31
],
[
35
],
[
37
],
[
39
],
[
43
],
[
47
],
[
49
],
[
53,
55
],
[
79
... |
15,638 | static void test_cancel(void)
{
WorkerTestData data[100];
int num_canceled;
int i;
/* Start more work items than there will be threads, to ensure
* the pool is full.
*/
test_submit_many();
/* Start long running jobs, to ensure we can cancel some. */
for (i = 0; i < 100; i++) {
data[i].n = 0;
data[i].ret = -EINPROGRESS;
data[i].aiocb = thread_pool_submit_aio(long_cb, &data[i],
done_cb, &data[i]);
}
/* Starting the threads may be left to a bottom half. Let it
* run, but do not waste too much time...
*/
active = 100;
qemu_aio_wait_nonblocking();
/* Wait some time for the threads to start, with some sanity
* testing on the behavior of the scheduler...
*/
g_assert_cmpint(active, ==, 100);
g_usleep(1000000);
g_assert_cmpint(active, >, 50);
/* Cancel the jobs that haven't been started yet. */
num_canceled = 0;
for (i = 0; i < 100; i++) {
if (__sync_val_compare_and_swap(&data[i].n, 0, 3) == 0) {
data[i].ret = -ECANCELED;
bdrv_aio_cancel(data[i].aiocb);
active--;
num_canceled++;
}
}
g_assert_cmpint(active, >, 0);
g_assert_cmpint(num_canceled, <, 100);
/* Canceling the others will be a blocking operation. */
for (i = 0; i < 100; i++) {
if (data[i].n != 3) {
bdrv_aio_cancel(data[i].aiocb);
}
}
/* Finish execution and execute any remaining callbacks. */
qemu_aio_wait_all();
g_assert_cmpint(active, ==, 0);
for (i = 0; i < 100; i++) {
if (data[i].n == 3) {
g_assert_cmpint(data[i].ret, ==, -ECANCELED);
g_assert(data[i].aiocb != NULL);
} else {
g_assert_cmpint(data[i].n, ==, 2);
g_assert_cmpint(data[i].ret, ==, 0);
g_assert(data[i].aiocb == NULL);
}
}
}
| false | qemu | c4d9d19645a484298a67e9021060bc7c2b081d0f | static void test_cancel(void)
{
WorkerTestData data[100];
int num_canceled;
int i;
test_submit_many();
for (i = 0; i < 100; i++) {
data[i].n = 0;
data[i].ret = -EINPROGRESS;
data[i].aiocb = thread_pool_submit_aio(long_cb, &data[i],
done_cb, &data[i]);
}
active = 100;
qemu_aio_wait_nonblocking();
g_assert_cmpint(active, ==, 100);
g_usleep(1000000);
g_assert_cmpint(active, >, 50);
num_canceled = 0;
for (i = 0; i < 100; i++) {
if (__sync_val_compare_and_swap(&data[i].n, 0, 3) == 0) {
data[i].ret = -ECANCELED;
bdrv_aio_cancel(data[i].aiocb);
active--;
num_canceled++;
}
}
g_assert_cmpint(active, >, 0);
g_assert_cmpint(num_canceled, <, 100);
for (i = 0; i < 100; i++) {
if (data[i].n != 3) {
bdrv_aio_cancel(data[i].aiocb);
}
}
qemu_aio_wait_all();
g_assert_cmpint(active, ==, 0);
for (i = 0; i < 100; i++) {
if (data[i].n == 3) {
g_assert_cmpint(data[i].ret, ==, -ECANCELED);
g_assert(data[i].aiocb != NULL);
} else {
g_assert_cmpint(data[i].n, ==, 2);
g_assert_cmpint(data[i].ret, ==, 0);
g_assert(data[i].aiocb == NULL);
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
WorkerTestData data[100];
int VAR_0;
int VAR_1;
test_submit_many();
for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {
data[VAR_1].n = 0;
data[VAR_1].ret = -EINPROGRESS;
data[VAR_1].aiocb = thread_pool_submit_aio(long_cb, &data[VAR_1],
done_cb, &data[VAR_1]);
}
active = 100;
qemu_aio_wait_nonblocking();
g_assert_cmpint(active, ==, 100);
g_usleep(1000000);
g_assert_cmpint(active, >, 50);
VAR_0 = 0;
for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {
if (__sync_val_compare_and_swap(&data[VAR_1].n, 0, 3) == 0) {
data[VAR_1].ret = -ECANCELED;
bdrv_aio_cancel(data[VAR_1].aiocb);
active--;
VAR_0++;
}
}
g_assert_cmpint(active, >, 0);
g_assert_cmpint(VAR_0, <, 100);
for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {
if (data[VAR_1].n != 3) {
bdrv_aio_cancel(data[VAR_1].aiocb);
}
}
qemu_aio_wait_all();
g_assert_cmpint(active, ==, 0);
for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {
if (data[VAR_1].n == 3) {
g_assert_cmpint(data[VAR_1].ret, ==, -ECANCELED);
g_assert(data[VAR_1].aiocb != NULL);
} else {
g_assert_cmpint(data[VAR_1].n, ==, 2);
g_assert_cmpint(data[VAR_1].ret, ==, 0);
g_assert(data[VAR_1].aiocb == NULL);
}
}
}
| [
"static void FUNC_0(void)\n{",
"WorkerTestData data[100];",
"int VAR_0;",
"int VAR_1;",
"test_submit_many();",
"for (VAR_1 = 0; VAR_1 < 100; VAR_1++) {",
"data[VAR_1].n = 0;",
"data[VAR_1].ret = -EINPROGRESS;",
"data[VAR_1].aiocb = thread_pool_submit_aio(long_cb, &data[VAR_1],\ndone_cb, &data[VAR_1]... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31,
33
],
[
35
],
[
45
],
[
47
],
[
57
],
[
59
],
[
61
],
[
67
],
[
69
],
[
71
],
[
73
],
[... |
15,639 | int qemu_paio_write(struct qemu_paiocb *aiocb)
{
return qemu_paio_submit(aiocb, QEMU_PAIO_WRITE);
}
| false | qemu | 9ef91a677110ec200d7b2904fc4bcae5a77329ad | int qemu_paio_write(struct qemu_paiocb *aiocb)
{
return qemu_paio_submit(aiocb, QEMU_PAIO_WRITE);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(struct qemu_paiocb *VAR_0)
{
return qemu_paio_submit(VAR_0, QEMU_PAIO_WRITE);
}
| [
"int FUNC_0(struct qemu_paiocb *VAR_0)\n{",
"return qemu_paio_submit(VAR_0, QEMU_PAIO_WRITE);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
15,640 | static ssize_t v9fs_synth_llistxattr(FsContext *ctx, V9fsPath *path,
void *value, size_t size)
{
errno = ENOTSUP;
return -1;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e | static ssize_t v9fs_synth_llistxattr(FsContext *ctx, V9fsPath *path,
void *value, size_t size)
{
errno = ENOTSUP;
return -1;
}
| {
"code": [],
"line_no": []
} | static ssize_t FUNC_0(FsContext *ctx, V9fsPath *path,
void *value, size_t size)
{
errno = ENOTSUP;
return -1;
}
| [
"static ssize_t FUNC_0(FsContext *ctx, V9fsPath *path,\nvoid *value, size_t size)\n{",
"errno = ENOTSUP;",
"return -1;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
]
] |
15,641 | static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs,
Error **errp)
{
char *p, *buf;
char *name;
char *value;
Error *local_err = NULL;
int ret = 0;
buf = g_strdup(keypairs);
p = buf;
while (p) {
name = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, p,
'=', "conf option name", &p, &local_err);
if (local_err) {
break;
}
if (!p) {
error_setg(errp, "conf option %s has no value", name);
ret = -EINVAL;
break;
}
value = qemu_rbd_next_tok(RBD_MAX_CONF_VAL_SIZE, p,
':', "conf option value", &p, &local_err);
if (local_err) {
break;
}
ret = rados_conf_set(cluster, name, value);
if (ret < 0) {
error_setg_errno(errp, -ret, "invalid conf option %s", name);
ret = -EINVAL;
break;
}
}
if (local_err) {
error_propagate(errp, local_err);
ret = -EINVAL;
}
g_free(buf);
return ret;
}
| false | qemu | 730b00bbfdc15f914f47e03a703fa7647c10c4a9 | static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs,
Error **errp)
{
char *p, *buf;
char *name;
char *value;
Error *local_err = NULL;
int ret = 0;
buf = g_strdup(keypairs);
p = buf;
while (p) {
name = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, p,
'=', "conf option name", &p, &local_err);
if (local_err) {
break;
}
if (!p) {
error_setg(errp, "conf option %s has no value", name);
ret = -EINVAL;
break;
}
value = qemu_rbd_next_tok(RBD_MAX_CONF_VAL_SIZE, p,
':', "conf option value", &p, &local_err);
if (local_err) {
break;
}
ret = rados_conf_set(cluster, name, value);
if (ret < 0) {
error_setg_errno(errp, -ret, "invalid conf option %s", name);
ret = -EINVAL;
break;
}
}
if (local_err) {
error_propagate(errp, local_err);
ret = -EINVAL;
}
g_free(buf);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(rados_t VAR_0, const char *VAR_1,
Error **VAR_2)
{
char *VAR_3, *VAR_4;
char *VAR_5;
char *VAR_6;
Error *local_err = NULL;
int VAR_7 = 0;
VAR_4 = g_strdup(VAR_1);
VAR_3 = VAR_4;
while (VAR_3) {
VAR_5 = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, VAR_3,
'=', "conf option VAR_5", &VAR_3, &local_err);
if (local_err) {
break;
}
if (!VAR_3) {
error_setg(VAR_2, "conf option %s has no VAR_6", VAR_5);
VAR_7 = -EINVAL;
break;
}
VAR_6 = qemu_rbd_next_tok(RBD_MAX_CONF_VAL_SIZE, VAR_3,
':', "conf option VAR_6", &VAR_3, &local_err);
if (local_err) {
break;
}
VAR_7 = rados_conf_set(VAR_0, VAR_5, VAR_6);
if (VAR_7 < 0) {
error_setg_errno(VAR_2, -VAR_7, "invalid conf option %s", VAR_5);
VAR_7 = -EINVAL;
break;
}
}
if (local_err) {
error_propagate(VAR_2, local_err);
VAR_7 = -EINVAL;
}
g_free(VAR_4);
return VAR_7;
}
| [
"static int FUNC_0(rados_t VAR_0, const char *VAR_1,\nError **VAR_2)\n{",
"char *VAR_3, *VAR_4;",
"char *VAR_5;",
"char *VAR_6;",
"Error *local_err = NULL;",
"int VAR_7 = 0;",
"VAR_4 = g_strdup(VAR_1);",
"VAR_3 = VAR_4;",
"while (VAR_3) {",
"VAR_5 = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, VAR_3,... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51,... |
15,642 | static void spapr_phb_remove_pci_device_cb(DeviceState *dev, void *opaque)
{
/* some version guests do not wait for completion of a device
* cleanup (generally done asynchronously by the kernel) before
* signaling to QEMU that the device is safe, but instead sleep
* for some 'safe' period of time. unfortunately on a busy host
* this sleep isn't guaranteed to be long enough, resulting in
* bad things like IRQ lines being left asserted during final
* device removal. to deal with this we call reset just prior
* to finalizing the device, which will put the device back into
* an 'idle' state, as the device cleanup code expects.
*/
pci_device_reset(PCI_DEVICE(dev));
object_unparent(OBJECT(dev));
}
| false | qemu | 318347234d7069b62d38391dd27e269a3107d668 | static void spapr_phb_remove_pci_device_cb(DeviceState *dev, void *opaque)
{
pci_device_reset(PCI_DEVICE(dev));
object_unparent(OBJECT(dev));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0, void *VAR_1)
{
pci_device_reset(PCI_DEVICE(VAR_0));
object_unparent(OBJECT(VAR_0));
}
| [
"static void FUNC_0(DeviceState *VAR_0, void *VAR_1)\n{",
"pci_device_reset(PCI_DEVICE(VAR_0));",
"object_unparent(OBJECT(VAR_0));",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
25
],
[
27
],
[
29
]
] |
15,643 | static QObject *parse_object(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
QDict *dict = NULL;
QObject *token, *peek;
QList *working = qlist_copy(*tokens);
token = qlist_pop(working);
if (token == NULL) {
goto out;
}
if (!token_is_operator(token, '{')) {
goto out;
}
qobject_decref(token);
token = NULL;
dict = qdict_new();
peek = qlist_peek(working);
if (peek == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
if (!token_is_operator(peek, '}')) {
if (parse_pair(ctxt, dict, &working, ap) == -1) {
goto out;
}
token = qlist_pop(working);
if (token == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
while (!token_is_operator(token, '}')) {
if (!token_is_operator(token, ',')) {
parse_error(ctxt, token, "expected separator in dict");
goto out;
}
qobject_decref(token);
token = NULL;
if (parse_pair(ctxt, dict, &working, ap) == -1) {
goto out;
}
token = qlist_pop(working);
if (token == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
}
qobject_decref(token);
token = NULL;
} else {
token = qlist_pop(working);
qobject_decref(token);
token = NULL;
}
QDECREF(*tokens);
*tokens = working;
return QOBJECT(dict);
out:
qobject_decref(token);
QDECREF(working);
QDECREF(dict);
return NULL;
}
| false | qemu | 65c0f1e9558c7c762cdb333406243fff1d687117 | static QObject *parse_object(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
QDict *dict = NULL;
QObject *token, *peek;
QList *working = qlist_copy(*tokens);
token = qlist_pop(working);
if (token == NULL) {
goto out;
}
if (!token_is_operator(token, '{')) {
goto out;
}
qobject_decref(token);
token = NULL;
dict = qdict_new();
peek = qlist_peek(working);
if (peek == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
if (!token_is_operator(peek, '}')) {
if (parse_pair(ctxt, dict, &working, ap) == -1) {
goto out;
}
token = qlist_pop(working);
if (token == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
while (!token_is_operator(token, '}')) {
if (!token_is_operator(token, ',')) {
parse_error(ctxt, token, "expected separator in dict");
goto out;
}
qobject_decref(token);
token = NULL;
if (parse_pair(ctxt, dict, &working, ap) == -1) {
goto out;
}
token = qlist_pop(working);
if (token == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
}
qobject_decref(token);
token = NULL;
} else {
token = qlist_pop(working);
qobject_decref(token);
token = NULL;
}
QDECREF(*tokens);
*tokens = working;
return QOBJECT(dict);
out:
qobject_decref(token);
QDECREF(working);
QDECREF(dict);
return NULL;
}
| {
"code": [],
"line_no": []
} | static QObject *FUNC_0(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
QDict *dict = NULL;
QObject *token, *peek;
QList *working = qlist_copy(*tokens);
token = qlist_pop(working);
if (token == NULL) {
goto out;
}
if (!token_is_operator(token, '{')) {
goto out;
}
qobject_decref(token);
token = NULL;
dict = qdict_new();
peek = qlist_peek(working);
if (peek == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
if (!token_is_operator(peek, '}')) {
if (parse_pair(ctxt, dict, &working, ap) == -1) {
goto out;
}
token = qlist_pop(working);
if (token == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
while (!token_is_operator(token, '}')) {
if (!token_is_operator(token, ',')) {
parse_error(ctxt, token, "expected separator in dict");
goto out;
}
qobject_decref(token);
token = NULL;
if (parse_pair(ctxt, dict, &working, ap) == -1) {
goto out;
}
token = qlist_pop(working);
if (token == NULL) {
parse_error(ctxt, NULL, "premature EOI");
goto out;
}
}
qobject_decref(token);
token = NULL;
} else {
token = qlist_pop(working);
qobject_decref(token);
token = NULL;
}
QDECREF(*tokens);
*tokens = working;
return QOBJECT(dict);
out:
qobject_decref(token);
QDECREF(working);
QDECREF(dict);
return NULL;
}
| [
"static QObject *FUNC_0(JSONParserContext *ctxt, QList **tokens, va_list *ap)\n{",
"QDict *dict = NULL;",
"QObject *token, *peek;",
"QList *working = qlist_copy(*tokens);",
"token = qlist_pop(working);",
"if (token == NULL) {",
"goto out;",
"}",
"if (!token_is_operator(token, '{')) {",
"goto out;"... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
... |
15,645 | static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum)
{
BDRVQcow2State *s = bs->opaque;
uint64_t cluster_offset;
int index_in_cluster, ret;
int64_t status = 0;
*pnum = nb_sectors;
qemu_co_mutex_lock(&s->lock);
ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
qemu_co_mutex_unlock(&s->lock);
if (ret < 0) {
return ret;
}
if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
!s->cipher) {
index_in_cluster = sector_num & (s->cluster_sectors - 1);
cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
}
if (ret == QCOW2_CLUSTER_ZERO) {
status |= BDRV_BLOCK_ZERO;
} else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
status |= BDRV_BLOCK_DATA;
}
return status;
}
| false | qemu | 67a0fd2a9bca204d2b39f910a97c7137636a0715 | static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum)
{
BDRVQcow2State *s = bs->opaque;
uint64_t cluster_offset;
int index_in_cluster, ret;
int64_t status = 0;
*pnum = nb_sectors;
qemu_co_mutex_lock(&s->lock);
ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
qemu_co_mutex_unlock(&s->lock);
if (ret < 0) {
return ret;
}
if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
!s->cipher) {
index_in_cluster = sector_num & (s->cluster_sectors - 1);
cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
}
if (ret == QCOW2_CLUSTER_ZERO) {
status |= BDRV_BLOCK_ZERO;
} else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
status |= BDRV_BLOCK_DATA;
}
return status;
}
| {
"code": [],
"line_no": []
} | static int64_t VAR_0 qcow2_co_get_block_status(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum)
{
BDRVQcow2State *s = bs->opaque;
uint64_t cluster_offset;
int index_in_cluster, ret;
int64_t status = 0;
*pnum = nb_sectors;
qemu_co_mutex_lock(&s->lock);
ret = qcow2_get_cluster_offset(bs, sector_num << 9, pnum, &cluster_offset);
qemu_co_mutex_unlock(&s->lock);
if (ret < 0) {
return ret;
}
if (cluster_offset != 0 && ret != QCOW2_CLUSTER_COMPRESSED &&
!s->cipher) {
index_in_cluster = sector_num & (s->cluster_sectors - 1);
cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
status |= BDRV_BLOCK_OFFSET_VALID | cluster_offset;
}
if (ret == QCOW2_CLUSTER_ZERO) {
status |= BDRV_BLOCK_ZERO;
} else if (ret != QCOW2_CLUSTER_UNALLOCATED) {
status |= BDRV_BLOCK_DATA;
}
return status;
}
| [
"static int64_t VAR_0 qcow2_co_get_block_status(BlockDriverState *bs,\nint64_t sector_num, int nb_sectors, int *pnum)\n{",
"BDRVQcow2State *s = bs->opaque;",
"uint64_t cluster_offset;",
"int index_in_cluster, ret;",
"int64_t status = 0;",
"*pnum = nb_sectors;",
"qemu_co_mutex_lock(&s->lock);",
"ret = ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
... |
15,646 | int avpriv_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le,
int depth, AVDictionary **metadata)
{
int i, ret;
int entries;
entries = ff_tget_short(gbytes, le);
if (bytestream2_get_bytes_left(gbytes) < entries * 12) {
return AVERROR_INVALIDDATA;
}
for (i = 0; i < entries; i++) {
if ((ret = exif_decode_tag(logctx, gbytes, le, depth, metadata)) < 0) {
return ret;
}
}
// return next IDF offset or 0x000000000 or a value < 0 for failure
return ff_tget_long(gbytes, le);
}
| false | FFmpeg | ae100046ca32b0b83031a60d0c3cdfc5ceb9f874 | int avpriv_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le,
int depth, AVDictionary **metadata)
{
int i, ret;
int entries;
entries = ff_tget_short(gbytes, le);
if (bytestream2_get_bytes_left(gbytes) < entries * 12) {
return AVERROR_INVALIDDATA;
}
for (i = 0; i < entries; i++) {
if ((ret = exif_decode_tag(logctx, gbytes, le, depth, metadata)) < 0) {
return ret;
}
}
return ff_tget_long(gbytes, le);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(void *VAR_0, GetByteContext *VAR_1, int VAR_2,
int VAR_3, AVDictionary **VAR_4)
{
int VAR_5, VAR_6;
int VAR_7;
VAR_7 = ff_tget_short(VAR_1, VAR_2);
if (bytestream2_get_bytes_left(VAR_1) < VAR_7 * 12) {
return AVERROR_INVALIDDATA;
}
for (VAR_5 = 0; VAR_5 < VAR_7; VAR_5++) {
if ((VAR_6 = exif_decode_tag(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4)) < 0) {
return VAR_6;
}
}
return ff_tget_long(VAR_1, VAR_2);
}
| [
"int FUNC_0(void *VAR_0, GetByteContext *VAR_1, int VAR_2,\nint VAR_3, AVDictionary **VAR_4)\n{",
"int VAR_5, VAR_6;",
"int VAR_7;",
"VAR_7 = ff_tget_short(VAR_1, VAR_2);",
"if (bytestream2_get_bytes_left(VAR_1) < VAR_7 * 12) {",
"return AVERROR_INVALIDDATA;",
"}",
"for (VAR_5 = 0; VAR_5 < VAR_7; VAR_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
39
],
[
41
]
] |
15,647 | static struct omap_rtc_s *omap_rtc_init(MemoryRegion *system_memory,
target_phys_addr_t base,
qemu_irq *irq, omap_clk clk)
{
struct omap_rtc_s *s = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
s->irq = irq[0];
s->alarm = irq[1];
s->clk = qemu_new_timer_ms(rt_clock, omap_rtc_tick, s);
omap_rtc_reset(s);
memory_region_init_io(&s->iomem, &omap_rtc_ops, s,
"omap-rtc", 0x800);
memory_region_add_subregion(system_memory, base, &s->iomem);
return s;
}
| false | qemu | 0919ac787641db11024912651f3bc5764d4f1286 | static struct omap_rtc_s *omap_rtc_init(MemoryRegion *system_memory,
target_phys_addr_t base,
qemu_irq *irq, omap_clk clk)
{
struct omap_rtc_s *s = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
s->irq = irq[0];
s->alarm = irq[1];
s->clk = qemu_new_timer_ms(rt_clock, omap_rtc_tick, s);
omap_rtc_reset(s);
memory_region_init_io(&s->iomem, &omap_rtc_ops, s,
"omap-rtc", 0x800);
memory_region_add_subregion(system_memory, base, &s->iomem);
return s;
}
| {
"code": [],
"line_no": []
} | static struct omap_rtc_s *FUNC_0(MemoryRegion *VAR_0,
target_phys_addr_t VAR_1,
qemu_irq *VAR_2, omap_clk VAR_3)
{
struct omap_rtc_s *VAR_4 = (struct omap_rtc_s *)
g_malloc0(sizeof(struct omap_rtc_s));
VAR_4->VAR_2 = VAR_2[0];
VAR_4->alarm = VAR_2[1];
VAR_4->VAR_3 = qemu_new_timer_ms(rt_clock, omap_rtc_tick, VAR_4);
omap_rtc_reset(VAR_4);
memory_region_init_io(&VAR_4->iomem, &omap_rtc_ops, VAR_4,
"omap-rtc", 0x800);
memory_region_add_subregion(VAR_0, VAR_1, &VAR_4->iomem);
return VAR_4;
}
| [
"static struct omap_rtc_s *FUNC_0(MemoryRegion *VAR_0,\ntarget_phys_addr_t VAR_1,\nqemu_irq *VAR_2, omap_clk VAR_3)\n{",
"struct omap_rtc_s *VAR_4 = (struct omap_rtc_s *)\ng_malloc0(sizeof(struct omap_rtc_s));",
"VAR_4->VAR_2 = VAR_2[0];",
"VAR_4->alarm = VAR_2[1];",
"VAR_4->VAR_3 = qemu_new_timer_ms(rt_clo... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9,
11
],
[
15
],
[
17
],
[
19
],
[
23
],
[
27,
29
],
[
31
],
[
35
],
[
37
]
] |
15,648 | static inline void patch_reloc(tcg_insn_unit *code_ptr, int type,
intptr_t value, intptr_t addend)
{
assert(addend == 0);
switch (type) {
case R_AARCH64_JUMP26:
case R_AARCH64_CALL26:
reloc_pc26(code_ptr, (tcg_insn_unit *)value);
break;
case R_AARCH64_CONDBR19:
reloc_pc19(code_ptr, (tcg_insn_unit *)value);
break;
default:
tcg_abort();
}
}
| false | qemu | eabb7b91b36b202b4dac2df2d59d698e3aff197a | static inline void patch_reloc(tcg_insn_unit *code_ptr, int type,
intptr_t value, intptr_t addend)
{
assert(addend == 0);
switch (type) {
case R_AARCH64_JUMP26:
case R_AARCH64_CALL26:
reloc_pc26(code_ptr, (tcg_insn_unit *)value);
break;
case R_AARCH64_CONDBR19:
reloc_pc19(code_ptr, (tcg_insn_unit *)value);
break;
default:
tcg_abort();
}
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(tcg_insn_unit *VAR_0, int VAR_1,
intptr_t VAR_2, intptr_t VAR_3)
{
assert(VAR_3 == 0);
switch (VAR_1) {
case R_AARCH64_JUMP26:
case R_AARCH64_CALL26:
reloc_pc26(VAR_0, (tcg_insn_unit *)VAR_2);
break;
case R_AARCH64_CONDBR19:
reloc_pc19(VAR_0, (tcg_insn_unit *)VAR_2);
break;
default:
tcg_abort();
}
}
| [
"static inline void FUNC_0(tcg_insn_unit *VAR_0, int VAR_1,\nintptr_t VAR_2, intptr_t VAR_3)\n{",
"assert(VAR_3 == 0);",
"switch (VAR_1) {",
"case R_AARCH64_JUMP26:\ncase R_AARCH64_CALL26:\nreloc_pc26(VAR_0, (tcg_insn_unit *)VAR_2);",
"break;",
"case R_AARCH64_CONDBR19:\nreloc_pc19(VAR_0, (tcg_insn_unit *... | [
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
]
] |
15,649 | static void disas_simd_mod_imm(DisasContext *s, uint32_t insn)
{
int rd = extract32(insn, 0, 5);
int cmode = extract32(insn, 12, 4);
int cmode_3_1 = extract32(cmode, 1, 3);
int cmode_0 = extract32(cmode, 0, 1);
int o2 = extract32(insn, 11, 1);
uint64_t abcdefgh = extract32(insn, 5, 5) | (extract32(insn, 16, 3) << 5);
bool is_neg = extract32(insn, 29, 1);
bool is_q = extract32(insn, 30, 1);
uint64_t imm = 0;
TCGv_i64 tcg_rd, tcg_imm;
int i;
if (o2 != 0 || ((cmode == 0xf) && is_neg && !is_q)) {
unallocated_encoding(s);
return;
}
if (!fp_access_check(s)) {
return;
}
/* See AdvSIMDExpandImm() in ARM ARM */
switch (cmode_3_1) {
case 0: /* Replicate(Zeros(24):imm8, 2) */
case 1: /* Replicate(Zeros(16):imm8:Zeros(8), 2) */
case 2: /* Replicate(Zeros(8):imm8:Zeros(16), 2) */
case 3: /* Replicate(imm8:Zeros(24), 2) */
{
int shift = cmode_3_1 * 8;
imm = bitfield_replicate(abcdefgh << shift, 32);
break;
}
case 4: /* Replicate(Zeros(8):imm8, 4) */
case 5: /* Replicate(imm8:Zeros(8), 4) */
{
int shift = (cmode_3_1 & 0x1) * 8;
imm = bitfield_replicate(abcdefgh << shift, 16);
break;
}
case 6:
if (cmode_0) {
/* Replicate(Zeros(8):imm8:Ones(16), 2) */
imm = (abcdefgh << 16) | 0xffff;
} else {
/* Replicate(Zeros(16):imm8:Ones(8), 2) */
imm = (abcdefgh << 8) | 0xff;
}
imm = bitfield_replicate(imm, 32);
break;
case 7:
if (!cmode_0 && !is_neg) {
imm = bitfield_replicate(abcdefgh, 8);
} else if (!cmode_0 && is_neg) {
int i;
imm = 0;
for (i = 0; i < 8; i++) {
if ((abcdefgh) & (1 << i)) {
imm |= 0xffULL << (i * 8);
}
}
} else if (cmode_0) {
if (is_neg) {
imm = (abcdefgh & 0x3f) << 48;
if (abcdefgh & 0x80) {
imm |= 0x8000000000000000ULL;
}
if (abcdefgh & 0x40) {
imm |= 0x3fc0000000000000ULL;
} else {
imm |= 0x4000000000000000ULL;
}
} else {
imm = (abcdefgh & 0x3f) << 19;
if (abcdefgh & 0x80) {
imm |= 0x80000000;
}
if (abcdefgh & 0x40) {
imm |= 0x3e000000;
} else {
imm |= 0x40000000;
}
imm |= (imm << 32);
}
}
break;
}
if (cmode_3_1 != 7 && is_neg) {
imm = ~imm;
}
tcg_imm = tcg_const_i64(imm);
tcg_rd = new_tmp_a64(s);
for (i = 0; i < 2; i++) {
int foffs = i ? fp_reg_hi_offset(rd) : fp_reg_offset(rd, MO_64);
if (i == 1 && !is_q) {
/* non-quad ops clear high half of vector */
tcg_gen_movi_i64(tcg_rd, 0);
} else if ((cmode & 0x9) == 0x1 || (cmode & 0xd) == 0x9) {
tcg_gen_ld_i64(tcg_rd, cpu_env, foffs);
if (is_neg) {
/* AND (BIC) */
tcg_gen_and_i64(tcg_rd, tcg_rd, tcg_imm);
} else {
/* ORR */
tcg_gen_or_i64(tcg_rd, tcg_rd, tcg_imm);
}
} else {
/* MOVI */
tcg_gen_mov_i64(tcg_rd, tcg_imm);
}
tcg_gen_st_i64(tcg_rd, cpu_env, foffs);
}
tcg_temp_free_i64(tcg_imm);
}
| false | qemu | 90e496386fe7fd32c189561f846b7913f95b8cf4 | static void disas_simd_mod_imm(DisasContext *s, uint32_t insn)
{
int rd = extract32(insn, 0, 5);
int cmode = extract32(insn, 12, 4);
int cmode_3_1 = extract32(cmode, 1, 3);
int cmode_0 = extract32(cmode, 0, 1);
int o2 = extract32(insn, 11, 1);
uint64_t abcdefgh = extract32(insn, 5, 5) | (extract32(insn, 16, 3) << 5);
bool is_neg = extract32(insn, 29, 1);
bool is_q = extract32(insn, 30, 1);
uint64_t imm = 0;
TCGv_i64 tcg_rd, tcg_imm;
int i;
if (o2 != 0 || ((cmode == 0xf) && is_neg && !is_q)) {
unallocated_encoding(s);
return;
}
if (!fp_access_check(s)) {
return;
}
switch (cmode_3_1) {
case 0:
case 1:
case 2:
case 3:
{
int shift = cmode_3_1 * 8;
imm = bitfield_replicate(abcdefgh << shift, 32);
break;
}
case 4:
case 5:
{
int shift = (cmode_3_1 & 0x1) * 8;
imm = bitfield_replicate(abcdefgh << shift, 16);
break;
}
case 6:
if (cmode_0) {
imm = (abcdefgh << 16) | 0xffff;
} else {
imm = (abcdefgh << 8) | 0xff;
}
imm = bitfield_replicate(imm, 32);
break;
case 7:
if (!cmode_0 && !is_neg) {
imm = bitfield_replicate(abcdefgh, 8);
} else if (!cmode_0 && is_neg) {
int i;
imm = 0;
for (i = 0; i < 8; i++) {
if ((abcdefgh) & (1 << i)) {
imm |= 0xffULL << (i * 8);
}
}
} else if (cmode_0) {
if (is_neg) {
imm = (abcdefgh & 0x3f) << 48;
if (abcdefgh & 0x80) {
imm |= 0x8000000000000000ULL;
}
if (abcdefgh & 0x40) {
imm |= 0x3fc0000000000000ULL;
} else {
imm |= 0x4000000000000000ULL;
}
} else {
imm = (abcdefgh & 0x3f) << 19;
if (abcdefgh & 0x80) {
imm |= 0x80000000;
}
if (abcdefgh & 0x40) {
imm |= 0x3e000000;
} else {
imm |= 0x40000000;
}
imm |= (imm << 32);
}
}
break;
}
if (cmode_3_1 != 7 && is_neg) {
imm = ~imm;
}
tcg_imm = tcg_const_i64(imm);
tcg_rd = new_tmp_a64(s);
for (i = 0; i < 2; i++) {
int foffs = i ? fp_reg_hi_offset(rd) : fp_reg_offset(rd, MO_64);
if (i == 1 && !is_q) {
tcg_gen_movi_i64(tcg_rd, 0);
} else if ((cmode & 0x9) == 0x1 || (cmode & 0xd) == 0x9) {
tcg_gen_ld_i64(tcg_rd, cpu_env, foffs);
if (is_neg) {
tcg_gen_and_i64(tcg_rd, tcg_rd, tcg_imm);
} else {
tcg_gen_or_i64(tcg_rd, tcg_rd, tcg_imm);
}
} else {
tcg_gen_mov_i64(tcg_rd, tcg_imm);
}
tcg_gen_st_i64(tcg_rd, cpu_env, foffs);
}
tcg_temp_free_i64(tcg_imm);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)
{
int VAR_2 = extract32(VAR_1, 0, 5);
int VAR_3 = extract32(VAR_1, 12, 4);
int VAR_4 = extract32(VAR_3, 1, 3);
int VAR_5 = extract32(VAR_3, 0, 1);
int VAR_6 = extract32(VAR_1, 11, 1);
uint64_t abcdefgh = extract32(VAR_1, 5, 5) | (extract32(VAR_1, 16, 3) << 5);
bool is_neg = extract32(VAR_1, 29, 1);
bool is_q = extract32(VAR_1, 30, 1);
uint64_t imm = 0;
TCGv_i64 tcg_rd, tcg_imm;
int VAR_9;
if (VAR_6 != 0 || ((VAR_3 == 0xf) && is_neg && !is_q)) {
unallocated_encoding(VAR_0);
return;
}
if (!fp_access_check(VAR_0)) {
return;
}
switch (VAR_4) {
case 0:
case 1:
case 2:
case 3:
{
int VAR_9 = VAR_4 * 8;
imm = bitfield_replicate(abcdefgh << VAR_9, 32);
break;
}
case 4:
case 5:
{
int VAR_9 = (VAR_4 & 0x1) * 8;
imm = bitfield_replicate(abcdefgh << VAR_9, 16);
break;
}
case 6:
if (VAR_5) {
imm = (abcdefgh << 16) | 0xffff;
} else {
imm = (abcdefgh << 8) | 0xff;
}
imm = bitfield_replicate(imm, 32);
break;
case 7:
if (!VAR_5 && !is_neg) {
imm = bitfield_replicate(abcdefgh, 8);
} else if (!VAR_5 && is_neg) {
int VAR_9;
imm = 0;
for (VAR_9 = 0; VAR_9 < 8; VAR_9++) {
if ((abcdefgh) & (1 << VAR_9)) {
imm |= 0xffULL << (VAR_9 * 8);
}
}
} else if (VAR_5) {
if (is_neg) {
imm = (abcdefgh & 0x3f) << 48;
if (abcdefgh & 0x80) {
imm |= 0x8000000000000000ULL;
}
if (abcdefgh & 0x40) {
imm |= 0x3fc0000000000000ULL;
} else {
imm |= 0x4000000000000000ULL;
}
} else {
imm = (abcdefgh & 0x3f) << 19;
if (abcdefgh & 0x80) {
imm |= 0x80000000;
}
if (abcdefgh & 0x40) {
imm |= 0x3e000000;
} else {
imm |= 0x40000000;
}
imm |= (imm << 32);
}
}
break;
}
if (VAR_4 != 7 && is_neg) {
imm = ~imm;
}
tcg_imm = tcg_const_i64(imm);
tcg_rd = new_tmp_a64(VAR_0);
for (VAR_9 = 0; VAR_9 < 2; VAR_9++) {
int VAR_9 = VAR_9 ? fp_reg_hi_offset(VAR_2) : fp_reg_offset(VAR_2, MO_64);
if (VAR_9 == 1 && !is_q) {
tcg_gen_movi_i64(tcg_rd, 0);
} else if ((VAR_3 & 0x9) == 0x1 || (VAR_3 & 0xd) == 0x9) {
tcg_gen_ld_i64(tcg_rd, cpu_env, VAR_9);
if (is_neg) {
tcg_gen_and_i64(tcg_rd, tcg_rd, tcg_imm);
} else {
tcg_gen_or_i64(tcg_rd, tcg_rd, tcg_imm);
}
} else {
tcg_gen_mov_i64(tcg_rd, tcg_imm);
}
tcg_gen_st_i64(tcg_rd, cpu_env, VAR_9);
}
tcg_temp_free_i64(tcg_imm);
}
| [
"static void FUNC_0(DisasContext *VAR_0, uint32_t VAR_1)\n{",
"int VAR_2 = extract32(VAR_1, 0, 5);",
"int VAR_3 = extract32(VAR_1, 12, 4);",
"int VAR_4 = extract32(VAR_3, 1, 3);",
"int VAR_5 = extract32(VAR_3, 0, 1);",
"int VAR_6 = extract32(VAR_1, 11, 1);",
"uint64_t abcdefgh = extract32(VAR_1, 5, 5) |... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
49
... |
15,650 | int tcp_ctl(struct socket *so)
{
Slirp *slirp = so->slirp;
struct sbuf *sb = &so->so_snd;
struct ex_list *ex_ptr;
int do_pty;
DEBUG_CALL("tcp_ctl");
DEBUG_ARG("so = %lx", (long )so);
if (so->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
/* Check if it's pty_exec */
for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
if (ex_ptr->ex_fport == so->so_fport &&
so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr) {
if (ex_ptr->ex_pty == 3) {
so->s = -1;
so->extra = (void *)ex_ptr->ex_exec;
return 1;
}
do_pty = ex_ptr->ex_pty;
DEBUG_MISC((dfd, " executing %s \n",ex_ptr->ex_exec));
return fork_exec(so, ex_ptr->ex_exec, do_pty);
}
}
}
sb->sb_cc =
snprintf(sb->sb_wptr, sb->sb_datalen - (sb->sb_wptr - sb->sb_data),
"Error: No application configured.\r\n");
sb->sb_wptr += sb->sb_cc;
return 0;
}
| false | qemu | b2bedb214469af55179d907a60cd67fed6b0779e | int tcp_ctl(struct socket *so)
{
Slirp *slirp = so->slirp;
struct sbuf *sb = &so->so_snd;
struct ex_list *ex_ptr;
int do_pty;
DEBUG_CALL("tcp_ctl");
DEBUG_ARG("so = %lx", (long )so);
if (so->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
if (ex_ptr->ex_fport == so->so_fport &&
so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr) {
if (ex_ptr->ex_pty == 3) {
so->s = -1;
so->extra = (void *)ex_ptr->ex_exec;
return 1;
}
do_pty = ex_ptr->ex_pty;
DEBUG_MISC((dfd, " executing %s \n",ex_ptr->ex_exec));
return fork_exec(so, ex_ptr->ex_exec, do_pty);
}
}
}
sb->sb_cc =
snprintf(sb->sb_wptr, sb->sb_datalen - (sb->sb_wptr - sb->sb_data),
"Error: No application configured.\r\n");
sb->sb_wptr += sb->sb_cc;
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(struct socket *VAR_0)
{
Slirp *slirp = VAR_0->slirp;
struct sbuf *VAR_1 = &VAR_0->so_snd;
struct ex_list *VAR_2;
int VAR_3;
DEBUG_CALL("FUNC_0");
DEBUG_ARG("VAR_0 = %lx", (long )VAR_0);
if (VAR_0->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
for (VAR_2 = slirp->exec_list; VAR_2; VAR_2 = VAR_2->ex_next) {
if (VAR_2->ex_fport == VAR_0->so_fport &&
VAR_0->so_faddr.s_addr == VAR_2->ex_addr.s_addr) {
if (VAR_2->ex_pty == 3) {
VAR_0->s = -1;
VAR_0->extra = (void *)VAR_2->ex_exec;
return 1;
}
VAR_3 = VAR_2->ex_pty;
DEBUG_MISC((dfd, " executing %s \n",VAR_2->ex_exec));
return fork_exec(VAR_0, VAR_2->ex_exec, VAR_3);
}
}
}
VAR_1->sb_cc =
snprintf(VAR_1->sb_wptr, VAR_1->sb_datalen - (VAR_1->sb_wptr - VAR_1->sb_data),
"Error: No application configured.\r\n");
VAR_1->sb_wptr += VAR_1->sb_cc;
return 0;
}
| [
"int FUNC_0(struct socket *VAR_0)\n{",
"Slirp *slirp = VAR_0->slirp;",
"struct sbuf *VAR_1 = &VAR_0->so_snd;",
"struct ex_list *VAR_2;",
"int VAR_3;",
"DEBUG_CALL(\"FUNC_0\");",
"DEBUG_ARG(\"VAR_0 = %lx\", (long )VAR_0);",
"if (VAR_0->so_faddr.s_addr != slirp->vhost_addr.s_addr) {",
"for (VAR_2 = sl... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[... |
15,651 | void cpu_outl(CPUState *env, pio_addr_t addr, uint32_t val)
{
LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
ioport_write(2, addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
}
| false | qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | void cpu_outl(CPUState *env, pio_addr_t addr, uint32_t val)
{
LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);
ioport_write(2, addr, val);
#ifdef CONFIG_KQEMU
if (env)
env->last_io_time = cpu_get_time_fast();
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUState *VAR_0, pio_addr_t VAR_1, uint32_t VAR_2)
{
LOG_IOPORT("outl: %04"FMT_pioaddr" %08"PRIx32"\n", VAR_1, VAR_2);
ioport_write(2, VAR_1, VAR_2);
#ifdef CONFIG_KQEMU
if (VAR_0)
VAR_0->last_io_time = cpu_get_time_fast();
#endif
}
| [
"void FUNC_0(CPUState *VAR_0, pio_addr_t VAR_1, uint32_t VAR_2)\n{",
"LOG_IOPORT(\"outl: %04\"FMT_pioaddr\" %08\"PRIx32\"\\n\", VAR_1, VAR_2);",
"ioport_write(2, VAR_1, VAR_2);",
"#ifdef CONFIG_KQEMU\nif (VAR_0)\nVAR_0->last_io_time = cpu_get_time_fast();",
"#endif\n}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9,
11,
13
],
[
15,
17
]
] |
15,652 | static int v9fs_synth_lsetxattr(FsContext *ctx, V9fsPath *path,
const char *name, void *value,
size_t size, int flags)
{
errno = ENOTSUP;
return -1;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e | static int v9fs_synth_lsetxattr(FsContext *ctx, V9fsPath *path,
const char *name, void *value,
size_t size, int flags)
{
errno = ENOTSUP;
return -1;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,
const char *VAR_2, void *VAR_3,
size_t VAR_4, int VAR_5)
{
errno = ENOTSUP;
return -1;
}
| [
"static int FUNC_0(FsContext *VAR_0, V9fsPath *VAR_1,\nconst char *VAR_2, void *VAR_3,\nsize_t VAR_4, int VAR_5)\n{",
"errno = ENOTSUP;",
"return -1;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
]
] |
15,656 | static void register_types(void)
{
register_char_driver_qapi("null", CHARDEV_BACKEND_KIND_NULL, NULL);
register_char_driver("socket", qemu_chr_open_socket);
register_char_driver("udp", qemu_chr_open_udp);
register_char_driver("memory", qemu_chr_open_ringbuf);
register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE,
qemu_chr_parse_file_out);
register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO,
qemu_chr_parse_stdio);
register_char_driver_qapi("serial", CHARDEV_BACKEND_KIND_SERIAL,
qemu_chr_parse_serial);
register_char_driver_qapi("tty", CHARDEV_BACKEND_KIND_SERIAL,
qemu_chr_parse_serial);
register_char_driver_qapi("parallel", CHARDEV_BACKEND_KIND_PARALLEL,
qemu_chr_parse_parallel);
register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL,
qemu_chr_parse_parallel);
#ifdef _WIN32
register_char_driver("pipe", qemu_chr_open_win_pipe);
register_char_driver("console", qemu_chr_open_win_con);
#else
register_char_driver("pipe", qemu_chr_open_pipe);
#endif
#ifdef HAVE_CHARDEV_TTY
register_char_driver("pty", qemu_chr_open_pty);
#endif
}
| false | qemu | e68c5958668596a5023e30ddf8368410878f7682 | static void register_types(void)
{
register_char_driver_qapi("null", CHARDEV_BACKEND_KIND_NULL, NULL);
register_char_driver("socket", qemu_chr_open_socket);
register_char_driver("udp", qemu_chr_open_udp);
register_char_driver("memory", qemu_chr_open_ringbuf);
register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE,
qemu_chr_parse_file_out);
register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO,
qemu_chr_parse_stdio);
register_char_driver_qapi("serial", CHARDEV_BACKEND_KIND_SERIAL,
qemu_chr_parse_serial);
register_char_driver_qapi("tty", CHARDEV_BACKEND_KIND_SERIAL,
qemu_chr_parse_serial);
register_char_driver_qapi("parallel", CHARDEV_BACKEND_KIND_PARALLEL,
qemu_chr_parse_parallel);
register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL,
qemu_chr_parse_parallel);
#ifdef _WIN32
register_char_driver("pipe", qemu_chr_open_win_pipe);
register_char_driver("console", qemu_chr_open_win_con);
#else
register_char_driver("pipe", qemu_chr_open_pipe);
#endif
#ifdef HAVE_CHARDEV_TTY
register_char_driver("pty", qemu_chr_open_pty);
#endif
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
register_char_driver_qapi("null", CHARDEV_BACKEND_KIND_NULL, NULL);
register_char_driver("socket", qemu_chr_open_socket);
register_char_driver("udp", qemu_chr_open_udp);
register_char_driver("memory", qemu_chr_open_ringbuf);
register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE,
qemu_chr_parse_file_out);
register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO,
qemu_chr_parse_stdio);
register_char_driver_qapi("serial", CHARDEV_BACKEND_KIND_SERIAL,
qemu_chr_parse_serial);
register_char_driver_qapi("tty", CHARDEV_BACKEND_KIND_SERIAL,
qemu_chr_parse_serial);
register_char_driver_qapi("parallel", CHARDEV_BACKEND_KIND_PARALLEL,
qemu_chr_parse_parallel);
register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL,
qemu_chr_parse_parallel);
#ifdef _WIN32
register_char_driver("pipe", qemu_chr_open_win_pipe);
register_char_driver("console", qemu_chr_open_win_con);
#else
register_char_driver("pipe", qemu_chr_open_pipe);
#endif
#ifdef HAVE_CHARDEV_TTY
register_char_driver("pty", qemu_chr_open_pty);
#endif
}
| [
"static void FUNC_0(void)\n{",
"register_char_driver_qapi(\"null\", CHARDEV_BACKEND_KIND_NULL, NULL);",
"register_char_driver(\"socket\", qemu_chr_open_socket);",
"register_char_driver(\"udp\", qemu_chr_open_udp);",
"register_char_driver(\"memory\", qemu_chr_open_ringbuf);",
"register_char_driver_qapi(\"f... | [
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
... |
15,657 | static void FUNCC(pred8x8_vertical_add)(uint8_t *pix, const int *block_offset,
const int16_t *block, ptrdiff_t stride)
{
int i;
for(i=0; i<4; i++)
FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
}
| false | FFmpeg | 1acd7d594c15aa491729c837ad3519d3469e620a | static void FUNCC(pred8x8_vertical_add)(uint8_t *pix, const int *block_offset,
const int16_t *block, ptrdiff_t stride)
{
int i;
for(i=0; i<4; i++)
FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(pred8x8_vertical_add)(uint8_t *pix, const int *block_offset,
const int16_t *block, ptrdiff_t stride)
{
int VAR_0;
for(VAR_0=0; VAR_0<4; VAR_0++)
FUNC_0(pred4x4_vertical_add)(pix + block_offset[VAR_0], block + VAR_0*16*sizeof(pixel), stride);
}
| [
"static void FUNC_0(pred8x8_vertical_add)(uint8_t *pix, const int *block_offset,\nconst int16_t *block, ptrdiff_t stride)\n{",
"int VAR_0;",
"for(VAR_0=0; VAR_0<4; VAR_0++)",
"FUNC_0(pred4x4_vertical_add)(pix + block_offset[VAR_0], block + VAR_0*16*sizeof(pixel), stride);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
15,658 | static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
UINT8 *buf_ptr1,
const UINT16 *mb_pos_ptr)
{
int quant, dc, dct_mode, class1, j;
int mb_index, mb_x, mb_y, v, last_index;
DCTELEM *block, *block1;
int c_offset, bits_left;
UINT8 *y_ptr;
BlockInfo mb_data[5 * 6], *mb, *mb1;
void (*idct_put)(UINT8 *dest, int line_size, DCTELEM *block);
UINT8 *buf_ptr;
PutBitContext pb, vs_pb;
UINT8 mb_bit_buffer[80 + 4]; /* allow some slack */
int mb_bit_count;
UINT8 vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
int vs_bit_count;
memset(s->block, 0, sizeof(s->block));
/* pass 1 : read DC and AC coefficients in blocks */
buf_ptr = buf_ptr1;
block1 = &s->block[0][0];
mb1 = mb_data;
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);
vs_bit_count = 0;
for(mb_index = 0; mb_index < 5; mb_index++) {
/* skip header */
quant = buf_ptr[3] & 0x0f;
buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);
mb_bit_count = 0;
mb = mb1;
block = block1;
for(j = 0;j < 6; j++) {
/* NOTE: size is not important here */
init_get_bits(&s->gb, buf_ptr, 14);
/* get the dc */
dc = get_bits(&s->gb, 9);
dc = (dc << (32 - 9)) >> (32 - 9);
dct_mode = get_bits1(&s->gb);
mb->dct_mode = dct_mode;
mb->scan_table = s->dv_zigzag[dct_mode];
class1 = get_bits(&s->gb, 2);
mb->shift_offset = (class1 == 3);
mb->shift_table = s->dv_shift[dct_mode]
[quant + dv_quant_offset[class1]];
dc = dc << 2;
/* convert to unsigned because 128 is not added in the
standard IDCT */
dc += 1024;
block[0] = dc;
last_index = block_sizes[j];
buf_ptr += last_index >> 3;
mb->pos = 0;
mb->partial_bit_count = 0;
dv_decode_ac(s, mb, block, last_index);
/* write the remaining bits in a new buffer only if the
block is finished */
bits_left = last_index - s->gb.index;
if (mb->eob_reached) {
mb->partial_bit_count = 0;
mb_bit_count += bits_left;
bit_copy(&pb, &s->gb, bits_left);
} else {
/* should be < 16 bits otherwise a codeword could have
been parsed */
mb->partial_bit_count = bits_left;
mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
}
block += 64;
mb++;
}
flush_put_bits(&pb);
/* pass 2 : we can do it just after */
#ifdef VLC_DEBUG
printf("***pass 2 size=%d\n", mb_bit_count);
#endif
block = block1;
mb = mb1;
init_get_bits(&s->gb, mb_bit_buffer, 80);
for(j = 0;j < 6; j++) {
if (!mb->eob_reached && s->gb.index < mb_bit_count) {
dv_decode_ac(s, mb, block, mb_bit_count);
/* if still not finished, no need to parse other blocks */
if (!mb->eob_reached) {
/* we could not parse the current AC coefficient,
so we add the remaining bytes */
bits_left = mb_bit_count - s->gb.index;
if (bits_left > 0) {
mb->partial_bit_count += bits_left;
mb->partial_bit_buffer =
(mb->partial_bit_buffer << bits_left) |
get_bits(&s->gb, bits_left);
}
goto next_mb;
}
}
block += 64;
mb++;
}
/* all blocks are finished, so the extra bytes can be used at
the video segment level */
bits_left = mb_bit_count - s->gb.index;
vs_bit_count += bits_left;
bit_copy(&vs_pb, &s->gb, bits_left);
next_mb:
mb1 += 6;
block1 += 6 * 64;
}
/* we need a pass other the whole video segment */
flush_put_bits(&vs_pb);
#ifdef VLC_DEBUG
printf("***pass 3 size=%d\n", vs_bit_count);
#endif
block = &s->block[0][0];
mb = mb_data;
init_get_bits(&s->gb, vs_bit_buffer, 5 * 80);
for(mb_index = 0; mb_index < 5; mb_index++) {
for(j = 0;j < 6; j++) {
if (!mb->eob_reached) {
#ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j);
#endif
dv_decode_ac(s, mb, block, vs_bit_count);
}
block += 64;
mb++;
}
}
/* compute idct and place blocks */
block = &s->block[0][0];
mb = mb_data;
for(mb_index = 0; mb_index < 5; mb_index++) {
v = *mb_pos_ptr++;
mb_x = v & 0xff;
mb_y = v >> 8;
y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);
if (s->sampling_411)
c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);
else
c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);
for(j = 0;j < 6; j++) {
idct_put = s->idct_put[mb->dct_mode];
if (j < 4) {
if (s->sampling_411 && mb_x < (704 / 8)) {
/* NOTE: at end of line, the macroblock is handled as 420 */
idct_put(y_ptr + (j * 8), s->linesize[0], block);
} else {
idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),
s->linesize[0], block);
}
} else {
if (s->sampling_411 && mb_x >= (704 / 8)) {
uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;
int y, linesize;
/* NOTE: at end of line, the macroblock is handled as 420 */
idct_put(pixels, 8, block);
linesize = s->linesize[6 - j];
c_ptr = s->current_picture[6 - j] + c_offset;
ptr = pixels;
for(y = 0;y < 8; y++) {
/* convert to 411P */
c_ptr1 = c_ptr + linesize;
c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;
c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;
c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;
c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;
c_ptr += linesize * 2;
ptr += 8;
}
} else {
/* don't ask me why they inverted Cb and Cr ! */
idct_put(s->current_picture[6 - j] + c_offset,
s->linesize[6 - j], block);
}
}
block += 64;
mb++;
}
}
}
| false | FFmpeg | 68f593b48433842f3407586679fe07f3e5199ab9 | static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
UINT8 *buf_ptr1,
const UINT16 *mb_pos_ptr)
{
int quant, dc, dct_mode, class1, j;
int mb_index, mb_x, mb_y, v, last_index;
DCTELEM *block, *block1;
int c_offset, bits_left;
UINT8 *y_ptr;
BlockInfo mb_data[5 * 6], *mb, *mb1;
void (*idct_put)(UINT8 *dest, int line_size, DCTELEM *block);
UINT8 *buf_ptr;
PutBitContext pb, vs_pb;
UINT8 mb_bit_buffer[80 + 4];
int mb_bit_count;
UINT8 vs_bit_buffer[5 * 80 + 4];
int vs_bit_count;
memset(s->block, 0, sizeof(s->block));
buf_ptr = buf_ptr1;
block1 = &s->block[0][0];
mb1 = mb_data;
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);
vs_bit_count = 0;
for(mb_index = 0; mb_index < 5; mb_index++) {
quant = buf_ptr[3] & 0x0f;
buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);
mb_bit_count = 0;
mb = mb1;
block = block1;
for(j = 0;j < 6; j++) {
init_get_bits(&s->gb, buf_ptr, 14);
dc = get_bits(&s->gb, 9);
dc = (dc << (32 - 9)) >> (32 - 9);
dct_mode = get_bits1(&s->gb);
mb->dct_mode = dct_mode;
mb->scan_table = s->dv_zigzag[dct_mode];
class1 = get_bits(&s->gb, 2);
mb->shift_offset = (class1 == 3);
mb->shift_table = s->dv_shift[dct_mode]
[quant + dv_quant_offset[class1]];
dc = dc << 2;
dc += 1024;
block[0] = dc;
last_index = block_sizes[j];
buf_ptr += last_index >> 3;
mb->pos = 0;
mb->partial_bit_count = 0;
dv_decode_ac(s, mb, block, last_index);
bits_left = last_index - s->gb.index;
if (mb->eob_reached) {
mb->partial_bit_count = 0;
mb_bit_count += bits_left;
bit_copy(&pb, &s->gb, bits_left);
} else {
mb->partial_bit_count = bits_left;
mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
}
block += 64;
mb++;
}
flush_put_bits(&pb);
#ifdef VLC_DEBUG
printf("***pass 2 size=%d\n", mb_bit_count);
#endif
block = block1;
mb = mb1;
init_get_bits(&s->gb, mb_bit_buffer, 80);
for(j = 0;j < 6; j++) {
if (!mb->eob_reached && s->gb.index < mb_bit_count) {
dv_decode_ac(s, mb, block, mb_bit_count);
if (!mb->eob_reached) {
bits_left = mb_bit_count - s->gb.index;
if (bits_left > 0) {
mb->partial_bit_count += bits_left;
mb->partial_bit_buffer =
(mb->partial_bit_buffer << bits_left) |
get_bits(&s->gb, bits_left);
}
goto next_mb;
}
}
block += 64;
mb++;
}
bits_left = mb_bit_count - s->gb.index;
vs_bit_count += bits_left;
bit_copy(&vs_pb, &s->gb, bits_left);
next_mb:
mb1 += 6;
block1 += 6 * 64;
}
flush_put_bits(&vs_pb);
#ifdef VLC_DEBUG
printf("***pass 3 size=%d\n", vs_bit_count);
#endif
block = &s->block[0][0];
mb = mb_data;
init_get_bits(&s->gb, vs_bit_buffer, 5 * 80);
for(mb_index = 0; mb_index < 5; mb_index++) {
for(j = 0;j < 6; j++) {
if (!mb->eob_reached) {
#ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j);
#endif
dv_decode_ac(s, mb, block, vs_bit_count);
}
block += 64;
mb++;
}
}
block = &s->block[0][0];
mb = mb_data;
for(mb_index = 0; mb_index < 5; mb_index++) {
v = *mb_pos_ptr++;
mb_x = v & 0xff;
mb_y = v >> 8;
y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);
if (s->sampling_411)
c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);
else
c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);
for(j = 0;j < 6; j++) {
idct_put = s->idct_put[mb->dct_mode];
if (j < 4) {
if (s->sampling_411 && mb_x < (704 / 8)) {
idct_put(y_ptr + (j * 8), s->linesize[0], block);
} else {
idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),
s->linesize[0], block);
}
} else {
if (s->sampling_411 && mb_x >= (704 / 8)) {
uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;
int y, linesize;
idct_put(pixels, 8, block);
linesize = s->linesize[6 - j];
c_ptr = s->current_picture[6 - j] + c_offset;
ptr = pixels;
for(y = 0;y < 8; y++) {
c_ptr1 = c_ptr + linesize;
c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;
c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;
c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;
c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;
c_ptr += linesize * 2;
ptr += 8;
}
} else {
idct_put(s->current_picture[6 - j] + c_offset,
s->linesize[6 - j], block);
}
}
block += 64;
mb++;
}
}
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(DVVideoDecodeContext *VAR_0,
UINT8 *VAR_1,
const UINT16 *VAR_2)
{
int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;
int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;
DCTELEM *VAR_18, *block1;
int VAR_13, VAR_14;
UINT8 *y_ptr;
BlockInfo mb_data[5 * 6], *mb, *mb1;
void (*VAR_15)(UINT8 *VAR_16, int VAR_17, DCTELEM *VAR_18);
UINT8 *buf_ptr;
PutBitContext pb, vs_pb;
UINT8 mb_bit_buffer[80 + 4];
int VAR_19;
UINT8 vs_bit_buffer[5 * 80 + 4];
int VAR_20;
memset(VAR_0->VAR_18, 0, sizeof(VAR_0->VAR_18));
buf_ptr = VAR_1;
block1 = &VAR_0->VAR_18[0][0];
mb1 = mb_data;
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);
VAR_20 = 0;
for(VAR_8 = 0; VAR_8 < 5; VAR_8++) {
VAR_3 = buf_ptr[3] & 0x0f;
buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);
VAR_19 = 0;
mb = mb1;
VAR_18 = block1;
for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {
init_get_bits(&VAR_0->gb, buf_ptr, 14);
VAR_4 = get_bits(&VAR_0->gb, 9);
VAR_4 = (VAR_4 << (32 - 9)) >> (32 - 9);
VAR_5 = get_bits1(&VAR_0->gb);
mb->VAR_5 = VAR_5;
mb->scan_table = VAR_0->dv_zigzag[VAR_5];
VAR_6 = get_bits(&VAR_0->gb, 2);
mb->shift_offset = (VAR_6 == 3);
mb->shift_table = VAR_0->dv_shift[VAR_5]
[VAR_3 + dv_quant_offset[VAR_6]];
VAR_4 = VAR_4 << 2;
VAR_4 += 1024;
VAR_18[0] = VAR_4;
VAR_12 = block_sizes[VAR_7];
buf_ptr += VAR_12 >> 3;
mb->pos = 0;
mb->partial_bit_count = 0;
dv_decode_ac(VAR_0, mb, VAR_18, VAR_12);
VAR_14 = VAR_12 - VAR_0->gb.index;
if (mb->eob_reached) {
mb->partial_bit_count = 0;
VAR_19 += VAR_14;
bit_copy(&pb, &VAR_0->gb, VAR_14);
} else {
mb->partial_bit_count = VAR_14;
mb->partial_bit_buffer = get_bits(&VAR_0->gb, VAR_14);
}
VAR_18 += 64;
mb++;
}
flush_put_bits(&pb);
#ifdef VLC_DEBUG
printf("***pass 2 size=%d\n", VAR_19);
#endif
VAR_18 = block1;
mb = mb1;
init_get_bits(&VAR_0->gb, mb_bit_buffer, 80);
for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {
if (!mb->eob_reached && VAR_0->gb.index < VAR_19) {
dv_decode_ac(VAR_0, mb, VAR_18, VAR_19);
if (!mb->eob_reached) {
VAR_14 = VAR_19 - VAR_0->gb.index;
if (VAR_14 > 0) {
mb->partial_bit_count += VAR_14;
mb->partial_bit_buffer =
(mb->partial_bit_buffer << VAR_14) |
get_bits(&VAR_0->gb, VAR_14);
}
goto next_mb;
}
}
VAR_18 += 64;
mb++;
}
VAR_14 = VAR_19 - VAR_0->gb.index;
VAR_20 += VAR_14;
bit_copy(&vs_pb, &VAR_0->gb, VAR_14);
next_mb:
mb1 += 6;
block1 += 6 * 64;
}
flush_put_bits(&vs_pb);
#ifdef VLC_DEBUG
printf("***pass 3 size=%d\n", VAR_20);
#endif
VAR_18 = &VAR_0->VAR_18[0][0];
mb = mb_data;
init_get_bits(&VAR_0->gb, vs_bit_buffer, 5 * 80);
for(VAR_8 = 0; VAR_8 < 5; VAR_8++) {
for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {
if (!mb->eob_reached) {
#ifdef VLC_DEBUG
printf("start %d:%d\n", VAR_8, VAR_7);
#endif
dv_decode_ac(VAR_0, mb, VAR_18, VAR_20);
}
VAR_18 += 64;
mb++;
}
}
VAR_18 = &VAR_0->VAR_18[0][0];
mb = mb_data;
for(VAR_8 = 0; VAR_8 < 5; VAR_8++) {
VAR_11 = *VAR_2++;
VAR_9 = VAR_11 & 0xff;
VAR_10 = VAR_11 >> 8;
y_ptr = VAR_0->current_picture[0] + (VAR_10 * VAR_0->VAR_22[0] * 8) + (VAR_9 * 8);
if (VAR_0->sampling_411)
VAR_13 = (VAR_10 * VAR_0->VAR_22[1] * 8) + ((VAR_9 >> 2) * 8);
else
VAR_13 = ((VAR_10 >> 1) * VAR_0->VAR_22[1] * 8) + ((VAR_9 >> 1) * 8);
for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {
VAR_15 = VAR_0->VAR_15[mb->VAR_5];
if (VAR_7 < 4) {
if (VAR_0->sampling_411 && VAR_9 < (704 / 8)) {
VAR_15(y_ptr + (VAR_7 * 8), VAR_0->VAR_22[0], VAR_18);
} else {
VAR_15(y_ptr + ((VAR_7 & 1) * 8) + ((VAR_7 >> 1) * 8 * VAR_0->VAR_22[0]),
VAR_0->VAR_22[0], VAR_18);
}
} else {
if (VAR_0->sampling_411 && VAR_9 >= (704 / 8)) {
uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;
int VAR_21, VAR_22;
VAR_15(pixels, 8, VAR_18);
VAR_22 = VAR_0->VAR_22[6 - VAR_7];
c_ptr = VAR_0->current_picture[6 - VAR_7] + VAR_13;
ptr = pixels;
for(VAR_21 = 0;VAR_21 < 8; VAR_21++) {
c_ptr1 = c_ptr + VAR_22;
c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;
c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;
c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;
c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;
c_ptr += VAR_22 * 2;
ptr += 8;
}
} else {
VAR_15(VAR_0->current_picture[6 - VAR_7] + VAR_13,
VAR_0->VAR_22[6 - VAR_7], VAR_18);
}
}
VAR_18 += 64;
mb++;
}
}
}
| [
"static inline void FUNC_0(DVVideoDecodeContext *VAR_0,\nUINT8 *VAR_1,\nconst UINT16 *VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;",
"int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;",
"DCTELEM *VAR_18, *block1;",
"int VAR_13, VAR_14;",
"UINT8 *y_ptr;",
"BlockInfo mb_data[5 * 6], *mb, *mb1;",
"void (*... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
43
],
[
45
],
[
47
],
[
49
... |
15,659 | void helper_syscall(CPUX86State *env, int next_eip_addend)
{
int selector;
if (!(env->efer & MSR_EFER_SCE)) {
raise_exception_err(env, EXCP06_ILLOP, 0);
}
selector = (env->star >> 32) & 0xffff;
if (env->hflags & HF_LMA_MASK) {
int code64;
env->regs[R_ECX] = env->eip + next_eip_addend;
env->regs[11] = cpu_compute_eflags(env);
code64 = env->hflags & HF_CS64_MASK;
env->eflags &= ~env->fmask;
cpu_load_eflags(env, env->eflags, 0);
cpu_x86_set_cpl(env, 0);
cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |
DESC_L_MASK);
cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_W_MASK | DESC_A_MASK);
if (code64) {
env->eip = env->lstar;
} else {
env->eip = env->cstar;
}
} else {
env->regs[R_ECX] = (uint32_t)(env->eip + next_eip_addend);
env->eflags &= ~(IF_MASK | RF_MASK | VM_MASK);
cpu_x86_set_cpl(env, 0);
cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_W_MASK | DESC_A_MASK);
env->eip = (uint32_t)env->star;
}
}
| false | qemu | 7848c8d19f8556666df25044bbd5d8b29439c368 | void helper_syscall(CPUX86State *env, int next_eip_addend)
{
int selector;
if (!(env->efer & MSR_EFER_SCE)) {
raise_exception_err(env, EXCP06_ILLOP, 0);
}
selector = (env->star >> 32) & 0xffff;
if (env->hflags & HF_LMA_MASK) {
int code64;
env->regs[R_ECX] = env->eip + next_eip_addend;
env->regs[11] = cpu_compute_eflags(env);
code64 = env->hflags & HF_CS64_MASK;
env->eflags &= ~env->fmask;
cpu_load_eflags(env, env->eflags, 0);
cpu_x86_set_cpl(env, 0);
cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |
DESC_L_MASK);
cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_W_MASK | DESC_A_MASK);
if (code64) {
env->eip = env->lstar;
} else {
env->eip = env->cstar;
}
} else {
env->regs[R_ECX] = (uint32_t)(env->eip + next_eip_addend);
env->eflags &= ~(IF_MASK | RF_MASK | VM_MASK);
cpu_x86_set_cpl(env, 0);
cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_W_MASK | DESC_A_MASK);
env->eip = (uint32_t)env->star;
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUX86State *VAR_0, int VAR_1)
{
int VAR_2;
if (!(VAR_0->efer & MSR_EFER_SCE)) {
raise_exception_err(VAR_0, EXCP06_ILLOP, 0);
}
VAR_2 = (VAR_0->star >> 32) & 0xffff;
if (VAR_0->hflags & HF_LMA_MASK) {
int VAR_3;
VAR_0->regs[R_ECX] = VAR_0->eip + VAR_1;
VAR_0->regs[11] = cpu_compute_eflags(VAR_0);
VAR_3 = VAR_0->hflags & HF_CS64_MASK;
VAR_0->eflags &= ~VAR_0->fmask;
cpu_load_eflags(VAR_0, VAR_0->eflags, 0);
cpu_x86_set_cpl(VAR_0, 0);
cpu_x86_load_seg_cache(VAR_0, R_CS, VAR_2 & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |
DESC_L_MASK);
cpu_x86_load_seg_cache(VAR_0, R_SS, (VAR_2 + 8) & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_W_MASK | DESC_A_MASK);
if (VAR_3) {
VAR_0->eip = VAR_0->lstar;
} else {
VAR_0->eip = VAR_0->cstar;
}
} else {
VAR_0->regs[R_ECX] = (uint32_t)(VAR_0->eip + VAR_1);
VAR_0->eflags &= ~(IF_MASK | RF_MASK | VM_MASK);
cpu_x86_set_cpl(VAR_0, 0);
cpu_x86_load_seg_cache(VAR_0, R_CS, VAR_2 & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
cpu_x86_load_seg_cache(VAR_0, R_SS, (VAR_2 + 8) & 0xfffc,
0, 0xffffffff,
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
DESC_S_MASK |
DESC_W_MASK | DESC_A_MASK);
VAR_0->eip = (uint32_t)VAR_0->star;
}
}
| [
"void FUNC_0(CPUX86State *VAR_0, int VAR_1)\n{",
"int VAR_2;",
"if (!(VAR_0->efer & MSR_EFER_SCE)) {",
"raise_exception_err(VAR_0, EXCP06_ILLOP, 0);",
"}",
"VAR_2 = (VAR_0->star >> 32) & 0xffff;",
"if (VAR_0->hflags & HF_LMA_MASK) {",
"int VAR_3;",
"VAR_0->regs[R_ECX] = VAR_0->eip + VAR_1;",
"VAR_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39,
41,
43,
45,
47,
49
],
[
51,
53,
55,
57... |
15,662 | static int net_socket_listen_init(NetClientState *peer,
const char *model,
const char *name,
const char *host_str)
{
NetClientState *nc;
NetSocketState *s;
struct sockaddr_in saddr;
int fd, ret;
Error *err = NULL;
if (parse_host_port(&saddr, host_str, &err) < 0) {
error_report_err(err);
return -1;
}
fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
return -1;
}
qemu_set_nonblock(fd);
socket_set_fast_reuse(fd);
ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
if (ret < 0) {
perror("bind");
closesocket(fd);
return -1;
}
ret = listen(fd, 0);
if (ret < 0) {
perror("listen");
closesocket(fd);
return -1;
}
nc = qemu_new_net_client(&net_socket_info, peer, model, name);
s = DO_UPCAST(NetSocketState, nc, nc);
s->fd = -1;
s->listen_fd = fd;
s->nc.link_down = true;
net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
return 0;
}
| true | qemu | 0522a959aec29768610900636f6234ab40530f82 | static int net_socket_listen_init(NetClientState *peer,
const char *model,
const char *name,
const char *host_str)
{
NetClientState *nc;
NetSocketState *s;
struct sockaddr_in saddr;
int fd, ret;
Error *err = NULL;
if (parse_host_port(&saddr, host_str, &err) < 0) {
error_report_err(err);
return -1;
}
fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
return -1;
}
qemu_set_nonblock(fd);
socket_set_fast_reuse(fd);
ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
if (ret < 0) {
perror("bind");
closesocket(fd);
return -1;
}
ret = listen(fd, 0);
if (ret < 0) {
perror("listen");
closesocket(fd);
return -1;
}
nc = qemu_new_net_client(&net_socket_info, peer, model, name);
s = DO_UPCAST(NetSocketState, nc, nc);
s->fd = -1;
s->listen_fd = fd;
s->nc.link_down = true;
net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
return 0;
}
| {
"code": [
" const char *host_str)",
" Error *err = NULL;",
" if (parse_host_port(&saddr, host_str, &err) < 0) {",
" error_report_err(err);",
" perror(\"socket\");",
" perror(\"bind\");",
" perror(\"listen\");",
" Error *err = NULL;",
" if (parse_host_port(&saddr, host_str, &err) < 0) {",
" error_report_err(err);",
" perror(\"socket\");",
" error_report_err(err);",
" Error *err = NULL;",
" if (parse_host_port(&saddr, host_str, &err) < 0) {",
" error_report_err(err);",
" error_report_err(err);",
" error_report_err(err);",
" Error *err = NULL;",
" error_report_err(err);",
" error_report_err(err);",
" perror(\"bind\");",
" error_report_err(err);",
" Error *err = NULL;"
],
"line_no": [
7,
19,
23,
25,
37,
55,
67,
19,
23,
25,
37,
25,
19,
23,
25,
25,
25,
19,
25,
25,
55,
25,
19
]
} | static int FUNC_0(NetClientState *VAR_0,
const char *VAR_1,
const char *VAR_2,
const char *VAR_3)
{
NetClientState *nc;
NetSocketState *s;
struct sockaddr_in VAR_4;
int VAR_5, VAR_6;
Error *err = NULL;
if (parse_host_port(&VAR_4, VAR_3, &err) < 0) {
error_report_err(err);
return -1;
}
VAR_5 = qemu_socket(PF_INET, SOCK_STREAM, 0);
if (VAR_5 < 0) {
perror("socket");
return -1;
}
qemu_set_nonblock(VAR_5);
socket_set_fast_reuse(VAR_5);
VAR_6 = bind(VAR_5, (struct sockaddr *)&VAR_4, sizeof(VAR_4));
if (VAR_6 < 0) {
perror("bind");
closesocket(VAR_5);
return -1;
}
VAR_6 = listen(VAR_5, 0);
if (VAR_6 < 0) {
perror("listen");
closesocket(VAR_5);
return -1;
}
nc = qemu_new_net_client(&net_socket_info, VAR_0, VAR_1, VAR_2);
s = DO_UPCAST(NetSocketState, nc, nc);
s->VAR_5 = -1;
s->listen_fd = VAR_5;
s->nc.link_down = true;
net_socket_rs_init(&s->rs, net_socket_rs_finalize, false);
qemu_set_fd_handler(s->listen_fd, net_socket_accept, NULL, s);
return 0;
}
| [
"static int FUNC_0(NetClientState *VAR_0,\nconst char *VAR_1,\nconst char *VAR_2,\nconst char *VAR_3)\n{",
"NetClientState *nc;",
"NetSocketState *s;",
"struct sockaddr_in VAR_4;",
"int VAR_5, VAR_6;",
"Error *err = NULL;",
"if (parse_host_port(&VAR_4, VAR_3, &err) < 0) {",
"error_report_err(err);",
... | [
1,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
51
],
[... |
15,663 | static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
BdrvCheckMode fix)
{
BDRVQcowState *s = bs->opaque;
uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
int ret;
int refcount;
int i, j;
for (i = 0; i < s->l1_size; i++) {
uint64_t l1_entry = s->l1_table[i];
uint64_t l2_offset = l1_entry & L1E_OFFSET_MASK;
bool l2_dirty = false;
if (!l2_offset) {
continue;
}
refcount = get_refcount(bs, l2_offset >> s->cluster_bits);
if (refcount < 0) {
/* don't print message nor increment check_errors */
continue;
}
if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
"l1_entry=%" PRIx64 " refcount=%d\n",
fix & BDRV_FIX_ERRORS ? "Repairing" :
"ERROR",
i, l1_entry, refcount);
if (fix & BDRV_FIX_ERRORS) {
s->l1_table[i] = refcount == 1
? l1_entry | QCOW_OFLAG_COPIED
: l1_entry & ~QCOW_OFLAG_COPIED;
ret = qcow2_write_l1_entry(bs, i);
if (ret < 0) {
res->check_errors++;
goto fail;
}
res->corruptions_fixed++;
} else {
res->corruptions++;
}
}
ret = bdrv_pread(bs->file, l2_offset, l2_table,
s->l2_size * sizeof(uint64_t));
if (ret < 0) {
fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
strerror(-ret));
res->check_errors++;
goto fail;
}
for (j = 0; j < s->l2_size; j++) {
uint64_t l2_entry = be64_to_cpu(l2_table[j]);
uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
int cluster_type = qcow2_get_cluster_type(l2_entry);
if ((cluster_type == QCOW2_CLUSTER_NORMAL) ||
((cluster_type == QCOW2_CLUSTER_ZERO) && (data_offset != 0))) {
refcount = get_refcount(bs, data_offset >> s->cluster_bits);
if (refcount < 0) {
/* don't print message nor increment check_errors */
continue;
}
if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
fprintf(stderr, "%s OFLAG_COPIED data cluster: "
"l2_entry=%" PRIx64 " refcount=%d\n",
fix & BDRV_FIX_ERRORS ? "Repairing" :
"ERROR",
l2_entry, refcount);
if (fix & BDRV_FIX_ERRORS) {
l2_table[j] = cpu_to_be64(refcount == 1
? l2_entry | QCOW_OFLAG_COPIED
: l2_entry & ~QCOW_OFLAG_COPIED);
l2_dirty = true;
res->corruptions_fixed++;
} else {
res->corruptions++;
}
}
}
}
if (l2_dirty) {
ret = qcow2_pre_write_overlap_check(bs,
QCOW2_OL_DEFAULT & ~QCOW2_OL_ACTIVE_L2, l2_offset,
s->cluster_size);
if (ret < 0) {
fprintf(stderr, "ERROR: Could not write L2 table; metadata "
"overlap check failed: %s\n", strerror(-ret));
res->check_errors++;
goto fail;
}
ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size);
if (ret < 0) {
fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
strerror(-ret));
res->check_errors++;
goto fail;
}
}
}
ret = 0;
fail:
qemu_vfree(l2_table);
return ret;
}
| true | qemu | 231bb267644ee3a9ebfd9c7f42d5d41610194b45 | static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
BdrvCheckMode fix)
{
BDRVQcowState *s = bs->opaque;
uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
int ret;
int refcount;
int i, j;
for (i = 0; i < s->l1_size; i++) {
uint64_t l1_entry = s->l1_table[i];
uint64_t l2_offset = l1_entry & L1E_OFFSET_MASK;
bool l2_dirty = false;
if (!l2_offset) {
continue;
}
refcount = get_refcount(bs, l2_offset >> s->cluster_bits);
if (refcount < 0) {
continue;
}
if ((refcount == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
"l1_entry=%" PRIx64 " refcount=%d\n",
fix & BDRV_FIX_ERRORS ? "Repairing" :
"ERROR",
i, l1_entry, refcount);
if (fix & BDRV_FIX_ERRORS) {
s->l1_table[i] = refcount == 1
? l1_entry | QCOW_OFLAG_COPIED
: l1_entry & ~QCOW_OFLAG_COPIED;
ret = qcow2_write_l1_entry(bs, i);
if (ret < 0) {
res->check_errors++;
goto fail;
}
res->corruptions_fixed++;
} else {
res->corruptions++;
}
}
ret = bdrv_pread(bs->file, l2_offset, l2_table,
s->l2_size * sizeof(uint64_t));
if (ret < 0) {
fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
strerror(-ret));
res->check_errors++;
goto fail;
}
for (j = 0; j < s->l2_size; j++) {
uint64_t l2_entry = be64_to_cpu(l2_table[j]);
uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
int cluster_type = qcow2_get_cluster_type(l2_entry);
if ((cluster_type == QCOW2_CLUSTER_NORMAL) ||
((cluster_type == QCOW2_CLUSTER_ZERO) && (data_offset != 0))) {
refcount = get_refcount(bs, data_offset >> s->cluster_bits);
if (refcount < 0) {
continue;
}
if ((refcount == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
fprintf(stderr, "%s OFLAG_COPIED data cluster: "
"l2_entry=%" PRIx64 " refcount=%d\n",
fix & BDRV_FIX_ERRORS ? "Repairing" :
"ERROR",
l2_entry, refcount);
if (fix & BDRV_FIX_ERRORS) {
l2_table[j] = cpu_to_be64(refcount == 1
? l2_entry | QCOW_OFLAG_COPIED
: l2_entry & ~QCOW_OFLAG_COPIED);
l2_dirty = true;
res->corruptions_fixed++;
} else {
res->corruptions++;
}
}
}
}
if (l2_dirty) {
ret = qcow2_pre_write_overlap_check(bs,
QCOW2_OL_DEFAULT & ~QCOW2_OL_ACTIVE_L2, l2_offset,
s->cluster_size);
if (ret < 0) {
fprintf(stderr, "ERROR: Could not write L2 table; metadata "
"overlap check failed: %s\n", strerror(-ret));
res->check_errors++;
goto fail;
}
ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size);
if (ret < 0) {
fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
strerror(-ret));
res->check_errors++;
goto fail;
}
}
}
ret = 0;
fail:
qemu_vfree(l2_table);
return ret;
}
| {
"code": [
" ret = qcow2_pre_write_overlap_check(bs,",
" QCOW2_OL_DEFAULT & ~QCOW2_OL_ACTIVE_L2, l2_offset,",
" s->cluster_size);"
],
"line_no": [
171,
173,
175
]
} | static int FUNC_0(BlockDriverState *VAR_0, BdrvCheckResult *VAR_1,
BdrvCheckMode VAR_2)
{
BDRVQcowState *s = VAR_0->opaque;
uint64_t *l2_table = qemu_blockalign(VAR_0, s->cluster_size);
int VAR_3;
int VAR_4;
int VAR_5, VAR_6;
for (VAR_5 = 0; VAR_5 < s->l1_size; VAR_5++) {
uint64_t l1_entry = s->l1_table[VAR_5];
uint64_t l2_offset = l1_entry & L1E_OFFSET_MASK;
bool l2_dirty = false;
if (!l2_offset) {
continue;
}
VAR_4 = get_refcount(VAR_0, l2_offset >> s->cluster_bits);
if (VAR_4 < 0) {
continue;
}
if ((VAR_4 == 1) != ((l1_entry & QCOW_OFLAG_COPIED) != 0)) {
fprintf(stderr, "%s OFLAG_COPIED L2 cluster: l1_index=%d "
"l1_entry=%" PRIx64 " VAR_4=%d\n",
VAR_2 & BDRV_FIX_ERRORS ? "Repairing" :
"ERROR",
VAR_5, l1_entry, VAR_4);
if (VAR_2 & BDRV_FIX_ERRORS) {
s->l1_table[VAR_5] = VAR_4 == 1
? l1_entry | QCOW_OFLAG_COPIED
: l1_entry & ~QCOW_OFLAG_COPIED;
VAR_3 = qcow2_write_l1_entry(VAR_0, VAR_5);
if (VAR_3 < 0) {
VAR_1->check_errors++;
goto fail;
}
VAR_1->corruptions_fixed++;
} else {
VAR_1->corruptions++;
}
}
VAR_3 = bdrv_pread(VAR_0->file, l2_offset, l2_table,
s->l2_size * sizeof(uint64_t));
if (VAR_3 < 0) {
fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
strerror(-VAR_3));
VAR_1->check_errors++;
goto fail;
}
for (VAR_6 = 0; VAR_6 < s->l2_size; VAR_6++) {
uint64_t l2_entry = be64_to_cpu(l2_table[VAR_6]);
uint64_t data_offset = l2_entry & L2E_OFFSET_MASK;
int cluster_type = qcow2_get_cluster_type(l2_entry);
if ((cluster_type == QCOW2_CLUSTER_NORMAL) ||
((cluster_type == QCOW2_CLUSTER_ZERO) && (data_offset != 0))) {
VAR_4 = get_refcount(VAR_0, data_offset >> s->cluster_bits);
if (VAR_4 < 0) {
continue;
}
if ((VAR_4 == 1) != ((l2_entry & QCOW_OFLAG_COPIED) != 0)) {
fprintf(stderr, "%s OFLAG_COPIED data cluster: "
"l2_entry=%" PRIx64 " VAR_4=%d\n",
VAR_2 & BDRV_FIX_ERRORS ? "Repairing" :
"ERROR",
l2_entry, VAR_4);
if (VAR_2 & BDRV_FIX_ERRORS) {
l2_table[VAR_6] = cpu_to_be64(VAR_4 == 1
? l2_entry | QCOW_OFLAG_COPIED
: l2_entry & ~QCOW_OFLAG_COPIED);
l2_dirty = true;
VAR_1->corruptions_fixed++;
} else {
VAR_1->corruptions++;
}
}
}
}
if (l2_dirty) {
VAR_3 = qcow2_pre_write_overlap_check(VAR_0,
QCOW2_OL_DEFAULT & ~QCOW2_OL_ACTIVE_L2, l2_offset,
s->cluster_size);
if (VAR_3 < 0) {
fprintf(stderr, "ERROR: Could not write L2 table; metadata "
"overlap check failed: %s\n", strerror(-VAR_3));
VAR_1->check_errors++;
goto fail;
}
VAR_3 = bdrv_pwrite(VAR_0->file, l2_offset, l2_table, s->cluster_size);
if (VAR_3 < 0) {
fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
strerror(-VAR_3));
VAR_1->check_errors++;
goto fail;
}
}
}
VAR_3 = 0;
fail:
qemu_vfree(l2_table);
return VAR_3;
}
| [
"static int FUNC_0(BlockDriverState *VAR_0, BdrvCheckResult *VAR_1,\nBdrvCheckMode VAR_2)\n{",
"BDRVQcowState *s = VAR_0->opaque;",
"uint64_t *l2_table = qemu_blockalign(VAR_0, s->cluster_size);",
"int VAR_3;",
"int VAR_4;",
"int VAR_5, VAR_6;",
"for (VAR_5 = 0; VAR_5 < s->l1_size; VAR_5++) {",
"uint6... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49,
51,... |
15,665 | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,
const char *name, int devfn,
PCIConfigReadFunc *config_read,
PCIConfigWriteFunc *config_write,
uint8_t header_type)
{
if (devfn < 0) {
for(devfn = bus->devfn_min ; devfn < 256; devfn += 8) {
if (!bus->devices[devfn])
goto found;
}
return NULL;
found: ;
} else if (bus->devices[devfn]) {
return NULL;
}
pci_dev->bus = bus;
pci_dev->devfn = devfn;
pstrcpy(pci_dev->name, sizeof(pci_dev->name), name);
memset(pci_dev->irq_state, 0, sizeof(pci_dev->irq_state));
pci_config_alloc(pci_dev);
header_type &= ~PCI_HEADER_TYPE_MULTI_FUNCTION;
if (header_type == PCI_HEADER_TYPE_NORMAL) {
pci_set_default_subsystem_id(pci_dev);
}
pci_init_cmask(pci_dev);
pci_init_wmask(pci_dev);
if (header_type == PCI_HEADER_TYPE_BRIDGE) {
pci_init_wmask_bridge(pci_dev);
}
if (!config_read)
config_read = pci_default_read_config;
if (!config_write)
config_write = pci_default_write_config;
pci_dev->config_read = config_read;
pci_dev->config_write = config_write;
bus->devices[devfn] = pci_dev;
pci_dev->irq = qemu_allocate_irqs(pci_set_irq, pci_dev, PCI_NUM_PINS);
pci_dev->version_id = 2; /* Current pci device vmstate version */
return pci_dev;
}
| true | qemu | c364c974d9ab90e25e7887f516da65d2811ba5e3 | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,
const char *name, int devfn,
PCIConfigReadFunc *config_read,
PCIConfigWriteFunc *config_write,
uint8_t header_type)
{
if (devfn < 0) {
for(devfn = bus->devfn_min ; devfn < 256; devfn += 8) {
if (!bus->devices[devfn])
goto found;
}
return NULL;
found: ;
} else if (bus->devices[devfn]) {
return NULL;
}
pci_dev->bus = bus;
pci_dev->devfn = devfn;
pstrcpy(pci_dev->name, sizeof(pci_dev->name), name);
memset(pci_dev->irq_state, 0, sizeof(pci_dev->irq_state));
pci_config_alloc(pci_dev);
header_type &= ~PCI_HEADER_TYPE_MULTI_FUNCTION;
if (header_type == PCI_HEADER_TYPE_NORMAL) {
pci_set_default_subsystem_id(pci_dev);
}
pci_init_cmask(pci_dev);
pci_init_wmask(pci_dev);
if (header_type == PCI_HEADER_TYPE_BRIDGE) {
pci_init_wmask_bridge(pci_dev);
}
if (!config_read)
config_read = pci_default_read_config;
if (!config_write)
config_write = pci_default_write_config;
pci_dev->config_read = config_read;
pci_dev->config_write = config_write;
bus->devices[devfn] = pci_dev;
pci_dev->irq = qemu_allocate_irqs(pci_set_irq, pci_dev, PCI_NUM_PINS);
pci_dev->version_id = 2;
return pci_dev;
}
| {
"code": [
" return NULL;",
" return NULL;"
],
"line_no": [
23,
23
]
} | static PCIDevice *FUNC_0(PCIDevice *pci_dev, PCIBus *bus,
const char *name, int devfn,
PCIConfigReadFunc *config_read,
PCIConfigWriteFunc *config_write,
uint8_t header_type)
{
if (devfn < 0) {
for(devfn = bus->devfn_min ; devfn < 256; devfn += 8) {
if (!bus->devices[devfn])
goto found;
}
return NULL;
found: ;
} else if (bus->devices[devfn]) {
return NULL;
}
pci_dev->bus = bus;
pci_dev->devfn = devfn;
pstrcpy(pci_dev->name, sizeof(pci_dev->name), name);
memset(pci_dev->irq_state, 0, sizeof(pci_dev->irq_state));
pci_config_alloc(pci_dev);
header_type &= ~PCI_HEADER_TYPE_MULTI_FUNCTION;
if (header_type == PCI_HEADER_TYPE_NORMAL) {
pci_set_default_subsystem_id(pci_dev);
}
pci_init_cmask(pci_dev);
pci_init_wmask(pci_dev);
if (header_type == PCI_HEADER_TYPE_BRIDGE) {
pci_init_wmask_bridge(pci_dev);
}
if (!config_read)
config_read = pci_default_read_config;
if (!config_write)
config_write = pci_default_write_config;
pci_dev->config_read = config_read;
pci_dev->config_write = config_write;
bus->devices[devfn] = pci_dev;
pci_dev->irq = qemu_allocate_irqs(pci_set_irq, pci_dev, PCI_NUM_PINS);
pci_dev->version_id = 2;
return pci_dev;
}
| [
"static PCIDevice *FUNC_0(PCIDevice *pci_dev, PCIBus *bus,\nconst char *name, int devfn,\nPCIConfigReadFunc *config_read,\nPCIConfigWriteFunc *config_write,\nuint8_t header_type)\n{",
"if (devfn < 0) {",
"for(devfn = bus->devfn_min ; devfn < 256; devfn += 8) {",
"if (!bus->devices[devfn])\ngoto found;",
"}"... | [
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[... |
15,666 | static void put_int8(QEMUFile *f, void *pv, size_t size)
{
int8_t *v = pv;
qemu_put_s8s(f, v);
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | static void put_int8(QEMUFile *f, void *pv, size_t size)
{
int8_t *v = pv;
qemu_put_s8s(f, v);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)
{
int8_t *v = VAR_1;
qemu_put_s8s(VAR_0, v);
}
| [
"static void FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)\n{",
"int8_t *v = VAR_1;",
"qemu_put_s8s(VAR_0, v);",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
15,667 | static void decode_q_branch(SnowContext *s, int level, int x, int y){
const int w= s->b_width << s->block_max_depth;
const int rem_depth= s->block_max_depth - level;
const int index= (x + y*w) << rem_depth;
int trx= (x+1)<<rem_depth;
const BlockNode *left = x ? &s->block[index-1] : &null_block;
const BlockNode *top = y ? &s->block[index-w] : &null_block;
const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
if(s->keyframe){
set_blocks(s, level, x, y, null_block.color[0], null_block.color[1], null_block.color[2], null_block.mx, null_block.my, null_block.ref, BLOCK_INTRA);
return;
}
if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
int type, mx, my;
int l = left->color[0];
int cb= left->color[1];
int cr= left->color[2];
int ref = 0;
int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
if(type){
pred_mv(s, &mx, &my, 0, left, top, tr);
l += get_symbol(&s->c, &s->block_state[32], 1);
cb+= get_symbol(&s->c, &s->block_state[64], 1);
cr+= get_symbol(&s->c, &s->block_state[96], 1);
}else{
if(s->ref_frames > 1)
ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
pred_mv(s, &mx, &my, ref, left, top, tr);
mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
}
set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
}else{
decode_q_branch(s, level+1, 2*x+0, 2*y+0);
decode_q_branch(s, level+1, 2*x+1, 2*y+0);
decode_q_branch(s, level+1, 2*x+0, 2*y+1);
decode_q_branch(s, level+1, 2*x+1, 2*y+1);
}
}
| true | FFmpeg | 0af48e29f55a4e5824e6f7157ac94cf8b210aa84 | static void decode_q_branch(SnowContext *s, int level, int x, int y){
const int w= s->b_width << s->block_max_depth;
const int rem_depth= s->block_max_depth - level;
const int index= (x + y*w) << rem_depth;
int trx= (x+1)<<rem_depth;
const BlockNode *left = x ? &s->block[index-1] : &null_block;
const BlockNode *top = y ? &s->block[index-w] : &null_block;
const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl;
int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
if(s->keyframe){
set_blocks(s, level, x, y, null_block.color[0], null_block.color[1], null_block.color[2], null_block.mx, null_block.my, null_block.ref, BLOCK_INTRA);
return;
}
if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
int type, mx, my;
int l = left->color[0];
int cb= left->color[1];
int cr= left->color[2];
int ref = 0;
int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
if(type){
pred_mv(s, &mx, &my, 0, left, top, tr);
l += get_symbol(&s->c, &s->block_state[32], 1);
cb+= get_symbol(&s->c, &s->block_state[64], 1);
cr+= get_symbol(&s->c, &s->block_state[96], 1);
}else{
if(s->ref_frames > 1)
ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
pred_mv(s, &mx, &my, ref, left, top, tr);
mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
}
set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
}else{
decode_q_branch(s, level+1, 2*x+0, 2*y+0);
decode_q_branch(s, level+1, 2*x+1, 2*y+0);
decode_q_branch(s, level+1, 2*x+0, 2*y+1);
decode_q_branch(s, level+1, 2*x+1, 2*y+1);
}
}
| {
"code": [
"static void decode_q_branch(SnowContext *s, int level, int x, int y){",
" decode_q_branch(s, level+1, 2*x+0, 2*y+0);",
" decode_q_branch(s, level+1, 2*x+1, 2*y+0);",
" decode_q_branch(s, level+1, 2*x+0, 2*y+1);",
" decode_q_branch(s, level+1, 2*x+1, 2*y+1);"
],
"line_no": [
1,
85,
87,
89,
91
]
} | static void FUNC_0(SnowContext *VAR_0, int VAR_1, int VAR_2, int VAR_3){
const int VAR_4= VAR_0->b_width << VAR_0->block_max_depth;
const int VAR_5= VAR_0->block_max_depth - VAR_1;
const int VAR_6= (VAR_2 + VAR_3*VAR_4) << VAR_5;
int VAR_7= (VAR_2+1)<<VAR_5;
const BlockNode *VAR_8 = VAR_2 ? &VAR_0->block[VAR_6-1] : &null_block;
const BlockNode *VAR_9 = VAR_3 ? &VAR_0->block[VAR_6-VAR_4] : &null_block;
const BlockNode *VAR_10 = VAR_3 && VAR_2 ? &VAR_0->block[VAR_6-VAR_4-1] : VAR_8;
const BlockNode *VAR_11 = VAR_3 && VAR_7<VAR_4 && ((VAR_2&1)==0 || VAR_1==0) ? &VAR_0->block[VAR_6-VAR_4+(1<<VAR_5)] : VAR_10;
int VAR_12= 2*VAR_8->VAR_1 + 2*VAR_9->VAR_1 + VAR_10->VAR_1 + VAR_11->VAR_1;
if(VAR_0->keyframe){
set_blocks(VAR_0, VAR_1, VAR_2, VAR_3, null_block.color[0], null_block.color[1], null_block.color[2], null_block.VAR_14, null_block.VAR_15, null_block.VAR_19, BLOCK_INTRA);
return;
}
if(VAR_1==VAR_0->block_max_depth || get_rac(&VAR_0->c, &VAR_0->block_state[4 + VAR_12])){
int VAR_13, VAR_14, VAR_15;
int VAR_16 = VAR_8->color[0];
int VAR_17= VAR_8->color[1];
int VAR_18= VAR_8->color[2];
int VAR_19 = 0;
int VAR_20= av_log2(2*VAR_8->VAR_19) + av_log2(2*VAR_9->VAR_19);
int VAR_21= av_log2(2*FFABS(VAR_8->VAR_14 - VAR_9->VAR_14)) + 0*av_log2(2*FFABS(VAR_11->VAR_14 - VAR_9->VAR_14));
int VAR_22= av_log2(2*FFABS(VAR_8->VAR_15 - VAR_9->VAR_15)) + 0*av_log2(2*FFABS(VAR_11->VAR_15 - VAR_9->VAR_15));
VAR_13= get_rac(&VAR_0->c, &VAR_0->block_state[1 + VAR_8->VAR_13 + VAR_9->VAR_13]) ? BLOCK_INTRA : 0;
if(VAR_13){
pred_mv(VAR_0, &VAR_14, &VAR_15, 0, VAR_8, VAR_9, VAR_11);
VAR_16 += get_symbol(&VAR_0->c, &VAR_0->block_state[32], 1);
VAR_17+= get_symbol(&VAR_0->c, &VAR_0->block_state[64], 1);
VAR_18+= get_symbol(&VAR_0->c, &VAR_0->block_state[96], 1);
}else{
if(VAR_0->ref_frames > 1)
VAR_19= get_symbol(&VAR_0->c, &VAR_0->block_state[128 + 1024 + 32*VAR_20], 0);
pred_mv(VAR_0, &VAR_14, &VAR_15, VAR_19, VAR_8, VAR_9, VAR_11);
VAR_14+= get_symbol(&VAR_0->c, &VAR_0->block_state[128 + 32*(VAR_21 + 16*!!VAR_19)], 1);
VAR_15+= get_symbol(&VAR_0->c, &VAR_0->block_state[128 + 32*(VAR_22 + 16*!!VAR_19)], 1);
}
set_blocks(VAR_0, VAR_1, VAR_2, VAR_3, VAR_16, VAR_17, VAR_18, VAR_14, VAR_15, VAR_19, VAR_13);
}else{
FUNC_0(VAR_0, VAR_1+1, 2*VAR_2+0, 2*VAR_3+0);
FUNC_0(VAR_0, VAR_1+1, 2*VAR_2+1, 2*VAR_3+0);
FUNC_0(VAR_0, VAR_1+1, 2*VAR_2+0, 2*VAR_3+1);
FUNC_0(VAR_0, VAR_1+1, 2*VAR_2+1, 2*VAR_3+1);
}
}
| [
"static void FUNC_0(SnowContext *VAR_0, int VAR_1, int VAR_2, int VAR_3){",
"const int VAR_4= VAR_0->b_width << VAR_0->block_max_depth;",
"const int VAR_5= VAR_0->block_max_depth - VAR_1;",
"const int VAR_6= (VAR_2 + VAR_3*VAR_4) << VAR_5;",
"int VAR_7= (VAR_2+1)<<VAR_5;",
"const BlockNode *VAR_8 = VAR_2... | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[... |
15,668 | static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
{
int compno, reslevelno, bandno, ret;
Jpeg2000T1Context t1;
Jpeg2000CodingStyle *codsty = &s->codsty;
for (compno = 0; compno < s->ncomponents; compno++){
Jpeg2000Component *comp = s->tile[tileno].comp + compno;
av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");
if (ret = ff_dwt_encode(&comp->dwt, comp->i_data))
return ret;
av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
for (bandno = 0; bandno < reslevel->nbands ; bandno++){
Jpeg2000Band *band = reslevel->band + bandno;
Jpeg2000Prec *prec = band->prec; // we support only 1 precinct per band ATM in the encoder
int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
y0 = yy0;
yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,
band->coord[1][1]) - band->coord[1][0] + yy0;
if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])
continue;
bandpos = bandno + (reslevelno > 0);
for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){
if (reslevelno == 0 || bandno == 1)
xx0 = 0;
else
xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];
x0 = xx0;
xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,
band->coord[0][1]) - band->coord[0][0] + xx0;
for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){
int y, x;
if (codsty->transform == FF_DWT53){
for (y = yy0; y < yy1; y++){
int *ptr = t1.data[y-yy0];
for (x = xx0; x < xx1; x++){
*ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] << NMSEDEC_FRACBITS;
}
}
} else{
for (y = yy0; y < yy1; y++){
int *ptr = t1.data[y-yy0];
for (x = xx0; x < xx1; x++){
*ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
*ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 14 - NMSEDEC_FRACBITS;
ptr++;
}
}
}
encode_cblk(s, &t1, prec->cblk + cblkno, tile, xx1 - xx0, yy1 - yy0,
bandpos, codsty->nreslevels - reslevelno - 1);
xx0 = xx1;
xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);
}
yy0 = yy1;
yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);
}
}
}
av_log(s->avctx, AV_LOG_DEBUG, "after tier1\n");
}
av_log(s->avctx, AV_LOG_DEBUG, "rate control\n");
truncpasses(s, tile);
if (ret = encode_packets(s, tile, tileno))
return ret;
av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n");
return 0;
}
| true | FFmpeg | f57119b8e58cb5437c3ab40d797293ecb9b4a894 | static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
{
int compno, reslevelno, bandno, ret;
Jpeg2000T1Context t1;
Jpeg2000CodingStyle *codsty = &s->codsty;
for (compno = 0; compno < s->ncomponents; compno++){
Jpeg2000Component *comp = s->tile[tileno].comp + compno;
av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");
if (ret = ff_dwt_encode(&comp->dwt, comp->i_data))
return ret;
av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
for (bandno = 0; bandno < reslevel->nbands ; bandno++){
Jpeg2000Band *band = reslevel->band + bandno;
Jpeg2000Prec *prec = band->prec;
int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
y0 = yy0;
yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,
band->coord[1][1]) - band->coord[1][0] + yy0;
if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])
continue;
bandpos = bandno + (reslevelno > 0);
for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){
if (reslevelno == 0 || bandno == 1)
xx0 = 0;
else
xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];
x0 = xx0;
xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,
band->coord[0][1]) - band->coord[0][0] + xx0;
for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){
int y, x;
if (codsty->transform == FF_DWT53){
for (y = yy0; y < yy1; y++){
int *ptr = t1.data[y-yy0];
for (x = xx0; x < xx1; x++){
*ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] << NMSEDEC_FRACBITS;
}
}
} else{
for (y = yy0; y < yy1; y++){
int *ptr = t1.data[y-yy0];
for (x = xx0; x < xx1; x++){
*ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
*ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 14 - NMSEDEC_FRACBITS;
ptr++;
}
}
}
encode_cblk(s, &t1, prec->cblk + cblkno, tile, xx1 - xx0, yy1 - yy0,
bandpos, codsty->nreslevels - reslevelno - 1);
xx0 = xx1;
xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);
}
yy0 = yy1;
yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);
}
}
}
av_log(s->avctx, AV_LOG_DEBUG, "after tier1\n");
}
av_log(s->avctx, AV_LOG_DEBUG, "rate control\n");
truncpasses(s, tile);
if (ret = encode_packets(s, tile, tileno))
return ret;
av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n");
return 0;
}
| {
"code": [
" *ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 14 - NMSEDEC_FRACBITS;"
],
"line_no": [
107
]
} | static int FUNC_0(Jpeg2000EncoderContext *VAR_0, Jpeg2000Tile *VAR_1, int VAR_2)
{
int VAR_3, VAR_4, VAR_5, VAR_6;
Jpeg2000T1Context t1;
Jpeg2000CodingStyle *codsty = &VAR_0->codsty;
for (VAR_3 = 0; VAR_3 < VAR_0->ncomponents; VAR_3++){
Jpeg2000Component *comp = VAR_0->VAR_1[VAR_2].comp + VAR_3;
av_log(VAR_0->avctx, AV_LOG_DEBUG,"dwt\n");
if (VAR_6 = ff_dwt_encode(&comp->dwt, comp->i_data))
return VAR_6;
av_log(VAR_0->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
for (VAR_4 = 0; VAR_4 < codsty->nreslevels; VAR_4++){
Jpeg2000ResLevel *reslevel = comp->reslevel + VAR_4;
for (VAR_5 = 0; VAR_5 < reslevel->nbands ; VAR_5++){
Jpeg2000Band *band = reslevel->band + VAR_5;
Jpeg2000Prec *prec = band->prec;
int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
yy0 = VAR_5 == 0 ? 0 : comp->reslevel[VAR_4-1].coord[1][1] - comp->reslevel[VAR_4-1].coord[1][0];
y0 = yy0;
yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,
band->coord[1][1]) - band->coord[1][0] + yy0;
if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])
continue;
bandpos = VAR_5 + (VAR_4 > 0);
for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){
if (VAR_4 == 0 || VAR_5 == 1)
xx0 = 0;
else
xx0 = comp->reslevel[VAR_4-1].coord[0][1] - comp->reslevel[VAR_4-1].coord[0][0];
x0 = xx0;
xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,
band->coord[0][1]) - band->coord[0][0] + xx0;
for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){
int y, x;
if (codsty->transform == FF_DWT53){
for (y = yy0; y < yy1; y++){
int *ptr = t1.data[y-yy0];
for (x = xx0; x < xx1; x++){
*ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] << NMSEDEC_FRACBITS;
}
}
} else{
for (y = yy0; y < yy1; y++){
int *ptr = t1.data[y-yy0];
for (x = xx0; x < xx1; x++){
*ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
*ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 14 - NMSEDEC_FRACBITS;
ptr++;
}
}
}
encode_cblk(VAR_0, &t1, prec->cblk + cblkno, VAR_1, xx1 - xx0, yy1 - yy0,
bandpos, codsty->nreslevels - VAR_4 - 1);
xx0 = xx1;
xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);
}
yy0 = yy1;
yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);
}
}
}
av_log(VAR_0->avctx, AV_LOG_DEBUG, "after tier1\n");
}
av_log(VAR_0->avctx, AV_LOG_DEBUG, "rate control\n");
truncpasses(VAR_0, VAR_1);
if (VAR_6 = encode_packets(VAR_0, VAR_1, VAR_2))
return VAR_6;
av_log(VAR_0->avctx, AV_LOG_DEBUG, "after rate control\n");
return 0;
}
| [
"static int FUNC_0(Jpeg2000EncoderContext *VAR_0, Jpeg2000Tile *VAR_1, int VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5, VAR_6;",
"Jpeg2000T1Context t1;",
"Jpeg2000CodingStyle *codsty = &VAR_0->codsty;",
"for (VAR_3 = 0; VAR_3 < VAR_0->ncomponents; VAR_3++){",
"Jpeg2000Component *comp = VAR_0->VAR_1[VAR_2].comp +... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
13
],
[
17
],
[
19,
21
],
[
23
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
51,... |
15,669 | static struct omap_mpuio_s *omap_mpuio_init(MemoryRegion *memory,
hwaddr base,
qemu_irq kbd_int, qemu_irq gpio_int, qemu_irq wakeup,
omap_clk clk)
{
struct omap_mpuio_s *s = (struct omap_mpuio_s *)
g_malloc0(sizeof(struct omap_mpuio_s));
s->irq = gpio_int;
s->kbd_irq = kbd_int;
s->wakeup = wakeup;
s->in = qemu_allocate_irqs(omap_mpuio_set, s, 16);
omap_mpuio_reset(s);
memory_region_init_io(&s->iomem, NULL, &omap_mpuio_ops, s,
"omap-mpuio", 0x800);
memory_region_add_subregion(memory, base, &s->iomem);
omap_clk_adduser(clk, qemu_allocate_irq(omap_mpuio_onoff, s, 0));
return s;
}
| true | qemu | b45c03f585ea9bb1af76c73e82195418c294919d | static struct omap_mpuio_s *omap_mpuio_init(MemoryRegion *memory,
hwaddr base,
qemu_irq kbd_int, qemu_irq gpio_int, qemu_irq wakeup,
omap_clk clk)
{
struct omap_mpuio_s *s = (struct omap_mpuio_s *)
g_malloc0(sizeof(struct omap_mpuio_s));
s->irq = gpio_int;
s->kbd_irq = kbd_int;
s->wakeup = wakeup;
s->in = qemu_allocate_irqs(omap_mpuio_set, s, 16);
omap_mpuio_reset(s);
memory_region_init_io(&s->iomem, NULL, &omap_mpuio_ops, s,
"omap-mpuio", 0x800);
memory_region_add_subregion(memory, base, &s->iomem);
omap_clk_adduser(clk, qemu_allocate_irq(omap_mpuio_onoff, s, 0));
return s;
}
| {
"code": [
" struct omap_mpuio_s *s = (struct omap_mpuio_s *)",
" g_malloc0(sizeof(struct omap_mpuio_s));"
],
"line_no": [
11,
13
]
} | static struct omap_mpuio_s *FUNC_0(MemoryRegion *VAR_0,
hwaddr VAR_1,
qemu_irq VAR_2, qemu_irq VAR_3, qemu_irq VAR_4,
omap_clk VAR_5)
{
struct omap_mpuio_s *VAR_6 = (struct omap_mpuio_s *)
g_malloc0(sizeof(struct omap_mpuio_s));
VAR_6->irq = VAR_3;
VAR_6->kbd_irq = VAR_2;
VAR_6->VAR_4 = VAR_4;
VAR_6->in = qemu_allocate_irqs(omap_mpuio_set, VAR_6, 16);
omap_mpuio_reset(VAR_6);
memory_region_init_io(&VAR_6->iomem, NULL, &omap_mpuio_ops, VAR_6,
"omap-mpuio", 0x800);
memory_region_add_subregion(VAR_0, VAR_1, &VAR_6->iomem);
omap_clk_adduser(VAR_5, qemu_allocate_irq(omap_mpuio_onoff, VAR_6, 0));
return VAR_6;
}
| [
"static struct omap_mpuio_s *FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nqemu_irq VAR_2, qemu_irq VAR_3, qemu_irq VAR_4,\nomap_clk VAR_5)\n{",
"struct omap_mpuio_s *VAR_6 = (struct omap_mpuio_s *)\ng_malloc0(sizeof(struct omap_mpuio_s));",
"VAR_6->irq = VAR_3;",
"VAR_6->kbd_irq = VAR_2;",
"VAR_6->VAR_4 = VA... | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11,
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29,
31
],
[
33
],
[
37
],
[
41
],
[
43
]
] |
15,670 | static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
int dc_index, int ac_index, int16_t *quant_matrix)
{
int code, i, j, level, val;
/* DC coef */
val = mjpeg_decode_dc(s, dc_index);
if (val == 0xfffff) {
av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return AVERROR_INVALIDDATA;
}
val = val * quant_matrix[0] + s->last_dc[component];
s->last_dc[component] = val;
block[0] = val;
/* AC coefs */
i = 0;
{OPEN_READER(re, &s->gb);
do {
UPDATE_CACHE(re, &s->gb);
GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
i += ((unsigned)code) >> 4;
code &= 0xf;
if (code) {
if (code > MIN_CACHE_BITS - 16)
UPDATE_CACHE(re, &s->gb);
{
int cache = GET_CACHE(re, &s->gb);
int sign = (~cache) >> 31;
level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
}
LAST_SKIP_BITS(re, &s->gb, code);
if (i > 63) {
av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
return AVERROR_INVALIDDATA;
}
j = s->scantable.permutated[i];
block[j] = level * quant_matrix[j];
}
} while (i < 63);
CLOSE_READER(re, &s->gb);}
return 0;
} | true | FFmpeg | dffae122d0f448029c30afc672233f114a3fe09c | static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
int dc_index, int ac_index, int16_t *quant_matrix)
{
int code, i, j, level, val;
val = mjpeg_decode_dc(s, dc_index);
if (val == 0xfffff) {
av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return AVERROR_INVALIDDATA;
}
val = val * quant_matrix[0] + s->last_dc[component];
s->last_dc[component] = val;
block[0] = val;
i = 0;
{OPEN_READER(re, &s->gb);
do {
UPDATE_CACHE(re, &s->gb);
GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
i += ((unsigned)code) >> 4;
code &= 0xf;
if (code) {
if (code > MIN_CACHE_BITS - 16)
UPDATE_CACHE(re, &s->gb);
{
int cache = GET_CACHE(re, &s->gb);
int sign = (~cache) >> 31;
level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
}
LAST_SKIP_BITS(re, &s->gb, code);
if (i > 63) {
av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
return AVERROR_INVALIDDATA;
}
j = s->scantable.permutated[i];
block[j] = level * quant_matrix[j];
}
} while (i < 63);
CLOSE_READER(re, &s->gb);}
return 0;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(MJpegDecodeContext *VAR_0, int16_t *VAR_1, int VAR_2,
int VAR_3, int VAR_4, int16_t *VAR_5)
{
int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;
VAR_10 = mjpeg_decode_dc(VAR_0, VAR_3);
if (VAR_10 == 0xfffff) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "error dc\n");
return AVERROR_INVALIDDATA;
}
VAR_10 = VAR_10 * VAR_5[0] + VAR_0->last_dc[VAR_2];
VAR_0->last_dc[VAR_2] = VAR_10;
VAR_1[0] = VAR_10;
VAR_7 = 0;
{OPEN_READER(re, &VAR_0->gb);
do {
UPDATE_CACHE(re, &VAR_0->gb);
GET_VLC(VAR_6, re, &VAR_0->gb, VAR_0->vlcs[1][VAR_4].table, 9, 2);
VAR_7 += ((unsigned)VAR_6) >> 4;
VAR_6 &= 0xf;
if (VAR_6) {
if (VAR_6 > MIN_CACHE_BITS - 16)
UPDATE_CACHE(re, &VAR_0->gb);
{
int VAR_11 = GET_CACHE(re, &VAR_0->gb);
int VAR_12 = (~VAR_11) >> 31;
VAR_9 = (NEG_USR32(VAR_12 ^ VAR_11,VAR_6) ^ VAR_12) - VAR_12;
}
LAST_SKIP_BITS(re, &VAR_0->gb, VAR_6);
if (VAR_7 > 63) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "error count: %d\n", VAR_7);
return AVERROR_INVALIDDATA;
}
VAR_8 = VAR_0->scantable.permutated[VAR_7];
VAR_1[VAR_8] = VAR_9 * VAR_5[VAR_8];
}
} while (VAR_7 < 63);
CLOSE_READER(re, &VAR_0->gb);}
return 0;
} | [
"static int FUNC_0(MJpegDecodeContext *VAR_0, int16_t *VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int16_t *VAR_5)\n{",
"int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;",
"VAR_10 = mjpeg_decode_dc(VAR_0, VAR_3);",
"if (VAR_10 == 0xfffff) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"error dc\\n\");",
"return AVERROR_INV... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
26
],
[
28
],
[
32
],
[
34
],
[
36
],
[
38
],
[
40
],
[
44
],
[
46
],
[
48
],
[
50,
52... |
15,671 | static void iscsi_attach_aio_context(BlockDriverState *bs,
AioContext *new_context)
{
IscsiLun *iscsilun = bs->opaque;
iscsilun->aio_context = new_context;
iscsi_set_events(iscsilun);
#if defined(LIBISCSI_FEATURE_NOP_COUNTER)
/* Set up a timer for sending out iSCSI NOPs */
iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
QEMU_CLOCK_REALTIME, SCALE_MS,
iscsi_nop_timed_event, iscsilun);
timer_mod(iscsilun->nop_timer,
qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
#endif
}
| true | qemu | e49ab19fcaa617ad6cdfe1ac401327326b6a2552 | static void iscsi_attach_aio_context(BlockDriverState *bs,
AioContext *new_context)
{
IscsiLun *iscsilun = bs->opaque;
iscsilun->aio_context = new_context;
iscsi_set_events(iscsilun);
#if defined(LIBISCSI_FEATURE_NOP_COUNTER)
iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
QEMU_CLOCK_REALTIME, SCALE_MS,
iscsi_nop_timed_event, iscsilun);
timer_mod(iscsilun->nop_timer,
qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
#endif
}
| {
"code": [
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"#if defined(LIBISCSI_FEATURE_NOP_COUNTER)",
"#endif",
"#if defined(LIBISCSI_FEATURE_NOP_COUNTER)",
"#endif",
"#endif",
"#endif",
"#endif"
],
"line_no": [
31,
31,
31,
31,
31,
31,
31,
31,
17,
31,
17,
31,
31,
31,
31
]
} | static void FUNC_0(BlockDriverState *VAR_0,
AioContext *VAR_1)
{
IscsiLun *iscsilun = VAR_0->opaque;
iscsilun->aio_context = VAR_1;
iscsi_set_events(iscsilun);
#if defined(LIBISCSI_FEATURE_NOP_COUNTER)
iscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,
QEMU_CLOCK_REALTIME, SCALE_MS,
iscsi_nop_timed_event, iscsilun);
timer_mod(iscsilun->nop_timer,
qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
#endif
}
| [
"static void FUNC_0(BlockDriverState *VAR_0,\nAioContext *VAR_1)\n{",
"IscsiLun *iscsilun = VAR_0->opaque;",
"iscsilun->aio_context = VAR_1;",
"iscsi_set_events(iscsilun);",
"#if defined(LIBISCSI_FEATURE_NOP_COUNTER)\niscsilun->nop_timer = aio_timer_new(iscsilun->aio_context,\nQEMU_CLOCK_REALTIME, SCALE_MS,... | [
0,
0,
0,
0,
1,
0,
1
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
17,
21,
23,
25
],
[
27,
29
],
[
31,
33
]
] |
15,672 | static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
{
BDRVVPCState *s = bs->opaque;
int64_t bat_offset;
uint32_t index, bat_value;
int ret;
uint8_t bitmap[s->bitmap_size];
// Check if sector_num is valid
if ((sector_num < 0) || (sector_num > bs->total_sectors))
return -1;
// Write entry into in-memory BAT
index = (sector_num * 512) / s->block_size;
if (s->pagetable[index] != 0xFFFFFFFF)
return -1;
s->pagetable[index] = s->free_data_block_offset / 512;
// Initialize the block's bitmap
memset(bitmap, 0xff, s->bitmap_size);
bdrv_pwrite(bs->file, s->free_data_block_offset, bitmap, s->bitmap_size);
// Write new footer (the old one will be overwritten)
s->free_data_block_offset += s->block_size + s->bitmap_size;
ret = rewrite_footer(bs);
if (ret < 0)
goto fail;
// Write BAT entry to disk
bat_offset = s->bat_offset + (4 * index);
bat_value = be32_to_cpu(s->pagetable[index]);
ret = bdrv_pwrite(bs->file, bat_offset, &bat_value, 4);
if (ret < 0)
goto fail;
return get_sector_offset(bs, sector_num, 0);
fail:
s->free_data_block_offset -= (s->block_size + s->bitmap_size);
return -1;
}
| true | qemu | 078a458e077d6b0db262c4b05fee51d01de2d1d2 | static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
{
BDRVVPCState *s = bs->opaque;
int64_t bat_offset;
uint32_t index, bat_value;
int ret;
uint8_t bitmap[s->bitmap_size];
if ((sector_num < 0) || (sector_num > bs->total_sectors))
return -1;
index = (sector_num * 512) / s->block_size;
if (s->pagetable[index] != 0xFFFFFFFF)
return -1;
s->pagetable[index] = s->free_data_block_offset / 512;
memset(bitmap, 0xff, s->bitmap_size);
bdrv_pwrite(bs->file, s->free_data_block_offset, bitmap, s->bitmap_size);
s->free_data_block_offset += s->block_size + s->bitmap_size;
ret = rewrite_footer(bs);
if (ret < 0)
goto fail;
bat_offset = s->bat_offset + (4 * index);
bat_value = be32_to_cpu(s->pagetable[index]);
ret = bdrv_pwrite(bs->file, bat_offset, &bat_value, 4);
if (ret < 0)
goto fail;
return get_sector_offset(bs, sector_num, 0);
fail:
s->free_data_block_offset -= (s->block_size + s->bitmap_size);
return -1;
}
| {
"code": [
" bdrv_pwrite(bs->file, s->free_data_block_offset, bitmap, s->bitmap_size);",
" ret = bdrv_pwrite(bs->file, bat_offset, &bat_value, 4);"
],
"line_no": [
43,
65
]
} | static int64_t FUNC_0(BlockDriverState* bs, int64_t sector_num)
{
BDRVVPCState *s = bs->opaque;
int64_t bat_offset;
uint32_t index, bat_value;
int VAR_0;
uint8_t bitmap[s->bitmap_size];
if ((sector_num < 0) || (sector_num > bs->total_sectors))
return -1;
index = (sector_num * 512) / s->block_size;
if (s->pagetable[index] != 0xFFFFFFFF)
return -1;
s->pagetable[index] = s->free_data_block_offset / 512;
memset(bitmap, 0xff, s->bitmap_size);
bdrv_pwrite(bs->file, s->free_data_block_offset, bitmap, s->bitmap_size);
s->free_data_block_offset += s->block_size + s->bitmap_size;
VAR_0 = rewrite_footer(bs);
if (VAR_0 < 0)
goto fail;
bat_offset = s->bat_offset + (4 * index);
bat_value = be32_to_cpu(s->pagetable[index]);
VAR_0 = bdrv_pwrite(bs->file, bat_offset, &bat_value, 4);
if (VAR_0 < 0)
goto fail;
return get_sector_offset(bs, sector_num, 0);
fail:
s->free_data_block_offset -= (s->block_size + s->bitmap_size);
return -1;
}
| [
"static int64_t FUNC_0(BlockDriverState* bs, int64_t sector_num)\n{",
"BDRVVPCState *s = bs->opaque;",
"int64_t bat_offset;",
"uint32_t index, bat_value;",
"int VAR_0;",
"uint8_t bitmap[s->bitmap_size];",
"if ((sector_num < 0) || (sector_num > bs->total_sectors))\nreturn -1;",
"index = (sector_num * 5... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
19,
21
],
[
27
],
[
29,
31
],
[
35
],
[
41
],
[
43
],
[
49
],
[
51
],
[
53,
55
],
[
61
],
[
63
],
[
65
],
[... |
15,673 | static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
int width, int height, int bandpos)
{
int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y, clnpass_cnt = 0;
int bpass_csty_symbol = JPEG2000_CBLK_BYPASS & codsty->cblk_style;
int vert_causal_ctx_csty_symbol = JPEG2000_CBLK_VSC & codsty->cblk_style;
for (y = 0; y < height; y++)
memset(t1->data[y], 0, width * sizeof(**t1->data));
/* If code-block contains no compressed data: nothing to do. */
if (!cblk->length)
return 0;
for (y = 0; y < height+2; y++)
memset(t1->flags[y], 0, (width + 2)*sizeof(**t1->flags));
cblk->data[cblk->length] = 0xff;
cblk->data[cblk->length+1] = 0xff;
ff_mqc_initdec(&t1->mqc, cblk->data);
while (passno--) {
if (bpno < 0) {
av_log(s->avctx, AV_LOG_ERROR, "bpno invalid\n");
return AVERROR(EINVAL);
}
switch(pass_t) {
case 0:
decode_sigpass(t1, width, height, bpno + 1, bandpos,
bpass_csty_symbol && (clnpass_cnt >= 4), vert_causal_ctx_csty_symbol);
break;
case 1:
decode_refpass(t1, width, height, bpno + 1);
if (bpass_csty_symbol && clnpass_cnt >= 4)
ff_mqc_initdec(&t1->mqc, cblk->data);
break;
case 2:
decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
codsty->cblk_style & JPEG2000_CBLK_SEGSYM, vert_causal_ctx_csty_symbol);
clnpass_cnt = clnpass_cnt + 1;
if (bpass_csty_symbol && clnpass_cnt >= 4)
ff_mqc_initdec(&t1->mqc, cblk->data);
break;
}
pass_t++;
if (pass_t == 3) {
bpno--;
pass_t = 0;
}
}
return 0;
}
| true | FFmpeg | 3b8617429014301b26b587a5e537910746d3377a | static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
int width, int height, int bandpos)
{
int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1, y, clnpass_cnt = 0;
int bpass_csty_symbol = JPEG2000_CBLK_BYPASS & codsty->cblk_style;
int vert_causal_ctx_csty_symbol = JPEG2000_CBLK_VSC & codsty->cblk_style;
for (y = 0; y < height; y++)
memset(t1->data[y], 0, width * sizeof(**t1->data));
if (!cblk->length)
return 0;
for (y = 0; y < height+2; y++)
memset(t1->flags[y], 0, (width + 2)*sizeof(**t1->flags));
cblk->data[cblk->length] = 0xff;
cblk->data[cblk->length+1] = 0xff;
ff_mqc_initdec(&t1->mqc, cblk->data);
while (passno--) {
if (bpno < 0) {
av_log(s->avctx, AV_LOG_ERROR, "bpno invalid\n");
return AVERROR(EINVAL);
}
switch(pass_t) {
case 0:
decode_sigpass(t1, width, height, bpno + 1, bandpos,
bpass_csty_symbol && (clnpass_cnt >= 4), vert_causal_ctx_csty_symbol);
break;
case 1:
decode_refpass(t1, width, height, bpno + 1);
if (bpass_csty_symbol && clnpass_cnt >= 4)
ff_mqc_initdec(&t1->mqc, cblk->data);
break;
case 2:
decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
codsty->cblk_style & JPEG2000_CBLK_SEGSYM, vert_causal_ctx_csty_symbol);
clnpass_cnt = clnpass_cnt + 1;
if (bpass_csty_symbol && clnpass_cnt >= 4)
ff_mqc_initdec(&t1->mqc, cblk->data);
break;
}
pass_t++;
if (pass_t == 3) {
bpno--;
pass_t = 0;
}
}
return 0;
}
| {
"code": [
" if (bpno < 0) {",
" av_log(s->avctx, AV_LOG_ERROR, \"bpno invalid\\n\");",
" return AVERROR(EINVAL);"
],
"line_no": [
47,
49,
51
]
} | static int FUNC_0(Jpeg2000DecoderContext *VAR_0, Jpeg2000CodingStyle *VAR_1,
Jpeg2000T1Context *VAR_2, Jpeg2000Cblk *VAR_3,
int VAR_4, int VAR_5, int VAR_6)
{
int VAR_7 = VAR_3->npasses, VAR_8 = 2, VAR_9 = VAR_3->nonzerobits - 1, VAR_10, VAR_11 = 0;
int VAR_12 = JPEG2000_CBLK_BYPASS & VAR_1->cblk_style;
int VAR_13 = JPEG2000_CBLK_VSC & VAR_1->cblk_style;
for (VAR_10 = 0; VAR_10 < VAR_5; VAR_10++)
memset(VAR_2->data[VAR_10], 0, VAR_4 * sizeof(**VAR_2->data));
if (!VAR_3->length)
return 0;
for (VAR_10 = 0; VAR_10 < VAR_5+2; VAR_10++)
memset(VAR_2->flags[VAR_10], 0, (VAR_4 + 2)*sizeof(**VAR_2->flags));
VAR_3->data[VAR_3->length] = 0xff;
VAR_3->data[VAR_3->length+1] = 0xff;
ff_mqc_initdec(&VAR_2->mqc, VAR_3->data);
while (VAR_7--) {
if (VAR_9 < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_9 invalid\n");
return AVERROR(EINVAL);
}
switch(VAR_8) {
case 0:
decode_sigpass(VAR_2, VAR_4, VAR_5, VAR_9 + 1, VAR_6,
VAR_12 && (VAR_11 >= 4), VAR_13);
break;
case 1:
decode_refpass(VAR_2, VAR_4, VAR_5, VAR_9 + 1);
if (VAR_12 && VAR_11 >= 4)
ff_mqc_initdec(&VAR_2->mqc, VAR_3->data);
break;
case 2:
decode_clnpass(VAR_0, VAR_2, VAR_4, VAR_5, VAR_9 + 1, VAR_6,
VAR_1->cblk_style & JPEG2000_CBLK_SEGSYM, VAR_13);
VAR_11 = VAR_11 + 1;
if (VAR_12 && VAR_11 >= 4)
ff_mqc_initdec(&VAR_2->mqc, VAR_3->data);
break;
}
VAR_8++;
if (VAR_8 == 3) {
VAR_9--;
VAR_8 = 0;
}
}
return 0;
}
| [
"static int FUNC_0(Jpeg2000DecoderContext *VAR_0, Jpeg2000CodingStyle *VAR_1,\nJpeg2000T1Context *VAR_2, Jpeg2000Cblk *VAR_3,\nint VAR_4, int VAR_5, int VAR_6)\n{",
"int VAR_7 = VAR_3->npasses, VAR_8 = 2, VAR_9 = VAR_3->nonzerobits - 1, VAR_10, VAR_11 = 0;",
"int VAR_12 = JPEG2000_CBLK_BYPASS & VAR_1->cblk_styl... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
25,
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[... |
15,674 | static void gen_addq(DisasContext *s, TCGv_i64 val, int rlow, int rhigh)
{
TCGv_i64 tmp;
TCGv tmpl;
TCGv tmph;
/* Load 64-bit value rd:rn. */
tmpl = load_reg(s, rlow);
tmph = load_reg(s, rhigh);
tmp = tcg_temp_new_i64();
tcg_gen_concat_i32_i64(tmp, tmpl, tmph);
dead_tmp(tmpl);
dead_tmp(tmph);
tcg_gen_add_i64(val, val, tmp);
tcg_temp_free_i64(tmp);
}
| true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 | static void gen_addq(DisasContext *s, TCGv_i64 val, int rlow, int rhigh)
{
TCGv_i64 tmp;
TCGv tmpl;
TCGv tmph;
tmpl = load_reg(s, rlow);
tmph = load_reg(s, rhigh);
tmp = tcg_temp_new_i64();
tcg_gen_concat_i32_i64(tmp, tmpl, tmph);
dead_tmp(tmpl);
dead_tmp(tmph);
tcg_gen_add_i64(val, val, tmp);
tcg_temp_free_i64(tmp);
}
| {
"code": [
" dead_tmp(tmpl);",
" dead_tmp(tmph);"
],
"line_no": [
23,
25
]
} | static void FUNC_0(DisasContext *VAR_0, TCGv_i64 VAR_1, int VAR_2, int VAR_3)
{
TCGv_i64 tmp;
TCGv tmpl;
TCGv tmph;
tmpl = load_reg(VAR_0, VAR_2);
tmph = load_reg(VAR_0, VAR_3);
tmp = tcg_temp_new_i64();
tcg_gen_concat_i32_i64(tmp, tmpl, tmph);
dead_tmp(tmpl);
dead_tmp(tmph);
tcg_gen_add_i64(VAR_1, VAR_1, tmp);
tcg_temp_free_i64(tmp);
}
| [
"static void FUNC_0(DisasContext *VAR_0, TCGv_i64 VAR_1, int VAR_2, int VAR_3)\n{",
"TCGv_i64 tmp;",
"TCGv tmpl;",
"TCGv tmph;",
"tmpl = load_reg(VAR_0, VAR_2);",
"tmph = load_reg(VAR_0, VAR_3);",
"tmp = tcg_temp_new_i64();",
"tcg_gen_concat_i32_i64(tmp, tmpl, tmph);",
"dead_tmp(tmpl);",
"dead_tmp... | [
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
]
] |
15,675 | static int do_compress_ram_page(QEMUFile *f, RAMBlock *block,
ram_addr_t offset)
{
RAMState *rs = &ram_state;
int bytes_sent, blen;
uint8_t *p = block->host + (offset & TARGET_PAGE_MASK);
bytes_sent = save_page_header(rs, block, offset |
RAM_SAVE_FLAG_COMPRESS_PAGE);
blen = qemu_put_compression_data(f, p, TARGET_PAGE_SIZE,
migrate_compress_level());
if (blen < 0) {
bytes_sent = 0;
qemu_file_set_error(migrate_get_current()->to_dst_file, blen);
error_report("compressed data failed!");
} else {
bytes_sent += blen;
ram_release_pages(block->idstr, offset & TARGET_PAGE_MASK, 1);
}
return bytes_sent;
}
| true | qemu | 2bf3aa85f08186b8162b76e7e8efe5b5a44306a6 | static int do_compress_ram_page(QEMUFile *f, RAMBlock *block,
ram_addr_t offset)
{
RAMState *rs = &ram_state;
int bytes_sent, blen;
uint8_t *p = block->host + (offset & TARGET_PAGE_MASK);
bytes_sent = save_page_header(rs, block, offset |
RAM_SAVE_FLAG_COMPRESS_PAGE);
blen = qemu_put_compression_data(f, p, TARGET_PAGE_SIZE,
migrate_compress_level());
if (blen < 0) {
bytes_sent = 0;
qemu_file_set_error(migrate_get_current()->to_dst_file, blen);
error_report("compressed data failed!");
} else {
bytes_sent += blen;
ram_release_pages(block->idstr, offset & TARGET_PAGE_MASK, 1);
}
return bytes_sent;
}
| {
"code": [
" bytes_sent = save_page_header(rs, block, offset |"
],
"line_no": [
15
]
} | static int FUNC_0(QEMUFile *VAR_0, RAMBlock *VAR_1,
ram_addr_t VAR_2)
{
RAMState *rs = &ram_state;
int VAR_3, VAR_4;
uint8_t *p = VAR_1->host + (VAR_2 & TARGET_PAGE_MASK);
VAR_3 = save_page_header(rs, VAR_1, VAR_2 |
RAM_SAVE_FLAG_COMPRESS_PAGE);
VAR_4 = qemu_put_compression_data(VAR_0, p, TARGET_PAGE_SIZE,
migrate_compress_level());
if (VAR_4 < 0) {
VAR_3 = 0;
qemu_file_set_error(migrate_get_current()->to_dst_file, VAR_4);
error_report("compressed data failed!");
} else {
VAR_3 += VAR_4;
ram_release_pages(VAR_1->idstr, VAR_2 & TARGET_PAGE_MASK, 1);
}
return VAR_3;
}
| [
"static int FUNC_0(QEMUFile *VAR_0, RAMBlock *VAR_1,\nram_addr_t VAR_2)\n{",
"RAMState *rs = &ram_state;",
"int VAR_3, VAR_4;",
"uint8_t *p = VAR_1->host + (VAR_2 & TARGET_PAGE_MASK);",
"VAR_3 = save_page_header(rs, VAR_1, VAR_2 |\nRAM_SAVE_FLAG_COMPRESS_PAGE);",
"VAR_4 = qemu_put_compression_data(VAR_0, ... | [
0,
0,
0,
0,
1,
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
],
[
43
]
] |
15,676 | void ff_avg_h264_qpel4_mc11_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_4x4_msa(src - 2,
src - (stride * 2),
stride, dst, stride);
}
| false | FFmpeg | 1181d93231e9b807965724587d363c1cfd5a1d0d | void ff_avg_h264_qpel4_mc11_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_4x4_msa(src - 2,
src - (stride * 2),
stride, dst, stride);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,
ptrdiff_t VAR_2)
{
avc_luma_hv_qrt_and_aver_dst_4x4_msa(VAR_1 - 2,
VAR_1 - (VAR_2 * 2),
VAR_2, VAR_0, VAR_2);
}
| [
"void FUNC_0(uint8_t *VAR_0, const uint8_t *VAR_1,\nptrdiff_t VAR_2)\n{",
"avc_luma_hv_qrt_and_aver_dst_4x4_msa(VAR_1 - 2,\nVAR_1 - (VAR_2 * 2),\nVAR_2, VAR_0, VAR_2);",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5
],
[
7,
9,
11
],
[
13
]
] |
15,677 | static int ra144_decode_frame(AVCodecContext * avctx,
void *vdata, int *data_size,
const uint8_t * buf, int buf_size)
{
static const uint8_t sizes[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
unsigned int a, b, c;
int i;
signed short *shptr;
int16_t *data = vdata;
unsigned int val;
Real144_internal *glob = avctx->priv_data;
GetBitContext gb;
if(buf_size == 0)
return 0;
init_get_bits(&gb, buf, 20 * 8);
for (i=0; i<10; i++)
// "<< 1"? Doesn't this make one value out of two of the table useless?
glob->swapbuf1[i] = decodetable[i][get_bits(&gb, sizes[i]) << 1];
do_voice(glob->swapbuf1, glob->swapbuf2);
val = decodeval[get_bits(&gb, 5) << 1]; // Useless table entries?
a = t_sqrt(val*glob->oldval) >> 12;
for (c=0; c < NBLOCKS; c++) {
if (c == (NBLOCKS - 1)) {
dec1(glob, glob->swapbuf1, glob->swapbuf2, 3, val);
} else {
if (c * 2 == (NBLOCKS - 2)) {
if (glob->oldval < val) {
dec2(glob, glob->swapbuf1, glob->swapbuf2, 3, a, glob->swapbuf2alt, c);
} else {
dec2(glob, glob->swapbuf1alt, glob->swapbuf2alt, 3, a, glob->swapbuf2, c);
}
} else {
if (c * 2 < (NBLOCKS - 2)) {
dec2(glob, glob->swapbuf1alt, glob->swapbuf2alt, 3, glob->oldval, glob->swapbuf2, c);
} else {
dec2(glob, glob->swapbuf1, glob->swapbuf2, 3, val, glob->swapbuf2alt, c);
}
}
}
}
/* do output */
for (b=0, c=0; c<4; c++) {
unsigned int gval = glob->gbuf1[c * 2];
unsigned short *gsp = glob->gbuf2 + b;
signed short output_buffer[40];
do_output_subblock(glob, gsp, gval, output_buffer, &gb);
shptr = output_buffer;
while (shptr < output_buffer + BLOCKSIZE)
*data++ = av_clip_int16(*(shptr++) << 2);
b += 30;
}
glob->oldval = val;
FFSWAP(unsigned int *, glob->swapbuf1alt, glob->swapbuf1);
FFSWAP(unsigned int *, glob->swapbuf2alt, glob->swapbuf2);
*data_size = 2*160;
return 20;
}
| false | FFmpeg | 59ffb6e2cc0974f3090a10facdedf8da5f6bf742 | static int ra144_decode_frame(AVCodecContext * avctx,
void *vdata, int *data_size,
const uint8_t * buf, int buf_size)
{
static const uint8_t sizes[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
unsigned int a, b, c;
int i;
signed short *shptr;
int16_t *data = vdata;
unsigned int val;
Real144_internal *glob = avctx->priv_data;
GetBitContext gb;
if(buf_size == 0)
return 0;
init_get_bits(&gb, buf, 20 * 8);
for (i=0; i<10; i++)
glob->swapbuf1[i] = decodetable[i][get_bits(&gb, sizes[i]) << 1];
do_voice(glob->swapbuf1, glob->swapbuf2);
val = decodeval[get_bits(&gb, 5) << 1];
a = t_sqrt(val*glob->oldval) >> 12;
for (c=0; c < NBLOCKS; c++) {
if (c == (NBLOCKS - 1)) {
dec1(glob, glob->swapbuf1, glob->swapbuf2, 3, val);
} else {
if (c * 2 == (NBLOCKS - 2)) {
if (glob->oldval < val) {
dec2(glob, glob->swapbuf1, glob->swapbuf2, 3, a, glob->swapbuf2alt, c);
} else {
dec2(glob, glob->swapbuf1alt, glob->swapbuf2alt, 3, a, glob->swapbuf2, c);
}
} else {
if (c * 2 < (NBLOCKS - 2)) {
dec2(glob, glob->swapbuf1alt, glob->swapbuf2alt, 3, glob->oldval, glob->swapbuf2, c);
} else {
dec2(glob, glob->swapbuf1, glob->swapbuf2, 3, val, glob->swapbuf2alt, c);
}
}
}
}
for (b=0, c=0; c<4; c++) {
unsigned int gval = glob->gbuf1[c * 2];
unsigned short *gsp = glob->gbuf2 + b;
signed short output_buffer[40];
do_output_subblock(glob, gsp, gval, output_buffer, &gb);
shptr = output_buffer;
while (shptr < output_buffer + BLOCKSIZE)
*data++ = av_clip_int16(*(shptr++) << 2);
b += 30;
}
glob->oldval = val;
FFSWAP(unsigned int *, glob->swapbuf1alt, glob->swapbuf1);
FFSWAP(unsigned int *, glob->swapbuf2alt, glob->swapbuf2);
*data_size = 2*160;
return 20;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext * VAR_0,
void *VAR_1, int *VAR_2,
const uint8_t * VAR_3, int VAR_4)
{
static const uint8_t VAR_5[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
unsigned int VAR_6, VAR_7, VAR_8;
int VAR_9;
signed short *VAR_10;
int16_t *data = VAR_1;
unsigned int VAR_11;
Real144_internal *glob = VAR_0->priv_data;
GetBitContext gb;
if(VAR_4 == 0)
return 0;
init_get_bits(&gb, VAR_3, 20 * 8);
for (VAR_9=0; VAR_9<10; VAR_9++)
glob->swapbuf1[VAR_9] = decodetable[VAR_9][get_bits(&gb, VAR_5[VAR_9]) << 1];
do_voice(glob->swapbuf1, glob->swapbuf2);
VAR_11 = decodeval[get_bits(&gb, 5) << 1];
VAR_6 = t_sqrt(VAR_11*glob->oldval) >> 12;
for (VAR_8=0; VAR_8 < NBLOCKS; VAR_8++) {
if (VAR_8 == (NBLOCKS - 1)) {
dec1(glob, glob->swapbuf1, glob->swapbuf2, 3, VAR_11);
} else {
if (VAR_8 * 2 == (NBLOCKS - 2)) {
if (glob->oldval < VAR_11) {
dec2(glob, glob->swapbuf1, glob->swapbuf2, 3, VAR_6, glob->swapbuf2alt, VAR_8);
} else {
dec2(glob, glob->swapbuf1alt, glob->swapbuf2alt, 3, VAR_6, glob->swapbuf2, VAR_8);
}
} else {
if (VAR_8 * 2 < (NBLOCKS - 2)) {
dec2(glob, glob->swapbuf1alt, glob->swapbuf2alt, 3, glob->oldval, glob->swapbuf2, VAR_8);
} else {
dec2(glob, glob->swapbuf1, glob->swapbuf2, 3, VAR_11, glob->swapbuf2alt, VAR_8);
}
}
}
}
for (VAR_7=0, VAR_8=0; VAR_8<4; VAR_8++) {
unsigned int VAR_12 = glob->gbuf1[VAR_8 * 2];
unsigned short *VAR_13 = glob->gbuf2 + VAR_7;
signed short VAR_14[40];
do_output_subblock(glob, VAR_13, VAR_12, VAR_14, &gb);
VAR_10 = VAR_14;
while (VAR_10 < VAR_14 + BLOCKSIZE)
*data++ = av_clip_int16(*(VAR_10++) << 2);
VAR_7 += 30;
}
glob->oldval = VAR_11;
FFSWAP(unsigned int *, glob->swapbuf1alt, glob->swapbuf1);
FFSWAP(unsigned int *, glob->swapbuf2alt, glob->swapbuf2);
*VAR_2 = 2*160;
return 20;
}
| [
"static int FUNC_0(AVCodecContext * VAR_0,\nvoid *VAR_1, int *VAR_2,\nconst uint8_t * VAR_3, int VAR_4)\n{",
"static const uint8_t VAR_5[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};",
"unsigned int VAR_6, VAR_7, VAR_8;",
"int VAR_9;",
"signed short *VAR_10;",
"int16_t *data = VAR_1;",
"unsigned int VAR_11;",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29,
31
],
[
35
],
[
39
],
[
43
],
[
47
],
[
51
],
[
53
],
[
57
],
[
59
],
[... |
15,678 | static int h261_decode_picture_header(H261Context *h)
{
MpegEncContext *const s = &h->s;
int format, i;
uint32_t startcode = 0;
for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
if (startcode == 0x10)
break;
}
if (startcode != 0x10) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
/* temporal reference */
i = get_bits(&s->gb, 5); /* picture timestamp */
if (i < (s->picture_number & 31))
i += 32;
s->picture_number = (s->picture_number & ~31) + i;
s->avctx->time_base = (AVRational) { 1001, 30000 };
/* PTYPE starts here */
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */
format = get_bits1(&s->gb);
// only 2 formats possible
if (format == 0) { // QCIF
s->width = 176;
s->height = 144;
s->mb_width = 11;
s->mb_height = 9;
} else { // CIF
s->width = 352;
s->height = 288;
s->mb_width = 22;
s->mb_height = 18;
}
s->mb_num = s->mb_width * s->mb_height;
skip_bits1(&s->gb); /* still image mode off */
skip_bits1(&s->gb); /* Reserved */
/* PEI */
while (get_bits1(&s->gb) != 0)
skip_bits(&s->gb, 8);
/* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
* frame, the codec crashes if it does not contain all I-blocks
* (e.g. when a packet is lost). */
s->pict_type = AV_PICTURE_TYPE_P;
h->gob_number = 0;
return 0;
}
| false | FFmpeg | 719dbe86ea0e85b3b89f492c69e10bb0e733bcbb | static int h261_decode_picture_header(H261Context *h)
{
MpegEncContext *const s = &h->s;
int format, i;
uint32_t startcode = 0;
for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
if (startcode == 0x10)
break;
}
if (startcode != 0x10) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
i = get_bits(&s->gb, 5);
if (i < (s->picture_number & 31))
i += 32;
s->picture_number = (s->picture_number & ~31) + i;
s->avctx->time_base = (AVRational) { 1001, 30000 };
skip_bits1(&s->gb);
skip_bits1(&s->gb);
skip_bits1(&s->gb);
format = get_bits1(&s->gb);
if (format == 0) {
s->width = 176;
s->height = 144;
s->mb_width = 11;
s->mb_height = 9;
} else {
s->width = 352;
s->height = 288;
s->mb_width = 22;
s->mb_height = 18;
}
s->mb_num = s->mb_width * s->mb_height;
skip_bits1(&s->gb);
skip_bits1(&s->gb);
while (get_bits1(&s->gb) != 0)
skip_bits(&s->gb, 8);
s->pict_type = AV_PICTURE_TYPE_P;
h->gob_number = 0;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(H261Context *VAR_0)
{
MpegEncContext *const s = &VAR_0->s;
int VAR_1, VAR_2;
uint32_t startcode = 0;
for (VAR_2 = get_bits_left(&s->gb); VAR_2 > 24; VAR_2 -= 1) {
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
if (startcode == 0x10)
break;
}
if (startcode != 0x10) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
VAR_2 = get_bits(&s->gb, 5);
if (VAR_2 < (s->picture_number & 31))
VAR_2 += 32;
s->picture_number = (s->picture_number & ~31) + VAR_2;
s->avctx->time_base = (AVRational) { 1001, 30000 };
skip_bits1(&s->gb);
skip_bits1(&s->gb);
skip_bits1(&s->gb);
VAR_1 = get_bits1(&s->gb);
if (VAR_1 == 0) {
s->width = 176;
s->height = 144;
s->mb_width = 11;
s->mb_height = 9;
} else {
s->width = 352;
s->height = 288;
s->mb_width = 22;
s->mb_height = 18;
}
s->mb_num = s->mb_width * s->mb_height;
skip_bits1(&s->gb);
skip_bits1(&s->gb);
while (get_bits1(&s->gb) != 0)
skip_bits(&s->gb, 8);
s->pict_type = AV_PICTURE_TYPE_P;
VAR_0->gob_number = 0;
return 0;
}
| [
"static int FUNC_0(H261Context *VAR_0)\n{",
"MpegEncContext *const s = &VAR_0->s;",
"int VAR_1, VAR_2;",
"uint32_t startcode = 0;",
"for (VAR_2 = get_bits_left(&s->gb); VAR_2 > 24; VAR_2 -= 1) {",
"startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;",
"if (startcode == 0x10)\nbreak;",
"... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
39
],
[
41,
43
],
[
45
],
[
49
],
[
55
],
[
57
],
[
59
... |
15,680 | static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
{
PowerPCCPU *cpu = POWERPC_CPU(dev);
CPUPPCState *env = &cpu->env;
opc_handler_t **table;
int i, j;
cpu_exec_exit(CPU(dev));
for (i = 0; i < PPC_CPU_OPCODES_LEN; i++) {
if (env->opcodes[i] == &invalid_handler) {
continue;
}
if (is_indirect_opcode(env->opcodes[i])) {
table = ind_table(env->opcodes[i]);
for (j = 0; j < PPC_CPU_INDIRECT_OPCODES_LEN; j++) {
if (table[j] != &invalid_handler &&
is_indirect_opcode(table[j])) {
g_free((opc_handler_t *)((uintptr_t)table[j] &
~PPC_INDIRECT));
}
}
g_free((opc_handler_t *)((uintptr_t)env->opcodes[i] &
~PPC_INDIRECT));
}
}
}
| true | qemu | 323ad19bcc601d3ec9cb6f0f5b4d67b602fc519e | static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
{
PowerPCCPU *cpu = POWERPC_CPU(dev);
CPUPPCState *env = &cpu->env;
opc_handler_t **table;
int i, j;
cpu_exec_exit(CPU(dev));
for (i = 0; i < PPC_CPU_OPCODES_LEN; i++) {
if (env->opcodes[i] == &invalid_handler) {
continue;
}
if (is_indirect_opcode(env->opcodes[i])) {
table = ind_table(env->opcodes[i]);
for (j = 0; j < PPC_CPU_INDIRECT_OPCODES_LEN; j++) {
if (table[j] != &invalid_handler &&
is_indirect_opcode(table[j])) {
g_free((opc_handler_t *)((uintptr_t)table[j] &
~PPC_INDIRECT));
}
}
g_free((opc_handler_t *)((uintptr_t)env->opcodes[i] &
~PPC_INDIRECT));
}
}
}
| {
"code": [
" opc_handler_t **table;",
" int i, j;",
" if (table[j] != &invalid_handler &&",
" is_indirect_opcode(table[j])) {",
" ~PPC_INDIRECT));"
],
"line_no": [
9,
11,
33,
35,
39
]
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
PowerPCCPU *cpu = POWERPC_CPU(VAR_0);
CPUPPCState *env = &cpu->env;
opc_handler_t **table;
int VAR_2, VAR_3;
cpu_exec_exit(CPU(VAR_0));
for (VAR_2 = 0; VAR_2 < PPC_CPU_OPCODES_LEN; VAR_2++) {
if (env->opcodes[VAR_2] == &invalid_handler) {
continue;
}
if (is_indirect_opcode(env->opcodes[VAR_2])) {
table = ind_table(env->opcodes[VAR_2]);
for (VAR_3 = 0; VAR_3 < PPC_CPU_INDIRECT_OPCODES_LEN; VAR_3++) {
if (table[VAR_3] != &invalid_handler &&
is_indirect_opcode(table[VAR_3])) {
g_free((opc_handler_t *)((uintptr_t)table[VAR_3] &
~PPC_INDIRECT));
}
}
g_free((opc_handler_t *)((uintptr_t)env->opcodes[VAR_2] &
~PPC_INDIRECT));
}
}
}
| [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"PowerPCCPU *cpu = POWERPC_CPU(VAR_0);",
"CPUPPCState *env = &cpu->env;",
"opc_handler_t **table;",
"int VAR_2, VAR_3;",
"cpu_exec_exit(CPU(VAR_0));",
"for (VAR_2 = 0; VAR_2 < PPC_CPU_OPCODES_LEN; VAR_2++) {",
"if (env->opcodes[VAR_2] == &inv... | [
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[... |
15,681 | static void h261_decode_init_vlc(H261Context *h){
static int done = 0;
if(!done){
done = 1;
init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
h261_mba_bits, 1, 1,
h261_mba_code, 1, 1);
init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
h261_mtype_bits, 1, 1,
h261_mtype_code, 1, 1);
init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
&h261_mv_tab[0][1], 2, 1,
&h261_mv_tab[0][0], 2, 1);
init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
&h261_cbp_tab[0][1], 2, 1,
&h261_cbp_tab[0][0], 2, 1);
init_rl(&h261_rl_tcoeff);
init_vlc_rl(&h261_rl_tcoeff);
}
}
| true | FFmpeg | 073c2593c9f0aa4445a6fc1b9b24e6e52a8cc2c1 | static void h261_decode_init_vlc(H261Context *h){
static int done = 0;
if(!done){
done = 1;
init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
h261_mba_bits, 1, 1,
h261_mba_code, 1, 1);
init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
h261_mtype_bits, 1, 1,
h261_mtype_code, 1, 1);
init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
&h261_mv_tab[0][1], 2, 1,
&h261_mv_tab[0][0], 2, 1);
init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
&h261_cbp_tab[0][1], 2, 1,
&h261_cbp_tab[0][0], 2, 1);
init_rl(&h261_rl_tcoeff);
init_vlc_rl(&h261_rl_tcoeff);
}
}
| {
"code": [
" static int done = 0;",
" done = 1;",
" init_rl(&h261_rl_tcoeff);",
" h261_mba_code, 1, 1);",
" h261_mtype_code, 1, 1);",
" &h261_mv_tab[0][0], 2, 1);",
" &h261_cbp_tab[0][0], 2, 1);",
" init_rl(&h261_rl_tcoeff);",
" init_vlc_rl(&h261_rl_tcoeff);"
],
"line_no": [
3,
9,
35,
15,
21,
27,
33,
35,
37
]
} | static void FUNC_0(H261Context *VAR_0){
static int VAR_1 = 0;
if(!VAR_1){
VAR_1 = 1;
init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
h261_mba_bits, 1, 1,
h261_mba_code, 1, 1);
init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
h261_mtype_bits, 1, 1,
h261_mtype_code, 1, 1);
init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
&h261_mv_tab[0][1], 2, 1,
&h261_mv_tab[0][0], 2, 1);
init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
&h261_cbp_tab[0][1], 2, 1,
&h261_cbp_tab[0][0], 2, 1);
init_rl(&h261_rl_tcoeff);
init_vlc_rl(&h261_rl_tcoeff);
}
}
| [
"static void FUNC_0(H261Context *VAR_0){",
"static int VAR_1 = 0;",
"if(!VAR_1){",
"VAR_1 = 1;",
"init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,\nh261_mba_bits, 1, 1,\nh261_mba_code, 1, 1);",
"init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,\nh261_mtype_bits, 1, 1,\nh261_mtype_code, 1, 1);",
"init_vlc... | [
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0
] | [
[
1
],
[
3
],
[
7
],
[
9
],
[
11,
13,
15
],
[
17,
19,
21
],
[
23,
25,
27
],
[
29,
31,
33
],
[
35
],
[
37
],
[
39
],
[
41
]
] |
15,682 | static void init_proc_750cl (CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
/* XXX : not implemented */
spr_register(env, SPR_L2CR, "L2CR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, NULL,
0x00000000);
/* Time base */
gen_tbl(env);
/* Thermal management */
/* Those registers are fake on 750CL */
spr_register(env, SPR_THRM1, "THRM1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_THRM2, "THRM2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_THRM3, "THRM3",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX: not implemented */
spr_register(env, SPR_750_TDCL, "TDCL",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_TDCH, "TDCH",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* DMA */
/* XXX : not implemented */
spr_register(env, SPR_750_WPAR, "WPAR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_DMAL, "DMAL",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_DMAU, "DMAU",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* Hardware implementation registers */
/* XXX : not implemented */
spr_register(env, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_HID1, "HID1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750CL_HID2, "HID2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750CL_HID4, "HID4",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* Quantization registers */
/* XXX : not implemented */
spr_register(env, SPR_750_GQR0, "GQR0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR1, "GQR1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR2, "GQR2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR3, "GQR3",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR4, "GQR4",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR5, "GQR5",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR6, "GQR6",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register(env, SPR_750_GQR7, "GQR7",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* Memory management */
gen_low_BATs(env);
/* PowerPC 750cl has 8 DBATs and 8 IBATs */
gen_high_BATs(env);
init_excp_750cl(env);
env->dcache_line_size = 32;
env->icache_line_size = 32;
/* Allocate hardware IRQ controller */
ppc6xx_irq_init(env);
}
| true | qemu | 9633fcc6a02f23e3ef00aa5fe3fe9c41f57c3456 | static void init_proc_750cl (CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
spr_register(env, SPR_L2CR, "L2CR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, NULL,
0x00000000);
gen_tbl(env);
spr_register(env, SPR_THRM1, "THRM1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_THRM2, "THRM2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_THRM3, "THRM3",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_TDCL, "TDCL",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_TDCH, "TDCH",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_WPAR, "WPAR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_DMAL, "DMAL",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_DMAU, "DMAU",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_HID1, "HID1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750CL_HID2, "HID2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750CL_HID4, "HID4",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR0, "GQR0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR1, "GQR1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR2, "GQR2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR3, "GQR3",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR4, "GQR4",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR5, "GQR5",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR6, "GQR6",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_750_GQR7, "GQR7",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
gen_low_BATs(env);
gen_high_BATs(env);
init_excp_750cl(env);
env->dcache_line_size = 32;
env->icache_line_size = 32;
ppc6xx_irq_init(env);
}
| {
"code": [
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,",
" &spr_read_generic, NULL,"
],
"line_no": [
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15
]
} | static void FUNC_0 (CPUPPCState *VAR_0)
{
gen_spr_ne_601(VAR_0);
gen_spr_7xx(VAR_0);
spr_register(VAR_0, SPR_L2CR, "L2CR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, NULL,
0x00000000);
gen_tbl(VAR_0);
spr_register(VAR_0, SPR_THRM1, "THRM1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_THRM2, "THRM2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_THRM3, "THRM3",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_TDCL, "TDCL",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_TDCH, "TDCH",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_WPAR, "WPAR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_DMAL, "DMAL",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_DMAU, "DMAU",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_HID1, "HID1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750CL_HID2, "HID2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750CL_HID4, "HID4",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR0, "GQR0",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR1, "GQR1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR2, "GQR2",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR3, "GQR3",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR4, "GQR4",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR5, "GQR5",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR6, "GQR6",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(VAR_0, SPR_750_GQR7, "GQR7",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
gen_low_BATs(VAR_0);
gen_high_BATs(VAR_0);
init_excp_750cl(VAR_0);
VAR_0->dcache_line_size = 32;
VAR_0->icache_line_size = 32;
ppc6xx_irq_init(VAR_0);
}
| [
"static void FUNC_0 (CPUPPCState *VAR_0)\n{",
"gen_spr_ne_601(VAR_0);",
"gen_spr_7xx(VAR_0);",
"spr_register(VAR_0, SPR_L2CR, \"L2CR\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_read_generic, NULL,\n0x00000000);",
"gen_tbl(VAR_0);",
"spr_register(VAR_0, SPR_THRM1, \"THRM1\",\nSPR_NOACCESS, SPR_NOACCESS,\n&spr_re... | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13,
15,
17
],
[
21
],
[
27,
29,
31,
33
],
[
35,
37,
39,
41
],
[
43,
45,
47,
49
],
[
53,
55,
57,
59
],
[
61,
63,
65,
67
],
[
73... |
15,683 | static target_ulong h_set_mode(PowerPCCPU *cpu, sPAPREnvironment *spapr,
target_ulong opcode, target_ulong *args)
{
CPUState *cs;
target_ulong mflags = args[0];
target_ulong resource = args[1];
target_ulong value1 = args[2];
target_ulong value2 = args[3];
target_ulong ret = H_P2;
if (resource == H_SET_MODE_ENDIAN) {
if (value1) {
ret = H_P3;
goto out;
}
if (value2) {
ret = H_P4;
goto out;
}
switch (mflags) {
case H_SET_MODE_ENDIAN_BIG:
CPU_FOREACH(cs) {
PowerPCCPU *cp = POWERPC_CPU(cs);
CPUPPCState *env = &cp->env;
env->spr[SPR_LPCR] &= ~LPCR_ILE;
}
ret = H_SUCCESS;
break;
case H_SET_MODE_ENDIAN_LITTLE:
CPU_FOREACH(cs) {
PowerPCCPU *cp = POWERPC_CPU(cs);
CPUPPCState *env = &cp->env;
env->spr[SPR_LPCR] |= LPCR_ILE;
}
ret = H_SUCCESS;
break;
default:
ret = H_UNSUPPORTED_FLAG;
}
}
out:
return ret;
}
| true | qemu | a46622fd07edc6fd3c66f8ab79b4782a78b115f3 | static target_ulong h_set_mode(PowerPCCPU *cpu, sPAPREnvironment *spapr,
target_ulong opcode, target_ulong *args)
{
CPUState *cs;
target_ulong mflags = args[0];
target_ulong resource = args[1];
target_ulong value1 = args[2];
target_ulong value2 = args[3];
target_ulong ret = H_P2;
if (resource == H_SET_MODE_ENDIAN) {
if (value1) {
ret = H_P3;
goto out;
}
if (value2) {
ret = H_P4;
goto out;
}
switch (mflags) {
case H_SET_MODE_ENDIAN_BIG:
CPU_FOREACH(cs) {
PowerPCCPU *cp = POWERPC_CPU(cs);
CPUPPCState *env = &cp->env;
env->spr[SPR_LPCR] &= ~LPCR_ILE;
}
ret = H_SUCCESS;
break;
case H_SET_MODE_ENDIAN_LITTLE:
CPU_FOREACH(cs) {
PowerPCCPU *cp = POWERPC_CPU(cs);
CPUPPCState *env = &cp->env;
env->spr[SPR_LPCR] |= LPCR_ILE;
}
ret = H_SUCCESS;
break;
default:
ret = H_UNSUPPORTED_FLAG;
}
}
out:
return ret;
}
| {
"code": [
" if (resource == H_SET_MODE_ENDIAN) {",
" PowerPCCPU *cp = POWERPC_CPU(cs);",
" CPUPPCState *env = &cp->env;",
" env->spr[SPR_LPCR] &= ~LPCR_ILE;",
" PowerPCCPU *cp = POWERPC_CPU(cs);",
" CPUPPCState *env = &cp->env;",
" env->spr[SPR_LPCR] |= LPCR_ILE;"
],
"line_no": [
21,
47,
49,
51,
47,
49,
69
]
} | static target_ulong FUNC_0(PowerPCCPU *cpu, sPAPREnvironment *spapr,
target_ulong opcode, target_ulong *args)
{
CPUState *cs;
target_ulong mflags = args[0];
target_ulong resource = args[1];
target_ulong value1 = args[2];
target_ulong value2 = args[3];
target_ulong ret = H_P2;
if (resource == H_SET_MODE_ENDIAN) {
if (value1) {
ret = H_P3;
goto out;
}
if (value2) {
ret = H_P4;
goto out;
}
switch (mflags) {
case H_SET_MODE_ENDIAN_BIG:
CPU_FOREACH(cs) {
PowerPCCPU *cp = POWERPC_CPU(cs);
CPUPPCState *env = &cp->env;
env->spr[SPR_LPCR] &= ~LPCR_ILE;
}
ret = H_SUCCESS;
break;
case H_SET_MODE_ENDIAN_LITTLE:
CPU_FOREACH(cs) {
PowerPCCPU *cp = POWERPC_CPU(cs);
CPUPPCState *env = &cp->env;
env->spr[SPR_LPCR] |= LPCR_ILE;
}
ret = H_SUCCESS;
break;
default:
ret = H_UNSUPPORTED_FLAG;
}
}
out:
return ret;
}
| [
"static target_ulong FUNC_0(PowerPCCPU *cpu, sPAPREnvironment *spapr,\ntarget_ulong opcode, target_ulong *args)\n{",
"CPUState *cs;",
"target_ulong mflags = args[0];",
"target_ulong resource = args[1];",
"target_ulong value1 = args[2];",
"target_ulong value2 = args[3];",
"target_ulong ret = H_P2;",
"i... | [
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
1,
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
],
[
41
],
[
43,
45
],
[
47
... |
15,684 | static int xan_wc3_decode_frame(XanContext *s) {
int width = s->avctx->width;
int height = s->avctx->height;
int total_pixels = width * height;
unsigned char opcode;
unsigned char flag = 0;
int size = 0;
int motion_x, motion_y;
int x, y;
unsigned char *opcode_buffer = s->buffer1;
unsigned char *opcode_buffer_end = s->buffer1 + s->buffer1_size;
int opcode_buffer_size = s->buffer1_size;
const unsigned char *imagedata_buffer = s->buffer2;
/* pointers to segments inside the compressed chunk */
const unsigned char *huffman_segment;
const unsigned char *size_segment;
const unsigned char *vector_segment;
const unsigned char *imagedata_segment;
int huffman_offset, size_offset, vector_offset, imagedata_offset, imagedata_size;
if (s->size < 8)
return AVERROR_INVALIDDATA;
huffman_offset = AV_RL16(&s->buf[0]);
size_offset = AV_RL16(&s->buf[2]);
vector_offset = AV_RL16(&s->buf[4]);
imagedata_offset = AV_RL16(&s->buf[6]);
if (huffman_offset >= s->size ||
size_offset >= s->size ||
vector_offset >= s->size ||
imagedata_offset >= s->size)
return AVERROR_INVALIDDATA;
huffman_segment = s->buf + huffman_offset;
size_segment = s->buf + size_offset;
vector_segment = s->buf + vector_offset;
imagedata_segment = s->buf + imagedata_offset;
if (xan_huffman_decode(opcode_buffer, opcode_buffer_size,
huffman_segment, s->size - huffman_offset) < 0)
return AVERROR_INVALIDDATA;
if (imagedata_segment[0] == 2) {
xan_unpack(s->buffer2, &imagedata_segment[1], s->buffer2_size);
imagedata_size = s->buffer2_size;
} else {
imagedata_size = s->size - imagedata_offset - 1;
imagedata_buffer = &imagedata_segment[1];
}
/* use the decoded data segments to build the frame */
x = y = 0;
while (total_pixels && opcode_buffer < opcode_buffer_end) {
opcode = *opcode_buffer++;
size = 0;
switch (opcode) {
case 0:
flag ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
size = opcode;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
size += (opcode - 10);
break;
case 9:
case 19:
size = *size_segment++;
break;
case 10:
case 20:
size = AV_RB16(&size_segment[0]);
size_segment += 2;
break;
case 11:
case 21:
size = AV_RB24(size_segment);
size_segment += 3;
break;
}
if (size > total_pixels)
break;
if (opcode < 12) {
flag ^= 1;
if (flag) {
/* run of (size) pixels is unchanged from last frame */
xan_wc3_copy_pixel_run(s, x, y, size, 0, 0);
} else {
/* output a run of pixels from imagedata_buffer */
if (imagedata_size < size)
break;
xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size);
imagedata_buffer += size;
imagedata_size -= size;
}
} else {
/* run-based motion compensation from last frame */
motion_x = sign_extend(*vector_segment >> 4, 4);
motion_y = sign_extend(*vector_segment & 0xF, 4);
vector_segment++;
/* copy a run of pixels from the previous frame */
xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y);
flag = 0;
}
/* coordinate accounting */
total_pixels -= size;
y += (x + size) / width;
x = (x + size) % width;
}
return 0;
}
| true | FFmpeg | 3e0757c2a87c8cf3e452f67bca279001c64cedff | static int xan_wc3_decode_frame(XanContext *s) {
int width = s->avctx->width;
int height = s->avctx->height;
int total_pixels = width * height;
unsigned char opcode;
unsigned char flag = 0;
int size = 0;
int motion_x, motion_y;
int x, y;
unsigned char *opcode_buffer = s->buffer1;
unsigned char *opcode_buffer_end = s->buffer1 + s->buffer1_size;
int opcode_buffer_size = s->buffer1_size;
const unsigned char *imagedata_buffer = s->buffer2;
const unsigned char *huffman_segment;
const unsigned char *size_segment;
const unsigned char *vector_segment;
const unsigned char *imagedata_segment;
int huffman_offset, size_offset, vector_offset, imagedata_offset, imagedata_size;
if (s->size < 8)
return AVERROR_INVALIDDATA;
huffman_offset = AV_RL16(&s->buf[0]);
size_offset = AV_RL16(&s->buf[2]);
vector_offset = AV_RL16(&s->buf[4]);
imagedata_offset = AV_RL16(&s->buf[6]);
if (huffman_offset >= s->size ||
size_offset >= s->size ||
vector_offset >= s->size ||
imagedata_offset >= s->size)
return AVERROR_INVALIDDATA;
huffman_segment = s->buf + huffman_offset;
size_segment = s->buf + size_offset;
vector_segment = s->buf + vector_offset;
imagedata_segment = s->buf + imagedata_offset;
if (xan_huffman_decode(opcode_buffer, opcode_buffer_size,
huffman_segment, s->size - huffman_offset) < 0)
return AVERROR_INVALIDDATA;
if (imagedata_segment[0] == 2) {
xan_unpack(s->buffer2, &imagedata_segment[1], s->buffer2_size);
imagedata_size = s->buffer2_size;
} else {
imagedata_size = s->size - imagedata_offset - 1;
imagedata_buffer = &imagedata_segment[1];
}
x = y = 0;
while (total_pixels && opcode_buffer < opcode_buffer_end) {
opcode = *opcode_buffer++;
size = 0;
switch (opcode) {
case 0:
flag ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
size = opcode;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
size += (opcode - 10);
break;
case 9:
case 19:
size = *size_segment++;
break;
case 10:
case 20:
size = AV_RB16(&size_segment[0]);
size_segment += 2;
break;
case 11:
case 21:
size = AV_RB24(size_segment);
size_segment += 3;
break;
}
if (size > total_pixels)
break;
if (opcode < 12) {
flag ^= 1;
if (flag) {
xan_wc3_copy_pixel_run(s, x, y, size, 0, 0);
} else {
if (imagedata_size < size)
break;
xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size);
imagedata_buffer += size;
imagedata_size -= size;
}
} else {
motion_x = sign_extend(*vector_segment >> 4, 4);
motion_y = sign_extend(*vector_segment & 0xF, 4);
vector_segment++;
xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y);
flag = 0;
}
total_pixels -= size;
y += (x + size) / width;
x = (x + size) % width;
}
return 0;
}
| {
"code": [
" xan_unpack(s->buffer2, &imagedata_segment[1], s->buffer2_size);"
],
"line_no": [
95
]
} | static int FUNC_0(XanContext *VAR_0) {
int VAR_1 = VAR_0->avctx->VAR_1;
int VAR_2 = VAR_0->avctx->VAR_2;
int VAR_3 = VAR_1 * VAR_2;
unsigned char VAR_4;
unsigned char VAR_5 = 0;
int VAR_6 = 0;
int VAR_7, VAR_8;
int VAR_9, VAR_10;
unsigned char *VAR_11 = VAR_0->buffer1;
unsigned char *VAR_12 = VAR_0->buffer1 + VAR_0->buffer1_size;
int VAR_13 = VAR_0->buffer1_size;
const unsigned char *VAR_14 = VAR_0->buffer2;
const unsigned char *VAR_15;
const unsigned char *VAR_16;
const unsigned char *VAR_17;
const unsigned char *VAR_18;
int VAR_19, VAR_20, VAR_21, VAR_22, VAR_23;
if (VAR_0->VAR_6 < 8)
return AVERROR_INVALIDDATA;
VAR_19 = AV_RL16(&VAR_0->buf[0]);
VAR_20 = AV_RL16(&VAR_0->buf[2]);
VAR_21 = AV_RL16(&VAR_0->buf[4]);
VAR_22 = AV_RL16(&VAR_0->buf[6]);
if (VAR_19 >= VAR_0->VAR_6 ||
VAR_20 >= VAR_0->VAR_6 ||
VAR_21 >= VAR_0->VAR_6 ||
VAR_22 >= VAR_0->VAR_6)
return AVERROR_INVALIDDATA;
VAR_15 = VAR_0->buf + VAR_19;
VAR_16 = VAR_0->buf + VAR_20;
VAR_17 = VAR_0->buf + VAR_21;
VAR_18 = VAR_0->buf + VAR_22;
if (xan_huffman_decode(VAR_11, VAR_13,
VAR_15, VAR_0->VAR_6 - VAR_19) < 0)
return AVERROR_INVALIDDATA;
if (VAR_18[0] == 2) {
xan_unpack(VAR_0->buffer2, &VAR_18[1], VAR_0->buffer2_size);
VAR_23 = VAR_0->buffer2_size;
} else {
VAR_23 = VAR_0->VAR_6 - VAR_22 - 1;
VAR_14 = &VAR_18[1];
}
VAR_9 = VAR_10 = 0;
while (VAR_3 && VAR_11 < VAR_12) {
VAR_4 = *VAR_11++;
VAR_6 = 0;
switch (VAR_4) {
case 0:
VAR_5 ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
VAR_6 = VAR_4;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
VAR_6 += (VAR_4 - 10);
break;
case 9:
case 19:
VAR_6 = *VAR_16++;
break;
case 10:
case 20:
VAR_6 = AV_RB16(&VAR_16[0]);
VAR_16 += 2;
break;
case 11:
case 21:
VAR_6 = AV_RB24(VAR_16);
VAR_16 += 3;
break;
}
if (VAR_6 > VAR_3)
break;
if (VAR_4 < 12) {
VAR_5 ^= 1;
if (VAR_5) {
xan_wc3_copy_pixel_run(VAR_0, VAR_9, VAR_10, VAR_6, 0, 0);
} else {
if (VAR_23 < VAR_6)
break;
xan_wc3_output_pixel_run(VAR_0, VAR_14, VAR_9, VAR_10, VAR_6);
VAR_14 += VAR_6;
VAR_23 -= VAR_6;
}
} else {
VAR_7 = sign_extend(*VAR_17 >> 4, 4);
VAR_8 = sign_extend(*VAR_17 & 0xF, 4);
VAR_17++;
xan_wc3_copy_pixel_run(VAR_0, VAR_9, VAR_10, VAR_6, VAR_7, VAR_8);
VAR_5 = 0;
}
VAR_3 -= VAR_6;
VAR_10 += (VAR_9 + VAR_6) / VAR_1;
VAR_9 = (VAR_9 + VAR_6) % VAR_1;
}
return 0;
}
| [
"static int FUNC_0(XanContext *VAR_0) {",
"int VAR_1 = VAR_0->avctx->VAR_1;",
"int VAR_2 = VAR_0->avctx->VAR_2;",
"int VAR_3 = VAR_1 * VAR_2;",
"unsigned char VAR_4;",
"unsigned char VAR_5 = 0;",
"int VAR_6 = 0;",
"int VAR_7, VAR_8;",
"int VAR_9, VAR_10;",
"unsigned char *VAR_11 = VAR_0->buffer1;"... | [
0,
0,
0,
0,
0,
0,
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... | [
[
1
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47,
49
],
[
53... |
15,685 | uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr)
{
long tcg_temps[CPU_TEMP_BUF_NLONGS];
uintptr_t sp_value = (uintptr_t)(tcg_temps + CPU_TEMP_BUF_NLONGS);
uintptr_t next_tb = 0;
tci_reg[TCG_AREG0] = (tcg_target_ulong)env;
tci_reg[TCG_REG_CALL_STACK] = sp_value;
assert(tb_ptr);
for (;;) {
TCGOpcode opc = tb_ptr[0];
#if !defined(NDEBUG)
uint8_t op_size = tb_ptr[1];
uint8_t *old_code_ptr = tb_ptr;
#endif
tcg_target_ulong t0;
tcg_target_ulong t1;
tcg_target_ulong t2;
tcg_target_ulong label;
TCGCond condition;
target_ulong taddr;
#ifndef CONFIG_SOFTMMU
tcg_target_ulong host_addr;
#endif
uint8_t tmp8;
uint16_t tmp16;
uint32_t tmp32;
uint64_t tmp64;
#if TCG_TARGET_REG_BITS == 32
uint64_t v64;
#endif
#if defined(GETPC)
tci_tb_ptr = (uintptr_t)tb_ptr;
#endif
/* Skip opcode and size entry. */
tb_ptr += 2;
switch (opc) {
case INDEX_op_end:
case INDEX_op_nop:
break;
case INDEX_op_nop1:
case INDEX_op_nop2:
case INDEX_op_nop3:
case INDEX_op_nopn:
case INDEX_op_discard:
TODO();
break;
case INDEX_op_set_label:
TODO();
break;
case INDEX_op_call:
t0 = tci_read_ri(&tb_ptr);
#if TCG_TARGET_REG_BITS == 32
tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
tci_read_reg(TCG_REG_R1),
tci_read_reg(TCG_REG_R2),
tci_read_reg(TCG_REG_R3),
tci_read_reg(TCG_REG_R5),
tci_read_reg(TCG_REG_R6),
tci_read_reg(TCG_REG_R7),
tci_read_reg(TCG_REG_R8),
tci_read_reg(TCG_REG_R9),
tci_read_reg(TCG_REG_R10));
tci_write_reg(TCG_REG_R0, tmp64);
tci_write_reg(TCG_REG_R1, tmp64 >> 32);
#else
tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
tci_read_reg(TCG_REG_R1),
tci_read_reg(TCG_REG_R2),
tci_read_reg(TCG_REG_R3),
tci_read_reg(TCG_REG_R5));
tci_write_reg(TCG_REG_R0, tmp64);
#endif
break;
case INDEX_op_br:
label = tci_read_label(&tb_ptr);
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
case INDEX_op_setcond_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg32(t0, tci_compare32(t1, t2, condition));
break;
#if TCG_TARGET_REG_BITS == 32
case INDEX_op_setcond2_i32:
t0 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
v64 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg32(t0, tci_compare64(tmp64, v64, condition));
break;
#elif TCG_TARGET_REG_BITS == 64
case INDEX_op_setcond_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg64(t0, tci_compare64(t1, t2, condition));
break;
#endif
case INDEX_op_mov_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, t1);
break;
case INDEX_op_movi_i32:
t0 = *tb_ptr++;
t1 = tci_read_i32(&tb_ptr);
tci_write_reg32(t0, t1);
break;
/* Load/store operations (32 bit). */
case INDEX_op_ld8u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
break;
case INDEX_op_ld8s_i32:
case INDEX_op_ld16u_i32:
TODO();
break;
case INDEX_op_ld16s_i32:
TODO();
break;
case INDEX_op_ld_i32:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
break;
case INDEX_op_st8_i32:
t0 = tci_read_r8(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint8_t *)(t1 + t2) = t0;
break;
case INDEX_op_st16_i32:
t0 = tci_read_r16(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint16_t *)(t1 + t2) = t0;
break;
case INDEX_op_st_i32:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
assert(t1 != sp_value || (int32_t)t2 < 0);
*(uint32_t *)(t1 + t2) = t0;
break;
/* Arithmetic operations (32 bit). */
case INDEX_op_add_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 + t2);
break;
case INDEX_op_sub_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 - t2);
break;
case INDEX_op_mul_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 * t2);
break;
#if TCG_TARGET_HAS_div_i32
case INDEX_op_div_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, (int32_t)t1 / (int32_t)t2);
break;
case INDEX_op_divu_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 / t2);
break;
case INDEX_op_rem_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, (int32_t)t1 % (int32_t)t2);
break;
case INDEX_op_remu_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 % t2);
break;
#elif TCG_TARGET_HAS_div2_i32
case INDEX_op_div2_i32:
case INDEX_op_divu2_i32:
TODO();
break;
#endif
case INDEX_op_and_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 & t2);
break;
case INDEX_op_or_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 | t2);
break;
case INDEX_op_xor_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 ^ t2);
break;
/* Shift/rotate operations (32 bit). */
case INDEX_op_shl_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 << t2);
break;
case INDEX_op_shr_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 >> t2);
break;
case INDEX_op_sar_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, ((int32_t)t1 >> t2));
break;
#if TCG_TARGET_HAS_rot_i32
case INDEX_op_rotl_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, rol32(t1, t2));
break;
case INDEX_op_rotr_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, ror32(t1, t2));
break;
#endif
#if TCG_TARGET_HAS_deposit_i32
case INDEX_op_deposit_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
t2 = tci_read_r32(&tb_ptr);
tmp16 = *tb_ptr++;
tmp8 = *tb_ptr++;
tmp32 = (((1 << tmp8) - 1) << tmp16);
tci_write_reg32(t0, (t1 & ~tmp32) | ((t2 << tmp16) & tmp32));
break;
#endif
case INDEX_op_brcond_i32:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_ri32(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare32(t0, t1, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
#if TCG_TARGET_REG_BITS == 32
case INDEX_op_add2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
tmp64 += tci_read_r64(&tb_ptr);
tci_write_reg64(t1, t0, tmp64);
break;
case INDEX_op_sub2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
tmp64 -= tci_read_r64(&tb_ptr);
tci_write_reg64(t1, t0, tmp64);
break;
case INDEX_op_brcond2_i32:
tmp64 = tci_read_r64(&tb_ptr);
v64 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare64(tmp64, v64, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
case INDEX_op_mulu2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
t2 = tci_read_r32(&tb_ptr);
tmp64 = tci_read_r32(&tb_ptr);
tci_write_reg64(t1, t0, t2 * tmp64);
break;
#endif /* TCG_TARGET_REG_BITS == 32 */
#if TCG_TARGET_HAS_ext8s_i32
case INDEX_op_ext8s_i32:
t0 = *tb_ptr++;
t1 = tci_read_r8s(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16s_i32
case INDEX_op_ext16s_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16s(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext8u_i32
case INDEX_op_ext8u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r8(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16u_i32
case INDEX_op_ext16u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_bswap16_i32
case INDEX_op_bswap16_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg32(t0, bswap16(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap32_i32
case INDEX_op_bswap32_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, bswap32(t1));
break;
#endif
#if TCG_TARGET_HAS_not_i32
case INDEX_op_not_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, ~t1);
break;
#endif
#if TCG_TARGET_HAS_neg_i32
case INDEX_op_neg_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, -t1);
break;
#endif
#if TCG_TARGET_REG_BITS == 64
case INDEX_op_mov_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, t1);
break;
case INDEX_op_movi_i64:
t0 = *tb_ptr++;
t1 = tci_read_i64(&tb_ptr);
tci_write_reg64(t0, t1);
break;
/* Load/store operations (64 bit). */
case INDEX_op_ld8u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
break;
case INDEX_op_ld8s_i64:
case INDEX_op_ld16u_i64:
case INDEX_op_ld16s_i64:
TODO();
break;
case INDEX_op_ld32u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
break;
case INDEX_op_ld32s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32s(t0, *(int32_t *)(t1 + t2));
break;
case INDEX_op_ld_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg64(t0, *(uint64_t *)(t1 + t2));
break;
case INDEX_op_st8_i64:
t0 = tci_read_r8(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint8_t *)(t1 + t2) = t0;
break;
case INDEX_op_st16_i64:
t0 = tci_read_r16(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint16_t *)(t1 + t2) = t0;
break;
case INDEX_op_st32_i64:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint32_t *)(t1 + t2) = t0;
break;
case INDEX_op_st_i64:
t0 = tci_read_r64(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
assert(t1 != sp_value || (int32_t)t2 < 0);
*(uint64_t *)(t1 + t2) = t0;
break;
/* Arithmetic operations (64 bit). */
case INDEX_op_add_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 + t2);
break;
case INDEX_op_sub_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 - t2);
break;
case INDEX_op_mul_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 * t2);
break;
#if TCG_TARGET_HAS_div_i64
case INDEX_op_div_i64:
case INDEX_op_divu_i64:
case INDEX_op_rem_i64:
case INDEX_op_remu_i64:
TODO();
break;
#elif TCG_TARGET_HAS_div2_i64
case INDEX_op_div2_i64:
case INDEX_op_divu2_i64:
TODO();
break;
#endif
case INDEX_op_and_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 & t2);
break;
case INDEX_op_or_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 | t2);
break;
case INDEX_op_xor_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 ^ t2);
break;
/* Shift/rotate operations (64 bit). */
case INDEX_op_shl_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 << t2);
break;
case INDEX_op_shr_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 >> t2);
break;
case INDEX_op_sar_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, ((int64_t)t1 >> t2));
break;
#if TCG_TARGET_HAS_rot_i64
case INDEX_op_rotl_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, rol64(t1, t2));
break;
case INDEX_op_rotr_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, ror64(t1, t2));
break;
#endif
#if TCG_TARGET_HAS_deposit_i64
case INDEX_op_deposit_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
t2 = tci_read_r64(&tb_ptr);
tmp16 = *tb_ptr++;
tmp8 = *tb_ptr++;
tmp64 = (((1ULL << tmp8) - 1) << tmp16);
tci_write_reg64(t0, (t1 & ~tmp64) | ((t2 << tmp16) & tmp64));
break;
#endif
case INDEX_op_brcond_i64:
t0 = tci_read_r64(&tb_ptr);
t1 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare64(t0, t1, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
#if TCG_TARGET_HAS_ext8u_i64
case INDEX_op_ext8u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r8(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext8s_i64
case INDEX_op_ext8s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r8s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16s_i64
case INDEX_op_ext16s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r16s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16u_i64
case INDEX_op_ext16u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext32s_i64
case INDEX_op_ext32s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext32u_i64
case INDEX_op_ext32u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_bswap16_i64
case INDEX_op_bswap16_i64:
TODO();
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg64(t0, bswap16(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap32_i64
case INDEX_op_bswap32_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg64(t0, bswap32(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap64_i64
case INDEX_op_bswap64_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, bswap64(t1));
break;
#endif
#if TCG_TARGET_HAS_not_i64
case INDEX_op_not_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, ~t1);
break;
#endif
#if TCG_TARGET_HAS_neg_i64
case INDEX_op_neg_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, -t1);
break;
#endif
#endif /* TCG_TARGET_REG_BITS == 64 */
/* QEMU specific operations. */
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
case INDEX_op_debug_insn_start:
TODO();
break;
#else
case INDEX_op_debug_insn_start:
TODO();
break;
#endif
case INDEX_op_exit_tb:
next_tb = *(uint64_t *)tb_ptr;
goto exit;
break;
case INDEX_op_goto_tb:
t0 = tci_read_i32(&tb_ptr);
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr += (int32_t)t0;
continue;
case INDEX_op_qemu_ld8u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
#endif
tci_write_reg8(t0, tmp8);
break;
case INDEX_op_qemu_ld8s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
#endif
tci_write_reg8s(t0, tmp8);
break;
case INDEX_op_qemu_ld16u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg16(t0, tmp16);
break;
case INDEX_op_qemu_ld16s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg16s(t0, tmp16);
break;
#if TCG_TARGET_REG_BITS == 64
case INDEX_op_qemu_ld32u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32(t0, tmp32);
break;
case INDEX_op_qemu_ld32s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32s(t0, tmp32);
break;
#endif /* TCG_TARGET_REG_BITS == 64 */
case INDEX_op_qemu_ld32:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32(t0, tmp32);
break;
case INDEX_op_qemu_ld64:
t0 = *tb_ptr++;
#if TCG_TARGET_REG_BITS == 32
t1 = *tb_ptr++;
#endif
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp64 = helper_ldq_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp64 = tswap64(*(uint64_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg(t0, tmp64);
#if TCG_TARGET_REG_BITS == 32
tci_write_reg(t1, tmp64 >> 32);
#endif
break;
case INDEX_op_qemu_st8:
t0 = tci_read_r8(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stb_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint8_t *)(host_addr + GUEST_BASE) = t0;
#endif
break;
case INDEX_op_qemu_st16:
t0 = tci_read_r16(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stw_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint16_t *)(host_addr + GUEST_BASE) = tswap16(t0);
#endif
break;
case INDEX_op_qemu_st32:
t0 = tci_read_r32(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stl_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint32_t *)(host_addr + GUEST_BASE) = tswap32(t0);
#endif
break;
case INDEX_op_qemu_st64:
tmp64 = tci_read_r64(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stq_mmu(env, taddr, tmp64, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint64_t *)(host_addr + GUEST_BASE) = tswap64(tmp64);
#endif
break;
default:
TODO();
break;
}
assert(tb_ptr == old_code_ptr + op_size);
}
exit:
return next_tb;
}
| true | qemu | 1976cccec8a9965ff3fd6f026783a04f6b4959fd | uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr)
{
long tcg_temps[CPU_TEMP_BUF_NLONGS];
uintptr_t sp_value = (uintptr_t)(tcg_temps + CPU_TEMP_BUF_NLONGS);
uintptr_t next_tb = 0;
tci_reg[TCG_AREG0] = (tcg_target_ulong)env;
tci_reg[TCG_REG_CALL_STACK] = sp_value;
assert(tb_ptr);
for (;;) {
TCGOpcode opc = tb_ptr[0];
#if !defined(NDEBUG)
uint8_t op_size = tb_ptr[1];
uint8_t *old_code_ptr = tb_ptr;
#endif
tcg_target_ulong t0;
tcg_target_ulong t1;
tcg_target_ulong t2;
tcg_target_ulong label;
TCGCond condition;
target_ulong taddr;
#ifndef CONFIG_SOFTMMU
tcg_target_ulong host_addr;
#endif
uint8_t tmp8;
uint16_t tmp16;
uint32_t tmp32;
uint64_t tmp64;
#if TCG_TARGET_REG_BITS == 32
uint64_t v64;
#endif
#if defined(GETPC)
tci_tb_ptr = (uintptr_t)tb_ptr;
#endif
tb_ptr += 2;
switch (opc) {
case INDEX_op_end:
case INDEX_op_nop:
break;
case INDEX_op_nop1:
case INDEX_op_nop2:
case INDEX_op_nop3:
case INDEX_op_nopn:
case INDEX_op_discard:
TODO();
break;
case INDEX_op_set_label:
TODO();
break;
case INDEX_op_call:
t0 = tci_read_ri(&tb_ptr);
#if TCG_TARGET_REG_BITS == 32
tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
tci_read_reg(TCG_REG_R1),
tci_read_reg(TCG_REG_R2),
tci_read_reg(TCG_REG_R3),
tci_read_reg(TCG_REG_R5),
tci_read_reg(TCG_REG_R6),
tci_read_reg(TCG_REG_R7),
tci_read_reg(TCG_REG_R8),
tci_read_reg(TCG_REG_R9),
tci_read_reg(TCG_REG_R10));
tci_write_reg(TCG_REG_R0, tmp64);
tci_write_reg(TCG_REG_R1, tmp64 >> 32);
#else
tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
tci_read_reg(TCG_REG_R1),
tci_read_reg(TCG_REG_R2),
tci_read_reg(TCG_REG_R3),
tci_read_reg(TCG_REG_R5));
tci_write_reg(TCG_REG_R0, tmp64);
#endif
break;
case INDEX_op_br:
label = tci_read_label(&tb_ptr);
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
case INDEX_op_setcond_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg32(t0, tci_compare32(t1, t2, condition));
break;
#if TCG_TARGET_REG_BITS == 32
case INDEX_op_setcond2_i32:
t0 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
v64 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg32(t0, tci_compare64(tmp64, v64, condition));
break;
#elif TCG_TARGET_REG_BITS == 64
case INDEX_op_setcond_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg64(t0, tci_compare64(t1, t2, condition));
break;
#endif
case INDEX_op_mov_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, t1);
break;
case INDEX_op_movi_i32:
t0 = *tb_ptr++;
t1 = tci_read_i32(&tb_ptr);
tci_write_reg32(t0, t1);
break;
case INDEX_op_ld8u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
break;
case INDEX_op_ld8s_i32:
case INDEX_op_ld16u_i32:
TODO();
break;
case INDEX_op_ld16s_i32:
TODO();
break;
case INDEX_op_ld_i32:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
break;
case INDEX_op_st8_i32:
t0 = tci_read_r8(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint8_t *)(t1 + t2) = t0;
break;
case INDEX_op_st16_i32:
t0 = tci_read_r16(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint16_t *)(t1 + t2) = t0;
break;
case INDEX_op_st_i32:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
assert(t1 != sp_value || (int32_t)t2 < 0);
*(uint32_t *)(t1 + t2) = t0;
break;
case INDEX_op_add_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 + t2);
break;
case INDEX_op_sub_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 - t2);
break;
case INDEX_op_mul_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 * t2);
break;
#if TCG_TARGET_HAS_div_i32
case INDEX_op_div_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, (int32_t)t1 / (int32_t)t2);
break;
case INDEX_op_divu_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 / t2);
break;
case INDEX_op_rem_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, (int32_t)t1 % (int32_t)t2);
break;
case INDEX_op_remu_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 % t2);
break;
#elif TCG_TARGET_HAS_div2_i32
case INDEX_op_div2_i32:
case INDEX_op_divu2_i32:
TODO();
break;
#endif
case INDEX_op_and_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 & t2);
break;
case INDEX_op_or_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 | t2);
break;
case INDEX_op_xor_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 ^ t2);
break;
case INDEX_op_shl_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 << t2);
break;
case INDEX_op_shr_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 >> t2);
break;
case INDEX_op_sar_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, ((int32_t)t1 >> t2));
break;
#if TCG_TARGET_HAS_rot_i32
case INDEX_op_rotl_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, rol32(t1, t2));
break;
case INDEX_op_rotr_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, ror32(t1, t2));
break;
#endif
#if TCG_TARGET_HAS_deposit_i32
case INDEX_op_deposit_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
t2 = tci_read_r32(&tb_ptr);
tmp16 = *tb_ptr++;
tmp8 = *tb_ptr++;
tmp32 = (((1 << tmp8) - 1) << tmp16);
tci_write_reg32(t0, (t1 & ~tmp32) | ((t2 << tmp16) & tmp32));
break;
#endif
case INDEX_op_brcond_i32:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_ri32(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare32(t0, t1, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
#if TCG_TARGET_REG_BITS == 32
case INDEX_op_add2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
tmp64 += tci_read_r64(&tb_ptr);
tci_write_reg64(t1, t0, tmp64);
break;
case INDEX_op_sub2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
tmp64 -= tci_read_r64(&tb_ptr);
tci_write_reg64(t1, t0, tmp64);
break;
case INDEX_op_brcond2_i32:
tmp64 = tci_read_r64(&tb_ptr);
v64 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare64(tmp64, v64, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
case INDEX_op_mulu2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
t2 = tci_read_r32(&tb_ptr);
tmp64 = tci_read_r32(&tb_ptr);
tci_write_reg64(t1, t0, t2 * tmp64);
break;
#endif
#if TCG_TARGET_HAS_ext8s_i32
case INDEX_op_ext8s_i32:
t0 = *tb_ptr++;
t1 = tci_read_r8s(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16s_i32
case INDEX_op_ext16s_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16s(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext8u_i32
case INDEX_op_ext8u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r8(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16u_i32
case INDEX_op_ext16u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_bswap16_i32
case INDEX_op_bswap16_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg32(t0, bswap16(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap32_i32
case INDEX_op_bswap32_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, bswap32(t1));
break;
#endif
#if TCG_TARGET_HAS_not_i32
case INDEX_op_not_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, ~t1);
break;
#endif
#if TCG_TARGET_HAS_neg_i32
case INDEX_op_neg_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, -t1);
break;
#endif
#if TCG_TARGET_REG_BITS == 64
case INDEX_op_mov_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, t1);
break;
case INDEX_op_movi_i64:
t0 = *tb_ptr++;
t1 = tci_read_i64(&tb_ptr);
tci_write_reg64(t0, t1);
break;
case INDEX_op_ld8u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
break;
case INDEX_op_ld8s_i64:
case INDEX_op_ld16u_i64:
case INDEX_op_ld16s_i64:
TODO();
break;
case INDEX_op_ld32u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
break;
case INDEX_op_ld32s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32s(t0, *(int32_t *)(t1 + t2));
break;
case INDEX_op_ld_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg64(t0, *(uint64_t *)(t1 + t2));
break;
case INDEX_op_st8_i64:
t0 = tci_read_r8(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint8_t *)(t1 + t2) = t0;
break;
case INDEX_op_st16_i64:
t0 = tci_read_r16(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint16_t *)(t1 + t2) = t0;
break;
case INDEX_op_st32_i64:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint32_t *)(t1 + t2) = t0;
break;
case INDEX_op_st_i64:
t0 = tci_read_r64(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
assert(t1 != sp_value || (int32_t)t2 < 0);
*(uint64_t *)(t1 + t2) = t0;
break;
case INDEX_op_add_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 + t2);
break;
case INDEX_op_sub_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 - t2);
break;
case INDEX_op_mul_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 * t2);
break;
#if TCG_TARGET_HAS_div_i64
case INDEX_op_div_i64:
case INDEX_op_divu_i64:
case INDEX_op_rem_i64:
case INDEX_op_remu_i64:
TODO();
break;
#elif TCG_TARGET_HAS_div2_i64
case INDEX_op_div2_i64:
case INDEX_op_divu2_i64:
TODO();
break;
#endif
case INDEX_op_and_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 & t2);
break;
case INDEX_op_or_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 | t2);
break;
case INDEX_op_xor_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 ^ t2);
break;
case INDEX_op_shl_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 << t2);
break;
case INDEX_op_shr_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 >> t2);
break;
case INDEX_op_sar_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, ((int64_t)t1 >> t2));
break;
#if TCG_TARGET_HAS_rot_i64
case INDEX_op_rotl_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, rol64(t1, t2));
break;
case INDEX_op_rotr_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, ror64(t1, t2));
break;
#endif
#if TCG_TARGET_HAS_deposit_i64
case INDEX_op_deposit_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
t2 = tci_read_r64(&tb_ptr);
tmp16 = *tb_ptr++;
tmp8 = *tb_ptr++;
tmp64 = (((1ULL << tmp8) - 1) << tmp16);
tci_write_reg64(t0, (t1 & ~tmp64) | ((t2 << tmp16) & tmp64));
break;
#endif
case INDEX_op_brcond_i64:
t0 = tci_read_r64(&tb_ptr);
t1 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare64(t0, t1, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
#if TCG_TARGET_HAS_ext8u_i64
case INDEX_op_ext8u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r8(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext8s_i64
case INDEX_op_ext8s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r8s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16s_i64
case INDEX_op_ext16s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r16s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16u_i64
case INDEX_op_ext16u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext32s_i64
case INDEX_op_ext32s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext32u_i64
case INDEX_op_ext32u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_bswap16_i64
case INDEX_op_bswap16_i64:
TODO();
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg64(t0, bswap16(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap32_i64
case INDEX_op_bswap32_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg64(t0, bswap32(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap64_i64
case INDEX_op_bswap64_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, bswap64(t1));
break;
#endif
#if TCG_TARGET_HAS_not_i64
case INDEX_op_not_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, ~t1);
break;
#endif
#if TCG_TARGET_HAS_neg_i64
case INDEX_op_neg_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, -t1);
break;
#endif
#endif
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
case INDEX_op_debug_insn_start:
TODO();
break;
#else
case INDEX_op_debug_insn_start:
TODO();
break;
#endif
case INDEX_op_exit_tb:
next_tb = *(uint64_t *)tb_ptr;
goto exit;
break;
case INDEX_op_goto_tb:
t0 = tci_read_i32(&tb_ptr);
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr += (int32_t)t0;
continue;
case INDEX_op_qemu_ld8u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
#endif
tci_write_reg8(t0, tmp8);
break;
case INDEX_op_qemu_ld8s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
#endif
tci_write_reg8s(t0, tmp8);
break;
case INDEX_op_qemu_ld16u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg16(t0, tmp16);
break;
case INDEX_op_qemu_ld16s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg16s(t0, tmp16);
break;
#if TCG_TARGET_REG_BITS == 64
case INDEX_op_qemu_ld32u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32(t0, tmp32);
break;
case INDEX_op_qemu_ld32s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32s(t0, tmp32);
break;
#endif
case INDEX_op_qemu_ld32:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32(t0, tmp32);
break;
case INDEX_op_qemu_ld64:
t0 = *tb_ptr++;
#if TCG_TARGET_REG_BITS == 32
t1 = *tb_ptr++;
#endif
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp64 = helper_ldq_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp64 = tswap64(*(uint64_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg(t0, tmp64);
#if TCG_TARGET_REG_BITS == 32
tci_write_reg(t1, tmp64 >> 32);
#endif
break;
case INDEX_op_qemu_st8:
t0 = tci_read_r8(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stb_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint8_t *)(host_addr + GUEST_BASE) = t0;
#endif
break;
case INDEX_op_qemu_st16:
t0 = tci_read_r16(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stw_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint16_t *)(host_addr + GUEST_BASE) = tswap16(t0);
#endif
break;
case INDEX_op_qemu_st32:
t0 = tci_read_r32(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stl_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint32_t *)(host_addr + GUEST_BASE) = tswap32(t0);
#endif
break;
case INDEX_op_qemu_st64:
tmp64 = tci_read_r64(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stq_mmu(env, taddr, tmp64, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint64_t *)(host_addr + GUEST_BASE) = tswap64(tmp64);
#endif
break;
default:
TODO();
break;
}
assert(tb_ptr == old_code_ptr + op_size);
}
exit:
return next_tb;
}
| {
"code": [
" tci_write_reg32(t0, t1 << t2);",
" tci_write_reg32(t0, t1 >> t2);",
" tci_write_reg32(t0, ((int32_t)t1 >> t2));",
" tci_write_reg32(t0, rol32(t1, t2));",
" tci_write_reg32(t0, ror32(t1, t2));",
" tci_write_reg64(t0, t1 << t2);",
" tci_write_reg64(t0, t1 >> t2);",
" tci_write_reg64(t0, ((int64_t)t1 >> t2));",
" tci_write_reg64(t0, rol64(t1, t2));",
" tci_write_reg64(t0, ror64(t1, t2));"
],
"line_no": [
471,
483,
495,
509,
521,
1005,
1017,
1029,
1043,
1055
]
} | uintptr_t FUNC_0(CPUArchState *env, uint8_t *tb_ptr)
{
long VAR_0[CPU_TEMP_BUF_NLONGS];
uintptr_t sp_value = (uintptr_t)(VAR_0 + CPU_TEMP_BUF_NLONGS);
uintptr_t next_tb = 0;
tci_reg[TCG_AREG0] = (tcg_target_ulong)env;
tci_reg[TCG_REG_CALL_STACK] = sp_value;
assert(tb_ptr);
for (;;) {
TCGOpcode opc = tb_ptr[0];
#if !defined(NDEBUG)
uint8_t op_size = tb_ptr[1];
uint8_t *old_code_ptr = tb_ptr;
#endif
tcg_target_ulong t0;
tcg_target_ulong t1;
tcg_target_ulong t2;
tcg_target_ulong label;
TCGCond condition;
target_ulong taddr;
#ifndef CONFIG_SOFTMMU
tcg_target_ulong host_addr;
#endif
uint8_t tmp8;
uint16_t tmp16;
uint32_t tmp32;
uint64_t tmp64;
#if TCG_TARGET_REG_BITS == 32
uint64_t v64;
#endif
#if defined(GETPC)
tci_tb_ptr = (uintptr_t)tb_ptr;
#endif
tb_ptr += 2;
switch (opc) {
case INDEX_op_end:
case INDEX_op_nop:
break;
case INDEX_op_nop1:
case INDEX_op_nop2:
case INDEX_op_nop3:
case INDEX_op_nopn:
case INDEX_op_discard:
TODO();
break;
case INDEX_op_set_label:
TODO();
break;
case INDEX_op_call:
t0 = tci_read_ri(&tb_ptr);
#if TCG_TARGET_REG_BITS == 32
tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
tci_read_reg(TCG_REG_R1),
tci_read_reg(TCG_REG_R2),
tci_read_reg(TCG_REG_R3),
tci_read_reg(TCG_REG_R5),
tci_read_reg(TCG_REG_R6),
tci_read_reg(TCG_REG_R7),
tci_read_reg(TCG_REG_R8),
tci_read_reg(TCG_REG_R9),
tci_read_reg(TCG_REG_R10));
tci_write_reg(TCG_REG_R0, tmp64);
tci_write_reg(TCG_REG_R1, tmp64 >> 32);
#else
tmp64 = ((helper_function)t0)(tci_read_reg(TCG_REG_R0),
tci_read_reg(TCG_REG_R1),
tci_read_reg(TCG_REG_R2),
tci_read_reg(TCG_REG_R3),
tci_read_reg(TCG_REG_R5));
tci_write_reg(TCG_REG_R0, tmp64);
#endif
break;
case INDEX_op_br:
label = tci_read_label(&tb_ptr);
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
case INDEX_op_setcond_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg32(t0, tci_compare32(t1, t2, condition));
break;
#if TCG_TARGET_REG_BITS == 32
case INDEX_op_setcond2_i32:
t0 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
v64 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg32(t0, tci_compare64(tmp64, v64, condition));
break;
#elif TCG_TARGET_REG_BITS == 64
case INDEX_op_setcond_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
tci_write_reg64(t0, tci_compare64(t1, t2, condition));
break;
#endif
case INDEX_op_mov_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, t1);
break;
case INDEX_op_movi_i32:
t0 = *tb_ptr++;
t1 = tci_read_i32(&tb_ptr);
tci_write_reg32(t0, t1);
break;
case INDEX_op_ld8u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
break;
case INDEX_op_ld8s_i32:
case INDEX_op_ld16u_i32:
TODO();
break;
case INDEX_op_ld16s_i32:
TODO();
break;
case INDEX_op_ld_i32:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
break;
case INDEX_op_st8_i32:
t0 = tci_read_r8(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint8_t *)(t1 + t2) = t0;
break;
case INDEX_op_st16_i32:
t0 = tci_read_r16(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint16_t *)(t1 + t2) = t0;
break;
case INDEX_op_st_i32:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
assert(t1 != sp_value || (int32_t)t2 < 0);
*(uint32_t *)(t1 + t2) = t0;
break;
case INDEX_op_add_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 + t2);
break;
case INDEX_op_sub_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 - t2);
break;
case INDEX_op_mul_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 * t2);
break;
#if TCG_TARGET_HAS_div_i32
case INDEX_op_div_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, (int32_t)t1 / (int32_t)t2);
break;
case INDEX_op_divu_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 / t2);
break;
case INDEX_op_rem_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, (int32_t)t1 % (int32_t)t2);
break;
case INDEX_op_remu_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 % t2);
break;
#elif TCG_TARGET_HAS_div2_i32
case INDEX_op_div2_i32:
case INDEX_op_divu2_i32:
TODO();
break;
#endif
case INDEX_op_and_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 & t2);
break;
case INDEX_op_or_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 | t2);
break;
case INDEX_op_xor_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 ^ t2);
break;
case INDEX_op_shl_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 << t2);
break;
case INDEX_op_shr_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, t1 >> t2);
break;
case INDEX_op_sar_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, ((int32_t)t1 >> t2));
break;
#if TCG_TARGET_HAS_rot_i32
case INDEX_op_rotl_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, rol32(t1, t2));
break;
case INDEX_op_rotr_i32:
t0 = *tb_ptr++;
t1 = tci_read_ri32(&tb_ptr);
t2 = tci_read_ri32(&tb_ptr);
tci_write_reg32(t0, ror32(t1, t2));
break;
#endif
#if TCG_TARGET_HAS_deposit_i32
case INDEX_op_deposit_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
t2 = tci_read_r32(&tb_ptr);
tmp16 = *tb_ptr++;
tmp8 = *tb_ptr++;
tmp32 = (((1 << tmp8) - 1) << tmp16);
tci_write_reg32(t0, (t1 & ~tmp32) | ((t2 << tmp16) & tmp32));
break;
#endif
case INDEX_op_brcond_i32:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_ri32(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare32(t0, t1, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
#if TCG_TARGET_REG_BITS == 32
case INDEX_op_add2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
tmp64 += tci_read_r64(&tb_ptr);
tci_write_reg64(t1, t0, tmp64);
break;
case INDEX_op_sub2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
tmp64 = tci_read_r64(&tb_ptr);
tmp64 -= tci_read_r64(&tb_ptr);
tci_write_reg64(t1, t0, tmp64);
break;
case INDEX_op_brcond2_i32:
tmp64 = tci_read_r64(&tb_ptr);
v64 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare64(tmp64, v64, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
case INDEX_op_mulu2_i32:
t0 = *tb_ptr++;
t1 = *tb_ptr++;
t2 = tci_read_r32(&tb_ptr);
tmp64 = tci_read_r32(&tb_ptr);
tci_write_reg64(t1, t0, t2 * tmp64);
break;
#endif
#if TCG_TARGET_HAS_ext8s_i32
case INDEX_op_ext8s_i32:
t0 = *tb_ptr++;
t1 = tci_read_r8s(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16s_i32
case INDEX_op_ext16s_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16s(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext8u_i32
case INDEX_op_ext8u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r8(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16u_i32
case INDEX_op_ext16u_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg32(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_bswap16_i32
case INDEX_op_bswap16_i32:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg32(t0, bswap16(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap32_i32
case INDEX_op_bswap32_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, bswap32(t1));
break;
#endif
#if TCG_TARGET_HAS_not_i32
case INDEX_op_not_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, ~t1);
break;
#endif
#if TCG_TARGET_HAS_neg_i32
case INDEX_op_neg_i32:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg32(t0, -t1);
break;
#endif
#if TCG_TARGET_REG_BITS == 64
case INDEX_op_mov_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, t1);
break;
case INDEX_op_movi_i64:
t0 = *tb_ptr++;
t1 = tci_read_i64(&tb_ptr);
tci_write_reg64(t0, t1);
break;
case INDEX_op_ld8u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg8(t0, *(uint8_t *)(t1 + t2));
break;
case INDEX_op_ld8s_i64:
case INDEX_op_ld16u_i64:
case INDEX_op_ld16s_i64:
TODO();
break;
case INDEX_op_ld32u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32(t0, *(uint32_t *)(t1 + t2));
break;
case INDEX_op_ld32s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg32s(t0, *(int32_t *)(t1 + t2));
break;
case INDEX_op_ld_i64:
t0 = *tb_ptr++;
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
tci_write_reg64(t0, *(uint64_t *)(t1 + t2));
break;
case INDEX_op_st8_i64:
t0 = tci_read_r8(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint8_t *)(t1 + t2) = t0;
break;
case INDEX_op_st16_i64:
t0 = tci_read_r16(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint16_t *)(t1 + t2) = t0;
break;
case INDEX_op_st32_i64:
t0 = tci_read_r32(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
*(uint32_t *)(t1 + t2) = t0;
break;
case INDEX_op_st_i64:
t0 = tci_read_r64(&tb_ptr);
t1 = tci_read_r(&tb_ptr);
t2 = tci_read_s32(&tb_ptr);
assert(t1 != sp_value || (int32_t)t2 < 0);
*(uint64_t *)(t1 + t2) = t0;
break;
case INDEX_op_add_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 + t2);
break;
case INDEX_op_sub_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 - t2);
break;
case INDEX_op_mul_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 * t2);
break;
#if TCG_TARGET_HAS_div_i64
case INDEX_op_div_i64:
case INDEX_op_divu_i64:
case INDEX_op_rem_i64:
case INDEX_op_remu_i64:
TODO();
break;
#elif TCG_TARGET_HAS_div2_i64
case INDEX_op_div2_i64:
case INDEX_op_divu2_i64:
TODO();
break;
#endif
case INDEX_op_and_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 & t2);
break;
case INDEX_op_or_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 | t2);
break;
case INDEX_op_xor_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 ^ t2);
break;
case INDEX_op_shl_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 << t2);
break;
case INDEX_op_shr_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, t1 >> t2);
break;
case INDEX_op_sar_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, ((int64_t)t1 >> t2));
break;
#if TCG_TARGET_HAS_rot_i64
case INDEX_op_rotl_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, rol64(t1, t2));
break;
case INDEX_op_rotr_i64:
t0 = *tb_ptr++;
t1 = tci_read_ri64(&tb_ptr);
t2 = tci_read_ri64(&tb_ptr);
tci_write_reg64(t0, ror64(t1, t2));
break;
#endif
#if TCG_TARGET_HAS_deposit_i64
case INDEX_op_deposit_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
t2 = tci_read_r64(&tb_ptr);
tmp16 = *tb_ptr++;
tmp8 = *tb_ptr++;
tmp64 = (((1ULL << tmp8) - 1) << tmp16);
tci_write_reg64(t0, (t1 & ~tmp64) | ((t2 << tmp16) & tmp64));
break;
#endif
case INDEX_op_brcond_i64:
t0 = tci_read_r64(&tb_ptr);
t1 = tci_read_ri64(&tb_ptr);
condition = *tb_ptr++;
label = tci_read_label(&tb_ptr);
if (tci_compare64(t0, t1, condition)) {
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr = (uint8_t *)label;
continue;
}
break;
#if TCG_TARGET_HAS_ext8u_i64
case INDEX_op_ext8u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r8(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext8s_i64
case INDEX_op_ext8s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r8s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16s_i64
case INDEX_op_ext16s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r16s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext16u_i64
case INDEX_op_ext16u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext32s_i64
case INDEX_op_ext32s_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32s(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_ext32u_i64
case INDEX_op_ext32u_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg64(t0, t1);
break;
#endif
#if TCG_TARGET_HAS_bswap16_i64
case INDEX_op_bswap16_i64:
TODO();
t0 = *tb_ptr++;
t1 = tci_read_r16(&tb_ptr);
tci_write_reg64(t0, bswap16(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap32_i64
case INDEX_op_bswap32_i64:
t0 = *tb_ptr++;
t1 = tci_read_r32(&tb_ptr);
tci_write_reg64(t0, bswap32(t1));
break;
#endif
#if TCG_TARGET_HAS_bswap64_i64
case INDEX_op_bswap64_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, bswap64(t1));
break;
#endif
#if TCG_TARGET_HAS_not_i64
case INDEX_op_not_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, ~t1);
break;
#endif
#if TCG_TARGET_HAS_neg_i64
case INDEX_op_neg_i64:
t0 = *tb_ptr++;
t1 = tci_read_r64(&tb_ptr);
tci_write_reg64(t0, -t1);
break;
#endif
#endif
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
case INDEX_op_debug_insn_start:
TODO();
break;
#else
case INDEX_op_debug_insn_start:
TODO();
break;
#endif
case INDEX_op_exit_tb:
next_tb = *(uint64_t *)tb_ptr;
goto exit;
break;
case INDEX_op_goto_tb:
t0 = tci_read_i32(&tb_ptr);
assert(tb_ptr == old_code_ptr + op_size);
tb_ptr += (int32_t)t0;
continue;
case INDEX_op_qemu_ld8u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
#endif
tci_write_reg8(t0, tmp8);
break;
case INDEX_op_qemu_ld8s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp8 = helper_ldb_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp8 = *(uint8_t *)(host_addr + GUEST_BASE);
#endif
tci_write_reg8s(t0, tmp8);
break;
case INDEX_op_qemu_ld16u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg16(t0, tmp16);
break;
case INDEX_op_qemu_ld16s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp16 = helper_ldw_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp16 = tswap16(*(uint16_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg16s(t0, tmp16);
break;
#if TCG_TARGET_REG_BITS == 64
case INDEX_op_qemu_ld32u:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32(t0, tmp32);
break;
case INDEX_op_qemu_ld32s:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32s(t0, tmp32);
break;
#endif
case INDEX_op_qemu_ld32:
t0 = *tb_ptr++;
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp32 = helper_ldl_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp32 = tswap32(*(uint32_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg32(t0, tmp32);
break;
case INDEX_op_qemu_ld64:
t0 = *tb_ptr++;
#if TCG_TARGET_REG_BITS == 32
t1 = *tb_ptr++;
#endif
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
tmp64 = helper_ldq_mmu(env, taddr, tci_read_i(&tb_ptr));
#else
host_addr = (tcg_target_ulong)taddr;
tmp64 = tswap64(*(uint64_t *)(host_addr + GUEST_BASE));
#endif
tci_write_reg(t0, tmp64);
#if TCG_TARGET_REG_BITS == 32
tci_write_reg(t1, tmp64 >> 32);
#endif
break;
case INDEX_op_qemu_st8:
t0 = tci_read_r8(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stb_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint8_t *)(host_addr + GUEST_BASE) = t0;
#endif
break;
case INDEX_op_qemu_st16:
t0 = tci_read_r16(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stw_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint16_t *)(host_addr + GUEST_BASE) = tswap16(t0);
#endif
break;
case INDEX_op_qemu_st32:
t0 = tci_read_r32(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stl_mmu(env, taddr, t0, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint32_t *)(host_addr + GUEST_BASE) = tswap32(t0);
#endif
break;
case INDEX_op_qemu_st64:
tmp64 = tci_read_r64(&tb_ptr);
taddr = tci_read_ulong(&tb_ptr);
#ifdef CONFIG_SOFTMMU
t2 = tci_read_i(&tb_ptr);
helper_stq_mmu(env, taddr, tmp64, t2);
#else
host_addr = (tcg_target_ulong)taddr;
*(uint64_t *)(host_addr + GUEST_BASE) = tswap64(tmp64);
#endif
break;
default:
TODO();
break;
}
assert(tb_ptr == old_code_ptr + op_size);
}
exit:
return next_tb;
}
| [
"uintptr_t FUNC_0(CPUArchState *env, uint8_t *tb_ptr)\n{",
"long VAR_0[CPU_TEMP_BUF_NLONGS];",
"uintptr_t sp_value = (uintptr_t)(VAR_0 + CPU_TEMP_BUF_NLONGS);",
"uintptr_t next_tb = 0;",
"tci_reg[TCG_AREG0] = (tcg_target_ulong)env;",
"tci_reg[TCG_REG_CALL_STACK] = sp_value;",
"assert(tb_ptr);",
"for (... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[... |
15,687 | static int vp9_raw_reorder_make_output(AVBSFContext *bsf,
AVPacket *out,
VP9RawReorderFrame *last_frame)
{
VP9RawReorderContext *ctx = bsf->priv_data;
VP9RawReorderFrame *next_output = last_frame,
*next_display = last_frame, *frame;
int s, err;
for (s = 0; s < FRAME_SLOTS; s++) {
frame = ctx->slot[s];
if (!frame)
continue;
if (frame->needs_output && (!next_output ||
frame->sequence < next_output->sequence))
next_output = frame;
if (frame->needs_display && (!next_display ||
frame->pts < next_display->pts))
next_display = frame;
}
if (!next_output && !next_display)
return AVERROR_EOF;
if (!next_display || (next_output &&
next_output->sequence < next_display->sequence))
frame = next_output;
else
frame = next_display;
if (frame->needs_output && frame->needs_display &&
next_output == next_display) {
av_log(bsf, AV_LOG_DEBUG, "Output and display frame "
"%"PRId64" (%"PRId64") in order.\n",
frame->sequence, frame->pts);
av_packet_move_ref(out, frame->packet);
frame->needs_output = frame->needs_display = 0;
} else if (frame->needs_output) {
if (frame->needs_display) {
av_log(bsf, AV_LOG_DEBUG, "Output frame %"PRId64" "
"(%"PRId64") for later display.\n",
frame->sequence, frame->pts);
} else {
av_log(bsf, AV_LOG_DEBUG, "Output unshown frame "
"%"PRId64" (%"PRId64") to keep order.\n",
frame->sequence, frame->pts);
}
av_packet_move_ref(out, frame->packet);
out->pts = out->dts;
frame->needs_output = 0;
} else {
PutBitContext pb;
av_assert0(!frame->needs_output && frame->needs_display);
if (frame->slots == 0) {
av_log(bsf, AV_LOG_ERROR, "Attempting to display frame "
"which is no longer available?\n");
frame->needs_display = 0;
return AVERROR_INVALIDDATA;
}
s = ff_ctz(frame->slots);
av_assert0(s < FRAME_SLOTS);
av_log(bsf, AV_LOG_DEBUG, "Display frame %"PRId64" "
"(%"PRId64") from slot %d.\n",
frame->sequence, frame->pts, s);
frame->packet = av_packet_alloc();
if (!frame->packet)
return AVERROR(ENOMEM);
err = av_new_packet(out, 2);
if (err < 0)
return err;
init_put_bits(&pb, out->data, 2);
// frame_marker
put_bits(&pb, 2, 2);
// profile_low_bit
put_bits(&pb, 1, frame->profile & 1);
// profile_high_bit
put_bits(&pb, 1, (frame->profile >> 1) & 1);
if (frame->profile == 3) {
// reserved_zero
put_bits(&pb, 1, 0);
}
// show_existing_frame
put_bits(&pb, 1, 1);
// frame_to_show_map_idx
put_bits(&pb, 3, s);
while (put_bits_count(&pb) < 16)
put_bits(&pb, 1, 0);
flush_put_bits(&pb);
out->pts = out->dts = frame->pts;
frame->needs_display = 0;
}
return 0;
}
| true | FFmpeg | b43b95f4789b6e60f9684918fd3c0a5f3f18aef6 | static int vp9_raw_reorder_make_output(AVBSFContext *bsf,
AVPacket *out,
VP9RawReorderFrame *last_frame)
{
VP9RawReorderContext *ctx = bsf->priv_data;
VP9RawReorderFrame *next_output = last_frame,
*next_display = last_frame, *frame;
int s, err;
for (s = 0; s < FRAME_SLOTS; s++) {
frame = ctx->slot[s];
if (!frame)
continue;
if (frame->needs_output && (!next_output ||
frame->sequence < next_output->sequence))
next_output = frame;
if (frame->needs_display && (!next_display ||
frame->pts < next_display->pts))
next_display = frame;
}
if (!next_output && !next_display)
return AVERROR_EOF;
if (!next_display || (next_output &&
next_output->sequence < next_display->sequence))
frame = next_output;
else
frame = next_display;
if (frame->needs_output && frame->needs_display &&
next_output == next_display) {
av_log(bsf, AV_LOG_DEBUG, "Output and display frame "
"%"PRId64" (%"PRId64") in order.\n",
frame->sequence, frame->pts);
av_packet_move_ref(out, frame->packet);
frame->needs_output = frame->needs_display = 0;
} else if (frame->needs_output) {
if (frame->needs_display) {
av_log(bsf, AV_LOG_DEBUG, "Output frame %"PRId64" "
"(%"PRId64") for later display.\n",
frame->sequence, frame->pts);
} else {
av_log(bsf, AV_LOG_DEBUG, "Output unshown frame "
"%"PRId64" (%"PRId64") to keep order.\n",
frame->sequence, frame->pts);
}
av_packet_move_ref(out, frame->packet);
out->pts = out->dts;
frame->needs_output = 0;
} else {
PutBitContext pb;
av_assert0(!frame->needs_output && frame->needs_display);
if (frame->slots == 0) {
av_log(bsf, AV_LOG_ERROR, "Attempting to display frame "
"which is no longer available?\n");
frame->needs_display = 0;
return AVERROR_INVALIDDATA;
}
s = ff_ctz(frame->slots);
av_assert0(s < FRAME_SLOTS);
av_log(bsf, AV_LOG_DEBUG, "Display frame %"PRId64" "
"(%"PRId64") from slot %d.\n",
frame->sequence, frame->pts, s);
frame->packet = av_packet_alloc();
if (!frame->packet)
return AVERROR(ENOMEM);
err = av_new_packet(out, 2);
if (err < 0)
return err;
init_put_bits(&pb, out->data, 2);
put_bits(&pb, 2, 2);
put_bits(&pb, 1, frame->profile & 1);
put_bits(&pb, 1, (frame->profile >> 1) & 1);
if (frame->profile == 3) {
put_bits(&pb, 1, 0);
}
put_bits(&pb, 1, 1);
put_bits(&pb, 3, s);
while (put_bits_count(&pb) < 16)
put_bits(&pb, 1, 0);
flush_put_bits(&pb);
out->pts = out->dts = frame->pts;
frame->needs_display = 0;
}
return 0;
}
| {
"code": [
" frame->packet = av_packet_alloc();",
" if (!frame->packet)",
" return AVERROR(ENOMEM);"
],
"line_no": [
147,
149,
151
]
} | static int FUNC_0(AVBSFContext *VAR_0,
AVPacket *VAR_1,
VP9RawReorderFrame *VAR_2)
{
VP9RawReorderContext *ctx = VAR_0->priv_data;
VP9RawReorderFrame *next_output = VAR_2,
*next_display = VAR_2, *frame;
int VAR_3, VAR_4;
for (VAR_3 = 0; VAR_3 < FRAME_SLOTS; VAR_3++) {
frame = ctx->slot[VAR_3];
if (!frame)
continue;
if (frame->needs_output && (!next_output ||
frame->sequence < next_output->sequence))
next_output = frame;
if (frame->needs_display && (!next_display ||
frame->pts < next_display->pts))
next_display = frame;
}
if (!next_output && !next_display)
return AVERROR_EOF;
if (!next_display || (next_output &&
next_output->sequence < next_display->sequence))
frame = next_output;
else
frame = next_display;
if (frame->needs_output && frame->needs_display &&
next_output == next_display) {
av_log(VAR_0, AV_LOG_DEBUG, "Output and display frame "
"%"PRId64" (%"PRId64") in order.\n",
frame->sequence, frame->pts);
av_packet_move_ref(VAR_1, frame->packet);
frame->needs_output = frame->needs_display = 0;
} else if (frame->needs_output) {
if (frame->needs_display) {
av_log(VAR_0, AV_LOG_DEBUG, "Output frame %"PRId64" "
"(%"PRId64") for later display.\n",
frame->sequence, frame->pts);
} else {
av_log(VAR_0, AV_LOG_DEBUG, "Output unshown frame "
"%"PRId64" (%"PRId64") to keep order.\n",
frame->sequence, frame->pts);
}
av_packet_move_ref(VAR_1, frame->packet);
VAR_1->pts = VAR_1->dts;
frame->needs_output = 0;
} else {
PutBitContext pb;
av_assert0(!frame->needs_output && frame->needs_display);
if (frame->slots == 0) {
av_log(VAR_0, AV_LOG_ERROR, "Attempting to display frame "
"which is no longer available?\n");
frame->needs_display = 0;
return AVERROR_INVALIDDATA;
}
VAR_3 = ff_ctz(frame->slots);
av_assert0(VAR_3 < FRAME_SLOTS);
av_log(VAR_0, AV_LOG_DEBUG, "Display frame %"PRId64" "
"(%"PRId64") from slot %d.\n",
frame->sequence, frame->pts, VAR_3);
frame->packet = av_packet_alloc();
if (!frame->packet)
return AVERROR(ENOMEM);
VAR_4 = av_new_packet(VAR_1, 2);
if (VAR_4 < 0)
return VAR_4;
init_put_bits(&pb, VAR_1->data, 2);
put_bits(&pb, 2, 2);
put_bits(&pb, 1, frame->profile & 1);
put_bits(&pb, 1, (frame->profile >> 1) & 1);
if (frame->profile == 3) {
put_bits(&pb, 1, 0);
}
put_bits(&pb, 1, 1);
put_bits(&pb, 3, VAR_3);
while (put_bits_count(&pb) < 16)
put_bits(&pb, 1, 0);
flush_put_bits(&pb);
VAR_1->pts = VAR_1->dts = frame->pts;
frame->needs_display = 0;
}
return 0;
}
| [
"static int FUNC_0(AVBSFContext *VAR_0,\nAVPacket *VAR_1,\nVP9RawReorderFrame *VAR_2)\n{",
"VP9RawReorderContext *ctx = VAR_0->priv_data;",
"VP9RawReorderFrame *next_output = VAR_2,\n*next_display = VAR_2, *frame;",
"int VAR_3, VAR_4;",
"for (VAR_3 = 0; VAR_3 < FRAME_SLOTS; VAR_3++) {",
"frame = ctx->slot... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11,
13
],
[
15
],
[
19
],
[
21
],
[
23,
25
],
[
27,
29,
31
],
[
33,
35,
37
],
[
39
],
[
43,
45
],
[
49,
51,
53
],
[
55,
57
],
[
61,... |
15,688 | static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
int ecpl, int start_subband, int end_subband,
const uint8_t *default_band_struct,
int *num_bands, uint8_t *band_sizes)
{
int subbnd, bnd, n_subbands, n_bands=0;
uint8_t bnd_sz[22];
uint8_t coded_band_struct[22];
const uint8_t *band_struct;
n_subbands = end_subband - start_subband;
/* decode band structure from bitstream or use default */
if (!eac3 || get_bits1(gbc)) {
for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
coded_band_struct[subbnd] = get_bits1(gbc);
}
band_struct = coded_band_struct;
} else if (!blk) {
band_struct = &default_band_struct[start_subband+1];
} else {
/* no change in band structure */
return;
}
/* calculate number of bands and band sizes based on band structure.
note that the first 4 subbands in enhanced coupling span only 6 bins
instead of 12. */
if (num_bands || band_sizes ) {
n_bands = n_subbands;
bnd_sz[0] = ecpl ? 6 : 12;
for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
if (band_struct[subbnd - 1]) {
n_bands--;
bnd_sz[bnd] += subbnd_size;
} else {
bnd_sz[++bnd] = subbnd_size;
}
}
}
/* set optional output params */
if (num_bands)
*num_bands = n_bands;
if (band_sizes)
memcpy(band_sizes, bnd_sz, n_bands);
}
| true | FFmpeg | 9351a156de724edb69ba6e1f05884fe806a13a21 | static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
int ecpl, int start_subband, int end_subband,
const uint8_t *default_band_struct,
int *num_bands, uint8_t *band_sizes)
{
int subbnd, bnd, n_subbands, n_bands=0;
uint8_t bnd_sz[22];
uint8_t coded_band_struct[22];
const uint8_t *band_struct;
n_subbands = end_subband - start_subband;
if (!eac3 || get_bits1(gbc)) {
for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
coded_band_struct[subbnd] = get_bits1(gbc);
}
band_struct = coded_band_struct;
} else if (!blk) {
band_struct = &default_band_struct[start_subband+1];
} else {
return;
}
if (num_bands || band_sizes ) {
n_bands = n_subbands;
bnd_sz[0] = ecpl ? 6 : 12;
for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
if (band_struct[subbnd - 1]) {
n_bands--;
bnd_sz[bnd] += subbnd_size;
} else {
bnd_sz[++bnd] = subbnd_size;
}
}
}
if (num_bands)
*num_bands = n_bands;
if (band_sizes)
memcpy(band_sizes, bnd_sz, n_bands);
}
| {
"code": [
" int *num_bands, uint8_t *band_sizes)",
" uint8_t coded_band_struct[22];",
" const uint8_t *band_struct;",
" coded_band_struct[subbnd] = get_bits1(gbc);",
" band_struct = coded_band_struct;",
" } else if (!blk) {",
" band_struct = &default_band_struct[start_subband+1];",
" } else {"
],
"line_no": [
7,
15,
17,
31,
35,
37,
39,
41
]
} | static void FUNC_0(GetBitContext *VAR_0, int VAR_1, int VAR_2,
int VAR_3, int VAR_4, int VAR_5,
const uint8_t *VAR_6,
int *VAR_7, uint8_t *VAR_8)
{
int VAR_9, VAR_10, VAR_11, VAR_12=0;
uint8_t bnd_sz[22];
uint8_t coded_band_struct[22];
const uint8_t *VAR_13;
VAR_11 = VAR_5 - VAR_4;
if (!VAR_2 || get_bits1(VAR_0)) {
for (VAR_9 = 0; VAR_9 < VAR_11 - 1; VAR_9++) {
coded_band_struct[VAR_9] = get_bits1(VAR_0);
}
VAR_13 = coded_band_struct;
} else if (!VAR_1) {
VAR_13 = &VAR_6[VAR_4+1];
} else {
return;
}
if (VAR_7 || VAR_8 ) {
VAR_12 = VAR_11;
bnd_sz[0] = VAR_3 ? 6 : 12;
for (VAR_10 = 0, VAR_9 = 1; VAR_9 < VAR_11; VAR_9++) {
int VAR_14 = (VAR_3 && VAR_9 < 4) ? 6 : 12;
if (VAR_13[VAR_9 - 1]) {
VAR_12--;
bnd_sz[VAR_10] += VAR_14;
} else {
bnd_sz[++VAR_10] = VAR_14;
}
}
}
if (VAR_7)
*VAR_7 = VAR_12;
if (VAR_8)
memcpy(VAR_8, bnd_sz, VAR_12);
}
| [
"static void FUNC_0(GetBitContext *VAR_0, int VAR_1, int VAR_2,\nint VAR_3, int VAR_4, int VAR_5,\nconst uint8_t *VAR_6,\nint *VAR_7, uint8_t *VAR_8)\n{",
"int VAR_9, VAR_10, VAR_11, VAR_12=0;",
"uint8_t bnd_sz[22];",
"uint8_t coded_band_struct[22];",
"const uint8_t *VAR_13;",
"VAR_11 = VAR_5 - VAR_4;",
... | [
1,
0,
0,
1,
1,
0,
0,
0,
1,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
57
],
[
59
],
[... |
15,689 | static ExitStatus trans_fop_weww_0e(DisasContext *ctx, uint32_t insn,
const DisasInsn *di)
{
unsigned rt = assemble_rt64(insn);
unsigned rb = assemble_rb64(insn);
unsigned ra = assemble_ra64(insn);
return do_fop_weww(ctx, rt, ra, rb, di->f_weww);
}
| true | qemu | eff235eb2bcd7092901f4698a7907e742f3b7f2f | static ExitStatus trans_fop_weww_0e(DisasContext *ctx, uint32_t insn,
const DisasInsn *di)
{
unsigned rt = assemble_rt64(insn);
unsigned rb = assemble_rb64(insn);
unsigned ra = assemble_ra64(insn);
return do_fop_weww(ctx, rt, ra, rb, di->f_weww);
}
| {
"code": [
" return do_fop_weww(ctx, rt, ra, rb, di->f_weww);",
" return do_fop_weww(ctx, rt, ra, rb, di->f_weww);"
],
"line_no": [
13,
13
]
} | static ExitStatus FUNC_0(DisasContext *ctx, uint32_t insn,
const DisasInsn *di)
{
unsigned VAR_0 = assemble_rt64(insn);
unsigned VAR_1 = assemble_rb64(insn);
unsigned VAR_2 = assemble_ra64(insn);
return do_fop_weww(ctx, VAR_0, VAR_2, VAR_1, di->f_weww);
}
| [
"static ExitStatus FUNC_0(DisasContext *ctx, uint32_t insn,\nconst DisasInsn *di)\n{",
"unsigned VAR_0 = assemble_rt64(insn);",
"unsigned VAR_1 = assemble_rb64(insn);",
"unsigned VAR_2 = assemble_ra64(insn);",
"return do_fop_weww(ctx, VAR_0, VAR_2, VAR_1, di->f_weww);",
"}"
] | [
0,
0,
0,
0,
1,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.