project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | 0 | static void test_visitor_in_wrong_type(TestInputVisitorData *data,
const void *unused)
{
TestStruct *p = NULL;
Visitor *v;
strList *q = NULL;
int64_t i;
Error *err = NULL;
/* Make sure arrays and structs cannot be confused */
v = visitor_in... | 23,231 |
qemu | a3fa1d78cbae2259491b17689812edcb643a3b30 | 0 | static int buffered_close(void *opaque)
{
MigrationState *s = opaque;
DPRINTF("closing\n");
s->xfer_limit = INT_MAX;
while (!qemu_file_get_error(s->file) && s->buffer_size) {
buffered_flush(s);
}
return migrate_fd_close(s);
}
| 23,232 |
qemu | 539de1246d355d3b8aa33fb7cde732352d8827c7 | 0 | static int blk_mig_save_bulked_block(Monitor *mon, QEMUFile *f)
{
int64_t completed_sector_sum = 0;
BlkMigDevState *bmds;
int progress;
int ret = 0;
QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
if (bmds->bulk_completed == 0) {
if (mig_save_device_bulk(mon... | 23,233 |
qemu | 46746dbaa8c2c421b9bda78193caad57d7fb1136 | 0 | static void vfio_msi_enable(VFIOPCIDevice *vdev)
{
int ret, i;
vfio_disable_interrupts(vdev);
vdev->nr_vectors = msi_nr_vectors_allocated(&vdev->pdev);
retry:
vdev->msi_vectors = g_malloc0(vdev->nr_vectors * sizeof(VFIOMSIVector));
for (i = 0; i < vdev->nr_vectors; i++) {
VFIOM... | 23,234 |
qemu | 0e9b9edae7bebfd31fdbead4ccbbce03876a7edd | 0 | build_madt(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info)
{
int madt_start = table_data->len;
const MemMapEntry *memmap = guest_info->memmap;
const int *irqmap = guest_info->irqmap;
AcpiMultipleApicTable *madt;
AcpiMadtGenericDistributor *gicd;
AcpiMadtGenericMsiFrame *gic... | 23,235 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val)
{
uint8_t *ptr;
MemoryRegionSection *section;
section = phys_page_find(address_space_memory.dispatch, addr >> TARGET_PAGE_BITS);
if (!memory_region_is_ram(section->mr) || section->readonly) {
addr = memory_region_section_add... | 23,236 |
qemu | 8ec14402029d783720f4312ed8a925548e1dad61 | 0 | static void compare_pri_rs_finalize(SocketReadState *pri_rs)
{
CompareState *s = container_of(pri_rs, CompareState, pri_rs);
if (packet_enqueue(s, PRIMARY_IN)) {
trace_colo_compare_main("primary: unsupported packet in");
compare_chr_send(s,
pri_rs->buf,
... | 23,238 |
FFmpeg | 3438d82d4b3bd987304975961e2a42e82767107d | 0 | static 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, ... | 23,239 |
qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | 0 | static void test_qemu_strtoul_overflow(void)
{
const char *str = "99999999999999999999999999999999999999999999";
char f = 'X';
const char *endptr = &f;
unsigned long res = 999;
int err;
err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
g_assert_cm... | 23,240 |
qemu | 036f7166c73a9e0cc1b2f10c03763e61894a1033 | 0 | int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
{
Property *prop;
int ret;
prop = qdev_prop_find(dev, name);
if (!prop) {
fprintf(stderr, "property \"%s.%s\" not found\n",
dev->info->name, name);
return -1;
}
if (!prop->info-... | 23,241 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | uint32_t ldub_phys(target_phys_addr_t addr)
{
uint8_t val;
cpu_physical_memory_read(addr, &val, 1);
return val;
}
| 23,242 |
qemu | b8e9fc0625c49404d63b4391f6dc5cf27be8b45b | 0 | static int get_physical_address_data(CPUState *env,
target_phys_addr_t *physical, int *prot,
target_ulong address, int rw, int mmu_idx)
{
unsigned int i;
uint64_t context;
int is_user = (mmu_idx == MMU_USER_IDX ||
... | 23,243 |
qemu | 5834a83f4803de88949162346e6dfa2060d3fca6 | 0 | static void vfio_pci_reset(DeviceState *dev)
{
PCIDevice *pdev = DO_UPCAST(PCIDevice, qdev, dev);
VFIODevice *vdev = DO_UPCAST(VFIODevice, pdev, pdev);
if (!vdev->reset_works) {
return;
}
if (ioctl(vdev->fd, VFIO_DEVICE_RESET)) {
error_report("vfio: Error unable to reset ... | 23,246 |
qemu | 3468b59e18b179bc63c7ce934de912dfa9596122 | 0 | void tcg_profile_snapshot(TCGProfile *prof, bool counters, bool table)
{
unsigned int i;
for (i = 0; i < n_tcg_ctxs; i++) {
const TCGProfile *orig = &tcg_ctxs[i]->prof;
if (counters) {
PROF_ADD(prof, orig, tb_count1);
PROF_ADD(prof, orig, tb_count);
... | 23,248 |
FFmpeg | bd31c61cf94d01dbe1051cf65874e7b2c0ac5454 | 0 | static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
{
char *pix_fmts;
OutputStream *ost = ofilter->ost;
OutputFile *of = output_files[ost->file_index];
AVFilterContext *last_filter = out->filter_ctx;
int pad_idx = out->pad_idx;
int ret;
... | 23,252 |
qemu | 77a10d04d033484a913a5ee76eed31a9acc57bae | 1 | static void vfio_exitfn(PCIDevice *pdev)
{
VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev);
VFIOGroup *group = vdev->vbasedev.group;
vfio_unregister_err_notifier(vdev);
pci_device_set_intx_routing_notifier(&vdev->pdev, NULL);
vfio_disable_interrupts(vdev);
if (vdev->intx.mmap... | 23,253 |
FFmpeg | 2caf19e90f270abe1e80a3e85acaf0eb5c9d0aac | 1 | static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
pixel *src = (pixel*)_src;
int stride = _stride/sizeof(pixel);
const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
((pixel4*)(src+0*stride))[0]=
((pixel4*)... | 23,254 |
FFmpeg | 5183fac92fc5c574a053dd06b84e735a1ec1cfa6 | 1 | static void decode_nal_sei_decoded_picture_hash(HEVCContext *s)
{
int cIdx, i;
uint8_t hash_type;
//uint16_t picture_crc;
//uint32_t picture_checksum;
GetBitContext *gb = &s->HEVClc->gb;
hash_type = get_bits(gb, 8);
for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3... | 23,255 |
FFmpeg | 801dbf0269b1bb5bc70c550e971491e0aea9eb70 | 0 | static av_cold void dcadec_flush(AVCodecContext *avctx)
{
DCAContext *s = avctx->priv_data;
ff_dca_core_flush(&s->core);
ff_dca_xll_flush(&s->xll);
ff_dca_lbr_flush(&s->lbr);
s->core_residual_valid = 0;
}
| 23,257 |
FFmpeg | 93c04e095dc37ebdab22174e88cfa91e24940866 | 0 | static int amf_parse_object(AVFormatContext *s, AVStream *astream,
AVStream *vstream, const char *key,
int64_t max_pos, int depth)
{
AVCodecContext *acodec, *vcodec;
FLVContext *flv = s->priv_data;
AVIOContext *ioc;
AMFDataType amf_type;
... | 23,258 |
FFmpeg | 955aec3c7c7be39b659197e1ec379a09f2b7c41c | 0 | static int check(AVIOContext *pb, int64_t pos, int64_t *out_pos)
{
MPADecodeHeader mh = { 0 };
int i;
uint32_t header;
int64_t off = 0;
for (i = 0; i < SEEK_PACKETS; i++) {
off = avio_seek(pb, pos + mh.frame_size, SEEK_SET);
if (off < 0)
break;
hea... | 23,261 |
FFmpeg | fd2982a0a01942091b2f08e17486ff4562f675a6 | 0 | int av_read_play(AVFormatContext *s)
{
if (s->iformat->read_play)
return s->iformat->read_play(s);
if (s->pb && s->pb->read_pause)
return av_url_read_fpause(s->pb, 0);
return AVERROR(ENOSYS);
}
| 23,262 |
FFmpeg | 4791a910c0dc3dd5861d38202457c9fb9bf1154c | 0 | int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
HEVCNAL *nal)
{
int i, si, di;
uint8_t *dst;
if (s)
nal->skipped_bytes = 0;
#define STARTCODE_TEST \
if (i + 2 < length && src[i + 1] =... | 23,264 |
FFmpeg | 1ec83d9a9e472f485897ac92bad9631d551a8c5b | 0 | static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
const uint8_t *buf, const uint8_t *end_buf)
{
unsigned tag, type, count, off, value = 0;
int i, j;
int ret;
uint32_t *pal;
const uint8_t *rp, *gp, *bp;
double *dp;
if (end_buf - buf < 12)
... | 23,265 |
FFmpeg | 3e0c78bac63c213649c3e8c2fa49e9f3c9848d5a | 0 | 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 ... | 23,266 |
FFmpeg | ec2694d25905c217e5815947cda896aa25398388 | 0 | static av_cold int g722_decode_init(AVCodecContext * avctx)
{
G722Context *c = avctx->priv_data;
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
return AVERROR_INVALIDDATA;
}
avctx->sample_fmt = AV_SAMPLE_FMT_S16;
c->band[0].sca... | 23,267 |
FFmpeg | b3f9f7a33337e9b64e6044b0010e2722fa0b2f9c | 0 | static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
{
AVFormatContext *s = ts->stream;
MpegTSFilter *tss;
int len, pid, cc, cc_ok, afc, is_start;
const uint8_t *p, *p_end;
int64_t pos;
pid = AV_RB16(packet + 1) & 0x1fff;
if(pid && discard_pid(ts, pid))
retur... | 23,268 |
FFmpeg | 03cef34aa66662e2ab3681d290e7c5a6634f4058 | 0 | static void buffer_release(void *opaque, uint8_t *data)
{
*(uint8_t*)opaque = 0;
}
| 23,269 |
FFmpeg | 63b737d4f9c118853a4f8d9af641335629bdf3ab | 0 | static void float_to_int16_3dnow(int16_t *dst, const float *src, int len){
// not bit-exact: pf2id uses different rounding than C and SSE
int i;
for(i=0; i<len; i+=4) {
asm volatile(
"pf2id %1, %%mm0 \n\t"
"pf2id %2, %%mm1 \n\t"
"packssdw %%mm1,... | 23,270 |
FFmpeg | 1ec83d9a9e472f485897ac92bad9631d551a8c5b | 0 | static int add_shorts_metadata(const uint8_t **buf, int count, const char *name,
const char *sep, TiffContext *s)
{
char *ap;
int i;
int *sp = av_malloc(count * sizeof(int));
if (!sp)
return AVERROR(ENOMEM);
for (i = 0; i < count; i++)
sp[i] ... | 23,271 |
FFmpeg | 15b219fae9da1691dfb264f51637805e1ca63d1a | 0 | int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
const uint8_t *mb_bitmask, const AVFrame *reference)
{
int len, nb_components, i, h, v, predictor, point_transform;
int index, id;
const int block_size= s->lossless ? 1 : 8;
int ilv, prev_shift;
/* XXX: verify len field ... | 23,272 |
FFmpeg | e1d5bbeb39501a3271c6422390d13bf9391872d1 | 0 | static int is_intra_more_likely(MpegEncContext *s){
int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;
if (!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) return 1; //no previous frame available -> use spatial prediction
undamaged_count=0;
for(i=0; i<s->mb_num; i++){
... | 23,273 |
qemu | d0bce760e04b1658a3b4ac95be2839ae20fd86db | 1 | I2CAdapter *omap_i2c_create(uint64_t addr)
{
OMAPI2C *s = g_malloc0(sizeof(*s));
I2CAdapter *i2c = (I2CAdapter *)s;
uint16_t data;
s->addr = addr;
i2c->send = omap_i2c_send;
i2c->recv = omap_i2c_recv;
/* verify the mmio address by looking for a known signature */
memread(a... | 23,275 |
FFmpeg | 84bc45880ae14277cb804569401ddd34274f4764 | 1 | void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
int nPbH, int log2_cb_size, int part_idx,
int merge_idx, MvField *mv,
int mvp_lx_flag, int LX)
{
HEVCLocalContext *lc = s->HEVClc;
MvField *tab_... | 23,276 |
qemu | 9745807191a81c45970f780166f44a7f93b18653 | 1 | static void gen_ove_cyov(DisasContext *dc, TCGv cy, TCGv ov)
{
if (dc->tb_flags & SR_OVE) {
TCGv t0 = tcg_temp_new();
tcg_gen_or_tl(t0, cy, ov);
gen_helper_ove(cpu_env, t0);
tcg_temp_free(t0);
}
}
| 23,278 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static void put_uint16(QEMUFile *f, void *pv, size_t size)
{
uint16_t *v = pv;
qemu_put_be16s(f, v);
}
| 23,280 |
FFmpeg | b12d92efd6c0d48665383a9baecc13e7ebbd8a22 | 1 | static int vqa_decode_chunk(VqaContext *s)
{
unsigned int chunk_type;
unsigned int chunk_size;
int byte_skip;
unsigned int index = 0;
int i;
unsigned char r, g, b;
int index_shift;
int res;
int cbf0_chunk = -1;
int cbfz_chunk = -1;
int cbp0_chunk = -1;
int ... | 23,281 |
FFmpeg | 8fb8d539a4c594a58df226bc1bd7a4d149f39424 | 1 | static int hls_read(URLContext *h, uint8_t *buf, int size)
{
HLSContext *s = h->priv_data;
const char *url;
int ret;
int64_t reload_interval;
start:
if (s->seg_hd) {
ret = ffurl_read(s->seg_hd, buf, size);
if (ret > 0)
return ret;
}
if (s->seg_hd) {
... | 23,282 |
FFmpeg | cec939597722663f322941b4c12e00a583e63504 | 1 | static inline void ff_h264_biweight_WxH_mmx2(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offsetd, int offsets, int w, int h)
{
int x, y;
int offset = ((offsets + offsetd + 1) | 1) << log2_denom;
asm volatile(
"movd %0, %%mm3 \n\t"
"mo... | 23,283 |
FFmpeg | 41ee459e88093a0b7ae13b8539ed9ccd0ebd0f0b | 1 | static int dpx_probe(AVProbeData *p)
{
const uint8_t *b = p->buf;
if (AV_RN32(b) == AV_RN32("SDPX") || AV_RN32(b) == AV_RN32("XPDS"))
return AVPROBE_SCORE_EXTENSION + 1;
return 0;
}
| 23,284 |
FFmpeg | b69c2e0e6dab87bb90fece1d0de47c28394aa8e6 | 1 | static int yop_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
YopDecContext *yop = s->priv_data;
int64_t frame_pos, pos_min, pos_max;
int frame_count;
av_free_packet(&yop->video_packet);
if (!stream_index)
return -1;
... | 23,285 |
FFmpeg | ded5957d75def70d2f1fc1c1eae079230004974b | 0 | 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)
return AV... | 23,287 |
qemu | 071d4054770205ddb8a58a9e2735069d8fe52af1 | 1 | void qdist_init(struct qdist *dist)
{
dist->entries = g_malloc(sizeof(*dist->entries));
dist->size = 1;
dist->n = 0;
}
| 23,288 |
qemu | d3392718e1fcf0859fb7c0774a8e946bacb8419c | 1 | void arm_v7m_cpu_do_interrupt(CPUState *cs)
{
ARMCPU *cpu = ARM_CPU(cs);
CPUARMState *env = &cpu->env;
uint32_t lr;
arm_log_exception(cs->exception_index);
/* For exceptions we just mark as pending on the NVIC, and let that
handle it. */
switch (cs->exception_index) {
ca... | 23,289 |
qemu | 563890c7c7e977842e2a35afe7a24d06d2103242 | 1 | static void socket_sendf(int fd, const char *fmt, va_list ap)
{
gchar *str;
size_t size, offset;
str = g_strdup_vprintf(fmt, ap);
size = strlen(str);
offset = 0;
while (offset < size) {
ssize_t len;
len = write(fd, str + offset, size - offset);
if (len == ... | 23,290 |
qemu | 04097f7c5957273c578f72b9bd603ba6b1d69e33 | 1 | int vhost_dev_init(struct vhost_dev *hdev, int devfd, bool force)
{
uint64_t features;
int r;
if (devfd >= 0) {
hdev->control = devfd;
} else {
hdev->control = open("/dev/vhost-net", O_RDWR);
if (hdev->control < 0) {
return -errno;
}
}
r = ... | 23,291 |
FFmpeg | c3ab0004ae4dffc32494ae84dd15cfaa909a7884 | 1 | static inline void RENAME(hcscale_fast)(SwsContext *c, int16_t *dst,
int dstWidth, const uint8_t *src1,
const uint8_t *src2, int srcW, int xInc)
{
#if ARCH_X86
#if COMPILE_TEMPLATE_MMX2
int32_t *filterPos = c->hChrFilterPos;
... | 23,293 |
FFmpeg | 2d09cdbaf2f449ba23d54e97e94bd97ca22208c6 | 1 | static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band,
IVITile *tile, AVCodecContext *avctx)
{
int x, y, mv_x, mv_y, mv_delta, offs, mb_offset,
mv_scale, blks_per_mb;
IVIMbInfo *mb, *ref_mb;
int row_offset = band->mb_size * band->pitch;... | 23,294 |
FFmpeg | 180a0b1bcb522dab0ad828d8efb9673a6531d534 | 1 | static void decode_nal_sei_frame_packing_arrangement(HEVCContext *s)
{
GetBitContext *gb = &s->HEVClc->gb;
int cancel, type, quincunx, content;
get_ue_golomb(gb); // frame_packing_arrangement_id
cancel = get_bits1(gb); // frame_packing_cancel_flag
if (cancel == 0... | 23,295 |
qemu | 70976a7926b42d87e0c575412b85a8f5c1e48fad | 1 | static int gdb_get_spe_reg(CPUState *env, uint8_t *mem_buf, int n)
{
if (n < 32) {
#if defined(TARGET_PPC64)
stl_p(mem_buf, env->gpr[n] >> 32);
#else
stl_p(mem_buf, env->gprh[n]);
#endif
return 4;
}
if (n == 33) {
stq_p(mem_buf, env->spe_acc);
return 8;
... | 23,296 |
qemu | 8b81bb3b069d4007bc44c8d5888d630b7f0b42ff | 1 | static void virtio_pci_device_unplugged(DeviceState *d)
{
PCIDevice *pci_dev = PCI_DEVICE(d);
VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
virtio_pci_stop_ioeventfd(proxy);
msix_uninit_exclusive_bar(pci_dev);
}
| 23,297 |
qemu | b36e391441906c36ed0856b69de84001860402bf | 1 | static int virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy)
{
int n;
if (!proxy->ioeventfd_started) {
return 0;
}
for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
if (!virtio_queue_get_num(proxy->vdev, n)) {
continue;
}
virtio_pci_set_host_notifier... | 23,300 |
qemu | 94fb0909645de18481cc726ee0ec9b5afa861394 | 1 | static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
{
int ret, clen;
s->zstream.avail_out = len;
s->zstream.next_out = buf;
while (s->zstream.avail_out > 0) {
if (s->zstream.avail_in == 0) {
if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
... | 23,301 |
FFmpeg | e977ca2645cc6b23589ddf97ab08861064ba8792 | 1 | void avfilter_free(AVFilterContext *filter)
{
int i;
AVFilterLink *link;
if (filter->filter->uninit)
filter->filter->uninit(filter);
for (i = 0; i < filter->input_count; i++) {
if ((link = filter->inputs[i])) {
if (link->src)
link->src->outputs[li... | 23,302 |
qemu | 21ef45d71221b4577330fe3aacfb06afad91ad46 | 1 | void gtk_display_init(DisplayState *ds)
{
GtkDisplayState *s = g_malloc0(sizeof(*s));
gtk_init(NULL, NULL);
ds->opaque = s;
s->ds = ds;
s->dcl.ops = &dcl_ops;
s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#if GTK_CHECK_VERSION(3, 2, 0)
s->vbox = gtk_box_new(GTK_ORIENTATION_... | 23,303 |
qemu | 21ef45d71221b4577330fe3aacfb06afad91ad46 | 1 | void vnc_display_init(DisplayState *ds)
{
VncDisplay *vs = g_malloc0(sizeof(*vs));
dcl = g_malloc0(sizeof(DisplayChangeListener));
ds->opaque = vs;
dcl->idle = 1;
vnc_display = vs;
vs->lsock = -1;
#ifdef CONFIG_VNC_WS
vs->lwebsock = -1;
#endif
vs->ds = ds;
QTAILQ_... | 23,304 |
FFmpeg | 078d43e23a7a3d64aafee8a58b380d3e139b3020 | 1 | static int mpegts_handle_packet(AVFormatContext *ctx, PayloadContext *data,
AVStream *st, AVPacket *pkt, uint32_t *timestamp,
const uint8_t *buf, int len, uint16_t seq,
int flags)
{
int ret;
// We don't want ... | 23,305 |
qemu | b3dd1b8c295636e64ceb14cdc4db6420d7319e38 | 1 | static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
{
MonFdset *mon_fdset;
MonFdsetFd *mon_fdset_fd_dup;
QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
if (mon_fdset_fd_dup->fd == dup_fd) {
... | 23,306 |
qemu | 6f2d8978728c48ca46f5c01835438508aace5c64 | 1 | static always_inline void powerpc_excp (CPUState *env,
int excp_model, int excp)
{
target_ulong msr, new_msr, vector;
int srr0, srr1, asrr0, asrr1;
#if defined(TARGET_PPC64H)
int lpes0, lpes1, lev;
lpes0 = (env->spr[SPR_LPCR] >> 1) & 1;
lpes1 = (env-... | 23,310 |
FFmpeg | c82b8ef0e4f226423ddd644bfe37e6a15d070924 | 1 | static void compute_default_clut(AVSubtitleRect *rect, int w, int h)
{
uint8_t list[256] = {0};
uint8_t list_inv[256];
int counttab[256] = {0};
int count, i, x, y;
#define V(x,y) rect->data[0][(x) + (y)*rect->linesize[0]]
for (y = 0; y<h; y++) {
for (x = 0; x<w; x++) {
... | 23,311 |
qemu | 0df93305f21712e975ab5df260cc5a91e5daafca | 1 | static void qcow_close(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
g_free(s->l1_table);
g_free(s->l2_cache);
g_free(s->cluster_cache);
g_free(s->cluster_data);
migrate_del_blocker(s->migration_blocker);
error_free(s->migration_blocker);
}
| 23,312 |
FFmpeg | 169c1cfa928040b83f2ac8386333ec5e5cff3df7 | 1 | static int pvf_read_header(AVFormatContext *s)
{
char buffer[32];
AVStream *st;
int bps, channels, sample_rate;
avio_skip(s->pb, 5);
ff_get_line(s->pb, buffer, sizeof(buffer));
if (sscanf(buffer, "%d %d %d",
&channels,
&sample_rate,
&bps) ... | 23,313 |
qemu | b20909195745c34a819aed14ae996b60ab0f591f | 1 | iscsi_readv_writev_bh_cb(void *p)
{
IscsiAIOCB *acb = p;
qemu_bh_delete(acb->bh);
if (!acb->canceled) {
acb->common.cb(acb->common.opaque, acb->status);
}
qemu_aio_release(acb);
if (acb->canceled) {
return;
}
scsi_free_scsi_task(acb->task);
acb->... | 23,315 |
qemu | 069ab0eb8a46bc4ff6f4d4d81bf037d3441347da | 1 | static void vmmouse_reset(DeviceState *d)
{
VMMouseState *s = container_of(d, VMMouseState, dev.qdev);
s->status = 0xffff;
s->queue_size = VMMOUSE_QUEUE_SIZE;
} | 23,317 |
FFmpeg | fac1ccbda1bb8441c7329a3ac18fbf04886da983 | 1 | static int doTest(uint8_t *ref[4], int refStride[4], int w, int h,
enum AVPixelFormat srcFormat, enum AVPixelFormat dstFormat,
int srcW, int srcH, int dstW, int dstH, int flags,
struct Results *r)
{
static enum AVPixelFormat cur_srcFormat;
static int c... | 23,318 |
qemu | 560f19f162529d691619ac69ed032321c7f5f1fb | 1 | char *object_property_get_str(Object *obj, const char *name,
Error **errp)
{
QObject *ret = object_property_get_qobject(obj, name, errp);
QString *qstring;
char *retval;
if (!ret) {
return NULL;
}
qstring = qobject_to_qstring(ret);
if (!qstri... | 23,319 |
qemu | 99787f69cdd8147d0be67d71ec3058cce21e2444 | 1 | ip_input(struct mbuf *m)
{
Slirp *slirp = m->slirp;
register struct ip *ip;
int hlen;
DEBUG_CALL("ip_input");
DEBUG_ARG("m = %p", m);
DEBUG_ARG("m_len = %d", m->m_len);
if (m->m_len < sizeof (struct ip)) {
return;
}
ip = mtod(m, struct ip *);
if (ip->ip_v != IPVERSION) {
goto bad;
}... | 23,320 |
FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 | 1 | static inline void RENAME(yuv2yuv1)(int16_t *lumSrc, int16_t *chrSrc,
uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW)
{
#ifdef HAVE_MMX
if(uDest != NULL)
{
asm volatile(
YSCALEYUV2YV121
:: "r" (chrSrc + chrDstW), "r" (uDest + chrDstW),
"g" ((long)-chrDstW)
: "... | 23,321 |
FFmpeg | 138902dfb60fbb87fb65a8c4800f8ac661394b72 | 1 | 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, &... | 23,322 |
FFmpeg | 932e6a5a4c78250e3cab4f65215214fb0dbf51f7 | 1 | static void quantize_bands(int (*out)[2], const float *in, const float *scaled,
int size, float Q34, int is_signed, int maxval)
{
int i;
double qc;
for (i = 0; i < size; i++) {
qc = scaled[i] * Q34;
out[i][0] = (int)FFMIN((int)qc, maxval);
... | 23,324 |
FFmpeg | df3b17eba47e635a694acb18b74e389194355f45 | 1 | av_cold int vaapi_device_init(const char *device)
{
int err;
err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI,
device, NULL, 0);
if (err < 0) {
av_log(&vaapi_log, AV_LOG_ERROR, "Failed to create a VAAPI device\n");
return err;
}
ret... | 23,325 |
qemu | a4e26048526d8d5b181f9a0a7d4f82b8441c5dfd | 1 | static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
PtyCharDriver *s;
struct termios tty;
int slave_fd, len;
#if defined(__OpenBSD__) || defined(__DragonFly__)
char pty_name[PATH_MAX];
#define q_ptsname(x) pty_name
#else
char *pty_name = NULL;
... | 23,326 |
FFmpeg | df037fe107ccfae4b26ee0e46b638b052f6e49f8 | 1 | static int smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
const AVPixFmtDescriptor *desc;
SMVJpegDecodeContext *s = avctx->priv_data;
AVFrame* mjpeg_data = s->picture[0];
int i, cur_frame = 0, ret = 0;
cur_frame = avpkt... | 23,327 |
qemu | a9a72aeefbd3ef8bcbbeeccaf174ee10db2978ac | 1 | static void tpm_display_backend_drivers(void)
{
int i;
fprintf(stderr, "Supported TPM types (choose only one):\n");
for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
fprintf(stderr, "%12s %s\n",
TpmType_lookup[be_drivers[i]->type], be_drivers[i]->desc());
... | 23,328 |
FFmpeg | 907783f221ad9594a528681e30777705f11bf0b5 | 0 | static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
{
int read = 0;
char key[20], value[1024], url[1024] = "";
uint32_t seq = 0, rtptime = 0;
for (;;) {
p += strspn(p, SPACE_CHARS);
if (!*p)
break;
get_word_sep(key, sizeof(key), "=", &p);
... | 23,329 |
FFmpeg | fd92dafaff8844b5fedf94679b93d953939a7f7b | 0 | static int bink_decode_plane(BinkContext *c, AVFrame *frame, BitstreamContext *bc,
int plane_idx, int is_chroma)
{
int blk, ret;
int i, j, bx, by;
uint8_t *dst, *prev, *ref_start, *ref_end;
int v, col[2];
const uint8_t *scan;
LOCAL_ALIGNED_16(int16_t, block, ... | 23,330 |
FFmpeg | 0c22311b56e66115675c4a96e4c78547886a4171 | 0 | static void opt_frame_pad_right(const char *arg)
{
frame_padright = atoi(arg);
if (frame_padright < 0) {
fprintf(stderr, "Incorrect right pad size\n");
av_exit(1);
}
}
| 23,331 |
FFmpeg | d1f558b3628d3ab99fd93a98b5758ef1be45a5da | 0 | static int dcadec_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
DCAContext *s = avctx->priv_data;
AVFrame *frame = data;
uint8_t *input = avpkt->data;
int input_size = avpkt->size;
int i, ret, prev_packet = s->packet;
... | 23,332 |
FFmpeg | 69e456d7fbc5fff88acf747d135bf15c8e511c59 | 0 | static int iszero(const int16_t *c, int sz)
{
int n;
for (n = 0; n < sz; n += 4)
if (AV_RN32A(&c[n]))
return 0;
return 1;
}
| 23,333 |
FFmpeg | 121d3875b692c83866928e271c4b6d20d680d1a6 | 0 | void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
unsigned int pts_num, unsigned int pts_den)
{
AVRational new_tb;
if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
if(new_tb.num != pts_num)
av_log(NULL, AV_LOG_DEBUG, "st:%d removing co... | 23,334 |
qemu | b308c82cbda44e138ef990af64d44a5613c16092 | 1 | static void pci_bridge_region_init(PCIBridge *br)
{
PCIBus *parent = br->dev.bus;
uint16_t cmd = pci_get_word(br->dev.config + PCI_COMMAND);
pci_bridge_init_alias(br, &br->alias_pref_mem,
PCI_BASE_ADDRESS_MEM_PREFETCH,
"pci_bridge_pref_mem",
... | 23,335 |
qemu | 8f2ad0a3fc5e3569183d44bf1c7fcb95294be4c0 | 1 | static void ecc_reset(void *opaque)
{
ECCState *s = opaque;
int i;
s->regs[ECC_MER] &= (ECC_MER_VER | ECC_MER_IMPL);
s->regs[ECC_MER] |= ECC_MER_MRR;
s->regs[ECC_MDR] = 0x20;
s->regs[ECC_MFSR] = 0;
s->regs[ECC_VCR] = 0;
s->regs[ECC_MFAR0] = 0x07c00000;
s->regs[ECC_MFAR1] ... | 23,336 |
qemu | 20c334a797bf46a4ee59a6e42be6d5e7c3cda585 | 1 | static inline int16_t mipsdsp_add_i16(int16_t a, int16_t b, CPUMIPSState *env)
{
int16_t tempI;
tempI = a + b;
if (MIPSDSP_OVERFLOW(a, b, tempI, 0x8000)) {
set_DSPControl_overflow_flag(1, 20, env);
}
return tempI;
}
| 23,337 |
qemu | d7dce494769e47c9a1eec6f55578d3acdfab888b | 1 | void cpu_loop(CPUMBState *env)
{
int trapnr, ret;
target_siginfo_t info;
while (1) {
trapnr = cpu_mb_exec (env);
switch (trapnr) {
case 0xaa:
{
info.si_signo = SIGSEGV;
info.si_errno = 0;
/* XXX: check env->... | 23,338 |
FFmpeg | 80bfce35ccd11458e97f68f417fc094c5347070c | 1 | static void RENAME(interleaveBytes)(const uint8_t *src1, const uint8_t *src2, uint8_t *dest,
int width, int height, int src1Stride,
int src2Stride, int dstStride)
{
int h;
for (h=0; h < height; h++) {
int w;
if (w... | 23,340 |
FFmpeg | 7c10068da10aa288195f5eb5d7e34eb2d8ff7447 | 1 | static int dvbsub_parse_page_segment(AVCodecContext *avctx,
const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubRegionDisplay *display;
DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;
const uint8_t *buf... | 23,341 |
FFmpeg | f80224ed19a4c012549fd460d529c7c04e68cf21 | 1 | static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s,
void *last, void *dst, int last2, int w,
int stride, int comp, int bits)
{
int i, x = 0;
int Ra, Rb, Rc, Rd;
int D0, D1, D2;
while (x < w) {
int err, pred... | 23,342 |
FFmpeg | 5484170ac729d739b2747979408f47bd9aa31c7c | 1 | static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
{
RV34DecContext *r = avctx->priv_data;
MpegEncContext *s = &r->s;
int got_picture = 0;
ff_er_frame_end(s);
ff_MPV_frame_end(s);
if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
ff_thread_repo... | 23,343 |
FFmpeg | 6029b8a6bbc8bbf7799108582e71078ec0bde1cf | 0 | static int s337m_probe(AVProbeData *p)
{
uint64_t state = 0;
int markers[3] = { 0 };
int i, sum, max, data_type, data_size, offset;
uint8_t *buf;
for (buf = p->buf; buf < p->buf + p->buf_size; buf++) {
state = (state << 8) | *buf;
if (!IS_LE_MARKER(state))
cont... | 23,345 |
FFmpeg | d1adad3cca407f493c3637e20ecd4f7124e69212 | 0 | static inline void RENAME(yuv2nv12X)(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
const int16_t *chrFilter, const int16_t **chrSrc, int chrFilterSize,
uint8_t *dest, uint8_t *uDest, int dstW, int chrDstW, ... | 23,346 |
qemu | 4f4321c11ff6e98583846bfd6f0e81954924b003 | 1 | static int usb_bt_handle_control(USBDevice *dev, USBPacket *p,
int request, int value, int index, int length, uint8_t *data)
{
struct USBBtState *s = (struct USBBtState *) dev->opaque;
int ret;
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
if (ret >= ... | 23,347 |
FFmpeg | 0d65e0f8cb0f924be95650f50f3d05d0b223aceb | 1 | int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
AVFilterBufferRef **picref_ptr, AVRational *tb)
{
int ret;
AVFilterBufferRef *picref;
if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
return ret;
if (!(picref = ctx->inputs[0]->cur_b... | 23,348 |
qemu | 3c99afc779c2c78718a565ad8c5e98de7c2c7484 | 1 | static int vmxnet3_post_load(void *opaque, int version_id)
{
VMXNET3State *s = opaque;
PCIDevice *d = PCI_DEVICE(s);
vmxnet_tx_pkt_init(&s->tx_pkt, s->max_tx_frags, s->peer_has_vhdr);
vmxnet_rx_pkt_init(&s->rx_pkt, s->peer_has_vhdr);
if (s->msix_used) {
if (!vmxnet3_use_msix_vectors(s, VMXN... | 23,349 |
FFmpeg | 3d9cb583c8f005a260d255853ef5f1c21e8599a0 | 1 | static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
int qsel, int is_chroma, int is_hqa)
{
const int32_t *q;
int val, pos = 1;
memset(block, 0, 64 * sizeof(*block));
if (!is_hqa) {
block[0] = get_sbits(gb, 9) * 64;
q = ff_... | 23,350 |
FFmpeg | af19f78f2fe2b969104d4419efd25fdee90a2814 | 0 | void dsputil_init_alpha(void)
{
put_pixels_tab[0][0] = put_pixels16_axp_asm;
put_pixels_tab[0][1] = put_pixels16_x2_axp;
put_pixels_tab[0][2] = put_pixels16_y2_axp;
put_pixels_tab[0][3] = put_pixels16_xy2_axp;
put_no_rnd_pixels_tab[0][0] = put_pixels16_axp_asm;
put_no_rnd_pixels_tab[0][... | 23,351 |
qemu | f35e44e7645edbb08e35b111c10c2fc57e2905c7 | 1 | address_space_translate_for_iotlb(CPUState *cpu, int asidx, hwaddr addr,
hwaddr *xlat, hwaddr *plen)
{
MemoryRegionSection *section;
AddressSpaceDispatch *d = cpu->cpu_ases[asidx].memory_dispatch;
section = address_space_translate_internal(d, addr, xlat, plen, false)... | 23,352 |
qemu | 187337f8b0ec0813dd3876d1efe37d415fb81c2e | 1 | static struct pxa2xx_fir_s *pxa2xx_fir_init(target_phys_addr_t base,
qemu_irq irq, struct pxa2xx_dma_state_s *dma,
CharDriverState *chr)
{
int iomemtype;
struct pxa2xx_fir_s *s = (struct pxa2xx_fir_s *)
qemu_mallocz(sizeof(struct pxa2xx_fir_s));
s->base =... | 23,353 |
qemu | 7fe7b68b32ba609faeeee03556aac0eb1b187c91 | 1 | static ssize_t nbd_co_receive_request(NBDRequest *req, struct nbd_request *request)
{
NBDClient *client = req->client;
int csock = client->sock;
ssize_t rc;
client->recv_coroutine = qemu_coroutine_self();
if (nbd_receive_request(csock, request) < 0) {
rc = -EIO;
goto out;
... | 23,355 |
qemu | 06b106889a09277617fc8c542397a9f595ee605a | 1 | ram_addr_t migration_bitmap_find_dirty(RAMState *rs, RAMBlock *rb,
ram_addr_t start,
ram_addr_t *ram_addr_abs)
{
unsigned long base = rb->offset >> TARGET_PAGE_BITS;
unsigned long nr = base + (start >> TARGET_PAGE_BITS);
uin... | 23,356 |
FFmpeg | fc3a03fcf9cd7eafe7342e2508e6128888efa0bb | 1 | AVFrame *ff_framequeue_take(FFFrameQueue *fq)
{
FFFrameBucket *b;
check_consistency(fq);
av_assert1(fq->queued);
b = bucket(fq, 0);
fq->queued--;
fq->tail++;
fq->tail &= fq->allocated - 1;
fq->total_frames_tail++;
fq->total_samples_tail += b->frame->nb_samples;
chec... | 23,357 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.