static int flic_read_header(AVFormatContext *s, AVFormatParameters *ap) { FlicDemuxContext *flic = s->priv_data; ByteIOContext *pb = s->pb; unsigned char header[FLIC_HEADER_SIZE]; AVStream *st, *ast; int speed; int magic_number; unsigned char preamble[FLIC_PREAMBLE_SIZE]; flic->frame_number = 0; /* load the whole header and pull out the width and height */ if (get_buffer(pb, header, FLIC_HEADER_SIZE) != FLIC_HEADER_SIZE) return AVERROR(EIO); magic_number = AV_RL16(&header[4]); speed = AV_RL32(&header[0x10]); if (speed == 0) speed = FLIC_DEFAULT_SPEED; /* initialize the decoder streams */ st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); flic->video_stream_index = st->index; st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_FLIC; st->codec->codec_tag = 0; /* no fourcc */ st->codec->width = AV_RL16(&header[0x08]); st->codec->height = AV_RL16(&header[0x0A]); if (!st->codec->width || !st->codec->height) { /* Ugly hack needed for the following sample: */ /* http://samples.mplayerhq.hu/fli-flc/fli-bugs/specular.flc */ av_log(s, AV_LOG_WARNING, "File with no specified width/height. Trying 640x480.\n"); st->codec->width = 640; st->codec->height = 480; } /* send over the whole 128-byte FLIC header */ st->codec->extradata_size = FLIC_HEADER_SIZE; st->codec->extradata = av_malloc(FLIC_HEADER_SIZE); memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE); /* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */ if (get_buffer(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) { av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n"); return AVERROR(EIO); } url_fseek(pb, -FLIC_PREAMBLE_SIZE, SEEK_CUR); /* Time to figure out the framerate: * If the first preamble's magic number is 0xAAAA then this file is from * X-COM: Terror from the Deep. If on the other hand there is a FLIC chunk * magic number at offset 0x10 assume this file is from Magic Carpet instead. * If neither of the above is true then this is a normal FLIC file. */ if (AV_RL16(&preamble[4]) == FLIC_TFTD_CHUNK_AUDIO) { /* TFTD videos have an extra 22050 Hz 8-bit mono audio stream */ ast = av_new_stream(s, 1); if (!ast) return AVERROR(ENOMEM); flic->audio_stream_index = ast->index; /* all audio frames are the same size, so use the size of the first chunk for block_align */ ast->codec->block_align = AV_RL32(&preamble[0]); ast->codec->codec_type = CODEC_TYPE_AUDIO; ast->codec->codec_id = CODEC_ID_PCM_U8; ast->codec->codec_tag = 0; ast->codec->sample_rate = FLIC_TFTD_SAMPLE_RATE; ast->codec->channels = 1; ast->codec->sample_fmt = SAMPLE_FMT_U8; ast->codec->bit_rate = st->codec->sample_rate * 8; ast->codec->bits_per_coded_sample = 8; ast->codec->channel_layout = CH_LAYOUT_MONO; ast->codec->extradata_size = 0; /* Since the header information is incorrect we have to figure out the * framerate using block_align and the fact that the audio is 22050 Hz. * We usually have two cases: 2205 -> 10 fps and 1470 -> 15 fps */ av_set_pts_info(st, 64, ast->codec->block_align, FLIC_TFTD_SAMPLE_RATE); av_set_pts_info(ast, 64, 1, FLIC_TFTD_SAMPLE_RATE); } else if (AV_RL16(&header[0x10]) == FLIC_CHUNK_MAGIC_1) { av_set_pts_info(st, 64, FLIC_MC_SPEED, 70); /* rewind the stream since the first chunk is at offset 12 */ url_fseek(pb, 12, SEEK_SET); /* send over abbreviated FLIC header chunk */ av_free(st->codec->extradata); st->codec->extradata_size = 12; st->codec->extradata = av_malloc(12); memcpy(st->codec->extradata, header, 12); } else if (magic_number == FLIC_FILE_MAGIC_1) { av_set_pts_info(st, 64, speed, 70); } else if ((magic_number == FLIC_FILE_MAGIC_2) || (magic_number == FLIC_FILE_MAGIC_3)) { av_set_pts_info(st, 64, speed, 1000); } else { av_log(s, AV_LOG_INFO, "Invalid or unsupported magic chunk in file\n"); return AVERROR_INVALIDDATA; } return 0; }
GLboolean GLAPIENTRY _mesa_UnmapBufferARB(GLenum target) { GET_CURRENT_CONTEXT(ctx); struct gl_buffer_object *bufObj; GLboolean status = GL_TRUE; ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); bufObj = get_buffer(ctx, "glUnmapBufferARB", target); if (!bufObj) return GL_FALSE; if (!_mesa_bufferobj_mapped(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB"); return GL_FALSE; } #ifdef BOUNDS_CHECK if (bufObj->Access != GL_READ_ONLY_ARB) { GLubyte *buf = (GLubyte *) bufObj->Pointer; GLuint i; /* check that last 100 bytes are still = magic value */ for (i = 0; i < 100; i++) { GLuint pos = bufObj->Size - i - 1; if (buf[pos] != 123) { _mesa_warning(ctx, "Out of bounds buffer object write detected" " at position %d (value = %u)\n", pos, buf[pos]); } } } #endif #ifdef VBO_DEBUG if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) { GLuint i, unchanged = 0; GLubyte *b = (GLubyte *) bufObj->Pointer; GLint pos = -1; /* check which bytes changed */ for (i = 0; i < bufObj->Size - 1; i++) { if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) { unchanged++; if (pos == -1) pos = i; } } if (unchanged) { printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n", bufObj->Name, unchanged, bufObj->Size, pos); } } #endif status = ctx->Driver.UnmapBuffer( ctx, bufObj ); bufObj->AccessFlags = default_access_mode(ctx); ASSERT(bufObj->Pointer == NULL); ASSERT(bufObj->Offset == 0); ASSERT(bufObj->Length == 0); return status; }
static int read_header(AVFormatContext *s, AVFormatParameters *ap) { int i, header_remaining; ASSContext *ass = s->priv_data; ByteIOContext *pb = s->pb; AVStream *st; int allocated[2]={0}; uint8_t *p, **dst[2]={0}; int pos[2]={0}; st = av_new_stream(s, 0); if (!st) return -1; av_set_pts_info(st, 64, 1, 100); st->codec->codec_type = CODEC_TYPE_SUBTITLE; st->codec->codec_id= CODEC_ID_SSA; header_remaining= INT_MAX; dst[0] = &st->codec->extradata; dst[1] = &ass->event_buffer; while(!url_feof(pb)){ uint8_t line[MAX_LINESIZE]; get_line(pb, line, sizeof(line)); if(!memcmp(line, "[Events]", 8)) header_remaining= 2; else if(line[0]=='[') header_remaining= INT_MAX; i= header_remaining==0; if(i && get_pts(line, NULL) == AV_NOPTS_VALUE) continue; p = av_fast_realloc(*(dst[i]), &allocated[i], pos[i]+MAX_LINESIZE); if(!p) goto fail; *(dst[i])= p; memcpy(p + pos[i], line, strlen(line)+1); pos[i] += strlen(line); if(i) ass->event_count++; else { header_remaining--; #if 0 if (!header_remaining) { /* write the header into extrada section */ int len = url_ftell(pb); st->codec->extradata = av_mallocz(len + 1); st->codec->extradata_size = len; url_fseek(pb, 0, SEEK_SET); get_buffer(pb, st->codec->extradata, len); } #endif } } st->codec->extradata_size= pos[0]; if(ass->event_count >= UINT_MAX / sizeof(*ass->event)) goto fail; ass->event= av_malloc(ass->event_count * sizeof(*ass->event)); p= ass->event_buffer; for(i=0; i<ass->event_count; i++){ ass->event[i].text= p; ass->event[i].start_time= get_pts(p, &ass->event[i].end_time); while(*p && *p != '\n') p++; p++; } qsort(ass->event, ass->event_count, sizeof(*ass->event), event_cmp); return 0; fail: read_close(s); return -1; }
static int jpeg_read(ByteIOContext *f, int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque) { AVCodecContext *c; AVFrame *picture, picture1; int len, size, got_picture, i; uint8_t *inbuf_ptr, inbuf[IO_BUF_SIZE]; JpegOpaque jctx; jctx.alloc_cb = alloc_cb; jctx.opaque = opaque; jctx.ret_code = -1; /* default return code is error */ c = avcodec_alloc_context(); if (!c) return -1; picture= avcodec_alloc_frame(); if (!picture) { av_free(c); return -1; } c->opaque = &jctx; c->get_buffer = jpeg_get_buffer; c->flags |= CODEC_FLAG_TRUNCATED; /* we dont send complete frames */ if (avcodec_open(c, &mjpeg_decoder) < 0) goto fail1; for(;;) { size = get_buffer(f, inbuf, sizeof(inbuf)); if (size == 0) break; inbuf_ptr = inbuf; while (size > 0) { len = avcodec_decode_video(c, &picture1, &got_picture, inbuf_ptr, size); if (len < 0) goto fail; if (got_picture) goto the_end; size -= len; inbuf_ptr += len; } } the_end: /* XXX: currently, the mjpeg decoder does not use AVFrame, so we must do it by hand */ if (jpeg_get_buffer(c, picture) < 0) goto fail; for(i=0;i<3;i++) { int w, h; w = c->width; h = c->height; if (i >= 1) { switch(c->pix_fmt) { default: case PIX_FMT_YUV420P: w = (w + 1) >> 1; h = (h + 1) >> 1; break; case PIX_FMT_YUV422P: w = (w + 1) >> 1; break; case PIX_FMT_YUV444P: break; } } jpeg_img_copy(picture->data[i], picture->linesize[i], picture1.data[i], picture1.linesize[i], w, h); } jctx.ret_code = 0; fail: avcodec_close(c); fail1: av_free(picture); av_free(c); return jctx.ret_code; }
void GLAPIENTRY _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage) { GET_CURRENT_CONTEXT(ctx); struct gl_buffer_object *bufObj; ASSERT_OUTSIDE_BEGIN_END(ctx); if (MESA_VERBOSE & VERBOSE_API) _mesa_debug(ctx, "glBufferData(%s, %ld, %p, %s)\n", _mesa_lookup_enum_by_nr(target), (long int) size, data, _mesa_lookup_enum_by_nr(usage)); if (size < 0) { _mesa_error(ctx, GL_INVALID_VALUE, "glBufferDataARB(size < 0)"); return; } switch (usage) { case GL_STREAM_DRAW_ARB: case GL_STREAM_READ_ARB: case GL_STREAM_COPY_ARB: case GL_STATIC_DRAW_ARB: case GL_STATIC_READ_ARB: case GL_STATIC_COPY_ARB: case GL_DYNAMIC_DRAW_ARB: case GL_DYNAMIC_READ_ARB: case GL_DYNAMIC_COPY_ARB: /* OK */ break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)"); return; } bufObj = get_buffer(ctx, "glBufferDataARB", target); if (!bufObj) return; if (_mesa_bufferobj_mapped(bufObj)) { /* Unmap the existing buffer. We'll replace it now. Not an error. */ ctx->Driver.UnmapBuffer(ctx, bufObj); bufObj->AccessFlags = default_access_mode(ctx); ASSERT(bufObj->Pointer == NULL); } FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT); bufObj->Written = GL_TRUE; #ifdef VBO_DEBUG printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n", bufObj->Name, size, data, usage); #endif #ifdef BOUNDS_CHECK size += 100; #endif ASSERT(ctx->Driver.BufferData); if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB()"); } }
ssize_t dst_entry_tcp::fast_send(const struct iovec* p_iov, const ssize_t sz_iov, bool b_blocked /*= true*/, bool is_rexmit /*= false*/, bool dont_inline /*= false*/) { tx_packet_template_t* p_pkt; mem_buf_desc_t *p_mem_buf_desc; size_t total_packet_len = 0; // The header is aligned for fast copy but we need to maintain this diff in order to get the real header pointer easily size_t hdr_alignment_diff = m_header.m_aligned_l2_l3_len - m_header.m_total_hdr_len; tcp_iovec* p_tcp_iov = NULL; bool no_copy = true; if (likely(sz_iov == 1 && !is_rexmit)) { p_tcp_iov = (tcp_iovec*)p_iov; if (unlikely(!m_p_ring->is_active_member(p_tcp_iov->p_desc->p_desc_owner, m_id))) { no_copy = false; dst_tcp_logdbg("p_desc=%p wrong desc_owner=%p, this ring=%p. did migration occurred?", p_tcp_iov->p_desc, p_tcp_iov->p_desc->p_desc_owner, m_p_ring); //todo can we handle this in migration (by going over all buffers lwip hold) instead for every send? } } else { no_copy = false; } if (unlikely(is_rexmit)) m_p_ring->inc_ring_stats(m_id); if (likely(no_copy)) { p_pkt = (tx_packet_template_t*)((uint8_t*)p_tcp_iov[0].iovec.iov_base - m_header.m_aligned_l2_l3_len); total_packet_len = p_tcp_iov[0].iovec.iov_len + m_header.m_total_hdr_len; m_header.copy_l2_ip_hdr(p_pkt); // We've copied to aligned address, and now we must update p_pkt to point to real // L2 header //p_pkt = (tx_packet_template_t*)((uint8_t*)p_pkt + hdr_alignment_diff); p_pkt->hdr.m_ip_hdr.tot_len = (htons)(p_tcp_iov[0].iovec.iov_len + m_header.m_ip_header_len); m_sge[0].addr = (uintptr_t)((uint8_t*)p_pkt + hdr_alignment_diff); m_sge[0].length = total_packet_len; /* for DEBUG */ if ((uint8_t*)m_sge[0].addr < p_tcp_iov[0].p_desc->p_buffer || (uint8_t*)p_pkt < p_tcp_iov[0].p_desc->p_buffer) { dst_tcp_logerr("p_buffer - addr=%d, m_total_hdr_len=%zd, p_buffer=%p, type=%d, len=%d, tot_len=%d, payload=%p, hdr_alignment_diff=%zd\n", (int)(p_tcp_iov[0].p_desc->p_buffer - (uint8_t*)m_sge[0].addr), m_header.m_total_hdr_len, p_tcp_iov[0].p_desc->p_buffer, p_tcp_iov[0].p_desc->lwip_pbuf.pbuf.type, p_tcp_iov[0].p_desc->lwip_pbuf.pbuf.len, p_tcp_iov[0].p_desc->lwip_pbuf.pbuf.tot_len, p_tcp_iov[0].p_desc->lwip_pbuf.pbuf.payload, hdr_alignment_diff); } if (!dont_inline && (total_packet_len < m_max_inline)) { // inline send m_p_send_wqe = &m_inline_send_wqe; } else { m_p_send_wqe = &m_not_inline_send_wqe; } m_p_send_wqe->wr_id = (uintptr_t)p_tcp_iov[0].p_desc; #ifdef VMA_NO_HW_CSUM p_pkt->hdr.m_ip_hdr.check = 0; // use 0 at csum calculation time p_pkt->hdr.m_ip_hdr.check = csum((unsigned short*)&p_pkt->hdr.m_ip_hdr, IPV4_HDR_LEN_WORDS * 2); struct tcphdr* p_tcphdr = (struct tcphdr*)(((uint8_t*)(&(p_pkt->hdr.m_ip_hdr)) + IPV4_HDR_LEN)); p_tcphdr->check = 0; p_tcphdr->check = compute_tcp_checksum(&p_pkt->hdr.m_ip_hdr, (const uint16_t *)p_tcphdr); dst_tcp_logfine("using SW checksum calculation: p_pkt->hdr.m_ip_hdr.check=%d, p_tcphdr->check=%d", (int)p_tcphdr->check, (int)p_pkt->hdr.m_ip_hdr.check); #endif m_p_ring->send_lwip_buffer(m_id, m_p_send_wqe, b_blocked); } else { // We don'nt support inline in this case, since we believe that this a very rare case p_mem_buf_desc = get_buffer(b_blocked); if (p_mem_buf_desc == NULL) { return -1; } m_header.copy_l2_ip_hdr((tx_packet_template_t*)p_mem_buf_desc->p_buffer); // Actually this is not the real packet len we will subtract the alignment diff at the end of the copy total_packet_len = m_header.m_aligned_l2_l3_len; for (int i = 0; i < sz_iov; ++i) { memcpy(p_mem_buf_desc->p_buffer + total_packet_len, p_iov[i].iov_base, p_iov[i].iov_len); total_packet_len += p_iov[i].iov_len; } m_sge[0].addr = (uintptr_t)(p_mem_buf_desc->p_buffer + hdr_alignment_diff); m_sge[0].length = total_packet_len - hdr_alignment_diff; // LKey will be updated in ring->send() // m_sge[0].lkey = p_mem_buf_desc->lkey; /* for DEBUG */ if ((uint8_t*)m_sge[0].addr < p_mem_buf_desc->p_buffer) { dst_tcp_logerr("p_buffer - addr=%d, m_total_hdr_len=%zd, p_buffer=%p, type=%d, len=%d, tot_len=%d, payload=%p, hdr_alignment_diff=%zd\n", (int)(p_mem_buf_desc->p_buffer - (uint8_t*)m_sge[0].addr), m_header.m_total_hdr_len, p_mem_buf_desc->p_buffer, p_mem_buf_desc->lwip_pbuf.pbuf.type, p_mem_buf_desc->lwip_pbuf.pbuf.len, p_mem_buf_desc->lwip_pbuf.pbuf.tot_len, p_mem_buf_desc->lwip_pbuf.pbuf.payload, hdr_alignment_diff); } p_pkt = (tx_packet_template_t*)((uint8_t*)p_mem_buf_desc->p_buffer); p_pkt->hdr.m_ip_hdr.tot_len = (htons)(m_sge[0].length - m_header.m_transport_header_len); #ifdef VMA_NO_HW_CSUM p_pkt->hdr.m_ip_hdr.check = 0; // use 0 at csum calculation time p_pkt->hdr.m_ip_hdr.check = csum((unsigned short*)&p_pkt->hdr.m_ip_hdr, IPV4_HDR_LEN_WORDS * 2); struct tcphdr* p_tcphdr = (struct tcphdr*)(((uint8_t*)(&(p_pkt->hdr.m_ip_hdr)) + IPV4_HDR_LEN)); p_tcphdr->check = 0; p_tcphdr->check = compute_tcp_checksum(&p_pkt->hdr.m_ip_hdr, (const uint16_t *)p_tcphdr); dst_tcp_logfine("using SW checksum calculation: p_pkt->hdr.m_ip_hdr.check=%d, p_tcphdr->check=%d", (int)p_tcphdr->check, (int)p_pkt->hdr.m_ip_hdr.check); #endif m_p_send_wqe = &m_not_inline_send_wqe; m_p_send_wqe->wr_id = (uintptr_t)p_mem_buf_desc; m_p_ring->send_ring_buffer(m_id, m_p_send_wqe, b_blocked); } #ifndef __COVERITY__ struct tcphdr* p_tcp_h = (struct tcphdr*)(((uint8_t*)(&(p_pkt->hdr.m_ip_hdr))+sizeof(p_pkt->hdr.m_ip_hdr))); dst_tcp_logfunc("Tx TCP segment info: src_port=%d, dst_port=%d, flags='%s%s%s%s%s%s' seq=%u, ack=%u, win=%u, payload_sz=%u", ntohs(p_tcp_h->source), ntohs(p_tcp_h->dest), p_tcp_h->urg?"U":"", p_tcp_h->ack?"A":"", p_tcp_h->psh?"P":"", p_tcp_h->rst?"R":"", p_tcp_h->syn?"S":"", p_tcp_h->fin?"F":"", ntohl(p_tcp_h->seq), ntohl(p_tcp_h->ack_seq), ntohs(p_tcp_h->window), total_packet_len- p_tcp_h->doff*4 -34); #endif if (unlikely(m_p_tx_mem_buf_desc_list == NULL)) { m_p_tx_mem_buf_desc_list = m_p_ring->mem_buf_tx_get(m_id, b_blocked, mce_sys.tx_bufs_batch_tcp); } return 0; }
int get_current(struct target *target, int create) { struct target_list *head; head = target->head; uint8_t *buf; uint32_t val; uint32_t ti_addr; uint8_t *buffer = calloc(1, 4); struct linux_os *linux_os = (struct linux_os *) target->rtos->rtos_specific_params; struct current_thread *ctt = linux_os->current_threads; /* invalid current threads content */ while (ctt != NULL) { ctt->threadid = -1; ctt->TS = 0xdeadbeef; ctt = ctt->next; } while (head != (struct target_list *)NULL) { struct reg **reg_list; int reg_list_size; int retval; if (target_get_gdb_reg_list(head->target, ®_list, ®_list_size) != ERROR_OK) { free(buffer); return ERROR_TARGET_FAILURE; } if (!reg_list[13]->valid) reg_list[13]->type->get(reg_list[13]); buf = reg_list[13]->value; val = get_buffer(target, buf); ti_addr = (val & 0xffffe000); uint32_t TS_addr = ti_addr + 0xc; retval = fill_buffer(target, TS_addr, buffer); if (retval == ERROR_OK) { uint32_t TS = get_buffer(target, buffer); uint32_t cpu, on_cpu = TS + ONCPU; retval = fill_buffer(target, on_cpu, buffer); if (retval == ERROR_OK) { /*uint32_t cpu = get_buffer(target, buffer);*/ struct current_thread *ct = linux_os->current_threads; cpu = head->target->coreid; while ((ct != NULL) && (ct->core_id != (int32_t) cpu)) ct = ct->next; if ((ct != NULL) && (ct->TS == 0xdeadbeef)) ct->TS = TS; else LOG_ERROR ("error in linux current thread update"); if (create) { struct threads *t; t = calloc(1, sizeof(struct threads)); t->base_addr = ct->TS; fill_task(target, t); get_name(target, t); t->oncpu = cpu; insert_into_threadlist(target, t); t->status = 3; t->thread_info_addr = 0xdeadbeef; ct->threadid = t->threadid; linux_os->thread_count++; #ifdef PID_CHECK ct->pid = t->pid; #endif /*LOG_INFO("Creation of current thread %s",t->name);*/ } } } free(reg_list); head = head->next; } free(buffer); return ERROR_OK; }
/** * read rl2 header data and setup the avstreams * @param s demuxer context * @param ap format parameters * @return 0 on success, AVERROR otherwise */ static av_cold int rl2_read_header(AVFormatContext *s, AVFormatParameters *ap) { ByteIOContext *pb = s->pb; AVStream *st; unsigned int frame_count; unsigned int audio_frame_counter = 0; unsigned int video_frame_counter = 0; unsigned int back_size; int data_size; unsigned short encoding_method; unsigned short sound_rate; unsigned short rate; unsigned short channels; unsigned short def_sound_size; unsigned int signature; unsigned int pts_den = 11025; /* video only case */ unsigned int pts_num = 1103; unsigned int* chunk_offset = NULL; int* chunk_size = NULL; int* audio_size = NULL; int i; int ret = 0; url_fskip(pb,4); /* skip FORM tag */ back_size = get_le32(pb); /** get size of the background frame */ signature = get_be32(pb); data_size = get_be32(pb); frame_count = get_le32(pb); /* disallow back_sizes and frame_counts that may lead to overflows later */ if(back_size > INT_MAX/2 || frame_count > INT_MAX / sizeof(uint32_t)) return AVERROR_INVALIDDATA; encoding_method = get_le16(pb); sound_rate = get_le16(pb); rate = get_le16(pb); channels = get_le16(pb); def_sound_size = get_le16(pb); /** setup video stream */ st = av_new_stream(s, 0); if(!st) return AVERROR(ENOMEM); st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_RL2; st->codec->codec_tag = 0; /* no fourcc */ st->codec->width = 320; st->codec->height = 200; /** allocate and fill extradata */ st->codec->extradata_size = EXTRADATA1_SIZE; if(signature == RLV3_TAG && back_size > 0) st->codec->extradata_size += back_size; st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); if(!st->codec->extradata) return AVERROR(ENOMEM); if(get_buffer(pb,st->codec->extradata,st->codec->extradata_size) != st->codec->extradata_size) return AVERROR(EIO); /** setup audio stream if present */ if(sound_rate){ pts_num = def_sound_size; pts_den = rate; st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_id = CODEC_ID_PCM_U8; st->codec->codec_tag = 1; st->codec->channels = channels; st->codec->bits_per_coded_sample = 8; st->codec->sample_rate = rate; st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codec->bits_per_coded_sample; st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample / 8; av_set_pts_info(st,32,1,rate); } av_set_pts_info(s->streams[0], 32, pts_num, pts_den); chunk_size = av_malloc(frame_count * sizeof(uint32_t)); audio_size = av_malloc(frame_count * sizeof(uint32_t)); chunk_offset = av_malloc(frame_count * sizeof(uint32_t)); if(!chunk_size || !audio_size || !chunk_offset){ av_free(chunk_size); av_free(audio_size); av_free(chunk_offset); return AVERROR(ENOMEM); } /** read offset and size tables */ for(i=0; i < frame_count;i++) chunk_size[i] = get_le32(pb); for(i=0; i < frame_count;i++) chunk_offset[i] = get_le32(pb); for(i=0; i < frame_count;i++) audio_size[i] = get_le32(pb) & 0xFFFF; /** build the sample index */ for(i=0;i<frame_count;i++){ if(chunk_size[i] < 0 || audio_size[i] > chunk_size[i]){ ret = AVERROR_INVALIDDATA; break; } if(sound_rate && audio_size[i]){ av_add_index_entry(s->streams[1], chunk_offset[i], audio_frame_counter,audio_size[i], 0, AVINDEX_KEYFRAME); audio_frame_counter += audio_size[i] / channels; } av_add_index_entry(s->streams[0], chunk_offset[i] + audio_size[i], video_frame_counter,chunk_size[i]-audio_size[i],0,AVINDEX_KEYFRAME); ++video_frame_counter; } av_free(chunk_size); av_free(audio_size); av_free(chunk_offset); return ret; }
void detect_ext234(SECTION *section, int level) { unsigned char *buf; char s[256]; int fslevel, is_journal, is_dev; u4 blocksize; u8 blockcount; if (get_buffer(section, 1024, 1024, (void **)&buf) < 1024) return; if (get_le_short(buf + 56) == 0xEF53) { fslevel = 2; is_journal = 0; is_dev = 0; /* Ext3/4 external journal: INCOMPAT feature JOURNAL_DEV */ if (get_le_long(buf + 96) & 0x0008) { is_journal = 1; fslevel = 3; /* at least ext3, ext2 has no journalling */ } /* Ext3/4 COMPAT feature: HAS_JOURNAL */ if (get_le_long(buf + 92) & 0x0004) fslevel = 3; /* Ext4 INCOMPAT features: EXTENTS, 64BIT, FLEX_BG */ //if (get_le_long(buf + 96) & 0x02C0) // fslevel = 4; /* Ext4 RO_COMPAT features: HUGE_FILE, GDT_CSUM, DIR_NLINK, EXTRA_ISIZE */ if (get_le_long(buf + 100) & 0x0078) fslevel = 4; /* Ext4 sets min_extra_isize even on external journals */ //if (get_le_short(buf + 348) >= 0x1c) // fslevel = 4; /* Ext4dev TEST_FILESYS flag */ //if (get_le_long(buf + 352) & 0x0004) // is_dev = 1; print_line(level, "Ext%d%s %s", fslevel, is_dev ? "dev" : "", is_journal ? "external journal" : "file system"); get_string(buf + 120, 16, s); if (s[0]) print_line(level + 1, "Volume name \"%s\"", s); format_uuid(buf + 104, s); print_line(level + 1, "UUID %s", s); get_string(buf + 136, 64, s); if (s[0]) print_line(level + 1, "Last mounted at \"%s\"", s); blocksize = 1024 << get_le_long(buf + 24); blockcount = get_le_long(buf + 4); format_blocky_size(s, blockcount, blocksize, "blocks", NULL); print_line(level + 1, "Volume size %s", s); /* 76 4 s_rev_level */ /* 62 2 s_minor_rev_level */ /* 72 4 s_creator_os */ /* 92 3x4 s_feature_compat, s_feature_incompat, s_feature_ro_compat */ } }
static int flic_read_header(AVFormatContext *s, AVFormatParameters *ap) { FlicDemuxContext *flic = (FlicDemuxContext *)s->priv_data; ByteIOContext *pb = &s->pb; unsigned char header[FLIC_HEADER_SIZE]; AVStream *st; int speed; int magic_number; flic->pts = 0; /* load the whole header and pull out the width and height */ if (get_buffer(pb, header, FLIC_HEADER_SIZE) != FLIC_HEADER_SIZE) return AVERROR_IO; magic_number = LE_16(&header[4]); speed = LE_32(&header[0x10]); /* initialize the decoder streams */ st = av_new_stream(s, 0); if (!st) return AVERROR_NOMEM; flic->video_stream_index = st->index; st->codec.codec_type = CODEC_TYPE_VIDEO; st->codec.codec_id = CODEC_ID_FLIC; st->codec.codec_tag = 0; /* no fourcc */ st->codec.width = LE_16(&header[0x08]); st->codec.height = LE_16(&header[0x0A]); if (!st->codec.width || !st->codec.height) return AVERROR_INVALIDDATA; /* send over the whole 128-byte FLIC header */ st->codec.extradata_size = FLIC_HEADER_SIZE; st->codec.extradata = av_malloc(FLIC_HEADER_SIZE); memcpy(st->codec.extradata, header, FLIC_HEADER_SIZE); av_set_pts_info(st, 33, 1, 90000); /* Time to figure out the framerate: If there is a FLIC chunk magic * number at offset 0x10, assume this is from the Bullfrog game, * Magic Carpet. */ if (LE_16(&header[0x10]) == FLIC_CHUNK_MAGIC_1) { flic->frame_pts_inc = FLIC_MC_PTS_INC; /* rewind the stream since the first chunk is at offset 12 */ url_fseek(pb, 12, SEEK_SET); /* send over abbreviated FLIC header chunk */ av_free(st->codec.extradata); st->codec.extradata_size = 12; st->codec.extradata = av_malloc(12); memcpy(st->codec.extradata, header, 12); } else if (magic_number == FLIC_FILE_MAGIC_1) { /* * in this case, the speed (n) is number of 1/70s ticks between frames: * * pts n * frame # * -------- = ----------- => pts = n * (90000/70) * frame # * 90000 70 * * therefore, the frame pts increment = n * 1285.7 */ flic->frame_pts_inc = speed * 1285.7; } else if (magic_number == FLIC_FILE_MAGIC_2) { /* * in this case, the speed (n) is number of milliseconds between frames: * * pts n * frame # * -------- = ----------- => pts = n * 90 * frame # * 90000 1000 * * therefore, the frame pts increment = n * 90 */ flic->frame_pts_inc = speed * 90; } else return AVERROR_INVALIDDATA; if (flic->frame_pts_inc == 0) flic->frame_pts_inc = FLIC_DEFAULT_PTS_INC; return 0; }
static int img_read_packet(AVFormatContext *s1, AVPacket *pkt) { VideoData *s = s1->priv_data; char filename[1024]; int i; int size[3]={0}, ret[3]={0}; ByteIOContext *f[3]; AVCodecContext *codec= s1->streams[0]->codec; if (!s->is_pipe) { /* loop over input */ if (s1->loop_input && s->img_number > s->img_last) { s->img_number = s->img_first; } if (s->img_number > s->img_last) return AVERROR_EOF; if (av_get_frame_filename(filename, sizeof(filename), s->path, s->img_number)<0 && s->img_number > 1) return AVERROR(EIO); for(i=0; i<3; i++){ if (url_fopen(&f[i], filename, URL_RDONLY) < 0) { if(i==1) break; av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",filename); return AVERROR(EIO); } size[i]= url_fsize(f[i]); if(codec->codec_id != CODEC_ID_RAWVIDEO) break; filename[ strlen(filename) - 1 ]= 'U' + i; } if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width) infer_size(&codec->width, &codec->height, size[0]); } else { f[0] = s1->pb; if (url_feof(f[0])) return AVERROR(EIO); size[0]= 4096; } av_new_packet(pkt, size[0] + size[1] + size[2]); pkt->stream_index = 0; pkt->flags |= AV_PKT_FLAG_KEY; pkt->size= 0; for(i=0; i<3; i++){ if(size[i]){ ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]); if (!s->is_pipe) url_fclose(f[i]); if(ret[i]>0) pkt->size += ret[i]; } } if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) { av_free_packet(pkt); return AVERROR(EIO); /* signal EOF */ } else { s->img_count++; s->img_number++; return 0; } }
static int roq_read_header(AVFormatContext *s, AVFormatParameters *ap) { RoqDemuxContext *roq = s->priv_data; ByteIOContext *pb = &s->pb; AVStream *st; unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE]; int i; unsigned int chunk_size; unsigned int chunk_type; /* get the main header */ if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE) return AVERROR(EIO); roq->framerate = AV_RL16(&preamble[6]); roq->frame_pts_inc = 90000 / roq->framerate; /* init private context parameters */ roq->width = roq->height = roq->audio_channels = roq->video_pts = roq->audio_frame_count = 0; /* scan the first n chunks searching for A/V parameters */ for (i = 0; i < RoQ_CHUNKS_TO_SCAN; i++) { if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE) return AVERROR(EIO); chunk_type = AV_RL16(&preamble[0]); chunk_size = AV_RL32(&preamble[2]); switch (chunk_type) { case RoQ_INFO: /* fetch the width and height; reuse the preamble bytes */ if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE) return AVERROR(EIO); roq->width = AV_RL16(&preamble[0]); roq->height = AV_RL16(&preamble[2]); break; case RoQ_QUAD_CODEBOOK: case RoQ_QUAD_VQ: /* ignore during this scan */ url_fseek(pb, chunk_size, SEEK_CUR); break; case RoQ_SOUND_MONO: roq->audio_channels = 1; url_fseek(pb, chunk_size, SEEK_CUR); break; case RoQ_SOUND_STEREO: roq->audio_channels = 2; url_fseek(pb, chunk_size, SEEK_CUR); break; default: av_log(s, AV_LOG_ERROR, " unknown RoQ chunk type (%04X)\n", AV_RL16(&preamble[0])); return AVERROR_INVALIDDATA; break; } /* if all necessary parameters have been gathered, exit early */ if ((roq->width && roq->height) && roq->audio_channels) break; } /* seek back to the first chunk */ url_fseek(pb, RoQ_CHUNK_PREAMBLE_SIZE, SEEK_SET); /* initialize the decoders */ st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); /* set the pts reference (1 pts = 1/90000) */ av_set_pts_info(st, 33, 1, 90000); roq->video_stream_index = st->index; st->codec->codec_type = CODEC_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_ROQ; st->codec->codec_tag = 0; /* no fourcc */ st->codec->width = roq->width; st->codec->height = roq->height; if (roq->audio_channels) { st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); av_set_pts_info(st, 33, 1, 90000); roq->audio_stream_index = st->index; st->codec->codec_type = CODEC_TYPE_AUDIO; st->codec->codec_id = CODEC_ID_ROQ_DPCM; st->codec->codec_tag = 0; /* no tag */ st->codec->channels = roq->audio_channels; st->codec->sample_rate = RoQ_AUDIO_SAMPLE_RATE; st->codec->bits_per_sample = 16; st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codec->bits_per_sample; st->codec->block_align = st->codec->channels * st->codec->bits_per_sample; } return 0; }
static int roq_read_packet(AVFormatContext *s, AVPacket *pkt) { RoqDemuxContext *roq = s->priv_data; ByteIOContext *pb = &s->pb; int ret = 0; unsigned int chunk_size; unsigned int chunk_type; unsigned int codebook_size; unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE]; int packet_read = 0; offset_t codebook_offset; while (!packet_read) { if (url_feof(&s->pb)) return AVERROR(EIO); /* get the next chunk preamble */ if ((ret = get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE)) != RoQ_CHUNK_PREAMBLE_SIZE) return AVERROR(EIO); chunk_type = AV_RL16(&preamble[0]); chunk_size = AV_RL32(&preamble[2]); if(chunk_size > INT_MAX) return AVERROR_INVALIDDATA; switch (chunk_type) { case RoQ_INFO: /* don't care about this chunk anymore */ url_fseek(pb, RoQ_CHUNK_PREAMBLE_SIZE, SEEK_CUR); break; case RoQ_QUAD_CODEBOOK: /* packet needs to contain both this codebook and next VQ chunk */ codebook_offset = url_ftell(pb) - RoQ_CHUNK_PREAMBLE_SIZE; codebook_size = chunk_size; url_fseek(pb, codebook_size, SEEK_CUR); if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE) return AVERROR(EIO); chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 + codebook_size; /* rewind */ url_fseek(pb, codebook_offset, SEEK_SET); /* load up the packet */ ret= av_get_packet(pb, pkt, chunk_size); if (ret != chunk_size) return AVERROR(EIO); pkt->stream_index = roq->video_stream_index; pkt->pts = roq->video_pts; roq->video_pts += roq->frame_pts_inc; packet_read = 1; break; case RoQ_SOUND_MONO: case RoQ_SOUND_STEREO: case RoQ_QUAD_VQ: /* load up the packet */ if (av_new_packet(pkt, chunk_size + RoQ_CHUNK_PREAMBLE_SIZE)) return AVERROR(EIO); /* copy over preamble */ memcpy(pkt->data, preamble, RoQ_CHUNK_PREAMBLE_SIZE); if (chunk_type == RoQ_QUAD_VQ) { pkt->stream_index = roq->video_stream_index; pkt->pts = roq->video_pts; roq->video_pts += roq->frame_pts_inc; } else { pkt->stream_index = roq->audio_stream_index; pkt->pts = roq->audio_frame_count; pkt->pts *= 90000; pkt->pts /= RoQ_AUDIO_SAMPLE_RATE; roq->audio_frame_count += (chunk_size / roq->audio_channels); } pkt->pos= url_ftell(pb); ret = get_buffer(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE, chunk_size); if (ret != chunk_size) ret = AVERROR(EIO); packet_read = 1; break; default: av_log(s, AV_LOG_ERROR, " unknown RoQ chunk (%04X)\n", chunk_type); return AVERROR_INVALIDDATA; break; } } return ret; }
static GstFlowReturn gst_visual_chain (GstPad * pad, GstBuffer * buffer) { GstBuffer *outbuf = NULL; guint i; GstVisual *visual = GST_VISUAL (gst_pad_get_parent (pad)); GstFlowReturn ret = GST_FLOW_OK; guint avail; GST_DEBUG_OBJECT (visual, "chain function called"); /* If we don't have an output format yet, preallocate a buffer to try and * set one */ if (GST_PAD_CAPS (visual->srcpad) == NULL) { ret = get_buffer (visual, &outbuf); if (ret != GST_FLOW_OK) { gst_buffer_unref (buffer); goto beach; } } /* resync on DISCONT */ if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) { gst_adapter_clear (visual->adapter); } GST_DEBUG_OBJECT (visual, "Input buffer has %d samples, time=%" G_GUINT64_FORMAT, GST_BUFFER_SIZE (buffer) / visual->bps, GST_BUFFER_TIMESTAMP (buffer)); gst_adapter_push (visual->adapter, buffer); while (TRUE) { gboolean need_skip; const guint16 *data; guint64 dist, timestamp; GST_DEBUG_OBJECT (visual, "processing buffer"); avail = gst_adapter_available (visual->adapter); GST_DEBUG_OBJECT (visual, "avail now %u", avail); /* we need at least 512 samples */ if (avail < 512 * visual->bps) break; /* we need at least enough samples to make one frame */ if (avail < visual->spf * visual->bps) break; /* get timestamp of the current adapter byte */ timestamp = gst_adapter_prev_timestamp (visual->adapter, &dist); if (GST_CLOCK_TIME_IS_VALID (timestamp)) { /* convert bytes to time */ dist /= visual->bps; timestamp += gst_util_uint64_scale_int (dist, GST_SECOND, visual->rate); } if (timestamp != -1) { gint64 qostime; /* QoS is done on running time */ qostime = gst_segment_to_running_time (&visual->segment, GST_FORMAT_TIME, timestamp); GST_OBJECT_LOCK (visual); /* check for QoS, don't compute buffers that are known to be late */ need_skip = visual->earliest_time != -1 && qostime <= visual->earliest_time; GST_OBJECT_UNLOCK (visual); if (need_skip) { GST_WARNING_OBJECT (visual, "QoS: skip ts: %" GST_TIME_FORMAT ", earliest: %" GST_TIME_FORMAT, GST_TIME_ARGS (qostime), GST_TIME_ARGS (visual->earliest_time)); goto skip; } } /* Read 512 samples per channel */ data = (const guint16 *) gst_adapter_peek (visual->adapter, 512 * visual->bps); #if defined(VISUAL_API_VERSION) && VISUAL_API_VERSION >= 4000 && VISUAL_API_VERSION < 5000 { VisBuffer *lbuf, *rbuf; guint16 ldata[512], rdata[512]; VisAudioSampleRateType rate; lbuf = visual_buffer_new_with_buffer (ldata, sizeof (ldata), NULL); rbuf = visual_buffer_new_with_buffer (rdata, sizeof (rdata), NULL); if (visual->channels == 2) { for (i = 0; i < 512; i++) { ldata[i] = *data++; rdata[i] = *data++; } } else { for (i = 0; i < 512; i++) { ldata[i] = *data; rdata[i] = *data++; } } switch (visual->rate) { case 8000: rate = VISUAL_AUDIO_SAMPLE_RATE_8000; break; case 11250: rate = VISUAL_AUDIO_SAMPLE_RATE_11250; break; case 22500: rate = VISUAL_AUDIO_SAMPLE_RATE_22500; break; case 32000: rate = VISUAL_AUDIO_SAMPLE_RATE_32000; break; case 44100: rate = VISUAL_AUDIO_SAMPLE_RATE_44100; break; case 48000: rate = VISUAL_AUDIO_SAMPLE_RATE_48000; break; case 96000: rate = VISUAL_AUDIO_SAMPLE_RATE_96000; break; default: visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); GST_ERROR_OBJECT (visual, "unsupported rate %d", visual->rate); ret = GST_FLOW_ERROR; goto beach; break; } visual_audio_samplepool_input_channel (visual->audio->samplepool, lbuf, rate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, (char *) VISUAL_AUDIO_CHANNEL_LEFT); visual_audio_samplepool_input_channel (visual->audio->samplepool, rbuf, rate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, (char *) VISUAL_AUDIO_CHANNEL_RIGHT); visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); } #else if (visual->channels == 2) { for (i = 0; i < 512; i++) { visual->audio->plugpcm[0][i] = *data++; visual->audio->plugpcm[1][i] = *data++; } } else { for (i = 0; i < 512; i++) { visual->audio->plugpcm[0][i] = *data; visual->audio->plugpcm[1][i] = *data++; } } #endif /* alloc a buffer if we don't have one yet, this happens * when we pushed a buffer in this while loop before */ if (outbuf == NULL) { ret = get_buffer (visual, &outbuf); if (ret != GST_FLOW_OK) { goto beach; } } visual_video_set_buffer (visual->video, GST_BUFFER_DATA (outbuf)); visual_audio_analyze (visual->audio); visual_actor_run (visual->actor, visual->audio); visual_video_set_buffer (visual->video, NULL); GST_DEBUG_OBJECT (visual, "rendered one frame"); GST_BUFFER_TIMESTAMP (outbuf) = timestamp; GST_BUFFER_DURATION (outbuf) = visual->duration; ret = gst_pad_push (visual->srcpad, outbuf); outbuf = NULL; skip: GST_DEBUG_OBJECT (visual, "finished frame, flushing %u samples from input", visual->spf); /* Flush out the number of samples per frame */ gst_adapter_flush (visual->adapter, visual->spf * visual->bps); /* quit the loop if something was wrong */ if (ret != GST_FLOW_OK) break; } beach: if (outbuf != NULL) gst_buffer_unref (outbuf); gst_object_unref (visual); return ret; }
/** * \brief read until we found all data needed for decoding * \param vst video stream of which to change parameters * \param ast video stream of which to change parameters * \param myth set if this is a MythTVVideo format file * \return 1 if all required codec data was found */ static int get_codec_data(ByteIOContext *pb, AVStream *vst, AVStream *ast, int myth) { nuv_frametype frametype; if (!vst && !myth) return 1; // no codec data needed while (!url_feof(pb)) { int size, subtype; frametype = get_byte(pb); switch (frametype) { case NUV_EXTRADATA: subtype = get_byte(pb); url_fskip(pb, 6); size = PKTSIZE(get_le32(pb)); if (vst && subtype == 'R') { vst->codec->extradata_size = size; vst->codec->extradata = av_malloc(size); get_buffer(pb, vst->codec->extradata, size); size = 0; if (!myth) return 1; } break; case NUV_MYTHEXT: url_fskip(pb, 7); size = PKTSIZE(get_le32(pb)); if (size != 128 * 4) break; get_le32(pb); // version if (vst) { vst->codec->codec_tag = get_le32(pb); vst->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag); if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G')) vst->codec->codec_id = CODEC_ID_NUV; } else url_fskip(pb, 4); if (ast) { ast->codec->codec_tag = get_le32(pb); ast->codec->sample_rate = get_le32(pb); ast->codec->bits_per_coded_sample = get_le32(pb); ast->codec->channels = get_le32(pb); ast->codec->codec_id = ff_wav_codec_get_id(ast->codec->codec_tag, ast->codec->bits_per_coded_sample); ast->need_parsing = AVSTREAM_PARSE_FULL; } else url_fskip(pb, 4 * 4); size -= 6 * 4; url_fskip(pb, size); return 1; case NUV_SEEKP: size = 11; break; default: url_fskip(pb, 7); size = PKTSIZE(get_le32(pb)); break; } url_fskip(pb, size); } return 0; }
void detect_linux_lvm2(SECTION *section, int level) { unsigned char *buf; int at, i; char s[256]; u8 labelsector; u4 labeloffset; u8 pvsize, mdoffset, mdsize; int mda_version; for (at = 0; at < 4; at++) { if (get_buffer(section, at * 512, 512, (void **)&buf) < 512) continue; /* check signature */ if (memcmp(buf, "LABELONE", 8) != 0) continue; labelsector = get_le_quad(buf + 8); labeloffset = get_le_long(buf + 20); if (memcmp(buf + 24, "LVM2 001", 8) != 0) { get_string(buf + 24, 8, s); print_line(level, "LABELONE label at sector %d, unknown type \"%s\"", at, s); return; } print_line(level, "Linux LVM2 volume, version 001"); print_line(level + 1, "LABELONE label at sector %d", at); if (labeloffset >= 512 || labelsector > 256 || labelsector != at) { print_line(level + 1, "LABELONE data inconsistent, aborting analysis"); return; } /* "UUID" of this physical volume */ format_uuid_lvm(buf + labeloffset, s); print_line(level + 1, "PV UUID %s", s); /* raw volume size */ pvsize = get_le_quad(buf + labeloffset + 32); format_size_verbose(s, pvsize); print_line(level + 1, "Volume size %s", s); /* find first metadata area in list */ mdoffset = 0; for (i = 0; i < 16; i++) if (get_le_quad(buf + labeloffset + 40 + i * 16) == 0) { i++; mdoffset = get_le_quad(buf + labeloffset + 40 + i * 16); mdsize = get_le_quad(buf + labeloffset + 40 + i * 16 + 8); break; } if (mdoffset == 0) return; if (get_buffer(section, mdoffset, mdsize, (void **)&buf) < mdsize) return; if (memcmp(buf + 4, " LVM2 x[5A%r0N*>", 16) != 0) return; mda_version = get_le_long(buf + 20); print_line(level + 1, "Meta-data version %d", mda_version); /* TODO: parse the metadata area (big task...) */ return; } }
static int thp_read_header(AVFormatContext *s, AVFormatParameters *ap) { ThpDemuxContext *thp = s->priv_data; AVStream *st; ByteIOContext *pb = s->pb; int i; /* Read the file header. */ get_be32(pb); /* Skip Magic. */ thp->version = get_be32(pb); get_be32(pb); /* Max buf size. */ get_be32(pb); /* Max samples. */ thp->fps = av_d2q(av_int2flt(get_be32(pb)), INT_MAX); thp->framecnt = get_be32(pb); thp->first_framesz = get_be32(pb); get_be32(pb); /* Data size. */ thp->compoff = get_be32(pb); get_be32(pb); /* offsetDataOffset. */ thp->first_frame = get_be32(pb); thp->last_frame = get_be32(pb); thp->next_framesz = thp->first_framesz; thp->next_frame = thp->first_frame; /* Read the component structure. */ url_fseek (pb, thp->compoff, SEEK_SET); thp->compcount = get_be32(pb); /* Read the list of component types. */ get_buffer(pb, thp->components, 16); for (i = 0; i < thp->compcount; i++) { if (thp->components[i] == 0) { if (thp->vst != 0) break; /* Video component. */ st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); /* The denominator and numerator are switched because 1/fps is required. */ av_set_pts_info(st, 64, thp->fps.den, thp->fps.num); st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_THP; st->codec->codec_tag = 0; /* no fourcc */ st->codec->width = get_be32(pb); st->codec->height = get_be32(pb); st->codec->sample_rate = av_q2d(thp->fps); thp->vst = st; thp->video_stream_index = st->index; if (thp->version == 0x11000) get_be32(pb); /* Unknown. */ } else if (thp->components[i] == 1) { if (thp->has_audio != 0) break; /* Audio component. */ st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_id = CODEC_ID_ADPCM_THP; st->codec->codec_tag = 0; /* no fourcc */ st->codec->channels = get_be32(pb); /* numChannels. */ st->codec->sample_rate = get_be32(pb); /* Frequency. */ av_set_pts_info(st, 64, 1, st->codec->sample_rate); thp->audio_stream_index = st->index; thp->has_audio = 1; } } return 0; }
/* * This function may be called to allocate rte_mbuf from existing pool. * Paramters: None * Returns: a pointer to rte_mbuf, if succeeded, NULL if failed * */ struct rte_mbuf *app_glue_get_buffer() { return get_buffer(); }
void receive_data (void) { unsigned int count; u_short perm; char *buffer; int bufsize; int fd; int len, len2; int error; char exists; int readsize; if (debug) diag("receiving data"); if ((tempmode&SEND_OVER) == 0) exists = 0; else if ( ! get_exists ( &exists ) ) efatal("server read failed"); if (debug) diag("exists %d", exists); if (exists) { if ( ! get_perm ( &perm ) ) efatal("server read failed"); if ( ! get_count ( &count ) ) efatal("server read failed"); } else { perm = 0600; count = 0; } concat ( temppath, sizeof(temppath), tempdir, "/", tempfile, NULL ); tempfile = temppath; if (debug) { diag("perm %#o, count %d", perm, count); diag("d: %s f: %s p: %s", tempdir, tempfile, temppath ); } fd = open ( tempfile, O_CREAT | O_RDWR, 0600 ); if (debug) diag("tempfile %s", tempfile); if (fchmod(fd, (mode_t) (perm & ( S_IRWXU | S_IRWXG | S_IRWXO ) ) ) < 0) efatal("fchmod failed"); if (!exists) (void) unlink(tempfile); if (count == 0) { (void) close(fd); return; } /* * should check for space on disk, but could be expensive and unreliable */ if ((bufsize = count) > 10*1024) buffer = (char *) malloc(bufsize = 10*1024); else buffer = (char *) malloc(bufsize); if (buffer == NULL) fatal("malloc failed"); while (count != 0) { if (debug) diag("loop count %d", count); if ( count > bufsize ) readsize = bufsize; else readsize = count; /* if */ get_buffer ( buffer, &len, readsize, fd ); if ((len2 = write(fd, buffer, len)) != len) { error = errno; (void) close(fd); (void) unlink(tempfile); (void) rmdir(tempdir); errno = error; efatal("write", error); } count -= len; if (count < bufsize) bufsize = count; } if (close(fd) < 0) { error = errno; (void) unlink(tempfile); (void) rmdir(tempdir); errno = error; efatal("close"); } (void) free(buffer); if (debug) diag("transfer complete"); } /* end receive_data */
static int read_header(AVFormatContext *s, AVFormatParameters *ap) { AnmDemuxContext *anm = s->priv_data; ByteIOContext *pb = s->pb; AVStream *st; int i, ret; url_fskip(pb, 4); /* magic number */ if (get_le16(pb) != MAX_PAGES) { av_log_ask_for_sample(s, "max_pages != " AV_STRINGIFY(MAX_PAGES) "\n"); return AVERROR_INVALIDDATA; } anm->nb_pages = get_le16(pb); anm->nb_records = get_le32(pb); url_fskip(pb, 2); /* max records per page */ anm->page_table_offset = get_le16(pb); if (get_le32(pb) != ANIM_TAG) return AVERROR_INVALIDDATA; /* video stream */ st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_ANM; st->codec->codec_tag = 0; /* no fourcc */ st->codec->width = get_le16(pb); st->codec->height = get_le16(pb); if (get_byte(pb) != 0) goto invalid; url_fskip(pb, 1); /* frame rate multiplier info */ /* ignore last delta record (used for looping) */ if (get_byte(pb)) /* has_last_delta */ anm->nb_records = FFMAX(anm->nb_records - 1, 0); url_fskip(pb, 1); /* last_delta_valid */ if (get_byte(pb) != 0) goto invalid; if (get_byte(pb) != 1) goto invalid; url_fskip(pb, 1); /* other recs per frame */ if (get_byte(pb) != 1) goto invalid; url_fskip(pb, 32); /* record_types */ st->nb_frames = get_le32(pb); av_set_pts_info(st, 64, 1, get_le16(pb)); url_fskip(pb, 58); /* color cycling and palette data */ st->codec->extradata_size = 16*8 + 4*256; st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); if (!st->codec->extradata) { ret = AVERROR(ENOMEM); goto close_and_return; } ret = get_buffer(pb, st->codec->extradata, st->codec->extradata_size); if (ret < 0) goto close_and_return; /* read page table */ ret = url_fseek(pb, anm->page_table_offset, SEEK_SET); if (ret < 0) goto close_and_return; for (i = 0; i < MAX_PAGES; i++) { Page *p = &anm->pt[i]; p->base_record = get_le16(pb); p->nb_records = get_le16(pb); p->size = get_le16(pb); } /* find page of first frame */ anm->page = find_record(anm, 0); if (anm->page < 0) { ret = anm->page; goto close_and_return; } anm->record = -1; return 0; invalid: av_log_ask_for_sample(s, NULL); ret = AVERROR_INVALIDDATA; close_and_return: av_close_input_stream(s); return ret; }
struct cpu_context *cpu_context_read(struct target *target, uint32_t base_addr, uint32_t *thread_info_addr_old) { struct cpu_context *context = calloc(1, sizeof(struct cpu_context)); uint32_t preempt_count_addr = 0; uint32_t registers[10]; uint8_t *buffer = calloc(1, 4); uint32_t stack = base_addr + QAT; uint32_t thread_info_addr = 0; uint32_t thread_info_addr_update = 0; int retval = ERROR_FAIL; context->R4 = 0xdeadbeef; context->R5 = 0xdeadbeef; context->R6 = 0xdeadbeef; context->R7 = 0xdeadbeef; context->R8 = 0xdeadbeef; context->R9 = 0xdeadbeef; context->IP = 0xdeadbeef; context->FP = 0xdeadbeef; context->SP = 0xdeadbeef; context->PC = 0xdeadbeef; retry: if (*thread_info_addr_old == 0xdeadbeef) { retval = fill_buffer(target, stack, buffer); if (retval == ERROR_OK) thread_info_addr = get_buffer(target, buffer); else LOG_ERROR("cpu_context: unable to read memory"); thread_info_addr_update = thread_info_addr; } else thread_info_addr = *thread_info_addr_old; preempt_count_addr = thread_info_addr + PREEMPT; retval = fill_buffer(target, preempt_count_addr, buffer); if (retval == ERROR_OK) context->preempt_count = get_buffer(target, buffer); else { if (*thread_info_addr_old != 0xdeadbeef) { LOG_ERROR ("cpu_context: cannot read at thread_info_addr"); if (*thread_info_addr_old < LINUX_USER_KERNEL_BORDER) LOG_INFO ("cpu_context : thread_info_addr in userspace!!!"); *thread_info_addr_old = 0xdeadbeef; goto retry; } LOG_ERROR("cpu_context: unable to read memory"); } thread_info_addr += CPU_CONT; retval = linux_read_memory(target, thread_info_addr, 4, 10, (uint8_t *) registers); if (retval != ERROR_OK) { free(buffer); LOG_ERROR("cpu_context: unable to read memory\n"); return context; } context->R4 = target_buffer_get_u32(target, (const uint8_t *)®isters[0]); context->R5 = target_buffer_get_u32(target, (const uint8_t *)®isters[1]); context->R6 = target_buffer_get_u32(target, (const uint8_t *)®isters[2]); context->R7 = target_buffer_get_u32(target, (const uint8_t *)®isters[3]); context->R8 = target_buffer_get_u32(target, (const uint8_t *)®isters[4]); context->R9 = target_buffer_get_u32(target, (const uint8_t *)®isters[5]); context->IP = target_buffer_get_u32(target, (const uint8_t *)®isters[6]); context->FP = target_buffer_get_u32(target, (const uint8_t *)®isters[7]); context->SP = target_buffer_get_u32(target, (const uint8_t *)®isters[8]); context->PC = target_buffer_get_u32(target, (const uint8_t *)®isters[9]); if (*thread_info_addr_old == 0xdeadbeef) *thread_info_addr_old = thread_info_addr_update; free(buffer); return context; }
static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt) { SmackerContext *smk = s->priv_data; int flags; int ret; int i; int frame_size = 0; int palchange = 0; int pos; if (url_feof(s->pb) || smk->cur_frame >= smk->frames) return AVERROR_EOF; /* if we demuxed all streams, pass another frame */ if(smk->curstream < 0) { url_fseek(s->pb, smk->nextpos, 0); frame_size = smk->frm_size[smk->cur_frame] & (~3); flags = smk->frm_flags[smk->cur_frame]; /* handle palette change event */ pos = url_ftell(s->pb); if(flags & SMACKER_PAL){ int size, sz, t, off, j, pos; uint8_t *pal = smk->pal; uint8_t oldpal[768]; memcpy(oldpal, pal, 768); size = get_byte(s->pb); size = size * 4 - 1; frame_size -= size; frame_size--; sz = 0; pos = url_ftell(s->pb) + size; while(sz < 256){ t = get_byte(s->pb); if(t & 0x80){ /* skip palette entries */ sz += (t & 0x7F) + 1; pal += ((t & 0x7F) + 1) * 3; } else if(t & 0x40){ /* copy with offset */ off = get_byte(s->pb) * 3; j = (t & 0x3F) + 1; while(j-- && sz < 256) { *pal++ = oldpal[off + 0]; *pal++ = oldpal[off + 1]; *pal++ = oldpal[off + 2]; sz++; off += 3; } } else { /* new entries */ *pal++ = smk_pal[t]; *pal++ = smk_pal[get_byte(s->pb) & 0x3F]; *pal++ = smk_pal[get_byte(s->pb) & 0x3F]; sz++; } } url_fseek(s->pb, pos, 0); palchange |= 1; } flags >>= 1; smk->curstream = -1; /* if audio chunks are present, put them to stack and retrieve later */ for(i = 0; i < 7; i++) { if(flags & 1) { int size; size = get_le32(s->pb) - 4; frame_size -= size; frame_size -= 4; smk->curstream++; smk->bufs[smk->curstream] = av_realloc(smk->bufs[smk->curstream], size); smk->buf_sizes[smk->curstream] = size; ret = get_buffer(s->pb, smk->bufs[smk->curstream], size); if(ret != size) return AVERROR(EIO); smk->stream_id[smk->curstream] = smk->indexes[i]; } flags >>= 1; } if (av_new_packet(pkt, frame_size + 768)) return AVERROR(ENOMEM); if(smk->frm_size[smk->cur_frame] & 1) palchange |= 2; pkt->data[0] = palchange; memcpy(pkt->data + 1, smk->pal, 768); ret = get_buffer(s->pb, pkt->data + 769, frame_size); if(ret != frame_size) return AVERROR(EIO); pkt->stream_index = smk->videoindex; pkt->size = ret + 769; smk->cur_frame++; smk->nextpos = url_ftell(s->pb); } else {
/** * See GL_ARB_map_buffer_range spec */ void * GLAPIENTRY _mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { GET_CURRENT_CONTEXT(ctx); struct gl_buffer_object *bufObj; void *map; ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL); if (!ctx->Extensions.ARB_map_buffer_range) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferRange(extension not supported)"); return NULL; } if (offset < 0) { _mesa_error(ctx, GL_INVALID_VALUE, "glMapBufferRange(offset = %ld)", (long)offset); return NULL; } if (length < 0) { _mesa_error(ctx, GL_INVALID_VALUE, "glMapBufferRange(length = %ld)", (long)length); return NULL; } if (access & ~(GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_UNSYNCHRONIZED_BIT)) { /* generate an error if any undefind bit is set */ _mesa_error(ctx, GL_INVALID_VALUE, "glMapBufferRange(access)"); return NULL; } if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferRange(access indicates neither read or write)"); return NULL; } if ((access & GL_MAP_READ_BIT) && (access & (GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT))) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferRange(invalid access flags)"); return NULL; } if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) && ((access & GL_MAP_WRITE_BIT) == 0)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferRange(invalid access flags)"); return NULL; } bufObj = get_buffer(ctx, "glMapBufferRange", target); if (!bufObj) return NULL; if (offset + length > bufObj->Size) { _mesa_error(ctx, GL_INVALID_VALUE, "glMapBufferRange(offset + length > size)"); return NULL; } if (_mesa_bufferobj_mapped(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferRange(buffer already mapped)"); return NULL; } if (!bufObj->Size) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferRange(buffer size = 0)"); return NULL; } /* Mapping zero bytes should return a non-null pointer. */ if (!length) { static long dummy = 0; bufObj->Pointer = &dummy; bufObj->Length = length; bufObj->Offset = offset; bufObj->AccessFlags = access; return bufObj->Pointer; } ASSERT(ctx->Driver.MapBufferRange); map = ctx->Driver.MapBufferRange(ctx, offset, length, access, bufObj); if (!map) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)"); } else { /* The driver callback should have set all these fields. * This is important because other modules (like VBO) might call * the driver function directly. */ ASSERT(bufObj->Pointer == map); ASSERT(bufObj->Length == length); ASSERT(bufObj->Offset == offset); ASSERT(bufObj->AccessFlags == access); } return map; }
static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap) { ByteIOContext *pb = s->pb; SmackerContext *smk = s->priv_data; AVStream *st, *ast[7]; int i, ret; int tbase; /* read and check header */ smk->magic = get_le32(pb); if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != MKTAG('S', 'M', 'K', '4')) return -1; smk->width = get_le32(pb); smk->height = get_le32(pb); smk->frames = get_le32(pb); smk->pts_inc = (int32_t)get_le32(pb); smk->flags = get_le32(pb); if(smk->flags & SMACKER_FLAG_RING_FRAME) smk->frames++; for(i = 0; i < 7; i++) smk->audio[i] = get_le32(pb); smk->treesize = get_le32(pb); if(smk->treesize >= UINT_MAX/4){ // smk->treesize + 16 must not overflow (this check is probably redundant) av_log(s, AV_LOG_ERROR, "treesize too large\n"); return -1; } //FIXME remove extradata "rebuilding" smk->mmap_size = get_le32(pb); smk->mclr_size = get_le32(pb); smk->full_size = get_le32(pb); smk->type_size = get_le32(pb); for(i = 0; i < 7; i++) smk->rates[i] = get_le32(pb); smk->pad = get_le32(pb); /* setup data */ if(smk->frames > 0xFFFFFF) { av_log(s, AV_LOG_ERROR, "Too many frames: %i\n", smk->frames); return -1; } smk->frm_size = av_malloc(smk->frames * 4); smk->frm_flags = av_malloc(smk->frames); smk->is_ver4 = (smk->magic != MKTAG('S', 'M', 'K', '2')); /* read frame info */ for(i = 0; i < smk->frames; i++) { smk->frm_size[i] = get_le32(pb); } for(i = 0; i < smk->frames; i++) { smk->frm_flags[i] = get_byte(pb); } /* init video codec */ st = av_new_stream(s, 0); if (!st) return -1; smk->videoindex = st->index; st->codec->width = smk->width; st->codec->height = smk->height; st->codec->pix_fmt = PIX_FMT_PAL8; st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_SMACKVIDEO; st->codec->codec_tag = smk->magic; /* Smacker uses 100000 as internal timebase */ if(smk->pts_inc < 0) smk->pts_inc = -smk->pts_inc; else smk->pts_inc *= 100; tbase = 100000; av_reduce(&tbase, &smk->pts_inc, tbase, smk->pts_inc, (1UL<<31)-1); av_set_pts_info(st, 33, smk->pts_inc, tbase); st->duration = smk->frames; /* handle possible audio streams */ for(i = 0; i < 7; i++) { smk->indexes[i] = -1; if(smk->rates[i] & 0xFFFFFF){ ast[i] = av_new_stream(s, 0); smk->indexes[i] = ast[i]->index; ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO; if (smk->rates[i] & SMK_AUD_BINKAUD) { ast[i]->codec->codec_id = CODEC_ID_BINKAUDIO_RDFT; } else if (smk->rates[i] & SMK_AUD_USEDCT) { ast[i]->codec->codec_id = CODEC_ID_BINKAUDIO_DCT; } else if (smk->rates[i] & SMK_AUD_PACKED){ ast[i]->codec->codec_id = CODEC_ID_SMACKAUDIO; ast[i]->codec->codec_tag = MKTAG('S', 'M', 'K', 'A'); } else { ast[i]->codec->codec_id = CODEC_ID_PCM_U8; } ast[i]->codec->channels = (smk->rates[i] & SMK_AUD_STEREO) ? 2 : 1; ast[i]->codec->sample_rate = smk->rates[i] & 0xFFFFFF; ast[i]->codec->bits_per_coded_sample = (smk->rates[i] & SMK_AUD_16BITS) ? 16 : 8; if(ast[i]->codec->bits_per_coded_sample == 16 && ast[i]->codec->codec_id == CODEC_ID_PCM_U8) ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE; av_set_pts_info(ast[i], 64, 1, ast[i]->codec->sample_rate * ast[i]->codec->channels * ast[i]->codec->bits_per_coded_sample / 8); } } /* load trees to extradata, they will be unpacked by decoder */ st->codec->extradata = av_malloc(smk->treesize + 16); st->codec->extradata_size = smk->treesize + 16; if(!st->codec->extradata){ av_log(s, AV_LOG_ERROR, "Cannot allocate %i bytes of extradata\n", smk->treesize + 16); av_free(smk->frm_size); av_free(smk->frm_flags); return -1; } ret = get_buffer(pb, st->codec->extradata + 16, st->codec->extradata_size - 16); if(ret != st->codec->extradata_size - 16){ av_free(smk->frm_size); av_free(smk->frm_flags); return AVERROR(EIO); } ((int32_t*)st->codec->extradata)[0] = av_le2ne32(smk->mmap_size); ((int32_t*)st->codec->extradata)[1] = av_le2ne32(smk->mclr_size); ((int32_t*)st->codec->extradata)[2] = av_le2ne32(smk->full_size); ((int32_t*)st->codec->extradata)[3] = av_le2ne32(smk->type_size); smk->curstream = -1; smk->nextpos = url_ftell(pb); return 0; }
void * GLAPIENTRY _mesa_MapBufferARB(GLenum target, GLenum access) { GET_CURRENT_CONTEXT(ctx); struct gl_buffer_object * bufObj; GLbitfield accessFlags; void *map; ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL); switch (access) { case GL_READ_ONLY_ARB: accessFlags = GL_MAP_READ_BIT; break; case GL_WRITE_ONLY_ARB: accessFlags = GL_MAP_WRITE_BIT; break; case GL_READ_WRITE_ARB: accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)"); return NULL; } bufObj = get_buffer(ctx, "glMapBufferARB", target); if (!bufObj) return NULL; if (_mesa_bufferobj_mapped(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)"); return NULL; } if (!bufObj->Size) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBuffer(buffer size = 0)"); return NULL; } ASSERT(ctx->Driver.MapBufferRange); map = ctx->Driver.MapBufferRange(ctx, 0, bufObj->Size, accessFlags, bufObj); if (!map) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)"); return NULL; } else { /* The driver callback should have set these fields. * This is important because other modules (like VBO) might call * the driver function directly. */ ASSERT(bufObj->Pointer == map); ASSERT(bufObj->Length == bufObj->Size); ASSERT(bufObj->Offset == 0); bufObj->AccessFlags = accessFlags; } if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB) bufObj->Written = GL_TRUE; #ifdef VBO_DEBUG printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n", bufObj->Name, bufObj->Size, access); if (access == GL_WRITE_ONLY_ARB) { GLuint i; GLubyte *b = (GLubyte *) bufObj->Pointer; for (i = 0; i < bufObj->Size; i++) b[i] = i & 0xff; } #endif #ifdef BOUNDS_CHECK { GLubyte *buf = (GLubyte *) bufObj->Pointer; GLuint i; /* buffer is 100 bytes larger than requested, fill with magic value */ for (i = 0; i < 100; i++) { buf[bufObj->Size - i - 1] = 123; } } #endif return bufObj->Pointer; }
static int nuv_header(AVFormatContext *s, AVFormatParameters *ap) { NUVContext *ctx = s->priv_data; ByteIOContext *pb = s->pb; char id_string[12]; double aspect, fps; int is_mythtv, width, height, v_packs, a_packs; int stream_nr = 0; AVStream *vst = NULL, *ast = NULL; get_buffer(pb, id_string, 12); is_mythtv = !memcmp(id_string, "MythTVVideo", 12); url_fskip(pb, 5); // version string url_fskip(pb, 3); // padding width = get_le32(pb); height = get_le32(pb); get_le32(pb); // unused, "desiredwidth" get_le32(pb); // unused, "desiredheight" get_byte(pb); // 'P' == progressive, 'I' == interlaced url_fskip(pb, 3); // padding aspect = av_int2dbl(get_le64(pb)); if (aspect > 0.9999 && aspect < 1.0001) aspect = 4.0 / 3.0; fps = av_int2dbl(get_le64(pb)); // number of packets per stream type, -1 means unknown, e.g. streaming v_packs = get_le32(pb); a_packs = get_le32(pb); get_le32(pb); // text get_le32(pb); // keyframe distance (?) if (v_packs) { ctx->v_id = stream_nr++; vst = av_new_stream(s, ctx->v_id); if (!vst) return AVERROR(ENOMEM); vst->codec->codec_type = CODEC_TYPE_VIDEO; vst->codec->codec_id = CODEC_ID_NUV; vst->codec->width = width; vst->codec->height = height; vst->codec->bits_per_coded_sample = 10; vst->sample_aspect_ratio = av_d2q(aspect * height / width, 10000); vst->r_frame_rate = av_d2q(fps, 60000); av_set_pts_info(vst, 32, 1, 1000); } else ctx->v_id = -1; if (a_packs) { ctx->a_id = stream_nr++; ast = av_new_stream(s, ctx->a_id); if (!ast) return AVERROR(ENOMEM); ast->codec->codec_type = CODEC_TYPE_AUDIO; ast->codec->codec_id = CODEC_ID_PCM_S16LE; ast->codec->channels = 2; ast->codec->sample_rate = 44100; ast->codec->bit_rate = 2 * 2 * 44100 * 8; ast->codec->block_align = 2 * 2; ast->codec->bits_per_coded_sample = 16; av_set_pts_info(ast, 32, 1, 1000); } else ctx->a_id = -1; get_codec_data(pb, vst, ast, is_mythtv); ctx->rtjpg_video = vst && vst->codec->codec_id == CODEC_ID_NUV; return 0; }
/// The commandline builtin. It is used for specifying a new value for the commandline. int builtin_commandline(parser_t &parser, io_streams_t &streams, wchar_t **argv) { wgetopter_t w; int buffer_part = 0; int cut_at_cursor = 0; int argc = builtin_count_args(argv); int append_mode = 0; int function_mode = 0; int selection_mode = 0; int tokenize = 0; int cursor_mode = 0; int line_mode = 0; int search_mode = 0; int paging_mode = 0; const wchar_t *begin = NULL, *end = NULL; scoped_push<const wchar_t *> saved_current_buffer(¤t_buffer); scoped_push<size_t> saved_current_cursor_pos(¤t_cursor_pos); wcstring transient_commandline; if (get_top_transient(&transient_commandline)) { current_buffer = transient_commandline.c_str(); current_cursor_pos = transient_commandline.size(); } else { current_buffer = reader_get_buffer(); current_cursor_pos = reader_get_cursor_pos(); } if (!get_buffer()) { if (is_interactive_session) { // Prompt change requested while we don't have a prompt, most probably while reading the // init files. Just ignore it. return 1; } streams.err.append(argv[0]); streams.err.append(L": Can not set commandline in non-interactive mode\n"); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } w.woptind = 0; while (1) { static const struct woption long_options[] = {{L"append", no_argument, 0, 'a'}, {L"insert", no_argument, 0, 'i'}, {L"replace", no_argument, 0, 'r'}, {L"current-job", no_argument, 0, 'j'}, {L"current-process", no_argument, 0, 'p'}, {L"current-token", no_argument, 0, 't'}, {L"current-buffer", no_argument, 0, 'b'}, {L"cut-at-cursor", no_argument, 0, 'c'}, {L"function", no_argument, 0, 'f'}, {L"tokenize", no_argument, 0, 'o'}, {L"help", no_argument, 0, 'h'}, {L"input", required_argument, 0, 'I'}, {L"cursor", no_argument, 0, 'C'}, {L"line", no_argument, 0, 'L'}, {L"search-mode", no_argument, 0, 'S'}, {L"selection", no_argument, 0, 's'}, {L"paging-mode", no_argument, 0, 'P'}, {0, 0, 0, 0}}; int opt_index = 0; int opt = w.wgetopt_long(argc, argv, L"abijpctwforhI:CLSsP", long_options, &opt_index); if (opt == -1) break; switch (opt) { case 0: { if (long_options[opt_index].flag != 0) break; streams.err.append_format(BUILTIN_ERR_UNKNOWN, argv[0], long_options[opt_index].name); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } case L'a': { append_mode = APPEND_MODE; break; } case L'b': { buffer_part = STRING_MODE; break; } case L'i': { append_mode = INSERT_MODE; break; } case L'r': { append_mode = REPLACE_MODE; break; } case 'c': { cut_at_cursor = 1; break; } case 't': { buffer_part = TOKEN_MODE; break; } case 'j': { buffer_part = JOB_MODE; break; } case 'p': { buffer_part = PROCESS_MODE; break; } case 'f': { function_mode = 1; break; } case 'o': { tokenize = 1; break; } case 'I': { current_buffer = w.woptarg; current_cursor_pos = wcslen(w.woptarg); break; } case 'C': { cursor_mode = 1; break; } case 'L': { line_mode = 1; break; } case 'S': { search_mode = 1; break; } case 's': { selection_mode = 1; break; } case 'P': { paging_mode = 1; break; } case 'h': { builtin_print_help(parser, streams, argv[0], streams.out); return 0; } case L'?': { builtin_unknown_option(parser, streams, argv[0], argv[w.woptind - 1]); return 1; } } } if (function_mode) { int i; // Check for invalid switch combinations. if (buffer_part || cut_at_cursor || append_mode || tokenize || cursor_mode || line_mode || search_mode || paging_mode) { streams.err.append_format(BUILTIN_ERR_COMBO, argv[0]); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } if (argc == w.woptind) { streams.err.append_format(BUILTIN_ERR_MISSING, argv[0]); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } for (i = w.woptind; i < argc; i++) { wchar_t c = input_function_get_code(argv[i]); if (c != INPUT_CODE_NONE) { // input_unreadch inserts the specified keypress or readline function at the back of // the queue of unused keypresses. input_queue_ch(c); } else { streams.err.append_format(_(L"%ls: Unknown input function '%ls'\n"), argv[0], argv[i]); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } } return 0; } if (selection_mode) { size_t start, len; const wchar_t *buffer = reader_get_buffer(); if (reader_get_selection(&start, &len)) { streams.out.append(buffer + start, len); } return 0; } // Check for invalid switch combinations. if ((search_mode || line_mode || cursor_mode || paging_mode) && (argc - w.woptind > 1)) { streams.err.append_format(argv[0], L": Too many arguments\n", NULL); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } if ((buffer_part || tokenize || cut_at_cursor) && (cursor_mode || line_mode || search_mode || paging_mode)) { streams.err.append_format(BUILTIN_ERR_COMBO, argv[0]); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } if ((tokenize || cut_at_cursor) && (argc - w.woptind)) { streams.err.append_format( BUILTIN_ERR_COMBO2, argv[0], L"--cut-at-cursor and --tokenize can not be used when setting the commandline"); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } if (append_mode && !(argc - w.woptind)) { streams.err.append_format( BUILTIN_ERR_COMBO2, argv[0], L"insertion mode switches can not be used when not in insertion mode"); builtin_print_help(parser, streams, argv[0], streams.err); return 1; } // Set default modes. if (!append_mode) { append_mode = REPLACE_MODE; } if (!buffer_part) { buffer_part = STRING_MODE; } if (cursor_mode) { if (argc - w.woptind) { wchar_t *endptr; long new_pos; errno = 0; new_pos = wcstol(argv[w.woptind], &endptr, 10); if (*endptr || errno) { streams.err.append_format(BUILTIN_ERR_NOT_NUMBER, argv[0], argv[w.woptind]); builtin_print_help(parser, streams, argv[0], streams.err); } current_buffer = reader_get_buffer(); new_pos = maxi(0L, mini(new_pos, (long)wcslen(current_buffer))); reader_set_buffer(current_buffer, (size_t)new_pos); return 0; } else { streams.out.append_format(L"%lu\n", (unsigned long)reader_get_cursor_pos()); return 0; } } if (line_mode) { size_t pos = reader_get_cursor_pos(); const wchar_t *buff = reader_get_buffer(); streams.out.append_format(L"%lu\n", (unsigned long)parse_util_lineno(buff, pos)); return 0; } if (search_mode) { return !reader_search_mode(); } if (paging_mode) { return !reader_has_pager_contents(); } switch (buffer_part) { case STRING_MODE: { begin = get_buffer(); end = begin + wcslen(begin); break; } case PROCESS_MODE: { parse_util_process_extent(get_buffer(), get_cursor_pos(), &begin, &end); break; } case JOB_MODE: { parse_util_job_extent(get_buffer(), get_cursor_pos(), &begin, &end); break; } case TOKEN_MODE: { parse_util_token_extent(get_buffer(), get_cursor_pos(), &begin, &end, 0, 0); break; } } switch (argc - w.woptind) { case 0: { write_part(begin, end, cut_at_cursor, tokenize, streams); break; } case 1: { replace_part(begin, end, argv[w.woptind], append_mode); break; } default: { wcstring sb = argv[w.woptind]; for (int i = w.woptind + 1; i < argc; i++) { sb.push_back(L'\n'); sb.append(argv[i]); } replace_part(begin, end, sb.c_str(), append_mode); break; } } return 0; }
static int nuv_packet(AVFormatContext *s, AVPacket *pkt) { NUVContext *ctx = s->priv_data; ByteIOContext *pb = s->pb; uint8_t hdr[HDRSIZE]; nuv_frametype frametype; int ret, size; while (!url_feof(pb)) { int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0; uint64_t pos = url_ftell(pb); ret = get_buffer(pb, hdr, HDRSIZE); if (ret < HDRSIZE) return ret < 0 ? ret : AVERROR(EIO); frametype = hdr[0]; size = PKTSIZE(AV_RL32(&hdr[8])); switch (frametype) { case NUV_EXTRADATA: if (!ctx->rtjpg_video) { url_fskip(pb, size); break; } case NUV_VIDEO: if (ctx->v_id < 0) { av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n"); url_fskip(pb, size); break; } ret = av_new_packet(pkt, copyhdrsize + size); if (ret < 0) return ret; // HACK: we have no idea if it is a keyframe, // but if we mark none seeking will not work at all. pkt->flags |= PKT_FLAG_KEY; pkt->pos = pos; pkt->pts = AV_RL32(&hdr[4]); pkt->stream_index = ctx->v_id; memcpy(pkt->data, hdr, copyhdrsize); ret = get_buffer(pb, pkt->data + copyhdrsize, size); if (ret < 0) { av_free_packet(pkt); return ret; } if (ret < size) av_shrink_packet(pkt, copyhdrsize + ret); return 0; case NUV_AUDIO: if (ctx->a_id < 0) { av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n"); url_fskip(pb, size); break; } ret = av_get_packet(pb, pkt, size); pkt->flags |= PKT_FLAG_KEY; pkt->pos = pos; pkt->pts = AV_RL32(&hdr[4]); pkt->stream_index = ctx->a_id; if (ret < 0) return ret; return 0; case NUV_SEEKP: // contains no data, size value is invalid break; default: url_fskip(pb, size); break; } } return AVERROR(EIO); }
void PrintNotesNoteAddin::on_draw_page(const Glib::RefPtr<Gtk::PrintContext>& context, guint page_nr) { Cairo::RefPtr<Cairo::Context> cr = context->get_cairo_context(); cr->move_to (m_margin_left, m_margin_top); PageBreak start; if (page_nr != 0) { start = m_page_breaks [page_nr - 1]; } PageBreak end(-1, -1); if (m_page_breaks.size() > page_nr) { end = m_page_breaks [page_nr]; } Gtk::TextIter position; Gtk::TextIter end_iter; get_buffer()->get_bounds (position, end_iter); // Fast-forward to the starting line while (position.get_line() < start.get_paragraph()) { position.forward_line (); } bool done = position.compare (end_iter) >= 0; while (!done) { Gtk::TextIter line_end = position; if (!line_end.ends_line ()) { line_end.forward_to_line_end (); } int paragraph_number = position.get_line(); int indentation; { Glib::RefPtr<Pango::Layout> layout = create_layout_for_paragraph (context,position, line_end, indentation); for(int line_number = 0; line_number < layout->get_line_count() && !done; line_number++) { // Skip the lines up to the starting line in the // first paragraph on this page if ((paragraph_number == start.get_paragraph()) && (line_number < start.get_line())) { continue; } // Break as soon as we hit the end line if ((paragraph_number == end.get_paragraph()) && (line_number == end.get_line())) { done = true; break; } Glib::RefPtr<Pango::LayoutLine> line = layout->get_line(line_number); Pango::Rectangle ink_rect; Pango::Rectangle logical_rect; line->get_extents (ink_rect, logical_rect); double curX, curY; cr->get_current_point(curX, curY); cr->move_to (m_margin_left + indentation, curY); int line_height = pango_units_to_double(logical_rect.get_height()); double x, y; x = m_margin_left + indentation; cr->get_current_point(curX, curY); y = curY + line_height; pango_cairo_show_layout_line(cr->cobj(), line->gobj()); cr->move_to(x, y); } } position.forward_line (); done = done || (position.compare (end_iter) >= 0); } // Print the footer int total_height = context->get_height(); int total_width = context->get_width(); int footer_height = 0; double footer_anchor_x, footer_anchor_y; { Glib::RefPtr<Pango::Layout> pages_footer = create_layout_for_pagenumbers (context, page_nr + 1, m_page_breaks.size() + 1); Pango::Rectangle ink_footer_rect; Pango::Rectangle logical_footer_rect; pages_footer->get_extents(ink_footer_rect, logical_footer_rect); footer_anchor_x = cm_to_pixel(0.5, context->get_dpi_x()); footer_anchor_y = total_height - m_margin_bottom; footer_height = pango_units_to_double(logical_footer_rect.get_height()); cr->move_to(total_width - pango_units_to_double(logical_footer_rect.get_width()) - cm_to_pixel(0.5, context->get_dpi_x()), footer_anchor_y); pango_cairo_show_layout_line(cr->cobj(), (pages_footer->get_line(0))->gobj()); } cr->move_to(footer_anchor_x, footer_anchor_y); pango_cairo_show_layout_line(cr->cobj(), (m_timestamp_footer->get_line(0))->gobj()); cr->move_to(cm_to_pixel(0.5, context->get_dpi_x()), total_height - m_margin_bottom - footer_height); cr->line_to(total_width - cm_to_pixel(0.5, context->get_dpi_x()), total_height - m_margin_bottom - footer_height); cr->stroke(); }
static int flic_read_packet(AVFormatContext *s, AVPacket *pkt) { FlicDemuxContext *flic = s->priv_data; ByteIOContext *pb = s->pb; int packet_read = 0; unsigned int size; int magic; int ret = 0; unsigned char preamble[FLIC_PREAMBLE_SIZE]; while (!packet_read) { if ((ret = get_buffer(pb, preamble, FLIC_PREAMBLE_SIZE)) != FLIC_PREAMBLE_SIZE) { ret = AVERROR(EIO); break; } size = AV_RL32(&preamble[0]); magic = AV_RL16(&preamble[4]); if (((magic == FLIC_CHUNK_MAGIC_1) || (magic == FLIC_CHUNK_MAGIC_2)) && size > FLIC_PREAMBLE_SIZE) { if (av_new_packet(pkt, size)) { ret = AVERROR(EIO); break; } pkt->stream_index = flic->video_stream_index; pkt->pts = flic->frame_number++; pkt->pos = url_ftell(pb); memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE); ret = get_buffer(pb, pkt->data + FLIC_PREAMBLE_SIZE, size - FLIC_PREAMBLE_SIZE); if (ret != size - FLIC_PREAMBLE_SIZE) { av_free_packet(pkt); ret = AVERROR(EIO); } packet_read = 1; } else if (magic == FLIC_TFTD_CHUNK_AUDIO) { if (av_new_packet(pkt, size)) { ret = AVERROR(EIO); break; } /* skip useless 10B sub-header (yes, it's not accounted for in the chunk header) */ url_fseek(pb, 10, SEEK_CUR); pkt->stream_index = flic->audio_stream_index; pkt->pos = url_ftell(pb); ret = get_buffer(pb, pkt->data, size); if (ret != size) { av_free_packet(pkt); ret = AVERROR(EIO); } packet_read = 1; } else { /* not interested in this chunk */ url_fseek(pb, size - 6, SEEK_CUR); } } return ret; }