Fix servomatic build. Hopefully resolve confusion wrt linesize and

[dcpomatic.git] / src / lib / image.cc

diff --git a/src/lib/image.cc b/src/lib/image.cc
index f774f476fd707c7b02ddf00b6ca099b6c3a6ca85..73d499fe825dc8d2ac99df776e8cff35b7ad118c 100644 (file)
--- a/src/lib/image.cc
+++ b/src/lib/image.cc
@@ -42,6 +42,7 @@ extern "C" {
 
 using namespace std;
 using namespace boost;
+using libdcp::Size;
 
 void
 Image::swap (Image& other)
@@ -95,11 +96,15 @@ Image::components () const
 }
 
 shared_ptr<Image>
-Image::scale (Size out_size, Scaler const * scaler, bool aligned) const
+Image::scale (libdcp::Size out_size, Scaler const * scaler, bool result_aligned) const
 {
        assert (scaler);
+       /* Empirical testing suggests that sws_scale() will crash if
+          the input image is not aligned.
+       */
+       assert (aligned ());
 
-       shared_ptr<Image> scaled (new SimpleImage (pixel_format(), out_size, aligned));
+       shared_ptr<Image> scaled (new SimpleImage (pixel_format(), out_size, result_aligned));
 
        struct SwsContext* scale_context = sws_getContext (
                size().width, size().height, pixel_format(),
@@ -124,14 +129,18 @@ Image::scale (Size out_size, Scaler const * scaler, bool aligned) const
  *  @param scaler Scaler to use.
  */
 shared_ptr<Image>
-Image::scale_and_convert_to_rgb (Size out_size, int padding, Scaler const * scaler, bool aligned) const
+Image::scale_and_convert_to_rgb (libdcp::Size out_size, int padding, Scaler const * scaler, bool result_aligned) const
 {
        assert (scaler);
+       /* Empirical testing suggests that sws_scale() will crash if
+          the input image is not aligned.
+       */
+       assert (aligned ());
 
-       Size content_size = out_size;
+       libdcp::Size content_size = out_size;
        content_size.width -= (padding * 2);
 
-       shared_ptr<Image> rgb (new SimpleImage (PIX_FMT_RGB24, content_size, aligned));
+       shared_ptr<Image> rgb (new SimpleImage (PIX_FMT_RGB24, content_size, result_aligned));
 
        struct SwsContext* scale_context = sws_getContext (
                size().width, size().height, pixel_format(),
@@ -152,7 +161,7 @@ Image::scale_and_convert_to_rgb (Size out_size, int padding, Scaler const * scal
           scheme of things.
        */
        if (padding > 0) {
-               shared_ptr<Image> padded_rgb (new SimpleImage (PIX_FMT_RGB24, out_size, aligned));
+               shared_ptr<Image> padded_rgb (new SimpleImage (PIX_FMT_RGB24, out_size, result_aligned));
                padded_rgb->make_black ();
 
                /* XXX: we are cheating a bit here; we know the frame is RGB so we can
@@ -215,7 +224,7 @@ Image::post_process (string pp, bool aligned) const
 shared_ptr<Image>
 Image::crop (Crop crop, bool aligned) const
 {
-       Size cropped_size = size ();
+       libdcp::Size cropped_size = size ();
        cropped_size.width -= crop.left + crop.right;
        cropped_size.height -= crop.top + crop.bottom;
 
@@ -231,8 +240,8 @@ Image::crop (Crop crop, bool aligned) const
                
                for (int y = 0; y < cropped_size.height; ++y) {
                        memcpy (out_p, in_p + crop_left_in_bytes, cropped_width_in_bytes);
-                       in_p += line_size()[c];
-                       out_p += out->line_size()[c];
+                       in_p += stride()[c];
+                       out_p += out->stride()[c];
                }
        }
 
@@ -244,13 +253,25 @@ Image::make_black ()
 {
        switch (_pixel_format) {
        case PIX_FMT_YUV420P:
-       case PIX_FMT_YUV422P10LE:
        case PIX_FMT_YUV422P:
                memset (data()[0], 0, lines(0) * stride()[0]);
-               memset (data()[1], 0x80, lines(1) * stride()[1]);
-               memset (data()[2], 0x80, lines(2) * stride()[2]);
+               memset (data()[1], 0x7f, lines(1) * stride()[1]);
+               memset (data()[2], 0x7f, lines(2) * stride()[2]);
                break;
 
+       case PIX_FMT_YUV422P10LE:
+               memset (data()[0], 0, lines(0) * stride()[0]);
+               for (int i = 1; i < 3; ++i) {
+                       int16_t* p = reinterpret_cast<int16_t*> (data()[i]);
+                       for (int y = 0; y < size().height; ++y) {
+                               for (int x = 0; x < line_size()[i] / 2; ++x) {
+                                       p[x] = (1 << 9) - 1;
+                               }
+                               p += stride()[i] / 2;
+                       }
+               }
+               break;
+               
        case PIX_FMT_RGB24:             
                memset (data()[0], 0, lines(0) * stride()[0]);
                break;
@@ -302,7 +323,7 @@ Image::read_from_socket (shared_ptr<Socket> socket)
        for (int i = 0; i < components(); ++i) {
                uint8_t* p = data()[i];
                for (int y = 0; y < lines(i); ++y) {
-                       socket->read_definite_and_consume (p, line_size()[i], 30);
+                       socket->read (p, line_size()[i]);
                        p += stride()[i];
                }
        }
@@ -314,7 +335,7 @@ Image::write_to_socket (shared_ptr<Socket> socket) const
        for (int i = 0; i < components(); ++i) {
                uint8_t* p = data()[i];
                for (int y = 0; y < lines(i); ++y) {
-                       socket->write (p, line_size()[i], 30);
+                       socket->write (p, line_size()[i]);
                        p += stride()[i];
                }
        }
@@ -349,7 +370,7 @@ Image::bytes_per_pixel (int c) const
                        return 0.5;
                }
        case PIX_FMT_YUV422P10LE:
-               if (c == 1) {
+               if (c == 0) {
                        return 2;
                } else {
                        return 1;
@@ -368,7 +389,7 @@ Image::bytes_per_pixel (int c) const
  *  @param p Pixel format.
  *  @param s Size in pixels.
  */
-SimpleImage::SimpleImage (AVPixelFormat p, Size s, bool aligned)
+SimpleImage::SimpleImage (AVPixelFormat p, libdcp::Size s, bool aligned)
        : Image (p)
        , _size (s)
        , _aligned (aligned)
@@ -466,22 +487,34 @@ SimpleImage::stride () const
        return _stride;
 }
 
-Size
+libdcp::Size
 SimpleImage::size () const
 {
        return _size;
 }
 
+bool
+SimpleImage::aligned () const
+{
+       return _aligned;
+}
+
 FilterBufferImage::FilterBufferImage (AVPixelFormat p, AVFilterBufferRef* b)
        : Image (p)
        , _buffer (b)
 {
-
+       _line_size = (int *) av_malloc (4 * sizeof (int));
+       _line_size[0] = _line_size[1] = _line_size[2] = _line_size[3] = 0;
+       
+       for (int i = 0; i < components(); ++i) {
+               _line_size[i] = size().width * bytes_per_pixel(i);
+       }
 }
 
 FilterBufferImage::~FilterBufferImage ()
 {
        avfilter_unref_buffer (_buffer);
+       av_free (_line_size);
 }
 
 uint8_t **
@@ -493,20 +526,30 @@ FilterBufferImage::data () const
 int *
 FilterBufferImage::line_size () const
 {
-       return _buffer->linesize;
+       return _line_size;
 }
 
 int *
 FilterBufferImage::stride () const
 {
-       /* XXX? */
+       /* I've seen images where the _buffer->linesize is larger than the width
+          (by a small amount), suggesting that _buffer->linesize is what we call
+          stride.  But I'm not sure.
+       */
        return _buffer->linesize;
 }
 
-Size
+libdcp::Size
 FilterBufferImage::size () const
 {
-       return Size (_buffer->video->w, _buffer->video->h);
+       return libdcp::Size (_buffer->video->w, _buffer->video->h);
+}
+
+bool
+FilterBufferImage::aligned () const
+{
+       /* XXX? */
+       return true;
 }
 
 RGBPlusAlphaImage::RGBPlusAlphaImage (shared_ptr<const Image> im)