Stream mjpeg using avcodec and yuv420p

src/zm_eventstream.cpp

@@ -870,14 +870,19 @@ bool EventStream::sendFrame(Microseconds delta_us) {
  }
 
  Image *send_image = prepareImage(image);
- reserveTempImgBuffer(send_image->Size());
+ int l_width = floor(send_image->Width() * scale / ZM_SCALE_BASE);
+ int l_height = floor(send_image->Height() * scale / ZM_SCALE_BASE);
+ reserveTempImgBuffer(av_image_get_buffer_size(AV_PIX_FMT_YUVJ420P, l_width, l_height, 32));
  int img_buffer_size = 0;
  uint8_t *img_buffer = temp_img_buffer;
 
  fprintf(stdout, "--" BOUNDARY "\r\n");
  switch ( type ) {
  case STREAM_JPEG :
- send_image->EncodeJpeg(img_buffer, &img_buffer_size);
+ if (mJpegCodecContext->width != l_width || mJpegCodecContext->height != l_height) {
+ initContexts(l_width, l_height);
+ }
+ send_image->EncodeJpeg(img_buffer, &img_buffer_size, mJpegCodecContext, mJpegSwsContext);
  fputs("Content-Type: image/jpeg\r\n", stdout);
  break;
  case STREAM_ZIP :

src/zm_image.cpp

@@ -1600,6 +1600,59 @@ bool Image::EncodeJpeg(JOCTET *outbuffer, int *outbuffer_size, int quality_overr
  return true;
 }
 
+bool Image::EncodeJpeg(JOCTET *outbuffer, int *outbuffer_size, AVCodecContext *p_jpegcodeccontext, SwsContext *p_jpegswscontext) const {
+ if ( config.colour_jpeg_files && (colours == ZM_COLOUR_GRAY8) ) {
+ Image temp_image(*this);
+ temp_image.Colourise(ZM_COLOUR_RGB24, ZM_SUBPIX_ORDER_RGB);
+ return temp_image.EncodeJpeg(outbuffer, outbuffer_size, p_jpegcodeccontext, p_jpegswscontext);
+ }
+
+ if (p_jpegcodeccontext == NULL) {
+ Error("Jpeg codec context is not initialized");
+ return false;
+ }
+
+ std::unique_lock<std::mutex> lck(jpeg_mutex);
+
+ av_frame_ptr frame = av_frame_ptr{zm_av_frame_alloc()};
+ AVPacket *pkt;
+
+ if (av_image_get_buffer_size(AV_PIX_FMT_YUVJ420P, width, height, 32) > Size()) {
+ Error("Output buffer not large enough");
+ return false;
+ }
+
+ if ( p_jpegswscontext ) {
+ av_frame_ptr temp_frame = av_frame_ptr{zm_av_frame_alloc()};
+ PopulateFrame(temp_frame.get());
+
+ frame.get()->width = width;
+ frame.get()->height = height;
+ frame.get()->format = AV_PIX_FMT_YUV420P;
+ av_image_fill_linesizes(frame.get()->linesize, AV_PIX_FMT_YUV420P, width);
+ av_frame_get_buffer(frame.get(), 32);
+
+ sws_scale(p_jpegswscontext, temp_frame.get()->data, temp_frame.get()->linesize, 0, height, frame.get()->data, frame.get()->linesize);
+
+ av_frame_unref(temp_frame.get());
+ } else {
+ PopulateFrame(frame.get());
+ }
+
+ pkt = av_packet_alloc();
+
+ avcodec_send_frame(p_jpegcodeccontext, frame.get());
+ if (avcodec_receive_packet(p_jpegcodeccontext, pkt) == 0) {
+ memcpy(outbuffer, pkt->data, pkt->size);
+ *outbuffer_size = pkt->size;
+ }
+
+ av_packet_free(&pkt);
+ av_frame_unref(frame.get());
+
+ return true;
+}
+
 #if HAVE_ZLIB_H
 bool Image::Unzip( const Bytef *inbuffer, unsigned long inbuffer_size ) {
  unsigned long zip_size = size;

src/zm_image.h

@@ -241,6 +241,7 @@ class Image {
 
  bool DecodeJpeg(const JOCTET *inbuffer, int inbuffer_size, unsigned int p_colours, unsigned int p_subpixelorder);
  bool EncodeJpeg(JOCTET *outbuffer, int *outbuffer_size, int quality_override=0) const;
+ bool EncodeJpeg(JOCTET *outbuffer, int *outbuffer_size, AVCodecContext *p_jpegcodeccontext, SwsContext *p_jpegswscontext) const;
 
 #if HAVE_ZLIB_H
  bool Unzip(const Bytef *inbuffer, unsigned long inbuffer_size);

src/zm_monitorstream.cpp

@@ -393,14 +393,20 @@ bool MonitorStream::sendFrame(Image *image, SystemTimePoint timestamp) {
 
  /* double pts = */ vid_stream->EncodeFrame(send_image->Buffer(), send_image->Size(), config.mpeg_timed_frames, delta_time.count());
  } else {
- reserveTempImgBuffer(send_image->Size());
+ int l_width = floor(send_image->Width() * scale / ZM_SCALE_BASE);
+ int l_height = floor(send_image->Height() * scale / ZM_SCALE_BASE);
+
+ reserveTempImgBuffer(av_image_get_buffer_size(AV_PIX_FMT_YUVJ420P, l_width, l_height, 32));
 
  int img_buffer_size = 0;
  unsigned char *img_buffer = temp_img_buffer;
 
  switch (type) {
  case STREAM_JPEG :
- send_image->EncodeJpeg(img_buffer, &img_buffer_size);
+ if (mJpegCodecContext->width != l_width || mJpegCodecContext->height != l_height) {
+ initContexts(l_width, l_height);
+ }
+ send_image->EncodeJpeg(img_buffer, &img_buffer_size, mJpegCodecContext, mJpegSwsContext);
  fputs("Content-Type: image/jpeg\r\n", stdout);
  break;
  case STREAM_RAW :
@@ -937,12 +943,12 @@ void MonitorStream::SingleImage(int scale) {
  SystemTimePoint(zm::chrono::duration_cast<Microseconds>(monitor->shared_timestamps[index])));
  }
 
- if ( scale != ZM_SCALE_BASE ) {
-  scaled_image.Assign(*snap_image);
-  scaled_image.Scale(scale);
- snap_image = &scaled_image;
+ int l_width = floor(snap_image->Width() * scale / ZM_SCALE_BASE);
+ int l_height = floor(snap_image->Height() * scale / ZM_SCALE_BASE);
+ if (mJpegCodecContext->width != l_width || mJpegCodecContext->height != l_height) {
+ initContexts(l_width, l_height);
  }
- snap_image->EncodeJpeg(img_buffer, &img_buffer_size);
+ snap_image->EncodeJpeg(img_buffer, &img_buffer_size, mJpegCodecContext, mJpegSwsContext);
 
  fprintf(stdout,
  "Content-Length: %d\r\n"

src/zm_stream.cpp

@@ -36,6 +36,61 @@ StreamBase::~StreamBase() {
  delete vid_stream;
  delete[] temp_img_buffer;
  closeComms();
+
+ if (mJpegCodecContext) {
+ avcodec_free_context(&mJpegCodecContext);
+ }
+
+ if (mJpegSwsContext) {
+ sws_freeContext(mJpegSwsContext);
+ }
+}
+
+bool StreamBase::initContexts(int p_width, int p_height) {
+ if (mJpegCodecContext) avcodec_free_context(&mJpegCodecContext);
+ if (mJpegSwsContext) sws_freeContext(mJpegSwsContext);
+
+ const AVCodec* mJpegCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
+ if (!mJpegCodec) {
+ Error("MJPEG codec not found");
+ return false;
+ }
+
+ mJpegCodecContext = avcodec_alloc_context3(mJpegCodec);
+ if (!mJpegCodecContext) {
+ Error("Could not allocate jpeg codec context");
+ return false;
+ }
+
+ mJpegCodecContext->bit_rate = 400000;
+ mJpegCodecContext->width = p_width;
+ mJpegCodecContext->height = p_height;
+ mJpegCodecContext->time_base= (AVRational) {1,25};
+ mJpegCodecContext->pix_fmt = AV_PIX_FMT_YUVJ420P;
+
+ if (avcodec_open2(mJpegCodecContext, mJpegCodec, NULL) < 0) {
+ Error("Could not open mjpeg codec");
+ return false;
+ }
+
+ AVPixelFormat format;
+ switch (monitor->Colours()) {
+ case ZM_COLOUR_RGB24:
+ format = (monitor->SubpixelOrder() == ZM_SUBPIX_ORDER_BGR ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24);
+ break;
+ case ZM_COLOUR_GRAY8:
+ format = AV_PIX_FMT_GRAY8;
+ break;
+ default:
+ format = AV_PIX_FMT_RGBA;
+ break;
+ };
+ mJpegSwsContext = sws_getContext(
+ monitor->Width(), monitor->Height(), format,
+ p_width, p_height, AV_PIX_FMT_YUV420P,
+ SWS_BICUBIC, nullptr, nullptr, nullptr);
+
+ return true;
 }
 
 bool StreamBase::loadMonitor(int p_monitor_id) {
@@ -64,7 +119,9 @@ bool StreamBase::loadMonitor(int p_monitor_id) {
  return false;
  }
 
- return true;
+ mJpegCodecContext = nullptr;
+ mJpegSwsContext = nullptr;
+ return initContexts(monitor->Width(), monitor->Height());
 }
 
 bool StreamBase::checkInitialised() {
@@ -150,9 +207,7 @@ Image *StreamBase::prepareImage(Image *image) {
 
  if (zoom != 100) {
  int base_image_width = image->Width(),
- base_image_height = image->Height(),
- disp_image_width = image->Width() * scale/ZM_SCALE_BASE,
- disp_image_height = image->Height() * scale / ZM_SCALE_BASE;
+ base_image_height = image->Height();
  /* x and y are scaled by web UI to base dimensions units.
  * When zooming, we blow up the image by the amount 150 for first zoom, right? 150%, then cut out a base sized chunk
  * However if we have zoomed before, then we are zooming into the previous cutout
@@ -229,14 +284,6 @@ Image *StreamBase::prepareImage(Image *image) {
  image_copied = true;
  }
  image->Crop(last_crop);
- image->Scale(disp_image_width, disp_image_height);
- } else if (scale != ZM_SCALE_BASE) {
- Debug(3, "scaling by %d from %dx%d", scale, image->Width(), image->Height());
- static Image copy_image;
- copy_image.Assign(*image);
- image = &copy_image;
- image_copied = true;
- image->Scale(scale);
  }
  Debug(3, "Sending %dx%d", image->Width(), image->Height());
 

src/zm_stream.h

@@ -153,6 +153,9 @@ class StreamBase {
  uint8_t *temp_img_buffer; // Used when encoding or sending file data
  size_t temp_img_buffer_size;
 
+ AVCodecContext *mJpegCodecContext;
+ SwsContext *mJpegSwsContext;
+
  protected:
  bool loadMonitor(int monitor_id);
  bool checkInitialised();
@@ -161,6 +164,7 @@ class StreamBase {
  void checkCommandQueue();
  virtual void processCommand(const CmdMsg *msg)=0;
  void reserveTempImgBuffer(size_t size);
+ bool initContexts(int p_width, int p_height);
 
  public:
  StreamBase():