static void flush_packet(AVFormatContext *s) { FFMContext *ffm = s->priv_data; int fill_size, h; ByteIOContext *pb = s->pb; fill_size = ffm->packet_end - ffm->packet_ptr; memset(ffm->packet_ptr, 0, fill_size); if (url_ftell(pb) % ffm->packet_size) av_abort(); /* put header */ put_be16(pb, PACKET_ID); put_be16(pb, fill_size); put_be64(pb, ffm->dts); h = ffm->frame_offset; if (ffm->first_packet) h |= 0x8000; put_be16(pb, h); put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet); put_flush_packet(pb); /* prepare next packet */ ffm->frame_offset = 0; /* no key frame */ ffm->packet_ptr = ffm->packet; ffm->first_packet = 0; }
static void write_sgi_header(ByteIOContext *f, const SGIInfo *info) { int i; put_be16(f, SGI_MAGIC); put_byte(f, info->rle); put_byte(f, info->bytes_per_channel); put_be16(f, info->dimension); put_be16(f, info->xsize); put_be16(f, info->ysize); put_be16(f, info->zsize); /* The rest are constant in this implementation */ put_be32(f, 0L); /* pixmin */ put_be32(f, 255L); /* pixmax */ put_be32(f, 0L); /* dummy */ /* name */ for (i = 0; i < 80; i++) { put_byte(f, 0); } put_be32(f, 0L); /* colormap */ /* The rest of the 512 byte header is unused. */ for (i = 0; i < 404; i++) { put_byte(f, 0); } }
static int gxf_write_media_preamble(ByteIOContext *pb, GXFContext *ctx, AVPacket *pkt, int size) { GXFStreamContext *sc = &ctx->streams[pkt->stream_index]; int64_t dts = av_rescale_rnd(pkt->dts, ctx->sample_rate, sc->codec->time_base.den, AV_ROUND_UP); put_byte(pb, sc->media_type); put_byte(pb, sc->index); put_be32(pb, dts); if (sc->codec->codec_type == CODEC_TYPE_AUDIO) { put_be16(pb, 0); put_be16(pb, size / 2); } else if (sc->codec->codec_id == CODEC_ID_MPEG2VIDEO) { int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size); if (frame_type == FF_I_TYPE) { put_byte(pb, 0x0d); sc->iframes++; } else if (frame_type == FF_B_TYPE) { put_byte(pb, 0x0f); sc->bframes++; } else { put_byte(pb, 0x0e); sc->pframes++; } put_be24(pb, size); } else if (sc->codec->codec_id == CODEC_ID_DVVIDEO) { put_byte(pb, size / 4096); put_be24(pb, 0); } else put_be32(pb, size); put_be32(pb, dts); put_byte(pb, 1); /* flags */ put_byte(pb, 0); /* reserved */ return 16; }
static bool free_eraseblk(eraseblock& eb) { if ( eb.e_type == eraseblock_type::dentry_inode || eb.e_type == eraseblock_type::dentry_clin || eb.e_type == eraseblock_type::file_inode || eb.e_type == eraseblock_type::file_clin) { // The given erase block contains inodes or indirect pointers // and therefore tracks it's valid cluster count. // Set it to "free" if it doesn't contain any valid clusters. if (get_be16(eb.e_cvalid) == 0) { eb.e_type = eraseblock_type::empty; eb.e_lastwrite = put_be16(0); eb.e_writeops = put_be16(0); return true; } } else if (eb.e_type == eraseblock_type::ebin) { // TODO: implement me! log().error("Unable to free ebin erase block {}", eb); } // the given erase block cannot be freed return false; }
void close_eraseblks(fs_context& fs) { /* TODO: Error handling missing! */ for (eb_id_t eb_id = 1; eb_id < fs.neraseblocks; ++eb_id) { if (fs.eb_usage[eb_id].e_type == eraseblock_type::ebin) continue; /* can never be "open" */ if (fs.eb_usage[eb_id].e_type == eraseblock_type::empty) continue; /* can never be "open" */ eraseblock_type eb_type = fs.eb_usage[eb_id].e_type; unsigned int writeops = get_be16(fs.eb_usage[eb_id].e_writeops); unsigned int max_writeops = fs.erasesize / fs.clustersize; if (writeops == max_writeops) continue; /* erase block is already finalized/closed */ fs.eb_usage[eb_id].e_writeops = put_be16(max_writeops); if (!summary_required(fs, eb_type)) continue; summary* eb_summary = summary_get(*fs.summary_cache, eb_type); summary_write(fs, eb_summary, eb_id); summary_close(*fs.summary_cache, eb_summary); /* tell gcinfo an erase block of a specific type was written */ unsigned int write_time = gcinfo_update_writetime(fs, eb_type); fs.eb_usage[eb_id].e_lastwrite = put_be16(write_time); } }
int ff_isom_write_avcc(ByteIOContext *pb, const uint8_t *data, int len) { if (len > 6) { /* check for h264 start code */ if (AV_RB32(data) == 0x00000001 || AV_RB24(data) == 0x000001) { uint8_t *buf=NULL, *end, *start; uint32_t sps_size=0, pps_size=0; uint8_t *sps=0, *pps=0; int ret = ff_avc_parse_nal_units_buf(data, &buf, &len); if (ret < 0) return ret; start = buf; end = buf + len; /* look for sps and pps */ while (buf < end) { unsigned int size; uint8_t nal_type; size = AV_RB32(buf); nal_type = buf[4] & 0x1f; if (nal_type == 7) { /* SPS */ sps = buf + 4; sps_size = size; } else if (nal_type == 8) { /* PPS */ pps = buf + 4; pps_size = size; } buf += size + 4; } if ( !sps || !pps ) { av_log( 0, AV_LOG_ERROR, "thinkingl Can't parse h264 nal!!!\n" ); } assert(sps); assert(pps); put_byte(pb, 1); /* version */ put_byte(pb, sps[1]); /* profile */ put_byte(pb, sps[2]); /* profile compat */ put_byte(pb, sps[3]); /* level */ put_byte(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */ put_byte(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */ put_be16(pb, sps_size); put_buffer(pb, sps, sps_size); put_byte(pb, 1); /* number of pps */ put_be16(pb, pps_size); put_buffer(pb, pps, pps_size); av_free(start); } else { put_buffer(pb, data, len); } } return 0; }
static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt) { put_be16(s->pb, pkt->size); put_be16(s->pb, 0x8010); // unknown put_buffer(s->pb, pkt->data, pkt->size); put_flush_packet(s->pb); return 0; }
static int gxf_write_track_description(AVFormatContext *s, GXFStreamContext *sc, int index) { ByteIOContext *pb = s->pb; int64_t pos; int mpeg = sc->track_type == 4 || sc->track_type == 9; /* track description section */ put_byte(pb, sc->media_type + 0x80); put_byte(pb, index + 0xC0); pos = url_ftell(pb); put_be16(pb, 0); /* size */ /* media file name */ put_byte(pb, TRACK_NAME); put_byte(pb, strlen(ES_NAME_PATTERN) + 3); put_tag(pb, ES_NAME_PATTERN); put_be16(pb, sc->media_info); put_byte(pb, 0); if (!mpeg) { /* auxiliary information */ put_byte(pb, TRACK_AUX); put_byte(pb, 8); if (sc->track_type == 3) gxf_write_timecode_auxiliary(pb, sc); else put_le64(pb, 0); } /* file system version */ put_byte(pb, TRACK_VER); put_byte(pb, 4); put_be32(pb, 0); if (mpeg) gxf_write_mpeg_auxiliary(pb, s->streams[index]); /* frame rate */ put_byte(pb, TRACK_FPS); put_byte(pb, 4); put_be32(pb, sc->frame_rate_index); /* lines per frame */ put_byte(pb, TRACK_LINES); put_byte(pb, 4); put_be32(pb, sc->lines_index); /* fields per frame */ put_byte(pb, TRACK_FPF); put_byte(pb, 4); put_be32(pb, sc->fields); return updateSize(pb, pos); }
static void output_match(ByteIOContext *out, int match_sample, int match_offset, int match_len, int *entries) { put_byte(out, 2); /* sample constructor */ put_byte(out, 0); /* track reference */ put_be16(out, match_len); put_be32(out, match_sample); put_be32(out, match_offset); put_be16(out, 1); /* bytes per block */ put_be16(out, 1); /* samples per block */ (*entries)++; }
static int gxf_write_track_description(ByteIOContext *pb, GXFStreamContext *stream) { int64_t pos; /* track description section */ put_byte(pb, stream->media_type + 0x80); put_byte(pb, stream->index + 0xC0); pos = url_ftell(pb); put_be16(pb, 0); /* size */ /* media file name */ put_byte(pb, TRACK_NAME); put_byte(pb, strlen(ES_NAME_PATTERN) + 3); put_tag(pb, ES_NAME_PATTERN); put_be16(pb, stream->media_info); put_byte(pb, 0); if (stream->codec->codec_id != CODEC_ID_MPEG2VIDEO) { /* auxiliary information */ put_byte(pb, TRACK_AUX); put_byte(pb, 8); if (stream->codec->codec_id == CODEC_ID_NONE) gxf_write_timecode_auxiliary(pb, stream); else put_le64(pb, 0); } /* file system version */ put_byte(pb, TRACK_VER); put_byte(pb, 4); put_be32(pb, 0); if (stream->codec->codec_id == CODEC_ID_MPEG2VIDEO) gxf_write_mpeg_auxiliary(pb, stream); /* frame rate */ put_byte(pb, TRACK_FPS); put_byte(pb, 4); put_be32(pb, stream->frame_rate_index); /* lines per frame */ put_byte(pb, TRACK_LINES); put_byte(pb, 4); put_be32(pb, stream->lines_index); /* fields per frame */ put_byte(pb, TRACK_FPF); put_byte(pb, 4); put_be32(pb, stream->fields); return updateSize(pb, pos); }
static int gxf_write_umf_media_description(AVFormatContext *s) { GXFContext *gxf = s->priv_data; ByteIOContext *pb = s->pb; int64_t pos; int i, j; pos = url_ftell(pb); gxf->umf_media_offset = pos - gxf->umf_start_offset; for (i = 0; i <= s->nb_streams; ++i) { GXFStreamContext *sc; int64_t startpos, curpos; if (i == s->nb_streams) sc = &gxf->timecode_track; else sc = s->streams[i]->priv_data; startpos = url_ftell(pb); put_le16(pb, 0); /* length */ put_le16(pb, sc->media_info); put_le16(pb, 0); /* reserved */ put_le16(pb, 0); /* reserved */ put_le32(pb, gxf->nb_fields); put_le32(pb, 0); /* attributes rw, ro */ put_le32(pb, 0); /* mark in */ put_le32(pb, gxf->nb_fields); /* mark out */ put_buffer(pb, ES_NAME_PATTERN, strlen(ES_NAME_PATTERN)); put_be16(pb, sc->media_info); for (j = strlen(ES_NAME_PATTERN)+2; j < 88; j++) put_byte(pb, 0); put_le32(pb, sc->track_type); put_le32(pb, sc->sample_rate); put_le32(pb, sc->sample_size); put_le32(pb, 0); /* reserved */ if (sc == &gxf->timecode_track) gxf_write_umf_media_timecode(pb, sc); /* 8 0bytes */ else { AVStream *st = s->streams[i]; switch (st->codec->codec_id) { case CODEC_ID_MPEG2VIDEO: gxf_write_umf_media_mpeg(pb, st); break; case CODEC_ID_PCM_S16LE: gxf_write_umf_media_audio(pb, sc); break; case CODEC_ID_DVVIDEO: gxf_write_umf_media_dv(pb, sc); break; } } curpos = url_ftell(pb); url_fseek(pb, startpos, SEEK_SET); put_le16(pb, curpos - startpos); url_fseek(pb, curpos, SEEK_SET); } return url_ftell(pb) - pos; }
/* send an rtcp sender report packet */ static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time) { RTPMuxContext *s = s1->priv_data; uint32_t rtp_ts; #ifdef _MSC_VER AVRational rational = {1, 1000000}; #endif dprintf(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp); s->last_rtcp_ntp_time = ntp_time; #ifdef _MSC_VER rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, rational, s1->streams[0]->time_base) + s->base_timestamp; #else rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000}, s1->streams[0]->time_base) + s->base_timestamp; #endif put_byte(s1->pb, (RTP_VERSION << 6)); put_byte(s1->pb, RTCP_SR); put_be16(s1->pb, 6); /* length in words - 1 */ put_be32(s1->pb, s->ssrc); put_be32(s1->pb, ntp_time / 1000000); put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000); put_be32(s1->pb, rtp_ts); put_be32(s1->pb, s->packet_count); put_be32(s1->pb, s->octet_count); put_flush_packet(s1->pb); }
static int rso_write_trailer(AVFormatContext *s) { ByteIOContext *pb = s->pb; int64_t file_size; uint16_t coded_file_size; file_size = url_ftell(pb); if (file_size < 0) return file_size; if (file_size > 0xffff + RSO_HEADER_SIZE) { av_log(s, AV_LOG_WARNING, "Output file is too big (%"PRId64" bytes >= 64kB)\n", file_size); coded_file_size = 0xffff; } else { coded_file_size = file_size - RSO_HEADER_SIZE; } /* update file size */ url_fseek(pb, 2, SEEK_SET); put_be16(pb, coded_file_size); url_fseek(pb, file_size, SEEK_SET); put_flush_packet(pb); return 0; }
static void put_str(ByteIOContext *s, const char *tag) { put_be16(s,strlen(tag)); while (*tag) { put_byte(s, *tag++); } }
void RTMPSession::sendConnectPacket() { RTMPChunk_0 metadata = {{0}}; metadata.msg_stream_id = kControlChannelStreamId; metadata.msg_type_id = RTMP_PT_INVOKE; std::vector<uint8_t> buff; std::stringstream url ; if(m_uri.port > 0) { url << m_uri.protocol << "://" << m_uri.host << ":" << m_uri.port << "/" << m_app; } else { url << m_uri.protocol << "://" << m_uri.host << "/" << m_app; } put_string(buff, "connect"); put_double(buff, ++m_numberOfInvokes); m_trackedCommands[m_numberOfInvokes] = "connect"; put_byte(buff, kAMFObject); put_named_string(buff, "app", m_app.c_str()); put_named_string(buff,"type", "nonprivate"); put_named_string(buff, "tcUrl", url.str().c_str()); put_named_bool(buff, "fpad", false); put_named_double(buff, "capabilities", 15.); put_named_double(buff, "audioCodecs", 10. ); put_named_double(buff, "videoCodecs", 7.); put_named_double(buff, "videoFunction", 1.); put_be16(buff, 0); put_byte(buff, kAMFObjectEnd); metadata.msg_length.data = static_cast<int>( buff.size() ); sendPacket(&buff[0], buff.size(), metadata); }
int sap_connect_rsp(void *sap_device, uint8_t status) { struct sap_server *server = sap_device; struct sap_connection *conn = server->conn; char buf[SAP_BUF_SIZE]; struct sap_message *msg = (struct sap_message *) buf; struct sap_parameter *param = (struct sap_parameter *) msg->param; size_t size = sizeof(struct sap_message); if (!conn) return -EINVAL; DBG("state %d pr 0x%02x status 0x%02x", conn->state, conn->processing_req, status); if (conn->state != SAP_STATE_CONNECT_IN_PROGRESS) return -EPERM; memset(buf, 0, sizeof(buf)); msg->id = SAP_CONNECT_RESP; msg->nparam = 0x01; /* Add connection status */ param->id = SAP_PARAM_ID_CONN_STATUS; param->len = htons(SAP_PARAM_ID_CONN_STATUS_LEN); *param->val = status; size += PARAMETER_SIZE(SAP_PARAM_ID_CONN_STATUS_LEN); switch (status) { case SAP_STATUS_OK: sap_set_connected(server); break; case SAP_STATUS_OK_ONGOING_CALL: DBG("ongoing call. Wait for reset indication!"); conn->state = SAP_STATE_CONNECT_MODEM_BUSY; break; case SAP_STATUS_MAX_MSG_SIZE_NOT_SUPPORTED: /* Add MaxMsgSize */ msg->nparam++; param = (struct sap_parameter *) &buf[size]; param->id = SAP_PARAM_ID_MAX_MSG_SIZE; param->len = htons(SAP_PARAM_ID_MAX_MSG_SIZE_LEN); put_be16(SAP_BUF_SIZE, ¶m->val); size += PARAMETER_SIZE(SAP_PARAM_ID_MAX_MSG_SIZE_LEN); /* fall */ default: conn->state = SAP_STATE_DISCONNECTED; /* Timer will shutdown channel if client doesn't send * CONNECT_REQ or doesn't shutdown channel itself.*/ start_guard_timer(server, SAP_TIMER_NO_ACTIVITY); break; } conn->processing_req = SAP_NO_REQ; return send_message(conn, buf, size); }
static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size) { GXFContext *gxf = s->priv_data; ByteIOContext *pb = s->pb; AVStream *st = s->streams[pkt->stream_index]; GXFStreamContext *sc = st->priv_data; unsigned field_nb; /* If the video is frame-encoded, the frame numbers shall be represented by * even field numbers. * see SMPTE360M-2004 6.4.2.1.3 Media field number */ if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { field_nb = gxf->nb_fields; } else { field_nb = av_rescale_rnd(pkt->dts, gxf->time_base.den, (int64_t)48000*gxf->time_base.num, AV_ROUND_UP); } put_byte(pb, sc->media_type); put_byte(pb, st->index); put_be32(pb, field_nb); if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { put_be16(pb, 0); put_be16(pb, size / 2); } else if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) { int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size); if (frame_type == FF_I_TYPE) { put_byte(pb, 0x0d); sc->iframes++; } else if (frame_type == FF_B_TYPE) { put_byte(pb, 0x0f); sc->bframes++; } else { put_byte(pb, 0x0e); sc->pframes++; } put_be24(pb, size); } else if (st->codec->codec_id == CODEC_ID_DVVIDEO) { put_byte(pb, size / 4096); put_be24(pb, 0); } else put_be32(pb, size); put_be32(pb, field_nb); put_byte(pb, 1); /* flags */ put_byte(pb, 0); /* reserved */ return 16; }
static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags) { RMMuxContext *rm = s->priv_data; ByteIOContext *pb = s->pb; StreamInfo *stream = rm->video_stream; int key_frame = !!(flags & AV_PKT_FLAG_KEY); /* XXX: this is incorrect: should be a parameter */ /* Well, I spent some time finding the meaning of these bits. I am not sure I understood everything, but it works !! */ #if 1 write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame); /* bit 7: '1' if final packet of a frame converted in several packets */ put_byte(pb, 0x81); /* bit 7: '1' if I frame. bits 6..0 : sequence number in current frame starting from 1 */ if (key_frame) { put_byte(pb, 0x81); } else { put_byte(pb, 0x01); } if(size >= 0x4000){ put_be32(pb, size); /* total frame size */ put_be32(pb, size); /* offset from the start or the end */ }else{ put_be16(pb, 0x4000 | size); /* total frame size */ put_be16(pb, 0x4000 | size); /* offset from the start or the end */ } #else /* full frame */ write_packet_header(s, size + 6); put_byte(pb, 0xc0); put_be16(pb, 0x4000 + size); /* total frame size */ put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */ #endif put_byte(pb, stream->nb_frames & 0xff); put_buffer(pb, buf, size); put_flush_packet(pb); stream->nb_frames++; return 0; }
static void put_amf_string( ByteIOContext *pb, const char *str ) { LogStr("Init"); size_t len = strlen(str); put_be16(pb, len); put_buffer(pb, str, len); LogStr("Exit"); }
static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream, int length, int key_frame) { int timestamp; ByteIOContext *s = ctx->pb; stream->nb_packets++; stream->packet_total_size += length; if (length > stream->packet_max_size) stream->packet_max_size = length; put_be16(s,0); /* version */ put_be16(s,length + 12); put_be16(s, stream->num); /* stream number */ timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate; put_be32(s, timestamp); /* timestamp */ put_byte(s, 0); /* reserved */ put_byte(s, key_frame ? 2 : 0); /* flags */ }
static int64_t updateSize(ByteIOContext *pb, int64_t pos) { int64_t curpos; curpos = url_ftell(pb); url_fseek(pb, pos, SEEK_SET); put_be16(pb, curpos - pos - 2); url_fseek(pb, curpos, SEEK_SET); return curpos - pos; }
static int gxf_write_track_description_section(ByteIOContext *pb, GXFContext *ctx) { int64_t pos; int i; pos = url_ftell(pb); put_be16(pb, 0); /* size */ for (i = 0; i < ctx->fc->nb_streams; ++i) gxf_write_track_description(pb, &ctx->streams[i]); return updateSize(pb, pos); }
std::vector<uint8_t> H264Packetizer::configurationFromSpsAndPps() { std::vector<uint8_t> conf; put_byte(conf, 1); // version put_byte(conf, m_sps[1]); // profile put_byte(conf, m_sps[2]); // compat put_byte(conf, m_sps[3]); // level put_byte(conf, 0xff); // 6 bits reserved + 2 bits nal size length - 1 (11) put_byte(conf, 0xe1); // 3 bits reserved + 5 bits number of sps (00001) put_be16(conf, m_sps.size()); put_buff(conf, &m_sps[0], m_sps.size()); put_byte(conf, 1); put_be16(conf, m_pps.size()); put_buff(conf, &m_pps[0], m_pps.size()); return conf; }
void CMp4Builder::put_VideoTrackBox(AM_UINT TrackId, AM_UINT Duration) { PRINT_FUNCTION_NAME; //TrackBox put_be32(VideoTrackBox_SIZE);//uint32 size put_boxtype("trak"); //'trak' //TrackHeaderBox put_be32(TrackHeaderBox_SIZE);//uint32 size put_boxtype("tkhd"); //'tkhd' put_byte(0); //uint8 version //0x01:track_enabled, 0x02:track_in_movie, 0x04:track_in_preview put_be24(0x07); //bits24 flags //uint32 creation_time [version==0] uint64 creation_time [version==1] put_be32(_create_time); //uint32 modification_time [version==0] uint64 modification_time [version==1] put_be32(_create_time); put_be32(TrackId); //uint32 track_ID put_be32(0); //uint32 reserved //uint32 duration [version==0] uint64 duration [version==1] put_be32(Duration); put_be32(0); //uint32 reserved[2] put_be32(0); put_be16(0); //int16 layer put_be16(0); //int16 alternate_group put_be16(0x0000); //int16 volume put_be16(0); //uint16 reserved put_be32(0x00010000); //int32 matrix[9] put_be32(0); put_be32(0); put_be32(0); put_be32(0x00010000); put_be32(0); put_be32(0); put_be32(0); put_be32(0x40000000); put_be32(mH264Info.width<<16); //uint32 width //16.16 fixed-point put_be32(mH264Info.height<<16);//uint32 height //16.16 fixed-point put_VideoMediaBox(Duration); }
void RTMPSession::sendPong() { m_jobQueue.enqueue([&] { int streamId = 0; std::vector<uint8_t> buff; put_byte(buff, 2); // chunk stream ID 2 put_be24(buff, 0); // ts put_be24(buff, 6); // size (6 bytes) put_byte(buff, RTMP_PT_PING); // chunk type put_buff(buff, (uint8_t*)&streamId, sizeof(int32_t)); // msg stream id is little-endian put_be16(buff, 7); put_be16(buff, 0); put_be16(buff, 0); write(&buff[0], buff.size()); }); }
static int rso_write_header(AVFormatContext *s) { ByteIOContext *pb = s->pb; AVCodecContext *enc = s->streams[0]->codec; if (!enc->codec_tag) return AVERROR_INVALIDDATA; if (enc->channels != 1) { av_log(s, AV_LOG_ERROR, "RSO only supports mono\n"); return AVERROR_INVALIDDATA; } if (url_is_streamed(s->pb)) { av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n"); return AVERROR_INVALIDDATA; } /* XXX: find legal sample rates (if any) */ if (enc->sample_rate >= 1u<<16) { av_log(s, AV_LOG_ERROR, "Sample rate must be < 65536\n"); return AVERROR_INVALIDDATA; } if (enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) { av_log(s, AV_LOG_ERROR, "ADPCM in RSO not implemented\n"); return AVERROR_PATCHWELCOME; } /* format header */ put_be16(pb, enc->codec_tag); /* codec ID */ put_be16(pb, 0); /* data size, will be written at EOF */ put_be16(pb, enc->sample_rate); put_be16(pb, 0x0000); /* play mode ? (0x0000 = don't loop) */ put_flush_packet(pb); return 0; }
void CMp4Builder::put_AudioMediaBox() { PRINT_FUNCTION_NAME; //MediaBox put_be32(AudioMediaBox_SIZE); //uint32 size put_boxtype("mdia"); //'mdia' //MediaHeaderBox put_be32(MediaHeaderBox_SIZE); //uint32 size put_boxtype("mdhd"); //'mdhd' put_byte(0); //uint8 version put_be24(0); //bits24 flags //uint32 creation_time [version==0] uint64 creation_time [version==1] put_be32(_create_time); //uint32 modification_time [version==0] uint64 modification_time [version==1] put_be32(_create_time); //Audio's timescale is the same as Video, 90000 put_be32(mH264Info.scale); //uint32 timescale //uint32 duration [version==0] uint64 duration [version==1] put_be32(mAudioDuration); put_be16(0); //bits5 language[3] //ISO-639-2/T language code put_be16(0); //uint16 pre_defined //HandlerReferenceBox put_be32(AudioHandlerReferenceBox_SIZE); //uint32 size put_boxtype("hdlr"); //'hdlr' put_byte(0); //uint8 version put_be24(0); //bits24 flags put_be32(0); //uint32 pre_defined put_boxtype("soun"); //'soun':audio track put_be32(0); //uint32 reserved[3] put_be32(0); put_be32(0); //char name[], name[0] is actual length put_byte(AUDIO_HANDLER_NAME_LEN); put_buffer((AM_U8 *)AUDIO_HANDLER_NAME, AUDIO_HANDLER_NAME_LEN-1); put_AudioMediaInformationBox(); }
static int gxf_write_umf_media_description(ByteIOContext *pb, GXFContext *ctx) { int64_t pos; int i; pos = url_ftell(pb); ctx->umf_media_offset = pos - ctx->umf_start_offset; for (i = 0; i < ctx->fc->nb_streams; ++i) { GXFStreamContext *sc = &ctx->streams[i]; char buffer[88]; int64_t startpos, curpos; int path_size = strlen(ES_NAME_PATTERN); memset(buffer, 0, 88); startpos = url_ftell(pb); put_le16(pb, 0); /* length */ put_le16(pb, sc->media_info); put_le16(pb, 0); /* reserved */ put_le16(pb, 0); /* reserved */ put_le32(pb, ctx->nb_frames); put_le32(pb, 0); /* attributes rw, ro */ put_le32(pb, 0); /* mark in */ put_le32(pb, ctx->nb_frames); /* mark out */ strncpy(buffer, ES_NAME_PATTERN, path_size); put_buffer(pb, (uint8_t *)buffer, path_size); put_be16(pb, sc->media_info); put_buffer(pb, (uint8_t *)buffer + path_size + 2, 88 - path_size - 2); put_le32(pb, sc->track_type); put_le32(pb, sc->sample_rate); put_le32(pb, sc->sample_size); put_le32(pb, 0); /* reserved */ switch (sc->codec->codec_id) { case CODEC_ID_MPEG2VIDEO: gxf_write_umf_media_mpeg(pb, sc); break; case CODEC_ID_PCM_S16LE: gxf_write_umf_media_audio(pb, sc); break; case CODEC_ID_DVVIDEO: gxf_write_umf_media_dv(pb, sc); break; default: gxf_write_umf_media_timecode(pb, sc); /* 8 0bytes */ } curpos = url_ftell(pb); url_fseek(pb, startpos, SEEK_SET); put_le16(pb, curpos - startpos); url_fseek(pb, curpos, SEEK_SET); } return url_ftell(pb) - pos; }
void CMp4Builder::put_VideoMediaBox(AM_UINT Duration) { PRINT_FUNCTION_NAME; INFO("Video duration is %lu", mVideoDuration); //MediaBox put_be32(VideoMediaBox_SIZE); //uint32 size put_boxtype("mdia"); //'mdia' //MediaHeaderBox put_be32(MediaHeaderBox_SIZE); //uint32 size put_boxtype("mdhd"); //'mdhd' put_byte(0); //uint8 version put_be24(0); //bits24 flags //uint32 creation_time [version==0] uint64 creation_time [version==1] put_be32(_create_time); //uint32 modification_time [version==0] uint64 modification_time [version==1] put_be32(_create_time); put_be32(mH264Info.scale); //uint32 timescale //uint32 duration [version==0] uint64 duration [version==1] put_be32(Duration); put_be16(0); //bits5 language[3] //ISO-639-2/T language code put_be16(0); //uint16 pre_defined //HandlerReferenceBox put_be32(VideoHandlerReferenceBox_SIZE); //uint32 size put_boxtype("hdlr"); //'hdlr' put_byte(0); //uint8 version put_be24(0); //bits24 flags put_be32(0); //uint32 pre_defined put_boxtype("vide"); //'vide' put_be32(0); //uint32 reserved[3] put_be32(0); put_be32(0); put_byte(VIDEO_HANDLER_NAME_LEN); //char name[], name[0] is actual length put_buffer((AM_U8 *)VIDEO_HANDLER_NAME, VIDEO_HANDLER_NAME_LEN-1); put_VideoMediaInformationBox(); }
/** * Configures the device to advertise iBeacons. * * @param uuid The 128-bit UUID to advertise. * @param major The major version number to include in * iBeacons. * @param minor The minor version number to include in * iBeacons. * * @return 0 on success; * BLE_HS_EBUSY if advertising is in progress; * Other nonzero on failure. */ int ble_ibeacon_set_adv_data(void *uuid128, uint16_t major, uint16_t minor) { struct ble_hs_adv_fields fields; uint8_t buf[BLE_IBEACON_MFG_DATA_SIZE]; int8_t tx_pwr; int rc; /** Company identifier (Apple). */ buf[0] = 0x4c; buf[1] = 0x00; /** iBeacon indicator. */ buf[2] = 0x02; buf[3] = 0x15; /** UUID. */ memcpy(buf + 4, uuid128, 16); /** Version number. */ put_be16(buf + 20, major); put_be16(buf + 22, minor); /** Last byte (tx power level) filled in after HCI exchange. */ rc = ble_hs_hci_util_read_adv_tx_pwr(&tx_pwr); if (rc != 0) { return rc; } buf[24] = tx_pwr; memset(&fields, 0, sizeof fields); fields.mfg_data = buf; fields.mfg_data_len = sizeof buf; rc = ble_gap_adv_set_fields(&fields); return rc; }