+#include <arpa/inet.h>
#include <assert.h>
#include <microhttpd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/mathematics.h>
-#include <libavutil/mem.h>
-#include <libavutil/pixfmt.h>
-#include <libavutil/rational.h>
-#include <libavutil/samplefmt.h>
-}
-
#include <vector>
#include "httpd.h"
#include "defs.h"
#include "flags.h"
+#include "metacube2.h"
#include "timebase.h"
struct MHD_Connection;
using namespace std;
-HTTPD::HTTPD(int width, int height)
- : width(width), height(height)
+HTTPD::HTTPD()
{
}
MHD_OPTION_END);
}
-void HTTPD::add_packet(const AVPacket &pkt, int64_t pts, int64_t dts, PacketDestination destination)
+void HTTPD::add_data(const char *buf, size_t size, bool keyframe)
{
unique_lock<mutex> lock(streams_mutex);
- if (destination != DESTINATION_FILE_ONLY) {
- for (Stream *stream : streams) {
- stream->add_packet(pkt, pts, dts);
- }
+ for (Stream *stream : streams) {
+ stream->add_data(buf, size, keyframe ? Stream::DATA_TYPE_KEYFRAME : Stream::DATA_TYPE_OTHER);
}
- if (file_mux && destination != DESTINATION_HTTP_ONLY) {
- file_mux->add_packet(pkt, pts, dts);
- }
-}
-
-void HTTPD::open_output_file(const string &filename)
-{
- AVFormatContext *avctx = avformat_alloc_context();
- avctx->oformat = av_guess_format(NULL, filename.c_str(), NULL);
- assert(filename.size() < sizeof(avctx->filename) - 1);
- strcpy(avctx->filename, filename.c_str());
-
- string url = "file:" + filename;
- int ret = avio_open2(&avctx->pb, url.c_str(), AVIO_FLAG_WRITE, &avctx->interrupt_callback, NULL);
- if (ret < 0) {
- char tmp[AV_ERROR_MAX_STRING_SIZE];
- fprintf(stderr, "%s: avio_open2() failed: %s\n", filename.c_str(), av_make_error_string(tmp, sizeof(tmp), ret));
- exit(1);
- }
-
- file_mux.reset(new Mux(avctx, width, height, Mux::CODEC_H264, TIMEBASE));
-}
-
-void HTTPD::close_output_file()
-{
- file_mux.reset();
}
int HTTPD::answer_to_connection_thunk(void *cls, MHD_Connection *connection,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls)
{
- AVOutputFormat *oformat = av_guess_format(global_flags.stream_mux_name.c_str(), nullptr, nullptr);
- assert(oformat != nullptr);
+ // See if the URL ends in “.metacube”.
+ HTTPD::Stream::Framing framing;
+ printf("url=[%s]\n", url);
+ if (strstr(url, ".metacube") == url + strlen(url) - strlen(".metacube")) {
+ printf("metacube\n");
+ framing = HTTPD::Stream::FRAMING_METACUBE;
+ } else {
+ printf("raw\n");
+ framing = HTTPD::Stream::FRAMING_RAW;
+ }
- int time_base = global_flags.stream_coarse_timebase ? COARSE_TIMEBASE : TIMEBASE;
- HTTPD::Stream *stream = new HTTPD::Stream(oformat, width, height, time_base);
+ HTTPD::Stream *stream = new HTTPD::Stream(framing);
+ stream->add_data(header.data(), header.size(), Stream::DATA_TYPE_HEADER);
{
unique_lock<mutex> lock(streams_mutex);
streams.insert(stream);
// Does not strictly have to be equal to MUX_BUFFER_SIZE.
MHD_Response *response = MHD_create_response_from_callback(
(size_t)-1, MUX_BUFFER_SIZE, &HTTPD::Stream::reader_callback_thunk, stream, &HTTPD::free_stream);
+
+ // TODO: Content-type?
+ if (framing == HTTPD::Stream::FRAMING_METACUBE) {
+ MHD_add_response_header(response, "Content-encoding", "metacube");
+ }
int ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
//MHD_destroy_response(response);
}
}
-HTTPD::Stream::Stream(AVOutputFormat *oformat, int width, int height, int time_base)
-{
- AVFormatContext *avctx = avformat_alloc_context();
- avctx->oformat = oformat;
- uint8_t *buf = (uint8_t *)av_malloc(MUX_BUFFER_SIZE);
- avctx->pb = avio_alloc_context(buf, MUX_BUFFER_SIZE, 1, this, nullptr, &HTTPD::Stream::write_packet_thunk, nullptr);
-
- Mux::Codec video_codec;
- if (global_flags.uncompressed_video_to_http) {
- video_codec = Mux::CODEC_NV12;
- } else {
- video_codec = Mux::CODEC_H264;
- }
-
- avctx->flags = AVFMT_FLAG_CUSTOM_IO;
-
- mux.reset(new Mux(avctx, width, height, video_codec, time_base));
-}
-
ssize_t HTTPD::Stream::reader_callback_thunk(void *cls, uint64_t pos, char *buf, size_t max)
{
HTTPD::Stream *stream = (HTTPD::Stream *)cls;
return ret;
}
-void HTTPD::Stream::add_packet(const AVPacket &pkt, int64_t pts, int64_t dts)
+void HTTPD::Stream::add_data(const char *buf, size_t buf_size, HTTPD::Stream::DataType data_type)
{
- mux->add_packet(pkt, pts, dts);
-}
-
-int HTTPD::Stream::write_packet_thunk(void *opaque, uint8_t *buf, int buf_size)
-{
- HTTPD::Stream *stream = (HTTPD::Stream *)opaque;
- return stream->write_packet(buf, buf_size);
-}
+ if (buf_size == 0) {
+ return;
+ }
+ if (data_type == DATA_TYPE_KEYFRAME) {
+ seen_keyframe = true;
+ } else if (data_type == DATA_TYPE_OTHER && !seen_keyframe) {
+ // Start sending only once we see a keyframe.
+ return;
+ }
-int HTTPD::Stream::write_packet(uint8_t *buf, int buf_size)
-{
unique_lock<mutex> lock(buffer_mutex);
- buffered_data.emplace_back((char *)buf, buf_size);
+
+ if (framing == FRAMING_METACUBE) {
+ metacube2_block_header hdr;
+ memcpy(hdr.sync, METACUBE2_SYNC, sizeof(hdr.sync));
+ hdr.size = htonl(buf_size);
+ int flags = 0;
+ if (data_type == DATA_TYPE_HEADER) {
+ flags |= METACUBE_FLAGS_HEADER;
+ } else if (data_type == DATA_TYPE_OTHER) {
+ flags |= METACUBE_FLAGS_NOT_SUITABLE_FOR_STREAM_START;
+ }
+ hdr.flags = htons(flags);
+ hdr.csum = htons(metacube2_compute_crc(&hdr));
+ buffered_data.emplace_back((char *)&hdr, sizeof(hdr));
+ }
+ buffered_data.emplace_back(buf, buf_size);
has_buffered_data.notify_all();
- return buf_size;
}
projects / nageru / blobdiff