static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data) { PacketWriter *writer = user_data; AVPacket *packet = writer->packet; if (nb_bytes < 0) { if (writer->pos == 0) { return (OPJ_SIZE_T)-1; } if (nb_bytes + writer->pos < 0) { nb_bytes = -writer->pos; } } else { int remaining = packet->size - writer->pos; if (nb_bytes > remaining) { OPJ_SIZE_T needed = nb_bytes - remaining; int max_growth = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - packet->size; if (needed > max_growth) { return (OPJ_SIZE_T)-1; } if (av_grow_packet(packet, (int)needed)) { return (OPJ_SIZE_T)-1; } } } writer->pos += (int)nb_bytes; return nb_bytes; }
static int alloc_and_copy(AVPacket *out, const uint8_t *sps_pps, uint32_t sps_pps_size, const uint8_t *in, uint32_t in_size) { uint32_t offset = out->size; uint8_t nal_header_size = offset ? 3 : 4; int err; err = av_grow_packet(out, sps_pps_size + in_size + nal_header_size); if (err < 0) return err; if (sps_pps) memcpy(out->data + offset, sps_pps, sps_pps_size); memcpy(out->data + sps_pps_size + nal_header_size + offset, in, in_size); if (!offset) { AV_WB32(out->data + sps_pps_size, 1); } else { (out->data + offset + sps_pps_size)[0] = (out->data + offset + sps_pps_size)[1] = 0; (out->data + offset + sps_pps_size)[2] = 1; } return 0; }
AVPacket *ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, int len, int merge) { AVPacket *subs, *sub; if (merge && q->nb_subs > 0) { /* merge with previous event */ int old_len; sub = &q->subs[q->nb_subs - 1]; old_len = sub->size; if (av_grow_packet(sub, len) < 0) return NULL; memcpy(sub->data + old_len, event, len); } else { /* new event */ if (q->nb_subs >= INT_MAX/sizeof(*q->subs) - 1) return NULL; subs = av_fast_realloc(q->subs, &q->allocated_size, (q->nb_subs + 1) * sizeof(*q->subs)); if (!subs) return NULL; q->subs = subs; sub = &subs[q->nb_subs++]; if (av_new_packet(sub, len) < 0) return NULL; sub->flags |= AV_PKT_FLAG_KEY; sub->pts = sub->dts = 0; memcpy(sub->data, event, len); } return sub; }
static int wv_read_packet(AVFormatContext *s, AVPacket *pkt) { WVContext *wc = s->priv_data; int ret; int off; int64_t pos; uint32_t block_samples; if (url_feof(s->pb)) return AVERROR_EOF; if (wc->block_parsed) { if ((ret = wv_read_block_header(s, s->pb)) < 0) return ret; } pos = wc->pos; if (av_new_packet(pkt, wc->header.blocksize + WV_HEADER_SIZE) < 0) return AVERROR(ENOMEM); memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE); ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->header.blocksize); if (ret != wc->header.blocksize) { av_free_packet(pkt); return AVERROR(EIO); } while (!(wc->header.flags & WV_FLAG_FINAL_BLOCK)) { if ((ret = wv_read_block_header(s, s->pb)) < 0) { av_free_packet(pkt); return ret; } off = pkt->size; if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->header.blocksize)) < 0) { av_free_packet(pkt); return ret; } memcpy(pkt->data + off, wc->block_header, WV_HEADER_SIZE); ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->header.blocksize); if (ret != wc->header.blocksize) { av_free_packet(pkt); return (ret < 0) ? ret : AVERROR_EOF; } } pkt->stream_index = 0; wc->block_parsed = 1; pkt->pts = wc->header.block_idx; block_samples = wc->header.samples; if (block_samples > INT32_MAX) av_log(s, AV_LOG_WARNING, "Too many samples in block: %"PRIu32"\n", block_samples); else pkt->duration = block_samples; av_add_index_entry(s->streams[0], pos, pkt->pts, 0, 0, AVINDEX_KEYFRAME); return 0; }
static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data) { PacketWriter *writer = user_data; AVPacket *packet = writer->packet; if (nb_bytes < 0) { return OPJ_FALSE; } if (nb_bytes > packet->size) { if (nb_bytes > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE || av_grow_packet(packet, (int)nb_bytes - packet->size)) { return OPJ_FALSE; } } writer->pos = (int)nb_bytes; return OPJ_TRUE; }
static int append_packet_chunked_with_pts(AVIOContext *s, AVPacket *pkt, int explicit_pts, int64_t *pts, int size) { int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos int orig_size = pkt->size; int ret; do { int prev_size = pkt->size; int read_size; /* When the caller requests a lot of data, limit it to the amount * left in file or SANE_CHUNK_SIZE when it is not known. */ read_size = size; if (read_size > SANE_CHUNK_SIZE/10) { read_size = ffio_limit(s, read_size); // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE if (s->maxsize < 0) read_size = FFMIN(read_size, SANE_CHUNK_SIZE); } ret = av_grow_packet(pkt, read_size); if (ret < 0) break; ret = avio_read(s, (unsigned char*)pts, sizeof(int64_t)); if (ret != sizeof(int64_t)) { av_shrink_packet(pkt, prev_size + FFMAX(ret, 0)); break; } ret = avio_read(s, pkt->data + prev_size, read_size); if (ret != read_size) { av_shrink_packet(pkt, prev_size + FFMAX(ret, 0)); break; } size -= read_size; } while (size > 0); if (size > 0) pkt->flags |= AV_PKT_FLAG_CORRUPT; pkt->pos = orig_pos; if (!pkt->size) av_free_packet(pkt); return pkt->size > orig_size ? pkt->size - orig_size : ret; }
static OPJ_SIZE_T stream_write(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data) { PacketWriter *writer = user_data; AVPacket *packet = writer->packet; int remaining = packet->size - writer->pos; if (nb_bytes > remaining) { OPJ_SIZE_T needed = nb_bytes - remaining; int max_growth = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - packet->size; if (needed > max_growth) { return (OPJ_SIZE_T)-1; } if (av_grow_packet(packet, (int)needed)) { return (OPJ_SIZE_T)-1; } } memcpy(packet->data + writer->pos, out_buffer, nb_bytes); writer->pos += (int)nb_bytes; return nb_bytes; }
/* * Class: org_jitsi_impl_neomedia_codec_FFmpeg * Method: avpacket_set_data * Signature: (J[BII)V */ JNIEXPORT void JNICALL Java_org_jitsi_impl_neomedia_codec_FFmpeg_avpacket_1set_1data (JNIEnv *env, jclass clazz, jlong pkt, jbyteArray data, jint offset, jint length) { jbyte *data_; jboolean ok; if (data) { data_ = (*env)->GetPrimitiveArrayCritical(env, data, NULL); ok = data_ ? JNI_TRUE : JNI_FALSE; } else { data_ = NULL; ok = JNI_TRUE; } if (JNI_TRUE == ok) { int delta; AVPacket *pkt_ = (AVPacket *) (intptr_t) pkt; delta = length - pkt_->size; if (delta > 0) { if (av_grow_packet(pkt_, delta) != 0) ok = JNI_FALSE; } else if (delta < 0) { av_shrink_packet(pkt_, length); } if (JNI_TRUE == ok) memcpy(pkt_->data, data_ + offset, length); if (data_) (*env)->ReleasePrimitiveArrayCritical(env, data, data_, JNI_ABORT); } }
int Packet::SetDataSize(int len) { if (len < 0) return -1; if (len <= GetDataSize()) { av_shrink_packet(m_Packet, len); return 0; } if (!m_Packet) { m_Packet = av_packet_alloc(); if (av_new_packet(m_Packet, len) < 0) return -1; } else { if (av_grow_packet(m_Packet, (len - m_Packet->size)) < 0) return -1; } return 0; }