id int64 80 27.2k | text stringlengths 48 60.4k | label bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 |
|---|---|---|---|---|
7,742 | void do_405_check_ov (void)
{
if (likely(((T1 ^ T2) >> 31) || !((T0 ^ T2) >> 31))) {
xer_ov = 0;
} else {
xer_ov = 1;
xer_so = 1;
}
}
| true | qemu | d9bce9d99f4656ae0b0127f7472db9067b8f84ab |
18,824 | static void rv40_h_strong_loop_filter(uint8_t *src, const int stride,
const int alpha, const int lims,
const int dmode, const int chroma)
{
rv40_strong_loop_filter(src, stride, 1, alpha, lims, dmode, chroma);
}
| true | FFmpeg | 3ab9a2a5577d445252724af4067d2a7c8a378efa |
12,417 | static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
{
AVFilterLink *outlink = inlink->dst->outputs[0];
AVFilterBufferRef *outpicref = NULL;
int ret = 0;
if (inpicref->perms & AV_PERM_PRESERVE) {
outpicref = ff_get_video_buffer(outlink, AV_PERM_WRITE,
... | false | FFmpeg | 1dc42050185d63c1de5d16146fbaee92640af187 |
9,045 | static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb,
const uint8_t *data_in,
size_t data_in_len,
uint8_t *data_out, size_t data_out_len,
struc... | false | qemu | a980f7f2c2f4d7e9a1eba4f804cd66dbd458b6d4 |
12,634 | void cpu_resume_from_signal(CPUState *cpu, void *puc)
{
/* XXX: restore cpu registers saved in host registers */
cpu->exception_index = -1;
siglongjmp(cpu->jmp_env, 1);
}
| false | qemu | 6886b98036a8f8f5bce8b10756ce080084cef11b |
26,936 | static void xan_unpack(unsigned char *dest, unsigned char *src)
{
unsigned char opcode;
int size;
int offset;
int byte1, byte2, byte3;
for (;;) {
opcode = *src++;
if ( (opcode & 0x80) == 0 ) {
offset = *src++;
size = opcode & 3;
... | false | FFmpeg | ca16618b01abfde44b4eaf92dc89b01aa1b4a91e |
23,684 | static long do_rt_sigreturn_v1(CPUARMState *env)
{
abi_ulong frame_addr;
struct rt_sigframe_v1 *frame = NULL;
sigset_t host_set;
/*
* Since we stacked the signal on a 64-bit boundary,
* then 'sp' should be word aligned here. If it's
* not, then the user is trying to mess with u... | false | qemu | 1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3 |
11,472 | static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
{
if (c->abits[band][ch] <= 7) {
int sum, i, j;
for (i = 0; i < 8; i += 4) {
sum = 0;
for (j = 3; j >= 0; j--) {
sum *= ff_dca_quant_levels[c->abits[band][ch]];
... | false | FFmpeg | a6191d098a03f94685ae4c072bfdf10afcd86223 |
774 | void helper_dcbz(CPUPPCState *env, target_ulong addr, uint32_t is_dcbzl)
{
int dcbz_size = env->dcache_line_size;
#if defined(TARGET_PPC64)
if (!is_dcbzl &&
(env->excp_model == POWERPC_EXCP_970) &&
((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1) {
dcbz_size = 32;
}
#endif
... | true | qemu | c9f82d013be0d8d9c5d9f51bb76e337a0a5a5cac |
10,388 | static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
{
struct addrinfo ai, *res;
int rc;
const char *addr;
const char *port;
memset(&ai, 0, sizeof(ai));
ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
ai.ai_family = PF_UNSPEC;
ai.ai_socktype = SOCK_STREA... | true | qemu | 3de3d698d942d1116152417f882c897b26b44e41 |
2,486 | bool virtio_disk_is_scsi(void)
{
if (guessed_disk_nature) {
return (blk_cfg.blk_size == 512);
}
return (blk_cfg.geometry.heads == 255)
&& (blk_cfg.geometry.sectors == 63)
&& (blk_cfg.blk_size == 512);
}
| false | qemu | 92cb05574b7bd489be81f9c58497dc7dfe5d8859 |
1,942 | av_cold void ff_sws_init_input_funcs(SwsContext *c)
{
enum PixelFormat srcFormat = c->srcFormat;
c->chrToYV12 = NULL;
switch(srcFormat) {
case PIX_FMT_YUYV422 : c->chrToYV12 = yuy2ToUV_c; break;
case PIX_FMT_UYVY422 : c->chrToYV12 = uyvyToUV_c; break;
case PIX_FMT_NV12 ... | true | FFmpeg | f972193a15026a99eb2b08e7913a03f2123663da |
23,322 | static int read_dialogue(ASSContext *ass, AVBPrint *dst, const uint8_t *p,
int64_t *start, int *duration)
{
int pos;
int64_t end;
int hh1, mm1, ss1, ms1;
int hh2, mm2, ss2, ms2;
if (sscanf(p, "Dialogue: %*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d,%n",
&hh1, &... | true | FFmpeg | 138902dfb60fbb87fb65a8c4800f8ac661394b72 |
11,371 | qemu_irq *pl190_init(uint32_t base, qemu_irq irq, qemu_irq fiq)
{
pl190_state *s;
qemu_irq *qi;
int iomemtype;
s = (pl190_state *)qemu_mallocz(sizeof(pl190_state));
iomemtype = cpu_register_io_memory(0, pl190_readfn,
pl190_writefn, s);
cpu_registe... | true | qemu | 187337f8b0ec0813dd3876d1efe37d415fb81c2e |
15,839 | static inline uint32_t efsctsf(uint32_t val)
{
CPU_FloatU u;
float32 tmp;
u.l = val;
/* NaN are not treated the same way IEEE 754 does */
if (unlikely(float32_is_nan(u.f)))
return 0;
tmp = uint64_to_float32(1ULL << 32, &env->vec_status);
u.f = float32_mul(u.f, tmp, &env->v... | false | qemu | 185698715dfb18c82ad2a5dbc169908602d43e81 |
17,083 | static uint64_t e1000_io_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
E1000State *s = opaque;
(void)s;
return 0;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
5,991 | static void qtest_process_command(CharDriverState *chr, gchar **words)
{
const gchar *command;
g_assert(words);
command = words[0];
if (qtest_log_fp) {
qemu_timeval tv;
int i;
qtest_get_time(&tv);
fprintf(qtest_log_fp, "[R +" FMT_timeval "]",
... | true | qemu | 332cc7e9b39ddb2feacb4c71dcd18c3e5b0c3147 |
21,291 | static int qemu_chr_open_win_con(QemuOpts *opts, CharDriverState **chr)
{
return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE), chr);
}
| true | qemu | 1f51470d044852592922f91000e741c381582cdc |
12,661 | static av_always_inline void h264_filter_mb_fast_internal(const H264Context *h,
H264SliceContext *sl,
int mb_x, int mb_y,
uint8_t *img_y,
... | false | FFmpeg | 3176217c60ca7828712985092d9102d331ea4f3d |
5,623 | static void qemu_thread_set_name(QemuThread *thread, const char *name)
{
#ifdef CONFIG_PTHREAD_SETNAME_NP
pthread_setname_np(thread->thread, name);
#endif
}
| true | qemu | 68a9398261ca38979bbc2b7c89ed5bb044ccc9e6 |
6,447 | static int vdpau_alloc(AVCodecContext *s)
{
InputStream *ist = s->opaque;
int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
AVVDPAUContext *vdpau_ctx;
VDPAUContext *ctx;
const char *display, *vendor;
VdpStatus err;
int i;
ctx = av_mallocz(sizeo... | false | FFmpeg | d3eb317b862c3f5653f0ae8dfcb22edf1713ab5b |
3,891 | static void s390_cpu_model_initfn(Object *obj)
{ | true | qemu | ad5afd07b628cd0610ea322ad60b5ad03aa250c8 |
14,581 | static uint32_t apic_mem_readb(void *opaque, target_phys_addr_t addr)
{
return 0;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
9,799 | void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t window_size, int *pfd)
{
struct kvm_create_spapr_tce args = {
.liobn = liobn,
.window_size = window_size,
};
long len;
int fd;
void *table;
/* Must set fd to -1 so we don't try to munmap when called for
* des... | false | qemu | a83000f5e3fac30a7f213af1ba6a8f827622854d |
6,423 | static void qemu_rdma_cleanup(RDMAContext *rdma)
{
struct rdma_cm_event *cm_event;
int ret, idx;
if (rdma->cm_id && rdma->connected) {
if (rdma->error_state) {
RDMAControlHeader head = { .len = 0,
.type = RDMA_CONTROL_ERROR,
... | true | qemu | 80b262e1439a22708e1c535b75363d4b90c3b41d |
5,413 | static int alac_decode_frame(AVCodecContext *avctx,
void *outbuffer, int *outputsize,
AVPacket *avpkt)
{
const uint8_t *inbuffer = avpkt->data;
int input_buffer_size = avpkt->size;
ALACContext *alac = avctx->priv_data;
int channels;
... | true | FFmpeg | 313b52fbfff47ed934cdeccaebda9b3406466575 |
21,865 | static void rtl8139_io_writeb(void *opaque, uint8_t addr, uint32_t val)
{
RTL8139State *s = opaque;
switch (addr)
{
case MAC0 ... MAC0+5:
s->phys[addr - MAC0] = val;
qemu_format_nic_info_str(qemu_get_queue(s->nic), s->phys);
break;
case MAC0+6 .... | false | qemu | 90d131fb6504ed12a37dc8433375cc683c30e9da |
9,384 | static QDict *build_qmp_error_dict(const QError *err)
{
QObject *obj;
obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
ErrorClass_lookup[err->err_class],
qerror_human(err));
return qobject_to_qdict(obj);
}
| false | qemu | 710aec915d208246891b68e2ba61b54951edc508 |
20,705 | static int vfio_populate_device(VFIODevice *vbasedev)
{
VFIOINTp *intp, *tmp;
int i, ret = -1;
VFIOPlatformDevice *vdev =
container_of(vbasedev, VFIOPlatformDevice, vbasedev);
if (!(vbasedev->flags & VFIO_DEVICE_FLAGS_PLATFORM)) {
error_report("vfio: Um, this isn't a platform de... | true | qemu | bdd81addf4033ce26e6cd180b060f63095f3ded9 |
2,028 | static void memory_region_dispatch_write(MemoryRegion *mr,
hwaddr addr,
uint64_t data,
unsigned size)
{
if (!memory_region_access_valid(mr, addr, size, true)) {
return; /* FIXME: ... | true | qemu | fbeadf50f2f965741def823036b086bbc2999b1f |
12,990 | static int mpegts_init(AVFormatContext *s)
{
MpegTSWrite *ts = s->priv_data;
MpegTSWriteStream *ts_st;
MpegTSService *service;
AVStream *st, *pcr_st = NULL;
AVDictionaryEntry *title, *provider;
int i, j;
const char *service_name;
const char *provider_name;
int *pids;
i... | true | FFmpeg | a566c952f905639456966413fee0b5701867ddcd |
22,897 | void cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata)
{
CacheItem *it = NULL;
g_assert(cache);
g_assert(cache->page_cache);
/* actual update of entry */
it = cache_get_by_addr(cache, addr);
if (!it->it_data) {
cache->num_items++;
}
it->it_data = pdata;
it->it_age... | true | qemu | 32a1c08b60a8ac0e63b54a5793a26b5e32b36618 |
1,943 | static uint32_t pcie_mmcfg_data_read(PCIBus *s, uint32_t addr, int len)
{
PCIDevice *pci_dev = pcie_dev_find_by_mmcfg_addr(s, addr);
if (!pci_dev) {
return ~0x0;
}
return pci_host_config_read_common(pci_dev, PCIE_MMCFG_CONFOFFSET(addr),
pci_config_... | true | qemu | 43e86c8f5b6d9f6279e20dede4e1f7829bdc43b7 |
17,488 | static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
uint8_t (*layout_map)[3],
GetBitContext *gb)
{
int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
int comment_len;
int tags;
skip_bits(gb, 2); // ob... | true | FFmpeg | dbe29db8cb09fb39bd8dc5b25934e92279d0aa8d |
4,182 | static int usb_hid_initfn(USBDevice *dev, int kind)
{
USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
usb_desc_init(dev);
hid_init(&us->hid, kind, usb_hid_changed);
/* Force poll routine to be run and grab input the first time. */
us->changed = 1;
return 0;
}
| false | qemu | 38931fa8cfb074a08ce65fd1982bd4a5bef9d6fb |
12,000 | static void vnc_dpy_resize(DisplayState *ds)
{
int size_changed;
VncState *vs = ds->opaque;
vs->old_data = qemu_realloc(vs->old_data, ds_get_linesize(ds) * ds_get_height(ds));
if (vs->old_data == NULL) {
fprintf(stderr, "vnc: memory allocation failed\n");
exit(1);
}
if (ds_get_b... | true | qemu | 6cec5487990bf3f1f22b3fcb871978255e92ae0d |
2,522 | int bdrv_commit(BlockDriverState *bs)
{
BlockDriver *drv = bs->drv;
int64_t sector, total_sectors, length, backing_length;
int n, ro, open_flags;
int ret = 0;
uint8_t *buf = NULL;
char filename[PATH_MAX];
if (!drv)
return -ENOMEDIUM;
if (!bs->backing_hd) {
... | false | qemu | 3718d8ab65f68de2acccbe6a315907805f54e3cc |
13,654 | static void bdrv_co_io_em_complete(void *opaque, int ret)
{
CoroutineIOCompletion *co = opaque;
co->ret = ret;
qemu_coroutine_enter(co->coroutine, NULL);
}
| true | qemu | 0b8b8753e4d94901627b3e86431230f2319215c4 |
22,882 | static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
Jpeg2000CodingStyle *codsty,
Jpeg2000ResLevel *rlevel, int precno,
int layno, uint8_t *expn, int numgbits)
{
int ... | false | FFmpeg | 4ec14ce121df4c33880251a96c2f3e7409eb14fe |
3,696 | static always_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 &... | true | qemu | 6f2d8978728c48ca46f5c01835438508aace5c64 |
14,232 | START_TEST(qstring_get_str_test)
{
QString *qstring;
const char *ret_str;
const char *str = "QEMU/KVM";
qstring = qstring_from_str(str);
ret_str = qstring_get_str(qstring);
fail_unless(strcmp(ret_str, str) == 0);
QDECREF(qstring);
}
| false | qemu | 0ac7cc2af500b948510f2481c22e84a57b0a2447 |
5,075 | pcie_cap_v1_fill(uint8_t *exp_cap, uint8_t port, uint8_t type, uint8_t version)
{
/* capability register
interrupt message number defaults to 0 */
pci_set_word(exp_cap + PCI_EXP_FLAGS,
((type << PCI_EXP_FLAGS_TYPE_SHIFT) & PCI_EXP_FLAGS_TYPE) |
version);
/* dev... | true | qemu | 6b4495401bdf442457b713b7e3994b465c55af35 |
3,511 | const char *qdev_fw_name(DeviceState *dev)
{
DeviceClass *dc = DEVICE_GET_CLASS(dev);
if (dc->fw_name) {
return dc->fw_name;
} else if (dc->alias) {
return dc->alias;
}
return object_get_typename(OBJECT(dev));
}
| false | qemu | 6acbe4c6f18e7de00481ff30574262b58526de45 |
11,227 | void rgb16tobgr16(const uint8_t *src, uint8_t *dst, long src_size)
{
long i;
long num_pixels = src_size >> 1;
for(i=0; i<num_pixels; i++)
{
unsigned b,g,r;
register uint16_t rgb;
rgb = src[2*i];
r = rgb&0x1F;
g = (rgb&0x7E0)>>5;
b = (rgb&0xF800)>>11;
dst[2*i] = (b&0x... | true | FFmpeg | 6e42e6c4b410dbef8b593c2d796a5dad95f89ee4 |
16,399 | static bool memory_region_access_valid(MemoryRegion *mr,
target_phys_addr_t addr,
unsigned size)
{
if (!mr->ops->valid.unaligned && (addr & (size - 1))) {
return false;
}
/* Treat zero as compatibility all valid *... | false | qemu | 897fa7cff21a98b260a5b3e73eae39273fa60272 |
14,365 | static inline void celt_encode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
{
ff_opus_rc_enc_uint(rc, celt_icwrsi(N, y), CELT_PVQ_V(N, K));
}
| false | FFmpeg | 67fa02ed794f9505bd9c3584c14bfb61c895f5bc |
10,489 | static inline void gen_movs(DisasContext *s, int ot)
{
gen_string_movl_A0_ESI(s);
gen_op_ld_T0_A0(ot + s->mem_index);
gen_string_movl_A0_EDI(s);
gen_op_st_T0_A0(ot + s->mem_index);
gen_op_movl_T0_Dshift[ot]();
#ifdef TARGET_X86_64
if (s->aflag == 2) {
gen_op_addq_ESI_T0();
... | false | qemu | 6e0d8677cb443e7408c0b7a25a93c6596d7fa380 |
9,558 | static void ratelimit_set_speed(RateLimit *limit, uint64_t speed)
{
limit->slice_quota = speed / (1000000000ULL / SLICE_TIME);
}
| false | qemu | 6ef228fc0de1d5fb43ebfef039563d39a3a37067 |
13,493 | static void qemu_aio_wait_nonblocking(void)
{
qemu_notify_event();
qemu_aio_wait();
}
| false | qemu | c4d9d19645a484298a67e9021060bc7c2b081d0f |
14,730 | static int aio_read_f(BlockBackend *blk, int argc, char **argv)
{
int nr_iov, c;
struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
ctx->blk = blk;
while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
switch (c) {
case 'C':
ctx->Cflag = 1;
break;
c... | false | qemu | b062ad86dcd33ab39be5060b0655d8e13834b167 |
9,197 | static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
{
GetBitContext *gb = &s->gb;
unsigned i, b;
int n1, n2;
for (i = 0; i < s->rows; i++) {
/* b = (x1) + (x2 * 11) */
b = get_bits(gb, 7);
n1 = (mul_2x11[b] & 0x0F) - 5;
n2 = ((mul_2x11[b] >>... | true | FFmpeg | 14e4e26559697cfdea584767be4e68474a0a9c7f |
12,565 | static void dct_unquantize_mpeg2_c(MpegEncContext *s,
DCTELEM *block, int n, int qscale)
{
int i, level, nCoeffs;
const UINT16 *quant_matrix;
if(s->alternate_scan) nCoeffs= 64;
else nCoeffs= s->block_last_index[n]+1;
if (s->mb_intra) {
if (... | true | FFmpeg | d7e9533aa06f4073a27812349b35ba5fede11ca1 |
13,327 | static av_always_inline int rv40_loop_filter_strength(uint8_t *src,
int step, int stride,
int beta, int beta2,
int edge,
... | true | FFmpeg | 3ab9a2a5577d445252724af4067d2a7c8a378efa |
16,720 | static void coroutine_fn stream_run(void *opaque)
{
StreamBlockJob *s = opaque;
BlockDriverState *bs = s->common.bs;
BlockDriverState *base = s->base;
int64_t sector_num, end;
int error = 0;
int ret = 0;
int n = 0;
void *buf;
s->common.len = bdrv_getlength(bs);
if (s... | true | qemu | c3e4f43a99549daa6e9b87350922e8339341c2ab |
26,922 | static int decode_ref_pic_marking(H264Context *h, GetBitContext *gb){
MpegEncContext * const s = &h->s;
int i;
if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
s->broken_link= get_bits1(gb) -1;
h->mmco[0].long_arg= get_bits1(gb) - 1; // current_long_term_idx
if(h->mmco[... | true | FFmpeg | d9fe1749fc1009b14252030dda9142de624670c0 |
20,418 | ssize_t v9fs_list_xattr(FsContext *ctx, const char *path,
void *value, size_t vsize)
{
ssize_t size = 0;
char *buffer;
void *ovalue = value;
XattrOperations *xops;
char *orig_value, *orig_value_start;
ssize_t xattr_len, parsed_len = 0, attr_len;
/* Get the ... | true | qemu | 5507904e362df252f6065cb27d1ff98372db6abc |
6,928 | static int m25p80_init(SSISlave *ss)
{
DriveInfo *dinfo;
Flash *s = M25P80(ss);
M25P80Class *mc = M25P80_GET_CLASS(s);
s->pi = mc->pi;
s->size = s->pi->sector_size * s->pi->n_sectors;
s->dirty_page = -1;
s->storage = qemu_blockalign(s->bdrv, s->size);
dinfo = drive_get_nex... | false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce |
21,945 | static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
{
AVCodec *codec;
int got_picture = 1, ret = 0;
AVFrame picture;
AVPacket pkt = *avpkt;
if(!st->codec->codec){
AVDictionary *thread_opt = NULL;
codec = avcodec_find_decoder(st->codec->codec... | false | FFmpeg | af08d9aeea870de017139f7b1c44b7d816cf8e56 |
12,116 | qcrypto_tls_session_new(QCryptoTLSCreds *creds,
const char *hostname,
const char *aclname,
QCryptoTLSCredsEndpoint endpoint,
Error **errp)
{
QCryptoTLSSession *session;
int ret;
session = g_new0(QCrypto... | false | qemu | 13f12430d48b62e2304e0e5a7c607279af68b98a |
4,054 | static const char *srt_to_ass(AVCodecContext *avctx, char *out, char *out_end,
const char *in, int x1, int y1, int x2, int y2)
{
char c, *param, buffer[128], tmp[128];
int len, tag_close, sptr = 1, line_start = 1, an = 0, end = 0;
SrtStack stack[16];
stack[0].tag[0]... | true | FFmpeg | aaa1173de775b9b865a714abcc270816d2f59dff |
7,856 | static void intel_hda_update_irq(IntelHDAState *d)
{
bool msi = msi_enabled(&d->pci);
int level;
intel_hda_update_int_sts(d);
if (d->int_sts & (1U << 31) && d->int_ctl & (1U << 31)) {
level = 1;
} else {
level = 0;
}
dprint(d, 2, "%s: level %d [%s]\n", __FUNCTION_... | false | qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 |
17,201 | AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask)
{
AVFilterBufferRef *ret = av_malloc(sizeof(AVFilterBufferRef));
if (!ret)
return NULL;
*ret = *ref;
if (ref->type == AVMEDIA_TYPE_VIDEO) {
ret->video = av_malloc(sizeof(AVFilterBufferRefVideoProps));
if (!... | true | FFmpeg | 6fb2fd895e858ab93f46e656a322778ee181c307 |
20,702 | abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
int flags, int fd, abi_ulong offset)
{
abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;
mmap_lock();
#ifdef DEBUG_MMAP
{
printf("mmap: start=0x" TARGET_ABI_FMT_lx
" l... | true | qemu | 35f2fd04ce8bd3eaad4b7790abb19fa2a56d7314 |
19,617 | int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf,
const uint8_t *searched_pc)
{
return tcg_gen_code_common(s, gen_code_buf, 1, searched_pc);
}
| true | qemu | 2ba1eeb62c29d23238b95dc7e9ade3444b49f0a1 |
1,679 | static struct iovec *cap_sg(struct iovec *sg, int cap, int *cnt)
{
int i;
int total = 0;
for (i = 0; i < *cnt; i++) {
if ((total + sg[i].iov_len) > cap) {
sg[i].iov_len -= ((total + sg[i].iov_len) - cap);
i++;
break;
}
total += sg[i].io... | true | qemu | 302a0d3ed721e4c30c6a2a37f64c60b50ffd33b9 |
24,639 | static void ppc405_ocm_init(CPUPPCState *env)
{
ppc405_ocm_t *ocm;
ocm = g_malloc0(sizeof(ppc405_ocm_t));
/* XXX: Size is 4096 or 0x04000000 */
memory_region_init_ram(&ocm->isarc_ram, NULL, "ppc405.ocm", 4096,
&error_abort);
vmstate_register_ram_global(&ocm->isarc... | true | qemu | f8ed85ac992c48814d916d5df4d44f9a971c5de4 |
6,319 | int DCT_common_init(MpegEncContext *s)
{
int i;
ff_put_pixels_clamped = s->dsp.put_pixels_clamped;
ff_add_pixels_clamped = s->dsp.add_pixels_clamped;
s->dct_unquantize_h263 = dct_unquantize_h263_c;
s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
s->dct_unquantize_mpeg2 = dct_unquant... | false | FFmpeg | 83f238cbf0c038245d2b2dffa5beb0916e7c36d2 |
1,724 | static int ehci_register_companion(USBBus *bus, USBPort *ports[],
uint32_t portcount, uint32_t firstport)
{
EHCIState *s = container_of(bus, EHCIState, bus);
uint32_t i;
if (firstport + portcount > NB_PORTS) {
qerror_report(QERR_INVALID_PARAMETER_VALUE, "fi... | true | qemu | 3e4f910c8d490a1490409a7e381dbbb229f9d272 |
20,124 | static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
{
int a, b, c, wrap, pred, scale, ret;
int16_t *dc_val;
/* find prediction */
if (n < 4) {
scale = s->y_dc_scale;
} else {
scale = s->c_dc_scale;
}
if(IS_3IV1)
... | false | FFmpeg | df8d98c4dd0853d92a16b1715d4e8abf19feabd8 |
25,559 | static int ppce500_load_device_tree(MachineState *machine,
PPCE500Params *params,
hwaddr addr,
hwaddr initrd_base,
hwaddr initrd_size,
... | true | qemu | 2343dd11a673597aa59813fd0cac2ae42e2e0312 |
17,771 | static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
const char *model,
const char *name,
int fd, int is_connected)
{
NetSocketState *s;
s = qemu_... | true | qemu | b946a1533209f61a93e34898aebb5b43154b99c3 |
21,842 | matroska_read_close (AVFormatContext *s)
{
MatroskaDemuxContext *matroska = s->priv_data;
int n = 0;
if (matroska->writing_app)
av_free(matroska->writing_app);
if (matroska->muxing_app)
av_free(matroska->muxing_app);
if (matroska->index)
av_free(matroska->index);
... | false | FFmpeg | ce99efc6ffedc7a8fbcc23690d9ff9f7e6f4bf44 |
1,658 | int opt_default(const char *opt, const char *arg){
int type;
const AVOption *o= NULL;
int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
for(type=0; type<CODEC_TYPE_NB; type++){
const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, o... | false | FFmpeg | 5c3383e5b5c7e3e3c1ba86a58d3e0a1ebf521aa7 |
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... | true | FFmpeg | 26ae9a5d7c448a3eb42641b546ee8d585ab716e6 |
823 | void error_setg_errno(Error **errp, int os_errno, const char *fmt, ...)
{
va_list ap;
char *msg;
int saved_errno = errno;
if (errp == NULL) {
return;
}
va_start(ap, fmt);
error_setv(errp, ERROR_CLASS_GENERIC_ERROR, fmt, ap);
va_end(ap);
if (os_errno != 0) {
... | true | qemu | 1e9b65bb1bad51735cab6c861c29b592dccabf0e |
26,838 | static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
{
int ret;
size_t buf_size;
if (size < 0)
return AVERROR(EINVAL);
buf_size = size + size / 2 + 1;
*str = av_malloc(buf_size);
if (!*str)
return AVERROR(ENOMEM);
if (be)
... | true | FFmpeg | fecb3e82a4ba09dc11a51ad0961ab491881a53a1 |
21,003 | get_pointer_coordinates(int *x, int *y, Display *dpy, AVFormatContext *s1)
{
Window mrootwindow, childwindow;
int dummy;
mrootwindow = DefaultRootWindow(dpy);
if (XQueryPointer(dpy, mrootwindow, &mrootwindow, &childwindow,
x, y, &dummy, &dummy, (unsigned int*)&dummy)) {
... | false | FFmpeg | ca4544409e32d692504b44e4ae804c3538993904 |
4,814 | int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
QemuOpts *opts;
int res;
opts = qemu_opts_from_qdict(&qemu_netdev_opts, qdict);
if (!opts) {
return -1;
res = net_client_init(mon, opts, 1);
return res; | true | qemu | 410cbafebc7168a278a23c856b4f5ff276ef1c85 |
17,432 | static int nprobe(AVFormatContext *s, uint8_t *enc_header, int size, const uint8_t *n_val)
{
OMAContext *oc = s->priv_data;
uint32_t pos, taglen, datalen;
struct AVDES av_des;
if (!enc_header || !n_val)
return -1;
pos = OMA_ENC_HEADER_SIZE + oc->k_size;
if (!memcmp(&enc_heade... | false | FFmpeg | f1d6f013b2078140fb701978d720abecde7cd73f |
23,199 | QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
{
QEMUFile *f;
f = g_malloc0(sizeof(QEMUFile));
f->opaque = opaque;
f->ops = ops;
return f;
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
6,737 | static void iscsi_nop_timed_event(void *opaque)
{
IscsiLun *iscsilun = opaque;
aio_context_acquire(iscsilun->aio_context);
if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
error_report("iSCSI: NOP timeout. Reconnecting...");
iscsilun->request_timed_out = true;
... | false | qemu | d045c466d9e62b4321fadf586d024d54ddfd8bd4 |
19,464 | av_cold void INIT_FUNC(VP9DSPContext *dsp, int bitexact)
{
#if HAVE_YASM
int cpu_flags = av_get_cpu_flags();
#define init_lpf_8_func(idx1, idx2, dir, wd, bpp, opt) \
dsp->loop_filter_8[idx1][idx2] = ff_vp9_loop_filter_##dir##_##wd##_##bpp##_##opt
#define init_lpf_16_func(idx, dir, bpp, opt) \
dsp->... | true | FFmpeg | 235e76aeb877bd1b23c12e74588e86752e3dfbe7 |
662 | void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p)
{
if (p->len < 0) {
s->setup_state = SETUP_STATE_IDLE;
}
switch (s->setup_state) {
case SETUP_STATE_SETUP:
if (p->len < s->setup_len) {
s->setup_len = p->len;
}
s->setup_state = SETUP... | true | qemu | 4f4321c11ff6e98583846bfd6f0e81954924b003 |
23,598 | int nbd_client_init(BlockDriverState *bs, QIOChannelSocket *sioc,
const char *export, Error **errp)
{
NbdClientSession *client = nbd_get_client_session(bs);
int ret;
/* NBD handshake */
logout("session init %s\n", export);
qio_channel_set_blocking(QIO_CHANNEL(sioc), true... | false | qemu | 75822a12c046646684bc8cad6296842b60e7b6bb |
1,309 | void ppc_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
int flags)
{
#define RGPL 4
#define RFPL 4
PowerPCCPU *cpu = POWERPC_CPU(cs);
CPUPPCState *env = &cpu->env;
int i;
cpu_fprintf(f, "NIP " TARGET_FMT_lx " LR " TARGET_FMT_lx " CTR "
... | true | qemu | f2b70fded9b32c4b9e45e5b7f11bfc2ef961ede7 |
26,235 | static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov,
AVFormatContext *s)
{
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "ilst");
mov_write_string_metadata(s, pb, "\251nam", "title" , 1);
mov_write_string_metadata(s, ... | false | FFmpeg | 565e0c6d866ce08d4b06427456d3d1f4fd856e9c |
22,807 | static int nut_read_close(AVFormatContext *s)
{
NUTContext *nut = s->priv_data;
av_freep(&nut->time_base);
av_freep(&nut->stream);
return 0;
} | true | FFmpeg | 27dbc47c05e07486feba1ab829db584da2159648 |
26,068 | static int encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
uint8_t *buf, int nb_sectors, bool enc,
Error **errp)
{
union {
uint64_t ll[2];
uint8_t b[16];
} ivec;
int i;
int ret;
for(i = 0; i < nb_sectors; i++) {
... | false | qemu | d85f4222b4681da7ebf8a90b26e085a68fa2c55a |
17,212 | void msix_write_config(PCIDevice *dev, uint32_t addr,
uint32_t val, int len)
{
unsigned enable_pos = dev->msix_cap + MSIX_CONTROL_OFFSET;
int vector;
bool was_masked;
if (!range_covers_byte(addr, len, enable_pos)) {
return;
}
was_masked = dev->msix_fun... | true | qemu | ae392c416c69a020226c768d9c3af08b29dd6d96 |
15,433 | static char *SocketAddress_to_str(const char *prefix, SocketAddress *addr,
bool is_listen, bool is_telnet)
{
switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET:
return g_strdup_printf("%s%s:%s:%s%s", prefix,
is_telnet ? "telnet" : "... | false | qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa |
19,541 | static int bit_allocation(IMCContext *q, IMCChannel *chctx,
int stream_format_code, int freebits, int flag)
{
int i, j;
const float limit = -1.e20;
float highest = 0.0;
int indx;
int t1 = 0;
int t2 = 1;
float summa = 0.0;
int iacc = 0;
int summer = 0;
in... | true | FFmpeg | 87fb18c3e4fea70d264c49428a66f86baf048450 |
3,860 | static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt)
{
int num_formats = sizeof(schro_pixel_format_map) /
sizeof(schro_pixel_format_map[0]);
int idx;
for (idx = 0; idx < num_formats; ++idx)
if (schro_pixel_format_map[idx].schro_pix_fmt == schro_p... | true | FFmpeg | 220b24c7c97dc033ceab1510549f66d0e7b52ef1 |
10,784 | static int concat_read_packet(AVFormatContext *avf, AVPacket *pkt)
{
ConcatContext *cat = avf->priv_data;
int ret;
int64_t delta;
while (1) {
if ((ret = av_read_frame(cat->avf, pkt)) != AVERROR_EOF ||
(ret = open_next_file(avf)) < 0)
break;
}
delta = av_rescale_q(... | true | FFmpeg | aeccb522ebb6fb0378bccd6393f1d0c1ca40fdd4 |
14,564 | static void dec_sru(DisasContext *dc)
{
if (dc->format == OP_FMT_RI) {
LOG_DIS("srui r%d, r%d, %d\n", dc->r1, dc->r0, dc->imm5);
} else {
LOG_DIS("sru r%d, r%d, r%d\n", dc->r2, dc->r0, dc->r1);
}
if (dc->format == OP_FMT_RI) {
if (!(dc->features & LM32_FEATURE_SHIFT) &&... | false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 |
19,419 | static int rm_assemble_video_frame(AVFormatContext *s, ByteIOContext *pb,
RMDemuxContext *rm, RMStream *vst,
AVPacket *pkt, int len, int *pseq)
{
int hdr, seq, pic_num, len2, pos;
int type;
hdr = get_byte(pb); len--;
type = h... | true | FFmpeg | cbb5da57cdaf547e47253beef31ddf38d181252a |
13,471 | static void copy_context_reset(AVCodecContext *avctx)
{
av_opt_free(avctx);
av_freep(&avctx->rc_override);
av_freep(&avctx->intra_matrix);
av_freep(&avctx->inter_matrix);
av_freep(&avctx->extradata);
av_freep(&avctx->subtitle_header);
av_buffer_unref(&avctx->hw_frames_ctx);
avctx->subtit... | true | FFmpeg | cac8de2da5c4935773128335c11b806faa73e19d |
22,243 | static void versatile_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model,
int board_id)
{
CPUState *env;
ram_addr... | true | qemu | e6b3c8ca0222f6633516c0461a713e7bddc4f076 |
18,983 | int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
{
int i, count, ret, read_size, j;
AVStream *st;
AVPacket pkt1, *pkt;
int64_t old_offset = avio_tell(ic->pb);
int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
for(i=0... | false | FFmpeg | af08d9aeea870de017139f7b1c44b7d816cf8e56 |
6,089 | static int rtc_post_load(void *opaque, int version_id)
{
RTCState *s = opaque;
if (version_id <= 2 || rtc_clock == QEMU_CLOCK_REALTIME) {
rtc_set_time(s);
s->offset = 0;
check_update_timer(s);
}
uint64_t now = qemu_clock_get_ns(rtc_clock);
if (now < s->next_perio... | false | qemu | 1dfb1b2d34840dce27e672f147bc4ef122abab74 |
5,371 | static uint64_t l2x0_priv_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
uint32_t cache_data;
l2x0_state *s = (l2x0_state *)opaque;
offset &= 0xfff;
if (offset >= 0x730 && offset < 0x800) {
return 0; /* cache ops complete */
}
switc... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.