libavcodec/magicyuvenc.c

   1 /*
   2  * MagicYUV encoder
   3  * Copyright (c) 2017 Paul B Mahol
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "libavutil/cpu.h"
  26 #include "libavutil/mem.h"
  27 #include "libavutil/opt.h"
  28 #include "libavutil/pixdesc.h"
  29 #include "libavutil/qsort.h"
  30
  31 #include "avcodec.h"
  32 #include "bytestream.h"
  33 #include "codec_internal.h"
  34 #include "encode.h"
  35 #include "put_bits.h"
  36 #include "lossless_videoencdsp.h"
  37
  38 #define MAGICYUV_EXTRADATA_SIZE 32
  39
  40 typedef enum Prediction {
  41     LEFT = 1,
  42     GRADIENT,
  43     MEDIAN,
  44 } Prediction;
  45
  46 typedef struct HuffEntry {
  47     uint8_t  len;
  48     uint32_t code;
  49 } HuffEntry;
  50
  51 typedef struct PTable {
  52     int     value;  ///< input value
  53     int64_t prob;   ///< number of occurences of this value in input
  54 } PTable;
  55
  56 typedef struct Slice {
  57     unsigned pos;
  58     unsigned size;
  59     uint8_t *slice;
  60     uint8_t *bitslice;
  61     PTable counts[256];
  62 } Slice;
  63
  64 typedef struct MagicYUVContext {
  65     const AVClass       *class;
  66     int                  frame_pred;
  67     int                  planes;
  68     uint8_t              format;
  69     int                  slice_height;
  70     int                  nb_slices;
  71     int                  correlate;
  72     int                  hshift[4];
  73     int                  vshift[4];
  74     unsigned             bitslice_size;
  75     uint8_t             *decorrelate_buf[2];
  76     Slice               *slices;
  77     HuffEntry            he[4][256];
  78     LLVidEncDSPContext   llvidencdsp;
  79     void (*predict)(struct MagicYUVContext *s, const uint8_t *src, uint8_t *dst,
  80                     ptrdiff_t stride, int width, int height);
  81 } MagicYUVContext;
  82
  83 static void left_predict(MagicYUVContext *s,
  84                          const uint8_t *src, uint8_t *dst, ptrdiff_t stride,
  85                          int width, int height)
  86 {
  87     uint8_t prev = 0;
  88     int i, j;
  89
  90     for (i = 0; i < width; i++) {
  91         dst[i] = src[i] - prev;
  92         prev   = src[i];
  93     }
  94     dst += width;
  95     src += stride;
  96     for (j = 1; j < height; j++) {
  97         prev = src[-stride];
  98         for (i = 0; i < width; i++) {
  99             dst[i] = src[i] - prev;
 100             prev   = src[i];
 101         }
 102         dst += width;
 103         src += stride;
 104     }
 105 }
 106
 107 static void gradient_predict(MagicYUVContext *s,
 108                              const uint8_t *src, uint8_t *dst, ptrdiff_t stride,
 109                              int width, int height)
 110 {
 111     int left = 0, top, lefttop;
 112     int i, j;
 113
 114     for (i = 0; i < width; i++) {
 115         dst[i] = src[i] - left;
 116         left   = src[i];
 117     }
 118     dst += width;
 119     src += stride;
 120     for (j = 1; j < height; j++) {
 121         top = src[-stride];
 122         left = src[0] - top;
 123         dst[0] = left;
 124         for (i = 1; i < width; i++) {
 125             top = src[i - stride];
 126             lefttop = src[i - (stride + 1)];
 127             left = src[i-1];
 128             dst[i] = (src[i] - top) - left + lefttop;
 129         }
 130         dst += width;
 131         src += stride;
 132     }
 133 }
 134
 135 static void median_predict(MagicYUVContext *s,
 136                            const uint8_t *src, uint8_t *dst, ptrdiff_t stride,
 137                            int width, int height)
 138 {
 139     int left = 0, lefttop;
 140     int i, j;
 141
 142     for (i = 0; i < width; i++) {
 143         dst[i] = src[i] - left;
 144         left   = src[i];
 145     }
 146     dst += width;
 147     src += stride;
 148     for (j = 1; j < height; j++) {
 149         left = lefttop = src[-stride];
 150         s->llvidencdsp.sub_median_pred(dst, src - stride, src, width, &left, &lefttop);
 151         dst += width;
 152         src += stride;
 153     }
 154 }
 155
 156 static av_cold int magy_encode_init(AVCodecContext *avctx)
 157 {
 158     MagicYUVContext *s = avctx->priv_data;
 159     PutByteContext pb;
 160
 161     switch (avctx->pix_fmt) {
 162     case AV_PIX_FMT_GBRP:
 163         avctx->codec_tag = MKTAG('M', '8', 'R', 'G');
 164         s->correlate = 1;
 165         s->format = 0x65;
 166         break;
 167     case AV_PIX_FMT_GBRAP:
 168         avctx->codec_tag = MKTAG('M', '8', 'R', 'A');
 169         s->correlate = 1;
 170         s->format = 0x66;
 171         break;
 172     case AV_PIX_FMT_YUV420P:
 173         avctx->codec_tag = MKTAG('M', '8', 'Y', '0');
 174         s->hshift[1] =
 175         s->vshift[1] =
 176         s->hshift[2] =
 177         s->vshift[2] = 1;
 178         s->format = 0x69;
 179         break;
 180     case AV_PIX_FMT_YUV422P:
 181         avctx->codec_tag = MKTAG('M', '8', 'Y', '2');
 182         s->hshift[1] =
 183         s->hshift[2] = 1;
 184         s->format = 0x68;
 185         break;
 186     case AV_PIX_FMT_YUV444P:
 187         avctx->codec_tag = MKTAG('M', '8', 'Y', '4');
 188         s->format = 0x67;
 189         break;
 190     case AV_PIX_FMT_YUVA444P:
 191         avctx->codec_tag = MKTAG('M', '8', 'Y', 'A');
 192         s->format = 0x6a;
 193         break;
 194     case AV_PIX_FMT_GRAY8:
 195         avctx->codec_tag = MKTAG('M', '8', 'G', '0');
 196         s->format = 0x6b;
 197         break;
 198     }
 199
 200     ff_llvidencdsp_init(&s->llvidencdsp);
 201
 202     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
 203
 204     s->nb_slices = (avctx->slices <= 0) ? av_cpu_count() : avctx->slices;
 205     s->nb_slices = FFMIN(s->nb_slices, avctx->height >> s->vshift[1]);
 206     s->nb_slices = FFMAX(1, s->nb_slices);
 207     s->slice_height = FFALIGN((avctx->height + s->nb_slices - 1) / s->nb_slices, 1 << s->vshift[1]);
 208     s->nb_slices = (avctx->height + s->slice_height - 1) / s->slice_height;
 209     s->slices = av_calloc(s->nb_slices * s->planes, sizeof(*s->slices));
 210     if (!s->slices)
 211         return AVERROR(ENOMEM);
 212
 213     if (s->correlate) {
 214         size_t max_align = av_cpu_max_align();
 215         size_t aligned_width = FFALIGN(avctx->width, max_align);
 216         s->decorrelate_buf[0] = av_calloc(2U * (s->nb_slices * s->slice_height),
 217                                           aligned_width);
 218         if (!s->decorrelate_buf[0])
 219             return AVERROR(ENOMEM);
 220         s->decorrelate_buf[1] = s->decorrelate_buf[0] + (s->nb_slices * s->slice_height) * aligned_width;
 221     }
 222
 223     s->bitslice_size = avctx->width * s->slice_height + 2;
 224     for (int n = 0; n < s->nb_slices; n++) {
 225         for (int i = 0; i < s->planes; i++) {
 226             Slice *sl = &s->slices[n * s->planes + i];
 227
 228             sl->bitslice = av_malloc(s->bitslice_size + AV_INPUT_BUFFER_PADDING_SIZE);
 229             sl->slice = av_malloc(avctx->width * (s->slice_height + 2) +
 230                                                      AV_INPUT_BUFFER_PADDING_SIZE);
 231             if (!sl->slice || !sl->bitslice) {
 232                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer.\n");
 233                 return AVERROR(ENOMEM);
 234             }
 235         }
 236     }
 237
 238     switch (s->frame_pred) {
 239     case LEFT:     s->predict = left_predict;     break;
 240     case GRADIENT: s->predict = gradient_predict; break;
 241     case MEDIAN:   s->predict = median_predict;   break;
 242     }
 243
 244     avctx->extradata_size = MAGICYUV_EXTRADATA_SIZE;
 245
 246     avctx->extradata = av_mallocz(avctx->extradata_size +
 247                                   AV_INPUT_BUFFER_PADDING_SIZE);
 248
 249     if (!avctx->extradata) {
 250         av_log(avctx, AV_LOG_ERROR, "Could not allocate extradata.\n");
 251         return AVERROR(ENOMEM);
 252     }
 253
 254     bytestream2_init_writer(&pb, avctx->extradata, MAGICYUV_EXTRADATA_SIZE);
 255     bytestream2_put_le32(&pb, MKTAG('M', 'A', 'G', 'Y'));
 256     bytestream2_put_le32(&pb, 32);
 257     bytestream2_put_byte(&pb, 7);
 258     bytestream2_put_byte(&pb, s->format);
 259     bytestream2_put_byte(&pb, 12);
 260     bytestream2_put_byte(&pb, 0);
 261
 262     bytestream2_put_byte(&pb, 0);
 263     bytestream2_put_byte(&pb, 0);
 264     bytestream2_put_byte(&pb, 32);
 265     bytestream2_put_byte(&pb, 0);
 266
 267     bytestream2_put_le32(&pb, avctx->width);
 268     bytestream2_put_le32(&pb, avctx->height);
 269     bytestream2_put_le32(&pb, avctx->width);
 270     bytestream2_put_le32(&pb, avctx->height);
 271
 272     return 0;
 273 }
 274
 275 static void calculate_codes(HuffEntry *he, uint16_t codes_count[33])
 276 {
 277     for (unsigned i = 32, nb_codes = 0; i > 0; i--) {
 278         uint16_t curr = codes_count[i];   // # of leafs of length i
 279         codes_count[i] = nb_codes / 2;    // # of non-leaf nodes on level i
 280         nb_codes = codes_count[i] + curr; // # of nodes on level i
 281     }
 282
 283     for (unsigned i = 0; i < 256; i++) {
 284         he[i].code = codes_count[he[i].len];
 285         codes_count[he[i].len]++;
 286     }
 287 }
 288
 289 static void count_usage(const uint8_t *src, int width,
 290                         int height, PTable *counts)
 291 {
 292     for (int j = 0; j < height; j++) {
 293         for (int i = 0; i < width; i++)
 294             counts[src[i]].prob++;
 295         src += width;
 296     }
 297 }
 298
 299 typedef struct PackageMergerList {
 300     int nitems;             ///< number of items in the list and probability      ex. 4
 301     int item_idx[515];      ///< index range for each item in items                   0, 2, 5, 9, 13
 302     int probability[514];   ///< probability of each item                             3, 8, 18, 46
 303     int items[257 * 16];    ///< chain of all individual values that make up items    A, B, A, B, C, A, B, C, D, C, D, D, E
 304 } PackageMergerList;
 305
 306 static int compare_by_prob(const void *a, const void *b)
 307 {
 308     const PTable *a2 = a;
 309     const PTable *b2 = b;
 310     return a2->prob - b2->prob;
 311 }
 312
 313 static void magy_huffman_compute_bits(PTable *prob_table, HuffEntry *distincts,
 314                                       uint16_t codes_counts[33],
 315                                       int size, int max_length)
 316 {
 317     PackageMergerList list_a, list_b, *to = &list_a, *from = &list_b, *temp;
 318     int times, i, j, k;
 319     int nbits[257] = {0};
 320     int min;
 321
 322     av_assert0(max_length > 0);
 323
 324     to->nitems = 0;
 325     from->nitems = 0;
 326     to->item_idx[0] = 0;
 327     from->item_idx[0] = 0;
 328     AV_QSORT(prob_table, size, PTable, compare_by_prob);
 329
 330     for (times = 0; times <= max_length; times++) {
 331         to->nitems = 0;
 332         to->item_idx[0] = 0;
 333
 334         j = 0;
 335         k = 0;
 336
 337         if (times < max_length) {
 338             i = 0;
 339         }
 340         while (i < size || j + 1 < from->nitems) {
 341             to->nitems++;
 342             to->item_idx[to->nitems] = to->item_idx[to->nitems - 1];
 343             if (i < size &&
 344                 (j + 1 >= from->nitems ||
 345                  prob_table[i].prob <
 346                      from->probability[j] + from->probability[j + 1])) {
 347                 to->items[to->item_idx[to->nitems]++] = prob_table[i].value;
 348                 to->probability[to->nitems - 1] = prob_table[i].prob;
 349                 i++;
 350             } else {
 351                 for (k = from->item_idx[j]; k < from->item_idx[j + 2]; k++) {
 352                     to->items[to->item_idx[to->nitems]++] = from->items[k];
 353                 }
 354                 to->probability[to->nitems - 1] =
 355                     from->probability[j] + from->probability[j + 1];
 356                 j += 2;
 357             }
 358         }
 359         temp = to;
 360         to = from;
 361         from = temp;
 362     }
 363
 364     min = (size - 1 < from->nitems) ? size - 1 : from->nitems;
 365     for (i = 0; i < from->item_idx[min]; i++) {
 366         nbits[from->items[i]]++;
 367     }
 368
 369     for (i = 0; i < size; i++) {
 370         distincts[i].len = nbits[i];
 371         codes_counts[nbits[i]]++;
 372     }
 373 }
 374
 375 static int count_plane_slice(AVCodecContext *avctx, int n, int plane)
 376 {
 377     MagicYUVContext *s = avctx->priv_data;
 378     Slice *sl = &s->slices[n * s->planes + plane];
 379     const uint8_t *dst = sl->slice;
 380     PTable *counts = sl->counts;
 381     const int slice_height = s->slice_height;
 382     const int last_height = FFMIN(slice_height, avctx->height - n * slice_height);
 383     const int height = (n < (s->nb_slices - 1)) ? slice_height : last_height;
 384
 385     memset(counts, 0, sizeof(sl->counts));
 386
 387     count_usage(dst, AV_CEIL_RSHIFT(avctx->width, s->hshift[plane]),
 388                 AV_CEIL_RSHIFT(height, s->vshift[plane]), counts);
 389
 390     return 0;
 391 }
 392
 393 static int encode_table(AVCodecContext *avctx,
 394                         PutBitContext *pb, HuffEntry *he, int plane)
 395 {
 396     MagicYUVContext *s = avctx->priv_data;
 397     PTable counts[256] = { {0} };
 398     uint16_t codes_counts[33] = { 0 };
 399
 400     for (int n = 0; n < s->nb_slices; n++) {
 401         Slice *sl = &s->slices[n * s->planes + plane];
 402         PTable *slice_counts = sl->counts;
 403
 404         for (int i = 0; i < 256; i++)
 405             counts[i].prob = slice_counts[i].prob;
 406     }
 407
 408     for (int i = 0; i < 256; i++) {
 409         counts[i].prob++;
 410         counts[i].value = i;
 411     }
 412
 413     magy_huffman_compute_bits(counts, he, codes_counts, 256, 12);
 414
 415     calculate_codes(he, codes_counts);
 416
 417     for (int i = 0; i < 256; i++) {
 418         put_bits(pb, 1, 0);
 419         put_bits(pb, 7, he[i].len);
 420     }
 421
 422     return 0;
 423 }
 424
 425 static int encode_plane_slice_raw(const uint8_t *src, uint8_t *dst, unsigned dst_size,
 426                                   int width, int height, int prediction)
 427 {
 428     unsigned count = width * height;
 429
 430     dst[0] = 1;
 431     dst[1] = prediction;
 432
 433     memcpy(dst + 2, src, count);
 434     count += 2;
 435     AV_WN32(dst + count, 0);
 436     if (count & 3)
 437         count += 4 - (count & 3);
 438
 439     return count;
 440 }
 441
 442 static int encode_plane_slice(const uint8_t *src, uint8_t *dst, unsigned dst_size,
 443                               int width, int height, HuffEntry *he, int prediction)
 444 {
 445     const uint8_t *osrc = src;
 446     PutBitContext pb;
 447     int count;
 448
 449     init_put_bits(&pb, dst, dst_size);
 450
 451     put_bits(&pb, 8, 0);
 452     put_bits(&pb, 8, prediction);
 453
 454     for (int j = 0; j < height; j++) {
 455         for (int i = 0; i < width; i++) {
 456             const int idx = src[i];
 457             const int len = he[idx].len;
 458             if (put_bits_left(&pb) < len + 32)
 459                 return encode_plane_slice_raw(osrc, dst, dst_size, width, height, prediction);
 460             put_bits(&pb, len, he[idx].code);
 461         }
 462
 463         src += width;
 464     }
 465
 466     count = put_bits_count(&pb) & 0x1F;
 467
 468     if (count)
 469         put_bits(&pb, 32 - count, 0);
 470
 471     flush_put_bits(&pb);
 472
 473     return put_bytes_output(&pb);
 474 }
 475
 476 static int encode_slice(AVCodecContext *avctx, void *tdata,
 477                         int n, int threadnr)
 478 {
 479     MagicYUVContext *s = avctx->priv_data;
 480     const int slice_height = s->slice_height;
 481     const int last_height = FFMIN(slice_height, avctx->height - n * slice_height);
 482     const int height = (n < (s->nb_slices - 1)) ? slice_height : last_height;
 483
 484     for (int i = 0; i < s->planes; i++) {
 485         Slice *sl = &s->slices[n * s->planes + i];
 486
 487         sl->size =
 488             encode_plane_slice(sl->slice,
 489                                sl->bitslice,
 490                                s->bitslice_size,
 491                                AV_CEIL_RSHIFT(avctx->width, s->hshift[i]),
 492                                AV_CEIL_RSHIFT(height, s->vshift[i]),
 493                                s->he[i], s->frame_pred);
 494     }
 495
 496     return 0;
 497 }
 498
 499 static int predict_slice(AVCodecContext *avctx, void *tdata,
 500                          int n, int threadnr)
 501 {
 502     size_t max_align = av_cpu_max_align();
 503     const int aligned_width = FFALIGN(avctx->width, max_align);
 504     MagicYUVContext *s = avctx->priv_data;
 505     const int slice_height = s->slice_height;
 506     const int last_height = FFMIN(slice_height, avctx->height - n * slice_height);
 507     const int height = (n < (s->nb_slices - 1)) ? slice_height : last_height;
 508     const int width = avctx->width;
 509     AVFrame *frame = tdata;
 510
 511     if (s->correlate) {
 512         uint8_t *decorrelated[2] = { s->decorrelate_buf[0] + n * slice_height * aligned_width,
 513                                      s->decorrelate_buf[1] + n * slice_height * aligned_width };
 514         const int decorrelate_linesize = aligned_width;
 515         const uint8_t *const data[4] = { decorrelated[0], frame->data[0] + n * slice_height * frame->linesize[0],
 516                                          decorrelated[1], s->planes == 4 ? frame->data[3] + n * slice_height * frame->linesize[3] : NULL };
 517         const uint8_t *r, *g, *b;
 518         const int linesize[4]  = { decorrelate_linesize, frame->linesize[0],
 519                                    decorrelate_linesize, frame->linesize[3] };
 520
 521         g = frame->data[0] + n * slice_height * frame->linesize[0];
 522         b = frame->data[1] + n * slice_height * frame->linesize[1];
 523         r = frame->data[2] + n * slice_height * frame->linesize[2];
 524
 525         for (int i = 0; i < height; i++) {
 526             s->llvidencdsp.diff_bytes(decorrelated[0], b, g, width);
 527             s->llvidencdsp.diff_bytes(decorrelated[1], r, g, width);
 528             g += frame->linesize[0];
 529             b += frame->linesize[1];
 530             r += frame->linesize[2];
 531             decorrelated[0] += decorrelate_linesize;
 532             decorrelated[1] += decorrelate_linesize;
 533         }
 534
 535         for (int i = 0; i < s->planes; i++) {
 536             Slice *sl = &s->slices[n * s->planes + i];
 537
 538             s->predict(s, data[i], sl->slice, linesize[i],
 539                        frame->width, height);
 540         }
 541     } else {
 542         for (int i = 0; i < s->planes; i++) {
 543             Slice *sl = &s->slices[n * s->planes + i];
 544
 545             s->predict(s, frame->data[i] + n * (slice_height >> s->vshift[i]) * frame->linesize[i],
 546                        sl->slice,
 547                        frame->linesize[i],
 548                        AV_CEIL_RSHIFT(frame->width, s->hshift[i]),
 549                        AV_CEIL_RSHIFT(height, s->vshift[i]));
 550         }
 551     }
 552
 553     for (int p = 0; p < s->planes; p++)
 554         count_plane_slice(avctx, n, p);
 555
 556     return 0;
 557 }
 558
 559 static int magy_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 560                              const AVFrame *frame, int *got_packet)
 561 {
 562     MagicYUVContext *s = avctx->priv_data;
 563     const int width = avctx->width, height = avctx->height;
 564     const int slice_height = s->slice_height;
 565     unsigned tables_size;
 566     PutBitContext pbit;
 567     PutByteContext pb;
 568     int pos, ret = 0;
 569
 570     ret = ff_alloc_packet(avctx, pkt, (256 + 4 * s->nb_slices + width * height) *
 571                           s->planes + 256);
 572     if (ret < 0)
 573         return ret;
 574
 575     bytestream2_init_writer(&pb, pkt->data, pkt->size);
 576     bytestream2_put_le32(&pb, MKTAG('M', 'A', 'G', 'Y'));
 577     bytestream2_put_le32(&pb, 32); // header size
 578     bytestream2_put_byte(&pb, 7);  // version
 579     bytestream2_put_byte(&pb, s->format);
 580     bytestream2_put_byte(&pb, 12); // max huffman length
 581     bytestream2_put_byte(&pb, 0);
 582
 583     bytestream2_put_byte(&pb, 0);
 584     bytestream2_put_byte(&pb, 0);
 585     bytestream2_put_byte(&pb, 32); // coder type
 586     bytestream2_put_byte(&pb, 0);
 587
 588     bytestream2_put_le32(&pb, avctx->width);
 589     bytestream2_put_le32(&pb, avctx->height);
 590     bytestream2_put_le32(&pb, avctx->width);
 591     bytestream2_put_le32(&pb, slice_height);
 592     bytestream2_put_le32(&pb, 0);
 593
 594     for (int i = 0; i < s->planes; i++) {
 595         bytestream2_put_le32(&pb, 0);
 596         for (int j = 1; j < s->nb_slices; j++)
 597             bytestream2_put_le32(&pb, 0);
 598     }
 599
 600     bytestream2_put_byte(&pb, s->planes);
 601
 602     for (int i = 0; i < s->planes; i++) {
 603         for (int n = 0; n < s->nb_slices; n++)
 604             bytestream2_put_byte(&pb, n * s->planes + i);
 605     }
 606
 607     avctx->execute2(avctx, predict_slice, (void *)frame, NULL, s->nb_slices);
 608
 609     init_put_bits(&pbit, pkt->data + bytestream2_tell_p(&pb), bytestream2_get_bytes_left_p(&pb));
 610
 611     for (int i = 0; i < s->planes; i++)
 612         encode_table(avctx, &pbit, s->he[i], i);
 613
 614     tables_size = put_bytes_count(&pbit, 1);
 615     bytestream2_skip_p(&pb, tables_size);
 616
 617     avctx->execute2(avctx, encode_slice, NULL, NULL, s->nb_slices);
 618
 619     for (int n = 0; n < s->nb_slices; n++) {
 620         for (int i = 0; i < s->planes; i++) {
 621             Slice *sl = &s->slices[n * s->planes + i];
 622
 623             sl->pos = bytestream2_tell_p(&pb);
 624
 625             bytestream2_put_buffer(&pb, sl->bitslice, sl->size);
 626         }
 627     }
 628
 629     pos = bytestream2_tell_p(&pb);
 630     bytestream2_seek_p(&pb, 32, SEEK_SET);
 631     bytestream2_put_le32(&pb, s->slices[0].pos - 32);
 632     for (int i = 0; i < s->planes; i++) {
 633         for (int n = 0; n < s->nb_slices; n++) {
 634             Slice *sl = &s->slices[n * s->planes + i];
 635
 636             bytestream2_put_le32(&pb, sl->pos - 32);
 637         }
 638     }
 639     bytestream2_seek_p(&pb, pos, SEEK_SET);
 640
 641     pkt->size   = bytestream2_tell_p(&pb);
 642
 643     *got_packet = 1;
 644
 645     return 0;
 646 }
 647
 648 static av_cold int magy_encode_close(AVCodecContext *avctx)
 649 {
 650     MagicYUVContext *s = avctx->priv_data;
 651
 652     for (int i = 0; i < s->planes * s->nb_slices && s->slices; i++) {
 653         Slice *sl = &s->slices[i];
 654
 655         av_freep(&sl->slice);
 656         av_freep(&sl->bitslice);
 657     }
 658     av_freep(&s->slices);
 659     av_freep(&s->decorrelate_buf);
 660
 661     return 0;
 662 }
 663
 664 #define OFFSET(x) offsetof(MagicYUVContext, x)
 665 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 666 static const AVOption options[] = {
 667     { "pred", "Prediction method", OFFSET(frame_pred), AV_OPT_TYPE_INT, {.i64=LEFT}, LEFT, MEDIAN, VE, .unit = "pred" },
 668     { "left",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT },     0, 0, VE, .unit = "pred" },
 669     { "gradient", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = GRADIENT }, 0, 0, VE, .unit = "pred" },
 670     { "median",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN },   0, 0, VE, .unit = "pred" },
 671     { NULL},
 672 };
 673
 674 static const AVClass magicyuv_class = {
 675     .class_name = "magicyuv",
 676     .item_name  = av_default_item_name,
 677     .option     = options,
 678     .version    = LIBAVUTIL_VERSION_INT,
 679 };
 680
 681 const FFCodec ff_magicyuv_encoder = {
 682     .p.name           = "magicyuv",
 683     CODEC_LONG_NAME("MagicYUV video"),
 684     .p.type           = AVMEDIA_TYPE_VIDEO,
 685     .p.id             = AV_CODEC_ID_MAGICYUV,
 686     .p.capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
 687                         AV_CODEC_CAP_SLICE_THREADS |
 688                         AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
 689     .priv_data_size   = sizeof(MagicYUVContext),
 690     .p.priv_class     = &magicyuv_class,
 691     .init             = magy_encode_init,
 692     .close            = magy_encode_close,
 693     FF_CODEC_ENCODE_CB(magy_encode_frame),
 694     .p.pix_fmts       = (const enum AVPixelFormat[]) {
 695                           AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_YUV422P,
 696                           AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_GRAY8,
 697                           AV_PIX_FMT_NONE
 698                       },
 699     .color_ranges     = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
 700     .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
 701 };