git.sesse.net Git - nageru/blob - httpd.cpp

   1 #include <string.h>
   2 #include <microhttpd.h>
   3 #include <assert.h>
   4
   5 extern "C" {
   6 #include <libavcodec/avcodec.h>
   7 }
   8
   9 #include "httpd.h"
  10 #include "timebase.h"
  11
  12 using namespace std;
  13
  14 HTTPD::HTTPD() {}
  15
  16 void HTTPD::start(int port)
  17 {
  18         MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_POLL_INTERNALLY | MHD_USE_DUAL_STACK,
  19                          port,
  20                          nullptr, nullptr,
  21                          &answer_to_connection_thunk, this, MHD_OPTION_END);
  22 }
  23
  24 void HTTPD::add_packet(const AVPacket &pkt)
  25 {
  26         for (Stream *stream : streams) {
  27                 stream->add_packet(pkt);
  28         }
  29 }
  30
  31 int HTTPD::answer_to_connection_thunk(void *cls, MHD_Connection *connection,
  32                                       const char *url, const char *method,
  33                                       const char *version, const char *upload_data,
  34                                       size_t *upload_data_size, void **con_cls)
  35 {
  36         HTTPD *httpd = (HTTPD *)cls;
  37         return httpd->answer_to_connection(connection, url, method, version, upload_data, upload_data_size, con_cls);
  38 }
  39
  40 int HTTPD::answer_to_connection(MHD_Connection *connection,
  41                                 const char *url, const char *method,
  42                                 const char *version, const char *upload_data,
  43                                 size_t *upload_data_size, void **con_cls)
  44 {
  45         printf("url %s\n", url);
  46         AVOutputFormat *oformat = av_guess_format("mpegts", nullptr, nullptr);
  47         assert(oformat != nullptr);
  48         HTTPD::Stream *stream = new HTTPD::Stream(oformat);
  49         streams.push_back(stream);
  50         MHD_Response *response = MHD_create_response_from_callback(
  51                 (size_t)-1, 1048576, &HTTPD::Stream::reader_callback_thunk, stream, &HTTPD::free_stream);
  52         int ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
  53         //MHD_destroy_response(response);
  54
  55         return ret;
  56 }
  57
  58 void HTTPD::free_stream(void *cls)
  59 {
  60         HTTPD::Stream *stream = (HTTPD::Stream *)cls;
  61         delete stream;
  62 }
  63
  64 HTTPD::Stream::Stream(AVOutputFormat *oformat)
  65 {
  66         avctx = avformat_alloc_context();
  67         avctx->oformat = oformat;
  68         uint8_t *buf = (uint8_t *)av_malloc(1048576);
  69         avctx->pb = avio_alloc_context(buf, 1048576, 1, this, nullptr, &HTTPD::Stream::write_packet_thunk, nullptr);
  70         avctx->flags = AVFMT_FLAG_CUSTOM_IO;
  71
  72         // TODO: Unify with the code in h264encoder.cpp.
  73         AVCodec *codec_video = avcodec_find_encoder(AV_CODEC_ID_H264);
  74         avstream_video = avformat_new_stream(avctx, codec_video);
  75         if (avstream_video == nullptr) {
  76                 fprintf(stderr, "avformat_new_stream() failed\n");
  77                 exit(1);
  78         }
  79         avstream_video->time_base = AVRational{1, TIMEBASE};
  80         avstream_video->codec->width = 1280;  // FIXME
  81         avstream_video->codec->height = 720;  // FIXME
  82         avstream_video->codec->time_base = AVRational{1, TIMEBASE};
  83         avstream_video->codec->ticks_per_frame = 1;  // or 2?
  84
  85         AVCodec *codec_audio = avcodec_find_encoder(AV_CODEC_ID_MP3);
  86         avstream_audio = avformat_new_stream(avctx, codec_audio);
  87         if (avstream_audio == nullptr) {
  88                 fprintf(stderr, "avformat_new_stream() failed\n");
  89                 exit(1);
  90         }
  91         avstream_audio->time_base = AVRational{1, TIMEBASE};
  92         avstream_audio->codec->bit_rate = 256000;
  93         avstream_audio->codec->sample_rate = 48000;
  94         avstream_audio->codec->sample_fmt = AV_SAMPLE_FMT_FLTP;
  95         avstream_audio->codec->channels = 2;
  96         avstream_audio->codec->channel_layout = AV_CH_LAYOUT_STEREO;
  97         avstream_audio->codec->time_base = AVRational{1, TIMEBASE};
  98
  99         if (avformat_write_header(avctx, NULL) < 0) {
 100                 fprintf(stderr, "avformat_write_header() failed\n");
 101                 exit(1);
 102         }
 103 }
 104
 105 HTTPD::Stream::~Stream()
 106 {
 107         avformat_free_context(avctx);
 108 }
 109
 110 ssize_t HTTPD::Stream::reader_callback_thunk(void *cls, uint64_t pos, char *buf, size_t max)
 111 {
 112         HTTPD::Stream *stream = (HTTPD::Stream *)cls;
 113         return stream->reader_callback(pos, buf, max);
 114 }
 115
 116 ssize_t HTTPD::Stream::reader_callback(uint64_t pos, char *buf, size_t max)
 117 {
 118         unique_lock<mutex> lock(buffer_mutex);
 119         has_buffered_data.wait(lock, [this]{ return !buffered_data.empty(); });
 120
 121         ssize_t ret = 0;
 122         while (max > 0 && !buffered_data.empty()) {
 123                 const string &s = buffered_data.front();
 124                 assert(s.size() > used_of_buffered_data);
 125                 size_t len = s.size() - used_of_buffered_data;
 126                 if (max >= len) {
 127                         // Consume the entire (rest of the) string.
 128                         memcpy(buf, s.data() + used_of_buffered_data, len);
 129                         ret += len;
 130                         max -= len;
 131                         buffered_data.pop_front();
 132                         used_of_buffered_data = 0;
 133                 } else {
 134                         // We don't need the entire string; just use the first part of it.
 135                         memcpy(buf, s.data() + used_of_buffered_data, max);
 136                         used_of_buffered_data += max;
 137                         ret += max;
 138                         max = 0;
 139                 }
 140         }
 141
 142         return ret;
 143 }
 144
 145 void HTTPD::Stream::add_packet(const AVPacket &pkt)
 146 {
 147         AVPacket pkt_copy;
 148         av_copy_packet(&pkt_copy, &pkt);
 149         if (pkt.stream_index == 0) {
 150                 pkt_copy.pts = av_rescale_q(pkt.pts, AVRational{1, TIMEBASE}, avstream_video->time_base);
 151                 pkt_copy.dts = av_rescale_q(pkt.dts, AVRational{1, TIMEBASE}, avstream_video->time_base);
 152         } else if (pkt.stream_index == 1) {
 153                 pkt_copy.pts = av_rescale_q(pkt.pts, AVRational{1, TIMEBASE}, avstream_audio->time_base);
 154                 pkt_copy.dts = av_rescale_q(pkt.dts, AVRational{1, TIMEBASE}, avstream_audio->time_base);
 155         } else {
 156                 assert(false);
 157         }
 158
 159         if (av_interleaved_write_frame(avctx, &pkt_copy) < 0) {
 160                 fprintf(stderr, "av_interleaved_write_frame() failed\n");
 161                 exit(1);
 162         }
 163 }
 164
 165 int HTTPD::Stream::write_packet_thunk(void *opaque, uint8_t *buf, int buf_size)
 166 {
 167         HTTPD::Stream *stream = (HTTPD::Stream *)opaque;
 168         return stream->write_packet(buf, buf_size);
 169 }
 170
 171 int HTTPD::Stream::write_packet(uint8_t *buf, int buf_size)
 172 {
 173         unique_lock<mutex> lock(buffer_mutex);
 174         buffered_data.emplace_back((char *)buf, buf_size);
 175         has_buffered_data.notify_all();
 176         return buf_size;
 177 }
 178