project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | 1359c2d43e8b13f09ad46526261fe00d7834d411 | 0 | static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
{
ASFContext *asf = s->priv_data;
ASFStream *asf_st = 0;
ByteIOContext *pb = &s->pb;
static int pc = 0;
for (;;) {
int rsize = 0;
if (asf->packet_size_left < FRAME_HEADER_SIZE
|| asf->packet_segments < 0) {
//asf->pa... | 15,322 |
FFmpeg | 7d49f79f1cd47783a963a757a6563b9cac29db62 | 0 | static int qdm2_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
QDM2Context *s = avctx->priv_data;
int16_t *out = data;
int i;
if(!buf)
return 0;
if(b... | 15,323 |
FFmpeg | 62eca2f827d441f52125191fd78c96b67a7ba30c | 0 | static av_cold int xcbgrab_read_header(AVFormatContext *s)
{
XCBGrabContext *c = s->priv_data;
int screen_num, ret;
const xcb_setup_t *setup;
char *display_name = av_strdup(s->filename);
if (s->filename) {
if (!display_name)
return AVERROR(ENOMEM);
if (!sscan... | 15,324 |
FFmpeg | 6ff6a51b863733f2a3a737cdbfe492fa9cefe16b | 0 | H264_CHROMA_MC(put_ , op_put)
H264_CHROMA_MC(avg_ , op_avg)
#undef op_avg
#undef op_put
#define H264_LOWPASS(OPNAME, OP, OP2) \
static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
const int h=2;\
INIT_CLIP\
int i;\
... | 15,325 |
FFmpeg | 13a099799e89a76eb921ca452e1b04a7a28a9855 | 0 | yuv2yuvX16_c_template(const int16_t *lumFilter, const int16_t **lumSrc,
int lumFilterSize, const int16_t *chrFilter,
const int16_t **chrUSrc, const int16_t **chrVSrc,
int chrFilterSize, const int16_t **alpSrc,
uint16_t *dest, ui... | 15,326 |
FFmpeg | 055a6aa76a84ced5bebf988ef67e22ac3c5763c5 | 0 | void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){
MpegEncContext * const s = &h->s;
int b8_stride = h->b8_stride;
int b4_stride = h->b_stride;
int mb_xy = h->mb_xy;
int mb_type_col[2];
const int16_t (*l1mv0)[2], (*l1mv1)[2];
const int8_t *l1ref0, *l1ref1;
cons... | 15,327 |
FFmpeg | 1181d93231e9b807965724587d363c1cfd5a1d0d | 0 | static void avc_luma_mid_and_aver_dst_4x4_msa(const uint8_t *src,
int32_t src_stride,
uint8_t *dst, int32_t dst_stride)
{
v16i8 src0, src1, src2, src3, src4;
v16i8 mask0, mask1, mask2;
v8i16 hz_out0, hz_out1, h... | 15,328 |
FFmpeg | b297c881d6b968bbb2bb7a3a0979429ee03b594c | 0 | static av_always_inline void dnxhd_decode_dct_block(DNXHDContext *ctx,
DCTELEM *block, int n,
int qscale,
int index_bits,
... | 15,329 |
FFmpeg | daece4c6745b42e8b1e171fb4bf485d5d64fc53f | 0 | static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
{
VideoState *is;
is = av_mallocz(sizeof(VideoState));
if (!is)
return NULL;
av_strlcpy(is->filename, filename, sizeof(is->filename));
is->iformat = iformat;
is->ytop = 0;
is->xleft = 0;
... | 15,331 |
FFmpeg | 3e1507a9547ac09b6ff4372123cde09f19218f3d | 0 | int ff_mjpeg_encode_stuffing(MpegEncContext *s)
{
int i;
PutBitContext *pbc = &s->pb;
int mb_y = s->mb_y - !s->mb_x;
int ret;
MJpegContext *m;
m = s->mjpeg_ctx;
if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
ff_mjpeg_build_optimal_huffman(m);
// Replace the VLCs w... | 15,332 |
FFmpeg | 0ccabeeaef77e240f2a44f78271a8914a23e239b | 0 | void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
{
void (*start_frame)(AVFilterLink *, AVFilterBufferRef *);
AVFilterPad *dst = link->dstpad;
FF_DPRINTF_START(NULL, start_frame); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " "); ff_dprintf_ref(NULL, picref, 1);
if (!(s... | 15,333 |
FFmpeg | bf1945af301aff54c33352e75f17aec6cb5269d7 | 0 | static void decorrelation(PSContext *ps, float (*out)[32][2], const float (*s)[32][2], int is34)
{
float power[34][PS_QMF_TIME_SLOTS] = {{0}};
float transient_gain[34][PS_QMF_TIME_SLOTS];
float *peak_decay_nrg = ps->peak_decay_nrg;
float *power_smooth = ps->power_smooth;
float *peak_decay_diff... | 15,334 |
FFmpeg | 8692e6284f5169257a537c8fc25addf32fc67c87 | 0 | rdt_new_context (void)
{
PayloadContext *rdt = av_mallocz(sizeof(PayloadContext));
int ret = avformat_open_input(&rdt->rmctx, "", &ff_rdt_demuxer, NULL);
if (ret < 0) {
av_free(rdt);
return NULL;
}
return rdt;
}
| 15,335 |
qemu | a8b42a1c09e751b9f921a1a73756411fc118020b | 0 | void bdrv_img_create(const char *filename, const char *fmt,
const char *base_filename, const char *base_fmt,
char *options, uint64_t img_size, int flags, bool quiet,
Error **errp)
{
QemuOptsList *create_opts = NULL;
QemuOpts *opts = NULL;
... | 15,336 |
qemu | d1b4259f1ab18af24e6a297edb6a8f71691f3256 | 0 | static void virtio_ccw_post_plugged(DeviceState *d, Error **errp)
{
VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
if (!virtio_host_has_feature(vdev, VIRTIO_F_VERSION_1)) {
/* A backend didn't support modern virtio. */
dev->max_rev = 0... | 15,338 |
qemu | b3ceef24f4fee8d5ed96b8c4a5d3e80c0a651f0b | 0 | static void sun4m_load_kernel(long vram_size, int ram_size, int boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
int machine_id)
{
int ret, ... | 15,339 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void gen_srq(DisasContext *ctx)
{
int l1 = gen_new_label();
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1F);
tcg_gen_shr_tl(t0, cpu_gpr[rS(ctx->opcode)], t1);
tcg_gen_subfi_tl(t1, 32, t1);
tcg_gen_shl_tl(t1, cpu_gpr[rS(ct... | 15,340 |
qemu | 81ffbf5ab1458e357a761f1272105a55829b351e | 0 | static void local_mapped_file_attr(int dirfd, const char *name,
struct stat *stbuf)
{
FILE *fp;
char buf[ATTR_MAX];
int map_dirfd;
map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
if (map_dirfd == -1) {
return;
}
fp = local_fopenat(map_... | 15,342 |
qemu | c650c008e326f3a1e84083bc269265456057a212 | 0 | static int save_user_regs(CPUPPCState *env, struct target_mcontext *frame,
int sigret)
{
target_ulong msr = env->msr;
int i;
target_ulong ccr = 0;
/* In general, the kernel attempts to be intelligent about what it
needs to save for Altivec/FP/SPE registers. We ... | 15,343 |
FFmpeg | aec8f88a9eb0ef8d684a2e76a152c9090da4af51 | 0 | static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code, int frame_type){
AVFormatContext *s= nut->avf;
StreamContext *stream;
ByteIOContext *bc = &s->pb;
int size, flags, size_mul, size_lsb, stream_id;
int key_frame = 0;
int64_t pts = 0;
const int prefix_len= frame_typ... | 15,344 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void dec_sr(DisasContext *dc)
{
if (dc->format == OP_FMT_RI) {
LOG_DIS("sri r%d, r%d, %d\n", dc->r1, dc->r0, dc->imm5);
} else {
LOG_DIS("sr r%d, r%d, r%d\n", dc->r2, dc->r0, dc->r1);
}
/* The real CPU (w/o hardware shifter) only supports right shift by exactly
* on... | 15,345 |
qemu | 7ce21016b69b512bf4777965a4292318f2bc7544 | 0 | static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
{
int ret = -EOPNOTSUPP;
BDRVRawState *s = aiocb->bs->opaque;
if (s->has_discard == 0) {
return 0;
}
if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
#ifdef BLKDISCARD
do {
uint64_t range[2] = { aiocb->aio_... | 15,346 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | void AUD_register_card (const char *name, QEMUSoundCard *card)
{
audio_init ();
card->name = qemu_strdup (name);
memset (&card->entries, 0, sizeof (card->entries));
LIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries);
}
| 15,347 |
qemu | 8e099d14f5233f330c4a6f03ff655219cd789c8f | 0 | static void rtc_get_date(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
Error *err = NULL;
RTCState *s = MC146818_RTC(obj);
struct tm current_tm;
rtc_update_time(s);
rtc_get_time(s, ¤t_tm);
visit_start_struct(v, NULL, "struct tm"... | 15,348 |
qemu | cfde4bd93100c58c0bfaed76deefb144caac488f | 0 | static inline void tlb_set_dirty(CPUState *env, target_ulong vaddr)
{
int i;
vaddr &= TARGET_PAGE_MASK;
i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
tlb_set_dirty1(&env->tlb_table[0][i], vaddr);
tlb_set_dirty1(&env->tlb_table[1][i], vaddr);
#if (NB_MMU_MODES >= 3)
tlb_set_dirt... | 15,349 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | ioapic_mem_write(void *opaque, target_phys_addr_t addr, uint64_t val,
unsigned int size)
{
IOAPICCommonState *s = opaque;
int index;
switch (addr & 0xff) {
case IOAPIC_IOREGSEL:
s->ioregsel = val;
break;
case IOAPIC_IOWIN:
if (size != 4) {
... | 15,350 |
qemu | 347ed55cd109864b02dd29bb7e6cda1622e8019e | 0 | int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
int ret;
#ifdef CONFIG_ACCEPT4
ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
if (ret != -1 || errno != EINVAL) {
return ret;
}
#endif
ret = accept(s, addr, addrlen);
if (ret >= 0) {
qemu_set_cloexec... | 15,351 |
qemu | fd56e0612b6454a282fa6a953fdb09281a98c589 | 0 | static void ich9_lpc_config_write(PCIDevice *d,
uint32_t addr, uint32_t val, int len)
{
ICH9LPCState *lpc = ICH9_LPC_DEVICE(d);
uint32_t rcba_old = pci_get_long(d->config + ICH9_LPC_RCBA);
pci_default_write_config(d, addr, val, len);
if (ranges_overlap(addr, len... | 15,352 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t omap_mpui_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
if (size != 4) {
return omap_badwidth_read32(opaque, addr);
}
switch (addr) {
case 0x00: /* CTRL ... | 15,353 |
qemu | f22d85e9e67262db34504f4079745f9843da6a92 | 0 | GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
{
return guest_fsfreeze_state.status;
}
| 15,354 |
FFmpeg | 4e93f00b06d9623ea9639ba7185cdacdf11c2672 | 0 | static av_cold int nvenc_setup_surfaces(AVCodecContext *avctx)
{
NvencContext *ctx = avctx->priv_data;
int i, res;
ctx->surfaces = av_mallocz_array(ctx->nb_surfaces, sizeof(*ctx->surfaces));
if (!ctx->surfaces)
return AVERROR(ENOMEM);
ctx->timestamp_list = av_fifo_alloc(ctx->nb_su... | 15,355 |
qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 | 0 | static void do_transmit_packets(dp8393xState *s)
{
uint16_t data[12];
int width, size;
int tx_len, len;
uint16_t i;
width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
while (1) {
/* Read memory */
DPRINTF("Transmit packet at %08x\n",
(s->regs[SONIC... | 15,357 |
FFmpeg | 875efafac8afe22971c87fc7dfee83d27364ab50 | 0 | static void msrle_decode_pal8(MsrleContext *s)
{
int stream_ptr = 0;
unsigned char rle_code;
unsigned char extra_byte;
unsigned char stream_byte;
int pixel_ptr = 0;
int row_dec = s->frame.linesize[0];
int row_ptr = (s->avctx->height - 1) * row_dec;
int frame_size = row_dec * s->... | 15,359 |
FFmpeg | 979bea13003ef489d95d2538ac2fb1c26c6f103b | 0 | static int rv30_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
{
int i, j, k;
for(i = 0; i < 4; i++, dst += r->intra_types_stride - 4){
for(j = 0; j < 4; j+= 2){
int code = svq3_get_ue_golomb(gb) << 1;
if(code >= 81*2){
av_log(r->s.... | 15,360 |
FFmpeg | 64d779f2f7607070a87b0a70edeba5e51834ce85 | 0 | static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
if(bit == ((*state)&1)){
c->range -= RangeLPS;
*state= ff_h264_mps_state[*state];
}else{
c->low += c->range - RangeLPS;
c->range = Ran... | 15,361 |
FFmpeg | aa926a480f2f84a87dc1fbf42d40fe23bae82ae1 | 0 | static int wv_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
ByteIOContext *pb = s->pb;
WVContext *wc = s->priv_data;
AVStream *st;
if(wv_read_block_header(s, pb) < 0)
return -1;
wc->block_parsed = 0;
/* now we are ready: build format str... | 15,362 |
FFmpeg | 86dfcfd0e30d6645eea2c63c1c60a0550e7c97ea | 1 | static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
return ff_mov_read_esds(c->fc, pb, atom);
}
| 15,363 |
qemu | 12d4536f7d911b6d87a766ad7300482ea663cea2 | 1 | void qemu_cpu_kick_self(void)
{
#ifndef _WIN32
assert(cpu_single_env);
raise(SIG_IPI);
#else
abort();
#endif
}
| 15,364 |
qemu | ff4b91c2f7e51dab148aba4bf43c2f39f219e495 | 1 | static uint64_t get_cluster_offset(BlockDriverState *bs,
uint64_t offset, int *num)
{
BDRVQcowState *s = bs->opaque;
int l1_index, l2_index;
uint64_t l2_offset, *l2_table, cluster_offset;
int l1_bits, c;
int index_in_cluster, nb_available, nb_needed, nb_clus... | 15,365 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | bool migration_has_finished(MigrationState *s)
{
return s->state == MIG_STATE_COMPLETED;
}
| 15,366 |
qemu | f3c7d0389fe8a2792fd4c1cf151b885de03c8f62 | 1 | static void microdrive_realize(DeviceState *dev, Error **errp)
{
MicroDriveState *md = MICRODRIVE(dev);
ide_init2(&md->bus, qemu_allocate_irqs(md_set_irq, md, 1)[0]);
}
| 15,367 |
FFmpeg | 2c9a5172d328259c5d76e588f2ddc12f439ffcd0 | 1 | static int decode_tsw1(uint8_t *frame, int width, int height,
const uint8_t *src, const uint8_t *src_end)
{
const uint8_t *frame_start = frame;
const uint8_t *frame_end = frame + width * height;
int mask = 0x10000, bitbuf = 0;
int v, offset, count, segments;
segment... | 15,369 |
qemu | 0a73336d96397c80881219d080518fac6f1ecacb | 1 | static CharDriverState *net_vhost_parse_chardev(
const NetdevVhostUserOptions *opts, Error **errp)
{
CharDriverState *chr = qemu_chr_find(opts->chardev);
VhostUserChardevProps props;
if (chr == NULL) {
error_setg(errp, "chardev \"%s\" not found", opts->chardev);
return NULL;
... | 15,370 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static int qemu_rdma_drain_cq(QEMUFile *f, RDMAContext *rdma)
{
int ret;
if (qemu_rdma_write_flush(f, rdma) < 0) {
return -EIO;
}
while (rdma->nb_sent) {
ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE, NULL);
if (ret < 0) {
fprintf(stderr, "rdm... | 15,371 |
FFmpeg | 3a1a7e32ace7af47de74e8ae779cb4e04c89aa97 | 1 | static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
{
int res;
HuffContext huff;
HuffContext tmp1, tmp2;
VLC vlc[2];
int escapes[3];
DBCtx ctx;
tmp1.length = 256;
tmp1.maxlength = 0;
tmp1.current = 0;
tmp1.bits = av_mal... | 15,372 |
qemu | 4cae9c97967a0e6311858285a30c44208210b277 | 1 | static void get_seg(SegmentCache *lhs, const struct kvm_segment *rhs)
{
lhs->selector = rhs->selector;
lhs->base = rhs->base;
lhs->limit = rhs->limit;
lhs->flags = (rhs->type << DESC_TYPE_SHIFT) |
(rhs->present * DESC_P_MASK) |
(rhs->dpl << DESC_DPL_SHIFT) |
... | 15,374 |
FFmpeg | d600b18f224e02f8bfc6660bfa442e7ff3fb057c | 1 | int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
{
int i, j;
int64_t last = st->info->last_dts;
if( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
&& ts - (uint64_t)last < INT64_MAX){
double dts= (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q... | 15,375 |
qemu | 8617343faae6ba7e916137c6c9e3ef22c00565d8 | 1 | static int vhost_verify_ring_mappings(struct vhost_dev *dev,
uint64_t start_addr,
uint64_t size)
{
int i;
for (i = 0; i < dev->nvqs; ++i) {
struct vhost_virtqueue *vq = dev->vqs + i;
hwaddr l;
void *p;
... | 15,376 |
FFmpeg | f4b30beac0c1a70d6da1e3ffe1e74e9e55397d8e | 1 | static av_cold int vc2_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet)
{
int ret = 0;
int sig_size = 256;
VC2EncContext *s = avctx->priv_data;
const char aux_data[] = LIBAVCODEC_IDENT;
const int aux_data_size = ... | 15,377 |
FFmpeg | 6bd665b7c5798803366b877903fa3bce7f129d05 | 0 | int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
TAKStreamInfo *ti, int log_level_offset)
{
if (get_bits(gb, TAK_FRAME_HEADER_SYNC_ID_BITS) != TAK_FRAME_HEADER_SYNC_ID) {
av_log(avctx, AV_LOG_ERROR + log_level_offset, "missing sync id\n");
... | 15,378 |
FFmpeg | eea064aea610ea41b5bda0b62dac56be536af9aa | 0 | static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,
const uint8_t **srcbuf, int buf_size,
int non_mod, uint8_t *map_table)
{
GetBitContext gb;
int bits;
int run_length;
int pixels_read = 0;
init_get_bits... | 15,379 |
FFmpeg | 9937362c54be085e75c90c55dad443329be59e69 | 0 | D(float, sse)
D(float, avx)
D(int16, mmx)
D(int16, sse2)
av_cold void swri_rematrix_init_x86(struct SwrContext *s){
int mm_flags = av_get_cpu_flags();
int nb_in = av_get_channel_layout_nb_channels(s->in_ch_layout);
int nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);
int num =... | 15,380 |
FFmpeg | 5c720657c23afd798ae0db7c7362eb859a89ab3d | 1 | static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
return AVERROR_INVALIDDATA;
if (st->codec->codec_id == AV_CODEC_ID_QD... | 15,381 |
qemu | 456d60692310e7ac25cf822cc1e98192ad636ece | 1 | static void rng_egd_finalize(Object *obj)
{
RngEgd *s = RNG_EGD(obj);
if (s->chr) {
qemu_chr_add_handlers(s->chr, NULL, NULL, NULL, NULL);
}
g_free(s->chr_name);
rng_egd_free_requests(s);
} | 15,382 |
FFmpeg | 9afb7061f938831248942050cfdb449e014ed427 | 1 | static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
if (atom.size < 16)
return 0;
ff_mov_read_chan(c->fc, st, atom.size - 4);
return 0;
}
| 15,383 |
qemu | 3c2daac0b98952a858277878cb11294256b39e43 | 1 | static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
uint64_t sector, size_t size)
{
if (sector & dev->sector_mask) {
if (size % dev->conf->logical_block_size) {
return true; | 15,384 |
FFmpeg | b5f45208fbe5373c7f9112a8169933b73a8478e1 | 1 | static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
{
BC_STATUS ret;
BC_DTS_STATUS decoder_status = { 0, };
CopyRet rec_ret;
CHDContext *priv = avctx->priv_data;
HANDLE dev = priv->dev;
uint8_t *in_data = avpkt->data;
int len =... | 15,385 |
FFmpeg | 0ecca7a49f8e254c12a3a1de048d738bfbb614c6 | 1 | static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb)
{
Vp3DecodeContext *s = avctx->priv_data;
int major, minor, micro;
major = get_bits(&gb, 8); /* version major */
minor = get_bits(&gb, 8); /* version minor */
micro = get_bits(&gb, 8); /* version micro */
av_log(avctx, AV_L... | 15,386 |
qemu | f65ed4c1529f29a7d62d6733eaa50bed24a4b2ed | 1 | static void pci_update_mappings(PCIDevice *d)
{
PCIIORegion *r;
int cmd, i;
uint32_t last_addr, new_addr, config_ofs;
cmd = le16_to_cpu(*(uint16_t *)(d->config + PCI_COMMAND));
for(i = 0; i < PCI_NUM_REGIONS; i++) {
r = &d->io_regions[i];
if (i == PCI_ROM_SLOT) {
... | 15,387 |
qemu | 7061a078984ba7d08b8b80686ad98c5162e56fbd | 1 | static int make_completely_empty(BlockDriverState *bs)
{
BDRVQcow2State *s = bs->opaque;
int ret, l1_clusters;
int64_t offset;
uint64_t *new_reftable = NULL;
uint64_t rt_entry, l1_size2;
struct {
uint64_t l1_offset;
uint64_t reftable_offset;
uint32_t reftable_cl... | 15,390 |
qemu | 0280b3eb7c0519b43452c05cf51f8777d9e38975 | 1 | bool gs_allowed(void)
{
/* for "none" machine this results in true */
return get_machine_class()->gs_allowed;
}
| 15,391 |
qemu | 9bd2b08f27b9c27bb40d73b6466321b8c635086e | 1 | void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
Error **errp)
{
AioContext *aio_context;
BlockDriverState *bs;
BdrvDirtyBitmap *bitmap;
bitmap = block_dirty_bitmap_lookup(node, name, &bs, &aio_context, errp);
if (!bitmap || !bs) {
... | 15,392 |
FFmpeg | 57d77b3963ce1023eaf5ada8cba58b9379405cc8 | 0 | void av_opencl_uninit(void)
{
cl_int status;
int i;
LOCK_OPENCL
gpu_env.init_count--;
if (gpu_env.is_user_created)
goto end;
if ((gpu_env.init_count > 0) || (gpu_env.kernel_count > 0))
goto end;
for (i = 0; i < gpu_env.program_count; i++) {
if (gpu_env.prog... | 15,393 |
qemu | c5b934303cf83fe3dda31e8d3e5778458c8a9eeb | 1 | static void s390_cpu_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
MachineState *ms = MACHINE(hotplug_dev);
S390CPU *cpu = S390_CPU(dev);
g_assert(!ms->possible_cpus->cpus[cpu->env.core_id].cpu);
ms->possible_cpus->cpus[cpu->env.core_id].cpu = OBJECT(dev); | 15,394 |
qemu | b2d1fe67d09d2b6c7da647fbcea6ca0148c206d3 | 1 | static void usbredir_handle_data(USBDevice *udev, USBPacket *p)
{
USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
uint8_t ep;
ep = p->ep->nr;
if (p->pid == USB_TOKEN_IN) {
ep |= USB_DIR_IN;
}
switch (dev->endpoint[EP2I(ep)].type) {
case USB_ENDPOINT_XFER_CONT... | 15,395 |
qemu | 5706db1deb061ee9affdcea81e59c4c2cad7c41e | 1 | static int sdl_init_out (HWVoiceOut *hw, struct audsettings *as)
{
SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
SDLAudioState *s = &glob_sdl;
SDL_AudioSpec req, obt;
int endianness;
int err;
audfmt_e effective_fmt;
struct audsettings obt_as;
req.freq = as->freq;
req.format = au... | 15,396 |
FFmpeg | 2fbc759d08cae97f9361e464a685a149c9d12c72 | 1 | static int dirac_probe(AVProbeData *p)
{
if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
return AVPROBE_SCORE_MAX;
else
return 0;
}
| 15,398 |
FFmpeg | 323e6fead07c75f418e4b60704a4f437bb3483b2 | 1 | static void apply_mdct(AC3EncodeContext *s)
{
int blk, ch;
for (ch = 0; ch < s->channels; ch++) {
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
AC3Block *block = &s->blocks[blk];
const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
... | 15,399 |
FFmpeg | 5331773cc33ba26b9e26ace643d926219e46a17b | 0 | static void read_id3(AVFormatContext *s, uint64_t id3pos)
{
ID3v2ExtraMeta *id3v2_extra_meta = NULL;
if (avio_seek(s->pb, id3pos, SEEK_SET) < 0)
return;
ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
if (id3v2_extra_meta)
ff_id3v2_parse_apic(s, &id3v2_extra_meta);
... | 15,400 |
FFmpeg | 9cf0419bb1a2cf929dcf458d435ae3c3bfb5d3ab | 0 | static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
if((uint64_t)atom.size > (1<<30))
return -1;
if (st->codec->codec_id == CODEC_ID_QDM2) {
// pass all frma atom to codec, needed at least for QDM2
... | 15,402 |
qemu | 40ff6d7e8dceca227e7f8a3e8e0d58b2c66d19b4 | 1 | static void unix_accept_incoming_migration(void *opaque)
{
struct sockaddr_un addr;
socklen_t addrlen = sizeof(addr);
int s = (unsigned long)opaque;
QEMUFile *f;
int c, ret;
do {
c = accept(s, (struct sockaddr *)&addr, &addrlen);
} while (c == -1 && socket_error() == EINTR... | 15,404 |
qemu | 0d6ae94783b35a5c42d88872d1adb523f5fcc6f3 | 1 | int qemu_uuid_parse(const char *str, QemuUUID *uuid)
{
unsigned char *uu = &uuid->data[0];
int ret;
if (strlen(str) != 36) {
return -1;
}
ret = sscanf(str, UUID_FMT, &uu[0], &uu[1], &uu[2], &uu[3],
&uu[4], &uu[5], &uu[6], &uu[7], &uu[8], &uu[9],
... | 15,405 |
FFmpeg | d8f3b0fb584677d4882e3a2d7c28f8b15c7319f5 | 1 | static int targa_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *p, int *got_packet)
{
TargaContext *s = avctx->priv_data;
int bpp, picsize, datasize = -1, ret;
uint8_t *out;
if(avctx->width > 0xffff || avctx->height > 0xffff) {
av_log(avc... | 15,406 |
FFmpeg | c23acbaed40101c677dfcfbbfe0d2c230a8e8f44 | 1 | static void vp8_idct_dc_add_c(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride)
{
int i, dc = (block[0] + 4) >> 3;
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP + dc;
block[0] = 0;
for (i = 0; i < 4; i++) {
dst[0] = cm[dst[0]];
dst[1] = cm[dst[1]];
dst[2] = cm[dst[2]];
... | 15,407 |
FFmpeg | eeb48353abaab335a1fc9cc448a5691330325a09 | 1 | static av_cold void set_bandwidth(AC3EncodeContext *s)
{
int blk, ch, cpl_start;
if (s->cutoff) {
/* calculate bandwidth based on user-specified cutoff frequency */
int fbw_coeffs;
fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
s->bandwidth_code = av_cl... | 15,408 |
qemu | 34779e8c3991f7fcd74b2045478abcef67dbeb15 | 1 | static void test_tco_defaults(void)
{
TestData d;
d.args = NULL;
d.noreboot = true;
test_init(&d);
g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_bar, TCO_RLD), ==,
TCO_RLD_DEFAULT);
/* TCO_DAT_IN & TCO_DAT_OUT */
g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_ba... | 15,409 |
FFmpeg | 636ced8e1dc8248a1353b416240b93d70ad03edb | 1 | static void print_sdp(void)
{
char sdp[16384];
int i;
AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
if (!avc)
exit(1);
for (i = 0; i < nb_output_files; i++)
avc[i] = output_files[i]->ctx;
av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
... | 15,410 |
qemu | a97d6fe6fbb97630d77253d20bdce78f76d01850 | 0 | static void pc_xen_hvm_init(QEMUMachineInitArgs *args)
{
if (xen_hvm_init() != 0) {
hw_error("xen hardware virtual machine initialisation failed");
}
pc_init_pci(args);
}
| 15,412 |
qemu | 5d47e3728bbd589701f74bb494c9c9825ba23c88 | 0 | static void cond_broadcast(pthread_cond_t *cond)
{
int ret = pthread_cond_broadcast(cond);
if (ret) die2(ret, "pthread_cond_broadcast");
}
| 15,413 |
qemu | 245f7b51c0ea04fb2224b1127430a096c91aee70 | 0 | void vnc_tight_clear(VncState *vs)
{
int i;
for (i=0; i<ARRAY_SIZE(vs->tight_stream); i++) {
if (vs->tight_stream[i].opaque) {
deflateEnd(&vs->tight_stream[i]);
}
}
buffer_free(&vs->tight);
buffer_free(&vs->tight_zlib);
buffer_free(&vs->tight_gradient);
#... | 15,414 |
qemu | a66c9dc734fb30de1e18e9dc217f2d37e16c492a | 0 | static void default_drive(int enable, int snapshot, BlockInterfaceType type,
int index, const char *optstr)
{
QemuOpts *opts;
if (!enable || drive_get_by_index(type, index)) {
return;
}
opts = drive_add(type, index, NULL, optstr);
if (snapshot) {
... | 15,415 |
qemu | 544d1afa7013fce155f5afbbc24737f2fc0c0f26 | 0 | static void gic_set_irq(void *opaque, int irq, int level)
{
gic_state *s = (gic_state *)opaque;
/* The first external input line is internal interrupt 32. */
irq += GIC_INTERNAL;
if (level == GIC_TEST_LEVEL(irq, ALL_CPU_MASK))
return;
if (level) {
GIC_SET_LEVEL(irq, ALL_CP... | 15,416 |
qemu | 8dfbaa6ac450c4ec2646b1ca08a4017052a90c1d | 0 | static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev)
{
VirtIODevice *vdev;
int n, r;
if (!dev->ioeventfd_started) {
return;
}
vdev = virtio_bus_get_device(&dev->bus);
for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
if (!virtio_queue_get_num(vdev, n)) {
... | 15,417 |
qemu | bc3b26f5356c6de13f887c865c98dcdfac143514 | 0 | static void pl181_fifo_run(pl181_state *s)
{
uint32_t bits;
uint32_t value;
int n;
int limit;
int is_read;
is_read = (s->datactrl & PL181_DATA_DIRECTION) != 0;
if (s->datacnt != 0 && (!is_read || sd_data_ready(s->card))
&& !s->linux_hack) {
limit = is_read ? P... | 15,418 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | envlist_setenv(envlist_t *envlist, const char *env)
{
struct envlist_entry *entry = NULL;
const char *eq_sign;
size_t envname_len;
if ((envlist == NULL) || (env == NULL))
return (EINVAL);
/* find out first equals sign in given env */
if ((eq_sign = strchr(env, '=')) == NULL)
return (EINVAL);
en... | 15,419 |
qemu | 9abf567d95a4e840df868ca993219175fbef8c22 | 0 | int sclp_service_call(CPUS390XState *env, uint32_t sccb, uint64_t code)
{
int r = 0;
int shift = 0;
#ifdef DEBUG_HELPER
printf("sclp(0x%x, 0x%" PRIx64 ")\n", sccb, code);
#endif
if (sccb & ~0x7ffffff8ul) {
fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb);
r = -1;
... | 15,422 |
qemu | a03ef88f77af045a2eb9629b5ce774a3fb973c5e | 0 | static int coroutine_fn do_perform_cow(BlockDriverState *bs,
uint64_t src_cluster_offset,
uint64_t cluster_offset,
int offset_in_cluster,
int bytes)
{
BDR... | 15,423 |
qemu | e8807b14cc8c12c0e14c08fa396d9da043b48209 | 0 | static int get_physical_address_code(CPUState *env,
target_phys_addr_t *physical, int *prot,
target_ulong address, int is_user)
{
target_ulong mask;
unsigned int i;
if ((env->lsu & IMMU_E) == 0) { /* IMMU disabled */
... | 15,424 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
ThreadPoolFunc *func, void *arg,
BlockCompletionFunc *cb, void *opaque)
{
ThreadPoolElement *req;
req = qemu_aio_get(&thread_pool_aiocb_info, NULL, cb, opaque);
req->func = func;
req->arg = arg;
req->state = THREAD_QUEUED... | 15,425 |
qemu | 184d4d42033d5c111276e4eef9ea273c2e114d18 | 0 | static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
{
struct tcphdr *ptcp, *stcp;
int res;
trace_colo_compare_main("compare tcp");
ptcp = (struct tcphdr *)ppkt->transport_header;
stcp = (struct tcphdr *)spkt->transport_header;
/*
* The 'identification' field in the ... | 15,426 |
qemu | 348295838384941d1e5420d10e57366c4e303d45 | 0 | static void data_plane_blk_insert_notifier(Notifier *n, void *data)
{
VirtIOBlockDataPlane *s = container_of(n, VirtIOBlockDataPlane,
insert_notifier);
assert(s->conf->conf.blk == data);
data_plane_set_up_op_blockers(s);
}
| 15,427 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void vapic_write(void *opaque, target_phys_addr_t addr, uint64_t data,
unsigned int size)
{
CPUX86State *env = cpu_single_env;
target_phys_addr_t rom_paddr;
VAPICROMState *s = opaque;
cpu_synchronize_state(env);
/*
* The VAPIC supports two PIO-based hy... | 15,428 |
qemu | 1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3 | 0 | long do_rt_sigreturn(CPUM68KState *env)
{
struct target_rt_sigframe *frame;
abi_ulong frame_addr = env->aregs[7] - 4;
target_sigset_t target_set;
sigset_t set;
int d0;
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
goto badframe;
target_to_host_sigset_internal... | 15,429 |
qemu | 0bf8264e2d2bd19c1eecf9bde0e59284ef47eabb | 0 | static int32_t scsi_unit_attention(SCSIRequest *req, uint8_t *buf)
{
if (req->dev && req->dev->unit_attention.key == UNIT_ATTENTION) {
scsi_req_build_sense(req, req->dev->unit_attention);
} else if (req->bus->unit_attention.key == UNIT_ATTENTION) {
scsi_req_build_sense(req, req->bus->unit_a... | 15,430 |
FFmpeg | 0d194ee51ed477f843900e657a7edbcbecdffa42 | 0 | static void vc1_decode_skip_blocks(VC1Context *v)
{
MpegEncContext *s = &v->s;
ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
s->first_slice_line = 1;
for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
s->mb_x = 0;
ff_init_block... | 15,431 |
qemu | bd79255d2571a3c68820117caf94ea9afe1d527e | 0 | static ExitStatus gen_mfpr(TCGv va, int regno)
{
int data = cpu_pr_data(regno);
/* Special help for VMTIME and WALLTIME. */
if (regno == 250 || regno == 249) {
void (*helper)(TCGv) = gen_helper_get_walltime;
if (regno == 249) {
helper = gen_helper_get_vmtime;
}
if (use_icount) {
... | 15,432 |
qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa | 0 | 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" : "... | 15,433 |
qemu | a5b8dd2ce83208cd7d6eb4562339ecf5aae13574 | 0 | static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp)
{
BDRVBlkdebugState *s = bs->opaque;
if (s->align) {
bs->request_alignment = s->align;
}
}
| 15,435 |
qemu | d4362d642e5cfd50671eba250b5888a89a88691a | 0 | static int add_rule(QemuOpts *opts, void *opaque)
{
struct add_rule_data *d = opaque;
BDRVBlkdebugState *s = d->s;
const char* event_name;
BlkDebugEvent event;
struct BlkdebugRule *rule;
/* Find the right event for the rule */
event_name = qemu_opt_get(opts, "event");
if (!eve... | 15,436 |
qemu | bda055096be9a91d602af457f8bedeede86eb3f6 | 0 | static int cmos_get_fd_drive_type(FloppyDriveType fd0)
{
int val;
switch (fd0) {
case FLOPPY_DRIVE_TYPE_144:
/* 1.44 Mb 3"5 drive */
val = 4;
break;
case FLOPPY_DRIVE_TYPE_288:
/* 2.88 Mb 3"5 drive */
val = 5;
break;
case FLOPPY_DRIVE_TYP... | 15,437 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.